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

Merge pull request #17630 from taosdata/test/jcy 

test:update test case for TD-19816
This commit is contained in:
Hui Li 2022-10-26 16:43:38 +08:00 committed by GitHub
parent a27335c786 bee030cda7
commit 212c782531
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 255 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
tests/system-test/0-others/show.py
View File

@ -15,28 +15,30 @@
from util.log import *
from util.cases import *
from util.sql import *
import subprocess
from util.common import *
from util.sqlset import *
class TDTestCase:
def init(self, conn, logSql):
tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor())
self.dbname = 'db'
self.setsql = TDSetSql()
self.ins_param_list = ['dnodes','mnodes','qnodes','cluster','functions','users','grants','topics','subscriptions','streams']
self.perf_param = ['apps','connections','consumers','queries','transactions']
self.perf_param_list = ['apps','connections','consumers','queries','trans']
def ins_check(self):
tdSql.prepare()
for param in self.ins_param_list:
tdSql.query(f'show {param}')
show_result = tdSql.queryResult
tdSql.query(f'select * from information_schema.ins_{param}')
select_result = tdSql.queryResult
tdSql.checkEqual(show_result,select_result)
tdSql.execute('drop database db')
def perf_check(self):
tdSql.prepare()
for param in range(len(self.perf_param_list)):
tdSql.query(f'show {self.perf_param[param]}')
if len(tdSql.queryResult) != 0:
@ -46,11 +48,74 @@ class TDTestCase:
tdSql.checkEqual(show_result,select_result)
else :
continue
def run(self):
tdSql.execute('drop database db')
def set_stb_sql(self,stbname,column_dict,tag_dict):
column_sql = ''
tag_sql = ''
for k,v in column_dict.items():
column_sql += f"{k} {v}, "
for k,v in tag_dict.items():
tag_sql += f"{k} {v}, "
create_stb_sql = f'create stable {stbname} ({column_sql[:-2]}) tags ({tag_sql[:-2]})'
return create_stb_sql
def show_sql(self):
tdSql.prepare()
tdSql.execute('use db')
stbname = f'`{tdCom.getLongName(5)}`'
tbname = f'`{tdCom.getLongName(3)}`'
column_dict = {
'`ts`': 'timestamp',
'`col1`': 'tinyint',
'`col2`': 'smallint',
'`col3`': 'int',
'`col4`': 'bigint',
'`col5`': 'tinyint unsigned',
'`col6`': 'smallint unsigned',
'`col7`': 'int unsigned',
'`col8`': 'bigint unsigned',
'`col9`': 'float',
'`col10`': 'double',
'`col11`': 'bool',
'`col12`': 'varchar(20)',
'`col13`': 'nchar(20)'
}
tag_dict = {
'`t1`': 'tinyint',
'`t2`': 'smallint',
'`t3`': 'int',
'`t4`': 'bigint',
'`t5`': 'tinyint unsigned',
'`t6`': 'smallint unsigned',
'`t7`': 'int unsigned',
'`t8`': 'bigint unsigned',
'`t9`': 'float',
'`t10`': 'double',
'`t11`': 'bool',
'`t12`': 'varchar(20)',
'`t13`': 'nchar(20)',
'`t14`': 'timestamp'
}
create_table_sql = self.set_stb_sql(stbname,column_dict,tag_dict)
tdSql.execute(create_table_sql)
tdSql.query(f'show create table {stbname}')
query_result = tdSql.queryResult
tdSql.checkEqual(query_result[0][1].lower(),create_table_sql)
tdSql.execute(f'create table {tbname} using {stbname} tags(1,1,1,1,1,1,1,1,1.000000e+00,1.000000e+00,true,"abc","abc123",0)')
tag_sql = '('
for tag_keys in tag_dict.keys():
tag_sql += f'{tag_keys}, '
tags = f'{tag_sql[:-2]})'
sql = f'create table {tbname} using {stbname} {tags} tags (1, 1, 1, 1, 1, 1, 1, 1, 1.000000e+00, 1.000000e+00, true, "abc", "abc123", 0)'
tdSql.query(f'show create table {tbname}')
query_result = tdSql.queryResult
tdSql.checkEqual(query_result[0][1].lower(),sql)
tdSql.execute('drop database db')
def run(self):
self.ins_check()
self.perf_check()
self.show_sql()
def stop(self):
tdSql.close()
@ -58,3 +123,4 @@ class TDTestCase:
tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase())

81
tests/system-test/2-query/Timediff.py
View File

@ -16,6 +16,7 @@ class TDTestCase:
'2020-5-1 00:00:00.001002001'
]
self.rest_tag = str(conn).lower().split('.')[0].replace("<taos","")
self.db_param_precision = ['ms','us','ns']
self.time_unit = ['1w','1d','1h','1m','1s','1a','1u','1b']
self.error_unit = ['2w','2d','2h','2m','2s','2a','2u','1c','#1']
@ -101,33 +102,34 @@ class TDTestCase:
for i in range(len(self.ts_str)):
tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i])-self.subtractor*1000000)))
elif precision.lower() == 'ns':
self.check_tb_type(unit,tb_type)
tdSql.checkRows(len(self.ts_str))
if unit.lower() == '1w':
if self.rest_tag != 'rest':
self.check_tb_type(unit,tb_type)
tdSql.checkRows(len(self.ts_str))
if unit.lower() == '1w':
for i in range(len(self.ts_str)):
tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000000)-self.subtractor)/60/60/24/7))
elif unit.lower() == '1d':
for i in range(len(self.ts_str)):
tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000000)-self.subtractor)/60/60/24))
elif unit.lower() == '1h':
for i in range(len(self.ts_str)):
tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000000)-self.subtractor)/60/60))
elif unit.lower() == '1m':
for i in range(len(self.ts_str)):
tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000000)-self.subtractor)/60))
elif unit.lower() == '1s':
for i in range(len(self.ts_str)):
tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000000)-self.subtractor)))
elif unit.lower() == '1a':
for i in range(len(self.ts_str)):
tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000)-self.subtractor*1000)))
elif unit.lower() == '1u':
for i in range(len(self.ts_str)):
tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000)-self.subtractor*1000000)))
self.check_tbtype(tb_type)
tdSql.checkRows(len(self.ts_str))
for i in range(len(self.ts_str)):
tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000000)-self.subtractor)/60/60/24/7))
elif unit.lower() == '1d':
for i in range(len(self.ts_str)):
tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000000)-self.subtractor)/60/60/24))
elif unit.lower() == '1h':
for i in range(len(self.ts_str)):
tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000000)-self.subtractor)/60/60))
elif unit.lower() == '1m':
for i in range(len(self.ts_str)):
tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000000)-self.subtractor)/60))
elif unit.lower() == '1s':
for i in range(len(self.ts_str)):
tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000000)-self.subtractor)))
elif unit.lower() == '1a':
for i in range(len(self.ts_str)):
tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000000)-self.subtractor*1000)))
elif unit.lower() == '1u':
for i in range(len(self.ts_str)):
tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i]/1000)-self.subtractor*1000000)))
self.check_tbtype(tb_type)
tdSql.checkRows(len(self.ts_str))
for i in range(len(self.ts_str)):
tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i])-self.subtractor*1000000000)))
tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i])-self.subtractor*1000000000)))
for unit in self.error_unit:
if tb_type.lower() == 'ntb':
tdSql.error(f'select timediff(ts,{self.subtractor},{unit}) from {self.ntbname}')
@ -162,10 +164,35 @@ class TDTestCase:
date_time = self.get_time.time_transform(self.ts_str,precision)
self.data_check(date_time,precision,'ctb')
self.data_check(date_time,precision,'stb')
def run(self): # sourcery skip: extract-duplicate-method
def function_without_param(self):
for precision in self.db_param_precision:
tdSql.execute(f'drop database if exists {self.dbname}')
tdSql.execute(f'create database {self.dbname} precision "{precision}"')
tdSql.execute(f'use {self.dbname}')
tdSql.execute(f'create table {self.stbname} (ts timestamp,c0 int) tags(t0 int)')
tdSql.execute(f'create table {self.ctbname} using {self.stbname} tags(1)')
for ts in self.ts_str:
tdSql.execute(f'insert into {self.ctbname} values("{ts}",1)')
date_time = self.get_time.time_transform(self.ts_str,precision)
tdSql.query(f'select timediff(ts,{self.subtractor}) from {self.ctbname}')
if precision.lower() == 'ms':
for i in range(len(self.ts_str)):
tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i])-self.subtractor*1000)))
elif precision.lower() == 'us':
for i in range(len(self.ts_str)):
tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i])-self.subtractor*1000000)))
elif precision.lower() == 'ns':
for i in range(len(self.ts_str)):
tdSql.checkEqual(tdSql.queryResult[i][0],int(((date_time[i])-self.subtractor*1000000000)))
def run(self): # sourcery skip: extract-duplicate-method
self.function_check_ntb()
self.function_check_stb()
self.function_without_param()
def stop(self):
tdSql.close()

53
tests/system-test/2-query/avg.py
View File

