ttime.c 17.5 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

S
Shengliang Guan 已提交
72
  (void)strptime("1970-01-01 00:00:00", (const char*)("%Y-%m-%d %H:%M:%S"), &tm);
L
lihui 已提交
73
  m_deltaUtc = (int64_t)mktime(&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);
H
hzcheng 已提交
79
static int32_t parseLocaltime(char* timestr, int64_t* time, int32_t timePrec);
80
static int32_t parseLocaltimeDst(char* timestr, int64_t* time, int32_t timePrec);
S
Shengliang Guan 已提交
81 82
static char*   forwardToTimeStringEnd(char* str);
static bool    checkTzPresent(const char* str, int32_t len);
dengyihao's avatar
dengyihao 已提交
83

S
Shengliang Guan 已提交
84 85
static int32_t (*parseLocaltimeFp[])(char* timestr, int64_t* time, int32_t timePrec) = {parseLocaltime,
                                                                                        parseLocaltimeDst};
H
hzcheng 已提交
86

87
int32_t taosParseTime(const char* timestr, int64_t* time, 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
    return parseTimeWithTz(timestr, time, timePrec, 'T');
91 92
  } else if (checkTzPresent(timestr, len)) {
    return parseTimeWithTz(timestr, time, timePrec, 0);
H
hzcheng 已提交
93
  } else {
S
Shengliang Guan 已提交
94
    return (*parseLocaltimeFp[day_light])((char*)timestr, time, timePrec);
H
hzcheng 已提交
95 96 97
  }
}

S
Shengliang Guan 已提交
98 99
bool checkTzPresent(const char* str, int32_t len) {
  char*   seg = forwardToTimeStringEnd((char*)str);
100 101
  int32_t seg_len = len - (int32_t)(seg - str);

S
Shengliang Guan 已提交
102 103 104
  char* c = &seg[seg_len - 1];
  for (int32_t i = 0; i < seg_len; ++i) {
    if (*c == 'Z' || *c == 'z' || *c == '+' || *c == '-') {
105 106 107 108 109
      return true;
    }
    c--;
  }

110
  return false;
111 112
}

H
hzcheng 已提交
113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
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;
136
  const int32_t NANO_SEC_FRACTION_LEN = 9;
H
hzcheng 已提交
137

138
  int32_t factor[9] = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000};
H
hzcheng 已提交
139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
  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;
158
  } else if (timePrec == TSDB_TIME_PRECISION_MICRO) {
H
hzcheng 已提交
159 160 161 162
    if (i >= MICRO_SEC_FRACTION_LEN) {
      i = MICRO_SEC_FRACTION_LEN;
    }
    times = MICRO_SEC_FRACTION_LEN - i;
163 164 165 166 167 168
  } 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 已提交
169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
  }

  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++;

  char* sep = strchr(&str[i], ':');
  if (sep != NULL) {
S
slguan 已提交
189
    int32_t len = (int32_t)(sep - &str[i]);
H
hzcheng 已提交
190 191 192 193 194 195 196 197

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

S
Shengliang Guan 已提交
198 199
  // return error if there're illegal charaters after min(2 Digits)
  char* minStr = &str[i];
200
  if (minStr[1] != '\0' && minStr[2] != '\0') {
S
Shengliang Guan 已提交
201
    return -1;
202 203
  }

weixin_48148422's avatar
weixin_48148422 已提交
204 205
  int64_t minute = strnatoi(&str[i], 2);
  if (minute > 59) {
H
hzcheng 已提交
206 207 208 209
    return -1;
  }

  if (str[0] == '+') {
weixin_48148422's avatar
weixin_48148422 已提交
210
    *tzOffset = -(hour * 3600 + minute * 60);
H
hzcheng 已提交
211
  } else {
weixin_48148422's avatar
weixin_48148422 已提交
212
    *tzOffset = hour * 3600 + minute * 60;
H
hzcheng 已提交
213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
  }

  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
 */
230
int32_t parseTimeWithTz(const char* timestr, int64_t* time, int32_t timePrec, char delim) {
S
Shengliang Guan 已提交
231 232
  int64_t factor =
      (timePrec == TSDB_TIME_PRECISION_MILLI) ? 1000 : (timePrec == TSDB_TIME_PRECISION_MICRO ? 1000000 : 1000000000);
H
hzcheng 已提交
233 234 235
  int64_t tzOffset = 0;

  struct tm tm = {0};
236 237 238 239

  char* str;
  if (delim == 'T') {
    str = strptime(timestr, "%Y-%m-%dT%H:%M:%S", &tm);
240 241
  } else if (delim == 0) {
    str = strptime(timestr, "%Y-%m-%d %H:%M:%S", &tm);
242 243 244 245
  } else {
    str = NULL;
  }

H
hzcheng 已提交
246 247 248 249
  if (str == NULL) {
    return -1;
  }

S
slguan 已提交
250 251
/* mktime will be affected by TZ, set by using taos_options */
#ifdef WINDOWS
S
Shengliang Guan 已提交
252 253
  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 已提交
254
#else
H
hzcheng 已提交
255
  int64_t seconds = timegm(&tm);
S
slguan 已提交
256
#endif
H
hzcheng 已提交
257 258

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

261
  if ((str[0] == 'Z' || str[0] == 'z') && str[1] == '\0') {
H
hzcheng 已提交
262 263 264 265 266 267 268 269 270 271 272 273 274
    /* 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;
275 276
    } else if ((seg == 'Z' || seg == 'z') && str[1] != '\0') {
      return -1;
H
hzcheng 已提交
277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310
    } 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;
}

int32_t parseLocaltime(char* timestr, int64_t* time, int32_t timePrec) {
  *time = 0;
  struct tm tm = {0};

  char* str = strptime(timestr, "%Y-%m-%d %H:%M:%S", &tm);
  if (str == NULL) {
    return -1;
  }

311 312 313 314 315 316
#ifdef _MSC_VER
#if _MSC_VER >= 1900
  int64_t timezone = _timezone;
#endif
#endif

S
Shengliang Guan 已提交
317 318 319
  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 已提交
320 321 322 323 324 325 326 327 328
  int64_t fraction = 0;

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

S
Shengliang Guan 已提交
329 330
  int64_t factor =
      (timePrec == TSDB_TIME_PRECISION_MILLI) ? 1000 : (timePrec == TSDB_TIME_PRECISION_MICRO ? 1000000 : 1000000000);
H
hzcheng 已提交
331 332 333 334 335
  *time = factor * seconds + fraction;

  return 0;
}

336
int32_t parseLocaltimeDst(char* timestr, int64_t* time, int32_t timePrec) {
dengyihao's avatar
dengyihao 已提交
337 338 339 340 341 342 343 344 345 346 347
  *time = 0;
  struct tm tm = {0};
  tm.tm_isdst = -1;

  char* str = strptime(timestr, "%Y-%m-%d %H:%M:%S", &tm);
  if (str == NULL) {
    return -1;
  }

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

dengyihao's avatar
dengyihao 已提交
349 350 351 352 353 354 355 356 357
  int64_t fraction = 0;

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

S
Shengliang Guan 已提交
358 359
  int64_t factor =
      (timePrec == TSDB_TIME_PRECISION_MILLI) ? 1000 : (timePrec == TSDB_TIME_PRECISION_MICRO ? 1000000 : 1000000000);
dengyihao's avatar
dengyihao 已提交
360 361 362
  *time = factor * seconds + fraction;
  return 0;
}
B
Bomin Zhang 已提交
363

364
int64_t convertTimePrecision(int64_t time, int32_t fromPrecision, int32_t toPrecision) {
S
Shengliang Guan 已提交
365
  assert(fromPrecision == TSDB_TIME_PRECISION_MILLI || fromPrecision == TSDB_TIME_PRECISION_MICRO ||
366
         fromPrecision == TSDB_TIME_PRECISION_NANO);
S
Shengliang Guan 已提交
367
  assert(toPrecision == TSDB_TIME_PRECISION_MILLI || toPrecision == TSDB_TIME_PRECISION_MICRO ||
368
         toPrecision == TSDB_TIME_PRECISION_NANO);
S
Shengliang Guan 已提交
369
  static double factors[3][3] = {{1., 1000., 1000000.}, {1.0 / 1000, 1., 1000.}, {1.0 / 1000000, 1.0 / 1000, 1.}};
370 371
  return (int64_t)((double)time * factors[fromPrecision][toPrecision]);
}
372

373
static int32_t getDuration(int64_t val, char unit, int64_t* result, int32_t timePrecision) {
H
hzcheng 已提交
374 375
  switch (unit) {
    case 's':
376
      (*result) = convertTimePrecision(val * MILLISECOND_PER_SECOND, TSDB_TIME_PRECISION_MILLI, timePrecision);
H
hzcheng 已提交
377 378
      break;
    case 'm':
379
      (*result) = convertTimePrecision(val * MILLISECOND_PER_MINUTE, TSDB_TIME_PRECISION_MILLI, timePrecision);
H
hzcheng 已提交
380 381
      break;
    case 'h':
382
      (*result) = convertTimePrecision(val * MILLISECOND_PER_HOUR, TSDB_TIME_PRECISION_MILLI, timePrecision);
H
hzcheng 已提交
383 384
      break;
    case 'd':
385
      (*result) = convertTimePrecision(val * MILLISECOND_PER_DAY, TSDB_TIME_PRECISION_MILLI, timePrecision);
H
hzcheng 已提交
386 387
      break;
    case 'w':
388
      (*result) = convertTimePrecision(val * MILLISECOND_PER_WEEK, TSDB_TIME_PRECISION_MILLI, timePrecision);
H
hzcheng 已提交
389 390
      break;
    case 'a':
391
      (*result) = convertTimePrecision(val, TSDB_TIME_PRECISION_MILLI, timePrecision);
H
Haojun Liao 已提交
392 393
      break;
    case 'u':
394 395 396 397
      (*result) = convertTimePrecision(val, TSDB_TIME_PRECISION_MICRO, timePrecision);
      break;
    case 'b':
      (*result) = convertTimePrecision(val, TSDB_TIME_PRECISION_NANO, timePrecision);
H
hzcheng 已提交
398 399 400 401 402 403 404 405 406
      break;
    default: {
      return -1;
    }
  }
  return 0;
}

/*
407 408 409 410
 * n - months
 * y - Years
 * is not allowed, since the duration of month or year are both variable.
 *
411 412
 * b - nanoseconds;
 * u - microseconds;
H
hzcheng 已提交
413 414 415 416 417 418 419
 * a - Millionseconds
 * s - Seconds
 * m - Minutes
 * h - Hours
 * d - Days (24 hours)
 * w - Weeks (7 days)
 */
S
Shengliang Guan 已提交
420 421
int32_t parseAbsoluteDuration(const char* token, int32_t tokenlen, int64_t* duration, char* unit,
                              int32_t timePrecision) {
H
hzcheng 已提交
422 423 424 425 426 427 428 429 430
  errno = 0;
  char* endPtr = NULL;

  /* get the basic numeric value */
  int64_t timestamp = strtoll(token, &endPtr, 10);
  if (errno != 0) {
    return -1;
  }

431
  /* natual month/year are not allowed in absolute duration */
432 433
  *unit = token[tokenlen - 1];
  if (*unit == 'n' || *unit == 'y') {
434 435 436
    return -1;
  }

437
  return getDuration(timestamp, *unit, duration, timePrecision);
H
hzcheng 已提交
438
}
439

440
int32_t parseNatualDuration(const char* token, int32_t tokenLen, int64_t* duration, char* unit, int32_t timePrecision) {
B
Bomin Zhang 已提交
441 442 443 444 445 446 447 448 449 450 451 452 453
  errno = 0;

  /* get the basic numeric value */
  *duration = strtoll(token, NULL, 10);
  if (errno != 0) {
    return -1;
  }

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

454
  return getDuration(*duration, *unit, duration, timePrecision);
B
Bomin Zhang 已提交
455 456
}

457 458 459 460 461 462 463 464 465 466 467
int64_t taosTimeAdd(int64_t t, int64_t duration, char unit, int32_t precision) {
  if (duration == 0) {
    return t;
  }
  if (unit == 'y') {
    duration *= 12;
  } else if (unit != 'n') {
    return t + duration;
  }

  struct tm tm;
S
Shengliang Guan 已提交
468
  time_t    tt = (time_t)(t / TSDB_TICK_PER_SECOND(precision));
469
  localtime_r(&tt, &tm);
S
Shengliang Guan 已提交
470
  int32_t mon = tm.tm_year * 12 + tm.tm_mon + (int32_t)duration;
471 472 473
  tm.tm_year = mon / 12;
  tm.tm_mon = mon % 12;

S
Shengliang Guan 已提交
474
  return (int64_t)(mktime(&tm) * TSDB_TICK_PER_SECOND(precision));
B
Bomin Zhang 已提交
475 476 477 478 479 480 481
}

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;
482
  }
B
Bomin Zhang 已提交
483 484 485 486
  if (unit != 'n' && unit != 'y') {
    return (int32_t)((ekey - skey) / interval);
  }

S
Shengliang Guan 已提交
487 488
  skey /= (int64_t)(TSDB_TICK_PER_SECOND(precision));
  ekey /= (int64_t)(TSDB_TICK_PER_SECOND(precision));
489

B
Bomin Zhang 已提交
490
  struct tm tm;
S
Shengliang Guan 已提交
491
  time_t    t = (time_t)skey;
B
Bomin Zhang 已提交
492
  localtime_r(&t, &tm);
S
Shengliang Guan 已提交
493
  int32_t smon = tm.tm_year * 12 + tm.tm_mon;
B
Bomin Zhang 已提交
494 495 496

  t = (time_t)ekey;
  localtime_r(&t, &tm);
S
Shengliang Guan 已提交
497
  int32_t emon = tm.tm_year * 12 + tm.tm_mon;
B
Bomin Zhang 已提交
498 499 500 501 502 503

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

  return (emon - smon) / (int32_t)interval;
504 505 506 507 508 509 510 511 512
}

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 已提交
513
  if (pInterval->slidingUnit == 'n' || pInterval->slidingUnit == 'y') {
S
Shengliang Guan 已提交
514
    start /= (int64_t)(TSDB_TICK_PER_SECOND(precision));
515
    struct tm tm;
S
Shengliang Guan 已提交
516
    time_t    tt = (time_t)start;
B
Bomin Zhang 已提交
517
    localtime_r(&tt, &tm);
518 519 520 521 522 523 524
    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 已提交
525
      tm.tm_year = (int32_t)(tm.tm_year / pInterval->sliding * pInterval->sliding);
526
    } else {
S
Shengliang Guan 已提交
527 528
      int32_t mon = tm.tm_year * 12 + tm.tm_mon;
      mon = (int32_t)(mon / pInterval->sliding * pInterval->sliding);
529 530 531 532
      tm.tm_year = mon / 12;
      tm.tm_mon = mon % 12;
    }

S
Shengliang Guan 已提交
533
    start = (int64_t)(mktime(&tm) * TSDB_TICK_PER_SECOND(precision));
534 535
  } else {
    int64_t delta = t - pInterval->interval;
H
Haojun Liao 已提交
536
    int32_t factor = (delta >= 0) ? 1 : -1;
537 538 539 540

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

    if (pInterval->intervalUnit == 'd' || pInterval->intervalUnit == 'w') {
S
Shengliang Guan 已提交
541 542 543 544
      /*
       * 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.
       */
545
      // todo refactor to extract function that is available for Linux/Windows/Mac platform
S
Shengliang Guan 已提交
546
#if defined(WINDOWS) && _MSC_VER >= 1900
547 548 549 550
      // 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 已提交
551
#endif
552

S
Shengliang Guan 已提交
553
      start += (int64_t)(timezone * TSDB_TICK_PER_SECOND(precision));
554 555
    }

H
Haojun Liao 已提交
556 557 558
    int64_t end = 0;

    // not enough time range
D
fix bug  
dapan1121 已提交
559
    if (start < 0 || INT64_MAX - start > pInterval->interval - 1) {
560
      end = start + pInterval->interval - 1;
H
Haojun Liao 已提交
561

S
Shengliang Guan 已提交
562
      while (end < t && ((start + pInterval->sliding) <= INT64_MAX)) {  // move forward to the correct time window
H
Haojun Liao 已提交
563 564
        start += pInterval->sliding;

D
fix bug  
dapan1121 已提交
565
        if (start < 0 || INT64_MAX - start > pInterval->interval - 1) {
H
Haojun Liao 已提交
566 567 568 569 570 571 572 573
          end = start + pInterval->interval - 1;
        } else {
          end = INT64_MAX;
          break;
        }
      }
    } else {
      end = INT64_MAX;
574 575 576
    }
  }

B
Bomin Zhang 已提交
577 578 579 580 581 582 583
  if (pInterval->offset > 0) {
    start = taosTimeAdd(start, pInterval->offset, pInterval->offsetUnit, precision);
    if (start > t) {
      start = taosTimeAdd(start, -pInterval->interval, pInterval->intervalUnit, precision);
    }
  }
  return start;
584 585
}

586 587 588 589 590 591 592 593
// 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) {
B
Bomin Zhang 已提交
594
  static char buf[96];
S
Shengliang Guan 已提交
595 596
  size_t      pos = 0;
  struct tm   tm;
597 598

  if (ts > -62135625943 && ts < 32503651200) {
B
Bomin Zhang 已提交
599 600 601
    time_t t = (time_t)ts;
    localtime_r(&t, &tm);
    pos += strftime(buf + pos, sizeof(buf), "s=%Y-%m-%d %H:%M:%S", &tm);
602 603
  }

B
Bomin Zhang 已提交
604 605 606 607 608 609 610 611 612
  if (ts > -62135625943000 && ts < 32503651200000) {
    time_t t = (time_t)(ts / 1000);
    localtime_r(&t, &tm);
    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 已提交
613
    pos += sprintf(buf + pos, ".%03d", (int32_t)(ts % 1000));
B
Bomin Zhang 已提交
614
  }
615

B
Bomin Zhang 已提交
616 617 618 619 620 621 622 623 624
  {
    time_t t = (time_t)(ts / 1000000);
    localtime_r(&t, &tm);
    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 已提交
625
    pos += sprintf(buf + pos, ".%06d", (int32_t)(ts % 1000000));
626 627 628
  }

  return buf;
629
}