nodesUtilFuncs.c 71.5 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 * 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/>.
 */

16
#include "cmdnodes.h"
X
Xiaoyu Wang 已提交
17
#include "nodesUtil.h"
X
Xiaoyu Wang 已提交
18
#include "plannodes.h"
19
#include "querynodes.h"
X
Xiaoyu Wang 已提交
20
#include "taos.h"
21
#include "taoserror.h"
wmmhello's avatar
wmmhello 已提交
22
#include "tdatablock.h"
X
Xiaoyu Wang 已提交
23
#include "thash.h"
24
#include "tref.h"
25

26 27 28 29 30 31 32 33
typedef struct SNodeMemChunk {
  int32_t               availableSize;
  int32_t               usedSize;
  char*                 pBuf;
  struct SNodeMemChunk* pNext;
} SNodeMemChunk;

typedef struct SNodeAllocator {
34
  int64_t        self;
35
  int64_t        queryId;
36 37 38 39
  int32_t        chunkSize;
  int32_t        chunkNum;
  SNodeMemChunk* pCurrChunk;
  SNodeMemChunk* pChunks;
40
  TdThreadMutex  mutex;
41 42
} SNodeAllocator;

43 44
static threadlocal SNodeAllocator* g_pNodeAllocator;
static int32_t                     g_allocatorReqRefPool = -1;
45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

static SNodeMemChunk* callocNodeChunk(SNodeAllocator* pAllocator) {
  SNodeMemChunk* pNewChunk = taosMemoryCalloc(1, sizeof(SNodeMemChunk) + pAllocator->chunkSize);
  if (NULL == pNewChunk) {
    return NULL;
  }
  pNewChunk->pBuf = (char*)(pNewChunk + 1);
  pNewChunk->availableSize = pAllocator->chunkSize;
  pNewChunk->usedSize = 0;
  pNewChunk->pNext = NULL;
  if (NULL != pAllocator->pCurrChunk) {
    pAllocator->pCurrChunk->pNext = pNewChunk;
  }
  pAllocator->pCurrChunk = pNewChunk;
  if (NULL == pAllocator->pChunks) {
    pAllocator->pChunks = pNewChunk;
  }
  ++(pAllocator->chunkNum);
  return pNewChunk;
}

66
static void* nodesCallocImpl(int32_t size) {
67
  if (NULL == g_pNodeAllocator) {
68
    return taosMemoryCalloc(1, size);
69 70
  }

71 72
  if (g_pNodeAllocator->pCurrChunk->usedSize + size > g_pNodeAllocator->pCurrChunk->availableSize) {
    if (NULL == callocNodeChunk(g_pNodeAllocator)) {
73 74 75
      return NULL;
    }
  }
76 77
  void* p = g_pNodeAllocator->pCurrChunk->pBuf + g_pNodeAllocator->pCurrChunk->usedSize;
  g_pNodeAllocator->pCurrChunk->usedSize += size;
78 79 80
  return p;
}

81 82 83 84 85
static void* nodesCalloc(int32_t num, int32_t size) {
  void* p = nodesCallocImpl(num * size + 1);
  if (NULL == p) {
    return NULL;
  }
86
  *(char*)p = (NULL != g_pNodeAllocator) ? 1 : 0;
87 88 89
  return (char*)p + 1;
}

90
static void nodesFree(void* p) {
91 92 93
  char* ptr = (char*)p - 1;
  if (0 == *ptr) {
    taosMemoryFree(ptr);
94 95 96 97
  }
  return;
}

98
static int32_t createNodeAllocator(int32_t chunkSize, SNodeAllocator** pAllocator) {
99 100 101 102 103 104 105 106 107
  *pAllocator = taosMemoryCalloc(1, sizeof(SNodeAllocator));
  if (NULL == *pAllocator) {
    return TSDB_CODE_OUT_OF_MEMORY;
  }
  (*pAllocator)->chunkSize = chunkSize;
  if (NULL == callocNodeChunk(*pAllocator)) {
    taosMemoryFreeClear(*pAllocator);
    return TSDB_CODE_OUT_OF_MEMORY;
  }
108
  taosThreadMutexInit(&(*pAllocator)->mutex, NULL);
109 110 111
  return TSDB_CODE_SUCCESS;
}

112
static void destroyNodeAllocator(void* p) {
113
  if (NULL == p) {
114 115 116
    return;
  }

117 118
  SNodeAllocator* pAllocator = p;

119 120
  nodesDebug("query id %" PRIx64 " allocator id %" PRIx64 " alloc chunkNum: %d, chunkTotakSize: %d",
             pAllocator->queryId, pAllocator->self, pAllocator->chunkNum, pAllocator->chunkNum * pAllocator->chunkSize);
121 122 123 124 125 126 127

  SNodeMemChunk* pChunk = pAllocator->pChunks;
  while (NULL != pChunk) {
    SNodeMemChunk* pTemp = pChunk->pNext;
    taosMemoryFree(pChunk);
    pChunk = pTemp;
  }
128
  taosThreadMutexDestroy(&pAllocator->mutex);
129 130 131
  taosMemoryFree(pAllocator);
}

132 133 134 135 136 137 138 139 140 141 142 143 144 145
int32_t nodesInitAllocatorSet() {
  if (g_allocatorReqRefPool >= 0) {
    nodesWarn("nodes already initialized");
    return TSDB_CODE_SUCCESS;
  }

  g_allocatorReqRefPool = taosOpenRef(1024, destroyNodeAllocator);
  if (g_allocatorReqRefPool < 0) {
    nodesError("init nodes failed");
    return TSDB_CODE_OUT_OF_MEMORY;
  }

  return TSDB_CODE_SUCCESS;
}
146

147 148 149 150 151 152 153 154 155 156 157 158 159 160
void nodesDestroyAllocatorSet() {
  if (g_allocatorReqRefPool >= 0) {
    SNodeAllocator* pAllocator = taosIterateRef(g_allocatorReqRefPool, 0);
    int64_t         refId = 0;
    while (NULL != pAllocator) {
      refId = pAllocator->self;
      taosRemoveRef(g_allocatorReqRefPool, refId);
      pAllocator = taosIterateRef(g_allocatorReqRefPool, refId);
    }
    taosCloseRef(g_allocatorReqRefPool);
  }
}

int32_t nodesCreateAllocator(int64_t queryId, int32_t chunkSize, int64_t* pAllocatorId) {
161
  SNodeAllocator* pAllocator = NULL;
162
  int32_t         code = createNodeAllocator(chunkSize, &pAllocator);
163
  if (TSDB_CODE_SUCCESS == code) {
164 165 166 167 168 169
    pAllocator->self = taosAddRef(g_allocatorReqRefPool, pAllocator);
    if (pAllocator->self <= 0) {
      return terrno;
    }
    pAllocator->queryId = queryId;
    *pAllocatorId = pAllocator->self;
170 171 172 173
  }
  return code;
}

174 175 176
int32_t nodesAcquireAllocator(int64_t allocatorId) {
  if (allocatorId <= 0) {
    return TSDB_CODE_SUCCESS;
177
  }
178 179 180 181 182 183 184 185

  SNodeAllocator* pAllocator = taosAcquireRef(g_allocatorReqRefPool, allocatorId);
  if (NULL == pAllocator) {
    return terrno;
  }
  taosThreadMutexLock(&pAllocator->mutex);
  g_pNodeAllocator = pAllocator;
  return TSDB_CODE_SUCCESS;
186 187
}

188 189 190 191 192
int32_t nodesReleaseAllocator(int64_t allocatorId) {
  if (allocatorId <= 0) {
    return TSDB_CODE_SUCCESS;
  }

D
dapan1121 已提交
193
  if (NULL == g_pNodeAllocator) {
194 195 196 197 198
    nodesError("allocator id %" PRIx64
               " release failed: The nodesReleaseAllocator function needs to be called after the nodesAcquireAllocator "
               "function is called!",
               allocatorId);
    return TSDB_CODE_FAILED;
199
  }
D
dapan1121 已提交
200
  SNodeAllocator* pAllocator = g_pNodeAllocator;
201 202 203
  g_pNodeAllocator = NULL;
  taosThreadMutexUnlock(&pAllocator->mutex);
  return taosReleaseRef(g_allocatorReqRefPool, allocatorId);
204 205
}

206 207 208
int64_t nodesMakeAllocatorWeakRef(int64_t allocatorId) {
  if (allocatorId <= 0) {
    return 0;
209
  }
210 211

  SNodeAllocator* pAllocator = taosAcquireRef(g_allocatorReqRefPool, allocatorId);
X
Xiaoyu Wang 已提交
212 213 214 215
  if (NULL == pAllocator) {
    nodesError("allocator id %" PRIx64 " weak reference failed", allocatorId);
    return -1;
  }
216 217 218
  return pAllocator->self;
}

219 220 221 222 223 224 225 226 227 228
int64_t nodesReleaseAllocatorWeakRef(int64_t allocatorId) { return taosReleaseRef(g_allocatorReqRefPool, allocatorId); }

void nodesDestroyAllocator(int64_t allocatorId) {
  if (allocatorId <= 0) {
    return;
  }

  taosRemoveRef(g_allocatorReqRefPool, allocatorId);
}

229 230
static SNode* makeNode(ENodeType type, int32_t size) {
  SNode* p = nodesCalloc(1, size);
X
Xiaoyu Wang 已提交
231 232 233 234 235 236 237
  if (NULL == p) {
    return NULL;
  }
  setNodeType(p, type);
  return p;
}

238
SNode* nodesMakeNode(ENodeType type) {
239 240
  switch (type) {
    case QUERY_NODE_COLUMN:
X
Xiaoyu Wang 已提交
241
      return makeNode(type, sizeof(SColumnNode));
242
    case QUERY_NODE_VALUE:
X
Xiaoyu Wang 已提交
243
      return makeNode(type, sizeof(SValueNode));
244
    case QUERY_NODE_OPERATOR:
X
Xiaoyu Wang 已提交
245
      return makeNode(type, sizeof(SOperatorNode));
246
    case QUERY_NODE_LOGIC_CONDITION:
X
Xiaoyu Wang 已提交
247
      return makeNode(type, sizeof(SLogicConditionNode));
248
    case QUERY_NODE_FUNCTION:
X
Xiaoyu Wang 已提交
249
      return makeNode(type, sizeof(SFunctionNode));
250
    case QUERY_NODE_REAL_TABLE:
X
Xiaoyu Wang 已提交
251
      return makeNode(type, sizeof(SRealTableNode));
252
    case QUERY_NODE_TEMP_TABLE:
X
Xiaoyu Wang 已提交
253
      return makeNode(type, sizeof(STempTableNode));
254
    case QUERY_NODE_JOIN_TABLE:
X
Xiaoyu Wang 已提交
255
      return makeNode(type, sizeof(SJoinTableNode));
256
    case QUERY_NODE_GROUPING_SET:
X
Xiaoyu Wang 已提交
257
      return makeNode(type, sizeof(SGroupingSetNode));
258
    case QUERY_NODE_ORDER_BY_EXPR:
X
Xiaoyu Wang 已提交
259
      return makeNode(type, sizeof(SOrderByExprNode));
260
    case QUERY_NODE_LIMIT:
X
Xiaoyu Wang 已提交
261
      return makeNode(type, sizeof(SLimitNode));
262
    case QUERY_NODE_STATE_WINDOW:
X
Xiaoyu Wang 已提交
263
      return makeNode(type, sizeof(SStateWindowNode));
264
    case QUERY_NODE_SESSION_WINDOW:
X
Xiaoyu Wang 已提交
265
      return makeNode(type, sizeof(SSessionWindowNode));
266
    case QUERY_NODE_INTERVAL_WINDOW:
X
Xiaoyu Wang 已提交
267
      return makeNode(type, sizeof(SIntervalWindowNode));
268
    case QUERY_NODE_NODE_LIST:
X
Xiaoyu Wang 已提交
269
      return makeNode(type, sizeof(SNodeListNode));
270
    case QUERY_NODE_FILL:
X
Xiaoyu Wang 已提交
271
      return makeNode(type, sizeof(SFillNode));
272
    case QUERY_NODE_RAW_EXPR:
X
Xiaoyu Wang 已提交
273
      return makeNode(type, sizeof(SRawExprNode));
274
    case QUERY_NODE_TARGET:
X
Xiaoyu Wang 已提交
275
      return makeNode(type, sizeof(STargetNode));
276
    case QUERY_NODE_DATABLOCK_DESC:
X
Xiaoyu Wang 已提交
277
      return makeNode(type, sizeof(SDataBlockDescNode));
278
    case QUERY_NODE_SLOT_DESC:
X
Xiaoyu Wang 已提交
279
      return makeNode(type, sizeof(SSlotDescNode));
280
    case QUERY_NODE_COLUMN_DEF:
X
Xiaoyu Wang 已提交
281
      return makeNode(type, sizeof(SColumnDefNode));
X
Xiaoyu Wang 已提交
282
    case QUERY_NODE_DOWNSTREAM_SOURCE:
X
Xiaoyu Wang 已提交
283
      return makeNode(type, sizeof(SDownstreamSourceNode));
X
Xiaoyu Wang 已提交
284
    case QUERY_NODE_DATABASE_OPTIONS:
X
Xiaoyu Wang 已提交
285
      return makeNode(type, sizeof(SDatabaseOptions));
X
Xiaoyu Wang 已提交
286
    case QUERY_NODE_TABLE_OPTIONS:
X
Xiaoyu Wang 已提交
287
      return makeNode(type, sizeof(STableOptions));
X
Xiaoyu Wang 已提交
288
    case QUERY_NODE_INDEX_OPTIONS:
X
Xiaoyu Wang 已提交
289
      return makeNode(type, sizeof(SIndexOptions));
290
    case QUERY_NODE_EXPLAIN_OPTIONS:
X
Xiaoyu Wang 已提交
291
      return makeNode(type, sizeof(SExplainOptions));
292
    case QUERY_NODE_STREAM_OPTIONS:
X
Xiaoyu Wang 已提交
293
      return makeNode(type, sizeof(SStreamOptions));
294
    case QUERY_NODE_LEFT_VALUE:
X
Xiaoyu Wang 已提交
295
      return makeNode(type, sizeof(SLeftValueNode));
296 297
    case QUERY_NODE_COLUMN_REF:
      return makeNode(type, sizeof(SColumnDefNode));
X
Xiaoyu Wang 已提交
298 299 300 301
    case QUERY_NODE_WHEN_THEN:
      return makeNode(type, sizeof(SWhenThenNode));
    case QUERY_NODE_CASE_WHEN:
      return makeNode(type, sizeof(SCaseWhenNode));
X
Xiaoyu Wang 已提交
302 303
    case QUERY_NODE_EVENT_WINDOW:
      return makeNode(type, sizeof(SEventWindowNode));
304
    case QUERY_NODE_SET_OPERATOR:
X
Xiaoyu Wang 已提交
305
      return makeNode(type, sizeof(SSetOperator));
306
    case QUERY_NODE_SELECT_STMT:
X
Xiaoyu Wang 已提交
307
      return makeNode(type, sizeof(SSelectStmt));
X
Xiaoyu Wang 已提交
308 309
    case QUERY_NODE_VNODE_MODIFY_STMT:
      return makeNode(type, sizeof(SVnodeModifyOpStmt));
310
    case QUERY_NODE_CREATE_DATABASE_STMT:
X
Xiaoyu Wang 已提交
311
      return makeNode(type, sizeof(SCreateDatabaseStmt));
312
    case QUERY_NODE_DROP_DATABASE_STMT:
X
Xiaoyu Wang 已提交
313
      return makeNode(type, sizeof(SDropDatabaseStmt));
314
    case QUERY_NODE_ALTER_DATABASE_STMT:
X
Xiaoyu Wang 已提交
315
      return makeNode(type, sizeof(SAlterDatabaseStmt));
X
Xiaoyu Wang 已提交
316 317
    case QUERY_NODE_FLUSH_DATABASE_STMT:
      return makeNode(type, sizeof(SFlushDatabaseStmt));
X
Xiaoyu Wang 已提交
318 319
    case QUERY_NODE_TRIM_DATABASE_STMT:
      return makeNode(type, sizeof(STrimDatabaseStmt));
320
    case QUERY_NODE_CREATE_TABLE_STMT:
X
Xiaoyu Wang 已提交
321
      return makeNode(type, sizeof(SCreateTableStmt));
322
    case QUERY_NODE_CREATE_SUBTABLE_CLAUSE:
X
Xiaoyu Wang 已提交
323
      return makeNode(type, sizeof(SCreateSubTableClause));
X
Xiaoyu Wang 已提交
324 325
    case QUERY_NODE_CREATE_MULTI_TABLES_STMT:
      return makeNode(type, sizeof(SCreateMultiTablesStmt));
326
    case QUERY_NODE_DROP_TABLE_CLAUSE:
X
Xiaoyu Wang 已提交
327
      return makeNode(type, sizeof(SDropTableClause));
328
    case QUERY_NODE_DROP_TABLE_STMT:
X
Xiaoyu Wang 已提交
329
      return makeNode(type, sizeof(SDropTableStmt));
330
    case QUERY_NODE_DROP_SUPER_TABLE_STMT:
X
Xiaoyu Wang 已提交
331
      return makeNode(type, sizeof(SDropSuperTableStmt));
332
    case QUERY_NODE_ALTER_TABLE_STMT:
333
    case QUERY_NODE_ALTER_SUPER_TABLE_STMT:
X
Xiaoyu Wang 已提交
334
      return makeNode(type, sizeof(SAlterTableStmt));
335
    case QUERY_NODE_CREATE_USER_STMT:
X
Xiaoyu Wang 已提交
336
      return makeNode(type, sizeof(SCreateUserStmt));
337
    case QUERY_NODE_ALTER_USER_STMT:
X
Xiaoyu Wang 已提交
338
      return makeNode(type, sizeof(SAlterUserStmt));
339
    case QUERY_NODE_DROP_USER_STMT:
X
Xiaoyu Wang 已提交
340
      return makeNode(type, sizeof(SDropUserStmt));
341
    case QUERY_NODE_USE_DATABASE_STMT:
X
Xiaoyu Wang 已提交
342
      return makeNode(type, sizeof(SUseDatabaseStmt));
343
    case QUERY_NODE_CREATE_DNODE_STMT:
X
Xiaoyu Wang 已提交
344
      return makeNode(type, sizeof(SCreateDnodeStmt));
345
    case QUERY_NODE_DROP_DNODE_STMT:
X
Xiaoyu Wang 已提交
346
      return makeNode(type, sizeof(SDropDnodeStmt));
347
    case QUERY_NODE_ALTER_DNODE_STMT:
X
Xiaoyu Wang 已提交
348
      return makeNode(type, sizeof(SAlterDnodeStmt));
X
Xiaoyu Wang 已提交
349
    case QUERY_NODE_CREATE_INDEX_STMT:
X
Xiaoyu Wang 已提交
350
      return makeNode(type, sizeof(SCreateIndexStmt));
351
    case QUERY_NODE_DROP_INDEX_STMT:
X
Xiaoyu Wang 已提交
352
      return makeNode(type, sizeof(SDropIndexStmt));
X
Xiaoyu Wang 已提交
353
    case QUERY_NODE_CREATE_QNODE_STMT:
354 355 356
    case QUERY_NODE_CREATE_BNODE_STMT:
    case QUERY_NODE_CREATE_SNODE_STMT:
    case QUERY_NODE_CREATE_MNODE_STMT:
X
Xiaoyu Wang 已提交
357
      return makeNode(type, sizeof(SCreateComponentNodeStmt));
358
    case QUERY_NODE_DROP_QNODE_STMT:
359 360 361
    case QUERY_NODE_DROP_BNODE_STMT:
    case QUERY_NODE_DROP_SNODE_STMT:
    case QUERY_NODE_DROP_MNODE_STMT:
X
Xiaoyu Wang 已提交
362
      return makeNode(type, sizeof(SDropComponentNodeStmt));
363
    case QUERY_NODE_CREATE_TOPIC_STMT:
X
Xiaoyu Wang 已提交
364
      return makeNode(type, sizeof(SCreateTopicStmt));
365
    case QUERY_NODE_DROP_TOPIC_STMT:
X
Xiaoyu Wang 已提交
366 367 368
      return makeNode(type, sizeof(SDropTopicStmt));
    case QUERY_NODE_DROP_CGROUP_STMT:
      return makeNode(type, sizeof(SDropCGroupStmt));
369 370
    case QUERY_NODE_ALTER_LOCAL_STMT:
      return makeNode(type, sizeof(SAlterLocalStmt));
371
    case QUERY_NODE_EXPLAIN_STMT:
X
Xiaoyu Wang 已提交
372
      return makeNode(type, sizeof(SExplainStmt));
373
    case QUERY_NODE_DESCRIBE_STMT:
X
Xiaoyu Wang 已提交
374
      return makeNode(type, sizeof(SDescribeStmt));
375
    case QUERY_NODE_RESET_QUERY_CACHE_STMT:
X
Xiaoyu Wang 已提交
376
      return makeNode(type, sizeof(SNode));
377
    case QUERY_NODE_COMPACT_STMT:
378
      break;
379
    case QUERY_NODE_CREATE_FUNCTION_STMT:
X
Xiaoyu Wang 已提交
380
      return makeNode(type, sizeof(SCreateFunctionStmt));
381
    case QUERY_NODE_DROP_FUNCTION_STMT:
X
Xiaoyu Wang 已提交
382
      return makeNode(type, sizeof(SDropFunctionStmt));
383
    case QUERY_NODE_CREATE_STREAM_STMT:
X
Xiaoyu Wang 已提交
384
      return makeNode(type, sizeof(SCreateStreamStmt));
385
    case QUERY_NODE_DROP_STREAM_STMT:
X
Xiaoyu Wang 已提交
386
      return makeNode(type, sizeof(SDropStreamStmt));
X
Xiaoyu Wang 已提交
387 388
    case QUERY_NODE_BALANCE_VGROUP_STMT:
      return makeNode(type, sizeof(SBalanceVgroupStmt));
389
    case QUERY_NODE_MERGE_VGROUP_STMT:
X
Xiaoyu Wang 已提交
390
      return makeNode(type, sizeof(SMergeVgroupStmt));
391
    case QUERY_NODE_REDISTRIBUTE_VGROUP_STMT:
X
Xiaoyu Wang 已提交
392
      return makeNode(type, sizeof(SRedistributeVgroupStmt));
393
    case QUERY_NODE_SPLIT_VGROUP_STMT:
X
Xiaoyu Wang 已提交
394
      return makeNode(type, sizeof(SSplitVgroupStmt));
395 396
    case QUERY_NODE_SYNCDB_STMT:
      break;
397
    case QUERY_NODE_GRANT_STMT:
X
Xiaoyu Wang 已提交
398
      return makeNode(type, sizeof(SGrantStmt));
399
    case QUERY_NODE_REVOKE_STMT:
X
Xiaoyu Wang 已提交
400
      return makeNode(type, sizeof(SRevokeStmt));
401
    case QUERY_NODE_SHOW_DNODES_STMT:
X
Xiaoyu Wang 已提交
402
    case QUERY_NODE_SHOW_MNODES_STMT:
X
Xiaoyu Wang 已提交
403 404
    case QUERY_NODE_SHOW_MODULES_STMT:
    case QUERY_NODE_SHOW_QNODES_STMT:
405 406
    case QUERY_NODE_SHOW_SNODES_STMT:
    case QUERY_NODE_SHOW_BNODES_STMT:
407
    case QUERY_NODE_SHOW_CLUSTER_STMT:
408
    case QUERY_NODE_SHOW_DATABASES_STMT:
X
Xiaoyu Wang 已提交
409 410
    case QUERY_NODE_SHOW_FUNCTIONS_STMT:
    case QUERY_NODE_SHOW_INDEXES_STMT:
411
    case QUERY_NODE_SHOW_STABLES_STMT:
X
Xiaoyu Wang 已提交
412
    case QUERY_NODE_SHOW_STREAMS_STMT:
413 414
    case QUERY_NODE_SHOW_TABLES_STMT:
    case QUERY_NODE_SHOW_USERS_STMT:
X
Xiaoyu Wang 已提交
415
    case QUERY_NODE_SHOW_LICENCES_STMT:
416
    case QUERY_NODE_SHOW_VGROUPS_STMT:
S
Shengliang Guan 已提交
417
    case QUERY_NODE_SHOW_TOPICS_STMT:
418
    case QUERY_NODE_SHOW_CONSUMERS_STMT:
419
    case QUERY_NODE_SHOW_CONNECTIONS_STMT:
420 421
    case QUERY_NODE_SHOW_QUERIES_STMT:
    case QUERY_NODE_SHOW_VNODES_STMT:
422 423
    case QUERY_NODE_SHOW_APPS_STMT:
    case QUERY_NODE_SHOW_SCORES_STMT:
424 425
    case QUERY_NODE_SHOW_VARIABLES_STMT:
    case QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT:
426
    case QUERY_NODE_SHOW_TRANSACTIONS_STMT:
427
    case QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT:
428
    case QUERY_NODE_SHOW_TAGS_STMT:
429
    case QUERY_NODE_SHOW_USER_PRIVILEGES_STMT:
430
      return makeNode(type, sizeof(SShowStmt));
431 432
    case QUERY_NODE_SHOW_TABLE_TAGS_STMT:
      return makeNode(type, sizeof(SShowTableTagsStmt));
433 434
    case QUERY_NODE_SHOW_DNODE_VARIABLES_STMT:
      return makeNode(type, sizeof(SShowDnodeVariablesStmt));
435
    case QUERY_NODE_SHOW_CREATE_DATABASE_STMT:
436
      return makeNode(type, sizeof(SShowCreateDatabaseStmt));
437 438 439
    case QUERY_NODE_SHOW_DB_ALIVE_STMT:
    case QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT:
      return makeNode(type, sizeof(SShowAliveStmt));      
440 441
    case QUERY_NODE_SHOW_CREATE_TABLE_STMT:
    case QUERY_NODE_SHOW_CREATE_STABLE_STMT:
442
      return makeNode(type, sizeof(SShowCreateTableStmt));
443 444
    case QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT:
      return makeNode(type, sizeof(SShowTableDistributedStmt));
445
    case QUERY_NODE_KILL_QUERY_STMT:
X
Xiaoyu Wang 已提交
446
      return makeNode(type, sizeof(SKillQueryStmt));
447
    case QUERY_NODE_KILL_TRANSACTION_STMT:
X
Xiaoyu Wang 已提交
448
    case QUERY_NODE_KILL_CONNECTION_STMT:
X
Xiaoyu Wang 已提交
449
      return makeNode(type, sizeof(SKillStmt));
X
Xiaoyu Wang 已提交
450 451
    case QUERY_NODE_DELETE_STMT:
      return makeNode(type, sizeof(SDeleteStmt));
452 453
    case QUERY_NODE_INSERT_STMT:
      return makeNode(type, sizeof(SInsertStmt));
454 455
    case QUERY_NODE_QUERY:
      return makeNode(type, sizeof(SQuery));
X
Xiaoyu Wang 已提交
456
    case QUERY_NODE_LOGIC_PLAN_SCAN:
X
Xiaoyu Wang 已提交
457
      return makeNode(type, sizeof(SScanLogicNode));
X
Xiaoyu Wang 已提交
458
    case QUERY_NODE_LOGIC_PLAN_JOIN:
X
Xiaoyu Wang 已提交
459
      return makeNode(type, sizeof(SJoinLogicNode));
X
Xiaoyu Wang 已提交
460
    case QUERY_NODE_LOGIC_PLAN_AGG:
X
Xiaoyu Wang 已提交
461
      return makeNode(type, sizeof(SAggLogicNode));
X
Xiaoyu Wang 已提交
462
    case QUERY_NODE_LOGIC_PLAN_PROJECT:
X
Xiaoyu Wang 已提交
463
      return makeNode(type, sizeof(SProjectLogicNode));
X
Xiaoyu Wang 已提交
464 465
    case QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY:
      return makeNode(type, sizeof(SVnodeModifyLogicNode));
X
Xiaoyu Wang 已提交
466
    case QUERY_NODE_LOGIC_PLAN_EXCHANGE:
X
Xiaoyu Wang 已提交
467
      return makeNode(type, sizeof(SExchangeLogicNode));
X
Xiaoyu Wang 已提交
468 469
    case QUERY_NODE_LOGIC_PLAN_MERGE:
      return makeNode(type, sizeof(SMergeLogicNode));
X
Xiaoyu Wang 已提交
470
    case QUERY_NODE_LOGIC_PLAN_WINDOW:
X
Xiaoyu Wang 已提交
471
      return makeNode(type, sizeof(SWindowLogicNode));
X
Xiaoyu Wang 已提交
472
    case QUERY_NODE_LOGIC_PLAN_FILL:
X
Xiaoyu Wang 已提交
473
      return makeNode(type, sizeof(SFillLogicNode));
X
Xiaoyu Wang 已提交
474
    case QUERY_NODE_LOGIC_PLAN_SORT:
X
Xiaoyu Wang 已提交
475
      return makeNode(type, sizeof(SSortLogicNode));
476
    case QUERY_NODE_LOGIC_PLAN_PARTITION:
X
Xiaoyu Wang 已提交
477
      return makeNode(type, sizeof(SPartitionLogicNode));
478 479
    case QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC:
      return makeNode(type, sizeof(SIndefRowsFuncLogicNode));
X
Xiaoyu Wang 已提交
480 481
    case QUERY_NODE_LOGIC_PLAN_INTERP_FUNC:
      return makeNode(type, sizeof(SInterpFuncLogicNode));
X
Xiaoyu Wang 已提交
482
    case QUERY_NODE_LOGIC_SUBPLAN:
X
Xiaoyu Wang 已提交
483
      return makeNode(type, sizeof(SLogicSubplan));
X
Xiaoyu Wang 已提交
484
    case QUERY_NODE_LOGIC_PLAN:
X
Xiaoyu Wang 已提交
485
      return makeNode(type, sizeof(SQueryLogicPlan));
X
Xiaoyu Wang 已提交
486
    case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN:
X
Xiaoyu Wang 已提交
487
      return makeNode(type, sizeof(STagScanPhysiNode));
X
Xiaoyu Wang 已提交
488
    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:
X
Xiaoyu Wang 已提交
489
      return makeNode(type, sizeof(STableScanPhysiNode));
490
    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN:
X
Xiaoyu Wang 已提交
491
      return makeNode(type, sizeof(STableSeqScanPhysiNode));
X
Xiaoyu Wang 已提交
492 493
    case QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN:
      return makeNode(type, sizeof(STableMergeScanPhysiNode));
494
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN:
X
Xiaoyu Wang 已提交
495
      return makeNode(type, sizeof(SStreamScanPhysiNode));
X
Xiaoyu Wang 已提交
496
    case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN:
X
Xiaoyu Wang 已提交
497
      return makeNode(type, sizeof(SSystemTableScanPhysiNode));
498 499
    case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN:
      return makeNode(type, sizeof(SBlockDistScanPhysiNode));
X
Xiaoyu Wang 已提交
500 501
    case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN:
      return makeNode(type, sizeof(SLastRowScanPhysiNode));
502 503
    case QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN:
      return makeNode(type, sizeof(STableCountScanPhysiNode));
X
Xiaoyu Wang 已提交
504
    case QUERY_NODE_PHYSICAL_PLAN_PROJECT:
X
Xiaoyu Wang 已提交
505
      return makeNode(type, sizeof(SProjectPhysiNode));
506
    case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN:
507
      return makeNode(type, sizeof(SSortMergeJoinPhysiNode));
508
    case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG:
X
Xiaoyu Wang 已提交
509
      return makeNode(type, sizeof(SAggPhysiNode));
510
    case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE:
X
Xiaoyu Wang 已提交
511
      return makeNode(type, sizeof(SExchangePhysiNode));
X
Xiaoyu Wang 已提交
512 513
    case QUERY_NODE_PHYSICAL_PLAN_MERGE:
      return makeNode(type, sizeof(SMergePhysiNode));
514
    case QUERY_NODE_PHYSICAL_PLAN_SORT:
X
Xiaoyu Wang 已提交
515
      return makeNode(type, sizeof(SSortPhysiNode));
516 517
    case QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT:
      return makeNode(type, sizeof(SGroupSortPhysiNode));
X
Xiaoyu Wang 已提交
518
    case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL:
X
Xiaoyu Wang 已提交
519
      return makeNode(type, sizeof(SIntervalPhysiNode));
520 521
    case QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL:
      return makeNode(type, sizeof(SMergeAlignedIntervalPhysiNode));
X
Xiaoyu Wang 已提交
522
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL:
X
Xiaoyu Wang 已提交
523
      return makeNode(type, sizeof(SStreamIntervalPhysiNode));
524 525 526 527
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL:
      return makeNode(type, sizeof(SStreamFinalIntervalPhysiNode));
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL:
      return makeNode(type, sizeof(SStreamSemiIntervalPhysiNode));
X
Xiaoyu Wang 已提交
528
    case QUERY_NODE_PHYSICAL_PLAN_FILL:
5
54liuyao 已提交
529
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL:
X
Xiaoyu Wang 已提交
530
      return makeNode(type, sizeof(SFillPhysiNode));
531
    case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION:
X
Xiaoyu Wang 已提交
532
      return makeNode(type, sizeof(SSessionWinodwPhysiNode));
533
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION:
X
Xiaoyu Wang 已提交
534
      return makeNode(type, sizeof(SStreamSessionWinodwPhysiNode));
535 536 537 538
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION:
      return makeNode(type, sizeof(SStreamSemiSessionWinodwPhysiNode));
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION:
      return makeNode(type, sizeof(SStreamFinalSessionWinodwPhysiNode));
539
    case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE:
X
Xiaoyu Wang 已提交
540
      return makeNode(type, sizeof(SStateWinodwPhysiNode));
541
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE:
5
54liuyao 已提交
542
      return makeNode(type, sizeof(SStreamStateWinodwPhysiNode));
X
Xiaoyu Wang 已提交
543 544 545 546
    case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT:
      return makeNode(type, sizeof(SEventWinodwPhysiNode));
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT:
      return makeNode(type, sizeof(SStreamEventWinodwPhysiNode));
547
    case QUERY_NODE_PHYSICAL_PLAN_PARTITION:
X
Xiaoyu Wang 已提交
548
      return makeNode(type, sizeof(SPartitionPhysiNode));
549 550
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION:
      return makeNode(type, sizeof(SStreamPartitionPhysiNode));
551 552
    case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC:
      return makeNode(type, sizeof(SIndefRowsFuncPhysiNode));
X
Xiaoyu Wang 已提交
553 554
    case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC:
      return makeNode(type, sizeof(SInterpFuncLogicNode));
555
    case QUERY_NODE_PHYSICAL_PLAN_DISPATCH:
X
Xiaoyu Wang 已提交
556
      return makeNode(type, sizeof(SDataDispatcherNode));
557
    case QUERY_NODE_PHYSICAL_PLAN_INSERT:
X
Xiaoyu Wang 已提交
558
      return makeNode(type, sizeof(SDataInserterNode));
559 560
    case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT:
      return makeNode(type, sizeof(SQueryInserterNode));
X
Xiaoyu Wang 已提交
561 562
    case QUERY_NODE_PHYSICAL_PLAN_DELETE:
      return makeNode(type, sizeof(SDataDeleterNode));
X
Xiaoyu Wang 已提交
563
    case QUERY_NODE_PHYSICAL_SUBPLAN:
X
Xiaoyu Wang 已提交
564
      return makeNode(type, sizeof(SSubplan));
X
Xiaoyu Wang 已提交
565
    case QUERY_NODE_PHYSICAL_PLAN:
X
Xiaoyu Wang 已提交
566
      return makeNode(type, sizeof(SQueryPlan));
567 568 569
    default:
      break;
  }
570
  nodesError("nodesMakeNode unknown node = %s", nodesNodeName(type));
X
Xiaoyu Wang 已提交
571
  return NULL;
572 573
}

