• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

taosdata / TDengine / #4794

15 Oct 2025 11:06AM UTC coverage: 60.905% (-0.001%) from 60.906%
#4794

push

travis-ci

web-flow
Merge c54016657 into 7e74ade39

154617 of 324341 branches covered (47.67%)

Branch coverage included in aggregate %.

54 of 65 new or added lines in 13 files covered. (83.08%)

2506 existing lines in 114 files now uncovered.

207077 of 269525 relevant lines covered (76.83%)

125143530.79 hits per line

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

61.76
/include/util/tcoding.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) {
17,980,996!
50
    ((int8_t *)(*buf))[0] = value;
8,994,697✔
51
    *buf = POINTER_SHIFT(*buf, sizeof(value));
8,994,697✔
52
  }
53
  return (int32_t)sizeof(value);
17,981,216✔
54
}
55

56
static FORCE_INLINE void *taosDecodeFixedI8(const void *buf, int8_t *value) {
57
  *value = ((int8_t *)buf)[0];
8,050,686✔
58
  return POINTER_SHIFT(buf, sizeof(*value));
8,050,686✔
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) {
1,098,079✔
67
    ((int8_t *)(*buf))[0] = (value ? 1 : 0);
549,360✔
68
    *buf = POINTER_SHIFT(*buf, sizeof(int8_t));
549,360✔
69
  }
70
  return (int32_t)sizeof(int8_t);
1,098,079✔
71
}
72

73
static FORCE_INLINE void *taosDecodeFixedBool(const void *buf, bool *value) {
74
  *value = ((((int8_t *)buf)[0] == 0) ? false : true);
630,709✔
75
  return POINTER_SHIFT(buf, sizeof(int8_t));
630,709✔
76
}
77

78
// ---- Fixed U16
79
static FORCE_INLINE int32_t taosEncodeFixedU16(void **buf, uint16_t value) {
80
  if (buf != NULL) {
12,244,143✔
81
    if (IS_LITTLE_ENDIAN()) {
6,793,483!
82
      TAOS_MEMCPY(*buf, &value, sizeof(value));
6,793,663✔
83
    } else {
UNCOV
84
      ((uint8_t *)(*buf))[0] = value & 0xff;
×
UNCOV
85
      ((uint8_t *)(*buf))[1] = (value >> 8) & 0xff;
×
86
    }
87
    *buf = POINTER_SHIFT(*buf, sizeof(value));
6,793,593✔
88
  }
89

90
  return (int32_t)sizeof(value);
13,582,317✔
91
}
92

93
static FORCE_INLINE void *taosDecodeFixedU16(const void *buf, uint16_t *value) {
94
  if (IS_LITTLE_ENDIAN()) {
6,302,981!
95
    TAOS_MEMCPY(value, buf, sizeof(*value));
6,397,010✔
96
  } else {
97
    ((uint8_t *)value)[1] = ((uint8_t *)buf)[0];
×
98
    ((uint8_t *)value)[0] = ((uint8_t *)buf)[1];
×
99
  }
100

101
  return POINTER_SHIFT(buf, sizeof(*value));
6,396,982✔
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));
12,072,324✔
107
}
108

109
static FORCE_INLINE void *taosDecodeFixedI16(const void *buf, int16_t *value) {
110
  uint16_t tvalue = 0;
2,955,037!
111
  void    *ret = taosDecodeFixedU16(buf, &tvalue);
2,955,037✔
112
  *value = ZIGZAGD(int16_t, tvalue);
2,955,037✔
113
  return ret;
2,955,037✔
114
}
115

116
// ---- Fixed U32
117
static FORCE_INLINE int32_t taosEncodeFixedU32(void **buf, uint32_t value) {
118
  if (buf != NULL) {
19,872,757!
119
    if (IS_LITTLE_ENDIAN()) {
10,518,790!
120
      TAOS_MEMCPY(*buf, &value, sizeof(value));
10,519,010✔
121
    } else {
122
      ((uint8_t *)(*buf))[0] = value & 0xff;
14✔
123
      ((uint8_t *)(*buf))[1] = (value >> 8) & 0xff;
14✔
124
      ((uint8_t *)(*buf))[2] = (value >> 16) & 0xff;
14✔
125
      ((uint8_t *)(*buf))[3] = (value >> 24) & 0xff;
14✔
126
    }
127
    *buf = POINTER_SHIFT(*buf, sizeof(value));
10,519,010✔
128
  }
129

130
  return (int32_t)sizeof(value);
19,872,977✔
131
}
132

133
static FORCE_INLINE void *taosDecodeFixedU32(const void *buf, uint32_t *value) {
134
  if (IS_LITTLE_ENDIAN()) {
8,404,458!
135
    TAOS_MEMCPY(value, buf, sizeof(*value));
8,404,651✔
136
  } else {
137
    ((uint8_t *)value)[3] = ((uint8_t *)buf)[0];
×
138
    ((uint8_t *)value)[2] = ((uint8_t *)buf)[1];
×
139
    ((uint8_t *)value)[1] = ((uint8_t *)buf)[2];
×
140
    ((uint8_t *)value)[0] = ((uint8_t *)buf)[3];
×
141
  }
142

143
  return POINTER_SHIFT(buf, sizeof(*value));
8,404,458✔
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));
37,419,620✔
149
}
150

151
static FORCE_INLINE void *taosDecodeFixedI32(const void *buf, int32_t *value) {
152
  uint32_t tvalue = 0;
8,010,729!
153
  void    *ret = taosDecodeFixedU32(buf, &tvalue);
8,010,729✔
154
  *value = ZIGZAGD(int32_t, tvalue);
8,010,729✔
155
  return ret;
8,010,729✔
156
}
157

158
// ---- Fixed U64
159
static FORCE_INLINE int32_t taosEncodeFixedU64(void **buf, uint64_t value) {
160
  if (buf != NULL) {
9,449,742!
161
    if (IS_LITTLE_ENDIAN()) {
4,834,310!
162
      TAOS_MEMCPY(*buf, &value, sizeof(value));
4,834,253✔
163
    } else {
164
      ((uint8_t *)(*buf))[0] = value & 0xff;
71✔
165
      ((uint8_t *)(*buf))[1] = (value >> 8) & 0xff;
71✔
166
      ((uint8_t *)(*buf))[2] = (value >> 16) & 0xff;
71✔
167
      ((uint8_t *)(*buf))[3] = (value >> 24) & 0xff;
71✔
168
      ((uint8_t *)(*buf))[4] = (value >> 32) & 0xff;
71✔
169
      ((uint8_t *)(*buf))[5] = (value >> 40) & 0xff;
71✔
170
      ((uint8_t *)(*buf))[6] = (value >> 48) & 0xff;
71✔
171
      ((uint8_t *)(*buf))[7] = (value >> 56) & 0xff;
71✔
172
    }
173

174
    *buf = POINTER_SHIFT(*buf, sizeof(value));
4,834,310✔
175
  }
176

177
  return (int32_t)sizeof(value);
9,449,742✔
178
}
179

180
static FORCE_INLINE void *taosDecodeFixedU64(const void *buf, uint64_t *value) {
181
  if (IS_LITTLE_ENDIAN()) {
4,698,571!
182
    TAOS_MEMCPY(value, buf, sizeof(*value));
5,161,599✔
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));
5,161,571✔
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));
18,464,516✔
200
}
201

202
static FORCE_INLINE void *taosDecodeFixedI64(const void *buf, int64_t *value) {
203
  uint64_t tvalue = 0;
4,326,542!
204
  void    *ret = taosDecodeFixedU64(buf, &tvalue);
4,326,542✔
205
  *value = ZIGZAGD(int64_t, tvalue);
4,326,542✔
206
  return ret;
4,326,542✔
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;
701,540✔
259
  while (value >= ENCODE_LIMIT) {
701,540!
260
    if (buf != NULL) ((uint8_t *)(*buf))[i] = (value | ENCODE_LIMIT);
×
261
    value >>= 7;
×
262
    i++;
×
263
  }
264

265
  if (buf != NULL) {
701,540!
266
    ((uint8_t *)(*buf))[i] = value;
362,906✔
267
    *buf = POINTER_SHIFT(*buf, i + 1);
363,016✔
268
  }
269

270
  return i + 1;
701,540✔
271
}
272

273
static FORCE_INLINE void *taosDecodeVariantU32(const void *buf, uint32_t *value) {
274
  int32_t  i = 0;
401,060✔
275
  uint32_t tval = 0;
401,060✔
276
  *value = 0;
741,922✔
277
  while (i < 5) {
401,060!
278
    tval = (uint32_t)(((uint8_t *)buf)[i]);
401,060✔
279
    if (tval < ENCODE_LIMIT) {
401,060!
280
      (*value) |= (tval << (7 * i));
401,060!
281
      return POINTER_SHIFT(buf, i + 1);
401,060✔
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));
1,403,080✔
294
}
295

296
static FORCE_INLINE void *taosDecodeVariantI32(const void *buf, int32_t *value) {
297
  uint32_t tvalue = 0;
401,060✔
298
  void    *ret = taosDecodeVariantU32(buf, &tvalue);
401,060✔
299
  *value = ZIGZAGD(int32_t, tvalue);
401,060✔
300
  return ret;
401,060✔
301
}
302

