Merge pull request #19547 from taosdata/fix/TD-21648

fix:add interface for odbc

include/client/taos.h

@@ -208,6 +208,7 @@ 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();
+DLL_EXPORT int         taos_get_current_db(TAOS *taos, char *database, int len, int *required);
 
 DLL_EXPORT const char *taos_errstr(TAOS_RES *res);
 DLL_EXPORT int         taos_errno(TAOS_RES *res);

include/common/systable.h

@@ -36,6 +36,7 @@ extern "C" {
 #define TSDB_INS_TABLE_STABLES           "ins_stables"
 #define TSDB_INS_TABLE_TABLES            "ins_tables"
 #define TSDB_INS_TABLE_TAGS              "ins_tags"
+#define TSDB_INS_TABLE_COLS              "ins_columns"
 #define TSDB_INS_TABLE_TABLE_DISTRIBUTED "ins_table_distributed"
 #define TSDB_INS_TABLE_USERS             "ins_users"
 #define TSDB_INS_TABLE_LICENCES          "ins_grants"

include/common/tmsg.h

@@ -115,6 +115,7 @@ typedef enum _mgmt_table {
   TSDB_MGMT_TABLE_STREAMS,
   TSDB_MGMT_TABLE_TABLE,
   TSDB_MGMT_TABLE_TAG,
+  TSDB_MGMT_TABLE_COL,
   TSDB_MGMT_TABLE_USER,
   TSDB_MGMT_TABLE_GRANTS,
   TSDB_MGMT_TABLE_VGROUP,
@@ -382,6 +383,13 @@ static FORCE_INLINE void tDeleteSSchemaWrapper(SSchemaWrapper* pSchemaWrapper) {
   }
 }
 
+static FORCE_INLINE void tDeleteSSchemaWrapperForHash(void* pSchemaWrapper) {
+  if (pSchemaWrapper != NULL && *(SSchemaWrapper**)pSchemaWrapper != NULL) {
+    taosMemoryFree((*(SSchemaWrapper**)pSchemaWrapper)->pSchema);
+    taosMemoryFree(*(SSchemaWrapper**)pSchemaWrapper);
+  }
+}
+
 static FORCE_INLINE int32_t taosEncodeSSchema(void** buf, const SSchema* pSchema) {
   int32_t tlen = 0;
   tlen += taosEncodeFixedI8(buf, pSchema->type);
@@ -1393,6 +1401,7 @@ typedef struct {
   char    db[TSDB_DB_FNAME_LEN];
   char    tb[TSDB_TABLE_NAME_LEN];
   char    user[TSDB_USER_LEN];
+  char    filterTb[TSDB_TABLE_NAME_LEN];
   int64_t showId;
 } SRetrieveTableReq;
 

source/client/src/clientMain.c

@@ -435,6 +435,22 @@ const char *taos_data_type(int type) {
       return "TSDB_DATA_TYPE_NCHAR";
     case TSDB_DATA_TYPE_JSON:
       return "TSDB_DATA_TYPE_JSON";
+    case TSDB_DATA_TYPE_UTINYINT:
+      return "TSDB_DATA_TYPE_UTINYINT";
+    case TSDB_DATA_TYPE_USMALLINT:
+      return "TSDB_DATA_TYPE_USMALLINT";
+    case TSDB_DATA_TYPE_UINT:
+      return "TSDB_DATA_TYPE_UINT";
+    case TSDB_DATA_TYPE_UBIGINT:
+      return "TSDB_DATA_TYPE_UBIGINT";
+    case TSDB_DATA_TYPE_VARBINARY:
+      return "TSDB_DATA_TYPE_VARBINARY";
+    case TSDB_DATA_TYPE_DECIMAL:
+      return "TSDB_DATA_TYPE_DECIMAL";
+    case TSDB_DATA_TYPE_BLOB:
+      return "TSDB_DATA_TYPE_BLOB";
+    case TSDB_DATA_TYPE_MEDIUMBLOB:
+      return "TSDB_DATA_TYPE_MEDIUMBLOB";
     default:
       return "UNKNOWN";
   }
@@ -675,6 +691,32 @@ const char *taos_get_server_info(TAOS *taos) {
   return pTscObj->sDetailVer;
 }
 
+int taos_get_current_db(TAOS *taos, char *database, int len, int *required) {
+  STscObj *pTscObj = acquireTscObj(*(int64_t *)taos);
+  if (pTscObj == NULL) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return -1;
+  }
+
+  int code = TSDB_CODE_SUCCESS;
+  taosThreadMutexLock(&pTscObj->mutex);
+  if(database == NULL || len <= 0){
+    if(required != NULL) *required = strlen(pTscObj->db) + 1;
+    terrno = TSDB_CODE_INVALID_PARA;
+    code = -1;
+  }else if(len < strlen(pTscObj->db) + 1){
+    tstrncpy(database, pTscObj->db, len);
+    if(required) *required = strlen(pTscObj->db) + 1;
+    terrno = TSDB_CODE_INVALID_PARA;
+    code = -1;
+  }else{
+    strcpy(database, pTscObj->db);
+    code = 0;
+  }
+  taosThreadMutexUnlock(&pTscObj->mutex);
+  return code;
+}
+
 static void destoryTablesReq(void *p) {
   STablesReq *pRes = (STablesReq *)p;
   taosArrayDestroy(pRes->pTables);

source/common/src/systable.c

@@ -178,6 +178,18 @@ static const SSysDbTableSchema userTagsSchema[] = {
     {.name = "tag_value", .bytes = TSDB_MAX_TAGS_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
 };
 
+static const SSysDbTableSchema userColsSchema[] = {
+    {.name = "table_name", .bytes = SYSTABLE_SCH_TABLE_NAME_LEN, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
+    {.name = "db_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
+    {.name = "table_type", .bytes = 21 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
+    {.name = "col_name", .bytes = TSDB_COL_NAME_LEN - 1 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
+    {.name = "col_type", .bytes = 32 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = false},
+    {.name = "col_length", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = false},
+    {.name = "col_precision", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = false},
+    {.name = "col_scale", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = false},
+    {.name = "col_nullable", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = false}
+};
+
 static const SSysDbTableSchema userTblDistSchema[] = {
     {.name = "db_name", .bytes = 32 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
     {.name = "table_name", .bytes = SYSTABLE_SCH_DB_NAME_LEN, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
@@ -294,6 +306,7 @@ static const SSysTableMeta infosMeta[] = {
     {TSDB_INS_TABLE_STABLES, userStbsSchema, tListLen(userStbsSchema), false},
     {TSDB_INS_TABLE_TABLES, userTblsSchema, tListLen(userTblsSchema), false},
     {TSDB_INS_TABLE_TAGS, userTagsSchema, tListLen(userTagsSchema), false},
+    {TSDB_INS_TABLE_COLS, userColsSchema, tListLen(userColsSchema), false},
     // {TSDB_INS_TABLE_TABLE_DISTRIBUTED, userTblDistSchema, tListLen(userTblDistSchema)},
     {TSDB_INS_TABLE_USERS, userUsersSchema, tListLen(userUsersSchema), false},
     {TSDB_INS_TABLE_LICENCES, grantsSchema, tListLen(grantsSchema), true},

source/common/src/tmsg.c

@@ -3191,6 +3191,7 @@ int32_t tSerializeSRetrieveTableReq(void *buf, int32_t bufLen, SRetrieveTableReq
   if (tEncodeI64(&encoder, pReq->showId) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->db) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->tb) < 0) return -1;
+  if (tEncodeCStr(&encoder, pReq->filterTb) < 0) return -1;
   if (tEncodeCStr(&encoder, pReq->user) < 0) return -1;
   tEndEncode(&encoder);
 
@@ -3207,6 +3208,7 @@ int32_t tDeserializeSRetrieveTableReq(void *buf, int32_t bufLen, SRetrieveTableR
   if (tDecodeI64(&decoder, &pReq->showId) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pReq->tb) < 0) return -1;
+  if (tDecodeCStrTo(&decoder, pReq->filterTb) < 0) return -1;
   if (tDecodeCStrTo(&decoder, pReq->user) < 0) return -1;
 
   tEndDecode(&decoder);

source/dnode/mnode/impl/inc/mndDef.h

@@ -444,6 +444,7 @@ typedef struct {
   STableMetaRsp* pMeta;
   bool           sysDbRsp;
   char           db[TSDB_DB_FNAME_LEN];
+  char           filterTb[TSDB_TABLE_NAME_LEN];
 } SShowObj;
 
 typedef struct {

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

@@ -19,6 +19,7 @@
 #include "systable.h"
 
 #define SHOW_STEP_SIZE 100
+#define SHOW_COLS_STEP_SIZE 4096
 
 static SShowObj *mndCreateShowObj(SMnode *pMnode, SRetrieveTableReq *pReq);
 static void      mndFreeShowObj(SShowObj *pShow);
@@ -76,6 +77,8 @@ static int32_t convertToRetrieveType(char *name, int32_t len) {
     type = TSDB_MGMT_TABLE_TABLE;
   } else if (strncasecmp(name, TSDB_INS_TABLE_TAGS, len) == 0) {
     type = TSDB_MGMT_TABLE_TAG;
+  } else if (strncasecmp(name, TSDB_INS_TABLE_COLS, len) == 0) {
+    type = TSDB_MGMT_TABLE_COL;
   } else if (strncasecmp(name, TSDB_INS_TABLE_TABLE_DISTRIBUTED, len) == 0) {
     //    type = TSDB_MGMT_TABLE_DIST;
   } else if (strncasecmp(name, TSDB_INS_TABLE_USERS, len) == 0) {
@@ -131,6 +134,7 @@ static SShowObj *mndCreateShowObj(SMnode *pMnode, SRetrieveTableReq *pReq) {
   showObj.pMnode = pMnode;
   showObj.type = convertToRetrieveType(pReq->tb, tListLen(pReq->tb));
   memcpy(showObj.db, pReq->db, TSDB_DB_FNAME_LEN);
+  strncpy(showObj.filterTb, pReq->filterTb, TSDB_TABLE_NAME_LEN);
 
   int32_t   keepTime = tsShellActivityTimer * 6 * 1000;
   SShowObj *pShow = taosCachePut(pMgmt->cache, &showId, sizeof(int64_t), &showObj, size, keepTime);
@@ -190,13 +194,15 @@ static int32_t mndProcessRetrieveSysTableReq(SRpcMsg *pReq) {
   int32_t    rowsToRead = SHOW_STEP_SIZE;
   int32_t    size = 0;
   int32_t    rowsRead = 0;
-
+  mDebug("mndProcessRetrieveSysTableReq start");
   SRetrieveTableReq retrieveReq = {0};
   if (tDeserializeSRetrieveTableReq(pReq->pCont, pReq->contLen, &retrieveReq) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     return -1;
   }
 
+  mDebug("mndProcessRetrieveSysTableReq tb:%s", retrieveReq.tb);
+
   if (retrieveReq.showId == 0) {
     STableMetaRsp *pMeta = taosHashGet(pMnode->infosMeta, retrieveReq.tb, strlen(retrieveReq.tb));
     if (pMeta == NULL) {
@@ -226,6 +232,9 @@ static int32_t mndProcessRetrieveSysTableReq(SRpcMsg *pReq) {
     }
   }
 
+  if(pShow->type == TSDB_MGMT_TABLE_COL){   // expend capacity for ins_columns
+    rowsToRead = SHOW_COLS_STEP_SIZE;
+  }
   ShowRetrieveFp retrieveFp = pMgmt->retrieveFps[pShow->type];
   if (retrieveFp == NULL) {
     mndReleaseShowObj(pShow, false);

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

@@ -43,6 +43,7 @@ static int32_t  mndProcessAlterStbReq(SRpcMsg *pReq);
 static int32_t  mndProcessDropStbReq(SRpcMsg *pReq);
 static int32_t  mndProcessTableMetaReq(SRpcMsg *pReq);
 static int32_t  mndRetrieveStb(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
+static int32_t  mndRetrieveStbCol(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 static void     mndCancelGetNextStb(SMnode *pMnode, void *pIter);
 static int32_t  mndProcessTableCfgReq(SRpcMsg *pReq);
 static int32_t  mndAlterStbImp(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SStbObj *pStb, bool needRsp,
@@ -69,10 +70,14 @@ int32_t mndInitStb(SMnode *pMnode) {
   mndSetMsgHandle(pMnode, TDMT_MND_TABLE_META, mndProcessTableMetaReq);
   mndSetMsgHandle(pMnode, TDMT_MND_TTL_TIMER, mndProcessTtlTimer);
   mndSetMsgHandle(pMnode, TDMT_MND_TABLE_CFG, mndProcessTableCfgReq);
+//  mndSetMsgHandle(pMnode, TDMT_MND_SYSTABLE_RETRIEVE, mndProcessRetrieveStbReq);
 
   mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_STB, mndRetrieveStb);
   mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_STB, mndCancelGetNextStb);
 
+  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_COL, mndRetrieveStbCol);
+  mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_COL, mndCancelGetNextStb);
+
   return sdbSetTable(pMnode->pSdb, table);
 }
 
@@ -2489,6 +2494,283 @@ void mndExtractTbNameFromStbFullName(const char *stbFullName, char *dst, int32_t
   }
 }
 
+//static int32_t mndProcessRetrieveStbReq(SRpcMsg *pReq) {
+//  SMnode    *pMnode = pReq->info.node;
+//  SShowMgmt *pMgmt = &pMnode->showMgmt;
+//  SShowObj  *pShow = NULL;
+//  int32_t    rowsToRead = SHOW_STEP_SIZE;
+//  int32_t    rowsRead = 0;
+//
+//  SRetrieveTableReq retrieveReq = {0};
+//  if (tDeserializeSRetrieveTableReq(pReq->pCont, pReq->contLen, &retrieveReq) != 0) {
+//    terrno = TSDB_CODE_INVALID_MSG;
+//    return -1;
+//  }
+//
+//  SMnode    *pMnode = pReq->info.node;
+//  SSdb      *pSdb = pMnode->pSdb;
+//  int32_t    numOfRows = 0;
+//  SDbObj    *pDb = NULL;
+//  ESdbStatus objStatus = 0;
+//
+//  SUserObj *pUser = mndAcquireUser(pMnode, pReq->info.conn.user);
+//  if (pUser == NULL) return 0;
+//  bool sysinfo = pUser->sysInfo;
+//
+//  // Append the information_schema database into the result.
+////  if (!pShow->sysDbRsp) {
+////    SDbObj infoschemaDb = {0};
+////    setInformationSchemaDbCfg(pMnode, &infoschemaDb);
+////    size_t numOfTables = 0;
+////    getVisibleInfosTablesNum(sysinfo, &numOfTables);
+////    mndDumpDbInfoData(pMnode, pBlock, &infoschemaDb, pShow, numOfRows, numOfTables, true, 0, 1);
+////
+////    numOfRows += 1;
+////
+////    SDbObj perfschemaDb = {0};
+////    setPerfSchemaDbCfg(pMnode, &perfschemaDb);
+////    numOfTables = 0;
+////    getPerfDbMeta(NULL, &numOfTables);
+////    mndDumpDbInfoData(pMnode, pBlock, &perfschemaDb, pShow, numOfRows, numOfTables, true, 0, 1);
+////
+////    numOfRows += 1;
+////    pShow->sysDbRsp = true;
+////  }
+//
+//  SSDataBlock* p = buildInfoSchemaTableMetaBlock(TSDB_INS_TABLE_COLS);
+//  blockDataEnsureCapacity(p, rowsToRead);
+//
+//  size_t               size = 0;
+//  const SSysTableMeta* pSysDbTableMeta = NULL;
+//
+//  getInfosDbMeta(&pSysDbTableMeta, &size);
+//  p->info.rows = buildDbColsInfoBlock(sysinfo, p, pSysDbTableMeta, size, TSDB_INFORMATION_SCHEMA_DB);
+//
+//  getPerfDbMeta(&pSysDbTableMeta, &size);
+//  p->info.rows = buildDbColsInfoBlock(sysinfo, p, pSysDbTableMeta, size, TSDB_PERFORMANCE_SCHEMA_DB);
+//
+//  blockDataDestroy(p);
+//
+//
+//  while (numOfRows < rowsToRead) {
+//    pShow->pIter = sdbFetchAll(pSdb, SDB_DB, pShow->pIter, (void **)&pDb, &objStatus, true);
+//    if (pShow->pIter == NULL) break;
+//    if (strncmp(retrieveReq.db, pDb->name, strlen(retrieveReq.db)) != 0){
+//      continue;
+//    }
+//    if (mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_READ_OR_WRITE_DB, pDb) != 0) {
+//      continue;
+//    }
+//
+//    while (numOfRows < rowsToRead) {
+//      pShow->pIter = sdbFetch(pSdb, SDB_STB, pShow->pIter, (void **)&pStb);
+//      if (pShow->pIter == NULL) break;
+//
+//      if (pDb != NULL && pStb->dbUid != pDb->uid) {
+//        sdbRelease(pSdb, pStb);
+//        continue;
+//      }
+//
+//      cols = 0;
+//
+//      SName name = {0};
+//      char  stbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
+//      mndExtractTbNameFromStbFullName(pStb->name, &stbName[VARSTR_HEADER_SIZE], TSDB_TABLE_NAME_LEN);
+//      varDataSetLen(stbName, strlen(&stbName[VARSTR_HEADER_SIZE]));
+//
+//      SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+//      colDataAppend(pColInfo, numOfRows, (const char *)stbName, false);
+//
+//      char db[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
+//      tNameFromString(&name, pStb->db, T_NAME_ACCT | T_NAME_DB);
+//      tNameGetDbName(&name, varDataVal(db));
+//      varDataSetLen(db, strlen(varDataVal(db)));
+//
+//      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+//      colDataAppend(pColInfo, numOfRows, (const char *)db, false);
+//
+//      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+//      colDataAppend(pColInfo, numOfRows, (const char *)&pStb->createdTime, false);
+//
+//      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+//      colDataAppend(pColInfo, numOfRows, (const char *)&pStb->numOfColumns, false);
+//
+//      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+//      colDataAppend(pColInfo, numOfRows, (const char *)&pStb->numOfTags, false);
+//
+//      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+//      colDataAppend(pColInfo, numOfRows, (const char *)&pStb->updateTime, false);  // number of tables
+//
+//      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+//      if (pStb->commentLen > 0) {
+//        char comment[TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0};
+//        STR_TO_VARSTR(comment, pStb->comment);
+//        colDataAppend(pColInfo, numOfRows, comment, false);
+//      } else if (pStb->commentLen == 0) {
+//        char comment[VARSTR_HEADER_SIZE + VARSTR_HEADER_SIZE] = {0};
+//        STR_TO_VARSTR(comment, "");
+//        colDataAppend(pColInfo, numOfRows, comment, false);
+//      } else {
+//        colDataAppendNULL(pColInfo, numOfRows);
+//      }
+//
+//      char watermark[64 + VARSTR_HEADER_SIZE] = {0};
+//      sprintf(varDataVal(watermark), "%" PRId64 "a,%" PRId64 "a", pStb->watermark[0], pStb->watermark[1]);
+//      varDataSetLen(watermark, strlen(varDataVal(watermark)));
+//
+//      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+//      colDataAppend(pColInfo, numOfRows, (const char *)watermark, false);
+//
+//      char maxDelay[64 + VARSTR_HEADER_SIZE] = {0};
+//      sprintf(varDataVal(maxDelay), "%" PRId64 "a,%" PRId64 "a", pStb->maxdelay[0], pStb->maxdelay[1]);
+//      varDataSetLen(maxDelay, strlen(varDataVal(maxDelay)));
+//
+//      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+//      colDataAppend(pColInfo, numOfRows, (const char *)maxDelay, false);
+//
+//      char    rollup[160 + VARSTR_HEADER_SIZE] = {0};
+//      int32_t rollupNum = (int32_t)taosArrayGetSize(pStb->pFuncs);
+//      char   *sep = ", ";
+//      int32_t sepLen = strlen(sep);
+//      int32_t rollupLen = sizeof(rollup) - VARSTR_HEADER_SIZE - 2;
+//      for (int32_t i = 0; i < rollupNum; ++i) {
+//        char *funcName = taosArrayGet(pStb->pFuncs, i);
+//        if (i) {
+//          strncat(varDataVal(rollup), sep, rollupLen);
+//          rollupLen -= sepLen;
+//        }
+//        strncat(varDataVal(rollup), funcName, rollupLen);
+//        rollupLen -= strlen(funcName);
+//      }
+//      varDataSetLen(rollup, strlen(varDataVal(rollup)));
+//
+//      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+//      colDataAppend(pColInfo, numOfRows, (const char *)rollup, false);
+//
+//      numOfRows++;
+//      sdbRelease(pSdb, pStb);
+//    }
+//
+//    if (pDb != NULL) {
+//      mndReleaseDb(pMnode, pDb);
+//    }
+//
+//    sdbRelease(pSdb, pDb);
+//  }
+//
+//  pShow->numOfRows += numOfRows;
+//  mndReleaseUser(pMnode, pUser);
+//
+//
+//
+//
+//
+//
+//
+//
+//  ShowRetrieveFp retrieveFp = pMgmt->retrieveFps[pShow->type];
+//  if (retrieveFp == NULL) {
+//    mndReleaseShowObj(pShow, false);
+//    terrno = TSDB_CODE_MSG_NOT_PROCESSED;
+//    mError("show:0x%" PRIx64 ", failed to retrieve data since %s", pShow->id, terrstr());
+//    return -1;
+//  }
+//
+//  mDebug("show:0x%" PRIx64 ", start retrieve data, type:%d", pShow->id, pShow->type);
+//  if (retrieveReq.user[0] != 0) {
+//    memcpy(pReq->info.conn.user, retrieveReq.user, TSDB_USER_LEN);
+//  } else {
+//    memcpy(pReq->info.conn.user, TSDB_DEFAULT_USER, strlen(TSDB_DEFAULT_USER) + 1);
+//  }
+//  if (retrieveReq.db[0] && mndCheckShowPrivilege(pMnode, pReq->info.conn.user, pShow->type, retrieveReq.db) != 0) {
+//    return -1;
+//  }
+//
+//  int32_t numOfCols = pShow->pMeta->numOfColumns;
+//
+//  SSDataBlock *pBlock = createDataBlock();
+//  for (int32_t i = 0; i < numOfCols; ++i) {
+//    SColumnInfoData idata = {0};
+//
+//    SSchema *p = &pShow->pMeta->pSchemas[i];
+//
+//    idata.info.bytes = p->bytes;
+//    idata.info.type = p->type;
+//    idata.info.colId = p->colId;
+//    blockDataAppendColInfo(pBlock, &idata);
+//  }
+//
+//  blockDataEnsureCapacity(pBlock, rowsToRead);
+//
+//  if (mndCheckRetrieveFinished(pShow)) {
+//    mDebug("show:0x%" PRIx64 ", read finished, numOfRows:%d", pShow->id, pShow->numOfRows);
+//    rowsRead = 0;
+//  } else {
+//    rowsRead = (*retrieveFp)(pReq, pShow, pBlock, rowsToRead);
+//    if (rowsRead < 0) {
+//      terrno = rowsRead;
+//      mDebug("show:0x%" PRIx64 ", retrieve completed", pShow->id);
+//      mndReleaseShowObj(pShow, true);
+//      blockDataDestroy(pBlock);
+//      return -1;
+//    }
+//
+//    pBlock->info.rows = rowsRead;
+//    mDebug("show:0x%" PRIx64 ", stop retrieve data, rowsRead:%d numOfRows:%d", pShow->id, rowsRead, pShow->numOfRows);
+//  }
+//
+//  size = sizeof(SRetrieveMetaTableRsp) + sizeof(int32_t) + sizeof(SSysTableSchema) * pShow->pMeta->numOfColumns +
+//         blockDataGetSize(pBlock) + blockDataGetSerialMetaSize(taosArrayGetSize(pBlock->pDataBlock));
+//
+//  SRetrieveMetaTableRsp *pRsp = rpcMallocCont(size);
+//  if (pRsp == NULL) {
+//    mndReleaseShowObj(pShow, false);
+//    terrno = TSDB_CODE_OUT_OF_MEMORY;
+//    mError("show:0x%" PRIx64 ", failed to retrieve data since %s", pShow->id, terrstr());
+//    blockDataDestroy(pBlock);
+//    return -1;
+//  }
+//
+//  pRsp->handle = htobe64(pShow->id);
+//
+//  if (rowsRead > 0) {
+//    char    *pStart = pRsp->data;
+//    SSchema *ps = pShow->pMeta->pSchemas;
+//
+//    *(int32_t *)pStart = htonl(pShow->pMeta->numOfColumns);
+//    pStart += sizeof(int32_t);  // number of columns
+//
+//    for (int32_t i = 0; i < pShow->pMeta->numOfColumns; ++i) {
+//      SSysTableSchema *pSchema = (SSysTableSchema *)pStart;
+//      pSchema->bytes = htonl(ps[i].bytes);
+//      pSchema->colId = htons(ps[i].colId);
+//      pSchema->type = ps[i].type;
+//
+//      pStart += sizeof(SSysTableSchema);
+//    }
+//
+//    int32_t len = blockEncode(pBlock, pStart, pShow->pMeta->numOfColumns);
+//  }
+//
+//  pRsp->numOfRows = htonl(rowsRead);
+//  pRsp->precision = TSDB_TIME_PRECISION_MILLI;  // millisecond time precision
+//  pReq->info.rsp = pRsp;
+//  pReq->info.rspLen = size;
+//
+//  if (rowsRead == 0 || rowsRead < rowsToRead) {
+//    pRsp->completed = 1;
+//    mDebug("show:0x%" PRIx64 ", retrieve completed", pShow->id);
+//    mndReleaseShowObj(pShow, true);
+//  } else {
+//    mDebug("show:0x%" PRIx64 ", retrieve not completed yet", pShow->id);
+//    mndReleaseShowObj(pShow, false);
+//  }
+//
+//  blockDataDestroy(pBlock);
+//  return TSDB_CODE_SUCCESS;
+//}
+
+
 static int32_t mndRetrieveStb(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
   SMnode  *pMnode = pReq->info.node;
   SSdb    *pSdb = pMnode->pSdb;
@@ -2599,6 +2881,187 @@ static int32_t mndRetrieveStb(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBloc
   return numOfRows;
 }
 
+static int32_t buildDbColsInfoBlock(const SSDataBlock* p, const SSysTableMeta* pSysDbTableMeta, size_t size,
+                                    const char* dbName, const char* tbName) {
+  char    tName[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
+  char    dName[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
+  char    typeName[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
+  int32_t numOfRows = p->info.rows;
+
+  STR_TO_VARSTR(dName, dbName);
+  STR_TO_VARSTR(typeName, "SYSTEM_TABLE");
+
+  for (int32_t i = 0; i < size; ++i) {
+    const SSysTableMeta* pm = &pSysDbTableMeta[i];
+//    if (pm->sysInfo) {
+//      continue;
+//    }
+    if(tbName[0] && strncmp(tbName, pm->name, TSDB_TABLE_NAME_LEN) != 0){
+      continue;
+    }
+
+    STR_TO_VARSTR(tName, pm->name);
+
+    for(int32_t j = 0; j < pm->colNum; j++){
+      // table name
+      SColumnInfoData* pColInfoData = taosArrayGet(p->pDataBlock, 0);
+      colDataAppend(pColInfoData, numOfRows, tName, false);
+
+      // database name
+      pColInfoData = taosArrayGet(p->pDataBlock, 1);
+      colDataAppend(pColInfoData, numOfRows, dName, false);
+
+      pColInfoData = taosArrayGet(p->pDataBlock, 2);
+      colDataAppend(pColInfoData, numOfRows, typeName, false);
+
+      // col name
+      char colName[TSDB_COL_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
+      STR_TO_VARSTR(colName, pm->schema[j].name);
+      pColInfoData = taosArrayGet(p->pDataBlock, 3);
+      colDataAppend(pColInfoData, numOfRows, colName, false);
+
+      // col type
+      int8_t colType = pm->schema[j].type;
+      pColInfoData = taosArrayGet(p->pDataBlock, 4);
+      char colTypeStr[VARSTR_HEADER_SIZE + 32];
+      int  colTypeLen = sprintf(varDataVal(colTypeStr), "%s", tDataTypes[colType].name);
+      if (colType == TSDB_DATA_TYPE_VARCHAR) {
+        colTypeLen += sprintf(varDataVal(colTypeStr) + colTypeLen, "(%d)",
+                              (int32_t)(pm->schema[j].bytes - VARSTR_HEADER_SIZE));
+      } else if (colType == TSDB_DATA_TYPE_NCHAR) {
+        colTypeLen += sprintf(
+            varDataVal(colTypeStr) + colTypeLen, "(%d)",
+            (int32_t)((pm->schema[j].bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE));
+      }
+      varDataSetLen(colTypeStr, colTypeLen);
+      colDataAppend(pColInfoData, numOfRows, (char*)colTypeStr, false);
+
+      pColInfoData = taosArrayGet(p->pDataBlock, 5);
+      colDataAppend(pColInfoData, numOfRows, (const char*)&pm->schema[j].bytes, false);
+      for (int32_t k = 6; k <= 8; ++k) {
+        pColInfoData = taosArrayGet(p->pDataBlock, k);
+        colDataAppendNULL(pColInfoData, numOfRows);
+      }
+
+      numOfRows += 1;
+    }
+  }
+
+  return numOfRows;
+}
+
+static int32_t buildSysDbColsInfo(SSDataBlock* p, char* db, char* tb) {
+  size_t               size = 0;
+  const SSysTableMeta* pSysDbTableMeta = NULL;
+
+  if(db[0] && strncmp(db, TSDB_INFORMATION_SCHEMA_DB, TSDB_DB_FNAME_LEN) != 0 && strncmp(db, TSDB_PERFORMANCE_SCHEMA_DB, TSDB_DB_FNAME_LEN) != 0){
+    return p->info.rows;
+  }
+
+  getInfosDbMeta(&pSysDbTableMeta, &size);
+  p->info.rows = buildDbColsInfoBlock(p, pSysDbTableMeta, size, TSDB_INFORMATION_SCHEMA_DB, tb);
+
+  getPerfDbMeta(&pSysDbTableMeta, &size);
+  p->info.rows = buildDbColsInfoBlock(p, pSysDbTableMeta, size, TSDB_PERFORMANCE_SCHEMA_DB, tb);
+
+  return p->info.rows;
+}
+
+static int32_t mndRetrieveStbCol(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
+  SMnode  *pMnode = pReq->info.node;
+  SSdb    *pSdb = pMnode->pSdb;
+  SStbObj *pStb = NULL;
+
+  int32_t numOfRows = buildSysDbColsInfo(pBlock, pShow->db, pShow->filterTb);
+  mDebug("mndRetrieveStbCol get system table cols, rows:%d, db:%s", numOfRows, pShow->db);
+  SDbObj *pDb = NULL;
+  if (strlen(pShow->db) > 0) {
+    pDb = mndAcquireDb(pMnode, pShow->db);
+    if (pDb == NULL) return terrno;
+  }
+
+  char    typeName[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
+  STR_TO_VARSTR(typeName, "SUPER_TABLE");
+  while (numOfRows < rows) {
+    pShow->pIter = sdbFetch(pSdb, SDB_STB, pShow->pIter, (void **)&pStb);
+    if (pShow->pIter == NULL) break;
+
+    if (pDb != NULL && pStb->dbUid != pDb->uid) {
+      sdbRelease(pSdb, pStb);
+      continue;
+    }
+
+    SName name = {0};
+    char  stbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
+    mndExtractTbNameFromStbFullName(pStb->name, &stbName[VARSTR_HEADER_SIZE], TSDB_TABLE_NAME_LEN);
+    if(pShow->filterTb[0] && strncmp(pShow->filterTb, &stbName[VARSTR_HEADER_SIZE], TSDB_TABLE_NAME_LEN) != 0){
+      sdbRelease(pSdb, pStb);
+      continue;
+    }
+    varDataSetLen(stbName, strlen(&stbName[VARSTR_HEADER_SIZE]));
+
+    mDebug("mndRetrieveStbCol get stable cols, stable name:%s, db:%s", pStb->name, pStb->db);
+
+    char db[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
+    tNameFromString(&name, pStb->db, T_NAME_ACCT | T_NAME_DB);
+    tNameGetDbName(&name, varDataVal(db));
+    varDataSetLen(db, strlen(varDataVal(db)));
+
+    for(int i = 0; i < pStb->numOfColumns; i++){
+      int32_t  cols = 0;
+      SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      colDataAppend(pColInfo, numOfRows, (const char *)stbName, false);
+
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      colDataAppend(pColInfo, numOfRows, (const char *)db, false);
+
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      colDataAppend(pColInfo, numOfRows, typeName, false);
+
+      // col name
+      char colName[TSDB_COL_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
+      STR_TO_VARSTR(colName, pStb->pColumns[i].name);
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      colDataAppend(pColInfo, numOfRows, colName, false);
+
+      // col type
+      int8_t colType = pStb->pColumns[i].type;
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      char colTypeStr[VARSTR_HEADER_SIZE + 32];
+      int  colTypeLen = sprintf(varDataVal(colTypeStr), "%s", tDataTypes[colType].name);
+      if (colType == TSDB_DATA_TYPE_VARCHAR) {
+        colTypeLen += sprintf(varDataVal(colTypeStr) + colTypeLen, "(%d)",
+                              (int32_t)(pStb->pColumns[i].bytes - VARSTR_HEADER_SIZE));
+      } else if (colType == TSDB_DATA_TYPE_NCHAR) {
+        colTypeLen += sprintf(
+            varDataVal(colTypeStr) + colTypeLen, "(%d)",
+            (int32_t)((pStb->pColumns[i].bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE));
+      }
+      varDataSetLen(colTypeStr, colTypeLen);
+      colDataAppend(pColInfo, numOfRows, (char*)colTypeStr, false);
+
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      colDataAppend(pColInfo, numOfRows, (const char*)&pStb->pColumns[i].bytes, false);
+      while(cols < pShow->numOfColumns) {
+        pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+        colDataAppendNULL(pColInfo, numOfRows);
+      }
+      numOfRows++;
+    }
+
+    sdbRelease(pSdb, pStb);
+  }
+
+  if (pDb != NULL) {
+    mndReleaseDb(pMnode, pDb);
+  }
+
+  pShow->numOfRows += numOfRows;
+  mDebug("mndRetrieveStbCol success, rows:%d, pShow->numOfRows:%d", numOfRows, pShow->numOfRows);
+
+  return numOfRows;
+}
+
 static void mndCancelGetNextStb(SMnode *pMnode, void *pIter) {
   SSdb *pSdb = pMnode->pSdb;
   sdbCancelFetch(pSdb, pIter);

source/dnode/vnode/inc/vnode.h

@@ -152,7 +152,7 @@ typedef struct SMTbCursor SMTbCursor;
 
 SMTbCursor *metaOpenTbCursor(SMeta *pMeta);
 void        metaCloseTbCursor(SMTbCursor *pTbCur);
-int32_t     metaTbCursorNext(SMTbCursor *pTbCur);
+int32_t     metaTbCursorNext(SMTbCursor *pTbCur, ETableType jumpTableType);
 #endif
 
 // tsdb

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

@@ -310,7 +310,7 @@ void metaCloseTbCursor(SMTbCursor *pTbCur) {
   }
 }
 
-int metaTbCursorNext(SMTbCursor *pTbCur) {
+int metaTbCursorNext(SMTbCursor *pTbCur, ETableType jumpTableType) {
   int    ret;
   void  *pBuf;
   STbCfg tbCfg;
@@ -324,7 +324,7 @@ int metaTbCursorNext(SMTbCursor *pTbCur) {
     tDecoderClear(&pTbCur->mr.coder);
 
     metaGetTableEntryByVersion(&pTbCur->mr, ((SUidIdxVal *)pTbCur->pVal)[0].version, *(tb_uid_t *)pTbCur->pKey);
-    if (pTbCur->mr.me.type == TSDB_SUPER_TABLE) {
+    if (pTbCur->mr.me.type == jumpTableType) {
       continue;
     }
 

source/libs/executor/src/sysscanoperator.c

@@ -140,6 +140,10 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo,
                                                 SMetaReader* smrChildTable, const char* dbname, const char* tableName,
                                                 int32_t* pNumOfRows, const SSDataBlock* dataBlock);
 
+static int32_t sysTableUserColsFillOneTableCols(const SSysTableScanInfo* pInfo, const char* dbname,
+                                                int32_t* pNumOfRows, const SSDataBlock* dataBlock,
+                                                char* tName, SSchemaWrapper* schemaRow, char* tableType);
+
 static void relocateAndFilterSysTagsScanResult(SSysTableScanInfo* pInfo, int32_t numOfRows, SSDataBlock* dataBlock,
                                                SFilterInfo* pFilterInfo);
 
@@ -413,6 +417,176 @@ static bool sysTableIsCondOnOneTable(SNode* pCond, char* condTable) {
   return false;
 }
 
+static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) {
+  qDebug("sysTableScanUserCols get cols start");
+  SExecTaskInfo*     pTaskInfo = pOperator->pTaskInfo;
+  SSysTableScanInfo* pInfo = pOperator->info;
+  if (pOperator->status == OP_EXEC_DONE) {
+    return NULL;
+  }
+
+  blockDataCleanup(pInfo->pRes);
+  int32_t numOfRows = 0;
+
+  SSDataBlock* dataBlock = buildInfoSchemaTableMetaBlock(TSDB_INS_TABLE_COLS);
+  blockDataEnsureCapacity(dataBlock, pOperator->resultInfo.capacity);
+
+  const char* db = NULL;
+  int32_t     vgId = 0;
+  vnodeGetInfo(pInfo->readHandle.vnode, &db, &vgId);
+
+  SName sn = {0};
+  char  dbname[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
+  tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB);
+
+  tNameGetDbName(&sn, varDataVal(dbname));
+  varDataSetLen(dbname, strlen(varDataVal(dbname)));
+
+  // optimize when sql like where table_name='tablename' and xxx.
+  if (pInfo->req.filterTb[0]) {
+    char tableName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
+    STR_TO_VARSTR(tableName, pInfo->req.filterTb);
+
+    SMetaReader smrTable = {0};
+    metaReaderInit(&smrTable, pInfo->readHandle.meta, 0);
+    int32_t code = metaGetTableEntryByName(&smrTable, pInfo->req.filterTb);
+    if (code != TSDB_CODE_SUCCESS) {
+      // terrno has been set by metaGetTableEntryByName, therefore, return directly
+      metaReaderClear(&smrTable);
+      blockDataDestroy(dataBlock);
+      pInfo->loadInfo.totalRows = 0;
+      return NULL;
+    }
+
+    if (smrTable.me.type == TSDB_SUPER_TABLE) {
+      metaReaderClear(&smrTable);
+      blockDataDestroy(dataBlock);
+      pInfo->loadInfo.totalRows = 0;
+      return NULL;
+    }
+
+    if (smrTable.me.type == TSDB_CHILD_TABLE) {
+      int64_t suid = smrTable.me.ctbEntry.suid;
+      metaReaderClear(&smrTable);
+      metaReaderInit(&smrTable, pInfo->readHandle.meta, 0);
+      code = metaGetTableEntryByUid(&smrTable, suid);
+      if (code != TSDB_CODE_SUCCESS) {
+        // terrno has been set by metaGetTableEntryByName, therefore, return directly
+        metaReaderClear(&smrTable);
+        blockDataDestroy(dataBlock);
+        pInfo->loadInfo.totalRows = 0;
+        return NULL;
+      }
+    }
+
+    char    typeName[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
+    SSchemaWrapper *schemaRow = NULL;
+    if(smrTable.me.type == TSDB_SUPER_TABLE){
+      schemaRow  = &smrTable.me.stbEntry.schemaRow;
+      STR_TO_VARSTR(typeName, "CHILD_TABLE");
+    }else if(smrTable.me.type == TSDB_NORMAL_TABLE){
+      schemaRow  = &smrTable.me.ntbEntry.schemaRow;
+      STR_TO_VARSTR(typeName, "NORMAL_TABLE");
+    }
+
+    sysTableUserColsFillOneTableCols(pInfo, dbname, &numOfRows, dataBlock, tableName, schemaRow, typeName);
+    metaReaderClear(&smrTable);
+
+    if (numOfRows > 0) {
+      relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo);
+      numOfRows = 0;
+    }
+    blockDataDestroy(dataBlock);
+    pInfo->loadInfo.totalRows += pInfo->pRes->info.rows;
+    setOperatorCompleted(pOperator);
+    return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes;
+  }
+
+  int32_t ret = 0;
+  if (pInfo->pCur == NULL) {
+    pInfo->pCur = metaOpenTbCursor(pInfo->readHandle.meta);
+  }
+
+  SHashObj *stableSchema = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
+  taosHashSetFreeFp(stableSchema, tDeleteSSchemaWrapperForHash);
+  while ((ret = metaTbCursorNext(pInfo->pCur, TSDB_TABLE_MAX)) == 0) {
+    char typeName[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
+    char tableName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
+
+    SSchemaWrapper *schemaRow = NULL;
+
+    if(pInfo->pCur->mr.me.type == TSDB_SUPER_TABLE){
+      qDebug("sysTableScanUserCols cursor get super table");
+      void *schema = taosHashGet(stableSchema, &pInfo->pCur->mr.me.uid, sizeof(int64_t));
+      if(schema == NULL){
+        SSchemaWrapper *schemaWrapper = tCloneSSchemaWrapper(&pInfo->pCur->mr.me.stbEntry.schemaRow);
+        taosHashPut(stableSchema, &pInfo->pCur->mr.me.uid, sizeof(int64_t), &schemaWrapper, POINTER_BYTES);
+      }
+      continue;
+    }else if (pInfo->pCur->mr.me.type == TSDB_CHILD_TABLE) {
+      qDebug("sysTableScanUserCols cursor get child table");
+      STR_TO_VARSTR(typeName, "CHILD_TABLE");
+      STR_TO_VARSTR(tableName, pInfo->pCur->mr.me.name);
+
+      int64_t suid = pInfo->pCur->mr.me.ctbEntry.suid;
+      void *schema = taosHashGet(stableSchema, &pInfo->pCur->mr.me.ctbEntry.suid, sizeof(int64_t));
+      if(schema != NULL){
+        schemaRow = *(SSchemaWrapper **)schema;
+      }else{
+        tDecoderClear(&pInfo->pCur->mr.coder);
+        int code = metaGetTableEntryByUid(&pInfo->pCur->mr, suid);
+        if (code != TSDB_CODE_SUCCESS) {
+          // terrno has been set by metaGetTableEntryByName, therefore, return directly
+          qError("sysTableScanUserCols get meta by suid:%"PRId64 " error, code:%d", suid, code);
+          blockDataDestroy(dataBlock);
+          pInfo->loadInfo.totalRows = 0;
+          taosHashCleanup(stableSchema);
+          return NULL;
+        }
+        schemaRow  = &pInfo->pCur->mr.me.stbEntry.schemaRow;
+      }
+    }else if(pInfo->pCur->mr.me.type == TSDB_NORMAL_TABLE){
+      qDebug("sysTableScanUserCols cursor get normal table");
+      schemaRow  = &pInfo->pCur->mr.me.ntbEntry.schemaRow;
+      STR_TO_VARSTR(typeName, "NORMAL_TABLE");
+      STR_TO_VARSTR(tableName, pInfo->pCur->mr.me.name);
+    }else{
+      qDebug("sysTableScanUserCols cursor get invalid table");
+      continue;
+    }
+
+    sysTableUserColsFillOneTableCols(pInfo, dbname, &numOfRows, dataBlock, tableName, schemaRow, typeName);
+
+    if (numOfRows >= pOperator->resultInfo.capacity) {
+      relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo);
+      numOfRows = 0;
+
+      if (pInfo->pRes->info.rows > 0) {
+        break;
+      }
+    }
+  }
+
+  taosHashCleanup(stableSchema);
+
+  if (numOfRows > 0) {
+    relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo);
+    numOfRows = 0;
+  }
+
+  blockDataDestroy(dataBlock);
+  if (ret != 0) {
+    metaCloseTbCursor(pInfo->pCur);
+    pInfo->pCur = NULL;
+    setOperatorCompleted(pOperator);
+  }
+
+  pInfo->loadInfo.totalRows += pInfo->pRes->info.rows;
+  qDebug("sysTableScanUserCols get cols success, rows:%" PRIu64, pInfo->loadInfo.totalRows);
+
+  return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes;
+}
+
 static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
   SExecTaskInfo*     pTaskInfo = pOperator->pTaskInfo;
   SSysTableScanInfo* pInfo = pOperator->info;
@@ -491,7 +665,7 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
     pInfo->pCur = metaOpenTbCursor(pInfo->readHandle.meta);
   }
 
-  while ((ret = metaTbCursorNext(pInfo->pCur)) == 0) {
+  while ((ret = metaTbCursorNext(pInfo->pCur, TSDB_SUPER_TABLE)) == 0) {
     if (pInfo->pCur->mr.me.type != TSDB_CHILD_TABLE) {
       continue;
     }
@@ -728,6 +902,67 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo,
   return TSDB_CODE_SUCCESS;
 }
 
+static int32_t sysTableUserColsFillOneTableCols(const SSysTableScanInfo* pInfo, const char* dbname,
+                                                int32_t* pNumOfRows, const SSDataBlock* dataBlock, char* tName,
+                                                SSchemaWrapper* schemaRow, char* tableType) {
+  if(schemaRow == NULL){
+    qError("sysTableUserColsFillOneTableCols schemaRow is NULL");
+    return TSDB_CODE_SUCCESS;
+  }
+  int32_t numOfRows = *pNumOfRows;
+
+  int32_t numOfCols = schemaRow->nCols;
+  for (int32_t i = 0; i < numOfCols; ++i) {
+    SColumnInfoData* pColInfoData = NULL;
+
+    // table name
+    pColInfoData = taosArrayGet(dataBlock->pDataBlock, 0);
+    colDataAppend(pColInfoData, numOfRows, tName, false);
+
+    // database name
+    pColInfoData = taosArrayGet(dataBlock->pDataBlock, 1);
+    colDataAppend(pColInfoData, numOfRows, dbname, false);
+
+    pColInfoData = taosArrayGet(dataBlock->pDataBlock, 2);
+    colDataAppend(pColInfoData, numOfRows, tableType, false);
+
+    // col name
+    char colName[TSDB_COL_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
+    STR_TO_VARSTR(colName, schemaRow->pSchema[i].name);
+    pColInfoData = taosArrayGet(dataBlock->pDataBlock, 3);
+    colDataAppend(pColInfoData, numOfRows, colName, false);
+
+    // col type
+    int8_t colType = schemaRow->pSchema[i].type;
+    pColInfoData = taosArrayGet(dataBlock->pDataBlock, 4);
+    char colTypeStr[VARSTR_HEADER_SIZE + 32];
+    int  colTypeLen = sprintf(varDataVal(colTypeStr), "%s", tDataTypes[colType].name);
+    if (colType == TSDB_DATA_TYPE_VARCHAR) {
+      colTypeLen += sprintf(varDataVal(colTypeStr) + colTypeLen, "(%d)",
+                            (int32_t)(schemaRow->pSchema[i].bytes - VARSTR_HEADER_SIZE));
+    } else if (colType == TSDB_DATA_TYPE_NCHAR) {
+      colTypeLen += sprintf(
+          varDataVal(colTypeStr) + colTypeLen, "(%d)",
+          (int32_t)((schemaRow->pSchema[i].bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE));
+    }
+    varDataSetLen(colTypeStr, colTypeLen);
+    colDataAppend(pColInfoData, numOfRows, (char*)colTypeStr, false);
+
+    pColInfoData = taosArrayGet(dataBlock->pDataBlock, 5);
+    colDataAppend(pColInfoData, numOfRows, (const char*)&schemaRow->pSchema[i].bytes, false);
+
+    for (int32_t j = 6; j <= 8; ++j) {
+      pColInfoData = taosArrayGet(dataBlock->pDataBlock, j);
+      colDataAppendNULL(pColInfoData, numOfRows);
+    }
+    ++numOfRows;
+  }
+
+  *pNumOfRows = numOfRows;
+
+  return TSDB_CODE_SUCCESS;
+}
+
 static SSDataBlock* buildInfoSchemaTableMetaBlock(char* tableName) {
   size_t               size = 0;
   const SSysTableMeta* pMeta = NULL;
@@ -1029,7 +1264,7 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) {
   char n[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
 
   int32_t ret = 0;
-  while ((ret = metaTbCursorNext(pInfo->pCur)) == 0) {
+  while ((ret = metaTbCursorNext(pInfo->pCur, TSDB_SUPER_TABLE)) == 0) {
     STR_TO_VARSTR(n, pInfo->pCur->mr.me.name);
 
     // table name
@@ -1315,12 +1550,19 @@ static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator) {
   if (pInfo->showRewrite) {
     getDBNameFromCondition(pInfo->pCondition, dbName);
     sprintf(pInfo->req.db, "%d.%s", pInfo->accountId, dbName);
+  }else if(strncasecmp(name, TSDB_INS_TABLE_COLS, TSDB_TABLE_FNAME_LEN) == 0){
+    getDBNameFromCondition(pInfo->pCondition, dbName);
+    if(dbName[0]) sprintf(pInfo->req.db, "%d.%s", pInfo->accountId, dbName);
+    sysTableIsCondOnOneTable(pInfo->pCondition, pInfo->req.filterTb);
   }
+
   SSDataBlock* pBlock = NULL;
   if (strncasecmp(name, TSDB_INS_TABLE_TABLES, TSDB_TABLE_FNAME_LEN) == 0) {
     pBlock = sysTableScanUserTables(pOperator);
   } else if (strncasecmp(name, TSDB_INS_TABLE_TAGS, TSDB_TABLE_FNAME_LEN) == 0) {
     pBlock = sysTableScanUserTags(pOperator);
+  } else if (strncasecmp(name, TSDB_INS_TABLE_COLS, TSDB_TABLE_FNAME_LEN) == 0 && pInfo->readHandle.mnd == NULL) {
+    pBlock = sysTableScanUserCols(pOperator);
   } else if (strncasecmp(name, TSDB_INS_TABLE_STABLES, TSDB_TABLE_FNAME_LEN) == 0 && pInfo->showRewrite &&
              IS_SYS_DBNAME(dbName)) {
     pBlock = sysTableScanUserSTables(pOperator);
@@ -1391,7 +1633,7 @@ static SSDataBlock* sysTableScanFromMNode(SOperatorInfo* pOperator, SSysTableSca
     tsem_wait(&pInfo->ready);
 
     if (pTaskInfo->code) {
-      qDebug("%s load meta data from mnode failed, totalRows:%" PRIu64 ", code:%s", GET_TASKID(pTaskInfo),
+      qError("%s load meta data from mnode failed, totalRows:%" PRIu64 ", code:%s", GET_TASKID(pTaskInfo),
              pInfo->loadInfo.totalRows, tstrerror(pTaskInfo->code));
       return NULL;
     }
@@ -1427,6 +1669,7 @@ static SSDataBlock* sysTableScanFromMNode(SOperatorInfo* pOperator, SSysTableSca
 
 SOperatorInfo* createSysTableScanOperatorInfo(void* readHandle, SSystemTableScanPhysiNode* pScanPhyNode,
                                               const char* pUser, SExecTaskInfo* pTaskInfo) {
+  int32_t code = TDB_CODE_SUCCESS;
   SSysTableScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SSysTableScanInfo));
   SOperatorInfo*     pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
   if (pInfo == NULL || pOperator == NULL) {
@@ -1437,7 +1680,7 @@ SOperatorInfo* createSysTableScanOperatorInfo(void* readHandle, SSystemTableScan
   SDataBlockDescNode* pDescNode = pScanNode->node.pOutputDataBlockDesc;
 
   int32_t num = 0;
-  int32_t code = extractColMatchInfo(pScanNode->pScanCols, pDescNode, &num, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo);
+  code = extractColMatchInfo(pScanNode->pScanCols, pDescNode, &num, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo);
   if (code != TSDB_CODE_SUCCESS) {
     goto _error;
   }
@@ -1513,7 +1756,8 @@ void destroySysScanOperator(void* param) {
 
   const char* name = tNameGetTableName(&pInfo->name);
   if (strncasecmp(name, TSDB_INS_TABLE_TABLES, TSDB_TABLE_FNAME_LEN) == 0 ||
-      strncasecmp(name, TSDB_INS_TABLE_TAGS, TSDB_TABLE_FNAME_LEN) == 0 || pInfo->pCur != NULL) {
+      strncasecmp(name, TSDB_INS_TABLE_TAGS, TSDB_TABLE_FNAME_LEN) == 0 ||
+      strncasecmp(name, TSDB_INS_TABLE_COLS, TSDB_TABLE_FNAME_LEN) == 0|| pInfo->pCur != NULL) {
     metaCloseTbCursor(pInfo->pCur);
     pInfo->pCur = NULL;
   }

source/libs/parser/src/parAstParser.c

@@ -166,7 +166,7 @@ static int32_t collectMetaKeyFromRealTableImpl(SCollectMetaKeyCxt* pCxt, const c
     code = reserveDnodeRequiredInCache(pCxt->pMetaCache);
   }
   if (TSDB_CODE_SUCCESS == code &&
-      (0 == strcmp(pTable, TSDB_INS_TABLE_TAGS) || 0 == strcmp(pTable, TSDB_INS_TABLE_TABLES)) &&
+      (0 == strcmp(pTable, TSDB_INS_TABLE_TAGS) || 0 == strcmp(pTable, TSDB_INS_TABLE_TABLES) || 0 == strcmp(pTable, TSDB_INS_TABLE_COLS)) &&
       QUERY_NODE_SELECT_STMT == nodeType(pCxt->pStmt)) {
     code = collectMetaKeyFromInsTags(pCxt);
   }

source/libs/parser/src/parTranslater.c

@@ -2210,7 +2210,7 @@ static int32_t dnodeToVgroupsInfo(SArray* pDnodes, SVgroupsInfo** pVgsInfo) {
 }
 
 static bool sysTableFromVnode(const char* pTable) {
-  return ((0 == strcmp(pTable, TSDB_INS_TABLE_TABLES)) || (0 == strcmp(pTable, TSDB_INS_TABLE_TAGS)));
+  return ((0 == strcmp(pTable, TSDB_INS_TABLE_TABLES)) || (0 == strcmp(pTable, TSDB_INS_TABLE_TAGS)) || (0 == strcmp(pTable, TSDB_INS_TABLE_COLS)));
 }
 
 static bool sysTableFromDnode(const char* pTable) { return 0 == strcmp(pTable, TSDB_INS_TABLE_DNODE_VARIABLES); }
@@ -2278,7 +2278,8 @@ static int32_t setVnodeSysTableVgroupList(STranslateContext* pCxt, SName* pName,
     ((SSelectStmt*)pCxt->pCurrStmt)->isEmptyResult = true;
   }
 
-  if (TSDB_CODE_SUCCESS == code && 0 == strcmp(pRealTable->table.tableName, TSDB_INS_TABLE_TABLES) && !hasUserDbCond) {
+  if (TSDB_CODE_SUCCESS == code && (0 == strcmp(pRealTable->table.tableName, TSDB_INS_TABLE_TABLES) && !hasUserDbCond) ||
+                                    0 == strcmp(pRealTable->table.tableName, TSDB_INS_TABLE_COLS)) {
     code = addMnodeToVgroupList(&pCxt->pParseCxt->mgmtEpSet, &pVgs);
   }
 
@@ -2376,7 +2377,8 @@ static bool isSingleTable(SRealTableNode* pRealTable) {
   int8_t tableType = pRealTable->pMeta->tableType;
   if (TSDB_SYSTEM_TABLE == tableType) {
     return 0 != strcmp(pRealTable->table.tableName, TSDB_INS_TABLE_TABLES) &&
-           0 != strcmp(pRealTable->table.tableName, TSDB_INS_TABLE_TAGS);
+           0 != strcmp(pRealTable->table.tableName, TSDB_INS_TABLE_TAGS) &&
+           0 != strcmp(pRealTable->table.tableName, TSDB_INS_TABLE_COLS);
   }
   return (TSDB_CHILD_TABLE == tableType || TSDB_NORMAL_TABLE == tableType);
 }

source/libs/parser/test/mockCatalog.cpp

@@ -102,6 +102,10 @@ void generateInformationSchema(MockCatalogService* mcs) {
       .addColumn("table_name", TSDB_DATA_TYPE_BINARY, TSDB_TABLE_NAME_LEN)
       .addColumn("db_name", TSDB_DATA_TYPE_BINARY, TSDB_DB_NAME_LEN)
       .done();
+  mcs->createTableBuilder(TSDB_INFORMATION_SCHEMA_DB, TSDB_INS_TABLE_COLS, TSDB_SYSTEM_TABLE, 2)
+      .addColumn("table_name", TSDB_DATA_TYPE_BINARY, TSDB_TABLE_NAME_LEN)
+      .addColumn("db_name", TSDB_DATA_TYPE_BINARY, TSDB_DB_NAME_LEN)
+      .done();
   mcs->createTableBuilder(TSDB_INFORMATION_SCHEMA_DB, TSDB_INS_TABLE_USER_PRIVILEGES, TSDB_SYSTEM_TABLE, 2)
       .addColumn("user_name", TSDB_DATA_TYPE_BINARY, TSDB_USER_LEN)
       .addColumn("privilege", TSDB_DATA_TYPE_BINARY, 10)

source/libs/planner/src/planPhysiCreater.c

@@ -609,7 +609,8 @@ static int32_t createSystemTableScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan*
   pScan->accountId = pCxt->pPlanCxt->acctId;
   pScan->sysInfo = pCxt->pPlanCxt->sysInfo;
   if (0 == strcmp(pScanLogicNode->tableName.tname, TSDB_INS_TABLE_TABLES) ||
-      0 == strcmp(pScanLogicNode->tableName.tname, TSDB_INS_TABLE_TAGS)) {
+      0 == strcmp(pScanLogicNode->tableName.tname, TSDB_INS_TABLE_TAGS) ||
+      0 == strcmp(pScanLogicNode->tableName.tname, TSDB_INS_TABLE_COLS)) {
     vgroupInfoToNodeAddr(pScanLogicNode->pVgroupList->vgroups, &pSubplan->execNode);
   } else {
     pSubplan->execNode.nodeId = MNODE_HANDLE;

tests/parallel_test/cases.task

@@ -1053,6 +1053,7 @@
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/out_of_order.py -Q 3
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/out_of_order.py -Q 4
 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/blockSMA.py -Q 4
+,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/odbc.py
 ,,y,system-test,./pytest.sh python3 ./test.py -f 99-TDcase/TD-21561.py -Q 4
 ,,y,system-test,./pytest.sh python3 ./test.py -f 99-TDcase/TD-20582.py
 

tests/script/tsim/query/sys_tbname.sim

@@ -53,7 +53,7 @@ endi
 
 sql select tbname from information_schema.ins_tables;
 print $rows $data00
-if $rows != 32 then
+if $rows != 33 then
 	return -1
 endi
 if $data00 != @ins_tables@ then

tests/system-test/2-query/odbc.py

+import taos
+import sys
+import datetime
+import inspect
+
+from util.log import *
+from util.sql import *
+from util.cases import *
+from util.common import tdCom
+
+class TDTestCase:
+
+    def init(self, conn, logSql, replicaVar=1):
+        self.replicaVar = int(replicaVar)
+        tdLog.debug(f"start to excute {__file__}")
+        tdSql.init(conn.cursor(), False)
+
+    def check_ins_cols(self):
+        tdSql.execute("create database if not exists db")
+        tdSql.execute("create table db.ntb (ts timestamp, c1 bool, c2 tinyint, c3 smallint, c4 int, c5 bigint, c6 tinyint unsigned, c7 smallint unsigned, c8 int unsigned, c9 bigint unsigned, c10 float, c11 double, c12 varchar(100), c13 nchar(100))")
+        tdSql.execute("create table db.stb (ts timestamp, c1 bool, c2 tinyint, c3 smallint, c4 int, c5 bigint, c6 tinyint unsigned, c7 smallint unsigned, c8 int unsigned, c9 bigint unsigned, c10 float, c11 double, c12 varchar(100), c13 nchar(100)) tags(t int)")
+        tdSql.execute("insert into db.ctb using db.stb tags(1) (ts, c1) values (now, 1)")
+
+        tdSql.query("select count(*) from information_schema.ins_columns")
+        tdSql.checkData(0, 0, 265)
+
+        tdSql.query("select * from information_schema.ins_columns where table_name = 'ntb'")
+        tdSql.checkRows(14)
+        tdSql.checkData(0, 2, "NORMAL_TABLE")
+
+
+        tdSql.query("select * from information_schema.ins_columns where table_name = 'stb'")
+        tdSql.checkRows(14)
+        tdSql.checkData(0, 2, "SUPER_TABLE")
+
+
+        tdSql.query("select db_name,table_type,col_name,col_type,col_length from information_schema.ins_columns where table_name = 'ctb'")
+        tdSql.checkRows(14)
+        tdSql.checkData(0, 0, "db")
+        tdSql.checkData(1, 1, "CHILD_TABLE")
+        tdSql.checkData(3, 2, "c3")
+        tdSql.checkData(4, 3, "INT")
+        tdSql.checkData(5, 4, 8)
+
+        tdSql.query("desc information_schema.ins_columns")
+        tdSql.checkRows(9)
+        tdSql.checkData(0, 0, "table_name")
+        tdSql.checkData(5, 0, "col_length")
+        tdSql.checkData(1, 2, 64)
+
+    def check_get_db_name(self):
+        buildPath = tdCom.getBuildPath()
+        cmdStr = '%s/build/bin/get_db_name_test'%(buildPath)
+        tdLog.info(cmdStr)
+        ret = os.system(cmdStr)
+        if ret != 0:
+            tdLog.exit("sml_test get_db_name_test != 0")
+
+    def run(self):  # sourcery skip: extract-duplicate-method, remove-redundant-fstring
+        tdSql.prepare(replica = self.replicaVar)
+
+        tdLog.printNoPrefix("==========start check_ins_cols run ...............")
+        self.check_ins_cols()
+        tdLog.printNoPrefix("==========end check_ins_cols run ...............")
+
+        tdLog.printNoPrefix("==========start check_get_db_name run ...............")
+        self.check_get_db_name()
+        tdLog.printNoPrefix("==========end check_get_db_name run ...............")
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success(f"{__file__} successfully executed")
+
+
+tdCases.addLinux(__file__, TDTestCase())
+tdCases.addWindows(__file__, TDTestCase())

utils/test/c/CMakeLists.txt

@@ -4,6 +4,7 @@ add_executable(tmq_sim tmqSim.c)
 add_executable(create_table createTable.c)
 add_executable(tmq_taosx_ci tmq_taosx_ci.c)
 add_executable(sml_test sml_test.c)
+add_executable(get_db_name_test get_db_name_test.c)
 target_link_libraries(
     create_table
     PUBLIC taos_static
@@ -40,3 +41,11 @@ target_link_libraries(
     PUBLIC common
     PUBLIC os
 )
+
+target_link_libraries(
+    get_db_name_test
+    PUBLIC taos_static
+    PUBLIC util
+    PUBLIC common
+    PUBLIC os
+)

utils/test/c/get_db_name_test.c

+/*
+ * 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/>.
+ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include "taos.h"
+#include "types.h"
+#include "tlog.h"
+
+int get_db_test() {
+  TAOS *taos = taos_connect("localhost", "root", "taosdata", NULL, 0);
+
+  TAOS_RES *pRes = taos_query(taos, "create database if not exists sml_db vgroups 2");
+  taos_free_result(pRes);
+
+  pRes = taos_query(taos, "use sml_db");
+  int code = taos_errno(pRes);
+  taos_free_result(pRes);
+  ASSERT(code == 0);
+
+  code = taos_get_current_db(taos, NULL, 0, NULL);
+  ASSERT(code != 0);
+
+  int required = 0;
+  code = taos_get_current_db(taos, NULL, 0, &required);
+  ASSERT(code != 0);
+  ASSERT(required == 7);
+
+  char database[10] = {0};
+  code = taos_get_current_db(taos, database, 3, &required);
+  ASSERT(code != 0);
+  ASSERT(required == 7);
+  ASSERT(strcpy(database, "sm"));
+
+  char database1[10] = {0};
+  code = taos_get_current_db(taos, database1, 10, &required);
+  ASSERT(code == 0);
+  ASSERT(strcpy(database1, "sml_db"));
+
+  taos_close(taos);
+
+  return code;
+}
+
+int main(int argc, char *argv[]) {
+  int ret = 0;
+  ret = get_db_test();
+  ASSERT(!ret);
+  return ret;
+}