diff --git a/tests/pytest/insert/schemalessInsert.py b/tests/pytest/insert/schemalessInsert.py index f4b1dde0005ced4f92f13341ed6ea370283085ce..952c383f3a49cdee0c7eddee9866f0a0a3938bf3 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)