xxq250
/
homework-jianmu
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

fix case

This commit is contained in:
cpwu 2022-08-17 16:11:37 +08:00
parent 09982db5d3
commit 3a5f3203a0
7 changed files with 391 additions and 407 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
tests/pytest/util/common.py
View File

@ -199,22 +199,22 @@ class TDCom:
res = requests.post(url, sql.encode("utf-8"), headers = self.preDefine()[0]) res = requests.post(url, sql.encode("utf-8"), headers = self.preDefine()[0])
return res return res
def cleanTb(self, type="taosc"): def cleanTb(self, type="taosc", dbname="db"):
''' '''
type is taosc or restful type is taosc or restful
''' '''
query_sql = "show stables" query_sql = f"show {dbname}.stables"
res_row_list = tdSql.query(query_sql, True) res_row_list = tdSql.query(query_sql, True)
stb_list = map(lambda x: x[0], res_row_list) stb_list = map(lambda x: x[0], res_row_list)
for stb in stb_list: for stb in stb_list:
if type == "taosc": if type == "taosc":
tdSql.execute(f'drop table if exists `{stb}`') tdSql.execute(f'drop table if exists `{dbname}.{stb}`')
if not stb[0].isdigit(): if not stb[0].isdigit():
tdSql.execute(f'drop table if exists {stb}') tdSql.execute(f'drop table if exists {dbname}.{stb}')
elif type == "restful": elif type == "restful":
self.restApiPost(f"drop table if exists `{stb}`") self.restApiPost(f"drop table if exists `{dbname}.{stb}`")
if not stb[0].isdigit(): if not stb[0].isdigit():
self.restApiPost(f"drop table if exists {stb}") self.restApiPost(f"drop table if exists {dbname}.{stb}")
def dateToTs(self, datetime_input): def dateToTs(self, datetime_input):
return int(time.mktime(time.strptime(datetime_input, "%Y-%m-%d %H:%M:%S.%f"))) return int(time.mktime(time.strptime(datetime_input, "%Y-%m-%d %H:%M:%S.%f")))

48
tests/system-test/2-query/qnodeCluster.py
View File

@ -13,9 +13,9 @@ from util.common import *
sys.path.append("./6-cluster/") sys.path.append("./6-cluster/")
from clusterCommonCreate import * from clusterCommonCreate import *
from clusterCommonCheck import clusterComCheck from clusterCommonCheck import clusterComCheck
import threading import threading
class TDTestCase: class TDTestCase:
@ -28,7 +28,7 @@ class TDTestCase:
def init(self, conn, logSql): def init(self, conn, logSql):
tdLog.debug(f"start to excute {__file__}") tdLog.debug(f"start to excute {__file__}")
tdSql.init(conn.cursor(), True) tdSql.init(conn.cursor(), False)
def create_ctable(self,tsql=None, dbName='dbx',stbName='stb',ctbPrefix='ctb',ctbNum=1): def create_ctable(self,tsql=None, dbName='dbx',stbName='stb',ctbPrefix='ctb',ctbNum=1):
tsql.execute("use %s" %dbName) tsql.execute("use %s" %dbName)
@ -47,7 +47,7 @@ class TDTestCase:
sql = pre_create sql = pre_create
if sql != pre_create: if sql != pre_create:
tsql.execute(sql) tsql.execute(sql)
tdLog.debug("complete to create %d child tables in %s.%s" %(ctbNum, dbName, stbName)) tdLog.debug("complete to create %d child tables in %s.%s" %(ctbNum, dbName, stbName))
return return
@ -55,7 +55,7 @@ class TDTestCase:
dbname="db_tsbs" dbname="db_tsbs"
stabname1="readings" stabname1="readings"
stabname2="diagnostics" stabname2="diagnostics"
ctbnamePre1="rct" ctbnamePre1="rct"
ctbnamePre2="dct" ctbnamePre2="dct"
ctbNums=40 ctbNums=40
self.ctbNums=ctbNums self.ctbNums=ctbNums
@ -73,7 +73,7 @@ class TDTestCase:
self.create_ctable(tsql=tdSql,dbName=dbname,stbName=stabname2,ctbPrefix=ctbnamePre2,ctbNum=ctbNums) self.create_ctable(tsql=tdSql,dbName=dbname,stbName=stabname2,ctbPrefix=ctbnamePre2,ctbNum=ctbNums)
for j in range(ctbNums): for j in range(ctbNums):
for i in range(rowNUms): for i in range(rowNUms):
tdSql.execute( tdSql.execute(
f"insert into rct{j} values ( {ts+i*60000}, {80+i}, {90+i}, {85+i}, {30+i*10}, {1.2*i}, {221+i*2}, {20+i*0.2}, {1500+i*20}, {150+i*2},{5+i} )" f"insert into rct{j} values ( {ts+i*60000}, {80+i}, {90+i}, {85+i}, {30+i*10}, {1.2*i}, {221+i*2}, {20+i*0.2}, {1500+i*20}, {150+i*2},{5+i} )"
@ -109,19 +109,19 @@ class TDTestCase:
def tsbsIotQuery(self,tdSql): def tsbsIotQuery(self,tdSql):
tdSql.execute("use db_tsbs") tdSql.execute("use db_tsbs")
# test interval and partition # test interval and partition
tdSql.query(" SELECT avg(velocity) as mean_velocity ,name,driver,fleet FROM readings WHERE ts > 1451606400000 AND ts <= 1451606460000 partition BY name,driver,fleet; ") tdSql.query(" SELECT avg(velocity) as mean_velocity ,name,driver,fleet FROM readings WHERE ts > 1451606400000 AND ts <= 1451606460000 partition BY name,driver,fleet; ")
# print(tdSql.queryResult) # print(tdSql.queryResult)
parRows=tdSql.queryRows parRows=tdSql.queryRows
tdSql.query(" SELECT avg(velocity) as mean_velocity ,name,driver,fleet FROM readings WHERE ts > 1451606400000 AND ts <= 1451606460000 partition BY name,driver,fleet interval(10m); ") tdSql.query(" SELECT avg(velocity) as mean_velocity ,name,driver,fleet FROM readings WHERE ts > 1451606400000 AND ts <= 1451606460000 partition BY name,driver,fleet interval(10m); ")
tdSql.checkRows(parRows) tdSql.checkRows(parRows)
# # test insert into # # test insert into
# tdSql.execute("create table testsnode (ts timestamp, c1 float,c2 binary(30),c3 binary(30),c4 binary(30)) ;") # tdSql.execute("create table testsnode (ts timestamp, c1 float,c2 binary(30),c3 binary(30),c4 binary(30)) ;")
# tdSql.query("insert into testsnode SELECT ts,avg(velocity) as mean_velocity,name,driver,fleet FROM readings WHERE ts > 1451606400000 AND ts <= 1451606460000 partition BY name,driver,fleet,ts interval(10m);") # tdSql.query("insert into testsnode SELECT ts,avg(velocity) as mean_velocity,name,driver,fleet FROM readings WHERE ts > 1451606400000 AND ts <= 1451606460000 partition BY name,driver,fleet,ts interval(10m);")
# tdSql.query("insert into testsnode(ts,c1,c2,c3,c4) SELECT ts,avg(velocity) as mean_velocity,name,driver,fleet FROM readings WHERE ts > 1451606400000 AND ts <= 1451606460000 partition BY name,driver,fleet,ts interval(10m);") # tdSql.query("insert into testsnode(ts,c1,c2,c3,c4) SELECT ts,avg(velocity) as mean_velocity,name,driver,fleet FROM readings WHERE ts > 1451606400000 AND ts <= 1451606460000 partition BY name,driver,fleet,ts interval(10m);")
@ -141,7 +141,7 @@ class TDTestCase:
tdSql.query("SELECT ts,name,driver,current_load,load_capacity FROM (SELECT last(ts) as ts,name,driver, current_load,load_capacity FROM diagnostics WHERE fleet = 'South' partition by name,driver) WHERE current_load>= (0.9 * load_capacity) partition by name ORDER BY name ;") tdSql.query("SELECT ts,name,driver,current_load,load_capacity FROM (SELECT last(ts) as ts,name,driver, current_load,load_capacity FROM diagnostics WHERE fleet = 'South' partition by name,driver) WHERE current_load>= (0.9 * load_capacity) partition by name ORDER BY name ;")
# 2 stationary-trucks # 2 stationary-trucks
tdSql.query("select name,driver from (SELECT name,driver,fleet ,avg(velocity) as mean_velocity FROM readings WHERE ts > '2016-01-01T15:07:21Z' AND ts <= '2016-01-01T16:17:21Z' partition BY name,driver,fleet interval(10m) LIMIT 1)") tdSql.query("select name,driver from (SELECT name,driver,fleet ,avg(velocity) as mean_velocity FROM readings WHERE ts > '2016-01-01T15:07:21Z' AND ts <= '2016-01-01T16:17:21Z' partition BY name,driver,fleet interval(10m) LIMIT 1)")
tdSql.query("select name,driver from (SELECT name,driver,fleet ,avg(velocity) as mean_velocity FROM readings WHERE ts > '2016-01-01T15:07:21Z' AND ts <= '2016-01-01T16:17:21Z' partition BY name,driver,fleet interval(10m) LIMIT 1) WHERE fleet = 'West' AND mean_velocity < 1000 partition BY name") tdSql.query("select name,driver from (SELECT name,driver,fleet ,avg(velocity) as mean_velocity FROM readings WHERE ts > '2016-01-01T15:07:21Z' AND ts <= '2016-01-01T16:17:21Z' partition BY name,driver,fleet interval(10m) LIMIT 1) WHERE fleet = 'West' AND mean_velocity < 1000 partition BY name")
@ -156,7 +156,7 @@ class TDTestCase:
tdSql.query("select _wstart as ts,fleet,name,driver,count(mv)/6 as hours_driven from ( select _wstart as ts,fleet,name,driver,avg(velocity) as mv from readings where ts > '2016-01-01T00:00:00Z' and ts < '2016-01-05T00:00:01Z' partition by fleet,name,driver interval(10m)) where ts > '2016-01-01T00:00:00Z' and ts < '2016-01-05T00:00:01Z' partition by fleet,name,driver interval(1d) ;") tdSql.query("select _wstart as ts,fleet,name,driver,count(mv)/6 as hours_driven from ( select _wstart as ts,fleet,name,driver,avg(velocity) as mv from readings where ts > '2016-01-01T00:00:00Z' and ts < '2016-01-05T00:00:01Z' partition by fleet,name,driver interval(10m)) where ts > '2016-01-01T00:00:00Z' and ts < '2016-01-05T00:00:01Z' partition by fleet,name,driver interval(1d) ;")
# # 6. avg-daily-driving-session # # 6. avg-daily-driving-session
# #taosc core dumped # #taosc core dumped
# tdSql.execute("create table random_measure2_1 (ts timestamp,ela float, name binary(40))") # tdSql.execute("create table random_measure2_1 (ts timestamp,ela float, name binary(40))")
# tdSql.query("SELECT ts,diff(mv) AS difka FROM (SELECT ts,name,floor(avg(velocity)/10)/floor(avg(velocity)/10) AS mv FROM readings WHERE name!='' AND ts > '2016-01-01T00:00:00Z' AND ts < '2016-01-05T00:00:01Z' partition by name,ts interval(10m) fill(value,0)) GROUP BY name,ts;") # tdSql.query("SELECT ts,diff(mv) AS difka FROM (SELECT ts,name,floor(avg(velocity)/10)/floor(avg(velocity)/10) AS mv FROM readings WHERE name!='' AND ts > '2016-01-01T00:00:00Z' AND ts < '2016-01-05T00:00:01Z' partition by name,ts interval(10m) fill(value,0)) GROUP BY name,ts;")
@ -166,7 +166,7 @@ class TDTestCase:
# 7. avg-load # 7. avg-load
tdSql.query("SELECT fleet, model,avg(ml) AS mean_load_percentage FROM (SELECT fleet, model,current_load/load_capacity AS ml FROM diagnostics partition BY name, fleet, model) partition BY fleet, model order by fleet ;") tdSql.query("SELECT fleet, model,avg(ml) AS mean_load_percentage FROM (SELECT fleet, model,current_load/load_capacity AS ml FROM diagnostics partition BY name, fleet, model) partition BY fleet, model order by fleet ;")
# 8. daily-activity # 8. daily-activity
tdSql.query(" SELECT model,ms1 FROM (SELECT _wstart as ts1,model, fleet,avg(status) AS ms1 FROM diagnostics WHERE ts >= '2016-01-01T00:00:00Z' AND ts < '2016-01-05T00:00:01Z' partition by model, fleet interval(10m) fill(value,0)) WHERE ts1 >= '2016-01-01T00:00:00Z' AND ts1 < '2016-01-05T00:00:01Z' AND ms1<1;") tdSql.query(" SELECT model,ms1 FROM (SELECT _wstart as ts1,model, fleet,avg(status) AS ms1 FROM diagnostics WHERE ts >= '2016-01-01T00:00:00Z' AND ts < '2016-01-05T00:00:01Z' partition by model, fleet interval(10m) fill(value,0)) WHERE ts1 >= '2016-01-01T00:00:00Z' AND ts1 < '2016-01-05T00:00:01Z' AND ms1<1;")
tdSql.query(" SELECT model,ms1 FROM (SELECT _wstart as ts1,model, fleet,avg(status) AS ms1 FROM diagnostics WHERE ts >= '2016-01-01T00:00:00Z' AND ts < '2016-01-05T00:00:01Z' partition by model, fleet interval(10m) ) WHERE ts1 >= '2016-01-01T00:00:00Z' AND ts1 < '2016-01-05T00:00:01Z' AND ms1<1;") tdSql.query(" SELECT model,ms1 FROM (SELECT _wstart as ts1,model, fleet,avg(status) AS ms1 FROM diagnostics WHERE ts >= '2016-01-01T00:00:00Z' AND ts < '2016-01-05T00:00:01Z' partition by model, fleet interval(10m) ) WHERE ts1 >= '2016-01-01T00:00:00Z' AND ts1 < '2016-01-05T00:00:01Z' AND ms1<1;")
@ -184,7 +184,7 @@ class TDTestCase:
tdSql.query(" SELECT model,state_changed,count(state_changed) FROM (SELECT model,diff(broken_down) AS state_changed FROM (SELECT _wstart,model,cast(cast(floor(2*(sum(nzs)/count(nzs))) as bool) as int) AS broken_down FROM (SELECT ts,model, cast(cast(status as bool) as int) AS nzs FROM diagnostics WHERE ts >= '2016-01-01T00:00:00Z' AND ts < '2016-01-05T00:00:01Z' ) WHERE ts >= '2016-01-01T00:00:00Z' AND ts < '2016-01-05T00:00:01Z' partition BY model interval(10m)) partition BY model) where state_changed =1 partition BY model,state_changed ;") tdSql.query(" SELECT model,state_changed,count(state_changed) FROM (SELECT model,diff(broken_down) AS state_changed FROM (SELECT _wstart,model,cast(cast(floor(2*(sum(nzs)/count(nzs))) as bool) as int) AS broken_down FROM (SELECT ts,model, cast(cast(status as bool) as int) AS nzs FROM diagnostics WHERE ts >= '2016-01-01T00:00:00Z' AND ts < '2016-01-05T00:00:01Z' ) WHERE ts >= '2016-01-01T00:00:00Z' AND ts < '2016-01-05T00:00:01Z' partition BY model interval(10m)) partition BY model) where state_changed =1 partition BY model,state_changed ;")
#it's already supported: #it's already supported:
# last-loc # last-loc
tdSql.query("SELECT last_row(ts),latitude,longitude,name,driver FROM readings WHERE fleet='South' and name IS NOT NULL partition BY name,driver order by name ;") tdSql.query("SELECT last_row(ts),latitude,longitude,name,driver FROM readings WHERE fleet='South' and name IS NOT NULL partition BY name,driver order by name ;")
@ -192,7 +192,7 @@ class TDTestCase:
#2. low-fuel #2. low-fuel
tdSql.query("SELECT last_row(ts),name,driver,fuel_state,driver FROM diagnostics WHERE fuel_state <= 0.1 AND fleet = 'South' and name IS NOT NULL GROUP BY name,driver order by name;") tdSql.query("SELECT last_row(ts),name,driver,fuel_state,driver FROM diagnostics WHERE fuel_state <= 0.1 AND fleet = 'South' and name IS NOT NULL GROUP BY name,driver order by name;")
# 3. avg-vs-projected-fuel-consumption # 3. avg-vs-projected-fuel-consumption
tdSql.query("select avg(fuel_consumption) as avg_fuel_consumption,avg(nominal_fuel_consumption) as nominal_fuel_consumption from readings where velocity > 1 group by fleet") tdSql.query("select avg(fuel_consumption) as avg_fuel_consumption,avg(nominal_fuel_consumption) as nominal_fuel_consumption from readings where velocity > 1 group by fleet")
@ -213,16 +213,16 @@ class TDTestCase:
'ctbPrefix': 'ctb', 'ctbPrefix': 'ctb',
'ctbNum': 1, 'ctbNum': 1,
} }
dnodeNumbers=int(dnodeNumbers) dnodeNumbers=int(dnodeNumbers)
mnodeNums=int(mnodeNums) mnodeNums=int(mnodeNums)
vnodeNumbers = int(dnodeNumbers-mnodeNums) vnodeNumbers = int(dnodeNumbers-mnodeNums)
tdSql.query("select * from information_schema.ins_dnodes;") tdSql.query("select * from information_schema.ins_dnodes;")
tdLog.debug(tdSql.queryResult) tdLog.debug(tdSql.queryResult)
clusterComCheck.checkDnodes(dnodeNumbers) clusterComCheck.checkDnodes(dnodeNumbers)
tdLog.info("create database and stable") tdLog.info("create database and stable")
tdDnodes=cluster.dnodes tdDnodes=cluster.dnodes
stopcount =0 stopcount =0
threads=[] threads=[]
@ -234,7 +234,7 @@ class TDTestCase:
for tr in threads: for tr in threads:
tr.start() tr.start()
tdLog.info("Take turns stopping %s "%stopRole) tdLog.info("Take turns stopping %s "%stopRole)
while stopcount < restartNumbers: while stopcount < restartNumbers:
tdLog.info(" restart loop: %d"%stopcount ) tdLog.info(" restart loop: %d"%stopcount )
if stopRole == "mnode": if stopRole == "mnode":
@ -242,7 +242,7 @@ class TDTestCase:
tdDnodes[i].stoptaosd() tdDnodes[i].stoptaosd()
# sleep(10) # sleep(10)
tdDnodes[i].starttaosd() tdDnodes[i].starttaosd()
# sleep(10) # sleep(10)
elif stopRole == "vnode": elif stopRole == "vnode":
for i in range(vnodeNumbers): for i in range(vnodeNumbers):
tdDnodes[i+mnodeNums].stoptaosd() tdDnodes[i+mnodeNums].stoptaosd()
@ -254,7 +254,7 @@ class TDTestCase:
tdDnodes[i].stoptaosd() tdDnodes[i].stoptaosd()
# sleep(10) # sleep(10)
tdDnodes[i].starttaosd() tdDnodes[i].starttaosd()
# sleep(10) # sleep(10)
# dnodeNumbers don't include database of schema # dnodeNumbers don't include database of schema
if clusterComCheck.checkDnodes(dnodeNumbers): if clusterComCheck.checkDnodes(dnodeNumbers):
@ -265,12 +265,12 @@ class TDTestCase:
tdLog.exit("one or more of dnodes failed to start ") tdLog.exit("one or more of dnodes failed to start ")
# self.check3mnode() # self.check3mnode()
stopcount+=1 stopcount+=1
for tr in threads: for tr in threads:
tr.join() tr.join()
def run(self): def run(self):
tdLog.printNoPrefix("==========step1:create database and table,insert data ==============") tdLog.printNoPrefix("==========step1:create database and table,insert data ==============")
self.createCluster() self.createCluster()
self.prepareData() self.prepareData()

21
tests/system-test/2-query/query_cols_tags_and_or.py
View File

@ -19,7 +19,7 @@ class TDTestCase:
def init(self, conn, logSql): def init(self, conn, logSql):
## add for TD-6672 ## add for TD-6672
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor(), logSql) tdSql.init(conn.cursor(), False)
def insertData(self, tb_name): def insertData(self, tb_name):
insert_sql_list = [f'insert into {tb_name} values ("2021-01-01 12:00:00", 1, 1, 1, 3, 1.1, 1.1, "binary", "nchar", true, 1, 2, 3, 4)', insert_sql_list = [f'insert into {tb_name} values ("2021-01-01 12:00:00", 1, 1, 1, 3, 1.1, 1.1, "binary", "nchar", true, 1, 2, 3, 4)',
@ -37,17 +37,17 @@ class TDTestCase:
for sql in insert_sql_list: for sql in insert_sql_list:
tdSql.execute(sql) tdSql.execute(sql)
def initTb(self): def initTb(self, dbname="db"):
tdCom.cleanTb() tdCom.cleanTb(dbname)
tb_name = tdCom.getLongName(8, "letters") tb_name = f'{dbname}.{tdCom.getLongName(8, "letters")}'
tdSql.execute( tdSql.execute(
f"CREATE TABLE {tb_name} (ts timestamp, c1 tinyint, c2 smallint, c3 int, c4 bigint, c5 float, c6 double, c7 binary(100), c8 nchar(200), c9 bool, c10 tinyint unsigned, c11 smallint unsigned, c12 int unsigned, c13 bigint unsigned)") f"CREATE TABLE {tb_name} (ts timestamp, c1 tinyint, c2 smallint, c3 int, c4 bigint, c5 float, c6 double, c7 binary(100), c8 nchar(200), c9 bool, c10 tinyint unsigned, c11 smallint unsigned, c12 int unsigned, c13 bigint unsigned)")
self.insertData(tb_name) self.insertData(tb_name)
return tb_name return tb_name
def initStb(self, count=5): def initStb(self, count=5, dbname="db"):
tdCom.cleanTb() tdCom.cleanTb(dbname)
tb_name = tdCom.getLongName(8, "letters") tb_name = f'{dbname}.{tdCom.getLongName(8, "letters")}'
tdSql.execute( tdSql.execute(
f"CREATE TABLE {tb_name} (ts timestamp, c1 tinyint, c2 smallint, c3 int, c4 bigint, c5 float, c6 double, c7 binary(100), c8 nchar(200), c9 bool, c10 tinyint unsigned, c11 smallint unsigned, c12 int unsigned, c13 bigint unsigned) tags (t1 tinyint, t2 smallint, t3 int, t4 bigint, t5 float, t6 double, t7 binary(100), t8 nchar(200), t9 bool, t10 tinyint unsigned, t11 smallint unsigned, t12 int unsigned, t13 bigint unsigned)") f"CREATE TABLE {tb_name} (ts timestamp, c1 tinyint, c2 smallint, c3 int, c4 bigint, c5 float, c6 double, c7 binary(100), c8 nchar(200), c9 bool, c10 tinyint unsigned, c11 smallint unsigned, c12 int unsigned, c13 bigint unsigned) tags (t1 tinyint, t2 smallint, t3 int, t4 bigint, t5 float, t6 double, t7 binary(100), t8 nchar(200), t9 bool, t10 tinyint unsigned, t11 smallint unsigned, t12 int unsigned, t13 bigint unsigned)")
for i in range(1, count+1): for i in range(1, count+1):
@ -56,9 +56,10 @@ class TDTestCase:
self.insertData(f'{tb_name}_sub_{i}') self.insertData(f'{tb_name}_sub_{i}')
return tb_name return tb_name
def initTwoStb(self): def initTwoStb(self, dbname="db"):
tdCom.cleanTb() tdCom.cleanTb(dbname)
tb_name = tdCom.getLongName(8, "letters") tb_name = f'{dbname}.{tdCom.getLongName(8, "letters")}'
# tb_name = tdCom.getLongName(8, "letters")
tb_name1 = f'{tb_name}1' tb_name1 = f'{tb_name}1'
tb_name2 = f'{tb_name}2' tb_name2 = f'{tb_name}2'
tdSql.execute( tdSql.execute(

343
tests/system-test/2-query/round.py
View File

@ -8,49 +8,46 @@ from util.sql import *
from util.cases import * from util.cases import *
class TDTestCase: 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}
def init(self, conn, logSql): def init(self, conn, logSql):
tdLog.debug(f"start to excute {__file__}") tdLog.debug(f"start to excute {__file__}")
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def prepare_datas(self): def prepare_datas(self, dbname="db"):
tdSql.execute( 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) (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) tags (t1 int)
''' '''
) )
tdSql.execute( tdSql.execute(
''' f'''
create table t1 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) (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): for i in range(4):
tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )') tdSql.execute(f'create table {dbname}.ct{i+1} using {dbname}.stb1 tags ( {i+1} )')
for i in range(9): for i in range(9):
tdSql.execute( 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( 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 )"
) )
tdSql.execute("insert into ct1 values (now()-45s, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar0', now()+8a )") tdSql.execute(f"insert into {dbname}.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(f"insert into {dbname}.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(f"insert into {dbname}.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()+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(f"insert into {dbname}.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(f"insert into {dbname}.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()+90d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
tdSql.execute( 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-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-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 ) ( '2020-12-31 01:01:01.000', 2, 22222, 222, 22, 2.22, 22.22, 0, "binary2", "nchar2", now()+2a )
@ -94,68 +91,68 @@ class TDTestCase:
else: else:
tdLog.info("round value check pass , it work as expected ,sql is \"%s\" "%round_query ) tdLog.info("round value check pass , it work as expected ,sql is \"%s\" "%round_query )
def test_errors(self): def test_errors(self, dbname="db"):
error_sql_lists = [ error_sql_lists = [
"select round from t1", f"select round from {dbname}.t1",
# "select round(-+--+c1) from t1", # f"select round(-+--+c1) from {dbname}.t1",
# "select +-round(c1) from t1", # f"select +-round(c1) from {dbname}.t1",
# "select ++-round(c1) from t1", # f"select ++-round(c1) from {dbname}.t1",
# "select ++--round(c1) from t1", # f"select ++--round(c1) from {dbname}.t1",
# "select - -round(c1)*0 from t1", # f"select - -round(c1)*0 from {dbname}.t1",
# "select round(tbname+1) from t1 ", # f"select round(tbname+1) from {dbname}.t1 ",
"select round(123--123)==1 from t1", f"select round(123--123)==1 from {dbname}.t1",
"select round(c1) as 'd1' from t1", f"select round(c1) as 'd1' from {dbname}.t1",
"select round(c1 ,c2 ) from t1", f"select round(c1 ,c2 ) from {dbname}.t1",
"select round(c1 ,NULL) from t1", f"select round(c1 ,NULL) from {dbname}.t1",
"select round(,) from t1;", f"select round(,) from {dbname}.t1;",
"select round(round(c1) ab from t1)", f"select round(round(c1) ab from {dbname}.t1)",
"select round(c1) as int from t1", f"select round(c1) as int from {dbname}.t1",
"select round from stb1", f"select round from {dbname}.stb1",
# "select round(-+--+c1) from stb1", # f"select round(-+--+c1) from {dbname}.stb1",
# "select +-round(c1) from stb1", # f"select +-round(c1) from {dbname}.stb1",
# "select ++-round(c1) from stb1", # f"select ++-round(c1) from {dbname}.stb1",
# "select ++--round(c1) from stb1", # f"select ++--round(c1) from {dbname}.stb1",
# "select - -round(c1)*0 from stb1", # f"select - -round(c1)*0 from {dbname}.stb1",
# "select round(tbname+1) from stb1 ", # f"select round(tbname+1) from {dbname}.stb1 ",
"select round(123--123)==1 from stb1", f"select round(123--123)==1 from {dbname}.stb1",
"select round(c1) as 'd1' from stb1", f"select round(c1) as 'd1' from {dbname}.stb1",
"select round(c1 ,c2 ) from stb1", f"select round(c1 ,c2 ) from {dbname}.stb1",
"select round(c1 ,NULL) from stb1", f"select round(c1 ,NULL) from {dbname}.stb1",
"select round(,) from stb1;", f"select round(,) from {dbname}.stb1;",
"select round(round(c1) ab from stb1)", f"select round(round(c1) ab from {dbname}.stb1)",
"select round(c1) as int from stb1" f"select round(c1) as int from {dbname}.stb1"
] ]
for error_sql in error_sql_lists: for error_sql in error_sql_lists:
tdSql.error(error_sql) tdSql.error(error_sql)
def support_types(self): def support_types(self, dbname="db"):
type_error_sql_lists = [ type_error_sql_lists = [
"select round(ts) from t1" , f"select round(ts) from {dbname}.t1" ,
"select round(c7) from t1", f"select round(c7) from {dbname}.t1",
"select round(c8) from t1", f"select round(c8) from {dbname}.t1",
"select round(c9) from t1", f"select round(c9) from {dbname}.t1",
"select round(ts) from ct1" , f"select round(ts) from {dbname}.ct1" ,
"select round(c7) from ct1", f"select round(c7) from {dbname}.ct1",
"select round(c8) from ct1", f"select round(c8) from {dbname}.ct1",
"select round(c9) from ct1", f"select round(c9) from {dbname}.ct1",
"select round(ts) from ct3" , f"select round(ts) from {dbname}.ct3" ,
"select round(c7) from ct3", f"select round(c7) from {dbname}.ct3",
"select round(c8) from ct3", f"select round(c8) from {dbname}.ct3",
"select round(c9) from ct3", f"select round(c9) from {dbname}.ct3",
"select round(ts) from ct4" , f"select round(ts) from {dbname}.ct4" ,
"select round(c7) from ct4", f"select round(c7) from {dbname}.ct4",
"select round(c8) from ct4", f"select round(c8) from {dbname}.ct4",
"select round(c9) from ct4", f"select round(c9) from {dbname}.ct4",
"select round(ts) from stb1" , f"select round(ts) from {dbname}.stb1" ,
"select round(c7) from stb1", f"select round(c7) from {dbname}.stb1",
"select round(c8) from stb1", f"select round(c8) from {dbname}.stb1",
"select round(c9) from stb1" , f"select round(c9) from {dbname}.stb1" ,
"select round(ts) from stbbb1" , f"select round(ts) from {dbname}.stbbb1" ,
"select round(c7) from stbbb1", f"select round(c7) from {dbname}.stbbb1",
"select round(ts) from tbname", f"select round(ts) from {dbname}.tbname",
"select round(c9) from tbname" f"select round(c9) from {dbname}.tbname"
] ]
@ -164,127 +161,127 @@ class TDTestCase:
type_sql_lists = [ type_sql_lists = [
"select round(c1) from t1", f"select round(c1) from {dbname}.t1",
"select round(c2) from t1", f"select round(c2) from {dbname}.t1",
"select round(c3) from t1", f"select round(c3) from {dbname}.t1",
"select round(c4) from t1", f"select round(c4) from {dbname}.t1",
"select round(c5) from t1", f"select round(c5) from {dbname}.t1",
"select round(c6) from t1", f"select round(c6) from {dbname}.t1",
"select round(c1) from ct1", f"select round(c1) from {dbname}.ct1",
"select round(c2) from ct1", f"select round(c2) from {dbname}.ct1",
"select round(c3) from ct1", f"select round(c3) from {dbname}.ct1",
"select round(c4) from ct1", f"select round(c4) from {dbname}.ct1",
"select round(c5) from ct1", f"select round(c5) from {dbname}.ct1",
"select round(c6) from ct1", f"select round(c6) from {dbname}.ct1",
"select round(c1) from ct3", f"select round(c1) from {dbname}.ct3",
"select round(c2) from ct3", f"select round(c2) from {dbname}.ct3",
"select round(c3) from ct3", f"select round(c3) from {dbname}.ct3",
"select round(c4) from ct3", f"select round(c4) from {dbname}.ct3",
"select round(c5) from ct3", f"select round(c5) from {dbname}.ct3",
"select round(c6) from ct3", f"select round(c6) from {dbname}.ct3",
"select round(c1) from stb1", f"select round(c1) from {dbname}.stb1",
"select round(c2) from stb1", f"select round(c2) from {dbname}.stb1",
"select round(c3) from stb1", f"select round(c3) from {dbname}.stb1",
"select round(c4) from stb1", f"select round(c4) from {dbname}.stb1",
"select round(c5) from stb1", f"select round(c5) from {dbname}.stb1",
"select round(c6) from stb1", f"select round(c6) from {dbname}.stb1",
"select round(c6) as alisb from stb1", f"select round(c6) as alisb from {dbname}.stb1",
"select round(c6) alisb from stb1", f"select round(c6) alisb from {dbname}.stb1",
] ]
for type_sql in type_sql_lists: for type_sql in type_sql_lists:
tdSql.query(type_sql) tdSql.query(type_sql)
def basic_round_function(self): def basic_round_function(self, dbname="db"):
# basic query # basic query
tdSql.query("select c1 from ct3") tdSql.query(f"select c1 from {dbname}.ct3")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select c1 from t1") tdSql.query(f"select c1 from {dbname}.t1")
tdSql.checkRows(12) tdSql.checkRows(12)
tdSql.query("select c1 from stb1") tdSql.query(f"select c1 from {dbname}.stb1")
tdSql.checkRows(25) tdSql.checkRows(25)
# used for empty table , ct3 is empty # used for empty table , ct3 is empty
tdSql.query("select round(c1) from ct3") tdSql.query(f"select round(c1) from {dbname}.ct3")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select round(c2) from ct3") tdSql.query(f"select round(c2) from {dbname}.ct3")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select round(c3) from ct3") tdSql.query(f"select round(c3) from {dbname}.ct3")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select round(c4) from ct3") tdSql.query(f"select round(c4) from {dbname}.ct3")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select round(c5) from ct3") tdSql.query(f"select round(c5) from {dbname}.ct3")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select round(c6) from ct3") tdSql.query(f"select round(c6) from {dbname}.ct3")
# used for regular table # used for regular table
tdSql.query("select round(c1) from t1") tdSql.query(f"select round(c1) from {dbname}.t1")
tdSql.checkData(0, 0, None) tdSql.checkData(0, 0, None)
tdSql.checkData(1 , 0, 1) tdSql.checkData(1 , 0, 1)
tdSql.checkData(3 , 0, 3) tdSql.checkData(3 , 0, 3)
tdSql.checkData(5 , 0, None) tdSql.checkData(5 , 0, None)
tdSql.query("select c1, c2, c3 , c4, c5 from t1") tdSql.query(f"select c1, c2, c3 , c4, c5 from {dbname}.t1")
tdSql.checkData(1, 4, 1.11000) tdSql.checkData(1, 4, 1.11000)
tdSql.checkData(3, 3, 33) tdSql.checkData(3, 3, 33)
tdSql.checkData(5, 4, None) tdSql.checkData(5, 4, None)
tdSql.query("select ts,c1, c2, c3 , c4, c5 from t1") tdSql.query(f"select ts,c1, c2, c3 , c4, c5 from {dbname}.t1")
tdSql.checkData(1, 5, 1.11000) tdSql.checkData(1, 5, 1.11000)
tdSql.checkData(3, 4, 33) tdSql.checkData(3, 4, 33)
tdSql.checkData(5, 5, None) tdSql.checkData(5, 5, None)
self.check_result_auto( "select c1, c2, c3 , c4, c5 from t1", "select (c1), round(c2) ,round(c3), round(c4), round(c5) from t1") self.check_result_auto( f"select c1, c2, c3 , c4, c5 from {dbname}.t1", f"select (c1), round(c2) ,round(c3), round(c4), round(c5) from {dbname}.t1")
# used for sub table # used for sub table
tdSql.query("select round(c1) from ct1") tdSql.query(f"select round(c1) from {dbname}.ct1")
tdSql.checkData(0, 0, 8) tdSql.checkData(0, 0, 8)
tdSql.checkData(1 , 0, 7) tdSql.checkData(1 , 0, 7)
tdSql.checkData(3 , 0, 5) tdSql.checkData(3 , 0, 5)
tdSql.checkData(5 , 0, 4) tdSql.checkData(5 , 0, 4)
tdSql.query("select round(c1) from ct1") tdSql.query(f"select round(c1) from {dbname}.ct1")
self.check_result_auto( "select c1, c2, c3 , c4, c5 from ct1", "select (c1), round(c2) ,round(c3), round(c4), round(c5) from ct1") self.check_result_auto( f"select c1, c2, c3 , c4, c5 from {dbname}.ct1", f"select (c1), round(c2) ,round(c3), round(c4), round(c5) from {dbname}.ct1")
self.check_result_auto("select round(round(round(round(round(round(round(round(round(round(c1)))))))))) nest_col_func from ct1;","select c1 from ct1" ) self.check_result_auto(f"select round(round(round(round(round(round(round(round(round(round(c1)))))))))) nest_col_func from {dbname}.ct1;",f"select c1 from {dbname}.ct1" )
# used for stable table # used for stable table
tdSql.query("select round(c1) from stb1") tdSql.query(f"select round(c1) from {dbname}.stb1")
tdSql.checkRows(25) tdSql.checkRows(25)
self.check_result_auto( "select c1, c2, c3 , c4, c5 from ct4 ", "select (c1), round(c2) ,round(c3), round(c4), round(c5) from ct4") self.check_result_auto( f"select c1, c2, c3 , c4, c5 from {dbname}.ct4 ", f"select (c1), round(c2) ,round(c3), round(c4), round(c5) from {dbname}.ct4")
self.check_result_auto("select round(round(round(round(round(round(round(round(round(round(c1)))))))))) nest_col_func from ct4;" , "select c1 from ct4" ) self.check_result_auto(f"select round(round(round(round(round(round(round(round(round(round(c1)))))))))) nest_col_func from {dbname}.ct4;" , f"select c1 from {dbname}.ct4" )
# used for not exists table # used for not exists table
tdSql.error("select round(c1) from stbbb1") tdSql.error(f"select round(c1) from {dbname}.stbbb1")
tdSql.error("select round(c1) from tbname") tdSql.error(f"select round(c1) from {dbname}.tbname")
tdSql.error("select round(c1) from ct5") tdSql.error(f"select round(c1) from {dbname}.ct5")
# mix with common col # mix with common col
tdSql.query("select c1, round(c1) from ct1") tdSql.query(f"select c1, round(c1) from {dbname}.ct1")
tdSql.checkData(0 , 0 ,8) tdSql.checkData(0 , 0 ,8)
tdSql.checkData(0 , 1 ,8) tdSql.checkData(0 , 1 ,8)
tdSql.checkData(4 , 0 ,0) tdSql.checkData(4 , 0 ,0)
tdSql.checkData(4 , 1 ,0) tdSql.checkData(4 , 1 ,0)
tdSql.query("select c1, round(c1) from ct4") tdSql.query(f"select c1, round(c1) from {dbname}.ct4")
tdSql.checkData(0 , 0 , None) tdSql.checkData(0 , 0 , None)
tdSql.checkData(0 , 1 ,None) tdSql.checkData(0 , 1 ,None)
tdSql.checkData(4 , 0 ,5) tdSql.checkData(4 , 0 ,5)
tdSql.checkData(4 , 1 ,5) tdSql.checkData(4 , 1 ,5)
tdSql.checkData(5 , 0 ,None) tdSql.checkData(5 , 0 ,None)
tdSql.checkData(5 , 1 ,None) tdSql.checkData(5 , 1 ,None)
tdSql.query("select c1, round(c1) from ct4 ") tdSql.query(f"select c1, round(c1) from {dbname}.ct4 ")
tdSql.checkData(0 , 0 ,None) tdSql.checkData(0 , 0 ,None)
tdSql.checkData(0 , 1 ,None) tdSql.checkData(0 , 1 ,None)
tdSql.checkData(4 , 0 ,5) tdSql.checkData(4 , 0 ,5)
tdSql.checkData(4 , 1 ,5) tdSql.checkData(4 , 1 ,5)
# mix with common functions # mix with common functions
tdSql.query("select c1, round(c1),c5, round(c5) from ct4 ") tdSql.query(f"select c1, round(c1),c5, round(c5) from {dbname}.ct4 ")
tdSql.checkData(0 , 0 ,None) tdSql.checkData(0 , 0 ,None)
tdSql.checkData(0 , 1 ,None) tdSql.checkData(0 , 1 ,None)
tdSql.checkData(0 , 2 ,None) tdSql.checkData(0 , 2 ,None)
@ -300,34 +297,34 @@ class TDTestCase:
tdSql.checkData(6 , 2 ,4.44000) tdSql.checkData(6 , 2 ,4.44000)
tdSql.checkData(6 , 3 ,4.00000) tdSql.checkData(6 , 3 ,4.00000)
tdSql.query("select c1, round(c1),c5, round(c5) from stb1 ") tdSql.query(f"select c1, round(c1),c5, round(c5) from {dbname}.stb1 ")
# mix with agg functions , not support # mix with agg functions , not support
tdSql.error("select c1, round(c1),c5, count(c5) from stb1 ") tdSql.error(f"select c1, round(c1),c5, count(c5) from {dbname}.stb1 ")
tdSql.error("select c1, round(c1),c5, count(c5) from ct1 ") tdSql.error(f"select c1, round(c1),c5, count(c5) from {dbname}.ct1 ")
tdSql.error("select round(c1), count(c5) from stb1 ") tdSql.error(f"select round(c1), count(c5) from {dbname}.stb1 ")
tdSql.error("select round(c1), count(c5) from ct1 ") tdSql.error(f"select round(c1), count(c5) from {dbname}.ct1 ")
tdSql.error("select c1, count(c5) from ct1 ") tdSql.error(f"select c1, count(c5) from {dbname}.ct1 ")
tdSql.error("select c1, count(c5) from stb1 ") tdSql.error(f"select c1, count(c5) from {dbname}.stb1 ")
# agg functions mix with agg functions # agg functions mix with agg functions
tdSql.query("select max(c5), count(c5) from stb1") tdSql.query(f"select max(c5), count(c5) from {dbname}.stb1")
tdSql.query("select max(c5), count(c5) from ct1") tdSql.query(f"select max(c5), count(c5) from {dbname}.ct1")
# bug fix for count # bug fix for count
tdSql.query("select count(c1) from ct4 ") tdSql.query(f"select count(c1) from {dbname}.ct4 ")
tdSql.checkData(0,0,9) tdSql.checkData(0,0,9)
tdSql.query("select count(*) from ct4 ") tdSql.query(f"select count(*) from {dbname}.ct4 ")
tdSql.checkData(0,0,12) tdSql.checkData(0,0,12)
tdSql.query("select count(c1) from stb1 ") tdSql.query(f"select count(c1) from {dbname}.stb1 ")
tdSql.checkData(0,0,22) tdSql.checkData(0,0,22)
tdSql.query("select count(*) from stb1 ") tdSql.query(f"select count(*) from {dbname}.stb1 ")
tdSql.checkData(0,0,25) tdSql.checkData(0,0,25)
# bug fix for compute # bug fix for compute
tdSql.query("select c1, abs(c1) -0 ,round(c1)-0 from ct4 ") tdSql.query(f"select c1, abs(c1) -0 ,round(c1)-0 from {dbname}.ct4 ")
tdSql.checkData(0, 0, None) tdSql.checkData(0, 0, None)
tdSql.checkData(0, 1, None) tdSql.checkData(0, 1, None)
tdSql.checkData(0, 2, None) tdSql.checkData(0, 2, None)
@ -335,7 +332,7 @@ class TDTestCase:
tdSql.checkData(1, 1, 8.000000000) tdSql.checkData(1, 1, 8.000000000)
tdSql.checkData(1, 2, 8.000000000) tdSql.checkData(1, 2, 8.000000000)
tdSql.query(" select c1, abs(c1) -0 ,round(c1-0.1)-0.1 from ct4") tdSql.query(f"select c1, abs(c1) -0 ,round(c1-0.1)-0.1 from {dbname}.ct4")
tdSql.checkData(0, 0, None) tdSql.checkData(0, 0, None)
tdSql.checkData(0, 1, None) tdSql.checkData(0, 1, None)
tdSql.checkData(0, 2, None) tdSql.checkData(0, 2, None)
@ -343,9 +340,8 @@ class TDTestCase:
tdSql.checkData(1, 1, 8.000000000) tdSql.checkData(1, 1, 8.000000000)
tdSql.checkData(1, 2, 7.900000000) tdSql.checkData(1, 2, 7.900000000)
def abs_func_filter(self): def abs_func_filter(self, dbname="db"):
tdSql.execute("use db") tdSql.query(f"select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from {dbname}.ct4 where c1>5 ")
tdSql.query("select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from ct4 where c1>5 ")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.checkData(0,0,8) tdSql.checkData(0,0,8)
tdSql.checkData(0,1,8.000000000) tdSql.checkData(0,1,8.000000000)
@ -353,7 +349,7 @@ class TDTestCase:
tdSql.checkData(0,3,7.900000000) tdSql.checkData(0,3,7.900000000)
tdSql.checkData(0,4,3.000000000) tdSql.checkData(0,4,3.000000000)
tdSql.query("select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from ct4 where c1=5 ") tdSql.query(f"select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from {dbname}.ct4 where c1=5 ")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.checkData(0,0,5) tdSql.checkData(0,0,5)
tdSql.checkData(0,1,5.000000000) tdSql.checkData(0,1,5.000000000)
@ -361,7 +357,7 @@ class TDTestCase:
tdSql.checkData(0,3,4.900000000) tdSql.checkData(0,3,4.900000000)
tdSql.checkData(0,4,2.000000000) tdSql.checkData(0,4,2.000000000)
tdSql.query("select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from ct4 where c1=5 ") tdSql.query(f"select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from {dbname}.ct4 where c1=5 ")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.checkData(0,0,5) tdSql.checkData(0,0,5)
tdSql.checkData(0,1,5.000000000) tdSql.checkData(0,1,5.000000000)
@ -369,7 +365,7 @@ class TDTestCase:
tdSql.checkData(0,3,4.900000000) tdSql.checkData(0,3,4.900000000)
tdSql.checkData(0,4,2.000000000) tdSql.checkData(0,4,2.000000000)
tdSql.query("select c1,c2 , abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) , round(abs(c1))-0.5 from ct4 where c1>log(c1,2) limit 1 ") tdSql.query(f"select c1,c2 , abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) , round(abs(c1))-0.5 from {dbname}.ct4 where c1>log(c1,2) limit 1 ")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.checkData(0,0,8) tdSql.checkData(0,0,8)
tdSql.checkData(0,1,88888) tdSql.checkData(0,1,88888)
@ -382,44 +378,42 @@ class TDTestCase:
def round_Arithmetic(self): def round_Arithmetic(self):
pass pass
def check_boundary_values(self): def check_boundary_values(self, dbname="bound_test"):
tdSql.execute("drop database if exists bound_test") tdSql.execute(f"drop database if exists {dbname}")
tdSql.execute("create database if not exists bound_test") tdSql.execute(f"create database if not exists {dbname}")
time.sleep(3)
tdSql.execute("use bound_test")
tdSql.execute( 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);" f"create table {dbname}.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'create table {dbname}.sub1_bound using {dbname}.stb_bound tags ( 1 )')
tdSql.execute( 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() )" f"insert into {dbname}.sub1_bound values ( now()-1s, 2147483647, 9223372036854775807, 32767, 127, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
) )
tdSql.execute( 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() )" f"insert into {dbname}.sub1_bound values ( now(), 2147483646, 9223372036854775806, 32766, 126, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
) )
tdSql.execute( 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() )" f"insert into {dbname}.sub1_bound values ( now(), -2147483646, -9223372036854775806, -32766, -126, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
) )
tdSql.execute( tdSql.execute(
f"insert into sub1_bound values ( now(), 2147483643, 9223372036854775803, 32763, 123, 3.39E+38, 1.69e+308, True, 'binary_tb1', 'nchar_tb1', now() )" f"insert into {dbname}.sub1_bound values ( now(), 2147483643, 9223372036854775803, 32763, 123, 3.39E+38, 1.69e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
) )
tdSql.execute( tdSql.execute(
f"insert into sub1_bound values ( now(), -2147483643, -9223372036854775803, -32763, -123, -3.39E+38, -1.69e+308, True, 'binary_tb1', 'nchar_tb1', now() )" f"insert into {dbname}.sub1_bound values ( now(), -2147483643, -9223372036854775803, -32763, -123, -3.39E+38, -1.69e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
) )
tdSql.error( 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() )" f"insert into {dbname}.sub1_bound values ( now()+1s, 2147483648, 9223372036854775808, 32768, 128, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
) )
self.check_result_auto( "select c1, c2, c3 , c4, c5 ,c6 from sub1_bound ", "select round(c1), round(c2) ,round(c3), round(c4), round(c5) ,round(c6) from sub1_bound") self.check_result_auto( f"select c1, c2, c3 , c4, c5 ,c6 from {dbname}.sub1_bound ", f"select round(c1), round(c2) ,round(c3), round(c4), round(c5) ,round(c6) from {dbname}.sub1_bound")
self.check_result_auto( "select c1, c2, c3 , c3, c2 ,c1 from sub1_bound ", "select round(c1), round(c2) ,round(c3), round(c3), round(c2) ,round(c1) from sub1_bound") self.check_result_auto( f"select c1, c2, c3 , c3, c2 ,c1 from {dbname}.sub1_bound ", f"select round(c1), round(c2) ,round(c3), round(c3), round(c2) ,round(c1) from {dbname}.sub1_bound")
self.check_result_auto("select round(round(round(round(round(round(round(round(round(round(c1)))))))))) nest_col_func from sub1_bound;" , "select round(c1) from sub1_bound" ) self.check_result_auto(f"select round(round(round(round(round(round(round(round(round(round(c1)))))))))) nest_col_func from {dbname}.sub1_bound;" , f"select round(c1) from {dbname}.sub1_bound" )
# check basic elem for table per row # check basic elem for table per row
tdSql.query("select round(c1+0.2) ,round(c2) , round(c3+0.3) , round(c4-0.3), round(c5/2), round(c6/2) from sub1_bound ") tdSql.query(f"select round(c1+0.2) ,round(c2) , round(c3+0.3) , round(c4-0.3), round(c5/2), round(c6/2) from {dbname}.sub1_bound ")
tdSql.checkData(0, 0, 2147483647.000000000) tdSql.checkData(0, 0, 2147483647.000000000)
tdSql.checkData(0, 2, 32767.000000000) tdSql.checkData(0, 2, 32767.000000000)
tdSql.checkData(0, 3, 127.000000000) tdSql.checkData(0, 3, 127.000000000)
@ -430,19 +424,18 @@ class TDTestCase:
tdSql.checkData(4, 3, -123.000000000) tdSql.checkData(4, 3, -123.000000000)
tdSql.checkData(4, 4, -169499995645668991474575059260979281920.000000000) tdSql.checkData(4, 4, -169499995645668991474575059260979281920.000000000)
self.check_result_auto("select c1+1 ,c2 , c3*1 , c4/2, c5/2, c6 from sub1_bound" ,"select round(c1+1) ,round(c2) , round(c3*1) , round(c4/2), round(c5)/2, round(c6) from sub1_bound ") self.check_result_auto(f"select c1+1 ,c2 , c3*1 , c4/2, c5/2, c6 from {dbname}.sub1_bound" ,f"select round(c1+1) ,round(c2) , round(c3*1) , round(c4/2), round(c5)/2, round(c6) from {dbname}.sub1_bound ")
def support_super_table_test(self): def support_super_table_test(self, dbname="db"):
tdSql.execute(" use db ") self.check_result_auto( f"select c5 from {dbname}.stb1 order by ts " , f"select round(c5) from {dbname}.stb1 order by ts" )
self.check_result_auto( " select c5 from stb1 order by ts " , "select round(c5) from stb1 order by ts" ) self.check_result_auto( f"select c5 from {dbname}.stb1 order by tbname " , f"select round(c5) from {dbname}.stb1 order by tbname" )
self.check_result_auto( " select c5 from stb1 order by tbname " , "select round(c5) from stb1 order by tbname" ) self.check_result_auto( f"select c5 from {dbname}.stb1 where c1 > 0 order by tbname " , f"select round(c5) from {dbname}.stb1 where c1 > 0 order by tbname" )
self.check_result_auto( " select c5 from stb1 where c1 > 0 order by tbname " , "select round(c5) from stb1 where c1 > 0 order by tbname" ) self.check_result_auto( f"select c5 from {dbname}.stb1 where c1 > 0 order by tbname " , f"select round(c5) from {dbname}.stb1 where c1 > 0 order by tbname" )
self.check_result_auto( " select c5 from stb1 where c1 > 0 order by tbname " , "select round(c5) from stb1 where c1 > 0 order by tbname" )
self.check_result_auto( " select t1,c5 from stb1 order by ts " , "select round(t1), round(c5) from stb1 order by ts" ) self.check_result_auto( f"select t1,c5 from {dbname}.stb1 order by ts " , f"select round(t1), round(c5) from {dbname}.stb1 order by ts" )
self.check_result_auto( " select t1,c5 from stb1 order by tbname " , "select round(t1) ,round(c5) from stb1 order by tbname" ) self.check_result_auto( f"select t1,c5 from {dbname}.stb1 order by tbname " , f"select round(t1) ,round(c5) from {dbname}.stb1 order by tbname" )
self.check_result_auto( " select t1,c5 from stb1 where c1 > 0 order by tbname " , "select round(t1) ,round(c5) from stb1 where c1 > 0 order by tbname" ) self.check_result_auto( f"select t1,c5 from {dbname}.stb1 where c1 > 0 order by tbname " , f"select round(t1) ,round(c5) from {dbname}.stb1 where c1 > 0 order by tbname" )
self.check_result_auto( " select t1,c5 from stb1 where c1 > 0 order by tbname " , "select round(t1) , round(c5) from stb1 where c1 > 0 order by tbname" ) self.check_result_auto( f"select t1,c5 from {dbname}.stb1 where c1 > 0 order by tbname " , f"select round(t1) , round(c5) from {dbname}.stb1 where c1 > 0 order by tbname" )
pass pass

39
tests/system-test/2-query/rtrim.py
View File

@ -120,16 +120,16 @@ class TDTestCase:
return sqls return sqls
def __test_current(self): # sourcery skip: use-itertools-product def __test_current(self, dbname="db"): # sourcery skip: use-itertools-product
tdLog.printNoPrefix("==========current sql condition check , must return query ok==========") tdLog.printNoPrefix("==========current sql condition check , must return query ok==========")
tbname = ["ct1", "ct2", "ct4", "t1", "stb1"] tbname = [f"{dbname}.ct1", f"{dbname}.ct2", f"{dbname}.ct4", f"{dbname}.t1", f"{dbname}.stb1"]
for tb in tbname: for tb in tbname:
self.__rtrim_check(tb) self.__rtrim_check(tb)
tdLog.printNoPrefix(f"==========current sql condition check in {tb} over==========") tdLog.printNoPrefix(f"==========current sql condition check in {tb} over==========")
def __test_error(self): def __test_error(self, dbname="db"):
tdLog.printNoPrefix("==========err sql condition check , must return error==========") tdLog.printNoPrefix("==========err sql condition check , must return error==========")
tbname = ["ct1", "ct2", "ct4", "t1", "stb1"] tbname = [f"{dbname}.ct1", f"{dbname}.ct2", f"{dbname}.ct4", f"{dbname}.t1", f"{dbname}.stb1"]
for tb in tbname: for tb in tbname:
for errsql in self.__rtrim_err_check(tb): for errsql in self.__rtrim_err_check(tb):
@ -142,17 +142,15 @@ class TDTestCase:
self.__test_error() self.__test_error()
def __create_tb(self): def __create_tb(self, dbname="db"):
tdSql.prepare()
tdLog.printNoPrefix("==========step1:create table") tdLog.printNoPrefix("==========step1:create table")
create_stb_sql = f'''create table stb1( create_stb_sql = f'''create table {dbname}.stb1(
ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint, ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint,
{FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool,
{BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp
) tags (t1 int) ) tags (t1 int)
''' '''
create_ntb_sql = f'''create table t1( create_ntb_sql = f'''create table {dbname}.t1(
ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint, ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint,
{FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool,
{BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp
@ -162,29 +160,29 @@ class TDTestCase:
tdSql.execute(create_ntb_sql) tdSql.execute(create_ntb_sql)
for i in range(4): for i in range(4):
tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )') tdSql.execute(f'create table {dbname}.ct{i+1} using {dbname}.stb1 tags ( {i+1} )')
def __insert_data(self, rows): def __insert_data(self, rows, dbname="db"):
now_time = int(datetime.datetime.timestamp(datetime.datetime.now()) * 1000) now_time = int(datetime.datetime.timestamp(datetime.datetime.now()) * 1000)
for i in range(rows): for i in range(rows):
tdSql.execute( tdSql.execute(
f"insert into ct1 values ( { now_time - i * 1000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" f"insert into {dbname}.ct1 values ( { now_time - i * 1000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )"
) )
tdSql.execute( tdSql.execute(
f"insert into ct4 values ( { now_time - i * 7776000000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" f"insert into {dbname}.ct4 values ( { now_time - i * 7776000000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )"
) )
tdSql.execute( tdSql.execute(
f"insert into ct2 values ( { now_time - i * 7776000000 }, {-i}, {-11111 * i}, {-111 * i % 32767 }, {-11 * i % 127}, {-1.11*i}, {-1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" f"insert into {dbname}.ct2 values ( { now_time - i * 7776000000 }, {-i}, {-11111 * i}, {-111 * i % 32767 }, {-11 * i % 127}, {-1.11*i}, {-1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )"
) )
tdSql.execute( tdSql.execute(
f'''insert into ct1 values f'''insert into {dbname}.ct1 values
( { now_time - rows * 5 }, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar_测试_0', { now_time + 8 } ) ( { now_time - rows * 5 }, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar_测试_0', { now_time + 8 } )
( { now_time + 10000 }, { rows }, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar_测试_9', { now_time + 9 } ) ( { now_time + 10000 }, { rows }, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar_测试_9', { now_time + 9 } )
''' '''
) )
tdSql.execute( tdSql.execute(
f'''insert into ct4 values f'''insert into {dbname}.ct4 values
( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
@ -200,7 +198,7 @@ class TDTestCase:
) )
tdSql.execute( tdSql.execute(
f'''insert into ct2 values f'''insert into {dbname}.ct2 values
( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
@ -216,13 +214,13 @@ class TDTestCase:
) )
for i in range(rows): for i in range(rows):
insert_data = f'''insert into t1 values insert_data = f'''insert into {dbname}.t1 values
( { now_time - i * 3600000 }, {i}, {i * 11111}, { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2}, ( { now_time - i * 3600000 }, {i}, {i * 11111}, { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2},
"binary_{i}", "nchar_测试_{i}", { now_time - 1000 * i } ) "binary_{i}", "nchar_测试_{i}", { now_time - 1000 * i } )
''' '''
tdSql.execute(insert_data) tdSql.execute(insert_data)
tdSql.execute( tdSql.execute(
f'''insert into t1 values f'''insert into {dbname}.t1 values
( { now_time + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ( { now_time + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
( { now_time - (( rows // 2 ) * 60 + 30) * 60000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ( { now_time - (( rows // 2 ) * 60 + 30) * 60000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
( { now_time - rows * 3600000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ( { now_time - rows * 3600000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
@ -251,8 +249,7 @@ class TDTestCase:
tdLog.printNoPrefix("==========step3:all check") tdLog.printNoPrefix("==========step3:all check")
self.all_test() self.all_test()
tdDnodes.stop(1) tdSql.execute("flush database db")
tdDnodes.start(1)
tdSql.execute("use db") tdSql.execute("use db")

323
tests/system-test/2-query/sample.py
View File

@ -11,21 +11,17 @@
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
from pstats import Stats
import sys import sys
import subprocess
import random import random
import math
import numpy as np
import inspect
import re import re
import taos
from util.log import * from util.log import *
from util.cases import * from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
DBNAME = "db"
class TDTestCase: class TDTestCase:
def init(self, conn, logSql): def init(self, conn, logSql):
@ -33,11 +29,11 @@ class TDTestCase:
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
self.ts = 1537146000000 self.ts = 1537146000000
def sample_query_form(self, sel="select", func="sample(", col="c1", m_comm =",", k=1,r_comm=")", alias="", fr="from",table_expr="t1", condition=""): def sample_query_form(self, sel=f"select", func="sample(", col="c1", m_comm =",", k=1,r_comm=")", alias="", fr="from",table_expr="t1", condition=""):
''' '''
sample function: sample function:
:param sel: string, must be "select", required parameters; :param sel: string, must be f"select", required parameters;
:param func: string, in this case must be "sample(", otherwise return other function, required parameters; :param func: string, in this case must be "sample(", otherwise return other function, required parameters;
:param col: string, column name, required parameters; :param col: string, column name, required parameters;
:param m_comm: string, comma between col and k , required parameters; :param m_comm: string, comma between col and k , required parameters;
@ -47,12 +43,12 @@ class TDTestCase:
:param fr: string, must be "from", required parameters; :param fr: string, must be "from", required parameters;
:param table_expr: string or expression, data source（eg,table/stable name, result set）, required parameters; :param table_expr: string or expression, data source（eg,table/stable name, result set）, required parameters;
:param condition: expression； :param condition: expression；
:return: sample query statement,default: select sample(c1, 1) from t1 :return: sample query statement,default: select sample(c1, 1) from {dbname}.t1
''' '''
return f"{sel} {func} {col} {m_comm} {k} {r_comm} {alias} {fr} {table_expr} {condition}" return f"{sel} {func} {col} {m_comm} {k} {r_comm} {alias} {fr} {table_expr} {condition}"
def checksample(self,sel="select", func="sample(", col="c1", m_comm =",", k=1,r_comm=")", alias="", fr="from",table_expr="t1", condition=""): def checksample(self,sel=f"select", func="sample(", col="c1", m_comm =",", k=1,r_comm=")", alias="", fr="from",table_expr=f"{DBNAME}.t1", condition=""):
# print(self.sample_query_form(sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr, # print(self.sample_query_form(sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
# table_expr=table_expr, condition=condition)) # table_expr=table_expr, condition=condition))
line = sys._getframe().f_back.f_lineno line = sys._getframe().f_back.f_lineno
@ -65,7 +61,7 @@ class TDTestCase:
)) ))
sql = "select * from t1" sql = f"select * from {table_expr}"
collist = tdSql.getColNameList(sql) collist = tdSql.getColNameList(sql)
if not isinstance(col, str): if not isinstance(col, str):
@ -125,7 +121,7 @@ class TDTestCase:
# table_expr=table_expr, condition=condition # table_expr=table_expr, condition=condition
# )) # ))
if any( [func != "sample(" , r_comm != ")" , fr != "from", sel != "select"]): if any( [func != "sample(" , r_comm != ")" , fr != "from", sel != f"select"]):
print(f"case in {line}: ", end='') print(f"case in {line}: ", end='')
return tdSql.error(self.sample_query_form( return tdSql.error(self.sample_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr, sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
@ -286,14 +282,14 @@ class TDTestCase:
return return
else: else:
if "where" in condition: # if "where" in condition:
condition = re.sub('where', f"where {col} is not null and ", condition) # condition = re.sub('where', f"where {col} is not null and ", condition)
else: # else:
condition = f"where {col} is not null" + condition # condition = f"where {col} is not null" + condition
print(f"select ts, {col} {alias} from {table_expr} {re.sub('limit [0-9]*|offset [0-9]*','',condition)}") # print(f"select ts, {col} {alias} from {table_expr} {re.sub('limit [0-9]*|offset [0-9]*','',condition)}")
tdSql.query(f"select ts, {col} {alias} from {table_expr} {re.sub('limit [0-9]*|offset [0-9]*','',condition)}") # tdSql.query(f"select _c0, {col} {alias} 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 # offset_val = condition.split("offset")[1].split(" ")[1] if "offset" in condition else 0
pre_sample = tdSql.queryResult # pre_sample = tdSql.queryResult
# pre_len = tdSql.queryRows # pre_len = tdSql.queryRows
# for i in range(sample_len): # for i in range(sample_len):
# if sample_result[pre_row:pre_row + step][i] not in pre_sample: # if sample_result[pre_row:pre_row + step][i] not in pre_sample:
@ -301,7 +297,7 @@ class TDTestCase:
# else: # else:
# tdLog.info(f"case in {line} is success: sample data is in {group_name}") # tdLog.info(f"case in {line} is success: sample data is in {group_name}")
pass pass
def sample_current_query(self) : def sample_current_query(self) :
@ -322,24 +318,24 @@ class TDTestCase:
self.checksample(**case6) self.checksample(**case6)
# # case7~8: nested query # # case7~8: nested query
# case7 = {"table_expr": "(select c1 from stb1)"} case7 = {"table_expr": f"(select c1 from {DBNAME}.stb1)"}
# self.checksample(**case7) self.checksample(**case7)
# case8 = {"table_expr": "(select sample(c1, 1) c1 from stb1 group by tbname)"} case8 = {"table_expr": f"(select sample(c1, 1) c1 from {DBNAME}.stb1 group by tbname)"}
# self.checksample(**case8) self.checksample(**case8)
# case9~10: mix with tbname/ts/tag/col # case9~10: mix with tbname/ts/tag/col
# case9 = {"alias": ", tbname"} case9 = {"alias": ", tbname"}
# self.checksample(**case9) self.checksample(**case9)
# case10 = {"alias": ", _c0"} case10 = {"alias": ", _c0"}
# self.checksample(**case10) self.checksample(**case10)
# case11 = {"alias": ", st1"} case11 = {"alias": ", st1"}
# self.checksample(**case11) # self.checksample(**case11)
tdSql.query("select sample( c1 , 1 ) , st1 from t1") tdSql.query(f"select sample( c1 , 1 ) , st1 from {DBNAME}.t1")
# case12 = {"alias": ", c1"} case12 = {"alias": ", c1"}
# self.checksample(**case12) # self.checksample(**case12)
tdSql.query("select sample( c1 , 1 ) , c1 from t1") tdSql.query(f"select sample( c1 , 1 ) , c1 from {DBNAME}.t1")
# case13~15: with single condition # case13~15: with single condition
case13 = {"condition": "where c1 <= 10"} case13 = {"condition": "where c1 <= 10"}
@ -353,32 +349,31 @@ class TDTestCase:
case16 = {"condition": "where c6=1 or c6 =0"} case16 = {"condition": "where c6=1 or c6 =0"}
self.checksample(**case16) self.checksample(**case16)
# # case17: only support normal table join # case17: only support normal table join
# case17 = { case17 = {
# "col": "t1.c1", "col": "t1.c1",
# "table_expr": "t1, t2", "table_expr": f"{DBNAME}.t1 t1 join {DBNAME}.t2 t2 on t1.ts = t2.ts",
# "condition": "where t1.ts=t2.ts" }
# } self.checksample(**case17)
# self.checksample(**case17) # case18~19: with group by
# # case18~19: with group by case19 = {
# case19 = { "table_expr": f"{DBNAME}.stb1",
# "table_expr": "stb1", "condition": "partition by tbname"
# "condition": "partition by tbname" }
# }
# self.checksample(**case19) # self.checksample(**case19)
# # case20~21: with order by # case20~21: with order by
# case20 = {"condition": "order by ts"} case20 = {"condition": "order by ts"}
# self.checksample(**case20) # self.checksample(**case20)
# case21 = { case21 = {
# "table_expr": "stb1", "table_expr": f"{DBNAME}.stb1",
# "condition": "partition by tbname order by tbname" "condition": "partition by tbname order by tbname"
# } }
# self.checksample(**case21) # self.checksample(**case21)
# case22: with union # case22: with union
case22 = { case22 = {
"condition": "union all select sample( c1 , 1 ) from t2" "condition": f"union all select sample( c1 , 1 ) from {DBNAME}.t2"
} }
self.checksample(**case22) self.checksample(**case22)
@ -396,12 +391,12 @@ class TDTestCase:
case26 = {"k": 1000} case26 = {"k": 1000}
self.checksample(**case26) self.checksample(**case26)
case27 = { case27 = {
"table_expr": "stb1", "table_expr": f"{DBNAME}.stb1",
"condition": "group by tbname slimit 1 " "condition": "group by tbname slimit 1 "
} }
self.checksample(**case27) # with slimit self.checksample(**case27) # with slimit
case28 = { case28 = {
"table_expr": "stb1", "table_expr": f"{DBNAME}.stb1",
"condition": "group by tbname slimit 1 soffset 1" "condition": "group by tbname slimit 1 soffset 1"
} }
self.checksample(**case28) # with soffset self.checksample(**case28) # with soffset
@ -431,7 +426,7 @@ class TDTestCase:
# err9 = {"col": "st1"} # err9 = {"col": "st1"}
# self.checksample(**err9) # col: tag # self.checksample(**err9) # col: tag
tdSql.query(" select sample(st1 ,1) from t1 ") tdSql.query(f"select sample(st1 ,1) from {DBNAME}.t1 ")
# err10 = {"col": 1} # err10 = {"col": 1}
# self.checksample(**err10) # col: value # self.checksample(**err10) # col: value
# err11 = {"col": "NULL"} # err11 = {"col": "NULL"}
@ -494,13 +489,13 @@ class TDTestCase:
self.checksample(**err39) # mix with calculation function 2 self.checksample(**err39) # mix with calculation function 2
# err40 = {"alias": "+ 2"} # err40 = {"alias": "+ 2"}
# self.checksample(**err40) # mix with arithmetic 1 # self.checksample(**err40) # mix with arithmetic 1
# tdSql.query(" select sample(c1 , 1) + 2 from t1 ") # tdSql.query(f"select sample(c1 , 1) + 2 from {dbname}.t1 ")
err41 = {"alias": "+ avg(c1)"} err41 = {"alias": "+ avg(c1)"}
# self.checksample(**err41) # mix with arithmetic 2 # self.checksample(**err41) # mix with arithmetic 2
# err42 = {"alias": ", c1"} # err42 = {"alias": ", c1"}
# self.checksample(**err42) # self.checksample(**err42)
tdSql.query("select sample( c1 , 1 ) , c1 from t1") tdSql.query(f"select sample( c1 , 1 ) , c1 from {DBNAME}.t1")
# mix with other col # mix with other col
# err43 = {"table_expr": "stb1"} # err43 = {"table_expr": "stb1"}
# self.checksample(**err43) # select stb directly # self.checksample(**err43) # select stb directly
@ -510,14 +505,14 @@ class TDTestCase:
# "condition": "where stb1.ts=stb2.ts and stb1.st1=stb2.st2 order by stb1.ts" # "condition": "where stb1.ts=stb2.ts and stb1.st1=stb2.st2 order by stb1.ts"
# } # }
# self.checksample(**err44) # stb join # self.checksample(**err44) # stb join
tdSql.query("select sample( stb1.c1 , 1 ) from stb1, stb2 where stb1.ts=stb2.ts and stb1.st1=stb2.st2 order by stb1.ts") tdSql.query(f"select sample( stb1.c1 , 1 ) from {DBNAME}.stb1 stb1, {DBNAME}.stb2 stb2 where stb1.ts=stb2.ts and stb1.st1=stb2.st2 order by stb1.ts")
# err45 = { # err45 = {
# "condition": "where ts>0 and ts < now interval(1h) fill(next)" # "condition": "where ts>0 and ts < now interval(1h) fill(next)"
# } # }
# self.checksample(**err45) # interval # self.checksample(**err45) # interval
tdSql.error("select sample( c1 , 1 ) from t1 where ts>0 and ts < now interval(1h) fill(next)") tdSql.error(f"select sample( c1 , 1 ) from {DBNAME}.t1 where ts>0 and ts < now interval(1h) fill(next)")
err46 = { err46 = {
"table_expr": "t1", "table_expr": f"{DBNAME}.t1",
"condition": "group by c6" "condition": "group by c6"
} }
# self.checksample(**err46) # group by normal col # self.checksample(**err46) # group by normal col
@ -563,49 +558,45 @@ class TDTestCase:
pass pass
def sample_test_data(self, tbnum:int, data_row:int, basetime:int) -> None : def sample_test_data(self, tbnum:int, data_row:int, basetime:int, dbname="db") -> None :
for i in range(tbnum): for i in range(tbnum):
for j in range(data_row): for j in range(data_row):
tdSql.execute( tdSql.execute(
f"insert into t{i} values (" f"insert into {dbname}.t{i} values ("
f"{basetime + (j+1)*10}, {random.randint(-200, -1)}, {random.uniform(200, -1)}, {basetime + random.randint(-200, -1)}, " 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"'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}' )" f"{random.randint(-200, -1)}, {random.randint(-127, -1)}, 'nchar_{j}' )"
) )
tdSql.execute( tdSql.execute(
f"insert into t{i} values (" f"insert into {dbname}.t{i} values ("
f"{basetime - (j+1) * 10}, {random.randint(1, 200)}, {random.uniform(1, 200)}, {basetime - random.randint(1, 200)}, " 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"'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' )" f"{random.randint(1,200)}, {random.randint(1,127)}, 'nchar_{j}_1' )"
) )
tdSql.execute( tdSql.execute(
f"insert into tt{i} values ( {basetime-(j+1) * 10}, {random.randint(1, 200)} )" f"insert into {dbname}.tt{i} values ( {basetime-(j+1) * 10}, {random.randint(1, 200)} )"
) )
pass pass
def sample_test_table(self,tbnum: int) -> None : def sample_test_table(self,tbnum: int, dbname="db") -> None :
tdSql.execute("drop database if exists db") tdSql.execute(f"drop database if exists {dbname}")
tdSql.execute("create database if not exists db keep 3650") tdSql.execute(f"create database if not exists {dbname} keep 3650")
tdSql.execute("use db")
tdSql.execute( tdSql.execute(
"create stable db.stb1 (\ f"create stable {dbname}.stb1 (\
ts timestamp, c1 int, c2 float, c3 timestamp, c4 binary(16), c5 double, c6 bool, \ ts timestamp, c1 int, c2 float, c3 timestamp, c4 binary(16), c5 double, c6 bool, \
c7 bigint, c8 smallint, c9 tinyint, c10 nchar(16)\ c7 bigint, c8 smallint, c9 tinyint, c10 nchar(16)\
) \ ) \
tags(st1 int)" tags(st1 int)"
) )
tdSql.execute( tdSql.execute(
"create stable db.stb2 (ts timestamp, c1 int) tags(st2 int)" f"create stable {dbname}.stb2 (ts timestamp, c1 int) tags(st2 int)"
) )
for i in range(tbnum): for i in range(tbnum):
tdSql.execute(f"create table t{i} using stb1 tags({i})") tdSql.execute(f"create table {dbname}.t{i} using {dbname}.stb1 tags({i})")
tdSql.execute(f"create table tt{i} using stb2 tags({i})") tdSql.execute(f"create table {dbname}.tt{i} using {dbname}.stb2 tags({i})")
pass
def check_sample(self , sample_query , origin_query ): def check_sample(self , sample_query , origin_query ):
@ -626,45 +617,43 @@ class TDTestCase:
else: else:
tdLog.exit(" sample data is not in datas groups ,failed sql is : %s" % sample_query ) tdLog.exit(" sample data is not in datas groups ,failed sql is : %s" % sample_query )
def basic_sample_query(self, dbname="db"):
def basic_sample_query(self): tdSql.execute(f" drop database if exists {dbname} ")
tdSql.execute(" drop database if exists db ") tdSql.execute(f" create database if not exists {dbname} duration 300d ")
tdSql.execute(" create database if not exists db duration 300d ")
tdSql.execute(" use db ")
tdSql.execute( 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) (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) tags (t1 int)
''' '''
) )
tdSql.execute( tdSql.execute(
''' f'''
create table t1 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) (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): for i in range(4):
tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )') tdSql.execute(f'create table {dbname}.ct{i+1} using {dbname}.stb1 tags ( {i+1} )')
for i in range(9): for i in range(9):
tdSql.execute( 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( 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 )"
) )
tdSql.execute("insert into ct1 values (now()-45s, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar0', now()+8a )") tdSql.execute(f"insert into {dbname}.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(f"insert into {dbname}.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(f"insert into {dbname}.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()+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(f"insert into {dbname}.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(f"insert into {dbname}.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()+90d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
tdSql.execute( 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-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-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 ) ( '2020-12-31 01:01:01.000', 2, 22222, 222, 22, 2.22, 22.22, 0, "binary2", "nchar2", now()+2a )
@ -683,116 +672,116 @@ class TDTestCase:
# basic query for sample # basic query for sample
# params test for all # params test for all
tdSql.error(" select sample(c1,c1) from t1 ") tdSql.error(f"select sample(c1,c1) from {dbname}.t1 ")
tdSql.error(" select sample(c1,now) from t1 ") tdSql.error(f"select sample(c1,now) from {dbname}.t1 ")
tdSql.error(" select sample(c1,tbname) from t1 ") tdSql.error(f"select sample(c1,tbname) from {dbname}.t1 ")
tdSql.error(" select sample(c1,ts) from t1 ") tdSql.error(f"select sample(c1,ts) from {dbname}.t1 ")
tdSql.error(" select sample(c1,false) from t1 ") tdSql.error(f"select sample(c1,false) from {dbname}.t1 ")
tdSql.query(" select sample(123,1) from t1 ") tdSql.query(f"select sample(123,1) from {dbname}.t1 ")
tdSql.query(" select sample(c1,2) from t1 ") tdSql.query(f"select sample(c1,2) from {dbname}.t1 ")
tdSql.checkRows(2) tdSql.checkRows(2)
tdSql.query(" select sample(c1,10) from t1 ") tdSql.query(f"select sample(c1,10) from {dbname}.t1 ")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.query(" select sample(c8,10) from t1 ") tdSql.query(f"select sample(c8,10) from {dbname}.t1 ")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.query(" select sample(c1,999) from t1 ") tdSql.query(f"select sample(c1,999) from {dbname}.t1 ")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.query(" select sample(c1,1000) from t1 ") tdSql.query(f"select sample(c1,1000) from {dbname}.t1 ")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.query(" select sample(c8,1000) from t1 ") tdSql.query(f"select sample(c8,1000) from {dbname}.t1 ")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.error(" select sample(c1,-1) from t1 ") tdSql.error(f"select sample(c1,-1) from {dbname}.t1 ")
# bug need fix # bug need fix
# tdSql.query("select sample(c1 ,2) , 123 from stb1;") # tdSql.query(f"select sample(c1 ,2) , 123 from {dbname}.stb1;")
# all type support # all type support
tdSql.query(" select sample(c1 , 20 ) from ct4 ") tdSql.query(f"select sample(c1 , 20 ) from {dbname}.ct4 ")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.query(" select sample(c2 , 20 ) from ct4 ") tdSql.query(f"select sample(c2 , 20 ) from {dbname}.ct4 ")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.query(" select sample(c3 , 20 ) from ct4 ") tdSql.query(f"select sample(c3 , 20 ) from {dbname}.ct4 ")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.query(" select sample(c4 , 20 ) from ct4 ") tdSql.query(f"select sample(c4 , 20 ) from {dbname}.ct4 ")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.query(" select sample(c5 , 20 ) from ct4 ") tdSql.query(f"select sample(c5 , 20 ) from {dbname}.ct4 ")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.query(" select sample(c6 , 20 ) from ct4 ") tdSql.query(f"select sample(c6 , 20 ) from {dbname}.ct4 ")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.query(" select sample(c7 , 20 ) from ct4 ") tdSql.query(f"select sample(c7 , 20 ) from {dbname}.ct4 ")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.query(" select sample(c8 , 20 ) from ct4 ") tdSql.query(f"select sample(c8 , 20 ) from {dbname}.ct4 ")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.query(" select sample(c9 , 20 ) from ct4 ") tdSql.query(f"select sample(c9 , 20 ) from {dbname}.ct4 ")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.query(" select sample(c10 , 20 ) from ct4 ") tdSql.query(f"select sample(c10 , 20 ) from {dbname}.ct4 ")
tdSql.checkRows(9) tdSql.checkRows(9)
# tdSql.query(" select sample(t1 , 20 ) from ct1 ") # tdSql.query(f"select sample(t1 , 20 ) from {dbname}.ct1 ")
# tdSql.checkRows(13) # tdSql.checkRows(13)
# filter data # filter data
tdSql.query(" select sample(c1, 20 ) from t1 where c1 is null ") tdSql.query(f"select sample(c1, 20 ) from {dbname}.t1 where c1 is null ")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.query(" select sample(c1, 20 ) from t1 where c1 =6 ") tdSql.query(f"select sample(c1, 20 ) from {dbname}.t1 where c1 =6 ")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.query(" select sample(c1, 20 ) from t1 where c1 > 6 ") tdSql.query(f"select sample(c1, 20 ) from {dbname}.t1 where c1 > 6 ")
tdSql.checkRows(3) tdSql.checkRows(3)
self.check_sample("select sample(c1, 20 ) from t1 where c1 > 6" , "select c1 from t1 where c1 > 6") self.check_sample(f"select sample(c1, 20 ) from {dbname}.t1 where c1 > 6" , f"select c1 from {dbname}.t1 where c1 > 6")
tdSql.query(" select sample( c1 , 1 ) from t1 where c1 in (0, 1,2) ") tdSql.query(f"select sample( c1 , 1 ) from {dbname}.t1 where c1 in (0, 1,2) ")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.query("select sample( c1 ,3 ) from t1 where c1 between 1 and 10 ") tdSql.query(f"select sample( c1 ,3 ) from {dbname}.t1 where c1 between 1 and 10 ")
tdSql.checkRows(3) tdSql.checkRows(3)
self.check_sample("select sample( c1 ,3 ) from t1 where c1 between 1 and 10" ,"select c1 from t1 where c1 between 1 and 10") self.check_sample(f"select sample( c1 ,3 ) from {dbname}.t1 where c1 between 1 and 10" ,f"select c1 from {dbname}.t1 where c1 between 1 and 10")
# join # join
tdSql.query("select sample( ct4.c1 , 1 ) from ct1, ct4 where ct4.ts=ct1.ts") tdSql.query(f"select sample( ct4.c1 , 1 ) from {dbname}.ct1 ct1, {dbname}.ct4 ct4 where ct4.ts=ct1.ts")
# partition by tbname # partition by tbname
tdSql.query("select sample(c1,2) from stb1 partition by tbname") tdSql.query(f"select sample(c1,2) from {dbname}.stb1 partition by tbname")
tdSql.checkRows(4) tdSql.checkRows(4)
self.check_sample("select sample(c1,2) from stb1 partition by tbname" , "select c1 from stb1 partition by tbname") self.check_sample(f"select sample(c1,2) from {dbname}.stb1 partition by tbname" , f"select c1 from {dbname}.stb1 partition by tbname")
# nest query # nest query
# tdSql.query("select sample(c1,2) from (select c1 from t1); ") # tdSql.query(f"select sample(c1,2) from (select c1 from {dbname}.t1); ")
# tdSql.checkRows(2) # tdSql.checkRows(2)
# union all # union all
tdSql.query("select sample(c1,2) from t1 union all select sample(c1,3) from t1") tdSql.query(f"select sample(c1,2) from {dbname}.t1 union all select sample(c1,3) from {dbname}.t1")
tdSql.checkRows(5) tdSql.checkRows(5)
# fill interval # fill interval
# not support mix with other function # not support mix with other function
tdSql.error("select top(c1,2) , sample(c1,2) from ct1") tdSql.error(f"select top(c1,2) , sample(c1,2) from {dbname}.ct1")
tdSql.error("select max(c1) , sample(c1,2) from ct1") tdSql.error(f"select max(c1) , sample(c1,2) from {dbname}.ct1")
tdSql.query("select c1 , sample(c1,2) from ct1") tdSql.query(f"select c1 , sample(c1,2) from {dbname}.ct1")
# bug for mix with scalar # bug for mix with scalar
tdSql.query("select 123 , sample(c1,100) from ct1") tdSql.query(f"select 123 , sample(c1,100) from {dbname}.ct1")
tdSql.query("select sample(c1,100)+2 from ct1") tdSql.query(f"select sample(c1,100)+2 from {dbname}.ct1")
tdSql.query("select abs(sample(c1,100)) from ct1") tdSql.query(f"select abs(sample(c1,100)) from {dbname}.ct1")
def sample_test_run(self) : def sample_test_run(self, dbname="db") :
tdLog.printNoPrefix("==========support sample function==========") tdLog.printNoPrefix("==========support sample function==========")
tbnum = 10 tbnum = 10
nowtime = int(round(time.time() * 1000)) nowtime = int(round(time.time() * 1000))
@ -805,28 +794,28 @@ class TDTestCase:
tdLog.printNoPrefix("######## insert only NULL test:") tdLog.printNoPrefix("######## insert only NULL test:")
for i in range(tbnum): for i in range(tbnum):
tdSql.execute(f"insert into t{i}(ts) values ({nowtime - 5})") tdSql.execute(f"insert into {dbname}.t{i}(ts) values ({nowtime - 5})")
tdSql.execute(f"insert into t{i}(ts) values ({nowtime + 5})") tdSql.execute(f"insert into {dbname}.t{i}(ts) values ({nowtime + 5})")
self.sample_current_query() self.sample_current_query()
self.sample_error_query() self.sample_error_query()
tdLog.printNoPrefix("######## insert data in the range near the max(bigint/double):") tdLog.printNoPrefix("######## insert data in the range near the max(bigint/double):")
# self.sample_test_table(tbnum) self.sample_test_table(tbnum)
# tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values " tdSql.execute(f"insert into {dbname}.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})") 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 " tdSql.execute(f"insert into {dbname}.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})") f"({nowtime - (per_table_rows + 2) * 10}, {2**31-1}, {3.4*10**38}, {1.7*10**308}, {2**63-1})")
# self.sample_current_query() self.sample_current_query()
# self.sample_error_query() self.sample_error_query()
tdLog.printNoPrefix("######## insert data in the range near the min(bigint/double):") tdLog.printNoPrefix("######## insert data in the range near the min(bigint/double):")
# self.sample_test_table(tbnum) self.sample_test_table(tbnum)
# tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values " tdSql.execute(f"insert into {dbname}.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})") 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 " tdSql.execute(f"insert into {dbname}.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})") f"({nowtime - (per_table_rows + 2) * 10}, {1-2**31}, {-3.4*10**38}, {-1.7*10**308}, {512-2**63})")
# self.sample_current_query() self.sample_current_query()
# self.sample_error_query() self.sample_error_query()
tdLog.printNoPrefix("######## insert data without NULL data test:") tdLog.printNoPrefix("######## insert data without NULL data test:")
self.sample_test_table(tbnum) self.sample_test_table(tbnum)
@ -837,16 +826,16 @@ class TDTestCase:
tdLog.printNoPrefix("######## insert data mix with NULL test:") tdLog.printNoPrefix("######## insert data mix with NULL test:")
for i in range(tbnum): for i in range(tbnum):
tdSql.execute(f"insert into t{i}(ts) values ({nowtime})") tdSql.execute(f"insert into {dbname}.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 {dbname}.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})") tdSql.execute(f"insert into {dbname}.t{i}(ts) values ({nowtime+(per_table_rows+3)*10})")
self.sample_current_query() self.sample_current_query()
self.sample_error_query() self.sample_error_query()
tdLog.printNoPrefix("######## check after WAL test:") tdLog.printNoPrefix("######## check after WAL test:")
tdSql.query("select * from information_schema.ins_dnodes") tdSql.query(f"select * from information_schema.ins_dnodes")
index = tdSql.getData(0, 0) index = tdSql.getData(0, 0)
tdDnodes.stop(index) tdDnodes.stop(index)
tdDnodes.start(index) tdDnodes.start(index)
@ -855,25 +844,25 @@ class TDTestCase:
self.basic_sample_query() self.basic_sample_query()
def sample_big_data(self): def sample_big_data(self, dbname="sample_db"):
tdSql.execute("create database sample_db") tdSql.execute(f"create database {dbname}")
tdSql.execute("use sample_db") tdSql.execute("use sample_db")
tdSql.execute("create stable st (ts timestamp ,c1 int ) tags(ind int)" ) tdSql.execute(f"create stable {dbname}.st (ts timestamp ,c1 int ) tags(ind int)" )
tdSql.execute("create table sub_tb using st tags(1)") tdSql.execute(f"create table {dbname}.sub_tb using {dbname}.st tags(1)")
for i in range(2000): for i in range(2000):
ts = self.ts+i*10 ts = self.ts+i*10
tdSql.execute(f"insert into sub_tb values({ts} ,{i})") tdSql.execute(f"insert into {dbname}.sub_tb values({ts} ,{i})")
tdSql.query("select count(*) from st") tdSql.query(f"select count(*) from {dbname}.st")
tdSql.checkData(0,0,2000) tdSql.checkData(0,0,2000)
tdSql.query("select sample(c1 ,1000) from st") tdSql.query(f"select sample(c1 ,1000) from {dbname}.st")
tdSql.checkRows(1000) tdSql.checkRows(1000)
# bug need fix # bug need fix
tdSql.query("select c1 ,t1, sample(c1,2) from db.stb1 partition by c1 ") tdSql.query(f"select c1 ,t1, sample(c1,2) from db.stb1 partition by c1 ")
tdSql.query("select sample(c1,2) from db.stb1 partition by c1 ") tdSql.query(f"select sample(c1,2) from db.stb1 partition by c1 ")
# tdSql.query("select c1 ,ind, sample(c1,2) from sample_db.st partition by c1 ") # tdSql.query(f"select c1 ,ind, sample(c1,2) from {dbname}.sample_db.st partition by c1 ")
def run(self): def run(self):
import traceback import traceback

12
tests/system-test/fulltest.sh
View File

@ -138,6 +138,14 @@ python3 ./test.py -f 2-query/percentile.py
python3 ./test.py -f 2-query/percentile.py -R python3 ./test.py -f 2-query/percentile.py -R
python3 ./test.py -f 2-query/pow.py python3 ./test.py -f 2-query/pow.py
python3 ./test.py -f 2-query/pow.py -R python3 ./test.py -f 2-query/pow.py -R
python3 ./test.py -f 2-query/query_cols_tags_and_or.py
python3 ./test.py -f 2-query/query_cols_tags_and_or.py -R
python3 ./test.py -f 2-query/round.py
python3 ./test.py -f 2-query/round.py -R
python3 ./test.py -f 2-query/rtrim.py
# python3 ./test.py -f 2-query/rtrim.py -R
python3 ./test.py -f 2-query/sample.py
python3 ./test.py -f 2-query/sample.py -R
python3 ./test.py -f 1-insert/update_data.py python3 ./test.py -f 1-insert/update_data.py
@ -145,7 +153,6 @@ python3 ./test.py -f 1-insert/update_data.py
python3 ./test.py -f 1-insert/delete_data.py python3 ./test.py -f 1-insert/delete_data.py
python3 ./test.py -f 2-query/varchar.py python3 ./test.py -f 2-query/varchar.py
python3 ./test.py -f 2-query/rtrim.py
python3 ./test.py -f 2-query/upper.py python3 ./test.py -f 2-query/upper.py
python3 ./test.py -f 2-query/lower.py python3 ./test.py -f 2-query/lower.py
python3 ./test.py -f 2-query/join2.py python3 ./test.py -f 2-query/join2.py
@ -165,12 +172,10 @@ python3 ./test.py -f 2-query/Timediff.py
python3 ./test.py -f 2-query/json_tag.py python3 ./test.py -f 2-query/json_tag.py
python3 ./test.py -f 2-query/top.py python3 ./test.py -f 2-query/top.py
python3 ./test.py -f 2-query/round.py
python3 ./test.py -f 2-query/log.py python3 ./test.py -f 2-query/log.py
python3 ./test.py -f 2-query/sqrt.py python3 ./test.py -f 2-query/sqrt.py
python3 ./test.py -f 2-query/sin.py python3 ./test.py -f 2-query/sin.py
python3 ./test.py -f 2-query/tan.py python3 ./test.py -f 2-query/tan.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.py
# TD-15983 subquery output duplicate name column. # TD-15983 subquery output duplicate name column.
# Please Xiangyang Guo modify the following script # Please Xiangyang Guo modify the following script
@ -179,7 +184,6 @@ python3 ./test.py -f 2-query/query_cols_tags_and_or.py
python3 ./test.py -f 2-query/elapsed.py python3 ./test.py -f 2-query/elapsed.py
python3 ./test.py -f 2-query/csum.py python3 ./test.py -f 2-query/csum.py
#python3 ./test.py -f 2-query/mavg.py #python3 ./test.py -f 2-query/mavg.py
python3 ./test.py -f 2-query/sample.py
python3 ./test.py -f 2-query/function_diff.py python3 ./test.py -f 2-query/function_diff.py
python3 ./test.py -f 2-query/unique.py python3 ./test.py -f 2-query/unique.py
python3 ./test.py -f 2-query/stateduration.py python3 ./test.py -f 2-query/stateduration.py