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

taosdata / TDengine / #4792

15 Oct 2025 05:45AM UTC coverage: 60.915% (-0.08%) from 60.992%
#4792

push

travis-ci

web-flow
Merge 4a01db54d into 19574fe21

154646 of 324376 branches covered (47.67%)

Branch coverage included in aggregate %.

31 of 62 new or added lines in 4 files covered. (50.0%)

440 existing lines in 117 files now uncovered.

207143 of 269552 relevant lines covered (76.85%)

127426675.82 hits per line

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

64.72
/source/libs/function/src/detail/tavgfunction.c
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
#include "builtinsimpl.h"
17
#include "function.h"
18
#include "tdatablock.h"
19
#include "tfunctionInt.h"
20
#include "tglobal.h"
21

22
#define SET_VAL(_info, numOfElem, res) \
23
  do {                                 \
24
    if ((numOfElem) <= 0) {            \
25
      break;                           \
26
    }                                  \
27
    (_info)->numOfRes = (res);         \
28
  } while (0)
29

30
#define LIST_AVG_N(sumT, T)                                               \
31
  do {                                                                    \
32
    T* plist = (T*)pCol->pData;                                           \
33
    for (int32_t i = start; i < numOfRows + pInput->startRowIndex; ++i) { \
34
      if (colDataIsNull_f(pCol, i)) {                         \
35
        continue;                                                         \
36
      }                                                                   \
37
                                                                          \
38
      numOfElem += 1;                                                     \
39
      pAvgRes->count -= 1;                                                \
40
      sumT -= plist[i];                                                   \
41
    }                                                                     \
42
  } while (0)
43

44
// define signed number sum with check overflow
45
#define CHECK_OVERFLOW_SUM_SIGNED(pAvgRes, val)                                    \
46
  do {                                                                             \
47
    SAvgRes* out = pAvgRes;                                                        \
48
    if (out->sum.overflow) {                                                       \
49
      out->sum.dsum += val;                                                        \
50
    } else if (out->sum.isum > 0 && val > 0 && INT64_MAX - out->sum.isum <= val || \
51
               out->sum.isum < 0 && val < 0 && INT64_MIN - out->sum.isum >= val) { \
52
      double dsum = (double)out->sum.isum;                                         \
53
      out->sum.overflow = true;                                                    \
54
      out->sum.dsum = dsum + val;                                                  \
55
    } else {                                                                       \
56
      out->sum.isum += val;                                                        \
57
    }                                                                              \
58
  } while (0)
59

60
// val is big than INT64_MAX, val come from merge
61
#define CHECK_OVERFLOW_SUM_SIGNED_BIG(pAvgRes, val, big)                                  \
62
  do {                                                                                    \
63
    SAvgRes* out = pAvgRes;                                                               \
64
    if (out->sum.overflow) {                                                              \
65
      out->sum.dsum += val;                                                               \
66
    } else if (out->sum.isum > 0 && val > 0 && INT64_MAX - out->sum.isum <= val ||        \
67
               out->sum.isum < 0 && val < 0 && INT64_MIN - out->sum.isum >= val || big) { \
68
      double dsum = (double)out->sum.isum;                                                \
69
      out->sum.overflow = true;                                                           \
70
      out->sum.dsum = dsum + val;                                                         \
71
    } else {                                                                              \
72
      SUM_RES_INC_ISUM(&AVG_RES_GET_SUM(out), val);                                       \
73
    }                                                                                     \
74
  } while (0)
75

76
// define unsigned number sum with check overflow
77
#define CHECK_OVERFLOW_SUM_UNSIGNED(pAvgRes, val)   \
78
  do {                                              \
79
    SAvgRes* out = pAvgRes;                         \
80
    if (out->sum.overflow) {                        \
81
      out->sum.dsum += val;                         \
82
    } else if (UINT64_MAX - out->sum.usum <= val) { \
83
      double dsum = (double)out->sum.usum;          \
84
      out->sum.overflow = true;                     \
85
      out->sum.dsum = dsum + val;                   \
86
    } else {                                        \
87
      out->sum.usum += val;                         \
88
    }                                               \
89
  } while (0)
90

91
// val is big than UINT64_MAX, val come from merge
92
#define CHECK_OVERFLOW_SUM_UNSIGNED_BIG(pAvgRes, val, big) \
93
  do {                                                     \
94
    SAvgRes* out = pAvgRes;                                \
95
    if (out->sum.overflow) {                               \
96
      out->sum.dsum += val;                                \
97
    } else if (UINT64_MAX - out->sum.usum <= val || big) { \
98
      double dsum = (double)out->sum.usum;                 \
99
      out->sum.overflow = true;                            \
100
      out->sum.dsum = dsum + val;                          \
101
    } else {                                               \
102
      out->sum.usum += val;                                \
103
    }                                                      \
104
  } while (0)
