diff --git a/source/libs/index/inc/indexInt.h b/source/libs/index/inc/indexInt.h
index 72415a9716..2584a847ff 100644
--- a/source/libs/index/inc/indexInt.h
+++ b/source/libs/index/inc/indexInt.h
@@ -42,11 +42,11 @@ typedef struct SIndexStat {
 
 struct SIndex {
 #ifdef USE_LUCENE
-  index_t *index;
+  index_t* index;
 #endif
-  void *    cache;
-  void *    tindex;
-  SHashObj *colObj;  // < field name, field id>
+  void*     cache;
+  void*     tindex;
+  SHashObj* colObj;  // < field name, field id>
 
   int64_t suid;      // current super table id, -1 is normal table
   int     colId;     // field id allocated to cache
@@ -58,7 +58,7 @@ struct SIndex {
 
 struct SIndexOpts {
 #ifdef USE_LUCENE
-  void *opts;
+  void* opts;
 #endif
 
 #ifdef USE_INVERTED_INDEX
@@ -69,7 +69,7 @@ struct SIndexOpts {
 
 struct SIndexMultiTermQuery {
   EIndexOperatorType opera;
-  SArray *           query;
+  SArray*            query;
 };
 
 // field and key;
@@ -77,14 +77,14 @@ typedef struct SIndexTerm {
   int64_t            suid;
   SIndexOperOnColumn operType;  // oper type, add/del/update
   uint8_t            colType;   // term data type, str/interger/json
-  char *             colName;
+  char*              colName;
   int32_t            nColName;
-  char *             colVal;
+  char*              colVal;
   int32_t            nColVal;
 } SIndexTerm;
 
 typedef struct SIndexTermQuery {
-  SIndexTerm *    term;
+  SIndexTerm*     term;
   EIndexQueryType qType;
 } SIndexTermQuery;
 
diff --git a/source/libs/index/inc/index_cache.h b/source/libs/index/inc/index_cache.h
index 9d5083d23d..fb4f478ae9 100644
--- a/source/libs/index/inc/index_cache.h
+++ b/source/libs/index/inc/index_cache.h
@@ -34,19 +34,18 @@ extern "C" {
 
 typedef struct IndexCache {
   T_REF_DECLARE()
-  SSkipList *skiplist;
+  SSkipList* skiplist;
 } IndexCache;
 
 //
-IndexCache *indexCacheCreate();
+IndexCache* indexCacheCreate();
 
-void indexCacheDestroy(void *cache);
+void indexCacheDestroy(void* cache);
 
-int indexCachePut(void *cache, SIndexTerm *term, int16_t colId, int32_t version, uint64_t uid);
+int indexCachePut(void* cache, SIndexTerm* term, int16_t colId, int32_t version, uint64_t uid);
 
 // int indexCacheGet(void *cache, uint64_t *rst);
-int indexCacheSearch(
-    void *cache, SIndexTermQuery *query, int16_t colId, int32_t version, SArray *result, STermValueType *s);
+int indexCacheSearch(void* cache, SIndexTermQuery* query, int16_t colId, int32_t version, SArray* result, STermValueType* s);
 
 #ifdef __cplusplus
 }
diff --git a/source/libs/index/inc/index_fst.h b/source/libs/index/inc/index_fst.h
index 67438c092b..3c572787fc 100644
--- a/source/libs/index/inc/index_fst.h
+++ b/source/libs/index/inc/index_fst.h
@@ -40,10 +40,10 @@ typedef struct FstBoundWithData {
 } FstBoundWithData;
 
 typedef struct FstStreamBuilder {
-  Fst *             fst;
-  AutomationCtx *   aut;
-  FstBoundWithData *min;
-  FstBoundWithData *max;
+  Fst*              fst;
+  AutomationCtx*    aut;
+  FstBoundWithData* min;
+  FstBoundWithData* max;
 } FstStreamBuilder, FstStreamWithStateBuilder;
 
 typedef struct FstRange {
@@ -55,10 +55,10 @@ typedef enum { GE, GT, LE, LT } RangeType;
 typedef enum { OneTransNext, OneTrans, AnyTrans, EmptyFinal } State;
 typedef enum { Ordered, OutOfOrdered, DuplicateKey } OrderType;
 
-FstBoundWithData *fstBoundStateCreate(FstBound type, FstSlice *data);
-bool              fstBoundWithDataExceededBy(FstBoundWithData *bound, FstSlice *slice);
-bool              fstBoundWithDataIsEmpty(FstBoundWithData *bound);
-bool              fstBoundWithDataIsIncluded(FstBoundWithData *bound);
+FstBoundWithData* fstBoundStateCreate(FstBound type, FstSlice* data);
+bool              fstBoundWithDataExceededBy(FstBoundWithData* bound, FstSlice* slice);
+bool              fstBoundWithDataIsEmpty(FstBoundWithData* bound);
+bool              fstBoundWithDataIsIncluded(FstBoundWithData* bound);
 
 typedef struct FstOutput {
   bool   null;
@@ -71,46 +71,46 @@ typedef struct FstOutput {
  * TODO: simple function name
  */
 typedef struct FstUnFinishedNodes {
-  SArray *stack;  // <FstBuilderNodeUnfinished> } FstUnFinishedNodes;
+  SArray* stack;  // <FstBuilderNodeUnfinished> } FstUnFinishedNodes;
 } FstUnFinishedNodes;
 
 #define FST_UNFINISHED_NODES_LEN(nodes) taosArrayGetSize(nodes->stack)
 
-FstUnFinishedNodes *fstUnFinishedNodesCreate();
-void                fstUnFinishedNodesDestroy(FstUnFinishedNodes *node);
-void                fstUnFinishedNodesPushEmpty(FstUnFinishedNodes *nodes, bool isFinal);
-void                fstUnFinishedNodesSetRootOutput(FstUnFinishedNodes *node, Output out);
-void                fstUnFinishedNodesTopLastFreeze(FstUnFinishedNodes *node, CompiledAddr addr);
-void                fstUnFinishedNodesAddSuffix(FstUnFinishedNodes *node, FstSlice bs, Output out);
-uint64_t            fstUnFinishedNodesFindCommPrefix(FstUnFinishedNodes *node, FstSlice bs);
-FstBuilderNode *    fstUnFinishedNodesPopRoot(FstUnFinishedNodes *nodes);
-FstBuilderNode *    fstUnFinishedNodesPopFreeze(FstUnFinishedNodes *nodes, CompiledAddr addr);
-FstBuilderNode *    fstUnFinishedNodesPopEmpty(FstUnFinishedNodes *nodes);
+FstUnFinishedNodes* fstUnFinishedNodesCreate();
+void                fstUnFinishedNodesDestroy(FstUnFinishedNodes* node);
+void                fstUnFinishedNodesPushEmpty(FstUnFinishedNodes* nodes, bool isFinal);
+void                fstUnFinishedNodesSetRootOutput(FstUnFinishedNodes* node, Output out);
+void                fstUnFinishedNodesTopLastFreeze(FstUnFinishedNodes* node, CompiledAddr addr);
+void                fstUnFinishedNodesAddSuffix(FstUnFinishedNodes* node, FstSlice bs, Output out);
+uint64_t            fstUnFinishedNodesFindCommPrefix(FstUnFinishedNodes* node, FstSlice bs);
+FstBuilderNode*     fstUnFinishedNodesPopRoot(FstUnFinishedNodes* nodes);
+FstBuilderNode*     fstUnFinishedNodesPopFreeze(FstUnFinishedNodes* nodes, CompiledAddr addr);
+FstBuilderNode*     fstUnFinishedNodesPopEmpty(FstUnFinishedNodes* nodes);
 
-uint64_t fstUnFinishedNodesFindCommPrefixAndSetOutput(FstUnFinishedNodes *node, FstSlice bs, Output in, Output *out);
+uint64_t fstUnFinishedNodesFindCommPrefixAndSetOutput(FstUnFinishedNodes* node, FstSlice bs, Output in, Output* out);
 
 typedef struct FstBuilder {
-  FstCountingWriter * wrt;         // The FST raw data is written directly to `wtr`.
-  FstUnFinishedNodes *unfinished;  // The stack of unfinished nodes
-  FstRegistry *       registry;    // A map of finished nodes.
+  FstCountingWriter*  wrt;         // The FST raw data is written directly to `wtr`.
+  FstUnFinishedNodes* unfinished;  // The stack of unfinished nodes
+  FstRegistry*        registry;    // A map of finished nodes.
   FstSlice            last;        // The last word added
   CompiledAddr        lastAddr;    // The address of the last compiled node
   uint64_t            len;         // num of keys added
 } FstBuilder;
 
-FstBuilder *fstBuilderCreate(void *w, FstType ty);
+FstBuilder* fstBuilderCreate(void* w, FstType ty);
 
-void         fstBuilderDestroy(FstBuilder *b);
-void         fstBuilderInsertOutput(FstBuilder *b, FstSlice bs, Output in);
-bool         fstBuilderInsert(FstBuilder *b, FstSlice bs, Output in);
-void         fstBuilderCompileFrom(FstBuilder *b, uint64_t istate);
-void *       fstBuilerIntoInner(FstBuilder *b);
-void         fstBuilderFinish(FstBuilder *b);
-OrderType    fstBuilderCheckLastKey(FstBuilder *b, FstSlice bs, bool ckDup);
-CompiledAddr fstBuilderCompile(FstBuilder *b, FstBuilderNode *bn);
+void         fstBuilderDestroy(FstBuilder* b);
+void         fstBuilderInsertOutput(FstBuilder* b, FstSlice bs, Output in);
+bool         fstBuilderInsert(FstBuilder* b, FstSlice bs, Output in);
+void         fstBuilderCompileFrom(FstBuilder* b, uint64_t istate);
+void*        fstBuilerIntoInner(FstBuilder* b);
+void         fstBuilderFinish(FstBuilder* b);
+OrderType    fstBuilderCheckLastKey(FstBuilder* b, FstSlice bs, bool ckDup);
+CompiledAddr fstBuilderCompile(FstBuilder* b, FstBuilderNode* bn);
 
 typedef struct FstTransitions {
-  FstNode *node;
+  FstNode* node;
   FstRange range;
 } FstTransitions;
 
@@ -121,56 +121,55 @@ typedef struct FstState {
   uint8_t val;
 } FstState;
 
-FstState fstStateCreateFrom(FstSlice *data, CompiledAddr addr);
+FstState fstStateCreateFrom(FstSlice* data, CompiledAddr addr);
 FstState fstStateCreate(State state);
 
 // compile
-void fstStateCompileForOneTransNext(FstCountingWriter *w, CompiledAddr addr, uint8_t inp);
-void fstStateCompileForOneTrans(FstCountingWriter *w, CompiledAddr addr, FstTransition *trn);
-void fstStateCompileForAnyTrans(FstCountingWriter *w, CompiledAddr addr, FstBuilderNode *node);
+void fstStateCompileForOneTransNext(FstCountingWriter* w, CompiledAddr addr, uint8_t inp);
+void fstStateCompileForOneTrans(FstCountingWriter* w, CompiledAddr addr, FstTransition* trn);
+void fstStateCompileForAnyTrans(FstCountingWriter* w, CompiledAddr addr, FstBuilderNode* node);
 
 // set_comm_input
-void fstStateSetCommInput(FstState *state, uint8_t inp);
+void fstStateSetCommInput(FstState* state, uint8_t inp);
 
 // comm_input
-uint8_t fstStateCommInput(FstState *state, bool *null);
+uint8_t fstStateCommInput(FstState* state, bool* null);
 
 // input_len
 
-uint64_t fstStateInputLen(FstState *state);
+uint64_t fstStateInputLen(FstState* state);
 
 // end_addr
-uint64_t fstStateEndAddrForOneTransNext(FstState *state, FstSlice *data);
-uint64_t fstStateEndAddrForOneTrans(FstState *state, FstSlice *data, PackSizes sizes);
-uint64_t fstStateEndAddrForAnyTrans(
-    FstState *state, uint64_t version, FstSlice *date, PackSizes sizes, uint64_t nTrans);
+uint64_t fstStateEndAddrForOneTransNext(FstState* state, FstSlice* data);
+uint64_t fstStateEndAddrForOneTrans(FstState* state, FstSlice* data, PackSizes sizes);
+uint64_t fstStateEndAddrForAnyTrans(FstState* state, uint64_t version, FstSlice* date, PackSizes sizes, uint64_t nTrans);
 // input
-uint8_t fstStateInput(FstState *state, FstNode *node);
-uint8_t fstStateInputForAnyTrans(FstState *state, FstNode *node, uint64_t i);
+uint8_t fstStateInput(FstState* state, FstNode* node);
+uint8_t fstStateInputForAnyTrans(FstState* state, FstNode* node, uint64_t i);
 
 // trans_addr
-CompiledAddr fstStateTransAddr(FstState *state, FstNode *node);
-CompiledAddr fstStateTransAddrForAnyTrans(FstState *state, FstNode *node, uint64_t i);
+CompiledAddr fstStateTransAddr(FstState* state, FstNode* node);
+CompiledAddr fstStateTransAddrForAnyTrans(FstState* state, FstNode* node, uint64_t i);
 
 // sizes
-PackSizes fstStateSizes(FstState *state, FstSlice *data);
+PackSizes fstStateSizes(FstState* state, FstSlice* data);
 // Output
-Output fstStateOutput(FstState *state, FstNode *node);
-Output fstStateOutputForAnyTrans(FstState *state, FstNode *node, uint64_t i);
+Output fstStateOutput(FstState* state, FstNode* node);
+Output fstStateOutputForAnyTrans(FstState* state, FstNode* node, uint64_t i);
 
 // anyTrans specify function
 
-void fstStateSetFinalState(FstState *state, bool yes);
-bool fstStateIsFinalState(FstState *state);
-void fstStateSetStateNtrans(FstState *state, uint8_t n);
+void fstStateSetFinalState(FstState* state, bool yes);
+bool fstStateIsFinalState(FstState* state);
+void fstStateSetStateNtrans(FstState* state, uint8_t n);
 // state_ntrans
-uint8_t  fstStateStateNtrans(FstState *state, bool *null);
-uint64_t fstStateTotalTransSize(FstState *state, uint64_t version, PackSizes size, uint64_t nTrans);
-uint64_t fstStateTransIndexSize(FstState *state, uint64_t version, uint64_t nTrans);
-uint64_t fstStateNtransLen(FstState *state);
-uint64_t fstStateNtrans(FstState *state, FstSlice *slice);
-Output   fstStateFinalOutput(FstState *state, uint64_t version, FstSlice *date, PackSizes sizes, uint64_t nTrans);
-uint64_t fstStateFindInput(FstState *state, FstNode *node, uint8_t b, bool *null);
+uint8_t  fstStateStateNtrans(FstState* state, bool* null);
+uint64_t fstStateTotalTransSize(FstState* state, uint64_t version, PackSizes size, uint64_t nTrans);
+uint64_t fstStateTransIndexSize(FstState* state, uint64_t version, uint64_t nTrans);
+uint64_t fstStateNtransLen(FstState* state);
+uint64_t fstStateNtrans(FstState* state, FstSlice* slice);
+Output   fstStateFinalOutput(FstState* state, uint64_t version, FstSlice* date, PackSizes sizes, uint64_t nTrans);
+uint64_t fstStateFindInput(FstState* state, FstNode* node, uint8_t b, bool* null);
 
 #define FST_STATE_ONE_TRNAS_NEXT(node) (node->state.state == OneTransNext)
 #define FST_STATE_ONE_TRNAS(node) (node->state.state == OneTrans)
@@ -187,13 +186,13 @@ typedef struct FstLastTransition {
  * TODO: simple function name
  */
 typedef struct FstBuilderNodeUnfinished {
-  FstBuilderNode *   node;
-  FstLastTransition *last;
+  FstBuilderNode*    node;
+  FstLastTransition* last;
 } FstBuilderNodeUnfinished;
 
-void fstBuilderNodeUnfinishedLastCompiled(FstBuilderNodeUnfinished *node, CompiledAddr addr);
+void fstBuilderNodeUnfinishedLastCompiled(FstBuilderNodeUnfinished* node, CompiledAddr addr);
 
-void fstBuilderNodeUnfinishedAddOutputPrefix(FstBuilderNodeUnfinished *node, Output out);
+void fstBuilderNodeUnfinishedAddOutputPrefix(FstBuilderNodeUnfinished* node, Output out);
 
 /*
  * FstNode and helper function
@@ -224,18 +223,18 @@ typedef struct FstNode {
 // Return the address of this node.
 #define FST_NODE_ADDR(node) node->start
 
-FstNode *fstNodeCreate(int64_t version, CompiledAddr addr, FstSlice *data);
-void     fstNodeDestroy(FstNode *fstNode);
+FstNode* fstNodeCreate(int64_t version, CompiledAddr addr, FstSlice* data);
+void     fstNodeDestroy(FstNode* fstNode);
 
-FstTransitions  fstNodeTransitionIter(FstNode *node);
-FstTransitions *fstNodeTransitions(FstNode *node);
-bool            fstNodeGetTransitionAt(FstNode *node, uint64_t i, FstTransition *res);
-bool            fstNodeGetTransitionAddrAt(FstNode *node, uint64_t i, CompiledAddr *res);
-bool            fstNodeFindInput(FstNode *node, uint8_t b, uint64_t *res);
+FstTransitions  fstNodeTransitionIter(FstNode* node);
+FstTransitions* fstNodeTransitions(FstNode* node);
+bool            fstNodeGetTransitionAt(FstNode* node, uint64_t i, FstTransition* res);
+bool            fstNodeGetTransitionAddrAt(FstNode* node, uint64_t i, CompiledAddr* res);
+bool            fstNodeFindInput(FstNode* node, uint8_t b, uint64_t* res);
 
-bool fstNodeCompile(FstNode *node, void *w, CompiledAddr lastAddr, CompiledAddr addr, FstBuilderNode *builderNode);
+bool fstNodeCompile(FstNode* node, void* w, CompiledAddr lastAddr, CompiledAddr addr, FstBuilderNode* builderNode);
 
-FstSlice fstNodeAsSlice(FstNode *node);
+FstSlice fstNodeAsSlice(FstNode* node);
 
 // ops
 
@@ -244,8 +243,8 @@ typedef struct FstIndexedValue {
   uint64_t value;
 } FstIndexedValue;
 
-FstLastTransition *fstLastTransitionCreate(uint8_t inp, Output out);
-void               fstLastTransitionDestroy(FstLastTransition *trn);
+FstLastTransition* fstLastTransitionCreate(uint8_t inp, Output out);
+void               fstLastTransitionDestroy(FstLastTransition* trn);
 
 typedef struct FstMeta {
   uint64_t     version;
@@ -256,75 +255,74 @@ typedef struct FstMeta {
 } FstMeta;
 
 typedef struct Fst {
-  FstMeta * meta;
-  FstSlice *data;  //
-  FstNode * root;  //
+  FstMeta*  meta;
+  FstSlice* data;  //
+  FstNode*  root;  //
 } Fst;
 
 // refactor simple function
 
-Fst *fstCreate(FstSlice *data);
-void fstDestroy(Fst *fst);
+Fst* fstCreate(FstSlice* data);
+void fstDestroy(Fst* fst);
 
-bool              fstGet(Fst *fst, FstSlice *b, Output *out);
-FstNode *         fstGetNode(Fst *fst, CompiledAddr);
-FstNode *         fstGetRoot(Fst *fst);
-FstType           fstGetType(Fst *fst);
-CompiledAddr      fstGetRootAddr(Fst *fst);
-Output            fstEmptyFinalOutput(Fst *fst, bool *null);
-FstStreamBuilder *fstSearch(Fst *fst, AutomationCtx *ctx);
+bool              fstGet(Fst* fst, FstSlice* b, Output* out);
+FstNode*          fstGetNode(Fst* fst, CompiledAddr);
+FstNode*          fstGetRoot(Fst* fst);
+FstType           fstGetType(Fst* fst);
+CompiledAddr      fstGetRootAddr(Fst* fst);
+Output            fstEmptyFinalOutput(Fst* fst, bool* null);
+FstStreamBuilder* fstSearch(Fst* fst, AutomationCtx* ctx);
 
-FstStreamWithStateBuilder *fstSearchWithState(Fst *fst, AutomationCtx *ctx);
+FstStreamWithStateBuilder* fstSearchWithState(Fst* fst, AutomationCtx* ctx);
 // into stream to expand later
-StreamWithState *streamBuilderIntoStream(FstStreamBuilder *sb);
+StreamWithState* streamBuilderIntoStream(FstStreamBuilder* sb);
 
-bool fstVerify(Fst *fst);
+bool fstVerify(Fst* fst);
 
 // refactor this function
-bool fstBuilderNodeCompileTo(FstBuilderNode *b, FstCountingWriter *wrt, CompiledAddr lastAddr, CompiledAddr startAddr);
+bool fstBuilderNodeCompileTo(FstBuilderNode* b, FstCountingWriter* wrt, CompiledAddr lastAddr, CompiledAddr startAddr);
 
 typedef struct StreamState {
-  FstNode * node;
+  FstNode*  node;
   uint64_t  trans;
   FstOutput out;
-  void *    autState;
+  void*     autState;
 } StreamState;
 
-void streamStateDestroy(void *s);
+void streamStateDestroy(void* s);
 
 typedef struct StreamWithState {
-  Fst *             fst;
-  AutomationCtx *   aut;
-  SArray *          inp;
+  Fst*              fst;
+  AutomationCtx*    aut;
+  SArray*           inp;
   FstOutput         emptyOutput;
-  SArray *          stack;  // <StreamState>
-  FstBoundWithData *endAt;
+  SArray*           stack;  // <StreamState>
+  FstBoundWithData* endAt;
 } StreamWithState;
 
 typedef struct StreamWithStateResult {
   FstSlice  data;
   FstOutput out;
-  void *    state;
+  void*     state;
 } StreamWithStateResult;
 
-StreamWithStateResult *swsResultCreate(FstSlice *data, FstOutput fOut, void *state);
-void                   swsResultDestroy(StreamWithStateResult *result);
+StreamWithStateResult* swsResultCreate(FstSlice* data, FstOutput fOut, void* state);
+void                   swsResultDestroy(StreamWithStateResult* result);
 
-typedef void *(*StreamCallback)(void *);
-StreamWithState *streamWithStateCreate(
-    Fst *fst, AutomationCtx *automation, FstBoundWithData *min, FstBoundWithData *max);
+typedef void* (*StreamCallback)(void*);
+StreamWithState* streamWithStateCreate(Fst* fst, AutomationCtx* automation, FstBoundWithData* min, FstBoundWithData* max);
 
-void streamWithStateDestroy(StreamWithState *sws);
+void streamWithStateDestroy(StreamWithState* sws);
 
-bool streamWithStateSeekMin(StreamWithState *sws, FstBoundWithData *min);
+bool streamWithStateSeekMin(StreamWithState* sws, FstBoundWithData* min);
 
-StreamWithStateResult *streamWithStateNextWith(StreamWithState *sws, StreamCallback callback);
+StreamWithStateResult* streamWithStateNextWith(StreamWithState* sws, StreamCallback callback);
 
-FstStreamBuilder *fstStreamBuilderCreate(Fst *fst, AutomationCtx *aut);
+FstStreamBuilder* fstStreamBuilderCreate(Fst* fst, AutomationCtx* aut);
 // set up bound range
 // refator, simple code by marco
 
-FstStreamBuilder *fstStreamBuilderRange(FstStreamBuilder *b, FstSlice *val, RangeType type);
+FstStreamBuilder* fstStreamBuilderRange(FstStreamBuilder* b, FstSlice* val, RangeType type);
 
 #ifdef __cplusplus
 }
diff --git a/source/libs/index/inc/index_fst_automation.h b/source/libs/index/inc/index_fst_automation.h
index 4e5309bf07..c7269eda0f 100644
--- a/source/libs/index/inc/index_fst_automation.h
+++ b/source/libs/index/inc/index_fst_automation.h
@@ -26,18 +26,18 @@ typedef struct AutomationCtx AutomationCtx;
 typedef enum AutomationType { AUTOMATION_PREFIX, AUTMMATION_MATCH } AutomationType;
 
 typedef struct StartWith {
-  AutomationCtx *autoSelf;
+  AutomationCtx* autoSelf;
 } StartWith;
 
 typedef struct Complement {
-  AutomationCtx *autoSelf;
+  AutomationCtx* autoSelf;
 } Complement;
 
 // automation
 typedef struct AutomationCtx {
   AutomationType type;
-  void *         stdata;
-  char *         data;
+  void*          stdata;
+  char*          data;
 } AutomationCtx;
 
 typedef enum ValueType { FST_INT, FST_CHAR, FST_ARRAY } ValueType;
@@ -48,27 +48,27 @@ typedef struct StartWithStateValue {
   ValueType          type;
   union {
     int     val;
-    char *  ptr;
-    SArray *arr;
+    char*   ptr;
+    SArray* arr;
     // add more type
   };
 } StartWithStateValue;
 
-StartWithStateValue *startWithStateValueCreate(StartWithStateKind kind, ValueType ty, void *val);
-StartWithStateValue *startWithStateValueDump(StartWithStateValue *sv);
-void                 startWithStateValueDestroy(void *sv);
+StartWithStateValue* startWithStateValueCreate(StartWithStateKind kind, ValueType ty, void* val);
+StartWithStateValue* startWithStateValueDump(StartWithStateValue* sv);
+void                 startWithStateValueDestroy(void* sv);
 
 typedef struct AutomationFunc {
-  void *(*start)(AutomationCtx *ctx);
-  bool (*isMatch)(AutomationCtx *ctx, void *);
-  bool (*canMatch)(AutomationCtx *ctx, void *data);
-  bool (*willAlwaysMatch)(AutomationCtx *ctx, void *state);
-  void *(*accept)(AutomationCtx *ctx, void *state, uint8_t byte);
-  void *(*acceptEof)(AutomationCtx *ct, void *state);
+  void* (*start)(AutomationCtx* ctx);
+  bool (*isMatch)(AutomationCtx* ctx, void*);
+  bool (*canMatch)(AutomationCtx* ctx, void* data);
+  bool (*willAlwaysMatch)(AutomationCtx* ctx, void* state);
+  void* (*accept)(AutomationCtx* ctx, void* state, uint8_t byte);
+  void* (*acceptEof)(AutomationCtx* ct, void* state);
 } AutomationFunc;
 
-AutomationCtx *automCtxCreate(void *data, AutomationType atype);
-void           automCtxDestroy(AutomationCtx *ctx);
+AutomationCtx* automCtxCreate(void* data, AutomationType atype);
+void           automCtxDestroy(AutomationCtx* ctx);
 
 extern AutomationFunc automFuncs[];
 #ifdef __cplusplus
diff --git a/source/libs/index/inc/index_fst_counting_writer.h b/source/libs/index/inc/index_fst_counting_writer.h
index b8a0384fb8..db1f063af3 100644
--- a/source/libs/index/inc/index_fst_counting_writer.h
+++ b/source/libs/index/inc/index_fst_counting_writer.h
@@ -28,9 +28,9 @@ static char tmpFile[] = "./index";
 typedef enum WriterType { TMemory, TFile } WriterType;
 
 typedef struct WriterCtx {
-  int (*write)(struct WriterCtx *ctx, uint8_t *buf, int len);
-  int (*read)(struct WriterCtx *ctx, uint8_t *buf, int len);
-  int (*flush)(struct WriterCtx *ctx);
+  int (*write)(struct WriterCtx* ctx, uint8_t* buf, int len);
+  int (*read)(struct WriterCtx* ctx, uint8_t* buf, int len);
+  int (*flush)(struct WriterCtx* ctx);
   WriterType type;
   union {
     struct {
@@ -39,41 +39,41 @@ typedef struct WriterCtx {
     } file;
     struct {
       int32_t capa;
-      char *  buf;
+      char*   buf;
     } mem;
   };
   int32_t offset;
   int32_t limit;
 } WriterCtx;
 
-static int writeCtxDoWrite(WriterCtx *ctx, uint8_t *buf, int len);
-static int writeCtxDoRead(WriterCtx *ctx, uint8_t *buf, int len);
-static int writeCtxDoFlush(WriterCtx *ctx);
+static int writeCtxDoWrite(WriterCtx* ctx, uint8_t* buf, int len);
+static int writeCtxDoRead(WriterCtx* ctx, uint8_t* buf, int len);
+static int writeCtxDoFlush(WriterCtx* ctx);
 
-WriterCtx *writerCtxCreate(WriterType type, const char *path, bool readOnly, int32_t capacity);
-void       writerCtxDestroy(WriterCtx *w);
+WriterCtx* writerCtxCreate(WriterType type, const char* path, bool readOnly, int32_t capacity);
+void       writerCtxDestroy(WriterCtx* w);
 
 typedef uint32_t CheckSummer;
 
 typedef struct FstCountingWriter {
-  void *      wrt;  // wrap any writer that counts and checksum bytes written
+  void*       wrt;  // wrap any writer that counts and checksum bytes written
   uint64_t    count;
   CheckSummer summer;
 } FstCountingWriter;
 
-int fstCountingWriterWrite(FstCountingWriter *write, uint8_t *buf, uint32_t len);
+int fstCountingWriterWrite(FstCountingWriter* write, uint8_t* buf, uint32_t len);
 
-int fstCountingWriterRead(FstCountingWriter *write, uint8_t *buf, uint32_t len);
+int fstCountingWriterRead(FstCountingWriter* write, uint8_t* buf, uint32_t len);
 
-int fstCountingWriterFlush(FstCountingWriter *write);
+int fstCountingWriterFlush(FstCountingWriter* write);
 
-uint32_t fstCountingWriterMaskedCheckSum(FstCountingWriter *write);
+uint32_t fstCountingWriterMaskedCheckSum(FstCountingWriter* write);
 
-FstCountingWriter *fstCountingWriterCreate(void *wtr);
-void               fstCountingWriterDestroy(FstCountingWriter *w);
+FstCountingWriter* fstCountingWriterCreate(void* wtr);
+void               fstCountingWriterDestroy(FstCountingWriter* w);
 
-void    fstCountingWriterPackUintIn(FstCountingWriter *writer, uint64_t n, uint8_t nBytes);
-uint8_t fstCountingWriterPackUint(FstCountingWriter *writer, uint64_t n);
+void    fstCountingWriterPackUintIn(FstCountingWriter* writer, uint64_t n, uint8_t nBytes);
+uint8_t fstCountingWriterPackUint(FstCountingWriter* writer, uint64_t n);
 
 #define FST_WRITER_COUNT(writer) (writer->count)
 #define FST_WRITER_INTER_WRITER(writer) (writer->wtr)
diff --git a/source/libs/index/inc/index_fst_node.h b/source/libs/index/inc/index_fst_node.h
index a2041fad40..32de7ea621 100644
--- a/source/libs/index/inc/index_fst_node.h
+++ b/source/libs/index/inc/index_fst_node.h
@@ -36,20 +36,20 @@ typedef struct FstTransition {
 typedef struct FstBuilderNode {
   bool    isFinal;
   Output  finalOutput;
-  SArray *trans;  // <FstTransition>
+  SArray* trans;  // <FstTransition>
 } FstBuilderNode;
 
-FstBuilderNode *fstBuilderNodeDefault();
+FstBuilderNode* fstBuilderNodeDefault();
 
-FstBuilderNode *fstBuilderNodeClone(FstBuilderNode *src);
+FstBuilderNode* fstBuilderNodeClone(FstBuilderNode* src);
 
-void fstBuilderNodeCloneFrom(FstBuilderNode *dst, FstBuilderNode *src);
+void fstBuilderNodeCloneFrom(FstBuilderNode* dst, FstBuilderNode* src);
 
 // bool fstBuilderNodeCompileTo(FstBuilderNode *b, FstCountingWriter *wrt,
 // CompiledAddr lastAddr, CompiledAddr startAddr);
-bool fstBuilderNodeEqual(FstBuilderNode *n1, FstBuilderNode *n2);
+bool fstBuilderNodeEqual(FstBuilderNode* n1, FstBuilderNode* n2);
 
-void fstBuilderNodeDestroy(FstBuilderNode *node);
+void fstBuilderNodeDestroy(FstBuilderNode* node);
 
 #ifdef __cplusplus
 }
diff --git a/source/libs/index/inc/index_fst_registry.h b/source/libs/index/inc/index_fst_registry.h
index 948bd41781..f94a21d8dd 100644
--- a/source/libs/index/inc/index_fst_registry.h
+++ b/source/libs/index/inc/index_fst_registry.h
@@ -25,12 +25,14 @@ extern "C" {
 
 typedef struct FstRegistryCell {
   CompiledAddr    addr;
-  FstBuilderNode *node;
+  FstBuilderNode* node;
 } FstRegistryCell;
 
 #define FST_REGISTRY_CELL_IS_EMPTY(cell) (cell->addr == NONE_ADDRESS)
 #define FST_REGISTRY_CELL_INSERT(cell, tAddr) \
-  do { cell->addr = tAddr; } while (0)
+  do {                                        \
+    cell->addr = tAddr;                       \
+  } while (0)
 
 // typedef struct FstRegistryCache {
 //  SArray *cells;
@@ -43,22 +45,22 @@ typedef enum { FOUND, NOTFOUND, REJECTED } FstRegistryEntryState;
 typedef struct FstRegistryEntry {
   FstRegistryEntryState state;
   CompiledAddr          addr;
-  FstRegistryCell *     cell;
+  FstRegistryCell*      cell;
 } FstRegistryEntry;
 
 // Registry relation function
 typedef struct FstRegistry {
-  SArray * table;      //<FstRegistryCell>
+  SArray*  table;      //<FstRegistryCell>
   uint64_t tableSize;  // num of rows
   uint64_t mruSize;    // num of columns
 } FstRegistry;
 
 //
-FstRegistry *fstRegistryCreate(uint64_t tableSize, uint64_t mruSize);
-void         fstRegistryDestroy(FstRegistry *registry);
+FstRegistry* fstRegistryCreate(uint64_t tableSize, uint64_t mruSize);
+void         fstRegistryDestroy(FstRegistry* registry);
 
-FstRegistryEntry *fstRegistryGetEntry(FstRegistry *registry, FstBuilderNode *bNode);
-void              fstRegistryEntryDestroy(FstRegistryEntry *entry);
+FstRegistryEntry* fstRegistryGetEntry(FstRegistry* registry, FstBuilderNode* bNode);
+void              fstRegistryEntryDestroy(FstRegistryEntry* entry);
 
 #ifdef __cplusplus
 }
diff --git a/source/libs/index/inc/index_fst_util.h b/source/libs/index/inc/index_fst_util.h
index c41977e637..71a378584d 100644
--- a/source/libs/index/inc/index_fst_util.h
+++ b/source/libs/index/inc/index_fst_util.h
@@ -69,29 +69,29 @@ extern const uint64_t TRANS_INDEX_THRESHOLD;
 // uint8_t commonIdx(uint8_t v, uint8_t max);
 
 uint8_t      packSize(uint64_t n);
-uint64_t     unpackUint64(uint8_t *ch, uint8_t sz);
+uint64_t     unpackUint64(uint8_t* ch, uint8_t sz);
 uint8_t      packDeltaSize(CompiledAddr nodeAddr, CompiledAddr transAddr);
-CompiledAddr unpackDelta(char *data, uint64_t len, uint64_t nodeAddr);
+CompiledAddr unpackDelta(char* data, uint64_t len, uint64_t nodeAddr);
 
 typedef struct FstString {
-  uint8_t *data;
+  uint8_t* data;
   uint32_t len;
   int32_t  ref;
 } FstString;
 
 typedef struct FstSlice {
-  FstString *str;
+  FstString* str;
   int32_t    start;
   int32_t    end;
 } FstSlice;
 
-FstSlice fstSliceCreate(uint8_t *data, uint64_t len);
-FstSlice fstSliceCopy(FstSlice *s, int32_t start, int32_t end);
-FstSlice fstSliceDeepCopy(FstSlice *s, int32_t start, int32_t end);
-bool     fstSliceIsEmpty(FstSlice *s);
-int      fstSliceCompare(FstSlice *s1, FstSlice *s2);
-void     fstSliceDestroy(FstSlice *s);
-uint8_t *fstSliceData(FstSlice *s, int32_t *sz);
+FstSlice fstSliceCreate(uint8_t* data, uint64_t len);
+FstSlice fstSliceCopy(FstSlice* s, int32_t start, int32_t end);
+FstSlice fstSliceDeepCopy(FstSlice* s, int32_t start, int32_t end);
+bool     fstSliceIsEmpty(FstSlice* s);
+int      fstSliceCompare(FstSlice* s1, FstSlice* s2);
+void     fstSliceDestroy(FstSlice* s);
+uint8_t* fstSliceData(FstSlice* s, int32_t* sz);
 
 #define FST_SLICE_LEN(s) (s->end - s->start + 1)
 
diff --git a/source/libs/index/inc/index_tfile.h b/source/libs/index/inc/index_tfile.h
index 5732e49ba0..613c6fbb7c 100644
--- a/source/libs/index/inc/index_tfile.h
+++ b/source/libs/index/inc/index_tfile.h
@@ -37,77 +37,77 @@ typedef struct TFileHeader {
   uint8_t  colType;
 } TFileHeader;
 
-#define TFILE_HEADER_SIZE (sizeof(TFILE_HEADER_SIZE) + sizeof(uint32_t));
+#define TFILE_HEADER_SIZE (sizeof(TFileHeader) + sizeof(uint32_t))
 #define TFILE_HADER_PRE_SIZE (sizeof(uint64_t) + sizeof(int32_t) + sizeof(int32_t))
 
 typedef struct TFileCacheKey {
   uint64_t suid;
   uint8_t  colType;
   int32_t  version;
-  char *   colName;
+  char*    colName;
   int32_t  nColName;
 } TFileCacheKey;
 
 // table cache
 // refactor to LRU cache later
 typedef struct TFileCache {
-  SHashObj *tableCache;
+  SHashObj* tableCache;
   int16_t   capacity;
   // add more param
 } TFileCache;
 
 typedef struct TFileWriter {
-  FstBuilder *fb;
-  WriterCtx * ctx;
+  FstBuilder* fb;
+  WriterCtx*  ctx;
   TFileHeader header;
 } TFileWriter;
 
 typedef struct TFileReader {
   T_REF_DECLARE()
-  Fst *       fst;
-  WriterCtx * ctx;
+  Fst*        fst;
+  WriterCtx*  ctx;
   TFileHeader header;
 } TFileReader;
 
 typedef struct IndexTFile {
-  char *       path;
-  TFileCache * cache;
-  TFileWriter *tw;
+  char*        path;
+  TFileCache*  cache;
+  TFileWriter* tw;
 } IndexTFile;
 
 typedef struct TFileWriterOpt {
   uint64_t suid;
   int8_t   colType;
-  char *   colName;
+  char*    colName;
   int32_t  nColName;
   int32_t  version;
 } TFileWriterOpt;
 
 typedef struct TFileReaderOpt {
   uint64_t suid;
-  char *   colName;
+  char*    colName;
   int32_t  nColName;
 } TFileReaderOpt;
 
 // tfile cache, manage tindex reader
-TFileCache * tfileCacheCreate(const char *path);
-void         tfileCacheDestroy(TFileCache *tcache);
-TFileReader *tfileCacheGet(TFileCache *tcache, TFileCacheKey *key);
-void         tfileCachePut(TFileCache *tcache, TFileCacheKey *key, TFileReader *reader);
+TFileCache*  tfileCacheCreate(const char* path);
+void         tfileCacheDestroy(TFileCache* tcache);
+TFileReader* tfileCacheGet(TFileCache* tcache, TFileCacheKey* key);
+void         tfileCachePut(TFileCache* tcache, TFileCacheKey* key, TFileReader* reader);
 
-TFileReader *tfileReaderCreate(WriterCtx *ctx);
-void         tfileReaderDestroy(TFileReader *reader);
-int          tfileReaderSearch(TFileReader *reader, SIndexTermQuery *query, SArray *result);
+TFileReader* tfileReaderCreate(WriterCtx* ctx);
+void         tfileReaderDestroy(TFileReader* reader);
+int          tfileReaderSearch(TFileReader* reader, SIndexTermQuery* query, SArray* result);
 
-TFileWriter *tfileWriterCreate(WriterCtx *ctx, TFileHeader *header);
-void         tfileWriterDestroy(TFileWriter *tw);
-int          tfileWriterPut(TFileWriter *tw, const char *key, int32_t nKey, const char *val, int32_t nVal);
-int          tfileWriterFinish(TFileWriter *tw);
+TFileWriter* tfileWriterCreate(WriterCtx* ctx, TFileHeader* header);
+void         tfileWriterDestroy(TFileWriter* tw);
+int          tfileWriterPut(TFileWriter* tw, const char* key, int32_t nKey, const char* val, int32_t nVal);
+int          tfileWriterFinish(TFileWriter* tw);
 
 //
-IndexTFile *indexTFileCreate(const char *path);
-int         indexTFilePut(void *tfile, SIndexTerm *term, uint64_t uid);
-int         indexTFileSearch(void *tfile, SIndexTermQuery *query, SArray *result);
+IndexTFile* indexTFileCreate(const char* path);
+int         indexTFilePut(void* tfile, SIndexTerm* term, uint64_t uid);
+int         indexTFileSearch(void* tfile, SIndexTermQuery* query, SArray* result);
 
 #ifdef __cplusplus
 }
diff --git a/source/libs/index/inc/index_util.h b/source/libs/index/inc/index_util.h
index f708e71f57..21c5ca155b 100644
--- a/source/libs/index/inc/index_util.h
+++ b/source/libs/index/inc/index_util.h
@@ -19,29 +19,29 @@
 extern "C" {
 #endif
 
-#define SERIALIZE_MEM_TO_BUF(buf, key, mem)                     \
-  do {                                                          \
-    memcpy((void *)buf, (void *)(&key->mem), sizeof(key->mem)); \
-    buf += sizeof(key->mem);                                    \
+#define SERIALIZE_MEM_TO_BUF(buf, key, mem)                   \
+  do {                                                        \
+    memcpy((void*)buf, (void*)(&key->mem), sizeof(key->mem)); \
+    buf += sizeof(key->mem);                                  \
   } while (0)
 
 #define SERIALIZE_STR_MEM_TO_BUF(buf, key, mem, len) \
   do {                                               \
-    memcpy((void *)buf, (void *)key->mem, len);      \
+    memcpy((void*)buf, (void*)key->mem, len);        \
     buf += len;                                      \
   } while (0)
 
-#define SERIALIZE_VAR_TO_BUF(buf, var, type)    \
-  do {                                          \
-    type c = var;                               \
-    assert(sizeof(var) == sizeof(type));        \
-    memcpy((void *)buf, (void *)&c, sizeof(c)); \
-    buf += sizeof(c);                           \
+#define SERIALIZE_VAR_TO_BUF(buf, var, type)  \
+  do {                                        \
+    type c = var;                             \
+    assert(sizeof(var) == sizeof(type));      \
+    memcpy((void*)buf, (void*)&c, sizeof(c)); \
+    buf += sizeof(c);                         \
   } while (0)
 
 #define SERIALIZE_STR_VAR_TO_BUF(buf, var, len) \
   do {                                          \
-    memcpy((void *)buf, (void *)var, len);      \
+    memcpy((void*)buf, (void*)var, len);        \
     buf += len;                                 \
   } while (0)
 
diff --git a/source/libs/index/src/index.c b/source/libs/index/src/index.c
index e034b582ea..e88cecfd62 100644
--- a/source/libs/index/src/index.c
+++ b/source/libs/index/src/index.c
@@ -23,9 +23,9 @@
 #include "lucene++/Lucene_c.h"
 #endif
 
-static int uidCompare(const void *a, const void *b) {
-  uint64_t u1 = *(uint64_t *)a;
-  uint64_t u2 = *(uint64_t *)b;
+static int uidCompare(const void* a, const void* b) {
+  uint64_t u1 = *(uint64_t*)a;
+  uint64_t u2 = *(uint64_t*)b;
   if (u1 == u2) {
     return 0;
   } else {
@@ -40,24 +40,26 @@ typedef struct SIdxColInfo {
 static pthread_once_t isInit = PTHREAD_ONCE_INIT;
 static void           indexInit();
 
-static int indexTermSearch(SIndex *sIdx, SIndexTermQuery *term, SArray **result);
-static int indexMergeCacheIntoTindex(SIndex *sIdx);
+static int indexTermSearch(SIndex* sIdx, SIndexTermQuery* term, SArray** result);
+static int indexMergeCacheIntoTindex(SIndex* sIdx);
 
-static void indexInterResultsDestroy(SArray *results);
-static int  indexMergeFinalResults(SArray *interResults, EIndexOperatorType oType, SArray *finalResult);
+static void indexInterResultsDestroy(SArray* results);
+static int  indexMergeFinalResults(SArray* interResults, EIndexOperatorType oType, SArray* finalResult);
 
-int indexOpen(SIndexOpts *opts, const char *path, SIndex **index) {
+int indexOpen(SIndexOpts* opts, const char* path, SIndex** index) {
   pthread_once(&isInit, indexInit);
-  SIndex *sIdx = calloc(1, sizeof(SIndex));
-  if (sIdx == NULL) { return -1; }
+  SIndex* sIdx = calloc(1, sizeof(SIndex));
+  if (sIdx == NULL) {
+    return -1;
+  }
 
 #ifdef USE_LUCENE
-  index_t *index = index_open(path);
+  index_t* index = index_open(path);
   sIdx->index = index;
 #endif
 
 #ifdef USE_INVERTED_INDEX
-  sIdx->cache = (void *)indexCacheCreate();
+  sIdx->cache = (void*)indexCacheCreate();
   sIdx->tindex = NULL;
   sIdx->colObj = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
   sIdx->colId = 1;
@@ -72,7 +74,7 @@ int indexOpen(SIndexOpts *opts, const char *path, SIndex **index) {
   return -1;
 }
 
-void indexClose(SIndex *sIdx) {
+void indexClose(SIndex* sIdx) {
 #ifdef USE_LUCENE
   index_close(sIdex->index);
   sIdx->index = NULL;
@@ -87,16 +89,16 @@ void indexClose(SIndex *sIdx) {
   return;
 }
 
-int indexPut(SIndex *index, SIndexMultiTerm *fVals, uint64_t uid) {
+int indexPut(SIndex* index, SIndexMultiTerm* fVals, uint64_t uid) {
 #ifdef USE_LUCENE
-  index_document_t *doc = index_document_create();
+  index_document_t* doc = index_document_create();
 
   char buf[16] = {0};
   sprintf(buf, "%d", uid);
 
   for (int i = 0; i < taosArrayGetSize(fVals); i++) {
-    SIndexTerm *p = taosArrayGetP(fVals, i);
-    index_document_add(doc, (const char *)(p->key), p->nKey, (const char *)(p->val), p->nVal, 1);
+    SIndexTerm* p = taosArrayGetP(fVals, i);
+    index_document_add(doc, (const char*)(p->key), p->nKey, (const char*)(p->val), p->nVal, 1);
   }
   index_document_add(doc, NULL, 0, buf, strlen(buf), 0);
 
@@ -109,8 +111,8 @@ int indexPut(SIndex *index, SIndexMultiTerm *fVals, uint64_t uid) {
   // TODO(yihao): reduce the lock range
   pthread_mutex_lock(&index->mtx);
   for (int i = 0; i < taosArrayGetSize(fVals); i++) {
-    SIndexTerm * p = taosArrayGetP(fVals, i);
-    SIdxColInfo *fi = taosHashGet(index->colObj, p->colName, p->nColName);
+    SIndexTerm*  p = taosArrayGetP(fVals, i);
+    SIdxColInfo* fi = taosHashGet(index->colObj, p->colName, p->nColName);
     if (fi == NULL) {
       SIdxColInfo tfi = {.colId = index->colId};
       index->cVersion++;
@@ -123,30 +125,32 @@ int indexPut(SIndex *index, SIndexMultiTerm *fVals, uint64_t uid) {
   pthread_mutex_unlock(&index->mtx);
 
   for (int i = 0; i < taosArrayGetSize(fVals); i++) {
-    SIndexTerm * p = taosArrayGetP(fVals, i);
-    SIdxColInfo *fi = taosHashGet(index->colObj, p->colName, p->nColName);
+    SIndexTerm*  p = taosArrayGetP(fVals, i);
+    SIdxColInfo* fi = taosHashGet(index->colObj, p->colName, p->nColName);
     assert(fi != NULL);
     int32_t colId = fi->colId;
     int32_t version = index->cVersion;
     int     ret = indexCachePut(index->cache, p, colId, version, uid);
-    if (ret != 0) { return ret; }
+    if (ret != 0) {
+      return ret;
+    }
   }
 #endif
 
   return 0;
 }
-int indexSearch(SIndex *index, SIndexMultiTermQuery *multiQuerys, SArray *result) {
+int indexSearch(SIndex* index, SIndexMultiTermQuery* multiQuerys, SArray* result) {
 #ifdef USE_LUCENE
   EIndexOperatorType opera = multiQuerys->opera;
 
   int    nQuery = taosArrayGetSize(multiQuerys->query);
-  char **fields = malloc(sizeof(char *) * nQuery);
-  char **keys = malloc(sizeof(char *) * nQuery);
-  int *  types = malloc(sizeof(int) * nQuery);
+  char** fields = malloc(sizeof(char*) * nQuery);
+  char** keys = malloc(sizeof(char*) * nQuery);
+  int*   types = malloc(sizeof(int) * nQuery);
 
   for (int i = 0; i < nQuery; i++) {
-    SIndexTermQuery *p = taosArrayGet(multiQuerys->query, i);
-    SIndexTerm *     term = p->field_value;
+    SIndexTermQuery* p = taosArrayGet(multiQuerys->query, i);
+    SIndexTerm*      term = p->field_value;
 
     fields[i] = calloc(1, term->nKey + 1);
     keys[i] = calloc(1, term->nVal + 1);
@@ -155,11 +159,13 @@ int indexSearch(SIndex *index, SIndexMultiTermQuery *multiQuerys, SArray *result
     memcpy(keys[i], term->val, term->nVal);
     types[i] = (int)(p->type);
   }
-  int *tResult = NULL;
+  int* tResult = NULL;
   int  tsz = 0;
-  index_multi_search(index->index, (const char **)fields, (const char **)keys, types, nQuery, opera, &tResult, &tsz);
+  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]);
@@ -173,13 +179,13 @@ int indexSearch(SIndex *index, SIndexMultiTermQuery *multiQuerys, SArray *result
 #ifdef USE_INVERTED_INDEX
   EIndexOperatorType opera = multiQuerys->opera;  // relation of querys
 
-  SArray *interResults = taosArrayInit(4, POINTER_BYTES);
+  SArray* interResults = taosArrayInit(4, POINTER_BYTES);
   int     nQuery = taosArrayGetSize(multiQuerys->query);
   for (size_t i = 0; i < nQuery; i++) {
-    SIndexTermQuery *qTerm = taosArrayGet(multiQuerys->query, i);
-    SArray *         tResult = NULL;
+    SIndexTermQuery* qTerm = taosArrayGet(multiQuerys->query, i);
+    SArray*          tResult = NULL;
     indexTermSearch(index, qTerm, &tResult);
-    taosArrayPush(interResults, (void *)&tResult);
+    taosArrayPush(interResults, (void*)&tResult);
   }
   indexMergeFinalResults(interResults, opera, result);
   indexInterResultsDestroy(interResults);
@@ -188,24 +194,24 @@ int indexSearch(SIndex *index, SIndexMultiTermQuery *multiQuerys, SArray *result
   return 1;
 }
 
-int indexDelete(SIndex *index, SIndexMultiTermQuery *query) {
+int indexDelete(SIndex* index, SIndexMultiTermQuery* query) {
 #ifdef USE_INVERTED_INDEX
 #endif
 
   return 1;
 }
-int indexRebuild(SIndex *index, SIndexOpts *opts){
+int indexRebuild(SIndex* index, SIndexOpts* opts){
 #ifdef USE_INVERTED_INDEX
 #endif
 
 }
 
-SIndexOpts *indexOptsCreate() {
+SIndexOpts* indexOptsCreate() {
 #ifdef USE_LUCENE
 #endif
   return NULL;
 }
-void indexOptsDestroy(SIndexOpts *opts){
+void indexOptsDestroy(SIndexOpts* opts){
 #ifdef USE_LUCENE
 #endif
 } /*
@@ -213,60 +219,71 @@ void indexOptsDestroy(SIndexOpts *opts){
    *
    */
 
-SIndexMultiTermQuery *indexMultiTermQueryCreate(EIndexOperatorType opera) {
-  SIndexMultiTermQuery *p = (SIndexMultiTermQuery *)malloc(sizeof(SIndexMultiTermQuery));
-  if (p == NULL) { return NULL; }
+SIndexMultiTermQuery* indexMultiTermQueryCreate(EIndexOperatorType opera) {
+  SIndexMultiTermQuery* p = (SIndexMultiTermQuery*)malloc(sizeof(SIndexMultiTermQuery));
+  if (p == NULL) {
+    return NULL;
+  }
   p->opera = opera;
   p->query = taosArrayInit(4, sizeof(SIndexTermQuery));
   return p;
 }
-void indexMultiTermQueryDestroy(SIndexMultiTermQuery *pQuery) {
+void indexMultiTermQueryDestroy(SIndexMultiTermQuery* pQuery) {
   for (int i = 0; i < taosArrayGetSize(pQuery->query); i++) {
-    SIndexTermQuery *p = (SIndexTermQuery *)taosArrayGet(pQuery->query, i);
+    SIndexTermQuery* p = (SIndexTermQuery*)taosArrayGet(pQuery->query, i);
     indexTermDestroy(p->term);
   }
   taosArrayDestroy(pQuery->query);
   free(pQuery);
 };
-int indexMultiTermQueryAdd(SIndexMultiTermQuery *pQuery, SIndexTerm *term, EIndexQueryType qType) {
+int indexMultiTermQueryAdd(SIndexMultiTermQuery* pQuery, SIndexTerm* term, EIndexQueryType qType) {
   SIndexTermQuery q = {.qType = qType, .term = term};
   taosArrayPush(pQuery->query, &q);
   return 0;
 }
 
-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; }
+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;
+  }
 
   t->suid = suid;
   t->operType = oper;
   t->colType = colType;
 
-  t->colName = (char *)calloc(1, nColName + 1);
+  t->colName = (char*)calloc(1, nColName + 1);
   memcpy(t->colName, colName, nColName);
   t->nColName = nColName;
 
-  t->colVal = (char *)calloc(1, nColVal + 1);
+  t->colVal = (char*)calloc(1, nColVal + 1);
   memcpy(t->colVal, colVal, nColVal);
   t->nColVal = nColVal;
   return t;
 }
-void indexTermDestroy(SIndexTerm *p) {
+void indexTermDestroy(SIndexTerm* p) {
   free(p->colName);
   free(p->colVal);
   free(p);
 }
 
-SIndexMultiTerm *indexMultiTermCreate() { return taosArrayInit(4, sizeof(SIndexTerm *)); }
+SIndexMultiTerm* indexMultiTermCreate() {
+  return taosArrayInit(4, sizeof(SIndexTerm*));
+}
 
-int indexMultiTermAdd(SIndexMultiTerm *terms, SIndexTerm *term) {
+int indexMultiTermAdd(SIndexMultiTerm* terms, SIndexTerm* term) {
   taosArrayPush(terms, &term);
   return 0;
 }
-void indexMultiTermDestroy(SIndexMultiTerm *terms) {
+void indexMultiTermDestroy(SIndexMultiTerm* terms) {
   for (int32_t i = 0; i < taosArrayGetSize(terms); i++) {
-    SIndexTerm *p = taosArrayGetP(terms, i);
+    SIndexTerm* p = taosArrayGetP(terms, i);
     indexTermDestroy(p);
   }
   taosArrayDestroy(terms);
@@ -275,13 +292,13 @@ void indexMultiTermDestroy(SIndexMultiTerm *terms) {
 void indexInit() {
   // do nothing
 }
-static int indexTermSearch(SIndex *sIdx, SIndexTermQuery *query, SArray **result) {
+static int indexTermSearch(SIndex* sIdx, SIndexTermQuery* query, SArray** result) {
   int32_t      version = -1;
   int16_t      colId = -1;
-  SIdxColInfo *colInfo = NULL;
+  SIdxColInfo* colInfo = NULL;
 
-  SIndexTerm *term = query->term;
-  const char *colName = term->colName;
+  SIndexTerm* term = query->term;
+  const char* colName = term->colName;
   int32_t     nColName = term->nColName;
 
   pthread_mutex_lock(&sIdx->mtx);
@@ -314,19 +331,21 @@ static int indexTermSearch(SIndex *sIdx, SIndexTermQuery *query, SArray **result
   }
   return 0;
 }
-static void indexInterResultsDestroy(SArray *results) {
-  if (results == NULL) { return; }
+static void indexInterResultsDestroy(SArray* results) {
+  if (results == NULL) {
+    return;
+  }
 
   size_t sz = taosArrayGetSize(results);
   for (size_t i = 0; i < sz; i++) {
-    SArray *p = taosArrayGetP(results, i);
+    SArray* p = taosArrayGetP(results, i);
     taosArrayDestroy(p);
   }
   taosArrayDestroy(results);
 }
-static int indexMergeFinalResults(SArray *interResults, EIndexOperatorType oType, SArray *fResults) {
+static int indexMergeFinalResults(SArray* interResults, EIndexOperatorType oType, SArray* fResults) {
   // refactor, merge interResults into fResults by oType
-  SArray *first = taosArrayGetP(interResults, 0);
+  SArray* first = taosArrayGetP(interResults, 0);
   taosArraySort(first, uidCompare);
   taosArrayRemoveDuplicate(first, uidCompare, NULL);
 
@@ -344,8 +363,10 @@ static int indexMergeFinalResults(SArray *interResults, EIndexOperatorType oType
   }
   return 0;
 }
-static int indexMergeCacheIntoTindex(SIndex *sIdx) {
-  if (sIdx == NULL) { return -1; }
+static int indexMergeCacheIntoTindex(SIndex* sIdx) {
+  if (sIdx == NULL) {
+    return -1;
+  }
   indexWarn("suid %" PRIu64 " merge cache into tindex", sIdx->suid);
   return 0;
 }
diff --git a/source/libs/index/src/index_cache.c b/source/libs/index/src/index_cache.c
index 52789bc642..6170642707 100644
--- a/source/libs/index/src/index_cache.c
+++ b/source/libs/index/src/index_cache.c
@@ -20,14 +20,15 @@
 #define MAX_INDEX_KEY_LEN 256  // test only, change later
 
 // ref index_cache.h:22
-#define CACHE_KEY_LEN(p)                                                                                          \
-  (sizeof(int32_t) + sizeof(uint16_t) + sizeof(p->colType) + sizeof(p->nColVal) + p->nColVal + sizeof(uint64_t) + \
-      sizeof(p->operType))
+#define CACHE_KEY_LEN(p) \
+  (sizeof(int32_t) + sizeof(uint16_t) + sizeof(p->colType) + sizeof(p->nColVal) + p->nColVal + sizeof(uint64_t) + sizeof(p->operType))
 
-static char *  getIndexKey(const void *pData) { return NULL; }
-static int32_t compareKey(const void *l, const void *r) {
-  char *lp = (char *)l;
-  char *rp = (char *)r;
+static char* getIndexKey(const void* pData) {
+  return NULL;
+}
+static int32_t compareKey(const void* l, const void* r) {
+  char* lp = (char*)l;
+  char* rp = (char*)r;
 
   // skip total len, not compare
   int32_t ll, rl;  // len
@@ -95,33 +96,33 @@ static int32_t compareKey(const void *l, const void *r) {
 
   return 0;
 }
-IndexCache *indexCacheCreate() {
-  IndexCache *cache = calloc(1, sizeof(IndexCache));
+IndexCache* indexCacheCreate() {
+  IndexCache* cache = calloc(1, sizeof(IndexCache));
   if (cache == NULL) {
     indexError("failed to create index cache");
     return NULL;
   }
-  cache->skiplist = tSkipListCreate(
-      MAX_SKIP_LIST_LEVEL, TSDB_DATA_TYPE_BINARY, MAX_INDEX_KEY_LEN, compareKey, SL_ALLOW_DUP_KEY, getIndexKey);
+  cache->skiplist =
+      tSkipListCreate(MAX_SKIP_LIST_LEVEL, TSDB_DATA_TYPE_BINARY, MAX_INDEX_KEY_LEN, compareKey, SL_ALLOW_DUP_KEY, getIndexKey);
   return cache;
 }
 
-void indexCacheDestroy(void *cache) {
-  IndexCache *pCache = cache;
+void indexCacheDestroy(void* cache) {
+  IndexCache* pCache = cache;
   if (pCache == NULL) { return; }
   tSkipListDestroy(pCache->skiplist);
   free(pCache);
 }
 
-int indexCachePut(void *cache, SIndexTerm *term, int16_t colId, int32_t version, uint64_t uid) {
+int indexCachePut(void* cache, SIndexTerm* term, int16_t colId, int32_t version, uint64_t uid) {
   if (cache == NULL) { return -1; }
 
-  IndexCache *pCache = cache;
+  IndexCache* pCache = cache;
   // encode data
   int32_t total = CACHE_KEY_LEN(term);
 
-  char *buf = calloc(1, total);
-  char *p = buf;
+  char* buf = calloc(1, total);
+  char* p = buf;
 
   SERIALIZE_VAR_TO_BUF(p, total, int32_t);
   SERIALIZE_VAR_TO_BUF(p, colId, int16_t);
@@ -135,28 +136,23 @@ int indexCachePut(void *cache, SIndexTerm *term, int16_t colId, int32_t version,
 
   SERIALIZE_MEM_TO_BUF(p, term, operType);
 
-  tSkipListPut(pCache->skiplist, (void *)buf);
+  tSkipListPut(pCache->skiplist, (void*)buf);
   return 0;
   // encode end
 }
-int indexCacheDel(void *cache, int32_t fieldId, const char *fieldValue, int32_t fvlen, uint64_t uid, int8_t operType) {
-  IndexCache *pCache = cache;
+int indexCacheDel(void* cache, int32_t fieldId, const char* fieldValue, int32_t fvlen, uint64_t uid, int8_t operType) {
+  IndexCache* pCache = cache;
   return 0;
 }
-int indexCacheSearch(void *cache,
-    SIndexTermQuery *      query,
-    int16_t                colId,
-    int32_t                version,
-    SArray *               result,
-    STermValueType *       s) {
+int indexCacheSearch(void* cache, SIndexTermQuery* query, int16_t colId, int32_t version, SArray* result, STermValueType* s) {
   if (cache == NULL) { return -1; }
-  IndexCache *    pCache = cache;
-  SIndexTerm *    term = query->term;
+  IndexCache*     pCache = cache;
+  SIndexTerm*     term = query->term;
   EIndexQueryType qtype = query->qType;
 
   int32_t keyLen = CACHE_KEY_LEN(term);
 
-  char *buf = calloc(1, keyLen);
+  char* buf = calloc(1, keyLen);
   if (qtype == QUERY_TERM) {
     //
   } else if (qtype == QUERY_PREFIX) {
diff --git a/source/libs/index/src/index_fst.c b/source/libs/index/src/index_fst.c
index a425cc676f..3106c1116e 100644
--- a/source/libs/index/src/index_fst.c
+++ b/source/libs/index/src/index_fst.c
@@ -19,39 +19,39 @@
 #include "tchecksum.h"
 #include "tcoding.h"
 
-static void fstPackDeltaIn(FstCountingWriter *wrt, CompiledAddr nodeAddr, CompiledAddr transAddr, uint8_t nBytes) {
+static void fstPackDeltaIn(FstCountingWriter* wrt, CompiledAddr nodeAddr, CompiledAddr transAddr, uint8_t nBytes) {
   CompiledAddr deltaAddr = (transAddr == EMPTY_ADDRESS) ? EMPTY_ADDRESS : nodeAddr - transAddr;
   fstCountingWriterPackUintIn(wrt, deltaAddr, nBytes);
 }
-static uint8_t fstPackDetla(FstCountingWriter *wrt, CompiledAddr nodeAddr, CompiledAddr transAddr) {
+static uint8_t fstPackDetla(FstCountingWriter* wrt, CompiledAddr nodeAddr, CompiledAddr transAddr) {
   uint8_t nBytes = packDeltaSize(nodeAddr, transAddr);
   fstPackDeltaIn(wrt, nodeAddr, transAddr, nBytes);
   return nBytes;
 }
 
-FstUnFinishedNodes *fstUnFinishedNodesCreate() {
-  FstUnFinishedNodes *nodes = malloc(sizeof(FstUnFinishedNodes));
+FstUnFinishedNodes* fstUnFinishedNodesCreate() {
+  FstUnFinishedNodes* nodes = malloc(sizeof(FstUnFinishedNodes));
   if (nodes == NULL) { return NULL; }
 
-  nodes->stack = (SArray *)taosArrayInit(64, sizeof(FstBuilderNodeUnfinished));
+  nodes->stack = (SArray*)taosArrayInit(64, sizeof(FstBuilderNodeUnfinished));
   fstUnFinishedNodesPushEmpty(nodes, false);
   return nodes;
 }
-void unFinishedNodeDestroyElem(void *elem) {
-  FstBuilderNodeUnfinished *b = (FstBuilderNodeUnfinished *)elem;
+void unFinishedNodeDestroyElem(void* elem) {
+  FstBuilderNodeUnfinished* b = (FstBuilderNodeUnfinished*)elem;
   fstBuilderNodeDestroy(b->node);
   free(b->last);
   b->last = NULL;
 }
-void fstUnFinishedNodesDestroy(FstUnFinishedNodes *nodes) {
+void fstUnFinishedNodesDestroy(FstUnFinishedNodes* nodes) {
   if (nodes == NULL) { return; }
 
   taosArrayDestroyEx(nodes->stack, unFinishedNodeDestroyElem);
   free(nodes);
 }
 
-void fstUnFinishedNodesPushEmpty(FstUnFinishedNodes *nodes, bool isFinal) {
-  FstBuilderNode *node = malloc(sizeof(FstBuilderNode));
+void fstUnFinishedNodesPushEmpty(FstUnFinishedNodes* nodes, bool isFinal) {
+  FstBuilderNode* node = malloc(sizeof(FstBuilderNode));
   node->isFinal = isFinal;
   node->finalOutput = 0;
   node->trans = taosArrayInit(16, sizeof(FstTransition));
@@ -59,54 +59,53 @@ void fstUnFinishedNodesPushEmpty(FstUnFinishedNodes *nodes, bool isFinal) {
   FstBuilderNodeUnfinished un = {.node = node, .last = NULL};
   taosArrayPush(nodes->stack, &un);
 }
-FstBuilderNode *fstUnFinishedNodesPopRoot(FstUnFinishedNodes *nodes) {
+FstBuilderNode* fstUnFinishedNodesPopRoot(FstUnFinishedNodes* nodes) {
   assert(taosArrayGetSize(nodes->stack) == 1);
 
-  FstBuilderNodeUnfinished *un = taosArrayPop(nodes->stack);
+  FstBuilderNodeUnfinished* un = taosArrayPop(nodes->stack);
   assert(un->last == NULL);
   return un->node;
 }
 
-FstBuilderNode *fstUnFinishedNodesPopFreeze(FstUnFinishedNodes *nodes, CompiledAddr addr) {
-  FstBuilderNodeUnfinished *un = taosArrayPop(nodes->stack);
+FstBuilderNode* fstUnFinishedNodesPopFreeze(FstUnFinishedNodes* nodes, CompiledAddr addr) {
+  FstBuilderNodeUnfinished* un = taosArrayPop(nodes->stack);
   fstBuilderNodeUnfinishedLastCompiled(un, addr);
   // free(un->last); // TODO add func FstLastTransitionFree()
   // un->last = NULL;
   return un->node;
 }
 
-FstBuilderNode *fstUnFinishedNodesPopEmpty(FstUnFinishedNodes *nodes) {
-  FstBuilderNodeUnfinished *un = taosArrayPop(nodes->stack);
+FstBuilderNode* fstUnFinishedNodesPopEmpty(FstUnFinishedNodes* nodes) {
+  FstBuilderNodeUnfinished* un = taosArrayPop(nodes->stack);
   assert(un->last == NULL);
   return un->node;
 }
-void fstUnFinishedNodesSetRootOutput(FstUnFinishedNodes *nodes, Output out) {
-  FstBuilderNodeUnfinished *un = taosArrayGet(nodes->stack, 0);
+void fstUnFinishedNodesSetRootOutput(FstUnFinishedNodes* nodes, Output out) {
+  FstBuilderNodeUnfinished* un = taosArrayGet(nodes->stack, 0);
   un->node->isFinal = true;
   un->node->finalOutput = out;
   // un->node->trans       = NULL;
 }
-void fstUnFinishedNodesTopLastFreeze(FstUnFinishedNodes *nodes, CompiledAddr addr) {
-  size_t                    sz = taosArrayGetSize(nodes->stack) - 1;
-  FstBuilderNodeUnfinished *un = taosArrayGet(nodes->stack, sz);
+void fstUnFinishedNodesTopLastFreeze(FstUnFinishedNodes* nodes, CompiledAddr addr) {
+  FstBuilderNodeUnfinished* un = taosArrayGet(nodes->stack, taosArrayGetSize(nodes->stack) - 1);
   fstBuilderNodeUnfinishedLastCompiled(un, addr);
 }
-void fstUnFinishedNodesAddSuffix(FstUnFinishedNodes *nodes, FstSlice bs, Output out) {
-  FstSlice *s = &bs;
+void fstUnFinishedNodesAddSuffix(FstUnFinishedNodes* nodes, FstSlice bs, Output out) {
+  FstSlice* s = &bs;
   if (fstSliceIsEmpty(s)) { return; }
   size_t                    sz = taosArrayGetSize(nodes->stack) - 1;
-  FstBuilderNodeUnfinished *un = taosArrayGet(nodes->stack, sz);
+  FstBuilderNodeUnfinished* un = taosArrayGet(nodes->stack, sz);
   assert(un->last == NULL);
 
   // FstLastTransition *trn = malloc(sizeof(FstLastTransition));
   // trn->inp = s->data[s->start];
   // trn->out = out;
   int32_t  len = 0;
-  uint8_t *data = fstSliceData(s, &len);
+  uint8_t* data = fstSliceData(s, &len);
   un->last = fstLastTransitionCreate(data[0], out);
 
   for (uint64_t i = 1; i < len; i++) {
-    FstBuilderNode *n = malloc(sizeof(FstBuilderNode));
+    FstBuilderNode* n = malloc(sizeof(FstBuilderNode));
     n->isFinal = false;
     n->finalOutput = 0;
     n->trans = taosArrayInit(16, sizeof(FstTransition));
@@ -114,7 +113,7 @@ void fstUnFinishedNodesAddSuffix(FstUnFinishedNodes *nodes, FstSlice bs, Output
     // FstLastTransition *trn = malloc(sizeof(FstLastTransition));
     // trn->inp = s->data[i];
     // trn->out = out;
-    FstLastTransition *trn = fstLastTransitionCreate(data[i], 0);
+    FstLastTransition* trn = fstLastTransitionCreate(data[i], 0);
 
     FstBuilderNodeUnfinished un = {.node = n, .last = trn};
     taosArrayPush(nodes->stack, &un);
@@ -122,15 +121,15 @@ void fstUnFinishedNodesAddSuffix(FstUnFinishedNodes *nodes, FstSlice bs, Output
   fstUnFinishedNodesPushEmpty(nodes, true);
 }
 
-uint64_t fstUnFinishedNodesFindCommPrefix(FstUnFinishedNodes *node, FstSlice bs) {
-  FstSlice *s = &bs;
+uint64_t fstUnFinishedNodesFindCommPrefix(FstUnFinishedNodes* node, FstSlice bs) {
+  FstSlice* s = &bs;
 
   size_t   ssz = taosArrayGetSize(node->stack);  // stack size
   uint64_t count = 0;
   int32_t  lsz;  // data len
-  uint8_t *data = fstSliceData(s, &lsz);
+  uint8_t* data = fstSliceData(s, &lsz);
   for (size_t i = 0; i < ssz && i < lsz; i++) {
-    FstBuilderNodeUnfinished *un = taosArrayGet(node->stack, i);
+    FstBuilderNodeUnfinished* un = taosArrayGet(node->stack, i);
     if (un->last->inp == data[i]) {
       count++;
     } else {
@@ -139,19 +138,19 @@ uint64_t fstUnFinishedNodesFindCommPrefix(FstUnFinishedNodes *node, FstSlice bs)
   }
   return count;
 }
-uint64_t fstUnFinishedNodesFindCommPrefixAndSetOutput(FstUnFinishedNodes *node, FstSlice bs, Output in, Output *out) {
-  FstSlice *s = &bs;
+uint64_t fstUnFinishedNodesFindCommPrefixAndSetOutput(FstUnFinishedNodes* node, FstSlice bs, Output in, Output* out) {
+  FstSlice* s = &bs;
 
   size_t lsz = (size_t)(s->end - s->start + 1);  // data len
   size_t ssz = taosArrayGetSize(node->stack);    // stack size
   *out = in;
   uint64_t i = 0;
   for (i = 0; i < lsz && i < ssz; i++) {
-    FstBuilderNodeUnfinished *un = taosArrayGet(node->stack, i);
+    FstBuilderNodeUnfinished* un = taosArrayGet(node->stack, i);
 
-    FstLastTransition *t = un->last;
+    FstLastTransition* t = un->last;
     uint64_t           addPrefix = 0;
-    uint8_t *          data = fstSliceData(s, NULL);
+    uint8_t*           data = fstSliceData(s, NULL);
     if (t && t->inp == data[i]) {
       uint64_t commPrefix = MIN(t->out, *out);
       uint64_t tAddPrefix = t->out - commPrefix;
@@ -163,7 +162,7 @@ uint64_t fstUnFinishedNodesFindCommPrefixAndSetOutput(FstUnFinishedNodes *node,
     }
     if (addPrefix != 0) {
       if (i + 1 < ssz) {
-        FstBuilderNodeUnfinished *unf = taosArrayGet(node->stack, i + 1);
+        FstBuilderNodeUnfinished* unf = taosArrayGet(node->stack, i + 1);
         fstBuilderNodeUnfinishedAddOutputPrefix(unf, addPrefix);
       }
     }
@@ -171,11 +170,11 @@ uint64_t fstUnFinishedNodesFindCommPrefixAndSetOutput(FstUnFinishedNodes *node,
   return i;
 }
 
-FstState fstStateCreateFrom(FstSlice *slice, CompiledAddr addr) {
+FstState fstStateCreateFrom(FstSlice* slice, CompiledAddr addr) {
   FstState fs = {.state = EmptyFinal, .val = 0};
   if (addr == EMPTY_ADDRESS) { return fs; }
 
-  uint8_t *data = fstSliceData(slice, NULL);
+  uint8_t* data = fstSliceData(slice, NULL);
   uint8_t  v = data[addr];
   uint8_t  t = (v & 0b11000000) >> 6;
   if (t == 0b11) {
@@ -189,17 +188,19 @@ FstState fstStateCreateFrom(FstSlice *slice, CompiledAddr addr) {
   return fs;
 }
 
-static FstState fstStateDict[] = {{.state = OneTransNext, .val = 0b11000000}, {.state = OneTrans, .val = 0b10000000},
-    {.state = AnyTrans, .val = 0b00000000}, {.state = EmptyFinal, .val = 0b00000000}};
+static FstState fstStateDict[] = {{.state = OneTransNext, .val = 0b11000000},
+                                  {.state = OneTrans, .val = 0b10000000},
+                                  {.state = AnyTrans, .val = 0b00000000},
+                                  {.state = EmptyFinal, .val = 0b00000000}};
 // debug
-static const char *fstStateStr[] = {"ONE_TRANS_NEXT", "ONE_TRANS", "ANY_TRANS", "EMPTY_FINAL"};
+static const char* fstStateStr[] = {"ONE_TRANS_NEXT", "ONE_TRANS", "ANY_TRANS", "EMPTY_FINAL"};
 
 FstState fstStateCreate(State state) {
   uint8_t idx = (uint8_t)state;
   return fstStateDict[idx];
 }
 // compile
-void fstStateCompileForOneTransNext(FstCountingWriter *w, CompiledAddr addr, uint8_t inp) {
+void fstStateCompileForOneTransNext(FstCountingWriter* w, CompiledAddr addr, uint8_t inp) {
   FstState s = fstStateCreate(OneTransNext);
   fstStateSetCommInput(&s, inp);
 
@@ -213,7 +214,7 @@ void fstStateCompileForOneTransNext(FstCountingWriter *w, CompiledAddr addr, uin
   // w->write_all(&[s.val])
   return;
 }
-void fstStateCompileForOneTrans(FstCountingWriter *w, CompiledAddr addr, FstTransition *trn) {
+void fstStateCompileForOneTrans(FstCountingWriter* w, CompiledAddr addr, FstTransition* trn) {
   Output    out = trn->out;
   uint8_t   outPackSize = (out == 0 ? 0 : fstCountingWriterPackUint(w, out));
   uint8_t   transPackSize = fstPackDetla(w, addr, trn->addr);
@@ -221,18 +222,18 @@ void fstStateCompileForOneTrans(FstCountingWriter *w, CompiledAddr addr, FstTran
 
   FST_SET_OUTPUT_PACK_SIZE(packSizes, outPackSize);
   FST_SET_TRANSITION_PACK_SIZE(packSizes, transPackSize);
-  fstCountingWriterWrite(w, (char *)&packSizes, sizeof(packSizes));
+  fstCountingWriterWrite(w, (char*)&packSizes, sizeof(packSizes));
 
   FstState st = fstStateCreate(OneTrans);
 
   fstStateSetCommInput(&st, trn->inp);
   bool    null = false;
   uint8_t inp = fstStateCommInput(&st, &null);
-  if (null == true) { fstCountingWriterWrite(w, (char *)&trn->inp, sizeof(trn->inp)); }
-  fstCountingWriterWrite(w, (char *)(&(st.val)), sizeof(st.val));
+  if (null == true) { fstCountingWriterWrite(w, (char*)&trn->inp, sizeof(trn->inp)); }
+  fstCountingWriterWrite(w, (char*)(&(st.val)), sizeof(st.val));
   return;
 }
-void fstStateCompileForAnyTrans(FstCountingWriter *w, CompiledAddr addr, FstBuilderNode *node) {
+void fstStateCompileForAnyTrans(FstCountingWriter* w, CompiledAddr addr, FstBuilderNode* node) {
   size_t sz = taosArrayGetSize(node->trans);
   assert(sz <= 256);
 
@@ -242,7 +243,7 @@ void fstStateCompileForAnyTrans(FstCountingWriter *w, CompiledAddr addr, FstBuil
   // finalOutput.is_zero()
   bool anyOuts = (node->finalOutput != 0);
   for (size_t i = 0; i < sz; i++) {
-    FstTransition *t = taosArrayGet(node->trans, i);
+    FstTransition* t = taosArrayGet(node->trans, i);
     tSize = MAX(tSize, packDeltaSize(addr, t->addr));
     oSize = MAX(oSize, packSize(t->out));
     anyOuts = anyOuts || (t->out != 0);
@@ -264,17 +265,17 @@ void fstStateCompileForAnyTrans(FstCountingWriter *w, CompiledAddr addr, FstBuil
   if (anyOuts) {
     if (FST_BUILDER_NODE_IS_FINAL(node)) { fstCountingWriterPackUintIn(w, node->finalOutput, oSize); }
     for (int32_t i = sz - 1; i >= 0; i--) {
-      FstTransition *t = taosArrayGet(node->trans, i);
+      FstTransition* t = taosArrayGet(node->trans, i);
       fstCountingWriterPackUintIn(w, t->out, oSize);
     }
   }
   for (int32_t i = sz - 1; i >= 0; i--) {
-    FstTransition *t = taosArrayGet(node->trans, i);
+    FstTransition* t = taosArrayGet(node->trans, i);
     fstPackDeltaIn(w, addr, t->addr, tSize);
   }
   for (int32_t i = sz - 1; i >= 0; i--) {
-    FstTransition *t = taosArrayGet(node->trans, i);
-    fstCountingWriterWrite(w, (char *)&t->inp, 1);
+    FstTransition* t = taosArrayGet(node->trans, i);
+    fstCountingWriterWrite(w, (char*)&t->inp, 1);
     // fstPackDeltaIn(w, addr, t->addr, tSize);
   }
   if (sz > TRANS_INDEX_THRESHOLD) {
@@ -282,20 +283,20 @@ void fstStateCompileForAnyTrans(FstCountingWriter *w, CompiledAddr addr, FstBuil
     // at that index. (Except when there are 256 transitions.) Namely,
     // any value greater than or equal to the number of transitions in
     // this node indicates an absent transition.
-    uint8_t *index = (uint8_t *)malloc(sizeof(uint8_t) * 256);
+    uint8_t* index = (uint8_t*)malloc(sizeof(uint8_t) * 256);
     memset(index, 255, sizeof(uint8_t) * 256);
     /// for (uint8_t i = 0; i < 256; i++) {
     //  index[i] = 255;
     ///}
     for (size_t i = 0; i < sz; i++) {
-      FstTransition *t = taosArrayGet(node->trans, i);
+      FstTransition* t = taosArrayGet(node->trans, i);
       index[t->inp] = i;
       // fstPackDeltaIn(w, addr, t->addr, tSize);
     }
-    fstCountingWriterWrite(w, (char *)index, 256);
+    fstCountingWriterWrite(w, (char*)index, 256);
     free(index);
   }
-  fstCountingWriterWrite(w, (char *)&packSizes, 1);
+  fstCountingWriterWrite(w, (char*)&packSizes, 1);
   bool null = false;
   fstStateStateNtrans(&st, &null);
   if (null == true) {
@@ -304,17 +305,17 @@ void fstStateCompileForAnyTrans(FstCountingWriter *w, CompiledAddr addr, FstBuil
     // encoded in the state byte.
     uint8_t v = 1;
     if (sz == 256) {
-      fstCountingWriterWrite(w, (char *)&v, 1);
+      fstCountingWriterWrite(w, (char*)&v, 1);
     } else {
-      fstCountingWriterWrite(w, (char *)&sz, 1);
+      fstCountingWriterWrite(w, (char*)&sz, 1);
     }
   }
-  fstCountingWriterWrite(w, (char *)(&(st.val)), 1);
+  fstCountingWriterWrite(w, (char*)(&(st.val)), 1);
   return;
 }
 
 // set_comm_input
-void fstStateSetCommInput(FstState *s, uint8_t inp) {
+void fstStateSetCommInput(FstState* s, uint8_t inp) {
   assert(s->state == OneTransNext || s->state == OneTrans);
 
   uint8_t val;
@@ -323,7 +324,7 @@ void fstStateSetCommInput(FstState *s, uint8_t inp) {
 }
 
 // comm_input
-uint8_t fstStateCommInput(FstState *s, bool *null) {
+uint8_t fstStateCommInput(FstState* s, bool* null) {
   assert(s->state == OneTransNext || s->state == OneTrans);
   uint8_t v = s->val & 0b00111111;
   if (v == 0) {
@@ -336,7 +337,7 @@ uint8_t fstStateCommInput(FstState *s, bool *null) {
 
 // input_len
 
-uint64_t fstStateInputLen(FstState *s) {
+uint64_t fstStateInputLen(FstState* s) {
   assert(s->state == OneTransNext || s->state == OneTrans);
   bool null = false;
   fstStateCommInput(s, &null);
@@ -344,17 +345,16 @@ uint64_t fstStateInputLen(FstState *s) {
 }
 
 // end_addr
-uint64_t fstStateEndAddrForOneTransNext(FstState *s, FstSlice *data) {
+uint64_t fstStateEndAddrForOneTransNext(FstState* s, FstSlice* data) {
   assert(s->state == OneTransNext);
   return FST_SLICE_LEN(data) - 1 - fstStateInputLen(s);
 }
-uint64_t fstStateEndAddrForOneTrans(FstState *s, FstSlice *data, PackSizes sizes) {
+uint64_t fstStateEndAddrForOneTrans(FstState* s, FstSlice* data, PackSizes sizes) {
   assert(s->state == OneTrans);
   return FST_SLICE_LEN(data) - 1 - fstStateInputLen(s) - 1  // pack size
          - FST_GET_TRANSITION_PACK_SIZE(sizes) - FST_GET_OUTPUT_PACK_SIZE(sizes);
 }
-uint64_t fstStateEndAddrForAnyTrans(
-    FstState *state, uint64_t version, FstSlice *date, PackSizes sizes, uint64_t nTrans) {
+uint64_t fstStateEndAddrForAnyTrans(FstState* state, uint64_t version, FstSlice* date, PackSizes sizes, uint64_t nTrans) {
   uint8_t oSizes = FST_GET_OUTPUT_PACK_SIZE(sizes);
   uint8_t finalOsize = !fstStateIsFinalState(state) ? 0 : oSizes;
   return FST_SLICE_LEN(date) - 1 - fstStateNtransLen(state) - 1                     // pack size
@@ -362,29 +362,29 @@ uint64_t fstStateEndAddrForAnyTrans(
          - finalOsize;                                                              // final output
 }
 // input
-uint8_t fstStateInput(FstState *s, FstNode *node) {
+uint8_t fstStateInput(FstState* s, FstNode* node) {
   assert(s->state == OneTransNext || s->state == OneTrans);
-  FstSlice *slice = &node->data;
+  FstSlice* slice = &node->data;
   bool      null = false;
   uint8_t   inp = fstStateCommInput(s, &null);
-  uint8_t * data = fstSliceData(slice, NULL);
+  uint8_t*  data = fstSliceData(slice, NULL);
   return null == false ? inp : data[-1];
 }
-uint8_t fstStateInputForAnyTrans(FstState *s, FstNode *node, uint64_t i) {
+uint8_t fstStateInputForAnyTrans(FstState* s, FstNode* node, uint64_t i) {
   assert(s->state == AnyTrans);
-  FstSlice *slice = &node->data;
+  FstSlice* slice = &node->data;
 
   uint64_t at = node->start - fstStateNtransLen(s) - 1                             // pack size
                 - fstStateTransIndexSize(s, node->version, node->nTrans) - i - 1;  // the output size
 
-  uint8_t *data = fstSliceData(slice, NULL);
+  uint8_t* data = fstSliceData(slice, NULL);
   return data[at];
 }
 
 // trans_addr
-CompiledAddr fstStateTransAddr(FstState *s, FstNode *node) {
+CompiledAddr fstStateTransAddr(FstState* s, FstNode* node) {
   assert(s->state == OneTransNext || s->state == OneTrans);
-  FstSlice *slice = &node->data;
+  FstSlice* slice = &node->data;
   if (s->state == OneTransNext) {
     return (CompiledAddr)(node->end) - 1;
   } else {
@@ -394,23 +394,23 @@ CompiledAddr fstStateTransAddr(FstState *s, FstNode *node) {
                  - tSizes;
 
     // refactor error logic
-    uint8_t *data = fstSliceData(slice, NULL);
+    uint8_t* data = fstSliceData(slice, NULL);
     return unpackDelta(data + i, tSizes, node->end);
   }
 }
-CompiledAddr fstStateTransAddrForAnyTrans(FstState *s, FstNode *node, uint64_t i) {
+CompiledAddr fstStateTransAddrForAnyTrans(FstState* s, FstNode* node, uint64_t i) {
   assert(s->state == AnyTrans);
 
-  FstSlice *slice = &node->data;
+  FstSlice* slice = &node->data;
   uint8_t   tSizes = FST_GET_TRANSITION_PACK_SIZE(node->sizes);
-  uint64_t  at = node->start - fstStateNtransLen(s) - 1 - fstStateTransIndexSize(s, node->version, node->nTrans) -
-                node->nTrans - (i * tSizes) - tSizes;
-  uint8_t *data = fstSliceData(slice, NULL);
+  uint64_t  at = node->start - fstStateNtransLen(s) - 1 - fstStateTransIndexSize(s, node->version, node->nTrans) - node->nTrans -
+                (i * tSizes) - tSizes;
+  uint8_t* data = fstSliceData(slice, NULL);
   return unpackDelta(data + at, tSizes, node->end);
 }
 
 // sizes
-PackSizes fstStateSizes(FstState *s, FstSlice *slice) {
+PackSizes fstStateSizes(FstState* s, FstSlice* slice) {
   assert(s->state == OneTrans || s->state == AnyTrans);
   uint64_t i;
   if (s->state == OneTrans) {
@@ -419,29 +419,29 @@ PackSizes fstStateSizes(FstState *s, FstSlice *slice) {
     i = FST_SLICE_LEN(slice) - 1 - fstStateNtransLen(s) - 1;
   }
 
-  uint8_t *data = fstSliceData(slice, NULL);
+  uint8_t* data = fstSliceData(slice, NULL);
   return (PackSizes)(*(data + i));
 }
 // Output
-Output fstStateOutput(FstState *s, FstNode *node) {
+Output fstStateOutput(FstState* s, FstNode* node) {
   assert(s->state == OneTrans);
 
   uint8_t oSizes = FST_GET_OUTPUT_PACK_SIZE(node->sizes);
   if (oSizes == 0) { return 0; }
-  FstSlice *slice = &node->data;
+  FstSlice* slice = &node->data;
   uint8_t   tSizes = FST_GET_TRANSITION_PACK_SIZE(node->sizes);
 
   uint64_t i = node->start - fstStateInputLen(s) - 1 - tSizes - oSizes;
-  uint8_t *data = fstSliceData(slice, NULL);
+  uint8_t* data = fstSliceData(slice, NULL);
   return unpackUint64(data + i, oSizes);
 }
-Output fstStateOutputForAnyTrans(FstState *s, FstNode *node, uint64_t i) {
+Output fstStateOutputForAnyTrans(FstState* s, FstNode* node, uint64_t i) {
   assert(s->state == AnyTrans);
 
   uint8_t oSizes = FST_GET_OUTPUT_PACK_SIZE(node->sizes);
   if (oSizes == 0) { return 0; }
-  FstSlice *slice = &node->data;
-  uint8_t * data = fstSliceData(slice, NULL);
+  FstSlice* slice = &node->data;
+  uint8_t*  data = fstSliceData(slice, NULL);
   uint64_t  at = node->start - fstStateNtransLen(s) - 1  // pack size
                 - fstStateTotalTransSize(s, node->version, node->sizes, node->nTrans) - (i * oSizes) - oSizes;
 
@@ -450,23 +450,23 @@ Output fstStateOutputForAnyTrans(FstState *s, FstNode *node, uint64_t i) {
 
 // anyTrans specify function
 
-void fstStateSetFinalState(FstState *s, bool yes) {
+void fstStateSetFinalState(FstState* s, bool yes) {
   assert(s->state == AnyTrans);
   if (yes) { s->val |= 0b01000000; }
   return;
 }
-bool fstStateIsFinalState(FstState *s) {
+bool fstStateIsFinalState(FstState* s) {
   assert(s->state == AnyTrans);
   return (s->val & 0b01000000) == 0b01000000;
 }
 
-void fstStateSetStateNtrans(FstState *s, uint8_t n) {
+void fstStateSetStateNtrans(FstState* s, uint8_t n) {
   assert(s->state == AnyTrans);
   if (n <= 0b00111111) { s->val = (s->val & 0b11000000) | n; }
   return;
 }
 // state_ntrans
-uint8_t fstStateStateNtrans(FstState *s, bool *null) {
+uint8_t fstStateStateNtrans(FstState* s, bool* null) {
   assert(s->state == AnyTrans);
   *null = false;
   uint8_t n = s->val & 0b00111111;
@@ -476,49 +476,49 @@ uint8_t fstStateStateNtrans(FstState *s, bool *null) {
   }
   return n;
 }
-uint64_t fstStateTotalTransSize(FstState *s, uint64_t version, PackSizes sizes, uint64_t nTrans) {
+uint64_t fstStateTotalTransSize(FstState* s, uint64_t version, PackSizes sizes, uint64_t nTrans) {
   assert(s->state == AnyTrans);
   uint64_t idxSize = fstStateTransIndexSize(s, version, nTrans);
   return nTrans + (nTrans * FST_GET_TRANSITION_PACK_SIZE(sizes)) + idxSize;
 }
-uint64_t fstStateTransIndexSize(FstState *s, uint64_t version, uint64_t nTrans) {
+uint64_t fstStateTransIndexSize(FstState* s, uint64_t version, uint64_t nTrans) {
   assert(s->state == AnyTrans);
   return (version >= 2 && nTrans > TRANS_INDEX_THRESHOLD) ? 256 : 0;
 }
-uint64_t fstStateNtransLen(FstState *s) {
+uint64_t fstStateNtransLen(FstState* s) {
   assert(s->state == AnyTrans);
   bool null = false;
   fstStateStateNtrans(s, &null);
   return null == true ? 1 : 0;
 }
-uint64_t fstStateNtrans(FstState *s, FstSlice *slice) {
+uint64_t fstStateNtrans(FstState* s, FstSlice* slice) {
   bool    null = false;
   uint8_t n = fstStateStateNtrans(s, &null);
   if (null != true) { return n; }
   int32_t  len;
-  uint8_t *data = fstSliceData(slice, &len);
+  uint8_t* data = fstSliceData(slice, &len);
   n = data[len - 2];
   // n = data[slice->end - 1]; // data[data.len() - 2]
   return n == 1 ? 256 : n;  // // "1" is never a normal legal value here, because if there, // is only 1 transition,
                             // then it is encoded in the state byte
 }
-Output fstStateFinalOutput(FstState *s, uint64_t version, FstSlice *slice, PackSizes sizes, uint64_t nTrans) {
+Output fstStateFinalOutput(FstState* s, uint64_t version, FstSlice* slice, PackSizes sizes, uint64_t nTrans) {
   uint8_t oSizes = FST_GET_OUTPUT_PACK_SIZE(sizes);
   if (oSizes == 0 || !fstStateIsFinalState(s)) { return 0; }
 
   uint64_t at = FST_SLICE_LEN(slice) - 1 - fstStateNtransLen(s) - 1  // pack size
                 - fstStateTotalTransSize(s, version, sizes, nTrans) - (nTrans * oSizes) - oSizes;
-  uint8_t *data = fstSliceData(slice, NULL);
+  uint8_t* data = fstSliceData(slice, NULL);
   return unpackUint64(data + at, (uint8_t)oSizes);
 }
-uint64_t fstStateFindInput(FstState *s, FstNode *node, uint8_t b, bool *null) {
+uint64_t fstStateFindInput(FstState* s, FstNode* node, uint8_t b, bool* null) {
   assert(s->state == AnyTrans);
-  FstSlice *slice = &node->data;
+  FstSlice* slice = &node->data;
   if (node->version >= 2 && node->nTrans > TRANS_INDEX_THRESHOLD) {
     uint64_t at = node->start - fstStateNtransLen(s) - 1  // pack size
                   - fstStateTransIndexSize(s, node->version, node->nTrans);
     int32_t  dlen = 0;
-    uint8_t *data = fstSliceData(slice, &dlen);
+    uint8_t* data = fstSliceData(slice, &dlen);
     uint64_t i = data[at + b];
     // uint64_t i = slice->data[slice->start + at + b];
     if (i >= node->nTrans) { *null = true; }
@@ -529,7 +529,7 @@ uint64_t fstStateFindInput(FstState *s, FstNode *node, uint8_t b, bool *null) {
     uint64_t end = start + node->nTrans;
     FstSlice t = fstSliceCopy(slice, start, end - 1);
     int32_t  len = 0;
-    uint8_t *data = fstSliceData(&t, &len);
+    uint8_t* data = fstSliceData(&t, &len);
     int      i = 0;
     for (; i < len; i++) {
       uint8_t v = data[i];
@@ -545,8 +545,8 @@ uint64_t fstStateFindInput(FstState *s, FstNode *node, uint8_t b, bool *null) {
 
 // fst node function
 
-FstNode *fstNodeCreate(int64_t version, CompiledAddr addr, FstSlice *slice) {
-  FstNode *n = (FstNode *)malloc(sizeof(FstNode));
+FstNode* fstNodeCreate(int64_t version, CompiledAddr addr, FstSlice* slice) {
+  FstNode* n = (FstNode*)malloc(sizeof(FstNode));
   if (n == NULL) { return NULL; }
 
   FstState st = fstStateCreateFrom(slice, addr);
@@ -595,24 +595,23 @@ FstNode *fstNodeCreate(int64_t version, CompiledAddr addr, FstSlice *slice) {
     n->isFinal = fstStateIsFinalState(&st);                                // s.is_final_state();
     n->nTrans = nTrans;
     n->sizes = sz;
-    n->finalOutput =
-        fstStateFinalOutput(&st, version, &data, sz, nTrans);  // s.final_output(version, data, sz, ntrans);
+    n->finalOutput = fstStateFinalOutput(&st, version, &data, sz, nTrans);  // s.final_output(version, data, sz, ntrans);
   }
   return n;
 }
 
 // debug state transition
-static const char *fstNodeState(FstNode *node) {
-  FstState *st = &node->state;
+static const char* fstNodeState(FstNode* node) {
+  FstState* st = &node->state;
   return fstStateStr[st->state];
 }
 
-void fstNodeDestroy(FstNode *node) {
+void fstNodeDestroy(FstNode* node) {
   fstSliceDestroy(&node->data);
   free(node);
 }
-FstTransitions *fstNodeTransitions(FstNode *node) {
-  FstTransitions *t = malloc(sizeof(FstTransitions));
+FstTransitions* fstNodeTransitions(FstNode* node) {
+  FstTransitions* t = malloc(sizeof(FstTransitions));
   if (NULL == t) { return NULL; }
   FstRange range = {.start = 0, .end = FST_NODE_LEN(node)};
   t->range = range;
@@ -621,9 +620,9 @@ FstTransitions *fstNodeTransitions(FstNode *node) {
 }
 
 // Returns the transition at index `i`.
-bool fstNodeGetTransitionAt(FstNode *node, uint64_t i, FstTransition *trn) {
+bool fstNodeGetTransitionAt(FstNode* node, uint64_t i, FstTransition* trn) {
   bool      s = true;
-  FstState *st = &node->state;
+  FstState* st = &node->state;
   if (st->state == OneTransNext) {
     trn->inp = fstStateInput(st, node);
     trn->out = 0;
@@ -643,9 +642,9 @@ bool fstNodeGetTransitionAt(FstNode *node, uint64_t i, FstTransition *trn) {
 }
 
 // Returns the transition address of the `i`th transition
-bool fstNodeGetTransitionAddrAt(FstNode *node, uint64_t i, CompiledAddr *res) {
+bool fstNodeGetTransitionAddrAt(FstNode* node, uint64_t i, CompiledAddr* res) {
   bool      s = true;
-  FstState *st = &node->state;
+  FstState* st = &node->state;
   if (st->state == OneTransNext) {
     assert(i == 0);
     fstStateTransAddr(st, node);
@@ -664,9 +663,9 @@ bool fstNodeGetTransitionAddrAt(FstNode *node, uint64_t i, CompiledAddr *res) {
 
 //  Finds the `i`th transition corresponding to the given input byte.
 //  If no transition for this byte exists, then `false` is returned.
-bool fstNodeFindInput(FstNode *node, uint8_t b, uint64_t *res) {
+bool fstNodeFindInput(FstNode* node, uint8_t b, uint64_t* res) {
   bool      s = true;
-  FstState *st = &node->state;
+  FstState* st = &node->state;
   if (st->state == OneTransNext) {
     if (fstStateInput(st, node) == b) {
       *res = 0;
@@ -691,7 +690,7 @@ bool fstNodeFindInput(FstNode *node, uint8_t b, uint64_t *res) {
   return s;
 }
 
-bool fstNodeCompile(FstNode *node, void *w, CompiledAddr lastAddr, CompiledAddr addr, FstBuilderNode *builderNode) {
+bool fstNodeCompile(FstNode* node, void* w, CompiledAddr lastAddr, CompiledAddr addr, FstBuilderNode* builderNode) {
   size_t sz = taosArrayGetSize(builderNode->trans);
   assert(sz < 256);
   if (sz == 0 && builderNode->isFinal && builderNode->finalOutput == 0) {
@@ -700,7 +699,7 @@ bool fstNodeCompile(FstNode *node, void *w, CompiledAddr lastAddr, CompiledAddr
     fstStateCompileForAnyTrans(w, addr, builderNode);
     // AnyTrans->Compile(w, addr, node);
   } else {
-    FstTransition *tran = taosArrayGet(builderNode->trans, 0);
+    FstTransition* tran = taosArrayGet(builderNode->trans, 0);
     if (tran->addr == lastAddr && tran->out == 0) {
       fstStateCompileForOneTransNext(w, addr, tran->inp);
       // OneTransNext::compile(w, lastAddr, tran->inp);
@@ -714,12 +713,12 @@ bool fstNodeCompile(FstNode *node, void *w, CompiledAddr lastAddr, CompiledAddr
   return true;
 }
 
-bool fstBuilderNodeCompileTo(FstBuilderNode *b, FstCountingWriter *wrt, CompiledAddr lastAddr, CompiledAddr startAddr) {
+bool fstBuilderNodeCompileTo(FstBuilderNode* b, FstCountingWriter* wrt, CompiledAddr lastAddr, CompiledAddr startAddr) {
   return fstNodeCompile(NULL, wrt, lastAddr, startAddr, b);
 }
 
-FstBuilder *fstBuilderCreate(void *w, FstType ty) {
-  FstBuilder *b = malloc(sizeof(FstBuilder));
+FstBuilder* fstBuilderCreate(void* w, FstType ty) {
+  FstBuilder* b = malloc(sizeof(FstBuilder));
   if (NULL == b) { return b; }
 
   b->wrt = fstCountingWriterCreate(w);
@@ -730,7 +729,7 @@ FstBuilder *fstBuilderCreate(void *w, FstType ty) {
   b->len = 0;
 
   char  buf64[8] = {0};
-  void *pBuf64 = buf64;
+  void* pBuf64 = buf64;
   taosEncodeFixedU64(&pBuf64, VERSION);
   fstCountingWriterWrite(b->wrt, buf64, sizeof(buf64));
 
@@ -741,7 +740,7 @@ FstBuilder *fstBuilderCreate(void *w, FstType ty) {
 
   return b;
 }
-void fstBuilderDestroy(FstBuilder *b) {
+void fstBuilderDestroy(FstBuilder* b) {
   if (b == NULL) { return; }
 
   fstCountingWriterDestroy(b->wrt);
@@ -751,7 +750,7 @@ void fstBuilderDestroy(FstBuilder *b) {
   free(b);
 }
 
-bool fstBuilderInsert(FstBuilder *b, FstSlice bs, Output in) {
+bool fstBuilderInsert(FstBuilder* b, FstSlice bs, Output in) {
   OrderType t = fstBuilderCheckLastKey(b, bs, true);
   if (t == Ordered) {
     // add log info
@@ -762,8 +761,8 @@ bool fstBuilderInsert(FstBuilder *b, FstSlice bs, Output in) {
   return false;
 }
 
-void fstBuilderInsertOutput(FstBuilder *b, FstSlice bs, Output in) {
-  FstSlice *s = &bs;
+void fstBuilderInsertOutput(FstBuilder* b, FstSlice bs, Output in) {
+  FstSlice* s = &bs;
   if (fstSliceIsEmpty(s)) {
     b->len = 1;
     fstUnFinishedNodesSetRootOutput(b->unfinished, in);
@@ -792,8 +791,8 @@ void fstBuilderInsertOutput(FstBuilder *b, FstSlice bs, Output in) {
   return;
 }
 
-OrderType fstBuilderCheckLastKey(FstBuilder *b, FstSlice bs, bool ckDup) {
-  FstSlice *input = &bs;
+OrderType fstBuilderCheckLastKey(FstBuilder* b, FstSlice bs, bool ckDup) {
+  FstSlice* input = &bs;
   if (fstSliceIsEmpty(&b->last)) {
     fstSliceDestroy(&b->last);
     // deep copy or not
@@ -811,10 +810,10 @@ OrderType fstBuilderCheckLastKey(FstBuilder *b, FstSlice bs, bool ckDup) {
   }
   return Ordered;
 }
-void fstBuilderCompileFrom(FstBuilder *b, uint64_t istate) {
+void fstBuilderCompileFrom(FstBuilder* b, uint64_t istate) {
   CompiledAddr addr = NONE_ADDRESS;
   while (istate + 1 < FST_UNFINISHED_NODES_LEN(b->unfinished)) {
-    FstBuilderNode *bn = NULL;
+    FstBuilderNode* bn = NULL;
     if (addr == NONE_ADDRESS) {
       bn = fstUnFinishedNodesPopEmpty(b->unfinished);
     } else {
@@ -829,11 +828,11 @@ void fstBuilderCompileFrom(FstBuilder *b, uint64_t istate) {
   fstUnFinishedNodesTopLastFreeze(b->unfinished, addr);
   return;
 }
-CompiledAddr fstBuilderCompile(FstBuilder *b, FstBuilderNode *bn) {
+CompiledAddr fstBuilderCompile(FstBuilder* b, FstBuilderNode* bn) {
   if (FST_BUILDER_NODE_IS_FINAL(bn) && FST_BUILDER_NODE_TRANS_ISEMPTY(bn) && FST_BUILDER_NODE_FINALOUTPUT_ISZERO(bn)) {
     return EMPTY_ADDRESS;
   }
-  FstRegistryEntry *entry = fstRegistryGetEntry(b->registry, bn);
+  FstRegistryEntry* entry = fstRegistryGetEntry(b->registry, bn);
   if (entry->state == FOUND) {
     CompiledAddr ret = entry->addr;
     fstRegistryEntryDestroy(entry);
@@ -849,15 +848,15 @@ CompiledAddr fstBuilderCompile(FstBuilder *b, FstBuilderNode *bn) {
   return b->lastAddr;
 }
 
-void *fstBuilderInsertInner(FstBuilder *b) {
+void* fstBuilderInsertInner(FstBuilder* b) {
   fstBuilderCompileFrom(b, 0);
-  FstBuilderNode *rootNode = fstUnFinishedNodesPopRoot(b->unfinished);
+  FstBuilderNode* rootNode = fstUnFinishedNodesPopRoot(b->unfinished);
   CompiledAddr    rootAddr = fstBuilderCompile(b, rootNode);
   fstBuilderNodeDestroy(rootNode);
 
   char buf64[8] = {0};
 
-  void *pBuf64 = buf64;
+  void* pBuf64 = buf64;
   taosEncodeFixedU64(&pBuf64, b->len);
   fstCountingWriterWrite(b->wrt, buf64, sizeof(buf64));
 
@@ -866,7 +865,7 @@ void *fstBuilderInsertInner(FstBuilder *b) {
   fstCountingWriterWrite(b->wrt, buf64, sizeof(buf64));
 
   char     buf32[4] = {0};
-  void *   pBuf32 = buf32;
+  void*    pBuf32 = buf32;
   uint32_t sum = fstCountingWriterMaskedCheckSum(b->wrt);
   taosEncodeFixedU32(&pBuf32, sum);
   fstCountingWriterWrite(b->wrt, buf32, sizeof(buf32));
@@ -876,16 +875,18 @@ void *fstBuilderInsertInner(FstBuilder *b) {
   // b->wrt = NULL;
   return b->wrt;
 }
-void fstBuilderFinish(FstBuilder *b) { fstBuilderInsertInner(b); }
+void fstBuilderFinish(FstBuilder* b) {
+  fstBuilderInsertInner(b);
+}
 
-FstSlice fstNodeAsSlice(FstNode *node) {
-  FstSlice *slice = &node->data;
+FstSlice fstNodeAsSlice(FstNode* node) {
+  FstSlice* slice = &node->data;
   FstSlice  s = fstSliceCopy(slice, slice->end, FST_SLICE_LEN(slice) - 1);
   return s;
 }
 
-FstLastTransition *fstLastTransitionCreate(uint8_t inp, Output out) {
-  FstLastTransition *trn = malloc(sizeof(FstLastTransition));
+FstLastTransition* fstLastTransitionCreate(uint8_t inp, Output out) {
+  FstLastTransition* trn = malloc(sizeof(FstLastTransition));
   if (trn == NULL) { return NULL; }
 
   trn->inp = inp;
@@ -893,9 +894,11 @@ FstLastTransition *fstLastTransitionCreate(uint8_t inp, Output out) {
   return trn;
 }
 
-void fstLastTransitionDestroy(FstLastTransition *trn) { free(trn); }
-void fstBuilderNodeUnfinishedLastCompiled(FstBuilderNodeUnfinished *unNode, CompiledAddr addr) {
-  FstLastTransition *trn = unNode->last;
+void fstLastTransitionDestroy(FstLastTransition* trn) {
+  free(trn);
+}
+void fstBuilderNodeUnfinishedLastCompiled(FstBuilderNodeUnfinished* unNode, CompiledAddr addr) {
+  FstLastTransition* trn = unNode->last;
   if (trn == NULL) { return; }
   FstTransition t = {.inp = trn->inp, .out = trn->out, .addr = addr};
   taosArrayPush(unNode->node->trans, &t);
@@ -904,20 +907,20 @@ void fstBuilderNodeUnfinishedLastCompiled(FstBuilderNodeUnfinished *unNode, Comp
   return;
 }
 
-void fstBuilderNodeUnfinishedAddOutputPrefix(FstBuilderNodeUnfinished *unNode, Output out) {
+void fstBuilderNodeUnfinishedAddOutputPrefix(FstBuilderNodeUnfinished* unNode, Output out) {
   if (FST_BUILDER_NODE_IS_FINAL(unNode->node)) { unNode->node->finalOutput += out; }
   size_t sz = taosArrayGetSize(unNode->node->trans);
   for (size_t i = 0; i < sz; i++) {
-    FstTransition *trn = taosArrayGet(unNode->node->trans, i);
+    FstTransition* trn = taosArrayGet(unNode->node->trans, i);
     trn->out += out;
   }
   if (unNode->last) { unNode->last->out += out; }
   return;
 }
 
-Fst *fstCreate(FstSlice *slice) {
+Fst* fstCreate(FstSlice* slice) {
   int32_t slen;
-  char *  buf = fstSliceData(slice, &slen);
+  char*   buf = fstSliceData(slice, &slen);
   if (slen < 36) { return NULL; }
   uint64_t len = slen;
   uint64_t skip = 0;
@@ -943,10 +946,10 @@ Fst *fstCreate(FstSlice *slice) {
   len -= sizeof(fstLen);
   taosDecodeFixedU64(buf + len, &fstLen);
   // TODO(validate root addr)
-  Fst *fst = (Fst *)calloc(1, sizeof(Fst));
+  Fst* fst = (Fst*)calloc(1, sizeof(Fst));
   if (fst == NULL) { return NULL; }
 
-  fst->meta = (FstMeta *)malloc(sizeof(FstMeta));
+  fst->meta = (FstMeta*)malloc(sizeof(FstMeta));
   if (NULL == fst->meta) { goto FST_CREAT_FAILED; }
 
   fst->meta->version = version;
@@ -955,7 +958,7 @@ Fst *fstCreate(FstSlice *slice) {
   fst->meta->len = fstLen;
   fst->meta->checkSum = checkSum;
 
-  FstSlice *s = calloc(1, sizeof(FstSlice));
+  FstSlice* s = calloc(1, sizeof(FstSlice));
   *s = fstSliceCopy(slice, 0, FST_SLICE_LEN(slice));
   fst->data = s;
 
@@ -965,7 +968,7 @@ FST_CREAT_FAILED:
   free(fst->meta);
   free(fst);
 }
-void fstDestroy(Fst *fst) {
+void fstDestroy(Fst* fst) {
   if (fst) {
     free(fst->meta);
     fstSliceDestroy(fst->data);
@@ -974,13 +977,13 @@ void fstDestroy(Fst *fst) {
   free(fst);
 }
 
-bool fstGet(Fst *fst, FstSlice *b, Output *out) {
-  FstNode *root = fstGetRoot(fst);
+bool fstGet(Fst* fst, FstSlice* b, Output* out) {
+  FstNode* root = fstGetRoot(fst);
   Output   tOut = 0;
   int32_t  len;
-  uint8_t *data = fstSliceData(b, &len);
+  uint8_t* data = fstSliceData(b, &len);
 
-  SArray *nodes = (SArray *)taosArrayInit(len, sizeof(FstNode *));
+  SArray* nodes = (SArray*)taosArrayInit(len, sizeof(FstNode*));
   taosArrayPush(nodes, &root);
   for (uint32_t i = 0; i < len; i++) {
     uint8_t inp = data[i];
@@ -1000,7 +1003,7 @@ bool fstGet(Fst *fst, FstSlice *b, Output *out) {
   }
 
   for (size_t i = 0; i < taosArrayGetSize(nodes); i++) {
-    FstNode **node = (FstNode **)taosArrayGet(nodes, i);
+    FstNode** node = (FstNode**)taosArrayGet(nodes, i);
     fstNodeDestroy(*node);
   }
   taosArrayDestroy(nodes);
@@ -1010,26 +1013,36 @@ bool fstGet(Fst *fst, FstSlice *b, Output *out) {
 
   return true;
 }
-FstStreamBuilder *fstSearch(Fst *fst, AutomationCtx *ctx) { return fstStreamBuilderCreate(fst, ctx); }
-StreamWithState * streamBuilderIntoStream(FstStreamBuilder *sb) {
+FstStreamBuilder* fstSearch(Fst* fst, AutomationCtx* ctx) {
+  return fstStreamBuilderCreate(fst, ctx);
+}
+StreamWithState* streamBuilderIntoStream(FstStreamBuilder* sb) {
   if (sb == NULL) { return NULL; }
   return streamWithStateCreate(sb->fst, sb->aut, sb->min, sb->max);
 }
-FstStreamWithStateBuilder *fstSearchWithState(Fst *fst, AutomationCtx *ctx) { return fstStreamBuilderCreate(fst, ctx); }
+FstStreamWithStateBuilder* fstSearchWithState(Fst* fst, AutomationCtx* ctx) {
+  return fstStreamBuilderCreate(fst, ctx);
+}
 
-FstNode *fstGetRoot(Fst *fst) {
+FstNode* fstGetRoot(Fst* fst) {
   if (fst->root != NULL) { return fst->root; }
   CompiledAddr rAddr = fstGetRootAddr(fst);
   fst->root = fstGetNode(fst, rAddr);
   return fst->root;
 }
-FstNode *    fstGetNode(Fst *fst, CompiledAddr addr) { return fstNodeCreate(fst->meta->version, addr, fst->data); }
-FstType      fstGetType(Fst *fst) { return fst->meta->ty; }
-CompiledAddr fstGetRootAddr(Fst *fst) { return fst->meta->rootAddr; }
+FstNode* fstGetNode(Fst* fst, CompiledAddr addr) {
+  return fstNodeCreate(fst->meta->version, addr, fst->data);
+}
+FstType fstGetType(Fst* fst) {
+  return fst->meta->ty;
+}
+CompiledAddr fstGetRootAddr(Fst* fst) {
+  return fst->meta->rootAddr;
+}
 
-Output fstEmptyFinalOutput(Fst *fst, bool *null) {
+Output fstEmptyFinalOutput(Fst* fst, bool* null) {
   Output   res = 0;
-  FstNode *node = fstGetRoot(fst);
+  FstNode* node = fstGetRoot(fst);
   if (FST_NODE_IS_FINAL(node)) {
     *null = false;
     res = FST_NODE_FINAL_OUTPUT(node);
@@ -1039,18 +1052,18 @@ Output fstEmptyFinalOutput(Fst *fst, bool *null) {
   return res;
 }
 
-bool fstVerify(Fst *fst) {
+bool fstVerify(Fst* fst) {
   uint32_t checkSum = fst->meta->checkSum;
   int32_t  len;
-  uint8_t *data = fstSliceData(fst->data, &len);
+  uint8_t* data = fstSliceData(fst->data, &len);
   TSCKSUM  initSum = 0;
   if (!taosCheckChecksumWhole(data, len)) { return false; }
   return true;
 }
 
 // data bound function
-FstBoundWithData *fstBoundStateCreate(FstBound type, FstSlice *data) {
-  FstBoundWithData *b = calloc(1, sizeof(FstBoundWithData));
+FstBoundWithData* fstBoundStateCreate(FstBound type, FstSlice* data) {
+  FstBoundWithData* b = calloc(1, sizeof(FstBoundWithData));
   if (b == NULL) { return NULL; }
 
   if (data != NULL) {
@@ -1063,7 +1076,7 @@ FstBoundWithData *fstBoundStateCreate(FstBound type, FstSlice *data) {
   return b;
 }
 
-bool fstBoundWithDataExceededBy(FstBoundWithData *bound, FstSlice *slice) {
+bool fstBoundWithDataExceededBy(FstBoundWithData* bound, FstSlice* slice) {
   int comp = fstSliceCompare(slice, &bound->data);
   if (bound->type == Included) {
     return comp > 0 ? true : false;
@@ -1073,7 +1086,7 @@ bool fstBoundWithDataExceededBy(FstBoundWithData *bound, FstSlice *slice) {
     return true;
   }
 }
-bool fstBoundWithDataIsEmpty(FstBoundWithData *bound) {
+bool fstBoundWithDataIsEmpty(FstBoundWithData* bound) {
   if (bound->type == Unbounded) {
     return true;
   } else {
@@ -1081,29 +1094,32 @@ bool fstBoundWithDataIsEmpty(FstBoundWithData *bound) {
   }
 }
 
-bool fstBoundWithDataIsIncluded(FstBoundWithData *bound) { return bound->type == Excluded ? false : true; }
+bool fstBoundWithDataIsIncluded(FstBoundWithData* bound) {
+  return bound->type == Excluded ? false : true;
+}
 
-void fstBoundDestroy(FstBoundWithData *bound) { free(bound); }
+void fstBoundDestroy(FstBoundWithData* bound) {
+  free(bound);
+}
 
-StreamWithState *streamWithStateCreate(
-    Fst *fst, AutomationCtx *automation, FstBoundWithData *min, FstBoundWithData *max) {
-  StreamWithState *sws = calloc(1, sizeof(StreamWithState));
+StreamWithState* streamWithStateCreate(Fst* fst, AutomationCtx* automation, FstBoundWithData* min, FstBoundWithData* max) {
+  StreamWithState* sws = calloc(1, sizeof(StreamWithState));
   if (sws == NULL) { return NULL; }
 
   sws->fst = fst;
   sws->aut = automation;
-  sws->inp = (SArray *)taosArrayInit(256, sizeof(uint8_t));
+  sws->inp = (SArray*)taosArrayInit(256, sizeof(uint8_t));
 
   sws->emptyOutput.null = false;
   sws->emptyOutput.out = 0;
 
-  sws->stack = (SArray *)taosArrayInit(256, sizeof(StreamState));
+  sws->stack = (SArray*)taosArrayInit(256, sizeof(StreamState));
   sws->endAt = max;
   streamWithStateSeekMin(sws, min);
 
   return sws;
 }
-void streamWithStateDestroy(StreamWithState *sws) {
+void streamWithStateDestroy(StreamWithState* sws) {
   if (sws == NULL) { return; }
 
   taosArrayDestroy(sws->inp);
@@ -1112,20 +1128,18 @@ void streamWithStateDestroy(StreamWithState *sws) {
   free(sws);
 }
 
-bool streamWithStateSeekMin(StreamWithState *sws, FstBoundWithData *min) {
-  AutomationCtx *aut = sws->aut;
+bool streamWithStateSeekMin(StreamWithState* sws, FstBoundWithData* min) {
+  AutomationCtx* aut = sws->aut;
   if (fstBoundWithDataIsEmpty(min)) {
-    if (fstBoundWithDataIsIncluded(min)) {
-      sws->emptyOutput.out = fstEmptyFinalOutput(sws->fst, &(sws->emptyOutput.null));
-    }
+    if (fstBoundWithDataIsIncluded(min)) { sws->emptyOutput.out = fstEmptyFinalOutput(sws->fst, &(sws->emptyOutput.null)); }
     StreamState s = {.node = fstGetRoot(sws->fst),
-        .trans = 0,
-        .out = {.null = false, .out = 0},
-        .autState = automFuncs[aut->type].start(aut)};  // auto.start callback
+                     .trans = 0,
+                     .out = {.null = false, .out = 0},
+                     .autState = automFuncs[aut->type].start(aut)};  // auto.start callback
     taosArrayPush(sws->stack, &s);
     return true;
   }
-  FstSlice *key = NULL;
+  FstSlice* key = NULL;
   bool      inclusize = false;
 
   if (min->type == Included) {
@@ -1137,13 +1151,13 @@ bool streamWithStateSeekMin(StreamWithState *sws, FstBoundWithData *min) {
     return false;
   }
 
-  FstNode *node = fstGetRoot(sws->fst);
+  FstNode* node = fstGetRoot(sws->fst);
   Output   out = 0;
   // void*   autState = sws->aut->start();
-  void *autState = automFuncs[aut->type].start(aut);
+  void* autState = automFuncs[aut->type].start(aut);
 
   int32_t  len;
-  uint8_t *data = fstSliceData(key, &len);
+  uint8_t* data = fstSliceData(key, &len);
   for (uint32_t i = 0; i < len; i++) {
     uint8_t  b = data[i];
     uint64_t res = 0;
@@ -1151,7 +1165,7 @@ bool streamWithStateSeekMin(StreamWithState *sws, FstBoundWithData *min) {
     if (null == false) {
       FstTransition trn;
       fstNodeGetTransitionAt(node, res, &trn);
-      void *preState = autState;
+      void* preState = autState;
       // autState = sws->aut->accept(preState, b);
       autState = automFuncs[aut->type].accept(aut, preState, b);
       taosArrayPush(sws->inp, &b);
@@ -1166,7 +1180,7 @@ bool streamWithStateSeekMin(StreamWithState *sws, FstBoundWithData *min) {
       // Since this is a minimum bound, we need to find the
       // first transition in this node that proceeds the current
       // input byte.
-      FstTransitions *trans = fstNodeTransitions(node);
+      FstTransitions* trans = fstNodeTransitions(node);
       uint64_t        i = 0;
       for (i = trans->range.start; i < trans->range.end; i++) {
         FstTransition trn;
@@ -1180,17 +1194,16 @@ bool streamWithStateSeekMin(StreamWithState *sws, FstBoundWithData *min) {
   }
   uint32_t sz = taosArrayGetSize(sws->stack);
   if (sz != 0) {
-    StreamState *s = taosArrayGet(sws->stack, sz - 1);
+    StreamState* s = taosArrayGet(sws->stack, sz - 1);
     if (inclusize) {
       s->trans -= 1;
       taosArrayPop(sws->inp);
     } else {
-      FstNode *     n = s->node;
+      FstNode*      n = s->node;
       uint64_t      trans = s->trans;
       FstTransition trn;
       fstNodeGetTransitionAt(n, trans - 1, &trn);
-      StreamState s = {
-          .node = fstGetNode(sws->fst, trn.addr), .trans = 0, .out = {.null = false, .out = out}, .autState = autState};
+      StreamState s = {.node = fstGetNode(sws->fst, trn.addr), .trans = 0, .out = {.null = false, .out = out}, .autState = autState};
       taosArrayPush(sws->stack, &s);
       return true;
     }
@@ -1198,25 +1211,25 @@ bool streamWithStateSeekMin(StreamWithState *sws, FstBoundWithData *min) {
   }
 }
 
-StreamWithStateResult *streamWithStateNextWith(StreamWithState *sws, StreamCallback callback) {
-  AutomationCtx *aut = sws->aut;
+StreamWithStateResult* streamWithStateNextWith(StreamWithState* sws, StreamCallback callback) {
+  AutomationCtx* aut = sws->aut;
   FstOutput      output = sws->emptyOutput;
   if (output.null == false) {
     FstSlice emptySlice = fstSliceCreate(NULL, 0);
     if (fstBoundWithDataExceededBy(sws->endAt, &emptySlice)) {
       taosArrayDestroyEx(sws->stack, streamStateDestroy);
-      sws->stack = (SArray *)taosArrayInit(256, sizeof(StreamState));
+      sws->stack = (SArray*)taosArrayInit(256, sizeof(StreamState));
       return NULL;
     }
-    void *start = automFuncs[aut->type].start(aut);
+    void* start = automFuncs[aut->type].start(aut);
     if (automFuncs[aut->type].isMatch(aut, start)) {
       FstSlice s = fstSliceCreate(NULL, 0);
       return swsResultCreate(&s, output, callback(start));
     }
   }
-  SArray *nodes = taosArrayInit(8, sizeof(FstNode *));
+  SArray* nodes = taosArrayInit(8, sizeof(FstNode*));
   while (taosArrayGetSize(sws->stack) > 0) {
-    StreamState *p = (StreamState *)taosArrayPop(sws->stack);
+    StreamState* p = (StreamState*)taosArrayPop(sws->stack);
     if (p->trans >= FST_NODE_LEN(p->node) || !automFuncs[aut->type].canMatch(aut, p->autState)) {
       if (FST_NODE_ADDR(p->node) != fstGetRootAddr(sws->fst)) { taosArrayPop(sws->inp); }
       streamStateDestroy(p);
@@ -1225,16 +1238,16 @@ StreamWithStateResult *streamWithStateNextWith(StreamWithState *sws, StreamCallb
     FstTransition trn;
     fstNodeGetTransitionAt(p->node, p->trans, &trn);
     Output   out = p->out.out + trn.out;
-    void *   nextState = automFuncs[aut->type].accept(aut, p->autState, trn.inp);
-    void *   tState = callback(nextState);
+    void*    nextState = automFuncs[aut->type].accept(aut, p->autState, trn.inp);
+    void*    tState = callback(nextState);
     bool     isMatch = automFuncs[aut->type].isMatch(aut, nextState);
-    FstNode *nextNode = fstGetNode(sws->fst, trn.addr);
+    FstNode* nextNode = fstGetNode(sws->fst, trn.addr);
     taosArrayPush(nodes, &nextNode);
     taosArrayPush(sws->inp, &(trn.inp));
 
     if (FST_NODE_IS_FINAL(nextNode)) {
       // void *eofState = sws->aut->acceptEof(nextState);
-      void *eofState = automFuncs[aut->type].acceptEof(aut, nextState);
+      void* eofState = automFuncs[aut->type].acceptEof(aut, nextState);
       if (eofState != NULL) { isMatch = automFuncs[aut->type].isMatch(aut, eofState); }
     }
     StreamState s1 = {.node = p->node, .trans = p->trans + 1, .out = p->out, .autState = p->autState};
@@ -1244,19 +1257,21 @@ StreamWithStateResult *streamWithStateNextWith(StreamWithState *sws, StreamCallb
     taosArrayPush(sws->stack, &s2);
 
     size_t   isz = taosArrayGetSize(sws->inp);
-    uint8_t *buf = (uint8_t *)malloc(isz * sizeof(uint8_t));
-    for (uint32_t i = 0; i < isz; i++) { buf[i] = *(uint8_t *)taosArrayGet(sws->inp, i); }
+    uint8_t* buf = (uint8_t*)malloc(isz * sizeof(uint8_t));
+    for (uint32_t i = 0; i < isz; i++) {
+      buf[i] = *(uint8_t*)taosArrayGet(sws->inp, i);
+    }
     FstSlice slice = fstSliceCreate(buf, taosArrayGetSize(sws->inp));
     if (fstBoundWithDataExceededBy(sws->endAt, &slice)) {
       taosArrayDestroyEx(sws->stack, streamStateDestroy);
-      sws->stack = (SArray *)taosArrayInit(256, sizeof(StreamState));
+      sws->stack = (SArray*)taosArrayInit(256, sizeof(StreamState));
       free(buf);
       fstSliceDestroy(&slice);
       return NULL;
     }
     if (FST_NODE_IS_FINAL(nextNode) && isMatch) {
       FstOutput              fOutput = {.null = false, .out = out + FST_NODE_FINAL_OUTPUT(nextNode)};
-      StreamWithStateResult *result = swsResultCreate(&slice, fOutput, tState);
+      StreamWithStateResult* result = swsResultCreate(&slice, fOutput, tState);
       free(buf);
       fstSliceDestroy(&slice);
       return result;
@@ -1265,15 +1280,15 @@ StreamWithStateResult *streamWithStateNextWith(StreamWithState *sws, StreamCallb
     fstSliceDestroy(&slice);
   }
   for (size_t i = 0; i < taosArrayGetSize(nodes); i++) {
-    FstNode **node = (FstNode **)taosArrayGet(nodes, i);
+    FstNode** node = (FstNode**)taosArrayGet(nodes, i);
     fstNodeDestroy(*node);
   }
   taosArrayDestroy(nodes);
   return NULL;
 }
 
-StreamWithStateResult *swsResultCreate(FstSlice *data, FstOutput fOut, void *state) {
-  StreamWithStateResult *result = calloc(1, sizeof(StreamWithStateResult));
+StreamWithStateResult* swsResultCreate(FstSlice* data, FstOutput fOut, void* state) {
+  StreamWithStateResult* result = calloc(1, sizeof(StreamWithStateResult));
   if (result == NULL) { return NULL; }
 
   result->data = fstSliceCopy(data, 0, FST_SLICE_LEN(data) - 1);
@@ -1282,7 +1297,7 @@ StreamWithStateResult *swsResultCreate(FstSlice *data, FstOutput fOut, void *sta
 
   return result;
 }
-void swsResultDestroy(StreamWithStateResult *result) {
+void swsResultDestroy(StreamWithStateResult* result) {
   if (NULL == result) { return; }
 
   fstSliceDestroy(&result->data);
@@ -1290,16 +1305,16 @@ void swsResultDestroy(StreamWithStateResult *result) {
   free(result);
 }
 
-void streamStateDestroy(void *s) {
+void streamStateDestroy(void* s) {
   if (NULL == s) { return; }
-  StreamState *ss = (StreamState *)s;
+  StreamState* ss = (StreamState*)s;
 
   fstNodeDestroy(ss->node);
   // free(s->autoState);
 }
 
-FstStreamBuilder *fstStreamBuilderCreate(Fst *fst, AutomationCtx *aut) {
-  FstStreamBuilder *b = calloc(1, sizeof(FstStreamBuilder));
+FstStreamBuilder* fstStreamBuilderCreate(Fst* fst, AutomationCtx* aut) {
+  FstStreamBuilder* b = calloc(1, sizeof(FstStreamBuilder));
   if (NULL == b) { return NULL; }
 
   b->fst = fst;
@@ -1308,14 +1323,14 @@ FstStreamBuilder *fstStreamBuilderCreate(Fst *fst, AutomationCtx *aut) {
   b->max = fstBoundStateCreate(Unbounded, NULL);
   return b;
 }
-void fstStreamBuilderDestroy(FstStreamBuilder *b) {
+void fstStreamBuilderDestroy(FstStreamBuilder* b) {
   fstSliceDestroy(&b->min->data);
   tfree(b->min);
   fstSliceDestroy(&b->max->data);
   tfree(b->max);
   free(b);
 }
-FstStreamBuilder *fstStreamBuilderRange(FstStreamBuilder *b, FstSlice *val, RangeType type) {
+FstStreamBuilder* fstStreamBuilderRange(FstStreamBuilder* b, FstSlice* val, RangeType type) {
   if (b == NULL) { return NULL; }
 
   if (type == GE) {
diff --git a/source/libs/index/src/index_fst_automation.c b/source/libs/index/src/index_fst_automation.c
index cf3165709c..eb4c479c94 100644
--- a/source/libs/index/src/index_fst_automation.c
+++ b/source/libs/index/src/index_fst_automation.c
@@ -15,19 +15,17 @@
 
 #include "index_fst_automation.h"
 
-StartWithStateValue *startWithStateValueCreate(StartWithStateKind kind, ValueType ty, void *val) {
-  StartWithStateValue *nsv = calloc(1, sizeof(StartWithStateValue));
-  if (nsv == NULL) {
-    return NULL;
-  }
+StartWithStateValue* startWithStateValueCreate(StartWithStateKind kind, ValueType ty, void* val) {
+  StartWithStateValue* nsv = calloc(1, sizeof(StartWithStateValue));
+  if (nsv == NULL) { return NULL; }
 
   nsv->kind = kind;
   nsv->type = ty;
   if (ty == FST_INT) {
-    nsv->val = *(int *)val;
+    nsv->val = *(int*)val;
   } else if (ty == FST_CHAR) {
-    size_t len = strlen((char *)val);
-    nsv->ptr = (char *)calloc(1, len + 1);
+    size_t len = strlen((char*)val);
+    nsv->ptr = (char*)calloc(1, len + 1);
     memcpy(nsv->ptr, val, len);
   } else if (ty == FST_ARRAY) {
     // TODO,
@@ -35,11 +33,9 @@ StartWithStateValue *startWithStateValueCreate(StartWithStateKind kind, ValueTyp
   }
   return nsv;
 }
-void startWithStateValueDestroy(void *val) {
-  StartWithStateValue *sv = (StartWithStateValue *)val;
-  if (sv == NULL) {
-    return;
-  }
+void startWithStateValueDestroy(void* val) {
+  StartWithStateValue* sv = (StartWithStateValue*)val;
+  if (sv == NULL) { return; }
 
   if (sv->type == FST_INT) {
     //
@@ -50,11 +46,9 @@ void startWithStateValueDestroy(void *val) {
   }
   free(sv);
 }
-StartWithStateValue *startWithStateValueDump(StartWithStateValue *sv) {
-  StartWithStateValue *nsv = calloc(1, sizeof(StartWithStateValue));
-  if (nsv == NULL) {
-    return NULL;
-  }
+StartWithStateValue* startWithStateValueDump(StartWithStateValue* sv) {
+  StartWithStateValue* nsv = calloc(1, sizeof(StartWithStateValue));
+  if (nsv == NULL) { return NULL; }
 
   nsv->kind = sv->kind;
   nsv->type = sv->type;
@@ -62,41 +56,40 @@ StartWithStateValue *startWithStateValueDump(StartWithStateValue *sv) {
     nsv->val = sv->val;
   } else if (nsv->type == FST_CHAR) {
     size_t len = strlen(sv->ptr);
-    nsv->ptr = (char *)calloc(1, len + 1);
+    nsv->ptr = (char*)calloc(1, len + 1);
     memcpy(nsv->ptr, sv->ptr, len);
   } else if (nsv->type == FST_ARRAY) {
+    //
   }
   return nsv;
 }
 
 // prefix query, impl later
 
-static void *prefixStart(AutomationCtx *ctx) {
-  StartWithStateValue *data = (StartWithStateValue *)(ctx->stdata);
+static void* prefixStart(AutomationCtx* ctx) {
+  StartWithStateValue* data = (StartWithStateValue*)(ctx->stdata);
   return startWithStateValueDump(data);
 };
-static bool prefixIsMatch(AutomationCtx *ctx, void *sv) {
-  StartWithStateValue *ssv = (StartWithStateValue *)sv;
+static bool prefixIsMatch(AutomationCtx* ctx, void* sv) {
+  StartWithStateValue* ssv = (StartWithStateValue*)sv;
   return ssv->val == strlen(ctx->data);
 }
-static bool prefixCanMatch(AutomationCtx *ctx, void *sv) {
-  StartWithStateValue *ssv = (StartWithStateValue *)sv;
+static bool prefixCanMatch(AutomationCtx* ctx, void* sv) {
+  StartWithStateValue* ssv = (StartWithStateValue*)sv;
   return ssv->val >= 0;
 }
-static bool  prefixWillAlwaysMatch(AutomationCtx *ctx, void *state) { return true; }
-static void *prefixAccept(AutomationCtx *ctx, void *state, uint8_t byte) {
-  StartWithStateValue *ssv = (StartWithStateValue *)state;
-  if (ssv == NULL || ctx == NULL) {
-    return NULL;
-  }
+static bool prefixWillAlwaysMatch(AutomationCtx* ctx, void* state) {
+  return true;
+}
+static void* prefixAccept(AutomationCtx* ctx, void* state, uint8_t byte) {
+  StartWithStateValue* ssv = (StartWithStateValue*)state;
+  if (ssv == NULL || ctx == NULL) { return NULL; }
 
-  char *data = ctx->data;
-  if (ssv->kind == Done) {
-    return startWithStateValueCreate(Done, FST_INT, &ssv->val);
-  }
+  char* data = ctx->data;
+  if (ssv->kind == Done) { return startWithStateValueCreate(Done, FST_INT, &ssv->val); }
   if ((strlen(data) > ssv->val) && data[ssv->val] == byte) {
     int                  val = ssv->val + 1;
-    StartWithStateValue *nsv = startWithStateValueCreate(Running, FST_INT, &val);
+    StartWithStateValue* nsv = startWithStateValueCreate(Running, FST_INT, &val);
     if (prefixIsMatch(ctx, nsv)) {
       nsv->kind = Done;
     } else {
@@ -106,18 +99,32 @@ static void *prefixAccept(AutomationCtx *ctx, void *state, uint8_t byte) {
   }
   return NULL;
 }
-static void *prefixAcceptEof(AutomationCtx *ctx, void *state) { return NULL; }
+static void* prefixAcceptEof(AutomationCtx* ctx, void* state) {
+  return NULL;
+}
 
 // pattern query, impl later
 
-static void *patternStart(AutomationCtx *ctx) { return NULL; }
-static bool  patternIsMatch(AutomationCtx *ctx, void *data) { return true; }
-static bool  patternCanMatch(AutomationCtx *ctx, void *data) { return true; }
-static bool  patternWillAlwaysMatch(AutomationCtx *ctx, void *state) { return true; }
+static void* patternStart(AutomationCtx* ctx) {
+  return NULL;
+}
+static bool patternIsMatch(AutomationCtx* ctx, void* data) {
+  return true;
+}
+static bool patternCanMatch(AutomationCtx* ctx, void* data) {
+  return true;
+}
+static bool patternWillAlwaysMatch(AutomationCtx* ctx, void* state) {
+  return true;
+}
 
-static void *patternAccept(AutomationCtx *ctx, void *state, uint8_t byte) { return NULL; }
+static void* patternAccept(AutomationCtx* ctx, void* state, uint8_t byte) {
+  return NULL;
+}
 
-static void *patternAcceptEof(AutomationCtx *ctx, void *state) { return NULL; }
+static void* patternAcceptEof(AutomationCtx* ctx, void* state) {
+  return NULL;
+}
 
 AutomationFunc automFuncs[] = {
     {prefixStart, prefixIsMatch, prefixCanMatch, prefixWillAlwaysMatch, prefixAccept, prefixAcceptEof},
@@ -125,34 +132,32 @@ AutomationFunc automFuncs[] = {
     // add more search type
 };
 
-AutomationCtx *automCtxCreate(void *data, AutomationType atype) {
-  AutomationCtx *ctx = calloc(1, sizeof(AutomationCtx));
-  if (ctx == NULL) {
-    return NULL;
-  }
+AutomationCtx* automCtxCreate(void* data, AutomationType atype) {
+  AutomationCtx* ctx = calloc(1, sizeof(AutomationCtx));
+  if (ctx == NULL) { return NULL; }
 
-  StartWithStateValue *sv = NULL;
+  StartWithStateValue* sv = NULL;
   if (atype == AUTOMATION_PREFIX) {
     int val = 0;
     sv = startWithStateValueCreate(Running, FST_INT, &val);
-    ctx->stdata = (void *)sv;
+    ctx->stdata = (void*)sv;
   } else if (atype == AUTMMATION_MATCH) {
   } else {
     // add more search type
   }
 
-  char * src = (char *)data;
+  char*  src = (char*)data;
   size_t len = strlen(src);
-  char * dst = (char *)malloc(len * sizeof(char) + 1);
+  char*  dst = (char*)malloc(len * sizeof(char) + 1);
   memcpy(dst, src, len);
   dst[len] = 0;
 
   ctx->data = dst;
   ctx->type = atype;
-  ctx->stdata = (void *)sv;
+  ctx->stdata = (void*)sv;
   return ctx;
 }
-void automCtxDestroy(AutomationCtx *ctx) {
+void automCtxDestroy(AutomationCtx* ctx) {
   startWithStateValueDestroy(ctx->stdata);
   free(ctx->data);
   free(ctx);
diff --git a/source/libs/index/src/index_fst_common.c b/source/libs/index/src/index_fst_common.c
index ee3b07713d..2d7586e8d9 100644
--- a/source/libs/index/src/index_fst_common.c
+++ b/source/libs/index/src/index_fst_common.c
@@ -274,260 +274,20 @@ const uint8_t COMMON_INPUTS[] = {
 };
 
 const char COMMON_INPUTS_INV[] = {
-    't',
-    'e',
-    '/',
-    'o',
-    'a',
-    's',
-    'r',
-    'i',
-    'p',
-    'c',
-    'n',
-    'w',
-    '.',
-    'h',
-    'l',
-    'm',
-    '-',
-    'd',
-    'u',
-    '0',
-    '1',
-    '2',
-    'g',
-    '=',
-    ':',
-    'b',
-    'f',
-    '3',
-    'y',
-    '5',
-    '&',
-    '_',
-    '4',
-    'v',
-    '9',
-    '6',
-    '7',
-    '8',
-    'k',
-    '%',
-    '?',
-    'x',
-    'C',
-    'D',
-    'A',
-    'S',
-    'F',
-    'I',
-    'B',
-    'E',
-    'j',
-    'P',
-    'T',
-    'z',
-    'R',
-    'N',
-    'M',
-    '+',
-    'L',
-    'O',
-    'q',
-    'H',
-    'G',
-    'W',
-    'U',
-    'V',
-    ',',
-    'Y',
-    'K',
-    'J',
-    'Z',
-    'X',
-    'Q',
-    ';',
-    ')',
-    '(',
-    '~',
-    '[',
-    ']',
-    '$',
-    '!',
-    '\'',
-    '*',
-    '@',
-    '\x00',
-    '\x01',
-    '\x02',
-    '\x03',
-    '\x04',
-    '\x05',
-    '\x06',
-    '\x07',
-    '\x08',
-    '\t',
-    '\n',
-    '\x0b',
-    '\x0c',
-    '\r',
-    '\x0e',
-    '\x0f',
-    '\x10',
-    '\x11',
-    '\x12',
-    '\x13',
-    '\x14',
-    '\x15',
-    '\x16',
-    '\x17',
-    '\x18',
-    '\x19',
-    '\x1a',
-    '\x1b',
-    '\x1c',
-    '\x1d',
-    '\x1e',
-    '\x1f',
-    ' ',
-    '"',
-    '#',
-    '<',
-    '>',
-    '\\',
-    '^',
-    '`',
-    '{',
-    '|',
-    '}',
-    '\x7f',
-    '\x80',
-    '\x81',
-    '\x82',
-    '\x83',
-    '\x84',
-    '\x85',
-    '\x86',
-    '\x87',
-    '\x88',
-    '\x89',
-    '\x8a',
-    '\x8b',
-    '\x8c',
-    '\x8d',
-    '\x8e',
-    '\x8f',
-    '\x90',
-    '\x91',
-    '\x92',
-    '\x93',
-    '\x94',
-    '\x95',
-    '\x96',
-    '\x97',
-    '\x98',
-    '\x99',
-    '\x9a',
-    '\x9b',
-    '\x9c',
-    '\x9d',
-    '\x9e',
-    '\x9f',
-    '\xa0',
-    '\xa1',
-    '\xa2',
-    '\xa3',
-    '\xa4',
-    '\xa5',
-    '\xa6',
-    '\xa7',
-    '\xa8',
-    '\xa9',
-    '\xaa',
-    '\xab',
-    '\xac',
-    '\xad',
-    '\xae',
-    '\xaf',
-    '\xb0',
-    '\xb1',
-    '\xb2',
-    '\xb3',
-    '\xb4',
-    '\xb5',
-    '\xb6',
-    '\xb7',
-    '\xb8',
-    '\xb9',
-    '\xba',
-    '\xbb',
-    '\xbc',
-    '\xbd',
-    '\xbe',
-    '\xbf',
-    '\xc0',
-    '\xc1',
-    '\xc2',
-    '\xc3',
-    '\xc4',
-    '\xc5',
-    '\xc6',
-    '\xc7',
-    '\xc8',
-    '\xc9',
-    '\xca',
-    '\xcb',
-    '\xcc',
-    '\xcd',
-    '\xce',
-    '\xcf',
-    '\xd0',
-    '\xd1',
-    '\xd2',
-    '\xd3',
-    '\xd4',
-    '\xd5',
-    '\xd6',
-    '\xd7',
-    '\xd8',
-    '\xd9',
-    '\xda',
-    '\xdb',
-    '\xdc',
-    '\xdd',
-    '\xde',
-    '\xdf',
-    '\xe0',
-    '\xe1',
-    '\xe2',
-    '\xe3',
-    '\xe4',
-    '\xe5',
-    '\xe6',
-    '\xe7',
-    '\xe8',
-    '\xe9',
-    '\xea',
-    '\xeb',
-    '\xec',
-    '\xed',
-    '\xee',
-    '\xef',
-    '\xf0',
-    '\xf1',
-    '\xf2',
-    '\xf3',
-    '\xf4',
-    '\xf5',
-    '\xf6',
-    '\xf7',
-    '\xf8',
-    '\xf9',
-    '\xfa',
-    '\xfb',
-    '\xfc',
-    '\xfd',
-    '\xfe',
-    '\xff',
+    't',    'e',    '/',    'o',    'a',    's',    'r',    'i',    'p',    'c',    'n',    'w',    '.',    'h',    'l',    'm',
+    '-',    'd',    'u',    '0',    '1',    '2',    'g',    '=',    ':',    'b',    'f',    '3',    'y',    '5',    '&',    '_',
+    '4',    'v',    '9',    '6',    '7',    '8',    'k',    '%',    '?',    'x',    'C',    'D',    'A',    'S',    'F',    'I',
+    'B',    'E',    'j',    'P',    'T',    'z',    'R',    'N',    'M',    '+',    'L',    'O',    'q',    'H',    'G',    'W',
+    'U',    'V',    ',',    'Y',    'K',    'J',    'Z',    'X',    'Q',    ';',    ')',    '(',    '~',    '[',    ']',    '$',
+    '!',    '\'',   '*',    '@',    '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08', '\t',   '\n',   '\x0b',
+    '\x0c', '\r',   '\x0e', '\x0f', '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1a', '\x1b',
+    '\x1c', '\x1d', '\x1e', '\x1f', ' ',    '"',    '#',    '<',    '>',    '\\',   '^',    '`',    '{',    '|',    '}',    '\x7f',
+    '\x80', '\x81', '\x82', '\x83', '\x84', '\x85', '\x86', '\x87', '\x88', '\x89', '\x8a', '\x8b', '\x8c', '\x8d', '\x8e', '\x8f',
+    '\x90', '\x91', '\x92', '\x93', '\x94', '\x95', '\x96', '\x97', '\x98', '\x99', '\x9a', '\x9b', '\x9c', '\x9d', '\x9e', '\x9f',
+    '\xa0', '\xa1', '\xa2', '\xa3', '\xa4', '\xa5', '\xa6', '\xa7', '\xa8', '\xa9', '\xaa', '\xab', '\xac', '\xad', '\xae', '\xaf',
+    '\xb0', '\xb1', '\xb2', '\xb3', '\xb4', '\xb5', '\xb6', '\xb7', '\xb8', '\xb9', '\xba', '\xbb', '\xbc', '\xbd', '\xbe', '\xbf',
+    '\xc0', '\xc1', '\xc2', '\xc3', '\xc4', '\xc5', '\xc6', '\xc7', '\xc8', '\xc9', '\xca', '\xcb', '\xcc', '\xcd', '\xce', '\xcf',
+    '\xd0', '\xd1', '\xd2', '\xd3', '\xd4', '\xd5', '\xd6', '\xd7', '\xd8', '\xd9', '\xda', '\xdb', '\xdc', '\xdd', '\xde', '\xdf',
+    '\xe0', '\xe1', '\xe2', '\xe3', '\xe4', '\xe5', '\xe6', '\xe7', '\xe8', '\xe9', '\xea', '\xeb', '\xec', '\xed', '\xee', '\xef',
+    '\xf0', '\xf1', '\xf2', '\xf3', '\xf4', '\xf5', '\xf6', '\xf7', '\xf8', '\xf9', '\xfa', '\xfb', '\xfc', '\xfd', '\xfe', '\xff',
 };
diff --git a/source/libs/index/src/index_fst_counting_writer.c b/source/libs/index/src/index_fst_counting_writer.c
index 6438654ee3..60d717efc6 100644
--- a/source/libs/index/src/index_fst_counting_writer.c
+++ b/source/libs/index/src/index_fst_counting_writer.c
@@ -17,7 +17,7 @@
 #include "index_fst_util.h"
 #include "tutil.h"
 
-static int writeCtxDoWrite(WriterCtx *ctx, uint8_t *buf, int len) {
+static int writeCtxDoWrite(WriterCtx* ctx, uint8_t* buf, int len) {
   if (ctx->offset + len > ctx->limit) { return -1; }
 
   if (ctx->type == TFile) {
@@ -28,7 +28,7 @@ static int writeCtxDoWrite(WriterCtx *ctx, uint8_t *buf, int len) {
   ctx->offset += len;
   return len;
 }
-static int writeCtxDoRead(WriterCtx *ctx, uint8_t *buf, int len) {
+static int writeCtxDoRead(WriterCtx* ctx, uint8_t* buf, int len) {
   int nRead = 0;
   if (ctx->type == TFile) {
     nRead = tfRead(ctx->file.fd, buf, len);
@@ -39,7 +39,7 @@ static int writeCtxDoRead(WriterCtx *ctx, uint8_t *buf, int len) {
 
   return nRead;
 }
-static int writeCtxDoFlush(WriterCtx *ctx) {
+static int writeCtxDoFlush(WriterCtx* ctx) {
   if (ctx->type == TFile) {
     // tfFsync(ctx->fd);
     // tfFlush(ctx->file.fd);
@@ -49,8 +49,8 @@ static int writeCtxDoFlush(WriterCtx *ctx) {
   return 1;
 }
 
-WriterCtx *writerCtxCreate(WriterType type, const char *path, bool readOnly, int32_t capacity) {
-  WriterCtx *ctx = calloc(1, sizeof(WriterCtx));
+WriterCtx* writerCtxCreate(WriterType type, const char* path, bool readOnly, int32_t capacity) {
+  WriterCtx* ctx = calloc(1, sizeof(WriterCtx));
   if (ctx == NULL) { return NULL; }
 
   ctx->type = type;
@@ -82,7 +82,7 @@ END:
   if (ctx->type == TMemory) { free(ctx->mem.buf); }
   free(ctx);
 }
-void writerCtxDestroy(WriterCtx *ctx) {
+void writerCtxDestroy(WriterCtx* ctx) {
   if (ctx->type == TMemory) {
     free(ctx->mem.buf);
   } else {
@@ -91,51 +91,53 @@ void writerCtxDestroy(WriterCtx *ctx) {
   free(ctx);
 }
 
-FstCountingWriter *fstCountingWriterCreate(void *wrt) {
-  FstCountingWriter *cw = calloc(1, sizeof(FstCountingWriter));
+FstCountingWriter* fstCountingWriterCreate(void* wrt) {
+  FstCountingWriter* cw = calloc(1, sizeof(FstCountingWriter));
   if (cw == NULL) { return NULL; }
 
   cw->wrt = wrt;
   //(void *)(writerCtxCreate(TFile, readOnly));
   return cw;
 }
-void fstCountingWriterDestroy(FstCountingWriter *cw) {
+void fstCountingWriterDestroy(FstCountingWriter* cw) {
   // free wrt object: close fd or free mem
   fstCountingWriterFlush(cw);
   // writerCtxDestroy((WriterCtx *)(cw->wrt));
   free(cw);
 }
 
-int fstCountingWriterWrite(FstCountingWriter *write, uint8_t *buf, uint32_t len) {
+int fstCountingWriterWrite(FstCountingWriter* write, uint8_t* buf, uint32_t len) {
   if (write == NULL) { return 0; }
   // update checksum
   // write data to file/socket or mem
-  WriterCtx *ctx = write->wrt;
+  WriterCtx* ctx = write->wrt;
 
   int nWrite = ctx->write(ctx, buf, len);
   assert(nWrite == len);
   write->count += len;
   return len;
 }
-int fstCountingWriterRead(FstCountingWriter *write, uint8_t *buf, uint32_t len) {
+int fstCountingWriterRead(FstCountingWriter* write, uint8_t* buf, uint32_t len) {
   if (write == NULL) { return 0; }
-  WriterCtx *ctx = write->wrt;
+  WriterCtx* ctx = write->wrt;
   int        nRead = ctx->read(ctx, buf, len);
   // assert(nRead == len);
   return nRead;
 }
 
-uint32_t fstCountingWriterMaskedCheckSum(FstCountingWriter *write) { return 0; }
-int      fstCountingWriterFlush(FstCountingWriter *write) {
-  WriterCtx *ctx = write->wrt;
+uint32_t fstCountingWriterMaskedCheckSum(FstCountingWriter* write) {
+  return 0;
+}
+int fstCountingWriterFlush(FstCountingWriter* write) {
+  WriterCtx* ctx = write->wrt;
   ctx->flush(ctx);
   // write->wtr->flush
   return 1;
 }
 
-void fstCountingWriterPackUintIn(FstCountingWriter *writer, uint64_t n, uint8_t nBytes) {
+void fstCountingWriterPackUintIn(FstCountingWriter* writer, uint64_t n, uint8_t nBytes) {
   assert(1 <= nBytes && nBytes <= 8);
-  uint8_t *buf = calloc(8, sizeof(uint8_t));
+  uint8_t* buf = calloc(8, sizeof(uint8_t));
   for (uint8_t i = 0; i < nBytes; i++) {
     buf[i] = (uint8_t)n;
     n = n >> 8;
@@ -145,7 +147,7 @@ void fstCountingWriterPackUintIn(FstCountingWriter *writer, uint64_t n, uint8_t
   return;
 }
 
-uint8_t fstCountingWriterPackUint(FstCountingWriter *writer, uint64_t n) {
+uint8_t fstCountingWriterPackUint(FstCountingWriter* writer, uint64_t n) {
   uint8_t nBytes = packSize(n);
   fstCountingWriterPackUintIn(writer, n, nBytes);
   return nBytes;
diff --git a/source/libs/index/src/index_fst_node.c b/source/libs/index/src/index_fst_node.c
index 084f280bc3..5cdf6adb31 100644
--- a/source/libs/index/src/index_fst_node.c
+++ b/source/libs/index/src/index_fst_node.c
@@ -14,60 +14,46 @@
  */
 #include "index_fst_node.h"
 
-FstBuilderNode *fstBuilderNodeDefault() {
-  FstBuilderNode *bn = malloc(sizeof(FstBuilderNode));
+FstBuilderNode* fstBuilderNodeDefault() {
+  FstBuilderNode* bn = malloc(sizeof(FstBuilderNode));
   bn->isFinal = false;
   bn->finalOutput = 0;
   bn->trans = taosArrayInit(16, sizeof(FstTransition));
   return bn;
 }
-void fstBuilderNodeDestroy(FstBuilderNode *node) {
-  if (node == NULL) {
-    return;
-  }
+void fstBuilderNodeDestroy(FstBuilderNode* node) {
+  if (node == NULL) { return; }
 
   taosArrayDestroy(node->trans);
   free(node);
 }
 
-bool fstBuilderNodeEqual(FstBuilderNode *n1, FstBuilderNode *n2) {
-  if (n1 == n2) {
-    return true;
-  }
-  if (n1 == NULL || n2 == NULL) {
-    return false;
-  }
+bool fstBuilderNodeEqual(FstBuilderNode* n1, FstBuilderNode* n2) {
+  if (n1 == n2) { return true; }
+  if (n1 == NULL || n2 == NULL) { return false; }
 
-  if (n1->isFinal != n2->isFinal || n1->finalOutput != n2->finalOutput) {
-    return false;
-  }
+  if (n1->isFinal != n2->isFinal || n1->finalOutput != n2->finalOutput) { return false; }
   size_t s1 = n1->trans ? taosArrayGetSize(n1->trans) : 0;
   size_t s2 = n2->trans ? taosArrayGetSize(n2->trans) : 0;
-  if (s1 != s2) {
-    return false;
-  }
+  if (s1 != s2) { return false; }
   for (size_t i = 0; i < s1; i++) {
-    FstTransition *t1 = taosArrayGet(n1->trans, i);
-    FstTransition *t2 = taosArrayGet(n2->trans, i);
-    if (t1->inp != t2->inp || t1->out != t2->out || t1->addr != t2->addr) {
-      return false;
-    }
+    FstTransition* t1 = taosArrayGet(n1->trans, i);
+    FstTransition* t2 = taosArrayGet(n2->trans, i);
+    if (t1->inp != t2->inp || t1->out != t2->out || t1->addr != t2->addr) { return false; }
   }
 
   return true;
 }
-FstBuilderNode *fstBuilderNodeClone(FstBuilderNode *src) {
-  FstBuilderNode *node = malloc(sizeof(FstBuilderNode));
-  if (node == NULL) {
-    return NULL;
-  }
+FstBuilderNode* fstBuilderNodeClone(FstBuilderNode* src) {
+  FstBuilderNode* node = malloc(sizeof(FstBuilderNode));
+  if (node == NULL) { return NULL; }
 
   //
   size_t  sz = taosArrayGetSize(src->trans);
-  SArray *trans = taosArrayInit(sz, sizeof(FstTransition));
+  SArray* trans = taosArrayInit(sz, sizeof(FstTransition));
 
   for (size_t i = 0; i < sz; i++) {
-    FstTransition *tran = taosArrayGet(src->trans, i);
+    FstTransition* tran = taosArrayGet(src->trans, i);
     taosArrayPush(trans, tran);
   }
 
@@ -77,10 +63,8 @@ FstBuilderNode *fstBuilderNodeClone(FstBuilderNode *src) {
   return node;
 }
 // not destroy src, User's bussiness
-void fstBuilderNodeCloneFrom(FstBuilderNode *dst, FstBuilderNode *src) {
-  if (dst == NULL || src == NULL) {
-    return;
-  }
+void fstBuilderNodeCloneFrom(FstBuilderNode* dst, FstBuilderNode* src) {
+  if (dst == NULL || src == NULL) { return; }
 
   dst->isFinal = src->isFinal;
   dst->finalOutput = src->finalOutput;
@@ -90,7 +74,7 @@ void fstBuilderNodeCloneFrom(FstBuilderNode *dst, FstBuilderNode *src) {
   size_t sz = taosArrayGetSize(src->trans);
   dst->trans = taosArrayInit(sz, sizeof(FstTransition));
   for (size_t i = 0; i < sz; i++) {
-    FstTransition *trn = taosArrayGet(src->trans, i);
+    FstTransition* trn = taosArrayGet(src->trans, i);
     taosArrayPush(dst->trans, trn);
   }
 }
diff --git a/source/libs/index/src/index_fst_registry.c b/source/libs/index/src/index_fst_registry.c
index dffbc820c8..07afc52ecf 100644
--- a/source/libs/index/src/index_fst_registry.c
+++ b/source/libs/index/src/index_fst_registry.c
@@ -15,7 +15,7 @@
 
 #include "index_fst_registry.h"
 
-uint64_t fstRegistryHash(FstRegistry *registry, FstBuilderNode *bNode) {
+uint64_t fstRegistryHash(FstRegistry* registry, FstBuilderNode* bNode) {
   // TODO(yihaoDeng): refactor later
   const uint64_t FNV_PRIME = 1099511628211;
   uint64_t       h = 14695981039346656037u;
@@ -25,19 +25,19 @@ uint64_t fstRegistryHash(FstRegistry *registry, FstBuilderNode *bNode) {
 
   uint32_t sz = (uint32_t)taosArrayGetSize(bNode->trans);
   for (uint32_t i = 0; i < sz; i++) {
-    FstTransition *trn = taosArrayGet(bNode->trans, i);
+    FstTransition* trn = taosArrayGet(bNode->trans, i);
     h = (h ^ (uint64_t)(trn->inp)) * FNV_PRIME;
     h = (h ^ (uint64_t)(trn->out)) * FNV_PRIME;
     h = (h ^ (uint64_t)(trn->addr)) * FNV_PRIME;
   }
   return h % (registry->tableSize);
 }
-static void fstRegistryCellSwap(SArray *arr, uint32_t a, uint32_t b) {
+static void fstRegistryCellSwap(SArray* arr, uint32_t a, uint32_t b) {
   size_t sz = taosArrayGetSize(arr);
   if (a >= sz || b >= sz) { return; }
 
-  FstRegistryCell *cell1 = (FstRegistryCell *)taosArrayGet(arr, a);
-  FstRegistryCell *cell2 = (FstRegistryCell *)taosArrayGet(arr, b);
+  FstRegistryCell* cell1 = (FstRegistryCell*)taosArrayGet(arr, a);
+  FstRegistryCell* cell2 = (FstRegistryCell*)taosArrayGet(arr, b);
 
   FstRegistryCell t = {.addr = cell1->addr, .node = cell1->node};
 
@@ -49,7 +49,7 @@ static void fstRegistryCellSwap(SArray *arr, uint32_t a, uint32_t b) {
   return;
 }
 
-static void fstRegistryCellPromote(SArray *arr, uint32_t start, uint32_t end) {
+static void fstRegistryCellPromote(SArray* arr, uint32_t start, uint32_t end) {
   size_t sz = taosArrayGetSize(arr);
   if (start >= sz && end >= sz) { return; }
 
@@ -63,12 +63,12 @@ static void fstRegistryCellPromote(SArray *arr, uint32_t start, uint32_t end) {
   }
 }
 
-FstRegistry *fstRegistryCreate(uint64_t tableSize, uint64_t mruSize) {
-  FstRegistry *registry = malloc(sizeof(FstRegistry));
+FstRegistry* fstRegistryCreate(uint64_t tableSize, uint64_t mruSize) {
+  FstRegistry* registry = malloc(sizeof(FstRegistry));
   if (registry == NULL) { return NULL; }
 
   uint64_t nCells = tableSize * mruSize;
-  SArray * tb = (SArray *)taosArrayInit(nCells, sizeof(FstRegistryCell));
+  SArray*  tb = (SArray*)taosArrayInit(nCells, sizeof(FstRegistryCell));
   if (NULL == tb) {
     free(registry);
     return NULL;
@@ -85,28 +85,28 @@ FstRegistry *fstRegistryCreate(uint64_t tableSize, uint64_t mruSize) {
   return registry;
 }
 
-void fstRegistryDestroy(FstRegistry *registry) {
+void fstRegistryDestroy(FstRegistry* registry) {
   if (registry == NULL) { return; }
 
-  SArray *tb = registry->table;
+  SArray* tb = registry->table;
   size_t  sz = taosArrayGetSize(tb);
   for (size_t i = 0; i < sz; i++) {
-    FstRegistryCell *cell = taosArrayGet(tb, i);
+    FstRegistryCell* cell = taosArrayGet(tb, i);
     fstBuilderNodeDestroy(cell->node);
   }
   taosArrayDestroy(tb);
   free(registry);
 }
 
-FstRegistryEntry *fstRegistryGetEntry(FstRegistry *registry, FstBuilderNode *bNode) {
+FstRegistryEntry* fstRegistryGetEntry(FstRegistry* registry, FstBuilderNode* bNode) {
   if (taosArrayGetSize(registry->table) <= 0) { return NULL; }
   uint64_t bucket = fstRegistryHash(registry, bNode);
   uint64_t start = registry->mruSize * bucket;
   uint64_t end = start + registry->mruSize;
 
-  FstRegistryEntry *entry = malloc(sizeof(FstRegistryEntry));
+  FstRegistryEntry* entry = malloc(sizeof(FstRegistryEntry));
   if (end - start == 1) {
-    FstRegistryCell *cell = taosArrayGet(registry->table, start);
+    FstRegistryCell* cell = taosArrayGet(registry->table, start);
     // cell->isNode &&
     if (cell->addr != NONE_ADDRESS && fstBuilderNodeEqual(cell->node, bNode)) {
       entry->state = FOUND;
@@ -118,13 +118,13 @@ FstRegistryEntry *fstRegistryGetEntry(FstRegistry *registry, FstBuilderNode *bNo
       entry->cell = cell;  // copy or not
     }
   } else if (end - start == 2) {
-    FstRegistryCell *cell1 = taosArrayGet(registry->table, start);
+    FstRegistryCell* cell1 = taosArrayGet(registry->table, start);
     if (cell1->addr != NONE_ADDRESS && fstBuilderNodeEqual(cell1->node, bNode)) {
       entry->state = FOUND;
       entry->addr = cell1->addr;
       return entry;
     }
-    FstRegistryCell *cell2 = taosArrayGet(registry->table, start + 1);
+    FstRegistryCell* cell2 = taosArrayGet(registry->table, start + 1);
     if (cell2->addr != NONE_ADDRESS && fstBuilderNodeEqual(cell2->node, bNode)) {
       entry->state = FOUND;
       entry->addr = cell2->addr;
@@ -136,13 +136,13 @@ FstRegistryEntry *fstRegistryGetEntry(FstRegistry *registry, FstBuilderNode *bNo
     fstBuilderNodeCloneFrom(cell2->node, bNode);
 
     fstRegistryCellSwap(registry->table, start, start + 1);
-    FstRegistryCell *cCell = taosArrayGet(registry->table, start);
+    FstRegistryCell* cCell = taosArrayGet(registry->table, start);
     entry->state = NOTFOUND;
     entry->cell = cCell;
   } else {
     uint32_t i = start;
     for (; i < end; i++) {
-      FstRegistryCell *cell = (FstRegistryCell *)taosArrayGet(registry->table, i);
+      FstRegistryCell* cell = (FstRegistryCell*)taosArrayGet(registry->table, i);
       if (cell->addr != NONE_ADDRESS && fstBuilderNodeEqual(cell->node, bNode)) {
         entry->state = FOUND;
         entry->addr = cell->addr;
@@ -152,16 +152,18 @@ FstRegistryEntry *fstRegistryGetEntry(FstRegistry *registry, FstBuilderNode *bNo
     }
     if (i >= end) {
       uint64_t         last = end - 1;
-      FstRegistryCell *cell = (FstRegistryCell *)taosArrayGet(registry->table, last);
+      FstRegistryCell* cell = (FstRegistryCell*)taosArrayGet(registry->table, last);
       // clone from bNode, refactor later
       fstBuilderNodeCloneFrom(cell->node, bNode);
 
       fstRegistryCellPromote(registry->table, last, start);
-      FstRegistryCell *cCell = taosArrayGet(registry->table, start);
+      FstRegistryCell* cCell = taosArrayGet(registry->table, start);
       entry->state = NOTFOUND;
       entry->cell = cCell;
     }
   }
   return entry;
 }
-void fstRegistryEntryDestroy(FstRegistryEntry *entry) { free(entry); }
+void fstRegistryEntryDestroy(FstRegistryEntry* entry) {
+  free(entry);
+}
diff --git a/source/libs/index/src/index_fst_util.c b/source/libs/index/src/index_fst_util.c
index ad5559f835..da1e177a18 100644
--- a/source/libs/index/src/index_fst_util.c
+++ b/source/libs/index/src/index_fst_util.c
@@ -61,7 +61,7 @@ uint8_t packSize(uint64_t n) {
   }
 }
 
-uint64_t unpackUint64(uint8_t *ch, uint8_t sz) {
+uint64_t unpackUint64(uint8_t* ch, uint8_t sz) {
   uint64_t n = 0;
   for (uint8_t i = 0; i < sz; i++) {
     //
@@ -76,7 +76,7 @@ uint8_t packDeltaSize(CompiledAddr nodeAddr, CompiledAddr transAddr) {
     return packSize(nodeAddr - transAddr);
   }
 }
-CompiledAddr unpackDelta(char *data, uint64_t len, uint64_t nodeAddr) {
+CompiledAddr unpackDelta(char* data, uint64_t len, uint64_t nodeAddr) {
   uint64_t delta = unpackUint64(data, len);
   // delta_add = u64_to_usize
   if (delta == EMPTY_ADDRESS) {
@@ -89,8 +89,8 @@ CompiledAddr unpackDelta(char *data, uint64_t len, uint64_t nodeAddr) {
 // fst slice func
 //
 
-FstSlice fstSliceCreate(uint8_t *data, uint64_t len) {
-  FstString *str = (FstString *)malloc(sizeof(FstString));
+FstSlice fstSliceCreate(uint8_t* data, uint64_t len) {
+  FstString* str = (FstString*)malloc(sizeof(FstString));
   str->ref = 1;
   str->len = len;
   str->data = malloc(len * sizeof(uint8_t));
@@ -100,8 +100,8 @@ FstSlice fstSliceCreate(uint8_t *data, uint64_t len) {
   return s;
 }
 // just shallow copy
-FstSlice fstSliceCopy(FstSlice *s, int32_t start, int32_t end) {
-  FstString *str = s->str;
+FstSlice fstSliceCopy(FstSlice* s, int32_t start, int32_t end) {
+  FstString* str = s->str;
   str->ref++;
   // uint8_t *buf = fstSliceData(s, &alen);
   // start = buf + start - (buf - s->start);
@@ -110,16 +110,16 @@ FstSlice fstSliceCopy(FstSlice *s, int32_t start, int32_t end) {
   FstSlice t = {.str = str, .start = start + s->start, .end = end + s->start};
   return t;
 }
-FstSlice fstSliceDeepCopy(FstSlice *s, int32_t start, int32_t end) {
+FstSlice fstSliceDeepCopy(FstSlice* s, int32_t start, int32_t end) {
   int32_t  tlen = end - start + 1;
   int32_t  slen;
-  uint8_t *data = fstSliceData(s, &slen);
+  uint8_t* data = fstSliceData(s, &slen);
   assert(tlen <= slen);
 
-  uint8_t *buf = malloc(sizeof(uint8_t) * tlen);
+  uint8_t* buf = malloc(sizeof(uint8_t) * tlen);
   memcpy(buf, data + start, tlen);
 
-  FstString *str = malloc(sizeof(FstString));
+  FstString* str = malloc(sizeof(FstString));
   str->data = buf;
   str->len = tlen;
   str->ref = 1;
@@ -130,15 +130,17 @@ FstSlice fstSliceDeepCopy(FstSlice *s, int32_t start, int32_t end) {
   ans.end = tlen - 1;
   return ans;
 }
-bool fstSliceIsEmpty(FstSlice *s) { return s->str == NULL || s->str->len == 0 || s->start < 0 || s->end < 0; }
+bool fstSliceIsEmpty(FstSlice* s) {
+  return s->str == NULL || s->str->len == 0 || s->start < 0 || s->end < 0;
+}
 
-uint8_t *fstSliceData(FstSlice *s, int32_t *size) {
-  FstString *str = s->str;
+uint8_t* fstSliceData(FstSlice* s, int32_t* size) {
+  FstString* str = s->str;
   if (size != NULL) { *size = s->end - s->start + 1; }
   return str->data + s->start;
 }
-void fstSliceDestroy(FstSlice *s) {
-  FstString *str = s->str;
+void fstSliceDestroy(FstSlice* s) {
+  FstString* str = s->str;
   str->ref--;
   if (str->ref <= 0) {
     free(str->data);
@@ -147,10 +149,10 @@ void fstSliceDestroy(FstSlice *s) {
   }
 }
 
-int fstSliceCompare(FstSlice *a, FstSlice *b) {
+int fstSliceCompare(FstSlice* a, FstSlice* b) {
   int32_t  alen, blen;
-  uint8_t *aBuf = fstSliceData(a, &alen);
-  uint8_t *bBuf = fstSliceData(b, &blen);
+  uint8_t* aBuf = fstSliceData(a, &alen);
+  uint8_t* bBuf = fstSliceData(b, &blen);
 
   uint32_t i, j;
   for (i = 0, j = 0; i < alen && j < blen; i++, j++) {
diff --git a/source/libs/index/src/index_tfile.c b/source/libs/index/src/index_tfile.c
index 9c7d23d8a9..86e60bc7dc 100644
--- a/source/libs/index/src/index_tfile.c
+++ b/source/libs/index/src/index_tfile.c
@@ -22,16 +22,30 @@
 #include "index_util.h"
 #include "taosdef.h"
 
-static FORCE_INLINE int tfileWriteHeader(TFileWriter *writer) {}
-static FORCE_INLINE int tfileReadLoadHeader(TFileReader *reader) {
+static FORCE_INLINE int tfileWriteHeader(TFileWriter* writer) {
+  char  buf[TFILE_HEADER_SIZE] = {0};
+  char* p = buf;
+
+  TFileHeader* header = &writer->header;
+  SERIALIZE_MEM_TO_BUF(p, header, suid);
+  SERIALIZE_MEM_TO_BUF(p, header, version);
+  SERIALIZE_VAR_TO_BUF(p, strlen(header->colName), int32_t);
+
+  SERIALIZE_STR_MEM_TO_BUF(p, header, colName, strlen(header->colName));
+  SERIALIZE_MEM_TO_BUF(p, header, colType);
+  int offset = p - buf;
+  int nwrite = writer->ctx->write(writer->ctx, buf, offset);
+  if (offset != nwrite) { return -1; }
+}
+static FORCE_INLINE int tfileReadLoadHeader(TFileReader* reader) {
   // TODO simple tfile header later
   char  buf[TFILE_HADER_PRE_SIZE];
-  char *p = buf;
+  char* p = buf;
 
   int64_t nread = reader->ctx->read(reader->ctx, buf, TFILE_HADER_PRE_SIZE);
   assert(nread == TFILE_HADER_PRE_SIZE);
 
-  TFileHeader *header = &reader->header;
+  TFileHeader* header = &reader->header;
   memcpy(&header->suid, p, sizeof(header->suid));
   p += sizeof(header->suid);
 
@@ -46,28 +60,29 @@ static FORCE_INLINE int tfileReadLoadHeader(TFileReader *reader) {
 
   nread = reader->ctx->read(reader->ctx, &header->colType, sizeof(header->colType));
   return 0;
-};
-static int tfileGetFileList(const char *path, SArray *result) {
-  DIR *dir = opendir(path);
+}
+
+static int tfileGetFileList(const char* path, SArray* result) {
+  DIR* dir = opendir(path);
   if (NULL == dir) { return -1; }
 
-  struct dirent *entry;
+  struct dirent* entry;
   while ((entry = readdir(dir)) != NULL) {
     size_t len = strlen(entry->d_name);
-    char * buf = calloc(1, len + 1);
+    char*  buf = calloc(1, len + 1);
     memcpy(buf, entry->d_name, len);
     taosArrayPush(result, &buf);
   }
   closedir(dir);
   return 0;
 }
-static void tfileDestroyFileName(void *elem) {
-  char *p = *(char **)elem;
+static void tfileDestroyFileName(void* elem) {
+  char* p = *(char**)elem;
   free(p);
 }
-static int tfileCompare(const void *a, const void *b) {
-  const char *aName = *(char **)a;
-  const char *bName = *(char **)b;
+static int tfileCompare(const void* a, const void* b) {
+  const char* aName = *(char**)a;
+  const char* bName = *(char**)b;
 
   size_t aLen = strlen(aName);
   size_t bLen = strlen(bName);
@@ -75,14 +90,14 @@ static int tfileCompare(const void *a, const void *b) {
   return strncmp(aName, bName, aLen > bLen ? aLen : bLen);
 }
 // tfile name suid-colId-version.tindex
-static int tfileParseFileName(const char *filename, uint64_t *suid, int *colId, int *version) {
+static int tfileParseFileName(const char* filename, uint64_t* suid, int* colId, int* version) {
   if (3 == sscanf(filename, "%" PRIu64 "-%d-%d.tindex", suid, colId, version)) {
     // read suid & colid & version  success
     return 0;
   }
   return -1;
 }
-static void tfileSerialCacheKey(TFileCacheKey *key, char *buf) {
+static void tfileSerialCacheKey(TFileCacheKey* key, char* buf) {
   SERIALIZE_MEM_TO_BUF(buf, key, suid);
   SERIALIZE_VAR_TO_BUF(buf, '_', char);
   SERIALIZE_MEM_TO_BUF(buf, key, colType);
@@ -92,30 +107,30 @@ static void tfileSerialCacheKey(TFileCacheKey *key, char *buf) {
   SERIALIZE_STR_MEM_TO_BUF(buf, key, colName, key->nColName);
 }
 
-TFileCache *tfileCacheCreate(const char *path) {
-  TFileCache *tcache = calloc(1, sizeof(TFileCache));
+TFileCache* tfileCacheCreate(const char* path) {
+  TFileCache* tcache = calloc(1, sizeof(TFileCache));
   if (tcache == NULL) { return NULL; }
 
   tcache->tableCache = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
   tcache->capacity = 64;
 
-  SArray *files = taosArrayInit(4, sizeof(void *));
+  SArray* files = taosArrayInit(4, sizeof(void*));
   tfileGetFileList(path, files);
   taosArraySort(files, tfileCompare);
   uint64_t suid;
   int32_t  colId, version;
   for (size_t i = 0; i < taosArrayGetSize(files); i++) {
-    char *file = taosArrayGetP(files, i);
-    if (0 != tfileParseFileName(file, &suid, (int *)&colId, (int *)&version)) {
+    char* file = taosArrayGetP(files, i);
+    if (0 != tfileParseFileName(file, &suid, (int*)&colId, (int*)&version)) {
       indexInfo("try parse invalid file:  %s, skip it", file);
       continue;
     }
-    WriterCtx *wc = writerCtxCreate(TFile, file, true, 1024 * 64);
+    WriterCtx* wc = writerCtxCreate(TFile, file, true, 1024 * 64);
     if (wc == NULL) {
       indexError("failed to open index:  %s", file);
       goto End;
     }
-    TFileReader *reader = tfileReaderCreate(wc);
+    TFileReader* reader = tfileReaderCreate(wc);
     if (0 != tfileReadLoadHeader(reader)) {
       tfileReaderDestroy(reader);
       indexError("failed to load index header, index Id: %s", file);
@@ -123,12 +138,16 @@ TFileCache *tfileCacheCreate(const char *path) {
     }
     // loader fst and validate it
 
-    TFileHeader * header = &reader->header;
-    TFileCacheKey key = {
-        .suid = header->suid, .version = header->version, .colName = header->colName, .nColName = strlen(header->colName), .colType = header->colType};
+    TFileHeader*  header = &reader->header;
+    TFileCacheKey key = {.suid = header->suid,
+                         .version = header->version,
+                         .colName = header->colName,
+                         .nColName = strlen(header->colName),
+                         .colType = header->colType};
+
     char buf[128] = {0};
     tfileSerialCacheKey(&key, buf);
-    taosHashPut(tcache->tableCache, buf, strlen(buf), &reader, sizeof(void *));
+    taosHashPut(tcache->tableCache, buf, strlen(buf), &reader, sizeof(void*));
   }
   taosArrayDestroyEx(files, tfileDestroyFileName);
   return tcache;
@@ -137,13 +156,13 @@ End:
   taosArrayDestroyEx(files, tfileDestroyFileName);
   return NULL;
 }
-void tfileCacheDestroy(TFileCache *tcache) {
+void tfileCacheDestroy(TFileCache* tcache) {
   if (tcache == NULL) { return; }
 
   // free table cache
-  TFileReader **reader = taosHashIterate(tcache->tableCache, NULL);
+  TFileReader** reader = taosHashIterate(tcache->tableCache, NULL);
   while (reader) {
-    TFileReader *p = *reader;
+    TFileReader* p = *reader;
     indexInfo("drop table cache suid: %" PRIu64 ", colName: %s, colType: %d", p->header.suid, p->header.colName, p->header.colType);
 
     tfileReaderDestroy(p);
@@ -153,36 +172,36 @@ void tfileCacheDestroy(TFileCache *tcache) {
   free(tcache);
 }
 
-TFileReader *tfileCacheGet(TFileCache *tcache, TFileCacheKey *key) {
+TFileReader* tfileCacheGet(TFileCache* tcache, TFileCacheKey* key) {
   char buf[128] = {0};
   tfileSerialCacheKey(key, buf);
-  TFileReader *reader = taosHashGet(tcache->tableCache, buf, strlen(buf));
+  TFileReader* reader = taosHashGet(tcache->tableCache, buf, strlen(buf));
   return reader;
 }
-void tfileCachePut(TFileCache *tcache, TFileCacheKey *key, TFileReader *reader) {
+void tfileCachePut(TFileCache* tcache, TFileCacheKey* key, TFileReader* reader) {
   char buf[128] = {0};
   tfileSerialCacheKey(key, buf);
-  taosHashPut(tcache->tableCache, buf, strlen(buf), &reader, sizeof(void *));
+  taosHashPut(tcache->tableCache, buf, strlen(buf), &reader, sizeof(void*));
   return;
 }
 
-TFileReader *tfileReaderCreate(WriterCtx *ctx) {
-  TFileReader *reader = calloc(1, sizeof(TFileReader));
+TFileReader* tfileReaderCreate(WriterCtx* ctx) {
+  TFileReader* reader = calloc(1, sizeof(TFileReader));
   if (reader == NULL) { return NULL; }
 
   // T_REF_INC(reader);
   reader->ctx = ctx;
   return reader;
 }
-void tfileReaderDestroy(TFileReader *reader) {
+void tfileReaderDestroy(TFileReader* reader) {
   if (reader == NULL) { return; }
   // T_REF_INC(reader);
   writerCtxDestroy(reader->ctx);
   free(reader);
 }
 
-int tfileReaderSearch(TFileReader *reader, SIndexTermQuery *query, SArray *result) {
-  SIndexTerm *term = query->term;
+int tfileReaderSearch(TFileReader* reader, SIndexTermQuery* query, SArray* result) {
+  SIndexTerm* term = query->term;
   // refactor to callback later
   if (query->qType == QUERY_TERM) {
     uint64_t offset;
@@ -200,52 +219,57 @@ int tfileReaderSearch(TFileReader *reader, SIndexTermQuery *query, SArray *resul
   return 0;
 }
 
-TFileWriter *tfileWriterCreate(WriterCtx *ctx, TFileHeader *header) {
+TFileWriter* tfileWriterCreate(WriterCtx* ctx, TFileHeader* header) {
   // char pathBuf[128] = {0};
   // sprintf(pathBuf, "%s/% " PRIu64 "-%d-%d.tindex", path, suid, colId, version);
   // TFileHeader header = {.suid = suid, .version = version, .colName = {0}, colType = colType};
   // memcpy(header.colName, );
 
-  char buf[TFILE_HADER_PRE_SIZE];
-  int  len = TFILE_HADER_PRE_SIZE;
-  if (len != ctx->write(ctx, buf, len)) {
-    indexError("index: %" PRIu64 " failed to write header info", header->suid);
-    return NULL;
-  }
-  TFileWriter *tw = calloc(1, sizeof(TFileWriter));
+  // char buf[TFILE_HADER_PRE_SIZE];
+  // int  len = TFILE_HADER_PRE_SIZE;
+  // if (len != ctx->write(ctx, buf, len)) {
+  //  indexError("index: %" PRIu64 " failed to write header info", header->suid);
+  //  return NULL;
+  //}
+  TFileWriter* tw = calloc(1, sizeof(TFileWriter));
   if (tw == NULL) {
     indexError("index: %" PRIu64 " failed to alloc TFilerWriter", header->suid);
     return NULL;
   }
+  tw->ctx = ctx;
+  tw->header = *header;
+
   return tw;
 }
-void tfileWriterDestroy(TFileWriter *tw) {
+void tfileWriterDestroy(TFileWriter* tw) {
   if (tw == NULL) { return; }
 
   writerCtxDestroy(tw->ctx);
   free(tw);
 }
 
-IndexTFile *indexTFileCreate(const char *path) {
-  IndexTFile *tfile = calloc(1, sizeof(IndexTFile));
+IndexTFile* indexTFileCreate(const char* path) {
+  IndexTFile* tfile = calloc(1, sizeof(IndexTFile));
   if (tfile == NULL) { return NULL; }
 
   tfile->cache = tfileCacheCreate(path);
   return tfile;
 }
-void IndexTFileDestroy(IndexTFile *tfile) { free(tfile); }
+void IndexTFileDestroy(IndexTFile* tfile) {
+  free(tfile);
+}
 
-int indexTFileSearch(void *tfile, SIndexTermQuery *query, SArray *result) {
+int indexTFileSearch(void* tfile, SIndexTermQuery* query, SArray* result) {
   if (tfile == NULL) { return -1; }
-  IndexTFile *pTfile = (IndexTFile *)tfile;
+  IndexTFile* pTfile = (IndexTFile*)tfile;
 
-  SIndexTerm *  term = query->term;
+  SIndexTerm*   term = query->term;
   TFileCacheKey key = {.suid = term->suid, .colType = term->colType, .version = 0, .colName = term->colName, .nColName = term->nColName};
 
-  TFileReader *reader = tfileCacheGet(pTfile->cache, &key);
+  TFileReader* reader = tfileCacheGet(pTfile->cache, &key);
   return tfileReaderSearch(reader, query, result);
 }
-int indexTFilePut(void *tfile, SIndexTerm *term, uint64_t uid) {
+int indexTFilePut(void* tfile, SIndexTerm* term, uint64_t uid) {
   TFileWriterOpt wOpt = {.suid = term->suid, .colType = term->colType, .colName = term->colName, .nColName = term->nColName, .version = 1};
 
   return 0;