#4986

Committed 15 Mar 2026 08:32AM UTC coverage: 37.305% (-31.3%) from 68.601%

Build # #4986

Build Type

push

travis-ci

Committed by

tomchon

Commit Message

test: keep docs and unit test

Run Details

125478 of 336361 relevant lines covered (37.3%)

1134847.06 hits per line

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

0.0

/source/dnode/vnode/src/vnd/vnodeApi.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 "meta.h"
#include "storageapi.h"
#include "vnodeInt.h"

static void initTsdbReaderAPI(TsdReader* pReader);
static void initMetadataAPI(SStoreMeta* pMeta);
static void initTqAPI(SStoreTqReader* pTq);
static void initMetaReaderAPI(SStoreMetaReader* pMetaReader);
static void initMetaFilterAPI(SMetaDataFilterAPI* pFilter);
static void initCacheFn(SStoreCacheReader* pCache);
static void initSnapshotFn(SStoreSnapshotFn* pSnapshot);

void initStorageAPI(SStorageAPI* pAPI) {
  initTsdbReaderAPI(&pAPI->tsdReader);
  initMetadataAPI(&pAPI->metaFn);
  initMetaReaderAPI(&pAPI->metaReaderFn);
  initMetaFilterAPI(&pAPI->metaFilter);
  initTqAPI(&pAPI->tqReaderFn);
  initCacheFn(&pAPI->cacheFn);
  initSnapshotFn(&pAPI->snapshotFn);
}

void initTsdbReaderAPI(TsdReader* pReader) {
  pReader->tsdReaderOpen = tsdbReaderOpen2;
  pReader->tsdReaderClose = tsdbReaderClose2;

  pReader->tsdNextDataBlock = tsdbNextDataBlock2;

  pReader->tsdReaderRetrieveDataBlock = tsdbRetrieveDataBlock2;
  pReader->tsdReaderReleaseDataBlock = tsdbReleaseDataBlock2;

  pReader->tsdReaderRetrieveBlockSMAInfo = tsdbRetrieveDatablockSMA2;

  pReader->tsdReaderNotifyClosing = tsdbReaderSetCloseFlag;
  pReader->tsdReaderResetStatus = tsdbReaderReset2;

  pReader->tsdReaderGetDataBlockDistInfo = tsdbGetFileBlocksDistInfo2;
  pReader->tsdReaderGetDatablock = tsdbGetDataBlock;
  pReader->tsdReaderSetDatablock = tsdbSetDataBlock;
  pReader->tsdReaderGetNumOfInMemRows = tsdbGetNumOfRowsInMemTable2;  // todo this function should be moved away

  pReader->tsdSetQueryTableList = tsdbSetTableList2;
  pReader->tsdSetReaderTaskId = tsdbReaderSetId;

  pReader->tsdSetFilesetDelimited = (void (*)(void*))tsdbSetFilesetDelimited;
  pReader->tsdSetSetNotifyCb = (void (*)(void*, TsdReaderNotifyCbFn, void*))tsdbReaderSetNotifyCb;

  // file set iterate
  pReader->fileSetReaderOpen = tsdbFileSetReaderOpen;
  pReader->fileSetReadNext = tsdbFileSetReaderNext;
  pReader->fileSetGetEntryField = tsdbFileSetGetEntryField;
  pReader->fileSetReaderClose = tsdbFileSetReaderClose;

  // retrieve first/last ts for each table
  pReader->tsdCreateFirstLastTsIter = tsdbCreateFirstLastTsIter;
  pReader->tsdNextFirstLastTsBlock = tsdbNextFirstLastTsBlock;
  pReader->tsdDestroyFirstLastTsIter = tsdbDestroyFirstLastTsIter;
  pReader->tsdReaderStepDone = (int32_t (*)(void*, int64_t))tsdbReaderStepDone;
}

