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