texpr.c 17.1 KB
Newer Older
H
hzcheng 已提交
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 "function.h"
S
slguan 已提交
17
#include "os.h"
H
Haojun Liao 已提交
18

S
Shengliang Guan 已提交
19
#include "texception.h"
20
#include "taosdef.h"
H
Hongze Cheng 已提交
21
#include "tmsg.h"
H
Haojun Liao 已提交
22 23 24
#include "tarray.h"
#include "tbuffer.h"
#include "tcompare.h"
H
Haojun Liao 已提交
25
#include "thash.h"
H
Haojun Liao 已提交
26
#include "texpr.h"
H
Haojun Liao 已提交
27
#include "tvariant.h"
D
dapan1121 已提交
28
#include "tdef.h"
H
hzcheng 已提交
29

30 31 32 33 34 35 36 37 38 39 40 41
//static uint8_t UNUSED_FUNC isQueryOnPrimaryKey(const char *primaryColumnName, const tExprNode *pLeft, const tExprNode *pRight) {
//  if (pLeft->nodeType == TEXPR_COL_NODE) {
//    // if left node is the primary column,return true
//    return (strcmp(primaryColumnName, pLeft->pSchema->name) == 0) ? 1 : 0;
//  } else {
//    // if any children have query on primary key, their parents are also keep this value
//    return ((pLeft->nodeType == TEXPR_BINARYEXPR_NODE && pLeft->_node.hasPK == 1) ||
//            (pRight->nodeType == TEXPR_BINARYEXPR_NODE && pRight->_node.hasPK == 1)) == true
//               ? 1
//               : 0;
//  }
//}
H
hzcheng 已提交
42

H
Haojun Liao 已提交
43 44 45
static void doExprTreeDestroy(tExprNode **pExpr, void (*fp)(void *));

void tExprTreeDestroy(tExprNode *pNode, void (*fp)(void *)) {
H
Haojun Liao 已提交
46 47 48 49
  if (pNode == NULL) {
    return;
  }

50
  if (pNode->nodeType == TEXPR_BINARYEXPR_NODE || pNode->nodeType == TEXPR_UNARYEXPR_NODE) {
H
Haojun Liao 已提交
51
    doExprTreeDestroy(&pNode, fp);
52
  } else if (pNode->nodeType == TEXPR_VALUE_NODE) {
H
Haojun Liao 已提交
53
    taosVariantDestroy(pNode->pVal);
54
  } else if (pNode->nodeType == TEXPR_COL_NODE) {
W
wpan 已提交
55
    tfree(pNode->pSchema);
H
Haojun Liao 已提交
56 57 58 59 60
  }

  free(pNode);
}

H
Haojun Liao 已提交
61
static void doExprTreeDestroy(tExprNode **pExpr, void (*fp)(void *)) {
H
Haojun Liao 已提交
62 63 64
  if (*pExpr == NULL) {
    return;
  }
65 66 67

  int32_t type = (*pExpr)->nodeType;
  if (type == TEXPR_BINARYEXPR_NODE) {
H
Haojun Liao 已提交
68 69
    doExprTreeDestroy(&(*pExpr)->_node.pLeft, fp);
    doExprTreeDestroy(&(*pExpr)->_node.pRight, fp);
H
Haojun Liao 已提交
70 71 72 73
  
    if (fp != NULL) {
      fp((*pExpr)->_node.info);
    }
74 75 76 77 78 79 80 81
  } else if (type == TEXPR_UNARYEXPR_NODE) {
    doExprTreeDestroy(&(*pExpr)->_node.pLeft, fp);
    if (fp != NULL) {
      fp((*pExpr)->_node.info);
    }

    assert((*pExpr)->_node.pRight == NULL);
  } else if (type == TEXPR_VALUE_NODE) {
H
Haojun Liao 已提交
82
    taosVariantDestroy((*pExpr)->pVal);
H
Haojun Liao 已提交
83
    free((*pExpr)->pVal);
84
  } else if (type == TEXPR_COL_NODE) {
H
Haojun Liao 已提交
85 86 87 88 89 90 91
    free((*pExpr)->pSchema);
  }

  free(*pExpr);
  *pExpr = NULL;
}

H
Haojun Liao 已提交
92
bool exprTreeApplyFilter(tExprNode *pExpr, const void *pItem, SExprTraverseSupp *param) {
H
Haojun Liao 已提交
93 94 95 96
  tExprNode *pLeft  = pExpr->_node.pLeft;
  tExprNode *pRight = pExpr->_node.pRight;

  //non-leaf nodes, recursively traverse the expression tree in the post-root order
97
  if (pLeft->nodeType == TEXPR_BINARYEXPR_NODE && pRight->nodeType == TEXPR_BINARYEXPR_NODE) {
D
dapan1121 已提交
98
    if (pExpr->_node.optr == LOGIC_COND_TYPE_OR) {  // or
H
Haojun Liao 已提交
99
      if (exprTreeApplyFilter(pLeft, pItem, param)) {
H
Haojun Liao 已提交
100 101 102 103
        return true;
      }

      // left child does not satisfy the query condition, try right child
H
Haojun Liao 已提交
104
      return exprTreeApplyFilter(pRight, pItem, param);
H
Haojun Liao 已提交
105
    } else {  // and
H
Haojun Liao 已提交
106
      if (!exprTreeApplyFilter(pLeft, pItem, param)) {
H
Haojun Liao 已提交
107 108 109
        return false;
      }

H
Haojun Liao 已提交
110
      return exprTreeApplyFilter(pRight, pItem, param);
H
Haojun Liao 已提交
111 112 113 114 115 116 117 118
    }
  }

  // handle the leaf node
  param->setupInfoFn(pExpr, param->pExtInfo);
  return param->nodeFilterFn(pItem, pExpr->_node.info);
}

H
hzcheng 已提交
119 120


121 122
static void exprTreeToBinaryImpl(SBufferWriter* bw, tExprNode* expr) {
  tbufWriteUint8(bw, expr->nodeType);
123
  
124
  if (expr->nodeType == TEXPR_VALUE_NODE) {
H
Haojun Liao 已提交
125
    SVariant* pVal = expr->pVal;
126
    
127
    tbufWriteUint32(bw, pVal->nType);
128
    if (pVal->nType == TSDB_DATA_TYPE_BINARY) {
129 130
      tbufWriteInt32(bw, pVal->nLen);
      tbufWrite(bw, pVal->pz, pVal->nLen);
131
    } else {
132
      tbufWriteInt64(bw, pVal->i);
133 134
    }
    
135
  } else if (expr->nodeType == TEXPR_COL_NODE) {
136 137 138 139 140
    SSchema* pSchema = expr->pSchema;
    tbufWriteInt16(bw, pSchema->colId);
    tbufWriteInt16(bw, pSchema->bytes);
    tbufWriteUint8(bw, pSchema->type);
    tbufWriteString(bw, pSchema->name);
141
    
142
  } else if (expr->nodeType == TEXPR_BINARYEXPR_NODE) {
143 144 145
    tbufWriteUint8(bw, expr->_node.optr);
    exprTreeToBinaryImpl(bw, expr->_node.pLeft);
    exprTreeToBinaryImpl(bw, expr->_node.pRight);
146 147 148
  }
}

149 150 151
void exprTreeToBinary(SBufferWriter* bw, tExprNode* expr) {
  if (expr != NULL) {
    exprTreeToBinaryImpl(bw, expr);
152
  }
153 154 155 156 157 158
}

// TODO: these three functions should be made global
static void* exception_calloc(size_t nmemb, size_t size) {
  void* p = calloc(nmemb, size);
  if (p == NULL) {
159
    THROW(TSDB_CODE_QRY_OUT_OF_MEMORY);
160
  }
161 162 163 164 165 166
  return p;
}