303
// ---- Variant U64
304
static FORCE_INLINE int32_t taosEncodeVariantU64(void **buf, uint64_t value) {
305
  int32_t i = 0;
14,928,623✔
306
  while (value >= ENCODE_LIMIT) {
15,283,215!
307
    if (buf != NULL) ((uint8_t *)(*buf))[i] = (uint8_t)(value | ENCODE_LIMIT);
354,592!
308
    value >>= 7;
354,592✔
309
    i++;
354,592✔
310
  }
311

312
  if (buf != NULL) {
14,928,623✔
313
    ((uint8_t *)(*buf))[i] = (uint8_t)value;
7,504,172✔
314
    *buf = POINTER_SHIFT(*buf, i + 1);
7,504,172✔
315
  }
316

317
  return i + 1;
14,928,733✔
318
}
319

320
static FORCE_INLINE void *taosDecodeVariantU64(const void *buf, uint64_t *value) {
321
  int32_t  i = 0;
6,496,430✔
322
  uint64_t tval = 0;
6,496,430✔
323
  *value = 0;
9,937,612✔
324
  while (i < 10) {
6,625,489!
325
    tval = (uint64_t)(((uint8_t *)buf)[i]);
6,625,489✔
326
    if (tval < ENCODE_LIMIT) {
6,625,489!
327
      (*value) |= (tval << (7 * i));
6,496,430!
328
      return POINTER_SHIFT(buf, i + 1);
6,496,430✔
329
    } else {
330
      (*value) |= ((tval & (ENCODE_LIMIT - 1)) << (7 * i));
129,059!
331
      i++;
129,059✔
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));
118,320✔
341
}
342

343
static FORCE_INLINE void *taosDecodeVariantI64(const void *buf, int64_t *value) {
344
  uint64_t tvalue = 0;
59,160✔
345
  void    *ret = taosDecodeVariantU64(buf, &tvalue);
59,160✔
346
  *value = ZIGZAGD(int64_t, tvalue);
59,160✔
347
  return ret;
59,160✔
348
}
349

350
// ---- string
351
static FORCE_INLINE int32_t taosEncodeString(void **buf, const char *value) {
352
  int32_t tlen = 0;
14,848,583✔
353
  size_t  size = strlen(value);
14,848,583!
354

355
  tlen += taosEncodeVariantU64(buf, size);
14,848,693✔
356
  if (buf != NULL) {
14,848,693✔
357
    TAOS_MEMCPY(*buf, value, size);
7,424,352!
358
    *buf = POINTER_SHIFT(*buf, size);
7,424,352✔
359
  }
360
  tlen += (int32_t)size;
14,848,583✔
361

362
  return tlen;
14,848,583✔
363
}
364

365
static FORCE_INLINE void *taosDecodeString(const void *buf, char **value) {
366
  uint64_t size = 0;
351,151✔
367

368
  buf = taosDecodeVariantU64(buf, &size);
351,151✔
369
  *value = (char *)taosMemoryMalloc((size_t)size + 1);
351,151!
370

371
  if (*value == NULL) return NULL;
351,151!
372
  TAOS_MEMCPY(*value, buf, (size_t)size);
351,151!
373

374
  (*value)[size] = '\0';
351,151✔
375

376
  return POINTER_SHIFT(buf, size);
351,151✔
377
}
378

379
static FORCE_INLINE void *taosDecodeStringTo(const void *buf, char *value) {
380
  uint64_t size = 0;
6,086,119✔
381

382
  buf = taosDecodeVariantU64(buf, &size);
6,086,119✔
383
  TAOS_MEMCPY(value, buf, (size_t)size);
6,086,119!
384

385
  value[size] = '\0';
6,086,119✔
386

387
  return POINTER_SHIFT(buf, size);
6,086,119✔
388
}
389

390
// ---- binary
391
static FORCE_INLINE int32_t taosEncodeBinary(void **buf, const void *value, int32_t valueLen) {
392
  int32_t tlen = 0;
6,841,009✔
393

394
  if (buf != NULL) {
6,841,009!
395
    TAOS_MEMCPY(*buf, value, valueLen);
3,433,131!
396
    *buf = POINTER_SHIFT(*buf, valueLen);
3,433,131✔
397
  }
398
  tlen += (int32_t)valueLen;
6,841,009✔
399

400
  return tlen;
6,841,009✔
401
}
402

403
static FORCE_INLINE void *taosDecodeBinary(const void *buf, void **value, int32_t valueLen) {
404
  *value = taosMemoryMalloc((size_t)valueLen);
1,611,330!
405
  if (*value == NULL) return NULL;
1,611,549!
406
  TAOS_MEMCPY(*value, buf, (size_t)valueLen);
1,611,549!
407

408
  return POINTER_SHIFT(buf, valueLen);
1,611,549✔
409
}
410

411
static FORCE_INLINE void *taosDecodeBinaryTo(const void *buf, void *value, int32_t valueLen) {
412
  TAOS_MEMCPY(value, buf, (size_t)valueLen);
38,160!
413
  return POINTER_SHIFT(buf, valueLen);
38,160✔
414
}
415

416
#endif
417

418
#ifdef __cplusplus
419
}
420
#endif
421

422
#endif /*_TD_UTIL_CODING_H_*/
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc