ttime.c 26.7 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() {
L
lihui 已提交
70
  struct tm tm = {0};
71

wafwerar's avatar
wafwerar 已提交
72
  (void)taosStrpTime("1970-01-01 00:00:00", (const char*)("%Y-%m-%d %H:%M:%S"), &tm);
73
  m_deltaUtc = (int64_t)taosMktime(&tm);
S
Shengliang Guan 已提交
74
  // 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

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) {
S
Shengliang Guan 已提交
247 248
  int64_t factor =
      (timePrec == TSDB_TIME_PRECISION_MILLI) ? 1000 : (timePrec == TSDB_TIME_PRECISION_MICRO ? 1000000 : 1000000000);
H
hzcheng 已提交
249 250 251
  int64_t tzOffset = 0;

  struct tm tm = {0};
252 253 254

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

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

S
slguan 已提交
266 267
/* mktime will be affected by TZ, set by using taos_options */
#ifdef WINDOWS
S
Shengliang Guan 已提交
268 269
  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 已提交
270
#else
H
hzcheng 已提交
271
  int64_t seconds = timegm(&tm);
S
slguan 已提交
272
#endif
H
hzcheng 已提交
273 274

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

277
  if ((str[0] == 'Z' || str[0] == 'z') && str[1] == '\0') {
H
hzcheng 已提交
278 279 280 281 282 283 284 285 286 287 288 289 290
    /* 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;
291 292
    } else if ((seg == 'Z' || seg == 'z') && str[1] != '\0') {
      return -1;
H
hzcheng 已提交
293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317
    } 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;
}

318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
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;
  bool isLeapYear = ((year % 100) == 0)? ((year % 400) == 0):((year % 4) == 0);

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

  return  true;
}

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

346 347 348 349 350 351 352 353 354
  char *str;
  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;
  }

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

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

S
Shengliang Guan 已提交
369 370 371
  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 已提交
372 373 374 375 376 377 378 379 380
  int64_t fraction = 0;

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

S
Shengliang Guan 已提交
381 382
  int64_t factor =
      (timePrec == TSDB_TIME_PRECISION_MILLI) ? 1000 : (timePrec == TSDB_TIME_PRECISION_MICRO ? 1000000 : 1000000000);
H
hzcheng 已提交
383 384 385 386 387
  *time = factor * seconds + fraction;

  return 0;
}

388
int32_t parseLocaltimeDst(char* timestr, int32_t len, int64_t* time, int32_t timePrec, char delim) {
dengyihao's avatar
dengyihao 已提交
389 390 391 392
  *time = 0;
  struct tm tm = {0};
  tm.tm_isdst = -1;

393 394 395 396 397 398 399 400 401
  char *str;
  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;
  }

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

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

dengyihao's avatar
dengyihao 已提交
413 414 415 416 417 418 419 420 421
  int64_t fraction = 0;

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

S
Shengliang Guan 已提交
422 423
  int64_t factor =
      (timePrec == TSDB_TIME_PRECISION_MILLI) ? 1000 : (timePrec == TSDB_TIME_PRECISION_MICRO ? 1000000 : 1000000000);
dengyihao's avatar
dengyihao 已提交
424 425 426
  *time = factor * seconds + fraction;
  return 0;
}
B
Bomin Zhang 已提交
427

D
dapan1121 已提交
428 429 430 431 432 433 434 435 436 437 438 439
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;
  }
}

440
int64_t convertTimePrecision(int64_t time, int32_t fromPrecision, int32_t toPrecision) {
441 442
  assert(fromPrecision == TSDB_TIME_PRECISION_MILLI ||
         fromPrecision == TSDB_TIME_PRECISION_MICRO ||
443
         fromPrecision == TSDB_TIME_PRECISION_NANO);
444 445
  assert(toPrecision == TSDB_TIME_PRECISION_MILLI ||
         toPrecision == TSDB_TIME_PRECISION_MICRO ||
446
         toPrecision == TSDB_TIME_PRECISION_NANO);
447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493
  double tempResult = (double)time;
  switch(fromPrecision) {
    case TSDB_TIME_PRECISION_MILLI: {
      switch (toPrecision) {
        case TSDB_TIME_PRECISION_MILLI:
          return time;
        case TSDB_TIME_PRECISION_MICRO:
          tempResult *= 1000;
          time *= 1000;
          goto end_;
        case TSDB_TIME_PRECISION_NANO:
          tempResult *= 1000000;
          time *= 1000000;
          goto end_;
      }
    } // end from milli
    case TSDB_TIME_PRECISION_MICRO: {
      switch (toPrecision) {
        case TSDB_TIME_PRECISION_MILLI:
          return time / 1000;
        case TSDB_TIME_PRECISION_MICRO:
          return time;
        case TSDB_TIME_PRECISION_NANO:
          tempResult *= 1000;
          time *= 1000;
          goto end_;
      }
    } //end from micro
    case TSDB_TIME_PRECISION_NANO: {
      switch (toPrecision) {
        case TSDB_TIME_PRECISION_MILLI:
          return time / 1000000;
        case TSDB_TIME_PRECISION_MICRO:
          return time / 1000;
        case TSDB_TIME_PRECISION_NANO:
          return time;
      }
    } //end from nano
    default: {
      assert(0);
      return time;  // only to pass windows compilation
    }
  } //end switch fromPrecision
end_:
  if (tempResult >= (double)INT64_MAX) return INT64_MAX;
  if (tempResult <= (double)INT64_MIN) return INT64_MIN;  // INT64_MIN means NULL
  return time;
494
}
495

496 497 498 499 500 501 502 503 504 505
// !!!!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) {
//  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]);
//}

506 507

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

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

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

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

  /* get the basic numeric value */
wafwerar's avatar
wafwerar 已提交
657
  int64_t timestamp = taosStr2Int64(token, &endPtr, 10);
H
hzcheng 已提交
658 659 660 661
  if (errno != 0) {
    return -1;
  }

662
  /* natual month/year are not allowed in absolute duration */
663 664
  *unit = token[tokenlen - 1];
  if (*unit == 'n' || *unit == 'y') {
665 666 667
    return -1;
  }

668
  return getDuration(timestamp, *unit, duration, timePrecision);
H
hzcheng 已提交
669
}
670

671
int32_t parseNatualDuration(const char* token, int32_t tokenLen, int64_t* duration, char* unit, int32_t timePrecision) {
B
Bomin Zhang 已提交
672 673 674
  errno = 0;

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

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

685
  return getDuration(*duration, *unit, duration, timePrecision);
B
Bomin Zhang 已提交
686 687
}

688 689 690 691
int64_t taosTimeAdd(int64_t t, int64_t duration, char unit, int32_t precision) {
  if (duration == 0) {
    return t;
  }
H
Haojun Liao 已提交
692 693

  if (unit != 'n' && unit != 'y') {
694 695 696
    return t + duration;
  }

H
Haojun Liao 已提交
697 698 699 700 701 702
  // The following code handles the y/n time duration
  int64_t numOfMonth = duration;
  if (unit == 'y') {
    numOfMonth *= 12;
  }

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

710
  return (int64_t)(taosMktime(&tm) * TSDB_TICK_PER_SECOND(precision));
B
Bomin Zhang 已提交
711 712 713 714 715 716 717
}

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;
718
  }
