fix desc crash

source/common/src/tcol.c

@@ -16,15 +16,14 @@
 #include "tcol.h"
 #include "tutil.h"
 
-const char* supportedEncode[4] = {TSDB_COLUMN_ENCODE_SIMPLE8B, TSDB_COLUMN_ENCODE_XOR,
+const char* supportedEncode[4] = {TSDB_COLUMN_ENCODE_SIMPLE8B, TSDB_COLUMN_ENCODE_XOR, TSDB_COLUMN_ENCODE_RLE,
-                                  TSDB_COLUMN_ENCODE_RLE, TSDB_COLUMN_ENCODE_DISABLED};
+                                  TSDB_COLUMN_ENCODE_DISABLED};
 
 const char* supportedCompress[6] = {TSDB_COLUMN_COMPRESS_LZ4,  TSDB_COLUMN_COMPRESS_TSZ,
-                                    TSDB_COLUMN_COMPRESS_XZ,      TSDB_COLUMN_COMPRESS_ZLIB, TSDB_COLUMN_COMPRESS_ZSTD,
+                                    TSDB_COLUMN_COMPRESS_XZ,   TSDB_COLUMN_COMPRESS_ZLIB,
-                                    TSDB_COLUMN_COMPRESS_DISABLED};
+                                    TSDB_COLUMN_COMPRESS_ZSTD, TSDB_COLUMN_COMPRESS_DISABLED};
 
-const char* supportedLevel[3] = {TSDB_COLUMN_LEVEL_HIGH, TSDB_COLUMN_LEVEL_MEDIUM,
+const char* supportedLevel[3] = {TSDB_COLUMN_LEVEL_HIGH, TSDB_COLUMN_LEVEL_MEDIUM, TSDB_COLUMN_LEVEL_LOW};
-                                 TSDB_COLUMN_LEVEL_LOW};
 
 const int supportedEncodeNum = sizeof(supportedEncode) / sizeof(char*);
 const int supportedCompressNum = sizeof(supportedCompress) / sizeof(char*);
@@ -60,12 +59,10 @@ uint8_t getDefaultEncode(uint8_t type) {
       return TSDB_COLVAL_ENCODE_SIMPLE8B;
   }
 }
-const char* getDefaultEncodeStr(uint8_t type) {
+const char* getDefaultEncodeStr(uint8_t type) { return columnEncodeStr(getDefaultEncode(type)); }
-  return columnEncodeStr(getDefaultEncode(type));
-}
 
 uint16_t getDefaultCompress(uint8_t type) {
- switch (type) {
+  switch (type) {
     case TSDB_DATA_TYPE_NULL:
     case TSDB_DATA_TYPE_BOOL:
     case TSDB_DATA_TYPE_TINYINT:
@@ -94,11 +91,9 @@ uint16_t getDefaultCompress(uint8_t type) {
       return TSDB_COLVAL_COMPRESS_LZ4;
   }
 }
-const char* getDefaultCompressStr(uint8_t type) {
+const char* getDefaultCompressStr(uint8_t type) { return columnCompressStr(getDefaultCompress(type)); }
-  return columnCompressStr(getDefaultCompress(type));
-}
 
-uint8_t getDefaultLevel(uint8_t type) { return TSDB_COLVAL_LEVEL_MEDIUM; }
+uint8_t     getDefaultLevel(uint8_t type) { return TSDB_COLVAL_LEVEL_MEDIUM; }
 const char* getDefaultLevelStr(uint8_t type) { return columnLevelStr(getDefaultLevel(type)); }
 
 const char* columnEncodeStr(uint8_t type) {
@@ -218,7 +213,7 @@ const char* columnLevelStr(uint8_t type) {
   return level;
 }
 
-bool checkColumnEncode(char encode[TSDB_CL_COMPRESS_OPTION_LEN]){
+bool checkColumnEncode(char encode[TSDB_CL_COMPRESS_OPTION_LEN]) {
   if (0 == strlen(encode)) return true;
   strtolower(encode, encode);
   for (int i = 0; i < supportedEncodeNum; ++i) {
@@ -296,6 +291,4 @@ void setColCompressByOption(uint32_t* compress, uint8_t encode, uint16_t compres
   return;
 }
 
-bool useCompress(uint8_t tableType) {
+bool useCompress(uint8_t tableType) { return TSDB_SUPER_TABLE == tableType || TSDB_NORMAL_TABLE == tableType; }
-  return  TSDB_SUPER_TABLE == tableType || TSDB_NORMAL_TABLE == tableType;
-}

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

@@ -17,6 +17,9 @@
 
 int meteEncodeColCmprEntry(SEncoder *pCoder, const SMetaEntry *pME) {
   const SColCmprWrapper *pw = &pME->colCmpr;
+  if (tEncodeI32v(pCoder, pw->nCols) < 0) return -1;
+  if (tEncodeI32v(pCoder, pw->version) < 0) return -1;
+
   for (int32_t i = 0; i < pw->nCols; i++) {
     SColCmpr *p = &pw->pColCmpr[i];
     if (tEncodeI16v(pCoder, p->id) < 0) return -1;

source/dnode/vnode/src/vnd/vnodeQuery.c

@@ -33,6 +33,20 @@ void vnodeQueryPreClose(SVnode *pVnode) { qWorkerStopAllTasks((void *)pVnode->pQ
 
 void vnodeQueryClose(SVnode *pVnode) { qWorkerDestroy((void **)&pVnode->pQuery); }
 
+int32_t fillTableColCmpr(SMetaReader *reader, SSchemaExt *pExt, int32_t numOfCol) {
+  int8_t tblType = reader->me.type;
+  if (useCompress(tblType)) {
+    SColCmprWrapper *p = &(reader->me.colCmpr);
+    ASSERT(numOfCol == p->nCols);
+    for (int i = 0; i < p->nCols; i++) {
+      SColCmpr *pCmpr = &p->pColCmpr[i];
+      pExt[i].colId = pCmpr->id;
+      pExt[i].compress = pCmpr->alg;
+    }
+  }
+  return 0;
+}
+
 int vnodeGetTableMeta(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
   STableInfoReq  infoReq = {0};
   STableMetaRsp  metaRsp = {0};
@@ -99,11 +113,22 @@ int vnodeGetTableMeta(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
   metaRsp.sversion = schema.version;
   metaRsp.tversion = schemaTag.version;
   metaRsp.pSchemas = (SSchema *)taosMemoryMalloc(sizeof(SSchema) * (metaRsp.numOfColumns + metaRsp.numOfTags));
+  metaRsp.pSchemaExt = (SSchemaExt *)taosMemoryCalloc(metaRsp.numOfColumns, sizeof(SSchemaExt));
 
   memcpy(metaRsp.pSchemas, schema.pSchema, sizeof(SSchema) * schema.nCols);
   if (schemaTag.nCols) {
     memcpy(metaRsp.pSchemas + schema.nCols, schemaTag.pSchema, sizeof(SSchema) * schemaTag.nCols);
   }
+  if (metaRsp.pSchemaExt) {
+    code = fillTableColCmpr(&mer1, metaRsp.pSchemaExt, metaRsp.numOfColumns);
+    if (code < 0) {
+      code = TSDB_CODE_INVALID_MSG;
+      goto _exit;
+    }
+  } else {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _exit;
+  }
 
   // encode and send response
   rspLen = tSerializeSTableMetaRsp(NULL, 0, &metaRsp);
@@ -126,6 +151,7 @@ int vnodeGetTableMeta(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
 
 _exit:
   taosMemoryFree(metaRsp.pSchemas);
+  taosMemoryFree(metaRsp.pSchemaExt);
 _exit2:
   metaReaderClear(&mer2);
 _exit3:

source/libs/parser/src/parUtil.c

@@ -282,17 +282,16 @@ STableMeta* tableMetaDup(const STableMeta* pTableMeta) {
     return NULL;
   }
 
-  size_t schemaExtSize = 0;
+  bool   hasSchemaExt = pTableMeta->schemaExt == NULL ? false : true;
-  if (useCompress(pTableMeta->tableType)) {
+  size_t schemaExtSize = hasSchemaExt ? pTableMeta->tableInfo.numOfColumns * sizeof(SSchemaExt) : 0;
-    schemaExtSize = pTableMeta->tableInfo.numOfColumns * sizeof(SSchemaExt);
+
-  }
   size_t      size = sizeof(STableMeta) + numOfFields * sizeof(SSchema);
   STableMeta* p = taosMemoryMalloc(size + schemaExtSize);
 
   if (NULL == p) return NULL;
 
   memcpy(p, pTableMeta, size);
-  if (useCompress(pTableMeta->tableType)) {
+  if (hasSchemaExt) {
     SSchemaExt* pSchemaExt = (SSchemaExt*)((char*)p + size);
     p->schemaExt = pSchemaExt;
     memcpy(pSchemaExt, pTableMeta->schemaExt, schemaExtSize);

source/libs/qcom/src/querymsg.c

@@ -426,6 +426,8 @@ int32_t queryCreateTableMetaFromMsg(STableMetaRsp *msg, bool isStb, STableMeta *
   if (useCompress(msg->tableType)) {
     pTableMeta->schemaExt = pSchemaExt;
     memcpy(pSchemaExt, msg->pSchemaExt, schemaExtSize);
+  } else {
+    pTableMeta->schemaExt = NULL;
   }
 
   for (int32_t i = 0; i < msg->numOfColumns; ++i) {