#4473

Committed 08 Jul 2025 09:38AM UTC coverage: 62.922% (+0.7%) from 62.22%

Build # #4473

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge pull request #31712 from taosdata/merge/mainto3.0

merge: from main to 3.0 branch

Run Details

158525 of 321496 branches covered (49.31%)

Branch coverage included in aggregate %.

56 of 60 new or added lines in 13 files covered. (93.33%)

1333 existing lines in 67 files now uncovered.

245526 of 320647 relevant lines covered (76.57%)

17689640.25 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

64.57

/source/common/src/tvariant.c

/*
 * 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/>.
 */

#define _DEFAULT_SOURCE
#include "tvariant.h"
#include "ttime.h"
#include "ttokendef.h"
#include "tvariant.h"

static int32_t parseBinaryUInteger(const char *z, int32_t n, uint64_t *value) {
  // skip head 0b
  const char *p = z + 2;
  int32_t     l = n - 2;

  while (*p == '0' && l > 0) {
    p++;
    l--;
  }
  if (l > 64) {  // too big
    return TSDB_CODE_FAILED;
  }

  uint64_t val = 0;
  for (int32_t i = 0; i < l; i++) {
    val = val << 1;
    if (p[i] == '1') {
      val |= 1;
    } else if (p[i] != '0') {  // abnormal char
      return TSDB_CODE_FAILED;
    }
  }
  *value = val;
  return TSDB_CODE_SUCCESS;
}

static int32_t parseSignAndUInteger(const char *z, int32_t n, bool *is_neg, uint64_t *value, bool parseFloat) {
  // parse sign
  bool has_sign = false;
  if (z[0] == '-') {
    *is_neg = true;
    has_sign = true;
  } else if (z[0] == '+') {
    has_sign = true;
  } else if (z[0] != '.' && (z[0] < '0' || z[0] > '9')) {
    return TSDB_CODE_FAILED;
  }
  if (has_sign) {
    if (n < 2) {
      return TSDB_CODE_FAILED;
    }
    z++;
    n--;
  }

  SET_ERRNO(0);
  char *endPtr = NULL;
  if (z[0] == '0' && n > 2) {
    if (z[1] == 'b' || z[1] == 'B') {
      // paring as binary
      return parseBinaryUInteger(z, n, value);
    }

    if (z[1] == 'x' || z[1] == 'X') {
      // parsing as hex
      *value = taosStr2UInt64(z, &endPtr, 16);
      if (ERRNO == ERANGE || ERRNO == EINVAL || endPtr - z != n) {
        return TSDB_CODE_FAILED;
      }
      return TSDB_CODE_SUCCESS;
    }
  }

  if (parseFloat) {
    // parsing as double
    double val = taosStr2Double(z, &endPtr);
    if (ERRNO == ERANGE || ERRNO == EINVAL || endPtr - z != n) {
      return TSDB_CODE_FAILED;
    }
    if (val > (double)UINT64_MAX) {
      SET_ERRNO(ERANGE);
      return TSDB_CODE_FAILED;
    }
    *value = round(val);
    return TSDB_CODE_SUCCESS;
  }

  return TSDB_CODE_FAILED;
}

int32_t toDoubleEx(const char *z, int32_t n, uint32_t type, double *value) {
  if (n == 0) {
    SET_ERRNO(EINVAL);
    return TSDB_CODE_FAILED;
  }

  SET_ERRNO(0);
  char *endPtr = NULL;
  *value = taosStr2Double(z, &endPtr);  // 0x already converted here
  if (ERRNO == ERANGE || ERRNO == EINVAL) return TSDB_CODE_FAILED;
  if (endPtr - z == n) return TSDB_CODE_SUCCESS;

  if (type == TK_NK_BIN || type == TK_NK_STRING) {
    bool     is_neg = false;
    uint64_t uv = 0;
    if (TSDB_CODE_SUCCESS == parseSignAndUInteger(z, n, &is_neg, &uv, false)) {
      *value = is_neg ? -(double)uv : uv;
      return TSDB_CODE_SUCCESS;
    }
  }

  return TSDB_CODE_FAILED;
}

int32_t toIntegerPure(const char *z, int32_t n, int32_t base, int64_t *value) {
  SET_ERRNO(0);

  char *endPtr = NULL;
  *value = taosStr2Int64(z, &endPtr, base);
  if (endPtr - z == n) {
    if (ERRNO == ERANGE || ERRNO == EINVAL) {
      return TSDB_CODE_FAILED;
    }
    return TSDB_CODE_SUCCESS;
  }

  bool     is_neg = false;
  uint64_t uv = 0;
  int32_t  code = parseSignAndUInteger(z, n, &is_neg, &uv, false);  // support 0b/0x
  if (code == TSDB_CODE_SUCCESS) {
    if (is_neg) {
      if (uv > 1ull + INT64_MAX) {
        *value = INT64_MIN;
        return TSDB_CODE_FAILED;
      } else {
        *value = -(int64_t)uv;
      }
    } else {
      if (uv > INT64_MAX) {
        *value = INT64_MAX;
        return TSDB_CODE_FAILED;
      }
      *value = uv;
    }
  }

  return code;
}