B
Bomin Zhang 已提交
719 720 721 722
  if (unit != 'n' && unit != 'y') {
    return (int32_t)((ekey - skey) / interval);
  }

S
Shengliang Guan 已提交
723 724
  skey /= (int64_t)(TSDB_TICK_PER_SECOND(precision));
  ekey /= (int64_t)(TSDB_TICK_PER_SECOND(precision));
725

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

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

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

  return (emon - smon) / (int32_t)interval;
740 741 742 743 744 745 746 747 748
}

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 已提交
749
  if (pInterval->slidingUnit == 'n' || pInterval->slidingUnit == 'y') {
S
Shengliang Guan 已提交
750
    start /= (int64_t)(TSDB_TICK_PER_SECOND(precision));
751
    struct tm tm;
S
Shengliang Guan 已提交
752
    time_t    tt = (time_t)start;
wafwerar's avatar
wafwerar 已提交
753
    taosLocalTime(&tt, &tm);
754 755 756 757 758 759 760
    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 已提交
761
      tm.tm_year = (int32_t)(tm.tm_year / pInterval->sliding * pInterval->sliding);
762
    } else {
S
Shengliang Guan 已提交
763 764
      int32_t mon = tm.tm_year * 12 + tm.tm_mon;
      mon = (int32_t)(mon / pInterval->sliding * pInterval->sliding);
765 766 767 768
      tm.tm_year = mon / 12;
      tm.tm_mon = mon % 12;
    }

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

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

    if (pInterval->intervalUnit == 'd' || pInterval->intervalUnit == 'w') {
S
Shengliang Guan 已提交
777 778 779 780
      /*
       * 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.
       */
781
      // todo refactor to extract function that is available for Linux/Windows/Mac platform
S
Shengliang Guan 已提交
782
#if defined(WINDOWS) && _MSC_VER >= 1900
783 784 785 786
      // 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 已提交
787
#endif
788

S
Shengliang Guan 已提交
789
      start += (int64_t)(timezone * TSDB_TICK_PER_SECOND(precision));
790 791
    }

