From bc2c2c07a174630a6d5a70cf3c7c740800a21e15 Mon Sep 17 00:00:00 2001
From: xywang <xywang@taosdata.com>
Date: Tue, 1 Jun 2021 11:54:22 +0000
Subject: [PATCH 01/70] [TD-2574]<enhance>: refactored algorithms for top and
 bottom functions.

---
 src/query/src/qAggMain.c | 201 +++++++++++++++++++++------------------
 1 file changed, 107 insertions(+), 94 deletions(-)

diff --git a/src/query/src/qAggMain.c b/src/query/src/qAggMain.c
index 4935633b9c..a7106a14a9 100644
--- a/src/query/src/qAggMain.c
+++ b/src/query/src/qAggMain.c
@@ -2201,6 +2201,101 @@ static void valuePairAssign(tValuePair *dst, int16_t type, const char *val, int6
     memcpy((dst)->pTags, (src)->pTags, (size_t)(__l)); \
   } while (0)
 
+static void heapSwap(tValuePair *a, tValuePair *b, const int16_t tagLen) {
+  char        tag[32768];
+  tValuePair  temp;
+
+  memset(tag, 0, sizeof(tag));
+  temp.pTags = tag;
+
+  VALUEPAIRASSIGN(&temp, a, tagLen);
+  VALUEPAIRASSIGN(a, b, tagLen);
+  VALUEPAIRASSIGN(b, &temp, tagLen);
+}
+
+static void heapAdjust(tValuePair **pList, uint16_t type, int16_t tagLen, int32_t start, int32_t end, bool minRoot) {
+  int32_t     parent = start;
+  int32_t     child = 2 * parent + 1;
+
+  while (child <= end) {
+    if (IS_SIGNED_NUMERIC_TYPE(type)) {
+      if (minRoot) {
+        if (child + 1 <= end && pList[child]->v.i64 < pList[child + 1]->v.i64) {
+          child++;
+        }
+
+        if (pList[parent]->v.i64 > pList[child]->v.i64) {
+          break;
+        }
+      } else {
+        if (child + 1 <= end && pList[child]->v.i64 >= pList[child + 1]->v.i64) {
+          child++;
+        }
+
+        if (pList[parent]->v.i64 <= pList[child]->v.i64) {
+          break;
+        }
+      }
+    } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
+      if (minRoot) {
+        if (child + 1 <= end && pList[child]->v.u64 < pList[child + 1]->v.u64) {
+          child++;
+        }
+
+        if (pList[parent]->v.u64 > pList[child]->v.u64) {
+          break;
+        }
+      } else {
+        if (child + 1 <= end && pList[child]->v.u64 >= pList[child + 1]->v.u64) {
+          child++;
+        }
+
+        if (pList[parent]->v.u64 <= pList[child]->v.u64) {
+          break;
+        }
+      }
+    } else {
+      if (minRoot) {
+        if (child + 1 <= end && pList[child]->v.dKey < pList[child + 1]->v.dKey) {
+          child++;
+        }
+
+        if (pList[parent]->v.dKey > pList[child]->v.dKey) {
+          break;
+        }
+      } else {
+        if (child + 1 <= end && pList[child]->v.dKey >= pList[child + 1]->v.dKey) {
+          child++;
+        }
+
+        if (pList[parent]->v.dKey <= pList[child]->v.dKey) {
+          break;
+        }
+      }
+    }
+
+    heapSwap(pList[parent], pList[child], tagLen);
+
+    parent = child;
+    child = parent * 2 + 1;
+  }
+}
+
+void heapSort(tValuePair **pList, uint16_t type, int16_t tagLen, int32_t len, bool minRoot) {
+  int32_t  i;
+
+  for (i = len / 2 - 1; i >= 0; i--) {
+    heapAdjust(pList, type, i, tagLen, len - 1, minRoot);
+  }
+
+/*
+  for (i = len - 1; i > 0; i--) {
+    heapSwap(pList[0], pList[i], tagsLen);
+    heapAdjust(pList, type, tagsLen, i - 1, minRoot);
+  }
+*/
+}
+
 static void do_top_function_add(STopBotInfo *pInfo, int32_t maxLen, void *pData, int64_t ts, uint16_t type,
                                 SExtTagsInfo *pTagInfo, char *pTags, int16_t stage) {
   tVariant val = {0};
@@ -2210,59 +2305,17 @@ static void do_top_function_add(STopBotInfo *pInfo, int32_t maxLen, void *pData,
   assert(pList != NULL);
   
   if (pInfo->num < maxLen) {
-    if (pInfo->num == 0 ||
-        (IS_SIGNED_NUMERIC_TYPE(type) && val.i64 >= pList[pInfo->num - 1]->v.i64) ||
-        (IS_UNSIGNED_NUMERIC_TYPE(type) && val.u64 >= pList[pInfo->num - 1]->v.u64) ||
-        (IS_FLOAT_TYPE(type) && val.dKey >= pList[pInfo->num - 1]->v.dKey)) {
-      valuePairAssign(pList[pInfo->num], type, (const char*)&val.i64, ts, pTags, pTagInfo, stage);
-    } else {
-      int32_t i = pInfo->num - 1;
-      if (IS_SIGNED_NUMERIC_TYPE(type)) {
-        while (i >= 0 && pList[i]->v.i64 > val.i64) {
-          VALUEPAIRASSIGN(pList[i + 1], pList[i], pTagInfo->tagsLen);
-          i -= 1;
-        }
-      } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
-        while (i >= 0 && pList[i]->v.u64 > val.u64) {
-          VALUEPAIRASSIGN(pList[i + 1], pList[i], pTagInfo->tagsLen);
-          i -= 1;
-        }
-      } else {
-        while (i >= 0 && pList[i]->v.dKey > val.dKey) {
-          VALUEPAIRASSIGN(pList[i + 1], pList[i], pTagInfo->tagsLen);
-          i -= 1;
-        }
-      }
-      
-      valuePairAssign(pList[i + 1], type, (const char*) &val.i64, ts, pTags, pTagInfo, stage);
-    }
-    
+    valuePairAssign(pList[pInfo->num], type, (const char *)&val.i64, ts, pTags, pTagInfo, stage);
+
+    heapSort(pList, type, pTagInfo->tagsLen, pInfo->num + 1, 0);
+ 
     pInfo->num++;
   } else {
-    int32_t i = 0;
-
     if ((IS_SIGNED_NUMERIC_TYPE(type) && val.i64 > pList[0]->v.i64) ||
         (IS_UNSIGNED_NUMERIC_TYPE(type) && val.u64 > pList[0]->v.u64) ||
         (IS_FLOAT_TYPE(type) && val.dKey > pList[0]->v.dKey)) {
-      // find the appropriate the slot position
-      if (IS_SIGNED_NUMERIC_TYPE(type)) {
-        while (i + 1 < maxLen && pList[i + 1]->v.i64 < val.i64) {
-          VALUEPAIRASSIGN(pList[i], pList[i + 1], pTagInfo->tagsLen);
-          i += 1;
-        }
-      } if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
-        while (i + 1 < maxLen && pList[i + 1]->v.u64 < val.u64) {
-          VALUEPAIRASSIGN(pList[i], pList[i + 1], pTagInfo->tagsLen);
-          i += 1;
-        }
-      } else {
-        while (i + 1 < maxLen && pList[i + 1]->v.dKey < val.dKey) {
-          VALUEPAIRASSIGN(pList[i], pList[i + 1], pTagInfo->tagsLen);
-          i += 1;
-        }
-      }
-
-      valuePairAssign(pList[i], type, (const char *)&val.i64, ts, pTags, pTagInfo, stage);
+      valuePairAssign(pList[0], type, (const char *)&val.i64, ts, pTags, pTagInfo, stage);
+      heapAdjust(pList, type, pTagInfo->tagsLen, 0, maxLen - 1, 0);
     }
   }
 }
@@ -2276,57 +2329,17 @@ static void do_bottom_function_add(STopBotInfo *pInfo, int32_t maxLen, void *pDa
   assert(pList != NULL);
 
   if (pInfo->num < maxLen) {
-    if (pInfo->num == 0) {
-      valuePairAssign(pList[pInfo->num], type, (const char*) &val.i64, ts, pTags, pTagInfo, stage);
-    } else {
-      int32_t i = pInfo->num - 1;
-      
-      if (IS_SIGNED_NUMERIC_TYPE(type)) {
-        while (i >= 0 && pList[i]->v.i64 < val.i64) {
-          VALUEPAIRASSIGN(pList[i + 1], pList[i], pTagInfo->tagsLen);
-          i -= 1;
-        }
-      } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
-          while (i >= 0 && pList[i]->v.u64 < val.u64) {
-            VALUEPAIRASSIGN(pList[i + 1], pList[i], pTagInfo->tagsLen);
-            i -= 1;
-          }
-      } else {
-        while (i >= 0 && pList[i]->v.dKey < val.dKey) {
-          VALUEPAIRASSIGN(pList[i + 1], pList[i], pTagInfo->tagsLen);
-          i -= 1;
-        }
-      }
-      
-      valuePairAssign(pList[i + 1], type, (const char*)&val.i64, ts, pTags, pTagInfo, stage);
-    }
-    
+    valuePairAssign(pList[pInfo->num], type, (const char *)&val.i64, ts, pTags, pTagInfo, stage);
+
+    heapSort(pList, type, pTagInfo->tagsLen, pInfo->num + 1, 1);
+
     pInfo->num++;
   } else {
-    int32_t i = 0;
-    
     if ((IS_SIGNED_NUMERIC_TYPE(type) && val.i64 < pList[0]->v.i64) ||
         (IS_UNSIGNED_NUMERIC_TYPE(type) && val.u64 < pList[0]->v.u64) ||
         (IS_FLOAT_TYPE(type) && val.dKey < pList[0]->v.dKey)) {
-      // find the appropriate the slot position
-      if (IS_SIGNED_NUMERIC_TYPE(type)) {
-        while (i + 1 < maxLen && pList[i + 1]->v.i64 > val.i64) {
-          VALUEPAIRASSIGN(pList[i], pList[i + 1], pTagInfo->tagsLen);
-          i += 1;
-        }
-      } if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
-        while (i + 1 < maxLen && pList[i + 1]->v.u64 > val.u64) {
-          VALUEPAIRASSIGN(pList[i], pList[i + 1], pTagInfo->tagsLen);
-          i += 1;
-        }
-      } else {
-        while (i + 1 < maxLen && pList[i + 1]->v.dKey > val.dKey) {
-          VALUEPAIRASSIGN(pList[i], pList[i + 1], pTagInfo->tagsLen);
-          i += 1;
-        }
-      }
-      
-      valuePairAssign(pList[i], type, (const char*)&val.i64, ts, pTags, pTagInfo, stage);
+      valuePairAssign(pList[0], type, (const char *)&val.i64, ts, pTags, pTagInfo, stage);
+      heapAdjust(pList, type, pTagInfo->tagsLen, 0, maxLen - 1, 1);
     }
   }
 }

From 0ef76e0c1dba1203297e1b70c11922c5ebc27f9a Mon Sep 17 00:00:00 2001
From: xywang <xywang@taosdata.com>
Date: Wed, 2 Jun 2021 05:50:11 +0000
Subject: [PATCH 02/70] [TD-2574]<fix>: fixed a bug in heapSort.

---
 src/query/src/qAggMain.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/query/src/qAggMain.c b/src/query/src/qAggMain.c
index a7106a14a9..b0329c845d 100644
--- a/src/query/src/qAggMain.c
+++ b/src/query/src/qAggMain.c
@@ -2285,13 +2285,13 @@ void heapSort(tValuePair **pList, uint16_t type, int16_t tagLen, int32_t len, bo
   int32_t  i;
 
   for (i = len / 2 - 1; i >= 0; i--) {
-    heapAdjust(pList, type, i, tagLen, len - 1, minRoot);
+    heapAdjust(pList, type, tagLen, i, len - 1, minRoot);
   }
 
 /*
   for (i = len - 1; i > 0; i--) {
     heapSwap(pList[0], pList[i], tagsLen);
-    heapAdjust(pList, type, tagsLen, i - 1, minRoot);
+    heapAdjust(pList, type, 0, tagsLen, i - 1, minRoot);
   }
 */
 }

From e7753404758bf8c9a3896d4936ae4b0aab54a21e Mon Sep 17 00:00:00 2001
From: xywang <xywang@taosdata.com>
Date: Sat, 19 Jun 2021 16:25:04 +0800
Subject: [PATCH 03/70] [TD-2574]<enhance>: added general heapsort algorithm

---
 src/query/src/qAggMain.c | 124 ++++++++++-----------------------------
 src/util/inc/talgo.h     |  33 +++++++++++
 src/util/src/talgo.c     |  86 +++++++++++++++++++++++++++
 3 files changed, 149 insertions(+), 94 deletions(-)

diff --git a/src/query/src/qAggMain.c b/src/query/src/qAggMain.c
index b0329c845d..2c7242b26a 100644
--- a/src/query/src/qAggMain.c
+++ b/src/query/src/qAggMain.c
@@ -2201,99 +2201,35 @@ static void valuePairAssign(tValuePair *dst, int16_t type, const char *val, int6
     memcpy((dst)->pTags, (src)->pTags, (size_t)(__l)); \
   } while (0)
 
-static void heapSwap(tValuePair *a, tValuePair *b, const int16_t tagLen) {
-  char        tag[32768];
-  tValuePair  temp;
+static int32_t topBotComparFn(const void *p1, const void *p2, const void *param)
+{
+  uint16_t     type = *(uint16_t *) param;
+  tValuePair  *val1 = *(tValuePair **) p1;
+  tValuePair  *val2 = *(tValuePair **) p2;
+
+  if (IS_SIGNED_NUMERIC_TYPE(type)) {
+    return val1->v.i64 - val2->v.i64;
+  } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
+    return val1->v.u64 - val2->v.u64;
+  }
+
+  return val1->v.dKey - val2->v.dKey;
+}
+
+static void topBotSwapFn(void *dst, void *src, const void *param)
+{
+  char         tag[32768];
+  tValuePair   temp;
+  uint16_t     tagLen = *(uint16_t *) param;
+  tValuePair  *vdst = *(tValuePair **) dst;
+  tValuePair  *vsrc = *(tValuePair **) src;
 
   memset(tag, 0, sizeof(tag));
   temp.pTags = tag;
 
-  VALUEPAIRASSIGN(&temp, a, tagLen);
-  VALUEPAIRASSIGN(a, b, tagLen);
-  VALUEPAIRASSIGN(b, &temp, tagLen);
-}
-
-static void heapAdjust(tValuePair **pList, uint16_t type, int16_t tagLen, int32_t start, int32_t end, bool minRoot) {
-  int32_t     parent = start;
-  int32_t     child = 2 * parent + 1;
-
-  while (child <= end) {
-    if (IS_SIGNED_NUMERIC_TYPE(type)) {
-      if (minRoot) {
-        if (child + 1 <= end && pList[child]->v.i64 < pList[child + 1]->v.i64) {
-          child++;
-        }
-
-        if (pList[parent]->v.i64 > pList[child]->v.i64) {
-          break;
-        }
-      } else {
-        if (child + 1 <= end && pList[child]->v.i64 >= pList[child + 1]->v.i64) {
-          child++;
-        }
-
-        if (pList[parent]->v.i64 <= pList[child]->v.i64) {
-          break;
-        }
-      }
-    } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
-      if (minRoot) {
-        if (child + 1 <= end && pList[child]->v.u64 < pList[child + 1]->v.u64) {
-          child++;
-        }
-
-        if (pList[parent]->v.u64 > pList[child]->v.u64) {
-          break;
-        }
-      } else {
-        if (child + 1 <= end && pList[child]->v.u64 >= pList[child + 1]->v.u64) {
-          child++;
-        }
-
-        if (pList[parent]->v.u64 <= pList[child]->v.u64) {
-          break;
-        }
-      }
-    } else {
-      if (minRoot) {
-        if (child + 1 <= end && pList[child]->v.dKey < pList[child + 1]->v.dKey) {
-          child++;
-        }
-
-        if (pList[parent]->v.dKey > pList[child]->v.dKey) {
-          break;
-        }
-      } else {
-        if (child + 1 <= end && pList[child]->v.dKey >= pList[child + 1]->v.dKey) {
-          child++;
-        }
-
-        if (pList[parent]->v.dKey <= pList[child]->v.dKey) {
-          break;
-        }
-      }
-    }
-
-    heapSwap(pList[parent], pList[child], tagLen);
-
-    parent = child;
-    child = parent * 2 + 1;
-  }
-}
-
-void heapSort(tValuePair **pList, uint16_t type, int16_t tagLen, int32_t len, bool minRoot) {
-  int32_t  i;
-
-  for (i = len / 2 - 1; i >= 0; i--) {
-    heapAdjust(pList, type, tagLen, i, len - 1, minRoot);
-  }
-
-/*
-  for (i = len - 1; i > 0; i--) {
-    heapSwap(pList[0], pList[i], tagsLen);
-    heapAdjust(pList, type, 0, tagsLen, i - 1, minRoot);
-  }
-*/
+  VALUEPAIRASSIGN(&temp, vdst, tagLen);
+  VALUEPAIRASSIGN(vdst, vsrc, tagLen);
+  VALUEPAIRASSIGN(vsrc, &temp, tagLen);
 }
 
 static void do_top_function_add(STopBotInfo *pInfo, int32_t maxLen, void *pData, int64_t ts, uint16_t type,
@@ -2303,11 +2239,11 @@ static void do_top_function_add(STopBotInfo *pInfo, int32_t maxLen, void *pData,
   
   tValuePair **pList = pInfo->res;
   assert(pList != NULL);
-  
+
   if (pInfo->num < maxLen) {
     valuePairAssign(pList[pInfo->num], type, (const char *)&val.i64, ts, pTags, pTagInfo, stage);
 
-    heapSort(pList, type, pTagInfo->tagsLen, pInfo->num + 1, 0);
+    taosheapsort((void *) pList, sizeof(tValuePair **), pInfo->num + 1, (const void *) &type, topBotComparFn, (const void *) &pTagInfo->tagsLen, topBotSwapFn, 0);
  
     pInfo->num++;
   } else {
@@ -2315,7 +2251,7 @@ static void do_top_function_add(STopBotInfo *pInfo, int32_t maxLen, void *pData,
         (IS_UNSIGNED_NUMERIC_TYPE(type) && val.u64 > pList[0]->v.u64) ||
         (IS_FLOAT_TYPE(type) && val.dKey > pList[0]->v.dKey)) {
       valuePairAssign(pList[0], type, (const char *)&val.i64, ts, pTags, pTagInfo, stage);
-      heapAdjust(pList, type, pTagInfo->tagsLen, 0, maxLen - 1, 0);
+      taosheapadjust((void *) pList, sizeof(tValuePair **), 0, maxLen - 1, (const void *) &type, topBotComparFn, (const void *) &pTagInfo->tagsLen, topBotSwapFn, 0);
     }
   }
 }
@@ -2331,7 +2267,7 @@ static void do_bottom_function_add(STopBotInfo *pInfo, int32_t maxLen, void *pDa
   if (pInfo->num < maxLen) {
     valuePairAssign(pList[pInfo->num], type, (const char *)&val.i64, ts, pTags, pTagInfo, stage);
 
-    heapSort(pList, type, pTagInfo->tagsLen, pInfo->num + 1, 1);
+    taosheapsort((void *) pList, sizeof(tValuePair **), pInfo->num + 1, (const void *) &type, topBotComparFn, (const void *) &pTagInfo->tagsLen, topBotSwapFn, 1);
 
     pInfo->num++;
   } else {
@@ -2339,7 +2275,7 @@ static void do_bottom_function_add(STopBotInfo *pInfo, int32_t maxLen, void *pDa
         (IS_UNSIGNED_NUMERIC_TYPE(type) && val.u64 < pList[0]->v.u64) ||
         (IS_FLOAT_TYPE(type) && val.dKey < pList[0]->v.dKey)) {
       valuePairAssign(pList[0], type, (const char *)&val.i64, ts, pTags, pTagInfo, stage);
-      heapAdjust(pList, type, pTagInfo->tagsLen, 0, maxLen - 1, 1);
+      taosheapadjust((void *) pList, sizeof(tValuePair **), 0, maxLen - 1, (const void *) &type, topBotComparFn, (const void *) &pTagInfo->tagsLen, topBotSwapFn, 1);
     }
   }
 }
diff --git a/src/util/inc/talgo.h b/src/util/inc/talgo.h
index 9e3692225b..4aa5430605 100644
--- a/src/util/inc/talgo.h
+++ b/src/util/inc/talgo.h
@@ -34,6 +34,7 @@ typedef int (*__compar_fn_t) (const void *, const void *);
 #define elePtrAt(base, size, idx) (void *)((char *)(base) + (size) * (idx))
 
 typedef int32_t (*__ext_compar_fn_t)(const void *p1, const void *p2, const void *param);
+typedef void (*__ext_swap_fn_t)(void *p1, void *p2, const void *param);
 
 /**
  * quick sort, with the compare function requiring additional parameters support
@@ -59,6 +60,38 @@ void taosqsort(void *src, size_t numOfElem, size_t size, const void* param, __ex
  */
 void *taosbsearch(const void *key, const void *base, size_t nmemb, size_t size, __compar_fn_t fn, int flags);
 
+/**
+ * adjust heap
+ *
+ * @param base: the start address of array
+ * @param size: size of every item in array
+ * @param start: the first index
+ * @param end: the last index
+ * @param parcompar: parameters for compare function
+ * @param compar: user defined compare function
+ * @param parswap: parameters for swap function
+ * @param swap: user defined swap function, the default swap function doswap will be used if swap is NULL
+ * @param maxroot: if heap is max root heap
+ * @return
+ */
+void taosheapadjust(void *base, int32_t size, int32_t start, int32_t end, const void *parcompar, __ext_compar_fn_t compar, const void *parswap, __ext_swap_fn_t swap, bool maxroot);
+
+/**
+ * sort heap to make sure it is a max/min root heap
+ *
+ * @param base: the start address of array
+ * @param size: size of every item in array
+ * @param len: the length of array
+ * @param parcompar: parameters for compare function
+ * @param compar: user defined compare function
+ * @param parswap: parameters for swap function
+ * @param swap: user defined swap function, the default swap function doswap will be used if swap is NULL
+ * @param maxroot: if heap is max root heap
+ * @return
+ */
+void taosheapsort(void *base, int32_t size, int32_t len, const void *parcompar, __ext_compar_fn_t compar, const void *parswap, __ext_swap_fn_t swap, bool maxroot);
+
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/util/src/talgo.c b/src/util/src/talgo.c
index 278683539e..54b7e00eb7 100644
--- a/src/util/src/talgo.c
+++ b/src/util/src/talgo.c
@@ -225,3 +225,89 @@ void * taosbsearch(const void *key, const void *base, size_t nmemb, size_t size,
   
   return NULL;
 }
+
+void taosheapadjust(void *base, int32_t size, int32_t start, int32_t end, const void *parcompar, __ext_compar_fn_t compar, const void *parswap, __ext_swap_fn_t swap, bool maxroot)
+{
+  int32_t  parent;
+  int32_t  child;
+  char    *buf;
+
+  if (base && size > 0 && compar) {
+    parent = start;
+    child = 2 * parent + 1;
+
+    if (swap == NULL) {
+      buf = calloc(1, size);
+      if (buf == NULL) {
+        return;
+      }
+    }
+
+    if (maxroot) {
+      while (child <= end) {
+        if (child + 1 <= end && (*compar)(elePtrAt(base, size, child), elePtrAt(base, size, child + 1), parcompar) < 0) {
+          child++;
+        }
+
+        if ((*compar)(elePtrAt(base, size, parent), elePtrAt(base, size, child), parcompar) > 0) {
+          break;
+        }
+
+        if (swap == NULL) {
+          doswap(elePtrAt(base, size, parent), elePtrAt(base, size, child), size, buf);
+        } else {
+          (*swap)(elePtrAt(base, size, parent), elePtrAt(base, size, child), parswap);
+        }
+
+        parent = child;
+        child = 2 * parent + 1;
+      }
+    } else {
+      while (child <= end) {
+        if (child + 1 <= end && (*compar)(elePtrAt(base, size, child), elePtrAt(base, size, child + 1), parcompar) > 0) {
+          child++;
+        }
+
+        if ((*compar)(elePtrAt(base, size, parent), elePtrAt(base, size, child), parcompar) < 0) {
+          break;
+        }
+
+        if (swap == NULL) {
+          doswap(elePtrAt(base, size, parent), elePtrAt(base, size, child), size, buf);
+        } else {
+          (*swap)(elePtrAt(base, size, parent), elePtrAt(base, size, child), parswap);
+        }
+
+        parent = child;
+        child = 2 * parent + 1;
+      }
+    }
+
+    if (swap == NULL) {
+      tfree(buf);
+    }
+  }
+}
+
+void taosheapsort(void *base, int32_t size, int32_t len, const void *parcompar, __ext_compar_fn_t compar, const void *parswap, __ext_swap_fn_t swap, bool maxroot)
+{
+  int32_t  i;
+
+  if (base && size > 0) {
+    for (i = len / 2 - 1; i >= 0; i--) {
+      taosheapadjust(base, size, i, len - 1, parcompar, compar, parswap, swap, maxroot);
+    }
+  }
+
+/*
+  char *buf = calloc(1, size);
+
+  for (i = len - 1; i > 0; i--) {
+    doswap(elePtrAt(base, size, 0), elePtrAt(base, size, i));
+    taosheapadjust(base, size, 0, i - 1, parcompar, compar, parswap, swap, maxroot);
+  }
+
+  tfree(buf);
+*/
+}
+

From fe3cc4facd7306153bf41587ed77874d2fe3c46b Mon Sep 17 00:00:00 2001
From: xywang <xywang@taosdata.com>
Date: Mon, 28 Jun 2021 19:32:10 +0800
Subject: [PATCH 04/70] [TD-2574]<fix>: fixed compilation errors.

---
 src/query/src/qAggMain.c | 20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/src/query/src/qAggMain.c b/src/query/src/qAggMain.c
index 2c7242b26a..c8f4cf8dbd 100644
--- a/src/query/src/qAggMain.c
+++ b/src/query/src/qAggMain.c
@@ -2208,12 +2208,24 @@ static int32_t topBotComparFn(const void *p1, const void *p2, const void *param)
   tValuePair  *val2 = *(tValuePair **) p2;
 
   if (IS_SIGNED_NUMERIC_TYPE(type)) {
-    return val1->v.i64 - val2->v.i64;
-  } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
-    return val1->v.u64 - val2->v.u64;
+    if (val1->v.i64 == val2->v.i64) {
+      return 0;
+    }
+
+    return (val1->v.i64 > val2->v.i64) ? 1 : -1;
+   } else if (IS_UNSIGNED_NUMERIC_TYPE(type)) {
+     if (val1->v.u64 == val2->v.u64) {
+       return 0;
+     }
+
+     return (val1->v.u64 > val2->v.u64) ? 1 : -1;
   }
 
-  return val1->v.dKey - val2->v.dKey;
+  if (val1->v.dKey == val2->v.dKey) {
+    return 0;
+  }
+
+  return (val1->v.dKey > val2->v.dKey) ? 1 : -1;
 }
 
 static void topBotSwapFn(void *dst, void *src, const void *param)

From c0e4296d15d7ded0cc2d451209c3cc98ed94826b Mon Sep 17 00:00:00 2001
From: tomchon <haoran920c@163.com>
Date: Tue, 29 Jun 2021 19:17:13 +0800
Subject: [PATCH 05/70] [TD-4552]<test>: update testcase that compressing wal
 logs

---
 tests/pytest/fulltest.sh                   |  2 +-
 tests/pytest/functions/function_irate.py   | 35 +++++++++++++++++++++-
 tests/pytest/wal/sdbCompClusterReplica2.py | 12 ++++++++
 3 files changed, 47 insertions(+), 2 deletions(-)

diff --git a/tests/pytest/fulltest.sh b/tests/pytest/fulltest.sh
index c66ccc5477..37fb3acdfa 100755
--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
@@ -235,7 +235,7 @@ python3 ./test.py -f query/queryTscomputWithNow.py
 python3 ./test.py -f query/computeErrorinWhere.py
 python3 ./test.py -f query/queryTsisNull.py
 python3 ./test.py -f query/subqueryFilter.py
-# python3 ./test.py -f query/nestedQuery/queryInterval.py
+python3 ./test.py -f query/nestedQuery/queryInterval.py
 python3 ./test.py -f query/queryStateWindow.py
 
 
diff --git a/tests/pytest/functions/function_irate.py b/tests/pytest/functions/function_irate.py
index 2c85e1bbdd..4e876cc270 100644
--- a/tests/pytest/functions/function_irate.py
+++ b/tests/pytest/functions/function_irate.py
@@ -27,6 +27,7 @@ class TDTestCase:
         self.rowNum = 100
         self.ts = 1537146000000
         self.ts1 = 1537146000000000
+        self.ts2 = 1597146000000
 
         
     def run(self):
@@ -35,6 +36,8 @@ class TDTestCase:
         tdSql.execute('''create table test(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double, 
                     col7 bool, col8 binary(20), col9 nchar(20), col11 tinyint unsigned, col12 smallint unsigned, col13 int unsigned, col14 bigint unsigned) tags(loc nchar(20), tag1 int)''')
         tdSql.execute("create table test1 using test tags('beijing', 10)")
+        tdSql.execute("create table test2 using test tags('tianjing', 20)")
+        tdSql.execute("create table test3 using test tags('shanghai', 20)")    
         tdSql.execute("create table gtest1 (ts timestamp, col1 float)")
         tdSql.execute("create table gtest2 (ts timestamp, col1 tinyint)")
         tdSql.execute("create table gtest3 (ts timestamp, col1 tinyint)")
@@ -48,6 +51,10 @@ class TDTestCase:
         for i in range(self.rowNum):
             tdSql.execute("insert into test1 values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)" 
                         % (self.ts + i*1000, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1))
+            tdSql.execute("insert into test2 values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)" 
+                        % (self.ts2 + i*1000, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1))
+            tdSql.execute("insert into test3 values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)" 
+                        % (self.ts2 + i*1000, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1))
                     
         tdSql.execute("insert into gtest1 values(1537146000000,0);")
         tdSql.execute("insert into gtest1 values(1537146001100,1.2);")
@@ -69,7 +76,7 @@ class TDTestCase:
         tdSql.execute("insert into gtest8 values(1537146000002,4);")
         tdSql.execute("insert into gtest8 values(1537146002202,4);")  
         
-        # irate verifacation 
+        # irate verifacation --child table'query
         tdSql.query("select irate(col1) from test1;")
         tdSql.checkData(0, 0, 1)
         tdSql.query("select irate(col1) from test1 interval(10s);")
@@ -99,6 +106,32 @@ class TDTestCase:
         tdSql.query("select irate(col2) from test1;")
         tdSql.checkData(0, 0, 1)
 
+        # irate verifacation --super table'query
+        tdSql.query("select irate(col1) from test group by tbname,loc,tag1;")
+        tdSql.checkData(0, 0, 1)
+        tdSql.checkData(1, 1, "test2")
+        tdSql.checkData(2, 2, "shanghai")    
+        
+        # add function testcase of twa: query from super table
+        tdSql.query("select twa(col1) from test group by tbname,loc,tag1;")
+        tdSql.checkData(0, 0, 50.5)
+        tdSql.checkData(1, 1, "test2")
+        tdSql.checkData(2, 2, "shanghai")        
+
+        # error: function of irate and twa has invalid operation
+        tdSql.error("select irate(col7) from test group by tbname,loc,tag1;")
+        tdSql.error("select irate(col7) from test group by tbname;")
+        tdSql.error("select irate(col1) from test group by loc,tbname,tag1;")
+        # tdSql.error("select irate(col1) from test group by tbname,col7;")
+        tdSql.error("select irate(col1) from test group by col7,tbname;")
+        tdSql.error("select twa(col7) from test group by tbname,loc,tag1;")
+        tdSql.error("select twa(col7) from test group by tbname;")
+        tdSql.error("select twa(col1) from test group by loc,tbname,tag1;")
+        # tdSql.error("select twa(col1) from test group by tbname,col7;")
+        tdSql.error("select twa(col1) from test group by col7,tbname;")
+                
+
+        # general table'query 
         tdSql.query("select irate(col1) from gtest1;")
         tdSql.checkData(0, 0, 1.2/1.1)
         tdSql.query("select irate(col1) from gtest2;")
diff --git a/tests/pytest/wal/sdbCompClusterReplica2.py b/tests/pytest/wal/sdbCompClusterReplica2.py
index 117da8ca2f..e364145e19 100644
--- a/tests/pytest/wal/sdbCompClusterReplica2.py
+++ b/tests/pytest/wal/sdbCompClusterReplica2.py
@@ -86,6 +86,18 @@ class TwoClients:
         tdSql.execute("alter table stb2_0 add column col2 binary(4)")
         tdSql.execute("alter table stb2_0 drop column col1")
         tdSql.execute("insert into stb2_0 values(1614218422000,8638,'R')")
+        tdSql.execute("drop dnode 10")
+        sleep(10)
+        os.system("rm -rf /var/lib/taos/*")
+        print("clear dnode chenhaoran02'data files")
+        os.system("nohup /usr/bin/taosd > /dev/null 2>&1 &")
+        print("start taosd")
+        sleep(10)
+        tdSql.execute("reset query cache ;")
+        tdSql.execute("create dnode chenhaoran02 ;")
+      
+
+       
         
 
         # stop taosd and compact wal file

From 965f55beeb04366d7efc90788bd8b62d14ae7541 Mon Sep 17 00:00:00 2001
From: zyyang-taosdata <zyyang@taosdata.com>
Date: Mon, 5 Jul 2021 15:43:25 +0800
Subject: [PATCH 06/70] change version number

---
 cmake/version.inc   | 2 +-
 snap/snapcraft.yaml | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/cmake/version.inc b/cmake/version.inc
index 134f09f179..34e8f1f83a 100755
--- a/cmake/version.inc
+++ b/cmake/version.inc
@@ -4,7 +4,7 @@ PROJECT(TDengine)
 IF (DEFINED VERNUMBER)
   SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "2.1.3.0")
+  SET(TD_VER_NUMBER "2.1.4.1")
 ENDIF ()
 
 IF (DEFINED VERCOMPATIBLE)
diff --git a/snap/snapcraft.yaml b/snap/snapcraft.yaml
index 65a8e6b684..fe60dca6ed 100644
--- a/snap/snapcraft.yaml
+++ b/snap/snapcraft.yaml
@@ -1,6 +1,6 @@
 name: tdengine
 base: core18
-version: '2.1.3.0'
+version: '2.1.4.1'
 icon: snap/gui/t-dengine.svg
 summary: an open-source big data platform designed and optimized for IoT. 
 description: |
@@ -72,7 +72,7 @@ parts:
       - usr/bin/taosd
       - usr/bin/taos
       - usr/bin/taosdemo
-      - usr/lib/libtaos.so.2.1.3.0
+      - usr/lib/libtaos.so.2.1.4.1
       - usr/lib/libtaos.so.1
       - usr/lib/libtaos.so
 

From 48db99a7e94966cb59346882633bab1fbf263e39 Mon Sep 17 00:00:00 2001
From: zyyang-taosdata <zyyang@taosdata.com>
Date: Mon, 5 Jul 2021 22:58:20 +0800
Subject: [PATCH 07/70] modify alert release'scripts

---
 alert/release.sh | 25 +++++++++++++++++++++++--
 1 file changed, 23 insertions(+), 2 deletions(-)

diff --git a/alert/release.sh b/alert/release.sh
index 35eb4d677f..77f6798480 100755
--- a/alert/release.sh
+++ b/alert/release.sh
@@ -7,8 +7,9 @@ set -e
 cpuType=amd64    # [armv6l | arm64 | amd64 | 386]
 osType=linux   # [linux | darwin | windows]
 version=""
+verType=stable   # [stable, beta]
 declare -A archMap=(["armv6l"]="arm" ["arm64"]="arm64" ["amd64"]="x64" ["386"]="x86")
-while getopts "h:c:o:n:" arg
+while getopts "h:c:o:n:V:" arg
 do
   case $arg in
     c)
@@ -23,6 +24,10 @@ do
       #echo "version=$OPTARG"
       version=$(echo $OPTARG)
       ;;
+     V)
+      #echo "verType=$OPTARG"
+      verType=$(echo $OPTARG)
+      ;;
     h)
       echo "Usage: `basename $0` -c [armv6l | arm64 | amd64 | 386] -o [linux | darwin | windows]"
       exit 0
@@ -55,6 +60,22 @@ cp alert alert.cfg install_driver.sh ./TDengine-alert/.
 cp ../../../debug/build/lib/libtaos.so.${version} ./TDengine-alert/driver/.
 chmod 777 ./TDengine-alert/install_driver.sh
 
-tar -I 'gzip -9' -cf ${startdir}/TDengine-alert-${version}-${osType^}-${archMap[${cpuType}]}.tar.gz TDengine-alert/
+tar -I 'gzip -9' -cf ${scriptdir}/TDengine-alert-${version}-${osType^}-${archMap[${cpuType}]}.tar.gz TDengine-alert/
 rm -rf ./TDengine-alert
 
+
+
+# mv package to comminuty/release/
+pkg_name=TDengine-alert-${version}-${osType^}-${archMap[${cpuType}]}
+
+if [ "$verType" == "beta" ]; then
+  pkg_name=${pkg_name}-${verType}
+elif [ "$verType" == "stable" ]; then
+  pkg_name=${pkg_name}
+else
+  echo "unknow verType, nor stabel or beta"
+  exit 1
+fi
+
+cd ${scriptdir}/../release/
+mv ${scriptdir}/TDengine-alert-${version}-${osType^}-${archMap[${cpuType}]}.tar.gz  ${pkg_name}.tar.gz

From 32d8dd797902c3fb3c27f9f9e74639694b9cac18 Mon Sep 17 00:00:00 2001
From: bryanchang0603 <changb9@mcamster.ca>
Date: Tue, 6 Jul 2021 02:27:49 +0800
Subject: [PATCH 08/70] modify release.sh

---
 alert/release.sh                   | 25 +++++++++++++++++++++++--
 cmake/version.inc                  |  2 +-
 packaging/docker/dockerManifest.sh |  4 +++-
 snap/snapcraft.yaml                |  4 ++--
 4 files changed, 29 insertions(+), 6 deletions(-)

diff --git a/alert/release.sh b/alert/release.sh
index 35eb4d677f..77f6798480 100755
--- a/alert/release.sh
+++ b/alert/release.sh
@@ -7,8 +7,9 @@ set -e
 cpuType=amd64    # [armv6l | arm64 | amd64 | 386]
 osType=linux   # [linux | darwin | windows]
 version=""
+verType=stable   # [stable, beta]
 declare -A archMap=(["armv6l"]="arm" ["arm64"]="arm64" ["amd64"]="x64" ["386"]="x86")
-while getopts "h:c:o:n:" arg
+while getopts "h:c:o:n:V:" arg
 do
   case $arg in
     c)
@@ -23,6 +24,10 @@ do
       #echo "version=$OPTARG"
       version=$(echo $OPTARG)
       ;;
+     V)
+      #echo "verType=$OPTARG"
+      verType=$(echo $OPTARG)
+      ;;
     h)
       echo "Usage: `basename $0` -c [armv6l | arm64 | amd64 | 386] -o [linux | darwin | windows]"
       exit 0
@@ -55,6 +60,22 @@ cp alert alert.cfg install_driver.sh ./TDengine-alert/.
 cp ../../../debug/build/lib/libtaos.so.${version} ./TDengine-alert/driver/.
 chmod 777 ./TDengine-alert/install_driver.sh
 
-tar -I 'gzip -9' -cf ${startdir}/TDengine-alert-${version}-${osType^}-${archMap[${cpuType}]}.tar.gz TDengine-alert/
+tar -I 'gzip -9' -cf ${scriptdir}/TDengine-alert-${version}-${osType^}-${archMap[${cpuType}]}.tar.gz TDengine-alert/
 rm -rf ./TDengine-alert
 
+
+
+# mv package to comminuty/release/
+pkg_name=TDengine-alert-${version}-${osType^}-${archMap[${cpuType}]}
+
+if [ "$verType" == "beta" ]; then
+  pkg_name=${pkg_name}-${verType}
+elif [ "$verType" == "stable" ]; then
+  pkg_name=${pkg_name}
+else
+  echo "unknow verType, nor stabel or beta"
+  exit 1
+fi
+
+cd ${scriptdir}/../release/
+mv ${scriptdir}/TDengine-alert-${version}-${osType^}-${archMap[${cpuType}]}.tar.gz  ${pkg_name}.tar.gz
diff --git a/cmake/version.inc b/cmake/version.inc
index 134f09f179..34e8f1f83a 100755
--- a/cmake/version.inc
+++ b/cmake/version.inc
@@ -4,7 +4,7 @@ PROJECT(TDengine)
 IF (DEFINED VERNUMBER)
   SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "2.1.3.0")
+  SET(TD_VER_NUMBER "2.1.4.1")
 ENDIF ()
 
 IF (DEFINED VERCOMPATIBLE)
diff --git a/packaging/docker/dockerManifest.sh b/packaging/docker/dockerManifest.sh
index c846e8345d..c479925932 100755
--- a/packaging/docker/dockerManifest.sh
+++ b/packaging/docker/dockerManifest.sh
@@ -35,7 +35,9 @@ done
 
 echo "verNumber=${verNumber}"
 
-#docker manifest create -a tdengine/tdengine:${verNumber} tdengine/tdengine-amd64:${verNumber} tdengine/tdengine-aarch64:${verNumber} tdengine/tdengine-aarch32:${verNumber}
+#docker manifest rm tdengine/tdengine
+#docker manifest rm tdengine/tdengine:${verNumber}
+docker manifest create -a tdengine/tdengine:${verNumber} tdengine/tdengine-amd64:${verNumber} tdengine/tdengine-aarch64:${verNumber} tdengine/tdengine-aarch32:${verNumber}
 docker manifest create -a tdengine/tdengine:latest tdengine/tdengine-amd64:latest tdengine/tdengine-aarch64:latest tdengine/tdengine-aarch32:latest
 
 docker login -u tdengine -p ${passWord}  #replace the docker registry username and password
diff --git a/snap/snapcraft.yaml b/snap/snapcraft.yaml
index 65a8e6b684..fe60dca6ed 100644
--- a/snap/snapcraft.yaml
+++ b/snap/snapcraft.yaml
@@ -1,6 +1,6 @@
 name: tdengine
 base: core18
-version: '2.1.3.0'
+version: '2.1.4.1'
 icon: snap/gui/t-dengine.svg
 summary: an open-source big data platform designed and optimized for IoT. 
 description: |
@@ -72,7 +72,7 @@ parts:
       - usr/bin/taosd
       - usr/bin/taos
       - usr/bin/taosdemo
-      - usr/lib/libtaos.so.2.1.3.0
+      - usr/lib/libtaos.so.2.1.4.1
       - usr/lib/libtaos.so.1
       - usr/lib/libtaos.so
 

From a7a38aece7c5bb74dd6d73b154ca3b4e5ff95663 Mon Sep 17 00:00:00 2001
From: tomchon <haoran920c@163.com>
Date: Tue, 6 Jul 2021 17:50:49 +0000
Subject: [PATCH 09/70] modify release scripts of docker-building

---
 packaging/docker/dockerbuild.sh | 67 +++++++++++++++++++++++++--------
 1 file changed, 52 insertions(+), 15 deletions(-)

diff --git a/packaging/docker/dockerbuild.sh b/packaging/docker/dockerbuild.sh
index b7991465b0..76717d5892 100755
--- a/packaging/docker/dockerbuild.sh
+++ b/packaging/docker/dockerbuild.sh
@@ -1,20 +1,24 @@
 #!/bin/bash
+#
+
 set -e
 #set -x
 
 # dockerbuild.sh 
 #             -c [aarch32 | aarch64 | amd64 | x86 | mips64 ...]  
-#             -f [pkg file]
 #             -n [version number]
 #             -p [password for docker hub]
+#             -V [stable | beta]
+#             -f [pkg file]
 
 # set parameters by default value
-cpuType=amd64
-verNumber=""
+cpuType=""
+version=""
 passWord=""
 pkgFile=""
+verType=""
 
-while getopts "hc:n:p:f:" arg
+while getopts "hc:n:p:f:V:" arg
 do
   case $arg in
     c)
@@ -22,8 +26,8 @@ do
       cpuType=$(echo $OPTARG)
       ;;
     n)
-      #echo "verNumber=$OPTARG"
-      verNumber=$(echo $OPTARG)
+      #echo "version=$OPTARG"
+      version=$(echo $OPTARG)
       ;;
     p)
       #echo "passWord=$OPTARG"
@@ -33,11 +37,17 @@ do
       #echo "pkgFile=$OPTARG"
       pkgFile=$(echo $OPTARG)
       ;;
+    V)
+      #echo "verType=$OPTARG"
+      verType=$(echo $OPTARG)
+      ;;
     h)
-      echo "Usage: `basename $0` -c [aarch32 | aarch64 | amd64 | x86 | mips64 ...] "      
-      echo "                      -f [pkg file] "      
+      echo "Usage: `basename $0`  -c [aarch32 | aarch64 | amd64 | x86 | mips64 ...] "
       echo "                      -n [version number] "
       echo "                      -p [password for docker hub] "
+      echo "                      -V [stable | beta] "
+      echo "                      -f [pkg file] "
+
       exit 0
       ;;
     ?) #unknow option 
@@ -47,17 +57,44 @@ do
   esac
 done
 
-echo "cpuType=${cpuType} verNumber=${verNumber} pkgFile=${pkgFile} "
+# if [ "$verType" == "beta" ]; then
+#   pkgFile=TDengine-server-${version}-Linux-${cpuType}-${verType}.tar.gz
+# elif [ "$verType" == "stable" ]; then
+#   pkgFile=TDengine-server-${version}-Linux-${cpuType}.tar.gz
+# else
+#   echo "unknow verType, nor stabel or beta"
+#   exit 1
+
+if [ "$verType" == "beta" ]; then
+  dockername=${cpuType}-${verType}
+elif [ "$verType" == "stable" ]; then
+  dockername=${cpuType}
+else
+  echo "unknow verType, nor stabel or beta"
+  exit 1
+fi
+
+
+echo "cpuType=${cpuType} version=${version} pkgFile=${pkgFile} verType=${verType} "
 echo "$(pwd)"
 echo "====NOTES: ${pkgFile} must be in the same directory as dockerbuild.sh===="
 
-dirName=${pkgFile%-Linux*}
-#echo "dirName=${dirName}"
+scriptDir=$(dirname $(readlink -f $0))
+comunityArchiveDir=/nas/TDengine/v$version/community   # community version’package directory
+cd ${scriptDir}
+cp -f ${comunityArchiveDir}/${pkgFile}  .
 
-docker build --rm -f "Dockerfile" -t tdengine/tdengine-${cpuType}:${verNumber} "." --build-arg pkgFile=${pkgFile} --build-arg dirName=${dirName}
+dirName=${pkgFile%-Linux*}
+echo "dirName=${dirName}"
+
+
+docker build --rm -f "Dockerfile" -t tdengine/tdengine-${dockername}:${version} "." --build-arg pkgFile=${pkgFile} --build-arg dirName=${dirName}
 docker login -u tdengine -p ${passWord}  #replace the docker registry username and password
-docker push tdengine/tdengine-${cpuType}:${verNumber}
+docker push tdengine/tdengine-${dockername}:${version}
 
 # set this version to latest version
-docker tag tdengine/tdengine-${cpuType}:${verNumber} tdengine/tdengine-${cpuType}:latest
-docker push tdengine/tdengine-${cpuType}:latest
+docker tag tdengine/tdengine-${dockername}:${version} tdengine/tdengine-${dockername}:latest
+docker push tdengine/tdengine-${dockername}:latest
+
+
+rm -f ${pkgFile}
\ No newline at end of file

From a388965892eae3f7711445301af49ec4a5cb1680 Mon Sep 17 00:00:00 2001
From: tomchon <haoran920c@163.com>
Date: Wed, 7 Jul 2021 11:31:15 +0800
Subject: [PATCH 10/70] modify dockerManifest.sh

---
 packaging/docker/dockerManifest.sh | 43 ++++++++++++++++++++++--------
 1 file changed, 32 insertions(+), 11 deletions(-)

diff --git a/packaging/docker/dockerManifest.sh b/packaging/docker/dockerManifest.sh
index c479925932..598bd46f13 100755
--- a/packaging/docker/dockerManifest.sh
+++ b/packaging/docker/dockerManifest.sh
@@ -5,22 +5,28 @@ set -e
 # dockerbuild.sh 
 #             -n [version number]
 #             -p [xxxx]
+#             -V [stable | beta]
 
 # set parameters by default value
-verNumber=""
+version=""
 passWord=""
+verType=""
 
-while getopts "hn:p:" arg
+while getopts "hn:p:V:" arg
 do
   case $arg in
     n)
-      #echo "verNumber=$OPTARG"
-      verNumber=$(echo $OPTARG)
+      #echo "version=$OPTARG"
+      version=$(echo $OPTARG)
       ;;
     p)
       #echo "passWord=$OPTARG"
       passWord=$(echo $OPTARG)
       ;;
+    V)
+      #echo "verType=$OPTARG"
+      verType=$(echo $OPTARG)
+      ;;    
     h)
       echo "Usage: `basename $0` -n [version number] "
       echo "                      -p [password for docker hub] "
@@ -33,15 +39,30 @@ do
   esac
 done
 
-echo "verNumber=${verNumber}"
+echo "version=${version}"
 
 #docker manifest rm tdengine/tdengine
-#docker manifest rm tdengine/tdengine:${verNumber}
-docker manifest create -a tdengine/tdengine:${verNumber} tdengine/tdengine-amd64:${verNumber} tdengine/tdengine-aarch64:${verNumber} tdengine/tdengine-aarch32:${verNumber}
-docker manifest create -a tdengine/tdengine:latest tdengine/tdengine-amd64:latest tdengine/tdengine-aarch64:latest tdengine/tdengine-aarch32:latest
+#docker manifest rm tdengine/tdengine:${version}
+if [ "$verType" == "beta" ]; then
+  docker manifest create -a tdengine/tdengine-beta:${version} tdengine/tdengine-amd64-beta:${version} tdengine/tdengine-aarch64-beta:${version} tdengine/tdengine-aarch32-beta:${version}
+  docker manifest create -a tdengine/tdengine-beta:latest tdengine/tdengine-amd64-beta:latest tdengine/tdengine-aarch64-beta:latest tdengine/tdengine-aarch32-beta:latest
+  docker login -u tdengine -p ${passWord}  #replace the docker registry username and password
+  docker manifest push tdengine/tdengine-beta:latest
+elif [ "$verType" == "stable" ]; then
+  docker manifest create -a tdengine/tdengine:${version} tdengine/tdengine-amd64:${version} tdengine/tdengine-aarch64:${version} tdengine/tdengine-aarch32:${version}
+  docker manifest create -a tdengine/tdengine:latest tdengine/tdengine-amd64:latest tdengine/tdengine-aarch64:latest tdengine/tdengine-aarch32:latest
+  docker login -u tdengine -p ${passWord}  #replace the docker registry username and password
+  docker manifest push tdengine/tdengine:latest
+else
+  echo "unknow verType, nor stabel or beta"
+  exit 1
+fi
 
-docker login -u tdengine -p ${passWord}  #replace the docker registry username and password
+# docker manifest create -a tdengine/${dockername}:${version} tdengine/tdengine-amd64:${version} tdengine/tdengine-aarch64:${version} tdengine/tdengine-aarch32:${version}
+# docker manifest create -a tdengine/${dockername}:latest tdengine/tdengine-amd64:latest tdengine/tdengine-aarch64:latest tdengine/tdengine-aarch32:latest
 
-docker manifest push tdengine/tdengine:latest
+# docker login -u tdengine -p ${passWord}  #replace the docker registry username and password
 
-# how set latest version ???
+# docker manifest push tdengine/tdengine:latest
+
+# # how set latest version ???

From cbb8642f7912fac1df200f1f755ab5d1962e86e0 Mon Sep 17 00:00:00 2001
From: happyguoxy <happy_guoxy@163.com>
Date: Thu, 8 Jul 2021 13:55:28 +0800
Subject: [PATCH 11/70] [TD-4735]<test>:test nestquery last row function

---
 tests/pytest/query/nestquery_last_row.py | 263 +++++++++++++++++++++++
 1 file changed, 263 insertions(+)
 create mode 100644 tests/pytest/query/nestquery_last_row.py

diff --git a/tests/pytest/query/nestquery_last_row.py b/tests/pytest/query/nestquery_last_row.py
new file mode 100644
index 0000000000..a04cb173af
--- /dev/null
+++ b/tests/pytest/query/nestquery_last_row.py
@@ -0,0 +1,263 @@
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import tdLog
+from util.cases import tdCases
+from util.sql import tdSql
+import random
+
+
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor(), logSql)
+
+        self.ts = 1600000000000
+        self.num = 10
+
+    def run(self):
+        tdSql.prepare() 
+        # test case for https://jira.taosdata.com:18080/browse/TD-4735       
+        
+        tdSql.execute('''create stable stable_1
+                    (ts timestamp , q_int int , q_bigint bigint , q_smallint smallint , q_tinyint tinyint, 
+                    q_bool bool , q_binary binary(20) , q_nchar nchar(20) ,
+                    q_float float , q_double double , q_ts timestamp) 
+                    tags(loc nchar(20) , t_int int , t_bigint bigint , t_smallint smallint , t_tinyint tinyint, 
+                    t_bool bool , t_binary binary(20) , t_nchar nchar(20) ,
+                    t_float float , t_double double , t_ts timestamp);''')
+        tdSql.execute('''create table table_0 using stable_1 
+                    tags('table_0' , '0' , '0' , '0' , '0' , 0 , '0' , '0' , '0' , '0' ,'0')''')
+        tdSql.execute('''create table table_1 using stable_1 
+                    tags('table_1' , '2147483647' , '9223372036854775807' , '32767' , '127' , 1 , 
+                    'binary1' , 'nchar1' , '1' , '11' , \'1999-09-09 09:09:09.090\')''')
+        tdSql.execute('''create table table_2 using stable_1 
+                    tags('table_2' , '-2147483647' , '-9223372036854775807' , '-32767' , '-127' , false , 
+                    'binary2' , 'nchar2nchar2' , '-2.2' , '-22.22' , \'2099-09-09 09:09:09.090\')''')
+        tdSql.execute('''create table table_3 using stable_1 
+                    tags('table_3' , '3' , '3' , '3' , '3' , true , 'binary3' , 'nchar3' , '33.33' , '3333.3333' , '0')''')
+        tdSql.execute('''create table table_4 using stable_1 
+                    tags('table_4' , '4' , '4' , '4' , '4' , false , 'binary4' , 'nchar4' , '-444.444' , '-444444.444444' , '0')''')
+        tdSql.execute('''create table table_5 using stable_1 
+                    tags('table_5' , '5' , '5' , '5' , '5' , true , 'binary5' , 'nchar5' , '5555.5555' , '55555555.55555555' , '0')''')
+        #regular table
+        tdSql.execute('''create table regular_table_1
+                    (ts timestamp , q_int int , q_bigint bigint , q_smallint smallint , q_tinyint tinyint, 
+                    q_bool bool , q_binary binary(20) , q_nchar nchar(20) ,
+                    q_float float , q_double double , q_ts timestamp) ;''')
+
+        for i in range(self.num):
+            tdSql.execute('''insert into table_0 values(%d, %d, %d, %d, %d, 0, 'binary.%s', 'nchar.%s', %f, %f, %d)''' 
+                            % (self.ts + i, i, i, i, i, i, i, i, i, self.ts + i))
+            tdSql.execute('''insert into table_1 values(%d, %d, %d, %d, %d, 1, 'binary1.%s', 'nchar1.%s', %f, %f, %d)''' 
+                            % (self.ts + i, 2147483647-i, 9223372036854775807-i, 32767-i, 127-i, 
+                            i, i, random.random(), random.random(), 1262304000001 + i))
+            tdSql.execute('''insert into table_2 values(%d, %d, %d, %d, %d, true, 'binary2.%s', 'nchar2nchar2.%s', %f, %f, %d)''' 
+                            % (self.ts + i, -2147483647+i, -9223372036854775807+i, -32767+i, -127+i, 
+                            i, i, random.uniform(-1,0), random.uniform(-1,0), 1577836800001 + i))
+            tdSql.execute('''insert into table_3 values(%d, %d, %d, %d, %d, false, 'binary3.%s', 'nchar3.%s', %f, %f, %d)''' 
+                            % (self.ts + i, random.randint(-2147483647, 2147483647), 
+                            random.randint(-9223372036854775807, 9223372036854775807), random.randint(-32767, 32767),
+                            random.randint(-127, 127), random.randint(-100, 100), random.randint(-10000, 10000), 
+                            random.uniform(-100000,100000), random.uniform(-1000000000,1000000000), self.ts + i))
+            tdSql.execute('''insert into table_4 values(%d, %d, %d, %d, %d, true, 'binary4.%s', 'nchar4.%s', %f, %f, %d)''' 
+                            % (self.ts + i, i, i, i, i, i, i, i, i, self.ts + i))
+            tdSql.execute('''insert into table_5 values(%d, %d, %d, %d, %d, false, 'binary5.%s', 'nchar5.%s', %f, %f, %d)''' 
+                            % (self.ts + i, i, i, i, i, i, i, i, i, self.ts + i))  
+
+            tdSql.execute('''insert into regular_table_1 values(%d, %d, %d, %d, %d, 0, 'binary.%s', 'nchar.%s', %f, %f, %d)''' 
+                            % (self.ts + i, i, i, i, i, i, i, i, i, self.ts + i))
+            tdSql.execute('''insert into regular_table_1 values(%d, %d, %d, %d, %d, 1, 'binary1.%s', 'nchar1.%s', %f, %f, %d)''' 
+                            % (self.ts + 100 + i, 2147483647-i, 9223372036854775807-i, 32767-i, 127-i, 
+                            i, i, random.random(), random.random(), 1262304000001 + i))
+            tdSql.execute('''insert into regular_table_1 values(%d, %d, %d, %d, %d, true, 'binary2.%s', 'nchar2nchar2.%s', %f, %f, %d)''' 
+                            % (self.ts + 200 + i, -2147483647+i, -9223372036854775807+i, -32767+i, -127+i, 
+                            i, i, random.uniform(-1,0), random.uniform(-1,0), 1577836800001 + i))
+            tdSql.execute('''insert into regular_table_1 values(%d, %d, %d, %d, %d, false, 'binary3.%s', 'nchar3.%s', %f, %f, %d)''' 
+                            % (self.ts + 300 + i, random.randint(-2147483647, 2147483647), 
+                            random.randint(-9223372036854775807, 9223372036854775807), random.randint(-32767, 32767),
+                            random.randint(-127, 127), random.randint(-100, 100), random.randint(-10000, 10000), 
+                            random.uniform(-100000,100000), random.uniform(-1000000000,1000000000), self.ts + i))
+            tdSql.execute('''insert into regular_table_1 values(%d, %d, %d, %d, %d, true, 'binary4.%s', 'nchar4.%s', %f, %f, %d)''' 
+                            % (self.ts + 400 + i, i, i, i, i, i, i, i, i, self.ts + i))
+            tdSql.execute('''insert into regular_table_1 values(%d, %d, %d, %d, %d, false, 'binary5.%s', 'nchar5.%s', %f, %f, %d)''' 
+                            % (self.ts + 500 + i, i, i, i, i, i, i, i, i, self.ts + i))               
+
+        sql = '''select * from stable_1'''
+        tdSql.query(sql)
+        tdSql.checkRows(6*self.num)    
+        sql = '''select * from regular_table_1'''
+        tdSql.query(sql)
+        tdSql.checkRows(6*self.num)    
+
+        tdLog.info("=======last_row(*)========")
+        sql = '''select last_row(*) from stable_1;'''
+        tdSql.query(sql)
+        tdSql.checkData(0,1,self.num-1)
+        sql = '''select last_row(*) from regular_table_1;'''
+        tdSql.query(sql)
+        tdSql.checkData(0,1,self.num-1)
+
+        sql = '''select * from stable_1 
+                where loc = 'table_0';'''
+        tdSql.query(sql)
+        tdSql.checkRows(self.num)
+        sql = '''select last_row(*) from 
+                (select * from stable_1 
+                where loc = 'table_0');'''
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        sql = '''select last_row(*) from 
+                (select * from stable_1);'''
+        tdSql.query(sql)
+        tdSql.checkData(0,1,self.num-1)
+        tdSql.checkData(0,2,self.num-1)
+        tdSql.checkData(0,3,self.num-1)
+        tdSql.checkData(0,4,self.num-1)
+        tdSql.checkData(0,5,'False')
+        tdSql.checkData(0,6,'binary5.9')
+        tdSql.checkData(0,7,'nchar5.9')
+        tdSql.checkData(0,8,9.00000)
+        tdSql.checkData(0,9,9.000000000)
+        tdSql.checkData(0,10,'2020-09-13 20:26:40.009')
+        tdSql.checkData(0,11,'table_5')
+        tdSql.checkData(0,12,5)
+        tdSql.checkData(0,13,5)
+        tdSql.checkData(0,14,5)
+        tdSql.checkData(0,15,5)
+        tdSql.checkData(0,16,'True')
+        tdSql.checkData(0,17,'binary5')
+        tdSql.checkData(0,18,'nchar5')
+        tdSql.checkData(0,21,'1970-01-01 08:00:00.000')
+
+        sql = '''select * from regular_table_1 ;'''
+        tdSql.query(sql)
+        tdSql.checkRows(6*self.num)
+        sql = '''select last_row(*) from 
+                (select * from regular_table_1);'''
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0,1,self.num-1)
+        tdSql.checkData(0,2,self.num-1)
+        tdSql.checkData(0,3,self.num-1)
+        tdSql.checkData(0,4,self.num-1)
+        tdSql.checkData(0,5,'False')
+        tdSql.checkData(0,6,'binary5.9')
+        tdSql.checkData(0,7,'nchar5.9')
+        tdSql.checkData(0,8,9.00000)
+        tdSql.checkData(0,9,9.000000000)
+        tdSql.checkData(0,10,'2020-09-13 20:26:40.009')
+
+        sql = '''select last_row(*) from 
+                ((select * from table_0) union all
+                 (select * from table_1) union all
+                 (select * from table_2));'''
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0,1,self.num-1)
+        tdSql.checkData(0,2,self.num-1)
+        tdSql.checkData(0,3,self.num-1)
+        tdSql.checkData(0,4,self.num-1)
+        tdSql.checkData(0,5,'False')
+        tdSql.checkData(0,6,'binary.9')
+        tdSql.checkData(0,7,'nchar.9')
+        tdSql.checkData(0,8,9.00000)
+        tdSql.checkData(0,9,9.000000000)
+        tdSql.checkData(0,10,'2020-09-13 20:26:40.009')
+
+        # bug 5055
+        # sql = '''select last_row(*) from 
+        #         ((select * from stable_1) union all
+        #          (select * from table_1) union all
+        #          (select * from regular_table_1));'''
+        # tdSql.query(sql)
+        # tdSql.checkData(0,1,self.num-1)
+
+        sql = '''select last_row(*) from 
+                ((select last_row(*) from table_0) union all
+                 (select last_row(*) from table_1) union all
+                 (select last_row(*) from table_2));'''
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0,1,self.num-1)
+        tdSql.checkData(0,2,self.num-1)
+        tdSql.checkData(0,3,self.num-1)
+        tdSql.checkData(0,4,self.num-1)
+        tdSql.checkData(0,5,'False')
+        tdSql.checkData(0,6,'binary.9')
+        tdSql.checkData(0,7,'nchar.9')
+        tdSql.checkData(0,8,9.00000)
+        tdSql.checkData(0,9,9.000000000)
+        tdSql.checkData(0,10,'2020-09-13 20:26:40.009')
+
+        # bug 5055
+        # sql = '''select last_row(*) from 
+        #         ((select last_row(*) from stable_1) union all
+        #          (select last_row(*) from table_1) union all
+        #          (select last_row(*) from regular_table_1));'''
+        # tdSql.query(sql)
+        # tdSql.checkData(0,1,self.num-1)
+
+        sql = '''select last_row(*) from 
+                ((select * from table_0 limit 5 offset 5) union all
+                 (select * from table_1 limit 5 offset 5) union all
+                 (select * from regular_table_1 limit 5 offset 5));'''
+        tdSql.query(sql)
+        tdSql.checkRows(1)
+        tdSql.checkData(0,1,self.num-1)
+        tdSql.checkData(0,2,self.num-1)
+        tdSql.checkData(0,3,self.num-1)
+        tdSql.checkData(0,4,self.num-1)
+        tdSql.checkData(0,5,'False')
+        tdSql.checkData(0,6,'binary.9')
+        tdSql.checkData(0,7,'nchar.9')
+        tdSql.checkData(0,8,9.00000)
+        tdSql.checkData(0,9,9.000000000)
+        tdSql.checkData(0,10,'2020-09-13 20:26:40.009')
+
+
+        sql = '''select last_row(*)  from 
+                (select * from stable_1) 
+                having q_int>5;'''
+        tdLog.info(sql)
+        tdSql.error(sql)
+        try:
+            tdSql.execute(sql)
+            tdLog.exit(" having only works with group by")
+        except Exception as e:
+            tdLog.info(repr(e))
+            tdLog.info("invalid operation: having only works with group by")  
+
+        #bug 5057
+        # sql = '''select last_row(*)  from 
+        #         (select * from (select * from stable_1))'''
+        # tdLog.info(sql)
+        # tdSql.error(sql)
+        # try:
+        #     tdSql.execute(sql)
+        #     tdLog.exit(" core dumped")
+        # except Exception as e:
+        #     tdLog.info(repr(e))
+        #     tdLog.info("core dumped") 
+
+
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
\ No newline at end of file

From df5f03bbdfc315807e03bbd071e5651b743ead53 Mon Sep 17 00:00:00 2001
From: happyguoxy <happy_guoxy@163.com>
Date: Thu, 8 Jul 2021 13:55:47 +0800
Subject: [PATCH 12/70] [TD-4735]<test>:test nestquery last row function

---
 tests/pytest/fulltest.sh | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/pytest/fulltest.sh b/tests/pytest/fulltest.sh
index 2cbc3747f6..9cdab008fd 100755
--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
@@ -239,6 +239,7 @@ python3 ./test.py -f query/subqueryFilter.py
 # python3 ./test.py -f query/nestedQuery/queryInterval.py
 python3 ./test.py -f query/queryStateWindow.py
 python3 ./test.py -f query/nestedQuery/queryWithOrderLimit.py
+python3 ./test.py -f query/nestquery_last_row.py
 
 
 #stream

From c4f06ca30b1a37b42b60a89285fbceba21f2cde8 Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Tue, 6 Jul 2021 18:05:27 +0800
Subject: [PATCH 13/70] develop schemaless

---
 src/client/src/tscParseLineProtocol.c | 731 ++++++++++++++++++++++++++
 1 file changed, 731 insertions(+)
 create mode 100644 src/client/src/tscParseLineProtocol.c

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
new file mode 100644
index 0000000000..79e8955f9a
--- /dev/null
+++ b/src/client/src/tscParseLineProtocol.c
@@ -0,0 +1,731 @@
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "os.h"
+#include "osString.h"
+#include "ttype.h"
+#include "tmd5.h"
+#include "tstrbuild.h"
+#include "tname.h"
+#include "taos.h"
+#include "tsclient.h"
+#include "tscLog.h"
+#include "hash.h"
+#include "tskiplist.h"
+#include "tscUtil.h"
+
+typedef enum {
+  LP_ITEM_TAG,
+  LP_ITEM_FIELD
+} LPItemKind;
+
+typedef struct  {
+  SStrToken key;
+  SStrToken value;
+
+  char name[TSDB_COL_NAME_LEN];
+  int8_t type;
+  int16_t bytes;
+
+  char* payload;
+}SLPItem;
+
+typedef struct {
+  SStrToken measToken;
+  SStrToken tsToken;
+
+  char sTableName[TSDB_TABLE_NAME_LEN];
+  SArray* tags;
+  SArray* fields;
+  int64_t ts;
+
+} SLPPoint;
+
+typedef enum {
+  LP_MEASUREMENT,
+  LP_TAG_KEY,
+  LP_TAG_VALUE,
+  LP_FIELD_KEY,
+  LP_FIELD_VALUE
+} LPPart;
+
+int32_t scanToCommaOrSpace(SStrToken s, int32_t start, int32_t* index, LPPart part) {
+  for (int32_t i = start; i < s.n; ++i) {
+    if (s.z[i] == ',' || s.z[i] == ' ') {
+      *index = i;
+      return 0;
+    }
+  }
+  return -1;
+}
+
+int32_t scanToEqual(SStrToken s, int32_t start, int32_t* index) {
+  for (int32_t i = start; i < s.n; ++i) {
+    if (s.z[i] == '=') {
+      *index = i;
+      return 0;
+    }
+  }
+  return -1;
+}
+
+int32_t setPointMeasurement(SLPPoint* point, SStrToken token) {
+  point->measToken = token;
+  if (point->measToken.n < TSDB_TABLE_NAME_LEN) {
+    strncpy(point->sTableName, point->measToken.z, point->measToken.n);
+    point->sTableName[point->measToken.n] = '\0';
+  }
+  return 0;
+}
+
+int32_t setItemKey(SLPItem* item, SStrToken key, LPPart part) {
+  item->key = key;
+  if (item->key.n < TSDB_COL_NAME_LEN) {
+    strncpy(item->name, item->key.z, item->key.n);
+    item->name[item->key.n] = '\0';
+  }
+  return 0;
+}
+
+int32_t setItemValue(SLPItem* item, SStrToken value, LPPart part) {
+  item->value = value;
+  return 0;
+}
+
+int32_t parseItemValue(SLPItem* item, LPItemKind kind) {
+  char* sv = item->value.z;
+  char* last = item->value.z + item->value.n - 1;
+
+  if (isdigit(sv[0]) || sv[0] == '-') {
+    if (*last == 'i') {
+      item->type = TSDB_DATA_TYPE_BIGINT;
+      item->bytes = (int16_t)tDataTypes[item->type].bytes;
+      item->payload = malloc(item->bytes);
+      char* endptr = NULL;
+      *(item->payload) = strtoll(sv, &endptr, 10);
+    } else {
+      item->type = TSDB_DATA_TYPE_DOUBLE;
+      item->bytes = (int16_t)tDataTypes[item->type].bytes;
+      item->payload = malloc(item->bytes);
+      char* endptr = NULL;
+      *(item->payload) = strtold(sv, &endptr);
+    }
+  } else if ((sv[0] == 'L' && sv[1] =='"') || sv[0] == '"' ) {
+    if (sv[0] == 'L') {
+      item->type = TSDB_DATA_TYPE_NCHAR;
+      uint32_t bytes = item->value.n - 3;
+//      uint32_t len = bytes;
+//      char* ucs = malloc(len);
+//      int32_t ncharBytes = 0;
+//      taosMbsToUcs4(sv+2, len, ucs, len, &ncharBytes);
+//      item->bytes = ncharBytes;
+//      item->payload = malloc(ncharBytes);
+//      memcpy(item->payload, ucs, ncharBytes);
+//      free(ucs);
+      item->bytes = bytes;
+      item->payload = malloc(bytes);
+      memcpy(item->payload, sv+1, bytes);
+    } else if (sv[0]=='"'){
+      item->type = TSDB_DATA_TYPE_BINARY;
+      uint32_t bytes = item->value.n - 2;
+      item->bytes = bytes;
+      item->payload = malloc(bytes);
+      memcpy(item->payload, sv+1, bytes);
+    }
+  } else if (sv[0] == 't' || sv[0] == 'f' || sv[0]=='T' || sv[0] == 'F') {
+    item->type = TSDB_DATA_TYPE_BOOL;
+    item->bytes = tDataTypes[item->type].bytes;
+    item->payload = malloc(tDataTypes[item->type].bytes);
+    *(item->payload) = tolower(sv[0])=='t' ? true : false;
+  }
+  return 0;
+}
+
+int32_t compareLPItemKey(const void* p1, const void* p2) {
+  const SLPItem* t1 = p1;
+  const SLPItem* t2 = p2;
+  uint32_t min = (t1->key.n < t2->key.n) ? t1->key.n : t2->key.n;
+  int res = strncmp(t1->key.z, t2->key.z, min);
+  if (res != 0) {
+    return res;
+  } else {
+    return (int)(t1->key.n) - (int)(t2->key.n);
+  }
+}
+
+int32_t setPointTimeStamp(SLPPoint* point, SStrToken tsToken) {
+  point->tsToken = tsToken;
+  return 0;
+}
+
+int32_t parsePointTime(SLPPoint* point) {
+  if (point->tsToken.n <= 0) {
+    point->ts = taosGetTimestampNs();
+  } else {
+    char* endptr = NULL;
+    point->ts = strtoll(point->tsToken.z, &endptr, 10);
+  }
+  return 0;
+}
+
+int32_t tscParseLine(SStrToken line, SLPPoint* point) {
+  int32_t pos = 0;
+
+  int32_t start = 0;
+  int32_t err = scanToCommaOrSpace(line, start, &pos, LP_MEASUREMENT);
+  if (err != 0) {
+    tscError("a");
+    return err;
+  }
+
+  SStrToken measurement = {.z = line.z+start, .n = pos-start};
+  setPointMeasurement(point, measurement);
+  point->tags = taosArrayInit(64, sizeof(SLPItem));
+  start = pos + 1;
+  while (line.z[start] == ',') {
+    SLPItem item;
+
+    err = scanToEqual(line, start, &pos);
+    if (err != 0) {
+      tscError("b");
+      goto error;
+    }
+
+    SStrToken tagKey = {.z = line.z + start, .n = pos-start};
+    setItemKey(&item, tagKey, LP_TAG_KEY);
+
+    start = pos + 1;
+    err = scanToCommaOrSpace(line, start, &pos, LP_TAG_VALUE);
+    if (err != 0) {
+      tscError("c");
+      goto error;
+    }
+
+    SStrToken tagValue = {.z = line.z + start, .n = pos-start};
+    setItemValue(&item, tagValue, LP_TAG_VALUE);
+
+    parseItemValue(&item, LP_ITEM_TAG);
+    taosArrayPush(point->tags, &item);
+
+    start = pos + 1;
+  }
+
+  taosArraySort(point->tags, compareLPItemKey);
+
+  point->fields = taosArrayInit(64, sizeof(SLPItem));
+  do {
+    SLPItem item;
+    err = scanToEqual(line, start, &pos);
+    if (err != 0) {
+      goto error;
+    }
+    SStrToken fieldKey = {.z = line.z + start, .n = pos- start};
+    setItemKey(&item, fieldKey, LP_FIELD_KEY);
+
+    start = pos + 1;
+    err = scanToCommaOrSpace(line, start, &pos, LP_FIELD_VALUE);
+    if (err != 0) {
+      goto error;
+    }
+    SStrToken fieldValue = {.z = line.z + start, .n = pos - start};
+    setItemValue(&item, fieldValue, LP_TAG_VALUE);
+
+    parseItemValue(&item, LP_ITEM_FIELD);
+    taosArrayPush(point->fields, &item);
+
+    start = pos + 1;
+  } while (line.z[pos] == ',');
+
+  taosArraySort(point->fields, compareLPItemKey);
+
+  SStrToken tsToken = {.z = line.z+start, .n = line.n-start};
+  setPointTimeStamp(point, tsToken);
+  parsePointTime(point);
+
+  goto done;
+
+error:
+  // free array
+  return err;
+done:
+  return 0;
+}
+
+
+int32_t tscParseLines(char* lines[], int numLines, SArray* points, SArray* failedLines) {
+  for (int32_t i = 0; i < numLines; ++i) {
+    SStrToken tkLine = {.z = lines[i], .n = strlen(lines[i])+1};
+    SLPPoint point;
+    tscParseLine(tkLine, &point);
+    taosArrayPush(points, &point);
+  }
+  return 0;
+}
+
+TAOS_RES* taos_insert_by_lines(TAOS* taos, char* lines[], int numLines) {
+  SArray* points = taosArrayInit(numLines, sizeof(SLPPoint));
+  tscParseLines(lines, numLines, points, NULL);
+
+
+  return NULL;
+}
+//=================================================================================================
+
+typedef struct {
+  char* key;
+  uint8_t type;
+  int16_t length;
+  char* value;
+} TAOS_SML_KV;
+
+typedef struct {
+  char* stableName;
+
+  char* childTableName;
+  TAOS_SML_KV* tags;
+  int tagNum;
+
+  // first kv must be timestamp
+  TAOS_SML_KV* fields;
+  int fieldNum;
+
+} TAOS_SML_DATA_POINT;
+
+typedef struct  {
+  char sTableName[TSDB_TABLE_NAME_LEN];
+  SHashObj* tagHash;
+  SHashObj* fieldHash;
+  SArray* tags; //SArray<SSchema>
+  SArray* fields; //SArray<TAOS_SFIELD>
+} SSmlSTableSchema;
+
+
+int compareSmlColKv(const void* p1, const void* p2) {
+  TAOS_SML_KV* kv1 = (TAOS_SML_KV*)p1;
+  TAOS_SML_KV* kv2 = (TAOS_SML_KV*)p2;
+  int kvLen1 = (int)strlen(kv1->key);
+  int kvLen2 = (int)strlen(kv2->key);
+  int res = strncasecmp(kv1->key, kv2->key, MIN(kvLen1, kvLen2));
+  if (res != 0) {
+    return res;
+  } else {
+    return kvLen1-kvLen2;
+  }
+}
+
+int32_t getChildTableName(TAOS_SML_DATA_POINT* point, char* tableName, int* tableNameLen) {
+    qsort(point->tags, point->tagNum, sizeof(TAOS_SML_KV), compareSmlColKv);
+
+    SStringBuilder sb; memset(&sb, 0, sizeof(sb));
+    taosStringBuilderAppendString(&sb, point->stableName);
+    for (int j = 0; j < point->tagNum; ++j) {
+      TAOS_SML_KV* tagKv = point->tags + j;
+      taosStringBuilderAppendChar(&sb, ',');
+      taosStringBuilderAppendString(&sb, tagKv->key);
+      taosStringBuilderAppendChar(&sb, '=');
+      taosStringBuilderAppend(&sb, tagKv->value, tagKv->length);
+    }
+    size_t len = 0;
+    char* keyJoined = taosStringBuilderGetResult(&sb, &len);
+    MD5_CTX context;
+    MD5Init(&context);
+    MD5Update(&context, (uint8_t *)keyJoined, (uint32_t)len);
+    MD5Final(&context);
+    *tableNameLen = snprintf(tableName, *tableNameLen,
+             "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", context.digest[0],
+             context.digest[1], context.digest[2], context.digest[3], context.digest[4], context.digest[5], context.digest[6],
+             context.digest[7], context.digest[8], context.digest[9], context.digest[10], context.digest[11],
+             context.digest[12], context.digest[13], context.digest[14], context.digest[15]);
+    return 0;
+}
+
+int32_t loadTableMeta(TAOS* taos, char* tableName, SSmlSTableSchema* schema) {
+  int32_t code = 0;
+
+  STscObj *pObj = (STscObj *)taos;
+  if (pObj == NULL || pObj->signature != pObj) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return TSDB_CODE_TSC_DISCONNECTED;
+  }
+
+  char sql[256];
+  snprintf(sql, 256, "describe %s", tableName);
+  TAOS_RES* res = taos_query(taos, sql);
+  code = taos_errno(res);
+  if (code != 0) {
+    taos_free_result(res);
+    return code;
+  }
+  taos_free_result(res);
+
+  SSqlObj* pSql = calloc(1, sizeof(SSqlObj));
+  pSql->pTscObj = taos;
+  pSql->signature = pSql;
+  pSql->fp = NULL;
+
+  SStrToken tableToken = {.z=tableName, .n=strlen(tableName), .type=TK_ID};
+  tGetToken(tableName, &tableToken.type);
+  // Check if the table name available or not
+  if (tscValidateName(&tableToken) != TSDB_CODE_SUCCESS) {
+    code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
+    sprintf(pSql->cmd.payload, "table name is invalid");
+    return code;
+  }
+
+  SName sname = {0};
+  if ((code = tscSetTableFullName(&sname, &tableToken, pSql)) != TSDB_CODE_SUCCESS) {
+    return code;
+  }
+
+  char  fullTableName[TSDB_TABLE_FNAME_LEN] = {0};
+  memset(fullTableName, 0, tListLen(fullTableName));
+  tNameExtractFullName(&sname, fullTableName);
+
+  if (code != TSDB_CODE_SUCCESS) {
+    tscFreeSqlObj(pSql);
+    return code;
+  }
+
+  tscFreeSqlObj(pSql);
+
+
+  uint32_t size = tscGetTableMetaMaxSize();
+  STableMeta* tableMeta = calloc(1, size);
+  taosHashGetClone(tscTableMetaInfo, fullTableName, strlen(fullTableName), NULL, tableMeta, -1);
+
+  tstrncpy(schema->sTableName, tableName, strlen(tableName));
+  for (int i=0; i<tableMeta->tableInfo.numOfColumns; ++i) {
+    SSchema field;
+    tstrncpy(field.name, tableMeta->schema[i].name, strlen(tableMeta->schema[i].name));
+    field.type = tableMeta->schema[i].type;
+    field.bytes = tableMeta->schema[i].bytes;
+    SSchema* pField = taosArrayPush(schema->fields, &field);
+    taosHashPut(schema->fieldHash, field.name, strlen(field.name), &pField, POINTER_BYTES);
+  }
+
+  for (int i=0; i<tableMeta->tableInfo.numOfTags; ++i) {
+    int j = i + tableMeta->tableInfo.numOfColumns;
+    SSchema field;
+    tstrncpy(field.name, tableMeta->schema[j].name, strlen(tableMeta->schema[j].name));
+    field.type = tableMeta->schema[j].type;
+    field.bytes = tableMeta->schema[j].bytes;
+    SSchema* pField = taosArrayPush(schema->tags, &field);
+    taosHashPut(schema->tagHash, field.name, strlen(field.name), &pField, POINTER_BYTES);
+  }
+
+  return code;
+
+}
+
+typedef enum {
+  SCHEMA_ACTION_CREATE_STABLE,
+  SCHEMA_ACTION_ADD_COLUMN,
+  SCHEMA_ACTION_ADD_TAG,
+  SCHEMA_ACTION_CHANGE_COLUMN_SIZE,
+  SCHEMA_ACTION_CHANGE_TAG_SIZE,
+  SCHEMA_ACTION_CREATE_CTABLE
+} ESchemaAction;
+
+typedef struct {
+  char sTableName[TSDB_TABLE_NAME_LEN];
+  SArray* tags; //SArray<SSchema>
+  SArray* fields; //SArray<SSchema>
+} SCreateSTableActionInfo;
+
+typedef struct {
+  char sTableName[TSDB_TABLE_NAME_LEN];
+  SSchema* field;
+} SAlterSTableActionInfo;
+
+typedef struct {
+  char sTableName[TSDB_TABLE_NAME_LEN];
+  char cTableName[TSDB_TABLE_NAME_LEN];
+  TAOS_SML_KV* tags;
+  int tagNum;
+} SCreateCTableActionInfo;
+
+typedef struct {
+  ESchemaAction action;
+  union {
+    SCreateSTableActionInfo createSTable;
+    SAlterSTableActionInfo alterSTable;
+    SCreateCTableActionInfo createCTable;
+  };
+} SSchemaAction;
+
+int32_t getFieldBytesFromSmlKv(TAOS_SML_KV* kv, int32_t* bytes) {
+  if (!IS_VAR_DATA_TYPE(kv->type)) {
+    *bytes = tDataTypes[kv->type].bytes;
+  } else {
+    if (kv->type == TSDB_DATA_TYPE_NCHAR) {
+      char* ucs = malloc(kv->length * TSDB_NCHAR_SIZE + 1);
+      int32_t bytesNeeded = 0;
+      //todo check conversion succeed
+      taosMbsToUcs4(kv->value, kv->length, ucs, kv->length * TSDB_NCHAR_SIZE, &bytesNeeded);
+      free(ucs);
+      *bytes =  bytesNeeded + VARSTR_HEADER_SIZE;
+
+    } else if (kv->type == TSDB_DATA_TYPE_BINARY) {
+      *bytes = kv->length + VARSTR_HEADER_SIZE;
+    }
+  }
+  return 0;
+}
+
+int32_t addTaosFieldToHashAndArray(TAOS_SML_KV* smlKv, SHashObj* hash, SArray* array) {
+  SSchema* pField = NULL;
+  SSchema** ppField = taosHashGet(hash, smlKv->key, strlen(smlKv->key));
+  if (ppField) {
+    pField = *ppField;
+
+    if (pField->type != smlKv->type) {
+      //TODO:
+      tscError("type mismatch");
+      return -1;
+    }
+
+    int32_t bytes = 0;
+    getFieldBytesFromSmlKv(smlKv, &bytes);
+    pField->bytes = MAX(pField->bytes, bytes);
+
+  } else {
+    SSchema field;
+    size_t tagKeyLen = strlen(smlKv->key);
+    strncpy(field.name, smlKv->key, tagKeyLen);
+    field.name[tagKeyLen] = '\0';
+    field.type = smlKv->type;
+
+    int32_t bytes = 0;
+    getFieldBytesFromSmlKv(smlKv, &bytes);
+    field.bytes = bytes;
+
+    pField = taosArrayPush(array, &field);
+    taosHashPut(hash, field.name, tagKeyLen, &pField, POINTER_BYTES);
+  }
+  return 0;
+}
+
+int32_t generateSchemaAction(SSchema* pointColField, SHashObj* dbAttrHash, bool isTag, char sTableName[],
+                                       SSchemaAction* action, bool* actionNeeded) {
+  SSchema** ppDbAttr = taosHashGet(dbAttrHash, pointColField->name, strlen(pointColField->name));
+  if (*ppDbAttr) {
+    SSchema* dbAttr = *ppDbAttr;
+    if (pointColField->type != dbAttr->type) {
+      //todo error
+      return -5;
+    }
+
+    if (IS_VAR_DATA_TYPE(pointColField->type) && (pointColField->bytes > dbAttr->bytes)) {
+      if (isTag) {
+        action->action = SCHEMA_ACTION_CHANGE_TAG_SIZE;
+      } else {
+        action->action = SCHEMA_ACTION_CHANGE_COLUMN_SIZE;
+      }
+      memset(&action->alterSTable, 0,  sizeof(SAlterSTableActionInfo));
+      memcpy(action->alterSTable.sTableName, sTableName, TSDB_TABLE_NAME_LEN);
+      action->alterSTable.field = pointColField;
+      *actionNeeded = true;
+    }
+  } else {
+    if (isTag) {
+      action->action = SCHEMA_ACTION_ADD_TAG;
+    } else {
+      action->action = SCHEMA_ACTION_ADD_COLUMN;
+    }
+    memset(&action->alterSTable, 0, sizeof(SAlterSTableActionInfo));
+    memcpy(action->alterSTable.sTableName, sTableName, TSDB_TABLE_NAME_LEN);
+    action->alterSTable.field = pointColField;
+    *actionNeeded = true;
+  }
+  return 0;
+}
+
+int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  SArray* stableArray = taosArrayInit(32, sizeof(SSmlSTableSchema)); // SArray<STableColumnsSchema>
+  SHashObj* sname2shema = taosHashInit(32,
+                                       taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+
+  for (int i = 0; i < numPoint; ++i) {
+    TAOS_SML_DATA_POINT* point = &points[i];
+    SSmlSTableSchema** ppStableSchema = taosHashGet(sname2shema, point->stableName, TSDB_TABLE_NAME_LEN);
+    SSmlSTableSchema* pStableSchema = NULL;
+    if (ppStableSchema) {
+      pStableSchema= *ppStableSchema;
+    } else {
+      SSmlSTableSchema schema;
+      size_t stableNameLen = strlen(point->stableName);
+      strncpy(schema.sTableName, point->stableName, stableNameLen);
+      schema.sTableName[stableNameLen] = '\0';
+      schema.fields = taosArrayInit(64, sizeof(SSchema));
+      schema.tags = taosArrayInit(8, sizeof(SSchema));
+      schema.tagHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+      schema.fieldHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+
+      pStableSchema = taosArrayPush(stableArray, &schema);
+      taosHashPut(sname2shema, schema.sTableName, stableNameLen, &pStableSchema, POINTER_BYTES);
+    }
+
+    for (int j = 0; j < point->tagNum; ++j) {
+      TAOS_SML_KV* tagKv = point->tags + j;
+      addTaosFieldToHashAndArray(tagKv, pStableSchema->tagHash, pStableSchema->tags);
+    }
+
+    for (int j = 0; j < point->fieldNum; ++j) {
+      TAOS_SML_KV* fieldKv = point->fields + j;
+      addTaosFieldToHashAndArray(fieldKv, pStableSchema->fieldHash, pStableSchema->fields);
+    }
+  }
+
+  SArray* schemaActions = taosArrayInit(32, sizeof(SSchemaAction));
+  size_t numStable = taosArrayGetSize(stableArray);
+  for (int i = 0; i < numStable; ++i) {
+    SSmlSTableSchema* pointSchema = taosArrayGet(stableArray, i);
+    SSmlSTableSchema  dbSchema = {0};
+    dbSchema.fields = taosArrayInit(64, sizeof(SSchema));
+    dbSchema.tags = taosArrayInit(8, sizeof(SSchema));
+    dbSchema.tagHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+    dbSchema.fieldHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+    code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
+    if (code == TSDB_CODE_MND_INVALID_TABLE_NAME) {
+      SSchemaAction schemaAction = {0};
+      schemaAction.action = SCHEMA_ACTION_CREATE_STABLE;
+      memset(&schemaAction.createSTable, 0, sizeof(SCreateSTableActionInfo));
+      memcpy(schemaAction.createSTable.sTableName, pointSchema->sTableName, TSDB_TABLE_NAME_LEN);
+      schemaAction.createSTable.tags = pointSchema->tags;
+      schemaAction.createSTable.fields = pointSchema->fields;
+      taosArrayPush(schemaActions, &schemaAction);
+    }else if (code == TSDB_CODE_SUCCESS) {
+      size_t pointTagSize = taosArrayGetSize(pointSchema->tags);
+      size_t pointFieldSize = taosArrayGetSize(pointSchema->fields);
+
+      SHashObj* dbTagHash = dbSchema.tagHash;
+      SHashObj* dbFieldHash = dbSchema.fieldHash;
+
+      for (int j = 0; j < pointTagSize; ++j) {
+        SSchema*            pointTag = taosArrayGet(pointSchema->tags, j);
+        SSchemaAction schemaAction = {0};
+        bool                   actionNeeded = false;
+        generateSchemaAction(pointTag, dbTagHash, true, pointSchema->sTableName, &schemaAction, &actionNeeded);
+        if (actionNeeded) {
+          taosArrayPush(schemaActions, &schemaAction);
+        }
+      }
+
+      for (int j = 0; j < pointFieldSize; ++j) {
+        SSchema*            pointCol = taosArrayGet(pointSchema->tags, j);
+        SSchemaAction schemaAction = {0};
+        bool                   actionNeeded = false;
+        generateSchemaAction(pointCol, dbFieldHash, false, pointSchema->sTableName, &schemaAction, &actionNeeded);
+        if (actionNeeded) {
+          taosArrayPush(schemaActions, &schemaAction);
+        }
+      }
+    } else {
+      return code;
+    }
+  }
+
+  return code;
+}
+
+
+int32_t buildColumnDescription(SSchema* field,
+                               char* buf, int32_t bufSize, int32_t* outBytes) {
+  uint8_t type = field->type;
+
+  if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {
+    int32_t bytes = field->bytes - VARSTR_HEADER_SIZE;
+    if (type == TSDB_DATA_TYPE_NCHAR) {
+      bytes =  bytes/TSDB_NCHAR_SIZE;
+    }
+    int out = snprintf(buf, bufSize,"%s %s(%d)",
+                       field->name,tDataTypes[field->type].name, bytes);
+    *outBytes = out;
+  } else {
+    int out = snprintf(buf, bufSize, "%s %s",
+                       field->name, tDataTypes[type].name);
+    *outBytes = out;
+  }
+
+  return 0;
+}
+
+int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
+  int32_t code = 0;
+  int32_t capacity = TSDB_MAX_BINARY_LEN;
+  int32_t outBytes = 0;
+  char *result = (char *)calloc(1, capacity);
+
+  switch (action->action) {
+    case SCHEMA_ACTION_ADD_COLUMN: {
+      int n = sprintf(result, "alter stable %s add column ", action->alterSTable.sTableName);
+      buildColumnDescription(action->alterSTable.field, result+n, capacity-n, &outBytes);
+      TAOS_RES* res = taos_query(taos, result); //TODO async doAsyncQuery
+      code = taos_errno(res);
+      break;
+    }
+    case SCHEMA_ACTION_ADD_TAG: {
+      int n = sprintf(result, "alter stable %s add tag ", action->alterSTable.sTableName);
+      buildColumnDescription(action->alterSTable.field,
+                             result+n, capacity-n, &outBytes);
+      TAOS_RES* res = taos_query(taos, result); //TODO async doAsyncQuery
+      code = taos_errno(res);
+      break;
+    }
+    case SCHEMA_ACTION_CHANGE_COLUMN_SIZE: {
+      int n = sprintf(result, "alter stable %s modify column ", action->alterSTable.sTableName);
+      buildColumnDescription(action->alterSTable.field, result+n,
+                             capacity-n, &outBytes);
+      TAOS_RES* res = taos_query(taos, result); //TODO async doAsyncQuery
+      code = taos_errno(res);
+    }
+    case SCHEMA_ACTION_CHANGE_TAG_SIZE: {
+      int n = sprintf(result, "alter stable %s modify tag ", action->alterSTable.sTableName);
+      buildColumnDescription(action->alterSTable.field, result+n,
+                             capacity-n, &outBytes);
+      TAOS_RES* res = taos_query(taos, result); //TODO async doAsyncQuery
+      code = taos_errno(res);
+      break;
+    }
+    case SCHEMA_ACTION_CREATE_STABLE: {
+      int n = sprintf(result, "create stable %s (", action->createSTable.sTableName);
+      char* pos = result + n; int freeBytes = capacity - n;
+      int numCols = taosArrayGetSize(action->createSTable.fields);
+      for (int32_t i = 0; i < numCols; ++i) {
+        SSchema* field = taosArrayGet(action->createSTable.fields, i);
+        buildColumnDescription(field, pos, freeBytes, &outBytes);
+        pos += outBytes; freeBytes -= outBytes;
+        *pos = ','; ++pos; --freeBytes;
+      }
+      --pos; ++freeBytes;
+      outBytes = snprintf(pos, freeBytes, ") tags (");
+      int numTags = taosArrayGetSize(action->createSTable.tags);
+      pos += outBytes; freeBytes -= outBytes;
+      for (int32_t i = 0; i < numTags; ++i) {
+        SSchema* field = taosArrayGet(action->createSTable.tags, i);
+        buildColumnDescription(field, pos, freeBytes, &outBytes);
+        pos += outBytes; freeBytes -= outBytes;
+        *pos = ','; ++pos; --freeBytes;
+      }
+      pos--; ++freeBytes;
+      outBytes = snprintf(pos, freeBytes, ")");
+      TAOS_RES* res = taos_query(taos, result);
+      code = taos_errno(res);
+      break;
+    }
+    case SCHEMA_ACTION_CREATE_CTABLE: {
+      
+      break;
+    }
+    default:
+      break;
+  }
+  free(result);
+  return code;
+}
+
+//todo: table/column length check
+//todo: type check
+//todo: taosmbs2ucs4 check

From d5ab8d7ced3a76013cfc64419ec3bf970d3a822b Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Fri, 9 Jul 2021 19:37:15 +0800
Subject: [PATCH 14/70] before taos_bind/taos_multi_bind generation

---
 src/client/src/tscParseLineProtocol.c | 99 +++++++++++++++++++++++++--
 1 file changed, 95 insertions(+), 4 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index 79e8955f9a..10d2429b5e 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -277,6 +277,9 @@ typedef struct {
   uint8_t type;
   int16_t length;
   char* value;
+
+  //===================================
+  SSchema* fieldSchema;
 } TAOS_SML_KV;
 
 typedef struct {
@@ -415,7 +418,6 @@ int32_t loadTableMeta(TAOS* taos, char* tableName, SSmlSTableSchema* schema) {
   }
 
   return code;
-
 }
 
 typedef enum {
@@ -465,7 +467,6 @@ int32_t getFieldBytesFromSmlKv(TAOS_SML_KV* kv, int32_t* bytes) {
       taosMbsToUcs4(kv->value, kv->length, ucs, kv->length * TSDB_NCHAR_SIZE, &bytesNeeded);
       free(ucs);
       *bytes =  bytesNeeded + VARSTR_HEADER_SIZE;
-
     } else if (kv->type == TSDB_DATA_TYPE_BINARY) {
       *bytes = kv->length + VARSTR_HEADER_SIZE;
     }
@@ -503,6 +504,9 @@ int32_t addTaosFieldToHashAndArray(TAOS_SML_KV* smlKv, SHashObj* hash, SArray* a
     pField = taosArrayPush(array, &field);
     taosHashPut(hash, field.name, tagKeyLen, &pField, POINTER_BYTES);
   }
+
+  smlKv->fieldSchema = pField;
+
   return 0;
 }
 
@@ -700,9 +704,11 @@ int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
         *pos = ','; ++pos; --freeBytes;
       }
       --pos; ++freeBytes;
+
       outBytes = snprintf(pos, freeBytes, ") tags (");
-      int numTags = taosArrayGetSize(action->createSTable.tags);
       pos += outBytes; freeBytes -= outBytes;
+
+      int numTags = taosArrayGetSize(action->createSTable.tags);
       for (int32_t i = 0; i < numTags; ++i) {
         SSchema* field = taosArrayGet(action->createSTable.tags, i);
         buildColumnDescription(field, pos, freeBytes, &outBytes);
@@ -716,7 +722,43 @@ int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
       break;
     }
     case SCHEMA_ACTION_CREATE_CTABLE: {
-      
+//      SCreateCTableActionInfo* pInfo = &action->createCTable;
+//      SArray* bindParams = taosArrayInit(2 + 2 * pInfo->tagNum, sizeof(TAOS_BIND));
+//      outBytes = sprintf(result, "create table ? using ?(");
+//      char* pos = result + outBytes; int32_t freeBytes = capacity-outBytes;
+//      uintptr_t lenSTableName = strlen(pInfo->sTableName);
+//      uintptr_t lenCTableName = strlen(pInfo->cTableName);
+//      TAOS_BIND tbCTableName = {.is_null = NULL, .buffer_type = TSDB_DATA_TYPE_BINARY,
+//                                .buffer = pInfo->cTableName, .length = &lenCTableName};
+//      TAOS_BIND tbSTableName = {.is_null = NULL, .buffer_type = TSDB_DATA_TYPE_BINARY,
+//                                .buffer = pInfo->sTableName, .length = &lenSTableName};
+//      taosArrayPush(bindParams, &tbCTableName);
+//      taosArrayPush(bindParams, &tbSTableName);
+//      for (int32_t i = 0; i < pInfo->tagNum; ++i) {
+//        outBytes = snprintf(pos, freeBytes, "?,");
+//
+//        TAOS_SML_KV* tagKv = pInfo->tags + i;
+//        TAOS_BIND tbTag = {.is_null = NULL, .buffer_type = TSDB_DATA_TYPE_BINARY,
+//                            .buffer = tagKv->key, .length = };
+//        pos += outBytes; freeBytes -= outBytes;
+//      }
+//      --pos; ++freeBytes;
+//
+//      outBytes = snprintf(pos, freeBytes, ") tags (");
+//      pos += outBytes; freeBytes -= outBytes;
+//      for (int32_t i = 0; i < pInfo->tagNum; ++i) {
+//        TAOS_SML_KV* tagKv = pInfo->tags + i;
+//        outBytes = snprintf(pos, freeBytes, "?,");
+//        pos += outBytes; freeBytes -= outBytes;
+//      }
+//      pos--; ++freeBytes;
+//      outBytes = snprintf(pos, freeBytes, ")");
+//
+//      TAOS_STMT* stmt = taos_stmt_init(taos);
+//      taos_stmt_prepare(stmt, result, strlen(result));
+//
+//
+//      taos_stmt_bind_param(stmt, (TAOS_BIND*)bindParams);
       break;
     }
     default:
@@ -726,6 +768,55 @@ int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
   return code;
 }
 
+int32_t transformIntoPreparedStatement(SArray* points) {
+  size_t numPoints = taosArrayGetSize(points);
+
+//  SHashObj* tag2bind = taosHashInit(32, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+//  SHashObj* field2multiBind = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+
+  for (int32_t i = 0; i < numPoints; ++i) {
+    TAOS_SML_DATA_POINT * point = taosArrayGet(points, i);
+    char tableKey[256];
+    snprintf(tableKey, 256, "%s.%s", point->stableName, point->childTableName);
+
+  }
+  return 0;
+}
+
+int32_t insertBatch(TAOS* taos, const char* sTableName, char* cTableName, SSchema* tagsSchema, int numTags, TAOS_BIND* tagBind,
+                  SSchema* colsSchema, int numCols, TAOS_MULTI_BIND* colBind) {
+  TAOS_STMT* stmt = taos_stmt_init(taos);
+
+  char result[TSDB_MAX_BINARY_LEN] = {0};
+  sprintf(result, "insert into ? using %s(", sTableName);
+  for (int i = 0; i < numTags; ++i) {
+    snprintf(result+strlen(result), TSDB_MAX_BINARY_LEN-strlen(result), "%s,", tagsSchema[i].name);
+  }
+  snprintf(result + strlen(result)-1, TSDB_MAX_BINARY_LEN-strlen(result)+1, ") tags (");
+
+  for (int i = 0; i < numTags; ++i) {
+    snprintf(result+strlen(result), TSDB_MAX_BINARY_LEN-strlen(result), "?,");
+  }
+  snprintf(result + strlen(result)-1, TSDB_MAX_BINARY_LEN-strlen(result)+1, ") (");
+
+  for (int i = 0; i < numCols; ++i) {
+    snprintf(result+strlen(result), TSDB_MAX_BINARY_LEN-strlen(result), "%s,", colsSchema[i].name);
+  }
+  snprintf(result + strlen(result)-1, TSDB_MAX_BINARY_LEN-strlen(result)+1, ") values (");
+
+  for (int i = 0; i < numCols; ++i) {
+    snprintf(result+strlen(result), TSDB_MAX_BINARY_LEN-strlen(result), "?,");
+  }
+  snprintf(result + strlen(result)-1, TSDB_MAX_BINARY_LEN-strlen(result)+1, ")");
+
+  int32_t code = 0;
+  code = taos_stmt_prepare(stmt, result, strlen(result));
+
+  code = taos_stmt_set_tbname_tags(stmt, cTableName, tagBind);
+  code = taos_stmt_bind_param_batch(stmt, colBind);
+  code = taos_stmt_execute(stmt);
+  return code;
+}
 //todo: table/column length check
 //todo: type check
 //todo: taosmbs2ucs4 check

From 12e8b038d176b8c0ded55fced17185d531c61cac Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Sat, 10 Jul 2021 16:18:38 +0800
Subject: [PATCH 15/70] before debugging

---
 src/client/src/tscParseLineProtocol.c | 393 ++++++++++++++------------
 1 file changed, 211 insertions(+), 182 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index 10d2429b5e..2738fe6f7a 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -272,6 +272,14 @@ TAOS_RES* taos_insert_by_lines(TAOS* taos, char* lines[], int numLines) {
 }
 //=================================================================================================
 
+typedef struct  {
+  char sTableName[TSDB_TABLE_NAME_LEN];
+  SHashObj* tagHash;
+  SHashObj* fieldHash;
+  SArray* tags; //SArray<SSchema>
+  SArray* fields; //SArray<SSchema>
+} SSmlSTableSchema;
+
 typedef struct {
   char* key;
   uint8_t type;
@@ -279,7 +287,7 @@ typedef struct {
   char* value;
 
   //===================================
-  SSchema* fieldSchema;
+  SSchema* schema;
 } TAOS_SML_KV;
 
 typedef struct {
@@ -293,17 +301,10 @@ typedef struct {
   TAOS_SML_KV* fields;
   int fieldNum;
 
+  //================================
+  SSmlSTableSchema* schema;
 } TAOS_SML_DATA_POINT;
 
-typedef struct  {
-  char sTableName[TSDB_TABLE_NAME_LEN];
-  SHashObj* tagHash;
-  SHashObj* fieldHash;
-  SArray* tags; //SArray<SSchema>
-  SArray* fields; //SArray<TAOS_SFIELD>
-} SSmlSTableSchema;
-
-
 int compareSmlColKv(const void* p1, const void* p2) {
   TAOS_SML_KV* kv1 = (TAOS_SML_KV*)p1;
   TAOS_SML_KV* kv2 = (TAOS_SML_KV*)p2;
@@ -426,7 +427,6 @@ typedef enum {
   SCHEMA_ACTION_ADD_TAG,
   SCHEMA_ACTION_CHANGE_COLUMN_SIZE,
   SCHEMA_ACTION_CHANGE_TAG_SIZE,
-  SCHEMA_ACTION_CREATE_CTABLE
 } ESchemaAction;
 
 typedef struct {
@@ -440,19 +440,11 @@ typedef struct {
   SSchema* field;
 } SAlterSTableActionInfo;
 
-typedef struct {
-  char sTableName[TSDB_TABLE_NAME_LEN];
-  char cTableName[TSDB_TABLE_NAME_LEN];
-  TAOS_SML_KV* tags;
-  int tagNum;
-} SCreateCTableActionInfo;
-
 typedef struct {
   ESchemaAction action;
   union {
     SCreateSTableActionInfo createSTable;
     SAlterSTableActionInfo alterSTable;
-    SCreateCTableActionInfo createCTable;
   };
 } SSchemaAction;
 
@@ -505,7 +497,7 @@ int32_t addTaosFieldToHashAndArray(TAOS_SML_KV* smlKv, SHashObj* hash, SArray* a
     taosHashPut(hash, field.name, tagKeyLen, &pField, POINTER_BYTES);
   }
 
-  smlKv->fieldSchema = pField;
+  smlKv->schema = pField;
 
   return 0;
 }
@@ -545,96 +537,6 @@ int32_t generateSchemaAction(SSchema* pointColField, SHashObj* dbAttrHash, bool
   return 0;
 }
 
-int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
-  int32_t code = TSDB_CODE_SUCCESS;
-  SArray* stableArray = taosArrayInit(32, sizeof(SSmlSTableSchema)); // SArray<STableColumnsSchema>
-  SHashObj* sname2shema = taosHashInit(32,
-                                       taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
-
-  for (int i = 0; i < numPoint; ++i) {
-    TAOS_SML_DATA_POINT* point = &points[i];
-    SSmlSTableSchema** ppStableSchema = taosHashGet(sname2shema, point->stableName, TSDB_TABLE_NAME_LEN);
-    SSmlSTableSchema* pStableSchema = NULL;
-    if (ppStableSchema) {
-      pStableSchema= *ppStableSchema;
-    } else {
-      SSmlSTableSchema schema;
-      size_t stableNameLen = strlen(point->stableName);
-      strncpy(schema.sTableName, point->stableName, stableNameLen);
-      schema.sTableName[stableNameLen] = '\0';
-      schema.fields = taosArrayInit(64, sizeof(SSchema));
-      schema.tags = taosArrayInit(8, sizeof(SSchema));
-      schema.tagHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
-      schema.fieldHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
-
-      pStableSchema = taosArrayPush(stableArray, &schema);
-      taosHashPut(sname2shema, schema.sTableName, stableNameLen, &pStableSchema, POINTER_BYTES);
-    }
-
-    for (int j = 0; j < point->tagNum; ++j) {
-      TAOS_SML_KV* tagKv = point->tags + j;
-      addTaosFieldToHashAndArray(tagKv, pStableSchema->tagHash, pStableSchema->tags);
-    }
-
-    for (int j = 0; j < point->fieldNum; ++j) {
-      TAOS_SML_KV* fieldKv = point->fields + j;
-      addTaosFieldToHashAndArray(fieldKv, pStableSchema->fieldHash, pStableSchema->fields);
-    }
-  }
-
-  SArray* schemaActions = taosArrayInit(32, sizeof(SSchemaAction));
-  size_t numStable = taosArrayGetSize(stableArray);
-  for (int i = 0; i < numStable; ++i) {
-    SSmlSTableSchema* pointSchema = taosArrayGet(stableArray, i);
-    SSmlSTableSchema  dbSchema = {0};
-    dbSchema.fields = taosArrayInit(64, sizeof(SSchema));
-    dbSchema.tags = taosArrayInit(8, sizeof(SSchema));
-    dbSchema.tagHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
-    dbSchema.fieldHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
-    code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
-    if (code == TSDB_CODE_MND_INVALID_TABLE_NAME) {
-      SSchemaAction schemaAction = {0};
-      schemaAction.action = SCHEMA_ACTION_CREATE_STABLE;
-      memset(&schemaAction.createSTable, 0, sizeof(SCreateSTableActionInfo));
-      memcpy(schemaAction.createSTable.sTableName, pointSchema->sTableName, TSDB_TABLE_NAME_LEN);
-      schemaAction.createSTable.tags = pointSchema->tags;
-      schemaAction.createSTable.fields = pointSchema->fields;
-      taosArrayPush(schemaActions, &schemaAction);
-    }else if (code == TSDB_CODE_SUCCESS) {
-      size_t pointTagSize = taosArrayGetSize(pointSchema->tags);
-      size_t pointFieldSize = taosArrayGetSize(pointSchema->fields);
-
-      SHashObj* dbTagHash = dbSchema.tagHash;
-      SHashObj* dbFieldHash = dbSchema.fieldHash;
-
-      for (int j = 0; j < pointTagSize; ++j) {
-        SSchema*            pointTag = taosArrayGet(pointSchema->tags, j);
-        SSchemaAction schemaAction = {0};
-        bool                   actionNeeded = false;
-        generateSchemaAction(pointTag, dbTagHash, true, pointSchema->sTableName, &schemaAction, &actionNeeded);
-        if (actionNeeded) {
-          taosArrayPush(schemaActions, &schemaAction);
-        }
-      }
-
-      for (int j = 0; j < pointFieldSize; ++j) {
-        SSchema*            pointCol = taosArrayGet(pointSchema->tags, j);
-        SSchemaAction schemaAction = {0};
-        bool                   actionNeeded = false;
-        generateSchemaAction(pointCol, dbFieldHash, false, pointSchema->sTableName, &schemaAction, &actionNeeded);
-        if (actionNeeded) {
-          taosArrayPush(schemaActions, &schemaAction);
-        }
-      }
-    } else {
-      return code;
-    }
-  }
-
-  return code;
-}
-
-
 int32_t buildColumnDescription(SSchema* field,
                                char* buf, int32_t bufSize, int32_t* outBytes) {
   uint8_t type = field->type;
@@ -721,46 +623,7 @@ int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
       code = taos_errno(res);
       break;
     }
-    case SCHEMA_ACTION_CREATE_CTABLE: {
-//      SCreateCTableActionInfo* pInfo = &action->createCTable;
-//      SArray* bindParams = taosArrayInit(2 + 2 * pInfo->tagNum, sizeof(TAOS_BIND));
-//      outBytes = sprintf(result, "create table ? using ?(");
-//      char* pos = result + outBytes; int32_t freeBytes = capacity-outBytes;
-//      uintptr_t lenSTableName = strlen(pInfo->sTableName);
-//      uintptr_t lenCTableName = strlen(pInfo->cTableName);
-//      TAOS_BIND tbCTableName = {.is_null = NULL, .buffer_type = TSDB_DATA_TYPE_BINARY,
-//                                .buffer = pInfo->cTableName, .length = &lenCTableName};
-//      TAOS_BIND tbSTableName = {.is_null = NULL, .buffer_type = TSDB_DATA_TYPE_BINARY,
-//                                .buffer = pInfo->sTableName, .length = &lenSTableName};
-//      taosArrayPush(bindParams, &tbCTableName);
-//      taosArrayPush(bindParams, &tbSTableName);
-//      for (int32_t i = 0; i < pInfo->tagNum; ++i) {
-//        outBytes = snprintf(pos, freeBytes, "?,");
-//
-//        TAOS_SML_KV* tagKv = pInfo->tags + i;
-//        TAOS_BIND tbTag = {.is_null = NULL, .buffer_type = TSDB_DATA_TYPE_BINARY,
-//                            .buffer = tagKv->key, .length = };
-//        pos += outBytes; freeBytes -= outBytes;
-//      }
-//      --pos; ++freeBytes;
-//
-//      outBytes = snprintf(pos, freeBytes, ") tags (");
-//      pos += outBytes; freeBytes -= outBytes;
-//      for (int32_t i = 0; i < pInfo->tagNum; ++i) {
-//        TAOS_SML_KV* tagKv = pInfo->tags + i;
-//        outBytes = snprintf(pos, freeBytes, "?,");
-//        pos += outBytes; freeBytes -= outBytes;
-//      }
-//      pos--; ++freeBytes;
-//      outBytes = snprintf(pos, freeBytes, ")");
-//
-//      TAOS_STMT* stmt = taos_stmt_init(taos);
-//      taos_stmt_prepare(stmt, result, strlen(result));
-//
-//
-//      taos_stmt_bind_param(stmt, (TAOS_BIND*)bindParams);
-      break;
-    }
+
     default:
       break;
   }
@@ -768,55 +631,221 @@ int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
   return code;
 }
 
-int32_t transformIntoPreparedStatement(SArray* points) {
-  size_t numPoints = taosArrayGetSize(points);
+int32_t getPreparedSQL(const char* sTableName, SArray* tagsSchema, SArray* colsSchema, char* result, int16_t freeBytes) {
+  size_t numTags = taosArrayGetSize(tagsSchema);
+  size_t numCols = taosArrayGetSize(colsSchema);
+  sprintf(result, "insert into ? using %s(", sTableName);
+  for (int i = 0; i < numTags; ++i) {
+    SSchema* tagSchema = taosArrayGet(tagsSchema, i);
+    snprintf(result+strlen(result), freeBytes-strlen(result), "%s,", tagSchema->name);
+  }
+  snprintf(result + strlen(result)-1, freeBytes-strlen(result)+1, ") tags (");
 
-//  SHashObj* tag2bind = taosHashInit(32, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
-//  SHashObj* field2multiBind = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+  for (int i = 0; i < numTags; ++i) {
+    snprintf(result+strlen(result), freeBytes-strlen(result), "?,");
+  }
+  snprintf(result + strlen(result)-1, freeBytes-strlen(result)+1, ") (");
 
+  for (int i = 0; i < numCols; ++i) {
+    SSchema* colSchema = taosArrayGet(colsSchema, i);
+    snprintf(result+strlen(result), freeBytes-strlen(result), "%s,", colSchema->name);
+  }
+  snprintf(result + strlen(result)-1, freeBytes-strlen(result)+1, ") values (");
+
+  for (int i = 0; i < numCols; ++i) {
+    snprintf(result+strlen(result), freeBytes-strlen(result), "?,");
+  }
+  snprintf(result + strlen(result)-1, freeBytes-strlen(result)+1, ")");
+  return 0;
+}
+
+int32_t insertBatch(TAOS* taos, char* sql, char* cTableName, SArray* tagsBind, SArray* rowsBind) {
+  TAOS_STMT* stmt = taos_stmt_init(taos);
+  taos_stmt_prepare(stmt, sql, strlen(sql));
+
+  taos_stmt_set_tbname_tags(stmt, cTableName, TARRAY_GET_START(tagsBind));
+  size_t rows = taosArrayGetSize(rowsBind);
+  for (int32_t i = 0; i < rows; ++i) {
+    TAOS_BIND* colBind = taosArrayGetP(rowsBind, i);
+    taos_stmt_bind_param(stmt, colBind);
+    taos_stmt_add_batch(stmt);
+  }
+
+  taos_stmt_execute(stmt);
+  TAOS_RES* res = taos_stmt_use_result(stmt);
+  return taos_errno(res);
+}
+
+int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints) {
+  SHashObj* cname2points = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
   for (int32_t i = 0; i < numPoints; ++i) {
-    TAOS_SML_DATA_POINT * point = taosArrayGet(points, i);
-    char tableKey[256];
-    snprintf(tableKey, 256, "%s.%s", point->stableName, point->childTableName);
+    TAOS_SML_DATA_POINT * point = points + i;
+    if (!point->childTableName) {
+      char childTableName[TSDB_TABLE_NAME_LEN];
+      int32_t tableNameLen;
+      getChildTableName(point, childTableName, &tableNameLen);
+      point->childTableName = calloc(1, tableNameLen+1);
+      strncpy(point->childTableName, childTableName, tableNameLen);
+      point->childTableName[tableNameLen] = '\0';
+    }
+    SArray* cTablePoints = NULL;
+    SArray** pCTablePoints = taosHashGet(cname2points, point->childTableName, strlen(point->childTableName));
+    if (pCTablePoints) {
+      cTablePoints = *pCTablePoints;
+    } else {
+      cTablePoints = taosArrayInit(64, sizeof(point));
+      taosHashPut(cname2points, point->childTableName, strlen(point->childTableName), &cTablePoints, POINTER_BYTES);
+    }
+    taosArrayPush(cTablePoints, point);
+  }
 
+  SArray** pCTablePoints = taosHashIterate(cname2points, NULL);
+  while (pCTablePoints) {
+    SArray* cTablePoints = *pCTablePoints;
+    TAOS_SML_DATA_POINT * point = taosArrayGet(cTablePoints, 0);
+    int32_t numTags = taosArrayGetSize(point->schema->tags);
+    int32_t numCols = taosArrayGetSize(point->schema->fields);
+    char* stableName = point->stableName;
+    char* ctableName = point->childTableName;
+    char sql[TSDB_MAX_BINARY_LEN];
+    getPreparedSQL(stableName, point->schema->tags, point->schema->fields, sql, TSDB_MAX_BINARY_LEN);
+
+    size_t rows = taosArrayGetSize(cTablePoints);
+    SArray* rowsBind = taosArrayInit(rows, POINTER_BYTES);
+    SArray* tagBinds = taosArrayInit(numTags, sizeof(TAOS_BIND));
+
+    for (int i = 0; i < rows; ++i) {
+      point = taosArrayGet(cTablePoints, i);
+
+      taosArraySetSize(tagBinds, numTags);
+      for (int j = 0; j < point->tagNum; ++j) {
+        TAOS_SML_KV* kv =  point->tags + j;
+        int32_t idx = TARRAY_ELEM_IDX(point->schema->tags, kv->schema);
+        TAOS_BIND* bind = taosArrayGet(tagBinds, idx);
+        bind->buffer_type = kv->type;
+        bind->length = (uintptr_t*)&kv->length;
+        bind->buffer = kv->value;
+      }
+
+      SArray* colBinds = taosArrayInit(numCols, sizeof(TAOS_BIND));
+      taosArraySetSize(colBinds, numCols);
+      for (int j = 0; j<point->fieldNum; ++j) {
+        TAOS_SML_KV* kv = point->fields + j;
+        int32_t idx = TARRAY_ELEM_IDX(point->schema->fields, kv->schema);
+        TAOS_BIND* bind = taosArrayGet(colBinds, idx);
+        bind->buffer_type = kv->type;
+        bind->length = (uintptr_t*)&kv->length;
+        bind->buffer = kv->value;
+      }
+      taosArrayPush(rowsBind, &colBinds);
+    }
+
+    insertBatch(taos, sql, ctableName, tagBinds, rowsBind);
+
+    pCTablePoints = taosHashIterate(cname2points, pCTablePoints);
   }
   return 0;
 }
 
-int32_t insertBatch(TAOS* taos, const char* sTableName, char* cTableName, SSchema* tagsSchema, int numTags, TAOS_BIND* tagBind,
-                  SSchema* colsSchema, int numCols, TAOS_MULTI_BIND* colBind) {
-  TAOS_STMT* stmt = taos_stmt_init(taos);
 
-  char result[TSDB_MAX_BINARY_LEN] = {0};
-  sprintf(result, "insert into ? using %s(", sTableName);
-  for (int i = 0; i < numTags; ++i) {
-    snprintf(result+strlen(result), TSDB_MAX_BINARY_LEN-strlen(result), "%s,", tagsSchema[i].name);
+int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  SArray* stableArray = taosArrayInit(32, sizeof(SSmlSTableSchema)); // SArray<STableColumnsSchema>
+  SHashObj* sname2shema = taosHashInit(32,
+                                       taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+
+  for (int i = 0; i < numPoint; ++i) {
+    TAOS_SML_DATA_POINT* point = &points[i];
+    SSmlSTableSchema** ppStableSchema = taosHashGet(sname2shema, point->stableName, TSDB_TABLE_NAME_LEN);
+    SSmlSTableSchema* pStableSchema = NULL;
+    if (ppStableSchema) {
+      pStableSchema= *ppStableSchema;
+    } else {
+      SSmlSTableSchema schema;
+      size_t stableNameLen = strlen(point->stableName);
+      strncpy(schema.sTableName, point->stableName, stableNameLen);
+      schema.sTableName[stableNameLen] = '\0';
+      schema.fields = taosArrayInit(64, sizeof(SSchema));
+      schema.tags = taosArrayInit(8, sizeof(SSchema));
+      schema.tagHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+      schema.fieldHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+
+      pStableSchema = taosArrayPush(stableArray, &schema);
+      taosHashPut(sname2shema, schema.sTableName, stableNameLen, &pStableSchema, POINTER_BYTES);
+    }
+
+    for (int j = 0; j < point->tagNum; ++j) {
+      TAOS_SML_KV* tagKv = point->tags + j;
+      addTaosFieldToHashAndArray(tagKv, pStableSchema->tagHash, pStableSchema->tags);
+    }
+
+    for (int j = 0; j < point->fieldNum; ++j) {
+      TAOS_SML_KV* fieldKv = point->fields + j;
+      addTaosFieldToHashAndArray(fieldKv, pStableSchema->fieldHash, pStableSchema->fields);
+    }
+
+    point->schema = pStableSchema;
   }
-  snprintf(result + strlen(result)-1, TSDB_MAX_BINARY_LEN-strlen(result)+1, ") tags (");
 
-  for (int i = 0; i < numTags; ++i) {
-    snprintf(result+strlen(result), TSDB_MAX_BINARY_LEN-strlen(result), "?,");
+  SArray* schemaActions = taosArrayInit(32, sizeof(SSchemaAction));
+  size_t numStable = taosArrayGetSize(stableArray);
+  for (int i = 0; i < numStable; ++i) {
+    SSmlSTableSchema* pointSchema = taosArrayGet(stableArray, i);
+    SSmlSTableSchema  dbSchema = {0};
+    dbSchema.fields = taosArrayInit(64, sizeof(SSchema));
+    dbSchema.tags = taosArrayInit(8, sizeof(SSchema));
+    dbSchema.tagHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+    dbSchema.fieldHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+    code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
+    if (code == TSDB_CODE_MND_INVALID_TABLE_NAME) {
+      SSchemaAction schemaAction = {0};
+      schemaAction.action = SCHEMA_ACTION_CREATE_STABLE;
+      memset(&schemaAction.createSTable, 0, sizeof(SCreateSTableActionInfo));
+      memcpy(schemaAction.createSTable.sTableName, pointSchema->sTableName, TSDB_TABLE_NAME_LEN);
+      schemaAction.createSTable.tags = pointSchema->tags;
+      schemaAction.createSTable.fields = pointSchema->fields;
+      taosArrayPush(schemaActions, &schemaAction);
+    }else if (code == TSDB_CODE_SUCCESS) {
+      size_t pointTagSize = taosArrayGetSize(pointSchema->tags);
+      size_t pointFieldSize = taosArrayGetSize(pointSchema->fields);
+
+      SHashObj* dbTagHash = dbSchema.tagHash;
+      SHashObj* dbFieldHash = dbSchema.fieldHash;
+
+      for (int j = 0; j < pointTagSize; ++j) {
+        SSchema*            pointTag = taosArrayGet(pointSchema->tags, j);
+        SSchemaAction schemaAction = {0};
+        bool                   actionNeeded = false;
+        generateSchemaAction(pointTag, dbTagHash, true, pointSchema->sTableName, &schemaAction, &actionNeeded);
+        if (actionNeeded) {
+          taosArrayPush(schemaActions, &schemaAction);
+        }
+      }
+
+      for (int j = 0; j < pointFieldSize; ++j) {
+        SSchema*            pointCol = taosArrayGet(pointSchema->tags, j);
+        SSchemaAction schemaAction = {0};
+        bool                   actionNeeded = false;
+        generateSchemaAction(pointCol, dbFieldHash, false, pointSchema->sTableName, &schemaAction, &actionNeeded);
+        if (actionNeeded) {
+          taosArrayPush(schemaActions, &schemaAction);
+        }
+      }
+    } else {
+      return code;
+    }
   }
-  snprintf(result + strlen(result)-1, TSDB_MAX_BINARY_LEN-strlen(result)+1, ") (");
 
-  for (int i = 0; i < numCols; ++i) {
-    snprintf(result+strlen(result), TSDB_MAX_BINARY_LEN-strlen(result), "%s,", colsSchema[i].name);
+  for (int i = 0; i < taosArrayGetSize(schemaActions); ++i) {
+    SSchemaAction* action = taosArrayGet(schemaActions, i);
+    applySchemaAction(taos, action);
   }
-  snprintf(result + strlen(result)-1, TSDB_MAX_BINARY_LEN-strlen(result)+1, ") values (");
 
-  for (int i = 0; i < numCols; ++i) {
-    snprintf(result+strlen(result), TSDB_MAX_BINARY_LEN-strlen(result), "?,");
-  }
-  snprintf(result + strlen(result)-1, TSDB_MAX_BINARY_LEN-strlen(result)+1, ")");
-
-  int32_t code = 0;
-  code = taos_stmt_prepare(stmt, result, strlen(result));
-
-  code = taos_stmt_set_tbname_tags(stmt, cTableName, tagBind);
-  code = taos_stmt_bind_param_batch(stmt, colBind);
-  code = taos_stmt_execute(stmt);
+  insertPoints(taos, points, numPoint);
   return code;
 }
+
+
 //todo: table/column length check
 //todo: type check
 //todo: taosmbs2ucs4 check

From e5917825b548e6f4b3d70c467face0712fd33314 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Sun, 11 Jul 2021 11:21:05 +0800
Subject: [PATCH 16/70] Hotfix/sangshuduo/td 3801 taosdump coverity scan issue
 for develop (#6827)

* fix converity scan issue.

* fix converity issues

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/kit/taosdump/taosdump.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/kit/taosdump/taosdump.c b/src/kit/taosdump/taosdump.c
index b03d557309..e6820f396b 100644
--- a/src/kit/taosdump/taosdump.c
+++ b/src/kit/taosdump/taosdump.c
@@ -1596,6 +1596,7 @@ static void taosStartDumpOutWorkThreads(int32_t  numOfThread, char *dbName)
             NULL, g_args.port);
         if (pThread->taosCon == NULL) {
             errorPrint("Failed to connect to TDengine server %s\n", g_args.host);
+            free(threadObj);
             return;
         }
         pthread_attr_init(&thattr);
@@ -2607,6 +2608,7 @@ static void taosStartDumpInWorkThreads()
             NULL, g_args.port);
         if (pThread->taosCon == NULL) {
             errorPrint("Failed to connect to TDengine server %s\n", g_args.host);
+            free(threadObj);
             return;
         }
         pthread_attr_init(&thattr);

From bf5b5b3549393ea84a16b17b8f6d1fb21ac8d37c Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Sun, 11 Jul 2021 20:24:55 +0800
Subject: [PATCH 17/70] Hotfix/sangshuduo/td 3197 fix taosdemo coverity scan
 (#6829)

* [TD-3197] <fix>: fix taosdemo coverity scan issues.

* [TD-3197] <fix>: fix taosdemo coverity scan issue.

fix subscribeTest pids uninitialized.

* [TD-3197] <fix>: fix taosdemo coverity scan issues.

* [TD-3197] <fix>: fix coverity scan issues.

check super tbl info pointer.

* [TD-3197] <fix>: fix coverity scan issues.

move sub tbl query thread join into loop

* [TD-3197] <fix>: fix coverity scan issues.

remove unused variable

* [TD-3197] <fix>: fix coverity scan issues.

use more secure random library

* [TD-3197] <fix>: fix coverity scan issues.

use strncpy for more safe

* [TD-3197] <fix>: fix taosdemo coverity scan issue.

replace arc4random with rand().

* [TD-3197] <fix>: fix coverity scan issues.

check stb info pointer for start time

* [TD-3197] <fix>: fix coverity scan issues.

fix strcpy vulnerability

* [TD-3197] <fix>: fix taosdemo coverity scan issue.

modify taosdemoTest2. try to check database continously.

* [TD-3197] <fix>: taosdemo coverity scan issues.

* [TD-3197] <fix>: fix memory leak when parsing arguments.

* [TD-3197] <fix>: fix cmake strip arguments.

* [TD-3197] <fix>: taosdemo coverity scan.

fix cmake string manipulation.

* [TD-3197]<fix>: taosdemo coverity scan issue.

configDir buffer overwrite.

* [TD-3197]<fix>: coverity scan issue.

taosdump argument validation.

* [TD-3197]<fix>: taosdemo and taosdump coverity scan issues.

* [TD-3197]<fix>: taosdemo coverity scan.

append result buf to file. for develop branch.

* exit if read sample file failed.

* fix converity scan issue.

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/kit/taosdemo/taosdemo.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index e5945f4eac..085f266149 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -6008,8 +6008,10 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
         errorPrint("[%d] %s() LN%d Failed to insert records of batch %d\n",
                 pThreadInfo->threadID, __func__, __LINE__,
                 batchPerTbl);
-        errorPrint("\tIf the batch is %d, the length of the SQL to insert a row must be less then %"PRId64"\n",
-                batchPerTbl, maxSqlLen / batchPerTbl);
+        if (batchPerTbl > 0) {
+          errorPrint("\tIf the batch is %d, the length of the SQL to insert a row must be less then %"PRId64"\n",
+              batchPerTbl, maxSqlLen / batchPerTbl);
+        }
         errorPrint("\tPlease check if the buffer length(%"PRId64") or batch(%d) is set with proper value!\n",
                 maxSqlLen, batchPerTbl);
         goto free_of_interlace;

From 20c6dd70701983b8c8c798fd847bbc111f967e24 Mon Sep 17 00:00:00 2001
From: tomchon <haoran920c@163.com>
Date: Sun, 11 Jul 2021 20:51:50 +0800
Subject: [PATCH 18/70] modify dockerManifest.sh

---
 packaging/docker/dockerManifest.sh | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/packaging/docker/dockerManifest.sh b/packaging/docker/dockerManifest.sh
index 598bd46f13..0b30dd702c 100755
--- a/packaging/docker/dockerManifest.sh
+++ b/packaging/docker/dockerManifest.sh
@@ -48,11 +48,15 @@ if [ "$verType" == "beta" ]; then
   docker manifest create -a tdengine/tdengine-beta:latest tdengine/tdengine-amd64-beta:latest tdengine/tdengine-aarch64-beta:latest tdengine/tdengine-aarch32-beta:latest
   docker login -u tdengine -p ${passWord}  #replace the docker registry username and password
   docker manifest push tdengine/tdengine-beta:latest
+  docker manifest push tdengine/tdengine-beta:${version}
+
 elif [ "$verType" == "stable" ]; then
   docker manifest create -a tdengine/tdengine:${version} tdengine/tdengine-amd64:${version} tdengine/tdengine-aarch64:${version} tdengine/tdengine-aarch32:${version}
   docker manifest create -a tdengine/tdengine:latest tdengine/tdengine-amd64:latest tdengine/tdengine-aarch64:latest tdengine/tdengine-aarch32:latest
   docker login -u tdengine -p ${passWord}  #replace the docker registry username and password
   docker manifest push tdengine/tdengine:latest
+    docker manifest push tdengine/tdengine:${version}
+
 else
   echo "unknow verType, nor stabel or beta"
   exit 1

From 696435cdcc397ba3a3806f8a1e488d0be2b750ac Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Sun, 11 Jul 2021 21:51:07 +0800
Subject: [PATCH 19/70] Hotfix/sangshuduo/td 3801 taosdump coverity scan issue
 for develop (#6831)

* fix converity scan issue.

* fix converity issues

* fix converity scan issue.

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/kit/taosdump/taosdump.c | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/kit/taosdump/taosdump.c b/src/kit/taosdump/taosdump.c
index e6820f396b..98521d8420 100644
--- a/src/kit/taosdump/taosdump.c
+++ b/src/kit/taosdump/taosdump.c
@@ -124,6 +124,9 @@ typedef struct {
 
 extern char version[];
 
+#define DB_PRECISION_LEN   8
+#define DB_STATUS_LEN      16
+
 typedef struct {
     char     name[TSDB_DB_NAME_LEN];
     char     create_time[32];
@@ -144,9 +147,9 @@ typedef struct {
     int32_t  fsync;
     int8_t   comp;
     int8_t   cachelast;
-    char     precision[8];   // time resolution
+    char     precision[DB_PRECISION_LEN];   // time resolution
     int8_t   update;
-    char     status[16];
+    char     status[DB_STATUS_LEN];
 } SDbInfo;
 
 typedef struct {
@@ -542,7 +545,8 @@ static void parse_precision_first(
                 free(tmp);
                 exit(-1);
             }
-            strncpy(g_args.precision, tmp, strlen(tmp));
+            strncpy(g_args.precision, tmp,
+                min(DB_PRECISION_LEN - 1, strlen(tmp)));
             free(tmp);
         }
     }

From 2d0005d3f179b3a4f734fd75dcd104058537a3a6 Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Sun, 11 Jul 2021 23:52:19 +0800
Subject: [PATCH 20/70] before getChildTableName and insertBatch

---
 src/client/src/tscParseLineProtocol.c | 758 +++++++++++++++-----------
 src/inc/taos.h                        |   2 +
 tests/examples/c/apitest.c            |  15 +
 3 files changed, 447 insertions(+), 328 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index 2738fe6f7a..3a88d2e906 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -15,263 +15,6 @@
 #include "tskiplist.h"
 #include "tscUtil.h"
 
-typedef enum {
-  LP_ITEM_TAG,
-  LP_ITEM_FIELD
-} LPItemKind;
-
-typedef struct  {
-  SStrToken key;
-  SStrToken value;
-
-  char name[TSDB_COL_NAME_LEN];
-  int8_t type;
-  int16_t bytes;
-
-  char* payload;
-}SLPItem;
-
-typedef struct {
-  SStrToken measToken;
-  SStrToken tsToken;
-
-  char sTableName[TSDB_TABLE_NAME_LEN];
-  SArray* tags;
-  SArray* fields;
-  int64_t ts;
-
-} SLPPoint;
-
-typedef enum {
-  LP_MEASUREMENT,
-  LP_TAG_KEY,
-  LP_TAG_VALUE,
-  LP_FIELD_KEY,
-  LP_FIELD_VALUE
-} LPPart;
-
-int32_t scanToCommaOrSpace(SStrToken s, int32_t start, int32_t* index, LPPart part) {
-  for (int32_t i = start; i < s.n; ++i) {
-    if (s.z[i] == ',' || s.z[i] == ' ') {
-      *index = i;
-      return 0;
-    }
-  }
-  return -1;
-}
-
-int32_t scanToEqual(SStrToken s, int32_t start, int32_t* index) {
-  for (int32_t i = start; i < s.n; ++i) {
-    if (s.z[i] == '=') {
-      *index = i;
-      return 0;
-    }
-  }
-  return -1;
-}
-
-int32_t setPointMeasurement(SLPPoint* point, SStrToken token) {
-  point->measToken = token;
-  if (point->measToken.n < TSDB_TABLE_NAME_LEN) {
-    strncpy(point->sTableName, point->measToken.z, point->measToken.n);
-    point->sTableName[point->measToken.n] = '\0';
-  }
-  return 0;
-}
-
-int32_t setItemKey(SLPItem* item, SStrToken key, LPPart part) {
-  item->key = key;
-  if (item->key.n < TSDB_COL_NAME_LEN) {
-    strncpy(item->name, item->key.z, item->key.n);
-    item->name[item->key.n] = '\0';
-  }
-  return 0;
-}
-
-int32_t setItemValue(SLPItem* item, SStrToken value, LPPart part) {
-  item->value = value;
-  return 0;
-}
-
-int32_t parseItemValue(SLPItem* item, LPItemKind kind) {
-  char* sv = item->value.z;
-  char* last = item->value.z + item->value.n - 1;
-
-  if (isdigit(sv[0]) || sv[0] == '-') {
-    if (*last == 'i') {
-      item->type = TSDB_DATA_TYPE_BIGINT;
-      item->bytes = (int16_t)tDataTypes[item->type].bytes;
-      item->payload = malloc(item->bytes);
-      char* endptr = NULL;
-      *(item->payload) = strtoll(sv, &endptr, 10);
-    } else {
-      item->type = TSDB_DATA_TYPE_DOUBLE;
-      item->bytes = (int16_t)tDataTypes[item->type].bytes;
-      item->payload = malloc(item->bytes);
-      char* endptr = NULL;
-      *(item->payload) = strtold(sv, &endptr);
-    }
-  } else if ((sv[0] == 'L' && sv[1] =='"') || sv[0] == '"' ) {
-    if (sv[0] == 'L') {
-      item->type = TSDB_DATA_TYPE_NCHAR;
-      uint32_t bytes = item->value.n - 3;
-//      uint32_t len = bytes;
-//      char* ucs = malloc(len);
-//      int32_t ncharBytes = 0;
-//      taosMbsToUcs4(sv+2, len, ucs, len, &ncharBytes);
-//      item->bytes = ncharBytes;
-//      item->payload = malloc(ncharBytes);
-//      memcpy(item->payload, ucs, ncharBytes);
-//      free(ucs);
-      item->bytes = bytes;
-      item->payload = malloc(bytes);
-      memcpy(item->payload, sv+1, bytes);
-    } else if (sv[0]=='"'){
-      item->type = TSDB_DATA_TYPE_BINARY;
-      uint32_t bytes = item->value.n - 2;
-      item->bytes = bytes;
-      item->payload = malloc(bytes);
-      memcpy(item->payload, sv+1, bytes);
-    }
-  } else if (sv[0] == 't' || sv[0] == 'f' || sv[0]=='T' || sv[0] == 'F') {
-    item->type = TSDB_DATA_TYPE_BOOL;
-    item->bytes = tDataTypes[item->type].bytes;
-    item->payload = malloc(tDataTypes[item->type].bytes);
-    *(item->payload) = tolower(sv[0])=='t' ? true : false;
-  }
-  return 0;
-}
-
-int32_t compareLPItemKey(const void* p1, const void* p2) {
-  const SLPItem* t1 = p1;
-  const SLPItem* t2 = p2;
-  uint32_t min = (t1->key.n < t2->key.n) ? t1->key.n : t2->key.n;
-  int res = strncmp(t1->key.z, t2->key.z, min);
-  if (res != 0) {
-    return res;
-  } else {
-    return (int)(t1->key.n) - (int)(t2->key.n);
-  }
-}
-
-int32_t setPointTimeStamp(SLPPoint* point, SStrToken tsToken) {
-  point->tsToken = tsToken;
-  return 0;
-}
-
-int32_t parsePointTime(SLPPoint* point) {
-  if (point->tsToken.n <= 0) {
-    point->ts = taosGetTimestampNs();
-  } else {
-    char* endptr = NULL;
-    point->ts = strtoll(point->tsToken.z, &endptr, 10);
-  }
-  return 0;
-}
-
-int32_t tscParseLine(SStrToken line, SLPPoint* point) {
-  int32_t pos = 0;
-
-  int32_t start = 0;
-  int32_t err = scanToCommaOrSpace(line, start, &pos, LP_MEASUREMENT);
-  if (err != 0) {
-    tscError("a");
-    return err;
-  }
-
-  SStrToken measurement = {.z = line.z+start, .n = pos-start};
-  setPointMeasurement(point, measurement);
-  point->tags = taosArrayInit(64, sizeof(SLPItem));
-  start = pos + 1;
-  while (line.z[start] == ',') {
-    SLPItem item;
-
-    err = scanToEqual(line, start, &pos);
-    if (err != 0) {
-      tscError("b");
-      goto error;
-    }
-
-    SStrToken tagKey = {.z = line.z + start, .n = pos-start};
-    setItemKey(&item, tagKey, LP_TAG_KEY);
-
-    start = pos + 1;
-    err = scanToCommaOrSpace(line, start, &pos, LP_TAG_VALUE);
-    if (err != 0) {
-      tscError("c");
-      goto error;
-    }
-
-    SStrToken tagValue = {.z = line.z + start, .n = pos-start};
-    setItemValue(&item, tagValue, LP_TAG_VALUE);
-
-    parseItemValue(&item, LP_ITEM_TAG);
-    taosArrayPush(point->tags, &item);
-
-    start = pos + 1;
-  }
-
-  taosArraySort(point->tags, compareLPItemKey);
-
-  point->fields = taosArrayInit(64, sizeof(SLPItem));
-  do {
-    SLPItem item;
-    err = scanToEqual(line, start, &pos);
-    if (err != 0) {
-      goto error;
-    }
-    SStrToken fieldKey = {.z = line.z + start, .n = pos- start};
-    setItemKey(&item, fieldKey, LP_FIELD_KEY);
-
-    start = pos + 1;
-    err = scanToCommaOrSpace(line, start, &pos, LP_FIELD_VALUE);
-    if (err != 0) {
-      goto error;
-    }
-    SStrToken fieldValue = {.z = line.z + start, .n = pos - start};
-    setItemValue(&item, fieldValue, LP_TAG_VALUE);
-
-    parseItemValue(&item, LP_ITEM_FIELD);
-    taosArrayPush(point->fields, &item);
-
-    start = pos + 1;
-  } while (line.z[pos] == ',');
-
-  taosArraySort(point->fields, compareLPItemKey);
-
-  SStrToken tsToken = {.z = line.z+start, .n = line.n-start};
-  setPointTimeStamp(point, tsToken);
-  parsePointTime(point);
-
-  goto done;
-
-error:
-  // free array
-  return err;
-done:
-  return 0;
-}
-
-
-int32_t tscParseLines(char* lines[], int numLines, SArray* points, SArray* failedLines) {
-  for (int32_t i = 0; i < numLines; ++i) {
-    SStrToken tkLine = {.z = lines[i], .n = strlen(lines[i])+1};
-    SLPPoint point;
-    tscParseLine(tkLine, &point);
-    taosArrayPush(points, &point);
-  }
-  return 0;
-}
-
-TAOS_RES* taos_insert_by_lines(TAOS* taos, char* lines[], int numLines) {
-  SArray* points = taosArrayInit(numLines, sizeof(SLPPoint));
-  tscParseLines(lines, numLines, points, NULL);
-
-
-  return NULL;
-}
-//=================================================================================================
-
 typedef struct  {
   char sTableName[TSDB_TABLE_NAME_LEN];
   SHashObj* tagHash;
@@ -305,6 +48,8 @@ typedef struct {
   SSmlSTableSchema* schema;
 } TAOS_SML_DATA_POINT;
 
+//=================================================================================================
+
 int compareSmlColKv(const void* p1, const void* p2) {
   TAOS_SML_KV* kv1 = (TAOS_SML_KV*)p1;
   TAOS_SML_KV* kv2 = (TAOS_SML_KV*)p2;
@@ -318,32 +63,6 @@ int compareSmlColKv(const void* p1, const void* p2) {
   }
 }
 
-int32_t getChildTableName(TAOS_SML_DATA_POINT* point, char* tableName, int* tableNameLen) {
-    qsort(point->tags, point->tagNum, sizeof(TAOS_SML_KV), compareSmlColKv);
-
-    SStringBuilder sb; memset(&sb, 0, sizeof(sb));
-    taosStringBuilderAppendString(&sb, point->stableName);
-    for (int j = 0; j < point->tagNum; ++j) {
-      TAOS_SML_KV* tagKv = point->tags + j;
-      taosStringBuilderAppendChar(&sb, ',');
-      taosStringBuilderAppendString(&sb, tagKv->key);
-      taosStringBuilderAppendChar(&sb, '=');
-      taosStringBuilderAppend(&sb, tagKv->value, tagKv->length);
-    }
-    size_t len = 0;
-    char* keyJoined = taosStringBuilderGetResult(&sb, &len);
-    MD5_CTX context;
-    MD5Init(&context);
-    MD5Update(&context, (uint8_t *)keyJoined, (uint32_t)len);
-    MD5Final(&context);
-    *tableNameLen = snprintf(tableName, *tableNameLen,
-             "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", context.digest[0],
-             context.digest[1], context.digest[2], context.digest[3], context.digest[4], context.digest[5], context.digest[6],
-             context.digest[7], context.digest[8], context.digest[9], context.digest[10], context.digest[11],
-             context.digest[12], context.digest[13], context.digest[14], context.digest[15]);
-    return 0;
-}
-
 int32_t loadTableMeta(TAOS* taos, char* tableName, SSmlSTableSchema* schema) {
   int32_t code = 0;
 
@@ -393,15 +112,14 @@ int32_t loadTableMeta(TAOS* taos, char* tableName, SSmlSTableSchema* schema) {
 
   tscFreeSqlObj(pSql);
 
-
   uint32_t size = tscGetTableMetaMaxSize();
   STableMeta* tableMeta = calloc(1, size);
   taosHashGetClone(tscTableMetaInfo, fullTableName, strlen(fullTableName), NULL, tableMeta, -1);
 
-  tstrncpy(schema->sTableName, tableName, strlen(tableName));
+  tstrncpy(schema->sTableName, tableName, strlen(tableName)+1);
   for (int i=0; i<tableMeta->tableInfo.numOfColumns; ++i) {
     SSchema field;
-    tstrncpy(field.name, tableMeta->schema[i].name, strlen(tableMeta->schema[i].name));
+    tstrncpy(field.name, tableMeta->schema[i].name, strlen(tableMeta->schema[i].name)+1);
     field.type = tableMeta->schema[i].type;
     field.bytes = tableMeta->schema[i].bytes;
     SSchema* pField = taosArrayPush(schema->fields, &field);
@@ -411,13 +129,13 @@ int32_t loadTableMeta(TAOS* taos, char* tableName, SSmlSTableSchema* schema) {
   for (int i=0; i<tableMeta->tableInfo.numOfTags; ++i) {
     int j = i + tableMeta->tableInfo.numOfColumns;
     SSchema field;
-    tstrncpy(field.name, tableMeta->schema[j].name, strlen(tableMeta->schema[j].name));
+    tstrncpy(field.name, tableMeta->schema[j].name, strlen(tableMeta->schema[j].name)+1);
     field.type = tableMeta->schema[j].type;
     field.bytes = tableMeta->schema[j].bytes;
     SSchema* pField = taosArrayPush(schema->tags, &field);
     taosHashPut(schema->tagHash, field.name, strlen(field.name), &pField, POINTER_BYTES);
   }
-
+  free(tableMeta); tableMeta = NULL;
   return code;
 }
 
@@ -586,6 +304,7 @@ int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
                              capacity-n, &outBytes);
       TAOS_RES* res = taos_query(taos, result); //TODO async doAsyncQuery
       code = taos_errno(res);
+      break;
     }
     case SCHEMA_ACTION_CHANGE_TAG_SIZE: {
       int n = sprintf(result, "alter stable %s modify tag ", action->alterSTable.sTableName);
@@ -631,15 +350,46 @@ int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
   return code;
 }
 
+int32_t getChildTableName(TAOS_SML_DATA_POINT* point, char* tableName, int* tableNameLen) {
+  qsort(point->tags, point->tagNum, sizeof(TAOS_SML_KV), compareSmlColKv);
+
+  SStringBuilder sb; memset(&sb, 0, sizeof(sb));
+  taosStringBuilderAppendString(&sb, point->stableName);
+  for (int j = 0; j < point->tagNum; ++j) {
+    taosStringBuilderAppendChar(&sb, ',');
+    TAOS_SML_KV* tagKv = point->tags + j;
+    taosStringBuilderAppendString(&sb, tagKv->key);
+    taosStringBuilderAppendChar(&sb, '=');
+    taosStringBuilderAppend(&sb, tagKv->value, tagKv->length);
+  }
+  size_t len = 0;
+  char* keyJoined = taosStringBuilderGetResult(&sb, &len);
+  MD5_CTX context;
+  MD5Init(&context);
+  MD5Update(&context, (uint8_t *)keyJoined, (uint32_t)len);
+  MD5Final(&context);
+  *tableNameLen = snprintf(tableName, *tableNameLen,
+                           "tbl%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", context.digest[0],
+                           context.digest[1], context.digest[2], context.digest[3], context.digest[4], context.digest[5], context.digest[6],
+                           context.digest[7], context.digest[8], context.digest[9], context.digest[10], context.digest[11],
+                           context.digest[12], context.digest[13], context.digest[14], context.digest[15]);
+  taosStringBuilderDestroy(&sb);
+  return 0;
+}
+
 int32_t getPreparedSQL(const char* sTableName, SArray* tagsSchema, SArray* colsSchema, char* result, int16_t freeBytes) {
   size_t numTags = taosArrayGetSize(tagsSchema);
   size_t numCols = taosArrayGetSize(colsSchema);
-  sprintf(result, "insert into ? using %s(", sTableName);
-  for (int i = 0; i < numTags; ++i) {
-    SSchema* tagSchema = taosArrayGet(tagsSchema, i);
-    snprintf(result+strlen(result), freeBytes-strlen(result), "%s,", tagSchema->name);
-  }
-  snprintf(result + strlen(result)-1, freeBytes-strlen(result)+1, ") tags (");
+  sprintf(result, "insert into ? using %s", sTableName);
+
+//  snprintf(result+strlen(result), freeBytes-strlen(result), "(");
+//  for (int i = 0; i < numTags; ++i) {
+//    SSchema* tagSchema = taosArrayGet(tagsSchema, i);
+//    snprintf(result+strlen(result), freeBytes-strlen(result), "%s,", tagSchema->name);
+//  }
+//  snprintf(result + strlen(result)-1, freeBytes-strlen(result)+1, ")");
+
+  snprintf(result + strlen(result), freeBytes-strlen(result), " tags (");
 
   for (int i = 0; i < numTags; ++i) {
     snprintf(result+strlen(result), freeBytes-strlen(result), "?,");
@@ -661,17 +411,38 @@ int32_t getPreparedSQL(const char* sTableName, SArray* tagsSchema, SArray* colsS
 
 int32_t insertBatch(TAOS* taos, char* sql, char* cTableName, SArray* tagsBind, SArray* rowsBind) {
   TAOS_STMT* stmt = taos_stmt_init(taos);
-  taos_stmt_prepare(stmt, sql, strlen(sql));
-
-  taos_stmt_set_tbname_tags(stmt, cTableName, TARRAY_GET_START(tagsBind));
-  size_t rows = taosArrayGetSize(rowsBind);
-  for (int32_t i = 0; i < rows; ++i) {
-    TAOS_BIND* colBind = taosArrayGetP(rowsBind, i);
-    taos_stmt_bind_param(stmt, colBind);
-    taos_stmt_add_batch(stmt);
+  int32_t code;
+  code = taos_stmt_prepare(stmt, sql, strlen(sql));
+  if (code != 0) {
+    printf("%s", taos_stmt_errstr(stmt));
+    return code;
   }
 
-  taos_stmt_execute(stmt);
+  code = taos_stmt_set_tbname_tags(stmt, cTableName, TARRAY_GET_START(tagsBind));
+  if (code != 0) {
+    printf("%s", taos_stmt_errstr(stmt));
+    return code;
+  }
+  size_t rows = taosArrayGetSize(rowsBind);
+  for (int32_t i = 0; i < rows; ++i) {
+    SArray* colBind = taosArrayGetP(rowsBind, i);
+    code = taos_stmt_bind_param(stmt, TARRAY_GET_START(colBind));
+    if (code != 0) {
+      printf("%s", taos_stmt_errstr(stmt));
+      return code;
+    }
+    code = taos_stmt_add_batch(stmt);
+    if (code != 0) {
+      printf("%s", taos_stmt_errstr(stmt));
+      return code;
+    }
+  }
+
+  code = taos_stmt_execute(stmt);
+  if (code != 0) {
+    printf("%s", taos_stmt_errstr(stmt));
+    return code;
+  }
   TAOS_RES* res = taos_stmt_use_result(stmt);
   return taos_errno(res);
 }
@@ -682,7 +453,7 @@ int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints)
     TAOS_SML_DATA_POINT * point = points + i;
     if (!point->childTableName) {
       char childTableName[TSDB_TABLE_NAME_LEN];
-      int32_t tableNameLen;
+      int32_t tableNameLen = TSDB_TABLE_NAME_LEN;
       getChildTableName(point, childTableName, &tableNameLen);
       point->childTableName = calloc(1, tableNameLen+1);
       strncpy(point->childTableName, childTableName, tableNameLen);
@@ -696,50 +467,62 @@ int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints)
       cTablePoints = taosArrayInit(64, sizeof(point));
       taosHashPut(cname2points, point->childTableName, strlen(point->childTableName), &cTablePoints, POINTER_BYTES);
     }
-    taosArrayPush(cTablePoints, point);
+    taosArrayPush(cTablePoints, &point);
   }
 
+  int isNullColBind = TSDB_TRUE;
   SArray** pCTablePoints = taosHashIterate(cname2points, NULL);
   while (pCTablePoints) {
     SArray* cTablePoints = *pCTablePoints;
-    TAOS_SML_DATA_POINT * point = taosArrayGet(cTablePoints, 0);
+
+    TAOS_SML_DATA_POINT * point = taosArrayGetP(cTablePoints, 0);
     int32_t numTags = taosArrayGetSize(point->schema->tags);
     int32_t numCols = taosArrayGetSize(point->schema->fields);
     char* stableName = point->stableName;
     char* ctableName = point->childTableName;
-    char sql[TSDB_MAX_BINARY_LEN];
-    getPreparedSQL(stableName, point->schema->tags, point->schema->fields, sql, TSDB_MAX_BINARY_LEN);
+
+    SArray* tagBinds = taosArrayInit(numTags, sizeof(TAOS_BIND));
+    taosArraySetSize(tagBinds, numTags);
+    for (int j = 0; j < numTags; ++j) {
+      TAOS_BIND* bind = taosArrayGet(tagBinds, j);
+      bind->is_null = &isNullColBind;
+    }
+    for (int j = 0; j < point->tagNum; ++j) {
+      TAOS_SML_KV* kv =  point->tags + j;
+      int32_t idx = TARRAY_ELEM_IDX(point->schema->tags, kv->schema);
+      TAOS_BIND* bind = taosArrayGet(tagBinds, idx);
+      bind->buffer_type = kv->type;
+      bind->length = (uintptr_t*)&kv->length;
+      bind->buffer = kv->value;
+      bind->is_null = NULL;
+    }
 
     size_t rows = taosArrayGetSize(cTablePoints);
     SArray* rowsBind = taosArrayInit(rows, POINTER_BYTES);
-    SArray* tagBinds = taosArrayInit(numTags, sizeof(TAOS_BIND));
 
     for (int i = 0; i < rows; ++i) {
-      point = taosArrayGet(cTablePoints, i);
-
-      taosArraySetSize(tagBinds, numTags);
-      for (int j = 0; j < point->tagNum; ++j) {
-        TAOS_SML_KV* kv =  point->tags + j;
-        int32_t idx = TARRAY_ELEM_IDX(point->schema->tags, kv->schema);
-        TAOS_BIND* bind = taosArrayGet(tagBinds, idx);
-        bind->buffer_type = kv->type;
-        bind->length = (uintptr_t*)&kv->length;
-        bind->buffer = kv->value;
-      }
+      point = taosArrayGetP(cTablePoints, i);
 
       SArray* colBinds = taosArrayInit(numCols, sizeof(TAOS_BIND));
       taosArraySetSize(colBinds, numCols);
-      for (int j = 0; j<point->fieldNum; ++j) {
+      for (int j = 0; j < numCols; ++j) {
+        TAOS_BIND* bind = taosArrayGet(colBinds, j);
+        bind->is_null = &isNullColBind;
+      }
+      for (int j = 0; j < point->fieldNum; ++j) {
         TAOS_SML_KV* kv = point->fields + j;
         int32_t idx = TARRAY_ELEM_IDX(point->schema->fields, kv->schema);
         TAOS_BIND* bind = taosArrayGet(colBinds, idx);
         bind->buffer_type = kv->type;
         bind->length = (uintptr_t*)&kv->length;
         bind->buffer = kv->value;
+        bind->is_null = NULL;
       }
       taosArrayPush(rowsBind, &colBinds);
     }
 
+    char sql[TSDB_MAX_BINARY_LEN];
+    getPreparedSQL(stableName, point->schema->tags, point->schema->fields, sql, TSDB_MAX_BINARY_LEN);
     insertBatch(taos, sql, ctableName, tagBinds, rowsBind);
 
     pCTablePoints = taosHashIterate(cname2points, pCTablePoints);
@@ -747,7 +530,6 @@ int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints)
   return 0;
 }
 
-
 int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
   int32_t code = TSDB_CODE_SUCCESS;
   SArray* stableArray = taosArrayInit(32, sizeof(SSmlSTableSchema)); // SArray<STableColumnsSchema>
@@ -792,11 +574,13 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
   for (int i = 0; i < numStable; ++i) {
     SSmlSTableSchema* pointSchema = taosArrayGet(stableArray, i);
     SSmlSTableSchema  dbSchema = {0};
-    dbSchema.fields = taosArrayInit(64, sizeof(SSchema));
     dbSchema.tags = taosArrayInit(8, sizeof(SSchema));
+    dbSchema.fields = taosArrayInit(64, sizeof(SSchema));
     dbSchema.tagHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
     dbSchema.fieldHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+
     code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
+
     if (code == TSDB_CODE_MND_INVALID_TABLE_NAME) {
       SSchemaAction schemaAction = {0};
       schemaAction.action = SCHEMA_ACTION_CREATE_STABLE;
@@ -813,19 +597,23 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
       SHashObj* dbFieldHash = dbSchema.fieldHash;
 
       for (int j = 0; j < pointTagSize; ++j) {
-        SSchema*            pointTag = taosArrayGet(pointSchema->tags, j);
+        SSchema* pointTag = taosArrayGet(pointSchema->tags, j);
         SSchemaAction schemaAction = {0};
-        bool                   actionNeeded = false;
+        bool actionNeeded = false;
         generateSchemaAction(pointTag, dbTagHash, true, pointSchema->sTableName, &schemaAction, &actionNeeded);
         if (actionNeeded) {
           taosArrayPush(schemaActions, &schemaAction);
         }
       }
 
-      for (int j = 0; j < pointFieldSize; ++j) {
-        SSchema*            pointCol = taosArrayGet(pointSchema->tags, j);
+      SSchema* pointColTs = taosArrayGet(pointSchema->fields, 0);
+      SSchema* dbColTs = taosArrayGet(dbSchema.fields, 0);
+      memcpy(pointColTs->name, dbColTs->name, TSDB_COL_NAME_LEN);
+
+      for (int j = 1; j < pointFieldSize; ++j) {
+        SSchema* pointCol = taosArrayGet(pointSchema->fields, j);
         SSchemaAction schemaAction = {0};
-        bool                   actionNeeded = false;
+        bool actionNeeded = false;
         generateSchemaAction(pointCol, dbFieldHash, false, pointSchema->sTableName, &schemaAction, &actionNeeded);
         if (actionNeeded) {
           taosArrayPush(schemaActions, &schemaAction);
@@ -849,3 +637,317 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
 //todo: table/column length check
 //todo: type check
 //todo: taosmbs2ucs4 check
+
+//=========================================================================
+
+typedef enum {
+  LP_ITEM_TAG,
+  LP_ITEM_FIELD
+} LPItemKind;
+
+typedef struct  {
+  SStrToken keyToken;
+  SStrToken valueToken;
+
+  char key[TSDB_COL_NAME_LEN];
+  int8_t type;
+  int16_t length;
+
+  char* value;
+}SLPItem;
+
+typedef struct {
+  SStrToken measToken;
+  SStrToken tsToken;
+
+  char sTableName[TSDB_TABLE_NAME_LEN];
+  SArray* tags;
+  SArray* fields;
+  int64_t ts;
+
+} SLPPoint;
+
+typedef enum {
+  LP_MEASUREMENT,
+  LP_TAG_KEY,
+  LP_TAG_VALUE,
+  LP_FIELD_KEY,
+  LP_FIELD_VALUE
+} LPPart;
+
+int32_t scanToCommaOrSpace(SStrToken s, int32_t start, int32_t* index, LPPart part) {
+  for (int32_t i = start; i < s.n; ++i) {
+    if (s.z[i] == ',' || s.z[i] == ' ') {
+      *index = i;
+      return 0;
+    }
+  }
+  return -1;
+}
+
+int32_t scanToEqual(SStrToken s, int32_t start, int32_t* index) {
+  for (int32_t i = start; i < s.n; ++i) {
+    if (s.z[i] == '=') {
+      *index = i;
+      return 0;
+    }
+  }
+  return -1;
+}
+
+int32_t setPointMeasurement(SLPPoint* point, SStrToken token) {
+  point->measToken = token;
+  if (point->measToken.n < TSDB_TABLE_NAME_LEN) {
+    strncpy(point->sTableName, point->measToken.z, point->measToken.n);
+    point->sTableName[point->measToken.n] = '\0';
+  }
+  return 0;
+}
+
+int32_t setItemKey(SLPItem* item, SStrToken key, LPPart part) {
+  item->keyToken = key;
+  if (item->keyToken.n < TSDB_COL_NAME_LEN) {
+    strncpy(item->key, item->keyToken.z, item->keyToken.n);
+    item->key[item->keyToken.n] = '\0';
+  }
+  return 0;
+}
+
+int32_t setItemValue(SLPItem* item, SStrToken value, LPPart part) {
+  item->valueToken = value;
+  return 0;
+}
+
+int32_t parseItemValue(SLPItem* item, LPItemKind kind) {
+  char* sv = item->valueToken.z;
+  char* last = item->valueToken.z + item->valueToken.n - 1;
+
+  if (isdigit(sv[0]) || sv[0] == '-') {
+    if (*last == 'i') {
+      item->type = TSDB_DATA_TYPE_BIGINT;
+      item->length = (int16_t)tDataTypes[item->type].bytes;
+      item->value = malloc(item->length);
+      char* endptr = NULL;
+      *(item->value) = strtoll(sv, &endptr, 10);
+    } else {
+      item->type = TSDB_DATA_TYPE_DOUBLE;
+      item->length = (int16_t)tDataTypes[item->type].bytes;
+      item->value = malloc(item->length);
+      char* endptr = NULL;
+      *(item->value) = strtold(sv, &endptr);
+    }
+  } else if ((sv[0] == 'L' && sv[1] =='"') || sv[0] == '"' ) {
+    if (sv[0] == 'L') {
+      item->type = TSDB_DATA_TYPE_NCHAR;
+      uint32_t bytes = item->valueToken.n - 3;
+      item->length = bytes;
+      item->value = malloc(bytes);
+      memcpy(item->value, sv+1, bytes);
+    } else if (sv[0]=='"'){
+      item->type = TSDB_DATA_TYPE_BINARY;
+      uint32_t bytes = item->valueToken.n - 2;
+      item->length = bytes;
+      item->value = malloc(bytes);
+      memcpy(item->value, sv+1, bytes);
+    }
+  } else if (sv[0] == 't' || sv[0] == 'f' || sv[0]=='T' || sv[0] == 'F') {
+    item->type = TSDB_DATA_TYPE_BOOL;
+    item->length = tDataTypes[item->type].bytes;
+    item->value = malloc(tDataTypes[item->type].bytes);
+    *(item->value) = tolower(sv[0])=='t' ? TSDB_TRUE : TSDB_FALSE;
+  }
+  return 0;
+}
+
+int32_t compareLPItemKey(const void* p1, const void* p2) {
+  const SLPItem* t1 = p1;
+  const SLPItem* t2 = p2;
+  uint32_t min = (t1->keyToken.n < t2->keyToken.n) ? t1->keyToken.n : t2->keyToken.n;
+  int res = strncmp(t1->keyToken.z, t2->keyToken.z, min);
+  if (res != 0) {
+    return res;
+  } else {
+    return (int)(t1->keyToken.n) - (int)(t2->keyToken.n);
+  }
+}
+
+int32_t setPointTimeStamp(SLPPoint* point, SStrToken tsToken) {
+  point->tsToken = tsToken;
+  return 0;
+}
+
+int32_t parsePointTime(SLPPoint* point) {
+  if (point->tsToken.n <= 0) {
+    point->ts = taosGetTimestampNs();
+  } else {
+    char* endptr = NULL;
+    point->ts = strtoll(point->tsToken.z, &endptr, 10);
+  }
+  return 0;
+}
+
+int32_t tscParseLine(SStrToken line, SLPPoint* point) {
+  int32_t pos = 0;
+
+  int32_t start = 0;
+  int32_t err = scanToCommaOrSpace(line, start, &pos, LP_MEASUREMENT);
+  if (err != 0) {
+    tscError("a");
+    return err;
+  }
+
+  SStrToken measurement = {.z = line.z+start, .n = pos-start};
+  setPointMeasurement(point, measurement);
+  point->tags = taosArrayInit(64, sizeof(SLPItem));
+  start = pos;
+  while (line.z[start] == ',') {
+    SLPItem item;
+
+    start++;
+    err = scanToEqual(line, start, &pos);
+    if (err != 0) {
+      tscError("b");
+      goto error;
+    }
+
+    SStrToken tagKey = {.z = line.z + start, .n = pos-start};
+    setItemKey(&item, tagKey, LP_TAG_KEY);
+
+    start = pos + 1;
+    err = scanToCommaOrSpace(line, start, &pos, LP_TAG_VALUE);
+    if (err != 0) {
+      tscError("c");
+      goto error;
+    }
+
+    SStrToken tagValue = {.z = line.z + start, .n = pos-start};
+    setItemValue(&item, tagValue, LP_TAG_VALUE);
+
+    parseItemValue(&item, LP_ITEM_TAG);
+    taosArrayPush(point->tags, &item);
+
+    start = pos;
+  }
+
+  taosArraySort(point->tags, compareLPItemKey);
+
+  point->fields = taosArrayInit(64, sizeof(SLPItem));
+
+  start++;
+  do {
+    SLPItem item;
+
+    err = scanToEqual(line, start, &pos);
+    if (err != 0) {
+      goto error;
+    }
+    SStrToken fieldKey = {.z = line.z + start, .n = pos- start};
+    setItemKey(&item, fieldKey, LP_FIELD_KEY);
+
+    start = pos + 1;
+    err = scanToCommaOrSpace(line, start, &pos, LP_FIELD_VALUE);
+    if (err != 0) {
+      goto error;
+    }
+    SStrToken fieldValue = {.z = line.z + start, .n = pos - start};
+    setItemValue(&item, fieldValue, LP_TAG_VALUE);
+
+    parseItemValue(&item, LP_ITEM_FIELD);
+    taosArrayPush(point->fields, &item);
+
+    start = pos + 1;
+  } while (line.z[pos] == ',');
+
+  taosArraySort(point->fields, compareLPItemKey);
+
+  SStrToken tsToken = {.z = line.z+start, .n = line.n-start};
+  setPointTimeStamp(point, tsToken);
+  parsePointTime(point);
+
+  goto done;
+
+  error:
+  // free array
+  return err;
+  done:
+  return 0;
+}
+
+
+int32_t tscParseLines(char* lines[], int numLines, SArray* points, SArray* failedLines) {
+  for (int32_t i = 0; i < numLines; ++i) {
+    SStrToken tkLine = {.z = lines[i], .n = strlen(lines[i])+1};
+    SLPPoint point;
+    tscParseLine(tkLine, &point);
+    taosArrayPush(points, &point);
+  }
+  return 0;
+}
+
+int taos_insert_by_lines(TAOS* taos, char* lines[], int numLines) {
+  SArray* lpPoints = taosArrayInit(numLines, sizeof(SLPPoint));
+  tscParseLines(lines, numLines, lpPoints, NULL);
+
+  size_t numPoints = taosArrayGetSize(lpPoints);
+  TAOS_SML_DATA_POINT* points = calloc(numPoints, sizeof(TAOS_SML_DATA_POINT));
+  for (int i = 0; i < numPoints; ++i) {
+    SLPPoint* lpPoint = taosArrayGet(lpPoints, i);
+    TAOS_SML_DATA_POINT* point = points+i;
+    point->stableName = calloc(1, strlen(lpPoint->sTableName)+1);
+    strncpy(point->stableName, lpPoint->sTableName, strlen(lpPoint->sTableName));
+    point->stableName[strlen(lpPoint->sTableName)] = '\0';
+
+    size_t lpTagSize = taosArrayGetSize(lpPoint->tags);
+    point->tags = calloc(lpTagSize, sizeof(TAOS_SML_KV));
+    point->tagNum = lpTagSize;
+    for (int j=0; j<lpTagSize; ++j) {
+      SLPItem* lpTag = taosArrayGet(lpPoint->tags, j);
+      TAOS_SML_KV* tagKv = point->tags + j;
+
+      size_t kenLen = strlen(lpTag->key);
+      tagKv->key = calloc(1, kenLen+1);
+      strncpy(tagKv->key, lpTag->key, kenLen);
+      tagKv->key[kenLen] = '\0';
+
+      tagKv->type = lpTag->type;
+      tagKv->length = lpTag->length;
+      tagKv->value = malloc(tagKv->length);
+      memcpy(tagKv->value, lpTag->value, tagKv->length);
+    }
+
+    size_t lpFieldsSize = taosArrayGetSize(lpPoint->fields);
+    point->fields = calloc(lpFieldsSize + 1, sizeof(TAOS_SML_KV));
+    point->fieldNum = lpFieldsSize + 1;
+
+    TAOS_SML_KV* tsField = point->fields + 0;
+    char tsKey[256];
+    snprintf(tsKey, 256, "_%s_ts", point->stableName);
+    size_t tsKeyLen = strlen(tsKey);
+    tsField->key = calloc(1, tsKeyLen+1);
+    strncpy(tsField->key, tsKey, tsKeyLen);
+    tsField->key[tsKeyLen] = '\0';
+    tsField->type = TSDB_DATA_TYPE_TIMESTAMP;
+    tsField->length = tDataTypes[TSDB_DATA_TYPE_TIMESTAMP].bytes;
+    tsField->value = malloc(tsField->length);
+    memcpy(tsField->value, &(lpPoint->ts), tsField->length);
+
+    for (int j=0; j<lpFieldsSize; ++j) {
+      SLPItem* lpField = taosArrayGet(lpPoint->fields, j);
+      TAOS_SML_KV* fieldKv = point->fields + j + 1;
+
+      size_t kenLen = strlen(lpField->key);
+      fieldKv->key = calloc(1, kenLen+1);
+      strncpy(fieldKv->key, lpField->key, kenLen);
+      fieldKv->key[kenLen] = '\0';
+
+      fieldKv->type = lpField->type;
+      fieldKv->length = lpField->length;
+      fieldKv->value = malloc(fieldKv->length);
+      memcpy(fieldKv->value, lpField->value, fieldKv->length);
+    }
+  }
+
+  taos_sml_insert(taos, points, numPoints);
+  return 0;
+}
+
diff --git a/src/inc/taos.h b/src/inc/taos.h
index 9f72945ef0..ca18c4fb93 100644
--- a/src/inc/taos.h
+++ b/src/inc/taos.h
@@ -169,6 +169,8 @@ DLL_EXPORT void taos_close_stream(TAOS_STREAM *tstr);
 
 DLL_EXPORT int taos_load_table_info(TAOS *taos, const char* tableNameList);
 
+DLL_EXPORT int taos_insert_by_lines(TAOS* taos, char* lines[], int numLines);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index 0f24df0f47..dc77677774 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -949,6 +949,15 @@ void verify_stream(TAOS* taos) {
   taos_close_stream(strm);
 }
 
+int32_t verify_schema_less(TAOS* taos) {
+  prepare_data(taos);
+  char* lines[] = {
+      "st,t1=3i,t2=4,t3=\"t3\" c1=3i,c3=L\"passit\",c2=false,c4=4 1626006833639162922"
+  };
+  int code = taos_insert_by_lines(taos, lines , 1);
+  return code;
+}
+
 int main(int argc, char *argv[]) {
   const char* host = "127.0.0.1";
   const char* user = "root";
@@ -967,6 +976,12 @@ int main(int argc, char *argv[]) {
   info = taos_get_client_info(taos);
   printf("client info: %s\n", info);
 
+  printf("************  verify query  *************\n");
+  int code = verify_schema_less(taos);
+  if (code == 0) {
+    return code;
+  }
+
   printf("************  verify query  *************\n");
   verify_query(taos);
 

From cb5a0012f411675b7d5a40d0ec6cd88361c157ec Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Mon, 12 Jul 2021 00:39:16 +0800
Subject: [PATCH 21/70] before time precision and create table with tags
 instead of autocreate

---
 src/client/src/tscParseLineProtocol.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index 3a88d2e906..4b9191a91f 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -492,7 +492,8 @@ int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints)
       int32_t idx = TARRAY_ELEM_IDX(point->schema->tags, kv->schema);
       TAOS_BIND* bind = taosArrayGet(tagBinds, idx);
       bind->buffer_type = kv->type;
-      bind->length = (uintptr_t*)&kv->length;
+      bind->length = malloc(sizeof(uintptr_t*));
+      *bind->length = kv->length;
       bind->buffer = kv->value;
       bind->is_null = NULL;
     }
@@ -514,7 +515,8 @@ int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints)
         int32_t idx = TARRAY_ELEM_IDX(point->schema->fields, kv->schema);
         TAOS_BIND* bind = taosArrayGet(colBinds, idx);
         bind->buffer_type = kv->type;
-        bind->length = (uintptr_t*)&kv->length;
+        bind->length = malloc(sizeof(uintptr_t*));
+        *bind->length = kv->length;
         bind->buffer = kv->value;
         bind->is_null = NULL;
       }

From 3d25ecdf29c3d912bb91e81f47c72b97fb737cea Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Mon, 12 Jul 2021 08:38:51 +0800
Subject: [PATCH 22/70] can add two lines of one supertable/diffrent subtable

---
 src/client/src/tscParseLineProtocol.c | 12 ++++++------
 tests/examples/c/apitest.c            |  8 +++++---
 2 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index 4b9191a91f..1fde741c2b 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -540,13 +540,13 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
 
   for (int i = 0; i < numPoint; ++i) {
     TAOS_SML_DATA_POINT* point = &points[i];
-    SSmlSTableSchema** ppStableSchema = taosHashGet(sname2shema, point->stableName, TSDB_TABLE_NAME_LEN);
+    size_t stableNameLen = strlen(point->stableName);
+    SSmlSTableSchema** ppStableSchema = taosHashGet(sname2shema, point->stableName, stableNameLen);
     SSmlSTableSchema* pStableSchema = NULL;
     if (ppStableSchema) {
       pStableSchema= *ppStableSchema;
     } else {
       SSmlSTableSchema schema;
-      size_t stableNameLen = strlen(point->stableName);
       strncpy(schema.sTableName, point->stableName, stableNameLen);
       schema.sTableName[stableNameLen] = '\0';
       schema.fields = taosArrayInit(64, sizeof(SSchema));
@@ -730,13 +730,13 @@ int32_t parseItemValue(SLPItem* item, LPItemKind kind) {
       item->length = (int16_t)tDataTypes[item->type].bytes;
       item->value = malloc(item->length);
       char* endptr = NULL;
-      *(item->value) = strtoll(sv, &endptr, 10);
+      *(int64_t*)(item->value) = strtoll(sv, &endptr, 10);
     } else {
       item->type = TSDB_DATA_TYPE_DOUBLE;
       item->length = (int16_t)tDataTypes[item->type].bytes;
       item->value = malloc(item->length);
       char* endptr = NULL;
-      *(item->value) = strtold(sv, &endptr);
+      *(double*)(item->value) = strtold(sv, &endptr);
     }
   } else if ((sv[0] == 'L' && sv[1] =='"') || sv[0] == '"' ) {
     if (sv[0] == 'L') {
@@ -744,7 +744,7 @@ int32_t parseItemValue(SLPItem* item, LPItemKind kind) {
       uint32_t bytes = item->valueToken.n - 3;
       item->length = bytes;
       item->value = malloc(bytes);
-      memcpy(item->value, sv+1, bytes);
+      memcpy(item->value, sv+2, bytes);
     } else if (sv[0]=='"'){
       item->type = TSDB_DATA_TYPE_BINARY;
       uint32_t bytes = item->valueToken.n - 2;
@@ -756,7 +756,7 @@ int32_t parseItemValue(SLPItem* item, LPItemKind kind) {
     item->type = TSDB_DATA_TYPE_BOOL;
     item->length = tDataTypes[item->type].bytes;
     item->value = malloc(tDataTypes[item->type].bytes);
-    *(item->value) = tolower(sv[0])=='t' ? TSDB_TRUE : TSDB_FALSE;
+    *(uint8_t*)(item->value) = tolower(sv[0])=='t' ? TSDB_TRUE : TSDB_FALSE;
   }
   return 0;
 }
diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index dc77677774..04a03df6fa 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -952,9 +952,11 @@ void verify_stream(TAOS* taos) {
 int32_t verify_schema_less(TAOS* taos) {
   prepare_data(taos);
   char* lines[] = {
-      "st,t1=3i,t2=4,t3=\"t3\" c1=3i,c3=L\"passit\",c2=false,c4=4 1626006833639162922"
+      "st,t1=3i,t2=4,t3=\"t3\" c1=3i,c3=L\"passit\",c2=false,c4=4 1626006833639",
+      "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833640",
+      "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833642"
   };
-  int code = taos_insert_by_lines(taos, lines , 1);
+  int code = taos_insert_by_lines(taos, lines , 2);
   return code;
 }
 
@@ -976,7 +978,7 @@ int main(int argc, char *argv[]) {
   info = taos_get_client_info(taos);
   printf("client info: %s\n", info);
 
-  printf("************  verify query  *************\n");
+  printf("************  verify shemaless  *************\n");
   int code = verify_schema_less(taos);
   if (code == 0) {
     return code;

From 4a75ebe4afacbcce488ec35fbdefc5e900ca781f Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Mon, 12 Jul 2021 09:17:15 +0800
Subject: [PATCH 23/70] create child table with tags

---
 src/client/src/tscParseLineProtocol.c | 87 +++++++++++++++++----------
 tests/examples/c/apitest.c            |  2 +-
 2 files changed, 57 insertions(+), 32 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index 1fde741c2b..dd0e64ba84 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -377,39 +377,26 @@ int32_t getChildTableName(TAOS_SML_DATA_POINT* point, char* tableName, int* tabl
   return 0;
 }
 
-int32_t getPreparedSQL(const char* sTableName, SArray* tagsSchema, SArray* colsSchema, char* result, int16_t freeBytes) {
+int32_t creatChildTableIfNotExists(TAOS* taos, const char* cTableName, const char* sTableName, SArray* tagsSchema, SArray* tagsBind) {
   size_t numTags = taosArrayGetSize(tagsSchema);
-  size_t numCols = taosArrayGetSize(colsSchema);
-  sprintf(result, "insert into ? using %s", sTableName);
+  char sql[TSDB_MAX_BINARY_LEN] = {0};
+  int freeBytes = TSDB_MAX_BINARY_LEN;
+  sprintf(sql, "create table if not exists %s using %s", cTableName, sTableName);
 
-//  snprintf(result+strlen(result), freeBytes-strlen(result), "(");
-//  for (int i = 0; i < numTags; ++i) {
-//    SSchema* tagSchema = taosArrayGet(tagsSchema, i);
-//    snprintf(result+strlen(result), freeBytes-strlen(result), "%s,", tagSchema->name);
-//  }
-//  snprintf(result + strlen(result)-1, freeBytes-strlen(result)+1, ")");
+  snprintf(sql+strlen(sql), freeBytes-strlen(sql), "(");
+  for (int i = 0; i < numTags; ++i) {
+    SSchema* tagSchema = taosArrayGet(tagsSchema, i);
+    snprintf(sql+strlen(sql), freeBytes-strlen(sql), "%s,", tagSchema->name);
+  }
+  snprintf(sql + strlen(sql) - 1, freeBytes-strlen(sql)+1, ")");
 
-  snprintf(result + strlen(result), freeBytes-strlen(result), " tags (");
+  snprintf(sql + strlen(sql), freeBytes-strlen(sql), " tags (");
 
   for (int i = 0; i < numTags; ++i) {
-    snprintf(result+strlen(result), freeBytes-strlen(result), "?,");
+    snprintf(sql+strlen(sql), freeBytes-strlen(sql), "?,");
   }
-  snprintf(result + strlen(result)-1, freeBytes-strlen(result)+1, ") (");
+  snprintf(sql + strlen(sql) - 1, freeBytes-strlen(sql)+1, ")");
 
-  for (int i = 0; i < numCols; ++i) {
-    SSchema* colSchema = taosArrayGet(colsSchema, i);
-    snprintf(result+strlen(result), freeBytes-strlen(result), "%s,", colSchema->name);
-  }
-  snprintf(result + strlen(result)-1, freeBytes-strlen(result)+1, ") values (");
-
-  for (int i = 0; i < numCols; ++i) {
-    snprintf(result+strlen(result), freeBytes-strlen(result), "?,");
-  }
-  snprintf(result + strlen(result)-1, freeBytes-strlen(result)+1, ")");
-  return 0;
-}
-
-int32_t insertBatch(TAOS* taos, char* sql, char* cTableName, SArray* tagsBind, SArray* rowsBind) {
   TAOS_STMT* stmt = taos_stmt_init(taos);
   int32_t code;
   code = taos_stmt_prepare(stmt, sql, strlen(sql));
@@ -418,7 +405,47 @@ int32_t insertBatch(TAOS* taos, char* sql, char* cTableName, SArray* tagsBind, S
     return code;
   }
 
-  code = taos_stmt_set_tbname_tags(stmt, cTableName, TARRAY_GET_START(tagsBind));
+  code = taos_stmt_bind_param(stmt, TARRAY_GET_START(tagsBind));
+  if (code != 0) {
+    printf("%s", taos_stmt_errstr(stmt));
+    return code;
+  }
+
+  code = taos_stmt_execute(stmt);
+  if (code != 0) {
+    printf("%s", taos_stmt_errstr(stmt));
+    return code;
+  }
+  TAOS_RES* res = taos_stmt_use_result(stmt);
+  return taos_errno(res);
+}
+
+int32_t insertBatch(TAOS* taos,  char* cTableName, SArray* colsSchema, SArray* rowsBind) {
+  size_t numCols = taosArrayGetSize(colsSchema);
+  char sql[TSDB_MAX_BINARY_LEN];
+  int32_t freeBytes = TSDB_MAX_BINARY_LEN;
+  sprintf(sql, "insert into ? (");
+
+  for (int i = 0; i < numCols; ++i) {
+    SSchema* colSchema = taosArrayGet(colsSchema, i);
+    snprintf(sql+strlen(sql), freeBytes-strlen(sql), "%s,", colSchema->name);
+  }
+  snprintf(sql + strlen(sql)-1, freeBytes-strlen(sql)+1, ") values (");
+
+  for (int i = 0; i < numCols; ++i) {
+    snprintf(sql+strlen(sql), freeBytes-strlen(sql), "?,");
+  }
+  snprintf(sql + strlen(sql)-1, freeBytes-strlen(sql)+1, ")");
+
+  TAOS_STMT* stmt = taos_stmt_init(taos);
+  int32_t code;
+  code = taos_stmt_prepare(stmt, sql, strlen(sql));
+  if (code != 0) {
+    printf("%s", taos_stmt_errstr(stmt));
+    return code;
+  }
+
+  code = taos_stmt_set_tbname(stmt, cTableName);
   if (code != 0) {
     printf("%s", taos_stmt_errstr(stmt));
     return code;
@@ -478,7 +505,6 @@ int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints)
     TAOS_SML_DATA_POINT * point = taosArrayGetP(cTablePoints, 0);
     int32_t numTags = taosArrayGetSize(point->schema->tags);
     int32_t numCols = taosArrayGetSize(point->schema->fields);
-    char* stableName = point->stableName;
     char* ctableName = point->childTableName;
 
     SArray* tagBinds = taosArrayInit(numTags, sizeof(TAOS_BIND));
@@ -523,9 +549,8 @@ int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints)
       taosArrayPush(rowsBind, &colBinds);
     }
 
-    char sql[TSDB_MAX_BINARY_LEN];
-    getPreparedSQL(stableName, point->schema->tags, point->schema->fields, sql, TSDB_MAX_BINARY_LEN);
-    insertBatch(taos, sql, ctableName, tagBinds, rowsBind);
+    creatChildTableIfNotExists(taos, point->childTableName, point->stableName, point->schema->tags, tagBinds);
+    insertBatch(taos, ctableName, point->schema->fields, rowsBind);
 
     pCTablePoints = taosHashIterate(cname2points, pCTablePoints);
   }
diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index 04a03df6fa..5272dafaf1 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -956,7 +956,7 @@ int32_t verify_schema_less(TAOS* taos) {
       "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833640",
       "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833642"
   };
-  int code = taos_insert_by_lines(taos, lines , 2);
+  int code = taos_insert_by_lines(taos, lines , 3);
   return code;
 }
 

From 62e4b0b599ba7a066cd6a0be435c60bac3a3cabd Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Mon, 12 Jul 2021 10:16:30 +0800
Subject: [PATCH 24/70] add timestamp precision support

---
 src/client/src/tscParseLineProtocol.c | 39 ++++++++++++++++++++-------
 tests/examples/c/apitest.c            | 18 +++++++++----
 2 files changed, 42 insertions(+), 15 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index dd0e64ba84..c0cc2ea3ae 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -21,6 +21,7 @@ typedef struct  {
   SHashObj* fieldHash;
   SArray* tags; //SArray<SSchema>
   SArray* fields; //SArray<SSchema>
+  uint8_t precision;
 } SSmlSTableSchema;
 
 typedef struct {
@@ -117,6 +118,7 @@ int32_t loadTableMeta(TAOS* taos, char* tableName, SSmlSTableSchema* schema) {
   taosHashGetClone(tscTableMetaInfo, fullTableName, strlen(fullTableName), NULL, tableMeta, -1);
 
   tstrncpy(schema->sTableName, tableName, strlen(tableName)+1);
+  schema->precision = tableMeta->tableInfo.precision;
   for (int i=0; i<tableMeta->tableInfo.numOfColumns; ++i) {
     SSchema field;
     tstrncpy(field.name, tableMeta->schema[i].name, strlen(tableMeta->schema[i].name)+1);
@@ -486,6 +488,25 @@ int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints)
       strncpy(point->childTableName, childTableName, tableNameLen);
       point->childTableName[tableNameLen] = '\0';
     }
+
+    for (int j = 0; j < point->tagNum; ++j) {
+      TAOS_SML_KV* kv =  point->tags + j;
+      if (kv->type == TSDB_DATA_TYPE_TIMESTAMP) {
+        int64_t ts = *(int64_t*)(kv->value);
+        ts = convertTimePrecision(ts, TSDB_TIME_PRECISION_NANO, point->schema->precision);
+        *(int64_t*)(kv->value) = ts;
+      }
+    }
+
+    for (int j = 0; j < point->fieldNum; ++j) {
+      TAOS_SML_KV* kv =  point->fields + j;
+      if (kv->type == TSDB_DATA_TYPE_TIMESTAMP) {
+        int64_t ts = *(int64_t*)(kv->value);
+        ts = convertTimePrecision(ts, TSDB_TIME_PRECISION_NANO, point->schema->precision);
+        *(int64_t*)(kv->value) = ts;
+      }
+    }
+
     SArray* cTablePoints = NULL;
     SArray** pCTablePoints = taosHashGet(cname2points, point->childTableName, strlen(point->childTableName));
     if (pCTablePoints) {
@@ -596,7 +617,6 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
     point->schema = pStableSchema;
   }
 
-  SArray* schemaActions = taosArrayInit(32, sizeof(SSchemaAction));
   size_t numStable = taosArrayGetSize(stableArray);
   for (int i = 0; i < numStable; ++i) {
     SSmlSTableSchema* pointSchema = taosArrayGet(stableArray, i);
@@ -615,8 +635,10 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
       memcpy(schemaAction.createSTable.sTableName, pointSchema->sTableName, TSDB_TABLE_NAME_LEN);
       schemaAction.createSTable.tags = pointSchema->tags;
       schemaAction.createSTable.fields = pointSchema->fields;
-      taosArrayPush(schemaActions, &schemaAction);
-    }else if (code == TSDB_CODE_SUCCESS) {
+      applySchemaAction(taos, &schemaAction);
+      code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
+      pointSchema->precision = dbSchema.precision;
+    } else if (code == TSDB_CODE_SUCCESS) {
       size_t pointTagSize = taosArrayGetSize(pointSchema->tags);
       size_t pointFieldSize = taosArrayGetSize(pointSchema->fields);
 
@@ -629,7 +651,7 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
         bool actionNeeded = false;
         generateSchemaAction(pointTag, dbTagHash, true, pointSchema->sTableName, &schemaAction, &actionNeeded);
         if (actionNeeded) {
-          taosArrayPush(schemaActions, &schemaAction);
+          applySchemaAction(taos, &schemaAction);
         }
       }
 
@@ -643,19 +665,16 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
         bool actionNeeded = false;
         generateSchemaAction(pointCol, dbFieldHash, false, pointSchema->sTableName, &schemaAction, &actionNeeded);
         if (actionNeeded) {
-          taosArrayPush(schemaActions, &schemaAction);
+          applySchemaAction(taos, &schemaAction);
         }
       }
+
+      pointSchema->precision = dbSchema.precision;
     } else {
       return code;
     }
   }
 
-  for (int i = 0; i < taosArrayGetSize(schemaActions); ++i) {
-    SSchemaAction* action = taosArrayGet(schemaActions, i);
-    applySchemaAction(taos, action);
-  }
-
   insertPoints(taos, points, numPoint);
   return code;
 }
diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index 5272dafaf1..656d5fd217 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -12,7 +12,7 @@ static void prepare_data(TAOS* taos) {
   result = taos_query(taos, "drop database if exists test;");
   taos_free_result(result);
   usleep(100000);
-  result = taos_query(taos, "create database test;");
+  result = taos_query(taos, "create database test precision 'us';");
   taos_free_result(result);
   usleep(100000);
   taos_select_db(taos, "test");
@@ -950,11 +950,19 @@ void verify_stream(TAOS* taos) {
 }
 
 int32_t verify_schema_less(TAOS* taos) {
-  prepare_data(taos);
+  TAOS_RES *result;
+  result = taos_query(taos, "drop database if exists test;");
+  taos_free_result(result);
+  usleep(100000);
+  result = taos_query(taos, "create database test precision 'us';");
+  taos_free_result(result);
+  usleep(100000);
+  taos_select_db(taos, "test");
+
   char* lines[] = {
-      "st,t1=3i,t2=4,t3=\"t3\" c1=3i,c3=L\"passit\",c2=false,c4=4 1626006833639",
-      "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833640",
-      "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833642"
+      "st,t1=3i,t2=4,t3=\"t3\" c1=3i,c3=L\"passit\",c2=false,c4=4 1626006833639000000",
+      "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833640000000",
+      "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833642000000"
   };
   int code = taos_insert_by_lines(taos, lines , 3);
   return code;

From d8c57f0be0bb51f2a81157f12d8885f5afa70f23 Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Mon, 12 Jul 2021 10:30:54 +0800
Subject: [PATCH 25/70] fixing exsiting stable

---
 src/client/src/tscParseLineProtocol.c | 2 +-
 tests/examples/c/apitest.c            | 6 ++++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index c0cc2ea3ae..61f9cd9e76 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -225,7 +225,7 @@ int32_t addTaosFieldToHashAndArray(TAOS_SML_KV* smlKv, SHashObj* hash, SArray* a
 int32_t generateSchemaAction(SSchema* pointColField, SHashObj* dbAttrHash, bool isTag, char sTableName[],
                                        SSchemaAction* action, bool* actionNeeded) {
   SSchema** ppDbAttr = taosHashGet(dbAttrHash, pointColField->name, strlen(pointColField->name));
-  if (*ppDbAttr) {
+  if (ppDbAttr) {
     SSchema* dbAttr = *ppDbAttr;
     if (pointColField->type != dbAttr->type) {
       //todo error
diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index 656d5fd217..5cb3f5762a 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -958,13 +958,15 @@ int32_t verify_schema_less(TAOS* taos) {
   taos_free_result(result);
   usleep(100000);
   taos_select_db(taos, "test");
+  result = taos_query(taos, "create stable ste(ts timestamp, f int) tags(t1 bigint)");
 
   char* lines[] = {
       "st,t1=3i,t2=4,t3=\"t3\" c1=3i,c3=L\"passit\",c2=false,c4=4 1626006833639000000",
       "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833640000000",
-      "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833642000000"
+      "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833642000000",
+      "ste,t2=5,t3=L\"ste\" c1=true,c2=4 1626056811823316532"
   };
-  int code = taos_insert_by_lines(taos, lines , 3);
+  int code = taos_insert_by_lines(taos, lines , 4);
   return code;
 }
 

From 958b89b4630c11c3c2c360d7d757c82213862461 Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Mon, 12 Jul 2021 11:27:34 +0800
Subject: [PATCH 26/70] before tsim/log/memory leak handling

---
 tests/examples/c/apitest.c | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index 5cb3f5762a..409140e0f2 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -957,16 +957,20 @@ int32_t verify_schema_less(TAOS* taos) {
   result = taos_query(taos, "create database test precision 'us';");
   taos_free_result(result);
   usleep(100000);
+
   taos_select_db(taos, "test");
   result = taos_query(taos, "create stable ste(ts timestamp, f int) tags(t1 bigint)");
+  taos_free_result(result);
+  usleep(100000);
 
   char* lines[] = {
       "st,t1=3i,t2=4,t3=\"t3\" c1=3i,c3=L\"passit\",c2=false,c4=4 1626006833639000000",
       "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833640000000",
       "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833642000000",
-      "ste,t2=5,t3=L\"ste\" c1=true,c2=4 1626056811823316532"
+      "ste,t2=5,t3=L\"ste\" c1=true,c2=4,c3=\"iam\" 1626056811823316532",
+      "ste,t2=5,t3=L\"ste2\" c3=\"iamszhou\",c4=false 1626056811843316532"
   };
-  int code = taos_insert_by_lines(taos, lines , 4);
+  int code = taos_insert_by_lines(taos, lines , 5);
   return code;
 }
 

From 64fb524796c4746a1a75f5a5fac29021305686d1 Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Tue, 6 Jul 2021 18:05:27 +0800
Subject: [PATCH 27/70] develop schemaless

---
 src/client/src/tscParseLineProtocol.c | 731 ++++++++++++++++++++++++++
 1 file changed, 731 insertions(+)
 create mode 100644 src/client/src/tscParseLineProtocol.c

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
new file mode 100644
index 0000000000..79e8955f9a
--- /dev/null
+++ b/src/client/src/tscParseLineProtocol.c
@@ -0,0 +1,731 @@
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "os.h"
+#include "osString.h"
+#include "ttype.h"
+#include "tmd5.h"
+#include "tstrbuild.h"
+#include "tname.h"
+#include "taos.h"
+#include "tsclient.h"
+#include "tscLog.h"
+#include "hash.h"
+#include "tskiplist.h"
+#include "tscUtil.h"
+
+typedef enum {
+  LP_ITEM_TAG,
+  LP_ITEM_FIELD
+} LPItemKind;
+
+typedef struct  {
+  SStrToken key;
+  SStrToken value;
+
+  char name[TSDB_COL_NAME_LEN];
+  int8_t type;
+  int16_t bytes;
+
+  char* payload;
+}SLPItem;
+
+typedef struct {
+  SStrToken measToken;
+  SStrToken tsToken;
+
+  char sTableName[TSDB_TABLE_NAME_LEN];
+  SArray* tags;
+  SArray* fields;
+  int64_t ts;
+
+} SLPPoint;
+
+typedef enum {
+  LP_MEASUREMENT,
+  LP_TAG_KEY,
+  LP_TAG_VALUE,
+  LP_FIELD_KEY,
+  LP_FIELD_VALUE
+} LPPart;
+
+int32_t scanToCommaOrSpace(SStrToken s, int32_t start, int32_t* index, LPPart part) {
+  for (int32_t i = start; i < s.n; ++i) {
+    if (s.z[i] == ',' || s.z[i] == ' ') {
+      *index = i;
+      return 0;
+    }
+  }
+  return -1;
+}
+
+int32_t scanToEqual(SStrToken s, int32_t start, int32_t* index) {
+  for (int32_t i = start; i < s.n; ++i) {
+    if (s.z[i] == '=') {
+      *index = i;
+      return 0;
+    }
+  }
+  return -1;
+}
+
+int32_t setPointMeasurement(SLPPoint* point, SStrToken token) {
+  point->measToken = token;
+  if (point->measToken.n < TSDB_TABLE_NAME_LEN) {
+    strncpy(point->sTableName, point->measToken.z, point->measToken.n);
+    point->sTableName[point->measToken.n] = '\0';
+  }
+  return 0;
+}
+
+int32_t setItemKey(SLPItem* item, SStrToken key, LPPart part) {
+  item->key = key;
+  if (item->key.n < TSDB_COL_NAME_LEN) {
+    strncpy(item->name, item->key.z, item->key.n);
+    item->name[item->key.n] = '\0';
+  }
+  return 0;
+}
+
+int32_t setItemValue(SLPItem* item, SStrToken value, LPPart part) {
+  item->value = value;
+  return 0;
+}
+
+int32_t parseItemValue(SLPItem* item, LPItemKind kind) {
+  char* sv = item->value.z;
+  char* last = item->value.z + item->value.n - 1;
+
+  if (isdigit(sv[0]) || sv[0] == '-') {
+    if (*last == 'i') {
+      item->type = TSDB_DATA_TYPE_BIGINT;
+      item->bytes = (int16_t)tDataTypes[item->type].bytes;
+      item->payload = malloc(item->bytes);
+      char* endptr = NULL;
+      *(item->payload) = strtoll(sv, &endptr, 10);
+    } else {
+      item->type = TSDB_DATA_TYPE_DOUBLE;
+      item->bytes = (int16_t)tDataTypes[item->type].bytes;
+      item->payload = malloc(item->bytes);
+      char* endptr = NULL;
+      *(item->payload) = strtold(sv, &endptr);
+    }
+  } else if ((sv[0] == 'L' && sv[1] =='"') || sv[0] == '"' ) {
+    if (sv[0] == 'L') {
+      item->type = TSDB_DATA_TYPE_NCHAR;
+      uint32_t bytes = item->value.n - 3;
+//      uint32_t len = bytes;
+//      char* ucs = malloc(len);
+//      int32_t ncharBytes = 0;
+//      taosMbsToUcs4(sv+2, len, ucs, len, &ncharBytes);
+//      item->bytes = ncharBytes;
+//      item->payload = malloc(ncharBytes);
+//      memcpy(item->payload, ucs, ncharBytes);
+//      free(ucs);
+      item->bytes = bytes;
+      item->payload = malloc(bytes);
+      memcpy(item->payload, sv+1, bytes);
+    } else if (sv[0]=='"'){
+      item->type = TSDB_DATA_TYPE_BINARY;
+      uint32_t bytes = item->value.n - 2;
+      item->bytes = bytes;
+      item->payload = malloc(bytes);
+      memcpy(item->payload, sv+1, bytes);
+    }
+  } else if (sv[0] == 't' || sv[0] == 'f' || sv[0]=='T' || sv[0] == 'F') {
+    item->type = TSDB_DATA_TYPE_BOOL;
+    item->bytes = tDataTypes[item->type].bytes;
+    item->payload = malloc(tDataTypes[item->type].bytes);
+    *(item->payload) = tolower(sv[0])=='t' ? true : false;
+  }
+  return 0;
+}
+
+int32_t compareLPItemKey(const void* p1, const void* p2) {
+  const SLPItem* t1 = p1;
+  const SLPItem* t2 = p2;
+  uint32_t min = (t1->key.n < t2->key.n) ? t1->key.n : t2->key.n;
+  int res = strncmp(t1->key.z, t2->key.z, min);
+  if (res != 0) {
+    return res;
+  } else {
+    return (int)(t1->key.n) - (int)(t2->key.n);
+  }
+}
+
+int32_t setPointTimeStamp(SLPPoint* point, SStrToken tsToken) {
+  point->tsToken = tsToken;
+  return 0;
+}
+
+int32_t parsePointTime(SLPPoint* point) {
+  if (point->tsToken.n <= 0) {
+    point->ts = taosGetTimestampNs();
+  } else {
+    char* endptr = NULL;
+    point->ts = strtoll(point->tsToken.z, &endptr, 10);
+  }
+  return 0;
+}
+
+int32_t tscParseLine(SStrToken line, SLPPoint* point) {
+  int32_t pos = 0;
+
+  int32_t start = 0;
+  int32_t err = scanToCommaOrSpace(line, start, &pos, LP_MEASUREMENT);
+  if (err != 0) {
+    tscError("a");
+    return err;
+  }
+
+  SStrToken measurement = {.z = line.z+start, .n = pos-start};
+  setPointMeasurement(point, measurement);
+  point->tags = taosArrayInit(64, sizeof(SLPItem));
+  start = pos + 1;
+  while (line.z[start] == ',') {
+    SLPItem item;
+
+    err = scanToEqual(line, start, &pos);
+    if (err != 0) {
+      tscError("b");
+      goto error;
+    }
+
+    SStrToken tagKey = {.z = line.z + start, .n = pos-start};
+    setItemKey(&item, tagKey, LP_TAG_KEY);
+
+    start = pos + 1;
+    err = scanToCommaOrSpace(line, start, &pos, LP_TAG_VALUE);
+    if (err != 0) {
+      tscError("c");
+      goto error;
+    }
+
+    SStrToken tagValue = {.z = line.z + start, .n = pos-start};
+    setItemValue(&item, tagValue, LP_TAG_VALUE);
+
+    parseItemValue(&item, LP_ITEM_TAG);
+    taosArrayPush(point->tags, &item);
+
+    start = pos + 1;
+  }
+
+  taosArraySort(point->tags, compareLPItemKey);
+
+  point->fields = taosArrayInit(64, sizeof(SLPItem));
+  do {
+    SLPItem item;
+    err = scanToEqual(line, start, &pos);
+    if (err != 0) {
+      goto error;
+    }
+    SStrToken fieldKey = {.z = line.z + start, .n = pos- start};
+    setItemKey(&item, fieldKey, LP_FIELD_KEY);
+
+    start = pos + 1;
+    err = scanToCommaOrSpace(line, start, &pos, LP_FIELD_VALUE);
+    if (err != 0) {
+      goto error;
+    }
+    SStrToken fieldValue = {.z = line.z + start, .n = pos - start};
+    setItemValue(&item, fieldValue, LP_TAG_VALUE);
+
+    parseItemValue(&item, LP_ITEM_FIELD);
+    taosArrayPush(point->fields, &item);
+
+    start = pos + 1;
+  } while (line.z[pos] == ',');
+
+  taosArraySort(point->fields, compareLPItemKey);
+
+  SStrToken tsToken = {.z = line.z+start, .n = line.n-start};
+  setPointTimeStamp(point, tsToken);
+  parsePointTime(point);
+
+  goto done;
+
+error:
+  // free array
+  return err;
+done:
+  return 0;
+}
+
+
+int32_t tscParseLines(char* lines[], int numLines, SArray* points, SArray* failedLines) {
+  for (int32_t i = 0; i < numLines; ++i) {
+    SStrToken tkLine = {.z = lines[i], .n = strlen(lines[i])+1};
+    SLPPoint point;
+    tscParseLine(tkLine, &point);
+    taosArrayPush(points, &point);
+  }
+  return 0;
+}
+
+TAOS_RES* taos_insert_by_lines(TAOS* taos, char* lines[], int numLines) {
+  SArray* points = taosArrayInit(numLines, sizeof(SLPPoint));
+  tscParseLines(lines, numLines, points, NULL);
+
+
+  return NULL;
+}
+//=================================================================================================
+
+typedef struct {
+  char* key;
+  uint8_t type;
+  int16_t length;
+  char* value;
+} TAOS_SML_KV;
+
+typedef struct {
+  char* stableName;
+
+  char* childTableName;
+  TAOS_SML_KV* tags;
+  int tagNum;
+
+  // first kv must be timestamp
+  TAOS_SML_KV* fields;
+  int fieldNum;
+
+} TAOS_SML_DATA_POINT;
+
+typedef struct  {
+  char sTableName[TSDB_TABLE_NAME_LEN];
+  SHashObj* tagHash;
+  SHashObj* fieldHash;
+  SArray* tags; //SArray<SSchema>
+  SArray* fields; //SArray<TAOS_SFIELD>
+} SSmlSTableSchema;
+
+
+int compareSmlColKv(const void* p1, const void* p2) {
+  TAOS_SML_KV* kv1 = (TAOS_SML_KV*)p1;
+  TAOS_SML_KV* kv2 = (TAOS_SML_KV*)p2;
+  int kvLen1 = (int)strlen(kv1->key);
+  int kvLen2 = (int)strlen(kv2->key);
+  int res = strncasecmp(kv1->key, kv2->key, MIN(kvLen1, kvLen2));
+  if (res != 0) {
+    return res;
+  } else {
+    return kvLen1-kvLen2;
+  }
+}
+
+int32_t getChildTableName(TAOS_SML_DATA_POINT* point, char* tableName, int* tableNameLen) {
+    qsort(point->tags, point->tagNum, sizeof(TAOS_SML_KV), compareSmlColKv);
+
+    SStringBuilder sb; memset(&sb, 0, sizeof(sb));
+    taosStringBuilderAppendString(&sb, point->stableName);
+    for (int j = 0; j < point->tagNum; ++j) {
+      TAOS_SML_KV* tagKv = point->tags + j;
+      taosStringBuilderAppendChar(&sb, ',');
+      taosStringBuilderAppendString(&sb, tagKv->key);
+      taosStringBuilderAppendChar(&sb, '=');
+      taosStringBuilderAppend(&sb, tagKv->value, tagKv->length);
+    }
+    size_t len = 0;
+    char* keyJoined = taosStringBuilderGetResult(&sb, &len);
+    MD5_CTX context;
+    MD5Init(&context);
+    MD5Update(&context, (uint8_t *)keyJoined, (uint32_t)len);
+    MD5Final(&context);
+    *tableNameLen = snprintf(tableName, *tableNameLen,
+             "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", context.digest[0],
+             context.digest[1], context.digest[2], context.digest[3], context.digest[4], context.digest[5], context.digest[6],
+             context.digest[7], context.digest[8], context.digest[9], context.digest[10], context.digest[11],
+             context.digest[12], context.digest[13], context.digest[14], context.digest[15]);
+    return 0;
+}
+
+int32_t loadTableMeta(TAOS* taos, char* tableName, SSmlSTableSchema* schema) {
+  int32_t code = 0;
+
+  STscObj *pObj = (STscObj *)taos;
+  if (pObj == NULL || pObj->signature != pObj) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return TSDB_CODE_TSC_DISCONNECTED;
+  }
+
+  char sql[256];
+  snprintf(sql, 256, "describe %s", tableName);
+  TAOS_RES* res = taos_query(taos, sql);
+  code = taos_errno(res);
+  if (code != 0) {
+    taos_free_result(res);
+    return code;
+  }
+  taos_free_result(res);
+
+  SSqlObj* pSql = calloc(1, sizeof(SSqlObj));
+  pSql->pTscObj = taos;
+  pSql->signature = pSql;
+  pSql->fp = NULL;
+
+  SStrToken tableToken = {.z=tableName, .n=strlen(tableName), .type=TK_ID};
+  tGetToken(tableName, &tableToken.type);
+  // Check if the table name available or not
+  if (tscValidateName(&tableToken) != TSDB_CODE_SUCCESS) {
+    code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
+    sprintf(pSql->cmd.payload, "table name is invalid");
+    return code;
+  }
+
+  SName sname = {0};
+  if ((code = tscSetTableFullName(&sname, &tableToken, pSql)) != TSDB_CODE_SUCCESS) {
+    return code;
+  }
+
+  char  fullTableName[TSDB_TABLE_FNAME_LEN] = {0};
+  memset(fullTableName, 0, tListLen(fullTableName));
+  tNameExtractFullName(&sname, fullTableName);
+
+  if (code != TSDB_CODE_SUCCESS) {
+    tscFreeSqlObj(pSql);
+    return code;
+  }
+
+  tscFreeSqlObj(pSql);
+
+
+  uint32_t size = tscGetTableMetaMaxSize();
+  STableMeta* tableMeta = calloc(1, size);
+  taosHashGetClone(tscTableMetaInfo, fullTableName, strlen(fullTableName), NULL, tableMeta, -1);
+
+  tstrncpy(schema->sTableName, tableName, strlen(tableName));
+  for (int i=0; i<tableMeta->tableInfo.numOfColumns; ++i) {
+    SSchema field;
+    tstrncpy(field.name, tableMeta->schema[i].name, strlen(tableMeta->schema[i].name));
+    field.type = tableMeta->schema[i].type;
+    field.bytes = tableMeta->schema[i].bytes;
+    SSchema* pField = taosArrayPush(schema->fields, &field);
+    taosHashPut(schema->fieldHash, field.name, strlen(field.name), &pField, POINTER_BYTES);
+  }
+
+  for (int i=0; i<tableMeta->tableInfo.numOfTags; ++i) {
+    int j = i + tableMeta->tableInfo.numOfColumns;
+    SSchema field;
+    tstrncpy(field.name, tableMeta->schema[j].name, strlen(tableMeta->schema[j].name));
+    field.type = tableMeta->schema[j].type;
+    field.bytes = tableMeta->schema[j].bytes;
+    SSchema* pField = taosArrayPush(schema->tags, &field);
+    taosHashPut(schema->tagHash, field.name, strlen(field.name), &pField, POINTER_BYTES);
+  }
+
+  return code;
+
+}
+
+typedef enum {
+  SCHEMA_ACTION_CREATE_STABLE,
+  SCHEMA_ACTION_ADD_COLUMN,
+  SCHEMA_ACTION_ADD_TAG,
+  SCHEMA_ACTION_CHANGE_COLUMN_SIZE,
+  SCHEMA_ACTION_CHANGE_TAG_SIZE,
+  SCHEMA_ACTION_CREATE_CTABLE
+} ESchemaAction;
+
+typedef struct {
+  char sTableName[TSDB_TABLE_NAME_LEN];
+  SArray* tags; //SArray<SSchema>
+  SArray* fields; //SArray<SSchema>
+} SCreateSTableActionInfo;
+
+typedef struct {
+  char sTableName[TSDB_TABLE_NAME_LEN];
+  SSchema* field;
+} SAlterSTableActionInfo;
+
+typedef struct {
+  char sTableName[TSDB_TABLE_NAME_LEN];
+  char cTableName[TSDB_TABLE_NAME_LEN];
+  TAOS_SML_KV* tags;
+  int tagNum;
+} SCreateCTableActionInfo;
+
+typedef struct {
+  ESchemaAction action;
+  union {
+    SCreateSTableActionInfo createSTable;
+    SAlterSTableActionInfo alterSTable;
+    SCreateCTableActionInfo createCTable;
+  };
+} SSchemaAction;
+
+int32_t getFieldBytesFromSmlKv(TAOS_SML_KV* kv, int32_t* bytes) {
+  if (!IS_VAR_DATA_TYPE(kv->type)) {
+    *bytes = tDataTypes[kv->type].bytes;
+  } else {
+    if (kv->type == TSDB_DATA_TYPE_NCHAR) {
+      char* ucs = malloc(kv->length * TSDB_NCHAR_SIZE + 1);
+      int32_t bytesNeeded = 0;
+      //todo check conversion succeed
+      taosMbsToUcs4(kv->value, kv->length, ucs, kv->length * TSDB_NCHAR_SIZE, &bytesNeeded);
+      free(ucs);
+      *bytes =  bytesNeeded + VARSTR_HEADER_SIZE;
+
+    } else if (kv->type == TSDB_DATA_TYPE_BINARY) {
+      *bytes = kv->length + VARSTR_HEADER_SIZE;
+    }
+  }
+  return 0;
+}
+
+int32_t addTaosFieldToHashAndArray(TAOS_SML_KV* smlKv, SHashObj* hash, SArray* array) {
+  SSchema* pField = NULL;
+  SSchema** ppField = taosHashGet(hash, smlKv->key, strlen(smlKv->key));
+  if (ppField) {
+    pField = *ppField;
+
+    if (pField->type != smlKv->type) {
+      //TODO:
+      tscError("type mismatch");
+      return -1;
+    }
+
+    int32_t bytes = 0;
+    getFieldBytesFromSmlKv(smlKv, &bytes);
+    pField->bytes = MAX(pField->bytes, bytes);
+
+  } else {
+    SSchema field;
+    size_t tagKeyLen = strlen(smlKv->key);
+    strncpy(field.name, smlKv->key, tagKeyLen);
+    field.name[tagKeyLen] = '\0';
+    field.type = smlKv->type;
+
+    int32_t bytes = 0;
+    getFieldBytesFromSmlKv(smlKv, &bytes);
+    field.bytes = bytes;
+
+    pField = taosArrayPush(array, &field);
+    taosHashPut(hash, field.name, tagKeyLen, &pField, POINTER_BYTES);
+  }
+  return 0;
+}
+
+int32_t generateSchemaAction(SSchema* pointColField, SHashObj* dbAttrHash, bool isTag, char sTableName[],
+                                       SSchemaAction* action, bool* actionNeeded) {
+  SSchema** ppDbAttr = taosHashGet(dbAttrHash, pointColField->name, strlen(pointColField->name));
+  if (*ppDbAttr) {
+    SSchema* dbAttr = *ppDbAttr;
+    if (pointColField->type != dbAttr->type) {
+      //todo error
+      return -5;
+    }
+
+    if (IS_VAR_DATA_TYPE(pointColField->type) && (pointColField->bytes > dbAttr->bytes)) {
+      if (isTag) {
+        action->action = SCHEMA_ACTION_CHANGE_TAG_SIZE;
+      } else {
+        action->action = SCHEMA_ACTION_CHANGE_COLUMN_SIZE;
+      }
+      memset(&action->alterSTable, 0,  sizeof(SAlterSTableActionInfo));
+      memcpy(action->alterSTable.sTableName, sTableName, TSDB_TABLE_NAME_LEN);
+      action->alterSTable.field = pointColField;
+      *actionNeeded = true;
+    }
+  } else {
+    if (isTag) {
+      action->action = SCHEMA_ACTION_ADD_TAG;
+    } else {
+      action->action = SCHEMA_ACTION_ADD_COLUMN;
+    }
+    memset(&action->alterSTable, 0, sizeof(SAlterSTableActionInfo));
+    memcpy(action->alterSTable.sTableName, sTableName, TSDB_TABLE_NAME_LEN);
+    action->alterSTable.field = pointColField;
+    *actionNeeded = true;
+  }
+  return 0;
+}
+
+int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  SArray* stableArray = taosArrayInit(32, sizeof(SSmlSTableSchema)); // SArray<STableColumnsSchema>
+  SHashObj* sname2shema = taosHashInit(32,
+                                       taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+
+  for (int i = 0; i < numPoint; ++i) {
+    TAOS_SML_DATA_POINT* point = &points[i];
+    SSmlSTableSchema** ppStableSchema = taosHashGet(sname2shema, point->stableName, TSDB_TABLE_NAME_LEN);
+    SSmlSTableSchema* pStableSchema = NULL;
+    if (ppStableSchema) {
+      pStableSchema= *ppStableSchema;
+    } else {
+      SSmlSTableSchema schema;
+      size_t stableNameLen = strlen(point->stableName);
+      strncpy(schema.sTableName, point->stableName, stableNameLen);
+      schema.sTableName[stableNameLen] = '\0';
+      schema.fields = taosArrayInit(64, sizeof(SSchema));
+      schema.tags = taosArrayInit(8, sizeof(SSchema));
+      schema.tagHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+      schema.fieldHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+
+      pStableSchema = taosArrayPush(stableArray, &schema);
+      taosHashPut(sname2shema, schema.sTableName, stableNameLen, &pStableSchema, POINTER_BYTES);
+    }
+
+    for (int j = 0; j < point->tagNum; ++j) {
+      TAOS_SML_KV* tagKv = point->tags + j;
+      addTaosFieldToHashAndArray(tagKv, pStableSchema->tagHash, pStableSchema->tags);
+    }
+
+    for (int j = 0; j < point->fieldNum; ++j) {
+      TAOS_SML_KV* fieldKv = point->fields + j;
+      addTaosFieldToHashAndArray(fieldKv, pStableSchema->fieldHash, pStableSchema->fields);
+    }
+  }
+
+  SArray* schemaActions = taosArrayInit(32, sizeof(SSchemaAction));
+  size_t numStable = taosArrayGetSize(stableArray);
+  for (int i = 0; i < numStable; ++i) {
+    SSmlSTableSchema* pointSchema = taosArrayGet(stableArray, i);
+    SSmlSTableSchema  dbSchema = {0};
+    dbSchema.fields = taosArrayInit(64, sizeof(SSchema));
+    dbSchema.tags = taosArrayInit(8, sizeof(SSchema));
+    dbSchema.tagHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+    dbSchema.fieldHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+    code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
+    if (code == TSDB_CODE_MND_INVALID_TABLE_NAME) {
+      SSchemaAction schemaAction = {0};
+      schemaAction.action = SCHEMA_ACTION_CREATE_STABLE;
+      memset(&schemaAction.createSTable, 0, sizeof(SCreateSTableActionInfo));
+      memcpy(schemaAction.createSTable.sTableName, pointSchema->sTableName, TSDB_TABLE_NAME_LEN);
+      schemaAction.createSTable.tags = pointSchema->tags;
+      schemaAction.createSTable.fields = pointSchema->fields;
+      taosArrayPush(schemaActions, &schemaAction);
+    }else if (code == TSDB_CODE_SUCCESS) {
+      size_t pointTagSize = taosArrayGetSize(pointSchema->tags);
+      size_t pointFieldSize = taosArrayGetSize(pointSchema->fields);
+
+      SHashObj* dbTagHash = dbSchema.tagHash;
+      SHashObj* dbFieldHash = dbSchema.fieldHash;
+
+      for (int j = 0; j < pointTagSize; ++j) {
+        SSchema*            pointTag = taosArrayGet(pointSchema->tags, j);
+        SSchemaAction schemaAction = {0};
+        bool                   actionNeeded = false;
+        generateSchemaAction(pointTag, dbTagHash, true, pointSchema->sTableName, &schemaAction, &actionNeeded);
+        if (actionNeeded) {
+          taosArrayPush(schemaActions, &schemaAction);
+        }
+      }
+
+      for (int j = 0; j < pointFieldSize; ++j) {
+        SSchema*            pointCol = taosArrayGet(pointSchema->tags, j);
+        SSchemaAction schemaAction = {0};
+        bool                   actionNeeded = false;
+        generateSchemaAction(pointCol, dbFieldHash, false, pointSchema->sTableName, &schemaAction, &actionNeeded);
+        if (actionNeeded) {
+          taosArrayPush(schemaActions, &schemaAction);
+        }
+      }
+    } else {
+      return code;
+    }
+  }
+
+  return code;
+}
+
+
+int32_t buildColumnDescription(SSchema* field,
+                               char* buf, int32_t bufSize, int32_t* outBytes) {
+  uint8_t type = field->type;
+
+  if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {
+    int32_t bytes = field->bytes - VARSTR_HEADER_SIZE;
+    if (type == TSDB_DATA_TYPE_NCHAR) {
+      bytes =  bytes/TSDB_NCHAR_SIZE;
+    }
+    int out = snprintf(buf, bufSize,"%s %s(%d)",
+                       field->name,tDataTypes[field->type].name, bytes);
+    *outBytes = out;
+  } else {
+    int out = snprintf(buf, bufSize, "%s %s",
+                       field->name, tDataTypes[type].name);
+    *outBytes = out;
+  }
+
+  return 0;
+}
+
+int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
+  int32_t code = 0;
+  int32_t capacity = TSDB_MAX_BINARY_LEN;
+  int32_t outBytes = 0;
+  char *result = (char *)calloc(1, capacity);
+
+  switch (action->action) {
+    case SCHEMA_ACTION_ADD_COLUMN: {
+      int n = sprintf(result, "alter stable %s add column ", action->alterSTable.sTableName);
+      buildColumnDescription(action->alterSTable.field, result+n, capacity-n, &outBytes);
+      TAOS_RES* res = taos_query(taos, result); //TODO async doAsyncQuery
+      code = taos_errno(res);
+      break;
+    }
+    case SCHEMA_ACTION_ADD_TAG: {
+      int n = sprintf(result, "alter stable %s add tag ", action->alterSTable.sTableName);
+      buildColumnDescription(action->alterSTable.field,
+                             result+n, capacity-n, &outBytes);
+      TAOS_RES* res = taos_query(taos, result); //TODO async doAsyncQuery
+      code = taos_errno(res);
+      break;
+    }
+    case SCHEMA_ACTION_CHANGE_COLUMN_SIZE: {
+      int n = sprintf(result, "alter stable %s modify column ", action->alterSTable.sTableName);
+      buildColumnDescription(action->alterSTable.field, result+n,
+                             capacity-n, &outBytes);
+      TAOS_RES* res = taos_query(taos, result); //TODO async doAsyncQuery
+      code = taos_errno(res);
+    }
+    case SCHEMA_ACTION_CHANGE_TAG_SIZE: {
+      int n = sprintf(result, "alter stable %s modify tag ", action->alterSTable.sTableName);
+      buildColumnDescription(action->alterSTable.field, result+n,
+                             capacity-n, &outBytes);
+      TAOS_RES* res = taos_query(taos, result); //TODO async doAsyncQuery
+      code = taos_errno(res);
+      break;
+    }
+    case SCHEMA_ACTION_CREATE_STABLE: {
+      int n = sprintf(result, "create stable %s (", action->createSTable.sTableName);
+      char* pos = result + n; int freeBytes = capacity - n;
+      int numCols = taosArrayGetSize(action->createSTable.fields);
+      for (int32_t i = 0; i < numCols; ++i) {
+        SSchema* field = taosArrayGet(action->createSTable.fields, i);
+        buildColumnDescription(field, pos, freeBytes, &outBytes);
+        pos += outBytes; freeBytes -= outBytes;
+        *pos = ','; ++pos; --freeBytes;
+      }
+      --pos; ++freeBytes;
+      outBytes = snprintf(pos, freeBytes, ") tags (");
+      int numTags = taosArrayGetSize(action->createSTable.tags);
+      pos += outBytes; freeBytes -= outBytes;
+      for (int32_t i = 0; i < numTags; ++i) {
+        SSchema* field = taosArrayGet(action->createSTable.tags, i);
+        buildColumnDescription(field, pos, freeBytes, &outBytes);
+        pos += outBytes; freeBytes -= outBytes;
+        *pos = ','; ++pos; --freeBytes;
+      }
+      pos--; ++freeBytes;
+      outBytes = snprintf(pos, freeBytes, ")");
+      TAOS_RES* res = taos_query(taos, result);
+      code = taos_errno(res);
+      break;
+    }
+    case SCHEMA_ACTION_CREATE_CTABLE: {
+      
+      break;
+    }
+    default:
+      break;
+  }
+  free(result);
+  return code;
+}
+
+//todo: table/column length check
+//todo: type check
+//todo: taosmbs2ucs4 check

From ca52c73bdeb9064a573857501035c648787a3521 Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Fri, 9 Jul 2021 19:37:15 +0800
Subject: [PATCH 28/70] before taos_bind/taos_multi_bind generation

---
 src/client/src/tscParseLineProtocol.c | 99 +++++++++++++++++++++++++--
 1 file changed, 95 insertions(+), 4 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index 79e8955f9a..10d2429b5e 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -277,6 +277,9 @@ typedef struct {
   uint8_t type;
   int16_t length;
   char* value;
+
+  //===================================
+  SSchema* fieldSchema;
 } TAOS_SML_KV;
 
 typedef struct {
@@ -415,7 +418,6 @@ int32_t loadTableMeta(TAOS* taos, char* tableName, SSmlSTableSchema* schema) {
   }
 
   return code;
-
 }
 
 typedef enum {
@@ -465,7 +467,6 @@ int32_t getFieldBytesFromSmlKv(TAOS_SML_KV* kv, int32_t* bytes) {
       taosMbsToUcs4(kv->value, kv->length, ucs, kv->length * TSDB_NCHAR_SIZE, &bytesNeeded);
       free(ucs);
       *bytes =  bytesNeeded + VARSTR_HEADER_SIZE;
-
     } else if (kv->type == TSDB_DATA_TYPE_BINARY) {
       *bytes = kv->length + VARSTR_HEADER_SIZE;
     }
@@ -503,6 +504,9 @@ int32_t addTaosFieldToHashAndArray(TAOS_SML_KV* smlKv, SHashObj* hash, SArray* a
     pField = taosArrayPush(array, &field);
     taosHashPut(hash, field.name, tagKeyLen, &pField, POINTER_BYTES);
   }
+
+  smlKv->fieldSchema = pField;
+
   return 0;
 }
 
@@ -700,9 +704,11 @@ int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
         *pos = ','; ++pos; --freeBytes;
       }
       --pos; ++freeBytes;
+
       outBytes = snprintf(pos, freeBytes, ") tags (");
-      int numTags = taosArrayGetSize(action->createSTable.tags);
       pos += outBytes; freeBytes -= outBytes;
+
+      int numTags = taosArrayGetSize(action->createSTable.tags);
       for (int32_t i = 0; i < numTags; ++i) {
         SSchema* field = taosArrayGet(action->createSTable.tags, i);
         buildColumnDescription(field, pos, freeBytes, &outBytes);
@@ -716,7 +722,43 @@ int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
       break;
     }
     case SCHEMA_ACTION_CREATE_CTABLE: {
-      
+//      SCreateCTableActionInfo* pInfo = &action->createCTable;
+//      SArray* bindParams = taosArrayInit(2 + 2 * pInfo->tagNum, sizeof(TAOS_BIND));
+//      outBytes = sprintf(result, "create table ? using ?(");
+//      char* pos = result + outBytes; int32_t freeBytes = capacity-outBytes;
+//      uintptr_t lenSTableName = strlen(pInfo->sTableName);
+//      uintptr_t lenCTableName = strlen(pInfo->cTableName);
+//      TAOS_BIND tbCTableName = {.is_null = NULL, .buffer_type = TSDB_DATA_TYPE_BINARY,
+//                                .buffer = pInfo->cTableName, .length = &lenCTableName};
+//      TAOS_BIND tbSTableName = {.is_null = NULL, .buffer_type = TSDB_DATA_TYPE_BINARY,
+//                                .buffer = pInfo->sTableName, .length = &lenSTableName};
+//      taosArrayPush(bindParams, &tbCTableName);
+//      taosArrayPush(bindParams, &tbSTableName);
+//      for (int32_t i = 0; i < pInfo->tagNum; ++i) {
+//        outBytes = snprintf(pos, freeBytes, "?,");
+//
+//        TAOS_SML_KV* tagKv = pInfo->tags + i;
+//        TAOS_BIND tbTag = {.is_null = NULL, .buffer_type = TSDB_DATA_TYPE_BINARY,
+//                            .buffer = tagKv->key, .length = };
+//        pos += outBytes; freeBytes -= outBytes;
+//      }
+//      --pos; ++freeBytes;
+//
+//      outBytes = snprintf(pos, freeBytes, ") tags (");
+//      pos += outBytes; freeBytes -= outBytes;
+//      for (int32_t i = 0; i < pInfo->tagNum; ++i) {
+//        TAOS_SML_KV* tagKv = pInfo->tags + i;
+//        outBytes = snprintf(pos, freeBytes, "?,");
+//        pos += outBytes; freeBytes -= outBytes;
+//      }
+//      pos--; ++freeBytes;
+//      outBytes = snprintf(pos, freeBytes, ")");
+//
+//      TAOS_STMT* stmt = taos_stmt_init(taos);
+//      taos_stmt_prepare(stmt, result, strlen(result));
+//
+//
+//      taos_stmt_bind_param(stmt, (TAOS_BIND*)bindParams);
       break;
     }
     default:
@@ -726,6 +768,55 @@ int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
   return code;
 }
 
+int32_t transformIntoPreparedStatement(SArray* points) {
+  size_t numPoints = taosArrayGetSize(points);
+
+//  SHashObj* tag2bind = taosHashInit(32, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+//  SHashObj* field2multiBind = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+
+  for (int32_t i = 0; i < numPoints; ++i) {
+    TAOS_SML_DATA_POINT * point = taosArrayGet(points, i);
+    char tableKey[256];
+    snprintf(tableKey, 256, "%s.%s", point->stableName, point->childTableName);
+
+  }
+  return 0;
+}
+
+int32_t insertBatch(TAOS* taos, const char* sTableName, char* cTableName, SSchema* tagsSchema, int numTags, TAOS_BIND* tagBind,
+                  SSchema* colsSchema, int numCols, TAOS_MULTI_BIND* colBind) {
+  TAOS_STMT* stmt = taos_stmt_init(taos);
+
+  char result[TSDB_MAX_BINARY_LEN] = {0};
+  sprintf(result, "insert into ? using %s(", sTableName);
+  for (int i = 0; i < numTags; ++i) {
+    snprintf(result+strlen(result), TSDB_MAX_BINARY_LEN-strlen(result), "%s,", tagsSchema[i].name);
+  }
+  snprintf(result + strlen(result)-1, TSDB_MAX_BINARY_LEN-strlen(result)+1, ") tags (");
+
+  for (int i = 0; i < numTags; ++i) {
+    snprintf(result+strlen(result), TSDB_MAX_BINARY_LEN-strlen(result), "?,");
+  }
+  snprintf(result + strlen(result)-1, TSDB_MAX_BINARY_LEN-strlen(result)+1, ") (");
+
+  for (int i = 0; i < numCols; ++i) {
+    snprintf(result+strlen(result), TSDB_MAX_BINARY_LEN-strlen(result), "%s,", colsSchema[i].name);
+  }
+  snprintf(result + strlen(result)-1, TSDB_MAX_BINARY_LEN-strlen(result)+1, ") values (");
+
+  for (int i = 0; i < numCols; ++i) {
+    snprintf(result+strlen(result), TSDB_MAX_BINARY_LEN-strlen(result), "?,");
+  }
+  snprintf(result + strlen(result)-1, TSDB_MAX_BINARY_LEN-strlen(result)+1, ")");
+
+  int32_t code = 0;
+  code = taos_stmt_prepare(stmt, result, strlen(result));
+
+  code = taos_stmt_set_tbname_tags(stmt, cTableName, tagBind);
+  code = taos_stmt_bind_param_batch(stmt, colBind);
+  code = taos_stmt_execute(stmt);
+  return code;
+}
 //todo: table/column length check
 //todo: type check
 //todo: taosmbs2ucs4 check

From 35cba8c21f858a22b045cf7cf2ad5cedb2cd1631 Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Sat, 10 Jul 2021 16:18:38 +0800
Subject: [PATCH 29/70] before debugging

---
 src/client/src/tscParseLineProtocol.c | 393 ++++++++++++++------------
 1 file changed, 211 insertions(+), 182 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index 10d2429b5e..2738fe6f7a 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -272,6 +272,14 @@ TAOS_RES* taos_insert_by_lines(TAOS* taos, char* lines[], int numLines) {
 }
 //=================================================================================================
 
+typedef struct  {
+  char sTableName[TSDB_TABLE_NAME_LEN];
+  SHashObj* tagHash;
+  SHashObj* fieldHash;
+  SArray* tags; //SArray<SSchema>
+  SArray* fields; //SArray<SSchema>
+} SSmlSTableSchema;
+
 typedef struct {
   char* key;
   uint8_t type;
@@ -279,7 +287,7 @@ typedef struct {
   char* value;
 
   //===================================
-  SSchema* fieldSchema;
+  SSchema* schema;
 } TAOS_SML_KV;
 
 typedef struct {
@@ -293,17 +301,10 @@ typedef struct {
   TAOS_SML_KV* fields;
   int fieldNum;
 
+  //================================
+  SSmlSTableSchema* schema;
 } TAOS_SML_DATA_POINT;
 
-typedef struct  {
-  char sTableName[TSDB_TABLE_NAME_LEN];
-  SHashObj* tagHash;
-  SHashObj* fieldHash;
-  SArray* tags; //SArray<SSchema>
-  SArray* fields; //SArray<TAOS_SFIELD>
-} SSmlSTableSchema;
-
-
 int compareSmlColKv(const void* p1, const void* p2) {
   TAOS_SML_KV* kv1 = (TAOS_SML_KV*)p1;
   TAOS_SML_KV* kv2 = (TAOS_SML_KV*)p2;
@@ -426,7 +427,6 @@ typedef enum {
   SCHEMA_ACTION_ADD_TAG,
   SCHEMA_ACTION_CHANGE_COLUMN_SIZE,
   SCHEMA_ACTION_CHANGE_TAG_SIZE,
-  SCHEMA_ACTION_CREATE_CTABLE
 } ESchemaAction;
 
 typedef struct {
@@ -440,19 +440,11 @@ typedef struct {
   SSchema* field;
 } SAlterSTableActionInfo;
 
-typedef struct {
-  char sTableName[TSDB_TABLE_NAME_LEN];
-  char cTableName[TSDB_TABLE_NAME_LEN];
-  TAOS_SML_KV* tags;
-  int tagNum;
-} SCreateCTableActionInfo;
-
 typedef struct {
   ESchemaAction action;
   union {
     SCreateSTableActionInfo createSTable;
     SAlterSTableActionInfo alterSTable;
-    SCreateCTableActionInfo createCTable;
   };
 } SSchemaAction;
 
@@ -505,7 +497,7 @@ int32_t addTaosFieldToHashAndArray(TAOS_SML_KV* smlKv, SHashObj* hash, SArray* a
     taosHashPut(hash, field.name, tagKeyLen, &pField, POINTER_BYTES);
   }
 
-  smlKv->fieldSchema = pField;
+  smlKv->schema = pField;
 
   return 0;
 }
@@ -545,96 +537,6 @@ int32_t generateSchemaAction(SSchema* pointColField, SHashObj* dbAttrHash, bool
   return 0;
 }
 
-int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
-  int32_t code = TSDB_CODE_SUCCESS;
-  SArray* stableArray = taosArrayInit(32, sizeof(SSmlSTableSchema)); // SArray<STableColumnsSchema>
-  SHashObj* sname2shema = taosHashInit(32,
-                                       taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
-
-  for (int i = 0; i < numPoint; ++i) {
-    TAOS_SML_DATA_POINT* point = &points[i];
-    SSmlSTableSchema** ppStableSchema = taosHashGet(sname2shema, point->stableName, TSDB_TABLE_NAME_LEN);
-    SSmlSTableSchema* pStableSchema = NULL;
-    if (ppStableSchema) {
-      pStableSchema= *ppStableSchema;
-    } else {
-      SSmlSTableSchema schema;
-      size_t stableNameLen = strlen(point->stableName);
-      strncpy(schema.sTableName, point->stableName, stableNameLen);
-      schema.sTableName[stableNameLen] = '\0';
-      schema.fields = taosArrayInit(64, sizeof(SSchema));
-      schema.tags = taosArrayInit(8, sizeof(SSchema));
-      schema.tagHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
-      schema.fieldHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
-
-      pStableSchema = taosArrayPush(stableArray, &schema);
-      taosHashPut(sname2shema, schema.sTableName, stableNameLen, &pStableSchema, POINTER_BYTES);
-    }
-
-    for (int j = 0; j < point->tagNum; ++j) {
-      TAOS_SML_KV* tagKv = point->tags + j;
-      addTaosFieldToHashAndArray(tagKv, pStableSchema->tagHash, pStableSchema->tags);
-    }
-
-    for (int j = 0; j < point->fieldNum; ++j) {
-      TAOS_SML_KV* fieldKv = point->fields + j;
-      addTaosFieldToHashAndArray(fieldKv, pStableSchema->fieldHash, pStableSchema->fields);
-    }
-  }
-
-  SArray* schemaActions = taosArrayInit(32, sizeof(SSchemaAction));
-  size_t numStable = taosArrayGetSize(stableArray);
-  for (int i = 0; i < numStable; ++i) {
-    SSmlSTableSchema* pointSchema = taosArrayGet(stableArray, i);
-    SSmlSTableSchema  dbSchema = {0};
-    dbSchema.fields = taosArrayInit(64, sizeof(SSchema));
-    dbSchema.tags = taosArrayInit(8, sizeof(SSchema));
-    dbSchema.tagHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
-    dbSchema.fieldHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
-    code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
-    if (code == TSDB_CODE_MND_INVALID_TABLE_NAME) {
-      SSchemaAction schemaAction = {0};
-      schemaAction.action = SCHEMA_ACTION_CREATE_STABLE;
-      memset(&schemaAction.createSTable, 0, sizeof(SCreateSTableActionInfo));
-      memcpy(schemaAction.createSTable.sTableName, pointSchema->sTableName, TSDB_TABLE_NAME_LEN);
-      schemaAction.createSTable.tags = pointSchema->tags;
-      schemaAction.createSTable.fields = pointSchema->fields;
-      taosArrayPush(schemaActions, &schemaAction);
-    }else if (code == TSDB_CODE_SUCCESS) {
-      size_t pointTagSize = taosArrayGetSize(pointSchema->tags);
-      size_t pointFieldSize = taosArrayGetSize(pointSchema->fields);
-
-      SHashObj* dbTagHash = dbSchema.tagHash;
-      SHashObj* dbFieldHash = dbSchema.fieldHash;
-
-      for (int j = 0; j < pointTagSize; ++j) {
-        SSchema*            pointTag = taosArrayGet(pointSchema->tags, j);
-        SSchemaAction schemaAction = {0};
-        bool                   actionNeeded = false;
-        generateSchemaAction(pointTag, dbTagHash, true, pointSchema->sTableName, &schemaAction, &actionNeeded);
-        if (actionNeeded) {
-          taosArrayPush(schemaActions, &schemaAction);
-        }
-      }
-
-      for (int j = 0; j < pointFieldSize; ++j) {
-        SSchema*            pointCol = taosArrayGet(pointSchema->tags, j);
-        SSchemaAction schemaAction = {0};
-        bool                   actionNeeded = false;
-        generateSchemaAction(pointCol, dbFieldHash, false, pointSchema->sTableName, &schemaAction, &actionNeeded);
-        if (actionNeeded) {
-          taosArrayPush(schemaActions, &schemaAction);
-        }
-      }
-    } else {
-      return code;
-    }
-  }
-
-  return code;
-}
-
-
 int32_t buildColumnDescription(SSchema* field,
                                char* buf, int32_t bufSize, int32_t* outBytes) {
   uint8_t type = field->type;
@@ -721,46 +623,7 @@ int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
       code = taos_errno(res);
       break;
     }
-    case SCHEMA_ACTION_CREATE_CTABLE: {
-//      SCreateCTableActionInfo* pInfo = &action->createCTable;
-//      SArray* bindParams = taosArrayInit(2 + 2 * pInfo->tagNum, sizeof(TAOS_BIND));
-//      outBytes = sprintf(result, "create table ? using ?(");
-//      char* pos = result + outBytes; int32_t freeBytes = capacity-outBytes;
-//      uintptr_t lenSTableName = strlen(pInfo->sTableName);
-//      uintptr_t lenCTableName = strlen(pInfo->cTableName);
-//      TAOS_BIND tbCTableName = {.is_null = NULL, .buffer_type = TSDB_DATA_TYPE_BINARY,
-//                                .buffer = pInfo->cTableName, .length = &lenCTableName};
-//      TAOS_BIND tbSTableName = {.is_null = NULL, .buffer_type = TSDB_DATA_TYPE_BINARY,
-//                                .buffer = pInfo->sTableName, .length = &lenSTableName};
-//      taosArrayPush(bindParams, &tbCTableName);
-//      taosArrayPush(bindParams, &tbSTableName);
-//      for (int32_t i = 0; i < pInfo->tagNum; ++i) {
-//        outBytes = snprintf(pos, freeBytes, "?,");
-//
-//        TAOS_SML_KV* tagKv = pInfo->tags + i;
-//        TAOS_BIND tbTag = {.is_null = NULL, .buffer_type = TSDB_DATA_TYPE_BINARY,
-//                            .buffer = tagKv->key, .length = };
-//        pos += outBytes; freeBytes -= outBytes;
-//      }
-//      --pos; ++freeBytes;
-//
-//      outBytes = snprintf(pos, freeBytes, ") tags (");
-//      pos += outBytes; freeBytes -= outBytes;
-//      for (int32_t i = 0; i < pInfo->tagNum; ++i) {
-//        TAOS_SML_KV* tagKv = pInfo->tags + i;
-//        outBytes = snprintf(pos, freeBytes, "?,");
-//        pos += outBytes; freeBytes -= outBytes;
-//      }
-//      pos--; ++freeBytes;
-//      outBytes = snprintf(pos, freeBytes, ")");
-//
-//      TAOS_STMT* stmt = taos_stmt_init(taos);
-//      taos_stmt_prepare(stmt, result, strlen(result));
-//
-//
-//      taos_stmt_bind_param(stmt, (TAOS_BIND*)bindParams);
-      break;
-    }
+
     default:
       break;
   }
@@ -768,55 +631,221 @@ int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
   return code;
 }
 
-int32_t transformIntoPreparedStatement(SArray* points) {
-  size_t numPoints = taosArrayGetSize(points);
+int32_t getPreparedSQL(const char* sTableName, SArray* tagsSchema, SArray* colsSchema, char* result, int16_t freeBytes) {
+  size_t numTags = taosArrayGetSize(tagsSchema);
+  size_t numCols = taosArrayGetSize(colsSchema);
+  sprintf(result, "insert into ? using %s(", sTableName);
+  for (int i = 0; i < numTags; ++i) {
+    SSchema* tagSchema = taosArrayGet(tagsSchema, i);
+    snprintf(result+strlen(result), freeBytes-strlen(result), "%s,", tagSchema->name);
+  }
+  snprintf(result + strlen(result)-1, freeBytes-strlen(result)+1, ") tags (");
 
-//  SHashObj* tag2bind = taosHashInit(32, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
-//  SHashObj* field2multiBind = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+  for (int i = 0; i < numTags; ++i) {
+    snprintf(result+strlen(result), freeBytes-strlen(result), "?,");
+  }
+  snprintf(result + strlen(result)-1, freeBytes-strlen(result)+1, ") (");
 
+  for (int i = 0; i < numCols; ++i) {
+    SSchema* colSchema = taosArrayGet(colsSchema, i);
+    snprintf(result+strlen(result), freeBytes-strlen(result), "%s,", colSchema->name);
+  }
+  snprintf(result + strlen(result)-1, freeBytes-strlen(result)+1, ") values (");
+
+  for (int i = 0; i < numCols; ++i) {
+    snprintf(result+strlen(result), freeBytes-strlen(result), "?,");
+  }
+  snprintf(result + strlen(result)-1, freeBytes-strlen(result)+1, ")");
+  return 0;
+}
+
+int32_t insertBatch(TAOS* taos, char* sql, char* cTableName, SArray* tagsBind, SArray* rowsBind) {
+  TAOS_STMT* stmt = taos_stmt_init(taos);
+  taos_stmt_prepare(stmt, sql, strlen(sql));
+
+  taos_stmt_set_tbname_tags(stmt, cTableName, TARRAY_GET_START(tagsBind));
+  size_t rows = taosArrayGetSize(rowsBind);
+  for (int32_t i = 0; i < rows; ++i) {
+    TAOS_BIND* colBind = taosArrayGetP(rowsBind, i);
+    taos_stmt_bind_param(stmt, colBind);
+    taos_stmt_add_batch(stmt);
+  }
+
+  taos_stmt_execute(stmt);
+  TAOS_RES* res = taos_stmt_use_result(stmt);
+  return taos_errno(res);
+}
+
+int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints) {
+  SHashObj* cname2points = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
   for (int32_t i = 0; i < numPoints; ++i) {
-    TAOS_SML_DATA_POINT * point = taosArrayGet(points, i);
-    char tableKey[256];
-    snprintf(tableKey, 256, "%s.%s", point->stableName, point->childTableName);
+    TAOS_SML_DATA_POINT * point = points + i;
+    if (!point->childTableName) {
+      char childTableName[TSDB_TABLE_NAME_LEN];
+      int32_t tableNameLen;
+      getChildTableName(point, childTableName, &tableNameLen);
+      point->childTableName = calloc(1, tableNameLen+1);
+      strncpy(point->childTableName, childTableName, tableNameLen);
+      point->childTableName[tableNameLen] = '\0';
+    }
+    SArray* cTablePoints = NULL;
+    SArray** pCTablePoints = taosHashGet(cname2points, point->childTableName, strlen(point->childTableName));
+    if (pCTablePoints) {
+      cTablePoints = *pCTablePoints;
+    } else {
+      cTablePoints = taosArrayInit(64, sizeof(point));
+      taosHashPut(cname2points, point->childTableName, strlen(point->childTableName), &cTablePoints, POINTER_BYTES);
+    }
+    taosArrayPush(cTablePoints, point);
+  }
 
+  SArray** pCTablePoints = taosHashIterate(cname2points, NULL);
+  while (pCTablePoints) {
+    SArray* cTablePoints = *pCTablePoints;
+    TAOS_SML_DATA_POINT * point = taosArrayGet(cTablePoints, 0);
+    int32_t numTags = taosArrayGetSize(point->schema->tags);
+    int32_t numCols = taosArrayGetSize(point->schema->fields);
+    char* stableName = point->stableName;
+    char* ctableName = point->childTableName;
+    char sql[TSDB_MAX_BINARY_LEN];
+    getPreparedSQL(stableName, point->schema->tags, point->schema->fields, sql, TSDB_MAX_BINARY_LEN);
+
+    size_t rows = taosArrayGetSize(cTablePoints);
+    SArray* rowsBind = taosArrayInit(rows, POINTER_BYTES);
+    SArray* tagBinds = taosArrayInit(numTags, sizeof(TAOS_BIND));
+
+    for (int i = 0; i < rows; ++i) {
+      point = taosArrayGet(cTablePoints, i);
+
+      taosArraySetSize(tagBinds, numTags);
+      for (int j = 0; j < point->tagNum; ++j) {
+        TAOS_SML_KV* kv =  point->tags + j;
+        int32_t idx = TARRAY_ELEM_IDX(point->schema->tags, kv->schema);
+        TAOS_BIND* bind = taosArrayGet(tagBinds, idx);
+        bind->buffer_type = kv->type;
+        bind->length = (uintptr_t*)&kv->length;
+        bind->buffer = kv->value;
+      }
+
+      SArray* colBinds = taosArrayInit(numCols, sizeof(TAOS_BIND));
+      taosArraySetSize(colBinds, numCols);
+      for (int j = 0; j<point->fieldNum; ++j) {
+        TAOS_SML_KV* kv = point->fields + j;
+        int32_t idx = TARRAY_ELEM_IDX(point->schema->fields, kv->schema);
+        TAOS_BIND* bind = taosArrayGet(colBinds, idx);
+        bind->buffer_type = kv->type;
+        bind->length = (uintptr_t*)&kv->length;
+        bind->buffer = kv->value;
+      }
+      taosArrayPush(rowsBind, &colBinds);
+    }
+
+    insertBatch(taos, sql, ctableName, tagBinds, rowsBind);
+
+    pCTablePoints = taosHashIterate(cname2points, pCTablePoints);
   }
   return 0;
 }
 
-int32_t insertBatch(TAOS* taos, const char* sTableName, char* cTableName, SSchema* tagsSchema, int numTags, TAOS_BIND* tagBind,
-                  SSchema* colsSchema, int numCols, TAOS_MULTI_BIND* colBind) {
-  TAOS_STMT* stmt = taos_stmt_init(taos);
 
-  char result[TSDB_MAX_BINARY_LEN] = {0};
-  sprintf(result, "insert into ? using %s(", sTableName);
-  for (int i = 0; i < numTags; ++i) {
-    snprintf(result+strlen(result), TSDB_MAX_BINARY_LEN-strlen(result), "%s,", tagsSchema[i].name);
+int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  SArray* stableArray = taosArrayInit(32, sizeof(SSmlSTableSchema)); // SArray<STableColumnsSchema>
+  SHashObj* sname2shema = taosHashInit(32,
+                                       taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+
+  for (int i = 0; i < numPoint; ++i) {
+    TAOS_SML_DATA_POINT* point = &points[i];
+    SSmlSTableSchema** ppStableSchema = taosHashGet(sname2shema, point->stableName, TSDB_TABLE_NAME_LEN);
+    SSmlSTableSchema* pStableSchema = NULL;
+    if (ppStableSchema) {
+      pStableSchema= *ppStableSchema;
+    } else {
+      SSmlSTableSchema schema;
+      size_t stableNameLen = strlen(point->stableName);
+      strncpy(schema.sTableName, point->stableName, stableNameLen);
+      schema.sTableName[stableNameLen] = '\0';
+      schema.fields = taosArrayInit(64, sizeof(SSchema));
+      schema.tags = taosArrayInit(8, sizeof(SSchema));
+      schema.tagHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+      schema.fieldHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+
+      pStableSchema = taosArrayPush(stableArray, &schema);
+      taosHashPut(sname2shema, schema.sTableName, stableNameLen, &pStableSchema, POINTER_BYTES);
+    }
+
+    for (int j = 0; j < point->tagNum; ++j) {
+      TAOS_SML_KV* tagKv = point->tags + j;
+      addTaosFieldToHashAndArray(tagKv, pStableSchema->tagHash, pStableSchema->tags);
+    }
+
+    for (int j = 0; j < point->fieldNum; ++j) {
+      TAOS_SML_KV* fieldKv = point->fields + j;
+      addTaosFieldToHashAndArray(fieldKv, pStableSchema->fieldHash, pStableSchema->fields);
+    }
+
+    point->schema = pStableSchema;
   }
-  snprintf(result + strlen(result)-1, TSDB_MAX_BINARY_LEN-strlen(result)+1, ") tags (");
 
-  for (int i = 0; i < numTags; ++i) {
-    snprintf(result+strlen(result), TSDB_MAX_BINARY_LEN-strlen(result), "?,");
+  SArray* schemaActions = taosArrayInit(32, sizeof(SSchemaAction));
+  size_t numStable = taosArrayGetSize(stableArray);
+  for (int i = 0; i < numStable; ++i) {
+    SSmlSTableSchema* pointSchema = taosArrayGet(stableArray, i);
+    SSmlSTableSchema  dbSchema = {0};
+    dbSchema.fields = taosArrayInit(64, sizeof(SSchema));
+    dbSchema.tags = taosArrayInit(8, sizeof(SSchema));
+    dbSchema.tagHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+    dbSchema.fieldHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+    code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
+    if (code == TSDB_CODE_MND_INVALID_TABLE_NAME) {
+      SSchemaAction schemaAction = {0};
+      schemaAction.action = SCHEMA_ACTION_CREATE_STABLE;
+      memset(&schemaAction.createSTable, 0, sizeof(SCreateSTableActionInfo));
+      memcpy(schemaAction.createSTable.sTableName, pointSchema->sTableName, TSDB_TABLE_NAME_LEN);
+      schemaAction.createSTable.tags = pointSchema->tags;
+      schemaAction.createSTable.fields = pointSchema->fields;
+      taosArrayPush(schemaActions, &schemaAction);
+    }else if (code == TSDB_CODE_SUCCESS) {
+      size_t pointTagSize = taosArrayGetSize(pointSchema->tags);
+      size_t pointFieldSize = taosArrayGetSize(pointSchema->fields);
+
+      SHashObj* dbTagHash = dbSchema.tagHash;
+      SHashObj* dbFieldHash = dbSchema.fieldHash;
+
+      for (int j = 0; j < pointTagSize; ++j) {
+        SSchema*            pointTag = taosArrayGet(pointSchema->tags, j);
+        SSchemaAction schemaAction = {0};
+        bool                   actionNeeded = false;
+        generateSchemaAction(pointTag, dbTagHash, true, pointSchema->sTableName, &schemaAction, &actionNeeded);
+        if (actionNeeded) {
+          taosArrayPush(schemaActions, &schemaAction);
+        }
+      }
+
+      for (int j = 0; j < pointFieldSize; ++j) {
+        SSchema*            pointCol = taosArrayGet(pointSchema->tags, j);
+        SSchemaAction schemaAction = {0};
+        bool                   actionNeeded = false;
+        generateSchemaAction(pointCol, dbFieldHash, false, pointSchema->sTableName, &schemaAction, &actionNeeded);
+        if (actionNeeded) {
+          taosArrayPush(schemaActions, &schemaAction);
+        }
+      }
+    } else {
+      return code;
+    }
   }
-  snprintf(result + strlen(result)-1, TSDB_MAX_BINARY_LEN-strlen(result)+1, ") (");
 
-  for (int i = 0; i < numCols; ++i) {
-    snprintf(result+strlen(result), TSDB_MAX_BINARY_LEN-strlen(result), "%s,", colsSchema[i].name);
+  for (int i = 0; i < taosArrayGetSize(schemaActions); ++i) {
+    SSchemaAction* action = taosArrayGet(schemaActions, i);
+    applySchemaAction(taos, action);
   }
-  snprintf(result + strlen(result)-1, TSDB_MAX_BINARY_LEN-strlen(result)+1, ") values (");
 
-  for (int i = 0; i < numCols; ++i) {
-    snprintf(result+strlen(result), TSDB_MAX_BINARY_LEN-strlen(result), "?,");
-  }
-  snprintf(result + strlen(result)-1, TSDB_MAX_BINARY_LEN-strlen(result)+1, ")");
-
-  int32_t code = 0;
-  code = taos_stmt_prepare(stmt, result, strlen(result));
-
-  code = taos_stmt_set_tbname_tags(stmt, cTableName, tagBind);
-  code = taos_stmt_bind_param_batch(stmt, colBind);
-  code = taos_stmt_execute(stmt);
+  insertPoints(taos, points, numPoint);
   return code;
 }
+
+
 //todo: table/column length check
 //todo: type check
 //todo: taosmbs2ucs4 check

From dbac6f2081636d78628191b4bf615c9289682b68 Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Sun, 11 Jul 2021 23:52:19 +0800
Subject: [PATCH 30/70] before getChildTableName and insertBatch

---
 src/client/src/tscParseLineProtocol.c | 758 +++++++++++++++-----------
 src/inc/taos.h                        |   2 +
 tests/examples/c/apitest.c            |  15 +
 3 files changed, 447 insertions(+), 328 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index 2738fe6f7a..3a88d2e906 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -15,263 +15,6 @@
 #include "tskiplist.h"
 #include "tscUtil.h"
 
-typedef enum {
-  LP_ITEM_TAG,
-  LP_ITEM_FIELD
-} LPItemKind;
-
-typedef struct  {
-  SStrToken key;
-  SStrToken value;
-
-  char name[TSDB_COL_NAME_LEN];
-  int8_t type;
-  int16_t bytes;
-
-  char* payload;
-}SLPItem;
-
-typedef struct {
-  SStrToken measToken;
-  SStrToken tsToken;
-
-  char sTableName[TSDB_TABLE_NAME_LEN];
-  SArray* tags;
-  SArray* fields;
-  int64_t ts;
-
-} SLPPoint;
-
-typedef enum {
-  LP_MEASUREMENT,
-  LP_TAG_KEY,
-  LP_TAG_VALUE,
-  LP_FIELD_KEY,
-  LP_FIELD_VALUE
-} LPPart;
-
-int32_t scanToCommaOrSpace(SStrToken s, int32_t start, int32_t* index, LPPart part) {
-  for (int32_t i = start; i < s.n; ++i) {
-    if (s.z[i] == ',' || s.z[i] == ' ') {
-      *index = i;
-      return 0;
-    }
-  }
-  return -1;
-}
-
-int32_t scanToEqual(SStrToken s, int32_t start, int32_t* index) {
-  for (int32_t i = start; i < s.n; ++i) {
-    if (s.z[i] == '=') {
-      *index = i;
-      return 0;
-    }
-  }
-  return -1;
-}
-
-int32_t setPointMeasurement(SLPPoint* point, SStrToken token) {
-  point->measToken = token;
-  if (point->measToken.n < TSDB_TABLE_NAME_LEN) {
-    strncpy(point->sTableName, point->measToken.z, point->measToken.n);
-    point->sTableName[point->measToken.n] = '\0';
-  }
-  return 0;
-}
-
-int32_t setItemKey(SLPItem* item, SStrToken key, LPPart part) {
-  item->key = key;
-  if (item->key.n < TSDB_COL_NAME_LEN) {
-    strncpy(item->name, item->key.z, item->key.n);
-    item->name[item->key.n] = '\0';
-  }
-  return 0;
-}
-
-int32_t setItemValue(SLPItem* item, SStrToken value, LPPart part) {
-  item->value = value;
-  return 0;
-}
-
-int32_t parseItemValue(SLPItem* item, LPItemKind kind) {
-  char* sv = item->value.z;
-  char* last = item->value.z + item->value.n - 1;
-
-  if (isdigit(sv[0]) || sv[0] == '-') {
-    if (*last == 'i') {
-      item->type = TSDB_DATA_TYPE_BIGINT;
-      item->bytes = (int16_t)tDataTypes[item->type].bytes;
-      item->payload = malloc(item->bytes);
-      char* endptr = NULL;
-      *(item->payload) = strtoll(sv, &endptr, 10);
-    } else {
-      item->type = TSDB_DATA_TYPE_DOUBLE;
-      item->bytes = (int16_t)tDataTypes[item->type].bytes;
-      item->payload = malloc(item->bytes);
-      char* endptr = NULL;
-      *(item->payload) = strtold(sv, &endptr);
-    }
-  } else if ((sv[0] == 'L' && sv[1] =='"') || sv[0] == '"' ) {
-    if (sv[0] == 'L') {
-      item->type = TSDB_DATA_TYPE_NCHAR;
-      uint32_t bytes = item->value.n - 3;
-//      uint32_t len = bytes;
-//      char* ucs = malloc(len);
-//      int32_t ncharBytes = 0;
-//      taosMbsToUcs4(sv+2, len, ucs, len, &ncharBytes);
-//      item->bytes = ncharBytes;
-//      item->payload = malloc(ncharBytes);
-//      memcpy(item->payload, ucs, ncharBytes);
-//      free(ucs);
-      item->bytes = bytes;
-      item->payload = malloc(bytes);
-      memcpy(item->payload, sv+1, bytes);
-    } else if (sv[0]=='"'){
-      item->type = TSDB_DATA_TYPE_BINARY;
-      uint32_t bytes = item->value.n - 2;
-      item->bytes = bytes;
-      item->payload = malloc(bytes);
-      memcpy(item->payload, sv+1, bytes);
-    }
-  } else if (sv[0] == 't' || sv[0] == 'f' || sv[0]=='T' || sv[0] == 'F') {
-    item->type = TSDB_DATA_TYPE_BOOL;
-    item->bytes = tDataTypes[item->type].bytes;
-    item->payload = malloc(tDataTypes[item->type].bytes);
-    *(item->payload) = tolower(sv[0])=='t' ? true : false;
-  }
-  return 0;
-}
-
-int32_t compareLPItemKey(const void* p1, const void* p2) {
-  const SLPItem* t1 = p1;
-  const SLPItem* t2 = p2;
-  uint32_t min = (t1->key.n < t2->key.n) ? t1->key.n : t2->key.n;
-  int res = strncmp(t1->key.z, t2->key.z, min);
-  if (res != 0) {
-    return res;
-  } else {
-    return (int)(t1->key.n) - (int)(t2->key.n);
-  }
-}
-
-int32_t setPointTimeStamp(SLPPoint* point, SStrToken tsToken) {
-  point->tsToken = tsToken;
-  return 0;
-}
-
-int32_t parsePointTime(SLPPoint* point) {
-  if (point->tsToken.n <= 0) {
-    point->ts = taosGetTimestampNs();
-  } else {
-    char* endptr = NULL;
-    point->ts = strtoll(point->tsToken.z, &endptr, 10);
-  }
-  return 0;
-}
-
-int32_t tscParseLine(SStrToken line, SLPPoint* point) {
-  int32_t pos = 0;
-
-  int32_t start = 0;
-  int32_t err = scanToCommaOrSpace(line, start, &pos, LP_MEASUREMENT);
-  if (err != 0) {
-    tscError("a");
-    return err;
-  }
-
-  SStrToken measurement = {.z = line.z+start, .n = pos-start};
-  setPointMeasurement(point, measurement);
-  point->tags = taosArrayInit(64, sizeof(SLPItem));
-  start = pos + 1;
-  while (line.z[start] == ',') {
-    SLPItem item;
-
-    err = scanToEqual(line, start, &pos);
-    if (err != 0) {
-      tscError("b");
-      goto error;
-    }
-
-    SStrToken tagKey = {.z = line.z + start, .n = pos-start};
-    setItemKey(&item, tagKey, LP_TAG_KEY);
-
-    start = pos + 1;
-    err = scanToCommaOrSpace(line, start, &pos, LP_TAG_VALUE);
-    if (err != 0) {
-      tscError("c");
-      goto error;
-    }
-
-    SStrToken tagValue = {.z = line.z + start, .n = pos-start};
-    setItemValue(&item, tagValue, LP_TAG_VALUE);
-
-    parseItemValue(&item, LP_ITEM_TAG);
-    taosArrayPush(point->tags, &item);
-
-    start = pos + 1;
-  }
-
-  taosArraySort(point->tags, compareLPItemKey);
-
-  point->fields = taosArrayInit(64, sizeof(SLPItem));
-  do {
-    SLPItem item;
-    err = scanToEqual(line, start, &pos);
-    if (err != 0) {
-      goto error;
-    }
-    SStrToken fieldKey = {.z = line.z + start, .n = pos- start};
-    setItemKey(&item, fieldKey, LP_FIELD_KEY);
-
-    start = pos + 1;
-    err = scanToCommaOrSpace(line, start, &pos, LP_FIELD_VALUE);
-    if (err != 0) {
-      goto error;
-    }
-    SStrToken fieldValue = {.z = line.z + start, .n = pos - start};
-    setItemValue(&item, fieldValue, LP_TAG_VALUE);
-
-    parseItemValue(&item, LP_ITEM_FIELD);
-    taosArrayPush(point->fields, &item);
-
-    start = pos + 1;
-  } while (line.z[pos] == ',');
-
-  taosArraySort(point->fields, compareLPItemKey);
-
-  SStrToken tsToken = {.z = line.z+start, .n = line.n-start};
-  setPointTimeStamp(point, tsToken);
-  parsePointTime(point);
-
-  goto done;
-
-error:
-  // free array
-  return err;
-done:
-  return 0;
-}
-
-
-int32_t tscParseLines(char* lines[], int numLines, SArray* points, SArray* failedLines) {
-  for (int32_t i = 0; i < numLines; ++i) {
-    SStrToken tkLine = {.z = lines[i], .n = strlen(lines[i])+1};
-    SLPPoint point;
-    tscParseLine(tkLine, &point);
-    taosArrayPush(points, &point);
-  }
-  return 0;
-}
-
-TAOS_RES* taos_insert_by_lines(TAOS* taos, char* lines[], int numLines) {
-  SArray* points = taosArrayInit(numLines, sizeof(SLPPoint));
-  tscParseLines(lines, numLines, points, NULL);
-
-
-  return NULL;
-}
-//=================================================================================================
-
 typedef struct  {
   char sTableName[TSDB_TABLE_NAME_LEN];
   SHashObj* tagHash;
@@ -305,6 +48,8 @@ typedef struct {
   SSmlSTableSchema* schema;
 } TAOS_SML_DATA_POINT;
 
+//=================================================================================================
+
 int compareSmlColKv(const void* p1, const void* p2) {
   TAOS_SML_KV* kv1 = (TAOS_SML_KV*)p1;
   TAOS_SML_KV* kv2 = (TAOS_SML_KV*)p2;
@@ -318,32 +63,6 @@ int compareSmlColKv(const void* p1, const void* p2) {
   }
 }
 
-int32_t getChildTableName(TAOS_SML_DATA_POINT* point, char* tableName, int* tableNameLen) {
-    qsort(point->tags, point->tagNum, sizeof(TAOS_SML_KV), compareSmlColKv);
-
-    SStringBuilder sb; memset(&sb, 0, sizeof(sb));
-    taosStringBuilderAppendString(&sb, point->stableName);
-    for (int j = 0; j < point->tagNum; ++j) {
-      TAOS_SML_KV* tagKv = point->tags + j;
-      taosStringBuilderAppendChar(&sb, ',');
-      taosStringBuilderAppendString(&sb, tagKv->key);
-      taosStringBuilderAppendChar(&sb, '=');
-      taosStringBuilderAppend(&sb, tagKv->value, tagKv->length);
-    }
-    size_t len = 0;
-    char* keyJoined = taosStringBuilderGetResult(&sb, &len);
-    MD5_CTX context;
-    MD5Init(&context);
-    MD5Update(&context, (uint8_t *)keyJoined, (uint32_t)len);
-    MD5Final(&context);
-    *tableNameLen = snprintf(tableName, *tableNameLen,
-             "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", context.digest[0],
-             context.digest[1], context.digest[2], context.digest[3], context.digest[4], context.digest[5], context.digest[6],
-             context.digest[7], context.digest[8], context.digest[9], context.digest[10], context.digest[11],
-             context.digest[12], context.digest[13], context.digest[14], context.digest[15]);
-    return 0;
-}
-
 int32_t loadTableMeta(TAOS* taos, char* tableName, SSmlSTableSchema* schema) {
   int32_t code = 0;
 
@@ -393,15 +112,14 @@ int32_t loadTableMeta(TAOS* taos, char* tableName, SSmlSTableSchema* schema) {
 
   tscFreeSqlObj(pSql);
 
-
   uint32_t size = tscGetTableMetaMaxSize();
   STableMeta* tableMeta = calloc(1, size);
   taosHashGetClone(tscTableMetaInfo, fullTableName, strlen(fullTableName), NULL, tableMeta, -1);
 
-  tstrncpy(schema->sTableName, tableName, strlen(tableName));
+  tstrncpy(schema->sTableName, tableName, strlen(tableName)+1);
   for (int i=0; i<tableMeta->tableInfo.numOfColumns; ++i) {
     SSchema field;
-    tstrncpy(field.name, tableMeta->schema[i].name, strlen(tableMeta->schema[i].name));
+    tstrncpy(field.name, tableMeta->schema[i].name, strlen(tableMeta->schema[i].name)+1);
     field.type = tableMeta->schema[i].type;
     field.bytes = tableMeta->schema[i].bytes;
     SSchema* pField = taosArrayPush(schema->fields, &field);
@@ -411,13 +129,13 @@ int32_t loadTableMeta(TAOS* taos, char* tableName, SSmlSTableSchema* schema) {
   for (int i=0; i<tableMeta->tableInfo.numOfTags; ++i) {
     int j = i + tableMeta->tableInfo.numOfColumns;
     SSchema field;
-    tstrncpy(field.name, tableMeta->schema[j].name, strlen(tableMeta->schema[j].name));
+    tstrncpy(field.name, tableMeta->schema[j].name, strlen(tableMeta->schema[j].name)+1);
     field.type = tableMeta->schema[j].type;
     field.bytes = tableMeta->schema[j].bytes;
     SSchema* pField = taosArrayPush(schema->tags, &field);
     taosHashPut(schema->tagHash, field.name, strlen(field.name), &pField, POINTER_BYTES);
   }
-
+  free(tableMeta); tableMeta = NULL;
   return code;
 }
 
@@ -586,6 +304,7 @@ int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
                              capacity-n, &outBytes);
       TAOS_RES* res = taos_query(taos, result); //TODO async doAsyncQuery
       code = taos_errno(res);
+      break;
     }
     case SCHEMA_ACTION_CHANGE_TAG_SIZE: {
       int n = sprintf(result, "alter stable %s modify tag ", action->alterSTable.sTableName);
@@ -631,15 +350,46 @@ int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
   return code;
 }
 
+int32_t getChildTableName(TAOS_SML_DATA_POINT* point, char* tableName, int* tableNameLen) {
+  qsort(point->tags, point->tagNum, sizeof(TAOS_SML_KV), compareSmlColKv);
+
+  SStringBuilder sb; memset(&sb, 0, sizeof(sb));
+  taosStringBuilderAppendString(&sb, point->stableName);
+  for (int j = 0; j < point->tagNum; ++j) {
+    taosStringBuilderAppendChar(&sb, ',');
+    TAOS_SML_KV* tagKv = point->tags + j;
+    taosStringBuilderAppendString(&sb, tagKv->key);
+    taosStringBuilderAppendChar(&sb, '=');
+    taosStringBuilderAppend(&sb, tagKv->value, tagKv->length);
+  }
+  size_t len = 0;
+  char* keyJoined = taosStringBuilderGetResult(&sb, &len);
+  MD5_CTX context;
+  MD5Init(&context);
+  MD5Update(&context, (uint8_t *)keyJoined, (uint32_t)len);
+  MD5Final(&context);
+  *tableNameLen = snprintf(tableName, *tableNameLen,
+                           "tbl%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", context.digest[0],
+                           context.digest[1], context.digest[2], context.digest[3], context.digest[4], context.digest[5], context.digest[6],
+                           context.digest[7], context.digest[8], context.digest[9], context.digest[10], context.digest[11],
+                           context.digest[12], context.digest[13], context.digest[14], context.digest[15]);
+  taosStringBuilderDestroy(&sb);
+  return 0;
+}
+
 int32_t getPreparedSQL(const char* sTableName, SArray* tagsSchema, SArray* colsSchema, char* result, int16_t freeBytes) {
   size_t numTags = taosArrayGetSize(tagsSchema);
   size_t numCols = taosArrayGetSize(colsSchema);
-  sprintf(result, "insert into ? using %s(", sTableName);
-  for (int i = 0; i < numTags; ++i) {
-    SSchema* tagSchema = taosArrayGet(tagsSchema, i);
-    snprintf(result+strlen(result), freeBytes-strlen(result), "%s,", tagSchema->name);
-  }
-  snprintf(result + strlen(result)-1, freeBytes-strlen(result)+1, ") tags (");
+  sprintf(result, "insert into ? using %s", sTableName);
+
+//  snprintf(result+strlen(result), freeBytes-strlen(result), "(");
+//  for (int i = 0; i < numTags; ++i) {
+//    SSchema* tagSchema = taosArrayGet(tagsSchema, i);
+//    snprintf(result+strlen(result), freeBytes-strlen(result), "%s,", tagSchema->name);
+//  }
+//  snprintf(result + strlen(result)-1, freeBytes-strlen(result)+1, ")");
+
+  snprintf(result + strlen(result), freeBytes-strlen(result), " tags (");
 
   for (int i = 0; i < numTags; ++i) {
     snprintf(result+strlen(result), freeBytes-strlen(result), "?,");
@@ -661,17 +411,38 @@ int32_t getPreparedSQL(const char* sTableName, SArray* tagsSchema, SArray* colsS
 
 int32_t insertBatch(TAOS* taos, char* sql, char* cTableName, SArray* tagsBind, SArray* rowsBind) {
   TAOS_STMT* stmt = taos_stmt_init(taos);
-  taos_stmt_prepare(stmt, sql, strlen(sql));
-
-  taos_stmt_set_tbname_tags(stmt, cTableName, TARRAY_GET_START(tagsBind));
-  size_t rows = taosArrayGetSize(rowsBind);
-  for (int32_t i = 0; i < rows; ++i) {
-    TAOS_BIND* colBind = taosArrayGetP(rowsBind, i);
-    taos_stmt_bind_param(stmt, colBind);
-    taos_stmt_add_batch(stmt);
+  int32_t code;
+  code = taos_stmt_prepare(stmt, sql, strlen(sql));
+  if (code != 0) {
+    printf("%s", taos_stmt_errstr(stmt));
+    return code;
   }
 
-  taos_stmt_execute(stmt);
+  code = taos_stmt_set_tbname_tags(stmt, cTableName, TARRAY_GET_START(tagsBind));
+  if (code != 0) {
+    printf("%s", taos_stmt_errstr(stmt));
+    return code;
+  }
+  size_t rows = taosArrayGetSize(rowsBind);
+  for (int32_t i = 0; i < rows; ++i) {
+    SArray* colBind = taosArrayGetP(rowsBind, i);
+    code = taos_stmt_bind_param(stmt, TARRAY_GET_START(colBind));
+    if (code != 0) {
+      printf("%s", taos_stmt_errstr(stmt));
+      return code;
+    }
+    code = taos_stmt_add_batch(stmt);
+    if (code != 0) {
+      printf("%s", taos_stmt_errstr(stmt));
+      return code;
+    }
+  }
+
+  code = taos_stmt_execute(stmt);
+  if (code != 0) {
+    printf("%s", taos_stmt_errstr(stmt));
+    return code;
+  }
   TAOS_RES* res = taos_stmt_use_result(stmt);
   return taos_errno(res);
 }
@@ -682,7 +453,7 @@ int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints)
     TAOS_SML_DATA_POINT * point = points + i;
     if (!point->childTableName) {
       char childTableName[TSDB_TABLE_NAME_LEN];
-      int32_t tableNameLen;
+      int32_t tableNameLen = TSDB_TABLE_NAME_LEN;
       getChildTableName(point, childTableName, &tableNameLen);
       point->childTableName = calloc(1, tableNameLen+1);
       strncpy(point->childTableName, childTableName, tableNameLen);
@@ -696,50 +467,62 @@ int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints)
       cTablePoints = taosArrayInit(64, sizeof(point));
       taosHashPut(cname2points, point->childTableName, strlen(point->childTableName), &cTablePoints, POINTER_BYTES);
     }
-    taosArrayPush(cTablePoints, point);
+    taosArrayPush(cTablePoints, &point);
   }
 
+  int isNullColBind = TSDB_TRUE;
   SArray** pCTablePoints = taosHashIterate(cname2points, NULL);
   while (pCTablePoints) {
     SArray* cTablePoints = *pCTablePoints;
-    TAOS_SML_DATA_POINT * point = taosArrayGet(cTablePoints, 0);
+
+    TAOS_SML_DATA_POINT * point = taosArrayGetP(cTablePoints, 0);
     int32_t numTags = taosArrayGetSize(point->schema->tags);
     int32_t numCols = taosArrayGetSize(point->schema->fields);
     char* stableName = point->stableName;
     char* ctableName = point->childTableName;
-    char sql[TSDB_MAX_BINARY_LEN];
-    getPreparedSQL(stableName, point->schema->tags, point->schema->fields, sql, TSDB_MAX_BINARY_LEN);
+
+    SArray* tagBinds = taosArrayInit(numTags, sizeof(TAOS_BIND));
+    taosArraySetSize(tagBinds, numTags);
+    for (int j = 0; j < numTags; ++j) {
+      TAOS_BIND* bind = taosArrayGet(tagBinds, j);
+      bind->is_null = &isNullColBind;
+    }
+    for (int j = 0; j < point->tagNum; ++j) {
+      TAOS_SML_KV* kv =  point->tags + j;
+      int32_t idx = TARRAY_ELEM_IDX(point->schema->tags, kv->schema);
+      TAOS_BIND* bind = taosArrayGet(tagBinds, idx);
+      bind->buffer_type = kv->type;
+      bind->length = (uintptr_t*)&kv->length;
+      bind->buffer = kv->value;
+      bind->is_null = NULL;
+    }
 
     size_t rows = taosArrayGetSize(cTablePoints);
     SArray* rowsBind = taosArrayInit(rows, POINTER_BYTES);
-    SArray* tagBinds = taosArrayInit(numTags, sizeof(TAOS_BIND));
 
     for (int i = 0; i < rows; ++i) {
-      point = taosArrayGet(cTablePoints, i);
-
-      taosArraySetSize(tagBinds, numTags);
-      for (int j = 0; j < point->tagNum; ++j) {
-        TAOS_SML_KV* kv =  point->tags + j;
-        int32_t idx = TARRAY_ELEM_IDX(point->schema->tags, kv->schema);
-        TAOS_BIND* bind = taosArrayGet(tagBinds, idx);
-        bind->buffer_type = kv->type;
-        bind->length = (uintptr_t*)&kv->length;
-        bind->buffer = kv->value;
-      }
+      point = taosArrayGetP(cTablePoints, i);
 
       SArray* colBinds = taosArrayInit(numCols, sizeof(TAOS_BIND));
       taosArraySetSize(colBinds, numCols);
-      for (int j = 0; j<point->fieldNum; ++j) {
+      for (int j = 0; j < numCols; ++j) {
+        TAOS_BIND* bind = taosArrayGet(colBinds, j);
+        bind->is_null = &isNullColBind;
+      }
+      for (int j = 0; j < point->fieldNum; ++j) {
         TAOS_SML_KV* kv = point->fields + j;
         int32_t idx = TARRAY_ELEM_IDX(point->schema->fields, kv->schema);
         TAOS_BIND* bind = taosArrayGet(colBinds, idx);
         bind->buffer_type = kv->type;
         bind->length = (uintptr_t*)&kv->length;
         bind->buffer = kv->value;
+        bind->is_null = NULL;
       }
       taosArrayPush(rowsBind, &colBinds);
     }
 
+    char sql[TSDB_MAX_BINARY_LEN];
+    getPreparedSQL(stableName, point->schema->tags, point->schema->fields, sql, TSDB_MAX_BINARY_LEN);
     insertBatch(taos, sql, ctableName, tagBinds, rowsBind);
 
     pCTablePoints = taosHashIterate(cname2points, pCTablePoints);
@@ -747,7 +530,6 @@ int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints)
   return 0;
 }
 
-
 int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
   int32_t code = TSDB_CODE_SUCCESS;
   SArray* stableArray = taosArrayInit(32, sizeof(SSmlSTableSchema)); // SArray<STableColumnsSchema>
@@ -792,11 +574,13 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
   for (int i = 0; i < numStable; ++i) {
     SSmlSTableSchema* pointSchema = taosArrayGet(stableArray, i);
     SSmlSTableSchema  dbSchema = {0};
-    dbSchema.fields = taosArrayInit(64, sizeof(SSchema));
     dbSchema.tags = taosArrayInit(8, sizeof(SSchema));
+    dbSchema.fields = taosArrayInit(64, sizeof(SSchema));
     dbSchema.tagHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
     dbSchema.fieldHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+
     code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
+
     if (code == TSDB_CODE_MND_INVALID_TABLE_NAME) {
       SSchemaAction schemaAction = {0};
       schemaAction.action = SCHEMA_ACTION_CREATE_STABLE;
@@ -813,19 +597,23 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
       SHashObj* dbFieldHash = dbSchema.fieldHash;
 
       for (int j = 0; j < pointTagSize; ++j) {
-        SSchema*            pointTag = taosArrayGet(pointSchema->tags, j);
+        SSchema* pointTag = taosArrayGet(pointSchema->tags, j);
         SSchemaAction schemaAction = {0};
-        bool                   actionNeeded = false;
+        bool actionNeeded = false;
         generateSchemaAction(pointTag, dbTagHash, true, pointSchema->sTableName, &schemaAction, &actionNeeded);
         if (actionNeeded) {
           taosArrayPush(schemaActions, &schemaAction);
         }
       }
 
-      for (int j = 0; j < pointFieldSize; ++j) {
-        SSchema*            pointCol = taosArrayGet(pointSchema->tags, j);
+      SSchema* pointColTs = taosArrayGet(pointSchema->fields, 0);
+      SSchema* dbColTs = taosArrayGet(dbSchema.fields, 0);
+      memcpy(pointColTs->name, dbColTs->name, TSDB_COL_NAME_LEN);
+
+      for (int j = 1; j < pointFieldSize; ++j) {
+        SSchema* pointCol = taosArrayGet(pointSchema->fields, j);
         SSchemaAction schemaAction = {0};
-        bool                   actionNeeded = false;
+        bool actionNeeded = false;
         generateSchemaAction(pointCol, dbFieldHash, false, pointSchema->sTableName, &schemaAction, &actionNeeded);
         if (actionNeeded) {
           taosArrayPush(schemaActions, &schemaAction);
@@ -849,3 +637,317 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
 //todo: table/column length check
 //todo: type check
 //todo: taosmbs2ucs4 check
+
+//=========================================================================
+
+typedef enum {
+  LP_ITEM_TAG,
+  LP_ITEM_FIELD
+} LPItemKind;
+
+typedef struct  {
+  SStrToken keyToken;
+  SStrToken valueToken;
+
+  char key[TSDB_COL_NAME_LEN];
+  int8_t type;
+  int16_t length;
+
+  char* value;
+}SLPItem;
+
+typedef struct {
+  SStrToken measToken;
+  SStrToken tsToken;
+
+  char sTableName[TSDB_TABLE_NAME_LEN];
+  SArray* tags;
+  SArray* fields;
+  int64_t ts;
+
+} SLPPoint;
+
+typedef enum {
+  LP_MEASUREMENT,
+  LP_TAG_KEY,
+  LP_TAG_VALUE,
+  LP_FIELD_KEY,
+  LP_FIELD_VALUE
+} LPPart;
+
+int32_t scanToCommaOrSpace(SStrToken s, int32_t start, int32_t* index, LPPart part) {
+  for (int32_t i = start; i < s.n; ++i) {
+    if (s.z[i] == ',' || s.z[i] == ' ') {
+      *index = i;
+      return 0;
+    }
+  }
+  return -1;
+}
+
+int32_t scanToEqual(SStrToken s, int32_t start, int32_t* index) {
+  for (int32_t i = start; i < s.n; ++i) {
+    if (s.z[i] == '=') {
+      *index = i;
+      return 0;
+    }
+  }
+  return -1;
+}
+
+int32_t setPointMeasurement(SLPPoint* point, SStrToken token) {
+  point->measToken = token;
+  if (point->measToken.n < TSDB_TABLE_NAME_LEN) {
+    strncpy(point->sTableName, point->measToken.z, point->measToken.n);
+    point->sTableName[point->measToken.n] = '\0';
+  }
+  return 0;
+}
+
+int32_t setItemKey(SLPItem* item, SStrToken key, LPPart part) {
+  item->keyToken = key;
+  if (item->keyToken.n < TSDB_COL_NAME_LEN) {
+    strncpy(item->key, item->keyToken.z, item->keyToken.n);
+    item->key[item->keyToken.n] = '\0';
+  }
+  return 0;
+}
+
+int32_t setItemValue(SLPItem* item, SStrToken value, LPPart part) {
+  item->valueToken = value;
+  return 0;
+}
+
+int32_t parseItemValue(SLPItem* item, LPItemKind kind) {
+  char* sv = item->valueToken.z;
+  char* last = item->valueToken.z + item->valueToken.n - 1;
+
+  if (isdigit(sv[0]) || sv[0] == '-') {
+    if (*last == 'i') {
+      item->type = TSDB_DATA_TYPE_BIGINT;
+      item->length = (int16_t)tDataTypes[item->type].bytes;
+      item->value = malloc(item->length);
+      char* endptr = NULL;
+      *(item->value) = strtoll(sv, &endptr, 10);
+    } else {
+      item->type = TSDB_DATA_TYPE_DOUBLE;
+      item->length = (int16_t)tDataTypes[item->type].bytes;
+      item->value = malloc(item->length);
+      char* endptr = NULL;
+      *(item->value) = strtold(sv, &endptr);
+    }
+  } else if ((sv[0] == 'L' && sv[1] =='"') || sv[0] == '"' ) {
+    if (sv[0] == 'L') {
+      item->type = TSDB_DATA_TYPE_NCHAR;
+      uint32_t bytes = item->valueToken.n - 3;
+      item->length = bytes;
+      item->value = malloc(bytes);
+      memcpy(item->value, sv+1, bytes);
+    } else if (sv[0]=='"'){
+      item->type = TSDB_DATA_TYPE_BINARY;
+      uint32_t bytes = item->valueToken.n - 2;
+      item->length = bytes;
+      item->value = malloc(bytes);
+      memcpy(item->value, sv+1, bytes);
+    }
+  } else if (sv[0] == 't' || sv[0] == 'f' || sv[0]=='T' || sv[0] == 'F') {
+    item->type = TSDB_DATA_TYPE_BOOL;
+    item->length = tDataTypes[item->type].bytes;
+    item->value = malloc(tDataTypes[item->type].bytes);
+    *(item->value) = tolower(sv[0])=='t' ? TSDB_TRUE : TSDB_FALSE;
+  }
+  return 0;
+}
+
+int32_t compareLPItemKey(const void* p1, const void* p2) {
+  const SLPItem* t1 = p1;
+  const SLPItem* t2 = p2;
+  uint32_t min = (t1->keyToken.n < t2->keyToken.n) ? t1->keyToken.n : t2->keyToken.n;
+  int res = strncmp(t1->keyToken.z, t2->keyToken.z, min);
+  if (res != 0) {
+    return res;
+  } else {
+    return (int)(t1->keyToken.n) - (int)(t2->keyToken.n);
+  }
+}
+
+int32_t setPointTimeStamp(SLPPoint* point, SStrToken tsToken) {
+  point->tsToken = tsToken;
+  return 0;
+}
+
+int32_t parsePointTime(SLPPoint* point) {
+  if (point->tsToken.n <= 0) {
+    point->ts = taosGetTimestampNs();
+  } else {
+    char* endptr = NULL;
+    point->ts = strtoll(point->tsToken.z, &endptr, 10);
+  }
+  return 0;
+}
+
+int32_t tscParseLine(SStrToken line, SLPPoint* point) {
+  int32_t pos = 0;
+
+  int32_t start = 0;
+  int32_t err = scanToCommaOrSpace(line, start, &pos, LP_MEASUREMENT);
+  if (err != 0) {
+    tscError("a");
+    return err;
+  }
+
+  SStrToken measurement = {.z = line.z+start, .n = pos-start};
+  setPointMeasurement(point, measurement);
+  point->tags = taosArrayInit(64, sizeof(SLPItem));
+  start = pos;
+  while (line.z[start] == ',') {
+    SLPItem item;
+
+    start++;
+    err = scanToEqual(line, start, &pos);
+    if (err != 0) {
+      tscError("b");
+      goto error;
+    }
+
+    SStrToken tagKey = {.z = line.z + start, .n = pos-start};
+    setItemKey(&item, tagKey, LP_TAG_KEY);
+
+    start = pos + 1;
+    err = scanToCommaOrSpace(line, start, &pos, LP_TAG_VALUE);
+    if (err != 0) {
+      tscError("c");
+      goto error;
+    }
+
+    SStrToken tagValue = {.z = line.z + start, .n = pos-start};
+    setItemValue(&item, tagValue, LP_TAG_VALUE);
+
+    parseItemValue(&item, LP_ITEM_TAG);
+    taosArrayPush(point->tags, &item);
+
+    start = pos;
+  }
+
+  taosArraySort(point->tags, compareLPItemKey);
+
+  point->fields = taosArrayInit(64, sizeof(SLPItem));
+
+  start++;
+  do {
+    SLPItem item;
+
+    err = scanToEqual(line, start, &pos);
+    if (err != 0) {
+      goto error;
+    }
+    SStrToken fieldKey = {.z = line.z + start, .n = pos- start};
+    setItemKey(&item, fieldKey, LP_FIELD_KEY);
+
+    start = pos + 1;
+    err = scanToCommaOrSpace(line, start, &pos, LP_FIELD_VALUE);
+    if (err != 0) {
+      goto error;
+    }
+    SStrToken fieldValue = {.z = line.z + start, .n = pos - start};
+    setItemValue(&item, fieldValue, LP_TAG_VALUE);
+
+    parseItemValue(&item, LP_ITEM_FIELD);
+    taosArrayPush(point->fields, &item);
+
+    start = pos + 1;
+  } while (line.z[pos] == ',');
+
+  taosArraySort(point->fields, compareLPItemKey);
+
+  SStrToken tsToken = {.z = line.z+start, .n = line.n-start};
+  setPointTimeStamp(point, tsToken);
+  parsePointTime(point);
+
+  goto done;
+
+  error:
+  // free array
+  return err;
+  done:
+  return 0;
+}
+
+
+int32_t tscParseLines(char* lines[], int numLines, SArray* points, SArray* failedLines) {
+  for (int32_t i = 0; i < numLines; ++i) {
+    SStrToken tkLine = {.z = lines[i], .n = strlen(lines[i])+1};
+    SLPPoint point;
+    tscParseLine(tkLine, &point);
+    taosArrayPush(points, &point);
+  }
+  return 0;
+}
+
+int taos_insert_by_lines(TAOS* taos, char* lines[], int numLines) {
+  SArray* lpPoints = taosArrayInit(numLines, sizeof(SLPPoint));
+  tscParseLines(lines, numLines, lpPoints, NULL);
+
+  size_t numPoints = taosArrayGetSize(lpPoints);
+  TAOS_SML_DATA_POINT* points = calloc(numPoints, sizeof(TAOS_SML_DATA_POINT));
+  for (int i = 0; i < numPoints; ++i) {
+    SLPPoint* lpPoint = taosArrayGet(lpPoints, i);
+    TAOS_SML_DATA_POINT* point = points+i;
+    point->stableName = calloc(1, strlen(lpPoint->sTableName)+1);
+    strncpy(point->stableName, lpPoint->sTableName, strlen(lpPoint->sTableName));
+    point->stableName[strlen(lpPoint->sTableName)] = '\0';
+
+    size_t lpTagSize = taosArrayGetSize(lpPoint->tags);
+    point->tags = calloc(lpTagSize, sizeof(TAOS_SML_KV));
+    point->tagNum = lpTagSize;
+    for (int j=0; j<lpTagSize; ++j) {
+      SLPItem* lpTag = taosArrayGet(lpPoint->tags, j);
+      TAOS_SML_KV* tagKv = point->tags + j;
+
+      size_t kenLen = strlen(lpTag->key);
+      tagKv->key = calloc(1, kenLen+1);
+      strncpy(tagKv->key, lpTag->key, kenLen);
+      tagKv->key[kenLen] = '\0';
+
+      tagKv->type = lpTag->type;
+      tagKv->length = lpTag->length;
+      tagKv->value = malloc(tagKv->length);
+      memcpy(tagKv->value, lpTag->value, tagKv->length);
+    }
+
+    size_t lpFieldsSize = taosArrayGetSize(lpPoint->fields);
+    point->fields = calloc(lpFieldsSize + 1, sizeof(TAOS_SML_KV));
+    point->fieldNum = lpFieldsSize + 1;
+
+    TAOS_SML_KV* tsField = point->fields + 0;
+    char tsKey[256];
+    snprintf(tsKey, 256, "_%s_ts", point->stableName);
+    size_t tsKeyLen = strlen(tsKey);
+    tsField->key = calloc(1, tsKeyLen+1);
+    strncpy(tsField->key, tsKey, tsKeyLen);
+    tsField->key[tsKeyLen] = '\0';
+    tsField->type = TSDB_DATA_TYPE_TIMESTAMP;
+    tsField->length = tDataTypes[TSDB_DATA_TYPE_TIMESTAMP].bytes;
+    tsField->value = malloc(tsField->length);
+    memcpy(tsField->value, &(lpPoint->ts), tsField->length);
+
+    for (int j=0; j<lpFieldsSize; ++j) {
+      SLPItem* lpField = taosArrayGet(lpPoint->fields, j);
+      TAOS_SML_KV* fieldKv = point->fields + j + 1;
+
+      size_t kenLen = strlen(lpField->key);
+      fieldKv->key = calloc(1, kenLen+1);
+      strncpy(fieldKv->key, lpField->key, kenLen);
+      fieldKv->key[kenLen] = '\0';
+
+      fieldKv->type = lpField->type;
+      fieldKv->length = lpField->length;
+      fieldKv->value = malloc(fieldKv->length);
+      memcpy(fieldKv->value, lpField->value, fieldKv->length);
+    }
+  }
+
+  taos_sml_insert(taos, points, numPoints);
+  return 0;
+}
+
diff --git a/src/inc/taos.h b/src/inc/taos.h
index 9f72945ef0..ca18c4fb93 100644
--- a/src/inc/taos.h
+++ b/src/inc/taos.h
@@ -169,6 +169,8 @@ DLL_EXPORT void taos_close_stream(TAOS_STREAM *tstr);
 
 DLL_EXPORT int taos_load_table_info(TAOS *taos, const char* tableNameList);
 
+DLL_EXPORT int taos_insert_by_lines(TAOS* taos, char* lines[], int numLines);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index 0f24df0f47..dc77677774 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -949,6 +949,15 @@ void verify_stream(TAOS* taos) {
   taos_close_stream(strm);
 }
 
+int32_t verify_schema_less(TAOS* taos) {
+  prepare_data(taos);
+  char* lines[] = {
+      "st,t1=3i,t2=4,t3=\"t3\" c1=3i,c3=L\"passit\",c2=false,c4=4 1626006833639162922"
+  };
+  int code = taos_insert_by_lines(taos, lines , 1);
+  return code;
+}
+
 int main(int argc, char *argv[]) {
   const char* host = "127.0.0.1";
   const char* user = "root";
@@ -967,6 +976,12 @@ int main(int argc, char *argv[]) {
   info = taos_get_client_info(taos);
   printf("client info: %s\n", info);
 
+  printf("************  verify query  *************\n");
+  int code = verify_schema_less(taos);
+  if (code == 0) {
+    return code;
+  }
+
   printf("************  verify query  *************\n");
   verify_query(taos);
 

From ee10305ddc472b5480587bd2c225f4645fdc9fb1 Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Mon, 12 Jul 2021 00:39:16 +0800
Subject: [PATCH 31/70] before time precision and create table with tags
 instead of autocreate

---
 src/client/src/tscParseLineProtocol.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index 3a88d2e906..4b9191a91f 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -492,7 +492,8 @@ int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints)
       int32_t idx = TARRAY_ELEM_IDX(point->schema->tags, kv->schema);
       TAOS_BIND* bind = taosArrayGet(tagBinds, idx);
       bind->buffer_type = kv->type;
-      bind->length = (uintptr_t*)&kv->length;
+      bind->length = malloc(sizeof(uintptr_t*));
+      *bind->length = kv->length;
       bind->buffer = kv->value;
       bind->is_null = NULL;
     }
@@ -514,7 +515,8 @@ int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints)
         int32_t idx = TARRAY_ELEM_IDX(point->schema->fields, kv->schema);
         TAOS_BIND* bind = taosArrayGet(colBinds, idx);
         bind->buffer_type = kv->type;
-        bind->length = (uintptr_t*)&kv->length;
+        bind->length = malloc(sizeof(uintptr_t*));
+        *bind->length = kv->length;
         bind->buffer = kv->value;
         bind->is_null = NULL;
       }

From 93c6fee9c5295cf3246fff619f2e1fbc378645ac Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Mon, 12 Jul 2021 08:38:51 +0800
Subject: [PATCH 32/70] can add two lines of one supertable/diffrent subtable

---
 src/client/src/tscParseLineProtocol.c | 12 ++++++------
 tests/examples/c/apitest.c            |  8 +++++---
 2 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index 4b9191a91f..1fde741c2b 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -540,13 +540,13 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
 
   for (int i = 0; i < numPoint; ++i) {
     TAOS_SML_DATA_POINT* point = &points[i];
-    SSmlSTableSchema** ppStableSchema = taosHashGet(sname2shema, point->stableName, TSDB_TABLE_NAME_LEN);
+    size_t stableNameLen = strlen(point->stableName);
+    SSmlSTableSchema** ppStableSchema = taosHashGet(sname2shema, point->stableName, stableNameLen);
     SSmlSTableSchema* pStableSchema = NULL;
     if (ppStableSchema) {
       pStableSchema= *ppStableSchema;
     } else {
       SSmlSTableSchema schema;
-      size_t stableNameLen = strlen(point->stableName);
       strncpy(schema.sTableName, point->stableName, stableNameLen);
       schema.sTableName[stableNameLen] = '\0';
       schema.fields = taosArrayInit(64, sizeof(SSchema));
@@ -730,13 +730,13 @@ int32_t parseItemValue(SLPItem* item, LPItemKind kind) {
       item->length = (int16_t)tDataTypes[item->type].bytes;
       item->value = malloc(item->length);
       char* endptr = NULL;
-      *(item->value) = strtoll(sv, &endptr, 10);
+      *(int64_t*)(item->value) = strtoll(sv, &endptr, 10);
     } else {
       item->type = TSDB_DATA_TYPE_DOUBLE;
       item->length = (int16_t)tDataTypes[item->type].bytes;
       item->value = malloc(item->length);
       char* endptr = NULL;
-      *(item->value) = strtold(sv, &endptr);
+      *(double*)(item->value) = strtold(sv, &endptr);
     }
   } else if ((sv[0] == 'L' && sv[1] =='"') || sv[0] == '"' ) {
     if (sv[0] == 'L') {
@@ -744,7 +744,7 @@ int32_t parseItemValue(SLPItem* item, LPItemKind kind) {
       uint32_t bytes = item->valueToken.n - 3;
       item->length = bytes;
       item->value = malloc(bytes);
-      memcpy(item->value, sv+1, bytes);
+      memcpy(item->value, sv+2, bytes);
     } else if (sv[0]=='"'){
       item->type = TSDB_DATA_TYPE_BINARY;
       uint32_t bytes = item->valueToken.n - 2;
@@ -756,7 +756,7 @@ int32_t parseItemValue(SLPItem* item, LPItemKind kind) {
     item->type = TSDB_DATA_TYPE_BOOL;
     item->length = tDataTypes[item->type].bytes;
     item->value = malloc(tDataTypes[item->type].bytes);
-    *(item->value) = tolower(sv[0])=='t' ? TSDB_TRUE : TSDB_FALSE;
+    *(uint8_t*)(item->value) = tolower(sv[0])=='t' ? TSDB_TRUE : TSDB_FALSE;
   }
   return 0;
 }
diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index dc77677774..04a03df6fa 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -952,9 +952,11 @@ void verify_stream(TAOS* taos) {
 int32_t verify_schema_less(TAOS* taos) {
   prepare_data(taos);
   char* lines[] = {
-      "st,t1=3i,t2=4,t3=\"t3\" c1=3i,c3=L\"passit\",c2=false,c4=4 1626006833639162922"
+      "st,t1=3i,t2=4,t3=\"t3\" c1=3i,c3=L\"passit\",c2=false,c4=4 1626006833639",
+      "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833640",
+      "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833642"
   };
-  int code = taos_insert_by_lines(taos, lines , 1);
+  int code = taos_insert_by_lines(taos, lines , 2);
   return code;
 }
 
@@ -976,7 +978,7 @@ int main(int argc, char *argv[]) {
   info = taos_get_client_info(taos);
   printf("client info: %s\n", info);
 
-  printf("************  verify query  *************\n");
+  printf("************  verify shemaless  *************\n");
   int code = verify_schema_less(taos);
   if (code == 0) {
     return code;

From 3d70319913feb1a486f47542e4b9e3412e045bcc Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Mon, 12 Jul 2021 09:17:15 +0800
Subject: [PATCH 33/70] create child table with tags

---
 src/client/src/tscParseLineProtocol.c | 87 +++++++++++++++++----------
 tests/examples/c/apitest.c            |  2 +-
 2 files changed, 57 insertions(+), 32 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index 1fde741c2b..dd0e64ba84 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -377,39 +377,26 @@ int32_t getChildTableName(TAOS_SML_DATA_POINT* point, char* tableName, int* tabl
   return 0;
 }
 
-int32_t getPreparedSQL(const char* sTableName, SArray* tagsSchema, SArray* colsSchema, char* result, int16_t freeBytes) {
+int32_t creatChildTableIfNotExists(TAOS* taos, const char* cTableName, const char* sTableName, SArray* tagsSchema, SArray* tagsBind) {
   size_t numTags = taosArrayGetSize(tagsSchema);
-  size_t numCols = taosArrayGetSize(colsSchema);
-  sprintf(result, "insert into ? using %s", sTableName);
+  char sql[TSDB_MAX_BINARY_LEN] = {0};
+  int freeBytes = TSDB_MAX_BINARY_LEN;
+  sprintf(sql, "create table if not exists %s using %s", cTableName, sTableName);
 
-//  snprintf(result+strlen(result), freeBytes-strlen(result), "(");
-//  for (int i = 0; i < numTags; ++i) {
-//    SSchema* tagSchema = taosArrayGet(tagsSchema, i);
-//    snprintf(result+strlen(result), freeBytes-strlen(result), "%s,", tagSchema->name);
-//  }
-//  snprintf(result + strlen(result)-1, freeBytes-strlen(result)+1, ")");
+  snprintf(sql+strlen(sql), freeBytes-strlen(sql), "(");
+  for (int i = 0; i < numTags; ++i) {
+    SSchema* tagSchema = taosArrayGet(tagsSchema, i);
+    snprintf(sql+strlen(sql), freeBytes-strlen(sql), "%s,", tagSchema->name);
+  }
+  snprintf(sql + strlen(sql) - 1, freeBytes-strlen(sql)+1, ")");
 
-  snprintf(result + strlen(result), freeBytes-strlen(result), " tags (");
+  snprintf(sql + strlen(sql), freeBytes-strlen(sql), " tags (");
 
   for (int i = 0; i < numTags; ++i) {
-    snprintf(result+strlen(result), freeBytes-strlen(result), "?,");
+    snprintf(sql+strlen(sql), freeBytes-strlen(sql), "?,");
   }
-  snprintf(result + strlen(result)-1, freeBytes-strlen(result)+1, ") (");
+  snprintf(sql + strlen(sql) - 1, freeBytes-strlen(sql)+1, ")");
 
-  for (int i = 0; i < numCols; ++i) {
-    SSchema* colSchema = taosArrayGet(colsSchema, i);
-    snprintf(result+strlen(result), freeBytes-strlen(result), "%s,", colSchema->name);
-  }
-  snprintf(result + strlen(result)-1, freeBytes-strlen(result)+1, ") values (");
-
-  for (int i = 0; i < numCols; ++i) {
-    snprintf(result+strlen(result), freeBytes-strlen(result), "?,");
-  }
-  snprintf(result + strlen(result)-1, freeBytes-strlen(result)+1, ")");
-  return 0;
-}
-
-int32_t insertBatch(TAOS* taos, char* sql, char* cTableName, SArray* tagsBind, SArray* rowsBind) {
   TAOS_STMT* stmt = taos_stmt_init(taos);
   int32_t code;
   code = taos_stmt_prepare(stmt, sql, strlen(sql));
@@ -418,7 +405,47 @@ int32_t insertBatch(TAOS* taos, char* sql, char* cTableName, SArray* tagsBind, S
     return code;
   }
 
-  code = taos_stmt_set_tbname_tags(stmt, cTableName, TARRAY_GET_START(tagsBind));
+  code = taos_stmt_bind_param(stmt, TARRAY_GET_START(tagsBind));
+  if (code != 0) {
+    printf("%s", taos_stmt_errstr(stmt));
+    return code;
+  }
+
+  code = taos_stmt_execute(stmt);
+  if (code != 0) {
+    printf("%s", taos_stmt_errstr(stmt));
+    return code;
+  }
+  TAOS_RES* res = taos_stmt_use_result(stmt);
+  return taos_errno(res);
+}
+
+int32_t insertBatch(TAOS* taos,  char* cTableName, SArray* colsSchema, SArray* rowsBind) {
+  size_t numCols = taosArrayGetSize(colsSchema);
+  char sql[TSDB_MAX_BINARY_LEN];
+  int32_t freeBytes = TSDB_MAX_BINARY_LEN;
+  sprintf(sql, "insert into ? (");
+
+  for (int i = 0; i < numCols; ++i) {
+    SSchema* colSchema = taosArrayGet(colsSchema, i);
+    snprintf(sql+strlen(sql), freeBytes-strlen(sql), "%s,", colSchema->name);
+  }
+  snprintf(sql + strlen(sql)-1, freeBytes-strlen(sql)+1, ") values (");
+
+  for (int i = 0; i < numCols; ++i) {
+    snprintf(sql+strlen(sql), freeBytes-strlen(sql), "?,");
+  }
+  snprintf(sql + strlen(sql)-1, freeBytes-strlen(sql)+1, ")");
+
+  TAOS_STMT* stmt = taos_stmt_init(taos);
+  int32_t code;
+  code = taos_stmt_prepare(stmt, sql, strlen(sql));
+  if (code != 0) {
+    printf("%s", taos_stmt_errstr(stmt));
+    return code;
+  }
+
+  code = taos_stmt_set_tbname(stmt, cTableName);
   if (code != 0) {
     printf("%s", taos_stmt_errstr(stmt));
     return code;
@@ -478,7 +505,6 @@ int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints)
     TAOS_SML_DATA_POINT * point = taosArrayGetP(cTablePoints, 0);
     int32_t numTags = taosArrayGetSize(point->schema->tags);
     int32_t numCols = taosArrayGetSize(point->schema->fields);
-    char* stableName = point->stableName;
     char* ctableName = point->childTableName;
 
     SArray* tagBinds = taosArrayInit(numTags, sizeof(TAOS_BIND));
@@ -523,9 +549,8 @@ int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints)
       taosArrayPush(rowsBind, &colBinds);
     }
 
-    char sql[TSDB_MAX_BINARY_LEN];
-    getPreparedSQL(stableName, point->schema->tags, point->schema->fields, sql, TSDB_MAX_BINARY_LEN);
-    insertBatch(taos, sql, ctableName, tagBinds, rowsBind);
+    creatChildTableIfNotExists(taos, point->childTableName, point->stableName, point->schema->tags, tagBinds);
+    insertBatch(taos, ctableName, point->schema->fields, rowsBind);
 
     pCTablePoints = taosHashIterate(cname2points, pCTablePoints);
   }
diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index 04a03df6fa..5272dafaf1 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -956,7 +956,7 @@ int32_t verify_schema_less(TAOS* taos) {
       "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833640",
       "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833642"
   };
-  int code = taos_insert_by_lines(taos, lines , 2);
+  int code = taos_insert_by_lines(taos, lines , 3);
   return code;
 }
 

From dec30e4473346b7d4529c6633549ffcb0867501a Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Mon, 12 Jul 2021 10:16:30 +0800
Subject: [PATCH 34/70] add timestamp precision support

---
 src/client/src/tscParseLineProtocol.c | 39 ++++++++++++++++++++-------
 tests/examples/c/apitest.c            | 18 +++++++++----
 2 files changed, 42 insertions(+), 15 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index dd0e64ba84..c0cc2ea3ae 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -21,6 +21,7 @@ typedef struct  {
   SHashObj* fieldHash;
   SArray* tags; //SArray<SSchema>
   SArray* fields; //SArray<SSchema>
+  uint8_t precision;
 } SSmlSTableSchema;
 
 typedef struct {
@@ -117,6 +118,7 @@ int32_t loadTableMeta(TAOS* taos, char* tableName, SSmlSTableSchema* schema) {
   taosHashGetClone(tscTableMetaInfo, fullTableName, strlen(fullTableName), NULL, tableMeta, -1);
 
   tstrncpy(schema->sTableName, tableName, strlen(tableName)+1);
+  schema->precision = tableMeta->tableInfo.precision;
   for (int i=0; i<tableMeta->tableInfo.numOfColumns; ++i) {
     SSchema field;
     tstrncpy(field.name, tableMeta->schema[i].name, strlen(tableMeta->schema[i].name)+1);
@@ -486,6 +488,25 @@ int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints)
       strncpy(point->childTableName, childTableName, tableNameLen);
       point->childTableName[tableNameLen] = '\0';
     }
+
+    for (int j = 0; j < point->tagNum; ++j) {
+      TAOS_SML_KV* kv =  point->tags + j;
+      if (kv->type == TSDB_DATA_TYPE_TIMESTAMP) {
+        int64_t ts = *(int64_t*)(kv->value);
+        ts = convertTimePrecision(ts, TSDB_TIME_PRECISION_NANO, point->schema->precision);
+        *(int64_t*)(kv->value) = ts;
+      }
+    }
+
+    for (int j = 0; j < point->fieldNum; ++j) {
+      TAOS_SML_KV* kv =  point->fields + j;
+      if (kv->type == TSDB_DATA_TYPE_TIMESTAMP) {
+        int64_t ts = *(int64_t*)(kv->value);
+        ts = convertTimePrecision(ts, TSDB_TIME_PRECISION_NANO, point->schema->precision);
+        *(int64_t*)(kv->value) = ts;
+      }
+    }
+
     SArray* cTablePoints = NULL;
     SArray** pCTablePoints = taosHashGet(cname2points, point->childTableName, strlen(point->childTableName));
     if (pCTablePoints) {
@@ -596,7 +617,6 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
     point->schema = pStableSchema;
   }
 
-  SArray* schemaActions = taosArrayInit(32, sizeof(SSchemaAction));
   size_t numStable = taosArrayGetSize(stableArray);
   for (int i = 0; i < numStable; ++i) {
     SSmlSTableSchema* pointSchema = taosArrayGet(stableArray, i);
@@ -615,8 +635,10 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
       memcpy(schemaAction.createSTable.sTableName, pointSchema->sTableName, TSDB_TABLE_NAME_LEN);
       schemaAction.createSTable.tags = pointSchema->tags;
       schemaAction.createSTable.fields = pointSchema->fields;
-      taosArrayPush(schemaActions, &schemaAction);
-    }else if (code == TSDB_CODE_SUCCESS) {
+      applySchemaAction(taos, &schemaAction);
+      code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
+      pointSchema->precision = dbSchema.precision;
+    } else if (code == TSDB_CODE_SUCCESS) {
       size_t pointTagSize = taosArrayGetSize(pointSchema->tags);
       size_t pointFieldSize = taosArrayGetSize(pointSchema->fields);
 
@@ -629,7 +651,7 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
         bool actionNeeded = false;
         generateSchemaAction(pointTag, dbTagHash, true, pointSchema->sTableName, &schemaAction, &actionNeeded);
         if (actionNeeded) {
-          taosArrayPush(schemaActions, &schemaAction);
+          applySchemaAction(taos, &schemaAction);
         }
       }
 
@@ -643,19 +665,16 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
         bool actionNeeded = false;
         generateSchemaAction(pointCol, dbFieldHash, false, pointSchema->sTableName, &schemaAction, &actionNeeded);
         if (actionNeeded) {
-          taosArrayPush(schemaActions, &schemaAction);
+          applySchemaAction(taos, &schemaAction);
         }
       }
+
+      pointSchema->precision = dbSchema.precision;
     } else {
       return code;
     }
   }
 
-  for (int i = 0; i < taosArrayGetSize(schemaActions); ++i) {
-    SSchemaAction* action = taosArrayGet(schemaActions, i);
-    applySchemaAction(taos, action);
-  }
-
   insertPoints(taos, points, numPoint);
   return code;
 }
diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index 5272dafaf1..656d5fd217 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -12,7 +12,7 @@ static void prepare_data(TAOS* taos) {
   result = taos_query(taos, "drop database if exists test;");
   taos_free_result(result);
   usleep(100000);
-  result = taos_query(taos, "create database test;");
+  result = taos_query(taos, "create database test precision 'us';");
   taos_free_result(result);
   usleep(100000);
   taos_select_db(taos, "test");
@@ -950,11 +950,19 @@ void verify_stream(TAOS* taos) {
 }
 
 int32_t verify_schema_less(TAOS* taos) {
-  prepare_data(taos);
+  TAOS_RES *result;
+  result = taos_query(taos, "drop database if exists test;");
+  taos_free_result(result);
+  usleep(100000);
+  result = taos_query(taos, "create database test precision 'us';");
+  taos_free_result(result);
+  usleep(100000);
+  taos_select_db(taos, "test");
+
   char* lines[] = {
-      "st,t1=3i,t2=4,t3=\"t3\" c1=3i,c3=L\"passit\",c2=false,c4=4 1626006833639",
-      "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833640",
-      "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833642"
+      "st,t1=3i,t2=4,t3=\"t3\" c1=3i,c3=L\"passit\",c2=false,c4=4 1626006833639000000",
+      "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833640000000",
+      "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833642000000"
   };
   int code = taos_insert_by_lines(taos, lines , 3);
   return code;

From ab67d612f0ee3e365b1357ffa5ec3aef4936b6b2 Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Mon, 12 Jul 2021 10:30:54 +0800
Subject: [PATCH 35/70] fixing exsiting stable

---
 src/client/src/tscParseLineProtocol.c | 2 +-
 tests/examples/c/apitest.c            | 6 ++++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index c0cc2ea3ae..61f9cd9e76 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -225,7 +225,7 @@ int32_t addTaosFieldToHashAndArray(TAOS_SML_KV* smlKv, SHashObj* hash, SArray* a
 int32_t generateSchemaAction(SSchema* pointColField, SHashObj* dbAttrHash, bool isTag, char sTableName[],
                                        SSchemaAction* action, bool* actionNeeded) {
   SSchema** ppDbAttr = taosHashGet(dbAttrHash, pointColField->name, strlen(pointColField->name));
-  if (*ppDbAttr) {
+  if (ppDbAttr) {
     SSchema* dbAttr = *ppDbAttr;
     if (pointColField->type != dbAttr->type) {
       //todo error
diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index 656d5fd217..5cb3f5762a 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -958,13 +958,15 @@ int32_t verify_schema_less(TAOS* taos) {
   taos_free_result(result);
   usleep(100000);
   taos_select_db(taos, "test");
+  result = taos_query(taos, "create stable ste(ts timestamp, f int) tags(t1 bigint)");
 
   char* lines[] = {
       "st,t1=3i,t2=4,t3=\"t3\" c1=3i,c3=L\"passit\",c2=false,c4=4 1626006833639000000",
       "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833640000000",
-      "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833642000000"
+      "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833642000000",
+      "ste,t2=5,t3=L\"ste\" c1=true,c2=4 1626056811823316532"
   };
-  int code = taos_insert_by_lines(taos, lines , 3);
+  int code = taos_insert_by_lines(taos, lines , 4);
   return code;
 }
 

From 14cab541f7cb6235a8b5ab0d16fc1a1aacb124ed Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Mon, 12 Jul 2021 11:27:34 +0800
Subject: [PATCH 36/70] before tsim/log/memory leak handling

---
 tests/examples/c/apitest.c | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index 5cb3f5762a..409140e0f2 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -957,16 +957,20 @@ int32_t verify_schema_less(TAOS* taos) {
   result = taos_query(taos, "create database test precision 'us';");
   taos_free_result(result);
   usleep(100000);
+
   taos_select_db(taos, "test");
   result = taos_query(taos, "create stable ste(ts timestamp, f int) tags(t1 bigint)");
+  taos_free_result(result);
+  usleep(100000);
 
   char* lines[] = {
       "st,t1=3i,t2=4,t3=\"t3\" c1=3i,c3=L\"passit\",c2=false,c4=4 1626006833639000000",
       "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833640000000",
       "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833642000000",
-      "ste,t2=5,t3=L\"ste\" c1=true,c2=4 1626056811823316532"
+      "ste,t2=5,t3=L\"ste\" c1=true,c2=4,c3=\"iam\" 1626056811823316532",
+      "ste,t2=5,t3=L\"ste2\" c3=\"iamszhou\",c4=false 1626056811843316532"
   };
-  int code = taos_insert_by_lines(taos, lines , 4);
+  int code = taos_insert_by_lines(taos, lines , 5);
   return code;
 }
 

From 3abecfdda9048d261103159d14eb1c9c6ace61a7 Mon Sep 17 00:00:00 2001
From: Elias Soong <elias.soong@gmail.com>
Date: Mon, 12 Jul 2021 14:17:43 +0800
Subject: [PATCH 37/70] [TD-4780] <docs>: unpublished WAL & FSNYC hot
 modification feature.

---
 documentation20/cn/11.administrator/docs.md |  4 ++--
 documentation20/cn/12.taos-sql/docs.md      | 10 ----------
 2 files changed, 2 insertions(+), 12 deletions(-)

diff --git a/documentation20/cn/11.administrator/docs.md b/documentation20/cn/11.administrator/docs.md
index 753f91f589..19e4b761ba 100644
--- a/documentation20/cn/11.administrator/docs.md
+++ b/documentation20/cn/11.administrator/docs.md
@@ -123,8 +123,8 @@ taosd -C
 - minRows：文件块中记录的最小条数。单位为条，默认值：100。
 - maxRows：文件块中记录的最大条数。单位为条，默认值：4096。
 - comp：文件压缩标志位。0：关闭；1：一阶段压缩；2：两阶段压缩。默认值：2。（可通过 alter database 修改）
-- wal：WAL级别。1：写wal，但不执行fsync；2：写wal, 而且执行fsync。默认值：1。（在 taos.cfg 中参数名需要写作 walLevel）（可通过 alter database 修改）
-- fsync：当wal设置为2时，执行fsync的周期。设置为0，表示每次写入，立即执行fsync。单位为毫秒，默认值：3000。（可通过 alter database 修改）
+- wal：WAL级别。1：写wal，但不执行fsync；2：写wal, 而且执行fsync。默认值：1。（在 taos.cfg 中参数名需要写作 walLevel）
+- fsync：当wal设置为2时，执行fsync的周期。设置为0，表示每次写入，立即执行fsync。单位为毫秒，默认值：3000。
 - cache：内存块的大小。单位为兆字节（MB），默认值：16。
 - blocks：每个VNODE（TSDB）中有多少cache大小的内存块。因此一个VNODE的用的内存大小粗略为（cache * blocks）。单位为块，默认值：4。（可通过 alter database 修改）
 - replica：副本个数。取值范围：1-3，单位为个，默认值：1。（可通过 alter database 修改）
diff --git a/documentation20/cn/12.taos-sql/docs.md b/documentation20/cn/12.taos-sql/docs.md
index d5cc8675a4..4a92effe6d 100644
--- a/documentation20/cn/12.taos-sql/docs.md
+++ b/documentation20/cn/12.taos-sql/docs.md
@@ -129,16 +129,6 @@ TDengine 缺省的时间戳是毫秒精度，但通过在 CREATE DATABASE 时传
     CACHELAST 参数控制是否在内存中缓存子表的最近数据。缺省值为 0，取值范围 [0, 1, 2, 3]。其中 0 表示不缓存，1 表示缓存子表最近一行数据，2 表示缓存子表每一列的最近的非 NULL 值，3 表示同时打开缓存最近行和列功能。（从 2.0.11.0 版本开始支持参数值 [0, 1]，从 2.1.2.0 版本开始支持参数值 [0, 1, 2, 3]。）  
     说明：缓存最近行，将显著改善 LAST_ROW 函数的性能表现；缓存每列的最近非 NULL 值，将显著改善无特殊影响（WHERE、ORDER BY、GROUP BY、INTERVAL）下的 LAST 函数的性能表现。
 
-    ```mysql
-    ALTER DATABASE db_name WAL 1;
-    ```
-    WAL 参数控制 WAL 日志的落盘方式。缺省值为 1，取值范围为 [1, 2]。1 表示写 WAL，但不执行 fsync；2 表示写 WAL，而且执行 fsync。
-
-    ```mysql
-    ALTER DATABASE db_name FSYNC 3000;
-    ```
-    FSYNC 参数控制执行 fsync 操作的周期。缺省值为 3000，单位是毫秒，取值范围为 [0, 180000]。如果设置为 0，表示每次写入，立即执行 fsync。该设置项主要用于调节 WAL 参数设为 2 时的系统行为。
-
     **Tips**: 以上所有参数修改后都可以用show databases来确认是否修改成功。另外，从 2.1.3.0 版本开始，修改这些参数后无需重启服务器即可生效。
 
 - **显示系统所有数据库**

From 4f0266b390ccdc00dc2b1c435efed3a7fbb824f8 Mon Sep 17 00:00:00 2001
From: tomchon <haoran920c@163.com>
Date: Mon, 12 Jul 2021 14:19:51 +0800
Subject: [PATCH 38/70] [TD-5087]<test>: update testcase that compressing wal
 logs

---
 tests/pytest/wal/sdbComp.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/pytest/wal/sdbComp.py b/tests/pytest/wal/sdbComp.py
index c0ac02610f..56b18c49eb 100644
--- a/tests/pytest/wal/sdbComp.py
+++ b/tests/pytest/wal/sdbComp.py
@@ -28,6 +28,7 @@ class TDTestCase:
         tdSql.init(conn.cursor(), logSql)
         
     def getBuildPath(self):
+        global selfPath
         selfPath = os.path.dirname(os.path.realpath(__file__))
         
         if ("community" in selfPath):
@@ -53,7 +54,7 @@ class TDTestCase:
             tdLog.info("taosd found in %s" % buildPath)
 
         binPath = buildPath+ "/build/bin/"
-        testPath = buildPath[:buildPath.find("debug")]
+        testPath = selfPath+ "/../../../"
         walFilePath = testPath + "/sim/dnode1/data/mnode_bak/wal/"
 
         #new db and insert data

From 4486cae1803b0772f68a7fdfad56a7adac4c7a35 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Mon, 12 Jul 2021 17:08:54 +0800
Subject: [PATCH 39/70] [TD-5136]<feature>: taosdemo simulate real senario.
 (#6833)

* [TD-5136]<feature>: taosdemo simulate real senario.

* update test case according to taosdemo change
---
 src/kit/taosdemo/taosdemo.c                   | 3426 +++++++++--------
 tests/pytest/tools/taosdemoTest.py            |    2 +-
 tests/pytest/tools/taosdemoTestTblAlt.py      |    2 +-
 .../pytest/tools/taosdemoTestWithoutMetric.py |    2 +-
 4 files changed, 1755 insertions(+), 1677 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index 085f266149..c92b8e41a6 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -198,44 +198,45 @@ enum _describe_table_index {
 static char *g_dupstr = NULL;
 
 typedef struct SArguments_S {
-  char *   metaFile;
-  uint32_t test_mode;
-  char *   host;
-  uint16_t port;
-  uint16_t iface;
-  char *   user;
-  char *   password;
-  char *   database;
-  int      replica;
-  char *   tb_prefix;
-  char *   sqlFile;
-  bool     use_metric;
-  bool     drop_database;
-  bool     insert_only;
-  bool     answer_yes;
-  bool     debug_print;
-  bool     verbose_print;
-  bool     performance_print;
-  char *   output_file;
-  bool     async_mode;
-  char *   datatype[MAX_NUM_DATATYPE + 1];
-  uint32_t len_of_binary;
-  uint32_t num_of_CPR;
-  uint32_t num_of_threads;
-  uint64_t insert_interval;
-  int64_t  query_times;
-  uint32_t interlace_rows;
-  uint32_t num_of_RPR;                  // num_of_records_per_req
-  uint64_t max_sql_len;
-  int64_t  num_of_tables;
-  int64_t  num_of_DPT;
-  int      abort;
-  uint32_t disorderRatio;               // 0: no disorder, >0: x%
-  int      disorderRange;               // ms or us by database precision
-  uint32_t method_of_delete;
-  char **  arg_list;
-  uint64_t totalInsertRows;
-  uint64_t totalAffectedRows;
+    char *   metaFile;
+    uint32_t test_mode;
+    char *   host;
+    uint16_t port;
+    uint16_t iface;
+    char *   user;
+    char *   password;
+    char *   database;
+    int      replica;
+    char *   tb_prefix;
+    char *   sqlFile;
+    bool     use_metric;
+    bool     drop_database;
+    bool     insert_only;
+    bool     answer_yes;
+    bool     debug_print;
+    bool     verbose_print;
+    bool     performance_print;
+    char *   output_file;
+    bool     async_mode;
+    char *   datatype[MAX_NUM_DATATYPE + 1];
+    uint32_t len_of_binary;
+    uint32_t num_of_CPR;
+    uint32_t num_of_threads;
+    uint64_t insert_interval;
+    int64_t  query_times;
+    uint32_t interlace_rows;
+    uint32_t num_of_RPR;                  // num_of_records_per_req
+    uint64_t max_sql_len;
+    int64_t  num_of_tables;
+    int64_t  num_of_DPT;
+    int      abort;
+    uint32_t disorderRatio;               // 0: no disorder, >0: x%
+    int      disorderRange;               // ms or us by database precision
+    uint32_t method_of_delete;
+    char **  arg_list;
+    uint64_t totalInsertRows;
+    uint64_t totalAffectedRows;
+    bool     demo_mode;                  // use default column name and semi-random data
 } SArguments;
 
 typedef struct SColumn_S {
@@ -427,47 +428,47 @@ typedef struct SQueryMetaInfo_S {
 } SQueryMetaInfo;
 
 typedef struct SThreadInfo_S {
-  TAOS *    taos;
-  TAOS_STMT *stmt;
-  int       threadID;
-  char      db_name[TSDB_DB_NAME_LEN];
-  uint32_t  time_precision;
-  char      filePath[4096];
-  FILE      *fp;
-  char      tb_prefix[TSDB_TABLE_NAME_LEN];
-  uint64_t  start_table_from;
-  uint64_t  end_table_to;
-  int64_t   ntables;
-  uint64_t  data_of_rate;
-  int64_t   start_time;
-  char*     cols;
-  bool      use_metric;
-  SSuperTable* superTblInfo;
-  char      *buffer;    // sql cmd buffer
+    TAOS *    taos;
+    TAOS_STMT *stmt;
+    int       threadID;
+    char      db_name[TSDB_DB_NAME_LEN];
+    uint32_t  time_precision;
+    char      filePath[4096];
+    FILE      *fp;
+    char      tb_prefix[TSDB_TABLE_NAME_LEN];
+    uint64_t  start_table_from;
+    uint64_t  end_table_to;
+    int64_t   ntables;
+    uint64_t  data_of_rate;
+    int64_t   start_time;
+    char*     cols;
+    bool      use_metric;
+    SSuperTable* superTblInfo;
+    char      *buffer;    // sql cmd buffer
 
-  // for async insert
-  tsem_t    lock_sem;
-  int64_t   counter;
-  uint64_t  st;
-  uint64_t  et;
-  uint64_t  lastTs;
+    // for async insert
+    tsem_t    lock_sem;
+    int64_t   counter;
+    uint64_t  st;
+    uint64_t  et;
+    uint64_t  lastTs;
 
-  // sample data
-  int64_t   samplePos;
-  // statistics
-  uint64_t  totalInsertRows;
-  uint64_t  totalAffectedRows;
+    // sample data
+    int64_t   samplePos;
+    // statistics
+    uint64_t  totalInsertRows;
+    uint64_t  totalAffectedRows;
 
-  // insert delay statistics
-  uint64_t  cntDelay;
-  uint64_t  totalDelay;
-  uint64_t  avgDelay;
-  uint64_t  maxDelay;
-  uint64_t  minDelay;
+    // insert delay statistics
+    uint64_t  cntDelay;
+    uint64_t  totalDelay;
+    uint64_t  avgDelay;
+    uint64_t  maxDelay;
+    uint64_t  minDelay;
 
-  // seq of query or subscribe
-  uint64_t  querySeq;   // sequence number of sql command
-  TAOS_SUB*  tsub;
+    // seq of query or subscribe
+    uint64_t  querySeq;   // sequence number of sql command
+    TAOS_SUB*  tsub;
 
 } threadInfo;
 
@@ -552,6 +553,8 @@ static int postProceSql(char *host, struct sockaddr_in *pServAddr,
         uint16_t port, char* sqlstr, threadInfo *pThreadInfo);
 static int64_t getTSRandTail(int64_t timeStampStep, int32_t seq,
         int disorderRatio, int disorderRange);
+static bool getInfoFromJsonFile(char* file);
+static void init_rand_data();
 
 /* ************ Global variables ************  */
 
@@ -563,53 +566,55 @@ char *aggreFunc[] = {"*", "count(*)", "avg(col0)", "sum(col0)",
     "max(col0)", "min(col0)", "first(col0)", "last(col0)"};
 
 SArguments g_args = {
-                     NULL,            // metaFile
-                     0,               // test_mode
-                     "127.0.0.1",     // host
-                     6030,            // port
-                     TAOSC_IFACE,     // iface
-                     "root",          // user
-                     #ifdef _TD_POWER_
-                     "powerdb",      // password
-                     #elif (_TD_TQ_ == true)
-                     "tqueue",      // password
-                     #else
-                     "taosdata",      // password
-                     #endif
-                     "test",          // database
-                     1,               // replica
-                     "t",             // tb_prefix
-                     NULL,            // sqlFile
-                     true,            // use_metric
-                     true,            // drop_database
-                     true,            // insert_only
-                     false,           // debug_print
-                     false,           // verbose_print
-                     false,           // performance statistic print
-                     false,           // answer_yes;
-                     "./output.txt",  // output_file
-                     0,               // mode : sync or async
-                     {
-                     "INT",           // datatype
-                     "INT",           // datatype
-                     "INT",           // datatype
-                     "INT",           // datatype
-                     },
-                     16,              // len_of_binary
-                     4,               // num_of_CPR
-                     10,              // num_of_connections/thread
-                     0,               // insert_interval
-                     1,               // query_times
-                     0,               // interlace_rows;
-                     30000,           // num_of_RPR
-                     (1024*1024),     // max_sql_len
-                     10000,           // num_of_tables
-                     10000,           // num_of_DPT
-                     0,               // abort
-                     0,               // disorderRatio
-                     1000,            // disorderRange
-                     1,               // method_of_delete
-                     NULL             // arg_list
+    NULL,            // metaFile
+    0,               // test_mode
+    "127.0.0.1",     // host
+    6030,            // port
+    TAOSC_IFACE,     // iface
+    "root",          // user
+#ifdef _TD_POWER_
+    "powerdb",      // password
+#elif (_TD_TQ_ == true)
+    "tqueue",      // password
+#else
+    "taosdata",      // password
+#endif
+    "test",          // database
+    1,               // replica
+    "d",             // tb_prefix
+    NULL,            // sqlFile
+    true,            // use_metric
+    true,            // drop_database
+    true,            // insert_only
+    false,           // debug_print
+    false,           // verbose_print
+    false,           // performance statistic print
+    false,           // answer_yes;
+    "./output.txt",  // output_file
+    0,               // mode : sync or async
+    {
+        "FLOAT",         // datatype
+        "INT",           // datatype
+        "FLOAT",         // datatype
+    },
+    16,              // len_of_binary
+    4,               // num_of_CPR
+    10,              // num_of_connections/thread
+    0,               // insert_interval
+    1,               // query_times
+    0,               // interlace_rows;
+    30000,           // num_of_RPR
+    (1024*1024),     // max_sql_len
+    10000,           // num_of_tables
+    10000,           // num_of_DPT
+    0,               // abort
+    0,               // disorderRatio
+    1000,            // disorderRange
+    1,               // method_of_delete
+    NULL,            // arg_list
+    0,               // totalInsertRows;
+    0,               // totalAffectedRows;
+    true,            // demo_mode;
 };
 
 
@@ -673,645 +678,674 @@ static void printVersion() {
 }
 
 static void printHelp() {
-  char indent[10] = "        ";
-  printf("%s%s%s%s\n", indent, "-f", indent,
-          "The meta file to the execution procedure. Default is './meta.json'.");
-  printf("%s%s%s%s\n", indent, "-u", indent,
-          "The TDengine user name to use when connecting to the server. Default is 'root'.");
+    char indent[10] = "        ";
+    printf("%s%s%s%s\n", indent, "-f", indent,
+            "The meta file to the execution procedure. Default is './meta.json'.");
+    printf("%s%s%s%s\n", indent, "-u", indent,
+            "The TDengine user name to use when connecting to the server. Default is 'root'.");
 #ifdef _TD_POWER_
-  printf("%s%s%s%s\n", indent, "-P", indent,
-          "The password to use when connecting to the server. Default is 'powerdb'.");
-  printf("%s%s%s%s\n", indent, "-c", indent,
-          "Configuration directory. Default is '/etc/power/'.");
+    printf("%s%s%s%s\n", indent, "-P", indent,
+            "The password to use when connecting to the server. Default is 'powerdb'.");
+    printf("%s%s%s%s\n", indent, "-c", indent,
+            "Configuration directory. Default is '/etc/power/'.");
 #elif (_TD_TQ_ == true)
-	printf("%s%s%s%s\n", indent, "-P", indent,
-			"The password to use when connecting to the server. Default is 'tqueue'.");
-	printf("%s%s%s%s\n", indent, "-c", indent,
-			"Configuration directory. Default is '/etc/tq/'.");
+    printf("%s%s%s%s\n", indent, "-P", indent,
+            "The password to use when connecting to the server. Default is 'tqueue'.");
+    printf("%s%s%s%s\n", indent, "-c", indent,
+            "Configuration directory. Default is '/etc/tq/'.");
 #else
-  printf("%s%s%s%s\n", indent, "-P", indent,
-          "The password to use when connecting to the server. Default is 'taosdata'.");
-  printf("%s%s%s%s\n", indent, "-c", indent,
-          "Configuration directory. Default is '/etc/taos/'.");
+    printf("%s%s%s%s\n", indent, "-P", indent,
+            "The password to use when connecting to the server. Default is 'taosdata'.");
+    printf("%s%s%s%s\n", indent, "-c", indent,
+            "Configuration directory. Default is '/etc/taos/'.");
 #endif
-  printf("%s%s%s%s\n", indent, "-h", indent,
-          "The host to connect to TDengine. Default is localhost.");
-  printf("%s%s%s%s\n", indent, "-p", indent,
-          "The TCP/IP port number to use for the connection. Default is 0.");
-  printf("%s%s%s%s\n", indent, "-I", indent,
+    printf("%s%s%s%s\n", indent, "-h", indent,
+            "The host to connect to TDengine. Default is localhost.");
+    printf("%s%s%s%s\n", indent, "-p", indent,
+            "The TCP/IP port number to use for the connection. Default is 0.");
+    printf("%s%s%s%s\n", indent, "-I", indent,
 #if STMT_IFACE_ENABLED == 1
-          "The interface (taosc, rest, and stmt) taosdemo uses. Default is 'taosc'.");
+            "The interface (taosc, rest, and stmt) taosdemo uses. Default is 'taosc'.");
 #else
-          "The interface (taosc, rest) taosdemo uses. Default is 'taosc'.");
+    "The interface (taosc, rest) taosdemo uses. Default is 'taosc'.");
 #endif
-  printf("%s%s%s%s\n", indent, "-d", indent,
-          "Destination database. Default is 'test'.");
-  printf("%s%s%s%s\n", indent, "-a", indent,
-          "Set the replica parameters of the database, Default 1, min: 1, max: 3.");
-  printf("%s%s%s%s\n", indent, "-m", indent,
-          "Table prefix name. Default is 't'.");
-  printf("%s%s%s%s\n", indent, "-s", indent, "The select sql file.");
-  printf("%s%s%s%s\n", indent, "-N", indent, "Use normal table flag.");
-  printf("%s%s%s%s\n", indent, "-o", indent,
-          "Direct output to the named file. Default is './output.txt'.");
-  printf("%s%s%s%s\n", indent, "-q", indent,
-          "Query mode -- 0: SYNC, 1: ASYNC. Default is SYNC.");
-  printf("%s%s%s%s\n", indent, "-b", indent,
-          "The data_type of columns, default: INT,INT,INT,INT.");
-  printf("%s%s%s%s\n", indent, "-w", indent,
-          "The length of data_type 'BINARY' or 'NCHAR'. Default is 16");
-  printf("%s%s%s%s%d\n", indent, "-l", indent,
-          "The number of columns per record. Default is 4. Max values is ",
-       MAX_NUM_DATATYPE);
-  printf("%s%s%s%s\n", indent, "-T", indent,
-          "The number of threads. Default is 10.");
-  printf("%s%s%s%s\n", indent, "-i", indent,
-          "The sleep time (ms) between insertion. Default is 0.");
-  printf("%s%s%s%s\n", indent, "-r", indent,
-          "The number of records per request. Default is 30000.");
-  printf("%s%s%s%s\n", indent, "-t", indent,
-          "The number of tables. Default is 10000.");
-  printf("%s%s%s%s\n", indent, "-n", indent,
-          "The number of records per table. Default is 10000.");
-  printf("%s%s%s%s\n", indent, "-x", indent, "Not insert only flag.");
-  printf("%s%s%s%s\n", indent, "-y", indent, "Default input yes for prompt.");
-  printf("%s%s%s%s\n", indent, "-O", indent,
-          "Insert mode--0: In order, 1 ~ 50: disorder ratio. Default is in order.");
-  printf("%s%s%s%s\n", indent, "-R", indent,
-          "Out of order data's range, ms, default is 1000.");
-  printf("%s%s%s%s\n", indent, "-g", indent,
-          "Print debug info.");
-  printf("%s%s%s\n", indent, "-V, --version\t",
-          "Print version info.");
-  printf("%s%s%s%s\n", indent, "--help\t", indent,
-          "Print command line arguments list info.");
-/*    printf("%s%s%s%s\n", indent, "-D", indent,
-          "if elete database if exists. 0: no, 1: yes, default is 1");
+    printf("%s%s%s%s\n", indent, "-d", indent,
+            "Destination database. Default is 'test'.");
+    printf("%s%s%s%s\n", indent, "-a", indent,
+            "Set the replica parameters of the database, Default 1, min: 1, max: 3.");
+    printf("%s%s%s%s\n", indent, "-m", indent,
+            "Table prefix name. Default is 'd'.");
+    printf("%s%s%s%s\n", indent, "-s", indent, "The select sql file.");
+    printf("%s%s%s%s\n", indent, "-N", indent, "Use normal table flag.");
+    printf("%s%s%s%s\n", indent, "-o", indent,
+            "Direct output to the named file. Default is './output.txt'.");
+    printf("%s%s%s%s\n", indent, "-q", indent,
+            "Query mode -- 0: SYNC, 1: ASYNC. Default is SYNC.");
+    printf("%s%s%s%s\n", indent, "-b", indent,
+            "The data_type of columns, default: FLOAT, INT, FLOAT.");
+    printf("%s%s%s%s\n", indent, "-w", indent,
+            "The length of data_type 'BINARY' or 'NCHAR'. Default is 16");
+    printf("%s%s%s%s%d\n", indent, "-l", indent,
+            "The number of columns per record. Default is 3. Max values is ",
+            MAX_NUM_DATATYPE);
+    printf("%s%s%s%s\n", indent, "-T", indent,
+            "The number of threads. Default is 10.");
+    printf("%s%s%s%s\n", indent, "-i", indent,
+            "The sleep time (ms) between insertion. Default is 0.");
+    printf("%s%s%s%s\n", indent, "-r", indent,
+            "The number of records per request. Default is 30000.");
+    printf("%s%s%s%s\n", indent, "-t", indent,
+            "The number of tables. Default is 10000.");
+    printf("%s%s%s%s\n", indent, "-n", indent,
+            "The number of records per table. Default is 10000.");
+    printf("%s%s%s%s\n", indent, "-M", indent,
+            "The value of records generated are totally random.");
+    printf("%s%s%s%s\n", indent, indent, indent,
+            " The default is to simulate power equipment senario.");
+    printf("%s%s%s%s\n", indent, "-x", indent, "Not insert only flag.");
+    printf("%s%s%s%s\n", indent, "-y", indent, "Default input yes for prompt.");
+    printf("%s%s%s%s\n", indent, "-O", indent,
+            "Insert mode--0: In order, 1 ~ 50: disorder ratio. Default is in order.");
+    printf("%s%s%s%s\n", indent, "-R", indent,
+            "Out of order data's range, ms, default is 1000.");
+    printf("%s%s%s%s\n", indent, "-g", indent,
+            "Print debug info.");
+    printf("%s%s%s\n", indent, "-V, --version\t",
+            "Print version info.");
+    printf("%s%s%s%s\n", indent, "--help\t", indent,
+            "Print command line arguments list info.");
+    /*    printf("%s%s%s%s\n", indent, "-D", indent,
+          "Delete database if exists. 0: no, 1: yes, default is 1");
           */
 }
 
 static bool isStringNumber(char *input)
 {
-  int len = strlen(input);
-  if (0 == len) {
-    return false;
-  }
+    int len = strlen(input);
+    if (0 == len) {
+        return false;
+    }
 
-  for (int i = 0; i < len; i++) {
-    if (!isdigit(input[i]))
-      return false;
-  }
+    for (int i = 0; i < len; i++) {
+        if (!isdigit(input[i]))
+            return false;
+    }
 
-  return true;
+    return true;
 }
 
 static void parse_args(int argc, char *argv[], SArguments *arguments) {
 
-  for (int i = 1; i < argc; i++) {
-    if (strcmp(argv[i], "-f") == 0) {
-      arguments->metaFile = argv[++i];
-    } else if (strcmp(argv[i], "-c") == 0) {
-      if (argc == i+1) {
-        printHelp();
-        errorPrint("%s", "\n\t-c need a valid path following!\n");
-        exit(EXIT_FAILURE);
-      }
-      tstrncpy(configDir, argv[++i], TSDB_FILENAME_LEN);
-    } else if (strcmp(argv[i], "-h") == 0) {
-      if (argc == i+1) {
-        printHelp();
-        errorPrint("%s", "\n\t-h need a valid string following!\n");
-        exit(EXIT_FAILURE);
-      }
-      arguments->host = argv[++i];
-    } else if (strcmp(argv[i], "-p") == 0) {
-      if ((argc == i+1) ||
-        (!isStringNumber(argv[i+1]))) {
-        printHelp();
-        errorPrint("%s", "\n\t-p need a number following!\n");
-        exit(EXIT_FAILURE);
-      }
-      arguments->port = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-I") == 0) {
-      if (argc == i+1) {
-        printHelp();
-        errorPrint("%s", "\n\t-I need a valid string following!\n");
-        exit(EXIT_FAILURE);
-      }
-      ++i;
-      if (0 == strcasecmp(argv[i], "taosc")) {
-          arguments->iface = TAOSC_IFACE;
-      } else if (0 == strcasecmp(argv[i], "rest")) {
-          arguments->iface = REST_IFACE;
+    for (int i = 1; i < argc; i++) {
+        if (strcmp(argv[i], "-f") == 0) {
+            arguments->demo_mode = false;
+            arguments->metaFile = argv[++i];
+        } else if (strcmp(argv[i], "-c") == 0) {
+            if (argc == i+1) {
+                printHelp();
+                errorPrint("%s", "\n\t-c need a valid path following!\n");
+                exit(EXIT_FAILURE);
+            }
+            tstrncpy(configDir, argv[++i], TSDB_FILENAME_LEN);
+        } else if (strcmp(argv[i], "-h") == 0) {
+            if (argc == i+1) {
+                printHelp();
+                errorPrint("%s", "\n\t-h need a valid string following!\n");
+                exit(EXIT_FAILURE);
+            }
+            arguments->host = argv[++i];
+        } else if (strcmp(argv[i], "-p") == 0) {
+            if ((argc == i+1) ||
+                    (!isStringNumber(argv[i+1]))) {
+                printHelp();
+                errorPrint("%s", "\n\t-p need a number following!\n");
+                exit(EXIT_FAILURE);
+            }
+            arguments->port = atoi(argv[++i]);
+        } else if (strcmp(argv[i], "-I") == 0) {
+            if (argc == i+1) {
+                printHelp();
+                errorPrint("%s", "\n\t-I need a valid string following!\n");
+                exit(EXIT_FAILURE);
+            }
+            ++i;
+            if (0 == strcasecmp(argv[i], "taosc")) {
+                arguments->iface = TAOSC_IFACE;
+            } else if (0 == strcasecmp(argv[i], "rest")) {
+                arguments->iface = REST_IFACE;
 #if STMT_IFACE_ENABLED == 1
-      } else if (0 == strcasecmp(argv[i], "stmt")) {
-          arguments->iface = STMT_IFACE;
+            } else if (0 == strcasecmp(argv[i], "stmt")) {
+                arguments->iface = STMT_IFACE;
 #endif
-      } else {
-        errorPrint("%s", "\n\t-I need a valid string following!\n");
-        exit(EXIT_FAILURE);
-      }
-    } else if (strcmp(argv[i], "-u") == 0) {
-      if (argc == i+1) {
-        printHelp();
-        errorPrint("%s", "\n\t-u need a valid string following!\n");
-        exit(EXIT_FAILURE);
-      }
-      arguments->user = argv[++i];
-    } else if (strcmp(argv[i], "-P") == 0) {
-      if (argc == i+1) {
-        printHelp();
-        errorPrint("%s", "\n\t-P need a valid string following!\n");
-        exit(EXIT_FAILURE);
-      }
-      arguments->password = argv[++i];
-    } else if (strcmp(argv[i], "-o") == 0) {
-      if (argc == i+1) {
-        printHelp();
-        errorPrint("%s", "\n\t-o need a valid string following!\n");
-        exit(EXIT_FAILURE);
-      }
-      arguments->output_file = argv[++i];
-    } else if (strcmp(argv[i], "-s") == 0) {
-      if (argc == i+1) {
-        printHelp();
-        errorPrint("%s", "\n\t-s need a valid string following!\n");
-        exit(EXIT_FAILURE);
-      }
-      arguments->sqlFile = argv[++i];
-    } else if (strcmp(argv[i], "-q") == 0) {
-      if ((argc == i+1)
-              || (!isStringNumber(argv[i+1]))) {
-        printHelp();
-        errorPrint("%s", "\n\t-q need a number following!\nQuery mode -- 0: SYNC, not-0: ASYNC. Default is SYNC.\n");
-        exit(EXIT_FAILURE);
-      }
-      arguments->async_mode = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-T") == 0) {
-      if ((argc == i+1)
-              || (!isStringNumber(argv[i+1]))) {
-        printHelp();
-        errorPrint("%s", "\n\t-T need a number following!\n");
-        exit(EXIT_FAILURE);
-      }
-      arguments->num_of_threads = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-i") == 0) {
-      if ((argc == i+1) ||
-        (!isStringNumber(argv[i+1]))) {
-        printHelp();
-        errorPrint("%s", "\n\t-i need a number following!\n");
-        exit(EXIT_FAILURE);
-      }
-      arguments->insert_interval = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-qt") == 0) {
-      if ((argc == i+1)
-              || (!isStringNumber(argv[i+1]))) {
-        printHelp();
-        errorPrint("%s", "\n\t-qt need a number following!\n");
-        exit(EXIT_FAILURE);
-      }
-      arguments->query_times = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-B") == 0) {
-      if ((argc == i+1)
-              || (!isStringNumber(argv[i+1]))) {
-        printHelp();
-        errorPrint("%s", "\n\t-B need a number following!\n");
-        exit(EXIT_FAILURE);
-      }
-      arguments->interlace_rows = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-r") == 0) {
-      if ((argc == i+1)
-              || (!isStringNumber(argv[i+1]))) {
-        printHelp();
-        errorPrint("%s", "\n\t-r need a number following!\n");
-        exit(EXIT_FAILURE);
-      }
-      arguments->num_of_RPR = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-t") == 0) {
-      if ((argc == i+1) ||
-        (!isStringNumber(argv[i+1]))) {
-        printHelp();
-        errorPrint("%s", "\n\t-t need a number following!\n");
-        exit(EXIT_FAILURE);
-      }
-      arguments->num_of_tables = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-n") == 0) {
-      if ((argc == i+1) ||
-        (!isStringNumber(argv[i+1]))) {
-        printHelp();
-        errorPrint("%s", "\n\t-n need a number following!\n");
-        exit(EXIT_FAILURE);
-      }
-      arguments->num_of_DPT = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-d") == 0) {
-      if (argc == i+1) {
-        printHelp();
-        errorPrint("%s", "\n\t-d need a valid string following!\n");
-        exit(EXIT_FAILURE);
-      }
-      arguments->database = argv[++i];
-    } else if (strcmp(argv[i], "-l") == 0) {
-      if (argc == i+1) {
-        if (!isStringNumber(argv[i+1])) {
+            } else {
+                errorPrint("%s", "\n\t-I need a valid string following!\n");
+                exit(EXIT_FAILURE);
+            }
+        } else if (strcmp(argv[i], "-u") == 0) {
+            if (argc == i+1) {
+                printHelp();
+                errorPrint("%s", "\n\t-u need a valid string following!\n");
+                exit(EXIT_FAILURE);
+            }
+            arguments->user = argv[++i];
+        } else if (strcmp(argv[i], "-P") == 0) {
+            if (argc == i+1) {
+                printHelp();
+                errorPrint("%s", "\n\t-P need a valid string following!\n");
+                exit(EXIT_FAILURE);
+            }
+            arguments->password = argv[++i];
+        } else if (strcmp(argv[i], "-o") == 0) {
+            if (argc == i+1) {
+                printHelp();
+                errorPrint("%s", "\n\t-o need a valid string following!\n");
+                exit(EXIT_FAILURE);
+            }
+            arguments->output_file = argv[++i];
+        } else if (strcmp(argv[i], "-s") == 0) {
+            if (argc == i+1) {
+                printHelp();
+                errorPrint("%s", "\n\t-s need a valid string following!\n");
+                exit(EXIT_FAILURE);
+            }
+            arguments->sqlFile = argv[++i];
+        } else if (strcmp(argv[i], "-q") == 0) {
+            if ((argc == i+1)
+                    || (!isStringNumber(argv[i+1]))) {
+                printHelp();
+                errorPrint("%s", "\n\t-q need a number following!\nQuery mode -- 0: SYNC, not-0: ASYNC. Default is SYNC.\n");
+                exit(EXIT_FAILURE);
+            }
+            arguments->async_mode = atoi(argv[++i]);
+        } else if (strcmp(argv[i], "-T") == 0) {
+            if ((argc == i+1)
+                    || (!isStringNumber(argv[i+1]))) {
+                printHelp();
+                errorPrint("%s", "\n\t-T need a number following!\n");
+                exit(EXIT_FAILURE);
+            }
+            arguments->num_of_threads = atoi(argv[++i]);
+        } else if (strcmp(argv[i], "-i") == 0) {
+            if ((argc == i+1) ||
+                    (!isStringNumber(argv[i+1]))) {
+                printHelp();
+                errorPrint("%s", "\n\t-i need a number following!\n");
+                exit(EXIT_FAILURE);
+            }
+            arguments->insert_interval = atoi(argv[++i]);
+        } else if (strcmp(argv[i], "-qt") == 0) {
+            if ((argc == i+1)
+                    || (!isStringNumber(argv[i+1]))) {
+                printHelp();
+                errorPrint("%s", "\n\t-qt need a number following!\n");
+                exit(EXIT_FAILURE);
+            }
+            arguments->query_times = atoi(argv[++i]);
+        } else if (strcmp(argv[i], "-B") == 0) {
+            if ((argc == i+1)
+                    || (!isStringNumber(argv[i+1]))) {
+                printHelp();
+                errorPrint("%s", "\n\t-B need a number following!\n");
+                exit(EXIT_FAILURE);
+            }
+            arguments->interlace_rows = atoi(argv[++i]);
+        } else if (strcmp(argv[i], "-r") == 0) {
+            if ((argc == i+1)
+                    || (!isStringNumber(argv[i+1]))) {
+                printHelp();
+                errorPrint("%s", "\n\t-r need a number following!\n");
+                exit(EXIT_FAILURE);
+            }
+            arguments->num_of_RPR = atoi(argv[++i]);
+        } else if (strcmp(argv[i], "-t") == 0) {
+            if ((argc == i+1) ||
+                    (!isStringNumber(argv[i+1]))) {
+                printHelp();
+                errorPrint("%s", "\n\t-t need a number following!\n");
+                exit(EXIT_FAILURE);
+            }
+            arguments->num_of_tables = atoi(argv[++i]);
+        } else if (strcmp(argv[i], "-n") == 0) {
+            if ((argc == i+1) ||
+                    (!isStringNumber(argv[i+1]))) {
+                printHelp();
+                errorPrint("%s", "\n\t-n need a number following!\n");
+                exit(EXIT_FAILURE);
+            }
+            arguments->num_of_DPT = atoi(argv[++i]);
+        } else if (strcmp(argv[i], "-d") == 0) {
+            if (argc == i+1) {
+                printHelp();
+                errorPrint("%s", "\n\t-d need a valid string following!\n");
+                exit(EXIT_FAILURE);
+            }
+            arguments->database = argv[++i];
+        } else if (strcmp(argv[i], "-l") == 0) {
+            arguments->demo_mode = false;
+            if (argc == i+1) {
+                if (!isStringNumber(argv[i+1])) {
+                    printHelp();
+                    errorPrint("%s", "\n\t-l need a number following!\n");
+                    exit(EXIT_FAILURE);
+                }
+            }
+            arguments->num_of_CPR = atoi(argv[++i]);
+
+            if (arguments->num_of_CPR > MAX_NUM_DATATYPE) {
+                printf("WARNING: max acceptible columns count is %d\n", MAX_NUM_DATATYPE);
+                prompt();
+                arguments->num_of_CPR = MAX_NUM_DATATYPE;
+            }
+
+            for (int col = arguments->num_of_CPR; col < MAX_NUM_DATATYPE; col++) {
+                arguments->datatype[col] = NULL;
+            }
+
+        } else if (strcmp(argv[i], "-b") == 0) {
+            arguments->demo_mode = false;
+            if (argc == i+1) {
+                printHelp();
+                errorPrint("%s", "\n\t-b need valid string following!\n");
+                exit(EXIT_FAILURE);
+            }
+            ++i;
+            if (strstr(argv[i], ",") == NULL) {
+                // only one col
+                if (strcasecmp(argv[i], "INT")
+                        && strcasecmp(argv[i], "FLOAT")
+                        && strcasecmp(argv[i], "TINYINT")
+                        && strcasecmp(argv[i], "BOOL")
+                        && strcasecmp(argv[i], "SMALLINT")
+                        && strcasecmp(argv[i], "BIGINT")
+                        && strcasecmp(argv[i], "DOUBLE")
+                        && strcasecmp(argv[i], "BINARY")
+                        && strcasecmp(argv[i], "TIMESTAMP")
+                        && strcasecmp(argv[i], "NCHAR")) {
+                    printHelp();
+                    errorPrint("%s", "-b: Invalid data_type!\n");
+                    exit(EXIT_FAILURE);
+                }
+                arguments->datatype[0] = argv[i];
+            } else {
+                // more than one col
+                int index = 0;
+                g_dupstr = strdup(argv[i]);
+                char *running = g_dupstr;
+                char *token = strsep(&running, ",");
+                while(token != NULL) {
+                    if (strcasecmp(token, "INT")
+                            && strcasecmp(token, "FLOAT")
+                            && strcasecmp(token, "TINYINT")
+                            && strcasecmp(token, "BOOL")
+                            && strcasecmp(token, "SMALLINT")
+                            && strcasecmp(token, "BIGINT")
+                            && strcasecmp(token, "DOUBLE")
+                            && strcasecmp(token, "BINARY")
+                            && strcasecmp(token, "TIMESTAMP")
+                            && strcasecmp(token, "NCHAR")) {
+                        printHelp();
+                        free(g_dupstr);
+                        errorPrint("%s", "-b: Invalid data_type!\n");
+                        exit(EXIT_FAILURE);
+                    }
+                    arguments->datatype[index++] = token;
+                    token = strsep(&running, ",");
+                    if (index >= MAX_NUM_DATATYPE) break;
+                }
+                arguments->datatype[index] = NULL;
+            }
+        } else if (strcmp(argv[i], "-w") == 0) {
+            if ((argc == i+1) ||
+                    (!isStringNumber(argv[i+1]))) {
+                printHelp();
+                errorPrint("%s", "\n\t-w need a number following!\n");
+                exit(EXIT_FAILURE);
+            }
+            arguments->len_of_binary = atoi(argv[++i]);
+        } else if (strcmp(argv[i], "-m") == 0) {
+            if ((argc == i+1) ||
+                    (isStringNumber(argv[i+1]))) {
+                printHelp();
+                errorPrint("%s", "\n\t-m need a letter-initial string following!\n");
+                exit(EXIT_FAILURE);
+            }
+            arguments->tb_prefix = argv[++i];
+        } else if (strcmp(argv[i], "-N") == 0) {
+            arguments->use_metric = false;
+        } else if (strcmp(argv[i], "-M") == 0) {
+            arguments->demo_mode = false;
+        } else if (strcmp(argv[i], "-x") == 0) {
+            arguments->insert_only = false;
+        } else if (strcmp(argv[i], "-y") == 0) {
+            arguments->answer_yes = true;
+        } else if (strcmp(argv[i], "-g") == 0) {
+            arguments->debug_print = true;
+        } else if (strcmp(argv[i], "-gg") == 0) {
+            arguments->verbose_print = true;
+        } else if (strcmp(argv[i], "-pp") == 0) {
+            arguments->performance_print = true;
+        } else if (strcmp(argv[i], "-O") == 0) {
+            if ((argc == i+1) ||
+                    (!isStringNumber(argv[i+1]))) {
+                printHelp();
+                errorPrint("%s", "\n\t-O need a number following!\n");
+                exit(EXIT_FAILURE);
+            }
+
+            arguments->disorderRatio = atoi(argv[++i]);
+
+            if (arguments->disorderRatio > 50) {
+                arguments->disorderRatio = 50;
+            }
+
+            if (arguments->disorderRatio < 0) {
+                arguments->disorderRatio = 0;
+            }
+
+        } else if (strcmp(argv[i], "-R") == 0) {
+            if ((argc == i+1) ||
+                    (!isStringNumber(argv[i+1]))) {
+                printHelp();
+                errorPrint("%s", "\n\t-R need a number following!\n");
+                exit(EXIT_FAILURE);
+            }
+
+            arguments->disorderRange = atoi(argv[++i]);
+            if (arguments->disorderRange < 0)
+                arguments->disorderRange = 1000;
+
+        } else if (strcmp(argv[i], "-a") == 0) {
+            if ((argc == i+1) ||
+                    (!isStringNumber(argv[i+1]))) {
+                printHelp();
+                errorPrint("%s", "\n\t-a need a number following!\n");
+                exit(EXIT_FAILURE);
+            }
+            arguments->replica = atoi(argv[++i]);
+            if (arguments->replica > 3 || arguments->replica < 1) {
+                arguments->replica = 1;
+            }
+        } else if (strcmp(argv[i], "-D") == 0) {
+            arguments->method_of_delete = atoi(argv[++i]);
+            if (arguments->method_of_delete > 3) {
+                errorPrint("%s", "\n\t-D need a valud (0~3) number following!\n");
+                exit(EXIT_FAILURE);
+            }
+        } else if ((strcmp(argv[i], "--version") == 0) ||
+                (strcmp(argv[i], "-V") == 0)){
+            printVersion();
+            exit(0);
+        } else if (strcmp(argv[i], "--help") == 0) {
             printHelp();
-            errorPrint("%s", "\n\t-l need a number following!\n");
+            exit(0);
+        } else {
+            printHelp();
+            errorPrint("%s", "ERROR: wrong options\n");
             exit(EXIT_FAILURE);
         }
-      }
-      arguments->num_of_CPR = atoi(argv[++i]);
+    }
 
-      if (arguments->num_of_CPR > MAX_NUM_DATATYPE) {
-          printf("WARNING: max acceptible columns count is %d\n", MAX_NUM_DATATYPE);
-          prompt();
-          arguments->num_of_CPR = MAX_NUM_DATATYPE;
-      }
-
-      for (int col = arguments->num_of_CPR; col < MAX_NUM_DATATYPE; col++) {
-          arguments->datatype[col] = NULL;
-      }
-
-    } else if (strcmp(argv[i], "-b") == 0) {
-      if (argc == i+1) {
-        printHelp();
-        errorPrint("%s", "\n\t-b need valid string following!\n");
-        exit(EXIT_FAILURE);
-      }
-      ++i;
-      if (strstr(argv[i], ",") == NULL) {
-        // only one col
-        if (strcasecmp(argv[i], "INT")
-                && strcasecmp(argv[i], "FLOAT")
-                && strcasecmp(argv[i], "TINYINT")
-                && strcasecmp(argv[i], "BOOL")
-                && strcasecmp(argv[i], "SMALLINT")
-                && strcasecmp(argv[i], "BIGINT")
-                && strcasecmp(argv[i], "DOUBLE")
-                && strcasecmp(argv[i], "BINARY")
-                && strcasecmp(argv[i], "TIMESTAMP")
-                && strcasecmp(argv[i], "NCHAR")) {
-          printHelp();
-          errorPrint("%s", "-b: Invalid data_type!\n");
-          exit(EXIT_FAILURE);
+    int columnCount;
+    for (columnCount = 0; columnCount < MAX_NUM_DATATYPE; columnCount ++) {
+        if (g_args.datatype[columnCount] == NULL) {
+            break;
         }
-        arguments->datatype[0] = argv[i];
-      } else {
-        // more than one col
-        int index = 0;
-        g_dupstr = strdup(argv[i]);
-        char *running = g_dupstr;
-        char *token = strsep(&running, ",");
-        while(token != NULL) {
-          if (strcasecmp(token, "INT")
-                  && strcasecmp(token, "FLOAT")
-                  && strcasecmp(token, "TINYINT")
-                  && strcasecmp(token, "BOOL")
-                  && strcasecmp(token, "SMALLINT")
-                  && strcasecmp(token, "BIGINT")
-                  && strcasecmp(token, "DOUBLE")
-                  && strcasecmp(token, "BINARY")
-                  && strcasecmp(token, "TIMESTAMP")
-                  && strcasecmp(token, "NCHAR")) {
-            printHelp();
-            free(g_dupstr);
-            errorPrint("%s", "-b: Invalid data_type!\n");
-            exit(EXIT_FAILURE);
-          }
-          arguments->datatype[index++] = token;
-          token = strsep(&running, ",");
-          if (index >= MAX_NUM_DATATYPE) break;
+    }
+
+    if (0 == columnCount) {
+        perror("data type error!");
+        exit(-1);
+    }
+    g_args.num_of_CPR = columnCount;
+
+    if (((arguments->debug_print) && (arguments->metaFile == NULL))
+            || arguments->verbose_print) {
+        printf("###################################################################\n");
+        printf("# meta file:                         %s\n", arguments->metaFile);
+        printf("# Server IP:                         %s:%hu\n",
+                arguments->host == NULL ? "localhost" : arguments->host,
+                arguments->port );
+        printf("# User:                              %s\n", arguments->user);
+        printf("# Password:                          %s\n", arguments->password);
+        printf("# Use metric:                        %s\n",
+                arguments->use_metric ? "true" : "false");
+        if (*(arguments->datatype)) {
+            printf("# Specified data type:               ");
+            for (int i = 0; i < MAX_NUM_DATATYPE; i++)
+                if (arguments->datatype[i])
+                    printf("%s,", arguments->datatype[i]);
+                else
+                    break;
+            printf("\n");
         }
-        arguments->datatype[index] = NULL;
-      }
-    } else if (strcmp(argv[i], "-w") == 0) {
-      if ((argc == i+1) ||
-        (!isStringNumber(argv[i+1]))) {
-        printHelp();
-        errorPrint("%s", "\n\t-w need a number following!\n");
-        exit(EXIT_FAILURE);
-      }
-      arguments->len_of_binary = atoi(argv[++i]);
-    } else if (strcmp(argv[i], "-m") == 0) {
-      if ((argc == i+1) ||
-        (isStringNumber(argv[i+1]))) {
-        printHelp();
-        errorPrint("%s", "\n\t-m need a letter-initial string following!\n");
-        exit(EXIT_FAILURE);
-      }
-      arguments->tb_prefix = argv[++i];
-    } else if (strcmp(argv[i], "-N") == 0) {
-      arguments->use_metric = false;
-    } else if (strcmp(argv[i], "-x") == 0) {
-      arguments->insert_only = false;
-    } else if (strcmp(argv[i], "-y") == 0) {
-      arguments->answer_yes = true;
-    } else if (strcmp(argv[i], "-g") == 0) {
-      arguments->debug_print = true;
-    } else if (strcmp(argv[i], "-gg") == 0) {
-      arguments->verbose_print = true;
-    } else if (strcmp(argv[i], "-pp") == 0) {
-      arguments->performance_print = true;
-    } else if (strcmp(argv[i], "-O") == 0) {
-      if ((argc == i+1) ||
-        (!isStringNumber(argv[i+1]))) {
-        printHelp();
-        errorPrint("%s", "\n\t-O need a number following!\n");
-        exit(EXIT_FAILURE);
-      }
+        printf("# Insertion interval:                %"PRIu64"\n",
+                arguments->insert_interval);
+        printf("# Number of records per req:         %u\n",
+                arguments->num_of_RPR);
+        printf("# Max SQL length:                    %"PRIu64"\n",
+                arguments->max_sql_len);
+        printf("# Length of Binary:                  %d\n", arguments->len_of_binary);
+        printf("# Number of Threads:                 %d\n", arguments->num_of_threads);
+        printf("# Number of Tables:                  %"PRId64"\n",
+                arguments->num_of_tables);
+        printf("# Number of Data per Table:          %"PRId64"\n",
+                arguments->num_of_DPT);
+        printf("# Database name:                     %s\n", arguments->database);
+        printf("# Table prefix:                      %s\n", arguments->tb_prefix);
+        if (arguments->disorderRatio) {
+            printf("# Data order:                        %d\n", arguments->disorderRatio);
+            printf("# Data out of order rate:            %d\n", arguments->disorderRange);
 
-      arguments->disorderRatio = atoi(argv[++i]);
+        }
+        printf("# Delete method:                     %d\n", arguments->method_of_delete);
+        printf("# Answer yes when prompt:            %d\n", arguments->answer_yes);
+        printf("# Print debug info:                  %d\n", arguments->debug_print);
+        printf("# Print verbose info:                %d\n", arguments->verbose_print);
+        printf("###################################################################\n");
 
-      if (arguments->disorderRatio > 50) {
-        arguments->disorderRatio = 50;
-      }
-
-      if (arguments->disorderRatio < 0) {
-        arguments->disorderRatio = 0;
-      }
-
-    } else if (strcmp(argv[i], "-R") == 0) {
-      if ((argc == i+1) ||
-        (!isStringNumber(argv[i+1]))) {
-        printHelp();
-        errorPrint("%s", "\n\t-R need a number following!\n");
-        exit(EXIT_FAILURE);
-      }
-
-      arguments->disorderRange = atoi(argv[++i]);
-      if (arguments->disorderRange < 0)
-        arguments->disorderRange = 1000;
-
-    } else if (strcmp(argv[i], "-a") == 0) {
-      if ((argc == i+1) ||
-        (!isStringNumber(argv[i+1]))) {
-        printHelp();
-        errorPrint("%s", "\n\t-a need a number following!\n");
-        exit(EXIT_FAILURE);
-      }
-      arguments->replica = atoi(argv[++i]);
-      if (arguments->replica > 3 || arguments->replica < 1) {
-          arguments->replica = 1;
-      }
-    } else if (strcmp(argv[i], "-D") == 0) {
-      arguments->method_of_delete = atoi(argv[++i]);
-      if (arguments->method_of_delete > 3) {
-        errorPrint("%s", "\n\t-D need a valud (0~3) number following!\n");
-        exit(EXIT_FAILURE);
-      }
-    } else if ((strcmp(argv[i], "--version") == 0) ||
-        (strcmp(argv[i], "-V") == 0)){
-      printVersion();
-      exit(0);
-    } else if (strcmp(argv[i], "--help") == 0) {
-      printHelp();
-      exit(0);
-    } else {
-      printHelp();
-      errorPrint("%s", "ERROR: wrong options\n");
-      exit(EXIT_FAILURE);
+        prompt();
     }
-  }
-
-  int columnCount;
-  for (columnCount = 0; columnCount < MAX_NUM_DATATYPE; columnCount ++) {
-    if (g_args.datatype[columnCount] == NULL) {
-      break;
-    }
-  }
-
-  if (0 == columnCount) {
-    perror("data type error!");
-    exit(-1);
-  }
-  g_args.num_of_CPR = columnCount;
-
-  if (((arguments->debug_print) && (arguments->metaFile == NULL))
-          || arguments->verbose_print) {
-    printf("###################################################################\n");
-    printf("# meta file:                         %s\n", arguments->metaFile);
-    printf("# Server IP:                         %s:%hu\n",
-            arguments->host == NULL ? "localhost" : arguments->host,
-            arguments->port );
-    printf("# User:                              %s\n", arguments->user);
-    printf("# Password:                          %s\n", arguments->password);
-    printf("# Use metric:                        %s\n",
-            arguments->use_metric ? "true" : "false");
-    if (*(arguments->datatype)) {
-        printf("# Specified data type:               ");
-        for (int i = 0; i < MAX_NUM_DATATYPE; i++)
-            if (arguments->datatype[i])
-               printf("%s,", arguments->datatype[i]);
-            else
-                break;
-        printf("\n");
-    }
-    printf("# Insertion interval:                %"PRIu64"\n",
-            arguments->insert_interval);
-    printf("# Number of records per req:         %u\n",
-            arguments->num_of_RPR);
-    printf("# Max SQL length:                    %"PRIu64"\n",
-            arguments->max_sql_len);
-    printf("# Length of Binary:                  %d\n", arguments->len_of_binary);
-    printf("# Number of Threads:                 %d\n", arguments->num_of_threads);
-    printf("# Number of Tables:                  %"PRId64"\n",
-            arguments->num_of_tables);
-    printf("# Number of Data per Table:          %"PRId64"\n",
-            arguments->num_of_DPT);
-    printf("# Database name:                     %s\n", arguments->database);
-    printf("# Table prefix:                      %s\n", arguments->tb_prefix);
-    if (arguments->disorderRatio) {
-      printf("# Data order:                        %d\n", arguments->disorderRatio);
-      printf("# Data out of order rate:            %d\n", arguments->disorderRange);
-
-    }
-    printf("# Delete method:                     %d\n", arguments->method_of_delete);
-    printf("# Answer yes when prompt:            %d\n", arguments->answer_yes);
-    printf("# Print debug info:                  %d\n", arguments->debug_print);
-    printf("# Print verbose info:                %d\n", arguments->verbose_print);
-    printf("###################################################################\n");
-
-    prompt();
-  }
 }
 
-static bool getInfoFromJsonFile(char* file);
-static void init_rand_data();
 static void tmfclose(FILE *fp) {
-  if (NULL != fp) {
-    fclose(fp);
-  }
+    if (NULL != fp) {
+        fclose(fp);
+    }
 }
 
 static void tmfree(char *buf) {
-  if (NULL != buf) {
-    free(buf);
-  }
+    if (NULL != buf) {
+        free(buf);
+    }
 }
 
 static int queryDbExec(TAOS *taos, char *command, QUERY_TYPE type, bool quiet) {
-  int i;
-  TAOS_RES *res = NULL;
-  int32_t   code = -1;
+    int i;
+    TAOS_RES *res = NULL;
+    int32_t   code = -1;
 
-  for (i = 0; i < 5 /* retry */; i++) {
-    if (NULL != res) {
-      taos_free_result(res);
-      res = NULL;
+    for (i = 0; i < 5 /* retry */; i++) {
+        if (NULL != res) {
+            taos_free_result(res);
+            res = NULL;
+        }
+
+        res = taos_query(taos, command);
+        code = taos_errno(res);
+        if (0 == code) {
+            break;
+        }
     }
 
-    res = taos_query(taos, command);
-    code = taos_errno(res);
-    if (0 == code) {
-      break;
+    verbosePrint("%s() LN%d - command: %s\n", __func__, __LINE__, command);
+    if (code != 0) {
+        if (!quiet) {
+            errorPrint("Failed to execute %s, reason: %s\n",
+                    command, taos_errstr(res));
+        }
+        taos_free_result(res);
+        //taos_close(taos);
+        return -1;
     }
-  }
 
-  verbosePrint("%s() LN%d - command: %s\n", __func__, __LINE__, command);
-  if (code != 0) {
-    if (!quiet) {
-      errorPrint("Failed to execute %s, reason: %s\n",
-              command, taos_errstr(res));
+    if (INSERT_TYPE == type) {
+        int affectedRows = taos_affected_rows(res);
+        taos_free_result(res);
+        return affectedRows;
     }
+
     taos_free_result(res);
-    //taos_close(taos);
-    return -1;
-  }
-
-  if (INSERT_TYPE == type) {
-    int affectedRows = taos_affected_rows(res);
-    taos_free_result(res);
-    return affectedRows;
-  }
-
-  taos_free_result(res);
-  return 0;
+    return 0;
 }
 
 static void appendResultBufToFile(char *resultBuf, threadInfo *pThreadInfo)
 {
-  pThreadInfo->fp = fopen(pThreadInfo->filePath, "at");
-  if (pThreadInfo->fp == NULL) {
-      errorPrint(
-              "%s() LN%d, failed to open result file: %s, result will not save to file\n",
-              __func__, __LINE__, pThreadInfo->filePath);
-      return;
-  }
+    pThreadInfo->fp = fopen(pThreadInfo->filePath, "at");
+    if (pThreadInfo->fp == NULL) {
+        errorPrint(
+                "%s() LN%d, failed to open result file: %s, result will not save to file\n",
+                __func__, __LINE__, pThreadInfo->filePath);
+        return;
+    }
 
-  fprintf(pThreadInfo->fp, "%s", resultBuf);
-  tmfclose(pThreadInfo->fp);
-  pThreadInfo->fp = NULL;
+    fprintf(pThreadInfo->fp, "%s", resultBuf);
+    tmfclose(pThreadInfo->fp);
+    pThreadInfo->fp = NULL;
 }
 
 static void fetchResult(TAOS_RES *res, threadInfo* pThreadInfo) {
-  TAOS_ROW    row = NULL;
-  int         num_rows = 0;
-  int         num_fields = taos_field_count(res);
-  TAOS_FIELD *fields     = taos_fetch_fields(res);
+    TAOS_ROW    row = NULL;
+    int         num_rows = 0;
+    int         num_fields = taos_field_count(res);
+    TAOS_FIELD *fields     = taos_fetch_fields(res);
 
-  char* databuf = (char*) calloc(1, 100*1024*1024);
-  if (databuf == NULL) {
-    errorPrint("%s() LN%d, failed to malloc, warning: save result to file slowly!\n",
-            __func__, __LINE__);
-    return ;
-  }
-
-  int64_t   totalLen = 0;
-
-  // fetch the records row by row
-  while((row = taos_fetch_row(res))) {
-    if (totalLen >= 100*1024*1024 - 32000) {
-        if (strlen(pThreadInfo->filePath) > 0)
-            appendResultBufToFile(databuf, pThreadInfo);
-        totalLen = 0;
-        memset(databuf, 0, 100*1024*1024);
+    char* databuf = (char*) calloc(1, 100*1024*1024);
+    if (databuf == NULL) {
+        errorPrint("%s() LN%d, failed to malloc, warning: save result to file slowly!\n",
+                __func__, __LINE__);
+        return ;
     }
-    num_rows++;
-    char  temp[16000] = {0};
-    int len = taos_print_row(temp, row, fields, num_fields);
-    len += sprintf(temp + len, "\n");
-    //printf("query result:%s\n", temp);
-    memcpy(databuf + totalLen, temp, len);
-    totalLen += len;
-    verbosePrint("%s() LN%d, totalLen: %"PRId64"\n", __func__, __LINE__, totalLen);
-  }
 
-  verbosePrint("%s() LN%d, databuf=%s resultFile=%s\n",
-          __func__, __LINE__, databuf, pThreadInfo->filePath);
-  if (strlen(pThreadInfo->filePath) > 0) {
-    appendResultBufToFile(databuf, pThreadInfo);
-  }
-  free(databuf);
+    int64_t   totalLen = 0;
+
+    // fetch the records row by row
+    while((row = taos_fetch_row(res))) {
+        if (totalLen >= 100*1024*1024 - 32000) {
+            if (strlen(pThreadInfo->filePath) > 0)
+                appendResultBufToFile(databuf, pThreadInfo);
+            totalLen = 0;
+            memset(databuf, 0, 100*1024*1024);
+        }
+        num_rows++;
+        char  temp[16000] = {0};
+        int len = taos_print_row(temp, row, fields, num_fields);
+        len += sprintf(temp + len, "\n");
+        //printf("query result:%s\n", temp);
+        memcpy(databuf + totalLen, temp, len);
+        totalLen += len;
+        verbosePrint("%s() LN%d, totalLen: %"PRId64"\n",
+                __func__, __LINE__, totalLen);
+    }
+
+    verbosePrint("%s() LN%d, databuf=%s resultFile=%s\n",
+            __func__, __LINE__, databuf, pThreadInfo->filePath);
+    if (strlen(pThreadInfo->filePath) > 0) {
+        appendResultBufToFile(databuf, pThreadInfo);
+    }
+    free(databuf);
 }
 
 static void selectAndGetResult(
         threadInfo *pThreadInfo, char *command)
 {
-  if (0 == strncasecmp(g_queryInfo.queryMode, "taosc", strlen("taosc"))) {
-    TAOS_RES *res = taos_query(pThreadInfo->taos, command);
-    if (res == NULL || taos_errno(res) != 0) {
-        errorPrint("%s() LN%d, failed to execute sql:%s, reason:%s\n",
-            __func__, __LINE__, command, taos_errstr(res));
+    if (0 == strncasecmp(g_queryInfo.queryMode, "taosc", strlen("taosc"))) {
+        TAOS_RES *res = taos_query(pThreadInfo->taos, command);
+        if (res == NULL || taos_errno(res) != 0) {
+            errorPrint("%s() LN%d, failed to execute sql:%s, reason:%s\n",
+                    __func__, __LINE__, command, taos_errstr(res));
+            taos_free_result(res);
+            return;
+        }
+
+        fetchResult(res, pThreadInfo);
         taos_free_result(res);
-        return;
+
+    } else if (0 == strncasecmp(g_queryInfo.queryMode, "rest", strlen("rest"))) {
+        int retCode = postProceSql(
+                g_queryInfo.host, &(g_queryInfo.serv_addr), g_queryInfo.port,
+                command,
+                pThreadInfo);
+        if (0 != retCode) {
+            printf("====restful return fail, threadID[%d]\n", pThreadInfo->threadID);
+        }
+
+    } else {
+        errorPrint("%s() LN%d, unknown query mode: %s\n",
+                __func__, __LINE__, g_queryInfo.queryMode);
     }
-
-    fetchResult(res, pThreadInfo);
-    taos_free_result(res);
-
-  } else if (0 == strncasecmp(g_queryInfo.queryMode, "rest", strlen("rest"))) {
-      int retCode = postProceSql(
-              g_queryInfo.host, &(g_queryInfo.serv_addr), g_queryInfo.port,
-              command,
-              pThreadInfo);
-      if (0 != retCode) {
-        printf("====restful return fail, threadID[%d]\n", pThreadInfo->threadID);
-      }
-
-  } else {
-      errorPrint("%s() LN%d, unknown query mode: %s\n",
-        __func__, __LINE__, g_queryInfo.queryMode);
-  }
 }
 
 static int32_t rand_bool(){
-  static int cursor;
-  cursor++;
-  cursor = cursor % MAX_PREPARED_RAND;
-  return randint[cursor] % 2;
+    static int cursor;
+    cursor++;
+    cursor = cursor % MAX_PREPARED_RAND;
+    return randint[cursor] % 2;
 }
 
 static int32_t rand_tinyint(){
-  static int cursor;
-  cursor++;
-  cursor = cursor % MAX_PREPARED_RAND;
-  return randint[cursor] % 128;
+    static int cursor;
+    cursor++;
+    cursor = cursor % MAX_PREPARED_RAND;
+    return randint[cursor] % 128;
 }
 
 static int32_t rand_smallint(){
-  static int cursor;
-  cursor++;
-  cursor = cursor % MAX_PREPARED_RAND;
-  return randint[cursor] % 32767;
+    static int cursor;
+    cursor++;
+    cursor = cursor % MAX_PREPARED_RAND;
+    return randint[cursor] % 32767;
 }
 
 static int32_t rand_int(){
-  static int cursor;
-  cursor++;
-  cursor = cursor % MAX_PREPARED_RAND;
-  return randint[cursor];
+    static int cursor;
+    cursor++;
+    cursor = cursor % MAX_PREPARED_RAND;
+    return randint[cursor];
 }
 
 static int64_t rand_bigint(){
-  static int cursor;
-  cursor++;
-  cursor = cursor % MAX_PREPARED_RAND;
-  return randbigint[cursor];
+    static int cursor;
+    cursor++;
+    cursor = cursor % MAX_PREPARED_RAND;
+    return randbigint[cursor];
 }
 
 static float rand_float(){
-  static int cursor;
-  cursor++;
-  cursor = cursor % MAX_PREPARED_RAND;
-  return randfloat[cursor];
+    static int cursor;
+    cursor++;
+    cursor = cursor % MAX_PREPARED_RAND;
+    return randfloat[cursor];
+}
+
+static float demo_current_float(){
+    static int cursor;
+    cursor++;
+    cursor = cursor % MAX_PREPARED_RAND;
+    return (float)(5 + randfloat[cursor] / 1000000000);
+}
+
+static int32_t demo_voltage_int(){
+    static int cursor;
+    cursor++;
+    cursor = cursor % MAX_PREPARED_RAND;
+    return 210 + randint[cursor] % 20;
+}
+
+static float demo_phase_float(){
+    static int cursor;
+    cursor++;
+    cursor = cursor % MAX_PREPARED_RAND;
+    return (float)(120 + randfloat[cursor] / 1000000000);
 }
 
 #if 0
@@ -1334,33 +1368,32 @@ static void nonrand_string(char *str, int size)
 static const char charset[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
 
 static void rand_string(char *str, int size) {
-  str[0] = 0;
-  if (size > 0) {
-    //--size;
-    int n;
-    for (n = 0; n < size; n++) {
-      int key = abs(rand_tinyint()) % (int)(sizeof(charset) - 1);
-      str[n] = charset[key];
+    str[0] = 0;
+    if (size > 0) {
+        //--size;
+        int n;
+        for (n = 0; n < size; n++) {
+            int key = abs(rand_tinyint()) % (int)(sizeof(charset) - 1);
+            str[n] = charset[key];
+        }
+        str[n] = 0;
     }
-    str[n] = 0;
-  }
 }
 
 static double rand_double() {
-  static int cursor;
-  cursor++;
-  cursor = cursor % MAX_PREPARED_RAND;
-  return randdouble[cursor];
-
+    static int cursor;
+    cursor++;
+    cursor = cursor % MAX_PREPARED_RAND;
+    return randdouble[cursor];
 }
 
 static void init_rand_data() {
-  for (int i = 0; i < MAX_PREPARED_RAND; i++){
-    randint[i] = (int)(taosRandom() % 65535);
-    randbigint[i] = (int64_t)(taosRandom() % 2147483648);
-    randfloat[i] = (float)(taosRandom() / 1000.0);
-    randdouble[i] = (double)(taosRandom() / 1000000.0);
-  }
+    for (int i = 0; i < MAX_PREPARED_RAND; i++){
+        randint[i] = (int)(taosRandom() % 65535);
+        randbigint[i] = (int64_t)(taosRandom() % 2147483648);
+        randfloat[i] = (float)(taosRandom() / 1000.0);
+        randdouble[i] = (double)(taosRandom() / 1000000.0);
+    }
 }
 
 #define SHOW_PARSE_RESULT_START()   \
@@ -1386,759 +1419,767 @@ static void init_rand_data() {
 static int printfInsertMeta() {
     SHOW_PARSE_RESULT_START();
 
-  printf("interface:                  \033[33m%s\033[0m\n",
-          (g_args.iface==TAOSC_IFACE)?"taosc":(g_args.iface==REST_IFACE)?"rest":"stmt");
-  printf("host:                       \033[33m%s:%u\033[0m\n",
-          g_Dbs.host, g_Dbs.port);
-  printf("user:                       \033[33m%s\033[0m\n", g_Dbs.user);
-  printf("password:                   \033[33m%s\033[0m\n", g_Dbs.password);
-  printf("configDir:                  \033[33m%s\033[0m\n", configDir);
-  printf("resultFile:                 \033[33m%s\033[0m\n", g_Dbs.resultFile);
-  printf("thread num of insert data:  \033[33m%d\033[0m\n", g_Dbs.threadCount);
-  printf("thread num of create table: \033[33m%d\033[0m\n",
-          g_Dbs.threadCountByCreateTbl);
-  printf("top insert interval:        \033[33m%"PRIu64"\033[0m\n",
-          g_args.insert_interval);
-  printf("number of records per req:  \033[33m%u\033[0m\n",
-          g_args.num_of_RPR);
-  printf("max sql length:             \033[33m%"PRIu64"\033[0m\n",
-          g_args.max_sql_len);
+    if (g_args.demo_mode)
+        printf("\ntaosdemo is simulating data generated by power equipments monitoring...\n\n");
+    else
+        printf("\ntaosdemo is simulating random data as you request..\n\n");
 
-  printf("database count:             \033[33m%d\033[0m\n", g_Dbs.dbCount);
+    printf("interface:                  \033[33m%s\033[0m\n",
+            (g_args.iface==TAOSC_IFACE)?"taosc":(g_args.iface==REST_IFACE)?"rest":"stmt");
+    printf("host:                       \033[33m%s:%u\033[0m\n",
+            g_Dbs.host, g_Dbs.port);
+    printf("user:                       \033[33m%s\033[0m\n", g_Dbs.user);
+    printf("password:                   \033[33m%s\033[0m\n", g_Dbs.password);
+    printf("configDir:                  \033[33m%s\033[0m\n", configDir);
+    printf("resultFile:                 \033[33m%s\033[0m\n", g_Dbs.resultFile);
+    printf("thread num of insert data:  \033[33m%d\033[0m\n", g_Dbs.threadCount);
+    printf("thread num of create table: \033[33m%d\033[0m\n",
+            g_Dbs.threadCountByCreateTbl);
+    printf("top insert interval:        \033[33m%"PRIu64"\033[0m\n",
+            g_args.insert_interval);
+    printf("number of records per req:  \033[33m%u\033[0m\n",
+            g_args.num_of_RPR);
+    printf("max sql length:             \033[33m%"PRIu64"\033[0m\n",
+            g_args.max_sql_len);
 
-  for (int i = 0; i < g_Dbs.dbCount; i++) {
-    printf("database[\033[33m%d\033[0m]:\n", i);
-    printf("  database[%d] name:      \033[33m%s\033[0m\n",
-            i, g_Dbs.db[i].dbName);
-    if (0 == g_Dbs.db[i].drop) {
-      printf("  drop:                  \033[33mno\033[0m\n");
-    } else {
-      printf("  drop:                  \033[33myes\033[0m\n");
-    }
+    printf("database count:             \033[33m%d\033[0m\n", g_Dbs.dbCount);
 
-    if (g_Dbs.db[i].dbCfg.blocks > 0) {
-      printf("  blocks:                \033[33m%d\033[0m\n",
-              g_Dbs.db[i].dbCfg.blocks);
-    }
-    if (g_Dbs.db[i].dbCfg.cache > 0) {
-      printf("  cache:                 \033[33m%d\033[0m\n",
-              g_Dbs.db[i].dbCfg.cache);
-    }
-    if (g_Dbs.db[i].dbCfg.days > 0) {
-      printf("  days:                  \033[33m%d\033[0m\n",
-              g_Dbs.db[i].dbCfg.days);
-    }
-    if (g_Dbs.db[i].dbCfg.keep > 0) {
-      printf("  keep:                  \033[33m%d\033[0m\n",
-              g_Dbs.db[i].dbCfg.keep);
-    }
-    if (g_Dbs.db[i].dbCfg.replica > 0) {
-      printf("  replica:               \033[33m%d\033[0m\n",
-              g_Dbs.db[i].dbCfg.replica);
-    }
-    if (g_Dbs.db[i].dbCfg.update > 0) {
-      printf("  update:                \033[33m%d\033[0m\n",
-              g_Dbs.db[i].dbCfg.update);
-    }
-    if (g_Dbs.db[i].dbCfg.minRows > 0) {
-      printf("  minRows:               \033[33m%d\033[0m\n",
-              g_Dbs.db[i].dbCfg.minRows);
-    }
-    if (g_Dbs.db[i].dbCfg.maxRows > 0) {
-      printf("  maxRows:               \033[33m%d\033[0m\n",
-              g_Dbs.db[i].dbCfg.maxRows);
-    }
-    if (g_Dbs.db[i].dbCfg.comp > 0) {
-      printf("  comp:                  \033[33m%d\033[0m\n", g_Dbs.db[i].dbCfg.comp);
-    }
-    if (g_Dbs.db[i].dbCfg.walLevel > 0) {
-      printf("  walLevel:              \033[33m%d\033[0m\n",
-              g_Dbs.db[i].dbCfg.walLevel);
-    }
-    if (g_Dbs.db[i].dbCfg.fsync > 0) {
-      printf("  fsync:                 \033[33m%d\033[0m\n",
-              g_Dbs.db[i].dbCfg.fsync);
-    }
-    if (g_Dbs.db[i].dbCfg.quorum > 0) {
-      printf("  quorum:                \033[33m%d\033[0m\n",
-              g_Dbs.db[i].dbCfg.quorum);
-    }
-    if (g_Dbs.db[i].dbCfg.precision[0] != 0) {
-      if ((0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "ms", 2))
-              || (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "us", 2))) {
-        printf("  precision:             \033[33m%s\033[0m\n",
-            g_Dbs.db[i].dbCfg.precision);
-      } else {
-        printf("\033[1m\033[40;31m  precision error:       %s\033[0m\n",
-                g_Dbs.db[i].dbCfg.precision);
-        return -1;
-      }
-    }
-
-    printf("  super table count:     \033[33m%"PRIu64"\033[0m\n",
-        g_Dbs.db[i].superTblCount);
-    for (uint64_t j = 0; j < g_Dbs.db[i].superTblCount; j++) {
-      printf("  super table[\033[33m%"PRIu64"\033[0m]:\n", j);
-
-      printf("      stbName:           \033[33m%s\033[0m\n",
-          g_Dbs.db[i].superTbls[j].sTblName);
-
-      if (PRE_CREATE_SUBTBL == g_Dbs.db[i].superTbls[j].autoCreateTable) {
-        printf("      autoCreateTable:   \033[33m%s\033[0m\n",  "no");
-      } else if (AUTO_CREATE_SUBTBL ==
-              g_Dbs.db[i].superTbls[j].autoCreateTable) {
-        printf("      autoCreateTable:   \033[33m%s\033[0m\n",  "yes");
-      } else {
-        printf("      autoCreateTable:   \033[33m%s\033[0m\n",  "error");
-      }
-
-      if (TBL_NO_EXISTS == g_Dbs.db[i].superTbls[j].childTblExists) {
-        printf("      childTblExists:    \033[33m%s\033[0m\n",  "no");
-      } else if (TBL_ALREADY_EXISTS == g_Dbs.db[i].superTbls[j].childTblExists) {
-        printf("      childTblExists:    \033[33m%s\033[0m\n",  "yes");
-      } else {
-        printf("      childTblExists:    \033[33m%s\033[0m\n",  "error");
-      }
-
-      printf("      childTblCount:     \033[33m%"PRId64"\033[0m\n",
-              g_Dbs.db[i].superTbls[j].childTblCount);
-      printf("      childTblPrefix:    \033[33m%s\033[0m\n",
-              g_Dbs.db[i].superTbls[j].childTblPrefix);
-      printf("      dataSource:        \033[33m%s\033[0m\n",
-              g_Dbs.db[i].superTbls[j].dataSource);
-      printf("      iface:             \033[33m%s\033[0m\n",
-          (g_Dbs.db[i].superTbls[j].iface==TAOSC_IFACE)?"taosc":
-          (g_Dbs.db[i].superTbls[j].iface==REST_IFACE)?"rest":"stmt");
-      if (g_Dbs.db[i].superTbls[j].childTblLimit > 0) {
-        printf("      childTblLimit:     \033[33m%"PRId64"\033[0m\n",
-                g_Dbs.db[i].superTbls[j].childTblLimit);
-      }
-      if (g_Dbs.db[i].superTbls[j].childTblOffset > 0) {
-        printf("      childTblOffset:    \033[33m%"PRIu64"\033[0m\n",
-                g_Dbs.db[i].superTbls[j].childTblOffset);
-      }
-      printf("      insertRows:        \033[33m%"PRId64"\033[0m\n",
-              g_Dbs.db[i].superTbls[j].insertRows);
-/*
-      if (0 == g_Dbs.db[i].superTbls[j].multiThreadWriteOneTbl) {
-        printf("      multiThreadWriteOneTbl:  \033[33mno\033[0m\n");
-      }else {
-        printf("      multiThreadWriteOneTbl:  \033[33myes\033[0m\n");
-      }
-      */
-      printf("      interlaceRows:     \033[33m%u\033[0m\n",
-              g_Dbs.db[i].superTbls[j].interlaceRows);
-
-      if (g_Dbs.db[i].superTbls[j].interlaceRows > 0) {
-        printf("      stable insert interval:   \033[33m%"PRIu64"\033[0m\n",
-            g_Dbs.db[i].superTbls[j].insertInterval);
-      }
-
-      printf("      disorderRange:     \033[33m%d\033[0m\n",
-              g_Dbs.db[i].superTbls[j].disorderRange);
-      printf("      disorderRatio:     \033[33m%d\033[0m\n",
-              g_Dbs.db[i].superTbls[j].disorderRatio);
-      printf("      maxSqlLen:         \033[33m%"PRIu64"\033[0m\n",
-              g_Dbs.db[i].superTbls[j].maxSqlLen);
-      printf("      timeStampStep:     \033[33m%"PRId64"\033[0m\n",
-              g_Dbs.db[i].superTbls[j].timeStampStep);
-      printf("      startTimestamp:    \033[33m%s\033[0m\n",
-              g_Dbs.db[i].superTbls[j].startTimestamp);
-      printf("      sampleFormat:      \033[33m%s\033[0m\n",
-              g_Dbs.db[i].superTbls[j].sampleFormat);
-      printf("      sampleFile:        \033[33m%s\033[0m\n",
-              g_Dbs.db[i].superTbls[j].sampleFile);
-      printf("      tagsFile:          \033[33m%s\033[0m\n",
-              g_Dbs.db[i].superTbls[j].tagsFile);
-      printf("      columnCount:       \033[33m%d\033[0m\n",
-              g_Dbs.db[i].superTbls[j].columnCount);
-      for (int k = 0; k < g_Dbs.db[i].superTbls[j].columnCount; k++) {
-        //printf("dataType:%s, dataLen:%d\t", g_Dbs.db[i].superTbls[j].columns[k].dataType, g_Dbs.db[i].superTbls[j].columns[k].dataLen);
-        if ((0 == strncasecmp(g_Dbs.db[i].superTbls[j].columns[k].dataType,
-                       "binary", 6))
-                || (0 == strncasecmp(g_Dbs.db[i].superTbls[j].columns[k].dataType,
-                       "nchar", 5))) {
-          printf("column[\033[33m%d\033[0m]:\033[33m%s(%d)\033[0m ", k,
-                  g_Dbs.db[i].superTbls[j].columns[k].dataType,
-                  g_Dbs.db[i].superTbls[j].columns[k].dataLen);
+    for (int i = 0; i < g_Dbs.dbCount; i++) {
+        printf("database[\033[33m%d\033[0m]:\n", i);
+        printf("  database[%d] name:      \033[33m%s\033[0m\n",
+                i, g_Dbs.db[i].dbName);
+        if (0 == g_Dbs.db[i].drop) {
+            printf("  drop:                  \033[33mno\033[0m\n");
         } else {
-          printf("column[%d]:\033[33m%s\033[0m ", k,
-                  g_Dbs.db[i].superTbls[j].columns[k].dataType);
+            printf("  drop:                  \033[33myes\033[0m\n");
         }
-      }
-      printf("\n");
 
-      printf("      tagCount:            \033[33m%d\033[0m\n        ",
-              g_Dbs.db[i].superTbls[j].tagCount);
-      for (int k = 0; k < g_Dbs.db[i].superTbls[j].tagCount; k++) {
-        //printf("dataType:%s, dataLen:%d\t", g_Dbs.db[i].superTbls[j].tags[k].dataType, g_Dbs.db[i].superTbls[j].tags[k].dataLen);
-        if ((0 == strncasecmp(g_Dbs.db[i].superTbls[j].tags[k].dataType,
-                        "binary", strlen("binary")))
-                || (0 == strncasecmp(g_Dbs.db[i].superTbls[j].tags[k].dataType,
-                        "nchar", strlen("nchar")))) {
-          printf("tag[%d]:\033[33m%s(%d)\033[0m ", k,
-                  g_Dbs.db[i].superTbls[j].tags[k].dataType,
-                  g_Dbs.db[i].superTbls[j].tags[k].dataLen);
-        } else {
-          printf("tag[%d]:\033[33m%s\033[0m ", k,
-                  g_Dbs.db[i].superTbls[j].tags[k].dataType);
+        if (g_Dbs.db[i].dbCfg.blocks > 0) {
+            printf("  blocks:                \033[33m%d\033[0m\n",
+                    g_Dbs.db[i].dbCfg.blocks);
         }
-      }
-      printf("\n");
+        if (g_Dbs.db[i].dbCfg.cache > 0) {
+            printf("  cache:                 \033[33m%d\033[0m\n",
+                    g_Dbs.db[i].dbCfg.cache);
+        }
+        if (g_Dbs.db[i].dbCfg.days > 0) {
+            printf("  days:                  \033[33m%d\033[0m\n",
+                    g_Dbs.db[i].dbCfg.days);
+        }
+        if (g_Dbs.db[i].dbCfg.keep > 0) {
+            printf("  keep:                  \033[33m%d\033[0m\n",
+                    g_Dbs.db[i].dbCfg.keep);
+        }
+        if (g_Dbs.db[i].dbCfg.replica > 0) {
+            printf("  replica:               \033[33m%d\033[0m\n",
+                    g_Dbs.db[i].dbCfg.replica);
+        }
+        if (g_Dbs.db[i].dbCfg.update > 0) {
+            printf("  update:                \033[33m%d\033[0m\n",
+                    g_Dbs.db[i].dbCfg.update);
+        }
+        if (g_Dbs.db[i].dbCfg.minRows > 0) {
+            printf("  minRows:               \033[33m%d\033[0m\n",
+                    g_Dbs.db[i].dbCfg.minRows);
+        }
+        if (g_Dbs.db[i].dbCfg.maxRows > 0) {
+            printf("  maxRows:               \033[33m%d\033[0m\n",
+                    g_Dbs.db[i].dbCfg.maxRows);
+        }
+        if (g_Dbs.db[i].dbCfg.comp > 0) {
+            printf("  comp:                  \033[33m%d\033[0m\n", g_Dbs.db[i].dbCfg.comp);
+        }
+        if (g_Dbs.db[i].dbCfg.walLevel > 0) {
+            printf("  walLevel:              \033[33m%d\033[0m\n",
+                    g_Dbs.db[i].dbCfg.walLevel);
+        }
+        if (g_Dbs.db[i].dbCfg.fsync > 0) {
+            printf("  fsync:                 \033[33m%d\033[0m\n",
+                    g_Dbs.db[i].dbCfg.fsync);
+        }
+        if (g_Dbs.db[i].dbCfg.quorum > 0) {
+            printf("  quorum:                \033[33m%d\033[0m\n",
+                    g_Dbs.db[i].dbCfg.quorum);
+        }
+        if (g_Dbs.db[i].dbCfg.precision[0] != 0) {
+            if ((0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "ms", 2))
+                    || (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "us", 2))) {
+                printf("  precision:             \033[33m%s\033[0m\n",
+                        g_Dbs.db[i].dbCfg.precision);
+            } else {
+                printf("\033[1m\033[40;31m  precision error:       %s\033[0m\n",
+                        g_Dbs.db[i].dbCfg.precision);
+                return -1;
+            }
+        }
+
+        printf("  super table count:     \033[33m%"PRIu64"\033[0m\n",
+                g_Dbs.db[i].superTblCount);
+        for (uint64_t j = 0; j < g_Dbs.db[i].superTblCount; j++) {
+            printf("  super table[\033[33m%"PRIu64"\033[0m]:\n", j);
+
+            printf("      stbName:           \033[33m%s\033[0m\n",
+                    g_Dbs.db[i].superTbls[j].sTblName);
+
+            if (PRE_CREATE_SUBTBL == g_Dbs.db[i].superTbls[j].autoCreateTable) {
+                printf("      autoCreateTable:   \033[33m%s\033[0m\n",  "no");
+            } else if (AUTO_CREATE_SUBTBL ==
+                    g_Dbs.db[i].superTbls[j].autoCreateTable) {
+                printf("      autoCreateTable:   \033[33m%s\033[0m\n",  "yes");
+            } else {
+                printf("      autoCreateTable:   \033[33m%s\033[0m\n",  "error");
+            }
+
+            if (TBL_NO_EXISTS == g_Dbs.db[i].superTbls[j].childTblExists) {
+                printf("      childTblExists:    \033[33m%s\033[0m\n",  "no");
+            } else if (TBL_ALREADY_EXISTS == g_Dbs.db[i].superTbls[j].childTblExists) {
+                printf("      childTblExists:    \033[33m%s\033[0m\n",  "yes");
+            } else {
+                printf("      childTblExists:    \033[33m%s\033[0m\n",  "error");
+            }
+
+            printf("      childTblCount:     \033[33m%"PRId64"\033[0m\n",
+                    g_Dbs.db[i].superTbls[j].childTblCount);
+            printf("      childTblPrefix:    \033[33m%s\033[0m\n",
+                    g_Dbs.db[i].superTbls[j].childTblPrefix);
+            printf("      dataSource:        \033[33m%s\033[0m\n",
+                    g_Dbs.db[i].superTbls[j].dataSource);
+            printf("      iface:             \033[33m%s\033[0m\n",
+                    (g_Dbs.db[i].superTbls[j].iface==TAOSC_IFACE)?"taosc":
+                    (g_Dbs.db[i].superTbls[j].iface==REST_IFACE)?"rest":"stmt");
+            if (g_Dbs.db[i].superTbls[j].childTblLimit > 0) {
+                printf("      childTblLimit:     \033[33m%"PRId64"\033[0m\n",
+                        g_Dbs.db[i].superTbls[j].childTblLimit);
+            }
+            if (g_Dbs.db[i].superTbls[j].childTblOffset > 0) {
+                printf("      childTblOffset:    \033[33m%"PRIu64"\033[0m\n",
+                        g_Dbs.db[i].superTbls[j].childTblOffset);
+            }
+            printf("      insertRows:        \033[33m%"PRId64"\033[0m\n",
+                    g_Dbs.db[i].superTbls[j].insertRows);
+            /*
+               if (0 == g_Dbs.db[i].superTbls[j].multiThreadWriteOneTbl) {
+               printf("      multiThreadWriteOneTbl:  \033[33mno\033[0m\n");
+               }else {
+               printf("      multiThreadWriteOneTbl:  \033[33myes\033[0m\n");
+               }
+               */
+            printf("      interlaceRows:     \033[33m%u\033[0m\n",
+                    g_Dbs.db[i].superTbls[j].interlaceRows);
+
+            if (g_Dbs.db[i].superTbls[j].interlaceRows > 0) {
+                printf("      stable insert interval:   \033[33m%"PRIu64"\033[0m\n",
+                        g_Dbs.db[i].superTbls[j].insertInterval);
+            }
+
+            printf("      disorderRange:     \033[33m%d\033[0m\n",
+                    g_Dbs.db[i].superTbls[j].disorderRange);
+            printf("      disorderRatio:     \033[33m%d\033[0m\n",
+                    g_Dbs.db[i].superTbls[j].disorderRatio);
+            printf("      maxSqlLen:         \033[33m%"PRIu64"\033[0m\n",
+                    g_Dbs.db[i].superTbls[j].maxSqlLen);
+            printf("      timeStampStep:     \033[33m%"PRId64"\033[0m\n",
+                    g_Dbs.db[i].superTbls[j].timeStampStep);
+            printf("      startTimestamp:    \033[33m%s\033[0m\n",
+                    g_Dbs.db[i].superTbls[j].startTimestamp);
+            printf("      sampleFormat:      \033[33m%s\033[0m\n",
+                    g_Dbs.db[i].superTbls[j].sampleFormat);
+            printf("      sampleFile:        \033[33m%s\033[0m\n",
+                    g_Dbs.db[i].superTbls[j].sampleFile);
+            printf("      tagsFile:          \033[33m%s\033[0m\n",
+                    g_Dbs.db[i].superTbls[j].tagsFile);
+            printf("      columnCount:       \033[33m%d\033[0m\n",
+                    g_Dbs.db[i].superTbls[j].columnCount);
+            for (int k = 0; k < g_Dbs.db[i].superTbls[j].columnCount; k++) {
+                //printf("dataType:%s, dataLen:%d\t", g_Dbs.db[i].superTbls[j].columns[k].dataType, g_Dbs.db[i].superTbls[j].columns[k].dataLen);
+                if ((0 == strncasecmp(g_Dbs.db[i].superTbls[j].columns[k].dataType,
+                                "binary", 6))
+                        || (0 == strncasecmp(g_Dbs.db[i].superTbls[j].columns[k].dataType,
+                                "nchar", 5))) {
+                    printf("column[\033[33m%d\033[0m]:\033[33m%s(%d)\033[0m ", k,
+                            g_Dbs.db[i].superTbls[j].columns[k].dataType,
+                            g_Dbs.db[i].superTbls[j].columns[k].dataLen);
+                } else {
+                    printf("column[%d]:\033[33m%s\033[0m ", k,
+                            g_Dbs.db[i].superTbls[j].columns[k].dataType);
+                }
+            }
+            printf("\n");
+
+            printf("      tagCount:            \033[33m%d\033[0m\n        ",
+                    g_Dbs.db[i].superTbls[j].tagCount);
+            for (int k = 0; k < g_Dbs.db[i].superTbls[j].tagCount; k++) {
+                //printf("dataType:%s, dataLen:%d\t", g_Dbs.db[i].superTbls[j].tags[k].dataType, g_Dbs.db[i].superTbls[j].tags[k].dataLen);
+                if ((0 == strncasecmp(g_Dbs.db[i].superTbls[j].tags[k].dataType,
+                                "binary", strlen("binary")))
+                        || (0 == strncasecmp(g_Dbs.db[i].superTbls[j].tags[k].dataType,
+                                "nchar", strlen("nchar")))) {
+                    printf("tag[%d]:\033[33m%s(%d)\033[0m ", k,
+                            g_Dbs.db[i].superTbls[j].tags[k].dataType,
+                            g_Dbs.db[i].superTbls[j].tags[k].dataLen);
+                } else {
+                    printf("tag[%d]:\033[33m%s\033[0m ", k,
+                            g_Dbs.db[i].superTbls[j].tags[k].dataType);
+                }
+            }
+            printf("\n");
+        }
+        printf("\n");
     }
-    printf("\n");
-  }
 
-  SHOW_PARSE_RESULT_END();
+    SHOW_PARSE_RESULT_END();
 
-  return 0;
+    return 0;
 }
 
 static void printfInsertMetaToFile(FILE* fp) {
 
-  SHOW_PARSE_RESULT_START_TO_FILE(fp);
+    SHOW_PARSE_RESULT_START_TO_FILE(fp);
 
-  fprintf(fp, "host:                       %s:%u\n", g_Dbs.host, g_Dbs.port);
-  fprintf(fp, "user:                       %s\n", g_Dbs.user);
-  fprintf(fp, "configDir:                  %s\n", configDir);
-  fprintf(fp, "resultFile:                 %s\n", g_Dbs.resultFile);
-  fprintf(fp, "thread num of insert data:  %d\n", g_Dbs.threadCount);
-  fprintf(fp, "thread num of create table: %d\n", g_Dbs.threadCountByCreateTbl);
-  fprintf(fp, "number of records per req:  %u\n", g_args.num_of_RPR);
-  fprintf(fp, "max sql length:             %"PRIu64"\n", g_args.max_sql_len);
-  fprintf(fp, "database count:          %d\n", g_Dbs.dbCount);
+    fprintf(fp, "host:                       %s:%u\n", g_Dbs.host, g_Dbs.port);
+    fprintf(fp, "user:                       %s\n", g_Dbs.user);
+    fprintf(fp, "configDir:                  %s\n", configDir);
+    fprintf(fp, "resultFile:                 %s\n", g_Dbs.resultFile);
+    fprintf(fp, "thread num of insert data:  %d\n", g_Dbs.threadCount);
+    fprintf(fp, "thread num of create table: %d\n", g_Dbs.threadCountByCreateTbl);
+    fprintf(fp, "number of records per req:  %u\n", g_args.num_of_RPR);
+    fprintf(fp, "max sql length:             %"PRIu64"\n", g_args.max_sql_len);
+    fprintf(fp, "database count:          %d\n", g_Dbs.dbCount);
 
-  for (int i = 0; i < g_Dbs.dbCount; i++) {
-    fprintf(fp, "database[%d]:\n", i);
-    fprintf(fp, "  database[%d] name:       %s\n", i, g_Dbs.db[i].dbName);
-    if (0 == g_Dbs.db[i].drop) {
-      fprintf(fp, "  drop:                  no\n");
-    }else {
-      fprintf(fp, "  drop:                  yes\n");
-    }
-
-    if (g_Dbs.db[i].dbCfg.blocks > 0) {
-      fprintf(fp, "  blocks:                %d\n", g_Dbs.db[i].dbCfg.blocks);
-    }
-    if (g_Dbs.db[i].dbCfg.cache > 0) {
-      fprintf(fp, "  cache:                 %d\n", g_Dbs.db[i].dbCfg.cache);
-    }
-    if (g_Dbs.db[i].dbCfg.days > 0) {
-      fprintf(fp, "  days:                  %d\n", g_Dbs.db[i].dbCfg.days);
-    }
-    if (g_Dbs.db[i].dbCfg.keep > 0) {
-      fprintf(fp, "  keep:                  %d\n", g_Dbs.db[i].dbCfg.keep);
-    }
-    if (g_Dbs.db[i].dbCfg.replica > 0) {
-      fprintf(fp, "  replica:               %d\n", g_Dbs.db[i].dbCfg.replica);
-    }
-    if (g_Dbs.db[i].dbCfg.update > 0) {
-      fprintf(fp, "  update:                %d\n", g_Dbs.db[i].dbCfg.update);
-    }
-    if (g_Dbs.db[i].dbCfg.minRows > 0) {
-      fprintf(fp, "  minRows:               %d\n", g_Dbs.db[i].dbCfg.minRows);
-    }
-    if (g_Dbs.db[i].dbCfg.maxRows > 0) {
-      fprintf(fp, "  maxRows:               %d\n", g_Dbs.db[i].dbCfg.maxRows);
-    }
-    if (g_Dbs.db[i].dbCfg.comp > 0) {
-      fprintf(fp, "  comp:                  %d\n", g_Dbs.db[i].dbCfg.comp);
-    }
-    if (g_Dbs.db[i].dbCfg.walLevel > 0) {
-      fprintf(fp, "  walLevel:              %d\n", g_Dbs.db[i].dbCfg.walLevel);
-    }
-    if (g_Dbs.db[i].dbCfg.fsync > 0) {
-      fprintf(fp, "  fsync:                 %d\n", g_Dbs.db[i].dbCfg.fsync);
-    }
-    if (g_Dbs.db[i].dbCfg.quorum > 0) {
-      fprintf(fp, "  quorum:                %d\n", g_Dbs.db[i].dbCfg.quorum);
-    }
-    if (g_Dbs.db[i].dbCfg.precision[0] != 0) {
-      if ((0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "ms", 2))
-              || (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "us", 2))) {
-        fprintf(fp, "  precision:             %s\n",
-                g_Dbs.db[i].dbCfg.precision);
-      } else {
-        fprintf(fp, "  precision error:       %s\n",
-                g_Dbs.db[i].dbCfg.precision);
-      }
-    }
-
-    fprintf(fp, "  super table count:     %"PRIu64"\n",
-            g_Dbs.db[i].superTblCount);
-    for (int j = 0; j < g_Dbs.db[i].superTblCount; j++) {
-      fprintf(fp, "  super table[%d]:\n", j);
-
-      fprintf(fp, "      stbName:           %s\n",
-              g_Dbs.db[i].superTbls[j].sTblName);
-
-      if (PRE_CREATE_SUBTBL == g_Dbs.db[i].superTbls[j].autoCreateTable) {
-        fprintf(fp, "      autoCreateTable:   %s\n",  "no");
-      } else if (AUTO_CREATE_SUBTBL
-              == g_Dbs.db[i].superTbls[j].autoCreateTable) {
-        fprintf(fp, "      autoCreateTable:   %s\n",  "yes");
-      } else {
-        fprintf(fp, "      autoCreateTable:   %s\n",  "error");
-      }
-
-      if (TBL_NO_EXISTS == g_Dbs.db[i].superTbls[j].childTblExists) {
-        fprintf(fp, "      childTblExists:    %s\n",  "no");
-      } else if (TBL_ALREADY_EXISTS
-              == g_Dbs.db[i].superTbls[j].childTblExists) {
-        fprintf(fp, "      childTblExists:    %s\n",  "yes");
-      } else {
-        fprintf(fp, "      childTblExists:    %s\n",  "error");
-      }
-
-      fprintf(fp, "      childTblCount:     %"PRId64"\n",
-              g_Dbs.db[i].superTbls[j].childTblCount);
-      fprintf(fp, "      childTblPrefix:    %s\n",
-              g_Dbs.db[i].superTbls[j].childTblPrefix);
-      fprintf(fp, "      dataSource:        %s\n",
-              g_Dbs.db[i].superTbls[j].dataSource);
-      fprintf(fp, "      iface:             %s\n",
-          (g_Dbs.db[i].superTbls[j].iface==TAOSC_IFACE)?"taosc":
-          (g_Dbs.db[i].superTbls[j].iface==REST_IFACE)?"rest":"stmt");
-      fprintf(fp, "      insertRows:        %"PRId64"\n",
-              g_Dbs.db[i].superTbls[j].insertRows);
-      fprintf(fp, "      interlace rows:    %u\n",
-              g_Dbs.db[i].superTbls[j].interlaceRows);
-      if (g_Dbs.db[i].superTbls[j].interlaceRows > 0) {
-        fprintf(fp, "      stable insert interval:   %"PRIu64"\n",
-                g_Dbs.db[i].superTbls[j].insertInterval);
-      }
-/*
-      if (0 == g_Dbs.db[i].superTbls[j].multiThreadWriteOneTbl) {
-        fprintf(fp, "      multiThreadWriteOneTbl:  no\n");
-      }else {
-        fprintf(fp, "      multiThreadWriteOneTbl:  yes\n");
-      }
-      */
-      fprintf(fp, "      interlaceRows:     %u\n",
-              g_Dbs.db[i].superTbls[j].interlaceRows);
-      fprintf(fp, "      disorderRange:     %d\n",
-              g_Dbs.db[i].superTbls[j].disorderRange);
-      fprintf(fp, "      disorderRatio:     %d\n",
-              g_Dbs.db[i].superTbls[j].disorderRatio);
-      fprintf(fp, "      maxSqlLen:         %"PRIu64"\n",
-              g_Dbs.db[i].superTbls[j].maxSqlLen);
-
-      fprintf(fp, "      timeStampStep:     %"PRId64"\n",
-              g_Dbs.db[i].superTbls[j].timeStampStep);
-      fprintf(fp, "      startTimestamp:    %s\n",
-              g_Dbs.db[i].superTbls[j].startTimestamp);
-      fprintf(fp, "      sampleFormat:      %s\n",
-              g_Dbs.db[i].superTbls[j].sampleFormat);
-      fprintf(fp, "      sampleFile:        %s\n",
-              g_Dbs.db[i].superTbls[j].sampleFile);
-      fprintf(fp, "      tagsFile:          %s\n",
-              g_Dbs.db[i].superTbls[j].tagsFile);
-
-      fprintf(fp, "      columnCount:       %d\n        ",
-              g_Dbs.db[i].superTbls[j].columnCount);
-      for (int k = 0; k < g_Dbs.db[i].superTbls[j].columnCount; k++) {
-        //printf("dataType:%s, dataLen:%d\t", g_Dbs.db[i].superTbls[j].columns[k].dataType, g_Dbs.db[i].superTbls[j].columns[k].dataLen);
-        if ((0 == strncasecmp(
-                        g_Dbs.db[i].superTbls[j].columns[k].dataType,
-                        "binary", strlen("binary")))
-                || (0 == strncasecmp(
-                        g_Dbs.db[i].superTbls[j].columns[k].dataType,
-                        "nchar", strlen("nchar")))) {
-          fprintf(fp, "column[%d]:%s(%d) ", k,
-                  g_Dbs.db[i].superTbls[j].columns[k].dataType,
-                  g_Dbs.db[i].superTbls[j].columns[k].dataLen);
-        } else {
-          fprintf(fp, "column[%d]:%s ",
-                  k, g_Dbs.db[i].superTbls[j].columns[k].dataType);
+    for (int i = 0; i < g_Dbs.dbCount; i++) {
+        fprintf(fp, "database[%d]:\n", i);
+        fprintf(fp, "  database[%d] name:       %s\n", i, g_Dbs.db[i].dbName);
+        if (0 == g_Dbs.db[i].drop) {
+            fprintf(fp, "  drop:                  no\n");
+        }else {
+            fprintf(fp, "  drop:                  yes\n");
         }
-      }
-      fprintf(fp, "\n");
 
-      fprintf(fp, "      tagCount:            %d\n        ",
-              g_Dbs.db[i].superTbls[j].tagCount);
-      for (int k = 0; k < g_Dbs.db[i].superTbls[j].tagCount; k++) {
-        //printf("dataType:%s, dataLen:%d\t", g_Dbs.db[i].superTbls[j].tags[k].dataType, g_Dbs.db[i].superTbls[j].tags[k].dataLen);
-        if ((0 == strncasecmp(g_Dbs.db[i].superTbls[j].tags[k].dataType,
-                        "binary", strlen("binary")))
-                || (0 == strncasecmp(g_Dbs.db[i].superTbls[j].tags[k].dataType,
-                        "nchar", strlen("nchar")))) {
-          fprintf(fp, "tag[%d]:%s(%d) ",
-                  k, g_Dbs.db[i].superTbls[j].tags[k].dataType,
-                  g_Dbs.db[i].superTbls[j].tags[k].dataLen);
-        } else {
-          fprintf(fp, "tag[%d]:%s ", k, g_Dbs.db[i].superTbls[j].tags[k].dataType);
+        if (g_Dbs.db[i].dbCfg.blocks > 0) {
+            fprintf(fp, "  blocks:                %d\n", g_Dbs.db[i].dbCfg.blocks);
+        }
+        if (g_Dbs.db[i].dbCfg.cache > 0) {
+            fprintf(fp, "  cache:                 %d\n", g_Dbs.db[i].dbCfg.cache);
+        }
+        if (g_Dbs.db[i].dbCfg.days > 0) {
+            fprintf(fp, "  days:                  %d\n", g_Dbs.db[i].dbCfg.days);
+        }
+        if (g_Dbs.db[i].dbCfg.keep > 0) {
+            fprintf(fp, "  keep:                  %d\n", g_Dbs.db[i].dbCfg.keep);
+        }
+        if (g_Dbs.db[i].dbCfg.replica > 0) {
+            fprintf(fp, "  replica:               %d\n", g_Dbs.db[i].dbCfg.replica);
+        }
+        if (g_Dbs.db[i].dbCfg.update > 0) {
+            fprintf(fp, "  update:                %d\n", g_Dbs.db[i].dbCfg.update);
+        }
+        if (g_Dbs.db[i].dbCfg.minRows > 0) {
+            fprintf(fp, "  minRows:               %d\n", g_Dbs.db[i].dbCfg.minRows);
+        }
+        if (g_Dbs.db[i].dbCfg.maxRows > 0) {
+            fprintf(fp, "  maxRows:               %d\n", g_Dbs.db[i].dbCfg.maxRows);
+        }
+        if (g_Dbs.db[i].dbCfg.comp > 0) {
+            fprintf(fp, "  comp:                  %d\n", g_Dbs.db[i].dbCfg.comp);
+        }
+        if (g_Dbs.db[i].dbCfg.walLevel > 0) {
+            fprintf(fp, "  walLevel:              %d\n", g_Dbs.db[i].dbCfg.walLevel);
+        }
+        if (g_Dbs.db[i].dbCfg.fsync > 0) {
+            fprintf(fp, "  fsync:                 %d\n", g_Dbs.db[i].dbCfg.fsync);
+        }
+        if (g_Dbs.db[i].dbCfg.quorum > 0) {
+            fprintf(fp, "  quorum:                %d\n", g_Dbs.db[i].dbCfg.quorum);
+        }
+        if (g_Dbs.db[i].dbCfg.precision[0] != 0) {
+            if ((0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "ms", 2))
+                    || (0 == strncasecmp(g_Dbs.db[i].dbCfg.precision, "us", 2))) {
+                fprintf(fp, "  precision:             %s\n",
+                        g_Dbs.db[i].dbCfg.precision);
+            } else {
+                fprintf(fp, "  precision error:       %s\n",
+                        g_Dbs.db[i].dbCfg.precision);
+            }
         }
-      }
-      fprintf(fp, "\n");
-    }
-    fprintf(fp, "\n");
-  }
 
-  SHOW_PARSE_RESULT_END_TO_FILE(fp);
+        fprintf(fp, "  super table count:     %"PRIu64"\n",
+                g_Dbs.db[i].superTblCount);
+        for (int j = 0; j < g_Dbs.db[i].superTblCount; j++) {
+            fprintf(fp, "  super table[%d]:\n", j);
+
+            fprintf(fp, "      stbName:           %s\n",
+                    g_Dbs.db[i].superTbls[j].sTblName);
+
+            if (PRE_CREATE_SUBTBL == g_Dbs.db[i].superTbls[j].autoCreateTable) {
+                fprintf(fp, "      autoCreateTable:   %s\n",  "no");
+            } else if (AUTO_CREATE_SUBTBL
+                    == g_Dbs.db[i].superTbls[j].autoCreateTable) {
+                fprintf(fp, "      autoCreateTable:   %s\n",  "yes");
+            } else {
+                fprintf(fp, "      autoCreateTable:   %s\n",  "error");
+            }
+
+            if (TBL_NO_EXISTS == g_Dbs.db[i].superTbls[j].childTblExists) {
+                fprintf(fp, "      childTblExists:    %s\n",  "no");
+            } else if (TBL_ALREADY_EXISTS
+                    == g_Dbs.db[i].superTbls[j].childTblExists) {
+                fprintf(fp, "      childTblExists:    %s\n",  "yes");
+            } else {
+                fprintf(fp, "      childTblExists:    %s\n",  "error");
+            }
+
+            fprintf(fp, "      childTblCount:     %"PRId64"\n",
+                    g_Dbs.db[i].superTbls[j].childTblCount);
+            fprintf(fp, "      childTblPrefix:    %s\n",
+                    g_Dbs.db[i].superTbls[j].childTblPrefix);
+            fprintf(fp, "      dataSource:        %s\n",
+                    g_Dbs.db[i].superTbls[j].dataSource);
+            fprintf(fp, "      iface:             %s\n",
+                    (g_Dbs.db[i].superTbls[j].iface==TAOSC_IFACE)?"taosc":
+                    (g_Dbs.db[i].superTbls[j].iface==REST_IFACE)?"rest":"stmt");
+            fprintf(fp, "      insertRows:        %"PRId64"\n",
+                    g_Dbs.db[i].superTbls[j].insertRows);
+            fprintf(fp, "      interlace rows:    %u\n",
+                    g_Dbs.db[i].superTbls[j].interlaceRows);
+            if (g_Dbs.db[i].superTbls[j].interlaceRows > 0) {
+                fprintf(fp, "      stable insert interval:   %"PRIu64"\n",
+                        g_Dbs.db[i].superTbls[j].insertInterval);
+            }
+            /*
+               if (0 == g_Dbs.db[i].superTbls[j].multiThreadWriteOneTbl) {
+               fprintf(fp, "      multiThreadWriteOneTbl:  no\n");
+               }else {
+               fprintf(fp, "      multiThreadWriteOneTbl:  yes\n");
+               }
+               */
+            fprintf(fp, "      interlaceRows:     %u\n",
+                    g_Dbs.db[i].superTbls[j].interlaceRows);
+            fprintf(fp, "      disorderRange:     %d\n",
+                    g_Dbs.db[i].superTbls[j].disorderRange);
+            fprintf(fp, "      disorderRatio:     %d\n",
+                    g_Dbs.db[i].superTbls[j].disorderRatio);
+            fprintf(fp, "      maxSqlLen:         %"PRIu64"\n",
+                    g_Dbs.db[i].superTbls[j].maxSqlLen);
+
+            fprintf(fp, "      timeStampStep:     %"PRId64"\n",
+                    g_Dbs.db[i].superTbls[j].timeStampStep);
+            fprintf(fp, "      startTimestamp:    %s\n",
+                    g_Dbs.db[i].superTbls[j].startTimestamp);
+            fprintf(fp, "      sampleFormat:      %s\n",
+                    g_Dbs.db[i].superTbls[j].sampleFormat);
+            fprintf(fp, "      sampleFile:        %s\n",
+                    g_Dbs.db[i].superTbls[j].sampleFile);
+            fprintf(fp, "      tagsFile:          %s\n",
+                    g_Dbs.db[i].superTbls[j].tagsFile);
+
+            fprintf(fp, "      columnCount:       %d\n        ",
+                    g_Dbs.db[i].superTbls[j].columnCount);
+            for (int k = 0; k < g_Dbs.db[i].superTbls[j].columnCount; k++) {
+                //printf("dataType:%s, dataLen:%d\t", g_Dbs.db[i].superTbls[j].columns[k].dataType, g_Dbs.db[i].superTbls[j].columns[k].dataLen);
+                if ((0 == strncasecmp(
+                                g_Dbs.db[i].superTbls[j].columns[k].dataType,
+                                "binary", strlen("binary")))
+                        || (0 == strncasecmp(
+                                g_Dbs.db[i].superTbls[j].columns[k].dataType,
+                                "nchar", strlen("nchar")))) {
+                    fprintf(fp, "column[%d]:%s(%d) ", k,
+                            g_Dbs.db[i].superTbls[j].columns[k].dataType,
+                            g_Dbs.db[i].superTbls[j].columns[k].dataLen);
+                } else {
+                    fprintf(fp, "column[%d]:%s ",
+                            k, g_Dbs.db[i].superTbls[j].columns[k].dataType);
+                }
+            }
+            fprintf(fp, "\n");
+
+            fprintf(fp, "      tagCount:            %d\n        ",
+                    g_Dbs.db[i].superTbls[j].tagCount);
+            for (int k = 0; k < g_Dbs.db[i].superTbls[j].tagCount; k++) {
+                //printf("dataType:%s, dataLen:%d\t", g_Dbs.db[i].superTbls[j].tags[k].dataType, g_Dbs.db[i].superTbls[j].tags[k].dataLen);
+                if ((0 == strncasecmp(g_Dbs.db[i].superTbls[j].tags[k].dataType,
+                                "binary", strlen("binary")))
+                        || (0 == strncasecmp(g_Dbs.db[i].superTbls[j].tags[k].dataType,
+                                "nchar", strlen("nchar")))) {
+                    fprintf(fp, "tag[%d]:%s(%d) ",
+                            k, g_Dbs.db[i].superTbls[j].tags[k].dataType,
+                            g_Dbs.db[i].superTbls[j].tags[k].dataLen);
+                } else {
+                    fprintf(fp, "tag[%d]:%s ", k, g_Dbs.db[i].superTbls[j].tags[k].dataType);
+                }
+            }
+            fprintf(fp, "\n");
+        }
+        fprintf(fp, "\n");
+    }
+
+    SHOW_PARSE_RESULT_END_TO_FILE(fp);
 }
 
 static void printfQueryMeta() {
 
-  SHOW_PARSE_RESULT_START();
+    SHOW_PARSE_RESULT_START();
 
-  printf("host:                    \033[33m%s:%u\033[0m\n",
-          g_queryInfo.host, g_queryInfo.port);
-  printf("user:                    \033[33m%s\033[0m\n", g_queryInfo.user);
-  printf("database name:           \033[33m%s\033[0m\n", g_queryInfo.dbName);
+    printf("host:                    \033[33m%s:%u\033[0m\n",
+            g_queryInfo.host, g_queryInfo.port);
+    printf("user:                    \033[33m%s\033[0m\n", g_queryInfo.user);
+    printf("database name:           \033[33m%s\033[0m\n", g_queryInfo.dbName);
 
-  printf("\n");
+    printf("\n");
 
-  if ((SUBSCRIBE_TEST == g_args.test_mode) || (QUERY_TEST == g_args.test_mode)) {
-    printf("specified table query info:                   \n");
-    printf("sqlCount:       \033[33m%d\033[0m\n",
-      g_queryInfo.specifiedQueryInfo.sqlCount);
-    if (g_queryInfo.specifiedQueryInfo.sqlCount > 0) {
-      printf("specified tbl query times:\n");
-      printf("                \033[33m%"PRIu64"\033[0m\n",
-      g_queryInfo.specifiedQueryInfo.queryTimes);
-      printf("query interval: \033[33m%"PRIu64" ms\033[0m\n",
-        g_queryInfo.specifiedQueryInfo.queryInterval);
-      printf("top query times:\033[33m%"PRIu64"\033[0m\n", g_args.query_times);
-      printf("concurrent:     \033[33m%d\033[0m\n",
-      g_queryInfo.specifiedQueryInfo.concurrent);
-      printf("mod:            \033[33m%s\033[0m\n",
-        (g_queryInfo.specifiedQueryInfo.asyncMode)?"async":"sync");
-      printf("interval:       \033[33m%"PRIu64"\033[0m\n",
-        g_queryInfo.specifiedQueryInfo.subscribeInterval);
-      printf("restart:        \033[33m%d\033[0m\n",
-        g_queryInfo.specifiedQueryInfo.subscribeRestart);
-      printf("keepProgress:   \033[33m%d\033[0m\n",
-        g_queryInfo.specifiedQueryInfo.subscribeKeepProgress);
+    if ((SUBSCRIBE_TEST == g_args.test_mode) || (QUERY_TEST == g_args.test_mode)) {
+        printf("specified table query info:                   \n");
+        printf("sqlCount:       \033[33m%d\033[0m\n",
+                g_queryInfo.specifiedQueryInfo.sqlCount);
+        if (g_queryInfo.specifiedQueryInfo.sqlCount > 0) {
+            printf("specified tbl query times:\n");
+            printf("                \033[33m%"PRIu64"\033[0m\n",
+                    g_queryInfo.specifiedQueryInfo.queryTimes);
+            printf("query interval: \033[33m%"PRIu64" ms\033[0m\n",
+                    g_queryInfo.specifiedQueryInfo.queryInterval);
+            printf("top query times:\033[33m%"PRIu64"\033[0m\n", g_args.query_times);
+            printf("concurrent:     \033[33m%d\033[0m\n",
+                    g_queryInfo.specifiedQueryInfo.concurrent);
+            printf("mod:            \033[33m%s\033[0m\n",
+                    (g_queryInfo.specifiedQueryInfo.asyncMode)?"async":"sync");
+            printf("interval:       \033[33m%"PRIu64"\033[0m\n",
+                    g_queryInfo.specifiedQueryInfo.subscribeInterval);
+            printf("restart:        \033[33m%d\033[0m\n",
+                    g_queryInfo.specifiedQueryInfo.subscribeRestart);
+            printf("keepProgress:   \033[33m%d\033[0m\n",
+                    g_queryInfo.specifiedQueryInfo.subscribeKeepProgress);
 
-      for (int i = 0; i < g_queryInfo.specifiedQueryInfo.sqlCount; i++) {
-        printf("  sql[%d]: \033[33m%s\033[0m\n",
-            i, g_queryInfo.specifiedQueryInfo.sql[i]);
-      }
-      printf("\n");
+            for (int i = 0; i < g_queryInfo.specifiedQueryInfo.sqlCount; i++) {
+                printf("  sql[%d]: \033[33m%s\033[0m\n",
+                        i, g_queryInfo.specifiedQueryInfo.sql[i]);
+            }
+            printf("\n");
+        }
+
+        printf("super table query info:\n");
+        printf("sqlCount:       \033[33m%d\033[0m\n",
+                g_queryInfo.superQueryInfo.sqlCount);
+
+        if (g_queryInfo.superQueryInfo.sqlCount > 0) {
+            printf("query interval: \033[33m%"PRIu64"\033[0m\n",
+                    g_queryInfo.superQueryInfo.queryInterval);
+            printf("threadCnt:      \033[33m%d\033[0m\n",
+                    g_queryInfo.superQueryInfo.threadCnt);
+            printf("childTblCount:  \033[33m%"PRId64"\033[0m\n",
+                    g_queryInfo.superQueryInfo.childTblCount);
+            printf("stable name:    \033[33m%s\033[0m\n",
+                    g_queryInfo.superQueryInfo.sTblName);
+            printf("stb query times:\033[33m%"PRIu64"\033[0m\n",
+                    g_queryInfo.superQueryInfo.queryTimes);
+
+            printf("mod:            \033[33m%s\033[0m\n",
+                    (g_queryInfo.superQueryInfo.asyncMode)?"async":"sync");
+            printf("interval:       \033[33m%"PRIu64"\033[0m\n",
+                    g_queryInfo.superQueryInfo.subscribeInterval);
+            printf("restart:        \033[33m%d\033[0m\n",
+                    g_queryInfo.superQueryInfo.subscribeRestart);
+            printf("keepProgress:   \033[33m%d\033[0m\n",
+                    g_queryInfo.superQueryInfo.subscribeKeepProgress);
+
+            for (int i = 0; i < g_queryInfo.superQueryInfo.sqlCount; i++) {
+                printf("  sql[%d]: \033[33m%s\033[0m\n",
+                        i, g_queryInfo.superQueryInfo.sql[i]);
+            }
+            printf("\n");
+        }
     }
 
-    printf("super table query info:\n");
-    printf("sqlCount:       \033[33m%d\033[0m\n",
-      g_queryInfo.superQueryInfo.sqlCount);
-
-    if (g_queryInfo.superQueryInfo.sqlCount > 0) {
-      printf("query interval: \033[33m%"PRIu64"\033[0m\n",
-        g_queryInfo.superQueryInfo.queryInterval);
-      printf("threadCnt:      \033[33m%d\033[0m\n",
-        g_queryInfo.superQueryInfo.threadCnt);
-      printf("childTblCount:  \033[33m%"PRId64"\033[0m\n",
-        g_queryInfo.superQueryInfo.childTblCount);
-      printf("stable name:    \033[33m%s\033[0m\n",
-        g_queryInfo.superQueryInfo.sTblName);
-      printf("stb query times:\033[33m%"PRIu64"\033[0m\n",
-        g_queryInfo.superQueryInfo.queryTimes);
-
-      printf("mod:            \033[33m%s\033[0m\n",
-        (g_queryInfo.superQueryInfo.asyncMode)?"async":"sync");
-      printf("interval:       \033[33m%"PRIu64"\033[0m\n",
-        g_queryInfo.superQueryInfo.subscribeInterval);
-      printf("restart:        \033[33m%d\033[0m\n",
-        g_queryInfo.superQueryInfo.subscribeRestart);
-      printf("keepProgress:   \033[33m%d\033[0m\n",
-        g_queryInfo.superQueryInfo.subscribeKeepProgress);
-
-      for (int i = 0; i < g_queryInfo.superQueryInfo.sqlCount; i++) {
-        printf("  sql[%d]: \033[33m%s\033[0m\n",
-            i, g_queryInfo.superQueryInfo.sql[i]);
-      }
-      printf("\n");
-    }
-  }
-
-  SHOW_PARSE_RESULT_END();
+    SHOW_PARSE_RESULT_END();
 }
 
 static char* formatTimestamp(char* buf, int64_t val, int precision) {
-  time_t tt;
-  if (precision == TSDB_TIME_PRECISION_NANO) {
-    tt = (time_t)(val / 1000000000);
-  } else if (precision == TSDB_TIME_PRECISION_MICRO) {
-    tt = (time_t)(val / 1000000);
-  } else {
-    tt = (time_t)(val / 1000);
-  }
+    time_t tt;
+    if (precision == TSDB_TIME_PRECISION_NANO) {
+        tt = (time_t)(val / 1000000000);
+    } else if (precision == TSDB_TIME_PRECISION_MICRO) {
+        tt = (time_t)(val / 1000000);
+    } else {
+        tt = (time_t)(val / 1000);
+    }
 
-/* comment out as it make testcases like select_with_tags.sim fail.
-  but in windows, this may cause the call to localtime crash if tt < 0,
-  need to find a better solution.
-  if (tt < 0) {
-    tt = 0;
-  }
-  */
+    /* comment out as it make testcases like select_with_tags.sim fail.
+       but in windows, this may cause the call to localtime crash if tt < 0,
+       need to find a better solution.
+       if (tt < 0) {
+       tt = 0;
+       }
+       */
 
 #ifdef WINDOWS
-  if (tt < 0) tt = 0;
+    if (tt < 0) tt = 0;
 #endif
 
-  struct tm* ptm = localtime(&tt);
-  size_t pos = strftime(buf, 32, "%Y-%m-%d %H:%M:%S", ptm);
+    struct tm* ptm = localtime(&tt);
+    size_t pos = strftime(buf, 32, "%Y-%m-%d %H:%M:%S", ptm);
 
-  if (precision == TSDB_TIME_PRECISION_NANO) {
-    sprintf(buf + pos, ".%09d", (int)(val % 1000000000));
-  } else if (precision == TSDB_TIME_PRECISION_MICRO) {
-    sprintf(buf + pos, ".%06d", (int)(val % 1000000));
-  } else {
-    sprintf(buf + pos, ".%03d", (int)(val % 1000));
-  }
+    if (precision == TSDB_TIME_PRECISION_NANO) {
+        sprintf(buf + pos, ".%09d", (int)(val % 1000000000));
+    } else if (precision == TSDB_TIME_PRECISION_MICRO) {
+        sprintf(buf + pos, ".%06d", (int)(val % 1000000));
+    } else {
+        sprintf(buf + pos, ".%03d", (int)(val % 1000));
+    }
 
-  return buf;
+    return buf;
 }
 
 static void xDumpFieldToFile(FILE* fp, const char* val,
         TAOS_FIELD* field, int32_t length, int precision) {
 
-  if (val == NULL) {
-    fprintf(fp, "%s", TSDB_DATA_NULL_STR);
-    return;
-  }
+    if (val == NULL) {
+        fprintf(fp, "%s", TSDB_DATA_NULL_STR);
+        return;
+    }
 
-  char buf[TSDB_MAX_BYTES_PER_ROW];
-  switch (field->type) {
-    case TSDB_DATA_TYPE_BOOL:
-      fprintf(fp, "%d", ((((int32_t)(*((char *)val))) == 1) ? 1 : 0));
-      break;
-    case TSDB_DATA_TYPE_TINYINT:
-      fprintf(fp, "%d", *((int8_t *)val));
-      break;
-    case TSDB_DATA_TYPE_SMALLINT:
-      fprintf(fp, "%d", *((int16_t *)val));
-      break;
-    case TSDB_DATA_TYPE_INT:
-      fprintf(fp, "%d", *((int32_t *)val));
-      break;
-    case TSDB_DATA_TYPE_BIGINT:
-      fprintf(fp, "%" PRId64, *((int64_t *)val));
-      break;
-    case TSDB_DATA_TYPE_FLOAT:
-      fprintf(fp, "%.5f", GET_FLOAT_VAL(val));
-      break;
-    case TSDB_DATA_TYPE_DOUBLE:
-      fprintf(fp, "%.9f", GET_DOUBLE_VAL(val));
-      break;
-    case TSDB_DATA_TYPE_BINARY:
-    case TSDB_DATA_TYPE_NCHAR:
-      memcpy(buf, val, length);
-      buf[length] = 0;
-      fprintf(fp, "\'%s\'", buf);
-      break;
-    case TSDB_DATA_TYPE_TIMESTAMP:
-      formatTimestamp(buf, *(int64_t*)val, precision);
-      fprintf(fp, "'%s'", buf);
-      break;
-    default:
-      break;
-  }
+    char buf[TSDB_MAX_BYTES_PER_ROW];
+    switch (field->type) {
+        case TSDB_DATA_TYPE_BOOL:
+            fprintf(fp, "%d", ((((int32_t)(*((char *)val))) == 1) ? 1 : 0));
+            break;
+        case TSDB_DATA_TYPE_TINYINT:
+            fprintf(fp, "%d", *((int8_t *)val));
+            break;
+        case TSDB_DATA_TYPE_SMALLINT:
+            fprintf(fp, "%d", *((int16_t *)val));
+            break;
+        case TSDB_DATA_TYPE_INT:
+            fprintf(fp, "%d", *((int32_t *)val));
+            break;
+        case TSDB_DATA_TYPE_BIGINT:
+            fprintf(fp, "%" PRId64, *((int64_t *)val));
+            break;
+        case TSDB_DATA_TYPE_FLOAT:
+            fprintf(fp, "%.5f", GET_FLOAT_VAL(val));
+            break;
+        case TSDB_DATA_TYPE_DOUBLE:
+            fprintf(fp, "%.9f", GET_DOUBLE_VAL(val));
+            break;
+        case TSDB_DATA_TYPE_BINARY:
+        case TSDB_DATA_TYPE_NCHAR:
+            memcpy(buf, val, length);
+            buf[length] = 0;
+            fprintf(fp, "\'%s\'", buf);
+            break;
+        case TSDB_DATA_TYPE_TIMESTAMP:
+            formatTimestamp(buf, *(int64_t*)val, precision);
+            fprintf(fp, "'%s'", buf);
+            break;
+        default:
+            break;
+    }
 }
 
 static int xDumpResultToFile(const char* fname, TAOS_RES* tres) {
-  TAOS_ROW row = taos_fetch_row(tres);
-  if (row == NULL) {
-    return 0;
-  }
-
-  FILE* fp = fopen(fname, "at");
-  if (fp == NULL) {
-    errorPrint("%s() LN%d, failed to open file: %s\n", __func__, __LINE__, fname);
-    return -1;
-  }
-
-  int num_fields = taos_num_fields(tres);
-  TAOS_FIELD *fields = taos_fetch_fields(tres);
-  int precision = taos_result_precision(tres);
-
-  for (int col = 0; col < num_fields; col++) {
-    if (col > 0) {
-      fprintf(fp, ",");
+    TAOS_ROW row = taos_fetch_row(tres);
+    if (row == NULL) {
+        return 0;
     }
-    fprintf(fp, "%s", fields[col].name);
-  }
-  fputc('\n', fp);
 
-  int numOfRows = 0;
-  do {
-    int32_t* length = taos_fetch_lengths(tres);
-    for (int i = 0; i < num_fields; i++) {
-      if (i > 0) {
-        fputc(',', fp);
-      }
-      xDumpFieldToFile(fp, (const char*)row[i], fields +i, length[i], precision);
+    FILE* fp = fopen(fname, "at");
+    if (fp == NULL) {
+        errorPrint("%s() LN%d, failed to open file: %s\n",
+                __func__, __LINE__, fname);
+        return -1;
+    }
+
+    int num_fields = taos_num_fields(tres);
+    TAOS_FIELD *fields = taos_fetch_fields(tres);
+    int precision = taos_result_precision(tres);
+
+    for (int col = 0; col < num_fields; col++) {
+        if (col > 0) {
+            fprintf(fp, ",");
+        }
+        fprintf(fp, "%s", fields[col].name);
     }
     fputc('\n', fp);
 
-    numOfRows++;
-    row = taos_fetch_row(tres);
-  } while( row != NULL);
+    int numOfRows = 0;
+    do {
+        int32_t* length = taos_fetch_lengths(tres);
+        for (int i = 0; i < num_fields; i++) {
+            if (i > 0) {
+                fputc(',', fp);
+            }
+            xDumpFieldToFile(fp,
+                    (const char*)row[i], fields +i, length[i], precision);
+        }
+        fputc('\n', fp);
 
-  fclose(fp);
+        numOfRows++;
+        row = taos_fetch_row(tres);
+    } while( row != NULL);
 
-  return numOfRows;
+    fclose(fp);
+
+    return numOfRows;
 }
 
 static int getDbFromServer(TAOS * taos, SDbInfo** dbInfos) {
-  TAOS_RES * res;
-  TAOS_ROW row = NULL;
-  int count = 0;
+    TAOS_RES * res;
+    TAOS_ROW row = NULL;
+    int count = 0;
 
-  res = taos_query(taos, "show databases;");
-  int32_t code = taos_errno(res);
+    res = taos_query(taos, "show databases;");
+    int32_t code = taos_errno(res);
 
-  if (code != 0) {
-    errorPrint( "failed to run <show databases>, reason: %s\n", taos_errstr(res));
-    return -1;
-  }
-
-  TAOS_FIELD *fields = taos_fetch_fields(res);
-
-  while((row = taos_fetch_row(res)) != NULL) {
-    // sys database name : 'log'
-    if (strncasecmp(row[TSDB_SHOW_DB_NAME_INDEX], "log",
-                fields[TSDB_SHOW_DB_NAME_INDEX].bytes) == 0) {
-      continue;
+    if (code != 0) {
+        errorPrint( "failed to run <show databases>, reason: %s\n",
+                taos_errstr(res));
+        return -1;
     }
 
-    dbInfos[count] = (SDbInfo *)calloc(1, sizeof(SDbInfo));
-    if (dbInfos[count] == NULL) {
-      errorPrint( "failed to allocate memory for some dbInfo[%d]\n", count);
-      return -1;
+    TAOS_FIELD *fields = taos_fetch_fields(res);
+
+    while((row = taos_fetch_row(res)) != NULL) {
+        // sys database name : 'log'
+        if (strncasecmp(row[TSDB_SHOW_DB_NAME_INDEX], "log",
+                    fields[TSDB_SHOW_DB_NAME_INDEX].bytes) == 0) {
+            continue;
+        }
+
+        dbInfos[count] = (SDbInfo *)calloc(1, sizeof(SDbInfo));
+        if (dbInfos[count] == NULL) {
+            errorPrint( "failed to allocate memory for some dbInfo[%d]\n", count);
+            return -1;
+        }
+
+        tstrncpy(dbInfos[count]->name, (char *)row[TSDB_SHOW_DB_NAME_INDEX],
+                fields[TSDB_SHOW_DB_NAME_INDEX].bytes);
+        formatTimestamp(dbInfos[count]->create_time,
+                *(int64_t*)row[TSDB_SHOW_DB_CREATED_TIME_INDEX],
+                TSDB_TIME_PRECISION_MILLI);
+        dbInfos[count]->ntables = *((int64_t *)row[TSDB_SHOW_DB_NTABLES_INDEX]);
+        dbInfos[count]->vgroups = *((int32_t *)row[TSDB_SHOW_DB_VGROUPS_INDEX]);
+        dbInfos[count]->replica = *((int16_t *)row[TSDB_SHOW_DB_REPLICA_INDEX]);
+        dbInfos[count]->quorum = *((int16_t *)row[TSDB_SHOW_DB_QUORUM_INDEX]);
+        dbInfos[count]->days = *((int16_t *)row[TSDB_SHOW_DB_DAYS_INDEX]);
+
+        tstrncpy(dbInfos[count]->keeplist, (char *)row[TSDB_SHOW_DB_KEEP_INDEX],
+                fields[TSDB_SHOW_DB_KEEP_INDEX].bytes);
+        dbInfos[count]->cache = *((int32_t *)row[TSDB_SHOW_DB_CACHE_INDEX]);
+        dbInfos[count]->blocks = *((int32_t *)row[TSDB_SHOW_DB_BLOCKS_INDEX]);
+        dbInfos[count]->minrows = *((int32_t *)row[TSDB_SHOW_DB_MINROWS_INDEX]);
+        dbInfos[count]->maxrows = *((int32_t *)row[TSDB_SHOW_DB_MAXROWS_INDEX]);
+        dbInfos[count]->wallevel = *((int8_t *)row[TSDB_SHOW_DB_WALLEVEL_INDEX]);
+        dbInfos[count]->fsync = *((int32_t *)row[TSDB_SHOW_DB_FSYNC_INDEX]);
+        dbInfos[count]->comp = (int8_t)(*((int8_t *)row[TSDB_SHOW_DB_COMP_INDEX]));
+        dbInfos[count]->cachelast =
+            (int8_t)(*((int8_t *)row[TSDB_SHOW_DB_CACHELAST_INDEX]));
+
+        tstrncpy(dbInfos[count]->precision,
+                (char *)row[TSDB_SHOW_DB_PRECISION_INDEX],
+                fields[TSDB_SHOW_DB_PRECISION_INDEX].bytes);
+        dbInfos[count]->update = *((int8_t *)row[TSDB_SHOW_DB_UPDATE_INDEX]);
+        tstrncpy(dbInfos[count]->status, (char *)row[TSDB_SHOW_DB_STATUS_INDEX],
+                fields[TSDB_SHOW_DB_STATUS_INDEX].bytes);
+
+        count++;
+        if (count > MAX_DATABASE_COUNT) {
+            errorPrint("%s() LN%d, The database count overflow than %d\n",
+                    __func__, __LINE__, MAX_DATABASE_COUNT);
+            break;
+        }
     }
 
-    tstrncpy(dbInfos[count]->name, (char *)row[TSDB_SHOW_DB_NAME_INDEX],
-            fields[TSDB_SHOW_DB_NAME_INDEX].bytes);
-    formatTimestamp(dbInfos[count]->create_time,
-            *(int64_t*)row[TSDB_SHOW_DB_CREATED_TIME_INDEX],
-            TSDB_TIME_PRECISION_MILLI);
-    dbInfos[count]->ntables = *((int64_t *)row[TSDB_SHOW_DB_NTABLES_INDEX]);
-    dbInfos[count]->vgroups = *((int32_t *)row[TSDB_SHOW_DB_VGROUPS_INDEX]);
-    dbInfos[count]->replica = *((int16_t *)row[TSDB_SHOW_DB_REPLICA_INDEX]);
-    dbInfos[count]->quorum = *((int16_t *)row[TSDB_SHOW_DB_QUORUM_INDEX]);
-    dbInfos[count]->days = *((int16_t *)row[TSDB_SHOW_DB_DAYS_INDEX]);
-
-    tstrncpy(dbInfos[count]->keeplist, (char *)row[TSDB_SHOW_DB_KEEP_INDEX],
-            fields[TSDB_SHOW_DB_KEEP_INDEX].bytes);
-    dbInfos[count]->cache = *((int32_t *)row[TSDB_SHOW_DB_CACHE_INDEX]);
-    dbInfos[count]->blocks = *((int32_t *)row[TSDB_SHOW_DB_BLOCKS_INDEX]);
-    dbInfos[count]->minrows = *((int32_t *)row[TSDB_SHOW_DB_MINROWS_INDEX]);
-    dbInfos[count]->maxrows = *((int32_t *)row[TSDB_SHOW_DB_MAXROWS_INDEX]);
-    dbInfos[count]->wallevel = *((int8_t *)row[TSDB_SHOW_DB_WALLEVEL_INDEX]);
-    dbInfos[count]->fsync = *((int32_t *)row[TSDB_SHOW_DB_FSYNC_INDEX]);
-    dbInfos[count]->comp = (int8_t)(*((int8_t *)row[TSDB_SHOW_DB_COMP_INDEX]));
-    dbInfos[count]->cachelast =
-      (int8_t)(*((int8_t *)row[TSDB_SHOW_DB_CACHELAST_INDEX]));
-
-    tstrncpy(dbInfos[count]->precision,
-            (char *)row[TSDB_SHOW_DB_PRECISION_INDEX],
-            fields[TSDB_SHOW_DB_PRECISION_INDEX].bytes);
-    dbInfos[count]->update = *((int8_t *)row[TSDB_SHOW_DB_UPDATE_INDEX]);
-    tstrncpy(dbInfos[count]->status, (char *)row[TSDB_SHOW_DB_STATUS_INDEX],
-            fields[TSDB_SHOW_DB_STATUS_INDEX].bytes);
-
-    count++;
-    if (count > MAX_DATABASE_COUNT) {
-      errorPrint("%s() LN%d, The database count overflow than %d\n",
-         __func__, __LINE__, MAX_DATABASE_COUNT);
-      break;
-    }
-  }
-
-  return count;
+    return count;
 }
 
 static void printfDbInfoForQueryToFile(
         char* filename, SDbInfo* dbInfos, int index) {
 
-  if (filename[0] == 0)
-      return;
+    if (filename[0] == 0)
+        return;
 
-  FILE *fp = fopen(filename, "at");
-  if (fp == NULL) {
-    errorPrint( "failed to open file: %s\n", filename);
-    return;
-  }
+    FILE *fp = fopen(filename, "at");
+    if (fp == NULL) {
+        errorPrint( "failed to open file: %s\n", filename);
+        return;
+    }
 
-  fprintf(fp, "================ database[%d] ================\n", index);
-  fprintf(fp, "name: %s\n", dbInfos->name);
-  fprintf(fp, "created_time: %s\n", dbInfos->create_time);
-  fprintf(fp, "ntables: %"PRId64"\n", dbInfos->ntables);
-  fprintf(fp, "vgroups: %d\n", dbInfos->vgroups);
-  fprintf(fp, "replica: %d\n", dbInfos->replica);
-  fprintf(fp, "quorum: %d\n", dbInfos->quorum);
-  fprintf(fp, "days: %d\n", dbInfos->days);
-  fprintf(fp, "keep0,keep1,keep(D): %s\n", dbInfos->keeplist);
-  fprintf(fp, "cache(MB): %d\n", dbInfos->cache);
-  fprintf(fp, "blocks: %d\n", dbInfos->blocks);
-  fprintf(fp, "minrows: %d\n", dbInfos->minrows);
-  fprintf(fp, "maxrows: %d\n", dbInfos->maxrows);
-  fprintf(fp, "wallevel: %d\n", dbInfos->wallevel);
-  fprintf(fp, "fsync: %d\n", dbInfos->fsync);
-  fprintf(fp, "comp: %d\n", dbInfos->comp);
-  fprintf(fp, "cachelast: %d\n", dbInfos->cachelast);
-  fprintf(fp, "precision: %s\n", dbInfos->precision);
-  fprintf(fp, "update: %d\n", dbInfos->update);
-  fprintf(fp, "status: %s\n", dbInfos->status);
-  fprintf(fp, "\n");
+    fprintf(fp, "================ database[%d] ================\n", index);
+    fprintf(fp, "name: %s\n", dbInfos->name);
+    fprintf(fp, "created_time: %s\n", dbInfos->create_time);
+    fprintf(fp, "ntables: %"PRId64"\n", dbInfos->ntables);
+    fprintf(fp, "vgroups: %d\n", dbInfos->vgroups);
+    fprintf(fp, "replica: %d\n", dbInfos->replica);
+    fprintf(fp, "quorum: %d\n", dbInfos->quorum);
+    fprintf(fp, "days: %d\n", dbInfos->days);
+    fprintf(fp, "keep0,keep1,keep(D): %s\n", dbInfos->keeplist);
+    fprintf(fp, "cache(MB): %d\n", dbInfos->cache);
+    fprintf(fp, "blocks: %d\n", dbInfos->blocks);
+    fprintf(fp, "minrows: %d\n", dbInfos->minrows);
+    fprintf(fp, "maxrows: %d\n", dbInfos->maxrows);
+    fprintf(fp, "wallevel: %d\n", dbInfos->wallevel);
+    fprintf(fp, "fsync: %d\n", dbInfos->fsync);
+    fprintf(fp, "comp: %d\n", dbInfos->comp);
+    fprintf(fp, "cachelast: %d\n", dbInfos->cachelast);
+    fprintf(fp, "precision: %s\n", dbInfos->precision);
+    fprintf(fp, "update: %d\n", dbInfos->update);
+    fprintf(fp, "status: %s\n", dbInfos->status);
+    fprintf(fp, "\n");
 
-  fclose(fp);
+    fclose(fp);
 }
 
 static void printfQuerySystemInfo(TAOS * taos) {
-  char filename[MAX_QUERY_SQL_LENGTH+1] = {0};
-  char buffer[MAX_QUERY_SQL_LENGTH+1] = {0};
-  TAOS_RES* res;
+    char filename[MAX_QUERY_SQL_LENGTH+1] = {0};
+    char buffer[MAX_QUERY_SQL_LENGTH+1] = {0};
+    TAOS_RES* res;
 
-  time_t t;
-  struct tm* lt;
-  time(&t);
-  lt = localtime(&t);
-  snprintf(filename, MAX_QUERY_SQL_LENGTH, "querySystemInfo-%d-%d-%d %d:%d:%d",
-          lt->tm_year+1900, lt->tm_mon, lt->tm_mday, lt->tm_hour, lt->tm_min,
-          lt->tm_sec);
+    time_t t;
+    struct tm* lt;
+    time(&t);
+    lt = localtime(&t);
+    snprintf(filename, MAX_QUERY_SQL_LENGTH, "querySystemInfo-%d-%d-%d %d:%d:%d",
+            lt->tm_year+1900, lt->tm_mon, lt->tm_mday, lt->tm_hour, lt->tm_min,
+            lt->tm_sec);
 
-  // show variables
-  res = taos_query(taos, "show variables;");
-  //fetchResult(res, filename);
-  xDumpResultToFile(filename, res);
-
-  // show dnodes
-  res = taos_query(taos, "show dnodes;");
-  xDumpResultToFile(filename, res);
-  //fetchResult(res, filename);
-
-  // show databases
-  res = taos_query(taos, "show databases;");
-  SDbInfo** dbInfos = (SDbInfo **)calloc(MAX_DATABASE_COUNT, sizeof(SDbInfo *));
-  if (dbInfos == NULL) {
-    errorPrint("%s() LN%d, failed to allocate memory\n", __func__, __LINE__);
-    return;
-  }
-  int dbCount = getDbFromServer(taos, dbInfos);
-  if (dbCount <= 0) {
-      free(dbInfos);
-      return;
-  }
-
-  for (int i = 0; i < dbCount; i++) {
-    // printf database info
-    printfDbInfoForQueryToFile(filename, dbInfos[i], i);
-
-    // show db.vgroups
-    snprintf(buffer, MAX_QUERY_SQL_LENGTH, "show %s.vgroups;", dbInfos[i]->name);
-    res = taos_query(taos, buffer);
+    // show variables
+    res = taos_query(taos, "show variables;");
+    //fetchResult(res, filename);
     xDumpResultToFile(filename, res);
 
-    // show db.stables
-    snprintf(buffer, MAX_QUERY_SQL_LENGTH, "show %s.stables;", dbInfos[i]->name);
-    res = taos_query(taos, buffer);
+    // show dnodes
+    res = taos_query(taos, "show dnodes;");
     xDumpResultToFile(filename, res);
+    //fetchResult(res, filename);
 
-    free(dbInfos[i]);
-  }
+    // show databases
+    res = taos_query(taos, "show databases;");
+    SDbInfo** dbInfos = (SDbInfo **)calloc(MAX_DATABASE_COUNT, sizeof(SDbInfo *));
+    if (dbInfos == NULL) {
+        errorPrint("%s() LN%d, failed to allocate memory\n", __func__, __LINE__);
+        return;
+    }
+    int dbCount = getDbFromServer(taos, dbInfos);
+    if (dbCount <= 0) {
+        free(dbInfos);
+        return;
+    }
 
-  free(dbInfos);
+    for (int i = 0; i < dbCount; i++) {
+        // printf database info
+        printfDbInfoForQueryToFile(filename, dbInfos[i], i);
+
+        // show db.vgroups
+        snprintf(buffer, MAX_QUERY_SQL_LENGTH, "show %s.vgroups;", dbInfos[i]->name);
+        res = taos_query(taos, buffer);
+        xDumpResultToFile(filename, res);
+
+        // show db.stables
+        snprintf(buffer, MAX_QUERY_SQL_LENGTH, "show %s.stables;", dbInfos[i]->name);
+        res = taos_query(taos, buffer);
+        xDumpResultToFile(filename, res);
+
+        free(dbInfos[i]);
+    }
+
+    free(dbInfos);
 }
 
 static int postProceSql(char *host, struct sockaddr_in *pServAddr, uint16_t port,
@@ -2294,98 +2335,100 @@ static int postProceSql(char *host, struct sockaddr_in *pServAddr, uint16_t port
 }
 
 static char* getTagValueFromTagSample(SSuperTable* stbInfo, int tagUsePos) {
-  char*  dataBuf = (char*)calloc(TSDB_MAX_SQL_LEN+1, 1);
-  if (NULL == dataBuf) {
-    errorPrint("%s() LN%d, calloc failed! size:%d\n",
-        __func__, __LINE__, TSDB_MAX_SQL_LEN+1);
-    return NULL;
-  }
+    char*  dataBuf = (char*)calloc(TSDB_MAX_SQL_LEN+1, 1);
+    if (NULL == dataBuf) {
+        errorPrint("%s() LN%d, calloc failed! size:%d\n",
+                __func__, __LINE__, TSDB_MAX_SQL_LEN+1);
+        return NULL;
+    }
 
-  int    dataLen = 0;
-  dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
-          "(%s)", stbInfo->tagDataBuf + stbInfo->lenOfTagOfOneRow * tagUsePos);
+    int    dataLen = 0;
+    dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
+            "(%s)", stbInfo->tagDataBuf + stbInfo->lenOfTagOfOneRow * tagUsePos);
 
-  return dataBuf;
+    return dataBuf;
 }
 
 static char* generateTagVaulesForStb(SSuperTable* stbInfo, int32_t tableSeq) {
-  char*  dataBuf = (char*)calloc(TSDB_MAX_SQL_LEN+1, 1);
-  if (NULL == dataBuf) {
-    printf("calloc failed! size:%d\n", TSDB_MAX_SQL_LEN+1);
-    return NULL;
-  }
-
-  int    dataLen = 0;
-  dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen, "(");
-  for (int i = 0; i < stbInfo->tagCount; i++) {
-    if ((0 == strncasecmp(stbInfo->tags[i].dataType, "binary", strlen("binary")))
-            || (0 == strncasecmp(stbInfo->tags[i].dataType, "nchar", strlen("nchar")))) {
-      if (stbInfo->tags[i].dataLen > TSDB_MAX_BINARY_LEN) {
-        printf("binary or nchar length overflow, max size:%u\n",
-                (uint32_t)TSDB_MAX_BINARY_LEN);
-        tmfree(dataBuf);
+    char*  dataBuf = (char*)calloc(TSDB_MAX_SQL_LEN+1, 1);
+    if (NULL == dataBuf) {
+        printf("calloc failed! size:%d\n", TSDB_MAX_SQL_LEN+1);
         return NULL;
-      }
-
-      int tagBufLen = stbInfo->tags[i].dataLen + 1;
-      char* buf = (char*)calloc(tagBufLen, 1);
-      if (NULL == buf) {
-        printf("calloc failed! size:%d\n", stbInfo->tags[i].dataLen);
-        tmfree(dataBuf);
-        return NULL;
-      }
-
-      if (tableSeq % 2) {
-        tstrncpy(buf, "beijing", tagBufLen);
-      } else {
-        tstrncpy(buf, "shanghai", tagBufLen);
-      }
-      //rand_string(buf, stbInfo->tags[i].dataLen);
-      dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
-              "\'%s\', ", buf);
-      tmfree(buf);
-    } else if (0 == strncasecmp(stbInfo->tags[i].dataType,
-                "int", strlen("int"))) {
-      dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
-              "%d, ", tableSeq);
-    } else if (0 == strncasecmp(stbInfo->tags[i].dataType,
-                "bigint", strlen("bigint"))) {
-      dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
-              "%"PRId64", ", rand_bigint());
-    }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
-                "float", strlen("float"))) {
-      dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
-              "%f, ", rand_float());
-    }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
-                "double", strlen("double"))) {
-      dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
-              "%f, ", rand_double());
-    }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
-                "smallint", strlen("smallint"))) {
-      dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
-              "%d, ", rand_smallint());
-    }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
-                "tinyint", strlen("tinyint"))) {
-      dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
-              "%d, ", rand_tinyint());
-    }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
-                "bool", strlen("bool"))) {
-      dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
-              "%d, ", rand_bool());
-    }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
-                "timestamp", strlen("timestamp"))) {
-      dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
-              "%"PRId64", ", rand_bigint());
-    }  else {
-      printf("No support data type: %s\n", stbInfo->tags[i].dataType);
-      tmfree(dataBuf);
-      return NULL;
     }
-  }
 
-  dataLen -= 2;
-  dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen, ")");
-  return dataBuf;
+    int    dataLen = 0;
+    dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen, "(");
+    for (int i = 0; i < stbInfo->tagCount; i++) {
+        if ((0 == strncasecmp(stbInfo->tags[i].dataType,
+                        "binary", strlen("binary")))
+                || (0 == strncasecmp(stbInfo->tags[i].dataType,
+                        "nchar", strlen("nchar")))) {
+            if (stbInfo->tags[i].dataLen > TSDB_MAX_BINARY_LEN) {
+                printf("binary or nchar length overflow, max size:%u\n",
+                        (uint32_t)TSDB_MAX_BINARY_LEN);
+                tmfree(dataBuf);
+                return NULL;
+            }
+
+            int tagBufLen = stbInfo->tags[i].dataLen + 1;
+            char* buf = (char*)calloc(tagBufLen, 1);
+            if (NULL == buf) {
+                printf("calloc failed! size:%d\n", stbInfo->tags[i].dataLen);
+                tmfree(dataBuf);
+                return NULL;
+            }
+
+            if (tableSeq % 2) {
+                tstrncpy(buf, "beijing", tagBufLen);
+            } else {
+                tstrncpy(buf, "shanghai", tagBufLen);
+            }
+            //rand_string(buf, stbInfo->tags[i].dataLen);
+            dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
+                    "\'%s\', ", buf);
+            tmfree(buf);
+        } else if (0 == strncasecmp(stbInfo->tags[i].dataType,
+                    "int", strlen("int"))) {
+            dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
+                    "%d, ", tableSeq);
+        } else if (0 == strncasecmp(stbInfo->tags[i].dataType,
+                    "bigint", strlen("bigint"))) {
+            dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
+                    "%"PRId64", ", rand_bigint());
+        }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
+                    "float", strlen("float"))) {
+            dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
+                    "%f, ", rand_float());
+        }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
+                    "double", strlen("double"))) {
+            dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
+                    "%f, ", rand_double());
+        }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
+                    "smallint", strlen("smallint"))) {
+            dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
+                    "%d, ", rand_smallint());
+        }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
+                    "tinyint", strlen("tinyint"))) {
+            dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
+                    "%d, ", rand_tinyint());
+        }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
+                    "bool", strlen("bool"))) {
+            dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
+                    "%d, ", rand_bool());
+        }  else if (0 == strncasecmp(stbInfo->tags[i].dataType,
+                    "timestamp", strlen("timestamp"))) {
+            dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
+                    "%"PRId64", ", rand_bigint());
+        }  else {
+            printf("No support data type: %s\n", stbInfo->tags[i].dataType);
+            tmfree(dataBuf);
+            return NULL;
+        }
+    }
+
+    dataLen -= 2;
+    dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen, ")");
+    return dataBuf;
 }
 
 static int calcRowLen(SSuperTable*  superTbls) {
@@ -2636,155 +2679,172 @@ static int createSuperTable(
         TAOS * taos, char* dbName,
         SSuperTable*  superTbl) {
 
-  char command[BUFFER_SIZE] = "\0";
+    char command[BUFFER_SIZE] = "\0";
 
-  char cols[STRING_LEN] = "\0";
-  int colIndex;
-  int len = 0;
+    char cols[STRING_LEN] = "\0";
+    int colIndex;
+    int len = 0;
 
-  int  lenOfOneRow = 0;
+    int  lenOfOneRow = 0;
 
-  if (superTbl->columnCount == 0) {
-    errorPrint("%s() LN%d, super table column count is %d\n",
-            __func__, __LINE__, superTbl->columnCount);
-    return -1;
-  }
-
-  for (colIndex = 0; colIndex < superTbl->columnCount; colIndex++) {
-    char* dataType = superTbl->columns[colIndex].dataType;
-
-    if (strcasecmp(dataType, "BINARY") == 0) {
-      len += snprintf(cols + len, STRING_LEN - len,
-          ", col%d %s(%d)", colIndex, "BINARY",
-          superTbl->columns[colIndex].dataLen);
-      lenOfOneRow += superTbl->columns[colIndex].dataLen + 3;
-    } else if (strcasecmp(dataType, "NCHAR") == 0) {
-      len += snprintf(cols + len, STRING_LEN - len,
-          ", col%d %s(%d)", colIndex, "NCHAR",
-          superTbl->columns[colIndex].dataLen);
-      lenOfOneRow += superTbl->columns[colIndex].dataLen + 3;
-    } else if (strcasecmp(dataType, "INT") == 0)  {
-      len += snprintf(cols + len, STRING_LEN - len, ", col%d %s", colIndex, "INT");
-      lenOfOneRow += 11;
-    } else if (strcasecmp(dataType, "BIGINT") == 0)  {
-      len += snprintf(cols + len, STRING_LEN - len, ", col%d %s", colIndex, "BIGINT");
-      lenOfOneRow += 21;
-    } else if (strcasecmp(dataType, "SMALLINT") == 0)  {
-      len += snprintf(cols + len, STRING_LEN - len, ", col%d %s", colIndex, "SMALLINT");
-      lenOfOneRow += 6;
-    } else if (strcasecmp(dataType, "TINYINT") == 0)  {
-      len += snprintf(cols + len, STRING_LEN - len, ", col%d %s", colIndex, "TINYINT");
-      lenOfOneRow += 4;
-    } else if (strcasecmp(dataType, "BOOL") == 0)  {
-      len += snprintf(cols + len, STRING_LEN - len, ", col%d %s", colIndex, "BOOL");
-      lenOfOneRow += 6;
-    } else if (strcasecmp(dataType, "FLOAT") == 0) {
-      len += snprintf(cols + len, STRING_LEN - len, ", col%d %s", colIndex, "FLOAT");
-      lenOfOneRow += 22;
-    } else if (strcasecmp(dataType, "DOUBLE") == 0) {
-      len += snprintf(cols + len, STRING_LEN - len, ", col%d %s", colIndex, "DOUBLE");
-      lenOfOneRow += 42;
-    }  else if (strcasecmp(dataType, "TIMESTAMP") == 0) {
-      len += snprintf(cols + len, STRING_LEN - len, ", col%d %s", colIndex, "TIMESTAMP");
-      lenOfOneRow += 21;
-    } else {
-      taos_close(taos);
-      errorPrint("%s() LN%d, config error data type : %s\n",
-         __func__, __LINE__, dataType);
-      exit(-1);
+    if (superTbl->columnCount == 0) {
+        errorPrint("%s() LN%d, super table column count is %d\n",
+                __func__, __LINE__, superTbl->columnCount);
+        return -1;
     }
-  }
 
-  superTbl->lenOfOneRow = lenOfOneRow + 20; // timestamp
-  //printf("%s.%s column count:%d, column length:%d\n\n", g_Dbs.db[i].dbName, g_Dbs.db[i].superTbl[j].sTblName, g_Dbs.db[i].superTbl[j].columnCount, lenOfOneRow);
+    for (colIndex = 0; colIndex < superTbl->columnCount; colIndex++) {
+        char* dataType = superTbl->columns[colIndex].dataType;
 
-  // save for creating child table
-  superTbl->colsOfCreateChildTable = (char*)calloc(len+20, 1);
-  if (NULL == superTbl->colsOfCreateChildTable) {
-    errorPrint("%s() LN%d, Failed when calloc, size:%d",
-           __func__, __LINE__, len+1);
-    taos_close(taos);
-    exit(-1);
-  }
+        if (strcasecmp(dataType, "BINARY") == 0) {
+            len += snprintf(cols + len, STRING_LEN - len,
+                    ", col%d %s(%d)", colIndex, "BINARY",
+                    superTbl->columns[colIndex].dataLen);
+            lenOfOneRow += superTbl->columns[colIndex].dataLen + 3;
+        } else if (strcasecmp(dataType, "NCHAR") == 0) {
+            len += snprintf(cols + len, STRING_LEN - len,
+                    ", col%d %s(%d)", colIndex, "NCHAR",
+                    superTbl->columns[colIndex].dataLen);
+            lenOfOneRow += superTbl->columns[colIndex].dataLen + 3;
+        } else if (strcasecmp(dataType, "INT") == 0)  {
+            if ((g_args.demo_mode) && (colIndex == 1)) {
+                    len += snprintf(cols + len, STRING_LEN - len,
+                            ", VOLTAGE INT");
+            } else {
+                len += snprintf(cols + len, STRING_LEN - len, ", col%d %s", colIndex, "INT");
+            }
+            lenOfOneRow += 11;
+        } else if (strcasecmp(dataType, "BIGINT") == 0)  {
+            len += snprintf(cols + len, STRING_LEN - len, ", col%d %s",
+                    colIndex, "BIGINT");
+            lenOfOneRow += 21;
+        } else if (strcasecmp(dataType, "SMALLINT") == 0)  {
+            len += snprintf(cols + len, STRING_LEN - len, ", col%d %s",
+                    colIndex, "SMALLINT");
+            lenOfOneRow += 6;
+        } else if (strcasecmp(dataType, "TINYINT") == 0)  {
+            len += snprintf(cols + len, STRING_LEN - len, ", col%d %s", colIndex, "TINYINT");
+            lenOfOneRow += 4;
+        } else if (strcasecmp(dataType, "BOOL") == 0)  {
+            len += snprintf(cols + len, STRING_LEN - len, ", col%d %s", colIndex, "BOOL");
+            lenOfOneRow += 6;
+        } else if (strcasecmp(dataType, "FLOAT") == 0) {
+            if (g_args.demo_mode) {
+                if (colIndex == 0) {
+                    len += snprintf(cols + len, STRING_LEN - len, ", CURRENT FLOAT");
+                } else if (colIndex == 2) {
+                    len += snprintf(cols + len, STRING_LEN - len, ", PHASE FLOAT");
+                }
+            } else {
+                len += snprintf(cols + len, STRING_LEN - len, ", col%d %s", colIndex, "FLOAT");
+            }
 
-  snprintf(superTbl->colsOfCreateChildTable, len+20, "(ts timestamp%s)", cols);
-  verbosePrint("%s() LN%d: %s\n",
-      __func__, __LINE__, superTbl->colsOfCreateChildTable);
-
-  if (superTbl->tagCount == 0) {
-    errorPrint("%s() LN%d, super table tag count is %d\n",
-            __func__, __LINE__, superTbl->tagCount);
-    return -1;
-  }
-
-  char tags[STRING_LEN] = "\0";
-  int tagIndex;
-  len = 0;
-
-  int lenOfTagOfOneRow = 0;
-  len += snprintf(tags + len, STRING_LEN - len, "(");
-  for (tagIndex = 0; tagIndex < superTbl->tagCount; tagIndex++) {
-    char* dataType = superTbl->tags[tagIndex].dataType;
-
-    if (strcasecmp(dataType, "BINARY") == 0) {
-      len += snprintf(tags + len, STRING_LEN - len, "t%d %s(%d), ", tagIndex,
-              "BINARY", superTbl->tags[tagIndex].dataLen);
-      lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 3;
-    } else if (strcasecmp(dataType, "NCHAR") == 0) {
-      len += snprintf(tags + len, STRING_LEN - len, "t%d %s(%d), ", tagIndex,
-              "NCHAR", superTbl->tags[tagIndex].dataLen);
-      lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 3;
-    } else if (strcasecmp(dataType, "INT") == 0)  {
-      len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
-              "INT");
-      lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 11;
-    } else if (strcasecmp(dataType, "BIGINT") == 0)  {
-      len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
-              "BIGINT");
-      lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 21;
-    } else if (strcasecmp(dataType, "SMALLINT") == 0)  {
-      len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
-              "SMALLINT");
-      lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 6;
-    } else if (strcasecmp(dataType, "TINYINT") == 0)  {
-      len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
-              "TINYINT");
-      lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 4;
-    } else if (strcasecmp(dataType, "BOOL") == 0)  {
-      len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
-              "BOOL");
-      lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 6;
-    } else if (strcasecmp(dataType, "FLOAT") == 0) {
-      len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
-              "FLOAT");
-      lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 22;
-    } else if (strcasecmp(dataType, "DOUBLE") == 0) {
-      len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
-              "DOUBLE");
-      lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 42;
-    } else {
-      taos_close(taos);
-      errorPrint("%s() LN%d, config error tag type : %s\n",
-         __func__, __LINE__, dataType);
-      exit(-1);
+            lenOfOneRow += 22;
+        } else if (strcasecmp(dataType, "DOUBLE") == 0) {
+            len += snprintf(cols + len, STRING_LEN - len, ", col%d %s",
+                    colIndex, "DOUBLE");
+            lenOfOneRow += 42;
+        }  else if (strcasecmp(dataType, "TIMESTAMP") == 0) {
+            len += snprintf(cols + len, STRING_LEN - len, ", col%d %s",
+                    colIndex, "TIMESTAMP");
+            lenOfOneRow += 21;
+        } else {
+            taos_close(taos);
+            errorPrint("%s() LN%d, config error data type : %s\n",
+                    __func__, __LINE__, dataType);
+            exit(-1);
+        }
     }
-  }
 
-  len -= 2;
-  len += snprintf(tags + len, STRING_LEN - len, ")");
+    superTbl->lenOfOneRow = lenOfOneRow + 20; // timestamp
 
-  superTbl->lenOfTagOfOneRow = lenOfTagOfOneRow;
+    // save for creating child table
+    superTbl->colsOfCreateChildTable = (char*)calloc(len+20, 1);
+    if (NULL == superTbl->colsOfCreateChildTable) {
+        errorPrint("%s() LN%d, Failed when calloc, size:%d",
+                __func__, __LINE__, len+1);
+        taos_close(taos);
+        exit(-1);
+    }
 
-  snprintf(command, BUFFER_SIZE,
-          "create table if not exists %s.%s (ts timestamp%s) tags %s",
-          dbName, superTbl->sTblName, cols, tags);
-  if (0 != queryDbExec(taos, command, NO_INSERT_TYPE, false)) {
-      errorPrint( "create supertable %s failed!\n\n",
-              superTbl->sTblName);
-      return -1;
-  }
-  debugPrint("create supertable %s success!\n\n", superTbl->sTblName);
-  return 0;
+    snprintf(superTbl->colsOfCreateChildTable, len+20, "(ts timestamp%s)", cols);
+    verbosePrint("%s() LN%d: %s\n",
+            __func__, __LINE__, superTbl->colsOfCreateChildTable);
+
+    if (superTbl->tagCount == 0) {
+        errorPrint("%s() LN%d, super table tag count is %d\n",
+                __func__, __LINE__, superTbl->tagCount);
+        return -1;
+    }
+
+    char tags[STRING_LEN] = "\0";
+    int tagIndex;
+    len = 0;
+
+    int lenOfTagOfOneRow = 0;
+    len += snprintf(tags + len, STRING_LEN - len, "(");
+    for (tagIndex = 0; tagIndex < superTbl->tagCount; tagIndex++) {
+        char* dataType = superTbl->tags[tagIndex].dataType;
+
+        if (strcasecmp(dataType, "BINARY") == 0) {
+            len += snprintf(tags + len, STRING_LEN - len, "t%d %s(%d), ", tagIndex,
+                    "BINARY", superTbl->tags[tagIndex].dataLen);
+            lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 3;
+        } else if (strcasecmp(dataType, "NCHAR") == 0) {
+            len += snprintf(tags + len, STRING_LEN - len, "t%d %s(%d), ", tagIndex,
+                    "NCHAR", superTbl->tags[tagIndex].dataLen);
+            lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 3;
+        } else if (strcasecmp(dataType, "INT") == 0)  {
+            len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
+                    "INT");
+            lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 11;
+        } else if (strcasecmp(dataType, "BIGINT") == 0)  {
+            len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
+                    "BIGINT");
+            lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 21;
+        } else if (strcasecmp(dataType, "SMALLINT") == 0)  {
+            len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
+                    "SMALLINT");
+            lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 6;
+        } else if (strcasecmp(dataType, "TINYINT") == 0)  {
+            len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
+                    "TINYINT");
+            lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 4;
+        } else if (strcasecmp(dataType, "BOOL") == 0)  {
+            len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
+                    "BOOL");
+            lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 6;
+        } else if (strcasecmp(dataType, "FLOAT") == 0) {
+            len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
+                    "FLOAT");
+            lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 22;
+        } else if (strcasecmp(dataType, "DOUBLE") == 0) {
+            len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
+                    "DOUBLE");
+            lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 42;
+        } else {
+            taos_close(taos);
+            errorPrint("%s() LN%d, config error tag type : %s\n",
+                    __func__, __LINE__, dataType);
+            exit(-1);
+        }
+    }
+
+    len -= 2;
+    len += snprintf(tags + len, STRING_LEN - len, ")");
+
+    superTbl->lenOfTagOfOneRow = lenOfTagOfOneRow;
+
+    snprintf(command, BUFFER_SIZE,
+            "create table if not exists %s.%s (ts timestamp%s) tags %s",
+            dbName, superTbl->sTblName, cols, tags);
+    if (0 != queryDbExec(taos, command, NO_INSERT_TYPE, false)) {
+        errorPrint( "create supertable %s failed!\n\n",
+                superTbl->sTblName);
+        return -1;
+    }
+    debugPrint("create supertable %s success!\n\n", superTbl->sTblName);
+    return 0;
 }
 
 static int createDatabasesAndStables() {
@@ -4746,106 +4806,124 @@ static void postFreeResource() {
 
 static int getRowDataFromSample(
         char* dataBuf, int64_t maxLen, int64_t timestamp,
-      SSuperTable* superTblInfo, int64_t* sampleUsePos) {
-  if ((*sampleUsePos) == MAX_SAMPLES_ONCE_FROM_FILE) {
-/*    int ret = readSampleFromCsvFileToMem(superTblInfo);
-    if (0 != ret) {
-      tmfree(superTblInfo->sampleDataBuf);
-      superTblInfo->sampleDataBuf = NULL;
-      return -1;
+      SSuperTable* superTblInfo, int64_t* sampleUsePos)
+{
+    if ((*sampleUsePos) == MAX_SAMPLES_ONCE_FROM_FILE) {
+        /*    int ret = readSampleFromCsvFileToMem(superTblInfo);
+              if (0 != ret) {
+              tmfree(superTblInfo->sampleDataBuf);
+              superTblInfo->sampleDataBuf = NULL;
+              return -1;
+              }
+              */
+        *sampleUsePos = 0;
     }
-*/
-    *sampleUsePos = 0;
-  }
 
-  int    dataLen = 0;
+    int    dataLen = 0;
 
-  dataLen += snprintf(dataBuf + dataLen, maxLen - dataLen,
-          "(%" PRId64 ", ", timestamp);
-  dataLen += snprintf(dataBuf + dataLen, maxLen - dataLen,
-          "%s", superTblInfo->sampleDataBuf + superTblInfo->lenOfOneRow * (*sampleUsePos));
-  dataLen += snprintf(dataBuf + dataLen, maxLen - dataLen, ")");
+    dataLen += snprintf(dataBuf + dataLen, maxLen - dataLen,
+            "(%" PRId64 ", ", timestamp);
+    dataLen += snprintf(dataBuf + dataLen, maxLen - dataLen,
+            "%s",
+            superTblInfo->sampleDataBuf
+            + superTblInfo->lenOfOneRow * (*sampleUsePos));
+    dataLen += snprintf(dataBuf + dataLen, maxLen - dataLen, ")");
 
-  (*sampleUsePos)++;
+    (*sampleUsePos)++;
 
-  return dataLen;
+    return dataLen;
 }
 
 static int64_t generateStbRowData(
         SSuperTable* stbInfo,
         char* recBuf, int64_t timestamp)
 {
-  int64_t   dataLen = 0;
-  char  *pstr = recBuf;
-  int64_t maxLen = MAX_DATA_SIZE;
+    int64_t   dataLen = 0;
+    char  *pstr = recBuf;
+    int64_t maxLen = MAX_DATA_SIZE;
 
-  dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
-          "(%" PRId64 ",", timestamp);
+    dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
+            "(%" PRId64 ",", timestamp);
 
-  for (int i = 0; i < stbInfo->columnCount; i++) {
-    if ((0 == strncasecmp(stbInfo->columns[i].dataType,
-                    "BINARY", strlen("BINARY")))
-            || (0 == strncasecmp(stbInfo->columns[i].dataType,
-                    "NCHAR", strlen("NCHAR")))) {
-      if (stbInfo->columns[i].dataLen > TSDB_MAX_BINARY_LEN) {
-        errorPrint( "binary or nchar length overflow, max size:%u\n",
-                (uint32_t)TSDB_MAX_BINARY_LEN);
-        return -1;
-      }
+    for (int i = 0; i < stbInfo->columnCount; i++) {
+        if ((0 == strncasecmp(stbInfo->columns[i].dataType,
+                        "BINARY", strlen("BINARY")))
+                || (0 == strncasecmp(stbInfo->columns[i].dataType,
+                        "NCHAR", strlen("NCHAR")))) {
+            if (stbInfo->columns[i].dataLen > TSDB_MAX_BINARY_LEN) {
+                errorPrint( "binary or nchar length overflow, max size:%u\n",
+                        (uint32_t)TSDB_MAX_BINARY_LEN);
+                return -1;
+            }
 
-      char* buf = (char*)calloc(stbInfo->columns[i].dataLen+1, 1);
-      if (NULL == buf) {
-        errorPrint( "calloc failed! size:%d\n", stbInfo->columns[i].dataLen);
-        return -1;
-      }
-      rand_string(buf, stbInfo->columns[i].dataLen);
-      dataLen += snprintf(pstr + dataLen, maxLen - dataLen, "\'%s\',", buf);
-      tmfree(buf);
-    } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-                "INT", strlen("INT"))) {
-      dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
-              "%d,", rand_int());
-    } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-                "BIGINT", strlen("BIGINT"))) {
-      dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
-              "%"PRId64",", rand_bigint());
-    }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-                "FLOAT", strlen("FLOAT"))) {
-      dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
-              "%f,", rand_float());
-    }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-                "DOUBLE", strlen("DOUBLE"))) {
-      dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
-              "%f,", rand_double());
-    }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-                "SMALLINT", strlen("SMALLINT"))) {
-      dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
-          "%d,", rand_smallint());
-    }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-          "TINYINT", strlen("TINYINT"))) {
-      dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
-          "%d,", rand_tinyint());
-    }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-          "BOOL", strlen("BOOL"))) {
-      dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
-          "%d,", rand_bool());
-    }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-          "TIMESTAMP", strlen("TIMESTAMP"))) {
-      dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
-          "%"PRId64",", rand_bigint());
-    }  else {
-      errorPrint( "Not support data type: %s\n", stbInfo->columns[i].dataType);
-      return -1;
+            char* buf = (char*)calloc(stbInfo->columns[i].dataLen+1, 1);
+            if (NULL == buf) {
+                errorPrint( "calloc failed! size:%d\n", stbInfo->columns[i].dataLen);
+                return -1;
+            }
+            rand_string(buf, stbInfo->columns[i].dataLen);
+            dataLen += snprintf(pstr + dataLen, maxLen - dataLen, "\'%s\',", buf);
+            tmfree(buf);
+        } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
+                    "INT", strlen("INT"))) {
+            if ((g_args.demo_mode) && (i == 1)) {
+                dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
+                        "%d,", demo_voltage_int());
+            } else {
+                dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
+                        "%d,", rand_int());
+            }
+        } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
+                    "BIGINT", strlen("BIGINT"))) {
+            dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
+                    "%"PRId64",", rand_bigint());
+        }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
+                    "FLOAT", strlen("FLOAT"))) {
+            if (g_args.demo_mode) {
+                if (i == 0) {
+                    dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
+                            "%f,", demo_current_float());
+                } else {
+                    dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
+                            "%f,", demo_phase_float());
+                }
+            } else {
+                dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
+                        "%f,", rand_float());
+            }
+        }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
+                    "DOUBLE", strlen("DOUBLE"))) {
+            dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
+                    "%f,", rand_double());
+        }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
+                    "SMALLINT", strlen("SMALLINT"))) {
+            dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
+                    "%d,", rand_smallint());
+        }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
+                    "TINYINT", strlen("TINYINT"))) {
+            dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
+                    "%d,", rand_tinyint());
+        }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
+                    "BOOL", strlen("BOOL"))) {
+            dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
+                    "%d,", rand_bool());
+        }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
+                    "TIMESTAMP", strlen("TIMESTAMP"))) {
+            dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
+                    "%"PRId64",", rand_bigint());
+        }  else {
+            errorPrint( "Not support data type: %s\n", stbInfo->columns[i].dataType);
+            return -1;
+        }
     }
-  }
 
-  dataLen -= 1;
-  dataLen += snprintf(pstr + dataLen, maxLen - dataLen, ")");
+    dataLen -= 1;
+    dataLen += snprintf(pstr + dataLen, maxLen - dataLen, ")");
 
-  verbosePrint("%s() LN%d, dataLen:%"PRId64"\n", __func__, __LINE__, dataLen);
-  verbosePrint("%s() LN%d, recBuf:\n\t%s\n", __func__, __LINE__, recBuf);
+    verbosePrint("%s() LN%d, dataLen:%"PRId64"\n", __func__, __LINE__, dataLen);
+    verbosePrint("%s() LN%d, recBuf:\n\t%s\n", __func__, __LINE__, recBuf);
 
-  return strlen(recBuf);
+    return strlen(recBuf);
 }
 
 static int64_t generateData(char *recBuf, char **data_type,
diff --git a/tests/pytest/tools/taosdemoTest.py b/tests/pytest/tools/taosdemoTest.py
index fec69bed64..4cae8dfd3c 100644
--- a/tests/pytest/tools/taosdemoTest.py
+++ b/tests/pytest/tools/taosdemoTest.py
@@ -51,7 +51,7 @@ class TDTestCase:
         else:
             tdLog.info("taosdemo found in %s" % buildPath)
         binPath = buildPath + "/build/bin/"
-        os.system("%staosdemo -y -t %d -n %d" %
+        os.system("%staosdemo -y -t %d -n %d -b INT,INT,INT,INT" %
                   (binPath, self.numberOfTables, self.numberOfRecords))
 
         tdSql.execute("use test")
diff --git a/tests/pytest/tools/taosdemoTestTblAlt.py b/tests/pytest/tools/taosdemoTestTblAlt.py
index 9aa131624e..56c535916a 100644
--- a/tests/pytest/tools/taosdemoTestTblAlt.py
+++ b/tests/pytest/tools/taosdemoTestTblAlt.py
@@ -54,7 +54,7 @@ class TDTestCase:
         binPath = buildPath + "/build/bin/"
 
         if(threadID == 0):
-            os.system("%staosdemo -y -t %d -n %d" %
+            os.system("%staosdemo -y -t %d -n %d -b INT,INT,INT,INT -m t" %
                       (binPath, self.numberOfTables, self.numberOfRecords))
         if(threadID == 1):
             time.sleep(2)
diff --git a/tests/pytest/tools/taosdemoTestWithoutMetric.py b/tests/pytest/tools/taosdemoTestWithoutMetric.py
index 9687600563..01e19355d9 100644
--- a/tests/pytest/tools/taosdemoTestWithoutMetric.py
+++ b/tests/pytest/tools/taosdemoTestWithoutMetric.py
@@ -60,7 +60,7 @@ class TDTestCase:
 
         tdSql.execute("use test")
         tdSql.query(
-            "select count(*) from test.t%d" % (self.numberOfTables -1))
+            "select count(*) from test.d%d" % (self.numberOfTables -1))
         tdSql.checkData(0, 0, self.numberOfRecords)
 
     def stop(self):

From aee50c892962fbd750591e81ecc9280e9fdc9c4d Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Mon, 12 Jul 2021 18:09:50 +0800
Subject: [PATCH 40/70] add unit test

---
 src/client/src/tscParseLineProtocol.c | 46 ++++++++++++++-----------
 tests/examples/c/apitest.c            | 18 ++++++++--
 tests/tsim/inc/sim.h                  |  4 +++
 tests/tsim/src/simExe.c               | 46 +++++++++++++++++++++++++
 tests/tsim/src/simParse.c             | 48 +++++++++++++++++++++++++++
 5 files changed, 139 insertions(+), 23 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index 61f9cd9e76..77d65f3d15 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -65,6 +65,11 @@ int compareSmlColKv(const void* p1, const void* p2) {
 }
 
 int32_t loadTableMeta(TAOS* taos, char* tableName, SSmlSTableSchema* schema) {
+  schema->tags = taosArrayInit(8, sizeof(SSchema));
+  schema->fields = taosArrayInit(64, sizeof(SSchema));
+  schema->tagHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+  schema->fieldHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+
   int32_t code = 0;
 
   STscObj *pObj = (STscObj *)taos;
@@ -203,7 +208,7 @@ int32_t addTaosFieldToHashAndArray(TAOS_SML_KV* smlKv, SHashObj* hash, SArray* a
     pField->bytes = MAX(pField->bytes, bytes);
 
   } else {
-    SSchema field;
+    SSchema field = {0};
     size_t tagKeyLen = strlen(smlKv->key);
     strncpy(field.name, smlKv->key, tagKeyLen);
     field.name[tagKeyLen] = '\0';
@@ -371,7 +376,7 @@ int32_t getChildTableName(TAOS_SML_DATA_POINT* point, char* tableName, int* tabl
   MD5Update(&context, (uint8_t *)keyJoined, (uint32_t)len);
   MD5Final(&context);
   *tableNameLen = snprintf(tableName, *tableNameLen,
-                           "tbl%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", context.digest[0],
+                           "tbl_%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", context.digest[0],
                            context.digest[1], context.digest[2], context.digest[3], context.digest[4], context.digest[5], context.digest[6],
                            context.digest[7], context.digest[8], context.digest[9], context.digest[10], context.digest[11],
                            context.digest[12], context.digest[13], context.digest[14], context.digest[15]);
@@ -418,14 +423,15 @@ int32_t creatChildTableIfNotExists(TAOS* taos, const char* cTableName, const cha
     printf("%s", taos_stmt_errstr(stmt));
     return code;
   }
-  TAOS_RES* res = taos_stmt_use_result(stmt);
-  return taos_errno(res);
+
+  taos_stmt_close(stmt);
+  return 0;
 }
 
 int32_t insertBatch(TAOS* taos,  char* cTableName, SArray* colsSchema, SArray* rowsBind) {
   size_t numCols = taosArrayGetSize(colsSchema);
-  char sql[TSDB_MAX_BINARY_LEN];
-  int32_t freeBytes = TSDB_MAX_BINARY_LEN;
+  char sql[4096];
+  int32_t freeBytes = 4096;
   sprintf(sql, "insert into ? (");
 
   for (int i = 0; i < numCols; ++i) {
@@ -454,8 +460,8 @@ int32_t insertBatch(TAOS* taos,  char* cTableName, SArray* colsSchema, SArray* r
   }
   size_t rows = taosArrayGetSize(rowsBind);
   for (int32_t i = 0; i < rows; ++i) {
-    SArray* colBind = taosArrayGetP(rowsBind, i);
-    code = taos_stmt_bind_param(stmt, TARRAY_GET_START(colBind));
+    TAOS_BIND* colsBinds = taosArrayGetP(rowsBind, i);
+    code = taos_stmt_bind_param(stmt, colsBinds);
     if (code != 0) {
       printf("%s", taos_stmt_errstr(stmt));
       return code;
@@ -472,8 +478,10 @@ int32_t insertBatch(TAOS* taos,  char* cTableName, SArray* colsSchema, SArray* r
     printf("%s", taos_stmt_errstr(stmt));
     return code;
   }
-  TAOS_RES* res = taos_stmt_use_result(stmt);
-  return taos_errno(res);
+
+
+  taos_stmt_close(stmt);
+  return code;
 }
 
 int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints) {
@@ -526,7 +534,6 @@ int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints)
     TAOS_SML_DATA_POINT * point = taosArrayGetP(cTablePoints, 0);
     int32_t numTags = taosArrayGetSize(point->schema->tags);
     int32_t numCols = taosArrayGetSize(point->schema->fields);
-    char* ctableName = point->childTableName;
 
     SArray* tagBinds = taosArrayInit(numTags, sizeof(TAOS_BIND));
     taosArraySetSize(tagBinds, numTags);
@@ -551,16 +558,15 @@ int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints)
     for (int i = 0; i < rows; ++i) {
       point = taosArrayGetP(cTablePoints, i);
 
-      SArray* colBinds = taosArrayInit(numCols, sizeof(TAOS_BIND));
-      taosArraySetSize(colBinds, numCols);
+      TAOS_BIND* colBinds = calloc(numCols, sizeof(TAOS_BIND));
       for (int j = 0; j < numCols; ++j) {
-        TAOS_BIND* bind = taosArrayGet(colBinds, j);
+        TAOS_BIND* bind = colBinds + j;
         bind->is_null = &isNullColBind;
       }
       for (int j = 0; j < point->fieldNum; ++j) {
         TAOS_SML_KV* kv = point->fields + j;
         int32_t idx = TARRAY_ELEM_IDX(point->schema->fields, kv->schema);
-        TAOS_BIND* bind = taosArrayGet(colBinds, idx);
+        TAOS_BIND* bind = colBinds + idx;
         bind->buffer_type = kv->type;
         bind->length = malloc(sizeof(uintptr_t*));
         *bind->length = kv->length;
@@ -571,7 +577,7 @@ int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints)
     }
 
     creatChildTableIfNotExists(taos, point->childTableName, point->stableName, point->schema->tags, tagBinds);
-    insertBatch(taos, ctableName, point->schema->fields, rowsBind);
+    insertBatch(taos, point->childTableName, point->schema->fields, rowsBind);
 
     pCTablePoints = taosHashIterate(cname2points, pCTablePoints);
   }
@@ -621,10 +627,6 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
   for (int i = 0; i < numStable; ++i) {
     SSmlSTableSchema* pointSchema = taosArrayGet(stableArray, i);
     SSmlSTableSchema  dbSchema = {0};
-    dbSchema.tags = taosArrayInit(8, sizeof(SSchema));
-    dbSchema.fields = taosArrayInit(64, sizeof(SSchema));
-    dbSchema.tagHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
-    dbSchema.fieldHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
 
     code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
 
@@ -652,6 +654,8 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
         generateSchemaAction(pointTag, dbTagHash, true, pointSchema->sTableName, &schemaAction, &actionNeeded);
         if (actionNeeded) {
           applySchemaAction(taos, &schemaAction);
+          code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
+          pointSchema->precision = dbSchema.precision;
         }
       }
 
@@ -666,6 +670,8 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
         generateSchemaAction(pointCol, dbFieldHash, false, pointSchema->sTableName, &schemaAction, &actionNeeded);
         if (actionNeeded) {
           applySchemaAction(taos, &schemaAction);
+          code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
+          pointSchema->precision = dbSchema.precision;
         }
       }
 
diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index 409140e0f2..75262d74d8 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -965,12 +965,24 @@ int32_t verify_schema_less(TAOS* taos) {
 
   char* lines[] = {
       "st,t1=3i,t2=4,t3=\"t3\" c1=3i,c3=L\"passit\",c2=false,c4=4 1626006833639000000",
-      "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833640000000",
+      "st,t1=4i,t3=\"t4\",t2=5,t4=5 c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833640000000",
       "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833642000000",
       "ste,t2=5,t3=L\"ste\" c1=true,c2=4,c3=\"iam\" 1626056811823316532",
       "ste,t2=5,t3=L\"ste2\" c3=\"iamszhou\",c4=false 1626056811843316532"
   };
-  int code = taos_insert_by_lines(taos, lines , 5);
+
+//  int code = taos_insert_by_lines(taos, lines , 5);
+  int code = taos_insert_by_lines(taos, &(lines[0]), 1);
+
+  code = taos_insert_by_lines(taos, &(lines[1]), 1);
+
+//  code = taos_insert_by_lines(taos, &(lines[2]), 1);
+//
+//  code = taos_insert_by_lines(taos, &(lines[3]), 1);
+//
+//  code = taos_insert_by_lines(taos, &(lines[4]), 1);
+
+
   return code;
 }
 
@@ -980,7 +992,7 @@ int main(int argc, char *argv[]) {
   const char* passwd = "taosdata";
 
   taos_options(TSDB_OPTION_TIMEZONE, "GMT-8");
-
+  taos_options(TSDB_OPTION_CONFIGDIR, "/etc/taos");
   TAOS* taos = taos_connect(host, user, passwd, "", 0);
   if (taos == NULL) {
     printf("\033[31mfailed to connect to db, reason:%s\033[0m\n", taos_errstr(taos));
diff --git a/tests/tsim/inc/sim.h b/tests/tsim/inc/sim.h
index 58314d2e50..2e19dde3d9 100644
--- a/tests/tsim/inc/sim.h
+++ b/tests/tsim/inc/sim.h
@@ -87,6 +87,8 @@ enum {
   SIM_CMD_RESTFUL,
   SIM_CMD_TEST,
   SIM_CMD_RETURN,
+  SIM_CMD_LINE_INSERT,
+  SIM_CMD_LINE_INSERT_ERROR,
   SIM_CMD_END
 };
 
@@ -172,6 +174,8 @@ bool     simExecuteSqlCmd(SScript *script, char *option);
 bool     simExecuteSqlErrorCmd(SScript *script, char *rest);
 bool     simExecuteSqlSlowCmd(SScript *script, char *option);
 bool     simExecuteRestfulCmd(SScript *script, char *rest);
+bool     simExecuteLineInsertCmd(SScript *script, char *option);
+bool     simExecuteLineInsertErrorCmd(SScript *script, char *option);
 void     simVisuallizeOption(SScript *script, char *src, char *dst);
 
 #endif
\ No newline at end of file
diff --git a/tests/tsim/src/simExe.c b/tests/tsim/src/simExe.c
index 7d74946e93..2615448e4b 100644
--- a/tests/tsim/src/simExe.c
+++ b/tests/tsim/src/simExe.c
@@ -1067,3 +1067,49 @@ bool simExecuteSqlErrorCmd(SScript *script, char *rest) {
 
   return false;
 }
+
+bool simExecuteLineInsertCmd(SScript *script, char *rest) {
+  char buf[TSDB_MAX_BINARY_LEN];
+
+  simVisuallizeOption(script, rest, buf);
+  rest = buf;
+
+  SCmdLine *line = &script->lines[script->linePos];
+
+  simInfo("script:%s, %s", script->fileName, rest);
+  simLogSql(buf, true);
+  char *  lines[] = {rest};
+  int32_t ret = taos_insert_by_lines(script->taos, lines, 1);
+  if (ret == TSDB_CODE_SUCCESS) {
+    simDebug("script:%s, taos:%p, %s executed. success.", script->fileName, script->taos, rest);
+    script->linePos++;
+    return true;
+  } else {
+    sprintf(script->error, "lineNum: %d. line: %s failed, ret:%d:%s", line->lineNum, rest,
+            ret & 0XFFFF, tstrerror(ret));
+    return false;
+  }
+}
+
+bool simExecuteLineInsertErrorCmd(SScript *script, char *rest) {
+  char buf[TSDB_MAX_BINARY_LEN];
+
+  simVisuallizeOption(script, rest, buf);
+  rest = buf;
+
+  SCmdLine *line = &script->lines[script->linePos];
+
+  simInfo("script:%s, %s", script->fileName, rest);
+  simLogSql(buf, true);
+  char *  lines[] = {rest};
+  int32_t ret = taos_insert_by_lines(script->taos, lines, 1);
+  if (ret == TSDB_CODE_SUCCESS) {
+    sprintf(script->error, "script:%s, taos:%p, %s executed. expect failed, but success.", script->fileName, script->taos, rest);
+    script->linePos++;
+    return false;
+  } else {
+    simDebug("lineNum: %d. line: %s failed, ret:%d:%s. Expect failed, so success", line->lineNum, rest,
+            ret & 0XFFFF, tstrerror(ret));
+    return true;
+  }
+}
diff --git a/tests/tsim/src/simParse.c b/tests/tsim/src/simParse.c
index b909f5bd8f..1acdcd2ac6 100644
--- a/tests/tsim/src/simParse.c
+++ b/tests/tsim/src/simParse.c
@@ -838,6 +838,38 @@ bool simParseRunBackCmd(char *rest, SCommand *pCmd, int32_t lineNum) {
   return true;
 }
 
+bool simParseLineInsertCmd(char* rest, SCommand* pCmd, int32_t lineNum) {
+  int32_t expLen;
+
+  rest++;
+  cmdLine[numOfLines].cmdno = SIM_CMD_LINE_INSERT;
+  cmdLine[numOfLines].lineNum = lineNum;
+  cmdLine[numOfLines].optionOffset = optionOffset;
+  expLen = (int32_t)strlen(rest);
+  memcpy(optionBuffer + optionOffset, rest, expLen);
+  optionOffset += expLen + 1;
+  *(optionBuffer + optionOffset - 1) = 0;
+
+  numOfLines++;
+  return true;
+}
+
+bool simParseLineInsertErrorCmd(char* rest, SCommand* pCmd, int32_t lineNum) {
+  int32_t expLen;
+
+  rest++;
+  cmdLine[numOfLines].cmdno = SIM_CMD_LINE_INSERT;
+  cmdLine[numOfLines].lineNum = lineNum;
+  cmdLine[numOfLines].optionOffset = optionOffset;
+  expLen = (int32_t)strlen(rest);
+  memcpy(optionBuffer + optionOffset, rest, expLen);
+  optionOffset += expLen + 1;
+  *(optionBuffer + optionOffset - 1) = 0;
+
+  numOfLines++;
+  return true;
+}
+
 void simInitsimCmdList() {
   int32_t cmdno;
   memset(simCmdList, 0, SIM_CMD_END * sizeof(SCommand));
@@ -1049,4 +1081,20 @@ void simInitsimCmdList() {
   simCmdList[cmdno].parseCmd = simParseReturnCmd;
   simCmdList[cmdno].executeCmd = simExecuteReturnCmd;
   simAddCmdIntoHash(&(simCmdList[cmdno]));
+
+  cmdno = SIM_CMD_LINE_INSERT;
+  simCmdList[cmdno].cmdno = cmdno;
+  strcpy(simCmdList[cmdno].name, "line_insert");
+  simCmdList[cmdno].nlen = (int16_t)strlen(simCmdList[cmdno].name);
+  simCmdList[cmdno].parseCmd = simParseLineInsertCmd;
+  simCmdList[cmdno].executeCmd = simExecuteLineInsertCmd;
+  simAddCmdIntoHash(&(simCmdList[cmdno]));
+
+  cmdno = SIM_CMD_LINE_INSERT_ERROR;
+  simCmdList[cmdno].cmdno = cmdno;
+  strcpy(simCmdList[cmdno].name, "line_insert_error");
+  simCmdList[cmdno].nlen = (int16_t)strlen(simCmdList[cmdno].name);
+  simCmdList[cmdno].parseCmd = simParseLineInsertErrorCmd;
+  simCmdList[cmdno].executeCmd = simExecuteLineInsertErrorCmd;
+  simAddCmdIntoHash(&(simCmdList[cmdno]));
 }

From 228be72a821df3e52b0dad6b4498e68f3f63bc63 Mon Sep 17 00:00:00 2001
From: tomchon <haoran920c@163.com>
Date: Mon, 12 Jul 2021 18:34:31 +0800
Subject: [PATCH 41/70] modify release.sh about beta version name

---
 alert/release.sh                |  2 +-
 packaging/docker/dockerbuild.sh |  2 +-
 packaging/tools/makearbi.sh     | 26 +++++++++++++++-----------
 packaging/tools/makeclient.sh   | 31 +++++++++++++++++--------------
 packaging/tools/makepkg.sh      | 27 +++++++++++++++------------
 5 files changed, 49 insertions(+), 39 deletions(-)

diff --git a/alert/release.sh b/alert/release.sh
index 77f6798480..20317e4166 100755
--- a/alert/release.sh
+++ b/alert/release.sh
@@ -69,7 +69,7 @@ rm -rf ./TDengine-alert
 pkg_name=TDengine-alert-${version}-${osType^}-${archMap[${cpuType}]}
 
 if [ "$verType" == "beta" ]; then
-  pkg_name=${pkg_name}-${verType}
+  pkg_name=TDengine-alert-${version}-${verType}-${osType^}-${archMap[${cpuType}]}
 elif [ "$verType" == "stable" ]; then
   pkg_name=${pkg_name}
 else
diff --git a/packaging/docker/dockerbuild.sh b/packaging/docker/dockerbuild.sh
index 76717d5892..861f00f854 100755
--- a/packaging/docker/dockerbuild.sh
+++ b/packaging/docker/dockerbuild.sh
@@ -16,7 +16,7 @@ cpuType=""
 version=""
 passWord=""
 pkgFile=""
-verType=""
+verType="stable"
 
 while getopts "hc:n:p:f:V:" arg
 do
diff --git a/packaging/tools/makearbi.sh b/packaging/tools/makearbi.sh
index 82808bcae9..5346a79c8f 100755
--- a/packaging/tools/makearbi.sh
+++ b/packaging/tools/makearbi.sh
@@ -47,24 +47,28 @@ mkdir -p ${install_dir}/init.d && cp ${init_file_tarbitrator_rpm} ${install_dir}
 
 cd ${release_dir} 
 
-if [ "$verMode" == "cluster" ]; then
-  pkg_name=${install_dir}-${osType}-${cpuType}
-elif [ "$verMode" == "edge" ]; then
-  pkg_name=${install_dir}-${osType}-${cpuType}
-else
-  echo "unknow verMode, nor cluster or edge"
-  exit 1
-fi
+#  install_dir has been distinguishes  cluster from  edege, so comments this code
+pkg_name=${install_dir}-${osType}-${cpuType}
+
+# if [ "$verMode" == "cluster" ]; then
+#   pkg_name=${install_dir}-${osType}-${cpuType}
+# elif [ "$verMode" == "edge" ]; then
+#   pkg_name=${install_dir}-${osType}-${cpuType}
+# else
+#   echo "unknow verMode, nor cluster or edge"
+#   exit 1
+# fi
 
 if [ "$verType" == "beta" ]; then
-  pkg_name=${pkg_name}-${verType}
-elif [ "$verType" == "stable" ]; then 
-  pkg_name=${pkg_name} 
+  pkg_name=${install_dir}-${verType}-${osType}-${cpuType} 
+elif [ "$verType" == "stable" ]; then
+  pkg_name=${pkg_name}
 else
   echo "unknow verType, nor stabel or beta"
   exit 1
 fi
 
+
 tar -zcv -f "$(basename ${pkg_name}).tar.gz" $(basename ${install_dir}) --remove-files || :
 exitcode=$?
 if [ "$exitcode" != "0" ]; then
diff --git a/packaging/tools/makeclient.sh b/packaging/tools/makeclient.sh
index 0ae5733599..2c36e85970 100755
--- a/packaging/tools/makeclient.sh
+++ b/packaging/tools/makeclient.sh
@@ -170,12 +170,24 @@ fi
 
 cd ${release_dir} 
 
-if [ "$verMode" == "cluster" ]; then
-  pkg_name=${install_dir}-${osType}-${cpuType}
-elif [ "$verMode" == "edge" ]; then
-  pkg_name=${install_dir}-${osType}-${cpuType}
+#  install_dir has been distinguishes  cluster from  edege, so comments this code
+pkg_name=${install_dir}-${osType}-${cpuType}
+
+# if [ "$verMode" == "cluster" ]; then
+#   pkg_name=${install_dir}-${osType}-${cpuType}
+# elif [ "$verMode" == "edge" ]; then
+#   pkg_name=${install_dir}-${osType}-${cpuType}
+# else
+#   echo "unknow verMode, nor cluster or edge"
+#   exit 1
+# fi
+
+if [ "$verType" == "beta" ]; then
+  pkg_name=${install_dir}-${verType}-${osType}-${cpuType} 
+elif [ "$verType" == "stable" ]; then
+  pkg_name=${pkg_name}
 else
-  echo "unknow verMode, nor cluster or edge"
+  echo "unknow verType, nor stabel or beta"
   exit 1
 fi
 
@@ -183,15 +195,6 @@ if [ "$pagMode" == "lite" ]; then
   pkg_name=${pkg_name}-Lite
 fi
 
-if [ "$verType" == "beta" ]; then
-  pkg_name=${pkg_name}-${verType}
-elif [ "$verType" == "stable" ]; then  
-  pkg_name=${pkg_name} 
-else
-  echo "unknow verType, nor stable or beta"
-  exit 1
-fi
-
 if [ "$osType" != "Darwin" ]; then
     tar -zcv -f "$(basename ${pkg_name}).tar.gz" $(basename ${install_dir}) --remove-files || :
 else
diff --git a/packaging/tools/makepkg.sh b/packaging/tools/makepkg.sh
index 81061416a2..56ab24426f 100755
--- a/packaging/tools/makepkg.sh
+++ b/packaging/tools/makepkg.sh
@@ -203,21 +203,20 @@ fi
 
 cd ${release_dir}
 
-if [ "$verMode" == "cluster" ]; then
-  pkg_name=${install_dir}-${osType}-${cpuType}
-elif [ "$verMode" == "edge" ]; then
-  pkg_name=${install_dir}-${osType}-${cpuType}
-else
-  echo "unknow verMode, nor cluster or edge"
-  exit 1
-fi
+#  install_dir has been distinguishes  cluster from  edege, so comments this code
+pkg_name=${install_dir}-${osType}-${cpuType}
 
-if [ "$pagMode" == "lite" ]; then
-  pkg_name=${pkg_name}-Lite
-fi
+# if [ "$verMode" == "cluster" ]; then
+#   pkg_name=${install_dir}-${osType}-${cpuType}
+# elif [ "$verMode" == "edge" ]; then
+#   pkg_name=${install_dir}-${osType}-${cpuType}
+# else
+#   echo "unknow verMode, nor cluster or edge"
+#   exit 1
+# fi
 
 if [ "$verType" == "beta" ]; then
-  pkg_name=${pkg_name}-${verType}
+  pkg_name=${install_dir}-${verType}-${osType}-${cpuType} 
 elif [ "$verType" == "stable" ]; then
   pkg_name=${pkg_name}
 else
@@ -225,6 +224,10 @@ else
   exit 1
 fi
 
+if [ "$pagMode" == "lite" ]; then
+  pkg_name=${pkg_name}-Lite
+fi
+
 tar -zcv -f "$(basename ${pkg_name}).tar.gz" $(basename ${install_dir}) --remove-files || :
 exitcode=$?
 if [ "$exitcode" != "0" ]; then

From a575364d318e491bb1ce482521ad186dbbdf3918 Mon Sep 17 00:00:00 2001
From: tomchon <haoran920c@163.com>
Date: Mon, 12 Jul 2021 21:23:06 +0800
Subject: [PATCH 42/70] modify release.sh about beta version name

---
 packaging/deb/makedeb.sh | 4 +++-
 packaging/rpm/makerpm.sh | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/packaging/deb/makedeb.sh b/packaging/deb/makedeb.sh
index e6ddb6d742..a169bf2ba0 100755
--- a/packaging/deb/makedeb.sh
+++ b/packaging/deb/makedeb.sh
@@ -123,7 +123,7 @@ else
 fi
 
 if [ "$verType" == "beta" ]; then
-  debname=${debname}-${verType}".deb"
+  debname="TDengine-server-"${tdengine_ver}-${verType}-${osType}-${cpuType}".deb"
 elif [ "$verType" == "stable" ]; then
   debname=${debname}".deb"
 else
@@ -131,6 +131,8 @@ else
   exit 1
 fi
 
+
+
 # make deb package
 dpkg -b ${pkg_dir} $debname
 echo "make deb package success!"
diff --git a/packaging/rpm/makerpm.sh b/packaging/rpm/makerpm.sh
index 7c3272f8d0..4cc7daf1a4 100755
--- a/packaging/rpm/makerpm.sh
+++ b/packaging/rpm/makerpm.sh
@@ -73,7 +73,7 @@ else
 fi
 
 if [ "$verType" == "beta" ]; then
-  rpmname=${rpmname}-${verType}".rpm"
+  rpmname="TDengine-server-"${tdengine_ver}-${verType}-${osType}-${cpuType}".rpm"
 elif [ "$verType" == "stable" ]; then
   rpmname=${rpmname}".rpm"
 else

From 4404919d3b7efd943efffdc8b9e640e3c8d6ed01 Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Tue, 13 Jul 2021 08:22:13 +0800
Subject: [PATCH 43/70] [TD-5201]<enhance>:record SSqlObjectId id in log

---
 src/client/src/tscParseInsert.c | 1 +
 src/client/src/tscPrepare.c     | 1 +
 src/client/src/tscUtil.c        | 1 +
 3 files changed, 3 insertions(+)

diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c
index cd56153bc4..26d9cf0e49 100644
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -1129,6 +1129,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
   SSqlCmd *pCmd = &pSql->cmd;
 
   SInsertStatementParam* pInsertParam = &pCmd->insertParam;
+  pInsertParam->objectId = pSql->self;
   char* str = pInsertParam->sql;
 
   int32_t totalNum = 0;
diff --git a/src/client/src/tscPrepare.c b/src/client/src/tscPrepare.c
index 08d3cc599e..798e79dbcb 100644
--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -1470,6 +1470,7 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
   pSql->fetchFp    = waitForQueryRsp;
   
   pCmd->insertParam.insertType = TSDB_QUERY_TYPE_STMT_INSERT;
+  pCmd->insertParam.objectId = pSql->self;
 
   pSql->sqlstr = realloc(pSql->sqlstr, sqlLen + 1);
 
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 173db05e10..460fe739e6 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -3342,6 +3342,7 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
   pnCmd->insertParam.numOfTables = 0;
   pnCmd->insertParam.pTableNameList = NULL;
   pnCmd->insertParam.pTableBlockHashList = NULL;
+  pnCmd->insertParam.objectId = pNew->self;
 
   memset(&pnCmd->insertParam.tagData, 0, sizeof(STagData));
 

From 54bdd895f7af09f793fbd6252a9ddd0a66bc292d Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Tue, 13 Jul 2021 10:38:55 +0800
Subject: [PATCH 44/70] Feature/sangshuduo/td 5136 taosdemo rework (#6837)

* [TD-5136]<feature>: taosdemo simulate real senario.

* update test case according to taosdemo change

* adjust range of semi-random data.
---
 src/kit/taosdemo/taosdemo.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index c92b8e41a6..fa3d263678 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -1331,21 +1331,21 @@ static float demo_current_float(){
     static int cursor;
     cursor++;
     cursor = cursor % MAX_PREPARED_RAND;
-    return (float)(5 + randfloat[cursor] / 1000000000);
+    return (float)(9.8 + 0.04 * (randint[cursor] % 10) + randfloat[cursor]/1000000000);
 }
 
 static int32_t demo_voltage_int(){
     static int cursor;
     cursor++;
     cursor = cursor % MAX_PREPARED_RAND;
-    return 210 + randint[cursor] % 20;
+    return 215 + randint[cursor] % 10;
 }
 
 static float demo_phase_float(){
     static int cursor;
     cursor++;
     cursor = cursor % MAX_PREPARED_RAND;
-    return (float)(120 + randfloat[cursor] / 1000000000);
+    return (float)((115 + randint[cursor] % 10 + randfloat[cursor]/1000000000)/360);
 }
 
 #if 0

From 136189e3c892075a628d753395ea9b5724739764 Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Tue, 13 Jul 2021 10:52:58 +0800
Subject: [PATCH 45/70] memory handling

---
 src/client/src/tscParseLineProtocol.c       | 440 +++++++++++---------
 tests/examples/c/apitest.c                  |  17 +-
 tests/script/general/parser/line_insert.sim |  32 ++
 3 files changed, 286 insertions(+), 203 deletions(-)
 create mode 100644 tests/script/general/parser/line_insert.sim

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index 77d65f3d15..85a6c41ccf 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -64,88 +64,6 @@ int compareSmlColKv(const void* p1, const void* p2) {
   }
 }
 
-int32_t loadTableMeta(TAOS* taos, char* tableName, SSmlSTableSchema* schema) {
-  schema->tags = taosArrayInit(8, sizeof(SSchema));
-  schema->fields = taosArrayInit(64, sizeof(SSchema));
-  schema->tagHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
-  schema->fieldHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
-
-  int32_t code = 0;
-
-  STscObj *pObj = (STscObj *)taos;
-  if (pObj == NULL || pObj->signature != pObj) {
-    terrno = TSDB_CODE_TSC_DISCONNECTED;
-    return TSDB_CODE_TSC_DISCONNECTED;
-  }
-
-  char sql[256];
-  snprintf(sql, 256, "describe %s", tableName);
-  TAOS_RES* res = taos_query(taos, sql);
-  code = taos_errno(res);
-  if (code != 0) {
-    taos_free_result(res);
-    return code;
-  }
-  taos_free_result(res);
-
-  SSqlObj* pSql = calloc(1, sizeof(SSqlObj));
-  pSql->pTscObj = taos;
-  pSql->signature = pSql;
-  pSql->fp = NULL;
-
-  SStrToken tableToken = {.z=tableName, .n=strlen(tableName), .type=TK_ID};
-  tGetToken(tableName, &tableToken.type);
-  // Check if the table name available or not
-  if (tscValidateName(&tableToken) != TSDB_CODE_SUCCESS) {
-    code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
-    sprintf(pSql->cmd.payload, "table name is invalid");
-    return code;
-  }
-
-  SName sname = {0};
-  if ((code = tscSetTableFullName(&sname, &tableToken, pSql)) != TSDB_CODE_SUCCESS) {
-    return code;
-  }
-
-  char  fullTableName[TSDB_TABLE_FNAME_LEN] = {0};
-  memset(fullTableName, 0, tListLen(fullTableName));
-  tNameExtractFullName(&sname, fullTableName);
-
-  if (code != TSDB_CODE_SUCCESS) {
-    tscFreeSqlObj(pSql);
-    return code;
-  }
-
-  tscFreeSqlObj(pSql);
-
-  uint32_t size = tscGetTableMetaMaxSize();
-  STableMeta* tableMeta = calloc(1, size);
-  taosHashGetClone(tscTableMetaInfo, fullTableName, strlen(fullTableName), NULL, tableMeta, -1);
-
-  tstrncpy(schema->sTableName, tableName, strlen(tableName)+1);
-  schema->precision = tableMeta->tableInfo.precision;
-  for (int i=0; i<tableMeta->tableInfo.numOfColumns; ++i) {
-    SSchema field;
-    tstrncpy(field.name, tableMeta->schema[i].name, strlen(tableMeta->schema[i].name)+1);
-    field.type = tableMeta->schema[i].type;
-    field.bytes = tableMeta->schema[i].bytes;
-    SSchema* pField = taosArrayPush(schema->fields, &field);
-    taosHashPut(schema->fieldHash, field.name, strlen(field.name), &pField, POINTER_BYTES);
-  }
-
-  for (int i=0; i<tableMeta->tableInfo.numOfTags; ++i) {
-    int j = i + tableMeta->tableInfo.numOfColumns;
-    SSchema field;
-    tstrncpy(field.name, tableMeta->schema[j].name, strlen(tableMeta->schema[j].name)+1);
-    field.type = tableMeta->schema[j].type;
-    field.bytes = tableMeta->schema[j].bytes;
-    SSchema* pField = taosArrayPush(schema->tags, &field);
-    taosHashPut(schema->tagHash, field.name, strlen(field.name), &pField, POINTER_BYTES);
-  }
-  free(tableMeta); tableMeta = NULL;
-  return code;
-}
-
 typedef enum {
   SCHEMA_ACTION_CREATE_STABLE,
   SCHEMA_ACTION_ADD_COLUMN,
@@ -173,7 +91,7 @@ typedef struct {
   };
 } SSchemaAction;
 
-int32_t getFieldBytesFromSmlKv(TAOS_SML_KV* kv, int32_t* bytes) {
+static int32_t getFieldBytesFromSmlKv(TAOS_SML_KV* kv, int32_t* bytes) {
   if (!IS_VAR_DATA_TYPE(kv->type)) {
     *bytes = tDataTypes[kv->type].bytes;
   } else {
@@ -191,7 +109,7 @@ int32_t getFieldBytesFromSmlKv(TAOS_SML_KV* kv, int32_t* bytes) {
   return 0;
 }
 
-int32_t addTaosFieldToHashAndArray(TAOS_SML_KV* smlKv, SHashObj* hash, SArray* array) {
+static int32_t buildSmlKvSchema(TAOS_SML_KV* smlKv, SHashObj* hash, SArray* array) {
   SSchema* pField = NULL;
   SSchema** ppField = taosHashGet(hash, smlKv->key, strlen(smlKv->key));
   if (ppField) {
@@ -227,7 +145,55 @@ int32_t addTaosFieldToHashAndArray(TAOS_SML_KV* smlKv, SHashObj* hash, SArray* a
   return 0;
 }
 
-int32_t generateSchemaAction(SSchema* pointColField, SHashObj* dbAttrHash, bool isTag, char sTableName[],
+static int32_t buildDataPointSchemas(TAOS_SML_DATA_POINT* points, int numPoint, SArray* stableSchemas) {
+  SHashObj* sname2shema = taosHashInit(32,
+                                       taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+
+  for (int i = 0; i < numPoint; ++i) {
+    TAOS_SML_DATA_POINT* point = &points[i];
+    size_t stableNameLen = strlen(point->stableName);
+    SSmlSTableSchema** ppStableSchema = taosHashGet(sname2shema, point->stableName, stableNameLen);
+    SSmlSTableSchema* pStableSchema = NULL;
+    if (ppStableSchema) {
+      pStableSchema= *ppStableSchema;
+    } else {
+      SSmlSTableSchema schema;
+      strncpy(schema.sTableName, point->stableName, stableNameLen);
+      schema.sTableName[stableNameLen] = '\0';
+      schema.fields = taosArrayInit(64, sizeof(SSchema));
+      schema.tags = taosArrayInit(8, sizeof(SSchema));
+      schema.tagHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+      schema.fieldHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+
+      pStableSchema = taosArrayPush(stableSchemas, &schema);
+      taosHashPut(sname2shema, schema.sTableName, stableNameLen, &pStableSchema, POINTER_BYTES);
+    }
+
+    for (int j = 0; j < point->tagNum; ++j) {
+      TAOS_SML_KV* tagKv = point->tags + j;
+      buildSmlKvSchema(tagKv, pStableSchema->tagHash, pStableSchema->tags);
+    }
+
+    for (int j = 0; j < point->fieldNum; ++j) {
+      TAOS_SML_KV* fieldKv = point->fields + j;
+      buildSmlKvSchema(fieldKv, pStableSchema->fieldHash, pStableSchema->fields);
+    }
+
+    point->schema = pStableSchema;
+  }
+
+  size_t numStables = taosArrayGetSize(stableSchemas);
+  for (int32_t i = 0; i < numStables; ++i) {
+    SSmlSTableSchema* schema = taosArrayGet(stableSchemas, i);
+    taosHashCleanup(schema->tagHash);
+    taosHashCleanup(schema->fieldHash);
+  }
+  taosHashCleanup(sname2shema);
+
+  return 0;
+}
+
+static int32_t generateSchemaAction(SSchema* pointColField, SHashObj* dbAttrHash, bool isTag, char sTableName[],
                                        SSchemaAction* action, bool* actionNeeded) {
   SSchema** ppDbAttr = taosHashGet(dbAttrHash, pointColField->name, strlen(pointColField->name));
   if (ppDbAttr) {
@@ -262,7 +228,7 @@ int32_t generateSchemaAction(SSchema* pointColField, SHashObj* dbAttrHash, bool
   return 0;
 }
 
-int32_t buildColumnDescription(SSchema* field,
+static int32_t buildColumnDescription(SSchema* field,
                                char* buf, int32_t bufSize, int32_t* outBytes) {
   uint8_t type = field->type;
 
@@ -283,7 +249,8 @@ int32_t buildColumnDescription(SSchema* field,
   return 0;
 }
 
-int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
+
+static int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
   int32_t code = 0;
   int32_t capacity = TSDB_MAX_BINARY_LEN;
   int32_t outBytes = 0;
@@ -357,7 +324,160 @@ int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
   return code;
 }
 
-int32_t getChildTableName(TAOS_SML_DATA_POINT* point, char* tableName, int* tableNameLen) {
+static int32_t destorySmlSTableSchema(SSmlSTableSchema* schema) {
+  taosHashCleanup(schema->tagHash);
+  taosHashCleanup(schema->fieldHash);
+  taosArrayDestroy(schema->tags);
+  taosArrayDestroy(schema->fields);
+  return 0;
+}
+
+int32_t loadTableMeta(TAOS* taos, char* tableName, SSmlSTableSchema* schema) {
+  int32_t code = 0;
+
+  STscObj *pObj = (STscObj *)taos;
+  if (pObj == NULL || pObj->signature != pObj) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return TSDB_CODE_TSC_DISCONNECTED;
+  }
+
+  char sql[256];
+  snprintf(sql, 256, "describe %s", tableName);
+  TAOS_RES* res = taos_query(taos, sql);
+  code = taos_errno(res);
+  if (code != 0) {
+    taos_free_result(res);
+    return code;
+  }
+  taos_free_result(res);
+
+  SSqlObj* pSql = calloc(1, sizeof(SSqlObj));
+  pSql->pTscObj = taos;
+  pSql->signature = pSql;
+  pSql->fp = NULL;
+
+  SStrToken tableToken = {.z=tableName, .n=strlen(tableName), .type=TK_ID};
+  tGetToken(tableName, &tableToken.type);
+  // Check if the table name available or not
+  if (tscValidateName(&tableToken) != TSDB_CODE_SUCCESS) {
+    code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
+    sprintf(pSql->cmd.payload, "table name is invalid");
+    return code;
+  }
+
+  SName sname = {0};
+  if ((code = tscSetTableFullName(&sname, &tableToken, pSql)) != TSDB_CODE_SUCCESS) {
+    return code;
+  }
+
+  char  fullTableName[TSDB_TABLE_FNAME_LEN] = {0};
+  memset(fullTableName, 0, tListLen(fullTableName));
+  tNameExtractFullName(&sname, fullTableName);
+
+  if (code != TSDB_CODE_SUCCESS) {
+    tscFreeSqlObj(pSql);
+    return code;
+  }
+
+  tscFreeSqlObj(pSql);
+
+  schema->tags = taosArrayInit(8, sizeof(SSchema));
+  schema->fields = taosArrayInit(64, sizeof(SSchema));
+  schema->tagHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+  schema->fieldHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+
+  uint32_t size = tscGetTableMetaMaxSize();
+  STableMeta* tableMeta = calloc(1, size);
+  taosHashGetClone(tscTableMetaInfo, fullTableName, strlen(fullTableName), NULL, tableMeta, -1);
+
+  tstrncpy(schema->sTableName, tableName, strlen(tableName)+1);
+  schema->precision = tableMeta->tableInfo.precision;
+  for (int i=0; i<tableMeta->tableInfo.numOfColumns; ++i) {
+    SSchema field;
+    tstrncpy(field.name, tableMeta->schema[i].name, strlen(tableMeta->schema[i].name)+1);
+    field.type = tableMeta->schema[i].type;
+    field.bytes = tableMeta->schema[i].bytes;
+    SSchema* pField = taosArrayPush(schema->fields, &field);
+    taosHashPut(schema->fieldHash, field.name, strlen(field.name), &pField, POINTER_BYTES);
+  }
+
+  for (int i=0; i<tableMeta->tableInfo.numOfTags; ++i) {
+    int j = i + tableMeta->tableInfo.numOfColumns;
+    SSchema field;
+    tstrncpy(field.name, tableMeta->schema[j].name, strlen(tableMeta->schema[j].name)+1);
+    field.type = tableMeta->schema[j].type;
+    field.bytes = tableMeta->schema[j].bytes;
+    SSchema* pField = taosArrayPush(schema->tags, &field);
+    taosHashPut(schema->tagHash, field.name, strlen(field.name), &pField, POINTER_BYTES);
+  }
+  free(tableMeta); tableMeta = NULL;
+  return code;
+}
+
+static int32_t reconcileDBSchemas(TAOS* taos, SArray* stableSchemas) {
+  int32_t code = 0;
+  size_t numStable = taosArrayGetSize(stableSchemas);
+  for (int i = 0; i < numStable; ++i) {
+    SSmlSTableSchema* pointSchema = taosArrayGet(stableSchemas, i);
+    SSmlSTableSchema  dbSchema = {0};
+
+    code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
+
+    if (code == TSDB_CODE_MND_INVALID_TABLE_NAME) {
+      SSchemaAction schemaAction = {0};
+      schemaAction.action = SCHEMA_ACTION_CREATE_STABLE;
+      memset(&schemaAction.createSTable, 0, sizeof(SCreateSTableActionInfo));
+      memcpy(schemaAction.createSTable.sTableName, pointSchema->sTableName, TSDB_TABLE_NAME_LEN);
+      schemaAction.createSTable.tags = pointSchema->tags;
+      schemaAction.createSTable.fields = pointSchema->fields;
+      applySchemaAction(taos, &schemaAction);
+      code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
+
+      pointSchema->precision = dbSchema.precision;
+
+      destorySmlSTableSchema(&dbSchema);
+    } else if (code == TSDB_CODE_SUCCESS) {
+      size_t pointTagSize = taosArrayGetSize(pointSchema->tags);
+      size_t pointFieldSize = taosArrayGetSize(pointSchema->fields);
+
+      SHashObj* dbTagHash = dbSchema.tagHash;
+      SHashObj* dbFieldHash = dbSchema.fieldHash;
+
+      for (int j = 0; j < pointTagSize; ++j) {
+        SSchema* pointTag = taosArrayGet(pointSchema->tags, j);
+        SSchemaAction schemaAction = {0};
+        bool actionNeeded = false;
+        generateSchemaAction(pointTag, dbTagHash, true, pointSchema->sTableName, &schemaAction, &actionNeeded);
+        if (actionNeeded) {
+          applySchemaAction(taos, &schemaAction);
+        }
+      }
+
+      SSchema* pointColTs = taosArrayGet(pointSchema->fields, 0);
+      SSchema* dbColTs = taosArrayGet(dbSchema.fields, 0);
+      memcpy(pointColTs->name, dbColTs->name, TSDB_COL_NAME_LEN);
+
+      for (int j = 1; j < pointFieldSize; ++j) {
+        SSchema* pointCol = taosArrayGet(pointSchema->fields, j);
+        SSchemaAction schemaAction = {0};
+        bool actionNeeded = false;
+        generateSchemaAction(pointCol, dbFieldHash, false, pointSchema->sTableName, &schemaAction, &actionNeeded);
+        if (actionNeeded) {
+          applySchemaAction(taos, &schemaAction);
+        }
+      }
+
+      pointSchema->precision = dbSchema.precision;
+
+      destorySmlSTableSchema(&dbSchema);
+    } else {
+      return code;
+    }
+  }
+  return 0;
+}
+
+static int32_t getChildTableName(TAOS_SML_DATA_POINT* point, char* tableName, int* tableNameLen) {
   qsort(point->tags, point->tagNum, sizeof(TAOS_SML_KV), compareSmlColKv);
 
   SStringBuilder sb; memset(&sb, 0, sizeof(sb));
@@ -384,7 +504,7 @@ int32_t getChildTableName(TAOS_SML_DATA_POINT* point, char* tableName, int* tabl
   return 0;
 }
 
-int32_t creatChildTableIfNotExists(TAOS* taos, const char* cTableName, const char* sTableName, SArray* tagsSchema, SArray* tagsBind) {
+static int32_t creatChildTableIfNotExists(TAOS* taos, const char* cTableName, const char* sTableName, SArray* tagsSchema, SArray* tagsBind) {
   size_t numTags = taosArrayGetSize(tagsSchema);
   char sql[TSDB_MAX_BINARY_LEN] = {0};
   int freeBytes = TSDB_MAX_BINARY_LEN;
@@ -428,10 +548,10 @@ int32_t creatChildTableIfNotExists(TAOS* taos, const char* cTableName, const cha
   return 0;
 }
 
-int32_t insertBatch(TAOS* taos,  char* cTableName, SArray* colsSchema, SArray* rowsBind) {
+static int32_t insertChildTableBatch(TAOS* taos,  char* cTableName, SArray* colsSchema, SArray* rowsBind) {
   size_t numCols = taosArrayGetSize(colsSchema);
-  char sql[4096];
-  int32_t freeBytes = 4096;
+  char sql[TSDB_MAX_BINARY_LEN];
+  int32_t freeBytes = TSDB_MAX_BINARY_LEN;
   sprintf(sql, "insert into ? (");
 
   for (int i = 0; i < numCols; ++i) {
@@ -458,6 +578,7 @@ int32_t insertBatch(TAOS* taos,  char* cTableName, SArray* colsSchema, SArray* r
     printf("%s", taos_stmt_errstr(stmt));
     return code;
   }
+
   size_t rows = taosArrayGetSize(rowsBind);
   for (int32_t i = 0; i < rows; ++i) {
     TAOS_BIND* colsBinds = taosArrayGetP(rowsBind, i);
@@ -479,13 +600,11 @@ int32_t insertBatch(TAOS* taos,  char* cTableName, SArray* colsSchema, SArray* r
     return code;
   }
 
-
   taos_stmt_close(stmt);
   return code;
 }
 
-int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints) {
-  SHashObj* cname2points = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+static int32_t arrangePointsByChildTableName(TAOS_SML_DATA_POINT* points, int numPoints, SHashObj* cname2points) {
   for (int32_t i = 0; i < numPoints; ++i) {
     TAOS_SML_DATA_POINT * point = points + i;
     if (!point->childTableName) {
@@ -526,6 +645,14 @@ int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints)
     taosArrayPush(cTablePoints, &point);
   }
 
+  return 0;
+}
+
+static int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints) {
+  SHashObj* cname2points = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY),
+                                        true, false);
+  arrangePointsByChildTableName(points, numPoints, cname2points);
+
   int isNullColBind = TSDB_TRUE;
   SArray** pCTablePoints = taosHashIterate(cname2points, NULL);
   while (pCTablePoints) {
@@ -577,111 +704,44 @@ int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t numPoints)
     }
 
     creatChildTableIfNotExists(taos, point->childTableName, point->stableName, point->schema->tags, tagBinds);
-    insertBatch(taos, point->childTableName, point->schema->fields, rowsBind);
+    for (int i = 0; i < taosArrayGetSize(tagBinds); ++i) {
+      TAOS_BIND* bind = taosArrayGet(tagBinds, i);
+      free(bind->length);
+    }
+    taosArrayDestroy(tagBinds);
+
+    insertChildTableBatch(taos, point->childTableName, point->schema->fields, rowsBind);
+    for (int i = 0; i < rows; ++i) {
+      TAOS_BIND* colBinds = taosArrayGetP(rowsBind, i);
+      for (int j = 0; j < numCols; ++j) {
+        TAOS_BIND* bind = colBinds + j;
+        free(bind->length);
+      }
+    }
+    taosArrayDestroy(rowsBind);
+    taosArrayDestroy(cTablePoints);
 
     pCTablePoints = taosHashIterate(cname2points, pCTablePoints);
   }
+
+  taosHashCleanup(cname2points);
   return 0;
 }
 
 int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
   int32_t code = TSDB_CODE_SUCCESS;
-  SArray* stableArray = taosArrayInit(32, sizeof(SSmlSTableSchema)); // SArray<STableColumnsSchema>
-  SHashObj* sname2shema = taosHashInit(32,
-                                       taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
-
-  for (int i = 0; i < numPoint; ++i) {
-    TAOS_SML_DATA_POINT* point = &points[i];
-    size_t stableNameLen = strlen(point->stableName);
-    SSmlSTableSchema** ppStableSchema = taosHashGet(sname2shema, point->stableName, stableNameLen);
-    SSmlSTableSchema* pStableSchema = NULL;
-    if (ppStableSchema) {
-      pStableSchema= *ppStableSchema;
-    } else {
-      SSmlSTableSchema schema;
-      strncpy(schema.sTableName, point->stableName, stableNameLen);
-      schema.sTableName[stableNameLen] = '\0';
-      schema.fields = taosArrayInit(64, sizeof(SSchema));
-      schema.tags = taosArrayInit(8, sizeof(SSchema));
-      schema.tagHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
-      schema.fieldHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
-
-      pStableSchema = taosArrayPush(stableArray, &schema);
-      taosHashPut(sname2shema, schema.sTableName, stableNameLen, &pStableSchema, POINTER_BYTES);
-    }
-
-    for (int j = 0; j < point->tagNum; ++j) {
-      TAOS_SML_KV* tagKv = point->tags + j;
-      addTaosFieldToHashAndArray(tagKv, pStableSchema->tagHash, pStableSchema->tags);
-    }
-
-    for (int j = 0; j < point->fieldNum; ++j) {
-      TAOS_SML_KV* fieldKv = point->fields + j;
-      addTaosFieldToHashAndArray(fieldKv, pStableSchema->fieldHash, pStableSchema->fields);
-    }
-
-    point->schema = pStableSchema;
-  }
-
-  size_t numStable = taosArrayGetSize(stableArray);
-  for (int i = 0; i < numStable; ++i) {
-    SSmlSTableSchema* pointSchema = taosArrayGet(stableArray, i);
-    SSmlSTableSchema  dbSchema = {0};
-
-    code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
-
-    if (code == TSDB_CODE_MND_INVALID_TABLE_NAME) {
-      SSchemaAction schemaAction = {0};
-      schemaAction.action = SCHEMA_ACTION_CREATE_STABLE;
-      memset(&schemaAction.createSTable, 0, sizeof(SCreateSTableActionInfo));
-      memcpy(schemaAction.createSTable.sTableName, pointSchema->sTableName, TSDB_TABLE_NAME_LEN);
-      schemaAction.createSTable.tags = pointSchema->tags;
-      schemaAction.createSTable.fields = pointSchema->fields;
-      applySchemaAction(taos, &schemaAction);
-      code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
-      pointSchema->precision = dbSchema.precision;
-    } else if (code == TSDB_CODE_SUCCESS) {
-      size_t pointTagSize = taosArrayGetSize(pointSchema->tags);
-      size_t pointFieldSize = taosArrayGetSize(pointSchema->fields);
-
-      SHashObj* dbTagHash = dbSchema.tagHash;
-      SHashObj* dbFieldHash = dbSchema.fieldHash;
-
-      for (int j = 0; j < pointTagSize; ++j) {
-        SSchema* pointTag = taosArrayGet(pointSchema->tags, j);
-        SSchemaAction schemaAction = {0};
-        bool actionNeeded = false;
-        generateSchemaAction(pointTag, dbTagHash, true, pointSchema->sTableName, &schemaAction, &actionNeeded);
-        if (actionNeeded) {
-          applySchemaAction(taos, &schemaAction);
-          code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
-          pointSchema->precision = dbSchema.precision;
-        }
-      }
-
-      SSchema* pointColTs = taosArrayGet(pointSchema->fields, 0);
-      SSchema* dbColTs = taosArrayGet(dbSchema.fields, 0);
-      memcpy(pointColTs->name, dbColTs->name, TSDB_COL_NAME_LEN);
-
-      for (int j = 1; j < pointFieldSize; ++j) {
-        SSchema* pointCol = taosArrayGet(pointSchema->fields, j);
-        SSchemaAction schemaAction = {0};
-        bool actionNeeded = false;
-        generateSchemaAction(pointCol, dbFieldHash, false, pointSchema->sTableName, &schemaAction, &actionNeeded);
-        if (actionNeeded) {
-          applySchemaAction(taos, &schemaAction);
-          code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
-          pointSchema->precision = dbSchema.precision;
-        }
-      }
-
-      pointSchema->precision = dbSchema.precision;
-    } else {
-      return code;
-    }
-  }
 
+  SArray* stableSchemas = taosArrayInit(32, sizeof(SSmlSTableSchema)); // SArray<STableColumnsSchema>
+  buildDataPointSchemas(points, numPoint, stableSchemas);
+  reconcileDBSchemas(taos, stableSchemas);
   insertPoints(taos, points, numPoint);
+
+  for (int i = 0; i < taosArrayGetSize(stableSchemas); ++i) {
+    SSmlSTableSchema* schema = taosArrayGet(stableSchemas, i);
+    taosArrayDestroy(schema->fields);
+    taosArrayDestroy(schema->tags);
+  }
+  taosArrayDestroy(stableSchemas);
   return code;
 }
 
diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index 75262d74d8..de7fcecc7e 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -6,6 +6,7 @@
 #include <string.h>
 #include <taos.h>
 #include <unistd.h>
+#include <tconfig.h>
 
 static void prepare_data(TAOS* taos) {
   TAOS_RES *result;
@@ -965,23 +966,13 @@ int32_t verify_schema_less(TAOS* taos) {
 
   char* lines[] = {
       "st,t1=3i,t2=4,t3=\"t3\" c1=3i,c3=L\"passit\",c2=false,c4=4 1626006833639000000",
-      "st,t1=4i,t3=\"t4\",t2=5,t4=5 c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833640000000",
+      "st,t1=4i,t3=\"t4\",t2=5,t4=5 c1=3i,c3=L\"passitagin\",c2=true,c4=5,c5=5 1626006833640000000",
       "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833642000000",
       "ste,t2=5,t3=L\"ste\" c1=true,c2=4,c3=\"iam\" 1626056811823316532",
       "ste,t2=5,t3=L\"ste2\" c3=\"iamszhou\",c4=false 1626056811843316532"
   };
 
-//  int code = taos_insert_by_lines(taos, lines , 5);
-  int code = taos_insert_by_lines(taos, &(lines[0]), 1);
-
-  code = taos_insert_by_lines(taos, &(lines[1]), 1);
-
-//  code = taos_insert_by_lines(taos, &(lines[2]), 1);
-//
-//  code = taos_insert_by_lines(taos, &(lines[3]), 1);
-//
-//  code = taos_insert_by_lines(taos, &(lines[4]), 1);
-
+  int code = taos_insert_by_lines(taos, lines , 5);
 
   return code;
 }
@@ -992,7 +983,7 @@ int main(int argc, char *argv[]) {
   const char* passwd = "taosdata";
 
   taos_options(TSDB_OPTION_TIMEZONE, "GMT-8");
-  taos_options(TSDB_OPTION_CONFIGDIR, "/etc/taos");
+  taosDumpGlobalCfg();
   TAOS* taos = taos_connect(host, user, passwd, "", 0);
   if (taos == NULL) {
     printf("\033[31mfailed to connect to db, reason:%s\033[0m\n", taos_errstr(taos));
diff --git a/tests/script/general/parser/line_insert.sim b/tests/script/general/parser/line_insert.sim
new file mode 100644
index 0000000000..cb6d228e4d
--- /dev/null
+++ b/tests/script/general/parser/line_insert.sim
@@ -0,0 +1,32 @@
+system sh/stop_dnodes.sh
+
+system sh/deploy.sh -n dnode1 -i 1
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
+system sh/exec.sh -n dnode1 -s start
+sleep 2000
+sql connect
+
+print =============== step1
+$db = testlp
+$mte = ste
+$mt = st
+sql drop database $db -x step1
+step1:
+sql create database $db precision 'us'
+sql use $db
+sql create stable $mte (ts timestamp, f int) TAGS(t1 bigint)
+
+line_insert st,t1=3i,t2=4,t3="t3" c1=3i,c3=L"passit",c2=false,c4=4 1626006833639000000
+line_insert st,t1=4i,t3="t4",t2=5 c1=3i,c3=L"passitagain",c2=true,c4=5,c5=5 1626006833640000000
+line_insert st,t1=4i,t2=5,t3="t4" c1=3i,c3=L"passitagain",c2=true,c4=5 1626006833642000000  
+line_insert ste,t2=5,t3=L"ste" c1=true,c2=4,c3="iam" 1626056811823316532
+line_insert ste,t2=5,t3=L"ste2" c3="iamszhou",c4=false 1626056811843316532
+
+#print =============== clear
+#sql drop database $db
+#sql show databases
+#if $rows != 0 then 
+#  return -1
+#endi
+#
+#system sh/exec.sh -n dnode1 -s stop -x SIGINT

From f9bfe6cc3d2bd91539941c799bdc8eb9066385fa Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Tue, 13 Jul 2021 10:55:26 +0800
Subject: [PATCH 46/70] for reconfigure table reproduction

---
 tests/examples/c/apitest.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index de7fcecc7e..b8f68636bd 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -972,7 +972,9 @@ int32_t verify_schema_less(TAOS* taos) {
       "ste,t2=5,t3=L\"ste2\" c3=\"iamszhou\",c4=false 1626056811843316532"
   };
 
-  int code = taos_insert_by_lines(taos, lines , 5);
+  //int code = taos_insert_by_lines(taos, lines , 5);
+  int code = taos_insert_by_lines(taos, &lines[0], 1);
+  code = taos_insert_by_lines(taos, &lines[1], 1);
 
   return code;
 }

From c24033dc259220527dc611de90666a5c0d5b91fd Mon Sep 17 00:00:00 2001
From: wpan <wpan@taosdata.com>
Date: Tue, 13 Jul 2021 11:32:39 +0800
Subject: [PATCH 47/70] add timezone comments for windows

---
 packaging/cfg/taos.cfg | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/packaging/cfg/taos.cfg b/packaging/cfg/taos.cfg
index 9ad06cd1bd..bbe6eae419 100644
--- a/packaging/cfg/taos.cfg
+++ b/packaging/cfg/taos.cfg
@@ -149,6 +149,8 @@ keepColumnName            1
 
 # system time zone
 # timezone              Asia/Shanghai (CST, +0800)
+# system time zone (for windows 10)
+# timezone              UTC-8
 
 # system locale
 # locale                en_US.UTF-8

From ddb783f40720708b0e94e40caac30fdabaa41c64 Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Tue, 13 Jul 2021 13:06:46 +0800
Subject: [PATCH 48/70] add simple tsim test

---
 tests/examples/c/apitest.c                  |  6 +--
 tests/script/general/parser/line_insert.sim | 42 ++++++++++++++++-----
 2 files changed, 35 insertions(+), 13 deletions(-)

diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index b8f68636bd..f4e222c4dc 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -972,9 +972,9 @@ int32_t verify_schema_less(TAOS* taos) {
       "ste,t2=5,t3=L\"ste2\" c3=\"iamszhou\",c4=false 1626056811843316532"
   };
 
-  //int code = taos_insert_by_lines(taos, lines , 5);
-  int code = taos_insert_by_lines(taos, &lines[0], 1);
-  code = taos_insert_by_lines(taos, &lines[1], 1);
+  int code = taos_insert_by_lines(taos, lines , 5);
+  //int code = taos_insert_by_lines(taos, &lines[0], 1);
+  //code = taos_insert_by_lines(taos, &lines[1], 1);
 
   return code;
 }
diff --git a/tests/script/general/parser/line_insert.sim b/tests/script/general/parser/line_insert.sim
index cb6d228e4d..f3067a3bbe 100644
--- a/tests/script/general/parser/line_insert.sim
+++ b/tests/script/general/parser/line_insert.sim
@@ -17,16 +17,38 @@ sql use $db
 sql create stable $mte (ts timestamp, f int) TAGS(t1 bigint)
 
 line_insert st,t1=3i,t2=4,t3="t3" c1=3i,c3=L"passit",c2=false,c4=4 1626006833639000000
-line_insert st,t1=4i,t3="t4",t2=5 c1=3i,c3=L"passitagain",c2=true,c4=5,c5=5 1626006833640000000
-line_insert st,t1=4i,t2=5,t3="t4" c1=3i,c3=L"passitagain",c2=true,c4=5 1626006833642000000  
+line_insert st,t1=4i,t3="t41",t2=5 c1=3i,c3=L"passiT",c2=true,c4=5 1626006833640000000
+line_insert stf,t1=4i,t2=5,t3="t4" c1=3i,c3=L"passitagain",c2=true,c4=5 1626006833642000000  
 line_insert ste,t2=5,t3=L"ste" c1=true,c2=4,c3="iam" 1626056811823316532
-line_insert ste,t2=5,t3=L"ste2" c3="iamszhou",c4=false 1626056811843316532
+
+sql select * from st
+if $rows != 2 then
+  return -1
+endi
+
+if $data00 != @21-07-11 20:33:53.639000@ then
+  return -1
+endi
+
+if $data03 != @passit@ then
+  return -1
+endi
+
+sql select * from stf
+if $rows != 1 then
+  return -1
+endi
+
+sql select * from ste
+if $rows != 1 then
+  return -1
+endi
 
 #print =============== clear
-#sql drop database $db
-#sql show databases
-#if $rows != 0 then 
-#  return -1
-#endi
-#
-#system sh/exec.sh -n dnode1 -s stop -x SIGINT
+sql drop database $db
+sql show databases
+if $rows != 0 then 
+  return -1
+endi
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT

From bcba45e38bcd2769057f3b631ee390a9289a8599 Mon Sep 17 00:00:00 2001
From: Shenglian Zhou <shenglian_zhou@163.com>
Date: Tue, 13 Jul 2021 14:19:56 +0800
Subject: [PATCH 49/70] retry afer batch execute reconfigure table

---
 src/client/src/tscParseLineProtocol.c | 61 +++++++++++++++------------
 tests/examples/c/apitest.c            |  8 ++--
 2 files changed, 36 insertions(+), 33 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index 85a6c41ccf..04b96dc52a 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -324,7 +324,7 @@ static int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
   return code;
 }
 
-static int32_t destorySmlSTableSchema(SSmlSTableSchema* schema) {
+static int32_t destroySmlSTableSchema(SSmlSTableSchema* schema) {
   taosHashCleanup(schema->tagHash);
   taosHashCleanup(schema->fieldHash);
   taosArrayDestroy(schema->tags);
@@ -435,7 +435,7 @@ static int32_t reconcileDBSchemas(TAOS* taos, SArray* stableSchemas) {
 
       pointSchema->precision = dbSchema.precision;
 
-      destorySmlSTableSchema(&dbSchema);
+      destroySmlSTableSchema(&dbSchema);
     } else if (code == TSDB_CODE_SUCCESS) {
       size_t pointTagSize = taosArrayGetSize(pointSchema->tags);
       size_t pointFieldSize = taosArrayGetSize(pointSchema->fields);
@@ -469,7 +469,7 @@ static int32_t reconcileDBSchemas(TAOS* taos, SArray* stableSchemas) {
 
       pointSchema->precision = dbSchema.precision;
 
-      destorySmlSTableSchema(&dbSchema);
+      destroySmlSTableSchema(&dbSchema);
     } else {
       return code;
     }
@@ -565,42 +565,47 @@ static int32_t insertChildTableBatch(TAOS* taos,  char* cTableName, SArray* cols
   }
   snprintf(sql + strlen(sql)-1, freeBytes-strlen(sql)+1, ")");
 
-  TAOS_STMT* stmt = taos_stmt_init(taos);
-  int32_t code;
-  code = taos_stmt_prepare(stmt, sql, strlen(sql));
-  if (code != 0) {
-    printf("%s", taos_stmt_errstr(stmt));
-    return code;
-  }
+  int32_t code = 0;
+  int32_t try = 0;
+  do {
+    TAOS_STMT* stmt = taos_stmt_init(taos);
 
-  code = taos_stmt_set_tbname(stmt, cTableName);
-  if (code != 0) {
-    printf("%s", taos_stmt_errstr(stmt));
-    return code;
-  }
-
-  size_t rows = taosArrayGetSize(rowsBind);
-  for (int32_t i = 0; i < rows; ++i) {
-    TAOS_BIND* colsBinds = taosArrayGetP(rowsBind, i);
-    code = taos_stmt_bind_param(stmt, colsBinds);
+    code = taos_stmt_prepare(stmt, sql, strlen(sql));
     if (code != 0) {
       printf("%s", taos_stmt_errstr(stmt));
       return code;
     }
-    code = taos_stmt_add_batch(stmt);
+
+    code = taos_stmt_set_tbname(stmt, cTableName);
     if (code != 0) {
       printf("%s", taos_stmt_errstr(stmt));
       return code;
     }
-  }
 
-  code = taos_stmt_execute(stmt);
-  if (code != 0) {
-    printf("%s", taos_stmt_errstr(stmt));
-    return code;
-  }
+    size_t rows = taosArrayGetSize(rowsBind);
+    for (int32_t i = 0; i < rows; ++i) {
+      TAOS_BIND* colsBinds = taosArrayGetP(rowsBind, i);
+      code = taos_stmt_bind_param(stmt, colsBinds);
+      if (code != 0) {
+        printf("%s", taos_stmt_errstr(stmt));
+        return code;
+      }
+      code = taos_stmt_add_batch(stmt);
+      if (code != 0) {
+        printf("%s", taos_stmt_errstr(stmt));
+        return code;
+      }
+    }
+
+    code = taos_stmt_execute(stmt);
+    if (code != 0) {
+      printf("%s", taos_stmt_errstr(stmt));
+      taos_stmt_close(stmt);
+    } else {
+      taos_stmt_close(stmt);
+    }
+  } while (code == TSDB_CODE_TDB_TABLE_RECONFIGURE && try++ < TSDB_MAX_REPLICA);
 
-  taos_stmt_close(stmt);
   return code;
 }
 
diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index f4e222c4dc..e7d4b087f7 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -6,7 +6,6 @@
 #include <string.h>
 #include <taos.h>
 #include <unistd.h>
-#include <tconfig.h>
 
 static void prepare_data(TAOS* taos) {
   TAOS_RES *result;
@@ -972,9 +971,9 @@ int32_t verify_schema_less(TAOS* taos) {
       "ste,t2=5,t3=L\"ste2\" c3=\"iamszhou\",c4=false 1626056811843316532"
   };
 
-  int code = taos_insert_by_lines(taos, lines , 5);
-  //int code = taos_insert_by_lines(taos, &lines[0], 1);
-  //code = taos_insert_by_lines(taos, &lines[1], 1);
+  // int code = taos_insert_by_lines(taos, lines , 5);
+  int code = taos_insert_by_lines(taos, &lines[0], 1);
+  code = taos_insert_by_lines(taos, &lines[1], 1);
 
   return code;
 }
@@ -985,7 +984,6 @@ int main(int argc, char *argv[]) {
   const char* passwd = "taosdata";
 
   taos_options(TSDB_OPTION_TIMEZONE, "GMT-8");
-  taosDumpGlobalCfg();
   TAOS* taos = taos_connect(host, user, passwd, "", 0);
   if (taos == NULL) {
     printf("\033[31mfailed to connect to db, reason:%s\033[0m\n", taos_errstr(taos));

From abf659bd14a86a3545745d87802bfdeea78ca817 Mon Sep 17 00:00:00 2001
From: Elias Soong <elias.soong@gmail.com>
Date: Tue, 13 Jul 2021 15:19:10 +0800
Subject: [PATCH 50/70] [TD-4969] <docs>: modify minimal interval of selecting
 window to be 1us.

---
 documentation20/cn/12.taos-sql/docs.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/documentation20/cn/12.taos-sql/docs.md b/documentation20/cn/12.taos-sql/docs.md
index 4a92effe6d..e7541bb877 100644
--- a/documentation20/cn/12.taos-sql/docs.md
+++ b/documentation20/cn/12.taos-sql/docs.md
@@ -1332,6 +1332,7 @@ SELECT function_list FROM stb_name
 - 在聚合查询中，function_list 位置允许使用聚合和选择函数，并要求每个函数仅输出单个结果（例如：COUNT、AVG、SUM、STDDEV、LEASTSQUARES、PERCENTILE、MIN、MAX、FIRST、LAST），而不能使用具有多行输出结果的函数（例如：TOP、BOTTOM、DIFF 以及四则运算）。
 - 查询过滤、聚合等操作按照每个切分窗口为独立的单位执行。聚合查询目前支持三种窗口的划分方式：
   1. 时间窗口：聚合时间段的窗口宽度由关键词 INTERVAL 指定，最短时间间隔 10 毫秒（10a）；并且支持偏移 offset（偏移必须小于间隔），也即时间窗口划分与“UTC 时刻 0”相比的偏移量。SLIDING 语句用于指定聚合时间段的前向增量，也即每次窗口向前滑动的时长。当 SLIDING 与 INTERVAL 取值相等的时候，滑动窗口即为翻转窗口。
+    * 从 2.1.5.0 版本开始，INTERVAL 语句允许的最短时间间隔调整为 1 微秒（1u），当然如果所查询的 DATABASE 的时间精度设置为毫秒级，那么允许的最短时间间隔为 1 毫秒（1a）。
   2. 状态窗口：使用整数（布尔值）或字符串来标识产生记录时设备的状态量，产生的记录如果具有相同的状态量取值则归属于同一个状态窗口，数值改变后该窗口关闭。状态量所对应的列作为 STATE_WINDOW 语句的参数来指定。
   3. 会话窗口：时间戳所在的列由 SESSION 语句的 ts_col 参数指定，会话窗口根据相邻两条记录的时间戳差值来确定是否属于同一个会话——如果时间戳差异在 tol_val 以内，则认为记录仍属于同一个窗口；如果时间变化超过 tol_val，则自动开启下一个窗口。
 - WHERE 语句可以指定查询的起止时间和其他过滤条件。

From 8f2008664e24972fd730aa8d4547d13ad092c26d Mon Sep 17 00:00:00 2001
From: wpan <wpan@taosdata.com>
Date: Tue, 13 Jul 2021 16:34:19 +0800
Subject: [PATCH 51/70] add retry for reconfigure table

---
 src/client/src/tscParseLineProtocol.c | 30 +++++++++++++++------------
 src/client/src/tscPrepare.c           | 10 +++++++--
 2 files changed, 25 insertions(+), 15 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index 04b96dc52a..5fba602670 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -565,16 +565,19 @@ static int32_t insertChildTableBatch(TAOS* taos,  char* cTableName, SArray* cols
   }
   snprintf(sql + strlen(sql)-1, freeBytes-strlen(sql)+1, ")");
 
+
   int32_t code = 0;
   int32_t try = 0;
-  do {
-    TAOS_STMT* stmt = taos_stmt_init(taos);
 
-    code = taos_stmt_prepare(stmt, sql, strlen(sql));
-    if (code != 0) {
-      printf("%s", taos_stmt_errstr(stmt));
-      return code;
-    }
+  TAOS_STMT* stmt = taos_stmt_init(taos);
+  
+  code = taos_stmt_prepare(stmt, sql, strlen(sql));
+  if (code != 0) {
+    printf("%s", taos_stmt_errstr(stmt));
+    return code;
+  }
+
+  do {
 
     code = taos_stmt_set_tbname(stmt, cTableName);
     if (code != 0) {
@@ -598,14 +601,15 @@ static int32_t insertChildTableBatch(TAOS* taos,  char* cTableName, SArray* cols
     }
 
     code = taos_stmt_execute(stmt);
-    if (code != 0) {
-      printf("%s", taos_stmt_errstr(stmt));
-      taos_stmt_close(stmt);
-    } else {
-      taos_stmt_close(stmt);
-    }
   } while (code == TSDB_CODE_TDB_TABLE_RECONFIGURE && try++ < TSDB_MAX_REPLICA);
 
+  if (code != 0) {
+    printf("%s", taos_stmt_errstr(stmt));
+    taos_stmt_close(stmt);
+  } else {
+    taos_stmt_close(stmt);
+  }
+
   return code;
 }
 
diff --git a/src/client/src/tscPrepare.c b/src/client/src/tscPrepare.c
index 798e79dbcb..3a462c96d6 100644
--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -1200,9 +1200,11 @@ static int insertBatchStmtExecute(STscStmt* pStmt) {
   // wait for the callback function to post the semaphore
   tsem_wait(&pStmt->pSql->rspSem);
 
+  code = pStmt->pSql->res.code;
+  
   insertBatchClean(pStmt);
 
-  return pStmt->pSql->res.code;
+  return code;
 }
 
 int stmtParseInsertTbTags(SSqlObj* pSql, STscStmt* pStmt) {
@@ -1647,7 +1649,11 @@ int taos_stmt_close(TAOS_STMT* stmt) {
   } else {
     if (pStmt->multiTbInsert) {
       taosHashCleanup(pStmt->mtb.pTableHash);
-      pStmt->mtb.pTableBlockHashList = tscDestroyBlockHashTable(pStmt->mtb.pTableBlockHashList, false);
+      bool rmMeta = false;
+      if (pStmt->pSql && pStmt->pSql->res.code != 0) {
+        rmMeta = true;
+      }
+      pStmt->mtb.pTableBlockHashList = tscDestroyBlockHashTable(pStmt->mtb.pTableBlockHashList, rmMeta);
       taosHashCleanup(pStmt->pSql->cmd.insertParam.pTableBlockHashList);
       pStmt->pSql->cmd.insertParam.pTableBlockHashList = NULL;
       taosArrayDestroy(pStmt->mtb.tags);

From 0d719ab43c3ef22932f7c99e5cffa4996ad25a31 Mon Sep 17 00:00:00 2001
From: Shenglian Zhou <shenglian_zhou@163.com>
Date: Tue, 13 Jul 2021 16:37:07 +0800
Subject: [PATCH 52/70] add log and free memory

---
 src/client/src/tscParseLineProtocol.c | 165 +++++++++++++++++++++-----
 tests/examples/c/apitest.c            |   9 +-
 2 files changed, 142 insertions(+), 32 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index 04b96dc52a..b657594db4 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -98,8 +98,12 @@ static int32_t getFieldBytesFromSmlKv(TAOS_SML_KV* kv, int32_t* bytes) {
     if (kv->type == TSDB_DATA_TYPE_NCHAR) {
       char* ucs = malloc(kv->length * TSDB_NCHAR_SIZE + 1);
       int32_t bytesNeeded = 0;
-      //todo check conversion succeed
-      taosMbsToUcs4(kv->value, kv->length, ucs, kv->length * TSDB_NCHAR_SIZE, &bytesNeeded);
+      bool succ = taosMbsToUcs4(kv->value, kv->length, ucs, kv->length * TSDB_NCHAR_SIZE, &bytesNeeded);
+      if (!succ) {
+        free(ucs);
+        tscError("convert nchar string to UCS4_LE failed:%s", kv->value);
+        return TSDB_CODE_TSC_INVALID_VALUE;
+      }
       free(ucs);
       *bytes =  bytesNeeded + VARSTR_HEADER_SIZE;
     } else if (kv->type == TSDB_DATA_TYPE_BINARY) {
@@ -112,17 +116,20 @@ static int32_t getFieldBytesFromSmlKv(TAOS_SML_KV* kv, int32_t* bytes) {
 static int32_t buildSmlKvSchema(TAOS_SML_KV* smlKv, SHashObj* hash, SArray* array) {
   SSchema* pField = NULL;
   SSchema** ppField = taosHashGet(hash, smlKv->key, strlen(smlKv->key));
+  int32_t code = 0;
   if (ppField) {
     pField = *ppField;
 
     if (pField->type != smlKv->type) {
-      //TODO:
-      tscError("type mismatch");
-      return -1;
+      tscError("type mismatch. key %s, type %d. type before %d", smlKv->key, smlKv->type, pField->type);
+      return TSDB_CODE_TSC_INVALID_VALUE;
     }
 
     int32_t bytes = 0;
-    getFieldBytesFromSmlKv(smlKv, &bytes);
+    code = getFieldBytesFromSmlKv(smlKv, &bytes);
+    if (code != 0) {
+      return code;
+    }
     pField->bytes = MAX(pField->bytes, bytes);
 
   } else {
@@ -133,7 +140,10 @@ static int32_t buildSmlKvSchema(TAOS_SML_KV* smlKv, SHashObj* hash, SArray* arra
     field.type = smlKv->type;
 
     int32_t bytes = 0;
-    getFieldBytesFromSmlKv(smlKv, &bytes);
+    code = getFieldBytesFromSmlKv(smlKv, &bytes);
+    if (code != 0) {
+      return code;
+    }
     field.bytes = bytes;
 
     pField = taosArrayPush(array, &field);
@@ -146,6 +156,7 @@ static int32_t buildSmlKvSchema(TAOS_SML_KV* smlKv, SHashObj* hash, SArray* arra
 }
 
 static int32_t buildDataPointSchemas(TAOS_SML_DATA_POINT* points, int numPoint, SArray* stableSchemas) {
+  int32_t code = 0;
   SHashObj* sname2shema = taosHashInit(32,
                                        taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
 
@@ -171,12 +182,20 @@ static int32_t buildDataPointSchemas(TAOS_SML_DATA_POINT* points, int numPoint,
 
     for (int j = 0; j < point->tagNum; ++j) {
       TAOS_SML_KV* tagKv = point->tags + j;
-      buildSmlKvSchema(tagKv, pStableSchema->tagHash, pStableSchema->tags);
+      code = buildSmlKvSchema(tagKv, pStableSchema->tagHash, pStableSchema->tags);
+      if (code != 0) {
+        tscError("build data point schema failed. point no.: %d, tag key: %s", i, tagKv->key);
+        return code;
+      }
     }
 
     for (int j = 0; j < point->fieldNum; ++j) {
       TAOS_SML_KV* fieldKv = point->fields + j;
-      buildSmlKvSchema(fieldKv, pStableSchema->fieldHash, pStableSchema->fields);
+      code = buildSmlKvSchema(fieldKv, pStableSchema->fieldHash, pStableSchema->fields);
+      if (code != 0) {
+        tscError("build data point schema failed. point no.: %d, tag key: %s", i, fieldKv->key);
+        return code;
+      }
     }
 
     point->schema = pStableSchema;
@@ -190,6 +209,13 @@ static int32_t buildDataPointSchemas(TAOS_SML_DATA_POINT* points, int numPoint,
   }
   taosHashCleanup(sname2shema);
 
+  tscDebug("build point schema succeed. num of super table: %zu", numStables);
+  for (int32_t i = 0; i < numStables; ++i) {
+    SSmlSTableSchema* schema = taosArrayGet(stableSchemas, i);
+    tscDebug("\ttable name: %s, tags number: %zu, fields number: %zu", schema->sTableName,
+             taosArrayGetSize(schema->tags), taosArrayGetSize(schema->fields));
+  }
+
   return 0;
 }
 
@@ -199,8 +225,9 @@ static int32_t generateSchemaAction(SSchema* pointColField, SHashObj* dbAttrHash
   if (ppDbAttr) {
     SSchema* dbAttr = *ppDbAttr;
     if (pointColField->type != dbAttr->type) {
-      //todo error
-      return -5;
+      tscError("point type and db type mismatch. key: %s. point type: %d, db type: %d", pointColField->name,
+               pointColField->type, dbAttr->type);
+      return TSDB_CODE_TSC_INVALID_VALUE;
     }
 
     if (IS_VAR_DATA_TYPE(pointColField->type) && (pointColField->bytes > dbAttr->bytes)) {
@@ -225,6 +252,7 @@ static int32_t generateSchemaAction(SSchema* pointColField, SHashObj* dbAttrHash
     action->alterSTable.field = pointColField;
     *actionNeeded = true;
   }
+  tscDebug("generate schema action. action needed: %d, action: %d", *actionNeeded, action->action);
   return 0;
 }
 
@@ -256,12 +284,14 @@ static int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
   int32_t outBytes = 0;
   char *result = (char *)calloc(1, capacity);
 
+  tscDebug("apply schema action: %d", action->action);
   switch (action->action) {
     case SCHEMA_ACTION_ADD_COLUMN: {
       int n = sprintf(result, "alter stable %s add column ", action->alterSTable.sTableName);
       buildColumnDescription(action->alterSTable.field, result+n, capacity-n, &outBytes);
       TAOS_RES* res = taos_query(taos, result); //TODO async doAsyncQuery
       code = taos_errno(res);
+      taos_free_result(res);
       break;
     }
     case SCHEMA_ACTION_ADD_TAG: {
@@ -270,6 +300,7 @@ static int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
                              result+n, capacity-n, &outBytes);
       TAOS_RES* res = taos_query(taos, result); //TODO async doAsyncQuery
       code = taos_errno(res);
+      taos_free_result(res);
       break;
     }
     case SCHEMA_ACTION_CHANGE_COLUMN_SIZE: {
@@ -278,6 +309,7 @@ static int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
                              capacity-n, &outBytes);
       TAOS_RES* res = taos_query(taos, result); //TODO async doAsyncQuery
       code = taos_errno(res);
+      taos_free_result(res);
       break;
     }
     case SCHEMA_ACTION_CHANGE_TAG_SIZE: {
@@ -286,6 +318,7 @@ static int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
                              capacity-n, &outBytes);
       TAOS_RES* res = taos_query(taos, result); //TODO async doAsyncQuery
       code = taos_errno(res);
+      taos_free_result(res);
       break;
     }
     case SCHEMA_ACTION_CREATE_STABLE: {
@@ -314,13 +347,18 @@ static int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
       outBytes = snprintf(pos, freeBytes, ")");
       TAOS_RES* res = taos_query(taos, result);
       code = taos_errno(res);
+      taos_free_result(res);
       break;
     }
 
     default:
       break;
   }
+
   free(result);
+  if (code != 0) {
+    tscError("apply schema action failure. %s", tstrerror(code));
+  }
   return code;
 }
 
@@ -341,11 +379,14 @@ int32_t loadTableMeta(TAOS* taos, char* tableName, SSmlSTableSchema* schema) {
     return TSDB_CODE_TSC_DISCONNECTED;
   }
 
+  tscDebug("load table schema. super table name: %s", tableName);
+
   char sql[256];
   snprintf(sql, 256, "describe %s", tableName);
   TAOS_RES* res = taos_query(taos, sql);
   code = taos_errno(res);
   if (code != 0) {
+    tscError("describe table failure. %s", taos_errstr(res));
     taos_free_result(res);
     return code;
   }
@@ -369,16 +410,13 @@ int32_t loadTableMeta(TAOS* taos, char* tableName, SSmlSTableSchema* schema) {
   if ((code = tscSetTableFullName(&sname, &tableToken, pSql)) != TSDB_CODE_SUCCESS) {
     return code;
   }
-
   char  fullTableName[TSDB_TABLE_FNAME_LEN] = {0};
   memset(fullTableName, 0, tListLen(fullTableName));
   tNameExtractFullName(&sname, fullTableName);
-
   if (code != TSDB_CODE_SUCCESS) {
     tscFreeSqlObj(pSql);
     return code;
   }
-
   tscFreeSqlObj(pSql);
 
   schema->tags = taosArrayInit(8, sizeof(SSchema));
@@ -410,6 +448,8 @@ int32_t loadTableMeta(TAOS* taos, char* tableName, SSmlSTableSchema* schema) {
     SSchema* pField = taosArrayPush(schema->tags, &field);
     taosHashPut(schema->tagHash, field.name, strlen(field.name), &pField, POINTER_BYTES);
   }
+  tscDebug("load table meta succeed. %s, columns number: %d, tag number: %d, precision: %d",
+           tableName, tableMeta->tableInfo.numOfColumns, tableMeta->tableInfo.numOfTags, schema->precision);
   free(tableMeta); tableMeta = NULL;
   return code;
 }
@@ -422,7 +462,6 @@ static int32_t reconcileDBSchemas(TAOS* taos, SArray* stableSchemas) {
     SSmlSTableSchema  dbSchema = {0};
 
     code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
-
     if (code == TSDB_CODE_MND_INVALID_TABLE_NAME) {
       SSchemaAction schemaAction = {0};
       schemaAction.action = SCHEMA_ACTION_CREATE_STABLE;
@@ -432,10 +471,12 @@ static int32_t reconcileDBSchemas(TAOS* taos, SArray* stableSchemas) {
       schemaAction.createSTable.fields = pointSchema->fields;
       applySchemaAction(taos, &schemaAction);
       code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
-
-      pointSchema->precision = dbSchema.precision;
-
-      destroySmlSTableSchema(&dbSchema);
+      if (code != 0) {
+        tscError("reconcile point schema failed. can not create %s", pointSchema->sTableName);
+      } else {
+        pointSchema->precision = dbSchema.precision;
+        destroySmlSTableSchema(&dbSchema);
+      }
     } else if (code == TSDB_CODE_SUCCESS) {
       size_t pointTagSize = taosArrayGetSize(pointSchema->tags);
       size_t pointFieldSize = taosArrayGetSize(pointSchema->fields);
@@ -471,6 +512,7 @@ static int32_t reconcileDBSchemas(TAOS* taos, SArray* stableSchemas) {
 
       destroySmlSTableSchema(&dbSchema);
     } else {
+      tscError("load table meta error: %s", tstrerror(code));
       return code;
     }
   }
@@ -496,11 +538,12 @@ static int32_t getChildTableName(TAOS_SML_DATA_POINT* point, char* tableName, in
   MD5Update(&context, (uint8_t *)keyJoined, (uint32_t)len);
   MD5Final(&context);
   *tableNameLen = snprintf(tableName, *tableNameLen,
-                           "tbl_%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", context.digest[0],
+                           "t_%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", context.digest[0],
                            context.digest[1], context.digest[2], context.digest[3], context.digest[4], context.digest[5], context.digest[6],
                            context.digest[7], context.digest[8], context.digest[9], context.digest[10], context.digest[11],
                            context.digest[12], context.digest[13], context.digest[14], context.digest[15]);
   taosStringBuilderDestroy(&sb);
+  tscDebug("child table name: %s", tableName);
   return 0;
 }
 
@@ -524,23 +567,25 @@ static int32_t creatChildTableIfNotExists(TAOS* taos, const char* cTableName, co
   }
   snprintf(sql + strlen(sql) - 1, freeBytes-strlen(sql)+1, ")");
 
+  tscDebug("create table : %s", sql);
+
   TAOS_STMT* stmt = taos_stmt_init(taos);
   int32_t code;
   code = taos_stmt_prepare(stmt, sql, strlen(sql));
   if (code != 0) {
-    printf("%s", taos_stmt_errstr(stmt));
+    tscError("%s", taos_stmt_errstr(stmt));
     return code;
   }
 
   code = taos_stmt_bind_param(stmt, TARRAY_GET_START(tagsBind));
   if (code != 0) {
-    printf("%s", taos_stmt_errstr(stmt));
+    tscError("%s", taos_stmt_errstr(stmt));
     return code;
   }
 
   code = taos_stmt_execute(stmt);
   if (code != 0) {
-    printf("%s", taos_stmt_errstr(stmt));
+    tscError("%s", taos_stmt_errstr(stmt));
     return code;
   }
 
@@ -565,6 +610,7 @@ static int32_t insertChildTableBatch(TAOS* taos,  char* cTableName, SArray* cols
   }
   snprintf(sql + strlen(sql)-1, freeBytes-strlen(sql)+1, ")");
 
+  tscDebug("insert rows %zu into child table %s. ", taosArrayGetSize(rowsBind), cTableName);
   int32_t code = 0;
   int32_t try = 0;
   do {
@@ -572,13 +618,13 @@ static int32_t insertChildTableBatch(TAOS* taos,  char* cTableName, SArray* cols
 
     code = taos_stmt_prepare(stmt, sql, strlen(sql));
     if (code != 0) {
-      printf("%s", taos_stmt_errstr(stmt));
+      tscError("%s", taos_stmt_errstr(stmt));
       return code;
     }
 
     code = taos_stmt_set_tbname(stmt, cTableName);
     if (code != 0) {
-      printf("%s", taos_stmt_errstr(stmt));
+      tscError("%s", taos_stmt_errstr(stmt));
       return code;
     }
 
@@ -587,19 +633,19 @@ static int32_t insertChildTableBatch(TAOS* taos,  char* cTableName, SArray* cols
       TAOS_BIND* colsBinds = taosArrayGetP(rowsBind, i);
       code = taos_stmt_bind_param(stmt, colsBinds);
       if (code != 0) {
-        printf("%s", taos_stmt_errstr(stmt));
+        tscError("%s", taos_stmt_errstr(stmt));
         return code;
       }
       code = taos_stmt_add_batch(stmt);
       if (code != 0) {
-        printf("%s", taos_stmt_errstr(stmt));
+        tscError("%s", taos_stmt_errstr(stmt));
         return code;
       }
     }
 
     code = taos_stmt_execute(stmt);
     if (code != 0) {
-      printf("%s", taos_stmt_errstr(stmt));
+      tscError("%s", taos_stmt_errstr(stmt));
       taos_stmt_close(stmt);
     } else {
       taos_stmt_close(stmt);
@@ -722,6 +768,7 @@ static int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t num
         TAOS_BIND* bind = colBinds + j;
         free(bind->length);
       }
+      free(colBinds);
     }
     taosArrayDestroy(rowsBind);
     taosArrayDestroy(cTablePoints);
@@ -734,6 +781,8 @@ static int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t num
 }
 
 int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
+  tscDebug("taos_sml_insert. number of points: %d", numPoint);
+
   int32_t code = TSDB_CODE_SUCCESS;
 
   SArray* stableSchemas = taosArrayInit(32, sizeof(SSmlSTableSchema)); // SArray<STableColumnsSchema>
@@ -846,6 +895,30 @@ int32_t parseItemValue(SLPItem* item, LPItemKind kind) {
       item->value = malloc(item->length);
       char* endptr = NULL;
       *(int64_t*)(item->value) = strtoll(sv, &endptr, 10);
+    } else if (*last == 'b') {
+      item->type = TSDB_DATA_TYPE_TINYINT;
+      item->length = (int16_t)tDataTypes[item->type].bytes;
+      item->value = malloc(item->length);
+      char* endptr = NULL;
+      *(int8_t*)(item->value) = strtoll(sv, &endptr, 10);
+    } else if (*last == 's') {
+      item->type = TSDB_DATA_TYPE_SMALLINT;
+      item->length = (int16_t)tDataTypes[item->type].bytes;
+      item->value = malloc(item->length);
+      char* endptr = NULL;
+      *(int16_t*)(item->value) = strtoll(sv, &endptr, 10);
+    } else if (*last == 'w') {
+      item->type = TSDB_DATA_TYPE_INT;
+      item->length = (int16_t)tDataTypes[item->type].bytes;
+      item->value = malloc(item->length);
+      char* endptr = NULL;
+      *(int32_t*)(item->value) = strtoll(sv, &endptr, 10);
+    } else if (*last == 'f') {
+      item->type = TSDB_DATA_TYPE_FLOAT;
+      item->length = (int16_t)tDataTypes[item->type].bytes;
+      item->value = malloc(item->length);
+      char* endptr = NULL;
+      *(float*)(item->value) = strtold(sv, &endptr);
     } else {
       item->type = TSDB_DATA_TYPE_DOUBLE;
       item->length = (int16_t)tDataTypes[item->type].bytes;
@@ -1001,6 +1074,36 @@ int32_t tscParseLines(char* lines[], int numLines, SArray* points, SArray* faile
   return 0;
 }
 
+void destroyLPPoint(void* p) {
+  SLPPoint* lpPoint = p;
+  for (int i=0; i<taosArrayGetSize(lpPoint->fields); ++i) {
+    SLPItem* item = taosArrayGet(lpPoint->fields, i);
+    free(item->value);
+  }
+  taosArrayDestroy(lpPoint->fields);
+
+  for (int i=0; i<taosArrayGetSize(lpPoint->tags); ++i) {
+    SLPItem* item = taosArrayGet(lpPoint->tags, i);
+    free(item->value);
+  }
+  taosArrayDestroy(lpPoint->tags);
+}
+
+void destroySmlDataPoint(TAOS_SML_DATA_POINT* point) {
+  for (int i=0; i<point->tagNum; ++i) {
+    free((point->tags+i)->key);
+    free((point->tags+i)->value);
+  }
+  free(point->tags);
+  for (int i=0; i<point->fieldNum; ++i) {
+    free((point->fields+i)->key);
+    free((point->fields+i)->value);
+  }
+  free(point->fields);
+  free(point->stableName);
+  free(point->childTableName);
+}
+
 int taos_insert_by_lines(TAOS* taos, char* lines[], int numLines) {
   SArray* lpPoints = taosArrayInit(numLines, sizeof(SLPPoint));
   tscParseLines(lines, numLines, lpPoints, NULL);
@@ -1065,6 +1168,12 @@ int taos_insert_by_lines(TAOS* taos, char* lines[], int numLines) {
   }
 
   taos_sml_insert(taos, points, numPoints);
+
+  for (int i=0; i<numPoints; ++i) {
+    destroySmlDataPoint(points+i);
+  }
+  free(points);
+  taosArrayDestroyEx(lpPoints, destroyLPPoint);
   return 0;
 }
 
diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index e7d4b087f7..4f9c890839 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -968,12 +968,13 @@ int32_t verify_schema_less(TAOS* taos) {
       "st,t1=4i,t3=\"t4\",t2=5,t4=5 c1=3i,c3=L\"passitagin\",c2=true,c4=5,c5=5 1626006833640000000",
       "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833642000000",
       "ste,t2=5,t3=L\"ste\" c1=true,c2=4,c3=\"iam\" 1626056811823316532",
-      "ste,t2=5,t3=L\"ste2\" c3=\"iamszhou\",c4=false 1626056811843316532"
+      "ste,t2=5,t3=L\"ste2\" c3=\"iamszhou\",c4=false 1626056811843316532",
+      "ste,t2=5,t3=L\"ste2\" c3=\"iamszhou\",c4=false,c5=32b,c6=64s,c7=32w,c8=88.88f 1626056812843316532"
   };
 
-  // int code = taos_insert_by_lines(taos, lines , 5);
-  int code = taos_insert_by_lines(taos, &lines[0], 1);
-  code = taos_insert_by_lines(taos, &lines[1], 1);
+  int code = taos_insert_by_lines(taos, lines , 6);
+//  int code = taos_insert_by_lines(taos, &lines[0], 1);
+//  code = taos_insert_by_lines(taos, &lines[1], 1);
 
   return code;
 }

From 81b60d96f1867d2ee90f87eceb6c17c3d0978722 Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Tue, 13 Jul 2021 17:34:06 +0800
Subject: [PATCH 53/70] show crash

---
 tests/examples/c/apitest.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index 4f9c890839..376b00ef71 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -972,9 +972,9 @@ int32_t verify_schema_less(TAOS* taos) {
       "ste,t2=5,t3=L\"ste2\" c3=\"iamszhou\",c4=false,c5=32b,c6=64s,c7=32w,c8=88.88f 1626056812843316532"
   };
 
-  int code = taos_insert_by_lines(taos, lines , 6);
-//  int code = taos_insert_by_lines(taos, &lines[0], 1);
-//  code = taos_insert_by_lines(taos, &lines[1], 1);
+  //int code = taos_insert_by_lines(taos, lines , 6);
+  int code = taos_insert_by_lines(taos, &lines[0], 1);
+  code = taos_insert_by_lines(taos, &lines[1], 1);
 
   return code;
 }

From a065d6a3579476cb3f28254ccc9ff80a63cf8ef8 Mon Sep 17 00:00:00 2001
From: Elias Soong <elias.soong@gmail.com>
Date: Tue, 13 Jul 2021 18:00:24 +0800
Subject: [PATCH 54/70] [TD-4905] <docs>: describe "INSERT INTO FILE" and
 restructured document about INSERT grammar.

---
 documentation20/cn/12.taos-sql/docs.md | 107 +++++++++++++------------
 1 file changed, 56 insertions(+), 51 deletions(-)

diff --git a/documentation20/cn/12.taos-sql/docs.md b/documentation20/cn/12.taos-sql/docs.md
index e7541bb877..73fa5b34e5 100644
--- a/documentation20/cn/12.taos-sql/docs.md
+++ b/documentation20/cn/12.taos-sql/docs.md
@@ -362,77 +362,82 @@ TDengine 缺省的时间戳是毫秒精度，但通过在 CREATE DATABASE 时传
 
 ## <a class="anchor" id="insert"></a>数据写入
 
-- **插入一条记录**
-    ```mysql
-    INSERT INTO tb_name VALUES (field_value, ...);
-    ```
-    向表tb_name中插入一条记录。
+### 写入语法：
 
-- **插入一条记录，数据对应到指定的列**
-    ```mysql
-    INSERT INTO tb_name (field1_name, ...) VALUES (field1_value1, ...);
-    ```
-    向表tb_name中插入一条记录，数据对应到指定的列。SQL语句中没有出现的列，数据库将自动填充为NULL。主键（时间戳）不能为NULL。
+```mysql
+INSERT INTO
+    tb_name
+        [USING stb_name [(tag1_name, ...)] TAGS (tag1_value, ...)]
+        [(field1_name, ...)]
+        VALUES (field1_value, ...) [(field1_value2, ...) ...] | FILE csv_file_path
+    [tb2_name
+        [USING stb_name [(tag1_name, ...)] TAGS (tag1_value, ...)]
+        [(field1_name, ...)]
+        VALUES (field1_value, ...) [(field1_value2, ...) ...] | FILE csv_file_path
+    ...];
+```
 
-- **插入多条记录**
-    ```mysql
-    INSERT INTO tb_name VALUES (field1_value1, ...) (field1_value2, ...) ...;
-    ```
-    向表tb_name中插入多条记录。  
-    **注意**：在使用“插入多条记录”方式写入数据时，不能把第一列的时间戳取值都设为now，否则会导致语句中的多条记录使用相同的时间戳，于是就可能出现相互覆盖以致这些数据行无法全部被正确保存。
+### 详细描述及示例：
 
-- **按指定的列插入多条记录**
+- **插入一条或多条记录**  
+    指定已经创建好的数据子表的表名，并通过 VALUES 关键字提供一行或多行数据，即可向数据库写入这些数据。例如，执行如下语句可以写入一行记录：
     ```mysql
-    INSERT INTO tb_name (field1_name, ...) VALUES (field1_value1, ...) (field1_value2, ...) ...;
+    INSERT INTO d1001 VALUES (NOW, 10.2, 219, 0.32);
     ```
-    向表tb_name中按指定的列插入多条记录。
+    或者，可以通过如下语句写入两行记录：  
+    ```mysql
+    INSERT INTO d1001 VALUES ('2021-07-13 14:06:32.272', 10.2, 219, 0.32) (1626164208000, 10.15, 217, 0.33);
+    ```
+    **注意：**  
+    1）在第二个例子中，两行记录的首列时间戳使用了不同格式的写法。其中字符串格式的时间戳写法不受所在 DATABASE 的时间精度设置影响；而长整形格式的时间戳写法会受到所在 DATABASE 的时间精度设置影响——例子中的时间戳在毫秒精度下可以写作 1626164208000，而如果是在微秒精度设置下就需要写为 1626164208000000。  
+    2）在使用“插入多条记录”方式写入数据时，不能把第一列的时间戳取值都设为 NOW，否则会导致语句中的多条记录使用相同的时间戳，于是就可能出现相互覆盖以致这些数据行无法全部被正确保存。其原因在于，NOW 函数在执行中会被解析为所在 SQL 语句的实际执行时间，出现在同一语句中的多个 NOW 标记也就会被替换为完全相同的时间戳取值。  
+    3）允许插入的最老记录的时间戳，是相对于当前服务器时间，减去配置的 keep 值（数据保留的天数）；允许插入的最新记录的时间戳，是相对于当前服务器时间，加上配置的 days 值（数据文件存储数据的时间跨度，单位为天）。keep 和 days 都是可以在创建数据库时指定的，缺省值分别是 3650 天和 10 天。
 
-- **向多个表插入多条记录**
+- **插入记录，数据对应到指定的列**  
+    向数据子表中插入记录时，无论插入一行还是多行，都可以让数据对应到指定的列。对于 SQL 语句中没有出现的列，数据库将自动填充为 NULL。主键（时间戳）不能为 NULL。例如：
     ```mysql
-    INSERT INTO tb1_name VALUES (field1_value1, ...) (field1_value2, ...) ...
-                tb2_name VALUES (field1_value1, ...) (field1_value2, ...) ...;
+    INSERT INTO d1001 (ts, current, phase) VALUES ('2021-07-13 14:06:33.196', 10.27, 0.31);
     ```
-    同时向表tb1_name和tb2_name中分别插入多条记录。
+    **说明：**如果不指定列，也即使用全列模式——那么在 VALUES 部分提供的数据，必须为数据表的每个列都显式地提供数据。全列模式写入速度会远快于指定列，因此建议尽可能采用全列写入方式，此时空列可以填入 NULL。
 
-- **同时向多个表按列插入多条记录**
+- **向多个表插入记录**  
+    可以在一条语句中，分别向多个表插入一条或多条记录，并且也可以在插入过程中指定列。例如：
     ```mysql
-    INSERT INTO tb1_name (tb1_field1_name, ...) VALUES (field1_value1, ...) (field1_value2, ...) ...
-                tb2_name (tb2_field1_name, ...) VALUES (field1_value1, ...) (field1_value2, ...) ...;
+    INSERT INTO d1001 VALUES ('2021-07-13 14:06:34.630', 10.2, 219, 0.32) ('2021-07-13 14:06:35.779', 10.15, 217, 0.33)
+                d1002 (ts, current, phase) VALUES ('2021-07-13 14:06:34.255', 10.27, 0.31）;
     ```
-    同时向表tb1_name和tb2_name中按列分别插入多条记录。  
 
-    注意：  
-    1) 如果时间戳为now，系统将自动使用客户端当前时间作为该记录的时间戳；  
-    2) 允许插入的最老记录的时间戳，是相对于当前服务器时间，减去配置的keep值（数据保留的天数），允许插入的最新记录的时间戳，是相对于当前服务器时间，加上配置的days值（数据文件存储数据的时间跨度，单位为天）。keep和days都是可以在创建数据库时指定的，缺省值分别是3650天和10天。
+- <a class="anchor" id="auto_create_table"></a>**插入记录时自动建表**  
+    如果用户在写数据时并不确定某个表是否存在，此时可以在写入数据时使用自动建表语法来创建不存在的表，若该表已存在则不会建立新表。自动建表时，要求必须以超级表为模板，并写明数据表的 TAGS 取值。例如：  
+    ```mysql
+    INSERT INTO d21001 USING meters TAGS ('Beijing.Chaoyang', 2) VALUES ('2021-07-13 14:06:32.272', 10.2, 219, 0.32);
+    ```
+    也可以在自动建表时，只是指定部分 TAGS 列的取值，未被指定的 TAGS 列将置为 NULL。例如：  
+    ```mysql
+    INSERT INTO d21001 USING meters (groupdId) TAGS (2) VALUES ('2021-07-13 14:06:33.196', 10.15, 217, 0.33);
+    ```
+    自动建表语法也支持在一条语句中向多个表插入记录。例如：  
+    ```mysql
+    INSERT INTO d21001 USING meters TAGS ('Beijing.Chaoyang', 2) VALUES ('2021-07-13 14:06:34.630', 10.2, 219, 0.32) ('2021-07-13 14:06:35.779', 10.15, 217, 0.33)
+                d21002 USING meters (groupdId) TAGS (2) VALUES ('2021-07-13 14:06:34.255', 10.15, 217, 0.33)
+                d21003 USING meters (groupdId) TAGS (2) (ts, current, phase) VALUES ('2021-07-13 14:06:34.255', 10.27, 0.31);
+    ```
+    **说明：**在 2.0.20.5 版本之前，在使用自动建表语法并指定列时，子表的列名必须紧跟在子表名称后面，而不能如例子里那样放在 TAGS 和 VALUES 之间。从 2.0.20.5 版本开始，两种写法都可以，但不能在一条 SQL 语句中混用，否则会报语法错误。
 
-- <a class="anchor" id="auto_create_table"></a>**插入记录时自动建表**
-    ```mysql
-    INSERT INTO tb_name USING stb_name TAGS (tag_value1, ...) VALUES (field_value1, ...);
+- **插入来自文件的数据记录**  
+    除了使用 VALUES 关键字插入一行或多行数据外，也可以把要写入的数据放在 CSV 文件中（英文逗号分隔、英文单引号括住每个值）供 SQL 指令读取。其中 CSV 文件无需表头。例如，如果 /tmp/csvfile.csv 文件的内容为：  
     ```
-    如果用户在写数据时并不确定某个表是否存在，此时可以在写入数据时使用自动建表语法来创建不存在的表，若该表已存在则不会建立新表。自动建表时，要求必须以超级表为模板，并写明数据表的 TAGS 取值。
-
-- **插入记录时自动建表，并指定具体的 TAGS 列**
-    ```mysql
-    INSERT INTO tb_name USING stb_name (tag_name1, ...) TAGS (tag_value1, ...) VALUES (field_value1, ...);
+    '2021-07-13 14:07:34.630', '10.2', '219', '0.32'
+    '2021-07-13 14:07:35.779', '10.15', '217', '0.33'
     ```
-    在自动建表时，可以只是指定部分 TAGS 列的取值，未被指定的 TAGS 列将取为空值。
-
-- **同时向多个表按列插入多条记录，自动建表**
+    那么通过如下指令可以把这个文件中的数据写入子表中：  
     ```mysql
-    INSERT INTO tb1_name (tb1_field1_name, ...) [USING stb1_name TAGS (tag_value1, ...)] VALUES (field1_value1, ...) (field1_value2, ...) ...
-                tb2_name (tb2_field1_name, ...) [USING stb2_name TAGS (tag_value2, ...)] VALUES (field1_value1, ...) (field1_value2, ...) ...;
+    INSERT INTO d1001 FILE '/tmp/csvfile.csv';
     ```
-    以自动建表的方式，同时向表tb1_name和tb2_name中按列分别插入多条记录。  
-    说明：`(tb1_field1_name, ...)`的部分可以省略掉，这样就是使用全列模式写入——也即在 VALUES 部分提供的数据，必须为数据表的每个列都显式地提供数据。全列写入速度会远快于指定列，因此建议尽可能采用全列写入方式，此时空列可以填入NULL。  
-    从 2.0.20.5 版本开始，子表的列名可以不跟在子表名称后面，而是可以放在 TAGS 和 VALUES 之间，例如像下面这样写：
-    ```mysql
-    INSERT INTO tb1_name [USING stb1_name TAGS (tag_value1, ...)] (tb1_field1_name, ...) VALUES (field1_value1, ...) (field1_value2, ...) ...;
-    ```
-    注意：虽然两种写法都可以，但并不能在一条 SQL 语句中混用，否则会报语法错误。
 
 **历史记录写入**：可使用IMPORT或者INSERT命令，IMPORT的语法，功能与INSERT完全一样。
 
-说明：针对 insert 类型的 SQL 语句，我们采用的流式解析策略，在发现后面的错误之前，前面正确的部分SQL仍会执行。下面的sql中，insert语句是无效的，但是d1001仍会被创建。
+**说明：**针对 insert 类型的 SQL 语句，我们采用的流式解析策略，在发现后面的错误之前，前面正确的部分 SQL 仍会执行。下面的 SQL 中，INSERT 语句是无效的，但是 d1001 仍会被创建。
 
 ```mysql
 taos> CREATE TABLE meters(ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS(location BINARY(30), groupId INT);

From 153b5d7115e6eb157e3b8639e3b716ee1c1a0faa Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Tue, 13 Jul 2021 21:37:22 +0800
Subject: [PATCH 55/70] pass pr build check

---
 src/client/src/tscParseLineProtocol.c | 62 ++++++++++++++++-----------
 1 file changed, 36 insertions(+), 26 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index a3bb7c6f15..a198a7b42a 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -324,7 +324,7 @@ static int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
     case SCHEMA_ACTION_CREATE_STABLE: {
       int n = sprintf(result, "create stable %s (", action->createSTable.sTableName);
       char* pos = result + n; int freeBytes = capacity - n;
-      int numCols = taosArrayGetSize(action->createSTable.fields);
+      size_t numCols = taosArrayGetSize(action->createSTable.fields);
       for (int32_t i = 0; i < numCols; ++i) {
         SSchema* field = taosArrayGet(action->createSTable.fields, i);
         buildColumnDescription(field, pos, freeBytes, &outBytes);
@@ -336,7 +336,7 @@ static int32_t applySchemaAction(TAOS* taos, SSchemaAction* action) {
       outBytes = snprintf(pos, freeBytes, ") tags (");
       pos += outBytes; freeBytes -= outBytes;
 
-      int numTags = taosArrayGetSize(action->createSTable.tags);
+      size_t numTags = taosArrayGetSize(action->createSTable.tags);
       for (int32_t i = 0; i < numTags; ++i) {
         SSchema* field = taosArrayGet(action->createSTable.tags, i);
         buildColumnDescription(field, pos, freeBytes, &outBytes);
@@ -397,7 +397,7 @@ int32_t loadTableMeta(TAOS* taos, char* tableName, SSmlSTableSchema* schema) {
   pSql->signature = pSql;
   pSql->fp = NULL;
 
-  SStrToken tableToken = {.z=tableName, .n=strlen(tableName), .type=TK_ID};
+  SStrToken tableToken = {.z=tableName, .n=(uint32_t)strlen(tableName), .type=TK_ID};
   tGetToken(tableName, &tableToken.type);
   // Check if the table name available or not
   if (tscValidateName(&tableToken) != TSDB_CODE_SUCCESS) {
@@ -459,7 +459,8 @@ static int32_t reconcileDBSchemas(TAOS* taos, SArray* stableSchemas) {
   size_t numStable = taosArrayGetSize(stableSchemas);
   for (int i = 0; i < numStable; ++i) {
     SSmlSTableSchema* pointSchema = taosArrayGet(stableSchemas, i);
-    SSmlSTableSchema  dbSchema = {0};
+    SSmlSTableSchema  dbSchema;
+    memset(&dbSchema, 0, sizeof(SSmlSTableSchema));
 
     code = loadTableMeta(taos, pointSchema->sTableName, &dbSchema);
     if (code == TSDB_CODE_MND_INVALID_TABLE_NAME) {
@@ -571,7 +572,7 @@ static int32_t creatChildTableIfNotExists(TAOS* taos, const char* cTableName, co
 
   TAOS_STMT* stmt = taos_stmt_init(taos);
   int32_t code;
-  code = taos_stmt_prepare(stmt, sql, strlen(sql));
+  code = taos_stmt_prepare(stmt, sql, (unsigned long)strlen(sql));
   if (code != 0) {
     tscError("%s", taos_stmt_errstr(stmt));
     return code;
@@ -617,7 +618,7 @@ static int32_t insertChildTableBatch(TAOS* taos,  char* cTableName, SArray* cols
 
   TAOS_STMT* stmt = taos_stmt_init(taos);
   
-  code = taos_stmt_prepare(stmt, sql, strlen(sql));
+  code = taos_stmt_prepare(stmt, sql, (unsigned long)strlen(sql));
   if (code != 0) {
     tscError("%s", taos_stmt_errstr(stmt));
     return code;
@@ -717,8 +718,8 @@ static int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t num
     SArray* cTablePoints = *pCTablePoints;
 
     TAOS_SML_DATA_POINT * point = taosArrayGetP(cTablePoints, 0);
-    int32_t numTags = taosArrayGetSize(point->schema->tags);
-    int32_t numCols = taosArrayGetSize(point->schema->fields);
+    size_t numTags = taosArrayGetSize(point->schema->tags);
+    size_t numCols = taosArrayGetSize(point->schema->fields);
 
     SArray* tagBinds = taosArrayInit(numTags, sizeof(TAOS_BIND));
     taosArraySetSize(tagBinds, numTags);
@@ -728,7 +729,7 @@ static int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t num
     }
     for (int j = 0; j < point->tagNum; ++j) {
       TAOS_SML_KV* kv =  point->tags + j;
-      int32_t idx = TARRAY_ELEM_IDX(point->schema->tags, kv->schema);
+      size_t idx = TARRAY_ELEM_IDX(point->schema->tags, kv->schema);
       TAOS_BIND* bind = taosArrayGet(tagBinds, idx);
       bind->buffer_type = kv->type;
       bind->length = malloc(sizeof(uintptr_t*));
@@ -750,7 +751,7 @@ static int32_t insertPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t num
       }
       for (int j = 0; j < point->fieldNum; ++j) {
         TAOS_SML_KV* kv = point->fields + j;
-        int32_t idx = TARRAY_ELEM_IDX(point->schema->fields, kv->schema);
+        size_t idx = TARRAY_ELEM_IDX(point->schema->fields, kv->schema);
         TAOS_BIND* bind = colBinds + idx;
         bind->buffer_type = kv->type;
         bind->length = malloc(sizeof(uintptr_t*));
@@ -793,10 +794,24 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
   int32_t code = TSDB_CODE_SUCCESS;
 
   SArray* stableSchemas = taosArrayInit(32, sizeof(SSmlSTableSchema)); // SArray<STableColumnsSchema>
-  buildDataPointSchemas(points, numPoint, stableSchemas);
-  reconcileDBSchemas(taos, stableSchemas);
-  insertPoints(taos, points, numPoint);
+  code = buildDataPointSchemas(points, numPoint, stableSchemas);
+  if (code != 0) {
+    tscError("error building data point schemas : %s", tstrerror(code));
+    goto clean_up;
+  }
 
+  code = reconcileDBSchemas(taos, stableSchemas);
+  if (code != 0) {
+    tscError("error change db schema : %s", tstrerror(code));
+    goto clean_up;
+  }
+
+  code = insertPoints(taos, points, numPoint);
+  if (code != 0) {
+    tscError("error insert points : %s", tstrerror(code));
+  }
+
+clean_up:
   for (int i = 0; i < taosArrayGetSize(stableSchemas); ++i) {
     SSmlSTableSchema* schema = taosArrayGet(stableSchemas, i);
     taosArrayDestroy(schema->fields);
@@ -806,11 +821,6 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
   return code;
 }
 
-
-//todo: table/column length check
-//todo: type check
-//todo: taosmbs2ucs4 check
-
 //=========================================================================
 
 typedef enum {
@@ -907,25 +917,25 @@ int32_t parseItemValue(SLPItem* item, LPItemKind kind) {
       item->length = (int16_t)tDataTypes[item->type].bytes;
       item->value = malloc(item->length);
       char* endptr = NULL;
-      *(int8_t*)(item->value) = strtoll(sv, &endptr, 10);
+      *(int8_t*)(item->value) = (int8_t)strtoll(sv, &endptr, 10);
     } else if (*last == 's') {
       item->type = TSDB_DATA_TYPE_SMALLINT;
       item->length = (int16_t)tDataTypes[item->type].bytes;
       item->value = malloc(item->length);
       char* endptr = NULL;
-      *(int16_t*)(item->value) = strtoll(sv, &endptr, 10);
+      *(int16_t*)(item->value) = (int16_t)strtoll(sv, &endptr, 10);
     } else if (*last == 'w') {
       item->type = TSDB_DATA_TYPE_INT;
       item->length = (int16_t)tDataTypes[item->type].bytes;
       item->value = malloc(item->length);
       char* endptr = NULL;
-      *(int32_t*)(item->value) = strtoll(sv, &endptr, 10);
+      *(int32_t*)(item->value) = (int32_t)strtoll(sv, &endptr, 10);
     } else if (*last == 'f') {
       item->type = TSDB_DATA_TYPE_FLOAT;
       item->length = (int16_t)tDataTypes[item->type].bytes;
       item->value = malloc(item->length);
       char* endptr = NULL;
-      *(float*)(item->value) = strtold(sv, &endptr);
+      *(float*)(item->value) = (float)strtold(sv, &endptr);
     } else {
       item->type = TSDB_DATA_TYPE_DOUBLE;
       item->length = (int16_t)tDataTypes[item->type].bytes;
@@ -1073,7 +1083,7 @@ int32_t tscParseLine(SStrToken line, SLPPoint* point) {
 
 int32_t tscParseLines(char* lines[], int numLines, SArray* points, SArray* failedLines) {
   for (int32_t i = 0; i < numLines; ++i) {
-    SStrToken tkLine = {.z = lines[i], .n = strlen(lines[i])+1};
+    SStrToken tkLine = {.z = lines[i], .n = (uint32_t)strlen(lines[i])+1};
     SLPPoint point;
     tscParseLine(tkLine, &point);
     taosArrayPush(points, &point);
@@ -1126,7 +1136,7 @@ int taos_insert_by_lines(TAOS* taos, char* lines[], int numLines) {
 
     size_t lpTagSize = taosArrayGetSize(lpPoint->tags);
     point->tags = calloc(lpTagSize, sizeof(TAOS_SML_KV));
-    point->tagNum = lpTagSize;
+    point->tagNum = (int)lpTagSize;
     for (int j=0; j<lpTagSize; ++j) {
       SLPItem* lpTag = taosArrayGet(lpPoint->tags, j);
       TAOS_SML_KV* tagKv = point->tags + j;
@@ -1144,7 +1154,7 @@ int taos_insert_by_lines(TAOS* taos, char* lines[], int numLines) {
 
     size_t lpFieldsSize = taosArrayGetSize(lpPoint->fields);
     point->fields = calloc(lpFieldsSize + 1, sizeof(TAOS_SML_KV));
-    point->fieldNum = lpFieldsSize + 1;
+    point->fieldNum = (int)(lpFieldsSize + 1);
 
     TAOS_SML_KV* tsField = point->fields + 0;
     char tsKey[256];
@@ -1174,7 +1184,7 @@ int taos_insert_by_lines(TAOS* taos, char* lines[], int numLines) {
     }
   }
 
-  taos_sml_insert(taos, points, numPoints);
+  taos_sml_insert(taos, points, (int)numPoints);
 
   for (int i=0; i<numPoints; ++i) {
     destroySmlDataPoint(points+i);

From 36f0b8a648a8b577937e5248f9e95f29dc5a1251 Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Tue, 13 Jul 2021 22:41:04 +0800
Subject: [PATCH 56/70] add more data type

---
 src/client/src/tscParseLineProtocol.c | 18 +++++++++++++++++-
 tests/examples/c/apitest.c            |  9 ++++++---
 2 files changed, 23 insertions(+), 4 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index a198a7b42a..9f86d780d3 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -912,6 +912,12 @@ int32_t parseItemValue(SLPItem* item, LPItemKind kind) {
       item->value = malloc(item->length);
       char* endptr = NULL;
       *(int64_t*)(item->value) = strtoll(sv, &endptr, 10);
+    } else if (*last == 'u') {
+      item->type = TSDB_DATA_TYPE_UBIGINT;
+      item->length = (int16_t)tDataTypes[item->type].bytes;
+      item->value = malloc(item->length);
+      char* endptr = NULL;
+      *(uint64_t*)(item->value) = (uint64_t)strtoull(sv, &endptr, 10);
     } else if (*last == 'b') {
       item->type = TSDB_DATA_TYPE_TINYINT;
       item->length = (int16_t)tDataTypes[item->type].bytes;
@@ -989,6 +995,16 @@ int32_t parsePointTime(SLPPoint* point) {
   } else {
     char* endptr = NULL;
     point->ts = strtoll(point->tsToken.z, &endptr, 10);
+    char* last = point->tsToken.z + point->tsToken.n - 1;
+    if (*last == 's') {
+      point->ts *= (int64_t)1e9;
+    } else if (*last == 'a') {
+      point->ts *= (int64_t)1e6;
+    } else if (*last == 'u') {
+      point->ts *= (int64_t)1e3;
+    } else if (*last == 'b') {
+      point->ts *= 1;
+    }
   }
   return 0;
 }
@@ -1083,7 +1099,7 @@ int32_t tscParseLine(SStrToken line, SLPPoint* point) {
 
 int32_t tscParseLines(char* lines[], int numLines, SArray* points, SArray* failedLines) {
   for (int32_t i = 0; i < numLines; ++i) {
-    SStrToken tkLine = {.z = lines[i], .n = (uint32_t)strlen(lines[i])+1};
+    SStrToken tkLine = {.z = lines[i], .n = (uint32_t)strlen(lines[i])};
     SLPPoint point;
     tscParseLine(tkLine, &point);
     taosArrayPush(points, &point);
diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index 376b00ef71..ed76e7b2b0 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -966,13 +966,16 @@ int32_t verify_schema_less(TAOS* taos) {
   char* lines[] = {
       "st,t1=3i,t2=4,t3=\"t3\" c1=3i,c3=L\"passit\",c2=false,c4=4 1626006833639000000",
       "st,t1=4i,t3=\"t4\",t2=5,t4=5 c1=3i,c3=L\"passitagin\",c2=true,c4=5,c5=5 1626006833640000000",
-      "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833642000000",
       "ste,t2=5,t3=L\"ste\" c1=true,c2=4,c3=\"iam\" 1626056811823316532",
+      "st,t1=4i,t2=5,t3=\"t4\" c1=3i,c3=L\"passitagain\",c2=true,c4=5 1626006833642000000",
       "ste,t2=5,t3=L\"ste2\" c3=\"iamszhou\",c4=false 1626056811843316532",
-      "ste,t2=5,t3=L\"ste2\" c3=\"iamszhou\",c4=false,c5=32b,c6=64s,c7=32w,c8=88.88f 1626056812843316532"
+      "ste,t2=5,t3=L\"ste2\" c3=\"iamszhou\",c4=false,c5=32b,c6=64s,c7=32w,c8=88.88f 1626056812843316532",
+      "st,t1=4i,t3=\"t4\",t2=5,t4=5 c1=3i,c3=L\"passitagin\",c2=true,c4=5,c5=5,c6=7u 1626006933640000000",
+      "stf,t1=4i,t3=\"t4\",t2=5,t4=5 c1=3i,c3=L\"passitagin\",c2=true,c4=5,c5=5,c6=7u 1626006933640000000",
+      "stf,t1=4i,t3=\"t4\",t2=5,t4=5 c1=3i,c3=L\"passitagin_stf\",c2=false,c5=5,c6=7u 1626006933641a"
   };
 
-  //int code = taos_insert_by_lines(taos, lines , 6);
+//  int code = taos_insert_by_lines(taos, lines , sizeof(lines)/sizeof(char*));
   int code = taos_insert_by_lines(taos, &lines[0], 1);
   code = taos_insert_by_lines(taos, &lines[1], 1);
 

From 6b404cd1cee243b63f5a32324f1c277094f73f20 Mon Sep 17 00:00:00 2001
From: shenglian zhou <slzhou@taosdata.com>
Date: Wed, 14 Jul 2021 07:48:55 +0800
Subject: [PATCH 57/70] change api function name taos_insert_by_lines to
 taos_insert_lines

---
 src/client/src/tscParseLineProtocol.c | 12 +++++++-----
 src/inc/taos.h                        |  2 +-
 tests/examples/c/apitest.c            |  6 +++---
 tests/tsim/src/simExe.c               |  4 ++--
 4 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/src/client/src/tscParseLineProtocol.c b/src/client/src/tscParseLineProtocol.c
index 9f86d780d3..37264e8eaa 100644
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
@@ -2,19 +2,21 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
 #include "os.h"
 #include "osString.h"
 #include "ttype.h"
 #include "tmd5.h"
 #include "tstrbuild.h"
 #include "tname.h"
-#include "taos.h"
-#include "tsclient.h"
-#include "tscLog.h"
 #include "hash.h"
 #include "tskiplist.h"
-#include "tscUtil.h"
 
+#include "tscUtil.h"
+#include "tsclient.h"
+#include "tscLog.h"
+
+#include "taos.h"
 typedef struct  {
   char sTableName[TSDB_TABLE_NAME_LEN];
   SHashObj* tagHash;
@@ -1137,7 +1139,7 @@ void destroySmlDataPoint(TAOS_SML_DATA_POINT* point) {
   free(point->childTableName);
 }
 
-int taos_insert_by_lines(TAOS* taos, char* lines[], int numLines) {
+int taos_insert_lines(TAOS* taos, char* lines[], int numLines) {
   SArray* lpPoints = taosArrayInit(numLines, sizeof(SLPPoint));
   tscParseLines(lines, numLines, lpPoints, NULL);
 
diff --git a/src/inc/taos.h b/src/inc/taos.h
index ca18c4fb93..a62f387924 100644
--- a/src/inc/taos.h
+++ b/src/inc/taos.h
@@ -169,7 +169,7 @@ DLL_EXPORT void taos_close_stream(TAOS_STREAM *tstr);
 
 DLL_EXPORT int taos_load_table_info(TAOS *taos, const char* tableNameList);
 
-DLL_EXPORT int taos_insert_by_lines(TAOS* taos, char* lines[], int numLines);
+DLL_EXPORT int taos_insert_lines(TAOS* taos, char* lines[], int numLines);
 
 #ifdef __cplusplus
 }
diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index ed76e7b2b0..a377bbc7b4 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -975,9 +975,9 @@ int32_t verify_schema_less(TAOS* taos) {
       "stf,t1=4i,t3=\"t4\",t2=5,t4=5 c1=3i,c3=L\"passitagin_stf\",c2=false,c5=5,c6=7u 1626006933641a"
   };
 
-//  int code = taos_insert_by_lines(taos, lines , sizeof(lines)/sizeof(char*));
-  int code = taos_insert_by_lines(taos, &lines[0], 1);
-  code = taos_insert_by_lines(taos, &lines[1], 1);
+//  int code = taos_insert_lines(taos, lines , sizeof(lines)/sizeof(char*));
+  int code = taos_insert_lines(taos, &lines[0], 1);
+  code = taos_insert_lines(taos, &lines[1], 1);
 
   return code;
 }
diff --git a/tests/tsim/src/simExe.c b/tests/tsim/src/simExe.c
index 2615448e4b..a05f46ce0d 100644
--- a/tests/tsim/src/simExe.c
+++ b/tests/tsim/src/simExe.c
@@ -1079,7 +1079,7 @@ bool simExecuteLineInsertCmd(SScript *script, char *rest) {
   simInfo("script:%s, %s", script->fileName, rest);
   simLogSql(buf, true);
   char *  lines[] = {rest};
-  int32_t ret = taos_insert_by_lines(script->taos, lines, 1);
+  int32_t ret = taos_insert_lines(script->taos, lines, 1);
   if (ret == TSDB_CODE_SUCCESS) {
     simDebug("script:%s, taos:%p, %s executed. success.", script->fileName, script->taos, rest);
     script->linePos++;
@@ -1102,7 +1102,7 @@ bool simExecuteLineInsertErrorCmd(SScript *script, char *rest) {
   simInfo("script:%s, %s", script->fileName, rest);
   simLogSql(buf, true);
   char *  lines[] = {rest};
-  int32_t ret = taos_insert_by_lines(script->taos, lines, 1);
+  int32_t ret = taos_insert_lines(script->taos, lines, 1);
   if (ret == TSDB_CODE_SUCCESS) {
     sprintf(script->error, "script:%s, taos:%p, %s executed. expect failed, but success.", script->fileName, script->taos, rest);
     script->linePos++;

From 420a1dfe05a5737ded2bc00a634422003f961efb Mon Sep 17 00:00:00 2001
From: glzhao89 <ganlinzhao@hotmail.com>
Date: Wed, 14 Jul 2021 09:16:00 +0800
Subject: [PATCH 58/70] [TD-5150]<fix>: fix unitialized semaphore when running
 test suites on MacOS

---
 src/client/src/tscUtil.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 173db05e10..02aeb3e33d 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -3608,6 +3608,7 @@ void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
       pNew->signature = pNew;
       pNew->sqlstr = strdup(pSql->sqlstr);  // todo refactor
       pNew->fp = tscSubqueryCompleteCallback;
+      tsem_init(&pNew->rspSem, 0, 0);
 
       SRetrieveSupport* ps = calloc(1, sizeof(SRetrieveSupport));  // todo use object id
       ps->pParentSql = pSql;

From 76e28e294cd2ae7acdb884cc28cb6d0907ec6c6c Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Wed, 14 Jul 2021 10:31:57 +0800
Subject: [PATCH 59/70] [td-225]update the test script.

---
 .../general/parser/select_with_tags.sim       | 20 +++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/tests/script/general/parser/select_with_tags.sim b/tests/script/general/parser/select_with_tags.sim
index 9d5214bfaa..514aabe56f 100644
--- a/tests/script/general/parser/select_with_tags.sim
+++ b/tests/script/general/parser/select_with_tags.sim
@@ -169,32 +169,32 @@ if $rows != 12800 then
   return -1
 endi
 
-sql select top(c1, 100), tbname, t1, t2 from select_tags_mt0;
-if $rows != 100 then
+sql select top(c1, 80), tbname, t1, t2 from select_tags_mt0;
+if $rows != 80 then
    return -1
 endi
 
-if $data00 != @70-01-01 08:03:30.100@ then
+if $data00 != @70-01-01 08:03:40.100@ then
    return -1
 endi
 
-if $data10 != @70-01-01 08:03:30.200@ then
+if $data10 != @70-01-01 08:03:40.200@ then
    return -1
 endi
 
-if $data01 != 110 then
+if $data01 != 111 then
    return -1
 endi
 
-if $data02 != @select_tags_tb11@ then
+if $data02 != @select_tags_tb12@ then
    return -1
 endi
 
-if $data03 != 11 then
+if $data03 != 12 then
    return -1
 endi
 
-if $data04 != @abc11@ then
+if $data04 != @abc12@ then
    return -1
 endi
 
@@ -227,8 +227,8 @@ if $data04 != @abc12@ then
    return -1
 endi
 
-sql select bottom(c1, 100), tbname, t1, t2 from select_tags_mt0;
-if $rows != 100 then
+sql select bottom(c1, 72), tbname, t1, t2 from select_tags_mt0;
+if $rows != 72 then
    return -1
 endi
 

From 2acc0194c667ea04d740fb61ddaf94f8432fd6b4 Mon Sep 17 00:00:00 2001
From: wpan <wpan@taosdata.com>
Date: Wed, 14 Jul 2021 11:17:01 +0800
Subject: [PATCH 60/70] fix bug

---
 src/query/inc/qUtil.h     | 9 +++++++++
 src/query/src/qExecutor.c | 6 +++---
 2 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/src/query/inc/qUtil.h b/src/query/inc/qUtil.h
index 0756e41785..e20a9268d3 100644
--- a/src/query/inc/qUtil.h
+++ b/src/query/inc/qUtil.h
@@ -24,6 +24,15 @@
     memcpy((_k) + sizeof(uint64_t), (_ori), (_len)); \
   } while (0)
 
+#define SET_RES_EXT_WINDOW_KEY(_k, _ori, _len, _uid, _buf)             \
+  do {                                                                 \
+    assert(sizeof(_uid) == sizeof(uint64_t));                          \
+    *(void **)(_k) = (_buf);                                           \
+    *(uint64_t *)((_k) + POINTER_BYTES) = (_uid);                      \
+    memcpy((_k) + POINTER_BYTES + sizeof(uint64_t), (_ori), (_len));   \
+  } while (0)
+
+
 #define GET_RES_WINDOW_KEY_LEN(_l) ((_l) + sizeof(uint64_t))
 #define GET_QID(_r)  (((SQInfo*)((_r)->qinfo))->qId)
 
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 3d585afb87..2b2f1efceb 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -433,7 +433,7 @@ static SResultRow* doSetResultOutBufByKey(SQueryRuntimeEnv* pRuntimeEnv, SResult
         existed = (pResultRowInfo->pResult[0] == (*p1));
         pResultRowInfo->curPos = 0;
       } else {  // check if current pResultRowInfo contains the existed pResultRow
-        SET_RES_WINDOW_KEY(pRuntimeEnv->keyBuf, pData, bytes, tid);
+        SET_RES_EXT_WINDOW_KEY(pRuntimeEnv->keyBuf, pData, bytes, tid, pResultRowInfo);
         int64_t* index = taosHashGet(pRuntimeEnv->pResultRowListSet, pRuntimeEnv->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes));
         if (index != NULL) {
           pResultRowInfo->curPos = (int32_t) *index;
@@ -471,7 +471,7 @@ static SResultRow* doSetResultOutBufByKey(SQueryRuntimeEnv* pRuntimeEnv, SResult
     pResultRowInfo->pResult[pResultRowInfo->size++] = pResult;
 
     int64_t index = pResultRowInfo->curPos;
-    SET_RES_WINDOW_KEY(pRuntimeEnv->keyBuf, pData, bytes, tid);
+    SET_RES_EXT_WINDOW_KEY(pRuntimeEnv->keyBuf, pData, bytes, tid, pResultRowInfo);
     taosHashPut(pRuntimeEnv->pResultRowListSet, pRuntimeEnv->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes), &index, POINTER_BYTES);
   }
 
@@ -1790,7 +1790,7 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
 
   pRuntimeEnv->pResultRowHashTable = taosHashInit(numOfTables, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
   pRuntimeEnv->pResultRowListSet = taosHashInit(numOfTables, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
-  pRuntimeEnv->keyBuf  = malloc(pQueryAttr->maxTableColumnWidth + sizeof(int64_t));
+  pRuntimeEnv->keyBuf  = malloc(pQueryAttr->maxTableColumnWidth + sizeof(int64_t) + POINTER_BYTES);
   pRuntimeEnv->pool    = initResultRowPool(getResultRowSize(pRuntimeEnv));
 
   pRuntimeEnv->prevRow = malloc(POINTER_BYTES * pQueryAttr->numOfCols + pQueryAttr->srcRowSize);

From 72a36b080d57b8c0e1785a6e8c04d459f9b7e2af Mon Sep 17 00:00:00 2001
From: Jun Li <jun.li@convoy.com>
Date: Tue, 13 Jul 2021 20:30:19 -0700
Subject: [PATCH 61/70] Remove unused code

---
 src/vnode/src/vnodeMain.c | 20 --------------------
 1 file changed, 20 deletions(-)

diff --git a/src/vnode/src/vnodeMain.c b/src/vnode/src/vnodeMain.c
index 979e4e4cdd..f826c1aecd 100644
--- a/src/vnode/src/vnodeMain.c
+++ b/src/vnode/src/vnodeMain.c
@@ -47,9 +47,6 @@ int32_t vnodeCreate(SCreateVnodeMsg *pVnodeCfg) {
     return terrno;
   }
 
-  char rootDir[TSDB_FILENAME_LEN] = {0};
-  sprintf(rootDir, "%s/vnode%d", tsVnodeDir, pVnodeCfg->cfg.vgId);
-
   char vnodeDir[TSDB_FILENAME_LEN] = "\0";
   snprintf(vnodeDir, TSDB_FILENAME_LEN, "/vnode/vnode%d", pVnodeCfg->cfg.vgId);
   if (tfsMkdir(vnodeDir) < 0) {
@@ -63,23 +60,6 @@ int32_t vnodeCreate(SCreateVnodeMsg *pVnodeCfg) {
     return code;
   }
 
-  // STsdbCfg tsdbCfg = {0};
-  // tsdbCfg.tsdbId              = pVnodeCfg->cfg.vgId;
-  // tsdbCfg.cacheBlockSize      = pVnodeCfg->cfg.cacheBlockSize;
-  // tsdbCfg.totalBlocks         = pVnodeCfg->cfg.totalBlocks;
-  // tsdbCfg.daysPerFile         = pVnodeCfg->cfg.daysPerFile;
-  // tsdbCfg.keep                = pVnodeCfg->cfg.daysToKeep;
-  // tsdbCfg.keep1               = pVnodeCfg->cfg.daysToKeep1;
-  // tsdbCfg.keep2               = pVnodeCfg->cfg.daysToKeep2;
-  // tsdbCfg.minRowsPerFileBlock = pVnodeCfg->cfg.minRowsPerFileBlock;
-  // tsdbCfg.maxRowsPerFileBlock = pVnodeCfg->cfg.maxRowsPerFileBlock;
-  // tsdbCfg.precision           = pVnodeCfg->cfg.precision;
-  // tsdbCfg.compression         = pVnodeCfg->cfg.compression;
-  // tsdbCfg.update              = pVnodeCfg->cfg.update;
-  // tsdbCfg.cacheLastRow        = pVnodeCfg->cfg.cacheLastRow;
-
-  // char tsdbDir[TSDB_FILENAME_LEN] = {0};
-  // sprintf(tsdbDir, "vnode/vnode%d/tsdb", pVnodeCfg->cfg.vgId);
   if (tsdbCreateRepo(pVnodeCfg->cfg.vgId) < 0) {
     vError("vgId:%d, failed to create tsdb in vnode, reason:%s", pVnodeCfg->cfg.vgId, tstrerror(terrno));
     return TSDB_CODE_VND_INIT_FAILED;

From 44cd80b3e1224c59f89954c199fa02b13a59e4fd Mon Sep 17 00:00:00 2001
From: Elias Soong <elias.soong@gmail.com>
Date: Wed, 14 Jul 2021 11:32:53 +0800
Subject: [PATCH 62/70] [TD-5255] <docs>: update getting-start doc to fit
 latest taosdemo feature.

---
 documentation20/cn/02.getting-started/docs.md | 98 +++++++++----------
 1 file changed, 46 insertions(+), 52 deletions(-)

diff --git a/documentation20/cn/02.getting-started/docs.md b/documentation20/cn/02.getting-started/docs.md
index 6eb58a1433..fa36481646 100644
--- a/documentation20/cn/02.getting-started/docs.md
+++ b/documentation20/cn/02.getting-started/docs.md
@@ -2,25 +2,25 @@
 
 ## <a class="anchor" id="install"></a>快捷安装
 
-TDengine软件分为服务器、客户端和报警模块三部分，目前2.0版服务器仅能在Linux系统上安装和运行，后续会支持Windows、mac OS等系统。客户端可以在Windows或Linux上安装和运行。任何OS的应用也可以选择RESTful接口连接服务器taosd。CPU支持X64/ARM64/MIPS64/Alpha64，后续会支持ARM32、RISC-V等CPU架构。用户可根据需求选择通过[源码](https://www.taosdata.com/cn/getting-started/#通过源码安装)或者[安装包](https://www.taosdata.com/cn/getting-started/#通过安装包安装)来安装。
+TDengine 软件分为服务器、客户端和报警模块三部分，目前 2.0 版服务器仅能在 Linux 系统上安装和运行，后续会支持 Windows、Mac OS 等系统。客户端可以在 Windows 或 Linux 上安装和运行。任何 OS 的应用也可以选择 RESTful 接口连接服务器 taosd。CPU 支持 X64/ARM64/MIPS64/Alpha64，后续会支持 ARM32、RISC-V 等 CPU 架构。用户可根据需求选择通过 [源码](https://www.taosdata.com/cn/getting-started/#通过源码安装) 或者 [安装包](https://www.taosdata.com/cn/getting-started/#通过安装包安装) 来安装。
 
 ### <a class="anchor" id="source-install"></a>通过源码安装
 
-请参考我们的[TDengine github主页](https://github.com/taosdata/TDengine)下载源码并安装.
+请参考我们的 [TDengine github 主页](https://github.com/taosdata/TDengine) 下载源码并安装.
 
-### 通过Docker容器运行
+### 通过 Docker 容器运行
 
-暂时不建议生产环境采用 Docker 来部署 TDengine 的客户端或服务端，但在开发环境下或初次尝试时，使用 Docker 方式部署是十分方便的。特别是，利用 Docker，可以方便地在 Mac OSX 和 Windows 环境下尝试 TDengine。
+暂时不建议生产环境采用 Docker 来部署 TDengine 的客户端或服务端，但在开发环境下或初次尝试时，使用 Docker 方式部署是十分方便的。特别是，利用 Docker，可以方便地在 Mac OS X 和 Windows 环境下尝试 TDengine。
 
-详细操作方法请参照 [通过Docker快速体验TDengine](https://www.taosdata.com/cn/documentation/getting-started/docker)。
+详细操作方法请参照 [通过 Docker 快速体验 TDengine](https://www.taosdata.com/cn/documentation/getting-started/docker)。
 
 ### <a class="anchor" id="package-install"></a>通过安装包安装
 
-TDengine的安装非常简单，从下载到安装成功仅仅只要几秒钟。服务端安装包包含客户端和连接器，我们提供三种安装包，您可以根据需要选择：
+TDengine 的安装非常简单，从下载到安装成功仅仅只要几秒钟。服务端安装包包含客户端和连接器，我们提供三种安装包，您可以根据需要选择：
 
-安装包下载在[这里](https://www.taosdata.com/cn/getting-started/#通过安装包安装)。
+安装包下载在 [这里](https://www.taosdata.com/cn/getting-started/#通过安装包安装)。
 
-具体的安装过程，请参见[TDengine多种安装包的安装和卸载](https://www.taosdata.com/blog/2019/08/09/566.html)以及[视频教程](https://www.taosdata.com/blog/2020/11/11/1941.html)。
+具体的安装过程，请参见 [TDengine 多种安装包的安装和卸载](https://www.taosdata.com/blog/2019/08/09/566.html) 以及 [视频教程](https://www.taosdata.com/blog/2020/11/11/1941.html)。
 
 ## <a class="anchor" id="start"></a>轻松启动
 
@@ -53,21 +53,21 @@ $ systemctl status taosd
   如果系统中不支持 systemd，也可以用手动运行 /usr/local/taos/bin/taosd 方式启动 TDengine 服务。
 
   
-## <a class="anchor" id="console"></a>TDengine命令行程序
+## <a class="anchor" id="console"></a>TDengine 命令行程序
 
-执行TDengine命令行程序，您只要在Linux终端执行`taos`即可。
+执行 TDengine 命令行程序，您只要在 Linux 终端执行 `taos` 即可。
 
 ```bash
 $ taos
 ```
 
-如果TDengine终端连接服务成功，将会打印出欢迎消息和版本信息。如果失败，则会打印错误消息出来（请参考[FAQ](https://www.taosdata.com/cn/documentation/faq/)来解决终端连接服务端失败的问题）。TDengine终端的提示符号如下：
+如果 TDengine 终端连接服务成功，将会打印出欢迎消息和版本信息。如果失败，则会打印错误消息出来（请参考 [FAQ](https://www.taosdata.com/cn/documentation/faq/) 来解决终端连接服务端失败的问题）。TDengine 终端的提示符号如下：
 
 ```cmd
 taos>
 ```
 
-在TDengine终端中，用户可以通过SQL命令来创建/删除数据库、表等，并进行插入查询操作。在终端中运行的SQL语句需要以分号结束来运行。示例：
+在 TDengine 终端中，用户可以通过 SQL 命令来创建/删除数据库、表等，并进行插入查询操作。在终端中运行的 SQL 语句需要以分号结束来运行。示例：
 
 ```mysql
 create database demo;
@@ -76,24 +76,24 @@ create table t (ts timestamp, speed int);
 insert into t values ('2019-07-15 00:00:00', 10);
 insert into t values ('2019-07-15 01:00:00', 20);
 select * from t;
-          ts          |   speed   |
-===================================
- 19-07-15 00:00:00.000|         10|
- 19-07-15 01:00:00.000|         20|
-Query OK, 2 row(s) in set (0.001700s)
+           ts            |    speed    |
+========================================
+ 2019-07-15 00:00:00.000 |          10 |
+ 2019-07-15 01:00:00.000 |          20 |
+Query OK, 2 row(s) in set (0.003128s)
 ```
 
-除执行SQL语句外，系统管理员还可以从TDengine终端检查系统运行状态，添加删除用户账号等。
+除执行 SQL 语句外，系统管理员还可以从 TDengine 终端检查系统运行状态，添加删除用户账号等。
 
 ### 命令行参数
 
-您可通过配置命令行参数来改变TDengine终端的行为。以下为常用的几个命令行参数：
+您可通过配置命令行参数来改变 TDengine 终端的行为。以下为常用的几个命令行参数：
 
-- -c, --config-dir: 指定配置文件目录，默认为_/etc/taos_
-- -h, --host: 指定服务的IP地址，默认为本地服务
-- -s, --commands: 在不进入终端的情况下运行TDengine命令
-- -u, -- user:  连接TDengine服务器的用户名，缺省为root
-- -p, --password: 连接TDengine服务器的密码，缺省为taosdata
+- -c, --config-dir: 指定配置文件目录，默认为 _/etc/taos_
+- -h, --host: 指定服务的 FQDN 地址（也可以使用 IP），默认为连接本地服务
+- -s, --commands: 在不进入终端的情况下运行 TDengine 命令
+- -u, --user: 连接 TDengine 服务器的用户名，缺省为 root
+- -p, --password: 连接TDengine服务器的密码，缺省为 taosdata
 - -?, --help: 打印出所有命令行参数
 
 示例：
@@ -102,7 +102,7 @@ Query OK, 2 row(s) in set (0.001700s)
 $ taos -h 192.168.0.1 -s "use db; show tables;"
 ```
 
-### 运行SQL命令脚本
+### 运行 SQL 命令脚本
 
 TDengine 终端可以通过 `source` 命令来运行 SQL 命令脚本.
 
@@ -110,27 +110,27 @@ TDengine 终端可以通过 `source` 命令来运行 SQL 命令脚本.
 taos> source <filename>;
 ```
 
-### Shell小技巧
+### Shell 小技巧
 
 - 可以使用上下光标键查看历史输入的指令
-- 修改用户密码。在 shell 中使用 alter user 指令
+- 修改用户密码，在 shell 中使用 alter user 指令
 - ctrl+c 中止正在进行中的查询
 - 执行 `RESET QUERY CACHE` 清空本地缓存的表 schema
 
 
 ## <a class="anchor" id="demo"></a>TDengine 极速体验
 
-启动TDengine的服务，在Linux终端执行taosdemo
+启动 TDengine 的服务，在 Linux 终端执行 taosdemo
 
 ```bash
 $ taosdemo
 ```
 
-该命令将在数据库test下面自动创建一张超级表meters，该超级表下有1万张表，表名为"t0" 到"t9999"，每张表有10万条记录，每条记录有 （f1, f2， f3）三个字段，时间戳从"2017-07-14 10:40:00 000" 到"2017-07-14 10:41:39 999"，每张表带有标签areaid和loc, areaid被设置为1到10, loc被设置为"beijing"或者“shanghai"。
+该命令将在数据库 test 下面自动创建一张超级表 meters，该超级表下有 1 万张表，表名为 "t0" 到 "t9999"，每张表有 1 万条记录，每条记录有 (ts, current, voltage, phase) 四个字段，时间戳从 "2017-07-14 10:40:00 000" 到 "2017-07-14 10:40:09 999"，每张表带有标签 location 和 groupdId，groupdId 被设置为 1 到 10， location 被设置为 "beijing" 或者 "shanghai"。
 
-执行这条命令大概需要10分钟，最后共插入10亿条记录。
+执行这条命令大概需要几分钟，最后共插入 1 亿条记录。
 
-在TDengine客户端输入查询命令，体验查询速度。
+在 TDengine 客户端输入查询命令，体验查询速度。
 
 - 查询超级表下记录总条数：
 
@@ -138,49 +138,43 @@ $ taosdemo
 taos> select count(*) from test.meters;
 ```
 
-- 查询10亿条记录的平均值、最大值、最小值等：
+- 查询 1 亿条记录的平均值、最大值、最小值等：
 
 ```mysql
-taos> select avg(f1), max(f2), min(f3) from test.meters;
+taos> select avg(current), max(voltage), min(phase) from test.meters;
 ```
 
-- 查询loc="beijing"的记录总条数：
+- 查询 location="beijing" 的记录总条数：
 
 ```mysql
-taos> select count(*) from test.meters where loc="beijing";
+taos> select count(*) from test.meters where location="beijing";
 ```
 
-- 查询areaid=10的所有记录的平均值、最大值、最小值等：
+- 查询 groupdId=10 的所有记录的平均值、最大值、最小值等：
 
 ```mysql
-taos> select avg(f1), max(f2), min(f3) from test.meters where areaid=10;
+taos> select avg(current), max(voltage), min(phase) from test.meters where groupdId=10;
 ```
 
-- 对表t10按10s进行平均值、最大值和最小值聚合统计：
+- 对表 t10 按 10s 进行平均值、最大值和最小值聚合统计：
 
 ```mysql
-taos> select avg(f1), max(f2), min(f3) from test.t10 interval(10s);
+taos> select avg(current), max(voltage), min(phase) from test.t10 interval(10s);
 ```
 
-**Note:** taosdemo命令本身带有很多选项，配置表的数目、记录条数等等，请执行 `taosdemo --help`详细列出。您可以设置不同参数进行体验。
+**Note:** taosdemo 命令本身带有很多选项，配置表的数目、记录条数等等，请执行 `taosdemo --help` 详细列出。您可以设置不同参数进行体验。
 
 
 ## 客户端和报警模块
 
-如果客户端和服务端运行在不同的电脑上，可以单独安装客户端。Linux和Windows安装包如下：
+如果客户端和服务端运行在不同的电脑上，可以单独安装客户端。Linux 和 Windows 安装包可以在 [这里](https://www.taosdata.com/cn/getting-started/#客户端) 下载。
 
-- TDengine-client-2.0.10.0-Linux-x64.tar.gz(3.0M)
-- TDengine-client-2.0.10.0-Windows-x64.exe(2.8M)
-- TDengine-client-2.0.10.0-Windows-x86.exe(2.8M)
-
-报警模块的Linux安装包如下（请参考[报警模块的使用方法](https://github.com/taosdata/TDengine/blob/master/alert/README_cn.md)）：
-
-- TDengine-alert-2.0.10.0-Linux-x64.tar.gz (8.1M)
+报警模块的 Linux 和 Windows 安装包请在 [所有下载链接](https://www.taosdata.com/cn/all-downloads/) 页面搜索“TDengine Alert Linux”章节或“TDengine Alert Windows”章节进行下载。使用方法请参考 [报警模块的使用方法](https://github.com/taosdata/TDengine/blob/master/alert/README_cn.md)。
 
   
 ## <a class="anchor" id="platforms"></a>支持平台列表
 
-### TDengine服务器支持的平台列表
+### TDengine 服务器支持的平台列表
 
 |                | **CentOS 6/7/8** | **Ubuntu 16/18/20** | **Other Linux** | **统信 UOS** | **银河/中标麒麟** | **凝思 V60/V80** | **华为 EulerOS** |
 | -------------- | --------------------- | ------------------------ | --------------- | --------------- | ------------------------- | --------------------- | --------------------- |
@@ -201,9 +195,9 @@ taos> select avg(f1), max(f2), min(f3) from test.t10 interval(10s);
 
 
 
-### TDengine客户端和连接器支持的平台列表
+### TDengine 客户端和连接器支持的平台列表
 
-目前TDengine的连接器可支持的平台广泛，目前包括：X64/X86/ARM64/ARM32/MIPS/Alpha等硬件平台，以及Linux/Win64/Win32等开发环境。
+目前 TDengine 的连接器可支持的平台广泛，目前包括：X64/X86/ARM64/ARM32/MIPS/Alpha 等硬件平台，以及 Linux/Win64/Win32 等开发环境。
 
 对照矩阵如下：
 
@@ -220,5 +214,5 @@ taos> select avg(f1), max(f2), min(f3) from test.t10 interval(10s);
 
 注： ● 表示经过官方测试验证， ○ 表示非官方测试验证。
 
-请跳转到 [连接器](https://www.taosdata.com/cn/documentation/connector)查看更详细的信息。
+请跳转到 [连接器](https://www.taosdata.com/cn/documentation/connector) 查看更详细的信息。
 

From 37e86d57e3024535552cf7ef736fb156e0c24a1a Mon Sep 17 00:00:00 2001
From: wpan <wpan@taosdata.com>
Date: Wed, 14 Jul 2021 13:02:14 +0800
Subject: [PATCH 63/70] add debug info

---
 src/query/src/qExecutor.c | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 2b2f1efceb..0f8bcc0712 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -437,6 +437,11 @@ static SResultRow* doSetResultOutBufByKey(SQueryRuntimeEnv* pRuntimeEnv, SResult
         int64_t* index = taosHashGet(pRuntimeEnv->pResultRowListSet, pRuntimeEnv->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes));
         if (index != NULL) {
           pResultRowInfo->curPos = (int32_t) *index;
+          if (pResultRowInfo->size > 1) {
+            for(int32_t k = 0; k <pResultRowInfo->size - 1; ++k) {
+              assert(pResultRowInfo->pResult[k]->win.skey < pResultRowInfo->pResult[k+1]->win.skey);
+            }
+          }
           existed = true;
         } else {
           existed = false;
@@ -470,6 +475,10 @@ static SResultRow* doSetResultOutBufByKey(SQueryRuntimeEnv* pRuntimeEnv, SResult
     pResultRowInfo->curPos = pResultRowInfo->size;
     pResultRowInfo->pResult[pResultRowInfo->size++] = pResult;
 
+    if (pResultRowInfo->curPos > 0) {
+      assert(pResultRowInfo->pResult[pResultRowInfo->curPos]->win.skey > pResultRowInfo->pResult[pResultRowInfo->curPos-1]->win.skey);
+    }
+
     int64_t index = pResultRowInfo->curPos;
     SET_RES_EXT_WINDOW_KEY(pRuntimeEnv->keyBuf, pData, bytes, tid, pResultRowInfo);
     taosHashPut(pRuntimeEnv->pResultRowListSet, pRuntimeEnv->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes), &index, POINTER_BYTES);

From 23545c2b29f73f71e1cca39f8ab8f819907aec1b Mon Sep 17 00:00:00 2001
From: wpan <wpan@taosdata.com>
Date: Wed, 14 Jul 2021 14:28:30 +0800
Subject: [PATCH 64/70] fix bug

---
 src/query/inc/qUtil.h     | 4 +++-
 src/query/src/qExecutor.c | 4 ++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/query/inc/qUtil.h b/src/query/inc/qUtil.h
index e20a9268d3..c8741030c0 100644
--- a/src/query/inc/qUtil.h
+++ b/src/query/inc/qUtil.h
@@ -27,13 +27,15 @@
 #define SET_RES_EXT_WINDOW_KEY(_k, _ori, _len, _uid, _buf)             \
   do {                                                                 \
     assert(sizeof(_uid) == sizeof(uint64_t));                          \
-    *(void **)(_k) = (_buf);                                           \
+    *(void **)(_k) = (_buf);                                             \
     *(uint64_t *)((_k) + POINTER_BYTES) = (_uid);                      \
     memcpy((_k) + POINTER_BYTES + sizeof(uint64_t), (_ori), (_len));   \
   } while (0)
 
 
 #define GET_RES_WINDOW_KEY_LEN(_l) ((_l) + sizeof(uint64_t))
+#define GET_RES_EXT_WINDOW_KEY_LEN(_l) ((_l) + sizeof(uint64_t) + POINTER_BYTES)
+
 #define GET_QID(_r)  (((SQInfo*)((_r)->qinfo))->qId)
 
 #define curTimeWindowIndex(_winres)        ((_winres)->curIndex)
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 0f8bcc0712..5214d52589 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -434,7 +434,7 @@ static SResultRow* doSetResultOutBufByKey(SQueryRuntimeEnv* pRuntimeEnv, SResult
         pResultRowInfo->curPos = 0;
       } else {  // check if current pResultRowInfo contains the existed pResultRow
         SET_RES_EXT_WINDOW_KEY(pRuntimeEnv->keyBuf, pData, bytes, tid, pResultRowInfo);
-        int64_t* index = taosHashGet(pRuntimeEnv->pResultRowListSet, pRuntimeEnv->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes));
+        int64_t* index = taosHashGet(pRuntimeEnv->pResultRowListSet, pRuntimeEnv->keyBuf, GET_RES_EXT_WINDOW_KEY_LEN(bytes));
         if (index != NULL) {
           pResultRowInfo->curPos = (int32_t) *index;
           if (pResultRowInfo->size > 1) {
@@ -481,7 +481,7 @@ static SResultRow* doSetResultOutBufByKey(SQueryRuntimeEnv* pRuntimeEnv, SResult
 
     int64_t index = pResultRowInfo->curPos;
     SET_RES_EXT_WINDOW_KEY(pRuntimeEnv->keyBuf, pData, bytes, tid, pResultRowInfo);
-    taosHashPut(pRuntimeEnv->pResultRowListSet, pRuntimeEnv->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes), &index, POINTER_BYTES);
+    taosHashPut(pRuntimeEnv->pResultRowListSet, pRuntimeEnv->keyBuf, GET_RES_EXT_WINDOW_KEY_LEN(bytes), &index, POINTER_BYTES);
   }
 
   // too many time window in query

From 83153f6a3e2f91bdb17b99258e4c0fd4e6e5fd59 Mon Sep 17 00:00:00 2001
From: wpan <wpan@taosdata.com>
Date: Wed, 14 Jul 2021 14:39:20 +0800
Subject: [PATCH 65/70] fix bug

---
 src/query/src/qExecutor.c | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 5214d52589..9016737c40 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -475,10 +475,6 @@ static SResultRow* doSetResultOutBufByKey(SQueryRuntimeEnv* pRuntimeEnv, SResult
     pResultRowInfo->curPos = pResultRowInfo->size;
     pResultRowInfo->pResult[pResultRowInfo->size++] = pResult;
 
-    if (pResultRowInfo->curPos > 0) {
-      assert(pResultRowInfo->pResult[pResultRowInfo->curPos]->win.skey > pResultRowInfo->pResult[pResultRowInfo->curPos-1]->win.skey);
-    }
-
     int64_t index = pResultRowInfo->curPos;
     SET_RES_EXT_WINDOW_KEY(pRuntimeEnv->keyBuf, pData, bytes, tid, pResultRowInfo);
     taosHashPut(pRuntimeEnv->pResultRowListSet, pRuntimeEnv->keyBuf, GET_RES_EXT_WINDOW_KEY_LEN(bytes), &index, POINTER_BYTES);

From c0c7043d20b658808a5e4bc5afa6ac1b462aaf01 Mon Sep 17 00:00:00 2001
From: wpan <wpan@taosdata.com>
Date: Wed, 14 Jul 2021 14:53:18 +0800
Subject: [PATCH 66/70] fix bug

---
 src/query/src/qExecutor.c | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 9016737c40..fa2ddb05b8 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -437,11 +437,6 @@ static SResultRow* doSetResultOutBufByKey(SQueryRuntimeEnv* pRuntimeEnv, SResult
         int64_t* index = taosHashGet(pRuntimeEnv->pResultRowListSet, pRuntimeEnv->keyBuf, GET_RES_EXT_WINDOW_KEY_LEN(bytes));
         if (index != NULL) {
           pResultRowInfo->curPos = (int32_t) *index;
-          if (pResultRowInfo->size > 1) {
-            for(int32_t k = 0; k <pResultRowInfo->size - 1; ++k) {
-              assert(pResultRowInfo->pResult[k]->win.skey < pResultRowInfo->pResult[k+1]->win.skey);
-            }
-          }
           existed = true;
         } else {
           existed = false;

From a1f1315de382125aba443f47062c25b5945d166e Mon Sep 17 00:00:00 2001
From: weicz1221 <49259303+weicz1221@users.noreply.github.com>
Date: Wed, 14 Jul 2021 16:13:27 +0800
Subject: [PATCH 67/70] fix sql regex (#6838)

Co-authored-by: weicz <weicz@runlion.com>
---
 .../jdbc/src/main/java/com/taosdata/jdbc/utils/Utils.java       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/Utils.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/Utils.java
index e3179bd317..efe3303bd9 100644
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/Utils.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/Utils.java
@@ -110,7 +110,7 @@ public class Utils {
             return rawSql;
         // toLowerCase
         String preparedSql = rawSql.trim().toLowerCase();
-        String[] clause = new String[]{"values\\s*\\(.*?\\)", "tags\\s*\\(.*?\\)", "where\\s*.*"};
+        String[] clause = new String[]{"values\\s*\\([\\s\\S]*?\\)", "tags\\s*\\([\\s\\S]*?\\)", "where[\\s\\S]*"};
         Map<Integer, Integer> placeholderPositions = new HashMap<>();
         RangeSet<Integer> clauseRangeSet = TreeRangeSet.create();
         findPlaceholderPosition(preparedSql, placeholderPositions);

From 80faa86c952dd5110862add4be9e4ecce1735def Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Wed, 14 Jul 2021 17:25:05 +0800
Subject: [PATCH 68/70] Feature/sangshuduo/td 5242 taosdemo support 4096
 columns (#6856)

* [TD-5136]<feature>: taosdemo simulate real senario.

* update test case according to taosdemo change

* adjust range of semi-random data.

* make demo mode use different tag name and value.

* [TD-5242]<feature>: taosdemo support max columns align with TSDB defines.
---
 src/kit/taosdemo/taosdemo.c | 107 ++++++++++++++++++++++--------------
 1 file changed, 65 insertions(+), 42 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index fa3d263678..d088d015d5 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -75,7 +75,7 @@ enum TEST_MODE {
 
 #define MAX_RECORDS_PER_REQ     32766
 
-#define HEAD_BUFF_LEN    1024*24  // 16*1024 + (192+32)*2 + insert into ..
+#define HEAD_BUFF_LEN       TSDB_MAX_COLUMNS*24  // 16*MAX_COLUMNS + (192+32)*2 + insert into ..
 
 #define MAX_SQL_SIZE       65536
 #define BUFFER_SIZE        (65536*2)
@@ -84,26 +84,23 @@ enum TEST_MODE {
 #define MAX_PASSWORD_SIZE  64
 #define MAX_HOSTNAME_SIZE  64
 #define MAX_TB_NAME_SIZE   64
-#define MAX_DATA_SIZE      (16*1024)+20     // max record len: 16*1024, timestamp string and ,('') need extra space
-#define MAX_NUM_DATATYPE   10
+#define MAX_DATA_SIZE      (16*TSDB_MAX_COLUMNS)+20     // max record len: 16*MAX_COLUMNS, timestamp string and ,('') need extra space
 #define OPT_ABORT          1 /* –abort */
 #define STRING_LEN         60000
 #define MAX_PREPARED_RAND  1000000
 #define MAX_FILE_NAME_LEN  256              // max file name length on linux is 255.
 
-#define   MAX_SAMPLES_ONCE_FROM_FILE   10000
-#define   MAX_NUM_DATATYPE 10
+#define MAX_SAMPLES_ONCE_FROM_FILE   10000
+#define MAX_NUM_COLUMNS        (TSDB_MAX_COLUMNS - 1)      // exclude first column timestamp
 
-#define   MAX_DB_COUNT           8
-#define   MAX_SUPER_TABLE_COUNT  200
-#define   MAX_COLUMN_COUNT       1024
-#define   MAX_TAG_COUNT          128
+#define MAX_DB_COUNT            8
+#define MAX_SUPER_TABLE_COUNT   200
 
-#define   MAX_QUERY_SQL_COUNT    100
-#define   MAX_QUERY_SQL_LENGTH   1024
+#define MAX_QUERY_SQL_COUNT     100
+#define MAX_QUERY_SQL_LENGTH    1024
 
-#define   MAX_DATABASE_COUNT     256
-#define INPUT_BUF_LEN   256
+#define MAX_DATABASE_COUNT      256
+#define INPUT_BUF_LEN           256
 
 #define DEFAULT_TIMESTAMP_STEP  1
 
@@ -218,7 +215,7 @@ typedef struct SArguments_S {
     bool     performance_print;
     char *   output_file;
     bool     async_mode;
-    char *   datatype[MAX_NUM_DATATYPE + 1];
+    char *   datatype[MAX_NUM_COLUMNS + 1];
     uint32_t len_of_binary;
     uint32_t num_of_CPR;
     uint32_t num_of_threads;
@@ -274,9 +271,9 @@ typedef struct SSuperTable_S {
   char         tagsFile[MAX_FILE_NAME_LEN];
 
   uint32_t     columnCount;
-  StrColumn    columns[MAX_COLUMN_COUNT];
+  StrColumn    columns[TSDB_MAX_COLUMNS];
   uint32_t     tagCount;
-  StrColumn    tags[MAX_TAG_COUNT];
+  StrColumn    tags[TSDB_MAX_TAGS];
 
   char*        childTblName;
   char*        colsOfCreateChildTable;
@@ -565,6 +562,8 @@ double   randdouble[MAX_PREPARED_RAND];
 char *aggreFunc[] = {"*", "count(*)", "avg(col0)", "sum(col0)",
     "max(col0)", "min(col0)", "first(col0)", "last(col0)"};
 
+#define DEFAULT_DATATYPE_NUM    3
+
 SArguments g_args = {
     NULL,            // metaFile
     0,               // test_mode
@@ -595,7 +594,7 @@ SArguments g_args = {
     {
         "FLOAT",         // datatype
         "INT",           // datatype
-        "FLOAT",         // datatype
+        "FLOAT",         // datatype. DEFAULT_DATATYPE_NUM is 3
     },
     16,              // len_of_binary
     4,               // num_of_CPR
@@ -725,9 +724,13 @@ static void printHelp() {
             "The data_type of columns, default: FLOAT, INT, FLOAT.");
     printf("%s%s%s%s\n", indent, "-w", indent,
             "The length of data_type 'BINARY' or 'NCHAR'. Default is 16");
-    printf("%s%s%s%s%d\n", indent, "-l", indent,
-            "The number of columns per record. Default is 3. Max values is ",
-            MAX_NUM_DATATYPE);
+    printf("%s%s%s%s%d%s%d\n", indent, "-l", indent,
+            "The number of columns per record. Default is ",
+            DEFAULT_DATATYPE_NUM,
+            ". Max values is ",
+            MAX_NUM_COLUMNS);
+    printf("%s%s%s%s\n", indent, indent, indent,
+            "All of the new column(s) type is INT. If use -b to specify column type, -l will be ignored.");
     printf("%s%s%s%s\n", indent, "-T", indent,
             "The number of threads. Default is 10.");
     printf("%s%s%s%s\n", indent, "-i", indent,
@@ -931,13 +934,16 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
             }
             arguments->num_of_CPR = atoi(argv[++i]);
 
-            if (arguments->num_of_CPR > MAX_NUM_DATATYPE) {
-                printf("WARNING: max acceptible columns count is %d\n", MAX_NUM_DATATYPE);
+            if (arguments->num_of_CPR > MAX_NUM_COLUMNS) {
+                printf("WARNING: max acceptible columns count is %d\n", MAX_NUM_COLUMNS);
                 prompt();
-                arguments->num_of_CPR = MAX_NUM_DATATYPE;
+                arguments->num_of_CPR = MAX_NUM_COLUMNS;
             }
 
-            for (int col = arguments->num_of_CPR; col < MAX_NUM_DATATYPE; col++) {
+            for (int col = DEFAULT_DATATYPE_NUM; col < arguments->num_of_CPR; col ++) {
+                arguments->datatype[col] = "INT";
+            }
+            for (int col = arguments->num_of_CPR; col < MAX_NUM_COLUMNS; col++) {
                 arguments->datatype[col] = NULL;
             }
 
@@ -990,7 +996,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
                     }
                     arguments->datatype[index++] = token;
                     token = strsep(&running, ",");
-                    if (index >= MAX_NUM_DATATYPE) break;
+                    if (index >= MAX_NUM_COLUMNS) break;
                 }
                 arguments->datatype[index] = NULL;
             }
@@ -1086,7 +1092,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
     }
 
     int columnCount;
-    for (columnCount = 0; columnCount < MAX_NUM_DATATYPE; columnCount ++) {
+    for (columnCount = 0; columnCount < MAX_NUM_COLUMNS; columnCount ++) {
         if (g_args.datatype[columnCount] == NULL) {
             break;
         }
@@ -1111,7 +1117,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
                 arguments->use_metric ? "true" : "false");
         if (*(arguments->datatype)) {
             printf("# Specified data type:               ");
-            for (int i = 0; i < MAX_NUM_DATATYPE; i++)
+            for (int i = 0; i < MAX_NUM_COLUMNS; i++)
                 if (arguments->datatype[i])
                     printf("%s,", arguments->datatype[i]);
                 else
@@ -2389,8 +2395,15 @@ static char* generateTagVaulesForStb(SSuperTable* stbInfo, int32_t tableSeq) {
             tmfree(buf);
         } else if (0 == strncasecmp(stbInfo->tags[i].dataType,
                     "int", strlen("int"))) {
-            dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
+            if ((g_args.demo_mode) && (i == 0)) {
+                dataLen += snprintf(dataBuf + dataLen,
+                        TSDB_MAX_SQL_LEN - dataLen,
+                    "%d, ", tableSeq % 10);
+            } else {
+                dataLen += snprintf(dataBuf + dataLen,
+                        TSDB_MAX_SQL_LEN - dataLen,
                     "%d, ", tableSeq);
+            }
         } else if (0 == strncasecmp(stbInfo->tags[i].dataType,
                     "bigint", strlen("bigint"))) {
             dataLen += snprintf(dataBuf + dataLen, TSDB_MAX_SQL_LEN - dataLen,
@@ -2787,16 +2800,26 @@ static int createSuperTable(
         char* dataType = superTbl->tags[tagIndex].dataType;
 
         if (strcasecmp(dataType, "BINARY") == 0) {
-            len += snprintf(tags + len, STRING_LEN - len, "t%d %s(%d), ", tagIndex,
-                    "BINARY", superTbl->tags[tagIndex].dataLen);
+            if ((g_args.demo_mode) && (tagIndex == 1)) {
+                len += snprintf(tags + len, STRING_LEN - len,
+                        "loction BINARY(%d), ",
+                        superTbl->tags[tagIndex].dataLen);
+            } else {
+                len += snprintf(tags + len, STRING_LEN - len, "t%d %s(%d), ",
+                        tagIndex, "BINARY", superTbl->tags[tagIndex].dataLen);
+            }
             lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 3;
         } else if (strcasecmp(dataType, "NCHAR") == 0) {
             len += snprintf(tags + len, STRING_LEN - len, "t%d %s(%d), ", tagIndex,
                     "NCHAR", superTbl->tags[tagIndex].dataLen);
             lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 3;
         } else if (strcasecmp(dataType, "INT") == 0)  {
-            len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
+            if ((g_args.demo_mode) && (tagIndex == 0)) {
+                len += snprintf(tags + len, STRING_LEN - len, "groupId INT, ");
+            } else {
+                len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
                     "INT");
+            }
             lenOfTagOfOneRow += superTbl->tags[tagIndex].dataLen + 11;
         } else if (strcasecmp(dataType, "BIGINT") == 0)  {
             len += snprintf(tags + len, STRING_LEN - len, "t%d %s, ", tagIndex,
@@ -3352,9 +3375,9 @@ static bool getColumnAndTagTypeFromInsertJsonFile(
   }
 
   int columnSize = cJSON_GetArraySize(columns);
-  if ((columnSize + 1/* ts */) > MAX_COLUMN_COUNT) {
+  if ((columnSize + 1/* ts */) > TSDB_MAX_COLUMNS) {
     errorPrint("%s() LN%d, failed to read json, column size overflow, max column size is %d\n",
-            __func__, __LINE__, MAX_COLUMN_COUNT);
+            __func__, __LINE__, TSDB_MAX_COLUMNS);
     goto PARSE_OVER;
   }
 
@@ -3410,9 +3433,9 @@ static bool getColumnAndTagTypeFromInsertJsonFile(
     }
   }
 
-  if ((index + 1 /* ts */) > MAX_COLUMN_COUNT) {
+  if ((index + 1 /* ts */) > MAX_NUM_COLUMNS) {
     errorPrint("%s() LN%d, failed to read json, column size overflow, allowed max column size is %d\n",
-            __func__, __LINE__, MAX_COLUMN_COUNT);
+            __func__, __LINE__, MAX_NUM_COLUMNS);
     goto PARSE_OVER;
   }
 
@@ -3429,9 +3452,9 @@ static bool getColumnAndTagTypeFromInsertJsonFile(
   }
 
   int tagSize = cJSON_GetArraySize(tags);
-  if (tagSize > MAX_TAG_COUNT) {
+  if (tagSize > TSDB_MAX_TAGS) {
     errorPrint("%s() LN%d, failed to read json, tags size overflow, max tag size is %d\n",
-        __func__, __LINE__, MAX_TAG_COUNT);
+        __func__, __LINE__, TSDB_MAX_TAGS);
     goto PARSE_OVER;
   }
 
@@ -3481,17 +3504,17 @@ static bool getColumnAndTagTypeFromInsertJsonFile(
     }
   }
 
-  if (index > MAX_TAG_COUNT) {
+  if (index > TSDB_MAX_TAGS) {
     errorPrint("%s() LN%d, failed to read json, tags size overflow, allowed max tag count is %d\n",
-        __func__, __LINE__, MAX_TAG_COUNT);
+        __func__, __LINE__, TSDB_MAX_TAGS);
     goto PARSE_OVER;
   }
 
   superTbls->tagCount = index;
 
-  if ((superTbls->columnCount + superTbls->tagCount + 1 /* ts */) > MAX_COLUMN_COUNT) {
+  if ((superTbls->columnCount + superTbls->tagCount + 1 /* ts */) > TSDB_MAX_COLUMNS) {
     errorPrint("%s() LN%d, columns + tags is more than allowed max columns count: %d\n",
-        __func__, __LINE__, MAX_COLUMN_COUNT);
+        __func__, __LINE__, TSDB_MAX_COLUMNS);
     goto PARSE_OVER;
   }
   ret = true;
@@ -7919,7 +7942,7 @@ static void setParaFromArg(){
     g_Dbs.db[0].superTbls[0].maxSqlLen = g_args.max_sql_len;
 
     g_Dbs.db[0].superTbls[0].columnCount = 0;
-    for (int i = 0; i < MAX_NUM_DATATYPE; i++) {
+    for (int i = 0; i < MAX_NUM_COLUMNS; i++) {
       if (data_type[i] == NULL) {
         break;
       }

From 09b58e7e8e3d1156529ed7f0fdc5884ff7424887 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Wed, 14 Jul 2021 18:32:43 +0800
Subject: [PATCH 69/70] [TD-5259]<fix>: JDBC vulnerable packages. (#6858)

---
 cmake/install.inc                                   |  2 +-
 src/connector/jdbc/CMakeLists.txt                   |  4 ++--
 src/connector/jdbc/pom.xml                          |  6 +++---
 .../comparisonTest/cassandra/cassandratest/pom.xml  |  2 +-
 tests/comparisonTest/opentsdb/opentsdbtest/pom.xml  |  4 ++--
 tests/examples/JDBC/SpringJdbcTemplate/pom.xml      |  2 +-
 tests/examples/JDBC/connectionPools/pom.xml         | 13 +++++++++----
 .../com/taosdata/example/ConnectionPoolDemo.java    |  5 +++--
 .../com/taosdata/example/common/InsertTask.java     |  5 +++--
 tests/examples/JDBC/mybatisplus-demo/pom.xml        |  2 +-
 tests/examples/JDBC/taosdemo/pom.xml                | 12 ++++++------
 .../com/taosdata/taosdemo/TaosDemoApplication.java  |  5 +++--
 .../taosdata/taosdemo/dao/DatabaseMapperImpl.java   |  5 +++--
 .../taosdata/taosdemo/dao/SubTableMapperImpl.java   |  5 +++--
 .../taosdata/taosdemo/dao/SuperTableMapperImpl.java |  5 +++--
 .../com/taosdata/taosdemo/dao/TableMapperImpl.java  |  5 +++--
 .../taosdata/taosdemo/service/SubTableService.java  |  5 +++--
 17 files changed, 50 insertions(+), 37 deletions(-)

diff --git a/cmake/install.inc b/cmake/install.inc
index 30aa801122..fced638966 100755
--- a/cmake/install.inc
+++ b/cmake/install.inc
@@ -32,7 +32,7 @@ ELSEIF (TD_WINDOWS)
   #INSTALL(TARGETS taos RUNTIME DESTINATION driver)
   #INSTALL(TARGETS shell RUNTIME DESTINATION .)
   IF (TD_MVN_INSTALLED)
-    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.32-dist.jar DESTINATION connector/jdbc)
+    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-*-dist.jar DESTINATION connector/jdbc)
   ENDIF ()
 ELSEIF (TD_DARWIN)
   SET(TD_MAKE_INSTALL_SH "${TD_COMMUNITY_DIR}/packaging/tools/make_install.sh")
diff --git a/src/connector/jdbc/CMakeLists.txt b/src/connector/jdbc/CMakeLists.txt
index 81af0ec144..7791317969 100644
--- a/src/connector/jdbc/CMakeLists.txt
+++ b/src/connector/jdbc/CMakeLists.txt
@@ -8,8 +8,8 @@ IF (TD_MVN_INSTALLED)
   ADD_CUSTOM_COMMAND(OUTPUT ${JDBC_CMD_NAME}
     POST_BUILD
     COMMAND mvn -Dmaven.test.skip=true install -f ${CMAKE_CURRENT_SOURCE_DIR}/pom.xml
-    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.32-dist.jar ${LIBRARY_OUTPUT_PATH}
+    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-*-dist.jar ${LIBRARY_OUTPUT_PATH}
     COMMAND mvn -Dmaven.test.skip=true clean -f ${CMAKE_CURRENT_SOURCE_DIR}/pom.xml
     COMMENT "build jdbc driver")
   ADD_CUSTOM_TARGET(${JDBC_TARGET_NAME} ALL WORKING_DIRECTORY ${EXECUTABLE_OUTPUT_PATH} DEPENDS ${JDBC_CMD_NAME})
-ENDIF ()
\ No newline at end of file
+ENDIF ()
diff --git a/src/connector/jdbc/pom.xml b/src/connector/jdbc/pom.xml
index 61d7fb85ef..a1aa41b351 100644
--- a/src/connector/jdbc/pom.xml
+++ b/src/connector/jdbc/pom.xml
@@ -3,7 +3,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.taosdata.jdbc</groupId>
     <artifactId>taos-jdbcdriver</artifactId>
-    <version>2.0.32</version>
+    <version>2.0.33</version>
     <packaging>jar</packaging>
     <name>JDBCDriver</name>
     <url>https://github.com/taosdata/TDengine/tree/master/src/connector/jdbc</url>
@@ -40,7 +40,7 @@
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
-            <version>4.13</version>
+            <version>4.13.1</version>
             <scope>test</scope>
         </dependency>
         <!-- for restful -->
@@ -57,7 +57,7 @@
         <dependency>
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>
-            <version>29.0-jre</version>
+            <version>30.0-jre</version>
         </dependency>
     </dependencies>
 
diff --git a/tests/comparisonTest/cassandra/cassandratest/pom.xml b/tests/comparisonTest/cassandra/cassandratest/pom.xml
index 8eeb5c3aa0..00630d93d1 100644
--- a/tests/comparisonTest/cassandra/cassandratest/pom.xml
+++ b/tests/comparisonTest/cassandra/cassandratest/pom.xml
@@ -75,7 +75,7 @@
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
-      <version>4.11</version>
+      <version>4.13.1</version>
       <scope>test</scope>
     </dependency>
 
diff --git a/tests/comparisonTest/opentsdb/opentsdbtest/pom.xml b/tests/comparisonTest/opentsdb/opentsdbtest/pom.xml
index e0ada8b763..b55a136c73 100644
--- a/tests/comparisonTest/opentsdb/opentsdbtest/pom.xml
+++ b/tests/comparisonTest/opentsdb/opentsdbtest/pom.xml
@@ -87,14 +87,14 @@
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
-      <version>4.11</version>
+      <version>4.13.1</version>
       <scope>test</scope>
     </dependency>
 
     <dependency>
       <groupId>com.google.guava</groupId>
       <artifactId>guava</artifactId>
-      <version>29.0-jre</version>
+      <version>30.0-jre</version>
     </dependency>
 
     <dependency>
diff --git a/tests/examples/JDBC/SpringJdbcTemplate/pom.xml b/tests/examples/JDBC/SpringJdbcTemplate/pom.xml
index 64a91b951b..eac3dec0a9 100644
--- a/tests/examples/JDBC/SpringJdbcTemplate/pom.xml
+++ b/tests/examples/JDBC/SpringJdbcTemplate/pom.xml
@@ -40,7 +40,7 @@
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
-            <version>4.13</version>
+            <version>4.13.1</version>
             <scope>test</scope>
         </dependency>
 
diff --git a/tests/examples/JDBC/connectionPools/pom.xml b/tests/examples/JDBC/connectionPools/pom.xml
index 045e9d336c..34518900ed 100644
--- a/tests/examples/JDBC/connectionPools/pom.xml
+++ b/tests/examples/JDBC/connectionPools/pom.xml
@@ -4,6 +4,11 @@
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
+    <properties>
+     <maven.compiler.source>1.8</maven.compiler.source>
+     <maven.compiler.target>1.8</maven.compiler.target>
+    </properties>
+
     <groupId>com.taosdata.demo</groupId>
     <artifactId>connectionPools</artifactId>
     <version>1.0-SNAPSHOT</version>
@@ -46,9 +51,9 @@
         </dependency>
         <!-- log4j -->
         <dependency>
-            <groupId>log4j</groupId>
-            <artifactId>log4j</artifactId>
-            <version>1.2.17</version>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-core</artifactId>
+            <version>2.14.1</version>
         </dependency>
         <!-- proxool -->
         <dependency>
@@ -108,4 +113,4 @@
         </plugins>
     </build>
 
-</project>
\ No newline at end of file
+</project>
diff --git a/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/example/ConnectionPoolDemo.java b/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/example/ConnectionPoolDemo.java
index bd57d138b2..96ad65aa4f 100644
--- a/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/example/ConnectionPoolDemo.java
+++ b/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/example/ConnectionPoolDemo.java
@@ -5,7 +5,8 @@ import com.taosdata.example.pool.C3p0Builder;
 import com.taosdata.example.pool.DbcpBuilder;
 import com.taosdata.example.pool.DruidPoolBuilder;
 import com.taosdata.example.pool.HikariCpBuilder;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
 
 import javax.sql.DataSource;
 import java.sql.Connection;
@@ -17,7 +18,7 @@ import java.util.concurrent.TimeUnit;
 
 public class ConnectionPoolDemo {
 
-    private static Logger logger = Logger.getLogger(DruidPoolBuilder.class);
+    private static Logger logger = LogManager.getLogger(DruidPoolBuilder.class);
     private static final String dbName = "pool_test";
 
     private static String poolType = "hikari";
diff --git a/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/example/common/InsertTask.java b/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/example/common/InsertTask.java
index da7c9a22b5..f8f1555c08 100644
--- a/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/example/common/InsertTask.java
+++ b/tests/examples/JDBC/connectionPools/src/main/java/com/taosdata/example/common/InsertTask.java
@@ -1,6 +1,7 @@
 package com.taosdata.example.common;
 
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
 
 import javax.sql.DataSource;
 import java.sql.Connection;
@@ -10,7 +11,7 @@ import java.util.Random;
 
 public class InsertTask implements Runnable {
     private final Random random = new Random(System.currentTimeMillis());
-    private static final Logger logger = Logger.getLogger(InsertTask.class);
+    private static final Logger logger = LogManager.getLogger(InsertTask.class);
 
     private final DataSource ds;
     private final String dbName;
diff --git a/tests/examples/JDBC/mybatisplus-demo/pom.xml b/tests/examples/JDBC/mybatisplus-demo/pom.xml
index a83d0a00e6..ad6a63e800 100644
--- a/tests/examples/JDBC/mybatisplus-demo/pom.xml
+++ b/tests/examples/JDBC/mybatisplus-demo/pom.xml
@@ -68,7 +68,7 @@
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
-            <version>4.12</version>
+            <version>4.13.1</version>
             <scope>test</scope>
         </dependency>
     </dependencies>
diff --git a/tests/examples/JDBC/taosdemo/pom.xml b/tests/examples/JDBC/taosdemo/pom.xml
index 22c2f3b63e..91b976c2ae 100644
--- a/tests/examples/JDBC/taosdemo/pom.xml
+++ b/tests/examples/JDBC/taosdemo/pom.xml
@@ -4,7 +4,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.taosdata</groupId>
     <artifactId>taosdemo</artifactId>
-    <version>2.0</version>
+    <version>2.0.1</version>
     <name>taosdemo</name>
     <packaging>jar</packaging>
     <description>Demo project for TDengine</description>
@@ -81,20 +81,20 @@
         <dependency>
             <groupId>mysql</groupId>
             <artifactId>mysql-connector-java</artifactId>
-            <version>5.1.47</version>
+            <version>8.0.16</version>
             <scope>test</scope>
         </dependency>
         <!-- log4j -->
         <dependency>
-            <groupId>log4j</groupId>
-            <artifactId>log4j</artifactId>
-            <version>1.2.17</version>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-core</artifactId>
+            <version>2.14.1</version>
         </dependency>
         <!-- junit -->
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
-            <version>4.12</version>
+            <version>4.13.1</version>
             <scope>test</scope>
         </dependency>
         <!-- lombok -->
diff --git a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/TaosDemoApplication.java b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/TaosDemoApplication.java
index c361df82b0..d4f5ff2688 100644
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/TaosDemoApplication.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/TaosDemoApplication.java
@@ -8,7 +8,8 @@ import com.taosdata.taosdemo.service.SqlExecuteTask;
 import com.taosdata.taosdemo.service.SubTableService;
 import com.taosdata.taosdemo.service.SuperTableService;
 import com.taosdata.taosdemo.service.data.SuperTableMetaGenerator;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
 
 import javax.sql.DataSource;
 import java.io.IOException;
@@ -20,7 +21,7 @@ import java.util.Map;
 
 public class TaosDemoApplication {
 
-    private static final Logger logger = Logger.getLogger(TaosDemoApplication.class);
+    private static final Logger logger = LogManager.getLogger(TaosDemoApplication.class);
 
     public static void main(String[] args) throws IOException {
         // 读配置参数
diff --git a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/dao/DatabaseMapperImpl.java b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/dao/DatabaseMapperImpl.java
index 421a2dea1f..9340fc3fdd 100644
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/dao/DatabaseMapperImpl.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/dao/DatabaseMapperImpl.java
@@ -1,14 +1,15 @@
 package com.taosdata.taosdemo.dao;
 
 import com.taosdata.taosdemo.utils.SqlSpeller;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
 import org.springframework.jdbc.core.JdbcTemplate;
 
 import javax.sql.DataSource;
 import java.util.Map;
 
 public class DatabaseMapperImpl implements DatabaseMapper {
-    private static final Logger logger = Logger.getLogger(DatabaseMapperImpl.class);
+    private static final Logger logger = LogManager.getLogger(DatabaseMapperImpl.class);
 
     private final JdbcTemplate jdbcTemplate;
 
diff --git a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/dao/SubTableMapperImpl.java b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/dao/SubTableMapperImpl.java
index 90b0990a2b..db0d43ff05 100644
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/dao/SubTableMapperImpl.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/dao/SubTableMapperImpl.java
@@ -3,7 +3,8 @@ package com.taosdata.taosdemo.dao;
 import com.taosdata.taosdemo.domain.SubTableMeta;
 import com.taosdata.taosdemo.domain.SubTableValue;
 import com.taosdata.taosdemo.utils.SqlSpeller;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
 import org.springframework.jdbc.core.JdbcTemplate;
 
 import javax.sql.DataSource;
@@ -11,7 +12,7 @@ import java.util.List;
 
 public class SubTableMapperImpl implements SubTableMapper {
 
-    private static final Logger logger = Logger.getLogger(SubTableMapperImpl.class);
+    private static final Logger logger = LogManager.getLogger(SubTableMapperImpl.class);
     private final JdbcTemplate jdbcTemplate;
 
     public SubTableMapperImpl(DataSource dataSource) {
diff --git a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/dao/SuperTableMapperImpl.java b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/dao/SuperTableMapperImpl.java
index efa9a1f39e..658a403a0c 100644
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/dao/SuperTableMapperImpl.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/dao/SuperTableMapperImpl.java
@@ -2,13 +2,14 @@ package com.taosdata.taosdemo.dao;
 
 import com.taosdata.taosdemo.domain.SuperTableMeta;
 import com.taosdata.taosdemo.utils.SqlSpeller;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
 import org.springframework.jdbc.core.JdbcTemplate;
 
 import javax.sql.DataSource;
 
 public class SuperTableMapperImpl implements SuperTableMapper {
-    private static final Logger logger = Logger.getLogger(SuperTableMapperImpl.class);
+    private static final Logger logger = LogManager.getLogger(SuperTableMapperImpl.class);
     private JdbcTemplate jdbcTemplate;
 
     public SuperTableMapperImpl(DataSource dataSource) {
diff --git a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/dao/TableMapperImpl.java b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/dao/TableMapperImpl.java
index b049fbe197..16bc094848 100644
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/dao/TableMapperImpl.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/dao/TableMapperImpl.java
@@ -3,13 +3,14 @@ package com.taosdata.taosdemo.dao;
 import com.taosdata.taosdemo.domain.TableMeta;
 import com.taosdata.taosdemo.domain.TableValue;
 import com.taosdata.taosdemo.utils.SqlSpeller;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
 import org.springframework.jdbc.core.JdbcTemplate;
 
 import java.util.List;
 
 public class TableMapperImpl implements TableMapper {
-    private static final Logger logger = Logger.getLogger(TableMapperImpl.class);
+    private static final Logger logger = LogManager.getLogger(TableMapperImpl.class);
     private JdbcTemplate template;
 
     @Override
diff --git a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/SubTableService.java b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/SubTableService.java
index cea98a1c5d..b0a79dea78 100644
--- a/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/SubTableService.java
+++ b/tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/service/SubTableService.java
@@ -8,7 +8,8 @@ import com.taosdata.taosdemo.domain.SubTableValue;
 import com.taosdata.taosdemo.domain.SuperTableMeta;
 import com.taosdata.taosdemo.service.data.SubTableMetaGenerator;
 import com.taosdata.taosdemo.service.data.SubTableValueGenerator;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
 
 import javax.sql.DataSource;
 import java.util.ArrayList;
@@ -20,7 +21,7 @@ import java.util.stream.IntStream;
 public class SubTableService extends AbstractService {
 
     private SubTableMapper mapper;
-    private static final Logger logger = Logger.getLogger(SubTableService.class);
+    private static final Logger logger = LogManager.getLogger(SubTableService.class);
 
     public SubTableService(DataSource datasource) {
         this.mapper = new SubTableMapperImpl(datasource);

From c62ebe7dc270ef59f700cb5693e419137138d4d4 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Thu, 15 Jul 2021 09:53:11 +0800
Subject: [PATCH 70/70] Feature/sangshuduo/td 5136 taosdemo rework (#6852)

* [TD-5136]<feature>: taosdemo simulate real senario.

* update test case according to taosdemo change

* adjust range of semi-random data.

* make demo mode use different tag name and value.

* change malloc to calloc for pid allocation.

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/kit/taosdemo/taosdemo.c | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index d088d015d5..9c547ff755 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -946,7 +946,6 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
             for (int col = arguments->num_of_CPR; col < MAX_NUM_COLUMNS; col++) {
                 arguments->datatype[col] = NULL;
             }
-
         } else if (strcmp(argv[i], "-b") == 0) {
             arguments->demo_mode = false;
             if (argc == i+1) {
@@ -3104,7 +3103,7 @@ static int startMultiThreadCreateChildTable(
         char* cols, int threads, uint64_t tableFrom, int64_t ntables,
         char* db_name, SSuperTable* superTblInfo) {
 
-  pthread_t *pids = malloc(threads * sizeof(pthread_t));
+  pthread_t *pids = calloc(1, threads * sizeof(pthread_t));
   threadInfo *infos = calloc(1, threads * sizeof(threadInfo));
 
   if ((NULL == pids) || (NULL == infos)) {
@@ -6602,7 +6601,7 @@ static void startMultiThreadInsertData(int threads, char* db_name,
       }
   }
 
-  pthread_t *pids = malloc(threads * sizeof(pthread_t));
+  pthread_t *pids = calloc(1, threads * sizeof(pthread_t));
   assert(pids != NULL);
 
   threadInfo *infos = calloc(1, threads * sizeof(threadInfo));
@@ -7261,8 +7260,8 @@ static int queryTestProcess() {
 
   if ((nSqlCount > 0) && (nConcurrent > 0)) {
 
-    pids  = malloc(nConcurrent * nSqlCount * sizeof(pthread_t));
-    infos = malloc(nConcurrent * nSqlCount * sizeof(threadInfo));
+    pids  = calloc(1, nConcurrent * nSqlCount * sizeof(pthread_t));
+    infos = calloc(1, nConcurrent * nSqlCount * sizeof(threadInfo));
 
     if ((NULL == pids) || (NULL == infos)) {
       taos_close(taos);
@@ -7307,8 +7306,8 @@ static int queryTestProcess() {
   //==== create sub threads for query from all sub table of the super table
   if ((g_queryInfo.superQueryInfo.sqlCount > 0)
           && (g_queryInfo.superQueryInfo.threadCnt > 0)) {
-    pidsOfSub  = malloc(g_queryInfo.superQueryInfo.threadCnt * sizeof(pthread_t));
-    infosOfSub = malloc(g_queryInfo.superQueryInfo.threadCnt * sizeof(threadInfo));
+    pidsOfSub  = calloc(1, g_queryInfo.superQueryInfo.threadCnt * sizeof(pthread_t));
+    infosOfSub = calloc(1, g_queryInfo.superQueryInfo.threadCnt * sizeof(threadInfo));
 
     if ((NULL == pidsOfSub) || (NULL == infosOfSub)) {
       free(infos);
@@ -7741,11 +7740,13 @@ static int subscribeTestProcess() {
         exit(-1);
     }
 
-    pids  = malloc(
+    pids  = calloc(
+            1,
             g_queryInfo.specifiedQueryInfo.sqlCount *
             g_queryInfo.specifiedQueryInfo.concurrent *
             sizeof(pthread_t));
-    infos = malloc(
+    infos = calloc(
+            1,
             g_queryInfo.specifiedQueryInfo.sqlCount *
             g_queryInfo.specifiedQueryInfo.concurrent *
             sizeof(threadInfo));
@@ -7774,11 +7775,13 @@ static int subscribeTestProcess() {
   } else {
     if ((g_queryInfo.superQueryInfo.sqlCount > 0)
           && (g_queryInfo.superQueryInfo.threadCnt > 0)) {
-        pidsOfStable  = malloc(
+        pidsOfStable  = calloc(
+                1,
                 g_queryInfo.superQueryInfo.sqlCount *
                 g_queryInfo.superQueryInfo.threadCnt *
             sizeof(pthread_t));
-        infosOfStable = malloc(
+        infosOfStable = calloc(
+                1,
                 g_queryInfo.superQueryInfo.sqlCount *
                 g_queryInfo.superQueryInfo.threadCnt *
             sizeof(threadInfo));
@@ -8095,7 +8098,7 @@ static void queryResult() {
   // query data
 
   pthread_t read_id;
-  threadInfo *pThreadInfo = malloc(sizeof(threadInfo));
+  threadInfo *pThreadInfo = calloc(1, sizeof(threadInfo));
   assert(pThreadInfo);
   pThreadInfo->start_time = 1500000000000;  // 2017-07-14 10:40:00.000
   pThreadInfo->start_table_from = 0;