105

106
int32_t getAvgInfoSize(SFunctionNode* pFunc) {
10,591,765✔
107
  if (pFunc->pSrcFuncRef) return AVG_RES_GET_SIZE(pFunc->pSrcFuncRef->srcFuncInputType.type);
10,591,765✔
108
  return AVG_RES_GET_SIZE(pFunc->srcFuncInputType.type);
8,125,823!
109
}
110

111
bool getAvgFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
8,124,416✔
112
  pEnv->calcMemSize =getAvgInfoSize(pFunc);
8,124,416✔
113
  return true;
8,126,809✔
114
}
115

116
int32_t avgFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
1,560,214,819✔
117
  if (pResultInfo->initialized) {
1,560,214,819!
118
    return TSDB_CODE_SUCCESS;
×
119
  }
120
  if (TSDB_CODE_SUCCESS != functionSetup(pCtx, pResultInfo)) {
1,563,090,730!
121
    return TSDB_CODE_FUNC_SETUP_ERROR;
×
122
  }
123

124
  void* pRes = GET_ROWCELL_INTERBUF(pResultInfo);
1,565,987,803✔
125
  (void)memset(pRes, 0, pCtx->resDataInfo.interBufSize);
1,566,166,083!
126
  return TSDB_CODE_SUCCESS;
1,558,903,383✔
127
}
128

129
static int32_t calculateAvgBySMAInfo(void* pRes, int32_t numOfRows, int32_t type, const SColumnDataAgg* pAgg, int32_t* pNumOfElem) {
1,603,498✔
130
  int32_t numOfElem = numOfRows - pAgg->numOfNull;
1,603,498✔
131

132
  AVG_RES_INC_COUNT(pRes, type, numOfElem);
1,603,498!
133
  if (IS_SIGNED_NUMERIC_TYPE(type)) {
1,603,498!
134
    CHECK_OVERFLOW_SUM_SIGNED(pRes, pAgg->sum);
1,393,650!
135
  } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
209,848!
136
    CHECK_OVERFLOW_SUM_UNSIGNED(pRes, pAgg->sum);
×
137
  } else if (IS_FLOAT_TYPE(type)) {
209,848!
138
    SUM_RES_INC_DSUM(&AVG_RES_GET_SUM(pRes), GET_DOUBLE_VAL((const char*)&(pAgg->sum)));
209,848✔
139
  } else if (IS_DECIMAL_TYPE(type)) {
×
140
    bool overflow = pAgg->overflow;
×
141
    if (overflow) return TSDB_CODE_DECIMAL_OVERFLOW;
×
142
    SUM_RES_INC_DECIMAL_SUM(&AVG_RES_GET_DECIMAL_SUM(pRes), &pAgg->decimal128Sum, TSDB_DATA_TYPE_DECIMAL);
×
143
    if (overflow) return TSDB_CODE_DECIMAL_OVERFLOW;
×
144
  }
145

146
  *pNumOfElem = numOfElem;
1,603,102✔
147
  return 0;
1,603,498✔
148
}
149

