/src/tdengine/source/common/src/tcol.c

Source
/*
 * 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 "tcompression.h"
#include "tutil.h"

const char* supportedEncode[] = {
    TSDB_COLUMN_ENCODE_SIMPLE8B, TSDB_COLUMN_ENCODE_XOR,      TSDB_COLUMN_ENCODE_RLE,
    TSDB_COLUMN_ENCODE_DELTAD,   TSDB_COLUMN_ENCODE_DISABLED, TSDB_COLUMN_ENCODE_BYTE_STREAM_SPLIT,
};

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[3] = {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:
      return TSDB_COLVAL_ENCODE_RLE;
    case TSDB_DATA_TYPE_TINYINT:
    case TSDB_DATA_TYPE_SMALLINT:
    case TSDB_DATA_TYPE_INT:
    case TSDB_DATA_TYPE_BIGINT:
      return TSDB_COLVAL_ENCODE_SIMPLE8B;
    case TSDB_DATA_TYPE_FLOAT:
    case TSDB_DATA_TYPE_DOUBLE:
      return TSDB_COLVAL_ENCODE_BYTE_STREAM_SPLIT;
    case TSDB_DATA_TYPE_VARCHAR:  // TSDB_DATA_TYPE_BINARY
      return TSDB_COLVAL_ENCODE_DISABLED;
    case TSDB_DATA_TYPE_TIMESTAMP:
      return TSDB_COLVAL_ENCODE_XOR;
    case TSDB_DATA_TYPE_NCHAR:
      return TSDB_COLVAL_ENCODE_DISABLED;
    case TSDB_DATA_TYPE_UTINYINT:
      return TSDB_COLVAL_ENCODE_SIMPLE8B;
    case TSDB_DATA_TYPE_USMALLINT:
      return TSDB_COLVAL_ENCODE_SIMPLE8B;
    case TSDB_DATA_TYPE_UINT:
      return TSDB_COLVAL_ENCODE_SIMPLE8B;
    case TSDB_DATA_TYPE_UBIGINT:
      return TSDB_COLVAL_ENCODE_SIMPLE8B;
    case TSDB_DATA_TYPE_JSON:
      return TSDB_COLVAL_ENCODE_DISABLED;
    case TSDB_DATA_TYPE_VARBINARY:
      return TSDB_COLVAL_ENCODE_DISABLED;
    case TSDB_DATA_TYPE_DECIMAL64:
    case TSDB_DATA_TYPE_DECIMAL:
      return TSDB_COLVAL_ENCODE_DISABLED;
    case TSDB_DATA_TYPE_BLOB:
      return TSDB_COLVAL_ENCODE_DISABLED;
    case TSDB_DATA_TYPE_MEDIUMBLOB:
      return TSDB_COLVAL_ENCODE_DISABLED;
    case TSDB_DATA_TYPE_GEOMETRY:
      return TSDB_COLVAL_ENCODE_DISABLED;

    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:
      return TSDB_COLVAL_COMPRESS_LZ4;
    case TSDB_DATA_TYPE_BOOL:
      return TSDB_COLVAL_COMPRESS_ZSTD;
    case TSDB_DATA_TYPE_TINYINT:
    case TSDB_DATA_TYPE_SMALLINT:
      return TSDB_COLVAL_COMPRESS_ZLIB;
    case TSDB_DATA_TYPE_INT:
    case TSDB_DATA_TYPE_BIGINT:
      return TSDB_COLVAL_COMPRESS_LZ4;
    case TSDB_DATA_TYPE_FLOAT:
    case TSDB_DATA_TYPE_DOUBLE:
      return TSDB_COLVAL_COMPRESS_LZ4;
    case TSDB_DATA_TYPE_VARCHAR:  // TSDB_DATA_TYPE_BINARY
      return TSDB_COLVAL_COMPRESS_ZSTD;
    case TSDB_DATA_TYPE_TIMESTAMP:
      return TSDB_COLVAL_COMPRESS_LZ4;
    case TSDB_DATA_TYPE_NCHAR:
      return TSDB_COLVAL_COMPRESS_ZSTD;
    case TSDB_DATA_TYPE_UTINYINT:
    case TSDB_DATA_TYPE_USMALLINT:
      return TSDB_COLVAL_COMPRESS_ZLIB;
    case TSDB_DATA_TYPE_UINT:
    case TSDB_DATA_TYPE_UBIGINT:
      return TSDB_COLVAL_COMPRESS_LZ4;
    case TSDB_DATA_TYPE_JSON:
      return TSDB_COLVAL_COMPRESS_LZ4;
    case TSDB_DATA_TYPE_VARBINARY:
      return TSDB_COLVAL_COMPRESS_ZSTD;
    case TSDB_DATA_TYPE_DECIMAL64:
    case TSDB_DATA_TYPE_DECIMAL:
      return TSDB_COLVAL_COMPRESS_ZSTD;
    case TSDB_DATA_TYPE_BLOB:
      return TSDB_COLVAL_COMPRESS_LZ4;
    case TSDB_DATA_TYPE_MEDIUMBLOB:
      return TSDB_COLVAL_COMPRESS_LZ4;
    case TSDB_DATA_TYPE_GEOMETRY:
      return TSDB_COLVAL_COMPRESS_LZ4;
    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_DELTAD:
      encode = TSDB_COLUMN_ENCODE_DELTAD;
      break;
    case TSDB_COLVAL_ENCODE_DISABLED:
      encode = TSDB_COLUMN_ENCODE_DISABLED;
      break;
    case TSDB_COLVAL_ENCODE_BYTE_STREAM_SPLIT:
      encode = TSDB_COLUMN_ENCODE_BYTE_STREAM_SPLIT;
      break;
    default:
      encode = TSDB_COLUMN_ENCODE_UNKNOWN;
      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:
      compress = TSDB_COLUMN_COMPRESS_UNKNOWN;
      break;
  }
  return compress;
}

uint8_t columnLevelVal(const char* level) {
  if (level == NULL) return TSDB_COLVAL_LEVEL_NOCHANGE;
  uint8_t l = TSDB_COLVAL_LEVEL_MEDIUM;
  if (0 == strcmp(level, "h") || 0 == strcmp(level, TSDB_COLUMN_LEVEL_HIGH)) {
    l = TSDB_COLVAL_LEVEL_HIGH;
  } else if (0 == strcmp(level, "m") || 0 == strcmp(level, TSDB_COLUMN_LEVEL_MEDIUM)) {
    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;
}

uint16_t columnCompressVal(const char* compress) {
  if (compress == NULL) return TSDB_COLVAL_COMPRESS_NOCHANGE;
  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;
  } else {
    c = TSDB_COLVAL_COMPRESS_NOCHANGE;
  }
  return c;
}

uint8_t columnEncodeVal(const char* encode) {
  if (encode == NULL) return TSDB_COLVAL_ENCODE_NOCHANGE;
  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_DELTAD)) {
    e = TSDB_COLVAL_ENCODE_DELTAD;
  } else if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_DISABLED)) {
    e = TSDB_COLVAL_ENCODE_DISABLED;
  } else if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_BYTE_STREAM_SPLIT)) {
    e = TSDB_COLVAL_ENCODE_BYTE_STREAM_SPLIT;
  } else {
    e = TSDB_COLVAL_ENCODE_NOCHANGE;
  }
  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:
      level = TSDB_COLUMN_LEVEL_UNKNOWN;
      break;
  }
  return level;
}

bool checkColumnEncode(char encode[TSDB_CL_COMPRESS_OPTION_LEN]) {
  if (0 == strlen(encode)) return true;
  TAOS_UNUSED(strtolower(encode, encode));
  for (int i = 0; i < supportedEncodeNum; ++i) {
    if (0 == strcmp((const char*)encode, supportedEncode[i])) {
      return true;
    }
  }
  return false;
}
bool checkColumnEncodeOrSetDefault(uint8_t type, char encode[TSDB_CL_COMPRESS_OPTION_LEN]) {
  if (0 == strlen(encode)) {
    tstrncpy(encode, getDefaultEncodeStr(type), TSDB_CL_COMPRESS_OPTION_LEN);
    return true;
  }
  return checkColumnEncode(encode) && validColEncode(type, columnEncodeVal(encode));
}
bool checkColumnCompress(char compress[TSDB_CL_COMPRESS_OPTION_LEN]) {
  if (0 == strlen(compress)) return true;
  TAOS_UNUSED(strtolower(compress, compress));
  for (int i = 0; i < supportedCompressNum; ++i) {
    if (0 == strcmp((const char*)compress, supportedCompress[i])) {
      return true;
    }
  }
  return false;
}
bool checkColumnCompressOrSetDefault(uint8_t type, char compress[TSDB_CL_COMPRESS_OPTION_LEN]) {
  if (0 == strlen(compress)) {
    tstrncpy(compress, getDefaultCompressStr(type), TSDB_CL_COMPRESS_OPTION_LEN);
    return true;
  }

  return checkColumnCompress(compress) && validColCompress(type, columnCompressVal(compress));
}
bool checkColumnLevel(char level[TSDB_CL_COMPRESS_OPTION_LEN]) {
  if (0 == strlen(level)) return true;
  TAOS_UNUSED(strtolower(level, level));
  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;
}
bool checkColumnLevelOrSetDefault(uint8_t type, char level[TSDB_CL_COMPRESS_OPTION_LEN]) {
  if (0 == strlen(level)) {
    tstrncpy(level, getDefaultLevelStr(type), TSDB_CL_COMPRESS_OPTION_LEN);
    return true;
  }
  return checkColumnLevel(level) && validColCompressLevel(type, columnLevelVal(level));
}

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;
}

int32_t setColCompressByOption(uint8_t type, uint8_t encode, uint16_t compressType, uint8_t level, bool check,
                               uint32_t* compress) {
  if (compress == NULL) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;
  if (check && !validColEncode(type, encode)) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;
  setColEncode(compress, encode);

  if (compressType == TSDB_COLVAL_COMPRESS_DISABLED) {
    setColCompress(compress, compressType);
    setColLevel(compress, TSDB_COLVAL_LEVEL_DISABLED);
  } else {
    if (check && !validColCompress(type, compressType)) return TSDB_CODE_TSC_COMPRESS_PARAM_ERROR;
    setColCompress(compress, compressType);

    if (check && !validColCompressLevel(type, level)) return TSDB_CODE_TSC_COMPRESS_LEVEL_ERROR;
    setColLevel(compress, level);
  }
  return TSDB_CODE_SUCCESS;
}

bool withColCompress(uint8_t tableType) {
  return TSDB_SUPER_TABLE == tableType || TSDB_NORMAL_TABLE == tableType || TSDB_CHILD_TABLE == tableType;
}

bool withExtSchema(uint8_t tableType) {
  return TSDB_SUPER_TABLE == tableType || TSDB_NORMAL_TABLE == tableType || TSDB_CHILD_TABLE == tableType ||
         TSDB_VIRTUAL_NORMAL_TABLE == tableType || TSDB_VIRTUAL_CHILD_TABLE == tableType;
}

bool hasColRef(uint8_t tableType) {
  return TSDB_VIRTUAL_NORMAL_TABLE == tableType || TSDB_VIRTUAL_CHILD_TABLE == tableType;
}

bool hasTagRef(uint8_t tableType) {
  return TSDB_VIRTUAL_NORMAL_TABLE == tableType || TSDB_VIRTUAL_CHILD_TABLE == tableType;
}

int8_t validColCompressLevel(uint8_t type, uint8_t level) {
  if (level == TSDB_COLVAL_LEVEL_DISABLED) return 1;
  if (level < TSDB_COLVAL_LEVEL_NOCHANGE || level > TSDB_COLVAL_LEVEL_HIGH) {
    return 0;
  }
  return 1;
}
int8_t validColCompress(uint8_t type, uint8_t l2) {
  if (l2 > TSDB_COLVAL_COMPRESS_XZ && l2 < TSDB_COLVAL_COMPRESS_DISABLED) {
    return 0;
  }
  if (l2 == TSDB_COLVAL_COMPRESS_TSZ) {
    if (type == TSDB_DATA_TYPE_FLOAT || type == TSDB_DATA_TYPE_DOUBLE) {
      return 1;
    } else {
      return 0;
    }
  }
  return 1;
}

//
// | --------type----------|----- supported encode ----|
// |tinyint/smallint/int/bigint/utinyint/usmallinit/uint/ubiginint| simple8b |
// | timestamp/bigint/ubigint | delta-i  |
// | bool  |  bit-packing   |
// | float/double | delta-d/byte-stream-split |
//
int8_t validColEncode(uint8_t type, uint8_t l1) {
  if (l1 == TSDB_COLVAL_ENCODE_NOCHANGE) {
    return 1;
  }
  if (l1 == TSDB_COLVAL_ENCODE_DISABLED) {
    return 1;
  }
  if (type == TSDB_DATA_TYPE_BOOL) {
    return TSDB_COLVAL_ENCODE_RLE == l1 ? 1 : 0;
  } else if (type >= TSDB_DATA_TYPE_TINYINT && type <= TSDB_DATA_TYPE_INT) {
    return TSDB_COLVAL_ENCODE_SIMPLE8B == l1 ? 1 : 0;
  } else if (type == TSDB_DATA_TYPE_BIGINT) {
    return TSDB_COLVAL_ENCODE_SIMPLE8B == l1 || TSDB_COLVAL_ENCODE_XOR == l1 ? 1 : 0;
  } else if (type == TSDB_DATA_TYPE_FLOAT || type == TSDB_DATA_TYPE_DOUBLE) {
    return (l1 == TSDB_COLVAL_ENCODE_DELTAD || l1 == TSDB_COLVAL_ENCODE_BYTE_STREAM_SPLIT) ? 1 : 0;
  } else if ((type == TSDB_DATA_TYPE_VARCHAR || type == TSDB_DATA_TYPE_NCHAR) || type == TSDB_DATA_TYPE_JSON ||
             type == TSDB_DATA_TYPE_VARBINARY || type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_GEOMETRY ||
             type == TSDB_DATA_TYPE_BLOB || type == TSDB_DATA_TYPE_MEDIUMBLOB) {
    return l1 == TSDB_COLVAL_ENCODE_DISABLED ? 1 : 0;
    // if (l1 >= TSDB_COLVAL_ENCODE_NOCHANGE || l1 <= TSDB_COLVAL_ENCODE_DELTAD) {
    //   return 1;
    // } else if (l1 == TSDB_COLVAL_ENCODE_DISABLED) {
    //   return 1;
    // } else {
    //   return 0;
    // }
  } else if (type == TSDB_DATA_TYPE_TIMESTAMP) {
    return TSDB_COLVAL_ENCODE_XOR == l1 ? 1 : 0;
  } else if (type >= TSDB_DATA_TYPE_UTINYINT && type <= TSDB_DATA_TYPE_UINT) {
    return TSDB_COLVAL_ENCODE_SIMPLE8B == l1 ? 1 : 0;
  } else if (type == TSDB_DATA_TYPE_UBIGINT) {
    return TSDB_COLVAL_ENCODE_SIMPLE8B == l1 || TSDB_COLVAL_ENCODE_XOR == l1 ? 1 : 0;
  } else if (type == TSDB_DATA_TYPE_GEOMETRY) {
    return 1;
  } else if (type == TSDB_DATA_TYPE_DECIMAL64 || type == TSDB_DATA_TYPE_DECIMAL) {
    return l1 == TSDB_COLVAL_ENCODE_DISABLED ? 1 : 0;
  }
  return 0;
}

uint32_t createDefaultColCmprByType(uint8_t type) {
  uint32_t ret = 0;
  uint8_t  encode = getDefaultEncode(type);
  uint8_t  compress = getDefaultCompress(type);
  uint8_t  lvl = getDefaultLevel(type);

  SET_COMPRESS(encode, compress, lvl, ret);
  return ret;
}
int32_t validColCmprByType(uint8_t type, uint32_t cmpr) {
  DEFINE_VAR(cmpr);
  if (!validColEncode(type, l1)) {
    return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;
  }
  if (!validColCompress(type, l2)) {
    return TSDB_CODE_TSC_COMPRESS_PARAM_ERROR;
  }

  if (!validColCompressLevel(type, lvl)) {
    return TSDB_CODE_TSC_COMPRESS_LEVEL_ERROR;
  }
  return TSDB_CODE_SUCCESS;
}

Coverage Report

Created: 2026-10-18 06:28

Line	Count	Source
1		/*
2		* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
3		*
4		* This program is free software: you can use, redistribute, and/or modify
5		* it under the terms of the GNU Affero General Public License, version 3
6		* or later ("AGPL"), as published by the Free Software Foundation.
7		*
8		* This program is distributed in the hope that it will be useful, but WITHOUT
9		* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10		* FITNESS FOR A PARTICULAR PURPOSE.
11		*
12		* You should have received a copy of the GNU Affero General Public License
13		* along with this program. If not, see <http://www.gnu.org/licenses/>.
14		*/
15
16
17		#include "tcol.h"
18		#include "tcompression.h"
19		#include "tutil.h"
20
21		const char* supportedEncode[] = {
22		TSDB_COLUMN_ENCODE_SIMPLE8B, TSDB_COLUMN_ENCODE_XOR, TSDB_COLUMN_ENCODE_RLE,
23		TSDB_COLUMN_ENCODE_DELTAD, TSDB_COLUMN_ENCODE_DISABLED, TSDB_COLUMN_ENCODE_BYTE_STREAM_SPLIT,
24		};
25
26		const char* supportedCompress[6] = {TSDB_COLUMN_COMPRESS_LZ4, TSDB_COLUMN_COMPRESS_TSZ,
27		TSDB_COLUMN_COMPRESS_XZ, TSDB_COLUMN_COMPRESS_ZLIB,
28		TSDB_COLUMN_COMPRESS_ZSTD, TSDB_COLUMN_COMPRESS_DISABLED};
29
30		const char* supportedLevel[3] = {TSDB_COLUMN_LEVEL_HIGH, TSDB_COLUMN_LEVEL_MEDIUM, TSDB_COLUMN_LEVEL_LOW};
31
32		const int supportedEncodeNum = sizeof(supportedEncode) / sizeof(char*);
33		const int supportedCompressNum = sizeof(supportedCompress) / sizeof(char*);
34		const int supportedLevelNum = sizeof(supportedLevel) / sizeof(char*);
35
36	0	uint8_t getDefaultEncode(uint8_t type) {
37	0	switch (type) {
38	0	case TSDB_DATA_TYPE_NULL:
39	0	case TSDB_DATA_TYPE_BOOL:
40	0	return TSDB_COLVAL_ENCODE_RLE;
41	0	case TSDB_DATA_TYPE_TINYINT:
42	0	case TSDB_DATA_TYPE_SMALLINT:
43	0	case TSDB_DATA_TYPE_INT:
44	0	case TSDB_DATA_TYPE_BIGINT:
45	0	return TSDB_COLVAL_ENCODE_SIMPLE8B;
46	0	case TSDB_DATA_TYPE_FLOAT:
47	0	case TSDB_DATA_TYPE_DOUBLE:
48	0	return TSDB_COLVAL_ENCODE_BYTE_STREAM_SPLIT;
49	0	case TSDB_DATA_TYPE_VARCHAR: // TSDB_DATA_TYPE_BINARY
50	0	return TSDB_COLVAL_ENCODE_DISABLED;
51	0	case TSDB_DATA_TYPE_TIMESTAMP:
52	0	return TSDB_COLVAL_ENCODE_XOR;
53	0	case TSDB_DATA_TYPE_NCHAR:
54	0	return TSDB_COLVAL_ENCODE_DISABLED;
55	0	case TSDB_DATA_TYPE_UTINYINT:
56	0	return TSDB_COLVAL_ENCODE_SIMPLE8B;
57	0	case TSDB_DATA_TYPE_USMALLINT:
58	0	return TSDB_COLVAL_ENCODE_SIMPLE8B;
59	0	case TSDB_DATA_TYPE_UINT:
60	0	return TSDB_COLVAL_ENCODE_SIMPLE8B;
61	0	case TSDB_DATA_TYPE_UBIGINT:
62	0	return TSDB_COLVAL_ENCODE_SIMPLE8B;
63	0	case TSDB_DATA_TYPE_JSON:
64	0	return TSDB_COLVAL_ENCODE_DISABLED;
65	0	case TSDB_DATA_TYPE_VARBINARY:
66	0	return TSDB_COLVAL_ENCODE_DISABLED;
67	0	case TSDB_DATA_TYPE_DECIMAL64:
68	0	case TSDB_DATA_TYPE_DECIMAL:
69	0	return TSDB_COLVAL_ENCODE_DISABLED;
70	0	case TSDB_DATA_TYPE_BLOB:
71	0	return TSDB_COLVAL_ENCODE_DISABLED;
72	0	case TSDB_DATA_TYPE_MEDIUMBLOB:
73	0	return TSDB_COLVAL_ENCODE_DISABLED;
74	0	case TSDB_DATA_TYPE_GEOMETRY:
75	0	return TSDB_COLVAL_ENCODE_DISABLED;
76
77	0	case TSDB_DATA_TYPE_MAX:
78	0	return TSDB_COLVAL_ENCODE_SIMPLE8B;
79
80	0	default:
81	0	return TSDB_COLVAL_ENCODE_SIMPLE8B;
82	0	}
83	0	}
84	0	const char* getDefaultEncodeStr(uint8_t type) { return columnEncodeStr(getDefaultEncode(type)); }
85
86	0	uint16_t getDefaultCompress(uint8_t type) {
87	0	switch (type) {
88	0	case TSDB_DATA_TYPE_NULL:
89	0	return TSDB_COLVAL_COMPRESS_LZ4;
90	0	case TSDB_DATA_TYPE_BOOL:
91	0	return TSDB_COLVAL_COMPRESS_ZSTD;
92	0	case TSDB_DATA_TYPE_TINYINT:
93	0	case TSDB_DATA_TYPE_SMALLINT:
94	0	return TSDB_COLVAL_COMPRESS_ZLIB;
95	0	case TSDB_DATA_TYPE_INT:
96	0	case TSDB_DATA_TYPE_BIGINT:
97	0	return TSDB_COLVAL_COMPRESS_LZ4;
98	0	case TSDB_DATA_TYPE_FLOAT:
99	0	case TSDB_DATA_TYPE_DOUBLE:
100	0	return TSDB_COLVAL_COMPRESS_LZ4;
101	0	case TSDB_DATA_TYPE_VARCHAR: // TSDB_DATA_TYPE_BINARY
102	0	return TSDB_COLVAL_COMPRESS_ZSTD;
103	0	case TSDB_DATA_TYPE_TIMESTAMP:
104	0	return TSDB_COLVAL_COMPRESS_LZ4;
105	0	case TSDB_DATA_TYPE_NCHAR:
106	0	return TSDB_COLVAL_COMPRESS_ZSTD;
107	0	case TSDB_DATA_TYPE_UTINYINT:
108	0	case TSDB_DATA_TYPE_USMALLINT:
109	0	return TSDB_COLVAL_COMPRESS_ZLIB;
110	0	case TSDB_DATA_TYPE_UINT:
111	0	case TSDB_DATA_TYPE_UBIGINT:
112	0	return TSDB_COLVAL_COMPRESS_LZ4;
113	0	case TSDB_DATA_TYPE_JSON:
114	0	return TSDB_COLVAL_COMPRESS_LZ4;
115	0	case TSDB_DATA_TYPE_VARBINARY:
116	0	return TSDB_COLVAL_COMPRESS_ZSTD;
117	0	case TSDB_DATA_TYPE_DECIMAL64:
118	0	case TSDB_DATA_TYPE_DECIMAL:
119	0	return TSDB_COLVAL_COMPRESS_ZSTD;
120	0	case TSDB_DATA_TYPE_BLOB:
121	0	return TSDB_COLVAL_COMPRESS_LZ4;
122	0	case TSDB_DATA_TYPE_MEDIUMBLOB:
123	0	return TSDB_COLVAL_COMPRESS_LZ4;
124	0	case TSDB_DATA_TYPE_GEOMETRY:
125	0	return TSDB_COLVAL_COMPRESS_LZ4;
126	0	case TSDB_DATA_TYPE_MAX:
127	0	return TSDB_COLVAL_COMPRESS_LZ4;
128	0	default:
129	0	return TSDB_COLVAL_COMPRESS_LZ4;
130	0	}
131	0	}
132	0	const char* getDefaultCompressStr(uint8_t type) { return columnCompressStr(getDefaultCompress(type)); }
133
134	0	uint8_t getDefaultLevel(uint8_t type) { return TSDB_COLVAL_LEVEL_MEDIUM; }
135	0	const char* getDefaultLevelStr(uint8_t type) { return columnLevelStr(getDefaultLevel(type)); }
136
137	0	const char* columnEncodeStr(uint8_t type) {
138	0	const char* encode = NULL;
139	0	switch (type) {
140	0	case TSDB_COLVAL_ENCODE_SIMPLE8B:
141	0	encode = TSDB_COLUMN_ENCODE_SIMPLE8B;
142	0	break;
143	0	case TSDB_COLVAL_ENCODE_XOR:
144	0	encode = TSDB_COLUMN_ENCODE_XOR;
145	0	break;
146	0	case TSDB_COLVAL_ENCODE_RLE:
147	0	encode = TSDB_COLUMN_ENCODE_RLE;
148	0	break;
149	0	case TSDB_COLVAL_ENCODE_DELTAD:
150	0	encode = TSDB_COLUMN_ENCODE_DELTAD;
151	0	break;
152	0	case TSDB_COLVAL_ENCODE_DISABLED:
153	0	encode = TSDB_COLUMN_ENCODE_DISABLED;
154	0	break;
155	0	case TSDB_COLVAL_ENCODE_BYTE_STREAM_SPLIT:
156	0	encode = TSDB_COLUMN_ENCODE_BYTE_STREAM_SPLIT;
157	0	break;
158	0	default:
159	0	encode = TSDB_COLUMN_ENCODE_UNKNOWN;
160	0	break;
161	0	}
162	0	return encode;
163	0	}
164
165	0	const char* columnCompressStr(uint16_t type) {
166	0	const char* compress = NULL;
167	0	switch (type) {
168	0	case TSDB_COLVAL_COMPRESS_LZ4:
169	0	compress = TSDB_COLUMN_COMPRESS_LZ4;
170	0	break;
171	0	case TSDB_COLVAL_COMPRESS_TSZ:
172	0	compress = TSDB_COLUMN_COMPRESS_TSZ;
173	0	break;
174	0	case TSDB_COLVAL_COMPRESS_XZ:
175	0	compress = TSDB_COLUMN_COMPRESS_XZ;
176	0	break;
177	0	case TSDB_COLVAL_COMPRESS_ZLIB:
178	0	compress = TSDB_COLUMN_COMPRESS_ZLIB;
179	0	break;
180	0	case TSDB_COLVAL_COMPRESS_ZSTD:
181	0	compress = TSDB_COLUMN_COMPRESS_ZSTD;
182	0	break;
183	0	case TSDB_COLVAL_COMPRESS_DISABLED:
184	0	compress = TSDB_COLUMN_COMPRESS_DISABLED;
185	0	break;
186	0	default:
187	0	compress = TSDB_COLUMN_COMPRESS_UNKNOWN;
188	0	break;
189	0	}
190	0	return compress;
191	0	}
192
193	0	uint8_t columnLevelVal(const char* level) {
194	0	if (level == NULL) return TSDB_COLVAL_LEVEL_NOCHANGE;
195	0	uint8_t l = TSDB_COLVAL_LEVEL_MEDIUM;
196	0	if (0 == strcmp(level, "h") \|\| 0 == strcmp(level, TSDB_COLUMN_LEVEL_HIGH)) {
197	0	l = TSDB_COLVAL_LEVEL_HIGH;
198	0	} else if (0 == strcmp(level, "m") \|\| 0 == strcmp(level, TSDB_COLUMN_LEVEL_MEDIUM)) {
199	0	l = TSDB_COLVAL_LEVEL_MEDIUM;
200	0	} else if (0 == strcmp(level, "l") \|\| 0 == strcmp(level, TSDB_COLUMN_LEVEL_LOW)) {
201	0	l = TSDB_COLVAL_LEVEL_LOW;
202	0	} else {
203	0	l = TSDB_COLVAL_LEVEL_NOCHANGE;
204	0	}
205	0	return l;
206	0	}
207
208	0	uint16_t columnCompressVal(const char* compress) {
209	0	if (compress == NULL) return TSDB_COLVAL_COMPRESS_NOCHANGE;
210	0	uint16_t c = TSDB_COLVAL_COMPRESS_LZ4;
211	0	if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_LZ4)) {
212	0	c = TSDB_COLVAL_COMPRESS_LZ4;
213	0	} else if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_TSZ)) {
214	0	c = TSDB_COLVAL_COMPRESS_TSZ;
215	0	} else if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_XZ)) {
216	0	c = TSDB_COLVAL_COMPRESS_XZ;
217	0	} else if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_ZLIB)) {
218	0	c = TSDB_COLVAL_COMPRESS_ZLIB;
219	0	} else if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_ZSTD)) {
220	0	c = TSDB_COLVAL_COMPRESS_ZSTD;
221	0	} else if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_DISABLED)) {
222	0	c = TSDB_COLVAL_COMPRESS_DISABLED;
223	0	} else {
224	0	c = TSDB_COLVAL_COMPRESS_NOCHANGE;
225	0	}
226	0	return c;
227	0	}
228
229	0	uint8_t columnEncodeVal(const char* encode) {
230	0	if (encode == NULL) return TSDB_COLVAL_ENCODE_NOCHANGE;
231	0	uint8_t e = TSDB_COLVAL_ENCODE_SIMPLE8B;
232	0	if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_SIMPLE8B)) {
233	0	e = TSDB_COLVAL_ENCODE_SIMPLE8B;
234	0	} else if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_XOR)) {
235	0	e = TSDB_COLVAL_ENCODE_XOR;
236	0	} else if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_RLE)) {
237	0	e = TSDB_COLVAL_ENCODE_RLE;
238	0	} else if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_DELTAD)) {
239	0	e = TSDB_COLVAL_ENCODE_DELTAD;
240	0	} else if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_DISABLED)) {
241	0	e = TSDB_COLVAL_ENCODE_DISABLED;
242	0	} else if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_BYTE_STREAM_SPLIT)) {
243	0	e = TSDB_COLVAL_ENCODE_BYTE_STREAM_SPLIT;
244	0	} else {
245	0	e = TSDB_COLVAL_ENCODE_NOCHANGE;
246	0	}
247	0	return e;
248	0	}
249
250	0	const char* columnLevelStr(uint8_t type) {
251	0	const char* level = NULL;
252	0	switch (type) {
253	0	case TSDB_COLVAL_LEVEL_HIGH:
254	0	level = TSDB_COLUMN_LEVEL_HIGH;
255	0	break;
256	0	case TSDB_COLVAL_LEVEL_MEDIUM:
257	0	level = TSDB_COLUMN_LEVEL_MEDIUM;
258	0	break;
259	0	case TSDB_COLVAL_LEVEL_LOW:
260	0	level = TSDB_COLUMN_LEVEL_LOW;
261	0	break;
262	0	default:
263	0	level = TSDB_COLUMN_LEVEL_UNKNOWN;
264	0	break;
265	0	}
266	0	return level;
267	0	}
268
269	0	bool checkColumnEncode(char encode[TSDB_CL_COMPRESS_OPTION_LEN]) {
270	0	if (0 == strlen(encode)) return true;
271	0	TAOS_UNUSED(strtolower(encode, encode));
272	0	for (int i = 0; i < supportedEncodeNum; ++i) {
273	0	if (0 == strcmp((const char*)encode, supportedEncode[i])) {
274	0	return true;
275	0	}
276	0	}
277	0	return false;
278	0	}
279	0	bool checkColumnEncodeOrSetDefault(uint8_t type, char encode[TSDB_CL_COMPRESS_OPTION_LEN]) {
280	0	if (0 == strlen(encode)) {
281	0	tstrncpy(encode, getDefaultEncodeStr(type), TSDB_CL_COMPRESS_OPTION_LEN);
282	0	return true;
283	0	}
284	0	return checkColumnEncode(encode) && validColEncode(type, columnEncodeVal(encode));
285	0	}
286	0	bool checkColumnCompress(char compress[TSDB_CL_COMPRESS_OPTION_LEN]) {
287	0	if (0 == strlen(compress)) return true;
288	0	TAOS_UNUSED(strtolower(compress, compress));
289	0	for (int i = 0; i < supportedCompressNum; ++i) {
290	0	if (0 == strcmp((const char*)compress, supportedCompress[i])) {
291	0	return true;
292	0	}
293	0	}
294	0	return false;
295	0	}
296	0	bool checkColumnCompressOrSetDefault(uint8_t type, char compress[TSDB_CL_COMPRESS_OPTION_LEN]) {
297	0	if (0 == strlen(compress)) {
298	0	tstrncpy(compress, getDefaultCompressStr(type), TSDB_CL_COMPRESS_OPTION_LEN);
299	0	return true;
300	0	}
301
302	0	return checkColumnCompress(compress) && validColCompress(type, columnCompressVal(compress));
303	0	}
304	0	bool checkColumnLevel(char level[TSDB_CL_COMPRESS_OPTION_LEN]) {
305	0	if (0 == strlen(level)) return true;
306	0	TAOS_UNUSED(strtolower(level, level));
307	0	if (1 == strlen(level)) {
308	0	if ('h' == level[0] \|\| 'm' == level[0] \|\| 'l' == level[0]) return true;
309	0	} else {
310	0	for (int i = 0; i < supportedLevelNum; ++i) {
311	0	if (0 == strcmp((const char*)level, supportedLevel[i])) {
312	0	return true;
313	0	}
314	0	}
315	0	}
316	0	return false;
317	0	}
318	0	bool checkColumnLevelOrSetDefault(uint8_t type, char level[TSDB_CL_COMPRESS_OPTION_LEN]) {
319	0	if (0 == strlen(level)) {
320	0	tstrncpy(level, getDefaultLevelStr(type), TSDB_CL_COMPRESS_OPTION_LEN);
321	0	return true;
322	0	}
323	0	return checkColumnLevel(level) && validColCompressLevel(type, columnLevelVal(level));
324	0	}
325
326	0	void setColEncode(uint32_t* compress, uint8_t l1) {
327	0	*compress &= 0x00FFFFFF;
328	0	*compress \|= (l1 << 24);
329	0	return;
330	0	}
331	0	void setColCompress(uint32_t* compress, uint16_t l2) {
332	0	*compress &= 0xFF0000FF;
333	0	*compress \|= (l2 << 8);
334	0	return;
335	0	}
336	0	void setColLevel(uint32_t* compress, uint8_t level) {
337	0	*compress &= 0xFFFFFF00;
338	0	*compress \|= level;
339	0	return;
340	0	}
341
342		int32_t setColCompressByOption(uint8_t type, uint8_t encode, uint16_t compressType, uint8_t level, bool check,
343	0	uint32_t* compress) {
344	0	if (compress == NULL) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;
345	0	if (check && !validColEncode(type, encode)) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;
346	0	setColEncode(compress, encode);
347
348	0	if (compressType == TSDB_COLVAL_COMPRESS_DISABLED) {
349	0	setColCompress(compress, compressType);
350	0	setColLevel(compress, TSDB_COLVAL_LEVEL_DISABLED);
351	0	} else {
352	0	if (check && !validColCompress(type, compressType)) return TSDB_CODE_TSC_COMPRESS_PARAM_ERROR;
353	0	setColCompress(compress, compressType);
354
355	0	if (check && !validColCompressLevel(type, level)) return TSDB_CODE_TSC_COMPRESS_LEVEL_ERROR;
356	0	setColLevel(compress, level);
357	0	}
358	0	return TSDB_CODE_SUCCESS;
359	0	}
360
361	0	bool withColCompress(uint8_t tableType) {
362	0	return TSDB_SUPER_TABLE == tableType \|\| TSDB_NORMAL_TABLE == tableType \|\| TSDB_CHILD_TABLE == tableType;
363	0	}
364
365	0	bool withExtSchema(uint8_t tableType) {
366	0	return TSDB_SUPER_TABLE == tableType \|\| TSDB_NORMAL_TABLE == tableType \|\| TSDB_CHILD_TABLE == tableType \|\|
367	0	TSDB_VIRTUAL_NORMAL_TABLE == tableType \|\| TSDB_VIRTUAL_CHILD_TABLE == tableType;
368	0	}
369
370	0	bool hasColRef(uint8_t tableType) {
371	0	return TSDB_VIRTUAL_NORMAL_TABLE == tableType \|\| TSDB_VIRTUAL_CHILD_TABLE == tableType;
372	0	}
373
374	0	bool hasTagRef(uint8_t tableType) {
375	0	return TSDB_VIRTUAL_NORMAL_TABLE == tableType \|\| TSDB_VIRTUAL_CHILD_TABLE == tableType;
376	0	}
377
378	0	int8_t validColCompressLevel(uint8_t type, uint8_t level) {
379	0	if (level == TSDB_COLVAL_LEVEL_DISABLED) return 1;
380	0	if (level < TSDB_COLVAL_LEVEL_NOCHANGE \|\| level > TSDB_COLVAL_LEVEL_HIGH) {
381	0	return 0;
382	0	}
383	0	return 1;
384	0	}
385	0	int8_t validColCompress(uint8_t type, uint8_t l2) {
386	0	if (l2 > TSDB_COLVAL_COMPRESS_XZ && l2 < TSDB_COLVAL_COMPRESS_DISABLED) {
387	0	return 0;
388	0	}
389	0	if (l2 == TSDB_COLVAL_COMPRESS_TSZ) {
390	0	if (type == TSDB_DATA_TYPE_FLOAT \|\| type == TSDB_DATA_TYPE_DOUBLE) {
391	0	return 1;
392	0	} else {
393	0	return 0;
394	0	}
395	0	}
396	0	return 1;
397	0	}
398
399		//
400		// \| --------type----------\|----- supported encode ----\|
401		// \|tinyint/smallint/int/bigint/utinyint/usmallinit/uint/ubiginint\| simple8b \|
402		// \| timestamp/bigint/ubigint \| delta-i \|
403		// \| bool \| bit-packing \|
404		// \| float/double \| delta-d/byte-stream-split \|
405		//
406	0	int8_t validColEncode(uint8_t type, uint8_t l1) {
407	0	if (l1 == TSDB_COLVAL_ENCODE_NOCHANGE) {
408	0	return 1;
409	0	}
410	0	if (l1 == TSDB_COLVAL_ENCODE_DISABLED) {
411	0	return 1;
412	0	}
413	0	if (type == TSDB_DATA_TYPE_BOOL) {
414	0	return TSDB_COLVAL_ENCODE_RLE == l1 ? 1 : 0;
415	0	} else if (type >= TSDB_DATA_TYPE_TINYINT && type <= TSDB_DATA_TYPE_INT) {
416	0	return TSDB_COLVAL_ENCODE_SIMPLE8B == l1 ? 1 : 0;
417	0	} else if (type == TSDB_DATA_TYPE_BIGINT) {
418	0	return TSDB_COLVAL_ENCODE_SIMPLE8B == l1 \|\| TSDB_COLVAL_ENCODE_XOR == l1 ? 1 : 0;
419	0	} else if (type == TSDB_DATA_TYPE_FLOAT \|\| type == TSDB_DATA_TYPE_DOUBLE) {
420	0	return (l1 == TSDB_COLVAL_ENCODE_DELTAD \|\| l1 == TSDB_COLVAL_ENCODE_BYTE_STREAM_SPLIT) ? 1 : 0;
421	0	} else if ((type == TSDB_DATA_TYPE_VARCHAR \|\| type == TSDB_DATA_TYPE_NCHAR) \|\| type == TSDB_DATA_TYPE_JSON \|\|
422	0	type == TSDB_DATA_TYPE_VARBINARY \|\| type == TSDB_DATA_TYPE_BINARY \|\| type == TSDB_DATA_TYPE_GEOMETRY \|\|
423	0	type == TSDB_DATA_TYPE_BLOB \|\| type == TSDB_DATA_TYPE_MEDIUMBLOB) {
424	0	return l1 == TSDB_COLVAL_ENCODE_DISABLED ? 1 : 0;
425		// if (l1 >= TSDB_COLVAL_ENCODE_NOCHANGE \|\| l1 <= TSDB_COLVAL_ENCODE_DELTAD) {
426		// return 1;
427		// } else if (l1 == TSDB_COLVAL_ENCODE_DISABLED) {
428		// return 1;
429		// } else {
430		// return 0;
431		// }
432	0	} else if (type == TSDB_DATA_TYPE_TIMESTAMP) {
433	0	return TSDB_COLVAL_ENCODE_XOR == l1 ? 1 : 0;
434	0	} else if (type >= TSDB_DATA_TYPE_UTINYINT && type <= TSDB_DATA_TYPE_UINT) {
435	0	return TSDB_COLVAL_ENCODE_SIMPLE8B == l1 ? 1 : 0;
436	0	} else if (type == TSDB_DATA_TYPE_UBIGINT) {
437	0	return TSDB_COLVAL_ENCODE_SIMPLE8B == l1 \|\| TSDB_COLVAL_ENCODE_XOR == l1 ? 1 : 0;
438	0	} else if (type == TSDB_DATA_TYPE_GEOMETRY) {
439	0	return 1;
440	0	} else if (type == TSDB_DATA_TYPE_DECIMAL64 \|\| type == TSDB_DATA_TYPE_DECIMAL) {
441	0	return l1 == TSDB_COLVAL_ENCODE_DISABLED ? 1 : 0;
442	0	}
443	0	return 0;
444	0	}
445
446	0	uint32_t createDefaultColCmprByType(uint8_t type) {
447	0	uint32_t ret = 0;
448	0	uint8_t encode = getDefaultEncode(type);
449	0	uint8_t compress = getDefaultCompress(type);
450	0	uint8_t lvl = getDefaultLevel(type);
451
452	0	SET_COMPRESS(encode, compress, lvl, ret);
453	0	return ret;
454	0	}
455	0	int32_t validColCmprByType(uint8_t type, uint32_t cmpr) {
456	0	DEFINE_VAR(cmpr);
457	0	if (!validColEncode(type, l1)) {
458	0	return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;
459	0	}
460	0	if (!validColCompress(type, l2)) {
461	0	return TSDB_CODE_TSC_COMPRESS_PARAM_ERROR;
462	0	}
463
464	0	if (!validColCompressLevel(type, lvl)) {
465	0	return TSDB_CODE_TSC_COMPRESS_LEVEL_ERROR;
466	0	}
467	0	return TSDB_CODE_SUCCESS;
468	0	}