Merge branch '3.0' of https://github.com/taosdata/TDengine into feature/tdb

include/client/taos.h

@@ -124,8 +124,25 @@ typedef struct TAOS_MULTI_BIND {
   int       num;
 } TAOS_MULTI_BIND;
 
+typedef enum {
+  SET_CONF_RET_SUCC = 0,
+  SET_CONF_RET_ERR_PART = -1,
+  SET_CONF_RET_ERR_INNER = -2,
+  SET_CONF_RET_ERR_JSON_INVALID = -3,
+  SET_CONF_RET_ERR_JSON_PARSE = -4,
+  SET_CONF_RET_ERR_ONLY_ONCE = -5,
+  SET_CONF_RET_ERR_TOO_LONG = -6
+} SET_CONF_RET_CODE;
+
+#define RET_MSG_LENGTH 1024
+typedef struct setConfRet {
+  SET_CONF_RET_CODE retCode;
+  char   retMsg[RET_MSG_LENGTH];
+} setConfRet;
+
 DLL_EXPORT void  taos_cleanup(void);
 DLL_EXPORT int   taos_options(TSDB_OPTION option, const void *arg, ...);
+DLL_EXPORT setConfRet   taos_set_config(const char *config);
 DLL_EXPORT TAOS *taos_connect(const char *ip, const char *user, const char *pass, const char *db, uint16_t port);
 DLL_EXPORT TAOS *taos_connect_l(const char *ip, int ipLen, const char *user, int userLen, const char *pass, int passLen,
                                 const char *db, int dbLen, uint16_t port);
@@ -168,10 +185,13 @@ DLL_EXPORT int         taos_select_db(TAOS *taos, const char *db);
 DLL_EXPORT int         taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields);
 DLL_EXPORT void        taos_stop_query(TAOS_RES *res);
 DLL_EXPORT bool        taos_is_null(TAOS_RES *res, int32_t row, int32_t col);
+DLL_EXPORT bool        taos_is_update_query(TAOS_RES *res);
 DLL_EXPORT int         taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows);
 DLL_EXPORT int         taos_validate_sql(TAOS *taos, const char *sql);
+DLL_EXPORT void taos_reset_current_db(TAOS *taos);
 
 DLL_EXPORT int *taos_fetch_lengths(TAOS_RES *res);
+DLL_EXPORT TAOS_ROW *taos_result_block(TAOS_RES *res);
 
 DLL_EXPORT const char *taos_get_server_info(TAOS *taos);
 DLL_EXPORT const char *taos_get_client_info();

include/libs/nodes/plannodes.h

@@ -197,7 +197,6 @@ typedef struct STableScanPhysiNode {
   SScanPhysiNode scan;
   uint8_t scanFlag;         // denotes reversed scan of data or not
   STimeWindow scanRange;
-  SNode* pScanConditions;
 } STableScanPhysiNode;
 
 typedef STableScanPhysiNode STableSeqScanPhysiNode;
@@ -252,6 +251,7 @@ typedef struct SIntervalPhysiNode {
   int64_t    sliding;
   int8_t     intervalUnit;
   int8_t     slidingUnit;
+  uint8_t precision;
   SFillNode* pFill;
 } SIntervalPhysiNode;
 

source/client/src/clientEnv.c

@@ -200,6 +200,9 @@ static void doDestroyRequest(void *p) {
     taosArrayDestroy(pRequest->body.showInfo.pArray);
   }
 
+  taosArrayDestroy(pRequest->tableList);
+  taosArrayDestroy(pRequest->dbList);
+
   deregisterRequest(pRequest);
   taosMemoryFreeClear(pRequest);
 }

source/client/src/clientMain.c

@@ -71,6 +71,12 @@ void taos_cleanup(void) {
   tscInfo("all local resources released");
 }
 
