add max to CI

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

@@ -5,10 +5,7 @@ import numpy as np
 
 
 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 ,"udfDebugFlag":143,
-    "maxTablesPerVnode":2 ,"minTablesPerVnode":2,"tableIncStepPerVnode":2 }
+    updatecfgDict = {"maxTablesPerVnode":2 ,"minTablesPerVnode":2,"tableIncStepPerVnode":2 }
     def init(self, conn, logSql):
         tdLog.debug("start to execute %s" % __file__)
         tdSql.init(conn.cursor())
@@ -17,60 +14,57 @@ class TDTestCase:
         self.ts = 1537146000000
         self.binary_str = 'taosdata'
         self.nchar_str = '涛思数据'
-    def max_check_stb_and_tb_base(self):
+    def max_check_stb_and_tb_base(self, dbname="db"):
         tdSql.prepare()
         intData = []
         floatData = []
-        tdSql.execute('''create table stb(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 tinyint unsigned, col6 smallint unsigned,
+        tdSql.execute(f'''create table {dbname}.stb(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 binary(20), col13 nchar(20)) tags(loc nchar(20))''')
-        tdSql.execute("create table stb_1 using stb tags('beijing')")
+        tdSql.execute(f"create table {dbname}.stb_1 using {dbname}.stb tags('beijing')")
         for i in range(self.rowNum):
-            tdSql.execute(f"insert into stb_1 values(%d, %d, %d, %d, %d, %d, %d, %d, %d, %f, %f, %d, '{self.binary_str}%d', '{self.nchar_str}%d')"
+            tdSql.execute(f"insert into {dbname}.stb_1 values(%d, %d, %d, %d, %d, %d, %d, %d, %d, %f, %f, %d, '{self.binary_str}%d', '{self.nchar_str}%d')"
                           % (self.ts + i, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1))
             intData.append(i + 1)
             floatData.append(i + 0.1)
         for i in ['ts','col11','col12','col13']:
-            for j in ['db.stb','stb','db.stb_1','stb_1']:
-                tdSql.error(f'select max({i} from {j} )')
+            for j in ['stb','stb_1']:
+                tdSql.error(f'select max({i} from {dbname}.{j} )')
 
         for i in range(1,11):
-            for j in ['db.stb','stb','db.stb_1','stb_1']:
-                tdSql.query(f"select max(col{i}) from {j}")
+            for j in ['stb', 'stb_1']:
+                tdSql.query(f"select max(col{i}) from {dbname}.{j}")
                 if i<9:
                     tdSql.checkData(0, 0, np.max(intData))
                 elif i>=9:
                     tdSql.checkData(0, 0, np.max(floatData))
-        tdSql.query("select max(col1) from stb_1 where col2<=5")
+        tdSql.query(f"select max(col1) from {dbname}.stb_1 where col2<=5")
         tdSql.checkData(0,0,5)
-        tdSql.query("select max(col1) from stb where col2<=5")
+        tdSql.query(f"select max(col1) from {dbname}.stb where col2<=5")
         tdSql.checkData(0,0,5)
-        tdSql.execute('drop database db')
 
-    def max_check_ntb_base(self):
+    def max_check_ntb_base(self, dbname="db"):
         tdSql.prepare()
         intData = []
         floatData = []
-        tdSql.execute('''create table ntb(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 tinyint unsigned, col6 smallint unsigned,
+        tdSql.execute(f'''create table {dbname}.ntb(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 binary(20), col13 nchar(20))''')
         for i in range(self.rowNum):
-            tdSql.execute(f"insert into ntb values(%d, %d, %d, %d, %d, %d, %d, %d, %d, %f, %f, %d, '{self.binary_str}%d', '{self.nchar_str}%d')"
+            tdSql.execute(f"insert into {dbname}.ntb values(%d, %d, %d, %d, %d, %d, %d, %d, %d, %f, %f, %d, '{self.binary_str}%d', '{self.nchar_str}%d')"
                           % (self.ts + i, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1))
             intData.append(i + 1)
             floatData.append(i + 0.1)
         for i in ['ts','col11','col12','col13']:
-            for j in ['db.ntb','ntb']:
-                tdSql.error(f'select max({i} from {j} )')
+            for j in ['ntb']:
+                tdSql.error(f'select max({i} from {dbname}.{j} )')
         for i in range(1,11):
-            for j in ['db.ntb','ntb']:
-                tdSql.query(f"select max(col{i}) from {j}")
+            for j in ['ntb']:
+                tdSql.query(f"select max(col{i}) from {dbname}.{j}")
                 if i<9:
                     tdSql.checkData(0, 0, np.max(intData))
                 elif i>=9:
                     tdSql.checkData(0, 0, np.max(floatData))
-        tdSql.query("select max(col1) from ntb where col2<=5")
+        tdSql.query(f"select max(col1) from {dbname}.ntb where col2<=5")
         tdSql.checkData(0,0,5)
-        tdSql.execute('drop database db')
-
 
     def check_max_functions(self, tbname , col_name):
 
@@ -90,55 +84,55 @@ class TDTestCase:
             tdLog.info(" max function work as expected, sql : %s "% max_sql)
 
 
-    def support_distributed_aggregate(self):
+    def support_distributed_aggregate(self, dbname="testdb"):
 
         # prepate datas for  20 tables distributed at different vgroups
-        tdSql.execute("create database if not exists testdb keep 3650 duration 1000 vgroups 5")
-        tdSql.execute(" use testdb ")
+        tdSql.execute(f"create database if not exists {dbname} keep 3650 duration 1000 vgroups 5")
+        tdSql.execute(f"use {dbname} ")
         tdSql.execute(
-            '''create table stb1
+            f'''create table {dbname}.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 (t0 timestamp, t1 int, t2 bigint, t3 smallint, t4 tinyint, t5 float, t6 double, t7 bool, t8 binary(16),t9 nchar(32))
             '''
         )
 
         tdSql.execute(
-            '''
-            create table t1
+            f'''
+            create table {dbname}.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(20):
-            tdSql.execute(f'create table ct{i+1} using stb1 tags ( now(), {1*i}, {11111*i}, {111*i}, {1*i}, {1.11*i}, {11.11*i}, {i%2}, "binary{i}", "nchar{i}" )')
+            tdSql.execute(f'create table {dbname}.ct{i+1} using {dbname}.stb1 tags ( now(), {1*i}, {11111*i}, {111*i}, {1*i}, {1.11*i}, {11.11*i}, {i%2}, "binary{i}", "nchar{i}" )')
 
         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 )"
+                f"insert into {dbname}.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 )"
+                f"insert into {dbname}.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 )"
             )
 
         for i in range(1,21):
             if i ==1 or i == 4:
                 continue
             else:
-                tbname = "ct"+f'{i}'
+                tbname = f"{dbname}.ct{i}"
                 for j in range(9):
                     tdSql.execute(
                 f"insert into {tbname} values ( now()-{(i+j)*10}s, {1*(j+i)}, {11111*(j+i)}, {111*(j+i)}, {11*(j)}, {1.11*(j+i)}, {11.11*(j+i)}, {(j+i)%2}, 'binary{j}', 'nchar{j}', now()+{1*j}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(f"insert into {dbname}.ct1 values (now()-45s, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar0', now()+8a )")
+        tdSql.execute(f"insert into {dbname}.ct1 values (now()+10s, 9, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a )")
+        tdSql.execute(f"insert into {dbname}.ct1 values (now()+15s, 9, -99999, -999, -99, -9.99, NULL, 1, 'binary9', 'nchar9', now()+9a )")
+        tdSql.execute(f"insert into {dbname}.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 {dbname}.ct4 values (now()-810d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
+        tdSql.execute(f"insert into {dbname}.ct4 values (now()-400d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
+        tdSql.execute(f"insert into {dbname}.ct4 values (now()+90d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL  ) ")
 
         tdSql.execute(
-            f'''insert into t1 values
+            f'''insert into {dbname}.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 )
@@ -157,7 +151,7 @@ class TDTestCase:
         tdLog.info(" prepare data for distributed_aggregate done! ")
 
         # get vgroup_ids of all
-        tdSql.query("show vgroups ")
+        tdSql.query(f"show {dbname}.vgroups ")
         vgroups = tdSql.queryResult
 
         vnode_tables={}
@@ -167,7 +161,7 @@ class TDTestCase:
 
 
         # check sub_table of per vnode ,make sure sub_table has been distributed
-        tdSql.query("select * from information_schema.ins_tables where db_name = 'testdb' and table_name like 'ct%'")
+        tdSql.query(f"select * from information_schema.ins_tables where db_name = '{dbname}' and table_name like 'ct%'")
         table_names = tdSql.queryResult
         tablenames = []
         for table_name in table_names:
@@ -182,13 +176,13 @@ class TDTestCase:
 
         # check max function work status
 
-        tdSql.query("show tables like 'ct%'")
+        tdSql.query(f"show {dbname}.tables like 'ct%'")
         table_names = tdSql.queryResult
         tablenames = []
         for table_name in table_names:
             tablenames.append(table_name[0])
 
-        tdSql.query("desc stb1")
+        tdSql.query(f"desc {dbname}.stb1")
         col_names = tdSql.queryResult
 
         colnames = []
@@ -198,11 +192,7 @@ class TDTestCase:
 
         for tablename in tablenames:
             for colname in colnames:
-                self.check_max_functions(tablename,colname)
-
-        # max function with basic filter
-        print(vnode_tables)
-
+                self.check_max_functions(f"{dbname}.{tablename}", colname)
 
     def run(self):
 

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

@@ -12,16 +12,15 @@ class TDTestCase:
         self.tb_nums = 10
         self.ts = 1537146000000
 
-    def prepare_datas(self, stb_name , tb_nums , row_nums ):
-        tdSql.execute(" use db ")
-        tdSql.execute(f" create stable {stb_name} (ts timestamp , c1 int , c2 bigint , c3 float , c4 double , c5 smallint , c6 tinyint , c7 bool , c8 binary(36) , c9 nchar(36) , uc1 int unsigned,\
+    def prepare_datas(self, stb_name , tb_nums , row_nums, dbname="db" ):
+        tdSql.execute(f" create stable {dbname}.{stb_name} (ts timestamp , c1 int , c2 bigint , c3 float , c4 double , c5 smallint , c6 tinyint , c7 bool , c8 binary(36) , c9 nchar(36) , uc1 int unsigned,\
             uc2 bigint unsigned ,uc3 smallint unsigned , uc4 tinyint unsigned ) tags(t1 timestamp , t2 int , t3 bigint , t4 float , t5 double , t6 smallint , t7 tinyint , t8 bool , t9 binary(36)\
                 , t10 nchar(36) , t11 int unsigned , t12 bigint unsigned ,t13 smallint unsigned , t14 tinyint unsigned ) ")
 
         for i in range(tb_nums):
-            tbname = f"sub_{stb_name}_{i}"
+            tbname = f"{dbname}.sub_{stb_name}_{i}"
             ts = self.ts + i*10000
-            tdSql.execute(f"create table {tbname} using {stb_name} tags ({ts} , {i} , {i}*10 ,{i}*1.0,{i}*1.0 , 1 , 2, 'true', 'binary_{i}' ,'nchar_{i}',{i},{i},10,20 )")
+            tdSql.execute(f"create table {tbname} using {dbname}.{stb_name} tags ({ts} , {i} , {i}*10 ,{i}*1.0,{i}*1.0 , 1 , 2, 'true', 'binary_{i}' ,'nchar_{i}',{i},{i},10,20 )")
 
             for row in range(row_nums):
                 ts = self.ts + row*1000
@@ -31,191 +30,192 @@ class TDTestCase:
                 ts =  self.ts + row_nums*1000 + null*1000
                 tdSql.execute(f"insert into {tbname} values({ts} , NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL )")
 
-    def basic_query(self):
-        tdSql.query("select count(*) from stb")
+    def basic_query(self, dbname="db"):
+        tdSql.query(f"select count(*) from {dbname}.stb")
         tdSql.checkData(0,0,(self.row_nums + 5 )*self.tb_nums)
-        tdSql.query("select max(c1) from stb")
+        tdSql.query(f"select max(c1) from {dbname}.stb")
         tdSql.checkData(0,0,(self.row_nums -1))
-        tdSql.query(" select tbname , max(c1) from stb partition by tbname ")
+        tdSql.query(f"select tbname , max(c1) from {dbname}.stb partition by tbname ")
         tdSql.checkRows(self.tb_nums)
-        tdSql.query(" select max(c1) from stb group by t1 order by t1 ")
+        tdSql.query(f"select max(c1) from {dbname}.stb group by t1 order by t1 ")
         tdSql.checkRows(self.tb_nums)
-        tdSql.query(" select max(c1) from stb group by c1 order by t1 ")
-        tdSql.query(" select max(t2) from stb group by c1 order by t1 ")
-        tdSql.query(" select max(c1) from stb group by tbname order by tbname ")
+        tdSql.query(f"select max(c1) from {dbname}.stb group by c1 order by t1 ")
+        tdSql.query(f"select max(t2) from {dbname}.stb group by c1 order by t1 ")
+        tdSql.query(f"select max(c1) from {dbname}.stb group by tbname order by tbname ")
         tdSql.checkRows(self.tb_nums)
         # bug need fix
-        tdSql.query(" select max(t2) from stb group by t2 order by t2 ")
+        tdSql.query(f"select max(t2) from {dbname}.stb group by t2 order by t2 ")
         tdSql.checkRows(self.tb_nums)
-        tdSql.query(" select max(c1) from stb group by c1 order by c1 ")
+        tdSql.query(f"select max(c1) from {dbname}.stb group by c1 order by c1 ")
         tdSql.checkRows(self.row_nums+1)
 
-        tdSql.query(" select c1 , max(c1) from stb group by c1 order by c1 ")
+        tdSql.query(f"select c1 , max(c1) from {dbname}.stb group by c1 order by c1 ")
         tdSql.checkRows(self.row_nums+1)
 
         # support selective functions
-        tdSql.query(" select c1 ,c2 ,c3 , max(c1)  ,c4 ,c5 ,t11 from stb group by c1 order by c1 desc ")
+        tdSql.query(f"select c1 ,c2 ,c3 , max(c1)  ,c4 ,c5 ,t11 from {dbname}.stb group by c1 order by c1 desc ")
         tdSql.checkRows(self.row_nums+1)
 
-        tdSql.query(" select c1, tbname , max(c1)  ,c4 ,c5 ,t11 from stb group by c1 order by c1 desc ")
+        tdSql.query(f"select c1, tbname , max(c1)  ,c4 ,c5 ,t11 from {dbname}.stb group by c1 order by c1 desc ")
         tdSql.checkRows(self.row_nums+1)
 
         # bug need fix
-        # tdSql.query(" select tbname , max(c1)  from sub_stb_1 where c1 is null group by c1 order by c1 desc ")
-        # tdSql.checkRows(1)
-        # tdSql.checkData(0,0,"sub_stb_1")
+        tdSql.query(f"select tbname , max(c1)  from {dbname}.sub_stb_1 where c1 is null group by c1 order by c1 desc ")
+        tdSql.checkRows(1)
+        tdSql.checkData(0,0,"sub_stb_1")
 
-        tdSql.query("select max(c1) ,c2 ,t2,tbname from stb group by abs(c1) order by abs(c1)")
+        tdSql.query(f"select max(c1) ,c2 ,t2,tbname from {dbname}.stb group by abs(c1) order by abs(c1)")
         tdSql.checkRows(self.row_nums+1)
-        tdSql.query("select abs(c1+c3), count(c1+c3) ,max(c1+t2) from stb group by abs(c1+c3) order by abs(c1+c3)")
+        tdSql.query(f"select abs(c1+c3), count(c1+c3) ,max(c1+t2) from {dbname}.stb group by abs(c1+c3) order by abs(c1+c3)")
         tdSql.checkRows(self.row_nums+1)
-        tdSql.query("select max(c1+c3)+min(c2) ,abs(c1) from stb group by abs(c1) order by abs(c1)")
+        tdSql.query(f"select max(c1+c3)+min(c2) ,abs(c1) from {dbname}.stb group by abs(c1) order by abs(c1)")
         tdSql.checkRows(self.row_nums+1)
-        tdSql.error("select count(c1+c3)+max(c2) ,abs(c1) ,abs(t1) from stb group by abs(c1) order by abs(t1)+c2")
-        tdSql.error("select count(c1+c3)+max(c2) ,abs(c1) from stb group by abs(c1) order by abs(c1)+c2")
-        tdSql.query("select abs(c1+c3)+abs(c2) , count(c1+c3)+max(c2) from stb group by abs(c1+c3)+abs(c2) order by abs(c1+c3)+abs(c2)")
+        tdSql.error(f"select count(c1+c3)+max(c2) ,abs(c1) ,abs(t1) from {dbname}.stb group by abs(c1) order by abs(t1)+c2")
+        tdSql.error(f"select count(c1+c3)+max(c2) ,abs(c1) from {dbname}.stb group by abs(c1) order by abs(c1)+c2")
+        tdSql.query(f"select abs(c1+c3)+abs(c2) , count(c1+c3)+max(c2) from {dbname}.stb group by abs(c1+c3)+abs(c2) order by abs(c1+c3)+abs(c2)")
         tdSql.checkRows(self.row_nums+1)
 
-        tdSql.query(" select max(c1) , max(t2) from stb where abs(c1+t2)=1 partition by tbname ")
+        tdSql.query(f"select max(c1) , max(t2) from {dbname}.stb where abs(c1+t2)=1 partition by tbname ")
         tdSql.checkRows(2)
-        tdSql.query(" select max(c1) from stb where abs(c1+t2)=1 partition by tbname ")
+        tdSql.query(f"select max(c1) from {dbname}.stb where abs(c1+t2)=1 partition by tbname ")
         tdSql.checkRows(2)
 
-        tdSql.query(" select tbname , max(c1) from stb partition by tbname order by tbname ")
+        tdSql.query(f"select tbname , max(c1) from {dbname}.stb partition by tbname order by tbname ")
         tdSql.checkRows(self.tb_nums)
         tdSql.checkData(0,1,self.row_nums-1)
 
-        tdSql.query("select tbname , max(c2) from stb partition by t1 order by t1")
-        tdSql.query("select tbname , max(t2) from stb partition by t1 order by t1")
-        tdSql.query("select tbname , max(t2) from stb partition by t2 order by t2")
+        tdSql.query(f"select tbname , max(c2) from {dbname}.stb partition by t1 order by t1")
+        tdSql.query(f"select tbname , max(t2) from {dbname}.stb partition by t1 order by t1")
+        tdSql.query(f"select tbname , max(t2) from {dbname}.stb partition by t2 order by t2")
 
         # # bug need fix
-        tdSql.query("select t2 , max(t2) from stb partition by t2 order by t2")
+        tdSql.query(f"select t2 , max(t2) from {dbname}.stb partition by t2 order by t2")
         tdSql.checkRows(self.tb_nums)
 
-        tdSql.query("select tbname , max(c1) from stb partition by tbname order by tbname")
+        tdSql.query(f"select tbname , max(c1) from {dbname}.stb partition by tbname order by tbname")
         tdSql.checkRows(self.tb_nums)
         tdSql.checkData(0,1,self.row_nums-1)
 
 
-        tdSql.query("select tbname , max(c1) from stb partition by t2 order by t2")
+        tdSql.query(f"select tbname , max(c1) from {dbname}.stb partition by t2 order by t2")
 
-        tdSql.query("select c2, max(c1) from stb partition by c2 order by c2 desc")
+        tdSql.query(f"select c2, max(c1) from {dbname}.stb partition by c2 order by c2 desc")
         tdSql.checkRows(self.tb_nums+1)
         tdSql.checkData(0,1,self.row_nums-1)
 
-        tdSql.query("select tbname , max(c1) from stb partition by c1 order by c2")
+        tdSql.query(f"select tbname , max(c1) from {dbname}.stb partition by c1 order by c2")
 
 
-        tdSql.query("select tbname , abs(t2) from stb partition by c2 order by t2")
+        tdSql.query(f"select tbname , abs(t2) from {dbname}.stb partition by c2 order by t2")
         tdSql.checkRows(self.tb_nums*(self.row_nums+5))
 
-        tdSql.query("select max(c1) , count(t2) from stb partition by c2 ")
+        tdSql.query(f"select max(c1) , count(t2) from {dbname}.stb partition by c2 ")
         tdSql.checkRows(self.row_nums+1)
         tdSql.checkData(0,1,self.row_nums)
 
-        tdSql.query("select count(c1) , max(t2) ,c2 from stb partition by c2 order by c2")
+        tdSql.query(f"select count(c1) , max(t2) ,c2 from {dbname}.stb partition by c2 order by c2")
         tdSql.checkRows(self.row_nums+1)
 
-        tdSql.query("select count(c1) , count(t1) ,max(c2) ,tbname  from stb partition by tbname order by tbname")
+        tdSql.query(f"select count(c1) , count(t1) ,max(c2) ,tbname  from {dbname}.stb partition by tbname order by tbname")
         tdSql.checkRows(self.tb_nums)
         tdSql.checkCols(4)
 
-        tdSql.query("select count(c1) , max(t2) ,t1  from stb partition by t1 order by t1")
+        tdSql.query(f"select count(c1) , max(t2) ,t1  from {dbname}.stb partition by t1 order by t1")
         tdSql.checkRows(self.tb_nums)
         tdSql.checkData(0,0,self.row_nums)
 
         # bug need fix
-        tdSql.query("select count(c1) , max(t2) ,abs(c1) from stb partition by abs(c1) order by abs(c1)")
+        tdSql.query(f"select count(c1) , max(t2) ,abs(c1) from {dbname}.stb partition by abs(c1) order by abs(c1)")
         tdSql.checkRows(self.row_nums+1)
 
 
-        tdSql.query("select max(ceil(c2)) , max(floor(t2)) ,max(floor(c2)) from stb partition by abs(c2) order by abs(c2)")
+        tdSql.query(f"select max(ceil(c2)) , max(floor(t2)) ,max(floor(c2)) from {dbname}.stb partition by abs(c2) order by abs(c2)")
         tdSql.checkRows(self.row_nums+1)
 
 
-        tdSql.query("select max(ceil(c1-2)) , max(floor(t2+1)) ,max(c2-c1) from stb partition by abs(floor(c1)) order by abs(floor(c1))")
+        tdSql.query(f"select max(ceil(c1-2)) , max(floor(t2+1)) ,max(c2-c1) from {dbname}.stb partition by abs(floor(c1)) order by abs(floor(c1))")
         tdSql.checkRows(self.row_nums+1)
 
-        tdSql.query("select tbname , max(c1) ,c1 from stb partition by tbname order by tbname")
+        tdSql.query(f"select tbname , max(c1) ,c1 from {dbname}.stb partition by tbname order by tbname")
         tdSql.checkRows(self.tb_nums)
         tdSql.checkData(0,0,'sub_stb_0')
         tdSql.checkData(0,1,9)
         tdSql.checkData(0,2,9)
 
-        tdSql.query("select tbname ,top(c1,1) ,c1 from stb partition by tbname order by tbname")
+        tdSql.query(f"select tbname ,top(c1,1) ,c1 from {dbname}.stb partition by tbname order by tbname")
         tdSql.checkRows(self.tb_nums)
 
-        tdSql.query(" select c1 , sample(c1,2) from stb partition by tbname order by tbname ")
+        tdSql.query(f"select c1 , sample(c1,2) from {dbname}.stb partition by tbname order by tbname ")
         tdSql.checkRows(self.tb_nums*2)
 
 
         # interval
-        tdSql.query("select max(c1) from stb interval(2s) sliding(1s)")
+        tdSql.query(f"select max(c1) from {dbname}.stb interval(2s) sliding(1s)")
 
         # bug need fix
 
-        tdSql.query('select max(c1) from stb where ts>="2022-07-06 16:00:00.000 " and ts < "2022-07-06 17:00:00.000 " interval(50s) sliding(30s) fill(NULL)')
+        tdSql.query(f'select max(c1) from {dbname}.stb where ts>="2022-07-06 16:00:00.000 " and ts < "2022-07-06 17:00:00.000 " interval(50s) sliding(30s) fill(NULL)')
 
-        tdSql.query(" select tbname , count(c1) from stb partition by tbname interval(10s) slimit 5 soffset 1 ")
+        tdSql.query(f"select tbname , count(c1) from {dbname}.stb partition by tbname interval(10s) slimit 5 soffset 1 ")
 
-        tdSql.query("select tbname , max(c1) from stb partition by tbname interval(10s)")
+        tdSql.query(f"select tbname , max(c1) from {dbname}.stb partition by tbname interval(10s)")
         tdSql.checkRows(self.row_nums*2)
 
-        tdSql.query("select unique(c1) from stb partition  by tbname order by tbname")
+        tdSql.query(f"select unique(c1) from {dbname}.stb partition  by tbname order by tbname")
 
-        tdSql.query("select tbname , count(c1) from sub_stb_1 partition by tbname interval(10s)")
+        tdSql.query(f"select tbname , count(c1) from {dbname}.sub_stb_1 partition by tbname interval(10s)")
         tdSql.checkData(0,0,'sub_stb_1')
         tdSql.checkData(0,1,self.row_nums)
 
-        tdSql.query("select c1 , mavg(c1 ,2 ) from stb partition by c1")
+        tdSql.query(f"select c1 , mavg(c1 ,2 ) from {dbname}.stb partition by c1")
         tdSql.checkRows(90)
 
-        tdSql.query("select c1 , diff(c1 , 0) from stb partition by c1")
+        tdSql.query(f"select c1 , diff(c1 , 0) from {dbname}.stb partition by c1")
         tdSql.checkRows(90)
 
-        tdSql.query("select c1 , csum(c1) from stb partition by c1")
+        tdSql.query(f"select c1 , csum(c1) from {dbname}.stb partition by c1")
         tdSql.checkRows(100)
 
-        tdSql.query("select c1 , sample(c1,2) from stb partition by c1 order by c1")
+        tdSql.query(f"select c1 , sample(c1,2) from {dbname}.stb partition by c1 order by c1")
         tdSql.checkRows(21)
         # bug need fix
-        # tdSql.checkData(0,1,None)
+        tdSql.checkData(0,1,None)
 
-        tdSql.query("select c1 , twa(c1) from stb partition by c1 order by c1")
+        tdSql.query(f"select c1 , twa(c1) from {dbname}.stb partition by c1 order by c1")
         tdSql.checkRows(11)
         tdSql.checkData(0,1,None)
 
-        tdSql.query("select c1 , irate(c1) from stb partition by c1 order by c1")
+        tdSql.query(f"select c1 , irate(c1) from {dbname}.stb partition by c1 order by c1")
         tdSql.checkRows(11)
         tdSql.checkData(0,1,None)
 
-        tdSql.query("select c1 , DERIVATIVE(c1,2,1) from stb partition by c1 order by c1")
+        tdSql.query(f"select c1 , DERIVATIVE(c1,2,1) from {dbname}.stb partition by c1 order by c1")
         tdSql.checkRows(90)
         # bug need fix
         tdSql.checkData(0,1,None)
 
 
-        tdSql.query(" select tbname , max(c1) from stb partition by tbname order by tbname slimit 5 soffset 0 ")
+        tdSql.query(f"select tbname , max(c1) from {dbname}.stb partition by tbname order by tbname slimit 5 soffset 0 ")
         tdSql.checkRows(10)
 
-        tdSql.query(" select tbname , max(c1) from sub_stb_1 partition by tbname interval(10s) sliding(5s) ")
+        tdSql.query(f"select tbname , max(c1) from {dbname}.sub_stb_1 partition by tbname interval(10s) sliding(5s) ")
 
-        tdSql.query(f'select max(c1) from stb where ts>={self.ts} and ts < {self.ts}+1000 interval(50s) sliding(30s)')
-        tdSql.query(f'select tbname , max(c1) from stb where ts>={self.ts} and ts < {self.ts}+1000 interval(50s) sliding(30s)')
+        tdSql.query(f'select max(c1) from {dbname}.stb where ts>={self.ts} and ts < {self.ts}+1000 interval(50s) sliding(30s)')
+        tdSql.query(f'select tbname , max(c1) from {dbname}.stb where ts>={self.ts} and ts < {self.ts}+1000 interval(50s) sliding(30s)')
 
 
     def run(self):
+        dbname = "db"
         tdSql.prepare()
         self.prepare_datas("stb",self.tb_nums,self.row_nums)
         self.basic_query()
 
         # # coverage case for taosd crash about bug fix
-        tdSql.query(" select sum(c1) from stb where t2+10 >1 ")
-        tdSql.query(" select count(c1),count(t1) from stb where -t2<1 ")
-        tdSql.query(" select tbname ,max(ceil(c1)) from stb group by tbname ")
-        tdSql.query(" select avg(abs(c1)) , tbname from stb group by tbname ")
-        tdSql.query(" select t1,c1 from stb where abs(t2+c1)=1 ")
+        tdSql.query(f"select sum(c1) from {dbname}.stb where t2+10 >1 ")
+        tdSql.query(f"select count(c1),count(t1) from {dbname}.stb where -t2<1 ")
+        tdSql.query(f"select tbname ,max(ceil(c1)) from {dbname}.stb group by tbname ")
+        tdSql.query(f"select avg(abs(c1)) , tbname from {dbname}.stb group by tbname ")
+        tdSql.query(f"select t1,c1 from {dbname}.stb where abs(t2+c1)=1 ")
 
 
     def stop(self):

tests/system-test/fulltest.sh

@@ -124,6 +124,11 @@ python3 ./test.py -f 2-query/leastsquares.py
 python3 ./test.py -f 2-query/leastsquares.py -R
 python3 ./test.py -f 2-query/length.py
 python3 ./test.py -f 2-query/length.py -R
+python3 ./test.py -f 2-query/max_partition.py
+python3 ./test.py -f 2-query/max_partition.py -R
+python3 ./test.py -f 2-query/max.py
+python3 ./test.py -f 2-query/max.py -R
+
 
 python3 ./test.py -f 1-insert/update_data.py
 
@@ -145,7 +150,6 @@ python3 ./test.py -f 2-query/spread.py
 python3 ./test.py -f 2-query/timezone.py
 python3 ./test.py -f 2-query/Now.py
 python3 ./test.py -f 2-query/Today.py
-python3 ./test.py -f 2-query/max.py
 python3 ./test.py -f 2-query/min.py
 python3 ./test.py -f 2-query/To_iso8601.py
 python3 ./test.py -f 2-query/To_unixtimestamp.py
@@ -179,7 +183,6 @@ python3 ./test.py -f 2-query/tail.py
 python3 ./test.py -f 2-query/ttl_comment.py
 python3 ./test.py -f 2-query/twa.py
 python3 ./test.py -f 2-query/queryQnode.py
-python3 ./test.py -f 2-query/max_partition.py
 python3 ./test.py -f 2-query/tsbsQuery.py
 
 python3 ./test.py -f 6-cluster/5dnode1mnode.py