refactor and rename

src/common/inc/tdataformat.h

@@ -27,19 +27,24 @@
 extern "C" {
 #endif
 
-#define STR_TO_VARSTR(x, str) do {VarDataLenT __len = strlen(str); \
-  *(VarDataLenT*)(x) = __len; \
-  strncpy(varDataVal(x), (str), __len);} while(0);
-
-#define STR_WITH_MAXSIZE_TO_VARSTR(x, str, _maxs) do {\
-  char* _e = stpncpy(varDataVal(x), (str), (_maxs));\
-  varDataSetLen(x, (_e - (x) - VARSTR_HEADER_SIZE));\
-} while(0)
-
-#define STR_WITH_SIZE_TO_VARSTR(x, str, _size) do {\
-  *(VarDataLenT*)(x) = (_size); \
-  strncpy(varDataVal(x), (str), (_size));\
-} while(0);
+#define STR_TO_VARSTR(x, str)             \
+  do {                                    \
+    VarDataLenT __len = strlen(str);      \
+    *(VarDataLenT *)(x) = __len;          \
+    strncpy(varDataVal(x), (str), __len); \
+  } while (0);
+
+#define STR_WITH_MAXSIZE_TO_VARSTR(x, str, _maxs)      \
+  do {                                                 \
+    char *_e = stpncpy(varDataVal(x), (str), (_maxs)); \
+    varDataSetLen(x, (_e - (x)-VARSTR_HEADER_SIZE));   \
+  } while (0)
+
+#define STR_WITH_SIZE_TO_VARSTR(x, str, _size) \
+  do {                                         \
+    *(VarDataLenT *)(x) = (_size);             \
+    strncpy(varDataVal(x), (str), (_size));    \
+  } while (0);
 
 // ----------------- TSDB COLUMN DEFINITION
 typedef struct {
@@ -73,9 +78,9 @@ typedef struct {
 #define schemaTLen(s) ((s)->tlen)
 #define schemaFLen(s) ((s)->flen)
 #define schemaColAt(s, i) ((s)->columns + i)
+#define tdFreeSchema(s) tfree((s))
 
 STSchema *tdNewSchema(int32_t nCols);
-#define   tdFreeSchema(s) tfree((s))
 int       tdSchemaAddCol(STSchema *pSchema, int8_t type, int16_t colId, int32_t bytes);
 STSchema *tdDupSchema(STSchema *pSchema);
 int       tdGetSchemaEncodeSize(STSchema *pSchema);
@@ -189,12 +194,11 @@ static FORCE_INLINE int32_t dataColGetNEleLen(SDataCol *pDataCol, int rows) {
   }
 }
 
-
 typedef struct {
-  int      maxRowSize;
-  int      maxCols;    // max number of columns
-  int      maxPoints;  // max number of points
-  int      bufSize;
+  int maxRowSize;
+  int maxCols;    // max number of columns
+  int maxPoints;  // max number of points
+  int bufSize;
 
   int      numOfRows;
   int      numOfCols;  // Total number of cols
@@ -214,11 +218,10 @@ void       tdInitDataCols(SDataCols *pCols, STSchema *pSchema);
 SDataCols *tdDupDataCols(SDataCols *pCols, bool keepData);
 void       tdFreeDataCols(SDataCols *pCols);
 void       tdAppendDataRowToDataCol(SDataRow row, SDataCols *pCols);
-void       tdPopDataColsPoints(SDataCols *pCols, int pointsToPop); //!!!!
+void       tdPopDataColsPoints(SDataCols *pCols, int pointsToPop);  //!!!!
 int        tdMergeDataCols(SDataCols *target, SDataCols *src, int rowsToMerge);
 void       tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, SDataCols *src2, int *iter2, int tRows);
 
-
 // ----------------- K-V data row structure
 /*
  * +----------+----------+---------------------------------+---------------------------------+
@@ -227,29 +230,29 @@ void       tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, SD
  * |    len   |   ncols  |           cols index            |             data part           |
  * +----------+----------+---------------------------------+---------------------------------+
  */
-typedef void *SKVDataRow;
+typedef void *SKVRow;
 
 typedef struct {
   int16_t colId;
   int16_t offset;
 } SColIdx;
 
-#define TD_KV_DATA_ROW_HEAD_SIZE 2*sizeof(int16_t)
+#define TD_KV_ROW_HEAD_SIZE 2 * sizeof(int16_t)
 
-#define kvDataRowLen(r) (*(int16_t *)(r))
-#define kvDataRowNCols(r) (*(int16_t *)POINTER_SHIFT(r, sizeof(int16_t)))
-#define kvDataRowColIdx(r) (SColIdx *)POINTER_SHIFT(r, TD_KV_DATA_ROW_HEAD_SIZE)
-#define kvDataRowValues(r) POINTER_SHIFT(r, TD_KV_DATA_ROW_HEAD_SIZE + sizeof(SColIdx) * kvDataRowNCols(r))
-#define kvDataRowCpy(dst, r) memcpy((dst), (r), kvDataRowLen(r))
-#define kvDataRowColVal(r, colIdx) POINTER_SHIFT(kvDataRowValues(r), (colIdx)->offset)
-#define kvDataRowSetLen(r, len) kvDataRowLen(r) = (len)
-#define kvDataRowSetNCols(r, n) kvDataRowNCols(r) = (n)
-#define kvDataRowColIdxAt(r, i) (kvDataRowColIdx(r) + (i))
+#define kvRowLen(r) (*(int16_t *)(r))
+#define kvRowNCols(r) (*(int16_t *)POINTER_SHIFT(r, sizeof(int16_t)))
+#define kvRowColIdx(r) (SColIdx *)POINTER_SHIFT(r, TD_KV_ROW_HEAD_SIZE)
+#define kvRowValues(r) POINTER_SHIFT(r, TD_KV_ROW_HEAD_SIZE + sizeof(SColIdx) * kvRowNCols(r))
+#define kvRowCpy(dst, r) memcpy((dst), (r), kvRowLen(r))
+#define kvRowColVal(r, colIdx) POINTER_SHIFT(kvRowValues(r), (colIdx)->offset)
+#define kvRowSetLen(r, len) kvRowLen(r) = (len)
+#define kvRowSetNCols(r, n) kvRowNCols(r) = (n)
+#define kvRowColIdxAt(r, i) (kvRowColIdx(r) + (i))
 
-SKVDataRow tdKVDataRowDup(SKVDataRow row);
-SKVDataRow tdSetKVRowDataOfCol(SKVDataRow row, int16_t colId, int8_t type, void *value);
-void *     tdEncodeKVDataRow(void *buf, SKVDataRow row);
-void *     tdDecodeKVDataRow(void *buf, SKVDataRow *row);
+SKVRow tdKVRowDup(SKVRow row);
+SKVRow tdSetKVRowDataOfCol(SKVRow row, int16_t colId, int8_t type, void *value);
+void * tdEncodeKVRow(void *buf, SKVRow row);
+void * tdDecodeKVRow(void *buf, SKVRow *row);
 
 static FORCE_INLINE int comparTagId(const void *key1, const void *key2) {
   if (*(int16_t *)key1 > ((SColIdx *)key2)->colId) {
@@ -261,10 +264,10 @@ static FORCE_INLINE int comparTagId(const void *key1, const void *key2) {
   }
 }
 
-static FORCE_INLINE void *tdGetKVRowDataOfCol(SKVDataRow row, int16_t colId) {
-  void *ret = taosbsearch(&colId, kvDataRowColIdx(row), kvDataRowNCols(row), sizeof(SColIdx), comparTagId, TD_EQ);
+static FORCE_INLINE void *tdGetKVRowDataOfCol(SKVRow row, int16_t colId) {
+  void *ret = taosbsearch(&colId, kvRowColIdx(row), kvRowNCols(row), sizeof(SColIdx), comparTagId, TD_EQ);
   if (ret == NULL) return NULL;
-  return kvDataRowColVal(row, (SColIdx *)ret);
+  return kvRowColVal(row, (SColIdx *)ret);
 }
 
 // ----------------- K-V data row builder
@@ -275,19 +278,19 @@ typedef struct {
   int16_t  alloc;
   int16_t  size;
   void *   buf;
-} SKVDataRowBuilder;
+} SKVRowBuilder;
 
-int        tdInitKVDataRowBuilder(SKVDataRowBuilder *pBuilder);
-void       tdDestroyKVDataRowBuilder(SKVDataRowBuilder *pBuilder);
-void       tdResetKVDataRowBuilder(SKVDataRowBuilder *pBuilder);
-SKVDataRow tdGetKVDataRowFromBuilder(SKVDataRowBuilder *pBuilder);
-int        tdAddColToKVDataRow(SKVDataRowBuilder *pBuilder, int16_t colId, int8_t type, void *value);
+int    tdInitKVRowBuilder(SKVRowBuilder *pBuilder);
+void   tdDestroyKVRowBuilder(SKVRowBuilder *pBuilder);
+void   tdResetKVRowBuilder(SKVRowBuilder *pBuilder);
+SKVRow tdGetKVRowFromBuilder(SKVRowBuilder *pBuilder);
+int    tdAddColToKVRow(SKVRowBuilder *pBuilder, int16_t colId, int8_t type, void *value);
 
 // ----------------- Tag row structure
 
 /* A tag row, the format is like below:
 +----------+----------------------------------------------------------------+
-| STagRow  | STagCol | STagCol | STagCol | STagCol | ...| STagCol | STagCol | 
+| STagRow  | STagCol | STagCol | STagCol | STagCol | ...| STagCol | STagCol |
 +----------+----------------------------------------------------------------+
 
 pData
@@ -297,7 +300,6 @@ pData
 
  */
 
-
 #define TD_TAG_ROW_HEAD_SIZE sizeof(int16_t)
 
 #define tagRowNum(r) (*(int16_t *)(r))

src/common/src/tdataformat.c

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 #include "tdataformat.h"
-#include "wchar.h"
 #include "talgo.h"
+#include "wchar.h"
 
 /**
  * Create a SSchema object with nCols columns
@@ -51,13 +51,13 @@ int tdSchemaAddCol(STSchema *pSchema, int8_t type, int16_t colId, int32_t bytes)
   if (schemaNCols(pSchema) == 0) {
     colSetOffset(pCol, 0);
   } else {
-    STColumn *pTCol = schemaColAt(pSchema, schemaNCols(pSchema)-1);
+    STColumn *pTCol = schemaColAt(pSchema, schemaNCols(pSchema) - 1);
     colSetOffset(pCol, pTCol->offset + TYPE_BYTES[pTCol->type]);
   }
   switch (type) {
     case TSDB_DATA_TYPE_BINARY:
     case TSDB_DATA_TYPE_NCHAR:
-      colSetBytes(pCol, bytes); // Set as maximum bytes
+      colSetBytes(pCol, bytes);  // Set as maximum bytes
       pSchema->tlen += (TYPE_BYTES[type] + sizeof(VarDataLenT) + bytes);
       break;
     default:
@@ -152,17 +152,18 @@ SDataRow tdNewDataRowFromSchema(STSchema *pSchema) {
   return row;
 }
 
-int tdSetTagCol(SDataRow row, void *value, int16_t len, int8_t type, int16_t colId){ //insert/update tag value and update all the information
+int tdSetTagCol(SDataRow row, void *value, int16_t len, int8_t type,
+                int16_t colId) {  // insert/update tag value and update all the information
   ASSERT(((STagRow *)row)->pData != NULL);
-  //STagCol * stCol = tdQueryTagColByID()
+  // STagCol * stCol = tdQueryTagColByID()
 
   return 0;
-};  
+};
 
-int tdDeleteTagCol(SDataRow row, int16_t colId){   // delete tag value and update all the information
-  //todo
+int tdDeleteTagCol(SDataRow row, int16_t colId) {  // delete tag value and update all the information
+  // todo
   return 0;
-};  
+};
 
 static int compTagId(const void *key1, const void *key2) {
   if (((STagCol *)key1)->colId > ((STagCol *)key2)->colId) {
@@ -177,43 +178,43 @@ static int compTagId(const void *key1, const void *key2) {
 /**
  * Find tag structure by colId, if find, return tag structure, else return NULL;
  */
-STagCol * tdQueryTagColByID(SDataRow row, int16_t colId, int flags) {  //if find tag, 0, else return -1; 
+STagCol *tdQueryTagColByID(SDataRow row, int16_t colId, int flags) {  // if find tag, 0, else return -1;
   ASSERT(((STagRow *)row)->pData != NULL);
   STagCol *pBase = ((STagRow *)row)->tagCols;
-  int16_t nCols = ((STagRow *)row)->ncols;
-  STagCol key = {colId,0,0};
-  STagCol * stCol = taosbsearch(&key, pBase, nCols, sizeof(STagCol), compTagId, flags);
+  int16_t  nCols = ((STagRow *)row)->ncols;
+  STagCol  key = {colId, 0, 0};
+  STagCol *stCol = taosbsearch(&key, pBase, nCols, sizeof(STagCol), compTagId, flags);
   return stCol;
-};   
+};
 
 /**
-* Find tag value by colId, if find, return tag value, else return NULL;
-*/
-void * tdQueryTagByID(SDataRow row, int16_t colId, int16_t *type) {
+ * Find tag value by colId, if find, return tag value, else return NULL;
+ */
+void *tdQueryTagByID(SDataRow row, int16_t colId, int16_t *type) {
   ASSERT(((STagRow *)row)->pData != NULL);
   STagCol *pBase = ((STagRow *)row)->tagCols;
-  int16_t nCols = ((STagRow *)row)->ncols;
-  STagCol key = {colId,0,0};
-  STagCol * stCol = taosbsearch(&key, pBase, nCols, sizeof(STagCol), compTagId, TD_EQ);
+  int16_t  nCols = ((STagRow *)row)->ncols;
+  STagCol  key = {colId, 0, 0};
+  STagCol *stCol = taosbsearch(&key, pBase, nCols, sizeof(STagCol), compTagId, TD_EQ);
   if (NULL == stCol) {
     return NULL;
   }
-  
-  void * pData = ((STagRow *)row)->pData;
+
+  void *pData = ((STagRow *)row)->pData;
   *type = stCol->colType;
 
   return pData + stCol->offset;
-};   
+};
 
-int tdAppendTagColVal(SDataRow row, void *value, int8_t type, int32_t bytes, int16_t colId){
+int tdAppendTagColVal(SDataRow row, void *value, int8_t type, int32_t bytes, int16_t colId) {
   ASSERT(value != NULL);
-  //ASSERT(bytes-2 == varDataTLen(value));
+  // ASSERT(bytes-2 == varDataTLen(value));
   ASSERT(row != NULL);
   STagRow *pTagrow = row;
   pTagrow->tagCols[pTagrow->ncols].colId = colId;
   pTagrow->tagCols[pTagrow->ncols].colType = type;
   pTagrow->tagCols[pTagrow->ncols].offset = pTagrow->dataLen;
-  
+
   switch (type) {
     case TSDB_DATA_TYPE_BINARY:
     case TSDB_DATA_TYPE_NCHAR:
@@ -224,14 +225,14 @@ int tdAppendTagColVal(SDataRow row, void *value, int8_t type, int32_t bytes, int
       memcpy((char *)pTagrow->pData + pTagrow->dataLen, value, TYPE_BYTES[type]);
       pTagrow->dataLen += TYPE_BYTES[type];
       break;
-  } 
-  
-  pTagrow->ncols++;   
+  }
+
+  pTagrow->ncols++;
 
   return 0;
-};  
+};
 
-void * tdNewTagRowFromSchema(STSchema *pSchema, int16_t numofTags) {
+void *tdNewTagRowFromSchema(STSchema *pSchema, int16_t numofTags) {
   int32_t size = sizeof(STagRow) + numofTags * sizeof(STagCol);
 
   STagRow *row = malloc(size);
@@ -245,25 +246,25 @@ void * tdNewTagRowFromSchema(STSchema *pSchema, int16_t numofTags) {
   }
 
   row->len = size;
-  row->dataLen = 0; 
-  row->ncols = 0; 
-  return row;   
+  row->dataLen = 0;
+  row->ncols = 0;
+  return row;
 }
 /**
- * free tag row 
+ * free tag row
  */
- 
+
 void tdFreeTagRow(SDataRow row) {
   if (row) {
     free(((STagRow *)row)->pData);
     free(row);
-  }  
+  }
 }
 
 SDataRow tdTagRowDup(SDataRow row) {
   STagRow *trow = malloc(dataRowLen(row));
   if (trow == NULL) return NULL;
-  
+
   dataRowCpy(trow, row);
   trow->pData = malloc(trow->dataLen);
   if (NULL == trow->pData) {
@@ -277,23 +278,23 @@ SDataRow tdTagRowDup(SDataRow row) {
 SDataRow tdTagRowDecode(SDataRow row) {
   STagRow *trow = malloc(dataRowLen(row));
   if (trow == NULL) return NULL;
-  
+
   dataRowCpy(trow, row);
   trow->pData = malloc(trow->dataLen);
   if (NULL == trow->pData) {
     free(trow);
     return NULL;
   }
-  char * pData = (char *)row + dataRowLen(row);
+  char *pData = (char *)row + dataRowLen(row);
   memcpy(trow->pData, pData, trow->dataLen);
   return trow;
 }
 
 int tdTagRowCpy(SDataRow dst, SDataRow src) {
   if (src == NULL) return -1;
-  
+
   dataRowCpy(dst, src);
-  void * pData = dst + dataRowLen(src);
+  void *pData = dst + dataRowLen(src);
   memcpy(pData, ((STagRow *)src)->pData, ((STagRow *)src)->dataLen);
   return 0;
 }
@@ -330,7 +331,6 @@ void dataColInit(SDataCol *pDataCol, STColumn *pCol, void **pBuf, int maxPoints)
     pDataCol->pData = *pBuf;
     *pBuf = POINTER_SHIFT(*pBuf, pDataCol->spaceSize);
   }
-
 }
 
 void dataColAppendVal(SDataCol *pCol, void *value, int numOfRows, int maxPoints) {
@@ -414,7 +414,7 @@ void dataColSetNEleNull(SDataCol *pCol, int nEle, int maxPoints) {
 void dataColSetOffset(SDataCol *pCol, int nEle) {
   ASSERT(((pCol->type == TSDB_DATA_TYPE_BINARY) || (pCol->type == TSDB_DATA_TYPE_NCHAR)));
 
-  void * tptr = pCol->pData;
+  void *tptr = pCol->pData;
   // char *tptr = (char *)(pCol->pData);
 
   VarDataOffsetT offset = 0;
@@ -596,26 +596,25 @@ void tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, SDataCol
   }
 }
 
-SKVDataRow tdKVDataRowDup(SKVDataRow row) {
-  SKVDataRow trow = malloc(kvDataRowLen(row));
+SKVRow tdKVRowDup(SKVRow row) {
+  SKVRow trow = malloc(kvRowLen(row));
   if (trow == NULL) return NULL;
 
-  kvDataRowCpy(trow, row);
+  kvRowCpy(trow, row);
   return trow;
 }
 
-SKVDataRow tdSetKVRowDataOfCol(SKVDataRow row, int16_t colId, int8_t type, void *value) {
+SKVRow tdSetKVRowDataOfCol(SKVRow row, int16_t colId, int8_t type, void *value) {
   // TODO
   return NULL;
   // SColIdx *pColIdx = NULL;
-  // SKVDataRow rrow = row;
-  // SKVDataRow nrow = NULL;
+  // SKVRow rrow = row;
+  // SKVRow nrow = NULL;
   // void *ptr = taosbsearch(&colId, kvDataRowColIdx(row), kvDataRowNCols(row), sizeof(SColIdx), comparTagId, TD_GE);
 
   // if (ptr == NULL || ((SColIdx *)ptr)->colId < colId) { // need to add a column value to the row
-  //   int tlen = kvDataRowLen(row) + sizeof(SColIdx) + (IS_VAR_DATA_TYPE(type) ? varDataTLen(value) : TYPE_BYTES[type]);
-  //   nrow = malloc(tlen);
-  //   if (nrow == NULL) return NULL;
+  //   int tlen = kvDataRowLen(row) + sizeof(SColIdx) + (IS_VAR_DATA_TYPE(type) ? varDataTLen(value) :
+  //   TYPE_BYTES[type]); nrow = malloc(tlen); if (nrow == NULL) return NULL;
 
   //   kvDataRowSetNCols(nrow, kvDataRowNCols(row)+1);
   //   kvDataRowSetLen(nrow, tlen);
@@ -670,18 +669,18 @@ SKVDataRow tdSetKVRowDataOfCol(SKVDataRow row, int16_t colId, int8_t type, void
   // return rrow;
 }
 
-void *tdEncodeKVDataRow(void *buf, SKVDataRow row) {
+void *tdEncodeKVRow(void *buf, SKVRow row) {
   // May change the encode purpose
-  kvDataRowCpy(buf, row);
-  return POINTER_SHIFT(buf, kvDataRowLen(row));
+  kvRowCpy(buf, row);
+  return POINTER_SHIFT(buf, kvRowLen(row));
 }
 
-void *tdDecodeKVDataRow(void *buf, SKVDataRow *row) {
-  *row = tdKVDataRowDup(buf);
-  return POINTER_SHIFT(buf, kvDataRowLen(*row));
+void *tdDecodeKVRow(void *buf, SKVRow *row) {
+  *row = tdKVRowDup(buf);
+  return POINTER_SHIFT(buf, kvRowLen(*row));
 }
 
-int tdInitKVDataRowBuilder(SKVDataRowBuilder *pBuilder) {
+int tdInitKVRowBuilder(SKVRowBuilder *pBuilder) {
   pBuilder->tCols = 128;
   pBuilder->nCols = 0;
   pBuilder->pColIdx = (SColIdx *)malloc(sizeof(SColIdx) * pBuilder->tCols);
@@ -696,33 +695,33 @@ int tdInitKVDataRowBuilder(SKVDataRowBuilder *pBuilder) {
   return 0;
 }
 
-void tdDestroyKVDataRowBuilder(SKVDataRowBuilder *pBuilder) {
+void tdDestroyKVRowBuilder(SKVRowBuilder *pBuilder) {
   tfree(pBuilder->pColIdx);
   tfree(pBuilder->buf);
 }
 
-void tdResetKVDataRowBuilder(SKVDataRowBuilder *pBuilder) {
+void tdResetKVRowBuilder(SKVRowBuilder *pBuilder) {
   pBuilder->nCols = 0;
   pBuilder->size = 0;
 }
 
-SKVDataRow tdGetKVDataRowFromBuilder(SKVDataRowBuilder *pBuilder) {
+SKVRow tdGetKVRowFromBuilder(SKVRowBuilder *pBuilder) {
   int tlen = sizeof(SColIdx) * pBuilder->nCols + pBuilder->size;
   if (tlen == 0) return NULL;
 
-  SKVDataRow row = malloc(TD_KV_DATA_ROW_HEAD_SIZE + tlen);
+  SKVRow row = malloc(TD_KV_ROW_HEAD_SIZE + tlen);
   if (row == NULL) return NULL;
 
-  kvDataRowSetNCols(row, pBuilder->nCols);
-  kvDataRowSetLen(row, TD_KV_DATA_ROW_HEAD_SIZE + tlen);
+  kvRowSetNCols(row, pBuilder->nCols);
+  kvRowSetLen(row, TD_KV_ROW_HEAD_SIZE + tlen);
 
-  memcpy(kvDataRowColIdx(row), pBuilder->pColIdx, sizeof(SColIdx) * pBuilder->nCols);
-  memcpy(kvDataRowValues(row), pBuilder->buf, pBuilder->size);
+  memcpy(kvRowColIdx(row), pBuilder->pColIdx, sizeof(SColIdx) * pBuilder->nCols);
+  memcpy(kvRowValues(row), pBuilder->buf, pBuilder->size);
 
   return row;
 }
 
-int tdAddColToKVDataRow(SKVDataRowBuilder *pBuilder, int16_t colId, int8_t type, void *value) {
+int tdAddColToKVRow(SKVRowBuilder *pBuilder, int16_t colId, int8_t type, void *value) {
   ASSERT(pBuilder->nCols == 0 || colId > pBuilder->pColIdx[pBuilder->nCols - 1].colId);
 
   if (pBuilder->nCols >= pBuilder->tCols) {
@@ -733,7 +732,7 @@ int tdAddColToKVDataRow(SKVDataRowBuilder *pBuilder, int16_t colId, int8_t type,
 
   pBuilder->pColIdx[pBuilder->nCols].colId = colId;
   pBuilder->pColIdx[pBuilder->nCols].offset = pBuilder->size;
-  
+
   pBuilder->nCols++;
 
   int tlen = IS_VAR_DATA_TYPE(type) ? varDataTLen(value) : TYPE_BYTES[type];