#3535

Committed 23 Nov 2024 02:07AM UTC coverage: 60.85% (+0.03%) from 60.825%

Build # #3535

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge pull request #28893 from taosdata/doc/internal

refact: rename taos lib name

Run Details

120252 of 252737 branches covered (47.58%)

Branch coverage included in aggregate %.

201187 of 275508 relevant lines covered (73.02%)

15886166.19 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.41

/source/common/src/tcol.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 "tcol.h"
#include "tcompression.h"
#include "tutil.h"

const char* supportedEncode[5] = {TSDB_COLUMN_ENCODE_SIMPLE8B, TSDB_COLUMN_ENCODE_XOR, TSDB_COLUMN_ENCODE_RLE,
                                  TSDB_COLUMN_ENCODE_DELTAD, 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_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_DELTAD;
    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_DECIMAL:
      return TSDB_COLVAL_ENCODE_DELTAD;
    case TSDB_DATA_TYPE_BLOB:
      return TSDB_COLVAL_ENCODE_SIMPLE8B;
    case TSDB_DATA_TYPE_MEDIUMBLOB:
    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_DECIMAL:
      return TSDB_COLVAL_COMPRESS_LZ4;
    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;
    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 {
    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)) {
    strncpy(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)) {
    strncpy(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)) {
    strncpy(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 useCompress(uint8_t tableType) {
  return TSDB_SUPER_TABLE == tableType || TSDB_NORMAL_TABLE == tableType || TSDB_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   |
// | flout/double | delta-d |
//
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 TSDB_COLVAL_ENCODE_DELTAD == l1 ? 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) {
    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;
  }
  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;
}

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	#include "tcol.h"
17	#include "tcompression.h"
18	#include "tutil.h"
19
20	const char* supportedEncode[5] = {TSDB_COLUMN_ENCODE_SIMPLE8B, TSDB_COLUMN_ENCODE_XOR, TSDB_COLUMN_ENCODE_RLE,
21	TSDB_COLUMN_ENCODE_DELTAD, TSDB_COLUMN_ENCODE_DISABLED};
22
23	const char* supportedCompress[6] = {TSDB_COLUMN_COMPRESS_LZ4, TSDB_COLUMN_COMPRESS_TSZ,
24	TSDB_COLUMN_COMPRESS_XZ, TSDB_COLUMN_COMPRESS_ZLIB,
25	TSDB_COLUMN_COMPRESS_ZSTD, TSDB_COLUMN_COMPRESS_DISABLED};
26
27	const char* supportedLevel[3] = {TSDB_COLUMN_LEVEL_HIGH, TSDB_COLUMN_LEVEL_MEDIUM, TSDB_COLUMN_LEVEL_LOW};
28
29	const int supportedEncodeNum = sizeof(supportedEncode) / sizeof(char*);
30	const int supportedCompressNum = sizeof(supportedCompress) / sizeof(char*);
31	const int supportedLevelNum = sizeof(supportedLevel) / sizeof(char*);
32
33	uint8_t getDefaultEncode(uint8_t type) {	190,591,414✔
34	switch (type) {	190,591,414!
35	case TSDB_DATA_TYPE_NULL:	15,307,177✔
36	case TSDB_DATA_TYPE_BOOL:
37	return TSDB_COLVAL_ENCODE_RLE;	15,307,177✔
38	case TSDB_DATA_TYPE_TINYINT:	61,302,012✔
39	case TSDB_DATA_TYPE_SMALLINT:
40	case TSDB_DATA_TYPE_INT:
41	case TSDB_DATA_TYPE_BIGINT:
42	return TSDB_COLVAL_ENCODE_SIMPLE8B;	61,302,012✔
43	case TSDB_DATA_TYPE_FLOAT:	30,602,637✔
44	case TSDB_DATA_TYPE_DOUBLE:
45	return TSDB_COLVAL_ENCODE_DELTAD;	30,602,637✔
46	case TSDB_DATA_TYPE_VARCHAR: // TSDB_DATA_TYPE_BINARY	15,351,356✔
47	return TSDB_COLVAL_ENCODE_DISABLED;	15,351,356✔
48	case TSDB_DATA_TYPE_TIMESTAMP:	22,946,927✔
49	return TSDB_COLVAL_ENCODE_XOR;	22,946,927✔
50	case TSDB_DATA_TYPE_NCHAR:	15,328,527✔
51	return TSDB_COLVAL_ENCODE_DISABLED;	15,328,527✔
52	case TSDB_DATA_TYPE_UTINYINT:	7,642,852✔
53	return TSDB_COLVAL_ENCODE_SIMPLE8B;	7,642,852✔
54	case TSDB_DATA_TYPE_USMALLINT:	7,641,736✔
55	return TSDB_COLVAL_ENCODE_SIMPLE8B;	7,641,736✔
56	case TSDB_DATA_TYPE_UINT:	7,639,509✔
57	return TSDB_COLVAL_ENCODE_SIMPLE8B;	7,639,509✔
58	case TSDB_DATA_TYPE_UBIGINT:	7,641,713✔
59	return TSDB_COLVAL_ENCODE_SIMPLE8B;	7,641,713✔
60	case TSDB_DATA_TYPE_JSON:	×
61	return TSDB_COLVAL_ENCODE_DISABLED;	×
62	case TSDB_DATA_TYPE_VARBINARY:	58✔
63	return TSDB_COLVAL_ENCODE_DISABLED;	58✔
64	case TSDB_DATA_TYPE_DECIMAL:	×
65	return TSDB_COLVAL_ENCODE_DELTAD;	×
66	case TSDB_DATA_TYPE_BLOB:	×
67	return TSDB_COLVAL_ENCODE_SIMPLE8B;	×
68	case TSDB_DATA_TYPE_MEDIUMBLOB:	27✔
69	case TSDB_DATA_TYPE_GEOMETRY:
70	return TSDB_COLVAL_ENCODE_DISABLED;	27✔
71
72	case TSDB_DATA_TYPE_MAX:	×
73	return TSDB_COLVAL_ENCODE_SIMPLE8B;	×
74
75	default:	×
76	return TSDB_COLVAL_ENCODE_SIMPLE8B;	×
77	}
78	}
79	const char* getDefaultEncodeStr(uint8_t type) { return columnEncodeStr(getDefaultEncode(type)); }	443,760✔
80
81	uint16_t getDefaultCompress(uint8_t type) {	190,540,856✔
82	switch (type) {	190,540,856!
83	case TSDB_DATA_TYPE_NULL:	×
84	return TSDB_COLVAL_COMPRESS_LZ4;	×
85	case TSDB_DATA_TYPE_BOOL:	15,306,212✔
86	return TSDB_COLVAL_COMPRESS_ZSTD;	15,306,212✔
87	case TSDB_DATA_TYPE_TINYINT:	30,584,097✔
88	case TSDB_DATA_TYPE_SMALLINT:
89	return TSDB_COLVAL_COMPRESS_ZLIB;	30,584,097✔
90	case TSDB_DATA_TYPE_INT:	30,762,190✔
91	case TSDB_DATA_TYPE_BIGINT:
92	return TSDB_COLVAL_COMPRESS_LZ4;	30,762,190✔
93	case TSDB_DATA_TYPE_FLOAT:	30,598,770✔
94	case TSDB_DATA_TYPE_DOUBLE:
95	return TSDB_COLVAL_COMPRESS_LZ4;	30,598,770✔
96	case TSDB_DATA_TYPE_VARCHAR: // TSDB_DATA_TYPE_BINARY	15,350,214✔
97	return TSDB_COLVAL_COMPRESS_ZSTD;	15,350,214✔
98	case TSDB_DATA_TYPE_TIMESTAMP:	22,946,597✔
99	return TSDB_COLVAL_COMPRESS_LZ4;	22,946,597✔
100	case TSDB_DATA_TYPE_NCHAR:	15,327,278✔
101	return TSDB_COLVAL_COMPRESS_ZSTD;	15,327,278✔
102	case TSDB_DATA_TYPE_UTINYINT:	15,276,810✔
103	case TSDB_DATA_TYPE_USMALLINT:
104	return TSDB_COLVAL_COMPRESS_ZLIB;	15,276,810✔
105	case TSDB_DATA_TYPE_UINT:	15,271,887✔
106	case TSDB_DATA_TYPE_UBIGINT:
107	return TSDB_COLVAL_COMPRESS_LZ4;	15,271,887✔
108	case TSDB_DATA_TYPE_JSON:	×
109	return TSDB_COLVAL_COMPRESS_LZ4;	×
110	case TSDB_DATA_TYPE_VARBINARY:	56✔
111	return TSDB_COLVAL_COMPRESS_ZSTD;	56✔
112	case TSDB_DATA_TYPE_DECIMAL:	×
113	return TSDB_COLVAL_COMPRESS_LZ4;	×
114	case TSDB_DATA_TYPE_BLOB:	×
115	return TSDB_COLVAL_COMPRESS_LZ4;	×
116	case TSDB_DATA_TYPE_MEDIUMBLOB:	×
117	return TSDB_COLVAL_COMPRESS_LZ4;	×
118	case TSDB_DATA_TYPE_GEOMETRY:	27✔
119	return TSDB_COLVAL_COMPRESS_LZ4;	27✔
120	case TSDB_DATA_TYPE_MAX:	×
121	return TSDB_COLVAL_COMPRESS_LZ4;	×
122	default:	×
123	return TSDB_COLVAL_COMPRESS_LZ4;	×
124	}
125	}
126	const char* getDefaultCompressStr(uint8_t type) { return columnCompressStr(getDefaultCompress(type)); }	442,115✔
127
128	uint8_t getDefaultLevel(uint8_t type) { return TSDB_COLVAL_LEVEL_MEDIUM; }	190,510,602✔
129	const char* getDefaultLevelStr(uint8_t type) { return columnLevelStr(getDefaultLevel(type)); }	442,105✔
130
131	const char* columnEncodeStr(uint8_t type) {	4,068,810✔
132	const char* encode = NULL;	4,068,810✔
133	switch (type) {	4,068,810!
134	case TSDB_COLVAL_ENCODE_SIMPLE8B:	2,108,856✔
135	encode = TSDB_COLUMN_ENCODE_SIMPLE8B;	2,108,856✔
136	break;	2,108,856✔
137	case TSDB_COLVAL_ENCODE_XOR:	577,093✔
138	encode = TSDB_COLUMN_ENCODE_XOR;	577,093✔
139	break;	577,093✔
140	case TSDB_COLVAL_ENCODE_RLE:	245,300✔
141	encode = TSDB_COLUMN_ENCODE_RLE;	245,300✔
142	break;	245,300✔
143	case TSDB_COLVAL_ENCODE_DELTAD:	532,455✔
144	encode = TSDB_COLUMN_ENCODE_DELTAD;	532,455✔
145	break;	532,455✔
146	case TSDB_COLVAL_ENCODE_DISABLED:	605,521✔
147	encode = TSDB_COLUMN_ENCODE_DISABLED;	605,521✔
148	break;	605,521✔
149	default:	×
150	encode = TSDB_COLUMN_ENCODE_UNKNOWN;	×
151	break;	×
152	}
153	return encode;	4,068,810✔
154	}
155
156	const char* columnCompressStr(uint16_t type) {	4,066,879✔
157	const char* compress = NULL;	4,066,879✔
158	switch (type) {	4,066,879!
159	case TSDB_COLVAL_COMPRESS_LZ4:	2,656,886✔
160	compress = TSDB_COLUMN_COMPRESS_LZ4;	2,656,886✔
161	break;	2,656,886✔
162	case TSDB_COLVAL_COMPRESS_TSZ:	220✔
163	compress = TSDB_COLUMN_COMPRESS_TSZ;	220✔
164	break;	220✔
165	case TSDB_COLVAL_COMPRESS_XZ:	×
166	compress = TSDB_COLUMN_COMPRESS_XZ;	×
167	break;	×
168	case TSDB_COLVAL_COMPRESS_ZLIB:	559,441✔
169	compress = TSDB_COLUMN_COMPRESS_ZLIB;	559,441✔
170	break;	559,441✔
171	case TSDB_COLVAL_COMPRESS_ZSTD:	850,731✔
172	compress = TSDB_COLUMN_COMPRESS_ZSTD;	850,731✔
173	break;	850,731✔
174	case TSDB_COLVAL_COMPRESS_DISABLED:	4✔
175	compress = TSDB_COLUMN_COMPRESS_DISABLED;	4✔
176	break;	4✔
177	default:	×
178	compress = TSDB_COLUMN_COMPRESS_UNKNOWN;	×
179	break;	×
180	}
181	return compress;	4,066,879✔
182	}
183
184	uint8_t columnLevelVal(const char* level) {	446,198✔
185	if (level == NULL) return TSDB_COLVAL_LEVEL_NOCHANGE;	446,198!
186	uint8_t l = TSDB_COLVAL_LEVEL_MEDIUM;	446,198✔
187	if (0 == strcmp(level, "h") \|\| 0 == strcmp(level, TSDB_COLUMN_LEVEL_HIGH)) {	446,198✔
188	l = TSDB_COLVAL_LEVEL_HIGH;	306✔
189	} else if (0 == strcmp(level, "m") \|\| 0 == strcmp(level, TSDB_COLUMN_LEVEL_MEDIUM)) {	445,892✔
190	l = TSDB_COLVAL_LEVEL_MEDIUM;	445,542✔
191	} else if (0 == strcmp(level, "l") \|\| 0 == strcmp(level, TSDB_COLUMN_LEVEL_LOW)) {	350✔
192	l = TSDB_COLVAL_LEVEL_LOW;	300✔
193	} else {
194	l = TSDB_COLVAL_LEVEL_NOCHANGE;	50✔
195	}
196	return l;	446,198✔
197	}
198
199	uint16_t columnCompressVal(const char* compress) {	446,223✔
200	if (compress == NULL) return TSDB_COLVAL_COMPRESS_NOCHANGE;	446,223!
201	uint16_t c = TSDB_COLVAL_COMPRESS_LZ4;	446,223✔
202	if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_LZ4)) {	446,223✔
203	c = TSDB_COLVAL_COMPRESS_LZ4;	271,376✔
204	} else if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_TSZ)) {	174,847✔
205	c = TSDB_COLVAL_COMPRESS_TSZ;	23✔
206	} else if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_XZ)) {	174,824✔
207	c = TSDB_COLVAL_COMPRESS_XZ;	172✔
208	} else if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_ZLIB)) {	174,652✔
209	c = TSDB_COLVAL_COMPRESS_ZLIB;	47,669✔
210	} else if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_ZSTD)) {	126,983✔
211	c = TSDB_COLVAL_COMPRESS_ZSTD;	126,719✔
212	} else if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_DISABLED)) {	264✔
213	c = TSDB_COLVAL_COMPRESS_DISABLED;	181✔
214	} else {
215	c = TSDB_COLVAL_COMPRESS_NOCHANGE;	83✔
216	}
217	return c;	446,223✔
218	}
219
220	uint8_t columnEncodeVal(const char* encode) {	444,600✔
221	if (encode == NULL) return TSDB_COLVAL_ENCODE_NOCHANGE;	444,600!
222	uint8_t e = TSDB_COLVAL_ENCODE_SIMPLE8B;	444,600✔
223	if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_SIMPLE8B)) {	444,600✔
224	e = TSDB_COLVAL_ENCODE_SIMPLE8B;	228,193✔
225	} else if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_XOR)) {	216,407✔
226	e = TSDB_COLVAL_ENCODE_XOR;	34,650✔
227	} else if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_RLE)) {	181,757✔
228	e = TSDB_COLVAL_ENCODE_RLE;	22,351✔
229	} else if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_DELTAD)) {	159,406✔
230	e = TSDB_COLVAL_ENCODE_DELTAD;	55,027✔
231	} else if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_DISABLED)) {	104,379✔
232	e = TSDB_COLVAL_ENCODE_DISABLED;	104,272✔
233	} else {
234	e = TSDB_COLVAL_ENCODE_NOCHANGE;	107✔
235	}
236	return e;	444,600✔
237	}
238
239	const char* columnLevelStr(uint8_t type) {	4,066,711✔
240	const char* level = NULL;	4,066,711✔
241	switch (type) {	4,066,711!
242	case TSDB_COLVAL_LEVEL_HIGH:	540✔
243	level = TSDB_COLUMN_LEVEL_HIGH;	540✔
244	break;	540✔
245	case TSDB_COLVAL_LEVEL_MEDIUM:	4,065,652✔
246	level = TSDB_COLUMN_LEVEL_MEDIUM;	4,065,652✔
247	break;	4,065,652✔
248	case TSDB_COLVAL_LEVEL_LOW:	530✔
249	level = TSDB_COLUMN_LEVEL_LOW;	530✔
250	break;	530✔
251	default:	×
252	level = TSDB_COLUMN_LEVEL_UNKNOWN;	×
253	break;	×
254	}
255	return level;	4,066,711✔
256	}
257
258	bool checkColumnEncode(char encode[TSDB_CL_COMPRESS_OPTION_LEN]) {	539✔
259	if (0 == strlen(encode)) return true;	539✔
260	TAOS_UNUSED(strtolower(encode, encode));	453✔
261	for (int i = 0; i < supportedEncodeNum; ++i) {	888✔
262	if (0 == strcmp((const char*)encode, supportedEncode[i])) {	870✔
263	return true;	435✔
264	}
265	}
266	return false;	18✔
267	}
268	bool checkColumnEncodeOrSetDefault(uint8_t type, char encode[TSDB_CL_COMPRESS_OPTION_LEN]) {	444,207✔
269	if (0 == strlen(encode)) {	444,207✔
270	strncpy(encode, getDefaultEncodeStr(type), TSDB_CL_COMPRESS_OPTION_LEN);	443,760✔
271	return true;	443,760✔
272	}
273	return checkColumnEncode(encode) && validColEncode(type, columnEncodeVal(encode));	447✔
274	}
275	bool checkColumnCompress(char compress[TSDB_CL_COMPRESS_OPTION_LEN]) {	2,163✔
276	if (0 == strlen(compress)) return true;	2,163✔
277	TAOS_UNUSED(strtolower(compress, compress));	2,102✔
278	for (int i = 0; i < supportedCompressNum; ++i) {	3,524✔
279	if (0 == strcmp((const char*)compress, supportedCompress[i])) {	3,504✔
280	return true;	2,082✔
281	}
282	}
283	return false;	20✔
284	}
285	bool checkColumnCompressOrSetDefault(uint8_t type, char compress[TSDB_CL_COMPRESS_OPTION_LEN]) {	444,186✔
286	if (0 == strlen(compress)) {	444,186✔
287	strncpy(compress, getDefaultCompressStr(type), TSDB_CL_COMPRESS_OPTION_LEN);	442,115✔
288	return true;	442,115✔
289	}
290
291	return checkColumnCompress(compress) && validColCompress(type, columnCompressVal(compress));	2,071✔
292	}
293	bool checkColumnLevel(char level[TSDB_CL_COMPRESS_OPTION_LEN]) {	2,136✔
294	if (0 == strlen(level)) return true;	2,136✔
295	TAOS_UNUSED(strtolower(level, level));	2,111✔
296	if (1 == strlen(level)) {	2,111✔
297	if ('h' == level[0] \|\| 'm' == level[0] \|\| 'l' == level[0]) return true;	19✔
298	} else {
299	for (int i = 0; i < supportedLevelNum; ++i) {	4,227✔
300	if (0 == strcmp((const char*)level, supportedLevel[i])) {	4,208✔
301	return true;	2,073✔
302	}
303	}
304	}
305	return false;	21✔
306	}
307	bool checkColumnLevelOrSetDefault(uint8_t type, char level[TSDB_CL_COMPRESS_OPTION_LEN]) {	444,150✔
308	if (0 == strlen(level)) {	444,150✔
309	strncpy(level, getDefaultLevelStr(type), TSDB_CL_COMPRESS_OPTION_LEN);	442,105✔
310	return true;	442,105✔
311	}
312	return checkColumnLevel(level) && validColCompressLevel(type, columnLevelVal(level));	2,045!
313	}
314
315	void setColEncode(uint32_t* compress, uint8_t l1) {	452,161✔
316	*compress &= 0x00FFFFFF;	452,161✔
317	*compress \|= (l1 << 24);	452,161✔
318	return;	452,161✔
319	}
320	void setColCompress(uint32_t* compress, uint16_t l2) {	452,159✔
321	*compress &= 0xFF0000FF;	452,159✔
322	*compress \|= (l2 << 8);	452,159✔
323	return;	452,159✔
324	}
325	void setColLevel(uint32_t* compress, uint8_t level) {	452,160✔
326	*compress &= 0xFFFFFF00;	452,160✔
327	*compress \|= level;	452,160✔
328	return;	452,160✔
329	}
330
331	int32_t setColCompressByOption(uint8_t type, uint8_t encode, uint16_t compressType, uint8_t level, bool check,	219,379✔
332	uint32_t* compress) {
333	if(compress == NULL) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;	219,379!
334	if (check && !validColEncode(type, encode)) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;	219,379!
335	setColEncode(compress, encode);	219,379✔
336
337	if (compressType == TSDB_COLVAL_COMPRESS_DISABLED) {	219,379✔
338	setColCompress(compress, compressType);	49✔
339	setColLevel(compress, TSDB_COLVAL_LEVEL_DISABLED);	49✔
340	} else {
341	if (check && !validColCompress(type, compressType)) return TSDB_CODE_TSC_COMPRESS_PARAM_ERROR;	219,330✔
342	setColCompress(compress, compressType);	219,329✔
343
344	if (check && !validColCompressLevel(type, level)) return TSDB_CODE_TSC_COMPRESS_LEVEL_ERROR;	219,329!
345	setColLevel(compress, level);	219,329✔
346	}
347	return TSDB_CODE_SUCCESS;	219,378✔
348	}
349
350	bool useCompress(uint8_t tableType) {	6,983,459✔
351	return TSDB_SUPER_TABLE == tableType \|\| TSDB_NORMAL_TABLE == tableType \|\| TSDB_CHILD_TABLE == tableType;	6,983,459✔
352	}
353
354	int8_t validColCompressLevel(uint8_t type, uint8_t level) {	221,130✔
355	if (level == TSDB_COLVAL_LEVEL_DISABLED) return 1;	221,130✔
356	if (level < TSDB_COLVAL_LEVEL_NOCHANGE \|\| level > TSDB_COLVAL_LEVEL_HIGH) {	221,128!
357	return 0;	×
358	}
359	return 1;	221,128✔
360	}
361	int8_t validColCompress(uint8_t type, uint8_t l2) {	221,157✔
362	if (l2 > TSDB_COLVAL_COMPRESS_XZ && l2 < TSDB_COLVAL_COMPRESS_DISABLED) {	221,157!
363	return 0;	×
364	}
365	if (l2 == TSDB_COLVAL_COMPRESS_TSZ) {	221,157✔
366	if (type == TSDB_DATA_TYPE_FLOAT \|\| type == TSDB_DATA_TYPE_DOUBLE) {	21✔
367	return 1;	2✔
368	} else {
369	return 0;	19✔
370	}
371	}
372	return 1;	221,136✔
373	}
374
375	//
376	// \| --------type----------\|----- supported encode ----\|
377	// \|tinyint/smallint/int/bigint/utinyint/usmallinit/uint/ubiginint\| simple8b \|
378	// \| timestamp/bigint/ubigint \| delta-i \|
379	// \| bool \| bit-packing \|
380	// \| flout/double \| delta-d \|
381	//
382	int8_t validColEncode(uint8_t type, uint8_t l1) {	219,539✔
383	if (l1 == TSDB_COLVAL_ENCODE_NOCHANGE) {	219,539✔
384	return 1;	31✔
385	}
386	if (l1 == TSDB_COLVAL_ENCODE_DISABLED) {	219,508✔
387	return 1;	62,906✔
388	}
389	if (type == TSDB_DATA_TYPE_BOOL) {	156,602✔
390	return TSDB_COLVAL_ENCODE_RLE == l1 ? 1 : 0;	9,052✔
391	} else if (type >= TSDB_DATA_TYPE_TINYINT && type <= TSDB_DATA_TYPE_INT) {	147,550!
392	return TSDB_COLVAL_ENCODE_SIMPLE8B == l1 ? 1 : 0;	68,366✔
393	} else if (type == TSDB_DATA_TYPE_BIGINT) {	79,184✔
394	return TSDB_COLVAL_ENCODE_SIMPLE8B == l1 \|\| TSDB_COLVAL_ENCODE_XOR == l1 ? 1 : 0;	25,636✔
395	} else if (type >= TSDB_DATA_TYPE_FLOAT && type <= TSDB_DATA_TYPE_DOUBLE) {	53,548!
396	return TSDB_COLVAL_ENCODE_DELTAD == l1 ? 1 : 0;	26,891✔
397	} else if ((type == TSDB_DATA_TYPE_VARCHAR \|\| type == TSDB_DATA_TYPE_NCHAR) \|\| type == TSDB_DATA_TYPE_JSON \|\|	26,657!
398	type == TSDB_DATA_TYPE_VARBINARY \|\| type == TSDB_DATA_TYPE_BINARY \|\| type == TSDB_DATA_TYPE_GEOMETRY) {	26,655!
399	return l1 == TSDB_COLVAL_ENCODE_DISABLED ? 1 : 0;	2✔
400	// if (l1 >= TSDB_COLVAL_ENCODE_NOCHANGE \|\| l1 <= TSDB_COLVAL_ENCODE_DELTAD) {
401	// return 1;
402	// } else if (l1 == TSDB_COLVAL_ENCODE_DISABLED) {
403	// return 1;
404	// } else {
405	// return 0;
406	// }
407	} else if (type == TSDB_DATA_TYPE_TIMESTAMP) {	26,655✔
408	return TSDB_COLVAL_ENCODE_XOR == l1 ? 1 : 0;	24,281✔
409	} else if (type >= TSDB_DATA_TYPE_UTINYINT && type <= TSDB_DATA_TYPE_UINT) {	2,374!
410	return TSDB_COLVAL_ENCODE_SIMPLE8B == l1 ? 1 : 0;	1,724✔
411	} else if (type == TSDB_DATA_TYPE_UBIGINT) {	650!
412	return TSDB_COLVAL_ENCODE_SIMPLE8B == l1 \|\| TSDB_COLVAL_ENCODE_XOR == l1 ? 1 : 0;	650!
413	} else if (type == TSDB_DATA_TYPE_GEOMETRY) {	×
414	return 1;	×
415	}
416	return 0;	×
417	}
418
419	uint32_t createDefaultColCmprByType(uint8_t type) {	190,047,067✔
420	uint32_t ret = 0;	190,047,067✔
421	uint8_t encode = getDefaultEncode(type);	190,047,067✔
422	uint8_t compress = getDefaultCompress(type);	190,085,453✔
423	uint8_t lvl = getDefaultLevel(type);	190,073,158✔
424
425	SET_COMPRESS(encode, compress, lvl, ret);	189,972,283✔
426	return ret;	189,972,283✔
427	}
428	int32_t validColCmprByType(uint8_t type, uint32_t cmpr) {	25✔
429	DEFINE_VAR(cmpr);	25✔
430	if (!validColEncode(type, l1)) {	25!
431	return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;	×
432	}
433	if (!validColCompress(type, l2)) {	25✔
434	return TSDB_CODE_TSC_COMPRESS_PARAM_ERROR;	1✔
435	}
436
437	if (!validColCompressLevel(type, lvl)) {	24!
438	return TSDB_CODE_TSC_COMPRESS_LEVEL_ERROR;	×
439	}
440	return TSDB_CODE_SUCCESS;	24✔
441	}

taosdata / TDengine / #3535

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous