diff --git a/include/common/tdataformat.h b/include/common/tdataformat.h
index eea1661ca9..957b93d359 100644
--- a/include/common/tdataformat.h
+++ b/include/common/tdataformat.h
@@ -128,9 +128,23 @@ struct STagVal {
     int16_t cid;
     char   *pKey;
   };
-  int8_t   type;
-  uint32_t nData;
-  uint8_t *pData;
+  int8_t type;
+  union {
+    int8_t   i8;
+    uint8_t  u8;
+    int16_t  i16;
+    uint16_t u16;
+    int32_t  i32;
+    uint32_t u32;
+    int64_t  i64;
+    uint64_t u64;
+    float    f;
+    double   d;
+    struct {
+      uint32_t nData;
+      uint8_t *pData;
+    };
+  };
 };
 
 static FORCE_INLINE void tTagValPush(SArray *pTagArray, void *key, int8_t type, uint8_t *pData, uint32_t nData,
@@ -218,8 +232,7 @@ struct STag {
 #define schemaColAt(s, i) ((s)->columns + i)
 #define tdFreeSchema(s)   taosMemoryFreeClear((s))
 
-    STSchema       *
-    tdDupSchema(const STSchema *pSchema);
+STSchema *tdDupSchema(const STSchema *pSchema);
 int32_t   tdEncodeSchema(void **buf, STSchema *pSchema);
 void     *tdDecodeSchema(void *buf, STSchema **pRSchema);
 
@@ -403,8 +416,6 @@ SDataCols *tdFreeDataCols(SDataCols *pCols);
 int32_t    tdMergeDataCols(SDataCols *target, SDataCols *source, int32_t rowsToMerge, int32_t *pOffset, bool update,
                            TDRowVerT maxVer);
 
-
-
 #endif
 
 #ifdef __cplusplus
diff --git a/include/util/tencode.h b/include/util/tencode.h
index 914091ad51..c1c5c1150d 100644
--- a/include/util/tencode.h
+++ b/include/util/tencode.h
@@ -530,6 +530,24 @@ static FORCE_INLINE int32_t tPutI64(uint8_t* p, int64_t v) {
   return sizeof(int64_t);
 }
 
+static FORCE_INLINE int32_t tPutFloat(uint8_t* p, float f) {
+  union {
+    uint32_t ui;
+    float    f;
+  } v = {.f = f};
+
+  return tPutU32(p, v.ui);
+}
+
+static FORCE_INLINE int32_t tPutDouble(uint8_t* p, double d) {
+  union {
+    uint64_t ui;
+    double   d;
+  } v = {.d = d};
+
+  return tPutU64(p, v.ui);
+}
+
 static FORCE_INLINE int32_t tPutU16v(uint8_t* p, uint16_t v) { tPutV(p, v); }
 
 static FORCE_INLINE int32_t tPutI16v(uint8_t* p, int16_t v) { return tPutU16v(p, ZIGZAGE(int16_t, v)); }
@@ -619,6 +637,34 @@ static FORCE_INLINE int32_t tGetI64v(uint8_t* p, int64_t* v) {
   return n;
 }
 
+static FORCE_INLINE int32_t tGetFloat(uint8_t* p, float* f) {
+  int32_t n = 0;
+
+  union {
+    uint32_t ui;
+    float    f;
+  } v;
+
+  n = tGetU32(p, &v.ui);
+
+  *f = v.f;
+  return n;
+}
+
+static FORCE_INLINE int32_t tGetDouble(uint8_t* p, double* d) {
+  int32_t n = 0;
+
+  union {
+    uint64_t ui;
+    double   d;
+  } v;
+
+  n = tGetU64(p, &v.ui);
+
+  *d = v.d;
+  return n;
+}
+
 // =====================
 static FORCE_INLINE int32_t tPutBinary(uint8_t* p, uint8_t* pData, uint32_t nData) {
   int n = 0;
diff --git a/source/common/src/tdataformat.c b/source/common/src/tdataformat.c
index 8959a63860..34e78c21db 100644
--- a/source/common/src/tdataformat.c
+++ b/source/common/src/tdataformat.c
@@ -574,28 +574,28 @@ static void debugPrintTagVal(int8_t type, const void *val, int32_t vlen, const c
   }
 }
 
-  // if (isLarge) {
-  //   p = (uint8_t *)&((int16_t *)pTag->idx)[pTag->nTag];
-  // } else {
-  //   p = (uint8_t *)&pTag->idx[pTag->nTag];
-  // }
+// if (isLarge) {
+//   p = (uint8_t *)&((int16_t *)pTag->idx)[pTag->nTag];
+// } else {
+//   p = (uint8_t *)&pTag->idx[pTag->nTag];
+// }
 
-  // (*ppArray) = taosArrayInit(pTag->nTag + 1, sizeof(STagVal));
-  // if (*ppArray == NULL) {
-  //   code = TSDB_CODE_OUT_OF_MEMORY;
-  //   goto _err;
-  // }
+// (*ppArray) = taosArrayInit(pTag->nTag + 1, sizeof(STagVal));
+// if (*ppArray == NULL) {
+//   code = TSDB_CODE_OUT_OF_MEMORY;
+//   goto _err;
+// }
 
-  // for (int16_t iTag = 0; iTag < pTag->nTag; iTag++) {
-  //   if (isLarge) {
-  //     offset = ((int16_t *)pTag->idx)[iTag];
-  //   } else {
-  //     offset = pTag->idx[iTag];
-  //   }
+// for (int16_t iTag = 0; iTag < pTag->nTag; iTag++) {
+//   if (isLarge) {
+//     offset = ((int16_t *)pTag->idx)[iTag];
+//   } else {
+//     offset = pTag->idx[iTag];
+//   }
 
 void debugPrintSTag(STag *pTag, const char *tag, int32_t ln) {
-  int8_t isJson = pTag->flags & TD_TAG_JSON;
-  int8_t isLarge = pTag->flags & TD_TAG_LARGE;
+  int8_t   isJson = pTag->flags & TD_TAG_JSON;
+  int8_t   isLarge = pTag->flags & TD_TAG_LARGE;
   uint8_t *p = NULL;
   int16_t  offset = 0;
 
@@ -642,9 +642,45 @@ static int32_t tPutTagVal(uint8_t *p, STagVal *pTagVal, int8_t isJson) {
   if (IS_VAR_DATA_TYPE(pTagVal->type)) {
     n += tPutBinary(p ? p + n : p, pTagVal->pData, pTagVal->nData);
   } else {
-    ASSERT(pTagVal->nData == TYPE_BYTES[pTagVal->type]);
-    if (p) memcpy(p + n, pTagVal->pData, pTagVal->nData);
-    n += pTagVal->nData;
+    p = p ? p + n : p;
+    switch (pTagVal->type) {
+      case TSDB_DATA_TYPE_BOOL:
+        n += tPutI8(p, pTagVal->i8 ? 1 : 0);
+        break;
+      case TSDB_DATA_TYPE_TINYINT:
+        n += tPutI8(p, pTagVal->i8);
+        break;
+      case TSDB_DATA_TYPE_SMALLINT:
+        n += tPutI16(p, pTagVal->i16);
+        break;
+      case TSDB_DATA_TYPE_INT:
+        n += tPutI32(p, pTagVal->i32);
+        break;
+      case TSDB_DATA_TYPE_TIMESTAMP:
+      case TSDB_DATA_TYPE_BIGINT:
+        n += tPutI64(p, pTagVal->i64);
+        break;
+      case TSDB_DATA_TYPE_FLOAT:
+        n += tPutFloat(p, pTagVal->f);
+        break;
+      case TSDB_DATA_TYPE_DOUBLE:
+        n += tPutDouble(p, pTagVal->d);
+        break;
+      case TSDB_DATA_TYPE_UTINYINT:
+        n += tPutU8(p, pTagVal->u8);
+        break;
+      case TSDB_DATA_TYPE_USMALLINT:
+        n += tPutU16(p, pTagVal->u16);
+        break;
+      case TSDB_DATA_TYPE_UINT:
+        n += tPutU32(p, pTagVal->u32);
+        break;
+      case TSDB_DATA_TYPE_UBIGINT:
+        n += tPutU64(p, pTagVal->u64);
+        break;
+      default:
+        ASSERT(0);
+    }
   }
 
   return n;
@@ -666,9 +702,42 @@ static int32_t tGetTagVal(uint8_t *p, STagVal *pTagVal, int8_t isJson) {
   if (IS_VAR_DATA_TYPE(pTagVal->type)) {
     n += tGetBinary(p + n, &pTagVal->pData, &pTagVal->nData);
   } else {
-    pTagVal->pData = p + n;
-    pTagVal->nData = TYPE_BYTES[pTagVal->type];
-    n += pTagVal->nData;
+    switch (pTagVal->type) {
+      case TSDB_DATA_TYPE_BOOL:
+      case TSDB_DATA_TYPE_TINYINT:
+        n += tGetI8(p + n, &pTagVal->i8);
+        break;
+      case TSDB_DATA_TYPE_SMALLINT:
+        n += tGetI16(p, &pTagVal->i16);
+        break;
+      case TSDB_DATA_TYPE_INT:
+        n += tGetI32(p, &pTagVal->i32);
+        break;
+      case TSDB_DATA_TYPE_TIMESTAMP:
+      case TSDB_DATA_TYPE_BIGINT:
+        n += tGetI64(p, &pTagVal->i64);
+        break;
+      case TSDB_DATA_TYPE_FLOAT:
+        n += tGetFloat(p, &pTagVal->f);
+        break;
+      case TSDB_DATA_TYPE_DOUBLE:
+        n += tGetDouble(p, &pTagVal->d);
+        break;
+      case TSDB_DATA_TYPE_UTINYINT:
+        n += tGetU8(p, &pTagVal->u8);
+        break;
+      case TSDB_DATA_TYPE_USMALLINT:
+        n += tGetU16(p, &pTagVal->u16);
+        break;
+      case TSDB_DATA_TYPE_UINT:
+        n += tGetU32(p, &pTagVal->u32);
+        break;
+      case TSDB_DATA_TYPE_UBIGINT:
+        n += tGetU64(p, &pTagVal->u64);
+        break;
+      default:
+        ASSERT(0);
+    }
   }
 
   return n;
@@ -785,9 +854,7 @@ bool tTagGet(const STag *pTag, STagVal *pTagVal) {
     } else if (c > 0) {
       lidx = midx + 1;
     } else {
-      pTagVal->type = tv.type;
-      pTagVal->nData = tv.nData;
-      pTagVal->pData = tv.pData;
+      memcpy(pTagVal, &tv, sizeof(tv));
       return true;
     }
   }