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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 |
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 | */ |
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 | */ |
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 | } |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 |
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 |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 |
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 */ |
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 | } |
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 | } |
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 | */ |
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 | } |
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 |
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 | */ |
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 | } |
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 |
1739 | static void minMaxValue(sqlite3_context *context){ |
1740 | minMaxValueFinalize(context, 1); |
1741 | } |
1742 | #else |
1743 | # define minMaxValue 0 |
1744 | #endif /* SQLITE_OMIT_WINDOWFUNC */ |
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 | |
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 |
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 */ |
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 |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
2068 | static double xCeil(double x){ return ceil(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 | */ |
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 | */ |
2129 | static double degToRad(double x){ return x*(M_PI/180.0); } |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | */ |
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 | |