scalar.c 51.2 KB
Newer Older
H
Hongze Cheng 已提交
1
#include "scalar.h"
D
dapan1121 已提交
2 3
#include "function.h"
#include "functionMgt.h"
H
Haojun Liao 已提交
4 5
#include "nodes.h"
#include "querynodes.h"
D
dapan1121 已提交
6
#include "sclInt.h"
H
Haojun Liao 已提交
7 8
#include "sclvector.h"
#include "tcommon.h"
H
Hongze Cheng 已提交
9
#include "tcompare.h"
H
Haojun Liao 已提交
10
#include "tdatablock.h"
D
fix bug  
dapan1121 已提交
11
#include "ttime.h"
H
Hongze Cheng 已提交
12
#include "tudf.h"
D
dapan1121 已提交
13

D
dapan1121 已提交
14
int32_t scalarGetOperatorParamNum(EOperatorType type) {
H
Hongze Cheng 已提交
15 16 17
  if (OP_TYPE_IS_NULL == type || OP_TYPE_IS_NOT_NULL == type || OP_TYPE_IS_TRUE == type ||
      OP_TYPE_IS_NOT_TRUE == type || OP_TYPE_IS_FALSE == type || OP_TYPE_IS_NOT_FALSE == type ||
      OP_TYPE_IS_UNKNOWN == type || OP_TYPE_IS_NOT_UNKNOWN == type || OP_TYPE_MINUS == type) {
D
dapan1121 已提交
18 19 20 21 22 23
    return 1;
  }

  return 2;
}

H
Hongze Cheng 已提交
24 25
int32_t sclConvertToTsValueNode(int8_t precision, SValueNode *valueNode) {
  char   *timeStr = valueNode->datum.p;
X
Xiaoyu Wang 已提交
26 27
  int64_t value = 0;
  int32_t code = convertStringToTimestamp(valueNode->node.resType.type, valueNode->datum.p, precision, &value);
D
dapan1121 已提交
28 29
  if (code != TSDB_CODE_SUCCESS) {
    return code;
D
dapan 已提交
30 31
  }
  taosMemoryFree(timeStr);
X
Xiaoyu Wang 已提交
32
  valueNode->datum.i = value;
D
dapan1121 已提交
33
  valueNode->typeData = valueNode->datum.i;
G
Ganlin Zhao 已提交
34

D
dapan 已提交
35 36
  valueNode->node.resType.type = TSDB_DATA_TYPE_TIMESTAMP;
  valueNode->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_TIMESTAMP].bytes;
D
dapan1121 已提交
37 38

  return TSDB_CODE_SUCCESS;
D
dapan 已提交
39 40
}

H
Hongze Cheng 已提交
41 42
int32_t sclCreateColumnInfoData(SDataType *pType, int32_t numOfRows, SScalarParam *pParam) {
  SColumnInfoData *pColumnData = taosMemoryCalloc(1, sizeof(SColumnInfoData));
43 44
  if (pColumnData == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
H
Haojun Liao 已提交
45
    return terrno;
46 47
  }

H
Hongze Cheng 已提交
48 49 50
  pColumnData->info.type = pType->type;
  pColumnData->info.bytes = pType->bytes;
  pColumnData->info.scale = pType->scale;
51 52
  pColumnData->info.precision = pType->precision;

H
Haojun Liao 已提交
53
  int32_t code = colInfoDataEnsureCapacity(pColumnData, numOfRows, true);
54 55
  if (code != TSDB_CODE_SUCCESS) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
H
Haojun Liao 已提交
56
    taosMemoryFree(pColumnData);
H
Haojun Liao 已提交
57
    return terrno;
58
  }
H
Haojun Liao 已提交
59 60

  pParam->columnData = pColumnData;
D
dapan1121 已提交
61
  pParam->colAlloced = true;
H
Haojun Liao 已提交
62
  return TSDB_CODE_SUCCESS;
63 64
}

X
Xiaoyu Wang 已提交
65
int32_t sclConvertValueToSclParam(SValueNode *pValueNode, SScalarParam *out, int32_t *overflow) {
66
  SScalarParam in = {.numOfRows = 1};
H
Hongze Cheng 已提交
67
  int32_t      code = sclCreateColumnInfoData(&pValueNode->node.resType, 1, &in);
H
Haojun Liao 已提交
68 69 70 71
  if (code != TSDB_CODE_SUCCESS) {
    return code;
  }

72
  colDataAppend(in.columnData, 0, nodesGetValueFromNode(pValueNode), false);
73

H
Haojun Liao 已提交
74
  colInfoDataEnsureCapacity(out->columnData, 1, true);
D
dapan1121 已提交
75
  code = vectorConvertSingleColImpl(&in, out, overflow, -1, -1);
76 77 78
  sclFreeParam(&in);

  return code;
79 80
}

D
dapan1121 已提交
81
int32_t sclExtendResRows(SScalarParam *pDst, SScalarParam *pSrc, SArray *pBlockList) {
X
Xiaoyu Wang 已提交
82
  SSDataBlock  *pb = taosArrayGetP(pBlockList, 0);
D
dapan1121 已提交
83 84 85
  SScalarParam *pLeft = taosMemoryCalloc(1, sizeof(SScalarParam));
  if (NULL == pLeft) {
    sclError("calloc %d failed", (int32_t)sizeof(SScalarParam));
S
Shengliang Guan 已提交
86
    SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
D
dapan1121 已提交
87 88 89 90 91
  }

  pLeft->numOfRows = pb->info.rows;

  if (pDst->numOfRows < pb->info.rows) {
H
Haojun Liao 已提交
92
    colInfoDataEnsureCapacity(pDst->columnData, pb->info.rows, true);
D
dapan1121 已提交
93
  }
X
Xiaoyu Wang 已提交
94

D
dapan1121 已提交
95 96 97 98 99 100 101 102
  _bin_scalar_fn_t OperatorFn = getBinScalarOperatorFn(OP_TYPE_ASSIGN);
  OperatorFn(pLeft, pSrc, pDst, TSDB_ORDER_ASC);

  taosMemoryFree(pLeft);

  return TSDB_CODE_SUCCESS;
}

D
dapan1121 已提交
103 104 105 106
int32_t scalarGenerateSetFromList(void **data, void *pNode, uint32_t type) {
  SHashObj *pObj = taosHashInit(256, taosGetDefaultHashFunction(type), true, false);
  if (NULL == pObj) {
    sclError("taosHashInit failed, size:%d", 256);
S
Shengliang Guan 已提交
107
    SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
D
dapan1121 已提交
108 109
  }

G
Ganlin Zhao 已提交
110
  taosHashSetEqualFp(pObj, taosGetDefaultEqualFunction(type));
D
dapan1121 已提交
111

H
Hongze Cheng 已提交
112
  int32_t        code = 0;
D
dapan1121 已提交
113
  SNodeListNode *nodeList = (SNodeListNode *)pNode;
H
Hongze Cheng 已提交
114 115
  SListCell     *cell = nodeList->pNodeList->pHead;
  SScalarParam   out = {.columnData = taosMemoryCalloc(1, sizeof(SColumnInfoData))};
116

D
dapan1121 已提交
117
  int32_t len = 0;
H
Hongze Cheng 已提交
118
  void   *buf = NULL;
G
Ganlin Zhao 已提交
119

D
dapan1121 已提交
120 121
  for (int32_t i = 0; i < nodeList->pNodeList->length; ++i) {
    SValueNode *valueNode = (SValueNode *)cell->pNode;
G
Ganlin Zhao 已提交
122

D
dapan1121 已提交
123
    if (valueNode->node.resType.type != type) {
124
      out.columnData->info.type = type;
D
dapan1121 已提交
125 126 127 128 129 130 131 132 133
      if (IS_VAR_DATA_TYPE(type)) {
        if (IS_VAR_DATA_TYPE(valueNode->node.resType.type)) {
          out.columnData->info.bytes = valueNode->node.resType.bytes * TSDB_NCHAR_SIZE;
        } else {
          out.columnData->info.bytes = 64 * TSDB_NCHAR_SIZE;
        }
      } else {
        out.columnData->info.bytes = tDataTypes[type].bytes;
      }
134

D
dapan1121 已提交
135
      int32_t overflow = 0;
D
dapan1121 已提交
136
      code = sclConvertValueToSclParam(valueNode, &out, &overflow);
137
      if (code != TSDB_CODE_SUCCESS) {
H
Hongze Cheng 已提交
138
        //        sclError("convert data from %d to %d failed", in.type, out.type);
D
dapan1121 已提交
139 140 141
        SCL_ERR_JRET(code);
      }

D
dapan1121 已提交
142 143 144 145 146
      if (overflow) {
        cell = cell->pNext;
        continue;
      }

D
dapan1121 已提交
147
      if (IS_VAR_DATA_TYPE(type)) {
148
        buf = colDataGetVarData(out.columnData, 0);
D
dapan1121 已提交
149
        len = varDataTLen(buf);
D
dapan1121 已提交
150 151
      } else {
        len = tDataTypes[type].bytes;
152
        buf = out.columnData->pData;
D
dapan1121 已提交
153 154 155
      }
    } else {
      buf = nodesGetValueFromNode(valueNode);
D
dapan1121 已提交
156
      if (IS_VAR_DATA_TYPE(type)) {
157
        len = varDataTLen(buf);
D
dapan1121 已提交
158 159
      } else {
        len = valueNode->node.resType.bytes;
160
      }
D
dapan1121 已提交
161
    }
G
Ganlin Zhao 已提交
162

163
    if (taosHashPut(pObj, buf, (size_t)len, NULL, 0)) {
D
dapan1121 已提交
164
      sclError("taosHashPut to set failed");
S
Shengliang Guan 已提交
165
      SCL_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
D
dapan1121 已提交
166
    }
D
dapan1121 已提交
167

168
    colInfoDataCleanup(out.columnData, out.numOfRows);
D
dapan1121 已提交
169
    cell = cell->pNext;
D
dapan1121 已提交
170 171 172
  }

  *data = pObj;
D
dapan1121 已提交
173 174 175

  colDataDestroy(out.columnData);
  taosMemoryFreeClear(out.columnData);
D
dapan1121 已提交
176 177 178
  return TSDB_CODE_SUCCESS;

_return:
D
dapan1121 已提交
179 180 181

  colDataDestroy(out.columnData);
  taosMemoryFreeClear(out.columnData);
D
dapan1121 已提交
182 183 184 185
  taosHashCleanup(pObj);
  SCL_RET(code);
}

D
dapan1121 已提交
186 187
void sclFreeRes(SHashObj *res) {
  SScalarParam *p = NULL;
H
Hongze Cheng 已提交
188
  void         *pIter = taosHashIterate(res, NULL);
D
dapan1121 已提交
189 190 191 192
  while (pIter) {
    p = (SScalarParam *)pIter;

    if (p) {
D
dapan 已提交
193
      sclFreeParam(p);
D
dapan1121 已提交
194 195 196 197 198 199
    }
    pIter = taosHashIterate(res, pIter);
  }
  taosHashCleanup(res);
}

D
dapan1121 已提交
200
void sclFreeParam(SScalarParam *param) {
D
dapan1121 已提交
201
  if (NULL == param || !param->colAlloced) {
D
dapan1121 已提交
202 203
    return;
  }
H
Hongze Cheng 已提交
204

D
dapan1121 已提交
205
  if (param->columnData != NULL) {
206
    colDataDestroy(param->columnData);
207
    taosMemoryFreeClear(param->columnData);
208 209 210 211
  }

  if (param->pHashFilter != NULL) {
    taosHashCleanup(param->pHashFilter);
D
dapan1121 已提交
212
    param->pHashFilter = NULL;
213
  }
D
dapan1121 已提交
214 215
}

D
dapan1121 已提交
216 217 218 219
int32_t sclCopyValueNodeValue(SValueNode *pNode, void **res) {
  if (TSDB_DATA_TYPE_NULL == pNode->node.resType.type) {
    return TSDB_CODE_SUCCESS;
  }
G
Ganlin Zhao 已提交
220

wafwerar's avatar
wafwerar 已提交
221
  *res = taosMemoryMalloc(pNode->node.resType.bytes);
D
dapan1121 已提交
222 223
  if (NULL == (*res)) {
    sclError("malloc %d failed", pNode->node.resType.bytes);
S
Shengliang Guan 已提交
224
    SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
D
dapan1121 已提交
225 226 227 228 229 230
  }

  memcpy(*res, nodesGetValueFromNode(pNode), pNode->node.resType.bytes);
  return TSDB_CODE_SUCCESS;
}

D
dapan1121 已提交
231 232 233 234 235 236
void sclFreeParamList(SScalarParam *param, int32_t paramNum) {
  if (NULL == param) {
    return;
  }

  for (int32_t i = 0; i < paramNum; ++i) {
H
Hongze Cheng 已提交
237
    SScalarParam *p = param + i;
D
dapan1121 已提交
238 239 240 241 242 243
    sclFreeParam(p);
  }

  taosMemoryFree(param);
}

244 245 246 247 248 249
void sclDowngradeValueType(SValueNode *valueNode) {
  switch (valueNode->node.resType.type) {
    case TSDB_DATA_TYPE_BIGINT: {
      int8_t i8 = valueNode->datum.i;
      if (i8 == valueNode->datum.i) {
        valueNode->node.resType.type = TSDB_DATA_TYPE_TINYINT;
H
Hongze Cheng 已提交
250
        *(int8_t *)&valueNode->typeData = i8;
251 252 253 254 255
        break;
      }
      int16_t i16 = valueNode->datum.i;
      if (i16 == valueNode->datum.i) {
        valueNode->node.resType.type = TSDB_DATA_TYPE_SMALLINT;
H
Hongze Cheng 已提交
256
        *(int16_t *)&valueNode->typeData = i16;
257 258 259 260 261
        break;
      }
      int32_t i32 = valueNode->datum.i;
      if (i32 == valueNode->datum.i) {
        valueNode->node.resType.type = TSDB_DATA_TYPE_INT;
H
Hongze Cheng 已提交
262
        *(int32_t *)&valueNode->typeData = i32;
263 264 265 266
        break;
      }
      break;
    }
H
Hongze Cheng 已提交
267
    case TSDB_DATA_TYPE_UBIGINT: {
268 269 270 271 272
      uint8_t u8 = valueNode->datum.i;
      if (u8 == valueNode->datum.i) {
        int8_t i8 = valueNode->datum.i;
        if (i8 == valueNode->datum.i) {
          valueNode->node.resType.type = TSDB_DATA_TYPE_TINYINT;
H
Hongze Cheng 已提交
273
          *(int8_t *)&valueNode->typeData = i8;
274 275
        } else {
          valueNode->node.resType.type = TSDB_DATA_TYPE_UTINYINT;
H
Hongze Cheng 已提交
276
          *(uint8_t *)&valueNode->typeData = u8;
277 278 279 280 281 282 283 284
        }
        break;
      }
      uint16_t u16 = valueNode->datum.i;
      if (u16 == valueNode->datum.i) {
        int16_t i16 = valueNode->datum.i;
        if (i16 == valueNode->datum.i) {
          valueNode->node.resType.type = TSDB_DATA_TYPE_SMALLINT;
H
Hongze Cheng 已提交
285
          *(int16_t *)&valueNode->typeData = i16;
286 287
        } else {
          valueNode->node.resType.type = TSDB_DATA_TYPE_USMALLINT;
H
Hongze Cheng 已提交
288
          *(uint16_t *)&valueNode->typeData = u16;
289 290 291 292 293 294 295 296
        }
        break;
      }
      uint32_t u32 = valueNode->datum.i;
      if (u32 == valueNode->datum.i) {
        int32_t i32 = valueNode->datum.i;
        if (i32 == valueNode->datum.i) {
          valueNode->node.resType.type = TSDB_DATA_TYPE_INT;
H
Hongze Cheng 已提交
297
          *(int32_t *)&valueNode->typeData = i32;
298 299
        } else {
          valueNode->node.resType.type = TSDB_DATA_TYPE_UINT;
H
Hongze Cheng 已提交
300
          *(uint32_t *)&valueNode->typeData = u32;
301 302 303 304 305 306 307 308 309
        }
        break;
      }
      break;
    }
    case TSDB_DATA_TYPE_DOUBLE: {
      float f = valueNode->datum.d;
      if (FLT_EQUAL(f, valueNode->datum.d)) {
        valueNode->node.resType.type = TSDB_DATA_TYPE_FLOAT;
H
Hongze Cheng 已提交
310
        *(float *)&valueNode->typeData = f;
311 312 313 314 315 316 317 318 319
        break;
      }
      break;
    }
    default:
      break;
  }
}

H
Hongze Cheng 已提交
320
int32_t sclInitParam(SNode *node, SScalarParam *param, SScalarCtx *ctx, int32_t *rowNum) {
D
dapan1121 已提交
321
  switch (nodeType(node)) {
D
dapan1121 已提交
322
    case QUERY_NODE_LEFT_VALUE: {
H
Hongze Cheng 已提交
323
      SSDataBlock *pb = taosArrayGetP(ctx->pBlockList, 0);
D
dapan1121 已提交
324 325 326
      param->numOfRows = pb->info.rows;
      break;
    }
D
dapan1121 已提交
327 328
    case QUERY_NODE_VALUE: {
      SValueNode *valueNode = (SValueNode *)node;
329

H
Haojun Liao 已提交
330
      ASSERT(param->columnData == NULL);
331
      param->numOfRows = 1;
G
Ganlin Zhao 已提交
332 333 334 335
      int32_t code = sclCreateColumnInfoData(&valueNode->node.resType, 1, param);
      if (code != TSDB_CODE_SUCCESS) {
        SCL_RET(TSDB_CODE_OUT_OF_MEMORY);
      }
wmmhello's avatar
wmmhello 已提交
336
      if (TSDB_DATA_TYPE_NULL == valueNode->node.resType.type || valueNode->isNull) {
337
        colDataAppendNULL(param->columnData, 0);
338 339
      } else {
        colDataAppend(param->columnData, 0, nodesGetValueFromNode(valueNode), false);
D
dapan1121 已提交
340
      }
D
dapan1121 已提交
341 342
      break;
    }
D
dapan1121 已提交
343 344
    case QUERY_NODE_NODE_LIST: {
      SNodeListNode *nodeList = (SNodeListNode *)node;
345 346
      if (LIST_LENGTH(nodeList->pNodeList) <= 0) {
        sclError("invalid length in nodeList, length:%d", LIST_LENGTH(nodeList->pNodeList));
D
dapan1121 已提交
347 348 349
        SCL_RET(TSDB_CODE_QRY_INVALID_INPUT);
      }

D
dapan1121 已提交
350 351 352 353
      int32_t type = vectorGetConvertType(ctx->type.selfType, ctx->type.peerType);
      if (type == 0) {
        type = nodeList->dataType.type;
      }
G
Ganlin Zhao 已提交
354

D
dapan1121 已提交
355 356
      SCL_ERR_RET(scalarGenerateSetFromList((void **)&param->pHashFilter, node, type));
      param->hashValueType = type;
D
dapan1121 已提交
357
      param->colAlloced = true;
D
dapan 已提交
358
      if (taosHashPut(ctx->pRes, &node, POINTER_BYTES, param, sizeof(*param))) {
359
        taosHashCleanup(param->pHashFilter);
D
dapan1121 已提交
360
        param->pHashFilter = NULL;
D
dapan 已提交
361
        sclError("taosHashPut nodeList failed, size:%d", (int32_t)sizeof(*param));
S
Shengliang Guan 已提交
362
        return TSDB_CODE_OUT_OF_MEMORY;
G
Ganlin Zhao 已提交
363
      }
D
dapan1121 已提交
364
      param->colAlloced = false;
D
dapan1121 已提交
365 366
      break;
    }
X
Xiaoyu Wang 已提交
367
    case QUERY_NODE_COLUMN: {
D
dapan 已提交
368 369
      if (NULL == ctx->pBlockList) {
        sclError("invalid node type for constant calculating, type:%d, src:%p", nodeType(node), ctx->pBlockList);
S
Shengliang Guan 已提交
370
        SCL_ERR_RET(TSDB_CODE_APP_ERROR);
D
dapan1121 已提交
371
      }
G
Ganlin Zhao 已提交
372

X
Xiaoyu Wang 已提交
373
      SColumnNode *ref = (SColumnNode *)node;
374 375

      int32_t index = -1;
H
Hongze Cheng 已提交
376 377
      for (int32_t i = 0; i < taosArrayGetSize(ctx->pBlockList); ++i) {
        SSDataBlock *pb = taosArrayGetP(ctx->pBlockList, i);
H
Haojun Liao 已提交
378
        if (pb->info.id.blockId == ref->dataBlockId) {
379 380 381 382 383 384
          index = i;
          break;
        }
      }

      if (index == -1) {
H
Hongze Cheng 已提交
385 386
        sclError("column tupleId is too big, tupleId:%d, dataBlockNum:%d", ref->dataBlockId,
                 (int32_t)taosArrayGetSize(ctx->pBlockList));
D
dapan 已提交
387 388 389
        SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
      }

390
      SSDataBlock *block = *(SSDataBlock **)taosArrayGet(ctx->pBlockList, index);
G
Ganlin Zhao 已提交
391 392 393 394 395
      if (NULL == block) {
        SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
      }

      if (ref->slotId >= taosArrayGetSize(block->pDataBlock)) {
H
Hongze Cheng 已提交
396 397
        sclError("column slotId is too big, slodId:%d, dataBlockSize:%d", ref->slotId,
                 (int32_t)taosArrayGetSize(block->pDataBlock));
D
dapan1121 已提交
398 399 400
        SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
      }

D
dapan 已提交
401
      SColumnInfoData *columnData = (SColumnInfoData *)taosArrayGet(block->pDataBlock, ref->slotId);
402
#if TAG_FILTER_DEBUG
H
Hongze Cheng 已提交
403 404
      qDebug("tagfilter column info, slotId:%d, colId:%d, type:%d", ref->slotId, columnData->info.colId,
             columnData->info.type);
405
#endif
406 407
      param->numOfRows = block->info.rows;
      param->columnData = columnData;
D
dapan1121 已提交
408 409
      break;
    }
410 411
    case QUERY_NODE_FUNCTION:
    case QUERY_NODE_OPERATOR:
D
dapan1121 已提交
412 413
    case QUERY_NODE_LOGIC_CONDITION:
    case QUERY_NODE_CASE_WHEN: {
D
dapan1121 已提交
414 415 416
      SScalarParam *res = (SScalarParam *)taosHashGet(ctx->pRes, &node, POINTER_BYTES);
      if (NULL == res) {
        sclError("no result for node, type:%d, node:%p", nodeType(node), node);
S
Shengliang Guan 已提交
417
        SCL_ERR_RET(TSDB_CODE_APP_ERROR);
D
dapan1121 已提交
418 419
      }
      *param = *res;
D
dapan1121 已提交
420
      param->colAlloced = false;
D
dapan1121 已提交
421 422
      break;
    }
423 424
    default:
      break;
D
dapan1121 已提交
425 426
  }

427 428 429
  if (param->numOfRows > *rowNum) {
    if ((1 != param->numOfRows) && (1 < *rowNum)) {
      sclError("different row nums, rowNum:%d, newRowNum:%d", *rowNum, param->numOfRows);
D
dapan1121 已提交
430 431
      SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
    }
G
Ganlin Zhao 已提交
432

433
    *rowNum = param->numOfRows;
D
dapan1121 已提交
434 435
  }

436
  param->param = ctx->param;
D
dapan1121 已提交
437 438 439
  return TSDB_CODE_SUCCESS;
}

H
Hongze Cheng 已提交
440 441
int32_t sclInitParamList(SScalarParam **pParams, SNodeList *pParamList, SScalarCtx *ctx, int32_t *paramNum,
                         int32_t *rowNum) {
D
dapan1121 已提交
442
  int32_t code = 0;
D
dapan1121 已提交
443 444
  if (NULL == pParamList) {
    if (ctx->pBlockList) {
D
dapan1121 已提交
445
      SSDataBlock *pBlock = taosArrayGetP(ctx->pBlockList, 0);
D
dapan1121 已提交
446 447 448 449 450
      *rowNum = pBlock->info.rows;
    } else {
      *rowNum = 1;
    }

D
dapan 已提交
451
    *paramNum = 1;
D
dapan1121 已提交
452
  } else {
D
dapan 已提交
453
    *paramNum = pParamList->length;
D
dapan1121 已提交
454 455
  }

D
dapan 已提交
456
  SScalarParam *paramList = taosMemoryCalloc(*paramNum, sizeof(SScalarParam));
D
dapan1121 已提交
457
  if (NULL == paramList) {
D
dapan 已提交
458
    sclError("calloc %d failed", (int32_t)((*paramNum) * sizeof(SScalarParam)));
S
Shengliang Guan 已提交
459
    SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
D
dapan1121 已提交
460 461
  }

D
dapan1121 已提交
462
  if (pParamList) {
H
Hongze Cheng 已提交
463
    SNode  *tnode = NULL;
D
dapan1121 已提交
464 465
    int32_t i = 0;
    if (SCL_IS_CONST_CALC(ctx)) {
H
Hongze Cheng 已提交
466
      WHERE_EACH(tnode, pParamList) {
D
dapan1121 已提交
467
        if (!SCL_IS_CONST_NODE(tnode)) {
D
dapan 已提交
468
          WHERE_NEXT;
D
dapan1121 已提交
469 470 471 472
        } else {
          SCL_ERR_JRET(sclInitParam(tnode, &paramList[i], ctx, rowNum));
          ERASE_NODE(pParamList);
        }
G
Ganlin Zhao 已提交
473

D
dapan1121 已提交
474 475 476
        ++i;
      }
    } else {
G
Ganlin Zhao 已提交
477
      FOREACH(tnode, pParamList) {
D
dapan1121 已提交
478 479 480
        SCL_ERR_JRET(sclInitParam(tnode, &paramList[i], ctx, rowNum));
        ++i;
      }
D
dapan1121 已提交
481
    }
D
dapan1121 已提交
482 483 484
  } else {
    paramList[0].numOfRows = *rowNum;
  }
D
dapan1121 已提交
485

D
dapan1121 已提交
486
  if (0 == *rowNum) {
G
Ganlin Zhao 已提交
487
    taosMemoryFreeClear(paramList);
D
dapan1121 已提交
488
  }
D
dapan1121 已提交
489

D
dapan1121 已提交
490
  *pParams = paramList;
D
dapan1121 已提交
491
  return TSDB_CODE_SUCCESS;
D
dapan1121 已提交
492

D
dapan1121 已提交
493
_return:
wafwerar's avatar
wafwerar 已提交
494
  taosMemoryFreeClear(paramList);
D
dapan1121 已提交
495 496 497
  SCL_RET(code);
}

D
dapan1121 已提交
498 499 500 501
int32_t sclGetNodeType(SNode *pNode, SScalarCtx *ctx) {
  if (NULL == pNode) {
    return -1;
  }
G
Ganlin Zhao 已提交
502

wafwerar's avatar
wafwerar 已提交
503
  switch ((int)nodeType(pNode)) {
D
dapan1121 已提交
504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536
    case QUERY_NODE_VALUE: {
      SValueNode *valueNode = (SValueNode *)pNode;
      return valueNode->node.resType.type;
    }
    case QUERY_NODE_NODE_LIST: {
      SNodeListNode *nodeList = (SNodeListNode *)pNode;
      return nodeList->dataType.type;
    }
    case QUERY_NODE_COLUMN: {
      SColumnNode *colNode = (SColumnNode *)pNode;
      return colNode->node.resType.type;
    }
    case QUERY_NODE_FUNCTION:
    case QUERY_NODE_OPERATOR:
    case QUERY_NODE_LOGIC_CONDITION: {
      SScalarParam *res = (SScalarParam *)taosHashGet(ctx->pRes, &pNode, POINTER_BYTES);
      if (NULL == res) {
        sclError("no result for node, type:%d, node:%p", nodeType(pNode), pNode);
        return -1;
      }
      return res->columnData->info.type;
    }
  }

  return -1;
}

void sclSetOperatorValueType(SOperatorNode *node, SScalarCtx *ctx) {
  ctx->type.opResType = node->node.resType.type;
  ctx->type.selfType = sclGetNodeType(node->pLeft, ctx);
  ctx->type.peerType = sclGetNodeType(node->pRight, ctx);
}

D
dapan1121 已提交
537 538
int32_t sclInitOperatorParams(SScalarParam **pParams, SOperatorNode *node, SScalarCtx *ctx, int32_t *rowNum) {
  int32_t code = 0;
D
dapan1121 已提交
539
  int32_t paramNum = scalarGetOperatorParamNum(node->opType);
D
dapan1121 已提交
540 541 542 543
  if (NULL == node->pLeft || (paramNum == 2 && NULL == node->pRight)) {
    sclError("invalid operation node, left:%p, right:%p", node->pLeft, node->pRight);
    SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
  }
G
Ganlin Zhao 已提交
544

wafwerar's avatar
wafwerar 已提交
545
  SScalarParam *paramList = taosMemoryCalloc(paramNum, sizeof(SScalarParam));
D
dapan1121 已提交
546 547
  if (NULL == paramList) {
    sclError("calloc %d failed", (int32_t)(paramNum * sizeof(SScalarParam)));
S
Shengliang Guan 已提交
548
    SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
D
dapan1121 已提交
549 550
  }

D
dapan1121 已提交
551 552
  sclSetOperatorValueType(node, ctx);

D
dapan1121 已提交
553
  SCL_ERR_JRET(sclInitParam(node->pLeft, &paramList[0], ctx, rowNum));
D
dapan1121 已提交
554
  if (paramNum > 1) {
D
dapan1121 已提交
555
    TSWAP(ctx->type.selfType, ctx->type.peerType);
D
dapan1121 已提交
556
    SCL_ERR_JRET(sclInitParam(node->pRight, &paramList[1], ctx, rowNum));
D
dapan1121 已提交
557 558
  }

D
dapan1121 已提交
559
  *pParams = paramList;
D
dapan1121 已提交
560
  return TSDB_CODE_SUCCESS;
D
dapan1121 已提交
561 562

_return:
wafwerar's avatar
wafwerar 已提交
563
  taosMemoryFreeClear(paramList);
D
dapan1121 已提交
564
  SCL_RET(code);
D
dapan1121 已提交
565 566
}

X
Xiaoyu Wang 已提交
567
int32_t sclGetNodeRes(SNode *node, SScalarCtx *ctx, SScalarParam **res) {
D
dapan1121 已提交
568 569 570 571 572 573 574 575 576
  if (NULL == node) {
    return TSDB_CODE_SUCCESS;
  }

  int32_t rowNum = 0;
  *res = taosMemoryCalloc(1, sizeof(**res));
  if (NULL == *res) {
    SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
  }
X
Xiaoyu Wang 已提交
577

D
dapan1121 已提交
578 579 580 581 582
  SCL_ERR_RET(sclInitParam(node, *res, ctx, &rowNum));

  return TSDB_CODE_SUCCESS;
}

X
Xiaoyu Wang 已提交
583 584 585 586 587 588 589 590 591 592 593 594
int32_t sclWalkCaseWhenList(SScalarCtx *ctx, SNodeList *pList, struct SListCell *pCell, SScalarParam *pCase,
                            SScalarParam *pElse, SScalarParam *pComp, SScalarParam *output, int32_t rowIdx,
                            int32_t totalRows, bool *complete) {
  SNode         *node = NULL;
  SWhenThenNode *pWhenThen = NULL;
  SScalarParam  *pWhen = NULL;
  SScalarParam  *pThen = NULL;
  int32_t        code = 0;

  for (SListCell *cell = pCell; (NULL != cell ? (node = cell->pNode, true) : (node = NULL, false));
       cell = cell->pNext) {
    pWhenThen = (SWhenThenNode *)node;
D
dapan1121 已提交
595 596 597

    SCL_ERR_RET(sclGetNodeRes(pWhenThen->pWhen, ctx, &pWhen));
    SCL_ERR_RET(sclGetNodeRes(pWhenThen->pThen, ctx, &pThen));
X
Xiaoyu Wang 已提交
598

D
dapan1121 已提交
599
    vectorCompareImpl(pCase, pWhen, pComp, rowIdx, 1, TSDB_ORDER_ASC, OP_TYPE_EQUAL);
X
Xiaoyu Wang 已提交
600 601

    bool *equal = (bool *)colDataGetData(pComp->columnData, rowIdx);
D
dapan1121 已提交
602
    if (*equal) {
dengyihao's avatar
dengyihao 已提交
603
      bool  isNull = colDataIsNull_s(pThen->columnData, (pThen->numOfRows > 1 ? rowIdx : 0));
D
dapan1121 已提交
604 605
      char *pData = isNull ? NULL : colDataGetData(pThen->columnData, (pThen->numOfRows > 1 ? rowIdx : 0));
      colDataAppend(output->columnData, rowIdx, pData, isNull);
D
dapan1121 已提交
606 607 608 609 610

      if (0 == rowIdx && 1 == pCase->numOfRows && 1 == pWhen->numOfRows && 1 == pThen->numOfRows && totalRows > 1) {
        SCL_ERR_JRET(sclExtendResRows(output, output, ctx->pBlockList));
        *complete = true;
      }
X
Xiaoyu Wang 已提交
611

D
dapan1121 已提交
612
      goto _return;
D
dapan1121 已提交
613 614 615 616
    }
  }

  if (pElse) {
dengyihao's avatar
dengyihao 已提交
617
    bool  isNull = colDataIsNull_s(pElse->columnData, (pElse->numOfRows > 1 ? rowIdx : 0));
D
dapan1121 已提交
618 619
    char *pData = isNull ? NULL : colDataGetData(pElse->columnData, (pElse->numOfRows > 1 ? rowIdx : 0));
    colDataAppend(output->columnData, rowIdx, pData, isNull);
D
dapan1121 已提交
620 621 622 623 624

    if (0 == rowIdx && 1 == pCase->numOfRows && 1 == pElse->numOfRows && totalRows > 1) {
      SCL_ERR_JRET(sclExtendResRows(output, output, ctx->pBlockList));
      *complete = true;
    }
X
Xiaoyu Wang 已提交
625

D
dapan1121 已提交
626
    goto _return;
D
dapan1121 已提交
627 628 629 630
  }

  colDataAppend(output->columnData, rowIdx, NULL, true);

D
dapan1121 已提交
631
  if (0 == rowIdx && 1 == pCase->numOfRows && totalRows > 1) {
D
dapan1121 已提交
632 633 634 635 636
    SCL_ERR_JRET(sclExtendResRows(output, output, ctx->pBlockList));
    *complete = true;
  }

_return:
X
Xiaoyu Wang 已提交
637

D
dapan1121 已提交
638 639
  sclFreeParam(pWhen);
  sclFreeParam(pThen);
D
dapan1121 已提交
640 641
  taosMemoryFree(pWhen);
  taosMemoryFree(pThen);
D
dapan1121 已提交
642 643

  SCL_RET(code);
D
dapan1121 已提交
644 645
}

X
Xiaoyu Wang 已提交
646 647 648 649 650 651 652
int32_t sclWalkWhenList(SScalarCtx *ctx, SNodeList *pList, struct SListCell *pCell, SScalarParam *pElse,
                        SScalarParam *output, int32_t rowIdx, int32_t totalRows, bool *complete, bool preSingle) {
  SNode         *node = NULL;
  SWhenThenNode *pWhenThen = NULL;
  SScalarParam  *pWhen = NULL;
  SScalarParam  *pThen = NULL;
  int32_t        code = 0;
D
dapan1121 已提交
653

X
Xiaoyu Wang 已提交
654 655 656
  for (SListCell *cell = pCell; (NULL != cell ? (node = cell->pNode, true) : (node = NULL, false));
       cell = cell->pNext) {
    pWhenThen = (SWhenThenNode *)node;
D
dapan1121 已提交
657 658
    pWhen = NULL;
    pThen = NULL;
X
Xiaoyu Wang 已提交
659

D
dapan1121 已提交
660 661 662
    SCL_ERR_JRET(sclGetNodeRes(pWhenThen->pWhen, ctx, &pWhen));
    SCL_ERR_JRET(sclGetNodeRes(pWhenThen->pThen, ctx, &pThen));

X
Xiaoyu Wang 已提交
663 664
    bool *whenValue = (bool *)colDataGetData(pWhen->columnData, (pWhen->numOfRows > 1 ? rowIdx : 0));

D
dapan1121 已提交
665
    if (*whenValue) {
dengyihao's avatar
dengyihao 已提交
666
      bool  isNull = colDataIsNull_s(pThen->columnData, (pThen->numOfRows > 1 ? rowIdx : 0));
D
dapan1121 已提交
667 668
      char *pData = isNull ? NULL : colDataGetData(pThen->columnData, (pThen->numOfRows > 1 ? rowIdx : 0));
      colDataAppend(output->columnData, rowIdx, pData, isNull);
D
dapan1121 已提交
669

D
dapan1121 已提交
670
      if (preSingle && 0 == rowIdx && 1 == pWhen->numOfRows && 1 == pThen->numOfRows && totalRows > 1) {
D
dapan1121 已提交
671
        SCL_ERR_JRET(sclExtendResRows(output, output, ctx->pBlockList));
D
dapan1121 已提交
672
        *complete = true;
D
dapan1121 已提交
673
      }
X
Xiaoyu Wang 已提交
674

D
dapan1121 已提交
675 676 677 678 679
      goto _return;
    }

    sclFreeParam(pWhen);
    sclFreeParam(pThen);
D
dapan1121 已提交
680 681
    taosMemoryFreeClear(pWhen);
    taosMemoryFreeClear(pThen);
D
dapan1121 已提交
682 683 684
  }

  if (pElse) {
dengyihao's avatar
dengyihao 已提交
685
    bool  isNull = colDataIsNull_s(pElse->columnData, (pElse->numOfRows > 1 ? rowIdx : 0));
D
dapan1121 已提交
686 687
    char *pData = isNull ? NULL : colDataGetData(pElse->columnData, (pElse->numOfRows > 1 ? rowIdx : 0));
    colDataAppend(output->columnData, rowIdx, pData, isNull);
D
dapan1121 已提交
688

D
dapan1121 已提交
689
    if (preSingle && 0 == rowIdx && 1 == pElse->numOfRows && totalRows > 1) {
D
dapan1121 已提交
690
      SCL_ERR_JRET(sclExtendResRows(output, output, ctx->pBlockList));
D
dapan1121 已提交
691
      *complete = true;
D
dapan1121 已提交
692
    }
X
Xiaoyu Wang 已提交
693

D
dapan1121 已提交
694 695 696 697 698
    goto _return;
  }

  colDataAppend(output->columnData, rowIdx, NULL, true);

D
dapan1121 已提交
699
  if (preSingle && 0 == rowIdx && totalRows > 1) {
D
dapan1121 已提交
700
    SCL_ERR_JRET(sclExtendResRows(output, output, ctx->pBlockList));
D
dapan1121 已提交
701
    *complete = true;
D
dapan1121 已提交
702 703
  }

D
dapan1121 已提交
704 705 706 707
_return:

  sclFreeParam(pWhen);
  sclFreeParam(pThen);
D
dapan1121 已提交
708 709
  taosMemoryFree(pWhen);
  taosMemoryFree(pThen);
D
dapan1121 已提交
710

D
dapan1121 已提交
711
  SCL_RET(code);
D
dapan1121 已提交
712 713
}

714
int32_t sclExecFunction(SFunctionNode *node, SScalarCtx *ctx, SScalarParam *output) {
D
dapan1121 已提交
715
  SScalarParam *params = NULL;
H
Hongze Cheng 已提交
716 717 718
  int32_t       rowNum = 0;
  int32_t       paramNum = 0;
  int32_t       code = 0;
D
dapan 已提交
719
  SCL_ERR_RET(sclInitParamList(&params, node->pParameterList, ctx, &paramNum, &rowNum));
D
dapan1121 已提交
720

D
dapan1121 已提交
721
  if (fmIsUserDefinedFunc(node->funcId)) {
722
    code = callUdfScalarFunc(node->functionName, params, paramNum, output);
723 724 725 726
    if (code != 0) {
      sclError("fmExecFunction error. callUdfScalarFunc. function name: %s, udf code:%d", node->functionName, code);
      goto _return;
    }
D
dapan1121 已提交
727 728 729 730 731 732 733
  } else {
    SScalarFuncExecFuncs ffpSet = {0};
    code = fmGetScalarFuncExecFuncs(node->funcId, &ffpSet);
    if (code) {
      sclError("fmGetFuncExecFuncs failed, funcId:%d, code:%s", node->funcId, tstrerror(code));
      SCL_ERR_JRET(code);
    }
G
Ganlin Zhao 已提交
734

H
Haojun Liao 已提交
735 736 737
    code = sclCreateColumnInfoData(&node->node.resType, rowNum, output);
    if (code != TSDB_CODE_SUCCESS) {
      SCL_ERR_JRET(code);
D
dapan1121 已提交
738 739 740 741 742 743 744
    }

    code = (*ffpSet.process)(params, paramNum, output);
    if (code) {
      sclError("scalar function exec failed, funcId:%d, code:%s", node->funcId, tstrerror(code));
      SCL_ERR_JRET(code);
    }
D
dapan1121 已提交
745 746 747 748
  }

_return:

D
dapan1121 已提交
749
  sclFreeParamList(params, paramNum);
D
dapan1121 已提交
750 751 752 753 754
  SCL_RET(code);
}

int32_t sclExecLogic(SLogicConditionNode *node, SScalarCtx *ctx, SScalarParam *output) {
  if (NULL == node->pParameterList || node->pParameterList->length <= 0) {
H
Hongze Cheng 已提交
755 756
    sclError("invalid logic parameter list, list:%p, paramNum:%d", node->pParameterList,
             node->pParameterList ? node->pParameterList->length : 0);
D
dapan1121 已提交
757 758 759 760 761 762
    SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
  }

  if (TSDB_DATA_TYPE_BOOL != node->node.resType.type) {
    sclError("invalid logic resType, type:%d", node->node.resType.type);
    SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
D
dapan1121 已提交
763 764
  }

D
dapan1121 已提交
765 766 767 768 769 770
  if (LOGIC_COND_TYPE_NOT == node->condType && node->pParameterList->length > 1) {
    sclError("invalid NOT operation parameter number, paramNum:%d", node->pParameterList->length);
    SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
  }

  SScalarParam *params = NULL;
H
Hongze Cheng 已提交
771 772 773
  int32_t       rowNum = 0;
  int32_t       paramNum = 0;
  int32_t       code = 0;
D
dapan 已提交
774
  SCL_ERR_RET(sclInitParamList(&params, node->pParameterList, ctx, &paramNum, &rowNum));
D
dapan1121 已提交
775 776 777 778
  if (NULL == params) {
    output->numOfRows = 0;
    return TSDB_CODE_SUCCESS;
  }
D
dapan1121 已提交
779

780 781 782 783
  int32_t type = node->node.resType.type;
  output->numOfRows = rowNum;

  SDataType t = {.type = type, .bytes = tDataTypes[type].bytes};
H
Haojun Liao 已提交
784 785 786
  code = sclCreateColumnInfoData(&t, rowNum, output);
  if (code != TSDB_CODE_SUCCESS) {
    SCL_ERR_JRET(code);
D
dapan1121 已提交
787
  }
D
dapan1121 已提交
788

789 790
  int32_t numOfQualified = 0;

D
dapan1121 已提交
791
  bool value = false;
D
dapan 已提交
792
  bool complete = true;
D
dapan1121 已提交
793
  for (int32_t i = 0; i < rowNum; ++i) {
D
dapan 已提交
794 795
    complete = true;
    for (int32_t m = 0; m < paramNum; ++m) {
D
dapan1121 已提交
796
      if (NULL == params[m].columnData) {
D
dapan 已提交
797
        complete = false;
D
dapan1121 已提交
798 799
        continue;
      }
H
Hongze Cheng 已提交
800
      char *p = colDataGetData(params[m].columnData, i);
801 802
      GET_TYPED_DATA(value, bool, params[m].columnData->info.type, p);

D
dapan1121 已提交
803
      if (LOGIC_COND_TYPE_AND == node->condType && (false == value)) {
D
dapan1121 已提交
804
        complete = true;
D
dapan1121 已提交
805 806
        break;
      } else if (LOGIC_COND_TYPE_OR == node->condType && value) {
D
dapan1121 已提交
807
        complete = true;
D
dapan1121 已提交
808 809 810 811 812 813
        break;
      } else if (LOGIC_COND_TYPE_NOT == node->condType) {
        value = !value;
      }
    }

D
dapan 已提交
814
    if (complete) {
H
Hongze Cheng 已提交
815
      colDataAppend(output->columnData, i, (char *)&value, false);
816 817 818
      if (value) {
        numOfQualified++;
      }
D
dapan 已提交
819
    }
D
dapan1121 已提交
820 821
  }

D
dapan1121 已提交
822 823 824 825 826
  if (SCL_IS_CONST_CALC(ctx) && (false == complete)) {
    sclFreeParam(output);
    output->numOfRows = 0;
  }

827
  output->numOfQualified = numOfQualified;
D
dapan1121 已提交
828

829
_return:
D
dapan1121 已提交
830
  sclFreeParamList(params, paramNum);
D
dapan1121 已提交
831
  SCL_RET(code);
D
dapan1121 已提交
832 833 834 835
}

int32_t sclExecOperator(SOperatorNode *node, SScalarCtx *ctx, SScalarParam *output) {
  SScalarParam *params = NULL;
H
Hongze Cheng 已提交
836 837
  int32_t       rowNum = 0;
  int32_t       code = 0;
838

wmmhello's avatar
wmmhello 已提交
839
  // json not support in in operator
H
Haojun Liao 已提交
840
  if (nodeType(node->pLeft) == QUERY_NODE_VALUE) {
wmmhello's avatar
wmmhello 已提交
841
    SValueNode *valueNode = (SValueNode *)node->pLeft;
H
Hongze Cheng 已提交
842 843
    if (valueNode->node.resType.type == TSDB_DATA_TYPE_JSON &&
        (node->opType == OP_TYPE_IN || node->opType == OP_TYPE_NOT_IN)) {
wmmhello's avatar
wmmhello 已提交
844 845 846 847
      SCL_RET(TSDB_CODE_QRY_JSON_IN_ERROR);
    }
  }

D
dapan1121 已提交
848
  SCL_ERR_RET(sclInitOperatorParams(&params, node, ctx, &rowNum));
849
  if (output->columnData == NULL) {
H
Haojun Liao 已提交
850 851 852 853
    code = sclCreateColumnInfoData(&node->node.resType, rowNum, output);
    if (code != TSDB_CODE_SUCCESS) {
      SCL_ERR_JRET(code);
    }
D
dapan1121 已提交
854 855 856 857
  }

  _bin_scalar_fn_t OperatorFn = getBinScalarOperatorFn(node->opType);

H
Hongze Cheng 已提交
858 859 860
  int32_t       paramNum = scalarGetOperatorParamNum(node->opType);
  SScalarParam *pLeft = &params[0];
  SScalarParam *pRight = paramNum > 1 ? &params[1] : NULL;
861

wmmhello's avatar
wmmhello 已提交
862
  terrno = TSDB_CODE_SUCCESS;
D
dapan 已提交
863
  OperatorFn(pLeft, pRight, output, TSDB_ORDER_ASC);
wmmhello's avatar
wmmhello 已提交
864
  code = terrno;
D
dapan1121 已提交
865 866

_return:
D
dapan1121 已提交
867

D
dapan1121 已提交
868
  sclFreeParamList(params, paramNum);
D
dapan1121 已提交
869
  SCL_RET(code);
D
dapan1121 已提交
870 871
}

D
dapan1121 已提交
872
int32_t sclExecCaseWhen(SCaseWhenNode *node, SScalarCtx *ctx, SScalarParam *output) {
X
Xiaoyu Wang 已提交
873
  int32_t       code = 0;
D
dapan1121 已提交
874 875
  SScalarParam *pCase = NULL;
  SScalarParam *pElse = NULL;
D
dapan1121 已提交
876 877
  SScalarParam *pWhen = NULL;
  SScalarParam *pThen = NULL;
D
dapan1121 已提交
878
  SScalarParam  comp = {0};
X
Xiaoyu Wang 已提交
879 880
  int32_t       rowNum = 1;
  bool          complete = false;
D
dapan1121 已提交
881 882 883 884 885 886 887

  if (NULL == node->pWhenThenList || node->pWhenThenList->length <= 0) {
    sclError("invalid whenThen list");
    SCL_ERR_RET(TSDB_CODE_INVALID_PARA);
  }

  if (ctx->pBlockList) {
X
Xiaoyu Wang 已提交
888
    SSDataBlock *pb = taosArrayGetP(ctx->pBlockList, 0);
D
dapan1121 已提交
889
    rowNum = pb->info.rows;
D
dapan1121 已提交
890
    output->numOfRows = pb->info.rows;
D
dapan1121 已提交
891
  }
D
dapan1121 已提交
892 893

  SCL_ERR_JRET(sclCreateColumnInfoData(&node->node.resType, rowNum, output));
X
Xiaoyu Wang 已提交
894

D
dapan1121 已提交
895 896 897 898 899 900
  SCL_ERR_JRET(sclGetNodeRes(node->pCase, ctx, &pCase));
  SCL_ERR_JRET(sclGetNodeRes(node->pElse, ctx, &pElse));

  SDataType compType = {0};
  compType.type = TSDB_DATA_TYPE_BOOL;
  compType.bytes = tDataTypes[compType.type].bytes;
X
Xiaoyu Wang 已提交
901

D
dapan1121 已提交
902
  SCL_ERR_JRET(sclCreateColumnInfoData(&compType, rowNum, &comp));
D
dapan1121 已提交
903

X
Xiaoyu Wang 已提交
904 905
  SNode         *tnode = NULL;
  SWhenThenNode *pWhenThen = (SWhenThenNode *)node->pWhenThenList->pHead->pNode;
D
dapan1121 已提交
906 907 908

  SCL_ERR_JRET(sclGetNodeRes(pWhenThen->pWhen, ctx, &pWhen));
  SCL_ERR_JRET(sclGetNodeRes(pWhenThen->pThen, ctx, &pThen));
D
dapan1121 已提交
909 910 911 912
  if (NULL == pWhen || NULL == pThen) {
    sclError("invalid when/then in whenThen list");
    SCL_ERR_JRET(TSDB_CODE_INVALID_PARA);
  }
D
dapan1121 已提交
913 914

  if (pCase) {
D
dapan1121 已提交
915
    vectorCompare(pCase, pWhen, &comp, TSDB_ORDER_ASC, OP_TYPE_EQUAL);
X
Xiaoyu Wang 已提交
916

D
dapan1121 已提交
917
    for (int32_t i = 0; i < rowNum; ++i) {
X
Xiaoyu Wang 已提交
918
      bool *equal = (bool *)colDataGetData(comp.columnData, (comp.numOfRows > 1 ? i : 0));
D
dapan1121 已提交
919
      if (*equal) {
X
Xiaoyu Wang 已提交
920 921
        colDataAppend(output->columnData, i, colDataGetData(pThen->columnData, (pThen->numOfRows > 1 ? i : 0)),
                      colDataIsNull_s(pThen->columnData, (pThen->numOfRows > 1 ? i : 0)));
D
dapan1121 已提交
922
        if (0 == i && 1 == pCase->numOfRows && 1 == pWhen->numOfRows && 1 == pThen->numOfRows && rowNum > 1) {
D
dapan1121 已提交
923 924 925
          SCL_ERR_JRET(sclExtendResRows(output, output, ctx->pBlockList));
          break;
        }
D
dapan1121 已提交
926
      } else {
X
Xiaoyu Wang 已提交
927 928
        SCL_ERR_JRET(sclWalkCaseWhenList(ctx, node->pWhenThenList, node->pWhenThenList->pHead->pNext, pCase, pElse,
                                         &comp, output, i, rowNum, &complete));
D
dapan1121 已提交
929 930 931
        if (complete) {
          break;
        }
D
dapan1121 已提交
932
      }
D
dapan1121 已提交
933
    }
D
dapan1121 已提交
934 935
  } else {
    for (int32_t i = 0; i < rowNum; ++i) {
X
Xiaoyu Wang 已提交
936
      bool *whenValue = (bool *)colDataGetData(pWhen->columnData, (pWhen->numOfRows > 1 ? i : 0));
D
dapan1121 已提交
937
      if (*whenValue) {
X
Xiaoyu Wang 已提交
938 939
        colDataAppend(output->columnData, i, colDataGetData(pThen->columnData, (pThen->numOfRows > 1 ? i : 0)),
                      colDataIsNull_s(pThen->columnData, (pThen->numOfRows > 1 ? i : 0)));
D
dapan1121 已提交
940 941 942 943
        if (0 == i && 1 == pWhen->numOfRows && 1 == pThen->numOfRows && rowNum > 1) {
          SCL_ERR_JRET(sclExtendResRows(output, output, ctx->pBlockList));
          break;
        }
D
dapan1121 已提交
944
      } else {
X
Xiaoyu Wang 已提交
945 946
        SCL_ERR_JRET(sclWalkWhenList(ctx, node->pWhenThenList, node->pWhenThenList->pHead->pNext, pElse, output, i,
                                     rowNum, &complete, (pWhen->numOfRows == 1 && pThen->numOfRows == 1)));
D
dapan1121 已提交
947 948 949
        if (complete) {
          break;
        }
D
dapan1121 已提交
950
      }
D
dapan1121 已提交
951 952 953
    }
  }

D
dapan1121 已提交
954 955
  sclFreeParam(pCase);
  sclFreeParam(pElse);
D
dapan1121 已提交
956
  sclFreeParam(&comp);
D
dapan1121 已提交
957 958
  sclFreeParam(pWhen);
  sclFreeParam(pThen);
D
dapan1121 已提交
959 960 961 962
  taosMemoryFree(pCase);
  taosMemoryFree(pElse);
  taosMemoryFree(pWhen);
  taosMemoryFree(pThen);
D
dapan1121 已提交
963

D
dapan1121 已提交
964
  return TSDB_CODE_SUCCESS;
D
dapan1121 已提交
965 966 967

_return:

D
dapan1121 已提交
968 969
  sclFreeParam(pCase);
  sclFreeParam(pElse);
D
dapan1121 已提交
970
  sclFreeParam(&comp);
D
dapan1121 已提交
971 972 973
  sclFreeParam(pWhen);
  sclFreeParam(pThen);
  sclFreeParam(output);
D
dapan1121 已提交
974 975 976 977
  taosMemoryFree(pCase);
  taosMemoryFree(pElse);
  taosMemoryFree(pWhen);
  taosMemoryFree(pThen);
D
dapan1121 已提交
978

D
dapan1121 已提交
979 980 981
  SCL_RET(code);
}

H
Hongze Cheng 已提交
982
EDealRes sclRewriteNullInOptr(SNode **pNode, SScalarCtx *ctx, EOperatorType opType) {
D
dapan1121 已提交
983 984 985
  if (opType <= OP_TYPE_CALC_MAX) {
    SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE);
    if (NULL == res) {
G
Ganlin Zhao 已提交
986
      sclError("make value node failed");
S
Shengliang Guan 已提交
987
      ctx->code = TSDB_CODE_OUT_OF_MEMORY;
D
dapan1121 已提交
988 989
      return DEAL_RES_ERROR;
    }
G
Ganlin Zhao 已提交
990

D
dapan1121 已提交
991
    res->node.resType.type = TSDB_DATA_TYPE_NULL;
G
Ganlin Zhao 已提交
992

D
dapan1121 已提交
993
    nodesDestroyNode(*pNode);
H
Hongze Cheng 已提交
994
    *pNode = (SNode *)res;
D
dapan1121 已提交
995 996 997
  } else {
    SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE);
    if (NULL == res) {
G
Ganlin Zhao 已提交
998
      sclError("make value node failed");
S
Shengliang Guan 已提交
999
      ctx->code = TSDB_CODE_OUT_OF_MEMORY;
D
dapan1121 已提交
1000 1001
      return DEAL_RES_ERROR;
    }
G
Ganlin Zhao 已提交
1002

D
dapan1121 已提交
1003
    res->node.resType.type = TSDB_DATA_TYPE_BOOL;
D
dapan1121 已提交
1004
    res->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;
D
dapan1121 已提交
1005
    res->datum.b = false;
G
Ganlin Zhao 已提交
1006

D
dapan1121 已提交
1007
    nodesDestroyNode(*pNode);
H
Hongze Cheng 已提交
1008
    *pNode = (SNode *)res;
D
dapan1121 已提交
1009 1010 1011 1012 1013
  }

  return DEAL_RES_CONTINUE;
}

H
Hongze Cheng 已提交
1014
EDealRes sclAggFuncWalker(SNode *pNode, void *pContext) {
D
dapan1121 已提交
1015
  if (QUERY_NODE_FUNCTION == nodeType(pNode)) {
H
Hongze Cheng 已提交
1016 1017 1018
    SFunctionNode *pFunc = (SFunctionNode *)pNode;
    *(bool *)pContext = fmIsAggFunc(pFunc->funcId);
    if (*(bool *)pContext) {
D
dapan1121 已提交
1019 1020 1021 1022 1023 1024 1025
      return DEAL_RES_END;
    }
  }

  return DEAL_RES_CONTINUE;
}

H
Hongze Cheng 已提交
1026
bool sclContainsAggFuncNode(SNode *pNode) {
D
dapan1121 已提交
1027 1028 1029 1030
  bool aggFunc = false;
  nodesWalkExpr(pNode, sclAggFuncWalker, (void *)&aggFunc);
  return aggFunc;
}
D
dapan1121 已提交
1031

H
Hongze Cheng 已提交
1032
EDealRes sclRewriteNonConstOperator(SNode **pNode, SScalarCtx *ctx) {
D
dapan1121 已提交
1033
  SOperatorNode *node = (SOperatorNode *)*pNode;
H
Hongze Cheng 已提交
1034
  int32_t        code = 0;
D
dapan1121 已提交
1035 1036 1037

  if (node->pLeft && (QUERY_NODE_VALUE == nodeType(node->pLeft))) {
    SValueNode *valueNode = (SValueNode *)node->pLeft;
H
Hongze Cheng 已提交
1038 1039
    if (SCL_IS_NULL_VALUE_NODE(valueNode) && (node->opType != OP_TYPE_IS_NULL && node->opType != OP_TYPE_IS_NOT_NULL) &&
        (!sclContainsAggFuncNode(node->pRight))) {
D
dapan1121 已提交
1040
      return sclRewriteNullInOptr(pNode, ctx, node->opType);
D
dapan1121 已提交
1041
    }
D
dapan 已提交
1042

H
Hongze Cheng 已提交
1043 1044 1045
    if (IS_STR_DATA_TYPE(valueNode->node.resType.type) && node->pRight && nodesIsExprNode(node->pRight) &&
        ((SExprNode *)node->pRight)->resType.type == TSDB_DATA_TYPE_TIMESTAMP) {
      code = sclConvertToTsValueNode(((SExprNode *)node->pRight)->resType.precision, valueNode);
D
dapan1121 已提交
1046 1047 1048 1049
      if (code) {
        ctx->code = code;
        return DEAL_RES_ERROR;
      }
D
dapan 已提交
1050
    }
1051 1052 1053

    if (SCL_IS_COMPARISON_OPERATOR(node->opType) && SCL_DOWNGRADE_DATETYPE(valueNode->node.resType.type)) {
      sclDowngradeValueType(valueNode);
H
Hongze Cheng 已提交
1054
    }
D
dapan1121 已提交
1055 1056 1057 1058
  }

  if (node->pRight && (QUERY_NODE_VALUE == nodeType(node->pRight))) {
    SValueNode *valueNode = (SValueNode *)node->pRight;
H
Hongze Cheng 已提交
1059 1060
    if (SCL_IS_NULL_VALUE_NODE(valueNode) && (node->opType != OP_TYPE_IS_NULL && node->opType != OP_TYPE_IS_NOT_NULL) &&
        (!sclContainsAggFuncNode(node->pLeft))) {
D
dapan1121 已提交
1061
      return sclRewriteNullInOptr(pNode, ctx, node->opType);
D
dapan1121 已提交
1062
    }
D
dapan 已提交
1063

H
Hongze Cheng 已提交
1064 1065 1066
    if (IS_STR_DATA_TYPE(valueNode->node.resType.type) && node->pLeft && nodesIsExprNode(node->pLeft) &&
        ((SExprNode *)node->pLeft)->resType.type == TSDB_DATA_TYPE_TIMESTAMP) {
      code = sclConvertToTsValueNode(((SExprNode *)node->pLeft)->resType.precision, valueNode);
D
dapan1121 已提交
1067 1068 1069 1070
      if (code) {
        ctx->code = code;
        return DEAL_RES_ERROR;
      }
D
dapan 已提交
1071
    }
1072 1073 1074

    if (SCL_IS_COMPARISON_OPERATOR(node->opType) && SCL_DOWNGRADE_DATETYPE(valueNode->node.resType.type)) {
      sclDowngradeValueType(valueNode);
H
Hongze Cheng 已提交
1075
    }
D
dapan1121 已提交
1076 1077 1078 1079
  }

  if (node->pRight && (QUERY_NODE_NODE_LIST == nodeType(node->pRight))) {
    SNodeListNode *listNode = (SNodeListNode *)node->pRight;
H
Hongze Cheng 已提交
1080
    SNode         *tnode = NULL;
D
dapan1121 已提交
1081 1082 1083 1084 1085
    WHERE_EACH(tnode, listNode->pNodeList) {
      if (SCL_IS_NULL_VALUE_NODE(tnode)) {
        if (node->opType == OP_TYPE_IN) {
          ERASE_NODE(listNode->pNodeList);
          continue;
H
Hongze Cheng 已提交
1086
        } else {  // OP_TYPE_NOT_IN
D
dapan1121 已提交
1087
          return sclRewriteNullInOptr(pNode, ctx, node->opType);
D
dapan1121 已提交
1088 1089 1090 1091 1092 1093 1094
        }
      }

      WHERE_NEXT;
    }

    if (listNode->pNodeList->length <= 0) {
D
dapan1121 已提交
1095
      return sclRewriteNullInOptr(pNode, ctx, node->opType);
D
dapan1121 已提交
1096 1097 1098 1099 1100 1101
    }
  }

  return DEAL_RES_CONTINUE;
}

H
Hongze Cheng 已提交
1102
EDealRes sclRewriteFunction(SNode **pNode, SScalarCtx *ctx) {
D
dapan1121 已提交
1103
  SFunctionNode *node = (SFunctionNode *)*pNode;
H
Hongze Cheng 已提交
1104
  SNode         *tnode = NULL;
X
Xiaoyu Wang 已提交
1105
  if ((!fmIsScalarFunc(node->funcId) && (!ctx->dual)) || fmIsUserDefinedFunc(node->funcId)) {
G
Ganlin Zhao 已提交
1106 1107
    return DEAL_RES_CONTINUE;
  }
1108

D
dapan1121 已提交
1109 1110 1111 1112 1113 1114
  FOREACH(tnode, node->pParameterList) {
    if (!SCL_IS_CONST_NODE(tnode)) {
      return DEAL_RES_CONTINUE;
    }
  }

D
dapan1121 已提交
1115
  SScalarParam output = {0};
1116

1117
  ctx->code = sclExecFunction(node, ctx, &output);
D
dapan 已提交
1118
  if (ctx->code) {
D
dapan1121 已提交
1119 1120 1121
    return DEAL_RES_ERROR;
  }

D
dapan1121 已提交
1122
  SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE);
D
dapan1121 已提交
1123 1124
  if (NULL == res) {
    sclError("make value node failed");
D
dapan1121 已提交
1125
    sclFreeParam(&output);
S
Shengliang Guan 已提交
1126
    ctx->code = TSDB_CODE_OUT_OF_MEMORY;
D
dapan1121 已提交
1127 1128 1129
    return DEAL_RES_ERROR;
  }

1130 1131
  res->translate = true;

1132 1133 1134 1135
  res->node.resType.type = output.columnData->info.type;
  res->node.resType.bytes = output.columnData->info.bytes;
  res->node.resType.scale = output.columnData->info.scale;
  res->node.resType.precision = output.columnData->info.precision;
1136
  if (colDataIsNull_s(output.columnData, 0)) {
1137
    res->isNull = true;
D
dapan1121 已提交
1138
  } else {
1139
    int32_t type = output.columnData->info.type;
H
Hongze Cheng 已提交
1140
    if (type == TSDB_DATA_TYPE_JSON) {
wmmhello's avatar
wmmhello 已提交
1141 1142 1143 1144
      int32_t len = getJsonValueLen(output.columnData->pData);
      res->datum.p = taosMemoryCalloc(len, 1);
      memcpy(res->datum.p, output.columnData->pData, len);
    } else if (IS_VAR_DATA_TYPE(type)) {
H
Hongze Cheng 已提交
1145
      // res->datum.p = taosMemoryCalloc(res->node.resType.bytes + VARSTR_HEADER_SIZE + 1, 1);
1146
      res->datum.p = taosMemoryCalloc(varDataTLen(output.columnData->pData) + 1, 1);
1147
      res->node.resType.bytes = varDataTLen(output.columnData->pData);
1148
      memcpy(res->datum.p, output.columnData->pData, varDataTLen(output.columnData->pData));
1149
    } else {
D
dapan1121 已提交
1150
      nodesSetValueNodeValue(res, output.columnData->pData);
1151
    }
D
dapan1121 已提交
1152
  }
1153

D
dapan1121 已提交
1154
  nodesDestroyNode(*pNode);
H
Hongze Cheng 已提交
1155
  *pNode = (SNode *)res;
D
dapan1121 已提交
1156

D
dapan1121 已提交
1157
  sclFreeParam(&output);
D
dapan1121 已提交
1158 1159 1160
  return DEAL_RES_CONTINUE;
}

H
Hongze Cheng 已提交
1161
EDealRes sclRewriteLogic(SNode **pNode, SScalarCtx *ctx) {
D
dapan1121 已提交
1162 1163
  SLogicConditionNode *node = (SLogicConditionNode *)*pNode;

H
Haojun Liao 已提交
1164
  SScalarParam output = {0};
D
dapan 已提交
1165 1166
  ctx->code = sclExecLogic(node, ctx, &output);
  if (ctx->code) {
D
dapan1121 已提交
1167 1168 1169
    return DEAL_RES_ERROR;
  }

D
dapan1121 已提交
1170 1171 1172 1173
  if (0 == output.numOfRows) {
    return DEAL_RES_CONTINUE;
  }

D
dapan1121 已提交
1174
  SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE);
D
dapan1121 已提交
1175 1176
  if (NULL == res) {
    sclError("make value node failed");
1177
    sclFreeParam(&output);
S
Shengliang Guan 已提交
1178
    ctx->code = TSDB_CODE_OUT_OF_MEMORY;
D
dapan1121 已提交
1179 1180 1181 1182
    return DEAL_RES_ERROR;
  }

  res->node.resType = node->node.resType;
1183
  res->translate = true;
D
dapan1121 已提交
1184

1185 1186 1187 1188
  int32_t type = output.columnData->info.type;
  if (IS_VAR_DATA_TYPE(type)) {
    res->datum.p = output.columnData->pData;
    output.columnData->pData = NULL;
D
dapan1121 已提交
1189
  } else {
D
dapan1121 已提交
1190
    nodesSetValueNodeValue(res, output.columnData->pData);
D
dapan1121 已提交
1191
  }
D
dapan1121 已提交
1192 1193

  nodesDestroyNode(*pNode);
H
Hongze Cheng 已提交
1194
  *pNode = (SNode *)res;
D
dapan1121 已提交
1195

D
dapan1121 已提交
1196
  sclFreeParam(&output);
D
dapan1121 已提交
1197 1198 1199
  return DEAL_RES_CONTINUE;
}

H
Hongze Cheng 已提交
1200
EDealRes sclRewriteOperator(SNode **pNode, SScalarCtx *ctx) {
D
dapan1121 已提交
1201
  SOperatorNode *node = (SOperatorNode *)*pNode;
D
dapan1121 已提交
1202

D
dapan1121 已提交
1203
  if ((!SCL_IS_CONST_NODE(node->pLeft)) || (!SCL_IS_CONST_NODE(node->pRight))) {
D
dapan 已提交
1204
    return sclRewriteNonConstOperator(pNode, ctx);
D
dapan1121 已提交
1205 1206
  }

H
Haojun Liao 已提交
1207
  SScalarParam output = {0};
D
dapan 已提交
1208 1209
  ctx->code = sclExecOperator(node, ctx, &output);
  if (ctx->code) {
dengyihao's avatar
dengyihao 已提交
1210
    sclFreeParam(&output);
D
dapan1121 已提交
1211 1212 1213
    return DEAL_RES_ERROR;
  }

D
dapan1121 已提交
1214
  SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE);
D
dapan1121 已提交
1215
  if (NULL == res) {
1216 1217
    sclError("make value node failed");
    sclFreeParam(&output);
S
Shengliang Guan 已提交
1218
    ctx->code = TSDB_CODE_OUT_OF_MEMORY;
D
dapan1121 已提交
1219 1220 1221
    return DEAL_RES_ERROR;
  }

1222
  res->translate = true;
D
dapan1121 已提交
1223

1224
  res->node.resType = node->node.resType;
1225
  if (colDataIsNull_s(output.columnData, 0)) {
1226 1227
    res->isNull = true;
    res->node.resType = node->node.resType;
1228
  } else {
1229 1230 1231 1232 1233
    int32_t type = output.columnData->info.type;
    if (IS_VAR_DATA_TYPE(type)) {  // todo refactor
      res->datum.p = output.columnData->pData;
      output.columnData->pData = NULL;
    } else {
G
Ganlin Zhao 已提交
1234
      nodesSetValueNodeValue(res, output.columnData->pData);
1235
    }
D
dapan1121 已提交
1236
  }
D
dapan1121 已提交
1237 1238

  nodesDestroyNode(*pNode);
H
Hongze Cheng 已提交
1239
  *pNode = (SNode *)res;
D
dapan1121 已提交
1240

H
Haojun Liao 已提交
1241
  sclFreeParam(&output);
D
dapan1121 已提交
1242 1243 1244
  return DEAL_RES_CONTINUE;
}

X
Xiaoyu Wang 已提交
1245
EDealRes sclRewriteCaseWhen(SNode **pNode, SScalarCtx *ctx) {
D
dapan1121 已提交
1246 1247 1248 1249 1250 1251
  SCaseWhenNode *node = (SCaseWhenNode *)*pNode;

  if ((!SCL_IS_CONST_NODE(node->pCase)) || (!SCL_IS_CONST_NODE(node->pElse))) {
    return DEAL_RES_CONTINUE;
  }

X
Xiaoyu Wang 已提交
1252
  SNode *tnode = NULL;
D
dapan1121 已提交
1253
  FOREACH(tnode, node->pWhenThenList) {
X
Xiaoyu Wang 已提交
1254
    SWhenThenNode *pWhenThen = (SWhenThenNode *)tnode;
D
dapan1121 已提交
1255
    if (!SCL_IS_CONST_NODE(pWhenThen->pWhen) || !SCL_IS_CONST_NODE(pWhenThen->pThen)) {
D
dapan1121 已提交
1256 1257
      return DEAL_RES_CONTINUE;
    }
X
Xiaoyu Wang 已提交
1258
  }
D
dapan1121 已提交
1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269

  SScalarParam output = {0};
  ctx->code = sclExecCaseWhen(node, ctx, &output);
  if (ctx->code) {
    return DEAL_RES_ERROR;
  }

  SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE);
  if (NULL == res) {
    sclError("make value node failed");
    sclFreeParam(&output);
S
Shengliang Guan 已提交
1270
    ctx->code = TSDB_CODE_OUT_OF_MEMORY;
D
dapan1121 已提交
1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290
    return DEAL_RES_ERROR;
  }

  res->translate = true;

  res->node.resType = node->node.resType;
  if (colDataIsNull_s(output.columnData, 0)) {
    res->isNull = true;
    res->node.resType = node->node.resType;
  } else {
    int32_t type = output.columnData->info.type;
    if (IS_VAR_DATA_TYPE(type)) {  // todo refactor
      res->datum.p = output.columnData->pData;
      output.columnData->pData = NULL;
    } else {
      nodesSetValueNodeValue(res, output.columnData->pData);
    }
  }

  nodesDestroyNode(*pNode);
X
Xiaoyu Wang 已提交
1291
  *pNode = (SNode *)res;
