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