int32_t toIntegerEx(const char *z, int32_t n, uint32_t type, int64_t *value) {
  SET_ERRNO(0);
  char *endPtr = NULL;
  switch (type) {
    case TK_NK_INTEGER: {
      *value = taosStr2Int64(z, &endPtr, 10);
      if (ERRNO == ERANGE || ERRNO == EINVAL || endPtr - z != n) {
        return TSDB_CODE_FAILED;
      }
      return TSDB_CODE_SUCCESS;
    } break;
    case TK_NK_FLOAT: {
      double val = round(taosStr2Double(z, &endPtr));
      if (val < (double)INT64_MIN || val > (double)INT64_MAX) {
        return TSDB_CODE_FAILED;
      }
      if (ERRNO == ERANGE || ERRNO == EINVAL || endPtr - z != n) {
        return TSDB_CODE_FAILED;
      }
      *value = val;
      return TSDB_CODE_SUCCESS;
    } break;
    default:
      break;
  }

  if (n == 0) {
    SET_ERRNO(EINVAL);
    return TSDB_CODE_FAILED;
  }

  // 1. try to parse as integer
  *value = taosStr2Int64(z, &endPtr, 10);
  if (endPtr - z == n) {
    if (ERRNO == ERANGE || ERRNO == EINVAL) {
      return TSDB_CODE_FAILED;
    }
    return TSDB_CODE_SUCCESS;
  } else if (ERRNO == 0 && *endPtr == '.') {
    // pure decimal part
    const char *s = endPtr + 1;
    const char *end = z + n;
    bool        pure = true;
    while (s < end) {
      if (*s < '0' || *s > '9') {
        pure = false;
        break;
      }
      s++;
    }
    if (pure) {
      if (endPtr + 1 < end && endPtr[1] > '4') {
        const char *p = z;
        while (*p == ' ') {
          p++;
        }
        if (*p == '-') {
          if (*value > INT64_MIN) {
            (*value)--;
          }
        } else {
          if (*value < INT64_MAX) {
            (*value)++;
          }
        }
      }
      return TSDB_CODE_SUCCESS;
    }
  }

  // 2. parse as other
  bool     is_neg = false;
  uint64_t uv = 0;
  int32_t  code = parseSignAndUInteger(z, n, &is_neg, &uv, true);
  if (code == TSDB_CODE_SUCCESS) {
    // truncate into int64
    if (is_neg) {
      if (uv > 1ull + INT64_MAX) {
        *value = INT64_MIN;
        return TSDB_CODE_FAILED;
      } else {
        *value = -(int64_t)uv;
      }
    } else {
      if (uv > INT64_MAX) {
        *value = INT64_MAX;
        return TSDB_CODE_FAILED;
      }
      *value = uv;
    }
  }

  return code;
}

int32_t toUIntegerEx(const char *z, int32_t n, uint32_t type, uint64_t *value) {
  SET_ERRNO(0);
  char       *endPtr = NULL;
  const char *p = z;
  switch (type) {
    case TK_NK_INTEGER: {
      *value = taosStr2UInt64(p, &endPtr, 10);
      if (*p == '-' && *value) {
        return TSDB_CODE_FAILED;
      }
      if (ERRNO == ERANGE || ERRNO == EINVAL || endPtr - z != n) {
        return TSDB_CODE_FAILED;
      }
      return TSDB_CODE_SUCCESS;
    } break;
    case TK_NK_FLOAT: {
      double val = round(taosStr2Double(p, &endPtr));
      if (val < 0 || val > (double)UINT64_MAX) {
        return TSDB_CODE_FAILED;
      }
      if (ERRNO == ERANGE || ERRNO == EINVAL || endPtr - z != n) {
        return TSDB_CODE_FAILED;
      }
      *value = val;
      return TSDB_CODE_SUCCESS;
    } break;
    default:
      break;
  }

  if (n == 0) {
    SET_ERRNO(EINVAL);
    return TSDB_CODE_FAILED;
  }

  // 1. parse as integer
  *value = taosStr2UInt64(p, &endPtr, 10);

  if (endPtr - z == n) {
    if (ERRNO == ERANGE || ERRNO == EINVAL || (*p == '-' && *value)) {
      return TSDB_CODE_FAILED;
    }
    return TSDB_CODE_SUCCESS;
  } else if (ERRNO == 0 && *endPtr == '.') {
    const char *s = endPtr + 1;
    const char *end = z + n;
    bool        pure = true;
    while (s < end) {
      if (*s < '0' || *s > '9') {
        pure = false;
        break;
      }
      s++;
    }
    if (pure) {
      if (endPtr + 1 < end && endPtr[1] > '4' && *value < UINT64_MAX) {
        (*value)++;
      }
      if (*p == '-' && *value) {
        return TSDB_CODE_FAILED;
      }
      return TSDB_CODE_SUCCESS;
    }
  }

  // 2. parse as other
  bool    is_neg = false;
  int32_t code = parseSignAndUInteger(z, n, &is_neg, value, true);
  if (is_neg) {
    if (TSDB_CODE_SUCCESS == code && 0 == *value) {
      return TSDB_CODE_SUCCESS;
    }
    return TSDB_CODE_FAILED;
  }
  return code;
}

int32_t toInteger(const char *z, int32_t n, int32_t base, int64_t *value) {
  SET_ERRNO(0);
  char *endPtr = NULL;

  *value = taosStr2Int64(z, &endPtr, base);
  if (ERRNO == ERANGE || ERRNO == EINVAL || endPtr - z != n) {
    SET_ERRNO(0);
    return TSDB_CODE_FAILED;
  }

  return TSDB_CODE_SUCCESS;
}

int32_t toUInteger(const char *z, int32_t n, int32_t base, uint64_t *value) {
  SET_ERRNO(0);
  char *endPtr = NULL;

  const char *p = z;
  while (*p == ' ') p++;
  if (*p == '-') {
    return TSDB_CODE_FAILED;
  }

  *value = taosStr2UInt64(z, &endPtr, base);
  if (ERRNO == ERANGE || ERRNO == EINVAL || endPtr - z != n) {
    SET_ERRNO(0);
    return TSDB_CODE_FAILED;
  }
  return TSDB_CODE_SUCCESS;
}

