ttime.c 26.3 KB
Newer Older
H
hzcheng 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
 *
 * This program is free software: you can use, redistribute, and/or modify
 * it under the terms of the GNU Affero General Public License, version 3
 * or later ("AGPL"), as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

16
#ifdef DARWIN
H
hzcheng 已提交
17
#define _XOPEN_SOURCE
18 19 20 21
#else
#define _XOPEN_SOURCE 500
#endif

S
common  
Shengliang Guan 已提交
22
#define _BSD_SOURCE
S
slguan 已提交
23
#define _DEFAULT_SOURCE
S
Shengliang Guan 已提交
24
#include "ttime.h"
S
Shengliang Guan 已提交
25

L
lihui 已提交
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
/*
 * mktime64 - Converts date to seconds.
 * Converts Gregorian date to seconds since 1970-01-01 00:00:00.
 * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
 *
 * [For the Julian calendar (which was used in Russia before 1917,
 * Britain & colonies before 1752, anywhere else before 1582,
 * and is still in use by some communities) leave out the
 * -year/100+year/400 terms, and add 10.]
 *
 * This algorithm was first published by Gauss (I think).
 *
 * A leap second can be indicated by calling this function with sec as
 * 60 (allowable under ISO 8601).  The leap second is treated the same
 * as the following second since they don't exist in UNIX time.
 *
 * An encoding of midnight at the end of the day as 24:00:00 - ie. midnight
 * tomorrow - (allowable under ISO 8601) is supported.
 */
S
Shengliang Guan 已提交
46 47 48
static int64_t user_mktime64(const uint32_t year0, const uint32_t mon0, const uint32_t day, const uint32_t hour,
                             const uint32_t min, const uint32_t sec, int64_t time_zone) {
  uint32_t mon = mon0, year = year0;
L
lihui 已提交
49

H
Haojun Liao 已提交
50
  /* 1..12 -> 11,12,1..10 */
S
Shengliang Guan 已提交
51 52
  if (0 >= (int32_t)(mon -= 2)) {
    mon += 12; /* Puts Feb last since it has leap day */
H
Haojun Liao 已提交
53 54
    year -= 1;
  }
L
lihui 已提交
55

S
Shengliang Guan 已提交
56 57
  // int64_t res = (((((int64_t) (year/4 - year/100 + year/400 + 367*mon/12 + day) +
  //                year*365 - 719499)*24 + hour)*60 + min)*60 + sec);
H
Hui Li 已提交
58
  int64_t res;
S
Shengliang Guan 已提交
59 60 61 62
  res = 367 * ((int64_t)mon) / 12;
  res += year / 4 - year / 100 + year / 400 + day + ((int64_t)year) * 365 - 719499;
  res = res * 24;
  res = ((res + hour) * 60 + min) * 60 + sec;
L
lihui 已提交
63

64
  return (res + time_zone);
L
lihui 已提交
65
}
66

L
lihui 已提交
67 68
// ==== mktime() kernel code =================//
static int64_t m_deltaUtc = 0;
S
Shengliang Guan 已提交
69
void           deltaToUtcInitOnce() {
H
Hongze Cheng 已提交
70
            struct tm tm = {0};
71

H
Hongze Cheng 已提交
72 73 74
            (void)taosStrpTime("1970-01-01 00:00:00", (const char*)("%Y-%m-%d %H:%M:%S"), &tm);
            m_deltaUtc = (int64_t)taosMktime(&tm);
            // printf("====delta:%lld\n\n", seconds);
L
lihui 已提交
75 76
}

H
hzcheng 已提交
77
static int64_t parseFraction(char* str, char** end, int32_t timePrec);
78
static int32_t parseTimeWithTz(const char* timestr, int64_t* time, int32_t timePrec, char delim);
79 80
static int32_t parseLocaltime(char* timestr, int32_t len, int64_t* utime, int32_t timePrec, char delim);
static int32_t parseLocaltimeDst(char* timestr, int32_t len, int64_t* utime, int32_t timePrec, char delim);
S
Shengliang Guan 已提交
81 82
static char*   forwardToTimeStringEnd(char* str);
static bool    checkTzPresent(const char* str, int32_t len);
dengyihao's avatar
dengyihao 已提交
83

H
Hongze Cheng 已提交
84 85
static int32_t (*parseLocaltimeFp[])(char* timestr, int32_t len, int64_t* utime, int32_t timePrec, char delim) = {
    parseLocaltime, parseLocaltimeDst};
H
hzcheng 已提交
86

87
int32_t taosParseTime(const char* timestr, int64_t* utime, int32_t len, int32_t timePrec, int8_t day_light) {
H
hzcheng 已提交
88
  /* parse datatime string in with tz */
S
slguan 已提交
89
  if (strnchr(timestr, 'T', len, false) != NULL) {
90 91 92 93 94
    if (checkTzPresent(timestr, len)) {
      return parseTimeWithTz(timestr, utime, timePrec, 'T');
    } else {
      return (*parseLocaltimeFp[day_light])((char*)timestr, len, utime, timePrec, 'T');
    }
H
hzcheng 已提交
95
  } else {
96 97 98 99 100
    if (checkTzPresent(timestr, len)) {
      return parseTimeWithTz(timestr, utime, timePrec, 0);
    } else {
      return (*parseLocaltimeFp[day_light])((char*)timestr, len, utime, timePrec, 0);
    }
H
hzcheng 已提交
101 102 103
  }
}

