builtinsimpl.c 178.6 KB
Newer Older
H
Haojun Liao 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/*
 * 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"
17
#include "cJSON.h"
18
#include "function.h"
X
Xiaoyu Wang 已提交
19
#include "query.h"
20
#include "querynodes.h"
21
#include "streamState.h"
G
Ganlin Zhao 已提交
22
#include "tcompare.h"
H
Haojun Liao 已提交
23
#include "tdatablock.h"
24
#include "tdigest.h"
25
#include "tfunctionInt.h"
X
Xiaoyu Wang 已提交
26
#include "tglobal.h"
27
#include "thistogram.h"
28
#include "tpercentile.h"
H
Haojun Liao 已提交
29

X
Xiaoyu Wang 已提交
30 31 32 33
#define HISTOGRAM_MAX_BINS_NUM 1000
#define MAVG_MAX_POINTS_NUM    1000
#define TAIL_MAX_POINTS_NUM    100
#define TAIL_MAX_OFFSET        100
G
Ganlin Zhao 已提交
34

X
Xiaoyu Wang 已提交
35
#define UNIQUE_MAX_RESULT_SIZE (1024 * 1024 * 10)
G
Ganlin Zhao 已提交
36
#define MODE_MAX_RESULT_SIZE   UNIQUE_MAX_RESULT_SIZE
37

X
Xiaoyu Wang 已提交
38 39 40 41 42
#define HLL_BUCKET_BITS 14  // The bits of the bucket
#define HLL_DATA_BITS   (64 - HLL_BUCKET_BITS)
#define HLL_BUCKETS     (1 << HLL_BUCKET_BITS)
#define HLL_BUCKET_MASK (HLL_BUCKETS - 1)
#define HLL_ALPHA_INF   0.721347520444481703680  // constant for 0.5/ln(2)
G
Ganlin Zhao 已提交
43

H
Haojun Liao 已提交
44 45 46 47 48 49 50 51 52
//typedef struct SMinmaxResInfo {
//  bool      assign;  // assign the first value or not
//  int64_t   v;
//  STuplePos tuplePos;
//
//  STuplePos nullTuplePos;
//  bool      nullTupleSaved;
//  int16_t   type;
//} SMinmaxResInfo;
G
Ganlin Zhao 已提交
53

54
typedef struct STopBotResItem {
55 56 57
  SVariant  v;
  uint64_t  uid;  // it is a table uid, used to extract tag data during building of the final result for the tag data
  STuplePos tuplePos;  // tuple data of this chosen row
58 59
} STopBotResItem;

G
Ganlin Zhao 已提交
60
typedef struct STopBotRes {
L
Liu Jicong 已提交
61 62
  int32_t maxSize;
  int16_t type;
63

L
Liu Jicong 已提交
64 65
  STuplePos nullTuplePos;
  bool      nullTupleSaved;
66

67
  STopBotResItem* pItems;
G
Ganlin Zhao 已提交
68 69 70 71 72
} STopBotRes;

typedef struct SStddevRes {
  double  result;
  int64_t count;
73
  union {
74 75 76
    double   quadraticDSum;
    int64_t  quadraticISum;
    uint64_t quadraticUSum;
77 78
  };
  union {
79 80 81
    double   dsum;
    int64_t  isum;
    uint64_t usum;
82
  };
G
Ganlin Zhao 已提交
83
  int16_t type;
G
Ganlin Zhao 已提交
84 85
} SStddevRes;

86
typedef struct SLeastSQRInfo {
X
Xiaoyu Wang 已提交
87 88 89
  double  matrix[2][3];
  double  startVal;
  double  stepVal;
90 91 92
  int64_t num;
} SLeastSQRInfo;

G
Ganlin Zhao 已提交
93 94
typedef struct SPercentileInfo {
  double      result;
95
  tMemBucket* pMemBucket;
G
Ganlin Zhao 已提交
96 97 98 99 100 101
  int32_t     stage;
  double      minval;
  double      maxval;
  int64_t     numOfElems;
} SPercentileInfo;

102
typedef struct SAPercentileInfo {
X
Xiaoyu Wang 已提交
103 104 105 106 107
  double          result;
  double          percent;
  int8_t          algo;
  SHistogramInfo* pHisto;
  TDigest*        pTDigest;
108 109 110 111 112 113 114 115
} SAPercentileInfo;

typedef enum {
  APERCT_ALGO_UNKNOWN = 0,
  APERCT_ALGO_DEFAULT,
  APERCT_ALGO_TDIGEST,
} EAPerctAlgoType;

G
Ganlin Zhao 已提交
116
typedef struct SDiffInfo {
117 118
  bool hasPrev;
  bool includeNull;
119
  bool ignoreNegative;  // replace the ignore with case when
120 121 122 123 124
  bool firstOutput;
  union {
    int64_t i64;
    double  d64;
  } prev;
125 126

  int64_t prevTs;
G
Ganlin Zhao 已提交
127 128
} SDiffInfo;

G
Ganlin Zhao 已提交
129 130 131 132 133 134 135
typedef struct SSpreadInfo {
  double result;
  bool   hasResult;
  double min;
  double max;
} SSpreadInfo;

G
Ganlin Zhao 已提交
136 137 138 139 140 141 142
typedef struct SElapsedInfo {
  double  result;
  TSKEY   min;
  TSKEY   max;
  int64_t timeUnit;
} SElapsedInfo;

G
Ganlin Zhao 已提交
143 144
typedef struct STwaInfo {
  double      dOutput;
145
  bool        isNull;
G
Ganlin Zhao 已提交
146 147 148 149
  SPoint1     p;
  STimeWindow win;
} STwaInfo;

150
typedef struct SHistoFuncBin {
X
Xiaoyu Wang 已提交
151 152
  double  lower;
  double  upper;
153 154
  int64_t count;
  double  percentage;
155 156 157
} SHistoFuncBin;

typedef struct SHistoFuncInfo {
X
Xiaoyu Wang 已提交
158 159 160
  int32_t       numOfBins;
  int32_t       totalCount;
  bool          normalized;
161 162 163
  SHistoFuncBin bins[];
} SHistoFuncInfo;

X
Xiaoyu Wang 已提交
164
typedef enum { UNKNOWN_BIN = 0, USER_INPUT_BIN, LINEAR_BIN, LOG_BIN } EHistoBinType;
165

166 167
typedef struct SHLLFuncInfo {
  uint64_t result;
168
  uint64_t totalCount;
X
Xiaoyu Wang 已提交
169
  uint8_t  buckets[HLL_BUCKETS];
170 171
} SHLLInfo;

172
typedef struct SStateInfo {
173 174 175 176
  union {
    int64_t count;
    int64_t durationStart;
  };
177 178
  int64_t prevTs;
  bool    isPrevTsSet;
179 180 181 182 183 184 185 186 187 188 189
} SStateInfo;

typedef enum {
  STATE_OPER_INVALID = 0,
  STATE_OPER_LT,
  STATE_OPER_GT,
  STATE_OPER_LE,
  STATE_OPER_GE,
  STATE_OPER_NE,
  STATE_OPER_EQ,
} EStateOperType;
190

G
Ganlin Zhao 已提交
191 192 193
typedef struct SMavgInfo {
  int32_t pos;
  double  sum;
194 195
  int64_t prevTs;
  bool    isPrevTsSet;
G
Ganlin Zhao 已提交
196 197 198 199 200
  int32_t numOfPoints;
  bool    pointsMeet;
  double  points[];
} SMavgInfo;

G
Ganlin Zhao 已提交
201
typedef struct SSampleInfo {
L
Liu Jicong 已提交
202 203 204 205 206
  int32_t samples;
  int32_t totalPoints;
  int32_t numSampled;
  uint8_t colType;
  int16_t colBytes;
207

L
Liu Jicong 已提交
208 209
  STuplePos nullTuplePos;
  bool      nullTupleSaved;
210

211 212
  char*      data;
  STuplePos* tuplePos;
G
Ganlin Zhao 已提交
213 214
} SSampleInfo;

G
Ganlin Zhao 已提交
215
typedef struct STailItem {
G
Ganlin Zhao 已提交
216
  int64_t timestamp;
217
  bool    isNull;
G
Ganlin Zhao 已提交
218
  char    data[];
G
Ganlin Zhao 已提交
219
} STailItem;
G
Ganlin Zhao 已提交
220 221

typedef struct STailInfo {
X
Xiaoyu Wang 已提交
222 223 224 225 226 227
  int32_t     numOfPoints;
  int32_t     numAdded;
  int32_t     offset;
  uint8_t     colType;
  int16_t     colBytes;
  STailItem** pItems;
G
Ganlin Zhao 已提交
228 229
} STailInfo;

G
Ganlin Zhao 已提交
230 231 232 233 234 235 236 237 238 239
typedef struct SUniqueItem {
  int64_t timestamp;
  bool    isNull;
  char    data[];
} SUniqueItem;

typedef struct SUniqueInfo {
  int32_t   numOfPoints;
  uint8_t   colType;
  int16_t   colBytes;
X
Xiaoyu Wang 已提交
240 241
  bool      hasNull;  // null is not hashable, handle separately
  SHashObj* pHash;
G
Ganlin Zhao 已提交
242 243 244
  char      pItems[];
} SUniqueInfo;

G
Ganlin Zhao 已提交
245
typedef struct SModeItem {
246 247 248
  int64_t   count;
  STuplePos tuplePos;
  char      data[];
G
Ganlin Zhao 已提交
249 250 251 252 253 254 255
} SModeItem;

typedef struct SModeInfo {
  int32_t   numOfPoints;
  uint8_t   colType;
  int16_t   colBytes;
  SHashObj* pHash;
256 257 258 259

  STuplePos nullTuplePos;
  bool      nullTupleSaved;

260
  char pItems[];
G
Ganlin Zhao 已提交
261 262
} SModeInfo;

G
Ganlin Zhao 已提交
263 264 265 266 267 268 269 270 271
typedef struct SDerivInfo {
  double  prevValue;       // previous value
  TSKEY   prevTs;          // previous timestamp
  bool    ignoreNegative;  // ignore the negative value
  int64_t tsWindow;        // time window for derivative
  bool    valueSet;        // the value has been set already
} SDerivInfo;

typedef struct SRateInfo {
272 273 274 275 276
  double firstValue;
  TSKEY  firstKey;
  double lastValue;
  TSKEY  lastKey;
  int8_t hasResult;  // flag to denote has value
G
Ganlin Zhao 已提交
277 278
} SRateInfo;

279 280 281 282
typedef struct SGroupKeyInfo {
  bool hasResult;
  bool isNull;
  char data[];
G
Ganlin Zhao 已提交
283 284
} SGroupKeyInfo;

285 286 287 288 289 290
#define SET_VAL(_info, numOfElem, res) \
  do {                                 \
    if ((numOfElem) <= 0) {            \
      break;                           \
    }                                  \
    (_info)->numOfRes = (res);         \
H
Haojun Liao 已提交
291 292
  } while (0)

G
Ganlin Zhao 已提交
293 294 295
#define GET_TS_LIST(x)    ((TSKEY*)((x)->ptsList))
#define GET_TS_DATA(x, y) (GET_TS_LIST(x)[(y)])

G
Ganlin Zhao 已提交
296 297 298 299 300 301 302 303 304 305 306 307
#define DO_UPDATE_SUBSID_RES(ctx, ts)                          \
  do {                                                         \
    for (int32_t _i = 0; _i < (ctx)->subsidiaries.num; ++_i) { \
      SqlFunctionCtx* __ctx = (ctx)->subsidiaries.pCtx[_i];    \
      if (__ctx->functionId == FUNCTION_TS_DUMMY) {            \
        __ctx->tag.i = (ts);                                   \
        __ctx->tag.nType = TSDB_DATA_TYPE_BIGINT;              \
      }                                                        \
      __ctx->fpSet.process(__ctx);                             \
    }                                                          \
  } while (0)

G
Ganlin Zhao 已提交
308 309 310 311 312 313 314 315 316 317 318
#define UPDATE_DATA(ctx, left, right, num, sign, _ts) \
  do {                                                \
    if (((left) < (right)) ^ (sign)) {                \
      (left) = (right);                               \
      DO_UPDATE_SUBSID_RES(ctx, _ts);                 \
      (num) += 1;                                     \
    }                                                 \
  } while (0)

#define LOOPCHECK_N(val, _col, ctx, _t, _nrow, _start, sign, num)        \
  do {                                                                   \
319
    _t* d = (_t*)((_col)->pData);                                        \
G
Ganlin Zhao 已提交
320 321 322 323 324 325 326 327 328
    for (int32_t i = (_start); i < (_nrow) + (_start); ++i) {            \
      if (((_col)->hasNull) && colDataIsNull_f((_col)->nullbitmap, i)) { \
        continue;                                                        \
      }                                                                  \
      TSKEY ts = (ctx)->ptsList != NULL ? GET_TS_DATA(ctx, i) : 0;       \
      UPDATE_DATA(ctx, val, d[i], num, sign, ts);                        \
    }                                                                    \
  } while (0)

329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
#define LIST_ADD_N(_res, _col, _start, _rows, _t, numOfElem)             \
  do {                                                                   \
    _t* d = (_t*)(_col->pData);                                          \
    for (int32_t i = (_start); i < (_rows) + (_start); ++i) {            \
      if (((_col)->hasNull) && colDataIsNull_f((_col)->nullbitmap, i)) { \
        continue;                                                        \
      };                                                                 \
      (_res) += (d)[i];                                                  \
      (numOfElem)++;                                                     \
    }                                                                    \
  } while (0)

#define LIST_SUB_N(_res, _col, _start, _rows, _t, numOfElem)             \
  do {                                                                   \
    _t* d = (_t*)(_col->pData);                                          \
    for (int32_t i = (_start); i < (_rows) + (_start); ++i) {            \
      if (((_col)->hasNull) && colDataIsNull_f((_col)->nullbitmap, i)) { \
        continue;                                                        \
      };                                                                 \
      (_res) -= (d)[i];                                                  \
      (numOfElem)++;                                                     \
    }                                                                    \
  } while (0)

H
Haojun Liao 已提交
353 354 355 356 357 358 359 360 361 362 363 364 365
//#define LIST_AVG_N(sumT, T)                                               \
//  do {                                                                    \
//    T* plist = (T*)pCol->pData;                                           \
//    for (int32_t i = start; i < numOfRows + pInput->startRowIndex; ++i) { \
//      if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {        \
//        continue;                                                         \
//      }                                                                   \
//                                                                          \
//      numOfElem += 1;                                                     \
//      pAvgRes->count -= 1;                                                \
//      sumT -= plist[i];                                                   \
//    }                                                                     \
//  } while (0)
366 367 368 369 370 371 372 373 374 375 376

#define LIST_STDDEV_SUB_N(sumT, T)                                 \
  do {                                                             \
    T* plist = (T*)pCol->pData;                                    \
    for (int32_t i = start; i < numOfRows + start; ++i) {          \
      if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) { \
        continue;                                                  \
      }                                                            \
      numOfElem += 1;                                              \
      pStddevRes->count -= 1;                                      \
      sumT -= plist[i];                                            \
5
54liuyao 已提交
377
      pStddevRes->quadraticISum -= (int64_t)(plist[i] * plist[i]); \
378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425
    }                                                              \
  } while (0)

#define LEASTSQR_CAL(p, x, y, index, step) \
  do {                                     \
    (p)[0][0] += (double)(x) * (x);        \
    (p)[0][1] += (double)(x);              \
    (p)[0][2] += (double)(x) * (y)[index]; \
    (p)[1][2] += (y)[index];               \
    (x) += step;                           \
  } while (0)

#define STATE_COMP(_op, _lval, _param) STATE_COMP_IMPL(_op, _lval, GET_STATE_VAL(_param))

#define GET_STATE_VAL(param) ((param.nType == TSDB_DATA_TYPE_BIGINT) ? (param.i) : (param.d))

#define STATE_COMP_IMPL(_op, _lval, _rval) \
  do {                                     \
    switch (_op) {                         \
      case STATE_OPER_LT:                  \
        return ((_lval) < (_rval));        \
        break;                             \
      case STATE_OPER_GT:                  \
        return ((_lval) > (_rval));        \
        break;                             \
      case STATE_OPER_LE:                  \
        return ((_lval) <= (_rval));       \
        break;                             \
      case STATE_OPER_GE:                  \
        return ((_lval) >= (_rval));       \
        break;                             \
      case STATE_OPER_NE:                  \
        return ((_lval) != (_rval));       \
        break;                             \
      case STATE_OPER_EQ:                  \
        return ((_lval) == (_rval));       \
        break;                             \
      default:                             \
        break;                             \
    }                                      \
  } while (0)

#define INIT_INTP_POINT(_p, _k, _v) \
  do {                              \
    (_p).key = (_k);                \
    (_p).val = (_v);                \
  } while (0)

5
54liuyao 已提交
426 427
static int32_t firstLastTransferInfoImpl(SFirstLastRes* pInput, SFirstLastRes* pOutput, bool isFirst);

428
bool functionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
H
Haojun Liao 已提交
429 430 431 432 433 434 435 436 437 438 439 440
  if (pResultInfo->initialized) {
    return false;
  }

  if (pCtx->pOutput != NULL) {
    memset(pCtx->pOutput, 0, (size_t)pCtx->resDataInfo.bytes);
  }

  initResultRowEntry(pResultInfo, pCtx->resDataInfo.interBufSize);
  return true;
}

441
int32_t functionFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
442
  int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
443
  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
444

445
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
H
Haojun Liao 已提交
446
  pResInfo->isNullRes = (pResInfo->numOfRes == 0) ? 1 : 0;
447 448 449 450 451

  char* in = GET_ROWCELL_INTERBUF(pResInfo);
  colDataAppend(pCol, pBlock->info.rows, in, pResInfo->isNullRes);

  return pResInfo->numOfRes;
H
Haojun Liao 已提交
452 453
}

5
54liuyao 已提交
454 455
int32_t firstCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);
456
  SFirstLastRes*       pDBuf = GET_ROWCELL_INTERBUF(pDResInfo);
457
  int32_t              bytes = pDBuf->bytes;
5
54liuyao 已提交
458 459

  SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
460
  SFirstLastRes*       pSBuf = GET_ROWCELL_INTERBUF(pSResInfo);
5
54liuyao 已提交
461

5
54liuyao 已提交
462 463
  if (TSDB_CODE_SUCCESS == firstLastTransferInfoImpl(pSBuf, pDBuf, true)) {
    pDBuf->hasResult = true;
5
54liuyao 已提交
464
  }
5
54liuyao 已提交
465 466 467

  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
  pDResInfo->isNullRes &= pSResInfo->isNullRes;
5
54liuyao 已提交
468 469 470
  return TSDB_CODE_SUCCESS;
}

471
int32_t functionFinalizeWithResultBuf(SqlFunctionCtx* pCtx, SSDataBlock* pBlock, char* finalResult) {
472
  int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
473 474 475
  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);

  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
H
Haojun Liao 已提交
476
  pResInfo->isNullRes = (pResInfo->numOfRes == 0) ? 1 : 0;
477 478 479 480 481 482 483

  char* in = finalResult;
  colDataAppend(pCol, pBlock->info.rows, in, pResInfo->isNullRes);

  return pResInfo->numOfRes;
}

484 485 486
EFuncDataRequired countDataRequired(SFunctionNode* pFunc, STimeWindow* pTimeWindow) {
  SNode* pParam = nodesListGetNode(pFunc->pParameterList, 0);
  if (QUERY_NODE_COLUMN == nodeType(pParam) && PRIMARYKEY_TIMESTAMP_COL_ID == ((SColumnNode*)pParam)->colId) {
487
    return FUNC_DATA_REQUIRED_NOT_LOAD;
488
  }
H
Haojun Liao 已提交
489
  return FUNC_DATA_REQUIRED_SMA_LOAD;
490
}
H
Haojun Liao 已提交
491 492 493 494 495 496

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

497
static int32_t getNumOfElems(SqlFunctionCtx* pCtx) {
H
Haojun Liao 已提交
498 499 500
  int32_t numOfElem = 0;

  /*
H
Haojun Liao 已提交
501 502 503
   * 1. column data missing (schema modified) causes pInputCol->hasNull == true. pInput->colDataSMAIsSet == true;
   * 2. for general non-primary key columns, pInputCol->hasNull may be true or false, pInput->colDataSMAIsSet == true;
   * 3. for primary key column, pInputCol->hasNull always be false, pInput->colDataSMAIsSet == false;
H
Haojun Liao 已提交
504 505
   */
  SInputColumnInfoData* pInput = &pCtx->input;
506
  SColumnInfoData*      pInputCol = pInput->pData[0];
507
  if (pInput->colDataSMAIsSet && pInput->totalRows == pInput->numOfRows && !IS_VAR_DATA_TYPE(pInputCol->info.type)) {
H
Haojun Liao 已提交
508
    numOfElem = pInput->numOfRows - pInput->pColumnDataAgg[0]->numOfNull;
509
    tAssert(numOfElem >= 0);
H
Haojun Liao 已提交
510 511 512 513 514 515 516 517 518
  } else {
    if (pInputCol->hasNull) {
      for (int32_t i = pInput->startRowIndex; i < pInput->startRowIndex + pInput->numOfRows; ++i) {
        if (colDataIsNull(pInputCol, pInput->totalRows, i, NULL)) {
          continue;
        }
        numOfElem += 1;
      }
    } else {
519 520
      // when counting on the primary time stamp column and no statistics data is presented, use the size value
      // directly.
H
Haojun Liao 已提交
521 522 523
      numOfElem = pInput->numOfRows;
    }
  }
5
54liuyao 已提交
524 525
  return numOfElem;
}
526

5
54liuyao 已提交
527 528 529 530 531
/*
 * count function does need the finalize, if data is missing, the default value, which is 0, is used
 * count function does not use the pCtx->interResBuf to keep the intermediate buffer
 */
int32_t countFunction(SqlFunctionCtx* pCtx) {
G
Ganlin Zhao 已提交
532
  int32_t numOfElem = 0;
533

X
Xiaoyu Wang 已提交
534
  SResultRowEntryInfo*  pResInfo = GET_RES_INFO(pCtx);
535
  SInputColumnInfoData* pInput = &pCtx->input;
536 537

  int32_t type = pInput->pData[0]->info.type;
538 539 540

  char* buf = GET_ROWCELL_INTERBUF(pResInfo);
  if (IS_NULL_TYPE(type)) {
X
Xiaoyu Wang 已提交
541
    // select count(NULL) returns 0
542 543 544
    numOfElem = 1;
    *((int64_t*)buf) = 0;
  } else {
G
Ganlin Zhao 已提交
545
    numOfElem = getNumOfElems(pCtx);
546 547
    *((int64_t*)buf) += numOfElem;
  }
H
Haojun Liao 已提交
548

549 550 551
  if (tsCountAlwaysReturnValue) {
    pResInfo->numOfRes = 1;
  } else {
552
    SET_VAL(pResInfo, *((int64_t*)buf), 1);
553 554
  }

wmmhello's avatar
wmmhello 已提交
555
  return TSDB_CODE_SUCCESS;
H
Haojun Liao 已提交
556 557
}

5
54liuyao 已提交
558
int32_t countInvertFunction(SqlFunctionCtx* pCtx) {
559
  int32_t numOfElem = getNumOfElems(pCtx);
5
54liuyao 已提交
560 561 562 563 564 565 566 567 568

  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  char*                buf = GET_ROWCELL_INTERBUF(pResInfo);
  *((int64_t*)buf) -= numOfElem;

  SET_VAL(pResInfo, *((int64_t*)buf), 1);
  return TSDB_CODE_SUCCESS;
}

5
54liuyao 已提交
569 570
int32_t combineFunction(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);
X
Xiaoyu Wang 已提交
571
  char*                pDBuf = GET_ROWCELL_INTERBUF(pDResInfo);
5
54liuyao 已提交
572 573 574 575 576 577 578 579 580

  SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
  char*                pSBuf = GET_ROWCELL_INTERBUF(pSResInfo);
  *((int64_t*)pDBuf) += *((int64_t*)pSBuf);

  SET_VAL(pDResInfo, *((int64_t*)pDBuf), 1);
  return TSDB_CODE_SUCCESS;
}

581
int32_t sumFunction(SqlFunctionCtx* pCtx) {
H
Haojun Liao 已提交
582 583 584 585
  int32_t numOfElem = 0;

  // Only the pre-computing information loaded and actual data does not loaded
  SInputColumnInfoData* pInput = &pCtx->input;
X
Xiaoyu Wang 已提交
586 587
  SColumnDataAgg*       pAgg = pInput->pColumnDataAgg[0];
  int32_t               type = pInput->pData[0]->info.type;
H
Haojun Liao 已提交
588

589
  SSumRes* pSumRes = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
590
  pSumRes->type = type;
G
Ganlin Zhao 已提交
591

592
  if (IS_NULL_TYPE(type)) {
593
    numOfElem = 0;
594 595 596
    goto _sum_over;
  }

H
Haojun Liao 已提交
597
  if (pInput->colDataSMAIsSet) {
H
Haojun Liao 已提交
598
    numOfElem = pInput->numOfRows - pAgg->numOfNull;
599
    tAssert(numOfElem >= 0);
H
Haojun Liao 已提交
600 601

    if (IS_SIGNED_NUMERIC_TYPE(type)) {
602
      pSumRes->isum += pAgg->sum;
H
Haojun Liao 已提交
603
    } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
604
      pSumRes->usum += pAgg->sum;
H
Haojun Liao 已提交
605
    } else if (IS_FLOAT_TYPE(type)) {
606
      pSumRes->dsum += GET_DOUBLE_VAL((const char*)&(pAgg->sum));
H
Haojun Liao 已提交
607 608 609 610
    }
  } else {  // computing based on the true data block
    SColumnInfoData* pCol = pInput->pData[0];

611
    int32_t start = pInput->startRowIndex;
H
Haojun Liao 已提交
612 613
    int32_t numOfRows = pInput->numOfRows;

614 615
    if (IS_SIGNED_NUMERIC_TYPE(type) || type == TSDB_DATA_TYPE_BOOL) {
      if (type == TSDB_DATA_TYPE_TINYINT || type == TSDB_DATA_TYPE_BOOL) {
616 617 618 619 620 621 622
        LIST_ADD_N(pSumRes->isum, pCol, start, numOfRows, int8_t, numOfElem);
      } else if (type == TSDB_DATA_TYPE_SMALLINT) {
        LIST_ADD_N(pSumRes->isum, pCol, start, numOfRows, int16_t, numOfElem);
      } else if (type == TSDB_DATA_TYPE_INT) {
        LIST_ADD_N(pSumRes->isum, pCol, start, numOfRows, int32_t, numOfElem);
      } else if (type == TSDB_DATA_TYPE_BIGINT) {
        LIST_ADD_N(pSumRes->isum, pCol, start, numOfRows, int64_t, numOfElem);
H
Haojun Liao 已提交
623
      }
624 625 626 627 628 629 630 631 632
    } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
      if (type == TSDB_DATA_TYPE_UTINYINT) {
        LIST_ADD_N(pSumRes->usum, pCol, start, numOfRows, uint8_t, numOfElem);
      } else if (type == TSDB_DATA_TYPE_USMALLINT) {
        LIST_ADD_N(pSumRes->usum, pCol, start, numOfRows, uint16_t, numOfElem);
      } else if (type == TSDB_DATA_TYPE_UINT) {
        LIST_ADD_N(pSumRes->usum, pCol, start, numOfRows, uint32_t, numOfElem);
      } else if (type == TSDB_DATA_TYPE_UBIGINT) {
        LIST_ADD_N(pSumRes->usum, pCol, start, numOfRows, uint64_t, numOfElem);
H
Haojun Liao 已提交
633
      }
634 635 636 637
    } else if (type == TSDB_DATA_TYPE_DOUBLE) {
      LIST_ADD_N(pSumRes->dsum, pCol, start, numOfRows, double, numOfElem);
    } else if (type == TSDB_DATA_TYPE_FLOAT) {
      LIST_ADD_N(pSumRes->dsum, pCol, start, numOfRows, float, numOfElem);
H
Haojun Liao 已提交
638 639 640
    }
  }

X
Xiaoyu Wang 已提交
641
  // check for overflow
642
  if (IS_FLOAT_TYPE(type) && (isinf(pSumRes->dsum) || isnan(pSumRes->dsum))) {
H
Haojun Liao 已提交
643
    numOfElem = 0;
644 645
  }

646
_sum_over:
H
Haojun Liao 已提交
647 648
  // data in the check operation are all null, not output
  SET_VAL(GET_RES_INFO(pCtx), numOfElem, 1);
wmmhello's avatar
wmmhello 已提交
649
  return TSDB_CODE_SUCCESS;
H
Haojun Liao 已提交
650 651
}

5
54liuyao 已提交
652 653 654 655 656 657 658 659 660 661
int32_t sumInvertFunction(SqlFunctionCtx* pCtx) {
  int32_t numOfElem = 0;

  // Only the pre-computing information loaded and actual data does not loaded
  SInputColumnInfoData* pInput = &pCtx->input;
  SColumnDataAgg*       pAgg = pInput->pColumnDataAgg[0];
  int32_t               type = pInput->pData[0]->info.type;

  SSumRes* pSumRes = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));

H
Haojun Liao 已提交
662
  if (pInput->colDataSMAIsSet) {
5
54liuyao 已提交
663
    numOfElem = pInput->numOfRows - pAgg->numOfNull;
664
    tAssert(numOfElem >= 0);
5
54liuyao 已提交
665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710

    if (IS_SIGNED_NUMERIC_TYPE(type)) {
      pSumRes->isum -= pAgg->sum;
    } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
      pSumRes->usum -= pAgg->sum;
    } else if (IS_FLOAT_TYPE(type)) {
      pSumRes->dsum -= GET_DOUBLE_VAL((const char*)&(pAgg->sum));
    }
  } else {  // computing based on the true data block
    SColumnInfoData* pCol = pInput->pData[0];

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

    if (IS_SIGNED_NUMERIC_TYPE(type) || type == TSDB_DATA_TYPE_BOOL) {
      if (type == TSDB_DATA_TYPE_TINYINT || type == TSDB_DATA_TYPE_BOOL) {
        LIST_SUB_N(pSumRes->isum, pCol, start, numOfRows, int8_t, numOfElem);
      } else if (type == TSDB_DATA_TYPE_SMALLINT) {
        LIST_SUB_N(pSumRes->isum, pCol, start, numOfRows, int16_t, numOfElem);
      } else if (type == TSDB_DATA_TYPE_INT) {
        LIST_SUB_N(pSumRes->isum, pCol, start, numOfRows, int32_t, numOfElem);
      } else if (type == TSDB_DATA_TYPE_BIGINT) {
        LIST_SUB_N(pSumRes->isum, pCol, start, numOfRows, int64_t, numOfElem);
      }
    } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
      if (type == TSDB_DATA_TYPE_UTINYINT) {
        LIST_SUB_N(pSumRes->usum, pCol, start, numOfRows, uint8_t, numOfElem);
      } else if (type == TSDB_DATA_TYPE_USMALLINT) {
        LIST_SUB_N(pSumRes->usum, pCol, start, numOfRows, uint16_t, numOfElem);
      } else if (type == TSDB_DATA_TYPE_UINT) {
        LIST_SUB_N(pSumRes->usum, pCol, start, numOfRows, uint32_t, numOfElem);
      } else if (type == TSDB_DATA_TYPE_UBIGINT) {
        LIST_SUB_N(pSumRes->usum, pCol, start, numOfRows, uint64_t, numOfElem);
      }
    } else if (type == TSDB_DATA_TYPE_DOUBLE) {
      LIST_SUB_N(pSumRes->dsum, pCol, start, numOfRows, double, numOfElem);
    } else if (type == TSDB_DATA_TYPE_FLOAT) {
      LIST_SUB_N(pSumRes->dsum, pCol, start, numOfRows, float, numOfElem);
    }
  }

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

5
54liuyao 已提交
711 712
int32_t sumCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);
X
Xiaoyu Wang 已提交
713
  SSumRes*             pDBuf = GET_ROWCELL_INTERBUF(pDResInfo);
5
54liuyao 已提交
714 715

  SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
X
Xiaoyu Wang 已提交
716
  SSumRes*             pSBuf = GET_ROWCELL_INTERBUF(pSResInfo);
717
  int16_t              type = pDBuf->type == TSDB_DATA_TYPE_NULL ? pSBuf->type : pDBuf->type;
718

5
54liuyao 已提交
719 720 721 722 723 724 725
  if (IS_SIGNED_NUMERIC_TYPE(type) || type == TSDB_DATA_TYPE_BOOL) {
    pDBuf->isum += pSBuf->isum;
  } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
    pDBuf->usum += pSBuf->usum;
  } else if (type == TSDB_DATA_TYPE_DOUBLE || type == TSDB_DATA_TYPE_FLOAT) {
    pDBuf->dsum += pSBuf->dsum;
  }
5
54liuyao 已提交
726
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
5
54liuyao 已提交
727
  pDResInfo->isNullRes &= pSResInfo->isNullRes;
