#3653

Committed 14 Mar 2025 08:10AM UTC coverage: 22.565% (-41.0%) from 63.596%

Build # #3653

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

feat(keep): support keep on super table level. (#30097)

* Feat: support use keep while create super table.

* Test(keep): add test for create super table with keep option.

* Feat(keep): Add tmsg for create keep.

* Feat(keep): support alter table option keep.

* Fix(keep): Add baisc test for alter table option.

* Fix(keep): memory leek.

* Feat(keep): add keep to metaEntry&metaCache and fix earliestTs with stn keep.

* Test(keep): add some cases for select with stb keep.

* Fix: fix ci core while alter stb.

* Feat(keep): delete expired data in super table level.

* Feat: remove get stb keep while query.

* Fix : build error.

* Revert "Fix : build error."

This reverts commit 0ed66e4e8.

* Revert "Feat(keep): delete expired data in super table level."

This reverts commit 36330f6b4.

* Fix : build errors.

* Feat : support restart taosd.

* Fix : alter table comment problems.

* Test : add tests for super table keep.

* Fix: change sdb stb reserve size.

* Test: add more tests.

* Feat: Disable normal tables and sub tables from setting the keep parameter

* Fix: add more checks to avoid unknown address.

* Docs: Add docs for stable keep.

* Fix: some review changes.

* Fix: review errors.

Run Details

49248 of 302527 branches covered (16.28%)

Branch coverage included in aggregate %.

53 of 99 new or added lines in 12 files covered. (53.54%)

155872 existing lines in 443 files now uncovered.

87359 of 302857 relevant lines covered (28.84%)

570004.22 hits per line

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

0.15

/source/libs/function/src/detail/tavgfunction.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/>.
 */

#include "builtinsimpl.h"
#include "function.h"
#include "tdatablock.h"
#include "tfunctionInt.h"
#include "tglobal.h"

#define SET_VAL(_info, numOfElem, res) \
  do {                                 \
    if ((numOfElem) <= 0) {            \
      break;                           \
    }                                  \
    (_info)->numOfRes = (res);         \
  } while (0)

#define LIST_AVG_N(sumT, T)                                               \
  do {                                                                    \
    T* plist = (T*)pCol->pData;                                           \
    for (int32_t i = start; i < numOfRows + pInput->startRowIndex; ++i) { \
      if (colDataIsNull_f(pCol->nullbitmap, i)) {                         \
        continue;                                                         \
      }                                                                   \
                                                                          \
      numOfElem += 1;                                                     \
      pAvgRes->count -= 1;                                                \
      sumT -= plist[i];                                                   \
    }                                                                     \
  } while (0)

// define signed number sum with check overflow
#define CHECK_OVERFLOW_SUM_SIGNED(out, val)                                      \
  if (out->sum.overflow) {                                                       \
    out->sum.dsum += val;                                                        \
  } else if (out->sum.isum > 0 && val > 0 && INT64_MAX - out->sum.isum <= val || \
             out->sum.isum < 0 && val < 0 && INT64_MIN - out->sum.isum >= val) { \
    double dsum = (double)out->sum.isum;                                         \
    out->sum.overflow = true;                                                    \
    out->sum.dsum = dsum + val;                                                  \
  } else {                                                                       \
    out->sum.isum += val;                                                        \
  }

// val is big than INT64_MAX, val come from merge
#define CHECK_OVERFLOW_SUM_SIGNED_BIG(out, val, big)                             \
  if (out->sum.overflow) {                                                       \
    out->sum.dsum += val;                                                        \
  } else if (out->sum.isum > 0 && val > 0 && INT64_MAX - out->sum.isum <= val || \
             out->sum.isum < 0 && val < 0 && INT64_MIN - out->sum.isum >= val || \
             big) {                                                              \
    double dsum = (double)out->sum.isum;                                         \
    out->sum.overflow = true;                                                    \
    out->sum.dsum = dsum + val;                                                  \
  } else {                                                                       \
    out->sum.isum += val;                                                        \
  }

// define unsigned number sum with check overflow
#define CHECK_OVERFLOW_SUM_UNSIGNED(out, val)                 \
  if (out->sum.overflow) {                                    \
    out->sum.dsum += val;                                     \
  } else if (UINT64_MAX - out->sum.usum <= val) {             \
    double dsum = (double)out->sum.usum;                      \
    out->sum.overflow = true;                                 \
    out->sum.dsum = dsum + val;                               \
  } else {                                                    \
    out->sum.usum += val;                                     \
  }

// val is big than UINT64_MAX, val come from merge
#define CHECK_OVERFLOW_SUM_UNSIGNED_BIG(out, val, big)        \
  if (out->sum.overflow) {                                    \
    out->sum.dsum += val;                                     \
  } else if (UINT64_MAX - out->sum.usum <= val || big) {      \
    double dsum = (double)out->sum.usum;                      \
    out->sum.overflow = true;                                 \
    out->sum.dsum = dsum + val;                               \
  } else {                                                    \
    out->sum.usum += val;                                     \
  }

int32_t getAvgInfoSize() { return (int32_t)sizeof(SAvgRes); }

bool getAvgFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(SAvgRes);
  return true;
}

int32_t avgFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
  if (pResultInfo->initialized) {
    return TSDB_CODE_SUCCESS;
  }
  if (TSDB_CODE_SUCCESS != functionSetup(pCtx, pResultInfo)) {
    return TSDB_CODE_FUNC_SETUP_ERROR;
  }

  SAvgRes* pRes = GET_ROWCELL_INTERBUF(pResultInfo);
  (void)memset(pRes, 0, sizeof(SAvgRes));
  return TSDB_CODE_SUCCESS;
}

