enh: refactor index code

eab330c0 · dengyihao · d9c83f63 · eab330c0 · eab330c0 · eab330c0
7 changed file
--- a/source/libs/index/inc/indexCache.h
+++ b/source/libs/index/inc/indexCache.h
@@ -62,25 +62,25 @@ typedef struct CacheTerm {
 } CacheTerm;
 //

-IndexCache* indexCacheCreate(SIndex* idx, uint64_t suid, const char* colName, int8_t type);
+IndexCache* idxCacheCreate(SIndex* idx, uint64_t suid, const char* colName, int8_t type);

-void indexCacheForceToMerge(void* cache);
-void indexCacheDestroy(void* cache);
-void indexCacheBroadcast(void* cache);
-void indexCacheWait(void* cache);
+void idxCacheForceToMerge(void* cache);
+void idxCacheDestroy(void* cache);
+void idxCacheBroadcast(void* cache);
+void idxCacheWait(void* cache);

-Iterate* indexCacheIteratorCreate(IndexCache* cache);
+Iterate* idxCacheIteratorCreate(IndexCache* cache);
 void     idxCacheIteratorDestroy(Iterate* iiter);

-int indexCachePut(void* cache, SIndexTerm* term, uint64_t uid);
+int idxCachePut(void* cache, SIndexTerm* term, uint64_t uid);

 // int indexCacheGet(void *cache, uint64_t *rst);
-int indexCacheSearch(void* cache, SIndexTermQuery* query, SIdxTRslt* tr, STermValueType* s);
+int idxCacheSearch(void* cache, SIndexTermQuery* query, SIdxTRslt* tr, STermValueType* s);

-void indexCacheRef(IndexCache* cache);
-void indexCacheUnRef(IndexCache* cache);
+void idxCacheRef(IndexCache* cache);
+void idxCacheUnRef(IndexCache* cache);

-void indexCacheDebug(IndexCache* cache);
+void idxCacheDebug(IndexCache* cache);

 void idxCacheDestroyImm(IndexCache* cache);
 #ifdef __cplusplus

--- a/source/libs/index/inc/indexInt.h
+++ b/source/libs/index/inc/indexInt.h
@@ -138,7 +138,7 @@ int32_t indexRemoveRef(int64_t ref);
 void    indexAcquireRef(int64_t ref);
 void    indexReleaseRef(int64_t ref);

-int32_t indexSerialCacheKey(ICacheKey* key, char* buf);
+int32_t idxSerialCacheKey(ICacheKey* key, char* buf);
 // int32_t indexSerialKey(ICacheKey* key, char* buf);
 // int32_t indexSerialTermKey(SIndexTerm* itm, char* buf);


--- a/source/libs/index/inc/indexTfile.h
+++ b/source/libs/index/inc/indexTfile.h
@@ -117,10 +117,10 @@ int          tfileWriterPut(TFileWriter* tw, void* data, bool order);
 int          tfileWriterFinish(TFileWriter* tw);

 //
-IndexTFile* indexTFileCreate(const char* path);
-void        indexTFileDestroy(IndexTFile* tfile);
-int         indexTFilePut(void* tfile, SIndexTerm* term, uint64_t uid);
-int         indexTFileSearch(void* tfile, SIndexTermQuery* query, SIdxTRslt* tr);
+IndexTFile* idxTFileCreate(const char* path);
+void        idxTFileDestroy(IndexTFile* tfile);
+int         idxTFilePut(void* tfile, SIndexTerm* term, uint64_t uid);
+int         idxTFileSearch(void* tfile, SIndexTermQuery* query, SIdxTRslt* tr);

 Iterate* tfileIteratorCreate(TFileReader* reader);
 void     tfileIteratorDestroy(Iterate* iterator);

--- a/source/libs/index/src/index.c
+++ b/source/libs/index/src/index.c
@@ -106,8 +106,8 @@ int indexOpen(SIndexOpts* opts, const char* path, SIndex** index) {
    return -1;
  }

-  // sIdx->cache = (void*)indexCacheCreate(sIdx);
-  sIdx->tindex = indexTFileCreate(path);
+  // sIdx->cache = (void*)idxCacheCreate(sIdx);
+  sIdx->tindex = idxTFileCreate(path);
  if (sIdx->tindex == NULL) {
    goto END;
  }
@@ -136,7 +136,7 @@ void indexDestroy(void* handle) {
  SIndex* sIdx = handle;
  taosThreadMutexDestroy(&sIdx->mtx);
  tsem_destroy(&sIdx->sem);
-  indexTFileDestroy(sIdx->tindex);
+  idxTFileDestroy(sIdx->tindex);
  taosMemoryFree(sIdx->path);
  taosMemoryFree(sIdx);
  return;
@@ -147,12 +147,12 @@ void indexClose(SIndex* sIdx) {
    void* iter = taosHashIterate(sIdx->colObj, NULL);
    while (iter) {
      IndexCache** pCache = iter;
-      indexCacheForceToMerge((void*)(*pCache));
+      idxCacheForceToMerge((void*)(*pCache));
      indexInfo("%s wait to merge", (*pCache)->colName);
      indexWait((void*)(sIdx));
      indexInfo("%s finish to wait", (*pCache)->colName);
      iter = taosHashIterate(sIdx->colObj, iter);
-      indexCacheUnRef(*pCache);
+      idxCacheUnRef(*pCache);
    }
    taosHashCleanup(sIdx->colObj);
    sIdx->colObj = NULL;
@@ -186,11 +186,11 @@ int indexPut(SIndex* index, SIndexMultiTerm* fVals, uint64_t uid) {

    char      buf[128] = {0};
    ICacheKey key = {.suid = p->suid, .colName = p->colName, .nColName = strlen(p->colName), .colType = p->colType};
-    int32_t   sz = indexSerialCacheKey(&key, buf);
+    int32_t   sz = idxSerialCacheKey(&key, buf);

    IndexCache** cache = taosHashGet(index->colObj, buf, sz);
    if (cache == NULL) {
-      IndexCache* pCache = indexCacheCreate(index, p->suid, p->colName, p->colType);
+      IndexCache* pCache = idxCacheCreate(index, p->suid, p->colName, p->colType);
      taosHashPut(index->colObj, buf, sz, &pCache, sizeof(void*));
    }
  }
@@ -201,12 +201,12 @@ int indexPut(SIndex* index, SIndexMultiTerm* fVals, uint64_t uid) {

    char      buf[128] = {0};
    ICacheKey key = {.suid = p->suid, .colName = p->colName, .nColName = strlen(p->colName), .colType = p->colType};
-    int32_t   sz = indexSerialCacheKey(&key, buf);
+    int32_t   sz = idxSerialCacheKey(&key, buf);
    indexDebug("w suid: %" PRIu64 ", colName: %s, colType: %d", key.suid, key.colName, key.colType);

    IndexCache** cache = taosHashGet(index->colObj, buf, sz);
    assert(*cache != NULL);
-    int ret = indexCachePut(*cache, p, uid);
+    int ret = idxCachePut(*cache, p, uid);
    if (ret != 0) {
      return ret;
    }
@@ -331,7 +331,7 @@ static int idxTermSearch(SIndex* sIdx, SIndexTermQuery* query, SArray** result)
  ICacheKey key = {
      .suid = term->suid, .colName = term->colName, .nColName = strlen(term->colName), .colType = term->colType};
  indexDebug("r suid: %" PRIu64 ", colName: %s, colType: %d", key.suid, key.colName, key.colType);
-  int32_t sz = indexSerialCacheKey(&key, buf);
+  int32_t sz = idxSerialCacheKey(&key, buf);

  taosThreadMutexLock(&sIdx->mtx);
  IndexCache** pCache = taosHashGet(sIdx->colObj, buf, sz);
@@ -345,14 +345,14 @@ static int idxTermSearch(SIndex* sIdx, SIndexTermQuery* query, SArray** result)
  int64_t st = taosGetTimestampUs();

  SIdxTRslt* tr = idxTRsltCreate();
-  if (0 == indexCacheSearch(cache, query, tr, &s)) {
+  if (0 == idxCacheSearch(cache, query, tr, &s)) {
    if (s == kTypeDeletion) {
      indexInfo("col: %s already drop by", term->colName);
      // coloum already drop by other oper, no need to query tindex
      return 0;
    } else {
      st = taosGetTimestampUs();
-      if (0 != indexTFileSearch(sIdx->tindex, query, tr)) {
+      if (0 != idxTFileSearch(sIdx->tindex, query, tr)) {
        indexError("corrupt at index(TFile) col:%s val: %s", term->colName, term->colVal);
        goto END;
      }
@@ -472,7 +472,7 @@ int idxFlushCacheToTFile(SIndex* sIdx, void* cache, bool quit) {
    indexWarn("empty tfile reader found");
  }
  // handle flush
-  Iterate* cacheIter = indexCacheIteratorCreate(pCache);
+  Iterate* cacheIter = idxCacheIteratorCreate(pCache);
  if (cacheIter == NULL) {
    indexError("%p immtable is empty, ignore merge opera", pCache);
    idxCacheDestroyImm(pCache);
@@ -532,7 +532,7 @@ int idxFlushCacheToTFile(SIndex* sIdx, void* cache, bool quit) {
  tfileIteratorDestroy(tfileIter);

  tfileReaderUnRef(pReader);
-  indexCacheUnRef(pCache);
+  idxCacheUnRef(pCache);

  int64_t cost = taosGetTimestampUs() - st;
  if (ret != 0) {
@@ -620,7 +620,7 @@ END:
  return -1;
 }

-int32_t indexSerialCacheKey(ICacheKey* key, char* buf) {
+int32_t idxSerialCacheKey(ICacheKey* key, char* buf) {
  bool hasJson = INDEX_TYPE_CONTAIN_EXTERN_TYPE(key->colType, TSDB_DATA_TYPE_JSON);

  char* p = buf;

--- a/source/libs/index/src/indexCache.c
+++ b/source/libs/index/src/indexCache.c
@@ -68,7 +68,7 @@ static int32_t (*cacheSearch[][QUERY_MAX])(void* cache, SIndexTerm* ct, SIdxTRsl
     cacheSearchLessThan_JSON, cacheSearchLessEqual_JSON, cacheSearchGreaterThan_JSON, cacheSearchGreaterEqual_JSON,
     cacheSearchRange_JSON}};

-static void doMergeWork(SSchedMsg* msg);
+static void idxDoMergeWork(SSchedMsg* msg);
 static bool idxCacheIteratorNext(Iterate* itera);

 static int32_t cacheSearchTerm(void* cache, SIndexTerm* term, SIdxTRslt* tr, STermValueType* s) {
@@ -331,9 +331,9 @@ static int32_t cacheSearchRange(void* cache, SIndexTerm* term, SIdxTRslt* tr, ST
  // impl later
  return 0;
 }
-static IterateValue* indexCacheIteratorGetValue(Iterate* iter);
+static IterateValue* idxCacheIteratorGetValue(Iterate* iter);

-IndexCache* indexCacheCreate(SIndex* idx, uint64_t suid, const char* colName, int8_t type) {
+IndexCache* idxCacheCreate(SIndex* idx, uint64_t suid, const char* colName, int8_t type) {
  IndexCache* cache = taosMemoryCalloc(1, sizeof(IndexCache));
  if (cache == NULL) {
    indexError("failed to create index cache");
@@ -352,13 +352,13 @@ IndexCache* indexCacheCreate(SIndex* idx, uint64_t suid, const char* colName, in
  taosThreadMutexInit(&cache->mtx, NULL);
  taosThreadCondInit(&cache->finished, NULL);

-  indexCacheRef(cache);
+  idxCacheRef(cache);
  if (idx != NULL) {
    indexAcquireRef(idx->refId);
  }
  return cache;
 }
-void indexCacheDebug(IndexCache* cache) {
+void idxCacheDebug(IndexCache* cache) {
  MemTable* tbl = NULL;

  taosThreadMutexLock(&cache->mtx);
@@ -405,7 +405,7 @@ void indexCacheDebug(IndexCache* cache) {
  }
 }

-void indexCacheDestroySkiplist(SSkipList* slt) {
+void idxCacheDestroySkiplist(SSkipList* slt) {
  SSkipListIterator* iter = tSkipListCreateIter(slt);
  while (iter != NULL && tSkipListIterNext(iter)) {
    SSkipListNode* node = tSkipListIterGet(iter);
@@ -418,11 +418,11 @@ void indexCacheDestroySkiplist(SSkipList* slt) {
  tSkipListDestroyIter(iter);
  tSkipListDestroy(slt);
 }
-void indexCacheBroadcast(void* cache) {
+void idxCacheBroadcast(void* cache) {
  IndexCache* pCache = cache;
  taosThreadCondBroadcast(&pCache->finished);
 }
-void indexCacheWait(void* cache) {
+void idxCacheWait(void* cache) {
  IndexCache* pCache = cache;
  taosThreadCondWait(&pCache->finished, &pCache->mtx);
 }
@@ -435,14 +435,14 @@ void idxCacheDestroyImm(IndexCache* cache) {

  tbl = cache->imm;
  cache->imm = NULL;  // or throw int bg thread
-  indexCacheBroadcast(cache);
+  idxCacheBroadcast(cache);

  taosThreadMutexUnlock(&cache->mtx);

  idxMemUnRef(tbl);
  idxMemUnRef(tbl);
 }
-void indexCacheDestroy(void* cache) {
+void idxCacheDestroy(void* cache) {
  IndexCache* pCache = cache;
  if (pCache == NULL) {
    return;
@@ -460,7 +460,7 @@ void indexCacheDestroy(void* cache) {
  taosMemoryFree(pCache);
 }

-Iterate* indexCacheIteratorCreate(IndexCache* cache) {
+Iterate* idxCacheIteratorCreate(IndexCache* cache) {
  if (cache->imm == NULL) {
    return NULL;
  }
@@ -477,7 +477,7 @@ Iterate* indexCacheIteratorCreate(IndexCache* cache) {
  iiter->val.colVal = NULL;
  iiter->iter = tbl != NULL ? tSkipListCreateIter(tbl->mem) : NULL;
  iiter->next = idxCacheIteratorNext;
-  iiter->getValue = indexCacheIteratorGetValue;
+  iiter->getValue = idxCacheIteratorGetValue;

  taosThreadMutexUnlock(&cache->mtx);

@@ -492,9 +492,9 @@ void idxCacheIteratorDestroy(Iterate* iter) {
  taosMemoryFree(iter);
 }

-int indexCacheSchedToMerge(IndexCache* pCache, bool notify) {
+int idxCacheSchedToMerge(IndexCache* pCache, bool notify) {
  SSchedMsg schedMsg = {0};
-  schedMsg.fp = doMergeWork;
+  schedMsg.fp = idxDoMergeWork;
  schedMsg.ahandle = pCache;
  if (notify) {
    schedMsg.thandle = taosMemoryMalloc(1);
@@ -505,17 +505,17 @@ int indexCacheSchedToMerge(IndexCache* pCache, bool notify) {
  return 0;
 }

-static void indexCacheMakeRoomForWrite(IndexCache* cache) {
+static void idxCacheMakeRoomForWrite(IndexCache* cache) {
  while (true) {
    if (cache->occupiedMem * MEM_ESTIMATE_RADIO < MEM_THRESHOLD) {
      break;
    } else if (cache->imm != NULL) {
      // TODO: wake up by condition variable
-      indexCacheWait(cache);
+      idxCacheWait(cache);
    } else {
      bool quit = cache->occupiedMem >= MEM_SIGNAL_QUIT ? true : false;

-      indexCacheRef(cache);
+      idxCacheRef(cache);
      cache->imm = cache->mem;
      cache->mem = idxInternalCacheCreate(cache->type);
      cache->mem->pCache = cache;
@@ -525,18 +525,18 @@ static void indexCacheMakeRoomForWrite(IndexCache* cache) {
      }
      // sched to merge
      // unref cache in bgwork
-      indexCacheSchedToMerge(cache, quit);
+      idxCacheSchedToMerge(cache, quit);
    }
  }
 }
-int indexCachePut(void* cache, SIndexTerm* term, uint64_t uid) {
+int idxCachePut(void* cache, SIndexTerm* term, uint64_t uid) {
  if (cache == NULL) {
    return -1;
  }
  bool hasJson = INDEX_TYPE_CONTAIN_EXTERN_TYPE(term->colType, TSDB_DATA_TYPE_JSON);

  IndexCache* pCache = cache;
-  indexCacheRef(pCache);
+  idxCacheRef(pCache);
  // encode data
  CacheTerm* ct = taosMemoryCalloc(1, sizeof(CacheTerm));
  if (cache == NULL) {
@@ -559,7 +559,7 @@ int indexCachePut(void* cache, SIndexTerm* term, uint64_t uid) {

  taosThreadMutexLock(&pCache->mtx);
  pCache->occupiedMem += estimate;
-  indexCacheMakeRoomForWrite(pCache);
+  idxCacheMakeRoomForWrite(pCache);
  MemTable* tbl = pCache->mem;
  idxMemRef(tbl);
  tSkipListPut(tbl->mem, (char*)ct);
@@ -567,29 +567,29 @@ int indexCachePut(void* cache, SIndexTerm* term, uint64_t uid) {

  taosThreadMutexUnlock(&pCache->mtx);

-  indexCacheUnRef(pCache);
+  idxCacheUnRef(pCache);
  return 0;
  // encode end
 }
-void indexCacheForceToMerge(void* cache) {
+void idxCacheForceToMerge(void* cache) {
  IndexCache* pCache = cache;
-  indexCacheRef(pCache);
+  idxCacheRef(pCache);
  taosThreadMutexLock(&pCache->mtx);

  indexInfo("%p is forced to merge into tfile", pCache);
  pCache->occupiedMem += MEM_SIGNAL_QUIT;
-  indexCacheMakeRoomForWrite(pCache);
+  idxCacheMakeRoomForWrite(pCache);

  taosThreadMutexUnlock(&pCache->mtx);
-  indexCacheUnRef(pCache);
+  idxCacheUnRef(pCache);
  return;
 }
-int indexCacheDel(void* cache, const char* fieldValue, int32_t fvlen, uint64_t uid, int8_t operType) {
+int idxCacheDel(void* cache, const char* fieldValue, int32_t fvlen, uint64_t uid, int8_t operType) {
  IndexCache* pCache = cache;
  return 0;
 }

-static int32_t indexQueryMem(MemTable* mem, SIndexTermQuery* query, SIdxTRslt* tr, STermValueType* s) {
+static int32_t idxQueryMem(MemTable* mem, SIndexTermQuery* query, SIdxTRslt* tr, STermValueType* s) {
  if (mem == NULL) {
    return 0;
  }
@@ -603,7 +603,7 @@ static int32_t indexQueryMem(MemTable* mem, SIndexTermQuery* query, SIdxTRslt* t
    return cacheSearch[0][qtype](mem, term, tr, s);
  }
 }
-int indexCacheSearch(void* cache, SIndexTermQuery* query, SIdxTRslt* result, STermValueType* s) {
+int idxCacheSearch(void* cache, SIndexTermQuery* query, SIdxTRslt* result, STermValueType* s) {
  int64_t st = taosGetTimestampUs();
  if (cache == NULL) {
    return 0;
@@ -618,10 +618,10 @@ int indexCacheSearch(void* cache, SIndexTermQuery* query, SIdxTRslt* result, STe
  idxMemRef(imm);
  taosThreadMutexUnlock(&pCache->mtx);

-  int ret = (mem && mem->mem) ? indexQueryMem(mem, query, result, s) : 0;
+  int ret = (mem && mem->mem) ? idxQueryMem(mem, query, result, s) : 0;
  if (ret == 0 && *s != kTypeDeletion) {
    // continue search in imm
-    ret = (imm && imm->mem) ? indexQueryMem(imm, query, result, s) : 0;
+    ret = (imm && imm->mem) ? idxQueryMem(imm, query, result, s) : 0;
  }

  idxMemUnRef(mem);
@@ -631,20 +631,20 @@ int indexCacheSearch(void* cache, SIndexTermQuery* query, SIdxTRslt* result, STe
  return ret;
 }

-void indexCacheRef(IndexCache* cache) {
+void idxCacheRef(IndexCache* cache) {
  if (cache == NULL) {
    return;
  }
  int ref = T_REF_INC(cache);
  UNUSED(ref);
 }
-void indexCacheUnRef(IndexCache* cache) {
+void idxCacheUnRef(IndexCache* cache) {
  if (cache == NULL) {
    return;
  }
  int ref = T_REF_DEC(cache);
  if (ref == 0) {
-    indexCacheDestroy(cache);
+    idxCacheDestroy(cache);
  }
 }

@@ -662,7 +662,7 @@ void idxMemUnRef(MemTable* tbl) {
  int ref = T_REF_DEC(tbl);
  if (ref == 0) {
    SSkipList* slt = tbl->mem;
-    indexCacheDestroySkiplist(slt);
+    idxCacheDestroySkiplist(slt);
    taosMemoryFree(tbl);
  }
 }
@@ -693,15 +693,15 @@ static int32_t idxCacheTermCompare(const void* l, const void* r) {
  return cmp;
 }

-static int indexFindCh(char* a, char c) {
+static int idxFindCh(char* a, char c) {
  char* p = a;
  while (*p != 0 && *p++ != c) {
  }
  return p - a;
 }
 static int idxCacheJsonTermCompareImpl(char* a, char* b) {
-  // int alen = indexFindCh(a, '&');
-  // int blen = indexFindCh(b, '&');
+  // int alen = idxFindCh(a, '&');
+  // int blen = idxFindCh(b, '&');

  // int cmp = strncmp(a, b, MIN(alen, blen));
  // if (cmp == 0) {
@@ -742,7 +742,7 @@ static MemTable* idxInternalCacheCreate(int8_t type) {
  return tbl;
 }

-static void doMergeWork(SSchedMsg* msg) {
+static void idxDoMergeWork(SSchedMsg* msg) {
  IndexCache* pCache = msg->ahandle;
  SIndex*     sidx = (SIndex*)pCache->index;

@@ -771,7 +771,7 @@ static bool idxCacheIteratorNext(Iterate* itera) {
  return next;
 }

-static IterateValue* indexCacheIteratorGetValue(Iterate* iter) {
+static IterateValue* idxCacheIteratorGetValue(Iterate* iter) {
  // opt later
  return &iter->val;
 }
--- a/source/libs/index/src/indexTfile.c
+++ b/source/libs/index/src/indexTfile.c
@@ -118,7 +118,7 @@ TFileCache* tfileCacheCreate(const char* path) {
    ICacheKey    key = {.suid = header->suid, .colName = header->colName, .nColName = (int32_t)strlen(header->colName)};

    char    buf[128] = {0};
-    int32_t sz = indexSerialCacheKey(&key, buf);
+    int32_t sz = idxSerialCacheKey(&key, buf);
    assert(sz < sizeof(buf));
    taosHashPut(tcache->tableCache, buf, sz, &reader, sizeof(void*));
    tfileReaderRef(reader);
@@ -149,7 +149,7 @@ void tfileCacheDestroy(TFileCache* tcache) {

 TFileReader* tfileCacheGet(TFileCache* tcache, ICacheKey* key) {
  char    buf[128] = {0};
-  int32_t sz = indexSerialCacheKey(key, buf);
+  int32_t sz = idxSerialCacheKey(key, buf);
  assert(sz < sizeof(buf));
  TFileReader** reader = taosHashGet(tcache->tableCache, buf, sz);
  if (reader == NULL || *reader == NULL) {
@@ -161,7 +161,7 @@ TFileReader* tfileCacheGet(TFileCache* tcache, ICacheKey* key) {
 }
 void tfileCachePut(TFileCache* tcache, ICacheKey* key, TFileReader* reader) {
  char    buf[128] = {0};
-  int32_t sz = indexSerialCacheKey(key, buf);
+  int32_t sz = idxSerialCacheKey(key, buf);
  // remove last version index reader
  TFileReader** p = taosHashGet(tcache->tableCache, buf, sz);
  if (p != NULL && *p != NULL) {
@@ -620,7 +620,7 @@ void tfileWriterDestroy(TFileWriter* tw) {
  taosMemoryFree(tw);
 }

-IndexTFile* indexTFileCreate(const char* path) {
+IndexTFile* idxTFileCreate(const char* path) {
  TFileCache* cache = tfileCacheCreate(path);
  if (cache == NULL) {
    return NULL;
@@ -635,7 +635,7 @@ IndexTFile* indexTFileCreate(const char* path) {
  tfile->cache = cache;
  return tfile;
 }
-void indexTFileDestroy(IndexTFile* tfile) {
+void idxTFileDestroy(IndexTFile* tfile) {
  if (tfile == NULL) {
    return;
  }
@@ -644,7 +644,7 @@ void indexTFileDestroy(IndexTFile* tfile) {
  taosMemoryFree(tfile);
 }

-int indexTFileSearch(void* tfile, SIndexTermQuery* query, SIdxTRslt* result) {
+int idxTFileSearch(void* tfile, SIndexTermQuery* query, SIdxTRslt* result) {
  int ret = -1;
  if (tfile == NULL) {
    return ret;
@@ -667,7 +667,7 @@ int indexTFileSearch(void* tfile, SIndexTermQuery* query, SIdxTRslt* result) {

  return tfileReaderSearch(reader, query, result);
 }
-int indexTFilePut(void* tfile, SIndexTerm* term, uint64_t uid) {
+int idxTFilePut(void* tfile, SIndexTerm* term, uint64_t uid) {
  // TFileWriterOpt wOpt = {.suid = term->suid, .colType = term->colType, .colName = term->colName, .nColName =
  // term->nColName, .version = 1};


--- a/source/libs/index/test/indexTests.cc
+++ b/source/libs/index/test/indexTests.cc
@@ -521,10 +521,10 @@ class CacheObj {
 public:
  CacheObj() {
    // TODO
-    cache = indexCacheCreate(NULL, 0, "voltage", TSDB_DATA_TYPE_BINARY);
+    cache = idxCacheCreate(NULL, 0, "voltage", TSDB_DATA_TYPE_BINARY);
  }
  int Put(SIndexTerm* term, int16_t colId, int32_t version, uint64_t uid) {
-    int ret = indexCachePut(cache, term, uid);
+    int ret = idxCachePut(cache, term, uid);
    if (ret != 0) {
      //
      std::cout << "failed to put into cache: " << ret << std::endl;
@@ -533,12 +533,12 @@ class CacheObj {
  }
  void Debug() {
    //
-    indexCacheDebug(cache);
+    idxCacheDebug(cache);
  }
  int Get(SIndexTermQuery* query, int16_t colId, int32_t version, SArray* result, STermValueType* s) {
    SIdxTRslt* tr = idxTRsltCreate();

-    int ret = indexCacheSearch(cache, query, tr, s);
+    int ret = idxCacheSearch(cache, query, tr, s);
    idxTRsltMergeTo(tr, result);
    idxTRsltDestroy(tr);

@@ -549,7 +549,7 @@ class CacheObj {
  }
  ~CacheObj() {
    // TODO
-    indexCacheDestroy(cache);
+    idxCacheDestroy(cache);
  }

 private: