tsdb.h 28.0 KB
Newer Older
L
Liu Jicong 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14
/*
 * 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/>.
 */
H
Hongze Cheng 已提交
15 16 17 18

#ifndef _TD_VNODE_TSDB_H_
#define _TD_VNODE_TSDB_H_

H
Hongze Cheng 已提交
19 20
#include "vnodeInt.h"

H
Hongze Cheng 已提交
21 22 23 24
#ifdef __cplusplus
extern "C" {
#endif

H
Hongze Cheng 已提交
25 26
// tsdbDebug ================
// clang-format off
H
Hongze Cheng 已提交
27 28 29 30 31 32
#define tsdbFatal(...) do { if (tsdbDebugFlag & DEBUG_FATAL) { taosPrintLog("TSD FATAL ", DEBUG_FATAL, 255, __VA_ARGS__); }}     while(0)
#define tsdbError(...) do { if (tsdbDebugFlag & DEBUG_ERROR) { taosPrintLog("TSD ERROR ", DEBUG_ERROR, 255, __VA_ARGS__); }}     while(0)
#define tsdbWarn(...)  do { if (tsdbDebugFlag & DEBUG_WARN)  { taosPrintLog("TSD WARN ", DEBUG_WARN, 255, __VA_ARGS__); }}       while(0)
#define tsdbInfo(...)  do { if (tsdbDebugFlag & DEBUG_INFO)  { taosPrintLog("TSD ", DEBUG_INFO, 255, __VA_ARGS__); }}            while(0)
#define tsdbDebug(...) do { if (tsdbDebugFlag & DEBUG_DEBUG) { taosPrintLog("TSD ", DEBUG_DEBUG, tsdbDebugFlag, __VA_ARGS__); }} while(0)
#define tsdbTrace(...) do { if (tsdbDebugFlag & DEBUG_TRACE) { taosPrintLog("TSD ", DEBUG_TRACE, tsdbDebugFlag, __VA_ARGS__); }} while(0)
H
Hongze Cheng 已提交
33
// clang-format on
H
Hongze Cheng 已提交
34

H
Hongze Cheng 已提交
35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
typedef struct TSDBROW          TSDBROW;
typedef struct TABLEID          TABLEID;
typedef struct TSDBKEY          TSDBKEY;
typedef struct SDelData         SDelData;
typedef struct SDelIdx          SDelIdx;
typedef struct STbData          STbData;
typedef struct SMemTable        SMemTable;
typedef struct STbDataIter      STbDataIter;
typedef struct SMapData         SMapData;
typedef struct SBlockIdx        SBlockIdx;
typedef struct SDataBlk         SDataBlk;
typedef struct SSttBlk          SSttBlk;
typedef struct SDiskDataHdr     SDiskDataHdr;
typedef struct SBlockData       SBlockData;
typedef struct SDelFile         SDelFile;
typedef struct SHeadFile        SHeadFile;
typedef struct SDataFile        SDataFile;
typedef struct SSttFile         SSttFile;
typedef struct SSmaFile         SSmaFile;
typedef struct SDFileSet        SDFileSet;
typedef struct SDataFWriter     SDataFWriter;
typedef struct SDataFReader     SDataFReader;
typedef struct SDelFWriter      SDelFWriter;
typedef struct SDelFReader      SDelFReader;
H
Hongze Cheng 已提交
59
typedef struct STSDBRowIter     STSDBRowIter;
H
Hongze Cheng 已提交
60 61 62 63 64 65 66 67 68 69 70
typedef struct STsdbFS          STsdbFS;
typedef struct SRowMerger       SRowMerger;
typedef struct STsdbReadSnap    STsdbReadSnap;
typedef struct SBlockInfo       SBlockInfo;
typedef struct SSmaInfo         SSmaInfo;
typedef struct SBlockCol        SBlockCol;
typedef struct SVersionRange    SVersionRange;
typedef struct SLDataIter       SLDataIter;
typedef struct SDiskCol         SDiskCol;
typedef struct SDiskData        SDiskData;
typedef struct SDiskDataBuilder SDiskDataBuilder;
H
Hongze Cheng 已提交
71
typedef struct SBlkInfo         SBlkInfo;
H
Hongze Cheng 已提交
72

H
Hongze Cheng 已提交
73 74 75
#define TSDBROW_ROW_FMT ((int8_t)0x0)
#define TSDBROW_COL_FMT ((int8_t)0x1)

H
Hongze Cheng 已提交
76 77 78
#define TSDB_FILE_DLMT     ((uint32_t)0xF00AFA0F)
#define TSDB_MAX_SUBBLOCKS 8
#define TSDB_FHDR_SIZE     512
H
refact  
Hongze Cheng 已提交
79

H
Hongze Cheng 已提交
80 81 82
#define VERSION_MIN 0
#define VERSION_MAX INT64_MAX

H
Hongze Cheng 已提交
83 84 85
#define TSDBKEY_MIN ((TSDBKEY){.ts = TSKEY_MIN, .version = VERSION_MIN})
#define TSDBKEY_MAX ((TSDBKEY){.ts = TSKEY_MAX, .version = VERSION_MAX})

H
Hongze Cheng 已提交
86 87
#define TABLE_SAME_SCHEMA(SUID1, UID1, SUID2, UID2) ((SUID1) ? (SUID1) == (SUID2) : (UID1) == (UID2))

H
Hongze Cheng 已提交
88 89 90 91 92 93
#define PAGE_CONTENT_SIZE(PAGE) ((PAGE) - sizeof(TSCKSUM))
#define LOGIC_TO_FILE_OFFSET(LOFFSET, PAGE) \
  ((LOFFSET) / PAGE_CONTENT_SIZE(PAGE) * (PAGE) + (LOFFSET) % PAGE_CONTENT_SIZE(PAGE))
#define FILE_TO_LOGIC_OFFSET(OFFSET, PAGE) ((OFFSET) / (PAGE)*PAGE_CONTENT_SIZE(PAGE) + (OFFSET) % (PAGE))
#define PAGE_OFFSET(PGNO, PAGE)            (((PGNO)-1) * (PAGE))
#define OFFSET_PGNO(OFFSET, PAGE)          ((OFFSET) / (PAGE) + 1)
H
Hongze Cheng 已提交
94 95 96 97 98

static FORCE_INLINE int64_t tsdbLogicToFileSize(int64_t lSize, int32_t szPage) {
  int64_t fOffSet = LOGIC_TO_FILE_OFFSET(lSize, szPage);
  int64_t pgno = OFFSET_PGNO(fOffSet, szPage);

H
Hongze Cheng 已提交
99
  if (fOffSet % szPage == 0) {
H
Hongze Cheng 已提交
100 101 102 103 104
    pgno--;
  }

  return pgno * szPage;
}
H
Hongze Cheng 已提交
105

H
Hongze Cheng 已提交
106
// tsdbUtil.c ==============================================================================================
H
Hongze Cheng 已提交
107
// TSDBROW
H
Hongze Cheng 已提交
108 109 110
#define TSDBROW_TS(ROW) (((ROW)->type == TSDBROW_ROW_FMT) ? (ROW)->pTSRow->ts : (ROW)->pBlockData->aTSKEY[(ROW)->iRow])
#define TSDBROW_VERSION(ROW) \
  (((ROW)->type == TSDBROW_ROW_FMT) ? (ROW)->version : (ROW)->pBlockData->aVersion[(ROW)->iRow])
H
Hongze Cheng 已提交
111
#define TSDBROW_SVERSION(ROW)            ((ROW)->type == TSDBROW_ROW_FMT ? (ROW)->pTSRow->ts : -1)
H
Hongze Cheng 已提交
112 113 114 115
#define TSDBROW_KEY(ROW)                 ((TSDBKEY){.version = TSDBROW_VERSION(ROW), .ts = TSDBROW_TS(ROW)})
#define tsdbRowFromTSRow(VERSION, TSROW) ((TSDBROW){.type = TSDBROW_ROW_FMT, .version = (VERSION), .pTSRow = (TSROW)})
#define tsdbRowFromBlockData(BLOCKDATA, IROW) \
  ((TSDBROW){.type = TSDBROW_COL_FMT, .pBlockData = (BLOCKDATA), .iRow = (IROW)})
H
Hongze Cheng 已提交
116 117

void    tsdbRowGetColVal(TSDBROW *pRow, STSchema *pTSchema, int32_t iCol, SColVal *pColVal);
H
Hongze Cheng 已提交
118
int32_t tsdbRowCmprFn(const void *p1, const void *p2);
H
Hongze Cheng 已提交
119
// STSDBRowIter
H
Hongze Cheng 已提交
120 121
int32_t  tsdbRowIterOpen(STSDBRowIter *pIter, TSDBROW *pRow, STSchema *pTSchema);
void     tsdbRowClose(STSDBRowIter *pIter);
H
Hongze Cheng 已提交
122
SColVal *tsdbRowIterNext(STSDBRowIter *pIter);
H
Hongze Cheng 已提交
123
// SRowMerger
H
Hongze Cheng 已提交
124 125
int32_t tsdbRowMergerInit2(SRowMerger *pMerger, STSchema *pResTSchema, TSDBROW *pRow, STSchema *pTSchema);
int32_t tsdbRowMergerAdd(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema);
126

H
Hongze Cheng 已提交
127 128 129 130
int32_t tsdbRowMergerInit(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema);
void    tsdbRowMergerClear(SRowMerger *pMerger);
int32_t tsdbRowMerge(SRowMerger *pMerger, TSDBROW *pRow);
int32_t tsdbRowMergerGetRow(SRowMerger *pMerger, SRow **ppRow);
H
Hongze Cheng 已提交
131
// TABLEID
H
Hongze Cheng 已提交
132
int32_t tTABLEIDCmprFn(const void *p1, const void *p2);
H
Hongze Cheng 已提交
133
// TSDBKEY
H
Hongze Cheng 已提交
134 135
#define MIN_TSDBKEY(KEY1, KEY2) ((tsdbKeyCmprFn(&(KEY1), &(KEY2)) < 0) ? (KEY1) : (KEY2))
#define MAX_TSDBKEY(KEY1, KEY2) ((tsdbKeyCmprFn(&(KEY1), &(KEY2)) > 0) ? (KEY1) : (KEY2))
H
Hongze Cheng 已提交
136 137 138
// SBlockCol
int32_t tPutBlockCol(uint8_t *p, void *ph);
int32_t tGetBlockCol(uint8_t *p, void *ph);
H
Hongze Cheng 已提交
139
int32_t tBlockColCmprFn(const void *p1, const void *p2);
H
Hongze Cheng 已提交
140
// SDataBlk
H
Hongze Cheng 已提交
141
void    tDataBlkReset(SDataBlk *pBlock);
H
Hongze Cheng 已提交
142 143
int32_t tPutDataBlk(uint8_t *p, void *ph);
int32_t tGetDataBlk(uint8_t *p, void *ph);
H
Hongze Cheng 已提交
144 145
int32_t tDataBlkCmprFn(const void *p1, const void *p2);
bool    tDataBlkHasSma(SDataBlk *pDataBlk);
H
Hongze Cheng 已提交
146 147 148
// SSttBlk
int32_t tPutSttBlk(uint8_t *p, void *ph);
int32_t tGetSttBlk(uint8_t *p, void *ph);
H
Hongze Cheng 已提交
149 150 151
// SBlockIdx
int32_t tPutBlockIdx(uint8_t *p, void *ph);
int32_t tGetBlockIdx(uint8_t *p, void *ph);
152
int32_t tCmprBlockIdx(void const *lhs, void const *rhs);
153
int32_t tCmprBlockL(void const *lhs, void const *rhs);
H
Hongze Cheng 已提交
154
// SBlockData
H
Hongze Cheng 已提交
155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
#define tBlockDataFirstRow(PBLOCKDATA)             tsdbRowFromBlockData(PBLOCKDATA, 0)
#define tBlockDataLastRow(PBLOCKDATA)              tsdbRowFromBlockData(PBLOCKDATA, (PBLOCKDATA)->nRow - 1)
#define tBlockDataFirstKey(PBLOCKDATA)             TSDBROW_KEY(&tBlockDataFirstRow(PBLOCKDATA))
#define tBlockDataLastKey(PBLOCKDATA)              TSDBROW_KEY(&tBlockDataLastRow(PBLOCKDATA))
#define tBlockDataGetColDataByIdx(PBLOCKDATA, IDX) (&(PBLOCKDATA)->aColData[IDX])

int32_t tBlockDataCreate(SBlockData *pBlockData);
void    tBlockDataDestroy(SBlockData *pBlockData);
int32_t tBlockDataInit(SBlockData *pBlockData, TABLEID *pId, STSchema *pTSchema, int16_t *aCid, int32_t nCid);
void    tBlockDataReset(SBlockData *pBlockData);
int32_t tBlockDataAppendRow(SBlockData *pBlockData, TSDBROW *pRow, STSchema *pTSchema, int64_t uid);
void    tBlockDataClear(SBlockData *pBlockData);
void    tBlockDataGetColData(SBlockData *pBlockData, int16_t cid, SColData **ppColData);
int32_t tCmprBlockData(SBlockData *pBlockData, int8_t cmprAlg, uint8_t **ppOut, int32_t *szOut, uint8_t *aBuf[],
                       int32_t aBufN[]);
int32_t tDecmprBlockData(uint8_t *pIn, int32_t szIn, SBlockData *pBlockData, uint8_t *aBuf[]);
H
Hongze Cheng 已提交
171
// SDiskDataHdr
H
Hongze Cheng 已提交
172
int32_t tPutDiskDataHdr(uint8_t *p, const SDiskDataHdr *pHdr);
H
Hongze Cheng 已提交
173
int32_t tGetDiskDataHdr(uint8_t *p, void *ph);
H
Hongze Cheng 已提交
174
// SDelIdx
H
Hongze Cheng 已提交
175 176
int32_t tPutDelIdx(uint8_t *p, void *ph);
int32_t tGetDelIdx(uint8_t *p, void *ph);
177
int32_t tCmprDelIdx(void const *lhs, void const *rhs);
H
Hongze Cheng 已提交
178
// SDelData
H
Hongze Cheng 已提交
179 180
int32_t tPutDelData(uint8_t *p, void *ph);
int32_t tGetDelData(uint8_t *p, void *ph);
H
Hongze Cheng 已提交
181
// SMapData
H
Hongze Cheng 已提交
182
#define tMapDataInit() ((SMapData){0})
H
Hongze Cheng 已提交
183 184 185
void    tMapDataReset(SMapData *pMapData);
void    tMapDataClear(SMapData *pMapData);
int32_t tMapDataPutItem(SMapData *pMapData, void *pItem, int32_t (*tPutItemFn)(uint8_t *, void *));
H
Hongze Cheng 已提交
186
int32_t tMapDataCopy(SMapData *pFrom, SMapData *pTo);
H
Hongze Cheng 已提交
187
void    tMapDataGetItemByIdx(SMapData *pMapData, int32_t idx, void *pItem, int32_t (*tGetItemFn)(uint8_t *, void *));
H
Hongze Cheng 已提交
188 189
int32_t tMapDataSearch(SMapData *pMapData, void *pSearchItem, int32_t (*tGetItemFn)(uint8_t *, void *),
                       int32_t (*tItemCmprFn)(const void *, const void *), void *pItem);
H
Hongze Cheng 已提交
190 191
int32_t tPutMapData(uint8_t *p, SMapData *pMapData);
int32_t tGetMapData(uint8_t *p, SMapData *pMapData);
H
Hongze Cheng 已提交
192 193
int32_t tMapDataToArray(SMapData *pMapData, int32_t itemSize, int32_t (*tGetItemFn)(uint8_t *, void *),
                        SArray **ppArray);
H
Hongze Cheng 已提交
194 195 196
// other
int32_t tsdbKeyFid(TSKEY key, int32_t minutes, int8_t precision);
void    tsdbFidKeyRange(int32_t fid, int32_t minutes, int8_t precision, TSKEY *minKey, TSKEY *maxKey);
H
Hongze Cheng 已提交
197
int32_t tsdbFidLevel(int32_t fid, STsdbKeepCfg *pKeepCfg, int64_t now);
H
Hongze Cheng 已提交
198
int32_t tsdbBuildDeleteSkyline(SArray *aDelData, int32_t sidx, int32_t eidx, SArray *aSkyline);
H
Hongze Cheng 已提交
199 200
int32_t tPutColumnDataAgg(uint8_t *p, SColumnDataAgg *pColAgg);
int32_t tGetColumnDataAgg(uint8_t *p, SColumnDataAgg *pColAgg);
H
Hongze Cheng 已提交
201 202
int32_t tsdbCmprData(uint8_t *pIn, int32_t szIn, int8_t type, int8_t cmprAlg, uint8_t **ppOut, int32_t nOut,
                     int32_t *szOut, uint8_t **ppBuf);
H
Hongze Cheng 已提交
203 204
int32_t tsdbDecmprData(uint8_t *pIn, int32_t szIn, int8_t type, int8_t cmprAlg, uint8_t **ppOut, int32_t szOut,
                       uint8_t **ppBuf);
H
Hongze Cheng 已提交
205
int32_t tsdbCmprColData(SColData *pColData, int8_t cmprAlg, SBlockCol *pBlockCol, uint8_t **ppOut, int32_t nOut,
H
Hongze Cheng 已提交
206
                        uint8_t **ppBuf);
H
Hongze Cheng 已提交
207 208
int32_t tsdbDecmprColData(uint8_t *pIn, SBlockCol *pBlockCol, int8_t cmprAlg, int32_t nVal, SColData *pColData,
                          uint8_t **ppBuf);
H
Hongze Cheng 已提交
209 210
// tsdbMemTable ==============================================================================================
// SMemTable
H
Hongze Cheng 已提交
211 212 213 214 215 216
int32_t  tsdbMemTableCreate(STsdb *pTsdb, SMemTable **ppMemTable);
void     tsdbMemTableDestroy(SMemTable *pMemTable);
STbData *tsdbGetTbDataFromMemTable(SMemTable *pMemTable, tb_uid_t suid, tb_uid_t uid);
void     tsdbRefMemTable(SMemTable *pMemTable);
void     tsdbUnrefMemTable(SMemTable *pMemTable);
SArray  *tsdbMemTableGetTbDataArray(SMemTable *pMemTable);
H
Hongze Cheng 已提交
217
// STbDataIter
H
Hongze Cheng 已提交
218 219 220 221
int32_t tsdbTbDataIterCreate(STbData *pTbData, TSDBKEY *pFrom, int8_t backward, STbDataIter **ppIter);
void   *tsdbTbDataIterDestroy(STbDataIter *pIter);
void    tsdbTbDataIterOpen(STbData *pTbData, TSDBKEY *pFrom, int8_t backward, STbDataIter *pIter);
bool    tsdbTbDataIterNext(STbDataIter *pIter);
H
Hongze Cheng 已提交
222 223
// STbData
int32_t tsdbGetNRowsInTbData(STbData *pTbData);
H
Hongze Cheng 已提交
224
// tsdbFile.c ==============================================================================================
H
Hongze Cheng 已提交
225
typedef enum { TSDB_HEAD_FILE = 0, TSDB_DATA_FILE, TSDB_LAST_FILE, TSDB_SMA_FILE } EDataFileT;
H
Hongze Cheng 已提交
226

H
Hongze Cheng 已提交
227
bool    tsdbDelFileIsSame(SDelFile *pDelFile1, SDelFile *pDelFile2);
H
Hongze Cheng 已提交
228
int32_t tsdbDFileRollback(STsdb *pTsdb, SDFileSet *pSet, EDataFileT ftype);
H
Hongze Cheng 已提交
229 230
int32_t tPutHeadFile(uint8_t *p, SHeadFile *pHeadFile);
int32_t tPutDataFile(uint8_t *p, SDataFile *pDataFile);
H
Hongze Cheng 已提交
231
int32_t tPutSttFile(uint8_t *p, SSttFile *pSttFile);
H
Hongze Cheng 已提交
232
int32_t tPutSmaFile(uint8_t *p, SSmaFile *pSmaFile);
H
Hongze Cheng 已提交
233 234 235 236
int32_t tPutDelFile(uint8_t *p, SDelFile *pDelFile);
int32_t tGetDelFile(uint8_t *p, SDelFile *pDelFile);
int32_t tPutDFileSet(uint8_t *p, SDFileSet *pSet);
int32_t tGetDFileSet(uint8_t *p, SDFileSet *pSet);
H
Hongze Cheng 已提交
237 238 239

void tsdbHeadFileName(STsdb *pTsdb, SDiskID did, int32_t fid, SHeadFile *pHeadF, char fname[]);
void tsdbDataFileName(STsdb *pTsdb, SDiskID did, int32_t fid, SDataFile *pDataF, char fname[]);
H
Hongze Cheng 已提交
240
void tsdbSttFileName(STsdb *pTsdb, SDiskID did, int32_t fid, SSttFile *pSttF, char fname[]);
H
Hongze Cheng 已提交
241
void tsdbSmaFileName(STsdb *pTsdb, SDiskID did, int32_t fid, SSmaFile *pSmaF, char fname[]);
H
Hongze Cheng 已提交
242
// SDelFile
H
Hongze Cheng 已提交
243
void tsdbDelFileName(STsdb *pTsdb, SDelFile *pFile, char fname[]);
H
Hongze Cheng 已提交
244
// tsdbFS.c ==============================================================================================
H
Hongze Cheng 已提交
245
int32_t tsdbFSOpen(STsdb *pTsdb, int8_t rollback);
H
Hongze Cheng 已提交
246 247 248 249
int32_t tsdbFSClose(STsdb *pTsdb);
int32_t tsdbFSCopy(STsdb *pTsdb, STsdbFS *pFS);
void    tsdbFSDestroy(STsdbFS *pFS);
int32_t tDFileSetCmprFn(const void *p1, const void *p2);
H
Hongze Cheng 已提交
250 251 252
int32_t tsdbFSCommit(STsdb *pTsdb);
int32_t tsdbFSRollback(STsdb *pTsdb);
int32_t tsdbFSPrepareCommit(STsdb *pTsdb, STsdbFS *pFS);
H
Hongze Cheng 已提交
253 254 255 256 257
int32_t tsdbFSRef(STsdb *pTsdb, STsdbFS *pFS);
void    tsdbFSUnref(STsdb *pTsdb, STsdbFS *pFS);

int32_t tsdbFSUpsertFSet(STsdbFS *pFS, SDFileSet *pSet);
int32_t tsdbFSUpsertDelFile(STsdbFS *pFS, SDelFile *pDelFile);
H
Hongze Cheng 已提交
258 259 260
// tsdbReaderWriter.c ==============================================================================================
// SDataFWriter
int32_t tsdbDataFWriterOpen(SDataFWriter **ppWriter, STsdb *pTsdb, SDFileSet *pSet);
H
Hongze Cheng 已提交
261
int32_t tsdbDataFWriterClose(SDataFWriter **ppWriter, int8_t sync);
H
Hongze Cheng 已提交
262
int32_t tsdbUpdateDFileSetHeader(SDataFWriter *pWriter);
H
Hongze Cheng 已提交
263
int32_t tsdbWriteBlockIdx(SDataFWriter *pWriter, SArray *aBlockIdx);
H
Hongze Cheng 已提交
264
int32_t tsdbWriteDataBlk(SDataFWriter *pWriter, SMapData *mDataBlk, SBlockIdx *pBlockIdx);
H
Hongze Cheng 已提交
265
int32_t tsdbWriteSttBlk(SDataFWriter *pWriter, SArray *aSttBlk);
H
Hongze Cheng 已提交
266
int32_t tsdbWriteBlockData(SDataFWriter *pWriter, SBlockData *pBlockData, SBlockInfo *pBlkInfo, SSmaInfo *pSmaInfo,
H
Hongze Cheng 已提交
267
                           int8_t cmprAlg, int8_t toLast);
H
Hongze Cheng 已提交
268
int32_t tsdbWriteDiskData(SDataFWriter *pWriter, const SDiskData *pDiskData, SBlockInfo *pBlkInfo, SSmaInfo *pSmaInfo);
H
Hongze Cheng 已提交
269 270

int32_t tsdbDFileSetCopy(STsdb *pTsdb, SDFileSet *pSetFrom, SDFileSet *pSetTo);
H
Hongze Cheng 已提交
271 272
// SDataFReader
int32_t tsdbDataFReaderOpen(SDataFReader **ppReader, STsdb *pTsdb, SDFileSet *pSet);
H
Hongze Cheng 已提交
273
int32_t tsdbDataFReaderClose(SDataFReader **ppReader);
H
Hongze Cheng 已提交
274
int32_t tsdbReadBlockIdx(SDataFReader *pReader, SArray *aBlockIdx);
H
Hongze Cheng 已提交
275
int32_t tsdbReadDataBlk(SDataFReader *pReader, SBlockIdx *pBlockIdx, SMapData *mDataBlk);
H
Hongze Cheng 已提交
276
int32_t tsdbReadSttBlk(SDataFReader *pReader, int32_t iStt, SArray *aSttBlk);
H
Hongze Cheng 已提交
277 278
int32_t tsdbReadBlockSma(SDataFReader *pReader, SDataBlk *pBlock, SArray *aColumnDataAgg);
int32_t tsdbReadDataBlock(SDataFReader *pReader, SDataBlk *pBlock, SBlockData *pBlockData);
H
Hongze Cheng 已提交
279
int32_t tsdbReadSttBlock(SDataFReader *pReader, int32_t iStt, SSttBlk *pSttBlk, SBlockData *pBlockData);
H
Hongze Cheng 已提交
280
int32_t tsdbReadSttBlockEx(SDataFReader *pReader, int32_t iStt, SSttBlk *pSttBlk, SBlockData *pBlockData);
H
Hongze Cheng 已提交
281 282
// SDelFWriter
int32_t tsdbDelFWriterOpen(SDelFWriter **ppWriter, SDelFile *pFile, STsdb *pTsdb);
H
Hongze Cheng 已提交
283
int32_t tsdbDelFWriterClose(SDelFWriter **ppWriter, int8_t sync);
H
Hongze Cheng 已提交
284 285
int32_t tsdbWriteDelData(SDelFWriter *pWriter, SArray *aDelData, SDelIdx *pDelIdx);
int32_t tsdbWriteDelIdx(SDelFWriter *pWriter, SArray *aDelIdx);
H
Hongze Cheng 已提交
286
int32_t tsdbUpdateDelFileHdr(SDelFWriter *pWriter);
H
Hongze Cheng 已提交
287
// SDelFReader
H
Hongze Cheng 已提交
288
int32_t tsdbDelFReaderOpen(SDelFReader **ppReader, SDelFile *pFile, STsdb *pTsdb);
H
Hongze Cheng 已提交
289
int32_t tsdbDelFReaderClose(SDelFReader **ppReader);
H
Hongze Cheng 已提交
290 291
int32_t tsdbReadDelData(SDelFReader *pReader, SDelIdx *pDelIdx, SArray *aDelData);
int32_t tsdbReadDelIdx(SDelFReader *pReader, SArray *aDelIdx);
H
Hongze Cheng 已提交
292
// tsdbRead.c ==============================================================================================
H
Hongze Cheng 已提交
293 294
int32_t tsdbTakeReadSnap(STsdb *pTsdb, STsdbReadSnap **ppSnap, const char *id);
void    tsdbUntakeReadSnap(STsdb *pTsdb, STsdbReadSnap *pSnap, const char *id);
H
Hongze Cheng 已提交
295 296
// tsdbMerge.c ==============================================================================================
int32_t tsdbMerge(STsdb *pTsdb);
H
Hongze Cheng 已提交
297

298 299 300 301
#define TSDB_CACHE_NO(c)       ((c).cacheLast == 0)
#define TSDB_CACHE_LAST_ROW(c) (((c).cacheLast & 1) > 0)
#define TSDB_CACHE_LAST(c)     (((c).cacheLast & 2) > 0)

H
Hongze Cheng 已提交
302 303 304 305 306
// tsdbDiskData ==============================================================================================
int32_t tDiskDataBuilderCreate(SDiskDataBuilder **ppBuilder);
void   *tDiskDataBuilderDestroy(SDiskDataBuilder *pBuilder);
int32_t tDiskDataBuilderInit(SDiskDataBuilder *pBuilder, STSchema *pTSchema, TABLEID *pId, uint8_t cmprAlg,
                             uint8_t calcSma);
H
Hongze Cheng 已提交
307 308
int32_t tDiskDataBuilderClear(SDiskDataBuilder *pBuilder);
int32_t tDiskDataAddRow(SDiskDataBuilder *pBuilder, TSDBROW *pRow, STSchema *pTSchema, TABLEID *pId);
H
Hongze Cheng 已提交
309
int32_t tGnrtDiskData(SDiskDataBuilder *pBuilder, const SDiskData **ppDiskData, const SBlkInfo **ppBlkInfo);
H
Hongze Cheng 已提交
310

H
Hongze Cheng 已提交
311
// structs =======================
H
Hongze Cheng 已提交
312 313 314 315 316
struct STsdbFS {
  SDelFile *pDelFile;
  SArray   *aDFileSet;  // SArray<SDFileSet>
};

H
Hongze Cheng 已提交
317
struct STsdb {
H
Hongze Cheng 已提交
318 319 320
  char          *path;
  SVnode        *pVnode;
  STsdbKeepCfg   keepCfg;
H
more  
Hongze Cheng 已提交
321
  TdThreadRwlock rwLock;
H
Hongze Cheng 已提交
322 323
  SMemTable     *mem;
  SMemTable     *imem;
H
Hongze Cheng 已提交
324
  STsdbFS        fs;
H
Hongze Cheng 已提交
325
  SLRUCache     *lruCache;
326
  TdThreadMutex  lruMutex;
H
Hongze Cheng 已提交
327 328
};

H
refact  
Hongze Cheng 已提交
329 330 331 332 333
struct TSDBKEY {
  int64_t version;
  TSKEY   ts;
};

334 335 336 337 338
struct SVersionRange {
  uint64_t minVer;
  uint64_t maxVer;
};

H
Hongze Cheng 已提交
339 340 341
typedef struct SMemSkipListNode SMemSkipListNode;
struct SMemSkipListNode {
  int8_t            level;
H
Hongze Cheng 已提交
342 343
  int8_t            flag;  // TSDBROW_ROW_FMT for row format, TSDBROW_COL_FMT for col format
  int32_t           iRow;
H
Hongze Cheng 已提交
344
  int64_t           version;
H
Hongze Cheng 已提交
345
  void             *pData;
H
Hongze Cheng 已提交
346 347
  SMemSkipListNode *forwards[0];
};
H
Hongze Cheng 已提交
348

H
Hongze Cheng 已提交
349 350
typedef struct SMemSkipList {
  int64_t           size;
H
Hongze Cheng 已提交
351
  uint32_t          seed;
H
Hongze Cheng 已提交
352 353 354 355 356 357
  int8_t            maxLevel;
  int8_t            level;
  SMemSkipListNode *pHead;
  SMemSkipListNode *pTail;
} SMemSkipList;

H
Hongze Cheng 已提交
358
struct STbData {
H
Hongze Cheng 已提交
359 360
  tb_uid_t     suid;
  tb_uid_t     uid;
H
Hongze Cheng 已提交
361 362
  TSKEY        minKey;
  TSKEY        maxKey;
H
Hongze Cheng 已提交
363 364
  SDelData    *pHead;
  SDelData    *pTail;
H
Hongze Cheng 已提交
365
  SMemSkipList sl;
H
Hongze Cheng 已提交
366
  STbData     *next;
H
Hongze Cheng 已提交
367
};
H
Hongze Cheng 已提交
368

H
refact  
Hongze Cheng 已提交
369
struct SMemTable {
H
Hongze Cheng 已提交
370 371 372 373 374 375 376 377
  SRWLatch         latch;
  STsdb           *pTsdb;
  SVBufPool       *pPool;
  volatile int32_t nRef;
  TSKEY            minKey;
  TSKEY            maxKey;
  int64_t          nRow;
  int64_t          nDel;
H
Hongze Cheng 已提交
378 379 380 381 382
  struct {
    int32_t   nTbData;
    int32_t   nBucket;
    STbData **aBucket;
  };
H
Hongze Cheng 已提交
383
};
H
Hongze Cheng 已提交
384

H
Hongze Cheng 已提交
385
struct TSDBROW {
H
Hongze Cheng 已提交
386
  int8_t type;  // TSDBROW_ROW_FMT for row from tsRow, TSDBROW_COL_FMT for row from block data
H
Hongze Cheng 已提交
387 388 389
  union {
    struct {
      int64_t version;
H
Hongze Cheng 已提交
390
      SRow   *pTSRow;
H
Hongze Cheng 已提交
391 392
    };
    struct {
H
Hongze Cheng 已提交
393 394
      SBlockData *pBlockData;
      int32_t     iRow;
H
Hongze Cheng 已提交
395 396
    };
  };
H
Hongze Cheng 已提交
397 398
};

H
Hongze Cheng 已提交
399
struct SBlockIdx {
H
Hongze Cheng 已提交
400 401
  int64_t suid;
  int64_t uid;
H
Hongze Cheng 已提交
402 403 404 405
  int64_t offset;
  int64_t size;
};

H
Hongze Cheng 已提交
406 407
struct SMapData {
  int32_t  nItem;
H
Hongze Cheng 已提交
408
  int32_t  nData;
409
  int32_t *aOffset;
H
Hongze Cheng 已提交
410 411 412
  uint8_t *pData;
};

H
Hongze Cheng 已提交
413
struct SBlockCol {
H
Hongze Cheng 已提交
414 415 416 417 418 419 420 421 422
  int16_t cid;
  int8_t  type;
  int8_t  smaOn;
  int8_t  flag;      // HAS_NONE|HAS_NULL|HAS_VALUE
  int32_t szOrigin;  // original column value size (only save for variant data type)
  int32_t szBitmap;  // bitmap size, 0 only for flag == HAS_VAL
  int32_t szOffset;  // offset size, 0 only for non-variant-length type
  int32_t szValue;   // value size, 0 when flag == (HAS_NULL | HAS_NONE)
  int32_t offset;
H
Hongze Cheng 已提交
423
};
H
Hongze Cheng 已提交
424

H
Hongze Cheng 已提交
425
struct SBlockInfo {
H
Hongze Cheng 已提交
426 427 428
  int64_t offset;  // block data offset
  int32_t szBlock;
  int32_t szKey;
H
Hongze Cheng 已提交
429
};
H
Hongze Cheng 已提交
430

H
Hongze Cheng 已提交
431
struct SSmaInfo {
H
Hongze Cheng 已提交
432 433
  int64_t offset;
  int32_t size;
H
Hongze Cheng 已提交
434
};
H
Hongze Cheng 已提交
435

H
Hongze Cheng 已提交
436
struct SBlkInfo {
H
Hongze Cheng 已提交
437 438
  int64_t minUid;
  int64_t maxUid;
H
Hongze Cheng 已提交
439 440
  TSKEY   minKey;
  TSKEY   maxKey;
H
Hongze Cheng 已提交
441 442
  int64_t minVer;
  int64_t maxVer;
H
Hongze Cheng 已提交
443 444 445
  TSDBKEY minTKey;
  TSDBKEY maxTKey;
};
H
Hongze Cheng 已提交
446

H
Hongze Cheng 已提交
447
struct SDataBlk {
H
Hongze Cheng 已提交
448 449 450 451 452 453 454 455 456
  TSDBKEY    minKey;
  TSDBKEY    maxKey;
  int64_t    minVer;
  int64_t    maxVer;
  int32_t    nRow;
  int8_t     hasDup;
  int8_t     nSubBlock;
  SBlockInfo aSubBlock[TSDB_MAX_SUBBLOCKS];
  SSmaInfo   smaInfo;
H
refact  
Hongze Cheng 已提交
457
};
H
Hongze Cheng 已提交
458

H
Hongze Cheng 已提交
459
struct SSttBlk {
H
Hongze Cheng 已提交
460 461 462
  int64_t    suid;
  int64_t    minUid;
  int64_t    maxUid;
H
Hongze Cheng 已提交
463 464
  TSKEY      minKey;
  TSKEY      maxKey;
H
Hongze Cheng 已提交
465 466 467 468
  int64_t    minVer;
  int64_t    maxVer;
  int32_t    nRow;
  SBlockInfo bInfo;
H
Hongze Cheng 已提交
469 470
};

H
Hongze Cheng 已提交
471 472 473 474
// (SBlockData){.suid = 0, .uid = 0}: block data not initialized
// (SBlockData){.suid = suid, .uid = uid}: block data for ONE child table int .data file
// (SBlockData){.suid = suid, .uid = 0}: block data for N child tables int .last file
// (SBlockData){.suid = 0, .uid = uid}: block data for 1 normal table int .last/.data file
H
Hongze Cheng 已提交
475
struct SBlockData {
H
Hongze Cheng 已提交
476 477 478 479 480 481 482 483
  int64_t   suid;      // 0 means normal table block data, otherwise child table block data
  int64_t   uid;       // 0 means block data in .last file, otherwise in .data file
  int32_t   nRow;      // number of rows
  int64_t  *aUid;      // uids of each row, only exist in block data in .last file (uid == 0)
  int64_t  *aVersion;  // versions of each row
  TSKEY    *aTSKEY;    // timestamp of each row
  int32_t   nColData;
  SColData *aColData;
H
Hongze Cheng 已提交
484
};
H
Hongze Cheng 已提交
485

H
Hongze Cheng 已提交
486 487 488 489 490
struct TABLEID {
  tb_uid_t suid;
  tb_uid_t uid;
};

H
Hongze Cheng 已提交
491 492 493 494
struct STbDataIter {
  STbData          *pTbData;
  int8_t            backward;
  SMemSkipListNode *pNode;
H
Hongze Cheng 已提交
495 496
  TSDBROW          *pRow;
  TSDBROW           row;
H
Hongze Cheng 已提交
497 498
};

H
Hongze Cheng 已提交
499
struct SDelData {
H
Hongze Cheng 已提交
500 501 502 503
  int64_t   version;
  TSKEY     sKey;
  TSKEY     eKey;
  SDelData *pNext;
H
Hongze Cheng 已提交
504
};
H
Hongze Cheng 已提交
505

H
Hongze Cheng 已提交
506
struct SDelIdx {
H
Hongze Cheng 已提交
507 508 509 510
  tb_uid_t suid;
  tb_uid_t uid;
  int64_t  offset;
  int64_t  size;
H
Hongze Cheng 已提交
511
};
H
Hongze Cheng 已提交
512

H
Hongze Cheng 已提交
513
struct SDiskDataHdr {
H
more  
Hongze Cheng 已提交
514
  uint32_t delimiter;
H
Hongze Cheng 已提交
515
  uint32_t fmtVer;
H
more  
Hongze Cheng 已提交
516 517
  int64_t  suid;
  int64_t  uid;
H
Hongze Cheng 已提交
518 519 520 521
  int32_t  szUid;
  int32_t  szVer;
  int32_t  szKey;
  int32_t  szBlkCol;
H
Hongze Cheng 已提交
522
  int32_t  nRow;
H
Hongze Cheng 已提交
523
  int8_t   cmprAlg;
H
Hongze Cheng 已提交
524 525
};

H
Hongze Cheng 已提交
526 527 528 529 530 531 532 533
struct SDelFile {
  volatile int32_t nRef;

  int64_t commitID;
  int64_t size;
  int64_t offset;
};

H
Hongze Cheng 已提交
534
struct SHeadFile {
H
Hongze Cheng 已提交
535 536
  volatile int32_t nRef;

H
Hongze Cheng 已提交
537
  int64_t commitID;
H
Hongze Cheng 已提交
538 539 540 541 542
  int64_t size;
  int64_t offset;
};

struct SDataFile {
H
Hongze Cheng 已提交
543 544
  volatile int32_t nRef;

H
Hongze Cheng 已提交
545
  int64_t commitID;
H
Hongze Cheng 已提交
546 547 548
  int64_t size;
};

H
Hongze Cheng 已提交
549
struct SSttFile {
H
Hongze Cheng 已提交
550 551
  volatile int32_t nRef;

H
Hongze Cheng 已提交
552
  int64_t commitID;
H
Hongze Cheng 已提交
553
  int64_t size;
H
Hongze Cheng 已提交
554
  int64_t offset;
H
Hongze Cheng 已提交
555 556 557
};

struct SSmaFile {
H
Hongze Cheng 已提交
558 559
  volatile int32_t nRef;

H
Hongze Cheng 已提交
560
  int64_t commitID;
H
Hongze Cheng 已提交
561 562 563 564
  int64_t size;
};

struct SDFileSet {
H
Hongze Cheng 已提交
565 566 567 568 569
  SDiskID    diskId;
  int32_t    fid;
  SHeadFile *pHeadF;
  SDataFile *pDataF;
  SSmaFile  *pSmaF;
H
Hongze Cheng 已提交
570
  uint8_t    nSttF;
H
Hongze Cheng 已提交
571
  SSttFile  *aSttF[TSDB_MAX_STT_TRIGGER];
H
Hongze Cheng 已提交
572 573
};

H
Hongze Cheng 已提交
574
struct STSDBRowIter {
H
Hongze Cheng 已提交
575 576 577 578 579 580 581 582
  TSDBROW *pRow;
  union {
    SRowIter *pIter;
    struct {
      int32_t iColData;
      SColVal cv;
    };
  };
H
Hongze Cheng 已提交
583
};
H
Hongze Cheng 已提交
584 585 586 587 588
struct SRowMerger {
  STSchema *pTSchema;
  int64_t   version;
  SArray   *pArray;  // SArray<SColVal>
};
H
Hongze Cheng 已提交
589

H
more  
Hongze Cheng 已提交
590
typedef struct {
H
Hongze Cheng 已提交
591
  char     *path;
H
more  
Hongze Cheng 已提交
592
  int32_t   szPage;
H
Hongze Cheng 已提交
593 594 595
  int32_t   flag;
  TdFilePtr pFD;
  int64_t   pgno;
H
more  
Hongze Cheng 已提交
596
  uint8_t  *pBuf;
H
Hongze Cheng 已提交
597
  int64_t   szFile;
H
more  
Hongze Cheng 已提交
598
} STsdbFD;
H
Hongze Cheng 已提交
599

H
Hongze Cheng 已提交
600 601 602 603
struct SDelFWriter {
  STsdb   *pTsdb;
  SDelFile fDel;
  STsdbFD *pWriteH;
H
Hongze Cheng 已提交
604
  uint8_t *aBuf[1];
H
Hongze Cheng 已提交
605 606
};

H
Hongze Cheng 已提交
607 608 609 610 611 612
struct STsdbReadSnap {
  SMemTable *pMem;
  SMemTable *pIMem;
  STsdbFS    fs;
};

H
Hongze Cheng 已提交
613 614 615 616
struct SDataFWriter {
  STsdb    *pTsdb;
  SDFileSet wSet;

H
Hongze Cheng 已提交
617 618 619
  STsdbFD *pHeadFD;
  STsdbFD *pDataFD;
  STsdbFD *pSmaFD;
H
Hongze Cheng 已提交
620
  STsdbFD *pSttFD;
H
Hongze Cheng 已提交
621 622 623 624

  SHeadFile fHead;
  SDataFile fData;
  SSmaFile  fSma;
H
Hongze Cheng 已提交
625
  SSttFile  fStt[TSDB_MAX_STT_TRIGGER];
H
Hongze Cheng 已提交
626

H
Hongze Cheng 已提交
627
  uint8_t *aBuf[4];
H
Hongze Cheng 已提交
628 629
};

H
Hongze Cheng 已提交
630 631 632
struct SDataFReader {
  STsdb     *pTsdb;
  SDFileSet *pSet;
H
Hongze Cheng 已提交
633 634 635
  STsdbFD   *pHeadFD;
  STsdbFD   *pDataFD;
  STsdbFD   *pSmaFD;
H
Hongze Cheng 已提交
636
  STsdbFD   *aSttFD[TSDB_MAX_STT_TRIGGER];
H
Hongze Cheng 已提交
637
  uint8_t   *aBuf[3];
H
Hongze Cheng 已提交
638 639
};

H
Hongze Cheng 已提交
640 641 642 643 644 645
typedef struct {
  int64_t suid;
  int64_t uid;
  TSDBROW row;
} SRowInfo;

646
typedef struct SSttBlockLoadInfo {
H
Hongze Cheng 已提交
647 648 649 650 651 652
  SBlockData blockData[2];
  SArray    *aSttBlk;
  int32_t    blockIndex[2];  // to denote the loaded block in the corresponding position.
  int32_t    currentLoadBlockIndex;
  int32_t    loadBlocks;
  double     elapsedTime;
653 654 655
  STSchema  *pSchema;
  int16_t   *colIds;
  int32_t    numOfCols;
656
  bool       sttBlockLoaded;
H
Haojun Liao 已提交
657 658 659 660 661 662 663

  // keep the last access position, this position may be used to reduce the binary times for
  // starting last block data for a new table
  struct {
    int32_t blockIndex;
    int32_t rowIndex;
  } prevEndPos;
664 665
} SSttBlockLoadInfo;

666
typedef struct SMergeTree {
H
Hongze Cheng 已提交
667 668 669 670 671 672 673
  int8_t             backward;
  SRBTree            rbt;
  SArray            *pIterList;
  SLDataIter        *pIter;
  bool               destroyLoadInfo;
  SSttBlockLoadInfo *pLoadInfo;
  const char        *idStr;
674 675
} SMergeTree;

H
Hongze Cheng 已提交
676 677 678 679 680 681
typedef struct {
  int64_t   suid;
  int64_t   uid;
  STSchema *pTSchema;
} SSkmInfo;

H
Hongze Cheng 已提交
682 683 684 685 686
struct SDiskCol {
  SBlockCol      bCol;
  const uint8_t *pBit;
  const uint8_t *pOff;
  const uint8_t *pVal;
H
Hongze Cheng 已提交
687
  SColumnDataAgg agg;
H
Hongze Cheng 已提交
688 689 690 691 692 693 694 695 696 697
};

struct SDiskData {
  SDiskDataHdr   hdr;
  const uint8_t *pUid;
  const uint8_t *pVer;
  const uint8_t *pKey;
  SArray        *aDiskCol;  // SArray<SDiskCol>
};

H
Hongze Cheng 已提交
698 699 700 701 702 703 704 705 706 707 708 709
struct SDiskDataBuilder {
  int64_t      suid;
  int64_t      uid;
  int32_t      nRow;
  uint8_t      cmprAlg;
  uint8_t      calcSma;
  SCompressor *pUidC;
  SCompressor *pVerC;
  SCompressor *pKeyC;
  int32_t      nBuilder;
  SArray      *aBuilder;  // SArray<SDiskColBuilder>
  uint8_t     *aBuf[2];
H
Hongze Cheng 已提交
710
  SDiskData    dd;
H
Hongze Cheng 已提交
711
  SBlkInfo     bi;
H
Hongze Cheng 已提交
712 713
};

H
Haojun Liao 已提交
714
int32_t tMergeTreeOpen(SMergeTree *pMTree, int8_t backward, SDataFReader *pFReader, uint64_t suid, uint64_t uid,
715 716
                       STimeWindow *pTimeWindow, SVersionRange *pVerRange, SSttBlockLoadInfo *pBlockLoadInfo,
                       bool destroyLoadInfo, const char *idStr);
H
Hongze Cheng 已提交
717
void    tMergeTreeAddIter(SMergeTree *pMTree, SLDataIter *pIter);
H
Hongze Cheng 已提交
718
bool    tMergeTreeNext(SMergeTree *pMTree);
H
refact  
Hongze Cheng 已提交
719 720
TSDBROW tMergeTreeGetRow(SMergeTree *pMTree);
void    tMergeTreeClose(SMergeTree *pMTree);
721

H
Hongze Cheng 已提交
722
SSttBlockLoadInfo *tCreateLastBlockLoadInfo(STSchema *pSchema, int16_t *colList, int32_t numOfCols);
H
Hongze Cheng 已提交
723 724 725
void               resetLastBlockLoadInfo(SSttBlockLoadInfo *pLoadInfo);
void               getLastBlockLoadInfo(SSttBlockLoadInfo *pLoadInfo, int64_t *blocks, double *el);
void              *destroyLastBlockLoadInfo(SSttBlockLoadInfo *pLoadInfo);
726

727 728
// tsdbCache ==============================================================================================
typedef struct SCacheRowsReader {
H
Hongze Cheng 已提交
729 730 731 732 733 734 735 736
  SVnode   *pVnode;
  STSchema *pSchema;
  uint64_t  uid;
  uint64_t  suid;
  char    **transferBuf;  // todo remove it soon
  int32_t   numOfCols;
  int32_t   type;
  int32_t   tableIndex;  // currently returned result tables
737 738 739

  STableKeyInfo     *pTableList;  // table id list
  int32_t            numOfTables;
740 741 742
  SSttBlockLoadInfo *pLoadInfo;
  STsdbReadSnap     *pReadSnap;
  SDataFReader      *pDataFReader;
743
  SDataFReader      *pDataFReaderLast;
744 745 746 747 748 749 750 751 752
} SCacheRowsReader;

typedef struct {
  TSKEY   ts;
  SColVal colVal;
} SLastCol;

int32_t tsdbOpenCache(STsdb *pTsdb);
void    tsdbCloseCache(STsdb *pTsdb);
H
Hongze Cheng 已提交
753 754
int32_t tsdbCacheInsertLast(SLRUCache *pCache, tb_uid_t uid, TSDBROW *row, STsdb *pTsdb);
int32_t tsdbCacheInsertLastrow(SLRUCache *pCache, STsdb *pTsdb, tb_uid_t uid, TSDBROW *row, bool dup);
755 756 757 758 759 760 761 762 763 764 765
int32_t tsdbCacheGetLastH(SLRUCache *pCache, tb_uid_t uid, SCacheRowsReader *pr, LRUHandle **h);
int32_t tsdbCacheGetLastrowH(SLRUCache *pCache, tb_uid_t uid, SCacheRowsReader *pr, LRUHandle **h);
int32_t tsdbCacheRelease(SLRUCache *pCache, LRUHandle *h);

int32_t tsdbCacheDeleteLastrow(SLRUCache *pCache, tb_uid_t uid, TSKEY eKey);
int32_t tsdbCacheDeleteLast(SLRUCache *pCache, tb_uid_t uid, TSKEY eKey);
int32_t tsdbCacheDelete(SLRUCache *pCache, tb_uid_t uid, TSKEY eKey);

void   tsdbCacheSetCapacity(SVnode *pVnode, size_t capacity);
size_t tsdbCacheGetCapacity(SVnode *pVnode);

H
Hongze Cheng 已提交
766
// int32_t tsdbCacheLastArray2Row(SArray *pLastArray, STSRow **ppRow, STSchema *pSchema);
767

768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787
// ========== inline functions ==========
static FORCE_INLINE int32_t tsdbKeyCmprFn(const void *p1, const void *p2) {
  TSDBKEY *pKey1 = (TSDBKEY *)p1;
  TSDBKEY *pKey2 = (TSDBKEY *)p2;

  if (pKey1->ts < pKey2->ts) {
    return -1;
  } else if (pKey1->ts > pKey2->ts) {
    return 1;
  }

  if (pKey1->version < pKey2->version) {
    return -1;
  } else if (pKey1->version > pKey2->version) {
    return 1;
  }

  return 0;
}

H
Hongze Cheng 已提交
788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808
#define SL_NODE_FORWARD(n, l)  ((n)->forwards[l])
#define SL_NODE_BACKWARD(n, l) ((n)->forwards[(n)->level + (l)])

static FORCE_INLINE TSDBROW *tsdbTbDataIterGet(STbDataIter *pIter) {
  if (pIter == NULL) return NULL;

  if (pIter->pRow) {
    return pIter->pRow;
  }

  if (pIter->backward) {
    if (pIter->pNode == pIter->pTbData->sl.pHead) {
      return NULL;
    }
  } else {
    if (pIter->pNode == pIter->pTbData->sl.pTail) {
      return NULL;
    }
  }

  pIter->pRow = &pIter->row;
H
Hongze Cheng 已提交
809 810 811 812 813 814 815
  if (pIter->pNode->flag == TSDBROW_ROW_FMT) {
    pIter->row = tsdbRowFromTSRow(pIter->pNode->version, pIter->pNode->pData);
  } else if (pIter->pNode->flag == TSDBROW_COL_FMT) {
    pIter->row = tsdbRowFromBlockData(pIter->pNode->pData, pIter->pNode->iRow);
  } else {
    ASSERT(0);
  }
H
Hongze Cheng 已提交
816 817 818 819

  return pIter->pRow;
}

H
Hongze Cheng 已提交
820 821 822 823
#ifdef __cplusplus
}
#endif

824
#endif /*_TD_VNODE_TSDB_H_*/