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