#3599

Committed 08 Feb 2025 11:23AM UTC coverage: 1.77% (-61.6%) from 63.396%

Build # #3599

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge pull request #29712 from taosdata/fix/TD-33652-3.0

fix: reduce write rows from 30w to 3w

Run Details

3776 of 278949 branches covered (1.35%)

Branch coverage included in aggregate %.

6012 of 274147 relevant lines covered (2.19%)

1642.73 hits per line

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

0.0

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

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

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

void initTsdbReaderAPI(TsdReader* pReader) {
  pReader->tsdReaderOpen = (int32_t(*)(void*, SQueryTableDataCond*, void*, int32_t, SSDataBlock*, void**, const char*,
                                       SHashObj**))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->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;
}

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->metaGetCachedTbGroup = metaGetCachedTbGroup;
  pMeta->metaPutTbGroupToCache = metaPutTbGroupToCache;

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

void initTqAPI(SStoreTqReader* pTq) {
  pTq->tqReaderOpen = tqReaderOpen;
  pTq->tqReaderSetColIdList = tqReaderSetColIdList;

  pTq->tqReaderClose = tqReaderClose;
  pTq->tqReaderSeek = tqReaderSeek;
  pTq->tqRetrieveBlock = tqRetrieveDataBlock;

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

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

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

  pTq->tqReaderRemoveTables = tqReaderRemoveTbUidList;

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

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

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

  //  pTq->tqReaderNextBlockFilterOut = tqNextDataBlockFilterOut;
  pTq->tqGetResultBlockTime = tqGetResultBlockTime;

  pTq->tqGetStreamExecProgress = tqGetStreamExecInfo;
}

