#4308

Committed 14 Jun 2025 02:06PM UTC coverage: 62.454% (-0.3%) from 62.777%

Build # #4308

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

fix: taosdump windows pthread_mutex_unlock crash(3.0) (#31357)

* fix: windows pthread_mutex_unlock crash

* enh: sync from main fix taosdump crash windows

* fix: restore .github action branch to main

Run Details

153985 of 315105 branches covered (48.87%)

Branch coverage included in aggregate %.

238120 of 312727 relevant lines covered (76.14%)

6462519.65 hits per line

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

86.06

/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_DECIMAL64:
    case TSDB_DATA_TYPE_DECIMAL:
      return TSDB_COLVAL_ENCODE_DISABLED;
    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_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;
    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)) {
    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 withExtSchema(uint8_t tableType) {
  return TSDB_SUPER_TABLE == tableType || TSDB_NORMAL_TABLE == tableType || TSDB_CHILD_TABLE == tableType;
}

bool hasRefCol(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   |
// | 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;
  } 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;
}

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

taosdata / TDengine / #4308

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