#5059

Committed 17 May 2026 01:15AM UTC coverage: 73.443% (+0.06%) from 73.387%

Build # #5059

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

feat (TDgpt): Dynamic Model Synchronization Enhancements (#35344)

* refactor: do some internal refactor.

* fix: fix multiprocess sync issue.

* feat: add dynamic anomaly detection and forecasting services

* fix: log error message for undeploying model in exception handling

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* fix: handle undeploy when model exists only on disk

Agent-Logs-Url: https://github.com/taosdata/TDengine/sessions/286aafa0-c3ce-4c27-b803-2707571e9dc1

Co-authored-by: hjxilinx <8252296+hjxilinx@users.noreply.github.com>

* fix: guard dynamic registry concurrent access

Agent-Logs-Url: https://github.com/taosdata/TDengine/sessions/5e4db858-6458-40f4-ac28-d1b1b7f97c18

Co-authored-by: hjxilinx <8252296+hjxilinx@users.noreply.github.com>

* fix: tighten service list locking scope

Agent-Logs-Url: https://github.com/taosdata/TDengine/sessions/5e4db858-6458-40f4-ac28-d1b1b7f97c18

Co-authored-by: hjxilinx <8252296+hjxilinx@users.noreply.github.com>

* fix: restore prophet support and update tests per review feedback

Agent-Logs-Url: https://github.com/taosdata/TDengine/sessions/92298ae1-7da6-4d07-b20e-101c7cd0b26b

Co-authored-by: hjxilinx <8252296+hjxilinx@users.noreply.github.com>

* fix: improve test name and move copy inside lock scope

Agent-Logs-Url: https://github.com/taosdata/TDengine/sessions/92298ae1-7da6-4d07-b20e-101c7cd0b26b

Co-authored-by: hjxilinx <8252296+hjxilinx@users.noreply.github.com>

* Potential fix for pull request finding

Co-au... (continued)

Coverage Stats

281870 of 383795 relevant lines covered (73.44%)

135516561.93 hits per line

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

92.74

/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[] = {
    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 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   |
// | 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;
}

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	uint8_t getDefaultEncode(uint8_t type) {	379,693,471✔
37	switch (type) {	379,693,471✔
38	case TSDB_DATA_TYPE_NULL:	8,413,244✔
39	case TSDB_DATA_TYPE_BOOL:
40	return TSDB_COLVAL_ENCODE_RLE;	8,413,244✔
41	case TSDB_DATA_TYPE_TINYINT:	64,638,722✔
42	case TSDB_DATA_TYPE_SMALLINT:
43	case TSDB_DATA_TYPE_INT:
44	case TSDB_DATA_TYPE_BIGINT:
45	return TSDB_COLVAL_ENCODE_SIMPLE8B;	64,638,722✔
46	case TSDB_DATA_TYPE_FLOAT:	261,235,829✔
47	case TSDB_DATA_TYPE_DOUBLE:
48	return TSDB_COLVAL_ENCODE_BYTE_STREAM_SPLIT;	261,235,829✔
49	case TSDB_DATA_TYPE_VARCHAR: // TSDB_DATA_TYPE_BINARY	13,363,202✔
50	return TSDB_COLVAL_ENCODE_DISABLED;	13,363,202✔
51	case TSDB_DATA_TYPE_TIMESTAMP:	15,302,996✔
52	return TSDB_COLVAL_ENCODE_XOR;	15,302,996✔
53	case TSDB_DATA_TYPE_NCHAR:	10,558,632✔
54	return TSDB_COLVAL_ENCODE_DISABLED;	10,558,632✔
55	case TSDB_DATA_TYPE_UTINYINT:	1,214,300✔
56	return TSDB_COLVAL_ENCODE_SIMPLE8B;	1,214,300✔
57	case TSDB_DATA_TYPE_USMALLINT:	1,220,000✔
58	return TSDB_COLVAL_ENCODE_SIMPLE8B;	1,220,000✔
59	case TSDB_DATA_TYPE_UINT:	1,285,640✔
60	return TSDB_COLVAL_ENCODE_SIMPLE8B;	1,285,640✔
61	case TSDB_DATA_TYPE_UBIGINT:	1,379,114✔
62	return TSDB_COLVAL_ENCODE_SIMPLE8B;	1,379,114✔
63	case TSDB_DATA_TYPE_JSON:	110✔
64	return TSDB_COLVAL_ENCODE_DISABLED;	110✔
65	case TSDB_DATA_TYPE_VARBINARY:	433,625✔
66	return TSDB_COLVAL_ENCODE_DISABLED;	433,625✔
67	case TSDB_DATA_TYPE_DECIMAL64:	196,252✔
68	case TSDB_DATA_TYPE_DECIMAL:
69	return TSDB_COLVAL_ENCODE_DISABLED;	196,252✔
70	case TSDB_DATA_TYPE_BLOB:	24,292✔
71	return TSDB_COLVAL_ENCODE_DISABLED;	24,292✔
72	case TSDB_DATA_TYPE_MEDIUMBLOB:	×
73	return TSDB_COLVAL_ENCODE_DISABLED;	×
74	case TSDB_DATA_TYPE_GEOMETRY:	427,514✔
75	return TSDB_COLVAL_ENCODE_DISABLED;	427,514✔
76
77	case TSDB_DATA_TYPE_MAX:	×
78	return TSDB_COLVAL_ENCODE_SIMPLE8B;	×
79
80	default:	83✔
81	return TSDB_COLVAL_ENCODE_SIMPLE8B;	83✔
82	}
83	}
84	const char* getDefaultEncodeStr(uint8_t type) { return columnEncodeStr(getDefaultEncode(type)); }	366,952,333✔
85
86	uint16_t getDefaultCompress(uint8_t type) {	379,451,865✔
87	switch (type) {	379,451,865✔
88	case TSDB_DATA_TYPE_NULL:	×
89	return TSDB_COLVAL_COMPRESS_LZ4;	×
90	case TSDB_DATA_TYPE_BOOL:	8,411,396✔
91	return TSDB_COLVAL_COMPRESS_ZSTD;	8,411,396✔
92	case TSDB_DATA_TYPE_TINYINT:	10,702,135✔
93	case TSDB_DATA_TYPE_SMALLINT:
94	return TSDB_COLVAL_COMPRESS_ZLIB;	10,702,135✔
95	case TSDB_DATA_TYPE_INT:	53,746,137✔
96	case TSDB_DATA_TYPE_BIGINT:
97	return TSDB_COLVAL_COMPRESS_LZ4;	53,746,137✔
98	case TSDB_DATA_TYPE_FLOAT:	261,233,343✔
99	case TSDB_DATA_TYPE_DOUBLE:
100	return TSDB_COLVAL_COMPRESS_LZ4;	261,233,343✔
101	case TSDB_DATA_TYPE_VARCHAR: // TSDB_DATA_TYPE_BINARY	13,358,305✔
102	return TSDB_COLVAL_COMPRESS_ZSTD;	13,358,305✔
103	case TSDB_DATA_TYPE_TIMESTAMP:	15,287,754✔
104	return TSDB_COLVAL_COMPRESS_LZ4;	15,287,754✔
105	case TSDB_DATA_TYPE_NCHAR:	10,556,118✔
106	return TSDB_COLVAL_COMPRESS_ZSTD;	10,556,118✔
107	case TSDB_DATA_TYPE_UTINYINT:	2,429,328✔
108	case TSDB_DATA_TYPE_USMALLINT:
109	return TSDB_COLVAL_COMPRESS_ZLIB;	2,429,328✔
110	case TSDB_DATA_TYPE_UINT:	2,659,754✔
111	case TSDB_DATA_TYPE_UBIGINT:
112	return TSDB_COLVAL_COMPRESS_LZ4;	2,659,754✔
113	case TSDB_DATA_TYPE_JSON:	110✔
114	return TSDB_COLVAL_COMPRESS_LZ4;	110✔
115	case TSDB_DATA_TYPE_VARBINARY:	431,139✔
116	return TSDB_COLVAL_COMPRESS_ZSTD;	431,139✔
117	case TSDB_DATA_TYPE_DECIMAL64:	184,596✔
118	case TSDB_DATA_TYPE_DECIMAL:
119	return TSDB_COLVAL_COMPRESS_ZSTD;	184,596✔
120	case TSDB_DATA_TYPE_BLOB:	24,292✔
121	return TSDB_COLVAL_COMPRESS_LZ4;	24,292✔
122	case TSDB_DATA_TYPE_MEDIUMBLOB:	×
123	return TSDB_COLVAL_COMPRESS_LZ4;	×
124	case TSDB_DATA_TYPE_GEOMETRY:	427,514✔
125	return TSDB_COLVAL_COMPRESS_LZ4;	427,514✔
126	case TSDB_DATA_TYPE_MAX:	×
127	return TSDB_COLVAL_COMPRESS_LZ4;	×
128	default:	×
129	return TSDB_COLVAL_COMPRESS_LZ4;	×
130	}
131	}
132	const char* getDefaultCompressStr(uint8_t type) { return columnCompressStr(getDefaultCompress(type)); }	366,710,632✔
133
134	uint8_t getDefaultLevel(uint8_t type) { return TSDB_COLVAL_LEVEL_MEDIUM; }	379,104,024✔
135	const char* getDefaultLevelStr(uint8_t type) { return columnLevelStr(getDefaultLevel(type)); }	366,710,783✔
136
137	const char* columnEncodeStr(uint8_t type) {	1,447,412,513✔
138	const char* encode = NULL;	1,447,412,513✔
139	switch (type) {	1,447,412,513✔
140	case TSDB_COLVAL_ENCODE_SIMPLE8B:	619,854,573✔
141	encode = TSDB_COLUMN_ENCODE_SIMPLE8B;	619,854,573✔
142	break;	619,854,573✔
143	case TSDB_COLVAL_ENCODE_XOR:	150,379,699✔
144	encode = TSDB_COLUMN_ENCODE_XOR;	150,379,699✔
145	break;	150,379,699✔
146	case TSDB_COLVAL_ENCODE_RLE:	56,123,098✔
147	encode = TSDB_COLUMN_ENCODE_RLE;	56,123,098✔
148	break;	56,123,098✔
149	case TSDB_COLVAL_ENCODE_DELTAD:	4,348,507✔
150	encode = TSDB_COLUMN_ENCODE_DELTAD;	4,348,507✔
151	break;	4,348,507✔
152	case TSDB_COLVAL_ENCODE_DISABLED:	160,544,977✔
153	encode = TSDB_COLUMN_ENCODE_DISABLED;	160,544,977✔
154	break;	160,544,977✔
155	case TSDB_COLVAL_ENCODE_BYTE_STREAM_SPLIT:	456,253,854✔
156	encode = TSDB_COLUMN_ENCODE_BYTE_STREAM_SPLIT;	456,253,854✔
157	break;	456,253,854✔
158	default:	200✔
159	encode = TSDB_COLUMN_ENCODE_UNKNOWN;	200✔
160	break;	200✔
161	}
162	return encode;	1,447,412,513✔
163	}
164
165	const char* columnCompressStr(uint16_t type) {	1,447,176,841✔
166	const char* compress = NULL;	1,447,176,841✔
167	switch (type) {	1,447,176,841✔
168	case TSDB_COLVAL_COMPRESS_LZ4:	1,080,299,619✔
169	compress = TSDB_COLUMN_COMPRESS_LZ4;	1,080,299,619✔
170	break;	1,080,299,619✔
171	case TSDB_COLVAL_COMPRESS_TSZ:	1,423,396✔
172	compress = TSDB_COLUMN_COMPRESS_TSZ;	1,423,396✔
173	break;	1,423,396✔
174	case TSDB_COLVAL_COMPRESS_XZ:	66✔
175	compress = TSDB_COLUMN_COMPRESS_XZ;	66✔
176	break;	66✔
177	case TSDB_COLVAL_COMPRESS_ZLIB:	148,995,943✔
178	compress = TSDB_COLUMN_COMPRESS_ZLIB;	148,995,943✔
179	break;	148,995,943✔
180	case TSDB_COLVAL_COMPRESS_ZSTD:	216,501,074✔
181	compress = TSDB_COLUMN_COMPRESS_ZSTD;	216,501,074✔
182	break;	216,501,074✔
183	case TSDB_COLVAL_COMPRESS_DISABLED:	11,526✔
184	compress = TSDB_COLUMN_COMPRESS_DISABLED;	11,526✔
185	break;	11,526✔
186	default:	×
187	compress = TSDB_COLUMN_COMPRESS_UNKNOWN;	×
188	break;	×
189	}
190	return compress;	1,447,176,841✔
191	}
192
193	uint8_t columnLevelVal(const char* level) {	264,611,129✔
194	if (level == NULL) return TSDB_COLVAL_LEVEL_NOCHANGE;	264,611,129✔
195	uint8_t l = TSDB_COLVAL_LEVEL_MEDIUM;	264,611,129✔
196	if (0 == strcmp(level, "h") \|\| 0 == strcmp(level, TSDB_COLUMN_LEVEL_HIGH)) {	264,611,129✔
197	l = TSDB_COLVAL_LEVEL_HIGH;	496,858✔
198	} else if (0 == strcmp(level, "m") \|\| 0 == strcmp(level, TSDB_COLUMN_LEVEL_MEDIUM)) {	264,114,271✔
199	l = TSDB_COLVAL_LEVEL_MEDIUM;	263,421,166✔
200	} else if (0 == strcmp(level, "l") \|\| 0 == strcmp(level, TSDB_COLUMN_LEVEL_LOW)) {	693,105✔
201	l = TSDB_COLVAL_LEVEL_LOW;	397,984✔
202	} else {
203	l = TSDB_COLVAL_LEVEL_NOCHANGE;	295,121✔
204	}
205	return l;	264,611,129✔
206	}
207
208	uint16_t columnCompressVal(const char* compress) {	264,654,884✔
209	if (compress == NULL) return TSDB_COLVAL_COMPRESS_NOCHANGE;	264,654,884✔
210	uint16_t c = TSDB_COLVAL_COMPRESS_LZ4;	264,654,884✔
211	if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_LZ4)) {	264,654,884✔
212	c = TSDB_COLVAL_COMPRESS_LZ4;	223,113,013✔
213	} else if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_TSZ)) {	41,541,871✔
214	c = TSDB_COLVAL_COMPRESS_TSZ;	30,055✔
215	} else if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_XZ)) {	41,511,816✔
216	c = TSDB_COLVAL_COMPRESS_XZ;	229,066✔
217	} else if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_ZLIB)) {	41,282,750✔
218	c = TSDB_COLVAL_COMPRESS_ZLIB;	12,581,122✔
219	} else if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_ZSTD)) {	28,701,628✔
220	c = TSDB_COLVAL_COMPRESS_ZSTD;	28,124,575✔
221	} else if (0 == strcmp(compress, TSDB_COLUMN_COMPRESS_DISABLED)) {	577,053✔
222	c = TSDB_COLVAL_COMPRESS_DISABLED;	241,714✔
223	} else {
224	c = TSDB_COLVAL_COMPRESS_NOCHANGE;	335,339✔
225	}
226	return c;	264,654,884✔
227	}
228
229	uint8_t columnEncodeVal(const char* encode) {	264,450,599✔
230	if (encode == NULL) return TSDB_COLVAL_ENCODE_NOCHANGE;	264,450,599✔
231	uint8_t e = TSDB_COLVAL_ENCODE_SIMPLE8B;	264,450,599✔
232	if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_SIMPLE8B)) {	264,450,599✔
233	e = TSDB_COLVAL_ENCODE_SIMPLE8B;	62,910,976✔
234	} else if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_XOR)) {	201,539,623✔
235	e = TSDB_COLVAL_ENCODE_XOR;	14,037,814✔
236	} else if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_RLE)) {	187,501,809✔
237	e = TSDB_COLVAL_ENCODE_RLE;	5,248,688✔
238	} else if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_DELTAD)) {	182,253,121✔
239	e = TSDB_COLVAL_ENCODE_DELTAD;	182,285✔
240	} else if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_DISABLED)) {	182,070,836✔
241	e = TSDB_COLVAL_ENCODE_DISABLED;	22,968,194✔
242	} else if (0 == strcmp(encode, TSDB_COLUMN_ENCODE_BYTE_STREAM_SPLIT)) {	159,102,642✔
243	e = TSDB_COLVAL_ENCODE_BYTE_STREAM_SPLIT;	158,738,826✔
244	} else {
245	e = TSDB_COLVAL_ENCODE_NOCHANGE;	363,816✔
246	}
247	return e;	264,450,599✔
248	}
249
250	const char* columnLevelStr(uint8_t type) {	1,447,126,141✔
251	const char* level = NULL;	1,447,126,141✔
252	switch (type) {	1,447,126,141✔
253	case TSDB_COLVAL_LEVEL_HIGH:	1,677,704✔
254	level = TSDB_COLUMN_LEVEL_HIGH;	1,677,704✔
255	break;	1,677,704✔
256	case TSDB_COLVAL_LEVEL_MEDIUM:	1,438,313,380✔
257	level = TSDB_COLUMN_LEVEL_MEDIUM;	1,438,313,380✔
258	break;	1,438,313,380✔
259	case TSDB_COLVAL_LEVEL_LOW:	7,158,236✔
260	level = TSDB_COLUMN_LEVEL_LOW;	7,158,236✔
261	break;	7,158,236✔
262	default:	×
263	level = TSDB_COLUMN_LEVEL_UNKNOWN;	×
264	break;	×
265	}
266	return level;	1,447,126,141✔
267	}
268
269	bool checkColumnEncode(char encode[TSDB_CL_COMPRESS_OPTION_LEN]) {	798,618✔
270	if (0 == strlen(encode)) return true;	798,618✔
271	TAOS_UNUSED(strtolower(encode, encode));	690,259✔
272	for (int i = 0; i < supportedEncodeNum; ++i) {	1,537,545✔
273	if (0 == strcmp((const char*)encode, supportedEncode[i])) {	1,515,171✔
274	return true;	667,885✔
275	}
276	}
277	return false;	22,374✔
278	}
279	bool checkColumnEncodeOrSetDefault(uint8_t type, char encode[TSDB_CL_COMPRESS_OPTION_LEN]) {	367,632,582✔
280	if (0 == strlen(encode)) {	367,632,582✔
281	tstrncpy(encode, getDefaultEncodeStr(type), TSDB_CL_COMPRESS_OPTION_LEN);	366,952,333✔
282	return true;	366,952,333✔
283	}
284	return checkColumnEncode(encode) && validColEncode(type, columnEncodeVal(encode));	680,249✔
285	}
286	bool checkColumnCompress(char compress[TSDB_CL_COMPRESS_OPTION_LEN]) {	1,004,212✔
287	if (0 == strlen(compress)) return true;	1,004,212✔
288	TAOS_UNUSED(strtolower(compress, compress));	925,573✔
289	for (int i = 0; i < supportedCompressNum; ++i) {	3,047,485✔
290	if (0 == strcmp((const char*)compress, supportedCompress[i])) {	3,022,559✔
291	return true;	900,647✔
292	}
293	}
294	return false;	24,926✔
295	}
296	bool checkColumnCompressOrSetDefault(uint8_t type, char compress[TSDB_CL_COMPRESS_OPTION_LEN]) {	367,596,475✔
297	if (0 == strlen(compress)) {	367,596,475✔
298	tstrncpy(compress, getDefaultCompressStr(type), TSDB_CL_COMPRESS_OPTION_LEN);	366,710,632✔
299	return true;	366,710,632✔
300	}
301
302	return checkColumnCompress(compress) && validColCompress(type, columnCompressVal(compress));	885,843✔
303	}
304	bool checkColumnLevel(char level[TSDB_CL_COMPRESS_OPTION_LEN]) {	957,938✔
305	if (0 == strlen(level)) return true;	957,938✔
306	TAOS_UNUSED(strtolower(level, level));	923,312✔
307	if (1 == strlen(level)) {	923,312✔
308	if ('h' == level[0] \|\| 'm' == level[0] \|\| 'l' == level[0]) return true;	24,882✔
309	} else {
310	for (int i = 0; i < supportedLevelNum; ++i) {	1,805,602✔
311	if (0 == strcmp((const char*)level, supportedLevel[i])) {	1,781,952✔
312	return true;	874,780✔
313	}
314	}
315	}
316	return false;	26,202✔
317	}
318	bool checkColumnLevelOrSetDefault(uint8_t type, char level[TSDB_CL_COMPRESS_OPTION_LEN]) {	367,551,595✔
319	if (0 == strlen(level)) {	367,551,595✔
320	tstrncpy(level, getDefaultLevelStr(type), TSDB_CL_COMPRESS_OPTION_LEN);	366,710,783✔
321	return true;	366,710,783✔
322	}
323	return checkColumnLevel(level) && validColCompressLevel(type, columnLevelVal(level));	840,812✔
324	}
325
326	void setColEncode(uint32_t* compress, uint8_t l1) {	268,457,018✔
327	*compress &= 0x00FFFFFF;	268,457,018✔
328	*compress \|= (l1 << 24);	268,457,018✔
329	return;	268,457,018✔
330	}
331	void setColCompress(uint32_t* compress, uint16_t l2) {	268,455,659✔
332	*compress &= 0xFF0000FF;	268,455,659✔
333	*compress \|= (l2 << 8);	268,455,659✔
334	return;	268,455,590✔
335	}
336	void setColLevel(uint32_t* compress, uint8_t level) {	268,455,575✔
337	*compress &= 0xFFFFFF00;	268,455,575✔
338	*compress \|= level;	268,455,575✔
339	return;	268,455,575✔
340	}
341
342	int32_t setColCompressByOption(uint8_t type, uint8_t encode, uint16_t compressType, uint8_t level, bool check,	94,145,300✔
343	uint32_t* compress) {
344	if (compress == NULL) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;	94,145,300✔
345	if (check && !validColEncode(type, encode)) return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;	94,145,300✔
346	setColEncode(compress, encode);	94,145,300✔
347
348	if (compressType == TSDB_COLVAL_COMPRESS_DISABLED) {	94,145,300✔
349	setColCompress(compress, compressType);	64,864✔
350	setColLevel(compress, TSDB_COLVAL_LEVEL_DISABLED);	64,864✔
351	} else {
352	if (check && !validColCompress(type, compressType)) return TSDB_CODE_TSC_COMPRESS_PARAM_ERROR;	94,080,436✔
353	setColCompress(compress, compressType);	94,079,160✔
354
355	if (check && !validColCompressLevel(type, level)) return TSDB_CODE_TSC_COMPRESS_LEVEL_ERROR;	94,079,160✔
356	setColLevel(compress, level);	94,079,160✔
357	}
358	return TSDB_CODE_SUCCESS;	94,144,024✔
359	}
360
361	bool withColCompress(uint8_t tableType) {	217,777,049✔
362	return TSDB_SUPER_TABLE == tableType \|\| TSDB_NORMAL_TABLE == tableType \|\| TSDB_CHILD_TABLE == tableType;	217,777,049✔
363	}
364
365	bool withExtSchema(uint8_t tableType) {	2,147,483,647✔
366	return TSDB_SUPER_TABLE == tableType \|\| TSDB_NORMAL_TABLE == tableType \|\| TSDB_CHILD_TABLE == tableType \|\|	2,147,483,647✔
367	TSDB_VIRTUAL_NORMAL_TABLE == tableType \|\| TSDB_VIRTUAL_CHILD_TABLE == tableType;	2,147,483,647✔
368	}
369
370	bool hasRefCol(uint8_t tableType) {	2,147,483,647✔
371	return TSDB_VIRTUAL_NORMAL_TABLE == tableType \|\| TSDB_VIRTUAL_CHILD_TABLE == tableType;	2,147,483,647✔
372	}
373
374	int8_t validColCompressLevel(uint8_t type, uint8_t level) {	94,666,331✔
375	if (level == TSDB_COLVAL_LEVEL_DISABLED) return 1;	94,666,331✔
376	if (level < TSDB_COLVAL_LEVEL_NOCHANGE \|\| level > TSDB_COLVAL_LEVEL_HIGH) {	94,663,779✔
377	return 0;	×
378	}
379	return 1;	94,663,779✔
380	}
381	int8_t validColCompress(uint8_t type, uint8_t l2) {	94,712,638✔
382	if (l2 > TSDB_COLVAL_COMPRESS_XZ && l2 < TSDB_COLVAL_COMPRESS_DISABLED) {	94,712,638✔
383	return 0;	×
384	}
385	if (l2 == TSDB_COLVAL_COMPRESS_TSZ) {	94,712,638✔
386	if (type == TSDB_DATA_TYPE_FLOAT \|\| type == TSDB_DATA_TYPE_DOUBLE) {	29,421✔
387	return 1;	5,672✔
388	} else {
389	return 0;	23,749✔
390	}
391	}
392	return 1;	94,683,217✔
393	}
394
395	//
396	// \| --------type----------\|----- supported encode ----\|
397	// \|tinyint/smallint/int/bigint/utinyint/usmallinit/uint/ubiginint\| simple8b \|
398	// \| timestamp/bigint/ubigint \| delta-i \|
399	// \| bool \| bit-packing \|
400	// \| float/double \| delta-d/byte-stream-split \|
401	//
402	int8_t validColEncode(uint8_t type, uint8_t l1) {	94,515,976✔
403	if (l1 == TSDB_COLVAL_ENCODE_NOCHANGE) {	94,515,976✔
404	return 1;	103,330✔
405	}
406	if (l1 == TSDB_COLVAL_ENCODE_DISABLED) {	94,412,646✔
407	return 1;	15,917,612✔
408	}
409	if (type == TSDB_DATA_TYPE_BOOL) {	78,495,034✔
410	return TSDB_COLVAL_ENCODE_RLE == l1 ? 1 : 0;	2,477,841✔
411	} else if (type >= TSDB_DATA_TYPE_TINYINT && type <= TSDB_DATA_TYPE_INT) {	76,017,193✔
412	return TSDB_COLVAL_ENCODE_SIMPLE8B == l1 ? 1 : 0;	23,190,974✔
413	} else if (type == TSDB_DATA_TYPE_BIGINT) {	52,826,219✔
414	return TSDB_COLVAL_ENCODE_SIMPLE8B == l1 \|\| TSDB_COLVAL_ENCODE_XOR == l1 ? 1 : 0;	6,555,226✔
415	} else if (type == TSDB_DATA_TYPE_FLOAT \|\| type == TSDB_DATA_TYPE_DOUBLE) {	46,270,993✔
416	return (l1 == TSDB_COLVAL_ENCODE_DELTAD \|\| l1 == TSDB_COLVAL_ENCODE_BYTE_STREAM_SPLIT) ? 1 : 0;	31,019,457✔
417	} else if ((type == TSDB_DATA_TYPE_VARCHAR \|\| type == TSDB_DATA_TYPE_NCHAR) \|\| type == TSDB_DATA_TYPE_JSON \|\|	15,251,536✔
418	type == TSDB_DATA_TYPE_VARBINARY \|\| type == TSDB_DATA_TYPE_BINARY \|\| type == TSDB_DATA_TYPE_GEOMETRY \|\|	15,249,050✔
419	type == TSDB_DATA_TYPE_BLOB \|\| type == TSDB_DATA_TYPE_MEDIUMBLOB) {	15,249,050✔
420	return l1 == TSDB_COLVAL_ENCODE_DISABLED ? 1 : 0;	2,486✔
421	// if (l1 >= TSDB_COLVAL_ENCODE_NOCHANGE \|\| l1 <= TSDB_COLVAL_ENCODE_DELTAD) {
422	// return 1;
423	// } else if (l1 == TSDB_COLVAL_ENCODE_DISABLED) {
424	// return 1;
425	// } else {
426	// return 0;
427	// }
428	} else if (type == TSDB_DATA_TYPE_TIMESTAMP) {	15,249,050✔
429	return TSDB_COLVAL_ENCODE_XOR == l1 ? 1 : 0;	11,459,939✔
430	} else if (type >= TSDB_DATA_TYPE_UTINYINT && type <= TSDB_DATA_TYPE_UINT) {	3,789,111✔
431	return TSDB_COLVAL_ENCODE_SIMPLE8B == l1 ? 1 : 0;	2,788,225✔
432	} else if (type == TSDB_DATA_TYPE_UBIGINT) {	1,000,886✔
433	return TSDB_COLVAL_ENCODE_SIMPLE8B == l1 \|\| TSDB_COLVAL_ENCODE_XOR == l1 ? 1 : 0;	990,882✔
434	} else if (type == TSDB_DATA_TYPE_GEOMETRY) {	10,004✔
435	return 1;	×
436	} else if (type == TSDB_DATA_TYPE_DECIMAL64 \|\| type == TSDB_DATA_TYPE_DECIMAL) {	10,004✔
437	return l1 == TSDB_COLVAL_ENCODE_DISABLED ? 1 : 0;	10,004✔
438	}
439	return 0;	×
440	}
441
442	uint32_t createDefaultColCmprByType(uint8_t type) {	7,729,316✔
443	uint32_t ret = 0;	7,729,316✔
444	uint8_t encode = getDefaultEncode(type);	7,729,316✔
445	uint8_t compress = getDefaultCompress(type);	7,729,316✔
446	uint8_t lvl = getDefaultLevel(type);	7,729,031✔
447
448	SET_COMPRESS(encode, compress, lvl, ret);	7,729,031✔
449	return ret;	7,729,031✔
450	}
451	int32_t validColCmprByType(uint8_t type, uint32_t cmpr) {	105,052✔
452	DEFINE_VAR(cmpr);	105,052✔
453	if (!validColEncode(type, l1)) {	105,052✔
454	return TSDB_CODE_TSC_ENCODE_PARAM_ERROR;	1,243✔
455	}
456	if (!validColCompress(type, l2)) {	103,809✔
457	return TSDB_CODE_TSC_COMPRESS_PARAM_ERROR;	1,276✔
458	}
459
460	if (!validColCompressLevel(type, lvl)) {	102,533✔
461	return TSDB_CODE_TSC_COMPRESS_LEVEL_ERROR;	×
462	}
463	return TSDB_CODE_SUCCESS;	102,533✔
464	}

taosdata / TDengine / #5059

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