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