D
dapan1121 已提交
1292 1293 1294 1295 1296

  sclFreeParam(&output);
  return DEAL_RES_CONTINUE;
}

H
Hongze Cheng 已提交
1297
EDealRes sclConstantsRewriter(SNode **pNode, void *pContext) {
D
dapan 已提交
1298 1299
  SScalarCtx *ctx = (SScalarCtx *)pContext;

D
dapan1121 已提交
1300 1301 1302 1303
  if (QUERY_NODE_OPERATOR == nodeType(*pNode)) {
    return sclRewriteOperator(pNode, ctx);
  }

D
dapan1121 已提交
1304
  if (QUERY_NODE_FUNCTION == nodeType(*pNode)) {
D
dapan 已提交
1305
    return sclRewriteFunction(pNode, ctx);
D
dapan1121 已提交
1306 1307 1308
  }

  if (QUERY_NODE_LOGIC_CONDITION == nodeType(*pNode)) {
D
dapan 已提交
1309
    return sclRewriteLogic(pNode, ctx);
D
dapan1121 已提交
1310 1311
  }

D
dapan1121 已提交
1312
  if (QUERY_NODE_CASE_WHEN == nodeType(*pNode)) {
D
dapan1121 已提交
1313
    return sclRewriteCaseWhen(pNode, ctx);
1314
  }
1315 1316

  return DEAL_RES_CONTINUE;
D
dapan1121 已提交
1317 1318
}

H
Hongze Cheng 已提交
1319
EDealRes sclWalkFunction(SNode *pNode, SScalarCtx *ctx) {
D
dapan1121 已提交
1320
  SFunctionNode *node = (SFunctionNode *)pNode;
H
Hongze Cheng 已提交
1321
  SScalarParam   output = {0};
1322

1323
  ctx->code = sclExecFunction(node, ctx, &output);
D
dapan1121 已提交
1324 1325
  if (ctx->code) {
    return DEAL_RES_ERROR;
D
dapan1121 已提交
1326 1327
  }

D
dapan1121 已提交
1328
  if (taosHashPut(ctx->pRes, &pNode, POINTER_BYTES, &output, sizeof(output))) {
S
Shengliang Guan 已提交
1329
    ctx->code = TSDB_CODE_OUT_OF_MEMORY;
D
dapan1121 已提交
1330
    return DEAL_RES_ERROR;
D
dapan1121 已提交
1331 1332
  }

D
dapan1121 已提交
1333 1334 1335
  return DEAL_RES_CONTINUE;
}

H
Hongze Cheng 已提交
1336
EDealRes sclWalkLogic(SNode *pNode, SScalarCtx *ctx) {
D
dapan1121 已提交
1337
  SLogicConditionNode *node = (SLogicConditionNode *)pNode;
H
Hongze Cheng 已提交
1338
  SScalarParam         output = {0};
1339

D
dapan1121 已提交
1340 1341 1342
  ctx->code = sclExecLogic(node, ctx, &output);
  if (ctx->code) {
    return DEAL_RES_ERROR;
D
dapan1121 已提交
1343 1344
  }

D
dapan1121 已提交
1345
  if (taosHashPut(ctx->pRes, &pNode, POINTER_BYTES, &output, sizeof(output))) {
S
Shengliang Guan 已提交
1346
    ctx->code = TSDB_CODE_OUT_OF_MEMORY;
D
dapan1121 已提交
1347
    return DEAL_RES_ERROR;
D
dapan1121 已提交
1348 1349 1350 1351 1352
  }

  return DEAL_RES_CONTINUE;
}

H
Hongze Cheng 已提交
1353
EDealRes sclWalkOperator(SNode *pNode, SScalarCtx *ctx) {
D
dapan1121 已提交
1354
  SOperatorNode *node = (SOperatorNode *)pNode;
H
Hongze Cheng 已提交
1355
  SScalarParam   output = {0};
G
Ganlin Zhao 已提交
1356

D
dapan1121 已提交
1357 1358
  ctx->code = sclExecOperator(node, ctx, &output);
  if (ctx->code) {
dengyihao's avatar
dengyihao 已提交
1359
    sclFreeParam(&output);
D
dapan1121 已提交
1360 1361
    return DEAL_RES_ERROR;
  }
D
dapan1121 已提交
1362

D
dapan1121 已提交
1363
  if (taosHashPut(ctx->pRes, &pNode, POINTER_BYTES, &output, sizeof(output))) {
S
Shengliang Guan 已提交
1364
    ctx->code = TSDB_CODE_OUT_OF_MEMORY;
D
dapan1121 已提交
1365 1366 1367
    return DEAL_RES_ERROR;
  }

D
dapan1121 已提交
1368 1369 1370
  return DEAL_RES_CONTINUE;
}

H
Hongze Cheng 已提交
1371
EDealRes sclWalkTarget(SNode *pNode, SScalarCtx *ctx) {
1372 1373 1374
  STargetNode *target = (STargetNode *)pNode;

  if (target->dataBlockId >= taosArrayGetSize(ctx->pBlockList)) {
H
Hongze Cheng 已提交
1375 1376
    sclError("target tupleId is too big, tupleId:%d, dataBlockNum:%d", target->dataBlockId,
             (int32_t)taosArrayGetSize(ctx->pBlockList));
1377 1378 1379 1380 1381
    ctx->code = TSDB_CODE_QRY_INVALID_INPUT;
    return DEAL_RES_ERROR;
  }

  int32_t index = -1;
H
Hongze Cheng 已提交
1382 1383
  for (int32_t i = 0; i < taosArrayGetSize(ctx->pBlockList); ++i) {
    SSDataBlock *pb = taosArrayGetP(ctx->pBlockList, i);
H
Haojun Liao 已提交
1384
    if (pb->info.id.blockId == target->dataBlockId) {
1385 1386 1387 1388 1389 1390
      index = i;
      break;
    }
  }

  if (index == -1) {
H
Hongze Cheng 已提交
1391 1392
    sclError("column tupleId is too big, tupleId:%d, dataBlockNum:%d", target->dataBlockId,
             (int32_t)taosArrayGetSize(ctx->pBlockList));
1393 1394 1395 1396 1397 1398 1399
    ctx->code = TSDB_CODE_QRY_INVALID_INPUT;
    return DEAL_RES_ERROR;
  }

  SSDataBlock *block = *(SSDataBlock **)taosArrayGet(ctx->pBlockList, index);

  if (target->slotId >= taosArrayGetSize(block->pDataBlock)) {
H
Hongze Cheng 已提交
1400 1401
    sclError("target slot not exist, dataBlockId:%d, slotId:%d, dataBlockNum:%d", target->dataBlockId, target->slotId,
             (int32_t)taosArrayGetSize(block->pDataBlock));
1402 1403 1404 1405 1406 1407 1408 1409 1410 1411
    ctx->code = TSDB_CODE_QRY_INVALID_INPUT;
    return DEAL_RES_ERROR;
  }

  // if block->pDataBlock is not enough, there are problems if target->slotId bigger than the size of block->pDataBlock,
  SColumnInfoData *col = taosArrayGet(block->pDataBlock, target->slotId);

  SScalarParam *res = (SScalarParam *)taosHashGet(ctx->pRes, (void *)&target->pExpr, POINTER_BYTES);
  if (NULL == res) {
    sclError("no valid res in hash, node:%p, type:%d", target->pExpr, nodeType(target->pExpr));
S
Shengliang Guan 已提交
1412
    ctx->code = TSDB_CODE_APP_ERROR;
1413 1414 1415
    return DEAL_RES_ERROR;
  }

1416
  colDataAssign(col, res->columnData, res->numOfRows, NULL);
1417 1418 1419 1420 1421 1422
  block->info.rows = res->numOfRows;

  sclFreeParam(res);
  taosHashRemove(ctx->pRes, (void *)&target->pExpr, POINTER_BYTES);
  return DEAL_RES_CONTINUE;
}
D
dapan 已提交
1423

X
Xiaoyu Wang 已提交
1424
EDealRes sclWalkCaseWhen(SNode *pNode, SScalarCtx *ctx) {
D
dapan1121 已提交
1425
  SCaseWhenNode *node = (SCaseWhenNode *)pNode;
X
Xiaoyu Wang 已提交
1426
  SScalarParam   output = {0};
D
dapan1121 已提交
1427 1428 1429 1430 1431 1432 1433

  ctx->code = sclExecCaseWhen(node, ctx, &output);
  if (ctx->code) {
    return DEAL_RES_ERROR;
  }

  if (taosHashPut(ctx->pRes, &pNode, POINTER_BYTES, &output, sizeof(output))) {
S
Shengliang Guan 已提交
1434
    ctx->code = TSDB_CODE_OUT_OF_MEMORY;
D
dapan1121 已提交
1435 1436 1437 1438 1439 1440
    return DEAL_RES_ERROR;
  }

  return DEAL_RES_CONTINUE;
}

H
Hongze Cheng 已提交
1441
EDealRes sclCalcWalker(SNode *pNode, void *pContext) {
X
Xiaoyu Wang 已提交
1442 1443 1444
  if (QUERY_NODE_VALUE == nodeType(pNode) || QUERY_NODE_NODE_LIST == nodeType(pNode) ||
      QUERY_NODE_COLUMN == nodeType(pNode) || QUERY_NODE_LEFT_VALUE == nodeType(pNode) ||
      QUERY_NODE_WHEN_THEN == nodeType(pNode)) {
D
dapan1121 已提交
1445
    return DEAL_RES_CONTINUE;
D
dapan1121 已提交
1446
  }
D
dapan 已提交
1447 1448

  SScalarCtx *ctx = (SScalarCtx *)pContext;
D
dapan1121 已提交
1449 1450 1451 1452
  if (QUERY_NODE_OPERATOR == nodeType(pNode)) {
    return sclWalkOperator(pNode, ctx);
  }

D
dapan1121 已提交
1453
  if (QUERY_NODE_FUNCTION == nodeType(pNode)) {
D
dapan 已提交
1454
    return sclWalkFunction(pNode, ctx);
D
dapan1121 已提交
1455
  }
D
dapan1121 已提交
1456

D
dapan1121 已提交
1457
  if (QUERY_NODE_LOGIC_CONDITION == nodeType(pNode)) {
D
dapan 已提交
1458
    return sclWalkLogic(pNode, ctx);
D
dapan1121 已提交
1459
  }
D
dapan1121 已提交
1460

1461 1462 1463
  if (QUERY_NODE_TARGET == nodeType(pNode)) {
    return sclWalkTarget(pNode, ctx);
  }
D
dapan1121 已提交
1464

D
dapan1121 已提交
1465 1466 1467 1468
  if (QUERY_NODE_CASE_WHEN == nodeType(pNode)) {
    return sclWalkCaseWhen(pNode, ctx);
  }

D
dapan 已提交
1469
  sclError("invalid node type for scalar calculating, type:%d", nodeType(pNode));
D
dapan1121 已提交
1470 1471
  ctx->code = TSDB_CODE_QRY_INVALID_INPUT;
  return DEAL_RES_ERROR;
D
dapan1121 已提交
1472 1473
}

D
dapan1121 已提交
1474
int32_t sclCalcConstants(SNode *pNode, bool dual, SNode **pRes) {
D
dapan1121 已提交
1475 1476 1477 1478
  if (NULL == pNode) {
    SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
  }

H
Hongze Cheng 已提交
1479
  int32_t    code = 0;
D
dapan 已提交
1480
  SScalarCtx ctx = {0};
D
dapan1121 已提交
1481
  ctx.dual = dual;
1482
  ctx.pRes = taosHashInit(SCL_DEFAULT_OP_NUM, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
D
dapan 已提交
1483
  if (NULL == ctx.pRes) {
1484
    sclError("taosHashInit failed, num:%d", SCL_DEFAULT_OP_NUM);
S
Shengliang Guan 已提交
1485
    SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
D
dapan 已提交
1486
  }
G
Ganlin Zhao 已提交
1487

X
Xiaoyu Wang 已提交
1488
  nodesRewriteExprPostOrder(&pNode, sclConstantsRewriter, (void *)&ctx);
D
dapan 已提交
1489
  SCL_ERR_JRET(ctx.code);
D
dapan1121 已提交
1490 1491
  *pRes = pNode;

D
dapan 已提交
1492
_return:
1493

D
dapan 已提交
1494 1495
  sclFreeRes(ctx.pRes);
  return code;
D
dapan1121 已提交
1496
}
D
dapan1121 已提交
1497

H
Hongze Cheng 已提交
1498 1499
static int32_t sclGetMinusOperatorResType(SOperatorNode *pOp) {
  if (!IS_MATHABLE_TYPE(((SExprNode *)(pOp->pLeft))->resType.type)) {
1500 1501 1502 1503 1504 1505 1506
    return TSDB_CODE_TSC_INVALID_OPERATION;
  }
  pOp->node.resType.type = TSDB_DATA_TYPE_DOUBLE;
  pOp->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_DOUBLE].bytes;
  return TSDB_CODE_SUCCESS;
}

