#4829

Committed 30 Oct 2025 09:25AM UTC coverage: 49.734% (-11.3%) from 61.071%

Build # #4829

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge pull request #33435 from taosdata/3.0

merge 3.0

Run Details

123072 of 323930 branches covered (37.99%)

Branch coverage included in aggregate %.

7 of 25 new or added lines in 3 files covered. (28.0%)

35232 existing lines in 327 files now uncovered.

172062 of 269495 relevant lines covered (63.85%)

70709785.06 hits per line

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

51.72

/source/dnode/mnode/sdb/src/sdbRaw.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 "sdb.h"

int32_t sdbGetIdFromRaw(SSdb *pSdb, SSdbRaw *pRaw) {
  EKeyType keytype = pSdb->keyTypes[pRaw->type];
  if (keytype == SDB_KEY_INT32) {
    int32_t id = *((int32_t *)(pRaw->pData));
    return id;
  } else {
    return -2;
  }
}

SSdbRaw *sdbAllocRaw(ESdbType type, int8_t sver, int32_t dataLen) {
  SSdbRaw *pRaw = taosMemoryCalloc(1, dataLen + sizeof(SSdbRaw));
  if (pRaw == NULL) {
    terrno = TSDB_CODE_OUT_OF_MEMORY;
    return NULL;
  }

  pRaw->type = type;
  pRaw->sver = sver;
  pRaw->dataLen = dataLen;

#if 1
  mTrace("raw:%p, is created, len:%d table:%s", pRaw, dataLen, sdbTableName(type));
#endif
  return pRaw;
}

void sdbFreeRaw(SSdbRaw *pRaw) {
  if (pRaw != NULL) {
#if 1
    mTrace("raw:%p, is freed, len:%d, table:%s", pRaw, pRaw->dataLen, sdbTableName(pRaw->type));
#endif
    taosMemoryFree(pRaw);
  }
}

int32_t sdbSetRawInt8(SSdbRaw *pRaw, int32_t dataPos, int8_t val) {
  int32_t code = 0;
  if (pRaw == NULL) {
    code = TSDB_CODE_INVALID_PTR;
    TAOS_RETURN(code);
  }

  if (dataPos + sizeof(int8_t) > pRaw->dataLen) {
    code = TSDB_CODE_SDB_INVALID_DATA_LEN;
    TAOS_RETURN(code);
  }

  *(int8_t *)(pRaw->pData + dataPos) = val;
  return 0;
}

int32_t sdbSetRawUInt8(SSdbRaw *pRaw, int32_t dataPos, uint8_t val) {
  int32_t code = 0;
  if (pRaw == NULL) {
    code = TSDB_CODE_INVALID_PTR;
    TAOS_RETURN(code);
  }

  if (dataPos + sizeof(uint8_t) > pRaw->dataLen) {
    code = TSDB_CODE_SDB_INVALID_DATA_LEN;
    TAOS_RETURN(code);
  }

  *(uint8_t *)(pRaw->pData + dataPos) = val;
  return 0;
}

int32_t sdbSetRawBool(SSdbRaw *pRaw, int32_t dataPos, bool val) {
  if (val) {
    return sdbSetRawUInt8(pRaw, dataPos, 1);
  } else {
    return sdbSetRawUInt8(pRaw, dataPos, 0);
  }
}

int32_t sdbSetRawInt32(SSdbRaw *pRaw, int32_t dataPos, int32_t val) {
  int32_t code = 0;
  if (pRaw == NULL) {
    code = TSDB_CODE_INVALID_PTR;
    TAOS_RETURN(code);
  }

  if (dataPos + sizeof(int32_t) > pRaw->dataLen) {
    code = TSDB_CODE_SDB_INVALID_DATA_LEN;
    TAOS_RETURN(code);
  }

  *(int32_t *)(pRaw->pData + dataPos) = val;
  return 0;
}

