511 lines
22 KiB
Python
511 lines
22 KiB
Python
###################################################################
|
||
# 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 *
|
||
|
||
msec_per_min=60 * 1000
|
||
class TDTestCase:
|
||
def init(self, conn, logSql, replicaVar=1):
|
||
self.replicaVar = int(replicaVar)
|
||
tdLog.debug("start to execute %s" % __file__)
|
||
tdSql.init(conn.cursor(), logSql)
|
||
|
||
def csum_query_form(self, col="c1", alias="", table_expr="db.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="db.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.replace("csum", "ts, csum"), 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]
|
||
if (platform.system().lower() == 'windows' and pre_data.dtype == 'int32'):
|
||
pre_data = np.array(pre_data, dtype = 'int64')
|
||
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]
|
||
if (platform.system().lower() == 'windows' and pre_result.dtype == 'int32'):
|
||
pre_result = np.array(pre_result, dtype = 'int64')
|
||
pre_csum = np.cumsum(pre_result)[offset_val:]
|
||
tdSql.query(self.csum_query_form(
|
||
col=col, alias=alias, table_expr=table_expr.replace("csum", "ts,csum"), 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 ts,c1 from db.stb1 order by ts, tbname )"}
|
||
self.checkcsum(**case7)
|
||
case8 = {"table_expr": "(select csum(c1) c1 from db.t1)"}
|
||
self.checkcsum(**case8)
|
||
|
||
# case9~10: mix with tbname/ts/tag/col not support , must partition by alias ,such as select tbname ,csum(c1) partition by tbname
|
||
# 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": "db.t1",
|
||
"condition": "where c6 <0 partition by c6 order by c6"
|
||
}
|
||
self.checkcsum(**case18)
|
||
case19 = {
|
||
"table_expr": "db.t1",
|
||
"condition": " " # partition by tbname
|
||
}
|
||
self.checkcsum(**case19)
|
||
|
||
# case20~21: with order by
|
||
case20 = {"condition": "partition by tbname order by tbname "}
|
||
# self.checkcsum(**case20) # order by without order by tbname ,because check will random failed
|
||
|
||
# case22: with union
|
||
case22 = {
|
||
"condition": "union all select csum(c1) from db.t2"
|
||
}
|
||
# self.checkcsum(**case22) union all without check result becasue ,it will random return table_records
|
||
|
||
# case23: with limit/slimit
|
||
case23 = {
|
||
"condition": "limit 1"
|
||
}
|
||
self.checkcsum(**case23)
|
||
case24 = {
|
||
"table_expr": "db.t1",
|
||
"condition": "partition by tbname "
|
||
}
|
||
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": "db.t1",
|
||
"condition": "group by c6"
|
||
}
|
||
tdSql.error(self.csum_query_form(**group_normal_col)) # group by normal col
|
||
slimit_soffset_sql = {
|
||
"table_expr": "db.stb1",
|
||
"condition": "group by tbname slimit 1 soffset 1"
|
||
}
|
||
# tdSql.error(self.csum_query_form(**slimit_soffset_sql))
|
||
order_by_tbname_sql = {
|
||
"table_expr": "db.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 + i * msec_per_min}, {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 + i * msec_per_min}, {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 + i * msec_per_min}, {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 db.t{i} using db.stb1 tags({i})")
|
||
tdSql.execute(f"create table db.tt{i} using db.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 db.t{i}(ts) values ({nowtime - 5 + i * msec_per_min})")
|
||
tdSql.execute(f"insert into db.t{i}(ts) values ({nowtime + 5 + i * msec_per_min})")
|
||
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 db.t1(ts, c1,c2,c5,c7) values "
|
||
f"({nowtime - (per_table_rows + 1) * 10 + i * msec_per_min}, {2**31-1}, {3.4*10**38}, {1.7*10**308}, {2**63-1})")
|
||
tdSql.execute(f"insert into db.t1(ts, c1,c2,c5,c7) values "
|
||
f"({nowtime - (per_table_rows + 2) * 10 + i * msec_per_min}, {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 db.t1(ts, c1,c2,c5,c7) values "
|
||
f"({nowtime - (per_table_rows + 1) * 10 + i * msec_per_min}, {1-2**31}, {-3.4*10**38}, {-1.7*10**308}, {1-2**63})")
|
||
tdSql.execute(f"insert into db.t1(ts, c1,c2,c5,c7) values "
|
||
f"({nowtime - (per_table_rows + 2) * 10 + i * msec_per_min}, {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 db.t{i}(ts) values ({nowtime + i * msec_per_min})")
|
||
tdSql.execute(f"insert into db.t{i}(ts) values ({nowtime-(per_table_rows+3)*10 + i * msec_per_min})")
|
||
tdSql.execute(f"insert into db.t{i}(ts) values ({nowtime+(per_table_rows+3)*10 + i * msec_per_min})")
|
||
self.csum_current_query()
|
||
self.csum_error_query()
|
||
|
||
|
||
|
||
tdLog.printNoPrefix("######## check after WAL test:")
|
||
tdSql.query("select * from information_schema.ins_dnodes")
|
||
index = tdSql.getData(0, 0)
|
||
tdDnodes.stop(index)
|
||
tdDnodes.start(index)
|
||
self.csum_current_query()
|
||
self.csum_error_query()
|
||
tdSql.query("select csum(1) from db.t1 ")
|
||
tdSql.checkRows(7)
|
||
tdSql.checkData(0,0,1)
|
||
tdSql.checkData(1,0,2)
|
||
tdSql.checkData(2,0,3)
|
||
tdSql.checkData(3,0,4)
|
||
tdSql.query("select csum(abs(c1))+2 from db.t1 ")
|
||
tdSql.checkRows(4)
|
||
|
||
# support selectivity
|
||
tdSql.query("select ts, c1, csum(1) from db.t1")
|
||
tdSql.checkRows(7)
|
||
|
||
tdSql.query("select csum(1), ts, c1 from db.t1")
|
||
tdSql.checkRows(7)
|
||
|
||
tdSql.query("select ts, c1, c2, c3, csum(1), ts, c4, c5, c6 from db.t1")
|
||
tdSql.checkRows(7)
|
||
|
||
tdSql.query("select ts, c1, csum(1), c4, c5, csum(1), c6 from db.t1")
|
||
tdSql.checkRows(7)
|
||
|
||
def csum_support_stable(self):
|
||
tdSql.query(" select csum(1) from db.stb1 ")
|
||
tdSql.checkRows(70)
|
||
tdSql.query("select csum(c1) from db.stb1 partition by tbname ")
|
||
tdSql.checkRows(40)
|
||
tdSql.query("select csum(st1) from db.stb1 partition by tbname")
|
||
tdSql.checkRows(70)
|
||
tdSql.query("select csum(st1+c1) from db.stb1 partition by tbname")
|
||
tdSql.checkRows(40)
|
||
tdSql.query("select csum(st1+c1) from db.stb1 partition by tbname")
|
||
tdSql.checkRows(40)
|
||
tdSql.query("select csum(st1+c1) from db.stb1 partition by tbname")
|
||
tdSql.checkRows(40)
|
||
|
||
# # bug need fix
|
||
tdSql.query("select csum(st1+c1) from db.stb1 partition by tbname slimit 1 ")
|
||
tdSql.checkRows(4)
|
||
# tdSql.error("select csum(st1+c1) from db.stb1 partition by tbname limit 1 ")
|
||
|
||
|
||
# bug need fix
|
||
tdSql.query("select csum(st1+c1) from db.stb1 partition by tbname")
|
||
tdSql.checkRows(40)
|
||
|
||
# bug need fix
|
||
tdSql.query("select tbname , csum(c1) from db.stb1 partition by tbname")
|
||
tdSql.checkRows(40)
|
||
tdSql.query("select tbname , csum(st1) from db.stb1 partition by tbname")
|
||
tdSql.checkRows(70)
|
||
tdSql.query("select tbname , csum(st1) from db.stb1 partition by tbname slimit 1")
|
||
tdSql.checkRows(7)
|
||
|
||
# partition by tags
|
||
tdSql.query("select st1 , csum(c1) from db.stb1 partition by st1")
|
||
tdSql.checkRows(40)
|
||
tdSql.query("select csum(c1) from db.stb1 partition by st1")
|
||
tdSql.checkRows(40)
|
||
tdSql.query("select st1 , csum(c1) from db.stb1 partition by st1 slimit 1")
|
||
tdSql.checkRows(4)
|
||
tdSql.query("select csum(c1) from db.stb1 partition by st1 slimit 1")
|
||
tdSql.checkRows(4)
|
||
|
||
# partition by col
|
||
# tdSql.query("select c1 , csum(c1) from db.stb1 partition by c1")
|
||
# tdSql.checkRows(41)
|
||
# tdSql.query("select csum(c1) from db.stb1 partition by c1")
|
||
# tdSql.checkRows(41)
|
||
# tdSql.query("select c1 , csum(c1) from db.stb1 partition by st1 slimit 1")
|
||
# tdSql.checkRows(4)
|
||
# tdSql.query("select csum(c1) from db.stb1 partition by st1 slimit 1")
|
||
# tdSql.checkRows(4)
|
||
|
||
|
||
|
||
def run(self):
|
||
import traceback
|
||
try:
|
||
# run in develop branch
|
||
self.csum_test_run()
|
||
self.csum_support_stable()
|
||
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())
|