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.172 2007/08/30 16:30:27 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 if( argc>=1 ){ 1020 iMin = sqlite3_value_int(argv[0]); 1021 if( iMin<0 ) iMin = 0; 1022 if( iMin>=sizeof(zBuf) ) iMin = sizeof(zBuf)-1; 1023 }else{ 1024 iMin = 1; 1025 } 1026 if( argc>=2 ){ 1027 iMax = sqlite3_value_int(argv[1]); 1028 if( iMax<iMin ) iMax = iMin; 1029 if( iMax>=sizeof(zBuf) ) iMax = sizeof(zBuf)-1; 1030 }else{ 1031 iMax = 50; 1032 } 1033 n = iMin; 1034 if( iMax>iMin ){ 1035 sqlite3Randomness(sizeof(r), &r); 1036 r &= 0x7fffffff; 1037 n += r%(iMax + 1 - iMin); 1038 } 1039 assert( n<sizeof(zBuf) ); 1040 sqlite3Randomness(n, zBuf); 1041 for(i=0; i<n; i++){ 1042 zBuf[i] = zSrc[zBuf[i]%(sizeof(zSrc)-1)]; 1043 } 1044 zBuf[n] = 0; 1045 sqlite3_result_text(context, (char*)zBuf, n, SQLITE_TRANSIENT); 1046 } 1047 #endif /* SQLITE_TEST */ 1048 1049 #ifdef SQLITE_TEST 1050 /* 1051 ** The following two SQL functions are used to test returning a text 1052 ** result with a destructor. Function 'test_destructor' takes one argument 1053 ** and returns the same argument interpreted as TEXT. A destructor is 1054 ** passed with the sqlite3_result_text() call. 1055 ** 1056 ** SQL function 'test_destructor_count' returns the number of outstanding 1057 ** allocations made by 'test_destructor'; 1058 ** 1059 ** WARNING: Not threadsafe. 1060 */ 1061 static int test_destructor_count_var = 0; 1062 static void destructor(void *p){ 1063 char *zVal = (char *)p; 1064 assert(zVal); 1065 zVal--; 1066 sqlite3_free(zVal); 1067 test_destructor_count_var--; 1068 } 1069 static void test_destructor( 1070 sqlite3_context *pCtx, 1071 int nArg, 1072 sqlite3_value **argv 1073 ){ 1074 char *zVal; 1075 int len; 1076 sqlite3 *db = sqlite3_user_data(pCtx); 1077 1078 test_destructor_count_var++; 1079 assert( nArg==1 ); 1080 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 1081 len = sqlite3ValueBytes(argv[0], ENC(db)); 1082 zVal = contextMalloc(pCtx, len+3); 1083 if( !zVal ){ 1084 return; 1085 } 1086 zVal[len+1] = 0; 1087 zVal[len+2] = 0; 1088 zVal++; 1089 memcpy(zVal, sqlite3ValueText(argv[0], ENC(db)), len); 1090 if( ENC(db)==SQLITE_UTF8 ){ 1091 sqlite3_result_text(pCtx, zVal, -1, destructor); 1092 #ifndef SQLITE_OMIT_UTF16 1093 }else if( ENC(db)==SQLITE_UTF16LE ){ 1094 sqlite3_result_text16le(pCtx, zVal, -1, destructor); 1095 }else{ 1096 sqlite3_result_text16be(pCtx, zVal, -1, destructor); 1097 #endif /* SQLITE_OMIT_UTF16 */ 1098 } 1099 } 1100 static void test_destructor_count( 1101 sqlite3_context *pCtx, 1102 int nArg, 1103 sqlite3_value **argv 1104 ){ 1105 sqlite3_result_int(pCtx, test_destructor_count_var); 1106 } 1107 #endif /* SQLITE_TEST */ 1108 1109 #ifdef SQLITE_TEST 1110 /* 1111 ** Routines for testing the sqlite3_get_auxdata() and sqlite3_set_auxdata() 1112 ** interface. 1113 ** 1114 ** The test_auxdata() SQL function attempts to register each of its arguments 1115 ** as auxiliary data. If there are no prior registrations of aux data for 1116 ** that argument (meaning the argument is not a constant or this is its first 1117 ** call) then the result for that argument is 0. If there is a prior 1118 ** registration, the result for that argument is 1. The overall result 1119 ** is the individual argument results separated by spaces. 1120 */ 1121 static void free_test_auxdata(void *p) {sqlite3_free(p);} 1122 static void test_auxdata( 1123 sqlite3_context *pCtx, 1124 int nArg, 1125 sqlite3_value **argv 1126 ){ 1127 int i; 1128 char *zRet = contextMalloc(pCtx, nArg*2); 1129 if( !zRet ) return; 1130 memset(zRet, 0, nArg*2); 1131 for(i=0; i<nArg; i++){ 1132 char const *z = (char*)sqlite3_value_text(argv[i]); 1133 if( z ){ 1134 char *zAux = sqlite3_get_auxdata(pCtx, i); 1135 if( zAux ){ 1136 zRet[i*2] = '1'; 1137 if( strcmp(zAux, z) ){ 1138 free_test_auxdata((void *)zRet); 1139 sqlite3_result_error(pCtx, "Auxilary data corruption", -1); 1140 return; 1141 } 1142 }else{ 1143 zRet[i*2] = '0'; 1144 zAux = contextMalloc(pCtx, strlen(z)+1); 1145 if( zAux ){ 1146 strcpy(zAux, z); 1147 sqlite3_set_auxdata(pCtx, i, zAux, free_test_auxdata); 1148 } 1149 } 1150 zRet[i*2+1] = ' '; 1151 } 1152 } 1153 sqlite3_result_text(pCtx, zRet, 2*nArg-1, free_test_auxdata); 1154 } 1155 #endif /* SQLITE_TEST */ 1156 1157 #ifdef SQLITE_TEST 1158 /* 1159 ** A function to test error reporting from user functions. This function 1160 ** returns a copy of it's first argument as an error. 1161 */ 1162 static void test_error( 1163 sqlite3_context *pCtx, 1164 int nArg, 1165 sqlite3_value **argv 1166 ){ 1167 sqlite3_result_error(pCtx, (char*)sqlite3_value_text(argv[0]), 0); 1168 } 1169 #endif /* SQLITE_TEST */ 1170 1171 /* 1172 ** An instance of the following structure holds the context of a 1173 ** sum() or avg() aggregate computation. 1174 */ 1175 typedef struct SumCtx SumCtx; 1176 struct SumCtx { 1177 double rSum; /* Floating point sum */ 1178 i64 iSum; /* Integer sum */ 1179 i64 cnt; /* Number of elements summed */ 1180 u8 overflow; /* True if integer overflow seen */ 1181 u8 approx; /* True if non-integer value was input to the sum */ 1182 }; 1183 1184 /* 1185 ** Routines used to compute the sum, average, and total. 1186 ** 1187 ** The SUM() function follows the (broken) SQL standard which means 1188 ** that it returns NULL if it sums over no inputs. TOTAL returns 1189 ** 0.0 in that case. In addition, TOTAL always returns a float where 1190 ** SUM might return an integer if it never encounters a floating point 1191 ** value. TOTAL never fails, but SUM might through an exception if 1192 ** it overflows an integer. 1193 */ 1194 static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){ 1195 SumCtx *p; 1196 int type; 1197 assert( argc==1 ); 1198 p = sqlite3_aggregate_context(context, sizeof(*p)); 1199 type = sqlite3_value_numeric_type(argv[0]); 1200 if( p && type!=SQLITE_NULL ){ 1201 p->cnt++; 1202 if( type==SQLITE_INTEGER ){ 1203 i64 v = sqlite3_value_int64(argv[0]); 1204 p->rSum += v; 1205 if( (p->approx|p->overflow)==0 ){ 1206 i64 iNewSum = p->iSum + v; 1207 int s1 = p->iSum >> (sizeof(i64)*8-1); 1208 int s2 = v >> (sizeof(i64)*8-1); 1209 int s3 = iNewSum >> (sizeof(i64)*8-1); 1210 p->overflow = (s1&s2&~s3) | (~s1&~s2&s3); 1211 p->iSum = iNewSum; 1212 } 1213 }else{ 1214 p->rSum += sqlite3_value_double(argv[0]); 1215 p->approx = 1; 1216 } 1217 } 1218 } 1219 static void sumFinalize(sqlite3_context *context){ 1220 SumCtx *p; 1221 p = sqlite3_aggregate_context(context, 0); 1222 if( p && p->cnt>0 ){ 1223 if( p->overflow ){ 1224 sqlite3_result_error(context,"integer overflow",-1); 1225 }else if( p->approx ){ 1226 sqlite3_result_double(context, p->rSum); 1227 }else{ 1228 sqlite3_result_int64(context, p->iSum); 1229 } 1230 } 1231 } 1232 static void avgFinalize(sqlite3_context *context){ 1233 SumCtx *p; 1234 p = sqlite3_aggregate_context(context, 0); 1235 if( p && p->cnt>0 ){ 1236 sqlite3_result_double(context, p->rSum/(double)p->cnt); 1237 } 1238 } 1239 static void totalFinalize(sqlite3_context *context){ 1240 SumCtx *p; 1241 p = sqlite3_aggregate_context(context, 0); 1242 sqlite3_result_double(context, p ? p->rSum : 0.0); 1243 } 1244 1245 /* 1246 ** The following structure keeps track of state information for the 1247 ** count() aggregate function. 1248 */ 1249 typedef struct CountCtx CountCtx; 1250 struct CountCtx { 1251 i64 n; 1252 }; 1253 1254 /* 1255 ** Routines to implement the count() aggregate function. 1256 */ 1257 static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){ 1258 CountCtx *p; 1259 p = sqlite3_aggregate_context(context, sizeof(*p)); 1260 if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){ 1261 p->n++; 1262 } 1263 } 1264 static void countFinalize(sqlite3_context *context){ 1265 CountCtx *p; 1266 p = sqlite3_aggregate_context(context, 0); 1267 sqlite3_result_int64(context, p ? p->n : 0); 1268 } 1269 1270 /* 1271 ** Routines to implement min() and max() aggregate functions. 1272 */ 1273 static void minmaxStep(sqlite3_context *context, int argc, sqlite3_value **argv){ 1274 Mem *pArg = (Mem *)argv[0]; 1275 Mem *pBest; 1276 1277 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 1278 pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest)); 1279 if( !pBest ) return; 1280 1281 if( pBest->flags ){ 1282 int max; 1283 int cmp; 1284 CollSeq *pColl = sqlite3GetFuncCollSeq(context); 1285 /* This step function is used for both the min() and max() aggregates, 1286 ** the only difference between the two being that the sense of the 1287 ** comparison is inverted. For the max() aggregate, the 1288 ** sqlite3_user_data() function returns (void *)-1. For min() it 1289 ** returns (void *)db, where db is the sqlite3* database pointer. 1290 ** Therefore the next statement sets variable 'max' to 1 for the max() 1291 ** aggregate, or 0 for min(). 1292 */ 1293 max = sqlite3_user_data(context)!=0; 1294 cmp = sqlite3MemCompare(pBest, pArg, pColl); 1295 if( (max && cmp<0) || (!max && cmp>0) ){ 1296 sqlite3VdbeMemCopy(pBest, pArg); 1297 } 1298 }else{ 1299 sqlite3VdbeMemCopy(pBest, pArg); 1300 } 1301 } 1302 static void minMaxFinalize(sqlite3_context *context){ 1303 sqlite3_value *pRes; 1304 pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0); 1305 if( pRes ){ 1306 if( pRes->flags ){ 1307 sqlite3_result_value(context, pRes); 1308 } 1309 sqlite3VdbeMemRelease(pRes); 1310 } 1311 } 1312 1313 1314 /* 1315 ** This function registered all of the above C functions as SQL 1316 ** functions. This should be the only routine in this file with 1317 ** external linkage. 1318 */ 1319 void sqlite3RegisterBuiltinFunctions(sqlite3 *db){ 1320 static const struct { 1321 char *zName; 1322 signed char nArg; 1323 u8 argType; /* ff: db 1: 0, 2: 1, 3: 2,... N: N-1. */ 1324 u8 eTextRep; /* 1: UTF-16. 0: UTF-8 */ 1325 u8 needCollSeq; 1326 void (*xFunc)(sqlite3_context*,int,sqlite3_value **); 1327 } aFuncs[] = { 1328 { "min", -1, 0, SQLITE_UTF8, 1, minmaxFunc }, 1329 { "min", 0, 0, SQLITE_UTF8, 1, 0 }, 1330 { "max", -1, 1, SQLITE_UTF8, 1, minmaxFunc }, 1331 { "max", 0, 1, SQLITE_UTF8, 1, 0 }, 1332 { "typeof", 1, 0, SQLITE_UTF8, 0, typeofFunc }, 1333 { "length", 1, 0, SQLITE_UTF8, 0, lengthFunc }, 1334 { "substr", 3, 0, SQLITE_UTF8, 0, substrFunc }, 1335 { "abs", 1, 0, SQLITE_UTF8, 0, absFunc }, 1336 { "round", 1, 0, SQLITE_UTF8, 0, roundFunc }, 1337 { "round", 2, 0, SQLITE_UTF8, 0, roundFunc }, 1338 { "upper", 1, 0, SQLITE_UTF8, 0, upperFunc }, 1339 { "lower", 1, 0, SQLITE_UTF8, 0, lowerFunc }, 1340 { "coalesce", -1, 0, SQLITE_UTF8, 0, ifnullFunc }, 1341 { "coalesce", 0, 0, SQLITE_UTF8, 0, 0 }, 1342 { "coalesce", 1, 0, SQLITE_UTF8, 0, 0 }, 1343 { "hex", 1, 0, SQLITE_UTF8, 0, hexFunc }, 1344 { "ifnull", 2, 0, SQLITE_UTF8, 1, ifnullFunc }, 1345 { "random", -1, 0, SQLITE_UTF8, 0, randomFunc }, 1346 { "randomblob", 1, 0, SQLITE_UTF8, 0, randomBlob }, 1347 { "nullif", 2, 0, SQLITE_UTF8, 1, nullifFunc }, 1348 { "sqlite_version", 0, 0, SQLITE_UTF8, 0, versionFunc}, 1349 { "quote", 1, 0, SQLITE_UTF8, 0, quoteFunc }, 1350 { "last_insert_rowid", 0, 0xff, SQLITE_UTF8, 0, last_insert_rowid }, 1351 { "changes", 0, 0xff, SQLITE_UTF8, 0, changes }, 1352 { "total_changes", 0, 0xff, SQLITE_UTF8, 0, total_changes }, 1353 { "replace", 3, 0, SQLITE_UTF8, 0, replaceFunc }, 1354 { "ltrim", 1, 1, SQLITE_UTF8, 0, trimFunc }, 1355 { "ltrim", 2, 1, SQLITE_UTF8, 0, trimFunc }, 1356 { "rtrim", 1, 2, SQLITE_UTF8, 0, trimFunc }, 1357 { "rtrim", 2, 2, SQLITE_UTF8, 0, trimFunc }, 1358 { "trim", 1, 3, SQLITE_UTF8, 0, trimFunc }, 1359 { "trim", 2, 3, SQLITE_UTF8, 0, trimFunc }, 1360 { "zeroblob", 1, 0, SQLITE_UTF8, 0, zeroblobFunc }, 1361 #ifdef SQLITE_SOUNDEX 1362 { "soundex", 1, 0, SQLITE_UTF8, 0, soundexFunc}, 1363 #endif 1364 #ifndef SQLITE_OMIT_LOAD_EXTENSION 1365 { "load_extension", 1, 0xff, SQLITE_UTF8, 0, loadExt }, 1366 { "load_extension", 2, 0xff, SQLITE_UTF8, 0, loadExt }, 1367 #endif 1368 #ifdef SQLITE_TEST 1369 { "randstr", 2, 0, SQLITE_UTF8, 0, randStr }, 1370 { "test_destructor", 1, 0xff, SQLITE_UTF8, 0, test_destructor}, 1371 { "test_destructor_count", 0, 0, SQLITE_UTF8, 0, test_destructor_count}, 1372 { "test_auxdata", -1, 0, SQLITE_UTF8, 0, test_auxdata}, 1373 { "test_error", 1, 0, SQLITE_UTF8, 0, test_error}, 1374 #endif 1375 }; 1376 static const struct { 1377 char *zName; 1378 signed char nArg; 1379 u8 argType; 1380 u8 needCollSeq; 1381 void (*xStep)(sqlite3_context*,int,sqlite3_value**); 1382 void (*xFinalize)(sqlite3_context*); 1383 } aAggs[] = { 1384 { "min", 1, 0, 1, minmaxStep, minMaxFinalize }, 1385 { "max", 1, 1, 1, minmaxStep, minMaxFinalize }, 1386 { "sum", 1, 0, 0, sumStep, sumFinalize }, 1387 { "total", 1, 0, 0, sumStep, totalFinalize }, 1388 { "avg", 1, 0, 0, sumStep, avgFinalize }, 1389 { "count", 0, 0, 0, countStep, countFinalize }, 1390 { "count", 1, 0, 0, countStep, countFinalize }, 1391 }; 1392 int i; 1393 1394 for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){ 1395 void *pArg; 1396 u8 argType = aFuncs[i].argType; 1397 if( argType==0xff ){ 1398 pArg = db; 1399 }else{ 1400 pArg = (void*)(int)argType; 1401 } 1402 sqlite3CreateFunc(db, aFuncs[i].zName, aFuncs[i].nArg, 1403 aFuncs[i].eTextRep, pArg, aFuncs[i].xFunc, 0, 0); 1404 if( aFuncs[i].needCollSeq ){ 1405 FuncDef *pFunc = sqlite3FindFunction(db, aFuncs[i].zName, 1406 strlen(aFuncs[i].zName), aFuncs[i].nArg, aFuncs[i].eTextRep, 0); 1407 if( pFunc && aFuncs[i].needCollSeq ){ 1408 pFunc->needCollSeq = 1; 1409 } 1410 } 1411 } 1412 #ifndef SQLITE_OMIT_ALTERTABLE 1413 sqlite3AlterFunctions(db); 1414 #endif 1415 #ifndef SQLITE_OMIT_PARSER 1416 sqlite3AttachFunctions(db); 1417 #endif 1418 for(i=0; i<sizeof(aAggs)/sizeof(aAggs[0]); i++){ 1419 void *pArg = (void*)(int)aAggs[i].argType; 1420 sqlite3CreateFunc(db, aAggs[i].zName, aAggs[i].nArg, SQLITE_UTF8, 1421 pArg, 0, aAggs[i].xStep, aAggs[i].xFinalize); 1422 if( aAggs[i].needCollSeq ){ 1423 FuncDef *pFunc = sqlite3FindFunction( db, aAggs[i].zName, 1424 strlen(aAggs[i].zName), aAggs[i].nArg, SQLITE_UTF8, 0); 1425 if( pFunc && aAggs[i].needCollSeq ){ 1426 pFunc->needCollSeq = 1; 1427 } 1428 } 1429 } 1430 sqlite3RegisterDateTimeFunctions(db); 1431 if( !db->mallocFailed ){ 1432 int rc = sqlite3_overload_function(db, "MATCH", 2); 1433 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK ); 1434 if( rc==SQLITE_NOMEM ){ 1435 db->mallocFailed = 1; 1436 } 1437 } 1438 #ifdef SQLITE_SSE 1439 (void)sqlite3SseFunctions(db); 1440 #endif 1441 #ifdef SQLITE_CASE_SENSITIVE_LIKE 1442 sqlite3RegisterLikeFunctions(db, 1); 1443 #else 1444 sqlite3RegisterLikeFunctions(db, 0); 1445 #endif 1446 } 1447 1448 /* 1449 ** Set the LIKEOPT flag on the 2-argument function with the given name. 1450 */ 1451 static void setLikeOptFlag(sqlite3 *db, const char *zName, int flagVal){ 1452 FuncDef *pDef; 1453 pDef = sqlite3FindFunction(db, zName, strlen(zName), 2, SQLITE_UTF8, 0); 1454 if( pDef ){ 1455 pDef->flags = flagVal; 1456 } 1457 } 1458 1459 /* 1460 ** Register the built-in LIKE and GLOB functions. The caseSensitive 1461 ** parameter determines whether or not the LIKE operator is case 1462 ** sensitive. GLOB is always case sensitive. 1463 */ 1464 void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){ 1465 struct compareInfo *pInfo; 1466 if( caseSensitive ){ 1467 pInfo = (struct compareInfo*)&likeInfoAlt; 1468 }else{ 1469 pInfo = (struct compareInfo*)&likeInfoNorm; 1470 } 1471 sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0); 1472 sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0); 1473 sqlite3CreateFunc(db, "glob", 2, SQLITE_UTF8, 1474 (struct compareInfo*)&globInfo, likeFunc, 0,0); 1475 setLikeOptFlag(db, "glob", SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE); 1476 setLikeOptFlag(db, "like", 1477 caseSensitive ? (SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE) : SQLITE_FUNC_LIKE); 1478 } 1479 1480 /* 1481 ** pExpr points to an expression which implements a function. If 1482 ** it is appropriate to apply the LIKE optimization to that function 1483 ** then set aWc[0] through aWc[2] to the wildcard characters and 1484 ** return TRUE. If the function is not a LIKE-style function then 1485 ** return FALSE. 1486 */ 1487 int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){ 1488 FuncDef *pDef; 1489 if( pExpr->op!=TK_FUNCTION || !pExpr->pList ){ 1490 return 0; 1491 } 1492 if( pExpr->pList->nExpr!=2 ){ 1493 return 0; 1494 } 1495 pDef = sqlite3FindFunction(db, (char*)pExpr->token.z, pExpr->token.n, 2, 1496 SQLITE_UTF8, 0); 1497 if( pDef==0 || (pDef->flags & SQLITE_FUNC_LIKE)==0 ){ 1498 return 0; 1499 } 1500 1501 /* The memcpy() statement assumes that the wildcard characters are 1502 ** the first three statements in the compareInfo structure. The 1503 ** asserts() that follow verify that assumption 1504 */ 1505 memcpy(aWc, pDef->pUserData, 3); 1506 assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll ); 1507 assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne ); 1508 assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet ); 1509 *pIsNocase = (pDef->flags & SQLITE_FUNC_CASE)==0; 1510 return 1; 1511 } 1512