#4720

Committed 08 Sep 2025 08:43AM UTC coverage: 58.139% (-0.6%) from 58.762%

Build # #4720

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge pull request #32881 from taosdata/enh/add-new-windows-ci

fix(ci): update workflow reference to use new Windows CI YAML

Run Details

133181 of 292179 branches covered (45.58%)

Branch coverage included in aggregate %.

201691 of 283811 relevant lines covered (71.07%)

5442780.71 hits per line

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

44.77

/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;
    }
    case TSDB_DATA_TYPE_BLOB:
    case TSDB_DATA_TYPE_MEDIUMBLOB: {
      uError("SVariant: BLOB and MEDIUMBLOB are not supported, type:%d", type);
      return TSDB_CODE_INVALID_DATA_FMT;
    }

    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) {	12✔
23	// skip head 0b
24	const char *p = z + 2;	12✔
25	int32_t l = n - 2;	12✔
26
27	while (*p == '0' && l > 0) {	12!
28	p++;	×
29	l--;	×
30	}
31	if (l > 64) { // too big	12!
32	return TSDB_CODE_FAILED;	×
33	}
34
35	uint64_t val = 0;	12✔
36	for (int32_t i = 0; i < l; i++) {	60✔
37	val = val << 1;	48✔
38	if (p[i] == '1') {	48✔
39	val \|= 1;	24✔
40	} else if (p[i] != '0') { // abnormal char	24!
41	return TSDB_CODE_FAILED;	×
42	}
43	}
44	*value = val;	12✔
45	return TSDB_CODE_SUCCESS;	12✔
46	}
47
48	static int32_t parseSignAndUInteger(const char z, int32_t n, bool is_neg, uint64_t *value, bool parseFloat) {	78✔
49	// parse sign
50	bool has_sign = false;	78✔
51	if (z[0] == '-') {	78✔
52	*is_neg = true;	12✔
53	has_sign = true;	12✔
54	} else if (z[0] == '+') {	66!
55	has_sign = true;	×
56	} else if (z[0] != '.' && (z[0] < '0' \|\| z[0] > '9')) {	66!
57	return TSDB_CODE_FAILED;	×
58	}
59	if (has_sign) {	78✔
60	if (n < 2) {	12!
61	return TSDB_CODE_FAILED;	×
62	}
63	z++;	12✔
64	n--;	12✔
65	}
66
67	SET_ERRNO(0);	78✔
68	char *endPtr = NULL;	78✔
69	if (z[0] == '0' && n > 2) {	78!
70	if (z[1] == 'b' \|\| z[1] == 'B') {	24!
71	// paring as binary
72	return parseBinaryUInteger(z, n, value);	12✔
73	}
74
75	if (z[1] == 'x' \|\| z[1] == 'X') {	12!
76	// parsing as hex
77	*value = taosStr2UInt64(z, &endPtr, 16);	12✔
78	if (ERRNO == ERANGE \|\| ERRNO == EINVAL \|\| endPtr - z != n) {	12!
79	return TSDB_CODE_FAILED;	×
80	}
81	return TSDB_CODE_SUCCESS;	12✔
82	}
83	}
84
85	if (parseFloat) {	54✔
86	// parsing as double
87	double val = taosStr2Double(z, &endPtr);	4✔
88	if (ERRNO == ERANGE \|\| ERRNO == EINVAL \|\| endPtr - z != n) {	4!
89	return TSDB_CODE_FAILED;	4✔
90	}
91	if (val > (double)UINT64_MAX) {	×
92	SET_ERRNO(ERANGE);	×
93	return TSDB_CODE_FAILED;	×
94	}
95	*value = round(val);	×
96	return TSDB_CODE_SUCCESS;	×
97	}
98
99	return TSDB_CODE_FAILED;	50✔
100	}
101
102	int32_t toDoubleEx(const char z, int32_t n, uint32_t type, double value) {	40,367,224✔
103	if (n == 0) {	40,367,224!
104	SET_ERRNO(EINVAL);	×
105	return TSDB_CODE_FAILED;	×
106	}
107
108	SET_ERRNO(0);	40,367,224✔
109	char *endPtr = NULL;	40,367,224✔
110	*value = taosStr2Double(z, &endPtr); // 0x already converted here	40,367,224✔
111	if (ERRNO == ERANGE \|\| ERRNO == EINVAL) return TSDB_CODE_FAILED;	41,447,715!
112	if (endPtr - z == n) return TSDB_CODE_SUCCESS;	41,354,181!
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;	×
119	return TSDB_CODE_SUCCESS;	×
120	}
121	}
122
123	return TSDB_CODE_FAILED;	×
124	}
125
126	int32_t toIntegerPure(const char z, int32_t n, int32_t base, int64_t value) {	50✔
127	SET_ERRNO(0);	50✔
128
129	char *endPtr = NULL;	50✔
130	*value = taosStr2Int64(z, &endPtr, base);	50✔
131	if (endPtr - z == n) {	50!
132	if (ERRNO == ERANGE \|\| ERRNO == EINVAL) {	×
133	return TSDB_CODE_FAILED;	×
134	}
135	return TSDB_CODE_SUCCESS;	×
136	}
137
138	bool is_neg = false;	50✔
139	uint64_t uv = 0;	50✔
140	int32_t code = parseSignAndUInteger(z, n, &is_neg, &uv, false); // support 0b/0x	50✔
141	if (code == TSDB_CODE_SUCCESS) {	50!
142	if (is_neg) {	×
143	if (uv > 1ull + INT64_MAX) {	×
144	*value = INT64_MIN;	×
145	return TSDB_CODE_FAILED;	×
146	} else {
147	*value = -(int64_t)uv;	×
148	}
149	} else {
150	if (uv > INT64_MAX) {	×
151	*value = INT64_MAX;	×
152	return TSDB_CODE_FAILED;	×
153	}
154	*value = uv;	×
155	}
156	}
157
158	return code;	50✔
159	}
160
161	int32_t toIntegerEx(const char z, int32_t n, uint32_t type, int64_t value) {	252,340,457✔
162	SET_ERRNO(0);	252,340,457✔
163	char *endPtr = NULL;	252,340,457✔
164	switch (type) {	252,340,457!
165	case TK_NK_INTEGER: {	254,220,760✔
166	*value = taosStr2Int64(z, &endPtr, 10);	254,220,760✔
167	if (ERRNO == ERANGE \|\| ERRNO == EINVAL \|\| endPtr - z != n) {	272,515,332!
168	return TSDB_CODE_FAILED;	1,462,475✔
169	}
170	return TSDB_CODE_SUCCESS;	271,052,857✔
171	} break;
172	case TK_NK_FLOAT: {	12✔
173	double val = round(taosStr2Double(z, &endPtr));	12✔
174	if (val < (double)INT64_MIN \|\| val > (double)INT64_MAX) {	12!
175	return TSDB_CODE_FAILED;	×
176	}
177	if (ERRNO == ERANGE \|\| ERRNO == EINVAL \|\| endPtr - z != n) {	12!
178	return TSDB_CODE_FAILED;	×
179	}
180	*value = val;	12✔
181	return TSDB_CODE_SUCCESS;	12✔
182	} break;
183	default:	×
184	break;	×
185	}
186
187	if (n == 0) {	×
188	SET_ERRNO(EINVAL);	×
189	return TSDB_CODE_FAILED;	×
190	}
191
192	// 1. try to parse as integer
193	*value = taosStr2Int64(z, &endPtr, 10);	×
194	if (endPtr - z == n) {	13!
195	if (ERRNO == ERANGE \|\| ERRNO == EINVAL) {	×
196	return TSDB_CODE_FAILED;	×
197	}
198	return TSDB_CODE_SUCCESS;	×
199	} else if (ERRNO == 0 && *endPtr == '.') {	13!
200	// pure decimal part
201	const char *s = endPtr + 1;	×
202	const char *end = z + n;	×
203	bool pure = true;	×
204	while (s < end) {	×
205	if (s < '0' \|\| s > '9') {	×
206	pure = false;	×
207	break;	×
208	}
209	s++;	×
210	}
211	if (pure) {	×
212	if (endPtr + 1 < end && endPtr[1] > '4') {	×
213	const char *p = z;	×
214	while (*p == ' ') {	×
215	p++;	×
216	}
217	if (*p == '-') {	×
218	if (*value > INT64_MIN) {	×
219	(*value)--;	×
220	}
221	} else {
222	if (*value < INT64_MAX) {	×
223	(*value)++;	×
224	}
225	}
226	}
227	return TSDB_CODE_SUCCESS;	×
228	}
229	}
230
231	// 2. parse as other
232	bool is_neg = false;	13✔
233	uint64_t uv = 0;	13✔
234	int32_t code = parseSignAndUInteger(z, n, &is_neg, &uv, true);	13✔
235	if (code == TSDB_CODE_SUCCESS) {	13✔
236	// truncate into int64
237	if (is_neg) {	12✔
238	if (uv > 1ull + INT64_MAX) {	6!
239	*value = INT64_MIN;	×
240	return TSDB_CODE_FAILED;	×
241	} else {
242	*value = -(int64_t)uv;	6✔
243	}
244	} else {
245	if (uv > INT64_MAX) {	6!
246	*value = INT64_MAX;	×
247	return TSDB_CODE_FAILED;	×
248	}
249	*value = uv;	6✔
250	}
251	}
252
253	return code;	13✔
254	}
255
256	int32_t toUIntegerEx(const char z, int32_t n, uint32_t type, uint64_t value) {	50,164,803✔
257	SET_ERRNO(0);	50,164,803✔
258	char *endPtr = NULL;	50,164,803✔
259	const char *p = z;	50,164,803✔
260	switch (type) {	50,164,803!
261	case TK_NK_INTEGER: {	50,192,870✔
262	*value = taosStr2UInt64(p, &endPtr, 10);	50,192,870✔
263	if (p == '-' && value) {	50,348,564!
264	return TSDB_CODE_FAILED;	3✔
265	}
266	if (ERRNO == ERANGE \|\| ERRNO == EINVAL \|\| endPtr - z != n) {	50,348,561!
267	return TSDB_CODE_FAILED;	37,927✔
268	}
269	return TSDB_CODE_SUCCESS;	50,310,634✔
270	} break;
271	case TK_NK_FLOAT: {	15✔
272	double val = round(taosStr2Double(p, &endPtr));	15✔
273	if (val < 0 \|\| val > (double)UINT64_MAX) {	15✔
274	return TSDB_CODE_FAILED;	9✔
275	}
276	if (ERRNO == ERANGE \|\| ERRNO == EINVAL \|\| endPtr - z != n) {	6!
277	return TSDB_CODE_FAILED;	×
278	}
279	*value = val;	6✔
280	return TSDB_CODE_SUCCESS;	6✔
281	} break;
282	default:	×
283	break;	×
284	}
285
286	if (n == 0) {	×
287	SET_ERRNO(EINVAL);	×
288	return TSDB_CODE_FAILED;	×
289	}
290
291	// 1. parse as integer
292	*value = taosStr2UInt64(p, &endPtr, 10);	×
293
294	if (endPtr - z == n) {	15!
295	if (ERRNO == ERANGE \|\| ERRNO == EINVAL \|\| (p == '-' && value)) {	×
296	return TSDB_CODE_FAILED;	×
297	}
298	return TSDB_CODE_SUCCESS;	×
299	} else if (ERRNO == 0 && *endPtr == '.') {	15!
300	const char *s = endPtr + 1;	×
301	const char *end = z + n;	×
302	bool pure = true;	×
303	while (s < end) {	×
304	if (s < '0' \|\| s > '9') {	×
305	pure = false;	×
306	break;	×
307	}
308	s++;	×
309	}
310	if (pure) {	×
311	if (endPtr + 1 < end && endPtr[1] > '4' && *value < UINT64_MAX) {	×
312	(*value)++;	×
313	}
314	if (p == '-' && value) {	×
315	return TSDB_CODE_FAILED;	×
316	}
317	return TSDB_CODE_SUCCESS;	×
318	}
319	}
320
321	// 2. parse as other
322	bool is_neg = false;	15✔
323	int32_t code = parseSignAndUInteger(z, n, &is_neg, value, true);	15✔
324	if (is_neg) {	15✔
325	if (TSDB_CODE_SUCCESS == code && 0 == *value) {	6!
326	return TSDB_CODE_SUCCESS;	×
327	}
328	return TSDB_CODE_FAILED;	6✔
329	}
330	return code;	9✔
331	}
332
333	int32_t toInteger(const char z, int32_t n, int32_t base, int64_t value) {	43,470,020✔
334	SET_ERRNO(0);	43,470,020✔
335	char *endPtr = NULL;	43,470,020✔
336
337	*value = taosStr2Int64(z, &endPtr, base);	43,470,020✔
338	if (ERRNO == ERANGE \|\| ERRNO == EINVAL \|\| endPtr - z != n) {	43,687,276!
339	SET_ERRNO(0);	70,100✔
340	return TSDB_CODE_FAILED;	70,100✔
341	}
342
343	return TSDB_CODE_SUCCESS;	43,617,176✔
344	}
345
346	int32_t toUInteger(const char z, int32_t n, int32_t base, uint64_t value) {	648,561✔
347	SET_ERRNO(0);	648,561✔
348	char *endPtr = NULL;	648,561✔
349
350	const char *p = z;	648,561✔
351	while (*p == ' ') p++;	648,561!
352	if (*p == '-') {	648,561!
353	return TSDB_CODE_FAILED;	×
354	}
355
356	*value = taosStr2UInt64(z, &endPtr, base);	648,561✔
357	if (ERRNO == ERANGE \|\| ERRNO == EINVAL \|\| endPtr - z != n) {	648,414!
358	SET_ERRNO(0);	242✔
359	return TSDB_CODE_FAILED;	242✔
360	}
361	return TSDB_CODE_SUCCESS;	648,172✔
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) {	2,420,122✔
372	switch (type) {	2,420,122!
373	case TSDB_DATA_TYPE_BOOL:	42,739✔
374	case TSDB_DATA_TYPE_TINYINT: {
375	pVar->nLen = tDataTypes[type].bytes;	42,739✔
376	pVar->i = GET_INT8_VAL(pz);	42,739✔
377	break;	42,739✔
378	}
379	case TSDB_DATA_TYPE_UTINYINT: {	36,154✔
380	pVar->nLen = tDataTypes[type].bytes;	36,154✔
381	pVar->u = GET_UINT8_VAL(pz);	36,154✔
382	break;	36,154✔
383	}
384	case TSDB_DATA_TYPE_SMALLINT: {	42,847✔
385	pVar->nLen = tDataTypes[type].bytes;	42,847✔
386	pVar->i = GET_INT16_VAL(pz);	42,847✔
387	break;	42,847✔
388	}
389	case TSDB_DATA_TYPE_USMALLINT: {	1,236,109✔
390	pVar->nLen = tDataTypes[type].bytes;	1,236,109✔
391	pVar->u = GET_UINT16_VAL(pz);	1,236,109✔
392	break;	1,236,109✔
393	}
394	case TSDB_DATA_TYPE_INT: {	252,178✔
395	pVar->nLen = tDataTypes[type].bytes;	252,178✔
396	pVar->i = GET_INT32_VAL(pz);	252,178✔
397	break;	252,178✔
398	}
399	case TSDB_DATA_TYPE_UINT: {	40,477✔
400	pVar->nLen = tDataTypes[type].bytes;	40,477✔
401	pVar->u = GET_UINT32_VAL(pz);	40,477✔
402	break;	40,477✔
403	}
404	case TSDB_DATA_TYPE_BIGINT:	659,406✔
405	case TSDB_DATA_TYPE_TIMESTAMP: {
406	pVar->nLen = tDataTypes[type].bytes;	659,406✔
407	pVar->i = GET_INT64_VAL(pz);	659,406✔
408	break;	659,406✔
409	}
410	case TSDB_DATA_TYPE_UBIGINT: {	40,316✔
411	pVar->nLen = tDataTypes[type].bytes;	40,316✔
412	pVar->u = GET_UINT64_VAL(pz);	40,316✔
413	break;	40,316✔
414	}
415	case TSDB_DATA_TYPE_DOUBLE: {	62,322✔
416	pVar->nLen = tDataTypes[type].bytes;	62,322✔
417	pVar->d = GET_DOUBLE_VAL(pz);	62,322✔
418	break;	62,322✔
419	}
420	case TSDB_DATA_TYPE_FLOAT: {	7,672✔
421	pVar->nLen = tDataTypes[type].bytes;	7,672✔
422	pVar->f = GET_FLOAT_VAL(pz);	7,672✔
423	break;	7,672✔
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	case TSDB_DATA_TYPE_BLOB:	×
444	case TSDB_DATA_TYPE_MEDIUMBLOB: {
445	uError("SVariant: BLOB and MEDIUMBLOB are not supported, type:%d", type);	×
446	return TSDB_CODE_INVALID_DATA_FMT;	×
447	}
448
449	default:	×
450	pVar->i = GET_INT32_VAL(pz);	×
451	pVar->nLen = tDataTypes[TSDB_DATA_TYPE_INT].bytes;	×
452	}
453
454	pVar->nType = type;	2,420,122✔
455	return 0;	2,420,122✔
456	}
457
458	void taosVariantDestroy(SVariant *pVar) {	6,738,929✔
459	if (pVar == NULL) return;	6,738,929!
460
461	if (pVar->nType == TSDB_DATA_TYPE_BINARY \|\| pVar->nType == TSDB_DATA_TYPE_NCHAR \|\|	6,738,929✔
462	pVar->nType == TSDB_DATA_TYPE_JSON \|\| pVar->nType == TSDB_DATA_TYPE_GEOMETRY \|\|	6,460,280✔
463	pVar->nType == TSDB_DATA_TYPE_VARBINARY) {	6,460,174✔
464	taosMemoryFreeClear(pVar->pz);	278,987!
465	pVar->nLen = 0;	278,993✔
466	}
467	}
468
469	int32_t taosVariantAssign(SVariant pDst, const SVariant pSrc) {	×
470	if (pSrc == NULL \|\| pDst == NULL) return 0;	×
471
472	pDst->nType = pSrc->nType;	×
473	if (pSrc->nType == TSDB_DATA_TYPE_BINARY \|\| pSrc->nType == TSDB_DATA_TYPE_VARBINARY \|\|	×
474	pSrc->nType == TSDB_DATA_TYPE_NCHAR \|\| pSrc->nType == TSDB_DATA_TYPE_JSON \|\|	×
475	pSrc->nType == TSDB_DATA_TYPE_GEOMETRY) {	×
476	int32_t len = pSrc->nLen + TSDB_NCHAR_SIZE;	×
477	char *p = taosMemoryRealloc(pDst->pz, len);	×
478	if (!p) return terrno;	×
479
480	(void)memset(p, 0, len);	×
481	pDst->pz = p;	×
482
483	(void)memcpy(pDst->pz, pSrc->pz, pSrc->nLen);	×
484	pDst->nLen = pSrc->nLen;	×
485	return 0;	×
486	}
487
488	if (IS_NUMERIC_TYPE(pSrc->nType) \|\| (pSrc->nType == TSDB_DATA_TYPE_BOOL)) {	×
489	pDst->i = pSrc->i;	×
490	}
491	return 0;	×
492	}
493
494	int32_t taosVariantCompare(const SVariant p1, const SVariant p2) {	×
495	if (p1->nType == TSDB_DATA_TYPE_NULL && p2->nType == TSDB_DATA_TYPE_NULL) {	×
496	return 0;	×
497	}
498
499	if (p1->nType == TSDB_DATA_TYPE_NULL) {	×
500	return -1;	×
501	}
502
503	if (p2->nType == TSDB_DATA_TYPE_NULL) {	×
504	return 1;	×
505	}
506
507	if (p1->nType == TSDB_DATA_TYPE_BINARY \|\| p1->nType == TSDB_DATA_TYPE_VARBINARY \|\|	×
508	p1->nType == TSDB_DATA_TYPE_NCHAR \|\| p1->nType == TSDB_DATA_TYPE_GEOMETRY) {	×
509	if (p1->nLen == p2->nLen) {	×
510	return memcmp(p1->pz, p2->pz, p1->nLen);	×
511	} else {
512	return p1->nLen > p2->nLen ? 1 : -1;	×
513	}
514	} else if (p1->nType == TSDB_DATA_TYPE_DOUBLE) {	×
515	if (p1->d == p2->d) {	×
516	return 0;	×
517	} else {
518	return p1->d > p2->d ? 1 : -1;	×
519	}
520	} else if (p1->nType == TSDB_DATA_TYPE_FLOAT) {	×
521	if (p1->f == p2->f) {	×
522	return 0;	×
523	} else {
524	return p1->f > p2->f ? 1 : -1;	×
525	}
526	} else if (IS_UNSIGNED_NUMERIC_TYPE(p1->nType)) {	×
527	if (p1->u == p2->u) {	×
528	return 0;	×
529	} else {
530	return p1->u > p2->u ? 1 : -1;	×
531	}
532	} else {
533	if (p1->i == p2->i) {	×
534	return 0;	×
535	} else {
536	return p1->i > p2->i ? 1 : -1;	×
537	}
538	}
539	}
540
541	char taosVariantGet(SVariant pVar, int32_t type) {	136,837✔
542	switch (type) {	136,837!
543	case TSDB_DATA_TYPE_BOOL:	49,546✔
544	case TSDB_DATA_TYPE_TINYINT:
545	case TSDB_DATA_TYPE_SMALLINT:
546	case TSDB_DATA_TYPE_INT:
547	case TSDB_DATA_TYPE_BIGINT:
548	case TSDB_DATA_TYPE_TIMESTAMP:
549	return (char *)&pVar->i;	49,546✔
550	case TSDB_DATA_TYPE_UTINYINT:	133✔
551	case TSDB_DATA_TYPE_USMALLINT:
552	case TSDB_DATA_TYPE_UINT:
553	case TSDB_DATA_TYPE_UBIGINT:
554	return (char *)&pVar->u;	133✔
555	case TSDB_DATA_TYPE_DOUBLE:	58,055✔
556	return (char *)&pVar->d;	58,055✔
557	case TSDB_DATA_TYPE_FLOAT:	65✔
558	return (char *)&pVar->f;	65✔
559	case TSDB_DATA_TYPE_BINARY:	28,402✔
560	case TSDB_DATA_TYPE_VARBINARY:
561	case TSDB_DATA_TYPE_JSON:
562	case TSDB_DATA_TYPE_GEOMETRY:
563	return (char *)pVar->pz;	28,402✔
564	case TSDB_DATA_TYPE_NCHAR:	714✔
565	return (char *)pVar->ucs4;	714✔
566	default:	×
567	return NULL;	×
568	}
569
570	return NULL;
571	}

taosdata / TDengine / #4720

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