static int32_t calculateAvgBySMAInfo(SAvgRes* pRes, int32_t numOfRows, int32_t type, const SColumnDataAgg* pAgg) {
  int32_t numOfElem = numOfRows - pAgg->numOfNull;

  pRes->count += numOfElem;
  if (IS_SIGNED_NUMERIC_TYPE(type)) {
    CHECK_OVERFLOW_SUM_SIGNED(pRes, pAgg->sum);
  } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
    CHECK_OVERFLOW_SUM_UNSIGNED(pRes, pAgg->sum);
  } else if (IS_FLOAT_TYPE(type)) {
    pRes->sum.dsum += GET_DOUBLE_VAL((const char*)&(pAgg->sum));
  }

  return numOfElem;
}

static int32_t doAddNumericVector(SColumnInfoData* pCol, int32_t type, SInputColumnInfoData *pInput, SAvgRes* pRes) {
  int32_t start = pInput->startRowIndex;
  int32_t numOfRows = pInput->numOfRows;
  int32_t numOfElems = 0;

  switch (type) {
    case TSDB_DATA_TYPE_TINYINT: {
      int8_t* plist = (int8_t*)pCol->pData;
      for (int32_t i = start; i < numOfRows + start; ++i) {
        if (colDataIsNull_f(pCol->nullbitmap, i)) {
          continue;
        }

        numOfElems += 1;
        pRes->count += 1;
        CHECK_OVERFLOW_SUM_SIGNED(pRes, plist[i])
      }

      break;
    }

    case TSDB_DATA_TYPE_SMALLINT: {
      int16_t* plist = (int16_t*)pCol->pData;
      for (int32_t i = start; i < numOfRows + start; ++i) {
        if (colDataIsNull_f(pCol->nullbitmap, i)) {
          continue;
        }

        numOfElems += 1;
        pRes->count += 1;
        CHECK_OVERFLOW_SUM_SIGNED(pRes, plist[i])
      }
      break;
    }

    case TSDB_DATA_TYPE_INT: {
      int32_t* plist = (int32_t*)pCol->pData;
      for (int32_t i = start; i < numOfRows + start; ++i) {
        if (colDataIsNull_f(pCol->nullbitmap, i)) {
          continue;
        }

        numOfElems += 1;
        pRes->count += 1;
        CHECK_OVERFLOW_SUM_SIGNED(pRes, plist[i])
      }

      break;
    }

    case TSDB_DATA_TYPE_BIGINT: {
      int64_t* plist = (int64_t*)pCol->pData;
      for (int32_t i = start; i < numOfRows + start; ++i) {
        if (colDataIsNull_f(pCol->nullbitmap, i)) {
          continue;
        }

        numOfElems += 1;
        pRes->count += 1;
        CHECK_OVERFLOW_SUM_SIGNED(pRes, plist[i])
      }
      break;
    }

    case TSDB_DATA_TYPE_UTINYINT: {
      uint8_t* plist = (uint8_t*)pCol->pData;
      for (int32_t i = start; i < numOfRows + start; ++i) {
        if (colDataIsNull_f(pCol->nullbitmap, i)) {
          continue;
        }

        numOfElems += 1;
        pRes->count += 1;
        CHECK_OVERFLOW_SUM_UNSIGNED(pRes, plist[i])
      }

      break;
    }

    case TSDB_DATA_TYPE_USMALLINT: {
      uint16_t* plist = (uint16_t*)pCol->pData;
      for (int32_t i = start; i < numOfRows + start; ++i) {
        if (colDataIsNull_f(pCol->nullbitmap, i)) {
          continue;
        }

        numOfElems += 1;
        pRes->count += 1;
        CHECK_OVERFLOW_SUM_UNSIGNED(pRes, plist[i])
      }
      break;
    }

    case TSDB_DATA_TYPE_UINT: {
      uint32_t* plist = (uint32_t*)pCol->pData;
      for (int32_t i = start; i < numOfRows + start; ++i) {
        if (colDataIsNull_f(pCol->nullbitmap, i)) {
          continue;
        }

        numOfElems += 1;
        pRes->count += 1;
        CHECK_OVERFLOW_SUM_UNSIGNED(pRes, plist[i])
      }

      break;
    }

    case TSDB_DATA_TYPE_UBIGINT: {
      uint64_t* plist = (uint64_t*)pCol->pData;
      for (int32_t i = start; i < numOfRows + start; ++i) {
        if (colDataIsNull_f(pCol->nullbitmap, i)) {
          continue;
        }

        numOfElems += 1;
        pRes->count += 1;
        CHECK_OVERFLOW_SUM_UNSIGNED(pRes, plist[i])
        
      }
      break;
    }

    case TSDB_DATA_TYPE_FLOAT: {
      float* plist = (float*)pCol->pData;
      for (int32_t i = start; i < numOfRows + start; ++i) {
        if (colDataIsNull_f(pCol->nullbitmap, i)) {
          continue;
        }

        numOfElems += 1;
        pRes->count += 1;
        pRes->sum.dsum += plist[i];
      }
      break;
    }

    case TSDB_DATA_TYPE_DOUBLE: {
      double* plist = (double*)pCol->pData;
      for (int32_t i = start; i < numOfRows + start; ++i) {
        if (colDataIsNull_f(pCol->nullbitmap, i)) {
          continue;
        }

        numOfElems += 1;
        pRes->count += 1;
        pRes->sum.dsum += plist[i];
      }
      break;
    }

    default:
      break;
  }

  return numOfElems;
}

