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-language implementations for many of the SQL
13 ** functions of SQLite. (Some function, and in particular the date and
14 ** time functions, are implemented separately.)
15 */
16 #include "sqliteInt.h"
17 #include <stdlib.h>
18 #include <assert.h>
19 #ifndef SQLITE_OMIT_FLOATING_POINT
20 #include <math.h>
21 #endif
22 #include "vdbeInt.h"
23
24 /*
25 ** Return the collating function associated with a function.
26 */
sqlite3GetFuncCollSeq(sqlite3_context * context)27 static CollSeq *sqlite3GetFuncCollSeq(sqlite3_context *context){
28 VdbeOp *pOp;
29 assert( context->pVdbe!=0 );
30 pOp = &context->pVdbe->aOp[context->iOp-1];
31 assert( pOp->opcode==OP_CollSeq );
32 assert( pOp->p4type==P4_COLLSEQ );
33 return pOp->p4.pColl;
34 }
35
36 /*
37 ** Indicate that the accumulator load should be skipped on this
38 ** iteration of the aggregate loop.
39 */
sqlite3SkipAccumulatorLoad(sqlite3_context * context)40 static void sqlite3SkipAccumulatorLoad(sqlite3_context *context){
41 assert( context->isError<=0 );
42 context->isError = -1;
43 context->skipFlag = 1;
44 }
45
46 /*
47 ** Implementation of the non-aggregate min() and max() functions
48 */
minmaxFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)49 static void minmaxFunc(
50 sqlite3_context *context,
51 int argc,
52 sqlite3_value **argv
53 ){
54 int i;
55 int mask; /* 0 for min() or 0xffffffff for max() */
56 int iBest;
57 CollSeq *pColl;
58
59 assert( argc>1 );
60 mask = sqlite3_user_data(context)==0 ? 0 : -1;
61 pColl = sqlite3GetFuncCollSeq(context);
62 assert( pColl );
63 assert( mask==-1 || mask==0 );
64 iBest = 0;
65 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
66 for(i=1; i<argc; i++){
67 if( sqlite3_value_type(argv[i])==SQLITE_NULL ) return;
68 if( (sqlite3MemCompare(argv[iBest], argv[i], pColl)^mask)>=0 ){
69 testcase( mask==0 );
70 iBest = i;
71 }
72 }
73 sqlite3_result_value(context, argv[iBest]);
74 }
75
76 /*
77 ** Return the type of the argument.
78 */
typeofFunc(sqlite3_context * context,int NotUsed,sqlite3_value ** argv)79 static void typeofFunc(
80 sqlite3_context *context,
81 int NotUsed,
82 sqlite3_value **argv
83 ){
84 static const char *azType[] = { "integer", "real", "text", "blob", "null" };
85 int i = sqlite3_value_type(argv[0]) - 1;
86 UNUSED_PARAMETER(NotUsed);
87 assert( i>=0 && i<ArraySize(azType) );
88 assert( SQLITE_INTEGER==1 );
89 assert( SQLITE_FLOAT==2 );
90 assert( SQLITE_TEXT==3 );
91 assert( SQLITE_BLOB==4 );
92 assert( SQLITE_NULL==5 );
93 /* EVIDENCE-OF: R-01470-60482 The sqlite3_value_type(V) interface returns
94 ** the datatype code for the initial datatype of the sqlite3_value object
95 ** V. The returned value is one of SQLITE_INTEGER, SQLITE_FLOAT,
96 ** SQLITE_TEXT, SQLITE_BLOB, or SQLITE_NULL. */
97 sqlite3_result_text(context, azType[i], -1, SQLITE_STATIC);
98 }
99
100 /* subtype(X)
101 **
102 ** Return the subtype of X
103 */
subtypeFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)104 static void subtypeFunc(
105 sqlite3_context *context,
106 int argc,
107 sqlite3_value **argv
108 ){
109 UNUSED_PARAMETER(argc);
110 sqlite3_result_int(context, sqlite3_value_subtype(argv[0]));
111 }
112
113 /*
114 ** Implementation of the length() function
115 */
lengthFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)116 static void lengthFunc(
117 sqlite3_context *context,
118 int argc,
119 sqlite3_value **argv
120 ){
121 assert( argc==1 );
122 UNUSED_PARAMETER(argc);
123 switch( sqlite3_value_type(argv[0]) ){
124 case SQLITE_BLOB:
125 case SQLITE_INTEGER:
126 case SQLITE_FLOAT: {
127 sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
128 break;
129 }
130 case SQLITE_TEXT: {
131 const unsigned char *z = sqlite3_value_text(argv[0]);
132 const unsigned char *z0;
133 unsigned char c;
134 if( z==0 ) return;
135 z0 = z;
136 while( (c = *z)!=0 ){
137 z++;
138 if( c>=0xc0 ){
139 while( (*z & 0xc0)==0x80 ){ z++; z0++; }
140 }
141 }
142 sqlite3_result_int(context, (int)(z-z0));
143 break;
144 }
145 default: {
146 sqlite3_result_null(context);
147 break;
148 }
149 }
150 }
151
152 /*
153 ** Implementation of the abs() function.
154 **
155 ** IMP: R-23979-26855 The abs(X) function returns the absolute value of
156 ** the numeric argument X.
157 */
absFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)158 static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
159 assert( argc==1 );
160 UNUSED_PARAMETER(argc);
161 switch( sqlite3_value_type(argv[0]) ){
162 case SQLITE_INTEGER: {
163 i64 iVal = sqlite3_value_int64(argv[0]);
164 if( iVal<0 ){
165 if( iVal==SMALLEST_INT64 ){
166 /* IMP: R-31676-45509 If X is the integer -9223372036854775808
167 ** then abs(X) throws an integer overflow error since there is no
168 ** equivalent positive 64-bit two complement value. */
169 sqlite3_result_error(context, "integer overflow", -1);
170 return;
171 }
172 iVal = -iVal;
173 }
174 sqlite3_result_int64(context, iVal);
175 break;
176 }
177 case SQLITE_NULL: {
178 /* IMP: R-37434-19929 Abs(X) returns NULL if X is NULL. */
179 sqlite3_result_null(context);
180 break;
181 }
182 default: {
183 /* Because sqlite3_value_double() returns 0.0 if the argument is not
184 ** something that can be converted into a number, we have:
185 ** IMP: R-01992-00519 Abs(X) returns 0.0 if X is a string or blob
186 ** that cannot be converted to a numeric value.
187 */
188 double rVal = sqlite3_value_double(argv[0]);
189 if( rVal<0 ) rVal = -rVal;
190 sqlite3_result_double(context, rVal);
191 break;
192 }
193 }
194 }
195
196 /*
197 ** Implementation of the instr() function.
198 **
199 ** instr(haystack,needle) finds the first occurrence of needle
200 ** in haystack and returns the number of previous characters plus 1,
201 ** or 0 if needle does not occur within haystack.
202 **
203 ** If both haystack and needle are BLOBs, then the result is one more than
204 ** the number of bytes in haystack prior to the first occurrence of needle,
205 ** or 0 if needle never occurs in haystack.
206 */
instrFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)207 static void instrFunc(
208 sqlite3_context *context,
209 int argc,
210 sqlite3_value **argv
211 ){
212 const unsigned char *zHaystack;
213 const unsigned char *zNeedle;
214 int nHaystack;
215 int nNeedle;
216 int typeHaystack, typeNeedle;
217 int N = 1;
218 int isText;
219 unsigned char firstChar;
220 sqlite3_value *pC1 = 0;
221 sqlite3_value *pC2 = 0;
222
223 UNUSED_PARAMETER(argc);
224 typeHaystack = sqlite3_value_type(argv[0]);
225 typeNeedle = sqlite3_value_type(argv[1]);
226 if( typeHaystack==SQLITE_NULL || typeNeedle==SQLITE_NULL ) return;
227 nHaystack = sqlite3_value_bytes(argv[0]);
228 nNeedle = sqlite3_value_bytes(argv[1]);
229 if( nNeedle>0 ){
230 if( typeHaystack==SQLITE_BLOB && typeNeedle==SQLITE_BLOB ){
231 zHaystack = sqlite3_value_blob(argv[0]);
232 zNeedle = sqlite3_value_blob(argv[1]);
233 isText = 0;
234 }else if( typeHaystack!=SQLITE_BLOB && typeNeedle!=SQLITE_BLOB ){
235 zHaystack = sqlite3_value_text(argv[0]);
236 zNeedle = sqlite3_value_text(argv[1]);
237 isText = 1;
238 }else{
239 pC1 = sqlite3_value_dup(argv[0]);
240 zHaystack = sqlite3_value_text(pC1);
241 if( zHaystack==0 ) goto endInstrOOM;
242 nHaystack = sqlite3_value_bytes(pC1);
243 pC2 = sqlite3_value_dup(argv[1]);
244 zNeedle = sqlite3_value_text(pC2);
245 if( zNeedle==0 ) goto endInstrOOM;
246 nNeedle = sqlite3_value_bytes(pC2);
247 isText = 1;
248 }
249 if( zNeedle==0 || (nHaystack && zHaystack==0) ) goto endInstrOOM;
250 firstChar = zNeedle[0];
251 while( nNeedle<=nHaystack
252 && (zHaystack[0]!=firstChar || memcmp(zHaystack, zNeedle, nNeedle)!=0)
253 ){
254 N++;
255 do{
256 nHaystack--;
257 zHaystack++;
258 }while( isText && (zHaystack[0]&0xc0)==0x80 );
259 }
260 if( nNeedle>nHaystack ) N = 0;
261 }
262 sqlite3_result_int(context, N);
263 endInstr:
264 sqlite3_value_free(pC1);
265 sqlite3_value_free(pC2);
266 return;
267 endInstrOOM:
268 sqlite3_result_error_nomem(context);
269 goto endInstr;
270 }
271
272 /*
273 ** Implementation of the printf() (a.k.a. format()) SQL function.
274 */
printfFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)275 static void printfFunc(
276 sqlite3_context *context,
277 int argc,
278 sqlite3_value **argv
279 ){
280 PrintfArguments x;
281 StrAccum str;
282 const char *zFormat;
283 int n;
284 sqlite3 *db = sqlite3_context_db_handle(context);
285
286 if( argc>=1 && (zFormat = (const char*)sqlite3_value_text(argv[0]))!=0 ){
287 x.nArg = argc-1;
288 x.nUsed = 0;
289 x.apArg = argv+1;
290 sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]);
291 str.printfFlags = SQLITE_PRINTF_SQLFUNC;
292 sqlite3_str_appendf(&str, zFormat, &x);
293 n = str.nChar;
294 sqlite3_result_text(context, sqlite3StrAccumFinish(&str), n,
295 SQLITE_DYNAMIC);
296 }
297 }
298
299 /*
300 ** Implementation of the substr() function.
301 **
302 ** substr(x,p1,p2) returns p2 characters of x[] beginning with p1.
303 ** p1 is 1-indexed. So substr(x,1,1) returns the first character
304 ** of x. If x is text, then we actually count UTF-8 characters.
305 ** If x is a blob, then we count bytes.
306 **
307 ** If p1 is negative, then we begin abs(p1) from the end of x[].
308 **
309 ** If p2 is negative, return the p2 characters preceding p1.
310 */
substrFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)311 static void substrFunc(
312 sqlite3_context *context,
313 int argc,
314 sqlite3_value **argv
315 ){
316 const unsigned char *z;
317 const unsigned char *z2;
318 int len;
319 int p0type;
320 i64 p1, p2;
321 int negP2 = 0;
322
323 assert( argc==3 || argc==2 );
324 if( sqlite3_value_type(argv[1])==SQLITE_NULL
325 || (argc==3 && sqlite3_value_type(argv[2])==SQLITE_NULL)
326 ){
327 return;
328 }
329 p0type = sqlite3_value_type(argv[0]);
330 p1 = sqlite3_value_int(argv[1]);
331 if( p0type==SQLITE_BLOB ){
332 len = sqlite3_value_bytes(argv[0]);
333 z = sqlite3_value_blob(argv[0]);
334 if( z==0 ) return;
335 assert( len==sqlite3_value_bytes(argv[0]) );
336 }else{
337 z = sqlite3_value_text(argv[0]);
338 if( z==0 ) return;
339 len = 0;
340 if( p1<0 ){
341 for(z2=z; *z2; len++){
342 SQLITE_SKIP_UTF8(z2);
343 }
344 }
345 }
346 #ifdef SQLITE_SUBSTR_COMPATIBILITY
347 /* If SUBSTR_COMPATIBILITY is defined then substr(X,0,N) work the same as
348 ** as substr(X,1,N) - it returns the first N characters of X. This
349 ** is essentially a back-out of the bug-fix in check-in [5fc125d362df4b8]
350 ** from 2009-02-02 for compatibility of applications that exploited the
351 ** old buggy behavior. */
352 if( p1==0 ) p1 = 1; /* <rdar://problem/6778339> */
353 #endif
354 if( argc==3 ){
355 p2 = sqlite3_value_int(argv[2]);
356 if( p2<0 ){
357 p2 = -p2;
358 negP2 = 1;
359 }
360 }else{
361 p2 = sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH];
362 }
363 if( p1<0 ){
364 p1 += len;
365 if( p1<0 ){
366 p2 += p1;
367 if( p2<0 ) p2 = 0;
368 p1 = 0;
369 }
370 }else if( p1>0 ){
371 p1--;
372 }else if( p2>0 ){
373 p2--;
374 }
375 if( negP2 ){
376 p1 -= p2;
377 if( p1<0 ){
378 p2 += p1;
379 p1 = 0;
380 }
381 }
382 assert( p1>=0 && p2>=0 );
383 if( p0type!=SQLITE_BLOB ){
384 while( *z && p1 ){
385 SQLITE_SKIP_UTF8(z);
386 p1--;
387 }
388 for(z2=z; *z2 && p2; p2--){
389 SQLITE_SKIP_UTF8(z2);
390 }
391 sqlite3_result_text64(context, (char*)z, z2-z, SQLITE_TRANSIENT,
392 SQLITE_UTF8);
393 }else{
394 if( p1+p2>len ){
395 p2 = len-p1;
396 if( p2<0 ) p2 = 0;
397 }
398 sqlite3_result_blob64(context, (char*)&z[p1], (u64)p2, SQLITE_TRANSIENT);
399 }
400 }
401
402 /*
403 ** Implementation of the round() function
404 */
405 #ifndef SQLITE_OMIT_FLOATING_POINT
roundFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)406 static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
407 int n = 0;
408 double r;
409 char *zBuf;
410 assert( argc==1 || argc==2 );
411 if( argc==2 ){
412 if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return;
413 n = sqlite3_value_int(argv[1]);
414 if( n>30 ) n = 30;
415 if( n<0 ) n = 0;
416 }
417 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
418 r = sqlite3_value_double(argv[0]);
419 /* If Y==0 and X will fit in a 64-bit int,
420 ** handle the rounding directly,
421 ** otherwise use printf.
422 */
423 if( r<-4503599627370496.0 || r>+4503599627370496.0 ){
424 /* The value has no fractional part so there is nothing to round */
425 }else if( n==0 ){
426 r = (double)((sqlite_int64)(r+(r<0?-0.5:+0.5)));
427 }else{
428 zBuf = sqlite3_mprintf("%.*f",n,r);
429 if( zBuf==0 ){
430 sqlite3_result_error_nomem(context);
431 return;
432 }
433 sqlite3AtoF(zBuf, &r, sqlite3Strlen30(zBuf), SQLITE_UTF8);
434 sqlite3_free(zBuf);
435 }
436 sqlite3_result_double(context, r);
437 }
438 #endif
439
440 /*
441 ** Allocate nByte bytes of space using sqlite3Malloc(). If the
442 ** allocation fails, call sqlite3_result_error_nomem() to notify
443 ** the database handle that malloc() has failed and return NULL.
444 ** If nByte is larger than the maximum string or blob length, then
445 ** raise an SQLITE_TOOBIG exception and return NULL.
446 */
contextMalloc(sqlite3_context * context,i64 nByte)447 static void *contextMalloc(sqlite3_context *context, i64 nByte){
448 char *z;
449 sqlite3 *db = sqlite3_context_db_handle(context);
450 assert( nByte>0 );
451 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] );
452 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
453 if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
454 sqlite3_result_error_toobig(context);
455 z = 0;
456 }else{
457 z = sqlite3Malloc(nByte);
458 if( !z ){
459 sqlite3_result_error_nomem(context);
460 }
461 }
462 return z;
463 }
464
465 /*
466 ** Implementation of the upper() and lower() SQL functions.
467 */
upperFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)468 static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
469 char *z1;
470 const char *z2;
471 int i, n;
472 UNUSED_PARAMETER(argc);
473 z2 = (char*)sqlite3_value_text(argv[0]);
474 n = sqlite3_value_bytes(argv[0]);
475 /* Verify that the call to _bytes() does not invalidate the _text() pointer */
476 assert( z2==(char*)sqlite3_value_text(argv[0]) );
477 if( z2 ){
478 z1 = contextMalloc(context, ((i64)n)+1);
479 if( z1 ){
480 for(i=0; i<n; i++){
481 z1[i] = (char)sqlite3Toupper(z2[i]);
482 }
483 sqlite3_result_text(context, z1, n, sqlite3_free);
484 }
485 }
486 }
lowerFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)487 static void lowerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
488 char *z1;
489 const char *z2;
490 int i, n;
491 UNUSED_PARAMETER(argc);
492 z2 = (char*)sqlite3_value_text(argv[0]);
493 n = sqlite3_value_bytes(argv[0]);
494 /* Verify that the call to _bytes() does not invalidate the _text() pointer */
495 assert( z2==(char*)sqlite3_value_text(argv[0]) );
496 if( z2 ){
497 z1 = contextMalloc(context, ((i64)n)+1);
498 if( z1 ){
499 for(i=0; i<n; i++){
500 z1[i] = sqlite3Tolower(z2[i]);
501 }
502 sqlite3_result_text(context, z1, n, sqlite3_free);
503 }
504 }
505 }
506
507 /*
508 ** Some functions like COALESCE() and IFNULL() and UNLIKELY() are implemented
509 ** as VDBE code so that unused argument values do not have to be computed.
510 ** However, we still need some kind of function implementation for this
511 ** routines in the function table. The noopFunc macro provides this.
512 ** noopFunc will never be called so it doesn't matter what the implementation
513 ** is. We might as well use the "version()" function as a substitute.
514 */
515 #define noopFunc versionFunc /* Substitute function - never called */
516
517 /*
518 ** Implementation of random(). Return a random integer.
519 */
randomFunc(sqlite3_context * context,int NotUsed,sqlite3_value ** NotUsed2)520 static void randomFunc(
521 sqlite3_context *context,
522 int NotUsed,
523 sqlite3_value **NotUsed2
524 ){
525 sqlite_int64 r;
526 UNUSED_PARAMETER2(NotUsed, NotUsed2);
527 sqlite3_randomness(sizeof(r), &r);
528 if( r<0 ){
529 /* We need to prevent a random number of 0x8000000000000000
530 ** (or -9223372036854775808) since when you do abs() of that
531 ** number of you get the same value back again. To do this
532 ** in a way that is testable, mask the sign bit off of negative
533 ** values, resulting in a positive value. Then take the
534 ** 2s complement of that positive value. The end result can
535 ** therefore be no less than -9223372036854775807.
536 */
537 r = -(r & LARGEST_INT64);
538 }
539 sqlite3_result_int64(context, r);
540 }
541
542 /*
543 ** Implementation of randomblob(N). Return a random blob
544 ** that is N bytes long.
545 */
randomBlob(sqlite3_context * context,int argc,sqlite3_value ** argv)546 static void randomBlob(
547 sqlite3_context *context,
548 int argc,
549 sqlite3_value **argv
550 ){
551 sqlite3_int64 n;
552 unsigned char *p;
553 assert( argc==1 );
554 UNUSED_PARAMETER(argc);
555 n = sqlite3_value_int64(argv[0]);
556 if( n<1 ){
557 n = 1;
558 }
559 p = contextMalloc(context, n);
560 if( p ){
561 sqlite3_randomness(n, p);
562 sqlite3_result_blob(context, (char*)p, n, sqlite3_free);
563 }
564 }
565
566 /*
567 ** Implementation of the last_insert_rowid() SQL function. The return
568 ** value is the same as the sqlite3_last_insert_rowid() API function.
569 */
last_insert_rowid(sqlite3_context * context,int NotUsed,sqlite3_value ** NotUsed2)570 static void last_insert_rowid(
571 sqlite3_context *context,
572 int NotUsed,
573 sqlite3_value **NotUsed2
574 ){
575 sqlite3 *db = sqlite3_context_db_handle(context);
576 UNUSED_PARAMETER2(NotUsed, NotUsed2);
577 /* IMP: R-51513-12026 The last_insert_rowid() SQL function is a
578 ** wrapper around the sqlite3_last_insert_rowid() C/C++ interface
579 ** function. */
580 sqlite3_result_int64(context, sqlite3_last_insert_rowid(db));
581 }
582
583 /*
584 ** Implementation of the changes() SQL function.
585 **
586 ** IMP: R-32760-32347 The changes() SQL function is a wrapper
587 ** around the sqlite3_changes64() C/C++ function and hence follows the
588 ** same rules for counting changes.
589 */
changes(sqlite3_context * context,int NotUsed,sqlite3_value ** NotUsed2)590 static void changes(
591 sqlite3_context *context,
592 int NotUsed,
593 sqlite3_value **NotUsed2
594 ){
595 sqlite3 *db = sqlite3_context_db_handle(context);
596 UNUSED_PARAMETER2(NotUsed, NotUsed2);
597 sqlite3_result_int64(context, sqlite3_changes64(db));
598 }
599
600 /*
601 ** Implementation of the total_changes() SQL function. The return value is
602 ** the same as the sqlite3_total_changes64() API function.
603 */
total_changes(sqlite3_context * context,int NotUsed,sqlite3_value ** NotUsed2)604 static void total_changes(
605 sqlite3_context *context,
606 int NotUsed,
607 sqlite3_value **NotUsed2
608 ){
609 sqlite3 *db = sqlite3_context_db_handle(context);
610 UNUSED_PARAMETER2(NotUsed, NotUsed2);
611 /* IMP: R-11217-42568 This function is a wrapper around the
612 ** sqlite3_total_changes64() C/C++ interface. */
613 sqlite3_result_int64(context, sqlite3_total_changes64(db));
614 }
615
616 /*
617 ** A structure defining how to do GLOB-style comparisons.
618 */
619 struct compareInfo {
620 u8 matchAll; /* "*" or "%" */
621 u8 matchOne; /* "?" or "_" */
622 u8 matchSet; /* "[" or 0 */
623 u8 noCase; /* true to ignore case differences */
624 };
625
626 /*
627 ** For LIKE and GLOB matching on EBCDIC machines, assume that every
628 ** character is exactly one byte in size. Also, provde the Utf8Read()
629 ** macro for fast reading of the next character in the common case where
630 ** the next character is ASCII.
631 */
632 #if defined(SQLITE_EBCDIC)
633 # define sqlite3Utf8Read(A) (*((*A)++))
634 # define Utf8Read(A) (*(A++))
635 #else
636 # define Utf8Read(A) (A[0]<0x80?*(A++):sqlite3Utf8Read(&A))
637 #endif
638
639 static const struct compareInfo globInfo = { '*', '?', '[', 0 };
640 /* The correct SQL-92 behavior is for the LIKE operator to ignore
641 ** case. Thus 'a' LIKE 'A' would be true. */
642 static const struct compareInfo likeInfoNorm = { '%', '_', 0, 1 };
643 /* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator
644 ** is case sensitive causing 'a' LIKE 'A' to be false */
645 static const struct compareInfo likeInfoAlt = { '%', '_', 0, 0 };
646
647 /*
648 ** Possible error returns from patternMatch()
649 */
650 #define SQLITE_MATCH 0
651 #define SQLITE_NOMATCH 1
652 #define SQLITE_NOWILDCARDMATCH 2
653
654 /*
655 ** Compare two UTF-8 strings for equality where the first string is
656 ** a GLOB or LIKE expression. Return values:
657 **
658 ** SQLITE_MATCH: Match
659 ** SQLITE_NOMATCH: No match
660 ** SQLITE_NOWILDCARDMATCH: No match in spite of having * or % wildcards.
661 **
662 ** Globbing rules:
663 **
664 ** '*' Matches any sequence of zero or more characters.
665 **
666 ** '?' Matches exactly one character.
667 **
668 ** [...] Matches one character from the enclosed list of
669 ** characters.
670 **
671 ** [^...] Matches one character not in the enclosed list.
672 **
673 ** With the [...] and [^...] matching, a ']' character can be included
674 ** in the list by making it the first character after '[' or '^'. A
675 ** range of characters can be specified using '-'. Example:
676 ** "[a-z]" matches any single lower-case letter. To match a '-', make
677 ** it the last character in the list.
678 **
679 ** Like matching rules:
680 **
681 ** '%' Matches any sequence of zero or more characters
682 **
683 *** '_' Matches any one character
684 **
685 ** Ec Where E is the "esc" character and c is any other
686 ** character, including '%', '_', and esc, match exactly c.
687 **
688 ** The comments within this routine usually assume glob matching.
689 **
690 ** This routine is usually quick, but can be N**2 in the worst case.
691 */
patternCompare(const u8 * zPattern,const u8 * zString,const struct compareInfo * pInfo,u32 matchOther)692 static int patternCompare(
693 const u8 *zPattern, /* The glob pattern */
694 const u8 *zString, /* The string to compare against the glob */
695 const struct compareInfo *pInfo, /* Information about how to do the compare */
696 u32 matchOther /* The escape char (LIKE) or '[' (GLOB) */
697 ){
698 u32 c, c2; /* Next pattern and input string chars */
699 u32 matchOne = pInfo->matchOne; /* "?" or "_" */
700 u32 matchAll = pInfo->matchAll; /* "*" or "%" */
701 u8 noCase = pInfo->noCase; /* True if uppercase==lowercase */
702 const u8 *zEscaped = 0; /* One past the last escaped input char */
703
704 while( (c = Utf8Read(zPattern))!=0 ){
705 if( c==matchAll ){ /* Match "*" */
706 /* Skip over multiple "*" characters in the pattern. If there
707 ** are also "?" characters, skip those as well, but consume a
708 ** single character of the input string for each "?" skipped */
709 while( (c=Utf8Read(zPattern)) == matchAll
710 || (c == matchOne && matchOne!=0) ){
711 if( c==matchOne && sqlite3Utf8Read(&zString)==0 ){
712 return SQLITE_NOWILDCARDMATCH;
713 }
714 }
715 if( c==0 ){
716 return SQLITE_MATCH; /* "*" at the end of the pattern matches */
717 }else if( c==matchOther ){
718 if( pInfo->matchSet==0 ){
719 c = sqlite3Utf8Read(&zPattern);
720 if( c==0 ) return SQLITE_NOWILDCARDMATCH;
721 }else{
722 /* "[...]" immediately follows the "*". We have to do a slow
723 ** recursive search in this case, but it is an unusual case. */
724 assert( matchOther<0x80 ); /* '[' is a single-byte character */
725 while( *zString ){
726 int bMatch = patternCompare(&zPattern[-1],zString,pInfo,matchOther);
727 if( bMatch!=SQLITE_NOMATCH ) return bMatch;
728 SQLITE_SKIP_UTF8(zString);
729 }
730 return SQLITE_NOWILDCARDMATCH;
731 }
732 }
733
734 /* At this point variable c contains the first character of the
735 ** pattern string past the "*". Search in the input string for the
736 ** first matching character and recursively continue the match from
737 ** that point.
738 **
739 ** For a case-insensitive search, set variable cx to be the same as
740 ** c but in the other case and search the input string for either
741 ** c or cx.
742 */
743 if( c<0x80 ){
744 char zStop[3];
745 int bMatch;
746 if( noCase ){
747 zStop[0] = sqlite3Toupper(c);
748 zStop[1] = sqlite3Tolower(c);
749 zStop[2] = 0;
750 }else{
751 zStop[0] = c;
752 zStop[1] = 0;
753 }
754 while(1){
755 zString += strcspn((const char*)zString, zStop);
756 if( zString[0]==0 ) break;
757 zString++;
758 bMatch = patternCompare(zPattern,zString,pInfo,matchOther);
759 if( bMatch!=SQLITE_NOMATCH ) return bMatch;
760 }
761 }else{
762 int bMatch;
763 while( (c2 = Utf8Read(zString))!=0 ){
764 if( c2!=c ) continue;
765 bMatch = patternCompare(zPattern,zString,pInfo,matchOther);
766 if( bMatch!=SQLITE_NOMATCH ) return bMatch;
767 }
768 }
769 return SQLITE_NOWILDCARDMATCH;
770 }
771 if( c==matchOther ){
772 if( pInfo->matchSet==0 ){
773 c = sqlite3Utf8Read(&zPattern);
774 if( c==0 ) return SQLITE_NOMATCH;
775 zEscaped = zPattern;
776 }else{
777 u32 prior_c = 0;
778 int seen = 0;
779 int invert = 0;
780 c = sqlite3Utf8Read(&zString);
781 if( c==0 ) return SQLITE_NOMATCH;
782 c2 = sqlite3Utf8Read(&zPattern);
783 if( c2=='^' ){
784 invert = 1;
785 c2 = sqlite3Utf8Read(&zPattern);
786 }
787 if( c2==']' ){
788 if( c==']' ) seen = 1;
789 c2 = sqlite3Utf8Read(&zPattern);
790 }
791 while( c2 && c2!=']' ){
792 if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){
793 c2 = sqlite3Utf8Read(&zPattern);
794 if( c>=prior_c && c<=c2 ) seen = 1;
795 prior_c = 0;
796 }else{
797 if( c==c2 ){
798 seen = 1;
799 }
800 prior_c = c2;
801 }
802 c2 = sqlite3Utf8Read(&zPattern);
803 }
804 if( c2==0 || (seen ^ invert)==0 ){
805 return SQLITE_NOMATCH;
806 }
807 continue;
808 }
809 }
810 c2 = Utf8Read(zString);
811 if( c==c2 ) continue;
812 if( noCase && sqlite3Tolower(c)==sqlite3Tolower(c2) && c<0x80 && c2<0x80 ){
813 continue;
814 }
815 if( c==matchOne && zPattern!=zEscaped && c2!=0 ) continue;
816 return SQLITE_NOMATCH;
817 }
818 return *zString==0 ? SQLITE_MATCH : SQLITE_NOMATCH;
819 }
820
821 /*
822 ** The sqlite3_strglob() interface. Return 0 on a match (like strcmp()) and
823 ** non-zero if there is no match.
824 */
sqlite3_strglob(const char * zGlobPattern,const char * zString)825 int sqlite3_strglob(const char *zGlobPattern, const char *zString){
826 if( zString==0 ){
827 return zGlobPattern!=0;
828 }else if( zGlobPattern==0 ){
829 return 1;
830 }else {
831 return patternCompare((u8*)zGlobPattern, (u8*)zString, &globInfo, '[');
832 }
833 }
834
835 /*
836 ** The sqlite3_strlike() interface. Return 0 on a match and non-zero for
837 ** a miss - like strcmp().
838 */
sqlite3_strlike(const char * zPattern,const char * zStr,unsigned int esc)839 int sqlite3_strlike(const char *zPattern, const char *zStr, unsigned int esc){
840 if( zStr==0 ){
841 return zPattern!=0;
842 }else if( zPattern==0 ){
843 return 1;
844 }else{
845 return patternCompare((u8*)zPattern, (u8*)zStr, &likeInfoNorm, esc);
846 }
847 }
848
849 /*
850 ** Count the number of times that the LIKE operator (or GLOB which is
851 ** just a variation of LIKE) gets called. This is used for testing
852 ** only.
853 */
854 #ifdef SQLITE_TEST
855 int sqlite3_like_count = 0;
856 #endif
857
858
859 /*
860 ** Implementation of the like() SQL function. This function implements
861 ** the build-in LIKE operator. The first argument to the function is the
862 ** pattern and the second argument is the string. So, the SQL statements:
863 **
864 ** A LIKE B
865 **
866 ** is implemented as like(B,A).
867 **
868 ** This same function (with a different compareInfo structure) computes
869 ** the GLOB operator.
870 */
likeFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)871 static void likeFunc(
872 sqlite3_context *context,
873 int argc,
874 sqlite3_value **argv
875 ){
876 const unsigned char *zA, *zB;
877 u32 escape;
878 int nPat;
879 sqlite3 *db = sqlite3_context_db_handle(context);
880 struct compareInfo *pInfo = sqlite3_user_data(context);
881 struct compareInfo backupInfo;
882
883 #ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS
884 if( sqlite3_value_type(argv[0])==SQLITE_BLOB
885 || sqlite3_value_type(argv[1])==SQLITE_BLOB
886 ){
887 #ifdef SQLITE_TEST
888 sqlite3_like_count++;
889 #endif
890 sqlite3_result_int(context, 0);
891 return;
892 }
893 #endif
894
895 /* Limit the length of the LIKE or GLOB pattern to avoid problems
896 ** of deep recursion and N*N behavior in patternCompare().
897 */
898 nPat = sqlite3_value_bytes(argv[0]);
899 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] );
900 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 );
901 if( nPat > db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){
902 sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);
903 return;
904 }
905 if( argc==3 ){
906 /* The escape character string must consist of a single UTF-8 character.
907 ** Otherwise, return an error.
908 */
909 const unsigned char *zEsc = sqlite3_value_text(argv[2]);
910 if( zEsc==0 ) return;
911 if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){
912 sqlite3_result_error(context,
913 "ESCAPE expression must be a single character", -1);
914 return;
915 }
916 escape = sqlite3Utf8Read(&zEsc);
917 if( escape==pInfo->matchAll || escape==pInfo->matchOne ){
918 memcpy(&backupInfo, pInfo, sizeof(backupInfo));
919 pInfo = &backupInfo;
920 if( escape==pInfo->matchAll ) pInfo->matchAll = 0;
921 if( escape==pInfo->matchOne ) pInfo->matchOne = 0;
922 }
923 }else{
924 escape = pInfo->matchSet;
925 }
926 zB = sqlite3_value_text(argv[0]);
927 zA = sqlite3_value_text(argv[1]);
928 if( zA && zB ){
929 #ifdef SQLITE_TEST
930 sqlite3_like_count++;
931 #endif
932 sqlite3_result_int(context,
933 patternCompare(zB, zA, pInfo, escape)==SQLITE_MATCH);
934 }
935 }
936
937 /*
938 ** Implementation of the NULLIF(x,y) function. The result is the first
939 ** argument if the arguments are different. The result is NULL if the
940 ** arguments are equal to each other.
941 */
nullifFunc(sqlite3_context * context,int NotUsed,sqlite3_value ** argv)942 static void nullifFunc(
943 sqlite3_context *context,
944 int NotUsed,
945 sqlite3_value **argv
946 ){
947 CollSeq *pColl = sqlite3GetFuncCollSeq(context);
948 UNUSED_PARAMETER(NotUsed);
949 if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){
950 sqlite3_result_value(context, argv[0]);
951 }
952 }
953
954 /*
955 ** Implementation of the sqlite_version() function. The result is the version
956 ** of the SQLite library that is running.
957 */
versionFunc(sqlite3_context * context,int NotUsed,sqlite3_value ** NotUsed2)958 static void versionFunc(
959 sqlite3_context *context,
960 int NotUsed,
961 sqlite3_value **NotUsed2
962 ){
963 UNUSED_PARAMETER2(NotUsed, NotUsed2);
964 /* IMP: R-48699-48617 This function is an SQL wrapper around the
965 ** sqlite3_libversion() C-interface. */
966 sqlite3_result_text(context, sqlite3_libversion(), -1, SQLITE_STATIC);
967 }
968
969 /*
970 ** Implementation of the sqlite_source_id() function. The result is a string
971 ** that identifies the particular version of the source code used to build
972 ** SQLite.
973 */
sourceidFunc(sqlite3_context * context,int NotUsed,sqlite3_value ** NotUsed2)974 static void sourceidFunc(
975 sqlite3_context *context,
976 int NotUsed,
977 sqlite3_value **NotUsed2
978 ){
979 UNUSED_PARAMETER2(NotUsed, NotUsed2);
980 /* IMP: R-24470-31136 This function is an SQL wrapper around the
981 ** sqlite3_sourceid() C interface. */
982 sqlite3_result_text(context, sqlite3_sourceid(), -1, SQLITE_STATIC);
983 }
984
985 /*
986 ** Implementation of the sqlite_log() function. This is a wrapper around
987 ** sqlite3_log(). The return value is NULL. The function exists purely for
988 ** its side-effects.
989 */
errlogFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)990 static void errlogFunc(
991 sqlite3_context *context,
992 int argc,
993 sqlite3_value **argv
994 ){
995 UNUSED_PARAMETER(argc);
996 UNUSED_PARAMETER(context);
997 sqlite3_log(sqlite3_value_int(argv[0]), "%s", sqlite3_value_text(argv[1]));
998 }
999
1000 /*
1001 ** Implementation of the sqlite_compileoption_used() function.
1002 ** The result is an integer that identifies if the compiler option
1003 ** was used to build SQLite.
1004 */
1005 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
compileoptionusedFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)1006 static void compileoptionusedFunc(
1007 sqlite3_context *context,
1008 int argc,
1009 sqlite3_value **argv
1010 ){
1011 const char *zOptName;
1012 assert( argc==1 );
1013 UNUSED_PARAMETER(argc);
1014 /* IMP: R-39564-36305 The sqlite_compileoption_used() SQL
1015 ** function is a wrapper around the sqlite3_compileoption_used() C/C++
1016 ** function.
1017 */
1018 if( (zOptName = (const char*)sqlite3_value_text(argv[0]))!=0 ){
1019 sqlite3_result_int(context, sqlite3_compileoption_used(zOptName));
1020 }
1021 }
1022 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
1023
1024 /*
1025 ** Implementation of the sqlite_compileoption_get() function.
1026 ** The result is a string that identifies the compiler options
1027 ** used to build SQLite.
1028 */
1029 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
compileoptiongetFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)1030 static void compileoptiongetFunc(
1031 sqlite3_context *context,
1032 int argc,
1033 sqlite3_value **argv
1034 ){
1035 int n;
1036 assert( argc==1 );
1037 UNUSED_PARAMETER(argc);
1038 /* IMP: R-04922-24076 The sqlite_compileoption_get() SQL function
1039 ** is a wrapper around the sqlite3_compileoption_get() C/C++ function.
1040 */
1041 n = sqlite3_value_int(argv[0]);
1042 sqlite3_result_text(context, sqlite3_compileoption_get(n), -1, SQLITE_STATIC);
1043 }
1044 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
1045
1046 /* Array for converting from half-bytes (nybbles) into ASCII hex
1047 ** digits. */
1048 static const char hexdigits[] = {
1049 '0', '1', '2', '3', '4', '5', '6', '7',
1050 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
1051 };
1052
1053 /*
1054 ** Append to pStr text that is the SQL literal representation of the
1055 ** value contained in pValue.
1056 */
sqlite3QuoteValue(StrAccum * pStr,sqlite3_value * pValue)1057 void sqlite3QuoteValue(StrAccum *pStr, sqlite3_value *pValue){
1058 /* As currently implemented, the string must be initially empty.
1059 ** we might relax this requirement in the future, but that will
1060 ** require enhancements to the implementation. */
1061 assert( pStr!=0 && pStr->nChar==0 );
1062
1063 switch( sqlite3_value_type(pValue) ){
1064 case SQLITE_FLOAT: {
1065 double r1, r2;
1066 const char *zVal;
1067 r1 = sqlite3_value_double(pValue);
1068 sqlite3_str_appendf(pStr, "%!.15g", r1);
1069 zVal = sqlite3_str_value(pStr);
1070 if( zVal ){
1071 sqlite3AtoF(zVal, &r2, pStr->nChar, SQLITE_UTF8);
1072 if( r1!=r2 ){
1073 sqlite3_str_reset(pStr);
1074 sqlite3_str_appendf(pStr, "%!.20e", r1);
1075 }
1076 }
1077 break;
1078 }
1079 case SQLITE_INTEGER: {
1080 sqlite3_str_appendf(pStr, "%lld", sqlite3_value_int64(pValue));
1081 break;
1082 }
1083 case SQLITE_BLOB: {
1084 char const *zBlob = sqlite3_value_blob(pValue);
1085 int nBlob = sqlite3_value_bytes(pValue);
1086 assert( zBlob==sqlite3_value_blob(pValue) ); /* No encoding change */
1087 sqlite3StrAccumEnlarge(pStr, nBlob*2 + 4);
1088 if( pStr->accError==0 ){
1089 char *zText = pStr->zText;
1090 int i;
1091 for(i=0; i<nBlob; i++){
1092 zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F];
1093 zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F];
1094 }
1095 zText[(nBlob*2)+2] = '\'';
1096 zText[(nBlob*2)+3] = '\0';
1097 zText[0] = 'X';
1098 zText[1] = '\'';
1099 pStr->nChar = nBlob*2 + 3;
1100 }
1101 break;
1102 }
1103 case SQLITE_TEXT: {
1104 const unsigned char *zArg = sqlite3_value_text(pValue);
1105 sqlite3_str_appendf(pStr, "%Q", zArg);
1106 break;
1107 }
1108 default: {
1109 assert( sqlite3_value_type(pValue)==SQLITE_NULL );
1110 sqlite3_str_append(pStr, "NULL", 4);
1111 break;
1112 }
1113 }
1114 }
1115
1116 /*
1117 ** Implementation of the QUOTE() function.
1118 **
1119 ** The quote(X) function returns the text of an SQL literal which is the
1120 ** value of its argument suitable for inclusion into an SQL statement.
1121 ** Strings are surrounded by single-quotes with escapes on interior quotes
1122 ** as needed. BLOBs are encoded as hexadecimal literals. Strings with
1123 ** embedded NUL characters cannot be represented as string literals in SQL
1124 ** and hence the returned string literal is truncated prior to the first NUL.
1125 */
quoteFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)1126 static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
1127 sqlite3_str str;
1128 sqlite3 *db = sqlite3_context_db_handle(context);
1129 assert( argc==1 );
1130 UNUSED_PARAMETER(argc);
1131 sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]);
1132 sqlite3QuoteValue(&str,argv[0]);
1133 sqlite3_result_text(context, sqlite3StrAccumFinish(&str), str.nChar,
1134 SQLITE_DYNAMIC);
1135 if( str.accError!=SQLITE_OK ){
1136 sqlite3_result_null(context);
1137 sqlite3_result_error_code(context, str.accError);
1138 }
1139 }
1140
1141 /*
1142 ** The unicode() function. Return the integer unicode code-point value
1143 ** for the first character of the input string.
1144 */
unicodeFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)1145 static void unicodeFunc(
1146 sqlite3_context *context,
1147 int argc,
1148 sqlite3_value **argv
1149 ){
1150 const unsigned char *z = sqlite3_value_text(argv[0]);
1151 (void)argc;
1152 if( z && z[0] ) sqlite3_result_int(context, sqlite3Utf8Read(&z));
1153 }
1154
1155 /*
1156 ** The char() function takes zero or more arguments, each of which is
1157 ** an integer. It constructs a string where each character of the string
1158 ** is the unicode character for the corresponding integer argument.
1159 */
charFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)1160 static void charFunc(
1161 sqlite3_context *context,
1162 int argc,
1163 sqlite3_value **argv
1164 ){
1165 unsigned char *z, *zOut;
1166 int i;
1167 zOut = z = sqlite3_malloc64( argc*4+1 );
1168 if( z==0 ){
1169 sqlite3_result_error_nomem(context);
1170 return;
1171 }
1172 for(i=0; i<argc; i++){
1173 sqlite3_int64 x;
1174 unsigned c;
1175 x = sqlite3_value_int64(argv[i]);
1176 if( x<0 || x>0x10ffff ) x = 0xfffd;
1177 c = (unsigned)(x & 0x1fffff);
1178 if( c<0x00080 ){
1179 *zOut++ = (u8)(c&0xFF);
1180 }else if( c<0x00800 ){
1181 *zOut++ = 0xC0 + (u8)((c>>6)&0x1F);
1182 *zOut++ = 0x80 + (u8)(c & 0x3F);
1183 }else if( c<0x10000 ){
1184 *zOut++ = 0xE0 + (u8)((c>>12)&0x0F);
1185 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);
1186 *zOut++ = 0x80 + (u8)(c & 0x3F);
1187 }else{
1188 *zOut++ = 0xF0 + (u8)((c>>18) & 0x07);
1189 *zOut++ = 0x80 + (u8)((c>>12) & 0x3F);
1190 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);
1191 *zOut++ = 0x80 + (u8)(c & 0x3F);
1192 } \
1193 }
1194 sqlite3_result_text64(context, (char*)z, zOut-z, sqlite3_free, SQLITE_UTF8);
1195 }
1196
1197 /*
1198 ** The hex() function. Interpret the argument as a blob. Return
1199 ** a hexadecimal rendering as text.
1200 */
hexFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)1201 static void hexFunc(
1202 sqlite3_context *context,
1203 int argc,
1204 sqlite3_value **argv
1205 ){
1206 int i, n;
1207 const unsigned char *pBlob;
1208 char *zHex, *z;
1209 assert( argc==1 );
1210 UNUSED_PARAMETER(argc);
1211 pBlob = sqlite3_value_blob(argv[0]);
1212 n = sqlite3_value_bytes(argv[0]);
1213 assert( pBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */
1214 z = zHex = contextMalloc(context, ((i64)n)*2 + 1);
1215 if( zHex ){
1216 for(i=0; i<n; i++, pBlob++){
1217 unsigned char c = *pBlob;
1218 *(z++) = hexdigits[(c>>4)&0xf];
1219 *(z++) = hexdigits[c&0xf];
1220 }
1221 *z = 0;
1222 sqlite3_result_text(context, zHex, n*2, sqlite3_free);
1223 }
1224 }
1225
1226 /*
1227 ** The zeroblob(N) function returns a zero-filled blob of size N bytes.
1228 */
zeroblobFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)1229 static void zeroblobFunc(
1230 sqlite3_context *context,
1231 int argc,
1232 sqlite3_value **argv
1233 ){
1234 i64 n;
1235 int rc;
1236 assert( argc==1 );
1237 UNUSED_PARAMETER(argc);
1238 n = sqlite3_value_int64(argv[0]);
1239 if( n<0 ) n = 0;
1240 rc = sqlite3_result_zeroblob64(context, n); /* IMP: R-00293-64994 */
1241 if( rc ){
1242 sqlite3_result_error_code(context, rc);
1243 }
1244 }
1245
1246 /*
1247 ** The replace() function. Three arguments are all strings: call
1248 ** them A, B, and C. The result is also a string which is derived
1249 ** from A by replacing every occurrence of B with C. The match
1250 ** must be exact. Collating sequences are not used.
1251 */
replaceFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)1252 static void replaceFunc(
1253 sqlite3_context *context,
1254 int argc,
1255 sqlite3_value **argv
1256 ){
1257 const unsigned char *zStr; /* The input string A */
1258 const unsigned char *zPattern; /* The pattern string B */
1259 const unsigned char *zRep; /* The replacement string C */
1260 unsigned char *zOut; /* The output */
1261 int nStr; /* Size of zStr */
1262 int nPattern; /* Size of zPattern */
1263 int nRep; /* Size of zRep */
1264 i64 nOut; /* Maximum size of zOut */
1265 int loopLimit; /* Last zStr[] that might match zPattern[] */
1266 int i, j; /* Loop counters */
1267 unsigned cntExpand; /* Number zOut expansions */
1268 sqlite3 *db = sqlite3_context_db_handle(context);
1269
1270 assert( argc==3 );
1271 UNUSED_PARAMETER(argc);
1272 zStr = sqlite3_value_text(argv[0]);
1273 if( zStr==0 ) return;
1274 nStr = sqlite3_value_bytes(argv[0]);
1275 assert( zStr==sqlite3_value_text(argv[0]) ); /* No encoding change */
1276 zPattern = sqlite3_value_text(argv[1]);
1277 if( zPattern==0 ){
1278 assert( sqlite3_value_type(argv[1])==SQLITE_NULL
1279 || sqlite3_context_db_handle(context)->mallocFailed );
1280 return;
1281 }
1282 if( zPattern[0]==0 ){
1283 assert( sqlite3_value_type(argv[1])!=SQLITE_NULL );
1284 sqlite3_result_value(context, argv[0]);
1285 return;
1286 }
1287 nPattern = sqlite3_value_bytes(argv[1]);
1288 assert( zPattern==sqlite3_value_text(argv[1]) ); /* No encoding change */
1289 zRep = sqlite3_value_text(argv[2]);
1290 if( zRep==0 ) return;
1291 nRep = sqlite3_value_bytes(argv[2]);
1292 assert( zRep==sqlite3_value_text(argv[2]) );
1293 nOut = nStr + 1;
1294 assert( nOut<SQLITE_MAX_LENGTH );
1295 zOut = contextMalloc(context, (i64)nOut);
1296 if( zOut==0 ){
1297 return;
1298 }
1299 loopLimit = nStr - nPattern;
1300 cntExpand = 0;
1301 for(i=j=0; i<=loopLimit; i++){
1302 if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){
1303 zOut[j++] = zStr[i];
1304 }else{
1305 if( nRep>nPattern ){
1306 nOut += nRep - nPattern;
1307 testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] );
1308 testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] );
1309 if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
1310 sqlite3_result_error_toobig(context);
1311 sqlite3_free(zOut);
1312 return;
1313 }
1314 cntExpand++;
1315 if( (cntExpand&(cntExpand-1))==0 ){
1316 /* Grow the size of the output buffer only on substitutions
1317 ** whose index is a power of two: 1, 2, 4, 8, 16, 32, ... */
1318 u8 *zOld;
1319 zOld = zOut;
1320 zOut = sqlite3Realloc(zOut, (int)nOut + (nOut - nStr - 1));
1321 if( zOut==0 ){
1322 sqlite3_result_error_nomem(context);
1323 sqlite3_free(zOld);
1324 return;
1325 }
1326 }
1327 }
1328 memcpy(&zOut[j], zRep, nRep);
1329 j += nRep;
1330 i += nPattern-1;
1331 }
1332 }
1333 assert( j+nStr-i+1<=nOut );
1334 memcpy(&zOut[j], &zStr[i], nStr-i);
1335 j += nStr - i;
1336 assert( j<=nOut );
1337 zOut[j] = 0;
1338 sqlite3_result_text(context, (char*)zOut, j, sqlite3_free);
1339 }
1340
1341 /*
1342 ** Implementation of the TRIM(), LTRIM(), and RTRIM() functions.
1343 ** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both.
1344 */
trimFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)1345 static void trimFunc(
1346 sqlite3_context *context,
1347 int argc,
1348 sqlite3_value **argv
1349 ){
1350 const unsigned char *zIn; /* Input string */
1351 const unsigned char *zCharSet; /* Set of characters to trim */
1352 unsigned int nIn; /* Number of bytes in input */
1353 int flags; /* 1: trimleft 2: trimright 3: trim */
1354 int i; /* Loop counter */
1355 unsigned int *aLen = 0; /* Length of each character in zCharSet */
1356 unsigned char **azChar = 0; /* Individual characters in zCharSet */
1357 int nChar; /* Number of characters in zCharSet */
1358
1359 if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
1360 return;
1361 }
1362 zIn = sqlite3_value_text(argv[0]);
1363 if( zIn==0 ) return;
1364 nIn = (unsigned)sqlite3_value_bytes(argv[0]);
1365 assert( zIn==sqlite3_value_text(argv[0]) );
1366 if( argc==1 ){
1367 static const unsigned lenOne[] = { 1 };
1368 static unsigned char * const azOne[] = { (u8*)" " };
1369 nChar = 1;
1370 aLen = (unsigned*)lenOne;
1371 azChar = (unsigned char **)azOne;
1372 zCharSet = 0;
1373 }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){
1374 return;
1375 }else{
1376 const unsigned char *z;
1377 for(z=zCharSet, nChar=0; *z; nChar++){
1378 SQLITE_SKIP_UTF8(z);
1379 }
1380 if( nChar>0 ){
1381 azChar = contextMalloc(context,
1382 ((i64)nChar)*(sizeof(char*)+sizeof(unsigned)));
1383 if( azChar==0 ){
1384 return;
1385 }
1386 aLen = (unsigned*)&azChar[nChar];
1387 for(z=zCharSet, nChar=0; *z; nChar++){
1388 azChar[nChar] = (unsigned char *)z;
1389 SQLITE_SKIP_UTF8(z);
1390 aLen[nChar] = (unsigned)(z - azChar[nChar]);
1391 }
1392 }
1393 }
1394 if( nChar>0 ){
1395 flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context));
1396 if( flags & 1 ){
1397 while( nIn>0 ){
1398 unsigned int len = 0;
1399 for(i=0; i<nChar; i++){
1400 len = aLen[i];
1401 if( len<=nIn && memcmp(zIn, azChar[i], len)==0 ) break;
1402 }
1403 if( i>=nChar ) break;
1404 zIn += len;
1405 nIn -= len;
1406 }
1407 }
1408 if( flags & 2 ){
1409 while( nIn>0 ){
1410 unsigned int len = 0;
1411 for(i=0; i<nChar; i++){
1412 len = aLen[i];
1413 if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break;
1414 }
1415 if( i>=nChar ) break;
1416 nIn -= len;
1417 }
1418 }
1419 if( zCharSet ){
1420 sqlite3_free(azChar);
1421 }
1422 }
1423 sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT);
1424 }
1425
1426
1427 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
1428 /*
1429 ** The "unknown" function is automatically substituted in place of
1430 ** any unrecognized function name when doing an EXPLAIN or EXPLAIN QUERY PLAN
1431 ** when the SQLITE_ENABLE_UNKNOWN_FUNCTION compile-time option is used.
1432 ** When the "sqlite3" command-line shell is built using this functionality,
1433 ** that allows an EXPLAIN or EXPLAIN QUERY PLAN for complex queries
1434 ** involving application-defined functions to be examined in a generic
1435 ** sqlite3 shell.
1436 */
unknownFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)1437 static void unknownFunc(
1438 sqlite3_context *context,
1439 int argc,
1440 sqlite3_value **argv
1441 ){
1442 /* no-op */
1443 }
1444 #endif /*SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION*/
1445
1446
1447 /* IMP: R-25361-16150 This function is omitted from SQLite by default. It
1448 ** is only available if the SQLITE_SOUNDEX compile-time option is used
1449 ** when SQLite is built.
1450 */
1451 #ifdef SQLITE_SOUNDEX
1452 /*
1453 ** Compute the soundex encoding of a word.
1454 **
1455 ** IMP: R-59782-00072 The soundex(X) function returns a string that is the
1456 ** soundex encoding of the string X.
1457 */
soundexFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)1458 static void soundexFunc(
1459 sqlite3_context *context,
1460 int argc,
1461 sqlite3_value **argv
1462 ){
1463 char zResult[8];
1464 const u8 *zIn;
1465 int i, j;
1466 static const unsigned char iCode[] = {
1467 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1468 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1469 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1470 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1471 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
1472 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
1473 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
1474 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
1475 };
1476 assert( argc==1 );
1477 zIn = (u8*)sqlite3_value_text(argv[0]);
1478 if( zIn==0 ) zIn = (u8*)"";
1479 for(i=0; zIn[i] && !sqlite3Isalpha(zIn[i]); i++){}
1480 if( zIn[i] ){
1481 u8 prevcode = iCode[zIn[i]&0x7f];
1482 zResult[0] = sqlite3Toupper(zIn[i]);
1483 for(j=1; j<4 && zIn[i]; i++){
1484 int code = iCode[zIn[i]&0x7f];
1485 if( code>0 ){
1486 if( code!=prevcode ){
1487 prevcode = code;
1488 zResult[j++] = code + '0';
1489 }
1490 }else{
1491 prevcode = 0;
1492 }
1493 }
1494 while( j<4 ){
1495 zResult[j++] = '0';
1496 }
1497 zResult[j] = 0;
1498 sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT);
1499 }else{
1500 /* IMP: R-64894-50321 The string "?000" is returned if the argument
1501 ** is NULL or contains no ASCII alphabetic characters. */
1502 sqlite3_result_text(context, "?000", 4, SQLITE_STATIC);
1503 }
1504 }
1505 #endif /* SQLITE_SOUNDEX */
1506
1507 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1508 /*
1509 ** A function that loads a shared-library extension then returns NULL.
1510 */
loadExt(sqlite3_context * context,int argc,sqlite3_value ** argv)1511 static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){
1512 const char *zFile = (const char *)sqlite3_value_text(argv[0]);
1513 const char *zProc;
1514 sqlite3 *db = sqlite3_context_db_handle(context);
1515 char *zErrMsg = 0;
1516
1517 /* Disallow the load_extension() SQL function unless the SQLITE_LoadExtFunc
1518 ** flag is set. See the sqlite3_enable_load_extension() API.
1519 */
1520 if( (db->flags & SQLITE_LoadExtFunc)==0 ){
1521 sqlite3_result_error(context, "not authorized", -1);
1522 return;
1523 }
1524
1525 if( argc==2 ){
1526 zProc = (const char *)sqlite3_value_text(argv[1]);
1527 }else{
1528 zProc = 0;
1529 }
1530 if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){
1531 sqlite3_result_error(context, zErrMsg, -1);
1532 sqlite3_free(zErrMsg);
1533 }
1534 }
1535 #endif
1536
1537
1538 /*
1539 ** An instance of the following structure holds the context of a
1540 ** sum() or avg() aggregate computation.
1541 */
1542 typedef struct SumCtx SumCtx;
1543 struct SumCtx {
1544 double rSum; /* Floating point sum */
1545 i64 iSum; /* Integer sum */
1546 i64 cnt; /* Number of elements summed */
1547 u8 overflow; /* True if integer overflow seen */
1548 u8 approx; /* True if non-integer value was input to the sum */
1549 };
1550
1551 /*
1552 ** Routines used to compute the sum, average, and total.
1553 **
1554 ** The SUM() function follows the (broken) SQL standard which means
1555 ** that it returns NULL if it sums over no inputs. TOTAL returns
1556 ** 0.0 in that case. In addition, TOTAL always returns a float where
1557 ** SUM might return an integer if it never encounters a floating point
1558 ** value. TOTAL never fails, but SUM might through an exception if
1559 ** it overflows an integer.
1560 */
sumStep(sqlite3_context * context,int argc,sqlite3_value ** argv)1561 static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){
1562 SumCtx *p;
1563 int type;
1564 assert( argc==1 );
1565 UNUSED_PARAMETER(argc);
1566 p = sqlite3_aggregate_context(context, sizeof(*p));
1567 type = sqlite3_value_numeric_type(argv[0]);
1568 if( p && type!=SQLITE_NULL ){
1569 p->cnt++;
1570 if( type==SQLITE_INTEGER ){
1571 i64 v = sqlite3_value_int64(argv[0]);
1572 p->rSum += v;
1573 if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){
1574 p->approx = p->overflow = 1;
1575 }
1576 }else{
1577 p->rSum += sqlite3_value_double(argv[0]);
1578 p->approx = 1;
1579 }
1580 }
1581 }
1582 #ifndef SQLITE_OMIT_WINDOWFUNC
sumInverse(sqlite3_context * context,int argc,sqlite3_value ** argv)1583 static void sumInverse(sqlite3_context *context, int argc, sqlite3_value**argv){
1584 SumCtx *p;
1585 int type;
1586 assert( argc==1 );
1587 UNUSED_PARAMETER(argc);
1588 p = sqlite3_aggregate_context(context, sizeof(*p));
1589 type = sqlite3_value_numeric_type(argv[0]);
1590 /* p is always non-NULL because sumStep() will have been called first
1591 ** to initialize it */
1592 if( ALWAYS(p) && type!=SQLITE_NULL ){
1593 assert( p->cnt>0 );
1594 p->cnt--;
1595 assert( type==SQLITE_INTEGER || p->approx );
1596 if( type==SQLITE_INTEGER && p->approx==0 ){
1597 i64 v = sqlite3_value_int64(argv[0]);
1598 p->rSum -= v;
1599 p->iSum -= v;
1600 }else{
1601 p->rSum -= sqlite3_value_double(argv[0]);
1602 }
1603 }
1604 }
1605 #else
1606 # define sumInverse 0
1607 #endif /* SQLITE_OMIT_WINDOWFUNC */
sumFinalize(sqlite3_context * context)1608 static void sumFinalize(sqlite3_context *context){
1609 SumCtx *p;
1610 p = sqlite3_aggregate_context(context, 0);
1611 if( p && p->cnt>0 ){
1612 if( p->overflow ){
1613 sqlite3_result_error(context,"integer overflow",-1);
1614 }else if( p->approx ){
1615 sqlite3_result_double(context, p->rSum);
1616 }else{
1617 sqlite3_result_int64(context, p->iSum);
1618 }
1619 }
1620 }
avgFinalize(sqlite3_context * context)1621 static void avgFinalize(sqlite3_context *context){
1622 SumCtx *p;
1623 p = sqlite3_aggregate_context(context, 0);
1624 if( p && p->cnt>0 ){
1625 sqlite3_result_double(context, p->rSum/(double)p->cnt);
1626 }
1627 }
totalFinalize(sqlite3_context * context)1628 static void totalFinalize(sqlite3_context *context){
1629 SumCtx *p;
1630 p = sqlite3_aggregate_context(context, 0);
1631 /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
1632 sqlite3_result_double(context, p ? p->rSum : (double)0);
1633 }
1634
1635 /*
1636 ** The following structure keeps track of state information for the
1637 ** count() aggregate function.
1638 */
1639 typedef struct CountCtx CountCtx;
1640 struct CountCtx {
1641 i64 n;
1642 #ifdef SQLITE_DEBUG
1643 int bInverse; /* True if xInverse() ever called */
1644 #endif
1645 };
1646
1647 /*
1648 ** Routines to implement the count() aggregate function.
1649 */
countStep(sqlite3_context * context,int argc,sqlite3_value ** argv)1650 static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){
1651 CountCtx *p;
1652 p = sqlite3_aggregate_context(context, sizeof(*p));
1653 if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){
1654 p->n++;
1655 }
1656
1657 #ifndef SQLITE_OMIT_DEPRECATED
1658 /* The sqlite3_aggregate_count() function is deprecated. But just to make
1659 ** sure it still operates correctly, verify that its count agrees with our
1660 ** internal count when using count(*) and when the total count can be
1661 ** expressed as a 32-bit integer. */
1662 assert( argc==1 || p==0 || p->n>0x7fffffff || p->bInverse
1663 || p->n==sqlite3_aggregate_count(context) );
1664 #endif
1665 }
countFinalize(sqlite3_context * context)1666 static void countFinalize(sqlite3_context *context){
1667 CountCtx *p;
1668 p = sqlite3_aggregate_context(context, 0);
1669 sqlite3_result_int64(context, p ? p->n : 0);
1670 }
1671 #ifndef SQLITE_OMIT_WINDOWFUNC
countInverse(sqlite3_context * ctx,int argc,sqlite3_value ** argv)1672 static void countInverse(sqlite3_context *ctx, int argc, sqlite3_value **argv){
1673 CountCtx *p;
1674 p = sqlite3_aggregate_context(ctx, sizeof(*p));
1675 /* p is always non-NULL since countStep() will have been called first */
1676 if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && ALWAYS(p) ){
1677 p->n--;
1678 #ifdef SQLITE_DEBUG
1679 p->bInverse = 1;
1680 #endif
1681 }
1682 }
1683 #else
1684 # define countInverse 0
1685 #endif /* SQLITE_OMIT_WINDOWFUNC */
1686
1687 /*
1688 ** Routines to implement min() and max() aggregate functions.
1689 */
minmaxStep(sqlite3_context * context,int NotUsed,sqlite3_value ** argv)1690 static void minmaxStep(
1691 sqlite3_context *context,
1692 int NotUsed,
1693 sqlite3_value **argv
1694 ){
1695 Mem *pArg = (Mem *)argv[0];
1696 Mem *pBest;
1697 UNUSED_PARAMETER(NotUsed);
1698
1699 pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest));
1700 if( !pBest ) return;
1701
1702 if( sqlite3_value_type(pArg)==SQLITE_NULL ){
1703 if( pBest->flags ) sqlite3SkipAccumulatorLoad(context);
1704 }else if( pBest->flags ){
1705 int max;
1706 int cmp;
1707 CollSeq *pColl = sqlite3GetFuncCollSeq(context);
1708 /* This step function is used for both the min() and max() aggregates,
1709 ** the only difference between the two being that the sense of the
1710 ** comparison is inverted. For the max() aggregate, the
1711 ** sqlite3_user_data() function returns (void *)-1. For min() it
1712 ** returns (void *)db, where db is the sqlite3* database pointer.
1713 ** Therefore the next statement sets variable 'max' to 1 for the max()
1714 ** aggregate, or 0 for min().
1715 */
1716 max = sqlite3_user_data(context)!=0;
1717 cmp = sqlite3MemCompare(pBest, pArg, pColl);
1718 if( (max && cmp<0) || (!max && cmp>0) ){
1719 sqlite3VdbeMemCopy(pBest, pArg);
1720 }else{
1721 sqlite3SkipAccumulatorLoad(context);
1722 }
1723 }else{
1724 pBest->db = sqlite3_context_db_handle(context);
1725 sqlite3VdbeMemCopy(pBest, pArg);
1726 }
1727 }
minMaxValueFinalize(sqlite3_context * context,int bValue)1728 static void minMaxValueFinalize(sqlite3_context *context, int bValue){
1729 sqlite3_value *pRes;
1730 pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0);
1731 if( pRes ){
1732 if( pRes->flags ){
1733 sqlite3_result_value(context, pRes);
1734 }
1735 if( bValue==0 ) sqlite3VdbeMemRelease(pRes);
1736 }
1737 }
1738 #ifndef SQLITE_OMIT_WINDOWFUNC
minMaxValue(sqlite3_context * context)1739 static void minMaxValue(sqlite3_context *context){
1740 minMaxValueFinalize(context, 1);
1741 }
1742 #else
1743 # define minMaxValue 0
1744 #endif /* SQLITE_OMIT_WINDOWFUNC */
minMaxFinalize(sqlite3_context * context)1745 static void minMaxFinalize(sqlite3_context *context){
1746 minMaxValueFinalize(context, 0);
1747 }
1748
1749 /*
1750 ** group_concat(EXPR, ?SEPARATOR?)
1751 **
1752 ** The SEPARATOR goes before the EXPR string. This is tragic. The
1753 ** groupConcatInverse() implementation would have been easier if the
1754 ** SEPARATOR were appended after EXPR. And the order is undocumented,
1755 ** so we could change it, in theory. But the old behavior has been
1756 ** around for so long that we dare not, for fear of breaking something.
1757 */
1758 typedef struct {
1759 StrAccum str; /* The accumulated concatenation */
1760 #ifndef SQLITE_OMIT_WINDOWFUNC
1761 int nAccum; /* Number of strings presently concatenated */
1762 int nFirstSepLength; /* Used to detect separator length change */
1763 /* If pnSepLengths!=0, refs an array of inter-string separator lengths,
1764 ** stored as actually incorporated into presently accumulated result.
1765 ** (Hence, its slots in use number nAccum-1 between method calls.)
1766 ** If pnSepLengths==0, nFirstSepLength is the length used throughout.
1767 */
1768 int *pnSepLengths;
1769 #endif
1770 } GroupConcatCtx;
1771
groupConcatStep(sqlite3_context * context,int argc,sqlite3_value ** argv)1772 static void groupConcatStep(
1773 sqlite3_context *context,
1774 int argc,
1775 sqlite3_value **argv
1776 ){
1777 const char *zVal;
1778 GroupConcatCtx *pGCC;
1779 const char *zSep;
1780 int nVal, nSep;
1781 assert( argc==1 || argc==2 );
1782 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
1783 pGCC = (GroupConcatCtx*)sqlite3_aggregate_context(context, sizeof(*pGCC));
1784 if( pGCC ){
1785 sqlite3 *db = sqlite3_context_db_handle(context);
1786 int firstTerm = pGCC->str.mxAlloc==0;
1787 pGCC->str.mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH];
1788 if( argc==1 ){
1789 if( !firstTerm ){
1790 sqlite3_str_appendchar(&pGCC->str, 1, ',');
1791 }
1792 #ifndef SQLITE_OMIT_WINDOWFUNC
1793 else{
1794 pGCC->nFirstSepLength = 1;
1795 }
1796 #endif
1797 }else if( !firstTerm ){
1798 zSep = (char*)sqlite3_value_text(argv[1]);
1799 nSep = sqlite3_value_bytes(argv[1]);
1800 if( zSep ){
1801 sqlite3_str_append(&pGCC->str, zSep, nSep);
1802 }
1803 #ifndef SQLITE_OMIT_WINDOWFUNC
1804 else{
1805 nSep = 0;
1806 }
1807 if( nSep != pGCC->nFirstSepLength || pGCC->pnSepLengths != 0 ){
1808 int *pnsl = pGCC->pnSepLengths;
1809 if( pnsl == 0 ){
1810 /* First separator length variation seen, start tracking them. */
1811 pnsl = (int*)sqlite3_malloc64((pGCC->nAccum+1) * sizeof(int));
1812 if( pnsl!=0 ){
1813 int i = 0, nA = pGCC->nAccum-1;
1814 while( i<nA ) pnsl[i++] = pGCC->nFirstSepLength;
1815 }
1816 }else{
1817 pnsl = (int*)sqlite3_realloc64(pnsl, pGCC->nAccum * sizeof(int));
1818 }
1819 if( pnsl!=0 ){
1820 if( ALWAYS(pGCC->nAccum>0) ){
1821 pnsl[pGCC->nAccum-1] = nSep;
1822 }
1823 pGCC->pnSepLengths = pnsl;
1824 }else{
1825 sqlite3StrAccumSetError(&pGCC->str, SQLITE_NOMEM);
1826 }
1827 }
1828 #endif
1829 }
1830 #ifndef SQLITE_OMIT_WINDOWFUNC
1831 else{
1832 pGCC->nFirstSepLength = sqlite3_value_bytes(argv[1]);
1833 }
1834 pGCC->nAccum += 1;
1835 #endif
1836 zVal = (char*)sqlite3_value_text(argv[0]);
1837 nVal = sqlite3_value_bytes(argv[0]);
1838 if( zVal ) sqlite3_str_append(&pGCC->str, zVal, nVal);
1839 }
1840 }
1841
1842 #ifndef SQLITE_OMIT_WINDOWFUNC
groupConcatInverse(sqlite3_context * context,int argc,sqlite3_value ** argv)1843 static void groupConcatInverse(
1844 sqlite3_context *context,
1845 int argc,
1846 sqlite3_value **argv
1847 ){
1848 GroupConcatCtx *pGCC;
1849 assert( argc==1 || argc==2 );
1850 (void)argc; /* Suppress unused parameter warning */
1851 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
1852 pGCC = (GroupConcatCtx*)sqlite3_aggregate_context(context, sizeof(*pGCC));
1853 /* pGCC is always non-NULL since groupConcatStep() will have always
1854 ** run frist to initialize it */
1855 if( ALWAYS(pGCC) ){
1856 int nVS;
1857 /* Must call sqlite3_value_text() to convert the argument into text prior
1858 ** to invoking sqlite3_value_bytes(), in case the text encoding is UTF16 */
1859 (void)sqlite3_value_text(argv[0]);
1860 nVS = sqlite3_value_bytes(argv[0]);
1861 pGCC->nAccum -= 1;
1862 if( pGCC->pnSepLengths!=0 ){
1863 assert(pGCC->nAccum >= 0);
1864 if( pGCC->nAccum>0 ){
1865 nVS += *pGCC->pnSepLengths;
1866 memmove(pGCC->pnSepLengths, pGCC->pnSepLengths+1,
1867 (pGCC->nAccum-1)*sizeof(int));
1868 }
1869 }else{
1870 /* If removing single accumulated string, harmlessly over-do. */
1871 nVS += pGCC->nFirstSepLength;
1872 }
1873 if( nVS>=(int)pGCC->str.nChar ){
1874 pGCC->str.nChar = 0;
1875 }else{
1876 pGCC->str.nChar -= nVS;
1877 memmove(pGCC->str.zText, &pGCC->str.zText[nVS], pGCC->str.nChar);
1878 }
1879 if( pGCC->str.nChar==0 ){
1880 pGCC->str.mxAlloc = 0;
1881 sqlite3_free(pGCC->pnSepLengths);
1882 pGCC->pnSepLengths = 0;
1883 }
1884 }
1885 }
1886 #else
1887 # define groupConcatInverse 0
1888 #endif /* SQLITE_OMIT_WINDOWFUNC */
groupConcatFinalize(sqlite3_context * context)1889 static void groupConcatFinalize(sqlite3_context *context){
1890 GroupConcatCtx *pGCC
1891 = (GroupConcatCtx*)sqlite3_aggregate_context(context, 0);
1892 if( pGCC ){
1893 sqlite3ResultStrAccum(context, &pGCC->str);
1894 #ifndef SQLITE_OMIT_WINDOWFUNC
1895 sqlite3_free(pGCC->pnSepLengths);
1896 #endif
1897 }
1898 }
1899 #ifndef SQLITE_OMIT_WINDOWFUNC
groupConcatValue(sqlite3_context * context)1900 static void groupConcatValue(sqlite3_context *context){
1901 GroupConcatCtx *pGCC
1902 = (GroupConcatCtx*)sqlite3_aggregate_context(context, 0);
1903 if( pGCC ){
1904 StrAccum *pAccum = &pGCC->str;
1905 if( pAccum->accError==SQLITE_TOOBIG ){
1906 sqlite3_result_error_toobig(context);
1907 }else if( pAccum->accError==SQLITE_NOMEM ){
1908 sqlite3_result_error_nomem(context);
1909 }else{
1910 const char *zText = sqlite3_str_value(pAccum);
1911 sqlite3_result_text(context, zText, pAccum->nChar, SQLITE_TRANSIENT);
1912 }
1913 }
1914 }
1915 #else
1916 # define groupConcatValue 0
1917 #endif /* SQLITE_OMIT_WINDOWFUNC */
1918
1919 /*
1920 ** This routine does per-connection function registration. Most
1921 ** of the built-in functions above are part of the global function set.
1922 ** This routine only deals with those that are not global.
1923 */
sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3 * db)1924 void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3 *db){
1925 int rc = sqlite3_overload_function(db, "MATCH", 2);
1926 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
1927 if( rc==SQLITE_NOMEM ){
1928 sqlite3OomFault(db);
1929 }
1930 }
1931
1932 /*
1933 ** Re-register the built-in LIKE functions. The caseSensitive
1934 ** parameter determines whether or not the LIKE operator is case
1935 ** sensitive.
1936 */
sqlite3RegisterLikeFunctions(sqlite3 * db,int caseSensitive)1937 void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){
1938 struct compareInfo *pInfo;
1939 int flags;
1940 if( caseSensitive ){
1941 pInfo = (struct compareInfo*)&likeInfoAlt;
1942 flags = SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE;
1943 }else{
1944 pInfo = (struct compareInfo*)&likeInfoNorm;
1945 flags = SQLITE_FUNC_LIKE;
1946 }
1947 sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0, 0, 0);
1948 sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0, 0, 0);
1949 sqlite3FindFunction(db, "like", 2, SQLITE_UTF8, 0)->funcFlags |= flags;
1950 sqlite3FindFunction(db, "like", 3, SQLITE_UTF8, 0)->funcFlags |= flags;
1951 }
1952
1953 /*
1954 ** pExpr points to an expression which implements a function. If
1955 ** it is appropriate to apply the LIKE optimization to that function
1956 ** then set aWc[0] through aWc[2] to the wildcard characters and the
1957 ** escape character and then return TRUE. If the function is not a
1958 ** LIKE-style function then return FALSE.
1959 **
1960 ** The expression "a LIKE b ESCAPE c" is only considered a valid LIKE
1961 ** operator if c is a string literal that is exactly one byte in length.
1962 ** That one byte is stored in aWc[3]. aWc[3] is set to zero if there is
1963 ** no ESCAPE clause.
1964 **
1965 ** *pIsNocase is set to true if uppercase and lowercase are equivalent for
1966 ** the function (default for LIKE). If the function makes the distinction
1967 ** between uppercase and lowercase (as does GLOB) then *pIsNocase is set to
1968 ** false.
1969 */
sqlite3IsLikeFunction(sqlite3 * db,Expr * pExpr,int * pIsNocase,char * aWc)1970 int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){
1971 FuncDef *pDef;
1972 int nExpr;
1973 assert( pExpr!=0 );
1974 assert( pExpr->op==TK_FUNCTION );
1975 assert( ExprUseXList(pExpr) );
1976 if( !pExpr->x.pList ){
1977 return 0;
1978 }
1979 nExpr = pExpr->x.pList->nExpr;
1980 assert( !ExprHasProperty(pExpr, EP_IntValue) );
1981 pDef = sqlite3FindFunction(db, pExpr->u.zToken, nExpr, SQLITE_UTF8, 0);
1982 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
1983 if( pDef==0 ) return 0;
1984 #endif
1985 if( NEVER(pDef==0) || (pDef->funcFlags & SQLITE_FUNC_LIKE)==0 ){
1986 return 0;
1987 }
1988
1989 /* The memcpy() statement assumes that the wildcard characters are
1990 ** the first three statements in the compareInfo structure. The
1991 ** asserts() that follow verify that assumption
1992 */
1993 memcpy(aWc, pDef->pUserData, 3);
1994 assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll );
1995 assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne );
1996 assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet );
1997
1998 if( nExpr<3 ){
1999 aWc[3] = 0;
2000 }else{
2001 Expr *pEscape = pExpr->x.pList->a[2].pExpr;
2002 char *zEscape;
2003 if( pEscape->op!=TK_STRING ) return 0;
2004 assert( !ExprHasProperty(pEscape, EP_IntValue) );
2005 zEscape = pEscape->u.zToken;
2006 if( zEscape[0]==0 || zEscape[1]!=0 ) return 0;
2007 if( zEscape[0]==aWc[0] ) return 0;
2008 if( zEscape[0]==aWc[1] ) return 0;
2009 aWc[3] = zEscape[0];
2010 }
2011
2012 *pIsNocase = (pDef->funcFlags & SQLITE_FUNC_CASE)==0;
2013 return 1;
2014 }
2015
2016 /* Mathematical Constants */
2017 #ifndef M_PI
2018 # define M_PI 3.141592653589793238462643383279502884
2019 #endif
2020 #ifndef M_LN10
2021 # define M_LN10 2.302585092994045684017991454684364208
2022 #endif
2023 #ifndef M_LN2
2024 # define M_LN2 0.693147180559945309417232121458176568
2025 #endif
2026
2027
2028 /* Extra math functions that require linking with -lm
2029 */
2030 #ifdef SQLITE_ENABLE_MATH_FUNCTIONS
2031 /*
2032 ** Implementation SQL functions:
2033 **
2034 ** ceil(X)
2035 ** ceiling(X)
2036 ** floor(X)
2037 **
2038 ** The sqlite3_user_data() pointer is a pointer to the libm implementation
2039 ** of the underlying C function.
2040 */
ceilingFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)2041 static void ceilingFunc(
2042 sqlite3_context *context,
2043 int argc,
2044 sqlite3_value **argv
2045 ){
2046 assert( argc==1 );
2047 switch( sqlite3_value_numeric_type(argv[0]) ){
2048 case SQLITE_INTEGER: {
2049 sqlite3_result_int64(context, sqlite3_value_int64(argv[0]));
2050 break;
2051 }
2052 case SQLITE_FLOAT: {
2053 double (*x)(double) = (double(*)(double))sqlite3_user_data(context);
2054 sqlite3_result_double(context, x(sqlite3_value_double(argv[0])));
2055 break;
2056 }
2057 default: {
2058 break;
2059 }
2060 }
2061 }
2062
2063 /*
2064 ** On some systems, ceil() and floor() are intrinsic function. You are
2065 ** unable to take a pointer to these functions. Hence, we here wrap them
2066 ** in our own actual functions.
2067 */
xCeil(double x)2068 static double xCeil(double x){ return ceil(x); }
xFloor(double x)2069 static double xFloor(double x){ return floor(x); }
2070
2071 /*
2072 ** Implementation of SQL functions:
2073 **
2074 ** ln(X) - natural logarithm
2075 ** log(X) - log X base 10
2076 ** log10(X) - log X base 10
2077 ** log(B,X) - log X base B
2078 */
logFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)2079 static void logFunc(
2080 sqlite3_context *context,
2081 int argc,
2082 sqlite3_value **argv
2083 ){
2084 double x, b, ans;
2085 assert( argc==1 || argc==2 );
2086 switch( sqlite3_value_numeric_type(argv[0]) ){
2087 case SQLITE_INTEGER:
2088 case SQLITE_FLOAT:
2089 x = sqlite3_value_double(argv[0]);
2090 if( x<=0.0 ) return;
2091 break;
2092 default:
2093 return;
2094 }
2095 if( argc==2 ){
2096 switch( sqlite3_value_numeric_type(argv[0]) ){
2097 case SQLITE_INTEGER:
2098 case SQLITE_FLOAT:
2099 b = log(x);
2100 if( b<=0.0 ) return;
2101 x = sqlite3_value_double(argv[1]);
2102 if( x<=0.0 ) return;
2103 break;
2104 default:
2105 return;
2106 }
2107 ans = log(x)/b;
2108 }else{
2109 ans = log(x);
2110 switch( SQLITE_PTR_TO_INT(sqlite3_user_data(context)) ){
2111 case 1:
2112 /* Convert from natural logarithm to log base 10 */
2113 ans /= M_LN10;
2114 break;
2115 case 2:
2116 /* Convert from natural logarithm to log base 2 */
2117 ans /= M_LN2;
2118 break;
2119 default:
2120 break;
2121 }
2122 }
2123 sqlite3_result_double(context, ans);
2124 }
2125
2126 /*
2127 ** Functions to converts degrees to radians and radians to degrees.
2128 */
degToRad(double x)2129 static double degToRad(double x){ return x*(M_PI/180.0); }
radToDeg(double x)2130 static double radToDeg(double x){ return x*(180.0/M_PI); }
2131
2132 /*
2133 ** Implementation of 1-argument SQL math functions:
2134 **
2135 ** exp(X) - Compute e to the X-th power
2136 */
math1Func(sqlite3_context * context,int argc,sqlite3_value ** argv)2137 static void math1Func(
2138 sqlite3_context *context,
2139 int argc,
2140 sqlite3_value **argv
2141 ){
2142 int type0;
2143 double v0, ans;
2144 double (*x)(double);
2145 assert( argc==1 );
2146 type0 = sqlite3_value_numeric_type(argv[0]);
2147 if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return;
2148 v0 = sqlite3_value_double(argv[0]);
2149 x = (double(*)(double))sqlite3_user_data(context);
2150 ans = x(v0);
2151 sqlite3_result_double(context, ans);
2152 }
2153
2154 /*
2155 ** Implementation of 2-argument SQL math functions:
2156 **
2157 ** power(X,Y) - Compute X to the Y-th power
2158 */
math2Func(sqlite3_context * context,int argc,sqlite3_value ** argv)2159 static void math2Func(
2160 sqlite3_context *context,
2161 int argc,
2162 sqlite3_value **argv
2163 ){
2164 int type0, type1;
2165 double v0, v1, ans;
2166 double (*x)(double,double);
2167 assert( argc==2 );
2168 type0 = sqlite3_value_numeric_type(argv[0]);
2169 if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return;
2170 type1 = sqlite3_value_numeric_type(argv[1]);
2171 if( type1!=SQLITE_INTEGER && type1!=SQLITE_FLOAT ) return;
2172 v0 = sqlite3_value_double(argv[0]);
2173 v1 = sqlite3_value_double(argv[1]);
2174 x = (double(*)(double,double))sqlite3_user_data(context);
2175 ans = x(v0, v1);
2176 sqlite3_result_double(context, ans);
2177 }
2178
2179 /*
2180 ** Implementation of 0-argument pi() function.
2181 */
piFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)2182 static void piFunc(
2183 sqlite3_context *context,
2184 int argc,
2185 sqlite3_value **argv
2186 ){
2187 assert( argc==0 );
2188 sqlite3_result_double(context, M_PI);
2189 }
2190
2191 #endif /* SQLITE_ENABLE_MATH_FUNCTIONS */
2192
2193 /*
2194 ** Implementation of sign(X) function.
2195 */
signFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)2196 static void signFunc(
2197 sqlite3_context *context,
2198 int argc,
2199 sqlite3_value **argv
2200 ){
2201 int type0;
2202 double x;
2203 UNUSED_PARAMETER(argc);
2204 assert( argc==1 );
2205 type0 = sqlite3_value_numeric_type(argv[0]);
2206 if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return;
2207 x = sqlite3_value_double(argv[0]);
2208 sqlite3_result_int(context, x<0.0 ? -1 : x>0.0 ? +1 : 0);
2209 }
2210
2211 /*
2212 ** All of the FuncDef structures in the aBuiltinFunc[] array above
2213 ** to the global function hash table. This occurs at start-time (as
2214 ** a consequence of calling sqlite3_initialize()).
2215 **
2216 ** After this routine runs
2217 */
sqlite3RegisterBuiltinFunctions(void)2218 void sqlite3RegisterBuiltinFunctions(void){
2219 /*
2220 ** The following array holds FuncDef structures for all of the functions
2221 ** defined in this file.
2222 **
2223 ** The array cannot be constant since changes are made to the
2224 ** FuncDef.pHash elements at start-time. The elements of this array
2225 ** are read-only after initialization is complete.
2226 **
2227 ** For peak efficiency, put the most frequently used function last.
2228 */
2229 static FuncDef aBuiltinFunc[] = {
2230 /***** Functions only available with SQLITE_TESTCTRL_INTERNAL_FUNCTIONS *****/
2231 #if !defined(SQLITE_UNTESTABLE)
2232 TEST_FUNC(implies_nonnull_row, 2, INLINEFUNC_implies_nonnull_row, 0),
2233 TEST_FUNC(expr_compare, 2, INLINEFUNC_expr_compare, 0),
2234 TEST_FUNC(expr_implies_expr, 2, INLINEFUNC_expr_implies_expr, 0),
2235 TEST_FUNC(affinity, 1, INLINEFUNC_affinity, 0),
2236 #endif /* !defined(SQLITE_UNTESTABLE) */
2237 /***** Regular functions *****/
2238 #ifdef SQLITE_SOUNDEX
2239 FUNCTION(soundex, 1, 0, 0, soundexFunc ),
2240 #endif
2241 #ifndef SQLITE_OMIT_LOAD_EXTENSION
2242 SFUNCTION(load_extension, 1, 0, 0, loadExt ),
2243 SFUNCTION(load_extension, 2, 0, 0, loadExt ),
2244 #endif
2245 #if SQLITE_USER_AUTHENTICATION
2246 FUNCTION(sqlite_crypt, 2, 0, 0, sqlite3CryptFunc ),
2247 #endif
2248 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
2249 DFUNCTION(sqlite_compileoption_used,1, 0, 0, compileoptionusedFunc ),
2250 DFUNCTION(sqlite_compileoption_get, 1, 0, 0, compileoptiongetFunc ),
2251 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
2252 INLINE_FUNC(unlikely, 1, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY),
2253 INLINE_FUNC(likelihood, 2, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY),
2254 INLINE_FUNC(likely, 1, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY),
2255 #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
2256 INLINE_FUNC(sqlite_offset, 1, INLINEFUNC_sqlite_offset, 0 ),
2257 #endif
2258 FUNCTION(ltrim, 1, 1, 0, trimFunc ),
2259 FUNCTION(ltrim, 2, 1, 0, trimFunc ),
2260 FUNCTION(rtrim, 1, 2, 0, trimFunc ),
2261 FUNCTION(rtrim, 2, 2, 0, trimFunc ),
2262 FUNCTION(trim, 1, 3, 0, trimFunc ),
2263 FUNCTION(trim, 2, 3, 0, trimFunc ),
2264 FUNCTION(min, -1, 0, 1, minmaxFunc ),
2265 FUNCTION(min, 0, 0, 1, 0 ),
2266 WAGGREGATE(min, 1, 0, 1, minmaxStep, minMaxFinalize, minMaxValue, 0,
2267 SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER ),
2268 FUNCTION(max, -1, 1, 1, minmaxFunc ),
2269 FUNCTION(max, 0, 1, 1, 0 ),
2270 WAGGREGATE(max, 1, 1, 1, minmaxStep, minMaxFinalize, minMaxValue, 0,
2271 SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER ),
2272 FUNCTION2(typeof, 1, 0, 0, typeofFunc, SQLITE_FUNC_TYPEOF),
2273 FUNCTION2(subtype, 1, 0, 0, subtypeFunc, SQLITE_FUNC_TYPEOF),
2274 FUNCTION2(length, 1, 0, 0, lengthFunc, SQLITE_FUNC_LENGTH),
2275 FUNCTION(instr, 2, 0, 0, instrFunc ),
2276 FUNCTION(printf, -1, 0, 0, printfFunc ),
2277 FUNCTION(format, -1, 0, 0, printfFunc ),
2278 FUNCTION(unicode, 1, 0, 0, unicodeFunc ),
2279 FUNCTION(char, -1, 0, 0, charFunc ),
2280 FUNCTION(abs, 1, 0, 0, absFunc ),
2281 #ifndef SQLITE_OMIT_FLOATING_POINT
2282 FUNCTION(round, 1, 0, 0, roundFunc ),
2283 FUNCTION(round, 2, 0, 0, roundFunc ),
2284 #endif
2285 FUNCTION(upper, 1, 0, 0, upperFunc ),
2286 FUNCTION(lower, 1, 0, 0, lowerFunc ),
2287 FUNCTION(hex, 1, 0, 0, hexFunc ),
2288 INLINE_FUNC(ifnull, 2, INLINEFUNC_coalesce, 0 ),
2289 VFUNCTION(random, 0, 0, 0, randomFunc ),
2290 VFUNCTION(randomblob, 1, 0, 0, randomBlob ),
2291 FUNCTION(nullif, 2, 0, 1, nullifFunc ),
2292 DFUNCTION(sqlite_version, 0, 0, 0, versionFunc ),
2293 DFUNCTION(sqlite_source_id, 0, 0, 0, sourceidFunc ),
2294 FUNCTION(sqlite_log, 2, 0, 0, errlogFunc ),
2295 FUNCTION(quote, 1, 0, 0, quoteFunc ),
2296 VFUNCTION(last_insert_rowid, 0, 0, 0, last_insert_rowid),
2297 VFUNCTION(changes, 0, 0, 0, changes ),
2298 VFUNCTION(total_changes, 0, 0, 0, total_changes ),
2299 FUNCTION(replace, 3, 0, 0, replaceFunc ),
2300 FUNCTION(zeroblob, 1, 0, 0, zeroblobFunc ),
2301 FUNCTION(substr, 2, 0, 0, substrFunc ),
2302 FUNCTION(substr, 3, 0, 0, substrFunc ),
2303 FUNCTION(substring, 2, 0, 0, substrFunc ),
2304 FUNCTION(substring, 3, 0, 0, substrFunc ),
2305 WAGGREGATE(sum, 1,0,0, sumStep, sumFinalize, sumFinalize, sumInverse, 0),
2306 WAGGREGATE(total, 1,0,0, sumStep,totalFinalize,totalFinalize,sumInverse, 0),
2307 WAGGREGATE(avg, 1,0,0, sumStep, avgFinalize, avgFinalize, sumInverse, 0),
2308 WAGGREGATE(count, 0,0,0, countStep,
2309 countFinalize, countFinalize, countInverse,
2310 SQLITE_FUNC_COUNT|SQLITE_FUNC_ANYORDER ),
2311 WAGGREGATE(count, 1,0,0, countStep,
2312 countFinalize, countFinalize, countInverse, SQLITE_FUNC_ANYORDER ),
2313 WAGGREGATE(group_concat, 1, 0, 0, groupConcatStep,
2314 groupConcatFinalize, groupConcatValue, groupConcatInverse, 0),
2315 WAGGREGATE(group_concat, 2, 0, 0, groupConcatStep,
2316 groupConcatFinalize, groupConcatValue, groupConcatInverse, 0),
2317
2318 LIKEFUNC(glob, 2, &globInfo, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
2319 #ifdef SQLITE_CASE_SENSITIVE_LIKE
2320 LIKEFUNC(like, 2, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
2321 LIKEFUNC(like, 3, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
2322 #else
2323 LIKEFUNC(like, 2, &likeInfoNorm, SQLITE_FUNC_LIKE),
2324 LIKEFUNC(like, 3, &likeInfoNorm, SQLITE_FUNC_LIKE),
2325 #endif
2326 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
2327 FUNCTION(unknown, -1, 0, 0, unknownFunc ),
2328 #endif
2329 FUNCTION(coalesce, 1, 0, 0, 0 ),
2330 FUNCTION(coalesce, 0, 0, 0, 0 ),
2331 #ifdef SQLITE_ENABLE_MATH_FUNCTIONS
2332 MFUNCTION(ceil, 1, xCeil, ceilingFunc ),
2333 MFUNCTION(ceiling, 1, xCeil, ceilingFunc ),
2334 MFUNCTION(floor, 1, xFloor, ceilingFunc ),
2335 #if SQLITE_HAVE_C99_MATH_FUNCS
2336 MFUNCTION(trunc, 1, trunc, ceilingFunc ),
2337 #endif
2338 FUNCTION(ln, 1, 0, 0, logFunc ),
2339 FUNCTION(log, 1, 1, 0, logFunc ),
2340 FUNCTION(log10, 1, 1, 0, logFunc ),
2341 FUNCTION(log2, 1, 2, 0, logFunc ),
2342 FUNCTION(log, 2, 0, 0, logFunc ),
2343 MFUNCTION(exp, 1, exp, math1Func ),
2344 MFUNCTION(pow, 2, pow, math2Func ),
2345 MFUNCTION(power, 2, pow, math2Func ),
2346 MFUNCTION(mod, 2, fmod, math2Func ),
2347 MFUNCTION(acos, 1, acos, math1Func ),
2348 MFUNCTION(asin, 1, asin, math1Func ),
2349 MFUNCTION(atan, 1, atan, math1Func ),
2350 MFUNCTION(atan2, 2, atan2, math2Func ),
2351 MFUNCTION(cos, 1, cos, math1Func ),
2352 MFUNCTION(sin, 1, sin, math1Func ),
2353 MFUNCTION(tan, 1, tan, math1Func ),
2354 MFUNCTION(cosh, 1, cosh, math1Func ),
2355 MFUNCTION(sinh, 1, sinh, math1Func ),
2356 MFUNCTION(tanh, 1, tanh, math1Func ),
2357 #if SQLITE_HAVE_C99_MATH_FUNCS
2358 MFUNCTION(acosh, 1, acosh, math1Func ),
2359 MFUNCTION(asinh, 1, asinh, math1Func ),
2360 MFUNCTION(atanh, 1, atanh, math1Func ),
2361 #endif
2362 MFUNCTION(sqrt, 1, sqrt, math1Func ),
2363 MFUNCTION(radians, 1, degToRad, math1Func ),
2364 MFUNCTION(degrees, 1, radToDeg, math1Func ),
2365 FUNCTION(pi, 0, 0, 0, piFunc ),
2366 #endif /* SQLITE_ENABLE_MATH_FUNCTIONS */
2367 FUNCTION(sign, 1, 0, 0, signFunc ),
2368 INLINE_FUNC(coalesce, -1, INLINEFUNC_coalesce, 0 ),
2369 INLINE_FUNC(iif, 3, INLINEFUNC_iif, 0 ),
2370 };
2371 #ifndef SQLITE_OMIT_ALTERTABLE
2372 sqlite3AlterFunctions();
2373 #endif
2374 sqlite3WindowFunctions();
2375 sqlite3RegisterDateTimeFunctions();
2376 sqlite3RegisterJsonFunctions();
2377 sqlite3InsertBuiltinFuncs(aBuiltinFunc, ArraySize(aBuiltinFunc));
2378
2379 #if 0 /* Enable to print out how the built-in functions are hashed */
2380 {
2381 int i;
2382 FuncDef *p;
2383 for(i=0; i<SQLITE_FUNC_HASH_SZ; i++){
2384 printf("FUNC-HASH %02d:", i);
2385 for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.pHash){
2386 int n = sqlite3Strlen30(p->zName);
2387 int h = p->zName[0] + n;
2388 assert( p->funcFlags & SQLITE_FUNC_BUILTIN );
2389 printf(" %s(%d)", p->zName, h);
2390 }
2391 printf("\n");
2392 }
2393 }
2394 #endif
2395 }
2396