X
Xiaoyu Wang 已提交
574 575 576 577 578 579 580 581 582 583 584 585
static void destroyVgDataBlockArray(SArray* pArray) {
  size_t size = taosArrayGetSize(pArray);
  for (size_t i = 0; i < size; ++i) {
    SVgDataBlocks* pVg = taosArrayGetP(pArray, i);
    taosMemoryFreeClear(pVg->pData);
    taosMemoryFreeClear(pVg);
  }
  taosArrayDestroy(pArray);
}

static void destroyLogicNode(SLogicNode* pNode) {
  nodesDestroyList(pNode->pTargets);
X
Xiaoyu Wang 已提交
586 587 588 589
  nodesDestroyNode(pNode->pConditions);
  nodesDestroyList(pNode->pChildren);
  nodesDestroyNode(pNode->pLimit);
  nodesDestroyNode(pNode->pSlimit);
X
Xiaoyu Wang 已提交
590 591 592 593 594
}

static void destroyPhysiNode(SPhysiNode* pNode) {
  nodesDestroyList(pNode->pChildren);
  nodesDestroyNode(pNode->pConditions);
595
  nodesDestroyNode((SNode*)pNode->pOutputDataBlockDesc);
596 597
  nodesDestroyNode(pNode->pLimit);
  nodesDestroyNode(pNode->pSlimit);
X
Xiaoyu Wang 已提交
598 599 600 601 602 603
}

static void destroyWinodwPhysiNode(SWinodwPhysiNode* pNode) {
  destroyPhysiNode((SPhysiNode*)pNode);
  nodesDestroyList(pNode->pExprs);
  nodesDestroyList(pNode->pFuncs);
604
  nodesDestroyNode(pNode->pTspk);
5
54liuyao 已提交
605
  nodesDestroyNode(pNode->pTsEnd);
X
Xiaoyu Wang 已提交
606 607
}

608 609 610 611 612 613 614
static void destroyPartitionPhysiNode(SPartitionPhysiNode* pNode) {
  destroyPhysiNode((SPhysiNode*)pNode);
  nodesDestroyList(pNode->pExprs);
  nodesDestroyList(pNode->pPartitionKeys);
  nodesDestroyList(pNode->pTargets);
}

X
Xiaoyu Wang 已提交
615 616 617
static void destroyScanPhysiNode(SScanPhysiNode* pNode) {
  destroyPhysiNode((SPhysiNode*)pNode);
  nodesDestroyList(pNode->pScanCols);
X
Xiaoyu Wang 已提交
618
  nodesDestroyList(pNode->pScanPseudoCols);
X
Xiaoyu Wang 已提交
619 620
}

621
static void destroyDataSinkNode(SDataSinkNode* pNode) { nodesDestroyNode((SNode*)pNode->pInputDataBlockDesc); }
X
Xiaoyu Wang 已提交
622

X
Xiaoyu Wang 已提交
623 624
static void destroyExprNode(SExprNode* pExpr) { taosArrayDestroy(pExpr->pAssociation); }

625
static void destroyTableCfg(STableCfg* pCfg) {
626 627 628
  if (NULL == pCfg) {
    return;
  }
629 630 631 632 633
  taosArrayDestroy(pCfg->pFuncs);
  taosMemoryFree(pCfg->pComment);
  taosMemoryFree(pCfg->pSchemas);
  taosMemoryFree(pCfg->pTags);
  taosMemoryFree(pCfg);
D
dapan1121 已提交
634 635
}

636 637
static void destroySmaIndex(void* pIndex) { taosMemoryFree(((STableIndexInfo*)pIndex)->expr); }