S
Shengliang Guan 已提交
104 105
bool checkTzPresent(const char* str, int32_t len) {
  char*   seg = forwardToTimeStringEnd((char*)str);
106 107
  int32_t seg_len = len - (int32_t)(seg - str);

S
Shengliang Guan 已提交
108 109 110
  char* c = &seg[seg_len - 1];
  for (int32_t i = 0; i < seg_len; ++i) {
    if (*c == 'Z' || *c == 'z' || *c == '+' || *c == '-') {
111 112 113 114 115
      return true;
    }
    c--;
  }

116
  return false;
117 118
}

H
hzcheng 已提交
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
char* forwardToTimeStringEnd(char* str) {
  int32_t i = 0;
  int32_t numOfSep = 0;

  while (str[i] != 0 && numOfSep < 2) {
    if (str[i++] == ':') {
      numOfSep++;
    }
  }

  while (str[i] >= '0' && str[i] <= '9') {
    i++;
  }

  return &str[i];
}

int64_t parseFraction(char* str, char** end, int32_t timePrec) {
  int32_t i = 0;
  int64_t fraction = 0;

  const int32_t MILLI_SEC_FRACTION_LEN = 3;
  const int32_t MICRO_SEC_FRACTION_LEN = 6;
142
  const int32_t NANO_SEC_FRACTION_LEN = 9;
H
hzcheng 已提交
143

144
  int32_t factor[9] = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000};
H
hzcheng 已提交
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
  int32_t times = 1;

  while (str[i] >= '0' && str[i] <= '9') {
    i++;
  }

  int32_t totalLen = i;
  if (totalLen <= 0) {
    return -1;
  }

  /* parse the fraction */
  if (timePrec == TSDB_TIME_PRECISION_MILLI) {
    /* only use the initial 3 bits */
    if (i >= MILLI_SEC_FRACTION_LEN) {
      i = MILLI_SEC_FRACTION_LEN;
    }

    times = MILLI_SEC_FRACTION_LEN - i;
164
  } else if (timePrec == TSDB_TIME_PRECISION_MICRO) {
H
hzcheng 已提交
165 166 167 168
    if (i >= MICRO_SEC_FRACTION_LEN) {
      i = MICRO_SEC_FRACTION_LEN;
    }
    times = MICRO_SEC_FRACTION_LEN - i;
169 170 171 172 173 174
  } else {
    assert(timePrec == TSDB_TIME_PRECISION_NANO);
    if (i >= NANO_SEC_FRACTION_LEN) {
      i = NANO_SEC_FRACTION_LEN;
    }
    times = NANO_SEC_FRACTION_LEN - i;
H
hzcheng 已提交
175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192
  }

  fraction = strnatoi(str, i) * factor[times];
  *end = str + totalLen;

  return fraction;
}

int32_t parseTimezone(char* str, int64_t* tzOffset) {
  int64_t hour = 0;

  int32_t i = 0;
  if (str[i] != '+' && str[i] != '-') {
    return -1;
  }

  i++;

D
dapan1121 已提交
193 194 195 196
  int32_t j = i;
  while (str[j]) {
    if ((str[j] >= '0' && str[j] <= '9') || str[j] == ':') {
      ++j;
D
dapan1121 已提交
197 198 199 200 201 202
      continue;
    }

    return -1;
  }

H
hzcheng 已提交
203 204
  char* sep = strchr(&str[i], ':');
  if (sep != NULL) {
S
slguan 已提交
205
    int32_t len = (int32_t)(sep - &str[i]);
H
hzcheng 已提交
206 207 208 209 210 211 212 213

    hour = strnatoi(&str[i], len);
    i += len + 1;
  } else {
    hour = strnatoi(&str[i], 2);
    i += 2;
  }

S
Shengliang Guan 已提交
214 215
  // return error if there're illegal charaters after min(2 Digits)
  char* minStr = &str[i];
216
  if (minStr[1] != '\0' && minStr[2] != '\0') {
S
Shengliang Guan 已提交
217
    return -1;
218 219
  }

weixin_48148422's avatar
weixin_48148422 已提交
220 221
  int64_t minute = strnatoi(&str[i], 2);
  if (minute > 59) {
H
hzcheng 已提交
222 223 224 225
    return -1;
  }

  if (str[0] == '+') {
weixin_48148422's avatar
weixin_48148422 已提交
226
    *tzOffset = -(hour * 3600 + minute * 60);
H
hzcheng 已提交
227
  } else {
weixin_48148422's avatar
weixin_48148422 已提交
228
    *tzOffset = hour * 3600 + minute * 60;
H
hzcheng 已提交
229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
  }

  return 0;
}

/*
 * rfc3339 format:
 * 2013-04-12T15:52:01+08:00
 * 2013-04-12T15:52:01.123+08:00
 *
 * 2013-04-12T15:52:01Z
 * 2013-04-12T15:52:01.123Z
 *
 * iso-8601 format:
 * 2013-04-12T15:52:01+0800
 * 2013-04-12T15:52:01.123+0800
 */
246
int32_t parseTimeWithTz(const char* timestr, int64_t* time, int32_t timePrec, char delim) {
247
  int64_t factor = TSDB_TICK_PER_SECOND(timePrec);
H
hzcheng 已提交
248 249 250
  int64_t tzOffset = 0;

  struct tm tm = {0};
251 252 253

  char* str;
  if (delim == 'T') {
wafwerar's avatar
wafwerar 已提交
254
    str = taosStrpTime(timestr, "%Y-%m-%dT%H:%M:%S", &tm);
255
  } else if (delim == 0) {
wafwerar's avatar
wafwerar 已提交
256
    str = taosStrpTime(timestr, "%Y-%m-%d %H:%M:%S", &tm);
257 258 259 260
  } else {
    str = NULL;
  }

H
hzcheng 已提交
261 262 263 264
  if (str == NULL) {
    return -1;
  }

S
slguan 已提交
265 266
/* mktime will be affected by TZ, set by using taos_options */
#ifdef WINDOWS
S
Shengliang Guan 已提交
267 268
  int64_t seconds = user_mktime64(tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, 0);
  // int64_t seconds = gmtime(&tm);
S
slguan 已提交
269
#else
H
hzcheng 已提交
270
  int64_t seconds = timegm(&tm);
S
slguan 已提交
271
#endif
H
hzcheng 已提交
272 273

  int64_t fraction = 0;
S
Shengliang Guan 已提交
274
  str = forwardToTimeStringEnd((char*)timestr);
H
hzcheng 已提交
275

276
  if ((str[0] == 'Z' || str[0] == 'z') && str[1] == '\0') {
H
hzcheng 已提交
277 278 279 280 281 282 283 284 285 286 287 288 289
    /* utc time, no millisecond, return directly*/
    *time = seconds * factor;
  } else if (str[0] == '.') {
    str += 1;
    if ((fraction = parseFraction(str, &str, timePrec)) < 0) {
      return -1;
    }

    *time = seconds * factor + fraction;

    char seg = str[0];
    if (seg != 'Z' && seg != 'z' && seg != '+' && seg != '-') {
      return -1;
290 291
    } else if ((seg == 'Z' || seg == 'z') && str[1] != '\0') {
      return -1;
H
hzcheng 已提交
292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
    } else if (seg == '+' || seg == '-') {
      // parse the timezone
      if (parseTimezone(str, &tzOffset) == -1) {
        return -1;
      }

      *time += tzOffset * factor;
    }

  } else if (str[0] == '+' || str[0] == '-') {
    *time = seconds * factor + fraction;

    // parse the timezone
    if (parseTimezone(str, &tzOffset) == -1) {
      return -1;
    }

    *time += tzOffset * factor;
  } else {
    return -1;
  }

  return 0;
}

317 318 319 320 321 322 323 324 325
static FORCE_INLINE bool validateTm(struct tm* pTm) {
  if (pTm == NULL) {
    return false;
  }

  int32_t dayOfMonth[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

  int32_t leapYearMonthDay = 29;
  int32_t year = pTm->tm_year + 1900;
H
Hongze Cheng 已提交
326
  bool    isLeapYear = ((year % 100) == 0) ? ((year % 400) == 0) : ((year % 4) == 0);
327 328 329 330 331 332 333 334 335 336 337

  if (isLeapYear && (pTm->tm_mon == 1)) {
    if (pTm->tm_mday > leapYearMonthDay) {
      return false;
    }
  } else {
    if (pTm->tm_mday > dayOfMonth[pTm->tm_mon]) {
      return false;
    }
  }

H
Hongze Cheng 已提交
338
  return true;
339 340
}

341 342
int32_t parseLocaltime(char* timestr, int32_t len, int64_t* utime, int32_t timePrec, char delim) {
  *utime = 0;
H
hzcheng 已提交
343 344
  struct tm tm = {0};

H
Hongze Cheng 已提交
345
  char* str;
346 347 348 349 350 351 352 353
  if (delim == 'T') {
    str = taosStrpTime(timestr, "%Y-%m-%dT%H:%M:%S", &tm);
  } else if (delim == 0) {
    str = taosStrpTime(timestr, "%Y-%m-%d %H:%M:%S", &tm);
  } else {
    str = NULL;
  }

354
  if (str == NULL || (((str - timestr) < len) && (*str != '.')) || !validateTm(&tm)) {
H
Hongze Cheng 已提交
355
    // if parse failed, try "%Y-%m-%d" format
356 357 358 359
    str = taosStrpTime(timestr, "%Y-%m-%d", &tm);
    if (str == NULL || (((str - timestr) < len) && (*str != '.')) || !validateTm(&tm)) {
      return -1;
    }
H
hzcheng 已提交
360 361
  }

362 363 364 365 366 367
#ifdef _MSC_VER
#if _MSC_VER >= 1900
  int64_t timezone = _timezone;
#endif
#endif

S
Shengliang Guan 已提交
368 369 370
  int64_t seconds =
      user_mktime64(tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, timezone);

H
hzcheng 已提交
371 372 373 374 375 376 377 378 379
  int64_t fraction = 0;

  if (*str == '.') {
    /* parse the second fraction part */
    if ((fraction = parseFraction(str + 1, &str, timePrec)) < 0) {
      return -1;
    }
  }

380
  *utime = TSDB_TICK_PER_SECOND(timePrec) * seconds + fraction;
H
hzcheng 已提交
381 382 383
  return 0;
}

384 385
int32_t parseLocaltimeDst(char* timestr, int32_t len, int64_t* utime, int32_t timePrec, char delim) {
  *utime = 0;
dengyihao's avatar
dengyihao 已提交
386 387 388
  struct tm tm = {0};
  tm.tm_isdst = -1;

H
Hongze Cheng 已提交
389
  char* str;
390 391 392 393 394 395 396 397
  if (delim == 'T') {
    str = taosStrpTime(timestr, "%Y-%m-%dT%H:%M:%S", &tm);
  } else if (delim == 0) {
    str = taosStrpTime(timestr, "%Y-%m-%d %H:%M:%S", &tm);
  } else {
    str = NULL;
  }

398
  if (str == NULL || (((str - timestr) < len) && (*str != '.')) || !validateTm(&tm)) {
H
Hongze Cheng 已提交
399
    // if parse failed, try "%Y-%m-%d" format
400 401 402 403
    str = taosStrpTime(timestr, "%Y-%m-%d", &tm);
    if (str == NULL || (((str - timestr) < len) && (*str != '.')) || !validateTm(&tm)) {
      return -1;
    }
dengyihao's avatar
dengyihao 已提交
404 405 406
  }

  /* mktime will be affected by TZ, set by using taos_options */
407
  int64_t seconds = taosMktime(&tm);
S
Shengliang Guan 已提交
408

dengyihao's avatar
dengyihao 已提交
409 410 411 412 413 414 415 416
  int64_t fraction = 0;
  if (*str == '.') {
    /* parse the second fraction part */
    if ((fraction = parseFraction(str + 1, &str, timePrec)) < 0) {
      return -1;
    }
  }

417
  *utime = TSDB_TICK_PER_SECOND(timePrec) * seconds + fraction;
dengyihao's avatar
dengyihao 已提交
418 419
  return 0;
}
B
Bomin Zhang 已提交
420

D
dapan1121 已提交
421 422 423 424 425 426 427 428 429 430 431 432
char getPrecisionUnit(int32_t precision) {
  static char units[3] = {TIME_UNIT_MILLISECOND, TIME_UNIT_MICROSECOND, TIME_UNIT_NANOSECOND};
  switch (precision) {
    case TSDB_TIME_PRECISION_MILLI:
    case TSDB_TIME_PRECISION_MICRO:
    case TSDB_TIME_PRECISION_NANO:
      return units[precision];
    default:
      return 0;
  }
}

433 434
int64_t convertTimePrecision(int64_t utime, int32_t fromPrecision, int32_t toPrecision) {
  ASSERT(fromPrecision == TSDB_TIME_PRECISION_MILLI || fromPrecision == TSDB_TIME_PRECISION_MICRO ||
435
         fromPrecision == TSDB_TIME_PRECISION_NANO);
436
  ASSERT(toPrecision == TSDB_TIME_PRECISION_MILLI || toPrecision == TSDB_TIME_PRECISION_MICRO ||
437
         toPrecision == TSDB_TIME_PRECISION_NANO);
438 439 440

  double tempResult = (double)utime;

H
Hongze Cheng 已提交
441
  switch (fromPrecision) {
442 443 444
    case TSDB_TIME_PRECISION_MILLI: {
      switch (toPrecision) {
        case TSDB_TIME_PRECISION_MILLI:
445
          return utime;
446 447
        case TSDB_TIME_PRECISION_MICRO:
          tempResult *= 1000;
448
          utime *= 1000;
449 450 451
          goto end_;
        case TSDB_TIME_PRECISION_NANO:
          tempResult *= 1000000;
452
          utime *= 1000000;
453 454
          goto end_;
      }
H
Hongze Cheng 已提交
455
    }  // end from milli
456 457 458
    case TSDB_TIME_PRECISION_MICRO: {
      switch (toPrecision) {
        case TSDB_TIME_PRECISION_MILLI:
459
          return utime / 1000;
460
        case TSDB_TIME_PRECISION_MICRO:
461
          return utime;
462 463
        case TSDB_TIME_PRECISION_NANO:
          tempResult *= 1000;
464
          utime *= 1000;
465 466
          goto end_;
      }
H
Hongze Cheng 已提交
467
    }  // end from micro
468 469 470
    case TSDB_TIME_PRECISION_NANO: {
      switch (toPrecision) {
        case TSDB_TIME_PRECISION_MILLI:
471
          return utime / 1000000;
472
        case TSDB_TIME_PRECISION_MICRO:
473
          return utime / 1000;
474
        case TSDB_TIME_PRECISION_NANO:
475
          return utime;
476
      }
H
Hongze Cheng 已提交
477
    }  // end from nano
478 479
    default: {
      assert(0);
480
      return utime;  // only to pass windows compilation
481
    }
H
Hongze Cheng 已提交
482
  }  // end switch fromPrecision
483

484 485 486
end_:
  if (tempResult >= (double)INT64_MAX) return INT64_MAX;
  if (tempResult <= (double)INT64_MIN) return INT64_MIN;  // INT64_MIN means NULL
487
  return utime;
488
}
489

H
Hongze Cheng 已提交
490 491 492
// !!!!notice:there are precision problems, double lose precison if time is too large, for example:
// 1626006833631000000*1.0 = double = 1626006833631000064
// int64_t convertTimePrecision(int64_t time, int32_t fromPrecision, int32_t toPrecision) {
493 494 495 496 497 498 499 500
//  assert(fromPrecision == TSDB_TIME_PRECISION_MILLI || fromPrecision == TSDB_TIME_PRECISION_MICRO ||
//         fromPrecision == TSDB_TIME_PRECISION_NANO);
//  assert(toPrecision == TSDB_TIME_PRECISION_MILLI || toPrecision == TSDB_TIME_PRECISION_MICRO ||
//         toPrecision == TSDB_TIME_PRECISION_NANO);
//  static double factors[3][3] = {{1., 1000., 1000000.}, {1.0 / 1000, 1., 1000.}, {1.0 / 1000000, 1.0 / 1000, 1.}};
//  ((double)time * factors[fromPrecision][toPrecision]);
//}

H
Hongze Cheng 已提交
501 502
// !!!!notice: double lose precison if time is too large, for example: 1626006833631000000*1.0 = double =
// 1626006833631000064
D
dapan1121 已提交
503 504 505
int64_t convertTimeFromPrecisionToUnit(int64_t time, int32_t fromPrecision, char toUnit) {
  assert(fromPrecision == TSDB_TIME_PRECISION_MILLI || fromPrecision == TSDB_TIME_PRECISION_MICRO ||
         fromPrecision == TSDB_TIME_PRECISION_NANO);
506
  int64_t factors[3] = {NANOSECOND_PER_MSEC, NANOSECOND_PER_USEC, 1};
H
Hongze Cheng 已提交
507
  double  tmp = time;
D
dapan1121 已提交
508
  switch (toUnit) {
H
Hongze Cheng 已提交
509 510 511
    case 's': {
      tmp /= (NANOSECOND_PER_SEC / factors[fromPrecision]);  // the result of division is an integer
      time /= (NANOSECOND_PER_SEC / factors[fromPrecision]);
512 513
      break;
    }
D
dapan1121 已提交
514
    case 'm':
H
Hongze Cheng 已提交
515 516
      tmp /= (NANOSECOND_PER_MINUTE / factors[fromPrecision]);  // the result of division is an integer
      time /= (NANOSECOND_PER_MINUTE / factors[fromPrecision]);
517
      break;
D
dapan1121 已提交
518
    case 'h':
H
Hongze Cheng 已提交
519 520
      tmp /= (NANOSECOND_PER_HOUR / factors[fromPrecision]);  // the result of division is an integer
      time /= (NANOSECOND_PER_HOUR / factors[fromPrecision]);
521
      break;
D
dapan1121 已提交
522
    case 'd':
H
Hongze Cheng 已提交
523 524
      tmp /= (NANOSECOND_PER_DAY / factors[fromPrecision]);  // the result of division is an integer
      time /= (NANOSECOND_PER_DAY / factors[fromPrecision]);
525
      break;
D
dapan1121 已提交
526
    case 'w':
H
Hongze Cheng 已提交
527 528
      tmp /= (NANOSECOND_PER_WEEK / factors[fromPrecision]);  // the result of division is an integer
      time /= (NANOSECOND_PER_WEEK / factors[fromPrecision]);
529
      break;
D
dapan1121 已提交
530
    case 'a':
H
Hongze Cheng 已提交
531 532
      tmp /= (NANOSECOND_PER_MSEC / factors[fromPrecision]);  // the result of division is an integer
      time /= (NANOSECOND_PER_MSEC / factors[fromPrecision]);
533
      break;
D
dapan1121 已提交
534
    case 'u':
535 536
      // the result of (NANOSECOND_PER_USEC/(double)factors[fromPrecision]) maybe a double
      switch (fromPrecision) {
H
Hongze Cheng 已提交
537
        case TSDB_TIME_PRECISION_MILLI: {
538 539
          tmp *= 1000;
          time *= 1000;
540 541
          break;
        }
H
Hongze Cheng 已提交
542
        case TSDB_TIME_PRECISION_MICRO: {
543 544 545 546
          tmp /= 1;
          time /= 1;
          break;
        }
H
Hongze Cheng 已提交
547
        case TSDB_TIME_PRECISION_NANO: {
548 549
          tmp /= 1000;
          time /= 1000;
550 551 552 553
          break;
        }
      }
      break;
D
dapan1121 已提交
554
    case 'b':
555 556 557
      tmp *= factors[fromPrecision];
      time *= factors[fromPrecision];
      break;
D
dapan1121 已提交
558 559 560
    default: {
      return -1;
    }
561
  }
562 563 564
  if (tmp >= (double)INT64_MAX) return INT64_MAX;
  if (tmp <= (double)INT64_MIN) return INT64_MIN;
  return time;
565 566
}

H
Hongze Cheng 已提交
567
int32_t convertStringToTimestamp(int16_t type, char* inputData, int64_t timePrec, int64_t* timeVal) {
568
  int32_t charLen = varDataLen(inputData);
H
Hongze Cheng 已提交
569
  char*   newColData;
X
Xiaoyu Wang 已提交
570
  if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_VARBINARY) {
H
Hongze Cheng 已提交
571
    newColData = taosMemoryCalloc(1, charLen + 1);
572
    memcpy(newColData, varDataVal(inputData), charLen);
D
dapan1121 已提交
573
    int32_t ret = taosParseTime(newColData, timeVal, charLen, (int32_t)timePrec, tsDaylight);
574 575
    if (ret != TSDB_CODE_SUCCESS) {
      taosMemoryFree(newColData);
D
dapan1121 已提交
576
      return TSDB_CODE_INVALID_TIMESTAMP;
577
    }
578 579
    taosMemoryFree(newColData);
  } else if (type == TSDB_DATA_TYPE_NCHAR) {
H
Hongze Cheng 已提交
580 581 582
    newColData = taosMemoryCalloc(1, charLen + TSDB_NCHAR_SIZE);
    int len = taosUcs4ToMbs((TdUcs4*)varDataVal(inputData), charLen, newColData);
    if (len < 0) {
583 584 585 586
      taosMemoryFree(newColData);
      return TSDB_CODE_FAILED;
    }
    newColData[len] = 0;
587
    int32_t ret = taosParseTime(newColData, timeVal, len, (int32_t)timePrec, tsDaylight);
588 589 590 591
    if (ret != TSDB_CODE_SUCCESS) {
      taosMemoryFree(newColData);
      return ret;
    }
592 593 594 595 596
    taosMemoryFree(newColData);
  } else {
    return TSDB_CODE_FAILED;
  }
  return TSDB_CODE_SUCCESS;
D
dapan1121 已提交
597 598
}

