date.c
上传用户:sunhongbo
上传日期:2022-01-25
资源大小:3010k
文件大小:25k
源码类别:

数据库系统

开发平台:

C/C++

  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. ** sqlite3RegisterDateTimeFunctions() found at the bottom of the file.
  17. ** All other code has file scope.
  18. **
  19. ** $Id: date.c,v 1.79 2008/03/20 14:03:29 drh Exp $
  20. **
  21. ** SQLite processes all times and dates as Julian Day numbers.  The
  22. ** dates and times are stored as the number of days since noon
  23. ** in Greenwich on November 24, 4714 B.C. according to the Gregorian
  24. ** calendar system. 
  25. **
  26. ** 1970-01-01 00:00:00 is JD 2440587.5
  27. ** 2000-01-01 00:00:00 is JD 2451544.5
  28. **
  29. ** This implemention requires years to be expressed as a 4-digit number
  30. ** which means that only dates between 0000-01-01 and 9999-12-31 can
  31. ** be represented, even though julian day numbers allow a much wider
  32. ** range of dates.
  33. **
  34. ** The Gregorian calendar system is used for all dates and times,
  35. ** even those that predate the Gregorian calendar.  Historians usually
  36. ** use the Julian calendar for dates prior to 1582-10-15 and for some
  37. ** dates afterwards, depending on locale.  Beware of this difference.
  38. **
  39. ** The conversion algorithms are implemented based on descriptions
  40. ** in the following text:
  41. **
  42. **      Jean Meeus
  43. **      Astronomical Algorithms, 2nd Edition, 1998
  44. **      ISBM 0-943396-61-1
  45. **      Willmann-Bell, Inc
  46. **      Richmond, Virginia (USA)
  47. */
  48. #include "sqliteInt.h"
  49. #include <ctype.h>
  50. #include <stdlib.h>
  51. #include <assert.h>
  52. #include <time.h>
  53. #ifndef SQLITE_OMIT_DATETIME_FUNCS
  54. /*
  55. ** A structure for holding a single date and time.
  56. */
  57. typedef struct DateTime DateTime;
  58. struct DateTime {
  59.   double rJD;      /* The julian day number */
  60.   int Y, M, D;     /* Year, month, and day */
  61.   int h, m;        /* Hour and minutes */
  62.   int tz;          /* Timezone offset in minutes */
  63.   double s;        /* Seconds */
  64.   char validYMD;   /* True if Y,M,D are valid */
  65.   char validHMS;   /* True if h,m,s are valid */
  66.   char validJD;    /* True if rJD is valid */
  67.   char validTZ;    /* True if tz is valid */
  68. };
  69. /*
  70. ** Convert zDate into one or more integers.  Additional arguments
  71. ** come in groups of 5 as follows:
  72. **
  73. **       N       number of digits in the integer
  74. **       min     minimum allowed value of the integer
  75. **       max     maximum allowed value of the integer
  76. **       nextC   first character after the integer
  77. **       pVal    where to write the integers value.
  78. **
  79. ** Conversions continue until one with nextC==0 is encountered.
  80. ** The function returns the number of successful conversions.
  81. */
  82. static int getDigits(const char *zDate, ...){
  83.   va_list ap;
  84.   int val;
  85.   int N;
  86.   int min;
  87.   int max;
  88.   int nextC;
  89.   int *pVal;
  90.   int cnt = 0;
  91.   va_start(ap, zDate);
  92.   do{
  93.     N = va_arg(ap, int);
  94.     min = va_arg(ap, int);
  95.     max = va_arg(ap, int);
  96.     nextC = va_arg(ap, int);
  97.     pVal = va_arg(ap, int*);
  98.     val = 0;
  99.     while( N-- ){
  100.       if( !isdigit(*(u8*)zDate) ){
  101.         goto end_getDigits;
  102.       }
  103.       val = val*10 + *zDate - '0';
  104.       zDate++;
  105.     }
  106.     if( val<min || val>max || (nextC!=0 && nextC!=*zDate) ){
  107.       goto end_getDigits;
  108.     }
  109.     *pVal = val;
  110.     zDate++;
  111.     cnt++;
  112.   }while( nextC );
  113. end_getDigits:
  114.   va_end(ap);
  115.   return cnt;
  116. }
  117. /*
  118. ** Read text from z[] and convert into a floating point number.  Return
  119. ** the number of digits converted.
  120. */
  121. #define getValue sqlite3AtoF
  122. /*
  123. ** Parse a timezone extension on the end of a date-time.
  124. ** The extension is of the form:
  125. **
  126. **        (+/-)HH:MM
  127. **
  128. ** Or the "zulu" notation:
  129. **
  130. **        Z
  131. **
  132. ** If the parse is successful, write the number of minutes
  133. ** of change in p->tz and return 0.  If a parser error occurs,
  134. ** return non-zero.
  135. **
  136. ** A missing specifier is not considered an error.
  137. */
  138. static int parseTimezone(const char *zDate, DateTime *p){
  139.   int sgn = 0;
  140.   int nHr, nMn;
  141.   int c;
  142.   while( isspace(*(u8*)zDate) ){ zDate++; }
  143.   p->tz = 0;
  144.   c = *zDate;
  145.   if( c=='-' ){
  146.     sgn = -1;
  147.   }else if( c=='+' ){
  148.     sgn = +1;
  149.   }else if( c=='Z' || c=='z' ){
  150.     zDate++;
  151.     goto zulu_time;
  152.   }else{
  153.     return c!=0;
  154.   }
  155.   zDate++;
  156.   if( getDigits(zDate, 2, 0, 14, ':', &nHr, 2, 0, 59, 0, &nMn)!=2 ){
  157.     return 1;
  158.   }
  159.   zDate += 5;
  160.   p->tz = sgn*(nMn + nHr*60);
  161. zulu_time:
  162.   while( isspace(*(u8*)zDate) ){ zDate++; }
  163.   return *zDate!=0;
  164. }
  165. /*
  166. ** Parse times of the form HH:MM or HH:MM:SS or HH:MM:SS.FFFF.
  167. ** The HH, MM, and SS must each be exactly 2 digits.  The
  168. ** fractional seconds FFFF can be one or more digits.
  169. **
  170. ** Return 1 if there is a parsing error and 0 on success.
  171. */
  172. static int parseHhMmSs(const char *zDate, DateTime *p){
  173.   int h, m, s;
  174.   double ms = 0.0;
  175.   if( getDigits(zDate, 2, 0, 24, ':', &h, 2, 0, 59, 0, &m)!=2 ){
  176.     return 1;
  177.   }
  178.   zDate += 5;
  179.   if( *zDate==':' ){
  180.     zDate++;
  181.     if( getDigits(zDate, 2, 0, 59, 0, &s)!=1 ){
  182.       return 1;
  183.     }
  184.     zDate += 2;
  185.     if( *zDate=='.' && isdigit((u8)zDate[1]) ){
  186.       double rScale = 1.0;
  187.       zDate++;
  188.       while( isdigit(*(u8*)zDate) ){
  189.         ms = ms*10.0 + *zDate - '0';
  190.         rScale *= 10.0;
  191.         zDate++;
  192.       }
  193.       ms /= rScale;
  194.     }
  195.   }else{
  196.     s = 0;
  197.   }
  198.   p->validJD = 0;
  199.   p->validHMS = 1;
  200.   p->h = h;
  201.   p->m = m;
  202.   p->s = s + ms;
  203.   if( parseTimezone(zDate, p) ) return 1;
  204.   p->validTZ = p->tz!=0;
  205.   return 0;
  206. }
  207. /*
  208. ** Convert from YYYY-MM-DD HH:MM:SS to julian day.  We always assume
  209. ** that the YYYY-MM-DD is according to the Gregorian calendar.
  210. **
  211. ** Reference:  Meeus page 61
  212. */
  213. static void computeJD(DateTime *p){
  214.   int Y, M, D, A, B, X1, X2;
  215.   if( p->validJD ) return;
  216.   if( p->validYMD ){
  217.     Y = p->Y;
  218.     M = p->M;
  219.     D = p->D;
  220.   }else{
  221.     Y = 2000;  /* If no YMD specified, assume 2000-Jan-01 */
  222.     M = 1;
  223.     D = 1;
  224.   }
  225.   if( M<=2 ){
  226.     Y--;
  227.     M += 12;
  228.   }
  229.   A = Y/100;
  230.   B = 2 - A + (A/4);
  231.   X1 = 365.25*(Y+4716);
  232.   X2 = 30.6001*(M+1);
  233.   p->rJD = X1 + X2 + D + B - 1524.5;
  234.   p->validJD = 1;
  235.   if( p->validHMS ){
  236.     p->rJD += (p->h*3600.0 + p->m*60.0 + p->s)/86400.0;
  237.     if( p->validTZ ){
  238.       p->rJD -= p->tz*60/86400.0;
  239.       p->validYMD = 0;
  240.       p->validHMS = 0;
  241.       p->validTZ = 0;
  242.     }
  243.   }
  244. }
  245. /*
  246. ** Parse dates of the form
  247. **
  248. **     YYYY-MM-DD HH:MM:SS.FFF
  249. **     YYYY-MM-DD HH:MM:SS
  250. **     YYYY-MM-DD HH:MM
  251. **     YYYY-MM-DD
  252. **
  253. ** Write the result into the DateTime structure and return 0
  254. ** on success and 1 if the input string is not a well-formed
  255. ** date.
  256. */
  257. static int parseYyyyMmDd(const char *zDate, DateTime *p){
  258.   int Y, M, D, neg;
  259.   if( zDate[0]=='-' ){
  260.     zDate++;
  261.     neg = 1;
  262.   }else{
  263.     neg = 0;
  264.   }
  265.   if( getDigits(zDate,4,0,9999,'-',&Y,2,1,12,'-',&M,2,1,31,0,&D)!=3 ){
  266.     return 1;
  267.   }
  268.   zDate += 10;
  269.   while( isspace(*(u8*)zDate) || 'T'==*(u8*)zDate ){ zDate++; }
  270.   if( parseHhMmSs(zDate, p)==0 ){
  271.     /* We got the time */
  272.   }else if( *zDate==0 ){
  273.     p->validHMS = 0;
  274.   }else{
  275.     return 1;
  276.   }
  277.   p->validJD = 0;
  278.   p->validYMD = 1;
  279.   p->Y = neg ? -Y : Y;
  280.   p->M = M;
  281.   p->D = D;
  282.   if( p->validTZ ){
  283.     computeJD(p);
  284.   }
  285.   return 0;
  286. }
  287. /*
  288. ** Attempt to parse the given string into a Julian Day Number.  Return
  289. ** the number of errors.
  290. **
  291. ** The following are acceptable forms for the input string:
  292. **
  293. **      YYYY-MM-DD HH:MM:SS.FFF  +/-HH:MM
  294. **      DDDD.DD 
  295. **      now
  296. **
  297. ** In the first form, the +/-HH:MM is always optional.  The fractional
  298. ** seconds extension (the ".FFF") is optional.  The seconds portion
  299. ** (":SS.FFF") is option.  The year and date can be omitted as long
  300. ** as there is a time string.  The time string can be omitted as long
  301. ** as there is a year and date.
  302. */
  303. static int parseDateOrTime(
  304.   sqlite3_context *context, 
  305.   const char *zDate, 
  306.   DateTime *p
  307. ){
  308.   memset(p, 0, sizeof(*p));
  309.   if( parseYyyyMmDd(zDate,p)==0 ){
  310.     return 0;
  311.   }else if( parseHhMmSs(zDate, p)==0 ){
  312.     return 0;
  313.   }else if( sqlite3StrICmp(zDate,"now")==0){
  314.     double r;
  315.     sqlite3 *db = sqlite3_context_db_handle(context);
  316.     sqlite3OsCurrentTime(db->pVfs, &r);
  317.     p->rJD = r;
  318.     p->validJD = 1;
  319.     return 0;
  320.   }else if( sqlite3IsNumber(zDate, 0, SQLITE_UTF8) ){
  321.     getValue(zDate, &p->rJD);
  322.     p->validJD = 1;
  323.     return 0;
  324.   }
  325.   return 1;
  326. }
  327. /*
  328. ** Compute the Year, Month, and Day from the julian day number.
  329. */
  330. static void computeYMD(DateTime *p){
  331.   int Z, A, B, C, D, E, X1;
  332.   if( p->validYMD ) return;
  333.   if( !p->validJD ){
  334.     p->Y = 2000;
  335.     p->M = 1;
  336.     p->D = 1;
  337.   }else{
  338.     Z = p->rJD + 0.5;
  339.     A = (Z - 1867216.25)/36524.25;
  340.     A = Z + 1 + A - (A/4);
  341.     B = A + 1524;
  342.     C = (B - 122.1)/365.25;
  343.     D = 365.25*C;
  344.     E = (B-D)/30.6001;
  345.     X1 = 30.6001*E;
  346.     p->D = B - D - X1;
  347.     p->M = E<14 ? E-1 : E-13;
  348.     p->Y = p->M>2 ? C - 4716 : C - 4715;
  349.   }
  350.   p->validYMD = 1;
  351. }
  352. /*
  353. ** Compute the Hour, Minute, and Seconds from the julian day number.
  354. */
  355. static void computeHMS(DateTime *p){
  356.   int Z, s;
  357.   if( p->validHMS ) return;
  358.   computeJD(p);
  359.   Z = p->rJD + 0.5;
  360.   s = (p->rJD + 0.5 - Z)*86400000.0 + 0.5;
  361.   p->s = 0.001*s;
  362.   s = p->s;
  363.   p->s -= s;
  364.   p->h = s/3600;
  365.   s -= p->h*3600;
  366.   p->m = s/60;
  367.   p->s += s - p->m*60;
  368.   p->validHMS = 1;
  369. }
  370. /*
  371. ** Compute both YMD and HMS
  372. */
  373. static void computeYMD_HMS(DateTime *p){
  374.   computeYMD(p);
  375.   computeHMS(p);
  376. }
  377. /*
  378. ** Clear the YMD and HMS and the TZ
  379. */
  380. static void clearYMD_HMS_TZ(DateTime *p){
  381.   p->validYMD = 0;
  382.   p->validHMS = 0;
  383.   p->validTZ = 0;
  384. }
  385. /*
  386. ** Compute the difference (in days) between localtime and UTC (a.k.a. GMT)
  387. ** for the time value p where p is in UTC.
  388. */
  389. static double localtimeOffset(DateTime *p){
  390.   DateTime x, y;
  391.   time_t t;
  392.   x = *p;
  393.   computeYMD_HMS(&x);
  394.   if( x.Y<1971 || x.Y>=2038 ){
  395.     x.Y = 2000;
  396.     x.M = 1;
  397.     x.D = 1;
  398.     x.h = 0;
  399.     x.m = 0;
  400.     x.s = 0.0;
  401.   } else {
  402.     int s = x.s + 0.5;
  403.     x.s = s;
  404.   }
  405.   x.tz = 0;
  406.   x.validJD = 0;
  407.   computeJD(&x);
  408.   t = (x.rJD-2440587.5)*86400.0 + 0.5;
  409. #ifdef HAVE_LOCALTIME_R
  410.   {
  411.     struct tm sLocal;
  412.     localtime_r(&t, &sLocal);
  413.     y.Y = sLocal.tm_year + 1900;
  414.     y.M = sLocal.tm_mon + 1;
  415.     y.D = sLocal.tm_mday;
  416.     y.h = sLocal.tm_hour;
  417.     y.m = sLocal.tm_min;
  418.     y.s = sLocal.tm_sec;
  419.   }
  420. #else
  421.   {
  422.     struct tm *pTm;
  423.     sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER));
  424.     pTm = localtime(&t);
  425.     y.Y = pTm->tm_year + 1900;
  426.     y.M = pTm->tm_mon + 1;
  427.     y.D = pTm->tm_mday;
  428.     y.h = pTm->tm_hour;
  429.     y.m = pTm->tm_min;
  430.     y.s = pTm->tm_sec;
  431.     sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER));
  432.   }
  433. #endif
  434.   y.validYMD = 1;
  435.   y.validHMS = 1;
  436.   y.validJD = 0;
  437.   y.validTZ = 0;
  438.   computeJD(&y);
  439.   return y.rJD - x.rJD;
  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 occurrence 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.       assert( n>=1 );
  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(*(u8*)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(*(u8*)z) ) 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. ** Process time function arguments.  argv[0] is a date-time stamp.
  645. ** argv[1] and following are modifiers.  Parse them all and write
  646. ** the resulting time into the DateTime structure p.  Return 0
  647. ** on success and 1 if there are any errors.
  648. **
  649. ** If there are zero parameters (if even argv[0] is undefined)
  650. ** then assume a default value of "now" for argv[0].
  651. */
  652. static int isDate(
  653.   sqlite3_context *context, 
  654.   int argc, 
  655.   sqlite3_value **argv, 
  656.   DateTime *p
  657. ){
  658.   int i;
  659.   const unsigned char *z;
  660.   static const unsigned char zDflt[] = "now";
  661.   if( argc==0 ){
  662.     z = zDflt;
  663.   }else{
  664.     z = sqlite3_value_text(argv[0]);
  665.   }
  666.   if( !z || parseDateOrTime(context, (char*)z, p) ){
  667.     return 1;
  668.   }
  669.   for(i=1; i<argc; i++){
  670.     if( (z = sqlite3_value_text(argv[i]))==0 || parseModifier((char*)z, p) ){
  671.       return 1;
  672.     }
  673.   }
  674.   return 0;
  675. }
  676. /*
  677. ** The following routines implement the various date and time functions
  678. ** of SQLite.
  679. */
  680. /*
  681. **    julianday( TIMESTRING, MOD, MOD, ...)
  682. **
  683. ** Return the julian day number of the date specified in the arguments
  684. */
  685. static void juliandayFunc(
  686.   sqlite3_context *context,
  687.   int argc,
  688.   sqlite3_value **argv
  689. ){
  690.   DateTime x;
  691.   if( isDate(context, argc, argv, &x)==0 ){
  692.     computeJD(&x);
  693.     sqlite3_result_double(context, x.rJD);
  694.   }
  695. }
  696. /*
  697. **    datetime( TIMESTRING, MOD, MOD, ...)
  698. **
  699. ** Return YYYY-MM-DD HH:MM:SS
  700. */
  701. static void datetimeFunc(
  702.   sqlite3_context *context,
  703.   int argc,
  704.   sqlite3_value **argv
  705. ){
  706.   DateTime x;
  707.   if( isDate(context, argc, argv, &x)==0 ){
  708.     char zBuf[100];
  709.     computeYMD_HMS(&x);
  710.     sqlite3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d %02d:%02d:%02d",
  711.                      x.Y, x.M, x.D, x.h, x.m, (int)(x.s));
  712.     sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
  713.   }
  714. }
  715. /*
  716. **    time( TIMESTRING, MOD, MOD, ...)
  717. **
  718. ** Return HH:MM:SS
  719. */
  720. static void timeFunc(
  721.   sqlite3_context *context,
  722.   int argc,
  723.   sqlite3_value **argv
  724. ){
  725.   DateTime x;
  726.   if( isDate(context, argc, argv, &x)==0 ){
  727.     char zBuf[100];
  728.     computeHMS(&x);
  729.     sqlite3_snprintf(sizeof(zBuf), zBuf, "%02d:%02d:%02d", x.h, x.m, (int)x.s);
  730.     sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
  731.   }
  732. }
  733. /*
  734. **    date( TIMESTRING, MOD, MOD, ...)
  735. **
  736. ** Return YYYY-MM-DD
  737. */
  738. static void dateFunc(
  739.   sqlite3_context *context,
  740.   int argc,
  741.   sqlite3_value **argv
  742. ){
  743.   DateTime x;
  744.   if( isDate(context, argc, argv, &x)==0 ){
  745.     char zBuf[100];
  746.     computeYMD(&x);
  747.     sqlite3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d", x.Y, x.M, x.D);
  748.     sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
  749.   }
  750. }
  751. /*
  752. **    strftime( FORMAT, TIMESTRING, MOD, MOD, ...)
  753. **
  754. ** Return a string described by FORMAT.  Conversions as follows:
  755. **
  756. **   %d  day of month
  757. **   %f  ** fractional seconds  SS.SSS
  758. **   %H  hour 00-24
  759. **   %j  day of year 000-366
  760. **   %J  ** Julian day number
  761. **   %m  month 01-12
  762. **   %M  minute 00-59
  763. **   %s  seconds since 1970-01-01
  764. **   %S  seconds 00-59
  765. **   %w  day of week 0-6  sunday==0
  766. **   %W  week of year 00-53
  767. **   %Y  year 0000-9999
  768. **   %%  %
  769. */
  770. static void strftimeFunc(
  771.   sqlite3_context *context,
  772.   int argc,
  773.   sqlite3_value **argv
  774. ){
  775.   DateTime x;
  776.   u64 n;
  777.   int i, j;
  778.   char *z;
  779.   const char *zFmt = (const char*)sqlite3_value_text(argv[0]);
  780.   char zBuf[100];
  781.   if( zFmt==0 || isDate(context, argc-1, argv+1, &x) ) return;
  782.   for(i=0, n=1; zFmt[i]; i++, n++){
  783.     if( zFmt[i]=='%' ){
  784.       switch( zFmt[i+1] ){
  785.         case 'd':
  786.         case 'H':
  787.         case 'm':
  788.         case 'M':
  789.         case 'S':
  790.         case 'W':
  791.           n++;
  792.           /* fall thru */
  793.         case 'w':
  794.         case '%':
  795.           break;
  796.         case 'f':
  797.           n += 8;
  798.           break;
  799.         case 'j':
  800.           n += 3;
  801.           break;
  802.         case 'Y':
  803.           n += 8;
  804.           break;
  805.         case 's':
  806.         case 'J':
  807.           n += 50;
  808.           break;
  809.         default:
  810.           return;  /* ERROR.  return a NULL */
  811.       }
  812.       i++;
  813.     }
  814.   }
  815.   if( n<sizeof(zBuf) ){
  816.     z = zBuf;
  817.   }else if( n>sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH] ){
  818.     sqlite3_result_error_toobig(context);
  819.     return;
  820.   }else{
  821.     z = sqlite3_malloc( n );
  822.     if( z==0 ){
  823.       sqlite3_result_error_nomem(context);
  824.       return;
  825.     }
  826.   }
  827.   computeJD(&x);
  828.   computeYMD_HMS(&x);
  829.   for(i=j=0; zFmt[i]; i++){
  830.     if( zFmt[i]!='%' ){
  831.       z[j++] = zFmt[i];
  832.     }else{
  833.       i++;
  834.       switch( zFmt[i] ){
  835.         case 'd':  sqlite3_snprintf(3, &z[j],"%02d",x.D); j+=2; break;
  836.         case 'f': {
  837.           double s = x.s;
  838.           if( s>59.999 ) s = 59.999;
  839.           sqlite3_snprintf(7, &z[j],"%06.3f", s);
  840.           j += strlen(&z[j]);
  841.           break;
  842.         }
  843.         case 'H':  sqlite3_snprintf(3, &z[j],"%02d",x.h); j+=2; break;
  844.         case 'W': /* Fall thru */
  845.         case 'j': {
  846.           int nDay;             /* Number of days since 1st day of year */
  847.           DateTime y = x;
  848.           y.validJD = 0;
  849.           y.M = 1;
  850.           y.D = 1;
  851.           computeJD(&y);
  852.           nDay = x.rJD - y.rJD + 0.5;
  853.           if( zFmt[i]=='W' ){
  854.             int wd;   /* 0=Monday, 1=Tuesday, ... 6=Sunday */
  855.             wd = ((int)(x.rJD+0.5)) % 7;
  856.             sqlite3_snprintf(3, &z[j],"%02d",(nDay+7-wd)/7);
  857.             j += 2;
  858.           }else{
  859.             sqlite3_snprintf(4, &z[j],"%03d",nDay+1);
  860.             j += 3;
  861.           }
  862.           break;
  863.         }
  864.         case 'J': {
  865.           sqlite3_snprintf(20, &z[j],"%.16g",x.rJD);
  866.           j+=strlen(&z[j]);
  867.           break;
  868.         }
  869.         case 'm':  sqlite3_snprintf(3, &z[j],"%02d",x.M); j+=2; break;
  870.         case 'M':  sqlite3_snprintf(3, &z[j],"%02d",x.m); j+=2; break;
  871.         case 's': {
  872.           sqlite3_snprintf(30,&z[j],"%d",
  873.                            (int)((x.rJD-2440587.5)*86400.0 + 0.5));
  874.           j += strlen(&z[j]);
  875.           break;
  876.         }
  877.         case 'S':  sqlite3_snprintf(3,&z[j],"%02d",(int)x.s); j+=2; break;
  878.         case 'w':  z[j++] = (((int)(x.rJD+1.5)) % 7) + '0'; break;
  879.         case 'Y':  sqlite3_snprintf(5,&z[j],"%04d",x.Y); j+=strlen(&z[j]);break;
  880.         default:   z[j++] = '%'; break;
  881.       }
  882.     }
  883.   }
  884.   z[j] = 0;
  885.   sqlite3_result_text(context, z, -1,
  886.                       z==zBuf ? SQLITE_TRANSIENT : sqlite3_free);
  887. }
  888. /*
  889. ** current_time()
  890. **
  891. ** This function returns the same value as time('now').
  892. */
  893. static void ctimeFunc(
  894.   sqlite3_context *context,
  895.   int argc,
  896.   sqlite3_value **argv
  897. ){
  898.   timeFunc(context, 0, 0);
  899. }
  900. /*
  901. ** current_date()
  902. **
  903. ** This function returns the same value as date('now').
  904. */
  905. static void cdateFunc(
  906.   sqlite3_context *context,
  907.   int argc,
  908.   sqlite3_value **argv
  909. ){
  910.   dateFunc(context, 0, 0);
  911. }
  912. /*
  913. ** current_timestamp()
  914. **
  915. ** This function returns the same value as datetime('now').
  916. */
  917. static void ctimestampFunc(
  918.   sqlite3_context *context,
  919.   int argc,
  920.   sqlite3_value **argv
  921. ){
  922.   datetimeFunc(context, 0, 0);
  923. }
  924. #endif /* !defined(SQLITE_OMIT_DATETIME_FUNCS) */
  925. #ifdef SQLITE_OMIT_DATETIME_FUNCS
  926. /*
  927. ** If the library is compiled to omit the full-scale date and time
  928. ** handling (to get a smaller binary), the following minimal version
  929. ** of the functions current_time(), current_date() and current_timestamp()
  930. ** are included instead. This is to support column declarations that
  931. ** include "DEFAULT CURRENT_TIME" etc.
  932. **
  933. ** This function uses the C-library functions time(), gmtime()
  934. ** and strftime(). The format string to pass to strftime() is supplied
  935. ** as the user-data for the function.
  936. */
  937. static void currentTimeFunc(
  938.   sqlite3_context *context,
  939.   int argc,
  940.   sqlite3_value **argv
  941. ){
  942.   time_t t;
  943.   char *zFormat = (char *)sqlite3_user_data(context);
  944.   sqlite3 *db;
  945.   double rT;
  946.   char zBuf[20];
  947.   db = sqlite3_context_db_handle(context);
  948.   sqlite3OsCurrentTime(db->pVfs, &rT);
  949.   t = 86400.0*(rT - 2440587.5) + 0.5;
  950. #ifdef HAVE_GMTIME_R
  951.   {
  952.     struct tm sNow;
  953.     gmtime_r(&t, &sNow);
  954.     strftime(zBuf, 20, zFormat, &sNow);
  955.   }
  956. #else
  957.   {
  958.     struct tm *pTm;
  959.     sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER));
  960.     pTm = gmtime(&t);
  961.     strftime(zBuf, 20, zFormat, pTm);
  962.     sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER));
  963.   }
  964. #endif
  965.   sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
  966. }
  967. #endif
  968. /*
  969. ** This function registered all of the above C functions as SQL
  970. ** functions.  This should be the only routine in this file with
  971. ** external linkage.
  972. */
  973. void sqlite3RegisterDateTimeFunctions(sqlite3 *db){
  974. #ifndef SQLITE_OMIT_DATETIME_FUNCS
  975.   static const struct {
  976.      char *zName;
  977.      int nArg;
  978.      void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
  979.   } aFuncs[] = {
  980.     { "julianday", -1, juliandayFunc   },
  981.     { "date",      -1, dateFunc        },
  982.     { "time",      -1, timeFunc        },
  983.     { "datetime",  -1, datetimeFunc    },
  984.     { "strftime",  -1, strftimeFunc    },
  985.     { "current_time",       0, ctimeFunc      },
  986.     { "current_timestamp",  0, ctimestampFunc },
  987.     { "current_date",       0, cdateFunc      },
  988.   };
  989.   int i;
  990.   for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
  991.     sqlite3CreateFunc(db, aFuncs[i].zName, aFuncs[i].nArg,
  992.         SQLITE_UTF8, 0, aFuncs[i].xFunc, 0, 0);
  993.   }
  994. #else
  995.   static const struct {
  996.      char *zName;
  997.      char *zFormat;
  998.   } aFuncs[] = {
  999.     { "current_time", "%H:%M:%S" },
  1000.     { "current_date", "%Y-%m-%d" },
  1001.     { "current_timestamp", "%Y-%m-%d %H:%M:%S" }
  1002.   };
  1003.   int i;
  1004.   for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
  1005.     sqlite3CreateFunc(db, aFuncs[i].zName, 0, SQLITE_UTF8, 
  1006.         aFuncs[i].zFormat, currentTimeFunc, 0, 0);
  1007.   }
  1008. #endif
  1009. }