+setConfRet   taos_set_config(const char *config) {
+  // TODO
+  setConfRet ret = {SET_CONF_RET_SUCC, {0}};
+  return ret;
+}
+
 TAOS *taos_connect(const char *ip, const char *user, const char *pass, const char *db, uint16_t port) {
   tscDebug("try to connect to %s:%u, user:%s db:%s", ip, port, user, db);
   if (user == NULL) {
@@ -257,6 +263,11 @@ int *taos_fetch_lengths(TAOS_RES *res) {
   return ((SRequestObj *)res)->body.resInfo.length;
 }
 
+TAOS_ROW *taos_result_block(TAOS_RES *res) {
+  // TODO
+  return NULL;
+}
+
 // todo intergrate with tDataTypes
 const char *taos_data_type(int type) {
   switch (type) {
@@ -353,6 +364,11 @@ bool taos_is_null(TAOS_RES *res, int32_t row, int32_t col) {
   return colDataIsNull_f(pCol->nullbitmap, row);
 }
 
+bool taos_is_update_query(TAOS_RES *res) {
+  // TODO
+  return true;
+}
+
 int taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows) {
   if (res == NULL) {
     return 0;
@@ -376,6 +392,11 @@ int taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows) {
 
 int taos_validate_sql(TAOS *taos, const char *sql) { return true; }
 
+void taos_reset_current_db(TAOS *taos) {
+  // TODO
+  return;
+}
+
 const char *taos_get_server_info(TAOS *taos) {
   if (taos == NULL) {
     return NULL;

source/dnode/vnode/CMakeLists.txt

@@ -46,14 +46,11 @@ target_link_libraries(
     PUBLIC stream
     PUBLIC qworker
     PUBLIC sync
+    # TODO: get rid of BDB
+    PUBLIC bdb
+    PUBLIC tdb
 )
 
-if(${META_DB_IMPL} STREQUAL "BDB")
-    target_link_libraries(vnode PUBLIC bdb)
-elseif(${META_DB_IMPL} STREQUAL "TDB")
-    target_link_libraries(vnode PUBLIC tdb)
-endif()
-
 if(${BUILD_TEST})
     add_subdirectory(test)
 endif(${BUILD_TEST})

source/dnode/vnode/src/meta/metaTDBImpl.c

@@ -15,131 +15,637 @@
 
 #include "metaDef.h"
 
-#include "tdb.h"
+#include "tdbInt.h"
 
 struct SMetaDB {
   TENV *pEnv;
-  TDB * pTbDB;
-  TDB * pSchemaDB;
-  TDB * pNameIdx;
-  TDB * pStbIdx;
-  TDB * pNtbIdx;
-  TDB * pCtbIdx;
-  // tag index hash table
-  // suid+colid --> TDB *
-  struct {
-  } tagIdxHt;
+  TDB  *pTbDB;
+  TDB  *pSchemaDB;
+  TDB  *pNameIdx;
+  TDB  *pStbIdx;
+  TDB  *pNtbIdx;
+  TDB  *pCtbIdx;
 };
 
-#define A(op, flag)                 \
-  do {                              \
-    if ((ret = op) != 0) goto flag; \
-  } while (0)
+typedef struct __attribute__((__packed__)) {
+  tb_uid_t uid;
+  int32_t  sver;
+} SSchemaDbKey;
+
+typedef struct {
+  char    *name;
+  tb_uid_t uid;
+} SNameIdxKey;
+
+typedef struct {
+  tb_uid_t suid;
+  tb_uid_t uid;
+} SCtbIdxKey;
+
+static int   metaEncodeTbInfo(void **buf, STbCfg *pTbCfg);
+static void *metaDecodeTbInfo(void *buf, STbCfg *pTbCfg);
+static int   metaEncodeSchema(void **buf, SSchemaWrapper *pSW);
+static void *metaDecodeSchema(void *buf, SSchemaWrapper *pSW);
+
+static inline int metaUidCmpr(const void *arg1, int len1, const void *arg2, int len2) {
+  tb_uid_t uid1, uid2;
+
+  ASSERT(len1 == sizeof(tb_uid_t));
+  ASSERT(len2 == sizeof(tb_uid_t));
+
+  uid1 = ((tb_uid_t *)arg1)[0];
+  uid2 = ((tb_uid_t *)arg2)[0];
+
+  if (uid1 < uid2) {
+    return -1;
+  }
+  if (uid1 == uid2) {
+    return 0;
+  } else {
+    return 1;
+  }
+}
+
+static inline int metaSchemaKeyCmpr(const void *arg1, int len1, const void *arg2, int len2) {
+  int           c;
+  SSchemaDbKey *pKey1 = (SSchemaDbKey *)arg1;
+  SSchemaDbKey *pKey2 = (SSchemaDbKey *)arg2;
+
+  c = metaUidCmpr(arg1, sizeof(tb_uid_t), arg2, sizeof(tb_uid_t));
+  if (c) return c;
+
+  if (pKey1->sver > pKey2->sver) {
+    return 1;
+  } else if (pKey1->sver == pKey2->sver) {
+    return 0;
+  } else {
+    return -1;
+  }
+}
+
+static inline int metaNameIdxCmpr(const void *arg1, int len1, const void *arg2, int len2) {
+  return strcmp((char *)arg1, (char *)arg2);
+}
+
+static inline int metaCtbIdxCmpr(const void *arg1, int len1, const void *arg2, int len2) {
+  int         c;
+  SCtbIdxKey *pKey1 = (SCtbIdxKey *)arg1;
+  SCtbIdxKey *pKey2 = (SCtbIdxKey *)arg2;
+
+  c = metaUidCmpr(arg1, sizeof(tb_uid_t), arg2, sizeof(tb_uid_t));
+  if (c) return c;
+
+  return metaUidCmpr(&pKey1->uid, sizeof(tb_uid_t), &pKey2->uid, sizeof(tb_uid_t));
+}
 
 int metaOpenDB(SMeta *pMeta) {
-  SMetaDB *pDb;
-  TENV *   pEnv;
-  TDB *    pTbDB;
-  TDB *    pSchemaDB;
-  TDB *    pNameIdx;
-  TDB *    pStbIdx;
-  TDB *    pNtbIdx;
-  TDB *    pCtbIdx;
+  SMetaDB *pMetaDb;
   int      ret;
 
-  pDb = (SMetaDB *)taosMemoryCalloc(1, sizeof(*pDb));
-  if (pDb == NULL) {
+  // allocate DB handle
+  pMetaDb = taosMemoryCalloc(1, sizeof(*pMetaDb));
+  if (pMetaDb == NULL) {
+    // TODO
+    ASSERT(0);
     return -1;
   }
 
-  // Create and open the ENV
-  A((tdbEnvCreate(&pEnv)), _err);
-#if 0
-  // Set options of the environment
-  A(tdbEnvSetPageSize(pEnv, 8192), _err);
-  A(tdbEnvSetCacheSize(pEnv, 16 * 1024 * 1024), _err);
-#endif
-  A((tdbEnvOpen(&pEnv)), _err);
+  // open the ENV
+  ret = tdbEnvOpen(pMeta->path, 4096, 256, &(pMetaDb->pEnv));
+  if (ret < 0) {
+    // TODO
+    ASSERT(0);
+    return -1;
+  }
 
-  // Create and open each DB
-  A(tdbCreate(&pTbDB), _err);
-  A(tdbOpen(&pTbDB, "table.db", NULL, pEnv), _err);
+  // open table DB
+  ret = tdbDbOpen("table.db", sizeof(tb_uid_t), TDB_VARIANT_LEN, metaUidCmpr, pMetaDb->pEnv, &(pMetaDb->pTbDB));
+  if (ret < 0) {
+    // TODO
+    ASSERT(0);
+    return -1;
+  }
 
-  A(tdbCreate(&pSchemaDB), _err);
-  A(tdbOpen(&pSchemaDB, "schema.db", NULL, pEnv), _err);
+  // open schema DB
+  ret = tdbDbOpen("schema.db", sizeof(SSchemaDbKey), TDB_VARIANT_LEN, metaSchemaKeyCmpr, pMetaDb->pEnv,
+                  &(pMetaDb->pSchemaDB));
+  if (ret < 0) {
+    // TODO
+    ASSERT(0);
+    return -1;
+  }
 
-  A(tdbCreate(&pNameIdx), _err);
-  A(tdbOpen(&pNameIdx, "name.db", NULL, pEnv), _err);
-  // tdbAssociate();
+  ret = tdbDbOpen("name.idx", TDB_VARIANT_LEN, 0, metaNameIdxCmpr, pMetaDb->pEnv, &(pMetaDb->pNameIdx));
+  if (ret < 0) {
+    // TODO
+    ASSERT(0);
+    return -1;
+  }
 
-  pDb->pEnv = pEnv;
-  pDb->pTbDB = pTbDB;
-  pDb->pSchemaDB = pSchemaDB;
-  pMeta->pDB = pDb;
-  return 0;
+  ret = tdbDbOpen("stb.idx", sizeof(tb_uid_t), 0, metaUidCmpr, pMetaDb->pEnv, &(pMetaDb->pStbIdx));
+  if (ret < 0) {
+    // TODO
+    ASSERT(0);
+    return -1;
+  }
+
+  ret = tdbDbOpen("ntb.idx", sizeof(tb_uid_t), 0, metaUidCmpr, pMetaDb->pEnv, &(pMetaDb->pNtbIdx));
+  if (ret < 0) {
+    // TODO
+    ASSERT(0);
+    return -1;
+  }
 
-_err:
-  return -1;
+  ret = tdbDbOpen("ctb.idx", sizeof(SCtbIdxKey), 0, metaCtbIdxCmpr, pMetaDb->pEnv, &(pMetaDb->pCtbIdx));
+  if (ret < 0) {
+    // TODO
+    ASSERT(0);
+    return -1;
+  }
+
+  pMeta->pDB = pMetaDb;
+  return 0;
 }
 
 void metaCloseDB(SMeta *pMeta) {
-  // TODO
+  if (pMeta->pDB) {
+    tdbDbClose(pMeta->pDB->pCtbIdx);
+    tdbDbClose(pMeta->pDB->pNtbIdx);
+    tdbDbClose(pMeta->pDB->pStbIdx);
+    tdbDbClose(pMeta->pDB->pNameIdx);
+    tdbDbClose(pMeta->pDB->pSchemaDB);
+    tdbDbClose(pMeta->pDB->pTbDB);
+    taosMemoryFree(pMeta->pDB);
+  }
 }
 
 int metaSaveTableToDB(SMeta *pMeta, STbCfg *pTbCfg) {
-  // TODO
+  tb_uid_t       uid;
+  SMetaDB       *pMetaDb;
+  void          *pKey;
+  void          *pVal;
+  int            kLen;
+  int            vLen;
+  int            ret;
+  char           buf[512];
+  void          *pBuf;
+  SCtbIdxKey     ctbIdxKey;
+  SSchemaDbKey   schemaDbKey;
+  SSchemaWrapper schemaWrapper;
+
+  pMetaDb = pMeta->pDB;
+
+  // TODO: make this operation pre-process
+  if (pTbCfg->type == META_SUPER_TABLE) {
+    uid = pTbCfg->stbCfg.suid;
+  } else {
+    uid = metaGenerateUid(pMeta);
+  }
+
+  // save to table.db
+  pKey = &uid;
+  kLen = sizeof(uid);
+  pVal = pBuf = buf;
+  metaEncodeTbInfo(&pBuf, pTbCfg);
+  vLen = POINTER_DISTANCE(pBuf, buf);
+  ret = tdbDbInsert(pMetaDb->pTbDB, pKey, kLen, pVal, vLen);
+  if (ret < 0) {
+    return -1;
+  }
+
+  // save to schema.db for META_SUPER_TABLE and META_NORMAL_TABLE
+  if (pTbCfg->type != META_CHILD_TABLE) {
+    schemaDbKey.uid = uid;
+    schemaDbKey.sver = 0;  // TODO
+    pKey = &schemaDbKey;
+    kLen = sizeof(schemaDbKey);
+
+    if (pTbCfg->type == META_SUPER_TABLE) {
+      schemaWrapper.nCols = pTbCfg->stbCfg.nCols;
+      schemaWrapper.pSchema = pTbCfg->stbCfg.pSchema;
+    } else {
+      schemaWrapper.nCols = pTbCfg->ntbCfg.nCols;
+      schemaWrapper.pSchema = pTbCfg->ntbCfg.pSchema;
+    }
+    pVal = pBuf = buf;
+    metaEncodeSchema(&pBuf, &schemaWrapper);
+    vLen = POINTER_DISTANCE(pBuf, buf);
+    ret = tdbDbInsert(pMetaDb->pSchemaDB, pKey, kLen, pVal, vLen);
+    if (ret < 0) {
+      return -1;
+    }
+  }
+
+  // update name.idx
+  int nameLen = strlen(pTbCfg->name);
+  memcpy(buf, pTbCfg->name, nameLen + 1);
+  ((tb_uid_t *)(buf + nameLen + 1))[0] = uid;
+  pKey = buf;
+  kLen = nameLen + 1 + sizeof(uid);
+  pVal = NULL;
+  vLen = 0;
+  ret = tdbDbInsert(pMetaDb->pNameIdx, pKey, kLen, pVal, vLen);
+  if (ret < 0) {
+    return -1;
+  }
+
+  // update other index
+  if (pTbCfg->type == META_SUPER_TABLE) {
+    pKey = &uid;
+    kLen = sizeof(uid);
+    pVal = NULL;
+    vLen = 0;
+    ret = tdbDbInsert(pMetaDb->pStbIdx, pKey, kLen, pVal, vLen);
+    if (ret < 0) {
+      return -1;
+    }
+  } else if (pTbCfg->type == META_CHILD_TABLE) {
+    ctbIdxKey.suid = pTbCfg->ctbCfg.suid;
+    ctbIdxKey.uid = uid;
+    pKey = &ctbIdxKey;
+    kLen = sizeof(ctbIdxKey);
+    pVal = NULL;
+    vLen = 0;
+    ret = tdbDbInsert(pMetaDb->pCtbIdx, pKey, kLen, pVal, vLen);
+    if (ret < 0) {
+      return -1;
+    }
+  } else if (pTbCfg->type == META_NORMAL_TABLE) {
+    pKey = &uid;
+    kLen = sizeof(uid);
+    pVal = NULL;
+    vLen = 0;
+    ret = tdbDbInsert(pMetaDb->pNtbIdx, pKey, kLen, pVal, vLen);
+    if (ret < 0) {
+      return -1;
+    }
+  }
+
   return 0;
 }
 
 int metaRemoveTableFromDb(SMeta *pMeta, tb_uid_t uid) {
   // TODO
+  ASSERT(0);
   return 0;
 }
 
 STbCfg *metaGetTbInfoByUid(SMeta *pMeta, tb_uid_t uid) {
-  // TODO
-  return NULL;
+  int      ret;
+  SMetaDB *pMetaDb = pMeta->pDB;
+  void    *pKey;
+  void    *pVal;
+  int      kLen;
+  int      vLen;
+  STbCfg  *pTbCfg;
+
+  // Fetch
+  pKey = &uid;
+  kLen = sizeof(uid);
+  pVal = NULL;
+  ret = tdbDbGet(pMetaDb->pTbDB, pKey, kLen, &pVal, &vLen);
+  if (ret < 0) {
+    return NULL;
+  }
+
+  // Decode
+  pTbCfg = taosMemoryMalloc(sizeof(*pTbCfg));
+  metaDecodeTbInfo(pVal, pTbCfg);
+
+  TDB_FREE(pVal);
+
+  return pTbCfg;
 }
 
 STbCfg *metaGetTbInfoByName(SMeta *pMeta, char *tbname, tb_uid_t *uid) {
-  // TODO
-  return NULL;
+  void *pKey;
+  void *pVal;
+  void *ppKey;
+  int   pkLen;
+  int   kLen;
+  int   vLen;
+  int   ret;
+
+  pKey = tbname;
+  kLen = strlen(tbname) + 1;
+  pVal = NULL;
+  ppKey = NULL;
+  ret = tdbDbPGet(pMeta->pDB->pNameIdx, pKey, kLen, &ppKey, &pkLen, &pVal, &vLen);
+  if (ret < 0) {
+    return NULL;
+  }
+
+  ASSERT(pkLen == kLen + sizeof(uid));
+
+  *uid = *(tb_uid_t *)POINTER_SHIFT(ppKey, kLen);
+  TDB_FREE(ppKey);
+  TDB_FREE(pVal);
+
+  return metaGetTbInfoByUid(pMeta, *uid);
 }
 
 SSchemaWrapper *metaGetTableSchema(SMeta *pMeta, tb_uid_t uid, int32_t sver, bool isinline) {
-  // TODO
-  return NULL;
+  void           *pKey;
+  void           *pVal;
+  int             kLen;
+  int             vLen;
+  int             ret;
+  SSchemaDbKey    schemaDbKey;
+  SSchemaWrapper *pSchemaWrapper;
+  void           *pBuf;
+
+  // fetch
+  schemaDbKey.uid = uid;
+  schemaDbKey.sver = sver;
+  pKey = &schemaDbKey;
+  kLen = sizeof(schemaDbKey);
+  pVal = NULL;
+  ret = tdbDbGet(pMeta->pDB->pSchemaDB, pKey, kLen, &pVal, &vLen);
+  if (ret < 0) {
+    return NULL;
+  }
+
+  // decode
+  pBuf = pVal;
+  pSchemaWrapper = taosMemoryMalloc(sizeof(*pSchemaWrapper));
+  metaDecodeSchema(pBuf, pSchemaWrapper);
+
+  TDB_FREE(pVal);
+
+  return pSchemaWrapper;
 }
 
 STSchema *metaGetTbTSchema(SMeta *pMeta, tb_uid_t uid, int32_t sver) {
-  // TODO
-  return NULL;
+  tb_uid_t        quid;
+  SSchemaWrapper *pSW;
+  STSchemaBuilder sb;
+  SSchema        *pSchema;
+  STSchema       *pTSchema;
+  STbCfg         *pTbCfg;
+
+  pTbCfg = metaGetTbInfoByUid(pMeta, uid);
+  if (pTbCfg->type == META_CHILD_TABLE) {
+    quid = pTbCfg->ctbCfg.suid;
+  } else {
+    quid = uid;
+  }
+
+  pSW = metaGetTableSchema(pMeta, quid, sver, true);
+  if (pSW == NULL) {
+    return NULL;
+  }
+
+  tdInitTSchemaBuilder(&sb, 0);
+  for (int i = 0; i < pSW->nCols; i++) {
+    pSchema = pSW->pSchema + i;
+    tdAddColToSchema(&sb, pSchema->type, pSchema->colId, pSchema->bytes);
+  }
+  pTSchema = tdGetSchemaFromBuilder(&sb);
+  tdDestroyTSchemaBuilder(&sb);
+
+  return pTSchema;
 }
 
+struct SMTbCursor {
+  TDBC *pDbc;
+};
+
 SMTbCursor *metaOpenTbCursor(SMeta *pMeta) {
-  // TODO
-  return NULL;
+  SMTbCursor *pTbCur = NULL;
+  SMetaDB    *pDB = pMeta->pDB;
+
+  pTbCur = (SMTbCursor *)taosMemoryCalloc(1, sizeof(*pTbCur));
+  if (pTbCur == NULL) {
+    return NULL;
+  }
+
+  tdbDbcOpen(pDB->pTbDB, &pTbCur->pDbc);
+
+  return pTbCur;
 }
 
 void metaCloseTbCursor(SMTbCursor *pTbCur) {
-  // TODO
+  if (pTbCur) {
+    if (pTbCur->pDbc) {
+      tdbDbcClose(pTbCur->pDbc);
+    }
+    taosMemoryFree(pTbCur);
+  }
 }
 
 char *metaTbCursorNext(SMTbCursor *pTbCur) {
-  // TODO
+  void  *pKey = NULL;
+  void  *pVal = NULL;
+  int    kLen;
+  int    vLen;
+  int    ret;
+  void  *pBuf;
+  STbCfg tbCfg;
+
+  for (;;) {
+    ret = tdbDbNext(pTbCur->pDbc, &pKey, &kLen, &pVal, &vLen);
+    if (ret < 0) break;
+    pBuf = pVal;
+    metaDecodeTbInfo(pBuf, &tbCfg);
+    if (tbCfg.type == META_SUPER_TABLE) {
+      taosMemoryFree(tbCfg.name);
+      taosMemoryFree(tbCfg.stbCfg.pTagSchema);
+      continue;
+      ;
+    } else if (tbCfg.type == META_CHILD_TABLE) {
+      kvRowFree(tbCfg.ctbCfg.pTag);
+    }
+
+    return tbCfg.name;
+  }
+
   return NULL;
 }
 
+struct SMCtbCursor {
+  TDBC    *pCur;
+  tb_uid_t suid;
+  void    *pKey;
+  void    *pVal;
+  int      kLen;
+  int      vLen;
+};
+
 SMCtbCursor *metaOpenCtbCursor(SMeta *pMeta, tb_uid_t uid) {
+  SMCtbCursor *pCtbCur = NULL;
+  SMetaDB     *pDB = pMeta->pDB;
+  int          ret;
+
+  pCtbCur = (SMCtbCursor *)taosMemoryCalloc(1, sizeof(*pCtbCur));
+  if (pCtbCur == NULL) {
+    return NULL;
+  }
+
+  pCtbCur->suid = uid;
+  ret = tdbDbcOpen(pDB->pCtbIdx, &pCtbCur->pCur);
+  if (ret < 0) {
+    taosMemoryFree(pCtbCur);
+    return NULL;
+  }
+
+  // TODO: move the cursor to the suid there
+
+  return pCtbCur;
+}
+
+void metaCloseCtbCurosr(SMCtbCursor *pCtbCur) {
+  if (pCtbCur) {
+    if (pCtbCur->pCur) {
+      tdbDbcClose(pCtbCur->pCur);
+
+      TDB_FREE(pCtbCur->pKey);
+      TDB_FREE(pCtbCur->pVal);
+    }
+
+    taosMemoryFree(pCtbCur);
+  }
+}
+
+tb_uid_t metaCtbCursorNext(SMCtbCursor *pCtbCur) {
+  int         ret;
+  SCtbIdxKey *pCtbIdxKey;
+
+  ret = tdbDbNext(pCtbCur->pCur, &pCtbCur->pKey, &pCtbCur->kLen, &pCtbCur->pVal, &pCtbCur->vLen);
+  if (ret < 0) {
+    return 0;
+  }
+
+  pCtbIdxKey = pCtbCur->pVal;
+
+  return pCtbIdxKey->uid;
+}
+
+int metaGetTbNum(SMeta *pMeta) {
+  // TODO
+  // ASSERT(0);
+  return 0;
+}
+
+STSmaWrapper *metaGetSmaInfoByTable(SMeta *pMeta, tb_uid_t uid) {
   // TODO
+  ASSERT(0);
   return NULL;
 }
 
-void metaCloseCtbCurosr(SMCtbCursor *pCtbCur) {
+int metaRemoveSmaFromDb(SMeta *pMeta, int64_t indexUid) {
   // TODO
+  ASSERT(0);
+  return 0;
 }
 
-tb_uid_t metaCtbCursorNext(SMCtbCursor *pCtbCur) {
+int metaSaveSmaToDB(SMeta *pMeta, STSma *pSmaCfg) {
   // TODO
+  ASSERT(0);
   return 0;
-}
\ No newline at end of file
+}
+
+STSma *metaGetSmaInfoByIndex(SMeta *pMeta, int64_t indexUid) {
+  // TODO
+  ASSERT(0);
+  return NULL;
+}
+
+const char *metaSmaCursorNext(SMSmaCursor *pCur) {
+  // TODO
+  ASSERT(0);
+  return NULL;
+}
+
+void metaCloseSmaCurosr(SMSmaCursor *pCur) {
+  // TODO
+  ASSERT(0);
+}
+
+SArray *metaGetSmaTbUids(SMeta *pMeta, bool isDup) {
+  // TODO
+  ASSERT(0);
+  return NULL;
+}
+
+SMSmaCursor *metaOpenSmaCursor(SMeta *pMeta, tb_uid_t uid) {
+  // TODO
+  ASSERT(0);
+  return NULL;
+}
+
+static int metaEncodeSchema(void **buf, SSchemaWrapper *pSW) {
+  int      tlen = 0;
+  SSchema *pSchema;
+
+  tlen += taosEncodeFixedU32(buf, pSW->nCols);
+  for (int i = 0; i < pSW->nCols; i++) {
+    pSchema = pSW->pSchema + i;
+    tlen += taosEncodeFixedI8(buf, pSchema->type);
+    tlen += taosEncodeFixedI16(buf, pSchema->colId);
+    tlen += taosEncodeFixedI32(buf, pSchema->bytes);
+    tlen += taosEncodeString(buf, pSchema->name);
+  }
+
+  return tlen;
+}
+
+static void *metaDecodeSchema(void *buf, SSchemaWrapper *pSW) {
+  SSchema *pSchema;
+
+  buf = taosDecodeFixedU32(buf, &pSW->nCols);
+  pSW->pSchema = (SSchema *)taosMemoryMalloc(sizeof(SSchema) * pSW->nCols);
+  for (int i = 0; i < pSW->nCols; i++) {
+    pSchema = pSW->pSchema + i;
+    buf = taosDecodeFixedI8(buf, &pSchema->type);
+    buf = taosDecodeFixedI16(buf, &pSchema->colId);
+    buf = taosDecodeFixedI32(buf, &pSchema->bytes);
+    buf = taosDecodeStringTo(buf, pSchema->name);
+  }
+
+  return buf;
+}
+
+static int metaEncodeTbInfo(void **buf, STbCfg *pTbCfg) {
+  int tsize = 0;
+
+  tsize += taosEncodeString(buf, pTbCfg->name);
+  tsize += taosEncodeFixedU32(buf, pTbCfg->ttl);
+  tsize += taosEncodeFixedU32(buf, pTbCfg->keep);
+  tsize += taosEncodeFixedU8(buf, pTbCfg->info);
+
+  if (pTbCfg->type == META_SUPER_TABLE) {
+    SSchemaWrapper sw = {.nCols = pTbCfg->stbCfg.nTagCols, .pSchema = pTbCfg->stbCfg.pTagSchema};
+    tsize += metaEncodeSchema(buf, &sw);
+  } else if (pTbCfg->type == META_CHILD_TABLE) {
+    tsize += taosEncodeFixedU64(buf, pTbCfg->ctbCfg.suid);
+    tsize += tdEncodeKVRow(buf, pTbCfg->ctbCfg.pTag);
+  } else if (pTbCfg->type == META_NORMAL_TABLE) {
+    // TODO
+  } else {
+    ASSERT(0);
+  }
+
+  return tsize;
+}
+
+static void *metaDecodeTbInfo(void *buf, STbCfg *pTbCfg) {
+  buf = taosDecodeString(buf, &(pTbCfg->name));
+  buf = taosDecodeFixedU32(buf, &(pTbCfg->ttl));
+  buf = taosDecodeFixedU32(buf, &(pTbCfg->keep));
+  buf = taosDecodeFixedU8(buf, &(pTbCfg->info));
+
+  if (pTbCfg->type == META_SUPER_TABLE) {
+    SSchemaWrapper sw;
+    buf = metaDecodeSchema(buf, &sw);
+    pTbCfg->stbCfg.nTagCols = sw.nCols;
+    pTbCfg->stbCfg.pTagSchema = sw.pSchema;
+  } else if (pTbCfg->type == META_CHILD_TABLE) {
+    buf = taosDecodeFixedU64(buf, &(pTbCfg->ctbCfg.suid));
+    buf = tdDecodeKVRow(buf, &(pTbCfg->ctbCfg.pTag));
+  } else if (pTbCfg->type == META_NORMAL_TABLE) {
+    // TODO
+  } else {
+    ASSERT(0);
+  }
+  return buf;
+}

source/libs/nodes/src/nodesCodeFuncs.c

@@ -1057,6 +1057,7 @@ static const char* jkIntervalPhysiPlanIntervalUnit = "intervalUnit";
 static const char* jkIntervalPhysiPlanSlidingUnit  = "slidingUnit";
 static const char* jkIntervalPhysiPlanFill = "Fill";
 static const char* jkIntervalPhysiPlanTsPk = "TsPk";
+static const char* jkIntervalPhysiPlanPrecision = "Precision";
 
 static int32_t physiIntervalNodeToJson(const void* pObj, SJson* pJson) {
   const SIntervalPhysiNode* pNode = (const SIntervalPhysiNode*)pObj;
@@ -1083,6 +1084,9 @@ static int32_t physiIntervalNodeToJson(const void* pObj, SJson* pJson) {
   if (TSDB_CODE_SUCCESS == code) {
     code = tjsonAddObject(pJson, jkIntervalPhysiPlanTsPk, nodeToJson, pNode->pTspk);
   }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddIntegerToObject(pJson, jkIntervalPhysiPlanPrecision, pNode->precision);
+  }
 
   return code;
 }
@@ -1112,6 +1116,9 @@ static int32_t jsonToPhysiIntervalNode(const SJson* pJson, void* pObj) {
   if (TSDB_CODE_SUCCESS == code) {
     code = jsonToNodeObject(pJson, jkIntervalPhysiPlanTsPk, (SNode**)&pNode->pTspk);
   }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonGetUTinyIntValue(pJson, jkIntervalPhysiPlanPrecision, &pNode->precision);
+  }
 
   return code;
 }

source/libs/nodes/src/nodesUtilFuncs.c

@@ -204,49 +204,159 @@ SNodeptr nodesMakeNode(ENodeType type) {
   return NULL;
 }
 
-static EDealRes destroyNode(SNode** pNode, void* pContext) {
-  switch (nodeType(*pNode)) {
+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->pChildren);
+  nodesDestroyNode(pNode->pConditions);
+  nodesDestroyList(pNode->pTargets);
+}
+
+static void destroyPhysiNode(SPhysiNode* pNode) {
+  nodesDestroyList(pNode->pChildren);
+  nodesDestroyNode(pNode->pConditions);
+  nodesDestroyNode(pNode->pOutputDataBlockDesc);
+}
+
+static void destroyWinodwPhysiNode(SWinodwPhysiNode* pNode) {
+  destroyPhysiNode((SPhysiNode*)pNode);
+  nodesDestroyList(pNode->pExprs);
+  nodesDestroyList(pNode->pFuncs);
+}
+
+static void destroyScanPhysiNode(SScanPhysiNode* pNode) {
+  destroyPhysiNode((SPhysiNode*)pNode);
+  nodesDestroyList(pNode->pScanCols);
+}
+
+static void destroyDataSinkNode(SDataSinkNode* pNode) {
+  nodesDestroyNode(pNode->pInputDataBlockDesc);
+}
+
+void nodesDestroyNode(SNodeptr pNode) {
+  if (NULL == pNode) {
+    return;
+  }
+
+  switch (nodeType(pNode)) {
+    case QUERY_NODE_COLUMN: // pProjectRef is weak reference, no need to release
+      break;
     case QUERY_NODE_VALUE: {
-      SValueNode* pValue = (SValueNode*)*pNode;
-      
+      SValueNode* pValue = (SValueNode*)pNode;
       taosMemoryFreeClear(pValue->literal);
       if (IS_VAR_DATA_TYPE(pValue->node.resType.type)) {
         taosMemoryFreeClear(pValue->datum.p);
       }
-      
+      break;
+    }
+    case QUERY_NODE_OPERATOR: {
+      SOperatorNode* pOp = (SOperatorNode*)pNode;
+      nodesDestroyNode(pOp->pLeft);
+      nodesDestroyNode(pOp->pRight);
       break;
     }
     case QUERY_NODE_LOGIC_CONDITION:
-      nodesClearList(((SLogicConditionNode*)(*pNode))->pParameterList);
+      nodesDestroyList(((SLogicConditionNode*)pNode)->pParameterList);
       break;
     case QUERY_NODE_FUNCTION:
-      nodesClearList(((SFunctionNode*)(*pNode))->pParameterList);
+      nodesDestroyList(((SFunctionNode*)pNode)->pParameterList);
       break;
     case QUERY_NODE_REAL_TABLE: {
-      SRealTableNode* pReal = (SRealTableNode*)*pNode;
+      SRealTableNode* pReal = (SRealTableNode*)pNode;
       taosMemoryFreeClear(pReal->pMeta);
       taosMemoryFreeClear(pReal->pVgroupList);
       break;
     }
     case QUERY_NODE_TEMP_TABLE:
-      nodesDestroyNode(((STempTableNode*)(*pNode))->pSubquery);
+      nodesDestroyNode(((STempTableNode*)pNode)->pSubquery);
+      break;
+    case QUERY_NODE_JOIN_TABLE: {
+      SJoinTableNode* pJoin = (SJoinTableNode*)pNode;
+      nodesDestroyNode(pJoin->pLeft);
+      nodesDestroyNode(pJoin->pRight);
+      nodesDestroyNode(pJoin->pOnCond);
       break;
+    }
     case QUERY_NODE_GROUPING_SET:
-      nodesClearList(((SGroupingSetNode*)(*pNode))->pParameterList);
+      nodesDestroyList(((SGroupingSetNode*)pNode)->pParameterList);
+      break;
+    case QUERY_NODE_ORDER_BY_EXPR:
+      nodesDestroyNode(((SOrderByExprNode*)pNode)->pExpr);
+      break;
+    case QUERY_NODE_LIMIT: // no pointer field
+      break;
+    case QUERY_NODE_STATE_WINDOW:
+      nodesDestroyNode(((SStateWindowNode*)pNode)->pCol);
+      break;
+    case QUERY_NODE_SESSION_WINDOW: {
+      SSessionWindowNode* pSession = (SSessionWindowNode*)pNode;
+      nodesDestroyNode(pSession->pCol);
+      nodesDestroyNode(pSession->pGap);
       break;
+    }
+    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;
+    }
     case QUERY_NODE_NODE_LIST:
-      nodesClearList(((SNodeListNode*)(*pNode))->pNodeList);
+      nodesDestroyList(((SNodeListNode*)pNode)->pNodeList);
+      break;
+    case QUERY_NODE_FILL:
+      nodesDestroyNode(((SFillNode*)pNode)->pValues);
+      break;
+    case QUERY_NODE_RAW_EXPR:
+      nodesDestroyNode(((SRawExprNode*)pNode)->pNode);
+      break;
+    case QUERY_NODE_TARGET:
+      nodesDestroyNode(((STargetNode*)pNode)->pExpr);
       break;
+    case QUERY_NODE_DATABLOCK_DESC:
+      nodesDestroyList(((SDataBlockDescNode*)pNode)->pSlots);
+      break;
+    case QUERY_NODE_SLOT_DESC:         // no pointer field
+    case QUERY_NODE_COLUMN_DEF:        // no pointer field
+    case QUERY_NODE_DOWNSTREAM_SOURCE: // no pointer field
+      break;
+    case QUERY_NODE_DATABASE_OPTIONS:
+      nodesDestroyList(((SDatabaseOptions*)pNode)->pRetentions);
+      break;
+    case QUERY_NODE_TABLE_OPTIONS: {
+      STableOptions* pStmt = (STableOptions*)pNode;
+      nodesDestroyList(pStmt->pSma);
+      nodesDestroyList(pStmt->pFuncs);
+      break;
+    }
     case QUERY_NODE_INDEX_OPTIONS: {
-      SIndexOptions* pStmt = (SIndexOptions*)*pNode;
+      SIndexOptions* pStmt = (SIndexOptions*)pNode;
       nodesDestroyList(pStmt->pFuncs);
       nodesDestroyNode(pStmt->pInterval);
       nodesDestroyNode(pStmt->pOffset);
       nodesDestroyNode(pStmt->pSliding);
       break;
     }
+    case QUERY_NODE_SET_OPERATOR: {
+      SSetOperator* pStmt = (SSetOperator*)pNode;
+      nodesDestroyNode(pStmt->pLeft);
+      nodesDestroyNode(pStmt->pRight);
+      nodesDestroyList(pStmt->pOrderByList);
+      nodesDestroyNode(pStmt->pLimit);
+      break;
+    }
     case QUERY_NODE_SELECT_STMT: {
-      SSelectStmt* pStmt = (SSelectStmt*)*pNode;
+      SSelectStmt* pStmt = (SSelectStmt*)pNode;
       nodesDestroyList(pStmt->pProjectionList);
       nodesDestroyNode(pStmt->pFromTable);
       nodesDestroyNode(pStmt->pWhere);
@@ -259,50 +369,255 @@ static EDealRes destroyNode(SNode** pNode, void* pContext) {
       nodesDestroyNode(pStmt->pSlimit);
       break;
     }
-    case QUERY_NODE_VNODE_MODIF_STMT: {
-      SVnodeModifOpStmt* pStmt = (SVnodeModifOpStmt*)*pNode;
-      size_t size = taosArrayGetSize(pStmt->pDataBlocks);
-      for (size_t i = 0; i < size; ++i) {
-        SVgDataBlocks* pVg = taosArrayGetP(pStmt->pDataBlocks, i);
-        taosMemoryFreeClear(pVg->pData);
-        taosMemoryFreeClear(pVg);
-      }
-      taosArrayDestroy(pStmt->pDataBlocks);
+    case QUERY_NODE_VNODE_MODIF_STMT:
+      destroyVgDataBlockArray(((SVnodeModifOpStmt*)pNode)->pDataBlocks);
+      break;
+    case QUERY_NODE_CREATE_DATABASE_STMT:
+      nodesDestroyNode(((SCreateDatabaseStmt*)pNode)->pOptions);
+      break;
+    case QUERY_NODE_DROP_DATABASE_STMT: // no pointer field
+      break;
+    case QUERY_NODE_ALTER_DATABASE_STMT:
+      nodesDestroyNode(((SAlterDatabaseStmt*)pNode)->pOptions);
       break;
-    }
     case QUERY_NODE_CREATE_TABLE_STMT: {
-      SCreateTableStmt* pStmt = (SCreateTableStmt*)*pNode;
+      SCreateTableStmt* pStmt = (SCreateTableStmt*)pNode;
       nodesDestroyList(pStmt->pCols);
       nodesDestroyList(pStmt->pTags);
+      nodesDestroyNode(pStmt->pOptions);
       break;
     }
     case QUERY_NODE_CREATE_SUBTABLE_CLAUSE: {
-      SCreateSubTableClause* pStmt = (SCreateSubTableClause*)*pNode;
+      SCreateSubTableClause* pStmt = (SCreateSubTableClause*)pNode;
       nodesDestroyList(pStmt->pSpecificTags);
       nodesDestroyList(pStmt->pValsOfTags);
       break;
     }
     case QUERY_NODE_CREATE_MULTI_TABLE_STMT:
-      nodesDestroyList(((SCreateMultiTableStmt*)(*pNode))->pSubTables);
+      nodesDestroyList(((SCreateMultiTableStmt*)pNode)->pSubTables);
+      break;
+    case QUERY_NODE_DROP_TABLE_CLAUSE: // no pointer field
+      break;
+    case QUERY_NODE_DROP_TABLE_STMT:
+      nodesDestroyNode(((SDropTableStmt*)pNode)->pTables);
+      break;
+    case QUERY_NODE_DROP_SUPER_TABLE_STMT: // no pointer field
+      break;
+    case QUERY_NODE_ALTER_TABLE_STMT: {
+      SAlterTableStmt* pStmt = (SAlterTableStmt*)pNode;
+      nodesDestroyNode(pStmt->pOptions);
+      nodesDestroyNode(pStmt->pVal);
+      break;
+    }
+    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
       break;
     case QUERY_NODE_CREATE_INDEX_STMT: {
-      SCreateIndexStmt* pStmt = (SCreateIndexStmt*)*pNode;
+      SCreateIndexStmt* pStmt = (SCreateIndexStmt*)pNode;
       nodesDestroyNode(pStmt->pOptions);
       nodesDestroyList(pStmt->pCols);
       break;
     }
+    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
+      break;
+    case QUERY_NODE_CREATE_TOPIC_STMT:
+      nodesDestroyNode(((SCreateTopicStmt*)pNode)->pQuery);
+      break;
+    case QUERY_NODE_DROP_TOPIC_STMT:  // no pointer field
+    case QUERY_NODE_ALTER_LOCAL_STMT: // no pointer field
+      break;
+    case QUERY_NODE_SHOW_DATABASES_STMT:
+    case QUERY_NODE_SHOW_TABLES_STMT:
+    case QUERY_NODE_SHOW_STABLES_STMT:
+    case QUERY_NODE_SHOW_USERS_STMT:
+    case QUERY_NODE_SHOW_DNODES_STMT:
+    case QUERY_NODE_SHOW_VGROUPS_STMT:
+    case QUERY_NODE_SHOW_MNODES_STMT:
+    case QUERY_NODE_SHOW_MODULES_STMT:
+    case QUERY_NODE_SHOW_QNODES_STMT:
+    case QUERY_NODE_SHOW_FUNCTIONS_STMT:
+    case QUERY_NODE_SHOW_INDEXES_STMT:
+    case QUERY_NODE_SHOW_STREAMS_STMT: {
+      SShowStmt* pStmt = (SShowStmt*)pNode;
+      nodesDestroyNode(pStmt->pDbName);
+      nodesDestroyNode(pStmt->pTbNamePattern);
+      break;
+    }
+    case QUERY_NODE_LOGIC_PLAN_SCAN: {
+      SScanLogicNode* pLogicNode = (SScanLogicNode*)pNode;
+      destroyLogicNode((SLogicNode*)pLogicNode);
+      nodesDestroyList(pLogicNode->pScanCols);
+      taosMemoryFreeClear(pLogicNode->pMeta);
+      taosMemoryFreeClear(pLogicNode->pVgroupList);
+      break;
+    }
+    case QUERY_NODE_LOGIC_PLAN_JOIN: {
+      SJoinLogicNode* pLogicNode = (SJoinLogicNode*)pNode;
+      destroyLogicNode((SLogicNode*)pLogicNode);
+      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;
+    }
+    case QUERY_NODE_LOGIC_PLAN_VNODE_MODIF: {
+      SVnodeModifLogicNode* pLogicNode = (SVnodeModifLogicNode*)pNode;
+      destroyLogicNode((SLogicNode*)pLogicNode);
+      destroyVgDataBlockArray(pLogicNode->pDataBlocks);
+      // pVgDataBlocks is weak reference
+      break;
+    }
+    case QUERY_NODE_LOGIC_PLAN_EXCHANGE:
+      destroyLogicNode((SLogicNode*)pNode);
+      break;
+    case QUERY_NODE_LOGIC_PLAN_WINDOW: {
+      SWindowLogicNode* pLogicNode = (SWindowLogicNode*)pNode;
+      destroyLogicNode((SLogicNode*)pLogicNode);
+      nodesDestroyList(pLogicNode->pFuncs);
+      nodesDestroyNode(pLogicNode->pFill);
+      nodesDestroyNode(pLogicNode->pTspk);
+      break;
+    }
+    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);
+      break;
+    }
+    case QUERY_NODE_LOGIC_SUBPLAN: {
+      SLogicSubplan* pSubplan = (SLogicSubplan*)pNode;
+      nodesDestroyList(pSubplan->pChildren);
+      nodesDestroyNode(pSubplan->pNode);
+      nodesClearList(pSubplan->pParents);
+      taosMemoryFreeClear(pSubplan->pVgroupList);
+      break;
+    }
+    case QUERY_NODE_LOGIC_PLAN:
+      nodesDestroyList(((SQueryLogicPlan*)pNode)->pTopSubplans);
+      break;
+    case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN:
+      destroyScanPhysiNode((SScanPhysiNode*)pNode);
+      break;
+    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN:
+      destroyScanPhysiNode((SScanPhysiNode*)pNode);
+      break;
+    case QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN:
+      destroyScanPhysiNode((SScanPhysiNode*)pNode);
+      break;
+    case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN:
+      destroyScanPhysiNode((SScanPhysiNode*)pNode);
+      break;
+    case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN:
+      destroyScanPhysiNode((SScanPhysiNode*)pNode);
+      break;
+    case QUERY_NODE_PHYSICAL_PLAN_PROJECT: {
+      SProjectPhysiNode* pPhyNode = (SProjectPhysiNode*)pNode;
+      destroyPhysiNode((SPhysiNode*)pPhyNode);
+      nodesDestroyList(pPhyNode->pProjections);
+      break;
+    }
+    case QUERY_NODE_PHYSICAL_PLAN_JOIN: {
+      SJoinPhysiNode* pPhyNode = (SJoinPhysiNode*)pNode;
+      destroyPhysiNode((SPhysiNode*)pPhyNode);
+      nodesDestroyNode(pPhyNode->pOnConditions);
+      nodesDestroyList(pPhyNode->pTargets);
+      break;
+    }
+    case QUERY_NODE_PHYSICAL_PLAN_AGG: {
+      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;
+    }
+    case QUERY_NODE_PHYSICAL_PLAN_SORT: {
+      SSortPhysiNode* pPhyNode = (SSortPhysiNode*)pNode;
+      destroyPhysiNode((SPhysiNode*)pPhyNode);
+      nodesDestroyNode(pPhyNode->pExprs);
+      nodesDestroyNode(pPhyNode->pSortKeys);
+      break;
+    }
+    case QUERY_NODE_PHYSICAL_PLAN_INTERVAL: {
+      SIntervalPhysiNode* pPhyNode = (SIntervalPhysiNode*)pNode;
+      destroyWinodwPhysiNode((SWinodwPhysiNode*)pPhyNode);
+      nodesDestroyNode(pPhyNode->pFill);
+      nodesDestroyNode(pPhyNode->pTspk);
+      break;
+    }
+    case QUERY_NODE_PHYSICAL_PLAN_SESSION_WINDOW:
+      destroyWinodwPhysiNode((SWinodwPhysiNode*)pNode);
+      break;
+    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;
+    }
+    case QUERY_NODE_PHYSICAL_SUBPLAN: {
+      SSubplan* pSubplan = (SSubplan*)pNode;
+      nodesDestroyList(pSubplan->pChildren);
+      nodesDestroyNode(pSubplan->pNode);
+      nodesDestroyNode(pSubplan->pDataSink);
+      nodesClearList(pSubplan->pParents);
+      break;
+    }
+    case QUERY_NODE_PHYSICAL_PLAN: {
+      SQueryPlan* pPlan = (SQueryPlan*)pNode;
+      if (NULL != pPlan->pSubplans) {
+        // only need to destroy the top-level subplans, because they will recurse to all the subplans below
+        bool first = true;
+        SNode* pElement = NULL;
+        FOREACH(pElement, pPlan->pSubplans) {
+          if (first) {
+            first = false;
+            nodesDestroyNode(pElement);
+          } else {
+            nodesClearList(((SNodeListNode*)pElement)->pNodeList);
+            taosMemoryFreeClear(pElement);
+          }
+        }
+        nodesClearList(pPlan->pSubplans);
+      }
+      break;
+    }
     default:
       break;
   }
-  taosMemoryFreeClear(*pNode);
-  return DEAL_RES_CONTINUE;
-}
-
-void nodesDestroyNode(SNodeptr pNode) {
-  if (NULL == pNode) {
-    return;
-  }
-  nodesRewriteNodePostOrder((SNode**)&pNode, destroyNode, NULL);
+  taosMemoryFreeClear(pNode);
+  return;
 }
 
 SNodeList* nodesMakeList() {

source/libs/parser/src/parTranslater.c

@@ -228,6 +228,9 @@ static void setColumnInfoBySchema(const SRealTableNode* pTable, const SSchema* p
   pCol->colType = isTag ? COLUMN_TYPE_TAG : COLUMN_TYPE_COLUMN;
   pCol->node.resType.type = pColSchema->type;
   pCol->node.resType.bytes = pColSchema->bytes;
+  if (TSDB_DATA_TYPE_TIMESTAMP == pCol->node.resType.type) {
+    pCol->node.resType.precision = pTable->pMeta->tableInfo.precision;
+  }
 }
 
 static void setColumnInfoByExpr(const STableNode* pTable, SExprNode* pExpr, SColumnNode* pCol) {

source/libs/parser/src/parser.c

@@ -58,5 +58,7 @@ void qDestroyQuery(SQuery* pQueryNode) {
     taosMemoryFreeClear(pQueryNode->pCmdMsg->pMsg);
     taosMemoryFreeClear(pQueryNode->pCmdMsg);
   }
+  taosArrayDestroy(pQueryNode->pDbList);
+  taosArrayDestroy(pQueryNode->pTableList);
   taosMemoryFreeClear(pQueryNode);
 }

source/libs/planner/src/planLogicCreater.c

@@ -692,7 +692,7 @@ static int32_t createVnodeModifLogicNode(SLogicPlanContext* pCxt, SVnodeModifOpS
   if (NULL == pModif) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
-  pModif->pDataBlocks = pStmt->pDataBlocks;
+  TSWAP(pModif->pDataBlocks, pStmt->pDataBlocks, SArray*);
   pModif->msgType = getMsgType(pStmt->sqlNodeType);
   *pLogicNode = (SLogicNode*)pModif;
   return TSDB_CODE_SUCCESS;

source/libs/planner/src/planPhysiCreater.c

@@ -780,6 +780,7 @@ static int32_t createIntervalPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChil
   pInterval->sliding = pWindowLogicNode->sliding;
   pInterval->intervalUnit = pWindowLogicNode->intervalUnit;
   pInterval->slidingUnit = pWindowLogicNode->slidingUnit;
+  pInterval->precision = ((SColumnNode*)pWindowLogicNode->pTspk)->node.resType.precision;
 
   pInterval->pFill = nodesCloneNode(pWindowLogicNode->pFill);
   if (NULL != pWindowLogicNode->pFill && NULL == pInterval->pFill) {
@@ -1080,6 +1081,20 @@ static int32_t doCreatePhysiPlan(SPhysiPlanContext* pCxt, SQueryLogicPlan* pLogi
   return code;
 }
 
+static void destoryLocationHash(void* p) {
+  SHashObj* pHash = *(SHashObj**)p;
+  SSlotIndex* pIndex = taosHashIterate(pHash, NULL);
+  while (NULL != pIndex) {
+    taosArrayDestroy(pIndex->pSlotIdsInfo);
+    pIndex = taosHashIterate(pHash, pIndex);
+  }
+  taosHashCleanup(pHash);
+}
+
+static void destoryPhysiPlanContext(SPhysiPlanContext* pCxt) {
+  taosArrayDestroyEx(pCxt->pLocationHelper, destoryLocationHash);
+}
+
 int32_t createPhysiPlan(SPlanContext* pCxt, SQueryLogicPlan* pLogicPlan, SQueryPlan** pPlan, SArray* pExecNodeList) {
   SPhysiPlanContext cxt = {
     .pPlanCxt = pCxt,
@@ -1091,5 +1106,7 @@ int32_t createPhysiPlan(SPlanContext* pCxt, SQueryLogicPlan* pLogicPlan, SQueryP
   if (NULL == cxt.pLocationHelper) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
-  return doCreatePhysiPlan(&cxt, pLogicPlan, pPlan);
+  int32_t code = doCreatePhysiPlan(&cxt, pLogicPlan, pPlan);
+  destoryPhysiPlanContext(&cxt);
+  return code;
 }

source/libs/planner/src/planScaleOut.c

@@ -167,6 +167,8 @@ static int32_t doScaleOut(SScaleOutContext* pCxt, SLogicSubplan* pSubplan, int32
 
   if (TSDB_CODE_SUCCESS != code) {
     nodesDestroyList(pCurrentGroup);
+  } else {
+    nodesClearList(pCurrentGroup);
   }
 
   return code;

source/libs/planner/src/planSpliter.c

@@ -140,6 +140,7 @@ static int32_t stsSplit(SSplitContext* pCxt) {
     code = stsCreateExchangeNode(pCxt, pInfo->pSubplan, pInfo->pScan);
   }
   ++(pCxt->groupId);
+  taosMemoryFreeClear(pCxt->pInfo);
   return code;
 }
 

source/libs/planner/test/plannerTest.cpp

@@ -248,6 +248,11 @@ TEST_F(PlannerTest, showTables) {
 
   bind("show tables");
   ASSERT_TRUE(run());
+
+  setDatabase("root", "information_schema");
+
+  bind("show tables");
+  ASSERT_TRUE(run());
 }
 
 TEST_F(PlannerTest, showStables) {