#3558

Committed 17 Dec 2024 06:05AM UTC coverage: 59.778% (+1.6%) from 58.204%

Build # #3558

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge pull request #29179 from taosdata/merge/mainto3.0

merge: form main to 3.0 branch

Run Details

132787 of 287595 branches covered (46.17%)

Branch coverage included in aggregate %.

104 of 191 new or added lines in 5 files covered. (54.45%)

6085 existing lines in 168 files now uncovered.

209348 of 284746 relevant lines covered (73.52%)

8164844.48 hits per line

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

70.16

/source/common/src/tname.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/>.
 */

#define _DEFAULT_SOURCE
#include "tname.h"
#include "tcommon.h"
#include "tstrbuild.h"

#define VALID_NAME_TYPE(x) ((x) == TSDB_DB_NAME_T || (x) == TSDB_TABLE_NAME_T)

void toName(int32_t acctId, const char* pDbName, const char* pTableName, SName* pName) {
  if (pName == NULL){
    return;
  }
  pName->type = TSDB_TABLE_NAME_T;
  pName->acctId = acctId;
  snprintf(pName->dbname, sizeof(pName->dbname), "%s", pDbName);
  snprintf(pName->tname, sizeof(pName->tname), "%s", pTableName);
}

int32_t tNameExtractFullName(const SName* name, char* dst) {
  // invalid full name format, abort
  if (!tNameIsValid(name)) {
    return TSDB_CODE_INVALID_PARA;
  }

  int32_t len = tsnprintf(dst, TSDB_DB_FNAME_LEN, "%d.%s", name->acctId, name->dbname);

  size_t tnameLen = strlen(name->tname);
  if (tnameLen > 0) {
    dst[len] = TS_PATH_DELIMITER[0];

    memcpy(dst + len + 1, name->tname, tnameLen);
    dst[len + tnameLen + 1] = 0;
  }

  return 0;
}

int32_t tNameLen(const SName* name) {
  char    tmp[12] = {0};
  int32_t len = sprintf(tmp, "%d", name->acctId);
  int32_t len1 = (int32_t)strlen(name->dbname);
  int32_t len2 = (int32_t)strlen(name->tname);

  if (name->type == TSDB_DB_NAME_T) {
    return len + len1 + TSDB_NAME_DELIMITER_LEN;
  } else {
    return len + len1 + len2 + TSDB_NAME_DELIMITER_LEN * 2;
  }
}

bool tNameIsValid(const SName* name) {
  if (!VALID_NAME_TYPE(name->type)) {
    return false;
  }

  if (name->type == TSDB_DB_NAME_T) {
    return strlen(name->dbname) > 0;
  } else {
    return strlen(name->dbname) > 0 && strlen(name->tname) > 0;
  }
}

SName* tNameDup(const SName* name) {
  SName* p = taosMemoryMalloc(sizeof(SName));
  if (p) TAOS_MEMCPY(p, name, sizeof(SName));
  return p;
}

int32_t tNameGetDbName(const SName* name, char* dst) {
  tstrncpy(dst, name->dbname, tListLen(name->dbname));
  return 0;
}

const char* tNameGetDbNameP(const SName* name) { return &name->dbname[0]; }

int32_t tNameGetFullDbName(const SName* name, char* dst) {
  if (name == NULL || dst == NULL) {
    return TSDB_CODE_INVALID_PARA;
  }
  (void)snprintf(dst, TSDB_DB_FNAME_LEN, "%d.%s", name->acctId, name->dbname);
  return 0;
}

bool tNameIsEmpty(const SName* name) { return name->type == 0 || name->acctId == 0; }

const char* tNameGetTableName(const SName* name) {
  if (!(name != NULL && name->type == TSDB_TABLE_NAME_T)) {
    terrno = TSDB_CODE_INVALID_PARA;
    return NULL;
  }
  return &name->tname[0];
}

void tNameAssign(SName* dst, const SName* src) { memcpy(dst, src, sizeof(SName)); }

int32_t tNameSetDbName(SName* dst, int32_t acct, const char* dbName, size_t nameLen) {
  // too long account id or too long db name
  if (nameLen <= 0 || nameLen >= tListLen(dst->dbname)) {
    return TSDB_CODE_INVALID_PARA;
  }

  dst->type = TSDB_DB_NAME_T;
  dst->acctId = acct;
  tstrncpy(dst->dbname, dbName, nameLen + 1);
  return 0;
}