5
54liuyao 已提交
728 729 730
  return TSDB_CODE_SUCCESS;
}

H
Haojun Liao 已提交
731
bool getSumFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
H
Haojun Liao 已提交
732 733 734 735
  pEnv->calcMemSize = sizeof(SSumRes);
  return true;
}

736
EFuncDataRequired statisDataRequired(SFunctionNode* pFunc, STimeWindow* pTimeWindow) {
H
Haojun Liao 已提交
737
  return FUNC_DATA_REQUIRED_SMA_LOAD;
738 739
}

740
bool minmaxFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
741 742 743 744
  if (!functionSetup(pCtx, pResultInfo)) {
    return false;  // not initialized since it has been initialized
  }

745 746 747
  SMinmaxResInfo* buf = GET_ROWCELL_INTERBUF(pResultInfo);
  buf->assign = false;
  buf->tuplePos.pageId = -1;
748 749 750

  buf->nullTupleSaved = false;
  buf->nullTuplePos.pageId = -1;
751 752 753
  return true;
}

H
Haojun Liao 已提交
754
bool getMinmaxFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
755
  pEnv->calcMemSize = sizeof(SMinmaxResInfo);
756 757 758
  return true;
}

759
int32_t minFunction(SqlFunctionCtx* pCtx) {
760 761
  int32_t numOfElems = doMinMaxHelper(pCtx, 1);
  SET_VAL(GET_RES_INFO(pCtx), numOfElems, 1);
wmmhello's avatar
wmmhello 已提交
762
  return TSDB_CODE_SUCCESS;
763 764
}

765
int32_t maxFunction(SqlFunctionCtx* pCtx) {
766 767
  int32_t numOfElems = doMinMaxHelper(pCtx, 0);
  SET_VAL(GET_RES_INFO(pCtx), numOfElems, 1);
wmmhello's avatar
wmmhello 已提交
768
  return TSDB_CODE_SUCCESS;
H
Haojun Liao 已提交
769 770
}

771
static void setNullSelectivityValue(SqlFunctionCtx* pCtx, SSDataBlock* pBlock, int32_t rowIndex);
L
Liu Jicong 已提交
772 773
static void setSelectivityValue(SqlFunctionCtx* pCtx, SSDataBlock* pBlock, const STuplePos* pTuplePos,
                                int32_t rowIndex);
774

775 776 777 778 779 780
int32_t minmaxFunctionFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SResultRowEntryInfo* pEntryInfo = GET_RES_INFO(pCtx);

  SMinmaxResInfo* pRes = GET_ROWCELL_INTERBUF(pEntryInfo);

  int32_t slotId = pCtx->pExpr->base.resSchema.slotId;
781
  int32_t currentRow = pBlock->info.rows;
782 783

  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);
H
Haojun Liao 已提交
784
  pEntryInfo->isNullRes = (pEntryInfo->numOfRes == 0) ? 1 : 0;
785

786
  if (pCol->info.type == TSDB_DATA_TYPE_FLOAT) {
787
    float v = *(float*)&pRes->v;
788
    colDataAppend(pCol, currentRow, (const char*)&v, pEntryInfo->isNullRes);
789
  } else {
790
    colDataAppend(pCol, currentRow, (const char*)&pRes->v, pEntryInfo->isNullRes);
791
  }
792

793 794
  if (pEntryInfo->numOfRes > 0) {
    setSelectivityValue(pCtx, pBlock, &pRes->tuplePos, currentRow);
795
  } else {
796
    setSelectivityValue(pCtx, pBlock, &pRes->nullTuplePos, currentRow);
797 798
  }

799 800
  return pEntryInfo->numOfRes;
}
801

802
void setNullSelectivityValue(SqlFunctionCtx* pCtx, SSDataBlock* pBlock, int32_t rowIndex) {
803 804 805 806
  if (pCtx->subsidiaries.num <= 0) {
    return;
  }

807 808
  for (int32_t j = 0; j < pCtx->subsidiaries.num; ++j) {
    SqlFunctionCtx* pc = pCtx->subsidiaries.pCtx[j];
809
    int32_t         dstSlotId = pc->pExpr->base.resSchema.slotId;
810 811 812 813 814 815

    SColumnInfoData* pDstCol = taosArrayGet(pBlock->pDataBlock, dstSlotId);
    colDataAppendNULL(pDstCol, rowIndex);
  }
}

X
Xiaoyu Wang 已提交
816
void setSelectivityValue(SqlFunctionCtx* pCtx, SSDataBlock* pBlock, const STuplePos* pTuplePos, int32_t rowIndex) {
817 818 819 820
  if (pCtx->subsidiaries.num <= 0) {
    return;
  }

821 822
  if (pCtx->saveHandle.pBuf != NULL) {
    if (pTuplePos->pageId != -1) {
L
Liu Jicong 已提交
823
      int32_t     numOfCols = pCtx->subsidiaries.num;
824
      const char* p = loadTupleData(pCtx, pTuplePos);
825

826 827
      bool* nullList = (bool*)p;
      char* pStart = (char*)(nullList + numOfCols * sizeof(bool));
828

829 830 831
      // todo set the offset value to optimize the performance.
      for (int32_t j = 0; j < numOfCols; ++j) {
        SqlFunctionCtx* pc = pCtx->subsidiaries.pCtx[j];
L
Liu Jicong 已提交
832
        int32_t         dstSlotId = pc->pExpr->base.resSchema.slotId;
833

834
        SColumnInfoData* pDstCol = taosArrayGet(pBlock->pDataBlock, dstSlotId);
835
        tAssert(pc->pExpr->base.resSchema.bytes == pDstCol->info.bytes);
836 837 838 839 840 841
        if (nullList[j]) {
          colDataAppendNULL(pDstCol, rowIndex);
        } else {
          colDataAppend(pDstCol, rowIndex, pStart, false);
        }
        pStart += pDstCol->info.bytes;
842 843 844 845 846
      }
    }
  }
}

847 848
void releaseSource(STuplePos* pPos) {
  if (pPos->pageId == -1) {
X
Xiaoyu Wang 已提交
849
    return;
850 851 852 853
  }
  // Todo(liuyao) relase row
}

854 855
// This function append the selectivity to subsidiaries function context directly, without fetching data
// from intermediate disk based buf page
856
void appendSelectivityValue(SqlFunctionCtx* pCtx, int32_t rowIndex, int32_t pos) {
857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872
  if (pCtx->subsidiaries.num <= 0) {
    return;
  }

  for (int32_t j = 0; j < pCtx->subsidiaries.num; ++j) {
    SqlFunctionCtx* pc = pCtx->subsidiaries.pCtx[j];

    // get data from source col
    SFunctParam* pFuncParam = &pc->pExpr->base.pParam[0];
    int32_t      srcSlotId = pFuncParam->pCol->slotId;

    SColumnInfoData* pSrcCol = taosArrayGet(pCtx->pSrcBlock->pDataBlock, srcSlotId);

    char* pData = colDataGetData(pSrcCol, rowIndex);

    // append to dest col
L
Liu Jicong 已提交
873
    int32_t dstSlotId = pc->pExpr->base.resSchema.slotId;
874 875

    SColumnInfoData* pDstCol = taosArrayGet(pCtx->pDstBlock->pDataBlock, dstSlotId);
876
    tAssert(pc->pExpr->base.resSchema.bytes == pDstCol->info.bytes);
877 878

    if (colDataIsNull_s(pSrcCol, rowIndex) == true) {
879
      colDataAppendNULL(pDstCol, pos);
880
    } else {
881
      colDataAppend(pDstCol, pos, pData, false);
882 883 884 885
    }
  }
}

886 887 888 889 890
void replaceTupleData(STuplePos* pDestPos, STuplePos* pSourcePos) {
  releaseSource(pDestPos);
  *pDestPos = *pSourcePos;
}

5
54liuyao 已提交
891 892 893 894 895 896
int32_t minMaxCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx, int32_t isMinFunc) {
  SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);
  SMinmaxResInfo*      pDBuf = GET_ROWCELL_INTERBUF(pDResInfo);

  SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
  SMinmaxResInfo*      pSBuf = GET_ROWCELL_INTERBUF(pSResInfo);
897
  int16_t              type = pDBuf->type == TSDB_DATA_TYPE_NULL ? pSBuf->type : pDBuf->type;
5
54liuyao 已提交
898
  if (IS_FLOAT_TYPE(type)) {
X
Xiaoyu Wang 已提交
899 900
    if (pSBuf->assign && ((((*(double*)&pDBuf->v) < (*(double*)&pSBuf->v)) ^ isMinFunc) || !pDBuf->assign)) {
      *(double*)&pDBuf->v = *(double*)&pSBuf->v;
901
      replaceTupleData(&pDBuf->tuplePos, &pSBuf->tuplePos);
5
54liuyao 已提交
902
      pDBuf->assign = true;
5
54liuyao 已提交
903 904
    }
  } else {
X
Xiaoyu Wang 已提交
905
    if (pSBuf->assign && (((pDBuf->v < pSBuf->v) ^ isMinFunc) || !pDBuf->assign)) {
5
54liuyao 已提交
906
      pDBuf->v = pSBuf->v;
907
      replaceTupleData(&pDBuf->tuplePos, &pSBuf->tuplePos);
5
54liuyao 已提交
908
      pDBuf->assign = true;
5
54liuyao 已提交
909 910
    }
  }
5
54liuyao 已提交
911
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
5
54liuyao 已提交
912
  pDResInfo->isNullRes &= pSResInfo->isNullRes;
5
54liuyao 已提交
913 914 915 916 917 918 919 920 921 922
  return TSDB_CODE_SUCCESS;
}

int32_t minCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  return minMaxCombine(pDestCtx, pSourceCtx, 1);
}
int32_t maxCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  return minMaxCombine(pDestCtx, pSourceCtx, 0);
}

923 924
int32_t getStddevInfoSize() { return (int32_t)sizeof(SStddevRes); }

H
Haojun Liao 已提交
925 926 927 928 929
bool getStddevFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(SStddevRes);
  return true;
}

930
bool stddevFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
H
Haojun Liao 已提交
931 932 933 934 935 936 937 938 939
  if (!functionSetup(pCtx, pResultInfo)) {
    return false;
  }

  SStddevRes* pRes = GET_ROWCELL_INTERBUF(pResultInfo);
  memset(pRes, 0, sizeof(SStddevRes));
  return true;
}

H
Haojun Liao 已提交
940
int32_t stddevFunction(SqlFunctionCtx* pCtx) {
H
Haojun Liao 已提交
941 942 943 944
  int32_t numOfElem = 0;

  // Only the pre-computing information loaded and actual data does not loaded
  SInputColumnInfoData* pInput = &pCtx->input;
H
Haojun Liao 已提交
945
  int32_t               type = pInput->pData[0]->info.type;
H
Haojun Liao 已提交
946 947

  SStddevRes* pStddevRes = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
G
Ganlin Zhao 已提交
948
  pStddevRes->type = type;
H
Haojun Liao 已提交
949

H
Haojun Liao 已提交
950 951
  // computing based on the true data block
  SColumnInfoData* pCol = pInput->pData[0];
H
Haojun Liao 已提交
952

H
Haojun Liao 已提交
953 954
  int32_t start = pInput->startRowIndex;
  int32_t numOfRows = pInput->numOfRows;
H
Haojun Liao 已提交
955

956
  if (IS_NULL_TYPE(type)) {
H
Haojun Liao 已提交
957
    numOfElem = 0;
958 959 960
    goto _stddev_over;
  }

H
Haojun Liao 已提交
961 962
  switch (type) {
    case TSDB_DATA_TYPE_TINYINT: {
963 964 965 966
      int8_t* plist = (int8_t*)pCol->pData;
      for (int32_t i = start; i < numOfRows + start; ++i) {
        if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
          continue;
H
Haojun Liao 已提交
967
        }
H
Haojun Liao 已提交
968

969 970 971 972
        numOfElem += 1;
        pStddevRes->count += 1;
        pStddevRes->isum += plist[i];
        pStddevRes->quadraticISum += plist[i] * plist[i];
H
Haojun Liao 已提交
973 974
      }

975 976 977 978
      break;
    }

    case TSDB_DATA_TYPE_SMALLINT: {
H
Haojun Liao 已提交
979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023
      int16_t* plist = (int16_t*)pCol->pData;
      for (int32_t i = start; i < numOfRows + pInput->startRowIndex; ++i) {
        if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
          continue;
        }

        numOfElem += 1;
        pStddevRes->count += 1;
        pStddevRes->isum += plist[i];
        pStddevRes->quadraticISum += plist[i] * plist[i];
      }
      break;
    }

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

        numOfElem += 1;
        pStddevRes->count += 1;
        pStddevRes->isum += plist[i];
        pStddevRes->quadraticISum += plist[i] * plist[i];
      }

      break;
    }

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

        numOfElem += 1;
        pStddevRes->count += 1;
        pStddevRes->isum += plist[i];
        pStddevRes->quadraticISum += plist[i] * plist[i];
      }
      break;
    }

1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
    case TSDB_DATA_TYPE_UTINYINT: {
      uint8_t* plist = (uint8_t*)pCol->pData;
      for (int32_t i = start; i < numOfRows + start; ++i) {
        if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
          continue;
        }

        numOfElem += 1;
        pStddevRes->count += 1;
        pStddevRes->usum += plist[i];
G
Ganlin Zhao 已提交
1034
        pStddevRes->quadraticUSum += plist[i] * plist[i];
1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
      }

      break;
    }

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

        numOfElem += 1;
        pStddevRes->count += 1;
        pStddevRes->usum += plist[i];
G
Ganlin Zhao 已提交
1050
        pStddevRes->quadraticUSum += plist[i] * plist[i];
1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
      }
      break;
    }

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

        numOfElem += 1;
        pStddevRes->count += 1;
        pStddevRes->usum += plist[i];
G
Ganlin Zhao 已提交
1065
        pStddevRes->quadraticUSum += plist[i] * plist[i];
1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080
      }

      break;
    }

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

        numOfElem += 1;
        pStddevRes->count += 1;
        pStddevRes->usum += plist[i];
G
Ganlin Zhao 已提交
1081
        pStddevRes->quadraticUSum += plist[i] * plist[i];
1082 1083 1084 1085
      }
      break;
    }

H
Haojun Liao 已提交
1086 1087 1088 1089 1090 1091 1092 1093 1094
    case TSDB_DATA_TYPE_FLOAT: {
      float* plist = (float*)pCol->pData;
      for (int32_t i = start; i < numOfRows + pInput->startRowIndex; ++i) {
        if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
          continue;
        }

        numOfElem += 1;
        pStddevRes->count += 1;
G
Ganlin Zhao 已提交
1095 1096
        pStddevRes->dsum += plist[i];
        pStddevRes->quadraticDSum += plist[i] * plist[i];
H
Haojun Liao 已提交
1097 1098 1099 1100
      }
      break;
    }

H
Haojun Liao 已提交
1101 1102 1103 1104 1105 1106 1107 1108 1109
    case TSDB_DATA_TYPE_DOUBLE: {
      double* plist = (double*)pCol->pData;
      for (int32_t i = start; i < numOfRows + pInput->startRowIndex; ++i) {
        if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
          continue;
        }

        numOfElem += 1;
        pStddevRes->count += 1;
G
Ganlin Zhao 已提交
1110 1111
        pStddevRes->dsum += plist[i];
        pStddevRes->quadraticDSum += plist[i] * plist[i];
H
Haojun Liao 已提交
1112 1113 1114 1115 1116 1117 1118 1119
      }
      break;
    }

    default:
      break;
  }

1120
_stddev_over:
H
Haojun Liao 已提交
1121 1122
  // data in the check operation are all null, not output
  SET_VAL(GET_RES_INFO(pCtx), numOfElem, 1);
wmmhello's avatar
wmmhello 已提交
1123
  return TSDB_CODE_SUCCESS;
H
Haojun Liao 已提交
1124 1125
}

G
Ganlin Zhao 已提交
1126 1127
static void stddevTransferInfo(SStddevRes* pInput, SStddevRes* pOutput) {
  pOutput->type = pInput->type;
1128
  if (IS_SIGNED_NUMERIC_TYPE(pOutput->type)) {
G
Ganlin Zhao 已提交
1129 1130
    pOutput->quadraticISum += pInput->quadraticISum;
    pOutput->isum += pInput->isum;
1131 1132 1133
  } else if (IS_UNSIGNED_NUMERIC_TYPE(pOutput->type)) {
    pOutput->quadraticUSum += pInput->quadraticUSum;
    pOutput->usum += pInput->usum;
G
Ganlin Zhao 已提交
1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144
  } else {
    pOutput->quadraticDSum += pInput->quadraticDSum;
    pOutput->dsum += pInput->dsum;
  }

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

int32_t stddevFunctionMerge(SqlFunctionCtx* pCtx) {
  SInputColumnInfoData* pInput = &pCtx->input;
  SColumnInfoData*      pCol = pInput->pData[0];
1145
  tAssert(pCol->info.type == TSDB_DATA_TYPE_BINARY);
G
Ganlin Zhao 已提交
1146 1147 1148

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

H
Hongze Cheng 已提交
1149
  for (int32_t i = pInput->startRowIndex; i < pInput->startRowIndex + pInput->numOfRows; ++i) {
1150 1151 1152 1153
    char*       data = colDataGetData(pCol, i);
    SStddevRes* pInputInfo = (SStddevRes*)varDataVal(data);
    stddevTransferInfo(pInputInfo, pInfo);
  }
G
Ganlin Zhao 已提交
1154 1155 1156 1157 1158

  SET_VAL(GET_RES_INFO(pCtx), 1, 1);
  return TSDB_CODE_SUCCESS;
}

5
54liuyao 已提交
1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190
int32_t stddevInvertFunction(SqlFunctionCtx* pCtx) {
  int32_t numOfElem = 0;

  // Only the pre-computing information loaded and actual data does not loaded
  SInputColumnInfoData* pInput = &pCtx->input;
  int32_t               type = pInput->pData[0]->info.type;

  SStddevRes* pStddevRes = 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 (type) {
    case TSDB_DATA_TYPE_TINYINT: {
      LIST_STDDEV_SUB_N(pStddevRes->isum, int8_t);
      break;
    }
    case TSDB_DATA_TYPE_SMALLINT: {
      LIST_STDDEV_SUB_N(pStddevRes->isum, int16_t);
      break;
    }
    case TSDB_DATA_TYPE_INT: {
      LIST_STDDEV_SUB_N(pStddevRes->isum, int32_t);
      break;
    }
    case TSDB_DATA_TYPE_BIGINT: {
      LIST_STDDEV_SUB_N(pStddevRes->isum, int64_t);
      break;
    }
1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206
    case TSDB_DATA_TYPE_UTINYINT: {
      LIST_STDDEV_SUB_N(pStddevRes->isum, uint8_t);
      break;
    }
    case TSDB_DATA_TYPE_USMALLINT: {
      LIST_STDDEV_SUB_N(pStddevRes->isum, uint16_t);
      break;
    }
    case TSDB_DATA_TYPE_UINT: {
      LIST_STDDEV_SUB_N(pStddevRes->isum, uint32_t);
      break;
    }
    case TSDB_DATA_TYPE_UBIGINT: {
      LIST_STDDEV_SUB_N(pStddevRes->isum, uint64_t);
      break;
    }
5
54liuyao 已提交
1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223
    case TSDB_DATA_TYPE_FLOAT: {
      LIST_STDDEV_SUB_N(pStddevRes->dsum, float);
      break;
    }
    case TSDB_DATA_TYPE_DOUBLE: {
      LIST_STDDEV_SUB_N(pStddevRes->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;
}

H
Haojun Liao 已提交
1224
int32_t stddevFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
G
Ganlin Zhao 已提交
1225
  SInputColumnInfoData* pInput = &pCtx->input;
1226
  SStddevRes*           pStddevRes = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
G
Ganlin Zhao 已提交
1227
  int32_t               type = pStddevRes->type;
1228
  double                avg;
G
Ganlin Zhao 已提交
1229

1230 1231 1232 1233 1234
  if (pStddevRes->count == 0) {
    GET_RES_INFO(pCtx)->numOfRes = 0;
    return functionFinalize(pCtx, pBlock);
  }

1235
  if (IS_SIGNED_NUMERIC_TYPE(type)) {
1236
    avg = pStddevRes->isum / ((double)pStddevRes->count);
1237
    pStddevRes->result = sqrt(fabs(pStddevRes->quadraticISum / ((double)pStddevRes->count) - avg * avg));
1238 1239 1240
  } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
    avg = pStddevRes->usum / ((double)pStddevRes->count);
    pStddevRes->result = sqrt(fabs(pStddevRes->quadraticUSum / ((double)pStddevRes->count) - avg * avg));
G
Ganlin Zhao 已提交
1241
  } else {
1242
    avg = pStddevRes->dsum / ((double)pStddevRes->count);
1243
    pStddevRes->result = sqrt(fabs(pStddevRes->quadraticDSum / ((double)pStddevRes->count) - avg * avg));
G
Ganlin Zhao 已提交
1244
  }
1245

1246 1247 1248 1249 1250
  // check for overflow
  if (isinf(pStddevRes->result) || isnan(pStddevRes->result)) {
    GET_RES_INFO(pCtx)->numOfRes = 0;
  }

1251
  return functionFinalize(pCtx, pBlock);
H
Haojun Liao 已提交
1252 1253
}

G
Ganlin Zhao 已提交
1254 1255
int32_t stddevPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
1256 1257 1258
  SStddevRes*          pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
  int32_t              resultBytes = getStddevInfoSize();
  char*                res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
G
Ganlin Zhao 已提交
1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271

  memcpy(varDataVal(res), pInfo, resultBytes);
  varDataSetLen(res, resultBytes);

  int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);

  colDataAppend(pCol, pBlock->info.rows, res, false);

  taosMemoryFree(res);
  return pResInfo->numOfRes;
}

5
54liuyao 已提交
1272 1273
int32_t stddevCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);
X
Xiaoyu Wang 已提交
1274
  SStddevRes*          pDBuf = GET_ROWCELL_INTERBUF(pDResInfo);
5
54liuyao 已提交
1275 1276

  SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
X
Xiaoyu Wang 已提交
1277
  SStddevRes*          pSBuf = GET_ROWCELL_INTERBUF(pSResInfo);
1278
  int16_t              type = pDBuf->type == TSDB_DATA_TYPE_NULL ? pSBuf->type : pDBuf->type;
5
54liuyao 已提交
1279

5
54liuyao 已提交
1280 1281
  stddevTransferInfo(pSBuf, pDBuf);

5
54liuyao 已提交
1282
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
5
54liuyao 已提交
1283
  pDResInfo->isNullRes &= pSResInfo->isNullRes;
5
54liuyao 已提交
1284 1285 1286
  return TSDB_CODE_SUCCESS;
}

1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298
bool getLeastSQRFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(SLeastSQRInfo);
  return true;
}

bool leastSQRFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
  if (!functionSetup(pCtx, pResultInfo)) {
    return false;
  }

  SLeastSQRInfo* pInfo = GET_ROWCELL_INTERBUF(pResultInfo);

1299 1300
  GET_TYPED_DATA(pInfo->startVal, double, pCtx->param[1].param.nType, &pCtx->param[1].param.i);
  GET_TYPED_DATA(pInfo->stepVal, double, pCtx->param[2].param.nType, &pCtx->param[2].param.i);
1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329
  return true;
}

int32_t leastSQRFunction(SqlFunctionCtx* pCtx) {
  int32_t numOfElem = 0;

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

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

  SColumnInfoData* pCol = pInput->pData[0];

  double(*param)[3] = pInfo->matrix;
  double x = pInfo->startVal;

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

  switch (type) {
    case TSDB_DATA_TYPE_TINYINT: {
      int8_t* plist = (int8_t*)pCol->pData;
      for (int32_t i = start; i < numOfRows + pInput->startRowIndex; ++i) {
        if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
          continue;
        }
        numOfElem++;
        LEASTSQR_CAL(param, x, plist, i, pInfo->stepVal);
      }
1330
      break;
1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370
    }
    case TSDB_DATA_TYPE_SMALLINT: {
      int16_t* plist = (int16_t*)pCol->pData;
      for (int32_t i = start; i < numOfRows + pInput->startRowIndex; ++i) {
        if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
          continue;
        }

        numOfElem++;
        LEASTSQR_CAL(param, x, plist, i, pInfo->stepVal);
      }
      break;
    }

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

        numOfElem++;
        LEASTSQR_CAL(param, x, plist, i, pInfo->stepVal);
      }
      break;
    }

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

        numOfElem++;
        LEASTSQR_CAL(param, x, plist, i, pInfo->stepVal);
      }
      break;
    }

1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420
    case TSDB_DATA_TYPE_UTINYINT: {
      uint8_t* plist = (uint8_t*)pCol->pData;
      for (int32_t i = start; i < numOfRows + pInput->startRowIndex; ++i) {
        if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
          continue;
        }
        numOfElem++;
        LEASTSQR_CAL(param, x, plist, i, pInfo->stepVal);
      }
      break;
    }
    case TSDB_DATA_TYPE_USMALLINT: {
      uint16_t* plist = (uint16_t*)pCol->pData;
      for (int32_t i = start; i < numOfRows + pInput->startRowIndex; ++i) {
        if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
          continue;
        }

        numOfElem++;
        LEASTSQR_CAL(param, x, plist, i, pInfo->stepVal);
      }
      break;
    }

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

        numOfElem++;
        LEASTSQR_CAL(param, x, plist, i, pInfo->stepVal);
      }
      break;
    }

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

        numOfElem++;
        LEASTSQR_CAL(param, x, plist, i, pInfo->stepVal);
      }
      break;
    }

1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445
    case TSDB_DATA_TYPE_FLOAT: {
      float* plist = (float*)pCol->pData;
      for (int32_t i = start; i < numOfRows + pInput->startRowIndex; ++i) {
        if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
          continue;
        }

        numOfElem++;
        LEASTSQR_CAL(param, x, plist, i, pInfo->stepVal);
      }
      break;
    }

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

        numOfElem++;
        LEASTSQR_CAL(param, x, plist, i, pInfo->stepVal);
      }
      break;
    }
1446 1447 1448 1449 1450
    case TSDB_DATA_TYPE_NULL: {
      GET_RES_INFO(pCtx)->isNullRes = 1;
      numOfElem = 1;
      break;
    }
1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465

    default:
      break;
  }

  pInfo->startVal = x;
  pInfo->num += numOfElem;

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

  return TSDB_CODE_SUCCESS;
}

int32_t leastSQRFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
X
Xiaoyu Wang 已提交
1466 1467 1468
  SLeastSQRInfo*       pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
  int32_t              slotId = pCtx->pExpr->base.resSchema.slotId;
  SColumnInfoData*     pCol = taosArrayGet(pBlock->pDataBlock, slotId);
1469 1470 1471

  int32_t currentRow = pBlock->info.rows;

1472
  if (0 == pInfo->num) {
1473
    colDataAppendNULL(pCol, currentRow);
1474 1475 1476 1477 1478 1479 1480 1481
    return 0;
  }

  double(*param)[3] = pInfo->matrix;

  param[1][1] = (double)pInfo->num;
  param[1][0] = param[0][1];

5
54liuyao 已提交
1482 1483
  double param00 = param[0][0] - param[1][0] * (param[0][1] / param[1][1]);
  double param02 = param[0][2] - param[1][2] * (param[0][1] / param[1][1]);
1484 1485 1486 1487 1488 1489

  if (0 == param00) {
    colDataAppendNULL(pCol, currentRow);
    return 0;
  }

5
54liuyao 已提交
1490 1491 1492 1493
  // param[0][1] = 0;
  double param12 = param[1][2] - param02 * (param[1][0] / param00);
  // param[1][0] = 0;
  param02 /= param00;
1494

5
54liuyao 已提交
1495
  param12 /= param[1][1];
1496

G
Ganlin Zhao 已提交
1497
  char   buf[512] = {0};
X
Xiaoyu Wang 已提交
1498 1499
  size_t len =
      snprintf(varDataVal(buf), sizeof(buf) - VARSTR_HEADER_SIZE, "{slop:%.6lf, intercept:%.6lf}", param02, param12);
1500 1501
  varDataSetLen(buf, len);

1502
  colDataAppend(pCol, currentRow, buf, pResInfo->isNullRes);
1503 1504 1505 1506 1507

  return pResInfo->numOfRes;
}

int32_t leastSQRInvertFunction(SqlFunctionCtx* pCtx) {
X
Xiaoyu Wang 已提交
1508
  // TODO
1509 1510 1511
  return TSDB_CODE_SUCCESS;
}

5
54liuyao 已提交
1512 1513 1514 1515
int32_t leastSQRCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);
  SLeastSQRInfo*       pDBuf = GET_ROWCELL_INTERBUF(pDResInfo);
  int32_t              type = pDestCtx->input.pData[0]->info.type;
X
Xiaoyu Wang 已提交
1516
  double(*pDparam)[3] = pDBuf->matrix;
5
54liuyao 已提交
1517 1518 1519

  SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
  SLeastSQRInfo*       pSBuf = GET_ROWCELL_INTERBUF(pSResInfo);
X
Xiaoyu Wang 已提交
1520
  double(*pSparam)[3] = pSBuf->matrix;
5
54liuyao 已提交
1521 1522 1523 1524 1525 1526 1527 1528 1529
  for (int32_t i = 0; i < pSBuf->num; i++) {
    pDparam[0][0] += pDBuf->startVal * pDBuf->startVal;
    pDparam[0][1] += pDBuf->startVal;
    pDBuf->startVal += pDBuf->stepVal;
  }
  pDparam[0][2] += pSparam[0][2] + pDBuf->num * pDBuf->stepVal * pSparam[1][2];
  pDparam[1][2] += pSparam[1][2];
  pDBuf->num += pSBuf->num;
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
5
54liuyao 已提交
1530
  pDResInfo->isNullRes &= pSResInfo->isNullRes;
5
54liuyao 已提交
1531 1532 1533
  return TSDB_CODE_SUCCESS;
}

H
Haojun Liao 已提交
1534 1535 1536 1537 1538
bool getPercentileFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(SPercentileInfo);
  return true;
}

1539
bool percentileFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
H
Haojun Liao 已提交
1540 1541 1542 1543 1544
  if (!functionSetup(pCtx, pResultInfo)) {
    return false;
  }

  // in the first round, get the min-max value of all involved data
1545
  SPercentileInfo* pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
H
Haojun Liao 已提交
1546 1547 1548 1549 1550
  SET_DOUBLE_VAL(&pInfo->minval, DBL_MAX);
  SET_DOUBLE_VAL(&pInfo->maxval, -DBL_MAX);
  pInfo->numOfElems = 0;

  return true;
H
Haojun Liao 已提交
1551 1552
}

1553
int32_t percentileFunction(SqlFunctionCtx* pCtx) {
1554
  int32_t              numOfElems = 0;
1555
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
1556 1557

  SInputColumnInfoData* pInput = &pCtx->input;
1558
  SColumnDataAgg*       pAgg = pInput->pColumnDataAgg[0];
H
Haojun Liao 已提交
1559

1560 1561
  SColumnInfoData* pCol = pInput->pData[0];
  int32_t          type = pCol->info.type;
1562

1563
  SPercentileInfo* pInfo = GET_ROWCELL_INTERBUF(pResInfo);
1564
  if (pCtx->scanFlag == REPEAT_SCAN && pInfo->stage == 0) {
H
Haojun Liao 已提交
1565
    pInfo->stage += 1;
H
Haojun Liao 已提交
1566

H
Haojun Liao 已提交
1567 1568 1569
    // all data are null, set it completed
    if (pInfo->numOfElems == 0) {
      pResInfo->complete = true;
H
Haojun Liao 已提交
1570
      return 0;
H
Haojun Liao 已提交
1571
    } else {
1572
      pInfo->pMemBucket = tMemBucketCreate(pCol->info.bytes, type, pInfo->minval, pInfo->maxval);
H
Haojun Liao 已提交
1573 1574 1575 1576 1577
    }
  }

  // the first stage, only acquire the min/max value
  if (pInfo->stage == 0) {
H
Haojun Liao 已提交
1578
    if (pCtx->input.colDataSMAIsSet) {
H
Haojun Liao 已提交
1579
      double tmin = 0.0, tmax = 0.0;
1580 1581 1582 1583 1584 1585 1586 1587 1588
      if (IS_SIGNED_NUMERIC_TYPE(type)) {
        tmin = (double)GET_INT64_VAL(&pAgg->min);
        tmax = (double)GET_INT64_VAL(&pAgg->max);
      } else if (IS_FLOAT_TYPE(type)) {
        tmin = GET_DOUBLE_VAL(&pAgg->min);
        tmax = GET_DOUBLE_VAL(&pAgg->max);
      } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
        tmin = (double)GET_UINT64_VAL(&pAgg->min);
        tmax = (double)GET_UINT64_VAL(&pAgg->max);
H
Haojun Liao 已提交
1589 1590 1591 1592 1593 1594 1595 1596 1597 1598
      }

      if (GET_DOUBLE_VAL(&pInfo->minval) > tmin) {
        SET_DOUBLE_VAL(&pInfo->minval, tmin);
      }

      if (GET_DOUBLE_VAL(&pInfo->maxval) < tmax) {
        SET_DOUBLE_VAL(&pInfo->maxval, tmax);
      }

1599
      pInfo->numOfElems += (pInput->numOfRows - pAgg->numOfNull);
H
Haojun Liao 已提交
1600
    } else {
1601 1602 1603 1604
      // check the valid data one by one
      int32_t start = pInput->startRowIndex;
      for (int32_t i = start; i < pInput->numOfRows + start; ++i) {
        if (colDataIsNull_f(pCol->nullbitmap, i)) {
H
Haojun Liao 已提交
1605 1606 1607
          continue;
        }

1608
        char* data = colDataGetData(pCol, i);
1609

H
Haojun Liao 已提交
1610
        double v = 0;
1611
        GET_TYPED_DATA(v, double, type, data);
H
Haojun Liao 已提交
1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622
        if (v < GET_DOUBLE_VAL(&pInfo->minval)) {
          SET_DOUBLE_VAL(&pInfo->minval, v);
        }

        if (v > GET_DOUBLE_VAL(&pInfo->maxval)) {
          SET_DOUBLE_VAL(&pInfo->maxval, v);
        }

        pInfo->numOfElems += 1;
      }
    }
1623 1624 1625 1626 1627 1628 1629
  } else {
    // the second stage, calculate the true percentile value
    int32_t start = pInput->startRowIndex;
    for (int32_t i = start; i < pInput->numOfRows + start; ++i) {
      if (colDataIsNull_f(pCol->nullbitmap, i)) {
        continue;
      }
H
Haojun Liao 已提交
1630

1631
      char* data = colDataGetData(pCol, i);
1632
      numOfElems += 1;
1633
      tMemBucketPut(pInfo->pMemBucket, data, 1);
H
Haojun Liao 已提交
1634 1635
    }

1636
    SET_VAL(pResInfo, numOfElems, 1);
H
Haojun Liao 已提交
1637 1638
  }

