diff --git a/include/common/tdataformat.h b/include/common/tdataformat.h
index 5b495601756d246abd08a3ef07f5efa8a6b47e62..ac94b0af7d8c2118e65a94f9b06e84c7b5ed4b48 100644
--- a/include/common/tdataformat.h
+++ b/include/common/tdataformat.h
@@ -66,10 +66,18 @@ int32_t tGetValue(uint8_t *p, SValue *pValue, int8_t type);
 int     tValueCmprFn(const SValue *pValue1, const SValue *pValue2, int8_t type);
 
 // SColVal ================================
-#define COL_VAL_NONE(CID, TYPE)     ((SColVal){.cid = (CID), .type = (TYPE), .isNone = 1})
-#define COL_VAL_NULL(CID, TYPE)     ((SColVal){.cid = (CID), .type = (TYPE), .isNull = 1})
+#define CV_FLAG_VALUE ((int8_t)0x0)
+#define CV_FLAG_NONE  ((int8_t)0x1)
+#define CV_FLAG_NULL  ((int8_t)0x2)
+
+#define COL_VAL_NONE(CID, TYPE)     ((SColVal){.cid = (CID), .type = (TYPE), .flag = CV_FLAG_NONE})
+#define COL_VAL_NULL(CID, TYPE)     ((SColVal){.cid = (CID), .type = (TYPE), .flag = CV_FLAG_NULL})
 #define COL_VAL_VALUE(CID, TYPE, V) ((SColVal){.cid = (CID), .type = (TYPE), .value = (V)})
 
+#define COL_VAL_IS_NONE(CV)  ((CV)->flag == CV_FLAG_NONE)
+#define COL_VAL_IS_NULL(CV)  ((CV)->flag == CV_FLAG_NULL)
+#define COL_VAL_IS_VALUE(CV) ((CV)->flag == CV_FLAG_VALUE)
+
 // STSRow2 ================================
 #define TSROW_LEN(PROW, V)  tGetI32v((uint8_t *)(PROW)->data, (V) ? &(V) : NULL)
 #define TSROW_SVER(PROW, V) tGetI32v((PROW)->data + TSROW_LEN(PROW, NULL), (V) ? &(V) : NULL)
