Annotation of embedaddon/php/ext/sqlite/libsqlite/src/date.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2003 October 31
! 3: **
! 4: ** The author disclaims copyright to this source code. In place of
! 5: ** a legal notice, here is a blessing:
! 6: **
! 7: ** May you do good and not evil.
! 8: ** May you find forgiveness for yourself and forgive others.
! 9: ** May you share freely, never taking more than you give.
! 10: **
! 11: *************************************************************************
! 12: ** This file contains the C functions that implement date and time
! 13: ** functions for SQLite.
! 14: **
! 15: ** There is only one exported symbol in this file - the function
! 16: ** sqliteRegisterDateTimeFunctions() found at the bottom of the file.
! 17: ** All other code has file scope.
! 18: **
! 19: ** $Id: date.c 278363 2009-04-07 11:45:13Z kalle $
! 20: **
! 21: ** NOTES:
! 22: **
! 23: ** SQLite processes all times and dates as Julian Day numbers. The
! 24: ** dates and times are stored as the number of days since noon
! 25: ** in Greenwich on November 24, 4714 B.C. according to the Gregorian
! 26: ** calendar system.
! 27: **
! 28: ** 1970-01-01 00:00:00 is JD 2440587.5
! 29: ** 2000-01-01 00:00:00 is JD 2451544.5
! 30: **
! 31: ** This implemention requires years to be expressed as a 4-digit number
! 32: ** which means that only dates between 0000-01-01 and 9999-12-31 can
! 33: ** be represented, even though julian day numbers allow a much wider
! 34: ** range of dates.
! 35: **
! 36: ** The Gregorian calendar system is used for all dates and times,
! 37: ** even those that predate the Gregorian calendar. Historians usually
! 38: ** use the Julian calendar for dates prior to 1582-10-15 and for some
! 39: ** dates afterwards, depending on locale. Beware of this difference.
! 40: **
! 41: ** The conversion algorithms are implemented based on descriptions
! 42: ** in the following text:
! 43: **
! 44: ** Jean Meeus
! 45: ** Astronomical Algorithms, 2nd Edition, 1998
! 46: ** ISBM 0-943396-61-1
! 47: ** Willmann-Bell, Inc
! 48: ** Richmond, Virginia (USA)
! 49: */
! 50: #include "os.h"
! 51: #include "sqliteInt.h"
! 52: #include <ctype.h>
! 53: #include <stdlib.h>
! 54: #include <assert.h>
! 55: #include <time.h>
! 56: #ifndef PHP_WIN32
! 57: #include "main/php_reentrancy.h"
! 58: #endif
! 59:
! 60: #ifndef SQLITE_OMIT_DATETIME_FUNCS
! 61:
! 62: /*
! 63: ** A structure for holding a single date and time.
! 64: */
! 65: typedef struct DateTime DateTime;
! 66: struct DateTime {
! 67: double rJD; /* The julian day number */
! 68: int Y, M, D; /* Year, month, and day */
! 69: int h, m; /* Hour and minutes */
! 70: int tz; /* Timezone offset in minutes */
! 71: double s; /* Seconds */
! 72: char validYMD; /* True if Y,M,D are valid */
! 73: char validHMS; /* True if h,m,s are valid */
! 74: char validJD; /* True if rJD is valid */
! 75: char validTZ; /* True if tz is valid */
! 76: };
! 77:
! 78:
! 79: /*
! 80: ** Convert zDate into one or more integers. Additional arguments
! 81: ** come in groups of 5 as follows:
! 82: **
! 83: ** N number of digits in the integer
! 84: ** min minimum allowed value of the integer
! 85: ** max maximum allowed value of the integer
! 86: ** nextC first character after the integer
! 87: ** pVal where to write the integers value.
! 88: **
! 89: ** Conversions continue until one with nextC==0 is encountered.
! 90: ** The function returns the number of successful conversions.
! 91: */
! 92: static int getDigits(const char *zDate, ...){
! 93: va_list ap;
! 94: int val;
! 95: int N;
! 96: int min;
! 97: int max;
! 98: int nextC;
! 99: int *pVal;
! 100: int cnt = 0;
! 101: va_start(ap, zDate);
! 102: do{
! 103: N = va_arg(ap, int);
! 104: min = va_arg(ap, int);
! 105: max = va_arg(ap, int);
! 106: nextC = va_arg(ap, int);
! 107: pVal = va_arg(ap, int*);
! 108: val = 0;
! 109: while( N-- ){
! 110: if( !isdigit(*zDate) ){
! 111: return cnt;
! 112: }
! 113: val = val*10 + *zDate - '0';
! 114: zDate++;
! 115: }
! 116: if( val<min || val>max || (nextC!=0 && nextC!=*zDate) ){
! 117: return cnt;
! 118: }
! 119: *pVal = val;
! 120: zDate++;
! 121: cnt++;
! 122: }while( nextC );
! 123: return cnt;
! 124: }
! 125:
! 126: /*
! 127: ** Read text from z[] and convert into a floating point number. Return
! 128: ** the number of digits converted.
! 129: */
! 130: static int getValue(const char *z, double *pR){
! 131: const char *zEnd;
! 132: *pR = sqliteAtoF(z, &zEnd);
! 133: return zEnd - z;
! 134: }
! 135:
! 136: /*
! 137: ** Parse a timezone extension on the end of a date-time.
! 138: ** The extension is of the form:
! 139: **
! 140: ** (+/-)HH:MM
! 141: **
! 142: ** If the parse is successful, write the number of minutes
! 143: ** of change in *pnMin and return 0. If a parser error occurs,
! 144: ** return 0.
! 145: **
! 146: ** A missing specifier is not considered an error.
! 147: */
! 148: static int parseTimezone(const char *zDate, DateTime *p){
! 149: int sgn = 0;
! 150: int nHr, nMn;
! 151: while( isspace(*zDate) ){ zDate++; }
! 152: p->tz = 0;
! 153: if( *zDate=='-' ){
! 154: sgn = -1;
! 155: }else if( *zDate=='+' ){
! 156: sgn = +1;
! 157: }else{
! 158: return *zDate!=0;
! 159: }
! 160: zDate++;
! 161: if( getDigits(zDate, 2, 0, 14, ':', &nHr, 2, 0, 59, 0, &nMn)!=2 ){
! 162: return 1;
! 163: }
! 164: zDate += 5;
! 165: p->tz = sgn*(nMn + nHr*60);
! 166: while( isspace(*zDate) ){ zDate++; }
! 167: return *zDate!=0;
! 168: }
! 169:
! 170: /*
! 171: ** Parse times of the form HH:MM or HH:MM:SS or HH:MM:SS.FFFF.
! 172: ** The HH, MM, and SS must each be exactly 2 digits. The
! 173: ** fractional seconds FFFF can be one or more digits.
! 174: **
! 175: ** Return 1 if there is a parsing error and 0 on success.
! 176: */
! 177: static int parseHhMmSs(const char *zDate, DateTime *p){
! 178: int h, m, s;
! 179: double ms = 0.0;
! 180: if( getDigits(zDate, 2, 0, 24, ':', &h, 2, 0, 59, 0, &m)!=2 ){
! 181: return 1;
! 182: }
! 183: zDate += 5;
! 184: if( *zDate==':' ){
! 185: zDate++;
! 186: if( getDigits(zDate, 2, 0, 59, 0, &s)!=1 ){
! 187: return 1;
! 188: }
! 189: zDate += 2;
! 190: if( *zDate=='.' && isdigit(zDate[1]) ){
! 191: double rScale = 1.0;
! 192: zDate++;
! 193: while( isdigit(*zDate) ){
! 194: ms = ms*10.0 + *zDate - '0';
! 195: rScale *= 10.0;
! 196: zDate++;
! 197: }
! 198: ms /= rScale;
! 199: }
! 200: }else{
! 201: s = 0;
! 202: }
! 203: p->validJD = 0;
! 204: p->validHMS = 1;
! 205: p->h = h;
! 206: p->m = m;
! 207: p->s = s + ms;
! 208: if( parseTimezone(zDate, p) ) return 1;
! 209: p->validTZ = p->tz!=0;
! 210: return 0;
! 211: }
! 212:
! 213: /*
! 214: ** Convert from YYYY-MM-DD HH:MM:SS to julian day. We always assume
! 215: ** that the YYYY-MM-DD is according to the Gregorian calendar.
! 216: **
! 217: ** Reference: Meeus page 61
! 218: */
! 219: static void computeJD(DateTime *p){
! 220: int Y, M, D, A, B, X1, X2;
! 221:
! 222: if( p->validJD ) return;
! 223: if( p->validYMD ){
! 224: Y = p->Y;
! 225: M = p->M;
! 226: D = p->D;
! 227: }else{
! 228: Y = 2000; /* If no YMD specified, assume 2000-Jan-01 */
! 229: M = 1;
! 230: D = 1;
! 231: }
! 232: if( M<=2 ){
! 233: Y--;
! 234: M += 12;
! 235: }
! 236: A = Y/100;
! 237: B = 2 - A + (A/4);
! 238: X1 = 365.25*(Y+4716);
! 239: X2 = 30.6001*(M+1);
! 240: p->rJD = X1 + X2 + D + B - 1524.5;
! 241: p->validJD = 1;
! 242: p->validYMD = 0;
! 243: if( p->validHMS ){
! 244: p->rJD += (p->h*3600.0 + p->m*60.0 + p->s)/86400.0;
! 245: if( p->validTZ ){
! 246: p->rJD += p->tz*60/86400.0;
! 247: p->validHMS = 0;
! 248: p->validTZ = 0;
! 249: }
! 250: }
! 251: }
! 252:
! 253: /*
! 254: ** Parse dates of the form
! 255: **
! 256: ** YYYY-MM-DD HH:MM:SS.FFF
! 257: ** YYYY-MM-DD HH:MM:SS
! 258: ** YYYY-MM-DD HH:MM
! 259: ** YYYY-MM-DD
! 260: **
! 261: ** Write the result into the DateTime structure and return 0
! 262: ** on success and 1 if the input string is not a well-formed
! 263: ** date.
! 264: */
! 265: static int parseYyyyMmDd(const char *zDate, DateTime *p){
! 266: int Y, M, D, neg;
! 267:
! 268: if( zDate[0]=='-' ){
! 269: zDate++;
! 270: neg = 1;
! 271: }else{
! 272: neg = 0;
! 273: }
! 274: if( getDigits(zDate,4,0,9999,'-',&Y,2,1,12,'-',&M,2,1,31,0,&D)!=3 ){
! 275: return 1;
! 276: }
! 277: zDate += 10;
! 278: while( isspace(*zDate) ){ zDate++; }
! 279: if( parseHhMmSs(zDate, p)==0 ){
! 280: /* We got the time */
! 281: }else if( *zDate==0 ){
! 282: p->validHMS = 0;
! 283: }else{
! 284: return 1;
! 285: }
! 286: p->validJD = 0;
! 287: p->validYMD = 1;
! 288: p->Y = neg ? -Y : Y;
! 289: p->M = M;
! 290: p->D = D;
! 291: if( p->validTZ ){
! 292: computeJD(p);
! 293: }
! 294: return 0;
! 295: }
! 296:
! 297: /*
! 298: ** Attempt to parse the given string into a Julian Day Number. Return
! 299: ** the number of errors.
! 300: **
! 301: ** The following are acceptable forms for the input string:
! 302: **
! 303: ** YYYY-MM-DD HH:MM:SS.FFF +/-HH:MM
! 304: ** DDDD.DD
! 305: ** now
! 306: **
! 307: ** In the first form, the +/-HH:MM is always optional. The fractional
! 308: ** seconds extension (the ".FFF") is optional. The seconds portion
! 309: ** (":SS.FFF") is option. The year and date can be omitted as long
! 310: ** as there is a time string. The time string can be omitted as long
! 311: ** as there is a year and date.
! 312: */
! 313: static int parseDateOrTime(const char *zDate, DateTime *p){
! 314: memset(p, 0, sizeof(*p));
! 315: if( parseYyyyMmDd(zDate,p)==0 ){
! 316: return 0;
! 317: }else if( parseHhMmSs(zDate, p)==0 ){
! 318: return 0;
! 319: }else if( sqliteStrICmp(zDate,"now")==0){
! 320: double r;
! 321: if( sqliteOsCurrentTime(&r)==0 ){
! 322: p->rJD = r;
! 323: p->validJD = 1;
! 324: return 0;
! 325: }
! 326: return 1;
! 327: }else if( sqliteIsNumber(zDate) ){
! 328: p->rJD = sqliteAtoF(zDate, 0);
! 329: p->validJD = 1;
! 330: return 0;
! 331: }
! 332: return 1;
! 333: }
! 334:
! 335: /*
! 336: ** Compute the Year, Month, and Day from the julian day number.
! 337: */
! 338: static void computeYMD(DateTime *p){
! 339: int Z, A, B, C, D, E, X1;
! 340: if( p->validYMD ) return;
! 341: if( !p->validJD ){
! 342: p->Y = 2000;
! 343: p->M = 1;
! 344: p->D = 1;
! 345: }else{
! 346: Z = p->rJD + 0.5;
! 347: A = (Z - 1867216.25)/36524.25;
! 348: A = Z + 1 + A - (A/4);
! 349: B = A + 1524;
! 350: C = (B - 122.1)/365.25;
! 351: D = 365.25*C;
! 352: E = (B-D)/30.6001;
! 353: X1 = 30.6001*E;
! 354: p->D = B - D - X1;
! 355: p->M = E<14 ? E-1 : E-13;
! 356: p->Y = p->M>2 ? C - 4716 : C - 4715;
! 357: }
! 358: p->validYMD = 1;
! 359: }
! 360:
! 361: /*
! 362: ** Compute the Hour, Minute, and Seconds from the julian day number.
! 363: */
! 364: static void computeHMS(DateTime *p){
! 365: int Z, s;
! 366: if( p->validHMS ) return;
! 367: Z = p->rJD + 0.5;
! 368: s = (p->rJD + 0.5 - Z)*86400000.0 + 0.5;
! 369: p->s = 0.001*s;
! 370: s = p->s;
! 371: p->s -= s;
! 372: p->h = s/3600;
! 373: s -= p->h*3600;
! 374: p->m = s/60;
! 375: p->s += s - p->m*60;
! 376: p->validHMS = 1;
! 377: }
! 378:
! 379: /*
! 380: ** Compute both YMD and HMS
! 381: */
! 382: static void computeYMD_HMS(DateTime *p){
! 383: computeYMD(p);
! 384: computeHMS(p);
! 385: }
! 386:
! 387: /*
! 388: ** Clear the YMD and HMS and the TZ
! 389: */
! 390: static void clearYMD_HMS_TZ(DateTime *p){
! 391: p->validYMD = 0;
! 392: p->validHMS = 0;
! 393: p->validTZ = 0;
! 394: }
! 395:
! 396: /*
! 397: ** Compute the difference (in days) between localtime and UTC (a.k.a. GMT)
! 398: ** for the time value p where p is in UTC.
! 399: */
! 400: static double localtimeOffset(DateTime *p){
! 401: DateTime x, y;
! 402: time_t t;
! 403: struct tm *pTm, tmbuf;
! 404: x = *p;
! 405: computeYMD_HMS(&x);
! 406: if( x.Y<1971 || x.Y>=2038 ){
! 407: x.Y = 2000;
! 408: x.M = 1;
! 409: x.D = 1;
! 410: x.h = 0;
! 411: x.m = 0;
! 412: x.s = 0.0;
! 413: } else {
! 414: int s = x.s + 0.5;
! 415: x.s = s;
! 416: }
! 417: x.tz = 0;
! 418: x.validJD = 0;
! 419: computeJD(&x);
! 420: t = (x.rJD-2440587.5)*86400.0 + 0.5;
! 421: sqliteOsEnterMutex();
! 422: pTm = php_localtime_r(&t, &tmbuf);
! 423: if (!pTm) {
! 424: return 0;
! 425: }
! 426: y.Y = pTm->tm_year + 1900;
! 427: y.M = pTm->tm_mon + 1;
! 428: y.D = pTm->tm_mday;
! 429: y.h = pTm->tm_hour;
! 430: y.m = pTm->tm_min;
! 431: y.s = pTm->tm_sec;
! 432: sqliteOsLeaveMutex();
! 433: y.validYMD = 1;
! 434: y.validHMS = 1;
! 435: y.validJD = 0;
! 436: y.validTZ = 0;
! 437: computeJD(&y);
! 438: return y.rJD - x.rJD;
! 439: }
! 440:
! 441: /*
! 442: ** Process a modifier to a date-time stamp. The modifiers are
! 443: ** as follows:
! 444: **
! 445: ** NNN days
! 446: ** NNN hours
! 447: ** NNN minutes
! 448: ** NNN.NNNN seconds
! 449: ** NNN months
! 450: ** NNN years
! 451: ** start of month
! 452: ** start of year
! 453: ** start of week
! 454: ** start of day
! 455: ** weekday N
! 456: ** unixepoch
! 457: ** localtime
! 458: ** utc
! 459: **
! 460: ** Return 0 on success and 1 if there is any kind of error.
! 461: */
! 462: static int parseModifier(const char *zMod, DateTime *p){
! 463: int rc = 1;
! 464: int n;
! 465: double r;
! 466: char *z, zBuf[30];
! 467: z = zBuf;
! 468: for(n=0; n<sizeof(zBuf)-1 && zMod[n]; n++){
! 469: z[n] = tolower(zMod[n]);
! 470: }
! 471: z[n] = 0;
! 472: switch( z[0] ){
! 473: case 'l': {
! 474: /* localtime
! 475: **
! 476: ** Assuming the current time value is UTC (a.k.a. GMT), shift it to
! 477: ** show local time.
! 478: */
! 479: if( strcmp(z, "localtime")==0 ){
! 480: computeJD(p);
! 481: p->rJD += localtimeOffset(p);
! 482: clearYMD_HMS_TZ(p);
! 483: rc = 0;
! 484: }
! 485: break;
! 486: }
! 487: case 'u': {
! 488: /*
! 489: ** unixepoch
! 490: **
! 491: ** Treat the current value of p->rJD as the number of
! 492: ** seconds since 1970. Convert to a real julian day number.
! 493: */
! 494: if( strcmp(z, "unixepoch")==0 && p->validJD ){
! 495: p->rJD = p->rJD/86400.0 + 2440587.5;
! 496: clearYMD_HMS_TZ(p);
! 497: rc = 0;
! 498: }else if( strcmp(z, "utc")==0 ){
! 499: double c1;
! 500: computeJD(p);
! 501: c1 = localtimeOffset(p);
! 502: p->rJD -= c1;
! 503: clearYMD_HMS_TZ(p);
! 504: p->rJD += c1 - localtimeOffset(p);
! 505: rc = 0;
! 506: }
! 507: break;
! 508: }
! 509: case 'w': {
! 510: /*
! 511: ** weekday N
! 512: **
! 513: ** Move the date to the same time on the next occurrance of
! 514: ** weekday N where 0==Sunday, 1==Monday, and so forth. If the
! 515: ** date is already on the appropriate weekday, this is a no-op.
! 516: */
! 517: if( strncmp(z, "weekday ", 8)==0 && getValue(&z[8],&r)>0
! 518: && (n=r)==r && n>=0 && r<7 ){
! 519: int Z;
! 520: computeYMD_HMS(p);
! 521: p->validTZ = 0;
! 522: p->validJD = 0;
! 523: computeJD(p);
! 524: Z = p->rJD + 1.5;
! 525: Z %= 7;
! 526: if( Z>n ) Z -= 7;
! 527: p->rJD += n - Z;
! 528: clearYMD_HMS_TZ(p);
! 529: rc = 0;
! 530: }
! 531: break;
! 532: }
! 533: case 's': {
! 534: /*
! 535: ** start of TTTTT
! 536: **
! 537: ** Move the date backwards to the beginning of the current day,
! 538: ** or month or year.
! 539: */
! 540: if( strncmp(z, "start of ", 9)!=0 ) break;
! 541: z += 9;
! 542: computeYMD(p);
! 543: p->validHMS = 1;
! 544: p->h = p->m = 0;
! 545: p->s = 0.0;
! 546: p->validTZ = 0;
! 547: p->validJD = 0;
! 548: if( strcmp(z,"month")==0 ){
! 549: p->D = 1;
! 550: rc = 0;
! 551: }else if( strcmp(z,"year")==0 ){
! 552: computeYMD(p);
! 553: p->M = 1;
! 554: p->D = 1;
! 555: rc = 0;
! 556: }else if( strcmp(z,"day")==0 ){
! 557: rc = 0;
! 558: }
! 559: break;
! 560: }
! 561: case '+':
! 562: case '-':
! 563: case '0':
! 564: case '1':
! 565: case '2':
! 566: case '3':
! 567: case '4':
! 568: case '5':
! 569: case '6':
! 570: case '7':
! 571: case '8':
! 572: case '9': {
! 573: n = getValue(z, &r);
! 574: if( n<=0 ) break;
! 575: if( z[n]==':' ){
! 576: /* A modifier of the form (+|-)HH:MM:SS.FFF adds (or subtracts) the
! 577: ** specified number of hours, minutes, seconds, and fractional seconds
! 578: ** to the time. The ".FFF" may be omitted. The ":SS.FFF" may be
! 579: ** omitted.
! 580: */
! 581: const char *z2 = z;
! 582: DateTime tx;
! 583: int day;
! 584: if( !isdigit(*z2) ) z2++;
! 585: memset(&tx, 0, sizeof(tx));
! 586: if( parseHhMmSs(z2, &tx) ) break;
! 587: computeJD(&tx);
! 588: tx.rJD -= 0.5;
! 589: day = (int)tx.rJD;
! 590: tx.rJD -= day;
! 591: if( z[0]=='-' ) tx.rJD = -tx.rJD;
! 592: computeJD(p);
! 593: clearYMD_HMS_TZ(p);
! 594: p->rJD += tx.rJD;
! 595: rc = 0;
! 596: break;
! 597: }
! 598: z += n;
! 599: while( isspace(z[0]) ) z++;
! 600: n = strlen(z);
! 601: if( n>10 || n<3 ) break;
! 602: if( z[n-1]=='s' ){ z[n-1] = 0; n--; }
! 603: computeJD(p);
! 604: rc = 0;
! 605: if( n==3 && strcmp(z,"day")==0 ){
! 606: p->rJD += r;
! 607: }else if( n==4 && strcmp(z,"hour")==0 ){
! 608: p->rJD += r/24.0;
! 609: }else if( n==6 && strcmp(z,"minute")==0 ){
! 610: p->rJD += r/(24.0*60.0);
! 611: }else if( n==6 && strcmp(z,"second")==0 ){
! 612: p->rJD += r/(24.0*60.0*60.0);
! 613: }else if( n==5 && strcmp(z,"month")==0 ){
! 614: int x, y;
! 615: computeYMD_HMS(p);
! 616: p->M += r;
! 617: x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12;
! 618: p->Y += x;
! 619: p->M -= x*12;
! 620: p->validJD = 0;
! 621: computeJD(p);
! 622: y = r;
! 623: if( y!=r ){
! 624: p->rJD += (r - y)*30.0;
! 625: }
! 626: }else if( n==4 && strcmp(z,"year")==0 ){
! 627: computeYMD_HMS(p);
! 628: p->Y += r;
! 629: p->validJD = 0;
! 630: computeJD(p);
! 631: }else{
! 632: rc = 1;
! 633: }
! 634: clearYMD_HMS_TZ(p);
! 635: break;
! 636: }
! 637: default: {
! 638: break;
! 639: }
! 640: }
! 641: return rc;
! 642: }
! 643:
! 644: /*
! 645: ** Process time function arguments. argv[0] is a date-time stamp.
! 646: ** argv[1] and following are modifiers. Parse them all and write
! 647: ** the resulting time into the DateTime structure p. Return 0
! 648: ** on success and 1 if there are any errors.
! 649: */
! 650: static int isDate(int argc, const char **argv, DateTime *p){
! 651: int i;
! 652: if( argc==0 ) return 1;
! 653: if( argv[0]==0 || parseDateOrTime(argv[0], p) ) return 1;
! 654: for(i=1; i<argc; i++){
! 655: if( argv[i]==0 || parseModifier(argv[i], p) ) return 1;
! 656: }
! 657: return 0;
! 658: }
! 659:
! 660:
! 661: /*
! 662: ** The following routines implement the various date and time functions
! 663: ** of SQLite.
! 664: */
! 665:
! 666: /*
! 667: ** julianday( TIMESTRING, MOD, MOD, ...)
! 668: **
! 669: ** Return the julian day number of the date specified in the arguments
! 670: */
! 671: static void juliandayFunc(sqlite_func *context, int argc, const char **argv){
! 672: DateTime x;
! 673: if( isDate(argc, argv, &x)==0 ){
! 674: computeJD(&x);
! 675: sqlite_set_result_double(context, x.rJD);
! 676: }
! 677: }
! 678:
! 679: /*
! 680: ** datetime( TIMESTRING, MOD, MOD, ...)
! 681: **
! 682: ** Return YYYY-MM-DD HH:MM:SS
! 683: */
! 684: static void datetimeFunc(sqlite_func *context, int argc, const char **argv){
! 685: DateTime x;
! 686: if( isDate(argc, argv, &x)==0 ){
! 687: char zBuf[100];
! 688: computeYMD_HMS(&x);
! 689: sprintf(zBuf, "%04d-%02d-%02d %02d:%02d:%02d",x.Y, x.M, x.D, x.h, x.m,
! 690: (int)(x.s));
! 691: sqlite_set_result_string(context, zBuf, -1);
! 692: }
! 693: }
! 694:
! 695: /*
! 696: ** time( TIMESTRING, MOD, MOD, ...)
! 697: **
! 698: ** Return HH:MM:SS
! 699: */
! 700: static void timeFunc(sqlite_func *context, int argc, const char **argv){
! 701: DateTime x;
! 702: if( isDate(argc, argv, &x)==0 ){
! 703: char zBuf[100];
! 704: computeHMS(&x);
! 705: sprintf(zBuf, "%02d:%02d:%02d", x.h, x.m, (int)x.s);
! 706: sqlite_set_result_string(context, zBuf, -1);
! 707: }
! 708: }
! 709:
! 710: /*
! 711: ** date( TIMESTRING, MOD, MOD, ...)
! 712: **
! 713: ** Return YYYY-MM-DD
! 714: */
! 715: static void dateFunc(sqlite_func *context, int argc, const char **argv){
! 716: DateTime x;
! 717: if( isDate(argc, argv, &x)==0 ){
! 718: char zBuf[100];
! 719: computeYMD(&x);
! 720: sprintf(zBuf, "%04d-%02d-%02d", x.Y, x.M, x.D);
! 721: sqlite_set_result_string(context, zBuf, -1);
! 722: }
! 723: }
! 724:
! 725: /*
! 726: ** strftime( FORMAT, TIMESTRING, MOD, MOD, ...)
! 727: **
! 728: ** Return a string described by FORMAT. Conversions as follows:
! 729: **
! 730: ** %d day of month
! 731: ** %f ** fractional seconds SS.SSS
! 732: ** %H hour 00-24
! 733: ** %j day of year 000-366
! 734: ** %J ** Julian day number
! 735: ** %m month 01-12
! 736: ** %M minute 00-59
! 737: ** %s seconds since 1970-01-01
! 738: ** %S seconds 00-59
! 739: ** %w day of week 0-6 sunday==0
! 740: ** %W week of year 00-53
! 741: ** %Y year 0000-9999
! 742: ** %% %
! 743: */
! 744: static void strftimeFunc(sqlite_func *context, int argc, const char **argv){
! 745: DateTime x;
! 746: int n, i, j;
! 747: char *z;
! 748: const char *zFmt = argv[0];
! 749: char zBuf[100];
! 750: if( argv[0]==0 || isDate(argc-1, argv+1, &x) ) return;
! 751: for(i=0, n=1; zFmt[i]; i++, n++){
! 752: if( zFmt[i]=='%' ){
! 753: switch( zFmt[i+1] ){
! 754: case 'd':
! 755: case 'H':
! 756: case 'm':
! 757: case 'M':
! 758: case 'S':
! 759: case 'W':
! 760: n++;
! 761: /* fall thru */
! 762: case 'w':
! 763: case '%':
! 764: break;
! 765: case 'f':
! 766: n += 8;
! 767: break;
! 768: case 'j':
! 769: n += 3;
! 770: break;
! 771: case 'Y':
! 772: n += 8;
! 773: break;
! 774: case 's':
! 775: case 'J':
! 776: n += 50;
! 777: break;
! 778: default:
! 779: return; /* ERROR. return a NULL */
! 780: }
! 781: i++;
! 782: }
! 783: }
! 784: if( n<sizeof(zBuf) ){
! 785: z = zBuf;
! 786: }else{
! 787: z = sqliteMalloc( n );
! 788: if( z==0 ) return;
! 789: }
! 790: computeJD(&x);
! 791: computeYMD_HMS(&x);
! 792: for(i=j=0; zFmt[i]; i++){
! 793: if( zFmt[i]!='%' ){
! 794: z[j++] = zFmt[i];
! 795: }else{
! 796: i++;
! 797: switch( zFmt[i] ){
! 798: case 'd': sprintf(&z[j],"%02d",x.D); j+=2; break;
! 799: case 'f': {
! 800: int s = x.s;
! 801: int ms = (x.s - s)*1000.0;
! 802: sprintf(&z[j],"%02d.%03d",s,ms);
! 803: j += strlen(&z[j]);
! 804: break;
! 805: }
! 806: case 'H': sprintf(&z[j],"%02d",x.h); j+=2; break;
! 807: case 'W': /* Fall thru */
! 808: case 'j': {
! 809: int n; /* Number of days since 1st day of year */
! 810: DateTime y = x;
! 811: y.validJD = 0;
! 812: y.M = 1;
! 813: y.D = 1;
! 814: computeJD(&y);
! 815: n = x.rJD - y.rJD;
! 816: if( zFmt[i]=='W' ){
! 817: int wd; /* 0=Monday, 1=Tuesday, ... 6=Sunday */
! 818: wd = ((int)(x.rJD+0.5)) % 7;
! 819: sprintf(&z[j],"%02d",(n+7-wd)/7);
! 820: j += 2;
! 821: }else{
! 822: sprintf(&z[j],"%03d",n+1);
! 823: j += 3;
! 824: }
! 825: break;
! 826: }
! 827: case 'J': sprintf(&z[j],"%.16g",x.rJD); j+=strlen(&z[j]); break;
! 828: case 'm': sprintf(&z[j],"%02d",x.M); j+=2; break;
! 829: case 'M': sprintf(&z[j],"%02d",x.m); j+=2; break;
! 830: case 's': {
! 831: sprintf(&z[j],"%d",(int)((x.rJD-2440587.5)*86400.0 + 0.5));
! 832: j += strlen(&z[j]);
! 833: break;
! 834: }
! 835: case 'S': sprintf(&z[j],"%02d",(int)(x.s+0.5)); j+=2; break;
! 836: case 'w': z[j++] = (((int)(x.rJD+1.5)) % 7) + '0'; break;
! 837: case 'Y': sprintf(&z[j],"%04d",x.Y); j+=strlen(&z[j]); break;
! 838: case '%': z[j++] = '%'; break;
! 839: }
! 840: }
! 841: }
! 842: z[j] = 0;
! 843: sqlite_set_result_string(context, z, -1);
! 844: if( z!=zBuf ){
! 845: sqliteFree(z);
! 846: }
! 847: }
! 848:
! 849:
! 850: #endif /* !defined(SQLITE_OMIT_DATETIME_FUNCS) */
! 851:
! 852: /*
! 853: ** This function registered all of the above C functions as SQL
! 854: ** functions. This should be the only routine in this file with
! 855: ** external linkage.
! 856: */
! 857: void sqliteRegisterDateTimeFunctions(sqlite *db){
! 858: #ifndef SQLITE_OMIT_DATETIME_FUNCS
! 859: static struct {
! 860: char *zName;
! 861: int nArg;
! 862: int dataType;
! 863: void (*xFunc)(sqlite_func*,int,const char**);
! 864: } aFuncs[] = {
! 865: { "julianday", -1, SQLITE_NUMERIC, juliandayFunc },
! 866: { "date", -1, SQLITE_TEXT, dateFunc },
! 867: { "time", -1, SQLITE_TEXT, timeFunc },
! 868: { "datetime", -1, SQLITE_TEXT, datetimeFunc },
! 869: { "strftime", -1, SQLITE_TEXT, strftimeFunc },
! 870: };
! 871: int i;
! 872:
! 873: for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
! 874: sqlite_create_function(db, aFuncs[i].zName,
! 875: aFuncs[i].nArg, aFuncs[i].xFunc, 0);
! 876: if( aFuncs[i].xFunc ){
! 877: sqlite_function_type(db, aFuncs[i].zName, aFuncs[i].dataType);
! 878: }
! 879: }
! 880: #endif
! 881: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to date.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / sqlite / libsqlite / src