int32_t avgFunction(SqlFunctionCtx* pCtx) {
  int32_t       numOfElem = 0;
  const int32_t THRESHOLD_SIZE = 8;

  SInputColumnInfoData* pInput = &pCtx->input;
  SColumnDataAgg*       pAgg = pInput->pColumnDataAgg[0];
  int32_t               type = pInput->pData[0]->info.type;

  SAvgRes* pAvgRes = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));

  // computing based on the true data block
  SColumnInfoData* pCol = pInput->pData[0];

  int32_t start = pInput->startRowIndex;
  int32_t numOfRows = pInput->numOfRows;

  if (IS_NULL_TYPE(type)) {
    goto _over;
  }

  pAvgRes->type = type;

  if (pInput->colDataSMAIsSet) {  // try to use SMA if available
    numOfElem = calculateAvgBySMAInfo(pAvgRes, numOfRows, type, pAgg);
  } else if (!pCol->hasNull) {  // try to employ the simd instructions to speed up the loop
    numOfElem = pInput->numOfRows;
    pAvgRes->count += pInput->numOfRows;

    switch(type) {
      case TSDB_DATA_TYPE_UTINYINT:
      case TSDB_DATA_TYPE_TINYINT: {
        const int8_t* plist = (const int8_t*) pCol->pData;

        for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
          if (type == TSDB_DATA_TYPE_TINYINT) {
            CHECK_OVERFLOW_SUM_SIGNED(pAvgRes, plist[i])
          } else {
            CHECK_OVERFLOW_SUM_UNSIGNED(pAvgRes, (uint8_t)plist[i])
          }
        }
        break;
      }

      case TSDB_DATA_TYPE_USMALLINT:
      case TSDB_DATA_TYPE_SMALLINT: {
        const int16_t* plist = (const int16_t*)pCol->pData;

        for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
          if (type == TSDB_DATA_TYPE_SMALLINT) {
            CHECK_OVERFLOW_SUM_SIGNED(pAvgRes, plist[i])
          } else {
            CHECK_OVERFLOW_SUM_UNSIGNED(pAvgRes, (uint16_t)plist[i])
          }
        }
        break;
      }

      case TSDB_DATA_TYPE_UINT:
      case TSDB_DATA_TYPE_INT: {
        const int32_t* plist = (const int32_t*) pCol->pData;

        for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
          if (type == TSDB_DATA_TYPE_INT) {
            CHECK_OVERFLOW_SUM_SIGNED(pAvgRes, plist[i])
          } else {
            CHECK_OVERFLOW_SUM_UNSIGNED(pAvgRes, (uint32_t)plist[i])
          }
        }
        break;
      }

      case TSDB_DATA_TYPE_UBIGINT:
      case TSDB_DATA_TYPE_BIGINT: {
        const int64_t* plist = (const int64_t*) pCol->pData;

        for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
          if (type == TSDB_DATA_TYPE_BIGINT) {
            CHECK_OVERFLOW_SUM_SIGNED(pAvgRes, plist[i])
          } else {
            CHECK_OVERFLOW_SUM_UNSIGNED(pAvgRes, (uint64_t)plist[i])
          }
        }
        break;
      }

      case TSDB_DATA_TYPE_FLOAT: {
        const float* plist = (const float*) pCol->pData;

        for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
          pAvgRes->sum.dsum += plist[i];
        }
        break;
      }
      case TSDB_DATA_TYPE_DOUBLE: {
        const double* plist = (const double*)pCol->pData;

        for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
          pAvgRes->sum.dsum += plist[i];
        }
        break;
      }
      default:
        return TSDB_CODE_FUNC_FUNTION_PARA_TYPE;
    }
  } else {
    numOfElem = doAddNumericVector(pCol, type, pInput, pAvgRes);
  }

_over:
  // data in the check operation are all null, not output
  SET_VAL(GET_RES_INFO(pCtx), numOfElem, 1);
  return TSDB_CODE_SUCCESS;
}

static void avgTransferInfo(SAvgRes* pInput, SAvgRes* pOutput) {
  if (IS_NULL_TYPE(pInput->type)) {
    return;
  }

  pOutput->type = pInput->type;
  if (IS_SIGNED_NUMERIC_TYPE(pOutput->type)) {
    bool overflow = pInput->sum.overflow;
    CHECK_OVERFLOW_SUM_SIGNED_BIG(pOutput, (overflow ? pInput->sum.dsum : pInput->sum.isum), overflow);
  } else if (IS_UNSIGNED_NUMERIC_TYPE(pOutput->type)) {
    bool overflow = pInput->sum.overflow;
    CHECK_OVERFLOW_SUM_UNSIGNED_BIG(pOutput, (overflow ? pInput->sum.dsum : pInput->sum.usum), overflow);
  } else {
    pOutput->sum.dsum += pInput->sum.dsum;
  }

  pOutput->count += pInput->count;
}

int32_t avgFunctionMerge(SqlFunctionCtx* pCtx) {
  SInputColumnInfoData* pInput = &pCtx->input;
  SColumnInfoData*      pCol = pInput->pData[0];

  if (IS_NULL_TYPE(pCol->info.type)) {
    SET_VAL(GET_RES_INFO(pCtx), 0, 1);
    return TSDB_CODE_SUCCESS;
  }

  if (pCol->info.type != TSDB_DATA_TYPE_BINARY) {
    return TSDB_CODE_FUNC_FUNTION_PARA_TYPE;
  }

  SAvgRes* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));

  int32_t start = pInput->startRowIndex;

  for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
    if(colDataIsNull_s(pCol, i)) continue;
    char*    data = colDataGetData(pCol, i);
    SAvgRes* pInputInfo = (SAvgRes*)varDataVal(data);
    avgTransferInfo(pInputInfo, pInfo);
  }

  SET_VAL(GET_RES_INFO(pCtx), 1, 1);

  return TSDB_CODE_SUCCESS;
}

