4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
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"
19 #ifndef SQLITE_OMIT_FLOATING_POINT
25 ** Return the collating function associated with a function.
27 static CollSeq
*sqlite3GetFuncCollSeq(sqlite3_context
*context
){
29 assert( context
->pVdbe
!=0 );
30 pOp
= &context
->pVdbe
->aOp
[context
->iOp
-1];
31 assert( pOp
->opcode
==OP_CollSeq
);
32 assert( pOp
->p4type
==P4_COLLSEQ
);
37 ** Indicate that the accumulator load should be skipped on this
38 ** iteration of the aggregate loop.
40 static void sqlite3SkipAccumulatorLoad(sqlite3_context
*context
){
41 assert( context
->isError
<=0 );
42 context
->isError
= -1;
43 context
->skipFlag
= 1;
47 ** Implementation of the non-aggregate min() and max() functions
49 static void minmaxFunc(
50 sqlite3_context
*context
,
55 int mask
; /* 0 for min() or 0xffffffff for max() */
60 mask
= sqlite3_user_data(context
)==0 ? 0 : -1;
61 pColl
= sqlite3GetFuncCollSeq(context
);
63 assert( mask
==-1 || mask
==0 );
65 if( sqlite3_value_type(argv
[0])==SQLITE_NULL
) return;
66 for(i
=1; i
<argc
; i
++){
67 if( sqlite3_value_type(argv
[i
])==SQLITE_NULL
) return;
68 if( (sqlite3MemCompare(argv
[iBest
], argv
[i
], pColl
)^mask
)>=0 ){
73 sqlite3_result_value(context
, argv
[iBest
]);
77 ** Return the type of the argument.
79 static void typeofFunc(
80 sqlite3_context
*context
,
84 static const char *azType
[] = { "integer", "real", "text", "blob", "null" };
85 int i
= sqlite3_value_type(argv
[0]) - 1;
86 UNUSED_PARAMETER(NotUsed
);
87 assert( i
>=0 && i
<ArraySize(azType
) );
88 assert( SQLITE_INTEGER
==1 );
89 assert( SQLITE_FLOAT
==2 );
90 assert( SQLITE_TEXT
==3 );
91 assert( SQLITE_BLOB
==4 );
92 assert( SQLITE_NULL
==5 );
93 /* EVIDENCE-OF: R-01470-60482 The sqlite3_value_type(V) interface returns
94 ** the datatype code for the initial datatype of the sqlite3_value object
95 ** V. The returned value is one of SQLITE_INTEGER, SQLITE_FLOAT,
96 ** SQLITE_TEXT, SQLITE_BLOB, or SQLITE_NULL. */
97 sqlite3_result_text(context
, azType
[i
], -1, SQLITE_STATIC
);
102 ** Implementation of the length() function
104 static void lengthFunc(
105 sqlite3_context
*context
,
110 UNUSED_PARAMETER(argc
);
111 switch( sqlite3_value_type(argv
[0]) ){
115 sqlite3_result_int(context
, sqlite3_value_bytes(argv
[0]));
119 const unsigned char *z
= sqlite3_value_text(argv
[0]);
120 const unsigned char *z0
;
124 while( (c
= *z
)!=0 ){
127 while( (*z
& 0xc0)==0x80 ){ z
++; z0
++; }
130 sqlite3_result_int(context
, (int)(z
-z0
));
134 sqlite3_result_null(context
);
141 ** Implementation of the abs() function.
143 ** IMP: R-23979-26855 The abs(X) function returns the absolute value of
144 ** the numeric argument X.
146 static void absFunc(sqlite3_context
*context
, int argc
, sqlite3_value
**argv
){
148 UNUSED_PARAMETER(argc
);
149 switch( sqlite3_value_type(argv
[0]) ){
150 case SQLITE_INTEGER
: {
151 i64 iVal
= sqlite3_value_int64(argv
[0]);
153 if( iVal
==SMALLEST_INT64
){
154 /* IMP: R-31676-45509 If X is the integer -9223372036854775808
155 ** then abs(X) throws an integer overflow error since there is no
156 ** equivalent positive 64-bit two complement value. */
157 sqlite3_result_error(context
, "integer overflow", -1);
162 sqlite3_result_int64(context
, iVal
);
166 /* IMP: R-37434-19929 Abs(X) returns NULL if X is NULL. */
167 sqlite3_result_null(context
);
171 /* Because sqlite3_value_double() returns 0.0 if the argument is not
172 ** something that can be converted into a number, we have:
173 ** IMP: R-01992-00519 Abs(X) returns 0.0 if X is a string or blob
174 ** that cannot be converted to a numeric value.
176 double rVal
= sqlite3_value_double(argv
[0]);
177 if( rVal
<0 ) rVal
= -rVal
;
178 sqlite3_result_double(context
, rVal
);
185 ** Implementation of the instr() function.
187 ** instr(haystack,needle) finds the first occurrence of needle
188 ** in haystack and returns the number of previous characters plus 1,
189 ** or 0 if needle does not occur within haystack.
191 ** If both haystack and needle are BLOBs, then the result is one more than
192 ** the number of bytes in haystack prior to the first occurrence of needle,
193 ** or 0 if needle never occurs in haystack.
195 static void instrFunc(
196 sqlite3_context
*context
,
200 const unsigned char *zHaystack
;
201 const unsigned char *zNeedle
;
204 int typeHaystack
, typeNeedle
;
207 unsigned char firstChar
;
208 sqlite3_value
*pC1
= 0;
209 sqlite3_value
*pC2
= 0;
211 UNUSED_PARAMETER(argc
);
212 typeHaystack
= sqlite3_value_type(argv
[0]);
213 typeNeedle
= sqlite3_value_type(argv
[1]);
214 if( typeHaystack
==SQLITE_NULL
|| typeNeedle
==SQLITE_NULL
) return;
215 nHaystack
= sqlite3_value_bytes(argv
[0]);
216 nNeedle
= sqlite3_value_bytes(argv
[1]);
218 if( typeHaystack
==SQLITE_BLOB
&& typeNeedle
==SQLITE_BLOB
){
219 zHaystack
= sqlite3_value_blob(argv
[0]);
220 zNeedle
= sqlite3_value_blob(argv
[1]);
222 }else if( typeHaystack
!=SQLITE_BLOB
&& typeNeedle
!=SQLITE_BLOB
){
223 zHaystack
= sqlite3_value_text(argv
[0]);
224 zNeedle
= sqlite3_value_text(argv
[1]);
227 pC1
= sqlite3_value_dup(argv
[0]);
228 zHaystack
= sqlite3_value_text(pC1
);
229 if( zHaystack
==0 ) goto endInstrOOM
;
230 nHaystack
= sqlite3_value_bytes(pC1
);
231 pC2
= sqlite3_value_dup(argv
[1]);
232 zNeedle
= sqlite3_value_text(pC2
);
233 if( zNeedle
==0 ) goto endInstrOOM
;
234 nNeedle
= sqlite3_value_bytes(pC2
);
237 if( zNeedle
==0 || (nHaystack
&& zHaystack
==0) ) goto endInstrOOM
;
238 firstChar
= zNeedle
[0];
239 while( nNeedle
<=nHaystack
240 && (zHaystack
[0]!=firstChar
|| memcmp(zHaystack
, zNeedle
, nNeedle
)!=0)
246 }while( isText
&& (zHaystack
[0]&0xc0)==0x80 );
248 if( nNeedle
>nHaystack
) N
= 0;
250 sqlite3_result_int(context
, N
);
252 sqlite3_value_free(pC1
);
253 sqlite3_value_free(pC2
);
256 sqlite3_result_error_nomem(context
);
261 ** Implementation of the printf() function.
263 static void printfFunc(
264 sqlite3_context
*context
,
272 sqlite3
*db
= sqlite3_context_db_handle(context
);
274 if( argc
>=1 && (zFormat
= (const char*)sqlite3_value_text(argv
[0]))!=0 ){
278 sqlite3StrAccumInit(&str
, db
, 0, 0, db
->aLimit
[SQLITE_LIMIT_LENGTH
]);
279 str
.printfFlags
= SQLITE_PRINTF_SQLFUNC
;
280 sqlite3_str_appendf(&str
, zFormat
, &x
);
282 sqlite3_result_text(context
, sqlite3StrAccumFinish(&str
), n
,
288 ** Implementation of the substr() function.
290 ** substr(x,p1,p2) returns p2 characters of x[] beginning with p1.
291 ** p1 is 1-indexed. So substr(x,1,1) returns the first character
292 ** of x. If x is text, then we actually count UTF-8 characters.
293 ** If x is a blob, then we count bytes.
295 ** If p1 is negative, then we begin abs(p1) from the end of x[].
297 ** If p2 is negative, return the p2 characters preceding p1.
299 static void substrFunc(
300 sqlite3_context
*context
,
304 const unsigned char *z
;
305 const unsigned char *z2
;
311 assert( argc
==3 || argc
==2 );
312 if( sqlite3_value_type(argv
[1])==SQLITE_NULL
313 || (argc
==3 && sqlite3_value_type(argv
[2])==SQLITE_NULL
)
317 p0type
= sqlite3_value_type(argv
[0]);
318 p1
= sqlite3_value_int(argv
[1]);
319 if( p0type
==SQLITE_BLOB
){
320 len
= sqlite3_value_bytes(argv
[0]);
321 z
= sqlite3_value_blob(argv
[0]);
323 assert( len
==sqlite3_value_bytes(argv
[0]) );
325 z
= sqlite3_value_text(argv
[0]);
329 for(z2
=z
; *z2
; len
++){
330 SQLITE_SKIP_UTF8(z2
);
334 #ifdef SQLITE_SUBSTR_COMPATIBILITY
335 /* If SUBSTR_COMPATIBILITY is defined then substr(X,0,N) work the same as
336 ** as substr(X,1,N) - it returns the first N characters of X. This
337 ** is essentially a back-out of the bug-fix in check-in [5fc125d362df4b8]
338 ** from 2009-02-02 for compatibility of applications that exploited the
339 ** old buggy behavior. */
340 if( p1
==0 ) p1
= 1; /* <rdar://problem/6778339> */
343 p2
= sqlite3_value_int(argv
[2]);
349 p2
= sqlite3_context_db_handle(context
)->aLimit
[SQLITE_LIMIT_LENGTH
];
370 assert( p1
>=0 && p2
>=0 );
371 if( p0type
!=SQLITE_BLOB
){
376 for(z2
=z
; *z2
&& p2
; p2
--){
377 SQLITE_SKIP_UTF8(z2
);
379 sqlite3_result_text64(context
, (char*)z
, z2
-z
, SQLITE_TRANSIENT
,
386 sqlite3_result_blob64(context
, (char*)&z
[p1
], (u64
)p2
, SQLITE_TRANSIENT
);
391 ** Implementation of the round() function
393 #ifndef SQLITE_OMIT_FLOATING_POINT
394 static void roundFunc(sqlite3_context
*context
, int argc
, sqlite3_value
**argv
){
398 assert( argc
==1 || argc
==2 );
400 if( SQLITE_NULL
==sqlite3_value_type(argv
[1]) ) return;
401 n
= sqlite3_value_int(argv
[1]);
405 if( sqlite3_value_type(argv
[0])==SQLITE_NULL
) return;
406 r
= sqlite3_value_double(argv
[0]);
407 /* If Y==0 and X will fit in a 64-bit int,
408 ** handle the rounding directly,
409 ** otherwise use printf.
411 if( r
<-4503599627370496.0 || r
>+4503599627370496.0 ){
412 /* The value has no fractional part so there is nothing to round */
414 r
= (double)((sqlite_int64
)(r
+(r
<0?-0.5:+0.5)));
416 zBuf
= sqlite3_mprintf("%.*f",n
,r
);
418 sqlite3_result_error_nomem(context
);
421 sqlite3AtoF(zBuf
, &r
, sqlite3Strlen30(zBuf
), SQLITE_UTF8
);
424 sqlite3_result_double(context
, r
);
429 ** Allocate nByte bytes of space using sqlite3Malloc(). If the
430 ** allocation fails, call sqlite3_result_error_nomem() to notify
431 ** the database handle that malloc() has failed and return NULL.
432 ** If nByte is larger than the maximum string or blob length, then
433 ** raise an SQLITE_TOOBIG exception and return NULL.
435 static void *contextMalloc(sqlite3_context
*context
, i64 nByte
){
437 sqlite3
*db
= sqlite3_context_db_handle(context
);
439 testcase( nByte
==db
->aLimit
[SQLITE_LIMIT_LENGTH
] );
440 testcase( nByte
==db
->aLimit
[SQLITE_LIMIT_LENGTH
]+1 );
441 if( nByte
>db
->aLimit
[SQLITE_LIMIT_LENGTH
] ){
442 sqlite3_result_error_toobig(context
);
445 z
= sqlite3Malloc(nByte
);
447 sqlite3_result_error_nomem(context
);
454 ** Implementation of the upper() and lower() SQL functions.
456 static void upperFunc(sqlite3_context
*context
, int argc
, sqlite3_value
**argv
){
460 UNUSED_PARAMETER(argc
);
461 z2
= (char*)sqlite3_value_text(argv
[0]);
462 n
= sqlite3_value_bytes(argv
[0]);
463 /* Verify that the call to _bytes() does not invalidate the _text() pointer */
464 assert( z2
==(char*)sqlite3_value_text(argv
[0]) );
466 z1
= contextMalloc(context
, ((i64
)n
)+1);
469 z1
[i
] = (char)sqlite3Toupper(z2
[i
]);
471 sqlite3_result_text(context
, z1
, n
, sqlite3_free
);
475 static void lowerFunc(sqlite3_context
*context
, int argc
, sqlite3_value
**argv
){
479 UNUSED_PARAMETER(argc
);
480 z2
= (char*)sqlite3_value_text(argv
[0]);
481 n
= sqlite3_value_bytes(argv
[0]);
482 /* Verify that the call to _bytes() does not invalidate the _text() pointer */
483 assert( z2
==(char*)sqlite3_value_text(argv
[0]) );
485 z1
= contextMalloc(context
, ((i64
)n
)+1);
488 z1
[i
] = sqlite3Tolower(z2
[i
]);
490 sqlite3_result_text(context
, z1
, n
, sqlite3_free
);
496 ** Some functions like COALESCE() and IFNULL() and UNLIKELY() are implemented
497 ** as VDBE code so that unused argument values do not have to be computed.
498 ** However, we still need some kind of function implementation for this
499 ** routines in the function table. The noopFunc macro provides this.
500 ** noopFunc will never be called so it doesn't matter what the implementation
501 ** is. We might as well use the "version()" function as a substitute.
503 #define noopFunc versionFunc /* Substitute function - never called */
506 ** Implementation of random(). Return a random integer.
508 static void randomFunc(
509 sqlite3_context
*context
,
511 sqlite3_value
**NotUsed2
514 UNUSED_PARAMETER2(NotUsed
, NotUsed2
);
515 sqlite3_randomness(sizeof(r
), &r
);
517 /* We need to prevent a random number of 0x8000000000000000
518 ** (or -9223372036854775808) since when you do abs() of that
519 ** number of you get the same value back again. To do this
520 ** in a way that is testable, mask the sign bit off of negative
521 ** values, resulting in a positive value. Then take the
522 ** 2s complement of that positive value. The end result can
523 ** therefore be no less than -9223372036854775807.
525 r
= -(r
& LARGEST_INT64
);
527 sqlite3_result_int64(context
, r
);
531 ** Implementation of randomblob(N). Return a random blob
532 ** that is N bytes long.
534 static void randomBlob(
535 sqlite3_context
*context
,
542 UNUSED_PARAMETER(argc
);
543 n
= sqlite3_value_int64(argv
[0]);
547 p
= contextMalloc(context
, n
);
549 sqlite3_randomness(n
, p
);
550 sqlite3_result_blob(context
, (char*)p
, n
, sqlite3_free
);
555 ** Implementation of the last_insert_rowid() SQL function. The return
556 ** value is the same as the sqlite3_last_insert_rowid() API function.
558 static void last_insert_rowid(
559 sqlite3_context
*context
,
561 sqlite3_value
**NotUsed2
563 sqlite3
*db
= sqlite3_context_db_handle(context
);
564 UNUSED_PARAMETER2(NotUsed
, NotUsed2
);
565 /* IMP: R-51513-12026 The last_insert_rowid() SQL function is a
566 ** wrapper around the sqlite3_last_insert_rowid() C/C++ interface
568 sqlite3_result_int64(context
, sqlite3_last_insert_rowid(db
));
572 ** Implementation of the changes() SQL function.
574 ** IMP: R-32760-32347 The changes() SQL function is a wrapper
575 ** around the sqlite3_changes64() C/C++ function and hence follows the
576 ** same rules for counting changes.
579 sqlite3_context
*context
,
581 sqlite3_value
**NotUsed2
583 sqlite3
*db
= sqlite3_context_db_handle(context
);
584 UNUSED_PARAMETER2(NotUsed
, NotUsed2
);
585 sqlite3_result_int64(context
, sqlite3_changes64(db
));
589 ** Implementation of the total_changes() SQL function. The return value is
590 ** the same as the sqlite3_total_changes64() API function.
592 static void total_changes(
593 sqlite3_context
*context
,
595 sqlite3_value
**NotUsed2
597 sqlite3
*db
= sqlite3_context_db_handle(context
);
598 UNUSED_PARAMETER2(NotUsed
, NotUsed2
);
599 /* IMP: R-11217-42568 This function is a wrapper around the
600 ** sqlite3_total_changes64() C/C++ interface. */
601 sqlite3_result_int64(context
, sqlite3_total_changes64(db
));
605 ** A structure defining how to do GLOB-style comparisons.
608 u8 matchAll
; /* "*" or "%" */
609 u8 matchOne
; /* "?" or "_" */
610 u8 matchSet
; /* "[" or 0 */
611 u8 noCase
; /* true to ignore case differences */
615 ** For LIKE and GLOB matching on EBCDIC machines, assume that every
616 ** character is exactly one byte in size. Also, provde the Utf8Read()
617 ** macro for fast reading of the next character in the common case where
618 ** the next character is ASCII.
620 #if defined(SQLITE_EBCDIC)
621 # define sqlite3Utf8Read(A) (*((*A)++))
622 # define Utf8Read(A) (*(A++))
624 # define Utf8Read(A) (A[0]<0x80?*(A++):sqlite3Utf8Read(&A))
627 static const struct compareInfo globInfo
= { '*', '?', '[', 0 };
628 /* The correct SQL-92 behavior is for the LIKE operator to ignore
629 ** case. Thus 'a' LIKE 'A' would be true. */
630 static const struct compareInfo likeInfoNorm
= { '%', '_', 0, 1 };
631 /* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator
632 ** is case sensitive causing 'a' LIKE 'A' to be false */
633 static const struct compareInfo likeInfoAlt
= { '%', '_', 0, 0 };
636 ** Possible error returns from patternMatch()
638 #define SQLITE_MATCH 0
639 #define SQLITE_NOMATCH 1
640 #define SQLITE_NOWILDCARDMATCH 2
643 ** Compare two UTF-8 strings for equality where the first string is
644 ** a GLOB or LIKE expression. Return values:
646 ** SQLITE_MATCH: Match
647 ** SQLITE_NOMATCH: No match
648 ** SQLITE_NOWILDCARDMATCH: No match in spite of having * or % wildcards.
652 ** '*' Matches any sequence of zero or more characters.
654 ** '?' Matches exactly one character.
656 ** [...] Matches one character from the enclosed list of
659 ** [^...] Matches one character not in the enclosed list.
661 ** With the [...] and [^...] matching, a ']' character can be included
662 ** in the list by making it the first character after '[' or '^'. A
663 ** range of characters can be specified using '-'. Example:
664 ** "[a-z]" matches any single lower-case letter. To match a '-', make
665 ** it the last character in the list.
667 ** Like matching rules:
669 ** '%' Matches any sequence of zero or more characters
671 *** '_' Matches any one character
673 ** Ec Where E is the "esc" character and c is any other
674 ** character, including '%', '_', and esc, match exactly c.
676 ** The comments within this routine usually assume glob matching.
678 ** This routine is usually quick, but can be N**2 in the worst case.
680 static int patternCompare(
681 const u8
*zPattern
, /* The glob pattern */
682 const u8
*zString
, /* The string to compare against the glob */
683 const struct compareInfo
*pInfo
, /* Information about how to do the compare */
684 u32 matchOther
/* The escape char (LIKE) or '[' (GLOB) */
686 u32 c
, c2
; /* Next pattern and input string chars */
687 u32 matchOne
= pInfo
->matchOne
; /* "?" or "_" */
688 u32 matchAll
= pInfo
->matchAll
; /* "*" or "%" */
689 u8 noCase
= pInfo
->noCase
; /* True if uppercase==lowercase */
690 const u8
*zEscaped
= 0; /* One past the last escaped input char */
692 while( (c
= Utf8Read(zPattern
))!=0 ){
693 if( c
==matchAll
){ /* Match "*" */
694 /* Skip over multiple "*" characters in the pattern. If there
695 ** are also "?" characters, skip those as well, but consume a
696 ** single character of the input string for each "?" skipped */
697 while( (c
=Utf8Read(zPattern
)) == matchAll
698 || (c
== matchOne
&& matchOne
!=0) ){
699 if( c
==matchOne
&& sqlite3Utf8Read(&zString
)==0 ){
700 return SQLITE_NOWILDCARDMATCH
;
704 return SQLITE_MATCH
; /* "*" at the end of the pattern matches */
705 }else if( c
==matchOther
){
706 if( pInfo
->matchSet
==0 ){
707 c
= sqlite3Utf8Read(&zPattern
);
708 if( c
==0 ) return SQLITE_NOWILDCARDMATCH
;
710 /* "[...]" immediately follows the "*". We have to do a slow
711 ** recursive search in this case, but it is an unusual case. */
712 assert( matchOther
<0x80 ); /* '[' is a single-byte character */
714 int bMatch
= patternCompare(&zPattern
[-1],zString
,pInfo
,matchOther
);
715 if( bMatch
!=SQLITE_NOMATCH
) return bMatch
;
716 SQLITE_SKIP_UTF8(zString
);
718 return SQLITE_NOWILDCARDMATCH
;
722 /* At this point variable c contains the first character of the
723 ** pattern string past the "*". Search in the input string for the
724 ** first matching character and recursively continue the match from
727 ** For a case-insensitive search, set variable cx to be the same as
728 ** c but in the other case and search the input string for either
735 zStop
[0] = sqlite3Toupper(c
);
736 zStop
[1] = sqlite3Tolower(c
);
743 zString
+= strcspn((const char*)zString
, zStop
);
744 if( zString
[0]==0 ) break;
746 bMatch
= patternCompare(zPattern
,zString
,pInfo
,matchOther
);
747 if( bMatch
!=SQLITE_NOMATCH
) return bMatch
;
751 while( (c2
= Utf8Read(zString
))!=0 ){
752 if( c2
!=c
) continue;
753 bMatch
= patternCompare(zPattern
,zString
,pInfo
,matchOther
);
754 if( bMatch
!=SQLITE_NOMATCH
) return bMatch
;
757 return SQLITE_NOWILDCARDMATCH
;
760 if( pInfo
->matchSet
==0 ){
761 c
= sqlite3Utf8Read(&zPattern
);
762 if( c
==0 ) return SQLITE_NOMATCH
;
768 c
= sqlite3Utf8Read(&zString
);
769 if( c
==0 ) return SQLITE_NOMATCH
;
770 c2
= sqlite3Utf8Read(&zPattern
);
773 c2
= sqlite3Utf8Read(&zPattern
);
776 if( c
==']' ) seen
= 1;
777 c2
= sqlite3Utf8Read(&zPattern
);
779 while( c2
&& c2
!=']' ){
780 if( c2
=='-' && zPattern
[0]!=']' && zPattern
[0]!=0 && prior_c
>0 ){
781 c2
= sqlite3Utf8Read(&zPattern
);
782 if( c
>=prior_c
&& c
<=c2
) seen
= 1;
790 c2
= sqlite3Utf8Read(&zPattern
);
792 if( c2
==0 || (seen
^ invert
)==0 ){
793 return SQLITE_NOMATCH
;
798 c2
= Utf8Read(zString
);
799 if( c
==c2
) continue;
800 if( noCase
&& sqlite3Tolower(c
)==sqlite3Tolower(c2
) && c
<0x80 && c2
<0x80 ){
803 if( c
==matchOne
&& zPattern
!=zEscaped
&& c2
!=0 ) continue;
804 return SQLITE_NOMATCH
;
806 return *zString
==0 ? SQLITE_MATCH
: SQLITE_NOMATCH
;
810 ** The sqlite3_strglob() interface. Return 0 on a match (like strcmp()) and
811 ** non-zero if there is no match.
813 int sqlite3_strglob(const char *zGlobPattern
, const char *zString
){
814 return patternCompare((u8
*)zGlobPattern
, (u8
*)zString
, &globInfo
, '[');
818 ** The sqlite3_strlike() interface. Return 0 on a match and non-zero for
819 ** a miss - like strcmp().
821 int sqlite3_strlike(const char *zPattern
, const char *zStr
, unsigned int esc
){
822 return patternCompare((u8
*)zPattern
, (u8
*)zStr
, &likeInfoNorm
, esc
);
826 ** Count the number of times that the LIKE operator (or GLOB which is
827 ** just a variation of LIKE) gets called. This is used for testing
831 int sqlite3_like_count
= 0;
836 ** Implementation of the like() SQL function. This function implements
837 ** the build-in LIKE operator. The first argument to the function is the
838 ** pattern and the second argument is the string. So, the SQL statements:
842 ** is implemented as like(B,A).
844 ** This same function (with a different compareInfo structure) computes
845 ** the GLOB operator.
847 static void likeFunc(
848 sqlite3_context
*context
,
852 const unsigned char *zA
, *zB
;
855 sqlite3
*db
= sqlite3_context_db_handle(context
);
856 struct compareInfo
*pInfo
= sqlite3_user_data(context
);
857 struct compareInfo backupInfo
;
859 #ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS
860 if( sqlite3_value_type(argv
[0])==SQLITE_BLOB
861 || sqlite3_value_type(argv
[1])==SQLITE_BLOB
864 sqlite3_like_count
++;
866 sqlite3_result_int(context
, 0);
871 /* Limit the length of the LIKE or GLOB pattern to avoid problems
872 ** of deep recursion and N*N behavior in patternCompare().
874 nPat
= sqlite3_value_bytes(argv
[0]);
875 testcase( nPat
==db
->aLimit
[SQLITE_LIMIT_LIKE_PATTERN_LENGTH
] );
876 testcase( nPat
==db
->aLimit
[SQLITE_LIMIT_LIKE_PATTERN_LENGTH
]+1 );
877 if( nPat
> db
->aLimit
[SQLITE_LIMIT_LIKE_PATTERN_LENGTH
] ){
878 sqlite3_result_error(context
, "LIKE or GLOB pattern too complex", -1);
882 /* The escape character string must consist of a single UTF-8 character.
883 ** Otherwise, return an error.
885 const unsigned char *zEsc
= sqlite3_value_text(argv
[2]);
886 if( zEsc
==0 ) return;
887 if( sqlite3Utf8CharLen((char*)zEsc
, -1)!=1 ){
888 sqlite3_result_error(context
,
889 "ESCAPE expression must be a single character", -1);
892 escape
= sqlite3Utf8Read(&zEsc
);
893 if( escape
==pInfo
->matchAll
|| escape
==pInfo
->matchOne
){
894 memcpy(&backupInfo
, pInfo
, sizeof(backupInfo
));
896 if( escape
==pInfo
->matchAll
) pInfo
->matchAll
= 0;
897 if( escape
==pInfo
->matchOne
) pInfo
->matchOne
= 0;
900 escape
= pInfo
->matchSet
;
902 zB
= sqlite3_value_text(argv
[0]);
903 zA
= sqlite3_value_text(argv
[1]);
906 sqlite3_like_count
++;
908 sqlite3_result_int(context
,
909 patternCompare(zB
, zA
, pInfo
, escape
)==SQLITE_MATCH
);
914 ** Implementation of the NULLIF(x,y) function. The result is the first
915 ** argument if the arguments are different. The result is NULL if the
916 ** arguments are equal to each other.
918 static void nullifFunc(
919 sqlite3_context
*context
,
923 CollSeq
*pColl
= sqlite3GetFuncCollSeq(context
);
924 UNUSED_PARAMETER(NotUsed
);
925 if( sqlite3MemCompare(argv
[0], argv
[1], pColl
)!=0 ){
926 sqlite3_result_value(context
, argv
[0]);
931 ** Implementation of the sqlite_version() function. The result is the version
932 ** of the SQLite library that is running.
934 static void versionFunc(
935 sqlite3_context
*context
,
937 sqlite3_value
**NotUsed2
939 UNUSED_PARAMETER2(NotUsed
, NotUsed2
);
940 /* IMP: R-48699-48617 This function is an SQL wrapper around the
941 ** sqlite3_libversion() C-interface. */
942 sqlite3_result_text(context
, sqlite3_libversion(), -1, SQLITE_STATIC
);
946 ** Implementation of the sqlite_source_id() function. The result is a string
947 ** that identifies the particular version of the source code used to build
950 static void sourceidFunc(
951 sqlite3_context
*context
,
953 sqlite3_value
**NotUsed2
955 UNUSED_PARAMETER2(NotUsed
, NotUsed2
);
956 /* IMP: R-24470-31136 This function is an SQL wrapper around the
957 ** sqlite3_sourceid() C interface. */
958 sqlite3_result_text(context
, sqlite3_sourceid(), -1, SQLITE_STATIC
);
962 ** Implementation of the sqlite_log() function. This is a wrapper around
963 ** sqlite3_log(). The return value is NULL. The function exists purely for
966 static void errlogFunc(
967 sqlite3_context
*context
,
971 UNUSED_PARAMETER(argc
);
972 UNUSED_PARAMETER(context
);
973 sqlite3_log(sqlite3_value_int(argv
[0]), "%s", sqlite3_value_text(argv
[1]));
977 ** Implementation of the sqlite_compileoption_used() function.
978 ** The result is an integer that identifies if the compiler option
979 ** was used to build SQLite.
981 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
982 static void compileoptionusedFunc(
983 sqlite3_context
*context
,
987 const char *zOptName
;
989 UNUSED_PARAMETER(argc
);
990 /* IMP: R-39564-36305 The sqlite_compileoption_used() SQL
991 ** function is a wrapper around the sqlite3_compileoption_used() C/C++
994 if( (zOptName
= (const char*)sqlite3_value_text(argv
[0]))!=0 ){
995 sqlite3_result_int(context
, sqlite3_compileoption_used(zOptName
));
998 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
1001 ** Implementation of the sqlite_compileoption_get() function.
1002 ** The result is a string that identifies the compiler options
1003 ** used to build SQLite.
1005 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
1006 static void compileoptiongetFunc(
1007 sqlite3_context
*context
,
1009 sqlite3_value
**argv
1013 UNUSED_PARAMETER(argc
);
1014 /* IMP: R-04922-24076 The sqlite_compileoption_get() SQL function
1015 ** is a wrapper around the sqlite3_compileoption_get() C/C++ function.
1017 n
= sqlite3_value_int(argv
[0]);
1018 sqlite3_result_text(context
, sqlite3_compileoption_get(n
), -1, SQLITE_STATIC
);
1020 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
1022 /* Array for converting from half-bytes (nybbles) into ASCII hex
1024 static const char hexdigits
[] = {
1025 '0', '1', '2', '3', '4', '5', '6', '7',
1026 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
1030 ** Implementation of the QUOTE() function. This function takes a single
1031 ** argument. If the argument is numeric, the return value is the same as
1032 ** the argument. If the argument is NULL, the return value is the string
1033 ** "NULL". Otherwise, the argument is enclosed in single quotes with
1034 ** single-quote escapes.
1036 static void quoteFunc(sqlite3_context
*context
, int argc
, sqlite3_value
**argv
){
1038 UNUSED_PARAMETER(argc
);
1039 switch( sqlite3_value_type(argv
[0]) ){
1040 case SQLITE_FLOAT
: {
1043 r1
= sqlite3_value_double(argv
[0]);
1044 sqlite3_snprintf(sizeof(zBuf
), zBuf
, "%!.15g", r1
);
1045 sqlite3AtoF(zBuf
, &r2
, 20, SQLITE_UTF8
);
1047 sqlite3_snprintf(sizeof(zBuf
), zBuf
, "%!.20e", r1
);
1049 sqlite3_result_text(context
, zBuf
, -1, SQLITE_TRANSIENT
);
1052 case SQLITE_INTEGER
: {
1053 sqlite3_result_value(context
, argv
[0]);
1058 char const *zBlob
= sqlite3_value_blob(argv
[0]);
1059 int nBlob
= sqlite3_value_bytes(argv
[0]);
1060 assert( zBlob
==sqlite3_value_blob(argv
[0]) ); /* No encoding change */
1061 zText
= (char *)contextMalloc(context
, (2*(i64
)nBlob
)+4);
1064 for(i
=0; i
<nBlob
; i
++){
1065 zText
[(i
*2)+2] = hexdigits
[(zBlob
[i
]>>4)&0x0F];
1066 zText
[(i
*2)+3] = hexdigits
[(zBlob
[i
])&0x0F];
1068 zText
[(nBlob
*2)+2] = '\'';
1069 zText
[(nBlob
*2)+3] = '\0';
1072 sqlite3_result_text(context
, zText
, -1, SQLITE_TRANSIENT
);
1073 sqlite3_free(zText
);
1080 const unsigned char *zArg
= sqlite3_value_text(argv
[0]);
1083 if( zArg
==0 ) return;
1084 for(i
=0, n
=0; zArg
[i
]; i
++){ if( zArg
[i
]=='\'' ) n
++; }
1085 z
= contextMalloc(context
, ((i64
)i
)+((i64
)n
)+3);
1088 for(i
=0, j
=1; zArg
[i
]; i
++){
1090 if( zArg
[i
]=='\'' ){
1096 sqlite3_result_text(context
, z
, j
, sqlite3_free
);
1101 assert( sqlite3_value_type(argv
[0])==SQLITE_NULL
);
1102 sqlite3_result_text(context
, "NULL", 4, SQLITE_STATIC
);
1109 ** The unicode() function. Return the integer unicode code-point value
1110 ** for the first character of the input string.
1112 static void unicodeFunc(
1113 sqlite3_context
*context
,
1115 sqlite3_value
**argv
1117 const unsigned char *z
= sqlite3_value_text(argv
[0]);
1119 if( z
&& z
[0] ) sqlite3_result_int(context
, sqlite3Utf8Read(&z
));
1123 ** The char() function takes zero or more arguments, each of which is
1124 ** an integer. It constructs a string where each character of the string
1125 ** is the unicode character for the corresponding integer argument.
1127 static void charFunc(
1128 sqlite3_context
*context
,
1130 sqlite3_value
**argv
1132 unsigned char *z
, *zOut
;
1134 zOut
= z
= sqlite3_malloc64( argc
*4+1 );
1136 sqlite3_result_error_nomem(context
);
1139 for(i
=0; i
<argc
; i
++){
1142 x
= sqlite3_value_int64(argv
[i
]);
1143 if( x
<0 || x
>0x10ffff ) x
= 0xfffd;
1144 c
= (unsigned)(x
& 0x1fffff);
1146 *zOut
++ = (u8
)(c
&0xFF);
1147 }else if( c
<0x00800 ){
1148 *zOut
++ = 0xC0 + (u8
)((c
>>6)&0x1F);
1149 *zOut
++ = 0x80 + (u8
)(c
& 0x3F);
1150 }else if( c
<0x10000 ){
1151 *zOut
++ = 0xE0 + (u8
)((c
>>12)&0x0F);
1152 *zOut
++ = 0x80 + (u8
)((c
>>6) & 0x3F);
1153 *zOut
++ = 0x80 + (u8
)(c
& 0x3F);
1155 *zOut
++ = 0xF0 + (u8
)((c
>>18) & 0x07);
1156 *zOut
++ = 0x80 + (u8
)((c
>>12) & 0x3F);
1157 *zOut
++ = 0x80 + (u8
)((c
>>6) & 0x3F);
1158 *zOut
++ = 0x80 + (u8
)(c
& 0x3F);
1161 sqlite3_result_text64(context
, (char*)z
, zOut
-z
, sqlite3_free
, SQLITE_UTF8
);
1165 ** The hex() function. Interpret the argument as a blob. Return
1166 ** a hexadecimal rendering as text.
1168 static void hexFunc(
1169 sqlite3_context
*context
,
1171 sqlite3_value
**argv
1174 const unsigned char *pBlob
;
1177 UNUSED_PARAMETER(argc
);
1178 pBlob
= sqlite3_value_blob(argv
[0]);
1179 n
= sqlite3_value_bytes(argv
[0]);
1180 assert( pBlob
==sqlite3_value_blob(argv
[0]) ); /* No encoding change */
1181 z
= zHex
= contextMalloc(context
, ((i64
)n
)*2 + 1);
1183 for(i
=0; i
<n
; i
++, pBlob
++){
1184 unsigned char c
= *pBlob
;
1185 *(z
++) = hexdigits
[(c
>>4)&0xf];
1186 *(z
++) = hexdigits
[c
&0xf];
1189 sqlite3_result_text(context
, zHex
, n
*2, sqlite3_free
);
1194 ** The zeroblob(N) function returns a zero-filled blob of size N bytes.
1196 static void zeroblobFunc(
1197 sqlite3_context
*context
,
1199 sqlite3_value
**argv
1204 UNUSED_PARAMETER(argc
);
1205 n
= sqlite3_value_int64(argv
[0]);
1207 rc
= sqlite3_result_zeroblob64(context
, n
); /* IMP: R-00293-64994 */
1209 sqlite3_result_error_code(context
, rc
);
1214 ** The replace() function. Three arguments are all strings: call
1215 ** them A, B, and C. The result is also a string which is derived
1216 ** from A by replacing every occurrence of B with C. The match
1217 ** must be exact. Collating sequences are not used.
1219 static void replaceFunc(
1220 sqlite3_context
*context
,
1222 sqlite3_value
**argv
1224 const unsigned char *zStr
; /* The input string A */
1225 const unsigned char *zPattern
; /* The pattern string B */
1226 const unsigned char *zRep
; /* The replacement string C */
1227 unsigned char *zOut
; /* The output */
1228 int nStr
; /* Size of zStr */
1229 int nPattern
; /* Size of zPattern */
1230 int nRep
; /* Size of zRep */
1231 i64 nOut
; /* Maximum size of zOut */
1232 int loopLimit
; /* Last zStr[] that might match zPattern[] */
1233 int i
, j
; /* Loop counters */
1234 unsigned cntExpand
; /* Number zOut expansions */
1235 sqlite3
*db
= sqlite3_context_db_handle(context
);
1238 UNUSED_PARAMETER(argc
);
1239 zStr
= sqlite3_value_text(argv
[0]);
1240 if( zStr
==0 ) return;
1241 nStr
= sqlite3_value_bytes(argv
[0]);
1242 assert( zStr
==sqlite3_value_text(argv
[0]) ); /* No encoding change */
1243 zPattern
= sqlite3_value_text(argv
[1]);
1245 assert( sqlite3_value_type(argv
[1])==SQLITE_NULL
1246 || sqlite3_context_db_handle(context
)->mallocFailed
);
1249 if( zPattern
[0]==0 ){
1250 assert( sqlite3_value_type(argv
[1])!=SQLITE_NULL
);
1251 sqlite3_result_value(context
, argv
[0]);
1254 nPattern
= sqlite3_value_bytes(argv
[1]);
1255 assert( zPattern
==sqlite3_value_text(argv
[1]) ); /* No encoding change */
1256 zRep
= sqlite3_value_text(argv
[2]);
1257 if( zRep
==0 ) return;
1258 nRep
= sqlite3_value_bytes(argv
[2]);
1259 assert( zRep
==sqlite3_value_text(argv
[2]) );
1261 assert( nOut
<SQLITE_MAX_LENGTH
);
1262 zOut
= contextMalloc(context
, (i64
)nOut
);
1266 loopLimit
= nStr
- nPattern
;
1268 for(i
=j
=0; i
<=loopLimit
; i
++){
1269 if( zStr
[i
]!=zPattern
[0] || memcmp(&zStr
[i
], zPattern
, nPattern
) ){
1270 zOut
[j
++] = zStr
[i
];
1272 if( nRep
>nPattern
){
1273 nOut
+= nRep
- nPattern
;
1274 testcase( nOut
-1==db
->aLimit
[SQLITE_LIMIT_LENGTH
] );
1275 testcase( nOut
-2==db
->aLimit
[SQLITE_LIMIT_LENGTH
] );
1276 if( nOut
-1>db
->aLimit
[SQLITE_LIMIT_LENGTH
] ){
1277 sqlite3_result_error_toobig(context
);
1282 if( (cntExpand
&(cntExpand
-1))==0 ){
1283 /* Grow the size of the output buffer only on substitutions
1284 ** whose index is a power of two: 1, 2, 4, 8, 16, 32, ... */
1287 zOut
= sqlite3Realloc(zOut
, (int)nOut
+ (nOut
- nStr
- 1));
1289 sqlite3_result_error_nomem(context
);
1295 memcpy(&zOut
[j
], zRep
, nRep
);
1300 assert( j
+nStr
-i
+1<=nOut
);
1301 memcpy(&zOut
[j
], &zStr
[i
], nStr
-i
);
1305 sqlite3_result_text(context
, (char*)zOut
, j
, sqlite3_free
);
1309 ** Implementation of the TRIM(), LTRIM(), and RTRIM() functions.
1310 ** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both.
1312 static void trimFunc(
1313 sqlite3_context
*context
,
1315 sqlite3_value
**argv
1317 const unsigned char *zIn
; /* Input string */
1318 const unsigned char *zCharSet
; /* Set of characters to trim */
1319 unsigned int nIn
; /* Number of bytes in input */
1320 int flags
; /* 1: trimleft 2: trimright 3: trim */
1321 int i
; /* Loop counter */
1322 unsigned int *aLen
= 0; /* Length of each character in zCharSet */
1323 unsigned char **azChar
= 0; /* Individual characters in zCharSet */
1324 int nChar
; /* Number of characters in zCharSet */
1326 if( sqlite3_value_type(argv
[0])==SQLITE_NULL
){
1329 zIn
= sqlite3_value_text(argv
[0]);
1330 if( zIn
==0 ) return;
1331 nIn
= (unsigned)sqlite3_value_bytes(argv
[0]);
1332 assert( zIn
==sqlite3_value_text(argv
[0]) );
1334 static const unsigned lenOne
[] = { 1 };
1335 static unsigned char * const azOne
[] = { (u8
*)" " };
1337 aLen
= (unsigned*)lenOne
;
1338 azChar
= (unsigned char **)azOne
;
1340 }else if( (zCharSet
= sqlite3_value_text(argv
[1]))==0 ){
1343 const unsigned char *z
;
1344 for(z
=zCharSet
, nChar
=0; *z
; nChar
++){
1345 SQLITE_SKIP_UTF8(z
);
1348 azChar
= contextMalloc(context
,
1349 ((i64
)nChar
)*(sizeof(char*)+sizeof(unsigned)));
1353 aLen
= (unsigned*)&azChar
[nChar
];
1354 for(z
=zCharSet
, nChar
=0; *z
; nChar
++){
1355 azChar
[nChar
] = (unsigned char *)z
;
1356 SQLITE_SKIP_UTF8(z
);
1357 aLen
[nChar
] = (unsigned)(z
- azChar
[nChar
]);
1362 flags
= SQLITE_PTR_TO_INT(sqlite3_user_data(context
));
1365 unsigned int len
= 0;
1366 for(i
=0; i
<nChar
; i
++){
1368 if( len
<=nIn
&& memcmp(zIn
, azChar
[i
], len
)==0 ) break;
1370 if( i
>=nChar
) break;
1377 unsigned int len
= 0;
1378 for(i
=0; i
<nChar
; i
++){
1380 if( len
<=nIn
&& memcmp(&zIn
[nIn
-len
],azChar
[i
],len
)==0 ) break;
1382 if( i
>=nChar
) break;
1387 sqlite3_free(azChar
);
1390 sqlite3_result_text(context
, (char*)zIn
, nIn
, SQLITE_TRANSIENT
);
1394 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
1396 ** The "unknown" function is automatically substituted in place of
1397 ** any unrecognized function name when doing an EXPLAIN or EXPLAIN QUERY PLAN
1398 ** when the SQLITE_ENABLE_UNKNOWN_FUNCTION compile-time option is used.
1399 ** When the "sqlite3" command-line shell is built using this functionality,
1400 ** that allows an EXPLAIN or EXPLAIN QUERY PLAN for complex queries
1401 ** involving application-defined functions to be examined in a generic
1404 static void unknownFunc(
1405 sqlite3_context
*context
,
1407 sqlite3_value
**argv
1411 #endif /*SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION*/
1414 /* IMP: R-25361-16150 This function is omitted from SQLite by default. It
1415 ** is only available if the SQLITE_SOUNDEX compile-time option is used
1416 ** when SQLite is built.
1418 #ifdef SQLITE_SOUNDEX
1420 ** Compute the soundex encoding of a word.
1422 ** IMP: R-59782-00072 The soundex(X) function returns a string that is the
1423 ** soundex encoding of the string X.
1425 static void soundexFunc(
1426 sqlite3_context
*context
,
1428 sqlite3_value
**argv
1433 static const unsigned char iCode
[] = {
1434 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1435 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1436 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1437 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1438 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
1439 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
1440 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
1441 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
1444 zIn
= (u8
*)sqlite3_value_text(argv
[0]);
1445 if( zIn
==0 ) zIn
= (u8
*)"";
1446 for(i
=0; zIn
[i
] && !sqlite3Isalpha(zIn
[i
]); i
++){}
1448 u8 prevcode
= iCode
[zIn
[i
]&0x7f];
1449 zResult
[0] = sqlite3Toupper(zIn
[i
]);
1450 for(j
=1; j
<4 && zIn
[i
]; i
++){
1451 int code
= iCode
[zIn
[i
]&0x7f];
1453 if( code
!=prevcode
){
1455 zResult
[j
++] = code
+ '0';
1465 sqlite3_result_text(context
, zResult
, 4, SQLITE_TRANSIENT
);
1467 /* IMP: R-64894-50321 The string "?000" is returned if the argument
1468 ** is NULL or contains no ASCII alphabetic characters. */
1469 sqlite3_result_text(context
, "?000", 4, SQLITE_STATIC
);
1472 #endif /* SQLITE_SOUNDEX */
1474 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1476 ** A function that loads a shared-library extension then returns NULL.
1478 static void loadExt(sqlite3_context
*context
, int argc
, sqlite3_value
**argv
){
1479 const char *zFile
= (const char *)sqlite3_value_text(argv
[0]);
1481 sqlite3
*db
= sqlite3_context_db_handle(context
);
1484 /* Disallow the load_extension() SQL function unless the SQLITE_LoadExtFunc
1485 ** flag is set. See the sqlite3_enable_load_extension() API.
1487 if( (db
->flags
& SQLITE_LoadExtFunc
)==0 ){
1488 sqlite3_result_error(context
, "not authorized", -1);
1493 zProc
= (const char *)sqlite3_value_text(argv
[1]);
1497 if( zFile
&& sqlite3_load_extension(db
, zFile
, zProc
, &zErrMsg
) ){
1498 sqlite3_result_error(context
, zErrMsg
, -1);
1499 sqlite3_free(zErrMsg
);
1506 ** An instance of the following structure holds the context of a
1507 ** sum() or avg() aggregate computation.
1509 typedef struct SumCtx SumCtx
;
1511 double rSum
; /* Floating point sum */
1512 i64 iSum
; /* Integer sum */
1513 i64 cnt
; /* Number of elements summed */
1514 u8 overflow
; /* True if integer overflow seen */
1515 u8 approx
; /* True if non-integer value was input to the sum */
1519 ** Routines used to compute the sum, average, and total.
1521 ** The SUM() function follows the (broken) SQL standard which means
1522 ** that it returns NULL if it sums over no inputs. TOTAL returns
1523 ** 0.0 in that case. In addition, TOTAL always returns a float where
1524 ** SUM might return an integer if it never encounters a floating point
1525 ** value. TOTAL never fails, but SUM might through an exception if
1526 ** it overflows an integer.
1528 static void sumStep(sqlite3_context
*context
, int argc
, sqlite3_value
**argv
){
1532 UNUSED_PARAMETER(argc
);
1533 p
= sqlite3_aggregate_context(context
, sizeof(*p
));
1534 type
= sqlite3_value_numeric_type(argv
[0]);
1535 if( p
&& type
!=SQLITE_NULL
){
1537 if( type
==SQLITE_INTEGER
){
1538 i64 v
= sqlite3_value_int64(argv
[0]);
1540 if( (p
->approx
|p
->overflow
)==0 && sqlite3AddInt64(&p
->iSum
, v
) ){
1541 p
->approx
= p
->overflow
= 1;
1544 p
->rSum
+= sqlite3_value_double(argv
[0]);
1549 #ifndef SQLITE_OMIT_WINDOWFUNC
1550 static void sumInverse(sqlite3_context
*context
, int argc
, sqlite3_value
**argv
){
1554 UNUSED_PARAMETER(argc
);
1555 p
= sqlite3_aggregate_context(context
, sizeof(*p
));
1556 type
= sqlite3_value_numeric_type(argv
[0]);
1557 /* p is always non-NULL because sumStep() will have been called first
1558 ** to initialize it */
1559 if( ALWAYS(p
) && type
!=SQLITE_NULL
){
1562 assert( type
==SQLITE_INTEGER
|| p
->approx
);
1563 if( type
==SQLITE_INTEGER
&& p
->approx
==0 ){
1564 i64 v
= sqlite3_value_int64(argv
[0]);
1568 p
->rSum
-= sqlite3_value_double(argv
[0]);
1573 # define sumInverse 0
1574 #endif /* SQLITE_OMIT_WINDOWFUNC */
1575 static void sumFinalize(sqlite3_context
*context
){
1577 p
= sqlite3_aggregate_context(context
, 0);
1578 if( p
&& p
->cnt
>0 ){
1580 sqlite3_result_error(context
,"integer overflow",-1);
1581 }else if( p
->approx
){
1582 sqlite3_result_double(context
, p
->rSum
);
1584 sqlite3_result_int64(context
, p
->iSum
);
1588 static void avgFinalize(sqlite3_context
*context
){
1590 p
= sqlite3_aggregate_context(context
, 0);
1591 if( p
&& p
->cnt
>0 ){
1592 sqlite3_result_double(context
, p
->rSum
/(double)p
->cnt
);
1595 static void totalFinalize(sqlite3_context
*context
){
1597 p
= sqlite3_aggregate_context(context
, 0);
1598 /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
1599 sqlite3_result_double(context
, p
? p
->rSum
: (double)0);
1603 ** The following structure keeps track of state information for the
1604 ** count() aggregate function.
1606 typedef struct CountCtx CountCtx
;
1610 int bInverse
; /* True if xInverse() ever called */
1615 ** Routines to implement the count() aggregate function.
1617 static void countStep(sqlite3_context
*context
, int argc
, sqlite3_value
**argv
){
1619 p
= sqlite3_aggregate_context(context
, sizeof(*p
));
1620 if( (argc
==0 || SQLITE_NULL
!=sqlite3_value_type(argv
[0])) && p
){
1624 #ifndef SQLITE_OMIT_DEPRECATED
1625 /* The sqlite3_aggregate_count() function is deprecated. But just to make
1626 ** sure it still operates correctly, verify that its count agrees with our
1627 ** internal count when using count(*) and when the total count can be
1628 ** expressed as a 32-bit integer. */
1629 assert( argc
==1 || p
==0 || p
->n
>0x7fffffff || p
->bInverse
1630 || p
->n
==sqlite3_aggregate_count(context
) );
1633 static void countFinalize(sqlite3_context
*context
){
1635 p
= sqlite3_aggregate_context(context
, 0);
1636 sqlite3_result_int64(context
, p
? p
->n
: 0);
1638 #ifndef SQLITE_OMIT_WINDOWFUNC
1639 static void countInverse(sqlite3_context
*ctx
, int argc
, sqlite3_value
**argv
){
1641 p
= sqlite3_aggregate_context(ctx
, sizeof(*p
));
1642 /* p is always non-NULL since countStep() will have been called first */
1643 if( (argc
==0 || SQLITE_NULL
!=sqlite3_value_type(argv
[0])) && ALWAYS(p
) ){
1651 # define countInverse 0
1652 #endif /* SQLITE_OMIT_WINDOWFUNC */
1655 ** Routines to implement min() and max() aggregate functions.
1657 static void minmaxStep(
1658 sqlite3_context
*context
,
1660 sqlite3_value
**argv
1662 Mem
*pArg
= (Mem
*)argv
[0];
1664 UNUSED_PARAMETER(NotUsed
);
1666 pBest
= (Mem
*)sqlite3_aggregate_context(context
, sizeof(*pBest
));
1667 if( !pBest
) return;
1669 if( sqlite3_value_type(pArg
)==SQLITE_NULL
){
1670 if( pBest
->flags
) sqlite3SkipAccumulatorLoad(context
);
1671 }else if( pBest
->flags
){
1674 CollSeq
*pColl
= sqlite3GetFuncCollSeq(context
);
1675 /* This step function is used for both the min() and max() aggregates,
1676 ** the only difference between the two being that the sense of the
1677 ** comparison is inverted. For the max() aggregate, the
1678 ** sqlite3_user_data() function returns (void *)-1. For min() it
1679 ** returns (void *)db, where db is the sqlite3* database pointer.
1680 ** Therefore the next statement sets variable 'max' to 1 for the max()
1681 ** aggregate, or 0 for min().
1683 max
= sqlite3_user_data(context
)!=0;
1684 cmp
= sqlite3MemCompare(pBest
, pArg
, pColl
);
1685 if( (max
&& cmp
<0) || (!max
&& cmp
>0) ){
1686 sqlite3VdbeMemCopy(pBest
, pArg
);
1688 sqlite3SkipAccumulatorLoad(context
);
1691 pBest
->db
= sqlite3_context_db_handle(context
);
1692 sqlite3VdbeMemCopy(pBest
, pArg
);
1695 static void minMaxValueFinalize(sqlite3_context
*context
, int bValue
){
1696 sqlite3_value
*pRes
;
1697 pRes
= (sqlite3_value
*)sqlite3_aggregate_context(context
, 0);
1700 sqlite3_result_value(context
, pRes
);
1702 if( bValue
==0 ) sqlite3VdbeMemRelease(pRes
);
1705 #ifndef SQLITE_OMIT_WINDOWFUNC
1706 static void minMaxValue(sqlite3_context
*context
){
1707 minMaxValueFinalize(context
, 1);
1710 # define minMaxValue 0
1711 #endif /* SQLITE_OMIT_WINDOWFUNC */
1712 static void minMaxFinalize(sqlite3_context
*context
){
1713 minMaxValueFinalize(context
, 0);
1717 ** group_concat(EXPR, ?SEPARATOR?)
1719 ** The SEPARATOR goes before the EXPR string. This is tragic. The
1720 ** groupConcatInverse() implementation would have been easier if the
1721 ** SEPARATOR were appended after EXPR. And the order is undocumented,
1722 ** so we could change it, in theory. But the old behavior has been
1723 ** around for so long that we dare not, for fear of breaking something.
1726 StrAccum str
; /* The accumulated concatenation */
1727 #ifndef SQLITE_OMIT_WINDOWFUNC
1728 int nAccum
; /* Number of strings presently concatenated */
1729 int nFirstSepLength
; /* Used to detect separator length change */
1730 /* If pnSepLengths!=0, refs an array of inter-string separator lengths,
1731 ** stored as actually incorporated into presently accumulated result.
1732 ** (Hence, its slots in use number nAccum-1 between method calls.)
1733 ** If pnSepLengths==0, nFirstSepLength is the length used throughout.
1739 static void groupConcatStep(
1740 sqlite3_context
*context
,
1742 sqlite3_value
**argv
1745 GroupConcatCtx
*pGCC
;
1748 assert( argc
==1 || argc
==2 );
1749 if( sqlite3_value_type(argv
[0])==SQLITE_NULL
) return;
1750 pGCC
= (GroupConcatCtx
*)sqlite3_aggregate_context(context
, sizeof(*pGCC
));
1752 sqlite3
*db
= sqlite3_context_db_handle(context
);
1753 int firstTerm
= pGCC
->str
.mxAlloc
==0;
1754 pGCC
->str
.mxAlloc
= db
->aLimit
[SQLITE_LIMIT_LENGTH
];
1757 sqlite3_str_appendchar(&pGCC
->str
, 1, ',');
1759 #ifndef SQLITE_OMIT_WINDOWFUNC
1761 pGCC
->nFirstSepLength
= 1;
1764 }else if( !firstTerm
){
1765 zSep
= (char*)sqlite3_value_text(argv
[1]);
1766 nSep
= sqlite3_value_bytes(argv
[1]);
1768 sqlite3_str_append(&pGCC
->str
, zSep
, nSep
);
1770 #ifndef SQLITE_OMIT_WINDOWFUNC
1774 if( nSep
!= pGCC
->nFirstSepLength
|| pGCC
->pnSepLengths
!= 0 ){
1775 int *pnsl
= pGCC
->pnSepLengths
;
1777 /* First separator length variation seen, start tracking them. */
1778 pnsl
= (int*)sqlite3_malloc64((pGCC
->nAccum
+1) * sizeof(int));
1780 int i
= 0, nA
= pGCC
->nAccum
-1;
1781 while( i
<nA
) pnsl
[i
++] = pGCC
->nFirstSepLength
;
1784 pnsl
= (int*)sqlite3_realloc64(pnsl
, pGCC
->nAccum
* sizeof(int));
1787 if( ALWAYS(pGCC
->nAccum
>0) ){
1788 pnsl
[pGCC
->nAccum
-1] = nSep
;
1790 pGCC
->pnSepLengths
= pnsl
;
1792 sqlite3StrAccumSetError(&pGCC
->str
, SQLITE_NOMEM
);
1797 #ifndef SQLITE_OMIT_WINDOWFUNC
1799 pGCC
->nFirstSepLength
= sqlite3_value_bytes(argv
[1]);
1803 zVal
= (char*)sqlite3_value_text(argv
[0]);
1804 nVal
= sqlite3_value_bytes(argv
[0]);
1805 if( zVal
) sqlite3_str_append(&pGCC
->str
, zVal
, nVal
);
1809 #ifndef SQLITE_OMIT_WINDOWFUNC
1810 static void groupConcatInverse(
1811 sqlite3_context
*context
,
1813 sqlite3_value
**argv
1815 GroupConcatCtx
*pGCC
;
1816 assert( argc
==1 || argc
==2 );
1817 (void)argc
; /* Suppress unused parameter warning */
1818 if( sqlite3_value_type(argv
[0])==SQLITE_NULL
) return;
1819 pGCC
= (GroupConcatCtx
*)sqlite3_aggregate_context(context
, sizeof(*pGCC
));
1820 /* pGCC is always non-NULL since groupConcatStep() will have always
1821 ** run frist to initialize it */
1824 /* Must call sqlite3_value_text() to convert the argument into text prior
1825 ** to invoking sqlite3_value_bytes(), in case the text encoding is UTF16 */
1826 (void)sqlite3_value_text(argv
[0]);
1827 nVS
= sqlite3_value_bytes(argv
[0]);
1829 if( pGCC
->pnSepLengths
!=0 ){
1830 assert(pGCC
->nAccum
>= 0);
1831 if( pGCC
->nAccum
>0 ){
1832 nVS
+= *pGCC
->pnSepLengths
;
1833 memmove(pGCC
->pnSepLengths
, pGCC
->pnSepLengths
+1,
1834 (pGCC
->nAccum
-1)*sizeof(int));
1837 /* If removing single accumulated string, harmlessly over-do. */
1838 nVS
+= pGCC
->nFirstSepLength
;
1840 if( nVS
>=(int)pGCC
->str
.nChar
){
1841 pGCC
->str
.nChar
= 0;
1843 pGCC
->str
.nChar
-= nVS
;
1844 memmove(pGCC
->str
.zText
, &pGCC
->str
.zText
[nVS
], pGCC
->str
.nChar
);
1846 if( pGCC
->str
.nChar
==0 ){
1847 pGCC
->str
.mxAlloc
= 0;
1848 sqlite3_free(pGCC
->pnSepLengths
);
1849 pGCC
->pnSepLengths
= 0;
1854 # define groupConcatInverse 0
1855 #endif /* SQLITE_OMIT_WINDOWFUNC */
1856 static void groupConcatFinalize(sqlite3_context
*context
){
1857 GroupConcatCtx
*pGCC
1858 = (GroupConcatCtx
*)sqlite3_aggregate_context(context
, 0);
1860 sqlite3ResultStrAccum(context
, &pGCC
->str
);
1861 #ifndef SQLITE_OMIT_WINDOWFUNC
1862 sqlite3_free(pGCC
->pnSepLengths
);
1866 #ifndef SQLITE_OMIT_WINDOWFUNC
1867 static void groupConcatValue(sqlite3_context
*context
){
1868 GroupConcatCtx
*pGCC
1869 = (GroupConcatCtx
*)sqlite3_aggregate_context(context
, 0);
1871 StrAccum
*pAccum
= &pGCC
->str
;
1872 if( pAccum
->accError
==SQLITE_TOOBIG
){
1873 sqlite3_result_error_toobig(context
);
1874 }else if( pAccum
->accError
==SQLITE_NOMEM
){
1875 sqlite3_result_error_nomem(context
);
1877 const char *zText
= sqlite3_str_value(pAccum
);
1878 sqlite3_result_text(context
, zText
, pAccum
->nChar
, SQLITE_TRANSIENT
);
1883 # define groupConcatValue 0
1884 #endif /* SQLITE_OMIT_WINDOWFUNC */
1887 ** This routine does per-connection function registration. Most
1888 ** of the built-in functions above are part of the global function set.
1889 ** This routine only deals with those that are not global.
1891 void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3
*db
){
1892 int rc
= sqlite3_overload_function(db
, "MATCH", 2);
1893 assert( rc
==SQLITE_NOMEM
|| rc
==SQLITE_OK
);
1894 if( rc
==SQLITE_NOMEM
){
1895 sqlite3OomFault(db
);
1897 /* BEGIN SQLCIPHER */
1898 #ifdef SQLITE_HAS_CODEC
1900 extern void sqlcipher_exportFunc(sqlite3_context
*, int, sqlite3_value
**);
1901 sqlite3CreateFunc(db
, "sqlcipher_export", -1, SQLITE_TEXT
, 0, sqlcipher_exportFunc
, 0, 0, 0, 0, 0);
1903 #ifdef SQLCIPHER_EXT
1904 #include "sqlcipher_funcs_init.h"
1911 ** Re-register the built-in LIKE functions. The caseSensitive
1912 ** parameter determines whether or not the LIKE operator is case
1915 void sqlite3RegisterLikeFunctions(sqlite3
*db
, int caseSensitive
){
1916 struct compareInfo
*pInfo
;
1918 if( caseSensitive
){
1919 pInfo
= (struct compareInfo
*)&likeInfoAlt
;
1920 flags
= SQLITE_FUNC_LIKE
| SQLITE_FUNC_CASE
;
1922 pInfo
= (struct compareInfo
*)&likeInfoNorm
;
1923 flags
= SQLITE_FUNC_LIKE
;
1925 sqlite3CreateFunc(db
, "like", 2, SQLITE_UTF8
, pInfo
, likeFunc
, 0, 0, 0, 0, 0);
1926 sqlite3CreateFunc(db
, "like", 3, SQLITE_UTF8
, pInfo
, likeFunc
, 0, 0, 0, 0, 0);
1927 sqlite3FindFunction(db
, "like", 2, SQLITE_UTF8
, 0)->funcFlags
|= flags
;
1928 sqlite3FindFunction(db
, "like", 3, SQLITE_UTF8
, 0)->funcFlags
|= flags
;
1932 ** pExpr points to an expression which implements a function. If
1933 ** it is appropriate to apply the LIKE optimization to that function
1934 ** then set aWc[0] through aWc[2] to the wildcard characters and the
1935 ** escape character and then return TRUE. If the function is not a
1936 ** LIKE-style function then return FALSE.
1938 ** The expression "a LIKE b ESCAPE c" is only considered a valid LIKE
1939 ** operator if c is a string literal that is exactly one byte in length.
1940 ** That one byte is stored in aWc[3]. aWc[3] is set to zero if there is
1941 ** no ESCAPE clause.
1943 ** *pIsNocase is set to true if uppercase and lowercase are equivalent for
1944 ** the function (default for LIKE). If the function makes the distinction
1945 ** between uppercase and lowercase (as does GLOB) then *pIsNocase is set to
1948 int sqlite3IsLikeFunction(sqlite3
*db
, Expr
*pExpr
, int *pIsNocase
, char *aWc
){
1952 assert( pExpr
->op
==TK_FUNCTION
);
1953 assert( ExprUseXList(pExpr
) );
1954 if( !pExpr
->x
.pList
){
1957 nExpr
= pExpr
->x
.pList
->nExpr
;
1958 assert( !ExprHasProperty(pExpr
, EP_IntValue
) );
1959 pDef
= sqlite3FindFunction(db
, pExpr
->u
.zToken
, nExpr
, SQLITE_UTF8
, 0);
1960 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
1961 if( pDef
==0 ) return 0;
1963 if( NEVER(pDef
==0) || (pDef
->funcFlags
& SQLITE_FUNC_LIKE
)==0 ){
1967 /* The memcpy() statement assumes that the wildcard characters are
1968 ** the first three statements in the compareInfo structure. The
1969 ** asserts() that follow verify that assumption
1971 memcpy(aWc
, pDef
->pUserData
, 3);
1972 assert( (char*)&likeInfoAlt
== (char*)&likeInfoAlt
.matchAll
);
1973 assert( &((char*)&likeInfoAlt
)[1] == (char*)&likeInfoAlt
.matchOne
);
1974 assert( &((char*)&likeInfoAlt
)[2] == (char*)&likeInfoAlt
.matchSet
);
1979 Expr
*pEscape
= pExpr
->x
.pList
->a
[2].pExpr
;
1981 if( pEscape
->op
!=TK_STRING
) return 0;
1982 assert( !ExprHasProperty(pEscape
, EP_IntValue
) );
1983 zEscape
= pEscape
->u
.zToken
;
1984 if( zEscape
[0]==0 || zEscape
[1]!=0 ) return 0;
1985 if( zEscape
[0]==aWc
[0] ) return 0;
1986 if( zEscape
[0]==aWc
[1] ) return 0;
1987 aWc
[3] = zEscape
[0];
1990 *pIsNocase
= (pDef
->funcFlags
& SQLITE_FUNC_CASE
)==0;
1994 /* Mathematical Constants */
1996 # define M_PI 3.141592653589793238462643383279502884
1999 # define M_LN10 2.302585092994045684017991454684364208
2002 # define M_LN2 0.693147180559945309417232121458176568
2006 /* Extra math functions that require linking with -lm
2008 #ifdef SQLITE_ENABLE_MATH_FUNCTIONS
2010 ** Implementation SQL functions:
2016 ** The sqlite3_user_data() pointer is a pointer to the libm implementation
2017 ** of the underlying C function.
2019 static void ceilingFunc(
2020 sqlite3_context
*context
,
2022 sqlite3_value
**argv
2025 switch( sqlite3_value_numeric_type(argv
[0]) ){
2026 case SQLITE_INTEGER
: {
2027 sqlite3_result_int64(context
, sqlite3_value_int64(argv
[0]));
2030 case SQLITE_FLOAT
: {
2031 double (*x
)(double) = (double(*)(double))sqlite3_user_data(context
);
2032 sqlite3_result_double(context
, x(sqlite3_value_double(argv
[0])));
2042 ** On some systems, ceil() and floor() are intrinsic function. You are
2043 ** unable to take a pointer to these functions. Hence, we here wrap them
2044 ** in our own actual functions.
2046 static double xCeil(double x
){ return ceil(x
); }
2047 static double xFloor(double x
){ return floor(x
); }
2050 ** Implementation of SQL functions:
2052 ** ln(X) - natural logarithm
2053 ** log(X) - log X base 10
2054 ** log10(X) - log X base 10
2055 ** log(B,X) - log X base B
2057 static void logFunc(
2058 sqlite3_context
*context
,
2060 sqlite3_value
**argv
2063 assert( argc
==1 || argc
==2 );
2064 switch( sqlite3_value_numeric_type(argv
[0]) ){
2065 case SQLITE_INTEGER
:
2067 x
= sqlite3_value_double(argv
[0]);
2068 if( x
<=0.0 ) return;
2074 switch( sqlite3_value_numeric_type(argv
[0]) ){
2075 case SQLITE_INTEGER
:
2078 if( b
<=0.0 ) return;
2079 x
= sqlite3_value_double(argv
[1]);
2080 if( x
<=0.0 ) return;
2088 switch( SQLITE_PTR_TO_INT(sqlite3_user_data(context
)) ){
2090 /* Convert from natural logarithm to log base 10 */
2094 /* Convert from natural logarithm to log base 2 */
2101 sqlite3_result_double(context
, ans
);
2105 ** Functions to converts degrees to radians and radians to degrees.
2107 static double degToRad(double x
){ return x
*(M_PI
/180.0); }
2108 static double radToDeg(double x
){ return x
*(180.0/M_PI
); }
2111 ** Implementation of 1-argument SQL math functions:
2113 ** exp(X) - Compute e to the X-th power
2115 static void math1Func(
2116 sqlite3_context
*context
,
2118 sqlite3_value
**argv
2122 double (*x
)(double);
2124 type0
= sqlite3_value_numeric_type(argv
[0]);
2125 if( type0
!=SQLITE_INTEGER
&& type0
!=SQLITE_FLOAT
) return;
2126 v0
= sqlite3_value_double(argv
[0]);
2127 x
= (double(*)(double))sqlite3_user_data(context
);
2129 sqlite3_result_double(context
, ans
);
2133 ** Implementation of 2-argument SQL math functions:
2135 ** power(X,Y) - Compute X to the Y-th power
2137 static void math2Func(
2138 sqlite3_context
*context
,
2140 sqlite3_value
**argv
2144 double (*x
)(double,double);
2146 type0
= sqlite3_value_numeric_type(argv
[0]);
2147 if( type0
!=SQLITE_INTEGER
&& type0
!=SQLITE_FLOAT
) return;
2148 type1
= sqlite3_value_numeric_type(argv
[1]);
2149 if( type1
!=SQLITE_INTEGER
&& type1
!=SQLITE_FLOAT
) return;
2150 v0
= sqlite3_value_double(argv
[0]);
2151 v1
= sqlite3_value_double(argv
[1]);
2152 x
= (double(*)(double,double))sqlite3_user_data(context
);
2154 sqlite3_result_double(context
, ans
);
2158 ** Implementation of 0-argument pi() function.
2161 sqlite3_context
*context
,
2163 sqlite3_value
**argv
2166 sqlite3_result_double(context
, M_PI
);
2169 #endif /* SQLITE_ENABLE_MATH_FUNCTIONS */
2172 ** Implementation of sign(X) function.
2174 static void signFunc(
2175 sqlite3_context
*context
,
2177 sqlite3_value
**argv
2181 UNUSED_PARAMETER(argc
);
2183 type0
= sqlite3_value_numeric_type(argv
[0]);
2184 if( type0
!=SQLITE_INTEGER
&& type0
!=SQLITE_FLOAT
) return;
2185 x
= sqlite3_value_double(argv
[0]);
2186 sqlite3_result_int(context
, x
<0.0 ? -1 : x
>0.0 ? +1 : 0);
2190 ** All of the FuncDef structures in the aBuiltinFunc[] array above
2191 ** to the global function hash table. This occurs at start-time (as
2192 ** a consequence of calling sqlite3_initialize()).
2194 ** After this routine runs
2196 void sqlite3RegisterBuiltinFunctions(void){
2198 ** The following array holds FuncDef structures for all of the functions
2199 ** defined in this file.
2201 ** The array cannot be constant since changes are made to the
2202 ** FuncDef.pHash elements at start-time. The elements of this array
2203 ** are read-only after initialization is complete.
2205 ** For peak efficiency, put the most frequently used function last.
2207 static FuncDef aBuiltinFunc
[] = {
2208 /***** Functions only available with SQLITE_TESTCTRL_INTERNAL_FUNCTIONS *****/
2209 #if !defined(SQLITE_UNTESTABLE)
2210 TEST_FUNC(implies_nonnull_row
, 2, INLINEFUNC_implies_nonnull_row
, 0),
2211 TEST_FUNC(expr_compare
, 2, INLINEFUNC_expr_compare
, 0),
2212 TEST_FUNC(expr_implies_expr
, 2, INLINEFUNC_expr_implies_expr
, 0),
2213 TEST_FUNC(affinity
, 1, INLINEFUNC_affinity
, 0),
2214 #endif /* !defined(SQLITE_UNTESTABLE) */
2215 /***** Regular functions *****/
2216 #ifdef SQLITE_SOUNDEX
2217 FUNCTION(soundex
, 1, 0, 0, soundexFunc
),
2219 #ifndef SQLITE_OMIT_LOAD_EXTENSION
2220 SFUNCTION(load_extension
, 1, 0, 0, loadExt
),
2221 SFUNCTION(load_extension
, 2, 0, 0, loadExt
),
2223 #if SQLITE_USER_AUTHENTICATION
2224 FUNCTION(sqlite_crypt
, 2, 0, 0, sqlite3CryptFunc
),
2226 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
2227 DFUNCTION(sqlite_compileoption_used
,1, 0, 0, compileoptionusedFunc
),
2228 DFUNCTION(sqlite_compileoption_get
, 1, 0, 0, compileoptiongetFunc
),
2229 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
2230 INLINE_FUNC(unlikely
, 1, INLINEFUNC_unlikely
, SQLITE_FUNC_UNLIKELY
),
2231 INLINE_FUNC(likelihood
, 2, INLINEFUNC_unlikely
, SQLITE_FUNC_UNLIKELY
),
2232 INLINE_FUNC(likely
, 1, INLINEFUNC_unlikely
, SQLITE_FUNC_UNLIKELY
),
2233 #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
2234 FUNCTION2(sqlite_offset
, 1, 0, 0, noopFunc
, SQLITE_FUNC_OFFSET
|
2235 SQLITE_FUNC_TYPEOF
),
2237 FUNCTION(ltrim
, 1, 1, 0, trimFunc
),
2238 FUNCTION(ltrim
, 2, 1, 0, trimFunc
),
2239 FUNCTION(rtrim
, 1, 2, 0, trimFunc
),
2240 FUNCTION(rtrim
, 2, 2, 0, trimFunc
),
2241 FUNCTION(trim
, 1, 3, 0, trimFunc
),
2242 FUNCTION(trim
, 2, 3, 0, trimFunc
),
2243 FUNCTION(min
, -1, 0, 1, minmaxFunc
),
2244 FUNCTION(min
, 0, 0, 1, 0 ),
2245 WAGGREGATE(min
, 1, 0, 1, minmaxStep
, minMaxFinalize
, minMaxValue
, 0,
2246 SQLITE_FUNC_MINMAX
|SQLITE_FUNC_ANYORDER
),
2247 FUNCTION(max
, -1, 1, 1, minmaxFunc
),
2248 FUNCTION(max
, 0, 1, 1, 0 ),
2249 WAGGREGATE(max
, 1, 1, 1, minmaxStep
, minMaxFinalize
, minMaxValue
, 0,
2250 SQLITE_FUNC_MINMAX
|SQLITE_FUNC_ANYORDER
),
2251 FUNCTION2(typeof, 1, 0, 0, typeofFunc
, SQLITE_FUNC_TYPEOF
),
2252 FUNCTION2(length
, 1, 0, 0, lengthFunc
, SQLITE_FUNC_LENGTH
),
2253 FUNCTION(instr
, 2, 0, 0, instrFunc
),
2254 FUNCTION(printf
, -1, 0, 0, printfFunc
),
2255 FUNCTION(unicode
, 1, 0, 0, unicodeFunc
),
2256 FUNCTION(char, -1, 0, 0, charFunc
),
2257 FUNCTION(abs
, 1, 0, 0, absFunc
),
2258 #ifndef SQLITE_OMIT_FLOATING_POINT
2259 FUNCTION(round
, 1, 0, 0, roundFunc
),
2260 FUNCTION(round
, 2, 0, 0, roundFunc
),
2262 FUNCTION(upper
, 1, 0, 0, upperFunc
),
2263 FUNCTION(lower
, 1, 0, 0, lowerFunc
),
2264 FUNCTION(hex
, 1, 0, 0, hexFunc
),
2265 INLINE_FUNC(ifnull
, 2, INLINEFUNC_coalesce
, 0 ),
2266 VFUNCTION(random
, 0, 0, 0, randomFunc
),
2267 VFUNCTION(randomblob
, 1, 0, 0, randomBlob
),
2268 FUNCTION(nullif
, 2, 0, 1, nullifFunc
),
2269 DFUNCTION(sqlite_version
, 0, 0, 0, versionFunc
),
2270 DFUNCTION(sqlite_source_id
, 0, 0, 0, sourceidFunc
),
2271 FUNCTION(sqlite_log
, 2, 0, 0, errlogFunc
),
2272 FUNCTION(quote
, 1, 0, 0, quoteFunc
),
2273 VFUNCTION(last_insert_rowid
, 0, 0, 0, last_insert_rowid
),
2274 VFUNCTION(changes
, 0, 0, 0, changes
),
2275 VFUNCTION(total_changes
, 0, 0, 0, total_changes
),
2276 FUNCTION(replace
, 3, 0, 0, replaceFunc
),
2277 FUNCTION(zeroblob
, 1, 0, 0, zeroblobFunc
),
2278 FUNCTION(substr
, 2, 0, 0, substrFunc
),
2279 FUNCTION(substr
, 3, 0, 0, substrFunc
),
2280 FUNCTION(substring
, 2, 0, 0, substrFunc
),
2281 FUNCTION(substring
, 3, 0, 0, substrFunc
),
2282 WAGGREGATE(sum
, 1,0,0, sumStep
, sumFinalize
, sumFinalize
, sumInverse
, 0),
2283 WAGGREGATE(total
, 1,0,0, sumStep
,totalFinalize
,totalFinalize
,sumInverse
, 0),
2284 WAGGREGATE(avg
, 1,0,0, sumStep
, avgFinalize
, avgFinalize
, sumInverse
, 0),
2285 WAGGREGATE(count
, 0,0,0, countStep
,
2286 countFinalize
, countFinalize
, countInverse
,
2287 SQLITE_FUNC_COUNT
|SQLITE_FUNC_ANYORDER
),
2288 WAGGREGATE(count
, 1,0,0, countStep
,
2289 countFinalize
, countFinalize
, countInverse
, SQLITE_FUNC_ANYORDER
),
2290 WAGGREGATE(group_concat
, 1, 0, 0, groupConcatStep
,
2291 groupConcatFinalize
, groupConcatValue
, groupConcatInverse
, 0),
2292 WAGGREGATE(group_concat
, 2, 0, 0, groupConcatStep
,
2293 groupConcatFinalize
, groupConcatValue
, groupConcatInverse
, 0),
2295 LIKEFUNC(glob
, 2, &globInfo
, SQLITE_FUNC_LIKE
|SQLITE_FUNC_CASE
),
2296 #ifdef SQLITE_CASE_SENSITIVE_LIKE
2297 LIKEFUNC(like
, 2, &likeInfoAlt
, SQLITE_FUNC_LIKE
|SQLITE_FUNC_CASE
),
2298 LIKEFUNC(like
, 3, &likeInfoAlt
, SQLITE_FUNC_LIKE
|SQLITE_FUNC_CASE
),
2300 LIKEFUNC(like
, 2, &likeInfoNorm
, SQLITE_FUNC_LIKE
),
2301 LIKEFUNC(like
, 3, &likeInfoNorm
, SQLITE_FUNC_LIKE
),
2303 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
2304 FUNCTION(unknown
, -1, 0, 0, unknownFunc
),
2306 FUNCTION(coalesce
, 1, 0, 0, 0 ),
2307 FUNCTION(coalesce
, 0, 0, 0, 0 ),
2308 #ifdef SQLITE_ENABLE_MATH_FUNCTIONS
2309 MFUNCTION(ceil
, 1, xCeil
, ceilingFunc
),
2310 MFUNCTION(ceiling
, 1, xCeil
, ceilingFunc
),
2311 MFUNCTION(floor
, 1, xFloor
, ceilingFunc
),
2312 #if SQLITE_HAVE_C99_MATH_FUNCS
2313 MFUNCTION(trunc
, 1, trunc
, ceilingFunc
),
2315 FUNCTION(ln
, 1, 0, 0, logFunc
),
2316 FUNCTION(log
, 1, 1, 0, logFunc
),
2317 FUNCTION(log10
, 1, 1, 0, logFunc
),
2318 FUNCTION(log2
, 1, 2, 0, logFunc
),
2319 FUNCTION(log
, 2, 0, 0, logFunc
),
2320 MFUNCTION(exp
, 1, exp
, math1Func
),
2321 MFUNCTION(pow
, 2, pow
, math2Func
),
2322 MFUNCTION(power
, 2, pow
, math2Func
),
2323 MFUNCTION(mod
, 2, fmod
, math2Func
),
2324 MFUNCTION(acos
, 1, acos
, math1Func
),
2325 MFUNCTION(asin
, 1, asin
, math1Func
),
2326 MFUNCTION(atan
, 1, atan
, math1Func
),
2327 MFUNCTION(atan2
, 2, atan2
, math2Func
),
2328 MFUNCTION(cos
, 1, cos
, math1Func
),
2329 MFUNCTION(sin
, 1, sin
, math1Func
),
2330 MFUNCTION(tan
, 1, tan
, math1Func
),
2331 MFUNCTION(cosh
, 1, cosh
, math1Func
),
2332 MFUNCTION(sinh
, 1, sinh
, math1Func
),
2333 MFUNCTION(tanh
, 1, tanh
, math1Func
),
2334 #if SQLITE_HAVE_C99_MATH_FUNCS
2335 MFUNCTION(acosh
, 1, acosh
, math1Func
),
2336 MFUNCTION(asinh
, 1, asinh
, math1Func
),
2337 MFUNCTION(atanh
, 1, atanh
, math1Func
),
2339 MFUNCTION(sqrt
, 1, sqrt
, math1Func
),
2340 MFUNCTION(radians
, 1, degToRad
, math1Func
),
2341 MFUNCTION(degrees
, 1, radToDeg
, math1Func
),
2342 FUNCTION(pi
, 0, 0, 0, piFunc
),
2343 #endif /* SQLITE_ENABLE_MATH_FUNCTIONS */
2344 FUNCTION(sign
, 1, 0, 0, signFunc
),
2345 INLINE_FUNC(coalesce
, -1, INLINEFUNC_coalesce
, 0 ),
2346 INLINE_FUNC(iif
, 3, INLINEFUNC_iif
, 0 ),
2348 #ifndef SQLITE_OMIT_ALTERTABLE
2349 sqlite3AlterFunctions();
2351 sqlite3WindowFunctions();
2352 sqlite3RegisterDateTimeFunctions();
2353 sqlite3InsertBuiltinFuncs(aBuiltinFunc
, ArraySize(aBuiltinFunc
));
2355 #if 0 /* Enable to print out how the built-in functions are hashed */
2359 for(i
=0; i
<SQLITE_FUNC_HASH_SZ
; i
++){
2360 printf("FUNC-HASH %02d:", i
);
2361 for(p
=sqlite3BuiltinFunctions
.a
[i
]; p
; p
=p
->u
.pHash
){
2362 int n
= sqlite3Strlen30(p
->zName
);
2363 int h
= p
->zName
[0] + n
;
2364 assert( p
->funcFlags
& SQLITE_FUNC_BUILTIN
);
2365 printf(" %s(%d)", p
->zName
, h
);