int32_t sdbSetRawInt16(SSdbRaw *pRaw, int32_t dataPos, int16_t val) {
  int32_t code = 0;
  if (pRaw == NULL) {
    code = TSDB_CODE_INVALID_PTR;
    TAOS_RETURN(code);
  }

  if (dataPos + sizeof(int16_t) > pRaw->dataLen) {
    code = TSDB_CODE_SDB_INVALID_DATA_LEN;
    TAOS_RETURN(code);
  }

  *(int16_t *)(pRaw->pData + dataPos) = val;
  return 0;
}

int32_t sdbSetRawInt64(SSdbRaw *pRaw, int32_t dataPos, int64_t val) {
  int32_t code = 0;
  if (pRaw == NULL) {
    code = TSDB_CODE_INVALID_PTR;
    TAOS_RETURN(code);
  }

  if (dataPos + sizeof(int64_t) > pRaw->dataLen) {
    code = TSDB_CODE_SDB_INVALID_DATA_LEN;
    TAOS_RETURN(code);
  }

  taosSetInt64Aligned((int64_t *)(pRaw->pData + dataPos), val);
  return 0;
}

int32_t sdbSetRawFloat(SSdbRaw *pRaw, int32_t dataPos, float val) {
  int32_t code = 0;
  if (pRaw == NULL) {
    code = TSDB_CODE_INVALID_PTR;
    TAOS_RETURN(code);
  }

  if (dataPos + sizeof(float) > pRaw->dataLen) {
    code = TSDB_CODE_SDB_INVALID_DATA_LEN;
    TAOS_RETURN(code);
  }

  *(int64_t *)(pRaw->pData + dataPos) = val;
  return 0;
}

int32_t sdbSetRawBinary(SSdbRaw *pRaw, int32_t dataPos, const char *pVal, int32_t valLen) {
  int32_t code = 0;
  if (pRaw == NULL) {
    code = TSDB_CODE_INVALID_PTR;
    TAOS_RETURN(code);
  }

  if (dataPos + valLen > pRaw->dataLen) {
    code = TSDB_CODE_SDB_INVALID_DATA_LEN;
    TAOS_RETURN(code);
  }

  if (pVal != NULL) {
    memcpy(pRaw->pData + dataPos, pVal, valLen);
  }
  return 0;
}

int32_t sdbSetRawDataLen(SSdbRaw *pRaw, int32_t dataLen) {
  int32_t code = 0;
  if (pRaw == NULL) {
    code = TSDB_CODE_INVALID_PTR;
    TAOS_RETURN(code);
  }

  if (dataLen > pRaw->dataLen) {
    code = TSDB_CODE_SDB_INVALID_DATA_LEN;
    TAOS_RETURN(code);
  }

  pRaw->dataLen = dataLen;
  return 0;
}

int32_t sdbSetRawStatus(SSdbRaw *pRaw, ESdbStatus status) {
  int32_t code = 0;
  if (pRaw == NULL) {
    code = TSDB_CODE_INVALID_PTR;
    TAOS_RETURN(code);
  }

  if (status == SDB_STATUS_INIT) {
    code = TSDB_CODE_INVALID_PARA;
    TAOS_RETURN(code);
  }

  pRaw->status = status;
  return 0;
}

int32_t sdbGetRawInt8(SSdbRaw *pRaw, int32_t dataPos, int8_t *val) {
  int32_t code = 0;
  if (pRaw == NULL) {
    code = TSDB_CODE_INVALID_PTR;
    TAOS_RETURN(code);
  }

  if (dataPos + sizeof(int8_t) > pRaw->dataLen) {
    code = TSDB_CODE_SDB_INVALID_DATA_LEN;
    TAOS_RETURN(code);
  }

  *val = *(int8_t *)(pRaw->pData + dataPos);
  return 0;
}

int32_t sdbGetRawUInt8(SSdbRaw *pRaw, int32_t dataPos, uint8_t *val) {
  int32_t code = 0;
  if (pRaw == NULL) {
    code = TSDB_CODE_INVALID_PTR;
    TAOS_RETURN(code);
  }

  if (dataPos + sizeof(uint8_t) > pRaw->dataLen) {
    code = TSDB_CODE_SDB_INVALID_DATA_LEN;
    TAOS_RETURN(code);
  }

  *val = *(uint8_t *)(pRaw->pData + dataPos);
  return 0;
}