638
void nodesDestroyNode(SNode* pNode) {
X
Xiaoyu Wang 已提交
639 640 641 642 643
  if (NULL == pNode) {
    return;
  }

  switch (nodeType(pNode)) {
X
Xiaoyu Wang 已提交
644
    case QUERY_NODE_COLUMN:
X
Xiaoyu Wang 已提交
645
      destroyExprNode((SExprNode*)pNode);
X
Xiaoyu Wang 已提交
646
      break;
D
dapan1121 已提交
647
    case QUERY_NODE_VALUE: {
X
Xiaoyu Wang 已提交
648
      SValueNode* pValue = (SValueNode*)pNode;
X
Xiaoyu Wang 已提交
649
      destroyExprNode((SExprNode*)pNode);
wafwerar's avatar
wafwerar 已提交
650
      taosMemoryFreeClear(pValue->literal);
D
dapan1121 已提交
651
      if (IS_VAR_DATA_TYPE(pValue->node.resType.type)) {
wafwerar's avatar
wafwerar 已提交
652
        taosMemoryFreeClear(pValue->datum.p);
D
dapan1121 已提交
653
      }
X
Xiaoyu Wang 已提交
654 655 656 657
      break;
    }
    case QUERY_NODE_OPERATOR: {
      SOperatorNode* pOp = (SOperatorNode*)pNode;
X
Xiaoyu Wang 已提交
658
      destroyExprNode((SExprNode*)pNode);
X
Xiaoyu Wang 已提交
659 660
      nodesDestroyNode(pOp->pLeft);
      nodesDestroyNode(pOp->pRight);
D
dapan1121 已提交
661 662 663
      break;
    }
    case QUERY_NODE_LOGIC_CONDITION:
X
Xiaoyu Wang 已提交
664
      destroyExprNode((SExprNode*)pNode);
X
Xiaoyu Wang 已提交
665
      nodesDestroyList(((SLogicConditionNode*)pNode)->pParameterList);
D
dapan1121 已提交
666 667
      break;
    case QUERY_NODE_FUNCTION:
X
Xiaoyu Wang 已提交
668
      destroyExprNode((SExprNode*)pNode);
X
Xiaoyu Wang 已提交
669
      nodesDestroyList(((SFunctionNode*)pNode)->pParameterList);
X
Xiaoyu Wang 已提交
670 671
      break;
    case QUERY_NODE_REAL_TABLE: {
X
Xiaoyu Wang 已提交
672
      SRealTableNode* pReal = (SRealTableNode*)pNode;
wafwerar's avatar
wafwerar 已提交
673 674
      taosMemoryFreeClear(pReal->pMeta);
      taosMemoryFreeClear(pReal->pVgroupList);
675
      taosArrayDestroyEx(pReal->pSmaIndexes, destroySmaIndex);
X
Xiaoyu Wang 已提交
676 677 678
      break;
    }
    case QUERY_NODE_TEMP_TABLE:
X
Xiaoyu Wang 已提交
679
      nodesDestroyNode(((STempTableNode*)pNode)->pSubquery);
D
dapan1121 已提交
680
      break;
X
Xiaoyu Wang 已提交
681 682 683 684 685
    case QUERY_NODE_JOIN_TABLE: {
      SJoinTableNode* pJoin = (SJoinTableNode*)pNode;
      nodesDestroyNode(pJoin->pLeft);
      nodesDestroyNode(pJoin->pRight);
      nodesDestroyNode(pJoin->pOnCond);
D
dapan1121 已提交
686
      break;
X
Xiaoyu Wang 已提交
687
    }
D
dapan1121 已提交
688
    case QUERY_NODE_GROUPING_SET:
X
Xiaoyu Wang 已提交
689 690 691 692 693
      nodesDestroyList(((SGroupingSetNode*)pNode)->pParameterList);
      break;
    case QUERY_NODE_ORDER_BY_EXPR:
      nodesDestroyNode(((SOrderByExprNode*)pNode)->pExpr);
      break;
X
Xiaoyu Wang 已提交
694
    case QUERY_NODE_LIMIT:  // no pointer field
D
dapan1121 已提交
695
      break;
696 697 698 699
    case QUERY_NODE_STATE_WINDOW: {
      SStateWindowNode* pState = (SStateWindowNode*)pNode;
      nodesDestroyNode(pState->pCol);
      nodesDestroyNode(pState->pExpr);
X
Xiaoyu Wang 已提交
700
      break;
701
    }
X
Xiaoyu Wang 已提交
702 703
    case QUERY_NODE_SESSION_WINDOW: {
      SSessionWindowNode* pSession = (SSessionWindowNode*)pNode;
704 705
      nodesDestroyNode((SNode*)pSession->pCol);
      nodesDestroyNode((SNode*)pSession->pGap);
D
dapan1121 已提交
706
      break;
X
Xiaoyu Wang 已提交
707 708 709 710 711 712 713 714 715 716
    }
    case QUERY_NODE_INTERVAL_WINDOW: {
      SIntervalWindowNode* pJoin = (SIntervalWindowNode*)pNode;
      nodesDestroyNode(pJoin->pCol);
      nodesDestroyNode(pJoin->pInterval);
      nodesDestroyNode(pJoin->pOffset);
      nodesDestroyNode(pJoin->pSliding);
      nodesDestroyNode(pJoin->pFill);
      break;
    }
D
dapan1121 已提交
717
    case QUERY_NODE_NODE_LIST:
X
Xiaoyu Wang 已提交
718 719
      nodesDestroyList(((SNodeListNode*)pNode)->pNodeList);
      break;
X
Xiaoyu Wang 已提交
720 721 722 723
    case QUERY_NODE_FILL: {
      SFillNode* pFill = (SFillNode*)pNode;
      nodesDestroyNode(pFill->pValues);
      nodesDestroyNode(pFill->pWStartTs);
X
Xiaoyu Wang 已提交
724
      break;
X
Xiaoyu Wang 已提交
725
    }
X
Xiaoyu Wang 已提交
726 727
    case QUERY_NODE_RAW_EXPR:
      nodesDestroyNode(((SRawExprNode*)pNode)->pNode);
X
Xiaoyu Wang 已提交
728
      break;
X
Xiaoyu Wang 已提交
729 730 731 732 733 734
    case QUERY_NODE_TARGET:
      nodesDestroyNode(((STargetNode*)pNode)->pExpr);
      break;
    case QUERY_NODE_DATABLOCK_DESC:
      nodesDestroyList(((SDataBlockDescNode*)pNode)->pSlots);
      break;
X
Xiaoyu Wang 已提交
735 736 737
    case QUERY_NODE_SLOT_DESC:          // no pointer field
    case QUERY_NODE_COLUMN_DEF:         // no pointer field
    case QUERY_NODE_DOWNSTREAM_SOURCE:  // no pointer field
X
Xiaoyu Wang 已提交
738
      break;
X
Xiaoyu Wang 已提交
739 740
    case QUERY_NODE_DATABASE_OPTIONS: {
      SDatabaseOptions* pOptions = (SDatabaseOptions*)pNode;
741
      nodesDestroyNode((SNode*)pOptions->pDaysPerFile);
X
Xiaoyu Wang 已提交
742 743
      nodesDestroyList(pOptions->pKeep);
      nodesDestroyList(pOptions->pRetentions);
X
Xiaoyu Wang 已提交
744
      break;
X
Xiaoyu Wang 已提交
745
    }
X
Xiaoyu Wang 已提交
746
    case QUERY_NODE_TABLE_OPTIONS: {
X
Xiaoyu Wang 已提交
747
      STableOptions* pOptions = (STableOptions*)pNode;
748 749
      nodesDestroyList(pOptions->pMaxDelay);
      nodesDestroyList(pOptions->pWatermark);
X
Xiaoyu Wang 已提交
750
      nodesDestroyList(pOptions->pRollupFuncs);
751
      nodesDestroyList(pOptions->pSma);
752
      nodesDestroyList(pOptions->pDeleteMark);
X
Xiaoyu Wang 已提交
753
      break;
X
Xiaoyu Wang 已提交
754
    }
755
    case QUERY_NODE_INDEX_OPTIONS: {
X
Xiaoyu Wang 已提交
756 757 758 759 760
      SIndexOptions* pOptions = (SIndexOptions*)pNode;
      nodesDestroyList(pOptions->pFuncs);
      nodesDestroyNode(pOptions->pInterval);
      nodesDestroyNode(pOptions->pOffset);
      nodesDestroyNode(pOptions->pSliding);
761
      nodesDestroyNode(pOptions->pStreamOptions);
762 763
      break;
    }
764 765
    case QUERY_NODE_EXPLAIN_OPTIONS:  // no pointer field
      break;
766 767 768 769
    case QUERY_NODE_STREAM_OPTIONS: {
      SStreamOptions* pOptions = (SStreamOptions*)pNode;
      nodesDestroyNode(pOptions->pDelay);
      nodesDestroyNode(pOptions->pWatermark);
770
      nodesDestroyNode(pOptions->pDeleteMark);
771
      break;
772
    }
773
    case QUERY_NODE_LEFT_VALUE:  // no pointer field
X
Xiaoyu Wang 已提交
774
    case QUERY_NODE_COLUMN_REF:  // no pointer field
775
      break;
X
Xiaoyu Wang 已提交
776
    case QUERY_NODE_WHEN_THEN: {
X
Xiaoyu Wang 已提交
777 778 779
      SWhenThenNode* pWhenThen = (SWhenThenNode*)pNode;
      nodesDestroyNode(pWhenThen->pWhen);
      nodesDestroyNode(pWhenThen->pThen);
X
Xiaoyu Wang 已提交
780 781 782
      break;
    }
    case QUERY_NODE_CASE_WHEN: {
X
Xiaoyu Wang 已提交
783 784 785 786 787 788 789 790 791 792 793
      SCaseWhenNode* pCaseWhen = (SCaseWhenNode*)pNode;
      nodesDestroyNode(pCaseWhen->pCase);
      nodesDestroyNode(pCaseWhen->pElse);
      nodesDestroyList(pCaseWhen->pWhenThenList);
      break;
    }
    case QUERY_NODE_EVENT_WINDOW: {
      SEventWindowNode* pEvent = (SEventWindowNode*)pNode;
      nodesDestroyNode(pEvent->pCol);
      nodesDestroyNode(pEvent->pStartCond);
      nodesDestroyNode(pEvent->pEndCond);
X
Xiaoyu Wang 已提交
794 795
      break;
    }
X
Xiaoyu Wang 已提交
796 797
    case QUERY_NODE_SET_OPERATOR: {
      SSetOperator* pStmt = (SSetOperator*)pNode;
798
      nodesDestroyList(pStmt->pProjectionList);
X
Xiaoyu Wang 已提交
799 800 801 802 803 804
      nodesDestroyNode(pStmt->pLeft);
      nodesDestroyNode(pStmt->pRight);
      nodesDestroyList(pStmt->pOrderByList);
      nodesDestroyNode(pStmt->pLimit);
      break;
    }
X
Xiaoyu Wang 已提交
805
    case QUERY_NODE_SELECT_STMT: {
X
Xiaoyu Wang 已提交
806
      SSelectStmt* pStmt = (SSelectStmt*)pNode;
X
Xiaoyu Wang 已提交
807 808 809 810
      nodesDestroyList(pStmt->pProjectionList);
      nodesDestroyNode(pStmt->pFromTable);
      nodesDestroyNode(pStmt->pWhere);
      nodesDestroyList(pStmt->pPartitionByList);
811 812
      nodesDestroyList(pStmt->pTags);
      nodesDestroyNode(pStmt->pSubtable);
X
Xiaoyu Wang 已提交
813 814 815
      nodesDestroyNode(pStmt->pWindow);
      nodesDestroyList(pStmt->pGroupByList);
      nodesDestroyNode(pStmt->pHaving);
X
Xiaoyu Wang 已提交
816 817 818
      nodesDestroyNode(pStmt->pRange);
      nodesDestroyNode(pStmt->pEvery);
      nodesDestroyNode(pStmt->pFill);
X
Xiaoyu Wang 已提交
819
      nodesDestroyList(pStmt->pOrderByList);
820 821
      nodesDestroyNode((SNode*)pStmt->pLimit);
      nodesDestroyNode((SNode*)pStmt->pSlimit);
X
Xiaoyu Wang 已提交
822 823
      break;
    }
X
Xiaoyu Wang 已提交
824 825
    case QUERY_NODE_VNODE_MODIFY_STMT: {
      SVnodeModifyOpStmt* pStmt = (SVnodeModifyOpStmt*)pNode;
X
Xiaoyu Wang 已提交
826 827 828 829 830 831 832 833 834 835 836 837
      destroyVgDataBlockArray(pStmt->pDataBlocks);
      taosMemoryFreeClear(pStmt->pTableMeta);
      taosHashCleanup(pStmt->pVgroupsHashObj);
      taosHashCleanup(pStmt->pSubTableHashObj);
      taosHashCleanup(pStmt->pTableNameHashObj);
      taosHashCleanup(pStmt->pDbFNameHashObj);
      if (pStmt->freeHashFunc) {
        pStmt->freeHashFunc(pStmt->pTableBlockHashObj);
      }
      if (pStmt->freeArrayFunc) {
        pStmt->freeArrayFunc(pStmt->pVgDataBlocks);
      }
X
Xiaoyu Wang 已提交
838 839
      tdDestroySVCreateTbReq(pStmt->pCreateTblReq);
      taosMemoryFreeClear(pStmt->pCreateTblReq);
X
Xiaoyu Wang 已提交
840
      taosCloseFile(&pStmt->fp);
X
Xiaoyu Wang 已提交
841
      break;
X
Xiaoyu Wang 已提交
842
    }
X
Xiaoyu Wang 已提交
843
    case QUERY_NODE_CREATE_DATABASE_STMT:
844
      nodesDestroyNode((SNode*)((SCreateDatabaseStmt*)pNode)->pOptions);
X
Xiaoyu Wang 已提交
845
      break;
X
Xiaoyu Wang 已提交
846
    case QUERY_NODE_DROP_DATABASE_STMT:  // no pointer field
X
Xiaoyu Wang 已提交
847 848
      break;
    case QUERY_NODE_ALTER_DATABASE_STMT:
849
      nodesDestroyNode((SNode*)((SAlterDatabaseStmt*)pNode)->pOptions);
X
Xiaoyu Wang 已提交
850
      break;
X
Xiaoyu Wang 已提交
851
    case QUERY_NODE_FLUSH_DATABASE_STMT:  // no pointer field
X
Xiaoyu Wang 已提交
852
    case QUERY_NODE_TRIM_DATABASE_STMT:   // no pointer field
X
Xiaoyu Wang 已提交
853
      break;
X
Xiaoyu Wang 已提交
854
    case QUERY_NODE_CREATE_TABLE_STMT: {
X
Xiaoyu Wang 已提交
855
      SCreateTableStmt* pStmt = (SCreateTableStmt*)pNode;
X
Xiaoyu Wang 已提交
856 857
      nodesDestroyList(pStmt->pCols);
      nodesDestroyList(pStmt->pTags);
858
      nodesDestroyNode((SNode*)pStmt->pOptions);
X
Xiaoyu Wang 已提交
859 860 861
      break;
    }
    case QUERY_NODE_CREATE_SUBTABLE_CLAUSE: {
X
Xiaoyu Wang 已提交
862
      SCreateSubTableClause* pStmt = (SCreateSubTableClause*)pNode;
X
Xiaoyu Wang 已提交
863 864
      nodesDestroyList(pStmt->pSpecificTags);
      nodesDestroyList(pStmt->pValsOfTags);
wmmhello's avatar
wmmhello 已提交
865
      nodesDestroyNode((SNode*)pStmt->pOptions);
X
Xiaoyu Wang 已提交
866 867
      break;
    }
X
Xiaoyu Wang 已提交
868 869
    case QUERY_NODE_CREATE_MULTI_TABLES_STMT:
      nodesDestroyList(((SCreateMultiTablesStmt*)pNode)->pSubTables);
X
Xiaoyu Wang 已提交
870
      break;
X
Xiaoyu Wang 已提交
871
    case QUERY_NODE_DROP_TABLE_CLAUSE:  // no pointer field
X
Xiaoyu Wang 已提交
872 873
      break;
    case QUERY_NODE_DROP_TABLE_STMT:
874
      nodesDestroyList(((SDropTableStmt*)pNode)->pTables);
X
Xiaoyu Wang 已提交
875
      break;
X
Xiaoyu Wang 已提交
876
    case QUERY_NODE_DROP_SUPER_TABLE_STMT:  // no pointer field
X
Xiaoyu Wang 已提交
877
      break;
878 879
    case QUERY_NODE_ALTER_TABLE_STMT:
    case QUERY_NODE_ALTER_SUPER_TABLE_STMT: {
X
Xiaoyu Wang 已提交
880
      SAlterTableStmt* pStmt = (SAlterTableStmt*)pNode;
881 882
      nodesDestroyNode((SNode*)pStmt->pOptions);
      nodesDestroyNode((SNode*)pStmt->pVal);
X
Xiaoyu Wang 已提交
883 884
      break;
    }
X
Xiaoyu Wang 已提交
885 886 887 888 889 890 891
    case QUERY_NODE_CREATE_USER_STMT:   // no pointer field
    case QUERY_NODE_ALTER_USER_STMT:    // no pointer field
    case QUERY_NODE_DROP_USER_STMT:     // no pointer field
    case QUERY_NODE_USE_DATABASE_STMT:  // no pointer field
    case QUERY_NODE_CREATE_DNODE_STMT:  // no pointer field
    case QUERY_NODE_DROP_DNODE_STMT:    // no pointer field
    case QUERY_NODE_ALTER_DNODE_STMT:   // no pointer field
892
      break;
893
    case QUERY_NODE_CREATE_INDEX_STMT: {
X
Xiaoyu Wang 已提交
894
      SCreateIndexStmt* pStmt = (SCreateIndexStmt*)pNode;
895
      nodesDestroyNode((SNode*)pStmt->pOptions);
896 897 898
      nodesDestroyList(pStmt->pCols);
      break;
    }
X
Xiaoyu Wang 已提交
899 900 901
    case QUERY_NODE_DROP_INDEX_STMT:    // no pointer field
    case QUERY_NODE_CREATE_QNODE_STMT:  // no pointer field
    case QUERY_NODE_DROP_QNODE_STMT:    // no pointer field
902 903 904 905 906 907
    case QUERY_NODE_CREATE_BNODE_STMT:  // no pointer field
    case QUERY_NODE_DROP_BNODE_STMT:    // no pointer field
    case QUERY_NODE_CREATE_SNODE_STMT:  // no pointer field
    case QUERY_NODE_DROP_SNODE_STMT:    // no pointer field
    case QUERY_NODE_CREATE_MNODE_STMT:  // no pointer field
    case QUERY_NODE_DROP_MNODE_STMT:    // no pointer field
X
Xiaoyu Wang 已提交
908 909 910 911
      break;
    case QUERY_NODE_CREATE_TOPIC_STMT:
      nodesDestroyNode(((SCreateTopicStmt*)pNode)->pQuery);
      break;
X
Xiaoyu Wang 已提交
912
    case QUERY_NODE_DROP_TOPIC_STMT:   // no pointer field
913
    case QUERY_NODE_DROP_CGROUP_STMT:  // no pointer field
X
Xiaoyu Wang 已提交
914
    case QUERY_NODE_ALTER_LOCAL_STMT:  // no pointer field
X
Xiaoyu Wang 已提交
915
      break;
916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933
    case QUERY_NODE_EXPLAIN_STMT: {
      SExplainStmt* pStmt = (SExplainStmt*)pNode;
      nodesDestroyNode((SNode*)pStmt->pOptions);
      nodesDestroyNode(pStmt->pQuery);
      break;
    }
    case QUERY_NODE_DESCRIBE_STMT:
      taosMemoryFree(((SDescribeStmt*)pNode)->pMeta);
      break;
    case QUERY_NODE_RESET_QUERY_CACHE_STMT:  // no pointer field
    case QUERY_NODE_COMPACT_STMT:            // no pointer field
    case QUERY_NODE_CREATE_FUNCTION_STMT:    // no pointer field
    case QUERY_NODE_DROP_FUNCTION_STMT:      // no pointer field
      break;
    case QUERY_NODE_CREATE_STREAM_STMT: {
      SCreateStreamStmt* pStmt = (SCreateStreamStmt*)pNode;
      nodesDestroyNode((SNode*)pStmt->pOptions);
      nodesDestroyNode(pStmt->pQuery);
934 935
      nodesDestroyList(pStmt->pTags);
      nodesDestroyNode(pStmt->pSubtable);
936 937 938 939 940 941 942 943 944 945 946 947 948 949
      break;
    }
    case QUERY_NODE_DROP_STREAM_STMT:     // no pointer field
    case QUERY_NODE_BALANCE_VGROUP_STMT:  // no pointer field
    case QUERY_NODE_MERGE_VGROUP_STMT:    // no pointer field
      break;
    case QUERY_NODE_REDISTRIBUTE_VGROUP_STMT:
      nodesDestroyList(((SRedistributeVgroupStmt*)pNode)->pDnodes);
      break;
    case QUERY_NODE_SPLIT_VGROUP_STMT:  // no pointer field
    case QUERY_NODE_SYNCDB_STMT:        // no pointer field
    case QUERY_NODE_GRANT_STMT:         // no pointer field
    case QUERY_NODE_REVOKE_STMT:        // no pointer field
      break;
X
Xiaoyu Wang 已提交
950 951 952 953
    case QUERY_NODE_SHOW_DNODES_STMT:
    case QUERY_NODE_SHOW_MNODES_STMT:
    case QUERY_NODE_SHOW_MODULES_STMT:
    case QUERY_NODE_SHOW_QNODES_STMT:
954 955 956 957
    case QUERY_NODE_SHOW_SNODES_STMT:
    case QUERY_NODE_SHOW_BNODES_STMT:
    case QUERY_NODE_SHOW_CLUSTER_STMT:
    case QUERY_NODE_SHOW_DATABASES_STMT:
X
Xiaoyu Wang 已提交
958 959
    case QUERY_NODE_SHOW_FUNCTIONS_STMT:
    case QUERY_NODE_SHOW_INDEXES_STMT:
960 961 962 963
    case QUERY_NODE_SHOW_STABLES_STMT:
    case QUERY_NODE_SHOW_STREAMS_STMT:
    case QUERY_NODE_SHOW_TABLES_STMT:
    case QUERY_NODE_SHOW_USERS_STMT:
X
Xiaoyu Wang 已提交
964
    case QUERY_NODE_SHOW_LICENCES_STMT:
965
    case QUERY_NODE_SHOW_VGROUPS_STMT:
966 967
    case QUERY_NODE_SHOW_DB_ALIVE_STMT:
    case QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT:    
968 969 970 971 972 973 974
    case QUERY_NODE_SHOW_TOPICS_STMT:
    case QUERY_NODE_SHOW_CONSUMERS_STMT:
    case QUERY_NODE_SHOW_CONNECTIONS_STMT:
    case QUERY_NODE_SHOW_QUERIES_STMT:
    case QUERY_NODE_SHOW_VNODES_STMT:
    case QUERY_NODE_SHOW_APPS_STMT:
    case QUERY_NODE_SHOW_SCORES_STMT:
975 976
    case QUERY_NODE_SHOW_VARIABLES_STMT:
    case QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT:
977
    case QUERY_NODE_SHOW_TRANSACTIONS_STMT:
978
    case QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT:
979 980
    case QUERY_NODE_SHOW_TAGS_STMT:
    case QUERY_NODE_SHOW_USER_PRIVILEGES_STMT: {
X
Xiaoyu Wang 已提交
981 982
      SShowStmt* pStmt = (SShowStmt*)pNode;
      nodesDestroyNode(pStmt->pDbName);
983
      nodesDestroyNode(pStmt->pTbName);
X
Xiaoyu Wang 已提交
984 985
      break;
    }
986 987 988 989 990 991 992
    case QUERY_NODE_SHOW_TABLE_TAGS_STMT: {
      SShowTableTagsStmt* pStmt = (SShowTableTagsStmt*)pNode;
      nodesDestroyNode(pStmt->pDbName);
      nodesDestroyNode(pStmt->pTbName);
      nodesDestroyList(pStmt->pTags);
      break;
    }
993 994
    case QUERY_NODE_SHOW_DNODE_VARIABLES_STMT:
      nodesDestroyNode(((SShowDnodeVariablesStmt*)pNode)->pDnodeId);
995
      nodesDestroyNode(((SShowDnodeVariablesStmt*)pNode)->pLikePattern);
996
      break;
997 998 999 1000 1001
    case QUERY_NODE_SHOW_CREATE_DATABASE_STMT:
      taosMemoryFreeClear(((SShowCreateDatabaseStmt*)pNode)->pCfg);
      break;
    case QUERY_NODE_SHOW_CREATE_TABLE_STMT:
    case QUERY_NODE_SHOW_CREATE_STABLE_STMT:
X
Xiaoyu Wang 已提交
1002 1003
      taosMemoryFreeClear(((SShowCreateTableStmt*)pNode)->pDbCfg);
      destroyTableCfg((STableCfg*)(((SShowCreateTableStmt*)pNode)->pTableCfg));
1004 1005 1006 1007 1008
      break;
    case QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT:  // no pointer field
    case QUERY_NODE_KILL_CONNECTION_STMT:         // no pointer field
    case QUERY_NODE_KILL_QUERY_STMT:              // no pointer field
    case QUERY_NODE_KILL_TRANSACTION_STMT:        // no pointer field
1009 1010 1011 1012 1013 1014
      break;
    case QUERY_NODE_DELETE_STMT: {
      SDeleteStmt* pStmt = (SDeleteStmt*)pNode;
      nodesDestroyNode(pStmt->pFromTable);
      nodesDestroyNode(pStmt->pWhere);
      nodesDestroyNode(pStmt->pCountFunc);
1015 1016
      nodesDestroyNode(pStmt->pFirstFunc);
      nodesDestroyNode(pStmt->pLastFunc);
X
Xiaoyu Wang 已提交
1017
      nodesDestroyNode(pStmt->pTagCond);
1018 1019
      break;
    }
1020 1021 1022 1023 1024 1025 1026
    case QUERY_NODE_INSERT_STMT: {
      SInsertStmt* pStmt = (SInsertStmt*)pNode;
      nodesDestroyNode(pStmt->pTable);
      nodesDestroyList(pStmt->pCols);
      nodesDestroyNode(pStmt->pQuery);
      break;
    }
1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
    case QUERY_NODE_QUERY: {
      SQuery* pQuery = (SQuery*)pNode;
      nodesDestroyNode(pQuery->pRoot);
      taosMemoryFreeClear(pQuery->pResSchema);
      if (NULL != pQuery->pCmdMsg) {
        taosMemoryFreeClear(pQuery->pCmdMsg->pMsg);
        taosMemoryFreeClear(pQuery->pCmdMsg);
      }
      taosArrayDestroy(pQuery->pDbList);
      taosArrayDestroy(pQuery->pTableList);
D
dapan1121 已提交
1037
      taosArrayDestroy(pQuery->pTargetTableList);
1038 1039
      taosArrayDestroy(pQuery->pPlaceholderValues);
      nodesDestroyNode(pQuery->pPrepareRoot);
1040 1041
      break;
    }
X
Xiaoyu Wang 已提交
1042 1043 1044 1045
    case QUERY_NODE_LOGIC_PLAN_SCAN: {
      SScanLogicNode* pLogicNode = (SScanLogicNode*)pNode;
      destroyLogicNode((SLogicNode*)pLogicNode);
      nodesDestroyList(pLogicNode->pScanCols);
X
Xiaoyu Wang 已提交
1046
      nodesDestroyList(pLogicNode->pScanPseudoCols);
X
Xiaoyu Wang 已提交
1047
      taosMemoryFreeClear(pLogicNode->pVgroupList);
X
Xiaoyu Wang 已提交
1048 1049 1050
      nodesDestroyList(pLogicNode->pDynamicScanFuncs);
      nodesDestroyNode(pLogicNode->pTagCond);
      nodesDestroyNode(pLogicNode->pTagIndexCond);
1051
      taosArrayDestroyEx(pLogicNode->pSmaIndexes, destroySmaIndex);
1052
      nodesDestroyList(pLogicNode->pGroupTags);
1053 1054
      nodesDestroyList(pLogicNode->pTags);
      nodesDestroyNode(pLogicNode->pSubtable);
X
Xiaoyu Wang 已提交
1055 1056 1057 1058 1059
      break;
    }
    case QUERY_NODE_LOGIC_PLAN_JOIN: {
      SJoinLogicNode* pLogicNode = (SJoinLogicNode*)pNode;
      destroyLogicNode((SLogicNode*)pLogicNode);
1060
      nodesDestroyNode(pLogicNode->pMergeCondition);
X
Xiaoyu Wang 已提交
1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076
      nodesDestroyNode(pLogicNode->pOnConditions);
      break;
    }
    case QUERY_NODE_LOGIC_PLAN_AGG: {
      SAggLogicNode* pLogicNode = (SAggLogicNode*)pNode;
      destroyLogicNode((SLogicNode*)pLogicNode);
      nodesDestroyList(pLogicNode->pAggFuncs);
      nodesDestroyList(pLogicNode->pGroupKeys);
      break;
    }
    case QUERY_NODE_LOGIC_PLAN_PROJECT: {
      SProjectLogicNode* pLogicNode = (SProjectLogicNode*)pNode;
      destroyLogicNode((SLogicNode*)pLogicNode);
      nodesDestroyList(pLogicNode->pProjections);
      break;
    }
X
Xiaoyu Wang 已提交
1077 1078
    case QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY: {
      SVnodeModifyLogicNode* pLogicNode = (SVnodeModifyLogicNode*)pNode;
X
Xiaoyu Wang 已提交
1079 1080
      destroyLogicNode((SLogicNode*)pLogicNode);
      destroyVgDataBlockArray(pLogicNode->pDataBlocks);
X
bugfix  
Xiaoyu Wang 已提交
1081
      // pVgDataBlocks is weak reference
1082
      nodesDestroyNode(pLogicNode->pAffectedRows);
1083 1084
      nodesDestroyNode(pLogicNode->pStartTs);
      nodesDestroyNode(pLogicNode->pEndTs);
1085 1086
      taosMemoryFreeClear(pLogicNode->pVgroupList);
      nodesDestroyList(pLogicNode->pInsertCols);
X
Xiaoyu Wang 已提交
1087 1088 1089 1090 1091
      break;
    }
    case QUERY_NODE_LOGIC_PLAN_EXCHANGE:
      destroyLogicNode((SLogicNode*)pNode);
      break;
1092 1093 1094 1095 1096 1097 1098
    case QUERY_NODE_LOGIC_PLAN_MERGE: {
      SMergeLogicNode* pLogicNode = (SMergeLogicNode*)pNode;
      destroyLogicNode((SLogicNode*)pLogicNode);
      nodesDestroyList(pLogicNode->pMergeKeys);
      nodesDestroyList(pLogicNode->pInputs);
      break;
    }
X
Xiaoyu Wang 已提交
1099 1100 1101 1102 1103
    case QUERY_NODE_LOGIC_PLAN_WINDOW: {
      SWindowLogicNode* pLogicNode = (SWindowLogicNode*)pNode;
      destroyLogicNode((SLogicNode*)pLogicNode);
      nodesDestroyList(pLogicNode->pFuncs);
      nodesDestroyNode(pLogicNode->pTspk);
5
54liuyao 已提交
1104
      nodesDestroyNode(pLogicNode->pTsEnd);
1105
      nodesDestroyNode(pLogicNode->pStateExpr);
X
Xiaoyu Wang 已提交
1106 1107
      break;
    }
1108 1109 1110 1111 1112
    case QUERY_NODE_LOGIC_PLAN_FILL: {
      SFillLogicNode* pLogicNode = (SFillLogicNode*)pNode;
      destroyLogicNode((SLogicNode*)pLogicNode);
      nodesDestroyNode(pLogicNode->pWStartTs);
      nodesDestroyNode(pLogicNode->pValues);
F
freemine 已提交
1113
      nodesDestroyList(pLogicNode->pFillExprs);
1114
      nodesDestroyList(pLogicNode->pNotFillExprs);
1115 1116
      break;
    }
X
Xiaoyu Wang 已提交
1117 1118 1119 1120 1121 1122 1123 1124 1125 1126
    case QUERY_NODE_LOGIC_PLAN_SORT: {
      SSortLogicNode* pLogicNode = (SSortLogicNode*)pNode;
      destroyLogicNode((SLogicNode*)pLogicNode);
      nodesDestroyList(pLogicNode->pSortKeys);
      break;
    }
    case QUERY_NODE_LOGIC_PLAN_PARTITION: {
      SPartitionLogicNode* pLogicNode = (SPartitionLogicNode*)pNode;
      destroyLogicNode((SLogicNode*)pLogicNode);
      nodesDestroyList(pLogicNode->pPartitionKeys);
1127 1128
      nodesDestroyList(pLogicNode->pTags);
      nodesDestroyNode(pLogicNode->pSubtable);
X
Xiaoyu Wang 已提交
1129 1130
      break;
    }
1131 1132 1133
    case QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC: {
      SIndefRowsFuncLogicNode* pLogicNode = (SIndefRowsFuncLogicNode*)pNode;
      destroyLogicNode((SLogicNode*)pLogicNode);
X
Xiaoyu Wang 已提交
1134 1135 1136 1137 1138 1139 1140
      nodesDestroyList(pLogicNode->pFuncs);
      break;
    }
    case QUERY_NODE_LOGIC_PLAN_INTERP_FUNC: {
      SInterpFuncLogicNode* pLogicNode = (SInterpFuncLogicNode*)pNode;
      destroyLogicNode((SLogicNode*)pLogicNode);
      nodesDestroyList(pLogicNode->pFuncs);
X
Xiaoyu Wang 已提交
1141 1142
      nodesDestroyNode(pLogicNode->pFillValues);
      nodesDestroyNode(pLogicNode->pTimeSeries);
1143 1144
      break;
    }
X
Xiaoyu Wang 已提交
1145 1146 1147
    case QUERY_NODE_LOGIC_SUBPLAN: {
      SLogicSubplan* pSubplan = (SLogicSubplan*)pNode;
      nodesDestroyList(pSubplan->pChildren);
1148
      nodesDestroyNode((SNode*)pSubplan->pNode);
X
bugfix  
Xiaoyu Wang 已提交
1149
      nodesClearList(pSubplan->pParents);
X
Xiaoyu Wang 已提交
1150 1151 1152 1153 1154 1155 1156 1157
      taosMemoryFreeClear(pSubplan->pVgroupList);
      break;
    }
    case QUERY_NODE_LOGIC_PLAN:
      nodesDestroyList(((SQueryLogicPlan*)pNode)->pTopSubplans);
      break;
    case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN:
    case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN:
1158
    case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN:
X
Xiaoyu Wang 已提交
1159 1160
      destroyScanPhysiNode((SScanPhysiNode*)pNode);
      break;
1161 1162
    case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN:
    case QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN: {
1163 1164 1165 1166 1167
      SLastRowScanPhysiNode* pPhyNode = (SLastRowScanPhysiNode*)pNode;
      destroyScanPhysiNode((SScanPhysiNode*)pNode);
      nodesDestroyList(pPhyNode->pGroupTags);
      break;
    }
X
Xiaoyu Wang 已提交
1168 1169 1170 1171 1172 1173 1174
    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:
    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN:
    case QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN:
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN: {
      STableScanPhysiNode* pPhyNode = (STableScanPhysiNode*)pNode;
      destroyScanPhysiNode((SScanPhysiNode*)pNode);
      nodesDestroyList(pPhyNode->pDynamicScanFuncs);
1175
      nodesDestroyList(pPhyNode->pGroupTags);
1176 1177
      nodesDestroyList(pPhyNode->pTags);
      nodesDestroyNode(pPhyNode->pSubtable);
X
Xiaoyu Wang 已提交
1178 1179
      break;
    }
X
Xiaoyu Wang 已提交
1180 1181 1182 1183 1184 1185
    case QUERY_NODE_PHYSICAL_PLAN_PROJECT: {
      SProjectPhysiNode* pPhyNode = (SProjectPhysiNode*)pNode;
      destroyPhysiNode((SPhysiNode*)pPhyNode);
      nodesDestroyList(pPhyNode->pProjections);
      break;
    }
1186
    case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN: {
1187
      SSortMergeJoinPhysiNode* pPhyNode = (SSortMergeJoinPhysiNode*)pNode;
X
Xiaoyu Wang 已提交
1188
      destroyPhysiNode((SPhysiNode*)pPhyNode);
1189
      nodesDestroyNode(pPhyNode->pMergeCondition);
X
Xiaoyu Wang 已提交
1190 1191 1192 1193
      nodesDestroyNode(pPhyNode->pOnConditions);
      nodesDestroyList(pPhyNode->pTargets);
      break;
    }
1194
    case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG: {
X
Xiaoyu Wang 已提交
1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207
      SAggPhysiNode* pPhyNode = (SAggPhysiNode*)pNode;
      destroyPhysiNode((SPhysiNode*)pPhyNode);
      nodesDestroyList(pPhyNode->pExprs);
      nodesDestroyList(pPhyNode->pAggFuncs);
      nodesDestroyList(pPhyNode->pGroupKeys);
      break;
    }
    case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE: {
      SExchangePhysiNode* pPhyNode = (SExchangePhysiNode*)pNode;
      destroyPhysiNode((SPhysiNode*)pPhyNode);
      nodesDestroyList(pPhyNode->pSrcEndPoints);
      break;
    }
1208 1209 1210 1211 1212 1213 1214
    case QUERY_NODE_PHYSICAL_PLAN_MERGE: {
      SMergePhysiNode* pPhyNode = (SMergePhysiNode*)pNode;
      destroyPhysiNode((SPhysiNode*)pPhyNode);
      nodesDestroyList(pPhyNode->pMergeKeys);
      nodesDestroyList(pPhyNode->pTargets);
      break;
    }
1215 1216
    case QUERY_NODE_PHYSICAL_PLAN_SORT:
    case QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT: {
X
Xiaoyu Wang 已提交
1217 1218
      SSortPhysiNode* pPhyNode = (SSortPhysiNode*)pNode;
      destroyPhysiNode((SPhysiNode*)pPhyNode);
1219 1220
      nodesDestroyList(pPhyNode->pExprs);
      nodesDestroyList(pPhyNode->pSortKeys);
X
Xiaoyu Wang 已提交
1221
      nodesDestroyList(pPhyNode->pTargets);
X
Xiaoyu Wang 已提交
1222 1223
      break;
    }
X
Xiaoyu Wang 已提交
1224
    case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL:
1225
    case QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL:
X
Xiaoyu Wang 已提交
1226
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL:
1227 1228
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL:
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL:
X
Xiaoyu Wang 已提交
1229
      destroyWinodwPhysiNode((SWinodwPhysiNode*)pNode);
X
Xiaoyu Wang 已提交
1230
      break;
5
54liuyao 已提交
1231 1232
    case QUERY_NODE_PHYSICAL_PLAN_FILL:
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL: {
1233 1234
      SFillPhysiNode* pPhyNode = (SFillPhysiNode*)pNode;
      destroyPhysiNode((SPhysiNode*)pPhyNode);
1235 1236
      nodesDestroyList(pPhyNode->pFillExprs);
      nodesDestroyList(pPhyNode->pNotFillExprs);
1237 1238 1239 1240
      nodesDestroyNode(pPhyNode->pWStartTs);
      nodesDestroyNode(pPhyNode->pValues);
      break;
    }
1241 1242
    case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION:
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION:
1243
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION:
1244
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION:
X
Xiaoyu Wang 已提交
1245 1246
      destroyWinodwPhysiNode((SWinodwPhysiNode*)pNode);
      break;
1247 1248 1249 1250 1251 1252 1253
    case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE:
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE: {
      SStateWinodwPhysiNode* pPhyNode = (SStateWinodwPhysiNode*)pNode;
      destroyWinodwPhysiNode((SWinodwPhysiNode*)pPhyNode);
      nodesDestroyNode(pPhyNode->pStateKey);
      break;
    }
X
Xiaoyu Wang 已提交
1254 1255 1256 1257 1258 1259 1260 1261
    case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT:
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT: {
      SEventWinodwPhysiNode* pPhyNode = (SEventWinodwPhysiNode*)pNode;
      destroyWinodwPhysiNode((SWinodwPhysiNode*)pPhyNode);
      nodesDestroyNode(pPhyNode->pStartCond);
      nodesDestroyNode(pPhyNode->pEndCond);
      break;
    }
1262 1263 1264 1265
    case QUERY_NODE_PHYSICAL_PLAN_PARTITION: {
      destroyPartitionPhysiNode((SPartitionPhysiNode*)pNode);
      break;
    }
1266
    case QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION: {
1267 1268 1269 1270
      SStreamPartitionPhysiNode* pPhyNode = (SStreamPartitionPhysiNode*)pNode;
      destroyPartitionPhysiNode((SPartitionPhysiNode*)pPhyNode);
      nodesDestroyList(pPhyNode->pTags);
      nodesDestroyNode(pPhyNode->pSubtable);
1271 1272 1273 1274 1275 1276
      break;
    }
    case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC: {
      SIndefRowsFuncPhysiNode* pPhyNode = (SIndefRowsFuncPhysiNode*)pNode;
      destroyPhysiNode((SPhysiNode*)pPhyNode);
      nodesDestroyList(pPhyNode->pExprs);
X
Xiaoyu Wang 已提交
1277 1278 1279 1280 1281 1282 1283 1284
      nodesDestroyList(pPhyNode->pFuncs);
      break;
    }
    case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC: {
      SInterpFuncPhysiNode* pPhyNode = (SInterpFuncPhysiNode*)pNode;
      destroyPhysiNode((SPhysiNode*)pPhyNode);
      nodesDestroyList(pPhyNode->pExprs);
      nodesDestroyList(pPhyNode->pFuncs);
X
Xiaoyu Wang 已提交
1285 1286
      nodesDestroyNode(pPhyNode->pFillValues);
      nodesDestroyNode(pPhyNode->pTimeSeries);
1287 1288
      break;
    }
X
Xiaoyu Wang 已提交
1289 1290 1291 1292 1293 1294 1295 1296 1297
    case QUERY_NODE_PHYSICAL_PLAN_DISPATCH:
      destroyDataSinkNode((SDataSinkNode*)pNode);
      break;
    case QUERY_NODE_PHYSICAL_PLAN_INSERT: {
      SDataInserterNode* pSink = (SDataInserterNode*)pNode;
      destroyDataSinkNode((SDataSinkNode*)pSink);
      taosMemoryFreeClear(pSink->pData);
      break;
    }
1298 1299 1300
    case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT: {
      SQueryInserterNode* pSink = (SQueryInserterNode*)pNode;
      destroyDataSinkNode((SDataSinkNode*)pSink);
D
dapan1121 已提交
1301
      nodesDestroyList(pSink->pCols);
1302 1303
      break;
    }
1304 1305 1306 1307
    case QUERY_NODE_PHYSICAL_PLAN_DELETE: {
      SDataDeleterNode* pSink = (SDataDeleterNode*)pNode;
      destroyDataSinkNode((SDataSinkNode*)pSink);
      nodesDestroyNode(pSink->pAffectedRows);
1308 1309
      nodesDestroyNode(pSink->pStartTs);
      nodesDestroyNode(pSink->pEndTs);
1310 1311
      break;
    }
X
Xiaoyu Wang 已提交
1312 1313
    case QUERY_NODE_PHYSICAL_SUBPLAN: {
      SSubplan* pSubplan = (SSubplan*)pNode;
X
Xiaoyu Wang 已提交
1314
      nodesClearList(pSubplan->pChildren);
1315 1316
      nodesDestroyNode((SNode*)pSubplan->pNode);
      nodesDestroyNode((SNode*)pSubplan->pDataSink);
X
Xiaoyu Wang 已提交
1317 1318
      nodesDestroyNode((SNode*)pSubplan->pTagCond);
      nodesDestroyNode((SNode*)pSubplan->pTagIndexCond);
X
bugfix  
Xiaoyu Wang 已提交
1319 1320 1321
      nodesClearList(pSubplan->pParents);
      break;
    }
1322 1323
    case QUERY_NODE_PHYSICAL_PLAN:
      nodesDestroyList(((SQueryPlan*)pNode)->pSubplans);
X
Xiaoyu Wang 已提交
1324
      break;
1325 1326 1327
    default:
      break;
  }
1328
  nodesFree(pNode);
X
Xiaoyu Wang 已提交
1329
  return;
1330 1331
}

