Merge pull request #9258 from taosdata/feature/index_cache

update index TFile manage and format code

include/libs/index/index.h

@@ -39,11 +39,11 @@ typedef enum  {
 } SIndexOperOnColumn;
 
 typedef enum { MUST = 0, SHOULD = 1, NOT = 2 } EIndexOperatorType;
-typedef enum  { QUERY_TERM = 0, QUERY_PREFIX = 1, QUERY_SUFFIX = 2,QUERY_REGEX = 3} EIndexQueryType;
+typedef enum { QUERY_TERM = 0, QUERY_PREFIX = 1, QUERY_SUFFIX = 2, QUERY_REGEX = 3 } EIndexQueryType;
 /*
  * @param: oper
  *
-*/
+ */
 SIndexMultiTermQuery *indexMultiTermQueryCreate(EIndexOperatorType oper);
 void                  indexMultiTermQueryDestroy(SIndexMultiTermQuery *pQuery);
 int                   indexMultiTermQueryAdd(SIndexMultiTermQuery *pQuery, SIndexTerm *term, EIndexQueryType type);
@@ -76,11 +76,10 @@ void       indexOptsDestroy(SIndexOpts *opts);
  * @param:
  */
 
-SIndexTerm *indexTermCreate(int64_t suid, SIndexOperOnColumn operType, uint8_t colType, 
-                            const char *colName, int32_t nColName, const char *colVal, int32_t nColVal);
+SIndexTerm *indexTermCreate(int64_t suid, SIndexOperOnColumn operType, uint8_t colType, const char *colName,
+    int32_t nColName, const char *colVal, int32_t nColVal);
 void        indexTermDestroy(SIndexTerm *p);
 
-
 #ifdef __cplusplus
 }
 #endif

source/libs/index/inc/indexInt.h

@@ -18,20 +18,19 @@
 
 #include "index.h"
 #include "index_fst.h"
-#include "tlog.h"
-#include "thash.h"
 #include "taos.h"
+#include "thash.h"
+#include "tlog.h"
 
 #ifdef USE_LUCENE
 #include <lucene++/Lucene_c.h>
 #endif
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-typedef enum {kTypeValue, kTypeDeletion} STermValueType ;
+typedef enum { kTypeValue, kTypeDeletion } STermValueType;
 
 typedef struct SIndexStat {
   int32_t totalAdded;    //
@@ -45,9 +44,9 @@ struct SIndex {
 #ifdef USE_LUCENE
   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
@@ -66,12 +65,11 @@ struct SIndexOpts {
   int32_t cacheSize;  // MB
   // add cache module later
 #endif
-
 };
 
 struct SIndexMultiTermQuery {
   EIndexOperatorType opera;
-  SArray *query;
+  SArray *           query;
 };
 
 // field and key;
@@ -79,26 +77,53 @@ 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;
 
-
-
-#define indexFatal(...) do { if (sDebugFlag & DEBUG_FATAL) { taosPrintLog("index FATAL ", 255, __VA_ARGS__); }}     while(0)
-#define indexError(...) do { if (sDebugFlag & DEBUG_ERROR) { taosPrintLog("index ERROR ", 255, __VA_ARGS__); }}     while(0)
-#define indexWarn(...)  do { if (sDebugFlag & DEBUG_WARN)  { taosPrintLog("index WARN ", 255, __VA_ARGS__); }}      while(0)
-#define indexInfo(...)  do { if (sDebugFlag & DEBUG_INFO)  { taosPrintLog("index ", 255, __VA_ARGS__); }}           while(0)
-#define indexDebug(...) do { if (sDebugFlag & DEBUG_DEBUG) { taosPrintLog("index ", sDebugFlag, __VA_ARGS__); }} while(0)
-#define indexTrace(...) do { if (sDebugFlag & DEBUG_TRACE) { taosPrintLog("index ", sDebugFlag, __VA_ARGS__); }} while(0)
-
+#define indexFatal(...)                               \
+  do {                                                \
+    if (sDebugFlag & DEBUG_FATAL) {                   \
+      taosPrintLog("index FATAL ", 255, __VA_ARGS__); \
+    }                                                 \
+  } while (0)
+#define indexError(...)                               \
+  do {                                                \
+    if (sDebugFlag & DEBUG_ERROR) {                   \
+      taosPrintLog("index ERROR ", 255, __VA_ARGS__); \
+    }                                                 \
+  } while (0)
+#define indexWarn(...)                               \
+  do {                                               \
+    if (sDebugFlag & DEBUG_WARN) {                   \
+      taosPrintLog("index WARN ", 255, __VA_ARGS__); \
+    }                                                \
+  } while (0)
+#define indexInfo(...)                          \
+  do {                                          \
+    if (sDebugFlag & DEBUG_INFO) {              \
+      taosPrintLog("index ", 255, __VA_ARGS__); \
+    }                                           \
+  } while (0)
+#define indexDebug(...)                                \
+  do {                                                 \
+    if (sDebugFlag & DEBUG_DEBUG) {                    \
+      taosPrintLog("index ", sDebugFlag, __VA_ARGS__); \
+    }                                                  \
+  } while (0)
+#define indexTrace(...)                                \
+  do {                                                 \
+    if (sDebugFlag & DEBUG_TRACE) {                    \
+      taosPrintLog("index ", sDebugFlag, __VA_ARGS__); \
+    }                                                  \
+  } while (0)
 
 #ifdef __cplusplus
 }

source/libs/index/inc/index_cache.h

@@ -22,8 +22,10 @@
 // ----------------- key structure in skiplist ---------------------
 
 /* A data row, the format is like below:
- * content: |<--totalLen-->|<-- fieldid-->|<--field type -->|<-- value len--->|<-- value -->|<--  uid  -->|<--version--->|<-- itermType -->|
- * len    : |<--int32_t -->|<-- int16_t-->|<--  int8_t --->|<--- int32_t --->|<--valuelen->|<--uint64_t->|<-- int32_t-->|<--  int8_t  --->| 
+ * content: |<--totalLen-->|<-- fieldid-->|<--field type-->|<-- value len--->|
+ *          |<-- value -->|<--uid -->|<--version--->|<-- itermType -->|
+ *  len :   |<--int32_t -->|<-- int16_t-->|<--  int8_t --->|<--- int32_t --->|
+ *          <--valuelen->|<--uint64_t->| *  <-- int32_t-->|<-- int8_t --->|
  */
 
 #ifdef __cplusplus
@@ -35,7 +37,6 @@ typedef struct IndexCache {
   SSkipList *skiplist;
 } IndexCache;
 
-
 //
 IndexCache *indexCacheCreate();
 
@@ -43,13 +44,12 @@ void indexCacheDestroy(void *cache);
 
 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 indexCacheGet(void *cache, uint64_t *rst);
+int indexCacheSearch(
+    void *cache, SIndexTermQuery *query, int16_t colId, int32_t version, SArray *result, STermValueType *s);
 
 #ifdef __cplusplus
 }
 #endif
 
-
-
 #endif

source/libs/index/inc/index_fst.h

@@ -20,11 +20,11 @@
 extern "C" {
 #endif
 
-#include "tarray.h"
-#include "index_fst_util.h"
-#include "index_fst_registry.h"
-#include "index_fst_counting_writer.h"
 #include "index_fst_automation.h"
+#include "index_fst_counting_writer.h"
+#include "index_fst_registry.h"
+#include "index_fst_util.h"
+#include "tarray.h"
 
 #define OUTPUT_PREFIX(a, b) ((a) > (b) ? (b) : (a)
 
@@ -32,7 +32,7 @@ typedef struct Fst     Fst;
 typedef struct FstNode         FstNode;
 typedef struct StreamWithState StreamWithState;
 
-typedef enum { Included, Excluded, Unbounded} FstBound; 
+typedef enum { Included, Excluded, Unbounded } FstBound;
 
 typedef struct FstBoundWithData {
   FstSlice data;
@@ -40,8 +40,8 @@ typedef struct FstBoundWithData {
 } FstBoundWithData;
 
 typedef struct FstStreamBuilder {
-  Fst *fst; 
-  AutomationCtx *aut;
+  Fst *             fst;
+  AutomationCtx *   aut;
   FstBoundWithData *min;
   FstBoundWithData *max;
 } FstStreamBuilder, FstStreamWithStateBuilder;
@@ -51,18 +51,15 @@ typedef struct FstRange {
   uint64_t end;
 } FstRange;
 
+typedef enum { GE, GT, LE, LT } RangeType;
+typedef enum { OneTransNext, OneTrans, AnyTrans, EmptyFinal } State;
+typedef enum { Ordered, OutOfOrdered, DuplicateKey } OrderType;
 
-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);
+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;
   Output out;
@@ -82,76 +79,71 @@ typedef struct FstUnFinishedNodes {
 FstUnFinishedNodes *fstUnFinishedNodesCreate();
 void                fstUnFinishedNodesDestroy(FstUnFinishedNodes *node);
 void                fstUnFinishedNodesPushEmpty(FstUnFinishedNodes *nodes, bool isFinal);
-FstBuilderNode *fstUnFinishedNodesPopRoot(FstUnFinishedNodes *nodes);
-FstBuilderNode *fstUnFinishedNodesPopFreeze(FstUnFinishedNodes *nodes, CompiledAddr addr);
-FstBuilderNode *fstUnFinishedNodesPopEmpty(FstUnFinishedNodes *nodes);
 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);
-uint64_t fstUnFinishedNodesFindCommPrefixAndSetOutput(FstUnFinishedNodes *node, FstSlice bs, Output in, Output *out);
+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);
 
 typedef struct FstBuilder {
-  FstCountingWriter  *wrt;         // The FST raw data is written directly to `wtr`.  
+  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.        
+  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);
 
-
 void         fstBuilderDestroy(FstBuilder *b);
 void         fstBuilderInsertOutput(FstBuilder *b, FstSlice bs, Output in);
 bool         fstBuilderInsert(FstBuilder *b, FstSlice bs, Output in);
-OrderType fstBuilderCheckLastKey(FstBuilder *b, FstSlice bs, bool ckDup);
 void         fstBuilderCompileFrom(FstBuilder *b, uint64_t istate);
-CompiledAddr fstBuilderCompile(FstBuilder *b, FstBuilderNode *bn);
-void* fstBuilerIntoInner(FstBuilder *b);
+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;
   FstRange range;
 } FstTransitions;
 
-//FstState and relation function
+// FstState and relation function
 
 typedef struct FstState {
   State   state;
   uint8_t val;
 } FstState;
 
-FstState fstStateCreateFrom(FstSlice* data, CompiledAddr addr);
+FstState fstStateCreateFrom(FstSlice *data, CompiledAddr addr);
 FstState fstStateCreate(State state);
 
-//compile
+// 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);
 
 // 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 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 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);
@@ -180,14 +172,11 @@ 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)
 #define FST_STATE_ANY_TRANS(node) (node->state.state == AnyTrans)
 #define FST_STATE_EMPTY_FINAL(node) (node->state.state == EmptyFinal)
 