599
static int32_t getDuration(int64_t val, char unit, int64_t* result, int32_t timePrecision) {
H
hzcheng 已提交
600 601
  switch (unit) {
    case 's':
602
      (*result) = convertTimePrecision(val * MILLISECOND_PER_SECOND, TSDB_TIME_PRECISION_MILLI, timePrecision);
H
hzcheng 已提交
603 604
      break;
    case 'm':
605
      (*result) = convertTimePrecision(val * MILLISECOND_PER_MINUTE, TSDB_TIME_PRECISION_MILLI, timePrecision);
H
hzcheng 已提交
606 607
      break;
    case 'h':
608
      (*result) = convertTimePrecision(val * MILLISECOND_PER_HOUR, TSDB_TIME_PRECISION_MILLI, timePrecision);
H
hzcheng 已提交
609 610
      break;
    case 'd':
611
      (*result) = convertTimePrecision(val * MILLISECOND_PER_DAY, TSDB_TIME_PRECISION_MILLI, timePrecision);
H
hzcheng 已提交
612 613
      break;
    case 'w':
614
      (*result) = convertTimePrecision(val * MILLISECOND_PER_WEEK, TSDB_TIME_PRECISION_MILLI, timePrecision);
H
hzcheng 已提交
615 616
      break;
    case 'a':
617
      (*result) = convertTimePrecision(val, TSDB_TIME_PRECISION_MILLI, timePrecision);
H
Haojun Liao 已提交
618 619
      break;
    case 'u':
620 621 622 623
      (*result) = convertTimePrecision(val, TSDB_TIME_PRECISION_MICRO, timePrecision);
      break;
    case 'b':
      (*result) = convertTimePrecision(val, TSDB_TIME_PRECISION_NANO, timePrecision);
H
hzcheng 已提交
624 625 626 627 628 629 630 631 632
      break;
    default: {
      return -1;
    }
  }
  return 0;
}