static void* exception_malloc(size_t size) {
  void* p = malloc(size);
  if (p == NULL) {
167
    THROW(TSDB_CODE_QRY_OUT_OF_MEMORY);
168 169
  }
  return p;
170 171
}

172
static UNUSED_FUNC char* exception_strdup(const char* str) {
173 174
  char* p = strdup(str);
  if (p == NULL) {
175
    THROW(TSDB_CODE_QRY_OUT_OF_MEMORY);
176 177 178 179 180 181
  }
  return p;
}

static tExprNode* exprTreeFromBinaryImpl(SBufferReader* br) {
  int32_t anchor = CLEANUP_GET_ANCHOR();
dengyihao's avatar
TD-816  
dengyihao 已提交
182 183 184 185
  if (CLEANUP_EXCEED_LIMIT()) {
    THROW(TSDB_CODE_QRY_EXCEED_TAGS_LIMIT);
    return NULL;
  }
186 187

  tExprNode* pExpr = exception_calloc(1, sizeof(tExprNode));
H
Haojun Liao 已提交
188
  CLEANUP_PUSH_VOID_PTR_PTR(true, tExprTreeDestroy, pExpr, NULL);
189
  pExpr->nodeType = tbufReadUint8(br);
190
  
191
  if (pExpr->nodeType == TEXPR_VALUE_NODE) {
H
Haojun Liao 已提交
192
    SVariant* pVal = exception_calloc(1, sizeof(SVariant));
weixin_48148422's avatar
weixin_48148422 已提交
193
    pExpr->pVal = pVal;
194
  
195
    pVal->nType = tbufReadUint32(br);
196
    if (pVal->nType == TSDB_DATA_TYPE_BINARY) {
197
      tbufReadToBuffer(br, &pVal->nLen, sizeof(pVal->nLen));
198
      pVal->pz = calloc(1, pVal->nLen + 1);
199
      tbufReadToBuffer(br, pVal->pz, pVal->nLen);
200
    } else {
201
      pVal->i = tbufReadInt64(br);
202 203
    }
    
204
  } else if (pExpr->nodeType == TEXPR_COL_NODE) {
205
    SSchema* pSchema = exception_calloc(1, sizeof(SSchema));
weixin_48148422's avatar
weixin_48148422 已提交
206 207
    pExpr->pSchema = pSchema;

208 209 210 211
    pSchema->colId = tbufReadInt16(br);
    pSchema->bytes = tbufReadInt16(br);
    pSchema->type = tbufReadUint8(br);
    tbufReadToString(br, pSchema->name, TSDB_COL_NAME_LEN);
212
    
213
  } else if (pExpr->nodeType == TEXPR_BINARYEXPR_NODE) {
214 215 216
    pExpr->_node.optr = tbufReadUint8(br);
    pExpr->_node.pLeft = exprTreeFromBinaryImpl(br);
    pExpr->_node.pRight = exprTreeFromBinaryImpl(br);
217 218 219
    assert(pExpr->_node.pLeft != NULL && pExpr->_node.pRight != NULL);
  }
  
220
  CLEANUP_EXECUTE_TO(anchor, false);
weixin_48148422's avatar
weixin_48148422 已提交
221
  return pExpr;
222 223
}

224
tExprNode* exprTreeFromBinary(const void* data, size_t size) {
weixin_48148422's avatar
weixin_48148422 已提交
225 226 227
  if (size == 0) {
    return NULL;
  }
H
Haojun Liao 已提交
228

229 230
  SBufferReader br = tbufInitReader(data, size, false);
  return exprTreeFromBinaryImpl(&br);
231 232
}

weixin_48148422's avatar
weixin_48148422 已提交
233 234 235 236 237
tExprNode* exprTreeFromTableName(const char* tbnameCond) {
  if (!tbnameCond) {
    return NULL;
  }

238 239 240
  int32_t anchor = CLEANUP_GET_ANCHOR();

  tExprNode* expr = exception_calloc(1, sizeof(tExprNode));
H
Haojun Liao 已提交
241
  CLEANUP_PUSH_VOID_PTR_PTR(true, tExprTreeDestroy, expr, NULL);
242

243
  expr->nodeType = TEXPR_BINARYEXPR_NODE;
weixin_48148422's avatar
weixin_48148422 已提交
244

245
  tExprNode* left = exception_calloc(1, sizeof(tExprNode));
weixin_48148422's avatar
weixin_48148422 已提交
246 247
  expr->_node.pLeft = left;

248
  left->nodeType = TEXPR_COL_NODE;
249
  SSchema* pSchema = exception_calloc(1, sizeof(SSchema));
weixin_48148422's avatar
weixin_48148422 已提交
250 251
  left->pSchema = pSchema;

H
Haojun Liao 已提交
252
//  *pSchema = NULL;//*tGetTbnameColumnSchema();
weixin_48148422's avatar
weixin_48148422 已提交
253

254
  tExprNode* right = exception_calloc(1, sizeof(tExprNode));
weixin_48148422's avatar
weixin_48148422 已提交
255 256 257
  expr->_node.pRight = right;

  if (strncmp(tbnameCond, QUERY_COND_REL_PREFIX_LIKE, QUERY_COND_REL_PREFIX_LIKE_LEN) == 0) {
258
    right->nodeType = TEXPR_VALUE_NODE;
D
dapan1121 已提交
259
    expr->_node.optr = OP_TYPE_LIKE;
H
Haojun Liao 已提交
260
    SVariant* pVal = exception_calloc(1, sizeof(SVariant));
weixin_48148422's avatar
weixin_48148422 已提交
261 262
    right->pVal = pVal;
    size_t len = strlen(tbnameCond + QUERY_COND_REL_PREFIX_LIKE_LEN) + 1;
263
    pVal->pz = exception_malloc(len);
weixin_48148422's avatar
weixin_48148422 已提交
264
    memcpy(pVal->pz, tbnameCond + QUERY_COND_REL_PREFIX_LIKE_LEN, len);
265
    pVal->nType = TSDB_DATA_TYPE_BINARY;
266
    pVal->nLen = (int32_t)len;
weixin_48148422's avatar
weixin_48148422 已提交
267

268
  } else if (strncmp(tbnameCond, QUERY_COND_REL_PREFIX_MATCH, QUERY_COND_REL_PREFIX_MATCH_LEN) == 0) {
269
    right->nodeType = TEXPR_VALUE_NODE;
D
dapan1121 已提交
270
    expr->_node.optr = OP_TYPE_MATCH;
H
Haojun Liao 已提交
271
    SVariant* pVal = exception_calloc(1, sizeof(SVariant));
272 273 274 275 276 277
    right->pVal = pVal;
    size_t len = strlen(tbnameCond + QUERY_COND_REL_PREFIX_MATCH_LEN) + 1;
    pVal->pz = exception_malloc(len);
    memcpy(pVal->pz, tbnameCond + QUERY_COND_REL_PREFIX_MATCH_LEN, len);
    pVal->nType = TSDB_DATA_TYPE_BINARY;
    pVal->nLen = (int32_t)len;
278
  } else if (strncmp(tbnameCond, QUERY_COND_REL_PREFIX_NMATCH, QUERY_COND_REL_PREFIX_NMATCH_LEN) == 0) {
279
    right->nodeType = TEXPR_VALUE_NODE;
D
dapan1121 已提交
280
    expr->_node.optr = OP_TYPE_NMATCH;
H
Haojun Liao 已提交
281
    SVariant* pVal = exception_calloc(1, sizeof(SVariant));
282 283 284 285 286 287
    right->pVal = pVal;
    size_t len = strlen(tbnameCond + QUERY_COND_REL_PREFIX_NMATCH_LEN) + 1;
    pVal->pz = exception_malloc(len);
    memcpy(pVal->pz, tbnameCond + QUERY_COND_REL_PREFIX_NMATCH_LEN, len);
    pVal->nType = TSDB_DATA_TYPE_BINARY;
    pVal->nLen = (int32_t)len;
weixin_48148422's avatar
weixin_48148422 已提交
288
  } else if (strncmp(tbnameCond, QUERY_COND_REL_PREFIX_IN, QUERY_COND_REL_PREFIX_IN_LEN) == 0) {
289
    right->nodeType = TEXPR_VALUE_NODE;
D
dapan1121 已提交
290
    expr->_node.optr = OP_TYPE_IN;
H
Haojun Liao 已提交
291
    SVariant* pVal = exception_calloc(1, sizeof(SVariant));
weixin_48148422's avatar
weixin_48148422 已提交
292
    right->pVal = pVal;
W
wpan 已提交
293
    pVal->nType = TSDB_DATA_TYPE_POINTER_ARRAY;
294
    pVal->arr = taosArrayInit(2, POINTER_BYTES);
weixin_48148422's avatar
weixin_48148422 已提交
295 296 297

    const char* cond = tbnameCond + QUERY_COND_REL_PREFIX_IN_LEN;
    for (const char *e = cond; *e != 0; e++) {
298 299 300
      if (*e == TS_PATH_DELIMITER[0]) {
        cond = e + 1;
      } else if (*e == ',') {
301 302
        size_t len = e - cond;
        char* p = exception_malloc(len + VARSTR_HEADER_SIZE);
S
TD-1057  
Shengliang Guan 已提交
303
        STR_WITH_SIZE_TO_VARSTR(p, cond, (VarDataLenT)len);
weixin_48148422's avatar
weixin_48148422 已提交
304
        cond += len;
weixin_48148422's avatar
weixin_48148422 已提交
305
        taosArrayPush(pVal->arr, &p);
weixin_48148422's avatar
weixin_48148422 已提交
306 307 308 309
      }
    }

    if (*cond != 0) {
310 311 312
      size_t len = strlen(cond) + VARSTR_HEADER_SIZE;
      
      char* p = exception_malloc(len);
S
TD-1057  
Shengliang Guan 已提交
313
      STR_WITH_SIZE_TO_VARSTR(p, cond, (VarDataLenT)(len - VARSTR_HEADER_SIZE));
314
      taosArrayPush(pVal->arr, &p);
weixin_48148422's avatar
weixin_48148422 已提交
315 316
    }

317
    taosArraySortString(pVal->arr, taosArrayCompareString);
weixin_48148422's avatar
weixin_48148422 已提交
318 319
  }

320
  CLEANUP_EXECUTE_TO(anchor, false);
weixin_48148422's avatar
weixin_48148422 已提交
321
  return expr;
dengyihao's avatar
dengyihao 已提交
322
}
H
Haojun Liao 已提交
323

Y
yihaoDeng 已提交
324 325 326 327
void buildFilterSetFromBinary(void **q, const char *buf, int32_t len) {
  SBufferReader br = tbufInitReader(buf, len, false); 
  uint32_t type  = tbufReadUint32(&br);     
  SHashObj *pObj = taosHashInit(256, taosGetDefaultHashFunction(type), true, false);
328
  
H
Haojun Liao 已提交
329 330
//  taosHashSetEqualFp(pObj, taosGetDefaultEqualFunction(type));

Y
yihaoDeng 已提交
331 332 333
  int dummy = -1;
  int32_t sz = tbufReadInt32(&br);
  for (int32_t i = 0; i < sz; i++) {
334
    if (type == TSDB_DATA_TYPE_BOOL || IS_SIGNED_NUMERIC_TYPE(type)) {
335 336
      int64_t val = tbufReadInt64(&br); 
      taosHashPut(pObj, (char *)&val, sizeof(val),  &dummy, sizeof(dummy));
337 338 339 340 341
    } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
      uint64_t val = tbufReadUint64(&br); 
      taosHashPut(pObj, (char *)&val, sizeof(val),  &dummy, sizeof(dummy));
    }
    else if (type == TSDB_DATA_TYPE_TIMESTAMP) {
Y
yihaoDeng 已提交
342 343 344 345 346
      int64_t val = tbufReadInt64(&br); 
      taosHashPut(pObj, (char *)&val, sizeof(val),  &dummy, sizeof(dummy));
    } else if (type == TSDB_DATA_TYPE_DOUBLE || type == TSDB_DATA_TYPE_FLOAT) {
      double  val = tbufReadDouble(&br);
      taosHashPut(pObj, (char *)&val, sizeof(val), &dummy, sizeof(dummy));
Y
yihaoDeng 已提交
347
    } else if (type == TSDB_DATA_TYPE_BINARY) {
Y
yihaoDeng 已提交
348 349 350
      size_t  t = 0;
      const char *val = tbufReadBinary(&br, &t);
      taosHashPut(pObj, (char *)val, t, &dummy, sizeof(dummy));
Y
yihaoDeng 已提交
351
    } else if (type == TSDB_DATA_TYPE_NCHAR) {
Y
yihaoDeng 已提交
352 353 354
      size_t  t = 0;
      const char *val = tbufReadBinary(&br, &t);      
      taosHashPut(pObj, (char *)val, t, &dummy, sizeof(dummy));
Y
yihaoDeng 已提交
355 356 357 358 359
    }
  } 
  *q = (void *)pObj;
}

W
wpan 已提交
360 361 362 363 364
void convertFilterSetFromBinary(void **q, const char *buf, int32_t len, uint32_t tType) {
  SBufferReader br = tbufInitReader(buf, len, false); 
  uint32_t sType  = tbufReadUint32(&br);     
  SHashObj *pObj = taosHashInit(256, taosGetDefaultHashFunction(tType), true, false);
  
H
Haojun Liao 已提交
365
//  taosHashSetEqualFp(pObj, taosGetDefaultEqualFunction(tType));
W
wpan 已提交
366 367
  
  int dummy = -1;
H
Haojun Liao 已提交
368
  SVariant tmpVar = {0};  
W
wpan 已提交
369 370
  size_t  t = 0;
  int32_t sz = tbufReadInt32(&br);
W
wpan 已提交
371 372
  void *pvar = NULL;  
  int64_t val = 0;
W
wpan 已提交
373 374 375 376 377 378 379 380 381 382 383 384
  int32_t bufLen = 0;
  if (IS_NUMERIC_TYPE(sType)) {
    bufLen = 60;  // The maximum length of string that a number is converted to.
  } else {
    bufLen = 128;
  }

  char *tmp = calloc(1, bufLen * TSDB_NCHAR_SIZE);
    
  for (int32_t i = 0; i < sz; i++) {
    switch (sType) {
    case TSDB_DATA_TYPE_BOOL:
W
wpan 已提交
385
    case TSDB_DATA_TYPE_UTINYINT:
W
wpan 已提交
386
    case TSDB_DATA_TYPE_TINYINT: {
W
wpan 已提交
387
      *(uint8_t *)&val = (uint8_t)tbufReadInt64(&br); 
W
wpan 已提交
388 389 390 391
      t = sizeof(val);
      pvar = &val;
      break;
    }
W
wpan 已提交
392
    case TSDB_DATA_TYPE_USMALLINT:
W
wpan 已提交
393
    case TSDB_DATA_TYPE_SMALLINT: {
W
wpan 已提交
394
      *(uint16_t *)&val = (uint16_t)tbufReadInt64(&br); 
W
wpan 已提交
395 396 397 398
      t = sizeof(val);
      pvar = &val;
      break;
    }
W
wpan 已提交
399
    case TSDB_DATA_TYPE_UINT:
W
wpan 已提交
400
    case TSDB_DATA_TYPE_INT: {
W
wpan 已提交
401
      *(uint32_t *)&val = (uint32_t)tbufReadInt64(&br); 
W
wpan 已提交
402 403 404 405
      t = sizeof(val);
      pvar = &val;
      break;
    }
W
wpan 已提交
406
    case TSDB_DATA_TYPE_TIMESTAMP:
W
wpan 已提交
407
    case TSDB_DATA_TYPE_UBIGINT:
W
wpan 已提交
408
    case TSDB_DATA_TYPE_BIGINT: {
W
wpan 已提交
409
      *(uint64_t *)&val = (uint64_t)tbufReadInt64(&br); 
W
wpan 已提交
410 411 412 413 414
      t = sizeof(val);
      pvar = &val;
      break;
    }
    case TSDB_DATA_TYPE_DOUBLE: {
W
wpan 已提交
415
      *(double *)&val = tbufReadDouble(&br);
W
wpan 已提交
416 417 418 419 420
      t = sizeof(val);
      pvar = &val;
      break;
    }
    case TSDB_DATA_TYPE_FLOAT: {
W
wpan 已提交
421
      *(float *)&val = (float)tbufReadDouble(&br);
W
wpan 已提交
422 423 424 425 426
      t = sizeof(val);
      pvar = &val;
      break;
    }
    case TSDB_DATA_TYPE_BINARY: {
W
wpan 已提交
427
      pvar = (char *)tbufReadBinary(&br, &t);
W
wpan 已提交
428 429 430
      break;
    }
    case TSDB_DATA_TYPE_NCHAR: {
W
wpan 已提交
431
      pvar = (char *)tbufReadBinary(&br, &t);      
W
wpan 已提交
432 433 434 435 436 437 438 439
      break;
    }
    default:
      taosHashCleanup(pObj);
      *q = NULL;
      return;
    }
    
H
Haojun Liao 已提交
440
    taosVariantCreateFromBinary(&tmpVar, (char *)pvar, t, sType);
W
wpan 已提交
441 442 443

    if (bufLen < t) {
      tmp = realloc(tmp, t * TSDB_NCHAR_SIZE);
W
wpan 已提交
444
      bufLen = (int32_t)t;
W
wpan 已提交
445 446 447 448
    }

    switch (tType) {
      case TSDB_DATA_TYPE_BOOL:
W
wpan 已提交
449
      case TSDB_DATA_TYPE_UTINYINT:
W
wpan 已提交
450
      case TSDB_DATA_TYPE_TINYINT: {
H
Haojun Liao 已提交
451
        if (taosVariantDump(&tmpVar, (char *)&val, tType, false)) {
W
wpan 已提交
452 453 454 455 456 457
          goto err_ret;
        }
        pvar = &val;
        t = sizeof(val);
        break;
      }
W
wpan 已提交
458
      case TSDB_DATA_TYPE_USMALLINT:
W
wpan 已提交
459
      case TSDB_DATA_TYPE_SMALLINT: {
H
Haojun Liao 已提交
460
        if (taosVariantDump(&tmpVar, (char *)&val, tType, false)) {
W
wpan 已提交
461 462 463 464 465 466
          goto err_ret;
        }
        pvar = &val;
        t = sizeof(val);
        break;
      }
W
wpan 已提交
467
      case TSDB_DATA_TYPE_UINT:
W
wpan 已提交
468
      case TSDB_DATA_TYPE_INT: {
H
Haojun Liao 已提交
469
        if (taosVariantDump(&tmpVar, (char *)&val, tType, false)) {
W
wpan 已提交
470 471 472 473 474 475
          goto err_ret;
        }
        pvar = &val;
        t = sizeof(val);
        break;
      }
W
wpan 已提交
476
      case TSDB_DATA_TYPE_TIMESTAMP:
W
wpan 已提交
477
      case TSDB_DATA_TYPE_UBIGINT:
W
wpan 已提交
478
      case TSDB_DATA_TYPE_BIGINT: {
H
Haojun Liao 已提交
479
        if (taosVariantDump(&tmpVar, (char *)&val, tType, false)) {
W
wpan 已提交
480 481 482 483 484 485 486
          goto err_ret;
        }
        pvar = &val;
        t = sizeof(val);
        break;
      }
      case TSDB_DATA_TYPE_DOUBLE: {
H
Haojun Liao 已提交
487
        if (taosVariantDump(&tmpVar, (char *)&val, tType, false)) {
W
wpan 已提交
488 489 490 491 492 493 494
          goto err_ret;
        }
        pvar = &val;
        t = sizeof(val);
        break;
      }
      case TSDB_DATA_TYPE_FLOAT: {
H
Haojun Liao 已提交
495
        if (taosVariantDump(&tmpVar, (char *)&val, tType, false)) {
W
wpan 已提交
496 497 498 499 500 501 502
          goto err_ret;
        }
        pvar = &val;
        t = sizeof(val);
        break;
      }
      case TSDB_DATA_TYPE_BINARY: {
H
Haojun Liao 已提交
503
        if (taosVariantDump(&tmpVar, tmp, tType, true)) {
W
wpan 已提交
504 505 506 507 508 509 510
          goto err_ret;
        }
        t = varDataLen(tmp);
        pvar = varDataVal(tmp);
        break;
      }
      case TSDB_DATA_TYPE_NCHAR: {
H
Haojun Liao 已提交
511
        if (taosVariantDump(&tmpVar, tmp, tType, true)) {
W
wpan 已提交
512 513 514 515 516 517 518 519 520 521 522
          goto err_ret;
        }
        t = varDataLen(tmp);
        pvar = varDataVal(tmp);        
        break;
      }
      default:
        goto err_ret;
    }
    
    taosHashPut(pObj, (char *)pvar, t,  &dummy, sizeof(dummy));
H
Haojun Liao 已提交
523
    taosVariantDestroy(&tmpVar);
W
wpan 已提交
524
    memset(&tmpVar, 0, sizeof(tmpVar));
W
wpan 已提交
525 526 527 528 529 530
  } 

  *q = (void *)pObj;
  pObj = NULL;
  
err_ret:  
H
Haojun Liao 已提交
531
  taosVariantDestroy(&tmpVar);
W
wpan 已提交
532 533 534 535
  taosHashCleanup(pObj);
  tfree(tmp);
}

H
Haojun Liao 已提交
536 537
tExprNode* exprdup(tExprNode* pNode) {
  if (pNode == NULL) {
H
Haojun Liao 已提交
538 539 540
    return NULL;
  }

H
Haojun Liao 已提交
541
  tExprNode* pCloned = calloc(1, sizeof(tExprNode));
542
  if (pNode->nodeType == TEXPR_BINARYEXPR_NODE) {
H
Haojun Liao 已提交
543 544 545 546 547 548
    tExprNode* pLeft  = exprdup(pNode->_node.pLeft);
    tExprNode* pRight = exprdup(pNode->_node.pRight);

    pCloned->_node.pLeft  = pLeft;
    pCloned->_node.pRight = pRight;
    pCloned->_node.optr  = pNode->_node.optr;
549
  } else if (pNode->nodeType == TEXPR_VALUE_NODE) {
H
Haojun Liao 已提交
550
    pCloned->pVal = calloc(1, sizeof(SVariant));
H
Haojun Liao 已提交
551
    taosVariantAssign(pCloned->pVal, pNode->pVal);
552
  } else if (pNode->nodeType == TEXPR_COL_NODE) {
H
Haojun Liao 已提交
553 554
    pCloned->pSchema = calloc(1, sizeof(SSchema));
    *pCloned->pSchema = *pNode->pSchema;
555 556 557 558 559 560 561 562 563
  } else if (pNode->nodeType == TEXPR_FUNCTION_NODE) {
    strcpy(pCloned->_function.functionName, pNode->_function.functionName);

    int32_t num = pNode->_function.num;
    pCloned->_function.num = num;
    pCloned->_function.pChild = calloc(num, POINTER_BYTES);
    for(int32_t i = 0; i < num; ++i) {
      pCloned->_function.pChild[i] = exprdup(pNode->_function.pChild[i]);
    }
H
Haojun Liao 已提交
564 565
  }

H
Haojun Liao 已提交
566 567
  pCloned->nodeType = pNode->nodeType;
  return pCloned;
H
Haojun Liao 已提交
568 569
}