void initStateStoreAPI(SStateStore* pStore) {
  pStore->streamFileStateInit = streamFileStateInit;
  pStore->updateInfoDestoryColseWinSBF = updateInfoDestoryColseWinSBF;

  pStore->streamStatePutParName = streamStatePutParName;
  pStore->streamStateGetParName = streamStateGetParName;
  pStore->streamStateDeleteParName = streamStateDeleteParName;

  pStore->streamStateAddIfNotExist = streamStateAddIfNotExist;
  pStore->streamStateReleaseBuf = streamStateReleaseBuf;
  pStore->streamStateClearBuff = streamStateClearBuff;
  pStore->streamStateFreeVal = streamStateFreeVal;

  pStore->streamStatePut = streamStatePut;
  pStore->streamStateGet = streamStateGet;
  pStore->streamStateCheck = streamStateCheck;
  pStore->streamStateGetByPos = streamStateGetByPos;
  pStore->streamStateDel = streamStateDel;
  pStore->streamStateClear = streamStateClear;
  pStore->streamStateSaveInfo = streamStateSaveInfo;
  pStore->streamStateGetInfo = streamStateGetInfo;
  pStore->streamStateSetNumber = streamStateSetNumber;
  pStore->streamStateGetPrev = streamStateGetPrev;

  pStore->streamStateFillPut = streamStateFillPut;
  pStore->streamStateFillGet = streamStateFillGet;
  pStore->streamStateFillAddIfNotExist = streamStateFillAddIfNotExist;
  pStore->streamStateFillDel = streamStateFillDel;
  pStore->streamStateFillGetNext = streamStateFillGetNext;
  pStore->streamStateFillGetPrev = streamStateFillGetPrev;

  pStore->streamStateCurNext = streamStateCurNext;
  pStore->streamStateCurPrev = streamStateCurPrev;

  pStore->streamStateGetAndCheckCur = streamStateGetAndCheckCur;
  pStore->streamStateSeekKeyNext = streamStateSeekKeyNext;
  pStore->streamStateFillSeekKeyNext = streamStateFillSeekKeyNext;
  pStore->streamStateFillSeekKeyPrev = streamStateFillSeekKeyPrev;
  pStore->streamStateFreeCur = streamStateFreeCur;

  pStore->streamStateFillGetGroupKVByCur = streamStateFillGetGroupKVByCur;
  pStore->streamStateGetKVByCur = streamStateGetKVByCur;

  pStore->streamStateClearExpiredState = streamStateClearExpiredState;

  pStore->streamStateSessionAddIfNotExist = streamStateSessionAddIfNotExist;
  pStore->streamStateSessionPut = streamStateSessionPut;
  pStore->streamStateSessionGet = streamStateSessionGet;
  pStore->streamStateSessionDel = streamStateSessionDel;
  pStore->streamStateSessionReset = streamStateSessionReset;
  pStore->streamStateSessionClear = streamStateSessionClear;
  pStore->streamStateSessionGetKVByCur = streamStateSessionGetKVByCur;
  pStore->streamStateStateAddIfNotExist = streamStateStateAddIfNotExist;
  pStore->streamStateSessionGetKeyByRange = streamStateSessionGetKeyByRange;
  pStore->streamStateCountGetKeyByRange = streamStateCountGetKeyByRange;
  pStore->streamStateSessionAllocWinBuffByNextPosition = streamStateSessionAllocWinBuffByNextPosition;

  pStore->streamStateCountWinAddIfNotExist = streamStateCountWinAddIfNotExist;
  pStore->streamStateCountWinAdd = streamStateCountWinAdd;

  pStore->updateInfoInit = updateInfoInit;
  pStore->updateInfoFillBlockData = updateInfoFillBlockData;
  pStore->updateInfoIsUpdated = updateInfoIsUpdated;
  pStore->updateInfoIsTableInserted = updateInfoIsTableInserted;
  pStore->updateInfoDestroy = updateInfoDestroy;
  pStore->windowSBfDelete = windowSBfDelete;
  pStore->windowSBfAdd = windowSBfAdd;
  pStore->isIncrementalTimeStamp = isIncrementalTimeStamp;

  pStore->updateInfoInitP = updateInfoInitP;
  pStore->updateInfoAddCloseWindowSBF = updateInfoAddCloseWindowSBF;
  pStore->updateInfoDestoryColseWinSBF = updateInfoDestoryColseWinSBF;
  pStore->updateInfoSerialize = updateInfoSerialize;
  pStore->updateInfoDeserialize = updateInfoDeserialize;

  pStore->streamStateSessionSeekKeyNext = streamStateSessionSeekKeyNext;
  pStore->streamStateCountSeekKeyPrev = streamStateCountSeekKeyPrev;
  pStore->streamStateSessionSeekKeyCurrentPrev = streamStateSessionSeekKeyCurrentPrev;
  pStore->streamStateSessionSeekKeyCurrentNext = streamStateSessionSeekKeyCurrentNext;

  pStore->streamStateGroupPut = streamStateGroupPut;
  pStore->streamStateGroupGetCur = streamStateGroupGetCur;
  pStore->streamStateGroupCurNext = streamStateGroupCurNext;
  pStore->streamStateGroupGetKVByCur = streamStateGroupGetKVByCur;

  pStore->streamFileStateDestroy = streamFileStateDestroy;
  pStore->streamFileStateClear = streamFileStateClear;
  pStore->needClearDiskBuff = needClearDiskBuff;

  pStore->streamStateOpen = streamStateOpen;
  pStore->streamStateClose = streamStateClose;
  pStore->streamStateBegin = streamStateBegin;
  pStore->streamStateCommit = streamStateCommit;
  pStore->streamStateDestroy = streamStateDestroy;
  pStore->streamStateReloadInfo = streamStateReloadInfo;
  pStore->streamStateCopyBackend = streamStateCopyBackend;
}

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

  pMetaReader->getTableEntryByUid = metaReaderGetTableEntryByUid;

  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 initFunctionStateStore(SFunctionStateStore* pStore) {
  pStore->streamStateFuncPut = streamStateFuncPut;
  pStore->streamStateFuncGet = streamStateFuncGet;
}

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 "tstreamUpdate.h"
19	#include "vnodeInt.h"
20
21	static void initTsdbReaderAPI(TsdReader* pReader);
22	static void initMetadataAPI(SStoreMeta* pMeta);
23	static void initTqAPI(SStoreTqReader* pTq);
24	static void initStateStoreAPI(SStateStore* pStore);
25	static void initMetaReaderAPI(SStoreMetaReader* pMetaReader);
26	static void initMetaFilterAPI(SMetaDataFilterAPI* pFilter);
27	static void initFunctionStateStore(SFunctionStateStore* pStore);
28	static void initCacheFn(SStoreCacheReader* pCache);
29	static void initSnapshotFn(SStoreSnapshotFn* pSnapshot);
30
31	void initStorageAPI(SStorageAPI* pAPI) {	×
32	initTsdbReaderAPI(&pAPI->tsdReader);	×
33	initMetadataAPI(&pAPI->metaFn);	×
34	initStateStoreAPI(&pAPI->stateStore);	×
35	initMetaReaderAPI(&pAPI->metaReaderFn);	×
36	initMetaFilterAPI(&pAPI->metaFilter);	×
37	initTqAPI(&pAPI->tqReaderFn);	×
38	initFunctionStateStore(&pAPI->functionStore);	×
39	initCacheFn(&pAPI->cacheFn);	×
40	initSnapshotFn(&pAPI->snapshotFn);	×
41	}	×
42
43	void initTsdbReaderAPI(TsdReader* pReader) {	×
44	pReader->tsdReaderOpen = (int32_t()(void, SQueryTableDataCond, void, int32_t, SSDataBlock, void, const char,	×
45	SHashObj**))tsdbReaderOpen2;
46	pReader->tsdReaderClose = tsdbReaderClose2;	×
47
48	pReader->tsdNextDataBlock = tsdbNextDataBlock2;	×
49
50	pReader->tsdReaderRetrieveDataBlock = tsdbRetrieveDataBlock2;	×
51	pReader->tsdReaderReleaseDataBlock = tsdbReleaseDataBlock2;	×
52
53	pReader->tsdReaderRetrieveBlockSMAInfo = tsdbRetrieveDatablockSMA2;	×
54
55	pReader->tsdReaderNotifyClosing = tsdbReaderSetCloseFlag;	×
56	pReader->tsdReaderResetStatus = tsdbReaderReset2;	×
57
58	pReader->tsdReaderGetDataBlockDistInfo = tsdbGetFileBlocksDistInfo2;	×
59	pReader->tsdReaderGetNumOfInMemRows = tsdbGetNumOfRowsInMemTable2; // todo this function should be moved away	×
60
61	pReader->tsdSetQueryTableList = tsdbSetTableList2;	×
62	pReader->tsdSetReaderTaskId = tsdbReaderSetId;	×
63
64	pReader->tsdSetFilesetDelimited = (void ()(void))tsdbSetFilesetDelimited;	×
65	pReader->tsdSetSetNotifyCb = (void ()(void, TsdReaderNotifyCbFn, void*))tsdbReaderSetNotifyCb;	×
66
67	// file set iterate
68	pReader->fileSetReaderOpen = tsdbFileSetReaderOpen;	×
69	pReader->fileSetReadNext = tsdbFileSetReaderNext;	×
70	pReader->fileSetGetEntryField = tsdbFileSetGetEntryField;	×
71	pReader->fileSetReaderClose = tsdbFileSetReaderClose;	×
72	}	×
73
74	void initMetadataAPI(SStoreMeta* pMeta) {	×
75	pMeta->isTableExisted = metaIsTableExist;	×
76
77	pMeta->openTableMetaCursor = metaOpenTbCursor;	×
78	pMeta->closeTableMetaCursor = metaCloseTbCursor;	×
79	pMeta->pauseTableMetaCursor = metaPauseTbCursor;	×
80	pMeta->resumeTableMetaCursor = metaResumeTbCursor;	×
81	pMeta->cursorNext = metaTbCursorNext;	×
82	pMeta->cursorPrev = metaTbCursorPrev;	×
83
84	pMeta->getBasicInfo = vnodeGetInfo;	×
85	pMeta->getNumOfChildTables = metaGetStbStats;	×
86
87	pMeta->getChildTableList = vnodeGetCtbIdList;	×
88
89	pMeta->storeGetIndexInfo = vnodeGetIdx;	×
90	pMeta->getInvertIndex = vnodeGetIvtIdx;	×
91
92	pMeta->extractTagVal = (const void* ()(const void, int16_t, STagVal*))metaGetTableTagVal;	×
93	pMeta->getTableTags = metaGetTableTags;	×
94	pMeta->getTableTagsByUid = metaGetTableTagsByUids;	×
95
96	pMeta->getTableUidByName = metaGetTableUidByName;	×
97	pMeta->getTableTypeSuidByName = metaGetTableTypeSuidByName;	×
98	pMeta->getTableNameByUid = metaGetTableNameByUid;	×
99
100	pMeta->getTableSchema = vnodeGetTableSchema;	×
101	pMeta->storeGetTableList = vnodeGetTableList;	×
102
103	pMeta->getCachedTableList = metaGetCachedTableUidList;	×
104	pMeta->putCachedTableList = metaUidFilterCachePut;	×
105
106	pMeta->metaGetCachedTbGroup = metaGetCachedTbGroup;	×
107	pMeta->metaPutTbGroupToCache = metaPutTbGroupToCache;	×
108
109	pMeta->openCtbCursor = metaOpenCtbCursor;	×
110	pMeta->resumeCtbCursor = metaResumeCtbCursor;	×
111	pMeta->pauseCtbCursor = metaPauseCtbCursor;	×
112	pMeta->closeCtbCursor = metaCloseCtbCursor;	×
113	pMeta->ctbCursorNext = metaCtbCursorNext;	×
114	pMeta->getDBSize = vnodeGetDBSize;	×
115	}	×
116
117	void initTqAPI(SStoreTqReader* pTq) {	×
118	pTq->tqReaderOpen = tqReaderOpen;	×
119	pTq->tqReaderSetColIdList = tqReaderSetColIdList;	×
120
121	pTq->tqReaderClose = tqReaderClose;	×
122	pTq->tqReaderSeek = tqReaderSeek;	×
123	pTq->tqRetrieveBlock = tqRetrieveDataBlock;	×
124
125	pTq->tqGetTablePrimaryKey = tqGetTablePrimaryKey;	×
126	pTq->tqSetTablePrimaryKey = tqSetTablePrimaryKey;	×
127	pTq->tqReaderNextBlockInWal = tqNextBlockInWal;	×
128
129	pTq->tqNextBlockImpl = tqNextBlockImpl; // todo remove it	×
130
131	pTq->tqReaderAddTables = tqReaderAddTbUidList;	×
132	pTq->tqReaderSetQueryTableList = tqReaderSetTbUidList;	×
133
134	pTq->tqReaderRemoveTables = tqReaderRemoveTbUidList;	×
135
136	pTq->tqReaderIsQueriedTable = tqReaderIsQueriedTable;	×
137	pTq->tqReaderCurrentBlockConsumed = tqCurrentBlockConsumed;	×
138
139	pTq->tqReaderGetWalReader = tqGetWalReader; // todo remove it	×
140	// pTq->tqReaderRetrieveTaosXBlock = tqRetrieveTaosxBlock; // todo remove it
141
142	pTq->tqReaderSetSubmitMsg = tqReaderSetSubmitMsg; // todo remove it	×
143	pTq->tqGetResultBlock = tqGetResultBlock;	×
144
145	// pTq->tqReaderNextBlockFilterOut = tqNextDataBlockFilterOut;
146	pTq->tqGetResultBlockTime = tqGetResultBlockTime;	×
147
148	pTq->tqGetStreamExecProgress = tqGetStreamExecInfo;	×
149	}	×
150
151	void initStateStoreAPI(SStateStore* pStore) {	×
152	pStore->streamFileStateInit = streamFileStateInit;	×
153	pStore->updateInfoDestoryColseWinSBF = updateInfoDestoryColseWinSBF;	×
154
155	pStore->streamStatePutParName = streamStatePutParName;	×
156	pStore->streamStateGetParName = streamStateGetParName;	×
157	pStore->streamStateDeleteParName = streamStateDeleteParName;	×
158
159	pStore->streamStateAddIfNotExist = streamStateAddIfNotExist;	×
160	pStore->streamStateReleaseBuf = streamStateReleaseBuf;	×
161	pStore->streamStateClearBuff = streamStateClearBuff;	×
162	pStore->streamStateFreeVal = streamStateFreeVal;	×
163
164	pStore->streamStatePut = streamStatePut;	×
165	pStore->streamStateGet = streamStateGet;	×
166	pStore->streamStateCheck = streamStateCheck;	×
167	pStore->streamStateGetByPos = streamStateGetByPos;	×
168	pStore->streamStateDel = streamStateDel;	×
169	pStore->streamStateClear = streamStateClear;	×
170	pStore->streamStateSaveInfo = streamStateSaveInfo;	×
171	pStore->streamStateGetInfo = streamStateGetInfo;	×
172	pStore->streamStateSetNumber = streamStateSetNumber;	×
173	pStore->streamStateGetPrev = streamStateGetPrev;	×
174
175	pStore->streamStateFillPut = streamStateFillPut;	×
176	pStore->streamStateFillGet = streamStateFillGet;	×
177	pStore->streamStateFillAddIfNotExist = streamStateFillAddIfNotExist;	×
178	pStore->streamStateFillDel = streamStateFillDel;	×
179	pStore->streamStateFillGetNext = streamStateFillGetNext;	×
180	pStore->streamStateFillGetPrev = streamStateFillGetPrev;	×
181
182	pStore->streamStateCurNext = streamStateCurNext;	×
183	pStore->streamStateCurPrev = streamStateCurPrev;	×
184
185	pStore->streamStateGetAndCheckCur = streamStateGetAndCheckCur;	×
186	pStore->streamStateSeekKeyNext = streamStateSeekKeyNext;	×
187	pStore->streamStateFillSeekKeyNext = streamStateFillSeekKeyNext;	×
188	pStore->streamStateFillSeekKeyPrev = streamStateFillSeekKeyPrev;	×
189	pStore->streamStateFreeCur = streamStateFreeCur;	×
190
191	pStore->streamStateFillGetGroupKVByCur = streamStateFillGetGroupKVByCur;	×
192	pStore->streamStateGetKVByCur = streamStateGetKVByCur;	×
193
194	pStore->streamStateClearExpiredState = streamStateClearExpiredState;	×
195
196	pStore->streamStateSessionAddIfNotExist = streamStateSessionAddIfNotExist;	×
197	pStore->streamStateSessionPut = streamStateSessionPut;	×
198	pStore->streamStateSessionGet = streamStateSessionGet;	×
199	pStore->streamStateSessionDel = streamStateSessionDel;	×
200	pStore->streamStateSessionReset = streamStateSessionReset;	×
201	pStore->streamStateSessionClear = streamStateSessionClear;	×
202	pStore->streamStateSessionGetKVByCur = streamStateSessionGetKVByCur;	×
203	pStore->streamStateStateAddIfNotExist = streamStateStateAddIfNotExist;	×
204	pStore->streamStateSessionGetKeyByRange = streamStateSessionGetKeyByRange;	×
205	pStore->streamStateCountGetKeyByRange = streamStateCountGetKeyByRange;	×
206	pStore->streamStateSessionAllocWinBuffByNextPosition = streamStateSessionAllocWinBuffByNextPosition;	×
207
208	pStore->streamStateCountWinAddIfNotExist = streamStateCountWinAddIfNotExist;	×
209	pStore->streamStateCountWinAdd = streamStateCountWinAdd;	×
210
211	pStore->updateInfoInit = updateInfoInit;	×
212	pStore->updateInfoFillBlockData = updateInfoFillBlockData;	×
213	pStore->updateInfoIsUpdated = updateInfoIsUpdated;	×
214	pStore->updateInfoIsTableInserted = updateInfoIsTableInserted;	×
215	pStore->updateInfoDestroy = updateInfoDestroy;	×
216	pStore->windowSBfDelete = windowSBfDelete;	×
217	pStore->windowSBfAdd = windowSBfAdd;	×
218	pStore->isIncrementalTimeStamp = isIncrementalTimeStamp;	×
219
220	pStore->updateInfoInitP = updateInfoInitP;	×
221	pStore->updateInfoAddCloseWindowSBF = updateInfoAddCloseWindowSBF;	×
222	pStore->updateInfoDestoryColseWinSBF = updateInfoDestoryColseWinSBF;	×
223	pStore->updateInfoSerialize = updateInfoSerialize;	×
224	pStore->updateInfoDeserialize = updateInfoDeserialize;	×
225
226	pStore->streamStateSessionSeekKeyNext = streamStateSessionSeekKeyNext;	×
227	pStore->streamStateCountSeekKeyPrev = streamStateCountSeekKeyPrev;	×
228	pStore->streamStateSessionSeekKeyCurrentPrev = streamStateSessionSeekKeyCurrentPrev;	×
229	pStore->streamStateSessionSeekKeyCurrentNext = streamStateSessionSeekKeyCurrentNext;	×
230
231	pStore->streamStateGroupPut = streamStateGroupPut;	×
232	pStore->streamStateGroupGetCur = streamStateGroupGetCur;	×
233	pStore->streamStateGroupCurNext = streamStateGroupCurNext;	×
234	pStore->streamStateGroupGetKVByCur = streamStateGroupGetKVByCur;	×
235
236	pStore->streamFileStateDestroy = streamFileStateDestroy;	×
237	pStore->streamFileStateClear = streamFileStateClear;	×
238	pStore->needClearDiskBuff = needClearDiskBuff;	×
239
240	pStore->streamStateOpen = streamStateOpen;	×
241	pStore->streamStateClose = streamStateClose;	×
242	pStore->streamStateBegin = streamStateBegin;	×
243	pStore->streamStateCommit = streamStateCommit;	×
244	pStore->streamStateDestroy = streamStateDestroy;	×
245	pStore->streamStateReloadInfo = streamStateReloadInfo;	×
246	pStore->streamStateCopyBackend = streamStateCopyBackend;	×
247	}	×
248
249	void initMetaReaderAPI(SStoreMetaReader* pMetaReader) {	×
250	pMetaReader->initReader = _metaReaderInit;	×
251	pMetaReader->clearReader = metaReaderClear;	×
252
253	pMetaReader->getTableEntryByUid = metaReaderGetTableEntryByUid;	×
254
255	pMetaReader->getEntryGetUidCache = metaReaderGetTableEntryByUidCache;	×
256	pMetaReader->getTableEntryByName = metaGetTableEntryByName;	×
257
258	pMetaReader->readerReleaseLock = metaReaderReleaseLock;	×
259	}	×
260
261	void initMetaFilterAPI(SMetaDataFilterAPI* pFilter) {	×
262	pFilter->metaFilterCreateTime = metaFilterCreateTime;	×
263	pFilter->metaFilterTableIds = metaFilterTableIds;	×
264	pFilter->metaFilterTableName = metaFilterTableName;	×
265	pFilter->metaFilterTtl = metaFilterTtl;	×
266	}	×
267
268	void initFunctionStateStore(SFunctionStateStore* pStore) {	×
269	pStore->streamStateFuncPut = streamStateFuncPut;	×
270	pStore->streamStateFuncGet = streamStateFuncGet;	×
271	}	×
272
273	void initCacheFn(SStoreCacheReader* pCache) {	×
274	pCache->openReader = tsdbCacherowsReaderOpen;	×
275	pCache->closeReader = tsdbCacherowsReaderClose;	×
276	pCache->retrieveRows = tsdbRetrieveCacheRows;	×
277	pCache->reuseReader = tsdbReuseCacherowsReader;	×
278	}	×
279
280	void initSnapshotFn(SStoreSnapshotFn* pSnapshot) {	×
281	pSnapshot->taosXGetTablePrimaryKey = taosXGetTablePrimaryKey;	×
282	pSnapshot->taosXSetTablePrimaryKey = taosXSetTablePrimaryKey;	×
283	pSnapshot->setForSnapShot = setForSnapShot;	×
284	pSnapshot->destroySnapshot = destroySnapContext;	×
285	pSnapshot->getMetaTableInfoFromSnapshot = getMetaTableInfoFromSnapshot;	×
286	pSnapshot->getTableInfoFromSnapshot = getTableInfoFromSnapshot;	×
287	}	×

taosdata / TDengine / #3599

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