int32_t tNameAddTbName(SName* dst, const char* tbName, size_t nameLen) {
  // too long account id or too long db name
  if (nameLen >= tListLen(dst->tname) || nameLen <= 0) {
    return TSDB_CODE_INVALID_PARA;
  }

  dst->type = TSDB_TABLE_NAME_T;
  tstrncpy(dst->tname, tbName, nameLen + 1);
  return 0;
}

int32_t tNameSetAcctId(SName* dst, int32_t acctId) {
  dst->acctId = acctId;
  return 0;
}

bool tNameDBNameEqual(SName* left, SName* right) {
  if (NULL == left) {
    if (NULL == right) {
      return true;
    }

    return false;
  }

  if (NULL == right) {
    return false;
  }

  if (left->acctId != right->acctId) {
    return false;
  }

  return (0 == strcmp(left->dbname, right->dbname));
}

bool tNameTbNameEqual(SName* left, SName* right) {
  bool equal = tNameDBNameEqual(left, right);
  if (equal) {
    return (0 == strcmp(left->tname, right->tname));
  }

  return equal;
}

int32_t tNameFromString(SName* dst, const char* str, uint32_t type) {
  if (strlen(str) == 0) {
    return TSDB_CODE_INVALID_PARA;
  }

  char* p = NULL;
  if ((type & T_NAME_ACCT) == T_NAME_ACCT) {
    p = strstr(str, TS_PATH_DELIMITER);
    if (p == NULL) {
      return TSDB_CODE_INVALID_PARA;
    }

    dst->acctId = taosStr2Int32(str, NULL, 10);
  }

  if ((type & T_NAME_DB) == T_NAME_DB) {
    dst->type = TSDB_DB_NAME_T;
    char* start = (char*)((p == NULL) ? str : (p + 1));

    int32_t len = 0;
    p = strstr(start, TS_PATH_DELIMITER);
    if (p == NULL) {
      len = (int32_t)strlen(start);
    } else {
      len = (int32_t)(p - start);
    }

    // too long account id or too long db name
    if ((len >= tListLen(dst->dbname)) || (len <= 0)) {
      return TSDB_CODE_INVALID_PARA;
    }

    memcpy(dst->dbname, start, len);
    dst->dbname[len] = 0;
  }

  if ((type & T_NAME_TABLE) == T_NAME_TABLE) {
    dst->type = TSDB_TABLE_NAME_T;
    char* start = (char*)((p == NULL) ? str : (p + 1));

    // too long account id or too long db name
    int32_t len = (int32_t)strlen(start);
    if ((len >= tListLen(dst->tname)) || (len <= 0)) {
      return TSDB_CODE_INVALID_PARA;
    }

    memcpy(dst->tname, start, len);
    dst->tname[len] = 0;
  }

  return 0;
}

static int compareKv(const void* p1, const void* p2) {
  SSmlKv* kv1 = (SSmlKv*)p1;
  SSmlKv* kv2 = (SSmlKv*)p2;
  int32_t kvLen1 = kv1->keyLen;
  int32_t kvLen2 = kv2->keyLen;
  int32_t res = strncasecmp(kv1->key, kv2->key, TMIN(kvLen1, kvLen2));
  if (res != 0) {
    return res;
  } else {
    return kvLen1 - kvLen2;
  }
}

/*
 * use stable name and tags to grearate child table name
 */
