monotone

monotone Mtn Source Tree

Root/sqlite/func.c

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

Archive Download this file

Branches

Tags

Quick Links:     www.monotone.ca    -     Downloads    -     Documentation    -     Wiki    -     Code Forge    -     Build Status