1332
SNodeList* nodesMakeList() {
1333
  SNodeList* p = nodesCalloc(1, sizeof(SNodeList));
1334 1335 1336 1337 1338 1339
  if (NULL == p) {
    return NULL;
  }
  return p;
}

1340
int32_t nodesListAppend(SNodeList* pList, SNode* pNode) {
1341
  if (NULL == pList || NULL == pNode) {
X
Xiaoyu Wang 已提交
1342
    return TSDB_CODE_FAILED;
1343
  }
1344
  SListCell* p = nodesCalloc(1, sizeof(SListCell));
1345
  if (NULL == p) {
X
Xiaoyu Wang 已提交
1346 1347
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return TSDB_CODE_OUT_OF_MEMORY;
1348 1349
  }
  p->pNode = pNode;
1350 1351 1352 1353 1354 1355
  if (NULL == pList->pHead) {
    pList->pHead = p;
  }
  if (NULL != pList->pTail) {
    pList->pTail->pNext = p;
  }
1356
  p->pPrev = pList->pTail;
1357
  pList->pTail = p;
1358
  ++(pList->length);
X
Xiaoyu Wang 已提交
1359
  return TSDB_CODE_SUCCESS;
1360 1361
}

1362
int32_t nodesListStrictAppend(SNodeList* pList, SNode* pNode) {
1363
  if (NULL == pNode) {
X
Xiaoyu Wang 已提交
1364
    terrno = TSDB_CODE_OUT_OF_MEMORY;
1365 1366 1367 1368 1369 1370 1371 1372 1373
    return TSDB_CODE_OUT_OF_MEMORY;
  }
  int32_t code = nodesListAppend(pList, pNode);
  if (TSDB_CODE_SUCCESS != code) {
    nodesDestroyNode(pNode);
  }
  return code;
}