/*
633 634 635 636
 * n - months
 * y - Years
 * is not allowed, since the duration of month or year are both variable.
 *
637 638
 * b - nanoseconds;
 * u - microseconds;
H
hzcheng 已提交
639 640 641 642 643 644 645
 * a - Millionseconds
 * s - Seconds
 * m - Minutes
 * h - Hours
 * d - Days (24 hours)
 * w - Weeks (7 days)
 */
S
Shengliang Guan 已提交
646 647
int32_t parseAbsoluteDuration(const char* token, int32_t tokenlen, int64_t* duration, char* unit,
                              int32_t timePrecision) {
H
hzcheng 已提交
648 649 650 651
  errno = 0;
  char* endPtr = NULL;

  /* get the basic numeric value */
wafwerar's avatar
wafwerar 已提交
652
  int64_t timestamp = taosStr2Int64(token, &endPtr, 10);
H
hzcheng 已提交
653 654 655 656
  if (errno != 0) {
    return -1;
  }

657
  /* natual month/year are not allowed in absolute duration */
658 659
  *unit = token[tokenlen - 1];
  if (*unit == 'n' || *unit == 'y') {
660 661 662
    return -1;
  }

663
  return getDuration(timestamp, *unit, duration, timePrecision);
H
hzcheng 已提交
664
}
665

666
int32_t parseNatualDuration(const char* token, int32_t tokenLen, int64_t* duration, char* unit, int32_t timePrecision) {
B
Bomin Zhang 已提交
667 668 669
  errno = 0;

  /* get the basic numeric value */
wafwerar's avatar
wafwerar 已提交
670
  *duration = taosStr2Int64(token, NULL, 10);
B
Bomin Zhang 已提交
671 672 673 674 675 676 677 678 679
  if (errno != 0) {
    return -1;
  }

  *unit = token[tokenLen - 1];
  if (*unit == 'n' || *unit == 'y') {
    return 0;
  }

680
  return getDuration(*duration, *unit, duration, timePrecision);
B
Bomin Zhang 已提交
681 682
}

683 684 685 686
int64_t taosTimeAdd(int64_t t, int64_t duration, char unit, int32_t precision) {
  if (duration == 0) {
    return t;
  }
H
Haojun Liao 已提交
687 688

  if (unit != 'n' && unit != 'y') {
689 690 691
    return t + duration;
  }

H
Haojun Liao 已提交
692 693 694 695 696 697
  // The following code handles the y/n time duration
  int64_t numOfMonth = duration;
  if (unit == 'y') {
    numOfMonth *= 12;
  }

698 699
  int64_t fraction = t % TSDB_TICK_PER_SECOND(precision);

700
  struct tm tm;
S
Shengliang Guan 已提交
701
  time_t    tt = (time_t)(t / TSDB_TICK_PER_SECOND(precision));
wafwerar's avatar
wafwerar 已提交
702
  taosLocalTime(&tt, &tm);
H
Haojun Liao 已提交
703
  int32_t mon = tm.tm_year * 12 + tm.tm_mon + (int32_t)numOfMonth;
704 705 706
  tm.tm_year = mon / 12;
  tm.tm_mon = mon % 12;

707
  return (int64_t)(taosMktime(&tm) * TSDB_TICK_PER_SECOND(precision) + fraction);
B
Bomin Zhang 已提交
708 709 710 711 712 713 714
}

int32_t taosTimeCountInterval(int64_t skey, int64_t ekey, int64_t interval, char unit, int32_t precision) {
  if (ekey < skey) {
    int64_t tmp = ekey;
    ekey = skey;
    skey = tmp;
715
  }
B
Bomin Zhang 已提交
716 717 718 719
  if (unit != 'n' && unit != 'y') {
    return (int32_t)((ekey - skey) / interval);
  }

S
Shengliang Guan 已提交
720 721
  skey /= (int64_t)(TSDB_TICK_PER_SECOND(precision));
  ekey /= (int64_t)(TSDB_TICK_PER_SECOND(precision));
722

B
Bomin Zhang 已提交
723
  struct tm tm;
S
Shengliang Guan 已提交
724
  time_t    t = (time_t)skey;
wafwerar's avatar
wafwerar 已提交
725
  taosLocalTime(&t, &tm);
S
Shengliang Guan 已提交
726
  int32_t smon = tm.tm_year * 12 + tm.tm_mon;
B
Bomin Zhang 已提交
727 728

  t = (time_t)ekey;
wafwerar's avatar
wafwerar 已提交
729
  taosLocalTime(&t, &tm);
S
Shengliang Guan 已提交
730
  int32_t emon = tm.tm_year * 12 + tm.tm_mon;
B
Bomin Zhang 已提交
731 732 733 734 735 736

  if (unit == 'y') {
    interval *= 12;
  }

  return (emon - smon) / (int32_t)interval;
737 738 739 740 741 742 743 744 745
}

int64_t taosTimeTruncate(int64_t t, const SInterval* pInterval, int32_t precision) {
  if (pInterval->sliding == 0) {
    assert(pInterval->interval == 0);
    return t;
  }

  int64_t start = t;
B
Bomin Zhang 已提交
746
  if (pInterval->slidingUnit == 'n' || pInterval->slidingUnit == 'y') {
S
Shengliang Guan 已提交
747
    start /= (int64_t)(TSDB_TICK_PER_SECOND(precision));
748
    struct tm tm;
S
Shengliang Guan 已提交
749
    time_t    tt = (time_t)start;
wafwerar's avatar
wafwerar 已提交
750
    taosLocalTime(&tt, &tm);
751 752 753 754 755 756 757
    tm.tm_sec = 0;
    tm.tm_min = 0;
    tm.tm_hour = 0;
    tm.tm_mday = 1;

    if (pInterval->slidingUnit == 'y') {
      tm.tm_mon = 0;
S
Shengliang Guan 已提交
758
      tm.tm_year = (int32_t)(tm.tm_year / pInterval->sliding * pInterval->sliding);
759
    } else {
S
Shengliang Guan 已提交
760 761
      int32_t mon = tm.tm_year * 12 + tm.tm_mon;
      mon = (int32_t)(mon / pInterval->sliding * pInterval->sliding);
762 763 764 765
      tm.tm_year = mon / 12;
      tm.tm_mon = mon % 12;
    }

766
    start = (int64_t)(taosMktime(&tm) * TSDB_TICK_PER_SECOND(precision));
767 768
  } else {
    int64_t delta = t - pInterval->interval;
H
Haojun Liao 已提交
769
    int32_t factor = (delta >= 0) ? 1 : -1;
770 771 772 773

    start = (delta / pInterval->sliding + factor) * pInterval->sliding;

    if (pInterval->intervalUnit == 'd' || pInterval->intervalUnit == 'w') {
S
Shengliang Guan 已提交
774 775 776 777
      /*
       * here we revised the start time of day according to the local time zone,
       * but in case of DST, the start time of one day need to be dynamically decided.
       */
778
      // todo refactor to extract function that is available for Linux/Windows/Mac platform
S
Shengliang Guan 已提交
779
#if defined(WINDOWS) && _MSC_VER >= 1900
780 781 782 783
      // see https://docs.microsoft.com/en-us/cpp/c-runtime-library/daylight-dstbias-timezone-and-tzname?view=vs-2019
      int64_t timezone = _timezone;
      int32_t daylight = _daylight;
      char**  tzname = _tzname;
S
Shengliang Guan 已提交
784
#endif
785

S
Shengliang Guan 已提交
786
      start += (int64_t)(timezone * TSDB_TICK_PER_SECOND(precision));
787 788
    }

H
Haojun Liao 已提交
789 790 791
    int64_t end = 0;

    // not enough time range
D
fix bug  
dapan1121 已提交
792
    if (start < 0 || INT64_MAX - start > pInterval->interval - 1) {
793
      end = taosTimeAdd(start, pInterval->interval, pInterval->intervalUnit, precision) - 1;
G
Ganlin Zhao 已提交
794
      while (end < t) {  // move forward to the correct time window
H
Haojun Liao 已提交
795 796
        start += pInterval->sliding;

D
fix bug  
dapan1121 已提交
797
        if (start < 0 || INT64_MAX - start > pInterval->interval - 1) {
H
Haojun Liao 已提交
798 799 800 801 802 803 804 805
          end = start + pInterval->interval - 1;
        } else {
          end = INT64_MAX;
          break;
        }
      }
    } else {
      end = INT64_MAX;
806 807 808
    }
  }

H
Haojun Liao 已提交
809 810
  ASSERT(pInterval->offset >= 0);

B
Bomin Zhang 已提交
811 812
  if (pInterval->offset > 0) {
    start = taosTimeAdd(start, pInterval->offset, pInterval->offsetUnit, precision);
813

H
Haojun Liao 已提交
814 815
    // try to move current window to the left-hande-side, due to the offset effect.
    int64_t end = taosTimeAdd(start, pInterval->interval, pInterval->intervalUnit, precision) - 1;
816

H
Haojun Liao 已提交
817 818 819 820
    int64_t newEnd = end;
    while (newEnd >= t) {
      end = newEnd;
      newEnd = taosTimeAdd(newEnd, -pInterval->sliding, pInterval->slidingUnit, precision);
B
Bomin Zhang 已提交
821
    }
H
Haojun Liao 已提交
822 823

    start = taosTimeAdd(end, -pInterval->interval, pInterval->intervalUnit, precision) + 1;
B
Bomin Zhang 已提交
824
  }
H
Haojun Liao 已提交
825

B
Bomin Zhang 已提交
826
  return start;
827 828
}