wmmhello's avatar
wmmhello 已提交
1639
  return TSDB_CODE_SUCCESS;
1640 1641
}

1642
int32_t percentileFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
1643
  SVariant* pVal = &pCtx->param[1].param;
1644
  double    v = 0;
1645
  GET_TYPED_DATA(v, double, pVal->nType, &pVal->i);
H
Haojun Liao 已提交
1646

1647 1648
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  SPercentileInfo*     ppInfo = (SPercentileInfo*)GET_ROWCELL_INTERBUF(pResInfo);
1649

1650
  tMemBucket* pMemBucket = ppInfo->pMemBucket;
1651 1652 1653 1654 1655
  if (pMemBucket != NULL && pMemBucket->total > 0) {  // check for null
    SET_DOUBLE_VAL(&ppInfo->result, getPercentile(pMemBucket, v));
  }

  tMemBucketDestroy(pMemBucket);
1656
  return functionFinalize(pCtx, pBlock);
H
Haojun Liao 已提交
1657
}
H
Haojun Liao 已提交
1658

1659
bool getApercentileFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
X
Xiaoyu Wang 已提交
1660 1661
  int32_t bytesHist =
      (int32_t)(sizeof(SAPercentileInfo) + sizeof(SHistogramInfo) + sizeof(SHistBin) * (MAX_HISTOGRAM_BIN + 1));
1662
  int32_t bytesDigest = (int32_t)(sizeof(SAPercentileInfo) + TDIGEST_SIZE(COMPRESSION));
G
Ganlin Zhao 已提交
1663
  pEnv->calcMemSize = TMAX(bytesHist, bytesDigest);
1664 1665 1666
  return true;
}

G
Ganlin Zhao 已提交
1667
int32_t getApercentileMaxSize() {
X
Xiaoyu Wang 已提交
1668 1669
  int32_t bytesHist =
      (int32_t)(sizeof(SAPercentileInfo) + sizeof(SHistogramInfo) + sizeof(SHistBin) * (MAX_HISTOGRAM_BIN + 1));
G
Ganlin Zhao 已提交
1670 1671 1672 1673
  int32_t bytesDigest = (int32_t)(sizeof(SAPercentileInfo) + TDIGEST_SIZE(COMPRESSION));
  return TMAX(bytesHist, bytesDigest);
}

X
Xiaoyu Wang 已提交
1674
static int8_t getApercentileAlgo(char* algoStr) {
1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687
  int8_t algoType;
  if (strcasecmp(algoStr, "default") == 0) {
    algoType = APERCT_ALGO_DEFAULT;
  } else if (strcasecmp(algoStr, "t-digest") == 0) {
    algoType = APERCT_ALGO_TDIGEST;
  } else {
    algoType = APERCT_ALGO_UNKNOWN;
  }

  return algoType;
}

static void buildHistogramInfo(SAPercentileInfo* pInfo) {
X
Xiaoyu Wang 已提交
1688 1689
  pInfo->pHisto = (SHistogramInfo*)((char*)pInfo + sizeof(SAPercentileInfo));
  pInfo->pHisto->elems = (SHistBin*)((char*)pInfo->pHisto + sizeof(SHistogramInfo));
1690 1691
}

1692 1693 1694 1695
static void buildTDigestInfo(SAPercentileInfo* pInfo) {
  pInfo->pTDigest = (TDigest*)((char*)pInfo + sizeof(SAPercentileInfo));
}

1696 1697 1698 1699 1700 1701
bool apercentileFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
  if (!functionSetup(pCtx, pResultInfo)) {
    return false;
  }

  SAPercentileInfo* pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
1702 1703

  SVariant* pVal = &pCtx->param[1].param;
1704
  pInfo->percent = 0;
1705
  GET_TYPED_DATA(pInfo->percent, double, pVal->nType, &pVal->i);
1706

1707 1708 1709
  if (pCtx->numOfParams == 2) {
    pInfo->algo = APERCT_ALGO_DEFAULT;
  } else if (pCtx->numOfParams == 3) {
1710
    pInfo->algo = getApercentileAlgo(varDataVal(pCtx->param[2].param.pz));
1711 1712 1713 1714 1715
    if (pInfo->algo == APERCT_ALGO_UNKNOWN) {
      return false;
    }
  }

X
Xiaoyu Wang 已提交
1716
  char* tmp = (char*)pInfo + sizeof(SAPercentileInfo);
1717 1718 1719 1720 1721
  if (pInfo->algo == APERCT_ALGO_TDIGEST) {
    pInfo->pTDigest = tdigestNewFrom(tmp, COMPRESSION);
  } else {
    buildHistogramInfo(pInfo);
    pInfo->pHisto = tHistogramCreateFrom(tmp, MAX_HISTOGRAM_BIN);
G
Ganlin Zhao 已提交
1722 1723
    qDebug("%s set up histogram, numOfElems:%" PRId64 ", numOfEntry:%d, pHisto:%p, elems:%p", __FUNCTION__,
           pInfo->pHisto->numOfElems, pInfo->pHisto->numOfEntries, pInfo->pHisto, pInfo->pHisto->elems);
1724 1725 1726 1727 1728 1729
  }

  return true;
}

int32_t apercentileFunction(SqlFunctionCtx* pCtx) {
1730 1731
  int32_t               numOfElems = 0;
  SResultRowEntryInfo*  pResInfo = GET_RES_INFO(pCtx);
1732 1733 1734 1735 1736 1737 1738 1739 1740
  SInputColumnInfoData* pInput = &pCtx->input;

  SColumnInfoData* pCol = pInput->pData[0];
  int32_t          type = pCol->info.type;

  SAPercentileInfo* pInfo = GET_ROWCELL_INTERBUF(pResInfo);

  int32_t start = pInput->startRowIndex;
  if (pInfo->algo == APERCT_ALGO_TDIGEST) {
5
54liuyao 已提交
1741 1742
    buildTDigestInfo(pInfo);
    tdigestAutoFill(pInfo->pTDigest, COMPRESSION);
1743 1744 1745 1746
    for (int32_t i = start; i < pInput->numOfRows + start; ++i) {
      if (colDataIsNull_f(pCol->nullbitmap, i)) {
        continue;
      }
1747
      numOfElems += 1;
1748 1749
      char* data = colDataGetData(pCol, i);

X
Xiaoyu Wang 已提交
1750 1751
      double  v = 0;  // value
      int64_t w = 1;  // weigth
1752 1753 1754 1755
      GET_TYPED_DATA(v, double, type, data);
      tdigestAdd(pInfo->pTDigest, v, w);
    }
  } else {
1756 1757 1758
    // might be a race condition here that pHisto can be overwritten or setup function
    // has not been called, need to relink the buffer pHisto points to.
    buildHistogramInfo(pInfo);
5
54liuyao 已提交
1759 1760 1761
    qDebug("%s before add %d elements into histogram, total:%" PRId64 ", numOfEntry:%d, pHisto:%p, elems: %p",
           __FUNCTION__, numOfElems, pInfo->pHisto->numOfElems, pInfo->pHisto->numOfEntries, pInfo->pHisto,
           pInfo->pHisto->elems);
1762 1763 1764 1765
    for (int32_t i = start; i < pInput->numOfRows + start; ++i) {
      if (colDataIsNull_f(pCol->nullbitmap, i)) {
        continue;
      }
1766
      numOfElems += 1;
1767 1768 1769 1770 1771 1772
      char* data = colDataGetData(pCol, i);

      double v = 0;
      GET_TYPED_DATA(v, double, type, data);
      tHistogramAdd(&pInfo->pHisto, v);
    }
1773

1774 1775 1776
    qDebug("%s after add %d elements into histogram, total:%" PRId64 ", numOfEntry:%d, pHisto:%p, elems: %p",
           __FUNCTION__, numOfElems, pInfo->pHisto->numOfElems, pInfo->pHisto->numOfEntries, pInfo->pHisto,
           pInfo->pHisto->elems);
1777 1778
  }

1779
  SET_VAL(pResInfo, numOfElems, 1);
1780 1781 1782
  return TSDB_CODE_SUCCESS;
}

1783 1784 1785 1786 1787 1788
static void apercentileTransferInfo(SAPercentileInfo* pInput, SAPercentileInfo* pOutput) {
  pOutput->percent = pInput->percent;
  pOutput->algo = pInput->algo;
  if (pOutput->algo == APERCT_ALGO_TDIGEST) {
    buildTDigestInfo(pInput);
    tdigestAutoFill(pInput->pTDigest, COMPRESSION);
1789

X
Xiaoyu Wang 已提交
1790
    if (pInput->pTDigest->num_centroids == 0 && pInput->pTDigest->num_buffered_pts == 0) {
1791
      return;
1792 1793
    }

1794
    buildTDigestInfo(pOutput);
X
Xiaoyu Wang 已提交
1795
    TDigest* pTDigest = pOutput->pTDigest;
5
54liuyao 已提交
1796
    tdigestAutoFill(pTDigest, COMPRESSION);
1797

5
54liuyao 已提交
1798
    if (pTDigest->num_centroids <= 0 && pTDigest->num_buffered_pts == 0) {
1799
      memcpy(pTDigest, pInput->pTDigest, (size_t)TDIGEST_SIZE(COMPRESSION));
1800 1801
      tdigestAutoFill(pTDigest, COMPRESSION);
    } else {
1802
      tdigestMerge(pTDigest, pInput->pTDigest);
1803
    }
1804
  } else {
1805 1806 1807
    buildHistogramInfo(pInput);
    if (pInput->pHisto->numOfElems <= 0) {
      return;
1808 1809
    }

1810
    buildHistogramInfo(pOutput);
X
Xiaoyu Wang 已提交
1811
    SHistogramInfo* pHisto = pOutput->pHisto;
1812 1813

    if (pHisto->numOfElems <= 0) {
1814
      memcpy(pHisto, pInput->pHisto, sizeof(SHistogramInfo) + sizeof(SHistBin) * (MAX_HISTOGRAM_BIN + 1));
X
Xiaoyu Wang 已提交
1815
      pHisto->elems = (SHistBin*)((char*)pHisto + sizeof(SHistogramInfo));
1816

L
Liu Jicong 已提交
1817 1818
      qDebug("%s merge histo, total:%" PRId64 ", entry:%d, %p", __FUNCTION__, pHisto->numOfElems, pHisto->numOfEntries,
             pHisto);
1819
    } else {
X
Xiaoyu Wang 已提交
1820
      pHisto->elems = (SHistBin*)((char*)pHisto + sizeof(SHistogramInfo));
G
Ganlin Zhao 已提交
1821 1822
      qDebug("%s input histogram, elem:%" PRId64 ", entry:%d, %p", __FUNCTION__, pHisto->numOfElems,
             pHisto->numOfEntries, pInput->pHisto);
1823

X
Xiaoyu Wang 已提交
1824
      SHistogramInfo* pRes = tHistogramMerge(pHisto, pInput->pHisto, MAX_HISTOGRAM_BIN);
1825
      memcpy(pHisto, pRes, sizeof(SHistogramInfo) + sizeof(SHistBin) * MAX_HISTOGRAM_BIN);
X
Xiaoyu Wang 已提交
1826
      pHisto->elems = (SHistBin*)((char*)pHisto + sizeof(SHistogramInfo));
1827

L
Liu Jicong 已提交
1828 1829
      qDebug("%s merge histo, total:%" PRId64 ", entry:%d, %p", __FUNCTION__, pHisto->numOfElems, pHisto->numOfEntries,
             pHisto);
1830 1831 1832
      tHistogramDestroy(&pRes);
    }
  }
1833
}
1834

1835 1836 1837 1838 1839 1840
int32_t apercentileFunctionMerge(SqlFunctionCtx* pCtx) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);

  SInputColumnInfoData* pInput = &pCtx->input;

  SColumnInfoData* pCol = pInput->pData[0];
1841
  tAssert(pCol->info.type == TSDB_DATA_TYPE_BINARY);
1842 1843 1844

  SAPercentileInfo* pInfo = GET_ROWCELL_INTERBUF(pResInfo);

G
Ganlin Zhao 已提交
1845
  qDebug("%s total %d rows will merge, %p", __FUNCTION__, pInput->numOfRows, pInfo->pHisto);
1846

1847
  int32_t start = pInput->startRowIndex;
X
Xiaoyu Wang 已提交
1848
  for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
1849 1850
    char* data = colDataGetData(pCol, i);

1851 1852 1853
    SAPercentileInfo* pInputInfo = (SAPercentileInfo*)varDataVal(data);
    apercentileTransferInfo(pInputInfo, pInfo);
  }
1854

H
Haojun Liao 已提交
1855
  if (pInfo->algo != APERCT_ALGO_TDIGEST) {
1856
    qDebug("%s after merge, total:%" PRId64 ", numOfEntry:%d, %p", __FUNCTION__, pInfo->pHisto->numOfElems,
L
Liu Jicong 已提交
1857
           pInfo->pHisto->numOfEntries, pInfo->pHisto);
H
Haojun Liao 已提交
1858
  }
1859

1860
  SET_VAL(pResInfo, 1, 1);
1861 1862 1863
  return TSDB_CODE_SUCCESS;
}

1864 1865
int32_t apercentileFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
X
Xiaoyu Wang 已提交
1866
  SAPercentileInfo*    pInfo = (SAPercentileInfo*)GET_ROWCELL_INTERBUF(pResInfo);
1867 1868

  if (pInfo->algo == APERCT_ALGO_TDIGEST) {
1869
    buildTDigestInfo(pInfo);
5
54liuyao 已提交
1870
    tdigestAutoFill(pInfo->pTDigest, COMPRESSION);
1871
    if (pInfo->pTDigest->size > 0) {
1872
      pInfo->result = tdigestQuantile(pInfo->pTDigest, pInfo->percent / 100);
1873
    } else {  // no need to free
X
Xiaoyu Wang 已提交
1874
      // setNull(pCtx->pOutput, pCtx->outputType, pCtx->outputBytes);
1875 1876 1877
      return TSDB_CODE_SUCCESS;
    }
  } else {
1878
    buildHistogramInfo(pInfo);
1879
    if (pInfo->pHisto->numOfElems > 0) {
G
Ganlin Zhao 已提交
1880 1881
      qDebug("%s get the final res, elements:%" PRId64 ", numOfEntry:%d, pHisto:%p, elems:%p", __FUNCTION__,
             pInfo->pHisto->numOfElems, pInfo->pHisto->numOfEntries, pInfo->pHisto, pInfo->pHisto->elems);
1882

X
Xiaoyu Wang 已提交
1883 1884
      double  ratio[] = {pInfo->percent};
      double* res = tHistogramUniform(pInfo->pHisto, ratio, 1);
1885
      pInfo->result = *res;
X
Xiaoyu Wang 已提交
1886
      // memcpy(pCtx->pOutput, res, sizeof(double));
1887 1888
      taosMemoryFree(res);
    } else {  // no need to free
X
Xiaoyu Wang 已提交
1889
      // setNull(pCtx->pOutput, pCtx->outputType, pCtx->outputBytes);
1890 1891 1892
      // return TSDB_CODE_SUCCESS;
      qDebug("%s get the final res, elements:%" PRId64 ", numOfEntry:%d. result is null", __FUNCTION__,
             pInfo->pHisto->numOfElems, pInfo->pHisto->numOfEntries);
1893 1894 1895 1896 1897 1898
    }
  }

  return functionFinalize(pCtx, pBlock);
}

1899 1900
int32_t apercentilePartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
X
Xiaoyu Wang 已提交
1901
  SAPercentileInfo*    pInfo = (SAPercentileInfo*)GET_ROWCELL_INTERBUF(pResInfo);
1902

1903
  int32_t resultBytes = getApercentileMaxSize();
X
Xiaoyu Wang 已提交
1904
  char*   res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
1905 1906

  if (pInfo->algo == APERCT_ALGO_TDIGEST) {
1907 1908
    memcpy(varDataVal(res), pInfo, resultBytes);
    varDataSetLen(res, resultBytes);
1909
  } else {
1910 1911
    memcpy(varDataVal(res), pInfo, resultBytes);
    varDataSetLen(res, resultBytes);
1912 1913 1914 1915 1916
  }

  int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);

1917
  colDataAppend(pCol, pBlock->info.rows, res, false);
1918

1919
  taosMemoryFree(res);
1920 1921 1922
  return pResInfo->numOfRes;
}

1923 1924 1925 1926 1927 1928
int32_t apercentileCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);
  SAPercentileInfo*    pDBuf = GET_ROWCELL_INTERBUF(pDResInfo);

  SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
  SAPercentileInfo*    pSBuf = GET_ROWCELL_INTERBUF(pSResInfo);
1929

G
Ganlin Zhao 已提交
1930
  qDebug("%s start to combine apercentile, %p", __FUNCTION__, pDBuf->pHisto);
1931

1932
  apercentileTransferInfo(pSBuf, pDBuf);
1933
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
5
54liuyao 已提交
1934
  pDResInfo->isNullRes &= pSResInfo->isNullRes;
1935 1936 1937
  return TSDB_CODE_SUCCESS;
}

1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953
EFuncDataRequired firstDynDataReq(void* pRes, STimeWindow* pTimeWindow) {
  SResultRowEntryInfo* pEntry = (SResultRowEntryInfo*)pRes;

  // not initialized yet, data is required
  if (pEntry == NULL) {
    return FUNC_DATA_REQUIRED_DATA_LOAD;
  }

  SFirstLastRes* pResult = GET_ROWCELL_INTERBUF(pEntry);
  if (pResult->hasResult && pResult->ts <= pTimeWindow->skey) {
    return FUNC_DATA_REQUIRED_NOT_LOAD;
  } else {
    return FUNC_DATA_REQUIRED_DATA_LOAD;
  }
}

1954
EFuncDataRequired lastDynDataReq(void* pRes, STimeWindow* pTimeWindow) {
L
Liu Jicong 已提交
1955
  SResultRowEntryInfo* pEntry = (SResultRowEntryInfo*)pRes;
1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969

  // not initialized yet, data is required
  if (pEntry == NULL) {
    return FUNC_DATA_REQUIRED_DATA_LOAD;
  }

  SFirstLastRes* pResult = GET_ROWCELL_INTERBUF(pEntry);
  if (pResult->hasResult && pResult->ts >= pTimeWindow->ekey) {
    return FUNC_DATA_REQUIRED_NOT_LOAD;
  } else {
    return FUNC_DATA_REQUIRED_DATA_LOAD;
  }
}

1970
int32_t getFirstLastInfoSize(int32_t resBytes) { return sizeof(SFirstLastRes) + resBytes; }
1971

H
Haojun Liao 已提交
1972
bool getFirstLastFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
1973
  SColumnNode* pNode = (SColumnNode*)nodesListGetNode(pFunc->pParameterList, 0);
1974
  pEnv->calcMemSize = getFirstLastInfoSize(pNode->node.resType.bytes);
H
Haojun Liao 已提交
1975 1976 1977
  return true;
}

1978
bool getSelectivityFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
1979
  SColumnNode* pNode = (SColumnNode*)nodesListGetNode(pFunc->pParameterList, 0);
1980 1981 1982 1983
  pEnv->calcMemSize = pNode->node.resType.bytes;
  return true;
}

1984 1985
bool getGroupKeyFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
  SColumnNode* pNode = (SColumnNode*)nodesListGetNode(pFunc->pParameterList, 0);
G
Ganlin Zhao 已提交
1986
  pEnv->calcMemSize = sizeof(SGroupKeyInfo) + pNode->node.resType.bytes;
1987 1988 1989
  return true;
}

1990 1991 1992 1993 1994
static FORCE_INLINE TSKEY getRowPTs(SColumnInfoData* pTsColInfo, int32_t rowIndex) {
  if (pTsColInfo == NULL) {
    return 0;
  }

1995
  return *(TSKEY*)colDataGetData(pTsColInfo, rowIndex);
1996 1997
}

L
Liu Jicong 已提交
1998 1999
static void firstlastSaveTupleData(const SSDataBlock* pSrcBlock, int32_t rowIndex, SqlFunctionCtx* pCtx,
                                   SFirstLastRes* pInfo) {
2000 2001 2002 2003 2004
  if (pCtx->subsidiaries.num <= 0) {
    return;
  }

  if (!pInfo->hasResult) {
2005
    pInfo->pos = saveTupleData(pCtx, rowIndex, pSrcBlock, NULL);
2006 2007
    tAssert(pCtx->subsidiaries.buf != NULL);
    tAssert(pCtx->subsidiaries.rowLen > 0);
2008
  } else {
2009
    updateTupleData(pCtx, rowIndex, pSrcBlock, &pInfo->pos);
2010 2011 2012
  }
}

H
Haojun Liao 已提交
2013
static void doSaveCurrentVal(SqlFunctionCtx* pCtx, int32_t rowIndex, int64_t currentTs, int32_t type, char* pData) {
2014 2015 2016 2017 2018 2019 2020 2021 2022
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  SFirstLastRes*       pInfo = GET_ROWCELL_INTERBUF(pResInfo);

  if (IS_VAR_DATA_TYPE(type)) {
    pInfo->bytes = varDataTLen(pData);
  }

  memcpy(pInfo->buf, pData, pInfo->bytes);
  pInfo->ts = currentTs;
2023
  firstlastSaveTupleData(pCtx->pSrcBlock, rowIndex, pCtx, pInfo);
2024 2025 2026 2027

  pInfo->hasResult = true;
}

2028 2029
// This ordinary first function does not care if current scan is ascending order or descending order scan
// the OPTIMIZED version of first function will only handle the ascending order scan
2030
int32_t firstFunction(SqlFunctionCtx* pCtx) {
H
Haojun Liao 已提交
2031 2032
  int32_t numOfElems = 0;

2033
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
2034
  SFirstLastRes*       pInfo = GET_ROWCELL_INTERBUF(pResInfo);
H
Haojun Liao 已提交
2035 2036

  SInputColumnInfoData* pInput = &pCtx->input;
2037
  SColumnInfoData*      pInputCol = pInput->pData[0];
H
Haojun Liao 已提交
2038

2039
  pInfo->bytes = pInputCol->info.bytes;
2040

G
Ganlin Zhao 已提交
2041
  if (IS_NULL_TYPE(pInputCol->info.type)) {
G
Ganlin Zhao 已提交
2042
    return TSDB_CODE_SUCCESS;
G
Ganlin Zhao 已提交
2043 2044
  }

H
Haojun Liao 已提交
2045
  // All null data column, return directly.
H
Haojun Liao 已提交
2046
  if (pInput->colDataSMAIsSet && (pInput->pColumnDataAgg[0]->numOfNull == pInput->totalRows)) {
2047
    tAssert(pInputCol->hasNull == true);
2048 2049
    // save selectivity value for column consisted of all null values
    firstlastSaveTupleData(pCtx->pSrcBlock, pInput->startRowIndex, pCtx, pInfo);
G
Ganlin Zhao 已提交
2050
    return TSDB_CODE_SUCCESS;
H
Haojun Liao 已提交
2051 2052
  }

H
Haojun Liao 已提交
2053
  SColumnDataAgg* pColAgg = (pInput->colDataSMAIsSet) ? pInput->pColumnDataAgg[0] : NULL;
2054

2055 2056
  TSKEY startKey = getRowPTs(pInput->pPTS, 0);
  TSKEY endKey = getRowPTs(pInput->pPTS, pInput->totalRows - 1);
2057

2058
  int32_t blockDataOrder = (startKey <= endKey) ? TSDB_ORDER_ASC : TSDB_ORDER_DESC;
2059

2060 2061 2062
  //  please ref. to the comment in lastRowFunction for the reason why disabling the opt version of last/first function.
  //  we will use this opt implementation in an new version that is only available in scan subplan
#if 0
2063 2064 2065
  if (blockDataOrder == TSDB_ORDER_ASC) {
    // filter according to current result firstly
    if (pResInfo->numOfRes > 0) {
2066
      if (pInfo->ts < startKey) {
2067 2068 2069 2070 2071 2072 2073 2074 2075
        return TSDB_CODE_SUCCESS;
      }
    }

    for (int32_t i = pInput->startRowIndex; i < pInput->startRowIndex + pInput->numOfRows; ++i) {
      if (pInputCol->hasNull && colDataIsNull(pInputCol, pInput->totalRows, i, pColAgg)) {
        continue;
      }

2076 2077
      numOfElems++;

2078
      char* data = colDataGetData(pInputCol, i);
2079
      TSKEY cts = getRowPTs(pInput->pPTS, i);
2080 2081
      if (pResInfo->numOfRes == 0 || pInfo->ts > cts) {
        doSaveCurrentVal(pCtx, i, cts, pInputCol->info.type, data);
2082
        break;
2083 2084 2085 2086 2087 2088
      }
    }
  } else {
    // in case of descending order time stamp serial, which usually happens as the results of the nest query,
    // all data needs to be check.
    if (pResInfo->numOfRes > 0) {
2089
      if (pInfo->ts < endKey) {
2090 2091
        return TSDB_CODE_SUCCESS;
      }
H
Haojun Liao 已提交
2092 2093
    }

2094 2095 2096 2097 2098
    for (int32_t i = pInput->numOfRows + pInput->startRowIndex - 1; i >= pInput->startRowIndex; --i) {
      if (pInputCol->hasNull && colDataIsNull(pInputCol, pInput->totalRows, i, pColAgg)) {
        continue;
      }

2099 2100
      numOfElems++;

2101
      char* data = colDataGetData(pInputCol, i);
2102
      TSKEY cts = getRowPTs(pInput->pPTS, i);
2103

2104 2105
      if (pResInfo->numOfRes == 0 || pInfo->ts > cts) {
        doSaveCurrentVal(pCtx, i, cts, pInputCol->info.type, data);
2106
        break;
2107 2108
      }
    }
H
Haojun Liao 已提交
2109
  }
2110
#else
2111
  int64_t* pts = (int64_t*)pInput->pPTS->pData;
2112 2113 2114 2115 2116 2117 2118 2119
  for (int32_t i = pInput->startRowIndex; i < pInput->startRowIndex + pInput->numOfRows; ++i) {
    if (pInputCol->hasNull && colDataIsNull(pInputCol, pInput->totalRows, i, pColAgg)) {
      continue;
    }

    numOfElems++;

    char* data = colDataGetData(pInputCol, i);
H
Haojun Liao 已提交
2120
    TSKEY cts = pts[i];
2121 2122 2123 2124 2125 2126
    if (pResInfo->numOfRes == 0 || pInfo->ts > cts) {
      doSaveCurrentVal(pCtx, i, cts, pInputCol->info.type, data);
      pResInfo->numOfRes = 1;
    }
  }
#endif
H
Haojun Liao 已提交
2127

2128 2129 2130 2131
  if (numOfElems == 0) {
    // save selectivity value for column consisted of all null values
    firstlastSaveTupleData(pCtx->pSrcBlock, pInput->startRowIndex, pCtx, pInfo);
  }
H
Haojun Liao 已提交
2132
  SET_VAL(pResInfo, numOfElems, 1);
wmmhello's avatar
wmmhello 已提交
2133
  return TSDB_CODE_SUCCESS;
H
Haojun Liao 已提交
2134 2135
}

2136
int32_t lastFunction(SqlFunctionCtx* pCtx) {
H
Haojun Liao 已提交
2137 2138
  int32_t numOfElems = 0;

2139
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
2140
  SFirstLastRes*       pInfo = GET_ROWCELL_INTERBUF(pResInfo);
H
Haojun Liao 已提交
2141 2142

  SInputColumnInfoData* pInput = &pCtx->input;
2143
  SColumnInfoData*      pInputCol = pInput->pData[0];
H
Haojun Liao 已提交
2144

2145
  int32_t type = pInputCol->info.type;
2146
  int32_t bytes = pInputCol->info.bytes;
2147
  pInfo->bytes = bytes;
2148

G
Ganlin Zhao 已提交
2149
  if (IS_NULL_TYPE(type)) {
G
Ganlin Zhao 已提交
2150
    return TSDB_CODE_SUCCESS;
G
Ganlin Zhao 已提交
2151 2152
  }

H
Haojun Liao 已提交
2153
  // All null data column, return directly.
H
Haojun Liao 已提交
2154
  if (pInput->colDataSMAIsSet && (pInput->pColumnDataAgg[0]->numOfNull == pInput->totalRows)) {
2155
    tAssert(pInputCol->hasNull == true);
2156 2157
    // save selectivity value for column consisted of all null values
    firstlastSaveTupleData(pCtx->pSrcBlock, pInput->startRowIndex, pCtx, pInfo);
G
Ganlin Zhao 已提交
2158
    return TSDB_CODE_SUCCESS;
H
Haojun Liao 已提交
2159 2160
  }

H
Haojun Liao 已提交
2161
  SColumnDataAgg* pColAgg = (pInput->colDataSMAIsSet) ? pInput->pColumnDataAgg[0] : NULL;
2162 2163 2164 2165

  TSKEY startKey = getRowPTs(pInput->pPTS, 0);
  TSKEY endKey = getRowPTs(pInput->pPTS, pInput->totalRows - 1);

2166
  int32_t blockDataOrder = (startKey <= endKey) ? TSDB_ORDER_ASC : TSDB_ORDER_DESC;
2167

2168 2169
  //  please ref. to the comment in lastRowFunction for the reason why disabling the opt version of last/first function.
#if 0
2170
  if (blockDataOrder == TSDB_ORDER_ASC) {
H
Haojun Liao 已提交
2171
    for (int32_t i = pInput->numOfRows + pInput->startRowIndex - 1; i >= pInput->startRowIndex; --i) {
2172
      if (pInputCol->hasNull && colDataIsNull(pInputCol, pInput->totalRows, i, pColAgg)) {
H
Haojun Liao 已提交
2173 2174 2175 2176
        continue;
      }

      numOfElems++;
2177 2178 2179

      char* data = colDataGetData(pInputCol, i);
      TSKEY cts = getRowPTs(pInput->pPTS, i);
2180 2181
      if (pResInfo->numOfRes == 0 || pInfo->ts < cts) {
        doSaveCurrentVal(pCtx, i, cts, type, data);
2182
      }
2183

H
Haojun Liao 已提交
2184 2185
      break;
    }
2186
  } else {  // descending order
H
Haojun Liao 已提交
2187
    for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
2188
      if (pInputCol->hasNull && colDataIsNull(pInputCol, pInput->totalRows, i, pColAgg)) {
H
Haojun Liao 已提交
2189 2190 2191
        continue;
      }

2192
      numOfElems++;
H
Haojun Liao 已提交
2193

2194 2195
      char* data = colDataGetData(pInputCol, i);
      TSKEY cts = getRowPTs(pInput->pPTS, i);
2196 2197
      if (pResInfo->numOfRes == 0 || pInfo->ts < cts) {
        doSaveCurrentVal(pCtx, i, cts, type, data);
H
Haojun Liao 已提交
2198 2199 2200 2201
      }
      break;
    }
  }
2202
#else
H
Haojun Liao 已提交
2203
  int64_t* pts = (int64_t*)pInput->pPTS->pData;
H
Haojun Liao 已提交
2204

H
Haojun Liao 已提交
2205
#if 0
H
Haojun Liao 已提交
2206 2207 2208 2209
    for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
      if (pInputCol->hasNull && colDataIsNull(pInputCol, pInput->totalRows, i, pColAgg)) {
        continue;
      }
2210

H
Haojun Liao 已提交
2211
      numOfElems++;
H
Haojun Liao 已提交
2212 2213 2214
      if (pResInfo->numOfRes == 0 || pInfo->ts < pts[i]) {
        char* data = colDataGetData(pInputCol, i);
        doSaveCurrentVal(pCtx, i, pts[i], type, data);
H
Haojun Liao 已提交
2215 2216
        pResInfo->numOfRes = 1;
      }
2217
    }
H
Haojun Liao 已提交
2218
#else
2219 2220
  if (!pInputCol->hasNull) {
    numOfElems = 1;
H
Haojun Liao 已提交
2221

2222 2223
    int32_t round = pInput->numOfRows >> 2;
    int32_t reminder = pInput->numOfRows & 0x03;
H
Haojun Liao 已提交
2224

H
Haojun Liao 已提交
2225
      for (int32_t i = pInput->startRowIndex, tick = 0; tick < round; i += 4, tick += 1) {
H
Haojun Liao 已提交
2226 2227 2228
        int64_t cts = pts[i];
        int32_t chosen = i;

2229 2230 2231 2232
      if (cts < pts[i + 1]) {
        cts = pts[i + 1];
        chosen = i + 1;
      }
H
Haojun Liao 已提交
2233

2234 2235 2236 2237
      if (cts < pts[i + 2]) {
        cts = pts[i + 2];
        chosen = i + 2;
      }
H
Haojun Liao 已提交
2238

2239 2240 2241 2242
      if (cts < pts[i + 3]) {
        cts = pts[i + 3];
        chosen = i + 3;
      }
H
Haojun Liao 已提交
2243

2244 2245 2246 2247
      if (pResInfo->numOfRes == 0 || pInfo->ts < cts) {
        char* data = colDataGetData(pInputCol, chosen);
        doSaveCurrentVal(pCtx, i, cts, type, data);
        pResInfo->numOfRes = 1;
H
Haojun Liao 已提交
2248
      }
2249
    }
H
Haojun Liao 已提交
2250 2251

      for (int32_t i = pInput->startRowIndex + round * 4; i < pInput->startRowIndex + pInput->numOfRows; ++i) {
H
Haojun Liao 已提交
2252 2253 2254
        if (pResInfo->numOfRes == 0 || pInfo->ts < pts[i]) {
          char* data = colDataGetData(pInputCol, i);
          doSaveCurrentVal(pCtx, i, pts[i], type, data);
H
Haojun Liao 已提交
2255 2256 2257 2258 2259
          pResInfo->numOfRes = 1;
        }
      }
    } else {
      for (int32_t i = pInput->startRowIndex; i < pInput->startRowIndex + pInput->numOfRows; ++i) {
H
Haojun Liao 已提交
2260
        if (colDataIsNull(pInputCol, pInput->totalRows, i, pColAgg)) {
H
Haojun Liao 已提交
2261 2262 2263
          continue;
        }

2264
      numOfElems++;
H
Haojun Liao 已提交
2265

2266 2267 2268 2269
      if (pResInfo->numOfRes == 0 || pInfo->ts < pts[i]) {
        char* data = colDataGetData(pInputCol, i);
        doSaveCurrentVal(pCtx, i, pts[i], type, data);
        pResInfo->numOfRes = 1;
H
Haojun Liao 已提交
2270 2271
      }
    }
2272
  }
H
Haojun Liao 已提交
2273
#endif
H
Haojun Liao 已提交
2274

2275
#endif
H
Haojun Liao 已提交
2276 2277

  // save selectivity value for column consisted of all null values
2278 2279 2280
  if (numOfElems == 0) {
    firstlastSaveTupleData(pCtx->pSrcBlock, pInput->startRowIndex, pCtx, pInfo);
  }
H
Haojun Liao 已提交
2281

2282
  //  SET_VAL(pResInfo, numOfElems, 1);
wmmhello's avatar
wmmhello 已提交
2283
  return TSDB_CODE_SUCCESS;
H
Haojun Liao 已提交
2284
}
H
Haojun Liao 已提交
2285

5
54liuyao 已提交
2286
static int32_t firstLastTransferInfoImpl(SFirstLastRes* pInput, SFirstLastRes* pOutput, bool isFirst) {
G
Ganlin Zhao 已提交
2287
  if (pOutput->hasResult) {
2288
    if (isFirst) {
2289
      if (pInput->ts > pOutput->ts) {
5
54liuyao 已提交
2290
        return TSDB_CODE_FAILED;
2291 2292
      }
    } else {
2293
      if (pInput->ts < pOutput->ts) {
5
54liuyao 已提交
2294
        return TSDB_CODE_FAILED;
2295
      }
G
Ganlin Zhao 已提交
2296 2297
    }
  }
2298

2299 2300 2301 2302
  pOutput->isNull = pInput->isNull;
  pOutput->ts = pInput->ts;
  pOutput->bytes = pInput->bytes;

G
Ganlin Zhao 已提交
2303
  memcpy(pOutput->buf, pInput->buf, pOutput->bytes);
5
54liuyao 已提交
2304 2305
  return TSDB_CODE_SUCCESS;
}
G
Ganlin Zhao 已提交
2306

5
54liuyao 已提交
2307 2308 2309 2310 2311 2312
static void firstLastTransferInfo(SqlFunctionCtx* pCtx, SFirstLastRes* pInput, SFirstLastRes* pOutput, bool isFirst,
                                  int32_t rowIndex) {
  if (TSDB_CODE_SUCCESS == firstLastTransferInfoImpl(pInput, pOutput, isFirst)) {
    firstlastSaveTupleData(pCtx->pSrcBlock, rowIndex, pCtx, pOutput);
    pOutput->hasResult = true;
  }
G
Ganlin Zhao 已提交
2313 2314
}

2315
static int32_t firstLastFunctionMergeImpl(SqlFunctionCtx* pCtx, bool isFirstQuery) {
G
Ganlin Zhao 已提交
2316
  SInputColumnInfoData* pInput = &pCtx->input;
2317
  SColumnInfoData*      pCol = pInput->pData[0];
2318
  tAssert(pCol->info.type == TSDB_DATA_TYPE_BINARY);
G
Ganlin Zhao 已提交
2319 2320 2321

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

2322 2323
  int32_t start = pInput->startRowIndex;
  int32_t numOfElems = 0;
G
Ganlin Zhao 已提交
2324

X
Xiaoyu Wang 已提交
2325 2326
  for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
    char*          data = colDataGetData(pCol, i);
2327
    SFirstLastRes* pInputInfo = (SFirstLastRes*)varDataVal(data);
2328
    firstLastTransferInfo(pCtx, pInputInfo, pInfo, isFirstQuery, i);
2329 2330 2331 2332
    if (!numOfElems) {
      numOfElems = pInputInfo->hasResult ? 1 : 0;
    }
  }
2333 2334

  SET_VAL(GET_RES_INFO(pCtx), numOfElems, 1);
G
Ganlin Zhao 已提交
2335 2336 2337
  return TSDB_CODE_SUCCESS;
}

2338
int32_t firstFunctionMerge(SqlFunctionCtx* pCtx) { return firstLastFunctionMergeImpl(pCtx, true); }
2339

2340
int32_t lastFunctionMerge(SqlFunctionCtx* pCtx) { return firstLastFunctionMergeImpl(pCtx, false); }
2341

2342
int32_t firstLastFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
G
Ganlin Zhao 已提交
2343 2344 2345 2346 2347 2348
  int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);

  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  pResInfo->isNullRes = (pResInfo->numOfRes == 0) ? 1 : 0;

G
Ganlin Zhao 已提交
2349
  SFirstLastRes* pRes = GET_ROWCELL_INTERBUF(pResInfo);
X
Xiaoyu Wang 已提交
2350
  colDataAppend(pCol, pBlock->info.rows, pRes->buf, pRes->isNull || pResInfo->isNullRes);
2351

2352
  // handle selectivity
2353
  setSelectivityValue(pCtx, pBlock, &pRes->pos, pBlock->info.rows);
G
Ganlin Zhao 已提交
2354 2355 2356 2357

  return pResInfo->numOfRes;
}

G
Ganlin Zhao 已提交
2358 2359
int32_t firstLastPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SResultRowEntryInfo* pEntryInfo = GET_RES_INFO(pCtx);
2360
  SFirstLastRes*       pRes = GET_ROWCELL_INTERBUF(pEntryInfo);
2361

2362
  int32_t resultBytes = getFirstLastInfoSize(pRes->bytes);
G
Ganlin Zhao 已提交
2363

2364 2365
  // todo check for failure
  char* res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
G
Ganlin Zhao 已提交
2366
  memcpy(varDataVal(res), pRes, resultBytes);
2367

G
Ganlin Zhao 已提交
2368 2369 2370 2371 2372 2373
  varDataSetLen(res, resultBytes);

  int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);

  colDataAppend(pCol, pBlock->info.rows, res, false);
2374
  setSelectivityValue(pCtx, pBlock, &pRes->pos, pBlock->info.rows);
G
Ganlin Zhao 已提交
2375 2376 2377 2378 2379

  taosMemoryFree(res);
  return 1;
}

5
54liuyao 已提交
2380 2381
int32_t lastCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);
2382
  SFirstLastRes*       pDBuf = GET_ROWCELL_INTERBUF(pDResInfo);
2383
  int32_t              bytes = pDBuf->bytes;
5
54liuyao 已提交
2384 2385

  SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
2386
  SFirstLastRes*       pSBuf = GET_ROWCELL_INTERBUF(pSResInfo);
5
54liuyao 已提交
2387

5
54liuyao 已提交
2388 2389
  if (TSDB_CODE_SUCCESS == firstLastTransferInfoImpl(pSBuf, pDBuf, false)) {
    pDBuf->hasResult = true;
5
54liuyao 已提交
2390
  }
5
54liuyao 已提交
2391 2392 2393

  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
  pDResInfo->isNullRes &= pSResInfo->isNullRes;
5
54liuyao 已提交
2394 2395 2396
  return TSDB_CODE_SUCCESS;
}

2397
static void doSaveLastrow(SqlFunctionCtx* pCtx, char* pData, int32_t rowIndex, int64_t cts, SFirstLastRes* pInfo) {
2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413
  SInputColumnInfoData* pInput = &pCtx->input;
  SColumnInfoData*      pInputCol = pInput->pData[0];

  if (colDataIsNull_s(pInputCol, rowIndex)) {
    pInfo->isNull = true;
  } else {
    pInfo->isNull = false;

    if (IS_VAR_DATA_TYPE(pInputCol->info.type)) {
      pInfo->bytes = varDataTLen(pData);
    }

    memcpy(pInfo->buf, pData, pInfo->bytes);
  }

  pInfo->ts = cts;
2414
  firstlastSaveTupleData(pCtx->pSrcBlock, rowIndex, pCtx, pInfo);
2415 2416 2417 2418

  pInfo->hasResult = true;
}

2419 2420 2421 2422 2423 2424 2425 2426 2427
int32_t lastRowFunction(SqlFunctionCtx* pCtx) {
  int32_t numOfElems = 0;

  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  SFirstLastRes*       pInfo = GET_ROWCELL_INTERBUF(pResInfo);

  SInputColumnInfoData* pInput = &pCtx->input;
  SColumnInfoData*      pInputCol = pInput->pData[0];

G
Ganlin Zhao 已提交
2428
  int32_t type  = pInputCol->info.type;
2429 2430 2431
  int32_t bytes = pInputCol->info.bytes;
  pInfo->bytes = bytes;

G
Ganlin Zhao 已提交
2432 2433 2434 2435
  if (IS_NULL_TYPE(type)) {
    return TSDB_CODE_SUCCESS;
  }

2436 2437 2438
  TSKEY startKey = getRowPTs(pInput->pPTS, 0);
  TSKEY endKey = getRowPTs(pInput->pPTS, pInput->totalRows - 1);

2439
#if 0
2440 2441
  int32_t blockDataOrder = (startKey <= endKey) ? TSDB_ORDER_ASC : TSDB_ORDER_DESC;

H
Haojun Liao 已提交
2442 2443
  // the optimized version only valid if all tuples in one block are monotonious increasing or descreasing.
  // this assumption is NOT always works if project operator exists in downstream.
2444 2445 2446 2447
  if (blockDataOrder == TSDB_ORDER_ASC) {
    for (int32_t i = pInput->numOfRows + pInput->startRowIndex - 1; i >= pInput->startRowIndex; --i) {
      char* data = colDataGetData(pInputCol, i);
      TSKEY cts = getRowPTs(pInput->pPTS, i);
2448 2449 2450 2451
      numOfElems++;

      if (pResInfo->numOfRes == 0 || pInfo->ts < cts) {
        doSaveLastrow(pCtx, data, i, cts, pInfo);
2452
      }
2453

2454 2455 2456 2457 2458 2459
      break;
    }
  } else {  // descending order
    for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
      char* data = colDataGetData(pInputCol, i);
      TSKEY cts = getRowPTs(pInput->pPTS, i);
2460 2461 2462 2463
      numOfElems++;

      if (pResInfo->numOfRes == 0 || pInfo->ts < cts) {
        doSaveLastrow(pCtx, data, i, cts, pInfo);
2464 2465 2466 2467
      }
      break;
    }
  }
2468
#else
H
Haojun Liao 已提交
2469 2470

  int64_t* pts = (int64_t*)pInput->pPTS->pData;
2471
  for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
2472 2473
    bool  isNull = colDataIsNull(pInputCol, pInput->numOfRows, i, NULL);
    char* data = isNull ? NULL : colDataGetData(pInputCol, i);
H
Haojun Liao 已提交
2474
    TSKEY cts = pts[i];
2475

H
Haojun Liao 已提交
2476
    numOfElems++;
2477 2478 2479 2480 2481
    if (pResInfo->numOfRes == 0 || pInfo->ts < cts) {
      doSaveLastrow(pCtx, data, i, cts, pInfo);
      pResInfo->numOfRes = 1;
    }
  }
2482

2483
#endif
2484

2485 2486 2487 2488
  SET_VAL(pResInfo, numOfElems, 1);
  return TSDB_CODE_SUCCESS;
}

H
Haojun Liao 已提交
2489 2490 2491 2492 2493
bool getDiffFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(SDiffInfo);
  return true;
}

2494
bool diffFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
H
Haojun Liao 已提交
2495 2496 2497 2498 2499
  if (!functionSetup(pCtx, pResInfo)) {
    return false;
  }

  SDiffInfo* pDiffInfo = GET_ROWCELL_INTERBUF(pResInfo);
2500
  pDiffInfo->hasPrev = false;
H
Haojun Liao 已提交
2501
  pDiffInfo->prev.i64 = 0;
2502
  pDiffInfo->prevTs = -1;
2503 2504 2505 2506 2507
  if (pCtx->numOfParams > 1) {
    pDiffInfo->ignoreNegative = pCtx->param[1].param.i;  // TODO set correct param
  } else {
    pDiffInfo->ignoreNegative = false;
  }
H
Haojun Liao 已提交
2508 2509
  pDiffInfo->includeNull = false;
  pDiffInfo->firstOutput = false;
H
Haojun Liao 已提交
2510 2511 2512
  return true;
}

2513
static void doSetPrevVal(SDiffInfo* pDiffInfo, int32_t type, const char* pv, int64_t ts) {
X
Xiaoyu Wang 已提交
2514
  switch (type) {
2515
    case TSDB_DATA_TYPE_BOOL:
L
Liu Jicong 已提交
2516
      pDiffInfo->prev.i64 = *(bool*)pv ? 1 : 0;
2517
      break;
2518
    case TSDB_DATA_TYPE_TINYINT:
X
Xiaoyu Wang 已提交
2519 2520
      pDiffInfo->prev.i64 = *(int8_t*)pv;
      break;
2521
    case TSDB_DATA_TYPE_INT:
X
Xiaoyu Wang 已提交
2522 2523
      pDiffInfo->prev.i64 = *(int32_t*)pv;
      break;
2524
    case TSDB_DATA_TYPE_SMALLINT:
X
Xiaoyu Wang 已提交
2525 2526
      pDiffInfo->prev.i64 = *(int16_t*)pv;
      break;
2527
    case TSDB_DATA_TYPE_TIMESTAMP:
2528
    case TSDB_DATA_TYPE_BIGINT:
X
Xiaoyu Wang 已提交
2529 2530
      pDiffInfo->prev.i64 = *(int64_t*)pv;
      break;
2531
    case TSDB_DATA_TYPE_FLOAT:
X
Xiaoyu Wang 已提交
2532 2533
      pDiffInfo->prev.d64 = *(float*)pv;
      break;
2534
    case TSDB_DATA_TYPE_DOUBLE:
X
Xiaoyu Wang 已提交
2535 2536
      pDiffInfo->prev.d64 = *(double*)pv;
      break;
2537
    default:
2538
      tAssert(0);
2539
  }
2540
  pDiffInfo->prevTs = ts;
2541 2542
}

X
Xiaoyu Wang 已提交
2543
static void doHandleDiff(SDiffInfo* pDiffInfo, int32_t type, const char* pv, SColumnInfoData* pOutput, int32_t pos,
2544
                         int32_t order, int64_t ts) {
X
Xiaoyu Wang 已提交
2545
  int32_t factor = (order == TSDB_ORDER_ASC) ? 1 : -1;
2546
  pDiffInfo->prevTs = ts;
2547 2548 2549
  switch (type) {
    case TSDB_DATA_TYPE_INT: {
      int32_t v = *(int32_t*)pv;
X
Xiaoyu Wang 已提交
2550
      int64_t delta = factor * (v - pDiffInfo->prev.i64);  // direct previous may be null
2551 2552 2553
      if (delta < 0 && pDiffInfo->ignoreNegative) {
        colDataSetNull_f(pOutput->nullbitmap, pos);
      } else {
2554
        colDataAppendInt64(pOutput, pos, &delta);
2555 2556
      }
      pDiffInfo->prev.i64 = v;
2557

2558 2559 2560 2561
      break;
    }
    case TSDB_DATA_TYPE_BOOL:
    case TSDB_DATA_TYPE_TINYINT: {
X
Xiaoyu Wang 已提交
2562 2563
      int8_t  v = *(int8_t*)pv;
      int64_t delta = factor * (v - pDiffInfo->prev.i64);  // direct previous may be null
2564 2565 2566
      if (delta < 0 && pDiffInfo->ignoreNegative) {
        colDataSetNull_f(pOutput->nullbitmap, pos);
      } else {
2567
        colDataAppendInt64(pOutput, pos, &delta);
2568 2569 2570 2571 2572 2573
      }
      pDiffInfo->prev.i64 = v;
      break;
    }
    case TSDB_DATA_TYPE_SMALLINT: {
      int16_t v = *(int16_t*)pv;
X
Xiaoyu Wang 已提交
2574
      int64_t delta = factor * (v - pDiffInfo->prev.i64);  // direct previous may be null
2575 2576 2577
      if (delta < 0 && pDiffInfo->ignoreNegative) {
        colDataSetNull_f(pOutput->nullbitmap, pos);
      } else {
2578
        colDataAppendInt64(pOutput, pos, &delta);
2579 2580 2581 2582
      }
      pDiffInfo->prev.i64 = v;
      break;
    }
2583
    case TSDB_DATA_TYPE_TIMESTAMP:
2584 2585
    case TSDB_DATA_TYPE_BIGINT: {
      int64_t v = *(int64_t*)pv;
X
Xiaoyu Wang 已提交
2586
      int64_t delta = factor * (v - pDiffInfo->prev.i64);  // direct previous may be null
2587 2588 2589 2590 2591 2592 2593 2594 2595
      if (delta < 0 && pDiffInfo->ignoreNegative) {
        colDataSetNull_f(pOutput->nullbitmap, pos);
      } else {
        colDataAppendInt64(pOutput, pos, &delta);
      }
      pDiffInfo->prev.i64 = v;
      break;
    }
    case TSDB_DATA_TYPE_FLOAT: {
X
Xiaoyu Wang 已提交
2596 2597 2598
      float  v = *(float*)pv;
      double delta = factor * (v - pDiffInfo->prev.d64);                               // direct previous may be null
      if ((delta < 0 && pDiffInfo->ignoreNegative) || isinf(delta) || isnan(delta)) {  // check for overflow
2599 2600
        colDataSetNull_f(pOutput->nullbitmap, pos);
      } else {
2601
        colDataAppendDouble(pOutput, pos, &delta);
2602 2603 2604 2605 2606 2607
      }
      pDiffInfo->prev.d64 = v;
      break;
    }
    case TSDB_DATA_TYPE_DOUBLE: {
      double v = *(double*)pv;
X
Xiaoyu Wang 已提交
2608 2609
      double delta = factor * (v - pDiffInfo->prev.d64);                               // direct previous may be null
      if ((delta < 0 && pDiffInfo->ignoreNegative) || isinf(delta) || isnan(delta)) {  // check for overflow
2610 2611 2612 2613 2614 2615 2616 2617
        colDataSetNull_f(pOutput->nullbitmap, pos);
      } else {
        colDataAppendDouble(pOutput, pos, &delta);
      }
      pDiffInfo->prev.d64 = v;
      break;
    }
    default:
2618
      tAssert(0);
2619
  }
G
Ganlin Zhao 已提交
2620
}
2621

2622 2623 2624
int32_t diffFunction(SqlFunctionCtx* pCtx) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  SDiffInfo*           pDiffInfo = GET_ROWCELL_INTERBUF(pResInfo);
H
Haojun Liao 已提交
2625 2626 2627

  SInputColumnInfoData* pInput = &pCtx->input;

2628
  SColumnInfoData* pInputCol = pInput->pData[0];
H
Haojun Liao 已提交
2629

2630 2631
  TSKEY* tsList = (int64_t*)pInput->pPTS->pData;

2632
  int32_t numOfElems = 0;
H
Haojun Liao 已提交
2633
  int32_t startOffset = pCtx->offset;
H
Haojun Liao 已提交
2634

2635
  SColumnInfoData* pOutput = (SColumnInfoData*)pCtx->pOutput;
H
Haojun Liao 已提交
2636

2637 2638 2639
  if (pCtx->order == TSDB_ORDER_ASC) {
    for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
      int32_t pos = startOffset + numOfElems;
H
Haojun Liao 已提交
2640

2641 2642 2643
      if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
        if (pDiffInfo->includeNull) {
          colDataSetNull_f(pOutput->nullbitmap, pos);
H
Haojun Liao 已提交
2644

2645
          numOfElems += 1;
H
Haojun Liao 已提交
2646
        }
2647
        continue;
H
Haojun Liao 已提交
2648 2649
      }

2650
      char* pv = colDataGetData(pInputCol, i);
H
Haojun Liao 已提交
2651

2652
      if (pDiffInfo->hasPrev) {
2653 2654 2655 2656
        if (tsList[i] == pDiffInfo->prevTs) {
          return TSDB_CODE_FUNC_DUP_TIMESTAMP;
        }
        doHandleDiff(pDiffInfo, pInputCol->info.type, pv, pOutput, pos, pCtx->order, tsList[i]);
2657
        // handle selectivity
2658 2659 2660
        if (pCtx->subsidiaries.num > 0) {
          appendSelectivityValue(pCtx, i, pos);
        }
H
Haojun Liao 已提交
2661 2662

        numOfElems++;
2663
      } else {
2664
        doSetPrevVal(pDiffInfo, pInputCol->info.type, pv, tsList[i]);
H
Haojun Liao 已提交
2665 2666
      }

2667 2668 2669 2670 2671 2672 2673 2674 2675
      pDiffInfo->hasPrev = true;
    }
  } else {
    for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
      int32_t pos = startOffset + numOfElems;

      if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
        if (pDiffInfo->includeNull) {
          colDataSetNull_f(pOutput->nullbitmap, pos);
H
Haojun Liao 已提交
2676

2677
          numOfElems += 1;
H
Haojun Liao 已提交
2678
        }
2679
        continue;
H
Haojun Liao 已提交
2680 2681
      }

2682
      char* pv = colDataGetData(pInputCol, i);
H
Haojun Liao 已提交
2683

2684 2685
      // there is a row of previous data block to be handled in the first place.
      if (pDiffInfo->hasPrev) {
2686 2687 2688 2689
        if (tsList[i] == pDiffInfo->prevTs) {
          return TSDB_CODE_FUNC_DUP_TIMESTAMP;
        }
        doHandleDiff(pDiffInfo, pInputCol->info.type, pv, pOutput, pos, pCtx->order, tsList[i]);
2690
        // handle selectivity
2691 2692 2693
        if (pCtx->subsidiaries.num > 0) {
          appendSelectivityValue(pCtx, i, pos);
        }
H
Haojun Liao 已提交
2694 2695

        numOfElems++;
2696
      } else {
2697
        doSetPrevVal(pDiffInfo, pInputCol->info.type, pv, tsList[i]);
H
Haojun Liao 已提交
2698 2699
      }

2700
      pDiffInfo->hasPrev = true;
H
Haojun Liao 已提交
2701 2702 2703
    }
  }

2704 2705
  pResInfo->numOfRes = numOfElems;
  return TSDB_CODE_SUCCESS;
H
Haojun Liao 已提交
2706
}
H
Haojun Liao 已提交
2707

X
Xiaoyu Wang 已提交
2708
int32_t getTopBotInfoSize(int64_t numOfItems) { return sizeof(STopBotRes) + numOfItems * sizeof(STopBotResItem); }
G
Ganlin Zhao 已提交
2709

2710
bool getTopBotFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
2711
  SValueNode* pkNode = (SValueNode*)nodesListGetNode(pFunc->pParameterList, 1);
2712
  pEnv->calcMemSize = sizeof(STopBotRes) + pkNode->datum.i * sizeof(STopBotResItem);
2713 2714 2715
  return true;
}

G
Ganlin Zhao 已提交
2716 2717 2718 2719 2720
bool topBotFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
  if (!functionSetup(pCtx, pResInfo)) {
    return false;
  }

X
Xiaoyu Wang 已提交
2721
  STopBotRes*           pRes = GET_ROWCELL_INTERBUF(pResInfo);
2722 2723 2724 2725
  SInputColumnInfoData* pInput = &pCtx->input;

  pRes->maxSize = pCtx->param[1].param.i;

2726 2727
  pRes->nullTupleSaved = false;
  pRes->nullTuplePos.pageId = -1;
G
Ganlin Zhao 已提交
2728 2729 2730
  return true;
}

2731 2732 2733 2734
static STopBotRes* getTopBotOutputInfo(SqlFunctionCtx* pCtx) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  STopBotRes*          pRes = GET_ROWCELL_INTERBUF(pResInfo);
  pRes->pItems = (STopBotResItem*)((char*)pRes + sizeof(STopBotRes));
2735 2736

  return pRes;
2737 2738
}

2739
static void doAddIntoResult(SqlFunctionCtx* pCtx, void* pData, int32_t rowIndex, SSDataBlock* pSrcBlock, uint16_t type,
2740
                            uint64_t uid, SResultRowEntryInfo* pEntryInfo, bool isTopQuery);
2741

G
Ganlin Zhao 已提交
2742 2743
static void addResult(SqlFunctionCtx* pCtx, STopBotResItem* pSourceItem, int16_t type, bool isTopQuery);

2744 2745 2746
int32_t topFunction(SqlFunctionCtx* pCtx) {
  int32_t              numOfElems = 0;
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
2747 2748

  SInputColumnInfoData* pInput = &pCtx->input;
2749
  SColumnInfoData*      pCol = pInput->pData[0];
2750

G
Ganlin Zhao 已提交
2751 2752
  STopBotRes* pRes = getTopBotOutputInfo(pCtx);
  pRes->type = pInput->pData[0]->info.type;
2753 2754

  int32_t start = pInput->startRowIndex;
2755
  for (int32_t i = start; i < pInput->numOfRows + start; ++i) {
2756 2757 2758
    if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
      continue;
    }
2759

2760
    numOfElems++;
2761
    char* data = colDataGetData(pCol, i);
G
Ganlin Zhao 已提交
2762
    doAddIntoResult(pCtx, data, i, pCtx->pSrcBlock, pRes->type, pInput->uid, pResInfo, true);
2763 2764
  }

2765
  if (numOfElems == 0 && pCtx->subsidiaries.num > 0 && !pRes->nullTupleSaved) {
2766
    pRes->nullTuplePos = saveTupleData(pCtx, pInput->startRowIndex, pCtx->pSrcBlock, NULL);
2767 2768
    pRes->nullTupleSaved = true;
  }
2769 2770 2771
  return TSDB_CODE_SUCCESS;
}

2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792
int32_t bottomFunction(SqlFunctionCtx* pCtx) {
  int32_t              numOfElems = 0;
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);

  SInputColumnInfoData* pInput = &pCtx->input;
  SColumnInfoData*      pCol = pInput->pData[0];

  STopBotRes* pRes = getTopBotOutputInfo(pCtx);
  pRes->type = pInput->pData[0]->info.type;

  int32_t start = pInput->startRowIndex;
  for (int32_t i = start; i < pInput->numOfRows + start; ++i) {
    if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
      continue;
    }

    numOfElems++;
    char* data = colDataGetData(pCol, i);
    doAddIntoResult(pCtx, data, i, pCtx->pSrcBlock, pRes->type, pInput->uid, pResInfo, false);
  }

2793
  if (numOfElems == 0 && pCtx->subsidiaries.num > 0 && !pRes->nullTupleSaved) {
2794
    pRes->nullTuplePos = saveTupleData(pCtx, pInput->startRowIndex, pCtx->pSrcBlock, NULL);
2795 2796 2797
    pRes->nullTupleSaved = true;
  }

2798 2799 2800
  return TSDB_CODE_SUCCESS;
}

2801 2802
static int32_t topBotResComparFn(const void* p1, const void* p2, const void* param) {
  uint16_t type = *(uint16_t*)param;
2803

2804 2805
  STopBotResItem* val1 = (STopBotResItem*)p1;
  STopBotResItem* val2 = (STopBotResItem*)p2;
2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818

  if (IS_SIGNED_NUMERIC_TYPE(type)) {
    if (val1->v.i == val2->v.i) {
      return 0;
    }

    return (val1->v.i > val2->v.i) ? 1 : -1;
  } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
    if (val1->v.u == val2->v.u) {
      return 0;
    }

    return (val1->v.u > val2->v.u) ? 1 : -1;
2819 2820 2821 2822 2823 2824
  } else if (TSDB_DATA_TYPE_FLOAT == type) {
    if (val1->v.f == val2->v.f) {
      return 0;
    }

    return (val1->v.f > val2->v.f) ? 1 : -1;
2825 2826 2827 2828 2829 2830 2831 2832 2833
  }

  if (val1->v.d == val2->v.d) {
    return 0;
  }

  return (val1->v.d > val2->v.d) ? 1 : -1;
}

2834
void doAddIntoResult(SqlFunctionCtx* pCtx, void* pData, int32_t rowIndex, SSDataBlock* pSrcBlock, uint16_t type,
2835
                     uint64_t uid, SResultRowEntryInfo* pEntryInfo, bool isTopQuery) {
2836
  STopBotRes* pRes = getTopBotOutputInfo(pCtx);
2837

2838 2839 2840
  SVariant val = {0};
  taosVariantCreateFromBinary(&val, pData, tDataTypes[type].bytes, type);

2841
  STopBotResItem* pItems = pRes->pItems;
2842 2843 2844
  assert(pItems != NULL);

  // not full yet
G
Ganlin Zhao 已提交
2845
  if (pEntryInfo->numOfRes < pRes->maxSize) {
2846
    STopBotResItem* pItem = &pItems[pEntryInfo->numOfRes];
2847
    pItem->v = val;
2848
    pItem->uid = uid;
2849

2850
    // save the data of this tuple
G
Ganlin Zhao 已提交
2851
    if (pCtx->subsidiaries.num > 0) {
2852
      pItem->tuplePos = saveTupleData(pCtx, rowIndex, pSrcBlock, NULL);
G
Ganlin Zhao 已提交
2853
    }
2854
#ifdef BUF_PAGE_DEBUG
X
Xiaoyu Wang 已提交
2855 2856
    qDebug("page_saveTuple i:%d, item:%p,pageId:%d, offset:%d\n", pEntryInfo->numOfRes, pItem, pItem->tuplePos.pageId,
           pItem->tuplePos.offset);
2857
#endif
2858 2859
    // allocate the buffer and keep the data of this row into the new allocated buffer
    pEntryInfo->numOfRes++;
2860
    taosheapsort((void*)pItems, sizeof(STopBotResItem), pEntryInfo->numOfRes, (const void*)&type, topBotResComparFn,
2861
                 !isTopQuery);
2862
  } else {  // replace the minimum value in the result
X
Xiaoyu Wang 已提交
2863 2864
    if ((isTopQuery && ((IS_SIGNED_NUMERIC_TYPE(type) && val.i > pItems[0].v.i) ||
                        (IS_UNSIGNED_NUMERIC_TYPE(type) && val.u > pItems[0].v.u) ||
2865 2866
                        (TSDB_DATA_TYPE_FLOAT == type && val.f > pItems[0].v.f) ||
                        (TSDB_DATA_TYPE_DOUBLE == type && val.d > pItems[0].v.d))) ||
X
Xiaoyu Wang 已提交
2867 2868
        (!isTopQuery && ((IS_SIGNED_NUMERIC_TYPE(type) && val.i < pItems[0].v.i) ||
                         (IS_UNSIGNED_NUMERIC_TYPE(type) && val.u < pItems[0].v.u) ||
2869 2870
                         (TSDB_DATA_TYPE_FLOAT == type && val.f < pItems[0].v.f) ||
                         (TSDB_DATA_TYPE_DOUBLE == type && val.d < pItems[0].v.d)))) {
2871
      // replace the old data and the coresponding tuple data
2872
      STopBotResItem* pItem = &pItems[0];
2873
      pItem->v = val;
2874
      pItem->uid = uid;
2875 2876

      // save the data of this tuple by over writing the old data
G
Ganlin Zhao 已提交
2877
      if (pCtx->subsidiaries.num > 0) {
2878
        updateTupleData(pCtx, rowIndex, pSrcBlock, &pItem->tuplePos);
G
Ganlin Zhao 已提交
2879
      }
2880
#ifdef BUF_PAGE_DEBUG
wmmhello's avatar
wmmhello 已提交
2881
      qDebug("page_copyTuple pageId:%d, offset:%d", pItem->tuplePos.pageId, pItem->tuplePos.offset);
2882
#endif
2883
      taosheapadjust((void*)pItems, sizeof(STopBotResItem), 0, pEntryInfo->numOfRes - 1, (const void*)&type,
2884
                     topBotResComparFn, NULL, !isTopQuery);
2885
    }
2886 2887
  }
}
2888

2889 2890 2891 2892 2893 2894
/*
 * +------------------------------------+--------------+--------------+
 * |            null bitmap             |              |              |
 * |(n columns, one bit for each column)| src column #1| src column #2|
 * +------------------------------------+--------------+--------------+
 */
L
Liu Jicong 已提交
2895 2896
void* serializeTupleData(const SSDataBlock* pSrcBlock, int32_t rowIndex, SSubsidiaryResInfo* pSubsidiaryies,
                         char* buf) {
2897 2898
  char* nullList = buf;
  char* pStart = (char*)(nullList + sizeof(bool) * pSubsidiaryies->num);
2899 2900

  int32_t offset = 0;
2901 2902
  for (int32_t i = 0; i < pSubsidiaryies->num; ++i) {
    SqlFunctionCtx* pc = pSubsidiaryies->pCtx[i];
wmmhello's avatar
wmmhello 已提交
2903 2904 2905 2906 2907 2908

    SFunctParam* pFuncParam = &pc->pExpr->base.pParam[0];
    int32_t      srcSlotId = pFuncParam->pCol->slotId;

    SColumnInfoData* pCol = taosArrayGet(pSrcBlock->pDataBlock, srcSlotId);
    if ((nullList[i] = colDataIsNull_s(pCol, rowIndex)) == true) {
2909
      offset += pCol->info.bytes;
2910 2911 2912 2913 2914
      continue;
    }

    char* p = colDataGetData(pCol, rowIndex);
    if (IS_VAR_DATA_TYPE(pCol->info.type)) {
X
Xiaoyu Wang 已提交
2915
      memcpy(pStart + offset, p, (pCol->info.type == TSDB_DATA_TYPE_JSON) ? getJsonValueLen(p) : varDataTLen(p));
2916 2917 2918 2919 2920 2921 2922
    } else {
      memcpy(pStart + offset, p, pCol->info.bytes);
    }

    offset += pCol->info.bytes;
  }

2923
  return buf;
2924 2925
}

2926 2927
static STuplePos doSaveTupleData(SSerializeDataHandle* pHandle, const void* pBuf, size_t length,
                                 const STupleKey* pKey) {
2928 2929 2930
  STuplePos p = {0};
  if (pHandle->pBuf != NULL) {
    SFilePage* pPage = NULL;
2931

2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943
    if (pHandle->currentPage == -1) {
      pPage = getNewBufPage(pHandle->pBuf, &pHandle->currentPage);
      pPage->num = sizeof(SFilePage);
    } else {
      pPage = getBufPage(pHandle->pBuf, pHandle->currentPage);
      if (pPage->num + length > getBufPageSize(pHandle->pBuf)) {
        // current page is all used, let's prepare a new buffer page
        releaseBufPage(pHandle->pBuf, pPage);
        pPage = getNewBufPage(pHandle->pBuf, &pHandle->currentPage);
        pPage->num = sizeof(SFilePage);
      }
    }
2944

L
Liu Jicong 已提交
2945
    p = (STuplePos){.pageId = pHandle->currentPage, .offset = pPage->num};
2946
    memcpy(pPage->data + pPage->num, pBuf, length);
2947

2948 2949 2950 2951 2952
    pPage->num += length;
    setBufPageDirty(pPage, true);
    releaseBufPage(pHandle->pBuf, pPage);
  } else {
    // other tuple save policy
2953
    if (streamStateFuncPut(pHandle->pState, pKey, pBuf, length) < 0) {
2954
      tAssert(0);
2955 2956
    }
    p.streamTupleKey = *pKey;
2957
  }
wmmhello's avatar
wmmhello 已提交
2958

2959 2960
  return p;
}
2961

2962
STuplePos saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, const STupleKey* pKey) {
2963 2964 2965 2966 2967
  if (pCtx->subsidiaries.rowLen == 0) {
    int32_t rowLen = 0;
    for (int32_t j = 0; j < pCtx->subsidiaries.num; ++j) {
      SqlFunctionCtx* pc = pCtx->subsidiaries.pCtx[j];
      rowLen += pc->pExpr->base.resSchema.bytes;
2968 2969
    }

2970 2971
    pCtx->subsidiaries.rowLen = rowLen + pCtx->subsidiaries.num * sizeof(bool);
    pCtx->subsidiaries.buf = taosMemoryMalloc(pCtx->subsidiaries.rowLen);
2972 2973
  }

2974
  char* buf = serializeTupleData(pSrcBlock, rowIndex, &pCtx->subsidiaries, pCtx->subsidiaries.buf);
2975
  return doSaveTupleData(&pCtx->saveHandle, buf, pCtx->subsidiaries.rowLen, pKey);
2976 2977 2978 2979 2980 2981 2982 2983 2984
}

static int32_t doUpdateTupleData(SSerializeDataHandle* pHandle, const void* pBuf, size_t length, STuplePos* pPos) {
  if (pHandle->pBuf != NULL) {
    SFilePage* pPage = getBufPage(pHandle->pBuf, pPos->pageId);
    memcpy(pPage->data + pPos->offset, pBuf, length);
    setBufPageDirty(pPage, true);
    releaseBufPage(pHandle->pBuf, pPage);
  } else {
2985
    streamStateFuncPut(pHandle->pState, &pPos->streamTupleKey, pBuf, length);
2986 2987 2988 2989 2990
  }

  return TSDB_CODE_SUCCESS;
}

H
Haojun Liao 已提交
2991
int32_t updateTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STuplePos* pPos) {
2992
  char* buf = serializeTupleData(pSrcBlock, rowIndex, &pCtx->subsidiaries, pCtx->subsidiaries.buf);
2993
  doUpdateTupleData(&pCtx->saveHandle, buf, pCtx->subsidiaries.rowLen, pPos);
2994 2995 2996 2997 2998 2999
  return TSDB_CODE_SUCCESS;
}

static char* doLoadTupleData(SSerializeDataHandle* pHandle, const STuplePos* pPos) {
  if (pHandle->pBuf != NULL) {
    SFilePage* pPage = getBufPage(pHandle->pBuf, pPos->pageId);
L
Liu Jicong 已提交
3000
    char*      p = pPage->data + pPos->offset;
3001 3002 3003
    releaseBufPage(pHandle->pBuf, pPage);
    return p;
  } else {
3004 3005 3006 3007
    void*   value = NULL;
    int32_t vLen;
    streamStateFuncGet(pHandle->pState, &pPos->streamTupleKey, &value, &vLen);
    return (char*)value;
3008 3009 3010
  }
}

H
Haojun Liao 已提交
3011
const char* loadTupleData(SqlFunctionCtx* pCtx, const STuplePos* pPos) {
3012
  return doLoadTupleData(&pCtx->saveHandle, pPos);
3013 3014
}

3015
int32_t topBotFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
3016
  SResultRowEntryInfo* pEntryInfo = GET_RES_INFO(pCtx);
3017
  STopBotRes*          pRes = getTopBotOutputInfo(pCtx);
3018

3019
  int16_t type = pCtx->pExpr->base.resSchema.type;
3020 3021
  int32_t slotId = pCtx->pExpr->base.resSchema.slotId;

3022 3023 3024 3025
  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);

  // todo assign the tag value and the corresponding row data
  int32_t currentRow = pBlock->info.rows;
3026 3027
  if (pEntryInfo->numOfRes <= 0) {
    colDataAppendNULL(pCol, currentRow);
3028
    setSelectivityValue(pCtx, pBlock, &pRes->nullTuplePos, currentRow);
3029 3030
    return pEntryInfo->numOfRes;
  }
3031 3032
  for (int32_t i = 0; i < pEntryInfo->numOfRes; ++i) {
    STopBotResItem* pItem = &pRes->pItems[i];
3033
    colDataAppend(pCol, currentRow, (const char*)&pItem->v.i, false);
3034
#ifdef BUF_PAGE_DEBUG
X
Xiaoyu Wang 已提交
3035 3036
    qDebug("page_finalize i:%d,item:%p,pageId:%d, offset:%d\n", i, pItem, pItem->tuplePos.pageId,
           pItem->tuplePos.offset);
3037
#endif
3038
    setSelectivityValue(pCtx, pBlock, &pRes->pItems[i].tuplePos, currentRow);
3039
    currentRow += 1;
3040 3041 3042
  }

  return pEntryInfo->numOfRes;
3043
}
G
Ganlin Zhao 已提交
3044

X
Xiaoyu Wang 已提交
3045
void addResult(SqlFunctionCtx* pCtx, STopBotResItem* pSourceItem, int16_t type, bool isTopQuery) {
3046
  SResultRowEntryInfo* pEntryInfo = GET_RES_INFO(pCtx);
X
Xiaoyu Wang 已提交
3047 3048
  STopBotRes*          pRes = getTopBotOutputInfo(pCtx);
  STopBotResItem*      pItems = pRes->pItems;
3049 3050 3051
  assert(pItems != NULL);

  // not full yet
G
Ganlin Zhao 已提交
3052
  if (pEntryInfo->numOfRes < pRes->maxSize) {
3053 3054 3055 3056 3057 3058 3059 3060 3061
    STopBotResItem* pItem = &pItems[pEntryInfo->numOfRes];
    pItem->v = pSourceItem->v;
    pItem->uid = pSourceItem->uid;
    pItem->tuplePos.pageId = -1;
    replaceTupleData(&pItem->tuplePos, &pSourceItem->tuplePos);
    pEntryInfo->numOfRes++;
    taosheapsort((void*)pItems, sizeof(STopBotResItem), pEntryInfo->numOfRes, (const void*)&type, topBotResComparFn,
                 !isTopQuery);
  } else {  // replace the minimum value in the result
X
Xiaoyu Wang 已提交
3062 3063
    if ((isTopQuery && ((IS_SIGNED_NUMERIC_TYPE(type) && pSourceItem->v.i > pItems[0].v.i) ||
                        (IS_UNSIGNED_NUMERIC_TYPE(type) && pSourceItem->v.u > pItems[0].v.u) ||
3064 3065
                        (TSDB_DATA_TYPE_FLOAT == type && pSourceItem->v.f > pItems[0].v.f) ||
                        (TSDB_DATA_TYPE_DOUBLE == type && pSourceItem->v.d > pItems[0].v.d))) ||
X
Xiaoyu Wang 已提交
3066 3067
        (!isTopQuery && ((IS_SIGNED_NUMERIC_TYPE(type) && pSourceItem->v.i < pItems[0].v.i) ||
                         (IS_UNSIGNED_NUMERIC_TYPE(type) && pSourceItem->v.u < pItems[0].v.u) ||
3068 3069
                         (TSDB_DATA_TYPE_FLOAT == type && pSourceItem->v.f < pItems[0].v.f) ||
                         (TSDB_DATA_TYPE_DOUBLE == type && pSourceItem->v.d < pItems[0].v.d)))) {
3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085
      // replace the old data and the coresponding tuple data
      STopBotResItem* pItem = &pItems[0];
      pItem->v = pSourceItem->v;
      pItem->uid = pSourceItem->uid;

      // save the data of this tuple by over writing the old data
      replaceTupleData(&pItem->tuplePos, &pSourceItem->tuplePos);
      taosheapadjust((void*)pItems, sizeof(STopBotResItem), 0, pEntryInfo->numOfRes - 1, (const void*)&type,
                     topBotResComparFn, NULL, !isTopQuery);
    }
  }
}

int32_t topCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
  STopBotRes*          pSBuf = getTopBotOutputInfo(pSourceCtx);
3086
  int16_t              type = pSBuf->type;
3087 3088 3089 3090 3091 3092 3093 3094 3095
  for (int32_t i = 0; i < pSResInfo->numOfRes; i++) {
    addResult(pDestCtx, pSBuf->pItems + i, type, true);
  }
  return TSDB_CODE_SUCCESS;
}

int32_t bottomCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
  STopBotRes*          pSBuf = getTopBotOutputInfo(pSourceCtx);
3096
  int16_t              type = pSBuf->type;
3097 3098 3099 3100 3101 3102
  for (int32_t i = 0; i < pSResInfo->numOfRes; i++) {
    addResult(pDestCtx, pSBuf->pItems + i, type, false);
  }
  return TSDB_CODE_SUCCESS;
}

X
Xiaoyu Wang 已提交
3103
int32_t getSpreadInfoSize() { return (int32_t)sizeof(SSpreadInfo); }
G
Ganlin Zhao 已提交
3104

G
Ganlin Zhao 已提交
3105 3106 3107 3108 3109
bool getSpreadFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(SSpreadInfo);
  return true;
}

X
Xiaoyu Wang 已提交
3110
bool spreadFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
G
Ganlin Zhao 已提交
3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121
  if (!functionSetup(pCtx, pResultInfo)) {
    return false;
  }

  SSpreadInfo* pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
  SET_DOUBLE_VAL(&pInfo->min, DBL_MAX);
  SET_DOUBLE_VAL(&pInfo->max, -DBL_MAX);
  pInfo->hasResult = false;
  return true;
}

X
Xiaoyu Wang 已提交
3122
int32_t spreadFunction(SqlFunctionCtx* pCtx) {
G
Ganlin Zhao 已提交
3123 3124 3125 3126
  int32_t numOfElems = 0;

  // Only the pre-computing information loaded and actual data does not loaded
  SInputColumnInfoData* pInput = &pCtx->input;
X
Xiaoyu Wang 已提交
3127 3128
  SColumnDataAgg*       pAgg = pInput->pColumnDataAgg[0];
  int32_t               type = pInput->pData[0]->info.type;
G
Ganlin Zhao 已提交
3129 3130 3131

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

H
Haojun Liao 已提交
3132
  if (pInput->colDataSMAIsSet) {
G
Ganlin Zhao 已提交
3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159
    numOfElems = pInput->numOfRows - pAgg->numOfNull;
    if (numOfElems == 0) {
      goto _spread_over;
    }
    double tmin = 0.0, tmax = 0.0;
    if (IS_SIGNED_NUMERIC_TYPE(type)) {
      tmin = (double)GET_INT64_VAL(&pAgg->min);
      tmax = (double)GET_INT64_VAL(&pAgg->max);
    } else if (IS_FLOAT_TYPE(type)) {
      tmin = GET_DOUBLE_VAL(&pAgg->min);
      tmax = GET_DOUBLE_VAL(&pAgg->max);
    } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
      tmin = (double)GET_UINT64_VAL(&pAgg->min);
      tmax = (double)GET_UINT64_VAL(&pAgg->max);
    }

    if (GET_DOUBLE_VAL(&pInfo->min) > tmin) {
      SET_DOUBLE_VAL(&pInfo->min, tmin);
    }

    if (GET_DOUBLE_VAL(&pInfo->max) < tmax) {
      SET_DOUBLE_VAL(&pInfo->max, tmax);
    }

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

X
Xiaoyu Wang 已提交
3160
    int32_t start = pInput->startRowIndex;
G
Ganlin Zhao 已提交
3161 3162 3163 3164 3165 3166
    // check the valid data one by one
    for (int32_t i = start; i < pInput->numOfRows + start; ++i) {
      if (colDataIsNull_f(pCol->nullbitmap, i)) {
        continue;
      }

X
Xiaoyu Wang 已提交
3167
      char* data = colDataGetData(pCol, i);
G
Ganlin Zhao 已提交
3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192

      double v = 0;
      GET_TYPED_DATA(v, double, type, data);
      if (v < GET_DOUBLE_VAL(&pInfo->min)) {
        SET_DOUBLE_VAL(&pInfo->min, v);
      }

      if (v > GET_DOUBLE_VAL(&pInfo->max)) {
        SET_DOUBLE_VAL(&pInfo->max, v);
      }

      numOfElems += 1;
    }
  }

_spread_over:
  // data in the check operation are all null, not output
  SET_VAL(GET_RES_INFO(pCtx), numOfElems, 1);
  if (numOfElems > 0) {
    pInfo->hasResult = true;
  }

  return TSDB_CODE_SUCCESS;
}

3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203
static void spreadTransferInfo(SSpreadInfo* pInput, SSpreadInfo* pOutput) {
  pOutput->hasResult = pInput->hasResult;
  if (pInput->max > pOutput->max) {
    pOutput->max = pInput->max;
  }

  if (pInput->min < pOutput->min) {
    pOutput->min = pInput->min;
  }
}

X
Xiaoyu Wang 已提交
3204
int32_t spreadFunctionMerge(SqlFunctionCtx* pCtx) {
3205
  SInputColumnInfoData* pInput = &pCtx->input;
X
Xiaoyu Wang 已提交
3206
  SColumnInfoData*      pCol = pInput->pData[0];
3207
  tAssert(pCol->info.type == TSDB_DATA_TYPE_BINARY);
3208 3209 3210

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

3211
  int32_t start = pInput->startRowIndex;
X
Xiaoyu Wang 已提交
3212 3213
  for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
    char*        data = colDataGetData(pCol, i);
3214
    SSpreadInfo* pInputInfo = (SSpreadInfo*)varDataVal(data);
3215 3216 3217
    if (pInputInfo->hasResult) {
      spreadTransferInfo(pInputInfo, pInfo);
    }
3218
  }
3219

3220 3221 3222
  if (pInfo->hasResult) {
    GET_RES_INFO(pCtx)->numOfRes = 1;
  }
3223 3224 3225 3226

  return TSDB_CODE_SUCCESS;
}

G
Ganlin Zhao 已提交
3227 3228 3229 3230
int32_t spreadFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SSpreadInfo* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
  if (pInfo->hasResult == true) {
    SET_DOUBLE_VAL(&pInfo->result, pInfo->max - pInfo->min);
3231 3232
  } else {
    GET_RES_INFO(pCtx)->isNullRes = 1;
G
Ganlin Zhao 已提交
3233 3234 3235
  }
  return functionFinalize(pCtx, pBlock);
}
3236

3237 3238
int32_t spreadPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
3239 3240 3241
  SSpreadInfo*         pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
  int32_t              resultBytes = getSpreadInfoSize();
  char*                res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254

  memcpy(varDataVal(res), pInfo, resultBytes);
  varDataSetLen(res, resultBytes);

  int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);

  colDataAppend(pCol, pBlock->info.rows, res, false);

  taosMemoryFree(res);
  return pResInfo->numOfRes;
}

3255 3256
int32_t spreadCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);
X
Xiaoyu Wang 已提交
3257
  SSpreadInfo*         pDBuf = GET_ROWCELL_INTERBUF(pDResInfo);
3258 3259

  SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
X
Xiaoyu Wang 已提交
3260
  SSpreadInfo*         pSBuf = GET_ROWCELL_INTERBUF(pSResInfo);
3261
  spreadTransferInfo(pSBuf, pDBuf);
3262
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
5
54liuyao 已提交
3263
  pDResInfo->isNullRes &= pSResInfo->isNullRes;
3264 3265 3266
  return TSDB_CODE_SUCCESS;
}

X
Xiaoyu Wang 已提交
3267
int32_t getElapsedInfoSize() { return (int32_t)sizeof(SElapsedInfo); }
3268

G
Ganlin Zhao 已提交
3269 3270 3271 3272 3273
bool getElapsedFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(SElapsedInfo);
  return true;
}

X
Xiaoyu Wang 已提交
3274
bool elapsedFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
G
Ganlin Zhao 已提交
3275 3276 3277 3278 3279 3280
  if (!functionSetup(pCtx, pResultInfo)) {
    return false;
  }

  SElapsedInfo* pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
  pInfo->result = 0;
H
Hongze Cheng 已提交
3281
  pInfo->min = TSKEY_MAX;
G
Ganlin Zhao 已提交
3282 3283
  pInfo->max = 0;

3284
  if (pCtx->numOfParams > 1) {
G
Ganlin Zhao 已提交
3285 3286 3287 3288 3289 3290 3291 3292
    pInfo->timeUnit = pCtx->param[1].param.i;
  } else {
    pInfo->timeUnit = 1;
  }

  return true;
}

X
Xiaoyu Wang 已提交
3293
int32_t elapsedFunction(SqlFunctionCtx* pCtx) {
G
Ganlin Zhao 已提交
3294 3295 3296 3297
  int32_t numOfElems = 0;

  // Only the pre-computing information loaded and actual data does not loaded
  SInputColumnInfoData* pInput = &pCtx->input;
X
Xiaoyu Wang 已提交
3298
  SColumnDataAgg*       pAgg = pInput->pColumnDataAgg[0];
G
Ganlin Zhao 已提交
3299 3300 3301

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

X
Xiaoyu Wang 已提交
3302
  numOfElems = pInput->numOfRows;  // since this is the primary timestamp, no need to exclude NULL values
G
Ganlin Zhao 已提交
3303 3304 3305 3306
  if (numOfElems == 0) {
    goto _elapsed_over;
  }

H
Haojun Liao 已提交
3307
  if (pInput->colDataSMAIsSet) {
H
Hongze Cheng 已提交
3308
    if (pInfo->min == TSKEY_MAX) {
G
Ganlin Zhao 已提交
3309 3310 3311 3312 3313 3314 3315 3316 3317 3318
      pInfo->min = GET_INT64_VAL(&pAgg->min);
      pInfo->max = GET_INT64_VAL(&pAgg->max);
    } else {
      if (pCtx->order == TSDB_ORDER_ASC) {
        pInfo->max = GET_INT64_VAL(&pAgg->max);
      } else {
        pInfo->min = GET_INT64_VAL(&pAgg->min);
      }
    }
  } else {  // computing based on the true data block
H
Haojun Liao 已提交
3319
    if (0 == pInput->numOfRows) {
G
Ganlin Zhao 已提交
3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333
      if (pCtx->order == TSDB_ORDER_DESC) {
        if (pCtx->end.key != INT64_MIN) {
          pInfo->min = pCtx->end.key;
        }
      } else {
        if (pCtx->end.key != INT64_MIN) {
          pInfo->max = pCtx->end.key + 1;
        }
      }
      goto _elapsed_over;
    }

    SColumnInfoData* pCol = pInput->pData[0];

3334 3335
    int32_t start = pInput->startRowIndex;
    TSKEY*  ptsList = (int64_t*)colDataGetData(pCol, 0);
G
Ganlin Zhao 已提交
3336 3337
    if (pCtx->order == TSDB_ORDER_DESC) {
      if (pCtx->start.key == INT64_MIN) {
3338
        pInfo->max = (pInfo->max < ptsList[start]) ? ptsList[start] : pInfo->max;
G
Ganlin Zhao 已提交
3339 3340 3341 3342
      } else {
        pInfo->max = pCtx->start.key + 1;
      }

3343
      if (pCtx->end.key == INT64_MIN) {
L
Liu Jicong 已提交
3344 3345
        pInfo->min =
            (pInfo->min > ptsList[start + pInput->numOfRows - 1]) ? ptsList[start + pInput->numOfRows - 1] : pInfo->min;
G
Ganlin Zhao 已提交
3346
      } else {
3347
        pInfo->min = pCtx->end.key;
G
Ganlin Zhao 已提交
3348 3349 3350
      }
    } else {
      if (pCtx->start.key == INT64_MIN) {
3351
        pInfo->min = (pInfo->min > ptsList[start]) ? ptsList[start] : pInfo->min;
G
Ganlin Zhao 已提交
3352 3353 3354 3355
      } else {
        pInfo->min = pCtx->start.key;
      }

3356
      if (pCtx->end.key == INT64_MIN) {
L
Liu Jicong 已提交
3357 3358
        pInfo->max =
            (pInfo->max < ptsList[start + pInput->numOfRows - 1]) ? ptsList[start + pInput->numOfRows - 1] : pInfo->max;
G
Ganlin Zhao 已提交
3359
      } else {
3360
        pInfo->max = pCtx->end.key + 1;
G
Ganlin Zhao 已提交
3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371
      }
    }
  }

_elapsed_over:
  // data in the check operation are all null, not output
  SET_VAL(GET_RES_INFO(pCtx), numOfElems, 1);

  return TSDB_CODE_SUCCESS;
}

3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382
static void elapsedTransferInfo(SElapsedInfo* pInput, SElapsedInfo* pOutput) {
  pOutput->timeUnit = pInput->timeUnit;
  if (pOutput->min > pInput->min) {
    pOutput->min = pInput->min;
  }

  if (pOutput->max < pInput->max) {
    pOutput->max = pInput->max;
  }
}

X
Xiaoyu Wang 已提交
3383
int32_t elapsedFunctionMerge(SqlFunctionCtx* pCtx) {
3384
  SInputColumnInfoData* pInput = &pCtx->input;
X
Xiaoyu Wang 已提交
3385
  SColumnInfoData*      pCol = pInput->pData[0];
3386
  tAssert(pCol->info.type == TSDB_DATA_TYPE_BINARY);
3387 3388 3389

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

3390
  int32_t start = pInput->startRowIndex;
3391

X
Xiaoyu Wang 已提交
3392 3393
  for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
    char*         data = colDataGetData(pCol, i);
3394 3395 3396
    SElapsedInfo* pInputInfo = (SElapsedInfo*)varDataVal(data);
    elapsedTransferInfo(pInputInfo, pInfo);
  }
3397 3398 3399 3400 3401

  SET_VAL(GET_RES_INFO(pCtx), 1, 1);
  return TSDB_CODE_SUCCESS;
}

G
Ganlin Zhao 已提交
3402 3403
int32_t elapsedFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SElapsedInfo* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
X
Xiaoyu Wang 已提交
3404
  double        result = (double)pInfo->max - (double)pInfo->min;
G
Ganlin Zhao 已提交
3405 3406 3407 3408 3409
  result = (result >= 0) ? result : -result;
  pInfo->result = result / pInfo->timeUnit;
  return functionFinalize(pCtx, pBlock);
}

3410 3411
int32_t elapsedPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
X
Xiaoyu Wang 已提交
3412 3413 3414
  SElapsedInfo*        pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
  int32_t              resultBytes = getElapsedInfoSize();
  char*                res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427

  memcpy(varDataVal(res), pInfo, resultBytes);
  varDataSetLen(res, resultBytes);

  int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);

  colDataAppend(pCol, pBlock->info.rows, res, false);

  taosMemoryFree(res);
  return pResInfo->numOfRes;
}

3428 3429
int32_t elapsedCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);
X
Xiaoyu Wang 已提交
3430
  SElapsedInfo*        pDBuf = GET_ROWCELL_INTERBUF(pDResInfo);
3431 3432

  SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
X
Xiaoyu Wang 已提交
3433
  SElapsedInfo*        pSBuf = GET_ROWCELL_INTERBUF(pSResInfo);
3434

3435
  elapsedTransferInfo(pSBuf, pDBuf);
3436
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
5
54liuyao 已提交
3437
  pDResInfo->isNullRes &= pSResInfo->isNullRes;
3438 3439 3440
  return TSDB_CODE_SUCCESS;
}

3441 3442 3443 3444
int32_t getHistogramInfoSize() {
  return (int32_t)sizeof(SHistoFuncInfo) + HISTOGRAM_MAX_BINS_NUM * sizeof(SHistoFuncBin);
}

3445 3446 3447 3448 3449
bool getHistogramFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(SHistoFuncInfo) + HISTOGRAM_MAX_BINS_NUM * sizeof(SHistoFuncBin);
  return true;
}

X
Xiaoyu Wang 已提交
3450
static int8_t getHistogramBinType(char* binTypeStr) {
3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464
  int8_t binType;
  if (strcasecmp(binTypeStr, "user_input") == 0) {
    binType = USER_INPUT_BIN;
  } else if (strcasecmp(binTypeStr, "linear_bin") == 0) {
    binType = LINEAR_BIN;
  } else if (strcasecmp(binTypeStr, "log_bin") == 0) {
    binType = LOG_BIN;
  } else {
    binType = UNKNOWN_BIN;
  }

  return binType;
}

X
Xiaoyu Wang 已提交
3465
static bool getHistogramBinDesc(SHistoFuncInfo* pInfo, char* binDescStr, int8_t binType, bool normalized) {
3466 3467 3468 3469 3470 3471 3472
  cJSON*  binDesc = cJSON_Parse(binDescStr);
  int32_t numOfBins;
  double* intervals;
  if (cJSON_IsObject(binDesc)) { /* linaer/log bins */
    int32_t numOfParams = cJSON_GetArraySize(binDesc);
    int32_t startIndex;
    if (numOfParams != 4) {
3473
      cJSON_Delete(binDesc);
3474 3475 3476
      return false;
    }

X
Xiaoyu Wang 已提交
3477 3478 3479 3480
    cJSON* start = cJSON_GetObjectItem(binDesc, "start");
    cJSON* factor = cJSON_GetObjectItem(binDesc, "factor");
    cJSON* width = cJSON_GetObjectItem(binDesc, "width");
    cJSON* count = cJSON_GetObjectItem(binDesc, "count");
3481 3482 3483
    cJSON* infinity = cJSON_GetObjectItem(binDesc, "infinity");

    if (!cJSON_IsNumber(start) || !cJSON_IsNumber(count) || !cJSON_IsBool(infinity)) {
3484
      cJSON_Delete(binDesc);
3485 3486 3487
      return false;
    }

X
Xiaoyu Wang 已提交
3488
    if (count->valueint <= 0 || count->valueint > 1000) {  // limit count to 1000
3489
      cJSON_Delete(binDesc);
3490 3491 3492 3493 3494
      return false;
    }

    if (isinf(start->valuedouble) || (width != NULL && isinf(width->valuedouble)) ||
        (factor != NULL && isinf(factor->valuedouble)) || (count != NULL && isinf(count->valuedouble))) {
3495
      cJSON_Delete(binDesc);
3496 3497 3498
      return false;
    }

3499
    int32_t counter = (int32_t)count->valueint;
3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512
    if (infinity->valueint == false) {
      startIndex = 0;
      numOfBins = counter + 1;
    } else {
      startIndex = 1;
      numOfBins = counter + 3;
    }

    intervals = taosMemoryCalloc(numOfBins, sizeof(double));
    if (cJSON_IsNumber(width) && factor == NULL && binType == LINEAR_BIN) {
      // linear bin process
      if (width->valuedouble == 0) {
        taosMemoryFree(intervals);
3513
        cJSON_Delete(binDesc);
3514 3515 3516 3517 3518 3519
        return false;
      }
      for (int i = 0; i < counter + 1; ++i) {
        intervals[startIndex] = start->valuedouble + i * width->valuedouble;
        if (isinf(intervals[startIndex])) {
          taosMemoryFree(intervals);
3520
          cJSON_Delete(binDesc);
3521 3522 3523 3524 3525 3526 3527 3528
          return false;
        }
        startIndex++;
      }
    } else if (cJSON_IsNumber(factor) && width == NULL && binType == LOG_BIN) {
      // log bin process
      if (start->valuedouble == 0) {
        taosMemoryFree(intervals);
3529
        cJSON_Delete(binDesc);
3530 3531 3532 3533
        return false;
      }
      if (factor->valuedouble < 0 || factor->valuedouble == 0 || factor->valuedouble == 1) {
        taosMemoryFree(intervals);
3534
        cJSON_Delete(binDesc);
3535 3536 3537 3538 3539 3540
        return false;
      }
      for (int i = 0; i < counter + 1; ++i) {
        intervals[startIndex] = start->valuedouble * pow(factor->valuedouble, i * 1.0);
        if (isinf(intervals[startIndex])) {
          taosMemoryFree(intervals);
3541
          cJSON_Delete(binDesc);
3542 3543 3544 3545 3546 3547
          return false;
        }
        startIndex++;
      }
    } else {
      taosMemoryFree(intervals);
3548
      cJSON_Delete(binDesc);
3549 3550 3551 3552 3553 3554 3555
      return false;
    }

    if (infinity->valueint == true) {
      intervals[0] = -INFINITY;
      intervals[numOfBins - 1] = INFINITY;
      // in case of desc bin orders, -inf/inf should be swapped
3556
      tAssert(numOfBins >= 4);
3557 3558 3559 3560 3561 3562
      if (intervals[1] > intervals[numOfBins - 2]) {
        TSWAP(intervals[0], intervals[numOfBins - 1]);
      }
    }
  } else if (cJSON_IsArray(binDesc)) { /* user input bins */
    if (binType != USER_INPUT_BIN) {
3563
      cJSON_Delete(binDesc);
3564 3565
      return false;
    }
3566
    numOfBins = cJSON_GetArraySize(binDesc);
3567 3568 3569 3570
    intervals = taosMemoryCalloc(numOfBins, sizeof(double));
    cJSON* bin = binDesc->child;
    if (bin == NULL) {
      taosMemoryFree(intervals);
3571
      cJSON_Delete(binDesc);
3572 3573 3574 3575 3576 3577 3578
      return false;
    }
    int i = 0;
    while (bin) {
      intervals[i] = bin->valuedouble;
      if (!cJSON_IsNumber(bin)) {
        taosMemoryFree(intervals);
3579
        cJSON_Delete(binDesc);
3580 3581 3582 3583
        return false;
      }
      if (i != 0 && intervals[i] <= intervals[i - 1]) {
        taosMemoryFree(intervals);
3584
        cJSON_Delete(binDesc);
3585 3586 3587 3588 3589 3590
        return false;
      }
      bin = bin->next;
      i++;
    }
  } else {
3591
    cJSON_Delete(binDesc);
3592 3593 3594
    return false;
  }

X
Xiaoyu Wang 已提交
3595
  pInfo->numOfBins = numOfBins - 1;
3596
  pInfo->normalized = normalized;
3597
  for (int32_t i = 0; i < pInfo->numOfBins; ++i) {
3598 3599 3600 3601 3602 3603
    pInfo->bins[i].lower = intervals[i] < intervals[i + 1] ? intervals[i] : intervals[i + 1];
    pInfo->bins[i].upper = intervals[i + 1] > intervals[i] ? intervals[i + 1] : intervals[i];
    pInfo->bins[i].count = 0;
  }

  taosMemoryFree(intervals);
3604 3605
  cJSON_Delete(binDesc);

3606 3607 3608
  return true;
}

X
Xiaoyu Wang 已提交
3609
bool histogramFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
3610 3611 3612 3613
  if (!functionSetup(pCtx, pResultInfo)) {
    return false;
  }

X
Xiaoyu Wang 已提交
3614
  SHistoFuncInfo* pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
3615 3616 3617
  pInfo->numOfBins = 0;
  pInfo->totalCount = 0;
  pInfo->normalized = 0;
3618

3619 3620 3621 3622
  char *binTypeStr = strndup(varDataVal(pCtx->param[1].param.pz), varDataLen(pCtx->param[1].param.pz));
  int8_t binType = getHistogramBinType(binTypeStr);
  taosMemoryFree(binTypeStr);

3623 3624 3625
  if (binType == UNKNOWN_BIN) {
    return false;
  }
3626
  char*   binDesc = strndup(varDataVal(pCtx->param[2].param.pz), varDataLen(pCtx->param[2].param.pz));
3627
  int64_t normalized = pCtx->param[3].param.i;
3628
  if (normalized != 0 && normalized != 1) {
G
Ganlin Zhao 已提交
3629
    taosMemoryFree(binDesc);
3630 3631
    return false;
  }
3632
  if (!getHistogramBinDesc(pInfo, binDesc, binType, (bool)normalized)) {
3633
    taosMemoryFree(binDesc);
3634 3635
    return false;
  }
3636
  taosMemoryFree(binDesc);
3637 3638 3639 3640

  return true;
}

3641
static int32_t histogramFunctionImpl(SqlFunctionCtx* pCtx, bool isPartial) {
3642 3643 3644 3645 3646 3647 3648 3649 3650 3651
  SHistoFuncInfo* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));

  SInputColumnInfoData* pInput = &pCtx->input;
  SColumnInfoData*      pCol = pInput->pData[0];

  int32_t type = pInput->pData[0]->info.type;

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

3652
  int32_t numOfElems = 0;
3653 3654 3655 3656 3657
  for (int32_t i = start; i < numOfRows + start; ++i) {
    if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
      continue;
    }

3658 3659
    numOfElems++;

X
Xiaoyu Wang 已提交
3660
    char*  data = colDataGetData(pCol, i);
3661 3662 3663 3664 3665 3666
    double v;
    GET_TYPED_DATA(v, double, type, data);

    for (int32_t k = 0; k < pInfo->numOfBins; ++k) {
      if (v > pInfo->bins[k].lower && v <= pInfo->bins[k].upper) {
        pInfo->bins[k].count++;
3667
        pInfo->totalCount++;
3668 3669 3670
        break;
      }
    }
3671 3672
  }

3673
  if (!isPartial) {
3674
    GET_RES_INFO(pCtx)->numOfRes = pInfo->numOfBins;
3675
  } else {
3676
    GET_RES_INFO(pCtx)->numOfRes = 1;
3677
  }
3678 3679 3680
  return TSDB_CODE_SUCCESS;
}

X
Xiaoyu Wang 已提交
3681
int32_t histogramFunction(SqlFunctionCtx* pCtx) { return histogramFunctionImpl(pCtx, false); }
3682

X
Xiaoyu Wang 已提交
3683
int32_t histogramFunctionPartial(SqlFunctionCtx* pCtx) { return histogramFunctionImpl(pCtx, true); }
3684

3685 3686
static void histogramTransferInfo(SHistoFuncInfo* pInput, SHistoFuncInfo* pOutput) {
  pOutput->normalized = pInput->normalized;
X
Xiaoyu Wang 已提交
3687
  pOutput->numOfBins = pInput->numOfBins;
3688 3689 3690 3691 3692 3693 3694 3695
  pOutput->totalCount += pInput->totalCount;
  for (int32_t k = 0; k < pOutput->numOfBins; ++k) {
    pOutput->bins[k].lower = pInput->bins[k].lower;
    pOutput->bins[k].upper = pInput->bins[k].upper;
    pOutput->bins[k].count += pInput->bins[k].count;
  }
}

X
Xiaoyu Wang 已提交
3696
int32_t histogramFunctionMerge(SqlFunctionCtx* pCtx) {
3697
  SInputColumnInfoData* pInput = &pCtx->input;
X
Xiaoyu Wang 已提交
3698
  SColumnInfoData*      pCol = pInput->pData[0];
3699
  tAssert(pCol->info.type == TSDB_DATA_TYPE_BINARY);
3700 3701 3702

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

3703
  int32_t start = pInput->startRowIndex;
3704

X
Xiaoyu Wang 已提交
3705 3706
  for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
    char*           data = colDataGetData(pCol, i);
3707 3708 3709
    SHistoFuncInfo* pInputInfo = (SHistoFuncInfo*)varDataVal(data);
    histogramTransferInfo(pInputInfo, pInfo);
  }
3710

G
Ganlin Zhao 已提交
3711
  SET_VAL(GET_RES_INFO(pCtx), pInfo->numOfBins, pInfo->numOfBins);
3712 3713 3714
  return TSDB_CODE_SUCCESS;
}

3715
int32_t histogramFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
3716
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
X
Xiaoyu Wang 已提交
3717 3718 3719
  SHistoFuncInfo*      pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
  int32_t              slotId = pCtx->pExpr->base.resSchema.slotId;
  SColumnInfoData*     pCol = taosArrayGet(pBlock->pDataBlock, slotId);
3720 3721 3722

  int32_t currentRow = pBlock->info.rows;

3723 3724
  if (pInfo->normalized) {
    for (int32_t k = 0; k < pResInfo->numOfRes; ++k) {
X
Xiaoyu Wang 已提交
3725
      if (pInfo->totalCount != 0) {
3726 3727 3728 3729 3730 3731 3732
        pInfo->bins[k].percentage = pInfo->bins[k].count / (double)pInfo->totalCount;
      } else {
        pInfo->bins[k].percentage = 0;
      }
    }
  }

3733
  for (int32_t i = 0; i < pResInfo->numOfRes; ++i) {
3734
    int32_t len;
X
Xiaoyu Wang 已提交
3735
    char    buf[512] = {0};
3736
    if (!pInfo->normalized) {
X
Xiaoyu Wang 已提交
3737 3738
      len = sprintf(varDataVal(buf), "{\"lower_bin\":%g, \"upper_bin\":%g, \"count\":%" PRId64 "}",
                    pInfo->bins[i].lower, pInfo->bins[i].upper, pInfo->bins[i].count);
3739
    } else {
X
Xiaoyu Wang 已提交
3740 3741
      len = sprintf(varDataVal(buf), "{\"lower_bin\":%g, \"upper_bin\":%g, \"count\":%lf}", pInfo->bins[i].lower,
                    pInfo->bins[i].upper, pInfo->bins[i].percentage);
3742 3743 3744 3745 3746 3747
    }
    varDataSetLen(buf, len);
    colDataAppend(pCol, currentRow, buf, false);
    currentRow++;
  }

3748
  return pResInfo->numOfRes;
3749
}
3750

3751
int32_t histogramPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
3752
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
X
Xiaoyu Wang 已提交
3753 3754 3755
  SHistoFuncInfo*      pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
  int32_t              resultBytes = getHistogramInfoSize();
  char*                res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
3756 3757 3758 3759 3760 3761 3762 3763 3764 3765

  memcpy(varDataVal(res), pInfo, resultBytes);
  varDataSetLen(res, resultBytes);

  int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);

  colDataAppend(pCol, pBlock->info.rows, res, false);

  taosMemoryFree(res);
3766
  return pResInfo->numOfRes;
3767 3768
}

3769 3770 3771 3772 3773 3774 3775
int32_t histogramCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);
  SHistoFuncInfo*      pDBuf = GET_ROWCELL_INTERBUF(pDResInfo);

  SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
  SHistoFuncInfo*      pSBuf = GET_ROWCELL_INTERBUF(pSResInfo);

3776
  histogramTransferInfo(pSBuf, pDBuf);
3777
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
5
54liuyao 已提交
3778
  pDResInfo->isNullRes &= pSResInfo->isNullRes;
3779 3780 3781
  return TSDB_CODE_SUCCESS;
}

X
Xiaoyu Wang 已提交
3782
int32_t getHLLInfoSize() { return (int32_t)sizeof(SHLLInfo); }
3783

3784 3785 3786 3787 3788
bool getHLLFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(SHLLInfo);
  return true;
}

X
Xiaoyu Wang 已提交
3789
static uint8_t hllCountNum(void* data, int32_t bytes, int32_t* buk) {
3790
  uint64_t hash = MurmurHash3_64(data, bytes);
X
Xiaoyu Wang 已提交
3791
  int32_t  index = hash & HLL_BUCKET_MASK;
3792 3793 3794
  hash >>= HLL_BUCKET_BITS;
  hash |= ((uint64_t)1 << HLL_DATA_BITS);
  uint64_t bit = 1;
X
Xiaoyu Wang 已提交
3795 3796
  uint8_t  count = 1;
  while ((hash & bit) == 0) {
3797 3798 3799 3800 3801 3802 3803
    count++;
    bit <<= 1;
  }
  *buk = index;
  return count;
}

X
Xiaoyu Wang 已提交
3804 3805 3806
static void hllBucketHisto(uint8_t* buckets, int32_t* bucketHisto) {
  uint64_t* word = (uint64_t*)buckets;
  uint8_t*  bytes;
3807

X
Xiaoyu Wang 已提交
3808
  for (int32_t j = 0; j < HLL_BUCKETS >> 3; j++) {
3809 3810 3811
    if (*word == 0) {
      bucketHisto[0] += 8;
    } else {
X
Xiaoyu Wang 已提交
3812
      bytes = (uint8_t*)word;
3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833
      bucketHisto[bytes[0]]++;
      bucketHisto[bytes[1]]++;
      bucketHisto[bytes[2]]++;
      bucketHisto[bytes[3]]++;
      bucketHisto[bytes[4]]++;
      bucketHisto[bytes[5]]++;
      bucketHisto[bytes[6]]++;
      bucketHisto[bytes[7]]++;
    }
    word++;
  }
}
static double hllTau(double x) {
  if (x == 0. || x == 1.) return 0.;
  double zPrime;
  double y = 1.0;
  double z = 1 - x;
  do {
    x = sqrt(x);
    zPrime = z;
    y *= 0.5;
X
Xiaoyu Wang 已提交
3834 3835
    z -= pow(1 - x, 2) * y;
  } while (zPrime != z);
3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848
  return z / 3;
}

static double hllSigma(double x) {
  if (x == 1.0) return INFINITY;
  double zPrime;
  double y = 1;
  double z = x;
  do {
    x *= x;
    zPrime = z;
    z += x * y;
    y += y;
X
Xiaoyu Wang 已提交
3849
  } while (zPrime != z);
3850 3851 3852
  return z;
}

X
Xiaoyu Wang 已提交
3853 3854 3855 3856
// estimate the cardinality, the algorithm refer this paper: "New cardinality estimation algorithms for HyperLogLog
// sketches"
static uint64_t hllCountCnt(uint8_t* buckets) {
  double  m = HLL_BUCKETS;
3857
  int32_t buckethisto[64] = {0};
X
Xiaoyu Wang 已提交
3858
  hllBucketHisto(buckets, buckethisto);
3859

X
Xiaoyu Wang 已提交
3860
  double z = m * hllTau((m - buckethisto[HLL_DATA_BITS + 1]) / (double)m);
3861 3862 3863 3864
  for (int j = HLL_DATA_BITS; j >= 1; --j) {
    z += buckethisto[j];
    z *= 0.5;
  }
3865

X
Xiaoyu Wang 已提交
3866 3867
  z += m * hllSigma(buckethisto[0] / (double)m);
  double E = (double)llroundl(HLL_ALPHA_INF * m * m / z);
3868

X
Xiaoyu Wang 已提交
3869
  return (uint64_t)E;
3870 3871
}

X
Xiaoyu Wang 已提交
3872
int32_t hllFunction(SqlFunctionCtx* pCtx) {
3873 3874 3875 3876 3877
  SHLLInfo* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));

  SInputColumnInfoData* pInput = &pCtx->input;
  SColumnInfoData*      pCol = pInput->pData[0];

X
Xiaoyu Wang 已提交
3878
  int32_t type = pCol->info.type;
3879 3880 3881 3882 3883 3884
  int32_t bytes = pCol->info.bytes;

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

  int32_t numOfElems = 0;
G
Ganlin Zhao 已提交
3885 3886 3887 3888
  if (IS_NULL_TYPE(type)) {
    goto _hll_over;
  }

3889 3890 3891 3892 3893 3894 3895 3896 3897
  for (int32_t i = start; i < numOfRows + start; ++i) {
    if (pCol->hasNull && colDataIsNull_s(pCol, i)) {
      continue;
    }

    numOfElems++;

    char* data = colDataGetData(pCol, i);
    if (IS_VAR_DATA_TYPE(type)) {
G
Ganlin Zhao 已提交
3898
      bytes = varDataLen(data);
3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909
      data = varDataVal(data);
    }

    int32_t index = 0;
    uint8_t count = hllCountNum(data, bytes, &index);
    uint8_t oldcount = pInfo->buckets[index];
    if (count > oldcount) {
      pInfo->buckets[index] = count;
    }
  }

G
Ganlin Zhao 已提交
3910
_hll_over:
3911 3912 3913 3914 3915 3916 3917 3918
  pInfo->totalCount += numOfElems;

  if (pInfo->totalCount == 0 && !tsCountAlwaysReturnValue) {
    SET_VAL(GET_RES_INFO(pCtx), 0, 1);
  } else {
    SET_VAL(GET_RES_INFO(pCtx), 1, 1);
  }

3919 3920 3921
  return TSDB_CODE_SUCCESS;
}

3922 3923 3924 3925 3926 3927
static void hllTransferInfo(SHLLInfo* pInput, SHLLInfo* pOutput) {
  for (int32_t k = 0; k < HLL_BUCKETS; ++k) {
    if (pOutput->buckets[k] < pInput->buckets[k]) {
      pOutput->buckets[k] = pInput->buckets[k];
    }
  }
3928
  pOutput->totalCount += pInput->totalCount;
3929 3930
}

X
Xiaoyu Wang 已提交
3931
int32_t hllFunctionMerge(SqlFunctionCtx* pCtx) {
G
Ganlin Zhao 已提交
3932
  SInputColumnInfoData* pInput = &pCtx->input;
X
Xiaoyu Wang 已提交
3933
  SColumnInfoData*      pCol = pInput->pData[0];
G
Ganlin Zhao 已提交
3934 3935 3936 3937

  if (pCol->info.type != TSDB_DATA_TYPE_BINARY) {
    return TSDB_CODE_SUCCESS;
  }
G
Ganlin Zhao 已提交
3938 3939 3940

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

3941
  int32_t start = pInput->startRowIndex;
G
Ganlin Zhao 已提交
3942

G
Ganlin Zhao 已提交
3943

X
Xiaoyu Wang 已提交
3944 3945
  for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
    char*     data = colDataGetData(pCol, i);
3946 3947 3948
    SHLLInfo* pInputInfo = (SHLLInfo*)varDataVal(data);
    hllTransferInfo(pInputInfo, pInfo);
  }
G
Ganlin Zhao 已提交
3949

3950 3951 3952 3953 3954 3955
  if (pInfo->totalCount == 0 && !tsCountAlwaysReturnValue) {
    SET_VAL(GET_RES_INFO(pCtx), 0, 1);
  } else {
    SET_VAL(GET_RES_INFO(pCtx), 1, 1);
  }

G
Ganlin Zhao 已提交
3956 3957 3958
  return TSDB_CODE_SUCCESS;
}

3959
int32_t hllFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
X
Xiaoyu Wang 已提交
3960
  SResultRowEntryInfo* pInfo = GET_RES_INFO(pCtx);
3961

3962 3963 3964 3965 3966
  SHLLInfo* pHllInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
  pHllInfo->result = hllCountCnt(pHllInfo->buckets);
  if (tsCountAlwaysReturnValue && pHllInfo->result == 0) {
    pInfo->numOfRes = 1;
  }
3967 3968 3969 3970

  return functionFinalize(pCtx, pBlock);
}

G
Ganlin Zhao 已提交
3971 3972
int32_t hllPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
X
Xiaoyu Wang 已提交
3973 3974 3975
  SHLLInfo*            pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
  int32_t              resultBytes = getHLLInfoSize();
  char*                res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
G
Ganlin Zhao 已提交
3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988

  memcpy(varDataVal(res), pInfo, resultBytes);
  varDataSetLen(res, resultBytes);

  int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);

  colDataAppend(pCol, pBlock->info.rows, res, false);

  taosMemoryFree(res);
  return pResInfo->numOfRes;
}

3989 3990
int32_t hllCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);
X
Xiaoyu Wang 已提交
3991
  SHLLInfo*            pDBuf = GET_ROWCELL_INTERBUF(pDResInfo);
3992 3993

  SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
X
Xiaoyu Wang 已提交
3994
  SHLLInfo*            pSBuf = GET_ROWCELL_INTERBUF(pSResInfo);
3995

3996
  hllTransferInfo(pSBuf, pDBuf);
3997
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
5
54liuyao 已提交
3998
  pDResInfo->isNullRes &= pSResInfo->isNullRes;
3999 4000 4001
  return TSDB_CODE_SUCCESS;
}

4002 4003 4004 4005 4006
bool getStateFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(SStateInfo);
  return true;
}

X
Xiaoyu Wang 已提交
4007
static int8_t getStateOpType(char* opStr) {
4008
  int8_t opType;
4009
  if (strncasecmp(opStr, "LT", 2) == 0) {
4010
    opType = STATE_OPER_LT;
4011
  } else if (strncasecmp(opStr, "GT", 2) == 0) {
4012
    opType = STATE_OPER_GT;
4013
  } else if (strncasecmp(opStr, "LE", 2) == 0) {
4014
    opType = STATE_OPER_LE;
4015
  } else if (strncasecmp(opStr, "GE", 2) == 0) {
4016
    opType = STATE_OPER_GE;
4017
  } else if (strncasecmp(opStr, "NE", 2) == 0) {
4018
    opType = STATE_OPER_NE;
4019
  } else if (strncasecmp(opStr, "EQ", 2) == 0) {
4020 4021 4022 4023 4024 4025 4026 4027 4028 4029
    opType = STATE_OPER_EQ;
  } else {
    opType = STATE_OPER_INVALID;
  }

  return opType;
}

static bool checkStateOp(int8_t op, SColumnInfoData* pCol, int32_t index, SVariant param) {
  char* data = colDataGetData(pCol, index);
X
Xiaoyu Wang 已提交
4030
  switch (pCol->info.type) {
4031
    case TSDB_DATA_TYPE_TINYINT: {
X
Xiaoyu Wang 已提交
4032
      int8_t v = *(int8_t*)data;
4033 4034 4035 4036
      STATE_COMP(op, v, param);
      break;
    }
    case TSDB_DATA_TYPE_UTINYINT: {
X
Xiaoyu Wang 已提交
4037
      uint8_t v = *(uint8_t*)data;
4038 4039 4040 4041
      STATE_COMP(op, v, param);
      break;
    }
    case TSDB_DATA_TYPE_SMALLINT: {
X
Xiaoyu Wang 已提交
4042
      int16_t v = *(int16_t*)data;
4043 4044 4045 4046
      STATE_COMP(op, v, param);
      break;
    }
    case TSDB_DATA_TYPE_USMALLINT: {
X
Xiaoyu Wang 已提交
4047
      uint16_t v = *(uint16_t*)data;
4048 4049 4050 4051
      STATE_COMP(op, v, param);
      break;
    }
    case TSDB_DATA_TYPE_INT: {
X
Xiaoyu Wang 已提交
4052
      int32_t v = *(int32_t*)data;
4053 4054 4055 4056
      STATE_COMP(op, v, param);
      break;
    }
    case TSDB_DATA_TYPE_UINT: {
X
Xiaoyu Wang 已提交
4057
      uint32_t v = *(uint32_t*)data;
4058 4059 4060 4061
      STATE_COMP(op, v, param);
      break;
    }
    case TSDB_DATA_TYPE_BIGINT: {
X
Xiaoyu Wang 已提交
4062
      int64_t v = *(int64_t*)data;
4063 4064 4065 4066
      STATE_COMP(op, v, param);
      break;
    }
    case TSDB_DATA_TYPE_UBIGINT: {
X
Xiaoyu Wang 已提交
4067
      uint64_t v = *(uint64_t*)data;
4068 4069 4070 4071
      STATE_COMP(op, v, param);
      break;
    }
    case TSDB_DATA_TYPE_FLOAT: {
X
Xiaoyu Wang 已提交
4072
      float v = *(float*)data;
4073 4074 4075 4076
      STATE_COMP(op, v, param);
      break;
    }
    case TSDB_DATA_TYPE_DOUBLE: {
X
Xiaoyu Wang 已提交
4077
      double v = *(double*)data;
4078 4079 4080 4081
      STATE_COMP(op, v, param);
      break;
    }
    default: {
4082
      tAssert(0);
4083 4084 4085 4086 4087 4088 4089 4090 4091 4092
    }
  }
  return false;
}

int32_t stateCountFunction(SqlFunctionCtx* pCtx) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  SStateInfo*          pInfo = GET_ROWCELL_INTERBUF(pResInfo);

  SInputColumnInfoData* pInput = &pCtx->input;
4093
  TSKEY*                tsList = (int64_t*)pInput->pPTS->pData;
4094 4095 4096

  SColumnInfoData* pInputCol = pInput->pData[0];

X
Xiaoyu Wang 已提交
4097
  int32_t          numOfElems = 0;
4098 4099 4100
  SColumnInfoData* pOutput = (SColumnInfoData*)pCtx->pOutput;

  int8_t op = getStateOpType(varDataVal(pCtx->param[1].param.pz));
4101 4102 4103 4104
  if (STATE_OPER_INVALID == op) {
    return 0;
  }

4105
  for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
4106 4107 4108 4109 4110 4111 4112
    if (pInfo->isPrevTsSet == true && tsList[i] == pInfo->prevTs) {
      return TSDB_CODE_FUNC_DUP_TIMESTAMP;
    } else {
      pInfo->prevTs = tsList[i];
    }

    pInfo->isPrevTsSet = true;
4113
    numOfElems++;
4114

4115 4116
    if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
      colDataAppendNULL(pOutput, i);
4117 4118
      // handle selectivity
      if (pCtx->subsidiaries.num > 0) {
D
dapan1121 已提交
4119
        appendSelectivityValue(pCtx, i, pCtx->offset + numOfElems - 1);
4120
      }
4121 4122 4123
      continue;
    }

4124 4125
    bool ret = checkStateOp(op, pInputCol, i, pCtx->param[2].param);

4126 4127 4128 4129 4130 4131
    int64_t output = -1;
    if (ret) {
      output = ++pInfo->count;
    } else {
      pInfo->count = 0;
    }
D
dapan1121 已提交
4132
    colDataAppend(pOutput, pCtx->offset + numOfElems - 1, (char*)&output, false);
4133 4134 4135

    // handle selectivity
    if (pCtx->subsidiaries.num > 0) {
D
dapan1121 已提交
4136
      appendSelectivityValue(pCtx, i, pCtx->offset + numOfElems - 1);
4137
    }
4138 4139
  }

4140 4141
  pResInfo->numOfRes = numOfElems;
  return TSDB_CODE_SUCCESS;
4142
}
4143 4144 4145 4146 4147 4148

int32_t stateDurationFunction(SqlFunctionCtx* pCtx) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  SStateInfo*          pInfo = GET_ROWCELL_INTERBUF(pResInfo);

  SInputColumnInfoData* pInput = &pCtx->input;
X
Xiaoyu Wang 已提交
4149
  TSKEY*                tsList = (int64_t*)pInput->pPTS->pData;
4150 4151 4152

  SColumnInfoData* pInputCol = pInput->pData[0];

X
Xiaoyu Wang 已提交
4153
  int32_t          numOfElems = 0;
4154 4155
  SColumnInfoData* pOutput = (SColumnInfoData*)pCtx->pOutput;

X
Xiaoyu Wang 已提交
4156
  // TODO: process timeUnit for different db precisions
4157
  int32_t timeUnit = 1;
X
Xiaoyu Wang 已提交
4158
  if (pCtx->numOfParams == 5) {  // TODO: param number incorrect
4159 4160 4161 4162 4163
    timeUnit = pCtx->param[3].param.i;
  }

  int8_t op = getStateOpType(varDataVal(pCtx->param[1].param.pz));
  if (STATE_OPER_INVALID == op) {
4164
    return TSDB_CODE_INVALID_PARA;
4165 4166 4167
  }

  for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
4168 4169 4170 4171 4172 4173 4174
    if (pInfo->isPrevTsSet == true && tsList[i] == pInfo->prevTs) {
      return TSDB_CODE_FUNC_DUP_TIMESTAMP;
    } else {
      pInfo->prevTs = tsList[i];
    }

    pInfo->isPrevTsSet = true;
4175
    numOfElems++;
4176

4177 4178
    if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
      colDataAppendNULL(pOutput, i);
4179 4180
      // handle selectivity
      if (pCtx->subsidiaries.num > 0) {
D
dapan1121 已提交
4181
        appendSelectivityValue(pCtx, i, pCtx->offset + numOfElems - 1);
4182
      }
4183 4184 4185
      continue;
    }

X
Xiaoyu Wang 已提交
4186
    bool    ret = checkStateOp(op, pInputCol, i, pCtx->param[2].param);
4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197
    int64_t output = -1;
    if (ret) {
      if (pInfo->durationStart == 0) {
        output = 0;
        pInfo->durationStart = tsList[i];
      } else {
        output = (tsList[i] - pInfo->durationStart) / timeUnit;
      }
    } else {
      pInfo->durationStart = 0;
    }
D
dapan1121 已提交
4198
    colDataAppend(pOutput, pCtx->offset + numOfElems - 1, (char*)&output, false);
4199 4200 4201

    // handle selectivity
    if (pCtx->subsidiaries.num > 0) {
D
dapan1121 已提交
4202
      appendSelectivityValue(pCtx, i, pCtx->offset + numOfElems - 1);
4203
    }
4204 4205
  }

4206 4207
  pResInfo->numOfRes = numOfElems;
  return TSDB_CODE_SUCCESS;
4208
}
G
Ganlin Zhao 已提交
4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219

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

int32_t csumFunction(SqlFunctionCtx* pCtx) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  SSumRes*             pSumRes = GET_ROWCELL_INTERBUF(pResInfo);

  SInputColumnInfoData* pInput = &pCtx->input;
4220
  TSKEY*                tsList = (int64_t*)pInput->pPTS->pData;
G
Ganlin Zhao 已提交
4221 4222 4223 4224 4225 4226 4227 4228

  SColumnInfoData* pInputCol = pInput->pData[0];
  SColumnInfoData* pOutput = (SColumnInfoData*)pCtx->pOutput;

  int32_t numOfElems = 0;
  int32_t type = pInputCol->info.type;
  int32_t startOffset = pCtx->offset;
  for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
4229 4230 4231 4232 4233 4234 4235
    if (pSumRes->isPrevTsSet == true && tsList[i] == pSumRes->prevTs) {
      return TSDB_CODE_FUNC_DUP_TIMESTAMP;
    } else {
      pSumRes->prevTs = tsList[i];
    }
    pSumRes->isPrevTsSet = true;

G
Ganlin Zhao 已提交
4236 4237
    int32_t pos = startOffset + numOfElems;
    if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
X
Xiaoyu Wang 已提交
4238
      // colDataAppendNULL(pOutput, i);
G
Ganlin Zhao 已提交
4239 4240 4241 4242 4243 4244 4245 4246
      continue;
    }

    char* data = colDataGetData(pInputCol, i);
    if (IS_SIGNED_NUMERIC_TYPE(type)) {
      int64_t v;
      GET_TYPED_DATA(v, int64_t, type, data);
      pSumRes->isum += v;
X
Xiaoyu Wang 已提交
4247
      colDataAppend(pOutput, pos, (char*)&pSumRes->isum, false);
G
Ganlin Zhao 已提交
4248 4249 4250 4251
    } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
      uint64_t v;
      GET_TYPED_DATA(v, uint64_t, type, data);
      pSumRes->usum += v;
X
Xiaoyu Wang 已提交
4252
      colDataAppend(pOutput, pos, (char*)&pSumRes->usum, false);
G
Ganlin Zhao 已提交
4253 4254 4255 4256
    } else if (IS_FLOAT_TYPE(type)) {
      double v;
      GET_TYPED_DATA(v, double, type, data);
      pSumRes->dsum += v;
X
Xiaoyu Wang 已提交
4257
      // check for overflow
4258 4259
      if (isinf(pSumRes->dsum) || isnan(pSumRes->dsum)) {
        colDataAppendNULL(pOutput, pos);
X
Xiaoyu Wang 已提交
4260 4261
      } else {
        colDataAppend(pOutput, pos, (char*)&pSumRes->dsum, false);
4262
      }
G
Ganlin Zhao 已提交
4263 4264
    }

4265 4266 4267 4268 4269
    // handle selectivity
    if (pCtx->subsidiaries.num > 0) {
      appendSelectivityValue(pCtx, i, pos);
    }

G
Ganlin Zhao 已提交
4270 4271 4272
    numOfElems++;
  }

4273 4274
  pResInfo->numOfRes = numOfElems;
  return TSDB_CODE_SUCCESS;
G
Ganlin Zhao 已提交
4275
}
G
Ganlin Zhao 已提交
4276 4277 4278 4279 4280 4281

bool getMavgFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(SMavgInfo) + MAVG_MAX_POINTS_NUM * sizeof(double);
  return true;
}

X
Xiaoyu Wang 已提交
4282
bool mavgFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
G
Ganlin Zhao 已提交
4283 4284 4285 4286
  if (!functionSetup(pCtx, pResultInfo)) {
    return false;
  }

X
Xiaoyu Wang 已提交
4287
  SMavgInfo* pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
G
Ganlin Zhao 已提交
4288 4289
  pInfo->pos = 0;
  pInfo->sum = 0;
4290 4291
  pInfo->prevTs = -1;
  pInfo->isPrevTsSet = false;
G
Ganlin Zhao 已提交
4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305
  pInfo->numOfPoints = pCtx->param[1].param.i;
  if (pInfo->numOfPoints < 1 || pInfo->numOfPoints > MAVG_MAX_POINTS_NUM) {
    return false;
  }
  pInfo->pointsMeet = false;

  return true;
}

int32_t mavgFunction(SqlFunctionCtx* pCtx) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  SMavgInfo*           pInfo = GET_ROWCELL_INTERBUF(pResInfo);

  SInputColumnInfoData* pInput = &pCtx->input;
4306
  TSKEY*                tsList = (int64_t*)pInput->pPTS->pData;
G
Ganlin Zhao 已提交
4307 4308 4309 4310 4311 4312 4313 4314 4315

  SColumnInfoData* pInputCol = pInput->pData[0];
  SColumnInfoData* pTsOutput = pCtx->pTsOutput;
  SColumnInfoData* pOutput = (SColumnInfoData*)pCtx->pOutput;

  int32_t numOfElems = 0;
  int32_t type = pInputCol->info.type;
  int32_t startOffset = pCtx->offset;
  for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
4316 4317 4318 4319 4320 4321 4322
    if (pInfo->isPrevTsSet == true && tsList[i] == pInfo->prevTs) {
      return TSDB_CODE_FUNC_DUP_TIMESTAMP;
    } else {
      pInfo->prevTs = tsList[i];
    }
    pInfo->isPrevTsSet = true;

G
Ganlin Zhao 已提交
4323 4324
    int32_t pos = startOffset + numOfElems;
    if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
X
Xiaoyu Wang 已提交
4325
      // colDataAppendNULL(pOutput, i);
G
Ganlin Zhao 已提交
4326 4327 4328
      continue;
    }

X
Xiaoyu Wang 已提交
4329
    char*  data = colDataGetData(pInputCol, i);
G
Ganlin Zhao 已提交
4330 4331 4332 4333 4334 4335 4336 4337
    double v;
    GET_TYPED_DATA(v, double, type, data);

    if (!pInfo->pointsMeet && (pInfo->pos < pInfo->numOfPoints - 1)) {
      pInfo->points[pInfo->pos] = v;
      pInfo->sum += v;
    } else {
      if (!pInfo->pointsMeet && (pInfo->pos == pInfo->numOfPoints - 1)) {
X
Xiaoyu Wang 已提交
4338
        pInfo->sum += v;
G
Ganlin Zhao 已提交
4339 4340 4341 4342 4343
        pInfo->pointsMeet = true;
      } else {
        pInfo->sum = pInfo->sum + v - pInfo->points[pInfo->pos];
      }

G
Ganlin Zhao 已提交
4344 4345
      pInfo->points[pInfo->pos] = v;
      double result = pInfo->sum / pInfo->numOfPoints;
X
Xiaoyu Wang 已提交
4346
      // check for overflow
4347 4348
      if (isinf(result) || isnan(result)) {
        colDataAppendNULL(pOutput, pos);
X
Xiaoyu Wang 已提交
4349 4350
      } else {
        colDataAppend(pOutput, pos, (char*)&result, false);
4351
      }
G
Ganlin Zhao 已提交
4352

4353 4354 4355 4356 4357
      // handle selectivity
      if (pCtx->subsidiaries.num > 0) {
        appendSelectivityValue(pCtx, i, pos);
      }

G
Ganlin Zhao 已提交
4358
      numOfElems++;
G
Ganlin Zhao 已提交
4359 4360
    }

G
Ganlin Zhao 已提交
4361 4362 4363 4364
    pInfo->pos++;
    if (pInfo->pos == pInfo->numOfPoints) {
      pInfo->pos = 0;
    }
G
Ganlin Zhao 已提交
4365 4366
  }

4367 4368
  pResInfo->numOfRes = numOfElems;
  return TSDB_CODE_SUCCESS;
G
Ganlin Zhao 已提交
4369
}
G
Ganlin Zhao 已提交
4370

4371 4372 4373 4374 4375 4376 4377 4378 4379 4380
static SSampleInfo* getSampleOutputInfo(SqlFunctionCtx* pCtx) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  SSampleInfo*         pInfo = GET_ROWCELL_INTERBUF(pResInfo);

  pInfo->data = (char*)pInfo + sizeof(SSampleInfo);
  pInfo->tuplePos = (STuplePos*)((char*)pInfo + sizeof(SSampleInfo) + pInfo->samples * pInfo->colBytes);

  return pInfo;
}

G
Ganlin Zhao 已提交
4381 4382
bool getSampleFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
  SColumnNode* pCol = (SColumnNode*)nodesListGetNode(pFunc->pParameterList, 0);
X
Xiaoyu Wang 已提交
4383 4384
  SValueNode*  pVal = (SValueNode*)nodesListGetNode(pFunc->pParameterList, 1);
  int32_t      numOfSamples = pVal->datum.i;
4385
  pEnv->calcMemSize = sizeof(SSampleInfo) + numOfSamples * (pCol->node.resType.bytes + sizeof(STuplePos));
G
Ganlin Zhao 已提交
4386 4387 4388
  return true;
}

X
Xiaoyu Wang 已提交
4389
bool sampleFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
G
Ganlin Zhao 已提交
4390 4391 4392 4393 4394 4395
  if (!functionSetup(pCtx, pResultInfo)) {
    return false;
  }

  taosSeedRand(taosSafeRand());

X
Xiaoyu Wang 已提交
4396
  SSampleInfo* pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
G
Ganlin Zhao 已提交
4397 4398 4399
  pInfo->samples = pCtx->param[1].param.i;
  pInfo->totalPoints = 0;
  pInfo->numSampled = 0;
G
Ganlin Zhao 已提交
4400 4401
  pInfo->colType = pCtx->resDataInfo.type;
  pInfo->colBytes = pCtx->resDataInfo.bytes;
4402 4403
  pInfo->nullTuplePos.pageId = -1;
  pInfo->nullTupleSaved = false;
X
Xiaoyu Wang 已提交
4404
  pInfo->data = (char*)pInfo + sizeof(SSampleInfo);
4405
  pInfo->tuplePos = (STuplePos*)((char*)pInfo + sizeof(SSampleInfo) + pInfo->samples * pInfo->colBytes);
G
Ganlin Zhao 已提交
4406 4407 4408 4409

  return true;
}

4410
static void sampleAssignResult(SSampleInfo* pInfo, char* data, int32_t index) {
G
Ganlin Zhao 已提交
4411
  assignVal(pInfo->data + index * pInfo->colBytes, data, pInfo->colBytes, pInfo->colType);
G
Ganlin Zhao 已提交
4412 4413
}

4414
static void doReservoirSample(SqlFunctionCtx* pCtx, SSampleInfo* pInfo, char* data, int32_t index) {
G
Ganlin Zhao 已提交
4415 4416
  pInfo->totalPoints++;
  if (pInfo->numSampled < pInfo->samples) {
4417 4418
    sampleAssignResult(pInfo, data, pInfo->numSampled);
    if (pCtx->subsidiaries.num > 0) {
4419
      pInfo->tuplePos[pInfo->numSampled] = saveTupleData(pCtx, index, pCtx->pSrcBlock, NULL);
4420
    }
G
Ganlin Zhao 已提交
4421 4422 4423 4424
    pInfo->numSampled++;
  } else {
    int32_t j = taosRand() % (pInfo->totalPoints);
    if (j < pInfo->samples) {
4425 4426
      sampleAssignResult(pInfo, data, j);
      if (pCtx->subsidiaries.num > 0) {
4427
        updateTupleData(pCtx, index, pCtx->pSrcBlock, &pInfo->tuplePos[j]);
4428
      }
G
Ganlin Zhao 已提交
4429 4430 4431 4432 4433 4434
    }
  }
}

int32_t sampleFunction(SqlFunctionCtx* pCtx) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
4435
  SSampleInfo*         pInfo = getSampleOutputInfo(pCtx);
G
Ganlin Zhao 已提交
4436 4437 4438

  SInputColumnInfoData* pInput = &pCtx->input;

4439
  SColumnInfoData* pInputCol = pInput->pData[0];
G
Ganlin Zhao 已提交
4440
  for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
4441
    if (colDataIsNull_s(pInputCol, i)) {
G
Ganlin Zhao 已提交
4442 4443 4444 4445
      continue;
    }

    char* data = colDataGetData(pInputCol, i);
4446
    doReservoirSample(pCtx, pInfo, data, i);
G
Ganlin Zhao 已提交
4447 4448
  }

4449
  if (pInfo->numSampled == 0 && pCtx->subsidiaries.num > 0 && !pInfo->nullTupleSaved) {
4450
    pInfo->nullTuplePos = saveTupleData(pCtx, pInput->startRowIndex, pCtx->pSrcBlock, NULL);
4451 4452 4453
    pInfo->nullTupleSaved = true;
  }

4454 4455 4456 4457 4458 4459 4460
  SET_VAL(pResInfo, pInfo->numSampled, pInfo->numSampled);
  return TSDB_CODE_SUCCESS;
}

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

4461
  SSampleInfo* pInfo = getSampleOutputInfo(pCtx);
4462 4463
  pEntryInfo->complete = true;

X
Xiaoyu Wang 已提交
4464
  int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
4465 4466 4467
  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);

  int32_t currentRow = pBlock->info.rows;
4468 4469
  if (pInfo->numSampled == 0) {
    colDataAppendNULL(pCol, currentRow);
4470
    setSelectivityValue(pCtx, pBlock, &pInfo->nullTuplePos, currentRow);
4471 4472
    return pInfo->numSampled;
  }
G
Ganlin Zhao 已提交
4473
  for (int32_t i = 0; i < pInfo->numSampled; ++i) {
4474
    colDataAppend(pCol, currentRow + i, pInfo->data + i * pInfo->colBytes, false);
4475
    setSelectivityValue(pCtx, pBlock, &pInfo->tuplePos[i], currentRow + i);
G
Ganlin Zhao 已提交
4476 4477
  }

G
Ganlin Zhao 已提交
4478 4479 4480
  return pInfo->numSampled;
}

G
Ganlin Zhao 已提交
4481
bool getTailFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
4482
#if 0
G
Ganlin Zhao 已提交
4483 4484
  SColumnNode* pCol = (SColumnNode*)nodesListGetNode(pFunc->pParameterList, 0);
  SValueNode*  pVal = (SValueNode*)nodesListGetNode(pFunc->pParameterList, 1);
X
Xiaoyu Wang 已提交
4485
  int32_t      numOfPoints = pVal->datum.i;
G
Ganlin Zhao 已提交
4486
  pEnv->calcMemSize = sizeof(STailInfo) + numOfPoints * (POINTER_BYTES + sizeof(STailItem) + pCol->node.resType.bytes);
4487
#endif
G
Ganlin Zhao 已提交
4488 4489 4490
  return true;
}

X
Xiaoyu Wang 已提交
4491
bool tailFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
4492
#if 0
G
Ganlin Zhao 已提交
4493 4494 4495 4496
  if (!functionSetup(pCtx, pResultInfo)) {
    return false;
  }

X
Xiaoyu Wang 已提交
4497
  STailInfo* pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
G
Ganlin Zhao 已提交
4498 4499
  pInfo->numAdded = 0;
  pInfo->numOfPoints = pCtx->param[1].param.i;
4500 4501 4502 4503 4504
  if (pCtx->numOfParams == 4) {
    pInfo->offset = pCtx->param[2].param.i;
  } else {
    pInfo->offset = 0;
  }
G
Ganlin Zhao 已提交
4505 4506 4507 4508 4509 4510 4511
  pInfo->colType = pCtx->resDataInfo.type;
  pInfo->colBytes = pCtx->resDataInfo.bytes;
  if ((pInfo->numOfPoints < 1 || pInfo->numOfPoints > TAIL_MAX_POINTS_NUM) ||
      (pInfo->numOfPoints < 0 || pInfo->numOfPoints > TAIL_MAX_OFFSET)) {
    return false;
  }

X
Xiaoyu Wang 已提交
4512 4513
  pInfo->pItems = (STailItem**)((char*)pInfo + sizeof(STailInfo));
  char* pItem = (char*)pInfo->pItems + pInfo->numOfPoints * POINTER_BYTES;
G
Ganlin Zhao 已提交
4514

G
Ganlin Zhao 已提交
4515
  size_t unitSize = sizeof(STailItem) + pInfo->colBytes;
G
Ganlin Zhao 已提交
4516
  for (int32_t i = 0; i < pInfo->numOfPoints; ++i) {
X
Xiaoyu Wang 已提交
4517
    pInfo->pItems[i] = (STailItem*)(pItem + i * unitSize);
4518
    pInfo->pItems[i]->isNull = false;
G
Ganlin Zhao 已提交
4519
  }
4520
#endif
G
Ganlin Zhao 已提交
4521 4522 4523 4524

  return true;
}

X
Xiaoyu Wang 已提交
4525
static void tailAssignResult(STailItem* pItem, char* data, int32_t colBytes, TSKEY ts, bool isNull) {
4526
#if 0
G
Ganlin Zhao 已提交
4527
  pItem->timestamp = ts;
4528 4529 4530
  if (isNull) {
    pItem->isNull = true;
  } else {
4531
    pItem->isNull = false;
4532 4533
    memcpy(pItem->data, data, colBytes);
  }
4534
#endif
G
Ganlin Zhao 已提交
4535 4536
}

4537
#if 0
X
Xiaoyu Wang 已提交
4538 4539 4540
static int32_t tailCompFn(const void* p1, const void* p2, const void* param) {
  STailItem* d1 = *(STailItem**)p1;
  STailItem* d2 = *(STailItem**)p2;
G
Ganlin Zhao 已提交
4541 4542 4543
  return compareInt64Val(&d1->timestamp, &d2->timestamp);
}

X
Xiaoyu Wang 已提交
4544 4545
static void doTailAdd(STailInfo* pInfo, char* data, TSKEY ts, bool isNull) {
  STailItem** pList = pInfo->pItems;
G
Ganlin Zhao 已提交
4546
  if (pInfo->numAdded < pInfo->numOfPoints) {
4547
    tailAssignResult(pList[pInfo->numAdded], data, pInfo->colBytes, ts, isNull);
X
Xiaoyu Wang 已提交
4548
    taosheapsort((void*)pList, sizeof(STailItem**), pInfo->numAdded + 1, NULL, tailCompFn, 0);
G
Ganlin Zhao 已提交
4549
    pInfo->numAdded++;
G
Ganlin Zhao 已提交
4550
  } else if (pList[0]->timestamp < ts) {
4551
    tailAssignResult(pList[0], data, pInfo->colBytes, ts, isNull);
X
Xiaoyu Wang 已提交
4552
    taosheapadjust((void*)pList, sizeof(STailItem**), 0, pInfo->numOfPoints - 1, NULL, tailCompFn, NULL, 0);
G
Ganlin Zhao 已提交
4553 4554
  }
}
4555
#endif
G
Ganlin Zhao 已提交
4556 4557

int32_t tailFunction(SqlFunctionCtx* pCtx) {
4558
#if 0
G
Ganlin Zhao 已提交
4559
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
X
Xiaoyu Wang 已提交
4560
  STailInfo*           pInfo = GET_ROWCELL_INTERBUF(pResInfo);
G
Ganlin Zhao 已提交
4561 4562

  SInputColumnInfoData* pInput = &pCtx->input;
X
Xiaoyu Wang 已提交
4563
  TSKEY*                tsList = (int64_t*)pInput->pPTS->pData;
G
Ganlin Zhao 已提交
4564 4565 4566 4567 4568

  SColumnInfoData* pInputCol = pInput->pData[0];
  SColumnInfoData* pOutput = (SColumnInfoData*)pCtx->pOutput;

  int32_t startOffset = pCtx->offset;
4569 4570 4571
  if (pInfo->offset >= pInput->numOfRows) {
    return 0;
  } else {
wafwerar's avatar
wafwerar 已提交
4572
    pInfo->numOfPoints = TMIN(pInfo->numOfPoints, pInput->numOfRows - pInfo->offset);
4573 4574
  }
  for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex - pInfo->offset; i += 1) {
G
Ganlin Zhao 已提交
4575
    char* data = colDataGetData(pInputCol, i);
4576
    doTailAdd(pInfo, data, tsList[i], colDataIsNull_s(pInputCol, i));
G
Ganlin Zhao 已提交
4577 4578
  }

4579 4580
  taosqsort(pInfo->pItems, pInfo->numOfPoints, POINTER_BYTES, NULL, tailCompFn);

G
Ganlin Zhao 已提交
4581
  for (int32_t i = 0; i < pInfo->numOfPoints; ++i) {
X
Xiaoyu Wang 已提交
4582 4583
    int32_t    pos = startOffset + i;
    STailItem* pItem = pInfo->pItems[i];
4584 4585 4586 4587 4588
    if (pItem->isNull) {
      colDataAppendNULL(pOutput, pos);
    } else {
      colDataAppend(pOutput, pos, pItem->data, false);
    }
G
Ganlin Zhao 已提交
4589 4590
  }

G
Ganlin Zhao 已提交
4591
  return pInfo->numOfPoints;
4592 4593
#endif
  return 0;
G
Ganlin Zhao 已提交
4594
}
G
Ganlin Zhao 已提交
4595 4596

int32_t tailFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
4597
#if 0
G
Ganlin Zhao 已提交
4598
  SResultRowEntryInfo* pEntryInfo = GET_RES_INFO(pCtx);
X
Xiaoyu Wang 已提交
4599
  STailInfo*           pInfo = GET_ROWCELL_INTERBUF(pEntryInfo);
G
Ganlin Zhao 已提交
4600 4601 4602 4603 4604 4605 4606 4607 4608 4609
  pEntryInfo->complete = true;

  int32_t type = pCtx->input.pData[0]->info.type;
  int32_t slotId = pCtx->pExpr->base.resSchema.slotId;

  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);

  // todo assign the tag value and the corresponding row data
  int32_t currentRow = pBlock->info.rows;
  for (int32_t i = 0; i < pEntryInfo->numOfRes; ++i) {
X
Xiaoyu Wang 已提交
4610
    STailItem* pItem = pInfo->pItems[i];
G
Ganlin Zhao 已提交
4611 4612 4613 4614 4615
    colDataAppend(pCol, currentRow, pItem->data, false);
    currentRow += 1;
  }

  return pEntryInfo->numOfRes;
4616 4617
#endif
  return 0;
G
Ganlin Zhao 已提交
4618
}
4619 4620

bool getUniqueFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
4621
#if 0
4622
  pEnv->calcMemSize = sizeof(SUniqueInfo) + UNIQUE_MAX_RESULT_SIZE;
4623
#endif
4624 4625 4626 4627
  return true;
}

bool uniqueFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
4628
#if 0
4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641
  if (!functionSetup(pCtx, pResInfo)) {
    return false;
  }

  SUniqueInfo* pInfo = GET_ROWCELL_INTERBUF(pResInfo);
  pInfo->numOfPoints = 0;
  pInfo->colType = pCtx->resDataInfo.type;
  pInfo->colBytes = pCtx->resDataInfo.bytes;
  if (pInfo->pHash != NULL) {
    taosHashClear(pInfo->pHash);
  } else {
    pInfo->pHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
  }
4642
#endif
4643 4644 4645
  return true;
}

4646
#if 0
X
Xiaoyu Wang 已提交
4647 4648
static void doUniqueAdd(SUniqueInfo* pInfo, char* data, TSKEY ts, bool isNull) {
  // handle null elements
4649
  if (isNull == true) {
X
Xiaoyu Wang 已提交
4650 4651
    int32_t      size = sizeof(SUniqueItem) + pInfo->colBytes;
    SUniqueItem* pItem = (SUniqueItem*)(pInfo->pItems + pInfo->numOfPoints * size);
4652
    if (pInfo->hasNull == false && pItem->isNull == false) {
4653 4654 4655
      pItem->timestamp = ts;
      pItem->isNull = true;
      pInfo->numOfPoints++;
4656
      pInfo->hasNull = true;
4657 4658 4659 4660 4661
    } else if (pItem->timestamp > ts && pItem->isNull == true) {
      pItem->timestamp = ts;
    }
    return;
  }
4662

X
Xiaoyu Wang 已提交
4663 4664
  int32_t      hashKeyBytes = IS_VAR_DATA_TYPE(pInfo->colType) ? varDataTLen(data) : pInfo->colBytes;
  SUniqueItem* pHashItem = taosHashGet(pInfo->pHash, data, hashKeyBytes);
4665
  if (pHashItem == NULL) {
X
Xiaoyu Wang 已提交
4666 4667
    int32_t      size = sizeof(SUniqueItem) + pInfo->colBytes;
    SUniqueItem* pItem = (SUniqueItem*)(pInfo->pItems + pInfo->numOfPoints * size);
4668 4669 4670
    pItem->timestamp = ts;
    memcpy(pItem->data, data, pInfo->colBytes);

X
Xiaoyu Wang 已提交
4671
    taosHashPut(pInfo->pHash, data, hashKeyBytes, (char*)pItem, sizeof(SUniqueItem*));
4672 4673 4674 4675 4676
    pInfo->numOfPoints++;
  } else if (pHashItem->timestamp > ts) {
    pHashItem->timestamp = ts;
  }
}
4677
#endif
4678 4679

int32_t uniqueFunction(SqlFunctionCtx* pCtx) {
4680
#if 0
4681 4682 4683 4684
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  SUniqueInfo*         pInfo = GET_ROWCELL_INTERBUF(pResInfo);

  SInputColumnInfoData* pInput = &pCtx->input;
X
Xiaoyu Wang 已提交
4685
  TSKEY*                tsList = (int64_t*)pInput->pPTS->pData;
4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702

  SColumnInfoData* pInputCol = pInput->pData[0];
  SColumnInfoData* pTsOutput = pCtx->pTsOutput;
  SColumnInfoData* pOutput = (SColumnInfoData*)pCtx->pOutput;

  int32_t startOffset = pCtx->offset;
  for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
    char* data = colDataGetData(pInputCol, i);
    doUniqueAdd(pInfo, data, tsList[i], colDataIsNull_s(pInputCol, i));

    if (sizeof(SUniqueInfo) + pInfo->numOfPoints * (sizeof(SUniqueItem) + pInfo->colBytes) >= UNIQUE_MAX_RESULT_SIZE) {
      taosHashCleanup(pInfo->pHash);
      return 0;
    }
  }

  for (int32_t i = 0; i < pInfo->numOfPoints; ++i) {
X
Xiaoyu Wang 已提交
4703
    SUniqueItem* pItem = (SUniqueItem*)(pInfo->pItems + i * (sizeof(SUniqueItem) + pInfo->colBytes));
4704 4705 4706 4707 4708
    if (pItem->isNull == true) {
      colDataAppendNULL(pOutput, i);
    } else {
      colDataAppend(pOutput, i, pItem->data, false);
    }
4709 4710 4711 4712 4713 4714
    if (pTsOutput != NULL) {
      colDataAppendInt64(pTsOutput, i, &pItem->timestamp);
    }
  }

  return pInfo->numOfPoints;
4715 4716
#endif
  return 0;
4717 4718
}

G
Ganlin Zhao 已提交
4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737
bool getModeFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(SModeInfo) + MODE_MAX_RESULT_SIZE;
  return true;
}

bool modeFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
  if (!functionSetup(pCtx, pResInfo)) {
    return false;
  }

  SModeInfo* pInfo = GET_ROWCELL_INTERBUF(pResInfo);
  pInfo->numOfPoints = 0;
  pInfo->colType = pCtx->resDataInfo.type;
  pInfo->colBytes = pCtx->resDataInfo.bytes;
  if (pInfo->pHash != NULL) {
    taosHashClear(pInfo->pHash);
  } else {
    pInfo->pHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
  }
4738 4739 4740
  pInfo->nullTupleSaved = false;
  pInfo->nullTuplePos.pageId = -1;

G
Ganlin Zhao 已提交
4741 4742 4743
  return true;
}

4744
static void doModeAdd(SModeInfo* pInfo, int32_t rowIndex, SqlFunctionCtx* pCtx, char* data) {
4745
  int32_t     hashKeyBytes = IS_STR_DATA_TYPE(pInfo->colType) ? varDataTLen(data) : pInfo->colBytes;
4746
  SModeItem** pHashItem = taosHashGet(pInfo->pHash, data, hashKeyBytes);
G
Ganlin Zhao 已提交
4747
  if (pHashItem == NULL) {
4748 4749
    int32_t    size = sizeof(SModeItem) + pInfo->colBytes;
    SModeItem* pItem = (SModeItem*)(pInfo->pItems + pInfo->numOfPoints * size);
4750
    memcpy(pItem->data, data, hashKeyBytes);
G
Ganlin Zhao 已提交
4751 4752
    pItem->count += 1;

4753 4754 4755 4756
    if (pCtx->subsidiaries.num > 0) {
      pItem->tuplePos = saveTupleData(pCtx, rowIndex, pCtx->pSrcBlock, NULL);
    }

G
Ganlin Zhao 已提交
4757
    taosHashPut(pInfo->pHash, data, hashKeyBytes, &pItem, sizeof(SModeItem*));
G
Ganlin Zhao 已提交
4758 4759
    pInfo->numOfPoints++;
  } else {
G
Ganlin Zhao 已提交
4760
    (*pHashItem)->count += 1;
4761 4762 4763
    if (pCtx->subsidiaries.num > 0) {
      updateTupleData(pCtx, rowIndex, pCtx->pSrcBlock, &((*pHashItem)->tuplePos));
    }
G
Ganlin Zhao 已提交
4764 4765 4766 4767
  }
}

int32_t modeFunction(SqlFunctionCtx* pCtx) {
4768
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
4769
  SModeInfo*           pInfo = GET_ROWCELL_INTERBUF(pResInfo);
G
Ganlin Zhao 已提交
4770 4771 4772 4773 4774 4775

  SInputColumnInfoData* pInput = &pCtx->input;

  SColumnInfoData* pInputCol = pInput->pData[0];
  SColumnInfoData* pOutput = (SColumnInfoData*)pCtx->pOutput;

4776
  int32_t numOfElems = 0;
G
Ganlin Zhao 已提交
4777 4778
  int32_t startOffset = pCtx->offset;
  for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
4779 4780 4781 4782
    if (colDataIsNull_s(pInputCol, i)) {
      continue;
    }
    numOfElems++;
4783 4784

    char* data = colDataGetData(pInputCol, i);
4785
    doModeAdd(pInfo, i, pCtx, data);
G
Ganlin Zhao 已提交
4786 4787 4788 4789 4790 4791 4792

    if (sizeof(SModeInfo) + pInfo->numOfPoints * (sizeof(SModeItem) + pInfo->colBytes) >= MODE_MAX_RESULT_SIZE) {
      taosHashCleanup(pInfo->pHash);
      return TSDB_CODE_OUT_OF_MEMORY;
    }
  }

4793 4794 4795 4796 4797
  if (numOfElems == 0 && pCtx->subsidiaries.num > 0 && !pInfo->nullTupleSaved) {
    pInfo->nullTuplePos = saveTupleData(pCtx, pInput->startRowIndex, pCtx->pSrcBlock, NULL);
    pInfo->nullTupleSaved = true;
  }

4798
  SET_VAL(pResInfo, numOfElems, 1);
G
Ganlin Zhao 已提交
4799

G
Ganlin Zhao 已提交
4800 4801 4802 4803 4804 4805
  return TSDB_CODE_SUCCESS;
}

int32_t modeFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  SModeInfo*           pInfo = GET_ROWCELL_INTERBUF(pResInfo);
X
Xiaoyu Wang 已提交
4806 4807
  int32_t              slotId = pCtx->pExpr->base.resSchema.slotId;
  SColumnInfoData*     pCol = taosArrayGet(pBlock->pDataBlock, slotId);
G
Ganlin Zhao 已提交
4808
  int32_t              currentRow = pBlock->info.rows;
4809

G
Ganlin Zhao 已提交
4810
  int32_t resIndex = -1;
G
Ganlin Zhao 已提交
4811 4812 4813
  int32_t maxCount = 0;
  for (int32_t i = 0; i < pInfo->numOfPoints; ++i) {
    SModeItem* pItem = (SModeItem*)(pInfo->pItems + i * (sizeof(SModeItem) + pInfo->colBytes));
4814
    if (pItem->count >= maxCount) {
G
Ganlin Zhao 已提交
4815 4816 4817
      maxCount = pItem->count;
      resIndex = i;
    }
4818 4819
  }

G
Ganlin Zhao 已提交
4820 4821 4822
  if (maxCount != 0) {
    SModeItem* pResItem = (SModeItem*)(pInfo->pItems + resIndex * (sizeof(SModeItem) + pInfo->colBytes));
    colDataAppend(pCol, currentRow, pResItem->data, false);
4823
    setSelectivityValue(pCtx, pBlock, &pResItem->tuplePos, currentRow);
G
Ganlin Zhao 已提交
4824 4825
  } else {
    colDataAppendNULL(pCol, currentRow);
4826
    setSelectivityValue(pCtx, pBlock, &pInfo->nullTuplePos, currentRow);
G
Ganlin Zhao 已提交
4827
  }
G
Ganlin Zhao 已提交
4828

G
Ganlin Zhao 已提交
4829 4830
  taosHashCleanup(pInfo->pHash);

4831 4832 4833
  return pResInfo->numOfRes;
}

4834 4835 4836 4837 4838
bool getTwaFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(STwaInfo);
  return true;
}

X
Xiaoyu Wang 已提交
4839
bool twaFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
4840 4841 4842 4843
  if (!functionSetup(pCtx, pResultInfo)) {
    return false;
  }

X
Xiaoyu Wang 已提交
4844
  STwaInfo* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
4845
  pInfo->isNull = false;
4846 4847
  pInfo->p.key = INT64_MIN;
  pInfo->win = TSWINDOW_INITIALIZER;
4848 4849 4850 4851
  return true;
}

static double twa_get_area(SPoint1 s, SPoint1 e) {
4852 4853 4854 4855
  if (e.key == INT64_MAX || s.key == INT64_MIN) {
    return 0;
  }

X
Xiaoyu Wang 已提交
4856
  if ((s.val >= 0 && e.val >= 0) || (s.val <= 0 && e.val <= 0)) {
4857 4858 4859
    return (s.val + e.val) * (e.key - s.key) / 2;
  }

X
Xiaoyu Wang 已提交
4860
  double x = (s.key * e.val - e.key * s.val) / (e.val - s.val);
4861 4862 4863 4864 4865 4866
  double val = (s.val * (x - s.key) + e.val * (e.key - x)) / 2;
  return val;
}

int32_t twaFunction(SqlFunctionCtx* pCtx) {
  SInputColumnInfoData* pInput = &pCtx->input;
X
Xiaoyu Wang 已提交
4867
  SColumnInfoData*      pInputCol = pInput->pData[0];
4868 4869 4870

  TSKEY* tsList = (int64_t*)pInput->pPTS->pData;

X
Xiaoyu Wang 已提交
4871
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
4872

X
Xiaoyu Wang 已提交
4873 4874
  STwaInfo* pInfo = GET_ROWCELL_INTERBUF(pResInfo);
  SPoint1*  last = &pInfo->p;
4875
  int32_t   numOfElems = 0;
4876

4877 4878 4879 4880 4881
  if (IS_NULL_TYPE(pInputCol->info.type)) {
    pInfo->isNull = true;
    goto _twa_over;
  }

4882 4883
  int32_t i = pInput->startRowIndex;
  if (pCtx->start.key != INT64_MIN) {
4884
    // tAssert((pCtx->start.key < tsList[i] && pCtx->order == TSDB_ORDER_ASC) ||
4885
    //        (pCtx->start.key > tsList[i] && pCtx->order == TSDB_ORDER_DESC));
4886

4887
    tAssert(last->key == INT64_MIN);
4888 4889 4890 4891
    for (; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
      if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
        continue;
      }
4892

4893
      last->key = tsList[i];
4894

4895 4896 4897 4898 4899 4900 4901 4902
      GET_TYPED_DATA(last->val, double, pInputCol->info.type, colDataGetData(pInputCol, i));

      pInfo->dOutput += twa_get_area(pCtx->start, *last);
      pInfo->win.skey = pCtx->start.key;
      numOfElems++;
      i += 1;
      break;
    }
4903
  } else if (pInfo->p.key == INT64_MIN) {
4904 4905 4906 4907
    for (; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
      if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
        continue;
      }
4908

4909 4910 4911 4912 4913 4914 4915 4916 4917
      last->key = tsList[i];

      GET_TYPED_DATA(last->val, double, pInputCol->info.type, colDataGetData(pInputCol, i));

      pInfo->win.skey = last->key;
      numOfElems++;
      i += 1;
      break;
    }
4918 4919
  }

4920 4921
  SPoint1 st = {0};

4922
  // calculate the value of
X
Xiaoyu Wang 已提交
4923
  switch (pInputCol->info.type) {
4924
    case TSDB_DATA_TYPE_TINYINT: {
X
Xiaoyu Wang 已提交
4925
      int8_t* val = (int8_t*)colDataGetData(pInputCol, 0);
4926
      for (; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
4927 4928 4929
        if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
          continue;
        }
4930
        numOfElems++;
4931

4932
        INIT_INTP_POINT(st, tsList[i], val[i]);
4933
        if (pInfo->p.key == st.key) {
4934
          return TSDB_CODE_FUNC_DUP_TIMESTAMP;
4935 4936
        }

4937 4938 4939 4940 4941 4942 4943
        pInfo->dOutput += twa_get_area(pInfo->p, st);
        pInfo->p = st;
      }
      break;
    }

    case TSDB_DATA_TYPE_SMALLINT: {
X
Xiaoyu Wang 已提交
4944
      int16_t* val = (int16_t*)colDataGetData(pInputCol, 0);
4945
      for (; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
4946 4947 4948
        if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
          continue;
        }
4949
        numOfElems++;
4950

4951
        INIT_INTP_POINT(st, tsList[i], val[i]);
4952
        if (pInfo->p.key == st.key) {
4953
          return TSDB_CODE_FUNC_DUP_TIMESTAMP;
4954 4955
        }

4956 4957 4958 4959 4960 4961
        pInfo->dOutput += twa_get_area(pInfo->p, st);
        pInfo->p = st;
      }
      break;
    }
    case TSDB_DATA_TYPE_INT: {
X
Xiaoyu Wang 已提交
4962
      int32_t* val = (int32_t*)colDataGetData(pInputCol, 0);
4963
      for (; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
4964 4965 4966
        if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
          continue;
        }
4967
        numOfElems++;
4968

4969
        INIT_INTP_POINT(st, tsList[i], val[i]);
4970
        if (pInfo->p.key == st.key) {
4971
          return TSDB_CODE_FUNC_DUP_TIMESTAMP;
4972 4973
        }

4974 4975 4976 4977 4978 4979
        pInfo->dOutput += twa_get_area(pInfo->p, st);
        pInfo->p = st;
      }
      break;
    }
    case TSDB_DATA_TYPE_BIGINT: {
X
Xiaoyu Wang 已提交
4980
      int64_t* val = (int64_t*)colDataGetData(pInputCol, 0);
4981
      for (; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
4982 4983 4984
        if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
          continue;
        }
4985
        numOfElems++;
4986

4987
        INIT_INTP_POINT(st, tsList[i], val[i]);
4988
        if (pInfo->p.key == st.key) {
4989
          return TSDB_CODE_FUNC_DUP_TIMESTAMP;
4990 4991
        }

4992 4993 4994 4995 4996 4997
        pInfo->dOutput += twa_get_area(pInfo->p, st);
        pInfo->p = st;
      }
      break;
    }
    case TSDB_DATA_TYPE_FLOAT: {
X
Xiaoyu Wang 已提交
4998
      float* val = (float*)colDataGetData(pInputCol, 0);
4999
      for (; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
5000 5001 5002
        if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
          continue;
        }
5003
        numOfElems++;
5004

5005
        INIT_INTP_POINT(st, tsList[i], val[i]);
5006
        if (pInfo->p.key == st.key) {
5007
          return TSDB_CODE_FUNC_DUP_TIMESTAMP;
5008 5009
        }

5010 5011 5012 5013 5014 5015
        pInfo->dOutput += twa_get_area(pInfo->p, st);
        pInfo->p = st;
      }
      break;
    }
    case TSDB_DATA_TYPE_DOUBLE: {
X
Xiaoyu Wang 已提交
5016
      double* val = (double*)colDataGetData(pInputCol, 0);
5017
      for (; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
5018 5019 5020
        if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
          continue;
        }
5021
        numOfElems++;
5022

5023
        INIT_INTP_POINT(st, tsList[i], val[i]);
5024
        if (pInfo->p.key == st.key) {
5025
          return TSDB_CODE_FUNC_DUP_TIMESTAMP;
5026 5027
        }

5028 5029 5030 5031 5032 5033
        pInfo->dOutput += twa_get_area(pInfo->p, st);
        pInfo->p = st;
      }
      break;
    }
    case TSDB_DATA_TYPE_UTINYINT: {
X
Xiaoyu Wang 已提交
5034
      uint8_t* val = (uint8_t*)colDataGetData(pInputCol, 0);
5035
      for (; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
5036 5037 5038
        if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
          continue;
        }
5039
        numOfElems++;
5040

5041
        INIT_INTP_POINT(st, tsList[i], val[i]);
5042
        if (pInfo->p.key == st.key) {
5043
          return TSDB_CODE_FUNC_DUP_TIMESTAMP;
5044 5045
        }

5046 5047 5048 5049 5050 5051
        pInfo->dOutput += twa_get_area(pInfo->p, st);
        pInfo->p = st;
      }
      break;
    }
    case TSDB_DATA_TYPE_USMALLINT: {
X
Xiaoyu Wang 已提交
5052
      uint16_t* val = (uint16_t*)colDataGetData(pInputCol, 0);
5053
      for (; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
5054 5055 5056
        if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
          continue;
        }
5057
        numOfElems++;
5058

5059
        INIT_INTP_POINT(st, tsList[i], val[i]);
5060
        if (pInfo->p.key == st.key) {
5061
          return TSDB_CODE_FUNC_DUP_TIMESTAMP;
5062 5063
        }

5064 5065 5066 5067 5068 5069
        pInfo->dOutput += twa_get_area(pInfo->p, st);
        pInfo->p = st;
      }
      break;
    }
    case TSDB_DATA_TYPE_UINT: {
X
Xiaoyu Wang 已提交
5070
      uint32_t* val = (uint32_t*)colDataGetData(pInputCol, 0);
5071
      for (; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
5072 5073 5074
        if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
          continue;
        }
5075
        numOfElems++;
5076

5077
        INIT_INTP_POINT(st, tsList[i], val[i]);
5078
        if (pInfo->p.key == st.key) {
5079
          return TSDB_CODE_FUNC_DUP_TIMESTAMP;
5080 5081
        }

5082 5083 5084 5085 5086 5087
        pInfo->dOutput += twa_get_area(pInfo->p, st);
        pInfo->p = st;
      }
      break;
    }
    case TSDB_DATA_TYPE_UBIGINT: {
X
Xiaoyu Wang 已提交
5088
      uint64_t* val = (uint64_t*)colDataGetData(pInputCol, 0);
5089
      for (; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
5090 5091 5092
        if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
          continue;
        }
5093
        numOfElems++;
5094

5095
        INIT_INTP_POINT(st, tsList[i], val[i]);
5096
        if (pInfo->p.key == st.key) {
5097
          return TSDB_CODE_FUNC_DUP_TIMESTAMP;
5098 5099
        }

5100 5101 5102 5103 5104 5105
        pInfo->dOutput += twa_get_area(pInfo->p, st);
        pInfo->p = st;
      }
      break;
    }

X
Xiaoyu Wang 已提交
5106
    default:
5107
      tAssert(0);
5108 5109 5110 5111
  }

  // the last interpolated time window value
  if (pCtx->end.key != INT64_MIN) {
X
Xiaoyu Wang 已提交
5112
    pInfo->dOutput += twa_get_area(pInfo->p, pCtx->end);
5113
    pInfo->p = pCtx->end;
H
Haojun Liao 已提交
5114
    numOfElems += 1;
5115 5116
  }

X
Xiaoyu Wang 已提交
5117
  pInfo->win.ekey = pInfo->p.key;
5118

5119
_twa_over:
5120 5121 5122 5123 5124
  if (numOfElems == 0) {
    pInfo->isNull = true;
  }

  SET_VAL(pResInfo, 1, 1);
5125 5126 5127 5128 5129 5130 5131 5132
  return TSDB_CODE_SUCCESS;
}

/*
 * To copy the input to interResBuf to avoid the input buffer space be over writen
 * by next input data. The TWA function only applies to each table, so no merge procedure
 * is required, we simply copy to the resut ot interResBuffer.
 */
X
Xiaoyu Wang 已提交
5133 5134 5135
// void twa_function_copy(SQLFunctionCtx *pCtx) {
//   assert(pCtx->inputType == TSDB_DATA_TYPE_BINARY);
//   SResultRowEntryInfo *pResInfo = GET_RES_INFO(pCtx);
5136
//
X
Xiaoyu Wang 已提交
5137 5138 5139
//   memcpy(GET_ROWCELL_INTERBUF(pResInfo), pCtx->pInput, (size_t)pCtx->inputBytes);
//   pResInfo->hasResult = ((STwaInfo *)pCtx->pInput)->hasResult;
// }
5140

X
Xiaoyu Wang 已提交
5141 5142
int32_t twaFinalize(struct SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
5143

X
Xiaoyu Wang 已提交
5144
  STwaInfo* pInfo = (STwaInfo*)GET_ROWCELL_INTERBUF(pResInfo);
5145 5146
  if (pInfo->isNull == true) {
    pResInfo->numOfRes = 0;
5147 5148 5149
  } else {
    if (pInfo->win.ekey == pInfo->win.skey) {
      pInfo->dOutput = pInfo->p.val;
5150
    } else if (pInfo->win.ekey == INT64_MAX || pInfo->win.skey == INT64_MIN) {  // no data in timewindow
5151
      pInfo->dOutput = 0;
5152 5153 5154 5155 5156 5157 5158 5159 5160 5161
    } else {
      pInfo->dOutput = pInfo->dOutput / (pInfo->win.ekey - pInfo->win.skey);
    }

    pResInfo->numOfRes = 1;
  }

  return functionFinalize(pCtx, pBlock);
}

5162
bool blockDistSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
5163 5164 5165 5166 5167 5168 5169 5170 5171
  if (!functionSetup(pCtx, pResultInfo)) {
    return false;
  }

  STableBlockDistInfo* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
  pInfo->minRows = INT32_MAX;
  return true;
}

X
Xiaoyu Wang 已提交
5172
int32_t blockDistFunction(SqlFunctionCtx* pCtx) {
5173 5174
  const int32_t BLOCK_DIST_RESULT_ROWS = 24;

5175
  SInputColumnInfoData* pInput = &pCtx->input;
X
Xiaoyu Wang 已提交
5176
  SColumnInfoData*      pInputCol = pInput->pData[0];
5177

X
Xiaoyu Wang 已提交
5178
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
5179

5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191
  STableBlockDistInfo* pDistInfo = GET_ROWCELL_INTERBUF(pResInfo);

  STableBlockDistInfo p1 = {0};
  tDeserializeBlockDistInfo(varDataVal(pInputCol->pData), varDataLen(pInputCol->pData), &p1);

  pDistInfo->numOfBlocks += p1.numOfBlocks;
  pDistInfo->numOfTables += p1.numOfTables;
  pDistInfo->numOfInmemRows += p1.numOfInmemRows;
  pDistInfo->totalSize += p1.totalSize;
  pDistInfo->totalRows += p1.totalRows;
  pDistInfo->numOfFiles += p1.numOfFiles;

5192 5193
  pDistInfo->defMinRows = p1.defMinRows;
  pDistInfo->defMaxRows = p1.defMaxRows;
5194
  pDistInfo->rowSize = p1.rowSize;
5195 5196
  pDistInfo->numOfSmallBlocks = p1.numOfSmallBlocks;

5197 5198 5199 5200 5201 5202 5203
  if (pDistInfo->minRows > p1.minRows) {
    pDistInfo->minRows = p1.minRows;
  }
  if (pDistInfo->maxRows < p1.maxRows) {
    pDistInfo->maxRows = p1.maxRows;
  }

X
Xiaoyu Wang 已提交
5204
  for (int32_t i = 0; i < tListLen(pDistInfo->blockRowsHisto); ++i) {
5205 5206 5207
    pDistInfo->blockRowsHisto[i] += p1.blockRowsHisto[i];
  }

5208
  pResInfo->numOfRes = BLOCK_DIST_RESULT_ROWS;  // default output rows
5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219
  return TSDB_CODE_SUCCESS;
}

int32_t tSerializeBlockDistInfo(void* buf, int32_t bufLen, const STableBlockDistInfo* pInfo) {
  SEncoder encoder = {0};
  tEncoderInit(&encoder, buf, bufLen);

  if (tStartEncode(&encoder) < 0) return -1;
  if (tEncodeU32(&encoder, pInfo->rowSize) < 0) return -1;

  if (tEncodeU16(&encoder, pInfo->numOfFiles) < 0) return -1;
5220
  if (tEncodeU32(&encoder, pInfo->numOfBlocks) < 0) return -1;
5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231
  if (tEncodeU32(&encoder, pInfo->numOfTables) < 0) return -1;

  if (tEncodeU64(&encoder, pInfo->totalSize) < 0) return -1;
  if (tEncodeU64(&encoder, pInfo->totalRows) < 0) return -1;
  if (tEncodeI32(&encoder, pInfo->maxRows) < 0) return -1;
  if (tEncodeI32(&encoder, pInfo->minRows) < 0) return -1;
  if (tEncodeI32(&encoder, pInfo->defMaxRows) < 0) return -1;
  if (tEncodeI32(&encoder, pInfo->defMinRows) < 0) return -1;
  if (tEncodeU32(&encoder, pInfo->numOfInmemRows) < 0) return -1;
  if (tEncodeU32(&encoder, pInfo->numOfSmallBlocks) < 0) return -1;

X
Xiaoyu Wang 已提交
5232
  for (int32_t i = 0; i < tListLen(pInfo->blockRowsHisto); ++i) {
5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250
    if (tEncodeI32(&encoder, pInfo->blockRowsHisto[i]) < 0) return -1;
  }

  tEndEncode(&encoder);

  int32_t tlen = encoder.pos;
  tEncoderClear(&encoder);
  return tlen;
}

int32_t tDeserializeBlockDistInfo(void* buf, int32_t bufLen, STableBlockDistInfo* pInfo) {
  SDecoder decoder = {0};
  tDecoderInit(&decoder, buf, bufLen);

  if (tStartDecode(&decoder) < 0) return -1;
  if (tDecodeU32(&decoder, &pInfo->rowSize) < 0) return -1;

  if (tDecodeU16(&decoder, &pInfo->numOfFiles) < 0) return -1;
5251
  if (tDecodeU32(&decoder, &pInfo->numOfBlocks) < 0) return -1;
5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262
  if (tDecodeU32(&decoder, &pInfo->numOfTables) < 0) return -1;

  if (tDecodeU64(&decoder, &pInfo->totalSize) < 0) return -1;
  if (tDecodeU64(&decoder, &pInfo->totalRows) < 0) return -1;
  if (tDecodeI32(&decoder, &pInfo->maxRows) < 0) return -1;
  if (tDecodeI32(&decoder, &pInfo->minRows) < 0) return -1;
  if (tDecodeI32(&decoder, &pInfo->defMaxRows) < 0) return -1;
  if (tDecodeI32(&decoder, &pInfo->defMinRows) < 0) return -1;
  if (tDecodeU32(&decoder, &pInfo->numOfInmemRows) < 0) return -1;
  if (tDecodeU32(&decoder, &pInfo->numOfSmallBlocks) < 0) return -1;

X
Xiaoyu Wang 已提交
5263
  for (int32_t i = 0; i < tListLen(pInfo->blockRowsHisto); ++i) {
5264 5265 5266 5267 5268 5269 5270 5271
    if (tDecodeI32(&decoder, &pInfo->blockRowsHisto[i]) < 0) return -1;
  }

  tDecoderClear(&decoder);
  return 0;
}

int32_t blockDistFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
X
Xiaoyu Wang 已提交
5272
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
5273
  STableBlockDistInfo* pData = GET_ROWCELL_INTERBUF(pResInfo);
5274

5275 5276
  SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, 0);

H
Haojun Liao 已提交
5277 5278 5279 5280
  if (pData->totalRows == 0) {
    pData->minRows = 0;
  }

5281
  int32_t row = 0;
X
Xiaoyu Wang 已提交
5282
  char    st[256] = {0};
5283 5284 5285 5286 5287 5288 5289 5290 5291 5292
  double  averageSize = 0;
  if (pData->numOfBlocks != 0) {
    averageSize = ((double)pData->totalSize) / pData->numOfBlocks;
  }
  uint64_t totalRawSize = pData->totalRows * pData->rowSize;
  double   compRatio = 0;
  if (totalRawSize != 0) {
    compRatio = pData->totalSize * 100 / (double)totalRawSize;
  }

5293 5294
  int32_t len = sprintf(st + VARSTR_HEADER_SIZE,
                        "Total_Blocks=[%d] Total_Size=[%.2f Kb] Average_size=[%.2f Kb] Compression_Ratio=[%.2f %c]",
5295
                        pData->numOfBlocks, pData->totalSize / 1024.0, averageSize, compRatio, '%');
5296 5297 5298

  varDataSetLen(st, len);
  colDataAppend(pColInfo, row++, st, false);
5299

H
Haojun Liao 已提交
5300 5301 5302 5303 5304
  int64_t avgRows = 0;
  if (pData->numOfBlocks > 0) {
    avgRows = pData->totalRows / pData->numOfBlocks;
  }

5305 5306
  len = sprintf(st + VARSTR_HEADER_SIZE,
                "Total_Rows=[%" PRId64 "] Inmem_Rows=[%d] MinRows=[%d] MaxRows=[%d] Average_Rows=[%" PRId64 "]",
H
Haojun Liao 已提交
5307
                pData->totalRows, pData->numOfInmemRows, pData->minRows, pData->maxRows, avgRows);
5308

5309 5310
  varDataSetLen(st, len);
  colDataAppend(pColInfo, row++, st, false);
5311

5312 5313
  len = sprintf(st + VARSTR_HEADER_SIZE, "Total_Tables=[%d] Total_Files=[%d] Total_Vgroups=[%d]", pData->numOfTables,
                pData->numOfFiles, 0);
5314 5315 5316 5317

  varDataSetLen(st, len);
  colDataAppend(pColInfo, row++, st, false);

X
Xiaoyu Wang 已提交
5318 5319
  len = sprintf(st + VARSTR_HEADER_SIZE,
                "--------------------------------------------------------------------------------");
5320 5321
  varDataSetLen(st, len);
  colDataAppend(pColInfo, row++, st, false);
5322 5323 5324

  int32_t maxVal = 0;
  int32_t minVal = INT32_MAX;
5325 5326 5327
  for (int32_t i = 0; i < tListLen(pData->blockRowsHisto); ++i) {
    if (maxVal < pData->blockRowsHisto[i]) {
      maxVal = pData->blockRowsHisto[i];
5328 5329
    }

5330 5331
    if (minVal > pData->blockRowsHisto[i]) {
      minVal = pData->blockRowsHisto[i];
5332 5333 5334
    }
  }

5335 5336
  // maximum number of step is 80
  double factor = pData->numOfBlocks / 80.0;
5337 5338

  int32_t numOfBuckets = sizeof(pData->blockRowsHisto) / sizeof(pData->blockRowsHisto[0]);
5339
  int32_t bucketRange = (pData->defMaxRows - pData->defMinRows) / numOfBuckets;
5340

5341
  for (int32_t i = 0; i < tListLen(pData->blockRowsHisto); ++i) {
5342
    len = sprintf(st + VARSTR_HEADER_SIZE, "%04d |", pData->defMinRows + bucketRange * i);
5343

5344
    int32_t num = 0;
5345 5346
    if (pData->blockRowsHisto[i] > 0) {
      num = (pData->blockRowsHisto[i]) / factor;
5347
    }
5348 5349 5350

    for (int32_t j = 0; j < num; ++j) {
      int32_t x = sprintf(st + VARSTR_HEADER_SIZE + len, "%c", '|');
5351 5352 5353
      len += x;
    }

5354 5355 5356 5357
    if (num > 0) {
      double v = pData->blockRowsHisto[i] * 100.0 / pData->numOfBlocks;
      len += sprintf(st + VARSTR_HEADER_SIZE + len, "  %d (%.2f%c)", pData->blockRowsHisto[i], v, '%');
    }
5358 5359 5360

    varDataSetLen(st, len);
    colDataAppend(pColInfo, row++, st, false);
5361 5362
  }

5363
  return TSDB_CODE_SUCCESS;
5364
}
5365 5366 5367 5368 5369 5370

bool getDerivativeFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(SDerivInfo);
  return true;
}

5371
bool derivativeFuncSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
5372 5373 5374 5375 5376 5377 5378
  if (!functionSetup(pCtx, pResInfo)) {
    return false;  // not initialized since it has been initialized
  }

  SDerivInfo* pDerivInfo = GET_ROWCELL_INTERBUF(pResInfo);

  pDerivInfo->ignoreNegative = pCtx->param[2].param.i;
5379
  pDerivInfo->prevTs = -1;
5380 5381 5382 5383 5384
  pDerivInfo->tsWindow = pCtx->param[1].param.i;
  pDerivInfo->valueSet = false;
  return true;
}

5385 5386 5387
int32_t derivativeFunction(SqlFunctionCtx* pCtx) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  SDerivInfo*          pDerivInfo = GET_ROWCELL_INTERBUF(pResInfo);
5388 5389

  SInputColumnInfoData* pInput = &pCtx->input;
5390
  SColumnInfoData*      pInputCol = pInput->pData[0];
H
Haojun Liao 已提交
5391

5392
  int32_t          numOfElems = 0;
5393 5394 5395 5396
  SColumnInfoData* pOutput = (SColumnInfoData*)pCtx->pOutput;
  SColumnInfoData* pTsOutput = pCtx->pTsOutput;

  int32_t i = pInput->startRowIndex;
5397
  TSKEY*  tsList = (int64_t*)pInput->pPTS->pData;
5398

5399
  double v = 0;
5400

5401 5402
  if (pCtx->order == TSDB_ORDER_ASC) {
    for (; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
5403 5404 5405 5406
      if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
        continue;
      }

5407
      char* d = (char*)pInputCol->pData + pInputCol->info.bytes * i;
5408 5409 5410 5411 5412 5413
      GET_TYPED_DATA(v, double, pInputCol->info.type, d);

      int32_t pos = pCtx->offset + numOfElems;
      if (!pDerivInfo->valueSet) {  // initial value is not set yet
        pDerivInfo->valueSet = true;
      } else {
5414 5415 5416
        if (tsList[i] == pDerivInfo->prevTs) {
          return TSDB_CODE_FUNC_DUP_TIMESTAMP;
        }
5417 5418 5419
        double r = ((v - pDerivInfo->prevValue) * pDerivInfo->tsWindow) / (tsList[i] - pDerivInfo->prevTs);
        if (pDerivInfo->ignoreNegative && r < 0) {
        } else {
5420 5421 5422 5423 5424 5425
          if (isinf(r) || isnan(r)) {
            colDataAppendNULL(pOutput, pos);
          } else {
            colDataAppend(pOutput, pos, (const char*)&r, false);
          }

5426 5427 5428
          if (pTsOutput != NULL) {
            colDataAppendInt64(pTsOutput, pos, &tsList[i]);
          }
5429 5430 5431 5432 5433 5434

          // handle selectivity
          if (pCtx->subsidiaries.num > 0) {
            appendSelectivityValue(pCtx, i, pos);
          }

5435 5436 5437 5438 5439 5440 5441 5442
          numOfElems++;
        }
      }

      pDerivInfo->prevValue = v;
      pDerivInfo->prevTs = tsList[i];
    }
  } else {
5443 5444 5445 5446 5447
    for (; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
      if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
        continue;
      }

5448
      char* d = (char*)pInputCol->pData + pInputCol->info.bytes * i;
5449 5450 5451 5452 5453 5454
      GET_TYPED_DATA(v, double, pInputCol->info.type, d);

      int32_t pos = pCtx->offset + numOfElems;
      if (!pDerivInfo->valueSet) {  // initial value is not set yet
        pDerivInfo->valueSet = true;
      } else {
5455 5456 5457
        if (tsList[i] == pDerivInfo->prevTs) {
          return TSDB_CODE_FUNC_DUP_TIMESTAMP;
        }
5458 5459 5460
        double r = ((pDerivInfo->prevValue - v) * pDerivInfo->tsWindow) / (pDerivInfo->prevTs - tsList[i]);
        if (pDerivInfo->ignoreNegative && r < 0) {
        } else {
5461 5462 5463 5464 5465 5466
          if (isinf(r) || isnan(r)) {
            colDataAppendNULL(pOutput, pos);
          } else {
            colDataAppend(pOutput, pos, (const char*)&r, false);
          }

5467 5468 5469
          if (pTsOutput != NULL) {
            colDataAppendInt64(pTsOutput, pos, &pDerivInfo->prevTs);
          }
5470 5471 5472 5473 5474 5475

          // handle selectivity
          if (pCtx->subsidiaries.num > 0) {
            appendSelectivityValue(pCtx, i, pos);
          }

5476 5477 5478
          numOfElems++;
        }
      }
5479

5480 5481 5482
      pDerivInfo->prevValue = v;
      pDerivInfo->prevTs = tsList[i];
    }
5483 5484
  }

5485 5486 5487
  pResInfo->numOfRes = numOfElems;

  return TSDB_CODE_SUCCESS;
H
Haojun Liao 已提交
5488 5489
}

G
Ganlin Zhao 已提交
5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501
bool getIrateFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(SRateInfo);
  return true;
}

bool irateFuncSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
  if (!functionSetup(pCtx, pResInfo)) {
    return false;  // not initialized since it has been initialized
  }

  SRateInfo* pInfo = GET_ROWCELL_INTERBUF(pResInfo);

5502 5503
  pInfo->firstKey = INT64_MIN;
  pInfo->lastKey = INT64_MIN;
G
Ganlin Zhao 已提交
5504
  pInfo->firstValue = (double)INT64_MIN;
5505
  pInfo->lastValue = (double)INT64_MIN;
G
Ganlin Zhao 已提交
5506

5507
  pInfo->hasResult = 0;
G
Ganlin Zhao 已提交
5508 5509 5510 5511 5512
  return true;
}

int32_t irateFunction(SqlFunctionCtx* pCtx) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
5513
  SRateInfo*           pRateInfo = GET_ROWCELL_INTERBUF(pResInfo);
G
Ganlin Zhao 已提交
5514 5515 5516 5517 5518 5519

  SInputColumnInfoData* pInput = &pCtx->input;
  SColumnInfoData*      pInputCol = pInput->pData[0];

  SColumnInfoData* pOutput = (SColumnInfoData*)pCtx->pOutput;

5520
  TSKEY* tsList = (int64_t*)pInput->pPTS->pData;
G
Ganlin Zhao 已提交
5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531

  int32_t numOfElems = 0;
  int32_t type = pInputCol->info.type;

  for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
    if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
      continue;
    }

    numOfElems++;

5532 5533
    char*  data = colDataGetData(pInputCol, i);
    double v = 0;
G
Ganlin Zhao 已提交
5534 5535 5536 5537
    GET_TYPED_DATA(v, double, type, data);

    if (INT64_MIN == pRateInfo->lastKey) {
      pRateInfo->lastValue = v;
5538
      pRateInfo->lastKey = tsList[i];
G
Ganlin Zhao 已提交
5539 5540 5541 5542 5543 5544 5545 5546 5547 5548
      continue;
    }

    if (tsList[i] > pRateInfo->lastKey) {
      if ((INT64_MIN == pRateInfo->firstKey) || pRateInfo->lastKey > pRateInfo->firstKey) {
        pRateInfo->firstValue = pRateInfo->lastValue;
        pRateInfo->firstKey = pRateInfo->lastKey;
      }

      pRateInfo->lastValue = v;
5549
      pRateInfo->lastKey = tsList[i];
G
Ganlin Zhao 已提交
5550 5551

      continue;
5552 5553
    } else if (tsList[i] == pRateInfo->lastKey) {
      return TSDB_CODE_FUNC_DUP_TIMESTAMP;
G
Ganlin Zhao 已提交
5554 5555 5556 5557 5558
    }

    if ((INT64_MIN == pRateInfo->firstKey) || tsList[i] > pRateInfo->firstKey) {
      pRateInfo->firstValue = v;
      pRateInfo->firstKey = tsList[i];
5559 5560
    } else if (tsList[i] == pRateInfo->firstKey) {
      return TSDB_CODE_FUNC_DUP_TIMESTAMP;
G
Ganlin Zhao 已提交
5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586
    }
  }

  SET_VAL(pResInfo, numOfElems, 1);
  return TSDB_CODE_SUCCESS;
}

static double doCalcRate(const SRateInfo* pRateInfo, double tickPerSec) {
  if ((INT64_MIN == pRateInfo->lastKey) || (INT64_MIN == pRateInfo->firstKey) ||
      (pRateInfo->firstKey >= pRateInfo->lastKey)) {
    return 0.0;
  }

  double diff = 0;
  // If the previous value of the last is greater than the last value, only keep the last point instead of the delta
  // value between two values.
  diff = pRateInfo->lastValue;
  if (diff >= pRateInfo->firstValue) {
    diff -= pRateInfo->firstValue;
  }

  int64_t duration = pRateInfo->lastKey - pRateInfo->firstKey;
  if (duration == 0) {
    return 0;
  }

5587
  return (duration > 0) ? ((double)diff) / (duration / tickPerSec) : 0.0;
G
Ganlin Zhao 已提交
5588 5589 5590 5591 5592 5593 5594 5595 5596 5597
}

int32_t irateFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);

  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  pResInfo->isNullRes = (pResInfo->numOfRes == 0) ? 1 : 0;

  SRateInfo* pInfo = GET_ROWCELL_INTERBUF(pResInfo);
5598
  double     result = doCalcRate(pInfo, (double)TSDB_TICK_PER_SECOND(pCtx->param[1].param.i));
G
Ganlin Zhao 已提交
5599 5600 5601 5602 5603
  colDataAppend(pCol, pBlock->info.rows, (const char*)&result, pResInfo->isNullRes);

  return pResInfo->numOfRes;
}

5604 5605
int32_t groupKeyFunction(SqlFunctionCtx* pCtx) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
5606
  SGroupKeyInfo*       pInfo = GET_ROWCELL_INTERBUF(pResInfo);
5607 5608

  SInputColumnInfoData* pInput = &pCtx->input;
5609
  SColumnInfoData*      pInputCol = pInput->pData[0];
5610 5611

  int32_t startIndex = pInput->startRowIndex;
5612

5613
  // escape rest of data blocks to avoid first entry to be overwritten.
5614 5615 5616 5617
  if (pInfo->hasResult) {
    goto _group_key_over;
  }

5618
  if (colDataIsNull_s(pInputCol, startIndex)) {
5619 5620
    pInfo->isNull = true;
    pInfo->hasResult = true;
G
Ganlin Zhao 已提交
5621
    goto _group_key_over;
5622 5623 5624
  }

  char* data = colDataGetData(pInputCol, startIndex);
5625
  if (IS_VAR_DATA_TYPE(pInputCol->info.type)) {
X
Xiaoyu Wang 已提交
5626 5627
    memcpy(pInfo->data, data,
           (pInputCol->info.type == TSDB_DATA_TYPE_JSON) ? getJsonValueLen(data) : varDataTLen(data));
5628 5629 5630
  } else {
    memcpy(pInfo->data, data, pInputCol->info.bytes);
  }
5631
  pInfo->hasResult = true;
G
Ganlin Zhao 已提交
5632 5633

_group_key_over:
5634

G
Ganlin Zhao 已提交
5635
  SET_VAL(pResInfo, 1, 1);
5636 5637 5638
  return TSDB_CODE_SUCCESS;
}

G
Ganlin Zhao 已提交
5639 5640 5641 5642 5643 5644 5645
int32_t groupKeyFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);

  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);

  SGroupKeyInfo* pInfo = GET_ROWCELL_INTERBUF(pResInfo);
5646 5647

  if (pInfo->hasResult) {
5648 5649 5650 5651
    int32_t currentRow = pBlock->info.rows;
    for (; currentRow < pBlock->info.rows + pResInfo->numOfRes; ++currentRow) {
      colDataAppend(pCol, currentRow, pInfo->data, pInfo->isNull ? true : false);
    }
5652 5653 5654
  } else {
    pResInfo->numOfRes = 0;
  }
G
Ganlin Zhao 已提交
5655 5656 5657 5658

  return pResInfo->numOfRes;
}

5659
int32_t cachedLastRowFunction(SqlFunctionCtx* pCtx) {
5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670
  int32_t numOfElems = 0;

  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  SFirstLastRes*       pInfo = GET_ROWCELL_INTERBUF(pResInfo);

  SInputColumnInfoData* pInput = &pCtx->input;
  SColumnInfoData*      pInputCol = pInput->pData[0];

  int32_t bytes = pInputCol->info.bytes;
  pInfo->bytes = bytes;

5671
  // last_row function does not ignore the null value
5672 5673 5674
  for (int32_t i = pInput->numOfRows + pInput->startRowIndex - 1; i >= pInput->startRowIndex; --i) {
    numOfElems++;

H
Haojun Liao 已提交
5675 5676 5677
    bool  isNull = colDataIsNull(pInputCol, pInput->numOfRows, i, NULL);
    char* data = isNull ? NULL : colDataGetData(pInputCol, i);

5678
    TSKEY cts = getRowPTs(pInput->pPTS, i);
5679
    if (pResInfo->numOfRes == 0 || pInfo->ts < cts) {
5680
      doSaveLastrow(pCtx, data, i, cts, pInfo);
5681
      pResInfo->numOfRes = 1;
5682 5683 5684 5685 5686 5687
    }
  }

  SET_VAL(pResInfo, numOfElems, 1);
  return TSDB_CODE_SUCCESS;
}