000001 /*
000002 ** 2002 February 23
000003 **
000004 ** The author disclaims copyright to this source code. In place of
000005 ** a legal notice, here is a blessing:
000006 **
000007 ** May you do good and not evil.
000008 ** May you find forgiveness for yourself and forgive others.
000009 ** May you share freely, never taking more than you give.
000010 **
000011 *************************************************************************
000012 ** This file contains the C-language implementations for many of the SQL
000013 ** functions of SQLite. (Some function, and in particular the date and
000014 ** time functions, are implemented separately.)
000015 */
000016 #include "sqliteInt.h"
000017 #include <stdlib.h>
000018 #include <assert.h>
000019 #ifndef SQLITE_OMIT_FLOATING_POINT
000020 #include <math.h>
000021 #endif
000022 #include "vdbeInt.h"
000023
000024 /*
000025 ** Return the collating function associated with a function.
000026 */
000027 static CollSeq *sqlite3GetFuncCollSeq(sqlite3_context *context){
000028 VdbeOp *pOp;
000029 assert( context->pVdbe!=0 );
000030 pOp = &context->pVdbe->aOp[context->iOp-1];
000031 assert( pOp->opcode==OP_CollSeq );
000032 assert( pOp->p4type==P4_COLLSEQ );
000033 return pOp->p4.pColl;
000034 }
000035
000036 /*
000037 ** Indicate that the accumulator load should be skipped on this
000038 ** iteration of the aggregate loop.
000039 */
000040 static void sqlite3SkipAccumulatorLoad(sqlite3_context *context){
000041 assert( context->isError<=0 );
000042 context->isError = -1;
000043 context->skipFlag = 1;
000044 }
000045
000046 /*
000047 ** Implementation of the non-aggregate min() and max() functions
000048 */
000049 static void minmaxFunc(
000050 sqlite3_context *context,
000051 int argc,
000052 sqlite3_value **argv
000053 ){
000054 int i;
000055 int mask; /* 0 for min() or 0xffffffff for max() */
000056 int iBest;
000057 CollSeq *pColl;
000058
000059 assert( argc>1 );
000060 mask = sqlite3_user_data(context)==0 ? 0 : -1;
000061 pColl = sqlite3GetFuncCollSeq(context);
000062 assert( pColl );
000063 assert( mask==-1 || mask==0 );
000064 iBest = 0;
000065 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
000066 for(i=1; i<argc; i++){
000067 if( sqlite3_value_type(argv[i])==SQLITE_NULL ) return;
000068 if( (sqlite3MemCompare(argv[iBest], argv[i], pColl)^mask)>=0 ){
000069 testcase( mask==0 );
000070 iBest = i;
000071 }
000072 }
000073 sqlite3_result_value(context, argv[iBest]);
000074 }
000075
000076 /*
000077 ** Return the type of the argument.
000078 */
000079 static void typeofFunc(
000080 sqlite3_context *context,
000081 int NotUsed,
000082 sqlite3_value **argv
000083 ){
000084 static const char *azType[] = { "integer", "real", "text", "blob", "null" };
000085 int i = sqlite3_value_type(argv[0]) - 1;
000086 UNUSED_PARAMETER(NotUsed);
000087 assert( i>=0 && i<ArraySize(azType) );
000088 assert( SQLITE_INTEGER==1 );
000089 assert( SQLITE_FLOAT==2 );
000090 assert( SQLITE_TEXT==3 );
000091 assert( SQLITE_BLOB==4 );
000092 assert( SQLITE_NULL==5 );
000093 /* EVIDENCE-OF: R-01470-60482 The sqlite3_value_type(V) interface returns
000094 ** the datatype code for the initial datatype of the sqlite3_value object
000095 ** V. The returned value is one of SQLITE_INTEGER, SQLITE_FLOAT,
000096 ** SQLITE_TEXT, SQLITE_BLOB, or SQLITE_NULL. */
000097 sqlite3_result_text(context, azType[i], -1, SQLITE_STATIC);
000098 }
000099
000100 /* subtype(X)
000101 **
000102 ** Return the subtype of X
000103 */
000104 static void subtypeFunc(
000105 sqlite3_context *context,
000106 int argc,
000107 sqlite3_value **argv
000108 ){
000109 UNUSED_PARAMETER(argc);
000110 sqlite3_result_int(context, sqlite3_value_subtype(argv[0]));
000111 }
000112
000113 /*
000114 ** Implementation of the length() function
000115 */
000116 static void lengthFunc(
000117 sqlite3_context *context,
000118 int argc,
000119 sqlite3_value **argv
000120 ){
000121 assert( argc==1 );
000122 UNUSED_PARAMETER(argc);
000123 switch( sqlite3_value_type(argv[0]) ){
000124 case SQLITE_BLOB:
000125 case SQLITE_INTEGER:
000126 case SQLITE_FLOAT: {
000127 sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
000128 break;
000129 }
000130 case SQLITE_TEXT: {
000131 const unsigned char *z = sqlite3_value_text(argv[0]);
000132 const unsigned char *z0;
000133 unsigned char c;
000134 if( z==0 ) return;
000135 z0 = z;
000136 while( (c = *z)!=0 ){
000137 z++;
000138 if( c>=0xc0 ){
000139 while( (*z & 0xc0)==0x80 ){ z++; z0++; }
000140 }
000141 }
000142 sqlite3_result_int(context, (int)(z-z0));
000143 break;
000144 }
000145 default: {
000146 sqlite3_result_null(context);
000147 break;
000148 }
000149 }
000150 }
000151
000152 /*
000153 ** Implementation of the octet_length() function
000154 */
000155 static void bytelengthFunc(
000156 sqlite3_context *context,
000157 int argc,
000158 sqlite3_value **argv
000159 ){
000160 assert( argc==1 );
000161 UNUSED_PARAMETER(argc);
000162 switch( sqlite3_value_type(argv[0]) ){
000163 case SQLITE_BLOB: {
000164 sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
000165 break;
000166 }
000167 case SQLITE_INTEGER:
000168 case SQLITE_FLOAT: {
000169 i64 m = sqlite3_context_db_handle(context)->enc<=SQLITE_UTF8 ? 1 : 2;
000170 sqlite3_result_int64(context, sqlite3_value_bytes(argv[0])*m);
000171 break;
000172 }
000173 case SQLITE_TEXT: {
000174 if( sqlite3_value_encoding(argv[0])<=SQLITE_UTF8 ){
000175 sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
000176 }else{
000177 sqlite3_result_int(context, sqlite3_value_bytes16(argv[0]));
000178 }
000179 break;
000180 }
000181 default: {
000182 sqlite3_result_null(context);
000183 break;
000184 }
000185 }
000186 }
000187
000188 /*
000189 ** Implementation of the abs() function.
000190 **
000191 ** IMP: R-23979-26855 The abs(X) function returns the absolute value of
000192 ** the numeric argument X.
000193 */
000194 static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
000195 assert( argc==1 );
000196 UNUSED_PARAMETER(argc);
000197 switch( sqlite3_value_type(argv[0]) ){
000198 case SQLITE_INTEGER: {
000199 i64 iVal = sqlite3_value_int64(argv[0]);
000200 if( iVal<0 ){
000201 if( iVal==SMALLEST_INT64 ){
000202 /* IMP: R-31676-45509 If X is the integer -9223372036854775808
000203 ** then abs(X) throws an integer overflow error since there is no
000204 ** equivalent positive 64-bit two complement value. */
000205 sqlite3_result_error(context, "integer overflow", -1);
000206 return;
000207 }
000208 iVal = -iVal;
000209 }
000210 sqlite3_result_int64(context, iVal);
000211 break;
000212 }
000213 case SQLITE_NULL: {
000214 /* IMP: R-37434-19929 Abs(X) returns NULL if X is NULL. */
000215 sqlite3_result_null(context);
000216 break;
000217 }
000218 default: {
000219 /* Because sqlite3_value_double() returns 0.0 if the argument is not
000220 ** something that can be converted into a number, we have:
000221 ** IMP: R-01992-00519 Abs(X) returns 0.0 if X is a string or blob
000222 ** that cannot be converted to a numeric value.
000223 */
000224 double rVal = sqlite3_value_double(argv[0]);
000225 if( rVal<0 ) rVal = -rVal;
000226 sqlite3_result_double(context, rVal);
000227 break;
000228 }
000229 }
000230 }
000231
000232 /*
000233 ** Implementation of the instr() function.
000234 **
000235 ** instr(haystack,needle) finds the first occurrence of needle
000236 ** in haystack and returns the number of previous characters plus 1,
000237 ** or 0 if needle does not occur within haystack.
000238 **
000239 ** If both haystack and needle are BLOBs, then the result is one more than
000240 ** the number of bytes in haystack prior to the first occurrence of needle,
000241 ** or 0 if needle never occurs in haystack.
000242 */
000243 static void instrFunc(
000244 sqlite3_context *context,
000245 int argc,
000246 sqlite3_value **argv
000247 ){
000248 const unsigned char *zHaystack;
000249 const unsigned char *zNeedle;
000250 int nHaystack;
000251 int nNeedle;
000252 int typeHaystack, typeNeedle;
000253 int N = 1;
000254 int isText;
000255 unsigned char firstChar;
000256 sqlite3_value *pC1 = 0;
000257 sqlite3_value *pC2 = 0;
000258
000259 UNUSED_PARAMETER(argc);
000260 typeHaystack = sqlite3_value_type(argv[0]);
000261 typeNeedle = sqlite3_value_type(argv[1]);
000262 if( typeHaystack==SQLITE_NULL || typeNeedle==SQLITE_NULL ) return;
000263 nHaystack = sqlite3_value_bytes(argv[0]);
000264 nNeedle = sqlite3_value_bytes(argv[1]);
000265 if( nNeedle>0 ){
000266 if( typeHaystack==SQLITE_BLOB && typeNeedle==SQLITE_BLOB ){
000267 zHaystack = sqlite3_value_blob(argv[0]);
000268 zNeedle = sqlite3_value_blob(argv[1]);
000269 isText = 0;
000270 }else if( typeHaystack!=SQLITE_BLOB && typeNeedle!=SQLITE_BLOB ){
000271 zHaystack = sqlite3_value_text(argv[0]);
000272 zNeedle = sqlite3_value_text(argv[1]);
000273 isText = 1;
000274 }else{
000275 pC1 = sqlite3_value_dup(argv[0]);
000276 zHaystack = sqlite3_value_text(pC1);
000277 if( zHaystack==0 ) goto endInstrOOM;
000278 nHaystack = sqlite3_value_bytes(pC1);
000279 pC2 = sqlite3_value_dup(argv[1]);
000280 zNeedle = sqlite3_value_text(pC2);
000281 if( zNeedle==0 ) goto endInstrOOM;
000282 nNeedle = sqlite3_value_bytes(pC2);
000283 isText = 1;
000284 }
000285 if( zNeedle==0 || (nHaystack && zHaystack==0) ) goto endInstrOOM;
000286 firstChar = zNeedle[0];
000287 while( nNeedle<=nHaystack
000288 && (zHaystack[0]!=firstChar || memcmp(zHaystack, zNeedle, nNeedle)!=0)
000289 ){
000290 N++;
000291 do{
000292 nHaystack--;
000293 zHaystack++;
000294 }while( isText && (zHaystack[0]&0xc0)==0x80 );
000295 }
000296 if( nNeedle>nHaystack ) N = 0;
000297 }
000298 sqlite3_result_int(context, N);
000299 endInstr:
000300 sqlite3_value_free(pC1);
000301 sqlite3_value_free(pC2);
000302 return;
000303 endInstrOOM:
000304 sqlite3_result_error_nomem(context);
000305 goto endInstr;
000306 }
000307
000308 /*
000309 ** Implementation of the printf() (a.k.a. format()) SQL function.
000310 */
000311 static void printfFunc(
000312 sqlite3_context *context,
000313 int argc,
000314 sqlite3_value **argv
000315 ){
000316 PrintfArguments x;
000317 StrAccum str;
000318 const char *zFormat;
000319 int n;
000320 sqlite3 *db = sqlite3_context_db_handle(context);
000321
000322 if( argc>=1 && (zFormat = (const char*)sqlite3_value_text(argv[0]))!=0 ){
000323 x.nArg = argc-1;
000324 x.nUsed = 0;
000325 x.apArg = argv+1;
000326 sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]);
000327 str.printfFlags = SQLITE_PRINTF_SQLFUNC;
000328 sqlite3_str_appendf(&str, zFormat, &x);
000329 n = str.nChar;
000330 sqlite3_result_text(context, sqlite3StrAccumFinish(&str), n,
000331 SQLITE_DYNAMIC);
000332 }
000333 }
000334
000335 /*
000336 ** Implementation of the substr() function.
000337 **
000338 ** substr(x,p1,p2) returns p2 characters of x[] beginning with p1.
000339 ** p1 is 1-indexed. So substr(x,1,1) returns the first character
000340 ** of x. If x is text, then we actually count UTF-8 characters.
000341 ** If x is a blob, then we count bytes.
000342 **
000343 ** If p1 is negative, then we begin abs(p1) from the end of x[].
000344 **
000345 ** If p2 is negative, return the p2 characters preceding p1.
000346 */
000347 static void substrFunc(
000348 sqlite3_context *context,
000349 int argc,
000350 sqlite3_value **argv
000351 ){
000352 const unsigned char *z;
000353 const unsigned char *z2;
000354 int len;
000355 int p0type;
000356 i64 p1, p2;
000357 int negP2 = 0;
000358
000359 assert( argc==3 || argc==2 );
000360 if( sqlite3_value_type(argv[1])==SQLITE_NULL
000361 || (argc==3 && sqlite3_value_type(argv[2])==SQLITE_NULL)
000362 ){
000363 return;
000364 }
000365 p0type = sqlite3_value_type(argv[0]);
000366 p1 = sqlite3_value_int(argv[1]);
000367 if( p0type==SQLITE_BLOB ){
000368 len = sqlite3_value_bytes(argv[0]);
000369 z = sqlite3_value_blob(argv[0]);
000370 if( z==0 ) return;
000371 assert( len==sqlite3_value_bytes(argv[0]) );
000372 }else{
000373 z = sqlite3_value_text(argv[0]);
000374 if( z==0 ) return;
000375 len = 0;
000376 if( p1<0 ){
000377 for(z2=z; *z2; len++){
000378 SQLITE_SKIP_UTF8(z2);
000379 }
000380 }
000381 }
000382 #ifdef SQLITE_SUBSTR_COMPATIBILITY
000383 /* If SUBSTR_COMPATIBILITY is defined then substr(X,0,N) work the same as
000384 ** as substr(X,1,N) - it returns the first N characters of X. This
000385 ** is essentially a back-out of the bug-fix in check-in [5fc125d362df4b8]
000386 ** from 2009-02-02 for compatibility of applications that exploited the
000387 ** old buggy behavior. */
000388 if( p1==0 ) p1 = 1; /* <rdar://problem/6778339> */
000389 #endif
000390 if( argc==3 ){
000391 p2 = sqlite3_value_int(argv[2]);
000392 if( p2<0 ){
000393 p2 = -p2;
000394 negP2 = 1;
000395 }
000396 }else{
000397 p2 = sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH];
000398 }
000399 if( p1<0 ){
000400 p1 += len;
000401 if( p1<0 ){
000402 p2 += p1;
000403 if( p2<0 ) p2 = 0;
000404 p1 = 0;
000405 }
000406 }else if( p1>0 ){
000407 p1--;
000408 }else if( p2>0 ){
000409 p2--;
000410 }
000411 if( negP2 ){
000412 p1 -= p2;
000413 if( p1<0 ){
000414 p2 += p1;
000415 p1 = 0;
000416 }
000417 }
000418 assert( p1>=0 && p2>=0 );
000419 if( p0type!=SQLITE_BLOB ){
000420 while( *z && p1 ){
000421 SQLITE_SKIP_UTF8(z);
000422 p1--;
000423 }
000424 for(z2=z; *z2 && p2; p2--){
000425 SQLITE_SKIP_UTF8(z2);
000426 }
000427 sqlite3_result_text64(context, (char*)z, z2-z, SQLITE_TRANSIENT,
000428 SQLITE_UTF8);
000429 }else{
000430 if( p1+p2>len ){
000431 p2 = len-p1;
000432 if( p2<0 ) p2 = 0;
000433 }
000434 sqlite3_result_blob64(context, (char*)&z[p1], (u64)p2, SQLITE_TRANSIENT);
000435 }
000436 }
000437
000438 /*
000439 ** Implementation of the round() function
000440 */
000441 #ifndef SQLITE_OMIT_FLOATING_POINT
000442 static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
000443 int n = 0;
000444 double r;
000445 char *zBuf;
000446 assert( argc==1 || argc==2 );
000447 if( argc==2 ){
000448 if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return;
000449 n = sqlite3_value_int(argv[1]);
000450 if( n>30 ) n = 30;
000451 if( n<0 ) n = 0;
000452 }
000453 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
000454 r = sqlite3_value_double(argv[0]);
000455 /* If Y==0 and X will fit in a 64-bit int,
000456 ** handle the rounding directly,
000457 ** otherwise use printf.
000458 */
000459 if( r<-4503599627370496.0 || r>+4503599627370496.0 ){
000460 /* The value has no fractional part so there is nothing to round */
000461 }else if( n==0 ){
000462 r = (double)((sqlite_int64)(r+(r<0?-0.5:+0.5)));
000463 }else{
000464 zBuf = sqlite3_mprintf("%!.*f",n,r);
000465 if( zBuf==0 ){
000466 sqlite3_result_error_nomem(context);
000467 return;
000468 }
000469 sqlite3AtoF(zBuf, &r, sqlite3Strlen30(zBuf), SQLITE_UTF8);
000470 sqlite3_free(zBuf);
000471 }
000472 sqlite3_result_double(context, r);
000473 }
000474 #endif
000475
000476 /*
000477 ** Allocate nByte bytes of space using sqlite3Malloc(). If the
000478 ** allocation fails, call sqlite3_result_error_nomem() to notify
000479 ** the database handle that malloc() has failed and return NULL.
000480 ** If nByte is larger than the maximum string or blob length, then
000481 ** raise an SQLITE_TOOBIG exception and return NULL.
000482 */
000483 static void *contextMalloc(sqlite3_context *context, i64 nByte){
000484 char *z;
000485 sqlite3 *db = sqlite3_context_db_handle(context);
000486 assert( nByte>0 );
000487 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] );
000488 testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
000489 if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
000490 sqlite3_result_error_toobig(context);
000491 z = 0;
000492 }else{
000493 z = sqlite3Malloc(nByte);
000494 if( !z ){
000495 sqlite3_result_error_nomem(context);
000496 }
000497 }
000498 return z;
000499 }
000500
000501 /*
000502 ** Implementation of the upper() and lower() SQL functions.
000503 */
000504 static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
000505 char *z1;
000506 const char *z2;
000507 int i, n;
000508 UNUSED_PARAMETER(argc);
000509 z2 = (char*)sqlite3_value_text(argv[0]);
000510 n = sqlite3_value_bytes(argv[0]);
000511 /* Verify that the call to _bytes() does not invalidate the _text() pointer */
000512 assert( z2==(char*)sqlite3_value_text(argv[0]) );
000513 if( z2 ){
000514 z1 = contextMalloc(context, ((i64)n)+1);
000515 if( z1 ){
000516 for(i=0; i<n; i++){
000517 z1[i] = (char)sqlite3Toupper(z2[i]);
000518 }
000519 sqlite3_result_text(context, z1, n, sqlite3_free);
000520 }
000521 }
000522 }
000523 static void lowerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
000524 char *z1;
000525 const char *z2;
000526 int i, n;
000527 UNUSED_PARAMETER(argc);
000528 z2 = (char*)sqlite3_value_text(argv[0]);
000529 n = sqlite3_value_bytes(argv[0]);
000530 /* Verify that the call to _bytes() does not invalidate the _text() pointer */
000531 assert( z2==(char*)sqlite3_value_text(argv[0]) );
000532 if( z2 ){
000533 z1 = contextMalloc(context, ((i64)n)+1);
000534 if( z1 ){
000535 for(i=0; i<n; i++){
000536 z1[i] = sqlite3Tolower(z2[i]);
000537 }
000538 sqlite3_result_text(context, z1, n, sqlite3_free);
000539 }
000540 }
000541 }
000542
000543 /*
000544 ** Some functions like COALESCE() and IFNULL() and UNLIKELY() are implemented
000545 ** as VDBE code so that unused argument values do not have to be computed.
000546 ** However, we still need some kind of function implementation for this
000547 ** routines in the function table. The noopFunc macro provides this.
000548 ** noopFunc will never be called so it doesn't matter what the implementation
000549 ** is. We might as well use the "version()" function as a substitute.
000550 */
000551 #define noopFunc versionFunc /* Substitute function - never called */
000552
000553 /*
000554 ** Implementation of random(). Return a random integer.
000555 */
000556 static void randomFunc(
000557 sqlite3_context *context,
000558 int NotUsed,
000559 sqlite3_value **NotUsed2
000560 ){
000561 sqlite_int64 r;
000562 UNUSED_PARAMETER2(NotUsed, NotUsed2);
000563 sqlite3_randomness(sizeof(r), &r);
000564 if( r<0 ){
000565 /* We need to prevent a random number of 0x8000000000000000
000566 ** (or -9223372036854775808) since when you do abs() of that
000567 ** number of you get the same value back again. To do this
000568 ** in a way that is testable, mask the sign bit off of negative
000569 ** values, resulting in a positive value. Then take the
000570 ** 2s complement of that positive value. The end result can
000571 ** therefore be no less than -9223372036854775807.
000572 */
000573 r = -(r & LARGEST_INT64);
000574 }
000575 sqlite3_result_int64(context, r);
000576 }
000577
000578 /*
000579 ** Implementation of randomblob(N). Return a random blob
000580 ** that is N bytes long.
000581 */
000582 static void randomBlob(
000583 sqlite3_context *context,
000584 int argc,
000585 sqlite3_value **argv
000586 ){
000587 sqlite3_int64 n;
000588 unsigned char *p;
000589 assert( argc==1 );
000590 UNUSED_PARAMETER(argc);
000591 n = sqlite3_value_int64(argv[0]);
000592 if( n<1 ){
000593 n = 1;
000594 }
000595 p = contextMalloc(context, n);
000596 if( p ){
000597 sqlite3_randomness(n, p);
000598 sqlite3_result_blob(context, (char*)p, n, sqlite3_free);
000599 }
000600 }
000601
000602 /*
000603 ** Implementation of the last_insert_rowid() SQL function. The return
000604 ** value is the same as the sqlite3_last_insert_rowid() API function.
000605 */
000606 static void last_insert_rowid(
000607 sqlite3_context *context,
000608 int NotUsed,
000609 sqlite3_value **NotUsed2
000610 ){
000611 sqlite3 *db = sqlite3_context_db_handle(context);
000612 UNUSED_PARAMETER2(NotUsed, NotUsed2);
000613 /* IMP: R-51513-12026 The last_insert_rowid() SQL function is a
000614 ** wrapper around the sqlite3_last_insert_rowid() C/C++ interface
000615 ** function. */
000616 sqlite3_result_int64(context, sqlite3_last_insert_rowid(db));
000617 }
000618
000619 /*
000620 ** Implementation of the changes() SQL function.
000621 **
000622 ** IMP: R-32760-32347 The changes() SQL function is a wrapper
000623 ** around the sqlite3_changes64() C/C++ function and hence follows the
000624 ** same rules for counting changes.
000625 */
000626 static void changes(
000627 sqlite3_context *context,
000628 int NotUsed,
000629 sqlite3_value **NotUsed2
000630 ){
000631 sqlite3 *db = sqlite3_context_db_handle(context);
000632 UNUSED_PARAMETER2(NotUsed, NotUsed2);
000633 sqlite3_result_int64(context, sqlite3_changes64(db));
000634 }
000635
000636 /*
000637 ** Implementation of the total_changes() SQL function. The return value is
000638 ** the same as the sqlite3_total_changes64() API function.
000639 */
000640 static void total_changes(
000641 sqlite3_context *context,
000642 int NotUsed,
000643 sqlite3_value **NotUsed2
000644 ){
000645 sqlite3 *db = sqlite3_context_db_handle(context);
000646 UNUSED_PARAMETER2(NotUsed, NotUsed2);
000647 /* IMP: R-11217-42568 This function is a wrapper around the
000648 ** sqlite3_total_changes64() C/C++ interface. */
000649 sqlite3_result_int64(context, sqlite3_total_changes64(db));
000650 }
000651
000652 /*
000653 ** A structure defining how to do GLOB-style comparisons.
000654 */
000655 struct compareInfo {
000656 u8 matchAll; /* "*" or "%" */
000657 u8 matchOne; /* "?" or "_" */
000658 u8 matchSet; /* "[" or 0 */
000659 u8 noCase; /* true to ignore case differences */
000660 };
000661
000662 /*
000663 ** For LIKE and GLOB matching on EBCDIC machines, assume that every
000664 ** character is exactly one byte in size. Also, provide the Utf8Read()
000665 ** macro for fast reading of the next character in the common case where
000666 ** the next character is ASCII.
000667 */
000668 #if defined(SQLITE_EBCDIC)
000669 # define sqlite3Utf8Read(A) (*((*A)++))
000670 # define Utf8Read(A) (*(A++))
000671 #else
000672 # define Utf8Read(A) (A[0]<0x80?*(A++):sqlite3Utf8Read(&A))
000673 #endif
000674
000675 static const struct compareInfo globInfo = { '*', '?', '[', 0 };
000676 /* The correct SQL-92 behavior is for the LIKE operator to ignore
000677 ** case. Thus 'a' LIKE 'A' would be true. */
000678 static const struct compareInfo likeInfoNorm = { '%', '_', 0, 1 };
000679 /* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator
000680 ** is case sensitive causing 'a' LIKE 'A' to be false */
000681 static const struct compareInfo likeInfoAlt = { '%', '_', 0, 0 };
000682
000683 /*
000684 ** Possible error returns from patternMatch()
000685 */
000686 #define SQLITE_MATCH 0
000687 #define SQLITE_NOMATCH 1
000688 #define SQLITE_NOWILDCARDMATCH 2
000689
000690 /*
000691 ** Compare two UTF-8 strings for equality where the first string is
000692 ** a GLOB or LIKE expression. Return values:
000693 **
000694 ** SQLITE_MATCH: Match
000695 ** SQLITE_NOMATCH: No match
000696 ** SQLITE_NOWILDCARDMATCH: No match in spite of having * or % wildcards.
000697 **
000698 ** Globbing rules:
000699 **
000700 ** '*' Matches any sequence of zero or more characters.
000701 **
000702 ** '?' Matches exactly one character.
000703 **
000704 ** [...] Matches one character from the enclosed list of
000705 ** characters.
000706 **
000707 ** [^...] Matches one character not in the enclosed list.
000708 **
000709 ** With the [...] and [^...] matching, a ']' character can be included
000710 ** in the list by making it the first character after '[' or '^'. A
000711 ** range of characters can be specified using '-'. Example:
000712 ** "[a-z]" matches any single lower-case letter. To match a '-', make
000713 ** it the last character in the list.
000714 **
000715 ** Like matching rules:
000716 **
000717 ** '%' Matches any sequence of zero or more characters
000718 **
000719 *** '_' Matches any one character
000720 **
000721 ** Ec Where E is the "esc" character and c is any other
000722 ** character, including '%', '_', and esc, match exactly c.
000723 **
000724 ** The comments within this routine usually assume glob matching.
000725 **
000726 ** This routine is usually quick, but can be N**2 in the worst case.
000727 */
000728 static int patternCompare(
000729 const u8 *zPattern, /* The glob pattern */
000730 const u8 *zString, /* The string to compare against the glob */
000731 const struct compareInfo *pInfo, /* Information about how to do the compare */
000732 u32 matchOther /* The escape char (LIKE) or '[' (GLOB) */
000733 ){
000734 u32 c, c2; /* Next pattern and input string chars */
000735 u32 matchOne = pInfo->matchOne; /* "?" or "_" */
000736 u32 matchAll = pInfo->matchAll; /* "*" or "%" */
000737 u8 noCase = pInfo->noCase; /* True if uppercase==lowercase */
000738 const u8 *zEscaped = 0; /* One past the last escaped input char */
000739
000740 while( (c = Utf8Read(zPattern))!=0 ){
000741 if( c==matchAll ){ /* Match "*" */
000742 /* Skip over multiple "*" characters in the pattern. If there
000743 ** are also "?" characters, skip those as well, but consume a
000744 ** single character of the input string for each "?" skipped */
000745 while( (c=Utf8Read(zPattern)) == matchAll
000746 || (c == matchOne && matchOne!=0) ){
000747 if( c==matchOne && sqlite3Utf8Read(&zString)==0 ){
000748 return SQLITE_NOWILDCARDMATCH;
000749 }
000750 }
000751 if( c==0 ){
000752 return SQLITE_MATCH; /* "*" at the end of the pattern matches */
000753 }else if( c==matchOther ){
000754 if( pInfo->matchSet==0 ){
000755 c = sqlite3Utf8Read(&zPattern);
000756 if( c==0 ) return SQLITE_NOWILDCARDMATCH;
000757 }else{
000758 /* "[...]" immediately follows the "*". We have to do a slow
000759 ** recursive search in this case, but it is an unusual case. */
000760 assert( matchOther<0x80 ); /* '[' is a single-byte character */
000761 while( *zString ){
000762 int bMatch = patternCompare(&zPattern[-1],zString,pInfo,matchOther);
000763 if( bMatch!=SQLITE_NOMATCH ) return bMatch;
000764 SQLITE_SKIP_UTF8(zString);
000765 }
000766 return SQLITE_NOWILDCARDMATCH;
000767 }
000768 }
000769
000770 /* At this point variable c contains the first character of the
000771 ** pattern string past the "*". Search in the input string for the
000772 ** first matching character and recursively continue the match from
000773 ** that point.
000774 **
000775 ** For a case-insensitive search, set variable cx to be the same as
000776 ** c but in the other case and search the input string for either
000777 ** c or cx.
000778 */
000779 if( c<0x80 ){
000780 char zStop[3];
000781 int bMatch;
000782 if( noCase ){
000783 zStop[0] = sqlite3Toupper(c);
000784 zStop[1] = sqlite3Tolower(c);
000785 zStop[2] = 0;
000786 }else{
000787 zStop[0] = c;
000788 zStop[1] = 0;
000789 }
000790 while(1){
000791 zString += strcspn((const char*)zString, zStop);
000792 if( zString[0]==0 ) break;
000793 zString++;
000794 bMatch = patternCompare(zPattern,zString,pInfo,matchOther);
000795 if( bMatch!=SQLITE_NOMATCH ) return bMatch;
000796 }
000797 }else{
000798 int bMatch;
000799 while( (c2 = Utf8Read(zString))!=0 ){
000800 if( c2!=c ) continue;
000801 bMatch = patternCompare(zPattern,zString,pInfo,matchOther);
000802 if( bMatch!=SQLITE_NOMATCH ) return bMatch;
000803 }
000804 }
000805 return SQLITE_NOWILDCARDMATCH;
000806 }
000807 if( c==matchOther ){
000808 if( pInfo->matchSet==0 ){
000809 c = sqlite3Utf8Read(&zPattern);
000810 if( c==0 ) return SQLITE_NOMATCH;
000811 zEscaped = zPattern;
000812 }else{
000813 u32 prior_c = 0;
000814 int seen = 0;
000815 int invert = 0;
000816 c = sqlite3Utf8Read(&zString);
000817 if( c==0 ) return SQLITE_NOMATCH;
000818 c2 = sqlite3Utf8Read(&zPattern);
000819 if( c2=='^' ){
000820 invert = 1;
000821 c2 = sqlite3Utf8Read(&zPattern);
000822 }
000823 if( c2==']' ){
000824 if( c==']' ) seen = 1;
000825 c2 = sqlite3Utf8Read(&zPattern);
000826 }
000827 while( c2 && c2!=']' ){
000828 if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){
000829 c2 = sqlite3Utf8Read(&zPattern);
000830 if( c>=prior_c && c<=c2 ) seen = 1;
000831 prior_c = 0;
000832 }else{
000833 if( c==c2 ){
000834 seen = 1;
000835 }
000836 prior_c = c2;
000837 }
000838 c2 = sqlite3Utf8Read(&zPattern);
000839 }
000840 if( c2==0 || (seen ^ invert)==0 ){
000841 return SQLITE_NOMATCH;
000842 }
000843 continue;
000844 }
000845 }
000846 c2 = Utf8Read(zString);
000847 if( c==c2 ) continue;
000848 if( noCase && sqlite3Tolower(c)==sqlite3Tolower(c2) && c<0x80 && c2<0x80 ){
000849 continue;
000850 }
000851 if( c==matchOne && zPattern!=zEscaped && c2!=0 ) continue;
000852 return SQLITE_NOMATCH;
000853 }
000854 return *zString==0 ? SQLITE_MATCH : SQLITE_NOMATCH;
000855 }
000856
000857 /*
000858 ** The sqlite3_strglob() interface. Return 0 on a match (like strcmp()) and
000859 ** non-zero if there is no match.
000860 */
000861 int sqlite3_strglob(const char *zGlobPattern, const char *zString){
000862 if( zString==0 ){
000863 return zGlobPattern!=0;
000864 }else if( zGlobPattern==0 ){
000865 return 1;
000866 }else {
000867 return patternCompare((u8*)zGlobPattern, (u8*)zString, &globInfo, '[');
000868 }
000869 }
000870
000871 /*
000872 ** The sqlite3_strlike() interface. Return 0 on a match and non-zero for
000873 ** a miss - like strcmp().
000874 */
000875 int sqlite3_strlike(const char *zPattern, const char *zStr, unsigned int esc){
000876 if( zStr==0 ){
000877 return zPattern!=0;
000878 }else if( zPattern==0 ){
000879 return 1;
000880 }else{
000881 return patternCompare((u8*)zPattern, (u8*)zStr, &likeInfoNorm, esc);
000882 }
000883 }
000884
000885 /*
000886 ** Count the number of times that the LIKE operator (or GLOB which is
000887 ** just a variation of LIKE) gets called. This is used for testing
000888 ** only.
000889 */
000890 #ifdef SQLITE_TEST
000891 int sqlite3_like_count = 0;
000892 #endif
000893
000894
000895 /*
000896 ** Implementation of the like() SQL function. This function implements
000897 ** the built-in LIKE operator. The first argument to the function is the
000898 ** pattern and the second argument is the string. So, the SQL statements:
000899 **
000900 ** A LIKE B
000901 **
000902 ** is implemented as like(B,A).
000903 **
000904 ** This same function (with a different compareInfo structure) computes
000905 ** the GLOB operator.
000906 */
000907 static void likeFunc(
000908 sqlite3_context *context,
000909 int argc,
000910 sqlite3_value **argv
000911 ){
000912 const unsigned char *zA, *zB;
000913 u32 escape;
000914 int nPat;
000915 sqlite3 *db = sqlite3_context_db_handle(context);
000916 struct compareInfo *pInfo = sqlite3_user_data(context);
000917 struct compareInfo backupInfo;
000918
000919 #ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS
000920 if( sqlite3_value_type(argv[0])==SQLITE_BLOB
000921 || sqlite3_value_type(argv[1])==SQLITE_BLOB
000922 ){
000923 #ifdef SQLITE_TEST
000924 sqlite3_like_count++;
000925 #endif
000926 sqlite3_result_int(context, 0);
000927 return;
000928 }
000929 #endif
000930
000931 /* Limit the length of the LIKE or GLOB pattern to avoid problems
000932 ** of deep recursion and N*N behavior in patternCompare().
000933 */
000934 nPat = sqlite3_value_bytes(argv[0]);
000935 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] );
000936 testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 );
000937 if( nPat > db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){
000938 sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);
000939 return;
000940 }
000941 if( argc==3 ){
000942 /* The escape character string must consist of a single UTF-8 character.
000943 ** Otherwise, return an error.
000944 */
000945 const unsigned char *zEsc = sqlite3_value_text(argv[2]);
000946 if( zEsc==0 ) return;
000947 if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){
000948 sqlite3_result_error(context,
000949 "ESCAPE expression must be a single character", -1);
000950 return;
000951 }
000952 escape = sqlite3Utf8Read(&zEsc);
000953 if( escape==pInfo->matchAll || escape==pInfo->matchOne ){
000954 memcpy(&backupInfo, pInfo, sizeof(backupInfo));
000955 pInfo = &backupInfo;
000956 if( escape==pInfo->matchAll ) pInfo->matchAll = 0;
000957 if( escape==pInfo->matchOne ) pInfo->matchOne = 0;
000958 }
000959 }else{
000960 escape = pInfo->matchSet;
000961 }
000962 zB = sqlite3_value_text(argv[0]);
000963 zA = sqlite3_value_text(argv[1]);
000964 if( zA && zB ){
000965 #ifdef SQLITE_TEST
000966 sqlite3_like_count++;
000967 #endif
000968 sqlite3_result_int(context,
000969 patternCompare(zB, zA, pInfo, escape)==SQLITE_MATCH);
000970 }
000971 }
000972
000973 /*
000974 ** Implementation of the NULLIF(x,y) function. The result is the first
000975 ** argument if the arguments are different. The result is NULL if the
000976 ** arguments are equal to each other.
000977 */
000978 static void nullifFunc(
000979 sqlite3_context *context,
000980 int NotUsed,
000981 sqlite3_value **argv
000982 ){
000983 CollSeq *pColl = sqlite3GetFuncCollSeq(context);
000984 UNUSED_PARAMETER(NotUsed);
000985 if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){
000986 sqlite3_result_value(context, argv[0]);
000987 }
000988 }
000989
000990 /*
000991 ** Implementation of the sqlite_version() function. The result is the version
000992 ** of the SQLite library that is running.
000993 */
000994 static void versionFunc(
000995 sqlite3_context *context,
000996 int NotUsed,
000997 sqlite3_value **NotUsed2
000998 ){
000999 UNUSED_PARAMETER2(NotUsed, NotUsed2);
001000 /* IMP: R-48699-48617 This function is an SQL wrapper around the
001001 ** sqlite3_libversion() C-interface. */
001002 sqlite3_result_text(context, sqlite3_libversion(), -1, SQLITE_STATIC);
001003 }
001004
001005 /*
001006 ** Implementation of the sqlite_source_id() function. The result is a string
001007 ** that identifies the particular version of the source code used to build
001008 ** SQLite.
001009 */
001010 static void sourceidFunc(
001011 sqlite3_context *context,
001012 int NotUsed,
001013 sqlite3_value **NotUsed2
001014 ){
001015 UNUSED_PARAMETER2(NotUsed, NotUsed2);
001016 /* IMP: R-24470-31136 This function is an SQL wrapper around the
001017 ** sqlite3_sourceid() C interface. */
001018 sqlite3_result_text(context, sqlite3_sourceid(), -1, SQLITE_STATIC);
001019 }
001020
001021 /*
001022 ** Implementation of the sqlite_log() function. This is a wrapper around
001023 ** sqlite3_log(). The return value is NULL. The function exists purely for
001024 ** its side-effects.
001025 */
001026 static void errlogFunc(
001027 sqlite3_context *context,
001028 int argc,
001029 sqlite3_value **argv
001030 ){
001031 UNUSED_PARAMETER(argc);
001032 UNUSED_PARAMETER(context);
001033 sqlite3_log(sqlite3_value_int(argv[0]), "%s", sqlite3_value_text(argv[1]));
001034 }
001035
001036 /*
001037 ** Implementation of the sqlite_compileoption_used() function.
001038 ** The result is an integer that identifies if the compiler option
001039 ** was used to build SQLite.
001040 */
001041 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
001042 static void compileoptionusedFunc(
001043 sqlite3_context *context,
001044 int argc,
001045 sqlite3_value **argv
001046 ){
001047 const char *zOptName;
001048 assert( argc==1 );
001049 UNUSED_PARAMETER(argc);
001050 /* IMP: R-39564-36305 The sqlite_compileoption_used() SQL
001051 ** function is a wrapper around the sqlite3_compileoption_used() C/C++
001052 ** function.
001053 */
001054 if( (zOptName = (const char*)sqlite3_value_text(argv[0]))!=0 ){
001055 sqlite3_result_int(context, sqlite3_compileoption_used(zOptName));
001056 }
001057 }
001058 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
001059
001060 /*
001061 ** Implementation of the sqlite_compileoption_get() function.
001062 ** The result is a string that identifies the compiler options
001063 ** used to build SQLite.
001064 */
001065 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
001066 static void compileoptiongetFunc(
001067 sqlite3_context *context,
001068 int argc,
001069 sqlite3_value **argv
001070 ){
001071 int n;
001072 assert( argc==1 );
001073 UNUSED_PARAMETER(argc);
001074 /* IMP: R-04922-24076 The sqlite_compileoption_get() SQL function
001075 ** is a wrapper around the sqlite3_compileoption_get() C/C++ function.
001076 */
001077 n = sqlite3_value_int(argv[0]);
001078 sqlite3_result_text(context, sqlite3_compileoption_get(n), -1, SQLITE_STATIC);
001079 }
001080 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
001081
001082 /* Array for converting from half-bytes (nybbles) into ASCII hex
001083 ** digits. */
001084 static const char hexdigits[] = {
001085 '0', '1', '2', '3', '4', '5', '6', '7',
001086 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
001087 };
001088
001089 /*
001090 ** Append to pStr text that is the SQL literal representation of the
001091 ** value contained in pValue.
001092 */
001093 void sqlite3QuoteValue(StrAccum *pStr, sqlite3_value *pValue){
001094 /* As currently implemented, the string must be initially empty.
001095 ** we might relax this requirement in the future, but that will
001096 ** require enhancements to the implementation. */
001097 assert( pStr!=0 && pStr->nChar==0 );
001098
001099 switch( sqlite3_value_type(pValue) ){
001100 case SQLITE_FLOAT: {
001101 double r1, r2;
001102 const char *zVal;
001103 r1 = sqlite3_value_double(pValue);
001104 sqlite3_str_appendf(pStr, "%!0.15g", r1);
001105 zVal = sqlite3_str_value(pStr);
001106 if( zVal ){
001107 sqlite3AtoF(zVal, &r2, pStr->nChar, SQLITE_UTF8);
001108 if( r1!=r2 ){
001109 sqlite3_str_reset(pStr);
001110 sqlite3_str_appendf(pStr, "%!0.20e", r1);
001111 }
001112 }
001113 break;
001114 }
001115 case SQLITE_INTEGER: {
001116 sqlite3_str_appendf(pStr, "%lld", sqlite3_value_int64(pValue));
001117 break;
001118 }
001119 case SQLITE_BLOB: {
001120 char const *zBlob = sqlite3_value_blob(pValue);
001121 i64 nBlob = sqlite3_value_bytes(pValue);
001122 assert( zBlob==sqlite3_value_blob(pValue) ); /* No encoding change */
001123 sqlite3StrAccumEnlarge(pStr, nBlob*2 + 4);
001124 if( pStr->accError==0 ){
001125 char *zText = pStr->zText;
001126 int i;
001127 for(i=0; i<nBlob; i++){
001128 zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F];
001129 zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F];
001130 }
001131 zText[(nBlob*2)+2] = '\'';
001132 zText[(nBlob*2)+3] = '\0';
001133 zText[0] = 'X';
001134 zText[1] = '\'';
001135 pStr->nChar = nBlob*2 + 3;
001136 }
001137 break;
001138 }
001139 case SQLITE_TEXT: {
001140 const unsigned char *zArg = sqlite3_value_text(pValue);
001141 sqlite3_str_appendf(pStr, "%Q", zArg);
001142 break;
001143 }
001144 default: {
001145 assert( sqlite3_value_type(pValue)==SQLITE_NULL );
001146 sqlite3_str_append(pStr, "NULL", 4);
001147 break;
001148 }
001149 }
001150 }
001151
001152 /*
001153 ** Implementation of the QUOTE() function.
001154 **
001155 ** The quote(X) function returns the text of an SQL literal which is the
001156 ** value of its argument suitable for inclusion into an SQL statement.
001157 ** Strings are surrounded by single-quotes with escapes on interior quotes
001158 ** as needed. BLOBs are encoded as hexadecimal literals. Strings with
001159 ** embedded NUL characters cannot be represented as string literals in SQL
001160 ** and hence the returned string literal is truncated prior to the first NUL.
001161 */
001162 static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
001163 sqlite3_str str;
001164 sqlite3 *db = sqlite3_context_db_handle(context);
001165 assert( argc==1 );
001166 UNUSED_PARAMETER(argc);
001167 sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]);
001168 sqlite3QuoteValue(&str,argv[0]);
001169 sqlite3_result_text(context, sqlite3StrAccumFinish(&str), str.nChar,
001170 SQLITE_DYNAMIC);
001171 if( str.accError!=SQLITE_OK ){
001172 sqlite3_result_null(context);
001173 sqlite3_result_error_code(context, str.accError);
001174 }
001175 }
001176
001177 /*
001178 ** The unicode() function. Return the integer unicode code-point value
001179 ** for the first character of the input string.
001180 */
001181 static void unicodeFunc(
001182 sqlite3_context *context,
001183 int argc,
001184 sqlite3_value **argv
001185 ){
001186 const unsigned char *z = sqlite3_value_text(argv[0]);
001187 (void)argc;
001188 if( z && z[0] ) sqlite3_result_int(context, sqlite3Utf8Read(&z));
001189 }
001190
001191 /*
001192 ** The char() function takes zero or more arguments, each of which is
001193 ** an integer. It constructs a string where each character of the string
001194 ** is the unicode character for the corresponding integer argument.
001195 */
001196 static void charFunc(
001197 sqlite3_context *context,
001198 int argc,
001199 sqlite3_value **argv
001200 ){
001201 unsigned char *z, *zOut;
001202 int i;
001203 zOut = z = sqlite3_malloc64( argc*4+1 );
001204 if( z==0 ){
001205 sqlite3_result_error_nomem(context);
001206 return;
001207 }
001208 for(i=0; i<argc; i++){
001209 sqlite3_int64 x;
001210 unsigned c;
001211 x = sqlite3_value_int64(argv[i]);
001212 if( x<0 || x>0x10ffff ) x = 0xfffd;
001213 c = (unsigned)(x & 0x1fffff);
001214 if( c<0x00080 ){
001215 *zOut++ = (u8)(c&0xFF);
001216 }else if( c<0x00800 ){
001217 *zOut++ = 0xC0 + (u8)((c>>6)&0x1F);
001218 *zOut++ = 0x80 + (u8)(c & 0x3F);
001219 }else if( c<0x10000 ){
001220 *zOut++ = 0xE0 + (u8)((c>>12)&0x0F);
001221 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);
001222 *zOut++ = 0x80 + (u8)(c & 0x3F);
001223 }else{
001224 *zOut++ = 0xF0 + (u8)((c>>18) & 0x07);
001225 *zOut++ = 0x80 + (u8)((c>>12) & 0x3F);
001226 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);
001227 *zOut++ = 0x80 + (u8)(c & 0x3F);
001228 } \
001229 }
001230 *zOut = 0;
001231 sqlite3_result_text64(context, (char*)z, zOut-z, sqlite3_free, SQLITE_UTF8);
001232 }
001233
001234 /*
001235 ** The hex() function. Interpret the argument as a blob. Return
001236 ** a hexadecimal rendering as text.
001237 */
001238 static void hexFunc(
001239 sqlite3_context *context,
001240 int argc,
001241 sqlite3_value **argv
001242 ){
001243 int i, n;
001244 const unsigned char *pBlob;
001245 char *zHex, *z;
001246 assert( argc==1 );
001247 UNUSED_PARAMETER(argc);
001248 pBlob = sqlite3_value_blob(argv[0]);
001249 n = sqlite3_value_bytes(argv[0]);
001250 assert( pBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */
001251 z = zHex = contextMalloc(context, ((i64)n)*2 + 1);
001252 if( zHex ){
001253 for(i=0; i<n; i++, pBlob++){
001254 unsigned char c = *pBlob;
001255 *(z++) = hexdigits[(c>>4)&0xf];
001256 *(z++) = hexdigits[c&0xf];
001257 }
001258 *z = 0;
001259 sqlite3_result_text64(context, zHex, (u64)(z-zHex),
001260 sqlite3_free, SQLITE_UTF8);
001261 }
001262 }
001263
001264 /*
001265 ** Buffer zStr contains nStr bytes of utf-8 encoded text. Return 1 if zStr
001266 ** contains character ch, or 0 if it does not.
001267 */
001268 static int strContainsChar(const u8 *zStr, int nStr, u32 ch){
001269 const u8 *zEnd = &zStr[nStr];
001270 const u8 *z = zStr;
001271 while( z<zEnd ){
001272 u32 tst = Utf8Read(z);
001273 if( tst==ch ) return 1;
001274 }
001275 return 0;
001276 }
001277
001278 /*
001279 ** The unhex() function. This function may be invoked with either one or
001280 ** two arguments. In both cases the first argument is interpreted as text
001281 ** a text value containing a set of pairs of hexadecimal digits which are
001282 ** decoded and returned as a blob.
001283 **
001284 ** If there is only a single argument, then it must consist only of an
001285 ** even number of hexadecimal digits. Otherwise, return NULL.
001286 **
001287 ** Or, if there is a second argument, then any character that appears in
001288 ** the second argument is also allowed to appear between pairs of hexadecimal
001289 ** digits in the first argument. If any other character appears in the
001290 ** first argument, or if one of the allowed characters appears between
001291 ** two hexadecimal digits that make up a single byte, NULL is returned.
001292 **
001293 ** The following expressions are all true:
001294 **
001295 ** unhex('ABCD') IS x'ABCD'
001296 ** unhex('AB CD') IS NULL
001297 ** unhex('AB CD', ' ') IS x'ABCD'
001298 ** unhex('A BCD', ' ') IS NULL
001299 */
001300 static void unhexFunc(
001301 sqlite3_context *pCtx,
001302 int argc,
001303 sqlite3_value **argv
001304 ){
001305 const u8 *zPass = (const u8*)"";
001306 int nPass = 0;
001307 const u8 *zHex = sqlite3_value_text(argv[0]);
001308 int nHex = sqlite3_value_bytes(argv[0]);
001309 #ifdef SQLITE_DEBUG
001310 const u8 *zEnd = zHex ? &zHex[nHex] : 0;
001311 #endif
001312 u8 *pBlob = 0;
001313 u8 *p = 0;
001314
001315 assert( argc==1 || argc==2 );
001316 if( argc==2 ){
001317 zPass = sqlite3_value_text(argv[1]);
001318 nPass = sqlite3_value_bytes(argv[1]);
001319 }
001320 if( !zHex || !zPass ) return;
001321
001322 p = pBlob = contextMalloc(pCtx, (nHex/2)+1);
001323 if( pBlob ){
001324 u8 c; /* Most significant digit of next byte */
001325 u8 d; /* Least significant digit of next byte */
001326
001327 while( (c = *zHex)!=0x00 ){
001328 while( !sqlite3Isxdigit(c) ){
001329 u32 ch = Utf8Read(zHex);
001330 assert( zHex<=zEnd );
001331 if( !strContainsChar(zPass, nPass, ch) ) goto unhex_null;
001332 c = *zHex;
001333 if( c==0x00 ) goto unhex_done;
001334 }
001335 zHex++;
001336 assert( *zEnd==0x00 );
001337 assert( zHex<=zEnd );
001338 d = *(zHex++);
001339 if( !sqlite3Isxdigit(d) ) goto unhex_null;
001340 *(p++) = (sqlite3HexToInt(c)<<4) | sqlite3HexToInt(d);
001341 }
001342 }
001343
001344 unhex_done:
001345 sqlite3_result_blob(pCtx, pBlob, (p - pBlob), sqlite3_free);
001346 return;
001347
001348 unhex_null:
001349 sqlite3_free(pBlob);
001350 return;
001351 }
001352
001353
001354 /*
001355 ** The zeroblob(N) function returns a zero-filled blob of size N bytes.
001356 */
001357 static void zeroblobFunc(
001358 sqlite3_context *context,
001359 int argc,
001360 sqlite3_value **argv
001361 ){
001362 i64 n;
001363 int rc;
001364 assert( argc==1 );
001365 UNUSED_PARAMETER(argc);
001366 n = sqlite3_value_int64(argv[0]);
001367 if( n<0 ) n = 0;
001368 rc = sqlite3_result_zeroblob64(context, n); /* IMP: R-00293-64994 */
001369 if( rc ){
001370 sqlite3_result_error_code(context, rc);
001371 }
001372 }
001373
001374 /*
001375 ** The replace() function. Three arguments are all strings: call
001376 ** them A, B, and C. The result is also a string which is derived
001377 ** from A by replacing every occurrence of B with C. The match
001378 ** must be exact. Collating sequences are not used.
001379 */
001380 static void replaceFunc(
001381 sqlite3_context *context,
001382 int argc,
001383 sqlite3_value **argv
001384 ){
001385 const unsigned char *zStr; /* The input string A */
001386 const unsigned char *zPattern; /* The pattern string B */
001387 const unsigned char *zRep; /* The replacement string C */
001388 unsigned char *zOut; /* The output */
001389 int nStr; /* Size of zStr */
001390 int nPattern; /* Size of zPattern */
001391 int nRep; /* Size of zRep */
001392 i64 nOut; /* Maximum size of zOut */
001393 int loopLimit; /* Last zStr[] that might match zPattern[] */
001394 int i, j; /* Loop counters */
001395 unsigned cntExpand; /* Number zOut expansions */
001396 sqlite3 *db = sqlite3_context_db_handle(context);
001397
001398 assert( argc==3 );
001399 UNUSED_PARAMETER(argc);
001400 zStr = sqlite3_value_text(argv[0]);
001401 if( zStr==0 ) return;
001402 nStr = sqlite3_value_bytes(argv[0]);
001403 assert( zStr==sqlite3_value_text(argv[0]) ); /* No encoding change */
001404 zPattern = sqlite3_value_text(argv[1]);
001405 if( zPattern==0 ){
001406 assert( sqlite3_value_type(argv[1])==SQLITE_NULL
001407 || sqlite3_context_db_handle(context)->mallocFailed );
001408 return;
001409 }
001410 if( zPattern[0]==0 ){
001411 assert( sqlite3_value_type(argv[1])!=SQLITE_NULL );
001412 sqlite3_result_text(context, (const char*)zStr, nStr, SQLITE_TRANSIENT);
001413 return;
001414 }
001415 nPattern = sqlite3_value_bytes(argv[1]);
001416 assert( zPattern==sqlite3_value_text(argv[1]) ); /* No encoding change */
001417 zRep = sqlite3_value_text(argv[2]);
001418 if( zRep==0 ) return;
001419 nRep = sqlite3_value_bytes(argv[2]);
001420 assert( zRep==sqlite3_value_text(argv[2]) );
001421 nOut = nStr + 1;
001422 assert( nOut<SQLITE_MAX_LENGTH );
001423 zOut = contextMalloc(context, (i64)nOut);
001424 if( zOut==0 ){
001425 return;
001426 }
001427 loopLimit = nStr - nPattern;
001428 cntExpand = 0;
001429 for(i=j=0; i<=loopLimit; i++){
001430 if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){
001431 zOut[j++] = zStr[i];
001432 }else{
001433 if( nRep>nPattern ){
001434 nOut += nRep - nPattern;
001435 testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] );
001436 testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] );
001437 if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
001438 sqlite3_result_error_toobig(context);
001439 sqlite3_free(zOut);
001440 return;
001441 }
001442 cntExpand++;
001443 if( (cntExpand&(cntExpand-1))==0 ){
001444 /* Grow the size of the output buffer only on substitutions
001445 ** whose index is a power of two: 1, 2, 4, 8, 16, 32, ... */
001446 u8 *zOld;
001447 zOld = zOut;
001448 zOut = sqlite3Realloc(zOut, (int)nOut + (nOut - nStr - 1));
001449 if( zOut==0 ){
001450 sqlite3_result_error_nomem(context);
001451 sqlite3_free(zOld);
001452 return;
001453 }
001454 }
001455 }
001456 memcpy(&zOut[j], zRep, nRep);
001457 j += nRep;
001458 i += nPattern-1;
001459 }
001460 }
001461 assert( j+nStr-i+1<=nOut );
001462 memcpy(&zOut[j], &zStr[i], nStr-i);
001463 j += nStr - i;
001464 assert( j<=nOut );
001465 zOut[j] = 0;
001466 sqlite3_result_text(context, (char*)zOut, j, sqlite3_free);
001467 }
001468
001469 /*
001470 ** Implementation of the TRIM(), LTRIM(), and RTRIM() functions.
001471 ** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both.
001472 */
001473 static void trimFunc(
001474 sqlite3_context *context,
001475 int argc,
001476 sqlite3_value **argv
001477 ){
001478 const unsigned char *zIn; /* Input string */
001479 const unsigned char *zCharSet; /* Set of characters to trim */
001480 unsigned int nIn; /* Number of bytes in input */
001481 int flags; /* 1: trimleft 2: trimright 3: trim */
001482 int i; /* Loop counter */
001483 unsigned int *aLen = 0; /* Length of each character in zCharSet */
001484 unsigned char **azChar = 0; /* Individual characters in zCharSet */
001485 int nChar; /* Number of characters in zCharSet */
001486
001487 if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
001488 return;
001489 }
001490 zIn = sqlite3_value_text(argv[0]);
001491 if( zIn==0 ) return;
001492 nIn = (unsigned)sqlite3_value_bytes(argv[0]);
001493 assert( zIn==sqlite3_value_text(argv[0]) );
001494 if( argc==1 ){
001495 static const unsigned lenOne[] = { 1 };
001496 static unsigned char * const azOne[] = { (u8*)" " };
001497 nChar = 1;
001498 aLen = (unsigned*)lenOne;
001499 azChar = (unsigned char **)azOne;
001500 zCharSet = 0;
001501 }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){
001502 return;
001503 }else{
001504 const unsigned char *z;
001505 for(z=zCharSet, nChar=0; *z; nChar++){
001506 SQLITE_SKIP_UTF8(z);
001507 }
001508 if( nChar>0 ){
001509 azChar = contextMalloc(context,
001510 ((i64)nChar)*(sizeof(char*)+sizeof(unsigned)));
001511 if( azChar==0 ){
001512 return;
001513 }
001514 aLen = (unsigned*)&azChar[nChar];
001515 for(z=zCharSet, nChar=0; *z; nChar++){
001516 azChar[nChar] = (unsigned char *)z;
001517 SQLITE_SKIP_UTF8(z);
001518 aLen[nChar] = (unsigned)(z - azChar[nChar]);
001519 }
001520 }
001521 }
001522 if( nChar>0 ){
001523 flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context));
001524 if( flags & 1 ){
001525 while( nIn>0 ){
001526 unsigned int len = 0;
001527 for(i=0; i<nChar; i++){
001528 len = aLen[i];
001529 if( len<=nIn && memcmp(zIn, azChar[i], len)==0 ) break;
001530 }
001531 if( i>=nChar ) break;
001532 zIn += len;
001533 nIn -= len;
001534 }
001535 }
001536 if( flags & 2 ){
001537 while( nIn>0 ){
001538 unsigned int len = 0;
001539 for(i=0; i<nChar; i++){
001540 len = aLen[i];
001541 if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break;
001542 }
001543 if( i>=nChar ) break;
001544 nIn -= len;
001545 }
001546 }
001547 if( zCharSet ){
001548 sqlite3_free(azChar);
001549 }
001550 }
001551 sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT);
001552 }
001553
001554 /* The core implementation of the CONCAT(...) and CONCAT_WS(SEP,...)
001555 ** functions.
001556 **
001557 ** Return a string value that is the concatenation of all non-null
001558 ** entries in argv[]. Use zSep as the separator.
001559 */
001560 static void concatFuncCore(
001561 sqlite3_context *context,
001562 int argc,
001563 sqlite3_value **argv,
001564 int nSep,
001565 const char *zSep
001566 ){
001567 i64 j, k, n = 0;
001568 int i;
001569 char *z;
001570 for(i=0; i<argc; i++){
001571 n += sqlite3_value_bytes(argv[i]);
001572 }
001573 n += (argc-1)*nSep;
001574 z = sqlite3_malloc64(n+1);
001575 if( z==0 ){
001576 sqlite3_result_error_nomem(context);
001577 return;
001578 }
001579 j = 0;
001580 for(i=0; i<argc; i++){
001581 k = sqlite3_value_bytes(argv[i]);
001582 if( k>0 ){
001583 const char *v = (const char*)sqlite3_value_text(argv[i]);
001584 if( v!=0 ){
001585 if( j>0 && nSep>0 ){
001586 memcpy(&z[j], zSep, nSep);
001587 j += nSep;
001588 }
001589 memcpy(&z[j], v, k);
001590 j += k;
001591 }
001592 }
001593 }
001594 z[j] = 0;
001595 assert( j<=n );
001596 sqlite3_result_text64(context, z, j, sqlite3_free, SQLITE_UTF8);
001597 }
001598
001599 /*
001600 ** The CONCAT(...) function. Generate a string result that is the
001601 ** concatentation of all non-null arguments.
001602 */
001603 static void concatFunc(
001604 sqlite3_context *context,
001605 int argc,
001606 sqlite3_value **argv
001607 ){
001608 concatFuncCore(context, argc, argv, 0, "");
001609 }
001610
001611 /*
001612 ** The CONCAT_WS(separator, ...) function.
001613 **
001614 ** Generate a string that is the concatenation of 2nd through the Nth
001615 ** argument. Use the first argument (which must be non-NULL) as the
001616 ** separator.
001617 */
001618 static void concatwsFunc(
001619 sqlite3_context *context,
001620 int argc,
001621 sqlite3_value **argv
001622 ){
001623 int nSep = sqlite3_value_bytes(argv[0]);
001624 const char *zSep = (const char*)sqlite3_value_text(argv[0]);
001625 if( zSep==0 ) return;
001626 concatFuncCore(context, argc-1, argv+1, nSep, zSep);
001627 }
001628
001629
001630 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
001631 /*
001632 ** The "unknown" function is automatically substituted in place of
001633 ** any unrecognized function name when doing an EXPLAIN or EXPLAIN QUERY PLAN
001634 ** when the SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION compile-time option is used.
001635 ** When the "sqlite3" command-line shell is built using this functionality,
001636 ** that allows an EXPLAIN or EXPLAIN QUERY PLAN for complex queries
001637 ** involving application-defined functions to be examined in a generic
001638 ** sqlite3 shell.
001639 */
001640 static void unknownFunc(
001641 sqlite3_context *context,
001642 int argc,
001643 sqlite3_value **argv
001644 ){
001645 /* no-op */
001646 (void)context;
001647 (void)argc;
001648 (void)argv;
001649 }
001650 #endif /*SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION*/
001651
001652
001653 /* IMP: R-25361-16150 This function is omitted from SQLite by default. It
001654 ** is only available if the SQLITE_SOUNDEX compile-time option is used
001655 ** when SQLite is built.
001656 */
001657 #ifdef SQLITE_SOUNDEX
001658 /*
001659 ** Compute the soundex encoding of a word.
001660 **
001661 ** IMP: R-59782-00072 The soundex(X) function returns a string that is the
001662 ** soundex encoding of the string X.
001663 */
001664 static void soundexFunc(
001665 sqlite3_context *context,
001666 int argc,
001667 sqlite3_value **argv
001668 ){
001669 char zResult[8];
001670 const u8 *zIn;
001671 int i, j;
001672 static const unsigned char iCode[] = {
001673 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
001674 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
001675 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
001676 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
001677 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
001678 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
001679 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
001680 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
001681 };
001682 assert( argc==1 );
001683 zIn = (u8*)sqlite3_value_text(argv[0]);
001684 if( zIn==0 ) zIn = (u8*)"";
001685 for(i=0; zIn[i] && !sqlite3Isalpha(zIn[i]); i++){}
001686 if( zIn[i] ){
001687 u8 prevcode = iCode[zIn[i]&0x7f];
001688 zResult[0] = sqlite3Toupper(zIn[i]);
001689 for(j=1; j<4 && zIn[i]; i++){
001690 int code = iCode[zIn[i]&0x7f];
001691 if( code>0 ){
001692 if( code!=prevcode ){
001693 prevcode = code;
001694 zResult[j++] = code + '0';
001695 }
001696 }else{
001697 prevcode = 0;
001698 }
001699 }
001700 while( j<4 ){
001701 zResult[j++] = '0';
001702 }
001703 zResult[j] = 0;
001704 sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT);
001705 }else{
001706 /* IMP: R-64894-50321 The string "?000" is returned if the argument
001707 ** is NULL or contains no ASCII alphabetic characters. */
001708 sqlite3_result_text(context, "?000", 4, SQLITE_STATIC);
001709 }
001710 }
001711 #endif /* SQLITE_SOUNDEX */
001712
001713 #ifndef SQLITE_OMIT_LOAD_EXTENSION
001714 /*
001715 ** A function that loads a shared-library extension then returns NULL.
001716 */
001717 static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){
001718 const char *zFile = (const char *)sqlite3_value_text(argv[0]);
001719 const char *zProc;
001720 sqlite3 *db = sqlite3_context_db_handle(context);
001721 char *zErrMsg = 0;
001722
001723 /* Disallow the load_extension() SQL function unless the SQLITE_LoadExtFunc
001724 ** flag is set. See the sqlite3_enable_load_extension() API.
001725 */
001726 if( (db->flags & SQLITE_LoadExtFunc)==0 ){
001727 sqlite3_result_error(context, "not authorized", -1);
001728 return;
001729 }
001730
001731 if( argc==2 ){
001732 zProc = (const char *)sqlite3_value_text(argv[1]);
001733 }else{
001734 zProc = 0;
001735 }
001736 if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){
001737 sqlite3_result_error(context, zErrMsg, -1);
001738 sqlite3_free(zErrMsg);
001739 }
001740 }
001741 #endif
001742
001743
001744 /*
001745 ** An instance of the following structure holds the context of a
001746 ** sum() or avg() aggregate computation.
001747 */
001748 typedef struct SumCtx SumCtx;
001749 struct SumCtx {
001750 double rSum; /* Running sum as as a double */
001751 double rErr; /* Error term for Kahan-Babushka-Neumaier summation */
001752 i64 iSum; /* Running sum as a signed integer */
001753 i64 cnt; /* Number of elements summed */
001754 u8 approx; /* True if any non-integer value was input to the sum */
001755 u8 ovrfl; /* Integer overflow seen */
001756 };
001757
001758 /*
001759 ** Do one step of the Kahan-Babushka-Neumaier summation.
001760 **
001761 ** https://en.wikipedia.org/wiki/Kahan_summation_algorithm
001762 **
001763 ** Variables are marked "volatile" to defeat c89 x86 floating point
001764 ** optimizations can mess up this algorithm.
001765 */
001766 static void kahanBabuskaNeumaierStep(
001767 volatile SumCtx *pSum,
001768 volatile double r
001769 ){
001770 volatile double s = pSum->rSum;
001771 volatile double t = s + r;
001772 if( fabs(s) > fabs(r) ){
001773 pSum->rErr += (s - t) + r;
001774 }else{
001775 pSum->rErr += (r - t) + s;
001776 }
001777 pSum->rSum = t;
001778 }
001779
001780 /*
001781 ** Add a (possibly large) integer to the running sum.
001782 */
001783 static void kahanBabuskaNeumaierStepInt64(volatile SumCtx *pSum, i64 iVal){
001784 if( iVal<=-4503599627370496LL || iVal>=+4503599627370496LL ){
001785 i64 iBig, iSm;
001786 iSm = iVal % 16384;
001787 iBig = iVal - iSm;
001788 kahanBabuskaNeumaierStep(pSum, iBig);
001789 kahanBabuskaNeumaierStep(pSum, iSm);
001790 }else{
001791 kahanBabuskaNeumaierStep(pSum, (double)iVal);
001792 }
001793 }
001794
001795 /*
001796 ** Initialize the Kahan-Babaska-Neumaier sum from a 64-bit integer
001797 */
001798 static void kahanBabuskaNeumaierInit(
001799 volatile SumCtx *p,
001800 i64 iVal
001801 ){
001802 if( iVal<=-4503599627370496LL || iVal>=+4503599627370496LL ){
001803 i64 iSm = iVal % 16384;
001804 p->rSum = (double)(iVal - iSm);
001805 p->rErr = (double)iSm;
001806 }else{
001807 p->rSum = (double)iVal;
001808 p->rErr = 0.0;
001809 }
001810 }
001811
001812 /*
001813 ** Routines used to compute the sum, average, and total.
001814 **
001815 ** The SUM() function follows the (broken) SQL standard which means
001816 ** that it returns NULL if it sums over no inputs. TOTAL returns
001817 ** 0.0 in that case. In addition, TOTAL always returns a float where
001818 ** SUM might return an integer if it never encounters a floating point
001819 ** value. TOTAL never fails, but SUM might through an exception if
001820 ** it overflows an integer.
001821 */
001822 static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){
001823 SumCtx *p;
001824 int type;
001825 assert( argc==1 );
001826 UNUSED_PARAMETER(argc);
001827 p = sqlite3_aggregate_context(context, sizeof(*p));
001828 type = sqlite3_value_numeric_type(argv[0]);
001829 if( p && type!=SQLITE_NULL ){
001830 p->cnt++;
001831 if( p->approx==0 ){
001832 if( type!=SQLITE_INTEGER ){
001833 kahanBabuskaNeumaierInit(p, p->iSum);
001834 p->approx = 1;
001835 kahanBabuskaNeumaierStep(p, sqlite3_value_double(argv[0]));
001836 }else{
001837 i64 x = p->iSum;
001838 if( sqlite3AddInt64(&x, sqlite3_value_int64(argv[0]))==0 ){
001839 p->iSum = x;
001840 }else{
001841 p->ovrfl = 1;
001842 kahanBabuskaNeumaierInit(p, p->iSum);
001843 p->approx = 1;
001844 kahanBabuskaNeumaierStepInt64(p, sqlite3_value_int64(argv[0]));
001845 }
001846 }
001847 }else{
001848 if( type==SQLITE_INTEGER ){
001849 kahanBabuskaNeumaierStepInt64(p, sqlite3_value_int64(argv[0]));
001850 }else{
001851 p->ovrfl = 0;
001852 kahanBabuskaNeumaierStep(p, sqlite3_value_double(argv[0]));
001853 }
001854 }
001855 }
001856 }
001857 #ifndef SQLITE_OMIT_WINDOWFUNC
001858 static void sumInverse(sqlite3_context *context, int argc, sqlite3_value**argv){
001859 SumCtx *p;
001860 int type;
001861 assert( argc==1 );
001862 UNUSED_PARAMETER(argc);
001863 p = sqlite3_aggregate_context(context, sizeof(*p));
001864 type = sqlite3_value_numeric_type(argv[0]);
001865 /* p is always non-NULL because sumStep() will have been called first
001866 ** to initialize it */
001867 if( ALWAYS(p) && type!=SQLITE_NULL ){
001868 assert( p->cnt>0 );
001869 p->cnt--;
001870 if( !p->approx ){
001871 p->iSum -= sqlite3_value_int64(argv[0]);
001872 }else if( type==SQLITE_INTEGER ){
001873 i64 iVal = sqlite3_value_int64(argv[0]);
001874 if( iVal!=SMALLEST_INT64 ){
001875 kahanBabuskaNeumaierStepInt64(p, -iVal);
001876 }else{
001877 kahanBabuskaNeumaierStepInt64(p, LARGEST_INT64);
001878 kahanBabuskaNeumaierStepInt64(p, 1);
001879 }
001880 }else{
001881 kahanBabuskaNeumaierStep(p, -sqlite3_value_double(argv[0]));
001882 }
001883 }
001884 }
001885 #else
001886 # define sumInverse 0
001887 #endif /* SQLITE_OMIT_WINDOWFUNC */
001888 static void sumFinalize(sqlite3_context *context){
001889 SumCtx *p;
001890 p = sqlite3_aggregate_context(context, 0);
001891 if( p && p->cnt>0 ){
001892 if( p->approx ){
001893 if( p->ovrfl ){
001894 sqlite3_result_error(context,"integer overflow",-1);
001895 }else if( !sqlite3IsOverflow(p->rErr) ){
001896 sqlite3_result_double(context, p->rSum+p->rErr);
001897 }else{
001898 sqlite3_result_double(context, p->rSum);
001899 }
001900 }else{
001901 sqlite3_result_int64(context, p->iSum);
001902 }
001903 }
001904 }
001905 static void avgFinalize(sqlite3_context *context){
001906 SumCtx *p;
001907 p = sqlite3_aggregate_context(context, 0);
001908 if( p && p->cnt>0 ){
001909 double r;
001910 if( p->approx ){
001911 r = p->rSum;
001912 if( !sqlite3IsOverflow(p->rErr) ) r += p->rErr;
001913 }else{
001914 r = (double)(p->iSum);
001915 }
001916 sqlite3_result_double(context, r/(double)p->cnt);
001917 }
001918 }
001919 static void totalFinalize(sqlite3_context *context){
001920 SumCtx *p;
001921 double r = 0.0;
001922 p = sqlite3_aggregate_context(context, 0);
001923 if( p ){
001924 if( p->approx ){
001925 r = p->rSum;
001926 if( !sqlite3IsOverflow(p->rErr) ) r += p->rErr;
001927 }else{
001928 r = (double)(p->iSum);
001929 }
001930 }
001931 sqlite3_result_double(context, r);
001932 }
001933
001934 /*
001935 ** The following structure keeps track of state information for the
001936 ** count() aggregate function.
001937 */
001938 typedef struct CountCtx CountCtx;
001939 struct CountCtx {
001940 i64 n;
001941 #ifdef SQLITE_DEBUG
001942 int bInverse; /* True if xInverse() ever called */
001943 #endif
001944 };
001945
001946 /*
001947 ** Routines to implement the count() aggregate function.
001948 */
001949 static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){
001950 CountCtx *p;
001951 p = sqlite3_aggregate_context(context, sizeof(*p));
001952 if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){
001953 p->n++;
001954 }
001955
001956 #ifndef SQLITE_OMIT_DEPRECATED
001957 /* The sqlite3_aggregate_count() function is deprecated. But just to make
001958 ** sure it still operates correctly, verify that its count agrees with our
001959 ** internal count when using count(*) and when the total count can be
001960 ** expressed as a 32-bit integer. */
001961 assert( argc==1 || p==0 || p->n>0x7fffffff || p->bInverse
001962 || p->n==sqlite3_aggregate_count(context) );
001963 #endif
001964 }
001965 static void countFinalize(sqlite3_context *context){
001966 CountCtx *p;
001967 p = sqlite3_aggregate_context(context, 0);
001968 sqlite3_result_int64(context, p ? p->n : 0);
001969 }
001970 #ifndef SQLITE_OMIT_WINDOWFUNC
001971 static void countInverse(sqlite3_context *ctx, int argc, sqlite3_value **argv){
001972 CountCtx *p;
001973 p = sqlite3_aggregate_context(ctx, sizeof(*p));
001974 /* p is always non-NULL since countStep() will have been called first */
001975 if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && ALWAYS(p) ){
001976 p->n--;
001977 #ifdef SQLITE_DEBUG
001978 p->bInverse = 1;
001979 #endif
001980 }
001981 }
001982 #else
001983 # define countInverse 0
001984 #endif /* SQLITE_OMIT_WINDOWFUNC */
001985
001986 /*
001987 ** Routines to implement min() and max() aggregate functions.
001988 */
001989 static void minmaxStep(
001990 sqlite3_context *context,
001991 int NotUsed,
001992 sqlite3_value **argv
001993 ){
001994 Mem *pArg = (Mem *)argv[0];
001995 Mem *pBest;
001996 UNUSED_PARAMETER(NotUsed);
001997
001998 pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest));
001999 if( !pBest ) return;
002000
002001 if( sqlite3_value_type(pArg)==SQLITE_NULL ){
002002 if( pBest->flags ) sqlite3SkipAccumulatorLoad(context);
002003 }else if( pBest->flags ){
002004 int max;
002005 int cmp;
002006 CollSeq *pColl = sqlite3GetFuncCollSeq(context);
002007 /* This step function is used for both the min() and max() aggregates,
002008 ** the only difference between the two being that the sense of the
002009 ** comparison is inverted. For the max() aggregate, the
002010 ** sqlite3_user_data() function returns (void *)-1. For min() it
002011 ** returns (void *)db, where db is the sqlite3* database pointer.
002012 ** Therefore the next statement sets variable 'max' to 1 for the max()
002013 ** aggregate, or 0 for min().
002014 */
002015 max = sqlite3_user_data(context)!=0;
002016 cmp = sqlite3MemCompare(pBest, pArg, pColl);
002017 if( (max && cmp<0) || (!max && cmp>0) ){
002018 sqlite3VdbeMemCopy(pBest, pArg);
002019 }else{
002020 sqlite3SkipAccumulatorLoad(context);
002021 }
002022 }else{
002023 pBest->db = sqlite3_context_db_handle(context);
002024 sqlite3VdbeMemCopy(pBest, pArg);
002025 }
002026 }
002027 static void minMaxValueFinalize(sqlite3_context *context, int bValue){
002028 sqlite3_value *pRes;
002029 pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0);
002030 if( pRes ){
002031 if( pRes->flags ){
002032 sqlite3_result_value(context, pRes);
002033 }
002034 if( bValue==0 ) sqlite3VdbeMemRelease(pRes);
002035 }
002036 }
002037 #ifndef SQLITE_OMIT_WINDOWFUNC
002038 static void minMaxValue(sqlite3_context *context){
002039 minMaxValueFinalize(context, 1);
002040 }
002041 #else
002042 # define minMaxValue 0
002043 #endif /* SQLITE_OMIT_WINDOWFUNC */
002044 static void minMaxFinalize(sqlite3_context *context){
002045 minMaxValueFinalize(context, 0);
002046 }
002047
002048 /*
002049 ** group_concat(EXPR, ?SEPARATOR?)
002050 ** string_agg(EXPR, SEPARATOR)
002051 **
002052 ** The SEPARATOR goes before the EXPR string. This is tragic. The
002053 ** groupConcatInverse() implementation would have been easier if the
002054 ** SEPARATOR were appended after EXPR. And the order is undocumented,
002055 ** so we could change it, in theory. But the old behavior has been
002056 ** around for so long that we dare not, for fear of breaking something.
002057 */
002058 typedef struct {
002059 StrAccum str; /* The accumulated concatenation */
002060 #ifndef SQLITE_OMIT_WINDOWFUNC
002061 int nAccum; /* Number of strings presently concatenated */
002062 int nFirstSepLength; /* Used to detect separator length change */
002063 /* If pnSepLengths!=0, refs an array of inter-string separator lengths,
002064 ** stored as actually incorporated into presently accumulated result.
002065 ** (Hence, its slots in use number nAccum-1 between method calls.)
002066 ** If pnSepLengths==0, nFirstSepLength is the length used throughout.
002067 */
002068 int *pnSepLengths;
002069 #endif
002070 } GroupConcatCtx;
002071
002072 static void groupConcatStep(
002073 sqlite3_context *context,
002074 int argc,
002075 sqlite3_value **argv
002076 ){
002077 const char *zVal;
002078 GroupConcatCtx *pGCC;
002079 const char *zSep;
002080 int nVal, nSep;
002081 assert( argc==1 || argc==2 );
002082 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
002083 pGCC = (GroupConcatCtx*)sqlite3_aggregate_context(context, sizeof(*pGCC));
002084 if( pGCC ){
002085 sqlite3 *db = sqlite3_context_db_handle(context);
002086 int firstTerm = pGCC->str.mxAlloc==0;
002087 pGCC->str.mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH];
002088 if( argc==1 ){
002089 if( !firstTerm ){
002090 sqlite3_str_appendchar(&pGCC->str, 1, ',');
002091 }
002092 #ifndef SQLITE_OMIT_WINDOWFUNC
002093 else{
002094 pGCC->nFirstSepLength = 1;
002095 }
002096 #endif
002097 }else if( !firstTerm ){
002098 zSep = (char*)sqlite3_value_text(argv[1]);
002099 nSep = sqlite3_value_bytes(argv[1]);
002100 if( zSep ){
002101 sqlite3_str_append(&pGCC->str, zSep, nSep);
002102 }
002103 #ifndef SQLITE_OMIT_WINDOWFUNC
002104 else{
002105 nSep = 0;
002106 }
002107 if( nSep != pGCC->nFirstSepLength || pGCC->pnSepLengths != 0 ){
002108 int *pnsl = pGCC->pnSepLengths;
002109 if( pnsl == 0 ){
002110 /* First separator length variation seen, start tracking them. */
002111 pnsl = (int*)sqlite3_malloc64((pGCC->nAccum+1) * sizeof(int));
002112 if( pnsl!=0 ){
002113 int i = 0, nA = pGCC->nAccum-1;
002114 while( i<nA ) pnsl[i++] = pGCC->nFirstSepLength;
002115 }
002116 }else{
002117 pnsl = (int*)sqlite3_realloc64(pnsl, pGCC->nAccum * sizeof(int));
002118 }
002119 if( pnsl!=0 ){
002120 if( ALWAYS(pGCC->nAccum>0) ){
002121 pnsl[pGCC->nAccum-1] = nSep;
002122 }
002123 pGCC->pnSepLengths = pnsl;
002124 }else{
002125 sqlite3StrAccumSetError(&pGCC->str, SQLITE_NOMEM);
002126 }
002127 }
002128 #endif
002129 }
002130 #ifndef SQLITE_OMIT_WINDOWFUNC
002131 else{
002132 pGCC->nFirstSepLength = sqlite3_value_bytes(argv[1]);
002133 }
002134 pGCC->nAccum += 1;
002135 #endif
002136 zVal = (char*)sqlite3_value_text(argv[0]);
002137 nVal = sqlite3_value_bytes(argv[0]);
002138 if( zVal ) sqlite3_str_append(&pGCC->str, zVal, nVal);
002139 }
002140 }
002141
002142 #ifndef SQLITE_OMIT_WINDOWFUNC
002143 static void groupConcatInverse(
002144 sqlite3_context *context,
002145 int argc,
002146 sqlite3_value **argv
002147 ){
002148 GroupConcatCtx *pGCC;
002149 assert( argc==1 || argc==2 );
002150 (void)argc; /* Suppress unused parameter warning */
002151 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
002152 pGCC = (GroupConcatCtx*)sqlite3_aggregate_context(context, sizeof(*pGCC));
002153 /* pGCC is always non-NULL since groupConcatStep() will have always
002154 ** run first to initialize it */
002155 if( ALWAYS(pGCC) ){
002156 int nVS;
002157 /* Must call sqlite3_value_text() to convert the argument into text prior
002158 ** to invoking sqlite3_value_bytes(), in case the text encoding is UTF16 */
002159 (void)sqlite3_value_text(argv[0]);
002160 nVS = sqlite3_value_bytes(argv[0]);
002161 pGCC->nAccum -= 1;
002162 if( pGCC->pnSepLengths!=0 ){
002163 assert(pGCC->nAccum >= 0);
002164 if( pGCC->nAccum>0 ){
002165 nVS += *pGCC->pnSepLengths;
002166 memmove(pGCC->pnSepLengths, pGCC->pnSepLengths+1,
002167 (pGCC->nAccum-1)*sizeof(int));
002168 }
002169 }else{
002170 /* If removing single accumulated string, harmlessly over-do. */
002171 nVS += pGCC->nFirstSepLength;
002172 }
002173 if( nVS>=(int)pGCC->str.nChar ){
002174 pGCC->str.nChar = 0;
002175 }else{
002176 pGCC->str.nChar -= nVS;
002177 memmove(pGCC->str.zText, &pGCC->str.zText[nVS], pGCC->str.nChar);
002178 }
002179 if( pGCC->str.nChar==0 ){
002180 pGCC->str.mxAlloc = 0;
002181 sqlite3_free(pGCC->pnSepLengths);
002182 pGCC->pnSepLengths = 0;
002183 }
002184 }
002185 }
002186 #else
002187 # define groupConcatInverse 0
002188 #endif /* SQLITE_OMIT_WINDOWFUNC */
002189 static void groupConcatFinalize(sqlite3_context *context){
002190 GroupConcatCtx *pGCC
002191 = (GroupConcatCtx*)sqlite3_aggregate_context(context, 0);
002192 if( pGCC ){
002193 sqlite3ResultStrAccum(context, &pGCC->str);
002194 #ifndef SQLITE_OMIT_WINDOWFUNC
002195 sqlite3_free(pGCC->pnSepLengths);
002196 #endif
002197 }
002198 }
002199 #ifndef SQLITE_OMIT_WINDOWFUNC
002200 static void groupConcatValue(sqlite3_context *context){
002201 GroupConcatCtx *pGCC
002202 = (GroupConcatCtx*)sqlite3_aggregate_context(context, 0);
002203 if( pGCC ){
002204 StrAccum *pAccum = &pGCC->str;
002205 if( pAccum->accError==SQLITE_TOOBIG ){
002206 sqlite3_result_error_toobig(context);
002207 }else if( pAccum->accError==SQLITE_NOMEM ){
002208 sqlite3_result_error_nomem(context);
002209 }else if( pGCC->nAccum>0 && pAccum->nChar==0 ){
002210 sqlite3_result_text(context, "", 1, SQLITE_STATIC);
002211 }else{
002212 const char *zText = sqlite3_str_value(pAccum);
002213 sqlite3_result_text(context, zText, pAccum->nChar, SQLITE_TRANSIENT);
002214 }
002215 }
002216 }
002217 #else
002218 # define groupConcatValue 0
002219 #endif /* SQLITE_OMIT_WINDOWFUNC */
002220
002221 /*
002222 ** This routine does per-connection function registration. Most
002223 ** of the built-in functions above are part of the global function set.
002224 ** This routine only deals with those that are not global.
002225 */
002226 void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3 *db){
002227 int rc = sqlite3_overload_function(db, "MATCH", 2);
002228 assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
002229 if( rc==SQLITE_NOMEM ){
002230 sqlite3OomFault(db);
002231 }
002232 }
002233
002234 /*
002235 ** Re-register the built-in LIKE functions. The caseSensitive
002236 ** parameter determines whether or not the LIKE operator is case
002237 ** sensitive.
002238 */
002239 void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){
002240 FuncDef *pDef;
002241 struct compareInfo *pInfo;
002242 int flags;
002243 int nArg;
002244 if( caseSensitive ){
002245 pInfo = (struct compareInfo*)&likeInfoAlt;
002246 flags = SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE;
002247 }else{
002248 pInfo = (struct compareInfo*)&likeInfoNorm;
002249 flags = SQLITE_FUNC_LIKE;
002250 }
002251 for(nArg=2; nArg<=3; nArg++){
002252 sqlite3CreateFunc(db, "like", nArg, SQLITE_UTF8, pInfo, likeFunc,
002253 0, 0, 0, 0, 0);
002254 pDef = sqlite3FindFunction(db, "like", nArg, SQLITE_UTF8, 0);
002255 pDef->funcFlags |= flags;
002256 pDef->funcFlags &= ~SQLITE_FUNC_UNSAFE;
002257 }
002258 }
002259
002260 /*
002261 ** pExpr points to an expression which implements a function. If
002262 ** it is appropriate to apply the LIKE optimization to that function
002263 ** then set aWc[0] through aWc[2] to the wildcard characters and the
002264 ** escape character and then return TRUE. If the function is not a
002265 ** LIKE-style function then return FALSE.
002266 **
002267 ** The expression "a LIKE b ESCAPE c" is only considered a valid LIKE
002268 ** operator if c is a string literal that is exactly one byte in length.
002269 ** That one byte is stored in aWc[3]. aWc[3] is set to zero if there is
002270 ** no ESCAPE clause.
002271 **
002272 ** *pIsNocase is set to true if uppercase and lowercase are equivalent for
002273 ** the function (default for LIKE). If the function makes the distinction
002274 ** between uppercase and lowercase (as does GLOB) then *pIsNocase is set to
002275 ** false.
002276 */
002277 int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){
002278 FuncDef *pDef;
002279 int nExpr;
002280 assert( pExpr!=0 );
002281 assert( pExpr->op==TK_FUNCTION );
002282 assert( ExprUseXList(pExpr) );
002283 if( !pExpr->x.pList ){
002284 return 0;
002285 }
002286 nExpr = pExpr->x.pList->nExpr;
002287 assert( !ExprHasProperty(pExpr, EP_IntValue) );
002288 pDef = sqlite3FindFunction(db, pExpr->u.zToken, nExpr, SQLITE_UTF8, 0);
002289 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
002290 if( pDef==0 ) return 0;
002291 #endif
002292 if( NEVER(pDef==0) || (pDef->funcFlags & SQLITE_FUNC_LIKE)==0 ){
002293 return 0;
002294 }
002295
002296 /* The memcpy() statement assumes that the wildcard characters are
002297 ** the first three statements in the compareInfo structure. The
002298 ** asserts() that follow verify that assumption
002299 */
002300 memcpy(aWc, pDef->pUserData, 3);
002301 assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll );
002302 assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne );
002303 assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet );
002304
002305 if( nExpr<3 ){
002306 aWc[3] = 0;
002307 }else{
002308 Expr *pEscape = pExpr->x.pList->a[2].pExpr;
002309 char *zEscape;
002310 if( pEscape->op!=TK_STRING ) return 0;
002311 assert( !ExprHasProperty(pEscape, EP_IntValue) );
002312 zEscape = pEscape->u.zToken;
002313 if( zEscape[0]==0 || zEscape[1]!=0 ) return 0;
002314 if( zEscape[0]==aWc[0] ) return 0;
002315 if( zEscape[0]==aWc[1] ) return 0;
002316 aWc[3] = zEscape[0];
002317 }
002318
002319 *pIsNocase = (pDef->funcFlags & SQLITE_FUNC_CASE)==0;
002320 return 1;
002321 }
002322
002323 /* Mathematical Constants */
002324 #ifndef M_PI
002325 # define M_PI 3.141592653589793238462643383279502884
002326 #endif
002327 #ifndef M_LN10
002328 # define M_LN10 2.302585092994045684017991454684364208
002329 #endif
002330 #ifndef M_LN2
002331 # define M_LN2 0.693147180559945309417232121458176568
002332 #endif
002333
002334
002335 /* Extra math functions that require linking with -lm
002336 */
002337 #ifdef SQLITE_ENABLE_MATH_FUNCTIONS
002338 /*
002339 ** Implementation SQL functions:
002340 **
002341 ** ceil(X)
002342 ** ceiling(X)
002343 ** floor(X)
002344 **
002345 ** The sqlite3_user_data() pointer is a pointer to the libm implementation
002346 ** of the underlying C function.
002347 */
002348 static void ceilingFunc(
002349 sqlite3_context *context,
002350 int argc,
002351 sqlite3_value **argv
002352 ){
002353 assert( argc==1 );
002354 switch( sqlite3_value_numeric_type(argv[0]) ){
002355 case SQLITE_INTEGER: {
002356 sqlite3_result_int64(context, sqlite3_value_int64(argv[0]));
002357 break;
002358 }
002359 case SQLITE_FLOAT: {
002360 double (*x)(double) = (double(*)(double))sqlite3_user_data(context);
002361 sqlite3_result_double(context, x(sqlite3_value_double(argv[0])));
002362 break;
002363 }
002364 default: {
002365 break;
002366 }
002367 }
002368 }
002369
002370 /*
002371 ** On some systems, ceil() and floor() are intrinsic function. You are
002372 ** unable to take a pointer to these functions. Hence, we here wrap them
002373 ** in our own actual functions.
002374 */
002375 static double xCeil(double x){ return ceil(x); }
002376 static double xFloor(double x){ return floor(x); }
002377
002378 /*
002379 ** Some systems do not have log2() and log10() in their standard math
002380 ** libraries.
002381 */
002382 #if defined(HAVE_LOG10) && HAVE_LOG10==0
002383 # define log10(X) (0.4342944819032517867*log(X))
002384 #endif
002385 #if defined(HAVE_LOG2) && HAVE_LOG2==0
002386 # define log2(X) (1.442695040888963456*log(X))
002387 #endif
002388
002389
002390 /*
002391 ** Implementation of SQL functions:
002392 **
002393 ** ln(X) - natural logarithm
002394 ** log(X) - log X base 10
002395 ** log10(X) - log X base 10
002396 ** log(B,X) - log X base B
002397 */
002398 static void logFunc(
002399 sqlite3_context *context,
002400 int argc,
002401 sqlite3_value **argv
002402 ){
002403 double x, b, ans;
002404 assert( argc==1 || argc==2 );
002405 switch( sqlite3_value_numeric_type(argv[0]) ){
002406 case SQLITE_INTEGER:
002407 case SQLITE_FLOAT:
002408 x = sqlite3_value_double(argv[0]);
002409 if( x<=0.0 ) return;
002410 break;
002411 default:
002412 return;
002413 }
002414 if( argc==2 ){
002415 switch( sqlite3_value_numeric_type(argv[0]) ){
002416 case SQLITE_INTEGER:
002417 case SQLITE_FLOAT:
002418 b = log(x);
002419 if( b<=0.0 ) return;
002420 x = sqlite3_value_double(argv[1]);
002421 if( x<=0.0 ) return;
002422 break;
002423 default:
002424 return;
002425 }
002426 ans = log(x)/b;
002427 }else{
002428 switch( SQLITE_PTR_TO_INT(sqlite3_user_data(context)) ){
002429 case 1:
002430 ans = log10(x);
002431 break;
002432 case 2:
002433 ans = log2(x);
002434 break;
002435 default:
002436 ans = log(x);
002437 break;
002438 }
002439 }
002440 sqlite3_result_double(context, ans);
002441 }
002442
002443 /*
002444 ** Functions to converts degrees to radians and radians to degrees.
002445 */
002446 static double degToRad(double x){ return x*(M_PI/180.0); }
002447 static double radToDeg(double x){ return x*(180.0/M_PI); }
002448
002449 /*
002450 ** Implementation of 1-argument SQL math functions:
002451 **
002452 ** exp(X) - Compute e to the X-th power
002453 */
002454 static void math1Func(
002455 sqlite3_context *context,
002456 int argc,
002457 sqlite3_value **argv
002458 ){
002459 int type0;
002460 double v0, ans;
002461 double (*x)(double);
002462 assert( argc==1 );
002463 type0 = sqlite3_value_numeric_type(argv[0]);
002464 if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return;
002465 v0 = sqlite3_value_double(argv[0]);
002466 x = (double(*)(double))sqlite3_user_data(context);
002467 ans = x(v0);
002468 sqlite3_result_double(context, ans);
002469 }
002470
002471 /*
002472 ** Implementation of 2-argument SQL math functions:
002473 **
002474 ** power(X,Y) - Compute X to the Y-th power
002475 */
002476 static void math2Func(
002477 sqlite3_context *context,
002478 int argc,
002479 sqlite3_value **argv
002480 ){
002481 int type0, type1;
002482 double v0, v1, ans;
002483 double (*x)(double,double);
002484 assert( argc==2 );
002485 type0 = sqlite3_value_numeric_type(argv[0]);
002486 if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return;
002487 type1 = sqlite3_value_numeric_type(argv[1]);
002488 if( type1!=SQLITE_INTEGER && type1!=SQLITE_FLOAT ) return;
002489 v0 = sqlite3_value_double(argv[0]);
002490 v1 = sqlite3_value_double(argv[1]);
002491 x = (double(*)(double,double))sqlite3_user_data(context);
002492 ans = x(v0, v1);
002493 sqlite3_result_double(context, ans);
002494 }
002495
002496 /*
002497 ** Implementation of 0-argument pi() function.
002498 */
002499 static void piFunc(
002500 sqlite3_context *context,
002501 int argc,
002502 sqlite3_value **argv
002503 ){
002504 assert( argc==0 );
002505 (void)argv;
002506 sqlite3_result_double(context, M_PI);
002507 }
002508
002509 #endif /* SQLITE_ENABLE_MATH_FUNCTIONS */
002510
002511 /*
002512 ** Implementation of sign(X) function.
002513 */
002514 static void signFunc(
002515 sqlite3_context *context,
002516 int argc,
002517 sqlite3_value **argv
002518 ){
002519 int type0;
002520 double x;
002521 UNUSED_PARAMETER(argc);
002522 assert( argc==1 );
002523 type0 = sqlite3_value_numeric_type(argv[0]);
002524 if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return;
002525 x = sqlite3_value_double(argv[0]);
002526 sqlite3_result_int(context, x<0.0 ? -1 : x>0.0 ? +1 : 0);
002527 }
002528
002529 #ifdef SQLITE_DEBUG
002530 /*
002531 ** Implementation of fpdecode(x,y,z) function.
002532 **
002533 ** x is a real number that is to be decoded. y is the precision.
002534 ** z is the maximum real precision.
002535 */
002536 static void fpdecodeFunc(
002537 sqlite3_context *context,
002538 int argc,
002539 sqlite3_value **argv
002540 ){
002541 FpDecode s;
002542 double x;
002543 int y, z;
002544 char zBuf[100];
002545 UNUSED_PARAMETER(argc);
002546 assert( argc==3 );
002547 x = sqlite3_value_double(argv[0]);
002548 y = sqlite3_value_int(argv[1]);
002549 z = sqlite3_value_int(argv[2]);
002550 sqlite3FpDecode(&s, x, y, z);
002551 if( s.isSpecial==2 ){
002552 sqlite3_snprintf(sizeof(zBuf), zBuf, "NaN");
002553 }else{
002554 sqlite3_snprintf(sizeof(zBuf), zBuf, "%c%.*s/%d", s.sign, s.n, s.z, s.iDP);
002555 }
002556 sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
002557 }
002558 #endif /* SQLITE_DEBUG */
002559
002560 /*
002561 ** All of the FuncDef structures in the aBuiltinFunc[] array above
002562 ** to the global function hash table. This occurs at start-time (as
002563 ** a consequence of calling sqlite3_initialize()).
002564 **
002565 ** After this routine runs
002566 */
002567 void sqlite3RegisterBuiltinFunctions(void){
002568 /*
002569 ** The following array holds FuncDef structures for all of the functions
002570 ** defined in this file.
002571 **
002572 ** The array cannot be constant since changes are made to the
002573 ** FuncDef.pHash elements at start-time. The elements of this array
002574 ** are read-only after initialization is complete.
002575 **
002576 ** For peak efficiency, put the most frequently used function last.
002577 */
002578 static FuncDef aBuiltinFunc[] = {
002579 /***** Functions only available with SQLITE_TESTCTRL_INTERNAL_FUNCTIONS *****/
002580 #if !defined(SQLITE_UNTESTABLE)
002581 TEST_FUNC(implies_nonnull_row, 2, INLINEFUNC_implies_nonnull_row, 0),
002582 TEST_FUNC(expr_compare, 2, INLINEFUNC_expr_compare, 0),
002583 TEST_FUNC(expr_implies_expr, 2, INLINEFUNC_expr_implies_expr, 0),
002584 TEST_FUNC(affinity, 1, INLINEFUNC_affinity, 0),
002585 #endif /* !defined(SQLITE_UNTESTABLE) */
002586 /***** Regular functions *****/
002587 #ifdef SQLITE_SOUNDEX
002588 FUNCTION(soundex, 1, 0, 0, soundexFunc ),
002589 #endif
002590 #ifndef SQLITE_OMIT_LOAD_EXTENSION
002591 SFUNCTION(load_extension, 1, 0, 0, loadExt ),
002592 SFUNCTION(load_extension, 2, 0, 0, loadExt ),
002593 #endif
002594 #if SQLITE_USER_AUTHENTICATION
002595 FUNCTION(sqlite_crypt, 2, 0, 0, sqlite3CryptFunc ),
002596 #endif
002597 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
002598 DFUNCTION(sqlite_compileoption_used,1, 0, 0, compileoptionusedFunc ),
002599 DFUNCTION(sqlite_compileoption_get, 1, 0, 0, compileoptiongetFunc ),
002600 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
002601 INLINE_FUNC(unlikely, 1, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY),
002602 INLINE_FUNC(likelihood, 2, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY),
002603 INLINE_FUNC(likely, 1, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY),
002604 #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
002605 INLINE_FUNC(sqlite_offset, 1, INLINEFUNC_sqlite_offset, 0 ),
002606 #endif
002607 FUNCTION(ltrim, 1, 1, 0, trimFunc ),
002608 FUNCTION(ltrim, 2, 1, 0, trimFunc ),
002609 FUNCTION(rtrim, 1, 2, 0, trimFunc ),
002610 FUNCTION(rtrim, 2, 2, 0, trimFunc ),
002611 FUNCTION(trim, 1, 3, 0, trimFunc ),
002612 FUNCTION(trim, 2, 3, 0, trimFunc ),
002613 FUNCTION(min, -1, 0, 1, minmaxFunc ),
002614 FUNCTION(min, 0, 0, 1, 0 ),
002615 WAGGREGATE(min, 1, 0, 1, minmaxStep, minMaxFinalize, minMaxValue, 0,
002616 SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER ),
002617 FUNCTION(max, -1, 1, 1, minmaxFunc ),
002618 FUNCTION(max, 0, 1, 1, 0 ),
002619 WAGGREGATE(max, 1, 1, 1, minmaxStep, minMaxFinalize, minMaxValue, 0,
002620 SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER ),
002621 FUNCTION2(typeof, 1, 0, 0, typeofFunc, SQLITE_FUNC_TYPEOF),
002622 FUNCTION2(subtype, 1, 0, 0, subtypeFunc, SQLITE_FUNC_TYPEOF),
002623 FUNCTION2(length, 1, 0, 0, lengthFunc, SQLITE_FUNC_LENGTH),
002624 FUNCTION2(octet_length, 1, 0, 0, bytelengthFunc,SQLITE_FUNC_BYTELEN),
002625 FUNCTION(instr, 2, 0, 0, instrFunc ),
002626 FUNCTION(printf, -1, 0, 0, printfFunc ),
002627 FUNCTION(format, -1, 0, 0, printfFunc ),
002628 FUNCTION(unicode, 1, 0, 0, unicodeFunc ),
002629 FUNCTION(char, -1, 0, 0, charFunc ),
002630 FUNCTION(abs, 1, 0, 0, absFunc ),
002631 #ifdef SQLITE_DEBUG
002632 FUNCTION(fpdecode, 3, 0, 0, fpdecodeFunc ),
002633 #endif
002634 #ifndef SQLITE_OMIT_FLOATING_POINT
002635 FUNCTION(round, 1, 0, 0, roundFunc ),
002636 FUNCTION(round, 2, 0, 0, roundFunc ),
002637 #endif
002638 FUNCTION(upper, 1, 0, 0, upperFunc ),
002639 FUNCTION(lower, 1, 0, 0, lowerFunc ),
002640 FUNCTION(hex, 1, 0, 0, hexFunc ),
002641 FUNCTION(unhex, 1, 0, 0, unhexFunc ),
002642 FUNCTION(unhex, 2, 0, 0, unhexFunc ),
002643 FUNCTION(concat, -1, 0, 0, concatFunc ),
002644 FUNCTION(concat, 0, 0, 0, 0 ),
002645 FUNCTION(concat_ws, -1, 0, 0, concatwsFunc ),
002646 FUNCTION(concat_ws, 0, 0, 0, 0 ),
002647 FUNCTION(concat_ws, 1, 0, 0, 0 ),
002648 INLINE_FUNC(ifnull, 2, INLINEFUNC_coalesce, 0 ),
002649 VFUNCTION(random, 0, 0, 0, randomFunc ),
002650 VFUNCTION(randomblob, 1, 0, 0, randomBlob ),
002651 FUNCTION(nullif, 2, 0, 1, nullifFunc ),
002652 DFUNCTION(sqlite_version, 0, 0, 0, versionFunc ),
002653 DFUNCTION(sqlite_source_id, 0, 0, 0, sourceidFunc ),
002654 FUNCTION(sqlite_log, 2, 0, 0, errlogFunc ),
002655 FUNCTION(quote, 1, 0, 0, quoteFunc ),
002656 VFUNCTION(last_insert_rowid, 0, 0, 0, last_insert_rowid),
002657 VFUNCTION(changes, 0, 0, 0, changes ),
002658 VFUNCTION(total_changes, 0, 0, 0, total_changes ),
002659 FUNCTION(replace, 3, 0, 0, replaceFunc ),
002660 FUNCTION(zeroblob, 1, 0, 0, zeroblobFunc ),
002661 FUNCTION(substr, 2, 0, 0, substrFunc ),
002662 FUNCTION(substr, 3, 0, 0, substrFunc ),
002663 FUNCTION(substring, 2, 0, 0, substrFunc ),
002664 FUNCTION(substring, 3, 0, 0, substrFunc ),
002665 WAGGREGATE(sum, 1,0,0, sumStep, sumFinalize, sumFinalize, sumInverse, 0),
002666 WAGGREGATE(total, 1,0,0, sumStep,totalFinalize,totalFinalize,sumInverse, 0),
002667 WAGGREGATE(avg, 1,0,0, sumStep, avgFinalize, avgFinalize, sumInverse, 0),
002668 WAGGREGATE(count, 0,0,0, countStep,
002669 countFinalize, countFinalize, countInverse,
002670 SQLITE_FUNC_COUNT|SQLITE_FUNC_ANYORDER ),
002671 WAGGREGATE(count, 1,0,0, countStep,
002672 countFinalize, countFinalize, countInverse, SQLITE_FUNC_ANYORDER ),
002673 WAGGREGATE(group_concat, 1, 0, 0, groupConcatStep,
002674 groupConcatFinalize, groupConcatValue, groupConcatInverse, 0),
002675 WAGGREGATE(group_concat, 2, 0, 0, groupConcatStep,
002676 groupConcatFinalize, groupConcatValue, groupConcatInverse, 0),
002677 WAGGREGATE(string_agg, 2, 0, 0, groupConcatStep,
002678 groupConcatFinalize, groupConcatValue, groupConcatInverse, 0),
002679
002680 LIKEFUNC(glob, 2, &globInfo, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
002681 #ifdef SQLITE_CASE_SENSITIVE_LIKE
002682 LIKEFUNC(like, 2, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
002683 LIKEFUNC(like, 3, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
002684 #else
002685 LIKEFUNC(like, 2, &likeInfoNorm, SQLITE_FUNC_LIKE),
002686 LIKEFUNC(like, 3, &likeInfoNorm, SQLITE_FUNC_LIKE),
002687 #endif
002688 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
002689 FUNCTION(unknown, -1, 0, 0, unknownFunc ),
002690 #endif
002691 FUNCTION(coalesce, 1, 0, 0, 0 ),
002692 FUNCTION(coalesce, 0, 0, 0, 0 ),
002693 #ifdef SQLITE_ENABLE_MATH_FUNCTIONS
002694 MFUNCTION(ceil, 1, xCeil, ceilingFunc ),
002695 MFUNCTION(ceiling, 1, xCeil, ceilingFunc ),
002696 MFUNCTION(floor, 1, xFloor, ceilingFunc ),
002697 #if SQLITE_HAVE_C99_MATH_FUNCS
002698 MFUNCTION(trunc, 1, trunc, ceilingFunc ),
002699 #endif
002700 FUNCTION(ln, 1, 0, 0, logFunc ),
002701 FUNCTION(log, 1, 1, 0, logFunc ),
002702 FUNCTION(log10, 1, 1, 0, logFunc ),
002703 FUNCTION(log2, 1, 2, 0, logFunc ),
002704 FUNCTION(log, 2, 0, 0, logFunc ),
002705 MFUNCTION(exp, 1, exp, math1Func ),
002706 MFUNCTION(pow, 2, pow, math2Func ),
002707 MFUNCTION(power, 2, pow, math2Func ),
002708 MFUNCTION(mod, 2, fmod, math2Func ),
002709 MFUNCTION(acos, 1, acos, math1Func ),
002710 MFUNCTION(asin, 1, asin, math1Func ),
002711 MFUNCTION(atan, 1, atan, math1Func ),
002712 MFUNCTION(atan2, 2, atan2, math2Func ),
002713 MFUNCTION(cos, 1, cos, math1Func ),
002714 MFUNCTION(sin, 1, sin, math1Func ),
002715 MFUNCTION(tan, 1, tan, math1Func ),
002716 MFUNCTION(cosh, 1, cosh, math1Func ),
002717 MFUNCTION(sinh, 1, sinh, math1Func ),
002718 MFUNCTION(tanh, 1, tanh, math1Func ),
002719 #if SQLITE_HAVE_C99_MATH_FUNCS
002720 MFUNCTION(acosh, 1, acosh, math1Func ),
002721 MFUNCTION(asinh, 1, asinh, math1Func ),
002722 MFUNCTION(atanh, 1, atanh, math1Func ),
002723 #endif
002724 MFUNCTION(sqrt, 1, sqrt, math1Func ),
002725 MFUNCTION(radians, 1, degToRad, math1Func ),
002726 MFUNCTION(degrees, 1, radToDeg, math1Func ),
002727 FUNCTION(pi, 0, 0, 0, piFunc ),
002728 #endif /* SQLITE_ENABLE_MATH_FUNCTIONS */
002729 FUNCTION(sign, 1, 0, 0, signFunc ),
002730 INLINE_FUNC(coalesce, -1, INLINEFUNC_coalesce, 0 ),
002731 INLINE_FUNC(iif, 3, INLINEFUNC_iif, 0 ),
002732 };
002733 #ifndef SQLITE_OMIT_ALTERTABLE
002734 sqlite3AlterFunctions();
002735 #endif
002736 sqlite3WindowFunctions();
002737 sqlite3RegisterDateTimeFunctions();
002738 sqlite3RegisterJsonFunctions();
002739 sqlite3InsertBuiltinFuncs(aBuiltinFunc, ArraySize(aBuiltinFunc));
002740
002741 #if 0 /* Enable to print out how the built-in functions are hashed */
002742 {
002743 int i;
002744 FuncDef *p;
002745 for(i=0; i<SQLITE_FUNC_HASH_SZ; i++){
002746 printf("FUNC-HASH %02d:", i);
002747 for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.pHash){
002748 int n = sqlite3Strlen30(p->zName);
002749 int h = p->zName[0] + n;
002750 assert( p->funcFlags & SQLITE_FUNC_BUILTIN );
002751 printf(" %s(%d)", p->zName, h);
002752 }
002753 printf("\n");
002754 }
002755 }
002756 #endif
002757 }