H
Haojun Liao 已提交
792 793 794
    int64_t end = 0;

    // not enough time range
D
fix bug  
dapan1121 已提交
795
    if (start < 0 || INT64_MAX - start > pInterval->interval - 1) {
796
      end = taosTimeAdd(start, pInterval->interval, pInterval->intervalUnit, precision) - 1;
S
Shengliang Guan 已提交
797
      while (end < t && ((start + pInterval->sliding) <= INT64_MAX)) {  // move forward to the correct time window
H
Haojun Liao 已提交
798 799
        start += pInterval->sliding;

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

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

B
Bomin Zhang 已提交
814 815 816 817
  if (pInterval->offset > 0) {
    start = taosTimeAdd(start, pInterval->offset, pInterval->offsetUnit, precision);
    if (start > t) {
      start = taosTimeAdd(start, -pInterval->interval, pInterval->intervalUnit, precision);
H
Haojun Liao 已提交
818 819
    } else {
      // try to move current window to the left-hande-side, due to the offset effect.
H
Haojun Liao 已提交
820
      int64_t end = taosTimeAdd(start, pInterval->interval, pInterval->intervalUnit, precision) - 1;
H
Haojun Liao 已提交
821 822 823 824 825
      ASSERT(end >= t);
      end = taosTimeAdd(end, -pInterval->sliding, pInterval->slidingUnit, precision);
      if (end >= t) {
        start = taosTimeAdd(start, -pInterval->sliding, pInterval->slidingUnit, precision);
      }
B
Bomin Zhang 已提交
826 827
    }
  }
H
Haojun Liao 已提交
828

B
Bomin Zhang 已提交
829
  return start;
830 831
}

832 833 834 835 836 837 838 839
// 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 已提交
840
  static char buf[96] = {0};
S
Shengliang Guan 已提交
841 842
  size_t      pos = 0;
  struct tm   tm;
843 844

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

B
Bomin Zhang 已提交
850 851
  if (ts > -62135625943000 && ts < 32503651200000) {
    time_t t = (time_t)(ts / 1000);
wafwerar's avatar
wafwerar 已提交
852
    taosLocalTime(&t, &tm);
B
Bomin Zhang 已提交
853 854 855 856 857 858
    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 已提交
859
    pos += sprintf(buf + pos, ".%03d", (int32_t)(ts % 1000));
B
Bomin Zhang 已提交
860
  }
861

B
Bomin Zhang 已提交
862 863
  {
    time_t t = (time_t)(ts / 1000000);
wafwerar's avatar
wafwerar 已提交
864
    taosLocalTime(&t, &tm);
B
Bomin Zhang 已提交
865 866 867 868 869 870
    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 已提交
871
    pos += sprintf(buf + pos, ".%06d", (int32_t)(ts % 1000000));
872 873 874
  }

  return buf;
875
}
876 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 913 914 915

void taosFormatUtcTime(char* buf, int32_t bufLen, int64_t t, int32_t precision) {
  char       ts[40] = {0};
  struct tm* ptm;

  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);
  }

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

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