#ifdef BUILD_NO_CALL
int32_t avgInvertFunction(SqlFunctionCtx* pCtx) {
  int32_t numOfElem = 0;

  // Only the pre-computing information loaded and actual data does not loaded
  SInputColumnInfoData* pInput = &pCtx->input;
  SAvgRes* pAvgRes = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));

  // computing based on the true data block
  SColumnInfoData* pCol = pInput->pData[0];

  int32_t start = pInput->startRowIndex;
  int32_t numOfRows = pInput->numOfRows;

  switch (pCol->info.type) {
    case TSDB_DATA_TYPE_TINYINT: {
      LIST_AVG_N(pAvgRes->sum.isum, int8_t);
      break;
    }
    case TSDB_DATA_TYPE_SMALLINT: {
      LIST_AVG_N(pAvgRes->sum.isum, int16_t);
      break;
    }
    case TSDB_DATA_TYPE_INT: {
      LIST_AVG_N(pAvgRes->sum.isum, int32_t);
      break;
    }
    case TSDB_DATA_TYPE_BIGINT: {
      LIST_AVG_N(pAvgRes->sum.isum, int64_t);
      break;
    }
    case TSDB_DATA_TYPE_UTINYINT: {
      LIST_AVG_N(pAvgRes->sum.usum, uint8_t);
      break;
    }
    case TSDB_DATA_TYPE_USMALLINT: {
      LIST_AVG_N(pAvgRes->sum.usum, uint16_t);
      break;
    }
    case TSDB_DATA_TYPE_UINT: {
      LIST_AVG_N(pAvgRes->sum.usum, uint32_t);
      break;
    }
    case TSDB_DATA_TYPE_UBIGINT: {
      LIST_AVG_N(pAvgRes->sum.usum, uint64_t);
      break;
    }
    case TSDB_DATA_TYPE_FLOAT: {
      LIST_AVG_N(pAvgRes->sum.dsum, float);
      break;
    }
    case TSDB_DATA_TYPE_DOUBLE: {
      LIST_AVG_N(pAvgRes->sum.dsum, double);
      break;
    }
    default:
      break;
  }

  // data in the check operation are all null, not output
  SET_VAL(GET_RES_INFO(pCtx), numOfElem, 1);
  return TSDB_CODE_SUCCESS;
}
#endif

int32_t avgCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);
  SAvgRes*             pDBuf = GET_ROWCELL_INTERBUF(pDResInfo);

  SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
  SAvgRes*             pSBuf = GET_ROWCELL_INTERBUF(pSResInfo);
  int16_t              type = pDBuf->type == TSDB_DATA_TYPE_NULL ? pSBuf->type : pDBuf->type;

  if (IS_SIGNED_NUMERIC_TYPE(type)) {
    CHECK_OVERFLOW_SUM_SIGNED(pDBuf, pSBuf->sum.isum)
  } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
    CHECK_OVERFLOW_SUM_UNSIGNED(pDBuf, pSBuf->sum.usum)
  } else {
    pDBuf->sum.dsum += pSBuf->sum.dsum;
  }
  pDBuf->count += pSBuf->count;

  return TSDB_CODE_SUCCESS;
}

int32_t avgFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SResultRowEntryInfo* pEntryInfo = GET_RES_INFO(pCtx);

  SAvgRes* pRes = GET_ROWCELL_INTERBUF(pEntryInfo);
  int32_t  type = pRes->type;

  if (pRes->count > 0) {
    if(pRes->sum.overflow) {
      // overflow flag set , use dsum
      pRes->result = pRes->sum.dsum / ((double)pRes->count);
    }else if (IS_SIGNED_NUMERIC_TYPE(type)) {
      pRes->result = pRes->sum.isum / ((double)pRes->count);
    } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
      pRes->result = pRes->sum.usum / ((double)pRes->count);
    } else {
      pRes->result = pRes->sum.dsum / ((double)pRes->count);
    }
  }

  if (pRes->count == 0 || isinf(pRes->result) || isnan(pRes->result)) {
    pEntryInfo->numOfRes = 0;
  } else {
    pEntryInfo->numOfRes = 1;
  }

  return functionFinalize(pCtx, pBlock);
}

int32_t avgPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  SAvgRes*             pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
  int32_t              resultBytes = getAvgInfoSize();
  char*                res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
  int32_t              code = TSDB_CODE_SUCCESS;
  if (NULL == res) {
    return terrno;
  }
  (void)memcpy(varDataVal(res), pInfo, resultBytes);
  varDataSetLen(res, resultBytes);

  int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
  if(NULL == pCol) {
    code = TSDB_CODE_OUT_OF_RANGE;
    goto _exit;
  }

  code = colDataSetVal(pCol, pBlock->info.rows, res, false);