/**
 * create SVariant from binary string, not ascii data
 * @param pVar
 * @param pz
 * @param len
 * @param type
 */
int32_t taosVariantCreateFromBinary(SVariant *pVar, const char *pz, size_t len, uint32_t type) {
  switch (type) {
    case TSDB_DATA_TYPE_BOOL:
    case TSDB_DATA_TYPE_TINYINT: {
      pVar->nLen = tDataTypes[type].bytes;
      pVar->i = GET_INT8_VAL(pz);
      break;
    }
    case TSDB_DATA_TYPE_UTINYINT: {
      pVar->nLen = tDataTypes[type].bytes;
      pVar->u = GET_UINT8_VAL(pz);
      break;
    }
    case TSDB_DATA_TYPE_SMALLINT: {
      pVar->nLen = tDataTypes[type].bytes;
      pVar->i = GET_INT16_VAL(pz);
      break;
    }
    case TSDB_DATA_TYPE_USMALLINT: {
      pVar->nLen = tDataTypes[type].bytes;
      pVar->u = GET_UINT16_VAL(pz);
      break;
    }
    case TSDB_DATA_TYPE_INT: {
      pVar->nLen = tDataTypes[type].bytes;
      pVar->i = GET_INT32_VAL(pz);
      break;
    }
    case TSDB_DATA_TYPE_UINT: {
      pVar->nLen = tDataTypes[type].bytes;
      pVar->u = GET_UINT32_VAL(pz);
      break;
    }
    case TSDB_DATA_TYPE_BIGINT:
    case TSDB_DATA_TYPE_TIMESTAMP: {
      pVar->nLen = tDataTypes[type].bytes;
      pVar->i = GET_INT64_VAL(pz);
      break;
    }
    case TSDB_DATA_TYPE_UBIGINT: {
      pVar->nLen = tDataTypes[type].bytes;
      pVar->u = GET_UINT64_VAL(pz);
      break;
    }
    case TSDB_DATA_TYPE_DOUBLE: {
      pVar->nLen = tDataTypes[type].bytes;
      pVar->d = GET_DOUBLE_VAL(pz);
      break;
    }
    case TSDB_DATA_TYPE_FLOAT: {
      pVar->nLen = tDataTypes[type].bytes;
      pVar->f = GET_FLOAT_VAL(pz);
      break;
    }
    case TSDB_DATA_TYPE_NCHAR: {  // here we get the nchar length from raw binary bits length
      size_t lenInwchar = len / TSDB_NCHAR_SIZE;

      pVar->ucs4 = taosMemoryCalloc(1, (lenInwchar + 1) * TSDB_NCHAR_SIZE);
      if(!pVar->ucs4) return terrno;
      (void)memcpy(pVar->ucs4, pz, lenInwchar * TSDB_NCHAR_SIZE);
      pVar->nLen = (int32_t)len;

      break;
    }
    case TSDB_DATA_TYPE_BINARY:
    case TSDB_DATA_TYPE_VARBINARY:
    case TSDB_DATA_TYPE_GEOMETRY: {  // todo refactor, extract a method
      pVar->pz = taosMemoryCalloc(len + 1, sizeof(char));
      (void)memcpy(pVar->pz, pz, len);
      pVar->nLen = (int32_t)len;
      break;
    }

    default:
      pVar->i = GET_INT32_VAL(pz);
      pVar->nLen = tDataTypes[TSDB_DATA_TYPE_INT].bytes;
  }

  pVar->nType = type;
  return 0;
}

void taosVariantDestroy(SVariant *pVar) {
  if (pVar == NULL) return;

  if (pVar->nType == TSDB_DATA_TYPE_BINARY || pVar->nType == TSDB_DATA_TYPE_NCHAR ||
      pVar->nType == TSDB_DATA_TYPE_JSON || pVar->nType == TSDB_DATA_TYPE_GEOMETRY ||
      pVar->nType == TSDB_DATA_TYPE_VARBINARY) {
    taosMemoryFreeClear(pVar->pz);
    pVar->nLen = 0;
  }
}

int32_t taosVariantAssign(SVariant *pDst, const SVariant *pSrc) {
  if (pSrc == NULL || pDst == NULL) return 0;

  pDst->nType = pSrc->nType;
  if (pSrc->nType == TSDB_DATA_TYPE_BINARY || pSrc->nType == TSDB_DATA_TYPE_VARBINARY ||
      pSrc->nType == TSDB_DATA_TYPE_NCHAR || pSrc->nType == TSDB_DATA_TYPE_JSON ||
      pSrc->nType == TSDB_DATA_TYPE_GEOMETRY) {
    int32_t len = pSrc->nLen + TSDB_NCHAR_SIZE;
    char   *p = taosMemoryRealloc(pDst->pz, len);
    if (!p) return terrno;

    (void)memset(p, 0, len);
    pDst->pz = p;

    (void)memcpy(pDst->pz, pSrc->pz, pSrc->nLen);
    pDst->nLen = pSrc->nLen;
    return 0;
  }

  if (IS_NUMERIC_TYPE(pSrc->nType) || (pSrc->nType == TSDB_DATA_TYPE_BOOL)) {
    pDst->i = pSrc->i;
  }
  return 0;
}

int32_t taosVariantCompare(const SVariant *p1, const SVariant *p2) {
  if (p1->nType == TSDB_DATA_TYPE_NULL && p2->nType == TSDB_DATA_TYPE_NULL) {
    return 0;
  }

  if (p1->nType == TSDB_DATA_TYPE_NULL) {
    return -1;
  }

  if (p2->nType == TSDB_DATA_TYPE_NULL) {
    return 1;
  }

  if (p1->nType == TSDB_DATA_TYPE_BINARY || p1->nType == TSDB_DATA_TYPE_VARBINARY ||
      p1->nType == TSDB_DATA_TYPE_NCHAR || p1->nType == TSDB_DATA_TYPE_GEOMETRY) {
    if (p1->nLen == p2->nLen) {
      return memcmp(p1->pz, p2->pz, p1->nLen);
    } else {
      return p1->nLen > p2->nLen ? 1 : -1;
    }
  } else if (p1->nType == TSDB_DATA_TYPE_DOUBLE) {
    if (p1->d == p2->d) {
      return 0;
    } else {
      return p1->d > p2->d ? 1 : -1;
    }
  } else if (p1->nType == TSDB_DATA_TYPE_FLOAT) {
    if (p1->f == p2->f) {
      return 0;
    } else {
      return p1->f > p2->f ? 1 : -1;
    }
  } else if (IS_UNSIGNED_NUMERIC_TYPE(p1->nType)) {
    if (p1->u == p2->u) {
      return 0;
    } else {
      return p1->u > p2->u ? 1 : -1;
    }
  } else {
    if (p1->i == p2->i) {
      return 0;
    } else {
      return p1->i > p2->i ? 1 : -1;
    }
  }
}

char *taosVariantGet(SVariant *pVar, int32_t type) {
  switch (type) {
    case TSDB_DATA_TYPE_BOOL:
    case TSDB_DATA_TYPE_TINYINT:
    case TSDB_DATA_TYPE_SMALLINT:
    case TSDB_DATA_TYPE_INT:
    case TSDB_DATA_TYPE_BIGINT:
    case TSDB_DATA_TYPE_TIMESTAMP:
      return (char *)&pVar->i;
    case TSDB_DATA_TYPE_UTINYINT:
    case TSDB_DATA_TYPE_USMALLINT:
    case TSDB_DATA_TYPE_UINT:
    case TSDB_DATA_TYPE_UBIGINT:
      return (char *)&pVar->u;
    case TSDB_DATA_TYPE_DOUBLE:
      return (char *)&pVar->d;
    case TSDB_DATA_TYPE_FLOAT:
      return (char *)&pVar->f;
    case TSDB_DATA_TYPE_BINARY:
    case TSDB_DATA_TYPE_VARBINARY:
    case TSDB_DATA_TYPE_JSON:
    case TSDB_DATA_TYPE_GEOMETRY:
      return (char *)pVar->pz;
    case TSDB_DATA_TYPE_NCHAR:
      return (char *)pVar->ucs4;
    default:
      return NULL;
  }

  return NULL;
}

