Merge Chromium + Blink git repositories
[chromium-blink-merge.git] / third_party / sqlite / sqlite-src-3080704 / src / func.c
blobcf556e2439d944f85d955f862e6b8c78a7384a2d
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.
11 *************************************************************************
12 ** This file contains the C-language implementations for many of the SQL
13 ** functions of SQLite. (Some function, and in particular the date and
14 ** time functions, are implemented separately.)
16 #include "sqliteInt.h"
17 #include <stdlib.h>
18 #include <assert.h>
19 #include "vdbeInt.h"
22 ** Return the collating function associated with a function.
24 static CollSeq *sqlite3GetFuncCollSeq(sqlite3_context *context){
25 VdbeOp *pOp = &context->pVdbe->aOp[context->iOp-1];
26 assert( pOp->opcode==OP_CollSeq );
27 assert( pOp->p4type==P4_COLLSEQ );
28 return pOp->p4.pColl;
32 ** Indicate that the accumulator load should be skipped on this
33 ** iteration of the aggregate loop.
35 static void sqlite3SkipAccumulatorLoad(sqlite3_context *context){
36 context->skipFlag = 1;
40 ** Implementation of the non-aggregate min() and max() functions
42 static void minmaxFunc(
43 sqlite3_context *context,
44 int argc,
45 sqlite3_value **argv
47 int i;
48 int mask; /* 0 for min() or 0xffffffff for max() */
49 int iBest;
50 CollSeq *pColl;
52 assert( argc>1 );
53 mask = sqlite3_user_data(context)==0 ? 0 : -1;
54 pColl = sqlite3GetFuncCollSeq(context);
55 assert( pColl );
56 assert( mask==-1 || mask==0 );
57 iBest = 0;
58 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
59 for(i=1; i<argc; i++){
60 if( sqlite3_value_type(argv[i])==SQLITE_NULL ) return;
61 if( (sqlite3MemCompare(argv[iBest], argv[i], pColl)^mask)>=0 ){
62 testcase( mask==0 );
63 iBest = i;
66 sqlite3_result_value(context, argv[iBest]);
70 ** Return the type of the argument.
72 static void typeofFunc(
73 sqlite3_context *context,
74 int NotUsed,
75 sqlite3_value **argv
77 const char *z = 0;
78 UNUSED_PARAMETER(NotUsed);
79 switch( sqlite3_value_type(argv[0]) ){
80 case SQLITE_INTEGER: z = "integer"; break;
81 case SQLITE_TEXT: z = "text"; break;
82 case SQLITE_FLOAT: z = "real"; break;
83 case SQLITE_BLOB: z = "blob"; break;
84 default: z = "null"; break;
86 sqlite3_result_text(context, z, -1, SQLITE_STATIC);
91 ** Implementation of the length() function
93 static void lengthFunc(
94 sqlite3_context *context,
95 int argc,
96 sqlite3_value **argv
98 int len;
100 assert( argc==1 );
101 UNUSED_PARAMETER(argc);
102 switch( sqlite3_value_type(argv[0]) ){
103 case SQLITE_BLOB:
104 case SQLITE_INTEGER:
105 case SQLITE_FLOAT: {
106 sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
107 break;
109 case SQLITE_TEXT: {
110 const unsigned char *z = sqlite3_value_text(argv[0]);
111 if( z==0 ) return;
112 len = 0;
113 while( *z ){
114 len++;
115 SQLITE_SKIP_UTF8(z);
117 sqlite3_result_int(context, len);
118 break;
120 default: {
121 sqlite3_result_null(context);
122 break;
128 ** Implementation of the abs() function.
130 ** IMP: R-23979-26855 The abs(X) function returns the absolute value of
131 ** the numeric argument X.
133 static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
134 assert( argc==1 );
135 UNUSED_PARAMETER(argc);
136 switch( sqlite3_value_type(argv[0]) ){
137 case SQLITE_INTEGER: {
138 i64 iVal = sqlite3_value_int64(argv[0]);
139 if( iVal<0 ){
140 if( iVal==SMALLEST_INT64 ){
141 /* IMP: R-31676-45509 If X is the integer -9223372036854775808
142 ** then abs(X) throws an integer overflow error since there is no
143 ** equivalent positive 64-bit two complement value. */
144 sqlite3_result_error(context, "integer overflow", -1);
145 return;
147 iVal = -iVal;
149 sqlite3_result_int64(context, iVal);
150 break;
152 case SQLITE_NULL: {
153 /* IMP: R-37434-19929 Abs(X) returns NULL if X is NULL. */
154 sqlite3_result_null(context);
155 break;
157 default: {
158 /* Because sqlite3_value_double() returns 0.0 if the argument is not
159 ** something that can be converted into a number, we have:
160 ** IMP: R-57326-31541 Abs(X) return 0.0 if X is a string or blob that
161 ** cannot be converted to a numeric value.
163 double rVal = sqlite3_value_double(argv[0]);
164 if( rVal<0 ) rVal = -rVal;
165 sqlite3_result_double(context, rVal);
166 break;
172 ** Implementation of the instr() function.
174 ** instr(haystack,needle) finds the first occurrence of needle
175 ** in haystack and returns the number of previous characters plus 1,
176 ** or 0 if needle does not occur within haystack.
178 ** If both haystack and needle are BLOBs, then the result is one more than
179 ** the number of bytes in haystack prior to the first occurrence of needle,
180 ** or 0 if needle never occurs in haystack.
182 static void instrFunc(
183 sqlite3_context *context,
184 int argc,
185 sqlite3_value **argv
187 const unsigned char *zHaystack;
188 const unsigned char *zNeedle;
189 int nHaystack;
190 int nNeedle;
191 int typeHaystack, typeNeedle;
192 int N = 1;
193 int isText;
195 UNUSED_PARAMETER(argc);
196 typeHaystack = sqlite3_value_type(argv[0]);
197 typeNeedle = sqlite3_value_type(argv[1]);
198 if( typeHaystack==SQLITE_NULL || typeNeedle==SQLITE_NULL ) return;
199 nHaystack = sqlite3_value_bytes(argv[0]);
200 nNeedle = sqlite3_value_bytes(argv[1]);
201 if( typeHaystack==SQLITE_BLOB && typeNeedle==SQLITE_BLOB ){
202 zHaystack = sqlite3_value_blob(argv[0]);
203 zNeedle = sqlite3_value_blob(argv[1]);
204 isText = 0;
205 }else{
206 zHaystack = sqlite3_value_text(argv[0]);
207 zNeedle = sqlite3_value_text(argv[1]);
208 isText = 1;
210 while( nNeedle<=nHaystack && memcmp(zHaystack, zNeedle, nNeedle)!=0 ){
211 N++;
213 nHaystack--;
214 zHaystack++;
215 }while( isText && (zHaystack[0]&0xc0)==0x80 );
217 if( nNeedle>nHaystack ) N = 0;
218 sqlite3_result_int(context, N);
222 ** Implementation of the printf() function.
224 static void printfFunc(
225 sqlite3_context *context,
226 int argc,
227 sqlite3_value **argv
229 PrintfArguments x;
230 StrAccum str;
231 const char *zFormat;
232 int n;
234 if( argc>=1 && (zFormat = (const char*)sqlite3_value_text(argv[0]))!=0 ){
235 x.nArg = argc-1;
236 x.nUsed = 0;
237 x.apArg = argv+1;
238 sqlite3StrAccumInit(&str, 0, 0, SQLITE_MAX_LENGTH);
239 str.db = sqlite3_context_db_handle(context);
240 sqlite3XPrintf(&str, SQLITE_PRINTF_SQLFUNC, zFormat, &x);
241 n = str.nChar;
242 sqlite3_result_text(context, sqlite3StrAccumFinish(&str), n,
243 SQLITE_DYNAMIC);
248 ** Implementation of the substr() function.
250 ** substr(x,p1,p2) returns p2 characters of x[] beginning with p1.
251 ** p1 is 1-indexed. So substr(x,1,1) returns the first character
252 ** of x. If x is text, then we actually count UTF-8 characters.
253 ** If x is a blob, then we count bytes.
255 ** If p1 is negative, then we begin abs(p1) from the end of x[].
257 ** If p2 is negative, return the p2 characters preceding p1.
259 static void substrFunc(
260 sqlite3_context *context,
261 int argc,
262 sqlite3_value **argv
264 const unsigned char *z;
265 const unsigned char *z2;
266 int len;
267 int p0type;
268 i64 p1, p2;
269 int negP2 = 0;
271 assert( argc==3 || argc==2 );
272 if( sqlite3_value_type(argv[1])==SQLITE_NULL
273 || (argc==3 && sqlite3_value_type(argv[2])==SQLITE_NULL)
275 return;
277 p0type = sqlite3_value_type(argv[0]);
278 p1 = sqlite3_value_int(argv[1]);
279 if( p0type==SQLITE_BLOB ){
280 len = sqlite3_value_bytes(argv[0]);
281 z = sqlite3_value_blob(argv[0]);
282 if( z==0 ) return;
283 assert( len==sqlite3_value_bytes(argv[0]) );
284 }else{
285 z = sqlite3_value_text(argv[0]);
286 if( z==0 ) return;
287 len = 0;
288 if( p1<0 ){
289 for(z2=z; *z2; len++){
290 SQLITE_SKIP_UTF8(z2);
294 if( argc==3 ){
295 p2 = sqlite3_value_int(argv[2]);
296 if( p2<0 ){
297 p2 = -p2;
298 negP2 = 1;
300 }else{
301 p2 = sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH];
303 if( p1<0 ){
304 p1 += len;
305 if( p1<0 ){
306 p2 += p1;
307 if( p2<0 ) p2 = 0;
308 p1 = 0;
310 }else if( p1>0 ){
311 p1--;
312 }else if( p2>0 ){
313 p2--;
315 if( negP2 ){
316 p1 -= p2;
317 if( p1<0 ){
318 p2 += p1;
319 p1 = 0;
322 assert( p1>=0 && p2>=0 );
323 if( p0type!=SQLITE_BLOB ){
324 while( *z && p1 ){
325 SQLITE_SKIP_UTF8(z);
326 p1--;
328 for(z2=z; *z2 && p2; p2--){
329 SQLITE_SKIP_UTF8(z2);
331 sqlite3_result_text64(context, (char*)z, z2-z, SQLITE_TRANSIENT,
332 SQLITE_UTF8);
333 }else{
334 if( p1+p2>len ){
335 p2 = len-p1;
336 if( p2<0 ) p2 = 0;
338 sqlite3_result_blob64(context, (char*)&z[p1], (u64)p2, SQLITE_TRANSIENT);
343 ** Implementation of the round() function
345 #ifndef SQLITE_OMIT_FLOATING_POINT
346 static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
347 int n = 0;
348 double r;
349 char *zBuf;
350 assert( argc==1 || argc==2 );
351 if( argc==2 ){
352 if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return;
353 n = sqlite3_value_int(argv[1]);
354 if( n>30 ) n = 30;
355 if( n<0 ) n = 0;
357 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
358 r = sqlite3_value_double(argv[0]);
359 /* If Y==0 and X will fit in a 64-bit int,
360 ** handle the rounding directly,
361 ** otherwise use printf.
363 if( n==0 && r>=0 && r<LARGEST_INT64-1 ){
364 r = (double)((sqlite_int64)(r+0.5));
365 }else if( n==0 && r<0 && (-r)<LARGEST_INT64-1 ){
366 r = -(double)((sqlite_int64)((-r)+0.5));
367 }else{
368 zBuf = sqlite3_mprintf("%.*f",n,r);
369 if( zBuf==0 ){
370 sqlite3_result_error_nomem(context);
371 return;
373 sqlite3AtoF(zBuf, &r, sqlite3Strlen30(zBuf), SQLITE_UTF8);
374 sqlite3_free(zBuf);
376 sqlite3_result_double(context, r);
378 #endif
381 ** Allocate nByte bytes of space using sqlite3_malloc(). If the
382 ** allocation fails, call sqlite3_result_error_nomem() to notify
383 ** the database handle that malloc() has failed and return NULL.
384 ** If nByte is larger than the maximum string or blob length, then
385 ** raise an SQLITE_TOOBIG exception and return NULL.
387 static void *contextMalloc(sqlite3_context *context, i64 nByte){
388 char *z;
389 sqlite3 *db = sqlite3_context_db_handle(context);
390 assert( nByte>0 );
391 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] );
392 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
393 if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
394 sqlite3_result_error_toobig(context);
395 z = 0;
396 }else{
397 z = sqlite3Malloc(nByte);
398 if( !z ){
399 sqlite3_result_error_nomem(context);
402 return z;
406 ** Implementation of the upper() and lower() SQL functions.
408 static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
409 char *z1;
410 const char *z2;
411 int i, n;
412 UNUSED_PARAMETER(argc);
413 z2 = (char*)sqlite3_value_text(argv[0]);
414 n = sqlite3_value_bytes(argv[0]);
415 /* Verify that the call to _bytes() does not invalidate the _text() pointer */
416 assert( z2==(char*)sqlite3_value_text(argv[0]) );
417 if( z2 ){
418 z1 = contextMalloc(context, ((i64)n)+1);
419 if( z1 ){
420 for(i=0; i<n; i++){
421 z1[i] = (char)sqlite3Toupper(z2[i]);
423 sqlite3_result_text(context, z1, n, sqlite3_free);
427 static void lowerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
428 char *z1;
429 const char *z2;
430 int i, n;
431 UNUSED_PARAMETER(argc);
432 z2 = (char*)sqlite3_value_text(argv[0]);
433 n = sqlite3_value_bytes(argv[0]);
434 /* Verify that the call to _bytes() does not invalidate the _text() pointer */
435 assert( z2==(char*)sqlite3_value_text(argv[0]) );
436 if( z2 ){
437 z1 = contextMalloc(context, ((i64)n)+1);
438 if( z1 ){
439 for(i=0; i<n; i++){
440 z1[i] = sqlite3Tolower(z2[i]);
442 sqlite3_result_text(context, z1, n, sqlite3_free);
448 ** Some functions like COALESCE() and IFNULL() and UNLIKELY() are implemented
449 ** as VDBE code so that unused argument values do not have to be computed.
450 ** However, we still need some kind of function implementation for this
451 ** routines in the function table. The noopFunc macro provides this.
452 ** noopFunc will never be called so it doesn't matter what the implementation
453 ** is. We might as well use the "version()" function as a substitute.
455 #define noopFunc versionFunc /* Substitute function - never called */
458 ** Implementation of random(). Return a random integer.
460 static void randomFunc(
461 sqlite3_context *context,
462 int NotUsed,
463 sqlite3_value **NotUsed2
465 sqlite_int64 r;
466 UNUSED_PARAMETER2(NotUsed, NotUsed2);
467 sqlite3_randomness(sizeof(r), &r);
468 if( r<0 ){
469 /* We need to prevent a random number of 0x8000000000000000
470 ** (or -9223372036854775808) since when you do abs() of that
471 ** number of you get the same value back again. To do this
472 ** in a way that is testable, mask the sign bit off of negative
473 ** values, resulting in a positive value. Then take the
474 ** 2s complement of that positive value. The end result can
475 ** therefore be no less than -9223372036854775807.
477 r = -(r & LARGEST_INT64);
479 sqlite3_result_int64(context, r);
483 ** Implementation of randomblob(N). Return a random blob
484 ** that is N bytes long.
486 static void randomBlob(
487 sqlite3_context *context,
488 int argc,
489 sqlite3_value **argv
491 int n;
492 unsigned char *p;
493 assert( argc==1 );
494 UNUSED_PARAMETER(argc);
495 n = sqlite3_value_int(argv[0]);
496 if( n<1 ){
497 n = 1;
499 p = contextMalloc(context, n);
500 if( p ){
501 sqlite3_randomness(n, p);
502 sqlite3_result_blob(context, (char*)p, n, sqlite3_free);
507 ** Implementation of the last_insert_rowid() SQL function. The return
508 ** value is the same as the sqlite3_last_insert_rowid() API function.
510 static void last_insert_rowid(
511 sqlite3_context *context,
512 int NotUsed,
513 sqlite3_value **NotUsed2
515 sqlite3 *db = sqlite3_context_db_handle(context);
516 UNUSED_PARAMETER2(NotUsed, NotUsed2);
517 /* IMP: R-51513-12026 The last_insert_rowid() SQL function is a
518 ** wrapper around the sqlite3_last_insert_rowid() C/C++ interface
519 ** function. */
520 sqlite3_result_int64(context, sqlite3_last_insert_rowid(db));
524 ** Implementation of the changes() SQL function.
526 ** IMP: R-62073-11209 The changes() SQL function is a wrapper
527 ** around the sqlite3_changes() C/C++ function and hence follows the same
528 ** rules for counting changes.
530 static void changes(
531 sqlite3_context *context,
532 int NotUsed,
533 sqlite3_value **NotUsed2
535 sqlite3 *db = sqlite3_context_db_handle(context);
536 UNUSED_PARAMETER2(NotUsed, NotUsed2);
537 sqlite3_result_int(context, sqlite3_changes(db));
541 ** Implementation of the total_changes() SQL function. The return value is
542 ** the same as the sqlite3_total_changes() API function.
544 static void total_changes(
545 sqlite3_context *context,
546 int NotUsed,
547 sqlite3_value **NotUsed2
549 sqlite3 *db = sqlite3_context_db_handle(context);
550 UNUSED_PARAMETER2(NotUsed, NotUsed2);
551 /* IMP: R-52756-41993 This function is a wrapper around the
552 ** sqlite3_total_changes() C/C++ interface. */
553 sqlite3_result_int(context, sqlite3_total_changes(db));
557 ** A structure defining how to do GLOB-style comparisons.
559 struct compareInfo {
560 u8 matchAll;
561 u8 matchOne;
562 u8 matchSet;
563 u8 noCase;
567 ** For LIKE and GLOB matching on EBCDIC machines, assume that every
568 ** character is exactly one byte in size. Also, all characters are
569 ** able to participate in upper-case-to-lower-case mappings in EBCDIC
570 ** whereas only characters less than 0x80 do in ASCII.
572 #if defined(SQLITE_EBCDIC)
573 # define sqlite3Utf8Read(A) (*((*A)++))
574 # define GlobUpperToLower(A) A = sqlite3UpperToLower[A]
575 # define GlobUpperToLowerAscii(A) A = sqlite3UpperToLower[A]
576 #else
577 # define GlobUpperToLower(A) if( A<=0x7f ){ A = sqlite3UpperToLower[A]; }
578 # define GlobUpperToLowerAscii(A) A = sqlite3UpperToLower[A]
579 #endif
581 static const struct compareInfo globInfo = { '*', '?', '[', 0 };
582 /* The correct SQL-92 behavior is for the LIKE operator to ignore
583 ** case. Thus 'a' LIKE 'A' would be true. */
584 static const struct compareInfo likeInfoNorm = { '%', '_', 0, 1 };
585 /* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator
586 ** is case sensitive causing 'a' LIKE 'A' to be false */
587 static const struct compareInfo likeInfoAlt = { '%', '_', 0, 0 };
590 ** Compare two UTF-8 strings for equality where the first string can
591 ** potentially be a "glob" or "like" expression. Return true (1) if they
592 ** are the same and false (0) if they are different.
594 ** Globbing rules:
596 ** '*' Matches any sequence of zero or more characters.
598 ** '?' Matches exactly one character.
600 ** [...] Matches one character from the enclosed list of
601 ** characters.
603 ** [^...] Matches one character not in the enclosed list.
605 ** With the [...] and [^...] matching, a ']' character can be included
606 ** in the list by making it the first character after '[' or '^'. A
607 ** range of characters can be specified using '-'. Example:
608 ** "[a-z]" matches any single lower-case letter. To match a '-', make
609 ** it the last character in the list.
611 ** Like matching rules:
613 ** '%' Matches any sequence of zero or more characters
615 *** '_' Matches any one character
617 ** Ec Where E is the "esc" character and c is any other
618 ** character, including '%', '_', and esc, match exactly c.
620 ** The comments through this routine usually assume glob matching.
622 ** This routine is usually quick, but can be N**2 in the worst case.
624 static int patternCompare(
625 const u8 *zPattern, /* The glob pattern */
626 const u8 *zString, /* The string to compare against the glob */
627 const struct compareInfo *pInfo, /* Information about how to do the compare */
628 u32 esc /* The escape character */
630 u32 c, c2; /* Next pattern and input string chars */
631 u32 matchOne = pInfo->matchOne; /* "?" or "_" */
632 u32 matchAll = pInfo->matchAll; /* "*" or "%" */
633 u32 matchOther; /* "[" or the escape character */
634 u8 noCase = pInfo->noCase; /* True if uppercase==lowercase */
635 const u8 *zEscaped = 0; /* One past the last escaped input char */
637 /* The GLOB operator does not have an ESCAPE clause. And LIKE does not
638 ** have the matchSet operator. So we either have to look for one or
639 ** the other, never both. Hence the single variable matchOther is used
640 ** to store the one we have to look for.
642 matchOther = esc ? esc : pInfo->matchSet;
644 while( (c = sqlite3Utf8Read(&zPattern))!=0 ){
645 if( c==matchAll ){ /* Match "*" */
646 /* Skip over multiple "*" characters in the pattern. If there
647 ** are also "?" characters, skip those as well, but consume a
648 ** single character of the input string for each "?" skipped */
649 while( (c=sqlite3Utf8Read(&zPattern)) == matchAll
650 || c == matchOne ){
651 if( c==matchOne && sqlite3Utf8Read(&zString)==0 ){
652 return 0;
655 if( c==0 ){
656 return 1; /* "*" at the end of the pattern matches */
657 }else if( c==matchOther ){
658 if( esc ){
659 c = sqlite3Utf8Read(&zPattern);
660 if( c==0 ) return 0;
661 }else{
662 /* "[...]" immediately follows the "*". We have to do a slow
663 ** recursive search in this case, but it is an unusual case. */
664 assert( matchOther<0x80 ); /* '[' is a single-byte character */
665 while( *zString
666 && patternCompare(&zPattern[-1],zString,pInfo,esc)==0 ){
667 SQLITE_SKIP_UTF8(zString);
669 return *zString!=0;
673 /* At this point variable c contains the first character of the
674 ** pattern string past the "*". Search in the input string for the
675 ** first matching character and recursively contine the match from
676 ** that point.
678 ** For a case-insensitive search, set variable cx to be the same as
679 ** c but in the other case and search the input string for either
680 ** c or cx.
682 if( c<=0x80 ){
683 u32 cx;
684 if( noCase ){
685 cx = sqlite3Toupper(c);
686 c = sqlite3Tolower(c);
687 }else{
688 cx = c;
690 while( (c2 = *(zString++))!=0 ){
691 if( c2!=c && c2!=cx ) continue;
692 if( patternCompare(zPattern,zString,pInfo,esc) ) return 1;
694 }else{
695 while( (c2 = sqlite3Utf8Read(&zString))!=0 ){
696 if( c2!=c ) continue;
697 if( patternCompare(zPattern,zString,pInfo,esc) ) return 1;
700 return 0;
702 if( c==matchOther ){
703 if( esc ){
704 c = sqlite3Utf8Read(&zPattern);
705 if( c==0 ) return 0;
706 zEscaped = zPattern;
707 }else{
708 u32 prior_c = 0;
709 int seen = 0;
710 int invert = 0;
711 c = sqlite3Utf8Read(&zString);
712 if( c==0 ) return 0;
713 c2 = sqlite3Utf8Read(&zPattern);
714 if( c2=='^' ){
715 invert = 1;
716 c2 = sqlite3Utf8Read(&zPattern);
718 if( c2==']' ){
719 if( c==']' ) seen = 1;
720 c2 = sqlite3Utf8Read(&zPattern);
722 while( c2 && c2!=']' ){
723 if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){
724 c2 = sqlite3Utf8Read(&zPattern);
725 if( c>=prior_c && c<=c2 ) seen = 1;
726 prior_c = 0;
727 }else{
728 if( c==c2 ){
729 seen = 1;
731 prior_c = c2;
733 c2 = sqlite3Utf8Read(&zPattern);
735 if( c2==0 || (seen ^ invert)==0 ){
736 return 0;
738 continue;
741 c2 = sqlite3Utf8Read(&zString);
742 if( c==c2 ) continue;
743 if( noCase && c<0x80 && c2<0x80 && sqlite3Tolower(c)==sqlite3Tolower(c2) ){
744 continue;
746 if( c==matchOne && zPattern!=zEscaped && c2!=0 ) continue;
747 return 0;
749 return *zString==0;
753 ** The sqlite3_strglob() interface.
755 int sqlite3_strglob(const char *zGlobPattern, const char *zString){
756 return patternCompare((u8*)zGlobPattern, (u8*)zString, &globInfo, 0)==0;
760 ** Count the number of times that the LIKE operator (or GLOB which is
761 ** just a variation of LIKE) gets called. This is used for testing
762 ** only.
764 #ifdef SQLITE_TEST
765 int sqlite3_like_count = 0;
766 #endif
770 ** Implementation of the like() SQL function. This function implements
771 ** the build-in LIKE operator. The first argument to the function is the
772 ** pattern and the second argument is the string. So, the SQL statements:
774 ** A LIKE B
776 ** is implemented as like(B,A).
778 ** This same function (with a different compareInfo structure) computes
779 ** the GLOB operator.
781 static void likeFunc(
782 sqlite3_context *context,
783 int argc,
784 sqlite3_value **argv
786 const unsigned char *zA, *zB;
787 u32 escape = 0;
788 int nPat;
789 sqlite3 *db = sqlite3_context_db_handle(context);
791 zB = sqlite3_value_text(argv[0]);
792 zA = sqlite3_value_text(argv[1]);
794 /* Limit the length of the LIKE or GLOB pattern to avoid problems
795 ** of deep recursion and N*N behavior in patternCompare().
797 nPat = sqlite3_value_bytes(argv[0]);
798 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] );
799 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 );
800 if( nPat > db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){
801 sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);
802 return;
804 assert( zB==sqlite3_value_text(argv[0]) ); /* Encoding did not change */
806 if( argc==3 ){
807 /* The escape character string must consist of a single UTF-8 character.
808 ** Otherwise, return an error.
810 const unsigned char *zEsc = sqlite3_value_text(argv[2]);
811 if( zEsc==0 ) return;
812 if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){
813 sqlite3_result_error(context,
814 "ESCAPE expression must be a single character", -1);
815 return;
817 escape = sqlite3Utf8Read(&zEsc);
819 if( zA && zB ){
820 struct compareInfo *pInfo = sqlite3_user_data(context);
821 #ifdef SQLITE_TEST
822 sqlite3_like_count++;
823 #endif
825 sqlite3_result_int(context, patternCompare(zB, zA, pInfo, escape));
830 ** Implementation of the NULLIF(x,y) function. The result is the first
831 ** argument if the arguments are different. The result is NULL if the
832 ** arguments are equal to each other.
834 static void nullifFunc(
835 sqlite3_context *context,
836 int NotUsed,
837 sqlite3_value **argv
839 CollSeq *pColl = sqlite3GetFuncCollSeq(context);
840 UNUSED_PARAMETER(NotUsed);
841 if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){
842 sqlite3_result_value(context, argv[0]);
847 ** Implementation of the sqlite_version() function. The result is the version
848 ** of the SQLite library that is running.
850 static void versionFunc(
851 sqlite3_context *context,
852 int NotUsed,
853 sqlite3_value **NotUsed2
855 UNUSED_PARAMETER2(NotUsed, NotUsed2);
856 /* IMP: R-48699-48617 This function is an SQL wrapper around the
857 ** sqlite3_libversion() C-interface. */
858 sqlite3_result_text(context, sqlite3_libversion(), -1, SQLITE_STATIC);
862 ** Implementation of the sqlite_source_id() function. The result is a string
863 ** that identifies the particular version of the source code used to build
864 ** SQLite.
866 static void sourceidFunc(
867 sqlite3_context *context,
868 int NotUsed,
869 sqlite3_value **NotUsed2
871 UNUSED_PARAMETER2(NotUsed, NotUsed2);
872 /* IMP: R-24470-31136 This function is an SQL wrapper around the
873 ** sqlite3_sourceid() C interface. */
874 sqlite3_result_text(context, sqlite3_sourceid(), -1, SQLITE_STATIC);
878 ** Implementation of the sqlite_log() function. This is a wrapper around
879 ** sqlite3_log(). The return value is NULL. The function exists purely for
880 ** its side-effects.
882 static void errlogFunc(
883 sqlite3_context *context,
884 int argc,
885 sqlite3_value **argv
887 UNUSED_PARAMETER(argc);
888 UNUSED_PARAMETER(context);
889 sqlite3_log(sqlite3_value_int(argv[0]), "%s", sqlite3_value_text(argv[1]));
893 ** Implementation of the sqlite_compileoption_used() function.
894 ** The result is an integer that identifies if the compiler option
895 ** was used to build SQLite.
897 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
898 static void compileoptionusedFunc(
899 sqlite3_context *context,
900 int argc,
901 sqlite3_value **argv
903 const char *zOptName;
904 assert( argc==1 );
905 UNUSED_PARAMETER(argc);
906 /* IMP: R-39564-36305 The sqlite_compileoption_used() SQL
907 ** function is a wrapper around the sqlite3_compileoption_used() C/C++
908 ** function.
910 if( (zOptName = (const char*)sqlite3_value_text(argv[0]))!=0 ){
911 sqlite3_result_int(context, sqlite3_compileoption_used(zOptName));
914 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
917 ** Implementation of the sqlite_compileoption_get() function.
918 ** The result is a string that identifies the compiler options
919 ** used to build SQLite.
921 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
922 static void compileoptiongetFunc(
923 sqlite3_context *context,
924 int argc,
925 sqlite3_value **argv
927 int n;
928 assert( argc==1 );
929 UNUSED_PARAMETER(argc);
930 /* IMP: R-04922-24076 The sqlite_compileoption_get() SQL function
931 ** is a wrapper around the sqlite3_compileoption_get() C/C++ function.
933 n = sqlite3_value_int(argv[0]);
934 sqlite3_result_text(context, sqlite3_compileoption_get(n), -1, SQLITE_STATIC);
936 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
938 /* Array for converting from half-bytes (nybbles) into ASCII hex
939 ** digits. */
940 static const char hexdigits[] = {
941 '0', '1', '2', '3', '4', '5', '6', '7',
942 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
946 ** Implementation of the QUOTE() function. This function takes a single
947 ** argument. If the argument is numeric, the return value is the same as
948 ** the argument. If the argument is NULL, the return value is the string
949 ** "NULL". Otherwise, the argument is enclosed in single quotes with
950 ** single-quote escapes.
952 static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
953 assert( argc==1 );
954 UNUSED_PARAMETER(argc);
955 switch( sqlite3_value_type(argv[0]) ){
956 case SQLITE_FLOAT: {
957 double r1, r2;
958 char zBuf[50];
959 r1 = sqlite3_value_double(argv[0]);
960 sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.15g", r1);
961 sqlite3AtoF(zBuf, &r2, 20, SQLITE_UTF8);
962 if( r1!=r2 ){
963 sqlite3_snprintf(sizeof(zBuf), zBuf, "%!.20e", r1);
965 sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
966 break;
968 case SQLITE_INTEGER: {
969 sqlite3_result_value(context, argv[0]);
970 break;
972 case SQLITE_BLOB: {
973 char *zText = 0;
974 char const *zBlob = sqlite3_value_blob(argv[0]);
975 int nBlob = sqlite3_value_bytes(argv[0]);
976 assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */
977 zText = (char *)contextMalloc(context, (2*(i64)nBlob)+4);
978 if( zText ){
979 int i;
980 for(i=0; i<nBlob; i++){
981 zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F];
982 zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F];
984 zText[(nBlob*2)+2] = '\'';
985 zText[(nBlob*2)+3] = '\0';
986 zText[0] = 'X';
987 zText[1] = '\'';
988 sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT);
989 sqlite3_free(zText);
991 break;
993 case SQLITE_TEXT: {
994 int i,j;
995 u64 n;
996 const unsigned char *zArg = sqlite3_value_text(argv[0]);
997 char *z;
999 if( zArg==0 ) return;
1000 for(i=0, n=0; zArg[i]; i++){ if( zArg[i]=='\'' ) n++; }
1001 z = contextMalloc(context, ((i64)i)+((i64)n)+3);
1002 if( z ){
1003 z[0] = '\'';
1004 for(i=0, j=1; zArg[i]; i++){
1005 z[j++] = zArg[i];
1006 if( zArg[i]=='\'' ){
1007 z[j++] = '\'';
1010 z[j++] = '\'';
1011 z[j] = 0;
1012 sqlite3_result_text(context, z, j, sqlite3_free);
1014 break;
1016 default: {
1017 assert( sqlite3_value_type(argv[0])==SQLITE_NULL );
1018 sqlite3_result_text(context, "NULL", 4, SQLITE_STATIC);
1019 break;
1025 ** The unicode() function. Return the integer unicode code-point value
1026 ** for the first character of the input string.
1028 static void unicodeFunc(
1029 sqlite3_context *context,
1030 int argc,
1031 sqlite3_value **argv
1033 const unsigned char *z = sqlite3_value_text(argv[0]);
1034 (void)argc;
1035 if( z && z[0] ) sqlite3_result_int(context, sqlite3Utf8Read(&z));
1039 ** The char() function takes zero or more arguments, each of which is
1040 ** an integer. It constructs a string where each character of the string
1041 ** is the unicode character for the corresponding integer argument.
1043 static void charFunc(
1044 sqlite3_context *context,
1045 int argc,
1046 sqlite3_value **argv
1048 unsigned char *z, *zOut;
1049 int i;
1050 zOut = z = sqlite3_malloc( argc*4+1 );
1051 if( z==0 ){
1052 sqlite3_result_error_nomem(context);
1053 return;
1055 for(i=0; i<argc; i++){
1056 sqlite3_int64 x;
1057 unsigned c;
1058 x = sqlite3_value_int64(argv[i]);
1059 if( x<0 || x>0x10ffff ) x = 0xfffd;
1060 c = (unsigned)(x & 0x1fffff);
1061 if( c<0x00080 ){
1062 *zOut++ = (u8)(c&0xFF);
1063 }else if( c<0x00800 ){
1064 *zOut++ = 0xC0 + (u8)((c>>6)&0x1F);
1065 *zOut++ = 0x80 + (u8)(c & 0x3F);
1066 }else if( c<0x10000 ){
1067 *zOut++ = 0xE0 + (u8)((c>>12)&0x0F);
1068 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);
1069 *zOut++ = 0x80 + (u8)(c & 0x3F);
1070 }else{
1071 *zOut++ = 0xF0 + (u8)((c>>18) & 0x07);
1072 *zOut++ = 0x80 + (u8)((c>>12) & 0x3F);
1073 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);
1074 *zOut++ = 0x80 + (u8)(c & 0x3F);
1077 sqlite3_result_text64(context, (char*)z, zOut-z, sqlite3_free, SQLITE_UTF8);
1081 ** The hex() function. Interpret the argument as a blob. Return
1082 ** a hexadecimal rendering as text.
1084 static void hexFunc(
1085 sqlite3_context *context,
1086 int argc,
1087 sqlite3_value **argv
1089 int i, n;
1090 const unsigned char *pBlob;
1091 char *zHex, *z;
1092 assert( argc==1 );
1093 UNUSED_PARAMETER(argc);
1094 pBlob = sqlite3_value_blob(argv[0]);
1095 n = sqlite3_value_bytes(argv[0]);
1096 assert( pBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */
1097 z = zHex = contextMalloc(context, ((i64)n)*2 + 1);
1098 if( zHex ){
1099 for(i=0; i<n; i++, pBlob++){
1100 unsigned char c = *pBlob;
1101 *(z++) = hexdigits[(c>>4)&0xf];
1102 *(z++) = hexdigits[c&0xf];
1104 *z = 0;
1105 sqlite3_result_text(context, zHex, n*2, sqlite3_free);
1110 ** The zeroblob(N) function returns a zero-filled blob of size N bytes.
1112 static void zeroblobFunc(
1113 sqlite3_context *context,
1114 int argc,
1115 sqlite3_value **argv
1117 i64 n;
1118 sqlite3 *db = sqlite3_context_db_handle(context);
1119 assert( argc==1 );
1120 UNUSED_PARAMETER(argc);
1121 n = sqlite3_value_int64(argv[0]);
1122 testcase( n==db->aLimit[SQLITE_LIMIT_LENGTH] );
1123 testcase( n==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
1124 if( n>db->aLimit[SQLITE_LIMIT_LENGTH] ){
1125 sqlite3_result_error_toobig(context);
1126 }else{
1127 sqlite3_result_zeroblob(context, (int)n); /* IMP: R-00293-64994 */
1132 ** The replace() function. Three arguments are all strings: call
1133 ** them A, B, and C. The result is also a string which is derived
1134 ** from A by replacing every occurrence of B with C. The match
1135 ** must be exact. Collating sequences are not used.
1137 static void replaceFunc(
1138 sqlite3_context *context,
1139 int argc,
1140 sqlite3_value **argv
1142 const unsigned char *zStr; /* The input string A */
1143 const unsigned char *zPattern; /* The pattern string B */
1144 const unsigned char *zRep; /* The replacement string C */
1145 unsigned char *zOut; /* The output */
1146 int nStr; /* Size of zStr */
1147 int nPattern; /* Size of zPattern */
1148 int nRep; /* Size of zRep */
1149 i64 nOut; /* Maximum size of zOut */
1150 int loopLimit; /* Last zStr[] that might match zPattern[] */
1151 int i, j; /* Loop counters */
1153 assert( argc==3 );
1154 UNUSED_PARAMETER(argc);
1155 zStr = sqlite3_value_text(argv[0]);
1156 if( zStr==0 ) return;
1157 nStr = sqlite3_value_bytes(argv[0]);
1158 assert( zStr==sqlite3_value_text(argv[0]) ); /* No encoding change */
1159 zPattern = sqlite3_value_text(argv[1]);
1160 if( zPattern==0 ){
1161 assert( sqlite3_value_type(argv[1])==SQLITE_NULL
1162 || sqlite3_context_db_handle(context)->mallocFailed );
1163 return;
1165 if( zPattern[0]==0 ){
1166 assert( sqlite3_value_type(argv[1])!=SQLITE_NULL );
1167 sqlite3_result_value(context, argv[0]);
1168 return;
1170 nPattern = sqlite3_value_bytes(argv[1]);
1171 assert( zPattern==sqlite3_value_text(argv[1]) ); /* No encoding change */
1172 zRep = sqlite3_value_text(argv[2]);
1173 if( zRep==0 ) return;
1174 nRep = sqlite3_value_bytes(argv[2]);
1175 assert( zRep==sqlite3_value_text(argv[2]) );
1176 nOut = nStr + 1;
1177 assert( nOut<SQLITE_MAX_LENGTH );
1178 zOut = contextMalloc(context, (i64)nOut);
1179 if( zOut==0 ){
1180 return;
1182 loopLimit = nStr - nPattern;
1183 for(i=j=0; i<=loopLimit; i++){
1184 if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){
1185 zOut[j++] = zStr[i];
1186 }else{
1187 u8 *zOld;
1188 sqlite3 *db = sqlite3_context_db_handle(context);
1189 nOut += nRep - nPattern;
1190 testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] );
1191 testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] );
1192 if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
1193 sqlite3_result_error_toobig(context);
1194 sqlite3_free(zOut);
1195 return;
1197 zOld = zOut;
1198 zOut = sqlite3_realloc(zOut, (int)nOut);
1199 if( zOut==0 ){
1200 sqlite3_result_error_nomem(context);
1201 sqlite3_free(zOld);
1202 return;
1204 memcpy(&zOut[j], zRep, nRep);
1205 j += nRep;
1206 i += nPattern-1;
1209 assert( j+nStr-i+1==nOut );
1210 memcpy(&zOut[j], &zStr[i], nStr-i);
1211 j += nStr - i;
1212 assert( j<=nOut );
1213 zOut[j] = 0;
1214 sqlite3_result_text(context, (char*)zOut, j, sqlite3_free);
1218 ** Implementation of the TRIM(), LTRIM(), and RTRIM() functions.
1219 ** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both.
1221 static void trimFunc(
1222 sqlite3_context *context,
1223 int argc,
1224 sqlite3_value **argv
1226 const unsigned char *zIn; /* Input string */
1227 const unsigned char *zCharSet; /* Set of characters to trim */
1228 int nIn; /* Number of bytes in input */
1229 int flags; /* 1: trimleft 2: trimright 3: trim */
1230 int i; /* Loop counter */
1231 unsigned char *aLen = 0; /* Length of each character in zCharSet */
1232 unsigned char **azChar = 0; /* Individual characters in zCharSet */
1233 int nChar; /* Number of characters in zCharSet */
1235 if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
1236 return;
1238 zIn = sqlite3_value_text(argv[0]);
1239 if( zIn==0 ) return;
1240 nIn = sqlite3_value_bytes(argv[0]);
1241 assert( zIn==sqlite3_value_text(argv[0]) );
1242 if( argc==1 ){
1243 static const unsigned char lenOne[] = { 1 };
1244 static unsigned char * const azOne[] = { (u8*)" " };
1245 nChar = 1;
1246 aLen = (u8*)lenOne;
1247 azChar = (unsigned char **)azOne;
1248 zCharSet = 0;
1249 }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){
1250 return;
1251 }else{
1252 const unsigned char *z;
1253 for(z=zCharSet, nChar=0; *z; nChar++){
1254 SQLITE_SKIP_UTF8(z);
1256 if( nChar>0 ){
1257 azChar = contextMalloc(context, ((i64)nChar)*(sizeof(char*)+1));
1258 if( azChar==0 ){
1259 return;
1261 aLen = (unsigned char*)&azChar[nChar];
1262 for(z=zCharSet, nChar=0; *z; nChar++){
1263 azChar[nChar] = (unsigned char *)z;
1264 SQLITE_SKIP_UTF8(z);
1265 aLen[nChar] = (u8)(z - azChar[nChar]);
1269 if( nChar>0 ){
1270 flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context));
1271 if( flags & 1 ){
1272 while( nIn>0 ){
1273 int len = 0;
1274 for(i=0; i<nChar; i++){
1275 len = aLen[i];
1276 if( len<=nIn && memcmp(zIn, azChar[i], len)==0 ) break;
1278 if( i>=nChar ) break;
1279 zIn += len;
1280 nIn -= len;
1283 if( flags & 2 ){
1284 while( nIn>0 ){
1285 int len = 0;
1286 for(i=0; i<nChar; i++){
1287 len = aLen[i];
1288 if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break;
1290 if( i>=nChar ) break;
1291 nIn -= len;
1294 if( zCharSet ){
1295 sqlite3_free(azChar);
1298 sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT);
1302 /* IMP: R-25361-16150 This function is omitted from SQLite by default. It
1303 ** is only available if the SQLITE_SOUNDEX compile-time option is used
1304 ** when SQLite is built.
1306 #ifdef SQLITE_SOUNDEX
1308 ** Compute the soundex encoding of a word.
1310 ** IMP: R-59782-00072 The soundex(X) function returns a string that is the
1311 ** soundex encoding of the string X.
1313 static void soundexFunc(
1314 sqlite3_context *context,
1315 int argc,
1316 sqlite3_value **argv
1318 char zResult[8];
1319 const u8 *zIn;
1320 int i, j;
1321 static const unsigned char iCode[] = {
1322 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1323 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1324 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1325 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1326 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
1327 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
1328 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
1329 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
1331 assert( argc==1 );
1332 zIn = (u8*)sqlite3_value_text(argv[0]);
1333 if( zIn==0 ) zIn = (u8*)"";
1334 for(i=0; zIn[i] && !sqlite3Isalpha(zIn[i]); i++){}
1335 if( zIn[i] ){
1336 u8 prevcode = iCode[zIn[i]&0x7f];
1337 zResult[0] = sqlite3Toupper(zIn[i]);
1338 for(j=1; j<4 && zIn[i]; i++){
1339 int code = iCode[zIn[i]&0x7f];
1340 if( code>0 ){
1341 if( code!=prevcode ){
1342 prevcode = code;
1343 zResult[j++] = code + '0';
1345 }else{
1346 prevcode = 0;
1349 while( j<4 ){
1350 zResult[j++] = '0';
1352 zResult[j] = 0;
1353 sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT);
1354 }else{
1355 /* IMP: R-64894-50321 The string "?000" is returned if the argument
1356 ** is NULL or contains no ASCII alphabetic characters. */
1357 sqlite3_result_text(context, "?000", 4, SQLITE_STATIC);
1360 #endif /* SQLITE_SOUNDEX */
1362 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1364 ** A function that loads a shared-library extension then returns NULL.
1366 static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){
1367 const char *zFile = (const char *)sqlite3_value_text(argv[0]);
1368 const char *zProc;
1369 sqlite3 *db = sqlite3_context_db_handle(context);
1370 char *zErrMsg = 0;
1372 if( argc==2 ){
1373 zProc = (const char *)sqlite3_value_text(argv[1]);
1374 }else{
1375 zProc = 0;
1377 if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){
1378 sqlite3_result_error(context, zErrMsg, -1);
1379 sqlite3_free(zErrMsg);
1382 #endif
1386 ** An instance of the following structure holds the context of a
1387 ** sum() or avg() aggregate computation.
1389 typedef struct SumCtx SumCtx;
1390 struct SumCtx {
1391 double rSum; /* Floating point sum */
1392 i64 iSum; /* Integer sum */
1393 i64 cnt; /* Number of elements summed */
1394 u8 overflow; /* True if integer overflow seen */
1395 u8 approx; /* True if non-integer value was input to the sum */
1399 ** Routines used to compute the sum, average, and total.
1401 ** The SUM() function follows the (broken) SQL standard which means
1402 ** that it returns NULL if it sums over no inputs. TOTAL returns
1403 ** 0.0 in that case. In addition, TOTAL always returns a float where
1404 ** SUM might return an integer if it never encounters a floating point
1405 ** value. TOTAL never fails, but SUM might through an exception if
1406 ** it overflows an integer.
1408 static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){
1409 SumCtx *p;
1410 int type;
1411 assert( argc==1 );
1412 UNUSED_PARAMETER(argc);
1413 p = sqlite3_aggregate_context(context, sizeof(*p));
1414 type = sqlite3_value_numeric_type(argv[0]);
1415 if( p && type!=SQLITE_NULL ){
1416 p->cnt++;
1417 if( type==SQLITE_INTEGER ){
1418 i64 v = sqlite3_value_int64(argv[0]);
1419 p->rSum += v;
1420 if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){
1421 p->overflow = 1;
1423 }else{
1424 p->rSum += sqlite3_value_double(argv[0]);
1425 p->approx = 1;
1429 static void sumFinalize(sqlite3_context *context){
1430 SumCtx *p;
1431 p = sqlite3_aggregate_context(context, 0);
1432 if( p && p->cnt>0 ){
1433 if( p->overflow ){
1434 sqlite3_result_error(context,"integer overflow",-1);
1435 }else if( p->approx ){
1436 sqlite3_result_double(context, p->rSum);
1437 }else{
1438 sqlite3_result_int64(context, p->iSum);
1442 static void avgFinalize(sqlite3_context *context){
1443 SumCtx *p;
1444 p = sqlite3_aggregate_context(context, 0);
1445 if( p && p->cnt>0 ){
1446 sqlite3_result_double(context, p->rSum/(double)p->cnt);
1449 static void totalFinalize(sqlite3_context *context){
1450 SumCtx *p;
1451 p = sqlite3_aggregate_context(context, 0);
1452 /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
1453 sqlite3_result_double(context, p ? p->rSum : (double)0);
1457 ** The following structure keeps track of state information for the
1458 ** count() aggregate function.
1460 typedef struct CountCtx CountCtx;
1461 struct CountCtx {
1462 i64 n;
1466 ** Routines to implement the count() aggregate function.
1468 static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){
1469 CountCtx *p;
1470 p = sqlite3_aggregate_context(context, sizeof(*p));
1471 if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){
1472 p->n++;
1475 #ifndef SQLITE_OMIT_DEPRECATED
1476 /* The sqlite3_aggregate_count() function is deprecated. But just to make
1477 ** sure it still operates correctly, verify that its count agrees with our
1478 ** internal count when using count(*) and when the total count can be
1479 ** expressed as a 32-bit integer. */
1480 assert( argc==1 || p==0 || p->n>0x7fffffff
1481 || p->n==sqlite3_aggregate_count(context) );
1482 #endif
1484 static void countFinalize(sqlite3_context *context){
1485 CountCtx *p;
1486 p = sqlite3_aggregate_context(context, 0);
1487 sqlite3_result_int64(context, p ? p->n : 0);
1491 ** Routines to implement min() and max() aggregate functions.
1493 static void minmaxStep(
1494 sqlite3_context *context,
1495 int NotUsed,
1496 sqlite3_value **argv
1498 Mem *pArg = (Mem *)argv[0];
1499 Mem *pBest;
1500 UNUSED_PARAMETER(NotUsed);
1502 pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest));
1503 if( !pBest ) return;
1505 if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
1506 if( pBest->flags ) sqlite3SkipAccumulatorLoad(context);
1507 }else if( pBest->flags ){
1508 int max;
1509 int cmp;
1510 CollSeq *pColl = sqlite3GetFuncCollSeq(context);
1511 /* This step function is used for both the min() and max() aggregates,
1512 ** the only difference between the two being that the sense of the
1513 ** comparison is inverted. For the max() aggregate, the
1514 ** sqlite3_user_data() function returns (void *)-1. For min() it
1515 ** returns (void *)db, where db is the sqlite3* database pointer.
1516 ** Therefore the next statement sets variable 'max' to 1 for the max()
1517 ** aggregate, or 0 for min().
1519 max = sqlite3_user_data(context)!=0;
1520 cmp = sqlite3MemCompare(pBest, pArg, pColl);
1521 if( (max && cmp<0) || (!max && cmp>0) ){
1522 sqlite3VdbeMemCopy(pBest, pArg);
1523 }else{
1524 sqlite3SkipAccumulatorLoad(context);
1526 }else{
1527 pBest->db = sqlite3_context_db_handle(context);
1528 sqlite3VdbeMemCopy(pBest, pArg);
1531 static void minMaxFinalize(sqlite3_context *context){
1532 sqlite3_value *pRes;
1533 pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0);
1534 if( pRes ){
1535 if( pRes->flags ){
1536 sqlite3_result_value(context, pRes);
1538 sqlite3VdbeMemRelease(pRes);
1543 ** group_concat(EXPR, ?SEPARATOR?)
1545 static void groupConcatStep(
1546 sqlite3_context *context,
1547 int argc,
1548 sqlite3_value **argv
1550 const char *zVal;
1551 StrAccum *pAccum;
1552 const char *zSep;
1553 int nVal, nSep;
1554 assert( argc==1 || argc==2 );
1555 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
1556 pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum));
1558 if( pAccum ){
1559 sqlite3 *db = sqlite3_context_db_handle(context);
1560 int firstTerm = pAccum->useMalloc==0;
1561 pAccum->useMalloc = 2;
1562 pAccum->mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH];
1563 if( !firstTerm ){
1564 if( argc==2 ){
1565 zSep = (char*)sqlite3_value_text(argv[1]);
1566 nSep = sqlite3_value_bytes(argv[1]);
1567 }else{
1568 zSep = ",";
1569 nSep = 1;
1571 if( nSep ) sqlite3StrAccumAppend(pAccum, zSep, nSep);
1573 zVal = (char*)sqlite3_value_text(argv[0]);
1574 nVal = sqlite3_value_bytes(argv[0]);
1575 if( zVal ) sqlite3StrAccumAppend(pAccum, zVal, nVal);
1578 static void groupConcatFinalize(sqlite3_context *context){
1579 StrAccum *pAccum;
1580 pAccum = sqlite3_aggregate_context(context, 0);
1581 if( pAccum ){
1582 if( pAccum->accError==STRACCUM_TOOBIG ){
1583 sqlite3_result_error_toobig(context);
1584 }else if( pAccum->accError==STRACCUM_NOMEM ){
1585 sqlite3_result_error_nomem(context);
1586 }else{
1587 sqlite3_result_text(context, sqlite3StrAccumFinish(pAccum), -1,
1588 sqlite3_free);
1594 ** This routine does per-connection function registration. Most
1595 ** of the built-in functions above are part of the global function set.
1596 ** This routine only deals with those that are not global.
1598 void sqlite3RegisterBuiltinFunctions(sqlite3 *db){
1599 int rc = sqlite3_overload_function(db, "MATCH", 2);
1600 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
1601 if( rc==SQLITE_NOMEM ){
1602 db->mallocFailed = 1;
1607 ** Set the LIKEOPT flag on the 2-argument function with the given name.
1609 static void setLikeOptFlag(sqlite3 *db, const char *zName, u8 flagVal){
1610 FuncDef *pDef;
1611 pDef = sqlite3FindFunction(db, zName, sqlite3Strlen30(zName),
1612 2, SQLITE_UTF8, 0);
1613 if( ALWAYS(pDef) ){
1614 pDef->funcFlags |= flagVal;
1619 ** Register the built-in LIKE and GLOB functions. The caseSensitive
1620 ** parameter determines whether or not the LIKE operator is case
1621 ** sensitive. GLOB is always case sensitive.
1623 void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){
1624 struct compareInfo *pInfo;
1625 if( caseSensitive ){
1626 pInfo = (struct compareInfo*)&likeInfoAlt;
1627 }else{
1628 pInfo = (struct compareInfo*)&likeInfoNorm;
1630 sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0);
1631 sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0);
1632 sqlite3CreateFunc(db, "glob", 2, SQLITE_UTF8,
1633 (struct compareInfo*)&globInfo, likeFunc, 0, 0, 0);
1634 setLikeOptFlag(db, "glob", SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE);
1635 setLikeOptFlag(db, "like",
1636 caseSensitive ? (SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE) : SQLITE_FUNC_LIKE);
1640 ** pExpr points to an expression which implements a function. If
1641 ** it is appropriate to apply the LIKE optimization to that function
1642 ** then set aWc[0] through aWc[2] to the wildcard characters and
1643 ** return TRUE. If the function is not a LIKE-style function then
1644 ** return FALSE.
1646 int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){
1647 FuncDef *pDef;
1648 if( pExpr->op!=TK_FUNCTION
1649 || !pExpr->x.pList
1650 || pExpr->x.pList->nExpr!=2
1652 return 0;
1654 assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
1655 pDef = sqlite3FindFunction(db, pExpr->u.zToken,
1656 sqlite3Strlen30(pExpr->u.zToken),
1657 2, SQLITE_UTF8, 0);
1658 if( NEVER(pDef==0) || (pDef->funcFlags & SQLITE_FUNC_LIKE)==0 ){
1659 return 0;
1662 /* The memcpy() statement assumes that the wildcard characters are
1663 ** the first three statements in the compareInfo structure. The
1664 ** asserts() that follow verify that assumption
1666 memcpy(aWc, pDef->pUserData, 3);
1667 assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll );
1668 assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne );
1669 assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet );
1670 *pIsNocase = (pDef->funcFlags & SQLITE_FUNC_CASE)==0;
1671 return 1;
1675 ** All of the FuncDef structures in the aBuiltinFunc[] array above
1676 ** to the global function hash table. This occurs at start-time (as
1677 ** a consequence of calling sqlite3_initialize()).
1679 ** After this routine runs
1681 void sqlite3RegisterGlobalFunctions(void){
1683 ** The following array holds FuncDef structures for all of the functions
1684 ** defined in this file.
1686 ** The array cannot be constant since changes are made to the
1687 ** FuncDef.pHash elements at start-time. The elements of this array
1688 ** are read-only after initialization is complete.
1690 static SQLITE_WSD FuncDef aBuiltinFunc[] = {
1691 FUNCTION(ltrim, 1, 1, 0, trimFunc ),
1692 FUNCTION(ltrim, 2, 1, 0, trimFunc ),
1693 FUNCTION(rtrim, 1, 2, 0, trimFunc ),
1694 FUNCTION(rtrim, 2, 2, 0, trimFunc ),
1695 FUNCTION(trim, 1, 3, 0, trimFunc ),
1696 FUNCTION(trim, 2, 3, 0, trimFunc ),
1697 FUNCTION(min, -1, 0, 1, minmaxFunc ),
1698 FUNCTION(min, 0, 0, 1, 0 ),
1699 AGGREGATE2(min, 1, 0, 1, minmaxStep, minMaxFinalize,
1700 SQLITE_FUNC_MINMAX ),
1701 FUNCTION(max, -1, 1, 1, minmaxFunc ),
1702 FUNCTION(max, 0, 1, 1, 0 ),
1703 AGGREGATE2(max, 1, 1, 1, minmaxStep, minMaxFinalize,
1704 SQLITE_FUNC_MINMAX ),
1705 FUNCTION2(typeof, 1, 0, 0, typeofFunc, SQLITE_FUNC_TYPEOF),
1706 FUNCTION2(length, 1, 0, 0, lengthFunc, SQLITE_FUNC_LENGTH),
1707 FUNCTION(instr, 2, 0, 0, instrFunc ),
1708 FUNCTION(substr, 2, 0, 0, substrFunc ),
1709 FUNCTION(substr, 3, 0, 0, substrFunc ),
1710 FUNCTION(printf, -1, 0, 0, printfFunc ),
1711 FUNCTION(unicode, 1, 0, 0, unicodeFunc ),
1712 FUNCTION(char, -1, 0, 0, charFunc ),
1713 FUNCTION(abs, 1, 0, 0, absFunc ),
1714 #ifndef SQLITE_OMIT_FLOATING_POINT
1715 FUNCTION(round, 1, 0, 0, roundFunc ),
1716 FUNCTION(round, 2, 0, 0, roundFunc ),
1717 #endif
1718 FUNCTION(upper, 1, 0, 0, upperFunc ),
1719 FUNCTION(lower, 1, 0, 0, lowerFunc ),
1720 FUNCTION(coalesce, 1, 0, 0, 0 ),
1721 FUNCTION(coalesce, 0, 0, 0, 0 ),
1722 FUNCTION2(coalesce, -1, 0, 0, noopFunc, SQLITE_FUNC_COALESCE),
1723 FUNCTION(hex, 1, 0, 0, hexFunc ),
1724 FUNCTION2(ifnull, 2, 0, 0, noopFunc, SQLITE_FUNC_COALESCE),
1725 FUNCTION2(unlikely, 1, 0, 0, noopFunc, SQLITE_FUNC_UNLIKELY),
1726 FUNCTION2(likelihood, 2, 0, 0, noopFunc, SQLITE_FUNC_UNLIKELY),
1727 FUNCTION2(likely, 1, 0, 0, noopFunc, SQLITE_FUNC_UNLIKELY),
1728 VFUNCTION(random, 0, 0, 0, randomFunc ),
1729 VFUNCTION(randomblob, 1, 0, 0, randomBlob ),
1730 FUNCTION(nullif, 2, 0, 1, nullifFunc ),
1731 FUNCTION(sqlite_version, 0, 0, 0, versionFunc ),
1732 FUNCTION(sqlite_source_id, 0, 0, 0, sourceidFunc ),
1733 FUNCTION(sqlite_log, 2, 0, 0, errlogFunc ),
1734 #if SQLITE_USER_AUTHENTICATION
1735 FUNCTION(sqlite_crypt, 2, 0, 0, sqlite3CryptFunc ),
1736 #endif
1737 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
1738 FUNCTION(sqlite_compileoption_used,1, 0, 0, compileoptionusedFunc ),
1739 FUNCTION(sqlite_compileoption_get, 1, 0, 0, compileoptiongetFunc ),
1740 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
1741 FUNCTION(quote, 1, 0, 0, quoteFunc ),
1742 VFUNCTION(last_insert_rowid, 0, 0, 0, last_insert_rowid),
1743 VFUNCTION(changes, 0, 0, 0, changes ),
1744 VFUNCTION(total_changes, 0, 0, 0, total_changes ),
1745 FUNCTION(replace, 3, 0, 0, replaceFunc ),
1746 FUNCTION(zeroblob, 1, 0, 0, zeroblobFunc ),
1747 #ifdef SQLITE_SOUNDEX
1748 FUNCTION(soundex, 1, 0, 0, soundexFunc ),
1749 #endif
1750 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1751 FUNCTION(load_extension, 1, 0, 0, loadExt ),
1752 FUNCTION(load_extension, 2, 0, 0, loadExt ),
1753 #endif
1754 AGGREGATE(sum, 1, 0, 0, sumStep, sumFinalize ),
1755 AGGREGATE(total, 1, 0, 0, sumStep, totalFinalize ),
1756 AGGREGATE(avg, 1, 0, 0, sumStep, avgFinalize ),
1757 AGGREGATE2(count, 0, 0, 0, countStep, countFinalize,
1758 SQLITE_FUNC_COUNT ),
1759 AGGREGATE(count, 1, 0, 0, countStep, countFinalize ),
1760 AGGREGATE(group_concat, 1, 0, 0, groupConcatStep, groupConcatFinalize),
1761 AGGREGATE(group_concat, 2, 0, 0, groupConcatStep, groupConcatFinalize),
1763 LIKEFUNC(glob, 2, &globInfo, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
1764 #ifdef SQLITE_CASE_SENSITIVE_LIKE
1765 LIKEFUNC(like, 2, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
1766 LIKEFUNC(like, 3, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
1767 #else
1768 LIKEFUNC(like, 2, &likeInfoNorm, SQLITE_FUNC_LIKE),
1769 LIKEFUNC(like, 3, &likeInfoNorm, SQLITE_FUNC_LIKE),
1770 #endif
1773 int i;
1774 FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions);
1775 FuncDef *aFunc = (FuncDef*)&GLOBAL(FuncDef, aBuiltinFunc);
1777 for(i=0; i<ArraySize(aBuiltinFunc); i++){
1778 sqlite3FuncDefInsert(pHash, &aFunc[i]);
1780 sqlite3RegisterDateTimeFunctions();
1781 #ifndef SQLITE_OMIT_ALTERTABLE
1782 sqlite3AlterFunctions();
1783 #endif
1784 #if defined(SQLITE_ENABLE_STAT3) || defined(SQLITE_ENABLE_STAT4)
1785 sqlite3AnalyzeFunctions();
1786 #endif