@ -1,12 +1,11 @@
import taos
import sys
import datetime
import inspect
import numpy as np
from util.log import *
from util.sql import *
from util.cases import *
from util.sqlset import TDSetSql
from util.common import *
class TDTestCase:
# updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 ,
# "jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
@ -14,6 +13,51 @@ class TDTestCase:
def init(self, conn, logSql):
tdLog.debug(f"start to excute {__file__}")
tdSql.init(conn.cursor(), False)
self.setsql = TDSetSql()
self.column_dict = {
'ts':'timestamp',
'col1': 'tinyint',
'col2': 'smallint',
'col3': 'int',
'col4': 'bigint',
'col5': 'tinyint unsigned',
'col6': 'smallint unsigned',
'col7': 'int unsigned',
'col8': 'bigint unsigned',
}
self.dbname = tdCom.getLongName(3,"letters")
self.row_num = 10
self.ts = 1537146000000
def insert_data(self,column_dict,tbname,row_num):
insert_sql = self.setsql.set_insertsql(column_dict,tbname)
for i in range(row_num):
insert_list = []
self.setsql.insert_values(column_dict,i,insert_sql,insert_list,self.ts)
def avg_check_unsigned(self):
stbname = f'{self.dbname}.{tdCom.getLongName(5,"letters")}'
tag_dict = {
't0':'int'
}
tag_values = [
f'1'
]
tdSql.execute(f"create database if not exists {self.dbname}")
tdSql.execute(self.setsql.set_create_stable_sql(stbname,self.column_dict,tag_dict))
tdSql.execute(f"create table {stbname}_1 using {stbname} tags({tag_values[0]})")
self.insert_data(self.column_dict,f'{stbname}_1',self.row_num)
for col in self.column_dict.keys():
col_val_list = []
if col.lower() != 'ts':
tdSql.query(f'select {col} from {stbname}_1')
sum_val = 0
for col_val in tdSql.queryResult:
col_val_list.append(col_val[0])
col_avg = np.mean(col_val_list)
tdSql.query(f'select avg({col}) from {stbname}_1')
tdSql.checkEqual(col_avg,tdSql.queryResult[0][0])
tdSql.execute(f'drop database {self.dbname}')
def prepare_datas(self, dbname="db"):
tdSql.execute(
@ -412,6 +456,7 @@ class TDTestCase:
tdLog.printNoPrefix("==========step6: avg filter query ============")
self.avg_func_filter()
self.avg_check_unsigned()
def stop(self):
tdSql.close()

79
tests/system-test/2-query/stddev.py Normal file
View File

@ -0,0 +1,79 @@
###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved.
#
# This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao
#
###################################################################
# -*- coding: utf-8 -*-
import random
import string
import numpy as np
from util.log import *
from util.cases import *
from util.sql import *
from util.common import *
from util.sqlset import *
class TDTestCase:
def init(self, conn, logSql):
tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor())
self.dbname = 'db_test'
self.setsql = TDSetSql()
self.ntbname = f'{self.dbname}.ntb'
self.row_num = 10
self.ts = 1537146000000
self.column_dict = {
'ts':'timestamp',
'col1': 'tinyint',
'col2': 'smallint',
'col3': 'int',
'col4': 'bigint',
'col5': 'tinyint unsigned',
'col6': 'smallint unsigned',
'col7': 'int unsigned',
'col8': 'bigint unsigned',
}
def insert_data(self,column_dict,tbname,row_num):
insert_sql = self.setsql.set_insertsql(column_dict,tbname)
for i in range(row_num):
insert_list = []
self.setsql.insert_values(column_dict,i,insert_sql,insert_list,self.ts)
def stddev_check(self):
stbname = f'{self.dbname}.{tdCom.getLongName(5,"letters")}'
tag_dict = {
't0':'int'
}
tag_values = [
f'1'
]
tdSql.execute(f"create database if not exists {self.dbname}")
tdSql.execute(self.setsql.set_create_stable_sql(stbname,self.column_dict,tag_dict))
tdSql.execute(f"create table {stbname}_1 using {stbname} tags({tag_values[0]})")
self.insert_data(self.column_dict,f'{stbname}_1',self.row_num)
for col in self.column_dict.keys():
col_val_list = []
if col.lower() != 'ts':
tdSql.query(f'select {col} from {stbname}_1')
for col_val in tdSql.queryResult:
col_val_list.append(col_val[0])
col_std = np.std(col_val_list)
tdSql.query(f'select stddev({col}) from {stbname}_1')
tdSql.checkEqual(col_std,tdSql.queryResult[0][0])
tdSql.execute(f'drop database {self.dbname}')
def run(self):
self.stddev_check()
def stop(self):
tdSql.close()
tdLog.success(f"{__file__} successfully executed")
tdCases.addLinux(__file__, TDTestCase())
tdCases.addWindows(__file__, TDTestCase())

3
tests/system-test/2-query/timetruncate.py
View File

@ -180,7 +180,8 @@ class TDTestCase:
date_time = self.get_time.time_transform(self.ts_str,precision)
self.data_check(date_time,precision,'ctb')
self.data_check(date_time,precision,'stb')
def run(self):
self.function_check_ntb()
self.function_check_stb()