int32_t sdbGetRawBool(SSdbRaw *pRaw, int32_t dataPos, bool *val) {
  int32_t code = 0;
  uint8_t v = 0;
  code = sdbGetRawUInt8(pRaw, dataPos, &v);
  if (code != TSDB_CODE_SUCCESS) {
    return code;
  }
  if (v) {
    *val = true;
  } else {
    *val = false;
  }
  return TSDB_CODE_SUCCESS;
}

int32_t sdbGetRawInt32(SSdbRaw *pRaw, int32_t dataPos, int32_t *val) {
  int32_t code = 0;
  if (pRaw == NULL) {
    code = TSDB_CODE_INVALID_PTR;
    TAOS_RETURN(code);
  }

  if (dataPos + sizeof(int32_t) > pRaw->dataLen) {
    code = TSDB_CODE_SDB_INVALID_DATA_LEN;
    TAOS_RETURN(code);
  }

  *val = *(int32_t *)(pRaw->pData + dataPos);
  return 0;
}

int32_t sdbGetRawInt16(SSdbRaw *pRaw, int32_t dataPos, int16_t *val) {
  int32_t code = 0;
  if (pRaw == NULL) {
    code = TSDB_CODE_INVALID_PTR;
    TAOS_RETURN(code);
  }

  if (dataPos + sizeof(int16_t) > pRaw->dataLen) {
    code = TSDB_CODE_SDB_INVALID_DATA_LEN;
    TAOS_RETURN(code);
  }

  *val = *(int16_t *)(pRaw->pData + dataPos);
  return 0;
}

int32_t sdbGetRawInt64(SSdbRaw *pRaw, int32_t dataPos, int64_t *val) {
  int32_t code = 0;
  if (pRaw == NULL) {
    code = TSDB_CODE_INVALID_PTR;
    TAOS_RETURN(code);
  }

  if (dataPos + sizeof(int64_t) > pRaw->dataLen) {
    code = TSDB_CODE_SDB_INVALID_DATA_LEN;
    TAOS_RETURN(code);
  }

  taosSetPInt64Aligned(val, (int64_t *)(pRaw->pData + dataPos));
  return 0;
}

int32_t sdbGetRawFloat(SSdbRaw *pRaw, int32_t dataPos, float *val) {
  int32_t code = 0;
  if (pRaw == NULL) {
    code = TSDB_CODE_INVALID_PTR;
    TAOS_RETURN(code);
  }

  if (dataPos + sizeof(float) > pRaw->dataLen) {
    code = TSDB_CODE_SDB_INVALID_DATA_LEN;
    TAOS_RETURN(code);
  }

  *val = *(int64_t *)(pRaw->pData + dataPos);
  return 0;
}

int32_t sdbGetRawBinary(SSdbRaw *pRaw, int32_t dataPos, char *pVal, int32_t valLen) {
  int32_t code = 0;
  if (pRaw == NULL) {
    code = TSDB_CODE_INVALID_PTR;
    TAOS_RETURN(code);
  }

  if (dataPos + valLen > pRaw->dataLen) {
    code = TSDB_CODE_SDB_INVALID_DATA_LEN;
    TAOS_RETURN(code);
  }
  if (pVal != NULL) {
    memcpy(pVal, pRaw->pData + dataPos, valLen);
  }
  return 0;
}

int32_t sdbGetRawSoftVer(SSdbRaw *pRaw, int8_t *sver) {
  int32_t code = 0;
  if (pRaw == NULL) {
    code = TSDB_CODE_INVALID_PTR;
    TAOS_RETURN(code);
  }

  *sver = pRaw->sver;
  return 0;
}

int32_t sdbGetRawTotalSize(SSdbRaw *pRaw) {
  if (pRaw == NULL) {
    terrno = TSDB_CODE_INVALID_PTR;
    return -1;
  }

  return sizeof(SSdbRaw) + pRaw->dataLen;
}

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 "sdb.h"
18
19	int32_t sdbGetIdFromRaw(SSdb pSdb, SSdbRaw pRaw) {	6,830,605✔
20	EKeyType keytype = pSdb->keyTypes[pRaw->type];	6,830,605✔
21	if (keytype == SDB_KEY_INT32) {	6,830,605!
22	int32_t id = ((int32_t )(pRaw->pData));	6,830,605✔
23	return id;	6,830,605✔
24	} else {
UNCOV 25	return -2;	×
26	}
27	}
28
29	SSdbRaw *sdbAllocRaw(ESdbType type, int8_t sver, int32_t dataLen) {	49,875,429✔
30	SSdbRaw *pRaw = taosMemoryCalloc(1, dataLen + sizeof(SSdbRaw));	49,875,429!
31	if (pRaw == NULL) {	49,875,429!
UNCOV 32	terrno = TSDB_CODE_OUT_OF_MEMORY;	×
UNCOV 33	return NULL;	×
34	}
35
36	pRaw->type = type;	49,875,429✔
37	pRaw->sver = sver;	49,875,429✔
38	pRaw->dataLen = dataLen;	49,875,429✔
39
40	#if 1
41	mTrace("raw:%p, is created, len:%d table:%s", pRaw, dataLen, sdbTableName(type));	49,875,429!
42	#endif
43	return pRaw;	49,875,429✔
44	}
45
46	void sdbFreeRaw(SSdbRaw *pRaw) {	35,099,173✔
47	if (pRaw != NULL) {	35,099,173✔
48	#if 1
49	mTrace("raw:%p, is freed, len:%d, table:%s", pRaw, pRaw->dataLen, sdbTableName(pRaw->type));	34,830,694!
50	#endif
51	taosMemoryFree(pRaw);	34,830,694!
52	}
53	}	35,099,173✔
54
55	int32_t sdbSetRawInt8(SSdbRaw *pRaw, int32_t dataPos, int8_t val) {	503,752,251✔
56	int32_t code = 0;	503,752,251✔
57	if (pRaw == NULL) {	503,752,251!
UNCOV 58	code = TSDB_CODE_INVALID_PTR;	×
UNCOV 59	TAOS_RETURN(code);	×
60	}
61
62	if (dataPos + sizeof(int8_t) > pRaw->dataLen) {	503,752,251!
UNCOV 63	code = TSDB_CODE_SDB_INVALID_DATA_LEN;	×
UNCOV 64	TAOS_RETURN(code);	×
65	}
66
67	(int8_t )(pRaw->pData + dataPos) = val;	503,752,251✔
68	return 0;	503,752,251✔
69	}
70
71	int32_t sdbSetRawUInt8(SSdbRaw *pRaw, int32_t dataPos, uint8_t val) {	1,692,791✔
72	int32_t code = 0;	1,692,791✔
73	if (pRaw == NULL) {	1,692,791!
74	code = TSDB_CODE_INVALID_PTR;	×
75	TAOS_RETURN(code);	×
76	}
77
78	if (dataPos + sizeof(uint8_t) > pRaw->dataLen) {	1,692,791!
79	code = TSDB_CODE_SDB_INVALID_DATA_LEN;	×
80	TAOS_RETURN(code);	×
81	}
82
83	(uint8_t )(pRaw->pData + dataPos) = val;	1,692,791✔
84	return 0;	1,692,791✔
85	}
86
87	int32_t sdbSetRawBool(SSdbRaw *pRaw, int32_t dataPos, bool val) {	×
88	if (val) {	×
89	return sdbSetRawUInt8(pRaw, dataPos, 1);	×
90	} else {
91	return sdbSetRawUInt8(pRaw, dataPos, 0);	×
92	}
93	}
94
95	int32_t sdbSetRawInt32(SSdbRaw *pRaw, int32_t dataPos, int32_t val) {	793,011,777✔
96	int32_t code = 0;	793,011,777✔
97	if (pRaw == NULL) {	793,011,777!
UNCOV 98	code = TSDB_CODE_INVALID_PTR;	×
UNCOV 99	TAOS_RETURN(code);	×
100	}
101
102	if (dataPos + sizeof(int32_t) > pRaw->dataLen) {	793,011,777!
UNCOV 103	code = TSDB_CODE_SDB_INVALID_DATA_LEN;	×
UNCOV 104	TAOS_RETURN(code);	×
105	}
106
107	(int32_t )(pRaw->pData + dataPos) = val;	793,011,777✔
108	return 0;	793,011,777✔
109	}
110
111	int32_t sdbSetRawInt16(SSdbRaw *pRaw, int32_t dataPos, int16_t val) {	156,202,234✔
112	int32_t code = 0;	156,202,234✔
113	if (pRaw == NULL) {	156,202,234!
UNCOV 114	code = TSDB_CODE_INVALID_PTR;	×
UNCOV 115	TAOS_RETURN(code);	×
116	}
117
118	if (dataPos + sizeof(int16_t) > pRaw->dataLen) {	156,202,234!
UNCOV 119	code = TSDB_CODE_SDB_INVALID_DATA_LEN;	×
UNCOV 120	TAOS_RETURN(code);	×
121	}
122
123	(int16_t )(pRaw->pData + dataPos) = val;	156,202,234✔
124	return 0;	156,202,234✔
125	}
126
127	int32_t sdbSetRawInt64(SSdbRaw *pRaw, int32_t dataPos, int64_t val) {	62,486,487✔
128	int32_t code = 0;	62,486,487✔
129	if (pRaw == NULL) {	62,486,487!
UNCOV 130	code = TSDB_CODE_INVALID_PTR;	×
UNCOV 131	TAOS_RETURN(code);	×
132	}
133
134	if (dataPos + sizeof(int64_t) > pRaw->dataLen) {	62,486,487!
UNCOV 135	code = TSDB_CODE_SDB_INVALID_DATA_LEN;	×
UNCOV 136	TAOS_RETURN(code);	×
137	}
138
139	taosSetInt64Aligned((int64_t *)(pRaw->pData + dataPos), val);	62,486,487✔
140	return 0;	62,486,487✔
141	}
142
143	int32_t sdbSetRawFloat(SSdbRaw *pRaw, int32_t dataPos, float val) {	×
144	int32_t code = 0;	×
145	if (pRaw == NULL) {	×
146	code = TSDB_CODE_INVALID_PTR;	×
147	TAOS_RETURN(code);	×
148	}
149
150	if (dataPos + sizeof(float) > pRaw->dataLen) {	×
151	code = TSDB_CODE_SDB_INVALID_DATA_LEN;	×
152	TAOS_RETURN(code);	×
153	}
154
155	(int64_t )(pRaw->pData + dataPos) = val;	×
156	return 0;	×
157	}
158
159	int32_t sdbSetRawBinary(SSdbRaw pRaw, int32_t dataPos, const char pVal, int32_t valLen) {	253,417,617✔
160	int32_t code = 0;	253,417,617✔
161	if (pRaw == NULL) {	253,417,617!
UNCOV 162	code = TSDB_CODE_INVALID_PTR;	×
UNCOV 163	TAOS_RETURN(code);	×
164	}
165
166	if (dataPos + valLen > pRaw->dataLen) {	253,417,617!
UNCOV 167	code = TSDB_CODE_SDB_INVALID_DATA_LEN;	×
UNCOV 168	TAOS_RETURN(code);	×
169	}
170
171	if (pVal != NULL) {	253,417,617!
172	memcpy(pRaw->pData + dataPos, pVal, valLen);	253,417,617!
173	}
174	return 0;	253,417,617✔
175	}
176
177	int32_t sdbSetRawDataLen(SSdbRaw *pRaw, int32_t dataLen) {	49,466,258✔
178	int32_t code = 0;	49,466,258✔
179	if (pRaw == NULL) {	49,466,258!
UNCOV 180	code = TSDB_CODE_INVALID_PTR;	×
UNCOV 181	TAOS_RETURN(code);	×
182	}
183
184	if (dataLen > pRaw->dataLen) {	49,466,258!
UNCOV 185	code = TSDB_CODE_SDB_INVALID_DATA_LEN;	×
UNCOV 186	TAOS_RETURN(code);	×
187	}
188
189	pRaw->dataLen = dataLen;	49,466,258✔
190	return 0;	49,466,258✔
191	}
192
193	int32_t sdbSetRawStatus(SSdbRaw *pRaw, ESdbStatus status) {	24,753,741✔
194	int32_t code = 0;	24,753,741✔
195	if (pRaw == NULL) {	24,753,741!
UNCOV 196	code = TSDB_CODE_INVALID_PTR;	×
UNCOV 197	TAOS_RETURN(code);	×
198	}
199
200	if (status == SDB_STATUS_INIT) {	24,753,741!
UNCOV 201	code = TSDB_CODE_INVALID_PARA;	×
UNCOV 202	TAOS_RETURN(code);	×
203	}
204
205	pRaw->status = status;	24,753,741✔
206	return 0;	24,753,741✔
207	}
208
209	int32_t sdbGetRawInt8(SSdbRaw pRaw, int32_t dataPos, int8_t val) {	779,305,889✔
210	int32_t code = 0;	779,305,889✔
211	if (pRaw == NULL) {	779,305,889!
UNCOV 212	code = TSDB_CODE_INVALID_PTR;	×
UNCOV 213	TAOS_RETURN(code);	×
214	}
215
216	if (dataPos + sizeof(int8_t) > pRaw->dataLen) {	779,305,889!
UNCOV 217	code = TSDB_CODE_SDB_INVALID_DATA_LEN;	×
UNCOV 218	TAOS_RETURN(code);	×
219	}
220
221	val = (int8_t *)(pRaw->pData + dataPos);	779,305,889✔
222	return 0;	779,305,889✔
223	}
224
225	int32_t sdbGetRawUInt8(SSdbRaw pRaw, int32_t dataPos, uint8_t val) {	1,438,409✔
226	int32_t code = 0;	1,438,409✔
227	if (pRaw == NULL) {	1,438,409!
228	code = TSDB_CODE_INVALID_PTR;	×
229	TAOS_RETURN(code);	×
230	}
231
232	if (dataPos + sizeof(uint8_t) > pRaw->dataLen) {	1,438,409!
233	code = TSDB_CODE_SDB_INVALID_DATA_LEN;	×
234	TAOS_RETURN(code);	×
235	}
236
237	val = (uint8_t *)(pRaw->pData + dataPos);	1,438,409✔
238	return 0;	1,438,409✔
239	}
240
241	int32_t sdbGetRawBool(SSdbRaw pRaw, int32_t dataPos, bool val) {	×
242	int32_t code = 0;	×
243	uint8_t v = 0;	×
244	code = sdbGetRawUInt8(pRaw, dataPos, &v);	×
245	if (code != TSDB_CODE_SUCCESS) {	×
246	return code;	×
247	}
248	if (v) {	×
249	*val = true;	×
250	} else {
251	*val = false;	×
252	}
253	return TSDB_CODE_SUCCESS;	×
254	}
255
256	int32_t sdbGetRawInt32(SSdbRaw pRaw, int32_t dataPos, int32_t val) {	1,172,592,598✔
257	int32_t code = 0;	1,172,592,598✔
258	if (pRaw == NULL) {	1,172,592,598!
UNCOV 259	code = TSDB_CODE_INVALID_PTR;	×
UNCOV 260	TAOS_RETURN(code);	×
261	}
262
263	if (dataPos + sizeof(int32_t) > pRaw->dataLen) {	1,172,592,598!
UNCOV 264	code = TSDB_CODE_SDB_INVALID_DATA_LEN;	×
UNCOV 265	TAOS_RETURN(code);	×
266	}
267
268	val = (int32_t *)(pRaw->pData + dataPos);	1,172,592,598✔
269	return 0;	1,172,592,598✔
270	}
271
272	int32_t sdbGetRawInt16(SSdbRaw pRaw, int32_t dataPos, int16_t val) {	172,114,626✔
273	int32_t code = 0;	172,114,626✔
274	if (pRaw == NULL) {	172,114,626!
UNCOV 275	code = TSDB_CODE_INVALID_PTR;	×
UNCOV 276	TAOS_RETURN(code);	×
277	}
278
279	if (dataPos + sizeof(int16_t) > pRaw->dataLen) {	172,114,626!
UNCOV 280	code = TSDB_CODE_SDB_INVALID_DATA_LEN;	×
UNCOV 281	TAOS_RETURN(code);	×
282	}
283
284	val = (int16_t *)(pRaw->pData + dataPos);	172,114,626✔
285	return 0;	172,114,626✔
286	}
287
288	int32_t sdbGetRawInt64(SSdbRaw pRaw, int32_t dataPos, int64_t val) {	62,546,903✔
289	int32_t code = 0;	62,546,903✔
290	if (pRaw == NULL) {	62,546,903!
UNCOV 291	code = TSDB_CODE_INVALID_PTR;	×
UNCOV 292	TAOS_RETURN(code);	×
293	}
294
295	if (dataPos + sizeof(int64_t) > pRaw->dataLen) {	62,546,903!
UNCOV 296	code = TSDB_CODE_SDB_INVALID_DATA_LEN;	×
UNCOV 297	TAOS_RETURN(code);	×
298	}
299
300	taosSetPInt64Aligned(val, (int64_t *)(pRaw->pData + dataPos));	62,546,903✔
301	return 0;	62,546,903✔
302	}
303
304	int32_t sdbGetRawFloat(SSdbRaw pRaw, int32_t dataPos, float val) {	×
305	int32_t code = 0;	×
306	if (pRaw == NULL) {	×
307	code = TSDB_CODE_INVALID_PTR;	×
308	TAOS_RETURN(code);	×
309	}
310
311	if (dataPos + sizeof(float) > pRaw->dataLen) {	×
312	code = TSDB_CODE_SDB_INVALID_DATA_LEN;	×
313	TAOS_RETURN(code);	×
314	}
315
316	val = (int64_t *)(pRaw->pData + dataPos);	×
317	return 0;	×
318	}
319
320	int32_t sdbGetRawBinary(SSdbRaw pRaw, int32_t dataPos, char pVal, int32_t valLen) {	328,227,585✔
321	int32_t code = 0;	328,227,585✔
322	if (pRaw == NULL) {	328,227,585!
UNCOV 323	code = TSDB_CODE_INVALID_PTR;	×
UNCOV 324	TAOS_RETURN(code);	×
325	}
326
327	if (dataPos + valLen > pRaw->dataLen) {	328,227,585!
UNCOV 328	code = TSDB_CODE_SDB_INVALID_DATA_LEN;	×
UNCOV 329	TAOS_RETURN(code);	×
330	}
331	if (pVal != NULL) {	328,227,585✔
332	memcpy(pVal, pRaw->pData + dataPos, valLen);	327,245,399!
333	}
334	return 0;	328,227,585✔
335	}
336
337	int32_t sdbGetRawSoftVer(SSdbRaw pRaw, int8_t sver) {	38,294,046✔
338	int32_t code = 0;	38,294,046✔
339	if (pRaw == NULL) {	38,294,046!
UNCOV 340	code = TSDB_CODE_INVALID_PTR;	×
UNCOV 341	TAOS_RETURN(code);	×
342	}
343
344	*sver = pRaw->sver;	38,294,046✔
345	return 0;	38,294,046✔
346	}
347
348	int32_t sdbGetRawTotalSize(SSdbRaw *pRaw) {	101,415,959✔
349	if (pRaw == NULL) {	101,415,959!
UNCOV 350	terrno = TSDB_CODE_INVALID_PTR;	×
UNCOV 351	return -1;	×
352	}
353
354	return sizeof(SSdbRaw) + pRaw->dataLen;	101,415,959✔
355	}

taosdata / TDengine / #4829

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