col compress sql parse

include/common/tcol.h

@@ -0,0 +1,82 @@
+/*
+ * 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 "taosdef.h"
+
+#ifndef _TD_TCOL_H_
+#define _TD_TCOL_H_
+
+#define TSDB_COLUMN_ENCODE_UNKNOWN  "unknown"
+#define TSDB_COLUMN_ENCODE_SIMPLE8B "simple8b"
+#define TSDB_COLUMN_ENCODE_XOR      "xor"
+#define TSDB_COLUMN_ENCODE_RLE      "rle"
+#define TSDB_COLUMN_ENCODE_DISABLED "disabled"
+
+#define TSDB_COLUMN_COMPRESS_UNKNOWN  "unknown"
+#define TSDB_COLUMN_COMPRESS_LZ4      "lz4"
+#define TSDB_COLUMN_COMPRESS_ZLIB     "zlib"
+#define TSDB_COLUMN_COMPRESS_ZSTD     "zstd"
+#define TSDB_COLUMN_COMPRESS_TSZ      "tsz"
+#define TSDB_COLUMN_COMPRESS_XZ       "xz"
+#define TSDB_COLUMN_COMPRESS_DISABLED "disabled"
+
+#define TSDB_COLUMN_LEVEL_UNKNOWN "unknown"
+#define TSDB_COLUMN_LEVEL_HIGH    "high"
+#define TSDB_COLUMN_LEVEL_MEDIUM  "medium"
+#define TSDB_COLUMN_LEVEL_LOW     "low"
+
+#define TSDB_COLVAL_ENCODE_SIMPLE8B   1
+#define TSDB_COLVAL_ENCODE_XOR        2
+#define TSDB_COLVAL_ENCODE_RLE        3
+#define TSDB_COLVAL_ENCODE_DISABLED   0xff
+#define TSDB_COLVAL_COMPRESS_LZ4      1
+#define TSDB_COLVAL_COMPRESS_ZLIB     2
+#define TSDB_COLVAL_COMPRESS_ZSTD     3
+#define TSDB_COLVAL_COMPRESS_TSZ      4
+#define TSDB_COLVAL_COMPRESS_XZ       5
+#define TSDB_COLVAL_COMPRESS_DISABLED 0xff
+#define TSDB_COLVAL_LEVEL_HIGH        1
+#define TSDB_COLVAL_LEVEL_MEDIUM      2
+#define TSDB_COLVAL_LEVEL_LOW         3
+
+#define TSDB_CL_COMMENT_LEN 1025
+#define TSDB_CL_COMPRESS_OPTION_LEN 32
+
+extern const char* supportedEncode[5];
+extern const char* supportedCompress[7];
+extern const char* supportedLevel[4];
+
+uint8_t     getDefaultEncode(uint8_t type);
+uint16_t    getDefaultCompress(uint8_t type);
+uint8_t     getDefaultLevel(uint8_t type);
+const char* getDefaultEncodeStr(uint8_t type);
+const char* getDefaultCompressStr(uint8_t type);
+const char* getDefaultLevelStr(uint8_t type);
+
+const char* columnEncodeStr(uint8_t type);
+const char* columnCompressStr(uint16_t type);
+const char* columnLevelStr(uint8_t type);
+uint8_t     columnLevelVal(const char* level);
+uint8_t     columnEncodeVal(const char* encode);
+uint16_t    columnCompressVal(const char* compress);
+
+bool checkColumnEncode(uint8_t type, char encode[TSDB_CL_COMPRESS_OPTION_LEN]);
+bool checkColumnCompress(uint8_t type, char compress[TSDB_CL_COMPRESS_OPTION_LEN]);
+bool checkColumnLevel(uint8_t type, char level[TSDB_CL_COMPRESS_OPTION_LEN]);
+
+void setColEncode(uint32_t* compress, uint8_t encode);
+void setColCompress(uint32_t* compress, uint16_t compressType);
+void setColLevel(uint32_t* compress, uint8_t level);
+
+#endif /*_TD_TCOL_H_*/

include/common/tmsg.h

@@ -26,6 +26,7 @@
 #include "tname.h"
 #include "trow.h"
 #include "tuuid.h"
+#include "tcol.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -246,6 +247,7 @@ typedef enum ENodeType {
   QUERY_NODE_HINT,
   QUERY_NODE_VIEW,
   QUERY_NODE_COUNT_WINDOW,
+  QUERY_NODE_COLUMN_OPTIONS,
 
   // Statement nodes are used in parser and planner module.
   QUERY_NODE_SET_OPERATOR = 100,
@@ -456,6 +458,13 @@ typedef struct SField {
   int8_t  flags;
   int32_t bytes;
 } SField;
+typedef struct SFieldWithOptions {
+  char     name[TSDB_COL_NAME_LEN];
+  uint8_t  type;
+  int8_t   flags;
+  int32_t  bytes;
+  uint32_t compress;
+} SFieldWithOptions;
 
 typedef struct SRetention {
   int64_t freq;
@@ -832,7 +841,7 @@ typedef struct {
   int32_t  commentLen;
   int32_t  ast1Len;
   int32_t  ast2Len;
-  SArray*  pColumns;  // array of SField
+  SArray*  pColumns;  // array of SFieldWithOptions
   SArray*  pTags;     // array of SField
   SArray*  pFuncs;
   char*    pComment;
@@ -4100,6 +4109,9 @@ int32_t tSerializeSViewMetaRsp(void* buf, int32_t bufLen, const SViewMetaRsp* pR
 int32_t tDeserializeSViewMetaRsp(void* buf, int32_t bufLen, SViewMetaRsp* pRsp);
 void    tFreeSViewMetaRsp(SViewMetaRsp* pRsp);
 
+void setDefaultOptionsForField(SFieldWithOptions *field);
+void setFieldWithOptions(SFieldWithOptions *fieldWithOptions, SField* field);
+
 #pragma pack(pop)
 
 #ifdef __cplusplus

include/common/ttokendef.h

@@ -367,7 +367,9 @@
 #define TK_VALUES                         348
 #define TK_VARIABLE                       349
 #define TK_WAL                            350
-
+#define TK_ENCODE                         351
+#define TK_COMPRESS                       352
+#define TK_LEVEL                          353
 
 #define TK_NK_SPACE         600
 #define TK_NK_COMMENT       601

include/libs/nodes/cmdnodes.h

@@ -162,11 +162,20 @@ typedef struct STableOptions {
   SNodeList* pSma;
 } STableOptions;
 
+typedef struct SColumnOptions {
+  ENodeType  type;
+  bool       commentNull;
+  char       comment[TSDB_CL_COMMENT_LEN];
+  char       encode[TSDB_CL_COMPRESS_OPTION_LEN];
+  char       compress[TSDB_CL_COMPRESS_OPTION_LEN];
+  char       compressLevel[TSDB_CL_COMPRESS_OPTION_LEN];
+} SColumnOptions;
 typedef struct SColumnDefNode {
   ENodeType       type;
   char            colName[TSDB_COL_NAME_LEN];
   SDataType       dataType;
   char            comments[TSDB_TB_COMMENT_LEN];
+  SColumnOptions* pOptions;
   bool            sma;
 } SColumnDefNode;
 
@@ -226,6 +235,7 @@ typedef struct SAlterTableStmt {
   STableOptions*  pOptions;
   SDataType       dataType;
   SValueNode*     pVal;
+  SColumnOptions* pColOptions;
 } SAlterTableStmt;
 
 typedef struct SCreateUserStmt {

include/util/taoserror.h

@@ -172,7 +172,9 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_TSC_NO_EXEC_NODE              TAOS_DEF_ERROR_CODE(0, 0X022E)
 #define TSDB_CODE_TSC_NOT_STABLE_ERROR          TAOS_DEF_ERROR_CODE(0, 0X022F)
 #define TSDB_CODE_TSC_STMT_CACHE_ERROR          TAOS_DEF_ERROR_CODE(0, 0X0230)
-#define TSDB_CODE_TSC_INTERNAL_ERROR            TAOS_DEF_ERROR_CODE(0, 0X0231)
+#define TSDB_CODE_TSC_ENCODE_PARAM_ERROR        TAOS_DEF_ERROR_CODE(0, 0X0231)
+#define TSDB_CODE_TSC_ENCODE_PARAM_NULL         TAOS_DEF_ERROR_CODE(0, 0X0232)
+#define TSDB_CODE_TSC_INTERNAL_ERROR            TAOS_DEF_ERROR_CODE(0, 0X02FF)
 
 // mnode-common
 #define TSDB_CODE_MND_REQ_REJECTED              TAOS_DEF_ERROR_CODE(0, 0x0300)

source/client/src/clientRawBlockWrite.c

@@ -710,11 +710,13 @@ static int32_t taosCreateStb(TAOS* taos, void* meta, int32_t metaLen) {
     goto end;
   }
   // build create stable
-  pReq.pColumns = taosArrayInit(req.schemaRow.nCols, sizeof(SField));
+  pReq.pColumns = taosArrayInit(req.schemaRow.nCols, sizeof(SFieldWithOptions));
   for (int32_t i = 0; i < req.schemaRow.nCols; i++) {
     SSchema* pSchema = req.schemaRow.pSchema + i;
-    SField   field = {.type = pSchema->type, .flags = pSchema->flags, .bytes = pSchema->bytes};
+    SFieldWithOptions   field = {.type = pSchema->type, .flags = pSchema->flags, .bytes = pSchema->bytes};
     strcpy(field.name, pSchema->name);
+    // todo get active compress param
+    setDefaultOptionsForField(&field);
     taosArrayPush(pReq.pColumns, &field);
   }
   pReq.pTags = taosArrayInit(req.schemaTag.nCols, sizeof(SField));

source/client/src/clientSml.c

@@ -909,6 +909,14 @@ static int32_t smlSendMetaMsg(SSmlHandle *info, SName *pName, SArray *pColumns,
 
   // put front for free
   pReq.numOfColumns = taosArrayGetSize(pColumns);
+  for (int32_t i = 0; i < pReq.numOfColumns; ++i) {
+    SField *pField = taosArrayGet(pColumns, i);
+    SFieldWithOptions fieldWithOption;
+    setFieldWithOptions(&fieldWithOption, pField);
+    setDefaultOptionsForField(&fieldWithOption);
+    taosArrayPush(pReq.pColumns, &fieldWithOption);
+  }
+
   pReq.pColumns = pColumns;
   pReq.numOfTags = taosArrayGetSize(pTags);
   pReq.pTags = pTags;

source/common/src/tcol.c

@@ -0,0 +1,274 @@
+/*
+ * 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 "tcol.h"
+#include "tutil.h"
+
+const char* supportedEncode[5] = {TSDB_COLUMN_ENCODE_UNKNOWN, TSDB_COLUMN_ENCODE_SIMPLE8B, TSDB_COLUMN_ENCODE_XOR,
+                                  TSDB_COLUMN_ENCODE_RLE, TSDB_COLUMN_ENCODE_DISABLED};
+
+const char* supportedCompress[7] = {TSDB_COLUMN_COMPRESS_UNKNOWN, TSDB_COLUMN_COMPRESS_LZ4,  TSDB_COLUMN_COMPRESS_TSZ,
+                                    TSDB_COLUMN_COMPRESS_XZ,      TSDB_COLUMN_COMPRESS_ZLIB, TSDB_COLUMN_COMPRESS_ZSTD,
+                                    TSDB_COLUMN_COMPRESS_DISABLED};
+
+const char* supportedLevel[4] = {TSDB_COLUMN_LEVEL_UNKNOWN, TSDB_COLUMN_LEVEL_HIGH, TSDB_COLUMN_LEVEL_MEDIUM,
+                                 TSDB_COLUMN_LEVEL_LOW};
+
+const int supportedEncodeNum = sizeof(supportedEncode) / sizeof(char*);
+const int supportedCompressNum = sizeof(supportedCompress) / sizeof(char*);
+const int supportedLevelNum = sizeof(supportedLevel) / sizeof(char*);
+
+uint8_t getDefaultEncode(uint8_t type) {
+  switch (type) {
+    case TSDB_DATA_TYPE_NULL:
+    case TSDB_DATA_TYPE_BOOL:
+    case TSDB_DATA_TYPE_TINYINT:
+    case TSDB_DATA_TYPE_SMALLINT:
+    case TSDB_DATA_TYPE_INT:
+    case TSDB_DATA_TYPE_BIGINT:
+    case TSDB_DATA_TYPE_FLOAT:
+    case TSDB_DATA_TYPE_DOUBLE:
+    case TSDB_DATA_TYPE_VARCHAR:  // TSDB_DATA_TYPE_BINARY
+    case TSDB_DATA_TYPE_TIMESTAMP:
+    case TSDB_DATA_TYPE_NCHAR:
+    case TSDB_DATA_TYPE_UTINYINT:
+    case TSDB_DATA_TYPE_USMALLINT:
+    case TSDB_DATA_TYPE_UINT:
+    case TSDB_DATA_TYPE_UBIGINT:
+    case TSDB_DATA_TYPE_JSON:
+    case TSDB_DATA_TYPE_VARBINARY:
+    case TSDB_DATA_TYPE_DECIMAL:
+    case TSDB_DATA_TYPE_BLOB:
+    case TSDB_DATA_TYPE_MEDIUMBLOB:
+    case TSDB_DATA_TYPE_GEOMETRY:
+    case TSDB_DATA_TYPE_MAX:
+      return TSDB_COLVAL_ENCODE_SIMPLE8B;
+
+    default:
+      return TSDB_COLVAL_ENCODE_SIMPLE8B;
+  }
+}
+const char* getDefaultEncodeStr(uint8_t type) {
+  return columnEncodeStr(getDefaultEncode(type));
+}
+
+uint16_t getDefaultCompress(uint8_t type) {
+ switch (type) {
+    case TSDB_DATA_TYPE_NULL:
+    case TSDB_DATA_TYPE_BOOL:
+    case TSDB_DATA_TYPE_TINYINT:
+    case TSDB_DATA_TYPE_SMALLINT:
+    case TSDB_DATA_TYPE_INT:
+    case TSDB_DATA_TYPE_BIGINT:
+    case TSDB_DATA_TYPE_FLOAT:
+    case TSDB_DATA_TYPE_DOUBLE:
+    case TSDB_DATA_TYPE_VARCHAR:  // TSDB_DATA_TYPE_BINARY
+    case TSDB_DATA_TYPE_TIMESTAMP:
+    case TSDB_DATA_TYPE_NCHAR:
+    case TSDB_DATA_TYPE_UTINYINT:
+    case TSDB_DATA_TYPE_USMALLINT:
+    case TSDB_DATA_TYPE_UINT:
+    case TSDB_DATA_TYPE_UBIGINT:
+    case TSDB_DATA_TYPE_JSON:
+    case TSDB_DATA_TYPE_VARBINARY:
+    case TSDB_DATA_TYPE_DECIMAL:
+    case TSDB_DATA_TYPE_BLOB:
+    case TSDB_DATA_TYPE_MEDIUMBLOB:
+    case TSDB_DATA_TYPE_GEOMETRY:
+    case TSDB_DATA_TYPE_MAX:
+      return TSDB_COLVAL_COMPRESS_LZ4;
+
+    default:
+      return TSDB_COLVAL_COMPRESS_LZ4;
+  }
+}
+const char* getDefaultCompressStr(uint8_t type) {
+  return columnCompressStr(getDefaultCompress(type));
+}
+
+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) {
+  const char* encode = NULL;
+  switch (type) {
+    case TSDB_COLVAL_ENCODE_SIMPLE8B:
+      encode = TSDB_COLUMN_ENCODE_SIMPLE8B;
+      break;
+    case TSDB_COLVAL_ENCODE_XOR:
+      encode = TSDB_COLUMN_ENCODE_XOR;
+      break;
+    case TSDB_COLVAL_ENCODE_RLE:
+      encode = TSDB_COLUMN_ENCODE_RLE;
+      break;
+    case TSDB_COLVAL_ENCODE_DISABLED:
+      encode = TSDB_COLUMN_ENCODE_DISABLED;
+      break;
+    default:
+      break;
+  }
+  return encode;
+}
+
+const char* columnCompressStr(uint16_t type) {
+  const char* compress = NULL;
+  switch (type) {
+    case TSDB_COLVAL_COMPRESS_LZ4:
+      compress = TSDB_COLUMN_COMPRESS_LZ4;
+      break;
+    case TSDB_COLVAL_COMPRESS_TSZ:
+      compress = TSDB_COLUMN_COMPRESS_TSZ;
+      break;
+    case TSDB_COLVAL_COMPRESS_XZ:
+      compress = TSDB_COLUMN_COMPRESS_XZ;
+      break;
+    case TSDB_COLVAL_COMPRESS_ZLIB:
+      compress = TSDB_COLUMN_COMPRESS_ZLIB;
+      break;
+    case TSDB_COLVAL_COMPRESS_ZSTD:
+      compress = TSDB_COLUMN_COMPRESS_ZSTD;
+      break;
+    case TSDB_COLVAL_COMPRESS_DISABLED:
+      compress = TSDB_COLUMN_COMPRESS_DISABLED;
+      break;
+
+    default:
+      break;
+  }
+  return compress;
+}
+
+uint8_t columnLevelVal(const char* level) {
+  uint8_t l = TSDB_COLVAL_LEVEL_MEDIUM;
+  if (0 == strcmp(level, TSDB_COLUMN_LEVEL_HIGH)) {
+    l = TSDB_COLVAL_LEVEL_HIGH;
+  } else if (0 == strcmp(level, TSDB_COLUMN_LEVEL_MEDIUM)) {
+    l = TSDB_COLVAL_LEVEL_MEDIUM;
+  } else if (0 == strcmp(level, TSDB_COLUMN_LEVEL_LOW)) {
+    l = TSDB_COLVAL_LEVEL_LOW;
+  }
+  return l;
+}
+
+uint16_t columnCompressVal(const char* compress) {
+  uint16_t c = TSDB_COLVAL_COMPRESS_LZ4;
+  if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_LZ4)) {
+    c = TSDB_COLVAL_COMPRESS_LZ4;
+  } else if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_TSZ)) {
+    c = TSDB_COLVAL_COMPRESS_TSZ;
+  } else if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_XZ)) {
+    c = TSDB_COLVAL_COMPRESS_XZ;
+  } else if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_ZLIB)) {
+    c = TSDB_COLVAL_COMPRESS_ZLIB;
+  } else if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_ZSTD)) {
+    c = TSDB_COLVAL_COMPRESS_ZSTD;
+  } else if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_DISABLED)) {
+    c = TSDB_COLVAL_COMPRESS_DISABLED;
+  }
+  return c;
+}
+
+uint8_t columnEncodeVal(const char* encode) {
+  uint8_t e = TSDB_COLVAL_ENCODE_SIMPLE8B;
+  if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_SIMPLE8B)) {
+    e = TSDB_COLVAL_ENCODE_SIMPLE8B;
+  } else if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_XOR)) {
+    e = TSDB_COLVAL_ENCODE_XOR;
+  } else if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_RLE)) {
+    e = TSDB_COLVAL_ENCODE_RLE;
+  } else if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_DISABLED)) {
+    e = TSDB_COLVAL_ENCODE_DISABLED;
+  }
+  return e;
+}
+
+const char* columnLevelStr(uint8_t type) {
+  const char* level = NULL;
+  switch (type) {
+    case TSDB_COLVAL_LEVEL_HIGH:
+      level = TSDB_COLUMN_LEVEL_HIGH;
+      break;
+    case TSDB_COLVAL_LEVEL_MEDIUM:
+      level = TSDB_COLUMN_LEVEL_MEDIUM;
+      break;
+    case TSDB_COLVAL_LEVEL_LOW:
+      level = TSDB_COLUMN_LEVEL_LOW;
+      break;
+    default:
+      break;
+  }
+  return level;
+}
+
+bool checkColumnEncode(uint8_t type, char encode[TSDB_CL_COMPRESS_OPTION_LEN]) {
+  if (0 == strlen(encode)) {
+    strncpy(encode, getDefaultEncodeStr(type), TSDB_CL_COMPRESS_OPTION_LEN);
+    return true;
+  }
+  strtolower(encode, encode);
+  for (int i = 0; i < supportedEncodeNum; ++i) {
+    if (0 == strcmp((const char*)encode, supportedEncode[i])) {
+      return true;
+    }
+  }
+
+  return false;
+}
+bool checkColumnCompress(uint8_t type, char compress[TSDB_CL_COMPRESS_OPTION_LEN]) {
+  if (0 == strlen(compress)) {
+    strncpy(compress, getDefaultEncodeStr(type), TSDB_CL_COMPRESS_OPTION_LEN);
+    return true;
+  }
+  strtolower(compress, compress);
+  for (int i = 0; i < supportedCompressNum; ++i) {
+    if (0 == strcmp((const char*)compress, supportedCompress[i])) {
+      return true;
+    }
+  }
+
+  return false;
+}
+bool checkColumnLevel(uint8_t type, char level[TSDB_CL_COMPRESS_OPTION_LEN]) {
+  if (0 == strlen(level)) {
+    strncpy(level, getDefaultLevelStr(type), TSDB_CL_COMPRESS_OPTION_LEN);
+    return true;
+  } else if (1 == strlen(level)) {
+    if ('h' == level[0] || 'm' == level[0] || 'l' == level[0]) return true;
+  } else {
+    for (int i = 0; i < supportedLevelNum; ++i) {
+      if (0 == strcmp((const char*)level, supportedLevel[i])) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+void setColEncode(uint32_t* compress, uint8_t l1) {
+  *compress &= 0x00FFFFFF;
+  *compress |= (l1 << 24);
+  return;
+}
+void setColCompress(uint32_t* compress, uint16_t l2) {
+  *compress &= 0xFF0000FF;
+  *compress |= (l2 << 8);
+  return;
+}
+void setColLevel(uint32_t* compress, uint8_t level) {
+  *compress &= 0xFFFFFF00;
+  *compress |= level;
+  return;
+}

source/common/src/tmsg.c

@@ -38,6 +38,7 @@
 #include "tmsgdef.h"
 
 #include "tlog.h"
+#include "tcol.h"
 
 #define DECODESQL()                                                                 \
   do {                                                                              \
@@ -566,11 +567,14 @@ int32_t tSerializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pReq
   if (tEncodeI32(&encoder, pReq->ast2Len) < 0) return -1;
 
   for (int32_t i = 0; i < pReq->numOfColumns; ++i) {
-    SField *pField = taosArrayGet(pReq->pColumns, i);
+    SFieldWithOptions *pField = taosArrayGet(pReq->pColumns, i);
     if (tEncodeI8(&encoder, pField->type) < 0) return -1;
     if (tEncodeI8(&encoder, pField->flags) < 0) return -1;
     if (tEncodeI32(&encoder, pField->bytes) < 0) return -1;
     if (tEncodeCStr(&encoder, pField->name) < 0) return -1;
+    if (tEncodeU32(&encoder, pField->compress) < 0) return -1;
+    // XSDEBUG
+    printf("column: %s, compress: %0x.\n", pField->name, pField->compress);
   }
 
   for (int32_t i = 0; i < pReq->numOfTags; ++i) {
@@ -647,6 +651,9 @@ int32_t tDeserializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pR
     if (tDecodeI8(&decoder, &field.flags) < 0) return -1;
     if (tDecodeI32(&decoder, &field.bytes) < 0) return -1;
     if (tDecodeCStrTo(&decoder, field.name) < 0) return -1;
+    // if (tDecodeCStrTo(&decoder, field.encode) < 0) return -1;
+    // if (tDecodeCStrTo(&decoder, field.compress) < 0) return -1;
+    // if (tDecodeCStrTo(&decoder, field.level) < 0) return -1;
     if (taosArrayPush(pReq->pColumns, &field) == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       return -1;
@@ -7637,6 +7644,8 @@ int tEncodeSVCreateTbReq(SEncoder *pCoder, const SVCreateTbReq *pReq) {
   }
   if (tEncodeSColCmprWrapper(pCoder, &pReq->colCmpr) < 0) return -1;
 
+  // Encode Column Options: encode compress level
+
   tEndEncode(pCoder);
   return 0;
 }
@@ -8102,6 +8111,8 @@ int32_t tEncodeSVAlterTbReq(SEncoder *pEncoder, const SVAlterTbReq *pReq) {
         if (tEncodeCStr(pEncoder, pReq->newComment) < 0) return -1;
       }
       break;
+    case TSDB_ALTER_TABLE_UPDATE_COLUMN_COMPRESS:
+      break;
     default:
       break;
   }
@@ -9417,3 +9428,16 @@ void tFreeSViewHbRsp(SViewHbRsp *pRsp) {
 
   taosArrayDestroy(pRsp->pViewRsp);
 }
+
+void setDefaultOptionsForField(SFieldWithOptions *field) {
+  setColEncode(&field->compress, getDefaultEncode(field->type));
+  setColCompress(&field->compress, getDefaultCompress(field->type));
+  setColLevel(&field->compress, getDefaultLevel(field->type));
+}
+
+void setFieldWithOptions(SFieldWithOptions *fieldWithOptions, SField *field) {
+  fieldWithOptions->bytes = field->bytes;
+  fieldWithOptions->flags = field->flags;
+  fieldWithOptions->type = field->type;
+  strncpy(fieldWithOptions->name, field->name, TSDB_COL_NAME_LEN);
+}

source/libs/nodes/src/nodesCodeFuncs.c

@@ -77,6 +77,8 @@ const char* nodesNodeName(ENodeType type) {
       return "DatabaseOptions";
     case QUERY_NODE_TABLE_OPTIONS:
       return "TableOptions";
+    case QUERY_NODE_COLUMN_OPTIONS:
+      return "ColumnOptions";
     case QUERY_NODE_INDEX_OPTIONS:
       return "IndexOptions";
     case QUERY_NODE_EXPLAIN_OPTIONS:
@@ -4973,6 +4975,26 @@ static int32_t jsonToTableOptions(const SJson* pJson, void* pObj) {
   return code;
 }
 
+static const char* jkColumnOptionsEncode = "encode";
+static const char* jkColumnOptionsCompress = "compress";
+static const char* jkColumnOptionsLevel = "level";
+static int32_t     columnOptionsToJson(const void* pObj, SJson* pJson) {
+  const SColumnOptions* pNode = (const SColumnOptions*)pObj;
+  int32_t               code = tjsonAddStringToObject(pJson, jkColumnOptionsEncode, pNode->encode);
+  code = tjsonAddStringToObject(pJson, jkColumnOptionsCompress, pNode->compress);
+  code = tjsonAddStringToObject(pJson, jkColumnOptionsLevel, pNode->compressLevel);
+  return code;
+}
+
+static int32_t jsonToColumnOptions(const SJson* pJson, void* pObj) {
+  SColumnOptions* pNode = (SColumnOptions*)pObj;
+
+  int32_t code = tjsonGetStringValue(pJson, jkColumnOptionsEncode, pNode->encode);
+  code = tjsonGetStringValue(pJson, jkColumnOptionsCompress, pNode->compress);
+  code = tjsonGetStringValue(pJson, jkColumnOptionsLevel, pNode->compressLevel);
+  return code;
+}
+
 static const char* jkIndexOptionsFuncs = "Funcs";
 static const char* jkIndexOptionsInterval = "Interval";
 static const char* jkIndexOptionsOffset = "Offset";
@@ -7051,6 +7073,8 @@ static int32_t specificNodeToJson(const void* pObj, SJson* pJson) {
       return databaseOptionsToJson(pObj, pJson);
     case QUERY_NODE_TABLE_OPTIONS:
       return tableOptionsToJson(pObj, pJson);
+    case QUERY_NODE_COLUMN_OPTIONS:
+      return columnOptionsToJson(pObj, pJson);
     case QUERY_NODE_INDEX_OPTIONS:
       return indexOptionsToJson(pObj, pJson);
     case QUERY_NODE_EXPLAIN_OPTIONS:
@@ -7388,6 +7412,8 @@ static int32_t jsonToSpecificNode(const SJson* pJson, void* pObj) {
       return jsonToDatabaseOptions(pJson, pObj);
     case QUERY_NODE_TABLE_OPTIONS:
       return jsonToTableOptions(pJson, pObj);
+    case QUERY_NODE_COLUMN_OPTIONS:
+      return jsonToColumnOptions(pJson, pObj);
     case QUERY_NODE_INDEX_OPTIONS:
       return jsonToIndexOptions(pJson, pObj);
     case QUERY_NODE_EXPLAIN_OPTIONS:

source/libs/nodes/src/nodesUtilFuncs.c

@@ -286,6 +286,8 @@ SNode* nodesMakeNode(ENodeType type) {
       return makeNode(type, sizeof(SDatabaseOptions));
     case QUERY_NODE_TABLE_OPTIONS:
       return makeNode(type, sizeof(STableOptions));
+    case QUERY_NODE_COLUMN_OPTIONS:
+      return makeNode(type, sizeof(SColumnOptions));
     case QUERY_NODE_INDEX_OPTIONS:
       return makeNode(type, sizeof(SIndexOptions));
     case QUERY_NODE_EXPLAIN_OPTIONS:
@@ -815,6 +817,10 @@ void nodesDestroyNode(SNode* pNode) {
       nodesDestroyList(pOptions->pDeleteMark);
       break;
     }
+    case QUERY_NODE_COLUMN_OPTIONS: {
+      SColumnOptions* pOptions = (SColumnOptions*)pNode;
+      break;
+    }
     case QUERY_NODE_INDEX_OPTIONS: {
       SIndexOptions* pOptions = (SIndexOptions*)pNode;
       nodesDestroyList(pOptions->pFuncs);

source/libs/parser/inc/parAst.h

@@ -77,6 +77,13 @@ typedef enum ETableOptionType {
   TABLE_OPTION_DELETE_MARK
 } ETableOptionType;
 
+typedef enum EColumnOptionType {
+  COLUMN_OPTION_COMMENT = 1,
+  COLUMN_OPTION_ENCODE,
+  COLUMN_OPTION_COMPRESS,
+  COLUMN_OPTION_LEVEL,
+} EColumnOptionType;
+
 typedef struct SAlterOption {
   int32_t    type;
   SToken     val;
@@ -172,7 +179,9 @@ SNode* createCompactStmt(SAstCreateContext* pCxt, SToken* pDbName, SNode* pStart
 SNode* createDefaultTableOptions(SAstCreateContext* pCxt);
 SNode* createAlterTableOptions(SAstCreateContext* pCxt);
 SNode* setTableOption(SAstCreateContext* pCxt, SNode* pOptions, ETableOptionType type, void* pVal);
-SNode* createColumnDefNode(SAstCreateContext* pCxt, SToken* pColName, SDataType dataType, const SToken* pComment);
+SNode* createColumnDefNode(SAstCreateContext* pCxt, SToken* pColName, SDataType dataType, SNode* pOptions);
+SNode* setColumnOptions(SAstCreateContext* pCxt, SNode* pOptions, ETableOptionType type, void* pVal);
+SNode* createDefaultColumnOptions(SAstCreateContext* pCxt);
 SNode* createCreateTableStmt(SAstCreateContext* pCxt, bool ignoreExists, SNode* pRealTable, SNodeList* pCols,
                              SNodeList* pTags, SNode* pOptions);
 SNode* createCreateSubTableClause(SAstCreateContext* pCxt, bool ignoreExists, SNode* pRealTable, SNode* pUseRealTable,
@@ -184,6 +193,8 @@ SNode* createDropSuperTableStmt(SAstCreateContext* pCxt, bool ignoreNotExists, S
 SNode* createAlterTableModifyOptions(SAstCreateContext* pCxt, SNode* pRealTable, SNode* pOptions);
 SNode* createAlterTableAddModifyCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType, SToken* pColName,
                                     SDataType dataType);
+SNode* createAlterTableAddModifyColOptions(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType, SToken* pColName,
+                                    SNode* pOptions);
 SNode* createAlterTableDropCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType, SToken* pColName);
 SNode* createAlterTableRenameCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType, SToken* pOldColName,
                                  SToken* pNewColName);

source/libs/parser/inc/sql.y

@@ -344,6 +344,8 @@ alter_table_clause(A) ::=
 alter_table_clause(A) ::= full_table_name(B) DROP COLUMN column_name(C).          { A = createAlterTableDropCol(pCxt, B, TSDB_ALTER_TABLE_DROP_COLUMN, &C); }
 alter_table_clause(A) ::=
   full_table_name(B) MODIFY COLUMN column_name(C) type_name(D).                   { A = createAlterTableAddModifyCol(pCxt, B, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, &C, D); }
+alter_table_clause(A) ::=
+  full_table_name(B) MODIFY COLUMN column_name(C) column_options(D).              { A = createAlterTableAddModifyColOptions(pCxt, B, TSDB_ALTER_TABLE_UPDATE_COLUMN_COMPRESS, &C, D); }
 alter_table_clause(A) ::=
   full_table_name(B) RENAME COLUMN column_name(C) column_name(D).                 { A = createAlterTableRenameCol(pCxt, B, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &C, &D); }
 alter_table_clause(A) ::=
@@ -380,13 +382,19 @@ specific_cols_opt(A) ::= NK_LP col_name_list(B) NK_RP.
 full_table_name(A) ::= table_name(B).                                             { A = createRealTableNode(pCxt, NULL, &B, NULL); }
 full_table_name(A) ::= db_name(B) NK_DOT table_name(C).                           { A = createRealTableNode(pCxt, &B, &C, NULL); }
 
+%type tag_def_list                                                                { SNodeList* }
+%destructor tag_def_list                                                          { nodesDestroyList($$); }
+tag_def_list(A) ::= tag_def(B).                                                   { A = createNodeList(pCxt, B); }
+tag_def_list(A) ::= tag_def_list(B) NK_COMMA tag_def(C).                          { A = addNodeToList(pCxt, B, C); }
+tag_def(A) ::= column_name(B) type_name(C).                                       { A = createColumnDefNode(pCxt, &B, C, NULL); }
+
 %type column_def_list                                                             { SNodeList* }
 %destructor column_def_list                                                       { nodesDestroyList($$); }
 column_def_list(A) ::= column_def(B).                                             { A = createNodeList(pCxt, B); }
 column_def_list(A) ::= column_def_list(B) NK_COMMA column_def(C).                 { A = addNodeToList(pCxt, B, C); }
 
-column_def(A) ::= column_name(B) type_name(C).                                    { A = createColumnDefNode(pCxt, &B, C, NULL); }
+// column_def(A) ::= column_name(B) type_name(C).                                 { A = createColumnDefNode(pCxt, &B, C, NULL); }
-//column_def(A) ::= column_name(B) type_name(C) COMMENT NK_STRING(D).               { A = createColumnDefNode(pCxt, &B, C, &D); }
+column_def(A) ::= column_name(B) type_name(C) column_options(D).                  { A = createColumnDefNode(pCxt, &B, C, D); }
 
 %type type_name                                                                   { SDataType }
 %destructor type_name                                                             { }
@@ -422,7 +430,7 @@ tags_def_opt(A) ::= tags_def(B).
 
 %type tags_def                                                                    { SNodeList* }
 %destructor tags_def                                                              { nodesDestroyList($$); }
-tags_def(A) ::= TAGS NK_LP column_def_list(B) NK_RP.                              { A = B; }
+tags_def(A) ::= TAGS NK_LP tag_def_list(B) NK_RP.                              { A = B; }
 
 table_options(A) ::= .                                                            { A = createDefaultTableOptions(pCxt); }
 table_options(A) ::= table_options(B) COMMENT NK_STRING(C).                       { A = setTableOption(pCxt, B, TABLE_OPTION_COMMENT, &C); }
@@ -1276,3 +1284,8 @@ null_ordering_opt(A) ::= NULLS LAST.
 %fallback ABORT AFTER ATTACH BEFORE BEGIN BITAND BITNOT BITOR BLOCKS CHANGE COMMA CONCAT CONFLICT COPY DEFERRED DELIMITERS DETACH DIVIDE DOT EACH END FAIL
   FILE FOR GLOB ID IMMEDIATE IMPORT INITIALLY INSTEAD ISNULL KEY MODULES NK_BITNOT NK_SEMI NOTNULL OF PLUS PRIVILEGE RAISE RESTRICT ROW SEMI STAR STATEMENT
   STRICT STRING TIMES VALUES VARIABLE VIEW WAL.
+
+column_options(A) ::= .                                                           { A = createDefaultColumnOptions(pCxt); }
+column_options(A) ::= column_options(B) ENCODE NK_STRING(C).                      { A = setColumnOptions(pCxt, B, COLUMN_OPTION_ENCODE, &C); }
+column_options(A) ::= column_options(B) COMPRESS NK_STRING(C).                    { A = setColumnOptions(pCxt, B, COLUMN_OPTION_COMPRESS, &C); }
+column_options(A) ::= column_options(B) LEVEL NK_STRING(C).                       { A = setColumnOptions(pCxt, B, COLUMN_OPTION_LEVEL, &C); }

source/libs/parser/src/parAstCreater.c

@@ -1487,9 +1487,38 @@ SNode* setTableOption(SAstCreateContext* pCxt, SNode* pOptions, ETableOptionType
   return pOptions;
 }
 
-SNode* createColumnDefNode(SAstCreateContext* pCxt, SToken* pColName, SDataType dataType, const SToken* pComment) {
+SNode* createDefaultColumnOptions(SAstCreateContext* pCxt) {
   CHECK_PARSER_STATUS(pCxt);
-  if (!checkColumnName(pCxt, pColName) || !checkComment(pCxt, pComment, false)) {
+  SColumnOptions* pOptions = (SColumnOptions*)nodesMakeNode(QUERY_NODE_COLUMN_OPTIONS);
+  CHECK_OUT_OF_MEM(pOptions);
+  pOptions->commentNull = true;
+  return (SNode*)pOptions;
+}
+
+SNode* setColumnOptions(SAstCreateContext* pCxt, SNode* pOptions, ETableOptionType type, void* pVal) {
+  CHECK_PARSER_STATUS(pCxt);
+  switch (type) {
+    case COLUMN_OPTION_ENCODE:
+      memset(((SColumnOptions*)pOptions)->encode, 0, TSDB_CL_COMPRESS_OPTION_LEN);
+      COPY_STRING_FORM_STR_TOKEN(((SColumnOptions*)pOptions)->encode, (SToken*)pVal);
+      break;
+    case COLUMN_OPTION_COMPRESS:
+      memset(((SColumnOptions*)pOptions)->compress, 0, TSDB_CL_COMPRESS_OPTION_LEN);
+      COPY_STRING_FORM_STR_TOKEN(((SColumnOptions*)pOptions)->compress, (SToken*)pVal);
+      break;
+    case COLUMN_OPTION_LEVEL:
+      memset(((SColumnOptions*)pOptions)->compressLevel, 0, TSDB_CL_COMPRESS_OPTION_LEN);
+      COPY_STRING_FORM_STR_TOKEN(((SColumnOptions*)pOptions)->compressLevel, (SToken*)pVal);
+      break;
+    default:
+      break;
+  }
+  return pOptions;
+}
+
+SNode* createColumnDefNode(SAstCreateContext* pCxt, SToken* pColName, SDataType dataType, SNode* pNode) {
+  CHECK_PARSER_STATUS(pCxt);
+  if (!checkColumnName(pCxt, pColName)) {
     return NULL;
   }
   if (IS_VAR_DATA_TYPE(dataType.type) && dataType.bytes == 0) {
@@ -1500,9 +1529,7 @@ SNode* createColumnDefNode(SAstCreateContext* pCxt, SToken* pColName, SDataType
   CHECK_OUT_OF_MEM(pCol);
   COPY_STRING_FORM_ID_TOKEN(pCol->colName, pColName);
   pCol->dataType = dataType;
-  if (NULL != pComment) {
+  pCol->pOptions = (SColumnOptions*)pNode;
-    trimString(pComment->z, pComment->n, pCol->comments, sizeof(pCol->comments));
-  }
   pCol->sma = true;
   return (SNode*)pCol;
 }
@@ -1618,6 +1645,20 @@ SNode* createAlterTableAddModifyCol(SAstCreateContext* pCxt, SNode* pRealTable,
   return createAlterTableStmtFinalize(pRealTable, pStmt);
 }
 
+SNode* createAlterTableAddModifyColOptions(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType, SToken* pColName,
+                                    SNode* pOptions) {
+  CHECK_PARSER_STATUS(pCxt);
+  if (!checkColumnName(pCxt, pColName)) {
+    return NULL;
+  }
+  SAlterTableStmt* pStmt = (SAlterTableStmt*)nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT);
+  CHECK_OUT_OF_MEM(pStmt);
+  pStmt->alterType = TSDB_ALTER_TABLE_UPDATE_COLUMN_COMPRESS;
+  COPY_STRING_FORM_ID_TOKEN(pStmt->colName, pColName);
+  pStmt->pColOptions = (SColumnOptions*)pOptions;
+  return createAlterTableStmtFinalize(pRealTable, pStmt);
+}
+
 SNode* createAlterTableDropCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_t alterType, SToken* pColName) {
   CHECK_PARSER_STATUS(pCxt);
   if (!checkColumnName(pCxt, pColName)) {

source/libs/parser/src/parTokenizer.c

@@ -303,6 +303,9 @@ static SKeyword keywordTable[] = {
     {"ALIVE",                TK_ALIVE},
     {"VARBINARY",            TK_VARBINARY},
     {"KEEP_TIME_OFFSET",     TK_KEEP_TIME_OFFSET},
+    {"ENCODE",               TK_ENCODE},
+    {"COMPRESS",             TK_COMPRESS},
+    {"LEVEL",                TK_LEVEL},
 };
 // clang-format on
 

source/libs/parser/src/parTranslater.c

@@ -26,6 +26,7 @@
 #include "systable.h"
 #include "tglobal.h"
 #include "ttime.h"
+#include "tcol.h"
 
 #define generateDealNodeErrMsg(pCxt, code, ...) \
   (pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, code, ##__VA_ARGS__), DEAL_RES_ERROR)
@@ -5745,7 +5746,39 @@ static int32_t translateTrimDatabase(STranslateContext* pCxt, STrimDatabaseStmt*
   return buildCmdMsg(pCxt, TDMT_MND_TRIM_DB, (FSerializeFunc)tSerializeSTrimDbReq, &req);
 }
 
+static int32_t checkColumnOptions(SNodeList* pList) {
+  SNode* pNode;
+  FOREACH(pNode, pList) {
+    SColumnDefNode*   pCol = (SColumnDefNode*)pNode;
+    if (!pCol->pOptions)  return TSDB_CODE_TSC_ENCODE_PARAM_NULL;
+    if (!checkColumnEncode(pCol->type, pCol->pOptions->encode)) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;
+    if (!checkColumnCompress(pCol->type, pCol->pOptions->compress)) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;
+    if (!checkColumnLevel(pCol->type, pCol->pOptions->compressLevel)) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
 static int32_t columnDefNodeToField(SNodeList* pList, SArray** pArray) {
+  *pArray = taosArrayInit(LIST_LENGTH(pList), sizeof(SFieldWithOptions));
+  SNode* pNode;
+  FOREACH(pNode, pList) {
+    SColumnDefNode*   pCol = (SColumnDefNode*)pNode;
+    SFieldWithOptions field = {.type = pCol->dataType.type, .bytes = calcTypeBytes(pCol->dataType)};
+    strcpy(field.name, pCol->colName);
+    if (pCol->pOptions) {
+      setColEncode(&field.compress, columnEncodeVal(pCol->pOptions->encode));
+      setColCompress(&field.compress, columnCompressVal(pCol->pOptions->compress));
+      setColLevel(&field.compress, columnLevelVal(pCol->pOptions->compressLevel));
+    }
+    if (pCol->sma) {
+      field.flags |= COL_SMA_ON;
+    }
+    taosArrayPush(*pArray, &field);
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t tagDefNodeToField(SNodeList* pList, SArray** pArray) {
   *pArray = taosArrayInit(LIST_LENGTH(pList), sizeof(SField));
   SNode* pNode;
   FOREACH(pNode, pList) {
@@ -6110,6 +6143,9 @@ static int32_t checkCreateTable(STranslateContext* pCxt, SCreateTableStmt* pStmt
   if (TSDB_CODE_SUCCESS == code) {
     code = checkTableSchema(pCxt, pStmt);
   }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = checkColumnOptions(pStmt->pCols);
+  }
   if (TSDB_CODE_SUCCESS == code) {
     if (createStable && pStmt->pOptions->ttl != 0) {
       code = generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_TABLE_OPTION,
@@ -6436,7 +6472,7 @@ static int32_t buildCreateStbReq(STranslateContext* pCxt, SCreateTableStmt* pStm
   pReq->tagVer = 1;
   pReq->source = TD_REQ_FROM_APP;
   columnDefNodeToField(pStmt->pCols, &pReq->pColumns);
-  columnDefNodeToField(pStmt->pTags, &pReq->pTags);
+  tagDefNodeToField(pStmt->pTags, &pReq->pTags);
   pReq->numOfColumns = LIST_LENGTH(pStmt->pCols);
   pReq->numOfTags = LIST_LENGTH(pStmt->pTags);
   if (pStmt->pOptions->commentNull == false) {
@@ -8402,7 +8438,7 @@ static int32_t buildCreateStreamReq(STranslateContext* pCxt, SCreateStreamStmt*
     pReq->fillHistory = pStmt->pOptions->fillHistory;
     pReq->igExpired = pStmt->pOptions->ignoreExpired;
     if (pReq->createStb) {
-      columnDefNodeToField(pStmt->pTags, &pReq->pTags);
+      tagDefNodeToField(pStmt->pTags, &pReq->pTags);
       pReq->numOfTags = LIST_LENGTH(pStmt->pTags);
     }
     pReq->igUpdate = pStmt->pOptions->ignoreUpdate;

source/util/src/terror.c

@@ -147,6 +147,8 @@ TAOS_DEFINE_ERROR(TSDB_CODE_TSC_QUERY_KILLED,             "Query killed")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_NO_EXEC_NODE,             "No available execution node in current query policy configuration")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_NOT_STABLE_ERROR,         "Table is not a super table")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_STMT_CACHE_ERROR,         "Stmt cache error")
+TAOS_DEFINE_ERROR(TSDB_CODE_TSC_ENCODE_PARAM_ERROR,       "Invalid compress param")
+TAOS_DEFINE_ERROR(TSDB_CODE_TSC_ENCODE_PARAM_NULL,        "Not found compress param")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INTERNAL_ERROR,           "Internal error")
 
 // mnode-common