void initMetadataAPI(SStoreMeta* pMeta) {
  pMeta->isTableExisted = metaIsTableExist;

  pMeta->openTableMetaCursor = metaOpenTbCursor;
  pMeta->closeTableMetaCursor = metaCloseTbCursor;
  pMeta->pauseTableMetaCursor = metaPauseTbCursor;
  pMeta->resumeTableMetaCursor = metaResumeTbCursor;
  pMeta->cursorNext = metaTbCursorNext;
  pMeta->cursorPrev = metaTbCursorPrev;

  pMeta->getBasicInfo = vnodeGetInfo;
  pMeta->getNumOfChildTables = metaGetStbStats;

  pMeta->getChildTableList = vnodeGetCtbIdList;

  pMeta->storeGetIndexInfo = vnodeGetIdx;
  pMeta->getInvertIndex = vnodeGetIvtIdx;

  pMeta->extractTagVal = (const void* (*)(const void*, int16_t, STagVal*))metaGetTableTagVal;
  pMeta->getTableTags = metaGetTableTags;
  pMeta->getTableTagsByUid = metaGetTableTagsByUids;

  pMeta->getTableUidByName = metaGetTableUidByName;
  pMeta->getTableTypeSuidByName = metaGetTableTypeSuidByName;
  pMeta->getTableNameByUid = metaGetTableNameByUid;

  pMeta->getTableSchema = vnodeGetTableSchema;
  pMeta->storeGetTableList = vnodeGetTableList;

  pMeta->getCachedTableList = metaGetCachedTableUidList;
  pMeta->putCachedTableList = metaUidFilterCachePut;
  pMeta->getStableCachedTableList = metaStableTagFilterCacheGet;
  pMeta->putStableCachedTableList = metaStableTagFilterCachePut;

  pMeta->metaGetCachedTbGroup = metaGetCachedTbGroup;
  pMeta->metaPutTbGroupToCache = metaPutTbGroupToCache;

  pMeta->openCtbCursor = metaOpenCtbCursor;
  pMeta->resumeCtbCursor = metaResumeCtbCursor;
  pMeta->pauseCtbCursor = metaPauseCtbCursor;
  pMeta->closeCtbCursor = metaCloseCtbCursor;
  pMeta->ctbCursorNext = metaCtbCursorNext;
  pMeta->getDBSize = vnodeGetDBSize;

  pMeta->metaGetCachedRefDbs = metaGetCachedRefDbs;
  pMeta->metaPutRefDbsToCache = metaPutRefDbsToCache;
}

void initTqAPI(SStoreTqReader* pTq) {
#ifdef USE_TQ
  pTq->tqReaderOpen = tqReaderOpen;

  pTq->tqReaderClose = tqReaderClose;
  pTq->tqReaderSeek = tqReaderSeek;

  pTq->tqGetTablePrimaryKey = tqGetTablePrimaryKey;
  pTq->tqSetTablePrimaryKey = tqSetTablePrimaryKey;
  pTq->tqReaderNextBlockInWal = tqNextBlockInWal;
  pTq->tqUpdateTableTagCache = tqUpdateTableTagCache;

  pTq->tqReaderAddTables = tqReaderAddTbUidList;
  pTq->tqReaderSetQueryTableList = tqReaderSetTbUidList;

  pTq->tqReaderRemoveTables = tqReaderRemoveTbUidList;

  pTq->tqReaderIsQueriedTable = tqReaderIsQueriedTable;
  pTq->tqReaderCurrentBlockConsumed = tqCurrentBlockConsumed;

  pTq->tqReaderGetWalReader = tqGetWalReader;  // todo remove it

  pTq->tqReaderSetSubmitMsg = tqReaderSetSubmitMsg;  // todo remove it

  pTq->tqGetResultBlockTime = tqGetResultBlockTime;
#endif
}

void initMetaReaderAPI(SStoreMetaReader* pMetaReader) {
  pMetaReader->initReader = _metaReaderInit;
  pMetaReader->clearReader = metaReaderClear;

  pMetaReader->getTableEntryByUid = metaReaderGetTableEntryByUid;
  pMetaReader->getTableEntryByVersionUid = metaReaderGetTableEntryByVersionUid;

  pMetaReader->getEntryGetUidCache = metaReaderGetTableEntryByUidCache;
  pMetaReader->getTableEntryByName = metaGetTableEntryByName;

  pMetaReader->readerReleaseLock = metaReaderReleaseLock;
}

