refact: tag api

include/common/tdataformat.h

@@ -129,9 +129,23 @@ struct STagVal {
     char   *pKey;
   };
   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,
                                      bool isJson) {
@@ -218,8 +232,7 @@ struct STag {
 #define schemaColAt(s, i) ((s)->columns + i)
 #define tdFreeSchema(s)   taosMemoryFreeClear((s))
 
-    STSchema       *
+STSchema *tdDupSchema(const STSchema *pSchema);
-    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

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;

source/common/src/tdataformat.c

@@ -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]);
+    p = p ? p + n : p;
-    if (p) memcpy(p + n, pTagVal->pData, pTagVal->nData);
+    switch (pTagVal->type) {
-    n += pTagVal->nData;
+      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;
+    switch (pTagVal->type) {
-    pTagVal->nData = TYPE_BYTES[pTagVal->type];
+      case TSDB_DATA_TYPE_BOOL:
-    n += pTagVal->nData;
+      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;
+      memcpy(pTagVal, &tv, sizeof(tv));
-      pTagVal->nData = tv.nData;
-      pTagVal->pData = tv.pData;
       return true;
     }
   }