829 830 831 832 833 834 835 836
// internal function, when program is paused in debugger,
// one can call this function from debugger to print a
// timestamp as human readable string, for example (gdb):
//     p fmtts(1593769722)
// outputs:
//     2020-07-03 17:48:42
// and the parameter can also be a variable.
const char* fmtts(int64_t ts) {
C
Cary Xu 已提交
837
  static char buf[96] = {0};
S
Shengliang Guan 已提交
838 839
  size_t      pos = 0;
  struct tm   tm;
840 841

  if (ts > -62135625943 && ts < 32503651200) {
B
Bomin Zhang 已提交
842
    time_t t = (time_t)ts;
wafwerar's avatar
wafwerar 已提交
843
    taosLocalTime(&t, &tm);
B
Bomin Zhang 已提交
844
    pos += strftime(buf + pos, sizeof(buf), "s=%Y-%m-%d %H:%M:%S", &tm);
845 846
  }

B
Bomin Zhang 已提交
847 848
  if (ts > -62135625943000 && ts < 32503651200000) {
    time_t t = (time_t)(ts / 1000);
wafwerar's avatar
wafwerar 已提交
849
    taosLocalTime(&t, &tm);
B
Bomin Zhang 已提交
850 851 852 853 854 855
    if (pos > 0) {
      buf[pos++] = ' ';
      buf[pos++] = '|';
      buf[pos++] = ' ';
    }
    pos += strftime(buf + pos, sizeof(buf), "ms=%Y-%m-%d %H:%M:%S", &tm);
S
Shengliang Guan 已提交
856
    pos += sprintf(buf + pos, ".%03d", (int32_t)(ts % 1000));
B
Bomin Zhang 已提交
857
  }
858

B
Bomin Zhang 已提交
859 860
  {
    time_t t = (time_t)(ts / 1000000);
wafwerar's avatar
wafwerar 已提交
861
    taosLocalTime(&t, &tm);
B
Bomin Zhang 已提交
862 863 864 865 866 867
    if (pos > 0) {
      buf[pos++] = ' ';
      buf[pos++] = '|';
      buf[pos++] = ' ';
    }
    pos += strftime(buf + pos, sizeof(buf), "us=%Y-%m-%d %H:%M:%S", &tm);
S
Shengliang Guan 已提交
868
    pos += sprintf(buf + pos, ".%06d", (int32_t)(ts % 1000000));
869 870 871
  }

  return buf;
872
}
873 874

void taosFormatUtcTime(char* buf, int32_t bufLen, int64_t t, int32_t precision) {
H
Hongze Cheng 已提交
875 876
  char      ts[40] = {0};
  struct tm ptm;
877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912

  int32_t fractionLen;
  char*   format = NULL;
  time_t  quot = 0;
  long    mod = 0;

  switch (precision) {
    case TSDB_TIME_PRECISION_MILLI: {
      quot = t / 1000;
      fractionLen = 5;
      format = ".%03" PRId64;
      mod = t % 1000;
      break;
    }

    case TSDB_TIME_PRECISION_MICRO: {
      quot = t / 1000000;
      fractionLen = 8;
      format = ".%06" PRId64;
      mod = t % 1000000;
      break;
    }

    case TSDB_TIME_PRECISION_NANO: {
      quot = t / 1000000000;
      fractionLen = 11;
      format = ".%09" PRId64;
      mod = t % 1000000000;
      break;
    }

    default:
      fractionLen = 0;
      assert(false);
  }

913 914
  taosLocalTime(&quot, &ptm);
  int32_t length = (int32_t)strftime(ts, 40, "%Y-%m-%dT%H:%M:%S", &ptm);
915
  length += snprintf(ts + length, fractionLen, format, mod);
916
  length += (int32_t)strftime(ts + length, 40 - length, "%z", &ptm);
917 918

  tstrncpy(buf, ts, bufLen);
D
dapan1121 已提交
919
}