#5011

Committed 03 Apr 2026 03:59PM UTC coverage: 72.3% (+0.008%) from 72.292%

Build # #5011

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

merge: from main to 3.0 branch #35067

Coverage Stats

4053 of 5985 new or added lines in 68 files covered. (67.72%)

732 existing lines in 143 files now uncovered.

257430 of 356056 relevant lines covered (72.3%)

131834103.52 hits per line

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

76.47

/source/libs/tdb/src/db/tdbTable.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 "tdbInt.h"

struct STTB {
  TDB    *pEnv;
  SBTree *pBt;
};

struct STBC {
  SBTC btc;
};

int tdbTbOpen(const char *tbname, int keyLen, int valLen, tdb_cmpr_fn_t keyCmprFn, TDB *pEnv, TTB **ppTb,
              int8_t rollback) {
  TTB    *pTb;
  SPager *pPager;
  int     ret;
  char    fFullName[TDB_FILENAME_LEN];
  SPage  *pPage;
  SPgno   pgno;
  void   *pData = NULL;
  int     nData = 0;

  *ppTb = NULL;

  pTb = (TTB *)tdbOsCalloc(1, sizeof(*pTb));
  if (pTb == NULL) {
    return terrno;
  }

  // pTb->pEnv
  pTb->pEnv = pEnv;

#ifdef USE_MAINDB
  snprintf(fFullName, TDB_FILENAME_LEN, "%s/%s", pEnv->dbName, TDB_MAINDB_NAME);

  if (strcmp(TDB_MAINDB_NAME, tbname)) {
    pPager = tdbEnvGetPager(pEnv, fFullName);
    if (!pPager) {
      tdbOsFree(pTb);
      return terrno;
    }

    ret = tdbTbGet(pPager->pEnv->pMainDb, tbname, strlen(tbname) + 1, &pData, &nData);
    if (ret < 0) {
      // new pgno & insert into main db
      pgno = 0;
    } else {
      pgno = *(SPgno *)pData;
      tdbFree(pData);
    }

  } else {
    pPager = tdbEnvGetPager(pEnv, fFullName);
    if (pPager == NULL) {
      ret = tdbPagerOpen(pEnv->pCache, fFullName, &pPager);
      if (ret < 0) {
        tdbOsFree(pTb);
        return ret;
      }

      tdbEnvAddPager(pEnv, pPager);

      pPager->pEnv = pEnv;
    }

    if (pPager->dbOrigSize > 0) {
      pgno = 1;
    } else {
      pgno = 0;
    }
  }

#else

  pPager = tdbEnvGetPager(pEnv, tbname);
  if (pPager == NULL) {
    snprintf(fFullName, TDB_FILENAME_LEN, "%s/%s", pEnv->dbName, tbname);
    ret = tdbPagerOpen(pEnv->pCache, fFullName, &pPager);
    if (ret < 0) {
      tdbOsFree(pTb);
      return -1;
    }

    tdbEnvAddPager(pEnv, pPager);
  }

#endif
  /*
  if (rollback) {
    ret = tdbPagerRestoreJournals(pPager);
    if (ret < 0) {
      tdbOsFree(pTb);
      return ret;
    }
  } else {
    ret = tdbPagerRollback(pPager);
    if (ret < 0) {
      tdbOsFree(pTb);
      return ret;
    }
  }
  */
  // Always restore journal files with page flushing
  ret = tdbPagerRestoreJournals(pPager);
  if (ret < 0) {
    tdbOsFree(pTb);
    return ret;
  }

  // pTb->pBt
  ret = tdbBtreeOpen(keyLen, valLen, pPager, tbname, pgno, keyCmprFn, pEnv, &(pTb->pBt));
  if (ret < 0) {
    tdbOsFree(pTb);
    return ret;
  }

  *ppTb = pTb;
  return 0;
}

void tdbTbClose(TTB *pTb) {
  if (pTb) {
    tdbBtreeClose(pTb->pBt);
    tdbOsFree(pTb);
  }
  return;
}