int32_t buildChildTableName(RandTableName* rName) {
  SStringBuilder sb = {0};
  taosStringBuilderAppendStringLen(&sb, rName->stbFullName, rName->stbFullNameLen);
  if (sb.buf == NULL) {
    return TSDB_CODE_OUT_OF_MEMORY;
  }

  taosArraySort(rName->tags, compareKv);
  for (int j = 0; j < taosArrayGetSize(rName->tags); ++j) {
    taosStringBuilderAppendChar(&sb, ',');
    SSmlKv* tagKv = taosArrayGet(rName->tags, j);
    if (tagKv == NULL) {
      return TSDB_CODE_SML_INVALID_DATA;
    }

    taosStringBuilderAppendStringLen(&sb, tagKv->key, tagKv->keyLen);
    taosStringBuilderAppendChar(&sb, '=');
    if (IS_VAR_DATA_TYPE(tagKv->type)) {
      taosStringBuilderAppendStringLen(&sb, tagKv->value, tagKv->length);
    } else {
      taosStringBuilderAppendStringLen(&sb, (char*)(&(tagKv->value)), tagKv->length);
    }
  }

  size_t    len = 0;
  char*     keyJoined = taosStringBuilderGetResult(&sb, &len);
  T_MD5_CTX context;
  tMD5Init(&context);
  tMD5Update(&context, (uint8_t*)keyJoined, (uint32_t)len);
  tMD5Final(&context);

  char temp[8] = {0};
  rName->ctbShortName[0] = 't';
  rName->ctbShortName[1] = '_';
  for (int i = 0; i < 16; i++) {
    (void)sprintf(temp, "%02x", context.digest[i]);
    (void)strcat(rName->ctbShortName, temp);
  }
  taosStringBuilderDestroy(&sb);
  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	#define _DEFAULT_SOURCE
17	#include "tname.h"
18	#include "tcommon.h"
19	#include "tstrbuild.h"
20
21	#define VALID_NAME_TYPE(x) ((x) == TSDB_DB_NAME_T \|\| (x) == TSDB_TABLE_NAME_T)
22
23	void toName(int32_t acctId, const char* pDbName, const char* pTableName, SName* pName) {	2,818,922✔
24	if (pName == NULL){	2,818,922!
25	return;	×
26	}
27	pName->type = TSDB_TABLE_NAME_T;	2,818,922✔
28	pName->acctId = acctId;	2,818,922✔
29	snprintf(pName->dbname, sizeof(pName->dbname), "%s", pDbName);	2,818,922✔
30	snprintf(pName->tname, sizeof(pName->tname), "%s", pTableName);	2,818,922✔
31	}
32
33	int32_t tNameExtractFullName(const SName* name, char* dst) {	16,995,836✔
34	// invalid full name format, abort
35	if (!tNameIsValid(name)) {	16,995,836!
36	return TSDB_CODE_INVALID_PARA;	×
37	}
38
39	int32_t len = tsnprintf(dst, TSDB_DB_FNAME_LEN, "%d.%s", name->acctId, name->dbname);	16,996,370✔
40
41	size_t tnameLen = strlen(name->tname);	17,008,454✔
42	if (tnameLen > 0) {	17,008,454✔
43	dst[len] = TS_PATH_DELIMITER[0];	16,993,672✔
44
45	memcpy(dst + len + 1, name->tname, tnameLen);	16,993,672✔
46	dst[len + tnameLen + 1] = 0;	16,993,672✔
47	}
48
49	return 0;	17,008,454✔
50	}
51
52	int32_t tNameLen(const SName* name) {	×
53	char tmp[12] = {0};	×
54	int32_t len = sprintf(tmp, "%d", name->acctId);	×
55	int32_t len1 = (int32_t)strlen(name->dbname);	×
56	int32_t len2 = (int32_t)strlen(name->tname);	×
57
58	if (name->type == TSDB_DB_NAME_T) {	×
59	return len + len1 + TSDB_NAME_DELIMITER_LEN;	×
60	} else {
61	return len + len1 + len2 + TSDB_NAME_DELIMITER_LEN * 2;	×
62	}
63	}
64
65	bool tNameIsValid(const SName* name) {	16,994,092✔
66	if (!VALID_NAME_TYPE(name->type)) {	16,994,092!
67	return false;	×
68	}
69
70	if (name->type == TSDB_DB_NAME_T) {	16,994,092✔
71	return strlen(name->dbname) > 0;	7,185✔
72	} else {
73	return strlen(name->dbname) > 0 && strlen(name->tname) > 0;	16,986,907!
74	}
75	}
76
77	SName* tNameDup(const SName* name) {	×
78	SName* p = taosMemoryMalloc(sizeof(SName));	×
79	if (p) TAOS_MEMCPY(p, name, sizeof(SName));	×
80	return p;	×
81	}
82
83	int32_t tNameGetDbName(const SName* name, char* dst) {	395,637✔
84	tstrncpy(dst, name->dbname, tListLen(name->dbname));	395,637✔
85	return 0;	395,637✔
86	}
87
88	const char* tNameGetDbNameP(const SName* name) { return &name->dbname[0]; }	×
89
90	int32_t tNameGetFullDbName(const SName* name, char* dst) {	24,868,827✔
91	if (name == NULL \|\| dst == NULL) {	24,868,827!
92	return TSDB_CODE_INVALID_PARA;	×
93	}
94	(void)snprintf(dst, TSDB_DB_FNAME_LEN, "%d.%s", name->acctId, name->dbname);	24,876,807✔
95	return 0;	24,876,807✔
96	}
97
98	bool tNameIsEmpty(const SName* name) { return name->type == 0 \|\| name->acctId == 0; }	×
99
100	const char* tNameGetTableName(const SName* name) {	2,095,190✔
101	if (!(name != NULL && name->type == TSDB_TABLE_NAME_T)) {	2,095,190!
102	terrno = TSDB_CODE_INVALID_PARA;	×
103	return NULL;	×
104	}
105	return &name->tname[0];	2,098,847✔
106	}
107
108	void tNameAssign(SName* dst, const SName* src) { memcpy(dst, src, sizeof(SName)); }	412,429✔
109
110	int32_t tNameSetDbName(SName* dst, int32_t acct, const char* dbName, size_t nameLen) {	9,586,302✔
111	// too long account id or too long db name
112	if (nameLen <= 0 \|\| nameLen >= tListLen(dst->dbname)) {	9,586,302!
113	return TSDB_CODE_INVALID_PARA;	×
114	}
115
116	dst->type = TSDB_DB_NAME_T;	9,587,923✔
117	dst->acctId = acct;	9,587,923✔
118	tstrncpy(dst->dbname, dbName, nameLen + 1);	9,587,923✔
119	return 0;	9,587,923✔
120	}
121
122	int32_t tNameAddTbName(SName* dst, const char* tbName, size_t nameLen) {	4,194✔
123	// too long account id or too long db name
124	if (nameLen >= tListLen(dst->tname) \|\| nameLen <= 0) {	4,194!
125	return TSDB_CODE_INVALID_PARA;	×
126	}
127
128	dst->type = TSDB_TABLE_NAME_T;	4,194✔
129	tstrncpy(dst->tname, tbName, nameLen + 1);	4,194✔
130	return 0;	4,194✔
131	}
132
133	int32_t tNameSetAcctId(SName* dst, int32_t acctId) {	×
134	dst->acctId = acctId;	×
135	return 0;	×
136	}
137
138	bool tNameDBNameEqual(SName* left, SName* right) {	10✔
139	if (NULL == left) {	10!
140	if (NULL == right) {	×
141	return true;	×
142	}
143
144	return false;	×
145	}
146
147	if (NULL == right) {	10!
148	return false;	×
149	}
150
151	if (left->acctId != right->acctId) {	10!
152	return false;	×
153	}
154
155	return (0 == strcmp(left->dbname, right->dbname));	10✔
156	}
157
158	bool tNameTbNameEqual(SName* left, SName* right) {	10✔
159	bool equal = tNameDBNameEqual(left, right);	10✔
160	if (equal) {	10✔
161	return (0 == strcmp(left->tname, right->tname));	2✔
162	}
163
164	return equal;	8✔
165	}
166
167	int32_t tNameFromString(SName* dst, const char* str, uint32_t type) {	15,110,455✔
168	if (strlen(str) == 0) {	15,110,455✔
169	return TSDB_CODE_INVALID_PARA;	1✔
170	}
171
172	char* p = NULL;	15,110,454✔
173	if ((type & T_NAME_ACCT) == T_NAME_ACCT) {	15,110,454✔
174	p = strstr(str, TS_PATH_DELIMITER);	5,592,119✔
175	if (p == NULL) {	5,592,119!
176	return TSDB_CODE_INVALID_PARA;	×
177	}
178
179	dst->acctId = taosStr2Int32(str, NULL, 10);	5,592,119✔
180	}
181
182	if ((type & T_NAME_DB) == T_NAME_DB) {	15,110,027✔
183	dst->type = TSDB_DB_NAME_T;	5,590,135✔
184	char* start = (char*)((p == NULL) ? str : (p + 1));	5,590,135!
185
186	int32_t len = 0;	5,590,135✔
187	p = strstr(start, TS_PATH_DELIMITER);	5,590,135✔
188	if (p == NULL) {	5,590,135✔
189	len = (int32_t)strlen(start);	467,785✔
190	} else {
191	len = (int32_t)(p - start);	5,122,350✔
192	}
193
194	// too long account id or too long db name
195	if ((len >= tListLen(dst->dbname)) \|\| (len <= 0)) {	5,590,135!
UNCOV 196	return TSDB_CODE_INVALID_PARA;	×
197	}
198
199	memcpy(dst->dbname, start, len);	5,590,503✔
200	dst->dbname[len] = 0;	5,590,503✔
201	}
202
203	if ((type & T_NAME_TABLE) == T_NAME_TABLE) {	15,110,395✔
204	dst->type = TSDB_TABLE_NAME_T;	14,646,317✔
205	char* start = (char*)((p == NULL) ? str : (p + 1));	14,646,317✔
206
207	// too long account id or too long db name
208	int32_t len = (int32_t)strlen(start);	14,646,317✔
209	if ((len >= tListLen(dst->tname)) \|\| (len <= 0)) {	14,646,317!
210	return TSDB_CODE_INVALID_PARA;	×
211	}
212
213	memcpy(dst->tname, start, len);	14,652,524✔
214	dst->tname[len] = 0;	14,652,524✔
215	}
216
217	return 0;	15,116,602✔
218	}
219
220	static int compareKv(const void* p1, const void* p2) {	9,293✔
221	SSmlKv* kv1 = (SSmlKv*)p1;	9,293✔
222	SSmlKv* kv2 = (SSmlKv*)p2;	9,293✔
223	int32_t kvLen1 = kv1->keyLen;	9,293✔
224	int32_t kvLen2 = kv2->keyLen;	9,293✔
225	int32_t res = strncasecmp(kv1->key, kv2->key, TMIN(kvLen1, kvLen2));	9,293✔
226	if (res != 0) {	9,293✔
227	return res;	9,186✔
228	} else {
229	return kvLen1 - kvLen2;	107✔
230	}
231	}
232
233	/*
234	* use stable name and tags to grearate child table name
235	*/
236	int32_t buildChildTableName(RandTableName* rName) {	77,706✔
237	SStringBuilder sb = {0};	77,706✔
238	taosStringBuilderAppendStringLen(&sb, rName->stbFullName, rName->stbFullNameLen);	77,706✔
239	if (sb.buf == NULL) {	77,706!
240	return TSDB_CODE_OUT_OF_MEMORY;	×
241	}
242
243	taosArraySort(rName->tags, compareKv);	77,706✔
244	for (int j = 0; j < taosArrayGetSize(rName->tags); ++j) {	160,579✔
245	taosStringBuilderAppendChar(&sb, ',');	82,875✔
246	SSmlKv* tagKv = taosArrayGet(rName->tags, j);	82,875✔
247	if (tagKv == NULL) {	82,875!
248	return TSDB_CODE_SML_INVALID_DATA;	×
249	}
250
251	taosStringBuilderAppendStringLen(&sb, tagKv->key, tagKv->keyLen);	82,875✔
252	taosStringBuilderAppendChar(&sb, '=');	82,874✔
253	if (IS_VAR_DATA_TYPE(tagKv->type)) {	82,871!
254	taosStringBuilderAppendStringLen(&sb, tagKv->value, tagKv->length);	4,960✔
255	} else {
256	taosStringBuilderAppendStringLen(&sb, (char*)(&(tagKv->value)), tagKv->length);	77,911✔
257	}
258	}
259
260	size_t len = 0;	77,703✔
261	char* keyJoined = taosStringBuilderGetResult(&sb, &len);	77,703✔
262	T_MD5_CTX context;
263	tMD5Init(&context);	77,704✔
264	tMD5Update(&context, (uint8_t*)keyJoined, (uint32_t)len);	77,704✔
265	tMD5Final(&context);	77,706✔
266
267	char temp[8] = {0};	77,706✔
268	rName->ctbShortName[0] = 't';	77,706✔
269	rName->ctbShortName[1] = '_';	77,706✔
270	for (int i = 0; i < 16; i++) {	1,320,936✔
271	(void)sprintf(temp, "%02x", context.digest[i]);	1,243,230✔
272	(void)strcat(rName->ctbShortName, temp);	1,243,230✔
273	}
274	taosStringBuilderDestroy(&sb);	77,706✔
275	return TSDB_CODE_SUCCESS;	77,706✔
276	}

taosdata / TDengine / #3558

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