Merge pull request #15946 from taosdata/feature/3.0_row_optimize

enh: row iter and fetch optimization

include/common/tdataformat.h

@@ -200,8 +200,6 @@ struct STag {
 #if 1  //================================================================================================================================================
 // Imported since 3.0 and use bitmap to demonstrate None/Null/Norm, while use Null/Norm below 3.0 without of bitmap.
 #define TD_SUPPORT_BITMAP
-#define TD_SUPPORT_READ2
-#define TD_SUPPORT_BACK2  // suppport back compatibility of 2.0
 
 #define TASSERT(x) ASSERT(x)
 

include/common/trow.h

@@ -319,21 +319,17 @@ typedef struct {
   col_id_t  kvIdx;   // [0, nKvCols)
 } STSRowIter;
 
-void    tdSTSRowIterReset(STSRowIter *pIter, STSRow *pRow);
-void    tdSTSRowIterInit(STSRowIter *pIter, STSchema *pSchema);
+void tdSTSRowIterInit(STSRowIter *pIter, STSchema *pSchema);
+void tdSTSRowIterReset(STSRowIter *pIter, STSRow *pRow);
+bool tdSTSRowIterFetch(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCellVal *pVal);
+bool tdSTSRowIterNext(STSRowIter *pIter, SCellVal *pVal);
+
 int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow);
 bool    tdSTSRowGetVal(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCellVal *pVal);
-bool    tdGetTpRowDataOfCol(STSRowIter *pIter, col_type_t colType, int32_t offset, SCellVal *pVal);
-bool    tdGetKvRowValOfColEx(STSRowIter *pIter, col_id_t colId, col_type_t colType, col_id_t *nIdx, SCellVal *pVal);
-bool    tdSTSRowIterNext(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCellVal *pVal);
-bool    tdSTpRowGetVal(STSRow *pRow, col_id_t colId, col_type_t colType, int32_t flen, uint32_t offset, col_id_t colIdx,
-                       SCellVal *pVal);
-bool    tdSKvRowGetVal(STSRow *pRow, col_id_t colId, col_id_t colIdx, SCellVal *pVal);
-void    tdSCellValPrint(SCellVal *pVal, int8_t colType);
 void    tdSRowPrint(STSRow *row, STSchema *pSchema, const char *tag);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /*_TD_COMMON_ROW_H_*/
+#endif /*_TD_COMMON_ROW_H_*/
\ No newline at end of file

source/common/src/trow.c

@@ -32,9 +32,13 @@ const uint8_t tdVTypeByte[2][3] = {{
 };
 
 // declaration
-static uint8_t              tdGetBitmapByte(uint8_t byte);
-static int32_t              tdCompareColId(const void *arg1, const void *arg2);
-static FORCE_INLINE int32_t compareKvRowColId(const void *key1, const void *key2);
+static uint8_t tdGetBitmapByte(uint8_t byte);
+static bool    tdSTSRowIterGetTpVal(STSRowIter *pIter, col_type_t colType, int32_t offset, SCellVal *pVal);
+static bool    tdSTSRowIterGetKvVal(STSRowIter *pIter, col_id_t colId, col_id_t *nIdx, SCellVal *pVal);
+static bool    tdSTpRowGetVal(STSRow *pRow, col_id_t colId, col_type_t colType, int32_t flen, uint32_t offset,
+                              col_id_t colIdx, SCellVal *pVal);
+static bool    tdSKvRowGetVal(STSRow *pRow, col_id_t colId, col_id_t colIdx, SCellVal *pVal);
+static void    tdSCellValPrint(SCellVal *pVal, int8_t colType);
 
 // implementation
 /**
@@ -330,14 +334,14 @@ void tdSRowPrint(STSRow *row, STSchema *pSchema, const char *tag) {
   tdSTSRowIterInit(&iter, pSchema);
   tdSTSRowIterReset(&iter, row);
   printf("%s >>>type:%d,sver:%d ", tag, (int32_t)TD_ROW_TYPE(row), (int32_t)TD_ROW_SVER(row));
-  for (int i = 0; i < pSchema->numOfCols; ++i) {
-    STColumn *stCol = pSchema->columns + i;
-    SCellVal  sVal = {255, NULL};
-    if (!tdSTSRowIterNext(&iter, stCol->colId, stCol->type, &sVal)) {
+  STColumn *cols = (STColumn *)&iter.pSchema->columns;
+  while (true) {
+    SCellVal sVal = {.valType = 255, NULL};
+    if (!tdSTSRowIterNext(&iter, &sVal)) {
       break;
     }
     ASSERT(sVal.valType == 0 || sVal.valType == 1 || sVal.valType == 2);
-    tdSCellValPrint(&sVal, stCol->type);
+    tdSCellValPrint(&sVal, cols[iter.colIdx - 1].type);
   }
   printf("\n");
 }
@@ -420,6 +424,16 @@ void tdSCellValPrint(SCellVal *pVal, int8_t colType) {
   }
 }
 
+static FORCE_INLINE int32_t compareKvRowColId(const void *key1, const void *key2) {
+  if (*(col_id_t *)key1 > ((SKvRowIdx *)key2)->colId) {
+    return 1;
+  } else if (*(col_id_t *)key1 < ((SKvRowIdx *)key2)->colId) {
+    return -1;
+  } else {
+    return 0;
+  }
+}
+
 bool tdSKvRowGetVal(STSRow *pRow, col_id_t colId, col_id_t colIdx, SCellVal *pVal) {
   if (colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
     tdRowSetVal(pVal, TD_VTYPE_NORM, TD_ROW_KEY_ADDR(pRow));
@@ -456,7 +470,7 @@ bool tdSTpRowGetVal(STSRow *pRow, col_id_t colId, col_type_t colType, int32_t fl
   return true;
 }
 
-bool tdSTSRowIterNext(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCellVal *pVal) {
+bool tdSTSRowIterFetch(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCellVal *pVal) {
   if (colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
     pVal->val = &pIter->pRow->ts;
     pVal->valType = TD_VTYPE_NORM;
@@ -477,10 +491,10 @@ bool tdSTSRowIterNext(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCe
         return false;
       }
     }
-    tdGetTpRowDataOfCol(pIter, pCol->type, pCol->offset - sizeof(TSKEY), pVal);
+    tdSTSRowIterGetTpVal(pIter, pCol->type, pCol->offset - sizeof(TSKEY), pVal);
     ++pIter->colIdx;
   } else if (TD_IS_KV_ROW(pIter->pRow)) {
-    return tdGetKvRowValOfColEx(pIter, colId, colType, &pIter->kvIdx, pVal);
+    return tdSTSRowIterGetKvVal(pIter, colId, &pIter->kvIdx, pVal);
   } else {
     pVal->valType = TD_VTYPE_NONE;
     terrno = TSDB_CODE_INVALID_PARA;
@@ -489,13 +503,69 @@ bool tdSTSRowIterNext(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCe
   return true;
 }
 
-bool tdGetKvRowValOfColEx(STSRowIter *pIter, col_id_t colId, col_type_t colType, col_id_t *nIdx, SCellVal *pVal) {
+bool tdSTSRowIterNext(STSRowIter *pIter, SCellVal *pVal) {
+  if (pIter->colIdx >= pIter->pSchema->numOfCols) {
+    return false;
+  }
+
+  STColumn *pCol = &pIter->pSchema->columns[pIter->colIdx];
+
+  if (pCol->colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
+    pVal->val = &pIter->pRow->ts;
+    pVal->valType = TD_VTYPE_NORM;
+    ++pIter->colIdx;
+    return true;
+  }
+
+  if (TD_IS_TP_ROW(pIter->pRow)) {
+    tdSTSRowIterGetTpVal(pIter, pCol->type, pCol->offset - sizeof(TSKEY), pVal);
+  } else if (TD_IS_KV_ROW(pIter->pRow)) {
+    tdSTSRowIterGetKvVal(pIter, pCol->colId, &pIter->kvIdx, pVal);
+    ASSERT(0);
+  } else {
+    ASSERT(0);
+  }
+  ++pIter->colIdx;
+
+  return true;
+}
+
+bool tdSTSRowIterGetTpVal(STSRowIter *pIter, col_type_t colType, int32_t offset, SCellVal *pVal) {
+  STSRow *pRow = pIter->pRow;
+  if (pRow->statis == 0) {
+    pVal->valType = TD_VTYPE_NORM;
+    if (IS_VAR_DATA_TYPE(colType)) {
+      pVal->val = POINTER_SHIFT(pRow, *(VarDataOffsetT *)POINTER_SHIFT(TD_ROW_DATA(pRow), offset));
+    } else {
+      pVal->val = POINTER_SHIFT(TD_ROW_DATA(pRow), offset);
+    }
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (tdGetBitmapValType(pIter->pBitmap, pIter->colIdx - 1, &pVal->valType, 0) != TSDB_CODE_SUCCESS) {
+    pVal->valType = TD_VTYPE_NONE;
+    return terrno;
+  }
+
+  if (pVal->valType == TD_VTYPE_NORM) {
+    if (IS_VAR_DATA_TYPE(colType)) {
+      pVal->val = POINTER_SHIFT(pRow, *(VarDataOffsetT *)POINTER_SHIFT(TD_ROW_DATA(pRow), offset));
+    } else {
+      pVal->val = POINTER_SHIFT(TD_ROW_DATA(pRow), offset);
+    }
+  }
+
+  return true;
+}
+
+bool tdSTSRowIterGetKvVal(STSRowIter *pIter, col_id_t colId, col_id_t *nIdx, SCellVal *pVal) {
   STSRow    *pRow = pIter->pRow;
   SKvRowIdx *pKvIdx = NULL;
   bool       colFound = false;
   col_id_t   kvNCols = tdRowGetNCols(pRow) - 1;
+  void      *pColIdx = TD_ROW_COL_IDX(pRow);
   while (*nIdx < kvNCols) {
-    pKvIdx = (SKvRowIdx *)POINTER_SHIFT(TD_ROW_COL_IDX(pRow), *nIdx * sizeof(SKvRowIdx));
+    pKvIdx = (SKvRowIdx *)POINTER_SHIFT(pColIdx, *nIdx * sizeof(SKvRowIdx));
     if (pKvIdx->colId == colId) {
       ++(*nIdx);
       pVal->val = POINTER_SHIFT(pRow, pKvIdx->offset);
@@ -518,48 +588,13 @@ bool tdGetKvRowValOfColEx(STSRowIter *pIter, col_id_t colId, col_type_t colType,
     }
   }
 
-#ifdef TD_SUPPORT_BITMAP
-  int16_t colIdx = -1;
-  if (pKvIdx) colIdx = POINTER_DISTANCE(pKvIdx, TD_ROW_COL_IDX(pRow)) / sizeof(SKvRowIdx);
-  if (tdGetBitmapValType(pIter->pBitmap, colIdx, &pVal->valType, 0) != TSDB_CODE_SUCCESS) {
+  if (tdGetBitmapValType(pIter->pBitmap, pIter->kvIdx - 1, &pVal->valType, 0) != TSDB_CODE_SUCCESS) {
     pVal->valType = TD_VTYPE_NONE;
   }
-#else
-  pVal->valType = isNull(pVal->val, colType) ? TD_VTYPE_NULL : TD_VTYPE_NORM;
-#endif
 
   return true;
 }
 
-bool tdGetTpRowDataOfCol(STSRowIter *pIter, col_type_t colType, int32_t offset, SCellVal *pVal) {
-  STSRow *pRow = pIter->pRow;
-  if (IS_VAR_DATA_TYPE(colType)) {
-    pVal->val = POINTER_SHIFT(pRow, *(VarDataOffsetT *)POINTER_SHIFT(TD_ROW_DATA(pRow), offset));
-  } else {
-    pVal->val = POINTER_SHIFT(TD_ROW_DATA(pRow), offset);
-  }
-
-#ifdef TD_SUPPORT_BITMAP
-  if (tdGetBitmapValType(pIter->pBitmap, pIter->colIdx - 1, &pVal->valType, 0) != TSDB_CODE_SUCCESS) {
-    pVal->valType = TD_VTYPE_NONE;
-  }
-#else
-  pVal->valType = isNull(pVal->val, colType) ? TD_VTYPE_NULL : TD_VTYPE_NORM;
-#endif
-
-  return true;
-}
-
-static FORCE_INLINE int32_t compareKvRowColId(const void *key1, const void *key2) {
-  if (*(col_id_t *)key1 > ((SKvRowIdx *)key2)->colId) {
-    return 1;
-  } else if (*(col_id_t *)key1 < ((SKvRowIdx *)key2)->colId) {
-    return -1;
-  } else {
-    return 0;
-  }
-}
-
 int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow) {
   STColumn *pTColumn;
   SColVal  *pColVal;
@@ -625,7 +660,7 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow) {
   if (maxVarDataLen > 0) {
     varBuf = taosMemoryMalloc(maxVarDataLen);
     if (!varBuf) {
-      if(isAlloc) {
+      if (isAlloc) {
         taosMemoryFreeClear(*ppRow);
       }
       terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -673,6 +708,19 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow) {
   return 0;
 }
 
+static FORCE_INLINE int32_t tdCompareColId(const void *arg1, const void *arg2) {
+  int32_t   colId = *(int32_t *)arg1;
+  STColumn *pCol = (STColumn *)arg2;
+
+  if (colId < pCol->colId) {
+    return -1;
+  } else if (colId == pCol->colId) {
+    return 0;
+  } else {
+    return 1;
+  }
+}
+
 bool tdSTSRowGetVal(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCellVal *pVal) {
   if (colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
     pVal->val = &pIter->pRow->ts;
@@ -712,19 +760,6 @@ bool tdSTSRowGetVal(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCell
   return true;
 }
 
-static int32_t tdCompareColId(const void *arg1, const void *arg2) {
-  int32_t   colId = *(int32_t *)arg1;
-  STColumn *pCol = (STColumn *)arg2;
-
-  if (colId < pCol->colId) {
-    return -1;
-  } else if (colId == pCol->colId) {
-    return 0;
-  } else {
-    return 1;
-  }
-}
-
 int32_t tdGetBitmapValTypeII(const void *pBitmap, int16_t colIdx, TDRowValT *pValType) {
   if (!pBitmap || colIdx < 0) {
     TASSERT(0);
@@ -938,7 +973,7 @@ int32_t tdAppendColValToRow(SRowBuilder *pBuilder, col_id_t colId, int8_t colTyp
       break;
     case TD_VTYPE_NONE:
       if (!pBuilder->hasNone) pBuilder->hasNone = true;
-      break;
+      return TSDB_CODE_SUCCESS;
     default:
       ASSERT(0);
       break;
@@ -970,13 +1005,11 @@ int32_t tdAppendColValToKvRow(SRowBuilder *pBuilder, TDRowValT valType, const vo
 
   STSRow *row = pBuilder->pBuf;
   // No need to store None/Null values.
+  SKvRowIdx *pColIdx = (SKvRowIdx *)POINTER_SHIFT(TD_ROW_COL_IDX(row), offset);
+  pColIdx->colId = colId;
+  pColIdx->offset = TD_ROW_LEN(row);  // the offset include the TD_ROW_HEAD_LEN
   if (valType == TD_VTYPE_NORM) {
-    // ts key stored in STSRow.ts
-    SKvRowIdx *pColIdx = (SKvRowIdx *)POINTER_SHIFT(TD_ROW_COL_IDX(row), offset);
-    char      *ptr = (char *)POINTER_SHIFT(row, TD_ROW_LEN(row));
-    pColIdx->colId = colId;
-    pColIdx->offset = TD_ROW_LEN(row);  // the offset include the TD_ROW_HEAD_LEN
-
+    char *ptr = (char *)POINTER_SHIFT(row, TD_ROW_LEN(row));
     if (IS_VAR_DATA_TYPE(colType)) {
       if (isCopyVarData) {
         memcpy(ptr, val, varDataTLen(val));
@@ -987,26 +1020,6 @@ int32_t tdAppendColValToKvRow(SRowBuilder *pBuilder, TDRowValT valType, const vo
       TD_ROW_LEN(row) += TYPE_BYTES[colType];
     }
   }
-#ifdef TD_SUPPORT_BACK2
-  // NULL/None value
-  else {
-    SKvRowIdx *pColIdx = (SKvRowIdx *)POINTER_SHIFT(TD_ROW_COL_IDX(row), offset);
-    char      *ptr = (char *)POINTER_SHIFT(row, TD_ROW_LEN(row));
-    pColIdx->colId = colId;
-    pColIdx->offset = TD_ROW_LEN(row);  // the offset include the TD_ROW_HEAD_LEN
-    const void *nullVal = getNullValue(colType);
-
-    if (IS_VAR_DATA_TYPE(colType)) {
-      if (isCopyVarData) {
-        memcpy(ptr, nullVal, varDataTLen(nullVal));
-      }
-      TD_ROW_LEN(row) += varDataTLen(nullVal);
-    } else {
-      memcpy(ptr, nullVal, TYPE_BYTES[colType]);
-      TD_ROW_LEN(row) += TYPE_BYTES[colType];
-    }
-  }
-#endif
 
   return 0;
 }
@@ -1044,24 +1057,6 @@ int32_t tdAppendColValToTpRow(SRowBuilder *pBuilder, TDRowValT valType, const vo
       memcpy(POINTER_SHIFT(TD_ROW_DATA(row), offset), val, TYPE_BYTES[colType]);
     }
   }
-#ifdef TD_SUPPORT_BACK2
-  // NULL/None value
-  else {
-    // TODO: Null value for new data types imported since 3.0 need to be defined.
-    const void *nullVal = getNullValue(colType);
-    if (IS_VAR_DATA_TYPE(colType)) {
-      // ts key stored in STSRow.ts
-      *(VarDataOffsetT *)POINTER_SHIFT(TD_ROW_DATA(row), offset) = TD_ROW_LEN(row);
-
-      if (isCopyVarData) {
-        memcpy(POINTER_SHIFT(row, TD_ROW_LEN(row)), nullVal, varDataTLen(nullVal));
-      }
-      TD_ROW_LEN(row) += varDataTLen(nullVal);
-    } else {
-      memcpy(POINTER_SHIFT(TD_ROW_DATA(row), offset), nullVal, TYPE_BYTES[colType]);
-    }
-  }
-#endif
 
   return 0;
 }
@@ -1329,7 +1324,7 @@ void tdSTSRowIterReset(STSRowIter *pIter, STSRow *pRow) {
   pIter->pRow = pRow;
   pIter->pBitmap = tdGetBitmapAddr(pRow, pRow->type, pIter->pSchema->flen, tdRowGetNCols(pRow));
   pIter->offset = 0;
-  pIter->colIdx = PRIMARYKEY_TIMESTAMP_COL_ID;
+  pIter->colIdx = 0;  // PRIMARYKEY_TIMESTAMP_COL_ID;
   pIter->kvIdx = 0;
 }
 
@@ -1367,4 +1362,4 @@ void tTSRowGetVal(STSRow *pRow, STSchema *pTSchema, int16_t iCol, SColVal *pColV
 
     *pColVal = COL_VAL_VALUE(pTColumn->colId, pTColumn->type, value);
   }
-}
+}
\ No newline at end of file

source/dnode/vnode/src/tq/tqRead.c

@@ -325,7 +325,7 @@ int32_t tqRetrieveDataBlock(SSDataBlock* pBlock, STqReader* pReader) {
     for (int32_t i = 0; i < colActual; i++) {
       SColumnInfoData* pColData = taosArrayGet(pBlock->pDataBlock, i);
       SCellVal         sVal = {0};
-      if (!tdSTSRowIterNext(&iter, pColData->info.colId, pColData->info.type, &sVal)) {
+      if (!tdSTSRowIterFetch(&iter, pColData->info.colId, pColData->info.type, &sVal)) {
         break;
       }
       if (colDataAppend(pColData, curRow, sVal.val, sVal.valType != TD_VTYPE_NORM) < 0) {

source/dnode/vnode/src/tsdb/tsdbRead.c

@@ -182,7 +182,7 @@ static int32_t setColumnIdSlotList(STsdbReader* pReader, SSDataBlock* pBlock) {
 
     if (IS_VAR_DATA_TYPE(pCol->info.type)) {
       pSupInfo->buildBuf[i] = taosMemoryMalloc(pCol->info.bytes);
-      tsdbInfo("-------------------%d\n", pCol->info.bytes);
+      // tsdbInfo("-------------------%d\n", pCol->info.bytes);
     }
   }
 

source/libs/executor/src/tsimplehash.c

@@ -13,38 +13,37 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "os.h"
 #include "tsimplehash.h"
+#include "os.h"
 #include "taoserror.h"
 
 #define SHASH_DEFAULT_LOAD_FACTOR 0.75
-#define HASH_MAX_CAPACITY         (1024*1024*16)
+#define HASH_MAX_CAPACITY         (1024 * 1024 * 16)
 #define SHASH_NEED_RESIZE(_h)     ((_h)->size >= (_h)->capacity * SHASH_DEFAULT_LOAD_FACTOR)
 
-#define GET_SHASH_NODE_KEY(_n, _dl)  ((char*)(_n) + sizeof(SHNode) + (_dl))
-#define GET_SHASH_NODE_DATA(_n)      ((char*)(_n) + sizeof(SHNode))
+#define GET_SHASH_NODE_KEY(_n, _dl) ((char *)(_n) + sizeof(SHNode) + (_dl))
+#define GET_SHASH_NODE_DATA(_n)     ((char *)(_n) + sizeof(SHNode))
 
-#define HASH_INDEX(v, c)         ((v) & ((c)-1))
-#define HASH_NEED_RESIZE(_h)     ((_h)->size >= (_h)->capacity * SHASH_DEFAULT_LOAD_FACTOR)
+#define HASH_INDEX(v, c) ((v) & ((c)-1))
 
-#define FREE_HASH_NODE(_n) \
-  do {                     \
-    taosMemoryFreeClear(_n);             \
+#define FREE_HASH_NODE(_n)   \
+  do {                       \
+    taosMemoryFreeClear(_n); \
   } while (0);
 
 typedef struct SHNode {
-  struct SHNode   *next;
-  char             data[];
+  struct SHNode *next;
+  char           data[];
 } SHNode;
 
 struct SSHashObj {
-  SHNode         **hashList;
-  size_t           capacity;     // number of slots
-  int64_t          size;         // number of elements in hash table
-  _hash_fn_t       hashFp;       // hash function
-  _equal_fn_t      equalFp;      // equal function
-  int32_t          keyLen;
-  int32_t          dataLen;
+  SHNode    **hashList;
+  size_t      capacity;  // number of slots
+  int64_t     size;      // number of elements in hash table
+  _hash_fn_t  hashFp;    // hash function
+  _equal_fn_t equalFp;   // equal function
+  int32_t     keyLen;
+  int32_t     dataLen;
 };
 
 static FORCE_INLINE int32_t taosHashCapacity(int32_t length) {
@@ -62,7 +61,7 @@ SSHashObj *tSimpleHashInit(size_t capacity, _hash_fn_t fn, size_t keyLen, size_t
     capacity = 4;
   }
 
-  SSHashObj* pHashObj = (SSHashObj*) taosMemoryCalloc(1, sizeof(SSHashObj));
+  SSHashObj *pHashObj = (SSHashObj *)taosMemoryCalloc(1, sizeof(SSHashObj));
   if (pHashObj == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
@@ -72,7 +71,7 @@ SSHashObj *tSimpleHashInit(size_t capacity, _hash_fn_t fn, size_t keyLen, size_t
   pHashObj->capacity = taosHashCapacity((int32_t)capacity);
 
   pHashObj->equalFp = memcmp;
-  pHashObj->hashFp  = fn;
+  pHashObj->hashFp = fn;
   ASSERT((pHashObj->capacity & (pHashObj->capacity - 1)) == 0);
 
   pHashObj->keyLen = keyLen;
@@ -91,7 +90,7 @@ int32_t tSimpleHashGetSize(const SSHashObj *pHashObj) {
   if (pHashObj == NULL) {
     return 0;
   }
-  return (int32_t)atomic_load_64((int64_t*)&pHashObj->size);
+  return (int32_t)atomic_load_64((int64_t *)&pHashObj->size);
 }
 
 static SHNode *doCreateHashNode(const void *key, size_t keyLen, const void *pData, size_t dsize, uint32_t hashVal) {
@@ -108,41 +107,42 @@ static SHNode *doCreateHashNode(const void *key, size_t keyLen, const void *pDat
 }
 
 static void taosHashTableResize(SSHashObj *pHashObj) {
-  if (!HASH_NEED_RESIZE(pHashObj)) {
+  if (!SHASH_NEED_RESIZE(pHashObj)) {
     return;
   }
 
   int32_t newCapacity = (int32_t)(pHashObj->capacity << 1u);
   if (newCapacity > HASH_MAX_CAPACITY) {
-//    uDebug("current capacity:%zu, maximum capacity:%d, no resize applied due to limitation is reached",
-//           pHashObj->capacity, HASH_MAX_CAPACITY);
+    //    uDebug("current capacity:%zu, maximum capacity:%d, no resize applied due to limitation is reached",
+    //           pHashObj->capacity, HASH_MAX_CAPACITY);
     return;
   }
 
   int64_t st = taosGetTimestampUs();
-  void *pNewEntryList = taosMemoryRealloc(pHashObj->hashList, sizeof(void *) * newCapacity);
+  void   *pNewEntryList = taosMemoryRealloc(pHashObj->hashList, sizeof(void *) * newCapacity);
   if (pNewEntryList == NULL) {
-//    qWarn("hash resize failed due to out of memory, capacity remain:%zu", pHashObj->capacity);
+    //    qWarn("hash resize failed due to out of memory, capacity remain:%zu", pHashObj->capacity);
     return;
   }
 
   size_t inc = newCapacity - pHashObj->capacity;
-  memset((char*)pNewEntryList + pHashObj->capacity * sizeof(void*), 0, inc);
+  memset((char *)pNewEntryList + pHashObj->capacity * sizeof(void *), 0, inc);
 
   pHashObj->hashList = pNewEntryList;
   pHashObj->capacity = newCapacity;
 
   for (int32_t idx = 0; idx < pHashObj->capacity; ++idx) {
-    SHNode* pNode = pHashObj->hashList[idx];
-    SHNode *pNext;
-    SHNode *pPrev = NULL;
-
+    SHNode *pNode = pHashObj->hashList[idx];
     if (pNode == NULL) {
       continue;
     }
 
+    SHNode *pNext;
+    SHNode *pPrev = NULL;
+
+
     while (pNode != NULL) {
-      void* key = GET_SHASH_NODE_KEY(pNode, pHashObj->dataLen);
+      void    *key = GET_SHASH_NODE_KEY(pNode, pHashObj->dataLen);
       uint32_t hashVal = (*pHashObj->hashFp)(key, (uint32_t)pHashObj->dataLen);
 
       int32_t newIdx = HASH_INDEX(hashVal, pHashObj->capacity);
@@ -166,8 +166,9 @@ static void taosHashTableResize(SSHashObj *pHashObj) {
 
   int64_t et = taosGetTimestampUs();
 
-//  uDebug("hash table resize completed, new capacity:%d, load factor:%f, elapsed time:%fms", (int32_t)pHashObj->capacity,
-//         ((double)pHashObj->size) / pHashObj->capacity, (et - st) / 1000.0);
+  //  uDebug("hash table resize completed, new capacity:%d, load factor:%f, elapsed time:%fms",
+  //  (int32_t)pHashObj->capacity,
+  //         ((double)pHashObj->size) / pHashObj->capacity, (et - st) / 1000.0);
 }
 
 int32_t tSimpleHashPut(SSHashObj *pHashObj, const void *key, const void *data) {
@@ -210,7 +211,7 @@ int32_t tSimpleHashPut(SSHashObj *pHashObj, const void *key, const void *data) {
     pNewNode->next = pHashObj->hashList[slot];
     pHashObj->hashList[slot] = pNewNode;
     atomic_add_fetch_64(&pHashObj->size, 1);
-  } else {  //update data
+  } else {  // update data
     memcpy(GET_SHASH_NODE_DATA(pNode), data, pHashObj->dataLen);
   }
 
@@ -230,9 +231,7 @@ static FORCE_INLINE SHNode *doSearchInEntryList(SSHashObj *pHashObj, const void
   return pNode;
 }
 
-static FORCE_INLINE bool taosHashTableEmpty(const SSHashObj *pHashObj) {
-  return tSimpleHashGetSize(pHashObj) == 0;
-}
+static FORCE_INLINE bool taosHashTableEmpty(const SSHashObj *pHashObj) { return tSimpleHashGetSize(pHashObj) == 0; }
 
 void *tSimpleHashGet(SSHashObj *pHashObj, const void *key) {
   if (pHashObj == NULL || taosHashTableEmpty(pHashObj) || key == NULL) {
@@ -299,9 +298,9 @@ size_t tSimpleHashGetMemSize(const SSHashObj *pHashObj) {
   return (pHashObj->capacity * sizeof(void *)) + sizeof(SHNode) * tSimpleHashGetSize(pHashObj) + sizeof(SSHashObj);
 }
 
-void *tSimpleHashGetKey(const SSHashObj* pHashObj, void *data, size_t* keyLen) {
+void *tSimpleHashGetKey(const SSHashObj *pHashObj, void *data, size_t *keyLen) {
   int32_t offset = offsetof(SHNode, data);
-  SHNode *node = ((SHNode*)(char*)data - offset);
+  SHNode *node = ((SHNode *)(char *)data - offset);
   if (keyLen != NULL) {
     *keyLen = pHashObj->keyLen;
   }

source/libs/parser/src/parInsert.c

@@ -1192,7 +1192,10 @@ static int parseOneRow(SInsertParseContext* pCxt, STableDataBlocks* pDataBlocks,
       pBuilder->hasNone = true;
     }
 
+    tdSRowEnd(pBuilder);
+
     *gotRow = true;
+    
 #ifdef TD_DEBUG_PRINT_ROW
     STSchema* pSTSchema = tdGetSTSChemaFromSSChema(schema, spd->numOfCols, 1);
     tdSRowPrint(row, pSTSchema, __func__);
@@ -1201,7 +1204,6 @@ static int parseOneRow(SInsertParseContext* pCxt, STableDataBlocks* pDataBlocks,
   }
 
   // *len = pBuilder->extendedRowSize;
-  tdSRowEnd(pBuilder);
   return TSDB_CODE_SUCCESS;
 }