Merge pull request #26676 from taosdata/feat/TD-30991-3.0

feat: (errcode) ttime.c geomFunc.c geosWrapper.c

include/common/ttime.h

@@ -86,11 +86,11 @@ void    deltaToUtcInitOnce();
 char    getPrecisionUnit(int32_t precision);
 
 int64_t convertTimePrecision(int64_t ts, int32_t fromPrecision, int32_t toPrecision);
-int64_t convertTimeFromPrecisionToUnit(int64_t ts, int32_t fromPrecision, char toUnit);
+int32_t convertTimeFromPrecisionToUnit(int64_t time, int32_t fromPrecision, char toUnit, int64_t* pRes);
 int32_t convertStringToTimestamp(int16_t type, char* inputData, int64_t timePrec, int64_t* timeVal);
 int32_t getDuration(int64_t val, char unit, int64_t* result, int32_t timePrecision);
 
-void taosFormatUtcTime(char* buf, int32_t bufLen, int64_t ts, int32_t precision);
+int32_t taosFormatUtcTime(char* buf, int32_t bufLen, int64_t ts, int32_t precision);
 
 struct STm {
   struct tm tm;

source/common/src/ttime.c

@@ -35,7 +35,7 @@ void deltaToUtcInitOnce() {
   // printf("====delta:%lld\n\n", seconds);
 }
 
-static int64_t parseFraction(char* str, char** end, int32_t timePrec);
+static int32_t parseFraction(char* str, char** end, int32_t timePrec, int64_t* pFraction);
 static int32_t parseTimeWithTz(const char* timestr, int64_t* time, int32_t timePrec, char delim);
 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);
@@ -95,7 +95,9 @@ char* forwardToTimeStringEnd(char* str) {
   return &str[i];
 }
 
-int64_t parseFraction(char* str, char** end, int32_t timePrec) {
+int32_t parseFraction(char* str, char** end, int32_t timePrec, int64_t* pFraction) {
+  int32_t code = TSDB_CODE_SUCCESS;
+
   int32_t i = 0;
   int64_t fraction = 0;
 
@@ -112,7 +114,7 @@ int64_t parseFraction(char* str, char** end, int32_t timePrec) {
 
   int32_t totalLen = i;
   if (totalLen <= 0) {
-    return -1;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
   }
 
   /* parse the fraction */
@@ -134,21 +136,24 @@ int64_t parseFraction(char* str, char** end, int32_t timePrec) {
     }
     times = NANO_SEC_FRACTION_LEN - i;
   } else {
-    return -1;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
   }
 
   fraction = strnatoi(str, i) * factor[times];
   *end = str + totalLen;
+  *pFraction = fraction;
 
-  return fraction;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t parseTimezone(char* str, int64_t* tzOffset) {
+  int32_t code = TSDB_CODE_SUCCESS;
+
   int64_t hour = 0;
 
   int32_t i = 0;
   if (str[i] != '+' && str[i] != '-') {
-    return -1;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
   }
 
   i++;
@@ -160,7 +165,7 @@ int32_t parseTimezone(char* str, int64_t* tzOffset) {
       continue;
     }
 
-    return -1;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
   }
 
   char* sep = strchr(&str[i], ':');
@@ -175,18 +180,18 @@ int32_t parseTimezone(char* str, int64_t* tzOffset) {
   }
 
   if (hour > 12 || hour < 0) {
-    return -1;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
   }
 
   // return error if there're illegal charaters after min(2 Digits)
   char* minStr = &str[i];
   if (minStr[1] != '\0' && minStr[2] != '\0') {
-    return -1;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
   }
 
   int64_t minute = strnatoi(&str[i], 2);
   if (minute > 59 || (hour == 12 && minute > 0)) {
-    return -1;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
   }
 
   if (str[0] == '+') {
@@ -195,13 +200,13 @@ int32_t parseTimezone(char* str, int64_t* tzOffset) {
     *tzOffset = hour * 3600 + minute * 60;
   }
 
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t offsetOfTimezone(char* tzStr, int64_t* offset) {
   if (tzStr && (tzStr[0] == 'z' || tzStr[0] == 'Z')) {
     *offset = 0;
-    return 0;
+    return TSDB_CODE_SUCCESS;
   }
   return parseTimezone(tzStr, offset);
 }
@@ -219,6 +224,8 @@ int32_t offsetOfTimezone(char* tzStr, int64_t* offset) {
  * 2013-04-12T15:52:01.123+0800
  */
 int32_t parseTimeWithTz(const char* timestr, int64_t* time, int32_t timePrec, char delim) {
+  int32_t code = TSDB_CODE_SUCCESS;
+
   int64_t factor = TSDB_TICK_PER_SECOND(timePrec);
   int64_t tzOffset = 0;
 
@@ -234,7 +241,7 @@ int32_t parseTimeWithTz(const char* timestr, int64_t* time, int32_t timePrec, ch
   }
 
   if (str == NULL) {
-    return -1;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
   }
 
 /* mktime will be affected by TZ, set by using taos_options */
@@ -253,22 +260,18 @@ int32_t parseTimeWithTz(const char* timestr, int64_t* time, int32_t timePrec, ch
     *time = seconds * factor;
   } else if (str[0] == '.') {
     str += 1;
-    if ((fraction = parseFraction(str, &str, timePrec)) < 0) {
+    TAOS_CHECK_RETURN(parseFraction(str, &str, timePrec, &fraction));
-      return -1;
-    }
 
     *time = seconds * factor + fraction;
 
     char seg = str[0];
     if (seg != 'Z' && seg != 'z' && seg != '+' && seg != '-') {
-      return -1;
+      TAOS_RETURN(TSDB_CODE_INVALID_PARA);
     } else if ((seg == 'Z' || seg == 'z') && str[1] != '\0') {
-      return -1;
+      TAOS_RETURN(TSDB_CODE_INVALID_PARA);
     } else if (seg == '+' || seg == '-') {
       // parse the timezone
-      if (parseTimezone(str, &tzOffset) == -1) {
+      TAOS_CHECK_RETURN(parseTimezone(str, &tzOffset));
-        return -1;
-      }
 
       *time += tzOffset * factor;
     }
@@ -277,16 +280,14 @@ int32_t parseTimeWithTz(const char* timestr, int64_t* time, int32_t timePrec, ch
     *time = seconds * factor + fraction;
 
     // parse the timezone
-    if (parseTimezone(str, &tzOffset) == -1) {
+    TAOS_CHECK_RETURN(parseTimezone(str, &tzOffset));
-      return -1;
-    }
 
     *time += tzOffset * factor;
   } else {
-    return -1;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
   }
 
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 static FORCE_INLINE bool validateTm(struct tm* pTm) {
@@ -314,6 +315,8 @@ static FORCE_INLINE bool validateTm(struct tm* pTm) {
 }
 
 int32_t parseLocaltime(char* timestr, int32_t len, int64_t* utime, int32_t timePrec, char delim) {
+  int32_t code = TSDB_CODE_SUCCESS;
+
   *utime = 0;
   struct tm tm = {0};
 
@@ -330,7 +333,7 @@ int32_t parseLocaltime(char* timestr, int32_t len, int64_t* utime, int32_t timeP
     // 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;
+      TAOS_RETURN(TSDB_CODE_INVALID_PARA);
     }
   }
 
@@ -347,16 +350,16 @@ int32_t parseLocaltime(char* timestr, int32_t len, int64_t* utime, int32_t timeP
 
   if (*str == '.') {
     /* parse the second fraction part */
-    if ((fraction = parseFraction(str + 1, &str, timePrec)) < 0) {
+    TAOS_CHECK_RETURN(parseFraction(str + 1, &str, timePrec, &fraction));
-      return -1;
-    }
   }
 
   *utime = TSDB_TICK_PER_SECOND(timePrec) * seconds + fraction;
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t parseLocaltimeDst(char* timestr, int32_t len, int64_t* utime, int32_t timePrec, char delim) {
+  int32_t code = TSDB_CODE_SUCCESS;
+
   *utime = 0;
   struct tm tm = {0};
   tm.tm_isdst = -1;
@@ -374,7 +377,7 @@ int32_t parseLocaltimeDst(char* timestr, int32_t len, int64_t* utime, int32_t ti
     // 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;
+      TAOS_RETURN(TSDB_CODE_INVALID_PARA);
     }
   }
 
@@ -384,13 +387,11 @@ int32_t parseLocaltimeDst(char* timestr, int32_t len, int64_t* utime, int32_t ti
   int64_t fraction = 0;
   if (*str == '.') {
     /* parse the second fraction part */
-    if ((fraction = parseFraction(str + 1, &str, timePrec)) < 0) {
+    TAOS_CHECK_RETURN(parseFraction(str + 1, &str, timePrec, &fraction));
-      return -1;
-    }
   }
 
   *utime = TSDB_TICK_PER_SECOND(timePrec) * seconds + fraction;
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 char getPrecisionUnit(int32_t precision) {
@@ -482,10 +483,12 @@ int64_t convertTimePrecision(int64_t utime, int32_t fromPrecision, int32_t toPre
 
 // !!!!notice: double lose precison if time is too large, for example: 1626006833631000000*1.0 = double =
 // 1626006833631000064
-int64_t convertTimeFromPrecisionToUnit(int64_t time, int32_t fromPrecision, char toUnit) {
+int32_t convertTimeFromPrecisionToUnit(int64_t time, int32_t fromPrecision, char toUnit, int64_t* pRes) {
+  int32_t code = TSDB_CODE_SUCCESS;
+
   if (fromPrecision != TSDB_TIME_PRECISION_MILLI && fromPrecision != TSDB_TIME_PRECISION_MICRO &&
       fromPrecision != TSDB_TIME_PRECISION_NANO) {
-    return -1;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
   }
 
   int64_t factors[3] = {NANOSECOND_PER_MSEC, NANOSECOND_PER_USEC, 1};
@@ -541,15 +544,23 @@ int64_t convertTimeFromPrecisionToUnit(int64_t time, int32_t fromPrecision, char
       time *= factors[fromPrecision];
       break;
     default: {
-      return -1;
+      TAOS_RETURN(TSDB_CODE_INVALID_PARA);
     }
   }
-  if (tmp >= (double)INT64_MAX) return INT64_MAX;
+  if (tmp >= (double)INT64_MAX) {
-  if (tmp <= (double)INT64_MIN) return INT64_MIN;
+    *pRes = INT64_MAX;
-  return time;
+  } else if (tmp <= (double)INT64_MIN) {
+    *pRes = INT64_MIN;
+  } else {
+    *pRes = time;
+  }
+
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t convertStringToTimestamp(int16_t type, char* inputData, int64_t timePrec, int64_t* timeVal) {
+  int32_t code = TSDB_CODE_SUCCESS;
+
   int32_t charLen = varDataLen(inputData);
   char*   newColData;
   if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_VARBINARY) {
@@ -558,7 +569,7 @@ int32_t convertStringToTimestamp(int16_t type, char* inputData, int64_t timePrec
     int32_t ret = taosParseTime(newColData, timeVal, charLen, (int32_t)timePrec, tsDaylight);
     if (ret != TSDB_CODE_SUCCESS) {
       taosMemoryFree(newColData);
-      return TSDB_CODE_INVALID_TIMESTAMP;
+      TAOS_RETURN(TSDB_CODE_INVALID_TIMESTAMP);
     }
     taosMemoryFree(newColData);
   } else if (type == TSDB_DATA_TYPE_NCHAR) {
@@ -566,50 +577,52 @@ int32_t convertStringToTimestamp(int16_t type, char* inputData, int64_t timePrec
     int len = taosUcs4ToMbs((TdUcs4*)varDataVal(inputData), charLen, newColData);
     if (len < 0) {
       taosMemoryFree(newColData);
-      return TSDB_CODE_FAILED;
+      TAOS_RETURN(TSDB_CODE_FAILED);
     }
     newColData[len] = 0;
     int32_t ret = taosParseTime(newColData, timeVal, len, (int32_t)timePrec, tsDaylight);
     if (ret != TSDB_CODE_SUCCESS) {
       taosMemoryFree(newColData);
-      return ret;
+      TAOS_RETURN(ret);
     }
     taosMemoryFree(newColData);
   } else {
-    return TSDB_CODE_FAILED;
+    TAOS_RETURN(TSDB_CODE_FAILED);
   }
-  return TSDB_CODE_SUCCESS;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t getDuration(int64_t val, char unit, int64_t* result, int32_t timePrecision) {
+  int32_t code = TSDB_CODE_SUCCESS;
+
   switch (unit) {
     case 's':
       if (val > INT64_MAX / MILLISECOND_PER_SECOND) {
-        return -1;
+        TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
       }
       (*result) = convertTimePrecision(val * MILLISECOND_PER_SECOND, TSDB_TIME_PRECISION_MILLI, timePrecision);
       break;
     case 'm':
       if (val > INT64_MAX / MILLISECOND_PER_MINUTE) {
-        return -1;
+        TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
       }
       (*result) = convertTimePrecision(val * MILLISECOND_PER_MINUTE, TSDB_TIME_PRECISION_MILLI, timePrecision);
       break;
     case 'h':
       if (val > INT64_MAX / MILLISECOND_PER_MINUTE) {
-        return -1;
+        TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
       }
       (*result) = convertTimePrecision(val * MILLISECOND_PER_HOUR, TSDB_TIME_PRECISION_MILLI, timePrecision);
       break;
     case 'd':
       if (val > INT64_MAX / MILLISECOND_PER_DAY) {
-        return -1;
+        TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
       }
       (*result) = convertTimePrecision(val * MILLISECOND_PER_DAY, TSDB_TIME_PRECISION_MILLI, timePrecision);
       break;
     case 'w':
       if (val > INT64_MAX / MILLISECOND_PER_WEEK) {
-        return -1;
+        TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
       }
       (*result) = convertTimePrecision(val * MILLISECOND_PER_WEEK, TSDB_TIME_PRECISION_MILLI, timePrecision);
       break;
@@ -623,10 +636,10 @@ int32_t getDuration(int64_t val, char unit, int64_t* result, int32_t timePrecisi
       (*result) = convertTimePrecision(val, TSDB_TIME_PRECISION_NANO, timePrecision);
       break;
     default: {
-      return -1;
+      TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
     }
   }
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 /*
@@ -645,36 +658,41 @@ int32_t getDuration(int64_t val, char unit, int64_t* result, int32_t timePrecisi
  */
 int32_t parseAbsoluteDuration(const char* token, int32_t tokenlen, int64_t* duration, char* unit,
                               int32_t timePrecision) {
+  int32_t code = TSDB_CODE_SUCCESS;
+
   errno = 0;
   char* endPtr = NULL;
 
   /* get the basic numeric value */
   int64_t timestamp = taosStr2Int64(token, &endPtr, 10);
   if ((timestamp == 0 && token[0] != '0') || errno != 0) {
-    return -1;
+    TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
   }
 
   /* natual month/year are not allowed in absolute duration */
   *unit = token[tokenlen - 1];
   if (*unit == 'n' || *unit == 'y') {
-    return -1;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
   }
 
   return getDuration(timestamp, *unit, duration, timePrecision);
 }
 
-int32_t parseNatualDuration(const char* token, int32_t tokenLen, int64_t* duration, char* unit, int32_t timePrecision, bool negativeAllow) {
+int32_t parseNatualDuration(const char* token, int32_t tokenLen, int64_t* duration, char* unit, int32_t timePrecision,
+                            bool negativeAllow) {
+  int32_t code = TSDB_CODE_SUCCESS;
+
   errno = 0;
 
   /* get the basic numeric value */
   *duration = taosStr2Int64(token, NULL, 10);
   if ((*duration < 0 && !negativeAllow) || errno != 0) {
-    return -1;
+    TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
   }
 
   *unit = token[tokenLen - 1];
   if (*unit == 'n' || *unit == 'y') {
-    return 0;
+    TAOS_RETURN(TSDB_CODE_SUCCESS);
   }
   if (isdigit(*unit)) {
     *unit = getPrecisionUnit(timePrecision);
@@ -683,9 +701,7 @@ int32_t parseNatualDuration(const char* token, int32_t tokenLen, int64_t* durati
   return getDuration(*duration, *unit, duration, timePrecision);
 }
 
-static bool taosIsLeapYear(int32_t year) {
+static bool taosIsLeapYear(int32_t year) { return (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)); }
-  return (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
-}
 
 int64_t taosTimeAdd(int64_t t, int64_t duration, char unit, int32_t precision) {
   if (duration == 0) {
@@ -900,7 +916,8 @@ int64_t taosTimeTruncate(int64_t ts, const SInterval* pInterval) {
 // used together with taosTimeTruncate. when offset is great than zero, slide-start/slide-end is the anchor point
 int64_t taosTimeGetIntervalEnd(int64_t intervalStart, const SInterval* pInterval) {
   if (pInterval->offset > 0) {
-    int64_t slideStart = taosTimeAdd(intervalStart, -1 * pInterval->offset, pInterval->offsetUnit, pInterval->precision);
+    int64_t slideStart =
+        taosTimeAdd(intervalStart, -1 * pInterval->offset, pInterval->offsetUnit, pInterval->precision);
     int64_t slideEnd = taosTimeAdd(slideStart, pInterval->interval, pInterval->intervalUnit, pInterval->precision) - 1;
     int64_t result = taosTimeAdd(slideEnd, pInterval->offset, pInterval->offsetUnit, pInterval->precision);
     return result;
@@ -960,7 +977,9 @@ const char* fmtts(int64_t ts) {
   return buf;
 }
 
-void taosFormatUtcTime(char* buf, int32_t bufLen, int64_t t, int32_t precision) {
+int32_t taosFormatUtcTime(char* buf, int32_t bufLen, int64_t t, int32_t precision) {
+  int32_t code = TSDB_CODE_SUCCESS;
+
   char      ts[40] = {0};
   struct tm ptm;
 
@@ -996,17 +1015,18 @@ void taosFormatUtcTime(char* buf, int32_t bufLen, int64_t t, int32_t precision)
 
     default:
       fractionLen = 0;
-      return;
+      TAOS_RETURN(TSDB_CODE_INVALID_PARA);
   }
 
   if (taosLocalTime(&quot, &ptm, buf) == NULL) {
-    return;
+    TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
   }
   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);
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t taosTs2Tm(int64_t ts, int32_t precision, struct STm* tm) {
@@ -1923,8 +1943,8 @@ int32_t taosTs2Char(const char* format, SArray** formats, int64_t ts, int32_t pr
   return tm2char(*formats, &tm, out, outLen);
 }
 
-int32_t taosChar2Ts(const char* format, SArray** formats, const char* tsStr, int64_t* ts, int32_t precision, char* errMsg,
+int32_t taosChar2Ts(const char* format, SArray** formats, const char* tsStr, int64_t* ts, int32_t precision,
-                    int32_t errMsgLen) {
+                    char* errMsg, int32_t errMsgLen) {
   const char* sErrPos;
   int32_t     fErrIdx;
   if (!*formats) {
@@ -1989,7 +2009,8 @@ static int64_t UNIT_MATRIX[10][11] = {     /*  ns,   us,   ms,    s,   min,   h,
                                       /*mon*/ {0, 0, 0, 0, 0, 0, 0, 0, 1, 12, 0},
                                       /*y*/ {0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 0}};
 
-static bool recursiveTsmaCheckRecursive(int64_t baseInterval, int8_t baseIdx, int64_t interval, int8_t idx, bool checkEq) {
+static bool recursiveTsmaCheckRecursive(int64_t baseInterval, int8_t baseIdx, int64_t interval, int8_t idx,
+                                        bool checkEq) {
   if (UNIT_MATRIX[baseIdx][idx] == -1) return false;
   if (baseIdx == idx) {
     if (interval < baseInterval) return false;
@@ -2021,7 +2042,8 @@ static bool recursiveTsmaCheckRecursive(int64_t baseInterval, int8_t baseIdx, in
   return false;
 }
 
-static bool recursiveTsmaCheckRecursiveReverse(int64_t baseInterval, int8_t baseIdx, int64_t interval, int8_t idx, bool checkEq) {
+static bool recursiveTsmaCheckRecursiveReverse(int64_t baseInterval, int8_t baseIdx, int64_t interval, int8_t idx,
+                                               bool checkEq) {
   if (UNIT_MATRIX[baseIdx][idx] == -1) return false;
 
   if (baseIdx == idx) {
@@ -2041,18 +2063,27 @@ static bool recursiveTsmaCheckRecursiveReverse(int64_t baseInterval, int8_t base
 /*
  * @breif check if tsma with param [interval], [unit] can create based on base tsma with baseInterval and baseUnit
  * @param baseInterval, baseUnit, interval/unit of base tsma
- * @param interval the tsma interval going to create. Not that if unit is not calander unit, then interval has already been
+ * @param interval the tsma interval going to create. Not that if unit is not calander unit, then interval has already
- * translated to TICKS of [precision]
+ * been translated to TICKS of [precision]
  * @param unit the tsma unit going to create
  * @param precision the precision of this db
  * @param checkEq pass true if same interval is not acceptable, false if acceptable.
  * @ret true the tsma can be created, else cannot
  * */
-bool checkRecursiveTsmaInterval(int64_t baseInterval, int8_t baseUnit, int64_t interval, int8_t unit, int8_t precision, bool checkEq) {
+bool checkRecursiveTsmaInterval(int64_t baseInterval, int8_t baseUnit, int64_t interval, int8_t unit, int8_t precision,
+                                bool checkEq) {
   bool baseIsCalendarDuration = IS_CALENDAR_TIME_DURATION(baseUnit);
-  if (!baseIsCalendarDuration) baseInterval = convertTimeFromPrecisionToUnit(baseInterval, precision, baseUnit);
+  if (!baseIsCalendarDuration) {
+    if (TSDB_CODE_SUCCESS != convertTimeFromPrecisionToUnit(baseInterval, precision, baseUnit, &baseInterval)) {
+      return false;
+    }
+  }
   bool isCalendarDuration = IS_CALENDAR_TIME_DURATION(unit);
-  if (!isCalendarDuration) interval = convertTimeFromPrecisionToUnit(interval, precision, unit);
+  if (!isCalendarDuration) {
+    if (TSDB_CODE_SUCCESS != convertTimeFromPrecisionToUnit(interval, precision, unit, &interval)) {
+      return false;
+    }
+  }
 
   bool needCheckEq = baseIsCalendarDuration == isCalendarDuration && checkEq;
 

source/dnode/mnode/impl/src/mndSma.c

@@ -616,7 +616,12 @@ static int32_t mndCreateSma(SMnode *pMnode, SRpcMsg *pReq, SMCreateSmaReq *pCrea
 
   // check the maxDelay
   if (streamObj.conf.triggerParam < TSDB_MIN_ROLLUP_MAX_DELAY) {
-    int64_t msInterval = convertTimeFromPrecisionToUnit(pCreate->interval, pDb->cfg.precision, TIME_UNIT_MILLISECOND);
+    int64_t msInterval = -1;
+    int32_t code = convertTimeFromPrecisionToUnit(pCreate->interval, pDb->cfg.precision, TIME_UNIT_MILLISECOND, &msInterval);
+    if (TSDB_CODE_SUCCESS != code) {
+      mError("sma:%s, failed to create since convert time failed: %s", smaObj.name, tstrerror(code));
+      return code;
+    }
     streamObj.conf.triggerParam = msInterval > TSDB_MIN_ROLLUP_MAX_DELAY ? msInterval : TSDB_MIN_ROLLUP_MAX_DELAY;
   }
   if (streamObj.conf.triggerParam > TSDB_MAX_ROLLUP_MAX_DELAY) {

source/dnode/vnode/src/sma/smaOpen.c

@@ -23,7 +23,9 @@ static int32_t rsmaRestore(SSma *pSma);
 #define SMA_SET_KEEP_CFG(v, l)                                                                    \
   do {                                                                                            \
     SRetention *r = &pCfg->retentions[l];                                                         \
-    pKeepCfg->keep2 = convertTimeFromPrecisionToUnit(r->keep, pCfg->precision, TIME_UNIT_MINUTE); \
+    int64_t keep = -1;                                                                            \
+    convertTimeFromPrecisionToUnit(r->keep, pCfg->precision, TIME_UNIT_MINUTE, &keep);            \
+    pKeepCfg->keep2 = (int32_t)keep;                                                              \
     pKeepCfg->keep0 = pKeepCfg->keep2;                                                            \
     pKeepCfg->keep1 = pKeepCfg->keep2;                                                            \
     pKeepCfg->days = smaEvalDays(v, pCfg->retentions, l, pCfg->precision, pCfg->days);            \
@@ -60,8 +62,12 @@ static int32_t rsmaRestore(SSma *pSma);
  * @return int32_t
  */
 static int32_t smaEvalDays(SVnode *pVnode, SRetention *r, int8_t level, int8_t precision, int32_t duration) {
-  int32_t freqDuration = convertTimeFromPrecisionToUnit((r + TSDB_RETENTION_L0)->freq, precision, TIME_UNIT_MINUTE);
+  int32_t code = TSDB_CODE_SUCCESS;
-  int32_t keepDuration = convertTimeFromPrecisionToUnit((r + TSDB_RETENTION_L0)->keep, precision, TIME_UNIT_MINUTE);
+
+  int64_t freqDuration = -1;
+  int64_t keepDuration = -1;
+  code = convertTimeFromPrecisionToUnit((r + TSDB_RETENTION_L0)->freq, precision, TIME_UNIT_MINUTE, &freqDuration);
+  code = convertTimeFromPrecisionToUnit((r + TSDB_RETENTION_L0)->keep, precision, TIME_UNIT_MINUTE, &keepDuration);
   int32_t days = duration;  // min
 
   if (days < freqDuration) {
@@ -76,8 +82,8 @@ static int32_t smaEvalDays(SVnode *pVnode, SRetention *r, int8_t level, int8_t p
     goto _exit;
   }
 
-  freqDuration = convertTimeFromPrecisionToUnit((r + level)->freq, precision, TIME_UNIT_MINUTE);
+  code = convertTimeFromPrecisionToUnit((r + level)->freq, precision, TIME_UNIT_MINUTE, &freqDuration);
-  keepDuration = convertTimeFromPrecisionToUnit((r + level)->keep, precision, TIME_UNIT_MINUTE);
+  code = convertTimeFromPrecisionToUnit((r + level)->keep, precision, TIME_UNIT_MINUTE, &keepDuration);
 
   int32_t nFreqTimes = (r + level)->freq / (60 * 1000);  // use 60s for freq of 1st level
   days *= (nFreqTimes > 1 ? nFreqTimes : 1);

source/dnode/vnode/src/sma/smaRollup.c

@@ -335,8 +335,9 @@ static int32_t tdSetRSmaInfoItemParams(SSma *pSma, SRSmaParam *param, SRSmaStat
     }
 
     if (param->maxdelay[idx] < TSDB_MIN_ROLLUP_MAX_DELAY) {
-      int64_t msInterval =
+      int64_t msInterval = -1;
-          convertTimeFromPrecisionToUnit(pRetention[idx + 1].freq, pTsdbCfg->precision, TIME_UNIT_MILLISECOND);
+      TAOS_CHECK_RETURN(convertTimeFromPrecisionToUnit(pRetention[idx + 1].freq, pTsdbCfg->precision,
+                                                       TIME_UNIT_MILLISECOND, &msInterval));
       pItem->maxDelay = (int32_t)msInterval;
     } else {
       pItem->maxDelay = (int32_t)param->maxdelay[idx];

source/dnode/vnode/src/sma/smaTimeRange.c

@@ -69,8 +69,9 @@ static int32_t tdProcessTSmaGetDaysImpl(SVnodeCfg *pCfg, void *pCont, uint32_t c
   }
 
   STsdbCfg *pTsdbCfg = &pCfg->tsdbCfg;
-  int64_t   sInterval = convertTimeFromPrecisionToUnit(tsma.interval, pTsdbCfg->precision, TIME_UNIT_SECOND);
+  int64_t   sInterval = -1;
-  if (sInterval <= 0) {
+  code = convertTimeFromPrecisionToUnit(tsma.interval, pTsdbCfg->precision, TIME_UNIT_SECOND, &sInterval);
+  if (TSDB_CODE_SUCCESS != code || 0 == sInterval) {
     *days = pTsdbCfg->days;
     goto _exit;
   }
@@ -78,7 +79,11 @@ static int32_t tdProcessTSmaGetDaysImpl(SVnodeCfg *pCfg, void *pCont, uint32_t c
   if (records >= SMA_STORAGE_SPLIT_FACTOR) {
     *days = pTsdbCfg->days;
   } else {
-    int64_t mInterval = convertTimeFromPrecisionToUnit(tsma.interval, pTsdbCfg->precision, TIME_UNIT_MINUTE);
+    int64_t mInterval = -1;
+    code = convertTimeFromPrecisionToUnit(tsma.interval, pTsdbCfg->precision, TIME_UNIT_MINUTE, &mInterval);
+    if (TSDB_CODE_SUCCESS != code) {
+      goto _exit;
+    }
     int64_t daysPerFile = mInterval * SMA_STORAGE_MINUTES_DAY * 2;
 
     if (daysPerFile > SMA_STORAGE_MINUTES_MAX) {

source/libs/command/inc/commandInt.h

@@ -176,7 +176,14 @@ typedef struct SExplainCtx {
 #define EXPLAIN_JOIN_STRING(_type) ((JOIN_TYPE_INNER == _type) ? "Inner join" : "Join")
 #define EXPLAIN_MERGE_MODE_STRING(_mode) ((_mode) == MERGE_TYPE_SORT ? "sort" : ((_mode) == MERGE_TYPE_NON_SORT ? "merge" : "column"))
 
-#define INVERAL_TIME_FROM_PRECISION_TO_UNIT(_t, _u, _p) (((_u) == 'n' || (_u) == 'y') ? (_t) : (convertTimeFromPrecisionToUnit(_t, _p, _u)))
+#define INVERAL_TIME_FROM_PRECISION_TO_UNIT(_t, _u, _p, _r)         \
+do {                                                                \
+  if ((_u) == 'n' || (_u) == 'y') {                                 \
+    _r = (_t);                                                      \
+  } else {                                                          \
+    code = convertTimeFromPrecisionToUnit(_t, _p, _u, &_r);         \
+  }                                                                 \
+} while(0)
 
 #define EXPLAIN_ROW_NEW(level, ...)                                                                               \
   do {                                                                                                            \

source/libs/command/src/explain.c

@@ -991,10 +991,17 @@ int32_t qExplainResNodeToRowsImpl(SExplainResNode *pResNode, SExplainCtx *ctx, i
         EXPLAIN_ROW_END();
         QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));
         uint8_t precision = qExplainGetIntervalPrecision(pIntNode);
+        int64_t time1 = -1;
+        int64_t time2 = -1;
+        int32_t code = TSDB_CODE_SUCCESS;
+        INVERAL_TIME_FROM_PRECISION_TO_UNIT(pIntNode->interval, pIntNode->intervalUnit, precision, time1);
+        QRY_ERR_RET(code);
+        INVERAL_TIME_FROM_PRECISION_TO_UNIT(pIntNode->sliding, pIntNode->slidingUnit, precision, time2);
+        QRY_ERR_RET(code);
         EXPLAIN_ROW_NEW(level + 1, EXPLAIN_TIME_WINDOWS_FORMAT,
-                        INVERAL_TIME_FROM_PRECISION_TO_UNIT(pIntNode->interval, pIntNode->intervalUnit, precision),
+                        time1,
                         pIntNode->intervalUnit, pIntNode->offset, getPrecisionUnit(precision),
-                        INVERAL_TIME_FROM_PRECISION_TO_UNIT(pIntNode->sliding, pIntNode->slidingUnit, precision),
+                        time2,
                         pIntNode->slidingUnit);
         EXPLAIN_ROW_END();
         QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));
@@ -1043,10 +1050,17 @@ int32_t qExplainResNodeToRowsImpl(SExplainResNode *pResNode, SExplainCtx *ctx, i
         EXPLAIN_ROW_END();
         QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));
         uint8_t precision = qExplainGetIntervalPrecision(pIntNode);
+        int64_t time1 = -1;
+        int64_t time2 = -1;
+        int32_t code = TSDB_CODE_SUCCESS;
+        INVERAL_TIME_FROM_PRECISION_TO_UNIT(pIntNode->interval, pIntNode->intervalUnit, precision, time1);
+        QRY_ERR_RET(code);
+        INVERAL_TIME_FROM_PRECISION_TO_UNIT(pIntNode->sliding, pIntNode->slidingUnit, precision, time2);
+        QRY_ERR_RET(code);
         EXPLAIN_ROW_NEW(level + 1, EXPLAIN_TIME_WINDOWS_FORMAT,
-                        INVERAL_TIME_FROM_PRECISION_TO_UNIT(pIntNode->interval, pIntNode->intervalUnit, precision),
+                        time1,
                         pIntNode->intervalUnit, pIntNode->offset, getPrecisionUnit(precision),
-                        INVERAL_TIME_FROM_PRECISION_TO_UNIT(pIntNode->sliding, pIntNode->slidingUnit, precision),
+                        time2,
                         pIntNode->slidingUnit);
         EXPLAIN_ROW_END();
         QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));
@@ -1563,10 +1577,17 @@ int32_t qExplainResNodeToRowsImpl(SExplainResNode *pResNode, SExplainCtx *ctx, i
         EXPLAIN_ROW_END();
         QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));
         uint8_t precision = qExplainGetIntervalPrecision(pIntNode);
+        int64_t time1 = -1;
+        int64_t time2 = -1;
+        int32_t code = TSDB_CODE_SUCCESS;
+        INVERAL_TIME_FROM_PRECISION_TO_UNIT(pIntNode->interval, pIntNode->intervalUnit, precision, time1);
+        QRY_ERR_RET(code);
+        INVERAL_TIME_FROM_PRECISION_TO_UNIT(pIntNode->sliding, pIntNode->slidingUnit, precision, time2);
+        QRY_ERR_RET(code);
         EXPLAIN_ROW_NEW(level + 1, EXPLAIN_TIME_WINDOWS_FORMAT,
-                        INVERAL_TIME_FROM_PRECISION_TO_UNIT(pIntNode->interval, pIntNode->intervalUnit, precision),
+                        time1,
                         pIntNode->intervalUnit, pIntNode->offset, getPrecisionUnit(precision),
-                        INVERAL_TIME_FROM_PRECISION_TO_UNIT(pIntNode->sliding, pIntNode->slidingUnit, precision),
+                        time2,
                         pIntNode->slidingUnit);
         EXPLAIN_ROW_END();
         QRY_ERR_RET(qExplainResAppendRow(ctx, tbuf, tlen, level + 1));

source/libs/geometry/src/geomFunc.c

@@ -180,7 +180,7 @@ int32_t executeGeomFromTextFunc(SColumnInfoData *pInputData, int32_t i, SColumnI
     goto _exit;
   }
 
-  colDataSetVal(pOutputData, i, output, (output == NULL));
+  code = colDataSetVal(pOutputData, i, output, (output == NULL));
 
 _exit:
   if (output) {
@@ -200,7 +200,7 @@ int32_t executeAsTextFunc(SColumnInfoData *pInputData, int32_t i, SColumnInfoDat
     goto _exit;
   }
 
-  colDataSetVal(pOutputData, i, output, (output == NULL));
+  code = colDataSetVal(pOutputData, i, output, (output == NULL));
 
 _exit:
   if (output) {
@@ -228,7 +228,7 @@ int32_t executeRelationFunc(const GEOSGeometry *geom1, const GEOSPreparedGeometr
     }
   }
 
-  colDataSetVal(pOutputData, i, &res, (res==-1));
+  code = colDataSetVal(pOutputData, i, &res, (res==-1));
 
   return code;
 }

source/libs/geometry/src/geosWrapper.c

@@ -86,8 +86,8 @@ _exit:
   return code;
 }
 
-static int initWktRegex(pcre2_code **ppRegex, pcre2_match_data **ppMatchData) {
+static int32_t initWktRegex(pcre2_code **ppRegex, pcre2_match_data **ppMatchData) {
-  int   ret = 0;
+  int32_t code = 0;
   char   *wktPatternWithSpace = taosMemoryCalloc(4, 1024);
   sprintf(
       wktPatternWithSpace,
@@ -142,9 +142,9 @@ static int initWktRegex(pcre2_code **ppRegex, pcre2_match_data **ppMatchData) {
       "*)(([-+]?[0-9]+\\.?[0-9]*)|([-+]?[0-9]*\\.?[0-9]+))(e[-+]?[0-9]+)?){1,3}( *))*( *)\\)))( *))*( *)\\)))( *))*( "
       "*)\\)))|(GEOCOLLECTION\\((?R)(( *)(,)( *)(?R))*( *)\\))( *)$");
 
-  ret = doRegComp(ppRegex, ppMatchData, wktPatternWithSpace);
+  code = doRegComp(ppRegex, ppMatchData, wktPatternWithSpace);
   taosMemoryFree(wktPatternWithSpace);
-  return ret;
+  return code;
 }
 
 int32_t initCtxGeomFromText() {

source/libs/parser/src/parTranslater.c

@@ -5233,7 +5233,8 @@ static int32_t translateFill(STranslateContext* pCxt, SSelectStmt* pSelect, SInt
 }
 
 static int64_t getMonthsFromTimeVal(int64_t val, int32_t fromPrecision, char unit) {
-  int64_t days = convertTimeFromPrecisionToUnit(val, fromPrecision, 'd');
+  int64_t days = -1;
+  convertTimeFromPrecisionToUnit(val, fromPrecision, 'd', &days);
   switch (unit) {
     case 'b':
     case 'u':
@@ -8232,7 +8233,8 @@ static SNode* makeIntervalVal(SRetention* pRetension, int8_t precision) {
   if (NULL == pVal) {
     return NULL;
   }
-  int64_t timeVal = convertTimeFromPrecisionToUnit(pRetension->freq, precision, pRetension->freqUnit);
+  int64_t timeVal = -1;
+  convertTimeFromPrecisionToUnit(pRetension->freq, precision, pRetension->freqUnit, &timeVal);
   char    buf[20] = {0};
   int32_t len = snprintf(buf, sizeof(buf), "%" PRId64 "%c", timeVal, pRetension->freqUnit);
   pVal->literal = strndup(buf, len);