1374
int32_t nodesListMakeAppend(SNodeList** pList, SNode* pNode) {
X
Xiaoyu Wang 已提交
1375 1376 1377 1378 1379 1380 1381 1382 1383 1384
  if (NULL == *pList) {
    *pList = nodesMakeList();
    if (NULL == *pList) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
      return TSDB_CODE_OUT_OF_MEMORY;
    }
  }
  return nodesListAppend(*pList, pNode);
}

1385
int32_t nodesListMakeStrictAppend(SNodeList** pList, SNode* pNode) {
S
Shengliang Guan 已提交
1386 1387 1388 1389 1390 1391 1392 1393 1394 1395
  if (NULL == *pList) {
    *pList = nodesMakeList();
    if (NULL == *pList) {
      terrno = TSDB_CODE_OUT_OF_MEMORY;
      return TSDB_CODE_OUT_OF_MEMORY;
    }
  }
  return nodesListStrictAppend(*pList, pNode);
}

X
Xiaoyu Wang 已提交
1396
int32_t nodesListAppendList(SNodeList* pTarget, SNodeList* pSrc) {
X
Xiaoyu Wang 已提交
1397
  if (NULL == pTarget || NULL == pSrc) {
X
Xiaoyu Wang 已提交
1398
    return TSDB_CODE_FAILED;
X
Xiaoyu Wang 已提交
1399 1400 1401 1402 1403 1404 1405 1406 1407 1408
  }

  if (NULL == pTarget->pHead) {
    pTarget->pHead = pSrc->pHead;
  } else {
    pTarget->pTail->pNext = pSrc->pHead;
    if (NULL != pSrc->pHead) {
      pSrc->pHead->pPrev = pTarget->pTail;
    }
  }
X
Xiaoyu Wang 已提交
1409 1410
  pTarget->pTail = pSrc->pTail;
  pTarget->length += pSrc->length;
1411
  nodesFree(pSrc);
X
Xiaoyu Wang 已提交
1412

X
Xiaoyu Wang 已提交
1413 1414 1415
  return TSDB_CODE_SUCCESS;
}

1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426
int32_t nodesListStrictAppendList(SNodeList* pTarget, SNodeList* pSrc) {
  if (NULL == pSrc) {
    return TSDB_CODE_OUT_OF_MEMORY;
  }
  int32_t code = nodesListAppendList(pTarget, pSrc);
  if (TSDB_CODE_SUCCESS != code) {
    nodesDestroyList(pSrc);
  }
  return code;
}

1427
int32_t nodesListPushFront(SNodeList* pList, SNode* pNode) {
X
Xiaoyu Wang 已提交
1428 1429 1430
  if (NULL == pList || NULL == pNode) {
    return TSDB_CODE_FAILED;
  }
1431
  SListCell* p = nodesCalloc(1, sizeof(SListCell));
X
Xiaoyu Wang 已提交
1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445
  if (NULL == p) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return TSDB_CODE_OUT_OF_MEMORY;
  }
  p->pNode = pNode;
  if (NULL != pList->pHead) {
    pList->pHead->pPrev = p;
    p->pNext = pList->pHead;
  }
  pList->pHead = p;
  ++(pList->length);
  return TSDB_CODE_SUCCESS;
}

1446 1447 1448 1449 1450
SListCell* nodesListErase(SNodeList* pList, SListCell* pCell) {
  if (NULL == pCell->pPrev) {
    pList->pHead = pCell->pNext;
  } else {
    pCell->pPrev->pNext = pCell->pNext;
X
Xiaoyu Wang 已提交
1451 1452 1453 1454
  }
  if (NULL == pCell->pNext) {
    pList->pTail = pCell->pPrev;
  } else {
1455 1456 1457
    pCell->pNext->pPrev = pCell->pPrev;
  }
  SListCell* pNext = pCell->pNext;
X
Xiaoyu Wang 已提交
1458
  nodesDestroyNode(pCell->pNode);
1459
  nodesFree(pCell);
1460 1461 1462 1463
  --(pList->length);
  return pNext;
}

X
Xiaoyu Wang 已提交
1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478
void nodesListInsertList(SNodeList* pTarget, SListCell* pPos, SNodeList* pSrc) {
  if (NULL == pTarget || NULL == pPos || NULL == pSrc) {
    return;
  }

  if (NULL == pPos->pPrev) {
    pTarget->pHead = pSrc->pHead;
  } else {
    pPos->pPrev->pNext = pSrc->pHead;
  }
  pSrc->pHead->pPrev = pPos->pPrev;
  pSrc->pTail->pNext = pPos;
  pPos->pPrev = pSrc->pTail;

  pTarget->length += pSrc->length;
1479
  nodesFree(pSrc);
X
Xiaoyu Wang 已提交
1480 1481
}

1482
SNode* nodesListGetNode(SNodeList* pList, int32_t index) {
1483 1484 1485 1486 1487 1488 1489 1490 1491
  SNode* node;
  FOREACH(node, pList) {
    if (0 == index--) {
      return node;
    }
  }
  return NULL;
}

X
Xiaoyu Wang 已提交
1492 1493 1494 1495 1496 1497 1498 1499 1500 1501
SListCell* nodesListGetCell(SNodeList* pList, int32_t index) {
  SNode* node;
  FOREACH(node, pList) {
    if (0 == index--) {
      return cell;
    }
  }
  return NULL;
}

1502
void nodesDestroyList(SNodeList* pList) {
1503 1504 1505
  if (NULL == pList) {
    return;
  }
X
Xiaoyu Wang 已提交
1506

D
dapan1121 已提交
1507 1508 1509
  SListCell* pNext = pList->pHead;
  while (NULL != pNext) {
    pNext = nodesListErase(pList, pNext);
1510
  }
1511
  nodesFree(pList);
1512 1513
}

X
Xiaoyu Wang 已提交
1514 1515 1516 1517 1518 1519 1520 1521 1522
void nodesClearList(SNodeList* pList) {
  if (NULL == pList) {
    return;
  }

  SListCell* pNext = pList->pHead;
  while (NULL != pNext) {
    SListCell* tmp = pNext;
    pNext = pNext->pNext;
1523
    nodesFree(tmp);
X
Xiaoyu Wang 已提交
1524
  }
1525
  nodesFree(pList);
X
Xiaoyu Wang 已提交
1526 1527
}

