builtinsimpl.c 179.0 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

L
Liu Jicong 已提交
44 45 46 47
// typedef struct SMinmaxResInfo {
//   bool      assign;  // assign the first value or not
//   int64_t   v;
//   STuplePos tuplePos;
H
Haojun Liao 已提交
48
//
L
Liu Jicong 已提交
49 50 51 52
//   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
    ASSERT(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
    numOfElem = 1;
543
    *((int64_t*)buf) += 0;
544
  } 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
    ASSERT(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
    ASSERT(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) {
G
Ganlin Zhao 已提交
787
    float v = GET_FLOAT_VAL(&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;
  }

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

L
Liu Jicong 已提交
826 827
    bool* nullList = (bool*)p;
    char* pStart = (char*)(nullList + numOfCols * sizeof(bool));
828

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

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

    if (pCtx->saveHandle.pState) {
      tdbFree((void*)p);
846 847 848 849
    }
  }
}

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

857 858
// This function append the selectivity to subsidiaries function context directly, without fetching data
// from intermediate disk based buf page
859
void appendSelectivityValue(SqlFunctionCtx* pCtx, int32_t rowIndex, int32_t pos) {
860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875
  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 已提交
876
    int32_t dstSlotId = pc->pExpr->base.resSchema.slotId;
877 878

    SColumnInfoData* pDstCol = taosArrayGet(pCtx->pDstBlock->pDataBlock, dstSlotId);
879
    ASSERT(pc->pExpr->base.resSchema.bytes == pDstCol->info.bytes);
880 881

    if (colDataIsNull_s(pSrcCol, rowIndex) == true) {
882
      colDataAppendNULL(pDstCol, pos);
883
    } else {
884
      colDataAppend(pDstCol, pos, pData, false);
885 886 887 888
    }
  }
}

889 890 891 892 893
void replaceTupleData(STuplePos* pDestPos, STuplePos* pSourcePos) {
  releaseSource(pDestPos);
  *pDestPos = *pSourcePos;
}

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

926 927
int32_t getStddevInfoSize() { return (int32_t)sizeof(SStddevRes); }

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

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

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

H
Haojun Liao 已提交
943
int32_t stddevFunction(SqlFunctionCtx* pCtx) {
H
Haojun Liao 已提交
944 945 946 947
  int32_t numOfElem = 0;

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

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

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

H
Haojun Liao 已提交
956 957
  int32_t start = pInput->startRowIndex;
  int32_t numOfRows = pInput->numOfRows;
H
Haojun Liao 已提交
958

959
  if (IS_NULL_TYPE(type)) {
H
Haojun Liao 已提交
960
    numOfElem = 0;
961 962 963
    goto _stddev_over;
  }

H
Haojun Liao 已提交
964 965
  switch (type) {
    case TSDB_DATA_TYPE_TINYINT: {
966 967 968 969
      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 已提交
970
        }
H
Haojun Liao 已提交
971

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

978 979 980 981
      break;
    }

    case TSDB_DATA_TYPE_SMALLINT: {
H
Haojun Liao 已提交
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 1024 1025 1026
      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;
    }

1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
    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 已提交
1037
        pStddevRes->quadraticUSum += plist[i] * plist[i];
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
      }

      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 已提交
1053
        pStddevRes->quadraticUSum += plist[i] * plist[i];
1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067
      }
      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 已提交
1068
        pStddevRes->quadraticUSum += plist[i] * plist[i];
1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083
      }

      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 已提交
1084
        pStddevRes->quadraticUSum += plist[i] * plist[i];
1085 1086 1087 1088
      }
      break;
    }

H
Haojun Liao 已提交
1089 1090 1091 1092 1093 1094 1095 1096 1097
    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 已提交
1098 1099
        pStddevRes->dsum += plist[i];
        pStddevRes->quadraticDSum += plist[i] * plist[i];
H
Haojun Liao 已提交
1100 1101 1102 1103
      }
      break;
    }

H
Haojun Liao 已提交
1104 1105 1106 1107 1108 1109 1110 1111 1112
    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 已提交
1113 1114
        pStddevRes->dsum += plist[i];
        pStddevRes->quadraticDSum += plist[i] * plist[i];
H
Haojun Liao 已提交
1115 1116 1117 1118 1119 1120 1121 1122
      }
      break;
    }

    default:
      break;
  }

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

G
Ganlin Zhao 已提交
1129 1130
static void stddevTransferInfo(SStddevRes* pInput, SStddevRes* pOutput) {
  pOutput->type = pInput->type;
1131
  if (IS_SIGNED_NUMERIC_TYPE(pOutput->type)) {
G
Ganlin Zhao 已提交
1132 1133
    pOutput->quadraticISum += pInput->quadraticISum;
    pOutput->isum += pInput->isum;
1134 1135 1136
  } else if (IS_UNSIGNED_NUMERIC_TYPE(pOutput->type)) {
    pOutput->quadraticUSum += pInput->quadraticUSum;
    pOutput->usum += pInput->usum;
G
Ganlin Zhao 已提交
1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147
  } 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];
1148
  ASSERT(pCol->info.type == TSDB_DATA_TYPE_BINARY);
G
Ganlin Zhao 已提交
1149 1150 1151

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

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

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

5
54liuyao 已提交
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 1191 1192 1193
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;
    }
1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209
    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 已提交
1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226
    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 已提交
1227
int32_t stddevFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
G
Ganlin Zhao 已提交
1228
  SInputColumnInfoData* pInput = &pCtx->input;
1229
  SStddevRes*           pStddevRes = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
G
Ganlin Zhao 已提交
1230
  int32_t               type = pStddevRes->type;
1231
  double                avg;
G
Ganlin Zhao 已提交
1232

1233 1234 1235 1236 1237
  if (pStddevRes->count == 0) {
    GET_RES_INFO(pCtx)->numOfRes = 0;
    return functionFinalize(pCtx, pBlock);
  }

1238
  if (IS_SIGNED_NUMERIC_TYPE(type)) {
1239
    avg = pStddevRes->isum / ((double)pStddevRes->count);
1240
    pStddevRes->result = sqrt(fabs(pStddevRes->quadraticISum / ((double)pStddevRes->count) - avg * avg));
1241 1242 1243
  } 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 已提交
1244
  } else {
1245
    avg = pStddevRes->dsum / ((double)pStddevRes->count);
1246
    pStddevRes->result = sqrt(fabs(pStddevRes->quadraticDSum / ((double)pStddevRes->count) - avg * avg));
G
Ganlin Zhao 已提交
1247
  }
1248

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

1254
  return functionFinalize(pCtx, pBlock);
H
Haojun Liao 已提交
1255 1256
}

G
Ganlin Zhao 已提交
1257 1258
int32_t stddevPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
1259 1260 1261
  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 已提交
1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274

  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 已提交
1275 1276
int32_t stddevCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);
X
Xiaoyu Wang 已提交
1277
  SStddevRes*          pDBuf = GET_ROWCELL_INTERBUF(pDResInfo);
5
54liuyao 已提交
1278 1279

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

5
54liuyao 已提交
1283 1284
  stddevTransferInfo(pSBuf, pDBuf);

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

1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301
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);

1302 1303
  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);
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 1330 1331 1332
  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);
      }
1333
      break;
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 1371 1372 1373
    }
    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;
    }

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 1421 1422 1423
    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;
    }

1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448
    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;
    }
1449 1450 1451 1452 1453
    case TSDB_DATA_TYPE_NULL: {
      GET_RES_INFO(pCtx)->isNullRes = 1;
      numOfElem = 1;
      break;
    }
1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468

    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 已提交
1469 1470 1471
  SLeastSQRInfo*       pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
  int32_t              slotId = pCtx->pExpr->base.resSchema.slotId;
  SColumnInfoData*     pCol = taosArrayGet(pBlock->pDataBlock, slotId);
1472 1473 1474

  int32_t currentRow = pBlock->info.rows;

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

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

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

5
54liuyao 已提交
1485 1486
  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]);
1487 1488 1489 1490 1491 1492

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

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

5
54liuyao 已提交
1498
  param12 /= param[1][1];
1499

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

1505
  colDataAppend(pCol, currentRow, buf, pResInfo->isNullRes);
1506 1507 1508 1509 1510

  return pResInfo->numOfRes;
}

int32_t leastSQRInvertFunction(SqlFunctionCtx* pCtx) {
X
Xiaoyu Wang 已提交
1511
  // TODO
1512 1513 1514
  return TSDB_CODE_SUCCESS;
}

5
54liuyao 已提交
1515 1516 1517 1518
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 已提交
1519
  double(*pDparam)[3] = pDBuf->matrix;
5
54liuyao 已提交
1520 1521 1522

  SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
  SLeastSQRInfo*       pSBuf = GET_ROWCELL_INTERBUF(pSResInfo);
X
Xiaoyu Wang 已提交
1523
  double(*pSparam)[3] = pSBuf->matrix;
5
54liuyao 已提交
1524 1525 1526 1527 1528 1529 1530 1531 1532
  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 已提交
1533
  pDResInfo->isNullRes &= pSResInfo->isNullRes;
5
54liuyao 已提交
1534 1535 1536
  return TSDB_CODE_SUCCESS;
}

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

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

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

  return true;
H
Haojun Liao 已提交
1554 1555
}

1556
int32_t percentileFunction(SqlFunctionCtx* pCtx) {
1557
  int32_t              numOfElems = 0;
1558
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
1559 1560

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

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

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

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

  // the first stage, only acquire the min/max value
  if (pInfo->stage == 0) {
H
Haojun Liao 已提交
1581
    if (pCtx->input.colDataSMAIsSet) {
H
Haojun Liao 已提交
1582
      double tmin = 0.0, tmax = 0.0;
1583 1584 1585 1586 1587 1588 1589 1590 1591
      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 已提交
1592 1593 1594 1595 1596 1597 1598 1599 1600 1601
      }

      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);
      }

1602
      pInfo->numOfElems += (pInput->numOfRows - pAgg->numOfNull);
H
Haojun Liao 已提交
1603
    } else {
1604 1605 1606 1607
      // 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 已提交
1608 1609 1610
          continue;
        }

1611
        char* data = colDataGetData(pCol, i);
1612

H
Haojun Liao 已提交
1613
        double v = 0;
1614
        GET_TYPED_DATA(v, double, type, data);
H
Haojun Liao 已提交
1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625
        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;
      }
    }
1626 1627 1628 1629 1630 1631 1632
  } 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 已提交
1633

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

1639
    SET_VAL(pResInfo, numOfElems, 1);
H
Haojun Liao 已提交
1640 1641
  }

wmmhello's avatar
wmmhello 已提交
1642
  return TSDB_CODE_SUCCESS;
1643 1644
}

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

1650 1651
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  SPercentileInfo*     ppInfo = (SPercentileInfo*)GET_ROWCELL_INTERBUF(pResInfo);
1652

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

  tMemBucketDestroy(pMemBucket);
1659
  return functionFinalize(pCtx, pBlock);
H
Haojun Liao 已提交
1660
}
H
Haojun Liao 已提交
1661

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

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

X
Xiaoyu Wang 已提交
1677
static int8_t getApercentileAlgo(char* algoStr) {
1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690
  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 已提交
1691 1692
  pInfo->pHisto = (SHistogramInfo*)((char*)pInfo + sizeof(SAPercentileInfo));
  pInfo->pHisto->elems = (SHistBin*)((char*)pInfo->pHisto + sizeof(SHistogramInfo));
1693 1694
}

1695 1696 1697 1698
static void buildTDigestInfo(SAPercentileInfo* pInfo) {
  pInfo->pTDigest = (TDigest*)((char*)pInfo + sizeof(SAPercentileInfo));
}

1699 1700 1701 1702 1703 1704
bool apercentileFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
  if (!functionSetup(pCtx, pResultInfo)) {
    return false;
  }

  SAPercentileInfo* pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
1705 1706

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

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

X
Xiaoyu Wang 已提交
1719
  char* tmp = (char*)pInfo + sizeof(SAPercentileInfo);
1720 1721 1722 1723 1724
  if (pInfo->algo == APERCT_ALGO_TDIGEST) {
    pInfo->pTDigest = tdigestNewFrom(tmp, COMPRESSION);
  } else {
    buildHistogramInfo(pInfo);
    pInfo->pHisto = tHistogramCreateFrom(tmp, MAX_HISTOGRAM_BIN);
G
Ganlin Zhao 已提交
1725 1726
    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);
1727 1728 1729 1730 1731 1732
  }

  return true;
}

int32_t apercentileFunction(SqlFunctionCtx* pCtx) {
1733 1734
  int32_t               numOfElems = 0;
  SResultRowEntryInfo*  pResInfo = GET_RES_INFO(pCtx);
1735 1736 1737 1738 1739 1740 1741 1742 1743
  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 已提交
1744 1745
    buildTDigestInfo(pInfo);
    tdigestAutoFill(pInfo->pTDigest, COMPRESSION);
1746 1747 1748 1749
    for (int32_t i = start; i < pInput->numOfRows + start; ++i) {
      if (colDataIsNull_f(pCol->nullbitmap, i)) {
        continue;
      }
1750
      numOfElems += 1;
1751 1752
      char* data = colDataGetData(pCol, i);

X
Xiaoyu Wang 已提交
1753 1754
      double  v = 0;  // value
      int64_t w = 1;  // weigth
1755 1756 1757 1758
      GET_TYPED_DATA(v, double, type, data);
      tdigestAdd(pInfo->pTDigest, v, w);
    }
  } else {
1759 1760 1761
    // 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 已提交
1762 1763 1764
    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);
1765 1766 1767 1768
    for (int32_t i = start; i < pInput->numOfRows + start; ++i) {
      if (colDataIsNull_f(pCol->nullbitmap, i)) {
        continue;
      }
1769
      numOfElems += 1;
1770 1771 1772 1773 1774 1775
      char* data = colDataGetData(pCol, i);

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

1777 1778 1779
    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);
1780 1781
  }

1782
  SET_VAL(pResInfo, numOfElems, 1);
1783 1784 1785
  return TSDB_CODE_SUCCESS;
}

1786 1787 1788 1789 1790 1791
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);
1792

X
Xiaoyu Wang 已提交
1793
    if (pInput->pTDigest->num_centroids == 0 && pInput->pTDigest->num_buffered_pts == 0) {
1794
      return;
1795 1796
    }

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

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

1813
    buildHistogramInfo(pOutput);
X
Xiaoyu Wang 已提交
1814
    SHistogramInfo* pHisto = pOutput->pHisto;
1815 1816

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

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

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

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

1838 1839 1840 1841 1842 1843
int32_t apercentileFunctionMerge(SqlFunctionCtx* pCtx) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);

  SInputColumnInfoData* pInput = &pCtx->input;

  SColumnInfoData* pCol = pInput->pData[0];
1844
  ASSERT(pCol->info.type == TSDB_DATA_TYPE_BINARY);
1845 1846 1847

  SAPercentileInfo* pInfo = GET_ROWCELL_INTERBUF(pResInfo);

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

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

1854 1855 1856
    SAPercentileInfo* pInputInfo = (SAPercentileInfo*)varDataVal(data);
    apercentileTransferInfo(pInputInfo, pInfo);
  }
1857

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

1863
  SET_VAL(pResInfo, 1, 1);
1864 1865 1866
  return TSDB_CODE_SUCCESS;
}

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

  if (pInfo->algo == APERCT_ALGO_TDIGEST) {
1872
    buildTDigestInfo(pInfo);
5
54liuyao 已提交
1873
    tdigestAutoFill(pInfo->pTDigest, COMPRESSION);
1874
    if (pInfo->pTDigest->size > 0) {
1875
      pInfo->result = tdigestQuantile(pInfo->pTDigest, pInfo->percent / 100);
1876
    } else {  // no need to free
X
Xiaoyu Wang 已提交
1877
      // setNull(pCtx->pOutput, pCtx->outputType, pCtx->outputBytes);
1878 1879 1880
      return TSDB_CODE_SUCCESS;
    }
  } else {
1881
    buildHistogramInfo(pInfo);
1882
    if (pInfo->pHisto->numOfElems > 0) {
G
Ganlin Zhao 已提交
1883 1884
      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);
1885

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

  return functionFinalize(pCtx, pBlock);
}

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

1906
  int32_t resultBytes = getApercentileMaxSize();
X
Xiaoyu Wang 已提交
1907
  char*   res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
1908 1909

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

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

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

1922
  taosMemoryFree(res);
1923 1924 1925
  return pResInfo->numOfRes;
}

1926 1927 1928 1929 1930 1931
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);
1932

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

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

1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956
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;
  }
}

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

  // 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;
  }
}

1973
int32_t getFirstLastInfoSize(int32_t resBytes) { return sizeof(SFirstLastRes) + resBytes; }
1974

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

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

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

1993 1994 1995 1996 1997
static FORCE_INLINE TSKEY getRowPTs(SColumnInfoData* pTsColInfo, int32_t rowIndex) {
  if (pTsColInfo == NULL) {
    return 0;
  }

1998
  return *(TSKEY*)colDataGetData(pTsColInfo, rowIndex);
1999 2000
}

2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016
static void prepareBuf(SqlFunctionCtx* pCtx) {
  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;
    }

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

  ASSERT(pCtx->subsidiaries.buf != NULL);
  ASSERT(pCtx->subsidiaries.rowLen > 0);
}

L
Liu Jicong 已提交
2017 2018
static void firstlastSaveTupleData(const SSDataBlock* pSrcBlock, int32_t rowIndex, SqlFunctionCtx* pCtx,
                                   SFirstLastRes* pInfo) {
2019 2020 2021 2022 2023
  if (pCtx->subsidiaries.num <= 0) {
    return;
  }

  if (!pInfo->hasResult) {
L
Liu Jicong 已提交
2024
    pInfo->pos = saveTupleData(pCtx, rowIndex, pSrcBlock);
2025
  } else {
2026
    updateTupleData(pCtx, rowIndex, pSrcBlock, &pInfo->pos);
2027 2028 2029
  }
}

H
Haojun Liao 已提交
2030
static void doSaveCurrentVal(SqlFunctionCtx* pCtx, int32_t rowIndex, int64_t currentTs, int32_t type, char* pData) {
2031 2032 2033 2034 2035 2036 2037 2038 2039
  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;
2040
  firstlastSaveTupleData(pCtx->pSrcBlock, rowIndex, pCtx, pInfo);
2041 2042 2043 2044

  pInfo->hasResult = true;
}

2045 2046
// 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
2047
int32_t firstFunction(SqlFunctionCtx* pCtx) {
H
Haojun Liao 已提交
2048 2049
  int32_t numOfElems = 0;

2050
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
2051
  SFirstLastRes*       pInfo = GET_ROWCELL_INTERBUF(pResInfo);
H
Haojun Liao 已提交
2052 2053

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

2056
  pInfo->bytes = pInputCol->info.bytes;
2057

G
Ganlin Zhao 已提交
2058
  if (IS_NULL_TYPE(pInputCol->info.type)) {
G
Ganlin Zhao 已提交
2059
    return TSDB_CODE_SUCCESS;
G
Ganlin Zhao 已提交
2060 2061
  }

H
Haojun Liao 已提交
2062
  // All null data column, return directly.
H
Haojun Liao 已提交
2063
  if (pInput->colDataSMAIsSet && (pInput->pColumnDataAgg[0]->numOfNull == pInput->totalRows)) {
2064
    ASSERT(pInputCol->hasNull == true);
2065 2066
    // save selectivity value for column consisted of all null values
    firstlastSaveTupleData(pCtx->pSrcBlock, pInput->startRowIndex, pCtx, pInfo);
G
Ganlin Zhao 已提交
2067
    return TSDB_CODE_SUCCESS;
H
Haojun Liao 已提交
2068 2069
  }

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

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

2075
  int32_t blockDataOrder = (startKey <= endKey) ? TSDB_ORDER_ASC : TSDB_ORDER_DESC;
2076

L
Liu Jicong 已提交
2077 2078
  //  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
2079
#if 0
2080 2081 2082
  if (blockDataOrder == TSDB_ORDER_ASC) {
    // filter according to current result firstly
    if (pResInfo->numOfRes > 0) {
2083
      if (pInfo->ts < startKey) {
2084 2085 2086 2087 2088 2089 2090 2091 2092
        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;
      }

2093 2094
      numOfElems++;

2095
      char* data = colDataGetData(pInputCol, i);
2096
      TSKEY cts = getRowPTs(pInput->pPTS, i);
2097 2098
      if (pResInfo->numOfRes == 0 || pInfo->ts > cts) {
        doSaveCurrentVal(pCtx, i, cts, pInputCol->info.type, data);
2099
        break;
2100 2101 2102 2103 2104 2105
      }
    }
  } 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) {
2106
      if (pInfo->ts < endKey) {
2107 2108
        return TSDB_CODE_SUCCESS;
      }
H
Haojun Liao 已提交
2109 2110
    }

2111 2112 2113 2114 2115
    for (int32_t i = pInput->numOfRows + pInput->startRowIndex - 1; i >= pInput->startRowIndex; --i) {
      if (pInputCol->hasNull && colDataIsNull(pInputCol, pInput->totalRows, i, pColAgg)) {
        continue;
      }

2116 2117
      numOfElems++;

2118
      char* data = colDataGetData(pInputCol, i);
2119
      TSKEY cts = getRowPTs(pInput->pPTS, i);
2120

2121 2122
      if (pResInfo->numOfRes == 0 || pInfo->ts > cts) {
        doSaveCurrentVal(pCtx, i, cts, pInputCol->info.type, data);
2123
        break;
2124 2125
      }
    }
H
Haojun Liao 已提交
2126
  }
2127
#else
2128
  int64_t* pts = (int64_t*)pInput->pPTS->pData;
2129 2130 2131 2132 2133 2134 2135 2136
  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 已提交
2137
    TSKEY cts = pts[i];
2138 2139 2140 2141 2142 2143
    if (pResInfo->numOfRes == 0 || pInfo->ts > cts) {
      doSaveCurrentVal(pCtx, i, cts, pInputCol->info.type, data);
      pResInfo->numOfRes = 1;
    }
  }
#endif
H
Haojun Liao 已提交
2144

2145 2146 2147 2148
  if (numOfElems == 0) {
    // save selectivity value for column consisted of all null values
    firstlastSaveTupleData(pCtx->pSrcBlock, pInput->startRowIndex, pCtx, pInfo);
  }
H
Haojun Liao 已提交
2149
  SET_VAL(pResInfo, numOfElems, 1);
wmmhello's avatar
wmmhello 已提交
2150
  return TSDB_CODE_SUCCESS;
H
Haojun Liao 已提交
2151 2152
}

2153
int32_t lastFunction(SqlFunctionCtx* pCtx) {
H
Haojun Liao 已提交
2154 2155
  int32_t numOfElems = 0;

2156
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
2157
  SFirstLastRes*       pInfo = GET_ROWCELL_INTERBUF(pResInfo);
H
Haojun Liao 已提交
2158 2159

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

2162
  int32_t type = pInputCol->info.type;
2163
  int32_t bytes = pInputCol->info.bytes;
2164
  pInfo->bytes = bytes;
2165

G
Ganlin Zhao 已提交
2166
  if (IS_NULL_TYPE(type)) {
G
Ganlin Zhao 已提交
2167
    return TSDB_CODE_SUCCESS;
G
Ganlin Zhao 已提交
2168 2169
  }

H
Haojun Liao 已提交
2170
  // All null data column, return directly.
H
Haojun Liao 已提交
2171
  if (pInput->colDataSMAIsSet && (pInput->pColumnDataAgg[0]->numOfNull == pInput->totalRows)) {
2172
    ASSERT(pInputCol->hasNull == true);
2173 2174
    // save selectivity value for column consisted of all null values
    firstlastSaveTupleData(pCtx->pSrcBlock, pInput->startRowIndex, pCtx, pInfo);
G
Ganlin Zhao 已提交
2175
    return TSDB_CODE_SUCCESS;
H
Haojun Liao 已提交
2176 2177
  }

H
Haojun Liao 已提交
2178
  SColumnDataAgg* pColAgg = (pInput->colDataSMAIsSet) ? pInput->pColumnDataAgg[0] : NULL;
2179 2180 2181 2182

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

2183
  int32_t blockDataOrder = (startKey <= endKey) ? TSDB_ORDER_ASC : TSDB_ORDER_DESC;
2184

L
Liu Jicong 已提交
2185 2186
  //  please ref. to the comment in lastRowFunction for the reason why disabling the opt version of last/first
  //  function.
2187
#if 0
2188
  if (blockDataOrder == TSDB_ORDER_ASC) {
H
Haojun Liao 已提交
2189
    for (int32_t i = pInput->numOfRows + pInput->startRowIndex - 1; i >= pInput->startRowIndex; --i) {
2190
      if (pInputCol->hasNull && colDataIsNull(pInputCol, pInput->totalRows, i, pColAgg)) {
H
Haojun Liao 已提交
2191 2192 2193 2194
        continue;
      }

      numOfElems++;
2195 2196 2197

      char* data = colDataGetData(pInputCol, i);
      TSKEY cts = getRowPTs(pInput->pPTS, i);
2198 2199
      if (pResInfo->numOfRes == 0 || pInfo->ts < cts) {
        doSaveCurrentVal(pCtx, i, cts, type, data);
2200
      }
2201

H
Haojun Liao 已提交
2202 2203
      break;
    }
2204
  } else {  // descending order
H
Haojun Liao 已提交
2205
    for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
2206
      if (pInputCol->hasNull && colDataIsNull(pInputCol, pInput->totalRows, i, pColAgg)) {
H
Haojun Liao 已提交
2207 2208 2209
        continue;
      }

2210
      numOfElems++;
H
Haojun Liao 已提交
2211

2212 2213
      char* data = colDataGetData(pInputCol, i);
      TSKEY cts = getRowPTs(pInput->pPTS, i);
2214 2215
      if (pResInfo->numOfRes == 0 || pInfo->ts < cts) {
        doSaveCurrentVal(pCtx, i, cts, type, data);
H
Haojun Liao 已提交
2216 2217 2218 2219
      }
      break;
    }
  }
2220
#else
H
Haojun Liao 已提交
2221
  int64_t* pts = (int64_t*)pInput->pPTS->pData;
H
Haojun Liao 已提交
2222

H
Haojun Liao 已提交
2223
#if 0
H
Haojun Liao 已提交
2224 2225 2226 2227
    for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
      if (pInputCol->hasNull && colDataIsNull(pInputCol, pInput->totalRows, i, pColAgg)) {
        continue;
      }
2228

H
Haojun Liao 已提交
2229
      numOfElems++;
H
Haojun Liao 已提交
2230 2231 2232
      if (pResInfo->numOfRes == 0 || pInfo->ts < pts[i]) {
        char* data = colDataGetData(pInputCol, i);
        doSaveCurrentVal(pCtx, i, pts[i], type, data);
H
Haojun Liao 已提交
2233 2234
        pResInfo->numOfRes = 1;
      }
2235
    }
H
Haojun Liao 已提交
2236
#else
2237 2238
  if (!pInputCol->hasNull) {
    numOfElems = 1;
H
Haojun Liao 已提交
2239

2240 2241
    int32_t round = pInput->numOfRows >> 2;
    int32_t reminder = pInput->numOfRows & 0x03;
H
Haojun Liao 已提交
2242

L
Liu Jicong 已提交
2243 2244 2245
    for (int32_t i = pInput->startRowIndex, tick = 0; tick < round; i += 4, tick += 1) {
      int64_t cts = pts[i];
      int32_t chosen = i;
H
Haojun Liao 已提交
2246

2247 2248 2249 2250
      if (cts < pts[i + 1]) {
        cts = pts[i + 1];
        chosen = i + 1;
      }
H
Haojun Liao 已提交
2251

2252 2253 2254 2255
      if (cts < pts[i + 2]) {
        cts = pts[i + 2];
        chosen = i + 2;
      }
H
Haojun Liao 已提交
2256

2257 2258 2259 2260
      if (cts < pts[i + 3]) {
        cts = pts[i + 3];
        chosen = i + 3;
      }
H
Haojun Liao 已提交
2261

2262 2263 2264 2265
      if (pResInfo->numOfRes == 0 || pInfo->ts < cts) {
        char* data = colDataGetData(pInputCol, chosen);
        doSaveCurrentVal(pCtx, i, cts, type, data);
        pResInfo->numOfRes = 1;
H
Haojun Liao 已提交
2266
      }
2267
    }
H
Haojun Liao 已提交
2268

L
Liu Jicong 已提交
2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279
    for (int32_t i = pInput->startRowIndex + round * 4; i < pInput->startRowIndex + pInput->numOfRows; ++i) {
      if (pResInfo->numOfRes == 0 || pInfo->ts < pts[i]) {
        char* data = colDataGetData(pInputCol, i);
        doSaveCurrentVal(pCtx, i, pts[i], type, data);
        pResInfo->numOfRes = 1;
      }
    }
  } else {
    for (int32_t i = pInput->startRowIndex; i < pInput->startRowIndex + pInput->numOfRows; ++i) {
      if (colDataIsNull(pInputCol, pInput->totalRows, i, pColAgg)) {
        continue;
H
Haojun Liao 已提交
2280 2281
      }

2282
      numOfElems++;
H
Haojun Liao 已提交
2283

2284 2285 2286 2287
      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 已提交
2288 2289
      }
    }
2290
  }
H
Haojun Liao 已提交
2291
#endif
H
Haojun Liao 已提交
2292

2293
#endif
H
Haojun Liao 已提交
2294 2295

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

2300
  //  SET_VAL(pResInfo, numOfElems, 1);
wmmhello's avatar
wmmhello 已提交
2301
  return TSDB_CODE_SUCCESS;
H
Haojun Liao 已提交
2302
}
H
Haojun Liao 已提交
2303

5
54liuyao 已提交
2304
static int32_t firstLastTransferInfoImpl(SFirstLastRes* pInput, SFirstLastRes* pOutput, bool isFirst) {
G
Ganlin Zhao 已提交
2305
  if (pOutput->hasResult) {
2306
    if (isFirst) {
2307
      if (pInput->ts > pOutput->ts) {
5
54liuyao 已提交
2308
        return TSDB_CODE_FAILED;
2309 2310
      }
    } else {
2311
      if (pInput->ts < pOutput->ts) {
5
54liuyao 已提交
2312
        return TSDB_CODE_FAILED;
2313
      }
G
Ganlin Zhao 已提交
2314 2315
    }
  }
2316

2317 2318 2319 2320
  pOutput->isNull = pInput->isNull;
  pOutput->ts = pInput->ts;
  pOutput->bytes = pInput->bytes;

G
Ganlin Zhao 已提交
2321
  memcpy(pOutput->buf, pInput->buf, pOutput->bytes);
5
54liuyao 已提交
2322 2323
  return TSDB_CODE_SUCCESS;
}
G
Ganlin Zhao 已提交
2324

5
54liuyao 已提交
2325 2326 2327 2328 2329 2330
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 已提交
2331 2332
}

2333
static int32_t firstLastFunctionMergeImpl(SqlFunctionCtx* pCtx, bool isFirstQuery) {
G
Ganlin Zhao 已提交
2334
  SInputColumnInfoData* pInput = &pCtx->input;
2335
  SColumnInfoData*      pCol = pInput->pData[0];
2336
  ASSERT(pCol->info.type == TSDB_DATA_TYPE_BINARY);
G
Ganlin Zhao 已提交
2337 2338 2339

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

2340 2341
  int32_t start = pInput->startRowIndex;
  int32_t numOfElems = 0;
G
Ganlin Zhao 已提交
2342

X
Xiaoyu Wang 已提交
2343 2344
  for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
    char*          data = colDataGetData(pCol, i);
2345
    SFirstLastRes* pInputInfo = (SFirstLastRes*)varDataVal(data);
2346
    firstLastTransferInfo(pCtx, pInputInfo, pInfo, isFirstQuery, i);
2347 2348 2349 2350
    if (!numOfElems) {
      numOfElems = pInputInfo->hasResult ? 1 : 0;
    }
  }
2351 2352

  SET_VAL(GET_RES_INFO(pCtx), numOfElems, 1);
G
Ganlin Zhao 已提交
2353 2354 2355
  return TSDB_CODE_SUCCESS;
}

2356
int32_t firstFunctionMerge(SqlFunctionCtx* pCtx) { return firstLastFunctionMergeImpl(pCtx, true); }
2357

2358
int32_t lastFunctionMerge(SqlFunctionCtx* pCtx) { return firstLastFunctionMergeImpl(pCtx, false); }
2359

2360
int32_t firstLastFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
G
Ganlin Zhao 已提交
2361 2362 2363 2364 2365 2366
  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 已提交
2367
  SFirstLastRes* pRes = GET_ROWCELL_INTERBUF(pResInfo);
X
Xiaoyu Wang 已提交
2368
  colDataAppend(pCol, pBlock->info.rows, pRes->buf, pRes->isNull || pResInfo->isNullRes);
2369

2370
  // handle selectivity
2371
  setSelectivityValue(pCtx, pBlock, &pRes->pos, pBlock->info.rows);
G
Ganlin Zhao 已提交
2372 2373 2374 2375

  return pResInfo->numOfRes;
}

G
Ganlin Zhao 已提交
2376 2377
int32_t firstLastPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SResultRowEntryInfo* pEntryInfo = GET_RES_INFO(pCtx);
2378
  SFirstLastRes*       pRes = GET_ROWCELL_INTERBUF(pEntryInfo);
2379

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

2382 2383
  // todo check for failure
  char* res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
G
Ganlin Zhao 已提交
2384
  memcpy(varDataVal(res), pRes, resultBytes);
2385

G
Ganlin Zhao 已提交
2386 2387 2388 2389 2390 2391
  varDataSetLen(res, resultBytes);

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

  colDataAppend(pCol, pBlock->info.rows, res, false);
2392
  setSelectivityValue(pCtx, pBlock, &pRes->pos, pBlock->info.rows);
G
Ganlin Zhao 已提交
2393 2394 2395 2396 2397

  taosMemoryFree(res);
  return 1;
}

5
54liuyao 已提交
2398 2399
int32_t lastCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);
2400
  SFirstLastRes*       pDBuf = GET_ROWCELL_INTERBUF(pDResInfo);
2401
  int32_t              bytes = pDBuf->bytes;
5
54liuyao 已提交
2402 2403

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

5
54liuyao 已提交
2406 2407
  if (TSDB_CODE_SUCCESS == firstLastTransferInfoImpl(pSBuf, pDBuf, false)) {
    pDBuf->hasResult = true;
5
54liuyao 已提交
2408
  }
5
54liuyao 已提交
2409 2410 2411

  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
  pDResInfo->isNullRes &= pSResInfo->isNullRes;
5
54liuyao 已提交
2412 2413 2414
  return TSDB_CODE_SUCCESS;
}

2415
static void doSaveLastrow(SqlFunctionCtx* pCtx, char* pData, int32_t rowIndex, int64_t cts, SFirstLastRes* pInfo) {
2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431
  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;
2432
  firstlastSaveTupleData(pCtx->pSrcBlock, rowIndex, pCtx, pInfo);
2433 2434 2435 2436

  pInfo->hasResult = true;
}

2437 2438 2439 2440 2441 2442 2443 2444 2445
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];

L
Liu Jicong 已提交
2446
  int32_t type = pInputCol->info.type;
2447 2448 2449
  int32_t bytes = pInputCol->info.bytes;
  pInfo->bytes = bytes;

G
Ganlin Zhao 已提交
2450 2451 2452 2453
  if (IS_NULL_TYPE(type)) {
    return TSDB_CODE_SUCCESS;
  }

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

2457
#if 0
2458 2459
  int32_t blockDataOrder = (startKey <= endKey) ? TSDB_ORDER_ASC : TSDB_ORDER_DESC;

H
Haojun Liao 已提交
2460 2461
  // 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.
2462 2463 2464 2465
  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);
2466 2467 2468 2469
      numOfElems++;

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

2472 2473 2474 2475 2476 2477
      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);
2478 2479 2480 2481
      numOfElems++;

      if (pResInfo->numOfRes == 0 || pInfo->ts < cts) {
        doSaveLastrow(pCtx, data, i, cts, pInfo);
2482 2483 2484 2485
      }
      break;
    }
  }
2486
#else
H
Haojun Liao 已提交
2487 2488

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

H
Haojun Liao 已提交
2494
    numOfElems++;
2495 2496 2497 2498 2499
    if (pResInfo->numOfRes == 0 || pInfo->ts < cts) {
      doSaveLastrow(pCtx, data, i, cts, pInfo);
      pResInfo->numOfRes = 1;
    }
  }
2500

2501
#endif
2502

2503 2504 2505 2506
  SET_VAL(pResInfo, numOfElems, 1);
  return TSDB_CODE_SUCCESS;
}

H
Haojun Liao 已提交
2507 2508 2509 2510 2511
bool getDiffFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(SDiffInfo);
  return true;
}

2512
bool diffFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
H
Haojun Liao 已提交
2513 2514 2515 2516 2517
  if (!functionSetup(pCtx, pResInfo)) {
    return false;
  }

  SDiffInfo* pDiffInfo = GET_ROWCELL_INTERBUF(pResInfo);
2518
  pDiffInfo->hasPrev = false;
H
Haojun Liao 已提交
2519
  pDiffInfo->prev.i64 = 0;
2520
  pDiffInfo->prevTs = -1;
2521 2522 2523 2524 2525
  if (pCtx->numOfParams > 1) {
    pDiffInfo->ignoreNegative = pCtx->param[1].param.i;  // TODO set correct param
  } else {
    pDiffInfo->ignoreNegative = false;
  }
H
Haojun Liao 已提交
2526 2527
  pDiffInfo->includeNull = false;
  pDiffInfo->firstOutput = false;
H
Haojun Liao 已提交
2528 2529 2530
  return true;
}

2531
static void doSetPrevVal(SDiffInfo* pDiffInfo, int32_t type, const char* pv, int64_t ts) {
X
Xiaoyu Wang 已提交
2532
  switch (type) {
2533
    case TSDB_DATA_TYPE_BOOL:
L
Liu Jicong 已提交
2534
      pDiffInfo->prev.i64 = *(bool*)pv ? 1 : 0;
2535
      break;
2536
    case TSDB_DATA_TYPE_TINYINT:
X
Xiaoyu Wang 已提交
2537 2538
      pDiffInfo->prev.i64 = *(int8_t*)pv;
      break;
2539
    case TSDB_DATA_TYPE_INT:
X
Xiaoyu Wang 已提交
2540 2541
      pDiffInfo->prev.i64 = *(int32_t*)pv;
      break;
2542
    case TSDB_DATA_TYPE_SMALLINT:
X
Xiaoyu Wang 已提交
2543 2544
      pDiffInfo->prev.i64 = *(int16_t*)pv;
      break;
2545
    case TSDB_DATA_TYPE_TIMESTAMP:
2546
    case TSDB_DATA_TYPE_BIGINT:
X
Xiaoyu Wang 已提交
2547 2548
      pDiffInfo->prev.i64 = *(int64_t*)pv;
      break;
2549
    case TSDB_DATA_TYPE_FLOAT:
X
Xiaoyu Wang 已提交
2550 2551
      pDiffInfo->prev.d64 = *(float*)pv;
      break;
2552
    case TSDB_DATA_TYPE_DOUBLE:
X
Xiaoyu Wang 已提交
2553 2554
      pDiffInfo->prev.d64 = *(double*)pv;
      break;
2555
    default:
2556
      ASSERT(0);
2557
  }
2558
  pDiffInfo->prevTs = ts;
2559 2560
}

X
Xiaoyu Wang 已提交
2561
static void doHandleDiff(SDiffInfo* pDiffInfo, int32_t type, const char* pv, SColumnInfoData* pOutput, int32_t pos,
2562
                         int32_t order, int64_t ts) {
X
Xiaoyu Wang 已提交
2563
  int32_t factor = (order == TSDB_ORDER_ASC) ? 1 : -1;
2564
  pDiffInfo->prevTs = ts;
2565 2566 2567
  switch (type) {
    case TSDB_DATA_TYPE_INT: {
      int32_t v = *(int32_t*)pv;
X
Xiaoyu Wang 已提交
2568
      int64_t delta = factor * (v - pDiffInfo->prev.i64);  // direct previous may be null
2569 2570 2571
      if (delta < 0 && pDiffInfo->ignoreNegative) {
        colDataSetNull_f(pOutput->nullbitmap, pos);
      } else {
2572
        colDataAppendInt64(pOutput, pos, &delta);
2573 2574
      }
      pDiffInfo->prev.i64 = v;
2575

2576 2577 2578 2579
      break;
    }
    case TSDB_DATA_TYPE_BOOL:
    case TSDB_DATA_TYPE_TINYINT: {
X
Xiaoyu Wang 已提交
2580 2581
      int8_t  v = *(int8_t*)pv;
      int64_t delta = factor * (v - pDiffInfo->prev.i64);  // direct previous may be null
2582 2583 2584
      if (delta < 0 && pDiffInfo->ignoreNegative) {
        colDataSetNull_f(pOutput->nullbitmap, pos);
      } else {
2585
        colDataAppendInt64(pOutput, pos, &delta);
2586 2587 2588 2589 2590 2591
      }
      pDiffInfo->prev.i64 = v;
      break;
    }
    case TSDB_DATA_TYPE_SMALLINT: {
      int16_t v = *(int16_t*)pv;
X
Xiaoyu Wang 已提交
2592
      int64_t delta = factor * (v - pDiffInfo->prev.i64);  // direct previous may be null
2593 2594 2595
      if (delta < 0 && pDiffInfo->ignoreNegative) {
        colDataSetNull_f(pOutput->nullbitmap, pos);
      } else {
2596
        colDataAppendInt64(pOutput, pos, &delta);
2597 2598 2599 2600
      }
      pDiffInfo->prev.i64 = v;
      break;
    }
2601
    case TSDB_DATA_TYPE_TIMESTAMP:
2602 2603
    case TSDB_DATA_TYPE_BIGINT: {
      int64_t v = *(int64_t*)pv;
X
Xiaoyu Wang 已提交
2604
      int64_t delta = factor * (v - pDiffInfo->prev.i64);  // direct previous may be null
2605 2606 2607 2608 2609 2610 2611 2612 2613
      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 已提交
2614 2615 2616
      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
2617 2618
        colDataSetNull_f(pOutput->nullbitmap, pos);
      } else {
2619
        colDataAppendDouble(pOutput, pos, &delta);
2620 2621 2622 2623 2624 2625
      }
      pDiffInfo->prev.d64 = v;
      break;
    }
    case TSDB_DATA_TYPE_DOUBLE: {
      double v = *(double*)pv;
X
Xiaoyu Wang 已提交
2626 2627
      double delta = factor * (v - pDiffInfo->prev.d64);                               // direct previous may be null
      if ((delta < 0 && pDiffInfo->ignoreNegative) || isinf(delta) || isnan(delta)) {  // check for overflow
2628 2629 2630 2631 2632 2633 2634 2635
        colDataSetNull_f(pOutput->nullbitmap, pos);
      } else {
        colDataAppendDouble(pOutput, pos, &delta);
      }
      pDiffInfo->prev.d64 = v;
      break;
    }
    default:
2636
      ASSERT(0);
2637
  }
G
Ganlin Zhao 已提交
2638
}
2639

2640 2641 2642
int32_t diffFunction(SqlFunctionCtx* pCtx) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  SDiffInfo*           pDiffInfo = GET_ROWCELL_INTERBUF(pResInfo);
H
Haojun Liao 已提交
2643 2644 2645

  SInputColumnInfoData* pInput = &pCtx->input;

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

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

2650
  int32_t numOfElems = 0;
H
Haojun Liao 已提交
2651
  int32_t startOffset = pCtx->offset;
H
Haojun Liao 已提交
2652

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

2655 2656 2657
  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 已提交
2658

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

2663
          numOfElems += 1;
H
Haojun Liao 已提交
2664
        }
2665
        continue;
H
Haojun Liao 已提交
2666 2667
      }

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

2670
      if (pDiffInfo->hasPrev) {
2671 2672 2673 2674
        if (tsList[i] == pDiffInfo->prevTs) {
          return TSDB_CODE_FUNC_DUP_TIMESTAMP;
        }
        doHandleDiff(pDiffInfo, pInputCol->info.type, pv, pOutput, pos, pCtx->order, tsList[i]);
2675
        // handle selectivity
2676 2677 2678
        if (pCtx->subsidiaries.num > 0) {
          appendSelectivityValue(pCtx, i, pos);
        }
H
Haojun Liao 已提交
2679 2680

        numOfElems++;
2681
      } else {
2682
        doSetPrevVal(pDiffInfo, pInputCol->info.type, pv, tsList[i]);
H
Haojun Liao 已提交
2683 2684
      }

2685 2686 2687 2688 2689 2690 2691 2692 2693
      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 已提交
2694

2695
          numOfElems += 1;
H
Haojun Liao 已提交
2696
        }
2697
        continue;
H
Haojun Liao 已提交
2698 2699
      }

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

2702 2703
      // there is a row of previous data block to be handled in the first place.
      if (pDiffInfo->hasPrev) {
2704 2705 2706 2707
        if (tsList[i] == pDiffInfo->prevTs) {
          return TSDB_CODE_FUNC_DUP_TIMESTAMP;
        }
        doHandleDiff(pDiffInfo, pInputCol->info.type, pv, pOutput, pos, pCtx->order, tsList[i]);
2708
        // handle selectivity
2709 2710 2711
        if (pCtx->subsidiaries.num > 0) {
          appendSelectivityValue(pCtx, i, pos);
        }
H
Haojun Liao 已提交
2712 2713

        numOfElems++;
2714
      } else {
2715
        doSetPrevVal(pDiffInfo, pInputCol->info.type, pv, tsList[i]);
H
Haojun Liao 已提交
2716 2717
      }

2718
      pDiffInfo->hasPrev = true;
H
Haojun Liao 已提交
2719 2720 2721
    }
  }

2722 2723
  pResInfo->numOfRes = numOfElems;
  return TSDB_CODE_SUCCESS;
H
Haojun Liao 已提交
2724
}
H
Haojun Liao 已提交
2725

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

2728
bool getTopBotFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
2729
  SValueNode* pkNode = (SValueNode*)nodesListGetNode(pFunc->pParameterList, 1);
2730
  pEnv->calcMemSize = sizeof(STopBotRes) + pkNode->datum.i * sizeof(STopBotResItem);
2731 2732 2733
  return true;
}

G
Ganlin Zhao 已提交
2734 2735 2736 2737 2738
bool topBotFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
  if (!functionSetup(pCtx, pResInfo)) {
    return false;
  }

X
Xiaoyu Wang 已提交
2739
  STopBotRes*           pRes = GET_ROWCELL_INTERBUF(pResInfo);
2740 2741 2742 2743
  SInputColumnInfoData* pInput = &pCtx->input;

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

2744 2745
  pRes->nullTupleSaved = false;
  pRes->nullTuplePos.pageId = -1;
G
Ganlin Zhao 已提交
2746 2747 2748
  return true;
}

2749 2750 2751 2752
static STopBotRes* getTopBotOutputInfo(SqlFunctionCtx* pCtx) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  STopBotRes*          pRes = GET_ROWCELL_INTERBUF(pResInfo);
  pRes->pItems = (STopBotResItem*)((char*)pRes + sizeof(STopBotRes));
2753 2754

  return pRes;
2755 2756
}

2757
static void doAddIntoResult(SqlFunctionCtx* pCtx, void* pData, int32_t rowIndex, SSDataBlock* pSrcBlock, uint16_t type,
2758
                            uint64_t uid, SResultRowEntryInfo* pEntryInfo, bool isTopQuery);
2759

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

2762 2763 2764
int32_t topFunction(SqlFunctionCtx* pCtx) {
  int32_t              numOfElems = 0;
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
2765 2766

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

G
Ganlin Zhao 已提交
2769 2770
  STopBotRes* pRes = getTopBotOutputInfo(pCtx);
  pRes->type = pInput->pData[0]->info.type;
2771 2772

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

2778
    numOfElems++;
2779
    char* data = colDataGetData(pCol, i);
G
Ganlin Zhao 已提交
2780
    doAddIntoResult(pCtx, data, i, pCtx->pSrcBlock, pRes->type, pInput->uid, pResInfo, true);
2781 2782
  }

2783
  if (numOfElems == 0 && pCtx->subsidiaries.num > 0 && !pRes->nullTupleSaved) {
L
Liu Jicong 已提交
2784
    pRes->nullTuplePos = saveTupleData(pCtx, pInput->startRowIndex, pCtx->pSrcBlock);
2785 2786
    pRes->nullTupleSaved = true;
  }
2787 2788 2789
  return TSDB_CODE_SUCCESS;
}

2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810
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);
  }

2811
  if (numOfElems == 0 && pCtx->subsidiaries.num > 0 && !pRes->nullTupleSaved) {
L
Liu Jicong 已提交
2812
    pRes->nullTuplePos = saveTupleData(pCtx, pInput->startRowIndex, pCtx->pSrcBlock);
2813 2814 2815
    pRes->nullTupleSaved = true;
  }

2816 2817 2818
  return TSDB_CODE_SUCCESS;
}

2819 2820
static int32_t topBotResComparFn(const void* p1, const void* p2, const void* param) {
  uint16_t type = *(uint16_t*)param;
2821

2822 2823
  STopBotResItem* val1 = (STopBotResItem*)p1;
  STopBotResItem* val2 = (STopBotResItem*)p2;
2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836

  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;
2837 2838 2839 2840 2841 2842
  } 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;
2843 2844 2845 2846 2847 2848 2849 2850 2851
  }

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

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

2852
void doAddIntoResult(SqlFunctionCtx* pCtx, void* pData, int32_t rowIndex, SSDataBlock* pSrcBlock, uint16_t type,
2853
                     uint64_t uid, SResultRowEntryInfo* pEntryInfo, bool isTopQuery) {
2854
  STopBotRes* pRes = getTopBotOutputInfo(pCtx);
2855

2856 2857 2858
  SVariant val = {0};
  taosVariantCreateFromBinary(&val, pData, tDataTypes[type].bytes, type);

2859
  STopBotResItem* pItems = pRes->pItems;
2860 2861 2862
  assert(pItems != NULL);

  // not full yet
G
Ganlin Zhao 已提交
2863
  if (pEntryInfo->numOfRes < pRes->maxSize) {
2864
    STopBotResItem* pItem = &pItems[pEntryInfo->numOfRes];
2865
    pItem->v = val;
2866
    pItem->uid = uid;
2867

2868
    // save the data of this tuple
G
Ganlin Zhao 已提交
2869
    if (pCtx->subsidiaries.num > 0) {
L
Liu Jicong 已提交
2870
      pItem->tuplePos = saveTupleData(pCtx, rowIndex, pSrcBlock);
G
Ganlin Zhao 已提交
2871
    }
2872
#ifdef BUF_PAGE_DEBUG
X
Xiaoyu Wang 已提交
2873 2874
    qDebug("page_saveTuple i:%d, item:%p,pageId:%d, offset:%d\n", pEntryInfo->numOfRes, pItem, pItem->tuplePos.pageId,
           pItem->tuplePos.offset);
2875
#endif
2876 2877
    // allocate the buffer and keep the data of this row into the new allocated buffer
    pEntryInfo->numOfRes++;
2878
    taosheapsort((void*)pItems, sizeof(STopBotResItem), pEntryInfo->numOfRes, (const void*)&type, topBotResComparFn,
2879
                 !isTopQuery);
2880
  } else {  // replace the minimum value in the result
X
Xiaoyu Wang 已提交
2881 2882
    if ((isTopQuery && ((IS_SIGNED_NUMERIC_TYPE(type) && val.i > pItems[0].v.i) ||
                        (IS_UNSIGNED_NUMERIC_TYPE(type) && val.u > pItems[0].v.u) ||
2883 2884
                        (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 已提交
2885 2886
        (!isTopQuery && ((IS_SIGNED_NUMERIC_TYPE(type) && val.i < pItems[0].v.i) ||
                         (IS_UNSIGNED_NUMERIC_TYPE(type) && val.u < pItems[0].v.u) ||
2887 2888
                         (TSDB_DATA_TYPE_FLOAT == type && val.f < pItems[0].v.f) ||
                         (TSDB_DATA_TYPE_DOUBLE == type && val.d < pItems[0].v.d)))) {
2889
      // replace the old data and the coresponding tuple data
2890
      STopBotResItem* pItem = &pItems[0];
2891
      pItem->v = val;
2892
      pItem->uid = uid;
2893 2894

      // save the data of this tuple by over writing the old data
G
Ganlin Zhao 已提交
2895
      if (pCtx->subsidiaries.num > 0) {
2896
        updateTupleData(pCtx, rowIndex, pSrcBlock, &pItem->tuplePos);
G
Ganlin Zhao 已提交
2897
      }
2898
#ifdef BUF_PAGE_DEBUG
wmmhello's avatar
wmmhello 已提交
2899
      qDebug("page_copyTuple pageId:%d, offset:%d", pItem->tuplePos.pageId, pItem->tuplePos.offset);
2900
#endif
2901
      taosheapadjust((void*)pItems, sizeof(STopBotResItem), 0, pEntryInfo->numOfRes - 1, (const void*)&type,
2902
                     topBotResComparFn, NULL, !isTopQuery);
2903
    }
2904 2905
  }
}
2906

2907 2908 2909 2910 2911 2912
/*
 * +------------------------------------+--------------+--------------+
 * |            null bitmap             |              |              |
 * |(n columns, one bit for each column)| src column #1| src column #2|
 * +------------------------------------+--------------+--------------+
 */
L
Liu Jicong 已提交
2913 2914
void* serializeTupleData(const SSDataBlock* pSrcBlock, int32_t rowIndex, SSubsidiaryResInfo* pSubsidiaryies,
                         char* buf) {
2915 2916
  char* nullList = buf;
  char* pStart = (char*)(nullList + sizeof(bool) * pSubsidiaryies->num);
2917 2918

  int32_t offset = 0;
2919 2920
  for (int32_t i = 0; i < pSubsidiaryies->num; ++i) {
    SqlFunctionCtx* pc = pSubsidiaryies->pCtx[i];
wmmhello's avatar
wmmhello 已提交
2921 2922 2923 2924 2925 2926

    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) {
2927
      offset += pCol->info.bytes;
2928 2929 2930 2931 2932
      continue;
    }

    char* p = colDataGetData(pCol, rowIndex);
    if (IS_VAR_DATA_TYPE(pCol->info.type)) {
X
Xiaoyu Wang 已提交
2933
      memcpy(pStart + offset, p, (pCol->info.type == TSDB_DATA_TYPE_JSON) ? getJsonValueLen(p) : varDataTLen(p));
2934 2935 2936 2937 2938 2939 2940
    } else {
      memcpy(pStart + offset, p, pCol->info.bytes);
    }

    offset += pCol->info.bytes;
  }

2941
  return buf;
2942 2943
}

L
Liu Jicong 已提交
2944
static STuplePos doSaveTupleData(SSerializeDataHandle* pHandle, const void* pBuf, size_t length, STupleKey key) {
2945 2946 2947
  STuplePos p = {0};
  if (pHandle->pBuf != NULL) {
    SFilePage* pPage = NULL;
2948

2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960
    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);
      }
    }
2961

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

2965 2966 2967 2968 2969
    pPage->num += length;
    setBufPageDirty(pPage, true);
    releaseBufPage(pHandle->pBuf, pPage);
  } else {
    // other tuple save policy
L
Liu Jicong 已提交
2970
    if (streamStateFuncPut(pHandle->pState, &key, pBuf, length) < 0) {
2971
      ASSERT(0);
2972
    }
L
Liu Jicong 已提交
2973
    p.streamTupleKey = key;
2974
  }
wmmhello's avatar
wmmhello 已提交
2975

2976 2977
  return p;
}
2978

L
Liu Jicong 已提交
2979
STuplePos saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock) {
2980 2981
  prepareBuf(pCtx);

L
Liu Jicong 已提交
2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992
  STupleKey key;
  if (pCtx->saveHandle.pBuf == NULL) {
    SColumnInfoData* pColInfo = taosArrayGet(pSrcBlock->pDataBlock, 0);
    ASSERT(pColInfo->info.type == TSDB_DATA_TYPE_TIMESTAMP);
    int64_t skey = *(int64_t*)colDataGetData(pColInfo, rowIndex);

    key.groupId = pSrcBlock->info.id.groupId;
    key.ts = skey;
    key.exprIdx = pCtx->exprIdx;
  }

2993
  char* buf = serializeTupleData(pSrcBlock, rowIndex, &pCtx->subsidiaries, pCtx->subsidiaries.buf);
L
Liu Jicong 已提交
2994
  return doSaveTupleData(&pCtx->saveHandle, buf, pCtx->subsidiaries.rowLen, key);
2995 2996 2997 2998 2999 3000 3001 3002 3003
}

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 {
3004
    streamStateFuncPut(pHandle->pState, &pPos->streamTupleKey, pBuf, length);
3005 3006 3007 3008 3009
  }

  return TSDB_CODE_SUCCESS;
}

H
Haojun Liao 已提交
3010
int32_t updateTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STuplePos* pPos) {
3011 3012
  prepareBuf(pCtx);

3013
  char* buf = serializeTupleData(pSrcBlock, rowIndex, &pCtx->subsidiaries, pCtx->subsidiaries.buf);
3014
  doUpdateTupleData(&pCtx->saveHandle, buf, pCtx->subsidiaries.rowLen, pPos);
3015 3016 3017 3018 3019 3020
  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 已提交
3021
    char*      p = pPage->data + pPos->offset;
3022 3023 3024
    releaseBufPage(pHandle->pBuf, pPage);
    return p;
  } else {
3025 3026 3027 3028
    void*   value = NULL;
    int32_t vLen;
    streamStateFuncGet(pHandle->pState, &pPos->streamTupleKey, &value, &vLen);
    return (char*)value;
3029 3030 3031
  }
}

H
Haojun Liao 已提交
3032
const char* loadTupleData(SqlFunctionCtx* pCtx, const STuplePos* pPos) {
3033
  return doLoadTupleData(&pCtx->saveHandle, pPos);
3034 3035
}

3036
int32_t topBotFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
3037
  SResultRowEntryInfo* pEntryInfo = GET_RES_INFO(pCtx);
3038
  STopBotRes*          pRes = getTopBotOutputInfo(pCtx);
3039

3040
  int16_t type = pCtx->pExpr->base.resSchema.type;
3041 3042
  int32_t slotId = pCtx->pExpr->base.resSchema.slotId;

3043 3044 3045 3046
  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);

  // todo assign the tag value and the corresponding row data
  int32_t currentRow = pBlock->info.rows;
3047 3048
  if (pEntryInfo->numOfRes <= 0) {
    colDataAppendNULL(pCol, currentRow);
3049
    setSelectivityValue(pCtx, pBlock, &pRes->nullTuplePos, currentRow);
3050 3051
    return pEntryInfo->numOfRes;
  }
3052 3053
  for (int32_t i = 0; i < pEntryInfo->numOfRes; ++i) {
    STopBotResItem* pItem = &pRes->pItems[i];
3054
    colDataAppend(pCol, currentRow, (const char*)&pItem->v.i, false);
3055
#ifdef BUF_PAGE_DEBUG
X
Xiaoyu Wang 已提交
3056 3057
    qDebug("page_finalize i:%d,item:%p,pageId:%d, offset:%d\n", i, pItem, pItem->tuplePos.pageId,
           pItem->tuplePos.offset);
3058
#endif
3059
    setSelectivityValue(pCtx, pBlock, &pRes->pItems[i].tuplePos, currentRow);
3060
    currentRow += 1;
3061 3062 3063
  }

  return pEntryInfo->numOfRes;
3064
}
G
Ganlin Zhao 已提交
3065

X
Xiaoyu Wang 已提交
3066
void addResult(SqlFunctionCtx* pCtx, STopBotResItem* pSourceItem, int16_t type, bool isTopQuery) {
3067
  SResultRowEntryInfo* pEntryInfo = GET_RES_INFO(pCtx);
X
Xiaoyu Wang 已提交
3068 3069
  STopBotRes*          pRes = getTopBotOutputInfo(pCtx);
  STopBotResItem*      pItems = pRes->pItems;
3070 3071 3072
  assert(pItems != NULL);

  // not full yet
G
Ganlin Zhao 已提交
3073
  if (pEntryInfo->numOfRes < pRes->maxSize) {
3074 3075 3076 3077 3078 3079 3080 3081 3082
    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 已提交
3083 3084
    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) ||
3085 3086
                        (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 已提交
3087 3088
        (!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) ||
3089 3090
                         (TSDB_DATA_TYPE_FLOAT == type && pSourceItem->v.f < pItems[0].v.f) ||
                         (TSDB_DATA_TYPE_DOUBLE == type && pSourceItem->v.d < pItems[0].v.d)))) {
3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106
      // 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);
3107
  int16_t              type = pSBuf->type;
3108 3109 3110 3111 3112 3113 3114 3115 3116
  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);
3117
  int16_t              type = pSBuf->type;
3118 3119 3120 3121 3122 3123
  for (int32_t i = 0; i < pSResInfo->numOfRes; i++) {
    addResult(pDestCtx, pSBuf->pItems + i, type, false);
  }
  return TSDB_CODE_SUCCESS;
}

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

G
Ganlin Zhao 已提交
3126 3127 3128 3129 3130
bool getSpreadFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(SSpreadInfo);
  return true;
}

X
Xiaoyu Wang 已提交
3131
bool spreadFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
G
Ganlin Zhao 已提交
3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142
  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 已提交
3143
int32_t spreadFunction(SqlFunctionCtx* pCtx) {
G
Ganlin Zhao 已提交
3144 3145 3146 3147
  int32_t numOfElems = 0;

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

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

H
Haojun Liao 已提交
3153
  if (pInput->colDataSMAIsSet) {
G
Ganlin Zhao 已提交
3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180
    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 已提交
3181
    int32_t start = pInput->startRowIndex;
G
Ganlin Zhao 已提交
3182 3183 3184 3185 3186 3187
    // 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 已提交
3188
      char* data = colDataGetData(pCol, i);
G
Ganlin Zhao 已提交
3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213

      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;
}

3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224
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 已提交
3225
int32_t spreadFunctionMerge(SqlFunctionCtx* pCtx) {
3226
  SInputColumnInfoData* pInput = &pCtx->input;
X
Xiaoyu Wang 已提交
3227
  SColumnInfoData*      pCol = pInput->pData[0];
3228
  ASSERT(pCol->info.type == TSDB_DATA_TYPE_BINARY);
3229 3230 3231

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

3232
  int32_t start = pInput->startRowIndex;
X
Xiaoyu Wang 已提交
3233 3234
  for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
    char*        data = colDataGetData(pCol, i);
3235
    SSpreadInfo* pInputInfo = (SSpreadInfo*)varDataVal(data);
3236 3237 3238
    if (pInputInfo->hasResult) {
      spreadTransferInfo(pInputInfo, pInfo);
    }
3239
  }
3240

3241 3242 3243
  if (pInfo->hasResult) {
    GET_RES_INFO(pCtx)->numOfRes = 1;
  }
3244 3245 3246 3247

  return TSDB_CODE_SUCCESS;
}

G
Ganlin Zhao 已提交
3248 3249 3250 3251
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);
3252 3253
  } else {
    GET_RES_INFO(pCtx)->isNullRes = 1;
G
Ganlin Zhao 已提交
3254 3255 3256
  }
  return functionFinalize(pCtx, pBlock);
}
3257

3258 3259
int32_t spreadPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
3260 3261 3262
  SSpreadInfo*         pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
  int32_t              resultBytes = getSpreadInfoSize();
  char*                res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275

  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;
}

3276 3277
int32_t spreadCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);
X
Xiaoyu Wang 已提交
3278
  SSpreadInfo*         pDBuf = GET_ROWCELL_INTERBUF(pDResInfo);
3279 3280

  SResultRowEntryInfo* pSResInfo = GET_RES_INFO(pSourceCtx);
X
Xiaoyu Wang 已提交
3281
  SSpreadInfo*         pSBuf = GET_ROWCELL_INTERBUF(pSResInfo);
3282
  spreadTransferInfo(pSBuf, pDBuf);
3283
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
5
54liuyao 已提交
3284
  pDResInfo->isNullRes &= pSResInfo->isNullRes;
3285 3286 3287
  return TSDB_CODE_SUCCESS;
}

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

G
Ganlin Zhao 已提交
3290 3291 3292 3293 3294
bool getElapsedFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(SElapsedInfo);
  return true;
}

X
Xiaoyu Wang 已提交
3295
bool elapsedFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
G
Ganlin Zhao 已提交
3296 3297 3298 3299 3300 3301
  if (!functionSetup(pCtx, pResultInfo)) {
    return false;
  }

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

3305
  if (pCtx->numOfParams > 1) {
G
Ganlin Zhao 已提交
3306 3307 3308 3309 3310 3311 3312 3313
    pInfo->timeUnit = pCtx->param[1].param.i;
  } else {
    pInfo->timeUnit = 1;
  }

  return true;
}

X
Xiaoyu Wang 已提交
3314
int32_t elapsedFunction(SqlFunctionCtx* pCtx) {
G
Ganlin Zhao 已提交
3315 3316 3317 3318
  int32_t numOfElems = 0;

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

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

X
Xiaoyu Wang 已提交
3323
  numOfElems = pInput->numOfRows;  // since this is the primary timestamp, no need to exclude NULL values
G
Ganlin Zhao 已提交
3324 3325 3326 3327
  if (numOfElems == 0) {
    goto _elapsed_over;
  }

H
Haojun Liao 已提交
3328
  if (pInput->colDataSMAIsSet) {
H
Hongze Cheng 已提交
3329
    if (pInfo->min == TSKEY_MAX) {
G
Ganlin Zhao 已提交
3330 3331 3332 3333 3334 3335 3336 3337 3338 3339
      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 已提交
3340
    if (0 == pInput->numOfRows) {
G
Ganlin Zhao 已提交
3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354
      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];

3355 3356
    int32_t start = pInput->startRowIndex;
    TSKEY*  ptsList = (int64_t*)colDataGetData(pCol, 0);
G
Ganlin Zhao 已提交
3357 3358
    if (pCtx->order == TSDB_ORDER_DESC) {
      if (pCtx->start.key == INT64_MIN) {
3359
        pInfo->max = (pInfo->max < ptsList[start]) ? ptsList[start] : pInfo->max;
G
Ganlin Zhao 已提交
3360 3361 3362 3363
      } else {
        pInfo->max = pCtx->start.key + 1;
      }

3364
      if (pCtx->end.key == INT64_MIN) {
L
Liu Jicong 已提交
3365 3366
        pInfo->min =
            (pInfo->min > ptsList[start + pInput->numOfRows - 1]) ? ptsList[start + pInput->numOfRows - 1] : pInfo->min;
G
Ganlin Zhao 已提交
3367
      } else {
3368
        pInfo->min = pCtx->end.key;
G
Ganlin Zhao 已提交
3369 3370 3371
      }
    } else {
      if (pCtx->start.key == INT64_MIN) {
3372
        pInfo->min = (pInfo->min > ptsList[start]) ? ptsList[start] : pInfo->min;
G
Ganlin Zhao 已提交
3373 3374 3375 3376
      } else {
        pInfo->min = pCtx->start.key;
      }

3377
      if (pCtx->end.key == INT64_MIN) {
L
Liu Jicong 已提交
3378 3379
        pInfo->max =
            (pInfo->max < ptsList[start + pInput->numOfRows - 1]) ? ptsList[start + pInput->numOfRows - 1] : pInfo->max;
G
Ganlin Zhao 已提交
3380
      } else {
3381
        pInfo->max = pCtx->end.key + 1;
G
Ganlin Zhao 已提交
3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392
      }
    }
  }

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

  return TSDB_CODE_SUCCESS;
}

3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403
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 已提交
3404
int32_t elapsedFunctionMerge(SqlFunctionCtx* pCtx) {
3405
  SInputColumnInfoData* pInput = &pCtx->input;
X
Xiaoyu Wang 已提交
3406
  SColumnInfoData*      pCol = pInput->pData[0];
3407
  ASSERT(pCol->info.type == TSDB_DATA_TYPE_BINARY);
3408 3409 3410

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

3411
  int32_t start = pInput->startRowIndex;
3412

X
Xiaoyu Wang 已提交
3413 3414
  for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
    char*         data = colDataGetData(pCol, i);
3415 3416 3417
    SElapsedInfo* pInputInfo = (SElapsedInfo*)varDataVal(data);
    elapsedTransferInfo(pInputInfo, pInfo);
  }
3418 3419 3420 3421 3422

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

G
Ganlin Zhao 已提交
3423 3424
int32_t elapsedFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SElapsedInfo* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
X
Xiaoyu Wang 已提交
3425
  double        result = (double)pInfo->max - (double)pInfo->min;
G
Ganlin Zhao 已提交
3426 3427 3428 3429 3430
  result = (result >= 0) ? result : -result;
  pInfo->result = result / pInfo->timeUnit;
  return functionFinalize(pCtx, pBlock);
}

3431 3432
int32_t elapsedPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
X
Xiaoyu Wang 已提交
3433 3434 3435
  SElapsedInfo*        pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
  int32_t              resultBytes = getElapsedInfoSize();
  char*                res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448

  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;
}

3449 3450
int32_t elapsedCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);
X
Xiaoyu Wang 已提交
3451
  SElapsedInfo*        pDBuf = GET_ROWCELL_INTERBUF(pDResInfo);
3452 3453

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

3456
  elapsedTransferInfo(pSBuf, pDBuf);
3457
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
5
54liuyao 已提交
3458
  pDResInfo->isNullRes &= pSResInfo->isNullRes;
3459 3460 3461
  return TSDB_CODE_SUCCESS;
}

3462 3463 3464 3465
int32_t getHistogramInfoSize() {
  return (int32_t)sizeof(SHistoFuncInfo) + HISTOGRAM_MAX_BINS_NUM * sizeof(SHistoFuncBin);
}

3466 3467 3468 3469 3470
bool getHistogramFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(SHistoFuncInfo) + HISTOGRAM_MAX_BINS_NUM * sizeof(SHistoFuncBin);
  return true;
}

X
Xiaoyu Wang 已提交
3471
static int8_t getHistogramBinType(char* binTypeStr) {
3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485
  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 已提交
3486
static bool getHistogramBinDesc(SHistoFuncInfo* pInfo, char* binDescStr, int8_t binType, bool normalized) {
3487 3488 3489 3490 3491 3492 3493
  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) {
3494
      cJSON_Delete(binDesc);
3495 3496 3497
      return false;
    }

X
Xiaoyu Wang 已提交
3498 3499 3500 3501
    cJSON* start = cJSON_GetObjectItem(binDesc, "start");
    cJSON* factor = cJSON_GetObjectItem(binDesc, "factor");
    cJSON* width = cJSON_GetObjectItem(binDesc, "width");
    cJSON* count = cJSON_GetObjectItem(binDesc, "count");
3502 3503 3504
    cJSON* infinity = cJSON_GetObjectItem(binDesc, "infinity");

    if (!cJSON_IsNumber(start) || !cJSON_IsNumber(count) || !cJSON_IsBool(infinity)) {
3505
      cJSON_Delete(binDesc);
3506 3507 3508
      return false;
    }

X
Xiaoyu Wang 已提交
3509
    if (count->valueint <= 0 || count->valueint > 1000) {  // limit count to 1000
3510
      cJSON_Delete(binDesc);
3511 3512 3513 3514 3515
      return false;
    }

    if (isinf(start->valuedouble) || (width != NULL && isinf(width->valuedouble)) ||
        (factor != NULL && isinf(factor->valuedouble)) || (count != NULL && isinf(count->valuedouble))) {
3516
      cJSON_Delete(binDesc);
3517 3518 3519
      return false;
    }

3520
    int32_t counter = (int32_t)count->valueint;
3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533
    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);
3534
        cJSON_Delete(binDesc);
3535 3536 3537 3538 3539 3540
        return false;
      }
      for (int i = 0; i < counter + 1; ++i) {
        intervals[startIndex] = start->valuedouble + i * width->valuedouble;
        if (isinf(intervals[startIndex])) {
          taosMemoryFree(intervals);
3541
          cJSON_Delete(binDesc);
3542 3543 3544 3545 3546 3547 3548 3549
          return false;
        }
        startIndex++;
      }
    } else if (cJSON_IsNumber(factor) && width == NULL && binType == LOG_BIN) {
      // log bin process
      if (start->valuedouble == 0) {
        taosMemoryFree(intervals);
3550
        cJSON_Delete(binDesc);
3551 3552 3553 3554
        return false;
      }
      if (factor->valuedouble < 0 || factor->valuedouble == 0 || factor->valuedouble == 1) {
        taosMemoryFree(intervals);
3555
        cJSON_Delete(binDesc);
3556 3557 3558 3559 3560 3561
        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);
3562
          cJSON_Delete(binDesc);
3563 3564 3565 3566 3567 3568
          return false;
        }
        startIndex++;
      }
    } else {
      taosMemoryFree(intervals);
3569
      cJSON_Delete(binDesc);
3570 3571 3572 3573 3574 3575 3576
      return false;
    }

    if (infinity->valueint == true) {
      intervals[0] = -INFINITY;
      intervals[numOfBins - 1] = INFINITY;
      // in case of desc bin orders, -inf/inf should be swapped
3577
      ASSERT(numOfBins >= 4);
3578 3579 3580 3581 3582 3583
      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) {
3584
      cJSON_Delete(binDesc);
3585 3586
      return false;
    }
3587
    numOfBins = cJSON_GetArraySize(binDesc);
3588 3589 3590 3591
    intervals = taosMemoryCalloc(numOfBins, sizeof(double));
    cJSON* bin = binDesc->child;
    if (bin == NULL) {
      taosMemoryFree(intervals);
3592
      cJSON_Delete(binDesc);
3593 3594 3595 3596 3597 3598 3599
      return false;
    }
    int i = 0;
    while (bin) {
      intervals[i] = bin->valuedouble;
      if (!cJSON_IsNumber(bin)) {
        taosMemoryFree(intervals);
3600
        cJSON_Delete(binDesc);
3601 3602 3603 3604
        return false;
      }
      if (i != 0 && intervals[i] <= intervals[i - 1]) {
        taosMemoryFree(intervals);
3605
        cJSON_Delete(binDesc);
3606 3607 3608 3609 3610 3611
        return false;
      }
      bin = bin->next;
      i++;
    }
  } else {
3612
    cJSON_Delete(binDesc);
3613 3614 3615
    return false;
  }

X
Xiaoyu Wang 已提交
3616
  pInfo->numOfBins = numOfBins - 1;
3617
  pInfo->normalized = normalized;
3618
  for (int32_t i = 0; i < pInfo->numOfBins; ++i) {
3619 3620 3621 3622 3623 3624
    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);
3625 3626
  cJSON_Delete(binDesc);

3627 3628 3629
  return true;
}

X
Xiaoyu Wang 已提交
3630
bool histogramFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
3631 3632 3633 3634
  if (!functionSetup(pCtx, pResultInfo)) {
    return false;
  }

X
Xiaoyu Wang 已提交
3635
  SHistoFuncInfo* pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
3636 3637 3638
  pInfo->numOfBins = 0;
  pInfo->totalCount = 0;
  pInfo->normalized = 0;
3639

L
Liu Jicong 已提交
3640
  char*  binTypeStr = strndup(varDataVal(pCtx->param[1].param.pz), varDataLen(pCtx->param[1].param.pz));
3641 3642 3643
  int8_t binType = getHistogramBinType(binTypeStr);
  taosMemoryFree(binTypeStr);

3644 3645 3646
  if (binType == UNKNOWN_BIN) {
    return false;
  }
3647
  char*   binDesc = strndup(varDataVal(pCtx->param[2].param.pz), varDataLen(pCtx->param[2].param.pz));
3648
  int64_t normalized = pCtx->param[3].param.i;
3649
  if (normalized != 0 && normalized != 1) {
G
Ganlin Zhao 已提交
3650
    taosMemoryFree(binDesc);
3651 3652
    return false;
  }
3653
  if (!getHistogramBinDesc(pInfo, binDesc, binType, (bool)normalized)) {
3654
    taosMemoryFree(binDesc);
3655 3656
    return false;
  }
3657
  taosMemoryFree(binDesc);
3658 3659 3660 3661

  return true;
}

3662
static int32_t histogramFunctionImpl(SqlFunctionCtx* pCtx, bool isPartial) {
3663 3664 3665 3666 3667 3668 3669 3670 3671 3672
  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;

3673
  int32_t numOfElems = 0;
3674 3675 3676 3677 3678
  for (int32_t i = start; i < numOfRows + start; ++i) {
    if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) {
      continue;
    }

3679 3680
    numOfElems++;

X
Xiaoyu Wang 已提交
3681
    char*  data = colDataGetData(pCol, i);
3682 3683 3684 3685 3686 3687
    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++;
3688
        pInfo->totalCount++;
3689 3690 3691
        break;
      }
    }
3692 3693
  }

3694
  if (!isPartial) {
3695
    GET_RES_INFO(pCtx)->numOfRes = pInfo->numOfBins;
3696
  } else {
3697
    GET_RES_INFO(pCtx)->numOfRes = 1;
3698
  }
3699 3700 3701
  return TSDB_CODE_SUCCESS;
}

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

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

3706 3707
static void histogramTransferInfo(SHistoFuncInfo* pInput, SHistoFuncInfo* pOutput) {
  pOutput->normalized = pInput->normalized;
X
Xiaoyu Wang 已提交
3708
  pOutput->numOfBins = pInput->numOfBins;
3709 3710 3711 3712 3713 3714 3715 3716
  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 已提交
3717
int32_t histogramFunctionMerge(SqlFunctionCtx* pCtx) {
3718
  SInputColumnInfoData* pInput = &pCtx->input;
X
Xiaoyu Wang 已提交
3719
  SColumnInfoData*      pCol = pInput->pData[0];
3720
  ASSERT(pCol->info.type == TSDB_DATA_TYPE_BINARY);
3721 3722 3723

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

3724
  int32_t start = pInput->startRowIndex;
3725

X
Xiaoyu Wang 已提交
3726 3727
  for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
    char*           data = colDataGetData(pCol, i);
3728 3729 3730
    SHistoFuncInfo* pInputInfo = (SHistoFuncInfo*)varDataVal(data);
    histogramTransferInfo(pInputInfo, pInfo);
  }
3731

G
Ganlin Zhao 已提交
3732
  SET_VAL(GET_RES_INFO(pCtx), pInfo->numOfBins, pInfo->numOfBins);
3733 3734 3735
  return TSDB_CODE_SUCCESS;
}

3736
int32_t histogramFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
3737
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
X
Xiaoyu Wang 已提交
3738 3739 3740
  SHistoFuncInfo*      pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
  int32_t              slotId = pCtx->pExpr->base.resSchema.slotId;
  SColumnInfoData*     pCol = taosArrayGet(pBlock->pDataBlock, slotId);
3741 3742 3743

  int32_t currentRow = pBlock->info.rows;

3744 3745
  if (pInfo->normalized) {
    for (int32_t k = 0; k < pResInfo->numOfRes; ++k) {
X
Xiaoyu Wang 已提交
3746
      if (pInfo->totalCount != 0) {
3747 3748 3749 3750 3751 3752 3753
        pInfo->bins[k].percentage = pInfo->bins[k].count / (double)pInfo->totalCount;
      } else {
        pInfo->bins[k].percentage = 0;
      }
    }
  }

3754
  for (int32_t i = 0; i < pResInfo->numOfRes; ++i) {
3755
    int32_t len;
X
Xiaoyu Wang 已提交
3756
    char    buf[512] = {0};
3757
    if (!pInfo->normalized) {
X
Xiaoyu Wang 已提交
3758 3759
      len = sprintf(varDataVal(buf), "{\"lower_bin\":%g, \"upper_bin\":%g, \"count\":%" PRId64 "}",
                    pInfo->bins[i].lower, pInfo->bins[i].upper, pInfo->bins[i].count);
3760
    } else {
X
Xiaoyu Wang 已提交
3761 3762
      len = sprintf(varDataVal(buf), "{\"lower_bin\":%g, \"upper_bin\":%g, \"count\":%lf}", pInfo->bins[i].lower,
                    pInfo->bins[i].upper, pInfo->bins[i].percentage);
3763 3764 3765 3766 3767 3768
    }
    varDataSetLen(buf, len);
    colDataAppend(pCol, currentRow, buf, false);
    currentRow++;
  }

3769
  return pResInfo->numOfRes;
3770
}
3771

3772
int32_t histogramPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
3773
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
X
Xiaoyu Wang 已提交
3774 3775 3776
  SHistoFuncInfo*      pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
  int32_t              resultBytes = getHistogramInfoSize();
  char*                res = taosMemoryCalloc(resultBytes + VARSTR_HEADER_SIZE, sizeof(char));
3777 3778 3779 3780 3781 3782 3783 3784 3785 3786

  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);
3787
  return pResInfo->numOfRes;
3788 3789
}

3790 3791 3792 3793 3794 3795 3796
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);

3797
  histogramTransferInfo(pSBuf, pDBuf);
3798
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
5
54liuyao 已提交
3799
  pDResInfo->isNullRes &= pSResInfo->isNullRes;
3800 3801 3802
  return TSDB_CODE_SUCCESS;
}

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

3805 3806 3807 3808 3809
bool getHLLFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(SHLLInfo);
  return true;
}

X
Xiaoyu Wang 已提交
3810
static uint8_t hllCountNum(void* data, int32_t bytes, int32_t* buk) {
3811
  uint64_t hash = MurmurHash3_64(data, bytes);
X
Xiaoyu Wang 已提交
3812
  int32_t  index = hash & HLL_BUCKET_MASK;
3813 3814 3815
  hash >>= HLL_BUCKET_BITS;
  hash |= ((uint64_t)1 << HLL_DATA_BITS);
  uint64_t bit = 1;
X
Xiaoyu Wang 已提交
3816 3817
  uint8_t  count = 1;
  while ((hash & bit) == 0) {
3818 3819 3820 3821 3822 3823 3824
    count++;
    bit <<= 1;
  }
  *buk = index;
  return count;
}

X
Xiaoyu Wang 已提交
3825 3826 3827
static void hllBucketHisto(uint8_t* buckets, int32_t* bucketHisto) {
  uint64_t* word = (uint64_t*)buckets;
  uint8_t*  bytes;
3828

X
Xiaoyu Wang 已提交
3829
  for (int32_t j = 0; j < HLL_BUCKETS >> 3; j++) {
3830 3831 3832
    if (*word == 0) {
      bucketHisto[0] += 8;
    } else {
X
Xiaoyu Wang 已提交
3833
      bytes = (uint8_t*)word;
3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854
      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 已提交
3855 3856
    z -= pow(1 - x, 2) * y;
  } while (zPrime != z);
3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869
  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 已提交
3870
  } while (zPrime != z);
3871 3872 3873
  return z;
}

X
Xiaoyu Wang 已提交
3874 3875 3876 3877
// 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;
3878
  int32_t buckethisto[64] = {0};
X
Xiaoyu Wang 已提交
3879
  hllBucketHisto(buckets, buckethisto);
3880

X
Xiaoyu Wang 已提交
3881
  double z = m * hllTau((m - buckethisto[HLL_DATA_BITS + 1]) / (double)m);
3882 3883 3884 3885
  for (int j = HLL_DATA_BITS; j >= 1; --j) {
    z += buckethisto[j];
    z *= 0.5;
  }
3886

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

X
Xiaoyu Wang 已提交
3890
  return (uint64_t)E;
3891 3892
}

X
Xiaoyu Wang 已提交
3893
int32_t hllFunction(SqlFunctionCtx* pCtx) {
3894 3895 3896 3897 3898
  SHLLInfo* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));

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

X
Xiaoyu Wang 已提交
3899
  int32_t type = pCol->info.type;
3900 3901 3902 3903 3904 3905
  int32_t bytes = pCol->info.bytes;

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

  int32_t numOfElems = 0;
G
Ganlin Zhao 已提交
3906 3907 3908 3909
  if (IS_NULL_TYPE(type)) {
    goto _hll_over;
  }

3910 3911 3912 3913 3914 3915 3916 3917 3918
  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 已提交
3919
      bytes = varDataLen(data);
3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930
      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 已提交
3931
_hll_over:
3932 3933 3934 3935 3936 3937 3938 3939
  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);
  }

3940 3941 3942
  return TSDB_CODE_SUCCESS;
}

3943 3944 3945 3946 3947 3948
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];
    }
  }
3949
  pOutput->totalCount += pInput->totalCount;
3950 3951
}

X
Xiaoyu Wang 已提交
3952
int32_t hllFunctionMerge(SqlFunctionCtx* pCtx) {
G
Ganlin Zhao 已提交
3953
  SInputColumnInfoData* pInput = &pCtx->input;
X
Xiaoyu Wang 已提交
3954
  SColumnInfoData*      pCol = pInput->pData[0];
G
Ganlin Zhao 已提交
3955 3956 3957 3958

  if (pCol->info.type != TSDB_DATA_TYPE_BINARY) {
    return TSDB_CODE_SUCCESS;
  }
G
Ganlin Zhao 已提交
3959 3960 3961

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

3962
  int32_t start = pInput->startRowIndex;
G
Ganlin Zhao 已提交
3963

X
Xiaoyu Wang 已提交
3964 3965
  for (int32_t i = start; i < start + pInput->numOfRows; ++i) {
    char*     data = colDataGetData(pCol, i);
3966 3967 3968
    SHLLInfo* pInputInfo = (SHLLInfo*)varDataVal(data);
    hllTransferInfo(pInputInfo, pInfo);
  }
G
Ganlin Zhao 已提交
3969

3970 3971 3972 3973 3974 3975
  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 已提交
3976 3977 3978
  return TSDB_CODE_SUCCESS;
}

3979
int32_t hllFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
X
Xiaoyu Wang 已提交
3980
  SResultRowEntryInfo* pInfo = GET_RES_INFO(pCtx);
3981

3982 3983 3984 3985 3986
  SHLLInfo* pHllInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
  pHllInfo->result = hllCountCnt(pHllInfo->buckets);
  if (tsCountAlwaysReturnValue && pHllInfo->result == 0) {
    pInfo->numOfRes = 1;
  }
3987 3988 3989 3990

  return functionFinalize(pCtx, pBlock);
}

G
Ganlin Zhao 已提交
3991 3992
int32_t hllPartialFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
X
Xiaoyu Wang 已提交
3993 3994 3995
  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 已提交
3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008

  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;
}

4009 4010
int32_t hllCombine(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) {
  SResultRowEntryInfo* pDResInfo = GET_RES_INFO(pDestCtx);
X
Xiaoyu Wang 已提交
4011
  SHLLInfo*            pDBuf = GET_ROWCELL_INTERBUF(pDResInfo);
4012 4013

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

4016
  hllTransferInfo(pSBuf, pDBuf);
4017
  pDResInfo->numOfRes = TMAX(pDResInfo->numOfRes, pSResInfo->numOfRes);
5
54liuyao 已提交
4018
  pDResInfo->isNullRes &= pSResInfo->isNullRes;
4019 4020 4021
  return TSDB_CODE_SUCCESS;
}

4022 4023 4024 4025 4026
bool getStateFuncEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(SStateInfo);
  return true;
}

X
Xiaoyu Wang 已提交
4027
static int8_t getStateOpType(char* opStr) {
4028
  int8_t opType;
4029
  if (strncasecmp(opStr, "LT", 2) == 0) {
4030
    opType = STATE_OPER_LT;
4031
  } else if (strncasecmp(opStr, "GT", 2) == 0) {
4032
    opType = STATE_OPER_GT;
4033
  } else if (strncasecmp(opStr, "LE", 2) == 0) {
4034
    opType = STATE_OPER_LE;
4035
  } else if (strncasecmp(opStr, "GE", 2) == 0) {
4036
    opType = STATE_OPER_GE;
4037
  } else if (strncasecmp(opStr, "NE", 2) == 0) {
4038
    opType = STATE_OPER_NE;
4039
  } else if (strncasecmp(opStr, "EQ", 2) == 0) {
4040 4041 4042 4043 4044 4045 4046 4047 4048 4049
    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 已提交
4050
  switch (pCol->info.type) {
4051
    case TSDB_DATA_TYPE_TINYINT: {
X
Xiaoyu Wang 已提交
4052
      int8_t v = *(int8_t*)data;
4053 4054 4055 4056
      STATE_COMP(op, v, param);
      break;
    }
    case TSDB_DATA_TYPE_UTINYINT: {
X
Xiaoyu Wang 已提交
4057
      uint8_t v = *(uint8_t*)data;
4058 4059 4060 4061
      STATE_COMP(op, v, param);
      break;
    }
    case TSDB_DATA_TYPE_SMALLINT: {
X
Xiaoyu Wang 已提交
4062
      int16_t v = *(int16_t*)data;
4063 4064 4065 4066
      STATE_COMP(op, v, param);
      break;
    }
    case TSDB_DATA_TYPE_USMALLINT: {
X
Xiaoyu Wang 已提交
4067
      uint16_t v = *(uint16_t*)data;
4068 4069 4070 4071
      STATE_COMP(op, v, param);
      break;
    }
    case TSDB_DATA_TYPE_INT: {
X
Xiaoyu Wang 已提交
4072
      int32_t v = *(int32_t*)data;
4073 4074 4075 4076
      STATE_COMP(op, v, param);
      break;
    }
    case TSDB_DATA_TYPE_UINT: {
X
Xiaoyu Wang 已提交
4077
      uint32_t v = *(uint32_t*)data;
4078 4079 4080 4081
      STATE_COMP(op, v, param);
      break;
    }
    case TSDB_DATA_TYPE_BIGINT: {
X
Xiaoyu Wang 已提交
4082
      int64_t v = *(int64_t*)data;
4083 4084 4085 4086
      STATE_COMP(op, v, param);
      break;
    }
    case TSDB_DATA_TYPE_UBIGINT: {
X
Xiaoyu Wang 已提交
4087
      uint64_t v = *(uint64_t*)data;
4088 4089 4090 4091
      STATE_COMP(op, v, param);
      break;
    }
    case TSDB_DATA_TYPE_FLOAT: {
X
Xiaoyu Wang 已提交
4092
      float v = *(float*)data;
4093 4094 4095 4096
      STATE_COMP(op, v, param);
      break;
    }
    case TSDB_DATA_TYPE_DOUBLE: {
X
Xiaoyu Wang 已提交
4097
      double v = *(double*)data;
4098 4099 4100 4101
      STATE_COMP(op, v, param);
      break;
    }
    default: {
4102
      ASSERT(0);
4103 4104 4105 4106 4107 4108 4109 4110 4111 4112
    }
  }
  return false;
}

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

  SInputColumnInfoData* pInput = &pCtx->input;
4113
  TSKEY*                tsList = (int64_t*)pInput->pPTS->pData;
4114 4115 4116

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

X
Xiaoyu Wang 已提交
4117
  int32_t          numOfElems = 0;
4118 4119 4120
  SColumnInfoData* pOutput = (SColumnInfoData*)pCtx->pOutput;

  int8_t op = getStateOpType(varDataVal(pCtx->param[1].param.pz));
4121 4122 4123 4124
  if (STATE_OPER_INVALID == op) {
    return 0;
  }

4125
  for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
4126 4127 4128 4129 4130 4131 4132
    if (pInfo->isPrevTsSet == true && tsList[i] == pInfo->prevTs) {
      return TSDB_CODE_FUNC_DUP_TIMESTAMP;
    } else {
      pInfo->prevTs = tsList[i];
    }

    pInfo->isPrevTsSet = true;
4133
    numOfElems++;
4134

4135 4136
    if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
      colDataAppendNULL(pOutput, i);
4137 4138
      // handle selectivity
      if (pCtx->subsidiaries.num > 0) {
D
dapan1121 已提交
4139
        appendSelectivityValue(pCtx, i, pCtx->offset + numOfElems - 1);
4140
      }
4141 4142 4143
      continue;
    }

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

4146 4147 4148 4149 4150 4151
    int64_t output = -1;
    if (ret) {
      output = ++pInfo->count;
    } else {
      pInfo->count = 0;
    }
D
dapan1121 已提交
4152
    colDataAppend(pOutput, pCtx->offset + numOfElems - 1, (char*)&output, false);
4153 4154 4155

    // handle selectivity
    if (pCtx->subsidiaries.num > 0) {
D
dapan1121 已提交
4156
      appendSelectivityValue(pCtx, i, pCtx->offset + numOfElems - 1);
4157
    }
4158 4159
  }

4160 4161
  pResInfo->numOfRes = numOfElems;
  return TSDB_CODE_SUCCESS;
4162
}
4163 4164 4165 4166 4167 4168

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

  SInputColumnInfoData* pInput = &pCtx->input;
X
Xiaoyu Wang 已提交
4169
  TSKEY*                tsList = (int64_t*)pInput->pPTS->pData;
4170 4171 4172

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

X
Xiaoyu Wang 已提交
4173
  int32_t          numOfElems = 0;
4174 4175
  SColumnInfoData* pOutput = (SColumnInfoData*)pCtx->pOutput;

X
Xiaoyu Wang 已提交
4176
  // TODO: process timeUnit for different db precisions
4177
  int32_t timeUnit = 1;
X
Xiaoyu Wang 已提交
4178
  if (pCtx->numOfParams == 5) {  // TODO: param number incorrect
4179 4180 4181 4182 4183
    timeUnit = pCtx->param[3].param.i;
  }

  int8_t op = getStateOpType(varDataVal(pCtx->param[1].param.pz));
  if (STATE_OPER_INVALID == op) {
4184
    return TSDB_CODE_INVALID_PARA;
4185 4186 4187
  }

  for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
4188 4189 4190 4191 4192 4193 4194
    if (pInfo->isPrevTsSet == true && tsList[i] == pInfo->prevTs) {
      return TSDB_CODE_FUNC_DUP_TIMESTAMP;
    } else {
      pInfo->prevTs = tsList[i];
    }

    pInfo->isPrevTsSet = true;
4195
    numOfElems++;
4196

4197 4198
    if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
      colDataAppendNULL(pOutput, i);
4199 4200
      // handle selectivity
      if (pCtx->subsidiaries.num > 0) {
D
dapan1121 已提交
4201
        appendSelectivityValue(pCtx, i, pCtx->offset + numOfElems - 1);
4202
      }
4203 4204 4205
      continue;
    }

X
Xiaoyu Wang 已提交
4206
    bool    ret = checkStateOp(op, pInputCol, i, pCtx->param[2].param);
4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217
    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 已提交
4218
    colDataAppend(pOutput, pCtx->offset + numOfElems - 1, (char*)&output, false);
4219 4220 4221

    // handle selectivity
    if (pCtx->subsidiaries.num > 0) {
D
dapan1121 已提交
4222
      appendSelectivityValue(pCtx, i, pCtx->offset + numOfElems - 1);
4223
    }
4224 4225
  }

4226 4227
  pResInfo->numOfRes = numOfElems;
  return TSDB_CODE_SUCCESS;
4228
}
G
Ganlin Zhao 已提交
4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239

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;
4240
  TSKEY*                tsList = (int64_t*)pInput->pPTS->pData;
G
Ganlin Zhao 已提交
4241 4242 4243 4244 4245 4246 4247 4248

  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) {
4249 4250 4251 4252 4253 4254 4255
    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 已提交
4256 4257
    int32_t pos = startOffset + numOfElems;
    if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
X
Xiaoyu Wang 已提交
4258
      // colDataAppendNULL(pOutput, i);
G
Ganlin Zhao 已提交
4259 4260 4261 4262 4263 4264 4265 4266
      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 已提交
4267
      colDataAppend(pOutput, pos, (char*)&pSumRes->isum, false);
G
Ganlin Zhao 已提交
4268 4269 4270 4271
    } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
      uint64_t v;
      GET_TYPED_DATA(v, uint64_t, type, data);
      pSumRes->usum += v;
X
Xiaoyu Wang 已提交
4272
      colDataAppend(pOutput, pos, (char*)&pSumRes->usum, false);
G
Ganlin Zhao 已提交
4273 4274 4275 4276
    } else if (IS_FLOAT_TYPE(type)) {
      double v;
      GET_TYPED_DATA(v, double, type, data);
      pSumRes->dsum += v;
X
Xiaoyu Wang 已提交
4277
      // check for overflow
4278 4279
      if (isinf(pSumRes->dsum) || isnan(pSumRes->dsum)) {
        colDataAppendNULL(pOutput, pos);
X
Xiaoyu Wang 已提交
4280 4281
      } else {
        colDataAppend(pOutput, pos, (char*)&pSumRes->dsum, false);
4282
      }
G
Ganlin Zhao 已提交
4283 4284
    }

4285 4286 4287 4288 4289
    // handle selectivity
    if (pCtx->subsidiaries.num > 0) {
      appendSelectivityValue(pCtx, i, pos);
    }

G
Ganlin Zhao 已提交
4290 4291 4292
    numOfElems++;
  }

4293 4294
  pResInfo->numOfRes = numOfElems;
  return TSDB_CODE_SUCCESS;
G
Ganlin Zhao 已提交
4295
}
G
Ganlin Zhao 已提交
4296 4297 4298 4299 4300 4301

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

X
Xiaoyu Wang 已提交
4302
bool mavgFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
G
Ganlin Zhao 已提交
4303 4304 4305 4306
  if (!functionSetup(pCtx, pResultInfo)) {
    return false;
  }

X
Xiaoyu Wang 已提交
4307
  SMavgInfo* pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
G
Ganlin Zhao 已提交
4308 4309
  pInfo->pos = 0;
  pInfo->sum = 0;
4310 4311
  pInfo->prevTs = -1;
  pInfo->isPrevTsSet = false;
G
Ganlin Zhao 已提交
4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325
  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;
4326
  TSKEY*                tsList = (int64_t*)pInput->pPTS->pData;
G
Ganlin Zhao 已提交
4327 4328 4329 4330 4331 4332 4333 4334 4335

  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) {
4336 4337 4338 4339 4340 4341 4342
    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 已提交
4343 4344
    int32_t pos = startOffset + numOfElems;
    if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
X
Xiaoyu Wang 已提交
4345
      // colDataAppendNULL(pOutput, i);
G
Ganlin Zhao 已提交
4346 4347 4348
      continue;
    }

X
Xiaoyu Wang 已提交
4349
    char*  data = colDataGetData(pInputCol, i);
G
Ganlin Zhao 已提交
4350 4351 4352 4353 4354 4355 4356 4357
    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 已提交
4358
        pInfo->sum += v;
G
Ganlin Zhao 已提交
4359 4360 4361 4362 4363
        pInfo->pointsMeet = true;
      } else {
        pInfo->sum = pInfo->sum + v - pInfo->points[pInfo->pos];
      }

G
Ganlin Zhao 已提交
4364 4365
      pInfo->points[pInfo->pos] = v;
      double result = pInfo->sum / pInfo->numOfPoints;
X
Xiaoyu Wang 已提交
4366
      // check for overflow
4367 4368
      if (isinf(result) || isnan(result)) {
        colDataAppendNULL(pOutput, pos);
X
Xiaoyu Wang 已提交
4369 4370
      } else {
        colDataAppend(pOutput, pos, (char*)&result, false);
4371
      }
G
Ganlin Zhao 已提交
4372

4373 4374 4375 4376 4377
      // handle selectivity
      if (pCtx->subsidiaries.num > 0) {
        appendSelectivityValue(pCtx, i, pos);
      }

G
Ganlin Zhao 已提交
4378
      numOfElems++;
G
Ganlin Zhao 已提交
4379 4380
    }

G
Ganlin Zhao 已提交
4381 4382 4383 4384
    pInfo->pos++;
    if (pInfo->pos == pInfo->numOfPoints) {
      pInfo->pos = 0;
    }
G
Ganlin Zhao 已提交
4385 4386
  }

4387 4388
  pResInfo->numOfRes = numOfElems;
  return TSDB_CODE_SUCCESS;
G
Ganlin Zhao 已提交
4389
}
G
Ganlin Zhao 已提交
4390

4391 4392 4393 4394 4395 4396 4397 4398 4399 4400
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 已提交
4401 4402
bool getSampleFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
  SColumnNode* pCol = (SColumnNode*)nodesListGetNode(pFunc->pParameterList, 0);
X
Xiaoyu Wang 已提交
4403 4404
  SValueNode*  pVal = (SValueNode*)nodesListGetNode(pFunc->pParameterList, 1);
  int32_t      numOfSamples = pVal->datum.i;
4405
  pEnv->calcMemSize = sizeof(SSampleInfo) + numOfSamples * (pCol->node.resType.bytes + sizeof(STuplePos));
G
Ganlin Zhao 已提交
4406 4407 4408
  return true;
}

X
Xiaoyu Wang 已提交
4409
bool sampleFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
G
Ganlin Zhao 已提交
4410 4411 4412 4413 4414 4415
  if (!functionSetup(pCtx, pResultInfo)) {
    return false;
  }

  taosSeedRand(taosSafeRand());

X
Xiaoyu Wang 已提交
4416
  SSampleInfo* pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
G
Ganlin Zhao 已提交
4417 4418 4419
  pInfo->samples = pCtx->param[1].param.i;
  pInfo->totalPoints = 0;
  pInfo->numSampled = 0;
G
Ganlin Zhao 已提交
4420 4421
  pInfo->colType = pCtx->resDataInfo.type;
  pInfo->colBytes = pCtx->resDataInfo.bytes;
4422 4423
  pInfo->nullTuplePos.pageId = -1;
  pInfo->nullTupleSaved = false;
X
Xiaoyu Wang 已提交
4424
  pInfo->data = (char*)pInfo + sizeof(SSampleInfo);
4425
  pInfo->tuplePos = (STuplePos*)((char*)pInfo + sizeof(SSampleInfo) + pInfo->samples * pInfo->colBytes);
G
Ganlin Zhao 已提交
4426 4427 4428 4429

  return true;
}

4430
static void sampleAssignResult(SSampleInfo* pInfo, char* data, int32_t index) {
G
Ganlin Zhao 已提交
4431
  assignVal(pInfo->data + index * pInfo->colBytes, data, pInfo->colBytes, pInfo->colType);
G
Ganlin Zhao 已提交
4432 4433
}

4434
static void doReservoirSample(SqlFunctionCtx* pCtx, SSampleInfo* pInfo, char* data, int32_t index) {
G
Ganlin Zhao 已提交
4435 4436
  pInfo->totalPoints++;
  if (pInfo->numSampled < pInfo->samples) {
4437 4438
    sampleAssignResult(pInfo, data, pInfo->numSampled);
    if (pCtx->subsidiaries.num > 0) {
L
Liu Jicong 已提交
4439
      pInfo->tuplePos[pInfo->numSampled] = saveTupleData(pCtx, index, pCtx->pSrcBlock);
4440
    }
G
Ganlin Zhao 已提交
4441 4442 4443 4444
    pInfo->numSampled++;
  } else {
    int32_t j = taosRand() % (pInfo->totalPoints);
    if (j < pInfo->samples) {
4445 4446
      sampleAssignResult(pInfo, data, j);
      if (pCtx->subsidiaries.num > 0) {
4447
        updateTupleData(pCtx, index, pCtx->pSrcBlock, &pInfo->tuplePos[j]);
4448
      }
G
Ganlin Zhao 已提交
4449 4450 4451 4452 4453 4454
    }
  }
}

int32_t sampleFunction(SqlFunctionCtx* pCtx) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
4455
  SSampleInfo*         pInfo = getSampleOutputInfo(pCtx);
G
Ganlin Zhao 已提交
4456 4457 4458

  SInputColumnInfoData* pInput = &pCtx->input;

4459
  SColumnInfoData* pInputCol = pInput->pData[0];
G
Ganlin Zhao 已提交
4460
  for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
4461
    if (colDataIsNull_s(pInputCol, i)) {
G
Ganlin Zhao 已提交
4462 4463 4464 4465
      continue;
    }

    char* data = colDataGetData(pInputCol, i);
4466
    doReservoirSample(pCtx, pInfo, data, i);
G
Ganlin Zhao 已提交
4467 4468
  }

4469
  if (pInfo->numSampled == 0 && pCtx->subsidiaries.num > 0 && !pInfo->nullTupleSaved) {
L
Liu Jicong 已提交
4470
    pInfo->nullTuplePos = saveTupleData(pCtx, pInput->startRowIndex, pCtx->pSrcBlock);
4471 4472 4473
    pInfo->nullTupleSaved = true;
  }

4474 4475 4476 4477 4478 4479 4480
  SET_VAL(pResInfo, pInfo->numSampled, pInfo->numSampled);
  return TSDB_CODE_SUCCESS;
}

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

4481
  SSampleInfo* pInfo = getSampleOutputInfo(pCtx);
4482 4483
  pEntryInfo->complete = true;

X
Xiaoyu Wang 已提交
4484
  int32_t          slotId = pCtx->pExpr->base.resSchema.slotId;
4485 4486 4487
  SColumnInfoData* pCol = taosArrayGet(pBlock->pDataBlock, slotId);

  int32_t currentRow = pBlock->info.rows;
4488 4489
  if (pInfo->numSampled == 0) {
    colDataAppendNULL(pCol, currentRow);
4490
    setSelectivityValue(pCtx, pBlock, &pInfo->nullTuplePos, currentRow);
4491 4492
    return pInfo->numSampled;
  }
G
Ganlin Zhao 已提交
4493
  for (int32_t i = 0; i < pInfo->numSampled; ++i) {
4494
    colDataAppend(pCol, currentRow + i, pInfo->data + i * pInfo->colBytes, false);
4495
    setSelectivityValue(pCtx, pBlock, &pInfo->tuplePos[i], currentRow + i);
G
Ganlin Zhao 已提交
4496 4497
  }

G
Ganlin Zhao 已提交
4498 4499 4500
  return pInfo->numSampled;
}

G
Ganlin Zhao 已提交
4501
bool getTailFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
4502
#if 0
G
Ganlin Zhao 已提交
4503 4504
  SColumnNode* pCol = (SColumnNode*)nodesListGetNode(pFunc->pParameterList, 0);
  SValueNode*  pVal = (SValueNode*)nodesListGetNode(pFunc->pParameterList, 1);
X
Xiaoyu Wang 已提交
4505
  int32_t      numOfPoints = pVal->datum.i;
G
Ganlin Zhao 已提交
4506
  pEnv->calcMemSize = sizeof(STailInfo) + numOfPoints * (POINTER_BYTES + sizeof(STailItem) + pCol->node.resType.bytes);
4507
#endif
G
Ganlin Zhao 已提交
4508 4509 4510
  return true;
}

X
Xiaoyu Wang 已提交
4511
bool tailFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
4512
#if 0
G
Ganlin Zhao 已提交
4513 4514 4515 4516
  if (!functionSetup(pCtx, pResultInfo)) {
    return false;
  }

X
Xiaoyu Wang 已提交
4517
  STailInfo* pInfo = GET_ROWCELL_INTERBUF(pResultInfo);
G
Ganlin Zhao 已提交
4518 4519
  pInfo->numAdded = 0;
  pInfo->numOfPoints = pCtx->param[1].param.i;
4520 4521 4522 4523 4524
  if (pCtx->numOfParams == 4) {
    pInfo->offset = pCtx->param[2].param.i;
  } else {
    pInfo->offset = 0;
  }
G
Ganlin Zhao 已提交
4525 4526 4527 4528 4529 4530 4531
  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 已提交
4532 4533
  pInfo->pItems = (STailItem**)((char*)pInfo + sizeof(STailInfo));
  char* pItem = (char*)pInfo->pItems + pInfo->numOfPoints * POINTER_BYTES;
G
Ganlin Zhao 已提交
4534

G
Ganlin Zhao 已提交
4535
  size_t unitSize = sizeof(STailItem) + pInfo->colBytes;
G
Ganlin Zhao 已提交
4536
  for (int32_t i = 0; i < pInfo->numOfPoints; ++i) {
X
Xiaoyu Wang 已提交
4537
    pInfo->pItems[i] = (STailItem*)(pItem + i * unitSize);
4538
    pInfo->pItems[i]->isNull = false;
G
Ganlin Zhao 已提交
4539
  }
4540
#endif
G
Ganlin Zhao 已提交
4541 4542 4543 4544

  return true;
}

X
Xiaoyu Wang 已提交
4545
static void tailAssignResult(STailItem* pItem, char* data, int32_t colBytes, TSKEY ts, bool isNull) {
4546
#if 0
G
Ganlin Zhao 已提交
4547
  pItem->timestamp = ts;
4548 4549 4550
  if (isNull) {
    pItem->isNull = true;
  } else {
4551
    pItem->isNull = false;
4552 4553
    memcpy(pItem->data, data, colBytes);
  }
4554
#endif
G
Ganlin Zhao 已提交
4555 4556
}

4557
#if 0
X
Xiaoyu Wang 已提交
4558 4559 4560
static int32_t tailCompFn(const void* p1, const void* p2, const void* param) {
  STailItem* d1 = *(STailItem**)p1;
  STailItem* d2 = *(STailItem**)p2;
G
Ganlin Zhao 已提交
4561 4562 4563
  return compareInt64Val(&d1->timestamp, &d2->timestamp);
}

X
Xiaoyu Wang 已提交
4564 4565
static void doTailAdd(STailInfo* pInfo, char* data, TSKEY ts, bool isNull) {
  STailItem** pList = pInfo->pItems;
G
Ganlin Zhao 已提交
4566
  if (pInfo->numAdded < pInfo->numOfPoints) {
4567
    tailAssignResult(pList[pInfo->numAdded], data, pInfo->colBytes, ts, isNull);
X
Xiaoyu Wang 已提交
4568
    taosheapsort((void*)pList, sizeof(STailItem**), pInfo->numAdded + 1, NULL, tailCompFn, 0);
G
Ganlin Zhao 已提交
4569
    pInfo->numAdded++;
G
Ganlin Zhao 已提交
4570
  } else if (pList[0]->timestamp < ts) {
4571
    tailAssignResult(pList[0], data, pInfo->colBytes, ts, isNull);
X
Xiaoyu Wang 已提交
4572
    taosheapadjust((void*)pList, sizeof(STailItem**), 0, pInfo->numOfPoints - 1, NULL, tailCompFn, NULL, 0);
G
Ganlin Zhao 已提交
4573 4574
  }
}
4575
#endif
G
Ganlin Zhao 已提交
4576 4577

int32_t tailFunction(SqlFunctionCtx* pCtx) {
4578
#if 0
G
Ganlin Zhao 已提交
4579
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
X
Xiaoyu Wang 已提交
4580
  STailInfo*           pInfo = GET_ROWCELL_INTERBUF(pResInfo);
G
Ganlin Zhao 已提交
4581 4582

  SInputColumnInfoData* pInput = &pCtx->input;
X
Xiaoyu Wang 已提交
4583
  TSKEY*                tsList = (int64_t*)pInput->pPTS->pData;
G
Ganlin Zhao 已提交
4584 4585 4586 4587 4588

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

  int32_t startOffset = pCtx->offset;
4589 4590 4591
  if (pInfo->offset >= pInput->numOfRows) {
    return 0;
  } else {
wafwerar's avatar
wafwerar 已提交
4592
    pInfo->numOfPoints = TMIN(pInfo->numOfPoints, pInput->numOfRows - pInfo->offset);
4593 4594
  }
  for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex - pInfo->offset; i += 1) {
G
Ganlin Zhao 已提交
4595
    char* data = colDataGetData(pInputCol, i);
4596
    doTailAdd(pInfo, data, tsList[i], colDataIsNull_s(pInputCol, i));
G
Ganlin Zhao 已提交
4597 4598
  }

4599 4600
  taosqsort(pInfo->pItems, pInfo->numOfPoints, POINTER_BYTES, NULL, tailCompFn);

G
Ganlin Zhao 已提交
4601
  for (int32_t i = 0; i < pInfo->numOfPoints; ++i) {
X
Xiaoyu Wang 已提交
4602 4603
    int32_t    pos = startOffset + i;
    STailItem* pItem = pInfo->pItems[i];
4604 4605 4606 4607 4608
    if (pItem->isNull) {
      colDataAppendNULL(pOutput, pos);
    } else {
      colDataAppend(pOutput, pos, pItem->data, false);
    }
G
Ganlin Zhao 已提交
4609 4610
  }

G
Ganlin Zhao 已提交
4611
  return pInfo->numOfPoints;
4612 4613
#endif
  return 0;
G
Ganlin Zhao 已提交
4614
}
G
Ganlin Zhao 已提交
4615 4616

int32_t tailFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
4617
#if 0
G
Ganlin Zhao 已提交
4618
  SResultRowEntryInfo* pEntryInfo = GET_RES_INFO(pCtx);
X
Xiaoyu Wang 已提交
4619
  STailInfo*           pInfo = GET_ROWCELL_INTERBUF(pEntryInfo);
G
Ganlin Zhao 已提交
4620 4621 4622 4623 4624 4625 4626 4627 4628 4629
  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 已提交
4630
    STailItem* pItem = pInfo->pItems[i];
G
Ganlin Zhao 已提交
4631 4632 4633 4634 4635
    colDataAppend(pCol, currentRow, pItem->data, false);
    currentRow += 1;
  }

  return pEntryInfo->numOfRes;
4636 4637
#endif
  return 0;
G
Ganlin Zhao 已提交
4638
}
4639 4640

bool getUniqueFuncEnv(SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
4641
#if 0
4642
  pEnv->calcMemSize = sizeof(SUniqueInfo) + UNIQUE_MAX_RESULT_SIZE;
4643
#endif
4644 4645 4646 4647
  return true;
}

bool uniqueFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
4648
#if 0
4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661
  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);
  }
4662
#endif
4663 4664 4665
  return true;
}

4666
#if 0
X
Xiaoyu Wang 已提交
4667 4668
static void doUniqueAdd(SUniqueInfo* pInfo, char* data, TSKEY ts, bool isNull) {
  // handle null elements
4669
  if (isNull == true) {
X
Xiaoyu Wang 已提交
4670 4671
    int32_t      size = sizeof(SUniqueItem) + pInfo->colBytes;
    SUniqueItem* pItem = (SUniqueItem*)(pInfo->pItems + pInfo->numOfPoints * size);
4672
    if (pInfo->hasNull == false && pItem->isNull == false) {
4673 4674 4675
      pItem->timestamp = ts;
      pItem->isNull = true;
      pInfo->numOfPoints++;
4676
      pInfo->hasNull = true;
4677 4678 4679 4680 4681
    } else if (pItem->timestamp > ts && pItem->isNull == true) {
      pItem->timestamp = ts;
    }
    return;
  }
4682

X
Xiaoyu Wang 已提交
4683 4684
  int32_t      hashKeyBytes = IS_VAR_DATA_TYPE(pInfo->colType) ? varDataTLen(data) : pInfo->colBytes;
  SUniqueItem* pHashItem = taosHashGet(pInfo->pHash, data, hashKeyBytes);
4685
  if (pHashItem == NULL) {
X
Xiaoyu Wang 已提交
4686 4687
    int32_t      size = sizeof(SUniqueItem) + pInfo->colBytes;
    SUniqueItem* pItem = (SUniqueItem*)(pInfo->pItems + pInfo->numOfPoints * size);
4688 4689 4690
    pItem->timestamp = ts;
    memcpy(pItem->data, data, pInfo->colBytes);

X
Xiaoyu Wang 已提交
4691
    taosHashPut(pInfo->pHash, data, hashKeyBytes, (char*)pItem, sizeof(SUniqueItem*));
4692 4693 4694 4695 4696
    pInfo->numOfPoints++;
  } else if (pHashItem->timestamp > ts) {
    pHashItem->timestamp = ts;
  }
}
4697
#endif
4698 4699

int32_t uniqueFunction(SqlFunctionCtx* pCtx) {
4700
#if 0
4701 4702 4703 4704
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  SUniqueInfo*         pInfo = GET_ROWCELL_INTERBUF(pResInfo);

  SInputColumnInfoData* pInput = &pCtx->input;
X
Xiaoyu Wang 已提交
4705
  TSKEY*                tsList = (int64_t*)pInput->pPTS->pData;
4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722

  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 已提交
4723
    SUniqueItem* pItem = (SUniqueItem*)(pInfo->pItems + i * (sizeof(SUniqueItem) + pInfo->colBytes));
4724 4725 4726 4727 4728
    if (pItem->isNull == true) {
      colDataAppendNULL(pOutput, i);
    } else {
      colDataAppend(pOutput, i, pItem->data, false);
    }
4729 4730 4731 4732 4733 4734
    if (pTsOutput != NULL) {
      colDataAppendInt64(pTsOutput, i, &pItem->timestamp);
    }
  }

  return pInfo->numOfPoints;
4735 4736
#endif
  return 0;
4737 4738
}

G
Ganlin Zhao 已提交
4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757
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);
  }
4758 4759 4760
  pInfo->nullTupleSaved = false;
  pInfo->nullTuplePos.pageId = -1;

G
Ganlin Zhao 已提交
4761 4762 4763
  return true;
}

4764
static void doModeAdd(SModeInfo* pInfo, int32_t rowIndex, SqlFunctionCtx* pCtx, char* data) {
4765
  int32_t     hashKeyBytes = IS_STR_DATA_TYPE(pInfo->colType) ? varDataTLen(data) : pInfo->colBytes;
4766
  SModeItem** pHashItem = taosHashGet(pInfo->pHash, data, hashKeyBytes);
G
Ganlin Zhao 已提交
4767
  if (pHashItem == NULL) {
4768 4769
    int32_t    size = sizeof(SModeItem) + pInfo->colBytes;
    SModeItem* pItem = (SModeItem*)(pInfo->pItems + pInfo->numOfPoints * size);
4770
    memcpy(pItem->data, data, hashKeyBytes);
G
Ganlin Zhao 已提交
4771 4772
    pItem->count += 1;

4773
    if (pCtx->subsidiaries.num > 0) {
L
Liu Jicong 已提交
4774
      pItem->tuplePos = saveTupleData(pCtx, rowIndex, pCtx->pSrcBlock);
4775 4776
    }

G
Ganlin Zhao 已提交
4777
    taosHashPut(pInfo->pHash, data, hashKeyBytes, &pItem, sizeof(SModeItem*));
G
Ganlin Zhao 已提交
4778 4779
    pInfo->numOfPoints++;
  } else {
G
Ganlin Zhao 已提交
4780
    (*pHashItem)->count += 1;
4781 4782 4783
    if (pCtx->subsidiaries.num > 0) {
      updateTupleData(pCtx, rowIndex, pCtx->pSrcBlock, &((*pHashItem)->tuplePos));
    }
G
Ganlin Zhao 已提交
4784 4785 4786 4787
  }
}

int32_t modeFunction(SqlFunctionCtx* pCtx) {
4788
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
4789
  SModeInfo*           pInfo = GET_ROWCELL_INTERBUF(pResInfo);
G
Ganlin Zhao 已提交
4790 4791 4792 4793 4794 4795

  SInputColumnInfoData* pInput = &pCtx->input;

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

4796
  int32_t numOfElems = 0;
G
Ganlin Zhao 已提交
4797 4798
  int32_t startOffset = pCtx->offset;
  for (int32_t i = pInput->startRowIndex; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
4799 4800 4801 4802
    if (colDataIsNull_s(pInputCol, i)) {
      continue;
    }
    numOfElems++;
4803 4804

    char* data = colDataGetData(pInputCol, i);
4805
    doModeAdd(pInfo, i, pCtx, data);
G
Ganlin Zhao 已提交
4806 4807 4808 4809 4810 4811 4812

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

4813
  if (numOfElems == 0 && pCtx->subsidiaries.num > 0 && !pInfo->nullTupleSaved) {
L
Liu Jicong 已提交
4814
    pInfo->nullTuplePos = saveTupleData(pCtx, pInput->startRowIndex, pCtx->pSrcBlock);
4815 4816 4817
    pInfo->nullTupleSaved = true;
  }

4818
  SET_VAL(pResInfo, numOfElems, 1);
G
Ganlin Zhao 已提交
4819

G
Ganlin Zhao 已提交
4820 4821 4822 4823 4824 4825
  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 已提交
4826 4827
  int32_t              slotId = pCtx->pExpr->base.resSchema.slotId;
  SColumnInfoData*     pCol = taosArrayGet(pBlock->pDataBlock, slotId);
G
Ganlin Zhao 已提交
4828
  int32_t              currentRow = pBlock->info.rows;
4829

G
Ganlin Zhao 已提交
4830
  int32_t resIndex = -1;
G
Ganlin Zhao 已提交
4831 4832 4833
  int32_t maxCount = 0;
  for (int32_t i = 0; i < pInfo->numOfPoints; ++i) {
    SModeItem* pItem = (SModeItem*)(pInfo->pItems + i * (sizeof(SModeItem) + pInfo->colBytes));
4834
    if (pItem->count >= maxCount) {
G
Ganlin Zhao 已提交
4835 4836 4837
      maxCount = pItem->count;
      resIndex = i;
    }
4838 4839
  }

G
Ganlin Zhao 已提交
4840 4841 4842
  if (maxCount != 0) {
    SModeItem* pResItem = (SModeItem*)(pInfo->pItems + resIndex * (sizeof(SModeItem) + pInfo->colBytes));
    colDataAppend(pCol, currentRow, pResItem->data, false);
4843
    setSelectivityValue(pCtx, pBlock, &pResItem->tuplePos, currentRow);
G
Ganlin Zhao 已提交
4844 4845
  } else {
    colDataAppendNULL(pCol, currentRow);
4846
    setSelectivityValue(pCtx, pBlock, &pInfo->nullTuplePos, currentRow);
G
Ganlin Zhao 已提交
4847
  }
G
Ganlin Zhao 已提交
4848

G
Ganlin Zhao 已提交
4849 4850
  taosHashCleanup(pInfo->pHash);

4851 4852 4853
  return pResInfo->numOfRes;
}

4854 4855 4856 4857 4858
bool getTwaFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(STwaInfo);
  return true;
}

X
Xiaoyu Wang 已提交
4859
bool twaFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
4860 4861 4862 4863
  if (!functionSetup(pCtx, pResultInfo)) {
    return false;
  }

X
Xiaoyu Wang 已提交
4864
  STwaInfo* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
4865
  pInfo->isNull = false;
4866 4867
  pInfo->p.key = INT64_MIN;
  pInfo->win = TSWINDOW_INITIALIZER;
4868 4869 4870 4871
  return true;
}

static double twa_get_area(SPoint1 s, SPoint1 e) {
4872 4873 4874 4875
  if (e.key == INT64_MAX || s.key == INT64_MIN) {
    return 0;
  }

X
Xiaoyu Wang 已提交
4876
  if ((s.val >= 0 && e.val >= 0) || (s.val <= 0 && e.val <= 0)) {
4877 4878 4879
    return (s.val + e.val) * (e.key - s.key) / 2;
  }

X
Xiaoyu Wang 已提交
4880
  double x = (s.key * e.val - e.key * s.val) / (e.val - s.val);
4881 4882 4883 4884 4885 4886
  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 已提交
4887
  SColumnInfoData*      pInputCol = pInput->pData[0];
4888 4889 4890

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

X
Xiaoyu Wang 已提交
4891
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
4892

X
Xiaoyu Wang 已提交
4893 4894
  STwaInfo* pInfo = GET_ROWCELL_INTERBUF(pResInfo);
  SPoint1*  last = &pInfo->p;
4895
  int32_t   numOfElems = 0;
4896

4897 4898 4899 4900 4901
  if (IS_NULL_TYPE(pInputCol->info.type)) {
    pInfo->isNull = true;
    goto _twa_over;
  }

4902 4903
  int32_t i = pInput->startRowIndex;
  if (pCtx->start.key != INT64_MIN) {
4904
    // ASSERT((pCtx->start.key < tsList[i] && pCtx->order == TSDB_ORDER_ASC) ||
4905
    //        (pCtx->start.key > tsList[i] && pCtx->order == TSDB_ORDER_DESC));
4906

4907
    ASSERT(last->key == INT64_MIN);
4908 4909 4910 4911
    for (; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
      if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
        continue;
      }
4912

4913
      last->key = tsList[i];
4914

4915 4916 4917 4918 4919 4920 4921 4922
      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;
    }
4923
  } else if (pInfo->p.key == INT64_MIN) {
4924 4925 4926 4927
    for (; i < pInput->numOfRows + pInput->startRowIndex; ++i) {
      if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
        continue;
      }
4928

4929 4930 4931 4932 4933 4934 4935 4936 4937
      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;
    }
4938 4939
  }

4940 4941
  SPoint1 st = {0};

4942
  // calculate the value of
X
Xiaoyu Wang 已提交
4943
  switch (pInputCol->info.type) {
4944
    case TSDB_DATA_TYPE_TINYINT: {
X
Xiaoyu Wang 已提交
4945
      int8_t* val = (int8_t*)colDataGetData(pInputCol, 0);
4946
      for (; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
4947 4948 4949
        if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
          continue;
        }
4950
        numOfElems++;
4951

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

4957 4958 4959 4960 4961 4962 4963
        pInfo->dOutput += twa_get_area(pInfo->p, st);
        pInfo->p = st;
      }
      break;
    }

    case TSDB_DATA_TYPE_SMALLINT: {
X
Xiaoyu Wang 已提交
4964
      int16_t* val = (int16_t*)colDataGetData(pInputCol, 0);
4965
      for (; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
4966 4967 4968
        if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
          continue;
        }
4969
        numOfElems++;
4970

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

5102 5103 5104 5105 5106 5107
        pInfo->dOutput += twa_get_area(pInfo->p, st);
        pInfo->p = st;
      }
      break;
    }
    case TSDB_DATA_TYPE_UBIGINT: {
X
Xiaoyu Wang 已提交
5108
      uint64_t* val = (uint64_t*)colDataGetData(pInputCol, 0);
5109
      for (; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
5110 5111 5112
        if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
          continue;
        }
5113
        numOfElems++;
5114

5115
        INIT_INTP_POINT(st, tsList[i], val[i]);
5116
        if (pInfo->p.key == st.key) {
5117
          return TSDB_CODE_FUNC_DUP_TIMESTAMP;
5118 5119
        }

5120 5121 5122 5123 5124 5125
        pInfo->dOutput += twa_get_area(pInfo->p, st);
        pInfo->p = st;
      }
      break;
    }

X
Xiaoyu Wang 已提交
5126
    default:
5127
      ASSERT(0);
5128 5129 5130 5131
  }

  // the last interpolated time window value
  if (pCtx->end.key != INT64_MIN) {
X
Xiaoyu Wang 已提交
5132
    pInfo->dOutput += twa_get_area(pInfo->p, pCtx->end);
5133
    pInfo->p = pCtx->end;
H
Haojun Liao 已提交
5134
    numOfElems += 1;
5135 5136
  }

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

5139
_twa_over:
5140 5141 5142 5143 5144
  if (numOfElems == 0) {
    pInfo->isNull = true;
  }

  SET_VAL(pResInfo, 1, 1);
5145 5146 5147 5148 5149 5150 5151 5152
  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 已提交
5153 5154 5155
// void twa_function_copy(SQLFunctionCtx *pCtx) {
//   assert(pCtx->inputType == TSDB_DATA_TYPE_BINARY);
//   SResultRowEntryInfo *pResInfo = GET_RES_INFO(pCtx);
5156
//
X
Xiaoyu Wang 已提交
5157 5158 5159
//   memcpy(GET_ROWCELL_INTERBUF(pResInfo), pCtx->pInput, (size_t)pCtx->inputBytes);
//   pResInfo->hasResult = ((STwaInfo *)pCtx->pInput)->hasResult;
// }
5160

X
Xiaoyu Wang 已提交
5161 5162
int32_t twaFinalize(struct SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
5163

X
Xiaoyu Wang 已提交
5164
  STwaInfo* pInfo = (STwaInfo*)GET_ROWCELL_INTERBUF(pResInfo);
5165 5166
  if (pInfo->isNull == true) {
    pResInfo->numOfRes = 0;
5167 5168 5169
  } else {
    if (pInfo->win.ekey == pInfo->win.skey) {
      pInfo->dOutput = pInfo->p.val;
5170
    } else if (pInfo->win.ekey == INT64_MAX || pInfo->win.skey == INT64_MIN) {  // no data in timewindow
5171
      pInfo->dOutput = 0;
5172 5173 5174 5175 5176 5177 5178 5179 5180 5181
    } else {
      pInfo->dOutput = pInfo->dOutput / (pInfo->win.ekey - pInfo->win.skey);
    }

    pResInfo->numOfRes = 1;
  }

  return functionFinalize(pCtx, pBlock);
}

5182
bool blockDistSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo) {
5183 5184 5185 5186 5187 5188 5189 5190 5191
  if (!functionSetup(pCtx, pResultInfo)) {
    return false;
  }

  STableBlockDistInfo* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
  pInfo->minRows = INT32_MAX;
  return true;
}

X
Xiaoyu Wang 已提交
5192
int32_t blockDistFunction(SqlFunctionCtx* pCtx) {
5193 5194
  const int32_t BLOCK_DIST_RESULT_ROWS = 24;

5195
  SInputColumnInfoData* pInput = &pCtx->input;
X
Xiaoyu Wang 已提交
5196
  SColumnInfoData*      pInputCol = pInput->pData[0];
5197

X
Xiaoyu Wang 已提交
5198
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
5199

5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211
  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;

5212 5213
  pDistInfo->defMinRows = p1.defMinRows;
  pDistInfo->defMaxRows = p1.defMaxRows;
5214
  pDistInfo->rowSize = p1.rowSize;
5215 5216
  pDistInfo->numOfSmallBlocks = p1.numOfSmallBlocks;

5217 5218 5219 5220 5221 5222 5223
  if (pDistInfo->minRows > p1.minRows) {
    pDistInfo->minRows = p1.minRows;
  }
  if (pDistInfo->maxRows < p1.maxRows) {
    pDistInfo->maxRows = p1.maxRows;
  }

X
Xiaoyu Wang 已提交
5224
  for (int32_t i = 0; i < tListLen(pDistInfo->blockRowsHisto); ++i) {
5225 5226 5227
    pDistInfo->blockRowsHisto[i] += p1.blockRowsHisto[i];
  }

5228
  pResInfo->numOfRes = BLOCK_DIST_RESULT_ROWS;  // default output rows
5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239
  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;
5240
  if (tEncodeU32(&encoder, pInfo->numOfBlocks) < 0) return -1;
5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251
  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 已提交
5252
  for (int32_t i = 0; i < tListLen(pInfo->blockRowsHisto); ++i) {
5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270
    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;
5271
  if (tDecodeU32(&decoder, &pInfo->numOfBlocks) < 0) return -1;
5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282
  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 已提交
5283
  for (int32_t i = 0; i < tListLen(pInfo->blockRowsHisto); ++i) {
5284 5285 5286 5287 5288 5289 5290 5291
    if (tDecodeI32(&decoder, &pInfo->blockRowsHisto[i]) < 0) return -1;
  }

  tDecoderClear(&decoder);
  return 0;
}

int32_t blockDistFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
X
Xiaoyu Wang 已提交
5292
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
5293
  STableBlockDistInfo* pData = GET_ROWCELL_INTERBUF(pResInfo);
5294

5295 5296
  SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, 0);

H
Haojun Liao 已提交
5297 5298 5299 5300
  if (pData->totalRows == 0) {
    pData->minRows = 0;
  }

5301
  int32_t row = 0;
X
Xiaoyu Wang 已提交
5302
  char    st[256] = {0};
5303 5304 5305 5306 5307 5308 5309 5310 5311 5312
  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;
  }

5313 5314
  int32_t len = sprintf(st + VARSTR_HEADER_SIZE,
                        "Total_Blocks=[%d] Total_Size=[%.2f Kb] Average_size=[%.2f Kb] Compression_Ratio=[%.2f %c]",
L
Liu Jicong 已提交
5315
                        pData->numOfBlocks, pData->totalSize / 1024.0, averageSize / 1024.0, compRatio, '%');
5316 5317 5318

  varDataSetLen(st, len);
  colDataAppend(pColInfo, row++, st, false);
5319

H
Haojun Liao 已提交
5320 5321 5322 5323 5324
  int64_t avgRows = 0;
  if (pData->numOfBlocks > 0) {
    avgRows = pData->totalRows / pData->numOfBlocks;
  }

5325 5326
  len = sprintf(st + VARSTR_HEADER_SIZE,
                "Total_Rows=[%" PRId64 "] Inmem_Rows=[%d] MinRows=[%d] MaxRows=[%d] Average_Rows=[%" PRId64 "]",
H
Haojun Liao 已提交
5327
                pData->totalRows, pData->numOfInmemRows, pData->minRows, pData->maxRows, avgRows);
5328

5329 5330
  varDataSetLen(st, len);
  colDataAppend(pColInfo, row++, st, false);
5331

5332 5333
  len = sprintf(st + VARSTR_HEADER_SIZE, "Total_Tables=[%d] Total_Files=[%d] Total_Vgroups=[%d]", pData->numOfTables,
                pData->numOfFiles, 0);
5334 5335 5336 5337

  varDataSetLen(st, len);
  colDataAppend(pColInfo, row++, st, false);

X
Xiaoyu Wang 已提交
5338 5339
  len = sprintf(st + VARSTR_HEADER_SIZE,
                "--------------------------------------------------------------------------------");
5340 5341
  varDataSetLen(st, len);
  colDataAppend(pColInfo, row++, st, false);
5342 5343 5344

  int32_t maxVal = 0;
  int32_t minVal = INT32_MAX;
5345 5346 5347
  for (int32_t i = 0; i < tListLen(pData->blockRowsHisto); ++i) {
    if (maxVal < pData->blockRowsHisto[i]) {
      maxVal = pData->blockRowsHisto[i];
5348 5349
    }

5350 5351
    if (minVal > pData->blockRowsHisto[i]) {
      minVal = pData->blockRowsHisto[i];
5352 5353 5354
    }
  }

5355 5356
  // maximum number of step is 80
  double factor = pData->numOfBlocks / 80.0;
5357 5358

  int32_t numOfBuckets = sizeof(pData->blockRowsHisto) / sizeof(pData->blockRowsHisto[0]);
5359
  int32_t bucketRange = (pData->defMaxRows - pData->defMinRows) / numOfBuckets;
5360

5361
  for (int32_t i = 0; i < tListLen(pData->blockRowsHisto); ++i) {
5362
    len = sprintf(st + VARSTR_HEADER_SIZE, "%04d |", pData->defMinRows + bucketRange * i);
5363

5364
    int32_t num = 0;
5365 5366
    if (pData->blockRowsHisto[i] > 0) {
      num = (pData->blockRowsHisto[i]) / factor;
5367
    }
5368 5369 5370

    for (int32_t j = 0; j < num; ++j) {
      int32_t x = sprintf(st + VARSTR_HEADER_SIZE + len, "%c", '|');
5371 5372 5373
      len += x;
    }

5374 5375 5376 5377
    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, '%');
    }
5378 5379 5380

    varDataSetLen(st, len);
    colDataAppend(pColInfo, row++, st, false);
5381 5382
  }

5383
  return TSDB_CODE_SUCCESS;
5384
}
5385 5386 5387 5388 5389 5390

bool getDerivativeFuncEnv(struct SFunctionNode* pFunc, SFuncExecEnv* pEnv) {
  pEnv->calcMemSize = sizeof(SDerivInfo);
  return true;
}

5391
bool derivativeFuncSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
5392 5393 5394 5395 5396 5397 5398
  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;
5399
  pDerivInfo->prevTs = -1;
5400 5401 5402 5403 5404
  pDerivInfo->tsWindow = pCtx->param[1].param.i;
  pDerivInfo->valueSet = false;
  return true;
}

5405 5406 5407
int32_t derivativeFunction(SqlFunctionCtx* pCtx) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
  SDerivInfo*          pDerivInfo = GET_ROWCELL_INTERBUF(pResInfo);
5408 5409

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

5412
  int32_t          numOfElems = 0;
5413 5414 5415 5416
  SColumnInfoData* pOutput = (SColumnInfoData*)pCtx->pOutput;
  SColumnInfoData* pTsOutput = pCtx->pTsOutput;

  int32_t i = pInput->startRowIndex;
5417
  TSKEY*  tsList = (int64_t*)pInput->pPTS->pData;
5418

5419
  double v = 0;
5420

5421 5422
  if (pCtx->order == TSDB_ORDER_ASC) {
    for (; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
5423 5424 5425 5426
      if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
        continue;
      }

5427
      char* d = (char*)pInputCol->pData + pInputCol->info.bytes * i;
5428 5429 5430 5431 5432 5433
      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 {
5434 5435 5436
        if (tsList[i] == pDerivInfo->prevTs) {
          return TSDB_CODE_FUNC_DUP_TIMESTAMP;
        }
5437 5438 5439
        double r = ((v - pDerivInfo->prevValue) * pDerivInfo->tsWindow) / (tsList[i] - pDerivInfo->prevTs);
        if (pDerivInfo->ignoreNegative && r < 0) {
        } else {
5440 5441 5442 5443 5444 5445
          if (isinf(r) || isnan(r)) {
            colDataAppendNULL(pOutput, pos);
          } else {
            colDataAppend(pOutput, pos, (const char*)&r, false);
          }

5446 5447 5448
          if (pTsOutput != NULL) {
            colDataAppendInt64(pTsOutput, pos, &tsList[i]);
          }
5449 5450 5451 5452 5453 5454

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

5455 5456 5457 5458 5459 5460 5461 5462
          numOfElems++;
        }
      }

      pDerivInfo->prevValue = v;
      pDerivInfo->prevTs = tsList[i];
    }
  } else {
5463 5464 5465 5466 5467
    for (; i < pInput->numOfRows + pInput->startRowIndex; i += 1) {
      if (colDataIsNull_f(pInputCol->nullbitmap, i)) {
        continue;
      }

5468
      char* d = (char*)pInputCol->pData + pInputCol->info.bytes * i;
5469 5470 5471 5472 5473 5474
      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 {
5475 5476 5477
        if (tsList[i] == pDerivInfo->prevTs) {
          return TSDB_CODE_FUNC_DUP_TIMESTAMP;
        }
5478 5479 5480
        double r = ((pDerivInfo->prevValue - v) * pDerivInfo->tsWindow) / (pDerivInfo->prevTs - tsList[i]);
        if (pDerivInfo->ignoreNegative && r < 0) {
        } else {
5481 5482 5483 5484 5485 5486
          if (isinf(r) || isnan(r)) {
            colDataAppendNULL(pOutput, pos);
          } else {
            colDataAppend(pOutput, pos, (const char*)&r, false);
          }

5487 5488 5489
          if (pTsOutput != NULL) {
            colDataAppendInt64(pTsOutput, pos, &pDerivInfo->prevTs);
          }
5490 5491 5492 5493 5494 5495

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

5496 5497 5498
          numOfElems++;
        }
      }
5499

5500 5501 5502
      pDerivInfo->prevValue = v;
      pDerivInfo->prevTs = tsList[i];
    }
5503 5504
  }

5505 5506 5507
  pResInfo->numOfRes = numOfElems;

  return TSDB_CODE_SUCCESS;
H
Haojun Liao 已提交
5508 5509
}

G
Ganlin Zhao 已提交
5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521
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);

5522 5523
  pInfo->firstKey = INT64_MIN;
  pInfo->lastKey = INT64_MIN;
G
Ganlin Zhao 已提交
5524
  pInfo->firstValue = (double)INT64_MIN;
5525
  pInfo->lastValue = (double)INT64_MIN;
G
Ganlin Zhao 已提交
5526

5527
  pInfo->hasResult = 0;
G
Ganlin Zhao 已提交
5528 5529 5530 5531 5532
  return true;
}

int32_t irateFunction(SqlFunctionCtx* pCtx) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
5533
  SRateInfo*           pRateInfo = GET_ROWCELL_INTERBUF(pResInfo);
G
Ganlin Zhao 已提交
5534 5535 5536 5537 5538 5539

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

  SColumnInfoData* pOutput = (SColumnInfoData*)pCtx->pOutput;

5540
  TSKEY* tsList = (int64_t*)pInput->pPTS->pData;
G
Ganlin Zhao 已提交
5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551

  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++;

5552 5553
    char*  data = colDataGetData(pInputCol, i);
    double v = 0;
G
Ganlin Zhao 已提交
5554 5555 5556 5557
    GET_TYPED_DATA(v, double, type, data);

    if (INT64_MIN == pRateInfo->lastKey) {
      pRateInfo->lastValue = v;
5558
      pRateInfo->lastKey = tsList[i];
G
Ganlin Zhao 已提交
5559 5560 5561 5562 5563 5564 5565 5566 5567 5568
      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;
5569
      pRateInfo->lastKey = tsList[i];
G
Ganlin Zhao 已提交
5570 5571

      continue;
5572 5573
    } else if (tsList[i] == pRateInfo->lastKey) {
      return TSDB_CODE_FUNC_DUP_TIMESTAMP;
G
Ganlin Zhao 已提交
5574 5575 5576 5577 5578
    }

    if ((INT64_MIN == pRateInfo->firstKey) || tsList[i] > pRateInfo->firstKey) {
      pRateInfo->firstValue = v;
      pRateInfo->firstKey = tsList[i];
5579 5580
    } else if (tsList[i] == pRateInfo->firstKey) {
      return TSDB_CODE_FUNC_DUP_TIMESTAMP;
G
Ganlin Zhao 已提交
5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606
    }
  }

  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;
  }

5607
  return (duration > 0) ? ((double)diff) / (duration / tickPerSec) : 0.0;
G
Ganlin Zhao 已提交
5608 5609 5610 5611 5612 5613 5614 5615 5616 5617
}

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);
5618
  double     result = doCalcRate(pInfo, (double)TSDB_TICK_PER_SECOND(pCtx->param[1].param.i));
G
Ganlin Zhao 已提交
5619 5620 5621 5622 5623
  colDataAppend(pCol, pBlock->info.rows, (const char*)&result, pResInfo->isNullRes);

  return pResInfo->numOfRes;
}

5624 5625
int32_t groupKeyFunction(SqlFunctionCtx* pCtx) {
  SResultRowEntryInfo* pResInfo = GET_RES_INFO(pCtx);
5626
  SGroupKeyInfo*       pInfo = GET_ROWCELL_INTERBUF(pResInfo);
5627 5628

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

  int32_t startIndex = pInput->startRowIndex;
5632

5633
  // escape rest of data blocks to avoid first entry to be overwritten.
5634 5635 5636 5637
  if (pInfo->hasResult) {
    goto _group_key_over;
  }

5638
  if (colDataIsNull_s(pInputCol, startIndex)) {
5639 5640
    pInfo->isNull = true;
    pInfo->hasResult = true;
G
Ganlin Zhao 已提交
5641
    goto _group_key_over;
5642 5643 5644
  }

  char* data = colDataGetData(pInputCol, startIndex);
5645
  if (IS_VAR_DATA_TYPE(pInputCol->info.type)) {
X
Xiaoyu Wang 已提交
5646 5647
    memcpy(pInfo->data, data,
           (pInputCol->info.type == TSDB_DATA_TYPE_JSON) ? getJsonValueLen(data) : varDataTLen(data));
5648 5649 5650
  } else {
    memcpy(pInfo->data, data, pInputCol->info.bytes);
  }
5651
  pInfo->hasResult = true;
G
Ganlin Zhao 已提交
5652 5653

_group_key_over:
5654

G
Ganlin Zhao 已提交
5655
  SET_VAL(pResInfo, 1, 1);
5656 5657 5658
  return TSDB_CODE_SUCCESS;
}

G
Ganlin Zhao 已提交
5659 5660 5661 5662 5663 5664 5665
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);
5666 5667

  if (pInfo->hasResult) {
5668 5669 5670 5671
    int32_t currentRow = pBlock->info.rows;
    for (; currentRow < pBlock->info.rows + pResInfo->numOfRes; ++currentRow) {
      colDataAppend(pCol, currentRow, pInfo->data, pInfo->isNull ? true : false);
    }
5672 5673 5674
  } else {
    pResInfo->numOfRes = 0;
  }
G
Ganlin Zhao 已提交
5675 5676 5677 5678

  return pResInfo->numOfRes;
}

5679
int32_t cachedLastRowFunction(SqlFunctionCtx* pCtx) {
5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690
  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;

5691
  // last_row function does not ignore the null value
5692 5693 5694
  for (int32_t i = pInput->numOfRows + pInput->startRowIndex - 1; i >= pInput->startRowIndex; --i) {
    numOfElems++;

H
Haojun Liao 已提交
5695 5696 5697
    bool  isNull = colDataIsNull(pInputCol, pInput->numOfRows, i, NULL);
    char* data = isNull ? NULL : colDataGetData(pInputCol, i);

5698
    TSKEY cts = getRowPTs(pInput->pPTS, i);
5699
    if (pResInfo->numOfRes == 0 || pInfo->ts < cts) {
5700
      doSaveLastrow(pCtx, data, i, cts, pInfo);
5701
      pResInfo->numOfRes = 1;
5702 5703 5704 5705 5706 5707
    }
  }

  SET_VAL(pResInfo, numOfElems, 1);
  return TSDB_CODE_SUCCESS;
}