150
static int32_t doAddNumericVector(SColumnInfoData* pCol, int32_t type, SInputColumnInfoData *pInput, void* pRes, int32_t* pNumOfElem) {
2,147,483,647✔
151
  int32_t start = pInput->startRowIndex;
2,147,483,647✔
152
  int32_t numOfRows = pInput->numOfRows;
2,147,483,647✔
153
  int32_t numOfElems = 0;
2,147,483,647✔
154

155
  switch (type) {
2,147,483,647!
156
    case TSDB_DATA_TYPE_TINYINT: {
1,220,936,970✔
157
      int8_t* plist = (int8_t*)pCol->pData;
1,220,936,970✔
158
      for (int32_t i = start; i < numOfRows + start; ++i) {
2,147,483,647✔
159
        if (colDataIsNull_f(pCol, i)) {
2,147,483,647!
160
          continue;
1,608,251,854✔
161
        }
162

163
        numOfElems += 1;
836,642,807✔
164
        AVG_RES_INC_COUNT(pRes, TSDB_DATA_TYPE_TINYINT, 1);
836,642,807✔
165
        CHECK_OVERFLOW_SUM_SIGNED(pRes, plist[i]);
836,643,051!
166
      }
167

168
      break;
1,220,937,458✔
169
    }
170

171
    case TSDB_DATA_TYPE_SMALLINT: {
866,555,184✔
172
      int16_t* plist = (int16_t*)pCol->pData;
866,555,184✔
173
      for (int32_t i = start; i < numOfRows + start; ++i) {
2,147,483,647✔
174
        if (colDataIsNull_f(pCol, i)) {
1,966,698,626!
175
          continue;
1,289,751,510✔
176
        }
177

178
        numOfElems += 1;
676,947,116✔
179
        AVG_RES_INC_COUNT(pRes, TSDB_DATA_TYPE_SMALLINT, 1);
676,947,116✔
180
        CHECK_OVERFLOW_SUM_SIGNED(pRes, plist[i]);
676,947,116!
181
      }
182
      break;
866,555,184✔
183
    }
184

185
    case TSDB_DATA_TYPE_INT: {
917,485,385✔
186
      int32_t* plist = (int32_t*)pCol->pData;
917,485,385✔
187
      for (int32_t i = start; i < numOfRows + start; ++i) {
2,147,483,647✔
188
        if (colDataIsNull_f(pCol, i)) {
2,147,483,647!
189
          continue;
1,200,745,585✔
190
        }
191

192
        numOfElems += 1;
1,156,009,516✔
193
        AVG_RES_INC_COUNT(pRes, TSDB_DATA_TYPE_INT, 1);
1,156,009,516✔
194
        CHECK_OVERFLOW_SUM_SIGNED(pRes, plist[i]);
1,156,010,055!
195
      }
196

197
      break;
917,484,368✔
198
    }
199

200
    case TSDB_DATA_TYPE_BIGINT: {
1,515,349,382✔
201
      int64_t* plist = (int64_t*)pCol->pData;
1,515,349,382✔
202
      for (int32_t i = start; i < numOfRows + start; ++i) {
2,147,483,647✔
203
        if (colDataIsNull_f(pCol, i)) {
2,147,483,647!
204
          continue;
1,786,852,772✔
205
        }
206

207
        numOfElems += 1;
881,136,580✔
208
        AVG_RES_INC_COUNT(pRes, TSDB_DATA_TYPE_BIGINT, 1);
881,136,580✔
209
        CHECK_OVERFLOW_SUM_SIGNED(pRes, plist[i]);
881,136,824!
210
      }
211
      break;
1,516,386,733✔
212
    }
213

214
    case TSDB_DATA_TYPE_UTINYINT: {
866,121,124✔
215
      uint8_t* plist = (uint8_t*)pCol->pData;
866,121,124✔
216
      for (int32_t i = start; i < numOfRows + start; ++i) {
2,147,483,647✔
217
        if (colDataIsNull_f(pCol, i)) {
1,964,598,968!
218
          continue;
1,107,918,968✔
219
        }
220

221
        numOfElems += 1;
856,680,000✔
222
        AVG_RES_INC_COUNT(pRes, TSDB_DATA_TYPE_UTINYINT, 1);
856,680,000✔
223
        CHECK_OVERFLOW_SUM_UNSIGNED(pRes, plist[i]);
856,680,000!
224
      }
225

226
      break;
866,121,124✔
227
    }
228

229
    case TSDB_DATA_TYPE_USMALLINT: {
866,121,124✔
230
      uint16_t* plist = (uint16_t*)pCol->pData;
866,121,124✔
231
      for (int32_t i = start; i < numOfRows + start; ++i) {
2,147,483,647✔
232
        if (colDataIsNull_f(pCol, i)) {
1,964,598,968!
233
          continue;
1,107,918,968✔
234
        }
235

236
        numOfElems += 1;
856,680,000✔
237
        AVG_RES_INC_COUNT(pRes, TSDB_DATA_TYPE_USMALLINT, 1);
856,680,000✔
238
        CHECK_OVERFLOW_SUM_UNSIGNED(pRes, plist[i]);
856,680,000!
239
      }
240
      break;
866,121,124✔
241
    }
242

243
    case TSDB_DATA_TYPE_UINT: {
1,622,198,567✔
244
      uint32_t* plist = (uint32_t*)pCol->pData;
1,622,198,567✔
245
      for (int32_t i = start; i < numOfRows + start; ++i) {
2,147,483,647✔
246
        if (colDataIsNull_f(pCol, i)) {
2,147,483,647!
247
          continue;
1,618,669,628✔
248
        }
249

250
        numOfElems += 1;
1,687,823,151✔
251
        AVG_RES_INC_COUNT(pRes, TSDB_DATA_TYPE_UINT, 1);
1,687,823,151✔
252
        CHECK_OVERFLOW_SUM_UNSIGNED(pRes, plist[i]);
1,687,823,151!
253
      }
254

255
      break;
1,622,198,567✔
256
    }
257

258
    case TSDB_DATA_TYPE_UBIGINT: {
866,125,510✔
259
      uint64_t* plist = (uint64_t*)pCol->pData;
866,125,510✔
260
      for (int32_t i = start; i < numOfRows + start; ++i) {
2,147,483,647✔
261
        if (colDataIsNull_f(pCol, i)) {
1,964,605,990!
262
          continue;
1,288,322,036✔
263
        }
264

265
        numOfElems += 1;
676,283,954✔
266
        AVG_RES_INC_COUNT(pRes, TSDB_DATA_TYPE_UBIGINT, 1);
676,283,954✔
267
        CHECK_OVERFLOW_SUM_UNSIGNED(pRes, plist[i]);
676,283,954!
268
        
269
      }
270
      break;
866,125,510✔
271
    }
272

273
    case TSDB_DATA_TYPE_FLOAT: {
889,615,785✔
274
      float* plist = (float*)pCol->pData;
889,615,785✔
275
      for (int32_t i = start; i < numOfRows + start; ++i) {
2,147,483,647✔
276
        if (colDataIsNull_f(pCol, i)) {
2,046,792,233!
277
          continue;
1,151,232,244✔
278
        }
279

280
        numOfElems += 1;
895,560,044✔
281
        AVG_RES_INC_COUNT(pRes, TSDB_DATA_TYPE_FLOAT, 1);
895,560,044✔
282
        SUM_RES_INC_DSUM(&AVG_RES_GET_SUM(pRes), plist[i]);
895,556,680✔
283
      }
284
      break;
889,612,421✔
285
    }
286

287
    case TSDB_DATA_TYPE_DOUBLE: {
905,854,162✔
288
      double* plist = (double*)pCol->pData;
905,854,162✔
289
      for (int32_t i = start; i < numOfRows + start; ++i) {
2,147,483,647✔
290
        if (colDataIsNull_f(pCol, i)) {
2,147,483,647!
291
          continue;
1,341,279,017✔
292
        }
293

294
        numOfElems += 1;
811,354,205✔
295
        AVG_RES_INC_COUNT(pRes, TSDB_DATA_TYPE_DOUBLE, 1);
811,354,205✔
296
        SUM_RES_INC_DSUM(&AVG_RES_GET_SUM(pRes), plist[i]);
811,354,659✔
297
      }
298
      break;
905,853,867✔
299
    }
300
    case TSDB_DATA_TYPE_DECIMAL64:
×
301
    case TSDB_DATA_TYPE_DECIMAL: {
302
      const char* pDec = pCol->pData;
×
303
      for (int32_t i = start; i < numOfRows + start; ++i) {
×
304
        if (colDataIsNull_f(pCol, i)) {
×
305
          continue;
×
306
        }
307

308
        numOfElems += 1;
×
309
        AVG_RES_INC_COUNT(pRes, type, 1);
×
310
        bool overflow = false;
×
311
        SUM_RES_INC_DECIMAL_SUM(&AVG_RES_GET_DECIMAL_SUM(pRes), (const void*)(pDec + i * tDataTypes[type].bytes), type);
×
312
        if (overflow) return TSDB_CODE_DECIMAL_OVERFLOW;
×
313
      }
314
    } break;
×
315
    default:
×
316
      break;
×
317
  }
318

319
  *pNumOfElem = numOfElems;
2,147,483,647✔
320
  return 0;
2,147,483,647✔
321
}
322