_exit:
  taosMemoryFree(res);
  return code;
}

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->nullbitmap, 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(out, val) \
46	if (out->sum.overflow) { \
47	out->sum.dsum += val; \
48	} else if (out->sum.isum > 0 && val > 0 && INT64_MAX - out->sum.isum <= val \|\| \
49	out->sum.isum < 0 && val < 0 && INT64_MIN - out->sum.isum >= val) { \
50	double dsum = (double)out->sum.isum; \
51	out->sum.overflow = true; \
52	out->sum.dsum = dsum + val; \
53	} else { \
54	out->sum.isum += val; \
55	}
56
57	// val is big than INT64_MAX, val come from merge
58	#define CHECK_OVERFLOW_SUM_SIGNED_BIG(out, val, big) \
59	if (out->sum.overflow) { \
60	out->sum.dsum += val; \
61	} else if (out->sum.isum > 0 && val > 0 && INT64_MAX - out->sum.isum <= val \|\| \
62	out->sum.isum < 0 && val < 0 && INT64_MIN - out->sum.isum >= val \|\| \
63	big) { \
64	double dsum = (double)out->sum.isum; \
65	out->sum.overflow = true; \
66	out->sum.dsum = dsum + val; \
67	} else { \
68	out->sum.isum += val; \
69	}
70
71	// define unsigned number sum with check overflow
72	#define CHECK_OVERFLOW_SUM_UNSIGNED(out, val) \
73	if (out->sum.overflow) { \
74	out->sum.dsum += val; \
75	} else if (UINT64_MAX - out->sum.usum <= val) { \
76	double dsum = (double)out->sum.usum; \
77	out->sum.overflow = true; \
78	out->sum.dsum = dsum + val; \
79	} else { \
80	out->sum.usum += val; \
81	}
82
83	// val is big than UINT64_MAX, val come from merge
84	#define CHECK_OVERFLOW_SUM_UNSIGNED_BIG(out, val, big) \
85	if (out->sum.overflow) { \
86	out->sum.dsum += val; \
87	} else if (UINT64_MAX - out->sum.usum <= val \|\| big) { \
88	double dsum = (double)out->sum.usum; \
89	out->sum.overflow = true; \
90	out->sum.dsum = dsum + val; \
91	} else { \
92	out->sum.usum += val; \
93	}
94
95	int32_t getAvgInfoSize() { return (int32_t)sizeof(SAvgRes); }	4✔
96
UNCOV 97	bool getAvgFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {	×
UNCOV 98	pEnv->calcMemSize = sizeof(SAvgRes);	×
UNCOV 99	return true;	×
100	}
101
UNCOV 102	int32_t avgFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {	×
UNCOV 103	if (pResultInfo->initialized) {	×
104	return TSDB_CODE_SUCCESS;	×
105	}
UNCOV 106	if (TSDB_CODE_SUCCESS != functionSetup(pCtx, pResultInfo)) {	×
107	return TSDB_CODE_FUNC_SETUP_ERROR;	×
108	}
109
UNCOV 110	SAvgRes* pRes = GET_ROWCELL_INTERBUF(pResultInfo);	×
UNCOV 111	(void)memset(pRes, 0, sizeof(SAvgRes));	×
UNCOV 112	return TSDB_CODE_SUCCESS;	×
113	}
114
UNCOV 115	static int32_t calculateAvgBySMAInfo(SAvgRes* pRes, int32_t numOfRows, int32_t type, const SColumnDataAgg* pAgg) {	×
UNCOV 116	int32_t numOfElem = numOfRows - pAgg->numOfNull;	×
117
UNCOV 118	pRes->count += numOfElem;	×
UNCOV 119	if (IS_SIGNED_NUMERIC_TYPE(type)) {	×
UNCOV 120	CHECK_OVERFLOW_SUM_SIGNED(pRes, pAgg->sum);	×
121	} else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {	×
122	CHECK_OVERFLOW_SUM_UNSIGNED(pRes, pAgg->sum);	×
123	} else if (IS_FLOAT_TYPE(type)) {	×
124	pRes->sum.dsum += GET_DOUBLE_VAL((const char*)&(pAgg->sum));	×
125	}
126
UNCOV 127	return numOfElem;	×
128	}
129
UNCOV 130	static int32_t doAddNumericVector(SColumnInfoData* pCol, int32_t type, SInputColumnInfoData pInput, SAvgRes pRes) {	×
UNCOV 131	int32_t start = pInput->startRowIndex;	×
UNCOV 132	int32_t numOfRows = pInput->numOfRows;	×
UNCOV 133	int32_t numOfElems = 0;	×
134
UNCOV 135	switch (type) {	×
UNCOV 136	case TSDB_DATA_TYPE_TINYINT: {	×
UNCOV 137	int8_t* plist = (int8_t*)pCol->pData;	×
UNCOV 138	for (int32_t i = start; i < numOfRows + start; ++i) {	×
UNCOV 139	if (colDataIsNull_f(pCol->nullbitmap, i)) {	×
UNCOV 140	continue;	×
141	}
142
UNCOV 143	numOfElems += 1;	×
UNCOV 144	pRes->count += 1;	×
UNCOV 145	CHECK_OVERFLOW_SUM_SIGNED(pRes, plist[i])	×
146	}
147
UNCOV 148	break;	×
149	}
150
UNCOV 151	case TSDB_DATA_TYPE_SMALLINT: {	×
UNCOV 152	int16_t* plist = (int16_t*)pCol->pData;	×
UNCOV 153	for (int32_t i = start; i < numOfRows + start; ++i) {	×
UNCOV 154	if (colDataIsNull_f(pCol->nullbitmap, i)) {	×
UNCOV 155	continue;	×
156	}
157
UNCOV 158	numOfElems += 1;	×
UNCOV 159	pRes->count += 1;	×
UNCOV 160	CHECK_OVERFLOW_SUM_SIGNED(pRes, plist[i])	×
161	}
UNCOV 162	break;	×
163	}
164
UNCOV 165	case TSDB_DATA_TYPE_INT: {	×
UNCOV 166	int32_t* plist = (int32_t*)pCol->pData;	×
UNCOV 167	for (int32_t i = start; i < numOfRows + start; ++i) {	×
UNCOV 168	if (colDataIsNull_f(pCol->nullbitmap, i)) {	×
UNCOV 169	continue;	×
170	}
171
UNCOV 172	numOfElems += 1;	×
UNCOV 173	pRes->count += 1;	×
UNCOV 174	CHECK_OVERFLOW_SUM_SIGNED(pRes, plist[i])	×
175	}
176
UNCOV 177	break;	×
178	}
179
UNCOV 180	case TSDB_DATA_TYPE_BIGINT: {	×
UNCOV 181	int64_t* plist = (int64_t*)pCol->pData;	×
UNCOV 182	for (int32_t i = start; i < numOfRows + start; ++i) {	×
UNCOV 183	if (colDataIsNull_f(pCol->nullbitmap, i)) {	×
UNCOV 184	continue;	×
185	}
186
UNCOV 187	numOfElems += 1;	×
UNCOV 188	pRes->count += 1;	×
UNCOV 189	CHECK_OVERFLOW_SUM_SIGNED(pRes, plist[i])	×
190	}
UNCOV 191	break;	×
192	}
193
UNCOV 194	case TSDB_DATA_TYPE_UTINYINT: {	×
UNCOV 195	uint8_t* plist = (uint8_t*)pCol->pData;	×
UNCOV 196	for (int32_t i = start; i < numOfRows + start; ++i) {	×
UNCOV 197	if (colDataIsNull_f(pCol->nullbitmap, i)) {	×
198	continue;	×
199	}
200
UNCOV 201	numOfElems += 1;	×
UNCOV 202	pRes->count += 1;	×
UNCOV 203	CHECK_OVERFLOW_SUM_UNSIGNED(pRes, plist[i])	×
204	}
205
UNCOV 206	break;	×
207	}
208
UNCOV 209	case TSDB_DATA_TYPE_USMALLINT: {	×
UNCOV 210	uint16_t* plist = (uint16_t*)pCol->pData;	×
UNCOV 211	for (int32_t i = start; i < numOfRows + start; ++i) {	×
UNCOV 212	if (colDataIsNull_f(pCol->nullbitmap, i)) {	×
213	continue;	×
214	}
215
UNCOV 216	numOfElems += 1;	×
UNCOV 217	pRes->count += 1;	×
UNCOV 218	CHECK_OVERFLOW_SUM_UNSIGNED(pRes, plist[i])	×
219	}
UNCOV 220	break;	×
221	}
222
UNCOV 223	case TSDB_DATA_TYPE_UINT: {	×
UNCOV 224	uint32_t* plist = (uint32_t*)pCol->pData;	×
UNCOV 225	for (int32_t i = start; i < numOfRows + start; ++i) {	×
UNCOV 226	if (colDataIsNull_f(pCol->nullbitmap, i)) {	×
UNCOV 227	continue;	×
228	}
229
UNCOV 230	numOfElems += 1;	×
UNCOV 231	pRes->count += 1;	×
UNCOV 232	CHECK_OVERFLOW_SUM_UNSIGNED(pRes, plist[i])	×
233	}
234
UNCOV 235	break;	×
236	}
237
UNCOV 238	case TSDB_DATA_TYPE_UBIGINT: {	×
UNCOV 239	uint64_t* plist = (uint64_t*)pCol->pData;	×
UNCOV 240	for (int32_t i = start; i < numOfRows + start; ++i) {	×
UNCOV 241	if (colDataIsNull_f(pCol->nullbitmap, i)) {	×
UNCOV 242	continue;	×
243	}
244
UNCOV 245	numOfElems += 1;	×
UNCOV 246	pRes->count += 1;	×
UNCOV 247	CHECK_OVERFLOW_SUM_UNSIGNED(pRes, plist[i])	×
248
249	}
UNCOV 250	break;	×
251	}
252
UNCOV 253	case TSDB_DATA_TYPE_FLOAT: {	×
UNCOV 254	float* plist = (float*)pCol->pData;	×
UNCOV 255	for (int32_t i = start; i < numOfRows + start; ++i) {	×
UNCOV 256	if (colDataIsNull_f(pCol->nullbitmap, i)) {	×
UNCOV 257	continue;	×
258	}
259
UNCOV 260	numOfElems += 1;	×
UNCOV 261	pRes->count += 1;	×
UNCOV 262	pRes->sum.dsum += plist[i];	×
263	}
UNCOV 264	break;	×
265	}
266
UNCOV 267	case TSDB_DATA_TYPE_DOUBLE: {	×
UNCOV 268	double* plist = (double*)pCol->pData;	×
UNCOV 269	for (int32_t i = start; i < numOfRows + start; ++i) {	×
UNCOV 270	if (colDataIsNull_f(pCol->nullbitmap, i)) {	×
UNCOV 271	continue;	×
272	}
273
UNCOV 274	numOfElems += 1;	×
UNCOV 275	pRes->count += 1;	×
UNCOV 276	pRes->sum.dsum += plist[i];	×
277	}
UNCOV 278	break;	×
279	}
280
281	default:	×
282	break;	×
283	}
284
UNCOV 285	return numOfElems;	×
286	}
287
UNCOV 288	int32_t avgFunction(SqlFunctionCtx* pCtx) {	×
UNCOV 289	int32_t numOfElem = 0;	×
UNCOV 290	const int32_t THRESHOLD_SIZE = 8;	×
291
UNCOV 292	SInputColumnInfoData* pInput = &pCtx->input;	×
UNCOV 293	SColumnDataAgg* pAgg = pInput->pColumnDataAgg[0];	×
UNCOV 294	int32_t type = pInput->pData[0]->info.type;	×
295
UNCOV 296	SAvgRes* pAvgRes = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));	×
297
298	// computing based on the true data block
UNCOV 299	SColumnInfoData* pCol = pInput->pData[0];	×
300
UNCOV 301	int32_t start = pInput->startRowIndex;	×
UNCOV 302	int32_t numOfRows = pInput->numOfRows;	×
303
UNCOV 304	if (IS_NULL_TYPE(type)) {	×
UNCOV 305	goto _over;	×
306	}
307
UNCOV 308	pAvgRes->type = type;	×
309
UNCOV 310	if (pInput->colDataSMAIsSet) { // try to use SMA if available	×
UNCOV 311	numOfElem = calculateAvgBySMAInfo(pAvgRes, numOfRows, type, pAgg);	×
UNCOV 312	} else if (!pCol->hasNull) { // try to employ the simd instructions to speed up the loop	×
UNCOV 313	numOfElem = pInput->numOfRows;	×
UNCOV 314	pAvgRes->count += pInput->numOfRows;	×
315
UNCOV 316	switch(type) {	×
UNCOV 317	case TSDB_DATA_TYPE_UTINYINT:	×
318	case TSDB_DATA_TYPE_TINYINT: {
UNCOV 319	const int8_t* plist = (const int8_t*) pCol->pData;	×
320
UNCOV 321	for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {	×
UNCOV 322	if (type == TSDB_DATA_TYPE_TINYINT) {	×
UNCOV 323	CHECK_OVERFLOW_SUM_SIGNED(pAvgRes, plist[i])	×
324	} else {
UNCOV 325	CHECK_OVERFLOW_SUM_UNSIGNED(pAvgRes, (uint8_t)plist[i])	×
326	}
327	}
UNCOV 328	break;	×
329	}
330
UNCOV 331	case TSDB_DATA_TYPE_USMALLINT:	×
332	case TSDB_DATA_TYPE_SMALLINT: {
UNCOV 333	const int16_t* plist = (const int16_t*)pCol->pData;	×
334
UNCOV 335	for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {	×
UNCOV 336	if (type == TSDB_DATA_TYPE_SMALLINT) {	×
UNCOV 337	CHECK_OVERFLOW_SUM_SIGNED(pAvgRes, plist[i])	×
338	} else {
UNCOV 339	CHECK_OVERFLOW_SUM_UNSIGNED(pAvgRes, (uint16_t)plist[i])	×
340	}
341	}
UNCOV 342	break;	×
343	}
344
UNCOV 345	case TSDB_DATA_TYPE_UINT:	×
346	case TSDB_DATA_TYPE_INT: {
UNCOV 347	const int32_t* plist = (const int32_t*) pCol->pData;	×
348
UNCOV 349	for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {	×
UNCOV 350	if (type == TSDB_DATA_TYPE_INT) {	×
UNCOV 351	CHECK_OVERFLOW_SUM_SIGNED(pAvgRes, plist[i])	×
352	} else {
UNCOV 353	CHECK_OVERFLOW_SUM_UNSIGNED(pAvgRes, (uint32_t)plist[i])	×
354	}
355	}
UNCOV 356	break;	×
357	}
358
UNCOV 359	case TSDB_DATA_TYPE_UBIGINT:	×
360	case TSDB_DATA_TYPE_BIGINT: {
UNCOV 361	const int64_t* plist = (const int64_t*) pCol->pData;	×
362
UNCOV 363	for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {	×
UNCOV 364	if (type == TSDB_DATA_TYPE_BIGINT) {	×
UNCOV 365	CHECK_OVERFLOW_SUM_SIGNED(pAvgRes, plist[i])	×
366	} else {
UNCOV 367	CHECK_OVERFLOW_SUM_UNSIGNED(pAvgRes, (uint64_t)plist[i])	×
368	}
369	}
UNCOV 370	break;	×
371	}
372
UNCOV 373	case TSDB_DATA_TYPE_FLOAT: {	×
UNCOV 374	const float* plist = (const float*) pCol->pData;	×
375
UNCOV 376	for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {	×
UNCOV 377	pAvgRes->sum.dsum += plist[i];	×
378	}
UNCOV 379	break;	×
380	}
UNCOV 381	case TSDB_DATA_TYPE_DOUBLE: {	×
UNCOV 382	const double* plist = (const double*)pCol->pData;	×
383
UNCOV 384	for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {	×
UNCOV 385	pAvgRes->sum.dsum += plist[i];	×
386	}
UNCOV 387	break;	×
388	}
389	default:	×
390	return TSDB_CODE_FUNC_FUNTION_PARA_TYPE;	×
391	}
392	} else {
UNCOV 393	numOfElem = doAddNumericVector(pCol, type, pInput, pAvgRes);	×
394	}
395
UNCOV 396	_over:	×
397	// data in the check operation are all null, not output
UNCOV 398	SET_VAL(GET_RES_INFO(pCtx), numOfElem, 1);	×
UNCOV 399	return TSDB_CODE_SUCCESS;	×
400	}
401
UNCOV 402	static void avgTransferInfo(SAvgRes* pInput, SAvgRes* pOutput) {	×
UNCOV 403	if (IS_NULL_TYPE(pInput->type)) {	×
UNCOV 404	return;	×
405	}
406
UNCOV 407	pOutput->type = pInput->type;	×
UNCOV 408	if (IS_SIGNED_NUMERIC_TYPE(pOutput->type)) {	×
UNCOV 409	bool overflow = pInput->sum.overflow;	×
UNCOV 410	CHECK_OVERFLOW_SUM_SIGNED_BIG(pOutput, (overflow ? pInput->sum.dsum : pInput->sum.isum), overflow);	×
UNCOV 411	} else if (IS_UNSIGNED_NUMERIC_TYPE(pOutput->type)) {	×
UNCOV 412	bool overflow = pInput->sum.overflow;	×
UNCOV 413	CHECK_OVERFLOW_SUM_UNSIGNED_BIG(pOutput, (overflow ? pInput->sum.dsum : pInput->sum.usum), overflow);	×
414	} else {
UNCOV 415	pOutput->sum.dsum += pInput->sum.dsum;	×
416	}
417
UNCOV 418	pOutput->count += pInput->count;	×
419	}
420
UNCOV 421	int32_t avgFunctionMerge(SqlFunctionCtx* pCtx) {	×
UNCOV 422	SInputColumnInfoData* pInput = &pCtx->input;	×
UNCOV 423	SColumnInfoData* pCol = pInput->pData[0];	×
424
UNCOV 425	if (IS_NULL_TYPE(pCol->info.type)) {	×
UNCOV 426	SET_VAL(GET_RES_INFO(pCtx), 0, 1);	×
UNCOV 427	return TSDB_CODE_SUCCESS;	×
428	}
429
UNCOV 430	if (pCol->info.type != TSDB_DATA_TYPE_BINARY) {	×
431	return TSDB_CODE_FUNC_FUNTION_PARA_TYPE;	×
432	}
433
UNCOV 434	SAvgRes* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));	×
435
UNCOV 436	int32_t start = pInput->startRowIndex;	×
437
UNCOV 438	for (int32_t i = start; i < start + pInput->numOfRows; ++i) {	×
UNCOV 439	if(colDataIsNull_s(pCol, i)) continue;	×
UNCOV 440	char* data = colDataGetData(pCol, i);	×
UNCOV 441	SAvgRes* pInputInfo = (SAvgRes*)varDataVal(data);	×
UNCOV 442	avgTransferInfo(pInputInfo, pInfo);	×
443	}
444
UNCOV 445	SET_VAL(GET_RES_INFO(pCtx), 1, 1);	×
446
UNCOV 447	return TSDB_CODE_SUCCESS;	×
448	}
449
450	#ifdef BUILD_NO_CALL
451	int32_t avgInvertFunction(SqlFunctionCtx* pCtx) {
452	int32_t numOfElem = 0;
453
454	// Only the pre-computing information loaded and actual data does not loaded
455	SInputColumnInfoData* pInput = &pCtx->input;
456	SAvgRes* pAvgRes = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
457
458	// computing based on the true data block
459	SColumnInfoData* pCol = pInput->pData[0];
460
461	int32_t start = pInput->startRowIndex;
462	int32_t numOfRows = pInput->numOfRows;
463
464	switch (pCol->info.type) {
465	case TSDB_DATA_TYPE_TINYINT: {
466	LIST_AVG_N(pAvgRes->sum.isum, int8_t);
467	break;
468	}
469	case TSDB_DATA_TYPE_SMALLINT: {
470	LIST_AVG_N(pAvgRes->sum.isum, int16_t);
471	break;
472	}
473	case TSDB_DATA_TYPE_INT: {
474	LIST_AVG_N(pAvgRes->sum.isum, int32_t);
475	break;
476	}
477	case TSDB_DATA_TYPE_BIGINT: {
478	LIST_AVG_N(pAvgRes->sum.isum, int64_t);
479	break;
480	}
481	case TSDB_DATA_TYPE_UTINYINT: {
482	LIST_AVG_N(pAvgRes->sum.usum, uint8_t);
483	break;
484	}
485	case TSDB_DATA_TYPE_USMALLINT: {
486	LIST_AVG_N(pAvgRes->sum.usum, uint16_t);
487	break;
488	}
489	case TSDB_DATA_TYPE_UINT: {
490	LIST_AVG_N(pAvgRes->sum.usum, uint32_t);
491	break;
492	}
493	case TSDB_DATA_TYPE_UBIGINT: {
494	LIST_AVG_N(pAvgRes->sum.usum, uint64_t);
495	break;
496	}
497	case TSDB_DATA_TYPE_FLOAT: {
498	LIST_AVG_N(pAvgRes->sum.dsum, float);
499	break;
500	}
501	case TSDB_DATA_TYPE_DOUBLE: {
502	LIST_AVG_N(pAvgRes->sum.dsum, double);
503	break;
504	}
505	default:
506	break;
507	}
508
509	// data in the check operation are all null, not output
510	SET_VAL(GET_RES_INFO(pCtx), numOfElem, 1);
511	return TSDB_CODE_SUCCESS;
512	}
513	#endif
514
515	int32_t avgCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {	×
516	SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);	×
517	SAvgRes* pDBuf = GET_ROWCELL_INTERBUF(pDResInfo);	×
518
519	SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);	×
520	SAvgRes* pSBuf = GET_ROWCELL_INTERBUF(pSResInfo);	×
521	int16_t type = pDBuf->type == TSDB_DATA_TYPE_NULL ? pSBuf->type : pDBuf->type;	×
522
523	if (IS_SIGNED_NUMERIC_TYPE(type)) {	×
524	CHECK_OVERFLOW_SUM_SIGNED(pDBuf, pSBuf->sum.isum)	×
525	} else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {	×
526	CHECK_OVERFLOW_SUM_UNSIGNED(pDBuf, pSBuf->sum.usum)	×
527	} else {
528	pDBuf->sum.dsum += pSBuf->sum.dsum;	×
529	}
530	pDBuf->count += pSBuf->count;	×
531
532	return TSDB_CODE_SUCCESS;	×
533	}
534
UNCOV 535	int32_t avgFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {	×
UNCOV 536	SResultRowEntryInfo* pEntryInfo = GET_RES_INFO(pCtx);	×
537
UNCOV 538	SAvgRes* pRes = GET_ROWCELL_INTERBUF(pEntryInfo);	×
UNCOV 539	int32_t type = pRes->type;	×
540
UNCOV 541	if (pRes->count > 0) {	×
UNCOV 542	if(pRes->sum.overflow) {	×
543	// overflow flag set , use dsum
UNCOV 544	pRes->result = pRes->sum.dsum / ((double)pRes->count);	×
UNCOV 545	}else if (IS_SIGNED_NUMERIC_TYPE(type)) {	×
UNCOV 546	pRes->result = pRes->sum.isum / ((double)pRes->count);	×
UNCOV 547	} else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {	×
UNCOV 548	pRes->result = pRes->sum.usum / ((double)pRes->count);	×
549	} else {
UNCOV 550	pRes->result = pRes->sum.dsum / ((double)pRes->count);	×
551	}
552	}
553
UNCOV 554	if (pRes->count == 0 \|\| isinf(pRes->result) \|\| isnan(pRes->result)) {	×
UNCOV 555	pEntryInfo->numOfRes = 0;	×
556	} else {
UNCOV 557	pEntryInfo->numOfRes = 1;	×
558	}
559
UNCOV 560	return functionFinalize(pCtx, pBlock);	×
561	}
562
UNCOV 563	int32_t avgPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {	×
UNCOV 564	SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);	×
UNCOV 565	SAvgRes* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));	×
UNCOV 566	int32_t resultBytes = getAvgInfoSize();	×
UNCOV 567	char* res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));	×
UNCOV 568	int32_t code = TSDB_CODE_SUCCESS;	×
UNCOV 569	if (NULL == res) {	×
570	return terrno;	×
571	}
UNCOV 572	(void)memcpy(varDataVal(res), pInfo, resultBytes);	×
UNCOV 573	varDataSetLen(res, resultBytes);	×
574
UNCOV 575	int32_t slotId = pCtx->pExpr->base.resSchema.slotId;	×
UNCOV 576	SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);	×
UNCOV 577	if(NULL == pCol) {	×
578	code = TSDB_CODE_OUT_OF_RANGE;	×
579	goto _exit;	×
580	}
581
UNCOV 582	code = colDataSetVal(pCol, pBlock->info.rows, res, false);	×
583
UNCOV 584	_exit:	×
UNCOV 585	taosMemoryFree(res);	×
UNCOV 586	return code;	×
587	}

taosdata / TDengine / #3653

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