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