#4961

Committed 09 Feb 2026 01:16AM UTC coverage: 66.798% (-0.08%) from 66.88%

Build # #4961

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

docs: add support for recording STMT to CSV files (#34276)

* docs: add support for recording STMT to CSV files

* docs: update version for STMT recording feature in CSV files

Run Details

205534 of 307696 relevant lines covered (66.8%)

127069311.55 hits per line

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

87.58

/include/util/tcoding.h

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

#ifndef _TD_UTIL_CODING_H_
#define _TD_UTIL_CODING_H_

#include "os.h"
#include "tlog.h"

#ifdef __cplusplus
extern "C" {
#endif

#define ENCODE_LIMIT  (((uint8_t)1) << 7)
#define ZIGZAGE(T, v) (((u##T)((v) >> (sizeof(T) * 8 - 1))) ^ (((u##T)(v)) << 1))  // zigzag encode
#define ZIGZAGD(T, v) (((v) >> 1) ^ -((T)((v)&1)))                                 // zigzag decode

/* ------------------------ LEGACY CODES ------------------------ */
#if 1
// ---- Fixed U8
static FORCE_INLINE int32_t taosEncodeFixedU8(void **buf, uint8_t value) {
  if (buf != NULL) {
    ((uint8_t *)(*buf))[0] = value;
    *buf = POINTER_SHIFT(*buf, sizeof(value));
  }

  return (int32_t)sizeof(value);
}

static FORCE_INLINE void *taosDecodeFixedU8(const void *buf, uint8_t *value) {
  *value = ((uint8_t *)buf)[0];
  return POINTER_SHIFT(buf, sizeof(*value));
}

// ---- Fixed I8
static FORCE_INLINE int32_t taosEncodeFixedI8(void **buf, int8_t value) {
  if (buf != NULL) {
    ((int8_t *)(*buf))[0] = value;
    *buf = POINTER_SHIFT(*buf, sizeof(value));
  }
  return (int32_t)sizeof(value);
}

static FORCE_INLINE void *taosDecodeFixedI8(const void *buf, int8_t *value) {
  *value = ((int8_t *)buf)[0];
  return POINTER_SHIFT(buf, sizeof(*value));
}

static FORCE_INLINE void *taosSkipFixedLen(const void *buf, size_t len) { return POINTER_SHIFT(buf, len); }

// --- Bool

static FORCE_INLINE int32_t taosEncodeFixedBool(void **buf, bool value) {
  if (buf != NULL) {
    ((int8_t *)(*buf))[0] = (value ? 1 : 0);
    *buf = POINTER_SHIFT(*buf, sizeof(int8_t));
  }
  return (int32_t)sizeof(int8_t);
}

static FORCE_INLINE void *taosDecodeFixedBool(const void *buf, bool *value) {
  *value = ((((int8_t *)buf)[0] == 0) ? false : true);
  return POINTER_SHIFT(buf, sizeof(int8_t));
}

// ---- Fixed U16
static FORCE_INLINE int32_t taosEncodeFixedU16(void **buf, uint16_t value) {
  if (buf != NULL) {
    if (IS_LITTLE_ENDIAN()) {
      TAOS_MEMCPY(*buf, &value, sizeof(value));
    } else {
      ((uint8_t *)(*buf))[0] = value & 0xff;
      ((uint8_t *)(*buf))[1] = (value >> 8) & 0xff;
    }
    *buf = POINTER_SHIFT(*buf, sizeof(value));
  }

  return (int32_t)sizeof(value);
}

static FORCE_INLINE void *taosDecodeFixedU16(const void *buf, uint16_t *value) {
  if (IS_LITTLE_ENDIAN()) {
    TAOS_MEMCPY(value, buf, sizeof(*value));
  } else {
    ((uint8_t *)value)[1] = ((uint8_t *)buf)[0];
    ((uint8_t *)value)[0] = ((uint8_t *)buf)[1];
  }

  return POINTER_SHIFT(buf, sizeof(*value));
}

// ---- Fixed I16
static FORCE_INLINE int32_t taosEncodeFixedI16(void **buf, int16_t value) {
  return taosEncodeFixedU16(buf, ZIGZAGE(int16_t, value));
}

static FORCE_INLINE void *taosDecodeFixedI16(const void *buf, int16_t *value) {
  uint16_t tvalue = 0;
  void    *ret = taosDecodeFixedU16(buf, &tvalue);
  *value = ZIGZAGD(int16_t, tvalue);
  return ret;
}

// ---- Fixed U32
static FORCE_INLINE int32_t taosEncodeFixedU32(void **buf, uint32_t value) {
  if (buf != NULL) {
    if (IS_LITTLE_ENDIAN()) {
      TAOS_MEMCPY(*buf, &value, sizeof(value));
    } else {
      ((uint8_t *)(*buf))[0] = value & 0xff;
      ((uint8_t *)(*buf))[1] = (value >> 8) & 0xff;
      ((uint8_t *)(*buf))[2] = (value >> 16) & 0xff;
      ((uint8_t *)(*buf))[3] = (value >> 24) & 0xff;
    }
    *buf = POINTER_SHIFT(*buf, sizeof(value));
  }

  return (int32_t)sizeof(value);
}

static FORCE_INLINE void *taosDecodeFixedU32(const void *buf, uint32_t *value) {
  if (IS_LITTLE_ENDIAN()) {
    TAOS_MEMCPY(value, buf, sizeof(*value));
  } else {
    ((uint8_t *)value)[3] = ((uint8_t *)buf)[0];
    ((uint8_t *)value)[2] = ((uint8_t *)buf)[1];
    ((uint8_t *)value)[1] = ((uint8_t *)buf)[2];
    ((uint8_t *)value)[0] = ((uint8_t *)buf)[3];
  }

  return POINTER_SHIFT(buf, sizeof(*value));
}

// ---- Fixed I32
static FORCE_INLINE int32_t taosEncodeFixedI32(void **buf, int32_t value) {
  return taosEncodeFixedU32(buf, ZIGZAGE(int32_t, value));
}

static FORCE_INLINE void *taosDecodeFixedI32(const void *buf, int32_t *value) {
  uint32_t tvalue = 0;
  void    *ret = taosDecodeFixedU32(buf, &tvalue);
  *value = ZIGZAGD(int32_t, tvalue);
  return ret;
}

// ---- Fixed U64
static FORCE_INLINE int32_t taosEncodeFixedU64(void **buf, uint64_t value) {
  if (buf != NULL) {
    if (IS_LITTLE_ENDIAN()) {
      TAOS_MEMCPY(*buf, &value, sizeof(value));
    } else {
      ((uint8_t *)(*buf))[0] = value & 0xff;
      ((uint8_t *)(*buf))[1] = (value >> 8) & 0xff;
      ((uint8_t *)(*buf))[2] = (value >> 16) & 0xff;
      ((uint8_t *)(*buf))[3] = (value >> 24) & 0xff;
      ((uint8_t *)(*buf))[4] = (value >> 32) & 0xff;
      ((uint8_t *)(*buf))[5] = (value >> 40) & 0xff;
      ((uint8_t *)(*buf))[6] = (value >> 48) & 0xff;
      ((uint8_t *)(*buf))[7] = (value >> 56) & 0xff;
    }

    *buf = POINTER_SHIFT(*buf, sizeof(value));
  }

  return (int32_t)sizeof(value);
}

static FORCE_INLINE void *taosDecodeFixedU64(const void *buf, uint64_t *value) {
  if (IS_LITTLE_ENDIAN()) {
    TAOS_MEMCPY(value, buf, sizeof(*value));
  } else {
    ((uint8_t *)value)[7] = ((uint8_t *)buf)[0];
    ((uint8_t *)value)[6] = ((uint8_t *)buf)[1];
    ((uint8_t *)value)[5] = ((uint8_t *)buf)[2];
    ((uint8_t *)value)[4] = ((uint8_t *)buf)[3];
    ((uint8_t *)value)[3] = ((uint8_t *)buf)[4];
    ((uint8_t *)value)[2] = ((uint8_t *)buf)[5];
    ((uint8_t *)value)[1] = ((uint8_t *)buf)[6];
    ((uint8_t *)value)[0] = ((uint8_t *)buf)[7];
  }

  return POINTER_SHIFT(buf, sizeof(*value));
}

// ---- Fixed I64
static FORCE_INLINE int32_t taosEncodeFixedI64(void **buf, int64_t value) {
  return taosEncodeFixedU64(buf, ZIGZAGE(int64_t, value));
}

static FORCE_INLINE void *taosDecodeFixedI64(const void *buf, int64_t *value) {
  uint64_t tvalue = 0;
  void    *ret = taosDecodeFixedU64(buf, &tvalue);
  *value = ZIGZAGD(int64_t, tvalue);
  return ret;
}

// ---- Variant U16
static FORCE_INLINE int32_t taosEncodeVariantU16(void **buf, uint16_t value) {
  int32_t i = 0;
  while (value >= ENCODE_LIMIT) {
    if (buf != NULL) ((uint8_t *)(*buf))[i] = (uint8_t)(value | ENCODE_LIMIT);
    value >>= 7;
    i++;
  }

  if (buf != NULL) {
    ((uint8_t *)(*buf))[i] = (uint8_t)value;
    *buf = POINTER_SHIFT(*buf, i + 1);
  }

  return i + 1;
}

static FORCE_INLINE void *taosDecodeVariantU16(const void *buf, uint16_t *value) {
  int32_t  i = 0;
  uint16_t tval = 0;
  *value = 0;
  while (i < 3) {
    tval = (uint16_t)(((uint8_t *)buf)[i]);
    if (tval < ENCODE_LIMIT) {
      (*value) |= (tval << (7 * i));
      return POINTER_SHIFT(buf, i + 1);
    } else {
      (*value) |= ((tval & (ENCODE_LIMIT - 1)) << (7 * i));
      i++;
    }
  }

  return NULL;  // error happened
}

// ---- Variant I16
static FORCE_INLINE int32_t taosEncodeVariantI16(void **buf, int16_t value) {
  return taosEncodeVariantU16(buf, ZIGZAGE(int16_t, value));
}

static FORCE_INLINE void *taosDecodeVariantI16(const void *buf, int16_t *value) {
  uint16_t tvalue = 0;
  void    *ret = taosDecodeVariantU16(buf, &tvalue);
  *value = ZIGZAGD(int16_t, tvalue);
  return ret;
}

// ---- Variant U32
static FORCE_INLINE int32_t taosEncodeVariantU32(void **buf, uint32_t value) {
  int32_t i = 0;
  while (value >= ENCODE_LIMIT) {
    if (buf != NULL) ((uint8_t *)(*buf))[i] = (value | ENCODE_LIMIT);
    value >>= 7;
    i++;
  }

  if (buf != NULL) {
    ((uint8_t *)(*buf))[i] = value;
    *buf = POINTER_SHIFT(*buf, i + 1);
  }

  return i + 1;
}

static FORCE_INLINE void *taosDecodeVariantU32(const void *buf, uint32_t *value) {
  int32_t  i = 0;
  uint32_t tval = 0;
  *value = 0;
  while (i < 5) {
    tval = (uint32_t)(((uint8_t *)buf)[i]);
    if (tval < ENCODE_LIMIT) {
      (*value) |= (tval << (7 * i));
      return POINTER_SHIFT(buf, i + 1);
    } else {
      (*value) |= ((tval & (ENCODE_LIMIT - 1)) << (7 * i));
      i++;
    }
  }

  return NULL;  // error happened
}

// ---- Variant I32
static FORCE_INLINE int32_t taosEncodeVariantI32(void **buf, int32_t value) {
  return taosEncodeVariantU32(buf, ZIGZAGE(int32_t, value));
}

static FORCE_INLINE void *taosDecodeVariantI32(const void *buf, int32_t *value) {
  uint32_t tvalue = 0;
  void    *ret = taosDecodeVariantU32(buf, &tvalue);
  *value = ZIGZAGD(int32_t, tvalue);
  return ret;
}

// ---- Variant U64
static FORCE_INLINE int32_t taosEncodeVariantU64(void **buf, uint64_t value) {
  int32_t i = 0;
  while (value >= ENCODE_LIMIT) {
    if (buf != NULL) ((uint8_t *)(*buf))[i] = (uint8_t)(value | ENCODE_LIMIT);
    value >>= 7;
    i++;
  }

  if (buf != NULL) {
    ((uint8_t *)(*buf))[i] = (uint8_t)value;
    *buf = POINTER_SHIFT(*buf, i + 1);
  }

  return i + 1;
}

static FORCE_INLINE void *taosDecodeVariantU64(const void *buf, uint64_t *value) {
  int32_t  i = 0;
  uint64_t tval = 0;
  *value = 0;
  while (i < 10) {
    tval = (uint64_t)(((uint8_t *)buf)[i]);
    if (tval < ENCODE_LIMIT) {
      (*value) |= (tval << (7 * i));
      return POINTER_SHIFT(buf, i + 1);
    } else {
      (*value) |= ((tval & (ENCODE_LIMIT - 1)) << (7 * i));
      i++;
    }
  }

  return NULL;  // error happened
}

// ---- Variant I64
static FORCE_INLINE int32_t taosEncodeVariantI64(void **buf, int64_t value) {
  return taosEncodeVariantU64(buf, ZIGZAGE(int64_t, value));
}

static FORCE_INLINE void *taosDecodeVariantI64(const void *buf, int64_t *value) {
  uint64_t tvalue = 0;
  void    *ret = taosDecodeVariantU64(buf, &tvalue);
  *value = ZIGZAGD(int64_t, tvalue);
  return ret;
}

// ---- string
static FORCE_INLINE int32_t taosEncodeString(void **buf, const char *value) {
  int32_t tlen = 0;
  size_t  size = strlen(value);

  tlen += taosEncodeVariantU64(buf, size);
  if (buf != NULL) {
    TAOS_MEMCPY(*buf, value, size);
    *buf = POINTER_SHIFT(*buf, size);
  }
  tlen += (int32_t)size;

  return tlen;
}

static FORCE_INLINE void *taosDecodeString(const void *buf, char **value) {
  uint64_t size = 0;

  buf = taosDecodeVariantU64(buf, &size);
  *value = (char *)taosMemoryMalloc((size_t)size + 1);

  if (*value == NULL) return NULL;
  TAOS_MEMCPY(*value, buf, (size_t)size);

  (*value)[size] = '\0';

  return POINTER_SHIFT(buf, size);
}

static FORCE_INLINE void *taosDecodeStringTo(const void *buf, char *value) {
  uint64_t size = 0;

  buf = taosDecodeVariantU64(buf, &size);
  TAOS_MEMCPY(value, buf, (size_t)size);

  value[size] = '\0';

  return POINTER_SHIFT(buf, size);
}

// ---- binary
static FORCE_INLINE int32_t taosEncodeBinary(void **buf, const void *value, int32_t valueLen) {
  int32_t tlen = 0;

  if (buf != NULL) {
    TAOS_MEMCPY(*buf, value, valueLen);
    *buf = POINTER_SHIFT(*buf, valueLen);
  }
  tlen += (int32_t)valueLen;

  return tlen;
}

static FORCE_INLINE void *taosDecodeBinary(const void *buf, void **value, int32_t valueLen) {
  *value = taosMemoryMalloc((size_t)valueLen);
  if (*value == NULL) return NULL;
  TAOS_MEMCPY(*value, buf, (size_t)valueLen);

  return POINTER_SHIFT(buf, valueLen);
}

static FORCE_INLINE void *taosDecodeBinaryTo(const void *buf, void *value, int32_t valueLen) {
  TAOS_MEMCPY(value, buf, (size_t)valueLen);
  return POINTER_SHIFT(buf, valueLen);
}

#endif

#ifdef __cplusplus
}
#endif

#endif /*_TD_UTIL_CODING_H_*/

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	#ifndef _TD_UTIL_CODING_H_
17	#define _TD_UTIL_CODING_H_
18
19	#include "os.h"
20	#include "tlog.h"
21
22	#ifdef __cplusplus
23	extern "C" {
24	#endif
25
26	#define ENCODE_LIMIT (((uint8_t)1) << 7)
27	#define ZIGZAGE(T, v) (((u##T)((v) >> (sizeof(T) * 8 - 1))) ^ (((u##T)(v)) << 1)) // zigzag encode
28	#define ZIGZAGD(T, v) (((v) >> 1) ^ -((T)((v)&1))) // zigzag decode
29
30	/* ------------------------ LEGACY CODES ------------------------ */
31	#if 1
32	// ---- Fixed U8
33	static FORCE_INLINE int32_t taosEncodeFixedU8(void **buf, uint8_t value) {
34	if (buf != NULL) {
35	((uint8_t )(buf))[0] = value;
36	buf = POINTER_SHIFT(buf, sizeof(value));
37	}
38
39	return (int32_t)sizeof(value);
40	}
41
42	static FORCE_INLINE void taosDecodeFixedU8(const void buf, uint8_t *value) {
43	value = ((uint8_t )buf)[0];
44	return POINTER_SHIFT(buf, sizeof(*value));
45	}
46
47	// ---- Fixed I8
48	static FORCE_INLINE int32_t taosEncodeFixedI8(void **buf, int8_t value) {
49	if (buf != NULL) {	55,090,011✔
50	((int8_t )(buf))[0] = value;	27,552,945✔
51	buf = POINTER_SHIFT(buf, sizeof(value));	27,552,593✔
52	}
53	return (int32_t)sizeof(value);	55,089,337✔
54	}
55
56	static FORCE_INLINE void taosDecodeFixedI8(const void buf, int8_t *value) {
57	value = ((int8_t )buf)[0];	48,016,723✔
58	return POINTER_SHIFT(buf, sizeof(*value));	48,016,723✔
59	}
60
61	static FORCE_INLINE void taosSkipFixedLen(const void buf, size_t len) { return POINTER_SHIFT(buf, len); }
62
63	// --- Bool
64
65	static FORCE_INLINE int32_t taosEncodeFixedBool(void **buf, bool value) {
66	if (buf != NULL) {	5,113,849✔
67	((int8_t )(buf))[0] = (value ? 1 : 0);	2,559,734✔
68	buf = POINTER_SHIFT(buf, sizeof(int8_t));	2,559,734✔
69	}
70	return (int32_t)sizeof(int8_t);	5,113,849✔
71	}
72
73	static FORCE_INLINE void taosDecodeFixedBool(const void buf, bool *value) {
74	value = ((((int8_t )buf)[0] == 0) ? false : true);	2,512,873✔
75	return POINTER_SHIFT(buf, sizeof(int8_t));	2,512,873✔
76	}
77
78	// ---- Fixed U16
79	static FORCE_INLINE int32_t taosEncodeFixedU16(void **buf, uint16_t value) {
80	if (buf != NULL) {	47,639,806✔
81	if (IS_LITTLE_ENDIAN()) {	23,827,353✔
82	TAOS_MEMCPY(*buf, &value, sizeof(value));	23,827,893✔
83	} else {
84	((uint8_t )(buf))[0] = value & 0xff;	×
85	((uint8_t )(buf))[1] = (value >> 8) & 0xff;	×
86	}
87	buf = POINTER_SHIFT(buf, sizeof(value));	23,827,353✔
88	}
89
90	return (int32_t)sizeof(value);	47,639,806✔
91	}
92
93	static FORCE_INLINE void taosDecodeFixedU16(const void buf, uint16_t *value) {
94	if (IS_LITTLE_ENDIAN()) {	33,300,968✔
95	TAOS_MEMCPY(value, buf, sizeof(*value));	33,300,914✔
96	} else {
97	((uint8_t )value)[1] = ((uint8_t )buf)[0];	54✔
98	((uint8_t )value)[0] = ((uint8_t )buf)[1];	54✔
99	}
100
101	return POINTER_SHIFT(buf, sizeof(*value));	33,300,968✔
102	}
103
104	// ---- Fixed I16
105	static FORCE_INLINE int32_t taosEncodeFixedI16(void **buf, int16_t value) {
106	return taosEncodeFixedU16(buf, ZIGZAGE(int16_t, value));	35,515,704✔
107	}
108
109	static FORCE_INLINE void taosDecodeFixedI16(const void buf, int16_t *value) {
110	uint16_t tvalue = 0;	19,472,733✔
111	void *ret = taosDecodeFixedU16(buf, &tvalue);	19,472,733✔
112	*value = ZIGZAGD(int16_t, tvalue);	19,472,733✔
113	return ret;	19,472,733✔
114	}
115
116	// ---- Fixed U32
117	static FORCE_INLINE int32_t taosEncodeFixedU32(void **buf, uint32_t value) {
118	if (buf != NULL) {	73,705,845✔
119	if (IS_LITTLE_ENDIAN()) {	37,308,210✔
120	TAOS_MEMCPY(*buf, &value, sizeof(value));	37,309,556✔
121	} else {
122	((uint8_t )(buf))[0] = value & 0xff;	352✔
123	((uint8_t )(buf))[1] = (value >> 8) & 0xff;	×
124	((uint8_t )(buf))[2] = (value >> 16) & 0xff;	×
125	((uint8_t )(buf))[3] = (value >> 24) & 0xff;	×
126	}
127	buf = POINTER_SHIFT(buf, sizeof(value));	37,308,885✔
128	}
129
130	return (int32_t)sizeof(value);	73,706,570✔
131	}
132
133	static FORCE_INLINE void taosDecodeFixedU32(const void buf, uint32_t *value) {
134	if (IS_LITTLE_ENDIAN()) {	54,633,170✔
135	TAOS_MEMCPY(value, buf, sizeof(*value));	54,633,915✔
136	} else {
137	((uint8_t )value)[3] = ((uint8_t )buf)[0];	3✔
138	((uint8_t )value)[2] = ((uint8_t )buf)[1];	3✔
139	((uint8_t )value)[1] = ((uint8_t )buf)[2];	3✔
140	((uint8_t )value)[0] = ((uint8_t )buf)[3];	3✔
141	}
142
143	return POINTER_SHIFT(buf, sizeof(*value));	54,633,170✔
144	}
145
146	// ---- Fixed I32
147	static FORCE_INLINE int32_t taosEncodeFixedI32(void **buf, int32_t value) {
148	return taosEncodeFixedU32(buf, ZIGZAGE(int32_t, value));	145,615,525✔
149	}
150
151	static FORCE_INLINE void taosDecodeFixedI32(const void buf, int32_t *value) {
152	uint32_t tvalue = 0;	32,557,039✔
153	void *ret = taosDecodeFixedU32(buf, &tvalue);	32,557,039✔
154	*value = ZIGZAGD(int32_t, tvalue);	32,557,039✔
155	return ret;	32,557,039✔
156	}
157
158	// ---- Fixed U64
159	static FORCE_INLINE int32_t taosEncodeFixedU64(void **buf, uint64_t value) {
160	if (buf != NULL) {	27,701,885✔
161	if (IS_LITTLE_ENDIAN()) {	19,488,261✔
162	TAOS_MEMCPY(*buf, &value, sizeof(value));	19,487,721✔
163	} else {
164	((uint8_t )(buf))[0] = value & 0xff;	648✔
165	((uint8_t )(buf))[1] = (value >> 8) & 0xff;	648✔
166	((uint8_t )(buf))[2] = (value >> 16) & 0xff;	648✔
167	((uint8_t )(buf))[3] = (value >> 24) & 0xff;	648✔
168	((uint8_t )(buf))[4] = (value >> 32) & 0xff;	648✔
169	((uint8_t )(buf))[5] = (value >> 40) & 0xff;	648✔
170	((uint8_t )(buf))[6] = (value >> 48) & 0xff;	648✔
171	((uint8_t )(buf))[7] = (value >> 56) & 0xff;	648✔
172	}
173
174	buf = POINTER_SHIFT(buf, sizeof(value));	19,488,261✔
175	}
176
177	return (int32_t)sizeof(value);	38,824,853✔
178	}
179
180	static FORCE_INLINE void taosDecodeFixedU64(const void buf, uint64_t *value) {
181	if (IS_LITTLE_ENDIAN()) {	18,126,864✔
182	TAOS_MEMCPY(value, buf, sizeof(*value));	19,758,778✔
183	} else {
184	((uint8_t )value)[7] = ((uint8_t )buf)[0];	×
185	((uint8_t )value)[6] = ((uint8_t )buf)[1];	×
186	((uint8_t )value)[5] = ((uint8_t )buf)[2];	×
187	((uint8_t )value)[4] = ((uint8_t )buf)[3];	×
188	((uint8_t )value)[3] = ((uint8_t )buf)[4];	×
189	((uint8_t )value)[2] = ((uint8_t )buf)[5];	×
190	((uint8_t )value)[1] = ((uint8_t )buf)[6];	×
191	((uint8_t )value)[0] = ((uint8_t )buf)[7];	×
192	}
193
194	return POINTER_SHIFT(buf, sizeof(*value));	19,758,184✔
195	}
196
197	// ---- Fixed I64
198	static FORCE_INLINE int32_t taosEncodeFixedI64(void **buf, int64_t value) {
199	return taosEncodeFixedU64(buf, ZIGZAGE(int64_t, value));	75,886,424✔
200	}
201
202	static FORCE_INLINE void taosDecodeFixedI64(const void buf, int64_t *value) {
203	uint64_t tvalue = 0;	17,164,523✔
204	void *ret = taosDecodeFixedU64(buf, &tvalue);	17,164,523✔
205	*value = ZIGZAGD(int64_t, tvalue);	17,164,523✔
206	return ret;	17,164,523✔
207	}
208
209	// ---- Variant U16
210	static FORCE_INLINE int32_t taosEncodeVariantU16(void **buf, uint16_t value) {
211	int32_t i = 0;
212	while (value >= ENCODE_LIMIT) {
213	if (buf != NULL) ((uint8_t )(buf))[i] = (uint8_t)(value \| ENCODE_LIMIT);
214	value >>= 7;
215	i++;
216	}
217
218	if (buf != NULL) {
219	((uint8_t )(buf))[i] = (uint8_t)value;
220	buf = POINTER_SHIFT(buf, i + 1);
221	}
222
223	return i + 1;
224	}
225
226	static FORCE_INLINE void taosDecodeVariantU16(const void buf, uint16_t *value) {
227	int32_t i = 0;
228	uint16_t tval = 0;
229	*value = 0;
230	while (i < 3) {
231	tval = (uint16_t)(((uint8_t *)buf)[i]);
232	if (tval < ENCODE_LIMIT) {
233	(value) \|= (tval << (7 i));
234	return POINTER_SHIFT(buf, i + 1);
235	} else {
236	(value) \|= ((tval & (ENCODE_LIMIT - 1)) << (7 i));
237	i++;
238	}
239	}
240
241	return NULL; // error happened
242	}
243
244	// ---- Variant I16
245	static FORCE_INLINE int32_t taosEncodeVariantI16(void **buf, int16_t value) {
246	return taosEncodeVariantU16(buf, ZIGZAGE(int16_t, value));
247	}
248
249	static FORCE_INLINE void taosDecodeVariantI16(const void buf, int16_t *value) {
250	uint16_t tvalue = 0;
251	void *ret = taosDecodeVariantU16(buf, &tvalue);
252	*value = ZIGZAGD(int16_t, tvalue);
253	return ret;
254	}
255
256	// ---- Variant U32
257	static FORCE_INLINE int32_t taosEncodeVariantU32(void **buf, uint32_t value) {
258	int32_t i = 0;	22,048,115✔
259	while (value >= ENCODE_LIMIT) {	22,048,115✔
260	if (buf != NULL) ((uint8_t )(buf))[i] = (value \| ENCODE_LIMIT);	×
261	value >>= 7;	×
262	i++;	×
263	}
264
265	if (buf != NULL) {	22,048,115✔
266	((uint8_t )(buf))[i] = value;	21,613,777✔
267	buf = POINTER_SHIFT(buf, i + 1);	21,613,777✔
268	}
269
270	return i + 1;	22,048,115✔
271	}
272
273	static FORCE_INLINE void taosDecodeVariantU32(const void buf, uint32_t *value) {
274	int32_t i = 0;	2,147,483,647✔
275	uint32_t tval = 0;	2,147,483,647✔
276	*value = 0;	2,147,483,647✔
277	while (i < 5) {	2,147,483,647✔
278	tval = (uint32_t)(((uint8_t *)buf)[i]);	2,147,483,647✔
279	if (tval < ENCODE_LIMIT) {	2,147,483,647✔
280	(value) \|= (tval << (7 i));	2,147,483,647✔
281	return POINTER_SHIFT(buf, i + 1);	2,147,483,647✔
282	} else {
283	(value) \|= ((tval & (ENCODE_LIMIT - 1)) << (7 i));	×
284	i++;	×
285	}
286	}
287
288	return NULL; // error happened	×
289	}
290
291	// ---- Variant I32
292	static FORCE_INLINE int32_t taosEncodeVariantI32(void **buf, int32_t value) {
293	return taosEncodeVariantU32(buf, ZIGZAGE(int32_t, value));	44,096,230✔
294	}
295
296	static FORCE_INLINE void taosDecodeVariantI32(const void buf, int32_t *value) {
297	uint32_t tvalue = 0;	2,147,483,647✔
298	void *ret = taosDecodeVariantU32(buf, &tvalue);	2,147,483,647✔
299	*value = ZIGZAGD(int32_t, tvalue);	2,147,483,647✔
300	return ret;	2,147,483,647✔
301	}
302
303	// ---- Variant U64
304	static FORCE_INLINE int32_t taosEncodeVariantU64(void **buf, uint64_t value) {
305	int32_t i = 0;	69,576,411✔
306	while (value >= ENCODE_LIMIT) {	107,426,251✔
307	if (buf != NULL) ((uint8_t )(buf))[i] = (uint8_t)(value \| ENCODE_LIMIT);	37,849,840✔
308	value >>= 7;	37,849,840✔
309	i++;	37,849,840✔
310	}
311
312	if (buf != NULL) {	69,576,411✔
313	((uint8_t )(buf))[i] = (uint8_t)value;	45,409,854✔
314	buf = POINTER_SHIFT(buf, i + 1);	45,409,854✔
315	}
316
317	return i + 1;	69,575,737✔
318	}
319
320	static FORCE_INLINE void taosDecodeVariantU64(const void buf, uint64_t *value) {
321	int32_t i = 0;	2,147,483,647✔
322	uint64_t tval = 0;	2,147,483,647✔
323	*value = 0;	131,917,423✔
324	while (i < 10) {	2,147,483,647✔
325	tval = (uint64_t)(((uint8_t *)buf)[i]);	2,147,483,647✔
326	if (tval < ENCODE_LIMIT) {	2,147,483,647✔
327	(value) \|= (tval << (7 i));	2,147,483,647✔
328	return POINTER_SHIFT(buf, i + 1);	2,147,483,647✔
329	} else {
330	(value) \|= ((tval & (ENCODE_LIMIT - 1)) << (7 i));	2,147,483,647✔
331	i++;	2,147,483,647✔
332	}
333	}
334
335	return NULL; // error happened	×
336	}
337
338	// ---- Variant I64
339	static FORCE_INLINE int32_t taosEncodeVariantI64(void **buf, int64_t value) {
340	return taosEncodeVariantU64(buf, ZIGZAGE(int64_t, value));	42,436,618✔
341	}
342
343	static FORCE_INLINE void taosDecodeVariantI64(const void buf, int64_t *value) {
344	uint64_t tvalue = 0;	2,147,483,647✔
345	void *ret = taosDecodeVariantU64(buf, &tvalue);	2,147,483,647✔
346	*value = ZIGZAGD(int64_t, tvalue);	2,147,483,647✔
347	return ret;	2,147,483,647✔
348	}
349
350	// ---- string
351	static FORCE_INLINE int32_t taosEncodeString(void *buf, const char value) {
352	int32_t tlen = 0;	48,333,436✔
353	size_t size = strlen(value);	48,333,436✔
354
355	tlen += taosEncodeVariantU64(buf, size);	48,332,762✔
356	if (buf != NULL) {	48,332,762✔
357	TAOS_MEMCPY(*buf, value, size);	24,166,879✔
358	buf = POINTER_SHIFT(buf, size);	24,166,879✔
359	}
360	tlen += (int32_t)size;	48,332,792✔
361
362	return tlen;	48,332,792✔
363	}
364
365	static FORCE_INLINE void taosDecodeString(const void buf, char **value) {
366	uint64_t size = 0;	843,624✔
367
368	buf = taosDecodeVariantU64(buf, &size);	843,624✔
369	value = (char )taosMemoryMalloc((size_t)size + 1);	843,624✔
370
371	if (*value == NULL) return NULL;	843,624✔
372	TAOS_MEMCPY(*value, buf, (size_t)size);	843,624✔
373
374	(*value)[size] = '\0';	843,624✔
375
376	return POINTER_SHIFT(buf, size);	843,624✔
377	}
378
379	static FORCE_INLINE void taosDecodeStringTo(const void buf, char *value) {
380	uint64_t size = 0;	21,306,967✔
381
382	buf = taosDecodeVariantU64(buf, &size);	21,306,967✔
383	TAOS_MEMCPY(value, buf, (size_t)size);	21,306,967✔
384
385	value[size] = '\0';	21,306,967✔
386
387	return POINTER_SHIFT(buf, size);	21,306,967✔
388	}
389
390	// ---- binary
391	static FORCE_INLINE int32_t taosEncodeBinary(void *buf, const void value, int32_t valueLen) {
392	int32_t tlen = 0;	36,251,342✔
393
394	if (buf != NULL) {	36,251,342✔
395	TAOS_MEMCPY(*buf, value, valueLen);	28,719,777✔
396	buf = POINTER_SHIFT(buf, valueLen);	28,719,777✔
397	}
398	tlen += (int32_t)valueLen;	36,251,342✔
399
400	return tlen;	36,251,342✔
401	}
402
403	static FORCE_INLINE void taosDecodeBinary(const void buf, void **value, int32_t valueLen) {
404	*value = taosMemoryMalloc((size_t)valueLen);	6,719,159✔
405	if (*value == NULL) return NULL;	6,720,290✔
406	TAOS_MEMCPY(*value, buf, (size_t)valueLen);	6,720,290✔
407
408	return POINTER_SHIFT(buf, valueLen);	6,720,290✔
409	}
410
411	static FORCE_INLINE void taosDecodeBinaryTo(const void buf, void *value, int32_t valueLen) {
412	TAOS_MEMCPY(value, buf, (size_t)valueLen);	249,888✔
413	return POINTER_SHIFT(buf, valueLen);	249,888✔
414	}
415
416	#endif
417
418	#ifdef __cplusplus
419	}
420	#endif
421
422	#endif /_TD_UTIL_CODING_H_/

taosdata / TDengine / #4961

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