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

Merge pull request #7874 from taosdata/test/td-6515-2 

[TD-6515]<test>: add 45 testcases for OpenTSDB telnet style data import
This commit is contained in:
Hui Li 2021-09-13 19:53:28 +08:00 committed by GitHub
parent 1f0b6a6c3d d4b7655b97
commit d86c5910ec
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 297 additions and 241 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

538
tests/pytest/insert/openTsdbTelnetLinesInsert.py
View File

@ -13,7 +13,6 @@
import traceback import traceback
import random import random
import string
from taos.error import LinesError from taos.error import LinesError
import time import time
from copy import deepcopy from copy import deepcopy
@ -24,7 +23,6 @@ from util.sql import *
from util.common import tdCom from util.common import tdCom
import threading import threading
class TDTestCase: class TDTestCase:
def init(self, conn, logSql): def init(self, conn, logSql):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
@ -191,7 +189,8 @@ class TDTestCase:
t4="9223372036854775807i64", t5="11.12345f32", t6="22.123456789f64", t7="\"binaryTagValue\"", t4="9223372036854775807i64", t5="11.12345f32", t6="22.123456789f64", t7="\"binaryTagValue\"",
t8="L\"ncharTagValue\"", ts="1626006833639000000ns", t8="L\"ncharTagValue\"", ts="1626006833639000000ns",
id_noexist_tag=None, id_change_tag=None, id_upper_tag=None, id_double_tag=None, id_noexist_tag=None, id_change_tag=None, id_upper_tag=None, id_double_tag=None,
t_add_tag=None, t_mul_tag=None, t_multi_tag=None, t_blank_tag=None): t_add_tag=None, t_mul_tag=None, t_multi_tag=None, c_blank_tag=None, t_blank_tag=None,
chinese_tag=None, multi_field_tag=None):
if stb_name == "": if stb_name == "":
stb_name = tdCom.getLongName(len=6, mode="letters") stb_name = tdCom.getLongName(len=6, mode="letters")
if tb_name == "": if tb_name == "":
@ -221,8 +220,14 @@ class TDTestCase:
sql_seq = f'{stb_name} {ts} {value} t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6}' sql_seq = f'{stb_name} {ts} {value} t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6}'
if t_multi_tag is not None: if t_multi_tag is not None:
sql_seq = f'{stb_name} {ts} {value},{value} {id}=\"{tb_name}\",t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6}' sql_seq = f'{stb_name} {ts} {value},{value} {id}=\"{tb_name}\",t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6}'
if t_blank_tag is not None: if c_blank_tag is not None:
sql_seq = f'{stb_name} {ts} {id}=\"{tb_name}\",t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8}' sql_seq = f'{stb_name} {ts} {id}=\"{tb_name}\",t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8}'
if t_blank_tag is not None:
sql_seq = f'{stb_name} {ts} {value} {id}=\"{tb_name}\"'
if chinese_tag is not None:
sql_seq = f'{stb_name} {ts} L"涛思数据" t0={t0},t1=L"涛思数据"'
if multi_field_tag is not None:
sql_seq = f'{stb_name} {ts} {value} {id}=\"{tb_name}\",t0={t0} t1={t1}'
return sql_seq, stb_name return sql_seq, stb_name
def genMulTagColStr(self, genType, count=1): def genMulTagColStr(self, genType, count=1):
@ -259,8 +264,6 @@ class TDTestCase:
def resHandle(self, query_sql, query_tag): def resHandle(self, query_sql, query_tag):
tdSql.execute('reset query cache') tdSql.execute('reset query cache')
row_info = tdSql.query(query_sql, query_tag) row_info = tdSql.query(query_sql, query_tag)
print(query_sql)
print(row_info)
col_info = tdSql.getColNameList(query_sql, query_tag) col_info = tdSql.getColNameList(query_sql, query_tag)
res_row_list = [] res_row_list = []
sub_list = [] sub_list = []
@ -277,22 +280,6 @@ class TDTestCase:
self._conn.insert_telnet_lines([input_sql]) self._conn.insert_telnet_lines([input_sql])
query_sql = f"{query_sql} {stb_name} {condition}" query_sql = f"{query_sql} {stb_name} {condition}"
res_row_list, res_field_list_without_ts, res_type_list = self.resHandle(query_sql, True) res_row_list, res_field_list_without_ts, res_type_list = self.resHandle(query_sql, True)
res = tdSql.query(f'select * from {stb_name}', True)
print(res)
res = tdSql.query(f'select * from {stb_name}', True)
print(res)
time.sleep(2)
res = tdSql.query(f'select * from {stb_name}', True)
print(res)
time.sleep(2)
res = tdSql.query(f'select * from {stb_name}', True)
print(res)
time.sleep(2)
res = tdSql.query(f'select * from {stb_name}', True)
print(res)
if ts == 0: if ts == 0:
res_ts = self.dateToTs(res_row_list[0][0]) res_ts = self.dateToTs(res_row_list[0][0])
current_time = time.time() current_time = time.time()
@ -535,8 +522,8 @@ class TDTestCase:
input_sql, stb_name = self.genFullTypeSql(t6=t6) input_sql, stb_name = self.genFullTypeSql(t6=t6)
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
# * limit set to 1.797693134862316*(10**308) # * limit set to 1.797693134862316*(10**308)
for c6 in [f'{-1.797693134862316*(10**308)}f64', f'{-1.797693134862316*(10**308)}f64']: for t6 in [f'{-1.797693134862316*(10**308)}f64', f'{-1.797693134862316*(10**308)}f64']:
input_sql = self.genFullTypeSql(c6=c6)[0] input_sql = self.genFullTypeSql(t6=t6)[0]
try: try:
self._conn.insert_telnet_lines([input_sql]) self._conn.insert_telnet_lines([input_sql])
raise Exception("should not reach here") raise Exception("should not reach here")
@ -574,23 +561,25 @@ class TDTestCase:
""" """
tdCom.cleanTb() tdCom.cleanTb()
# i8 # i8
for c1 in ["-127i8", "127i8"]: for value in ["-127i8", "127i8"]:
input_sql, stb_name = self.genFullTypeSql(c1=c1) input_sql, stb_name = self.genFullTypeSql(value=value)
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
tdCom.cleanTb()
for c1 in ["-128i8", "128i8"]: for value in ["-128i8", "128i8"]:
input_sql = self.genFullTypeSql(c1=c1)[0] input_sql = self.genFullTypeSql(value=value)[0]
try: try:
self._conn.insert_telnet_lines([input_sql]) self._conn.insert_telnet_lines([input_sql])
raise Exception("should not reach here") raise Exception("should not reach here")
except LinesError as err: except LinesError as err:
tdSql.checkNotEqual(err.errno, 0) tdSql.checkNotEqual(err.errno, 0)
# i16 # i16
for c2 in ["-32767i16"]: tdCom.cleanTb()
input_sql, stb_name = self.genFullTypeSql(c2=c2) for value in ["-32767i16"]:
input_sql, stb_name = self.genFullTypeSql(value=value)
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
for c2 in ["-32768i16", "32768i16"]: tdCom.cleanTb()
input_sql = self.genFullTypeSql(c2=c2)[0] for value in ["-32768i16", "32768i16"]:
input_sql = self.genFullTypeSql(value=value)[0]
try: try:
self._conn.insert_telnet_lines([input_sql]) self._conn.insert_telnet_lines([input_sql])
raise Exception("should not reach here") raise Exception("should not reach here")
@ -598,11 +587,13 @@ class TDTestCase:
tdSql.checkNotEqual(err.errno, 0) tdSql.checkNotEqual(err.errno, 0)
# i32 # i32
for c3 in ["-2147483647i32"]: tdCom.cleanTb()
input_sql, stb_name = self.genFullTypeSql(c3=c3) for value in ["-2147483647i32"]:
input_sql, stb_name = self.genFullTypeSql(value=value)
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
for c3 in ["-2147483648i32", "2147483648i32"]: tdCom.cleanTb()
input_sql = self.genFullTypeSql(c3=c3)[0] for value in ["-2147483648i32", "2147483648i32"]:
input_sql = self.genFullTypeSql(value=value)[0]
try: try:
self._conn.insert_telnet_lines([input_sql]) self._conn.insert_telnet_lines([input_sql])
raise Exception("should not reach here") raise Exception("should not reach here")
@ -610,11 +601,13 @@ class TDTestCase:
tdSql.checkNotEqual(err.errno, 0) tdSql.checkNotEqual(err.errno, 0)
# i64 # i64
for c4 in ["-9223372036854775807i64"]: tdCom.cleanTb()
input_sql, stb_name = self.genFullTypeSql(c4=c4) for value in ["-9223372036854775807i64"]:
input_sql, stb_name = self.genFullTypeSql(value=value)
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
for c4 in ["-9223372036854775808i64", "9223372036854775808i64"]: tdCom.cleanTb()
input_sql = self.genFullTypeSql(c4=c4)[0] for value in ["-9223372036854775808i64", "9223372036854775808i64"]:
input_sql = self.genFullTypeSql(value=value)[0]
try: try:
self._conn.insert_telnet_lines([input_sql]) self._conn.insert_telnet_lines([input_sql])
raise Exception("should not reach here") raise Exception("should not reach here")
@ -622,12 +615,14 @@ class TDTestCase:
tdSql.checkNotEqual(err.errno, 0) tdSql.checkNotEqual(err.errno, 0)
# f32 # f32
for c5 in [f"{-3.4028234663852885981170418348451692544*(10**38)}f32", f"{3.4028234663852885981170418348451692544*(10**38)}f32"]: tdCom.cleanTb()
input_sql, stb_name = self.genFullTypeSql(c5=c5) for value in [f"{-3.4028234663852885981170418348451692544*(10**38)}f32", f"{3.4028234663852885981170418348451692544*(10**38)}f32"]:
input_sql, stb_name = self.genFullTypeSql(value=value)
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
# * limit set to 4028234664*(10**38) # * limit set to 4028234664*(10**38)
for c5 in [f"{-3.4028234664*(10**38)}f32", f"{3.4028234664*(10**38)}f32"]: tdCom.cleanTb()
input_sql = self.genFullTypeSql(c5=c5)[0] for value in [f"{-3.4028234664*(10**38)}f32", f"{3.4028234664*(10**38)}f32"]:
input_sql = self.genFullTypeSql(value=value)[0]
try: try:
self._conn.insert_telnet_lines([input_sql]) self._conn.insert_telnet_lines([input_sql])
raise Exception("should not reach here") raise Exception("should not reach here")
@ -635,12 +630,14 @@ class TDTestCase:
tdSql.checkNotEqual(err.errno, 0) tdSql.checkNotEqual(err.errno, 0)
# f64 # f64
for c6 in [f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64', f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64']: tdCom.cleanTb()
input_sql, stb_name = self.genFullTypeSql(c6=c6) for value in [f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64', f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64']:
input_sql, stb_name = self.genFullTypeSql(value=value)
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
# * limit set to 1.797693134862316*(10**308) # * limit set to 1.797693134862316*(10**308)
for c6 in [f'{-1.797693134862316*(10**308)}f64', f'{-1.797693134862316*(10**308)}f64']: tdCom.cleanTb()
input_sql = self.genFullTypeSql(c6=c6)[0] for value in [f'{-1.797693134862316*(10**308)}f64', f'{-1.797693134862316*(10**308)}f64']:
input_sql = self.genFullTypeSql(value=value)[0]
try: try:
self._conn.insert_telnet_lines([input_sql]) self._conn.insert_telnet_lines([input_sql])
raise Exception("should not reach here") raise Exception("should not reach here")
@ -648,10 +645,12 @@ class TDTestCase:
tdSql.checkNotEqual(err.errno, 0) tdSql.checkNotEqual(err.errno, 0)
# # binary # # binary
tdCom.cleanTb()
stb_name = tdCom.getLongName(7, "letters") stb_name = tdCom.getLongName(7, "letters")
input_sql = f'{stb_name} 1626006833639000000ns "{tdCom.getLongName(16374, "letters")}" t0=t' input_sql = f'{stb_name} 1626006833639000000ns "{tdCom.getLongName(16374, "letters")}" t0=t'
self._conn.insert_telnet_lines([input_sql]) self._conn.insert_telnet_lines([input_sql])
tdCom.cleanTb()
input_sql = f'{stb_name} 1626006833639000000ns "{tdCom.getLongName(16375, "letters")}" t0=t' input_sql = f'{stb_name} 1626006833639000000ns "{tdCom.getLongName(16375, "letters")}" t0=t'
try: try:
self._conn.insert_telnet_lines([input_sql]) self._conn.insert_telnet_lines([input_sql])
@ -661,10 +660,12 @@ class TDTestCase:
# nchar # nchar
# * legal nchar could not be larger than 16374/4 # * legal nchar could not be larger than 16374/4
tdCom.cleanTb()
stb_name = tdCom.getLongName(7, "letters") stb_name = tdCom.getLongName(7, "letters")
input_sql = f'{stb_name} 1626006833639000000ns L"{tdCom.getLongName(4093, "letters")}" t0=t' input_sql = f'{stb_name} 1626006833639000000ns L"{tdCom.getLongName(4093, "letters")}" t0=t'
self._conn.insert_telnet_lines([input_sql]) self._conn.insert_telnet_lines([input_sql])
tdCom.cleanTb()
input_sql = f'{stb_name} 1626006833639000000ns L"{tdCom.getLongName(4094, "letters")}" t0=t' input_sql = f'{stb_name} 1626006833639000000ns L"{tdCom.getLongName(4094, "letters")}" t0=t'
try: try:
self._conn.insert_telnet_lines([input_sql]) self._conn.insert_telnet_lines([input_sql])
@ -709,24 +710,21 @@ class TDTestCase:
tdSql.checkNotEqual(err.errno, 0) tdSql.checkNotEqual(err.errno, 0)
# check binary and nchar blank # check binary and nchar blank
stb_name = tdCom.getLongName(7, "letters") input_sql1 = f'{tdCom.getLongName(7, "letters")} 1626006833639000000ns "abc aaa" t0=t'
input_sql2 = f'{tdCom.getLongName(7, "letters")} 1626006833639000000ns L"abc aaa" t0=t'
input_sql1 = f'{stb_name} 1626006833639000000ns "abc aaa" t0=t' input_sql3 = f'{tdCom.getLongName(7, "letters")} 1626006833639000000ns t t0="abc aaa"'
input_sql2 = f'{stb_name} 1626006833639000000ns L"abc aaa" t0=t' input_sql4 = f'{tdCom.getLongName(7, "letters")} 1626006833639000000ns t t0=L"abc aaa"'
input_sql3 = f'{stb_name} 1626006833639000000ns t t0="abc aaa"'
input_sql4 = f'{stb_name} 1626006833639000000ns t t0=L"abc aaa"'
for input_sql in [input_sql1, input_sql2, input_sql3, input_sql4]: for input_sql in [input_sql1, input_sql2, input_sql3, input_sql4]:
try: try:
self._conn.insert_telnet_lines([input_sql]) self._conn.insert_telnet_lines([input_sql])
raise Exception("should not reach here")
except LinesError as err: except LinesError as err:
tdSql.checkNotEqual(err.errno, 0) pass
# check accepted binary and nchar symbols # check accepted binary and nchar symbols
# # * ~!@#$¥%^&*()-+={}|[]、「」:; # # * ~!@#$¥%^&*()-+={}|[]、「」:;
for symbol in list('~!@#$¥%^&*()-+={}|[]、「」:;'): for symbol in list('~!@#$¥%^&*()-+={}|[]、「」:;'):
input_sql1 = f'{stb_name} 1626006833639000000ns "abc{symbol}aaa" t0=t' input_sql1 = f'{tdCom.getLongName(7, "letters")} 1626006833639000000ns "abc{symbol}aaa" t0=t'
input_sql2 = f'{stb_name} 1626006833639000000ns t t0=t,t1="abc{symbol}aaa"' input_sql2 = f'{tdCom.getLongName(7, "letters")} 1626006833639000000ns t t0=t,t1="abc{symbol}aaa"'
self._conn.insert_telnet_lines([input_sql1]) self._conn.insert_telnet_lines([input_sql1])
self._conn.insert_telnet_lines([input_sql2]) self._conn.insert_telnet_lines([input_sql2])
@ -756,6 +754,7 @@ class TDTestCase:
""" """
case no id when stb exist case no id when stb exist
""" """
print("noIdStbExistCheckCase")
tdCom.cleanTb() tdCom.cleanTb()
input_sql, stb_name = self.genFullTypeSql(tb_name="sub_table_0123456", t0="f", value="f") input_sql, stb_name = self.genFullTypeSql(tb_name="sub_table_0123456", t0="f", value="f")
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
@ -779,22 +778,24 @@ class TDTestCase:
""" """
check length increase check length increase
""" """
print("tagColBinaryNcharLengthCheckCase")
tdCom.cleanTb() tdCom.cleanTb()
input_sql, stb_name = self.genFullTypeSql() input_sql, stb_name = self.genFullTypeSql()
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
tb_name = tdCom.getLongName(5, "letters") tb_name = tdCom.getLongName(5, "letters")
input_sql, stb_name = self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name,t7="\"binaryTagValuebinaryTagValue\"", t8="L\"ncharTagValuencharTagValue\"", c7="\"binaryTagValuebinaryTagValue\"", c8="L\"ncharTagValuencharTagValue\"") input_sql, stb_name = self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name,t7="\"binaryTagValuebinaryTagValue\"", t8="L\"ncharTagValuencharTagValue\"")
self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"') self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"')
def tagColAddDupIDCheckCase(self): def tagColAddDupIDCheckCase(self):
""" """
check column and tag count add, stb and tb duplicate check tag count add, stb and tb duplicate
* tag: alter table ... * tag: alter table ...
* col: when update==0 and ts is same, unchange * col: when update==0 and ts is same, unchange
* so this case tag&&value will be added, * so this case tag&&value will be added,
* col is added without value when update==0 * col is added without value when update==0
* col is added with value when update==1 * col is added with value when update==1
""" """
print("tagColAddDupIDCheckCase")
tdCom.cleanTb() tdCom.cleanTb()
tb_name = tdCom.getLongName(7, "letters") tb_name = tdCom.getLongName(7, "letters")
for db_update_tag in [0, 1]: for db_update_tag in [0, 1]:
@ -802,25 +803,27 @@ class TDTestCase:
self.createDb("test_update", db_update_tag=db_update_tag) self.createDb("test_update", db_update_tag=db_update_tag)
input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name, t0="f", value="f") input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name, t0="f", value="f")
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t0="f", value="f", ct_add_tag=True) self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t0="f", value="f", t_add_tag=True)
if db_update_tag == 1 : if db_update_tag == 1 :
self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"') self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"')
else: else:
self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"', none_check_tag=True) self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"', none_check_tag=True)
self.createDb()
def tagColAddCheckCase(self): def tagColAddCheckCase(self):
""" """
check column and tag count add check tag count add
""" """
print("tagColAddCheckCase")
tdCom.cleanTb() tdCom.cleanTb()
tb_name = tdCom.getLongName(7, "letters") tb_name = tdCom.getLongName(7, "letters")
input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name, t0="f", value="f") input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name, t0="f", value="f")
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
tb_name_1 = tdCom.getLongName(7, "letters") tb_name_1 = tdCom.getLongName(7, "letters")
input_sql, stb_name = self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name_1, t0="f", value="f", ct_add_tag=True) input_sql, stb_name = self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name_1, t0="f", value="f", t_add_tag=True)
self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name_1}"') self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name_1}"')
res_row_list = self.resHandle(f"select c10,c11,t10,t11 from {tb_name}", True)[0] res_row_list = self.resHandle(f"select t10,t11 from {tb_name}", True)[0]
tdSql.checkEqual(res_row_list[0], ['None', 'None', 'None', 'None']) tdSql.checkEqual(res_row_list[0], ['None', 'None'])
self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"', none_check_tag=True) self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"', none_check_tag=True)
def tagMd5Check(self): def tagMd5Check(self):
@ -838,7 +841,7 @@ class TDTestCase:
tdSql.query(f"select * from {stb_name}") tdSql.query(f"select * from {stb_name}")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.checkEqual(tb_name1, tb_name2) tdSql.checkEqual(tb_name1, tb_name2)
input_sql, stb_name = self.genFullTypeSql(stb_name=stb_name, t0="f", value="f", id_noexist_tag=True, ct_add_tag=True) input_sql, stb_name = self.genFullTypeSql(stb_name=stb_name, t0="f", value="f", id_noexist_tag=True, t_add_tag=True)
self._conn.insert_telnet_lines([input_sql]) self._conn.insert_telnet_lines([input_sql])
tb_name3 = self.getNoIdTbName(stb_name) tb_name3 = self.getNoIdTbName(stb_name)
tdSql.query(f"select * from {stb_name}") tdSql.query(f"select * from {stb_name}")
@ -853,16 +856,17 @@ class TDTestCase:
tdCom.cleanTb() tdCom.cleanTb()
stb_name = tdCom.getLongName(7, "letters") stb_name = tdCom.getLongName(7, "letters")
tb_name = f'{stb_name}_1' tb_name = f'{stb_name}_1'
input_sql = f'{stb_name},id="{tb_name}",t0=t c0=f 1626006833639000000ns'
input_sql = f'{stb_name} 1626006833639000000ns f id="{tb_name}",t0=t'
self._conn.insert_telnet_lines([input_sql]) self._conn.insert_telnet_lines([input_sql])
# * every binary and nchar must be length+2, so here is two tag, max length could not larger than 16384-2*2 # * every binary and nchar must be length+2, so here is two tag, max length could not larger than 16384-2*2
input_sql = f'{stb_name},t0=t,t1="{tdCom.getLongName(16374, "letters")}",t2="{tdCom.getLongName(5, "letters")}" c0=f 1626006833639000000ns' input_sql = f'{stb_name} 1626006833639000000ns f t0=t,t1="{tdCom.getLongName(16374, "letters")}",t2="{tdCom.getLongName(5, "letters")}"'
self._conn.insert_telnet_lines([input_sql]) self._conn.insert_telnet_lines([input_sql])
tdSql.query(f"select * from {stb_name}") tdSql.query(f"select * from {stb_name}")
tdSql.checkRows(2) tdSql.checkRows(2)
input_sql = f'{stb_name},t0=t,t1="{tdCom.getLongName(16374, "letters")}",t2="{tdCom.getLongName(6, "letters")}" c0=f 1626006833639000000ns' input_sql = f'{stb_name} 1626006833639000000ns f t0=t,t1="{tdCom.getLongName(16374, "letters")}",t2="{tdCom.getLongName(6, "letters")}"'
try: try:
self._conn.insert_telnet_lines([input_sql]) self._conn.insert_telnet_lines([input_sql])
raise Exception("should not reach here") raise Exception("should not reach here")
@ -871,21 +875,6 @@ class TDTestCase:
tdSql.query(f"select * from {stb_name}") tdSql.query(f"select * from {stb_name}")
tdSql.checkRows(2) tdSql.checkRows(2)
# # * check col，col+ts max in describe ---> 16143
input_sql = f'{stb_name},t0=t c0=f,c1="{tdCom.getLongName(16374, "letters")}",c2="{tdCom.getLongName(16374, "letters")}",c3="{tdCom.getLongName(16374, "letters")}",c4="{tdCom.getLongName(12, "letters")}" 1626006833639000000ns'
self._conn.insert_telnet_lines([input_sql])
tdSql.query(f"select * from {stb_name}")
tdSql.checkRows(3)
input_sql = f'{stb_name},t0=t c0=f,c1="{tdCom.getLongName(16374, "letters")}",c2="{tdCom.getLongName(16374, "letters")}",c3="{tdCom.getLongName(16374, "letters")}",c4="{tdCom.getLongName(13, "letters")}" 1626006833639000000ns'
try:
self._conn.insert_telnet_lines([input_sql])
raise Exception("should not reach here")
except LinesError as err:
tdSql.checkNotEqual(err.errno, 0)
tdSql.query(f"select * from {stb_name}")
tdSql.checkRows(3)
# * tag nchar max is 16374/4, col+ts nchar max 49151 # * tag nchar max is 16374/4, col+ts nchar max 49151
def tagColNcharMaxLengthCheckCase(self): def tagColNcharMaxLengthCheckCase(self):
""" """
@ -894,15 +883,15 @@ class TDTestCase:
tdCom.cleanTb() tdCom.cleanTb()
stb_name = tdCom.getLongName(7, "letters") stb_name = tdCom.getLongName(7, "letters")
tb_name = f'{stb_name}_1' tb_name = f'{stb_name}_1'
input_sql = f'{stb_name},id="{tb_name}",t0=t c0=f 1626006833639000000ns' input_sql = f'{stb_name} 1626006833639000000ns f id="{tb_name}",t0=t'
code = self._conn.insert_telnet_lines([input_sql]) self._conn.insert_telnet_lines([input_sql])
# * legal nchar could not be larger than 16374/4 # * legal nchar could not be larger than 16374/4
input_sql = f'{stb_name},t0=t,t1=L"{tdCom.getLongName(4093, "letters")}",t2=L"{tdCom.getLongName(1, "letters")}" c0=f 1626006833639000000ns' input_sql = f'{stb_name} 1626006833639000000ns f t0=t,t1=L"{tdCom.getLongName(4093, "letters")}",t2=L"{tdCom.getLongName(1, "letters")}"'
self._conn.insert_telnet_lines([input_sql]) self._conn.insert_telnet_lines([input_sql])
tdSql.query(f"select * from {stb_name}") tdSql.query(f"select * from {stb_name}")
tdSql.checkRows(2) tdSql.checkRows(2)
input_sql = f'{stb_name},t0=t,t1=L"{tdCom.getLongName(4093, "letters")}",t2=L"{tdCom.getLongName(2, "letters")}" c0=f 1626006833639000000ns' input_sql = f'{stb_name} 1626006833639000000ns f t0=t,t1=L"{tdCom.getLongName(4093, "letters")}",t2=L"{tdCom.getLongName(2, "letters")}"'
try: try:
self._conn.insert_telnet_lines([input_sql]) self._conn.insert_telnet_lines([input_sql])
raise Exception("should not reach here") raise Exception("should not reach here")
@ -911,19 +900,6 @@ class TDTestCase:
tdSql.query(f"select * from {stb_name}") tdSql.query(f"select * from {stb_name}")
tdSql.checkRows(2) tdSql.checkRows(2)
input_sql = f'{stb_name},t0=t c0=f,c1=L"{tdCom.getLongName(4093, "letters")}",c2=L"{tdCom.getLongName(4093, "letters")}",c3=L"{tdCom.getLongName(4093, "letters")}",c4=L"{tdCom.getLongName(4, "letters")}" 1626006833639000000ns'
self._conn.insert_telnet_lines([input_sql])
tdSql.query(f"select * from {stb_name}")
tdSql.checkRows(3)
input_sql = f'{stb_name},t0=t c0=f,c1=L"{tdCom.getLongName(4093, "letters")}",c2=L"{tdCom.getLongName(4093, "letters")}",c3=L"{tdCom.getLongName(4093, "letters")}",c4=L"{tdCom.getLongName(5, "letters")}" 1626006833639000000ns'
try:
self._conn.insert_telnet_lines([input_sql])
raise Exception("should not reach here")
except LinesError as err:
tdSql.checkNotEqual(err.errno, 0)
tdSql.query(f"select * from {stb_name}")
tdSql.checkRows(3)
def batchInsertCheckCase(self): def batchInsertCheckCase(self):
""" """
test batch insert test batch insert
@ -931,17 +907,24 @@ class TDTestCase:
tdCom.cleanTb() tdCom.cleanTb()
stb_name = tdCom.getLongName(8, "letters") stb_name = tdCom.getLongName(8, "letters")
tdSql.execute(f'create stable {stb_name}(ts timestamp, f int) tags(t1 bigint)') tdSql.execute(f'create stable {stb_name}(ts timestamp, f int) tags(t1 bigint)')
lines = ["st123456,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000ns",
"st123456,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64 1626006833640000000ns", lines = ["st123456 1626006833639000000ns 1i64 t1=3i64,t2=4f64,t3=\"t3\"",
f"{stb_name},t2=5f64,t3=L\"ste\" c1=true,c2=4i64,c3=\"iam\" 1626056811823316532ns", "st123456 1626006833640000000ns 2i64 t1=4i64,t3=\"t4\",t2=5f64,t4=5f64",
"stf567890,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64,c6=7u64 1626006933640000000ns", f'{stb_name} 1626056811823316532ns 3i64 t2=5f64,t3=L\"ste\"',
"st123456,t1=4i64,t2=5f64,t3=\"t4\" c1=3i64,c3=L\"passitagain\",c2=true,c4=5f64 1626006833642000000ns", "stf567890 1626006933640000000ns 4i64 t1=4i64,t3=\"t4\",t2=5f64,t4=5f64",
f"{stb_name},t2=5f64,t3=L\"ste2\" c3=\"iamszhou\",c4=false 1626056811843316532ns", "st123456 1626006833642000000ns 5i64 t1=4i64,t2=5f64,t3=\"t4\"",
f"{stb_name},t2=5f64,t3=L\"ste2\" c3=\"iamszhou\",c4=false,c5=32i8,c6=64i16,c7=32i32,c8=88.88f32 1626056812843316532ns", f'{stb_name} 1626056811843316532ns 6i64 t2=5f64,t3=L\"ste2\"',
"st123456,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64,c6=7u64 1626006933640000000ns", f'{stb_name} 1626056812843316532ns 7i64 t2=5f64,t3=L\"ste2\"',
"st123456,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin_stf\",c2=false,c5=5f64,c6=7u64 1626006933641000000ns" "st123456 1626006933640000000ns 8i64 t1=4i64,t3=\"t4\",t2=5f64,t4=5f64",
"st123456 1626006933641000000ns 9i64 t1=4i64,t3=\"t4\",t2=5f64,t4=5f64"
] ]
self._conn.insert_telnet_lines(lines) self._conn.insert_telnet_lines(lines)
tdSql.query('show stables')
tdSql.checkRows(3)
tdSql.query('show tables')
tdSql.checkRows(6)
tdSql.query('select * from st123456')
tdSql.checkRows(5)
def multiInsertCheckCase(self, count): def multiInsertCheckCase(self, count):
""" """
@ -952,9 +935,11 @@ class TDTestCase:
stb_name = tdCom.getLongName(8, "letters") stb_name = tdCom.getLongName(8, "letters")
tdSql.execute(f'create stable {stb_name}(ts timestamp, f int) tags(t1 bigint)') tdSql.execute(f'create stable {stb_name}(ts timestamp, f int) tags(t1 bigint)')
for i in range(count): for i in range(count):
input_sql = self.genFullTypeSql(stb_name=stb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', id_noexist_tag=True)[0] input_sql = self.genFullTypeSql(stb_name=stb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', value=f'"{tdCom.getLongName(8, "letters")}"', id_noexist_tag=True)[0]
sql_list.append(input_sql) sql_list.append(input_sql)
self._conn.insert_telnet_lines(sql_list) self._conn.insert_telnet_lines(sql_list)
tdSql.query('show tables')
tdSql.checkRows(1000)
def batchErrorInsertCheckCase(self): def batchErrorInsertCheckCase(self):
""" """
@ -962,14 +947,86 @@ class TDTestCase:
""" """
tdCom.cleanTb() tdCom.cleanTb()
stb_name = tdCom.getLongName(8, "letters") stb_name = tdCom.getLongName(8, "letters")
lines = ["st123456,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000ns", lines = ["st123456 1626006833639000000ns 3i64 t1=3i64,t2=4f64,t3=\"t3\"",
f"{stb_name},t2=5f64,t3=L\"ste\" c1=tRue,c2=4i64,c3=\"iam\" 1626056811823316532ns"] f"{stb_name} 1626056811823316532ns tRue t2=5f64,t3=L\"ste\""]
try: try:
self._conn.insert_telnet_lines(lines) self._conn.insert_telnet_lines(lines)
raise Exception("should not reach here") raise Exception("should not reach here")
except LinesError as err: except LinesError as err:
tdSql.checkNotEqual(err.errno, 0) tdSql.checkNotEqual(err.errno, 0)
def multiColsInsertCheckCase(self):
"""
test multi cols insert
"""
tdCom.cleanTb()
input_sql = self.genFullTypeSql(t_multi_tag=True)[0]
try:
self._conn.insert_telnet_lines([input_sql])
raise Exception("should not reach here")
except LinesError as err:
tdSql.checkNotEqual(err.errno, 0)
def blankColInsertCheckCase(self):
"""
test blank col insert
"""
tdCom.cleanTb()
input_sql = self.genFullTypeSql(c_blank_tag=True)[0]
try:
self._conn.insert_telnet_lines([input_sql])
raise Exception("should not reach here")
except LinesError as err:
tdSql.checkNotEqual(err.errno, 0)
def blankTagInsertCheckCase(self):
"""
test blank tag insert
"""
tdCom.cleanTb()
input_sql = self.genFullTypeSql(t_blank_tag=True)[0]
try:
self._conn.insert_telnet_lines([input_sql])
raise Exception("should not reach here")
except LinesError as err:
tdSql.checkNotEqual(err.errno, 0)
def chineseCheckCase(self):
"""
check nchar ---> chinese
"""
tdCom.cleanTb()
input_sql, stb_name = self.genFullTypeSql(chinese_tag=True)
self.resCmp(input_sql, stb_name)
def multiFieldCheckCase(self):
'''
multi_field
'''
tdCom.cleanTb()
input_sql = self.genFullTypeSql(multi_field_tag=True)[0]
try:
self._conn.insert_telnet_lines([input_sql])
raise Exception("should not reach here")
except LinesError as err:
tdSql.checkNotEqual(err.errno, 0)
def errorTypeCheckCase(self):
stb_name = tdCom.getLongName(8, "letters")
input_sql_list = [f'{stb_name} 0 "hkgjiwdj" t0=f,t1=127I8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="vozamcts",t8=L"ncharTagValue"', \
f'{stb_name} 0 "hkgjiwdj" t0=f,t1=127i8,t2=32767I16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="vozamcts",t8=L"ncharTagValue"', \
f'{stb_name} 0 "hkgjiwdj" t0=f,t1=127i8,t2=32767i16,t3=2147483647I32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="vozamcts",t8=L"ncharTagValue"', \
f'{stb_name} 0 "hkgjiwdj" t0=f,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807I64,t5=11.12345f32,t6=22.123456789f64,t7="vozamcts",t8=L"ncharTagValue"', \
f'{stb_name} 0 "hkgjiwdj" t0=f,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345F32,t6=22.123456789f64,t7="vozamcts",t8=L"ncharTagValue"', \
f'{stb_name} 0 "hkgjiwdj" t0=f,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789F64,t7="vozamcts",t8=L"ncharTagValue"', \
f'{stb_name} 1626006833639000000NS "hkgjiwdj" t0=f,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="vozamcts",t8=L"ncharTagValue"']
for input_sql in input_sql_list:
try:
self._conn.insert_telnet_lines([input_sql])
raise Exception("should not reach here")
except LinesError as err:
tdSql.checkNotEqual(err.errno, 0)
def genSqlList(self, count=5, stb_name="", tb_name=""): def genSqlList(self, count=5, stb_name="", tb_name=""):
""" """
stb --> supertable stb --> supertable
@ -984,36 +1041,36 @@ class TDTestCase:
""" """
d_stb_d_tb_list = list() d_stb_d_tb_list = list()
s_stb_s_tb_list = list() s_stb_s_tb_list = list()
s_stb_s_tb_a_col_a_tag_list = list() s_stb_s_tb_a_tag_list = list()
s_stb_s_tb_m_col_m_tag_list = list() s_stb_s_tb_m_tag_list = list()
s_stb_d_tb_list = list() s_stb_d_tb_list = list()
s_stb_d_tb_a_col_m_tag_list = list() s_stb_d_tb_m_tag_list = list()
s_stb_d_tb_a_tag_m_col_list = list() s_stb_d_tb_a_tag_list = list()
s_stb_s_tb_d_ts_list = list() s_stb_s_tb_d_ts_list = list()
s_stb_s_tb_d_ts_a_col_m_tag_list = list() s_stb_s_tb_d_ts_m_tag_list = list()
s_stb_s_tb_d_ts_a_tag_m_col_list = list() s_stb_s_tb_d_ts_a_tag_list = list()
s_stb_d_tb_d_ts_list = list() s_stb_d_tb_d_ts_list = list()
s_stb_d_tb_d_ts_a_col_m_tag_list = list() s_stb_d_tb_d_ts_m_tag_list = list()
s_stb_d_tb_d_ts_a_tag_m_col_list = list() s_stb_d_tb_d_ts_a_tag_list = list()
for i in range(count): for i in range(count):
d_stb_d_tb_list.append(self.genFullTypeSql(t0="f", c0="f")) d_stb_d_tb_list.append(self.genFullTypeSql(t0="f", value="f"))
s_stb_s_tb_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"')) s_stb_s_tb_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', value=f'"{tdCom.getLongName(8, "letters")}"'))
s_stb_s_tb_a_col_a_tag_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', ct_add_tag=True)) s_stb_s_tb_a_tag_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', value=f'"{tdCom.getLongName(8, "letters")}"', t_add_tag=True))
s_stb_s_tb_m_col_m_tag_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', ct_min_tag=True)) s_stb_s_tb_m_tag_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', value=f'"{tdCom.getLongName(8, "letters")}"', t_mul_tag=True))
s_stb_d_tb_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', id_noexist_tag=True)) s_stb_d_tb_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', value=f'"{tdCom.getLongName(8, "letters")}"', id_noexist_tag=True))
s_stb_d_tb_a_col_m_tag_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', id_noexist_tag=True, ct_am_tag=True)) s_stb_d_tb_m_tag_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', value=f'"{tdCom.getLongName(8, "letters")}"', id_noexist_tag=True, t_mul_tag=True))
s_stb_d_tb_a_tag_m_col_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', id_noexist_tag=True, ct_ma_tag=True)) s_stb_d_tb_a_tag_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', value=f'"{tdCom.getLongName(8, "letters")}"', id_noexist_tag=True, t_add_tag=True))
s_stb_s_tb_d_ts_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', ts=0)) s_stb_s_tb_d_ts_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', value=f'"{tdCom.getLongName(8, "letters")}"', ts=0))
s_stb_s_tb_d_ts_a_col_m_tag_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', ts=0, ct_am_tag=True)) s_stb_s_tb_d_ts_m_tag_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', value=f'"{tdCom.getLongName(8, "letters")}"', ts=0, t_mul_tag=True))
s_stb_s_tb_d_ts_a_tag_m_col_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', ts=0, ct_ma_tag=True)) s_stb_s_tb_d_ts_a_tag_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', value=f'"{tdCom.getLongName(8, "letters")}"', ts=0, t_add_tag=True))
s_stb_d_tb_d_ts_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', id_noexist_tag=True, ts=0)) s_stb_d_tb_d_ts_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', value=f'"{tdCom.getLongName(8, "letters")}"', id_noexist_tag=True, ts=0))
s_stb_d_tb_d_ts_a_col_m_tag_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', id_noexist_tag=True, ts=0, ct_am_tag=True)) s_stb_d_tb_d_ts_m_tag_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', value=f'"{tdCom.getLongName(8, "letters")}"', id_noexist_tag=True, ts=0, t_mul_tag=True))
s_stb_d_tb_d_ts_a_tag_m_col_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', c7=f'"{tdCom.getLongName(8, "letters")}"', id_noexist_tag=True, ts=0, ct_ma_tag=True)) s_stb_d_tb_d_ts_a_tag_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{tdCom.getLongName(8, "letters")}"', value=f'"{tdCom.getLongName(8, "letters")}"', id_noexist_tag=True, ts=0, t_add_tag=True))
return d_stb_d_tb_list, s_stb_s_tb_list, s_stb_s_tb_a_col_a_tag_list, s_stb_s_tb_m_col_m_tag_list, \ return d_stb_d_tb_list, s_stb_s_tb_list, s_stb_s_tb_a_tag_list, s_stb_s_tb_m_tag_list, \
s_stb_d_tb_list, s_stb_d_tb_a_col_m_tag_list, s_stb_d_tb_a_tag_m_col_list, s_stb_s_tb_d_ts_list, \ s_stb_d_tb_list, s_stb_d_tb_m_tag_list, s_stb_d_tb_a_tag_list, s_stb_s_tb_d_ts_list, \
s_stb_s_tb_d_ts_a_col_m_tag_list, s_stb_s_tb_d_ts_a_tag_m_col_list, s_stb_d_tb_d_ts_list, \ s_stb_s_tb_d_ts_m_tag_list, s_stb_s_tb_d_ts_a_tag_list, s_stb_d_tb_d_ts_list, \
s_stb_d_tb_d_ts_a_col_m_tag_list, s_stb_d_tb_d_ts_a_tag_m_col_list s_stb_d_tb_d_ts_m_tag_list, s_stb_d_tb_d_ts_a_tag_list
def genMultiThreadSeq(self, sql_list): def genMultiThreadSeq(self, sql_list):
@ -1045,7 +1102,7 @@ class TDTestCase:
""" """
tdCom.cleanTb() tdCom.cleanTb()
tb_name = tdCom.getLongName(7, "letters") tb_name = tdCom.getLongName(7, "letters")
input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name) input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name, value="\"binaryTagValue\"")
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
s_stb_s_tb_list = self.genSqlList(stb_name=stb_name, tb_name=tb_name)[1] s_stb_s_tb_list = self.genSqlList(stb_name=stb_name, tb_name=tb_name)[1]
self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_list)) self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_list))
@ -1056,16 +1113,16 @@ class TDTestCase:
tdSql.query(f"select * from {stb_name};") tdSql.query(f"select * from {stb_name};")
tdSql.checkRows(1) tdSql.checkRows(1)
def sStbStbDdataAtcInsertMultiThreadCheckCase(self): def sStbStbDdataAtInsertMultiThreadCheckCase(self):
""" """
thread input same stb tb, different data, add columes and tags, result keep first data thread input same stb tb, different data, add columes and tags, result keep first data
""" """
tdCom.cleanTb() tdCom.cleanTb()
tb_name = tdCom.getLongName(7, "letters") tb_name = tdCom.getLongName(7, "letters")
input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name) input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name, value="\"binaryTagValue\"")
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
s_stb_s_tb_a_col_a_tag_list = self.genSqlList(stb_name=stb_name, tb_name=tb_name)[2] s_stb_s_tb_a_tag_list = self.genSqlList(stb_name=stb_name, tb_name=tb_name)[2]
self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_a_col_a_tag_list)) self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_a_tag_list))
tdSql.query(f"show tables;") tdSql.query(f"show tables;")
tdSql.checkRows(1) tdSql.checkRows(1)
expected_tb_name = self.getNoIdTbName(stb_name)[0] expected_tb_name = self.getNoIdTbName(stb_name)[0]
@ -1073,16 +1130,16 @@ class TDTestCase:
tdSql.query(f"select * from {stb_name};") tdSql.query(f"select * from {stb_name};")
tdSql.checkRows(1) tdSql.checkRows(1)
def sStbStbDdataMtcInsertMultiThreadCheckCase(self): def sStbStbDdataMtInsertMultiThreadCheckCase(self):
""" """
thread input same stb tb, different data, minus columes and tags, result keep first data thread input same stb tb, different data, minus columes and tags, result keep first data
""" """
tdCom.cleanTb() tdCom.cleanTb()
tb_name = tdCom.getLongName(7, "letters") tb_name = tdCom.getLongName(7, "letters")
input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name) input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name, value="\"binaryTagValue\"")
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
s_stb_s_tb_m_col_m_tag_list = self.genSqlList(stb_name=stb_name, tb_name=tb_name)[3] s_stb_s_tb_m_tag_list = self.genSqlList(stb_name=stb_name, tb_name=tb_name)[3]
self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_m_col_m_tag_list)) self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_m_tag_list))
tdSql.query(f"show tables;") tdSql.query(f"show tables;")
tdSql.checkRows(1) tdSql.checkRows(1)
expected_tb_name = self.getNoIdTbName(stb_name)[0] expected_tb_name = self.getNoIdTbName(stb_name)[0]
@ -1095,40 +1152,38 @@ class TDTestCase:
thread input same stb, different tb, different data thread input same stb, different tb, different data
""" """
tdCom.cleanTb() tdCom.cleanTb()
input_sql, stb_name = self.genFullTypeSql() input_sql, stb_name = self.genFullTypeSql(value="\"binaryTagValue\"")
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
s_stb_d_tb_list = self.genSqlList(stb_name=stb_name)[4] s_stb_d_tb_list = self.genSqlList(stb_name=stb_name)[4]
self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_list)) self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_list))
tdSql.query(f"show tables;") tdSql.query(f"show tables;")
tdSql.checkRows(6) tdSql.checkRows(6)
def sStbDtbDdataAcMtInsertMultiThreadCheckCase(self): def sStbDtbDdataMtInsertMultiThreadCheckCase(self):
"""
#! concurrency conflict
"""
""" """
thread input same stb, different tb, different data, add col, mul tag thread input same stb, different tb, different data, add col, mul tag
""" """
tdCom.cleanTb() tdCom.cleanTb()
input_sql, stb_name = self.genFullTypeSql() input_sql, stb_name = self.genFullTypeSql(value="\"binaryTagValue\"")
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
s_stb_d_tb_a_col_m_tag_list = self.genSqlList(stb_name=stb_name)[5] s_stb_d_tb_m_tag_list = [(f'{stb_name} 1626006833639000000ns "omfdhyom" t0=F,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64', 'yzwswz'), \
self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_a_col_m_tag_list)) (f'{stb_name} 1626006833639000000ns "vqowydbc" t0=F,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64', 'yzwswz'), \
(f'{stb_name} 1626006833639000000ns "plgkckpv" t0=F,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64', 'yzwswz'), \
(f'{stb_name} 1626006833639000000ns "cujyqvlj" t0=F,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64', 'yzwswz'), \
(f'{stb_name} 1626006833639000000ns "twjxisat" t0=T,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64', 'yzwswz')]
self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_m_tag_list))
tdSql.query(f"show tables;") tdSql.query(f"show tables;")
tdSql.checkRows(6) tdSql.checkRows(3)
def sStbDtbDdataAtMcInsertMultiThreadCheckCase(self): def sStbDtbDdataAtInsertMultiThreadCheckCase(self):
"""
#! concurrency conflict
"""
""" """
thread input same stb, different tb, different data, add tag, mul col thread input same stb, different tb, different data, add tag, mul col
""" """
tdCom.cleanTb() tdCom.cleanTb()
input_sql, stb_name = self.genFullTypeSql() input_sql, stb_name = self.genFullTypeSql(value="\"binaryTagValue\"")
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
s_stb_d_tb_a_tag_m_col_list = self.genSqlList(stb_name=stb_name)[6] s_stb_d_tb_a_tag_list = self.genSqlList(stb_name=stb_name)[6]
self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_a_tag_m_col_list)) self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_a_tag_list))
tdSql.query(f"show tables;") tdSql.query(f"show tables;")
tdSql.checkRows(6) tdSql.checkRows(6)
@ -1138,89 +1193,94 @@ class TDTestCase:
""" """
tdCom.cleanTb() tdCom.cleanTb()
tb_name = tdCom.getLongName(7, "letters") tb_name = tdCom.getLongName(7, "letters")
input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name) input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name, value="\"binaryTagValue\"")
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
s_stb_s_tb_d_ts_list = self.genSqlList(stb_name=stb_name, tb_name=tb_name)[7] s_stb_s_tb_d_ts_list = [(f'{stb_name} 0 "hkgjiwdj" id="{tb_name}",t0=f,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="vozamcts",t8=L"ncharTagValue"', 'dwpthv'), \
(f'{stb_name} 0 "rljjrrul" id="{tb_name}",t0=False,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="bmcanhbs",t8=L"ncharTagValue"', 'dwpthv'), \
(f'{stb_name} 0 "basanglx" id="{tb_name}",t0=False,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="enqkyvmb",t8=L"ncharTagValue"', 'dwpthv'), \
(f'{stb_name} 0 "clsajzpp" id="{tb_name}",t0=F,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="eivaegjk",t8=L"ncharTagValue"', 'dwpthv'), \
(f'{stb_name} 0 "jitwseso" id="{tb_name}",t0=T,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="yhlwkddq",t8=L"ncharTagValue"', 'dwpthv')]
self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_d_ts_list)) self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_d_ts_list))
tdSql.query(f"show tables;") tdSql.query(f"show tables;")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.query(f"select * from {stb_name}") tdSql.query(f"select * from {stb_name}")
tdSql.checkRows(6) tdSql.checkRows(6)
def sStbStbDdataDtsAcMtInsertMultiThreadCheckCase(self): def sStbStbDdataDtsMtInsertMultiThreadCheckCase(self):
""" """
thread input same stb tb, different ts, add col, mul tag thread input same stb tb, different ts, add col, mul tag
""" """
tdCom.cleanTb() tdCom.cleanTb()
tb_name = tdCom.getLongName(7, "letters") tb_name = tdCom.getLongName(7, "letters")
input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name) input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name, value="\"binaryTagValue\"")
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
s_stb_s_tb_d_ts_a_col_m_tag_list = self.genSqlList(stb_name=stb_name, tb_name=tb_name)[8] s_stb_s_tb_d_ts_m_tag_list = self.genSqlList(stb_name=stb_name, tb_name=tb_name)[8]
self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_d_ts_a_col_m_tag_list)) self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_d_ts_m_tag_list))
tdSql.query(f"show tables;") tdSql.query(f"show tables;")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.query(f"select * from {stb_name}") tdSql.query(f"select * from {stb_name}")
tdSql.checkRows(6) tdSql.checkRows(6)
tdSql.query(f"select * from {stb_name} where t8 is not NULL") tdSql.query(f"select * from {stb_name} where t8 is not NULL")
tdSql.checkRows(6) tdSql.checkRows(6)
tdSql.query(f"select * from {tb_name} where c11 is not NULL;")
tdSql.checkRows(5)
def sStbStbDdataDtsAtMcInsertMultiThreadCheckCase(self): def sStbStbDdataDtsAtInsertMultiThreadCheckCase(self):
""" """
thread input same stb tb, different ts, add tag, mul col thread input same stb tb, different ts, add tag, mul col
""" """
tdCom.cleanTb() tdCom.cleanTb()
tb_name = tdCom.getLongName(7, "letters") tb_name = tdCom.getLongName(7, "letters")
input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name) input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name, value="\"binaryTagValue\"")
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
s_stb_s_tb_d_ts_a_tag_m_col_list = self.genSqlList(stb_name=stb_name, tb_name=tb_name)[9] s_stb_s_tb_d_ts_a_tag_list = [(f'{stb_name} 0 "clummqfy" id="{tb_name}",t0=False,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="hpxzrdiw",t8=L"ncharTagValue",t11=127i8,t10=L"ncharTagValue"', 'bokaxl'), \
self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_d_ts_a_tag_m_col_list)) (f'{stb_name} 0 "yqeztggb" id="{tb_name}",t0=F,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="gdtblmrc",t8=L"ncharTagValue",t11=127i8,t10=L"ncharTagValue"', 'bokaxl'), \
(f'{stb_name} 0 "gbkinqdk" id="{tb_name}",t0=f,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="iqniuvco",t8=L"ncharTagValue",t11=127i8,t10=L"ncharTagValue"', 'bokaxl'), \
(f'{stb_name} 0 "ldxxejbd" id="{tb_name}",t0=f,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="vxkipags",t8=L"ncharTagValue",t11=127i8,t10=L"ncharTagValue"', 'bokaxl'), \
(f'{stb_name} 0 "tlvzwjes" id="{tb_name}",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="enwrlrtj",t8=L"ncharTagValue",t11=127i8,t10=L"ncharTagValue"', 'bokaxl')]
self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_d_ts_a_tag_list))
tdSql.query(f"show tables;") tdSql.query(f"show tables;")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.query(f"select * from {stb_name}") tdSql.query(f"select * from {stb_name}")
tdSql.checkRows(6) tdSql.checkRows(6)
for c in ["c7", "c8", "c9"]:
tdSql.query(f"select * from {stb_name} where {c} is NULL")
tdSql.checkRows(5)
for t in ["t10", "t11"]: for t in ["t10", "t11"]:
tdSql.query(f"select * from {stb_name} where {t} is not NULL;") tdSql.query(f"select * from {stb_name} where {t} is not NULL;")
tdSql.checkRows(6) tdSql.checkRows(0)
def sStbDtbDdataDtsInsertMultiThreadCheckCase(self): def sStbDtbDdataDtsInsertMultiThreadCheckCase(self):
""" """
thread input same stb, different tb, data, ts thread input same stb, different tb, data, ts
""" """
tdCom.cleanTb() tdCom.cleanTb()
input_sql, stb_name = self.genFullTypeSql() input_sql, stb_name = self.genFullTypeSql(value="\"binaryTagValue\"")
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
s_stb_d_tb_d_ts_list = self.genSqlList(stb_name=stb_name)[10] s_stb_d_tb_d_ts_list = self.genSqlList(stb_name=stb_name)[10]
self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_d_ts_list)) self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_d_ts_list))
tdSql.query(f"show tables;") tdSql.query(f"show tables;")
tdSql.checkRows(6) tdSql.checkRows(6)
def sStbDtbDdataDtsAcMtInsertMultiThreadCheckCase(self): def sStbDtbDdataDtsMtInsertMultiThreadCheckCase(self):
"""
# ! concurrency conflict
"""
""" """
thread input same stb, different tb, data, ts, add col, mul tag thread input same stb, different tb, data, ts, add col, mul tag
""" """
tdCom.cleanTb() tdCom.cleanTb()
input_sql, stb_name = self.genFullTypeSql() input_sql, stb_name = self.genFullTypeSql(value="\"binaryTagValue\"")
self.resCmp(input_sql, stb_name) self.resCmp(input_sql, stb_name)
s_stb_d_tb_d_ts_a_col_m_tag_list = self.genSqlList(stb_name=stb_name)[11] s_stb_d_tb_d_ts_m_tag_list = [(f'{stb_name} 0 "mnpmtzul" t0=f,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64', 'pcppkg'), \
self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_d_ts_a_col_m_tag_list)) (f'{stb_name} 0 "zbvwckcd" t0=True,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64', 'pcppkg'), \
(f'{stb_name} 0 "vymcjfwc" t0=F,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64', 'pcppkg'), \
(f'{stb_name} 0 "laumkwfn" t0=False,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64', 'pcppkg'), \
(f'{stb_name} 0 "nyultzxr" t0=false,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64', 'pcppkg')]
self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_d_ts_m_tag_list))
tdSql.query(f"show tables;") tdSql.query(f"show tables;")
tdSql.checkRows(6) tdSql.checkRows(3)
def test(self): def test(self):
# input_sql1 = "stb2_5 1626006833610ms 3f64 host=\"host0\",host2=L\"host2\"" # input_sql1 = "stb2_5 1626006833610ms 3f64 host=\"host0\",host2=L\"host2\""
# input_sql2 = "rfasta,id=\"rfasta_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64 c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64 1626006933640000000ns" # input_sql2 = "rfasta,id=\"rfasta_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64 c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64 1626006933640000000ns"
try: try:
input_sql, stb_name = self.genFullTypeSql() input_sql = f'test_nchar 0 L"涛思数据" t0=f,t1=L"涛思数据",t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64'
self.resCmp(input_sql, stb_name) self._conn.insert_telnet_lines([input_sql])
# input_sql, stb_name = self.genFullTypeSql()
# self.resCmp(input_sql, stb_name)
except LinesError as err: except LinesError as err:
print(err.errno) print(err.errno)
# self._conn.insert_telnet_lines([input_sql2]) # self._conn.insert_telnet_lines([input_sql2])
@ -1232,68 +1292,64 @@ class TDTestCase:
# self._conn.insert_telnet_lines([input_sql4]) # self._conn.insert_telnet_lines([input_sql4])
def runAll(self): def runAll(self):
# self.initCheckCase() self.initCheckCase()
# self.boolTypeCheckCase() self.boolTypeCheckCase()
self.symbolsCheckCase() # ! leave a bug
#self.symbolsCheckCase()
self.tsCheckCase()
self.idSeqCheckCase()
self.idUpperCheckCase()
self.noIdCheckCase()
self.maxColTagCheckCase()
self.idIllegalNameCheckCase()
self.idStartWithNumCheckCase()
self.nowTsCheckCase()
self.dateFormatTsCheckCase()
self.illegalTsCheckCase()
self.tagValueLengthCheckCase()
self.colValueLengthCheckCase()
self.tagColIllegalValueCheckCase()
self.duplicateIdTagColInsertCheckCase()
self.noIdStbExistCheckCase()
self.duplicateInsertExistCheckCase()
self.tagColBinaryNcharLengthCheckCase()
self.tagColAddDupIDCheckCase()
self.tagColAddCheckCase()
self.tagMd5Check()
self.tagColBinaryMaxLengthCheckCase()
self.tagColNcharMaxLengthCheckCase()
self.batchInsertCheckCase()
self.multiInsertCheckCase(1000)
# self.tsCheckCase() self.batchErrorInsertCheckCase()
# self.idSeqCheckCase() self.multiColsInsertCheckCase()
# self.idUpperCheckCase() self.blankColInsertCheckCase()
# self.noIdCheckCase() self.blankTagInsertCheckCase()
# self.maxColTagCheckCase() self.chineseCheckCase()
self.multiFieldCheckCase()
# self.idIllegalNameCheckCase() self.errorTypeCheckCase()
# self.idStartWithNumCheckCase() # MultiThreads
# self.nowTsCheckCase()
# self.dateFormatTsCheckCase()
# self.illegalTsCheckCase()
# self.tagValueLengthCheckCase()
# self.colValueLengthCheckCase()
# self.tagColIllegalValueCheckCase()
# self.duplicateIdTagColInsertCheckCase()
# self.noIdStbExistCheckCase()
# self.duplicateInsertExistCheckCase()
# self.tagColBinaryNcharLengthCheckCase()
# self.tagColAddDupIDCheckCase()
# self.tagColAddCheckCase()
# self.tagMd5Check()
# self.tagColBinaryMaxLengthCheckCase()
# # self.tagColNcharMaxLengthCheckCase()
# self.batchInsertCheckCase()
# self.multiInsertCheckCase(1000)
# self.batchErrorInsertCheckCase()
# # MultiThreads
# self.stbInsertMultiThreadCheckCase() # self.stbInsertMultiThreadCheckCase()
# self.sStbStbDdataInsertMultiThreadCheckCase() # self.sStbStbDdataInsertMultiThreadCheckCase()
# self.sStbStbDdataAtcInsertMultiThreadCheckCase() # self.sStbStbDdataAtInsertMultiThreadCheckCase()
# self.sStbStbDdataMtcInsertMultiThreadCheckCase() # self.sStbStbDdataMtInsertMultiThreadCheckCase()
# self.sStbDtbDdataInsertMultiThreadCheckCase() # self.sStbDtbDdataInsertMultiThreadCheckCase()
# self.sStbDtbDdataMtInsertMultiThreadCheckCase()
# # # ! concurrency conflict # self.sStbDtbDdataAtInsertMultiThreadCheckCase()
# # self.sStbDtbDdataAcMtInsertMultiThreadCheckCase()
# # self.sStbDtbDdataAtMcInsertMultiThreadCheckCase()
# self.sStbStbDdataDtsInsertMultiThreadCheckCase() # self.sStbStbDdataDtsInsertMultiThreadCheckCase()
# self.sStbStbDdataDtsMtInsertMultiThreadCheckCase()
# # # ! concurrency conflict # self.sStbStbDdataDtsAtInsertMultiThreadCheckCase()
# # self.sStbStbDdataDtsAcMtInsertMultiThreadCheckCase()
# # self.sStbStbDdataDtsAtMcInsertMultiThreadCheckCase()
# self.sStbDtbDdataDtsInsertMultiThreadCheckCase() # self.sStbDtbDdataDtsInsertMultiThreadCheckCase()
# self.sStbDtbDdataDtsMtInsertMultiThreadCheckCase()
# # ! concurrency conflict
# # self.sStbDtbDdataDtsAcMtInsertMultiThreadCheckCase()
def run(self): def run(self):
print("running {}".format(__file__)) print("running {}".format(__file__))
self.createDb() self.createDb()
try: try:
# self.symbolsCheckCase()
self.runAll() self.runAll()
# self.test()
except Exception as err: except Exception as err:
print(''.join(traceback.format_exception(None, err, err.__traceback__))) print(''.join(traceback.format_exception(None, err, err.__traceback__)))
raise err raise err