void initMetaFilterAPI(SMetaDataFilterAPI* pFilter) {
  pFilter->metaFilterCreateTime = metaFilterCreateTime;
  pFilter->metaFilterTableIds = metaFilterTableIds;
  pFilter->metaFilterTableName = metaFilterTableName;
  pFilter->metaFilterTtl = metaFilterTtl;
}

void initCacheFn(SStoreCacheReader* pCache) {
  pCache->openReader = tsdbCacherowsReaderOpen;
  pCache->closeReader = tsdbCacherowsReaderClose;
  pCache->retrieveRows = tsdbRetrieveCacheRows;
  pCache->reuseReader = tsdbReuseCacherowsReader;
}

void initSnapshotFn(SStoreSnapshotFn* pSnapshot) {
  pSnapshot->taosXGetTablePrimaryKey = taosXGetTablePrimaryKey;
  pSnapshot->taosXSetTablePrimaryKey = taosXSetTablePrimaryKey;
  pSnapshot->setForSnapShot = setForSnapShot;
  pSnapshot->destroySnapshot = destroySnapContext;
  pSnapshot->getMetaTableInfoFromSnapshot = getMetaTableInfoFromSnapshot;
  pSnapshot->getTableInfoFromSnapshot = getTableInfoFromSnapshot;
}

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 "meta.h"
17	#include "storageapi.h"
18	#include "vnodeInt.h"
19
20	static void initTsdbReaderAPI(TsdReader* pReader);
21	static void initMetadataAPI(SStoreMeta* pMeta);
22	static void initTqAPI(SStoreTqReader* pTq);
23	static void initMetaReaderAPI(SStoreMetaReader* pMetaReader);
24	static void initMetaFilterAPI(SMetaDataFilterAPI* pFilter);
25	static void initCacheFn(SStoreCacheReader* pCache);
26	static void initSnapshotFn(SStoreSnapshotFn* pSnapshot);
27
28	void initStorageAPI(SStorageAPI* pAPI) {	×
29	initTsdbReaderAPI(&pAPI->tsdReader);	×
30	initMetadataAPI(&pAPI->metaFn);	×
31	initMetaReaderAPI(&pAPI->metaReaderFn);	×
32	initMetaFilterAPI(&pAPI->metaFilter);	×
33	initTqAPI(&pAPI->tqReaderFn);	×
34	initCacheFn(&pAPI->cacheFn);	×
35	initSnapshotFn(&pAPI->snapshotFn);	×
36	}	×
37
38	void initTsdbReaderAPI(TsdReader* pReader) {	×
39	pReader->tsdReaderOpen = tsdbReaderOpen2;	×
40	pReader->tsdReaderClose = tsdbReaderClose2;	×
41
42	pReader->tsdNextDataBlock = tsdbNextDataBlock2;	×
43
44	pReader->tsdReaderRetrieveDataBlock = tsdbRetrieveDataBlock2;	×
45	pReader->tsdReaderReleaseDataBlock = tsdbReleaseDataBlock2;	×
46
47	pReader->tsdReaderRetrieveBlockSMAInfo = tsdbRetrieveDatablockSMA2;	×
48
49	pReader->tsdReaderNotifyClosing = tsdbReaderSetCloseFlag;	×
50	pReader->tsdReaderResetStatus = tsdbReaderReset2;	×
51
52	pReader->tsdReaderGetDataBlockDistInfo = tsdbGetFileBlocksDistInfo2;	×
53	pReader->tsdReaderGetDatablock = tsdbGetDataBlock;	×
54	pReader->tsdReaderSetDatablock = tsdbSetDataBlock;	×
55	pReader->tsdReaderGetNumOfInMemRows = tsdbGetNumOfRowsInMemTable2; // todo this function should be moved away	×
56
57	pReader->tsdSetQueryTableList = tsdbSetTableList2;	×
58	pReader->tsdSetReaderTaskId = tsdbReaderSetId;	×
59
60	pReader->tsdSetFilesetDelimited = (void ()(void))tsdbSetFilesetDelimited;	×
61	pReader->tsdSetSetNotifyCb = (void ()(void, TsdReaderNotifyCbFn, void*))tsdbReaderSetNotifyCb;	×
62
63	// file set iterate
64	pReader->fileSetReaderOpen = tsdbFileSetReaderOpen;	×
65	pReader->fileSetReadNext = tsdbFileSetReaderNext;	×
66	pReader->fileSetGetEntryField = tsdbFileSetGetEntryField;	×
67	pReader->fileSetReaderClose = tsdbFileSetReaderClose;	×
68
69	// retrieve first/last ts for each table
70	pReader->tsdCreateFirstLastTsIter = tsdbCreateFirstLastTsIter;	×
71	pReader->tsdNextFirstLastTsBlock = tsdbNextFirstLastTsBlock;	×
72	pReader->tsdDestroyFirstLastTsIter = tsdbDestroyFirstLastTsIter;	×
73	pReader->tsdReaderStepDone = (int32_t ()(void, int64_t))tsdbReaderStepDone;	×
74	}	×
75
76	void initMetadataAPI(SStoreMeta* pMeta) {	×
77	pMeta->isTableExisted = metaIsTableExist;	×
78
79	pMeta->openTableMetaCursor = metaOpenTbCursor;	×
80	pMeta->closeTableMetaCursor = metaCloseTbCursor;	×
81	pMeta->pauseTableMetaCursor = metaPauseTbCursor;	×
82	pMeta->resumeTableMetaCursor = metaResumeTbCursor;	×
83	pMeta->cursorNext = metaTbCursorNext;	×
84	pMeta->cursorPrev = metaTbCursorPrev;	×
85
86	pMeta->getBasicInfo = vnodeGetInfo;	×
87	pMeta->getNumOfChildTables = metaGetStbStats;	×
88
89	pMeta->getChildTableList = vnodeGetCtbIdList;	×
90
91	pMeta->storeGetIndexInfo = vnodeGetIdx;	×
92	pMeta->getInvertIndex = vnodeGetIvtIdx;	×
93
94	pMeta->extractTagVal = (const void* ()(const void, int16_t, STagVal*))metaGetTableTagVal;	×
95	pMeta->getTableTags = metaGetTableTags;	×
96	pMeta->getTableTagsByUid = metaGetTableTagsByUids;	×
97
98	pMeta->getTableUidByName = metaGetTableUidByName;	×
99	pMeta->getTableTypeSuidByName = metaGetTableTypeSuidByName;	×
100	pMeta->getTableNameByUid = metaGetTableNameByUid;	×
101
102	pMeta->getTableSchema = vnodeGetTableSchema;	×
103	pMeta->storeGetTableList = vnodeGetTableList;	×
104
105	pMeta->getCachedTableList = metaGetCachedTableUidList;	×
106	pMeta->putCachedTableList = metaUidFilterCachePut;	×
107	pMeta->getStableCachedTableList = metaStableTagFilterCacheGet;	×
108	pMeta->putStableCachedTableList = metaStableTagFilterCachePut;	×
109
110	pMeta->metaGetCachedTbGroup = metaGetCachedTbGroup;	×
111	pMeta->metaPutTbGroupToCache = metaPutTbGroupToCache;	×
112
113	pMeta->openCtbCursor = metaOpenCtbCursor;	×
114	pMeta->resumeCtbCursor = metaResumeCtbCursor;	×
115	pMeta->pauseCtbCursor = metaPauseCtbCursor;	×
116	pMeta->closeCtbCursor = metaCloseCtbCursor;	×
117	pMeta->ctbCursorNext = metaCtbCursorNext;	×
118	pMeta->getDBSize = vnodeGetDBSize;	×
119
120	pMeta->metaGetCachedRefDbs = metaGetCachedRefDbs;	×
121	pMeta->metaPutRefDbsToCache = metaPutRefDbsToCache;	×
122	}	×
123
124	void initTqAPI(SStoreTqReader* pTq) {	×
125	#ifdef USE_TQ
126	pTq->tqReaderOpen = tqReaderOpen;	×
127
128	pTq->tqReaderClose = tqReaderClose;	×
129	pTq->tqReaderSeek = tqReaderSeek;	×
130
131	pTq->tqGetTablePrimaryKey = tqGetTablePrimaryKey;	×
132	pTq->tqSetTablePrimaryKey = tqSetTablePrimaryKey;	×
133	pTq->tqReaderNextBlockInWal = tqNextBlockInWal;	×
134	pTq->tqUpdateTableTagCache = tqUpdateTableTagCache;	×
135
136	pTq->tqReaderAddTables = tqReaderAddTbUidList;	×
137	pTq->tqReaderSetQueryTableList = tqReaderSetTbUidList;	×
138
139	pTq->tqReaderRemoveTables = tqReaderRemoveTbUidList;	×
140
141	pTq->tqReaderIsQueriedTable = tqReaderIsQueriedTable;	×
142	pTq->tqReaderCurrentBlockConsumed = tqCurrentBlockConsumed;	×
143
144	pTq->tqReaderGetWalReader = tqGetWalReader; // todo remove it	×
145
146	pTq->tqReaderSetSubmitMsg = tqReaderSetSubmitMsg; // todo remove it	×
147
148	pTq->tqGetResultBlockTime = tqGetResultBlockTime;	×
149	#endif
150	}	×
151
152	void initMetaReaderAPI(SStoreMetaReader* pMetaReader) {	×
153	pMetaReader->initReader = _metaReaderInit;	×
154	pMetaReader->clearReader = metaReaderClear;	×
155
156	pMetaReader->getTableEntryByUid = metaReaderGetTableEntryByUid;	×
157	pMetaReader->getTableEntryByVersionUid = metaReaderGetTableEntryByVersionUid;	×
158
159	pMetaReader->getEntryGetUidCache = metaReaderGetTableEntryByUidCache;	×
160	pMetaReader->getTableEntryByName = metaGetTableEntryByName;	×
161
162	pMetaReader->readerReleaseLock = metaReaderReleaseLock;	×
163	}	×
164
165	void initMetaFilterAPI(SMetaDataFilterAPI* pFilter) {	×
166	pFilter->metaFilterCreateTime = metaFilterCreateTime;	×
167	pFilter->metaFilterTableIds = metaFilterTableIds;	×
168	pFilter->metaFilterTableName = metaFilterTableName;	×
169	pFilter->metaFilterTtl = metaFilterTtl;	×
170	}	×
171
172	void initCacheFn(SStoreCacheReader* pCache) {	×
173	pCache->openReader = tsdbCacherowsReaderOpen;	×
174	pCache->closeReader = tsdbCacherowsReaderClose;	×
175	pCache->retrieveRows = tsdbRetrieveCacheRows;	×
176	pCache->reuseReader = tsdbReuseCacherowsReader;	×
177	}	×
178
179	void initSnapshotFn(SStoreSnapshotFn* pSnapshot) {	×
180	pSnapshot->taosXGetTablePrimaryKey = taosXGetTablePrimaryKey;	×
181	pSnapshot->taosXSetTablePrimaryKey = taosXSetTablePrimaryKey;	×
182	pSnapshot->setForSnapShot = setForSnapShot;	×
183	pSnapshot->destroySnapshot = destroySnapContext;	×
184	pSnapshot->getMetaTableInfoFromSnapshot = getMetaTableInfoFromSnapshot;	×
185	pSnapshot->getTableInfoFromSnapshot = getTableInfoFromSnapshot;	×
186	}	×

taosdata / TDengine / #4986

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