bool tdbTbExist(const char *tbname, TDB *pEnv) {
  bool    exist = false;
  SPager *pPager;
  char    fFullName[TDB_FILENAME_LEN];

#ifdef USE_MAINDB

  snprintf(fFullName, TDB_FILENAME_LEN, "%s/%s", pEnv->dbName, TDB_MAINDB_NAME);

  if (strcmp(TDB_MAINDB_NAME, tbname)) {
    pPager = tdbEnvGetPager(pEnv, fFullName);

    exist = tdbTbGet(pPager->pEnv->pMainDb, tbname, strlen(tbname) + 1, NULL, NULL) == 0;
  } else {
    exist = taosCheckExistFile(fFullName);
  }

#else

  snprintf(fFullName, TDB_FILENAME_LEN, "%s/%s", pEnv->dbName, tbname);

  exist = taosCheckExistFile(fFullName);

#endif

  return exist;
}

int tdbTbDrop(TTB *pTb) {
  // TODO
  return 0;
}

int tdbTbDropByName(const char *tbname, TDB *pEnv, TXN *pTxn) {
  int     ret;
  SPager *pPager;
  char    fFullName[TDB_FILENAME_LEN];

#ifdef USE_MAINDB

  snprintf(fFullName, TDB_FILENAME_LEN, "%s/%s", pEnv->dbName, TDB_MAINDB_NAME);

  if (strcmp(TDB_MAINDB_NAME, tbname)) {
    pPager = tdbEnvGetPager(pEnv, fFullName);

    ret = tdbTbDelete(pPager->pEnv->pMainDb, tbname, strlen(tbname) + 1, pTxn);
  } else {
    ret = taosRemoveFile(fFullName);
  }

#else

  snprintf(fFullName, TDB_FILENAME_LEN, "%s/%s", pEnv->dbName, tbname);

  ret = taosRemoveFile(fFullName);

#endif

  return ret;
}

int tdbTbInsert(TTB *pTb, const void *pKey, int keyLen, const void *pVal, int valLen, TXN *pTxn) {
  return tdbBtreeInsert(pTb->pBt, pKey, keyLen, pVal, valLen, pTxn);
}

int tdbTbDelete(TTB *pTb, const void *pKey, int kLen, TXN *pTxn) { return tdbBtreeDelete(pTb->pBt, pKey, kLen, pTxn); }

int tdbTbUpsert(TTB *pTb, const void *pKey, int kLen, const void *pVal, int vLen, TXN *pTxn) {
  TAOS_UNUSED(tdbTbDelete(pTb, pKey, kLen, pTxn));
  return tdbTbInsert(pTb, pKey, kLen, pVal, vLen, pTxn);
}

int tdbTbGet(TTB *pTb, const void *pKey, int kLen, void **ppVal, int *vLen) {
  return tdbBtreeGet(pTb->pBt, pKey, kLen, ppVal, vLen);
}

int tdbTbPGet(TTB *pTb, const void *pKey, int kLen, void **ppKey, int *pkLen, void **ppVal, int *vLen) {
  return tdbBtreePGet(pTb->pBt, pKey, kLen, ppKey, pkLen, ppVal, vLen);
}

// tdbTbBtreeToStack, tdbTbPushFreePage, tdbTbPopFreePage are only for free page management,
// they are using the b-tree as a stack, never call them for other purpose
int tdbTbBtreeToStack(TTB *pTb) {
  return tdbBtreeToStack(pTb->pBt);
}

int tdbTbPushFreePage(TTB *pTb, SPage* pPage, TXN *pTxn) {
  return tdbBtreePushFreePage(pTb->pBt, pPage, pTxn);
}

int tdbTbPopFreePage(TTB *pTb, SPgno* pgno, TXN *pTxn) {
  return tdbBtreePopFreePage(pTb->pBt, pgno, pTxn);
}

int tdbTbcOpen(TTB *pTb, TBC **ppTbc, TXN *pTxn) {
  int  ret;
  TBC *pTbc = NULL;

  *ppTbc = NULL;
  pTbc = (TBC *)tdbOsMalloc(sizeof(*pTbc));
  if (pTbc == NULL) {
    return terrno;
  }

  if ((ret = tdbBtcOpen(&pTbc->btc, pTb->pBt, pTxn)) != 0) {
    tdbOsFree(pTbc);
    return ret;
  }

  *ppTbc = pTbc;
  return 0;
}

int32_t tdbTbTraversal(TTB *pTb, void *data,
                       int32_t (*func)(const void *pKey, int keyLen, const void *pVal, int valLen, void *data)) {
  TBC *pCur;
  int  ret = tdbTbcOpen(pTb, &pCur, NULL);
  if (ret < 0) {
    return ret;
  }

  ret = tdbTbcMoveToFirst(pCur);
  if (ret < 0) {
    tdbTbcClose(pCur);
    return ret;
  }

  void *pKey = NULL;
  int   kLen = 0;
  void *pValue = NULL;
  int   vLen = 0;

  while (1) {
    ret = tdbTbcNext(pCur, &pKey, &kLen, &pValue, &vLen);
    if (ret < 0) {
      ret = 0;
      break;
    }

    ret = func(pKey, kLen, pValue, vLen, data);
    if (ret < 0) break;
  }
  tdbFree(pKey);
  tdbFree(pValue);
  tdbTbcClose(pCur);

  return 0;
}

int tdbTbcMoveTo(TBC *pTbc, const void *pKey, int kLen, int *c) { return tdbBtcMoveTo(&pTbc->btc, pKey, kLen, c); }

int tdbTbcMoveToFirst(TBC *pTbc) { return tdbBtcMoveToFirst(&pTbc->btc); }

int tdbTbcMoveToLast(TBC *pTbc) { return tdbBtcMoveToLast(&pTbc->btc); }

int tdbTbcMoveToNext(TBC *pTbc) { return tdbBtcMoveToNext(&pTbc->btc); }

int tdbTbcMoveToPrev(TBC *pTbc) { return tdbBtcMoveToPrev(&pTbc->btc); }

int tdbTbcGet(TBC *pTbc, const void **ppKey, int *pkLen, const void **ppVal, int *pvLen) {
  return tdbBtcGet(&pTbc->btc, ppKey, pkLen, ppVal, pvLen);
}

int tdbTbcDelete(TBC *pTbc) { return tdbBtcDelete(&pTbc->btc); }

int tdbTbcNext(TBC *pTbc, void **ppKey, int *kLen, void **ppVal, int *vLen) {
  return tdbBtreeNext(&pTbc->btc, ppKey, kLen, ppVal, vLen);
}

int tdbTbcPrev(TBC *pTbc, void **ppKey, int *kLen, void **ppVal, int *vLen) {
  return tdbBtreePrev(&pTbc->btc, ppKey, kLen, ppVal, vLen);
}

int tdbTbcUpsert(TBC *pTbc, const void *pKey, int nKey, const void *pData, int nData, int insert) {
  return tdbBtcUpsert(&pTbc->btc, pKey, nKey, pData, nData, insert);
}

void tdbTbcClose(TBC *pTbc) {
  if (pTbc) {
    tdbBtcClose(&pTbc->btc);
    tdbOsFree(pTbc);
  }
}

int tdbTbcIsValid(TBC *pTbc) { return tdbBtcIsValid(&pTbc->btc); }

1	/*
2	* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
3	*
4	* This program is free software: you can use, redistribute, and/or modify
5	* it under the terms of the GNU Affero General Public License, version 3
6	* or later ("AGPL"), as published by the Free Software Foundation.
7	*
8	* This program is distributed in the hope that it will be useful, but WITHOUT
9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10	* FITNESS FOR A PARTICULAR PURPOSE.
11	*
12	* You should have received a copy of the GNU Affero General Public License
13	* along with this program. If not, see <http://www.gnu.org/licenses/>.
14	*/
15
16	#include "tdbInt.h"
17
18	struct STTB {
19	TDB *pEnv;
20	SBTree *pBt;
21	};
22
23	struct STBC {
24	SBTC btc;
25	};
26
27	int tdbTbOpen(const char tbname, int keyLen, int valLen, tdb_cmpr_fn_t keyCmprFn, TDB pEnv, TTB **ppTb,	80,225,242✔
28	int8_t rollback) {
29	TTB *pTb;
30	SPager *pPager;	80,137,268✔
31	int ret;
32	char fFullName[TDB_FILENAME_LEN];	80,137,933✔
33	SPage *pPage;
34	SPgno pgno;
35	void *pData = NULL;	80,227,339✔
36	int nData = 0;	80,228,879✔
37
38	*ppTb = NULL;	80,192,117✔
39
40	pTb = (TTB )tdbOsCalloc(1, sizeof(pTb));	80,194,814✔
41	if (pTb == NULL) {	80,215,667✔
42	return terrno;	×
43	}
44
45	// pTb->pEnv
46	pTb->pEnv = pEnv;	80,215,667✔
47
48	#ifdef USE_MAINDB
49	snprintf(fFullName, TDB_FILENAME_LEN, "%s/%s", pEnv->dbName, TDB_MAINDB_NAME);	80,216,945✔
50
51	if (strcmp(TDB_MAINDB_NAME, tbname)) {	80,216,246✔
52	pPager = tdbEnvGetPager(pEnv, fFullName);	71,303,377✔
53	if (!pPager) {	71,320,512✔
54	tdbOsFree(pTb);	×
55	return terrno;	×
56	}
57
58	ret = tdbTbGet(pPager->pEnv->pMainDb, tbname, strlen(tbname) + 1, &pData, &nData);	71,320,512✔
59	if (ret < 0) {	71,307,796✔
60	// new pgno & insert into main db
61	pgno = 0;	51,857,785✔
62	} else {
63	pgno = (SPgno )pData;	19,450,011✔
64	tdbFree(pData);	19,451,531✔
65	}
66
67	} else {
68	pPager = tdbEnvGetPager(pEnv, fFullName);	8,912,869✔
69	if (pPager == NULL) {	8,913,515✔
70	ret = tdbPagerOpen(pEnv->pCache, fFullName, &pPager);	8,913,854✔
71	if (ret < 0) {	8,912,912✔
72	tdbOsFree(pTb);	×
73	return ret;	×
74	}
75
76	tdbEnvAddPager(pEnv, pPager);	8,912,912✔
77
78	pPager->pEnv = pEnv;	8,910,927✔
79	}
80
81	if (pPager->dbOrigSize > 0) {	8,912,686✔
82	pgno = 1;	2,428,607✔
83	} else {
84	pgno = 0;	6,481,897✔
85	}
86	}
87
88	#else
89
90	pPager = tdbEnvGetPager(pEnv, tbname);
91	if (pPager == NULL) {
92	snprintf(fFullName, TDB_FILENAME_LEN, "%s/%s", pEnv->dbName, tbname);
93	ret = tdbPagerOpen(pEnv->pCache, fFullName, &pPager);
94	if (ret < 0) {
95	tdbOsFree(pTb);
96	return -1;
97	}
98
99	tdbEnvAddPager(pEnv, pPager);
100	}
101
102	#endif
103	/*
104	if (rollback) {
105	ret = tdbPagerRestoreJournals(pPager);
106	if (ret < 0) {
107	tdbOsFree(pTb);
108	return ret;
109	}
110	} else {
111	ret = tdbPagerRollback(pPager);
112	if (ret < 0) {
113	tdbOsFree(pTb);
114	return ret;
115	}
116	}
117	*/
118	// Always restore journal files with page flushing
119	ret = tdbPagerRestoreJournals(pPager);	80,217,013✔
120	if (ret < 0) {	80,220,993✔
121	tdbOsFree(pTb);	×
122	return ret;	×
123	}
124
125	// pTb->pBt
126	ret = tdbBtreeOpen(keyLen, valLen, pPager, tbname, pgno, keyCmprFn, pEnv, &(pTb->pBt));	80,220,993✔
127	if (ret < 0) {	80,190,995✔
128	tdbOsFree(pTb);	28✔
129	return ret;	×
130	}
131
132	*ppTb = pTb;	80,190,967✔
133	return 0;	80,195,334✔
134	}
135
136	void tdbTbClose(TTB *pTb) {	80,253,427✔
137	if (pTb) {	80,253,427✔
138	tdbBtreeClose(pTb->pBt);	80,253,427✔
139	tdbOsFree(pTb);	80,254,257✔
140	}
141	return;	80,254,257✔
142	}
143
144	bool tdbTbExist(const char tbname, TDB pEnv) {	4,452,803✔
145	bool exist = false;	4,452,803✔
146	SPager *pPager;
147	char fFullName[TDB_FILENAME_LEN];	4,448,174✔
148
149	#ifdef USE_MAINDB
150
151	snprintf(fFullName, TDB_FILENAME_LEN, "%s/%s", pEnv->dbName, TDB_MAINDB_NAME);	4,452,803✔
152
153	if (strcmp(TDB_MAINDB_NAME, tbname)) {	4,452,803✔
154	pPager = tdbEnvGetPager(pEnv, fFullName);	4,452,803✔
155
156	exist = tdbTbGet(pPager->pEnv->pMainDb, tbname, strlen(tbname) + 1, NULL, NULL) == 0;	4,452,803✔
157	} else {
158	exist = taosCheckExistFile(fFullName);	×
159	}
160
161	#else
162
163	snprintf(fFullName, TDB_FILENAME_LEN, "%s/%s", pEnv->dbName, tbname);
164
165	exist = taosCheckExistFile(fFullName);
166
167	#endif
168
169	return exist;	4,452,747✔
170	}
171
172	int tdbTbDrop(TTB *pTb) {	×
173	// TODO
174	return 0;	×
175	}
176
177	int tdbTbDropByName(const char tbname, TDB pEnv, TXN *pTxn) {	×
178	int ret;
179	SPager *pPager;
180	char fFullName[TDB_FILENAME_LEN];	×
181
182	#ifdef USE_MAINDB
183
184	snprintf(fFullName, TDB_FILENAME_LEN, "%s/%s", pEnv->dbName, TDB_MAINDB_NAME);	×
185
186	if (strcmp(TDB_MAINDB_NAME, tbname)) {	×
187	pPager = tdbEnvGetPager(pEnv, fFullName);	×
188
189	ret = tdbTbDelete(pPager->pEnv->pMainDb, tbname, strlen(tbname) + 1, pTxn);	×
190	} else {
191	ret = taosRemoveFile(fFullName);	×
192	}
193
194	#else
195
196	snprintf(fFullName, TDB_FILENAME_LEN, "%s/%s", pEnv->dbName, tbname);
197
198	ret = taosRemoveFile(fFullName);
199
200	#endif
201
202	return ret;	×
203	}
204
205	int tdbTbInsert(TTB pTb, const void pKey, int keyLen, const void pVal, int valLen, TXN pTxn) {	638,253,076✔
206	return tdbBtreeInsert(pTb->pBt, pKey, keyLen, pVal, valLen, pTxn);	638,253,076✔
207	}
208
209	int tdbTbDelete(TTB pTb, const void pKey, int kLen, TXN *pTxn) { return tdbBtreeDelete(pTb->pBt, pKey, kLen, pTxn); }	102,332,463✔
210
211	int tdbTbUpsert(TTB pTb, const void pKey, int kLen, const void pVal, int vLen, TXN pTxn) {	74,415,431✔
212	TAOS_UNUSED(tdbTbDelete(pTb, pKey, kLen, pTxn));	74,415,431✔
213	return tdbTbInsert(pTb, pKey, kLen, pVal, vLen, pTxn);	74,513,716✔
214	}
215
216	int tdbTbGet(TTB pTb, const void pKey, int kLen, void *ppVal, int vLen) {	2,147,483,647✔
217	return tdbBtreeGet(pTb->pBt, pKey, kLen, ppVal, vLen);	2,147,483,647✔
218	}
219
220	int tdbTbPGet(TTB pTb, const void pKey, int kLen, void *ppKey, int pkLen, void *ppVal, int vLen) {	×
221	return tdbBtreePGet(pTb->pBt, pKey, kLen, ppKey, pkLen, ppVal, vLen);	×
222	}
223
224	// tdbTbBtreeToStack, tdbTbPushFreePage, tdbTbPopFreePage are only for free page management,
225	// they are using the b-tree as a stack, never call them for other purpose
226	int tdbTbBtreeToStack(TTB *pTb) {	8,912,731✔
227	return tdbBtreeToStack(pTb->pBt);	8,912,731✔
228	}
229
230	int tdbTbPushFreePage(TTB pTb, SPage pPage, TXN *pTxn) {	8,989,268✔
231	return tdbBtreePushFreePage(pTb->pBt, pPage, pTxn);	8,989,268✔
232	}
233
234	int tdbTbPopFreePage(TTB pTb, SPgno pgno, TXN *pTxn) {	195,584,819✔
235	return tdbBtreePopFreePage(pTb->pBt, pgno, pTxn);	195,584,819✔
236	}
237
238	int tdbTbcOpen(TTB pTb, TBC ppTbc, TXN pTxn) {	254,757,499✔
239	int ret;
240	TBC *pTbc = NULL;	254,757,499✔
241
242	*ppTbc = NULL;	254,757,499✔
243	pTbc = (TBC )tdbOsMalloc(sizeof(pTbc));	254,775,952✔
244	if (pTbc == NULL) {	254,643,758✔
245	return terrno;	×
246	}
247
248	if ((ret = tdbBtcOpen(&pTbc->btc, pTb->pBt, pTxn)) != 0) {	254,643,758✔
NEW 249	tdbOsFree(pTbc);	×
250	return ret;	×
251	}
252
253	*ppTbc = pTbc;	254,682,676✔
254	return 0;	254,736,012✔
255	}
256
257	int32_t tdbTbTraversal(TTB pTb, void data,	17,502,857✔
258	int32_t (func)(const void pKey, int keyLen, const void pVal, int valLen, void data)) {
259	TBC *pCur;	17,497,172✔
260	int ret = tdbTbcOpen(pTb, &pCur, NULL);	17,505,383✔
261	if (ret < 0) {	17,500,759✔
262	return ret;	×
263	}
264
265	ret = tdbTbcMoveToFirst(pCur);	17,500,759✔
266	if (ret < 0) {	17,492,136✔
UNCOV 267	tdbTbcClose(pCur);	×
268	return ret;	×
269	}
270
271	void *pKey = NULL;	17,492,136✔
272	int kLen = 0;	17,491,595✔
273	void *pValue = NULL;	17,495,290✔
274	int vLen = 0;	17,500,680✔
275
276	while (1) {
277	ret = tdbTbcNext(pCur, &pKey, &kLen, &pValue, &vLen);	17,577,950✔
278	if (ret < 0) {	17,557,513✔
279	ret = 0;	17,463,631✔
280	break;	17,463,631✔
281	}
282
283	ret = func(pKey, kLen, pValue, vLen, data);	94,016✔
284	if (ret < 0) break;	100,985✔
285	}
286	tdbFree(pKey);	17,486,976✔
287	tdbFree(pValue);	17,497,041✔
288	tdbTbcClose(pCur);	17,495,875✔
289
290	return 0;	17,497,588✔
291	}
292
293	int tdbTbcMoveTo(TBC pTbc, const void pKey, int kLen, int *c) { return tdbBtcMoveTo(&pTbc->btc, pKey, kLen, c); }	216,347,821✔
294
295	int tdbTbcMoveToFirst(TBC *pTbc) { return tdbBtcMoveToFirst(&pTbc->btc); }	38,390,660✔
296
297	int tdbTbcMoveToLast(TBC *pTbc) { return tdbBtcMoveToLast(&pTbc->btc); }	×
298
299	int tdbTbcMoveToNext(TBC *pTbc) { return tdbBtcMoveToNext(&pTbc->btc); }	62,667,344✔
300
301	int tdbTbcMoveToPrev(TBC *pTbc) { return tdbBtcMoveToPrev(&pTbc->btc); }	18,813,542✔
302
303	int tdbTbcGet(TBC pTbc, const void ppKey, int pkLen, const void *ppVal, int pvLen) {	59,945,579✔
304	return tdbBtcGet(&pTbc->btc, ppKey, pkLen, ppVal, pvLen);	59,945,579✔
305	}
306
307	int tdbTbcDelete(TBC *pTbc) { return tdbBtcDelete(&pTbc->btc); }	×
308
309	int tdbTbcNext(TBC pTbc, void ppKey, int kLen, void *ppVal, int vLen) {	1,382,393,799✔
310	return tdbBtreeNext(&pTbc->btc, ppKey, kLen, ppVal, vLen);	1,382,393,799✔
311	}
312
313	int tdbTbcPrev(TBC pTbc, void ppKey, int kLen, void *ppVal, int vLen) {	12,634,331✔
314	return tdbBtreePrev(&pTbc->btc, ppKey, kLen, ppVal, vLen);	12,634,331✔
315	}
316
317	int tdbTbcUpsert(TBC pTbc, const void pKey, int nKey, const void *pData, int nData, int insert) {	×
318	return tdbBtcUpsert(&pTbc->btc, pKey, nKey, pData, nData, insert);	×
319	}
320
321	void tdbTbcClose(TBC *pTbc) {	256,540,944✔
322	if (pTbc) {	256,540,944✔
323	tdbBtcClose(&pTbc->btc);	254,771,925✔
324	tdbOsFree(pTbc);	254,777,651✔
325	}
326	}	256,502,984✔
327
328	int tdbTbcIsValid(TBC *pTbc) { return tdbBtcIsValid(&pTbc->btc); }	×

taosdata / TDengine / #5011

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