@@ -175,8 +183,7 @@ struct SValue {
 struct SColVal {
   int16_t cid;
   int8_t  type;
-  int8_t  isNone;
-  int8_t  isNull;
+  int8_t  flag;
   SValue  value;
 };
 
diff --git a/source/common/src/tdataformat.c b/source/common/src/tdataformat.c
index 15a369fe404da6e279afe14bdaf3e68ac6a07f8a..c0ae99806e2f97fc3e4e4340ddc6a4716452dff1 100644
--- a/source/common/src/tdataformat.c
+++ b/source/common/src/tdataformat.c
@@ -212,9 +212,9 @@ int32_t tTSRowNew(STSRowBuilder *pBuilder, SArray *pArray, STSchema *pTSchema, S
         if (pColVal->cid == pTColumn->colId) {
           iColVal++;
 
-          if (pColVal->isNone) {
+          if (COL_VAL_IS_NONE(pColVal)) {
             flags |= TSROW_HAS_NONE;
-          } else if (pColVal->isNull) {
+          } else if (COL_VAL_IS_NULL(pColVal)) {
             flags |= TSROW_HAS_NULL;
             maxIdx = nkv;
             nTag++;
@@ -398,9 +398,9 @@ int32_t tTSRowNew(STSRowBuilder *pBuilder, SArray *pArray, STSchema *pTSchema, S
         if (pColVal->cid == pTColumn->colId) {
           iColVal++;
 
-          if (pColVal->isNone) {
+          if (COL_VAL_IS_NONE(pColVal)) {
             goto _set_none;
-          } else if (pColVal->isNull) {
+          } else if (COL_VAL_IS_NULL(pColVal)) {
             goto _set_null;
           } else {
             goto _set_value;
@@ -1222,9 +1222,9 @@ _exit:
 static FORCE_INLINE int32_t tColDataAppendValue0(SColData *pColData, SColVal *pColVal) {  // 0
   int32_t code = 0;
 
-  if (pColVal->isNone) {
+  if (COL_VAL_IS_NONE(pColVal)) {
     pColData->flag = HAS_NONE;
-  } else if (pColVal->isNull) {
+  } else if (COL_VAL_IS_NULL(pColVal)) {
     pColData->flag = HAS_NULL;
   } else {
     pColData->flag = HAS_VALUE;
@@ -1239,7 +1239,7 @@ _exit:
 static FORCE_INLINE int32_t tColDataAppendValue1(SColData *pColData, SColVal *pColVal) {  // HAS_NONE
   int32_t code = 0;
 
-  if (!pColVal->isNone) {
+  if (!COL_VAL_IS_NONE(pColVal)) {
     int32_t nBit = BIT1_SIZE(pColData->nVal + 1);
 
     code = tRealloc(&pColData->pBitMap, nBit);
@@ -1248,7 +1248,7 @@ static FORCE_INLINE int32_t tColDataAppendValue1(SColData *pColData, SColVal *pC
     memset(pColData->pBitMap, 0, nBit);
     SET_BIT1(pColData->pBitMap, pColData->nVal, 1);
 
-    if (pColVal->isNull) {
+    if (COL_VAL_IS_NULL(pColVal)) {
       pColData->flag |= HAS_NULL;
     } else {
       pColData->flag |= HAS_VALUE;
@@ -1279,12 +1279,12 @@ _exit:
 static FORCE_INLINE int32_t tColDataAppendValue2(SColData *pColData, SColVal *pColVal) {  // HAS_NULL
   int32_t code = 0;
 
-  if (!pColVal->isNull) {
+  if (!COL_VAL_IS_NULL(pColVal)) {
     int32_t nBit = BIT1_SIZE(pColData->nVal + 1);
     code = tRealloc(&pColData->pBitMap, nBit);
     if (code) goto _exit;
 
-    if (pColVal->isNone) {
+    if (COL_VAL_IS_NONE(pColVal)) {
       pColData->flag |= HAS_NONE;
 
       memset(pColData->pBitMap, 255, nBit);
@@ -1321,12 +1321,12 @@ _exit:
 static FORCE_INLINE int32_t tColDataAppendValue3(SColData *pColData, SColVal *pColVal) {  // HAS_NULL|HAS_NONE
   int32_t code = 0;
 
-  if (pColVal->isNone) {
+  if (COL_VAL_IS_NONE(pColVal)) {
     code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1));
     if (code) goto _exit;
 
     SET_BIT1(pColData->pBitMap, pColData->nVal, 0);
-  } else if (pColVal->isNull) {
+  } else if (COL_VAL_IS_NULL(pColVal)) {
     code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1));
     if (code) goto _exit;
 
@@ -1371,8 +1371,8 @@ _exit:
 static FORCE_INLINE int32_t tColDataAppendValue4(SColData *pColData, SColVal *pColVal) {  // HAS_VALUE
   int32_t code = 0;
 
-  if (pColVal->isNone || pColVal->isNull) {
-    if (pColVal->isNone) {
+  if (!COL_VAL_IS_VALUE(pColVal)) {
+    if (COL_VAL_IS_NONE(pColVal)) {
       pColData->flag |= HAS_NONE;
     } else {
       pColData->flag |= HAS_NULL;
@@ -1399,7 +1399,7 @@ _exit:
 static FORCE_INLINE int32_t tColDataAppendValue5(SColData *pColData, SColVal *pColVal) {  // HAS_VALUE|HAS_NONE
   int32_t code = 0;
 
-  if (pColVal->isNull) {
+  if (COL_VAL_IS_NULL(pColVal)) {
     pColData->flag |= HAS_NULL;
 
     uint8_t *pBitMap = NULL;
@@ -1417,7 +1417,7 @@ static FORCE_INLINE int32_t tColDataAppendValue5(SColData *pColData, SColVal *pC
     code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1));
     if (code) goto _exit;
 
-    if (pColVal->isNone) {
+    if (COL_VAL_IS_NONE(pColVal)) {
       SET_BIT1(pColData->pBitMap, pColData->nVal, 0);
     } else {
       SET_BIT1(pColData->pBitMap, pColData->nVal, 1);
@@ -1434,7 +1434,7 @@ _exit:
 static FORCE_INLINE int32_t tColDataAppendValue6(SColData *pColData, SColVal *pColVal) {  // HAS_VALUE|HAS_NULL
   int32_t code = 0;
 
-  if (pColVal->isNone) {
+  if (COL_VAL_IS_NONE(pColVal)) {
     pColData->flag |= HAS_NONE;
 
     uint8_t *pBitMap = NULL;
@@ -1452,7 +1452,7 @@ static FORCE_INLINE int32_t tColDataAppendValue6(SColData *pColData, SColVal *pC
     code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1));
     if (code) goto _exit;
 
-    if (pColVal->isNull) {
+    if (COL_VAL_IS_NULL(pColVal)) {
       SET_BIT1(pColData->pBitMap, pColData->nVal, 0);
     } else {
       SET_BIT1(pColData->pBitMap, pColData->nVal, 1);
@@ -1473,9 +1473,9 @@ static FORCE_INLINE int32_t tColDataAppendValue7(SColData *pColData,
   code = tRealloc(&pColData->pBitMap, BIT2_SIZE(pColData->nVal + 1));
   if (code) goto _exit;
 
-  if (pColVal->isNone) {
+  if (COL_VAL_IS_NONE(pColVal)) {
     SET_BIT2(pColData->pBitMap, pColData->nVal, 0);
-  } else if (pColVal->isNull) {
+  } else if (COL_VAL_IS_NULL(pColVal)) {
     SET_BIT2(pColData->pBitMap, pColData->nVal, 1);
   } else {
     SET_BIT2(pColData->pBitMap, pColData->nVal, 2);
diff --git a/source/common/src/trow.c b/source/common/src/trow.c
index 9880fe362eb55e909842cb0e9aec007667426c71..f23a2b386e280a185c1af7f4976070ed04d4f3f3 100644
--- a/source/common/src/trow.c
+++ b/source/common/src/trow.c
@@ -620,7 +620,7 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow) {
       ASSERT(pTColumn->colId == PRIMARYKEY_TIMESTAMP_COL_ID);
     } else {
       if (IS_VAR_DATA_TYPE(pTColumn->type)) {
-        if (pColVal && !pColVal->isNone && !pColVal->isNull) {
+        if (pColVal && COL_VAL_IS_VALUE(pColVal)) {
           varDataLen += (pColVal->value.nData + sizeof(VarDataLenT));
           if (maxVarDataLen < (pColVal->value.nData + sizeof(VarDataLenT))) {
             maxVarDataLen = pColVal->value.nData + sizeof(VarDataLenT);
@@ -680,9 +680,9 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow) {
     const void *val = NULL;
     if (iColVal < nColVal) {
       pColVal = (SColVal *)taosArrayGet(pArray, iColVal);
-      if (pColVal->isNone) {
+      if (COL_VAL_IS_NONE(pColVal)) {
         valType = TD_VTYPE_NONE;
-      } else if (pColVal->isNull) {
+      } else if (COL_VAL_IS_NULL(pColVal)) {
         valType = TD_VTYPE_NULL;
       } else if (IS_VAR_DATA_TYPE(pTColumn->type)) {
         varDataSetLen(varBuf, pColVal->value.nData);
diff --git a/source/dnode/vnode/src/tsdb/tsdbCache.c b/source/dnode/vnode/src/tsdb/tsdbCache.c
index 8452d14c869f1a41c81b904b90e13a49169f8f1e..32272b541cca6d6cf4057bd8f51e6facb0a86083 100644
--- a/source/dnode/vnode/src/tsdb/tsdbCache.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCache.c
@@ -272,8 +272,8 @@ int32_t tsdbCacheInsertLast(SLRUCache *pCache, tb_uid_t uid, STSRow *row, STsdb
 
         SColVal colVal = {0};
         tTSRowGetVal(row, pTSchema, iCol, &colVal);
-        if (colVal.isNone || colVal.isNull) {
-          if (keyTs == tTsVal1->ts && !tColVal->isNone && !tColVal->isNull) {
+        if (!COL_VAL_IS_VALUE(&colVal)) {
+          if (keyTs == tTsVal1->ts && COL_VAL_IS_VALUE(tColVal)) {
             invalidate = true;
 
             break;
@@ -1062,7 +1062,7 @@ static int32_t mergeLastRow(tb_uid_t uid, STsdb *pTsdb, bool *dup, STSRow **ppRo
           goto _err;
         }
 
-        if (pColVal->isNone && !setNoneCol) {
+        if (COL_VAL_IS_NONE(pColVal) && !setNoneCol) {
           noneCol = iCol;
           setNoneCol = true;
         }
@@ -1087,9 +1087,9 @@ static int32_t mergeLastRow(tb_uid_t uid, STsdb *pTsdb, bool *dup, STSRow **ppRo
       SColVal *tColVal = (SColVal *)taosArrayGet(pColArray, iCol);
 
       tsdbRowGetColVal(pRow, pTSchema, iCol, pColVal);
-      if (tColVal->isNone && !pColVal->isNone) {
+      if (COL_VAL_IS_NONE(tColVal) && !COL_VAL_IS_NONE(pColVal)) {
         taosArraySet(pColArray, iCol, pColVal);
-      } else if (tColVal->isNone && pColVal->isNone && !setNoneCol) {
+      } else if (COL_VAL_IS_NONE(tColVal) && COL_VAL_IS_NONE(pColVal) && !setNoneCol) {
         noneCol = iCol;
         setNoneCol = true;
       }
@@ -1161,7 +1161,7 @@ static int32_t mergeLast(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray) {
           goto _err;
         }
 
-        if ((pColVal->isNone || pColVal->isNull) && !setNoneCol) {
+        if (!COL_VAL_IS_VALUE(pColVal) && !setNoneCol) {
           noneCol = iCol;
           setNoneCol = true;
         }
@@ -1181,9 +1181,9 @@ static int32_t mergeLast(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray) {
       SColVal *tColVal = (SColVal *)taosArrayGet(pColArray, iCol);
 
       tsdbRowGetColVal(pRow, pTSchema, iCol, pColVal);
-      if ((tColVal->isNone || tColVal->isNull) && (!pColVal->isNone && !pColVal->isNull)) {
+      if (!COL_VAL_IS_VALUE(tColVal) && COL_VAL_IS_VALUE(pColVal)) {
         taosArraySet(pColArray, iCol, &(SLastCol){.ts = rowTs, .colVal = *pColVal});
-      } else if ((tColVal->isNone || tColVal->isNull) && (pColVal->isNone || pColVal->isNull) && !setNoneCol) {
+      } else if (!COL_VAL_IS_VALUE(tColVal) && !COL_VAL_IS_VALUE(pColVal) && !setNoneCol) {
         noneCol = iCol;
         setNoneCol = true;
       }
diff --git a/source/dnode/vnode/src/tsdb/tsdbCacheRead.c b/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
index ea9a7ec7d9b3df80edbb1e5f93db5b2420f908e5..5f981649f355f0384a0e089feb8da27d60630cc8 100644
--- a/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
@@ -45,7 +45,7 @@ static void saveOneRow(STSRow* pRow, SSDataBlock* pBlock, SCacheRowsReader* pRea
       tTSRowGetVal(pRow, pReader->pSchema, slotId, &colVal);
 
       if (IS_VAR_DATA_TYPE(colVal.type)) {
-        if (colVal.isNull || colVal.isNone) {
+        if (!COL_VAL_IS_VALUE(&colVal)) {
           colDataAppendNULL(pColInfoData, numOfRows);
         } else {
           varDataSetLen(pReader->transferBuf[slotId], colVal.value.nData);
@@ -53,7 +53,7 @@ static void saveOneRow(STSRow* pRow, SSDataBlock* pBlock, SCacheRowsReader* pRea
           colDataAppend(pColInfoData, numOfRows, pReader->transferBuf[slotId], false);
         }
       } else {
-        colDataAppend(pColInfoData, numOfRows, (const char*)&colVal.value, colVal.isNull || colVal.isNone);
+        colDataAppend(pColInfoData, numOfRows, (const char*)&colVal.value, !COL_VAL_IS_VALUE(&colVal));
       }
     }
   }
@@ -84,7 +84,7 @@ int32_t tsdbCacherowsReaderOpen(void* pVnode, int32_t type, SArray* pTableIdList
 
   p->transferBuf = taosMemoryCalloc(p->pSchema->numOfCols, POINTER_BYTES);
   if (p->transferBuf == NULL) {
-    return  TSDB_CODE_OUT_OF_MEMORY;
+    return TSDB_CODE_OUT_OF_MEMORY;
   }
 
   for (int32_t i = 0; i < p->pSchema->numOfCols; ++i) {
@@ -117,7 +117,8 @@ int32_t tsdbCacherowsReaderClose(void* pReader) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t doExtractCacheRow(SCacheRowsReader* pr, SLRUCache* lruCache, uint64_t uid, STSRow** pRow, LRUHandle** h) {
+static int32_t doExtractCacheRow(SCacheRowsReader* pr, SLRUCache* lruCache, uint64_t uid, STSRow** pRow,
+                                 LRUHandle** h) {
   int32_t code = TSDB_CODE_SUCCESS;
   if ((pr->type & CACHESCAN_RETRIEVE_LAST_ROW) == CACHESCAN_RETRIEVE_LAST_ROW) {
     code = tsdbCacheGetLastrowH(lruCache, uid, pr->pVnode->pTsdb, h);
@@ -166,7 +167,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
       STableKeyInfo* pKeyInfo = taosArrayGet(pr->pTableList, i);
 
       code = doExtractCacheRow(pr, lruCache, pKeyInfo->uid, &pRow, &h);
-      if (code != TSDB_CODE_SUCCESS)  {
+      if (code != TSDB_CODE_SUCCESS) {
         return code;
       }
 
@@ -194,7 +195,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
     for (int32_t i = pr->tableIndex; i < numOfTables; ++i) {
       STableKeyInfo* pKeyInfo = taosArrayGet(pr->pTableList, i);
       code = doExtractCacheRow(pr, lruCache, pKeyInfo->uid, &pRow, &h);
-      if (code != TSDB_CODE_SUCCESS)  {
+      if (code != TSDB_CODE_SUCCESS) {
         return code;
       }
 
diff --git a/source/dnode/vnode/src/tsdb/tsdbRead.c b/source/dnode/vnode/src/tsdb/tsdbRead.c
index 681b25f67684f9846da940f10c4a24e696985acb..a2f21d4f6eeb2d30f75c73a3733a81daad60ad47 100644
--- a/source/dnode/vnode/src/tsdb/tsdbRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRead.c
@@ -662,7 +662,7 @@ static void setBlockAllDumped(SFileBlockDumpInfo* pDumpInfo, int64_t maxKey, int
 static void doCopyColVal(SColumnInfoData* pColInfoData, int32_t rowIndex, int32_t colIndex, SColVal* pColVal,
                          SBlockLoadSuppInfo* pSup) {
   if (IS_VAR_DATA_TYPE(pColVal->type)) {
-    if (pColVal->isNull || pColVal->isNone) {
+    if (!COL_VAL_IS_VALUE(pColVal)) {
       colDataAppendNULL(pColInfoData, rowIndex);
     } else {
       varDataSetLen(pSup->buildBuf[colIndex], pColVal->value.nData);
@@ -671,7 +671,7 @@ static void doCopyColVal(SColumnInfoData* pColInfoData, int32_t rowIndex, int32_
       colDataAppend(pColInfoData, rowIndex, pSup->buildBuf[colIndex], false);
     }
   } else {
-    colDataAppend(pColInfoData, rowIndex, (const char*)&pColVal->value, pColVal->isNull || pColVal->isNone);
+    colDataAppend(pColInfoData, rowIndex, (const char*)&pColVal->value, !COL_VAL_IS_VALUE(pColVal));
   }
 }
 
@@ -760,51 +760,43 @@ static int doBinarySearchKey(TSKEY* keyList, int num, int pos, TSKEY key, int or
   s = pos;
 
   // check
-  assert(pos >=0 && pos < num);
+  assert(pos >= 0 && pos < num);
   assert(num > 0);
 
   if (order == TSDB_ORDER_ASC) {
     // find the first position which is smaller than the key
-    e  = num - 1;
-    if (key < keyList[pos])
-      return -1;
+    e = num - 1;
+    if (key < keyList[pos]) return -1;
     while (1) {
       // check can return
-      if (key >= keyList[e])
-        return e;
-      if (key <= keyList[s])
-        return s;
-      if (e - s <= 1)
-        return s;
+      if (key >= keyList[e]) return e;
+      if (key <= keyList[s]) return s;
+      if (e - s <= 1) return s;
 
       // change start or end position
-      int mid = s + (e - s + 1)/2;
+      int mid = s + (e - s + 1) / 2;
       if (keyList[mid] > key)
         e = mid;
-      else if(keyList[mid] < key)
+      else if (keyList[mid] < key)
         s = mid;
       else
         return mid;
     }
-  } else { // DESC
+  } else {  // DESC
     // find the first position which is bigger than the key
-    e  = 0;
-    if (key > keyList[pos])
-      return -1;
+    e = 0;
+    if (key > keyList[pos]) return -1;
     while (1) {
       // check can return
-      if (key <= keyList[e])
-        return e;
-      if (key >= keyList[s])
-        return s;
-      if (s - e <= 1)
-        return s;
+      if (key <= keyList[e]) return e;
+      if (key >= keyList[s]) return s;
+      if (s - e <= 1) return s;
 
       // change start or end position
-      int mid = s - (s - e + 1)/2;
+      int mid = s - (s - e + 1) / 2;
       if (keyList[mid] < key)
         e = mid;
-      else if(keyList[mid] > key)
+      else if (keyList[mid] > key)
         s = mid;
       else
         return mid;
@@ -815,7 +807,7 @@ static int doBinarySearchKey(TSKEY* keyList, int num, int pos, TSKEY key, int or
 int32_t getEndPosInDataBlock(STsdbReader* pReader, SBlockData* pBlockData, SDataBlk* pBlock, int32_t pos) {
   // NOTE: reverse the order to find the end position in data block
   int32_t endPos = -1;
-  bool asc = ASCENDING_TRAVERSE(pReader->order);
+  bool    asc = ASCENDING_TRAVERSE(pReader->order);
 
   if (asc && pReader->window.ekey >= pBlock->maxKey.ts) {
     endPos = pBlock->nRow - 1;
@@ -851,8 +843,8 @@ static int32_t copyBlockDataToSDataBlock(STsdbReader* pReader, STableBlockScanIn
   } else if (!asc && pReader->window.ekey >= pBlock->maxKey.ts) {
     pDumpInfo->rowIndex = pBlock->nRow - 1;
   } else {
-    int32_t pos = asc? pBlock->nRow-1:0;
-    int32_t order = (pReader->order == TSDB_ORDER_ASC)? TSDB_ORDER_DESC:TSDB_ORDER_ASC;
+    int32_t pos = asc ? pBlock->nRow - 1 : 0;
+    int32_t order = (pReader->order == TSDB_ORDER_ASC) ? TSDB_ORDER_DESC : TSDB_ORDER_ASC;
     pDumpInfo->rowIndex = doBinarySearchKey(pBlockData->aTSKEY, pBlock->nRow, pos, pReader->window.skey, order);
   }
 
@@ -865,13 +857,13 @@ static int32_t copyBlockDataToSDataBlock(STsdbReader* pReader, STableBlockScanIn
 
   endIndex += step;
   int32_t remain = asc ? (endIndex - pDumpInfo->rowIndex) : (pDumpInfo->rowIndex - endIndex);
-  if (remain > pReader->capacity) { // output buffer check
+  if (remain > pReader->capacity) {  // output buffer check
     remain = pReader->capacity;
   }
 
   int32_t rowIndex = 0;
 
-  int32_t i = 0;
+  int32_t          i = 0;
   SColumnInfoData* pColData = taosArrayGet(pResBlock->pDataBlock, i);
   if (pColData->info.colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
     if (asc) {
@@ -895,7 +887,7 @@ static int32_t copyBlockDataToSDataBlock(STsdbReader* pReader, STableBlockScanIn
     if (pData->cid < pColData->info.colId) {
       colIndex += 1;
     } else if (pData->cid == pColData->info.colId) {
-      if (pData->flag == HAS_NONE || pData->flag == HAS_NULL || pData->flag == (HAS_NULL|HAS_NONE)) {
+      if (pData->flag == HAS_NONE || pData->flag == HAS_NULL || pData->flag == (HAS_NULL | HAS_NONE)) {
         colDataAppendNNULL(pColData, 0, remain);
       } else {
         if (IS_NUMERIC_TYPE(pColData->info.type) && asc) {
@@ -940,7 +932,7 @@ static int32_t copyBlockDataToSDataBlock(STsdbReader* pReader, STableBlockScanIn
     int64_t ts = pBlockData->aTSKEY[pDumpInfo->rowIndex];
     setBlockAllDumped(pDumpInfo, ts, pReader->order);
   } else {
-    int64_t k = asc? pBlock->maxKey.ts:pBlock->minKey.ts;
+    int64_t k = asc ? pBlock->maxKey.ts : pBlock->minKey.ts;
     setBlockAllDumped(pDumpInfo, k, pReader->order);
   }
 
@@ -950,8 +942,8 @@ static int32_t copyBlockDataToSDataBlock(STsdbReader* pReader, STableBlockScanIn
   int32_t unDumpedRows = asc ? pBlock->nRow - pDumpInfo->rowIndex : pDumpInfo->rowIndex + 1;
   tsdbDebug("%p copy file block to sdatablock, global index:%d, table index:%d, brange:%" PRId64 "-%" PRId64
             ", rows:%d, remain:%d, minVer:%" PRId64 ", maxVer:%" PRId64 ", elapsed time:%.2f ms, %s",
-            pReader, pBlockIter->index, pBlockInfo->tbBlockIdx, pBlock->minKey.ts, pBlock->maxKey.ts, remain, unDumpedRows,
-            pBlock->minVer, pBlock->maxVer, elapsedTime, pReader->idStr);
+            pReader, pBlockIter->index, pBlockInfo->tbBlockIdx, pBlock->minKey.ts, pBlock->maxKey.ts, remain,
+            unDumpedRows, pBlock->minVer, pBlock->maxVer, elapsedTime, pReader->idStr);
 
   return TSDB_CODE_SUCCESS;
 }
@@ -1287,14 +1279,14 @@ static bool doCheckforDatablockOverlap(STableBlockScanInfo* pBlockScanInfo, cons
       if (p->version >= pBlock->minVer) {
         if (i < num - 1) {
           TSDBKEY* pnext = taosArrayGet(pBlockScanInfo->delSkyline, i + 1);
-//          if (i + 1 == num - 1) {  // pnext is the last point
-            if (pnext->ts >= pBlock->minKey.ts) {
-              return true;
-//            }
-//          } else {
-//            if (pnext->ts >= pBlock->minKey.ts) {
-//              return true;
-//            }
+          //          if (i + 1 == num - 1) {  // pnext is the last point
+          if (pnext->ts >= pBlock->minKey.ts) {
+            return true;
+            //            }
+            //          } else {
+            //            if (pnext->ts >= pBlock->minKey.ts) {
+            //              return true;
+            //            }
           }
         } else {  // it must be the last point
           ASSERT(p->version == 0);
@@ -1755,7 +1747,7 @@ static int32_t doMergeMultiLevelRows(STsdbReader* pReader, STableBlockScanInfo*
     tsLast = getCurrentKeyInLastBlock(pLastBlockReader);
   }
 
-  int64_t key = hasDataInFileBlock(pBlockData, pDumpInfo)? pBlockData->aTSKEY[pDumpInfo->rowIndex]:INT64_MIN;
+  int64_t key = hasDataInFileBlock(pBlockData, pDumpInfo) ? pBlockData->aTSKEY[pDumpInfo->rowIndex] : INT64_MIN;
 
   TSDBKEY k = TSDBROW_KEY(pRow);
   TSDBKEY ik = TSDBROW_KEY(piRow);
@@ -2023,12 +2015,12 @@ static int64_t getCurrentKeyInLastBlock(SLastBlockReader* pLastBlockReader) {
 }
 
 static bool hasDataInLastBlock(SLastBlockReader* pLastBlockReader) { return pLastBlockReader->mergeTree.pIter != NULL; }
-bool hasDataInFileBlock(const SBlockData* pBlockData, const SFileBlockDumpInfo* pDumpInfo) {
-  if (pBlockData->nRow > 0) {
-    ASSERT(pBlockData->nRow == pDumpInfo->totalRows);
+bool        hasDataInFileBlock(const SBlockData* pBlockData, const SFileBlockDumpInfo* pDumpInfo) {
+         if (pBlockData->nRow > 0) {
+           ASSERT(pBlockData->nRow == pDumpInfo->totalRows);
   }
 
-  return pBlockData->nRow > 0 && (!pDumpInfo->allDumped);
+         return pBlockData->nRow > 0 && (!pDumpInfo->allDumped);
 }
 
 int32_t mergeRowsInFileBlocks(SBlockData* pBlockData, STableBlockScanInfo* pBlockScanInfo, int64_t key,
@@ -2101,11 +2093,12 @@ static int32_t buildComposedDataBlock(STsdbReader* pReader) {
   if (pBlockInfo != NULL) {
     pBlockScanInfo = taosHashGet(pReader->status.pTableMap, &pBlockInfo->uid, sizeof(pBlockInfo->uid));
     SDataBlk* pBlock = getCurrentBlock(&pReader->status.blockIter);
-    TSDBKEY keyInBuf = getCurrentKeyInBuf(pBlockScanInfo, pReader);
+    TSDBKEY   keyInBuf = getCurrentKeyInBuf(pBlockScanInfo, pReader);
 
     // it is a clean block, load it directly
     if (isCleanFileDataBlock(pReader, pBlockInfo, pBlock, pBlockScanInfo, keyInBuf, pLastBlockReader)) {
-      if (pReader->order == TSDB_ORDER_ASC || (pReader->order == TSDB_ORDER_DESC && (!hasDataInLastBlock(pLastBlockReader)))) {
+      if (pReader->order == TSDB_ORDER_ASC ||
+          (pReader->order == TSDB_ORDER_DESC && (!hasDataInLastBlock(pLastBlockReader)))) {
         copyBlockDataToSDataBlock(pReader, pBlockScanInfo);
         goto _end;
       }
@@ -2158,12 +2151,12 @@ static int32_t buildComposedDataBlock(STsdbReader* pReader) {
     }
   }
 
-  _end:
+_end:
   pResBlock->info.uid = pBlockScanInfo->uid;
   blockDataUpdateTsWindow(pResBlock, 0);
 
   setComposedBlockFlag(pReader, true);
-  double el = (taosGetTimestampUs() - st)/1000.0;
+  double el = (taosGetTimestampUs() - st) / 1000.0;
 
   pReader->cost.composedBlocks += 1;
   pReader->cost.buildComposedBlockTime += el;
@@ -3228,7 +3221,8 @@ int32_t doAppendRowFromFileBlock(SSDataBlock* pResBlock, STsdbReader* pReader, S
       tColDataGetValue(pData, rowIndex, &cv);
       doCopyColVal(pCol, outputRowIndex, i, &cv, pSupInfo);
       j += 1;
-    } else if (pData->cid > pCol->info.colId) {  // the specified column does not exist in file block, fill with null data
+    } else if (pData->cid >
+               pCol->info.colId) {  // the specified column does not exist in file block, fill with null data
       colDataAppendNULL(pCol, outputRowIndex);
     }
 
@@ -3302,7 +3296,6 @@ void* tsdbGetIvtIdx(SMeta* pMeta) {
 
 uint64_t getReaderMaxVersion(STsdbReader* pReader) { return pReader->verRange.maxVer; }
 
-
 static int32_t doOpenReaderImpl(STsdbReader* pReader) {
   SDataBlockIter* pBlockIter = &pReader->status.blockIter;
 
@@ -3375,19 +3368,20 @@ int32_t tsdbReaderOpen(SVnode* pVnode, SQueryTableDataCond* pCond, SArray* pTabl
 
   // NOTE: the endVersion in pCond is the data version not schema version, so pCond->endVersion is not correct here.
   if (pCond->suid != 0) {
-    pReader->pSchema = metaGetTbTSchema(pReader->pTsdb->pVnode->pMeta, pReader->suid,  -1);
+    pReader->pSchema = metaGetTbTSchema(pReader->pTsdb->pVnode->pMeta, pReader->suid, -1);
     if (pReader->pSchema == NULL) {
-      tsdbError("failed to get table schema, suid:%"PRIu64", ver:%"PRId64" , %s", pReader->suid, -1, pReader->idStr);
+      tsdbError("failed to get table schema, suid:%" PRIu64 ", ver:%" PRId64 " , %s", pReader->suid, -1,
+                pReader->idStr);
     }
   } else if (taosArrayGetSize(pTableList) > 0) {
     STableKeyInfo* pKey = taosArrayGet(pTableList, 0);
     pReader->pSchema = metaGetTbTSchema(pReader->pTsdb->pVnode->pMeta, pKey->uid, -1);
     if (pReader->pSchema == NULL) {
-      tsdbError("failed to get table schema, uid:%"PRIu64", ver:%"PRId64" , %s", pKey->uid, -1, pReader->idStr);
+      tsdbError("failed to get table schema, uid:%" PRIu64 ", ver:%" PRId64 " , %s", pKey->uid, -1, pReader->idStr);
     }
   }
 
-  STsdbReader* p = pReader->innerReader[0] != NULL? pReader->innerReader[0]:pReader;
+  STsdbReader* p = pReader->innerReader[0] != NULL ? pReader->innerReader[0] : pReader;
 
   int32_t numOfTables = taosArrayGetSize(pTableList);
   pReader->status.pTableMap = createDataBlockScanInfo(p, pTableList->pData, numOfTables);
@@ -3507,7 +3501,8 @@ void tsdbReaderClose(STsdbReader* pReader) {
 
   tsdbDebug(
       "%p :io-cost summary: head-file:%" PRIu64 ", head-file time:%.2f ms, SMA:%" PRId64
-      " SMA-time:%.2f ms, fileBlocks:%" PRId64 ", fileBlocks-load-time:%.2f ms, "
+      " SMA-time:%.2f ms, fileBlocks:%" PRId64
+      ", fileBlocks-load-time:%.2f ms, "
       "build in-memory-block-time:%.2f ms, lastBlocks:%" PRId64 ", lastBlocks-time:%.2f ms, composed-blocks:%" PRId64
       ", composed-blocks-time:%.2fms, STableBlockScanInfo size:%.2f Kb %s",
       pReader, pCost->headFileLoad, pCost->headFileLoadTime, pCost->smaDataLoad, pCost->smaLoadTime, pCost->numOfBlocks,
@@ -3765,8 +3760,10 @@ int32_t tsdbReaderReset(STsdbReader* pReader, SQueryTableDataCond* pCond) {
     }
   }
 
-  tsdbDebug("%p reset reader, suid:%" PRIu64 ", numOfTables:%d, skey:%"PRId64", query range:%" PRId64 " - %" PRId64 " in query %s",
-            pReader, pReader->suid, numOfTables, pCond->twindows.skey, pReader->window.skey, pReader->window.ekey, pReader->idStr);
+  tsdbDebug("%p reset reader, suid:%" PRIu64 ", numOfTables:%d, skey:%" PRId64 ", query range:%" PRId64 " - %" PRId64
+            " in query %s",
+            pReader, pReader->suid, numOfTables, pCond->twindows.skey, pReader->window.skey, pReader->window.ekey,
+            pReader->idStr);
 
   return code;
 }
diff --git a/source/dnode/vnode/src/tsdb/tsdbUtil.c b/source/dnode/vnode/src/tsdb/tsdbUtil.c
index 64c150484b4f873bd15fb69c2b238bd840e1ea1f..8026441cbcf9d85e8de6f0ae5b707c56f775b09a 100644
--- a/source/dnode/vnode/src/tsdb/tsdbUtil.c
+++ b/source/dnode/vnode/src/tsdb/tsdbUtil.c
@@ -705,12 +705,12 @@ int32_t tRowMergerAdd(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema) {
     tsdbRowGetColVal(pRow, pTSchema, jCol++, pColVal);
 
     if (key.version > pMerger->version) {
-      if (!pColVal->isNone) {
+      if (!COL_VAL_IS_NONE(pColVal)) {
         taosArraySet(pMerger->pArray, iCol, pColVal);
       }
     } else if (key.version < pMerger->version) {
       SColVal *tColVal = (SColVal *)taosArrayGet(pMerger->pArray, iCol);
-      if (tColVal->isNone && !pColVal->isNone) {
+      if (COL_VAL_IS_NONE(tColVal) && !COL_VAL_IS_NONE(pColVal)) {
         taosArraySet(pMerger->pArray, iCol, pColVal);
       }
     } else {
@@ -776,12 +776,12 @@ int32_t tRowMerge(SRowMerger *pMerger, TSDBROW *pRow) {
     tsdbRowGetColVal(pRow, pMerger->pTSchema, iCol, pColVal);
 
     if (key.version > pMerger->version) {
-      if (!pColVal->isNone) {
+      if (!COL_VAL_IS_NONE(pColVal)) {
         taosArraySet(pMerger->pArray, iCol, pColVal);
       }
     } else if (key.version < pMerger->version) {
       SColVal *tColVal = (SColVal *)taosArrayGet(pMerger->pArray, iCol);
-      if (tColVal->isNone && !pColVal->isNone) {
+      if (COL_VAL_IS_NONE(tColVal) && !COL_VAL_IS_NONE(pColVal)) {
         taosArraySet(pMerger->pArray, iCol, pColVal);
       }
     } else {
@@ -1505,7 +1505,7 @@ void tsdbCalcColDataSMA(SColData *pColData, SColumnDataAgg *pColAgg) {
   for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
     tColDataGetValue(pColData, iVal, pColVal);
 
-    if (pColVal->isNone || pColVal->isNull) {
+    if (!COL_VAL_IS_VALUE(pColVal)) {
       pColAgg->numOfNull++;
     } else {
       switch (pColData->type) {
diff --git a/source/libs/parser/src/parInsertData.c b/source/libs/parser/src/parInsertData.c
index 3ea5e81872f1562f09e35226c69c5a5295d684ab..e8c877bed2d69346cd718625688b0db3de85ae69 100644
--- a/source/libs/parser/src/parInsertData.c
+++ b/source/libs/parser/src/parInsertData.c
@@ -505,7 +505,7 @@ static int32_t tdBlockRowMerge(STableMeta* pTableMeta, SBlockKeyTuple* pEndKeyTp
     SColVal colVal = {0};
     for (int32_t j = 0; j < nDupRows; ++j) {
       tTSRowGetVal((pEndKeyTp - j)->payloadAddr, pSchema, i, &colVal);
-      if (!colVal.isNone) {
+      if (!COL_VAL_IS_NONE(&colVal)) {
         break;
       }
     }