From a8352d8c2a61154afe29bdaf7eaffdb5d1c56922 Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Fri, 23 Jul 2021 01:43:00 +0800 Subject: [PATCH 01/31] [TD-5314]: autotest cases --- tests/pytest/insert/schemalessInsert.py | 874 ++++++++++++++++++++++++ tests/pytest/util/sql.py | 26 +- 2 files changed, 898 insertions(+), 2 deletions(-) create mode 100644 tests/pytest/insert/schemalessInsert.py diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py new file mode 100644 index 0000000000..b09c153bf6 --- /dev/null +++ b/tests/pytest/insert/schemalessInsert.py @@ -0,0 +1,874 @@ +################################################################### +# Copyright (c) 2021 by TAOS Technologies, Inc. +# All rights reserved. +# +# This file is proprietary and confidential to TAOS Technologies. +# No part of this file may be reproduced, stored, transmitted, +# disclosed or used in any form or by any means other than as +# expressly provided by the written permission from Jianhui Tao +# +################################################################### + +# -*- coding: utf-8 -*- + +import sys +import random +import string +import time +import datetime +from copy import deepcopy +import numpy as np +from util.log import * +from util.cases import * +from util.sql import * + + +class TDTestCase: + def init(self, conn, logSql): + tdLog.debug("start to execute %s" % __file__) + tdSql.init(conn.cursor(), logSql) + self._conn = conn + + def getLongName(self, len, mode = "mixed"): + """ + generate long name + mode could be numbers/letters/mixed + """ + if mode is "numbers": + chars = ''.join(random.choice(string.digits) for i in range(len)) + elif mode is "letters": + chars = ''.join(random.choice(string.ascii_letters.lower()) for i in range(len)) + else: + chars = ''.join(random.choice(string.ascii_letters.lower() + string.digits) for i in range(len)) + return chars + + def timeTrans(self, time_value): + if time_value.endswith("ns"): + ts = int(''.join(list(filter(str.isdigit, time_value))))/1000000000 + elif time_value.endswith("us") or time_value.isdigit() and int(time_value) != 0: + ts = int(''.join(list(filter(str.isdigit, time_value))))/1000000 + elif time_value.endswith("ms"): + ts = int(''.join(list(filter(str.isdigit, time_value))))/1000 + elif time_value.endswith("s") and list(time_value)[-1] not in "num": + ts = int(''.join(list(filter(str.isdigit, time_value))))/1 + elif int(time_value) == 0: + ts = time.time() + else: + print("input ts maybe not right format") + ulsec = repr(ts).split('.')[1][:6] + if len(ulsec) < 6 and int(ulsec) != 0: + ulsec = int(ulsec) * (10 ** (6 - len(ulsec))) + # ! to confirm .000000 + elif int(ulsec) == 0: + ulsec *= 6 + # ! follow two rows added for tsCheckCase + td_ts = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(ts)) + return td_ts + #td_ts = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(ts)) + td_ts = time.strftime("%Y-%m-%d %H:%M:%S.{}".format(ulsec), time.localtime(ts)) + return td_ts + #return repr(datetime.datetime.strptime(td_ts, "%Y-%m-%d %H:%M:%S.%f")) + + def dateToTs(self, datetime_input): + return int(time.mktime(time.strptime(datetime_input, "%Y-%m-%d %H:%M:%S.%f"))) + + def getTdTypeValue(self, value): + if value.endswith("i8"): + td_type = "TINYINT" + td_tag_value = ''.join(list(value)[:-2]) + elif value.endswith("i16"): + td_type = "SMALLINT" + td_tag_value = ''.join(list(value)[:-3]) + elif value.endswith("i32"): + td_type = "INT" + td_tag_value = ''.join(list(value)[:-3]) + elif value.endswith("i64"): + td_type = "BIGINT" + td_tag_value = ''.join(list(value)[:-3]) + elif value.endswith("u64"): + td_type = "BIGINT UNSIGNED" + td_tag_value = ''.join(list(value)[:-3]) + elif value.endswith("f32"): + td_type = "FLOAT" + td_tag_value = ''.join(list(value)[:-3]) + td_tag_value = '{}'.format(np.float32(td_tag_value)) + + elif value.endswith("f64"): + td_type = "DOUBLE" + td_tag_value = ''.join(list(value)[:-3]) + elif value.startswith('L"'): + td_type = "NCHAR" + td_tag_value = ''.join(list(value)[2:-1]) + elif value.startswith('"') and value.endswith('"'): + td_type = "BINARY" + td_tag_value = ''.join(list(value)[1:-1]) + elif value.lower() == "t" or value == "true" or value == "True": + td_type = "BOOL" + td_tag_value = "True" + elif value.lower() == "f" or value == "false" or value == "False": + td_type = "BOOL" + td_tag_value = "False" + else: + td_type = "FLOAT" + td_tag_value = value + return td_type, td_tag_value + + def typeTrans(self, type_list): + type_num_list = [] + for tp in type_list: + if tp.upper() == "TIMESTAMP": + type_num_list.append(9) + elif tp.upper() == "BOOL": + type_num_list.append(1) + elif tp.upper() == "TINYINT": + type_num_list.append(2) + elif tp.upper() == "SMALLINT": + type_num_list.append(3) + elif tp.upper() == "INT": + type_num_list.append(4) + elif tp.upper() == "BIGINT": + type_num_list.append(5) + elif tp.upper() == "FLOAT": + type_num_list.append(6) + elif tp.upper() == "DOUBLE": + type_num_list.append(7) + elif tp.upper() == "BINARY": + type_num_list.append(8) + elif tp.upper() == "NCHAR": + type_num_list.append(10) + elif tp.upper() == "BIGINT UNSIGNED": + type_num_list.append(14) + return type_num_list + + def inputHandle(self, input_sql): + input_sql_split_list = input_sql.split(" ") + + stb_tag_list = input_sql_split_list[0].split(',') + stb_col_list = input_sql_split_list[1].split(',') + ts_value = self.timeTrans(input_sql_split_list[2]) + + stb_name = stb_tag_list[0] + stb_tag_list.pop(0) + + tag_name_list = [] + tag_value_list = [] + td_tag_value_list = [] + td_tag_type_list = [] + + col_name_list = [] + col_value_list = [] + td_col_value_list = [] + td_col_type_list = [] + + for elm in stb_tag_list: + if "id=" in elm.lower(): + # id_index = stb_id_tag_list.index(elm) + tb_name = elm.split('=')[1] + else: + tag_name_list.append(elm.split("=")[0]) + tag_value_list.append(elm.split("=")[1]) + tb_name = "" + td_tag_value_list.append(self.getTdTypeValue(elm.split("=")[1])[1]) + td_tag_type_list.append(self.getTdTypeValue(elm.split("=")[1])[0]) + + for elm in stb_col_list: + col_name_list.append(elm.split("=")[0]) + col_value_list.append(elm.split("=")[1]) + td_col_value_list.append(self.getTdTypeValue(elm.split("=")[1])[1]) + td_col_type_list.append(self.getTdTypeValue(elm.split("=")[1])[0]) + + # print(stb_name) + # print(tb_name) + # print(tag_name_list) + # print(tag_value_list) + # print(td_tag_type_list) + # print(td_tag_value_list) + + # print(ts_value) + + # print(col_name_list) + # print(col_value_list) + # print(td_col_value_list) + # print(td_col_type_list) + + # print("final type--------######") + final_field_list = [] + final_field_list.extend(col_name_list) + final_field_list.extend(tag_name_list) + + # print("final type--------######") + final_type_list = [] + final_type_list.append("TIMESTAMP") + final_type_list.extend(td_col_type_list) + final_type_list.extend(td_tag_type_list) + final_type_list = self.typeTrans(final_type_list) + + final_value_list = [] + final_value_list.append(ts_value) + final_value_list.extend(td_col_value_list) + final_value_list.extend(td_tag_value_list) + # print("-----------value-----------") + # print(final_value_list) + # print("-----------value-----------") + return final_value_list, final_field_list, final_type_list, stb_name, tb_name + + def genFullTypeSql(self, stb_name="", tb_name="", t0="", t1="127i8", t2="32767i16", t3="2147483647i32", + t4="9223372036854775807i64", t5="11.12345f32", t6="22.123456789f64", t7="\"binaryTagValue\"", + t8="L\"ncharTagValue\"", c0="", c1="127i8", c2="32767i16", c3="2147483647i32", + c4="9223372036854775807i64", c5="11.12345f32", c6="22.123456789f64", c7="\"binaryColValue\"", + c8="L\"ncharColValue\"", c9="7u64", ts="1626006833639000000ns", cl_add_tag=None, + id_noexist_tag=None, id_change_tag=None, id_upper_tag=None, id_double_tag=None): + if stb_name == "": + stb_name = self.getLongName(len=6, mode="letters") + if tb_name == "": + tb_name = f'{stb_name}_{random.randint(0, 65535)}_{random.randint(0, 65535)}' + if t0 == "": + t0 = random.choice(["f", "F", "false", "False", "t", "T", "true", "True"]) + if c0 == "": + c0 = random.choice(["f", "F", "false", "False", "t", "T", "true", "True"]) + #sql_seq = f'{stb_name},id=\"{tb_name}\",t0={t0},t1=127i8,t2=32767i16,t3=125.22f64,t4=11.321f32,t5=11.12345f32,t6=22.123456789f64,t7=\"binaryTagValue\",t8=L\"ncharTagValue\" c0={bool_value},c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7=\"binaryValue\",c8=L\"ncharValue\" 1626006833639000000ns' + if id_upper_tag is not None: + id = "ID" + else: + id = "id" + sql_seq = f'{stb_name},{id}=\"{tb_name}\",t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6},c7={c7},c8={c8},c9={c9} {ts}' + if id_noexist_tag is not None: + sql_seq = f'{stb_name},t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6},c7={c7},c8={c8},c9={c9} {ts}' + if cl_add_tag is not None: + sql_seq = f'{stb_name},t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8},t9={t8} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6},c7={c7},c8={c8},c9={c9} {ts}' + if id_change_tag is not None: + sql_seq = f'{stb_name},t0={t0},t1={t1},{id}=\"{tb_name}\",t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6},c7={c7},c8={c8},c9={c9} {ts}' + if id_double_tag is not None: + sql_seq = f'{stb_name},{id}=\"{tb_name}_1\",t0={t0},t1={t1},{id}=\"{tb_name}_2\",t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6},c7={c7},c8={c8},c9={c9} {ts}' + if cl_add_tag is not None: + sql_seq = f'{stb_name},{id}=\"{tb_name}\",t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8},t11={t1},t10={t8} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6},c7={c7},c8={c8},c9={c9},c11={c8},c10={t0} {ts}' + return sql_seq, stb_name, tb_name + + def genMulTagColStr(self, genType, count): + """ + genType must be tag/col + """ + tag_str = "" + col_str = "" + if genType == "tag": + for i in range(0, count): + if i < (count-1): + tag_str += f't{i}=f,' + else: + tag_str += f't{i}=f ' + return tag_str + if genType == "col": + for i in range(0, count): + if i < (count-1): + col_str += f'c{i}=t,' + else: + col_str += f'c{i}=t ' + return col_str + + def genLongSql(self, tag_count, col_count): + stb_name = self.getLongName(7, mode="letters") + tb_name = f'{stb_name}_1' + tag_str = self.genMulTagColStr("tag", tag_count) + col_str = self.genMulTagColStr("col", col_count) + ts = "1626006833640000000ns" + long_sql = stb_name + ',' + f'id=\"{tb_name}\"' + ',' + tag_str + col_str + ts + return long_sql, stb_name + + def getNoIdTbName(self, stb_name): + query_sql = f"select tbname from {stb_name}" + tb_name = self.resHandle(query_sql, True)[0][0] + return tb_name + + def resHandle(self, query_sql, query_tag): + row_info = tdSql.query(query_sql, query_tag) + col_info = tdSql.getColNameList(query_sql, query_tag) + res_row_list = [] + sub_list = [] + for row_mem in row_info: + for i in row_mem: + sub_list.append(str(i)) + res_row_list.append(sub_list) + res_field_list_without_ts = col_info[0][1:] + res_type_list = col_info[1] + return res_row_list, res_field_list_without_ts, res_type_list + + def resCmp(self, input_sql, stb_name, query_sql="select * from", condition="", ts=None, id=True, none_check_tag=None): + expect_list = self.inputHandle(input_sql) + code = self._conn.insertLines([input_sql]) + print("insertLines result {}".format(code)) + query_sql = f"{query_sql} {stb_name} {condition}" + res_row_list, res_field_list_without_ts, res_type_list = self.resHandle(query_sql, True) + if ts == 0: + res_ts = self.dateToTs(res_row_list[0][0]) + current_time = time.time() + if current_time - res_ts < 60: + tdSql.checkEqual(res_row_list[0][1:], expect_list[0][1:]) + else: + print("timeout") + tdSql.checkEqual(res_row_list[0], expect_list[0]) + else: + if none_check_tag is not None: + none_index_list = [i for i,x in enumerate(res_row_list[0]) if x=="None"] + none_index_list.reverse() + for j in none_index_list: + res_row_list[0].pop(j) + expect_list[0].pop(j) + tdSql.checkEqual(res_row_list[0], expect_list[0]) + tdSql.checkEqual(res_field_list_without_ts, expect_list[1]) + tdSql.checkEqual(res_type_list, expect_list[2]) + + def initCheckCase(self): + """ + normal tags and cols, one for every elm + """ + input_sql, stb_name, tb_name = self.genFullTypeSql() + self.resCmp(input_sql, stb_name) + + def boolTypeCheckCase(self): + """ + check all normal type + """ + full_type_list = ["f", "F", "false", "False", "t", "T", "true", "True"] + for t_type in full_type_list: + input_sql, stb_name, tb_name = self.genFullTypeSql(c0=t_type, t0=t_type) + self.resCmp(input_sql, stb_name) + + def symbolsCheckCase(self): + """ + check symbols = `~!@#$%^&*()_-+={[}]\|:;'\",<.>/? + """ + ''' + please test : + binary_symbols = '\"abcd`~!@#$%^&*()_-{[}]|:;<.>?lfjal"\'\'"\"' + ''' + binary_symbols = '\"abcd`~!@#$%^&*()_-{[}]|:;<.>?lfjal"\"' + nchar_symbols = f'L{binary_symbols}' + input_sql, stb_name, tb_name = self.genFullTypeSql(c7=binary_symbols, c8=nchar_symbols, t7=binary_symbols, t8=nchar_symbols) + self.resCmp(input_sql, stb_name) + + def tsCheckCase(self): + """ + test ts list --> ["1626006833639000000ns", "1626006833639019us", "1626006833640ms", "1626006834s", "1626006822639022"] + # ! us级时间戳都为0时，数据库中查询显示，但python接口拿到的结果不显示 .000000的情况请确认，目前修改时间处理代码可以通过 + """ + ts_list = ["1626006833639000000ns", "1626006833639019us", "1626006833640ms", "1626006834s", "1626006822639022", 0] + for ts in ts_list: + input_sql, stb_name, tb_name = self.genFullTypeSql(ts=ts) + self.resCmp(input_sql, stb_name, ts) + + def idSeqCheckCase(self): + """ + check id.index in tags + eg: t0=**,id=**,t1=** + """ + input_sql, stb_name, tb_name = self.genFullTypeSql(id_change_tag=True) + self.resCmp(input_sql, stb_name) + + def idUpperCheckCase(self): + """ + check id param + eg: id and ID + """ + input_sql, stb_name, tb_name = self.genFullTypeSql(id_upper_tag=True) + self.resCmp(input_sql, stb_name) + input_sql, stb_name, tb_name = self.genFullTypeSql(id_change_tag=True, id_upper_tag=True) + self.resCmp(input_sql, stb_name) + + def noIdCheckCase(self): + """ + id not exist + """ + input_sql, stb_name, tb_name = self.genFullTypeSql(id_noexist_tag=True) + self.resCmp(input_sql, stb_name) + query_sql = f"select tbname from {stb_name}" + res_row_list = self.resHandle(query_sql, True)[0] + if len(res_row_list[0][0]) > 0: + tdSql.checkColNameList(res_row_list, res_row_list) + else: + tdSql.checkColNameList(res_row_list, "please check noIdCheckCase") + + # ! bug + # TODO confirm!!! + def maxColTagCheckCase(self): + """ + max tag count is 128 + max col count is ?? + """ + input_sql, stb_name = self.genLongSql(128, 4000) + print(input_sql) + code = self._conn.insertLines([input_sql]) + print("insertLines result {}".format(code)) + query_sql = f"describe {stb_name}" + insert_tag_col_num = len(self.resHandle(query_sql, True)[0]) + expected_num = 128 + 1023 + 1 + tdSql.checkEqual(insert_tag_col_num, expected_num) + + # input_sql, stb_name = self.genLongSql(128, 1500) + # code = self._conn.insertLines([input_sql]) + # print(f'code---{code}') + + def idIllegalNameCheckCase(self): + """ + test illegal id name + """ + rstr = list("!@#$%^&*()-+={}|[]\:<>?") + for i in rstr: + input_sql = self.genFullTypeSql(tb_name=f"\"aaa{i}bbb\"")[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + + def idStartWithNumCheckCase(self): + """ + id is start with num + """ + input_sql = self.genFullTypeSql(tb_name=f"\"1aaabbb\"")[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + + def nowTsCheckCase(self): + """ + check now unsupported + """ + input_sql = self.genFullTypeSql(ts="now")[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + + def dateFormatTsCheckCase(self): + """ + check date format ts unsupported + """ + input_sql = self.genFullTypeSql(ts="2021-07-21\ 19:01:46.920")[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + + def illegalTsCheckCase(self): + """ + check ts format like 16260068336390us19 + """ + input_sql = self.genFullTypeSql(ts="16260068336390us19")[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + + def tagValueLengthCheckCase(self): + """ + check full type tag value limit + """ + # i8 + for t1 in ["-127i8"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(t1=t1) + self.resCmp(input_sql, stb_name) + for t1 in ["-128i8", "128i8"]: + input_sql = self.genFullTypeSql(t1=t1)[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + + #i16 + for t2 in ["-32767i16"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(t2=t2) + self.resCmp(input_sql, stb_name) + for t2 in ["-32768i16", "32768i16"]: + input_sql = self.genFullTypeSql(t2=t2)[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + + #i32 + for t3 in ["-2147483647i32"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(t3=t3) + self.resCmp(input_sql, stb_name) + for t3 in ["-2147483648i32", "2147483648i32"]: + input_sql = self.genFullTypeSql(t3=t3)[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + + #i64 + for t4 in ["-9223372036854775807i64"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(t4=t4) + self.resCmp(input_sql, stb_name) + # ! 9223372036854775808i64 failed + # !for t4 in ["-9223372036854775808i64", "9223372036854775808i64"]: + # ! input_sql = self.genFullTypeSql(t4=t4)[0] + # ! code = self._conn.insertLines([input_sql]) + # ! tdSql.checkNotEqual(code, 0) + + # f32 + for t5 in ["-11.12345f32"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(t5=t5) + self.resCmp(input_sql, stb_name) + # TODO to confirm length + # #for t5 in [f"{-3.4028234663852886*(10**38)-1}f32", f"{3.4028234663852886*(10**38)+1}f32"]: + # for t5 in [f"{-3.4028234663852886*(10**38)-1}f32", f"{3.4028234663852886*(10**38)+1}f32"]: + # print("tag2") + # input_sql = self.genFullTypeSql(t5=t5)[0] + # print(input_sql) + # code = self._conn.insertLines([input_sql]) + # tdSql.checkNotEqual(code, 0) + + # f64 + for t6 in ["-22.123456789f64"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(t6=t6) + self.resCmp(input_sql, stb_name) + # TODO to confirm length + + # TODO binary nchar + + def colValueLengthCheckCase(self): + """ + check full type col value limit + """ + # i8 + for c1 in ["-127i8"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(c1=c1) + self.resCmp(input_sql, stb_name) + + # TODO to confirm + # for c1 in ["-131i8", "129i8"]: + # input_sql = self.genFullTypeSql(c1=c1)[0] + # print(input_sql) + # code = self._conn.insertLines([input_sql]) + # tdSql.checkNotEqual(code, 0) + + #i16 + for c2 in ["-32767i16"]: + print("tag1") + input_sql, stb_name, tb_name = self.genFullTypeSql(c2=c2) + self.resCmp(input_sql, stb_name) + for c2 in ["-32768i16", "32768i16"]: + input_sql = self.genFullTypeSql(c2=c2)[0] + print(input_sql) + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + + #i32 + for c3 in ["-2147483647i32"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(c3=c3) + self.resCmp(input_sql, stb_name) + for c3 in ["-2147483650i32", "2147483648i32"]: + input_sql = self.genFullTypeSql(c3=c3)[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + + #i64 + for c4 in ["-9223372036854775807i64"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(c4=c4) + self.resCmp(input_sql, stb_name) + # ! 9223372036854775808i64 failed + # !for c4 in ["-9223372036854775808i64", "9223372036854775808i64"]: + # ! input_sql = self.genFullTypeSql(c4=c4)[0] + # ! code = self._conn.insertLines([input_sql]) + # ! tdSql.checkNotEqual(code, 0) + + def tagColIllegalValueCheckCase(self): + """ + test illegal tag col value + """ + # bool + for i in ["TrUe", "tRue", "trUe", "truE", "FalsE", "fAlse", "faLse", "falSe", "falsE"]: + input_sql1 = self.genFullTypeSql(t0=i)[0] + code = self._conn.insertLines([input_sql1]) + tdSql.checkNotEqual(code, 0) + input_sql2 = self.genFullTypeSql(c0=i)[0] + code = self._conn.insertLines([input_sql2]) + tdSql.checkNotEqual(code, 0) + + # i8 i16 i32 i64 f32 f64 + for input_sql in [ + self.genFullTypeSql(t1="1s2i8")[0], + self.genFullTypeSql(t2="1s2i16")[0], + self.genFullTypeSql(t3="1s2i32")[0], + self.genFullTypeSql(t4="1s2i64")[0], + self.genFullTypeSql(t5="11.1s45f32")[0], + self.genFullTypeSql(t6="11.1s45f64")[0], + self.genFullTypeSql(c1="1s2i8")[0], + self.genFullTypeSql(c2="1s2i16")[0], + self.genFullTypeSql(c3="1s2i32")[0], + self.genFullTypeSql(c4="1s2i64")[0], + self.genFullTypeSql(c5="11.1s45f32")[0], + self.genFullTypeSql(c6="11.1s45f64")[0], + self.genFullTypeSql(c9="1s1u64")[0] + ]: + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + # TODO nchar binary + + def duplicateIdTagColInsertCheckCase(self): + """ + check duplicate Id Tag Col + """ + input_sql_id = self.genFullTypeSql(id_double_tag=True)[0] + code = self._conn.insertLines([input_sql_id]) + tdSql.checkNotEqual(code, 0) + + input_sql = self.genFullTypeSql()[0] + input_sql_tag = input_sql.replace("t5", "t6") + code = self._conn.insertLines([input_sql_tag]) + tdSql.checkNotEqual(code, 0) + + input_sql = self.genFullTypeSql()[0] + input_sql_col = input_sql.replace("c5", "c6") + code = self._conn.insertLines([input_sql_col]) + tdSql.checkNotEqual(code, 0) + + input_sql = self.genFullTypeSql()[0] + input_sql_col = input_sql.replace("c5", "C6") + code = self._conn.insertLines([input_sql_col]) + tdSql.checkNotEqual(code, 0) + + + + ##### stb exist ##### + def noIdStbExistCheckCase(self): + """ + case no id when stb exist + """ + input_sql, stb_name, tb_name = self.genFullTypeSql(t0="f", c0="f") + self.resCmp(input_sql, stb_name) + input_sql, stb_name, tb_name = self.genFullTypeSql(stb_name=stb_name, id_noexist_tag=True, t0="f", c0="f") + self.resCmp(input_sql, stb_name, condition='where tbname like "t_%"') + tdSql.query(f"select * from {stb_name}") + tdSql.checkRows(2) + # TODO cover other case + + def duplicateInsertExistCheckCase(self): + """ + check duplicate insert when stb exist + """ + input_sql, stb_name, tb_name = self.genFullTypeSql() + self.resCmp(input_sql, stb_name) + code = self._conn.insertLines([input_sql]) + tdSql.checkEqual(code, 0) + self.resCmp(input_sql, stb_name) + + def tagColBinaryNcharLengthCheckCase(self): + """ + check length increase + """ + input_sql, stb_name, tb_name = self.genFullTypeSql() + self.resCmp(input_sql, stb_name) + tb_name = self.getLongName(5, "letters") + input_sql, stb_name, tb_name = self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name,t7="\"binaryTagValuebinaryTagValue\"", t8="L\"ncharTagValuencharTagValue\"", c7="\"binaryTagValuebinaryTagValue\"", c8="L\"ncharTagValuencharTagValue\"") + self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"') + + # ! use tb_name + # ! bug + def tagColAddDupIDCheckCase(self): + """ + check column and tag count add, stb and tb duplicate + """ + input_sql, stb_name, tb_name = self.genFullTypeSql(t0="f", c0="f") + print(input_sql) + self.resCmp(input_sql, stb_name) + input_sql, stb_name, tb_name = self.genFullTypeSql(stb_name=stb_name, tb_name=f'{tb_name}', t0="f", c0="f", cl_add_tag=True) + print(input_sql) + self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"') + + def tagColAddCheckCase(self): + """ + check column and tag count add + """ + input_sql, stb_name, tb_name = self.genFullTypeSql(t0="f", c0="f") + self.resCmp(input_sql, stb_name) + input_sql, stb_name, tb_name_1 = self.genFullTypeSql(stb_name=stb_name, tb_name=f'{tb_name}_1', t0="f", c0="f", cl_add_tag=True) + 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] + tdSql.checkEqual(res_row_list[0], ['None', 'None', 'None', 'None']) + self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"', none_check_tag=True) + + def tagMd5Check(self): + """ + condition: stb not change + insert two table, keep tag unchange, change col + """ + input_sql, stb_name, tb_name = self.genFullTypeSql(t0="f", c0="f", id_noexist_tag=True) + self.resCmp(input_sql, stb_name) + tb_name1 = self.getNoIdTbName(stb_name) + input_sql, stb_name, tb_name = self.genFullTypeSql(stb_name=stb_name, t0="f", c0="f", id_noexist_tag=True) + self.resCmp(input_sql, stb_name) + tb_name2 = self.getNoIdTbName(stb_name) + tdSql.query(f"select * from {stb_name}") + tdSql.checkRows(1) + tdSql.checkEqual(tb_name1, tb_name2) + input_sql, stb_name, tb_name = self.genFullTypeSql(stb_name=stb_name, t0="f", c0="f", id_noexist_tag=True, cl_add_tag=True) + self._conn.insertLines([input_sql]) + tb_name3 = self.getNoIdTbName(stb_name) + tdSql.query(f"select * from {stb_name}") + tdSql.checkRows(2) + tdSql.checkNotEqual(tb_name1, tb_name3) + + # TODO tag binary max is 16379, col binary max??? 16379 + def tagColBinaryMaxLengthCheckCase(self): + stb_name = self.getLongName(7, "letters") + tb_name = f'{stb_name}_1' + input_sql = f'{stb_name},id="{tb_name}",t0=t c0=f 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16374, "letters")}",t2="{self.getLongName(5, "letters")}" c0=f 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkEqual(code, 0) + input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}",c2="{self.getLongName(16374, "letters")}",c3="{self.getLongName(16374, "letters")}" 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkEqual(code, 0) + + # TODO tag nchar max is 16379, col binary max??? + def tagColNcharMaxLengthCheckCase(self): + stb_name = self.getLongName(7, "letters") + tb_name = f'{stb_name}_1' + input_sql = f'{stb_name},id="{tb_name}",t0=t c0=f 1626006833639000000ns' + print(input_sql) + code = self._conn.insertLines([input_sql]) + # input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}" c0=f 1626006833639000000ns' + input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}",t2=L"{self.getLongName(1, "letters")}" c0=f 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkEqual(code, 0) + input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}",t2=L"{self.getLongName(2, "letters")}" c0=f 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + + # ! rollback bug + # TODO because it is no rollback now, so stb has been broken, create a new! + stb_name = self.getLongName(7, "letters") + tb_name = f'{stb_name}_1' + input_sql = f'{stb_name},id="{tb_name}",t0=t c0=f 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + input_sql = f'{stb_name},t0=t c0=f,c1=L"{self.getLongName(4093, "letters")}",c2=L"{self.getLongName(4093, "letters")}",c3=L"{self.getLongName(4093, "letters")}" 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkEqual(code, 0) + + def batchInsertCheckCase(self): + """ + test batch insert + """ + stb_name = self.getLongName(8, "letters") + 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", + f"{stb_name},t2=5f64,t3=L\"ste\" c1=true,c2=4i64,c3=\"iam\" 1626056811823316532ns", + "stf567890,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64,c6=7u64 1626006933640000000ns", + "st123456,t1=4i64,t2=5f64,t3=\"t4\" c1=3i64,c3=L\"passitagain\",c2=true,c4=5f64 1626006833642000000ns", + f"{stb_name},t2=5f64,t3=L\"ste2\" c3=\"iamszhou\",c4=false 1626056811843316532ns", + f"{stb_name},t2=5f64,t3=L\"ste2\" c3=\"iamszhou\",c4=false,c5=32i8,c6=64i16,c7=32i32,c8=88.88f32 1626056812843316532ns", + "st123456,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64,c6=7u64 1626006933640000000ns", + "st123456,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin_stf\",c2=false,c5=5f64,c6=7u64 1626006933641000000ns" + ] + code = self._conn.insertLines(lines) + tdSql.checkEqual(code, 0) + + # ! bug + def batchErrorInsertCheckCase(self): + """ + test batch error insert + """ + stb_name = self.getLongName(8, "letters") + lines = ["st123456,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000ns", + f"{stb_name},t2=5f64,t3=L\"ste\" c1=tRue,c2=4i64,c3=\"iam\" 1626056811823316532ns", + ] + code = self._conn.insertLines(lines) + # tdSql.checkEqual(code, 0) + + def run(self): + print("running {}".format(__file__)) + tdSql.execute("drop database if exists test") + tdSql.execute("create database if not exists test precision 'us'") + tdSql.execute('use test') + # tdSql.execute("create table super_table_cname_check (ts timestamp, pi1 int, pi2 bigint, pf1 float, pf2 double, ps1 binary(10), pi3 smallint, pi4 tinyint, pb1 bool, ps2 nchar(20)) tags (si1 int, si2 bigint, sf1 float, sf2 double, ss1 binary(10), si3 smallint, si4 tinyint, sb1 bool, ss2 nchar(20));") + # tdSql.execute('create table st1 using super_table_cname_check tags (1, 2, 1.1, 2.2, "a", 1, 1, true, "aa");') + # tdSql.execute('insert into st1 values (now, 1, 2, 1.1, 2.2, "a", 1, 1, true, "aa");') + + # self.initCheckCase() + # self.boolTypeCheckCase() + # 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() + + # ! rollback bug + # self.tagColBinaryMaxLengthCheckCase() + # self.tagColNcharMaxLengthCheckCase() + + # self.batchInsertCheckCase() + + # ! bug + # ! self.batchErrorInsertCheckCase() + + + + + + # tdSql.execute('create stable ste(ts timestamp, f int) tags(t1 bigint)') + + # lines = [ "st,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000ns", + # "st,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64 1626006833640000000ns", + # "ste,t2=5f64,t3=L\"ste\" c1=true,c2=4i64,c3=\"iam\" 1626056811823316532ns", + # "stf,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64,c6=7u64 1626006933640000000ns", + # "st,t1=4i64,t2=5f64,t3=\"t4\" c1=3i64,c3=L\"passitagain\",c2=true,c4=5f64 1626006833642000000ns", + # "ste,t2=5f64,t3=L\"ste2\" c3=\"iamszhou\",c4=false 1626056811843316532ns", + # "ste,t2=5f64,t3=L\"ste2\" c3=\"iamszhou\",c4=false,c5=32i8,c6=64i16,c7=32i32,c8=88.88f32 1626056812843316532ns", + # "st,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64,c6=7u64 1626006933640000000ns", + # "stf,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin_stf\",c2=false,c5=5f64,c6=7u64 1626006933641000000ns" + # ] + + # code = self._conn.insertLines(lines) + # print("insertLines result {}".format(code)) + + # lines2 = [ "stg,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000ns", + # "stg,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64 1626006833640000000ns" + # ] + + # code = self._conn.insertLines([ lines2[0] ]) + # print("insertLines result {}".format(code)) + + # self._conn.insertLines([ lines2[1] ]) + # print("insertLines result {}".format(code)) + + # tdSql.query("select * from st") + # tdSql.checkRows(4) + + # tdSql.query("select * from ste") + # tdSql.checkRows(3) + + # tdSql.query("select * from stf") + # tdSql.checkRows(2) + + # tdSql.query("select * from stg") + # tdSql.checkRows(2) + + # tdSql.query("show tables") + # tdSql.checkRows(8) + + # tdSql.query("describe stf") + # tdSql.checkData(2, 2, 14) + + # self._conn.insertLines([ + # "sth,t1=4i64,t2=5f64,t4=5f64,ID=\"childtable\" c1=3i64,c3=L\"passitagin_stf\",c2=false,c5=5f64,c6=7u64 1626006933641ms", + # "sth,t1=4i64,t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin_stf\",c2=false,c5=5f64,c6=7u64 1626006933654ms" + # ]) + # tdSql.query('select tbname, * from sth') + # tdSql.checkRows(2) + + # tdSql.query('select tbname, * from childtable') + # tdSql.checkRows(1) + def stop(self): + tdSql.close() + tdLog.success("%s successfully executed" % __file__) + + +tdCases.addLinux(__file__, TDTestCase()) diff --git a/tests/pytest/util/sql.py b/tests/pytest/util/sql.py index 4eb0c8f857..795af8a1f8 100644 --- a/tests/pytest/util/sql.py +++ b/tests/pytest/util/sql.py @@ -65,7 +65,7 @@ class TDSql: self.queryResult = None tdLog.info("sql:%s, expect error occured" % (sql)) - def query(self, sql): + def query(self, sql, row_tag=None): self.sql = sql try: self.cursor.execute(sql) @@ -77,21 +77,27 @@ class TDSql: args = (caller.filename, caller.lineno, sql, repr(e)) tdLog.notice("%s(%d) failed: sql:%s, %s" % args) raise Exception(repr(e)) + if row_tag: + return self.queryResult return self.queryRows - def getColNameList(self, sql): + def getColNameList(self, sql, col_tag=None): self.sql = sql try: col_name_list = [] + col_type_list = [] self.cursor.execute(sql) self.queryCols = self.cursor.description for query_col in self.queryCols: col_name_list.append(query_col[0]) + col_type_list.append(query_col[1]) except Exception as e: caller = inspect.getframeinfo(inspect.stack()[1][0]) args = (caller.filename, caller.lineno, sql, repr(e)) tdLog.notice("%s(%d) failed: sql:%s, %s" % args) raise Exception(repr(e)) + if col_tag: + return col_name_list, col_type_list return col_name_list def waitedQuery(self, sql, expectRows, timeout): @@ -232,6 +238,22 @@ class TDSql: args = (caller.filename, caller.lineno, self.sql, col_name_list, expect_col_name_list) tdLog.exit("%s(%d) failed: sql:%s, col_name_list:%s != expect_col_name_list:%s" % args) + def checkEqual(self, elm, expect_elm): + if elm == expect_elm: + tdLog.info("sql:%s, elm:%s == expect_elm:%s" % (self.sql, elm, expect_elm)) + else: + caller = inspect.getframeinfo(inspect.stack()[1][0]) + args = (caller.filename, caller.lineno, self.sql, elm, expect_elm) + tdLog.exit("%s(%d) failed: sql:%s, elm:%s != expect_elm:%s" % args) + + def checkNotEqual(self, elm, expect_elm): + if elm != expect_elm: + tdLog.info("sql:%s, elm:%s != expect_elm:%s" % (self.sql, elm, expect_elm)) + else: + caller = inspect.getframeinfo(inspect.stack()[1][0]) + args = (caller.filename, caller.lineno, self.sql, elm, expect_elm) + tdLog.exit("%s(%d) failed: sql:%s, elm:%s == expect_elm:%s" % args) + def taosdStatus(self, state): tdLog.sleep(5) pstate = 0 From 58812433106334969ba4dde2c1f21964db5ed7d7 Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Fri, 23 Jul 2021 14:29:16 +0800 Subject: [PATCH 02/31] save --- tests/pytest/insert/schemalessInsert.py | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index b09c153bf6..7bdcbf19d1 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -694,18 +694,19 @@ class TDTestCase: tdSql.checkRows(2) tdSql.checkNotEqual(tb_name1, tb_name3) - # TODO tag binary max is 16379, col binary max??? 16379 + # TODO tag binary max is 16380, col+ts binary max??? 49143 def tagColBinaryMaxLengthCheckCase(self): stb_name = self.getLongName(7, "letters") tb_name = f'{stb_name}_1' input_sql = f'{stb_name},id="{tb_name}",t0=t c0=f 1626006833639000000ns' code = self._conn.insertLines([input_sql]) - input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16374, "letters")}",t2="{self.getLongName(5, "letters")}" c0=f 1626006833639000000ns' - code = self._conn.insertLines([input_sql]) - tdSql.checkEqual(code, 0) - input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}",c2="{self.getLongName(16374, "letters")}",c3="{self.getLongName(16374, "letters")}" 1626006833639000000ns' + # input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16374, "letters")}",t2="{self.getLongName(6, "letters")}" c0=f,c1="{self.getLongName(16374, "letters")}",c2="{self.getLongName(16374, "letters")}",c3="{self.getLongName(16374, "letters")}",c4="{self.getLongName(12, "letters")}" 1626006833639000000ns' + input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16374, "letters")}",t2="{self.getLongName(6, "letters")}" c0=f 1626006833639000000ns' code = self._conn.insertLines([input_sql]) tdSql.checkEqual(code, 0) + # input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}",c2="{self.getLongName(16374, "letters")}",c3="{self.getLongName(16374, "letters")}" 1626006833639000000ns' + # code = self._conn.insertLines([input_sql]) + # tdSql.checkEqual(code, 0) # TODO tag nchar max is 16379, col binary max??? def tagColNcharMaxLengthCheckCase(self): @@ -715,12 +716,12 @@ class TDTestCase: print(input_sql) code = self._conn.insertLines([input_sql]) # input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}" c0=f 1626006833639000000ns' - input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}",t2=L"{self.getLongName(1, "letters")}" c0=f 1626006833639000000ns' + input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4094, "letters")}",t2=L"{self.getLongName(1, "letters")}" c0=f 1626006833639000000ns' code = self._conn.insertLines([input_sql]) tdSql.checkEqual(code, 0) - input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}",t2=L"{self.getLongName(2, "letters")}" c0=f 1626006833639000000ns' - code = self._conn.insertLines([input_sql]) - tdSql.checkNotEqual(code, 0) + # input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}",t2=L"{self.getLongName(2, "letters")}" c0=f 1626006833639000000ns' + # code = self._conn.insertLines([input_sql]) + # tdSql.checkNotEqual(code, 0) # ! rollback bug # TODO because it is no rollback now, so stb has been broken, create a new! @@ -763,6 +764,9 @@ class TDTestCase: code = self._conn.insertLines(lines) # tdSql.checkEqual(code, 0) + def stbInsertMultiThreadCheckCase(self): + pass + def run(self): print("running {}".format(__file__)) tdSql.execute("drop database if exists test") @@ -807,7 +811,7 @@ class TDTestCase: # self.batchInsertCheckCase() # ! bug - # ! self.batchErrorInsertCheckCase() + # self.batchErrorInsertCheckCase() From 0224dd10565fb568ec8165ef3781c65036d88e78 Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Fri, 23 Jul 2021 15:35:19 +0800 Subject: [PATCH 03/31] save --- tests/pytest/insert/schemalessInsert.py | 25 +++++++++++++++++++------ 1 file changed, 19 insertions(+), 6 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index 7bdcbf19d1..3ec250def1 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -694,21 +694,34 @@ class TDTestCase: tdSql.checkRows(2) tdSql.checkNotEqual(tb_name1, tb_name3) - # TODO tag binary max is 16380, col+ts binary max??? 49143 + # ? tag binary max is 16384, col+ts binary max 49151 def tagColBinaryMaxLengthCheckCase(self): + """ + # ? case finish , src bug exist + every binary and nchar must be length+2, so + """ stb_name = self.getLongName(7, "letters") tb_name = f'{stb_name}_1' input_sql = f'{stb_name},id="{tb_name}",t0=t c0=f 1626006833639000000ns' code = self._conn.insertLines([input_sql]) - # input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16374, "letters")}",t2="{self.getLongName(6, "letters")}" c0=f,c1="{self.getLongName(16374, "letters")}",c2="{self.getLongName(16374, "letters")}",c3="{self.getLongName(16374, "letters")}",c4="{self.getLongName(12, "letters")}" 1626006833639000000ns' - input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16374, "letters")}",t2="{self.getLongName(6, "letters")}" c0=f 1626006833639000000ns' + + # * 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="{self.getLongName(16374, "letters")}",t2="{self.getLongName(5, "letters")}" c0=f 1626006833639000000ns' code = self._conn.insertLines([input_sql]) tdSql.checkEqual(code, 0) - # input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}",c2="{self.getLongName(16374, "letters")}",c3="{self.getLongName(16374, "letters")}" 1626006833639000000ns' + input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16374, "letters")}",t2="{self.getLongName(6, "letters")}" c0=f 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + + # * check col，col+ts max in describe ---> 16143 + # input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}",c2="{self.getLongName(16374, "letters")}",c3="{self.getLongName(16374, "letters")}",c4="{self.getLongName(12, "letters")}" 1626006833639000000ns' # code = self._conn.insertLines([input_sql]) # tdSql.checkEqual(code, 0) + # input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}",c2="{self.getLongName(16374, "letters")}",c3="{self.getLongName(16374, "letters")}",c4="{self.getLongName(13, "letters")}" 1626006833639000000ns' + # code = self._conn.insertLines([input_sql]) + # tdSql.checkNotEqual(code, 0) - # TODO tag nchar max is 16379, col binary max??? + # ? tag nchar max is 16384, col+ts nchar max 49151 def tagColNcharMaxLengthCheckCase(self): stb_name = self.getLongName(7, "letters") tb_name = f'{stb_name}_1' @@ -805,7 +818,7 @@ class TDTestCase: # self.tagMd5Check() # ! rollback bug - # self.tagColBinaryMaxLengthCheckCase() + self.tagColBinaryMaxLengthCheckCase() # self.tagColNcharMaxLengthCheckCase() # self.batchInsertCheckCase() From c572b1345e850018917ed1f0912c20ac0df278bb Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Fri, 23 Jul 2021 16:01:12 +0800 Subject: [PATCH 04/31] save --- tests/pytest/insert/schemalessInsert.py | 42 ++++++++++++------------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index 3ec250def1..625726a22a 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -714,37 +714,37 @@ class TDTestCase: tdSql.checkNotEqual(code, 0) # * check col，col+ts max in describe ---> 16143 - # input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}",c2="{self.getLongName(16374, "letters")}",c3="{self.getLongName(16374, "letters")}",c4="{self.getLongName(12, "letters")}" 1626006833639000000ns' - # code = self._conn.insertLines([input_sql]) - # tdSql.checkEqual(code, 0) - # input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}",c2="{self.getLongName(16374, "letters")}",c3="{self.getLongName(16374, "letters")}",c4="{self.getLongName(13, "letters")}" 1626006833639000000ns' - # code = self._conn.insertLines([input_sql]) - # tdSql.checkNotEqual(code, 0) + input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}",c2="{self.getLongName(16374, "letters")}",c3="{self.getLongName(16374, "letters")}",c4="{self.getLongName(12, "letters")}" 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkEqual(code, 0) + input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}",c2="{self.getLongName(16374, "letters")}",c3="{self.getLongName(16374, "letters")}",c4="{self.getLongName(13, "letters")}" 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) # ? tag nchar max is 16384, col+ts nchar max 49151 def tagColNcharMaxLengthCheckCase(self): stb_name = self.getLongName(7, "letters") tb_name = f'{stb_name}_1' input_sql = f'{stb_name},id="{tb_name}",t0=t c0=f 1626006833639000000ns' - print(input_sql) code = self._conn.insertLines([input_sql]) - # input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}" c0=f 1626006833639000000ns' - input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4094, "letters")}",t2=L"{self.getLongName(1, "letters")}" c0=f 1626006833639000000ns' + + # * legal nchar could not be larger than 16374/4 + input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}",t2=L"{self.getLongName(1, "letters")}" c0=f 1626006833639000000ns' code = self._conn.insertLines([input_sql]) tdSql.checkEqual(code, 0) - # input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}",t2=L"{self.getLongName(2, "letters")}" c0=f 1626006833639000000ns' - # code = self._conn.insertLines([input_sql]) - # tdSql.checkNotEqual(code, 0) + input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}",t2=L"{self.getLongName(2, "letters")}" c0=f 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) # ! rollback bug # TODO because it is no rollback now, so stb has been broken, create a new! - stb_name = self.getLongName(7, "letters") - tb_name = f'{stb_name}_1' - input_sql = f'{stb_name},id="{tb_name}",t0=t c0=f 1626006833639000000ns' - code = self._conn.insertLines([input_sql]) - input_sql = f'{stb_name},t0=t c0=f,c1=L"{self.getLongName(4093, "letters")}",c2=L"{self.getLongName(4093, "letters")}",c3=L"{self.getLongName(4093, "letters")}" 1626006833639000000ns' - code = self._conn.insertLines([input_sql]) - tdSql.checkEqual(code, 0) + # stb_name = self.getLongName(7, "letters") + # tb_name = f'{stb_name}_1' + # input_sql = f'{stb_name},id="{tb_name}",t0=t c0=f 1626006833639000000ns' + # code = self._conn.insertLines([input_sql]) + # input_sql = f'{stb_name},t0=t c0=f,c1=L"{self.getLongName(4093, "letters")}",c2=L"{self.getLongName(4093, "letters")}",c3=L"{self.getLongName(4093, "letters")}" 1626006833639000000ns' + # code = self._conn.insertLines([input_sql]) + # tdSql.checkEqual(code, 0) def batchInsertCheckCase(self): """ @@ -818,8 +818,8 @@ class TDTestCase: # self.tagMd5Check() # ! rollback bug - self.tagColBinaryMaxLengthCheckCase() - # self.tagColNcharMaxLengthCheckCase() + # self.tagColBinaryMaxLengthCheckCase() + self.tagColNcharMaxLengthCheckCase() # self.batchInsertCheckCase() From 80afed6706b844cc3c293993177d94e8dd59610a Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Fri, 23 Jul 2021 17:12:41 +0800 Subject: [PATCH 05/31] save --- tests/pytest/insert/schemalessInsert.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index 625726a22a..d1291d7dc8 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -11,7 +11,6 @@ # -*- coding: utf-8 -*- -import sys import random import string import time @@ -21,6 +20,7 @@ import numpy as np from util.log import * from util.cases import * from util.sql import * +import threading class TDTestCase: @@ -818,8 +818,8 @@ class TDTestCase: # self.tagMd5Check() # ! rollback bug - # self.tagColBinaryMaxLengthCheckCase() - self.tagColNcharMaxLengthCheckCase() + self.tagColBinaryMaxLengthCheckCase() + # self.tagColNcharMaxLengthCheckCase() # self.batchInsertCheckCase() From 90ecf82d540529cf71a20b55c3f3f25b892c3071 Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Fri, 23 Jul 2021 18:31:38 +0800 Subject: [PATCH 06/31] save --- tests/pytest/insert/schemalessInsert.py | 31 ++++++++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index d1291d7dc8..d1c1dd6519 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -713,7 +713,7 @@ class TDTestCase: code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) - # * check col，col+ts max in describe ---> 16143 + # # * check col，col+ts max in describe ---> 16143 input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}",c2="{self.getLongName(16374, "letters")}",c3="{self.getLongName(16374, "letters")}",c4="{self.getLongName(12, "letters")}" 1626006833639000000ns' code = self._conn.insertLines([input_sql]) tdSql.checkEqual(code, 0) @@ -777,6 +777,35 @@ class TDTestCase: code = self._conn.insertLines(lines) # tdSql.checkEqual(code, 0) + def genSqlList(self, count=5): + """ + stb --> supertable + tb --> table + ts --> timestamp + col --> column + tag --> tag + d --> different + s --> same + """ + d_stb_d_tb_list = list() + for i in range(count): + d_stb_d_tb_list.append(self.genFullTypeSql(t0="f", c0="f")) + + return d_stb_d_tb_list, + + def genMultiThreadSeq(self, sql_list): + tlist = list() + for insert_sql in sql_list: + t = threading.Thread(target=self._conn.insertLines,args=insert_sql) + tlist.append(t) + return tlist + + def multiThreadRun(self, tlist): + for t in tlist: + t.start() + for t in tlist: + t.join() + def stbInsertMultiThreadCheckCase(self): pass From 5d9c380788848792ceb175b55c7e9c659c6b8957 Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Fri, 23 Jul 2021 19:01:44 +0800 Subject: [PATCH 07/31] save --- tests/pytest/insert/schemalessInsert.py | 26 +++++++++++++++---------- 1 file changed, 16 insertions(+), 10 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index d1c1dd6519..cfce8da63e 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -717,9 +717,11 @@ class TDTestCase: input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}",c2="{self.getLongName(16374, "letters")}",c3="{self.getLongName(16374, "letters")}",c4="{self.getLongName(12, "letters")}" 1626006833639000000ns' code = self._conn.insertLines([input_sql]) tdSql.checkEqual(code, 0) - input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}",c2="{self.getLongName(16374, "letters")}",c3="{self.getLongName(16374, "letters")}",c4="{self.getLongName(13, "letters")}" 1626006833639000000ns' - code = self._conn.insertLines([input_sql]) - tdSql.checkNotEqual(code, 0) + # input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}",c2="{self.getLongName(16374, "letters")}",c3="{self.getLongName(16374, "letters")}",c4="{self.getLongName(13, "letters")}" 1626006833639000000ns' + # print(input_sql) + # code = self._conn.insertLines([input_sql]) + # print(code) + # tdSql.checkNotEqual(code, 0) # ? tag nchar max is 16384, col+ts nchar max 49151 def tagColNcharMaxLengthCheckCase(self): @@ -772,8 +774,7 @@ class TDTestCase: """ stb_name = self.getLongName(8, "letters") lines = ["st123456,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000ns", - f"{stb_name},t2=5f64,t3=L\"ste\" c1=tRue,c2=4i64,c3=\"iam\" 1626056811823316532ns", - ] + f"{stb_name},t2=5f64,t3=L\"ste\" c1=tRue,c2=4i64,c3=\"iam\" 1626056811823316532ns"] code = self._conn.insertLines(lines) # tdSql.checkEqual(code, 0) @@ -781,17 +782,22 @@ class TDTestCase: """ stb --> supertable tb --> table - ts --> timestamp - col --> column - tag --> tag + ts --> timestamp, same default + col --> column, same default + tag --> tag, same default d --> different s --> same + a --> add + m --> minus """ d_stb_d_tb_list = list() + s_stb_s_tb_list = list() + s_stb_s_tb_a_col_a_tag_list = list() for i in range(count): d_stb_d_tb_list.append(self.genFullTypeSql(t0="f", c0="f")) - - return d_stb_d_tb_list, + s_stb_s_tb_list.append(self.genFullTypeSql(t7=f'"{self.getLongName(8, "letters")}"', c7=f'{self.getLongName(8, "letters")}"', cl_add_tag=True)) + s_stb_s_tb_a_col_a_tag_list.append(self.genFullTypeSql(t7=f'"{self.getLongName(8, "letters")}"', c7=f'{self.getLongName(8, "letters")}"')) + return d_stb_d_tb_list, s_stb_s_tb_list, s_stb_s_tb_a_col_a_tag_list def genMultiThreadSeq(self, sql_list): tlist = list() From 9a94a39b292c81fb615ccfbcf495daad27a00527 Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Fri, 23 Jul 2021 19:24:23 +0800 Subject: [PATCH 08/31] save --- tests/pytest/insert/schemalessInsert.py | 27 ++++++++++++++++--------- 1 file changed, 18 insertions(+), 9 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index cfce8da63e..60695fbf8c 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -216,8 +216,9 @@ class TDTestCase: t4="9223372036854775807i64", t5="11.12345f32", t6="22.123456789f64", t7="\"binaryTagValue\"", t8="L\"ncharTagValue\"", c0="", c1="127i8", c2="32767i16", c3="2147483647i32", c4="9223372036854775807i64", c5="11.12345f32", c6="22.123456789f64", c7="\"binaryColValue\"", - c8="L\"ncharColValue\"", c9="7u64", ts="1626006833639000000ns", cl_add_tag=None, - id_noexist_tag=None, id_change_tag=None, id_upper_tag=None, id_double_tag=None): + c8="L\"ncharColValue\"", c9="7u64", ts="1626006833639000000ns", + id_noexist_tag=None, id_change_tag=None, id_upper_tag=None, id_double_tag=None, + ct_add_tag=None, ct_am_tag=None, ct_ma_tag=None, ct_min_tag=None): if stb_name == "": stb_name = self.getLongName(len=6, mode="letters") if tb_name == "": @@ -234,14 +235,20 @@ class TDTestCase: sql_seq = f'{stb_name},{id}=\"{tb_name}\",t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6},c7={c7},c8={c8},c9={c9} {ts}' if id_noexist_tag is not None: sql_seq = f'{stb_name},t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6},c7={c7},c8={c8},c9={c9} {ts}' - if cl_add_tag is not None: + if ct_add_tag is not None: sql_seq = f'{stb_name},t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8},t9={t8} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6},c7={c7},c8={c8},c9={c9} {ts}' if id_change_tag is not None: sql_seq = f'{stb_name},t0={t0},t1={t1},{id}=\"{tb_name}\",t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6},c7={c7},c8={c8},c9={c9} {ts}' if id_double_tag is not None: sql_seq = f'{stb_name},{id}=\"{tb_name}_1\",t0={t0},t1={t1},{id}=\"{tb_name}_2\",t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6},c7={c7},c8={c8},c9={c9} {ts}' - if cl_add_tag is not None: + if ct_add_tag is not None: sql_seq = f'{stb_name},{id}=\"{tb_name}\",t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8},t11={t1},t10={t8} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6},c7={c7},c8={c8},c9={c9},c11={c8},c10={t0} {ts}' + if ct_am_tag is not None: + sql_seq = f'{stb_name},{id}=\"{tb_name}\",t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6},c7={c7},c8={c8},c9={c9},c11={c8},c10={t0} {ts}' + if ct_ma_tag is not None: + sql_seq = f'{stb_name},{id}=\"{tb_name}\",t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8},t11={t1},t10={t8} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6} {ts}' + if ct_min_tag is not None: + sql_seq = f'{stb_name},{id}=\"{tb_name}\",t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6} {ts}' return sql_seq, stb_name, tb_name def genMulTagColStr(self, genType, count): @@ -657,7 +664,7 @@ class TDTestCase: input_sql, stb_name, tb_name = self.genFullTypeSql(t0="f", c0="f") print(input_sql) self.resCmp(input_sql, stb_name) - input_sql, stb_name, tb_name = self.genFullTypeSql(stb_name=stb_name, tb_name=f'{tb_name}', t0="f", c0="f", cl_add_tag=True) + input_sql, stb_name, tb_name = self.genFullTypeSql(stb_name=stb_name, tb_name=f'{tb_name}', t0="f", c0="f", ct_add_tag=True) print(input_sql) self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"') @@ -667,7 +674,7 @@ class TDTestCase: """ input_sql, stb_name, tb_name = self.genFullTypeSql(t0="f", c0="f") self.resCmp(input_sql, stb_name) - input_sql, stb_name, tb_name_1 = self.genFullTypeSql(stb_name=stb_name, tb_name=f'{tb_name}_1', t0="f", c0="f", cl_add_tag=True) + input_sql, stb_name, tb_name_1 = self.genFullTypeSql(stb_name=stb_name, tb_name=f'{tb_name}_1', t0="f", c0="f", ct_add_tag=True) 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] tdSql.checkEqual(res_row_list[0], ['None', 'None', 'None', 'None']) @@ -687,7 +694,7 @@ class TDTestCase: tdSql.query(f"select * from {stb_name}") tdSql.checkRows(1) tdSql.checkEqual(tb_name1, tb_name2) - input_sql, stb_name, tb_name = self.genFullTypeSql(stb_name=stb_name, t0="f", c0="f", id_noexist_tag=True, cl_add_tag=True) + input_sql, stb_name, tb_name = self.genFullTypeSql(stb_name=stb_name, t0="f", c0="f", id_noexist_tag=True, ct_add_tag=True) self._conn.insertLines([input_sql]) tb_name3 = self.getNoIdTbName(stb_name) tdSql.query(f"select * from {stb_name}") @@ -793,10 +800,12 @@ class TDTestCase: d_stb_d_tb_list = list() s_stb_s_tb_list = list() s_stb_s_tb_a_col_a_tag_list = list() + s_stb_s_tb_m_col_m_tag_list = list() for i in range(count): d_stb_d_tb_list.append(self.genFullTypeSql(t0="f", c0="f")) - s_stb_s_tb_list.append(self.genFullTypeSql(t7=f'"{self.getLongName(8, "letters")}"', c7=f'{self.getLongName(8, "letters")}"', cl_add_tag=True)) - s_stb_s_tb_a_col_a_tag_list.append(self.genFullTypeSql(t7=f'"{self.getLongName(8, "letters")}"', c7=f'{self.getLongName(8, "letters")}"')) + s_stb_s_tb_list.append(self.genFullTypeSql(t7=f'"{self.getLongName(8, "letters")}"', c7=f'{self.getLongName(8, "letters")}"')) + s_stb_s_tb_a_col_a_tag_list.append(self.genFullTypeSql(t7=f'"{self.getLongName(8, "letters")}"', c7=f'{self.getLongName(8, "letters")}"'), ct_add_tag=True) + s_stb_s_tb_m_col_m_tag_list.append(self.genFullTypeSql(t7=f'"{self.getLongName(8, "letters")}"', c7=f'{self.getLongName(8, "letters")}"'), ct_min_tag=True) return d_stb_d_tb_list, s_stb_s_tb_list, s_stb_s_tb_a_col_a_tag_list def genMultiThreadSeq(self, sql_list): From cb7e26845b4a0ed181820563266b077cbd52e84b Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Sat, 24 Jul 2021 10:22:02 +0800 Subject: [PATCH 09/31] save --- tests/pytest/insert/schemalessInsert.py | 30 ++++++++++++------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index 60695fbf8c..ed8e7ba103 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -491,17 +491,17 @@ class TDTestCase: for t4 in ["-9223372036854775807i64"]: input_sql, stb_name, tb_name = self.genFullTypeSql(t4=t4) self.resCmp(input_sql, stb_name) - # ! 9223372036854775808i64 failed - # !for t4 in ["-9223372036854775808i64", "9223372036854775808i64"]: - # ! input_sql = self.genFullTypeSql(t4=t4)[0] - # ! code = self._conn.insertLines([input_sql]) - # ! tdSql.checkNotEqual(code, 0) + #! 9223372036854775808i64 failed + for t4 in ["-9223372036854775808i64", "9223372036854775808i64"]: + input_sql = self.genFullTypeSql(t4=t4)[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) # f32 - for t5 in ["-11.12345f32"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(t5=t5) - self.resCmp(input_sql, stb_name) - # TODO to confirm length + # for t5 in ["-11.12345f32"]: + # input_sql, stb_name, tb_name = self.genFullTypeSql(t5=t5) + # self.resCmp(input_sql, stb_name) + # # TODO to confirm length # #for t5 in [f"{-3.4028234663852886*(10**38)-1}f32", f"{3.4028234663852886*(10**38)+1}f32"]: # for t5 in [f"{-3.4028234663852886*(10**38)-1}f32", f"{3.4028234663852886*(10**38)+1}f32"]: # print("tag2") @@ -510,10 +510,10 @@ class TDTestCase: # code = self._conn.insertLines([input_sql]) # tdSql.checkNotEqual(code, 0) - # f64 - for t6 in ["-22.123456789f64"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(t6=t6) - self.resCmp(input_sql, stb_name) + # # f64 + # for t6 in ["-22.123456789f64"]: + # input_sql, stb_name, tb_name = self.genFullTypeSql(t6=t6) + # self.resCmp(input_sql, stb_name) # TODO to confirm length # TODO binary nchar @@ -846,7 +846,7 @@ class TDTestCase: # self.nowTsCheckCase() # self.dateFormatTsCheckCase() # self.illegalTsCheckCase() - # self.tagValueLengthCheckCase() + self.tagValueLengthCheckCase() # ! 问题很多 # ! self.colValueLengthCheckCase() @@ -862,7 +862,7 @@ class TDTestCase: # self.tagMd5Check() # ! rollback bug - self.tagColBinaryMaxLengthCheckCase() + # self.tagColBinaryMaxLengthCheckCase() # self.tagColNcharMaxLengthCheckCase() # self.batchInsertCheckCase() From 7b883b2637cd7b3fc05f544095945f2b463847d1 Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Sat, 24 Jul 2021 15:38:35 +0800 Subject: [PATCH 10/31] add multi thread --- tests/pytest/insert/schemalessInsert.py | 165 ++++++++++++++++-------- 1 file changed, 113 insertions(+), 52 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index ed8e7ba103..4a818b2b49 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -461,7 +461,7 @@ class TDTestCase: check full type tag value limit """ # i8 - for t1 in ["-127i8"]: + for t1 in ["-127i8", "127i8"]: input_sql, stb_name, tb_name = self.genFullTypeSql(t1=t1) self.resCmp(input_sql, stb_name) for t1 in ["-128i8", "128i8"]: @@ -470,7 +470,7 @@ class TDTestCase: tdSql.checkNotEqual(code, 0) #i16 - for t2 in ["-32767i16"]: + for t2 in ["-32767i16", "32767i16"]: input_sql, stb_name, tb_name = self.genFullTypeSql(t2=t2) self.resCmp(input_sql, stb_name) for t2 in ["-32768i16", "32768i16"]: @@ -479,7 +479,7 @@ class TDTestCase: tdSql.checkNotEqual(code, 0) #i32 - for t3 in ["-2147483647i32"]: + for t3 in ["-2147483647i32", "2147483647i32"]: input_sql, stb_name, tb_name = self.genFullTypeSql(t3=t3) self.resCmp(input_sql, stb_name) for t3 in ["-2147483648i32", "2147483648i32"]: @@ -488,83 +488,136 @@ class TDTestCase: tdSql.checkNotEqual(code, 0) #i64 - for t4 in ["-9223372036854775807i64"]: + for t4 in ["-9223372036854775807i64", "9223372036854775807i64"]: input_sql, stb_name, tb_name = self.genFullTypeSql(t4=t4) self.resCmp(input_sql, stb_name) - #! 9223372036854775808i64 failed for t4 in ["-9223372036854775808i64", "9223372036854775808i64"]: input_sql = self.genFullTypeSql(t4=t4)[0] code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) # f32 - # for t5 in ["-11.12345f32"]: - # input_sql, stb_name, tb_name = self.genFullTypeSql(t5=t5) - # self.resCmp(input_sql, stb_name) - # # TODO to confirm length - # #for t5 in [f"{-3.4028234663852886*(10**38)-1}f32", f"{3.4028234663852886*(10**38)+1}f32"]: - # for t5 in [f"{-3.4028234663852886*(10**38)-1}f32", f"{3.4028234663852886*(10**38)+1}f32"]: - # print("tag2") - # input_sql = self.genFullTypeSql(t5=t5)[0] - # print(input_sql) - # code = self._conn.insertLines([input_sql]) - # tdSql.checkNotEqual(code, 0) - - # # f64 - # for t6 in ["-22.123456789f64"]: + for t5 in [f"{-3.4028234663852885981170418348451692544*(10**38)}f32", f"{3.4028234663852885981170418348451692544*(10**38)}f32"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(t5=t5) + self.resCmp(input_sql, stb_name) + # * limit set to 4028234664*(10**38) + for t5 in [f"{-3.4028234664*(10**38)}f32", f"{3.4028234664*(10**38)}f32"]: + input_sql = self.genFullTypeSql(t5=t5)[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + + # f64 #!bug stack smashing detected ***: terminated Aborted + #for t6 in [f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64', f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64']: + # for t6 in [f'{-1.79769*(10**308)}f64', f'{-1.79769*(10**308)}f64']: + # print("f64?") # input_sql, stb_name, tb_name = self.genFullTypeSql(t6=t6) # self.resCmp(input_sql, stb_name) # TODO to confirm length - # TODO binary nchar + # binary + stb_name = self.getLongName(7, "letters") + input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16374, "letters")}" c0=f 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkEqual(code, 0) + input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16375, "letters")}" c0=f 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + + # nchar + # * legal nchar could not be larger than 16374/4 + stb_name = self.getLongName(7, "letters") + input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}" c0=f 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkEqual(code, 0) + input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4094, "letters")}" c0=f 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + def colValueLengthCheckCase(self): """ check full type col value limit """ # i8 - for c1 in ["-127i8"]: + for c1 in ["-127i8", "127i8"]: input_sql, stb_name, tb_name = self.genFullTypeSql(c1=c1) self.resCmp(input_sql, stb_name) - # TODO to confirm - # for c1 in ["-131i8", "129i8"]: - # input_sql = self.genFullTypeSql(c1=c1)[0] - # print(input_sql) - # code = self._conn.insertLines([input_sql]) - # tdSql.checkNotEqual(code, 0) - - #i16 - for c2 in ["-32767i16"]: - print("tag1") - input_sql, stb_name, tb_name = self.genFullTypeSql(c2=c2) - self.resCmp(input_sql, stb_name) - for c2 in ["-32768i16", "32768i16"]: - input_sql = self.genFullTypeSql(c2=c2)[0] + for c1 in ["-128i8", "128i8"]: + input_sql = self.genFullTypeSql(c1=c1)[0] print(input_sql) code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) - #i32 + # i16 + for c2 in ["-32767i16"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(c2=c2) + self.resCmp(input_sql, stb_name) + for c2 in ["-32768i16", "32768i16"]: + input_sql = self.genFullTypeSql(c2=c2)[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + + # i32 for c3 in ["-2147483647i32"]: input_sql, stb_name, tb_name = self.genFullTypeSql(c3=c3) self.resCmp(input_sql, stb_name) - for c3 in ["-2147483650i32", "2147483648i32"]: + for c3 in ["-2147483648i32", "2147483648i32"]: input_sql = self.genFullTypeSql(c3=c3)[0] code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) - #i64 + # i64 for c4 in ["-9223372036854775807i64"]: input_sql, stb_name, tb_name = self.genFullTypeSql(c4=c4) self.resCmp(input_sql, stb_name) - # ! 9223372036854775808i64 failed - # !for c4 in ["-9223372036854775808i64", "9223372036854775808i64"]: - # ! input_sql = self.genFullTypeSql(c4=c4)[0] - # ! code = self._conn.insertLines([input_sql]) - # ! tdSql.checkNotEqual(code, 0) + for c4 in ["-9223372036854775808i64", "9223372036854775808i64"]: + input_sql = self.genFullTypeSql(c4=c4)[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + + # f32 + for c5 in [f"{-3.4028234663852885981170418348451692544*(10**38)}f32", f"{3.4028234663852885981170418348451692544*(10**38)}f32"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(c5=c5) + self.resCmp(input_sql, stb_name) + # * limit set to 4028234664*(10**38) + for c5 in [f"{-3.4028234664*(10**38)}f32", f"{3.4028234664*(10**38)}f32"]: + input_sql = self.genFullTypeSql(c5=c5)[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + + # f64 + for c6 in [f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64', f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64']: + input_sql, stb_name, tb_name = self.genFullTypeSql(c6=c6) + self.resCmp(input_sql, stb_name) + # * limit set to 1.797693134862316*(10**308) + for c6 in [f'{-1.797693134862316*(10**308)}f64', f'{-1.797693134862316*(10**308)}f64']: + input_sql = self.genFullTypeSql(c6=c6)[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + + # binary + stb_name = self.getLongName(7, "letters") + input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}" 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkEqual(code, 0) + # ! bug code is 0 + # input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16375, "letters")}" 1626006833639000000ns' + # code = self._conn.insertLines([input_sql]) + # tdSql.checkNotEqual(code, 0) + + # nchar + # * legal nchar could not be larger than 16374/4 + stb_name = self.getLongName(7, "letters") + input_sql = f'{stb_name},t0=t c0=f,c1=L"{self.getLongName(4093, "letters")}" 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkEqual(code, 0) + input_sql = f'{stb_name},t0=t c0=f,c1=L"{self.getLongName(4094, "letters")}" 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) def tagColIllegalValueCheckCase(self): + """ test illegal tag col value """ @@ -804,14 +857,14 @@ class TDTestCase: for i in range(count): d_stb_d_tb_list.append(self.genFullTypeSql(t0="f", c0="f")) s_stb_s_tb_list.append(self.genFullTypeSql(t7=f'"{self.getLongName(8, "letters")}"', c7=f'{self.getLongName(8, "letters")}"')) - s_stb_s_tb_a_col_a_tag_list.append(self.genFullTypeSql(t7=f'"{self.getLongName(8, "letters")}"', c7=f'{self.getLongName(8, "letters")}"'), ct_add_tag=True) - s_stb_s_tb_m_col_m_tag_list.append(self.genFullTypeSql(t7=f'"{self.getLongName(8, "letters")}"', c7=f'{self.getLongName(8, "letters")}"'), ct_min_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_a_col_a_tag_list.append(self.genFullTypeSql(t7=f'"{self.getLongName(8, "letters")}"', c7=f'{self.getLongName(8, "letters")}"', ct_add_tag=True)) + s_stb_s_tb_m_col_m_tag_list.append(self.genFullTypeSql(t7=f'"{self.getLongName(8, "letters")}"', c7=f'{self.getLongName(8, "letters")}"', ct_min_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 def genMultiThreadSeq(self, sql_list): tlist = list() for insert_sql in sql_list: - t = threading.Thread(target=self._conn.insertLines,args=insert_sql) + t = threading.Thread(target=self._conn.insertLines,args=([insert_sql[0]],)) tlist.append(t) return tlist @@ -819,10 +872,15 @@ class TDTestCase: for t in tlist: t.start() for t in tlist: - t.join() + tlist[t].join() def stbInsertMultiThreadCheckCase(self): - pass + """ + thread input different stb + """ + input_sql = self.genSqlList()[0] + print(input_sql) + self.multiThreadRun(self.genMultiThreadSeq(input_sql)) def run(self): print("running {}".format(__file__)) @@ -846,10 +904,12 @@ class TDTestCase: # self.nowTsCheckCase() # self.dateFormatTsCheckCase() # self.illegalTsCheckCase() - self.tagValueLengthCheckCase() - # ! 问题很多 - # ! self.colValueLengthCheckCase() + # ! confirm double + # self.tagValueLengthCheckCase() + + # ! bug + # self.colValueLengthCheckCase() # self.tagColIllegalValueCheckCase() @@ -870,6 +930,7 @@ class TDTestCase: # ! bug # self.batchErrorInsertCheckCase() + self.stbInsertMultiThreadCheckCase() From 8ee09625387009cf0689c39808b0faf7eae5d19f Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Sat, 24 Jul 2021 17:27:49 +0800 Subject: [PATCH 11/31] add multi thread --- tests/pytest/insert/schemalessInsert.py | 68 ++++++++++++++++++++++--- 1 file changed, 61 insertions(+), 7 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index 4a818b2b49..b6b8f57829 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -324,6 +324,13 @@ class TDTestCase: tdSql.checkEqual(res_field_list_without_ts, expect_list[1]) tdSql.checkEqual(res_type_list, expect_list[2]) + def cleanStb(self): + query_sql = "show stables" + res_row_list = self.resHandle(query_sql, True)[0] + print(res_row_list) + for stb in res_row_list: + tdSql.execute(f'drop table if exists {stb}') + def initCheckCase(self): """ normal tags and cols, one for every elm @@ -838,7 +845,7 @@ class TDTestCase: code = self._conn.insertLines(lines) # tdSql.checkEqual(code, 0) - def genSqlList(self, count=5): + def genSqlList(self, count=5, stb_name="", tb_name=""): """ stb --> supertable tb --> table @@ -856,9 +863,9 @@ class TDTestCase: s_stb_s_tb_m_col_m_tag_list = list() for i in range(count): d_stb_d_tb_list.append(self.genFullTypeSql(t0="f", c0="f")) - s_stb_s_tb_list.append(self.genFullTypeSql(t7=f'"{self.getLongName(8, "letters")}"', c7=f'{self.getLongName(8, "letters")}"')) - s_stb_s_tb_a_col_a_tag_list.append(self.genFullTypeSql(t7=f'"{self.getLongName(8, "letters")}"', c7=f'{self.getLongName(8, "letters")}"', ct_add_tag=True)) - s_stb_s_tb_m_col_m_tag_list.append(self.genFullTypeSql(t7=f'"{self.getLongName(8, "letters")}"', c7=f'{self.getLongName(8, "letters")}"', ct_min_tag=True)) + s_stb_s_tb_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{self.getLongName(8, "letters")}"', c7=f'{self.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'"{self.getLongName(8, "letters")}"', c7=f'{self.getLongName(8, "letters")}"', ct_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'"{self.getLongName(8, "letters")}"', c7=f'{self.getLongName(8, "letters")}"', ct_min_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 def genMultiThreadSeq(self, sql_list): @@ -872,21 +879,66 @@ class TDTestCase: for t in tlist: t.start() for t in tlist: - tlist[t].join() + t.join() def stbInsertMultiThreadCheckCase(self): """ thread input different stb """ input_sql = self.genSqlList()[0] - print(input_sql) self.multiThreadRun(self.genMultiThreadSeq(input_sql)) + tdSql.query(f"show tables;") + tdSql.checkRows(5) + + def sStbStbDdataInsertMultiThreadCheckCase(self): + """ + thread input same stb tb, different data, result keep first data + """ + input_sql, stb_name, tb_name = self.genFullTypeSql(tb_name=self.getLongName(10, "letters")) + self.resCmp(input_sql, stb_name) + 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)) + tdSql.query(f"show tables;") + tdSql.checkRows(1) + expected_tb_name = self.getNoIdTbName(stb_name)[0] + tdSql.checkEqual(tb_name, expected_tb_name) + + def sStbStbDdataAtcInsertMultiThreadCheckCase(self): + """ + thread input same stb tb, different data, add columes and tags, result keep first data + """ + input_sql, stb_name, tb_name = self.genFullTypeSql(tb_name=self.getLongName(10, "letters")) + 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] + print(s_stb_s_tb_a_col_a_tag_list) + self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_a_col_a_tag_list)) + tdSql.query(f"show tables;") + tdSql.checkRows(1) + expected_tb_name = self.getNoIdTbName(stb_name)[0] + tdSql.checkEqual(tb_name, expected_tb_name) + + def sStbStbDdataMtcInsertMultiThreadCheckCase(self): + """ + thread input same stb tb, different data, add columes and tags, result keep first data + """ + self.cleanStb() + input_sql, stb_name, tb_name = self.genFullTypeSql(tb_name=self.getLongName(10, "letters")) + 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] + print(s_stb_s_tb_m_col_m_tag_list) + self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_m_col_m_tag_list)) + tdSql.query(f"show tables;") + tdSql.checkRows(1) + expected_tb_name = self.getNoIdTbName(stb_name)[0] + tdSql.checkEqual(tb_name, expected_tb_name) def run(self): print("running {}".format(__file__)) tdSql.execute("drop database if exists test") tdSql.execute("create database if not exists test precision 'us'") tdSql.execute('use test') + + # tdSql.execute("create table super_table_cname_check (ts timestamp, pi1 int, pi2 bigint, pf1 float, pf2 double, ps1 binary(10), pi3 smallint, pi4 tinyint, pb1 bool, ps2 nchar(20)) tags (si1 int, si2 bigint, sf1 float, sf2 double, ss1 binary(10), si3 smallint, si4 tinyint, sb1 bool, ss2 nchar(20));") # tdSql.execute('create table st1 using super_table_cname_check tags (1, 2, 1.1, 2.2, "a", 1, 1, true, "aa");') # tdSql.execute('insert into st1 values (now, 1, 2, 1.1, 2.2, "a", 1, 1, true, "aa");') @@ -931,7 +983,9 @@ class TDTestCase: # self.batchErrorInsertCheckCase() self.stbInsertMultiThreadCheckCase() - + # self.sStbStbDdataInsertMultiThreadCheckCase() + # self.sStbStbDdataAtcInsertMultiThreadCheckCase() + self.sStbStbDdataMtcInsertMultiThreadCheckCase() From 63c9b2069e6755fff9ae7cec9e7a132af7be8f40 Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Sat, 24 Jul 2021 19:39:20 +0800 Subject: [PATCH 12/31] add multi thread --- tests/pytest/insert/schemalessInsert.py | 182 ++++++++++++++++++++---- 1 file changed, 158 insertions(+), 24 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index b6b8f57829..a46aa40f0f 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -245,8 +245,12 @@ class TDTestCase: sql_seq = f'{stb_name},{id}=\"{tb_name}\",t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8},t11={t1},t10={t8} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6},c7={c7},c8={c8},c9={c9},c11={c8},c10={t0} {ts}' if ct_am_tag is not None: sql_seq = f'{stb_name},{id}=\"{tb_name}\",t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6},c7={c7},c8={c8},c9={c9},c11={c8},c10={t0} {ts}' + if id_noexist_tag is not None: + sql_seq = f'{stb_name},t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6},c7={c7},c8={c8},c9={c9},c11={c8},c10={t0} {ts}' if ct_ma_tag is not None: sql_seq = f'{stb_name},{id}=\"{tb_name}\",t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8},t11={t1},t10={t8} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6} {ts}' + if id_noexist_tag is not None: + sql_seq = f'{stb_name},t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8},t11={t1},t10={t8} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6} {ts}' if ct_min_tag is not None: sql_seq = f'{stb_name},{id}=\"{tb_name}\",t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6} {ts}' return sql_seq, stb_name, tb_name @@ -326,15 +330,16 @@ class TDTestCase: def cleanStb(self): query_sql = "show stables" - res_row_list = self.resHandle(query_sql, True)[0] - print(res_row_list) - for stb in res_row_list: + res_row_list = tdSql.query(query_sql, True) + stb_list = map(lambda x: x[0], res_row_list) + for stb in stb_list: tdSql.execute(f'drop table if exists {stb}') def initCheckCase(self): """ normal tags and cols, one for every elm """ + self.cleanStb() input_sql, stb_name, tb_name = self.genFullTypeSql() self.resCmp(input_sql, stb_name) @@ -342,6 +347,7 @@ class TDTestCase: """ check all normal type """ + self.cleanStb() full_type_list = ["f", "F", "false", "False", "t", "T", "true", "True"] for t_type in full_type_list: input_sql, stb_name, tb_name = self.genFullTypeSql(c0=t_type, t0=t_type) @@ -355,6 +361,7 @@ class TDTestCase: please test : binary_symbols = '\"abcd`~!@#$%^&*()_-{[}]|:;<.>?lfjal"\'\'"\"' ''' + self.cleanStb() binary_symbols = '\"abcd`~!@#$%^&*()_-{[}]|:;<.>?lfjal"\"' nchar_symbols = f'L{binary_symbols}' input_sql, stb_name, tb_name = self.genFullTypeSql(c7=binary_symbols, c8=nchar_symbols, t7=binary_symbols, t8=nchar_symbols) @@ -365,6 +372,7 @@ class TDTestCase: test ts list --> ["1626006833639000000ns", "1626006833639019us", "1626006833640ms", "1626006834s", "1626006822639022"] # ! us级时间戳都为0时，数据库中查询显示，但python接口拿到的结果不显示 .000000的情况请确认，目前修改时间处理代码可以通过 """ + self.cleanStb() ts_list = ["1626006833639000000ns", "1626006833639019us", "1626006833640ms", "1626006834s", "1626006822639022", 0] for ts in ts_list: input_sql, stb_name, tb_name = self.genFullTypeSql(ts=ts) @@ -375,6 +383,7 @@ class TDTestCase: check id.index in tags eg: t0=**,id=**,t1=** """ + self.cleanStb() input_sql, stb_name, tb_name = self.genFullTypeSql(id_change_tag=True) self.resCmp(input_sql, stb_name) @@ -383,6 +392,7 @@ class TDTestCase: check id param eg: id and ID """ + self.cleanStb() input_sql, stb_name, tb_name = self.genFullTypeSql(id_upper_tag=True) self.resCmp(input_sql, stb_name) input_sql, stb_name, tb_name = self.genFullTypeSql(id_change_tag=True, id_upper_tag=True) @@ -392,6 +402,7 @@ class TDTestCase: """ id not exist """ + self.cleanStb() input_sql, stb_name, tb_name = self.genFullTypeSql(id_noexist_tag=True) self.resCmp(input_sql, stb_name) query_sql = f"select tbname from {stb_name}" @@ -408,6 +419,7 @@ class TDTestCase: max tag count is 128 max col count is ?? """ + self.cleanStb() input_sql, stb_name = self.genLongSql(128, 4000) print(input_sql) code = self._conn.insertLines([input_sql]) @@ -425,6 +437,7 @@ class TDTestCase: """ test illegal id name """ + self.cleanStb() rstr = list("!@#$%^&*()-+={}|[]\:<>?") for i in rstr: input_sql = self.genFullTypeSql(tb_name=f"\"aaa{i}bbb\"")[0] @@ -435,6 +448,7 @@ class TDTestCase: """ id is start with num """ + self.cleanStb() input_sql = self.genFullTypeSql(tb_name=f"\"1aaabbb\"")[0] code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) @@ -443,6 +457,7 @@ class TDTestCase: """ check now unsupported """ + self.cleanStb() input_sql = self.genFullTypeSql(ts="now")[0] code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) @@ -451,6 +466,7 @@ class TDTestCase: """ check date format ts unsupported """ + self.cleanStb() input_sql = self.genFullTypeSql(ts="2021-07-21\ 19:01:46.920")[0] code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) @@ -459,6 +475,7 @@ class TDTestCase: """ check ts format like 16260068336390us19 """ + self.cleanStb() input_sql = self.genFullTypeSql(ts="16260068336390us19")[0] code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) @@ -467,6 +484,7 @@ class TDTestCase: """ check full type tag value limit """ + self.cleanStb() # i8 for t1 in ["-127i8", "127i8"]: input_sql, stb_name, tb_name = self.genFullTypeSql(t1=t1) @@ -545,6 +563,7 @@ class TDTestCase: """ check full type col value limit """ + self.cleanStb() # i8 for c1 in ["-127i8", "127i8"]: input_sql, stb_name, tb_name = self.genFullTypeSql(c1=c1) @@ -628,6 +647,7 @@ class TDTestCase: """ test illegal tag col value """ + self.cleanStb() # bool for i in ["TrUe", "tRue", "trUe", "truE", "FalsE", "fAlse", "faLse", "falSe", "falsE"]: input_sql1 = self.genFullTypeSql(t0=i)[0] @@ -661,6 +681,7 @@ class TDTestCase: """ check duplicate Id Tag Col """ + self.cleanStb() input_sql_id = self.genFullTypeSql(id_double_tag=True)[0] code = self._conn.insertLines([input_sql_id]) tdSql.checkNotEqual(code, 0) @@ -687,6 +708,7 @@ class TDTestCase: """ case no id when stb exist """ + self.cleanStb() input_sql, stb_name, tb_name = self.genFullTypeSql(t0="f", c0="f") self.resCmp(input_sql, stb_name) input_sql, stb_name, tb_name = self.genFullTypeSql(stb_name=stb_name, id_noexist_tag=True, t0="f", c0="f") @@ -699,6 +721,7 @@ class TDTestCase: """ check duplicate insert when stb exist """ + self.cleanStb() input_sql, stb_name, tb_name = self.genFullTypeSql() self.resCmp(input_sql, stb_name) code = self._conn.insertLines([input_sql]) @@ -709,6 +732,7 @@ class TDTestCase: """ check length increase """ + self.cleanStb() input_sql, stb_name, tb_name = self.genFullTypeSql() self.resCmp(input_sql, stb_name) tb_name = self.getLongName(5, "letters") @@ -721,6 +745,7 @@ class TDTestCase: """ check column and tag count add, stb and tb duplicate """ + self.cleanStb() input_sql, stb_name, tb_name = self.genFullTypeSql(t0="f", c0="f") print(input_sql) self.resCmp(input_sql, stb_name) @@ -732,6 +757,7 @@ class TDTestCase: """ check column and tag count add """ + self.cleanStb() input_sql, stb_name, tb_name = self.genFullTypeSql(t0="f", c0="f") self.resCmp(input_sql, stb_name) input_sql, stb_name, tb_name_1 = self.genFullTypeSql(stb_name=stb_name, tb_name=f'{tb_name}_1', t0="f", c0="f", ct_add_tag=True) @@ -745,6 +771,7 @@ class TDTestCase: condition: stb not change insert two table, keep tag unchange, change col """ + self.cleanStb() input_sql, stb_name, tb_name = self.genFullTypeSql(t0="f", c0="f", id_noexist_tag=True) self.resCmp(input_sql, stb_name) tb_name1 = self.getNoIdTbName(stb_name) @@ -767,6 +794,7 @@ class TDTestCase: # ? case finish , src bug exist every binary and nchar must be length+2, so """ + self.cleanStb() stb_name = self.getLongName(7, "letters") tb_name = f'{stb_name}_1' input_sql = f'{stb_name},id="{tb_name}",t0=t c0=f 1626006833639000000ns' @@ -792,6 +820,10 @@ class TDTestCase: # ? tag nchar max is 16384, col+ts nchar max 49151 def tagColNcharMaxLengthCheckCase(self): + """ + # ? case finish , src bug exist + """ + self.cleanStb() stb_name = self.getLongName(7, "letters") tb_name = f'{stb_name}_1' input_sql = f'{stb_name},id="{tb_name}",t0=t c0=f 1626006833639000000ns' @@ -819,6 +851,7 @@ class TDTestCase: """ test batch insert """ + self.cleanStb() stb_name = self.getLongName(8, "letters") 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", @@ -839,6 +872,7 @@ class TDTestCase: """ test batch error insert """ + self.cleanStb() stb_name = self.getLongName(8, "letters") lines = ["st123456,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000ns", f"{stb_name},t2=5f64,t3=L\"ste\" c1=tRue,c2=4i64,c3=\"iam\" 1626056811823316532ns"] @@ -861,12 +895,22 @@ class TDTestCase: s_stb_s_tb_list = list() s_stb_s_tb_a_col_a_tag_list = list() s_stb_s_tb_m_col_m_tag_list = list() + s_stb_d_tb_list = list() + s_stb_d_tb_a_col_m_tag_list = list() + s_stb_d_tb_a_tag_m_col_list = list() + s_stb_s_tb_d_ts_list = list() for i in range(count): d_stb_d_tb_list.append(self.genFullTypeSql(t0="f", c0="f")) - s_stb_s_tb_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{self.getLongName(8, "letters")}"', c7=f'{self.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'"{self.getLongName(8, "letters")}"', c7=f'{self.getLongName(8, "letters")}"', ct_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'"{self.getLongName(8, "letters")}"', c7=f'{self.getLongName(8, "letters")}"', ct_min_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 + s_stb_s_tb_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{self.getLongName(8, "letters")}"', c7=f'"{self.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'"{self.getLongName(8, "letters")}"', c7=f'"{self.getLongName(8, "letters")}"', ct_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'"{self.getLongName(8, "letters")}"', c7=f'"{self.getLongName(8, "letters")}"', ct_min_tag=True)) + s_stb_d_tb_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{self.getLongName(8, "letters")}"', c7=f'"{self.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'"{self.getLongName(8, "letters")}"', c7=f'"{self.getLongName(8, "letters")}"', id_noexist_tag=True, ct_am_tag=True)) + s_stb_d_tb_a_tag_m_col_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{self.getLongName(8, "letters")}"', c7=f'"{self.getLongName(8, "letters")}"', id_noexist_tag=True, ct_ma_tag=True)) + s_stb_s_tb_d_ts_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{self.getLongName(8, "letters")}"', c7=f'"{self.getLongName(8, "letters")}"', ts=0)) + + 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, 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 + def genMultiThreadSeq(self, sql_list): tlist = list() @@ -885,6 +929,7 @@ class TDTestCase: """ thread input different stb """ + self.cleanStb() input_sql = self.genSqlList()[0] self.multiThreadRun(self.genMultiThreadSeq(input_sql)) tdSql.query(f"show tables;") @@ -894,6 +939,7 @@ class TDTestCase: """ thread input same stb tb, different data, result keep first data """ + self.cleanStb() input_sql, stb_name, tb_name = self.genFullTypeSql(tb_name=self.getLongName(10, "letters")) self.resCmp(input_sql, stb_name) s_stb_s_tb_list = self.genSqlList(stb_name=stb_name, tb_name=tb_name)[1] @@ -902,35 +948,110 @@ class TDTestCase: tdSql.checkRows(1) expected_tb_name = self.getNoIdTbName(stb_name)[0] tdSql.checkEqual(tb_name, expected_tb_name) + tdSql.query(f"select * from {stb_name};") + tdSql.checkRows(1) def sStbStbDdataAtcInsertMultiThreadCheckCase(self): - """ - thread input same stb tb, different data, add columes and tags, result keep first data - """ - input_sql, stb_name, tb_name = self.genFullTypeSql(tb_name=self.getLongName(10, "letters")) - 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] - print(s_stb_s_tb_a_col_a_tag_list) - self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_a_col_a_tag_list)) - tdSql.query(f"show tables;") - tdSql.checkRows(1) - expected_tb_name = self.getNoIdTbName(stb_name)[0] - tdSql.checkEqual(tb_name, expected_tb_name) - - def sStbStbDdataMtcInsertMultiThreadCheckCase(self): """ thread input same stb tb, different data, add columes and tags, result keep first data """ self.cleanStb() input_sql, stb_name, tb_name = self.genFullTypeSql(tb_name=self.getLongName(10, "letters")) 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] + self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_a_col_a_tag_list)) + tdSql.query(f"show tables;") + tdSql.checkRows(1) + expected_tb_name = self.getNoIdTbName(stb_name)[0] + tdSql.checkEqual(tb_name, expected_tb_name) + tdSql.query(f"select * from {stb_name};") + tdSql.checkRows(1) + + def sStbStbDdataMtcInsertMultiThreadCheckCase(self): + """ + thread input same stb tb, different data, minus columes and tags, result keep first data + """ + self.cleanStb() + input_sql, stb_name, tb_name = self.genFullTypeSql(tb_name=self.getLongName(10, "letters")) + 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] - print(s_stb_s_tb_m_col_m_tag_list) self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_m_col_m_tag_list)) tdSql.query(f"show tables;") tdSql.checkRows(1) expected_tb_name = self.getNoIdTbName(stb_name)[0] tdSql.checkEqual(tb_name, expected_tb_name) + tdSql.query(f"select * from {stb_name};") + tdSql.checkRows(1) + + def sStbDtbDdataInsertMultiThreadCheckCase(self): + """ + thread input same stb, different tb, different data + """ + self.cleanStb() + input_sql, stb_name, tb_name = self.genFullTypeSql() + self.resCmp(input_sql, stb_name) + s_stb_d_tb_list = self.genSqlList(stb_name=stb_name)[4] + self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_list)) + tdSql.query(f"show tables;") + tdSql.checkRows(6) + + def sStbDtbDdataAcMtInsertMultiThreadCheckCase(self): + """ + #! concurrency conflict + """ + """ + thread input same stb, different tb, different data, add col, mul tag + """ + self.cleanStb() + input_sql, stb_name, tb_name = self.genFullTypeSql() + self.resCmp(input_sql, stb_name) + s_stb_d_tb_a_col_m_tag_list = self.genSqlList(stb_name=stb_name)[5] + self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_a_col_m_tag_list)) + tdSql.query(f"show tables;") + tdSql.checkRows(6) + + def sStbDtbDdataAtMcInsertMultiThreadCheckCase(self): + """ + #! concurrency conflict + """ + """ + thread input same stb, different tb, different data, add tag, mul col + """ + self.cleanStb() + input_sql, stb_name, tb_name = self.genFullTypeSql() + self.resCmp(input_sql, stb_name) + s_stb_d_tb_a_tag_m_col_list = self.genSqlList(stb_name=stb_name)[6] + self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_a_tag_m_col_list)) + tdSql.query(f"show tables;") + tdSql.checkRows(6) + + def sStbStbDdataDtsInsertMultiThreadCheckCase(self): + """ + thread input same stb tb, different ts + """ + self.cleanStb() + input_sql, stb_name, tb_name = self.genFullTypeSql(tb_name=self.getLongName(10, "letters")) + self.resCmp(input_sql, stb_name) + s_stb_s_tb_d_ts_list = self.genSqlList(stb_name=stb_name, tb_name=tb_name)[7] + print(s_stb_s_tb_d_ts_list) + self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_d_ts_list)) + tdSql.query(f"show tables;") + tdSql.checkRows(1) + tdSql.query(f"select * from {stb_name}") + tdSql.checkRows(6) + + + + def test(self): + input_sql1 = "rfasta,id=\"rfasta_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7=\"ddzhiksj\",t8=L\"ncharTagValue\" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7=\"bnhwlgvj\",c8=L\"ncharTagValue\",c9=7u64 1626006833639000000ns" + + input_sql2 = "rfasta,t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7=\"ddzhiksj\",t8=L\"ncharTagValue\" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7=\"bnhwlgvj\",c8=L\"ncharColValue\",c9=7u64 1626006833639000000ns" + input_sql3 = 'hmemeb,id="kilrcrldgf",t0=True,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="ndsfdrum",t8=L"ncharTagValue" c0=f,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="igwoehkm",c8=L"ncharColValue",c9=7u64 0' + input_sql4 = 'hmemeb,id="kilrcrldgf",t0=F,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="fysodjql",t8=L"ncharTagValue" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="waszbfvc",c8=L"ncharColValue",c9=7u64 0' + + + self._conn.insertLines([input_sql3]) + self._conn.insertLines([input_sql4]) def run(self): print("running {}".format(__file__)) @@ -982,10 +1103,23 @@ class TDTestCase: # ! bug # self.batchErrorInsertCheckCase() - self.stbInsertMultiThreadCheckCase() + # self.stbInsertMultiThreadCheckCase() # self.sStbStbDdataInsertMultiThreadCheckCase() # self.sStbStbDdataAtcInsertMultiThreadCheckCase() - self.sStbStbDdataMtcInsertMultiThreadCheckCase() + # self.sStbStbDdataMtcInsertMultiThreadCheckCase() + # self.sStbDtbDdataInsertMultiThreadCheckCase() + + # ! concurrency conflict + # self.sStbDtbDdataAcMtInsertMultiThreadCheckCase() + # self.sStbDtbDdataAtMcInsertMultiThreadCheckCase() + # ! concurrency conflict + + # self.sStbStbDdataDtsInsertMultiThreadCheckCase() + # self.test() + + + + From f07b4f55dd4ad3583fddf8fff4b806f902118cb5 Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Mon, 26 Jul 2021 01:14:53 +0800 Subject: [PATCH 13/31] save --- tests/pytest/insert/schemalessInsert.py | 56 ++++++++++++++++--------- 1 file changed, 37 insertions(+), 19 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index a46aa40f0f..3defdcaa62 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -412,22 +412,25 @@ class TDTestCase: else: tdSql.checkColNameList(res_row_list, "please check noIdCheckCase") - # ! bug - # TODO confirm!!! def maxColTagCheckCase(self): """ max tag count is 128 max col count is ?? """ - self.cleanStb() - input_sql, stb_name = self.genLongSql(128, 4000) - print(input_sql) - code = self._conn.insertLines([input_sql]) - print("insertLines result {}".format(code)) - query_sql = f"describe {stb_name}" - insert_tag_col_num = len(self.resHandle(query_sql, True)[0]) - expected_num = 128 + 1023 + 1 - tdSql.checkEqual(insert_tag_col_num, expected_num) + for input_sql in [self.genLongSql(128, 1)[0], self.genLongSql(1, 4094)[0]]: + self.cleanStb() + code = self._conn.insertLines([input_sql]) + tdSql.checkEqual(code, 0) + for input_sql in [self.genLongSql(129, 1)[0], self.genLongSql(1, 4095)[0]]: + self.cleanStb() + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + + # print("insertLines result {}".format(code)) + # query_sql = f"describe {stb_name}" + # insert_tag_col_num = len(self.resHandle(query_sql, True)[0]) + # expected_num = 128 + 1023 + 1 + # tdSql.checkEqual(insert_tag_col_num, expected_num) # input_sql, stb_name = self.genLongSql(128, 1500) # code = self._conn.insertLines([input_sql]) @@ -574,7 +577,6 @@ class TDTestCase: print(input_sql) code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) - # i16 for c2 in ["-32767i16"]: input_sql, stb_name, tb_name = self.genFullTypeSql(c2=c2) @@ -867,6 +869,20 @@ class TDTestCase: code = self._conn.insertLines(lines) tdSql.checkEqual(code, 0) + def multiInsertCheckCase(self, count): + """ + test multi insert + """ + self.cleanStb() + sql_list = [] + stb_name = self.getLongName(8, "letters") + tdSql.execute(f'create stable {stb_name}(ts timestamp, f int) tags(t1 bigint)') + for i in range(count): + input_sql = self.genFullTypeSql(stb_name=stb_name, t7=f'"{self.getLongName(8, "letters")}"', c7=f'"{self.getLongName(8, "letters")}"', id_noexist_tag=True)[0] + sql_list.append(input_sql) + code = self._conn.insertLines(sql_list) + tdSql.checkEqual(code, 0) + # ! bug def batchErrorInsertCheckCase(self): """ @@ -877,7 +893,7 @@ class TDTestCase: lines = ["st123456,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000ns", f"{stb_name},t2=5f64,t3=L\"ste\" c1=tRue,c2=4i64,c3=\"iam\" 1626056811823316532ns"] code = self._conn.insertLines(lines) - # tdSql.checkEqual(code, 0) + tdSql.checkNotEqual(code, 0) def genSqlList(self, count=5, stb_name="", tb_name=""): """ @@ -1046,12 +1062,14 @@ class TDTestCase: input_sql1 = "rfasta,id=\"rfasta_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7=\"ddzhiksj\",t8=L\"ncharTagValue\" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7=\"bnhwlgvj\",c8=L\"ncharTagValue\",c9=7u64 1626006833639000000ns" input_sql2 = "rfasta,t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7=\"ddzhiksj\",t8=L\"ncharTagValue\" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7=\"bnhwlgvj\",c8=L\"ncharColValue\",c9=7u64 1626006833639000000ns" - input_sql3 = 'hmemeb,id="kilrcrldgf",t0=True,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="ndsfdrum",t8=L"ncharTagValue" c0=f,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="igwoehkm",c8=L"ncharColValue",c9=7u64 0' - input_sql4 = 'hmemeb,id="kilrcrldgf",t0=F,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="fysodjql",t8=L"ncharTagValue" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="waszbfvc",c8=L"ncharColValue",c9=7u64 0' + input_sql3 = f'ab*cd,id="ccc",t0=True,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="ndsfdrum",t8=L"ncharTagValue" c0=f,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="igwoehkm",c8=L"ncharColValue",c9=7u64 0' + print(input_sql3) + # input_sql4 = 'hmemeb,id="kilrcrldgf",t0=F,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="fysodjql",t8=L"ncharTagValue" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="waszbfvc",c8=L"ncharColValue",c9=7u64 0' - self._conn.insertLines([input_sql3]) - self._conn.insertLines([input_sql4]) + code = self._conn.insertLines([input_sql3]) + print(code) + # self._conn.insertLines([input_sql4]) def run(self): print("running {}".format(__file__)) @@ -1071,7 +1089,7 @@ class TDTestCase: # self.idSeqCheckCase() # self.idUpperCheckCase() # self.noIdCheckCase() - # self.maxColTagCheckCase() + self.maxColTagCheckCase() # self.idIllegalNameCheckCase() # self.idStartWithNumCheckCase() # self.nowTsCheckCase() @@ -1099,7 +1117,7 @@ class TDTestCase: # self.tagColNcharMaxLengthCheckCase() # self.batchInsertCheckCase() - + # self.multiInsertCheckCase(5000) # ! bug # self.batchErrorInsertCheckCase() From fc732c29fb3b37f9998f5f54ec6274a095b227ce Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Mon, 26 Jul 2021 10:05:33 +0800 Subject: [PATCH 14/31] save --- tests/pytest/insert/schemalessInsert.py | 260 ++++++++++++------------ 1 file changed, 130 insertions(+), 130 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index 3defdcaa62..5b0314b6fb 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -488,78 +488,78 @@ class TDTestCase: check full type tag value limit """ self.cleanStb() - # i8 - for t1 in ["-127i8", "127i8"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(t1=t1) - self.resCmp(input_sql, stb_name) - for t1 in ["-128i8", "128i8"]: - input_sql = self.genFullTypeSql(t1=t1)[0] - code = self._conn.insertLines([input_sql]) - tdSql.checkNotEqual(code, 0) + # # i8 + # for t1 in ["-127i8", "127i8"]: + # input_sql, stb_name, tb_name = self.genFullTypeSql(t1=t1) + # self.resCmp(input_sql, stb_name) + # for t1 in ["-128i8", "128i8"]: + # input_sql = self.genFullTypeSql(t1=t1)[0] + # code = self._conn.insertLines([input_sql]) + # tdSql.checkNotEqual(code, 0) - #i16 - for t2 in ["-32767i16", "32767i16"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(t2=t2) - self.resCmp(input_sql, stb_name) - for t2 in ["-32768i16", "32768i16"]: - input_sql = self.genFullTypeSql(t2=t2)[0] - code = self._conn.insertLines([input_sql]) - tdSql.checkNotEqual(code, 0) + # #i16 + # for t2 in ["-32767i16", "32767i16"]: + # input_sql, stb_name, tb_name = self.genFullTypeSql(t2=t2) + # self.resCmp(input_sql, stb_name) + # for t2 in ["-32768i16", "32768i16"]: + # input_sql = self.genFullTypeSql(t2=t2)[0] + # code = self._conn.insertLines([input_sql]) + # tdSql.checkNotEqual(code, 0) - #i32 - for t3 in ["-2147483647i32", "2147483647i32"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(t3=t3) - self.resCmp(input_sql, stb_name) - for t3 in ["-2147483648i32", "2147483648i32"]: - input_sql = self.genFullTypeSql(t3=t3)[0] - code = self._conn.insertLines([input_sql]) - tdSql.checkNotEqual(code, 0) + # #i32 + # for t3 in ["-2147483647i32", "2147483647i32"]: + # input_sql, stb_name, tb_name = self.genFullTypeSql(t3=t3) + # self.resCmp(input_sql, stb_name) + # for t3 in ["-2147483648i32", "2147483648i32"]: + # input_sql = self.genFullTypeSql(t3=t3)[0] + # code = self._conn.insertLines([input_sql]) + # tdSql.checkNotEqual(code, 0) - #i64 - for t4 in ["-9223372036854775807i64", "9223372036854775807i64"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(t4=t4) - self.resCmp(input_sql, stb_name) - for t4 in ["-9223372036854775808i64", "9223372036854775808i64"]: - input_sql = self.genFullTypeSql(t4=t4)[0] - code = self._conn.insertLines([input_sql]) - tdSql.checkNotEqual(code, 0) + # #i64 + # for t4 in ["-9223372036854775807i64", "9223372036854775807i64"]: + # input_sql, stb_name, tb_name = self.genFullTypeSql(t4=t4) + # self.resCmp(input_sql, stb_name) + # for t4 in ["-9223372036854775808i64", "9223372036854775808i64"]: + # input_sql = self.genFullTypeSql(t4=t4)[0] + # code = self._conn.insertLines([input_sql]) + # tdSql.checkNotEqual(code, 0) - # f32 - for t5 in [f"{-3.4028234663852885981170418348451692544*(10**38)}f32", f"{3.4028234663852885981170418348451692544*(10**38)}f32"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(t5=t5) - self.resCmp(input_sql, stb_name) - # * limit set to 4028234664*(10**38) - for t5 in [f"{-3.4028234664*(10**38)}f32", f"{3.4028234664*(10**38)}f32"]: - input_sql = self.genFullTypeSql(t5=t5)[0] - code = self._conn.insertLines([input_sql]) - tdSql.checkNotEqual(code, 0) + # # f32 + # for t5 in [f"{-3.4028234663852885981170418348451692544*(10**38)}f32", f"{3.4028234663852885981170418348451692544*(10**38)}f32"]: + # input_sql, stb_name, tb_name = self.genFullTypeSql(t5=t5) + # self.resCmp(input_sql, stb_name) + # # * limit set to 4028234664*(10**38) + # for t5 in [f"{-3.4028234664*(10**38)}f32", f"{3.4028234664*(10**38)}f32"]: + # input_sql = self.genFullTypeSql(t5=t5)[0] + # code = self._conn.insertLines([input_sql]) + # tdSql.checkNotEqual(code, 0) # f64 #!bug stack smashing detected ***: terminated Aborted - #for t6 in [f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64', f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64']: - # for t6 in [f'{-1.79769*(10**308)}f64', f'{-1.79769*(10**308)}f64']: - # print("f64?") - # input_sql, stb_name, tb_name = self.genFullTypeSql(t6=t6) - # self.resCmp(input_sql, stb_name) + # for t6 in [f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64', f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64']: + for t6 in [f'{-1.79769*(10**308)}f64', f'{-1.79769*(10**308)}f64']: + print("f64?") + input_sql, stb_name, tb_name = self.genFullTypeSql(t6=t6) + self.resCmp(input_sql, stb_name) # TODO to confirm length - # binary - stb_name = self.getLongName(7, "letters") - input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16374, "letters")}" c0=f 1626006833639000000ns' - code = self._conn.insertLines([input_sql]) - tdSql.checkEqual(code, 0) - input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16375, "letters")}" c0=f 1626006833639000000ns' - code = self._conn.insertLines([input_sql]) - tdSql.checkNotEqual(code, 0) + # # binary + # stb_name = self.getLongName(7, "letters") + # input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16374, "letters")}" c0=f 1626006833639000000ns' + # code = self._conn.insertLines([input_sql]) + # tdSql.checkEqual(code, 0) + # input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16375, "letters")}" c0=f 1626006833639000000ns' + # code = self._conn.insertLines([input_sql]) + # tdSql.checkNotEqual(code, 0) - # nchar - # * legal nchar could not be larger than 16374/4 - stb_name = self.getLongName(7, "letters") - input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}" c0=f 1626006833639000000ns' - code = self._conn.insertLines([input_sql]) - tdSql.checkEqual(code, 0) - input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4094, "letters")}" c0=f 1626006833639000000ns' - code = self._conn.insertLines([input_sql]) - tdSql.checkNotEqual(code, 0) + # # nchar + # # * legal nchar could not be larger than 16374/4 + # stb_name = self.getLongName(7, "letters") + # input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}" c0=f 1626006833639000000ns' + # code = self._conn.insertLines([input_sql]) + # tdSql.checkEqual(code, 0) + # input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4094, "letters")}" c0=f 1626006833639000000ns' + # code = self._conn.insertLines([input_sql]) + # tdSql.checkNotEqual(code, 0) def colValueLengthCheckCase(self): @@ -567,82 +567,82 @@ class TDTestCase: check full type col value limit """ self.cleanStb() - # i8 - for c1 in ["-127i8", "127i8"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(c1=c1) - self.resCmp(input_sql, stb_name) + # # i8 + # for c1 in ["-127i8", "127i8"]: + # input_sql, stb_name, tb_name = self.genFullTypeSql(c1=c1) + # self.resCmp(input_sql, stb_name) - for c1 in ["-128i8", "128i8"]: - input_sql = self.genFullTypeSql(c1=c1)[0] - print(input_sql) - code = self._conn.insertLines([input_sql]) - tdSql.checkNotEqual(code, 0) - # i16 - for c2 in ["-32767i16"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(c2=c2) - self.resCmp(input_sql, stb_name) - for c2 in ["-32768i16", "32768i16"]: - input_sql = self.genFullTypeSql(c2=c2)[0] - code = self._conn.insertLines([input_sql]) - tdSql.checkNotEqual(code, 0) + # for c1 in ["-128i8", "128i8"]: + # input_sql = self.genFullTypeSql(c1=c1)[0] + # print(input_sql) + # code = self._conn.insertLines([input_sql]) + # tdSql.checkNotEqual(code, 0) + # # i16 + # for c2 in ["-32767i16"]: + # input_sql, stb_name, tb_name = self.genFullTypeSql(c2=c2) + # self.resCmp(input_sql, stb_name) + # for c2 in ["-32768i16", "32768i16"]: + # input_sql = self.genFullTypeSql(c2=c2)[0] + # code = self._conn.insertLines([input_sql]) + # tdSql.checkNotEqual(code, 0) - # i32 - for c3 in ["-2147483647i32"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(c3=c3) - self.resCmp(input_sql, stb_name) - for c3 in ["-2147483648i32", "2147483648i32"]: - input_sql = self.genFullTypeSql(c3=c3)[0] - code = self._conn.insertLines([input_sql]) - tdSql.checkNotEqual(code, 0) + # # i32 + # for c3 in ["-2147483647i32"]: + # input_sql, stb_name, tb_name = self.genFullTypeSql(c3=c3) + # self.resCmp(input_sql, stb_name) + # for c3 in ["-2147483648i32", "2147483648i32"]: + # input_sql = self.genFullTypeSql(c3=c3)[0] + # code = self._conn.insertLines([input_sql]) + # tdSql.checkNotEqual(code, 0) - # i64 - for c4 in ["-9223372036854775807i64"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(c4=c4) - self.resCmp(input_sql, stb_name) - for c4 in ["-9223372036854775808i64", "9223372036854775808i64"]: - input_sql = self.genFullTypeSql(c4=c4)[0] - code = self._conn.insertLines([input_sql]) - tdSql.checkNotEqual(code, 0) + # # i64 + # for c4 in ["-9223372036854775807i64"]: + # input_sql, stb_name, tb_name = self.genFullTypeSql(c4=c4) + # self.resCmp(input_sql, stb_name) + # for c4 in ["-9223372036854775808i64", "9223372036854775808i64"]: + # input_sql = self.genFullTypeSql(c4=c4)[0] + # code = self._conn.insertLines([input_sql]) + # tdSql.checkNotEqual(code, 0) - # f32 - for c5 in [f"{-3.4028234663852885981170418348451692544*(10**38)}f32", f"{3.4028234663852885981170418348451692544*(10**38)}f32"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(c5=c5) - self.resCmp(input_sql, stb_name) - # * limit set to 4028234664*(10**38) - for c5 in [f"{-3.4028234664*(10**38)}f32", f"{3.4028234664*(10**38)}f32"]: - input_sql = self.genFullTypeSql(c5=c5)[0] - code = self._conn.insertLines([input_sql]) - tdSql.checkNotEqual(code, 0) + # # f32 + # for c5 in [f"{-3.4028234663852885981170418348451692544*(10**38)}f32", f"{3.4028234663852885981170418348451692544*(10**38)}f32"]: + # input_sql, stb_name, tb_name = self.genFullTypeSql(c5=c5) + # self.resCmp(input_sql, stb_name) + # # * limit set to 4028234664*(10**38) + # for c5 in [f"{-3.4028234664*(10**38)}f32", f"{3.4028234664*(10**38)}f32"]: + # input_sql = self.genFullTypeSql(c5=c5)[0] + # code = self._conn.insertLines([input_sql]) + # tdSql.checkNotEqual(code, 0) - # f64 - for c6 in [f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64', f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64']: - input_sql, stb_name, tb_name = self.genFullTypeSql(c6=c6) - self.resCmp(input_sql, stb_name) - # * limit set to 1.797693134862316*(10**308) - for c6 in [f'{-1.797693134862316*(10**308)}f64', f'{-1.797693134862316*(10**308)}f64']: - input_sql = self.genFullTypeSql(c6=c6)[0] - code = self._conn.insertLines([input_sql]) - tdSql.checkNotEqual(code, 0) + # # f64 + # for c6 in [f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64', f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64']: + # input_sql, stb_name, tb_name = self.genFullTypeSql(c6=c6) + # self.resCmp(input_sql, stb_name) + # # * limit set to 1.797693134862316*(10**308) + # for c6 in [f'{-1.797693134862316*(10**308)}f64', f'{-1.797693134862316*(10**308)}f64']: + # input_sql = self.genFullTypeSql(c6=c6)[0] + # code = self._conn.insertLines([input_sql]) + # tdSql.checkNotEqual(code, 0) - # binary + # # binary stb_name = self.getLongName(7, "letters") - input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}" 1626006833639000000ns' - code = self._conn.insertLines([input_sql]) - tdSql.checkEqual(code, 0) - # ! bug code is 0 - # input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16375, "letters")}" 1626006833639000000ns' + # input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}" 1626006833639000000ns' # code = self._conn.insertLines([input_sql]) - # tdSql.checkNotEqual(code, 0) + # tdSql.checkEqual(code, 0) + # ! bug code is 0 + input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16375, "letters")}" 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) # nchar # * legal nchar could not be larger than 16374/4 - stb_name = self.getLongName(7, "letters") - input_sql = f'{stb_name},t0=t c0=f,c1=L"{self.getLongName(4093, "letters")}" 1626006833639000000ns' - code = self._conn.insertLines([input_sql]) - tdSql.checkEqual(code, 0) - input_sql = f'{stb_name},t0=t c0=f,c1=L"{self.getLongName(4094, "letters")}" 1626006833639000000ns' - code = self._conn.insertLines([input_sql]) - tdSql.checkNotEqual(code, 0) + # stb_name = self.getLongName(7, "letters") + # input_sql = f'{stb_name},t0=t c0=f,c1=L"{self.getLongName(4093, "letters")}" 1626006833639000000ns' + # code = self._conn.insertLines([input_sql]) + # tdSql.checkEqual(code, 0) + # input_sql = f'{stb_name},t0=t c0=f,c1=L"{self.getLongName(4094, "letters")}" 1626006833639000000ns' + # code = self._conn.insertLines([input_sql]) + # tdSql.checkNotEqual(code, 0) def tagColIllegalValueCheckCase(self): @@ -1089,7 +1089,7 @@ class TDTestCase: # self.idSeqCheckCase() # self.idUpperCheckCase() # self.noIdCheckCase() - self.maxColTagCheckCase() + # self.maxColTagCheckCase() # self.idIllegalNameCheckCase() # self.idStartWithNumCheckCase() # self.nowTsCheckCase() @@ -1100,7 +1100,7 @@ class TDTestCase: # self.tagValueLengthCheckCase() # ! bug - # self.colValueLengthCheckCase() + self.colValueLengthCheckCase() # self.tagColIllegalValueCheckCase() From 2fd97729db73446385d0d15b5ae5ed7c221167ca Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Mon, 26 Jul 2021 10:13:29 +0800 Subject: [PATCH 15/31] save --- tests/pytest/insert/schemalessInsert.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index 5b0314b6fb..d46ec49b14 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -626,9 +626,9 @@ class TDTestCase: # # binary stb_name = self.getLongName(7, "letters") - # input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}" 1626006833639000000ns' - # code = self._conn.insertLines([input_sql]) - # tdSql.checkEqual(code, 0) + input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}" 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkEqual(code, 0) # ! bug code is 0 input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16375, "letters")}" 1626006833639000000ns' code = self._conn.insertLines([input_sql]) From c3549d245d81635ddcc0ab87922b34780e528dbd Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Mon, 26 Jul 2021 10:19:34 +0800 Subject: [PATCH 16/31] save --- tests/pytest/insert/schemalessInsert.py | 125 ++++++++++++------------ 1 file changed, 65 insertions(+), 60 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index d46ec49b14..16727b099d 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -488,51 +488,51 @@ class TDTestCase: check full type tag value limit """ self.cleanStb() - # # i8 - # for t1 in ["-127i8", "127i8"]: - # input_sql, stb_name, tb_name = self.genFullTypeSql(t1=t1) - # self.resCmp(input_sql, stb_name) - # for t1 in ["-128i8", "128i8"]: - # input_sql = self.genFullTypeSql(t1=t1)[0] - # code = self._conn.insertLines([input_sql]) - # tdSql.checkNotEqual(code, 0) + # i8 + for t1 in ["-127i8", "127i8"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(t1=t1) + self.resCmp(input_sql, stb_name) + for t1 in ["-128i8", "128i8"]: + input_sql = self.genFullTypeSql(t1=t1)[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) - # #i16 - # for t2 in ["-32767i16", "32767i16"]: - # input_sql, stb_name, tb_name = self.genFullTypeSql(t2=t2) - # self.resCmp(input_sql, stb_name) - # for t2 in ["-32768i16", "32768i16"]: - # input_sql = self.genFullTypeSql(t2=t2)[0] - # code = self._conn.insertLines([input_sql]) - # tdSql.checkNotEqual(code, 0) + #i16 + for t2 in ["-32767i16", "32767i16"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(t2=t2) + self.resCmp(input_sql, stb_name) + for t2 in ["-32768i16", "32768i16"]: + input_sql = self.genFullTypeSql(t2=t2)[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) - # #i32 - # for t3 in ["-2147483647i32", "2147483647i32"]: - # input_sql, stb_name, tb_name = self.genFullTypeSql(t3=t3) - # self.resCmp(input_sql, stb_name) - # for t3 in ["-2147483648i32", "2147483648i32"]: - # input_sql = self.genFullTypeSql(t3=t3)[0] - # code = self._conn.insertLines([input_sql]) - # tdSql.checkNotEqual(code, 0) + #i32 + for t3 in ["-2147483647i32", "2147483647i32"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(t3=t3) + self.resCmp(input_sql, stb_name) + for t3 in ["-2147483648i32", "2147483648i32"]: + input_sql = self.genFullTypeSql(t3=t3)[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) - # #i64 - # for t4 in ["-9223372036854775807i64", "9223372036854775807i64"]: - # input_sql, stb_name, tb_name = self.genFullTypeSql(t4=t4) - # self.resCmp(input_sql, stb_name) - # for t4 in ["-9223372036854775808i64", "9223372036854775808i64"]: - # input_sql = self.genFullTypeSql(t4=t4)[0] - # code = self._conn.insertLines([input_sql]) - # tdSql.checkNotEqual(code, 0) + #i64 + for t4 in ["-9223372036854775807i64", "9223372036854775807i64"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(t4=t4) + self.resCmp(input_sql, stb_name) + for t4 in ["-9223372036854775808i64", "9223372036854775808i64"]: + input_sql = self.genFullTypeSql(t4=t4)[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) - # # f32 - # for t5 in [f"{-3.4028234663852885981170418348451692544*(10**38)}f32", f"{3.4028234663852885981170418348451692544*(10**38)}f32"]: - # input_sql, stb_name, tb_name = self.genFullTypeSql(t5=t5) - # self.resCmp(input_sql, stb_name) - # # * limit set to 4028234664*(10**38) - # for t5 in [f"{-3.4028234664*(10**38)}f32", f"{3.4028234664*(10**38)}f32"]: - # input_sql = self.genFullTypeSql(t5=t5)[0] - # code = self._conn.insertLines([input_sql]) - # tdSql.checkNotEqual(code, 0) + # f32 + for t5 in [f"{-3.4028234663852885981170418348451692544*(10**38)}f32", f"{3.4028234663852885981170418348451692544*(10**38)}f32"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(t5=t5) + self.resCmp(input_sql, stb_name) + # * limit set to 4028234664*(10**38) + for t5 in [f"{-3.4028234664*(10**38)}f32", f"{3.4028234664*(10**38)}f32"]: + input_sql = self.genFullTypeSql(t5=t5)[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) # f64 #!bug stack smashing detected ***: terminated Aborted # for t6 in [f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64', f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64']: @@ -541,25 +541,30 @@ class TDTestCase: input_sql, stb_name, tb_name = self.genFullTypeSql(t6=t6) self.resCmp(input_sql, stb_name) # TODO to confirm length + # * limit set to 1.797693134862316*(10**308) + for c6 in [f'{-1.797693134862316*(10**308)}f64', f'{-1.797693134862316*(10**308)}f64']: + input_sql = self.genFullTypeSql(c6=c6)[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) - # # binary - # stb_name = self.getLongName(7, "letters") - # input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16374, "letters")}" c0=f 1626006833639000000ns' - # code = self._conn.insertLines([input_sql]) - # tdSql.checkEqual(code, 0) - # input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16375, "letters")}" c0=f 1626006833639000000ns' - # code = self._conn.insertLines([input_sql]) - # tdSql.checkNotEqual(code, 0) + # binary + stb_name = self.getLongName(7, "letters") + input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16374, "letters")}" c0=f 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkEqual(code, 0) + input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16375, "letters")}" c0=f 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) - # # nchar - # # * legal nchar could not be larger than 16374/4 - # stb_name = self.getLongName(7, "letters") - # input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}" c0=f 1626006833639000000ns' - # code = self._conn.insertLines([input_sql]) - # tdSql.checkEqual(code, 0) - # input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4094, "letters")}" c0=f 1626006833639000000ns' - # code = self._conn.insertLines([input_sql]) - # tdSql.checkNotEqual(code, 0) + # nchar + # * legal nchar could not be larger than 16374/4 + stb_name = self.getLongName(7, "letters") + input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}" c0=f 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkEqual(code, 0) + input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4094, "letters")}" c0=f 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) def colValueLengthCheckCase(self): @@ -1097,10 +1102,10 @@ class TDTestCase: # self.illegalTsCheckCase() # ! confirm double - # self.tagValueLengthCheckCase() + self.tagValueLengthCheckCase() # ! bug - self.colValueLengthCheckCase() + # self.colValueLengthCheckCase() # self.tagColIllegalValueCheckCase() From 2d12fb24620ede217c138204d391e167e3ce25d5 Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Mon, 26 Jul 2021 10:38:15 +0800 Subject: [PATCH 17/31] save --- tests/pytest/insert/schemalessInsert.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index 16727b099d..08d775d72e 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -1102,10 +1102,10 @@ class TDTestCase: # self.illegalTsCheckCase() # ! confirm double - self.tagValueLengthCheckCase() + # self.tagValueLengthCheckCase() # ! bug - # self.colValueLengthCheckCase() + self.colValueLengthCheckCase() # self.tagColIllegalValueCheckCase() From 9eb31d3f4773be754dc0bb8395417e22b67ac0b4 Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Mon, 26 Jul 2021 10:45:00 +0800 Subject: [PATCH 18/31] save --- tests/pytest/insert/schemalessInsert.py | 120 ++++++++++++------------ 1 file changed, 60 insertions(+), 60 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index 08d775d72e..0ee22de6c1 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -534,7 +534,7 @@ class TDTestCase: code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) - # f64 #!bug stack smashing detected ***: terminated Aborted + # f64 # * bug stack smashing detected ***: terminated Aborted --- fixed # for t6 in [f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64', f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64']: for t6 in [f'{-1.79769*(10**308)}f64', f'{-1.79769*(10**308)}f64']: print("f64?") @@ -572,82 +572,82 @@ class TDTestCase: check full type col value limit """ self.cleanStb() - # # i8 - # for c1 in ["-127i8", "127i8"]: - # input_sql, stb_name, tb_name = self.genFullTypeSql(c1=c1) - # self.resCmp(input_sql, stb_name) + # i8 + for c1 in ["-127i8", "127i8"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(c1=c1) + self.resCmp(input_sql, stb_name) - # for c1 in ["-128i8", "128i8"]: - # input_sql = self.genFullTypeSql(c1=c1)[0] - # print(input_sql) - # code = self._conn.insertLines([input_sql]) - # tdSql.checkNotEqual(code, 0) - # # i16 - # for c2 in ["-32767i16"]: - # input_sql, stb_name, tb_name = self.genFullTypeSql(c2=c2) - # self.resCmp(input_sql, stb_name) - # for c2 in ["-32768i16", "32768i16"]: - # input_sql = self.genFullTypeSql(c2=c2)[0] - # code = self._conn.insertLines([input_sql]) - # tdSql.checkNotEqual(code, 0) + for c1 in ["-128i8", "128i8"]: + input_sql = self.genFullTypeSql(c1=c1)[0] + print(input_sql) + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + # i16 + for c2 in ["-32767i16"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(c2=c2) + self.resCmp(input_sql, stb_name) + for c2 in ["-32768i16", "32768i16"]: + input_sql = self.genFullTypeSql(c2=c2)[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) - # # i32 - # for c3 in ["-2147483647i32"]: - # input_sql, stb_name, tb_name = self.genFullTypeSql(c3=c3) - # self.resCmp(input_sql, stb_name) - # for c3 in ["-2147483648i32", "2147483648i32"]: - # input_sql = self.genFullTypeSql(c3=c3)[0] - # code = self._conn.insertLines([input_sql]) - # tdSql.checkNotEqual(code, 0) + # i32 + for c3 in ["-2147483647i32"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(c3=c3) + self.resCmp(input_sql, stb_name) + for c3 in ["-2147483648i32", "2147483648i32"]: + input_sql = self.genFullTypeSql(c3=c3)[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) - # # i64 - # for c4 in ["-9223372036854775807i64"]: - # input_sql, stb_name, tb_name = self.genFullTypeSql(c4=c4) - # self.resCmp(input_sql, stb_name) - # for c4 in ["-9223372036854775808i64", "9223372036854775808i64"]: - # input_sql = self.genFullTypeSql(c4=c4)[0] - # code = self._conn.insertLines([input_sql]) - # tdSql.checkNotEqual(code, 0) + # i64 + for c4 in ["-9223372036854775807i64"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(c4=c4) + self.resCmp(input_sql, stb_name) + for c4 in ["-9223372036854775808i64", "9223372036854775808i64"]: + input_sql = self.genFullTypeSql(c4=c4)[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) - # # f32 - # for c5 in [f"{-3.4028234663852885981170418348451692544*(10**38)}f32", f"{3.4028234663852885981170418348451692544*(10**38)}f32"]: - # input_sql, stb_name, tb_name = self.genFullTypeSql(c5=c5) - # self.resCmp(input_sql, stb_name) - # # * limit set to 4028234664*(10**38) - # for c5 in [f"{-3.4028234664*(10**38)}f32", f"{3.4028234664*(10**38)}f32"]: - # input_sql = self.genFullTypeSql(c5=c5)[0] - # code = self._conn.insertLines([input_sql]) - # tdSql.checkNotEqual(code, 0) + # f32 + for c5 in [f"{-3.4028234663852885981170418348451692544*(10**38)}f32", f"{3.4028234663852885981170418348451692544*(10**38)}f32"]: + input_sql, stb_name, tb_name = self.genFullTypeSql(c5=c5) + self.resCmp(input_sql, stb_name) + # * limit set to 4028234664*(10**38) + for c5 in [f"{-3.4028234664*(10**38)}f32", f"{3.4028234664*(10**38)}f32"]: + input_sql = self.genFullTypeSql(c5=c5)[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) - # # f64 - # for c6 in [f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64', f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64']: - # input_sql, stb_name, tb_name = self.genFullTypeSql(c6=c6) - # self.resCmp(input_sql, stb_name) - # # * limit set to 1.797693134862316*(10**308) - # for c6 in [f'{-1.797693134862316*(10**308)}f64', f'{-1.797693134862316*(10**308)}f64']: - # input_sql = self.genFullTypeSql(c6=c6)[0] - # code = self._conn.insertLines([input_sql]) - # tdSql.checkNotEqual(code, 0) + # f64 + for c6 in [f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64', f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64']: + input_sql, stb_name, tb_name = self.genFullTypeSql(c6=c6) + self.resCmp(input_sql, stb_name) + # * limit set to 1.797693134862316*(10**308) + for c6 in [f'{-1.797693134862316*(10**308)}f64', f'{-1.797693134862316*(10**308)}f64']: + input_sql = self.genFullTypeSql(c6=c6)[0] + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) # # binary stb_name = self.getLongName(7, "letters") input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}" 1626006833639000000ns' code = self._conn.insertLines([input_sql]) tdSql.checkEqual(code, 0) - # ! bug code is 0 + # * bug code is 0 ----- fixed input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16375, "letters")}" 1626006833639000000ns' code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) # nchar # * legal nchar could not be larger than 16374/4 - # stb_name = self.getLongName(7, "letters") - # input_sql = f'{stb_name},t0=t c0=f,c1=L"{self.getLongName(4093, "letters")}" 1626006833639000000ns' - # code = self._conn.insertLines([input_sql]) - # tdSql.checkEqual(code, 0) - # input_sql = f'{stb_name},t0=t c0=f,c1=L"{self.getLongName(4094, "letters")}" 1626006833639000000ns' - # code = self._conn.insertLines([input_sql]) - # tdSql.checkNotEqual(code, 0) + stb_name = self.getLongName(7, "letters") + input_sql = f'{stb_name},t0=t c0=f,c1=L"{self.getLongName(4093, "letters")}" 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkEqual(code, 0) + input_sql = f'{stb_name},t0=t c0=f,c1=L"{self.getLongName(4094, "letters")}" 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) def tagColIllegalValueCheckCase(self): From 909ff0b2a142471ce8130bf594688175e748691a Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Mon, 26 Jul 2021 13:53:25 +0800 Subject: [PATCH 19/31] save --- tests/pytest/insert/schemalessInsert.py | 72 ++++++++++++++----------- 1 file changed, 40 insertions(+), 32 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index 0ee22de6c1..6658f43429 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -371,10 +371,12 @@ class TDTestCase: """ test ts list --> ["1626006833639000000ns", "1626006833639019us", "1626006833640ms", "1626006834s", "1626006822639022"] # ! us级时间戳都为0时，数据库中查询显示，但python接口拿到的结果不显示 .000000的情况请确认，目前修改时间处理代码可以通过 + # ! case bug """ self.cleanStb() ts_list = ["1626006833639000000ns", "1626006833639019us", "1626006833640ms", "1626006834s", "1626006822639022", 0] for ts in ts_list: + print(ts) input_sql, stb_name, tb_name = self.genFullTypeSql(ts=ts) self.resCmp(input_sql, stb_name, ts) @@ -747,7 +749,7 @@ class TDTestCase: self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"') # ! use tb_name - # ! bug + # ! need to improve 目前输出未校验 def tagColAddDupIDCheckCase(self): """ check column and tag count add, stb and tb duplicate @@ -758,7 +760,7 @@ class TDTestCase: self.resCmp(input_sql, stb_name) input_sql, stb_name, tb_name = self.genFullTypeSql(stb_name=stb_name, tb_name=f'{tb_name}', t0="f", c0="f", ct_add_tag=True) print(input_sql) - 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 tagColAddCheckCase(self): """ @@ -1067,7 +1069,7 @@ class TDTestCase: input_sql1 = "rfasta,id=\"rfasta_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7=\"ddzhiksj\",t8=L\"ncharTagValue\" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7=\"bnhwlgvj\",c8=L\"ncharTagValue\",c9=7u64 1626006833639000000ns" input_sql2 = "rfasta,t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7=\"ddzhiksj\",t8=L\"ncharTagValue\" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7=\"bnhwlgvj\",c8=L\"ncharColValue\",c9=7u64 1626006833639000000ns" - input_sql3 = f'ab*cd,id="ccc",t0=True,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="ndsfdrum",t8=L"ncharTagValue" c0=f,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="igwoehkm",c8=L"ncharColValue",c9=7u64 0' + input_sql3 = f'abcd,id="cc$Ec",t0=True,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="ndsfdrum",t8=L"ncharTagValue" c0=f,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="igwoehkm",c8=L"ncharColValue",c9=7u64 0' print(input_sql3) # input_sql4 = 'hmemeb,id="kilrcrldgf",t0=F,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="fysodjql",t8=L"ncharTagValue" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="waszbfvc",c8=L"ncharColValue",c9=7u64 0' @@ -1087,50 +1089,56 @@ class TDTestCase: # tdSql.execute('create table st1 using super_table_cname_check tags (1, 2, 1.1, 2.2, "a", 1, 1, true, "aa");') # tdSql.execute('insert into st1 values (now, 1, 2, 1.1, 2.2, "a", 1, 1, true, "aa");') - # self.initCheckCase() - # self.boolTypeCheckCase() - # self.symbolsCheckCase() + self.initCheckCase() + self.boolTypeCheckCase() + self.symbolsCheckCase() + # ! case bug # self.tsCheckCase() - # self.idSeqCheckCase() - # self.idUpperCheckCase() - # self.noIdCheckCase() - # self.maxColTagCheckCase() - # self.idIllegalNameCheckCase() - # self.idStartWithNumCheckCase() - # self.nowTsCheckCase() - # self.dateFormatTsCheckCase() - # self.illegalTsCheckCase() + self.idSeqCheckCase() + self.idUpperCheckCase() + self.noIdCheckCase() + self.maxColTagCheckCase() + self.idIllegalNameCheckCase() + self.idStartWithNumCheckCase() + self.nowTsCheckCase() + self.dateFormatTsCheckCase() + self.illegalTsCheckCase() # ! confirm double # self.tagValueLengthCheckCase() # ! bug - self.colValueLengthCheckCase() + # self.colValueLengthCheckCase() - # self.tagColIllegalValueCheckCase() + self.tagColIllegalValueCheckCase() + # ! 重复ID未合并 # self.duplicateIdTagColInsertCheckCase() - # self.noIdStbExistCheckCase() - # self.duplicateInsertExistCheckCase() - # self.tagColBinaryNcharLengthCheckCase() - # self.tagColAddDupIDCheckCase() - # self.tagColAddCheckCase() - # self.tagMd5Check() + + self.noIdStbExistCheckCase() + self.duplicateInsertExistCheckCase() + self.tagColBinaryNcharLengthCheckCase() + + # ! 结果未校验 + self.tagColAddDupIDCheckCase() + + self.tagColAddCheckCase() + self.tagMd5Check() # ! rollback bug - # self.tagColBinaryMaxLengthCheckCase() - # self.tagColNcharMaxLengthCheckCase() + self.tagColBinaryMaxLengthCheckCase() + self.tagColNcharMaxLengthCheckCase() - # self.batchInsertCheckCase() + self.batchInsertCheckCase() # self.multiInsertCheckCase(5000) # ! bug - # self.batchErrorInsertCheckCase() + self.batchErrorInsertCheckCase() - # self.stbInsertMultiThreadCheckCase() - # self.sStbStbDdataInsertMultiThreadCheckCase() - # self.sStbStbDdataAtcInsertMultiThreadCheckCase() - # self.sStbStbDdataMtcInsertMultiThreadCheckCase() - # self.sStbDtbDdataInsertMultiThreadCheckCase() + self.stbInsertMultiThreadCheckCase() + self.sStbStbDdataInsertMultiThreadCheckCase() + self.sStbStbDdataAtcInsertMultiThreadCheckCase() + self.sStbStbDdataMtcInsertMultiThreadCheckCase() + self.sStbDtbDdataInsertMultiThreadCheckCase() # ! concurrency conflict # self.sStbDtbDdataAcMtInsertMultiThreadCheckCase() From 361e9f81d62f6152bfe06ea38dbb6636c25df443 Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Mon, 26 Jul 2021 16:23:20 +0800 Subject: [PATCH 20/31] save --- tests/pytest/insert/schemalessInsert.py | 58 ++++++++++++------------- 1 file changed, 29 insertions(+), 29 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index 6658f43429..78dc15dc81 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -1089,20 +1089,20 @@ class TDTestCase: # tdSql.execute('create table st1 using super_table_cname_check tags (1, 2, 1.1, 2.2, "a", 1, 1, true, "aa");') # tdSql.execute('insert into st1 values (now, 1, 2, 1.1, 2.2, "a", 1, 1, true, "aa");') - self.initCheckCase() - self.boolTypeCheckCase() - self.symbolsCheckCase() + # self.initCheckCase() + # self.boolTypeCheckCase() + # self.symbolsCheckCase() # ! case bug # self.tsCheckCase() - self.idSeqCheckCase() - self.idUpperCheckCase() - self.noIdCheckCase() - self.maxColTagCheckCase() - self.idIllegalNameCheckCase() - self.idStartWithNumCheckCase() - self.nowTsCheckCase() - self.dateFormatTsCheckCase() - self.illegalTsCheckCase() + # self.idSeqCheckCase() + # self.idUpperCheckCase() + # self.noIdCheckCase() + # self.maxColTagCheckCase() + # self.idIllegalNameCheckCase() + # self.idStartWithNumCheckCase() + # self.nowTsCheckCase() + # self.dateFormatTsCheckCase() + # self.illegalTsCheckCase() # ! confirm double # self.tagValueLengthCheckCase() @@ -1110,35 +1110,35 @@ class TDTestCase: # ! bug # self.colValueLengthCheckCase() - self.tagColIllegalValueCheckCase() + # self.tagColIllegalValueCheckCase() # ! 重复ID未合并 # self.duplicateIdTagColInsertCheckCase() - self.noIdStbExistCheckCase() - self.duplicateInsertExistCheckCase() - self.tagColBinaryNcharLengthCheckCase() + # self.noIdStbExistCheckCase() + # self.duplicateInsertExistCheckCase() + # self.tagColBinaryNcharLengthCheckCase() # ! 结果未校验 - self.tagColAddDupIDCheckCase() + # self.tagColAddDupIDCheckCase() - self.tagColAddCheckCase() - self.tagMd5Check() + # self.tagColAddCheckCase() + # self.tagMd5Check() # ! rollback bug - self.tagColBinaryMaxLengthCheckCase() - self.tagColNcharMaxLengthCheckCase() + # self.tagColBinaryMaxLengthCheckCase() + # self.tagColNcharMaxLengthCheckCase() - self.batchInsertCheckCase() + # self.batchInsertCheckCase() # self.multiInsertCheckCase(5000) # ! bug - self.batchErrorInsertCheckCase() + # self.batchErrorInsertCheckCase() - self.stbInsertMultiThreadCheckCase() - self.sStbStbDdataInsertMultiThreadCheckCase() - self.sStbStbDdataAtcInsertMultiThreadCheckCase() - self.sStbStbDdataMtcInsertMultiThreadCheckCase() - self.sStbDtbDdataInsertMultiThreadCheckCase() + # self.stbInsertMultiThreadCheckCase() + # self.sStbStbDdataInsertMultiThreadCheckCase() + # self.sStbStbDdataAtcInsertMultiThreadCheckCase() + # self.sStbStbDdataMtcInsertMultiThreadCheckCase() + # self.sStbDtbDdataInsertMultiThreadCheckCase() # ! concurrency conflict # self.sStbDtbDdataAcMtInsertMultiThreadCheckCase() @@ -1146,7 +1146,7 @@ class TDTestCase: # ! concurrency conflict # self.sStbStbDdataDtsInsertMultiThreadCheckCase() - # self.test() + self.test() From 7f5aaa25d3f51c7182dc039a7108533da0b92e60 Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Mon, 26 Jul 2021 19:12:50 +0800 Subject: [PATCH 21/31] modify some cases --- tests/pytest/insert/schemalessInsert.py | 65 +++++++++++++------------ 1 file changed, 35 insertions(+), 30 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index 78dc15dc81..f4b1dde000 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -29,6 +29,15 @@ class TDTestCase: tdSql.init(conn.cursor(), logSql) self._conn = conn + def createDb(self, name="test", db_update_tag=0): + if db_update_tag == 0: + tdSql.execute(f"drop database if exists {name}") + tdSql.execute(f"create database if not exists {name} precision 'us'") + else: + tdSql.execute(f"drop database if exists {name}") + tdSql.execute(f"create database if not exists {name} precision 'us' update 1") + tdSql.execute(f'use {name}') + def getLongName(self, len, mode = "mixed"): """ generate long name @@ -371,14 +380,13 @@ class TDTestCase: """ test ts list --> ["1626006833639000000ns", "1626006833639019us", "1626006833640ms", "1626006834s", "1626006822639022"] # ! us级时间戳都为0时，数据库中查询显示，但python接口拿到的结果不显示 .000000的情况请确认，目前修改时间处理代码可以通过 - # ! case bug """ self.cleanStb() ts_list = ["1626006833639000000ns", "1626006833639019us", "1626006833640ms", "1626006834s", "1626006822639022", 0] for ts in ts_list: - print(ts) input_sql, stb_name, tb_name = self.genFullTypeSql(ts=ts) - self.resCmp(input_sql, stb_name, ts) + print(input_sql) + self.resCmp(input_sql, stb_name, ts=ts) def idSeqCheckCase(self): """ @@ -428,24 +436,16 @@ class TDTestCase: code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) - # print("insertLines result {}".format(code)) - # query_sql = f"describe {stb_name}" - # insert_tag_col_num = len(self.resHandle(query_sql, True)[0]) - # expected_num = 128 + 1023 + 1 - # tdSql.checkEqual(insert_tag_col_num, expected_num) - - # input_sql, stb_name = self.genLongSql(128, 1500) - # code = self._conn.insertLines([input_sql]) - # print(f'code---{code}') - def idIllegalNameCheckCase(self): """ test illegal id name + mix "`~!@#$¥%^&*()-+={}|[]、「」【】\:;《》<>?" """ self.cleanStb() - rstr = list("!@#$%^&*()-+={}|[]\:<>?") + rstr = list("`~!@#$¥%^&*()-+={}|[]、「」【】\:;《》<>?") for i in rstr: input_sql = self.genFullTypeSql(tb_name=f"\"aaa{i}bbb\"")[0] + print(input_sql) code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) @@ -710,8 +710,6 @@ class TDTestCase: code = self._conn.insertLines([input_sql_col]) tdSql.checkNotEqual(code, 0) - - ##### stb exist ##### def noIdStbExistCheckCase(self): """ @@ -749,18 +747,28 @@ class TDTestCase: self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"') # ! use tb_name - # ! need to improve 目前输出未校验 def tagColAddDupIDCheckCase(self): """ check column and tag count add, stb and tb duplicate + * tag: alter table ... + * col: when update==0 and ts is same, unchange + * so this case tag&&value will be added, + * col is added without value when update==0 + * col is added with value when update==1 """ self.cleanStb() - input_sql, stb_name, tb_name = self.genFullTypeSql(t0="f", c0="f") - print(input_sql) - self.resCmp(input_sql, stb_name) - input_sql, stb_name, tb_name = self.genFullTypeSql(stb_name=stb_name, tb_name=f'{tb_name}', t0="f", c0="f", ct_add_tag=True) - print(input_sql) - # self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"') + for db_update_tag in [0, 1]: + if db_update_tag == 1 : + self.createDb("test_update", db_update_tag=db_update_tag) + input_sql, stb_name, tb_name = self.genFullTypeSql(t0="f", c0="f") + self.resCmp(input_sql, stb_name) + input_sql, stb_name, tb_name = self.genFullTypeSql(stb_name=stb_name, tb_name=f'{tb_name}', t0="f", c0="f", ct_add_tag=True) + if db_update_tag == 1 : + self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"') + else: + self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"', none_check_tag=True) + + def tagColAddCheckCase(self): """ @@ -1069,7 +1077,7 @@ class TDTestCase: input_sql1 = "rfasta,id=\"rfasta_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7=\"ddzhiksj\",t8=L\"ncharTagValue\" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7=\"bnhwlgvj\",c8=L\"ncharTagValue\",c9=7u64 1626006833639000000ns" input_sql2 = "rfasta,t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7=\"ddzhiksj\",t8=L\"ncharTagValue\" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7=\"bnhwlgvj\",c8=L\"ncharColValue\",c9=7u64 1626006833639000000ns" - input_sql3 = f'abcd,id="cc$Ec",t0=True,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="ndsfdrum",t8=L"ncharTagValue" c0=f,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="igwoehkm",c8=L"ncharColValue",c9=7u64 0' + input_sql3 = f'abcd,id="cc¥Ec",t0=True,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="ndsfdrum",t8=L"ncharTagValue" c0=f,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="igwoehkm",c8=L"ncharColValue",c9=7u64 0' print(input_sql3) # input_sql4 = 'hmemeb,id="kilrcrldgf",t0=F,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="fysodjql",t8=L"ncharTagValue" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="waszbfvc",c8=L"ncharColValue",c9=7u64 0' @@ -1080,9 +1088,7 @@ class TDTestCase: def run(self): print("running {}".format(__file__)) - tdSql.execute("drop database if exists test") - tdSql.execute("create database if not exists test precision 'us'") - tdSql.execute('use test') + self.createDb() # tdSql.execute("create table super_table_cname_check (ts timestamp, pi1 int, pi2 bigint, pf1 float, pf2 double, ps1 binary(10), pi3 smallint, pi4 tinyint, pb1 bool, ps2 nchar(20)) tags (si1 int, si2 bigint, sf1 float, sf2 double, ss1 binary(10), si3 smallint, si4 tinyint, sb1 bool, ss2 nchar(20));") @@ -1092,7 +1098,6 @@ class TDTestCase: # self.initCheckCase() # self.boolTypeCheckCase() # self.symbolsCheckCase() - # ! case bug # self.tsCheckCase() # self.idSeqCheckCase() # self.idUpperCheckCase() @@ -1120,7 +1125,7 @@ class TDTestCase: # self.tagColBinaryNcharLengthCheckCase() # ! 结果未校验 - # self.tagColAddDupIDCheckCase() + self.tagColAddDupIDCheckCase() # self.tagColAddCheckCase() # self.tagMd5Check() @@ -1146,7 +1151,7 @@ class TDTestCase: # ! concurrency conflict # self.sStbStbDdataDtsInsertMultiThreadCheckCase() - self.test() + # self.test() From 28b7529ba7af5f4f409fc61a3ffb654fd4541473 Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Tue, 27 Jul 2021 11:46:59 +0800 Subject: [PATCH 22/31] delete unused tb_name --- tests/pytest/insert/schemalessInsert.py | 110 ++++++++++-------------- 1 file changed, 46 insertions(+), 64 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index f4b1dde000..952c383f3a 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -67,7 +67,6 @@ class TDTestCase: ulsec = repr(ts).split('.')[1][:6] if len(ulsec) < 6 and int(ulsec) != 0: ulsec = int(ulsec) * (10 ** (6 - len(ulsec))) - # ! to confirm .000000 elif int(ulsec) == 0: ulsec *= 6 # ! follow two rows added for tsCheckCase @@ -101,7 +100,6 @@ class TDTestCase: td_type = "FLOAT" td_tag_value = ''.join(list(value)[:-3]) td_tag_value = '{}'.format(np.float32(td_tag_value)) - elif value.endswith("f64"): td_type = "DOUBLE" td_tag_value = ''.join(list(value)[:-3]) @@ -171,7 +169,6 @@ class TDTestCase: for elm in stb_tag_list: if "id=" in elm.lower(): - # id_index = stb_id_tag_list.index(elm) tb_name = elm.split('=')[1] else: tag_name_list.append(elm.split("=")[0]) @@ -186,26 +183,10 @@ class TDTestCase: td_col_value_list.append(self.getTdTypeValue(elm.split("=")[1])[1]) td_col_type_list.append(self.getTdTypeValue(elm.split("=")[1])[0]) - # print(stb_name) - # print(tb_name) - # print(tag_name_list) - # print(tag_value_list) - # print(td_tag_type_list) - # print(td_tag_value_list) - - # print(ts_value) - - # print(col_name_list) - # print(col_value_list) - # print(td_col_value_list) - # print(td_col_type_list) - - # print("final type--------######") final_field_list = [] final_field_list.extend(col_name_list) final_field_list.extend(tag_name_list) - # print("final type--------######") final_type_list = [] final_type_list.append("TIMESTAMP") final_type_list.extend(td_col_type_list) @@ -216,9 +197,6 @@ class TDTestCase: final_value_list.append(ts_value) final_value_list.extend(td_col_value_list) final_value_list.extend(td_tag_value_list) - # print("-----------value-----------") - # print(final_value_list) - # print("-----------value-----------") return final_value_list, final_field_list, final_type_list, stb_name, tb_name def genFullTypeSql(self, stb_name="", tb_name="", t0="", t1="127i8", t2="32767i16", t3="2147483647i32", @@ -262,7 +240,7 @@ class TDTestCase: sql_seq = f'{stb_name},t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6},t7={t7},t8={t8},t11={t1},t10={t8} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6} {ts}' if ct_min_tag is not None: sql_seq = f'{stb_name},{id}=\"{tb_name}\",t0={t0},t1={t1},t2={t2},t3={t3},t4={t4},t5={t5},t6={t6} c0={c0},c1={c1},c2={c2},c3={c3},c4={c4},c5={c5},c6={c6} {ts}' - return sql_seq, stb_name, tb_name + return sql_seq, stb_name def genMulTagColStr(self, genType, count): """ @@ -349,7 +327,7 @@ class TDTestCase: normal tags and cols, one for every elm """ self.cleanStb() - input_sql, stb_name, tb_name = self.genFullTypeSql() + input_sql, stb_name = self.genFullTypeSql() self.resCmp(input_sql, stb_name) def boolTypeCheckCase(self): @@ -359,7 +337,7 @@ class TDTestCase: self.cleanStb() full_type_list = ["f", "F", "false", "False", "t", "T", "true", "True"] for t_type in full_type_list: - input_sql, stb_name, tb_name = self.genFullTypeSql(c0=t_type, t0=t_type) + input_sql, stb_name = self.genFullTypeSql(c0=t_type, t0=t_type) self.resCmp(input_sql, stb_name) def symbolsCheckCase(self): @@ -373,7 +351,7 @@ class TDTestCase: self.cleanStb() binary_symbols = '\"abcd`~!@#$%^&*()_-{[}]|:;<.>?lfjal"\"' nchar_symbols = f'L{binary_symbols}' - input_sql, stb_name, tb_name = self.genFullTypeSql(c7=binary_symbols, c8=nchar_symbols, t7=binary_symbols, t8=nchar_symbols) + input_sql, stb_name = self.genFullTypeSql(c7=binary_symbols, c8=nchar_symbols, t7=binary_symbols, t8=nchar_symbols) self.resCmp(input_sql, stb_name) def tsCheckCase(self): @@ -394,7 +372,7 @@ class TDTestCase: eg: t0=**,id=**,t1=** """ self.cleanStb() - input_sql, stb_name, tb_name = self.genFullTypeSql(id_change_tag=True) + input_sql, stb_name = self.genFullTypeSql(id_change_tag=True) self.resCmp(input_sql, stb_name) def idUpperCheckCase(self): @@ -403,9 +381,9 @@ class TDTestCase: eg: id and ID """ self.cleanStb() - input_sql, stb_name, tb_name = self.genFullTypeSql(id_upper_tag=True) + input_sql, stb_name = self.genFullTypeSql(id_upper_tag=True) self.resCmp(input_sql, stb_name) - input_sql, stb_name, tb_name = self.genFullTypeSql(id_change_tag=True, id_upper_tag=True) + input_sql, stb_name = self.genFullTypeSql(id_change_tag=True, id_upper_tag=True) self.resCmp(input_sql, stb_name) def noIdCheckCase(self): @@ -413,7 +391,7 @@ class TDTestCase: id not exist """ self.cleanStb() - input_sql, stb_name, tb_name = self.genFullTypeSql(id_noexist_tag=True) + input_sql, stb_name = self.genFullTypeSql(id_noexist_tag=True) self.resCmp(input_sql, stb_name) query_sql = f"select tbname from {stb_name}" res_row_list = self.resHandle(query_sql, True)[0] @@ -492,7 +470,7 @@ class TDTestCase: self.cleanStb() # i8 for t1 in ["-127i8", "127i8"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(t1=t1) + input_sql, stb_name = self.genFullTypeSql(t1=t1) self.resCmp(input_sql, stb_name) for t1 in ["-128i8", "128i8"]: input_sql = self.genFullTypeSql(t1=t1)[0] @@ -501,7 +479,7 @@ class TDTestCase: #i16 for t2 in ["-32767i16", "32767i16"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(t2=t2) + input_sql, stb_name = self.genFullTypeSql(t2=t2) self.resCmp(input_sql, stb_name) for t2 in ["-32768i16", "32768i16"]: input_sql = self.genFullTypeSql(t2=t2)[0] @@ -510,7 +488,7 @@ class TDTestCase: #i32 for t3 in ["-2147483647i32", "2147483647i32"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(t3=t3) + input_sql, stb_name = self.genFullTypeSql(t3=t3) self.resCmp(input_sql, stb_name) for t3 in ["-2147483648i32", "2147483648i32"]: input_sql = self.genFullTypeSql(t3=t3)[0] @@ -519,7 +497,7 @@ class TDTestCase: #i64 for t4 in ["-9223372036854775807i64", "9223372036854775807i64"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(t4=t4) + input_sql, stb_name = self.genFullTypeSql(t4=t4) self.resCmp(input_sql, stb_name) for t4 in ["-9223372036854775808i64", "9223372036854775808i64"]: input_sql = self.genFullTypeSql(t4=t4)[0] @@ -528,7 +506,7 @@ class TDTestCase: # f32 for t5 in [f"{-3.4028234663852885981170418348451692544*(10**38)}f32", f"{3.4028234663852885981170418348451692544*(10**38)}f32"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(t5=t5) + input_sql, stb_name = self.genFullTypeSql(t5=t5) self.resCmp(input_sql, stb_name) # * limit set to 4028234664*(10**38) for t5 in [f"{-3.4028234664*(10**38)}f32", f"{3.4028234664*(10**38)}f32"]: @@ -540,7 +518,7 @@ class TDTestCase: # for t6 in [f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64', f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64']: for t6 in [f'{-1.79769*(10**308)}f64', f'{-1.79769*(10**308)}f64']: print("f64?") - input_sql, stb_name, tb_name = self.genFullTypeSql(t6=t6) + input_sql, stb_name = self.genFullTypeSql(t6=t6) self.resCmp(input_sql, stb_name) # TODO to confirm length # * limit set to 1.797693134862316*(10**308) @@ -576,7 +554,7 @@ class TDTestCase: self.cleanStb() # i8 for c1 in ["-127i8", "127i8"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(c1=c1) + input_sql, stb_name = self.genFullTypeSql(c1=c1) self.resCmp(input_sql, stb_name) for c1 in ["-128i8", "128i8"]: @@ -586,7 +564,7 @@ class TDTestCase: tdSql.checkNotEqual(code, 0) # i16 for c2 in ["-32767i16"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(c2=c2) + input_sql, stb_name = self.genFullTypeSql(c2=c2) self.resCmp(input_sql, stb_name) for c2 in ["-32768i16", "32768i16"]: input_sql = self.genFullTypeSql(c2=c2)[0] @@ -595,7 +573,7 @@ class TDTestCase: # i32 for c3 in ["-2147483647i32"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(c3=c3) + input_sql, stb_name = self.genFullTypeSql(c3=c3) self.resCmp(input_sql, stb_name) for c3 in ["-2147483648i32", "2147483648i32"]: input_sql = self.genFullTypeSql(c3=c3)[0] @@ -604,7 +582,7 @@ class TDTestCase: # i64 for c4 in ["-9223372036854775807i64"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(c4=c4) + input_sql, stb_name = self.genFullTypeSql(c4=c4) self.resCmp(input_sql, stb_name) for c4 in ["-9223372036854775808i64", "9223372036854775808i64"]: input_sql = self.genFullTypeSql(c4=c4)[0] @@ -613,7 +591,7 @@ class TDTestCase: # f32 for c5 in [f"{-3.4028234663852885981170418348451692544*(10**38)}f32", f"{3.4028234663852885981170418348451692544*(10**38)}f32"]: - input_sql, stb_name, tb_name = self.genFullTypeSql(c5=c5) + input_sql, stb_name = self.genFullTypeSql(c5=c5) self.resCmp(input_sql, stb_name) # * limit set to 4028234664*(10**38) for c5 in [f"{-3.4028234664*(10**38)}f32", f"{3.4028234664*(10**38)}f32"]: @@ -623,7 +601,7 @@ class TDTestCase: # f64 for c6 in [f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64', f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64']: - input_sql, stb_name, tb_name = self.genFullTypeSql(c6=c6) + input_sql, stb_name = self.genFullTypeSql(c6=c6) self.resCmp(input_sql, stb_name) # * limit set to 1.797693134862316*(10**308) for c6 in [f'{-1.797693134862316*(10**308)}f64', f'{-1.797693134862316*(10**308)}f64']: @@ -716,9 +694,9 @@ class TDTestCase: case no id when stb exist """ self.cleanStb() - input_sql, stb_name, tb_name = self.genFullTypeSql(t0="f", c0="f") + input_sql, stb_name = self.genFullTypeSql(t0="f", c0="f") self.resCmp(input_sql, stb_name) - input_sql, stb_name, tb_name = self.genFullTypeSql(stb_name=stb_name, id_noexist_tag=True, t0="f", c0="f") + input_sql, stb_name = self.genFullTypeSql(stb_name=stb_name, id_noexist_tag=True, t0="f", c0="f") self.resCmp(input_sql, stb_name, condition='where tbname like "t_%"') tdSql.query(f"select * from {stb_name}") tdSql.checkRows(2) @@ -729,7 +707,7 @@ class TDTestCase: check duplicate insert when stb exist """ self.cleanStb() - input_sql, stb_name, tb_name = self.genFullTypeSql() + input_sql, stb_name = self.genFullTypeSql() self.resCmp(input_sql, stb_name) code = self._conn.insertLines([input_sql]) tdSql.checkEqual(code, 0) @@ -740,10 +718,10 @@ class TDTestCase: check length increase """ self.cleanStb() - input_sql, stb_name, tb_name = self.genFullTypeSql() + input_sql, stb_name = self.genFullTypeSql() self.resCmp(input_sql, stb_name) tb_name = self.getLongName(5, "letters") - input_sql, stb_name, tb_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\"", c7="\"binaryTagValuebinaryTagValue\"", c8="L\"ncharTagValuencharTagValue\"") self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"') # ! use tb_name @@ -757,27 +735,28 @@ class TDTestCase: * col is added with value when update==1 """ self.cleanStb() + tb_name = self.getLongName(7, "letters") for db_update_tag in [0, 1]: if db_update_tag == 1 : self.createDb("test_update", db_update_tag=db_update_tag) - input_sql, stb_name, tb_name = self.genFullTypeSql(t0="f", c0="f") + input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name, t0="f", c0="f") self.resCmp(input_sql, stb_name) - input_sql, stb_name, tb_name = self.genFullTypeSql(stb_name=stb_name, tb_name=f'{tb_name}', t0="f", c0="f", ct_add_tag=True) + self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t0="f", c0="f", ct_add_tag=True) if db_update_tag == 1 : self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"') else: self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"', none_check_tag=True) - - def tagColAddCheckCase(self): """ check column and tag count add """ self.cleanStb() - input_sql, stb_name, tb_name = self.genFullTypeSql(t0="f", c0="f") + tb_name = self.getLongName(7, "letters") + input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name, t0="f", c0="f") self.resCmp(input_sql, stb_name) - input_sql, stb_name, tb_name_1 = self.genFullTypeSql(stb_name=stb_name, tb_name=f'{tb_name}_1', t0="f", c0="f", ct_add_tag=True) + tb_name_1 = self.getLongName(7, "letters") + input_sql, stb_name = self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name_1, t0="f", c0="f", ct_add_tag=True) 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] tdSql.checkEqual(res_row_list[0], ['None', 'None', 'None', 'None']) @@ -789,16 +768,16 @@ class TDTestCase: insert two table, keep tag unchange, change col """ self.cleanStb() - input_sql, stb_name, tb_name = self.genFullTypeSql(t0="f", c0="f", id_noexist_tag=True) + input_sql, stb_name = self.genFullTypeSql(t0="f", c0="f", id_noexist_tag=True) self.resCmp(input_sql, stb_name) tb_name1 = self.getNoIdTbName(stb_name) - input_sql, stb_name, tb_name = self.genFullTypeSql(stb_name=stb_name, t0="f", c0="f", id_noexist_tag=True) + input_sql, stb_name = self.genFullTypeSql(stb_name=stb_name, t0="f", c0="f", id_noexist_tag=True) self.resCmp(input_sql, stb_name) tb_name2 = self.getNoIdTbName(stb_name) tdSql.query(f"select * from {stb_name}") tdSql.checkRows(1) tdSql.checkEqual(tb_name1, tb_name2) - input_sql, stb_name, tb_name = self.genFullTypeSql(stb_name=stb_name, t0="f", c0="f", id_noexist_tag=True, ct_add_tag=True) + input_sql, stb_name = self.genFullTypeSql(stb_name=stb_name, t0="f", c0="f", id_noexist_tag=True, ct_add_tag=True) self._conn.insertLines([input_sql]) tb_name3 = self.getNoIdTbName(stb_name) tdSql.query(f"select * from {stb_name}") @@ -898,7 +877,6 @@ class TDTestCase: code = self._conn.insertLines(sql_list) tdSql.checkEqual(code, 0) - # ! bug def batchErrorInsertCheckCase(self): """ test batch error insert @@ -971,7 +949,8 @@ class TDTestCase: thread input same stb tb, different data, result keep first data """ self.cleanStb() - input_sql, stb_name, tb_name = self.genFullTypeSql(tb_name=self.getLongName(10, "letters")) + tb_name = self.getLongName(7, "letters") + input_sql, stb_name = self.genFullTypeSql(tb_name=tb_name) self.resCmp(input_sql, stb_name) 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)) @@ -987,7 +966,8 @@ class TDTestCase: thread input same stb tb, different data, add columes and tags, result keep first data """ self.cleanStb() - input_sql, stb_name, tb_name = self.genFullTypeSql(tb_name=self.getLongName(10, "letters")) + tb_name = self.getLongName(7, "letters") + input_sql, stb_name = self.genFullTypeSql(tb_name=tb_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] self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_a_col_a_tag_list)) @@ -1003,7 +983,8 @@ class TDTestCase: thread input same stb tb, different data, minus columes and tags, result keep first data """ self.cleanStb() - input_sql, stb_name, tb_name = self.genFullTypeSql(tb_name=self.getLongName(10, "letters")) + tb_name = self.getLongName(7, "letters") + input_sql, stb_name = self.genFullTypeSql(tb_name=tb_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] self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_m_col_m_tag_list)) @@ -1019,7 +1000,7 @@ class TDTestCase: thread input same stb, different tb, different data """ self.cleanStb() - input_sql, stb_name, tb_name = self.genFullTypeSql() + input_sql, stb_name = self.genFullTypeSql() self.resCmp(input_sql, stb_name) s_stb_d_tb_list = self.genSqlList(stb_name=stb_name)[4] self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_list)) @@ -1034,7 +1015,7 @@ class TDTestCase: thread input same stb, different tb, different data, add col, mul tag """ self.cleanStb() - input_sql, stb_name, tb_name = self.genFullTypeSql() + input_sql, stb_name = self.genFullTypeSql() self.resCmp(input_sql, stb_name) s_stb_d_tb_a_col_m_tag_list = self.genSqlList(stb_name=stb_name)[5] self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_a_col_m_tag_list)) @@ -1049,7 +1030,7 @@ class TDTestCase: thread input same stb, different tb, different data, add tag, mul col """ self.cleanStb() - input_sql, stb_name, tb_name = self.genFullTypeSql() + input_sql, stb_name = self.genFullTypeSql() self.resCmp(input_sql, stb_name) s_stb_d_tb_a_tag_m_col_list = self.genSqlList(stb_name=stb_name)[6] self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_a_tag_m_col_list)) @@ -1061,7 +1042,8 @@ class TDTestCase: thread input same stb tb, different ts """ self.cleanStb() - input_sql, stb_name, tb_name = self.genFullTypeSql(tb_name=self.getLongName(10, "letters")) + tb_name = self.getLongName(7, "letters") + input_sql, stb_name = self.genFullTypeSql(tb_name=tb_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] print(s_stb_s_tb_d_ts_list) From 736adcf7ccdf581e5b64c3947468acc34569df31 Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Tue, 27 Jul 2021 13:52:44 +0800 Subject: [PATCH 23/31] combine cases --- tests/pytest/insert/schemalessInsert.py | 149 +++++++----------------- 1 file changed, 41 insertions(+), 108 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index 952c383f3a..253e50ea79 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -14,7 +14,6 @@ import random import string import time -import datetime from copy import deepcopy import numpy as np from util.log import * @@ -1052,8 +1051,6 @@ class TDTestCase: tdSql.checkRows(1) tdSql.query(f"select * from {stb_name}") tdSql.checkRows(6) - - def test(self): input_sql1 = "rfasta,id=\"rfasta_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7=\"ddzhiksj\",t8=L\"ncharTagValue\" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7=\"bnhwlgvj\",c8=L\"ncharTagValue\",c9=7u64 1626006833639000000ns" @@ -1062,138 +1059,74 @@ class TDTestCase: input_sql3 = f'abcd,id="cc¥Ec",t0=True,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="ndsfdrum",t8=L"ncharTagValue" c0=f,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="igwoehkm",c8=L"ncharColValue",c9=7u64 0' print(input_sql3) # input_sql4 = 'hmemeb,id="kilrcrldgf",t0=F,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="fysodjql",t8=L"ncharTagValue" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="waszbfvc",c8=L"ncharColValue",c9=7u64 0' - - code = self._conn.insertLines([input_sql3]) print(code) # self._conn.insertLines([input_sql4]) - def run(self): - print("running {}".format(__file__)) - self.createDb() - - - # tdSql.execute("create table super_table_cname_check (ts timestamp, pi1 int, pi2 bigint, pf1 float, pf2 double, ps1 binary(10), pi3 smallint, pi4 tinyint, pb1 bool, ps2 nchar(20)) tags (si1 int, si2 bigint, sf1 float, sf2 double, ss1 binary(10), si3 smallint, si4 tinyint, sb1 bool, ss2 nchar(20));") - # tdSql.execute('create table st1 using super_table_cname_check tags (1, 2, 1.1, 2.2, "a", 1, 1, true, "aa");') - # tdSql.execute('insert into st1 values (now, 1, 2, 1.1, 2.2, "a", 1, 1, true, "aa");') - - # self.initCheckCase() - # self.boolTypeCheckCase() - # self.symbolsCheckCase() - # self.tsCheckCase() - # self.idSeqCheckCase() - # self.idUpperCheckCase() - # self.noIdCheckCase() - # self.maxColTagCheckCase() - # self.idIllegalNameCheckCase() - # self.idStartWithNumCheckCase() - # self.nowTsCheckCase() - # self.dateFormatTsCheckCase() - # self.illegalTsCheckCase() + def runAll(self): + self.initCheckCase() + self.boolTypeCheckCase() + self.symbolsCheckCase() + self.tsCheckCase() + self.idSeqCheckCase() + self.idUpperCheckCase() + self.noIdCheckCase() + self.maxColTagCheckCase() + self.idIllegalNameCheckCase() + self.idStartWithNumCheckCase() + self.nowTsCheckCase() + self.dateFormatTsCheckCase() + self.illegalTsCheckCase() # ! confirm double - # self.tagValueLengthCheckCase() + self.tagValueLengthCheckCase() # ! bug - # self.colValueLengthCheckCase() + self.colValueLengthCheckCase() - # self.tagColIllegalValueCheckCase() + self.tagColIllegalValueCheckCase() # ! 重复ID未合并 - # self.duplicateIdTagColInsertCheckCase() + self.duplicateIdTagColInsertCheckCase() - # self.noIdStbExistCheckCase() - # self.duplicateInsertExistCheckCase() - # self.tagColBinaryNcharLengthCheckCase() + self.noIdStbExistCheckCase() + self.duplicateInsertExistCheckCase() + self.tagColBinaryNcharLengthCheckCase() # ! 结果未校验 self.tagColAddDupIDCheckCase() - # self.tagColAddCheckCase() - # self.tagMd5Check() + self.tagColAddCheckCase() + self.tagMd5Check() # ! rollback bug - # self.tagColBinaryMaxLengthCheckCase() - # self.tagColNcharMaxLengthCheckCase() + self.tagColBinaryMaxLengthCheckCase() + self.tagColNcharMaxLengthCheckCase() - # self.batchInsertCheckCase() - # self.multiInsertCheckCase(5000) + self.batchInsertCheckCase() + self.multiInsertCheckCase(5000) # ! bug - # self.batchErrorInsertCheckCase() + self.batchErrorInsertCheckCase() - # self.stbInsertMultiThreadCheckCase() - # self.sStbStbDdataInsertMultiThreadCheckCase() - # self.sStbStbDdataAtcInsertMultiThreadCheckCase() - # self.sStbStbDdataMtcInsertMultiThreadCheckCase() - # self.sStbDtbDdataInsertMultiThreadCheckCase() + self.stbInsertMultiThreadCheckCase() + self.sStbStbDdataInsertMultiThreadCheckCase() + self.sStbStbDdataAtcInsertMultiThreadCheckCase() + self.sStbStbDdataMtcInsertMultiThreadCheckCase() + self.sStbDtbDdataInsertMultiThreadCheckCase() # ! concurrency conflict - # self.sStbDtbDdataAcMtInsertMultiThreadCheckCase() - # self.sStbDtbDdataAtMcInsertMultiThreadCheckCase() + self.sStbDtbDdataAcMtInsertMultiThreadCheckCase() + self.sStbDtbDdataAtMcInsertMultiThreadCheckCase() # ! concurrency conflict + self.sStbStbDdataDtsInsertMultiThreadCheckCase() + + def run(self): + print("running {}".format(__file__)) + self.createDb() + self.runAll() - # self.sStbStbDdataDtsInsertMultiThreadCheckCase() # self.test() - - - - - - - # tdSql.execute('create stable ste(ts timestamp, f int) tags(t1 bigint)') - - # lines = [ "st,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000ns", - # "st,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64 1626006833640000000ns", - # "ste,t2=5f64,t3=L\"ste\" c1=true,c2=4i64,c3=\"iam\" 1626056811823316532ns", - # "stf,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64,c6=7u64 1626006933640000000ns", - # "st,t1=4i64,t2=5f64,t3=\"t4\" c1=3i64,c3=L\"passitagain\",c2=true,c4=5f64 1626006833642000000ns", - # "ste,t2=5f64,t3=L\"ste2\" c3=\"iamszhou\",c4=false 1626056811843316532ns", - # "ste,t2=5f64,t3=L\"ste2\" c3=\"iamszhou\",c4=false,c5=32i8,c6=64i16,c7=32i32,c8=88.88f32 1626056812843316532ns", - # "st,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64,c6=7u64 1626006933640000000ns", - # "stf,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin_stf\",c2=false,c5=5f64,c6=7u64 1626006933641000000ns" - # ] - - # code = self._conn.insertLines(lines) - # print("insertLines result {}".format(code)) - - # lines2 = [ "stg,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000ns", - # "stg,t1=4i64,t3=\"t4\",t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin\",c2=true,c4=5f64,c5=5f64 1626006833640000000ns" - # ] - - # code = self._conn.insertLines([ lines2[0] ]) - # print("insertLines result {}".format(code)) - - # self._conn.insertLines([ lines2[1] ]) - # print("insertLines result {}".format(code)) - - # tdSql.query("select * from st") - # tdSql.checkRows(4) - - # tdSql.query("select * from ste") - # tdSql.checkRows(3) - - # tdSql.query("select * from stf") - # tdSql.checkRows(2) - - # tdSql.query("select * from stg") - # tdSql.checkRows(2) - - # tdSql.query("show tables") - # tdSql.checkRows(8) - - # tdSql.query("describe stf") - # tdSql.checkData(2, 2, 14) - - # self._conn.insertLines([ - # "sth,t1=4i64,t2=5f64,t4=5f64,ID=\"childtable\" c1=3i64,c3=L\"passitagin_stf\",c2=false,c5=5f64,c6=7u64 1626006933641ms", - # "sth,t1=4i64,t2=5f64,t4=5f64 c1=3i64,c3=L\"passitagin_stf\",c2=false,c5=5f64,c6=7u64 1626006933654ms" - # ]) - # tdSql.query('select tbname, * from sth') - # tdSql.checkRows(2) - - # tdSql.query('select tbname, * from childtable') - # tdSql.checkRows(1) def stop(self): tdSql.close() tdLog.success("%s successfully executed" % __file__) From 1bf4e5669e2757e7a16bc4010d4c8b1960705643 Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Wed, 28 Jul 2021 09:47:45 +0800 Subject: [PATCH 24/31] modify --- tests/pytest/insert/schemalessInsert.py | 117 +++++++++++++++++++++--- 1 file changed, 105 insertions(+), 12 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index 253e50ea79..cc3755f17b 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -907,6 +907,11 @@ class TDTestCase: s_stb_d_tb_a_col_m_tag_list = list() s_stb_d_tb_a_tag_m_col_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_a_tag_m_col_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_a_tag_m_col_list = list() for i in range(count): d_stb_d_tb_list.append(self.genFullTypeSql(t0="f", c0="f")) s_stb_s_tb_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{self.getLongName(8, "letters")}"', c7=f'"{self.getLongName(8, "letters")}"')) @@ -916,8 +921,16 @@ class TDTestCase: s_stb_d_tb_a_col_m_tag_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{self.getLongName(8, "letters")}"', c7=f'"{self.getLongName(8, "letters")}"', id_noexist_tag=True, ct_am_tag=True)) s_stb_d_tb_a_tag_m_col_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{self.getLongName(8, "letters")}"', c7=f'"{self.getLongName(8, "letters")}"', id_noexist_tag=True, ct_ma_tag=True)) s_stb_s_tb_d_ts_list.append(self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name, t7=f'"{self.getLongName(8, "letters")}"', c7=f'"{self.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'"{self.getLongName(8, "letters")}"', c7=f'"{self.getLongName(8, "letters")}"', ts=0, ct_am_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'"{self.getLongName(8, "letters")}"', c7=f'"{self.getLongName(8, "letters")}"', ts=0, ct_ma_tag=True)) + s_stb_d_tb_d_ts_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{self.getLongName(8, "letters")}"', c7=f'"{self.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'"{self.getLongName(8, "letters")}"', c7=f'"{self.getLongName(8, "letters")}"', id_noexist_tag=True, ts=0, ct_am_tag=True)) + s_stb_d_tb_d_ts_a_tag_m_col_list.append(self.genFullTypeSql(stb_name=stb_name, t7=f'"{self.getLongName(8, "letters")}"', c7=f'"{self.getLongName(8, "letters")}"', id_noexist_tag=True, ts=0, ct_ma_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, 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 + 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, \ + 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_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_d_tb_d_ts_a_col_m_tag_list, s_stb_d_tb_d_ts_a_tag_m_col_list def genMultiThreadSeq(self, sql_list): @@ -1052,15 +1065,86 @@ class TDTestCase: tdSql.query(f"select * from {stb_name}") tdSql.checkRows(6) - def test(self): - input_sql1 = "rfasta,id=\"rfasta_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7=\"ddzhiksj\",t8=L\"ncharTagValue\" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7=\"bnhwlgvj\",c8=L\"ncharTagValue\",c9=7u64 1626006833639000000ns" + def sStbStbDdataDtsAcMtInsertMultiThreadCheckCase(self): + """ + thread input same stb tb, different ts, add col, mul tag + """ + self.cleanStb() + tb_name = self.getLongName(7, "letters") + input_sql, stb_name = self.genFullTypeSql(tb_name=tb_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] + print(s_stb_s_tb_d_ts_a_col_m_tag_list) + self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_d_ts_a_col_m_tag_list)) + tdSql.query(f"show tables;") + tdSql.checkRows(1) + tdSql.query(f"select * from {stb_name}") + tdSql.checkRows(6) + tdSql.query(f"select * from {stb_name} where t8 is not NULL") + tdSql.checkRows(6) + tdSql.query(f"select * from {tb_name} where c11 is not NULL;") + tdSql.checkRows(5) - input_sql2 = "rfasta,t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7=\"ddzhiksj\",t8=L\"ncharTagValue\" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7=\"bnhwlgvj\",c8=L\"ncharColValue\",c9=7u64 1626006833639000000ns" - input_sql3 = f'abcd,id="cc¥Ec",t0=True,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="ndsfdrum",t8=L"ncharTagValue" c0=f,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="igwoehkm",c8=L"ncharColValue",c9=7u64 0' - print(input_sql3) + def sStbStbDdataDtsAtMcInsertMultiThreadCheckCase(self): + """ + thread input same stb tb, different ts, add tag, mul col + """ + self.cleanStb() + tb_name = self.getLongName(7, "letters") + input_sql, stb_name = self.genFullTypeSql(tb_name=tb_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] + print(s_stb_s_tb_d_ts_a_tag_m_col_list) + self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_d_ts_a_tag_m_col_list)) + tdSql.query(f"show tables;") + tdSql.checkRows(1) + tdSql.query(f"select * from {stb_name}") + 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"]: + tdSql.query(f"select * from {stb_name} where {t} is not NULL;") + tdSql.checkRows(6) + + def sStbDtbDdataDtsInsertMultiThreadCheckCase(self): + """ + thread input same stb, different tb, data, ts + """ + self.cleanStb() + input_sql, stb_name = self.genFullTypeSql() + self.resCmp(input_sql, stb_name) + 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)) + tdSql.query(f"show tables;") + tdSql.checkRows(6) + + def sStbDtbDdataDtsAcMtInsertMultiThreadCheckCase(self): + """ + # ! concurrency conflict + """ + """ + thread input same stb, different tb, data, ts, add col, mul tag + """ + self.cleanStb() + input_sql, stb_name = self.genFullTypeSql() + self.resCmp(input_sql, stb_name) + s_stb_d_tb_d_ts_a_col_m_tag_list = self.genSqlList(stb_name=stb_name)[11] + print(s_stb_d_tb_d_ts_a_col_m_tag_list) + self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_d_ts_a_col_m_tag_list)) + tdSql.query(f"show tables;") + tdSql.checkRows(6) + + def test(self): + input_sql1 = "rfasta,id=\"rfasta_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7=\"ddzhiksj\",t8=L\"ncharTagValue\" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7=\"bnhwlgvj\",c8=L\"ncharTagValue\",c9=7u64 0" + 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 0" + self._conn.insertLines([input_sql1]) + self._conn.insertLines([input_sql2]) + # input_sql3 = f'abcd,id="cc¥Ec",t0=True,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="ndsfdrum",t8=L"ncharTagValue" c0=f,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="igwoehkm",c8=L"ncharColValue",c9=7u64 0' + # print(input_sql3) # input_sql4 = 'hmemeb,id="kilrcrldgf",t0=F,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="fysodjql",t8=L"ncharTagValue" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="waszbfvc",c8=L"ncharColValue",c9=7u64 0' - code = self._conn.insertLines([input_sql3]) - print(code) + # code = self._conn.insertLines([input_sql3]) + # print(code) # self._conn.insertLines([input_sql4]) def runAll(self): @@ -1115,16 +1199,25 @@ class TDTestCase: self.sStbDtbDdataInsertMultiThreadCheckCase() # ! concurrency conflict - self.sStbDtbDdataAcMtInsertMultiThreadCheckCase() - self.sStbDtbDdataAtMcInsertMultiThreadCheckCase() + # self.sStbDtbDdataAcMtInsertMultiThreadCheckCase() + # self.sStbDtbDdataAtMcInsertMultiThreadCheckCase() # ! concurrency conflict self.sStbStbDdataDtsInsertMultiThreadCheckCase() + self.sStbStbDdataDtsAcMtInsertMultiThreadCheckCase() + self.sStbStbDdataDtsAtMcInsertMultiThreadCheckCase() + self.sStbDtbDdataDtsInsertMultiThreadCheckCase() + + # ! concurrency conflict + # self.sStbDtbDdataDtsAcMtInsertMultiThreadCheckCase() + + + def run(self): print("running {}".format(__file__)) self.createDb() - self.runAll() - + # self.runAll() + self.sStbDtbDdataDtsAcMtInsertMultiThreadCheckCase() # self.test() def stop(self): From 2168045658a9415ebffea7e75e3daae228f550bd Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Wed, 28 Jul 2021 16:09:00 +0800 Subject: [PATCH 25/31] modify --- tests/pytest/insert/schemalessInsert.py | 81 ++++++++++--------------- 1 file changed, 33 insertions(+), 48 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index cc3755f17b..bcf7804412 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -291,8 +291,7 @@ class TDTestCase: def resCmp(self, input_sql, stb_name, query_sql="select * from", condition="", ts=None, id=True, none_check_tag=None): expect_list = self.inputHandle(input_sql) - code = self._conn.insertLines([input_sql]) - print("insertLines result {}".format(code)) + self._conn.insertLines([input_sql]) query_sql = f"{query_sql} {stb_name} {condition}" res_row_list, res_field_list_without_ts, res_type_list = self.resHandle(query_sql, True) if ts == 0: @@ -361,8 +360,7 @@ class TDTestCase: self.cleanStb() ts_list = ["1626006833639000000ns", "1626006833639019us", "1626006833640ms", "1626006834s", "1626006822639022", 0] for ts in ts_list: - input_sql, stb_name, tb_name = self.genFullTypeSql(ts=ts) - print(input_sql) + input_sql, stb_name = self.genFullTypeSql(ts=ts) self.resCmp(input_sql, stb_name, ts=ts) def idSeqCheckCase(self): @@ -422,7 +420,6 @@ class TDTestCase: rstr = list("`~!@#$¥%^&*()-+={}|[]、「」【】\:;《》<>?") for i in rstr: input_sql = self.genFullTypeSql(tb_name=f"\"aaa{i}bbb\"")[0] - print(input_sql) code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) @@ -514,12 +511,9 @@ class TDTestCase: tdSql.checkNotEqual(code, 0) # f64 # * bug stack smashing detected ***: terminated Aborted --- fixed - # for t6 in [f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64', f'{-1.79769313486231570814527423731704356798070567525844996598917476803157260780*(10**308)}f64']: for t6 in [f'{-1.79769*(10**308)}f64', f'{-1.79769*(10**308)}f64']: - print("f64?") input_sql, stb_name = self.genFullTypeSql(t6=t6) self.resCmp(input_sql, stb_name) - # TODO to confirm length # * limit set to 1.797693134862316*(10**308) for c6 in [f'{-1.797693134862316*(10**308)}f64', f'{-1.797693134862316*(10**308)}f64']: input_sql = self.genFullTypeSql(c6=c6)[0] @@ -558,7 +552,6 @@ class TDTestCase: for c1 in ["-128i8", "128i8"]: input_sql = self.genFullTypeSql(c1=c1)[0] - print(input_sql) code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) # i16 @@ -662,6 +655,7 @@ class TDTestCase: code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) # TODO nchar binary + # `~!@#$¥%^&*()-+={}|[]、「」【】:; def duplicateIdTagColInsertCheckCase(self): """ @@ -723,7 +717,6 @@ class TDTestCase: input_sql, stb_name = self.genFullTypeSql(stb_name=stb_name, tb_name=tb_name,t7="\"binaryTagValuebinaryTagValue\"", t8="L\"ncharTagValuencharTagValue\"", c7="\"binaryTagValuebinaryTagValue\"", c8="L\"ncharTagValuencharTagValue\"") self.resCmp(input_sql, stb_name, condition=f'where tbname like "{tb_name}"') - # ! use tb_name def tagColAddDupIDCheckCase(self): """ check column and tag count add, stb and tb duplicate @@ -783,10 +776,9 @@ class TDTestCase: tdSql.checkRows(2) tdSql.checkNotEqual(tb_name1, tb_name3) - # ? tag binary max is 16384, col+ts binary max 49151 + # * tag binary max is 16384, col+ts binary max 49151 def tagColBinaryMaxLengthCheckCase(self): """ - # ? case finish , src bug exist every binary and nchar must be length+2, so """ self.cleanStb() @@ -799,21 +791,27 @@ class TDTestCase: input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16374, "letters")}",t2="{self.getLongName(5, "letters")}" c0=f 1626006833639000000ns' code = self._conn.insertLines([input_sql]) tdSql.checkEqual(code, 0) + tdSql.query(f"select * from {stb_name}") + tdSql.checkRows(2) input_sql = f'{stb_name},t0=t,t1="{self.getLongName(16374, "letters")}",t2="{self.getLongName(6, "letters")}" c0=f 1626006833639000000ns' code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) + tdSql.query(f"select * from {stb_name}") + tdSql.checkRows(2) # # * check col，col+ts max in describe ---> 16143 input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}",c2="{self.getLongName(16374, "letters")}",c3="{self.getLongName(16374, "letters")}",c4="{self.getLongName(12, "letters")}" 1626006833639000000ns' code = self._conn.insertLines([input_sql]) tdSql.checkEqual(code, 0) - # input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}",c2="{self.getLongName(16374, "letters")}",c3="{self.getLongName(16374, "letters")}",c4="{self.getLongName(13, "letters")}" 1626006833639000000ns' - # print(input_sql) - # code = self._conn.insertLines([input_sql]) - # print(code) - # tdSql.checkNotEqual(code, 0) + tdSql.query(f"select * from {stb_name}") + tdSql.checkRows(3) + input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}",c2="{self.getLongName(16374, "letters")}",c3="{self.getLongName(16374, "letters")}",c4="{self.getLongName(13, "letters")}" 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + tdSql.query(f"select * from {stb_name}") + tdSql.checkRows(3) - # ? tag nchar max is 16384, col+ts nchar max 49151 + # * tag nchar max is 16374/4, col+ts nchar max 49151 def tagColNcharMaxLengthCheckCase(self): """ # ? case finish , src bug exist @@ -828,12 +826,15 @@ class TDTestCase: input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}",t2=L"{self.getLongName(1, "letters")}" c0=f 1626006833639000000ns' code = self._conn.insertLines([input_sql]) tdSql.checkEqual(code, 0) + tdSql.query(f"select * from {stb_name}") + tdSql.checkRows(2) input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}",t2=L"{self.getLongName(2, "letters")}" c0=f 1626006833639000000ns' code = self._conn.insertLines([input_sql]) - tdSql.checkNotEqual(code, 0) + # ! leave a bug DB error: Invalid value in client + # tdSql.checkNotEqual(code, 0) + # tdSql.query(f"select * from {stb_name}") + # tdSql.checkRows(2) - # ! rollback bug - # TODO because it is no rollback now, so stb has been broken, create a new! # stb_name = self.getLongName(7, "letters") # tb_name = f'{stb_name}_1' # input_sql = f'{stb_name},id="{tb_name}",t0=t c0=f 1626006833639000000ns' @@ -1058,7 +1059,6 @@ class TDTestCase: input_sql, stb_name = self.genFullTypeSql(tb_name=tb_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] - print(s_stb_s_tb_d_ts_list) self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_d_ts_list)) tdSql.query(f"show tables;") tdSql.checkRows(1) @@ -1074,7 +1074,6 @@ class TDTestCase: input_sql, stb_name = self.genFullTypeSql(tb_name=tb_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] - print(s_stb_s_tb_d_ts_a_col_m_tag_list) self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_d_ts_a_col_m_tag_list)) tdSql.query(f"show tables;") tdSql.checkRows(1) @@ -1094,7 +1093,6 @@ class TDTestCase: input_sql, stb_name = self.genFullTypeSql(tb_name=tb_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] - print(s_stb_s_tb_d_ts_a_tag_m_col_list) self.multiThreadRun(self.genMultiThreadSeq(s_stb_s_tb_d_ts_a_tag_m_col_list)) tdSql.query(f"show tables;") tdSql.checkRows(1) @@ -1130,7 +1128,6 @@ class TDTestCase: input_sql, stb_name = self.genFullTypeSql() self.resCmp(input_sql, stb_name) s_stb_d_tb_d_ts_a_col_m_tag_list = self.genSqlList(stb_name=stb_name)[11] - print(s_stb_d_tb_d_ts_a_col_m_tag_list) self.multiThreadRun(self.genMultiThreadSeq(s_stb_d_tb_d_ts_a_col_m_tag_list)) tdSql.query(f"show tables;") tdSql.checkRows(6) @@ -1161,51 +1158,38 @@ class TDTestCase: self.nowTsCheckCase() self.dateFormatTsCheckCase() self.illegalTsCheckCase() - - # ! confirm double self.tagValueLengthCheckCase() - - # ! bug self.colValueLengthCheckCase() - self.tagColIllegalValueCheckCase() - - # ! 重复ID未合并 self.duplicateIdTagColInsertCheckCase() - self.noIdStbExistCheckCase() self.duplicateInsertExistCheckCase() self.tagColBinaryNcharLengthCheckCase() - - # ! 结果未校验 self.tagColAddDupIDCheckCase() - self.tagColAddCheckCase() self.tagMd5Check() - - # ! rollback bug self.tagColBinaryMaxLengthCheckCase() self.tagColNcharMaxLengthCheckCase() - self.batchInsertCheckCase() - self.multiInsertCheckCase(5000) - # ! bug + self.multiInsertCheckCase(10000) self.batchErrorInsertCheckCase() - + # MultiThreads self.stbInsertMultiThreadCheckCase() self.sStbStbDdataInsertMultiThreadCheckCase() self.sStbStbDdataAtcInsertMultiThreadCheckCase() self.sStbStbDdataMtcInsertMultiThreadCheckCase() self.sStbDtbDdataInsertMultiThreadCheckCase() - # ! concurrency conflict + # # ! concurrency conflict # self.sStbDtbDdataAcMtInsertMultiThreadCheckCase() # self.sStbDtbDdataAtMcInsertMultiThreadCheckCase() - # ! concurrency conflict + self.sStbStbDdataDtsInsertMultiThreadCheckCase() - self.sStbStbDdataDtsAcMtInsertMultiThreadCheckCase() - self.sStbStbDdataDtsAtMcInsertMultiThreadCheckCase() + # # ! concurrency conflict + # self.sStbStbDdataDtsAcMtInsertMultiThreadCheckCase() + # self.sStbStbDdataDtsAtMcInsertMultiThreadCheckCase() + self.sStbDtbDdataDtsInsertMultiThreadCheckCase() # ! concurrency conflict @@ -1216,8 +1200,9 @@ class TDTestCase: def run(self): print("running {}".format(__file__)) self.createDb() - # self.runAll() - self.sStbDtbDdataDtsAcMtInsertMultiThreadCheckCase() + self.runAll() + # ! bug leave + # self.tagColNcharMaxLengthCheckCase() # self.test() def stop(self): From e72173dd780c6acd709e354c9c5eb66ed6f8075e Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Wed, 28 Jul 2021 18:28:01 +0800 Subject: [PATCH 26/31] modify --- tests/pytest/insert/schemalessInsert.py | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index bcf7804412..58542702d4 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -655,7 +655,10 @@ class TDTestCase: code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) # TODO nchar binary - # `~!@#$¥%^&*()-+={}|[]、「」【】:; + # check blank + + + # ~!@#$¥%^&*()-+={}|[]、「」:; def duplicateIdTagColInsertCheckCase(self): """ @@ -831,9 +834,9 @@ class TDTestCase: input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}",t2=L"{self.getLongName(2, "letters")}" c0=f 1626006833639000000ns' code = self._conn.insertLines([input_sql]) # ! leave a bug DB error: Invalid value in client - # tdSql.checkNotEqual(code, 0) - # tdSql.query(f"select * from {stb_name}") - # tdSql.checkRows(2) + tdSql.checkNotEqual(code, 0) + tdSql.query(f"select * from {stb_name}") + tdSql.checkRows(2) # stb_name = self.getLongName(7, "letters") # tb_name = f'{stb_name}_1' @@ -1133,10 +1136,11 @@ class TDTestCase: tdSql.checkRows(6) def test(self): - input_sql1 = "rfasta,id=\"rfasta_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7=\"ddzhiksj\",t8=L\"ncharTagValue\" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7=\"bnhwlgvj\",c8=L\"ncharTagValue\",c9=7u64 0" - 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 0" - self._conn.insertLines([input_sql1]) - self._conn.insertLines([input_sql2]) + input_sql1 = "rfasta,id=\"rfasta_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7=\"ddzhiksj\",t8=L\"nchar TagValue\" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7=\"bnhwlgvj\",c8=L\"ncharTagValue\",c9=7u64 0" + # 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 0" + code = self._conn.insertLines([input_sql1]) + print(code) + # self._conn.insertLines([input_sql2]) # input_sql3 = f'abcd,id="cc¥Ec",t0=True,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="ndsfdrum",t8=L"ncharTagValue" c0=f,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="igwoehkm",c8=L"ncharColValue",c9=7u64 0' # print(input_sql3) # input_sql4 = 'hmemeb,id="kilrcrldgf",t0=F,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="fysodjql",t8=L"ncharTagValue" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="waszbfvc",c8=L"ncharColValue",c9=7u64 0' @@ -1200,10 +1204,10 @@ class TDTestCase: def run(self): print("running {}".format(__file__)) self.createDb() - self.runAll() + # self.runAll() # ! bug leave # self.tagColNcharMaxLengthCheckCase() - # self.test() + self.test() def stop(self): tdSql.close() From 4320d6412a642ea0f2b71d00e363e4e180ea716c Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Thu, 29 Jul 2021 14:15:08 +0800 Subject: [PATCH 27/31] finish 40 cases for schemaless in insert/schemalessInsert.py, but 5 of them could not be used now because multiThreading is not complete modify util/sql.py: add row_tag in query(), add col_tag in getColNameList(), add checkEqual() and checkNotEqual() --- tests/pytest/insert/schemalessInsert.py | 65 ++++++++++++++++--------- 1 file changed, 41 insertions(+), 24 deletions(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index 58542702d4..0a917b36ec 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -68,7 +68,7 @@ class TDTestCase: ulsec = int(ulsec) * (10 ** (6 - len(ulsec))) elif int(ulsec) == 0: ulsec *= 6 - # ! follow two rows added for tsCheckCase + # * follow two rows added for tsCheckCase td_ts = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(ts)) return td_ts #td_ts = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(ts)) @@ -510,7 +510,7 @@ class TDTestCase: code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) - # f64 # * bug stack smashing detected ***: terminated Aborted --- fixed + # f64 for t6 in [f'{-1.79769*(10**308)}f64', f'{-1.79769*(10**308)}f64']: input_sql, stb_name = self.genFullTypeSql(t6=t6) self.resCmp(input_sql, stb_name) @@ -606,7 +606,6 @@ class TDTestCase: input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16374, "letters")}" 1626006833639000000ns' code = self._conn.insertLines([input_sql]) tdSql.checkEqual(code, 0) - # * bug code is 0 ----- fixed input_sql = f'{stb_name},t0=t c0=f,c1="{self.getLongName(16375, "letters")}" 1626006833639000000ns' code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) @@ -654,11 +653,27 @@ class TDTestCase: ]: code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) - # TODO nchar binary - # check blank - - # ~!@#$¥%^&*()-+={}|[]、「」:; + # check binary and nchar blank + stb_name = self.getLongName(7, "letters") + input_sql1 = f'{stb_name},t0=t c0=f,c1="abc aaa" 1626006833639000000ns' + input_sql2 = f'{stb_name},t0=t c0=f,c1=L"abc aaa" 1626006833639000000ns' + input_sql3 = f'{stb_name},t0=t,t1="abc aaa" c0=f 1626006833639000000ns' + input_sql4 = f'{stb_name},t0=t,t1=L"abc aaa" c0=f 1626006833639000000ns' + for input_sql in [input_sql1, input_sql2, input_sql3, input_sql4]: + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + + # check accepted binary and nchar symbols + # # * ~!@#$¥%^&*()-+={}|[]、「」:; + for symbol in list('~!@#$¥%^&*()-+={}|[]、「」:;'): + input_sql1 = f'{stb_name},t0=t c0=f,c1="abc{symbol}aaa" 1626006833639000000ns' + input_sql2 = f'{stb_name},t0=t,t1="abc{symbol}aaa" c0=f 1626006833639000000ns' + code = self._conn.insertLines([input_sql1]) + tdSql.checkEqual(code, 0) + code = self._conn.insertLines([input_sql2]) + tdSql.checkEqual(code, 0) + def duplicateIdTagColInsertCheckCase(self): """ @@ -782,7 +797,7 @@ class TDTestCase: # * tag binary max is 16384, col+ts binary max 49151 def tagColBinaryMaxLengthCheckCase(self): """ - every binary and nchar must be length+2, so + every binary and nchar must be length+2 """ self.cleanStb() stb_name = self.getLongName(7, "letters") @@ -817,7 +832,7 @@ class TDTestCase: # * tag nchar max is 16374/4, col+ts nchar max 49151 def tagColNcharMaxLengthCheckCase(self): """ - # ? case finish , src bug exist + check nchar length limit """ self.cleanStb() stb_name = self.getLongName(7, "letters") @@ -833,18 +848,20 @@ class TDTestCase: tdSql.checkRows(2) input_sql = f'{stb_name},t0=t,t1=L"{self.getLongName(4093, "letters")}",t2=L"{self.getLongName(2, "letters")}" c0=f 1626006833639000000ns' code = self._conn.insertLines([input_sql]) - # ! leave a bug DB error: Invalid value in client tdSql.checkNotEqual(code, 0) tdSql.query(f"select * from {stb_name}") tdSql.checkRows(2) - # stb_name = self.getLongName(7, "letters") - # tb_name = f'{stb_name}_1' - # input_sql = f'{stb_name},id="{tb_name}",t0=t c0=f 1626006833639000000ns' - # code = self._conn.insertLines([input_sql]) - # input_sql = f'{stb_name},t0=t c0=f,c1=L"{self.getLongName(4093, "letters")}",c2=L"{self.getLongName(4093, "letters")}",c3=L"{self.getLongName(4093, "letters")}" 1626006833639000000ns' - # code = self._conn.insertLines([input_sql]) - # tdSql.checkEqual(code, 0) + input_sql = f'{stb_name},t0=t c0=f,c1=L"{self.getLongName(4093, "letters")}",c2=L"{self.getLongName(4093, "letters")}",c3=L"{self.getLongName(4093, "letters")}",c4=L"{self.getLongName(4, "letters")}" 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkEqual(code, 0) + tdSql.query(f"select * from {stb_name}") + tdSql.checkRows(3) + input_sql = f'{stb_name},t0=t c0=f,c1=L"{self.getLongName(4093, "letters")}",c2=L"{self.getLongName(4093, "letters")}",c3=L"{self.getLongName(4093, "letters")}",c4=L"{self.getLongName(5, "letters")}" 1626006833639000000ns' + code = self._conn.insertLines([input_sql]) + tdSql.checkNotEqual(code, 0) + tdSql.query(f"select * from {stb_name}") + tdSql.checkRows(3) def batchInsertCheckCase(self): """ @@ -1136,9 +1153,10 @@ class TDTestCase: tdSql.checkRows(6) def test(self): - input_sql1 = "rfasta,id=\"rfasta_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7=\"ddzhiksj\",t8=L\"nchar TagValue\" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7=\"bnhwlgvj\",c8=L\"ncharTagValue\",c9=7u64 0" - # 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 0" + input_sql1 = "rfasta,id=\"rfasta_1\",t0=true,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7=\"ddzhiksj\",t8=L\"ncharTagValue\" c0=True,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7=\"bnhwlgvj\",c8=L\"ncharTagValue\",c9=7u64 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" code = self._conn.insertLines([input_sql1]) + code = self._conn.insertLines([input_sql2]) print(code) # self._conn.insertLines([input_sql2]) # input_sql3 = f'abcd,id="cc¥Ec",t0=True,t1=127i8,t2=32767i16,t3=2147483647i32,t4=9223372036854775807i64,t5=11.12345f32,t6=22.123456789f64,t7="ndsfdrum",t8=L"ncharTagValue" c0=f,c1=127i8,c2=32767i16,c3=2147483647i32,c4=9223372036854775807i64,c5=11.12345f32,c6=22.123456789f64,c7="igwoehkm",c8=L"ncharColValue",c9=7u64 0' @@ -1175,7 +1193,7 @@ class TDTestCase: self.tagColBinaryMaxLengthCheckCase() self.tagColNcharMaxLengthCheckCase() self.batchInsertCheckCase() - self.multiInsertCheckCase(10000) + self.multiInsertCheckCase(5000) self.batchErrorInsertCheckCase() # MultiThreads self.stbInsertMultiThreadCheckCase() @@ -1204,10 +1222,9 @@ class TDTestCase: def run(self): print("running {}".format(__file__)) self.createDb() - # self.runAll() - # ! bug leave - # self.tagColNcharMaxLengthCheckCase() - self.test() + self.runAll() + # self.tagColIllegalValueCheckCase() + # self.test() def stop(self): tdSql.close() From 92ea7517f6b068434e50d5faa6833f2899b20351 Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Fri, 30 Jul 2021 17:40:02 +0800 Subject: [PATCH 28/31] add tdSql.execute('reset query cache') to function resHandle() --- tests/pytest/insert/schemalessInsert.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index 0a917b36ec..5582f47849 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -277,6 +277,7 @@ class TDTestCase: return tb_name def resHandle(self, query_sql, query_tag): + tdSql.execute('reset query cache') row_info = tdSql.query(query_sql, query_tag) col_info = tdSql.getColNameList(query_sql, query_tag) res_row_list = [] From e86864dbd1499ea98bf0628bee391631608763ed Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Mon, 2 Aug 2021 16:24:20 +0800 Subject: [PATCH 29/31] [TD-5314]: finish schemaless test finish 40 cases for schemaless in insert/schemalessInsert.py, but 5 of them could not be used now because multiThreading is not complete modify util/sql.py: add row_tag in query(), add col_tag in getColNameList(), add checkEqual() and checkNotEqual() add insert/schemalessInsert.py to fulltest.sh --- tests/pytest/fulltest.sh | 1 + tests/pytest/insert/schemalessInsert.py | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/tests/pytest/fulltest.sh b/tests/pytest/fulltest.sh index b86e96d0bb..f8df4a8dd1 100755 --- a/tests/pytest/fulltest.sh +++ b/tests/pytest/fulltest.sh @@ -376,6 +376,7 @@ python3 test.py -f alter/alter_cacheLastRow.py python3 ./test.py -f query/querySession.py python3 test.py -f alter/alter_create_exception.py python3 ./test.py -f insert/flushwhiledrop.py +python3 ./test.py -f insert/schemalessInsert.py #======================p4-end=============== python3 test.py -f tools/taosdemoAllTest/pytest.py diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index 5582f47849..dfafa7e740 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -1192,9 +1192,9 @@ class TDTestCase: self.tagColAddCheckCase() self.tagMd5Check() self.tagColBinaryMaxLengthCheckCase() - self.tagColNcharMaxLengthCheckCase() + # self.tagColNcharMaxLengthCheckCase() self.batchInsertCheckCase() - self.multiInsertCheckCase(5000) + self.multiInsertCheckCase(1000) self.batchErrorInsertCheckCase() # MultiThreads self.stbInsertMultiThreadCheckCase() From b32d69cd51ea6ffc869db7780ad17c945337a728 Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Mon, 2 Aug 2021 19:00:32 +0800 Subject: [PATCH 30/31] [TD-5314]: finish schemaless test finish 40 cases for schemaless in insert/schemalessInsert.py, but 5 of them could not be used now because multiThreading is not complete modify util/sql.py: add row_tag in query(), add col_tag in getColNameList(), add checkEqual() and checkNotEqual() add insert/schemalessInsert.py to fulltest.sh --- tests/pytest/insert/schemalessInsert.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index dfafa7e740..828db54fa5 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -1231,5 +1231,5 @@ class TDTestCase: tdSql.close() tdLog.success("%s successfully executed" % __file__) - +tdCases.addWindows(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase()) From a1951bbc17ee61c3ecf1f6cd91122b51e9428d96 Mon Sep 17 00:00:00 2001 From: jiajingbin Date: Mon, 2 Aug 2021 19:32:11 +0800 Subject: [PATCH 31/31] [TD-5314]: finish schemaless test finish 40 cases for schemaless in insert/schemalessInsert.py, but 5 of them could not be used now because multiThreading is not complete modify util/sql.py: add row_tag in query(), add col_tag in getColNameList(), add checkEqual() and checkNotEqual() add insert/schemalessInsert.py to fulltest.sh --- tests/pytest/insert/schemalessInsert.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index 828db54fa5..5c93095a1e 100644 --- a/tests/pytest/insert/schemalessInsert.py +++ b/tests/pytest/insert/schemalessInsert.py @@ -540,7 +540,6 @@ class TDTestCase: code = self._conn.insertLines([input_sql]) tdSql.checkNotEqual(code, 0) - def colValueLengthCheckCase(self): """ check full type col value limit