Merge branch '3.0' of https://github.com/taosdata/TDengine into perf/row_iter_optimize

docs/en/12-taos-sql/06-select.md

@@ -334,6 +334,20 @@ If no comparison or condition is true, the result after ELSE is returned, or NUL
 
 The return type of the CASE expression is the result type of the first WHEN WHEN part, and the result type of the other WHEN WHEN parts and ELSE parts can be converted to them, otherwise TDengine will report an error.
 
+### Examples
+
+A device has three status codes to display its status. The statements are as follows:
+
+```sql
+SELECT CASE dev_status WHEN 1 THEN 'Running' WHEN 2 THEN 'Warning' WHEN 3 THEN 'Downtime' ELSE 'Unknown' END FROM dev_table;
+```
+
+The average voltage value of the smart meter is counted. When the voltage is less than 200 or more than 250, it is considered that the statistics is wrong, and the value is corrected to 220. The statement is as follows:
+
+```sql
+SELECT AVG(CASE WHEN voltage < 200 or voltage > 250 THEN 220 ELSE voltage END) FROM meters;
+```
+
 ## JOIN
 
 TDengine supports natural joins between supertables, between standard tables, and between subqueries. The difference between natural joins and inner joins is that natural joins require that the fields being joined in the supertables or standard tables must have the same name. Data or tag columns must be joined with the equivalent column in another table.

docs/zh/12-taos-sql/06-select.md

@@ -325,14 +325,28 @@ CASE WHEN condition THEN result [WHEN condition THEN result ...] [ELSE result] E
 ```
 
 ### 说明
+
 TDengine 通过 CASE 表达式让用户可以在 SQL 语句中使用 IF ... THEN ... ELSE 逻辑。
+
 第一种 CASE 语法返回第一个 value 等于 compare_value 的 result，如果没有 compare_value 符合，则返回 ELSE 之后的 result，如果没有 ELSE 部分，则返回 NULL。
 
 第二种语法返回第一个 condition 为真的 result。 如果没有 condition 符合，则返回 ELSE 之后的 result，如果没有 ELSE 部分，则返回 NULL。
 
 CASE 表达式的返回类型为第一个 WHEN THEN 部分的 result 类型，其余 WHEN THEN 部分和 ELSE 部分，result 类型都需要可以向其转换，否则 TDengine 会报错。
 
+### 示例
+
+某设备有三个状态码，显示其状态，语句如下：
 
+```sql
+SELECT CASE dev_status WHEN 1 THEN 'Running' WHEN 2 THEN 'Warning' WHEN 3 THEN 'Downtime' ELSE 'Unknown' END FROM dev_table;
+```
+
+统计智能电表的电压平均值，当电压小于 200 或大于 250 时认为是统计有误，修正其值为 220，语句如下：
+
+```sql
+SELECT AVG(CASE WHEN voltage < 200 or voltage > 250 THEN 220 ELSE voltage END) FROM meters;
+```
 
 ## JOIN 子句
 

include/common/tdataformat.h

@@ -134,6 +134,7 @@ int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal);
 void    tColDataGetValue(SColData *pColData, int32_t iVal, SColVal *pColVal);
 uint8_t tColDataGetBitValue(SColData *pColData, int32_t iVal);
 int32_t tColDataCopy(SColData *pColDataSrc, SColData *pColDataDest);
+extern void (*tColDataCalcSMA[])(SColData *pColData, int64_t *sum, int64_t *max, int64_t *min, int16_t *numOfNull);
 
 // STRUCT ================================
 struct STColumn {

source/common/src/tdataformat.c

@@ -1642,3 +1642,385 @@ int32_t tColDataCopy(SColData *pColDataSrc, SColData *pColDataDest) {
 _exit:
   return code;
 }
+
+#define CALC_SUM_MAX_MIN(SUM, MAX, MIN, VAL) \
+  do {                                       \
+    (SUM) += (VAL);                          \
+    if ((MAX) < (VAL)) (MAX) = (VAL);        \
+    if ((MIN) > (VAL)) (MIN) = (VAL);        \
+  } while (0)
+
+static FORCE_INLINE void tColDataCalcSMABool(SColData *pColData, int64_t *sum, int64_t *max, int64_t *min,
+                                             int16_t *numOfNull) {
+  *sum = 0;
+  *max = 0;
+  *min = 1;
+  *numOfNull = 0;
+
+  int8_t val;
+  if (HAS_VALUE == pColData->flag) {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      val = ((int8_t *)pColData->pData)[iVal] ? 1 : 0;
+      CALC_SUM_MAX_MIN(*sum, *max, *min, val);
+    }
+  } else {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      switch (tColDataGetBitValue(pColData, iVal)) {
+        case 0:
+        case 1:
+          (*numOfNull)++;
+          break;
+        case 2:
+          val = ((int8_t *)pColData->pData)[iVal] ? 1 : 0;
+          CALC_SUM_MAX_MIN(*sum, *max, *min, val);
+          break;
+        default:
+          ASSERT(0);
+          break;
+      }
+    }
+  }
+}
+
+static FORCE_INLINE void tColDataCalcSMATinyInt(SColData *pColData, int64_t *sum, int64_t *max, int64_t *min,
+                                                int16_t *numOfNull) {
+  *sum = 0;
+  *max = INT8_MIN;
+  *min = INT8_MAX;
+  *numOfNull = 0;
+
+  int8_t val;
+  if (HAS_VALUE == pColData->flag) {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      val = ((int8_t *)pColData->pData)[iVal];
+      CALC_SUM_MAX_MIN(*sum, *max, *min, val);
+    }
+  } else {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      switch (tColDataGetBitValue(pColData, iVal)) {
+        case 0:
+        case 1:
+          (*numOfNull)++;
+          break;
+        case 2:
+          val = ((int8_t *)pColData->pData)[iVal];
+          CALC_SUM_MAX_MIN(*sum, *max, *min, val);
+          break;
+        default:
+          ASSERT(0);
+          break;
+      }
+    }
+  }
+}
+
+static FORCE_INLINE void tColDataCalcSMATinySmallInt(SColData *pColData, int64_t *sum, int64_t *max, int64_t *min,
+                                                     int16_t *numOfNull) {
+  *sum = 0;
+  *max = INT16_MIN;
+  *min = INT16_MAX;
+  *numOfNull = 0;
+
+  int16_t val;
+  if (HAS_VALUE == pColData->flag) {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      val = ((int16_t *)pColData->pData)[iVal];
+      CALC_SUM_MAX_MIN(*sum, *max, *min, val);
+    }
+  } else {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      switch (tColDataGetBitValue(pColData, iVal)) {
+        case 0:
+        case 1:
+          (*numOfNull)++;
+          break;
+        case 2:
+          val = ((int16_t *)pColData->pData)[iVal];
+          CALC_SUM_MAX_MIN(*sum, *max, *min, val);
+          break;
+        default:
+          ASSERT(0);
+          break;
+      }
+    }
+  }
+}
+
+static FORCE_INLINE void tColDataCalcSMAInt(SColData *pColData, int64_t *sum, int64_t *max, int64_t *min,
+                                            int16_t *numOfNull) {
+  *sum = 0;
+  *max = INT32_MIN;
+  *min = INT32_MAX;
+  *numOfNull = 0;
+
+  int32_t val;
+  if (HAS_VALUE == pColData->flag) {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      val = ((int32_t *)pColData->pData)[iVal];
+      CALC_SUM_MAX_MIN(*sum, *max, *min, val);
+    }
+  } else {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      switch (tColDataGetBitValue(pColData, iVal)) {
+        case 0:
+        case 1:
+          (*numOfNull)++;
+          break;
+        case 2:
+          val = ((int32_t *)pColData->pData)[iVal];
+          CALC_SUM_MAX_MIN(*sum, *max, *min, val);
+          break;
+        default:
+          ASSERT(0);
+          break;
+      }
+    }
+  }
+}
+
+static FORCE_INLINE void tColDataCalcSMABigInt(SColData *pColData, int64_t *sum, int64_t *max, int64_t *min,
+                                               int16_t *numOfNull) {
+  *sum = 0;
+  *max = INT64_MIN;
+  *min = INT64_MAX;
+  *numOfNull = 0;
+
+  int64_t val;
+  if (HAS_VALUE == pColData->flag) {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      val = ((int64_t *)pColData->pData)[iVal];
+      CALC_SUM_MAX_MIN(*sum, *max, *min, val);
+    }
+  } else {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      switch (tColDataGetBitValue(pColData, iVal)) {
+        case 0:
+        case 1:
+          (*numOfNull)++;
+          break;
+        case 2:
+          val = ((int64_t *)pColData->pData)[iVal];
+          CALC_SUM_MAX_MIN(*sum, *max, *min, val);
+          break;
+        default:
+          ASSERT(0);
+          break;
+      }
+    }
+  }
+}
+
+static FORCE_INLINE void tColDataCalcSMAFloat(SColData *pColData, int64_t *sum, int64_t *max, int64_t *min,
+                                              int16_t *numOfNull) {
+  *(double *)sum = 0;
+  *(double *)max = -FLT_MAX;
+  *(double *)min = FLT_MAX;
+  *numOfNull = 0;
+
+  float val;
+  if (HAS_VALUE == pColData->flag) {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      val = ((float *)pColData->pData)[iVal];
+      CALC_SUM_MAX_MIN(*(double *)sum, *(double *)max, *(double *)min, val);
+    }
+  } else {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      switch (tColDataGetBitValue(pColData, iVal)) {
+        case 0:
+        case 1:
+          (*numOfNull)++;
+          break;
+        case 2:
+          val = ((float *)pColData->pData)[iVal];
+          CALC_SUM_MAX_MIN(*(double *)sum, *(double *)max, *(double *)min, val);
+          break;
+        default:
+          ASSERT(0);
+          break;
+      }
+    }
+  }
+}
+
+static FORCE_INLINE void tColDataCalcSMADouble(SColData *pColData, int64_t *sum, int64_t *max, int64_t *min,
+                                               int16_t *numOfNull) {
+  *(double *)sum = 0;
+  *(double *)max = -DBL_MAX;
+  *(double *)min = DBL_MAX;
+  *numOfNull = 0;
+
+  double val;
+  if (HAS_VALUE == pColData->flag) {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      val = ((double *)pColData->pData)[iVal];
+      CALC_SUM_MAX_MIN(*(double *)sum, *(double *)max, *(double *)min, val);
+    }
+  } else {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      switch (tColDataGetBitValue(pColData, iVal)) {
+        case 0:
+        case 1:
+          (*numOfNull)++;
+          break;
+        case 2:
+          val = ((double *)pColData->pData)[iVal];
+          CALC_SUM_MAX_MIN(*(double *)sum, *(double *)max, *(double *)min, val);
+          break;
+        default:
+          ASSERT(0);
+          break;
+      }
+    }
+  }
+}
+
+static FORCE_INLINE void tColDataCalcSMAUTinyInt(SColData *pColData, int64_t *sum, int64_t *max, int64_t *min,
+                                                 int16_t *numOfNull) {
+  *(uint64_t *)sum = 0;
+  *(uint64_t *)max = 0;
+  *(uint64_t *)min = UINT8_MAX;
+  *numOfNull = 0;
+
+  uint8_t val;
+  if (HAS_VALUE == pColData->flag) {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      val = ((uint8_t *)pColData->pData)[iVal];
+      CALC_SUM_MAX_MIN(*(uint64_t *)sum, *(uint64_t *)max, *(uint64_t *)min, val);
+    }
+  } else {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      switch (tColDataGetBitValue(pColData, iVal)) {
+        case 0:
+        case 1:
+          (*numOfNull)++;
+          break;
+        case 2:
+          val = ((uint8_t *)pColData->pData)[iVal];
+          CALC_SUM_MAX_MIN(*(uint64_t *)sum, *(uint64_t *)max, *(uint64_t *)min, val);
+          break;
+        default:
+          ASSERT(0);
+          break;
+      }
+    }
+  }
+}
+
+static FORCE_INLINE void tColDataCalcSMATinyUSmallInt(SColData *pColData, int64_t *sum, int64_t *max, int64_t *min,
+                                                      int16_t *numOfNull) {
+  *(uint64_t *)sum = 0;
+  *(uint64_t *)max = 0;
+  *(uint64_t *)min = UINT16_MAX;
+  *numOfNull = 0;
+
+  uint16_t val;
+  if (HAS_VALUE == pColData->flag) {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      val = ((uint16_t *)pColData->pData)[iVal];
+      CALC_SUM_MAX_MIN(*(uint64_t *)sum, *(uint64_t *)max, *(uint64_t *)min, val);
+    }
+  } else {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      switch (tColDataGetBitValue(pColData, iVal)) {
+        case 0:
+        case 1:
+          (*numOfNull)++;
+          break;
+        case 2:
+          val = ((uint16_t *)pColData->pData)[iVal];
+          CALC_SUM_MAX_MIN(*(uint64_t *)sum, *(uint64_t *)max, *(uint64_t *)min, val);
+          break;
+        default:
+          ASSERT(0);
+          break;
+      }
+    }
+  }
+}
+
+static FORCE_INLINE void tColDataCalcSMAUInt(SColData *pColData, int64_t *sum, int64_t *max, int64_t *min,
+                                             int16_t *numOfNull) {
+  *(uint64_t *)sum = 0;
+  *(uint64_t *)max = 0;
+  *(uint64_t *)min = UINT32_MAX;
+  *numOfNull = 0;
+
+  uint32_t val;
+  if (HAS_VALUE == pColData->flag) {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      val = ((uint32_t *)pColData->pData)[iVal];
+      CALC_SUM_MAX_MIN(*(uint64_t *)sum, *(uint64_t *)max, *(uint64_t *)min, val);
+    }
+  } else {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      switch (tColDataGetBitValue(pColData, iVal)) {
+        case 0:
+        case 1:
+          (*numOfNull)++;
+          break;
+        case 2:
+          val = ((uint32_t *)pColData->pData)[iVal];
+          CALC_SUM_MAX_MIN(*(uint64_t *)sum, *(uint64_t *)max, *(uint64_t *)min, val);
+          break;
+        default:
+          ASSERT(0);
+          break;
+      }
+    }
+  }
+}
+
+static FORCE_INLINE void tColDataCalcSMAUBigInt(SColData *pColData, int64_t *sum, int64_t *max, int64_t *min,
+                                                int16_t *numOfNull) {
+  *(uint64_t *)sum = 0;
+  *(uint64_t *)max = 0;
+  *(uint64_t *)min = UINT64_MAX;
+  *numOfNull = 0;
+
+  uint64_t val;
+  if (HAS_VALUE == pColData->flag) {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      val = ((uint64_t *)pColData->pData)[iVal];
+      CALC_SUM_MAX_MIN(*(uint64_t *)sum, *(uint64_t *)max, *(uint64_t *)min, val);
+    }
+  } else {
+    for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
+      switch (tColDataGetBitValue(pColData, iVal)) {
+        case 0:
+        case 1:
+          (*numOfNull)++;
+          break;
+        case 2:
+          val = ((uint64_t *)pColData->pData)[iVal];
+          CALC_SUM_MAX_MIN(*(uint64_t *)sum, *(uint64_t *)max, *(uint64_t *)min, val);
+          break;
+        default:
+          ASSERT(0);
+          break;
+      }
+    }
+  }
+}
+
+void (*tColDataCalcSMA[])(SColData *pColData, int64_t *sum, int64_t *max, int64_t *min, int16_t *numOfNull) = {
+    NULL,
+    tColDataCalcSMABool,           // TSDB_DATA_TYPE_BOOL
+    tColDataCalcSMATinyInt,        // TSDB_DATA_TYPE_TINYINT
+    tColDataCalcSMATinySmallInt,   // TSDB_DATA_TYPE_SMALLINT
+    tColDataCalcSMAInt,            // TSDB_DATA_TYPE_INT
+    tColDataCalcSMABigInt,         // TSDB_DATA_TYPE_BIGINT
+    tColDataCalcSMAFloat,          // TSDB_DATA_TYPE_FLOAT
+    tColDataCalcSMADouble,         // TSDB_DATA_TYPE_DOUBLE
+    NULL,                          // TSDB_DATA_TYPE_VARCHAR
+    tColDataCalcSMABigInt,         // TSDB_DATA_TYPE_TIMESTAMP
+    NULL,                          // TSDB_DATA_TYPE_NCHAR
+    tColDataCalcSMAUTinyInt,       // TSDB_DATA_TYPE_UTINYINT
+    tColDataCalcSMATinyUSmallInt,  // TSDB_DATA_TYPE_USMALLINT
+    tColDataCalcSMAUInt,           // TSDB_DATA_TYPE_UINT
+    tColDataCalcSMAUBigInt,        // TSDB_DATA_TYPE_UBIGINT
+    NULL,                          // TSDB_DATA_TYPE_JSON
+    NULL,                          // TSDB_DATA_TYPE_VARBINARY
+    NULL,                          // TSDB_DATA_TYPE_DECIMAL
+    NULL,                          // TSDB_DATA_TYPE_BLOB
+    NULL                           // TSDB_DATA_TYPE_MEDIUMBLOB
+};

source/dnode/mgmt/mgmt_vnode/src/vmWorker.c

@@ -155,9 +155,13 @@ static int32_t vmPutMsgToQueue(SVnodeMgmt *pMgmt, SRpcMsg *pMsg, EQueueType qtyp
 
   switch (qtype) {
     case QUERY_QUEUE:
-      vnodePreprocessQueryMsg(pVnode->pImpl, pMsg);
+      code = vnodePreprocessQueryMsg(pVnode->pImpl, pMsg);
+      if (code) {
+        dError("vgId:%d, msg:%p preprocess query msg failed since %s", pVnode->vgId, pMsg, terrstr(code));
+      } else {
         dGTrace("vgId:%d, msg:%p put into vnode-query queue", pVnode->vgId, pMsg);
         taosWriteQitem(pVnode->pQueryQ, pMsg);
+      }
       break;
     case STREAM_QUEUE:
       dGTrace("vgId:%d, msg:%p put into vnode-stream queue", pVnode->vgId, pMsg);

source/dnode/vnode/src/inc/tsdb.h

@@ -191,7 +191,6 @@ int32_t tsdbKeyFid(TSKEY key, int32_t minutes, int8_t precision);
 void    tsdbFidKeyRange(int32_t fid, int32_t minutes, int8_t precision, TSKEY *minKey, TSKEY *maxKey);
 int32_t tsdbFidLevel(int32_t fid, STsdbKeepCfg *pKeepCfg, int64_t now);
 int32_t tsdbBuildDeleteSkyline(SArray *aDelData, int32_t sidx, int32_t eidx, SArray *aSkyline);
-void    tsdbCalcColDataSMA(SColData *pColData, SColumnDataAgg *pColAgg);
 int32_t tPutColumnDataAgg(uint8_t *p, SColumnDataAgg *pColAgg);
 int32_t tGetColumnDataAgg(uint8_t *p, SColumnDataAgg *pColAgg);
 int32_t tsdbCmprData(uint8_t *pIn, int32_t szIn, int8_t type, int8_t cmprAlg, uint8_t **ppOut, int32_t nOut,

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

@@ -427,13 +427,13 @@ static int32_t (*tDiskColAddValImpl[8][3])(SDiskColBuilder *pBuilder, SColVal *p
     {tDiskColAddVal60, tDiskColAddVal61, tDiskColAddVal62},  // HAS_VALUE|HAS_NULL
     {tDiskColAddVal70, tDiskColAddVal71, tDiskColAddVal72}   // HAS_VALUE|HAS_NULL|HAS_NONE
 };
-extern void (*tSmaUpdateImpl[])(SColumnDataAgg *pColAgg, SColVal *pColVal, uint8_t *minSet, uint8_t *maxSet);
+// extern void (*tSmaUpdateImpl[])(SColumnDataAgg *pColAgg, SColVal *pColVal, uint8_t *minSet, uint8_t *maxSet);
 static int32_t tDiskColAddVal(SDiskColBuilder *pBuilder, SColVal *pColVal) {
   int32_t code = 0;
 
   if (pBuilder->calcSma) {
     if (COL_VAL_IS_VALUE(pColVal)) {
-      tSmaUpdateImpl[pBuilder->type](&pBuilder->sma, pColVal, &pBuilder->minSet, &pBuilder->maxSet);
+      // tSmaUpdateImpl[pBuilder->type](&pBuilder->sma, pColVal, &pBuilder->minSet, &pBuilder->maxSet);
     } else {
       pBuilder->sma.numOfNull++;
     }

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

@@ -519,8 +519,8 @@ static int32_t tsdbWriteBlockSma(SDataFWriter *pWriter, SBlockData *pBlockData,
 
     if ((!pColData->smaOn) || IS_VAR_DATA_TYPE(pColData->type)) continue;
 
-    SColumnDataAgg sma;
-    tsdbCalcColDataSMA(pColData, &sma);
+    SColumnDataAgg sma = {.colId = pColData->cid};
+    tColDataCalcSMA[pColData->type](pColData, &sma.sum, &sma.max, &sma.min, &sma.numOfNull);
 
     code = tRealloc(&pWriter->aBuf[0], pSmaInfo->size + tPutColumnDataAgg(NULL, &sma));
     if (code) goto _err;

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

@@ -1437,111 +1437,6 @@ int32_t tGetColumnDataAgg(uint8_t *p, SColumnDataAgg *pColAgg) {
   return n;
 }
 
-#define SMA_UPDATE(SUM_V, MIN_V, MAX_V, VAL, MINSET, MAXSET) \
-  do {                                                       \
-    (SUM_V) += (VAL);                                        \
-    if (!(MINSET)) {                                         \
-      (MIN_V) = (VAL);                                       \
-      (MINSET) = 1;                                          \
-    } else if ((MIN_V) > (VAL)) {                            \
-      (MIN_V) = (VAL);                                       \
-    }                                                        \
-    if (!(MAXSET)) {                                         \
-      (MAX_V) = (VAL);                                       \
-      (MAXSET) = 1;                                          \
-    } else if ((MAX_V) < (VAL)) {                            \
-      (MAX_V) = (VAL);                                       \
-    }                                                        \
-  } while (0)
-
-static FORCE_INLINE void tSmaUpdateBool(SColumnDataAgg *pColAgg, SColVal *pColVal, uint8_t *minSet, uint8_t *maxSet) {
-  int8_t val = *(int8_t *)&pColVal->value.val ? 1 : 0;
-  SMA_UPDATE(pColAgg->sum, pColAgg->min, pColAgg->max, val, *minSet, *maxSet);
-}
-static FORCE_INLINE void tSmaUpdateTinyint(SColumnDataAgg *pColAgg, SColVal *pColVal, uint8_t *minSet,
-                                           uint8_t *maxSet) {
-  int8_t val = *(int8_t *)&pColVal->value.val;
-  SMA_UPDATE(pColAgg->sum, pColAgg->min, pColAgg->max, val, *minSet, *maxSet);
-}
-static FORCE_INLINE void tSmaUpdateSmallint(SColumnDataAgg *pColAgg, SColVal *pColVal, uint8_t *minSet,
-                                            uint8_t *maxSet) {
-  int16_t val = *(int16_t *)&pColVal->value.val;
-  SMA_UPDATE(pColAgg->sum, pColAgg->min, pColAgg->max, val, *minSet, *maxSet);
-}
-static FORCE_INLINE void tSmaUpdateInt(SColumnDataAgg *pColAgg, SColVal *pColVal, uint8_t *minSet, uint8_t *maxSet) {
-  int32_t val = *(int32_t *)&pColVal->value.val;
-  SMA_UPDATE(pColAgg->sum, pColAgg->min, pColAgg->max, val, *minSet, *maxSet);
-}
-static FORCE_INLINE void tSmaUpdateBigint(SColumnDataAgg *pColAgg, SColVal *pColVal, uint8_t *minSet, uint8_t *maxSet) {
-  int64_t val = *(int64_t *)&pColVal->value.val;
-  SMA_UPDATE(pColAgg->sum, pColAgg->min, pColAgg->max, val, *minSet, *maxSet);
-}
-static FORCE_INLINE void tSmaUpdateFloat(SColumnDataAgg *pColAgg, SColVal *pColVal, uint8_t *minSet, uint8_t *maxSet) {
-  float val = *(float *)&pColVal->value.val;
-  SMA_UPDATE(*(double *)&pColAgg->sum, *(double *)&pColAgg->min, *(double *)&pColAgg->max, val, *minSet, *maxSet);
-}
-static FORCE_INLINE void tSmaUpdateDouble(SColumnDataAgg *pColAgg, SColVal *pColVal, uint8_t *minSet, uint8_t *maxSet) {
-  double val = *(double *)&pColVal->value.val;
-  SMA_UPDATE(*(double *)&pColAgg->sum, *(double *)&pColAgg->min, *(double *)&pColAgg->max, val, *minSet, *maxSet);
-}
-static FORCE_INLINE void tSmaUpdateUTinyint(SColumnDataAgg *pColAgg, SColVal *pColVal, uint8_t *minSet,
-                                            uint8_t *maxSet) {
-  uint8_t val = *(uint8_t *)&pColVal->value.val;
-  SMA_UPDATE(pColAgg->sum, pColAgg->min, pColAgg->max, val, *minSet, *maxSet);
-}
-static FORCE_INLINE void tSmaUpdateUSmallint(SColumnDataAgg *pColAgg, SColVal *pColVal, uint8_t *minSet,
-                                             uint8_t *maxSet) {
-  uint16_t val = *(uint16_t *)&pColVal->value.val;
-  SMA_UPDATE(pColAgg->sum, pColAgg->min, pColAgg->max, val, *minSet, *maxSet);
-}
-static FORCE_INLINE void tSmaUpdateUInt(SColumnDataAgg *pColAgg, SColVal *pColVal, uint8_t *minSet, uint8_t *maxSet) {
-  uint32_t val = *(uint32_t *)&pColVal->value.val;
-  SMA_UPDATE(pColAgg->sum, pColAgg->min, pColAgg->max, val, *minSet, *maxSet);
-}
-static FORCE_INLINE void tSmaUpdateUBigint(SColumnDataAgg *pColAgg, SColVal *pColVal, uint8_t *minSet,
-                                           uint8_t *maxSet) {
-  uint64_t val = *(uint64_t *)&pColVal->value.val;
-  SMA_UPDATE(pColAgg->sum, pColAgg->min, pColAgg->max, val, *minSet, *maxSet);
-}
-void (*tSmaUpdateImpl[])(SColumnDataAgg *pColAgg, SColVal *pColVal, uint8_t *minSet, uint8_t *maxSet) = {
-    NULL,
-    tSmaUpdateBool,       // TSDB_DATA_TYPE_BOOL
-    tSmaUpdateTinyint,    // TSDB_DATA_TYPE_TINYINT
-    tSmaUpdateSmallint,   // TSDB_DATA_TYPE_SMALLINT
-    tSmaUpdateInt,        // TSDB_DATA_TYPE_INT
-    tSmaUpdateBigint,     // TSDB_DATA_TYPE_BIGINT
-    tSmaUpdateFloat,      // TSDB_DATA_TYPE_FLOAT
-    tSmaUpdateDouble,     // TSDB_DATA_TYPE_DOUBLE
-    NULL,                 // TSDB_DATA_TYPE_VARCHAR
-    tSmaUpdateBigint,     // TSDB_DATA_TYPE_TIMESTAMP
-    NULL,                 // TSDB_DATA_TYPE_NCHAR
-    tSmaUpdateUTinyint,   // TSDB_DATA_TYPE_UTINYINT
-    tSmaUpdateUSmallint,  // TSDB_DATA_TYPE_USMALLINT
-    tSmaUpdateUInt,       // TSDB_DATA_TYPE_UINT
-    tSmaUpdateUBigint,    // TSDB_DATA_TYPE_UBIGINT
-    NULL,                 // TSDB_DATA_TYPE_JSON
-    NULL,                 // TSDB_DATA_TYPE_VARBINARY
-    NULL,                 // TSDB_DATA_TYPE_DECIMAL
-    NULL,                 // TSDB_DATA_TYPE_BLOB
-    NULL,                 // TSDB_DATA_TYPE_MEDIUMBLOB
-};
-void tsdbCalcColDataSMA(SColData *pColData, SColumnDataAgg *pColAgg) {
-  *pColAgg = (SColumnDataAgg){.colId = pColData->cid};
-  uint8_t minSet = 0;
-  uint8_t maxSet = 0;
-
-  SColVal cv;
-  for (int32_t iVal = 0; iVal < pColData->nVal; iVal++) {
-    tColDataGetValue(pColData, iVal, &cv);
-
-    if (COL_VAL_IS_VALUE(&cv)) {
-      tSmaUpdateImpl[pColData->type](pColAgg, &cv, &minSet, &maxSet);
-    } else {
-      pColAgg->numOfNull++;
-    }
-  }
-}
-
 int32_t tsdbCmprData(uint8_t *pIn, int32_t szIn, int8_t type, int8_t cmprAlg, uint8_t **ppOut, int32_t nOut,
                      int32_t *szOut, uint8_t **ppBuf) {
   int32_t code = 0;

tests/system-test/1-insert/delete_childtable.py

+
+###################################################################
+#           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 random
+import string
+
+from numpy import logspace
+from util import constant
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.common import *
+from util.sqlset import TDSetSql
+
+class TDTestCase:
+    def init(self, conn, logSql, replicaVar=1):
+        self.replicaVar = int(replicaVar)
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+        self.dbname = 'db_test'
+        self.setsql = TDSetSql()
+        self.stbname = 'stb'
+        self.ntbname = 'ntb'
+        self.rowNum = 5
+        self.tbnum = 2
+        self.ts = 1537146000000
+        self.binary_str = 'taosdata'
+        self.nchar_str = '涛思数据'
+        self.str_length = 20
+        self.column_dict = {
+            'col1': 'tinyint',
+            'col2': 'smallint',
+            'col3': 'int',
+            'col4': 'bigint',
+            'col5': 'tinyint unsigned',
+            'col6': 'smallint unsigned',
+            'col7': 'int unsigned',
+            'col8': 'bigint unsigned',
+            'col9': 'float',
+            'col10': 'double',
+            'col11': 'bool',
+            'col12': f'binary({self.str_length})',
+            'col13': f'nchar({self.str_length})',
+
+        }
+
+        self.tinyint_val = random.randint(constant.TINYINT_MIN,constant.TINYINT_MAX)
+        self.smallint_val = random.randint(constant.SMALLINT_MIN,constant.SMALLINT_MAX)
+        self.int_val = random.randint(constant.INT_MIN,constant.INT_MAX)
+        self.bigint_val = random.randint(constant.BIGINT_MIN,constant.BIGINT_MAX)
+        self.untingint_val = random.randint(constant.TINYINT_UN_MIN,constant.TINYINT_UN_MAX)
+        self.unsmallint_val = random.randint(constant.SMALLINT_UN_MIN,constant.SMALLINT_UN_MAX)
+        self.unint_val = random.randint(constant.INT_UN_MIN,constant.INT_MAX)
+        self.unbigint_val = random.randint(constant.BIGINT_UN_MIN,constant.BIGINT_UN_MAX)
+        self.float_val = random.uniform(constant.FLOAT_MIN,constant.FLOAT_MAX)
+        self.double_val = random.uniform(constant.DOUBLE_MIN*(1E-300),constant.DOUBLE_MAX*(1E-300))
+        self.bool_val = random.randint(0,100)%2
+        self.binary_val = tdCom.getLongName(random.randint(0,self.str_length))
+        self.nchar_val = tdCom.getLongName(random.randint(0,self.str_length))
+        self.base_data = {
+            'tinyint':self.tinyint_val,
+            'smallint':self.smallint_val,
+            'int':self.int_val,
+            'bigint':self.bigint_val,
+            'tinyint unsigned':self.untingint_val,
+            'smallint unsigned':self.unsmallint_val,
+            'int unsigned':self.unint_val,
+            'bigint unsigned':self.unbigint_val,
+            'bool':self.bool_val,
+            'float':self.float_val,
+            'double':self.double_val,
+            'binary':self.binary_val,
+            'nchar':self.nchar_val
+                    }
+        
+    def insert_base_data(self,col_type,tbname,rows,base_data):
+        for i in range(rows):
+            if col_type.lower() == 'tinyint':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["tinyint"]})')
+            elif col_type.lower() == 'smallint':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["smallint"]})')
+            elif col_type.lower() == 'int':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["int"]})')
+            elif col_type.lower() == 'bigint':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["bigint"]})')
+            elif col_type.lower() == 'tinyint unsigned':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["tinyint unsigned"]})')
+            elif col_type.lower() == 'smallint unsigned':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["smallint unsigned"]})')
+            elif col_type.lower() == 'int unsigned':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["int unsigned"]})')
+            elif col_type.lower() == 'bigint unsigned':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["bigint unsigned"]})')
+            elif col_type.lower() == 'bool':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["bool"]})')
+            elif col_type.lower() == 'float':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["float"]})')
+            elif col_type.lower() == 'double':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["double"]})')
+            elif 'binary' in col_type.lower():
+                tdSql.execute(f'''insert into {tbname} values({self.ts+i},"{base_data['binary']}")''')
+            elif 'nchar' in col_type.lower():
+                tdSql.execute(f'''insert into {tbname} values({self.ts+i},"{base_data['nchar']}")''')
+    def delete_all_data(self,tbname,col_type,row_num,base_data,dbname,tb_num=1,stbname=''):
+        tdSql.query(f'select count(*) from {tbname}')
+        tdSql.execute(f'delete from {tbname}')
+        tdSql.execute(f'flush database {dbname}')
+        tdSql.execute('reset query cache')
+        tdSql.query(f'select * from {tbname}')
+        tdSql.checkRows(0)
+        tdSql.query(f'select count(*) from {stbname}')
+        if tb_num <= 1:
+            if len(tdSql.queryResult) != 0:
+                tdLog.exit('delete case failure!')
+        else:
+            tdSql.checkEqual(tdSql.queryResult[0][0],(tb_num-1)*row_num)
+        self.insert_base_data(col_type,tbname,row_num,base_data)
+        tdSql.execute(f'flush database {dbname}')
+        tdSql.execute('reset query cache')
+        tdSql.query(f'select * from {tbname}')
+        tdSql.checkRows(row_num)
+    def delete_one_row(self,tbname,column_type,column_name,base_data,row_num,dbname,tb_num=1):
+        tdSql.execute(f'delete from {tbname} where ts={self.ts}')
+        tdSql.execute(f'flush database {dbname}')
+        tdSql.execute('reset query cache')
+        tdSql.query(f'select {column_name} from {tbname}')
+        tdSql.checkRows(row_num-1)
+        tdSql.query(f'select {column_name} from {tbname} where ts={self.ts}')
+        tdSql.checkRows(0)
+        if 'binary' in column_type.lower():
+            tdSql.execute(f'''insert into {tbname} values({self.ts},"{base_data['binary']}")''')
+        elif 'nchar' in column_type.lower():
+            tdSql.execute(f'''insert into {tbname} values({self.ts},"{base_data['nchar']}")''')
+        else:
+            tdSql.execute(f'insert into {tbname} values({self.ts},{base_data[column_type]})')
+        tdSql.query(f'select {column_name} from {tbname} where ts={self.ts}')
+        if column_type.lower() == 'float' or column_type.lower() == 'double':
+            if abs(tdSql.queryResult[0][0] - base_data[column_type]) / base_data[column_type] <= 0.0001:
+                tdSql.checkEqual(tdSql.queryResult[0][0],tdSql.queryResult[0][0])
+            else:
+                tdLog.exit(f'{column_type} data check failure')
+        elif 'binary' in column_type.lower():
+            tdSql.checkEqual(tdSql.queryResult[0][0],base_data['binary'])
+        elif 'nchar' in column_type.lower():
+            tdSql.checkEqual(tdSql.queryResult[0][0],base_data['nchar'])
+        else:
+            tdSql.checkEqual(tdSql.queryResult[0][0],base_data[column_type])
+    def delete_rows(self,dbname,tbname,col_name,col_type,base_data,row_num,tb_num=1):
+        for i in range(row_num):
+            tdSql.execute(f'delete from {tbname} where ts>{self.ts+i}')
+            tdSql.execute(f'flush database {dbname}')
+            tdSql.execute('reset query cache')
+            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.checkRows(i+1)
+            self.insert_base_data(col_type,tbname,row_num,base_data)
+        for i in range(row_num):
+            tdSql.execute(f'delete from {tbname} where ts>={self.ts+i}')
+            tdSql.execute(f'flush database {dbname}')
+            tdSql.execute('reset query cache')
+            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.checkRows(i)
+            self.insert_base_data(col_type,tbname,row_num,base_data)
+        for i in range(row_num):
+            tdSql.execute(f'delete from {tbname} where ts<={self.ts+i}')
+            tdSql.execute(f'flush database {dbname}')
+            tdSql.execute('reset query cache')
+            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.checkRows(row_num-i-1)
+            self.insert_base_data(col_type,tbname,row_num,base_data)
+        for i in range(row_num):
+            tdSql.execute(f'delete from {tbname} where ts<{self.ts+i}')
+            tdSql.execute(f'flush database {dbname}')
+            tdSql.execute('reset query cache')
+            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.checkRows(row_num-i)
+            self.insert_base_data(col_type,tbname,row_num,base_data)
+        for i in range(row_num):
+            tdSql.execute(f'delete from {tbname} where ts between {self.ts} and {self.ts+i}')
+            tdSql.execute(f'flush database {dbname}')
+            tdSql.execute('reset query cache')
+            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.checkRows(row_num - i-1)
+            self.insert_base_data(col_type,tbname,row_num,base_data)
+            tdSql.execute(f'delete from {tbname} where ts between {self.ts+i+1} and {self.ts}')
+            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.checkRows(row_num)
+    def delete_error(self,tbname,column_name,column_type,base_data):
+        for error_list in ['',f'ts = {self.ts} and',f'ts = {self.ts} or']:
+            if 'binary' in column_type.lower():
+                tdSql.error(f'''delete from {tbname} where {error_list} {column_name} ="{base_data['binary']}"''')
+            elif 'nchar' in column_type.lower():
+                tdSql.error(f'''delete from {tbname} where {error_list} {column_name} ="{base_data['nchar']}"''')
+            else:
+                tdSql.error(f'delete from {tbname} where {error_list} {column_name} = {base_data[column_type]}')
+
+    def delete_data_ctb(self):
+        tdSql.execute(f'create database if not exists {self.dbname}')
+        tdSql.execute(f'use {self.dbname}')
+        for col_name,col_type in self.column_dict.items():
+            tdSql.execute(f'create table {self.stbname} (ts timestamp,{col_name} {col_type}) tags(t1 int)')
+            for i in range(self.tbnum):
+                tdSql.execute(f'create table {self.stbname}_{i} using {self.stbname} tags(1)')
+                self.insert_base_data(col_type,f'{self.stbname}_{i}',self.rowNum,self.base_data)
+                self.delete_one_row(f'{self.stbname}_{i}',col_type,col_name,self.base_data,self.rowNum,self.dbname,)
+                self.delete_all_data(f'{self.stbname}_{i}',col_type,self.rowNum,self.base_data,self.dbname,i+1,self.stbname)
+                self.delete_error(f'{self.stbname}_{i}',col_name,col_type,self.base_data)
+                self.delete_rows(self.dbname,f'{self.stbname}_{i}',col_name,col_type,self.base_data,self.rowNum)
+                for func in ['first','last']:
+                    tdSql.query(f'select {func}(*) from {self.stbname}_{i}')
+            tdSql.execute(f'drop table {self.stbname}')
+    def run(self):
+        self.delete_data_ctb()
+        tdDnodes.stoptaosd(1)
+        tdDnodes.starttaosd(1)
+        self.delete_data_ctb()
+    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

tests/system-test/1-insert/delete_data.py

@@ -27,7 +27,7 @@ class TDTestCase:
     def init(self, conn, logSql, replicaVar=1):
         self.replicaVar = int(replicaVar)
         tdLog.debug("start to execute %s" % __file__)
-        tdSql.init(conn.cursor(), True)
+        tdSql.init(conn.cursor())
         self.dbname = 'db_test'
         self.setsql = TDSetSql()
         self.stbname = 'stb'

tests/system-test/1-insert/delete_normaltable.py

+
+###################################################################
+#           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 random
+import string
+
+from numpy import logspace
+from util import constant
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.common import *
+from util.sqlset import TDSetSql
+
+class TDTestCase:
+    def init(self, conn, logSql, replicaVar=1):
+        self.replicaVar = int(replicaVar)
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor(),True)
+        self.dbname = 'db_test'
+        self.setsql = TDSetSql()
+        self.ntbname = 'ntb'
+        self.rowNum = 10
+        self.tbnum = 3
+        self.ts = 1537146000000
+        self.binary_str = 'taosdata'
+        self.nchar_str = '涛思数据'
+        self.str_length = 20
+        self.column_dict = {
+            'col1': 'tinyint',
+            'col2': 'smallint',
+            'col3': 'int',
+            'col4': 'bigint',
+            'col5': 'tinyint unsigned',
+            'col6': 'smallint unsigned',
+            'col7': 'int unsigned',
+            'col8': 'bigint unsigned',
+            'col9': 'float',
+            'col10': 'double',
+            'col11': 'bool',
+            'col12': f'binary({self.str_length})',
+            'col13': f'nchar({self.str_length})',
+
+        }
+
+        self.tinyint_val = random.randint(constant.TINYINT_MIN,constant.TINYINT_MAX)
+        self.smallint_val = random.randint(constant.SMALLINT_MIN,constant.SMALLINT_MAX)
+        self.int_val = random.randint(constant.INT_MIN,constant.INT_MAX)
+        self.bigint_val = random.randint(constant.BIGINT_MIN,constant.BIGINT_MAX)
+        self.untingint_val = random.randint(constant.TINYINT_UN_MIN,constant.TINYINT_UN_MAX)
+        self.unsmallint_val = random.randint(constant.SMALLINT_UN_MIN,constant.SMALLINT_UN_MAX)
+        self.unint_val = random.randint(constant.INT_UN_MIN,constant.INT_MAX)
+        self.unbigint_val = random.randint(constant.BIGINT_UN_MIN,constant.BIGINT_UN_MAX)
+        self.float_val = random.uniform(constant.FLOAT_MIN,constant.FLOAT_MAX)
+        self.double_val = random.uniform(constant.DOUBLE_MIN*(1E-300),constant.DOUBLE_MAX*(1E-300))
+        self.bool_val = random.randint(0,100)%2
+        self.binary_val = tdCom.getLongName(random.randint(0,self.str_length))
+        self.nchar_val = tdCom.getLongName(random.randint(0,self.str_length))
+        self.base_data = {
+            'tinyint':self.tinyint_val,
+            'smallint':self.smallint_val,
+            'int':self.int_val,
+            'bigint':self.bigint_val,
+            'tinyint unsigned':self.untingint_val,
+            'smallint unsigned':self.unsmallint_val,
+            'int unsigned':self.unint_val,
+            'bigint unsigned':self.unbigint_val,
+            'bool':self.bool_val,
+            'float':self.float_val,
+            'double':self.double_val,
+            'binary':self.binary_val,
+            'nchar':self.nchar_val
+                    }
+        
+    def insert_base_data(self,col_type,tbname,rows,base_data):
+        for i in range(rows):
+            if col_type.lower() == 'tinyint':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["tinyint"]})')
+            elif col_type.lower() == 'smallint':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["smallint"]})')
+            elif col_type.lower() == 'int':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["int"]})')
+            elif col_type.lower() == 'bigint':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["bigint"]})')
+            elif col_type.lower() == 'tinyint unsigned':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["tinyint unsigned"]})')
+            elif col_type.lower() == 'smallint unsigned':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["smallint unsigned"]})')
+            elif col_type.lower() == 'int unsigned':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["int unsigned"]})')
+            elif col_type.lower() == 'bigint unsigned':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["bigint unsigned"]})')
+            elif col_type.lower() == 'bool':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["bool"]})')
+            elif col_type.lower() == 'float':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["float"]})')
+            elif col_type.lower() == 'double':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["double"]})')
+            elif 'binary' in col_type.lower():
+                tdSql.execute(f'''insert into {tbname} values({self.ts+i},"{base_data['binary']}")''')
+            elif 'nchar' in col_type.lower():
+                tdSql.execute(f'''insert into {tbname} values({self.ts+i},"{base_data['nchar']}")''')
+    def delete_all_data(self,tbname,col_type,row_num,base_data,dbname,tb_num=1,stbname=''):
+        tdSql.query(f'select count(*) from {tbname}')
+        tdSql.execute(f'delete from {tbname}')
+        tdSql.execute(f'flush database {dbname}')
+        tdSql.execute('reset query cache')
+        tdSql.query(f'select * from {tbname}')
+        tdSql.checkRows(0)
+        self.insert_base_data(col_type,tbname,row_num,base_data)
+        tdSql.execute(f'flush database {dbname}')
+        tdSql.execute('reset query cache')
+        tdSql.query(f'select * from {tbname}')
+        tdSql.checkRows(row_num)
+    def delete_one_row(self,tbname,column_type,column_name,base_data,row_num,dbname,tb_num=1):
+        tdSql.execute(f'delete from {tbname} where ts={self.ts}')
+        tdSql.execute(f'flush database {dbname}')
+        tdSql.execute('reset query cache')
+        tdSql.query(f'select {column_name} from {tbname}')
+        tdSql.checkRows(row_num-1)
+        tdSql.query(f'select {column_name} from {tbname} where ts={self.ts}')
+        tdSql.checkRows(0)
+        if 'binary' in column_type.lower():
+            tdSql.execute(f'''insert into {tbname} values({self.ts},"{base_data['binary']}")''')
+        elif 'nchar' in column_type.lower():
+            tdSql.execute(f'''insert into {tbname} values({self.ts},"{base_data['nchar']}")''')
+        else:
+            tdSql.execute(f'insert into {tbname} values({self.ts},{base_data[column_type]})')
+        tdSql.query(f'select {column_name} from {tbname} where ts={self.ts}')
+        if column_type.lower() == 'float' or column_type.lower() == 'double':
+            if abs(tdSql.queryResult[0][0] - base_data[column_type]) / base_data[column_type] <= 0.0001:
+                tdSql.checkEqual(tdSql.queryResult[0][0],tdSql.queryResult[0][0])
+            else:
+                tdLog.exit(f'{column_type} data check failure')
+        elif 'binary' in column_type.lower():
+            tdSql.checkEqual(tdSql.queryResult[0][0],base_data['binary'])
+        elif 'nchar' in column_type.lower():
+            tdSql.checkEqual(tdSql.queryResult[0][0],base_data['nchar'])
+        else:
+            tdSql.checkEqual(tdSql.queryResult[0][0],base_data[column_type])
+    def delete_rows(self,dbname,tbname,col_name,col_type,base_data,row_num,tb_num=1):
+        for i in range(row_num):
+            tdSql.execute(f'delete from {tbname} where ts>{self.ts+i}')
+            tdSql.execute(f'flush database {dbname}')
+            tdSql.execute('reset query cache')
+            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.checkRows(i+1)
+            self.insert_base_data(col_type,tbname,row_num,base_data)
+        for i in range(row_num):
+            tdSql.execute(f'delete from {tbname} where ts>={self.ts+i}')
+            tdSql.execute(f'flush database {dbname}')
+            tdSql.execute('reset query cache')
+            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.checkRows(i)
+            self.insert_base_data(col_type,tbname,row_num,base_data)
+        for i in range(row_num):
+            tdSql.execute(f'delete from {tbname} where ts<={self.ts+i}')
+            tdSql.execute(f'flush database {dbname}')
+            tdSql.execute('reset query cache')
+            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.checkRows(row_num-i-1)
+            self.insert_base_data(col_type,tbname,row_num,base_data)
+        for i in range(row_num):
+            tdSql.execute(f'delete from {tbname} where ts<{self.ts+i}')
+            tdSql.execute(f'flush database {dbname}')
+            tdSql.execute('reset query cache')
+            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.checkRows(row_num-i)
+            self.insert_base_data(col_type,tbname,row_num,base_data)
+        for i in range(row_num):
+            tdSql.execute(f'delete from {tbname} where ts between {self.ts} and {self.ts+i}')
+            tdSql.execute(f'flush database {dbname}')
+            tdSql.execute('reset query cache')
+            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.checkRows(row_num - i-1)
+            self.insert_base_data(col_type,tbname,row_num,base_data)
+            tdSql.execute(f'delete from {tbname} where ts between {self.ts+i+1} and {self.ts}')
+            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.checkRows(row_num)
+    def delete_error(self,tbname,column_name,column_type,base_data):
+        for error_list in ['',f'ts = {self.ts} and',f'ts = {self.ts} or']:
+            if 'binary' in column_type.lower():
+                tdSql.error(f'''delete from {tbname} where {error_list} {column_name} ="{base_data['binary']}"''')
+            elif 'nchar' in column_type.lower():
+                tdSql.error(f'''delete from {tbname} where {error_list} {column_name} ="{base_data['nchar']}"''')
+            else:
+                tdSql.error(f'delete from {tbname} where {error_list} {column_name} = {base_data[column_type]}')
+
+    def delete_data_ntb(self):
+        tdSql.execute(f'create database if not exists {self.dbname}')
+        tdSql.execute(f'use {self.dbname}')
+        for col_name,col_type in self.column_dict.items():
+            tdSql.execute(f'create table {self.ntbname} (ts timestamp,{col_name} {col_type})')
+            self.insert_base_data(col_type,self.ntbname,self.rowNum,self.base_data)
+            self.delete_one_row(self.ntbname,col_type,col_name,self.base_data,self.rowNum,self.dbname)
+            self.delete_all_data(self.ntbname,col_type,self.rowNum,self.base_data,self.dbname)
+            self.delete_error(self.ntbname,col_name,col_type,self.base_data)
+            self.delete_rows(self.dbname,self.ntbname,col_name,col_type,self.base_data,self.rowNum)
+            for func in ['first','last']:
+                tdSql.query(f'select {func}(*) from {self.ntbname}')
+            tdSql.execute(f'drop table {self.ntbname}')
+        tdSql.execute(f'drop database {self.dbname}')
+    def run(self):
+        self.delete_data_ntb()
+        tdDnodes.stoptaosd(1)
+        tdDnodes.starttaosd(1)
+        self.delete_data_ntb()
+    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

tests/system-test/1-insert/delete_stable.py

+
+###################################################################
+#           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 random
+import string
+
+from numpy import logspace
+from util import constant
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.common import *
+from util.sqlset import TDSetSql
+
+class TDTestCase:
+    def init(self, conn, logSql, replicaVar=1):
+        self.replicaVar = int(replicaVar)
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+        self.dbname = 'db_test'
+        self.setsql = TDSetSql()
+        self.stbname = 'stb'
+        self.ntbname = 'ntb'
+        self.rowNum = 10
+        self.tbnum = 3
+        self.ts = 1537146000000
+        self.binary_str = 'taosdata'
+        self.nchar_str = '涛思数据'
+        self.str_length = 20
+        self.column_dict = {
+            'col1': 'tinyint',
+            'col2': 'smallint',
+            'col3': 'int',
+            'col4': 'bigint',
+            'col5': 'tinyint unsigned',
+            'col6': 'smallint unsigned',
+            'col7': 'int unsigned',
+            'col8': 'bigint unsigned',
+            'col9': 'float',
+            'col10': 'double',
+            'col11': 'bool',
+            'col12': f'binary({self.str_length})',
+            'col13': f'nchar({self.str_length})',
+
+        }
+
+        self.tinyint_val = random.randint(constant.TINYINT_MIN,constant.TINYINT_MAX)
+        self.smallint_val = random.randint(constant.SMALLINT_MIN,constant.SMALLINT_MAX)
+        self.int_val = random.randint(constant.INT_MIN,constant.INT_MAX)
+        self.bigint_val = random.randint(constant.BIGINT_MIN,constant.BIGINT_MAX)
+        self.untingint_val = random.randint(constant.TINYINT_UN_MIN,constant.TINYINT_UN_MAX)
+        self.unsmallint_val = random.randint(constant.SMALLINT_UN_MIN,constant.SMALLINT_UN_MAX)
+        self.unint_val = random.randint(constant.INT_UN_MIN,constant.INT_MAX)
+        self.unbigint_val = random.randint(constant.BIGINT_UN_MIN,constant.BIGINT_UN_MAX)
+        self.float_val = random.uniform(constant.FLOAT_MIN,constant.FLOAT_MAX)
+        self.double_val = random.uniform(constant.DOUBLE_MIN*(1E-300),constant.DOUBLE_MAX*(1E-300))
+        self.bool_val = random.randint(0,100)%2
+        self.binary_val = tdCom.getLongName(random.randint(0,self.str_length))
+        self.nchar_val = tdCom.getLongName(random.randint(0,self.str_length))
+        self.base_data = {
+            'tinyint':self.tinyint_val,
+            'smallint':self.smallint_val,
+            'int':self.int_val,
+            'bigint':self.bigint_val,
+            'tinyint unsigned':self.untingint_val,
+            'smallint unsigned':self.unsmallint_val,
+            'int unsigned':self.unint_val,
+            'bigint unsigned':self.unbigint_val,
+            'bool':self.bool_val,
+            'float':self.float_val,
+            'double':self.double_val,
+            'binary':self.binary_val,
+            'nchar':self.nchar_val
+                    }
+        
+    def insert_base_data(self,col_type,tbname,rows,base_data):
+        for i in range(rows):
+            if col_type.lower() == 'tinyint':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["tinyint"]})')
+            elif col_type.lower() == 'smallint':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["smallint"]})')
+            elif col_type.lower() == 'int':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["int"]})')
+            elif col_type.lower() == 'bigint':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["bigint"]})')
+            elif col_type.lower() == 'tinyint unsigned':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["tinyint unsigned"]})')
+            elif col_type.lower() == 'smallint unsigned':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["smallint unsigned"]})')
+            elif col_type.lower() == 'int unsigned':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["int unsigned"]})')
+            elif col_type.lower() == 'bigint unsigned':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["bigint unsigned"]})')
+            elif col_type.lower() == 'bool':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["bool"]})')
+            elif col_type.lower() == 'float':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["float"]})')
+            elif col_type.lower() == 'double':
+                tdSql.execute(f'insert into {tbname} values({self.ts+i},{base_data["double"]})')
+            elif 'binary' in col_type.lower():
+                tdSql.execute(f'''insert into {tbname} values({self.ts+i},"{base_data['binary']}")''')
+            elif 'nchar' in col_type.lower():
+                tdSql.execute(f'''insert into {tbname} values({self.ts+i},"{base_data['nchar']}")''')
+    def delete_all_data(self,tbname,col_type,row_num,base_data,dbname,tb_num=1):
+        tdSql.query(f'select count(*) from {tbname}')
+        tdSql.execute(f'delete from {tbname}')
+        tdSql.execute(f'flush database {dbname}')
+        tdSql.execute('reset query cache')
+        tdSql.query(f'select * from {tbname}')
+        tdSql.checkRows(0)
+        for i in range(tb_num):
+            self.insert_base_data(col_type,f'{tbname}_{i}',row_num,base_data)
+        tdSql.execute(f'flush database {dbname}')
+        tdSql.execute('reset query cache')
+        tdSql.query(f'select * from {tbname}')
+        tdSql.checkRows(row_num*tb_num)
+    def delete_one_row(self,tbname,column_type,column_name,base_data,row_num,dbname,tb_num=1):
+        tdSql.execute(f'delete from {tbname} where ts={self.ts}')
+        tdSql.execute(f'flush database {dbname}')
+        tdSql.execute('reset query cache')
+        tdSql.query(f'select {column_name} from {tbname}')
+        tdSql.checkRows((row_num-1)*tb_num)
+        tdSql.query(f'select {column_name} from {tbname} where ts={self.ts}')
+        tdSql.checkRows(0)
+        for i in range(tb_num):
+            if 'binary' in column_type.lower():
+                tdSql.execute(f'''insert into {tbname}_{i} values({self.ts},"{base_data['binary']}")''')
+            elif 'nchar' in column_type.lower():
+                tdSql.execute(f'''insert into {tbname}_{i} values({self.ts},"{base_data['nchar']}")''')
+            else:
+                tdSql.execute(f'insert into {tbname}_{i} values({self.ts},{base_data[column_type]})')
+        tdSql.query(f'select {column_name} from {tbname} where ts={self.ts}')
+        if column_type.lower() == 'float' or column_type.lower() == 'double':
+            if abs(tdSql.queryResult[0][0] - base_data[column_type]) / base_data[column_type] <= 0.0001:
+                tdSql.checkEqual(tdSql.queryResult[0][0],tdSql.queryResult[0][0])
+            else:
+                tdLog.exit(f'{column_type} data check failure')
+        elif 'binary' in column_type.lower():
+            tdSql.checkEqual(tdSql.queryResult[0][0],base_data['binary'])
+        elif 'nchar' in column_type.lower():
+            tdSql.checkEqual(tdSql.queryResult[0][0],base_data['nchar'])
+        else:
+            tdSql.checkEqual(tdSql.queryResult[0][0],base_data[column_type])
+    def delete_rows(self,dbname,tbname,col_name,col_type,base_data,row_num,tb_num=1):
+        for i in range(row_num):
+            tdSql.execute(f'delete from {tbname} where ts>{self.ts+i}')
+            tdSql.execute(f'flush database {dbname}')
+            tdSql.execute('reset query cache')
+            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.checkRows((i+1)*tb_num)
+            for j in range(tb_num):
+                self.insert_base_data(col_type,f'{tbname}_{j}',row_num,base_data)
+        for i in range(row_num):
+            tdSql.execute(f'delete from {tbname} where ts>={self.ts+i}')
+            tdSql.execute(f'flush database {dbname}')
+            tdSql.execute('reset query cache')
+            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.checkRows(i*tb_num)
+            for j in range(tb_num):
+                self.insert_base_data(col_type,f'{tbname}_{j}',row_num,base_data)
+        for i in range(row_num):
+            tdSql.execute(f'delete from {tbname} where ts<={self.ts+i}')
+            tdSql.execute(f'flush database {dbname}')
+            tdSql.execute('reset query cache')
+            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.checkRows((row_num-i-1)*tb_num)
+            for j in range(tb_num):
+                self.insert_base_data(col_type,f'{tbname}_{j}',row_num,base_data)
+        for i in range(row_num):
+            tdSql.execute(f'delete from {tbname} where ts<{self.ts+i}')
+            tdSql.execute(f'flush database {dbname}')
+            tdSql.execute('reset query cache')
+            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.checkRows((row_num-i)*tb_num)
+            for j in range(tb_num):
+                self.insert_base_data(col_type,f'{tbname}_{j}',row_num,base_data)
+        for i in range(row_num):
+            tdSql.execute(f'delete from {tbname} where ts between {self.ts} and {self.ts+i}')
+            tdSql.execute(f'flush database {dbname}')
+            tdSql.execute('reset query cache')
+            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.checkRows(tb_num*(row_num - i-1))
+            for j in range(tb_num):
+                self.insert_base_data(col_type,f'{tbname}_{j}',row_num,base_data)
+            tdSql.execute(f'delete from {tbname} where ts between {self.ts+i+1} and {self.ts}')
+            tdSql.query(f'select {col_name} from {tbname}')
+            tdSql.checkRows(tb_num*row_num)
+    def delete_error(self,tbname,column_name,column_type,base_data):
+        for error_list in ['',f'ts = {self.ts} and',f'ts = {self.ts} or']:
+            if 'binary' in column_type.lower():
+                tdSql.error(f'''delete from {tbname} where {error_list} {column_name} ="{base_data['binary']}"''')
+            elif 'nchar' in column_type.lower():
+                tdSql.error(f'''delete from {tbname} where {error_list} {column_name} ="{base_data['nchar']}"''')
+            else:
+                tdSql.error(f'delete from {tbname} where {error_list} {column_name} = {base_data[column_type]}')
+    def delete_data_stb(self):
+        tdSql.execute(f'create database if not exists {self.dbname}')
+        tdSql.execute(f'use {self.dbname}')
+        for col_name,col_type in self.column_dict.items():
+            tdSql.execute(f'create table {self.stbname} (ts timestamp,{col_name} {col_type}) tags(t1 int)')
+            for i in range(self.tbnum):
+                tdSql.execute(f'create table {self.stbname}_{i} using {self.stbname} tags(1)')
+                self.insert_base_data(col_type,f'{self.stbname}_{i}',self.rowNum,self.base_data)
+            self.delete_error(self.stbname,col_name,col_type,self.base_data)
+            self.delete_one_row(self.stbname,col_type,col_name,self.base_data,self.rowNum,self.dbname,self.tbnum)
+            self.delete_all_data(self.stbname,col_type,self.rowNum,self.base_data,self.dbname,self.tbnum)
+            self.delete_rows(self.dbname,self.stbname,col_name,col_type,self.base_data,self.rowNum,self.tbnum)
+            for func in ['first','last']:
+                tdSql.query(f'select {func}(*) from {self.stbname}')
+            tdSql.execute(f'drop table {self.stbname}')
+        tdSql.execute(f'drop database {self.dbname}')
+    def run(self):
+        self.delete_data_stb()
+        tdDnodes.stoptaosd(1)
+        tdDnodes.starttaosd(1)
+        self.delete_data_stb()
+    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

tests/system-test/fulltest.sh

@@ -214,6 +214,9 @@ python3 ./test.py -f 1-insert/update_data.py
 python3 ./test.py -f 1-insert/tb_100w_data_order.py
 
 # TD-20200 python3 ./test.py -f 1-insert/delete_data.py
+python3 ./test.py -f 1-insert/delete_stable.py
+python3 ./test.py -f 1-insert/delete_childtable.py
+python3 ./test.py -f 1-insert/delete_normaltable.py
 python3 ./test.py -f 1-insert/keep_expired.py
 
 python3 ./test.py -f 2-query/join2.py

tools/shell/src/shellEngine.c

@@ -226,7 +226,7 @@ void shellRunSingleCommandImp(char *command) {
     int32_t num_rows_affacted = taos_affected_rows(pSql);
     taos_free_result(pSql);
     et = taosGetTimestampUs();
-    printf("Query OK, %d row(s) affected in set (%.6fs)\r\n", num_rows_affacted, (et - st) / 1E6);
+    printf("Query OK, %d row(s) affected(%.6fs)\r\n", num_rows_affacted, (et - st) / 1E6);
 
     // call auto tab
     callbackAutoTab(command, NULL, false);