Merge branch '3.0' into merge/mainto3.0

include/client/taos.h

@@ -81,6 +81,13 @@ typedef enum {
   TSDB_SML_TIMESTAMP_NANO_SECONDS,
 } TSDB_SML_TIMESTAMP_TYPE;
 
+typedef enum TAOS_FIELD_T {
+  TAOS_FIELD_COL = 1,
+  TAOS_FIELD_TAG,
+  TAOS_FIELD_QUERY,
+  TAOS_FIELD_TBNAME,
+} TAOS_FIELD_T;
+
 typedef struct taosField {
   char    name[65];
   int8_t  type;
@@ -95,6 +102,15 @@ typedef struct TAOS_FIELD_E {
   int32_t bytes;
 } TAOS_FIELD_E;
 
+typedef struct TAOS_FIELD_ALL {
+  char         name[65];
+  int8_t       type;
+  uint8_t      precision;
+  uint8_t      scale;
+  int32_t      bytes;
+  TAOS_FIELD_T field_type;
+} TAOS_FIELD_ALL;
+
 #ifdef WINDOWS
 #define DLL_EXPORT __declspec(dllexport)
 #else
@@ -195,13 +211,6 @@ DLL_EXPORT int       taos_stmt_affected_rows_once(TAOS_STMT *stmt);
 
 typedef void TAOS_STMT2;
 
-typedef enum TAOS_FIELD_T {
-  TAOS_FIELD_COL = 1,
-  TAOS_FIELD_TAG,
-  TAOS_FIELD_QUERY,
-  TAOS_FIELD_TBNAME,
-} TAOS_FIELD_T;
-
 typedef struct TAOS_STMT2_OPTION {
   int64_t           reqid;
   bool              singleStbInsert;
@@ -232,7 +241,9 @@ DLL_EXPORT int         taos_stmt2_exec(TAOS_STMT2 *stmt, int *affected_rows);
 DLL_EXPORT int         taos_stmt2_close(TAOS_STMT2 *stmt);
 DLL_EXPORT int         taos_stmt2_is_insert(TAOS_STMT2 *stmt, int *insert);
 DLL_EXPORT int  taos_stmt2_get_fields(TAOS_STMT2 *stmt, TAOS_FIELD_T field_type, int *count, TAOS_FIELD_E **fields);
+DLL_EXPORT int  taos_stmt2_get_all_fields(TAOS_STMT2 *stmt, int *count, TAOS_FIELD_ALL **fields);
 DLL_EXPORT void taos_stmt2_free_fields(TAOS_STMT2 *stmt, TAOS_FIELD_E *fields);
+DLL_EXPORT void taos_stmt2_free_all_fields(TAOS_STMT2 *stmt, TAOS_FIELD_ALL *fields);
 DLL_EXPORT TAOS_RES *taos_stmt2_result(TAOS_STMT2 *stmt);
 DLL_EXPORT char     *taos_stmt2_error(TAOS_STMT2 *stmt);
 
@@ -251,17 +262,17 @@ DLL_EXPORT int64_t  taos_affected_rows64(TAOS_RES *res);
 DLL_EXPORT TAOS_FIELD *taos_fetch_fields(TAOS_RES *res);
 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 int         taos_print_row_with_size(char *str, uint32_t size, TAOS_ROW row, TAOS_FIELD *fields, int num_fields);
+DLL_EXPORT int  taos_print_row_with_size(char *str, uint32_t size, TAOS_ROW row, TAOS_FIELD *fields, int num_fields);
-DLL_EXPORT void        taos_stop_query(TAOS_RES *res);
+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_null(TAOS_RES *res, int32_t row, int32_t col);
-DLL_EXPORT int         taos_is_null_by_column(TAOS_RES *res, int columnIndex, bool result[], int *rows);
+DLL_EXPORT int  taos_is_null_by_column(TAOS_RES *res, int columnIndex, bool result[], int *rows);
-DLL_EXPORT bool        taos_is_update_query(TAOS_RES *res);
+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_fetch_block(TAOS_RES *res, TAOS_ROW *rows);
-DLL_EXPORT int         taos_fetch_block_s(TAOS_RES *res, int *numOfRows, TAOS_ROW *rows);
+DLL_EXPORT int  taos_fetch_block_s(TAOS_RES *res, int *numOfRows, TAOS_ROW *rows);
-DLL_EXPORT int         taos_fetch_raw_block(TAOS_RES *res, int *numOfRows, void **pData);
+DLL_EXPORT int  taos_fetch_raw_block(TAOS_RES *res, int *numOfRows, void **pData);
-DLL_EXPORT int        *taos_get_column_data_offset(TAOS_RES *res, int columnIndex);
+DLL_EXPORT int *taos_get_column_data_offset(TAOS_RES *res, int columnIndex);
-DLL_EXPORT int         taos_validate_sql(TAOS *taos, const char *sql);
+DLL_EXPORT int  taos_validate_sql(TAOS *taos, const char *sql);
-DLL_EXPORT void        taos_reset_current_db(TAOS *taos);
+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);

source/client/inc/clientStmt2.h

@@ -222,6 +222,7 @@ int         stmtSetTbTags2(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *tags);
 int         stmtBindBatch2(TAOS_STMT2 *stmt, TAOS_STMT2_BIND *bind, int32_t colIdx);
 int         stmtGetTagFields2(TAOS_STMT2 *stmt, int *nums, TAOS_FIELD_E **fields);
 int         stmtGetColFields2(TAOS_STMT2 *stmt, int *nums, TAOS_FIELD_E **fields);
+int         stmtGetColFieldsALL2(TAOS_STMT2 *stmt, int *nums, TAOS_FIELD_ALL **fields);
 int         stmtGetParamNum2(TAOS_STMT2 *stmt, int *nums);
 int         stmtGetParamTbName(TAOS_STMT2 *stmt, int *nums);
 int         stmtIsInsert2(TAOS_STMT2 *stmt, int *insert);

source/client/src/clientMain.c

@@ -84,7 +84,7 @@ void taos_cleanup(void) {
   taosCloseRef(id);
 
   nodesDestroyAllocatorSet();
-//  cleanupAppInfo();
+  //  cleanupAppInfo();
   rpcCleanup();
   tscDebug("rpc cleanup");
 
@@ -388,7 +388,6 @@ void taos_free_result(TAOS_RES *res) {
     tDeleteMqBatchMetaRsp(&pRsp->batchMetaRsp);
   }
   taosMemoryFree(pRsp);
-
 }
 
 void taos_kill_query(TAOS *taos) {
@@ -484,7 +483,7 @@ TAOS_ROW taos_fetch_row(TAOS_RES *res) {
 int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields) {
   return taos_print_row_with_size(str, INT32_MAX, row, fields, num_fields);
 }
-int taos_print_row_with_size(char *str, uint32_t size, TAOS_ROW row, TAOS_FIELD *fields, int num_fields){
+int taos_print_row_with_size(char *str, uint32_t size, TAOS_ROW row, TAOS_FIELD *fields, int num_fields) {
   int32_t len = 0;
   for (int i = 0; i < num_fields; ++i) {
     if (i > 0 && len < size - 1) {
@@ -589,7 +588,7 @@ int taos_print_row_with_size(char *str, uint32_t size, TAOS_ROW row, TAOS_FIELD
       break;
     }
   }
-  if (len < size){
+  if (len < size) {
     str[len] = 0;
   }
 
@@ -2082,7 +2081,7 @@ int taos_stmt2_is_insert(TAOS_STMT2 *stmt, int *insert) {
 }
 
 int taos_stmt2_get_fields(TAOS_STMT2 *stmt, TAOS_FIELD_T field_type, int *count, TAOS_FIELD_E **fields) {
-  if (stmt == NULL || NULL == count) {
+  if (stmt == NULL || count == NULL) {
     tscError("NULL parameter for %s", __FUNCTION__);
     terrno = TSDB_CODE_INVALID_PARA;
     return terrno;
@@ -2103,12 +2102,28 @@ int taos_stmt2_get_fields(TAOS_STMT2 *stmt, TAOS_FIELD_T field_type, int *count,
   }
 }
 
+int taos_stmt2_get_all_fields(TAOS_STMT2 *stmt, int *count, TAOS_FIELD_ALL **fields) {
+  if (stmt == NULL || count == NULL) {
+    tscError("NULL parameter for %s", __FUNCTION__);
+    terrno = TSDB_CODE_INVALID_PARA;
+    return terrno;
+  }
+
+  return stmtGetColFieldsALL2(stmt, count, fields);
+}
+
 void taos_stmt2_free_fields(TAOS_STMT2 *stmt, TAOS_FIELD_E *fields) {
   (void)stmt;
   if (!fields) return;
   taosMemoryFree(fields);
 }
 
+DLL_EXPORT void taos_stmt2_free_all_fields(TAOS_STMT2 *stmt, TAOS_FIELD_ALL *fields) {
+  (void)stmt;
+  if (!fields) return;
+  taosMemoryFree(fields);
+}
+
 TAOS_RES *taos_stmt2_result(TAOS_STMT2 *stmt) {
   if (stmt == NULL) {
     tscError("NULL parameter for %s", __FUNCTION__);

source/client/src/clientStmt2.c

@@ -1068,6 +1068,48 @@ static int stmtFetchColFields2(STscStmt2* pStmt, int32_t* fieldNum, TAOS_FIELD_E
 
   return TSDB_CODE_SUCCESS;
 }
+
+static int stmtFetchFields2(STscStmt2* pStmt, int32_t* fieldNum, TAOS_FIELD_ALL** fields) {
+  SBoundColInfo* tags = (SBoundColInfo*)pStmt->bInfo.boundTags;
+  STableMeta*    meta = ((SVnodeModifyOpStmt*)(pStmt->sql.pQuery->pRoot))->pTableMeta;
+  if (tags == NULL || meta == NULL || (meta->schema == NULL && tags->numOfBound != 0)) {
+    return TSDB_CODE_INVALID_PARA;
+  }
+
+  if (fields != NULL) {
+    *fields = taosMemoryCalloc(tags->numOfBound, sizeof(TAOS_FIELD_ALL));
+    if (NULL == *fields) {
+      return terrno;
+    }
+
+    SSchema* pSchema = meta->schema;
+    int32_t  tbnameIdx = meta->tableInfo.numOfTags + meta->tableInfo.numOfColumns;
+    for (int32_t i = 0; i < tags->numOfBound; ++i) {
+      int16_t idx = tags->pColIndex[i];
+      if (idx == tbnameIdx) {
+        (*fields)[i].field_type = TAOS_FIELD_TBNAME;
+        tstrncpy((*fields)[i].name, "tbname", sizeof((*fields)[i].name));
+        continue;
+      } else if (idx < meta->tableInfo.numOfColumns) {
+        (*fields)[i].field_type = TAOS_FIELD_COL;
+      } else {
+        (*fields)[i].field_type = TAOS_FIELD_TAG;
+      }
+
+      if (TSDB_DATA_TYPE_TIMESTAMP == pSchema[tags->pColIndex[i]].type) {
+        (*fields)[i].precision = meta->tableInfo.precision;
+      }
+
+      tstrncpy((*fields)[i].name, pSchema[tags->pColIndex[i]].name, sizeof((*fields)[i].name));
+      (*fields)[i].type = pSchema[tags->pColIndex[i]].type;
+      (*fields)[i].bytes = pSchema[tags->pColIndex[i]].bytes;
+    }
+  }
+
+  *fieldNum = tags->numOfBound;
+
+  return TSDB_CODE_SUCCESS;
+}
 /*
 SArray* stmtGetFreeCol(STscStmt2* pStmt, int32_t* idx) {
   while (true) {
@@ -1851,6 +1893,50 @@ _return:
   return code;
 }
 
+int stmtGetColFieldsALL2(TAOS_STMT2* stmt, int* nums, TAOS_FIELD_ALL** fields) {
+  int32_t    code = 0;
+  STscStmt2* pStmt = (STscStmt2*)stmt;
+  int32_t    preCode = pStmt->errCode;
+
+  STMT_DLOG_E("start to get col fields");
+
+  if (pStmt->errCode != TSDB_CODE_SUCCESS) {
+    return pStmt->errCode;
+  }
+
+  if (STMT_TYPE_QUERY == pStmt->sql.type) {
+    STMT_ERRI_JRET(TSDB_CODE_TSC_STMT_API_ERROR);
+  }
+
+  STMT_ERRI_JRET(stmtSwitchStatus(pStmt, STMT_FETCH_FIELDS));
+
+  if (pStmt->bInfo.needParse && pStmt->sql.runTimes && pStmt->sql.type > 0 &&
+      STMT_TYPE_MULTI_INSERT != pStmt->sql.type) {
+    pStmt->bInfo.needParse = false;
+  }
+
+  if (pStmt->exec.pRequest && STMT_TYPE_QUERY == pStmt->sql.type && pStmt->sql.runTimes) {
+    taos_free_result(pStmt->exec.pRequest);
+    pStmt->exec.pRequest = NULL;
+    STMT_ERR_RET(stmtCreateRequest(pStmt));
+  }
+
+  STMT_ERRI_JRET(stmtCreateRequest(pStmt));
+
+  if (pStmt->bInfo.needParse) {
+    STMT_ERRI_JRET(stmtParseSql(pStmt));
+  }
+
+_return:
+
+  pStmt->errCode = preCode;
+  if (code == TSDB_CODE_TSC_INVALID_OPERATION) {
+    return stmtFetchFields2(stmt, nums, fields);
+  }
+
+  return code;
+}
+
 int stmtGetParamNum2(TAOS_STMT2* stmt, int* nums) {
   STscStmt2* pStmt = (STscStmt2*)stmt;
 

source/dnode/mgmt/node_mgmt/src/dmTransport.c

@@ -30,9 +30,18 @@ static inline void dmBuildMnodeRedirectRsp(SDnode *pDnode, SRpcMsg *pMsg) {
   dmGetMnodeEpSetForRedirect(&pDnode->data, pMsg, &epSet);
 
   if (epSet.numOfEps <= 1) {
-    pMsg->pCont = NULL;
+    if (epSet.numOfEps == 0) {
-    pMsg->code = TSDB_CODE_MNODE_NOT_FOUND;
+      pMsg->pCont = NULL;
-    return;
+      pMsg->code = TSDB_CODE_MNODE_NOT_FOUND;
+      return;
+    }
+    // dnode is not the mnode or mnode leader  and This ensures that the function correctly handles cases where the
+    // dnode cannot obtain a valid epSet and avoids returning an incorrect or misleading epSet.
+    if (strcmp(epSet.eps[0].fqdn, tsLocalFqdn) == 0 && epSet.eps[0].port == tsServerPort) {
+      pMsg->pCont = NULL;
+      pMsg->code = TSDB_CODE_MNODE_NOT_FOUND;
+      return;
+    }
   }
 
   int32_t contLen = tSerializeSEpSet(NULL, 0, &epSet);

source/dnode/mnode/impl/src/mndStb.c

@@ -1928,7 +1928,7 @@ static int32_t mndDropSuperTableColumn(SMnode *pMnode, const SStbObj *pOld, SStb
   }
 
   if (pOld->numOfColumns == 2) {
-    code = TSDB_CODE_MND_INVALID_STB_ALTER_OPTION;
+    code = TSDB_CODE_PAR_INVALID_DROP_COL;
     TAOS_RETURN(code);
   }
 
@@ -4295,9 +4295,9 @@ static int32_t mndDropTbAdd(SMnode *pMnode, SHashObj *pVgHashMap, const SVgroupI
   return 0;
 }
 
-int vgInfoCmp(const void* lp, const void* rp) {
+int vgInfoCmp(const void *lp, const void *rp) {
-  SVgroupInfo* pLeft = (SVgroupInfo*)lp;
+  SVgroupInfo *pLeft = (SVgroupInfo *)lp;
-  SVgroupInfo* pRight = (SVgroupInfo*)rp;
+  SVgroupInfo *pRight = (SVgroupInfo *)rp;
   if (pLeft->hashBegin < pRight->hashBegin) {
     return -1;
   } else if (pLeft->hashBegin > pRight->hashBegin) {

source/dnode/mnode/impl/test/stb/stb.cpp

@@ -782,7 +782,7 @@ TEST_F(MndTestStb, 07_Alter_Stb_DropColumn) {
   {
     void*    pReq = BuildAlterStbDropColumnReq(stbname, "col1", &contLen);
     SRpcMsg* pRsp = test.SendReq(TDMT_MND_ALTER_STB, pReq, contLen);
-    ASSERT_EQ(pRsp->code, TSDB_CODE_MND_INVALID_STB_ALTER_OPTION);
+    ASSERT_EQ(pRsp->code, TSDB_CODE_PAR_INVALID_DROP_COL);
     rpcFreeCont(pRsp->pCont);
   }
 

source/libs/parser/src/parInsertSql.c

@@ -30,7 +30,7 @@ typedef struct SInsertParseContext {
   bool           forceUpdate;
   bool           needTableTagVal;
   bool           needRequest;  // whether or not request server
-  bool           isStmtBind;    // whether is stmt bind
+  bool           isStmtBind;   // whether is stmt bind
 } SInsertParseContext;
 
 typedef int32_t (*_row_append_fn_t)(SMsgBuf* pMsgBuf, const void* value, int32_t len, void* param);
@@ -757,7 +757,7 @@ int32_t parseTagValue(SMsgBuf* pMsgBuf, const char** pSql, uint8_t precision, SS
   STagVal val = {0};
   int32_t code = parseTagToken(pSql, pToken, pTagSchema, precision, &val, pMsgBuf);
   if (TSDB_CODE_SUCCESS == code) {
-    if (NULL == taosArrayPush(pTagVals, &val)){
+    if (NULL == taosArrayPush(pTagVals, &val)) {
       code = terrno;
     }
   }
@@ -775,11 +775,14 @@ static int32_t buildCreateTbReq(SVnodeModifyOpStmt* pStmt, STag* pTag, SArray* p
     return terrno;
   }
   return insBuildCreateTbReq(pStmt->pCreateTblReq, pStmt->targetTableName.tname, pTag, pStmt->pTableMeta->suid,
-                      pStmt->usingTableName.tname, pTagName, pStmt->pTableMeta->tableInfo.numOfTags,
+                             pStmt->usingTableName.tname, pTagName, pStmt->pTableMeta->tableInfo.numOfTags,
-                      TSDB_DEFAULT_TABLE_TTL);
+                             TSDB_DEFAULT_TABLE_TTL);
 }
 
 int32_t checkAndTrimValue(SToken* pToken, char* tmpTokenBuf, SMsgBuf* pMsgBuf, int8_t type) {
+  if (pToken->type == TK_NK_QUESTION) {
+    return buildInvalidOperationMsg(pMsgBuf, "insert into super table syntax is not supported for stmt");
+  }
   if ((pToken->type != TK_NOW && pToken->type != TK_TODAY && pToken->type != TK_NK_INTEGER &&
        pToken->type != TK_NK_STRING && pToken->type != TK_NK_FLOAT && pToken->type != TK_NK_BOOL &&
        pToken->type != TK_NULL && pToken->type != TK_NK_HEX && pToken->type != TK_NK_OCT && pToken->type != TK_NK_BIN &&
@@ -810,7 +813,7 @@ typedef struct SRewriteTagCondCxt {
 
 static int32_t rewriteTagCondColumnImpl(STagVal* pVal, SNode** pNode) {
   SValueNode* pValue = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValue);
+  int32_t     code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValue);
   if (NULL == pValue) {
     return code;
   }
@@ -1041,7 +1044,7 @@ static int32_t storeChildTableMeta(SInsertParseContext* pCxt, SVnodeModifyOpStmt
     return TSDB_CODE_OUT_OF_MEMORY;
   }
 
-  char tbFName[TSDB_TABLE_FNAME_LEN];
+  char    tbFName[TSDB_TABLE_FNAME_LEN];
   int32_t code = tNameExtractFullName(&pStmt->targetTableName, tbFName);
   if (TSDB_CODE_SUCCESS != code) {
     taosMemoryFree(pBackup);
@@ -1236,7 +1239,7 @@ static int32_t getTargetTableMetaAndVgroup(SInsertParseContext* pCxt, SVnodeModi
 }
 
 static int32_t collectUseTable(const SName* pName, SHashObj* pTable) {
-  char fullName[TSDB_TABLE_FNAME_LEN];
+  char    fullName[TSDB_TABLE_FNAME_LEN];
   int32_t code = tNameExtractFullName(pName, fullName);
   if (TSDB_CODE_SUCCESS != code) {
     return code;
@@ -1382,7 +1385,7 @@ static int32_t getTableDataCxt(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pS
                               pStmt->pTableMeta, &pStmt->pCreateTblReq, pTableCxt, false, false);
   }
 
-  char tbFName[TSDB_TABLE_FNAME_LEN];
+  char    tbFName[TSDB_TABLE_FNAME_LEN];
   int32_t code = tNameExtractFullName(&pStmt->targetTableName, tbFName);
   if (TSDB_CODE_SUCCESS != code) {
     return code;
@@ -1923,8 +1926,8 @@ static int32_t processCtbAutoCreationAndCtbMeta(SInsertParseContext* pCxt, SVnod
   }
   if (code == TSDB_CODE_SUCCESS) {
     code = insBuildCreateTbReq(pStbRowsCxt->pCreateCtbReq, pStbRowsCxt->ctbName.tname, pStbRowsCxt->pTag,
-                        pStbRowsCxt->pStbMeta->uid, pStbRowsCxt->stbName.tname, pStbRowsCxt->aTagNames,
+                               pStbRowsCxt->pStbMeta->uid, pStbRowsCxt->stbName.tname, pStbRowsCxt->aTagNames,
-                        getNumOfTags(pStbRowsCxt->pStbMeta), TSDB_DEFAULT_TABLE_TTL);
+                               getNumOfTags(pStbRowsCxt->pStbMeta), TSDB_DEFAULT_TABLE_TTL);
     pStbRowsCxt->pTag = NULL;
   }
 
@@ -1933,9 +1936,9 @@ static int32_t processCtbAutoCreationAndCtbMeta(SInsertParseContext* pCxt, SVnod
     code = tNameExtractFullName(&pStbRowsCxt->ctbName, ctbFName);
     SVgroupInfo      vg;
     SRequestConnInfo conn = {.pTrans = pCxt->pComCxt->pTransporter,
-      .requestId = pCxt->pComCxt->requestId,
+                             .requestId = pCxt->pComCxt->requestId,
-      .requestObjRefId = pCxt->pComCxt->requestRid,
+                             .requestObjRefId = pCxt->pComCxt->requestRid,
-      .mgmtEps = pCxt->pComCxt->mgmtEpSet};
+                             .mgmtEps = pCxt->pComCxt->mgmtEpSet};
     if (TSDB_CODE_SUCCESS == code) {
       code = catalogGetTableHashVgroup(pCxt->pComCxt->pCatalog, &conn, &pStbRowsCxt->ctbName, &vg);
     }
@@ -2176,8 +2179,8 @@ static int32_t parseCsvFile(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt
         if (code == TSDB_CODE_SUCCESS) {
           SStbRowsDataContext* pStbRowsCxt = rowsDataCxt.pStbRowsCxt;
           void*                pData = pTableDataCxt;
-          code = taosHashPut(pStmt->pTableCxtHashObj, &pStbRowsCxt->pCtbMeta->uid, sizeof(pStbRowsCxt->pCtbMeta->uid), &pData,
+          code = taosHashPut(pStmt->pTableCxtHashObj, &pStbRowsCxt->pCtbMeta->uid, sizeof(pStbRowsCxt->pCtbMeta->uid),
-                      POINTER_BYTES);
+                             &pData, POINTER_BYTES);
           if (TSDB_CODE_SUCCESS != code) {
             break;
           }
@@ -2249,7 +2252,7 @@ static int32_t parseDataFromFileImpl(SInsertParseContext* pCxt, SVnodeModifyOpSt
   if (!pStmt->stbSyntax && numOfRows > 0) {
     void* pData = rowsDataCxt.pTableDataCxt;
     code = taosHashPut(pStmt->pTableCxtHashObj, &pStmt->pTableMeta->uid, sizeof(pStmt->pTableMeta->uid), &pData,
-                POINTER_BYTES);
+                       POINTER_BYTES);
   }
 
   return code;
@@ -2363,8 +2366,7 @@ static int32_t constructStbRowsDataContext(SVnodeModifyOpStmt* pStmt, SStbRowsDa
   if (TSDB_CODE_SUCCESS == code) {
     // col values and bound cols info of STableDataContext is not used
     pStbRowsCxt->aColVals = taosArrayInit(getNumOfColumns(pStbRowsCxt->pStbMeta), sizeof(SColVal));
-    if (!pStbRowsCxt->aColVals)
+    if (!pStbRowsCxt->aColVals) code = terrno;
-      code = terrno;
   }
   if (TSDB_CODE_SUCCESS == code) {
     code = insInitColValues(pStbRowsCxt->pStbMeta, pStbRowsCxt->aColVals);
@@ -2422,9 +2424,6 @@ static int32_t parseInsertStbClauseBottom(SInsertParseContext* pCxt, SVnodeModif
 //   1. [(tag1_name, ...)] ...
 //   2. VALUES ... | FILE ...
 static int32_t parseInsertTableClauseBottom(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt) {
-  if (pStmt->stbSyntax && TSDB_QUERY_HAS_TYPE(pStmt->insertType, TSDB_QUERY_TYPE_STMT_INSERT)) {
-    return buildInvalidOperationMsg(&pCxt->msg, "insert into super table syntax is not supported for stmt");
-  }
   if (!pStmt->stbSyntax) {
     STableDataCxt*   pTableCxt = NULL;
     int32_t          code = parseSchemaClauseBottom(pCxt, pStmt, &pTableCxt);
@@ -2511,9 +2510,9 @@ static int32_t checkTableClauseFirstToken(SInsertParseContext* pCxt, SVnodeModif
   }
 
   // db.? situation，ensure that the only thing following the '.' mark is '?'
-  char *tbNameAfterDbName = strnchr(pTbName->z, '.', pTbName->n, true);
+  char* tbNameAfterDbName = strnchr(pTbName->z, '.', pTbName->n, true);
   if ((tbNameAfterDbName != NULL) && (*(tbNameAfterDbName + 1) == '?')) {
-    char *tbName = NULL;
+    char* tbName = NULL;
     if (NULL == pCxt->pComCxt->pStmtCb) {
       return buildSyntaxErrMsg(&pCxt->msg, "? only used in stmt", pTbName->z);
     }
@@ -2528,7 +2527,8 @@ static int32_t checkTableClauseFirstToken(SInsertParseContext* pCxt, SVnodeModif
   if (pCxt->isStmtBind) {
     if (TK_NK_ID == pTbName->type || (tbNameAfterDbName != NULL && *(tbNameAfterDbName + 1) != '?')) {
       // In SQL statements, the table name has already been specified.
-      parserWarn("0x%" PRIx64 " table name is specified in sql, ignore the table name in bind param", pCxt->pComCxt->requestId);
+      parserWarn("0x%" PRIx64 " table name is specified in sql, ignore the table name in bind param",
+                 pCxt->pComCxt->requestId);
     }
   }
 
@@ -2614,7 +2614,7 @@ static void destroySubTableHashElem(void* p) { taosMemoryFree(*(STableMeta**)p);
 
 static int32_t createVnodeModifOpStmt(SInsertParseContext* pCxt, bool reentry, SNode** pOutput) {
   SVnodeModifyOpStmt* pStmt = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_VNODE_MODIFY_STMT, (SNode**)&pStmt);
+  int32_t             code = nodesMakeNode(QUERY_NODE_VNODE_MODIFY_STMT, (SNode**)&pStmt);
   if (NULL == pStmt) {
     return code;
   }
@@ -2729,7 +2729,7 @@ static int32_t buildTagNameFromMeta(STableMeta* pMeta, SArray** pTagName) {
     return terrno;
   }
   SSchema* pSchema = getTableTagSchema(pMeta);
-  int32_t code = 0;
+  int32_t  code = 0;
   for (int32_t i = 0; i < pMeta->tableInfo.numOfTags; ++i) {
     if (NULL == taosArrayPush(*pTagName, pSchema[i].name)) {
       code = terrno;
@@ -2834,7 +2834,7 @@ static int32_t resetVnodeModifOpStmt(SInsertParseContext* pCxt, SQuery* pQuery)
       }
       if (NULL == pStmt->pTableBlockHashObj) {
         pStmt->pTableBlockHashObj =
-          taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
+            taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
       }
       if (NULL == pStmt->pVgroupsHashObj || NULL == pStmt->pTableBlockHashObj) {
         code = TSDB_CODE_OUT_OF_MEMORY;
@@ -2866,7 +2866,7 @@ static int32_t initInsertQuery(SInsertParseContext* pCxt, SCatalogReq* pCatalogR
 
 static int32_t setRefreshMeta(SQuery* pQuery) {
   SVnodeModifyOpStmt* pStmt = (SVnodeModifyOpStmt*)pQuery->pRoot;
-  int32_t code = 0;
+  int32_t             code = 0;
 
   if (taosHashGetSize(pStmt->pTableNameHashObj) > 0) {
     taosArrayDestroy(pQuery->pTableList);
@@ -3065,9 +3065,10 @@ int32_t parseInsertSql(SParseContext* pCxt, SQuery** pQuery, SCatalogReq* pCatal
                                  .forceUpdate = (NULL != pCatalogReq ? pCatalogReq->forceUpdate : false),
                                  .isStmtBind = pCxt->isStmtBind};
 
-  int32_t code = initInsertQuery(&context, pCatalogReq, pMetaData, pQuery);
+  int32_t             code = initInsertQuery(&context, pCatalogReq, pMetaData, pQuery);
+  SVnodeModifyOpStmt* pStmt = (SVnodeModifyOpStmt*)((*pQuery)->pRoot);
   if (TSDB_CODE_SUCCESS == code) {
-    code = parseInsertSqlImpl(&context, (SVnodeModifyOpStmt*)(*pQuery)->pRoot);
+    code = parseInsertSqlImpl(&context, pStmt);
   }
   if (TSDB_CODE_SUCCESS == code) {
     code = setNextStageInfo(&context, *pQuery, pCatalogReq);
@@ -3076,8 +3077,27 @@ int32_t parseInsertSql(SParseContext* pCxt, SQuery** pQuery, SCatalogReq* pCatal
       QUERY_EXEC_STAGE_SCHEDULE == (*pQuery)->execStage) {
     code = setRefreshMeta(*pQuery);
   }
-  insDestroyBoundColInfo(&context.tags);
 
+  if (pStmt->stbSyntax && TSDB_QUERY_HAS_TYPE(pStmt->insertType, TSDB_QUERY_TYPE_STMT_INSERT) &&
+      code == TSDB_CODE_TSC_INVALID_OPERATION) {
+    context.tags.numOfBound = pStmt->pStbRowsCxt->boundColsInfo.numOfBound;
+    context.tags.numOfCols = pStmt->pStbRowsCxt->boundColsInfo.numOfCols;
+    context.tags.hasBoundCols = pStmt->pStbRowsCxt->boundColsInfo.hasBoundCols;
+    context.tags.pColIndex = taosMemoryMalloc(sizeof(int16_t) * context.tags.numOfBound);
+    if (NULL == context.tags.pColIndex) {
+      return terrno;
+    }
+
+    (void)memcpy(context.tags.pColIndex, pStmt->pStbRowsCxt->boundColsInfo.pColIndex,
+                 sizeof(int16_t) * pStmt->pStbRowsCxt->boundColsInfo.numOfBound);
+    code = setStmtInfo(&context, pStmt);
+    if (TSDB_CODE_SUCCESS == code) {
+      insDestroyBoundColInfo(&context.tags);
+      return TSDB_CODE_TSC_INVALID_OPERATION;
+    }
+  }
+
+  insDestroyBoundColInfo(&context.tags);
   // if no data to insert, set emptyMode to avoid request server
   if (!context.needRequest) {
     (*pQuery)->execMode = QUERY_EXEC_MODE_EMPTY_RESULT;

source/libs/parser/src/parInsertStmt.c

@@ -242,7 +242,7 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, const ch
   }
 
   code = insBuildCreateTbReq(pDataBlock->pData->pCreateTbReq, tName, pTag, suid, sTableName, tagName,
-                      pDataBlock->pMeta->tableInfo.numOfTags, TSDB_DEFAULT_TABLE_TTL);
+                             pDataBlock->pMeta->tableInfo.numOfTags, TSDB_DEFAULT_TABLE_TTL);
   pTag = NULL;
 
 end:
@@ -594,7 +594,7 @@ int32_t qBindStmtTagsValue2(void* pBlock, void* boundTags, int64_t suid, const c
   }
 
   code = insBuildCreateTbReq(pDataBlock->pData->pCreateTbReq, tName, pTag, suid, sTableName, tagName,
-                      pDataBlock->pMeta->tableInfo.numOfTags, TSDB_DEFAULT_TABLE_TTL);
+                             pDataBlock->pMeta->tableInfo.numOfTags, TSDB_DEFAULT_TABLE_TTL);
   pTag = NULL;
 
 end:
@@ -886,7 +886,7 @@ _return:
 
 int32_t buildBoundFields(int32_t numOfBound, int16_t* boundColumns, SSchema* pSchema, int32_t* fieldNum,
                          TAOS_FIELD_E** fields, uint8_t timePrec) {
-  if (fields) {
+  if (fields != NULL) {
     *fields = taosMemoryCalloc(numOfBound, sizeof(TAOS_FIELD_E));
     if (NULL == *fields) {
       return terrno;
@@ -939,7 +939,7 @@ int32_t qBuildStmtColFields(void* pBlock, int32_t* fieldNum, TAOS_FIELD_E** fiel
   SSchema*       pSchema = getTableColumnSchema(pDataBlock->pMeta);
   if (pDataBlock->boundColsInfo.numOfBound <= 0) {
     *fieldNum = 0;
-    if (fields) {
+    if (fields != NULL) {
       *fields = NULL;
     }
 

source/libs/wal/src/walMeta.c

@@ -1058,6 +1058,8 @@ int32_t walSaveMeta(SWal* pWal) {
 
     TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _err);
   }
+  wInfo("vgId:%d, save meta file: %s, firstVer:%" PRId64 ", lastVer:%" PRId64, pWal->cfg.vgId, tmpFnameStr,
+        pWal->vers.firstVer, pWal->vers.lastVer);
 
   // rename it
   n = walBuildMetaName(pWal, metaVer + 1, fnameStr);
@@ -1155,8 +1157,8 @@ int32_t walLoadMeta(SWal* pWal) {
   (void)taosCloseFile(&pFile);
   taosMemoryFree(buf);
 
-  wInfo("vgId:%d, load meta file: %s, fileInfoSet size:%d", pWal->cfg.vgId, fnameStr,
+  wInfo("vgId:%d, load meta file: %s, firstVer:%" PRId64 ", lastVer:%" PRId64 ", fileInfoSet size:%d", pWal->cfg.vgId,
-        (int32_t)taosArrayGetSize(pWal->fileInfoSet));
+        fnameStr, pWal->vers.firstVer, pWal->vers.lastVer, (int32_t)taosArrayGetSize(pWal->fileInfoSet));
   printFileSet(pWal->fileInfoSet);
 
   TAOS_RETURN(code);

tests/script/api/makefile

@@ -25,6 +25,7 @@ exe:
 	gcc $(CFLAGS) ./stmt.c  -o $(ROOT)stmt $(LFLAGS)
 	gcc $(CFLAGS) ./stmt2.c  -o $(ROOT)stmt2 $(LFLAGS)
 	gcc $(CFLAGS) ./stmt2-example.c  -o $(ROOT)stmt2-example $(LFLAGS)
+	gcc $(CFLAGS) ./stmt2-get-fields.c  -o $(ROOT)stmt2-get-fields $(LFLAGS)
 	gcc $(CFLAGS) ./stmt2-nohole.c  -o $(ROOT)stmt2-nohole $(LFLAGS)
 	gcc $(CFLAGS) ./stmt-crash.c  -o $(ROOT)stmt-crash $(LFLAGS)
 
@@ -42,5 +43,6 @@ clean:
 	rm $(ROOT)stmt
 	rm $(ROOT)stmt2
 	rm $(ROOT)stmt2-example
+	rm $(ROOT)stmt2-get-fields
 	rm $(ROOT)stmt2-nohole
 	rm $(ROOT)stmt-crash

tests/script/api/stmt2-get-fields.c

@@ -0,0 +1,63 @@
+// TAOS standard API example. The same syntax as MySQL, but only a subet
+// to compile: gcc -o stmt2-get-fields stmt2-get-fields.c -ltaos
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "taos.h"
+
+void do_query(TAOS *taos, const char *sql) {
+  TAOS_RES *result = taos_query(taos, sql);
+  int       code = taos_errno(result);
+  if (code) {
+    printf("failed to query: %s, reason:%s\n", sql, taos_errstr(result));
+    taos_free_result(result);
+    return;
+  }
+  taos_free_result(result);
+}
+
+void do_stmt(TAOS *taos) {
+  do_query(taos, "drop database if exists db");
+  do_query(taos, "create database db");
+  do_query(taos,
+           "create table db.stb (ts timestamp, b binary(10)) tags(t1 "
+           "int, t2 binary(10))");
+
+  TAOS_STMT2_OPTION option = {0};
+  TAOS_STMT2       *stmt = taos_stmt2_init(taos, &option);
+  const char       *sql = "insert into db.stb(t1,t2,ts,b,tbname) values(?,?,?,?,?)";
+
+  int code = taos_stmt2_prepare(stmt, sql, 0);
+  if (code != 0) {
+    printf("failed to execute taos_stmt2_prepare. error:%s\n", taos_stmt2_error(stmt));
+    taos_stmt2_close(stmt);
+    return;
+  }
+
+  int             fieldNum = 0;
+  TAOS_FIELD_ALL *pFields = NULL;
+  code = taos_stmt2_get_all_fields(stmt, &fieldNum, &pFields);
+  if (code != 0) {
+    printf("failed get col,ErrCode: 0x%x, ErrMessage: %s.\n", code, taos_stmt2_error(stmt));
+  } else {
+    printf("col nums:%d\n", fieldNum);
+    for (int i = 0; i < fieldNum; i++) {
+      printf("field[%d]: %s,type:%d\n", i, pFields[i].name, pFields[i].field_type);
+    }
+  }
+
+  taos_stmt2_close(stmt);
+}
+
+int main() {
+  TAOS *taos = taos_connect("localhost", "root", "taosdata", "", 0);
+  if (!taos) {
+    printf("failed to connect to db, reason:%s\n", taos_errstr(taos));
+    exit(1);
+  }
+
+  do_stmt(taos);
+  taos_close(taos);
+  taos_cleanup();
+}

tests/system-test/7-tmq/tmqVnodeTransform-stb-removewal.py

@@ -18,7 +18,7 @@ from tmqCommon import *
 
 class TDTestCase:
 
-    updatecfgDict = {'sDebugFlag':143}
+    updatecfgDict = {'sDebugFlag':143, 'wDebugFlag':143}
     def __init__(self):
         self.vgroups    = 1
         self.ctbNum     = 10