refactor code
This commit is contained in:
yihaoDeng
parent
11eb2719f8
commit
7d29af7316
|
|
@ -63,9 +63,7 @@ static int indexGenTFile(SIndex* index, IndexCache* cache, SArray* batch);
|
|||
int indexOpen(SIndexOpts* opts, const char* path, SIndex** index) {
|
||||
// pthread_once(&isInit, indexInit);
|
||||
SIndex* sIdx = calloc(1, sizeof(SIndex));
|
||||
if (sIdx == NULL) {
|
||||
return -1;
|
||||
}
|
||||
if (sIdx == NULL) { return -1; }
|
||||
|
||||
#ifdef USE_LUCENE
|
||||
index_t* index = index_open(path);
|
||||
|
|
@ -75,9 +73,7 @@ int indexOpen(SIndexOpts* opts, const char* path, SIndex** index) {
|
|||
#ifdef USE_INVERTED_INDEX
|
||||
// sIdx->cache = (void*)indexCacheCreate(sIdx);
|
||||
sIdx->tindex = indexTFileCreate(path);
|
||||
if (sIdx->tindex == NULL) {
|
||||
goto END;
|
||||
}
|
||||
if (sIdx->tindex == NULL) { goto END; }
|
||||
|
||||
sIdx->colObj = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
|
||||
sIdx->cVersion = 1;
|
||||
|
|
@ -88,9 +84,7 @@ int indexOpen(SIndexOpts* opts, const char* path, SIndex** index) {
|
|||
#endif
|
||||
|
||||
END:
|
||||
if (sIdx != NULL) {
|
||||
indexClose(sIdx);
|
||||
}
|
||||
if (sIdx != NULL) { indexClose(sIdx); }
|
||||
|
||||
*index = NULL;
|
||||
return -1;
|
||||
|
|
@ -106,9 +100,7 @@ void indexClose(SIndex* sIdx) {
|
|||
void* iter = taosHashIterate(sIdx->colObj, NULL);
|
||||
while (iter) {
|
||||
IndexCache** pCache = iter;
|
||||
if (*pCache) {
|
||||
indexCacheUnRef(*pCache);
|
||||
}
|
||||
if (*pCache) { indexCacheUnRef(*pCache); }
|
||||
iter = taosHashIterate(sIdx->colObj, iter);
|
||||
}
|
||||
taosHashCleanup(sIdx->colObj);
|
||||
|
|
@ -166,9 +158,7 @@ int indexPut(SIndex* index, SIndexMultiTerm* fVals, uint64_t uid) {
|
|||
IndexCache** cache = taosHashGet(index->colObj, buf, sz);
|
||||
assert(*cache != NULL);
|
||||
int ret = indexCachePut(*cache, p, uid);
|
||||
if (ret != 0) {
|
||||
return ret;
|
||||
}
|
||||
if (ret != 0) { return ret; }
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -198,9 +188,7 @@ int indexSearch(SIndex* index, SIndexMultiTermQuery* multiQuerys, SArray* result
|
|||
int tsz = 0;
|
||||
index_multi_search(index->index, (const char**)fields, (const char**)keys, types, nQuery, opera, &tResult, &tsz);
|
||||
|
||||
for (int i = 0; i < tsz; i++) {
|
||||
taosArrayPush(result, &tResult[i]);
|
||||
}
|
||||
for (int i = 0; i < tsz; i++) { taosArrayPush(result, &tResult[i]); }
|
||||
|
||||
for (int i = 0; i < nQuery; i++) {
|
||||
free(fields[i]);
|
||||
|
|
@ -257,9 +245,7 @@ void indexOptsDestroy(SIndexOpts* opts) {
|
|||
*/
|
||||
SIndexMultiTermQuery* indexMultiTermQueryCreate(EIndexOperatorType opera) {
|
||||
SIndexMultiTermQuery* p = (SIndexMultiTermQuery*)malloc(sizeof(SIndexMultiTermQuery));
|
||||
if (p == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
if (p == NULL) { return NULL; }
|
||||
p->opera = opera;
|
||||
p->query = taosArrayInit(4, sizeof(SIndexTermQuery));
|
||||
return p;
|
||||
|
|
@ -281,9 +267,7 @@ int indexMultiTermQueryAdd(SIndexMultiTermQuery* pQuery, SIndexTerm* term, EInde
|
|||
SIndexTerm* indexTermCreate(int64_t suid, SIndexOperOnColumn oper, uint8_t colType, const char* colName,
|
||||
int32_t nColName, const char* colVal, int32_t nColVal) {
|
||||
SIndexTerm* t = (SIndexTerm*)calloc(1, (sizeof(SIndexTerm)));
|
||||
if (t == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
if (t == NULL) { return NULL; }
|
||||
|
||||
t->suid = suid;
|
||||
t->operType = oper;
|
||||
|
|
@ -356,9 +340,7 @@ static int indexTermSearch(SIndex* sIdx, SIndexTermQuery* query, SArray** result
|
|||
return 0;
|
||||
}
|
||||
static void indexInterResultsDestroy(SArray* results) {
|
||||
if (results == NULL) {
|
||||
return;
|
||||
}
|
||||
if (results == NULL) { return; }
|
||||
|
||||
size_t sz = taosArrayGetSize(results);
|
||||
for (size_t i = 0; i < sz; i++) {
|
||||
|
|
@ -414,22 +396,16 @@ static void indexDestroyTempResult(SArray* result) {
|
|||
taosArrayDestroy(result);
|
||||
}
|
||||
int indexFlushCacheTFile(SIndex* sIdx, void* cache) {
|
||||
if (sIdx == NULL) {
|
||||
return -1;
|
||||
}
|
||||
if (sIdx == NULL) { return -1; }
|
||||
indexInfo("suid %" PRIu64 " merge cache into tindex", sIdx->suid);
|
||||
|
||||
IndexCache* pCache = (IndexCache*)cache;
|
||||
TFileReader* pReader = tfileGetReaderByCol(sIdx->tindex, pCache->suid, pCache->colName);
|
||||
if (pReader == NULL) {
|
||||
indexWarn("empty tfile reader found");
|
||||
}
|
||||
if (pReader == NULL) { indexWarn("empty tfile reader found"); }
|
||||
// handle flush
|
||||
Iterate* cacheIter = indexCacheIteratorCreate(pCache);
|
||||
Iterate* tfileIter = tfileIteratorCreate(pReader);
|
||||
if (tfileIter == NULL) {
|
||||
indexWarn("empty tfile reader iterator");
|
||||
}
|
||||
if (tfileIter == NULL) { indexWarn("empty tfile reader iterator"); }
|
||||
|
||||
SArray* result = taosArrayInit(1024, sizeof(void*));
|
||||
|
||||
|
|
@ -496,9 +472,7 @@ void iterateValueDestroy(IterateValue* value, bool destroy) {
|
|||
taosArrayDestroy(value->val);
|
||||
value->val = NULL;
|
||||
} else {
|
||||
if (value->val != NULL) {
|
||||
taosArrayClear(value->val);
|
||||
}
|
||||
if (value->val != NULL) { taosArrayClear(value->val); }
|
||||
}
|
||||
free(value->colVal);
|
||||
value->colVal = NULL;
|
||||
|
|
@ -521,9 +495,7 @@ static int indexGenTFile(SIndex* sIdx, IndexCache* cache, SArray* batch) {
|
|||
tfileWriterClose(tw);
|
||||
|
||||
TFileReader* reader = tfileReaderOpen(sIdx->path, cache->suid, version, cache->colName);
|
||||
if (reader == NULL) {
|
||||
goto END;
|
||||
}
|
||||
if (reader == NULL) { goto END; }
|
||||
|
||||
TFileHeader* header = &reader->header;
|
||||
ICacheKey key = {.suid = cache->suid, .colName = header->colName, .nColName = strlen(header->colName)};
|
||||
|
|
|
|||
|
|
@ -115,9 +115,7 @@ void indexCacheDestroySkiplist(SSkipList* slt) {
|
|||
tSkipListDestroy(slt);
|
||||
}
|
||||
void indexCacheDestroyImm(IndexCache* cache) {
|
||||
if (cache == NULL) {
|
||||
return;
|
||||
}
|
||||
if (cache == NULL) { return; }
|
||||
|
||||
MemTable* tbl = NULL;
|
||||
pthread_mutex_lock(&cache->mtx);
|
||||
|
|
@ -130,9 +128,7 @@ void indexCacheDestroyImm(IndexCache* cache) {
|
|||
}
|
||||
void indexCacheDestroy(void* cache) {
|
||||
IndexCache* pCache = cache;
|
||||
if (pCache == NULL) {
|
||||
return;
|
||||
}
|
||||
if (pCache == NULL) { return; }
|
||||
indexMemUnRef(pCache->mem);
|
||||
indexMemUnRef(pCache->imm);
|
||||
free(pCache->colName);
|
||||
|
|
@ -142,9 +138,7 @@ void indexCacheDestroy(void* cache) {
|
|||
|
||||
Iterate* indexCacheIteratorCreate(IndexCache* cache) {
|
||||
Iterate* iiter = calloc(1, sizeof(Iterate));
|
||||
if (iiter == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
if (iiter == NULL) { return NULL; }
|
||||
|
||||
pthread_mutex_lock(&cache->mtx);
|
||||
|
||||
|
|
@ -162,9 +156,7 @@ Iterate* indexCacheIteratorCreate(IndexCache* cache) {
|
|||
return iiter;
|
||||
}
|
||||
void indexCacheIteratorDestroy(Iterate* iter) {
|
||||
if (iter == NULL) {
|
||||
return;
|
||||
}
|
||||
if (iter == NULL) { return; }
|
||||
tSkipListDestroyIter(iter->iter);
|
||||
iterateValueDestroy(&iter->val, true);
|
||||
free(iter);
|
||||
|
|
@ -202,17 +194,13 @@ static void indexCacheMakeRoomForWrite(IndexCache* cache) {
|
|||
}
|
||||
|
||||
int indexCachePut(void* cache, SIndexTerm* term, uint64_t uid) {
|
||||
if (cache == NULL) {
|
||||
return -1;
|
||||
}
|
||||
if (cache == NULL) { return -1; }
|
||||
|
||||
IndexCache* pCache = cache;
|
||||
indexCacheRef(pCache);
|
||||
// encode data
|
||||
CacheTerm* ct = calloc(1, sizeof(CacheTerm));
|
||||
if (cache == NULL) {
|
||||
return -1;
|
||||
}
|
||||
if (cache == NULL) { return -1; }
|
||||
// set up key
|
||||
ct->colType = term->colType;
|
||||
ct->colVal = (char*)calloc(1, sizeof(char) * (term->nColVal + 1));
|
||||
|
|
@ -243,9 +231,7 @@ int indexCacheDel(void* cache, const char* fieldValue, int32_t fvlen, uint64_t u
|
|||
}
|
||||
|
||||
static int indexQueryMem(MemTable* mem, CacheTerm* ct, EIndexQueryType qtype, SArray* result, STermValueType* s) {
|
||||
if (mem == NULL) {
|
||||
return 0;
|
||||
}
|
||||
if (mem == NULL) { return 0; }
|
||||
char* key = getIndexKey(ct);
|
||||
|
||||
SSkipListIterator* iter = tSkipListCreateIterFromVal(mem->mem, key, TSDB_DATA_TYPE_BINARY, TSDB_ORDER_ASC);
|
||||
|
|
@ -271,9 +257,7 @@ static int indexQueryMem(MemTable* mem, CacheTerm* ct, EIndexQueryType qtype, SA
|
|||
return 0;
|
||||
}
|
||||
int indexCacheSearch(void* cache, SIndexTermQuery* query, SArray* result, STermValueType* s) {
|
||||
if (cache == NULL) {
|
||||
return 0;
|
||||
}
|
||||
if (cache == NULL) { return 0; }
|
||||
IndexCache* pCache = cache;
|
||||
|
||||
MemTable *mem = NULL, *imm = NULL;
|
||||
|
|
@ -301,33 +285,23 @@ int indexCacheSearch(void* cache, SIndexTermQuery* query, SArray* result, STermV
|
|||
}
|
||||
|
||||
void indexCacheRef(IndexCache* cache) {
|
||||
if (cache == NULL) {
|
||||
return;
|
||||
}
|
||||
if (cache == NULL) { return; }
|
||||
int ref = T_REF_INC(cache);
|
||||
UNUSED(ref);
|
||||
}
|
||||
void indexCacheUnRef(IndexCache* cache) {
|
||||
if (cache == NULL) {
|
||||
return;
|
||||
}
|
||||
if (cache == NULL) { return; }
|
||||
int ref = T_REF_DEC(cache);
|
||||
if (ref == 0) {
|
||||
indexCacheDestroy(cache);
|
||||
}
|
||||
if (ref == 0) { indexCacheDestroy(cache); }
|
||||
}
|
||||
|
||||
void indexMemRef(MemTable* tbl) {
|
||||
if (tbl == NULL) {
|
||||
return;
|
||||
}
|
||||
if (tbl == NULL) { return; }
|
||||
int ref = T_REF_INC(tbl);
|
||||
UNUSED(ref);
|
||||
}
|
||||
void indexMemUnRef(MemTable* tbl) {
|
||||
if (tbl == NULL) {
|
||||
return;
|
||||
}
|
||||
if (tbl == NULL) { return; }
|
||||
int ref = T_REF_DEC(tbl);
|
||||
if (ref == 0) {
|
||||
SSkipList* slt = tbl->mem;
|
||||
|
|
@ -337,9 +311,7 @@ void indexMemUnRef(MemTable* tbl) {
|
|||
}
|
||||
|
||||
static void cacheTermDestroy(CacheTerm* ct) {
|
||||
if (ct == NULL) {
|
||||
return;
|
||||
}
|
||||
if (ct == NULL) { return; }
|
||||
free(ct->colVal);
|
||||
free(ct);
|
||||
}
|
||||
|
|
@ -354,9 +326,7 @@ static int32_t compareKey(const void* l, const void* r) {
|
|||
|
||||
// compare colVal
|
||||
int32_t cmp = strcmp(lt->colVal, rt->colVal);
|
||||
if (cmp == 0) {
|
||||
return rt->version - lt->version;
|
||||
}
|
||||
if (cmp == 0) { return rt->version - lt->version; }
|
||||
return cmp;
|
||||
}
|
||||
|
||||
|
|
@ -376,9 +346,7 @@ static void doMergeWork(SSchedMsg* msg) {
|
|||
}
|
||||
static bool indexCacheIteratorNext(Iterate* itera) {
|
||||
SSkipListIterator* iter = itera->iter;
|
||||
if (iter == NULL) {
|
||||
return false;
|
||||
}
|
||||
if (iter == NULL) { return false; }
|
||||
IterateValue* iv = &itera->val;
|
||||
iterateValueDestroy(iv, false);
|
||||
|
||||
|
|
|
|||
|
|
@ -55,9 +55,7 @@ static void tfileGenFileFullName(char* fullname, const char* path, uint64_t s
|
|||
|
||||
TFileCache* tfileCacheCreate(const char* path) {
|
||||
TFileCache* tcache = calloc(1, sizeof(TFileCache));
|
||||
if (tcache == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
if (tcache == NULL) { return NULL; }
|
||||
|
||||
tcache->tableCache = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
|
||||
tcache->capacity = 64;
|
||||
|
|
@ -73,9 +71,7 @@ TFileCache* tfileCacheCreate(const char* path) {
|
|||
}
|
||||
|
||||
TFileReader* reader = tfileReaderCreate(wc);
|
||||
if (reader == NULL) {
|
||||
goto End;
|
||||
}
|
||||
if (reader == NULL) { goto End; }
|
||||
TFileHeader* header = &reader->header;
|
||||
ICacheKey key = {.suid = header->suid, .colName = header->colName, .nColName = strlen(header->colName)};
|
||||
|
||||
|
|
@ -93,9 +89,7 @@ End:
|
|||
return NULL;
|
||||
}
|
||||
void tfileCacheDestroy(TFileCache* tcache) {
|
||||
if (tcache == NULL) {
|
||||
return;
|
||||
}
|
||||
if (tcache == NULL) { return; }
|
||||
|
||||
// free table cache
|
||||
TFileReader** reader = taosHashIterate(tcache->tableCache, NULL);
|
||||
|
|
@ -116,9 +110,7 @@ TFileReader* tfileCacheGet(TFileCache* tcache, ICacheKey* key) {
|
|||
int32_t sz = indexSerialCacheKey(key, buf);
|
||||
assert(sz < sizeof(buf));
|
||||
TFileReader** reader = taosHashGet(tcache->tableCache, buf, sz);
|
||||
if (reader == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
if (reader == NULL) { return NULL; }
|
||||
tfileReaderRef(*reader);
|
||||
|
||||
return *reader;
|
||||
|
|
@ -141,9 +133,7 @@ void tfileCachePut(TFileCache* tcache, ICacheKey* key, TFileReader* reader) {
|
|||
}
|
||||
TFileReader* tfileReaderCreate(WriterCtx* ctx) {
|
||||
TFileReader* reader = calloc(1, sizeof(TFileReader));
|
||||
if (reader == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
if (reader == NULL) { return NULL; }
|
||||
|
||||
// T_REF_INC(reader);
|
||||
reader->ctx = ctx;
|
||||
|
|
@ -163,9 +153,7 @@ TFileReader* tfileReaderCreate(WriterCtx* ctx) {
|
|||
return reader;
|
||||
}
|
||||
void tfileReaderDestroy(TFileReader* reader) {
|
||||
if (reader == NULL) {
|
||||
return;
|
||||
}
|
||||
if (reader == NULL) { return; }
|
||||
// T_REF_INC(reader);
|
||||
fstDestroy(reader->fst);
|
||||
writerCtxDestroy(reader->ctx, reader->remove);
|
||||
|
|
@ -205,9 +193,7 @@ TFileWriter* tfileWriterOpen(char* path, uint64_t suid, int32_t version, const c
|
|||
tfileGenFileFullName(fullname, path, suid, colName, version);
|
||||
// indexInfo("open write file name %s", fullname);
|
||||
WriterCtx* wcx = writerCtxCreate(TFile, fullname, false, 1024 * 1024 * 64);
|
||||
if (wcx == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
if (wcx == NULL) { return NULL; }
|
||||
|
||||
TFileHeader tfh = {0};
|
||||
tfh.suid = suid;
|
||||
|
|
@ -223,9 +209,7 @@ TFileReader* tfileReaderOpen(char* path, uint64_t suid, int32_t version, const c
|
|||
|
||||
WriterCtx* wc = writerCtxCreate(TFile, fullname, true, 1024 * 1024 * 1024);
|
||||
indexInfo("open read file name:%s, size: %d", wc->file.buf, wc->file.size);
|
||||
if (wc == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
if (wc == NULL) { return NULL; }
|
||||
|
||||
TFileReader* reader = tfileReaderCreate(wc);
|
||||
return reader;
|
||||
|
|
@ -312,25 +296,19 @@ int tfileWriterPut(TFileWriter* tw, void* data, bool order) {
|
|||
return 0;
|
||||
}
|
||||
void tfileWriterClose(TFileWriter* tw) {
|
||||
if (tw == NULL) {
|
||||
return;
|
||||
}
|
||||
if (tw == NULL) { return; }
|
||||
writerCtxDestroy(tw->ctx, false);
|
||||
free(tw);
|
||||
}
|
||||
void tfileWriterDestroy(TFileWriter* tw) {
|
||||
if (tw == NULL) {
|
||||
return;
|
||||
}
|
||||
if (tw == NULL) { return; }
|
||||
writerCtxDestroy(tw->ctx, false);
|
||||
free(tw);
|
||||
}
|
||||
|
||||
IndexTFile* indexTFileCreate(const char* path) {
|
||||
TFileCache* cache = tfileCacheCreate(path);
|
||||
if (cache == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
if (cache == NULL) { return NULL; }
|
||||
|
||||
IndexTFile* tfile = calloc(1, sizeof(IndexTFile));
|
||||
if (tfile == NULL) {
|
||||
|
|
@ -342,27 +320,21 @@ IndexTFile* indexTFileCreate(const char* path) {
|
|||
return tfile;
|
||||
}
|
||||
void indexTFileDestroy(IndexTFile* tfile) {
|
||||
if (tfile == NULL) {
|
||||
return;
|
||||
}
|
||||
if (tfile == NULL) { return; }
|
||||
tfileCacheDestroy(tfile->cache);
|
||||
free(tfile);
|
||||
}
|
||||
|
||||
int indexTFileSearch(void* tfile, SIndexTermQuery* query, SArray* result) {
|
||||
int ret = -1;
|
||||
if (tfile == NULL) {
|
||||
return ret;
|
||||
}
|
||||
if (tfile == NULL) { return ret; }
|
||||
|
||||
IndexTFile* pTfile = (IndexTFile*)tfile;
|
||||
|
||||
SIndexTerm* term = query->term;
|
||||
ICacheKey key = {.suid = term->suid, .colType = term->colType, .colName = term->colName, .nColName = term->nColName};
|
||||
TFileReader* reader = tfileCacheGet(pTfile->cache, &key);
|
||||
if (reader == NULL) {
|
||||
return 0;
|
||||
}
|
||||
if (reader == NULL) { return 0; }
|
||||
|
||||
return tfileReaderSearch(reader, query, result);
|
||||
}
|
||||
|
|
@ -384,9 +356,7 @@ static bool tfileIteratorNext(Iterate* iiter) {
|
|||
|
||||
TFileFstIter* tIter = iiter->iter;
|
||||
StreamWithStateResult* rt = streamWithStateNextWith(tIter->st, NULL);
|
||||
if (rt == NULL) {
|
||||
return false;
|
||||
}
|
||||
if (rt == NULL) { return false; }
|
||||
|
||||
int32_t sz = 0;
|
||||
char* ch = (char*)fstSliceData(&rt->data, &sz);
|
||||
|
|
@ -396,9 +366,7 @@ static bool tfileIteratorNext(Iterate* iiter) {
|
|||
offset = (uint64_t)(rt->out.out);
|
||||
swsResultDestroy(rt);
|
||||
// set up iterate value
|
||||
if (tfileReaderLoadTableIds(tIter->rdr, offset, iv->val) != 0) {
|
||||
return false;
|
||||
}
|
||||
if (tfileReaderLoadTableIds(tIter->rdr, offset, iv->val) != 0) { return false; }
|
||||
|
||||
iv->colVal = colVal;
|
||||
return true;
|
||||
|
|
@ -409,9 +377,7 @@ static IterateValue* tifileIterateGetValue(Iterate* iter) { return &iter->val; }
|
|||
|
||||
static TFileFstIter* tfileFstIteratorCreate(TFileReader* reader) {
|
||||
TFileFstIter* tIter = calloc(1, sizeof(TFileFstIter));
|
||||
if (tIter == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
if (tIter == NULL) { return NULL; }
|
||||
|
||||
tIter->ctx = automCtxCreate(NULL, AUTOMATION_ALWAYS);
|
||||
tIter->fb = fstSearch(reader->fst, tIter->ctx);
|
||||
|
|
@ -421,9 +387,7 @@ static TFileFstIter* tfileFstIteratorCreate(TFileReader* reader) {
|
|||
}
|
||||
|
||||
Iterate* tfileIteratorCreate(TFileReader* reader) {
|
||||
if (reader == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
if (reader == NULL) { return NULL; }
|
||||
|
||||
Iterate* iter = calloc(1, sizeof(Iterate));
|
||||
iter->iter = tfileFstIteratorCreate(reader);
|
||||
|
|
@ -438,9 +402,7 @@ Iterate* tfileIteratorCreate(TFileReader* reader) {
|
|||
return iter;
|
||||
}
|
||||
void tfileIteratorDestroy(Iterate* iter) {
|
||||
if (iter == NULL) {
|
||||
return;
|
||||
}
|
||||
if (iter == NULL) { return; }
|
||||
|
||||
IterateValue* iv = &iter->val;
|
||||
iterateValueDestroy(iv, true);
|
||||
|
|
@ -455,9 +417,7 @@ void tfileIteratorDestroy(Iterate* iter) {
|
|||
}
|
||||
|
||||
TFileReader* tfileGetReaderByCol(IndexTFile* tf, uint64_t suid, char* colName) {
|
||||
if (tf == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
if (tf == NULL) { return NULL; }
|
||||
ICacheKey key = {.suid = suid, .colType = TSDB_DATA_TYPE_BINARY, .colName = colName, .nColName = strlen(colName)};
|
||||
return tfileCacheGet(tf->cache, &key);
|
||||
}
|
||||
|
|
@ -469,9 +429,7 @@ static int tfileUidCompare(const void* a, const void* b) {
|
|||
}
|
||||
static int tfileStrCompare(const void* a, const void* b) {
|
||||
int ret = strcmp((char*)a, (char*)b);
|
||||
if (ret == 0) {
|
||||
return ret;
|
||||
}
|
||||
if (ret == 0) { return ret; }
|
||||
return ret < 0 ? -1 : 1;
|
||||
}
|
||||
|
||||
|
|
@ -486,17 +444,13 @@ static int tfileValueCompare(const void* a, const void* b, const void* param) {
|
|||
|
||||
TFileValue* tfileValueCreate(char* val) {
|
||||
TFileValue* tf = calloc(1, sizeof(TFileValue));
|
||||
if (tf == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
if (tf == NULL) { return NULL; }
|
||||
tf->colVal = tstrdup(val);
|
||||
tf->tableId = taosArrayInit(32, sizeof(uint64_t));
|
||||
return tf;
|
||||
}
|
||||
int tfileValuePush(TFileValue* tf, uint64_t val) {
|
||||
if (tf == NULL) {
|
||||
return -1;
|
||||
}
|
||||
if (tf == NULL) { return -1; }
|
||||
taosArrayPush(tf->tableId, &val);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -517,9 +471,7 @@ static void tfileSerialTableIdsToBuf(char* buf, SArray* ids) {
|
|||
static int tfileWriteFstOffset(TFileWriter* tw, int32_t offset) {
|
||||
int32_t fstOffset = offset + sizeof(tw->header.fstOffset);
|
||||
tw->header.fstOffset = fstOffset;
|
||||
if (sizeof(fstOffset) != tw->ctx->write(tw->ctx, (char*)&fstOffset, sizeof(fstOffset))) {
|
||||
return -1;
|
||||
}
|
||||
if (sizeof(fstOffset) != tw->ctx->write(tw->ctx, (char*)&fstOffset, sizeof(fstOffset))) { return -1; }
|
||||
tw->offset += sizeof(fstOffset);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -530,9 +482,7 @@ static int tfileWriteHeader(TFileWriter* writer) {
|
|||
memcpy(buf, (char*)header, sizeof(buf));
|
||||
|
||||
int nwrite = writer->ctx->write(writer->ctx, buf, sizeof(buf));
|
||||
if (sizeof(buf) != nwrite) {
|
||||
return -1;
|
||||
}
|
||||
if (sizeof(buf) != nwrite) { return -1; }
|
||||
writer->offset = nwrite;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -574,9 +524,7 @@ static int tfileReaderLoadFst(TFileReader* reader) {
|
|||
static int FST_MAX_SIZE = 64 * 1024 * 1024;
|
||||
|
||||
char* buf = calloc(1, sizeof(char) * FST_MAX_SIZE);
|
||||
if (buf == NULL) {
|
||||
return -1;
|
||||
}
|
||||
if (buf == NULL) { return -1; }
|
||||
|
||||
WriterCtx* ctx = reader->ctx;
|
||||
int32_t nread = ctx->readFrom(ctx, buf, FST_MAX_SIZE, reader->header.fstOffset);
|
||||
|
|
@ -601,31 +549,23 @@ static int tfileReaderLoadTableIds(TFileReader* reader, int32_t offset, SArray*
|
|||
|
||||
int32_t total = sizeof(uint64_t) * nid;
|
||||
char* buf = calloc(1, total);
|
||||
if (buf == NULL) {
|
||||
return -1;
|
||||
}
|
||||
if (buf == NULL) { return -1; }
|
||||
|
||||
nread = ctx->readFrom(ctx, buf, total, offset + sizeof(nid));
|
||||
assert(total == nread);
|
||||
|
||||
for (int32_t i = 0; i < nid; i++) {
|
||||
taosArrayPush(result, (uint64_t*)buf + i);
|
||||
}
|
||||
for (int32_t i = 0; i < nid; i++) { taosArrayPush(result, (uint64_t*)buf + i); }
|
||||
free(buf);
|
||||
return 0;
|
||||
}
|
||||
void tfileReaderRef(TFileReader* reader) {
|
||||
if (reader == NULL) {
|
||||
return;
|
||||
}
|
||||
if (reader == NULL) { return; }
|
||||
int ref = T_REF_INC(reader);
|
||||
UNUSED(ref);
|
||||
}
|
||||
|
||||
void tfileReaderUnRef(TFileReader* reader) {
|
||||
if (reader == NULL) {
|
||||
return;
|
||||
}
|
||||
if (reader == NULL) { return; }
|
||||
int ref = T_REF_DEC(reader);
|
||||
if (ref == 0) {
|
||||
// do nothing
|
||||
|
|
@ -641,15 +581,11 @@ static SArray* tfileGetFileList(const char* path) {
|
|||
uint32_t version;
|
||||
|
||||
DIR* dir = opendir(path);
|
||||
if (NULL == dir) {
|
||||
return NULL;
|
||||
}
|
||||
if (NULL == dir) { return NULL; }
|
||||
struct dirent* entry;
|
||||
while ((entry = readdir(dir)) != NULL) {
|
||||
char* file = entry->d_name;
|
||||
if (0 != tfileParseFileName(file, &suid, buf, &version)) {
|
||||
continue;
|
||||
}
|
||||
if (0 != tfileParseFileName(file, &suid, buf, &version)) { continue; }
|
||||
|
||||
size_t len = strlen(path) + 1 + strlen(file) + 1;
|
||||
char* buf = calloc(1, len);
|
||||
|
|
|
|||
Loading…
Reference in New Issue