X
Xiaoyu Wang 已提交
1528
void* nodesGetValueFromNode(SValueNode* pNode) {
D
dapan1121 已提交
1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540
  switch (pNode->node.resType.type) {
    case TSDB_DATA_TYPE_BOOL:
    case TSDB_DATA_TYPE_TINYINT:
    case TSDB_DATA_TYPE_SMALLINT:
    case TSDB_DATA_TYPE_INT:
    case TSDB_DATA_TYPE_BIGINT:
    case TSDB_DATA_TYPE_TIMESTAMP:
    case TSDB_DATA_TYPE_UTINYINT:
    case TSDB_DATA_TYPE_USMALLINT:
    case TSDB_DATA_TYPE_UINT:
    case TSDB_DATA_TYPE_UBIGINT:
    case TSDB_DATA_TYPE_FLOAT:
1541
    case TSDB_DATA_TYPE_DOUBLE:
D
dapan1121 已提交
1542
      return (void*)&pNode->typeData;
D
dapan1121 已提交
1543 1544
    case TSDB_DATA_TYPE_NCHAR:
    case TSDB_DATA_TYPE_VARCHAR:
1545
    case TSDB_DATA_TYPE_VARBINARY:
wmmhello's avatar
wmmhello 已提交
1546
    case TSDB_DATA_TYPE_JSON:
X
Xiaoyu Wang 已提交
1547
      return (void*)pNode->datum.p;
D
dapan1121 已提交
1548 1549 1550 1551 1552 1553 1554
    default:
      break;
  }

  return NULL;
}

X
Xiaoyu Wang 已提交
1555
int32_t nodesSetValueNodeValue(SValueNode* pNode, void* value) {
D
dapan1121 已提交
1556 1557 1558
  switch (pNode->node.resType.type) {
    case TSDB_DATA_TYPE_BOOL:
      pNode->datum.b = *(bool*)value;
D
dapan1121 已提交
1559
      *(bool*)&pNode->typeData = pNode->datum.b;
D
dapan1121 已提交
1560 1561 1562
      break;
    case TSDB_DATA_TYPE_TINYINT:
      pNode->datum.i = *(int8_t*)value;
D
dapan1121 已提交
1563
      *(int8_t*)&pNode->typeData = pNode->datum.i;
D
dapan1121 已提交
1564 1565 1566
      break;
    case TSDB_DATA_TYPE_SMALLINT:
      pNode->datum.i = *(int16_t*)value;
D
dapan1121 已提交
1567
      *(int16_t*)&pNode->typeData = pNode->datum.i;
D
dapan1121 已提交
1568 1569 1570
      break;
    case TSDB_DATA_TYPE_INT:
      pNode->datum.i = *(int32_t*)value;
D
dapan1121 已提交
1571
      *(int32_t*)&pNode->typeData = pNode->datum.i;
D
dapan1121 已提交
1572 1573 1574
      break;
    case TSDB_DATA_TYPE_BIGINT:
      pNode->datum.i = *(int64_t*)value;
D
dapan1121 已提交
1575
      *(int64_t*)&pNode->typeData = pNode->datum.i;
D
dapan1121 已提交
1576 1577 1578
      break;
    case TSDB_DATA_TYPE_TIMESTAMP:
      pNode->datum.i = *(int64_t*)value;
D
dapan1121 已提交
1579
      *(int64_t*)&pNode->typeData = pNode->datum.i;
D
dapan1121 已提交
1580 1581 1582
      break;
    case TSDB_DATA_TYPE_UTINYINT:
      pNode->datum.u = *(int8_t*)value;
D
dapan1121 已提交
1583
      *(int8_t*)&pNode->typeData = pNode->datum.u;
D
dapan1121 已提交
1584 1585 1586
      break;
    case TSDB_DATA_TYPE_USMALLINT:
      pNode->datum.u = *(int16_t*)value;
D
dapan1121 已提交
1587
      *(int16_t*)&pNode->typeData = pNode->datum.u;
D
dapan1121 已提交
1588 1589 1590
      break;
    case TSDB_DATA_TYPE_UINT:
      pNode->datum.u = *(int32_t*)value;
D
dapan1121 已提交
1591
      *(int32_t*)&pNode->typeData = pNode->datum.u;
D
dapan1121 已提交
1592 1593 1594
      break;
    case TSDB_DATA_TYPE_UBIGINT:
      pNode->datum.u = *(uint64_t*)value;
D
dapan1121 已提交
1595
      *(uint64_t*)&pNode->typeData = pNode->datum.u;
D
dapan1121 已提交
1596 1597 1598
      break;
    case TSDB_DATA_TYPE_FLOAT:
      pNode->datum.d = *(float*)value;
D
dapan1121 已提交
1599
      *(float*)&pNode->typeData = pNode->datum.d;
D
dapan1121 已提交
1600 1601 1602
      break;
    case TSDB_DATA_TYPE_DOUBLE:
      pNode->datum.d = *(double*)value;
D
dapan1121 已提交
1603
      *(double*)&pNode->typeData = pNode->datum.d;
D
dapan1121 已提交
1604 1605 1606 1607
      break;
    case TSDB_DATA_TYPE_NCHAR:
    case TSDB_DATA_TYPE_VARCHAR:
    case TSDB_DATA_TYPE_VARBINARY:
wmmhello's avatar
wmmhello 已提交
1608
    case TSDB_DATA_TYPE_JSON:
D
dapan1121 已提交
1609 1610 1611
      pNode->datum.p = (char*)value;
      break;
    default:
S
Shengliang Guan 已提交
1612
      return TSDB_CODE_APP_ERROR;
D
dapan1121 已提交
1613 1614 1615 1616 1617
  }

  return TSDB_CODE_SUCCESS;
}

X
Xiaoyu Wang 已提交
1618
char* nodesGetStrValueFromNode(SValueNode* pNode) {
D
dapan1121 已提交
1619
  switch (pNode->node.resType.type) {
D
dapan1121 已提交
1620
    case TSDB_DATA_TYPE_BOOL: {
X
Xiaoyu Wang 已提交
1621
      void* buf = taosMemoryMalloc(MAX_NUM_STR_SIZE);
D
dapan1121 已提交
1622 1623 1624
      if (NULL == buf) {
        return NULL;
      }
1625

D
dapan1121 已提交
1626 1627
      sprintf(buf, "%s", pNode->datum.b ? "true" : "false");
      return buf;
D
dapan1121 已提交
1628
    }
D
dapan1121 已提交
1629 1630 1631 1632 1633
    case TSDB_DATA_TYPE_TINYINT:
    case TSDB_DATA_TYPE_SMALLINT:
    case TSDB_DATA_TYPE_INT:
    case TSDB_DATA_TYPE_BIGINT:
    case TSDB_DATA_TYPE_TIMESTAMP: {
X
Xiaoyu Wang 已提交
1634
      void* buf = taosMemoryMalloc(MAX_NUM_STR_SIZE);
D
dapan1121 已提交
1635 1636 1637
      if (NULL == buf) {
        return NULL;
      }
1638

D
dapan1121 已提交
1639 1640 1641 1642 1643 1644 1645
      sprintf(buf, "%" PRId64, pNode->datum.i);
      return buf;
    }
    case TSDB_DATA_TYPE_UTINYINT:
    case TSDB_DATA_TYPE_USMALLINT:
    case TSDB_DATA_TYPE_UINT:
    case TSDB_DATA_TYPE_UBIGINT: {
X
Xiaoyu Wang 已提交
1646
      void* buf = taosMemoryMalloc(MAX_NUM_STR_SIZE);
D
dapan1121 已提交
1647 1648 1649
      if (NULL == buf) {
        return NULL;
      }
1650

D
dapan1121 已提交
1651 1652 1653 1654 1655
      sprintf(buf, "%" PRIu64, pNode->datum.u);
      return buf;
    }
    case TSDB_DATA_TYPE_FLOAT:
    case TSDB_DATA_TYPE_DOUBLE: {
X
Xiaoyu Wang 已提交
1656
      void* buf = taosMemoryMalloc(MAX_NUM_STR_SIZE);
D
dapan1121 已提交
1657 1658 1659
      if (NULL == buf) {
        return NULL;
      }
1660

D
dapan1121 已提交
1661 1662 1663 1664 1665 1666
      sprintf(buf, "%e", pNode->datum.d);
      return buf;
    }
    case TSDB_DATA_TYPE_NCHAR:
    case TSDB_DATA_TYPE_VARCHAR:
    case TSDB_DATA_TYPE_VARBINARY: {
D
dapan1121 已提交
1667
      int32_t bufSize = varDataLen(pNode->datum.p) + 2 + 1;
X
Xiaoyu Wang 已提交
1668
      void*   buf = taosMemoryMalloc(bufSize);
D
dapan1121 已提交
1669 1670 1671
      if (NULL == buf) {
        return NULL;
      }
1672

D
dapan1121 已提交
1673
      snprintf(buf, bufSize, "'%s'", varDataVal(pNode->datum.p));
D
dapan1121 已提交
1674 1675 1676 1677 1678 1679 1680 1681 1682
      return buf;
    }
    default:
      break;
  }

  return NULL;
}

1683 1684
bool nodesIsExprNode(const SNode* pNode) {
  ENodeType type = nodeType(pNode);
X
Xiaoyu Wang 已提交
1685
  return (QUERY_NODE_COLUMN == type || QUERY_NODE_VALUE == type || QUERY_NODE_OPERATOR == type ||
D
dapan1121 已提交
1686
          QUERY_NODE_FUNCTION == type || QUERY_NODE_LOGIC_CONDITION == type || QUERY_NODE_CASE_WHEN == type);
1687 1688
}

X
Xiaoyu Wang 已提交
1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706
bool nodesIsUnaryOp(const SOperatorNode* pOp) {
  switch (pOp->opType) {
    case OP_TYPE_MINUS:
    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:
      return true;
    default:
      break;
  }
  return false;
}

1707 1708 1709 1710 1711 1712
bool nodesIsArithmeticOp(const SOperatorNode* pOp) {
  switch (pOp->opType) {
    case OP_TYPE_ADD:
    case OP_TYPE_SUB:
    case OP_TYPE_MULTI:
    case OP_TYPE_DIV:
1713
    case OP_TYPE_REM:
1714 1715 1716 1717 1718 1719
      return true;
    default:
      break;
  }
  return false;
}
1720

1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734
bool nodesIsComparisonOp(const SOperatorNode* pOp) {
  switch (pOp->opType) {
    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:
    case OP_TYPE_IN:
    case OP_TYPE_NOT_IN:
    case OP_TYPE_LIKE:
    case OP_TYPE_NOT_LIKE:
    case OP_TYPE_MATCH:
    case OP_TYPE_NMATCH:
1735
    case OP_TYPE_JSON_CONTAINS:
X
Xiaoyu Wang 已提交
1736 1737 1738 1739 1740 1741 1742 1743
    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:
1744 1745 1746 1747 1748
      return true;
    default:
      break;
  }
  return false;
1749 1750
}

1751 1752 1753
bool nodesIsJsonOp(const SOperatorNode* pOp) {
  switch (pOp->opType) {
    case OP_TYPE_JSON_GET_VALUE:
wmmhello's avatar
wmmhello 已提交
1754
    case OP_TYPE_JSON_CONTAINS:
1755 1756 1757 1758 1759 1760
      return true;
    default:
      break;
  }
  return false;
}
1761

X
Xiaoyu Wang 已提交
1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774
bool nodesIsRegularOp(const SOperatorNode* pOp) {
  switch (pOp->opType) {
    case OP_TYPE_LIKE:
    case OP_TYPE_NOT_LIKE:
    case OP_TYPE_MATCH:
    case OP_TYPE_NMATCH:
      return true;
    default:
      break;
  }
  return false;
}

X
Xiaoyu Wang 已提交
1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785
bool nodesIsBitwiseOp(const SOperatorNode* pOp) {
  switch (pOp->opType) {
    case OP_TYPE_BIT_AND:
    case OP_TYPE_BIT_OR:
      return true;
    default:
      break;
  }
  return false;
}

X
Xiaoyu Wang 已提交
1786
typedef struct SCollectColumnsCxt {
1787 1788 1789 1790 1791
  int32_t         errCode;
  const char*     pTableAlias;
  ECollectColType collectType;
  SNodeList*      pCols;
  SHashObj*       pColHash;
X
Xiaoyu Wang 已提交
1792 1793
} SCollectColumnsCxt;

1794
static EDealRes doCollect(SCollectColumnsCxt* pCxt, SColumnNode* pCol, SNode* pNode) {
X
Xiaoyu Wang 已提交
1795
  char    name[TSDB_TABLE_NAME_LEN + TSDB_COL_NAME_LEN];
1796 1797
  int32_t len = 0;
  if ('\0' == pCol->tableAlias[0]) {
X
Xiaoyu Wang 已提交
1798 1799 1800
    len = snprintf(name, sizeof(name), "%s", pCol->colName);
  } else {
    len = snprintf(name, sizeof(name), "%s.%s", pCol->tableAlias, pCol->colName);
1801 1802 1803
  }
  if (NULL == taosHashGet(pCxt->pColHash, name, len)) {
    pCxt->errCode = taosHashPut(pCxt->pColHash, name, len, NULL, 0);
X
Xiaoyu Wang 已提交
1804
    if (TSDB_CODE_SUCCESS == pCxt->errCode) {
1805
      pCxt->errCode = nodesListStrictAppend(pCxt->pCols, nodesCloneNode(pNode));
X
Xiaoyu Wang 已提交
1806 1807 1808 1809 1810 1811
    }
    return (TSDB_CODE_SUCCESS == pCxt->errCode ? DEAL_RES_IGNORE_CHILD : DEAL_RES_ERROR);
  }
  return DEAL_RES_CONTINUE;
}

1812 1813 1814 1815 1816 1817
static bool isCollectType(ECollectColType collectType, EColumnType colType) {
  return COLLECT_COL_TYPE_ALL == collectType
             ? true
             : (COLLECT_COL_TYPE_TAG == collectType ? COLUMN_TYPE_TAG == colType : COLUMN_TYPE_TAG != colType);
}

X
Xiaoyu Wang 已提交
1818 1819
static EDealRes collectColumns(SNode* pNode, void* pContext) {
  SCollectColumnsCxt* pCxt = (SCollectColumnsCxt*)pContext;
X
Xiaoyu Wang 已提交
1820
  if (QUERY_NODE_COLUMN == nodeType(pNode)) {
X
Xiaoyu Wang 已提交
1821
    SColumnNode* pCol = (SColumnNode*)pNode;
X
Xiaoyu Wang 已提交
1822
    if (isCollectType(pCxt->collectType, pCol->colType) && 0 != strcmp(pCol->colName, "*") &&
1823
        (NULL == pCxt->pTableAlias || 0 == strcmp(pCxt->pTableAlias, pCol->tableAlias))) {
1824
      return doCollect(pCxt, pCol, pNode);
X
Xiaoyu Wang 已提交
1825 1826 1827 1828 1829
    }
  }
  return DEAL_RES_CONTINUE;
}

1830 1831
int32_t nodesCollectColumns(SSelectStmt* pSelect, ESqlClause clause, const char* pTableAlias, ECollectColType type,
                            SNodeList** pCols) {
X
Xiaoyu Wang 已提交
1832
  if (NULL == pSelect || NULL == pCols) {
1833
    return TSDB_CODE_FAILED;
X
Xiaoyu Wang 已提交
1834 1835 1836
  }

  SCollectColumnsCxt cxt = {
X
Xiaoyu Wang 已提交
1837 1838
      .errCode = TSDB_CODE_SUCCESS,
      .pTableAlias = pTableAlias,
1839
      .collectType = type,
1840
      .pCols = (NULL == *pCols ? nodesMakeList() : *pCols),
X
Xiaoyu Wang 已提交
1841
      .pColHash = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK)};
1842
  if (NULL == cxt.pCols || NULL == cxt.pColHash) {
X
Xiaoyu Wang 已提交
1843 1844
    return TSDB_CODE_OUT_OF_MEMORY;
  }