323
int32_t avgFunction(SqlFunctionCtx* pCtx) {
2,147,483,647✔
324
  int32_t       numOfElem = 0;
2,147,483,647✔
325
  const int32_t THRESHOLD_SIZE = 8;
2,147,483,647✔
326

327
  SInputColumnInfoData* pInput = &pCtx->input;
2,147,483,647✔
328
  SColumnDataAgg*       pAgg = pInput->pColumnDataAgg[0];
2,147,483,647✔
329
  int32_t               type = pInput->pData[0]->info.type;
2,147,483,647✔
330
  pCtx->inputType = type;
2,147,483,647✔
331

332
  void* pAvgRes = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
2,147,483,647✔
333

334
  // computing based on the true data block
335
  SColumnInfoData* pCol = pInput->pData[0];
2,147,483,647✔
336

337
  int32_t start = pInput->startRowIndex;
2,147,483,647✔
338
  int32_t numOfRows = pInput->numOfRows;
2,147,483,647✔
339

340
  if (IS_NULL_TYPE(type)) {
2,147,483,647✔
341
    goto _over;
758,970✔
342
  }
343

344
  AVG_RES_SET_TYPE(pAvgRes, pCtx->inputType, type);
2,147,483,647✔
345
  if (IS_DECIMAL_TYPE(type)) AVG_RES_SET_INPUT_SCALE(pAvgRes, pInput->pData[0]->info.scale);
2,147,483,647!
346

347
  if (pInput->colDataSMAIsSet) {  // try to use SMA if available
2,147,483,647!
348
    int32_t code = calculateAvgBySMAInfo(pAvgRes, numOfRows, type, pAgg, &numOfElem);
1,603,498✔
349
    if (code != 0) return code;
1,603,102!
350
  } else if (!pCol->hasNull) {  // try to employ the simd instructions to speed up the loop
2,147,483,647!
351
    numOfElem = pInput->numOfRows;
836,715,755✔
352
    AVG_RES_INC_COUNT(pAvgRes, pCtx->inputType, pInput->numOfRows);
836,652,668✔
353

354
    switch(type) {
836,726,400!
355
      case TSDB_DATA_TYPE_UTINYINT:
321,031✔
356
      case TSDB_DATA_TYPE_TINYINT: {
357
        const int8_t* plist = (const int8_t*) pCol->pData;
321,031✔
358

359
        for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
10,742,092✔
360
          if (type == TSDB_DATA_TYPE_TINYINT) {
10,421,061✔
361
            CHECK_OVERFLOW_SUM_SIGNED(pAvgRes, plist[i]);
8,034,471!
362
          } else {
363
            CHECK_OVERFLOW_SUM_UNSIGNED(pAvgRes, (uint8_t)plist[i]);
2,386,590!
364
          }
365
        }
366
        break;
322,559✔
367
      }
368

369
      case TSDB_DATA_TYPE_USMALLINT:
1,536,358✔
370
      case TSDB_DATA_TYPE_SMALLINT: {
371
        const int16_t* plist = (const int16_t*)pCol->pData;
1,536,358✔
372

373
        for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
14,480,942✔
374
          if (type == TSDB_DATA_TYPE_SMALLINT) {
12,944,584✔
375
            CHECK_OVERFLOW_SUM_SIGNED(pAvgRes, plist[i]);
10,557,994!
376
          } else {
377
            CHECK_OVERFLOW_SUM_UNSIGNED(pAvgRes, (uint16_t)plist[i]);
2,386,590!
378
          }
379
        }
380
        break;
1,536,358✔
381
      }
382

383
      case TSDB_DATA_TYPE_UINT:
10,030,769✔
384
      case TSDB_DATA_TYPE_INT: {
385
        const int32_t* plist = (const int32_t*) pCol->pData;
10,030,769✔
386

387
        for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
2,147,483,647✔
388
          if (type == TSDB_DATA_TYPE_INT) {
2,147,483,647✔
389
            CHECK_OVERFLOW_SUM_SIGNED(pAvgRes, plist[i]);
2,147,483,647!
390
          } else {
391
            CHECK_OVERFLOW_SUM_UNSIGNED(pAvgRes, (uint32_t)plist[i]);
9,173,513!
392
          }
393
        }
394
        break;
10,040,553✔
395
      }
396

397
      case TSDB_DATA_TYPE_UBIGINT:
688,411,888✔
398
      case TSDB_DATA_TYPE_BIGINT: {
399
        const int64_t* plist = (const int64_t*) pCol->pData;
688,411,888✔
400

401
        for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
2,047,223,559✔
402
          if (type == TSDB_DATA_TYPE_BIGINT) {
1,358,808,758✔
403
            CHECK_OVERFLOW_SUM_SIGNED(pAvgRes, plist[i]);
1,356,009,608!
404
          } else {
405
            CHECK_OVERFLOW_SUM_UNSIGNED(pAvgRes, (uint64_t)plist[i]);
2,799,150!
406
          }
407
        }
408
        break;
688,453,432✔
409
      }
410

411
      case TSDB_DATA_TYPE_FLOAT: {
36,890,699✔
412
        const float* plist = (const float*) pCol->pData;
36,890,699✔
413

414
        for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
635,651,692✔
415
          SUM_RES_INC_DSUM(&AVG_RES_GET_SUM(pAvgRes), plist[i]);
598,805,315✔
416
        }
417
        break;
36,911,336✔
418
      }
419
      case TSDB_DATA_TYPE_DOUBLE: {
99,535,655✔
420
        const double* plist = (const double*)pCol->pData;
99,535,655✔
421

422
        for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
1,304,018,369✔
423
          SUM_RES_INC_DSUM(&AVG_RES_GET_SUM(pAvgRes), plist[i]);
1,204,487,757✔
424
        }
425
        break;
99,537,804✔
426
      }
427
      case TSDB_DATA_TYPE_DECIMAL:
×
428
      case TSDB_DATA_TYPE_DECIMAL64: {
429
        const char* pDec = pCol->pData;
×
430
        for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
×
431
          bool overflow = false;
×
432
          if (type == TSDB_DATA_TYPE_DECIMAL64) {
×
433
            SUM_RES_INC_DECIMAL_SUM(&AVG_RES_GET_DECIMAL_SUM(pAvgRes), (const void*)(pDec + i * tDataTypes[type].bytes),
×
434
                                    TSDB_DATA_TYPE_DECIMAL64);
435
          } else {
436
            SUM_RES_INC_DECIMAL_SUM(&AVG_RES_GET_DECIMAL_SUM(pAvgRes), (const void*)(pDec + i * tDataTypes[type].bytes),
×
437
                                    TSDB_DATA_TYPE_DECIMAL);
438
          }
439
          if (overflow) return TSDB_CODE_DECIMAL_OVERFLOW;
×
440
        }
441
      } break;
×
442
      default:
×
443
        return TSDB_CODE_FUNC_FUNTION_PARA_TYPE;
×
444
    }
445
  } else {
446
    int32_t code = doAddNumericVector(pCol, type, pInput, pAvgRes, &numOfElem);
2,147,483,647✔
447
    if (code) return code;
2,147,483,647!
448
  }
449

450
_over:
2,147,483,647✔
451
  // data in the check operation are all null, not output
452
  SET_VAL(GET_RES_INFO(pCtx), numOfElem, 1);
2,147,483,647✔
453
  return TSDB_CODE_SUCCESS;
2,147,483,647✔
454
}
455

456
static int32_t avgTransferInfo(SqlFunctionCtx* pCtx, void* pInput, void* pOutput) {
587,846,050✔
457
  int32_t inputDT = pCtx->pExpr->pExpr->_function.pFunctNode->srcFuncInputType.type;
587,846,050✔
458
  int32_t type = AVG_RES_GET_TYPE(pInput, inputDT);
587,846,050!
459
  pCtx->inputType = type;
587,846,050✔
460
  if (IS_NULL_TYPE(type)) {
587,846,050✔
461
    return 0;
609,323✔
462
  }
463

464

465
  AVG_RES_SET_TYPE(pOutput, inputDT, type);
587,236,727!
466
  if (IS_SIGNED_NUMERIC_TYPE(type)) {
1,111,489,460!
467
    bool overflow = AVG_RES_GET_SUM_OVERFLOW(pInput, false, 0);
524,252,733!
468
    CHECK_OVERFLOW_SUM_SIGNED_BIG(pOutput, (overflow ? SUM_RES_GET_DSUM(&AVG_RES_GET_SUM(pInput)) : SUM_RES_GET_ISUM(&AVG_RES_GET_SUM(pInput))), overflow);
524,252,733!
469
  } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
62,998,438!
470
    bool overflow = AVG_RES_GET_SUM_OVERFLOW(pInput, false, 0);
14,444!
471
    CHECK_OVERFLOW_SUM_UNSIGNED_BIG(pOutput, (overflow ? SUM_RES_GET_DSUM(&AVG_RES_GET_SUM(pInput)) : SUM_RES_GET_USUM(&AVG_RES_GET_SUM(pInput))), overflow);
14,444!
472
  } else if (IS_DECIMAL_TYPE(type)) {
62,969,550!
473
    AVG_RES_SET_INPUT_SCALE(pOutput, AVG_RES_GET_INPUT_SCALE(pInput));
×
474
    bool overflow = false;
×
475
    SUM_RES_INC_DECIMAL_SUM(&AVG_RES_GET_DECIMAL_SUM(pOutput), &AVG_RES_GET_DECIMAL_SUM(pInput), TSDB_DATA_TYPE_DECIMAL);
×
476
    if (overflow) return TSDB_CODE_DECIMAL_OVERFLOW;
×
477
  } else {
478
    SUM_RES_INC_DSUM(&AVG_RES_GET_SUM(pOutput), SUM_RES_GET_DSUM(&AVG_RES_GET_SUM(pInput)));
62,969,550✔
479
  }
480

481
  AVG_RES_INC_COUNT(pOutput, type, AVG_RES_GET_COUNT(pInput, true, type));
587,236,727!
482
  return 0;
587,236,727✔
483
}
484

485
int32_t avgFunctionMerge(SqlFunctionCtx* pCtx) {
234,383,347✔
486
  SInputColumnInfoData* pInput = &pCtx->input;
234,383,347✔
487
  SColumnInfoData*      pCol = pInput->pData[0];
234,383,347✔
488

489
  if (IS_NULL_TYPE(pCol->info.type)) {
234,383,347!
490
    SET_VAL(GET_RES_INFO(pCtx), 0, 1);
×
491
    return TSDB_CODE_SUCCESS;
×
492
  }
493

494
  if (pCol->info.type != TSDB_DATA_TYPE_BINARY) {
234,383,347!
495
    return TSDB_CODE_FUNC_FUNTION_PARA_TYPE;
×
496
  }
497

498
  void* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
234,383,347✔
499

500
  int32_t start = pInput->startRowIndex;
234,383,347✔
501

502
  for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
822,229,397✔
503
    if(colDataIsNull_s(pCol, i)) continue;
1,175,692,100!
504
    char*    data = colDataGetData(pCol, i);
587,846,050!
505
    void* pInputInfo = varDataVal(data);
587,846,050✔
506
    int32_t code = avgTransferInfo(pCtx, pInputInfo, pInfo);
587,846,050✔
507
    if (code != 0) return code;
587,846,050!
508
  }
509

510
  SET_VAL(GET_RES_INFO(pCtx), 1, 1);
234,383,347✔
511

512
  return TSDB_CODE_SUCCESS;
234,383,347✔
513
}
514

515
int32_t avgCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
×
516
  SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);
×
517
  void*                pDBuf = GET_ROWCELL_INTERBUF(pDResInfo);
×
518
  int32_t              type = AVG_RES_GET_TYPE(pDBuf, pDestCtx->inputType);
×
519

520
  SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
×
521
  void*                pSBuf = GET_ROWCELL_INTERBUF(pSResInfo);
×
522
  type = (type == TSDB_DATA_TYPE_NULL) ? AVG_RES_GET_TYPE(pSBuf, pDestCtx->inputType) : type;
×
523

524
  if (IS_SIGNED_NUMERIC_TYPE(type)) {
×
525
    CHECK_OVERFLOW_SUM_SIGNED(pDBuf, SUM_RES_GET_ISUM(&AVG_RES_GET_SUM(pSBuf)));
×
526
  } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
×
527
    CHECK_OVERFLOW_SUM_UNSIGNED(pDBuf, SUM_RES_GET_USUM(&AVG_RES_GET_SUM(pSBuf)));
×
528
  } else if (IS_DECIMAL_TYPE(type)) {
×
529
    bool overflow = false;
×
530
    SUM_RES_INC_DECIMAL_SUM(&AVG_RES_GET_DECIMAL_SUM(pDBuf), &SUM_RES_GET_DECIMAL_SUM(&AVG_RES_GET_DECIMAL_SUM(pSBuf)), type);
×
531
    if (overflow) {
532

533
    }
534
  } else {
535
    SUM_RES_INC_DSUM(&AVG_RES_GET_SUM(pDBuf), SUM_RES_GET_DSUM(&AVG_RES_GET_SUM(pSBuf)));
×
536
  }
537
  AVG_RES_INC_COUNT(pDBuf, pDestCtx->inputType, AVG_RES_GET_COUNT(pSBuf, true, pDestCtx->inputType));
×
538

539
  return TSDB_CODE_SUCCESS;
×
540
}
541

542
int32_t avgFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
468,308,266✔
543
  SResultRowEntryInfo* pEntryInfo = GET_RES_INFO(pCtx);
468,308,266✔
544

545
  void*   pRes = GET_ROWCELL_INTERBUF(pEntryInfo);
468,308,802✔
546
  int32_t type = AVG_RES_GET_TYPE(pRes, pCtx->inputType);
468,308,802!
547
  int64_t count = AVG_RES_GET_COUNT(pRes, true, type);
468,308,404!
548

549
  if (AVG_RES_GET_COUNT(pRes, true, pCtx->inputType) > 0) {
468,308,575✔
550
    
551
    if(AVG_RES_GET_SUM_OVERFLOW(pRes, true, pCtx->inputType)) {
406,079,995!
552
      AVG_RES_GET_AVG(pRes) = SUM_RES_GET_DSUM(&AVG_RES_GET_SUM(pRes)) / ((double)AVG_RES_GET_COUNT(pRes, false, 0));
8,624,159!
553
    }else if (IS_SIGNED_NUMERIC_TYPE(type)) {
397,455,527!
554
      AVG_RES_GET_AVG(pRes) = SUM_RES_GET_ISUM(&AVG_RES_GET_SUM(pRes)) / ((double)AVG_RES_GET_COUNT(pRes, false, 0));
219,951,652!
555
    } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
177,503,875!
556
      AVG_RES_GET_AVG(pRes) = SUM_RES_GET_USUM(&AVG_RES_GET_SUM(pRes)) / ((double)AVG_RES_GET_COUNT(pRes, false, 0));
29,756,712!
557
    } else if (IS_DECIMAL_TYPE(type)) {
147,747,163!
UNCOV
558
      int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
×
559
      SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
×
560
      SDataType        sumDt = {.type = TSDB_DATA_TYPE_DECIMAL,
×
561
                                .bytes = tDataTypes[TSDB_DATA_TYPE_DECIMAL].bytes,
×
562
                                .precision = pCol->info.precision,
×
563
                                .scale = AVG_RES_GET_INPUT_SCALE(pRes)};
×
564
      SDataType        countDt = {
×
565
                 .type = TSDB_DATA_TYPE_BIGINT, .bytes = tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes, .precision = 0, .scale = 0};
×
566
      SDataType avgDt = {.type = TSDB_DATA_TYPE_DECIMAL,
×
567
                         .bytes = tDataTypes[TSDB_DATA_TYPE_DECIMAL].bytes,
×
568
                         .precision = pCol->info.precision,
×
569
                         .scale = pCol->info.scale};
×
570
      int64_t   count = AVG_RES_GET_COUNT(pRes, true, type);
×
571
      int32_t   code =
572
          decimalOp(OP_TYPE_DIV, &sumDt, &countDt, &avgDt, &SUM_RES_GET_DECIMAL_SUM(&AVG_RES_GET_DECIMAL_SUM(pRes)),
×
573
                    &count, &AVG_RES_GET_DECIMAL_AVG(pRes));
×
574
      if (code != TSDB_CODE_SUCCESS) {
×
575
        return code;
×
576
      }
577
    } else {
578
      AVG_RES_GET_AVG(pRes) = SUM_RES_GET_DSUM(&AVG_RES_GET_SUM(pRes)) / ((double)AVG_RES_GET_COUNT(pRes, false, 0));
147,747,163!
579
    }
580
  }
581
  if (AVG_RES_GET_COUNT(pRes, true, pCtx->inputType) == 0) {
468,308,039!
582
    pEntryInfo->numOfRes = 0;
62,227,955✔
583
  } else if (!IS_DECIMAL_TYPE(pCtx->inputType)) {
406,079,913!
584
    if (isinf(AVG_RES_GET_AVG(pRes)) || isnan(AVG_RES_GET_AVG(pRes))) pEntryInfo->numOfRes = 0;
406,079,913!
585
  } else {
586
    pEntryInfo->numOfRes = 1;
×
587
  }
588

589
  return functionFinalize(pCtx, pBlock);
468,307,868✔
590
}
591

592
int32_t avgPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
634,669,146✔
593
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
634,669,146✔
594
  void*                pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
634,723,726✔
595
  int32_t              resultBytes = AVG_RES_GET_SIZE(pCtx->inputType);
634,781,722!
596
  char*                res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
634,793,187!
597
  int32_t              code = TSDB_CODE_SUCCESS;
633,503,771✔
598
  if (NULL == res) {
633,503,771!
599
    return terrno;
×
600
  }
601
  (void)memcpy(varDataVal(res), pInfo, resultBytes);
633,503,771!
602
  varDataSetLen(res, resultBytes);
633,472,140✔
603

604
  int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
634,334,750✔
605
  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
634,652,066✔
606
  if(NULL == pCol) {
634,578,646!
607
    code = TSDB_CODE_OUT_OF_RANGE;
×
608
    goto _exit;
×
609
  }
610

611
  code = colDataSetVal(pCol, pBlock->info.rows, res, false);
634,578,646✔
612

613
_exit:
634,700,654✔
614
  taosMemoryFree(res);
634,700,654!
615
  return code;
634,324,952✔
616
}
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