H
Hongze Cheng 已提交
1507
static int32_t sclGetMathOperatorResType(SOperatorNode *pOp) {
G
Ganlin Zhao 已提交
1508 1509 1510 1511
  if (pOp == NULL || pOp->pLeft == NULL || pOp->pRight == NULL) {
    return TSDB_CODE_TSC_INVALID_OPERATION;
  }

H
Hongze Cheng 已提交
1512 1513
  SDataType ldt = ((SExprNode *)(pOp->pLeft))->resType;
  SDataType rdt = ((SExprNode *)(pOp->pRight))->resType;
G
Ganlin Zhao 已提交
1514

1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533
  if ((TSDB_DATA_TYPE_TIMESTAMP == ldt.type && TSDB_DATA_TYPE_TIMESTAMP == rdt.type) ||
      (TSDB_DATA_TYPE_TIMESTAMP == ldt.type && (IS_VAR_DATA_TYPE(rdt.type) || IS_FLOAT_TYPE(rdt.type))) ||
      (TSDB_DATA_TYPE_TIMESTAMP == rdt.type && (IS_VAR_DATA_TYPE(ldt.type) || IS_FLOAT_TYPE(ldt.type)))) {
    return TSDB_CODE_TSC_INVALID_OPERATION;
  }

  if ((TSDB_DATA_TYPE_TIMESTAMP == ldt.type && IS_INTEGER_TYPE(rdt.type)) ||
      (TSDB_DATA_TYPE_TIMESTAMP == rdt.type && IS_INTEGER_TYPE(ldt.type)) ||
      (TSDB_DATA_TYPE_TIMESTAMP == ldt.type && TSDB_DATA_TYPE_BOOL == rdt.type) ||
      (TSDB_DATA_TYPE_TIMESTAMP == rdt.type && TSDB_DATA_TYPE_BOOL == ldt.type)) {
    pOp->node.resType.type = TSDB_DATA_TYPE_TIMESTAMP;
    pOp->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_TIMESTAMP].bytes;
  } else {
    pOp->node.resType.type = TSDB_DATA_TYPE_DOUBLE;
    pOp->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_DOUBLE].bytes;
  }
  return TSDB_CODE_SUCCESS;
}

H
Hongze Cheng 已提交
1534
static int32_t sclGetCompOperatorResType(SOperatorNode *pOp) {
G
Ganlin Zhao 已提交
1535
  if (pOp == NULL || pOp->pLeft == NULL) {
G
Ganlin Zhao 已提交
1536 1537 1538
    return TSDB_CODE_TSC_INVALID_OPERATION;
  }

H
Hongze Cheng 已提交
1539
  SDataType ldt = ((SExprNode *)(pOp->pLeft))->resType;
G
Ganlin Zhao 已提交
1540

1541
  if (OP_TYPE_IN == pOp->opType || OP_TYPE_NOT_IN == pOp->opType) {
G
Ganlin Zhao 已提交
1542 1543 1544
    if (pOp->pRight == NULL) {
      return TSDB_CODE_TSC_INVALID_OPERATION;
    }
H
Hongze Cheng 已提交
1545
    ((SExprNode *)(pOp->pRight))->resType = ldt;
1546
  } else if (nodesIsRegularOp(pOp)) {
G
Ganlin Zhao 已提交
1547 1548 1549
    if (pOp->pRight == NULL) {
      return TSDB_CODE_TSC_INVALID_OPERATION;
    }
H
Hongze Cheng 已提交
1550
    SDataType rdt = ((SExprNode *)(pOp->pRight))->resType;
1551 1552 1553
    if (!IS_VAR_DATA_TYPE(ldt.type) || QUERY_NODE_VALUE != nodeType(pOp->pRight) ||
        (!IS_STR_DATA_TYPE(rdt.type) && (rdt.type != TSDB_DATA_TYPE_NULL))) {
      return TSDB_CODE_TSC_INVALID_OPERATION;
1554 1555 1556 1557 1558 1559 1560
    }
  }
  pOp->node.resType.type = TSDB_DATA_TYPE_BOOL;
  pOp->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;
  return TSDB_CODE_SUCCESS;
}

H
Hongze Cheng 已提交
1561
static int32_t sclGetJsonOperatorResType(SOperatorNode *pOp) {
G
Ganlin Zhao 已提交
1562 1563 1564 1565
  if (pOp == NULL || pOp->pLeft == NULL || pOp->pRight == NULL) {
    return TSDB_CODE_TSC_INVALID_OPERATION;
  }

H
Hongze Cheng 已提交
1566 1567
  SDataType ldt = ((SExprNode *)(pOp->pLeft))->resType;
  SDataType rdt = ((SExprNode *)(pOp->pRight))->resType;
G
Ganlin Zhao 已提交
1568

1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580
  if (TSDB_DATA_TYPE_JSON != ldt.type || !IS_STR_DATA_TYPE(rdt.type)) {
    return TSDB_CODE_TSC_INVALID_OPERATION;
  }
  if (pOp->opType == OP_TYPE_JSON_GET_VALUE) {
    pOp->node.resType.type = TSDB_DATA_TYPE_JSON;
  } else if (pOp->opType == OP_TYPE_JSON_CONTAINS) {
    pOp->node.resType.type = TSDB_DATA_TYPE_BOOL;
  }
  pOp->node.resType.bytes = tDataTypes[pOp->node.resType.type].bytes;
  return TSDB_CODE_SUCCESS;
}

H
Hongze Cheng 已提交
1581
static int32_t sclGetBitwiseOperatorResType(SOperatorNode *pOp) {
1582 1583 1584 1585 1586
  pOp->node.resType.type = TSDB_DATA_TYPE_BIGINT;
  pOp->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes;
  return TSDB_CODE_SUCCESS;
}

H
Hongze Cheng 已提交
1587
int32_t scalarCalculateConstants(SNode *pNode, SNode **pRes) { return sclCalcConstants(pNode, false, pRes); }
D
dapan1121 已提交
1588

H
Hongze Cheng 已提交
1589
int32_t scalarCalculateConstantsFromDual(SNode *pNode, SNode **pRes) { return sclCalcConstants(pNode, true, pRes); }
D
dapan1121 已提交
1590 1591 1592 1593 1594 1595

int32_t scalarCalculate(SNode *pNode, SArray *pBlockList, SScalarParam *pDst) {
  if (NULL == pNode || NULL == pBlockList) {
    SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT);
  }

H
Hongze Cheng 已提交
1596
  int32_t    code = 0;
D
dapan1121 已提交
1597 1598 1599 1600 1601 1602
  SScalarCtx ctx = {.code = 0, .pBlockList = pBlockList, .param = pDst ? pDst->param : NULL};

  // TODO: OPT performance
  ctx.pRes = taosHashInit(SCL_DEFAULT_OP_NUM, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
  if (NULL == ctx.pRes) {
    sclError("taosHashInit failed, num:%d", SCL_DEFAULT_OP_NUM);
S
Shengliang Guan 已提交
1603
    SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
D
dapan1121 已提交
1604
  }
1605

D
dapan1121 已提交
1606 1607 1608 1609 1610 1611 1612
  nodesWalkExprPostOrder(pNode, sclCalcWalker, (void *)&ctx);
  SCL_ERR_JRET(ctx.code);

  if (pDst) {
    SScalarParam *res = (SScalarParam *)taosHashGet(ctx.pRes, (void *)&pNode, POINTER_BYTES);
    if (NULL == res) {
      sclError("no valid res in hash, node:%p, type:%d", pNode, nodeType(pNode));
S
Shengliang Guan 已提交
1613
      SCL_ERR_JRET(TSDB_CODE_APP_ERROR);
D
dapan1121 已提交
1614 1615 1616 1617 1618
    }

    if (1 == res->numOfRows) {
      SCL_ERR_JRET(sclExtendResRows(pDst, res, pBlockList));
    } else {
H
Haojun Liao 已提交
1619
      colInfoDataEnsureCapacity(pDst->columnData, res->numOfRows, true);
D
dapan1121 已提交
1620 1621
      colDataAssign(pDst->columnData, res->columnData, res->numOfRows, NULL);
      pDst->numOfRows = res->numOfRows;
1622
      pDst->numOfQualified = res->numOfQualified;
D
dapan1121 已提交
1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633
    }

    sclFreeParam(res);
    taosHashRemove(ctx.pRes, (void *)&pNode, POINTER_BYTES);
  }

_return:
  sclFreeRes(ctx.pRes);
  return code;
}

H
Hongze Cheng 已提交
1634 1635 1636
int32_t scalarGetOperatorResultType(SOperatorNode *pOp) {
  if (TSDB_DATA_TYPE_BLOB == ((SExprNode *)(pOp->pLeft))->resType.type ||
      (NULL != pOp->pRight && TSDB_DATA_TYPE_BLOB == ((SExprNode *)(pOp->pRight))->resType.type)) {
1637 1638 1639 1640 1641
    return TSDB_CODE_TSC_INVALID_OPERATION;
  }

  switch (pOp->opType) {
    case OP_TYPE_ADD:
D
dapan1121 已提交
1642 1643 1644 1645
    case OP_TYPE_SUB:
    case OP_TYPE_MULTI:
    case OP_TYPE_DIV:
    case OP_TYPE_REM:
D
dapan1121 已提交
1646
      return sclGetMathOperatorResType(pOp);
D
dapan1121 已提交
1647
    case OP_TYPE_MINUS:
D
dapan1121 已提交
1648
      return sclGetMinusOperatorResType(pOp);
1649
    case OP_TYPE_ASSIGN:
H
Hongze Cheng 已提交
1650
      pOp->node.resType = ((SExprNode *)(pOp->pLeft))->resType;
1651 1652 1653
      break;
    case OP_TYPE_BIT_AND:
    case OP_TYPE_BIT_OR:
D
dapan1121 已提交
1654
      return sclGetBitwiseOperatorResType(pOp);
D
dapan1121 已提交
1655 1656 1657 1658 1659 1660
    case OP_TYPE_GREATER_THAN:
    case OP_TYPE_GREATER_EQUAL:
    case OP_TYPE_LOWER_THAN:
    case OP_TYPE_LOWER_EQUAL:
    case OP_TYPE_EQUAL:
    case OP_TYPE_NOT_EQUAL:
1661 1662 1663 1664 1665 1666 1667 1668
    case OP_TYPE_IS_NULL:
    case OP_TYPE_IS_NOT_NULL:
    case OP_TYPE_IS_TRUE:
    case OP_TYPE_IS_FALSE:
    case OP_TYPE_IS_UNKNOWN:
    case OP_TYPE_IS_NOT_TRUE:
    case OP_TYPE_IS_NOT_FALSE:
    case OP_TYPE_IS_NOT_UNKNOWN:
D
dapan1121 已提交
1669 1670 1671 1672
    case OP_TYPE_LIKE:
    case OP_TYPE_NOT_LIKE:
    case OP_TYPE_MATCH:
    case OP_TYPE_NMATCH:
1673 1674
    case OP_TYPE_IN:
    case OP_TYPE_NOT_IN:
D
dapan1121 已提交
1675
      return sclGetCompOperatorResType(pOp);
D
dapan1121 已提交
1676
    case OP_TYPE_JSON_GET_VALUE:
1677
    case OP_TYPE_JSON_CONTAINS:
D
dapan1121 已提交
1678
      return sclGetJsonOperatorResType(pOp);
D
dapan1121 已提交
1679
    default:
1680
      break;
D
dapan1121 已提交
1681 1682
  }

1683 1684
  return TSDB_CODE_SUCCESS;
}