1	/*
2	* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
3	*
4	* This program is free software: you can use, redistribute, and/or modify
5	* it under the terms of the GNU Affero General Public License, version 3
6	* or later ("AGPL"), as published by the Free Software Foundation.
7	*
8	* This program is distributed in the hope that it will be useful, but WITHOUT
9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10	* FITNESS FOR A PARTICULAR PURPOSE.
11	*
12	* You should have received a copy of the GNU Affero General Public License
13	* along with this program. If not, see <http://www.gnu.org/licenses/>.
14	*/
15
16	#define _DEFAULT_SOURCE
17	#include "tvariant.h"
18	#include "ttime.h"
19	#include "ttokendef.h"
20	#include "tvariant.h"
21
22	static int32_t parseBinaryUInteger(const char z, int32_t n, uint64_t value) {	2,987✔
23	// skip head 0b
24	const char *p = z + 2;	2,987✔
25	int32_t l = n - 2;	2,987✔
26
27	while (*p == '0' && l > 0) {	8,050!
28	p++;	5,063✔
29	l--;	5,063✔
30	}
31	if (l > 64) { // too big	2,987!
32	return TSDB_CODE_FAILED;	×
33	}
34
35	uint64_t val = 0;	2,987✔
36	for (int32_t i = 0; i < l; i++) {	12,264✔
37	val = val << 1;	9,469✔
38	if (p[i] == '1') {	9,469✔
39	val \|= 1;	5,093✔
40	} else if (p[i] != '0') { // abnormal char	4,376✔
41	return TSDB_CODE_FAILED;	192✔
42	}
43	}
44	*value = val;	2,795✔
45	return TSDB_CODE_SUCCESS;	2,795✔
46	}
47
48	static int32_t parseSignAndUInteger(const char z, int32_t n, bool is_neg, uint64_t *value, bool parseFloat) {	22,941✔
49	// parse sign
50	bool has_sign = false;	22,941✔
51	if (z[0] == '-') {	22,941✔
52	*is_neg = true;	4,508✔
53	has_sign = true;	4,508✔
54	} else if (z[0] == '+') {	18,433✔
55	has_sign = true;	605✔
56	} else if (z[0] != '.' && (z[0] < '0' \|\| z[0] > '9')) {	17,828!
57	return TSDB_CODE_FAILED;	13,343✔
58	}
59	if (has_sign) {	9,598✔
60	if (n < 2) {	5,113!
61	return TSDB_CODE_FAILED;	×
62	}
63	z++;	5,113✔
64	n--;	5,113✔
65	}
66
67	SET_ERRNO(0);	9,598✔
68	char *endPtr = NULL;	9,598✔
69	if (z[0] == '0' && n > 2) {	9,598!
70	if (z[1] == 'b' \|\| z[1] == 'B') {	5,993✔
71	// paring as binary
72	return parseBinaryUInteger(z, n, value);	2,987✔
73	}
74
75	if (z[1] == 'x' \|\| z[1] == 'X') {	3,006✔
76	// parsing as hex
77	*value = taosStr2UInt64(z, &endPtr, 16);	2,752✔
78	if (ERRNO == ERANGE \|\| ERRNO == EINVAL \|\| endPtr - z != n) {	2,752!
79	return TSDB_CODE_FAILED;	192✔
80	}
81	return TSDB_CODE_SUCCESS;	2,560✔
82	}
83	}
84
85	if (parseFloat) {	3,859✔
86	// parsing as double
87	double val = taosStr2Double(z, &endPtr);	2,770✔
88	if (ERRNO == ERANGE \|\| ERRNO == EINVAL \|\| endPtr - z != n) {	2,770!
89	return TSDB_CODE_FAILED;	1,825✔
90	}
91	if (val > (double)UINT64_MAX) {	945!
92	SET_ERRNO(ERANGE);	×
93	return TSDB_CODE_FAILED;	×
94	}
95	*value = round(val);	945✔
96	return TSDB_CODE_SUCCESS;	945✔
97	}
98
99	return TSDB_CODE_FAILED;	1,089✔
100	}
101
102	int32_t toDoubleEx(const char z, int32_t n, uint32_t type, double value) {	869,905,432✔
103	if (n == 0) {	869,905,432✔
104	SET_ERRNO(EINVAL);	40✔
105	return TSDB_CODE_FAILED;	40✔
106	}
107
108	SET_ERRNO(0);	869,905,392✔
109	char *endPtr = NULL;	869,905,392✔
110	*value = taosStr2Double(z, &endPtr); // 0x already converted here	869,905,392✔
111	if (ERRNO == ERANGE \|\| ERRNO == EINVAL) return TSDB_CODE_FAILED;	872,518,157!
112	if (endPtr - z == n) return TSDB_CODE_SUCCESS;	872,710,772!
113
114	if (type == TK_NK_BIN \|\| type == TK_NK_STRING) {	×
115	bool is_neg = false;	×
116	uint64_t uv = 0;	×
117	if (TSDB_CODE_SUCCESS == parseSignAndUInteger(z, n, &is_neg, &uv, false)) {	✔
118	*value = is_neg ? -(double)uv : uv;	780✔
119	return TSDB_CODE_SUCCESS;	780✔
120	}
121	}
122
123	return TSDB_CODE_FAILED;	4,143✔
124	}
125
126	int32_t toIntegerPure(const char z, int32_t n, int32_t base, int64_t value) {	146,413✔
127	SET_ERRNO(0);	146,413✔
128
129	char *endPtr = NULL;	146,413✔
130	*value = taosStr2Int64(z, &endPtr, base);	146,413✔
131	if (endPtr - z == n) {	146,413✔
132	if (ERRNO == ERANGE \|\| ERRNO == EINVAL) {	144,577!
133	return TSDB_CODE_FAILED;	×
134	}
135	return TSDB_CODE_SUCCESS;	144,577✔
136	}
137
138	bool is_neg = false;	1,836✔
139	uint64_t uv = 0;	1,836✔
140	int32_t code = parseSignAndUInteger(z, n, &is_neg, &uv, false); // support 0b/0x	1,836✔
141	if (code == TSDB_CODE_SUCCESS) {	1,836✔
142	if (is_neg) {	615✔
143	if (uv > 1ull + INT64_MAX) {	385!
144	*value = INT64_MIN;	×
145	return TSDB_CODE_FAILED;	×
146	} else {
147	*value = -(int64_t)uv;	385✔
148	}
149	} else {
150	if (uv > INT64_MAX) {	230!
151	*value = INT64_MAX;	×
152	return TSDB_CODE_FAILED;	×
153	}
154	*value = uv;	230✔
155	}
156	}
157
158	return code;	1,836✔
159	}
160
161	int32_t toIntegerEx(const char z, int32_t n, uint32_t type, int64_t value) {	1,311,318,309✔
162	SET_ERRNO(0);	1,311,318,309✔
163	char *endPtr = NULL;	1,311,318,309✔
164	switch (type) {	1,311,318,309!
165	case TK_NK_INTEGER: {	1,313,950,303✔
166	*value = taosStr2Int64(z, &endPtr, 10);	1,313,950,303✔
167	if (ERRNO == ERANGE \|\| ERRNO == EINVAL \|\| endPtr - z != n) {	1,338,389,653!
168	return TSDB_CODE_FAILED;	×
169	}
170	return TSDB_CODE_SUCCESS;	1,342,967,729✔
171	} break;
172	case TK_NK_FLOAT: {	1,177✔
173	double val = round(taosStr2Double(z, &endPtr));	1,177✔
174	if (val < (double)INT64_MIN \|\| val > (double)INT64_MAX) {	1,177✔
175	return TSDB_CODE_FAILED;	8✔
176	}
177	if (ERRNO == ERANGE \|\| ERRNO == EINVAL \|\| endPtr - z != n) {	1,169!
178	return TSDB_CODE_FAILED;	×
179	}
180	*value = val;	1,169✔
181	return TSDB_CODE_SUCCESS;	1,169✔
182	} break;
UNCOV 183	default:	×
UNCOV 184	break;	×
185	}
186
UNCOV 187	if (n == 0) {	×
188	SET_ERRNO(EINVAL);	80✔
189	return TSDB_CODE_FAILED;	80✔
190	}
191
192	// 1. try to parse as integer
UNCOV 193	*value = taosStr2Int64(z, &endPtr, 10);	×
194	if (endPtr - z == n) {	9,996,772✔
195	if (ERRNO == ERANGE \|\| ERRNO == EINVAL) {	9,987,340!
196	return TSDB_CODE_FAILED;	×
197	}
198	return TSDB_CODE_SUCCESS;	9,987,340✔
199	} else if (ERRNO == 0 && *endPtr == '.') {	9,432!
200	// pure decimal part
201	const char *s = endPtr + 1;	629✔
202	const char *end = z + n;	629✔
203	bool pure = true;	629✔
204	while (s < end) {	1,762✔
205	if (s < '0' \|\| s > '9') {	1,268!
206	pure = false;	135✔
207	break;	135✔
208	}
209	s++;	1,133✔
210	}
211	if (pure) {	629✔
212	if (endPtr + 1 < end && endPtr[1] > '4') {	494!
213	const char *p = z;	9✔
214	while (*p == ' ') {	9!
215	p++;	×
216	}
217	if (*p == '-') {	9✔
218	if (*value > INT64_MIN) {	2!
219	(*value)--;	2✔
220	}
221	} else {
222	if (*value < INT64_MAX) {	7!
223	(*value)++;	7✔
224	}
225	}
226	}
227	return TSDB_CODE_SUCCESS;	494✔
228	}
229	}
230
231	// 2. parse as other
232	bool is_neg = false;	8,938✔
233	uint64_t uv = 0;	8,938✔
234	int32_t code = parseSignAndUInteger(z, n, &is_neg, &uv, true);	8,938✔
235	if (code == TSDB_CODE_SUCCESS) {	8,938✔
236	// truncate into int64
237	if (is_neg) {	2,705✔
238	if (uv > 1ull + INT64_MAX) {	1,707!
239	*value = INT64_MIN;	×
240	return TSDB_CODE_FAILED;	×
241	} else {
242	*value = -(int64_t)uv;	1,707✔
243	}
244	} else {
245	if (uv > INT64_MAX) {	998!
246	*value = INT64_MAX;	×
247	return TSDB_CODE_FAILED;	×
248	}
249	*value = uv;	998✔
250	}
251	}
252
253	return code;	8,938✔
254	}
255
256	int32_t toUIntegerEx(const char z, int32_t n, uint32_t type, uint64_t value) {	229,573,223✔
257	SET_ERRNO(0);	229,573,223✔
258	char *endPtr = NULL;	229,573,223✔
259	const char *p = z;	229,573,223✔
260	switch (type) {	229,573,223!
261	case TK_NK_INTEGER: {	229,627,127✔
262	*value = taosStr2UInt64(p, &endPtr, 10);	229,627,127✔
263	if (p == '-' && value) {	232,934,411✔
264	return TSDB_CODE_FAILED;	564✔
265	}
266	if (ERRNO == ERANGE \|\| ERRNO == EINVAL \|\| endPtr - z != n) {	232,933,847!
267	return TSDB_CODE_FAILED;	97,478✔
268	}
269	return TSDB_CODE_SUCCESS;	232,836,369✔
270	} break;
271	case TK_NK_FLOAT: {	1,124✔
272	double val = round(taosStr2Double(p, &endPtr));	1,124✔
273	if (val < 0 \|\| val > (double)UINT64_MAX) {	1,124✔
274	return TSDB_CODE_FAILED;	139✔
275	}
276	if (ERRNO == ERANGE \|\| ERRNO == EINVAL \|\| endPtr - z != n) {	985!
277	return TSDB_CODE_FAILED;	×
278	}
279	*value = val;	985✔
280	return TSDB_CODE_SUCCESS;	985✔
281	} break;
UNCOV 282	default:	×
UNCOV 283	break;	×
284	}
285
UNCOV 286	if (n == 0) {	×
287	SET_ERRNO(EINVAL);	67✔
288	return TSDB_CODE_FAILED;	67✔
289	}
290
291	// 1. parse as integer
UNCOV 292	*value = taosStr2UInt64(p, &endPtr, 10);	×
293
294	if (endPtr - z == n) {	226,037✔
295	if (ERRNO == ERANGE \|\| ERRNO == EINVAL \|\| (p == '-' && value)) {	217,480!
296	return TSDB_CODE_FAILED;	64✔
297	}
298	return TSDB_CODE_SUCCESS;	217,416✔
299	} else if (ERRNO == 0 && *endPtr == '.') {	8,557!
300	const char *s = endPtr + 1;	516✔
301	const char *end = z + n;	516✔
302	bool pure = true;	516✔
303	while (s < end) {	1,423✔
304	if (s < '0' \|\| s > '9') {	986!
305	pure = false;	79✔
306	break;	79✔
307	}
308	s++;	907✔
309	}
310	if (pure) {	516✔
311	if (endPtr + 1 < end && endPtr[1] > '4' && *value < UINT64_MAX) {	437!
312	(*value)++;	8✔
313	}
314	if (p == '-' && value) {	437✔
315	return TSDB_CODE_FAILED;	65✔
316	}
317	return TSDB_CODE_SUCCESS;	372✔
318	}
319	}
320
321	// 2. parse as other
322	bool is_neg = false;	8,120✔
323	int32_t code = parseSignAndUInteger(z, n, &is_neg, value, true);	8,120✔
324	if (is_neg) {	8,120✔
325	if (TSDB_CODE_SUCCESS == code && 0 == *value) {	1,394✔
326	return TSDB_CODE_SUCCESS;	624✔
327	}
328	return TSDB_CODE_FAILED;	770✔
329	}
330	return code;	6,726✔
331	}
332
333	int32_t toInteger(const char z, int32_t n, int32_t base, int64_t value) {	693,342,284✔
334	SET_ERRNO(0);	693,342,284✔
335	char *endPtr = NULL;	693,342,284✔
336
337	*value = taosStr2Int64(z, &endPtr, base);	693,342,284✔
338	if (ERRNO == ERANGE \|\| ERRNO == EINVAL \|\| endPtr - z != n) {	696,685,917!
339	SET_ERRNO(0);	×
340	return TSDB_CODE_FAILED;	×
341	}
342
343	return TSDB_CODE_SUCCESS;	698,124,765✔
344	}
345
346	int32_t toUInteger(const char z, int32_t n, int32_t base, uint64_t value) {	1,087,880✔
347	SET_ERRNO(0);	1,087,880✔
348	char *endPtr = NULL;	1,087,880✔
349
350	const char *p = z;	1,087,880✔
351	while (*p == ' ') p++;	1,087,880!
352	if (*p == '-') {	1,087,880!
353	return TSDB_CODE_FAILED;	×
354	}
355
356	*value = taosStr2UInt64(z, &endPtr, base);	1,087,880✔
357	if (ERRNO == ERANGE \|\| ERRNO == EINVAL \|\| endPtr - z != n) {	1,087,933!
358	SET_ERRNO(0);	143✔
359	return TSDB_CODE_FAILED;	143✔
360	}
361	return TSDB_CODE_SUCCESS;	1,087,790✔
362	}
363
364	/**
365	* create SVariant from binary string, not ascii data
366	* @param pVar
367	* @param pz
368	* @param len
369	* @param type
370	*/
371	int32_t taosVariantCreateFromBinary(SVariant pVar, const char pz, size_t len, uint32_t type) {	76,325,818✔
372	switch (type) {	76,325,818!
373	case TSDB_DATA_TYPE_BOOL:	47,560✔
374	case TSDB_DATA_TYPE_TINYINT: {
375	pVar->nLen = tDataTypes[type].bytes;	47,560✔
376	pVar->i = GET_INT8_VAL(pz);	47,560✔
377	break;	47,560✔
378	}
379	case TSDB_DATA_TYPE_UTINYINT: {	36,566✔
380	pVar->nLen = tDataTypes[type].bytes;	36,566✔
381	pVar->u = GET_UINT8_VAL(pz);	36,566✔
382	break;	36,566✔
383	}
384	case TSDB_DATA_TYPE_SMALLINT: {	10,507,415✔
385	pVar->nLen = tDataTypes[type].bytes;	10,507,415✔
386	pVar->i = GET_INT16_VAL(pz);	10,507,415✔
387	break;	10,507,415✔
388	}
389	case TSDB_DATA_TYPE_USMALLINT: {	36,494✔
390	pVar->nLen = tDataTypes[type].bytes;	36,494✔
391	pVar->u = GET_UINT16_VAL(pz);	36,494✔
392	break;	36,494✔
393	}
394	case TSDB_DATA_TYPE_INT: {	25,080,418✔
395	pVar->nLen = tDataTypes[type].bytes;	25,080,418✔
396	pVar->i = GET_INT32_VAL(pz);	25,080,418✔
397	break;	25,080,418✔
398	}
399	case TSDB_DATA_TYPE_UINT: {	57,623✔
400	pVar->nLen = tDataTypes[type].bytes;	57,623✔
401	pVar->u = GET_UINT32_VAL(pz);	57,623✔
402	break;	57,623✔
403	}
404	case TSDB_DATA_TYPE_BIGINT:	12,351,529✔
405	case TSDB_DATA_TYPE_TIMESTAMP: {
406	pVar->nLen = tDataTypes[type].bytes;	12,351,529✔
407	pVar->i = GET_INT64_VAL(pz);	12,351,529✔
408	break;	12,351,529✔
409	}
410	case TSDB_DATA_TYPE_UBIGINT: {	57,356✔
411	pVar->nLen = tDataTypes[type].bytes;	57,356✔
412	pVar->u = GET_UINT64_VAL(pz);	57,356✔
413	break;	57,356✔
414	}
415	case TSDB_DATA_TYPE_DOUBLE: {	10,097,280✔
416	pVar->nLen = tDataTypes[type].bytes;	10,097,280✔
417	pVar->d = GET_DOUBLE_VAL(pz);	10,097,280✔
418	break;	10,097,280✔
419	}
420	case TSDB_DATA_TYPE_FLOAT: {	18,115,678✔
421	pVar->nLen = tDataTypes[type].bytes;	18,115,678✔
422	pVar->f = GET_FLOAT_VAL(pz);	18,115,678✔
423	break;	18,115,678✔
424	}
425	case TSDB_DATA_TYPE_NCHAR: { // here we get the nchar length from raw binary bits length	×
426	size_t lenInwchar = len / TSDB_NCHAR_SIZE;	×
427
428	pVar->ucs4 = taosMemoryCalloc(1, (lenInwchar + 1) * TSDB_NCHAR_SIZE);	×
429	if(!pVar->ucs4) return terrno;	×
430	(void)memcpy(pVar->ucs4, pz, lenInwchar * TSDB_NCHAR_SIZE);	×
431	pVar->nLen = (int32_t)len;	×
432
433	break;	×
434	}
435	case TSDB_DATA_TYPE_BINARY:	×
436	case TSDB_DATA_TYPE_VARBINARY:
437	case TSDB_DATA_TYPE_GEOMETRY: { // todo refactor, extract a method
438	pVar->pz = taosMemoryCalloc(len + 1, sizeof(char));	×
439	(void)memcpy(pVar->pz, pz, len);	×
440	pVar->nLen = (int32_t)len;	×
441	break;	×
442	}
443
444	default:	×
445	pVar->i = GET_INT32_VAL(pz);	×
446	pVar->nLen = tDataTypes[TSDB_DATA_TYPE_INT].bytes;	×
447	}
448
449	pVar->nType = type;	76,325,818✔
450	return 0;	76,325,818✔
451	}
452
453	void taosVariantDestroy(SVariant *pVar) {	34,425,440✔
454	if (pVar == NULL) return;	34,425,440!
455
456	if (pVar->nType == TSDB_DATA_TYPE_BINARY \|\| pVar->nType == TSDB_DATA_TYPE_NCHAR \|\|	34,425,440!
457	pVar->nType == TSDB_DATA_TYPE_JSON \|\| pVar->nType == TSDB_DATA_TYPE_GEOMETRY \|\|	33,586,426✔
458	pVar->nType == TSDB_DATA_TYPE_VARBINARY) {	33,586,147✔
459	taosMemoryFreeClear(pVar->pz);	841,675!
460	pVar->nLen = 0;	841,678✔
461	}
462	}
463
464	int32_t taosVariantAssign(SVariant pDst, const SVariant pSrc) {	×
465	if (pSrc == NULL \|\| pDst == NULL) return 0;	×
466
467	pDst->nType = pSrc->nType;	×
468	if (pSrc->nType == TSDB_DATA_TYPE_BINARY \|\| pSrc->nType == TSDB_DATA_TYPE_VARBINARY \|\|	×
469	pSrc->nType == TSDB_DATA_TYPE_NCHAR \|\| pSrc->nType == TSDB_DATA_TYPE_JSON \|\|	×
470	pSrc->nType == TSDB_DATA_TYPE_GEOMETRY) {	×
471	int32_t len = pSrc->nLen + TSDB_NCHAR_SIZE;	×
472	char *p = taosMemoryRealloc(pDst->pz, len);	×
473	if (!p) return terrno;	×
474
475	(void)memset(p, 0, len);	×
476	pDst->pz = p;	×
477
478	(void)memcpy(pDst->pz, pSrc->pz, pSrc->nLen);	×
479	pDst->nLen = pSrc->nLen;	×
480	return 0;	×
481	}
482
483	if (IS_NUMERIC_TYPE(pSrc->nType) \|\| (pSrc->nType == TSDB_DATA_TYPE_BOOL)) {	×
484	pDst->i = pSrc->i;	×
485	}
486	return 0;	×
487	}
488
489	int32_t taosVariantCompare(const SVariant p1, const SVariant p2) {	×
490	if (p1->nType == TSDB_DATA_TYPE_NULL && p2->nType == TSDB_DATA_TYPE_NULL) {	×
491	return 0;	×
492	}
493
494	if (p1->nType == TSDB_DATA_TYPE_NULL) {	×
495	return -1;	×
496	}
497
498	if (p2->nType == TSDB_DATA_TYPE_NULL) {	×
499	return 1;	×
500	}
501
502	if (p1->nType == TSDB_DATA_TYPE_BINARY \|\| p1->nType == TSDB_DATA_TYPE_VARBINARY \|\|	×
503	p1->nType == TSDB_DATA_TYPE_NCHAR \|\| p1->nType == TSDB_DATA_TYPE_GEOMETRY) {	×
504	if (p1->nLen == p2->nLen) {	×
505	return memcmp(p1->pz, p2->pz, p1->nLen);	×
506	} else {
507	return p1->nLen > p2->nLen ? 1 : -1;	×
508	}
509	} else if (p1->nType == TSDB_DATA_TYPE_DOUBLE) {	×
510	if (p1->d == p2->d) {	×
511	return 0;	×
512	} else {
513	return p1->d > p2->d ? 1 : -1;	×
514	}
515	} else if (p1->nType == TSDB_DATA_TYPE_FLOAT) {	×
516	if (p1->f == p2->f) {	×
517	return 0;	×
518	} else {
519	return p1->f > p2->f ? 1 : -1;	×
520	}
521	} else if (IS_UNSIGNED_NUMERIC_TYPE(p1->nType)) {	×
522	if (p1->u == p2->u) {	×
523	return 0;	×
524	} else {
525	return p1->u > p2->u ? 1 : -1;	×
526	}
527	} else {
528	if (p1->i == p2->i) {	×
529	return 0;	×
530	} else {
531	return p1->i > p2->i ? 1 : -1;	×
532	}
533	}
534	}
535
536	char taosVariantGet(SVariant pVar, int32_t type) {	3,019,969✔
537	switch (type) {	3,019,969!
538	case TSDB_DATA_TYPE_BOOL:	2,812,456✔
539	case TSDB_DATA_TYPE_TINYINT:
540	case TSDB_DATA_TYPE_SMALLINT:
541	case TSDB_DATA_TYPE_INT:
542	case TSDB_DATA_TYPE_BIGINT:
543	case TSDB_DATA_TYPE_TIMESTAMP:
544	return (char *)&pVar->i;	2,812,456✔
545	case TSDB_DATA_TYPE_UTINYINT:	130✔
546	case TSDB_DATA_TYPE_USMALLINT:
547	case TSDB_DATA_TYPE_UINT:
548	case TSDB_DATA_TYPE_UBIGINT:
549	return (char *)&pVar->u;	130✔
550	case TSDB_DATA_TYPE_DOUBLE:	61,673✔
551	return (char *)&pVar->d;	61,673✔
552	case TSDB_DATA_TYPE_FLOAT:	65✔
553	return (char *)&pVar->f;	65✔
554	case TSDB_DATA_TYPE_BINARY:	144,962✔
555	case TSDB_DATA_TYPE_VARBINARY:
556	case TSDB_DATA_TYPE_JSON:
557	case TSDB_DATA_TYPE_GEOMETRY:
558	return (char *)pVar->pz;	144,962✔
559	case TSDB_DATA_TYPE_NCHAR:	714✔
560	return (char *)pVar->ucs4;	714✔
561	default:	×
562	return NULL;	×
563	}
564
565	return NULL;
566	}

taosdata / TDengine / #4473

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous