alter table column compress

include/common/tcol.h

@@ -36,16 +36,21 @@
 #define TSDB_COLUMN_LEVEL_MEDIUM  "medium"
 #define TSDB_COLUMN_LEVEL_LOW     "low"
 
+#define TSDB_COLVAL_ENCODE_NOCHANGE   0
 #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_NOCHANGE 0
 #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_NOCHANGE    0
 #define TSDB_COLVAL_LEVEL_HIGH        1
 #define TSDB_COLVAL_LEVEL_MEDIUM      2
 #define TSDB_COLVAL_LEVEL_LOW         3
@@ -53,9 +58,9 @@
 #define TSDB_CL_COMMENT_LEN 1025
 #define TSDB_CL_COMPRESS_OPTION_LEN 32
 
-extern const char* supportedEncode[5];
+extern const char* supportedEncode[4];
-extern const char* supportedCompress[7];
+extern const char* supportedCompress[6];
-extern const char* supportedLevel[4];
+extern const char* supportedLevel[3];
 
 uint8_t     getDefaultEncode(uint8_t type);
 uint16_t    getDefaultCompress(uint8_t type);
@@ -71,9 +76,12 @@ 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 checkColumnEncode(char encode[TSDB_CL_COMPRESS_OPTION_LEN]);
-bool checkColumnCompress(uint8_t type, char compress[TSDB_CL_COMPRESS_OPTION_LEN]);
+bool checkColumnEncodeOrSetDefault(uint8_t type, char encode[TSDB_CL_COMPRESS_OPTION_LEN]);
-bool checkColumnLevel(uint8_t type, char level[TSDB_CL_COMPRESS_OPTION_LEN]);
+bool checkColumnCompress(char compress[TSDB_CL_COMPRESS_OPTION_LEN]);
+bool checkColumnCompressOrSetDefault(uint8_t type, char compress[TSDB_CL_COMPRESS_OPTION_LEN]);
+bool checkColumnLevel(char level[TSDB_CL_COMPRESS_OPTION_LEN]);
+bool checkColumnLevelOrSetDefault(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);

include/common/tmsg.h

@@ -2892,23 +2892,22 @@ typedef struct {
   int32_t bytes;
   // TSDB_ALTER_TABLE_DROP_COLUMN
   // TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES
-  int8_t  colModType;
+  int8_t   colModType;
-  int32_t colModBytes;
+  int32_t  colModBytes;
-  // TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME
+  char*    colNewName;  // TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME
-  char* colNewName;
+  char*    tagName;     // TSDB_ALTER_TABLE_UPDATE_TAG_VAL
-  // TSDB_ALTER_TABLE_UPDATE_TAG_VAL
-  char*    tagName;
   int8_t   isNull;
   int8_t   tagType;
   uint32_t nTagVal;
   uint8_t* pTagVal;
   // TSDB_ALTER_TABLE_UPDATE_OPTIONS
-  int8_t  updateTTL;
+  int8_t   updateTTL;
-  int32_t newTTL;
+  int32_t  newTTL;
-  int32_t newCommentLen;
+  int32_t  newCommentLen;
-  char*   newComment;
+  char*    newComment;
-  int64_t ctimeMs;  // fill by vnode
+  int64_t  ctimeMs;   // fill by vnode
-  int8_t  source;   // TD_REQ_FROM_TAOX-taosX or TD_REQ_FROM_APP-taosClient
+  int8_t   source;    // TD_REQ_FROM_TAOX-taosX or TD_REQ_FROM_APP-taosClient
+  uint32_t compress;  // TSDB_ALTER_TABLE_UPDATE_COLUMN_COMPRESS
 } SVAlterTbReq;
 
 int32_t tEncodeSVAlterTbReq(SEncoder* pEncoder, const SVAlterTbReq* pReq);

source/common/src/tcol.c

@@ -16,14 +16,14 @@
 #include "tcol.h"
 #include "tutil.h"
 
-const char* supportedEncode[5] = {TSDB_COLUMN_ENCODE_UNKNOWN, 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_DISABLED};
 
-const char* supportedCompress[7] = {TSDB_COLUMN_COMPRESS_UNKNOWN, TSDB_COLUMN_COMPRESS_LZ4,  TSDB_COLUMN_COMPRESS_TSZ,
+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_DISABLED};
 
-const char* supportedLevel[4] = {TSDB_COLUMN_LEVEL_UNKNOWN, TSDB_COLUMN_LEVEL_HIGH, TSDB_COLUMN_LEVEL_MEDIUM,
+const char* supportedLevel[3] = {TSDB_COLUMN_LEVEL_HIGH, TSDB_COLUMN_LEVEL_MEDIUM,
                                  TSDB_COLUMN_LEVEL_LOW};
 
 const int supportedEncodeNum = sizeof(supportedEncode) / sizeof(char*);
@@ -158,6 +158,8 @@ uint8_t columnLevelVal(const char* level) {
     l = TSDB_COLVAL_LEVEL_MEDIUM;
   } else if (0 == strcmp(level, "l") || 0 == strcmp(level, TSDB_COLUMN_LEVEL_LOW)) {
     l = TSDB_COLVAL_LEVEL_LOW;
+  } else {
+    l = TSDB_COLVAL_LEVEL_NOCHANGE;
   }
   return l;
 }
@@ -176,6 +178,8 @@ uint16_t columnCompressVal(const char* compress) {
     c = TSDB_COLVAL_COMPRESS_ZSTD;
   } else if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_DISABLED)) {
     c = TSDB_COLVAL_COMPRESS_DISABLED;
+  } else {
+    c = TSDB_COLVAL_COMPRESS_NOCHANGE;
   }
   return c;
 }
@@ -190,6 +194,8 @@ uint8_t columnEncodeVal(const char* encode) {
     e = TSDB_COLVAL_ENCODE_RLE;
   } else if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_DISABLED)) {
     e = TSDB_COLVAL_ENCODE_DISABLED;
+  } else {
+    e = TSDB_COLVAL_ENCODE_NOCHANGE;
   }
   return e;
 }
@@ -212,39 +218,43 @@ const char* columnLevelStr(uint8_t type) {
   return level;
 }
 
-bool checkColumnEncode(uint8_t type, char encode[TSDB_CL_COMPRESS_OPTION_LEN]) {
+bool checkColumnEncode(char encode[TSDB_CL_COMPRESS_OPTION_LEN]){
-  if (0 == strlen(encode)) {
+  if (0 == strlen(encode)) return true;
-    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]) {
+bool checkColumnEncodeOrSetDefault(uint8_t type, char encode[TSDB_CL_COMPRESS_OPTION_LEN]) {
-  if (0 == strlen(compress)) {
+  if (0 == strlen(encode)) {
-    strncpy(compress, getDefaultCompressStr(type), TSDB_CL_COMPRESS_OPTION_LEN);
+    strncpy(encode, getDefaultEncodeStr(type), TSDB_CL_COMPRESS_OPTION_LEN);
     return true;
   }
+  return checkColumnEncode(encode);
+}
+bool checkColumnCompress(char compress[TSDB_CL_COMPRESS_OPTION_LEN]) {
+  if (0 == strlen(compress)) 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]) {
+bool checkColumnCompressOrSetDefault(uint8_t type, char compress[TSDB_CL_COMPRESS_OPTION_LEN]) {
-  if (0 == strlen(level)) {
+  if (0 == strlen(compress)) {
-    strncpy(level, getDefaultLevelStr(type), TSDB_CL_COMPRESS_OPTION_LEN);
+    strncpy(compress, getDefaultCompressStr(type), TSDB_CL_COMPRESS_OPTION_LEN);
     return true;
-  } else if (1 == strlen(level)) {
+  }
+  return checkColumnCompress(compress);
+}
+bool checkColumnLevel(char level[TSDB_CL_COMPRESS_OPTION_LEN]) {
+  if (0 == strlen(level)) return true;
+  if (1 == strlen(level)) {
     if ('h' == level[0] || 'm' == level[0] || 'l' == level[0]) return true;
   } else {
     for (int i = 0; i < supportedLevelNum; ++i) {
@@ -253,9 +263,15 @@ bool checkColumnLevel(uint8_t type, char level[TSDB_CL_COMPRESS_OPTION_LEN]) {
       }
     }
   }
-
   return false;
 }
+bool checkColumnLevelOrSetDefault(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;
+  } 
+  return checkColumnLevel(level);
+}
 
 void setColEncode(uint32_t* compress, uint8_t l1) {
   *compress &= 0x00FFFFFF;

source/common/src/tmsg.c

@@ -573,6 +573,8 @@ int32_t tSerializeSMCreateStbReq(void *buf, int32_t bufLen, SMCreateStbReq *pReq
     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) {
@@ -7638,10 +7640,7 @@ int tEncodeSVCreateTbReq(SEncoder *pCoder, const SVCreateTbReq *pReq) {
     if (tEncodeI32(pCoder, pReq->sqlLen) < 0) return -1;
     if (tEncodeBinary(pCoder, pReq->sql, pReq->sqlLen) < 0) return -1;
   }
-  if (tEncodeSColCmprWrapper(pCoder, &pReq->colCmpr) < 0) return -1;
+  //if (tEncodeSColCmprWrapper(pCoder, &pReq->colCmpr) < 0) return -1;
-
-  // Encode Column Options: encode compress level
-
   tEndEncode(pCoder);
   return 0;
 }
@@ -8115,6 +8114,9 @@ int32_t tEncodeSVAlterTbReq(SEncoder *pEncoder, const SVAlterTbReq *pReq) {
     default:
       break;
   }
+  if (tEncodeU32(pEncoder, pReq->compress) < 0) return -1;
+  // xsren
+  printf("alter table compress:%0x\n", pReq->compress);
   if (tEncodeI64(pEncoder, pReq->ctimeMs) < 0) return -1;
   if (tEncodeI8(pEncoder, pReq->source) < 0) return -1;
 
@@ -8166,6 +8168,7 @@ static int32_t tDecodeSVAlterTbReqCommon(SDecoder *pDecoder, SVAlterTbReq *pReq)
     default:
       break;
   }
+  if (tDecodeU32(pDecoder, &pReq->compress) < 0) return -1;
   return 0;
 }
 

source/libs/parser/inc/sql.y

@@ -345,7 +345,7 @@ alter_table_clause(A) ::= full_table_name(B) DROP COLUMN column_name(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); }
+  full_table_name(B) MODIFY 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) ::=

source/libs/parser/src/parTranslater.c

@@ -5751,9 +5751,9 @@ static int32_t checkColumnOptions(SNodeList* pList) {
   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 (!checkColumnEncodeOrSetDefault(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 (!checkColumnCompressOrSetDefault(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;
+    if (!checkColumnLevelOrSetDefault(pCol->type, pCol->pOptions->compressLevel)) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;
   }
   return TSDB_CODE_SUCCESS;
 }
@@ -10687,6 +10687,28 @@ static int32_t buildUpdateOptionsReq(STranslateContext* pCxt, SAlterTableStmt* p
   return code;
 }
 
+static int buildAlterTableColumnCompress(STranslateContext* pCxt, SAlterTableStmt* pStmt, STableMeta* pTableMeta,
+                                        SVAlterTbReq* pReq) {
+  const SSchema* pSchema = getColSchema(pTableMeta, pStmt->colName);
+  if (NULL == pSchema) {
+    return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_COLUMN, pStmt->colName);
+  }
+
+  pReq->colName = taosStrdup(pStmt->colName);
+  if (NULL == pReq->colName) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  if (!checkColumnEncode(pStmt->pColOptions->encode)) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;
+  if (!checkColumnCompress(pStmt->pColOptions->compress)) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;
+  if (!checkColumnLevel(pStmt->pColOptions->compressLevel)) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;
+  setColCompressByOption(&pReq->compress, columnEncodeVal(pStmt->pColOptions->encode),
+                         columnCompressVal(pStmt->pColOptions->compress),
+                         columnLevelVal(pStmt->pColOptions->compressLevel));
+
+  return TSDB_CODE_SUCCESS;
+}
+
 static int32_t buildAlterTbReq(STranslateContext* pCxt, SAlterTableStmt* pStmt, STableMeta* pTableMeta,
                                SVAlterTbReq* pReq) {
   pReq->tbName = taosStrdup(pStmt->tableName);
@@ -10717,6 +10739,12 @@ static int32_t buildAlterTbReq(STranslateContext* pCxt, SAlterTableStmt* pStmt,
       } else {
         return buildRenameColReq(pCxt, pStmt, pTableMeta, pReq);
       }
+    case TSDB_ALTER_TABLE_UPDATE_COLUMN_COMPRESS:
+      if (TSDB_CHILD_TABLE == pTableMeta->tableType) {
+        return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_ALTER_TABLE);
+      } else {
+        return buildAlterTableColumnCompress(pCxt, pStmt, pTableMeta, pReq);
+      }
     default:
       break;
   }