Merge pull request #13163 from taosdata/test/vector_function

test: add test case for vector function such as csum  , mavg , diff 

tests/system-test/2-query/avg.py

+import taos
+import sys
+import datetime
+import inspect
+
+from util.log import *
+from util.sql import *
+from util.cases import *
+
+class TDTestCase:
+    updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 , 
+    "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
+    "wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"fnDebugFlag":143}
+    def init(self, conn, logSql):
+        tdLog.debug(f"start to excute {__file__}")
+        tdSql.init(conn.cursor(), True)
+    
+    def prepare_datas(self):
+        tdSql.execute(
+            '''create table stb1
+            (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp)
+            tags (t1 int)
+            '''
+        )
+        
+        tdSql.execute(
+            '''
+            create table t1
+            (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp)
+            '''
+        )
+        for i in range(4):
+            tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )')
+
+        for i in range(9):
+            tdSql.execute(
+                f"insert into ct1 values ( now()-{i*10}s, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a )"
+            )
+            tdSql.execute(
+                f"insert into ct4 values ( now()-{i*90}d, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a )"
+            )
+        tdSql.execute("insert into ct1 values (now()-45s, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar0', now()+8a )")
+        tdSql.execute("insert into ct1 values (now()+10s, 9, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a )")
+        tdSql.execute("insert into ct1 values (now()+15s, 9, -99999, -999, -99, -9.99, NULL, 1, 'binary9', 'nchar9', now()+9a )")
+        tdSql.execute("insert into ct1 values (now()+20s, 9, -99999, -999, NULL, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a )")
+
+        tdSql.execute("insert into ct4 values (now()-810d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
+        tdSql.execute("insert into ct4 values (now()-400d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
+        tdSql.execute("insert into ct4 values (now()+90d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL  ) ")
+
+        tdSql.execute(
+            f'''insert into t1 values
+            ( '2020-04-21 01:01:01.000', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
+            ( '2020-10-21 01:01:01.000', 1, 11111, 111, 11, 1.11, 11.11, 1, "binary1", "nchar1", now()+1a )
+            ( '2020-12-31 01:01:01.000', 2, 22222, 222, 22, 2.22, 22.22, 0, "binary2", "nchar2", now()+2a )
+            ( '2021-01-01 01:01:06.000', 3, 33333, 333, 33, 3.33, 33.33, 0, "binary3", "nchar3", now()+3a )
+            ( '2021-05-07 01:01:10.000', 4, 44444, 444, 44, 4.44, 44.44, 1, "binary4", "nchar4", now()+4a )
+            ( '2021-07-21 01:01:01.000', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
+            ( '2021-09-30 01:01:16.000', 5, 55555, 555, 55, 5.55, 55.55, 0, "binary5", "nchar5", now()+5a )
+            ( '2022-02-01 01:01:20.000', 6, 66666, 666, 66, 6.66, 66.66, 1, "binary6", "nchar6", now()+6a )
+            ( '2022-10-28 01:01:26.000', 7, 00000, 000, 00, 0.00, 00.00, 1, "binary7", "nchar7", "1970-01-01 08:00:00.000" )
+            ( '2022-12-01 01:01:30.000', 8, -88888, -888, -88, -8.88, -88.88, 0, "binary8", "nchar8", "1969-01-01 01:00:00.000" )
+            ( '2022-12-31 01:01:36.000', 9, -99999999999999999, -999, -99, -9.99, -999999999999999999999.99, 1, "binary9", "nchar9", "1900-01-01 00:00:00.000" )
+            ( '2023-02-21 01:01:01.000', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
+            '''
+        )
+    
+    def check_avg(self ,origin_query , check_query):
+        avg_result = tdSql.getResult(origin_query)
+        origin_result = tdSql.getResult(check_query)
+
+        check_status = True
+        for row_index , row in enumerate(avg_result):
+            for col_index , elem in enumerate(row):
+                if avg_result[row_index][col_index] != origin_result[row_index][col_index]:
+                    check_status = False 
+        if not check_status:
+            tdLog.notice("avg function value has not as expected , sql is \"%s\" "%origin_query )
+            sys.exit(1)
+        else:
+            tdLog.info("avg value check pass , it work as expected ,sql is \"%s\"   "%check_query )
+        
+    def test_errors(self):
+        error_sql_lists = [
+            "select avg from t1",
+            # "select avg(-+--+c1) from t1",
+            # "select +-avg(c1) from t1",
+            # "select ++-avg(c1) from t1",
+            # "select ++--avg(c1) from t1",
+            # "select - -avg(c1)*0 from t1",
+            # "select avg(tbname+1) from t1 ",
+            "select avg(123--123)==1 from t1",
+            "select avg(c1) as 'd1' from t1",
+            "select avg(c1 ,c2 ) from t1",
+            "select avg(c1 ,NULL) from t1",
+            "select avg(,) from t1;",
+            "select avg(avg(c1) ab from t1)",
+            "select avg(c1) as int from t1",
+            "select avg from stb1",
+            # "select avg(-+--+c1) from stb1",
+            # "select +-avg(c1) from stb1",
+            # "select ++-avg(c1) from stb1",
+            # "select ++--avg(c1) from stb1",
+            # "select - -avg(c1)*0 from stb1",
+            # "select avg(tbname+1) from stb1 ",
+            "select avg(123--123)==1 from stb1",
+            "select avg(c1) as 'd1' from stb1",
+            "select avg(c1 ,c2 ) from stb1",
+            "select avg(c1 ,NULL) from stb1",
+            "select avg(,) from stb1;",
+            "select avg(avg(c1) ab from stb1)",
+            "select avg(c1) as int from stb1"
+        ]
+        for error_sql in error_sql_lists:
+            tdSql.error(error_sql)
+    
+    def support_types(self):
+        type_error_sql_lists = [
+            "select avg(ts) from t1" , 
+            "select avg(c7) from t1",
+            "select avg(c8) from t1",
+            "select avg(c9) from t1",
+            "select avg(ts) from ct1" , 
+            "select avg(c7) from ct1",
+            "select avg(c8) from ct1",
+            "select avg(c9) from ct1",
+            "select avg(ts) from ct3" , 
+            "select avg(c7) from ct3",
+            "select avg(c8) from ct3",
+            "select avg(c9) from ct3",
+            "select avg(ts) from ct4" , 
+            "select avg(c7) from ct4",
+            "select avg(c8) from ct4",
+            "select avg(c9) from ct4",
+            "select avg(ts) from stb1" , 
+            "select avg(c7) from stb1",
+            "select avg(c8) from stb1",
+            "select avg(c9) from stb1" ,
+
+            "select avg(ts) from stbbb1" , 
+            "select avg(c7) from stbbb1",
+
+            "select avg(ts) from tbname",
+            "select avg(c9) from tbname"
+
+        ]
+        
+        for type_sql in type_error_sql_lists:
+            tdSql.error(type_sql)
+        
+        
+        type_sql_lists = [
+            "select avg(c1) from t1",
+            "select avg(c2) from t1",
+            "select avg(c3) from t1",
+            "select avg(c4) from t1",
+            "select avg(c5) from t1",
+            "select avg(c6) from t1",
+
+            "select avg(c1) from ct1",
+            "select avg(c2) from ct1",
+            "select avg(c3) from ct1",
+            "select avg(c4) from ct1",
+            "select avg(c5) from ct1",
+            "select avg(c6) from ct1",
+
+            "select avg(c1) from ct3",
+            "select avg(c2) from ct3",
+            "select avg(c3) from ct3",
+            "select avg(c4) from ct3",
+            "select avg(c5) from ct3",
+            "select avg(c6) from ct3",
+
+            "select avg(c1) from stb1",
+            "select avg(c2) from stb1",
+            "select avg(c3) from stb1",
+            "select avg(c4) from stb1",
+            "select avg(c5) from stb1",
+            "select avg(c6) from stb1",
+
+            "select avg(c6) as alisb from stb1", 
+            "select avg(c6) alisb from stb1", 
+        ]
+
+        for type_sql in type_sql_lists:
+            tdSql.query(type_sql)
+    
+    def basic_avg_function(self):
+
+        # basic query 
+        tdSql.query("select c1 from ct3")
+        tdSql.checkRows(0)
+        tdSql.query("select c1 from t1")
+        tdSql.checkRows(12)
+        tdSql.query("select c1 from stb1")
+        tdSql.checkRows(25)
+
+        # used for empty table  , ct3 is empty
+        tdSql.query("select avg(c1) from ct3")
+        tdSql.checkRows(0)
+        tdSql.query("select avg(c2) from ct3")
+        tdSql.checkRows(0)
+        tdSql.query("select avg(c3) from ct3")
+        tdSql.checkRows(0)
+        tdSql.query("select avg(c4) from ct3")
+        tdSql.checkRows(0)
+        tdSql.query("select avg(c5) from ct3")
+        tdSql.checkRows(0)
+        tdSql.query("select avg(c6) from ct3")
+        
+        # used for regular table
+        tdSql.query("select avg(c1) from t1")
+        tdSql.checkData(0, 0, 5.000000000)
+       
+       
+        tdSql.query("select ts,c1, c2, c3 , c4, c5 from t1")
+        tdSql.checkData(1, 5, 1.11000)
+        tdSql.checkData(3, 4, 33)
+        tdSql.checkData(5, 5, None)
+        self.check_avg(" select avg(c1) , avg(c2) , avg(c3) from t1 " , " select sum(c1)/count(c1) , sum(c2)/count(c2) , sum(c3)/count(c3) from t1 ")
+        
+        # used for sub table
+        tdSql.query("select avg(c1) from ct1")
+        tdSql.checkData(0, 0, 4.846153846)
+
+        tdSql.query("select avg(c1) from ct3")
+        tdSql.checkRows(0)
+
+        self.check_avg(" select avg(abs(c1)) , avg(abs(c2)) , avg(abs(c3)) from t1 " , " select sum(abs(c1))/count(c1) , sum(abs(c2))/count(c2) , sum(abs(c3))/count(c3) from t1 ")
+        self.check_avg(" select avg(abs(c1)) , avg(abs(c2)) , avg(abs(c3)) from stb1 " , " select sum(abs(c1))/count(c1) , sum(abs(c2))/count(c2) , sum(abs(c3))/count(c3) from stb1 ")
+
+        # used for stable table 
+        
+        tdSql.query("select avg(c1) from stb1")
+        tdSql.checkRows(1)
+
+        self.check_avg(" select avg(abs(ceil(c1))) , avg(abs(ceil(c2))) , avg(abs(ceil(c3))) from stb1 " , " select sum(abs(ceil(c1)))/count(c1) , sum(abs(ceil(c2)))/count(c2) , sum(abs(ceil(c3)))/count(c3) from stb1 ")
+
+        # used for not exists table
+        tdSql.error("select avg(c1) from stbbb1")
+        tdSql.error("select avg(c1) from tbname")
+        tdSql.error("select avg(c1) from ct5")
+
+        # mix with common col 
+        tdSql.error("select c1, avg(c1) from ct1")
+        tdSql.error("select c1, avg(c1) from ct4")
+        
+
+        # mix with common functions
+        tdSql.error("select c1, avg(c1),c5, floor(c5) from ct4 ")
+        tdSql.error("select c1, avg(c1),c5, floor(c5) from stb1 ")
+
+        # mix with agg functions , not support
+        tdSql.error("select c1, avg(c1),c5, count(c5) from stb1 ")
+        tdSql.error("select c1, avg(c1),c5, count(c5) from ct1 ")
+        tdSql.error("select c1, count(c5) from ct1 ")
+        tdSql.error("select c1, count(c5) from stb1 ")
+
+        # agg functions mix with agg functions
+
+        tdSql.query(" select max(c5), count(c5) , avg(c5) from stb1 ")
+        tdSql.checkData(0, 0, 8.88000 )
+        tdSql.checkData(0, 1, 22 )
+        tdSql.checkData(0, 2, 2.270454591 )
+
+        tdSql.query(" select max(c5), count(c5) , avg(c5) ,elapsed(ts) , spread(c1)  from ct1; ")
+        tdSql.checkData(0, 0, 8.88000 )
+        tdSql.checkData(0, 1, 13 )
+        tdSql.checkData(0, 2, 0.768461603 )
+
+        # bug fix for count
+        tdSql.query("select count(c1) from ct4 ")
+        tdSql.checkData(0,0,9)
+        tdSql.query("select count(*) from ct4 ")
+        tdSql.checkData(0,0,12)
+        tdSql.query("select count(c1) from stb1 ")
+        tdSql.checkData(0,0,22)
+        tdSql.query("select count(*) from stb1 ")
+        tdSql.checkData(0,0,25)
+
+        # bug fix for compute 
+        tdSql.error("select c1, avg(c1) -0 ,ceil(c1)-0 from ct4 ")
+        tdSql.error(" select c1, avg(c1) -0 ,avg(ceil(c1-0.1))-0.1 from ct4")
+
+        # mix with nest query 
+        self.check_avg("select avg(col) from (select abs(c1) col from stb1)" , "select avg(abs(c1)) from stb1")
+        self.check_avg("select avg(col) from (select ceil(abs(c1)) col from stb1)" , "select avg(abs(c1)) from stb1")
+
+        tdSql.query(" select abs(avg(abs(abs(c1)))) from stb1 ")
+        tdSql.checkData(0, 0, 4.500000000)
+        tdSql.query(" select abs(avg(abs(abs(c1)))) from t1 ")
+        tdSql.checkData(0, 0, 5.000000000)
+
+        tdSql.query(" select abs(avg(abs(abs(c1)))) from stb1 ")
+        tdSql.checkData(0, 0, 4.500000000)
+
+        tdSql.query(" select avg(c1) from stb1 where c1 is null ")
+        tdSql.checkRows(0)
+
+        
+    def avg_func_filter(self):
+        tdSql.execute("use db")
+        tdSql.query(" select avg(c1), avg(c1) -0 ,avg(ceil(c1-0.1))-0 ,avg(floor(c1+0.1))-0.1 ,avg(ceil(log(c1,2)-0.5)) from ct4 where c1>5 ")
+        tdSql.checkRows(1)
+        tdSql.checkData(0,0,7.000000000)
+        tdSql.checkData(0,1,7.000000000)
+        tdSql.checkData(0,2,7.000000000)
+        tdSql.checkData(0,3,6.900000000)
+        tdSql.checkData(0,4,3.000000000)
+
+        tdSql.query("select avg(c1), avg(c1) -0 ,avg(ceil(c1-0.1))-0 ,avg(floor(c1+0.1))-0.1 ,avg(ceil(log(c1,2)-0.5)) from ct4 where c1=5 ")
+        tdSql.checkRows(1)
+        tdSql.checkData(0,0,5.000000000)
+        tdSql.checkData(0,1,5.000000000)
+        tdSql.checkData(0,2,5.000000000)
+        tdSql.checkData(0,3,4.900000000)
+        tdSql.checkData(0,4,2.000000000)
+
+        tdSql.query("select avg(c1) ,avg(c2) , avg(c1) -0 , avg(ceil(c1-0.1))-0 ,avg(floor(c1+0.1))-0.1 ,avg(ceil(log(c1,2))-0.5) from ct4 where c1>log(c1,2) limit 1 ")
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, 4.500000000)
+        tdSql.checkData(0, 1, 49999.500000000)
+        tdSql.checkData(0, 5, 1.625000000)
+
+    def avg_Arithmetic(self):
+        pass
+    
+    def check_boundary_values(self):
+
+        tdSql.execute("drop database if exists bound_test")
+        tdSql.execute("create database if not exists bound_test")
+        time.sleep(3)
+        tdSql.execute("use bound_test")
+        tdSql.execute(
+            "create table stb_bound (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(32),c9 nchar(32), c10 timestamp) tags (t1 int);"
+        )
+        tdSql.execute(f'create table sub1_bound using stb_bound tags ( 1 )')
+        tdSql.execute(
+                f"insert into sub1_bound values ( now()-1s, 2147483647, 9223372036854775807, 32767, 127, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            )
+        tdSql.execute(
+                f"insert into sub1_bound values ( now()-1s, -2147483647, -9223372036854775807, -32767, -127, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            )
+        tdSql.execute(
+                f"insert into sub1_bound values ( now(), 2147483646, 9223372036854775806, 32766, 126, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            )
+        
+        tdSql.execute(
+                f"insert into sub1_bound values ( now(), 2147483645, 9223372036854775805, 32765, 125, 3.40E+37, 1.7e+307, True, 'binary_tb1', 'nchar_tb1', now() )"
+            )
+        
+        tdSql.execute(
+                f"insert into sub1_bound values ( now(), 2147483644, 9223372036854775804, 32764, 124, 3.40E+37, 1.7e+307, True, 'binary_tb1', 'nchar_tb1', now() )"
+            )
+
+        tdSql.execute(
+                f"insert into sub1_bound values ( now(), -2147483646, -9223372036854775806, -32766, -126, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            )
+        tdSql.execute(
+                f"insert into sub1_bound values ( now(), 2147483646, 9223372036854775806, 32766, 126, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            )
+        
+
+        tdSql.error(
+                f"insert into sub1_bound values ( now()+1s, 2147483648, 9223372036854775808, 32768, 128, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
+            )
+        self.check_avg("select avg(c1), avg(c2), avg(c3) , avg(c4), avg(c5) ,avg(c6) from sub1_bound " , " select sum(c1)/count(c1), sum(c2)/count(c2) ,sum(c3)/count(c3), sum(c4)/count(c4), sum(c5)/count(c5) ,sum(c6)/count(c6) from sub1_bound ")
+
+        
+        # check basic elem for table per row
+        tdSql.query("select avg(c1) ,avg(c2) , avg(c3) , avg(c4), avg(c5), avg(c6) from sub1_bound ")
+        tdSql.checkRows(1)
+        tdSql.checkData(0,0,920350133.571428537)
+        tdSql.checkData(0,1,1.3176245766935393e+18)
+        tdSql.checkData(0,2,14042.142857143)
+        tdSql.checkData(0,3,53.571428571)
+        tdSql.checkData(0,4,5.828571332045761e+37)
+        # tdSql.checkData(0,5,None)
+        
+       
+        # check  + - * / in functions
+        tdSql.query(" select avg(c1+1) ,avg(c2) , avg(c3*1) , avg(c4/2), avg(c5)/2, avg(c6) from sub1_bound ")
+        tdSql.checkData(0,0,920350134.5714285)
+        tdSql.checkData(0,1,1.3176245766935393e+18)
+        tdSql.checkData(0,2,14042.142857143)
+        tdSql.checkData(0,3,26.785714286)
+        tdSql.checkData(0,4,2.9142856660228804e+37)
+        # tdSql.checkData(0,5,None)
+        
+       
+
+    def run(self):  # sourcery skip: extract-duplicate-method, remove-redundant-fstring
+        tdSql.prepare()
+
+        tdLog.printNoPrefix("==========step1:create table ==============")
+        
+        self.prepare_datas()
+
+        tdLog.printNoPrefix("==========step2:test errors ==============")    
+
+        self.test_errors()
+        
+        tdLog.printNoPrefix("==========step3:support types ============") 
+
+        self.support_types()
+
+        tdLog.printNoPrefix("==========step4: avg basic query ============") 
+
+        self.basic_avg_function()
+
+        tdLog.printNoPrefix("==========step5: avg boundary query ============") 
+
+        self.check_boundary_values()
+
+        tdLog.printNoPrefix("==========step6: avg filter query ============") 
+
+        self.avg_func_filter()
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success(f"{__file__} successfully executed")
+
+tdCases.addLinux(__file__, TDTestCase())
+tdCases.addWindows(__file__, TDTestCase())

tests/system-test/2-query/csum.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 sys
+import subprocess
+import random
+import math
+import numpy as np
+import inspect
+import re
+
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def csum_query_form(self, col="c1",  alias="", table_expr="t1", condition=""):
+
+        '''
+        csum function:
+        :param col:         string, column name, required parameters;
+        :param alias:       string, result column another name，or add other funtion;
+        :param table_expr:  string or expression, data source（eg,table/stable name, result set）, required parameters;
+        :param condition:   expression；
+        :param args:        other funtions,like: ', last(col)',or give result column another name, like 'c2'
+        :return:            csum query statement,default: select csum(c1) from t1
+        '''
+
+        return f"select csum({col}) {alias} from {table_expr} {condition}"
+
+    def checkcsum(self,col="c1", alias="", table_expr="t1", condition="" ):
+        line = sys._getframe().f_back.f_lineno
+        pre_sql = self.csum_query_form(
+            col=col, table_expr=table_expr, condition=condition
+        ).replace("csum", "count")
+        tdSql.query(pre_sql)
+
+        if tdSql.queryRows == 0:
+            tdSql.query(self.csum_query_form(
+                col=col, alias=alias, table_expr=table_expr, condition=condition
+            ))
+            print(f"case in {line}: ", end='')
+            tdSql.checkRows(0)
+            return
+
+        if "order by tbname" in condition:
+            tdSql.error(self.csum_query_form(
+                col=col, alias=alias, table_expr=table_expr, condition=condition
+            ))
+            return
+
+        if "group" in condition:
+
+            tb_condition = condition.split("group by")[1].split(" ")[1]
+            tdSql.query(f"select distinct {tb_condition} from {table_expr}")
+            query_result = tdSql.queryResult
+            query_rows = tdSql.queryRows
+            clear_condition = re.sub('order by [0-9a-z]*|slimit [0-9]*|soffset [0-9]*', "", condition)
+
+            pre_row = 0
+            for i in range(query_rows):
+                group_name = query_result[i][0]
+                if "where" in clear_condition:
+                    pre_condition = re.sub('group by [0-9a-z]*', f"{tb_condition}='{group_name}'", clear_condition)
+                else:
+                    pre_condition = "where " + re.sub('group by [0-9a-z]*',f"{tb_condition}='{group_name}'", clear_condition)
+
+                tdSql.query(f"select {col} {alias} from {table_expr} {pre_condition}")
+                pre_data = np.array(tdSql.queryResult)[np.array(tdSql.queryResult) != None]
+                print("data is ", pre_data)
+                pre_csum = np.cumsum(pre_data)
+                tdSql.query(self.csum_query_form(
+                    col=col, alias=alias, table_expr=table_expr, condition=condition
+                ))
+                for j in range(len(pre_csum)):
+                    print(f"case in {line}:", end='')
+                    tdSql.checkData(pre_row+j, 1, pre_csum[j])
+                pre_row += len(pre_csum)
+            return
+        elif "union" in condition:
+            union_sql_0 = self.csum_query_form(
+                col=col, alias=alias, table_expr=table_expr, condition=condition
+            ).split("union all")[0]
+
+            union_sql_1 = self.csum_query_form(
+                col=col, alias=alias, table_expr=table_expr, condition=condition
+            ).split("union all")[1]
+
+            tdSql.query(union_sql_0)
+            union_csum_0 = tdSql.queryResult
+            row_union_0 = tdSql.queryRows
+
+            tdSql.query(union_sql_1)
+            union_csum_1 = tdSql.queryResult
+
+            tdSql.query(self.csum_query_form(
+                col=col, alias=alias, table_expr=table_expr, condition=condition
+            ))
+            for i in range(tdSql.queryRows):
+                print(f"case in {line}: ", end='')
+                if i < row_union_0:
+                    tdSql.checkData(i, 0, union_csum_0[i][0])
+                else:
+                    tdSql.checkData(i, 0, union_csum_1[i-row_union_0][0])
+            return
+
+        else:
+            tdSql.query(f"select {col} from {table_expr} {re.sub('limit [0-9]*|offset [0-9]*','',condition)}")
+            offset_val = condition.split("offset")[1].split(" ")[1] if "offset" in condition else 0
+            pre_result = np.array(tdSql.queryResult)[np.array(tdSql.queryResult) != None]
+            pre_csum = np.cumsum(pre_result)[offset_val:]
+            tdSql.query(self.csum_query_form(
+                col=col, alias=alias, table_expr=table_expr, condition=condition
+            ))
+
+            for i in range(tdSql.queryRows):
+                print(f"case in {line}: ", end='')
+                if pre_csum[i] >1.7e+308 or pre_csum[i] < -1.7e+308:
+                    continue
+                else:
+                    tdSql.checkData(i, 0, pre_csum[i])
+
+        pass
+
+    def csum_current_query(self) :
+
+        # table schema :ts timestamp, c1 int, c2 float, c3 timestamp, c4 binary(16), c5 double, c6 bool
+        #                 c7 bigint, c8 smallint, c9 tinyint, c10 nchar(16)
+
+        # case1～6： numeric col:int/bigint/tinyint/smallint/float/double
+        self.checkcsum()
+        case2 =  {"col": "c2"}
+        self.checkcsum(**case2)
+        case3 =  {"col": "c5"}
+        self.checkcsum(**case3)
+        case4 =  {"col": "c7"}
+        self.checkcsum(**case4)
+        case5 =  {"col": "c8"}
+        self.checkcsum(**case5)
+        case6 =  {"col": "c9"}
+        self.checkcsum(**case6)
+
+        # case7~8: nested query
+        # case7 = {"table_expr": "(select c1 from stb1)"}
+        # self.checkcsum(**case7)
+        # case8 = {"table_expr": "(select csum(c1) c1 from stb1 group by tbname)"}
+        # self.checkcsum(**case8)
+
+        # case9~10: mix with tbname/ts/tag/col
+        # case9 = {"alias": ", tbname"}
+        # self.checkcsum(**case9)
+        # case10 = {"alias": ", _c0"}
+        # self.checkcsum(**case10)
+        # case11 = {"alias": ", st1"}
+        # self.checkcsum(**case11)
+        # case12 = {"alias": ", c1"}
+        # self.checkcsum(**case12)
+
+        # case13~15: with  single condition
+        case13 = {"condition": "where c1 <= 10"}
+        self.checkcsum(**case13)
+        case14 = {"condition": "where c6 in (0, 1)"}
+        self.checkcsum(**case14)
+        case15 = {"condition": "where c1 between 1 and 10"}
+        self.checkcsum(**case15)
+
+        # case16:  with multi-condition
+        case16 = {"condition": "where c6=1 or c6 =0"}
+        self.checkcsum(**case16)
+
+        # case17: only support normal table join
+        case17 = {
+            "col": "t1.c1",
+            "table_expr": "t1, t2",
+            "condition": "where t1.ts=t2.ts"
+        }
+        self.checkcsum(**case17)
+        # case18~19: with group by
+        # case18 = {
+        #     "table_expr": "t1",
+        #     "condition": "group by c6"
+        # }
+        # self.checkcsum(**case18)
+        # case19 = {
+        #     "table_expr": "stb1",
+        #     "condition": "partition by tbname"  # partition by tbname
+        # }
+        # self.checkcsum(**case19)
+
+        # # case20~21: with order by
+        # case20 = {"condition": "order by ts"}
+        # self.checkcsum(**case20)
+
+        # # case22: with union
+        # case22 = {
+        #     "condition": "union all select csum(c1) from t2"
+        # }
+        # self.checkcsum(**case22)
+
+        # case23: with limit/slimit
+        case23 = {
+            "condition": "limit 1"
+        }
+        self.checkcsum(**case23)
+        # case24 = {
+        #     "table_expr": "stb1",
+        #     "condition": "group by tbname slimit 1 soffset 1"
+        # }
+        # self.checkcsum(**case24)
+
+        pass
+
+    def csum_error_query(self) -> None :
+        # unusual test
+        #
+        # table schema :ts timestamp, c1 int, c2 float, c3 timestamp, c4 binary(16), c5 double, c6 bool
+        #                 c7 bigint, c8 smallint, c9 tinyint, c10 nchar(16)
+        #
+        # form test
+        tdSql.error(self.csum_query_form(col=""))   # no col
+        tdSql.error("csum(c1) from stb1")           # no select
+        tdSql.error("select csum from t1")          # no csum condition
+        tdSql.error("select csum c1 from t1")       # no brackets
+        tdSql.error("select csum(c1)   t1")         # no from
+        tdSql.error("select csum( c1 )  from ")     # no table_expr
+        # tdSql.error(self.csum_query_form(col="st1"))    # tag col
+        tdSql.error(self.csum_query_form(col=1))        # col is a value
+        tdSql.error(self.csum_query_form(col="'c1'"))   # col is a string
+        tdSql.error(self.csum_query_form(col=None))     # col is NULL 1
+        tdSql.error(self.csum_query_form(col="NULL"))   # col is NULL 2
+        tdSql.error(self.csum_query_form(col='""'))     # col is ""
+        tdSql.error(self.csum_query_form(col='c%'))     # col is spercial char 1
+        tdSql.error(self.csum_query_form(col='c_'))     # col is spercial char 2
+        tdSql.error(self.csum_query_form(col='c.'))     # col is spercial char 3
+        tdSql.error(self.csum_query_form(col='c3'))     # timestamp col
+        tdSql.error(self.csum_query_form(col='ts'))     # Primary key
+        tdSql.error(self.csum_query_form(col='avg(c1)'))    # expr col
+        tdSql.error(self.csum_query_form(col='c6'))     # bool col
+        tdSql.error(self.csum_query_form(col='c4'))     # binary col
+        tdSql.error(self.csum_query_form(col='c10'))    # nachr col
+        tdSql.error(self.csum_query_form(col='c10'))    # not table_expr col
+        tdSql.error(self.csum_query_form(col='t1'))     # tbname
+        tdSql.error(self.csum_query_form(col='stb1'))   # stbname
+        tdSql.error(self.csum_query_form(col='db'))     # datbasename
+        tdSql.error(self.csum_query_form(col=True))     # col is BOOL 1
+        tdSql.error(self.csum_query_form(col='True'))   # col is BOOL 2
+        tdSql.error(self.csum_query_form(col='*'))      # col is all col
+        tdSql.error("select csum[c1] from t1")          # sql form error 1
+        tdSql.error("select csum{c1} from t1")          # sql form error 2
+        tdSql.error(self.csum_query_form(col="[c1]"))   # sql form error 3
+        # tdSql.error(self.csum_query_form(col="c1, c2")) # sql form error 3
+        # tdSql.error(self.csum_query_form(col="c1, 2"))  # sql form error 3
+        tdSql.error(self.csum_query_form(alias=", count(c1)"))  # mix with aggregate function 1
+        tdSql.error(self.csum_query_form(alias=", avg(c1)"))    # mix with aggregate function 2
+        tdSql.error(self.csum_query_form(alias=", min(c1)"))    # mix with select function 1
+        tdSql.error(self.csum_query_form(alias=", top(c1, 5)")) # mix with select function 2
+        tdSql.error(self.csum_query_form(alias=", spread(c1)")) # mix with calculation function  1
+        tdSql.error(self.csum_query_form(alias=", diff(c1)"))   # mix with calculation function  2
+        # tdSql.error(self.csum_query_form(alias=" + 2"))         # mix with arithmetic 1
+        tdSql.error(self.csum_query_form(alias=" + avg(c1)"))   # mix with arithmetic 2
+        tdSql.error(self.csum_query_form(alias=", c2"))         # mix with other 1
+        # tdSql.error(self.csum_query_form(table_expr="stb1"))    # select stb directly
+        stb_join = {
+            "col": "stb1.c1",
+            "table_expr": "stb1, stb2",
+            "condition": "where stb1.ts=stb2.ts and stb1.st1=stb2.st2 order by stb1.ts"
+        }
+        tdSql.error(self.csum_query_form(**stb_join))           # stb join
+        interval_sql = {
+            "condition": "where ts>0 and ts < now interval(1h) fill(next)"
+        }
+        tdSql.error(self.csum_query_form(**interval_sql))       # interval
+        group_normal_col = {
+            "table_expr": "t1",
+            "condition": "group by c6"
+        }
+        tdSql.error(self.csum_query_form(**group_normal_col))       # group by normal col
+        slimit_soffset_sql = {
+            "table_expr": "stb1",
+            "condition": "group by tbname slimit 1 soffset 1"
+        }
+        # tdSql.error(self.csum_query_form(**slimit_soffset_sql))
+        order_by_tbname_sql = {
+            "table_expr": "stb1",
+            "condition": "group by tbname order by tbname"
+        }
+        tdSql.error(self.csum_query_form(**order_by_tbname_sql))
+
+        pass
+
+    def csum_test_data(self, tbnum:int, data_row:int, basetime:int) -> None :
+        for i in range(tbnum):
+            for j in range(data_row):
+                tdSql.execute(
+                    f"insert into t{i} values ("
+                    f"{basetime + (j+1)*10}, {random.randint(-200, -1)}, {random.uniform(200, -1)}, {basetime + random.randint(-200, -1)}, "
+                    f"'binary_{j}', {random.uniform(-200, -1)}, {random.choice([0,1])}, {random.randint(-200,-1)}, "
+                    f"{random.randint(-200, -1)}, {random.randint(-127, -1)}, 'nchar_{j}' )"
+                )
+
+                tdSql.execute(
+                    f"insert into t{i} values ("
+                    f"{basetime - (j+1) * 10}, {random.randint(1, 200)}, {random.uniform(1, 200)}, {basetime - random.randint(1, 200)}, "
+                    f"'binary_{j}_1', {random.uniform(1, 200)}, {random.choice([0, 1])}, {random.randint(1,200)}, "
+                    f"{random.randint(1,200)}, {random.randint(1,127)}, 'nchar_{j}_1' )"
+                )
+                tdSql.execute(
+                    f"insert into tt{i} values ( {basetime-(j+1) * 10}, {random.randint(1, 200)} )"
+                )
+
+        pass
+
+    def csum_test_table(self,tbnum: int) -> None :
+        tdSql.execute("drop database if exists db")
+        tdSql.execute("create database  if not exists db keep 3650")
+        tdSql.execute("use db")
+
+        tdSql.execute(
+            "create stable db.stb1 (\
+                ts timestamp, c1 int, c2 float, c3 timestamp, c4 binary(16), c5 double, c6 bool, \
+                c7 bigint, c8 smallint, c9 tinyint, c10 nchar(16)\
+                ) \
+            tags(st1 int)"
+        )
+        tdSql.execute(
+            "create stable db.stb2 (ts timestamp, c1 int) tags(st2 int)"
+        )
+        for i in range(tbnum):
+            tdSql.execute(f"create table t{i} using stb1 tags({i})")
+            tdSql.execute(f"create table tt{i} using stb2 tags({i})")
+
+        pass
+
+    def csum_test_run(self) :
+        tdLog.printNoPrefix("==========TD-10594==========")
+        tbnum = 10
+        nowtime = int(round(time.time() * 1000))
+        per_table_rows = 2
+        self.csum_test_table(tbnum)
+
+        tdLog.printNoPrefix("######## no data test:")
+        self.csum_current_query()
+        self.csum_error_query()
+
+        tdLog.printNoPrefix("######## insert only NULL test:")
+        for i in range(tbnum):
+            tdSql.execute(f"insert into t{i}(ts) values ({nowtime - 5})")
+            tdSql.execute(f"insert into t{i}(ts) values ({nowtime + 5})")
+        self.csum_current_query()
+        self.csum_error_query()
+
+        tdLog.printNoPrefix("######## insert data in the range near the max(bigint/double):")
+        self.csum_test_table(tbnum)
+        tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values "
+                      f"({nowtime - (per_table_rows + 1) * 10}, {2**31-1}, {3.4*10**38}, {1.7*10**308}, {2**63-1})")
+        tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values "
+                      f"({nowtime - (per_table_rows + 2) * 10}, {2**31-1}, {3.4*10**38}, {1.7*10**308}, {2**63-1})")
+        self.csum_current_query()
+        self.csum_error_query()
+
+        tdLog.printNoPrefix("######## insert data in the range near the min(bigint/double):")
+        self.csum_test_table(tbnum)
+        tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values "
+                      f"({nowtime - (per_table_rows + 1) * 10}, {1-2**31}, {-3.4*10**38}, {-1.7*10**308}, {1-2**63})")
+        tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values "
+                      f"({nowtime - (per_table_rows + 2) * 10}, {1-2**31}, {-3.4*10**38}, {-1.7*10**308}, {512-2**63})")
+        self.csum_current_query()
+        self.csum_error_query()
+
+        tdLog.printNoPrefix("######## insert data without NULL data test:")
+        self.csum_test_table(tbnum)
+        self.csum_test_data(tbnum, per_table_rows, nowtime)
+        self.csum_current_query()
+        self.csum_error_query()
+
+
+        tdLog.printNoPrefix("######## insert data mix with NULL test:")
+        for i in range(tbnum):
+            tdSql.execute(f"insert into t{i}(ts) values ({nowtime})")
+            tdSql.execute(f"insert into t{i}(ts) values ({nowtime-(per_table_rows+3)*10})")
+            tdSql.execute(f"insert into t{i}(ts) values ({nowtime+(per_table_rows+3)*10})")
+        self.csum_current_query()
+        self.csum_error_query()
+
+
+
+        tdLog.printNoPrefix("######## check after WAL test:")
+        tdSql.query("show dnodes")
+        index = tdSql.getData(0, 0)
+        tdDnodes.stop(index)
+        tdDnodes.start(index)
+        self.csum_current_query()
+        self.csum_error_query()
+
+    def run(self):
+        import traceback
+        try:
+            # run in  develop branch
+            self.csum_test_run()
+            pass
+        except Exception as e:
+            traceback.print_exc()
+            raise e
+
+
+
+    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/2-query/function_diff.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 sys
+import subprocess
+import random
+import math
+import numpy as np
+import inspect
+import re
+
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+    def diff_query_form(self, col="c1",  alias="", table_expr="t1", condition=""):
+
+        '''
+        diff function:
+        :param col:         string, column name, required parameters;
+        :param alias:       string, result column another name，or add other funtion;
+        :param table_expr:  string or expression, data source（eg,table/stable name, result set）, required parameters;
+        :param condition:   expression；
+        :param args:        other funtions,like: ', last(col)',or give result column another name, like 'c2'
+        :return:            diff query statement,default: select diff(c1) from t1
+        '''
+
+        return f"select diff({col}) {alias} from {table_expr} {condition}"
+
+    def checkdiff(self,col="c1", alias="", table_expr="t1", condition="" ):
+        line = sys._getframe().f_back.f_lineno
+        pre_sql = self.diff_query_form(
+            col=col, table_expr=table_expr, condition=condition
+        ).replace("diff", "count")
+        tdSql.query(pre_sql)
+
+        if tdSql.queryRows == 0:
+            tdSql.query(self.diff_query_form(
+                col=col, alias=alias, table_expr=table_expr, condition=condition
+            ))
+            print(f"case in {line}: ", end='')
+            tdSql.checkRows(0)
+            return
+
+        if "order by tbname" in condition:
+            tdSql.error(self.diff_query_form(
+                col=col, alias=alias, table_expr=table_expr, condition=condition
+            ))
+            return
+
+        if "group" in condition:
+
+            tb_condition = condition.split("group by")[1].split(" ")[1]
+            tdSql.query(f"select distinct {tb_condition} from {table_expr}")
+            query_result = tdSql.queryResult
+            query_rows = tdSql.queryRows
+            clear_condition = re.sub('order by [0-9a-z]*|slimit [0-9]*|soffset [0-9]*', "", condition)
+
+            pre_row = 0
+            for i in range(query_rows):
+                group_name = query_result[i][0]
+                if "where" in clear_condition:
+                    pre_condition = re.sub('group by [0-9a-z]*', f"{tb_condition}='{group_name}'", clear_condition)
+                else:
+                    pre_condition = "where " + re.sub('group by [0-9a-z]*',f"{tb_condition}='{group_name}'", clear_condition)
+
+                tdSql.query(f"select {col} {alias} from {table_expr} {pre_condition}")
+                pre_data = np.array(tdSql.queryResult)[np.array(tdSql.queryResult) != None]
+                pre_diff = np.diff(pre_data)
+                # trans precision for data
+                tdSql.query(self.diff_query_form(
+                    col=col, alias=alias, table_expr=table_expr, condition=condition
+                ))
+                for j in range(len(pre_diff)):
+                    print(f"case in {line}:", end='')
+                    if  isinstance(pre_diff[j] , float) :
+                        pass
+                    else:
+                        tdSql.checkData(pre_row+j, 1, pre_diff[j] )
+                pre_row += len(pre_diff)
+            return
+        elif "union" in condition:
+            union_sql_0 = self.diff_query_form(
+                col=col, alias=alias, table_expr=table_expr, condition=condition
+            ).split("union all")[0]
+
+            union_sql_1 = self.diff_query_form(
+                col=col, alias=alias, table_expr=table_expr, condition=condition
+            ).split("union all")[1]
+
+            tdSql.query(union_sql_0)
+            union_diff_0 = tdSql.queryResult
+            row_union_0 = tdSql.queryRows
+
+            tdSql.query(union_sql_1)
+            union_diff_1 = tdSql.queryResult
+
+            tdSql.query(self.diff_query_form(
+                col=col, alias=alias, table_expr=table_expr, condition=condition
+            ))
+            for i in range(tdSql.queryRows):
+                print(f"case in {line}: ", end='')
+                if i < row_union_0:
+                    tdSql.checkData(i, 0, union_diff_0[i][0])
+                else:
+                    tdSql.checkData(i, 0, union_diff_1[i-row_union_0][0])
+            return
+
+        else:
+            tdSql.query(f"select {col} from {table_expr} {re.sub('limit [0-9]*|offset [0-9]*','',condition)}")
+            offset_val = condition.split("offset")[1].split(" ")[1] if "offset" in condition else 0
+            pre_result = np.array(tdSql.queryResult)[np.array(tdSql.queryResult) != None]
+            pre_diff = np.diff(pre_result)[offset_val:]
+            tdSql.query(self.diff_query_form(
+                col=col, alias=alias, table_expr=table_expr, condition=condition
+            ))
+
+            for i in range(tdSql.queryRows):
+                print(f"case in {line}: ", end='')
+                if isinstance(pre_diff[i] , float ):
+                    pass
+                else:
+                    tdSql.checkData(i, 0, pre_diff[i])
+
+        pass
+
+    def diff_current_query(self) :
+
+        # table schema :ts timestamp, c1 int, c2 float, c3 timestamp, c4 binary(16), c5 double, c6 bool
+        #                 c7 bigint, c8 smallint, c9 tinyint, c10 nchar(16)
+
+        # case1～6： numeric col:int/bigint/tinyint/smallint/float/double
+        self.checkdiff()
+        case2 =  {"col": "c2"}
+        self.checkdiff(**case2)
+        case3 =  {"col": "c5"}
+        self.checkdiff(**case3)
+        case4 =  {"col": "c7"}
+        self.checkdiff(**case4)
+        case5 =  {"col": "c8"}
+        self.checkdiff(**case5)
+        case6 =  {"col": "c9"}
+        self.checkdiff(**case6)
+
+        # case7~8: nested query
+        # case7 = {"table_expr": "(select c1 from stb1)"}
+        # self.checkdiff(**case7)
+        # case8 = {"table_expr": "(select diff(c1) c1 from stb1 group by tbname)"}
+        # self.checkdiff(**case8)
+
+        # case9~10: mix with tbname/ts/tag/col
+        # case9 = {"alias": ", tbname"}
+        # self.checkdiff(**case9)
+        # case10 = {"alias": ", _c0"}
+        # self.checkdiff(**case10)
+        # case11 = {"alias": ", st1"}
+        # self.checkdiff(**case11)
+        # case12 = {"alias": ", c1"}
+        # self.checkdiff(**case12)
+
+        # case13~15: with  single condition
+        case13 = {"condition": "where c1 <= 10"}
+        self.checkdiff(**case13)
+        case14 = {"condition": "where c6 in (0, 1)"}
+        self.checkdiff(**case14)
+        case15 = {"condition": "where c1 between 1 and 10"}
+        self.checkdiff(**case15)
+
+        # case16:  with multi-condition
+        case16 = {"condition": "where c6=1 or c6 =0"}
+        self.checkdiff(**case16)
+
+        # case17: only support normal table join
+        case17 = {
+            "col": "t1.c1",
+            "table_expr": "t1, t2",
+            "condition": "where t1.ts=t2.ts"
+        }
+        self.checkdiff(**case17)
+        # case18~19: with group by
+        # case18 = {
+        #     "table_expr": "t1",
+        #     "condition": "group by c6"
+        # }
+        # self.checkdiff(**case18)
+        # case19 = {
+        #     "table_expr": "stb1",
+        #     "condition": "partition by tbname"  # partition by tbname
+        # }
+        # self.checkdiff(**case19)
+
+        # # case20~21: with order by
+        # case20 = {"condition": "order by ts"}
+        # self.checkdiff(**case20)
+
+        # # case22: with union
+        # case22 = {
+        #     "condition": "union all select diff(c1) from t2"
+        # }
+        # self.checkdiff(**case22)
+
+        # case23: with limit/slimit
+        case23 = {
+            "condition": "limit 1"
+        }
+        self.checkdiff(**case23)
+        # case24 = {
+        #     "table_expr": "stb1",
+        #     "condition": "group by tbname slimit 1 soffset 1"
+        # }
+        # self.checkdiff(**case24)
+
+        pass
+
+    def diff_error_query(self) -> None :
+        # unusual test
+        #
+        # table schema :ts timestamp, c1 int, c2 float, c3 timestamp, c4 binary(16), c5 double, c6 bool
+        #                 c7 bigint, c8 smallint, c9 tinyint, c10 nchar(16)
+        #
+        # form test
+        tdSql.error(self.diff_query_form(col=""))   # no col
+        tdSql.error("diff(c1) from stb1")           # no select
+        tdSql.error("select diff from t1")          # no diff condition
+        tdSql.error("select diff c1 from t1")       # no brackets
+        tdSql.error("select diff(c1)   t1")         # no from
+        tdSql.error("select diff( c1 )  from ")     # no table_expr
+        # tdSql.error(self.diff_query_form(col="st1"))    # tag col
+        tdSql.query("select diff(st1) from t1 ")
+        # tdSql.error(self.diff_query_form(col=1))        # col is a value
+        tdSql.error(self.diff_query_form(col="'c1'"))   # col is a string
+        tdSql.error(self.diff_query_form(col=None))     # col is NULL 1
+        tdSql.error(self.diff_query_form(col="NULL"))   # col is NULL 2
+        tdSql.error(self.diff_query_form(col='""'))     # col is ""
+        tdSql.error(self.diff_query_form(col='c%'))     # col is spercial char 1
+        tdSql.error(self.diff_query_form(col='c_'))     # col is spercial char 2
+        tdSql.error(self.diff_query_form(col='c.'))     # col is spercial char 3
+        tdSql.error(self.diff_query_form(col='c3'))     # timestamp col
+        tdSql.error(self.diff_query_form(col='ts'))     # Primary key
+        tdSql.error(self.diff_query_form(col='avg(c1)'))    # expr col
+        # tdSql.error(self.diff_query_form(col='c6'))     # bool col
+        tdSql.query("select diff(c6) from t1")
+        tdSql.error(self.diff_query_form(col='c4'))     # binary col
+        tdSql.error(self.diff_query_form(col='c10'))    # nachr col
+        tdSql.error(self.diff_query_form(col='c10'))    # not table_expr col
+        tdSql.error(self.diff_query_form(col='t1'))     # tbname
+        tdSql.error(self.diff_query_form(col='stb1'))   # stbname
+        tdSql.error(self.diff_query_form(col='db'))     # datbasename
+        # tdSql.error(self.diff_query_form(col=True))     # col is BOOL 1
+        # tdSql.error(self.diff_query_form(col='True'))   # col is BOOL 2
+        tdSql.error(self.diff_query_form(col='*'))      # col is all col
+        tdSql.error("select diff[c1] from t1")          # sql form error 1
+        tdSql.error("select diff{c1} from t1")          # sql form error 2
+        tdSql.error(self.diff_query_form(col="[c1]"))   # sql form error 3
+        # tdSql.error(self.diff_query_form(col="c1, c2")) # sql form error 3
+        # tdSql.error(self.diff_query_form(col="c1, 2"))  # sql form error 3
+        tdSql.error(self.diff_query_form(alias=", count(c1)"))  # mix with aggregate function 1
+        tdSql.error(self.diff_query_form(alias=", avg(c1)"))    # mix with aggregate function 2
+        tdSql.error(self.diff_query_form(alias=", min(c1)"))    # mix with select function 1
+        tdSql.error(self.diff_query_form(alias=", top(c1, 5)")) # mix with select function 2
+        tdSql.error(self.diff_query_form(alias=", spread(c1)")) # mix with calculation function  1
+        tdSql.error(self.diff_query_form(alias=", diff(c1)"))   # mix with calculation function  2
+        # tdSql.error(self.diff_query_form(alias=" + 2"))         # mix with arithmetic 1
+        tdSql.error(self.diff_query_form(alias=" + avg(c1)"))   # mix with arithmetic 2
+        tdSql.error(self.diff_query_form(alias=", c2"))         # mix with other 1
+        # tdSql.error(self.diff_query_form(table_expr="stb1"))    # select stb directly
+        stb_join = {
+            "col": "stb1.c1",
+            "table_expr": "stb1, stb2",
+            "condition": "where stb1.ts=stb2.ts and stb1.st1=stb2.st2 order by stb1.ts"
+        }
+        tdSql.error(self.diff_query_form(**stb_join))           # stb join
+        interval_sql = {
+            "condition": "where ts>0 and ts < now interval(1h) fill(next)"
+        }
+        tdSql.error(self.diff_query_form(**interval_sql))       # interval
+        group_normal_col = {
+            "table_expr": "t1",
+            "condition": "group by c6"
+        }
+        tdSql.error(self.diff_query_form(**group_normal_col))       # group by normal col
+        slimit_soffset_sql = {
+            "table_expr": "stb1",
+            "condition": "group by tbname slimit 1 soffset 1"
+        }
+        # tdSql.error(self.diff_query_form(**slimit_soffset_sql))
+        order_by_tbname_sql = {
+            "table_expr": "stb1",
+            "condition": "group by tbname order by tbname"
+        }
+        tdSql.error(self.diff_query_form(**order_by_tbname_sql))
+
+        pass
+
+    def diff_test_data(self, tbnum:int, data_row:int, basetime:int) -> None :
+        for i in range(tbnum):
+            for j in range(data_row):
+                tdSql.execute(
+                    f"insert into t{i} values ("
+                    f"{basetime + (j+1)*10}, {random.randint(-200, -1)}, {random.uniform(200, -1)}, {basetime + random.randint(-200, -1)}, "
+                    f"'binary_{j}', {random.uniform(-200, -1)}, {random.choice([0,1])}, {random.randint(-200,-1)}, "
+                    f"{random.randint(-200, -1)}, {random.randint(-127, -1)}, 'nchar_{j}' )"
+                )
+
+                tdSql.execute(
+                    f"insert into t{i} values ("
+                    f"{basetime - (j+1) * 10}, {random.randint(1, 200)}, {random.uniform(1, 200)}, {basetime - random.randint(1, 200)}, "
+                    f"'binary_{j}_1', {random.uniform(1, 200)}, {random.choice([0, 1])}, {random.randint(1,200)}, "
+                    f"{random.randint(1,200)}, {random.randint(1,127)}, 'nchar_{j}_1' )"
+                )
+                tdSql.execute(
+                    f"insert into tt{i} values ( {basetime-(j+1) * 10}, {random.randint(1, 200)} )"
+                )
+
+        pass
+
+    def diff_test_table(self,tbnum: int) -> None :
+        tdSql.execute("drop database if exists db")
+        tdSql.execute("create database  if not exists db keep 3650")
+        tdSql.execute("use db")
+
+        tdSql.execute(
+            "create stable db.stb1 (\
+                ts timestamp, c1 int, c2 float, c3 timestamp, c4 binary(16), c5 double, c6 bool, \
+                c7 bigint, c8 smallint, c9 tinyint, c10 nchar(16)\
+                ) \
+            tags(st1 int)"
+        )
+        tdSql.execute(
+            "create stable db.stb2 (ts timestamp, c1 int) tags(st2 int)"
+        )
+        for i in range(tbnum):
+            tdSql.execute(f"create table t{i} using stb1 tags({i})")
+            tdSql.execute(f"create table tt{i} using stb2 tags({i})")
+
+        pass
+
+    def diff_test_run(self) :
+        tdLog.printNoPrefix("==========TD-10594==========")
+        tbnum = 10
+        nowtime = int(round(time.time() * 1000))
+        per_table_rows = 10
+        self.diff_test_table(tbnum)
+
+        tdLog.printNoPrefix("######## no data test:")
+        self.diff_current_query()
+        self.diff_error_query()
+
+        tdLog.printNoPrefix("######## insert only NULL test:")
+        for i in range(tbnum):
+            tdSql.execute(f"insert into t{i}(ts) values ({nowtime - 5})")
+            tdSql.execute(f"insert into t{i}(ts) values ({nowtime + 5})")
+        self.diff_current_query()
+        self.diff_error_query()
+
+        tdLog.printNoPrefix("######## insert data in the range near the max(bigint/double):")
+        self.diff_test_table(tbnum)
+        tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values "
+                      f"({nowtime - (per_table_rows + 1) * 10}, {2**31-1}, {3.4*10**38}, {1.7*10**308}, {2**63-1})")
+        tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values "
+                      f"({nowtime - (per_table_rows + 2) * 10}, {2**31-1}, {3.4*10**38}, {1.7*10**308}, {2**63-1})")
+        self.diff_current_query()
+        self.diff_error_query()
+
+        tdLog.printNoPrefix("######## insert data in the range near the min(bigint/double):")
+        self.diff_test_table(tbnum)
+        tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values "
+                      f"({nowtime - (per_table_rows + 1) * 10}, {1-2**31}, {-3.4*10**38}, {-1.7*10**308}, {1-2**63})")
+        tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values "
+                      f"({nowtime - (per_table_rows + 2) * 10}, {1-2**31}, {-3.4*10**38}, {-1.7*10**308}, {512-2**63})")
+        self.diff_current_query()
+        self.diff_error_query()
+
+        tdLog.printNoPrefix("######## insert data without NULL data test:")
+        self.diff_test_table(tbnum)
+        self.diff_test_data(tbnum, per_table_rows, nowtime)
+        self.diff_current_query()
+        self.diff_error_query()
+
+
+        tdLog.printNoPrefix("######## insert data mix with NULL test:")
+        for i in range(tbnum):
+            tdSql.execute(f"insert into t{i}(ts) values ({nowtime})")
+            tdSql.execute(f"insert into t{i}(ts) values ({nowtime-(per_table_rows+3)*10})")
+            tdSql.execute(f"insert into t{i}(ts) values ({nowtime+(per_table_rows+3)*10})")
+        self.diff_current_query()
+        self.diff_error_query()
+
+
+
+        tdLog.printNoPrefix("######## check after WAL test:")
+        tdSql.query("show dnodes")
+        index = tdSql.getData(0, 0)
+        tdDnodes.stop(index)
+        tdDnodes.start(index)
+        self.diff_current_query()
+        self.diff_error_query()
+
+    def run(self):
+        import traceback
+        try:
+            # run in  develop branch
+            self.diff_test_run()
+            pass
+        except Exception as e:
+            traceback.print_exc()
+            raise e
+
+
+    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

@@ -73,6 +73,13 @@ python3 ./test.py -f 2-query/arctan.py
 python3 ./test.py -f 2-query/query_cols_tags_and_or.py
 # python3 ./test.py -f 2-query/nestedQuery.py
 python3 ./test.py -f 2-query/nestedQuery_str.py
+python3 ./test.py -f 2-query/avg.py
+python3 ./test.py -f 2-query/elapsed.py
+python3 ./test.py -f 2-query/csum.py
+python3 ./test.py -f 2-query/mavg.py
+python3 ./test.py -f 2-query/diff.py
+python3 ./test.py -f 2-query/sample.py
+python3 ./test.py -f 2-query/function_diff.py
 
 python3 ./test.py -f 7-tmq/basic5.py
 python3 ./test.py -f 7-tmq/subscribeDb.py
@@ -84,4 +91,4 @@ python3 ./test.py -f 7-tmq/subscribeStb1.py
 python3 ./test.py -f 7-tmq/subscribeStb2.py
 python3 ./test.py -f 7-tmq/subscribeStb3.py
 python3 ./test.py -f 7-tmq/subscribeStb4.py
-python3 ./test.py -f 7-tmq/subscribeStb2.py
+python3 ./test.py -f 7-tmq/subscribeStb2.py
\ No newline at end of file