#3653

Committed 14 Mar 2025 08:10AM UTC coverage: 22.565% (-41.0%) from 63.596%

Build # #3653

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

feat(keep): support keep on super table level. (#30097)

* Feat: support use keep while create super table.

* Test(keep): add test for create super table with keep option.

* Feat(keep): Add tmsg for create keep.

* Feat(keep): support alter table option keep.

* Fix(keep): Add baisc test for alter table option.

* Fix(keep): memory leek.

* Feat(keep): add keep to metaEntry&metaCache and fix earliestTs with stn keep.

* Test(keep): add some cases for select with stb keep.

* Fix: fix ci core while alter stb.

* Feat(keep): delete expired data in super table level.

* Feat: remove get stb keep while query.

* Fix : build error.

* Revert "Fix : build error."

This reverts commit 0ed66e4e8.

* Revert "Feat(keep): delete expired data in super table level."

This reverts commit 36330f6b4.

* Fix : build errors.

* Feat : support restart taosd.

* Fix : alter table comment problems.

* Test : add tests for super table keep.

* Fix: change sdb stb reserve size.

* Test: add more tests.

* Feat: Disable normal tables and sub tables from setting the keep parameter

* Fix: add more checks to avoid unknown address.

* Docs: Add docs for stable keep.

* Fix: some review changes.

* Fix: review errors.

Run Details

49248 of 302527 branches covered (16.28%)

Branch coverage included in aggregate %.

53 of 99 new or added lines in 12 files covered. (53.54%)

155872 existing lines in 443 files now uncovered.

87359 of 302857 relevant lines covered (28.84%)

570004.22 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) {
#ifdef USE_TQ
  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;
#endif
}

void initStateStoreAPI(SStateStore* pStore) {
#ifdef USE_STREAM
  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->streamStateDelByGroupId = streamStateDelByGroupId;
  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->streamStateSessionSeekKeyPrev = streamStateSessionSeekKeyPrev;
  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;
#endif
}

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) {
#ifdef USE_STREAM
  pStore->streamStateFuncPut = streamStateFuncPut;
  pStore->streamStateFuncGet = streamStateFuncGet;
#endif
}

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

taosdata / TDengine / #3653

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