-
 typedef struct FstLastTransition {
   uint8_t inp;
   Output  out;
@@ -198,13 +187,12 @@ 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 fstBuilderNodeUnfinishedAddOutputPrefix(FstBuilderNodeUnfinished *node, Output out);
 
 /*
@@ -222,27 +210,31 @@ typedef struct FstNode {
   Output       finalOutput;
 } FstNode;
 
-// If this node is final and has a terminal output value, then it is,  returned. Otherwise, a zero output is returned 
+// If this node is final and has a terminal output value, then it is,  returned.
+// Otherwise, a zero output is returned
 #define FST_NODE_FINAL_OUTPUT(node) node->finalOutput
-// Returns true if and only if this node corresponds to a final or "match", state in the finite state transducer.
+// Returns true if and only if this node corresponds to a final or "match",
+// state in the finite state transducer.
 #define FST_NODE_IS_FINAL(node) node->isFinal
-// Returns the number of transitions in this node, The maximum number of transitions is 256.
+// Returns the number of transitions in this node, The maximum number of
+// transitions is 256.
 #define FST_NODE_LEN(node) node->nTrans
 // Returns true if and only if this node has zero transitions.
 #define FST_NODE_IS_EMPTYE(node) (node->nTrans == 0)
 // 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);
 
 FstTransitions  fstNodeTransitionIter(FstNode *node);
-FstTransitions* fstNodeTransitions(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);
+
 FstSlice fstNodeAsSlice(FstNode *node);
 
 // ops
@@ -255,7 +247,6 @@ typedef struct FstIndexedValue {
 FstLastTransition *fstLastTransitionCreate(uint8_t inp, Output out);
 void               fstLastTransitionDestroy(FstLastTransition *trn);
 
-
 typedef struct FstMeta {
   uint64_t     version;
   CompiledAddr rootAddr;
@@ -265,67 +256,69 @@ typedef struct FstMeta {
 } FstMeta;
 
 typedef struct Fst {
-  FstMeta  *meta; 
+  FstMeta * meta;
   FstSlice *data;  //
-  FstNode  *root;  // 
+  FstNode * root;  //
 } Fst;
 
 // refactor simple function
 
-Fst*         fstCreate(FstSlice *data);
+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);
+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);
 
-
-//refactor this function 
+// refactor this function
 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);
 
 typedef struct StreamWithState {
-  Fst           *fst;
-  AutomationCtx *aut; 
-  SArray        *inp;
+  Fst *             fst;
+  AutomationCtx *   aut;
+  SArray *          inp;
   FstOutput         emptyOutput;
-  SArray        *stack; // <StreamState>
+  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);
 
-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);
+
 bool streamWithStateSeekMin(StreamWithState *sws, FstBoundWithData *min);
 
-StreamWithStateResult* streamWithStateNextWith(StreamWithState *sws, StreamCallback callback);
+StreamWithStateResult *streamWithStateNextWith(StreamWithState *sws, StreamCallback callback);
 
 FstStreamBuilder *fstStreamBuilderCreate(Fst *fst, AutomationCtx *aut);
 // set up bound range
@@ -333,7 +326,6 @@ FstStreamBuilder *fstStreamBuilderCreate(Fst *fst, AutomationCtx *aut);
 
 FstStreamBuilder *fstStreamBuilderRange(FstStreamBuilder *b, FstSlice *val, RangeType type);
 
-
 #ifdef __cplusplus
 }
 #endif

source/libs/index/inc/index_fst_automation.h

@@ -21,13 +21,9 @@ extern "C" {
 
 #include "index_fst_util.h"
 
-
 typedef struct AutomationCtx AutomationCtx;
 
-typedef enum AutomationType {
-  AUTOMATION_PREFIX,
-  AUTMMATION_MATCH 
-} AutomationType;
+typedef enum AutomationType { AUTOMATION_PREFIX, AUTMMATION_MATCH } AutomationType;
 
 typedef struct StartWith {
   AutomationCtx *autoSelf;
@@ -40,12 +36,11 @@ typedef struct 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;
+typedef enum ValueType { FST_INT, FST_CHAR, FST_ARRAY } ValueType;
 typedef enum StartWithStateKind { Done, Running } StartWithStateKind;
 
 typedef struct StartWithStateValue {
@@ -53,24 +48,23 @@ typedef struct StartWithStateValue {
   ValueType          type;
   union {
     int     val;
-    char   *ptr;
+    char *  ptr;
     SArray *arr;
     // add more type
-  } ;
+  };
 } StartWithStateValue;
 
 StartWithStateValue *startWithStateValueCreate(StartWithStateKind kind, ValueType ty, void *val);
 StartWithStateValue *startWithStateValueDump(StartWithStateValue *sv);
 void                 startWithStateValueDestroy(void *sv);
 
-
 typedef struct AutomationFunc {
-  void* (*start)(AutomationCtx *ctx) ; 
+  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 *(*accept)(AutomationCtx *ctx, void *state, uint8_t byte);
+  void *(*acceptEof)(AutomationCtx *ct, void *state);
 } AutomationFunc;
 
 AutomationCtx *automCtxCreate(void *data, AutomationType atype);

source/libs/index/inc/index_fst_common.h

 #ifndef __INDEX_FST_COMM_H__
 #define __INDEX_FST_COMM_H__
 
-
+#include "tutil.h"
 extern const uint8_t COMMON_INPUTS[];
-extern char const COMMON_INPUTS_INV[];
+extern const char    COMMON_INPUTS_INV[];
 
 #ifdef __cplusplus
 extern "C" {

source/libs/index/inc/index_fst_counting_writer.h

@@ -22,11 +22,10 @@ extern "C" {
 
 #include "tfile.h"
 
-
-#define DefaultMem  1024*1024
+#define DefaultMem 1024 * 1024
 
 static char tmpFile[] = "./index";
-typedef enum WriterType {TMemory, TFile} WriterType;   
+typedef enum WriterType { TMemory, TFile } WriterType;
 
 typedef struct WriterCtx {
   int (*write)(struct WriterCtx *ctx, uint8_t *buf, int len);
@@ -40,7 +39,7 @@ typedef struct WriterCtx {
     } file;
     struct {
       int32_t capa;
-      char *buf;
+      char *  buf;
     } mem;
   };
   int32_t offset;
@@ -51,14 +50,13 @@ 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);
+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;
@@ -69,17 +67,14 @@ int fstCountingWriterRead(FstCountingWriter *write, uint8_t *buf, uint32_t len);
 
 int fstCountingWriterFlush(FstCountingWriter *write);
 
-
 uint32_t fstCountingWriterMaskedCheckSum(FstCountingWriter *write);
 
 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);
 
-
 #define FST_WRITER_COUNT(writer) (writer->count)
 #define FST_WRITER_INTER_WRITER(writer) (writer->wtr)
 #define FST_WRITE_CHECK_SUMMER(writer) (writer->summer)
@@ -89,5 +84,3 @@ uint8_t fstCountingWriterPackUint(FstCountingWriter *writer, uint64_t n);
 #endif
 
 #endif
-
-

source/libs/index/inc/index_fst_node.h

@@ -20,17 +20,17 @@
 extern "C" {
 #endif
 
-#include "index_fst_util.h"
 #include "index_fst_counting_writer.h"
+#include "index_fst_util.h"
 
 #define FST_BUILDER_NODE_IS_FINAL(bn) (bn->isFinal)
 #define FST_BUILDER_NODE_TRANS_ISEMPTY(bn) (taosArrayGetSize(bn->trans) == 0)
 #define FST_BUILDER_NODE_FINALOUTPUT_ISZERO(bn) (bn->finalOutput == 0)
 
 typedef struct FstTransition {
-  uint8_t      inp;  //The byte input associated with this transition.
-  Output       out;  //The output associated with this transition 
-  CompiledAddr addr; //The address of the node that this transition points to
+  uint8_t      inp;   // The byte input associated with this transition.
+  Output       out;   // The output associated with this transition
+  CompiledAddr addr;  // The address of the node that this transition points to
 } FstTransition;
 
 typedef struct FstBuilderNode {
@@ -45,7 +45,8 @@ FstBuilderNode *fstBuilderNodeClone(FstBuilderNode *src);
 
 void fstBuilderNodeCloneFrom(FstBuilderNode *dst, FstBuilderNode *src);
 
-//bool fstBuilderNodeCompileTo(FstBuilderNode *b, FstCountingWriter *wrt, CompiledAddr lastAddr, CompiledAddr startAddr); 
+// bool fstBuilderNodeCompileTo(FstBuilderNode *b, FstCountingWriter *wrt,
+// CompiledAddr lastAddr, CompiledAddr startAddr);
 bool fstBuilderNodeEqual(FstBuilderNode *n1, FstBuilderNode *n2);
 
 void fstBuilderNodeDestroy(FstBuilderNode *node);

source/libs/index/inc/index_fst_registry.h

@@ -19,9 +19,9 @@
 extern "C" {
 #endif
 
+#include "index_fst_node.h"
 #include "index_fst_util.h"
 #include "tarray.h"
-#include "index_fst_node.h"
 
 typedef struct FstRegistryCell {
   CompiledAddr    addr;
@@ -29,38 +29,37 @@ typedef struct FstRegistryCell {
 } 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)
-
+#define FST_REGISTRY_CELL_INSERT(cell, tAddr) \
+  do {                                        \
+    cell->addr = tAddr;                       \
+  } while (0)
 
-//typedef struct FstRegistryCache {
+// typedef struct FstRegistryCache {
 //  SArray *cells;
 //  uint32_t start;
 //  uint32_t end;
 //} FstRegistryCache;
 
-typedef enum {FOUND, NOTFOUND, REJECTED} FstRegistryEntryState;
+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);
+FstRegistry *fstRegistryCreate(uint64_t tableSize, uint64_t mruSize);
 void         fstRegistryDestroy(FstRegistry *registry);
 
-
-FstRegistryEntry* fstRegistryGetEntry(FstRegistry *registry, FstBuilderNode *bNode);
+FstRegistryEntry *fstRegistryGetEntry(FstRegistry *registry, FstBuilderNode *bNode);
 void              fstRegistryEntryDestroy(FstRegistryEntry *entry);
 
 #ifdef __cplusplus

source/libs/index/inc/index_fst_util.h

@@ -13,7 +13,6 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #ifndef __INDEX_FST_UTIL_H__
 #define __INDEX_FST_UTIL_H__
 
@@ -21,16 +20,15 @@
 extern "C" {
 #endif
 
-#include "tarray.h"
 #include "index_fst_common.h"
+#include "tarray.h"
 
 typedef uint64_t FstType;
 typedef uint64_t CompiledAddr;
 typedef uint64_t Output;
 typedef uint8_t  PackSizes;
 
-
-//A sentinel value used to indicate an empty final state
+// A sentinel value used to indicate an empty final state
 extern const CompiledAddr EMPTY_ADDRESS;
 /// A sentinel value used to indicate an invalid state.
 extern const CompiledAddr NONE_ADDRESS;
@@ -48,29 +46,33 @@ extern const uint64_t TRANS_INDEX_THRESHOLD;
 //
 // `0` is a legal value which means there are no transitions/outputs
 
+#define FST_SET_TRANSITION_PACK_SIZE(v, sz) \
+  do {                                      \
+    v = (v & 0b00001111) | (sz << 4);       \
+  } while (0)
+#define FST_GET_TRANSITION_PACK_SIZE(v) (((v)&0b11110000) >> 4)
+#define FST_SET_OUTPUT_PACK_SIZE(v, sz) \
+  do {                                  \
+    v = (v & 0b11110000) | sz;          \
+  } while (0)
+#define FST_GET_OUTPUT_PACK_SIZE(v) ((v)&0b00001111)
 
-#define FST_SET_TRANSITION_PACK_SIZE(v, sz) do {v = (v & 0b00001111) | (sz << 4); } while(0)
-#define FST_GET_TRANSITION_PACK_SIZE(v) (((v) & 0b11110000) >> 4) 
-#define FST_SET_OUTPUT_PACK_SIZE(v, sz) do { v =  (v & 0b11110000) | sz; } while(0)
-#define FST_GET_OUTPUT_PACK_SIZE(v) ((v) & 0b00001111)   
-
-#define COMMON_INPUT(idx) COMMON_INPUTS_INV[(idx) - 1]
+#define COMMON_INPUT(idx) COMMON_INPUTS_INV[(idx)-1]
 
-#define COMMON_INDEX(v, max, val) do {         \
-  val = ((uint16_t)COMMON_INPUTS[v] + 1)%256;  \
-  val = val > max ? 0: val;                    \
-} while(0) 
+#define COMMON_INDEX(v, max, val)                 \
+  do {                                            \
+    val = ((uint16_t)COMMON_INPUTS[v] + 1) % 256; \
+    val = val > max ? 0 : val;                    \
+  } while (0)
 
-
-//uint8_t commonInput(uint8_t idx);
-//uint8_t commonIdx(uint8_t v, uint8_t max);
+// uint8_t commonInput(uint8_t idx);
+// uint8_t commonIdx(uint8_t v, uint8_t max);
 
 uint8_t      packSize(uint64_t n);
 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);
 
-
 typedef struct FstString {
   uint8_t *data;
   uint32_t len;
@@ -95,9 +97,9 @@ uint8_t *fstSliceData(FstSlice *s, int32_t *sz);
 
 //// stack
 //
-//typedef (*StackFreeElemFn)(void *elem);
+// typedef (*StackFreeElemFn)(void *elem);
 //
-//typedef struct FstStack {
+// typedef struct FstStack {
 //  void   *first;
 //  void   *end;
 //  size_t elemSize;
@@ -106,15 +108,13 @@ uint8_t *fstSliceData(FstSlice *s, int32_t *sz);
 //} FstStack;
 //
 //
-//FstStack* fstStackCreate(size_t elemSize, stackFreeElem); 
-//void  *fstStackPush(FstStack *s, void *elem);
-//void  *fstStackTop(FstStack *s);
-//size_t fstStackLen(FstStack *s); 
-//void  fstStackDestory(FstStack *); 
+// FstStack* fstStackCreate(size_t elemSize, stackFreeElem);
+// void  *fstStackPush(FstStack *s, void *elem);
+// void  *fstStackTop(FstStack *s);
+// size_t fstStackLen(FstStack *s);
+// void  fstStackDestory(FstStack *);
 //
 
-
-  
 #ifdef __cplusplus
 }
 #endif

source/libs/index/inc/index_tfile.h

@@ -17,10 +17,10 @@
 
 #include "index.h"
 #include "indexInt.h"
-#include "tlockfree.h"
-#include "index_tfile.h"
-#include "index_fst_counting_writer.h"
 #include "index_fst.h"
+#include "index_fst_counting_writer.h"
+#include "index_tfile.h"
+#include "tlockfree.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -48,7 +48,6 @@ typedef struct TFileCacheKey {
   int32_t     nColName;
 } TFileCacheKey;
 
-
 // table cache
 // refactor to LRU cache later
 typedef struct TFileCache {
@@ -57,49 +56,47 @@ typedef struct TFileCache {
   // add more param
 } TFileCache;
 
-
 typedef struct TFileWriter {
   FstBuilder *fb;
-  WriterCtx  *ctx; 
+  WriterCtx * ctx;
 } TFileWriter;
 
 typedef struct TFileReader {
   T_REF_DECLARE()
-  Fst *fst;
-  WriterCtx *ctx;  
+  Fst *           fst;
+  WriterCtx *     ctx;
+  TFileReadHeader header;
 } TFileReader;
 
 typedef struct IndexTFile {
-  char *path;
-  TFileCache *cache;
+  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);
+TFileCache * tfileCacheCreate(const char *path);
 void         tfileCacheDestroy(TFileCache *tcache);
-TFileReader* tfileCacheGet(TFileCache *tcache, TFileCacheKey *key);
+TFileReader *tfileCacheGet(TFileCache *tcache, TFileCacheKey *key);
 void         tfileCachePut(TFileCache *tcache, TFileCacheKey *key, TFileReader *reader);
 
-TFileReader* tfileReaderCreate();
+TFileReader *tfileReaderCreate();
 void         TFileReaderDestroy(TFileReader *reader);
 
-
 TFileWriter *tfileWriterCreate(const char *suid, const char *colName);
 void         tfileWriterDestroy(TFileWriter *tw);
 
@@ -108,13 +105,9 @@ IndexTFile *indexTFileCreate(const char *path);
 int         indexTFilePut(void *tfile, SIndexTerm *term, uint64_t uid);
 int         indexTFileSearch(void *tfile, SIndexTermQuery *query, SArray *result);
 
-
 #ifdef __cplusplus
 }
 
-
 #endif
 
-
-
 #endif

source/libs/index/inc/index_util.h

@@ -34,7 +34,7 @@ extern "C" {
 #define SERIALIZE_VAR_TO_BUF(buf, var, type)    \
   do {                                          \
     type c = var;                               \
-     assert(sizeof(var) == sizeof(type));\
+    assert(sizeof(var) == sizeof(type));        \
     memcpy((void *)buf, (void *)&c, sizeof(c)); \
     buf += sizeof(c);                           \
   } while (0)
@@ -42,10 +42,9 @@ extern "C" {
 #define SERIALIZE_STR_VAR_TO_BUF(buf, var, len) \
   do {                                          \
     memcpy((void *)buf, (void *)var, len);      \
-      buf += len;\
+    buf += len;                                 \
   } while (0)
 
-
 #ifdef __cplusplus
 }
 #endif

source/libs/index/src/index.c

@@ -26,8 +26,11 @@
 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 { return u1 < u2 ? -1 : 1; }
+  if (u1 == u2) {
+    return 0;
+  } else {
+    return u1 < u2 ? -1 : 1;
+  }
 }
 typedef struct SIdxColInfo {
   int colId;  // generated by index internal
@@ -37,7 +40,6 @@ 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);
 
@@ -47,14 +49,16 @@ static int indexMergeFinalResults(SArray *interResults, EIndexOperatorType oType
 int indexOpen(SIndexOpts *opts, const char *path, SIndex **index) {
   pthread_once(&isInit, indexInit);
   SIndex *sIdx = calloc(1, sizeof(SIndex));
-  if (sIdx == NULL) { return -1; }
+  if (sIdx == NULL) {
+    return -1;
+  }
 
 #ifdef USE_LUCENE
   index_t *index = index_open(path);
   sIdx->index = index;
 #endif
 
-  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;
@@ -80,8 +84,7 @@ 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();
 
@@ -100,10 +103,10 @@ int indexPut(SIndex *index, SIndexMultiTerm * fVals, uint64_t uid) {
 
 #ifdef USE_INVERTED_INDEX
 
-   //TODO(yihao): reduce the lock range 
+  // TODO(yihao): reduce the lock range
   pthread_mutex_lock(&index->mtx);
   for (int i = 0; i < taosArrayGetSize(fVals); i++) {
-    SIndexTerm     *p = taosArrayGetP(fVals, i);
+    SIndexTerm * p = taosArrayGetP(fVals, i);
     SIdxColInfo *fi = taosHashGet(index->colObj, p->colName, p->nColName);
     if (fi == NULL) {
       SIdxColInfo tfi = {.colId = index->colId};
@@ -111,13 +114,13 @@ int indexPut(SIndex *index, SIndexMultiTerm * fVals, uint64_t uid) {
       index->colId++;
       taosHashPut(index->colObj, p->colName, p->nColName, &tfi, sizeof(tfi));
     } else {
-      //TODO, del  
+      // TODO, del
     }
   }
   pthread_mutex_unlock(&index->mtx);
 
   for (int i = 0; i < taosArrayGetSize(fVals); i++) {
-    SIndexTerm     *p = taosArrayGetP(fVals, i);
+    SIndexTerm * p = taosArrayGetP(fVals, i);
     SIdxColInfo *fi = taosHashGet(index->colObj, p->colName, p->nColName);
     assert(fi != NULL);
     int32_t colId = fi->colId;
@@ -138,11 +141,11 @@ int indexSearch(SIndex *index, SIndexMultiTermQuery *multiQuerys, SArray *result
   int    nQuery = taosArrayGetSize(multiQuerys->query);
   char **fields = malloc(sizeof(char *) * nQuery);
   char **keys = malloc(sizeof(char *) * nQuery);
-  int  *types = malloc(sizeof(int)    * 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; 
+    SIndexTerm *     term = p->field_value;
 
     fields[i] = calloc(1, term->nKey + 1);
     keys[i] = calloc(1, term->nVal + 1);
@@ -152,7 +155,7 @@ int indexSearch(SIndex *index, SIndexMultiTermQuery *multiQuerys, SArray *result
     types[i] = (int)(p->type);
   }
   int *tResult = NULL;
-  int tsz= 0;
+  int  tsz = 0;
   index_multi_search(index->index, (const char **)fields, (const char **)keys, types, nQuery, opera, &tResult, &tsz);
 
   for (int i = 0; i < tsz; i++) {
@@ -175,7 +178,7 @@ int indexSearch(SIndex *index, SIndexMultiTermQuery *multiQuerys, SArray *result
   int     nQuery = taosArrayGetSize(multiQuerys->query);
   for (size_t i = 0; i < nQuery; i++) {
     SIndexTermQuery *qTerm = taosArrayGet(multiQuerys->query, i);
-     SArray *tResult = NULL;  
+    SArray *         tResult = NULL;
     indexTermSearch(index, qTerm, &tResult);
     taosArrayPush(interResults, (void *)&tResult);
   }
@@ -186,38 +189,36 @@ int indexSearch(SIndex *index, SIndexMultiTermQuery *multiQuerys, SArray *result
   return 1;
 }
 
-
-
 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() {
 #ifdef USE_LUCENE
 #endif
-return NULL;
+  return NULL;
 }
-void indexOptsDestroy(SIndexOpts *opts) {
+void indexOptsDestroy(SIndexOpts *opts){
 #ifdef USE_LUCENE
 #endif
-}
-/*
+} /*
    * @param: oper
    *
-*/
+   */
 
 SIndexMultiTermQuery *indexMultiTermQueryCreate(EIndexOperatorType opera) {
   SIndexMultiTermQuery *p = (SIndexMultiTermQuery *)malloc(sizeof(SIndexMultiTermQuery));
-  if (p == NULL) { return NULL; }
+  if (p == NULL) {
+    return NULL;
+  }
   p->opera = opera;
   p->query = taosArrayInit(4, sizeof(SIndexTermQuery));
   return p;
@@ -230,19 +231,21 @@ void indexMultiTermQueryDestroy(SIndexMultiTermQuery *pQuery) {
   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 *indexTermCreate(int64_t suid, SIndexOperOnColumn oper, uint8_t colType, const char *colName,
+    int32_t nColName, const char *colVal, int32_t nColVal) {
   SIndexTerm *t = (SIndexTerm *)calloc(1, (sizeof(SIndexTerm)));
-  if (t == NULL) { return NULL; }
+  if (t == NULL) {
+    return NULL;
+  }
 
   t->suid = suid;
-  t->operType= oper; 
+  t->operType = oper;
   t->colType = colType;
 
   t->colName = (char *)calloc(1, nColName + 1);
@@ -260,9 +263,7 @@ void indexTermDestroy(SIndexTerm *p) {
   free(p);
 }
 
-SIndexMultiTerm *indexMultiTermCreate() {
-  return taosArrayInit(4, sizeof(SIndexTerm *)); 
-}
+SIndexMultiTerm *indexMultiTermCreate() { return taosArrayInit(4, sizeof(SIndexTerm *)); }
 
 int indexMultiTermAdd(SIndexMultiTerm *terms, SIndexTerm *term) {
   taosArrayPush(terms, &term);
@@ -277,7 +278,7 @@ void indexMultiTermDestroy(SIndexMultiTerm *terms) {
 }
 
 void indexInit() {
-  //do nothing
+  // do nothing
 }
 static int indexTermSearch(SIndex *sIdx, SIndexTermQuery *query, SArray **result) {
   int32_t      version = -1;
@@ -299,7 +300,7 @@ static int indexTermSearch(SIndex *sIdx, SIndexTermQuery *query, SArray **result
   pthread_mutex_unlock(&sIdx->mtx);
 
   *result = taosArrayInit(4, sizeof(uint64_t));
-  //TODO: iterator mem and tidex
+  // TODO: iterator mem and tidex
   STermValueType s;
   if (0 == indexCacheSearch(sIdx->cache, query, colId, version, *result, &s)) {
     if (s == kTypeDeletion) {
@@ -319,7 +320,9 @@ static int indexTermSearch(SIndex *sIdx, SIndexTermQuery *query, SArray **result
   return 0;
 }
 static void indexInterResultsDestroy(SArray *results) {
-  if (results == NULL) { return; }
+  if (results == NULL) {
+    return;
+  }
 
   size_t sz = taosArrayGetSize(results);
   for (size_t i = 0; i < sz; i++) {
@@ -327,10 +330,9 @@ static void indexInterResultsDestroy(SArray *results) {
     taosArrayDestroy(p);
   }
   taosArrayDestroy(results);
-  
 }
 static int indexMergeFinalResults(SArray *interResults, EIndexOperatorType oType, SArray *fResults) {
-  //refactor, merge interResults into fResults by oType
+  // refactor, merge interResults into fResults by oType
   SArray *first = taosArrayGetP(interResults, 0);
   taosArraySort(first, uidCompare);
   taosArrayRemoveDuplicate(first, uidCompare, NULL);

source/libs/index/src/index_cache.c

@@ -14,17 +14,17 @@
  */
 
 #include "index_cache.h"
-#include "tcompare.h"
 #include "index_util.h"
+#include "tcompare.h"
 
-#define MAX_INDEX_KEY_LEN 256// test only, change later
+#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 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;
@@ -41,7 +41,7 @@ static int32_t compareKey(const void *l, const void *r) {
   memcpy(&lf, lp, sizeof(lf));
   memcpy(&rf, rp, sizeof(rf));
   if (lf != rf) {
-    return lf < rf ? -1: 1;
+    return lf < rf ? -1 : 1;
   }
   lp += sizeof(lf);
   rp += sizeof(rf);
@@ -64,11 +64,17 @@ static int32_t compareKey(const void *l, const void *r) {
   // compare value
   int32_t i, j;
   for (i = 0, j = 0; i < lfl && j < rfl; i++, j++) {
-    if (lp[i] == rp[j]) { continue; }
-    else { return lp[i] < rp[j] ? -1 : 1;}
+    if (lp[i] == rp[j]) {
+      continue;
+    } else {
+      return lp[i] < rp[j] ? -1 : 1;
+    }
+  }
+  if (i < lfl) {
+    return 1;
+  } else if (j < rfl) {
+    return -1;
   }
-  if (i < lfl) { return  1;}
-  else if (j < rfl) { return -1; }
   lp += lfl;
   rp += rfl;
 
@@ -91,32 +97,35 @@ static int32_t compareKey(const void *l, const void *r) {
   // not care item type
 
   return 0;
-  
 }
 IndexCache *indexCacheCreate() {
   IndexCache *cache = calloc(1, sizeof(IndexCache));
-  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;
-  if (pCache == NULL) { return; } 
+  if (pCache == NULL) {
+    return;
+  }
   tSkipListDestroy(pCache->skiplist);
   free(pCache);
 }
 
 int indexCachePut(void *cache, SIndexTerm *term, int16_t colId, int32_t version, uint64_t uid) {
-  if (cache == NULL) { return -1;} 
+  if (cache == NULL) {
+    return -1;
+  }
 
   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, total, int32_t);
   SERIALIZE_VAR_TO_BUF(p, colId, int16_t);
 
   SERIALIZE_MEM_TO_BUF(p, term, colType);
@@ -131,31 +140,28 @@ int indexCachePut(void *cache, SIndexTerm *term, int16_t colId, int32_t version,
   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;
   return 0;
 }
-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;
+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;
   EIndexQueryType qtype = query->qType;
 
   int32_t keyLen = CACHE_KEY_LEN(term);
 
   char *buf = calloc(1, keyLen);
   if (qtype == QUERY_TERM) {
-               
   } else if (qtype == QUERY_PREFIX) {
-
   } else if (qtype == QUERY_SUFFIX) {
-
   } else if (qtype == QUERY_REGEX) {
-
   }
 
   return 0;
 }
-    

source/libs/index/src/index_fst.c

@@ -14,11 +14,10 @@
  */
 
 #include "index_fst.h"
-#include "tcoding.h"
-#include "tchecksum.h"
 #include "indexInt.h"
 #include "index_fst_automation.h"
-
+#include "tchecksum.h"
+#include "tcoding.h"
 
 static void fstPackDeltaIn(FstCountingWriter *wrt, CompiledAddr nodeAddr, CompiledAddr transAddr, uint8_t nBytes) {
   CompiledAddr deltaAddr = (transAddr == EMPTY_ADDRESS) ? EMPTY_ADDRESS : nodeAddr - transAddr;
@@ -32,20 +31,24 @@ static uint8_t fstPackDetla(FstCountingWriter *wrt, CompiledAddr nodeAddr, Compi
 
 FstUnFinishedNodes *fstUnFinishedNodesCreate() {
   FstUnFinishedNodes *nodes = malloc(sizeof(FstUnFinishedNodes));
-  if (nodes == NULL) { return NULL; }
+  if (nodes == NULL) {
+    return NULL;
+  }
 
   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) {
-  if (nodes == NULL) { return; } 
+  if (nodes == NULL) {
+    return;
+  }
 
   taosArrayDestroyEx(nodes->stack, unFinishedNodeDestroyElem);
   free(nodes);
@@ -59,7 +62,6 @@ void fstUnFinishedNodesPushEmpty(FstUnFinishedNodes *nodes, bool isFinal) {
 
   FstBuilderNodeUnfinished un = {.node = node, .last = NULL};
   taosArrayPush(nodes->stack, &un);
-  
 }
 FstBuilderNode *fstUnFinishedNodesPopRoot(FstUnFinishedNodes *nodes) {
   assert(taosArrayGetSize(nodes->stack) == 1);
@@ -72,8 +74,8 @@ FstBuilderNode *fstUnFinishedNodesPopRoot(FstUnFinishedNodes *nodes) {
 FstBuilderNode *fstUnFinishedNodesPopFreeze(FstUnFinishedNodes *nodes, CompiledAddr addr) {
   FstBuilderNodeUnfinished *un = taosArrayPop(nodes->stack);
   fstBuilderNodeUnfinishedLastCompiled(un, addr);
-  //free(un->last); // TODO add func FstLastTransitionFree()
-  //un->last = NULL;
+  // free(un->last); // TODO add func FstLastTransitionFree()
+  // un->last = NULL;
   return un->node;
 }
 
@@ -81,13 +83,12 @@ 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);
   un->node->isFinal = true;
   un->node->finalOutput = out;
-  //un->node->trans       = NULL;  
+  // un->node->trans       = NULL;
 }
 void fstUnFinishedNodesTopLastFreeze(FstUnFinishedNodes *nodes, CompiledAddr addr) {
   size_t                    sz = taosArrayGetSize(nodes->stack) - 1;
@@ -103,9 +104,9 @@ void fstUnFinishedNodesAddSuffix(FstUnFinishedNodes *nodes, FstSlice bs, Output
   FstBuilderNodeUnfinished *un = taosArrayGet(nodes->stack, sz);
   assert(un->last == NULL);
 
-  //FstLastTransition *trn = malloc(sizeof(FstLastTransition)); 
-  //trn->inp = s->data[s->start]; 
-  //trn->out = out;
+  // FstLastTransition *trn = malloc(sizeof(FstLastTransition));
+  // trn->inp = s->data[s->start];
+  // trn->out = out;
   int32_t  len = 0;
   uint8_t *data = fstSliceData(s, &len);
   un->last = fstLastTransitionCreate(data[0], out);
@@ -116,9 +117,9 @@ void fstUnFinishedNodesAddSuffix(FstUnFinishedNodes *nodes, FstSlice bs, Output
     n->finalOutput = 0;
     n->trans = taosArrayInit(16, sizeof(FstTransition));
 
-    //FstLastTransition *trn = malloc(sizeof(FstLastTransition)); 
-    //trn->inp = s->data[i];
-    //trn->out = out; 
+    // FstLastTransition *trn = malloc(sizeof(FstLastTransition));
+    // trn->inp = s->data[i];
+    // trn->out = out;
     FstLastTransition *trn = fstLastTransitionCreate(data[i], 0);
 
     FstBuilderNodeUnfinished un = {.node = n, .last = trn};
@@ -127,7 +128,6 @@ void fstUnFinishedNodesAddSuffix(FstUnFinishedNodes *nodes, FstSlice bs, Output
   fstUnFinishedNodesPushEmpty(nodes, true);
 }
 
-
 uint64_t fstUnFinishedNodesFindCommPrefix(FstUnFinishedNodes *node, FstSlice bs) {
   FstSlice *s = &bs;
 
@@ -157,7 +157,7 @@ uint64_t fstUnFinishedNodesFindCommPrefixAndSetOutput(FstUnFinishedNodes *node,
 
     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;
@@ -177,8 +177,7 @@ 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;
@@ -198,20 +197,16 @@ 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"};
 
-FstState fstStateCreate(State state){
+FstState fstStateCreate(State state) {
   uint8_t idx = (uint8_t)state;
   return fstStateDict[idx];
 }
-//compile
+// compile
 void fstStateCompileForOneTransNext(FstCountingWriter *w, CompiledAddr addr, uint8_t inp) {
   FstState s = fstStateCreate(OneTransNext);
   fstStateSetCommInput(&s, inp);
@@ -226,7 +221,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);
@@ -245,18 +240,17 @@ void fstStateCompileForOneTrans(FstCountingWriter *w, CompiledAddr addr, FstTran
     fstCountingWriterWrite(w, (char *)&trn->inp, sizeof(trn->inp));
   }
   fstCountingWriterWrite(w, (char *)(&(st.val)), sizeof(st.val));
-  return ;
-
+  return;
 }
 void fstStateCompileForAnyTrans(FstCountingWriter *w, CompiledAddr addr, FstBuilderNode *node) {
   size_t sz = taosArrayGetSize(node->trans);
   assert(sz <= 256);
 
   uint8_t tSize = 0;
-  uint8_t oSize = packSize(node->finalOutput) ;  
+  uint8_t oSize = packSize(node->finalOutput);
 
   // finalOutput.is_zero()
-  bool anyOuts = (node->finalOutput != 0) ;
+  bool anyOuts = (node->finalOutput != 0);
   for (size_t i = 0; i < sz; i++) {
     FstTransition *t = taosArrayGet(node->trans, i);
     tSize = MAX(tSize, packDeltaSize(addr, t->addr));
@@ -265,8 +259,11 @@ void fstStateCompileForAnyTrans(FstCountingWriter *w, CompiledAddr addr, FstBuil
   }
 
   PackSizes packSizes = 0;
-  if (anyOuts) { FST_SET_OUTPUT_PACK_SIZE(packSizes, oSize); }
-  else { FST_SET_OUTPUT_PACK_SIZE(packSizes, 0); }
+  if (anyOuts) {
+    FST_SET_OUTPUT_PACK_SIZE(packSizes, oSize);
+  } else {
+    FST_SET_OUTPUT_PACK_SIZE(packSizes, 0);
+  }
 
   FST_SET_TRANSITION_PACK_SIZE(packSizes, tSize);
 
@@ -290,7 +287,7 @@ void fstStateCompileForAnyTrans(FstCountingWriter *w, CompiledAddr addr, FstBuil
   for (int32_t i = sz - 1; i >= 0; i--) {
     FstTransition *t = taosArrayGet(node->trans, i);
     fstCountingWriterWrite(w, (char *)&t->inp, 1);
-      //fstPackDeltaIn(w, addr, t->addr, tSize);
+    // fstPackDeltaIn(w, addr, t->addr, tSize);
   }
   if (sz > TRANS_INDEX_THRESHOLD) {
     // A value of 255 indicates that no transition exists for the byte
@@ -299,13 +296,13 @@ void fstStateCompileForAnyTrans(FstCountingWriter *w, CompiledAddr addr, FstBuil
     // this node indicates an absent transition.
     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++) {
+    /// 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);
       index[t->inp] = i;
-      //fstPackDeltaIn(w, addr, t->addr, tSize);
+      // fstPackDeltaIn(w, addr, t->addr, tSize);
     }
     fstCountingWriterWrite(w, (char *)index, 256);
     free(index);
@@ -318,15 +315,18 @@ void fstStateCompileForAnyTrans(FstCountingWriter *w, CompiledAddr addr, FstBuil
     // the # of transitions can never be 1 here, since 1 is always
     // encoded in the state byte.
     uint8_t v = 1;
-    if (sz == 256) { fstCountingWriterWrite(w, (char *)&v, 1); }
-    else { fstCountingWriterWrite(w, (char *)&sz, 1); }
+    if (sz == 256) {
+      fstCountingWriterWrite(w, (char *)&v, 1);
+    } else {
+      fstCountingWriterWrite(w, (char *)&sz, 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;
@@ -335,49 +335,42 @@ 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) {
     *null = true;
     return v;
   }
-  //v = 0 indicate that common_input is None
+  // v = 0 indicate that common_input is None
   return v == 0 ? 0 : COMMON_INPUT(v);
 }
 
 // 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);
-  return null ? 1 : 0 ;
+  return null ? 1 : 0;
 }
 
 // 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) {
   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) {
+  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) {
   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 
-               - fstStateTotalTransSize(state, version, sizes, nTrans) 
-               - nTrans * oSizes  // output values
+  return FST_SLICE_LEN(date) - 1 - fstStateNtransLen(state) - 1                     // pack size
+         - fstStateTotalTransSize(state, version, sizes, nTrans) - nTrans * oSizes  // output values
          - finalOsize;                                                              // final output
 }
 // input
@@ -386,19 +379,15 @@ uint8_t  fstStateInput(FstState *s, FstNode *node) {
   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) {
   assert(s->state == AnyTrans);
   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 
+  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);
   return data[at];
@@ -413,14 +402,12 @@ CompiledAddr fstStateTransAddr(FstState *s, FstNode *node) {
   } else {
     PackSizes sizes = node->sizes;
     uint8_t   tSizes = FST_GET_TRANSITION_PACK_SIZE(sizes);
-    uint64_t i = node->start 
-                - fstStateInputLen(s)
-                - 1 // PackSizes
+    uint64_t  i = node->start - fstStateInputLen(s) - 1  // PackSizes
                  - tSizes;
 
     // refactor error logic
     uint8_t *data = fstSliceData(slice, NULL);
-    return unpackDelta(data +i, tSizes, node->end);      
+    return unpackDelta(data + i, tSizes, node->end);
   }
 }
 CompiledAddr fstStateTransAddrForAnyTrans(FstState *s, FstNode *node, uint64_t i) {
@@ -428,20 +415,15 @@ CompiledAddr fstStateTransAddrForAnyTrans(FstState *s, FstNode *node, uint64_t i
 
   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;
+  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) {
-  assert(s->state == OneTrans || s->state == AnyTrans) ;
+  assert(s->state == OneTrans || s->state == AnyTrans);
   uint64_t i;
   if (s->state == OneTrans) {
     i = FST_SLICE_LEN(slice) - 1 - fstStateInputLen(s) - 1;
@@ -450,7 +432,7 @@ PackSizes fstStateSizes(FstState *s, FstSlice *slice) {
   }
 
   uint8_t *data = fstSliceData(slice, NULL);
-  return (PackSizes)(*(data +i));
+  return (PackSizes)(*(data + i));
 }
 // Output
 Output fstStateOutput(FstState *s, FstNode *node) {
@@ -463,14 +445,9 @@ Output fstStateOutput(FstState *s, FstNode *node) {
   FstSlice *slice = &node->data;
   uint8_t   tSizes = FST_GET_TRANSITION_PACK_SIZE(node->sizes);
 
-  uint64_t i = node->start 
-                - fstStateInputLen(s)
-                - 1
-                - tSizes 
-                - oSizes;
+  uint64_t i = node->start - fstStateInputLen(s) - 1 - tSizes - oSizes;
   uint8_t *data = fstSliceData(slice, NULL);
   return unpackUint64(data + i, oSizes);
-  
 }
 Output fstStateOutputForAnyTrans(FstState *s, FstNode *node, uint64_t i) {
   assert(s->state == AnyTrans);
@@ -480,13 +457,9 @@ Output fstStateOutputForAnyTrans(FstState *s, FstNode *node, uint64_t i) {
     return 0;
   }
   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;
+  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;
 
   return unpackUint64(data + at, oSizes);
 }
@@ -495,7 +468,9 @@ Output fstStateOutputForAnyTrans(FstState *s, FstNode *node, uint64_t i) {
 
 void fstStateSetFinalState(FstState *s, bool yes) {
   assert(s->state == AnyTrans);
-  if (yes) { s->val |= 0b01000000; } 
+  if (yes) {
+    s->val |= 0b01000000;
+  }
   return;
 }
 bool fstStateIsFinalState(FstState *s) {
@@ -528,7 +503,7 @@ uint64_t fstStateTotalTransSize(FstState *s, uint64_t version, PackSizes sizes,
 }
 uint64_t fstStateTransIndexSize(FstState *s, uint64_t version, uint64_t nTrans) {
   assert(s->state == AnyTrans);
-  return (version >= 2 &&nTrans > TRANS_INDEX_THRESHOLD) ?  256 : 0;
+  return (version >= 2 && nTrans > TRANS_INDEX_THRESHOLD) ? 256 : 0;
 }
 uint64_t fstStateNtransLen(FstState *s) {
   assert(s->state == AnyTrans);
@@ -545,8 +520,9 @@ uint64_t fstStateNtrans(FstState *s, FstSlice *slice) {
   int32_t  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  
+  // 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) {
   uint8_t oSizes = FST_GET_OUTPUT_PACK_SIZE(sizes);
@@ -554,61 +530,54 @@ Output  fstStateFinalOutput(FstState *s, uint64_t version, FstSlice *slice, Pack
     return 0;
   }
 
-   uint64_t at = FST_SLICE_LEN(slice) 
-                 - 1 
-                 - fstStateNtransLen(s)
-                 - 1 // pack size
-                 - fstStateTotalTransSize(s, version, sizes, nTrans)
-                 - (nTrans * oSizes)
-                 - oSizes;
+  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);
   return unpackUint64(data + at, (uint8_t)oSizes);
-
 }
 uint64_t fstStateFindInput(FstState *s, FstNode *node, uint8_t b, bool *null) {
   assert(s->state == AnyTrans);
   FstSlice *slice = &node->data;
   if (node->version >= 2 && node->nTrans > TRANS_INDEX_THRESHOLD) {
-    uint64_t at = node->start
-                  - fstStateNtransLen(s)
-                  - 1 // pack size 
+    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);
     uint64_t i = data[at + b];
-    //uint64_t i = slice->data[slice->start + at + b];  
+    // uint64_t i = slice->data[slice->start + at + b];
     if (i >= node->nTrans) {
       *null = true;
     }
     return i;
   } else {
-    uint64_t start = node->start 
-                    - fstStateNtransLen(s)
-                    - 1 // pack size
+    uint64_t start = node->start - fstStateNtransLen(s) - 1  // pack size
                      - node->nTrans;
     uint64_t end = start + node->nTrans;
     FstSlice t = fstSliceCopy(slice, start, end - 1);
     int32_t  len = 0;
     uint8_t *data = fstSliceData(&t, &len);
     int      i = 0;
-    for(; i < len; i++) {
+    for (; i < len; i++) {
       uint8_t v = data[i];
       if (v == b) {
         fstSliceDestroy(&t);
         return node->nTrans - i - 1;  // bug
       }
     }
-    if (i == len) { *null = true; }
+    if (i == len) {
+      *null = true;
+    }
     fstSliceDestroy(&t);
   }
 }
 
-
 // fst node function
 
 FstNode *fstNodeCreate(int64_t version, CompiledAddr addr, FstSlice *slice) {
   FstNode *n = (FstNode *)malloc(sizeof(FstNode));
-  if (n == NULL) { return NULL; }
+  if (n == NULL) {
+    return NULL;
+  }
 
   FstState st = fstStateCreateFrom(slice, addr);
 
@@ -656,7 +625,8 @@ 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;
 }
@@ -667,12 +637,11 @@ static const char *fstNodeState(FstNode *node) {
   return fstStateStr[st->state];
 }
 
-
 void fstNodeDestroy(FstNode *node) {
   fstSliceDestroy(&node->data);
   free(node);
 }
-FstTransitions* fstNodeTransitions(FstNode *node) {
+FstTransitions *fstNodeTransitions(FstNode *node) {
   FstTransitions *t = malloc(sizeof(FstTransitions));
   if (NULL == t) {
     return NULL;
@@ -717,7 +686,7 @@ bool fstNodeGetTransitionAddrAt(FstNode *node, uint64_t i, CompiledAddr *res) {
     fstStateTransAddr(st, node);
   } else if (st->state == AnyTrans) {
     fstStateTransAddrForAnyTrans(st, node, i);
-  } else if (FST_STATE_EMPTY_FINAL(node)){
+  } else if (FST_STATE_EMPTY_FINAL(node)) {
     s = false;
   } else {
     assert(0);
@@ -731,16 +700,25 @@ bool fstNodeFindInput(FstNode *node, uint8_t b, uint64_t *res) {
   bool      s = true;
   FstState *st = &node->state;
   if (st->state == OneTransNext) {
-    if (fstStateInput(st,node) == b) { *res = 0; } 
-    else { s = false; } } 
-  else if (st->state == OneTrans) {
-    if (fstStateInput(st, node) == b) { *res = 0 ;}
-    else {  s = false; }
+    if (fstStateInput(st, node) == b) {
+      *res = 0;
+    } else {
+      s = false;
+    }
+  } else if (st->state == OneTrans) {
+    if (fstStateInput(st, node) == b) {
+      *res = 0;
+    } else {
+      s = false;
+    }
   } else if (st->state == AnyTrans) {
     bool     null = false;
     uint64_t out = fstStateFindInput(st, node, b, &null);
-    if (null == false) { *res = out; } 
-    else { s = false;}
+    if (null == false) {
+      *res = out;
+    } else {
+      s = false;
+    }
   }
   return s;
 }
@@ -757,11 +735,11 @@ bool fstNodeCompile(FstNode *node, void *w, CompiledAddr lastAddr, CompiledAddr
     FstTransition *tran = taosArrayGet(builderNode->trans, 0);
     if (tran->addr == lastAddr && tran->out == 0) {
       fstStateCompileForOneTransNext(w, addr, tran->inp);
-       //OneTransNext::compile(w, lastAddr, tran->inp);
+      // OneTransNext::compile(w, lastAddr, tran->inp);
       return true;
     } else {
       fstStateCompileForOneTrans(w, addr, tran);
-      //OneTrans::Compile(w, lastAddr, *tran);
+      // OneTrans::Compile(w, lastAddr, *tran);
       return true;
     }
   }
@@ -772,16 +750,15 @@ bool fstBuilderNodeCompileTo(FstBuilderNode *b, FstCountingWriter *wrt, Compiled
   return fstNodeCompile(NULL, wrt, lastAddr, startAddr, b);
 }
 
-
-
 FstBuilder *fstBuilderCreate(void *w, FstType ty) {
   FstBuilder *b = malloc(sizeof(FstBuilder));
-  if (NULL == b) { return b; }
-
+  if (NULL == b) {
+    return b;
+  }
 
   b->wrt = fstCountingWriterCreate(w);
   b->unfinished = fstUnFinishedNodesCreate();
-  b->registry   = fstRegistryCreate(10000, 2) ;
+  b->registry = fstRegistryCreate(10000, 2);
   b->last = fstSliceCreate(NULL, 0);
   b->lastAddr = NONE_ADDRESS;
   b->len = 0;
@@ -799,7 +776,9 @@ FstBuilder *fstBuilderCreate(void *w, FstType ty) {
   return b;
 }
 void fstBuilderDestroy(FstBuilder *b) {
-  if (b == NULL) { return; }
+  if (b == NULL) {
+    return;
+  }
 
   fstCountingWriterDestroy(b->wrt);
   fstUnFinishedNodesDestroy(b->unfinished);
@@ -808,7 +787,6 @@ void fstBuilderDestroy(FstBuilder *b) {
   free(b);
 }
 
-
 bool fstBuilderInsert(FstBuilder *b, FstSlice bs, Output in) {
   OrderType t = fstBuilderCheckLastKey(b, bs, true);
   if (t == Ordered) {
@@ -827,7 +805,7 @@ void fstBuilderInsertOutput(FstBuilder *b, FstSlice bs, Output in) {
     fstUnFinishedNodesSetRootOutput(b->unfinished, in);
     return;
   }
-   //if (in != 0) { //if let Some(in) = in 
+  // if (in != 0) { //if let Some(in) = in
   //   prefixLen = fstUnFinishedNodesFindCommPrefixAndSetOutput(b->unfinished, bs, in, &out);
   //} else {
   //   prefixLen = fstUnFinishedNodesFindCommPrefix(b->unfinished, bs);
@@ -848,7 +826,7 @@ void fstBuilderInsertOutput(FstBuilder *b, FstSlice bs, Output in) {
   fstUnFinishedNodesAddSuffix(b->unfinished, sub, out);
   fstSliceDestroy(&sub);
   return;
- }
+}
 
 OrderType fstBuilderCheckLastKey(FstBuilder *b, FstSlice bs, bool ckDup) {
   FstSlice *input = &bs;
@@ -882,15 +860,13 @@ void fstBuilderCompileFrom(FstBuilder *b, uint64_t istate) {
 
     fstBuilderNodeDestroy(bn);
     assert(addr != NONE_ADDRESS);
-    //fstBuilderNodeDestroy(n);
+    // fstBuilderNodeDestroy(n);
   }
   fstUnFinishedNodesTopLastFreeze(b->unfinished, addr);
   return;
 }
 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)) {
+  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);
@@ -911,7 +887,7 @@ 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);
   CompiledAddr    rootAddr = fstBuilderCompile(b, rootNode);
@@ -928,21 +904,17 @@ 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));
 
   fstCountingWriterFlush(b->wrt);
-  //fstCountingWriterDestroy(b->wrt);  
-  //b->wrt = NULL;
+  // fstCountingWriterDestroy(b->wrt);
+  // 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;
@@ -952,19 +924,21 @@ FstSlice fstNodeAsSlice(FstNode *node) {
 
 FstLastTransition *fstLastTransitionCreate(uint8_t inp, Output out) {
   FstLastTransition *trn = malloc(sizeof(FstLastTransition));
-  if (trn == NULL) { return NULL; }
+  if (trn == NULL) {
+    return NULL;
+  }
 
   trn->inp = inp;
   trn->out = out;
   return trn;
 }
 
-void fstLastTransitionDestroy(FstLastTransition *trn) {
-  free(trn);
-}
+void fstLastTransitionDestroy(FstLastTransition *trn) { free(trn); }
 void fstBuilderNodeUnfinishedLastCompiled(FstBuilderNodeUnfinished *unNode, CompiledAddr addr) {
   FstLastTransition *trn = unNode->last;
-  if (trn == NULL) { return; }  
+  if (trn == NULL) {
+    return;
+  }
   FstTransition t = {.inp = trn->inp, .out = trn->out, .addr = addr};
   taosArrayPush(unNode->node->trans, &t);
   fstLastTransitionDestroy(trn);
@@ -987,9 +961,9 @@ void fstBuilderNodeUnfinishedAddOutputPrefix(FstBuilderNodeUnfinished *unNode, O
   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;
   }
@@ -1018,9 +992,11 @@ Fst* fstCreate(FstSlice *slice) {
   uint64_t fstLen;
   len -= sizeof(fstLen);
   taosDecodeFixedU64(buf + len, &fstLen);
-  //TODO(validate root addr)
-  Fst *fst= (Fst *)calloc(1, sizeof(Fst)); 
-  if (fst == NULL) { return NULL; }  
+  // TODO(validate root addr)
+  Fst *fst = (Fst *)calloc(1, sizeof(Fst));
+  if (fst == NULL) {
+    return NULL;
+  }
 
   fst->meta = (FstMeta *)malloc(sizeof(FstMeta));
   if (NULL == fst->meta) {
@@ -1042,7 +1018,6 @@ Fst* fstCreate(FstSlice *slice) {
 FST_CREAT_FAILED:
   free(fst->meta);
   free(fst);
-
 }
 void fstDestroy(Fst *fst) {
   if (fst) {
@@ -1091,16 +1066,14 @@ bool fstGet(Fst *fst, FstSlice *b, Output *out) {
 
   return true;
 }
-FstStreamBuilder *fstSearch(Fst *fst, AutomationCtx *ctx) {
-  return fstStreamBuilderCreate(fst, ctx);
-}
-StreamWithState* streamBuilderIntoStream(FstStreamBuilder *sb) {
-  if (sb == NULL) { return NULL; } 
+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) {
   if (fst->root != NULL) {
@@ -1110,16 +1083,9 @@ FstNode *fstGetRoot(Fst *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   res = 0;
@@ -1145,9 +1111,11 @@ bool fstVerify(Fst *fst) {
 }
 
 // data bound function
-FstBoundWithData* fstBoundStateCreate(FstBound type, FstSlice *data) {
+FstBoundWithData *fstBoundStateCreate(FstBound type, FstSlice *data) {
   FstBoundWithData *b = calloc(1, sizeof(FstBoundWithData));
-  if (b == NULL) { return NULL; }
+  if (b == NULL) {
+    return NULL;
+  }
 
   if (data != NULL) {
     b->data = fstSliceCopy(data, data->start, data->end);
@@ -1159,7 +1127,6 @@ FstBoundWithData* fstBoundStateCreate(FstBound type, FstSlice *data) {
   return b;
 }
 
-
 bool fstBoundWithDataExceededBy(FstBoundWithData *bound, FstSlice *slice) {
   int comp = fstSliceCompare(slice, &bound->data);
   if (bound->type == Included) {
@@ -1178,18 +1145,16 @@ 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 *streamWithStateCreate(
+    Fst *fst, AutomationCtx *automation, FstBoundWithData *min, FstBoundWithData *max) {
   StreamWithState *sws = calloc(1, sizeof(StreamWithState));
-  if (sws == NULL) { return NULL; } 
+  if (sws == NULL) {
+    return NULL;
+  }
 
   sws->fst = fst;
   sws->aut = automation;
@@ -1205,7 +1170,9 @@ StreamWithState *streamWithStateCreate(Fst *fst, AutomationCtx *automation, FstB
   return sws;
 }
 void streamWithStateDestroy(StreamWithState *sws) {
-  if (sws == NULL) { return; }
+  if (sws == NULL) {
+    return;
+  }
 
   taosArrayDestroy(sws->inp);
   taosArrayDestroyEx(sws->stack, streamStateDestroy);
@@ -1214,7 +1181,6 @@ void streamWithStateDestroy(StreamWithState *sws) {
 }
 
 bool streamWithStateSeekMin(StreamWithState *sws, FstBoundWithData *min) {
-
   AutomationCtx *aut = sws->aut;
   if (fstBoundWithDataIsEmpty(min)) {
     if (fstBoundWithDataIsIncluded(min)) {
@@ -1228,7 +1194,8 @@ bool streamWithStateSeekMin(StreamWithState *sws, FstBoundWithData *min) {
     return true;
   }
   FstSlice *key = NULL;
-  bool inclusize = false;;
+  bool      inclusize = false;
+  ;
 
   if (min->type == Included) {
     key = &min->data;
@@ -1241,8 +1208,8 @@ bool streamWithStateSeekMin(StreamWithState *sws, FstBoundWithData *min) {
 
   FstNode *node = fstGetRoot(sws->fst);
   Output   out = 0;
-  //void*   autState = sws->aut->start();  
-  void* autState = automFuncs[aut->type].start(aut);
+  // void*   autState = sws->aut->start();
+  void *autState = automFuncs[aut->type].start(aut);
 
   int32_t  len;
   uint8_t *data = fstSliceData(key, &len);
@@ -1257,16 +1224,12 @@ bool streamWithStateSeekMin(StreamWithState *sws, FstBoundWithData *min) {
       // autState = sws->aut->accept(preState, b);
       autState = automFuncs[aut->type].accept(aut, preState, b);
       taosArrayPush(sws->inp, &b);
-      StreamState s = {.node     = node, 
-                       .trans    = res + 1, 
-                       .out      = {.null = false, .out = out}, 
-                       .autState = preState}; 
+      StreamState s = {.node = node, .trans = res + 1, .out = {.null = false, .out = out}, .autState = preState};
       taosArrayPush(sws->stack, &s);
       out += trn.out;
       node = fstGetNode(sws->fst, trn.addr);
       fstNodeDestroy(node);
     } else {
-
       // This is a little tricky. We're in this case if the
       // given bound is not a prefix of any key in the FST.
       // Since this is a minimum bound, we need to find the
@@ -1281,10 +1244,7 @@ bool streamWithStateSeekMin(StreamWithState *sws, FstBoundWithData *min) {
         }
       }
 
-      StreamState s = {.node     = node, 
-                       .trans    = i, 
-                       .out      = {.null = false, .out = out}, 
-                       .autState = autState}; 
+      StreamState s = {.node = node, .trans = i, .out = {.null = false, .out = out}, .autState = autState};
       taosArrayPush(sws->stack, &s);
       return true;
     }
@@ -1296,14 +1256,12 @@ bool streamWithStateSeekMin(StreamWithState *sws, FstBoundWithData *min) {
       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;
     }
@@ -1340,27 +1298,26 @@ 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);
     taosArrayPush(nodes, &nextNode);
     taosArrayPush(sws->inp, &(trn.inp));
 
     if (FST_NODE_IS_FINAL(nextNode)) {
-      //void *eofState = sws->aut->acceptEof(nextState); 
+      // void *eofState = sws->aut->acceptEof(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};  
+    StreamState s1 = {.node = p->node, .trans = p->trans + 1, .out = p->out, .autState = p->autState};
     taosArrayPush(sws->stack, &s1);
 
     StreamState s2 = {.node = nextNode, .trans = 0, .out = {.null = false, .out = out}, .autState = nextState};
     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++) {
@@ -1385,17 +1342,18 @@ 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));
-  if (result == NULL) { return NULL; }
+  if (result == NULL) {
+    return NULL;
+  }
 
   result->data = fstSliceCopy(data, 0, FST_SLICE_LEN(data) - 1);
   result->out = fOut;
@@ -1404,7 +1362,9 @@ StreamWithStateResult *swsResultCreate(FstSlice *data, FstOutput fOut, void *sta
   return result;
 }
 void swsResultDestroy(StreamWithStateResult *result) {
-  if (NULL == result) { return; }
+  if (NULL == result) {
+    return;
+  }
 
   fstSliceDestroy(&result->data);
   startWithStateValueDestroy(result->state);
@@ -1412,16 +1372,20 @@ void swsResultDestroy(StreamWithStateResult *result) {
 }
 
 void streamStateDestroy(void *s) {
-  if (NULL == s) { return; }
+  if (NULL == s) {
+    return;
+  }
   StreamState *ss = (StreamState *)s;
 
   fstNodeDestroy(ss->node);
-  //free(s->autoState);
+  // free(s->autoState);
 }
 
 FstStreamBuilder *fstStreamBuilderCreate(Fst *fst, AutomationCtx *aut) {
   FstStreamBuilder *b = calloc(1, sizeof(FstStreamBuilder));
-  if (NULL == b) { return NULL; }
+  if (NULL == b) {
+    return NULL;
+  }
 
   b->fst = fst;
   b->aut = aut;
@@ -1437,7 +1401,9 @@ void fstStreamBuilderDestroy(FstStreamBuilder *b) {
   free(b);
 }
 FstStreamBuilder *fstStreamBuilderRange(FstStreamBuilder *b, FstSlice *val, RangeType type) {
-  if (b == NULL) { return NULL; }
+  if (b == NULL) {
+    return NULL;
+  }
 
   if (type == GE) {
     b->min->type = Included;
@@ -1458,9 +1424,3 @@ FstStreamBuilder *fstStreamBuilderRange(FstStreamBuilder *b, FstSlice *val, Rang
   }
   return b;
 }
-
-
-
-
-
-

source/libs/index/src/index_fst_automation.c

@@ -15,10 +15,11 @@
 
 #include "index_fst_automation.h"
 
-
 StartWithStateValue *startWithStateValueCreate(StartWithStateKind kind, ValueType ty, void *val) {
   StartWithStateValue *nsv = calloc(1, sizeof(StartWithStateValue));
-  if (nsv == NULL) { return NULL; }
+  if (nsv == NULL) {
+    return NULL;
+  }
 
   nsv->kind = kind;
   nsv->type = ty;
@@ -29,14 +30,16 @@ StartWithStateValue *startWithStateValueCreate(StartWithStateKind kind, ValueTyp
     nsv->ptr = (char *)calloc(1, len + 1);
     memcpy(nsv->ptr, val, len);
   } else if (ty == FST_ARRAY) {
-    //TODO, 
-    //nsv->arr = taosArrayFromList() 
+    // TODO,
+    // nsv->arr = taosArrayFromList()
   }
   return nsv;
 }
 void startWithStateValueDestroy(void *val) {
   StartWithStateValue *sv = (StartWithStateValue *)val;
-  if (sv == NULL) { return; }
+  if (sv == NULL) {
+    return;
+  }
 
   if (sv->type == FST_INT) {
     //
@@ -49,10 +52,12 @@ void startWithStateValueDestroy(void *val) {
 }
 StartWithStateValue *startWithStateValueDump(StartWithStateValue *sv) {
   StartWithStateValue *nsv = calloc(1, sizeof(StartWithStateValue));
-  if (nsv == NULL) { return NULL; }
+  if (nsv == NULL) {
+    return NULL;
+  }
 
   nsv->kind = sv->kind;
-  nsv->type= sv->type;
+  nsv->type = sv->type;
   if (nsv->type == FST_INT) {
     nsv->val = sv->val;
   } else if (nsv->type == FST_CHAR) {
@@ -64,27 +69,26 @@ StartWithStateValue *startWithStateValueDump(StartWithStateValue *sv) {
   return nsv;
 }
 
-
 // prefix query, impl later
 
-static void* prefixStart(AutomationCtx *ctx) {  
+static void *prefixStart(AutomationCtx *ctx) {
   StartWithStateValue *data = (StartWithStateValue *)(ctx->stdata);
   return startWithStateValueDump(data);
 };
 static bool prefixIsMatch(AutomationCtx *ctx, void *sv) {
-  StartWithStateValue* ssv = (StartWithStateValue *)sv;  
+  StartWithStateValue *ssv = (StartWithStateValue *)sv;
   return ssv->val == strlen(ctx->data);
 }
 static bool prefixCanMatch(AutomationCtx *ctx, void *sv) {
-  StartWithStateValue* ssv = (StartWithStateValue *)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) {
@@ -102,55 +106,30 @@ 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
-  },  
-  {
-    patternStart,
-    patternIsMatch,
-    patternCanMatch,
-    patternWillAlwaysMatch,
-    patternAccept,
-    patternAcceptEof
-  }
+AutomationFunc automFuncs[] = {
+    {prefixStart, prefixIsMatch, prefixCanMatch, prefixWillAlwaysMatch, prefixAccept, prefixAcceptEof},
+    {patternStart, patternIsMatch, patternCanMatch, patternWillAlwaysMatch, patternAccept, patternAcceptEof}
     // add more search type
 };
 
-AutomationCtx* automCtxCreate(void *data,AutomationType atype) {
+AutomationCtx *automCtxCreate(void *data, AutomationType atype) {
   AutomationCtx *ctx = calloc(1, sizeof(AutomationCtx));
-  if (ctx == NULL) { return NULL; }
+  if (ctx == NULL) {
+    return NULL;
+  }
 
   StartWithStateValue *sv = NULL;
   if (atype == AUTOMATION_PREFIX) {
@@ -158,14 +137,13 @@ AutomationCtx* automCtxCreate(void *data,AutomationType atype) {
     sv = startWithStateValueCreate(Running, FST_INT, &val);
     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;
 

source/libs/index/src/index_fst_common.c

@@ -12,8 +12,7 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
-
-#include "tutil.h"
+#include "index_fst_common.h"
 
 const uint8_t COMMON_INPUTS[] = {
     84,   // '\x00'
@@ -275,33 +274,260 @@ 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',
 };
-

source/libs/index/src/index_fst_counting_writer.c

@@ -12,10 +12,10 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
-#include "tutil.h"
+#include "index_fst_counting_writer.h"
 #include "indexInt.h"
 #include "index_fst_util.h"
-#include "index_fst_counting_writer.h"
+#include "tutil.h"
 
 static int writeCtxDoWrite(WriterCtx *ctx, uint8_t *buf, int len) {
   if (ctx->offset + len > ctx->limit) {
@@ -25,7 +25,7 @@ static int writeCtxDoWrite(WriterCtx *ctx, uint8_t *buf, int len) {
   if (ctx->type == TFile) {
     assert(len == tfWrite(ctx->file.fd, buf, len));
   } else {
-    memcpy(ctx->mem.buf+ ctx->offset, buf, len);
+    memcpy(ctx->mem.buf + ctx->offset, buf, len);
   }
   ctx->offset += len;
   return len;
@@ -43,17 +43,19 @@ static int writeCtxDoRead(WriterCtx *ctx, uint8_t *buf, int len) {
 }
 static int writeCtxDoFlush(WriterCtx *ctx) {
   if (ctx->type == TFile) {
-    //tfFsync(ctx->fd);
-    //tfFlush(ctx->file.fd);
+    // tfFsync(ctx->fd);
+    // tfFlush(ctx->file.fd);
   } else {
     // do nothing
   }
   return 1;
 }
 
-WriterCtx* writerCtxCreate(WriterType type, const char *path, bool readOnly, int32_t capacity) {     
+WriterCtx *writerCtxCreate(WriterType type, const char *path, bool readOnly, int32_t capacity) {
   WriterCtx *ctx = calloc(1, sizeof(WriterCtx));
-  if (ctx == NULL) { return NULL; }
+  if (ctx == NULL) {
+    return NULL;
+  }
 
   ctx->type = type;
   if (ctx->type == TFile) {
@@ -81,7 +83,9 @@ WriterCtx* writerCtxCreate(WriterType type, const char *path, bool readOnly, int
 
   return ctx;
 END:
-  if (ctx->type == TMemory) { free(ctx->mem.buf); } 
+  if (ctx->type == TMemory) {
+    free(ctx->mem.buf);
+  }
   free(ctx);
 }
 void writerCtxDestroy(WriterCtx *ctx) {
@@ -93,10 +97,11 @@ void writerCtxDestroy(WriterCtx *ctx) {
   free(ctx);
 }
 
-
 FstCountingWriter *fstCountingWriterCreate(void *wrt) {
   FstCountingWriter *cw = calloc(1, sizeof(FstCountingWriter));
-  if (cw == NULL) { return NULL; }
+  if (cw == NULL) {
+    return NULL;
+  }
 
   cw->wrt = wrt;
   //(void *)(writerCtxCreate(TFile, readOnly));
@@ -105,12 +110,14 @@ FstCountingWriter *fstCountingWriterCreate(void *wrt) {
 void fstCountingWriterDestroy(FstCountingWriter *cw) {
   // free wrt object: close fd or free mem
   fstCountingWriterFlush(cw);
-  //writerCtxDestroy((WriterCtx *)(cw->wrt));
+  // writerCtxDestroy((WriterCtx *)(cw->wrt));
   free(cw);
 }
 
 int fstCountingWriterWrite(FstCountingWriter *write, uint8_t *buf, uint32_t len) {
-  if (write == NULL) { return 0; } 
+  if (write == NULL) {
+    return 0;
+  }
   // update checksum
   // write data to file/socket or mem
   WriterCtx *ctx = write->wrt;
@@ -121,21 +128,20 @@ int fstCountingWriterWrite(FstCountingWriter *write, uint8_t *buf, uint32_t len)
   return len;
 }
 int fstCountingWriterRead(FstCountingWriter *write, uint8_t *buf, uint32_t len) {
-  if (write == NULL) { return 0; }
+  if (write == NULL) {
+    return 0;
+  }
   WriterCtx *ctx = write->wrt;
   int        nRead = ctx->read(ctx, buf, len);
-  //assert(nRead == len);
+  // assert(nRead == len);
   return nRead;
 }
 
-uint32_t fstCountingWriterMaskedCheckSum(FstCountingWriter *write) {
-  
-  return 0;
-}
+uint32_t fstCountingWriterMaskedCheckSum(FstCountingWriter *write) { return 0; }
 int      fstCountingWriterFlush(FstCountingWriter *write) {
   WriterCtx *ctx = write->wrt;
   ctx->flush(ctx);
-  //write->wtr->flush
+  // write->wtr->flush
   return 1;
 }
 
@@ -156,5 +162,3 @@ uint8_t fstCountingWriterPackUint(FstCountingWriter *writer, uint64_t n) {
   fstCountingWriterPackUintIn(writer, n, nBytes);
   return nBytes;
 }
-
-

source/libs/index/src/index_fst_node.c

@@ -22,23 +22,27 @@ FstBuilderNode *fstBuilderNodeDefault() {
   return bn;
 }
 void fstBuilderNodeDestroy(FstBuilderNode *node) {
-  if (node == NULL) { return; }
+  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 ) {
+  if (n1 == n2) {
+    return true;
+  }
+  if (n1 == NULL || n2 == NULL) {
     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;
+  size_t s1 = n1->trans ? taosArrayGetSize(n1->trans) : 0;
+  size_t s2 = n2->trans ? taosArrayGetSize(n2->trans) : 0;
   if (s1 != s2) {
     return false;
   }
@@ -54,7 +58,9 @@ bool fstBuilderNodeEqual(FstBuilderNode *n1, FstBuilderNode *n2) {
 }
 FstBuilderNode *fstBuilderNodeClone(FstBuilderNode *src) {
   FstBuilderNode *node = malloc(sizeof(FstBuilderNode));
-  if (node == NULL) { return NULL; }
+  if (node == NULL) {
+    return NULL;
+  }
 
   //
   size_t  sz = taosArrayGetSize(src->trans);
@@ -69,16 +75,17 @@ FstBuilderNode *fstBuilderNodeClone(FstBuilderNode *src) {
   node->isFinal = src->isFinal;
   node->finalOutput = src->finalOutput;
   return node;
-
 }
 // not destroy src, User's bussiness
 void fstBuilderNodeCloneFrom(FstBuilderNode *dst, FstBuilderNode *src) {
-  if (dst == NULL || src == NULL) { return; } 
+  if (dst == NULL || src == NULL) {
+    return;
+  }
 
   dst->isFinal = src->isFinal;
   dst->finalOutput = src->finalOutput;
 
-  //release free  avoid mem leak
+  // release free  avoid mem leak
   taosArrayDestroy(dst->trans);
   size_t sz = taosArrayGetSize(src->trans);
   dst->trans = taosArrayInit(sz, sizeof(FstTransition));
@@ -88,28 +95,26 @@ void fstBuilderNodeCloneFrom(FstBuilderNode *dst, FstBuilderNode *src) {
   }
 }
 
-
-//bool fstBuilderNodeCompileTo(FstBuilderNode *b, FstCountingWriter *wrt, CompiledAddr lastAddr, CompiledAddr startAddr) {
-  
-  //size_t sz = taosArrayGetSize(b->trans);  
-  //assert(sz < 256);
-  //if (FST_BUILDER_NODE_IS_FINAL(b) 
-  //    && FST_BUILDER_NODE_TRANS_ISEMPTY(b) 
-  //    && FST_BUILDER_NODE_FINALOUTPUT_ISZERO(b)) {
-  //  return true; 
-  //} else if (sz != 1 || b->isFinal) {
-  //  // AnyTrans->Compile(w, addr, node);
-  //} else {
-  //  FstTransition *tran = taosArrayGet(b->trans, 0);   
-  //  if (tran->addr == lastAddr && tran->out == 0) {
-  //     //OneTransNext::compile(w, lastAddr, tran->inp);
-  //     return true;
-  //  } else {
-  //    //OneTrans::Compile(w, lastAddr, *tran);
-  //     return true;
-  //  } 
-  //} 
-  //return true; 
+// bool fstBuilderNodeCompileTo(FstBuilderNode *b, FstCountingWriter *wrt, CompiledAddr lastAddr, CompiledAddr
+// startAddr) {
+
+// size_t sz = taosArrayGetSize(b->trans);
+// assert(sz < 256);
+// if (FST_BUILDER_NODE_IS_FINAL(b)
+//    && FST_BUILDER_NODE_TRANS_ISEMPTY(b)
+//    && FST_BUILDER_NODE_FINALOUTPUT_ISZERO(b)) {
+//  return true;
+//} else if (sz != 1 || b->isFinal) {
+//  // AnyTrans->Compile(w, addr, node);
+//} else {
+//  FstTransition *tran = taosArrayGet(b->trans, 0);
+//  if (tran->addr == lastAddr && tran->out == 0) {
+//     //OneTransNext::compile(w, lastAddr, tran->inp);
+//     return true;
+//  } else {
+//    //OneTrans::Compile(w, lastAddr, *tran);
+//     return true;
+//  }
+//}
+// return true;
 //}
-
-

source/libs/index/src/index_fst_registry.c

@@ -15,9 +15,8 @@
 
 #include "index_fst_registry.h"
 
-
 uint64_t fstRegistryHash(FstRegistry *registry, FstBuilderNode *bNode) {
-  //TODO(yihaoDeng): refactor later
+  // TODO(yihaoDeng): refactor later
   const uint64_t FNV_PRIME = 1099511628211;
   uint64_t       h = 14695981039346656037u;
 
@@ -29,14 +28,15 @@ uint64_t fstRegistryHash(FstRegistry *registry, FstBuilderNode *bNode) {
     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;
+    h = (h ^ (uint64_t)(trn->addr)) * FNV_PRIME;
   }
-  return h %(registry->tableSize); 
-
+  return h % (registry->tableSize);
 }
 static void fstRegistryCellSwap(SArray *arr, uint32_t a, uint32_t b) {
   size_t sz = taosArrayGetSize(arr);
-  if (a >= sz || b >= sz) { return; }
+  if (a >= sz || b >= sz) {
+    return;
+  }
 
   FstRegistryCell *cell1 = (FstRegistryCell *)taosArrayGet(arr, a);
   FstRegistryCell *cell2 = (FstRegistryCell *)taosArrayGet(arr, b);
@@ -53,24 +53,28 @@ static void fstRegistryCellSwap(SArray *arr, uint32_t a, uint32_t b) {
 
 static void fstRegistryCellPromote(SArray *arr, uint32_t start, uint32_t end) {
   size_t sz = taosArrayGetSize(arr);
-  if (start >= sz && end >= sz) {return; }
+  if (start >= sz && end >= sz) {
+    return;
+  }
 
   assert(start >= end);
 
   int32_t s = (int32_t)start;
   int32_t e = (int32_t)end;
-  while(s > e) {
+  while (s > e) {
     fstRegistryCellSwap(arr, s - 1, s);
     s -= 1;
   }
 }
 
-FstRegistry* fstRegistryCreate(uint64_t tableSize, uint64_t mruSize) {
+FstRegistry *fstRegistryCreate(uint64_t tableSize, uint64_t mruSize) {
   FstRegistry *registry = malloc(sizeof(FstRegistry));
-  if (registry == NULL) { return NULL ;} 
+  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;
@@ -88,7 +92,9 @@ FstRegistry* fstRegistryCreate(uint64_t tableSize, uint64_t mruSize) {
 }
 
 void fstRegistryDestroy(FstRegistry *registry) {
-  if (registry == NULL) { return; }
+  if (registry == NULL) {
+    return;
+  }
 
   SArray *tb = registry->table;
   size_t  sz = taosArrayGetSize(tb);
@@ -111,10 +117,10 @@ FstRegistryEntry *fstRegistryGetEntry(FstRegistry *registry, FstBuilderNode *bNo
   FstRegistryEntry *entry = malloc(sizeof(FstRegistryEntry));
   if (end - start == 1) {
     FstRegistryCell *cell = taosArrayGet(registry->table, start);
-    //cell->isNode && 
+    // cell->isNode &&
     if (cell->addr != NONE_ADDRESS && fstBuilderNodeEqual(cell->node, bNode)) {
       entry->state = FOUND;
-       entry->addr  = cell->addr ;
+      entry->addr = cell->addr;
       return entry;
     } else {
       fstBuilderNodeCloneFrom(cell->node, bNode);
@@ -136,7 +142,7 @@ FstRegistryEntry *fstRegistryGetEntry(FstRegistry *registry, FstBuilderNode *bNo
       fstRegistryCellSwap(registry->table, start, start + 1);
       return entry;
     }
-    //clone from bNode, refactor later 
+    // clone from bNode, refactor later
     fstBuilderNodeCloneFrom(cell2->node, bNode);
 
     fstRegistryCellSwap(registry->table, start, start + 1);
@@ -157,7 +163,7 @@ FstRegistryEntry *fstRegistryGetEntry(FstRegistry *registry, FstBuilderNode *bNo
     if (i >= end) {
       uint64_t         last = end - 1;
       FstRegistryCell *cell = (FstRegistryCell *)taosArrayGet(registry->table, last);
-      //clone from bNode, refactor later 
+      // clone from bNode, refactor later
       fstBuilderNodeCloneFrom(cell->node, bNode);
 
       fstRegistryCellPromote(registry->table, last, start);
@@ -168,8 +174,4 @@ FstRegistryEntry *fstRegistryGetEntry(FstRegistry *registry, FstBuilderNode *bNo
   }
   return entry;
 }
-void fstRegistryEntryDestroy(FstRegistryEntry *entry) {
-  free(entry);  
-}
-
-
+void fstRegistryEntryDestroy(FstRegistryEntry *entry) { free(entry); }

source/libs/index/src/index_fst_util.c

@@ -15,9 +15,7 @@
 #include "index_fst_util.h"
 #include "index_fst_common.h"
 
-
-
-//A sentinel value used to indicate an empty final state
+// A sentinel value used to indicate an empty final state
 const CompiledAddr EMPTY_ADDRESS = 0;
 /// A sentinel value used to indicate an invalid state.
 const CompiledAddr NONE_ADDRESS = 1;
@@ -31,21 +29,18 @@ const uint64_t    VERSION        = 3;
 
 const uint64_t TRANS_INDEX_THRESHOLD = 32;
 
-
-//uint8_t commonInput(uint8_t idx) {
+// uint8_t commonInput(uint8_t idx) {
 //  if (idx == 0) { return -1; }
 //  else {
 //    return COMMON_INPUTS_INV[idx - 1];
 //  }
 //}
 //
-//uint8_t commonIdx(uint8_t v, uint8_t max) {
+// uint8_t commonIdx(uint8_t v, uint8_t max) {
 //  uint8_t v = ((uint16_t)tCOMMON_INPUTS[v] + 1)%256;
 //  return v > max ? 0: v;
 //}
 
-
-
 uint8_t packSize(uint64_t n) {
   if (n < (1u << 8)) {
     return 1;
@@ -107,15 +102,14 @@ FstSlice fstSliceCreate(uint8_t *data, uint64_t len) {
 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);
-  //end   = buf + end - (buf - s->start);  
+  // uint8_t *buf = fstSliceData(s, &alen);
+  // start = buf + start - (buf - s->start);
+  // end   = buf + end - (buf - s->start);
 
   FstSlice t = {.str = str, .start = start + s->start, .end = end + s->start};
   return t;
 }
 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);
@@ -135,9 +129,7 @@ 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;
@@ -165,27 +157,32 @@ int fstSliceCompare(FstSlice *a, FstSlice *b) {
   for (i = 0, j = 0; i < alen && j < blen; i++, j++) {
     uint8_t x = aBuf[i];
     uint8_t y = bBuf[j];
-    if (x == y) { continue;}
-    else if (x < y) { return -1; }
-    else { return 1; };
+    if (x == y) {
+      continue;
+    } else if (x < y) {
+      return -1;
+    } else {
+      return 1;
+    };
+  }
+  if (i < alen) {
+    return 1;
+  } else if (j < blen) {
+    return -1;
+  } else {
+    return 0;
   }
-  if (i < alen) { return 1; } 
-  else if (j < blen) { return -1; }
-  else { return 0; } 
 }
 
-//FstStack* fstStackCreate(size_t elemSize, StackFreeElem freeFn) {
+// FstStack* fstStackCreate(size_t elemSize, StackFreeElem freeFn) {
 //  FstStack *s = calloc(1, sizeof(FstStack));
 //  if (s == NULL) { return NULL; }
 //  s->
 //  s->freeFn
 //
 //}
-//void  *fstStackPush(FstStack *s, void *elem);
-//void  *fstStackTop(FstStack *s);
-//size_t fstStackLen(FstStack *s); 
-//void  *fstStackGetAt(FstStack *s, size_t i);
-//void   fstStackDestory(FstStack *); 
-
-
-
+// void  *fstStackPush(FstStack *s, void *elem);
+// void  *fstStackTop(FstStack *s);
+// size_t fstStackLen(FstStack *s);
+// void  *fstStackGetAt(FstStack *s, size_t i);
+// void   fstStackDestory(FstStack *);

source/libs/index/src/index_tfile.c

@@ -16,18 +16,18 @@
 //#include <sys/types.h>
 //#include <dirent.h>
 #include "index_tfile.h"
+#include "index.h"
 #include "index_fst.h"
+#include "index_fst_counting_writer.h"
 #include "index_util.h"
 #include "taosdef.h"
-#include "index.h"
-#include "index_fst_counting_writer.h"
-
 
-static FORCE_INLINE int tfileLoadHeader(WriterCtx *ctx, TFileReadHeader *header) {
-  //TODO simple tfile header later
+static FORCE_INLINE int tfileReadLoadHeader(TFileReader *reader) {
+  // TODO simple tfile header later
   char             buf[TFILE_HADER_PRE_SIZE];
-  char *p = buf;
-  int64_t nread = ctx->read(ctx, buf, TFILE_HADER_PRE_SIZE);
+  char *           p = buf;
+  TFileReadHeader *header = &reader->header;
+  int64_t          nread = reader->ctx->read(reader->ctx, buf, TFILE_HADER_PRE_SIZE);
   assert(nread == TFILE_HADER_PRE_SIZE);
 
   memcpy(&header->suid, p, sizeof(header->suid));
@@ -39,20 +39,22 @@ static FORCE_INLINE int tfileLoadHeader(WriterCtx *ctx, TFileReadHeader *header)
   int32_t colLen = 0;
   memcpy(&colLen, p, sizeof(colLen));
   assert(colLen < sizeof(header->colName));
-  nread = ctx->read(ctx, header->colName, colLen); 
+  nread = reader->ctx->read(reader->ctx, header->colName, colLen);
   assert(nread == colLen);
 
-  nread = ctx->read(ctx, &header->colType, sizeof(header->colType)); 
+  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);
-  if (NULL == dir) { return -1; } 
+  if (NULL == dir) {
+    return -1;
+  }
 
   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);
   }
@@ -90,7 +92,9 @@ static void tfileSerialCacheKey(TFileCacheKey *key, char *buf) {
 
 TFileCache *tfileCacheCreate(const char *path) {
   TFileCache *tcache = calloc(1, sizeof(TFileCache));
-  if (tcache == NULL) { return NULL; }
+  if (tcache == NULL) {
+    return NULL;
+  }
 
   tcache->tableCache = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
   tcache->capacity = 64;
@@ -99,7 +103,7 @@ TFileCache *tfileCacheCreate(const char *path) {
   tfileGetFileList(path, files);
   taosArraySort(files, tfileCompare);
   for (size_t i = 0; i < taosArrayGetSize(files); i++) {
-    char *file = taosArrayGetP(files, i); 
+    char *   file = taosArrayGetP(files, i);
     uint64_t suid;
     int      colId, version;
     if (0 != tfileParseFileName(file, &suid, &colId, &version)) {
@@ -107,29 +111,41 @@ TFileCache *tfileCacheCreate(const char *path) {
       continue;
     }
 
-    TFileReader *reader = calloc(1, sizeof(TFileReader));  
-    reader->ctx = writerCtxCreate(TFile, file, true, 1024 * 64); 
-    if (reader->ctx == NULL) {
-      TFileReaderDestroy(reader);  
+    WriterCtx *wc = writerCtxCreate(TFile, file, true, 1024 * 64);
+    if (wc == NULL) {
       indexError("failed to open index:  %s", file);
       goto End;
     }
-    TFileReadHeader header = {0}; 
-    if (0 != tfileLoadHeader(reader->ctx, &header)) {
+    TFileReader *reader = tfileReaderCreate(wc);
+    if (0 != tfileReadLoadHeader(reader)) {
       TFileReaderDestroy(reader);
       indexError("failed to load index header, index Id: %s", file);
+      goto End;
     }
   }
   taosArrayDestroyEx(files, tfileDestroyFileName);
   return tcache;
 End:
+  tfileCacheDestroy(tcache);
   taosArrayDestroyEx(files, tfileDestroyFileName);
   return NULL;
 }
 void tfileCacheDestroy(TFileCache *tcache) {
+  if (tcache == NULL) {
+    return;
+  }
 
+  // free table cache
+  TFileReader **reader = taosHashIterate(tcache->tableCache, NULL);
+  while (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);
+    reader = taosHashIterate(tcache->tableCache, reader);
+  }
+  taosHashCleanup(tcache->tableCache);
   free(tcache);
-   
 }
 
 TFileReader *tfileCacheGet(TFileCache *tcache, TFileCacheKey *key) {
@@ -145,56 +161,47 @@ void tfileCachePut(TFileCache *tcache, TFileCacheKey *key, TFileReader *reader)
   return;
 }
 
-
-TFileReader* tfileReaderCreate() {
-  
+TFileReader *tfileReaderCreate(WriterCtx *ctx) {
+  TFileReader *reader = calloc(1, sizeof(TFileReader));
+  if (reader == NULL) {
+    return NULL;
+  }
+  reader->ctx = ctx;
+  // T_REF_INC(reader);
+  return reader;
 }
 void TFileReaderDestroy(TFileReader *reader) {
-  if (reader == NULL) { return; }
-
+  if (reader == NULL) {
+    return;
+  }
+  // T_REF_INC(reader);
   writerCtxDestroy(reader->ctx);
   free(reader);
 }
 
-
 TFileWriter *tfileWriterCreate(const char *suid, const char *colName);
 void         tfileWriterDestroy(TFileWriter *tw);
 
-
 IndexTFile *indexTFileCreate(const char *path) {
   IndexTFile *tfile = calloc(1, sizeof(IndexTFile));
   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) {
   IndexTFile *pTfile = (IndexTFile *)tfile;
 
-  SIndexTerm *term = query->term;
-  TFileCacheKey key = {.suid    = term->suid,
-                       .colType = term->colType,
-                       .version = 0,
-                       .colName = term->colName, 
-                       .nColName= term->nColName};
+  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);
   return 0;
 }
 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}; 
-
-  
+  TFileWriterOpt wOpt = {
+      .suid = term->suid, .colType = term->colType, .colName = term->colName, .nColName = term->nColName, .version = 1};
 
   return 0;
 }
-
-
-