update apercentile.py

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

@@ -15,89 +15,117 @@ from util.log import *
 from util.cases import *
 from util.sql import *
 import numpy as np
-
+from util.sqlset import TDSetSql
 
 class TDTestCase:
     def init(self, conn, logSql):
         tdLog.debug("start to execute %s" % __file__)
-        tdSql.init(conn.cursor())
+        tdSql.init(conn.cursor(),logSql)
         self.rowNum = 10
         self.ts = 1537146000000
-        
-    def check_apercentile(self,data,expect_data,param,percent,column):
-        if param == "default":
-            if abs((expect_data-data) <= expect_data * 0.2):
-                tdLog.info(f"apercentile function values check success with col{column}, param = {param},percent = {percent}")
+        self.setsql = TDSetSql()
+        self.ntbname = 'ntb'
+        self.stbname = 'stb'
+        self.binary_length = 20 # the length of binary for column_dict
+        self.nchar_length = 20  # the length of nchar for column_dict
+        self.column_dict = {
+            'ts'  : 'timestamp',
+            '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.binary_length})',
+            'col13': f'nchar({self.nchar_length})'
+        }
+        
+        self.tag_dict = {
+            'ts_tag'  : 'timestamp',
+            't1': 'tinyint',
+            't2': 'smallint',
+            't3': 'int',
+            't4': 'bigint',
+            't5': 'tinyint unsigned',
+            't6': 'smallint unsigned',
+            't7': 'int unsigned',
+            't8': 'bigint unsigned',
+            't9': 'float',
+            't10': 'double',
+            't11': 'bool',
+            't12': f'binary({self.binary_length})',
+            't13': f'nchar({self.nchar_length})'
+        }
+        self.binary_str = 'taosdata'
+        self.nchar_str = '涛思数据'
+        self.tbnum = 2
+        self.tag_ts = self.ts
+        self.tag_tinyint = 1
+        self.tag_smallint = 2
+        self.tag_int = 3
+        self.tag_bigint = 4
+        self.tag_utint = 5
+        self.tag_usint = 6
+        self.tag_uint = 7
+        self.tag_ubint = 8
+        self.tag_float = 9.1
+        self.tag_double = 10.1
+        self.tag_bool = True
+        self.tag_values = [
+            f'{self.tag_ts},{self.tag_tinyint},{self.tag_smallint},{self.tag_int},{self.tag_bigint},\
+            {self.tag_utint},{self.tag_usint},{self.tag_uint},{self.tag_ubint},{self.tag_float},{self.tag_double},{self.tag_bool},"{self.binary_str}","{self.nchar_str}"'
+            
+        ]
+        
+        self.percent = [1,50,100]
+        self.param_list = ['default','t-digest']
+    def insert_data(self,column_dict,tbname,row_num):
+        insert_sql = self.setsql.set_insertsql(column_dict,tbname,self.binary_str,self.nchar_str)
+        for i in range(row_num):
+            insert_list = []
+            self.setsql.insert_values(column_dict,i,insert_sql,insert_list,self.ts)
+
+        
+    def function_check_ntb(self):
+        tdSql.prepare()
+        tdSql.execute(self.setsql.set_create_normaltable_sql(self.ntbname,self.column_dict))
+        self.insert_data(self.column_dict,self.ntbname,self.rowNum)
+        for k,v in self.column_dict.items():
+            for percent in self.percent:
+                for param in self.param_list:
+                    if v.lower() in ['timestamp','bool'] or 'binary' in v.lower() or 'nchar' in v.lower():
+                        tdSql.error(f'select apercentile({k},{percent},"{param}") from {self.ntbname}')
+                    else:
+                        tdSql.query(f"select apercentile({k},{percent},'{param}') from {self.ntbname}")
+    def function_check_stb(self):
+        tdSql.prepare()
+        tdSql.execute(self.setsql.set_create_stable_sql(self.stbname,self.column_dict,self.tag_dict))
+        for i in range(self.tbnum):
+            tdSql.execute(f"create table {self.stbname}_{i} using {self.stbname} tags({self.tag_values[0]})")
+            self.insert_data(self.column_dict,f'{self.stbname}_{i}',self.rowNum)
+        for i in range(self.tbnum):
+            for k,v in self.column_dict.items():
+                for percent in self.percent:
+                    for param in self.param_list:
+                        if v.lower() in ['timestamp','bool'] or 'binary' in v.lower() or 'nchar' in v.lower():
+                            tdSql.error(f'select apercentile({k},{percent},"{param}") from {self.stbname}_{i}')
                         else:
-                tdLog.notice(f"apercentile function value has not as expected with col{column}, param = {param},percent = {percent}")
-                sys.exit(1)
-        elif param == "t-digest":
-            if abs((expect_data-data) <= expect_data * 0.2):
-                tdLog.info(f"apercentile function values check success with col{column}, param = {param},percent = {percent}")
+                            tdSql.query(f"select apercentile({k},{percent},'{param}') from {self.stbname}_{i}")
+        for k,v in self.column_dict.items():
+                for percent in self.percent:
+                    for param in self.param_list:
+                        if v.lower() in ['timestamp','bool'] or 'binary' in v.lower() or 'nchar' in v.lower():
+                            tdSql.error(f'select apercentile({k},{percent},"{param}") from {self.stbname}')
                         else:
-                tdLog.notice(f"apercentile function value has not as expected with col{column}, param = {param},percent = {percent}")
-                sys.exit(1)
-
+                            tdSql.query(f"select apercentile({k},{percent},'{param}') from {self.stbname}")
     def run(self):
-        tdSql.prepare()
-
-        intData = []        
-        floatData = []
-        percent_list = [0,50,100]
-        param_list = ['default','t-digest']
-        tdSql.execute('''create table test(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double, 
-                    col7 bool, col8 binary(20), col9 nchar(20), col11 tinyint unsigned, col12 smallint unsigned, col13 int unsigned, col14 bigint unsigned)''')
-        for i in range(self.rowNum):
-            tdSql.execute("insert into test values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)" 
-                        % (self.ts + i, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1))
-            intData.append(i + 1)            
-            floatData.append(i + 0.1)                        
-
-        # percentile verifacation 
-        
-        tdSql.error("select apercentile(ts ,20) from test")
-        tdSql.error("select apercentile(col7 ,20) from test") 
-        tdSql.error("select apercentile(col8 ,20) from test")
-        tdSql.error("select apercentile(col9 ,20) from test")    
-
-        column_list = [1,2,3,4,5,6,11,12,13,14]
-        
-        for i in column_list:
-            for j in percent_list:
-                for k in param_list:
-                    tdSql.query(f"select apercentile(col{i},{j},'{k}') from test")
-                    data = tdSql.getData(0, 0)
-                    tdSql.query(f"select percentile(col{i},{j}) from test")
-                    expect_data = tdSql.getData(0, 0)
-                    self.check_apercentile(data,expect_data,k,j,i) 
-
-        error_param_list = [-1,101,'"a"']
-        for i in error_param_list:
-            tdSql.error(f'select apercentile(col1,{i}) from test')
-
-        tdSql.execute("create table meters (ts timestamp, voltage int) tags(loc nchar(20))")
-        tdSql.execute("create table t0 using meters tags('beijing')")
-        tdSql.execute("create table t1 using meters tags('shanghai')")
-        for i in range(self.rowNum):
-            tdSql.execute("insert into t0 values(%d, %d)" % (self.ts + i, i + 1))            
-            tdSql.execute("insert into t1 values(%d, %d)" % (self.ts + i, i + 1))            
-        
-        column_list = ['voltage']
-        for i in column_list:
-            for j in percent_list:
-                for k in param_list:
-                    tdSql.query(f"select apercentile({i}, {j},'{k}') from t0")
-                    data = tdSql.getData(0, 0)
-                    tdSql.query(f"select percentile({i},{j}) from t0")
-                    expect_data = tdSql.getData(0,0)
-                    self.check_apercentile(data,expect_data,k,j,i)
-                    tdSql.query(f"select apercentile({i}, {j},'{k}') from meters")
-                    tdSql.checkRows(1) 
-        table_list = ["meters","t0"]
-        for i in error_param_list:
-            for j in table_list:
-                for k in column_list:
-                    tdSql.error(f'select apercentile({k},{i}) from {j}')
+        self.function_check_ntb()
+        self.function_check_stb()
         
     def stop(self):
         tdSql.close()