1845
  *pCols = NULL;
X
Xiaoyu Wang 已提交
1846
  nodesWalkSelectStmt(pSelect, clause, collectColumns, &cxt);
1847
  taosHashCleanup(cxt.pColHash);
X
Xiaoyu Wang 已提交
1848
  if (TSDB_CODE_SUCCESS != cxt.errCode) {
1849
    nodesDestroyList(cxt.pCols);
X
Xiaoyu Wang 已提交
1850 1851
    return cxt.errCode;
  }
1852 1853 1854
  if (LIST_LENGTH(cxt.pCols) > 0) {
    *pCols = cxt.pCols;
  } else {
1855
    nodesDestroyList(cxt.pCols);
X
Xiaoyu Wang 已提交
1856
  }
1857

X
Xiaoyu Wang 已提交
1858 1859 1860
  return TSDB_CODE_SUCCESS;
}

1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891
int32_t nodesCollectColumnsFromNode(SNode* node, const char* pTableAlias, ECollectColType type, SNodeList** pCols) {
  if (NULL == pCols) {
    return TSDB_CODE_FAILED;
  }
  SCollectColumnsCxt cxt = {
      .errCode = TSDB_CODE_SUCCESS,
      .pTableAlias = pTableAlias,
      .collectType = type,
      .pCols = (NULL == *pCols ? nodesMakeList() : *pCols),
      .pColHash = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK)};
  if (NULL == cxt.pCols || NULL == cxt.pColHash) {
    return TSDB_CODE_OUT_OF_MEMORY;
  }
  *pCols = NULL;

  nodesWalkExpr(node, collectColumns, &cxt);

  taosHashCleanup(cxt.pColHash);
  if (TSDB_CODE_SUCCESS != cxt.errCode) {
    nodesDestroyList(cxt.pCols);
    return cxt.errCode;
  }
  if (LIST_LENGTH(cxt.pCols) > 0) {
    *pCols = cxt.pCols;
  } else {
    nodesDestroyList(cxt.pCols);
  }

  return TSDB_CODE_SUCCESS;
}

X
Xiaoyu Wang 已提交
1892
typedef struct SCollectFuncsCxt {
X
Xiaoyu Wang 已提交
1893
  int32_t         errCode;
X
Xiaoyu Wang 已提交
1894
  FFuncClassifier classifier;
X
Xiaoyu Wang 已提交
1895
  SNodeList*      pFuncs;
X
Xiaoyu Wang 已提交
1896
  SHashObj*       pFuncsSet;
X
Xiaoyu Wang 已提交
1897 1898 1899 1900
} SCollectFuncsCxt;

static EDealRes collectFuncs(SNode* pNode, void* pContext) {
  SCollectFuncsCxt* pCxt = (SCollectFuncsCxt*)pContext;
1901 1902
  if (QUERY_NODE_FUNCTION == nodeType(pNode) && pCxt->classifier(((SFunctionNode*)pNode)->funcId) &&
      !(((SExprNode*)pNode)->orderAlias)) {
X
Xiaoyu Wang 已提交
1903
    SExprNode* pExpr = (SExprNode*)pNode;
X
Xiaoyu Wang 已提交
1904
    if (NULL == taosHashGet(pCxt->pFuncsSet, &pExpr, sizeof(SExprNode*))) {
X
Xiaoyu Wang 已提交
1905
      pCxt->errCode = nodesListStrictAppend(pCxt->pFuncs, nodesCloneNode(pNode));
X
Xiaoyu Wang 已提交
1906
      taosHashPut(pCxt->pFuncsSet, &pExpr, POINTER_BYTES, &pExpr, POINTER_BYTES);
X
Xiaoyu Wang 已提交
1907
    }
X
Xiaoyu Wang 已提交
1908 1909 1910 1911 1912
    return (TSDB_CODE_SUCCESS == pCxt->errCode ? DEAL_RES_IGNORE_CHILD : DEAL_RES_ERROR);
  }
  return DEAL_RES_CONTINUE;
}

X
Xiaoyu Wang 已提交
1913 1914 1915 1916 1917 1918
static uint32_t funcNodeHash(const char* pKey, uint32_t len) {
  SExprNode* pExpr = *(SExprNode**)pKey;
  return MurmurHash3_32(pExpr->aliasName, strlen(pExpr->aliasName));
}

static int32_t funcNodeEqual(const void* pLeft, const void* pRight, size_t len) {
X
Xiaoyu Wang 已提交
1919 1920 1921
  if (0 != strcmp((*(const SExprNode**)pLeft)->aliasName, (*(const SExprNode**)pRight)->aliasName)) {
    return 1;
  }
X
Xiaoyu Wang 已提交
1922 1923 1924
  return nodesEqualNode(*(const SNode**)pLeft, *(const SNode**)pRight) ? 0 : 1;
}

X
Xiaoyu Wang 已提交
1925
int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, FFuncClassifier classifier, SNodeList** pFuncs) {
X
Xiaoyu Wang 已提交
1926
  if (NULL == pSelect || NULL == pFuncs) {
1927
    return TSDB_CODE_FAILED;
X
Xiaoyu Wang 已提交
1928 1929
  }

X
Xiaoyu Wang 已提交
1930 1931 1932 1933 1934
  SCollectFuncsCxt cxt = {.errCode = TSDB_CODE_SUCCESS,
                          .classifier = classifier,
                          .pFuncs = (NULL == *pFuncs ? nodesMakeList() : *pFuncs),
                          .pFuncsSet = taosHashInit(4, funcNodeHash, false, false)};
  if (NULL == cxt.pFuncs || NULL == cxt.pFuncsSet) {
X
Xiaoyu Wang 已提交
1935 1936
    return TSDB_CODE_OUT_OF_MEMORY;
  }
X
Xiaoyu Wang 已提交
1937
  taosHashSetEqualFp(cxt.pFuncsSet, funcNodeEqual);
1938
  *pFuncs = NULL;
X
Xiaoyu Wang 已提交
1939
  nodesWalkSelectStmt(pSelect, clause, collectFuncs, &cxt);
X
Xiaoyu Wang 已提交
1940 1941 1942 1943 1944 1945
  if (TSDB_CODE_SUCCESS == cxt.errCode) {
    if (LIST_LENGTH(cxt.pFuncs) > 0) {
      *pFuncs = cxt.pFuncs;
    } else {
      nodesDestroyList(cxt.pFuncs);
    }
X
Xiaoyu Wang 已提交
1946 1947 1948
  } else {
    nodesDestroyList(cxt.pFuncs);
  }
X
Xiaoyu Wang 已提交
1949
  taosHashCleanup(cxt.pFuncsSet);
X
Xiaoyu Wang 已提交
1950

X
Xiaoyu Wang 已提交
1951
  return cxt.errCode;
1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990
}

typedef struct SCollectSpecialNodesCxt {
  int32_t    errCode;
  ENodeType  type;
  SNodeList* pNodes;
} SCollectSpecialNodesCxt;

static EDealRes collectSpecialNodes(SNode* pNode, void* pContext) {
  SCollectSpecialNodesCxt* pCxt = (SCollectSpecialNodesCxt*)pContext;
  if (pCxt->type == nodeType(pNode)) {
    pCxt->errCode = nodesListStrictAppend(pCxt->pNodes, nodesCloneNode(pNode));
    return (TSDB_CODE_SUCCESS == pCxt->errCode ? DEAL_RES_IGNORE_CHILD : DEAL_RES_ERROR);
  }
  return DEAL_RES_CONTINUE;
}

int32_t nodesCollectSpecialNodes(SSelectStmt* pSelect, ESqlClause clause, ENodeType type, SNodeList** pNodes) {
  if (NULL == pSelect || NULL == pNodes) {
    return TSDB_CODE_FAILED;
  }

  SCollectSpecialNodesCxt cxt = {
      .errCode = TSDB_CODE_SUCCESS, .type = type, .pNodes = (NULL == *pNodes ? nodesMakeList() : *pNodes)};
  if (NULL == cxt.pNodes) {
    return TSDB_CODE_OUT_OF_MEMORY;
  }
  *pNodes = NULL;
  nodesWalkSelectStmt(pSelect, SQL_CLAUSE_GROUP_BY, collectSpecialNodes, &cxt);
  if (TSDB_CODE_SUCCESS != cxt.errCode) {
    nodesDestroyList(cxt.pNodes);
    return cxt.errCode;
  }
  if (LIST_LENGTH(cxt.pNodes) > 0) {
    *pNodes = cxt.pNodes;
  } else {
    nodesDestroyList(cxt.pNodes);
  }

X
Xiaoyu Wang 已提交
1991 1992
  return TSDB_CODE_SUCCESS;
}
D
dapan1121 已提交
1993

1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013
static EDealRes hasColumn(SNode* pNode, void* pContext) {
  if (QUERY_NODE_COLUMN == nodeType(pNode)) {
    *(bool*)pContext = true;
    return DEAL_RES_END;
  }
  return DEAL_RES_CONTINUE;
}

bool nodesExprHasColumn(SNode* pNode) {
  bool hasCol = false;
  nodesWalkExprPostOrder(pNode, hasColumn, &hasCol);
  return hasCol;
}

bool nodesExprsHasColumn(SNodeList* pList) {
  bool hasCol = false;
  nodesWalkExprsPostOrder(pList, hasColumn, &hasCol);
  return hasCol;
}

X
Xiaoyu Wang 已提交
2014
char* nodesGetFillModeString(EFillMode mode) {
D
dapan1121 已提交
2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032
  switch (mode) {
    case FILL_MODE_NONE:
      return "none";
    case FILL_MODE_VALUE:
      return "value";
    case FILL_MODE_PREV:
      return "prev";
    case FILL_MODE_NULL:
      return "null";
    case FILL_MODE_LINEAR:
      return "linear";
    case FILL_MODE_NEXT:
      return "next";
    default:
      return "unknown";
  }
}

X
Xiaoyu Wang 已提交
2033
char* nodesGetNameFromColumnNode(SNode* pNode) {
D
dapan1121 已提交
2034 2035 2036
  if (NULL == pNode || QUERY_NODE_COLUMN != pNode->type) {
    return "NULL";
  }
X
Xiaoyu Wang 已提交
2037 2038

  return ((SColumnNode*)pNode)->colName;
D
dapan1121 已提交
2039 2040
}

D
dapan1121 已提交
2041 2042 2043 2044 2045
int32_t nodesGetOutputNumFromSlotList(SNodeList* pSlots) {
  if (NULL == pSlots || pSlots->length <= 0) {
    return 0;
  }

X
Xiaoyu Wang 已提交
2046
  SNode*  pNode = NULL;
D
dapan1121 已提交
2047 2048 2049 2050 2051 2052
  int32_t num = 0;
  FOREACH(pNode, pSlots) {
    if (QUERY_NODE_SLOT_DESC != pNode->type) {
      continue;
    }

X
Xiaoyu Wang 已提交
2053
    SSlotDescNode* descNode = (SSlotDescNode*)pNode;
D
dapan1121 已提交
2054 2055 2056 2057 2058 2059 2060 2061
    if (descNode->output) {
      ++num;
    }
  }

  return num;
}

X
Xiaoyu Wang 已提交
2062
void nodesValueNodeToVariant(const SValueNode* pNode, SVariant* pVal) {
2063 2064 2065 2066 2067
  if (pNode->isNull) {
    pVal->nType = TSDB_DATA_TYPE_NULL;
    pVal->nLen = tDataTypes[TSDB_DATA_TYPE_NULL].bytes;
    return;
  }
D
dapan1121 已提交
2068 2069 2070 2071
  pVal->nType = pNode->node.resType.type;
  pVal->nLen = pNode->node.resType.bytes;
  switch (pNode->node.resType.type) {
    case TSDB_DATA_TYPE_NULL:
X
Xiaoyu Wang 已提交
2072
      break;
D
dapan1121 已提交
2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089
    case TSDB_DATA_TYPE_BOOL:
      pVal->i = pNode->datum.b;
      break;
    case TSDB_DATA_TYPE_TINYINT:
    case TSDB_DATA_TYPE_SMALLINT:
    case TSDB_DATA_TYPE_INT:
    case TSDB_DATA_TYPE_BIGINT:
    case TSDB_DATA_TYPE_TIMESTAMP:
      pVal->i = pNode->datum.i;
      break;
    case TSDB_DATA_TYPE_UTINYINT:
    case TSDB_DATA_TYPE_USMALLINT:
    case TSDB_DATA_TYPE_UINT:
    case TSDB_DATA_TYPE_UBIGINT:
      pVal->u = pNode->datum.u;
      break;
    case TSDB_DATA_TYPE_FLOAT:
2090 2091
      pVal->f = pNode->datum.d;
      break;
D
dapan1121 已提交
2092 2093 2094 2095 2096 2097
    case TSDB_DATA_TYPE_DOUBLE:
      pVal->d = pNode->datum.d;
      break;
    case TSDB_DATA_TYPE_NCHAR:
    case TSDB_DATA_TYPE_VARCHAR:
    case TSDB_DATA_TYPE_VARBINARY:
D
dapan1121 已提交
2098 2099 2100
      pVal->pz = taosMemoryMalloc(pVal->nLen + VARSTR_HEADER_SIZE + 1);
      memcpy(pVal->pz, pNode->datum.p, pVal->nLen + VARSTR_HEADER_SIZE);
      pVal->pz[pVal->nLen + VARSTR_HEADER_SIZE] = 0;
D
dapan1121 已提交
2101 2102
      break;
    case TSDB_DATA_TYPE_JSON:
wmmhello's avatar
wmmhello 已提交
2103 2104 2105 2106
      pVal->nLen = getJsonValueLen(pNode->datum.p);
      pVal->pz = taosMemoryMalloc(pVal->nLen);
      memcpy(pVal->pz, pNode->datum.p, pVal->nLen);
      break;
D
dapan1121 已提交
2107 2108 2109 2110 2111 2112 2113
    case TSDB_DATA_TYPE_DECIMAL:
    case TSDB_DATA_TYPE_BLOB:
      // todo
    default:
      break;
  }
}
X
Xiaoyu Wang 已提交
2114 2115 2116 2117 2118 2119 2120 2121 2122 2123

int32_t nodesMergeConds(SNode** pDst, SNodeList** pSrc) {
  if (NULL == *pSrc) {
    return TSDB_CODE_SUCCESS;
  }

  if (1 == LIST_LENGTH(*pSrc)) {
    *pDst = nodesListGetNode(*pSrc, 0);
    nodesClearList(*pSrc);
  } else {
2124
    SLogicConditionNode* pLogicCond = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION);
X
Xiaoyu Wang 已提交
2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137
    if (NULL == pLogicCond) {
      return TSDB_CODE_OUT_OF_MEMORY;
    }
    pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL;
    pLogicCond->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;
    pLogicCond->condType = LOGIC_COND_TYPE_AND;
    pLogicCond->pParameterList = *pSrc;
    *pDst = (SNode*)pLogicCond;
  }
  *pSrc = NULL;

  return TSDB_CODE_SUCCESS;
}
X
Xiaoyu Wang 已提交
2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153

const char* dataOrderStr(EDataOrderLevel order) {
  switch (order) {
    case DATA_ORDER_LEVEL_NONE:
      return "no order required";
    case DATA_ORDER_LEVEL_IN_BLOCK:
      return "in-datablock order";
    case DATA_ORDER_LEVEL_IN_GROUP:
      return "in-group order";
    case DATA_ORDER_LEVEL_GLOBAL:
      return "global order";
    default:
      break;
  }
  return "unknown";
}