From 3353c1fa29522e3bec07a91f1afd91479ce56458 Mon Sep 17 00:00:00 2001 From: cpwu Date: Fri, 27 May 2022 20:20:38 +0800 Subject: [PATCH 01/34] fix case --- tests/system-test/2-query/explain.py | 359 +++++++++++++++++++++++++++ 1 file changed, 359 insertions(+) create mode 100644 tests/system-test/2-query/explain.py diff --git a/tests/system-test/2-query/explain.py b/tests/system-test/2-query/explain.py new file mode 100644 index 0000000000..b452da0a35 --- /dev/null +++ b/tests/system-test/2-query/explain.py @@ -0,0 +1,359 @@ +import datetime + +from util.log import * +from util.sql import * +from util.cases import * +from util.dnodes import * + +PRIMARY_COL = "ts" + +INT_COL = "c1" +BINT_COL = "c2" +SINT_COL = "c3" +TINT_COL = "c4" +FLOAT_COL = "c5" +DOUBLE_COL = "c6" +BOOL_COL = "c7" + +BINARY_COL = "c8" +NCHAR_COL = "c9" +TS_COL = "c10" + +NUM_COL = [ INT_COL, BINT_COL, SINT_COL, TINT_COL, FLOAT_COL, DOUBLE_COL, ] +CHAR_COL = [ BINARY_COL, NCHAR_COL, ] +BOOLEAN_COL = [ BOOL_COL, ] +TS_TYPE_COL = [ TS_COL, ] + +ALL_COL = [ INT_COL, BINT_COL, SINT_COL, TINT_COL, FLOAT_COL, DOUBLE_COL, BOOL_COL, BINARY_COL, NCHAR_COL, TS_COL ] + +class TDTestCase: + + def init(self, conn, logSql): + tdLog.debug(f"start to excute {__file__}") + tdSql.init(conn.cursor()) + + def __query_condition(self,tbname): + query_condition = [f"cast({col} as bigint)" for col in ALL_COL] + for num_col in NUM_COL: + query_condition.extend( + ( + f"{tbname}.{num_col}", + f"abs( {tbname}.{num_col} )", + f"acos( {tbname}.{num_col} )", + f"asin( {tbname}.{num_col} )", + f"atan( {tbname}.{num_col} )", + f"avg( {tbname}.{num_col} )", + f"ceil( {tbname}.{num_col} )", + f"cos( {tbname}.{num_col} )", + f"count( {tbname}.{num_col} )", + f"floor( {tbname}.{num_col} )", + f"log( {tbname}.{num_col}, {tbname}.{num_col})", + f"max( {tbname}.{num_col} )", + f"min( {tbname}.{num_col} )", + f"pow( {tbname}.{num_col}, 2)", + f"round( {tbname}.{num_col} )", + f"sum( {tbname}.{num_col} )", + f"sin( {tbname}.{num_col} )", + f"sqrt( {tbname}.{num_col} )", + f"tan( {tbname}.{num_col} )", + f"cast( {tbname}.{num_col} as timestamp)", + ) + ) + query_condition.extend((f"{num_col} + {any_col}" for any_col in ALL_COL)) + for char_col in CHAR_COL: + query_condition.extend( + ( + f"count({tbname}.{char_col})", + f"sum(cast({tbname}.{char_col}) as bigint)", + f"max(cast({tbname}.{char_col}) as bigint)", + f"min(cast({tbname}.{char_col}) as bigint)", + f"avg(cast({tbname}.{char_col}) as bigint)", + ) + ) + # query_condition.extend( + # ( + # 1010, + # ) + # ) + + return query_condition + + def __join_condition(self, tb_list, filter=PRIMARY_COL, INNER=False): + table_reference = tb_list[0] + join_condition = table_reference + join = "inner join" if INNER else "join" + for i in range(len(tb_list[1:])): + join_condition += f" {join} {tb_list[i+1]} on {table_reference}.{filter}={tb_list[i+1]}.{filter}" + + return join_condition + + def __where_condition(self, col=None, tbname=None, query_conditon=None): + if query_conditon and isinstance(query_conditon, str): + if query_conditon.startswith("count"): + query_conditon = query_conditon[6:-1] + elif query_conditon.startswith("max"): + query_conditon = query_conditon[4:-1] + elif query_conditon.startswith("sum"): + query_conditon = query_conditon[4:-1] + elif query_conditon.startswith("min"): + query_conditon = query_conditon[4:-1] + + if query_conditon: + return f" where {query_conditon} is not null" + if col in NUM_COL: + return f" where abs( {tbname}.{col} ) >= 0" + if col in CHAR_COL: + return f" where lower( {tbname}.{col} ) like 'bina%' or lower( {tbname}.{col} ) like '_cha%' " + if col in BOOLEAN_COL: + return f" where {tbname}.{col} in (false, true) " + if col in TS_TYPE_COL or col in PRIMARY_COL: + return f" where cast( {tbname}.{col} as binary(16) ) is not null " + + return "" + + def __group_condition(self, col, having = None): + if isinstance(col, str): + if col.startswith("count"): + col = col[6:-1] + elif col.startswith("max"): + col = col[4:-1] + elif col.startswith("sum"): + col = col[4:-1] + elif col.startswith("min"): + col = col[4:-1] + return f" group by {col} having {having}" if having else f" group by {col} " + + def __single_sql(self, select_clause, from_clause, where_condition="", group_condition=""): + if isinstance(select_clause, str) and "on" not in from_clause and select_clause.split(".")[0].split("(")[-1] != from_clause.split(".")[0]: + return + return f"select hyperloglog({select_clause}) from {from_clause} {where_condition} {group_condition}" + + @property + def __tb_list(self): + return [ + "ct1", + "ct4", + "t1", + "ct2", + "stb1", + ] + + def sql_list(self): + sqls = [] + __no_join_tblist = self.__tb_list + for tb in __no_join_tblist: + select_claus_list = self.__query_condition(tb) + for select_claus in select_claus_list: + group_claus = self.__group_condition(col=select_claus) + where_claus = self.__where_condition(query_conditon=select_claus) + having_claus = self.__group_condition(col=select_claus, having=f"{select_claus} is not null") + sqls.extend( + ( + self.__single_sql(select_claus, tb, where_claus, having_claus), + self.__single_sql(select_claus, tb,), + self.__single_sql(select_claus, tb, where_condition=where_claus), + self.__single_sql(select_claus, tb, group_condition=group_claus), + ) + ) + + # return filter(None, sqls) + return list(filter(None, sqls)) + + def __get_type(self, col): + if tdSql.cursor.istype(col, "BOOL"): + return "BOOL" + if tdSql.cursor.istype(col, "INT"): + return "INT" + if tdSql.cursor.istype(col, "BIGINT"): + return "BIGINT" + if tdSql.cursor.istype(col, "TINYINT"): + return "TINYINT" + if tdSql.cursor.istype(col, "SMALLINT"): + return "SMALLINT" + if tdSql.cursor.istype(col, "FLOAT"): + return "FLOAT" + if tdSql.cursor.istype(col, "DOUBLE"): + return "DOUBLE" + if tdSql.cursor.istype(col, "BINARY"): + return "BINARY" + if tdSql.cursor.istype(col, "NCHAR"): + return "NCHAR" + if tdSql.cursor.istype(col, "TIMESTAMP"): + return "TIMESTAMP" + if tdSql.cursor.istype(col, "JSON"): + return "JSON" + if tdSql.cursor.istype(col, "TINYINT UNSIGNED"): + return "TINYINT UNSIGNED" + if tdSql.cursor.istype(col, "SMALLINT UNSIGNED"): + return "SMALLINT UNSIGNED" + if tdSql.cursor.istype(col, "INT UNSIGNED"): + return "INT UNSIGNED" + if tdSql.cursor.istype(col, "BIGINT UNSIGNED"): + return "BIGINT UNSIGNED" + + def hyperloglog_check(self): + sqls = self.sql_list() + tdLog.printNoPrefix("===step 1: curent case, must return query OK") + for i in range(len(sqls)): + tdLog.info(f"sql: {sqls[i]}") + tdSql.query(sqls[i]) + + def __test_current(self): + tdSql.query("select hyperloglog(ts) from ct1") + tdSql.checkRows(1) + tdSql.query("select hyperloglog(c1) from ct2") + tdSql.checkRows(1) + tdSql.query("select hyperloglog(c1) from ct4 group by c1") + tdSql.checkRows(self.rows + 3) + tdSql.query("select hyperloglog(c1) from ct4 group by c7") + tdSql.checkRows(3) + tdSql.query("select hyperloglog(ct2.c1) from ct4 join ct2 on ct4.ts=ct2.ts") + tdSql.checkRows(1) + tdSql.checkData(0, 0, self.rows + 2) + tdSql.query("select hyperloglog(c1), c1 from stb1 group by c1") + for i in range(tdSql.queryRows): + tdSql.checkData(i, 0, 1) if tdSql.queryResult[i][1] is not None else tdSql.checkData(i, 0, 0) + + self.hyperloglog_check() + + def __test_error(self): + + tdLog.printNoPrefix("===step 0: err case, must return err") + tdSql.error( "select hyperloglog() from ct1" ) + tdSql.error( "select hyperloglog(c1, c2) from ct2" ) + tdSql.error( "select hyperloglog(1) from ct2" ) + tdSql.error( f"select hyperloglog({NUM_COL[0]}, {NUM_COL[1]}) from ct4" ) + tdSql.error( ''' select hyperloglog(['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10']) + from ct1 + where ['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'] is not null + group by ['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'] + having ['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'] is not null ''' ) + + def all_test(self): + self.__test_error() + self.__test_current() + + def __create_tb(self): + + tdLog.printNoPrefix("==========step1:create table") + create_stb_sql = f'''create table stb1( + ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint, + {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, + {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp + ) tags (t1 int) + ''' + create_ntb_sql = f'''create table t1( + ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint, + {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, + {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp + ) + ''' + tdSql.execute(create_stb_sql) + tdSql.execute(create_ntb_sql) + + for i in range(4): + tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )') + { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2} + + def __insert_data(self, rows): + now_time = int(datetime.datetime.timestamp(datetime.datetime.now()) * 1000) + for i in range(rows): + tdSql.execute( + f"insert into ct1 values ( { now_time - i * 1000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" + ) + tdSql.execute( + f"insert into ct4 values ( { now_time - i * 7776000000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" + ) + tdSql.execute( + f"insert into ct2 values ( { now_time - i * 7776000000 }, {-i}, {-11111 * i}, {-111 * i % 32767 }, {-11 * i % 127}, {-1.11*i}, {-1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" + ) + tdSql.execute( + f'''insert into ct1 values + ( { now_time - rows * 5 }, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar_测试_0', { now_time + 8 } ) + ( { now_time + 10000 }, { rows }, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar_测试_9', { now_time + 9 } ) + ''' + ) + + tdSql.execute( + f'''insert into ct4 values + ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( + { now_time + 5184000000}, {pow(2,31)-pow(2,15)}, {pow(2,63)-pow(2,30)}, 32767, 127, + { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000} + ) + ( + { now_time + 2592000000 }, {pow(2,31)-pow(2,16)}, {pow(2,63)-pow(2,31)}, 32766, 126, + { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000} + ) + ''' + ) + + tdSql.execute( + f'''insert into ct2 values + ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( + { now_time + 5184000000 }, { -1 * pow(2,31) + pow(2,15) }, { -1 * pow(2,63) + pow(2,30) }, -32766, -126, + { -1 * 3.2 * pow(10,38) }, { -1.2 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 } + ) + ( + { now_time + 2592000000 }, { -1 * pow(2,31) + pow(2,16) }, { -1 * pow(2,63) + pow(2,31) }, -32767, -127, + { - 3.3 * pow(10,38) }, { -1.3 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 } + ) + ''' + ) + + for i in range(rows): + insert_data = f'''insert into t1 values + ( { now_time - i * 3600000 }, {i}, {i * 11111}, { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2}, + "binary_{i}", "nchar_测试_{i}", { now_time - 1000 * i } ) + ''' + tdSql.execute(insert_data) + tdSql.execute( + f'''insert into t1 values + ( { now_time + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time - (( rows // 2 ) * 60 + 30) * 60000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time - rows * 3600000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time + 7200000 }, { pow(2,31) - pow(2,15) }, { pow(2,63) - pow(2,30) }, 32767, 127, + { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 }, + "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 } + ) + ( + { now_time + 3600000 } , { pow(2,31) - pow(2,16) }, { pow(2,63) - pow(2,31) }, 32766, 126, + { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, + "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 } + ) + ''' + ) + + + def run(self): + tdSql.prepare() + + tdLog.printNoPrefix("==========step1:create table") + self.__create_tb() + + tdLog.printNoPrefix("==========step2:insert data") + self.rows = 10 + self.__insert_data(self.rows) + + tdLog.printNoPrefix("==========step3:all check") + self.all_test() + + tdDnodes.stop(1) + tdDnodes.start(1) + + tdSql.execute("use db") + + tdLog.printNoPrefix("==========step4:after wal, all check again ") + self.all_test() + + def stop(self): + tdSql.close() + tdLog.success(f"{__file__} successfully executed") + +tdCases.addLinux(__file__, TDTestCase()) +tdCases.addWindows(__file__, TDTestCase()) From 50bba2037ff25ec9c95556c52ee5f07b115e1dcf Mon Sep 17 00:00:00 2001 From: cpwu Date: Fri, 27 May 2022 20:22:00 +0800 Subject: [PATCH 02/34] fix case --- tests/system-test/2-query/hyperloglog.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/system-test/2-query/hyperloglog.py b/tests/system-test/2-query/hyperloglog.py index 35703e441d..9cc2d925fb 100644 --- a/tests/system-test/2-query/hyperloglog.py +++ b/tests/system-test/2-query/hyperloglog.py @@ -124,7 +124,7 @@ class TDTestCase: return f" group by {col} having {having}" if having else f" group by {col} " def __single_sql(self, select_clause, from_clause, where_condition="", group_condition=""): - if isinstance(select_clause, str) and "on" not in from_clause and select_clause.split(".")[0] != from_clause.split(".")[0]: + if isinstance(select_clause, str) and "on" not in from_clause and select_clause.split(".")[0].split("(")[-1] != from_clause.split(".")[0]: return return f"select hyperloglog({select_clause}) from {from_clause} {where_condition} {group_condition}" From 55e464d3abf87a695f67619f185d07749e313994 Mon Sep 17 00:00:00 2001 From: cpwu Date: Fri, 27 May 2022 20:50:57 +0800 Subject: [PATCH 03/34] fix case --- tests/system-test/2-query/hyperloglog.py | 55 +++--------------------- 1 file changed, 6 insertions(+), 49 deletions(-) diff --git a/tests/system-test/2-query/hyperloglog.py b/tests/system-test/2-query/hyperloglog.py index 9cc2d925fb..afc31a60fd 100644 --- a/tests/system-test/2-query/hyperloglog.py +++ b/tests/system-test/2-query/hyperloglog.py @@ -33,50 +33,7 @@ class TDTestCase: tdSql.init(conn.cursor()) def __query_condition(self,tbname): - query_condition = [f"cast({col} as bigint)" for col in ALL_COL] - for num_col in NUM_COL: - query_condition.extend( - ( - f"{tbname}.{num_col}", - f"abs( {tbname}.{num_col} )", - f"acos( {tbname}.{num_col} )", - f"asin( {tbname}.{num_col} )", - f"atan( {tbname}.{num_col} )", - f"avg( {tbname}.{num_col} )", - f"ceil( {tbname}.{num_col} )", - f"cos( {tbname}.{num_col} )", - f"count( {tbname}.{num_col} )", - f"floor( {tbname}.{num_col} )", - f"log( {tbname}.{num_col}, {tbname}.{num_col})", - f"max( {tbname}.{num_col} )", - f"min( {tbname}.{num_col} )", - f"pow( {tbname}.{num_col}, 2)", - f"round( {tbname}.{num_col} )", - f"sum( {tbname}.{num_col} )", - f"sin( {tbname}.{num_col} )", - f"sqrt( {tbname}.{num_col} )", - f"tan( {tbname}.{num_col} )", - f"cast( {tbname}.{num_col} as timestamp)", - ) - ) - query_condition.extend((f"{num_col} + {any_col}" for any_col in ALL_COL)) - for char_col in CHAR_COL: - query_condition.extend( - ( - f"count({tbname}.{char_col})", - f"sum(cast({tbname}.{char_col}) as bigint)", - f"max(cast({tbname}.{char_col}) as bigint)", - f"min(cast({tbname}.{char_col}) as bigint)", - f"avg(cast({tbname}.{char_col}) as bigint)", - ) - ) - # query_condition.extend( - # ( - # 1010, - # ) - # ) - - return query_condition + return [ f"{any_col}" for any_col in ALL_COL ] def __join_condition(self, tb_list, filter=PRIMARY_COL, INNER=False): table_reference = tb_list[0] @@ -191,7 +148,7 @@ class TDTestCase: if tdSql.cursor.istype(col, "BIGINT UNSIGNED"): return "BIGINT UNSIGNED" - def spread_check(self): + def hyperloglog_check(self): sqls = self.sql_list() tdLog.printNoPrefix("===step 1: curent case, must return query OK") for i in range(len(sqls)): @@ -214,16 +171,16 @@ class TDTestCase: for i in range(tdSql.queryRows): tdSql.checkData(i, 0, 1) if tdSql.queryResult[i][1] is not None else tdSql.checkData(i, 0, 0) - - - self.spread_check() + self.hyperloglog_check() def __test_error(self): tdLog.printNoPrefix("===step 0: err case, must return err") tdSql.error( "select hyperloglog() from ct1" ) tdSql.error( "select hyperloglog(c1, c2) from ct2" ) - tdSql.error( "select hyperloglog(1) from ct2" ) + tdSql.error( "select hyperloglog(1) from stb1" ) + tdSql.error( "select hyperloglog(abs(c1)) from ct4" ) + tdSql.error( "select hyperloglog(count(c1)) from t1" ) tdSql.error( f"select hyperloglog({NUM_COL[0]}, {NUM_COL[1]}) from ct4" ) tdSql.error( ''' select hyperloglog(['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10']) from ct1 From e92623967de98480c1d2c26ed7d8118af5dfcbc0 Mon Sep 17 00:00:00 2001 From: cpwu Date: Sat, 28 May 2022 20:00:55 +0800 Subject: [PATCH 04/34] fix case --- tests/system-test/2-query/explain.py | 30 +++++++++++++++------------- 1 file changed, 16 insertions(+), 14 deletions(-) diff --git a/tests/system-test/2-query/explain.py b/tests/system-test/2-query/explain.py index b452da0a35..9694498eb5 100644 --- a/tests/system-test/2-query/explain.py +++ b/tests/system-test/2-query/explain.py @@ -33,11 +33,10 @@ class TDTestCase: tdSql.init(conn.cursor()) def __query_condition(self,tbname): - query_condition = [f"cast({col} as bigint)" for col in ALL_COL] + query_condition = [f"{tbname}.{col}" for col in ALL_COL] for num_col in NUM_COL: query_condition.extend( ( - f"{tbname}.{num_col}", f"abs( {tbname}.{num_col} )", f"acos( {tbname}.{num_col} )", f"asin( {tbname}.{num_col} )", @@ -63,18 +62,19 @@ class TDTestCase: for char_col in CHAR_COL: query_condition.extend( ( - f"count({tbname}.{char_col})", f"sum(cast({tbname}.{char_col}) as bigint)", f"max(cast({tbname}.{char_col}) as bigint)", f"min(cast({tbname}.{char_col}) as bigint)", f"avg(cast({tbname}.{char_col}) as bigint)", ) ) - # query_condition.extend( - # ( - # 1010, - # ) - # ) + query_condition.extend( + ( + 1010, + ''' "test1234!@#$%^&*():'> Date: Sat, 28 May 2022 20:09:53 +0800 Subject: [PATCH 05/34] fix case --- tests/system-test/2-query/explain.py | 22 +++++++--------------- 1 file changed, 7 insertions(+), 15 deletions(-) diff --git a/tests/system-test/2-query/explain.py b/tests/system-test/2-query/explain.py index 9694498eb5..2e94a2e462 100644 --- a/tests/system-test/2-query/explain.py +++ b/tests/system-test/2-query/explain.py @@ -199,27 +199,19 @@ class TDTestCase: tdSql.query(sqls[i]) def __test_current(self): - tdSql.query("select hyperloglog(ts) from ct1") - tdSql.checkRows(1) - tdSql.query("select hyperloglog(c1) from ct2") - tdSql.checkRows(1) - tdSql.query("select hyperloglog(c1) from ct4 group by c1") - tdSql.checkRows(self.rows + 3) - tdSql.query("select hyperloglog(c1) from ct4 group by c7") - tdSql.checkRows(3) - tdSql.query("select hyperloglog(ct2.c1) from ct4 join ct2 on ct4.ts=ct2.ts") - tdSql.checkRows(1) - tdSql.checkData(0, 0, self.rows + 2) - tdSql.query("select hyperloglog(c1), c1 from stb1 group by c1") - for i in range(tdSql.queryRows): - tdSql.checkData(i, 0, 1) if tdSql.queryResult[i][1] is not None else tdSql.checkData(i, 0, 0) + tdSql.query("explain select c1 from ct1") + tdSql.query("explain select 1 from ct2") + tdSql.query("explain select c2 from ct4 group by c1") + tdSql.query("explain select count(c3) from ct4 group by c7 having count(c3) > 0") + tdSql.query("explain select ct2.c3 from ct4 join ct2 on ct4.ts=ct2.ts") + tdSql.query("explain select c1 from stb1 where c1 is not null and c1 in (0, 1, 2) or c1 between 2 and 100 ") self.hyperloglog_check() def __test_error(self): tdLog.printNoPrefix("===step 0: err case, must return err") - tdSql.error( "select hyperloglog(c1) from ct8" ) + tdSql.error( "explain select hyperloglog(c1) from ct8" ) tdSql.error( "explain show databases " ) tdSql.error( "explain show stables " ) tdSql.error( "explain show tables " ) From c33d785b6e11c45227435cc26890beccef4ba2cc Mon Sep 17 00:00:00 2001 From: cpwu Date: Sat, 28 May 2022 20:12:42 +0800 Subject: [PATCH 06/34] fix case --- tests/system-test/2-query/explain.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/system-test/2-query/explain.py b/tests/system-test/2-query/explain.py index 2e94a2e462..53f9e40170 100644 --- a/tests/system-test/2-query/explain.py +++ b/tests/system-test/2-query/explain.py @@ -201,7 +201,7 @@ class TDTestCase: def __test_current(self): tdSql.query("explain select c1 from ct1") tdSql.query("explain select 1 from ct2") - tdSql.query("explain select c2 from ct4 group by c1") + tdSql.query("explain select cast(ceil(c6) as bigint) from ct4 group by c6") tdSql.query("explain select count(c3) from ct4 group by c7 having count(c3) > 0") tdSql.query("explain select ct2.c3 from ct4 join ct2 on ct4.ts=ct2.ts") tdSql.query("explain select c1 from stb1 where c1 is not null and c1 in (0, 1, 2) or c1 between 2 and 100 ") From fe491e3e9e36d1563b1eb1ece47756bd39bb9a7e Mon Sep 17 00:00:00 2001 From: cpwu Date: Mon, 30 May 2022 14:19:16 +0800 Subject: [PATCH 07/34] fix case --- tests/system-test/2-query/explain.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/system-test/2-query/explain.py b/tests/system-test/2-query/explain.py index 53f9e40170..4f98b4685d 100644 --- a/tests/system-test/2-query/explain.py +++ b/tests/system-test/2-query/explain.py @@ -62,10 +62,10 @@ class TDTestCase: for char_col in CHAR_COL: query_condition.extend( ( - f"sum(cast({tbname}.{char_col}) as bigint)", - f"max(cast({tbname}.{char_col}) as bigint)", - f"min(cast({tbname}.{char_col}) as bigint)", - f"avg(cast({tbname}.{char_col}) as bigint)", + f"sum(cast({tbname}.{char_col} as bigint ))", + f"max(cast({tbname}.{char_col} as bigint ))", + f"min(cast({tbname}.{char_col} as bigint ))", + f"avg(cast({tbname}.{char_col} as bigint ))", ) ) query_condition.extend( From b08f9094253fb4b9b54ff05e0542493bb00b8e7d Mon Sep 17 00:00:00 2001 From: cpwu Date: Mon, 30 May 2022 14:20:36 +0800 Subject: [PATCH 08/34] fix case --- tests/system-test/2-query/explain.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/system-test/2-query/explain.py b/tests/system-test/2-query/explain.py index 4f98b4685d..61954f8a38 100644 --- a/tests/system-test/2-query/explain.py +++ b/tests/system-test/2-query/explain.py @@ -121,6 +121,8 @@ class TDTestCase: col = col[4:-1] elif col.startswith("min"): col = col[4:-1] + elif col.startswith("avg"): + col = col[4:-1] return f" group by {col} having {having}" if having else f" group by {col} " def __single_sql(self, select_clause, from_clause, where_condition="", group_condition=""): From 56054ebae8dca15898017a2540fc832dda4621a4 Mon Sep 17 00:00:00 2001 From: cpwu Date: Mon, 30 May 2022 15:08:08 +0800 Subject: [PATCH 09/34] fix case --- tests/system-test/2-query/explain.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/system-test/2-query/explain.py b/tests/system-test/2-query/explain.py index 61954f8a38..45465cd71c 100644 --- a/tests/system-test/2-query/explain.py +++ b/tests/system-test/2-query/explain.py @@ -97,6 +97,8 @@ class TDTestCase: query_conditon = query_conditon[4:-1] elif query_conditon.startswith("min"): query_conditon = query_conditon[4:-1] + elif query_conditon.startswith("avg"): + query_conditon = query_conditon[4:-1] if query_conditon: return f" where {query_conditon} is not null" From 252dfe934680367989c518d2a4c7eb71e6f707dd Mon Sep 17 00:00:00 2001 From: cpwu Date: Mon, 30 May 2022 15:22:53 +0800 Subject: [PATCH 10/34] fix case --- tests/system-test/2-query/histogram.py | 626 ++++++++++++------------- tests/system-test/fulltest.sh | 1 + 2 files changed, 314 insertions(+), 313 deletions(-) diff --git a/tests/system-test/2-query/histogram.py b/tests/system-test/2-query/histogram.py index 2c203bdceb..c106d4d27c 100644 --- a/tests/system-test/2-query/histogram.py +++ b/tests/system-test/2-query/histogram.py @@ -1,361 +1,361 @@ -import datetime +# import datetime -from util.log import * -from util.sql import * -from util.cases import * -from util.dnodes import * +# from util.log import * +# from util.sql import * +# from util.cases import * +# from util.dnodes import * -PRIMARY_COL = "ts" +# PRIMARY_COL = "ts" -INT_COL = "c1" -BINT_COL = "c2" -SINT_COL = "c3" -TINT_COL = "c4" -FLOAT_COL = "c5" -DOUBLE_COL = "c6" -BOOL_COL = "c7" +# INT_COL = "c1" +# BINT_COL = "c2" +# SINT_COL = "c3" +# TINT_COL = "c4" +# FLOAT_COL = "c5" +# DOUBLE_COL = "c6" +# BOOL_COL = "c7" -BINARY_COL = "c8" -NCHAR_COL = "c9" -TS_COL = "c10" +# BINARY_COL = "c8" +# NCHAR_COL = "c9" +# TS_COL = "c10" -NUM_COL = [ INT_COL, BINT_COL, SINT_COL, TINT_COL, FLOAT_COL, DOUBLE_COL, ] -CHAR_COL = [ BINARY_COL, NCHAR_COL, ] -BOOLEAN_COL = [ BOOL_COL, ] -TS_TYPE_COL = [ TS_COL, ] +# NUM_COL = [ INT_COL, BINT_COL, SINT_COL, TINT_COL, FLOAT_COL, DOUBLE_COL, ] +# CHAR_COL = [ BINARY_COL, NCHAR_COL, ] +# BOOLEAN_COL = [ BOOL_COL, ] +# TS_TYPE_COL = [ TS_COL, ] -ALL_COL = [ INT_COL, BINT_COL, SINT_COL, TINT_COL, FLOAT_COL, DOUBLE_COL, BOOL_COL, BINARY_COL, NCHAR_COL, TS_COL ] +# ALL_COL = [ INT_COL, BINT_COL, SINT_COL, TINT_COL, FLOAT_COL, DOUBLE_COL, BOOL_COL, BINARY_COL, NCHAR_COL, TS_COL ] -class TDTestCase: +# class TDTestCase: - def init(self, conn, logSql): - tdLog.debug(f"start to excute {__file__}") - tdSql.init(conn.cursor()) +# def init(self, conn, logSql): +# tdLog.debug(f"start to excute {__file__}") +# tdSql.init(conn.cursor()) - def __query_condition(self,tbname): - query_condition = [f"cast({col} as bigint)" for col in ALL_COL] - for num_col in NUM_COL: - query_condition.extend( - ( - f"{tbname}.{num_col}", - f"abs( {tbname}.{num_col} )", - f"acos( {tbname}.{num_col} )", - f"asin( {tbname}.{num_col} )", - f"atan( {tbname}.{num_col} )", - f"avg( {tbname}.{num_col} )", - f"ceil( {tbname}.{num_col} )", - f"cos( {tbname}.{num_col} )", - f"count( {tbname}.{num_col} )", - f"floor( {tbname}.{num_col} )", - f"log( {tbname}.{num_col}, {tbname}.{num_col})", - f"max( {tbname}.{num_col} )", - f"min( {tbname}.{num_col} )", - f"pow( {tbname}.{num_col}, 2)", - f"round( {tbname}.{num_col} )", - f"sum( {tbname}.{num_col} )", - f"sin( {tbname}.{num_col} )", - f"sqrt( {tbname}.{num_col} )", - f"tan( {tbname}.{num_col} )", - f"cast( {tbname}.{num_col} as timestamp)", - ) - ) - [ query_condition.append(f"{num_col} + {any_col}") for any_col in ALL_COL ] - for char_col in CHAR_COL: - query_condition.extend( - ( - f"count({tbname}.{char_col})", - f"sum(cast({tbname}.{char_col}) as bigint)", - f"max(cast({tbname}.{char_col}) as bigint)", - f"min(cast({tbname}.{char_col}) as bigint)", - f"avg(cast({tbname}.{char_col}) as bigint)", - ) - ) - query_condition.extend( - ( - 1010, - ) - ) +# def __query_condition(self,tbname): +# query_condition = [f"cast({col} as bigint)" for col in ALL_COL] +# for num_col in NUM_COL: +# query_condition.extend( +# ( +# f"{tbname}.{num_col}", +# f"abs( {tbname}.{num_col} )", +# f"acos( {tbname}.{num_col} )", +# f"asin( {tbname}.{num_col} )", +# f"atan( {tbname}.{num_col} )", +# f"avg( {tbname}.{num_col} )", +# f"ceil( {tbname}.{num_col} )", +# f"cos( {tbname}.{num_col} )", +# f"count( {tbname}.{num_col} )", +# f"floor( {tbname}.{num_col} )", +# f"log( {tbname}.{num_col}, {tbname}.{num_col})", +# f"max( {tbname}.{num_col} )", +# f"min( {tbname}.{num_col} )", +# f"pow( {tbname}.{num_col}, 2)", +# f"round( {tbname}.{num_col} )", +# f"sum( {tbname}.{num_col} )", +# f"sin( {tbname}.{num_col} )", +# f"sqrt( {tbname}.{num_col} )", +# f"tan( {tbname}.{num_col} )", +# f"cast( {tbname}.{num_col} as timestamp)", +# ) +# ) +# [ query_condition.append(f"{num_col} + {any_col}") for any_col in ALL_COL ] +# for char_col in CHAR_COL: +# query_condition.extend( +# ( +# f"count({tbname}.{char_col})", +# f"sum(cast({tbname}.{char_col}) as bigint)", +# f"max(cast({tbname}.{char_col}) as bigint)", +# f"min(cast({tbname}.{char_col}) as bigint)", +# f"avg(cast({tbname}.{char_col}) as bigint)", +# ) +# ) +# query_condition.extend( +# ( +# 1010, +# ) +# ) - return query_condition +# return query_condition - def __join_condition(self, tb_list, filter=PRIMARY_COL, INNER=False): - table_reference = tb_list[0] - join_condition = table_reference - join = "inner join" if INNER else "join" - for i in range(len(tb_list[1:])): - join_condition += f" {join} {tb_list[i+1]} on {table_reference}.{filter}={tb_list[i+1]}.{filter}" +# def __join_condition(self, tb_list, filter=PRIMARY_COL, INNER=False): +# table_reference = tb_list[0] +# join_condition = table_reference +# join = "inner join" if INNER else "join" +# for i in range(len(tb_list[1:])): +# join_condition += f" {join} {tb_list[i+1]} on {table_reference}.{filter}={tb_list[i+1]}.{filter}" - return join_condition +# return join_condition - def __where_condition(self, col=None, tbname=None, query_conditon=None): - if query_conditon and isinstance(query_conditon, str): - if query_conditon.startswith("count"): - query_conditon = query_conditon[6:-1] - elif query_conditon.startswith("max"): - query_conditon = query_conditon[4:-1] - elif query_conditon.startswith("sum"): - query_conditon = query_conditon[4:-1] - elif query_conditon.startswith("min"): - query_conditon = query_conditon[4:-1] +# def __where_condition(self, col=None, tbname=None, query_conditon=None): +# if query_conditon and isinstance(query_conditon, str): +# if query_conditon.startswith("count"): +# query_conditon = query_conditon[6:-1] +# elif query_conditon.startswith("max"): +# query_conditon = query_conditon[4:-1] +# elif query_conditon.startswith("sum"): +# query_conditon = query_conditon[4:-1] +# elif query_conditon.startswith("min"): +# query_conditon = query_conditon[4:-1] - if query_conditon: - return f" where {query_conditon} is not null" - if col in NUM_COL: - return f" where abs( {tbname}.{col} ) >= 0" - if col in CHAR_COL: - return f" where lower( {tbname}.{col} ) like 'bina%' or lower( {tbname}.{col} ) like '_cha%' " - if col in BOOLEAN_COL: - return f" where {tbname}.{col} in (false, true) " - if col in TS_TYPE_COL or col in PRIMARY_COL: - return f" where cast( {tbname}.{col} as binary(16) ) is not null " +# if query_conditon: +# return f" where {query_conditon} is not null" +# if col in NUM_COL: +# return f" where abs( {tbname}.{col} ) >= 0" +# if col in CHAR_COL: +# return f" where lower( {tbname}.{col} ) like 'bina%' or lower( {tbname}.{col} ) like '_cha%' " +# if col in BOOLEAN_COL: +# return f" where {tbname}.{col} in (false, true) " +# if col in TS_TYPE_COL or col in PRIMARY_COL: +# return f" where cast( {tbname}.{col} as binary(16) ) is not null " - return "" +# return "" - def __group_condition(self, col, having = None): - if isinstance(col, str): - if col.startswith("count"): - col = col[6:-1] - elif col.startswith("max"): - col = col[4:-1] - elif col.startswith("sum"): - col = col[4:-1] - elif col.startswith("min"): - col = col[4:-1] - return f" group by {col} having {having}" if having else f" group by {col} " +# def __group_condition(self, col, having = None): +# if isinstance(col, str): +# if col.startswith("count"): +# col = col[6:-1] +# elif col.startswith("max"): +# col = col[4:-1] +# elif col.startswith("sum"): +# col = col[4:-1] +# elif col.startswith("min"): +# col = col[4:-1] +# return f" group by {col} having {having}" if having else f" group by {col} " - def __single_sql(self, select_clause, from_clause, where_condition="", group_condition=""): - if isinstance(select_clause, str) and "on" not in from_clause and select_clause.split(".")[0] != from_clause.split(".")[0]: - return - return f"select spread({select_clause}) from {from_clause} {where_condition} {group_condition}" +# def __single_sql(self, select_clause, from_clause, where_condition="", group_condition=""): +# if isinstance(select_clause, str) and "on" not in from_clause and select_clause.split(".")[0] != from_clause.split(".")[0]: +# return +# return f"select spread({select_clause}) from {from_clause} {where_condition} {group_condition}" - @property - def __tb_list(self): - return [ - "ct1", - "ct4", - "t1", - "ct2", - "stb1", - ] +# @property +# def __tb_list(self): +# return [ +# "ct1", +# "ct4", +# "t1", +# "ct2", +# "stb1", +# ] - def sql_list(self): - sqls = [] - __no_join_tblist = self.__tb_list - for tb in __no_join_tblist: - select_claus_list = self.__query_condition(tb) - for select_claus in select_claus_list: - group_claus = self.__group_condition(col=select_claus) - where_claus = self.__where_condition(query_conditon=select_claus) - having_claus = self.__group_condition(col=select_claus, having=f"{select_claus} is not null") - sqls.extend( - ( - self.__single_sql(select_claus, tb, where_claus, having_claus), - self.__single_sql(select_claus, tb,), - self.__single_sql(select_claus, tb, where_condition=where_claus), - self.__single_sql(select_claus, tb, group_condition=group_claus), - ) - ) +# def sql_list(self): +# sqls = [] +# __no_join_tblist = self.__tb_list +# for tb in __no_join_tblist: +# select_claus_list = self.__query_condition(tb) +# for select_claus in select_claus_list: +# group_claus = self.__group_condition(col=select_claus) +# where_claus = self.__where_condition(query_conditon=select_claus) +# having_claus = self.__group_condition(col=select_claus, having=f"{select_claus} is not null") +# sqls.extend( +# ( +# self.__single_sql(select_claus, tb, where_claus, having_claus), +# self.__single_sql(select_claus, tb,), +# self.__single_sql(select_claus, tb, where_condition=where_claus), +# self.__single_sql(select_claus, tb, group_condition=group_claus), +# ) +# ) - # return filter(None, sqls) - return list(filter(None, sqls)) +# # return filter(None, sqls) +# return list(filter(None, sqls)) - def __get_type(self, col): - if tdSql.cursor.istype(col, "BOOL"): - return "BOOL" - if tdSql.cursor.istype(col, "INT"): - return "INT" - if tdSql.cursor.istype(col, "BIGINT"): - return "BIGINT" - if tdSql.cursor.istype(col, "TINYINT"): - return "TINYINT" - if tdSql.cursor.istype(col, "SMALLINT"): - return "SMALLINT" - if tdSql.cursor.istype(col, "FLOAT"): - return "FLOAT" - if tdSql.cursor.istype(col, "DOUBLE"): - return "DOUBLE" - if tdSql.cursor.istype(col, "BINARY"): - return "BINARY" - if tdSql.cursor.istype(col, "NCHAR"): - return "NCHAR" - if tdSql.cursor.istype(col, "TIMESTAMP"): - return "TIMESTAMP" - if tdSql.cursor.istype(col, "JSON"): - return "JSON" - if tdSql.cursor.istype(col, "TINYINT UNSIGNED"): - return "TINYINT UNSIGNED" - if tdSql.cursor.istype(col, "SMALLINT UNSIGNED"): - return "SMALLINT UNSIGNED" - if tdSql.cursor.istype(col, "INT UNSIGNED"): - return "INT UNSIGNED" - if tdSql.cursor.istype(col, "BIGINT UNSIGNED"): - return "BIGINT UNSIGNED" +# def __get_type(self, col): +# if tdSql.cursor.istype(col, "BOOL"): +# return "BOOL" +# if tdSql.cursor.istype(col, "INT"): +# return "INT" +# if tdSql.cursor.istype(col, "BIGINT"): +# return "BIGINT" +# if tdSql.cursor.istype(col, "TINYINT"): +# return "TINYINT" +# if tdSql.cursor.istype(col, "SMALLINT"): +# return "SMALLINT" +# if tdSql.cursor.istype(col, "FLOAT"): +# return "FLOAT" +# if tdSql.cursor.istype(col, "DOUBLE"): +# return "DOUBLE" +# if tdSql.cursor.istype(col, "BINARY"): +# return "BINARY" +# if tdSql.cursor.istype(col, "NCHAR"): +# return "NCHAR" +# if tdSql.cursor.istype(col, "TIMESTAMP"): +# return "TIMESTAMP" +# if tdSql.cursor.istype(col, "JSON"): +# return "JSON" +# if tdSql.cursor.istype(col, "TINYINT UNSIGNED"): +# return "TINYINT UNSIGNED" +# if tdSql.cursor.istype(col, "SMALLINT UNSIGNED"): +# return "SMALLINT UNSIGNED" +# if tdSql.cursor.istype(col, "INT UNSIGNED"): +# return "INT UNSIGNED" +# if tdSql.cursor.istype(col, "BIGINT UNSIGNED"): +# return "BIGINT UNSIGNED" - def spread_check(self): - sqls = self.sql_list() - tdLog.printNoPrefix("===step 1: curent case, must return query OK") - for i in range(len(sqls)): - tdLog.info(f"sql: {sqls[i]}") - tdSql.query(sqls[i]) +# def spread_check(self): +# sqls = self.sql_list() +# tdLog.printNoPrefix("===step 1: curent case, must return query OK") +# for i in range(len(sqls)): +# tdLog.info(f"sql: {sqls[i]}") +# tdSql.query(sqls[i]) - def __test_current(self): - tdSql.query("select spread(ts) from ct1") - tdSql.checkRows(1) - tdSql.query("select spread(c1) from ct2") - tdSql.checkRows(1) - tdSql.query("select spread(c1) from ct4 group by c1") - tdSql.checkRows(self.rows + 3) - tdSql.query("select spread(c1) from ct4 group by c7") - tdSql.checkRows(3) - tdSql.query("select spread(ct2.c1) from ct4 join ct2 on ct4.ts=ct2.ts") - tdSql.checkRows(1) +# def __test_current(self): +# tdSql.query("select spread(ts) from ct1") +# tdSql.checkRows(1) +# tdSql.query("select spread(c1) from ct2") +# tdSql.checkRows(1) +# tdSql.query("select spread(c1) from ct4 group by c1") +# tdSql.checkRows(self.rows + 3) +# tdSql.query("select spread(c1) from ct4 group by c7") +# tdSql.checkRows(3) +# tdSql.query("select spread(ct2.c1) from ct4 join ct2 on ct4.ts=ct2.ts") +# tdSql.checkRows(1) - self.spread_check() +# self.spread_check() - def __test_error(self): +# def __test_error(self): - tdLog.printNoPrefix("===step 0: err case, must return err") - tdSql.error( "select spread() from ct1" ) - tdSql.error( "select spread(1, 2) from ct2" ) - tdSql.error( f"select spread({NUM_COL[0]}, {NUM_COL[1]}) from ct4" ) - tdSql.error( f"select spread({BOOLEAN_COL[0]}) from t1" ) - tdSql.error( f"select spread({CHAR_COL[0]}) from stb1" ) +# tdLog.printNoPrefix("===step 0: err case, must return err") +# tdSql.error( "select spread() from ct1" ) +# tdSql.error( "select spread(1, 2) from ct2" ) +# tdSql.error( f"select spread({NUM_COL[0]}, {NUM_COL[1]}) from ct4" ) +# tdSql.error( f"select spread({BOOLEAN_COL[0]}) from t1" ) +# tdSql.error( f"select spread({CHAR_COL[0]}) from stb1" ) - # tdSql.error( ''' select spread(['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10']) - # from ct1 - # where ['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'] is not null - # group by ['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'] - # having ['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'] is not null ''' ) - # tdSql.error( "select c1 from ct1 union select c1 from ct2 union select c1 from ct4 ") +# # tdSql.error( ''' select spread(['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10']) +# # from ct1 +# # where ['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'] is not null +# # group by ['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'] +# # having ['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'] is not null ''' ) +# # tdSql.error( "select c1 from ct1 union select c1 from ct2 union select c1 from ct4 ") - def all_test(self): - self.__test_error() - self.__test_current() +# def all_test(self): +# self.__test_error() +# self.__test_current() - def __create_tb(self): +# def __create_tb(self): - tdLog.printNoPrefix("==========step1:create table") - create_stb_sql = f'''create table stb1( - ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint, - {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, - {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp - ) tags (t1 int) - ''' - create_ntb_sql = f'''create table t1( - ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint, - {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, - {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp - ) - ''' - tdSql.execute(create_stb_sql) - tdSql.execute(create_ntb_sql) +# tdLog.printNoPrefix("==========step1:create table") +# create_stb_sql = f'''create table stb1( +# ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint, +# {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, +# {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp +# ) tags (t1 int) +# ''' +# create_ntb_sql = f'''create table t1( +# ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint, +# {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, +# {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp +# ) +# ''' +# tdSql.execute(create_stb_sql) +# tdSql.execute(create_ntb_sql) - for i in range(4): - tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )') - { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2} +# for i in range(4): +# tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )') +# { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2} - def __insert_data(self, rows): - now_time = int(datetime.datetime.timestamp(datetime.datetime.now()) * 1000) - for i in range(rows): - tdSql.execute( - f"insert into ct1 values ( { now_time - i * 1000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" - ) - tdSql.execute( - f"insert into ct4 values ( { now_time - i * 7776000000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" - ) - tdSql.execute( - f"insert into ct2 values ( { now_time - i * 7776000000 }, {-i}, {-11111 * i}, {-111 * i % 32767 }, {-11 * i % 127}, {-1.11*i}, {-1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" - ) - tdSql.execute( - f'''insert into ct1 values - ( { now_time - rows * 5 }, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar_测试_0', { now_time + 8 } ) - ( { now_time + 10000 }, { rows }, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar_测试_9', { now_time + 9 } ) - ''' - ) +# def __insert_data(self, rows): +# now_time = int(datetime.datetime.timestamp(datetime.datetime.now()) * 1000) +# for i in range(rows): +# tdSql.execute( +# f"insert into ct1 values ( { now_time - i * 1000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" +# ) +# tdSql.execute( +# f"insert into ct4 values ( { now_time - i * 7776000000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" +# ) +# tdSql.execute( +# f"insert into ct2 values ( { now_time - i * 7776000000 }, {-i}, {-11111 * i}, {-111 * i % 32767 }, {-11 * i % 127}, {-1.11*i}, {-1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" +# ) +# tdSql.execute( +# f'''insert into ct1 values +# ( { now_time - rows * 5 }, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar_测试_0', { now_time + 8 } ) +# ( { now_time + 10000 }, { rows }, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar_测试_9', { now_time + 9 } ) +# ''' +# ) - tdSql.execute( - f'''insert into ct4 values - ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) - ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) - ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) - ( - { now_time + 5184000000}, {pow(2,31)-pow(2,15)}, {pow(2,63)-pow(2,30)}, 32767, 127, - { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000} - ) - ( - { now_time + 2592000000 }, {pow(2,31)-pow(2,16)}, {pow(2,63)-pow(2,31)}, 32766, 126, - { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000} - ) - ''' - ) +# tdSql.execute( +# f'''insert into ct4 values +# ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) +# ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) +# ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) +# ( +# { now_time + 5184000000}, {pow(2,31)-pow(2,15)}, {pow(2,63)-pow(2,30)}, 32767, 127, +# { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000} +# ) +# ( +# { now_time + 2592000000 }, {pow(2,31)-pow(2,16)}, {pow(2,63)-pow(2,31)}, 32766, 126, +# { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000} +# ) +# ''' +# ) - tdSql.execute( - f'''insert into ct2 values - ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) - ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) - ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) - ( - { now_time + 5184000000 }, { -1 * pow(2,31) + pow(2,15) }, { -1 * pow(2,63) + pow(2,30) }, -32766, -126, - { -1 * 3.2 * pow(10,38) }, { -1.2 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 } - ) - ( - { now_time + 2592000000 }, { -1 * pow(2,31) + pow(2,16) }, { -1 * pow(2,63) + pow(2,31) }, -32767, -127, - { - 3.3 * pow(10,38) }, { -1.3 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 } - ) - ''' - ) +# tdSql.execute( +# f'''insert into ct2 values +# ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) +# ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) +# ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) +# ( +# { now_time + 5184000000 }, { -1 * pow(2,31) + pow(2,15) }, { -1 * pow(2,63) + pow(2,30) }, -32766, -126, +# { -1 * 3.2 * pow(10,38) }, { -1.2 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 } +# ) +# ( +# { now_time + 2592000000 }, { -1 * pow(2,31) + pow(2,16) }, { -1 * pow(2,63) + pow(2,31) }, -32767, -127, +# { - 3.3 * pow(10,38) }, { -1.3 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 } +# ) +# ''' +# ) - for i in range(rows): - insert_data = f'''insert into t1 values - ( { now_time - i * 3600000 }, {i}, {i * 11111}, { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2}, - "binary_{i}", "nchar_测试_{i}", { now_time - 1000 * i } ) - ''' - tdSql.execute(insert_data) - tdSql.execute( - f'''insert into t1 values - ( { now_time + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) - ( { now_time - (( rows // 2 ) * 60 + 30) * 60000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) - ( { now_time - rows * 3600000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) - ( { now_time + 7200000 }, { pow(2,31) - pow(2,15) }, { pow(2,63) - pow(2,30) }, 32767, 127, - { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 }, - "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 } - ) - ( - { now_time + 3600000 } , { pow(2,31) - pow(2,16) }, { pow(2,63) - pow(2,31) }, 32766, 126, - { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, - "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 } - ) - ''' - ) +# for i in range(rows): +# insert_data = f'''insert into t1 values +# ( { now_time - i * 3600000 }, {i}, {i * 11111}, { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2}, +# "binary_{i}", "nchar_测试_{i}", { now_time - 1000 * i } ) +# ''' +# tdSql.execute(insert_data) +# tdSql.execute( +# f'''insert into t1 values +# ( { now_time + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) +# ( { now_time - (( rows // 2 ) * 60 + 30) * 60000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) +# ( { now_time - rows * 3600000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) +# ( { now_time + 7200000 }, { pow(2,31) - pow(2,15) }, { pow(2,63) - pow(2,30) }, 32767, 127, +# { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 }, +# "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 } +# ) +# ( +# { now_time + 3600000 } , { pow(2,31) - pow(2,16) }, { pow(2,63) - pow(2,31) }, 32766, 126, +# { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, +# "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 } +# ) +# ''' +# ) - def run(self): - tdSql.prepare() +# def run(self): +# tdSql.prepare() - tdLog.printNoPrefix("==========step1:create table") - self.__create_tb() +# tdLog.printNoPrefix("==========step1:create table") +# self.__create_tb() - tdLog.printNoPrefix("==========step2:insert data") - self.rows = 10 - self.__insert_data(self.rows) +# tdLog.printNoPrefix("==========step2:insert data") +# self.rows = 10 +# self.__insert_data(self.rows) - tdLog.printNoPrefix("==========step3:all check") - self.all_test() +# tdLog.printNoPrefix("==========step3:all check") +# self.all_test() - tdDnodes.stop(1) - tdDnodes.start(1) +# tdDnodes.stop(1) +# tdDnodes.start(1) - tdSql.execute("use db") +# tdSql.execute("use db") - tdLog.printNoPrefix("==========step4:after wal, all check again ") - self.all_test() +# tdLog.printNoPrefix("==========step4:after wal, all check again ") +# self.all_test() - def stop(self): - tdSql.close() - tdLog.success(f"{__file__} successfully executed") +# def stop(self): +# tdSql.close() +# tdLog.success(f"{__file__} successfully executed") -tdCases.addLinux(__file__, TDTestCase()) -tdCases.addWindows(__file__, TDTestCase()) +# tdCases.addLinux(__file__, TDTestCase()) +# tdCases.addWindows(__file__, TDTestCase()) diff --git a/tests/system-test/fulltest.sh b/tests/system-test/fulltest.sh index aa6843435c..469e4bd9dc 100755 --- a/tests/system-test/fulltest.sh +++ b/tests/system-test/fulltest.sh @@ -35,6 +35,7 @@ python3 ./test.py -f 2-query/concat_ws2.py python3 ./test.py -f 2-query/check_tsdb.py python3 ./test.py -f 2-query/spread.py python3 ./test.py -f 2-query/hyperloglog.py +python3 ./test.py -f 2-query/explain.py python3 ./test.py -f 2-query/timezone.py From 8be02e1401ee9f35ab1560b6f61f823a1323f2fa Mon Sep 17 00:00:00 2001 From: cpwu Date: Tue, 31 May 2022 20:45:23 +0800 Subject: [PATCH 11/34] fix case --- tests/system-test/2-query/explain.py | 4 +- tests/system-test/2-query/leastsquares.py | 385 ++++++++++++++++++++++ 2 files changed, 387 insertions(+), 2 deletions(-) create mode 100644 tests/system-test/2-query/leastsquares.py diff --git a/tests/system-test/2-query/explain.py b/tests/system-test/2-query/explain.py index 45465cd71c..d440144841 100644 --- a/tests/system-test/2-query/explain.py +++ b/tests/system-test/2-query/explain.py @@ -195,7 +195,7 @@ class TDTestCase: if tdSql.cursor.istype(col, "BIGINT UNSIGNED"): return "BIGINT UNSIGNED" - def hyperloglog_check(self): + def explain_check(self): sqls = self.sql_list() tdLog.printNoPrefix("===step 1: curent case, must return query OK") for i in range(len(sqls)): @@ -210,7 +210,7 @@ class TDTestCase: tdSql.query("explain select ct2.c3 from ct4 join ct2 on ct4.ts=ct2.ts") tdSql.query("explain select c1 from stb1 where c1 is not null and c1 in (0, 1, 2) or c1 between 2 and 100 ") - self.hyperloglog_check() + self.explain_check() def __test_error(self): diff --git a/tests/system-test/2-query/leastsquares.py b/tests/system-test/2-query/leastsquares.py new file mode 100644 index 0000000000..775b624ee1 --- /dev/null +++ b/tests/system-test/2-query/leastsquares.py @@ -0,0 +1,385 @@ +import datetime + +from util.log import * +from util.sql import * +from util.cases import * +from util.dnodes import * + +PRIMARY_COL = "ts" + +INT_COL = "c1" +BINT_COL = "c2" +SINT_COL = "c3" +TINT_COL = "c4" +FLOAT_COL = "c5" +DOUBLE_COL = "c6" +BOOL_COL = "c7" + +BINARY_COL = "c8" +NCHAR_COL = "c9" +TS_COL = "c10" + +NUM_COL = [ INT_COL, BINT_COL, SINT_COL, TINT_COL, FLOAT_COL, DOUBLE_COL, ] +CHAR_COL = [ BINARY_COL, NCHAR_COL, ] +BOOLEAN_COL = [ BOOL_COL, ] +TS_TYPE_COL = [ TS_COL, ] + +ALL_COL = [ INT_COL, BINT_COL, SINT_COL, TINT_COL, FLOAT_COL, DOUBLE_COL, BOOL_COL, BINARY_COL, NCHAR_COL, TS_COL ] + +class TDTestCase: + + def init(self, conn, logSql): + tdLog.debug(f"start to excute {__file__}") + tdSql.init(conn.cursor()) + + def __query_condition(self,tbname): + query_condition = [f"{tbname}.{col}" for col in ALL_COL] + for num_col in NUM_COL: + query_condition.extend( + ( + f"abs( {tbname}.{num_col} )", + f"acos( {tbname}.{num_col} )", + f"asin( {tbname}.{num_col} )", + f"atan( {tbname}.{num_col} )", + f"avg( {tbname}.{num_col} )", + f"ceil( {tbname}.{num_col} )", + f"cos( {tbname}.{num_col} )", + f"count( {tbname}.{num_col} )", + f"floor( {tbname}.{num_col} )", + f"log( {tbname}.{num_col}, {tbname}.{num_col})", + f"max( {tbname}.{num_col} )", + f"min( {tbname}.{num_col} )", + f"pow( {tbname}.{num_col}, 2)", + f"round( {tbname}.{num_col} )", + f"sum( {tbname}.{num_col} )", + f"sin( {tbname}.{num_col} )", + f"sqrt( {tbname}.{num_col} )", + f"tan( {tbname}.{num_col} )", + f"cast( {tbname}.{num_col} as timestamp)", + ) + ) + query_condition.extend((f"{num_col} + {any_col}" for any_col in ALL_COL)) + for char_col in CHAR_COL: + query_condition.extend( + ( + f"sum(cast({tbname}.{char_col} as bigint ))", + f"max(cast({tbname}.{char_col} as bigint ))", + f"min(cast({tbname}.{char_col} as bigint ))", + f"avg(cast({tbname}.{char_col} as bigint ))", + ) + ) + query_condition.extend( + ( + 1010, + ''' "test1234!@#$%^&*():'>= 0" + if col in CHAR_COL: + return f" where lower( {tbname}.{col} ) like 'bina%' or lower( {tbname}.{col} ) like '_cha%' " + if col in BOOLEAN_COL: + return f" where {tbname}.{col} in (false, true) " + if col in TS_TYPE_COL or col in PRIMARY_COL: + return f" where cast( {tbname}.{col} as binary(16) ) is not null " + + return "" + + def __group_condition(self, col, having = None): + if isinstance(col, str): + if col.startswith("count"): + col = col[6:-1] + elif col.startswith("max"): + col = col[4:-1] + elif col.startswith("sum"): + col = col[4:-1] + elif col.startswith("min"): + col = col[4:-1] + elif col.startswith("avg"): + col = col[4:-1] + return f" group by {col} having {having}" if having else f" group by {col} " + + def __single_sql(self, select_clause, from_clause, start_val=0, step_val=0, where_condition="", group_condition=""): + if isinstance(select_clause, str) and "on" not in from_clause and select_clause.split(".")[0].split("(")[-1] != from_clause.split(".")[0]: + return + return f"select leastsquares({select_clause}, {start_val}, {step_val}) from {from_clause} {where_condition} {group_condition}" + + @property + def __tb_list(self): + return [ + "ct1", + "ct4", + "t1", + "ct2", + "stb1", + ] + + @property + def start_step_val(self): + return [ + 1, + 0, + 1.25, + -2.5, + True, + False, + None, + "", + "str", + ] + + def sql_list(self): + current_sqls = [] + err_sqls = [] + __no_join_tblist = self.__tb_list + for tb in __no_join_tblist: + select_claus_list = self.__query_condition(tb) + for select_claus in select_claus_list: + group_claus = self.__group_condition(col=select_claus) + where_claus = self.__where_condition(query_conditon=select_claus) + having_claus = self.__group_condition(col=select_claus, having=f"{select_claus} is not null") + for arg in self.start_step_val: + if not isinstance(arg,int): + err_sqls.extend( + ( + self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg), + self.__single_sql(select_clause=select_claus, from_clause=tb, step_val=arg, group_condition=group_claus), + self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg, step_val=arg, where_condition=where_claus, group_condition=having_claus), + ) + ) + else: + current_sqls.extend( + ( + self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg), + self.__single_sql(select_clause=select_claus, from_clause=tb, step_val=arg, group_condition=group_claus), + self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg, step_val=arg, where_condition=where_claus, group_condition=having_claus), + ) + ) + + # return filter(None, sqls) + return list(filter(None, current_sqls)), list(filter(None, err_sqls)) + + def __get_type(self, col): + if tdSql.cursor.istype(col, "BOOL"): + return "BOOL" + if tdSql.cursor.istype(col, "INT"): + return "INT" + if tdSql.cursor.istype(col, "BIGINT"): + return "BIGINT" + if tdSql.cursor.istype(col, "TINYINT"): + return "TINYINT" + if tdSql.cursor.istype(col, "SMALLINT"): + return "SMALLINT" + if tdSql.cursor.istype(col, "FLOAT"): + return "FLOAT" + if tdSql.cursor.istype(col, "DOUBLE"): + return "DOUBLE" + if tdSql.cursor.istype(col, "BINARY"): + return "BINARY" + if tdSql.cursor.istype(col, "NCHAR"): + return "NCHAR" + if tdSql.cursor.istype(col, "TIMESTAMP"): + return "TIMESTAMP" + if tdSql.cursor.istype(col, "JSON"): + return "JSON" + if tdSql.cursor.istype(col, "TINYINT UNSIGNED"): + return "TINYINT UNSIGNED" + if tdSql.cursor.istype(col, "SMALLINT UNSIGNED"): + return "SMALLINT UNSIGNED" + if tdSql.cursor.istype(col, "INT UNSIGNED"): + return "INT UNSIGNED" + if tdSql.cursor.istype(col, "BIGINT UNSIGNED"): + return "BIGINT UNSIGNED" + + def leastsquares_check(self): + current_sqls, err_sqls = self.sql_list() + for i in range(len(err_sqls)): + tdSql.error(err_sqls[i]) + + tdLog.printNoPrefix("===step 1: curent case, must return query OK") + for i in range(len(current_sqls)): + tdLog.info(f"sql: {current_sqls[i]}") + tdSql.query(current_sqls[i]) + + + def __test_current(self): + tdSql.query("explain select c1 from ct1") + tdSql.query("explain select 1 from ct2") + tdSql.query("explain select cast(ceil(c6) as bigint) from ct4 group by c6") + tdSql.query("explain select count(c3) from ct4 group by c7 having count(c3) > 0") + tdSql.query("explain select ct2.c3 from ct4 join ct2 on ct4.ts=ct2.ts") + tdSql.query("explain select c1 from stb1 where c1 is not null and c1 in (0, 1, 2) or c1 between 2 and 100 ") + + self.leastsquares_check() + + def __test_error(self): + + tdLog.printNoPrefix("===step 0: err case, must return err") + tdSql.error( "explain select hyperloglog(c1) from ct8" ) + tdSql.error( "explain show databases " ) + tdSql.error( "explain show stables " ) + tdSql.error( "explain show tables " ) + tdSql.error( "explain show vgroups " ) + tdSql.error( "explain show dnodes " ) + tdSql.error( '''explain select hyperloglog(['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10']) + from ct1 + where ['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'] is not null + group by ['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'] + having ['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'] is not null ''' ) + + def all_test(self): + self.__test_error() + self.__test_current() + + def __create_tb(self): + + tdLog.printNoPrefix("==========step1:create table") + create_stb_sql = f'''create table stb1( + ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint, + {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, + {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp + ) tags (t1 int) + ''' + create_ntb_sql = f'''create table t1( + ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint, + {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, + {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp + ) + ''' + tdSql.execute(create_stb_sql) + tdSql.execute(create_ntb_sql) + + for i in range(4): + tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )') + { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2} + + def __insert_data(self, rows): + now_time = int(datetime.datetime.timestamp(datetime.datetime.now()) * 1000) + for i in range(rows): + tdSql.execute( + f"insert into ct1 values ( { now_time - i * 1000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" + ) + tdSql.execute( + f"insert into ct4 values ( { now_time - i * 7776000000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" + ) + tdSql.execute( + f"insert into ct2 values ( { now_time - i * 7776000000 }, {-i}, {-11111 * i}, {-111 * i % 32767 }, {-11 * i % 127}, {-1.11*i}, {-1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" + ) + tdSql.execute( + f'''insert into ct1 values + ( { now_time - rows * 5 }, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar_测试_0', { now_time + 8 } ) + ( { now_time + 10000 }, { rows }, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar_测试_9', { now_time + 9 } ) + ''' + ) + + tdSql.execute( + f'''insert into ct4 values + ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( + { now_time + 5184000000}, {pow(2,31)-pow(2,15)}, {pow(2,63)-pow(2,30)}, 32767, 127, + { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000} + ) + ( + { now_time + 2592000000 }, {pow(2,31)-pow(2,16)}, {pow(2,63)-pow(2,31)}, 32766, 126, + { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000} + ) + ''' + ) + + tdSql.execute( + f'''insert into ct2 values + ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( + { now_time + 5184000000 }, { -1 * pow(2,31) + pow(2,15) }, { -1 * pow(2,63) + pow(2,30) }, -32766, -126, + { -1 * 3.2 * pow(10,38) }, { -1.2 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 } + ) + ( + { now_time + 2592000000 }, { -1 * pow(2,31) + pow(2,16) }, { -1 * pow(2,63) + pow(2,31) }, -32767, -127, + { - 3.3 * pow(10,38) }, { -1.3 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 } + ) + ''' + ) + + for i in range(rows): + insert_data = f'''insert into t1 values + ( { now_time - i * 3600000 }, {i}, {i * 11111}, { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2}, + "binary_{i}", "nchar_测试_{i}", { now_time - 1000 * i } ) + ''' + tdSql.execute(insert_data) + tdSql.execute( + f'''insert into t1 values + ( { now_time + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time - (( rows // 2 ) * 60 + 30) * 60000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time - rows * 3600000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time + 7200000 }, { pow(2,31) - pow(2,15) }, { pow(2,63) - pow(2,30) }, 32767, 127, + { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 }, + "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 } + ) + ( + { now_time + 3600000 } , { pow(2,31) - pow(2,16) }, { pow(2,63) - pow(2,31) }, 32766, 126, + { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, + "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 } + ) + ''' + ) + + + def run(self): + tdSql.prepare() + + tdLog.printNoPrefix("==========step1:create table") + self.__create_tb() + + tdLog.printNoPrefix("==========step2:insert data") + self.rows = 10 + self.__insert_data(self.rows) + + tdLog.printNoPrefix("==========step3:all check") + self.all_test() + + tdDnodes.stop(1) + tdDnodes.start(1) + + tdSql.execute("use db") + + tdLog.printNoPrefix("==========step4:after wal, all check again ") + self.all_test() + + def stop(self): + tdSql.close() + tdLog.success(f"{__file__} successfully executed") + +tdCases.addLinux(__file__, TDTestCase()) +tdCases.addWindows(__file__, TDTestCase()) From e58aed4b4dae13b74839c8cce445f863f9f5c537 Mon Sep 17 00:00:00 2001 From: cpwu Date: Wed, 8 Jun 2022 18:14:17 +0800 Subject: [PATCH 12/34] fix case --- .../system-test/1-insert/create_retentions.py | 201 +++++++++ tests/system-test/2-query/histogram.py | 386 +----------------- 2 files changed, 213 insertions(+), 374 deletions(-) create mode 100644 tests/system-test/1-insert/create_retentions.py diff --git a/tests/system-test/1-insert/create_retentions.py b/tests/system-test/1-insert/create_retentions.py new file mode 100644 index 0000000000..a286625511 --- /dev/null +++ b/tests/system-test/1-insert/create_retentions.py @@ -0,0 +1,201 @@ +import datetime + +from util.log import * +from util.sql import * +from util.cases import * +from util.dnodes import * + +PRIMARY_COL = "ts" + +INT_COL = "c1" +BINT_COL = "c2" +SINT_COL = "c3" +TINT_COL = "c4" +FLOAT_COL = "c5" +DOUBLE_COL = "c6" +BOOL_COL = "c7" + +BINARY_COL = "c8" +NCHAR_COL = "c9" +TS_COL = "c10" + +NUM_COL = [ INT_COL, BINT_COL, SINT_COL, TINT_COL, FLOAT_COL, DOUBLE_COL, ] +CHAR_COL = [ BINARY_COL, NCHAR_COL, ] +BOOLEAN_COL = [ BOOL_COL, ] +TS_TYPE_COL = [ TS_COL, ] + +class TDTestCase: + + def init(self, conn, logSql): + tdLog.debug(f"start to excute {__file__}") + tdSql.init(conn.cursor(), True) + + @property + def create_databases_sql_err(self): + return [ + "create database if not exists db1 retentions 0s:1d", + "create database if not exists db1 retentions 1s:1y", + "create database if not exists db1 retentions 1s:1n", + "create database if not exists db1 retentions 1s:1n,2s:2d,3s:3d,4s:4d", + ] + + @property + def create_databases_sql_current(self): + return [ + "create database db1 retentions 1s:1d", + "create database db2 retentions 1s:1d,2m:2d,3h:3d", + ] + + @property + def alter_database_sql(self): + return [ + "alter database db1 retentions 99h:99d", + "alter database db2 retentions 97h:97d,98h:98d,99h:99d,", + ] + + @property + def create_stable_sql_err(self): + return [ + "create stable stb1 (ts timestamp, c1 int) tags (tag1 int) rollup(ceil) file_factor 0.1", + ] + + def test_create_database(self): + pass + + def test_create_databases(self): + for err_sql in self.create_databases_sql_err: + tdSql.error(err_sql) + for cur_sql in self.create_databases_sql_current: + tdSql.execute(cur_sql) + tdSql.query("show databases") + for alter_sql in self.alter_database_sql: + tdSql.error(alter_sql) + + def all_test(self): + self.test_create_databases() + + def __create_tb(self): + tdSql.prepare() + + tdLog.printNoPrefix("==========step1:create table") + create_stb_sql = f'''create table stb1( + ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint, + {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, + {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp + ) tags (t1 int) + ''' + create_ntb_sql = f'''create table t1( + ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint, + {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, + {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp + ) + ''' + tdSql.execute(create_stb_sql) + tdSql.execute(create_ntb_sql) + + for i in range(4): + tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )') + { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2} + + def __insert_data(self, rows): + now_time = int(datetime.datetime.timestamp(datetime.datetime.now()) * 1000) + for i in range(rows): + tdSql.execute( + f"insert into ct1 values ( { now_time - i * 1000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" + ) + tdSql.execute( + f"insert into ct4 values ( { now_time - i * 7776000000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" + ) + tdSql.execute( + f"insert into ct2 values ( { now_time - i * 7776000000 }, {-i}, {-11111 * i}, {-111 * i % 32767 }, {-11 * i % 127}, {-1.11*i}, {-1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" + ) + tdSql.execute( + f'''insert into ct1 values + ( { now_time - rows * 5 }, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar_测试_0', { now_time + 8 } ) + ( { now_time + 10000 }, { rows }, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar_测试_9', { now_time + 9 } ) + ''' + ) + + tdSql.execute( + f'''insert into ct4 values + ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( + { now_time + 5184000000}, {pow(2,31)-pow(2,15)}, {pow(2,63)-pow(2,30)}, 32767, 127, + { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000} + ) + ( + { now_time + 2592000000 }, {pow(2,31)-pow(2,16)}, {pow(2,63)-pow(2,31)}, 32766, 126, + { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000} + ) + ''' + ) + + tdSql.execute( + f'''insert into ct2 values + ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( + { now_time + 5184000000 }, { -1 * pow(2,31) + pow(2,15) }, { -1 * pow(2,63) + pow(2,30) }, -32766, -126, + { -1 * 3.2 * pow(10,38) }, { -1.2 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 } + ) + ( + { now_time + 2592000000 }, { -1 * pow(2,31) + pow(2,16) }, { -1 * pow(2,63) + pow(2,31) }, -32767, -127, + { - 3.3 * pow(10,38) }, { -1.3 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 } + ) + ''' + ) + + for i in range(rows): + insert_data = f'''insert into t1 values + ( { now_time - i * 3600000 }, {i}, {i * 11111}, { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2}, + "binary_{i}", "nchar_测试_{i}", { now_time - 1000 * i } ) + ''' + tdSql.execute(insert_data) + tdSql.execute( + f'''insert into t1 values + ( { now_time + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time - (( rows // 2 ) * 60 + 30) * 60000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time - rows * 3600000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time + 7200000 }, { pow(2,31) - pow(2,15) }, { pow(2,63) - pow(2,30) }, 32767, 127, + { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 }, + "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 } + ) + ( + { now_time + 3600000 } , { pow(2,31) - pow(2,16) }, { pow(2,63) - pow(2,31) }, 32766, 126, + { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, + "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 } + ) + ''' + ) + + + def run(self): + tdSql.prepare() + + tdLog.printNoPrefix("==========step1:create table") + self.__create_tb() + + tdLog.printNoPrefix("==========step2:insert data") + self.rows = 10 + self.__insert_data(self.rows) + + tdLog.printNoPrefix("==========step3:all check") + self.all_test() + + tdDnodes.stop(1) + tdDnodes.start(1) + + tdSql.execute("use db") + + tdLog.printNoPrefix("==========step4:after wal, all check again ") + self.all_test() + + def stop(self): + tdSql.close() + tdLog.success(f"{__file__} successfully executed") + +tdCases.addLinux(__file__, TDTestCase()) +tdCases.addWindows(__file__, TDTestCase()) diff --git a/tests/system-test/2-query/histogram.py b/tests/system-test/2-query/histogram.py index c106d4d27c..09edabd45c 100644 --- a/tests/system-test/2-query/histogram.py +++ b/tests/system-test/2-query/histogram.py @@ -1,365 +1,3 @@ -# import datetime - -# from util.log import * -# from util.sql import * -# from util.cases import * -# from util.dnodes import * - -# PRIMARY_COL = "ts" - -# INT_COL = "c1" -# BINT_COL = "c2" -# SINT_COL = "c3" -# TINT_COL = "c4" -# FLOAT_COL = "c5" -# DOUBLE_COL = "c6" -# BOOL_COL = "c7" - -# BINARY_COL = "c8" -# NCHAR_COL = "c9" -# TS_COL = "c10" - -# NUM_COL = [ INT_COL, BINT_COL, SINT_COL, TINT_COL, FLOAT_COL, DOUBLE_COL, ] -# CHAR_COL = [ BINARY_COL, NCHAR_COL, ] -# BOOLEAN_COL = [ BOOL_COL, ] -# TS_TYPE_COL = [ TS_COL, ] - -# ALL_COL = [ INT_COL, BINT_COL, SINT_COL, TINT_COL, FLOAT_COL, DOUBLE_COL, BOOL_COL, BINARY_COL, NCHAR_COL, TS_COL ] - -# class TDTestCase: - -# def init(self, conn, logSql): -# tdLog.debug(f"start to excute {__file__}") -# tdSql.init(conn.cursor()) - -# def __query_condition(self,tbname): -# query_condition = [f"cast({col} as bigint)" for col in ALL_COL] -# for num_col in NUM_COL: -# query_condition.extend( -# ( -# f"{tbname}.{num_col}", -# f"abs( {tbname}.{num_col} )", -# f"acos( {tbname}.{num_col} )", -# f"asin( {tbname}.{num_col} )", -# f"atan( {tbname}.{num_col} )", -# f"avg( {tbname}.{num_col} )", -# f"ceil( {tbname}.{num_col} )", -# f"cos( {tbname}.{num_col} )", -# f"count( {tbname}.{num_col} )", -# f"floor( {tbname}.{num_col} )", -# f"log( {tbname}.{num_col}, {tbname}.{num_col})", -# f"max( {tbname}.{num_col} )", -# f"min( {tbname}.{num_col} )", -# f"pow( {tbname}.{num_col}, 2)", -# f"round( {tbname}.{num_col} )", -# f"sum( {tbname}.{num_col} )", -# f"sin( {tbname}.{num_col} )", -# f"sqrt( {tbname}.{num_col} )", -# f"tan( {tbname}.{num_col} )", -# f"cast( {tbname}.{num_col} as timestamp)", -# ) -# ) -# [ query_condition.append(f"{num_col} + {any_col}") for any_col in ALL_COL ] -# for char_col in CHAR_COL: -# query_condition.extend( -# ( -# f"count({tbname}.{char_col})", -# f"sum(cast({tbname}.{char_col}) as bigint)", -# f"max(cast({tbname}.{char_col}) as bigint)", -# f"min(cast({tbname}.{char_col}) as bigint)", -# f"avg(cast({tbname}.{char_col}) as bigint)", -# ) -# ) -# query_condition.extend( -# ( -# 1010, -# ) -# ) - -# return query_condition - -# def __join_condition(self, tb_list, filter=PRIMARY_COL, INNER=False): -# table_reference = tb_list[0] -# join_condition = table_reference -# join = "inner join" if INNER else "join" -# for i in range(len(tb_list[1:])): -# join_condition += f" {join} {tb_list[i+1]} on {table_reference}.{filter}={tb_list[i+1]}.{filter}" - -# return join_condition - -# def __where_condition(self, col=None, tbname=None, query_conditon=None): -# if query_conditon and isinstance(query_conditon, str): -# if query_conditon.startswith("count"): -# query_conditon = query_conditon[6:-1] -# elif query_conditon.startswith("max"): -# query_conditon = query_conditon[4:-1] -# elif query_conditon.startswith("sum"): -# query_conditon = query_conditon[4:-1] -# elif query_conditon.startswith("min"): -# query_conditon = query_conditon[4:-1] - -# if query_conditon: -# return f" where {query_conditon} is not null" -# if col in NUM_COL: -# return f" where abs( {tbname}.{col} ) >= 0" -# if col in CHAR_COL: -# return f" where lower( {tbname}.{col} ) like 'bina%' or lower( {tbname}.{col} ) like '_cha%' " -# if col in BOOLEAN_COL: -# return f" where {tbname}.{col} in (false, true) " -# if col in TS_TYPE_COL or col in PRIMARY_COL: -# return f" where cast( {tbname}.{col} as binary(16) ) is not null " - -# return "" - -# def __group_condition(self, col, having = None): -# if isinstance(col, str): -# if col.startswith("count"): -# col = col[6:-1] -# elif col.startswith("max"): -# col = col[4:-1] -# elif col.startswith("sum"): -# col = col[4:-1] -# elif col.startswith("min"): -# col = col[4:-1] -# return f" group by {col} having {having}" if having else f" group by {col} " - -# def __single_sql(self, select_clause, from_clause, where_condition="", group_condition=""): -# if isinstance(select_clause, str) and "on" not in from_clause and select_clause.split(".")[0] != from_clause.split(".")[0]: -# return -# return f"select spread({select_clause}) from {from_clause} {where_condition} {group_condition}" - -# @property -# def __tb_list(self): -# return [ -# "ct1", -# "ct4", -# "t1", -# "ct2", -# "stb1", -# ] - -# def sql_list(self): -# sqls = [] -# __no_join_tblist = self.__tb_list -# for tb in __no_join_tblist: -# select_claus_list = self.__query_condition(tb) -# for select_claus in select_claus_list: -# group_claus = self.__group_condition(col=select_claus) -# where_claus = self.__where_condition(query_conditon=select_claus) -# having_claus = self.__group_condition(col=select_claus, having=f"{select_claus} is not null") -# sqls.extend( -# ( -# self.__single_sql(select_claus, tb, where_claus, having_claus), -# self.__single_sql(select_claus, tb,), -# self.__single_sql(select_claus, tb, where_condition=where_claus), -# self.__single_sql(select_claus, tb, group_condition=group_claus), -# ) -# ) - -# # return filter(None, sqls) -# return list(filter(None, sqls)) - -# def __get_type(self, col): -# if tdSql.cursor.istype(col, "BOOL"): -# return "BOOL" -# if tdSql.cursor.istype(col, "INT"): -# return "INT" -# if tdSql.cursor.istype(col, "BIGINT"): -# return "BIGINT" -# if tdSql.cursor.istype(col, "TINYINT"): -# return "TINYINT" -# if tdSql.cursor.istype(col, "SMALLINT"): -# return "SMALLINT" -# if tdSql.cursor.istype(col, "FLOAT"): -# return "FLOAT" -# if tdSql.cursor.istype(col, "DOUBLE"): -# return "DOUBLE" -# if tdSql.cursor.istype(col, "BINARY"): -# return "BINARY" -# if tdSql.cursor.istype(col, "NCHAR"): -# return "NCHAR" -# if tdSql.cursor.istype(col, "TIMESTAMP"): -# return "TIMESTAMP" -# if tdSql.cursor.istype(col, "JSON"): -# return "JSON" -# if tdSql.cursor.istype(col, "TINYINT UNSIGNED"): -# return "TINYINT UNSIGNED" -# if tdSql.cursor.istype(col, "SMALLINT UNSIGNED"): -# return "SMALLINT UNSIGNED" -# if tdSql.cursor.istype(col, "INT UNSIGNED"): -# return "INT UNSIGNED" -# if tdSql.cursor.istype(col, "BIGINT UNSIGNED"): -# return "BIGINT UNSIGNED" - -# def spread_check(self): -# sqls = self.sql_list() -# tdLog.printNoPrefix("===step 1: curent case, must return query OK") -# for i in range(len(sqls)): -# tdLog.info(f"sql: {sqls[i]}") -# tdSql.query(sqls[i]) - -# def __test_current(self): -# tdSql.query("select spread(ts) from ct1") -# tdSql.checkRows(1) -# tdSql.query("select spread(c1) from ct2") -# tdSql.checkRows(1) -# tdSql.query("select spread(c1) from ct4 group by c1") -# tdSql.checkRows(self.rows + 3) -# tdSql.query("select spread(c1) from ct4 group by c7") -# tdSql.checkRows(3) -# tdSql.query("select spread(ct2.c1) from ct4 join ct2 on ct4.ts=ct2.ts") -# tdSql.checkRows(1) - -# self.spread_check() - -# def __test_error(self): - -# tdLog.printNoPrefix("===step 0: err case, must return err") -# tdSql.error( "select spread() from ct1" ) -# tdSql.error( "select spread(1, 2) from ct2" ) -# tdSql.error( f"select spread({NUM_COL[0]}, {NUM_COL[1]}) from ct4" ) -# tdSql.error( f"select spread({BOOLEAN_COL[0]}) from t1" ) -# tdSql.error( f"select spread({CHAR_COL[0]}) from stb1" ) - -# # tdSql.error( ''' select spread(['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10']) -# # from ct1 -# # where ['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'] is not null -# # group by ['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'] -# # having ['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'] is not null ''' ) -# # tdSql.error( "select c1 from ct1 union select c1 from ct2 union select c1 from ct4 ") - -# def all_test(self): -# self.__test_error() -# self.__test_current() - -# def __create_tb(self): - -# tdLog.printNoPrefix("==========step1:create table") -# create_stb_sql = f'''create table stb1( -# ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint, -# {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, -# {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp -# ) tags (t1 int) -# ''' -# create_ntb_sql = f'''create table t1( -# ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint, -# {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, -# {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp -# ) -# ''' -# tdSql.execute(create_stb_sql) -# tdSql.execute(create_ntb_sql) - -# for i in range(4): -# tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )') -# { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2} - -# def __insert_data(self, rows): -# now_time = int(datetime.datetime.timestamp(datetime.datetime.now()) * 1000) -# for i in range(rows): -# tdSql.execute( -# f"insert into ct1 values ( { now_time - i * 1000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" -# ) -# tdSql.execute( -# f"insert into ct4 values ( { now_time - i * 7776000000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" -# ) -# tdSql.execute( -# f"insert into ct2 values ( { now_time - i * 7776000000 }, {-i}, {-11111 * i}, {-111 * i % 32767 }, {-11 * i % 127}, {-1.11*i}, {-1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" -# ) -# tdSql.execute( -# f'''insert into ct1 values -# ( { now_time - rows * 5 }, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar_测试_0', { now_time + 8 } ) -# ( { now_time + 10000 }, { rows }, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar_测试_9', { now_time + 9 } ) -# ''' -# ) - -# tdSql.execute( -# f'''insert into ct4 values -# ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) -# ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) -# ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) -# ( -# { now_time + 5184000000}, {pow(2,31)-pow(2,15)}, {pow(2,63)-pow(2,30)}, 32767, 127, -# { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000} -# ) -# ( -# { now_time + 2592000000 }, {pow(2,31)-pow(2,16)}, {pow(2,63)-pow(2,31)}, 32766, 126, -# { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000} -# ) -# ''' -# ) - -# tdSql.execute( -# f'''insert into ct2 values -# ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) -# ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) -# ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) -# ( -# { now_time + 5184000000 }, { -1 * pow(2,31) + pow(2,15) }, { -1 * pow(2,63) + pow(2,30) }, -32766, -126, -# { -1 * 3.2 * pow(10,38) }, { -1.2 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 } -# ) -# ( -# { now_time + 2592000000 }, { -1 * pow(2,31) + pow(2,16) }, { -1 * pow(2,63) + pow(2,31) }, -32767, -127, -# { - 3.3 * pow(10,38) }, { -1.3 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 } -# ) -# ''' -# ) - -# for i in range(rows): -# insert_data = f'''insert into t1 values -# ( { now_time - i * 3600000 }, {i}, {i * 11111}, { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2}, -# "binary_{i}", "nchar_测试_{i}", { now_time - 1000 * i } ) -# ''' -# tdSql.execute(insert_data) -# tdSql.execute( -# f'''insert into t1 values -# ( { now_time + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) -# ( { now_time - (( rows // 2 ) * 60 + 30) * 60000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) -# ( { now_time - rows * 3600000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) -# ( { now_time + 7200000 }, { pow(2,31) - pow(2,15) }, { pow(2,63) - pow(2,30) }, 32767, 127, -# { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 }, -# "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 } -# ) -# ( -# { now_time + 3600000 } , { pow(2,31) - pow(2,16) }, { pow(2,63) - pow(2,31) }, 32766, 126, -# { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, -# "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 } -# ) -# ''' -# ) - - -# def run(self): -# tdSql.prepare() - -# tdLog.printNoPrefix("==========step1:create table") -# self.__create_tb() - -# tdLog.printNoPrefix("==========step2:insert data") -# self.rows = 10 -# self.__insert_data(self.rows) - -# tdLog.printNoPrefix("==========step3:all check") -# self.all_test() - -# tdDnodes.stop(1) -# tdDnodes.start(1) - -# tdSql.execute("use db") - -# tdLog.printNoPrefix("==========step4:after wal, all check again ") -# self.all_test() - -# def stop(self): -# tdSql.close() -# tdLog.success(f"{__file__} successfully executed") - -# tdCases.addLinux(__file__, TDTestCase()) -# tdCases.addWindows(__file__, TDTestCase()) - - - - ################################################################### # Copyright (c) 2021 by TAOS Technologies, Inc. @@ -532,21 +170,21 @@ class TDTestCase: tdSql.error('select histogram(tag_smallint, "user_input", "[1,3,5,7]", 0) from ctb;') tdSql.error('select histogram(tag_smallint, "user_input", "[1,3,5,7]", 0) from tb;') - tdSql.error('select histogram(tag_int, "user_input", "[1,3,5,7]", 0) from stb;') - tdSql.error('select histogram(tag_int, "user_input", "[1,3,5,7]", 0) from ctb;') - tdSql.error('select histogram(tag_int, "user_input", "[1,3,5,7]", 0) from tb;') + tdSql.query('select histogram(tag_int, "user_input", "[1,3,5,7]", 0) from stb;') + tdSql.query('select histogram(tag_int, "user_input", "[1,3,5,7]", 0) from ctb;') + tdSql.query('select histogram(tag_int, "user_input", "[1,3,5,7]", 0) from tb;') - tdSql.error('select histogram(tag_bigint, "user_input", "[1,3,5,7]", 0) from stb;') - tdSql.error('select histogram(tag_bigint, "user_input", "[1,3,5,7]", 0) from ctb;') - tdSql.error('select histogram(tag_bigint, "user_input", "[1,3,5,7]", 0) from tb;') + tdSql.query('select histogram(tag_bigint, "user_input", "[1,3,5,7]", 0) from stb;') + tdSql.query('select histogram(tag_bigint, "user_input", "[1,3,5,7]", 0) from ctb;') + tdSql.query('select histogram(tag_bigint, "user_input", "[1,3,5,7]", 0) from tb;') - tdSql.error('select histogram(tag_float, "user_input", "[1,3,5,7]", 0) from stb;') - tdSql.error('select histogram(tag_float, "user_input", "[1,3,5,7]", 0) from ctb;') - tdSql.error('select histogram(tag_float, "user_input", "[1,3,5,7]", 0) from tb;') + tdSql.query('select histogram(tag_float, "user_input", "[1,3,5,7]", 0) from stb;') + tdSql.query('select histogram(tag_float, "user_input", "[1,3,5,7]", 0) from ctb;') + tdSql.query('select histogram(tag_float, "user_input", "[1,3,5,7]", 0) from tb;') - tdSql.error('select histogram(tag_double, "user_input", "[1,3,5,7]", 0) from stb;') - tdSql.error('select histogram(tag_double, "user_input", "[1,3,5,7]", 0) from ctb;') - tdSql.error('select histogram(tag_double, "user_input", "[1,3,5,7]", 0) from tb;') + tdSql.query('select histogram(tag_double, "user_input", "[1,3,5,7]", 0) from stb;') + tdSql.query('select histogram(tag_double, "user_input", "[1,3,5,7]", 0) from ctb;') + tdSql.query('select histogram(tag_double, "user_input", "[1,3,5,7]", 0) from tb;') tdSql.error('select histogram(tag_bool, "user_input", "[1,3,5,7]", 0) from stb;') tdSql.error('select histogram(tag_bool, "user_input", "[1,3,5,7]", 0) from ctb;') From 10f5fd6c5ff13af6775c87bb17b680235f1b270e Mon Sep 17 00:00:00 2001 From: cpwu Date: Fri, 10 Jun 2022 17:27:42 +0800 Subject: [PATCH 13/34] fix case --- .../system-test/1-insert/create_retentions.py | 43 +++++++++++++------ 1 file changed, 29 insertions(+), 14 deletions(-) diff --git a/tests/system-test/1-insert/create_retentions.py b/tests/system-test/1-insert/create_retentions.py index a286625511..20f9ae73da 100644 --- a/tests/system-test/1-insert/create_retentions.py +++ b/tests/system-test/1-insert/create_retentions.py @@ -7,13 +7,17 @@ from util.dnodes import * PRIMARY_COL = "ts" -INT_COL = "c1" -BINT_COL = "c2" -SINT_COL = "c3" -TINT_COL = "c4" -FLOAT_COL = "c5" -DOUBLE_COL = "c6" -BOOL_COL = "c7" +INT_COL = "c_int" +BINT_COL = "c_bint" +SINT_COL = "c_sint" +TINT_COL = "c_tint" +FLOAT_COL = "c_float" +DOUBLE_COL = "c_double" +BOOL_COL = "c_bool" +TINT_UN_COL = "c_tint_un" +SINT_UN_COL = "c_sint_un" +BINT_UN_COL = "c_bint_un" +INT_UN_COL = "c_int_un" BINARY_COL = "c8" NCHAR_COL = "c9" @@ -56,11 +60,18 @@ class TDTestCase: @property def create_stable_sql_err(self): return [ - "create stable stb1 (ts timestamp, c1 int) tags (tag1 int) rollup(ceil) file_factor 0.1", + f"create stable stb1 (ts timestamp, {INT_COL} int) tags (tag1 int) rollup(ceil) file_factor 0.1", + f"create stable stb1 (ts timestamp, {INT_COL} int) tags (tag1 int) rollup(count) file_factor 0.1", + f"create stable stb2 (ts timestamp, {INT_COL} int, {BINARY_COL} binary(16)) tags (tag1 int) rollup(avg) file_factor 0.1", + f"create stable stb2 (ts timestamp, {INT_COL} int, {BINARY_COL} nchar(16)) tags (tag1 int) rollup(avg) file_factor 0.1", + ] + + @property + def create_stable_sql_err(self): + return [ + "create stable stb1 (ts timestamp, c1 int) tags (tag1 int) rollup(avg) file_factor 0.1", ] - def test_create_database(self): - pass def test_create_databases(self): for err_sql in self.create_databases_sql_err: @@ -80,14 +91,18 @@ class TDTestCase: tdLog.printNoPrefix("==========step1:create table") create_stb_sql = f'''create table stb1( ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint, - {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, - {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp + {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, + {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp, + {TINT_UN_COL} tinyint unsigned, {SINT_UN_COL} smallint unsigned, + {INT_UN_COL} int unsigned, {BINT_UN_COL} bigint unsigned, ) tags (t1 int) ''' create_ntb_sql = f'''create table t1( ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint, - {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, - {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp + {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, + {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp, + {TINT_UN_COL} tinyint unsigned, {SINT_UN_COL} smallint unsigned, + {INT_UN_COL} int unsigned, {BINT_UN_COL} bigint unsigned, ) ''' tdSql.execute(create_stb_sql) From 2273cbd22005c526f0a183caa3ae03cc75f2b20f Mon Sep 17 00:00:00 2001 From: cpwu Date: Fri, 10 Jun 2022 17:41:54 +0800 Subject: [PATCH 14/34] fix case --- tests/system-test/2-query/leastsquares.py | 25 +++++++++++------------ 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/tests/system-test/2-query/leastsquares.py b/tests/system-test/2-query/leastsquares.py index 775b624ee1..5d9857f224 100644 --- a/tests/system-test/2-query/leastsquares.py +++ b/tests/system-test/2-query/leastsquares.py @@ -231,25 +231,24 @@ class TDTestCase: def __test_current(self): - tdSql.query("explain select c1 from ct1") - tdSql.query("explain select 1 from ct2") - tdSql.query("explain select cast(ceil(c6) as bigint) from ct4 group by c6") - tdSql.query("explain select count(c3) from ct4 group by c7 having count(c3) > 0") - tdSql.query("explain select ct2.c3 from ct4 join ct2 on ct4.ts=ct2.ts") - tdSql.query("explain select c1 from stb1 where c1 is not null and c1 in (0, 1, 2) or c1 between 2 and 100 ") + # tdSql.query("explain select c1 from ct1") + # tdSql.query("explain select 1 from ct2") + # tdSql.query("explain select cast(ceil(c6) as bigint) from ct4 group by c6") + # tdSql.query("explain select count(c3) from ct4 group by c7 having count(c3) > 0") + # tdSql.query("explain select ct2.c3 from ct4 join ct2 on ct4.ts=ct2.ts") + # tdSql.query("explain select c1 from stb1 where c1 is not null and c1 in (0, 1, 2) or c1 between 2 and 100 ") self.leastsquares_check() def __test_error(self): tdLog.printNoPrefix("===step 0: err case, must return err") - tdSql.error( "explain select hyperloglog(c1) from ct8" ) - tdSql.error( "explain show databases " ) - tdSql.error( "explain show stables " ) - tdSql.error( "explain show tables " ) - tdSql.error( "explain show vgroups " ) - tdSql.error( "explain show dnodes " ) - tdSql.error( '''explain select hyperloglog(['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10']) + tdSql.error( "select leastsquares(c1) from ct8" ) + tdSql.error( "select leastsquares(c1, 1) from ct1 " ) + tdSql.error( "select leastsquares(c1, null, 1) from ct1 " ) + tdSql.error( "select leastsquares(c1, 1, null) from ct1 " ) + tdSql.error( "select leastsquares(null, 1, 1) from ct1 " ) + tdSql.error( '''select leastsquares(['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10']) from ct1 where ['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'] is not null group by ['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'] From df10e9ed5970fefe4342a715d8eafc7fec527449 Mon Sep 17 00:00:00 2001 From: cpwu Date: Fri, 10 Jun 2022 17:55:54 +0800 Subject: [PATCH 15/34] fix case --- tests/system-test/2-query/leastsquares.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/system-test/2-query/leastsquares.py b/tests/system-test/2-query/leastsquares.py index 5d9857f224..c49d35b417 100644 --- a/tests/system-test/2-query/leastsquares.py +++ b/tests/system-test/2-query/leastsquares.py @@ -127,7 +127,7 @@ class TDTestCase: col = col[4:-1] return f" group by {col} having {having}" if having else f" group by {col} " - def __single_sql(self, select_clause, from_clause, start_val=0, step_val=0, where_condition="", group_condition=""): + def __single_sql(self, select_clause, from_clause, start_val=None, step_val=None, where_condition="", group_condition=""): if isinstance(select_clause, str) and "on" not in from_clause and select_clause.split(".")[0].split("(")[-1] != from_clause.split(".")[0]: return return f"select leastsquares({select_clause}, {start_val}, {step_val}) from {from_clause} {where_condition} {group_condition}" @@ -178,8 +178,8 @@ class TDTestCase: else: current_sqls.extend( ( - self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg), - self.__single_sql(select_clause=select_claus, from_clause=tb, step_val=arg, group_condition=group_claus), + self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg, step_val=0), + self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=0, step_val=arg, group_condition=group_claus), self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg, step_val=arg, where_condition=where_claus, group_condition=having_claus), ) ) From 643ae76ecbc80c3e429493ee3e243b7b4703da45 Mon Sep 17 00:00:00 2001 From: cpwu Date: Fri, 10 Jun 2022 17:56:57 +0800 Subject: [PATCH 16/34] fix case --- tests/system-test/2-query/leastsquares.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/system-test/2-query/leastsquares.py b/tests/system-test/2-query/leastsquares.py index c49d35b417..8e7c475ea7 100644 --- a/tests/system-test/2-query/leastsquares.py +++ b/tests/system-test/2-query/leastsquares.py @@ -172,7 +172,7 @@ class TDTestCase: ( self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg), self.__single_sql(select_clause=select_claus, from_clause=tb, step_val=arg, group_condition=group_claus), - self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg, step_val=arg, where_condition=where_claus, group_condition=having_claus), + self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg, where_condition=where_claus, group_condition=having_claus), ) ) else: From 19ffe0ca81ad88f8ffe7626e8bad6b9ad8621f6e Mon Sep 17 00:00:00 2001 From: cpwu Date: Fri, 10 Jun 2022 18:08:52 +0800 Subject: [PATCH 17/34] fix case --- tests/system-test/2-query/leastsquares.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/system-test/2-query/leastsquares.py b/tests/system-test/2-query/leastsquares.py index 8e7c475ea7..ecdbecb526 100644 --- a/tests/system-test/2-query/leastsquares.py +++ b/tests/system-test/2-query/leastsquares.py @@ -167,7 +167,7 @@ class TDTestCase: where_claus = self.__where_condition(query_conditon=select_claus) having_claus = self.__group_condition(col=select_claus, having=f"{select_claus} is not null") for arg in self.start_step_val: - if not isinstance(arg,int): + if not isinstance(arg,int) or isinstance(arg, bool): err_sqls.extend( ( self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg), From f3d1ffa2952bb10188ff4ab4841200c2a4c0f33c Mon Sep 17 00:00:00 2001 From: cpwu Date: Fri, 10 Jun 2022 18:13:22 +0800 Subject: [PATCH 18/34] fix case --- tests/system-test/2-query/leastsquares.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/system-test/2-query/leastsquares.py b/tests/system-test/2-query/leastsquares.py index ecdbecb526..79c7d24410 100644 --- a/tests/system-test/2-query/leastsquares.py +++ b/tests/system-test/2-query/leastsquares.py @@ -167,7 +167,7 @@ class TDTestCase: where_claus = self.__where_condition(query_conditon=select_claus) having_claus = self.__group_condition(col=select_claus, having=f"{select_claus} is not null") for arg in self.start_step_val: - if not isinstance(arg,int) or isinstance(arg, bool): + if not isinstance(arg,int) or isinstance(arg, bool) or BOOL_COL in select_claus or BINARY_COL in select_claus or NCHAR_COL in select_claus or TS_COL in select_claus: err_sqls.extend( ( self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg), From 73ab3805cf5fccce555ffbd139064f5753c6a0aa Mon Sep 17 00:00:00 2001 From: cpwu Date: Fri, 10 Jun 2022 18:20:33 +0800 Subject: [PATCH 19/34] fix case --- tests/system-test/2-query/leastsquares.py | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/tests/system-test/2-query/leastsquares.py b/tests/system-test/2-query/leastsquares.py index 79c7d24410..35e765f186 100644 --- a/tests/system-test/2-query/leastsquares.py +++ b/tests/system-test/2-query/leastsquares.py @@ -167,7 +167,15 @@ class TDTestCase: where_claus = self.__where_condition(query_conditon=select_claus) having_claus = self.__group_condition(col=select_claus, having=f"{select_claus} is not null") for arg in self.start_step_val: - if not isinstance(arg,int) or isinstance(arg, bool) or BOOL_COL in select_claus or BINARY_COL in select_claus or NCHAR_COL in select_claus or TS_COL in select_claus: + if not isinstance(arg,int) or isinstance(arg, bool) : + err_sqls.extend( + ( + self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg), + self.__single_sql(select_clause=select_claus, from_clause=tb, step_val=arg, group_condition=group_claus), + self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg, where_condition=where_claus, group_condition=having_claus), + ) + ) + elif isinstance(select_claus, str) and any([BOOL_COL in select_claus, BINARY_COL in select_claus, NCHAR_COL in select_claus]): err_sqls.extend( ( self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg), From a158cc877f22bfb030c2886b98fb360b8c0abe7c Mon Sep 17 00:00:00 2001 From: cpwu Date: Fri, 10 Jun 2022 18:22:10 +0800 Subject: [PATCH 20/34] fix case --- tests/system-test/2-query/leastsquares.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/system-test/2-query/leastsquares.py b/tests/system-test/2-query/leastsquares.py index 35e765f186..e8fa32e8b3 100644 --- a/tests/system-test/2-query/leastsquares.py +++ b/tests/system-test/2-query/leastsquares.py @@ -175,7 +175,7 @@ class TDTestCase: self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg, where_condition=where_claus, group_condition=having_claus), ) ) - elif isinstance(select_claus, str) and any([BOOL_COL in select_claus, BINARY_COL in select_claus, NCHAR_COL in select_claus]): + elif isinstance(select_claus, str) and any([BOOL_COL in select_claus, BINARY_COL in select_claus, NCHAR_COL in select_claus, TS_COL in select_claus]): err_sqls.extend( ( self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg), From 26c6a115d33ee3be4c6b1a718ba950a275e50e05 Mon Sep 17 00:00:00 2001 From: cpwu Date: Fri, 10 Jun 2022 18:23:43 +0800 Subject: [PATCH 21/34] fix case --- tests/system-test/fulltest.sh | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/system-test/fulltest.sh b/tests/system-test/fulltest.sh index c383b33652..50c3259d68 100755 --- a/tests/system-test/fulltest.sh +++ b/tests/system-test/fulltest.sh @@ -44,6 +44,7 @@ python3 ./test.py -f 2-query/check_tsdb.py python3 ./test.py -f 2-query/spread.py python3 ./test.py -f 2-query/hyperloglog.py python3 ./test.py -f 2-query/explain.py +python3 ./test.py -f 2-query/leastsquares.py python3 ./test.py -f 2-query/timezone.py @@ -80,7 +81,7 @@ python3 ./test.py -f 2-query/arccos.py python3 ./test.py -f 2-query/arctan.py python3 ./test.py -f 2-query/query_cols_tags_and_or.py # python3 ./test.py -f 2-query/nestedQuery.py -# TD-15983 subquery output duplicate name column. +# TD-15983 subquery output duplicate name column. # Please Xiangyang Guo modify the following script # python3 ./test.py -f 2-query/nestedQuery_str.py From 478c43a98db1b57311649e308cdd715d64e27afe Mon Sep 17 00:00:00 2001 From: cpwu Date: Sat, 11 Jun 2022 17:09:31 +0800 Subject: [PATCH 22/34] Update hyperloglog.py --- tests/system-test/2-query/hyperloglog.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/system-test/2-query/hyperloglog.py b/tests/system-test/2-query/hyperloglog.py index 4b86da20ab..23bf02f795 100644 --- a/tests/system-test/2-query/hyperloglog.py +++ b/tests/system-test/2-query/hyperloglog.py @@ -178,7 +178,7 @@ class TDTestCase: tdLog.printNoPrefix("===step 0: err case, must return err") tdSql.error( "select hyperloglog() from ct1" ) tdSql.error( "select hyperloglog(c1, c2) from ct2" ) - tdSql.error( "select hyperloglog(1) from stb1" ) + # tdSql.error( "select hyperloglog(1) from stb1" ) tdSql.error( "select hyperloglog(abs(c1)) from ct4" ) tdSql.error( "select hyperloglog(count(c1)) from t1" ) # tdSql.error( "select hyperloglog(1) from ct2" ) From a0d2cb853f0bd85220629117c481706a51a56e13 Mon Sep 17 00:00:00 2001 From: cpwu Date: Sat, 11 Jun 2022 20:38:06 +0800 Subject: [PATCH 23/34] Update hyperloglog.py --- tests/system-test/2-query/hyperloglog.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/system-test/2-query/hyperloglog.py b/tests/system-test/2-query/hyperloglog.py index 23bf02f795..337db140a1 100644 --- a/tests/system-test/2-query/hyperloglog.py +++ b/tests/system-test/2-query/hyperloglog.py @@ -179,7 +179,7 @@ class TDTestCase: tdSql.error( "select hyperloglog() from ct1" ) tdSql.error( "select hyperloglog(c1, c2) from ct2" ) # tdSql.error( "select hyperloglog(1) from stb1" ) - tdSql.error( "select hyperloglog(abs(c1)) from ct4" ) + # tdSql.error( "select hyperloglog(abs(c1)) from ct4" ) tdSql.error( "select hyperloglog(count(c1)) from t1" ) # tdSql.error( "select hyperloglog(1) from ct2" ) tdSql.error( f"select hyperloglog({NUM_COL[0]}, {NUM_COL[1]}) from ct4" ) From 82dda9a50625250201e24f4c6335388161fcc2ca Mon Sep 17 00:00:00 2001 From: cpwu Date: Sat, 11 Jun 2022 20:41:45 +0800 Subject: [PATCH 24/34] Update explain.py --- tests/system-test/2-query/explain.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/system-test/2-query/explain.py b/tests/system-test/2-query/explain.py index d440144841..dfe9d800bc 100644 --- a/tests/system-test/2-query/explain.py +++ b/tests/system-test/2-query/explain.py @@ -150,7 +150,7 @@ class TDTestCase: for select_claus in select_claus_list: group_claus = self.__group_condition(col=select_claus) where_claus = self.__where_condition(query_conditon=select_claus) - having_claus = self.__group_condition(col=select_claus, having=f"{select_claus} is not null") + having_claus = self.__group_condition(col=select_claus, having=f"{group_claus} is not null") sqls.extend( ( self.__single_sql(select_claus, tb, where_claus, having_claus), From abc3a3c1aeb633d2bcf39cc8ef5be44a69a2ee2e Mon Sep 17 00:00:00 2001 From: cpwu Date: Mon, 13 Jun 2022 09:54:39 +0800 Subject: [PATCH 25/34] fix case --- tests/system-test/2-query/explain.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/system-test/2-query/explain.py b/tests/system-test/2-query/explain.py index dfe9d800bc..d440144841 100644 --- a/tests/system-test/2-query/explain.py +++ b/tests/system-test/2-query/explain.py @@ -150,7 +150,7 @@ class TDTestCase: for select_claus in select_claus_list: group_claus = self.__group_condition(col=select_claus) where_claus = self.__where_condition(query_conditon=select_claus) - having_claus = self.__group_condition(col=select_claus, having=f"{group_claus} is not null") + having_claus = self.__group_condition(col=select_claus, having=f"{select_claus} is not null") sqls.extend( ( self.__single_sql(select_claus, tb, where_claus, having_claus), From fc5f9634a80935e5f08f658db605d28c3f286f46 Mon Sep 17 00:00:00 2001 From: cpwu Date: Mon, 13 Jun 2022 14:41:59 +0800 Subject: [PATCH 26/34] fix case --- .../system-test/1-insert/create_retentions.py | 68 ++++++++++--------- 1 file changed, 37 insertions(+), 31 deletions(-) diff --git a/tests/system-test/1-insert/create_retentions.py b/tests/system-test/1-insert/create_retentions.py index 20f9ae73da..25e2faa016 100644 --- a/tests/system-test/1-insert/create_retentions.py +++ b/tests/system-test/1-insert/create_retentions.py @@ -60,16 +60,16 @@ class TDTestCase: @property def create_stable_sql_err(self): return [ - f"create stable stb1 (ts timestamp, {INT_COL} int) tags (tag1 int) rollup(ceil) file_factor 0.1", - f"create stable stb1 (ts timestamp, {INT_COL} int) tags (tag1 int) rollup(count) file_factor 0.1", - f"create stable stb2 (ts timestamp, {INT_COL} int, {BINARY_COL} binary(16)) tags (tag1 int) rollup(avg) file_factor 0.1", - f"create stable stb2 (ts timestamp, {INT_COL} int, {BINARY_COL} nchar(16)) tags (tag1 int) rollup(avg) file_factor 0.1", + f"create stable stb1 ({PRIMARY_COL} timestamp, {INT_COL} int) tags (tag1 int) rollup(ceil) delay 1", + f"create stable stb1 ({PRIMARY_COL} timestamp, {INT_COL} int) tags (tag1 int) rollup(count) delay 1", + f"create stable stb2 ({PRIMARY_COL} timestamp, {INT_COL} int, {BINARY_COL} binary(16)) tags (tag1 int) rollup(avg) delay 1", + f"create stable stb2 ({PRIMARY_COL} timestamp, {INT_COL} int, {BINARY_COL} nchar(16)) tags (tag1 int) rollup(avg) delay 1", ] @property def create_stable_sql_err(self): return [ - "create stable stb1 (ts timestamp, c1 int) tags (tag1 int) rollup(avg) file_factor 0.1", + f"create stable stb1 ({PRIMARY_COL} timestamp, {INT_COL} int) tags (tag1 int) rollup(avg) delay 5", ] @@ -110,55 +110,62 @@ class TDTestCase: for i in range(4): tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )') - { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2} def __insert_data(self, rows): now_time = int(datetime.datetime.timestamp(datetime.datetime.now()) * 1000) for i in range(rows): tdSql.execute( - f"insert into ct1 values ( { now_time - i * 1000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" + f'''insert into ct1 values ( + { now_time - i * 1000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, + {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i }, {11 * i % 127}, {111 * i % 32767}, {i}, {11111 * i},)''' ) tdSql.execute( - f"insert into ct4 values ( { now_time - i * 7776000000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" + f'''insert into ct4 values ( + { now_time - i * 7776000000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, + {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i }, {11 * i % 127}, {111 * i % 32767}, {i}, {11111 * i}, )''' ) tdSql.execute( - f"insert into ct2 values ( { now_time - i * 7776000000 }, {-i}, {-11111 * i}, {-111 * i % 32767 }, {-11 * i % 127}, {-1.11*i}, {-1100.0011*i}, {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i } )" + f'''insert into ct2 values ( + { now_time - i * 7776000000 }, {-i}, {-11111 * i}, {-111 * i % 32767 }, {-11 * i % 127}, {-1.11*i}, {-1100.0011*i}, + {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i }, {11 * i % 127}, {111 * i % 32767}, {i}, {11111 * i} )''' ) tdSql.execute( f'''insert into ct1 values - ( { now_time - rows * 5 }, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar_测试_0', { now_time + 8 } ) - ( { now_time + 10000 }, { rows }, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar_测试_9', { now_time + 9 } ) + ( { now_time - rows * 5 }, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar_测试_0', { now_time + 8 }, 0, 0, 0, 0, ) + ( { now_time + 10000 }, { rows }, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar_测试_9', { now_time + 9 }, 0, 0, 0, 0, ) ''' ) tdSql.execute( f'''insert into ct4 values - ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) - ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) - ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ( { now_time + 5184000000}, {pow(2,31)-pow(2,15)}, {pow(2,63)-pow(2,30)}, 32767, 127, - { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000} + { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000}, + 254, 65534, {pow(2,63)-pow(2,15)}, {pow(2,127)-pow(2,30)}, ) ( { now_time + 2592000000 }, {pow(2,31)-pow(2,16)}, {pow(2,63)-pow(2,31)}, 32766, 126, - { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000} + { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000}, + 255, 65535, {pow(2,63)-pow(2,30)}, {pow(2,127)-pow(2,60)}, ) ''' ) tdSql.execute( f'''insert into ct2 values - ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) - ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) - ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time - rows * 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time - rows * 3888000000 + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ( - { now_time + 5184000000 }, { -1 * pow(2,31) + pow(2,15) }, { -1 * pow(2,63) + pow(2,30) }, -32766, -126, - { -1 * 3.2 * pow(10,38) }, { -1.2 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 } + { now_time + 5184000000 }, { -1 * pow(2,31) + pow(2,15) }, { -1 * pow(2,63) + pow(2,30) }, -32766, -126, { -1 * 3.2 * pow(10,38) }, + { -1.2 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 }, 1, 1, 1, 1, ) ( - { now_time + 2592000000 }, { -1 * pow(2,31) + pow(2,16) }, { -1 * pow(2,63) + pow(2,31) }, -32767, -127, - { - 3.3 * pow(10,38) }, { -1.3 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 } + { now_time + 2592000000 }, { -1 * pow(2,31) + pow(2,16) }, { -1 * pow(2,63) + pow(2,31) }, -32767, -127, { - 3.3 * pow(10,38) }, + { -1.3 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 }, 1, 1, 1, 1, ) ''' ) @@ -166,18 +173,17 @@ class TDTestCase: for i in range(rows): insert_data = f'''insert into t1 values ( { now_time - i * 3600000 }, {i}, {i * 11111}, { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2}, - "binary_{i}", "nchar_测试_{i}", { now_time - 1000 * i } ) + "binary_{i}", "nchar_测试_{i}", { now_time - 1000 * i }, {i % 127}, {i % 32767}, {i}, {i * 11111}) ''' tdSql.execute(insert_data) tdSql.execute( f'''insert into t1 values - ( { now_time + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) - ( { now_time - (( rows // 2 ) * 60 + 30) * 60000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) - ( { now_time - rows * 3600000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) - ( { now_time + 7200000 }, { pow(2,31) - pow(2,15) }, { pow(2,63) - pow(2,30) }, 32767, 127, - { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 }, - "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 } - ) + ( { now_time + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time - (( rows // 2 ) * 60 + 30) * 60000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) + ( { now_time - rows * 3600000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) + ( { now_time + 7200000 }, { pow(2,31) - pow(2,15) }, { pow(2,63) - pow(2,30) }, 32767, 127, { 3.3 * pow(10,38) }, + { 1.3 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 }, 254, 65534, + ) ( { now_time + 3600000 } , { pow(2,31) - pow(2,16) }, { pow(2,63) - pow(2,31) }, 32766, 126, { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, From 34c70764db40c99da7b4b530d2c7f742bb3e1e65 Mon Sep 17 00:00:00 2001 From: cpwu Date: Mon, 13 Jun 2022 14:42:05 +0800 Subject: [PATCH 27/34] fix case --- tests/system-test/1-insert/create_retentions.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/tests/system-test/1-insert/create_retentions.py b/tests/system-test/1-insert/create_retentions.py index 25e2faa016..9a3c3736f0 100644 --- a/tests/system-test/1-insert/create_retentions.py +++ b/tests/system-test/1-insert/create_retentions.py @@ -181,13 +181,14 @@ class TDTestCase: ( { now_time + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ( { now_time - (( rows // 2 ) * 60 + 30) * 60000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) ( { now_time - rows * 3600000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) - ( { now_time + 7200000 }, { pow(2,31) - pow(2,15) }, { pow(2,63) - pow(2,30) }, 32767, 127, { 3.3 * pow(10,38) }, - { 1.3 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 }, 254, 65534, - ) ( - { now_time + 3600000 } , { pow(2,31) - pow(2,16) }, { pow(2,63) - pow(2,31) }, 32766, 126, - { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, - "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 } + { now_time + 7200000 }, { pow(2,31) - pow(2,15) }, { pow(2,63) - pow(2,30) }, 32767, 127, { 3.3 * pow(10,38) }, + { 1.3 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 }, + 254, 65534, {pow(2,63)-pow(2,15)}, {pow(2,127)-pow(2,30)}, + ( + { now_time + 3600000 } , { pow(2,31) - pow(2,16) }, { pow(2,63) - pow(2,31) }, 32766, 126, { 3.2 * pow(10,38) }, + { 1.2 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 }, + 255, 65535, {pow(2,63)-pow(2,30)}, {pow(2,127)-pow(2,60)}, ) ''' ) From 97b8714461f1821e7fa4057aa5a62a704ccfb05b Mon Sep 17 00:00:00 2001 From: cpwu Date: Mon, 13 Jun 2022 14:51:38 +0800 Subject: [PATCH 28/34] fix case --- .../system-test/1-insert/create_retentions.py | 22 +++++++++---------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/tests/system-test/1-insert/create_retentions.py b/tests/system-test/1-insert/create_retentions.py index 9a3c3736f0..ef59b3f9fc 100644 --- a/tests/system-test/1-insert/create_retentions.py +++ b/tests/system-test/1-insert/create_retentions.py @@ -94,7 +94,7 @@ class TDTestCase: {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp, {TINT_UN_COL} tinyint unsigned, {SINT_UN_COL} smallint unsigned, - {INT_UN_COL} int unsigned, {BINT_UN_COL} bigint unsigned, + {INT_UN_COL} int unsigned, {BINT_UN_COL} bigint unsigned ) tags (t1 int) ''' create_ntb_sql = f'''create table t1( @@ -102,7 +102,7 @@ class TDTestCase: {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp, {TINT_UN_COL} tinyint unsigned, {SINT_UN_COL} smallint unsigned, - {INT_UN_COL} int unsigned, {BINT_UN_COL} bigint unsigned, + {INT_UN_COL} int unsigned, {BINT_UN_COL} bigint unsigned ) ''' tdSql.execute(create_stb_sql) @@ -117,12 +117,12 @@ class TDTestCase: tdSql.execute( f'''insert into ct1 values ( { now_time - i * 1000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, - {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i }, {11 * i % 127}, {111 * i % 32767}, {i}, {11111 * i},)''' + {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i }, {11 * i % 127}, {111 * i % 32767}, {i}, {11111 * i} )''' ) tdSql.execute( f'''insert into ct4 values ( { now_time - i * 7776000000 }, {i}, {11111 * i}, {111 * i % 32767 }, {11 * i % 127}, {1.11*i}, {1100.0011*i}, - {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i }, {11 * i % 127}, {111 * i % 32767}, {i}, {11111 * i}, )''' + {i%2}, 'binary{i}', 'nchar_测试_{i}', { now_time + 1 * i }, {11 * i % 127}, {111 * i % 32767}, {i}, {11111 * i} )''' ) tdSql.execute( f'''insert into ct2 values ( @@ -132,7 +132,7 @@ class TDTestCase: tdSql.execute( f'''insert into ct1 values ( { now_time - rows * 5 }, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar_测试_0', { now_time + 8 }, 0, 0, 0, 0, ) - ( { now_time + 10000 }, { rows }, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar_测试_9', { now_time + 9 }, 0, 0, 0, 0, ) + ( { now_time + 10000 }, { rows }, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar_测试_9', { now_time + 9 }, 0, 0, 0, 0 ) ''' ) @@ -144,12 +144,12 @@ class TDTestCase: ( { now_time + 5184000000}, {pow(2,31)-pow(2,15)}, {pow(2,63)-pow(2,30)}, 32767, 127, { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000}, - 254, 65534, {pow(2,63)-pow(2,15)}, {pow(2,127)-pow(2,30)}, + 254, 65534, {pow(2,63)-pow(2,15)}, {pow(2,127)-pow(2,30)} ) ( { now_time + 2592000000 }, {pow(2,31)-pow(2,16)}, {pow(2,63)-pow(2,31)}, 32766, 126, { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000}, - 255, 65535, {pow(2,63)-pow(2,30)}, {pow(2,127)-pow(2,60)}, + 255, 65535, {pow(2,63)-pow(2,30)}, {pow(2,127)-pow(2,60)} ) ''' ) @@ -161,11 +161,11 @@ class TDTestCase: ( { now_time + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ( { now_time + 5184000000 }, { -1 * pow(2,31) + pow(2,15) }, { -1 * pow(2,63) + pow(2,30) }, -32766, -126, { -1 * 3.2 * pow(10,38) }, - { -1.2 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 }, 1, 1, 1, 1, + { -1.2 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 }, 1, 1, 1, 1 ) ( { now_time + 2592000000 }, { -1 * pow(2,31) + pow(2,16) }, { -1 * pow(2,63) + pow(2,31) }, -32767, -127, { - 3.3 * pow(10,38) }, - { -1.3 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 }, 1, 1, 1, 1, + { -1.3 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 }, 1, 1, 1, 1 ) ''' ) @@ -184,11 +184,11 @@ class TDTestCase: ( { now_time + 7200000 }, { pow(2,31) - pow(2,15) }, { pow(2,63) - pow(2,30) }, 32767, 127, { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 }, - 254, 65534, {pow(2,63)-pow(2,15)}, {pow(2,127)-pow(2,30)}, + 254, 65534, {pow(2,63)-pow(2,15)}, {pow(2,127)-pow(2,30)} ( { now_time + 3600000 } , { pow(2,31) - pow(2,16) }, { pow(2,63) - pow(2,31) }, 32766, 126, { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 }, - 255, 65535, {pow(2,63)-pow(2,30)}, {pow(2,127)-pow(2,60)}, + 255, 65535, {pow(2,63)-pow(2,30)}, {pow(2,127)-pow(2,60)} ) ''' ) From 869f184adb0944ce095119d24dad1e388be94e4a Mon Sep 17 00:00:00 2001 From: cpwu Date: Mon, 13 Jun 2022 15:41:46 +0800 Subject: [PATCH 29/34] fix case --- tests/system-test/1-insert/create_retentions.py | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/tests/system-test/1-insert/create_retentions.py b/tests/system-test/1-insert/create_retentions.py index ef59b3f9fc..9e6d4be75d 100644 --- a/tests/system-test/1-insert/create_retentions.py +++ b/tests/system-test/1-insert/create_retentions.py @@ -1,4 +1,5 @@ import datetime +from turtle import pos from util.log import * from util.sql import * @@ -111,6 +112,15 @@ class TDTestCase: for i in range(4): tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )') + def __create_data_set(self, rows): + pos_data = [] + neg_data = [] + spec_data = [] + for i in range(rows): + pos_data.append() + + + pass def __insert_data(self, rows): now_time = int(datetime.datetime.timestamp(datetime.datetime.now()) * 1000) for i in range(rows): @@ -131,7 +141,7 @@ class TDTestCase: ) tdSql.execute( f'''insert into ct1 values - ( { now_time - rows * 5 }, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar_测试_0', { now_time + 8 }, 0, 0, 0, 0, ) + ( { now_time - rows * 5 }, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar_测试_0', { now_time + 8 }, 0, 0, 0, 0) ( { now_time + 10000 }, { rows }, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar_测试_9', { now_time + 9 }, 0, 0, 0, 0 ) ''' ) From b0623b84be298845a82c8c39c5ec75f86ed132bf Mon Sep 17 00:00:00 2001 From: cpwu Date: Mon, 13 Jun 2022 15:54:06 +0800 Subject: [PATCH 30/34] fix case --- tests/system-test/1-insert/create_retentions.py | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/tests/system-test/1-insert/create_retentions.py b/tests/system-test/1-insert/create_retentions.py index 9e6d4be75d..bdd752988e 100644 --- a/tests/system-test/1-insert/create_retentions.py +++ b/tests/system-test/1-insert/create_retentions.py @@ -113,14 +113,24 @@ class TDTestCase: tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )') def __create_data_set(self, rows): + now_time = int(datetime.datetime.timestamp(datetime.datetime.now()) * 1000) pos_data = [] neg_data = [] spec_data = [] for i in range(rows): - pos_data.append() + pos_data.append( + ( + now_time - i * 1000, i, 11111 * i, 111 * i % 32767 , 11 * i % 127, 1.11 * i, 1100.0011 * i, + i % 2, f'binary{i}', f'nchar_测试_{i}', now_time + 1 * i, 11 * i % 127, 111 * i % 32767, i, 11111 * i + ) + ) + neg_data.append( + ( + now_time - i * 7776000000, -i, -11111 * i, -111 * i % 32767, -11 * i % 127, -1.11 * i, -1100.0011 * i, + i % 2, f'binary{i}', f'nchar_测试_{i}', now_time + 1 * i, 11 * i % 127, 111 * i % 32767, i, 11111 * i + ) + ) - - pass def __insert_data(self, rows): now_time = int(datetime.datetime.timestamp(datetime.datetime.now()) * 1000) for i in range(rows): From 32c0c105eae72f2867ad36be3fac6f067fae5127 Mon Sep 17 00:00:00 2001 From: cpwu Date: Mon, 13 Jun 2022 16:29:29 +0800 Subject: [PATCH 31/34] fix case --- tests/system-test/1-insert/create_retentions.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/tests/system-test/1-insert/create_retentions.py b/tests/system-test/1-insert/create_retentions.py index bdd752988e..80cedba9da 100644 --- a/tests/system-test/1-insert/create_retentions.py +++ b/tests/system-test/1-insert/create_retentions.py @@ -1,5 +1,4 @@ import datetime -from turtle import pos from util.log import * from util.sql import * @@ -164,12 +163,12 @@ class TDTestCase: ( { now_time + 5184000000}, {pow(2,31)-pow(2,15)}, {pow(2,63)-pow(2,30)}, 32767, 127, { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000}, - 254, 65534, {pow(2,63)-pow(2,15)}, {pow(2,127)-pow(2,30)} + 254, 65534, {pow(2,32)-pow(2,16)}, {pow(2,64)-pow(2,31)} ) ( { now_time + 2592000000 }, {pow(2,31)-pow(2,16)}, {pow(2,63)-pow(2,31)}, 32766, 126, { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000}, - 255, 65535, {pow(2,63)-pow(2,30)}, {pow(2,127)-pow(2,60)} + 255, 65535, {pow(2,32)-pow(2,15)}, {pow(2,64)-pow(2,30)} ) ''' ) @@ -204,11 +203,11 @@ class TDTestCase: ( { now_time + 7200000 }, { pow(2,31) - pow(2,15) }, { pow(2,63) - pow(2,30) }, 32767, 127, { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 }, - 254, 65534, {pow(2,63)-pow(2,15)}, {pow(2,127)-pow(2,30)} + 254, 65534, {pow(2,32)-pow(2,16)}, {pow(2,64)-pow(2,31)} ( { now_time + 3600000 } , { pow(2,31) - pow(2,16) }, { pow(2,63) - pow(2,31) }, 32766, 126, { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 }, - 255, 65535, {pow(2,63)-pow(2,30)}, {pow(2,127)-pow(2,60)} + 255, 65535, {pow(2,32)-pow(2,15)}, {pow(2,64)-pow(2,30)} ) ''' ) From 3479818d44153f69eef1bc11a2044f902f9f3847 Mon Sep 17 00:00:00 2001 From: cpwu Date: Mon, 13 Jun 2022 16:32:19 +0800 Subject: [PATCH 32/34] fix case --- tests/system-test/1-insert/create_retentions.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/system-test/1-insert/create_retentions.py b/tests/system-test/1-insert/create_retentions.py index 80cedba9da..3026627f1c 100644 --- a/tests/system-test/1-insert/create_retentions.py +++ b/tests/system-test/1-insert/create_retentions.py @@ -204,6 +204,7 @@ class TDTestCase: { now_time + 7200000 }, { pow(2,31) - pow(2,15) }, { pow(2,63) - pow(2,30) }, 32767, 127, { 3.3 * pow(10,38) }, { 1.3 * pow(10,308) }, { rows % 2 }, "binary_limit-1", "nchar_测试_limit-1", { now_time - 86400000 }, 254, 65534, {pow(2,32)-pow(2,16)}, {pow(2,64)-pow(2,31)} + ) ( { now_time + 3600000 } , { pow(2,31) - pow(2,16) }, { pow(2,63) - pow(2,31) }, 32766, 126, { 3.2 * pow(10,38) }, { 1.2 * pow(10,308) }, { (rows-1) % 2 }, "binary_limit-2", "nchar_测试_limit-2", { now_time - 172800000 }, From da49426887f6a7f2d71295598091db50b5b9fdf8 Mon Sep 17 00:00:00 2001 From: cpwu Date: Mon, 13 Jun 2022 16:35:09 +0800 Subject: [PATCH 33/34] fix case --- tests/system-test/1-insert/create_retentions.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/system-test/1-insert/create_retentions.py b/tests/system-test/1-insert/create_retentions.py index 3026627f1c..bde499d91a 100644 --- a/tests/system-test/1-insert/create_retentions.py +++ b/tests/system-test/1-insert/create_retentions.py @@ -226,6 +226,8 @@ class TDTestCase: tdLog.printNoPrefix("==========step3:all check") self.all_test() + tdSql.execute("drop database if exists db1 ") + tdSql.execute("drop database if exists db2 ") tdDnodes.stop(1) tdDnodes.start(1) From ae0b4c0426b96480b0cd16dded13fdfdb6fcc0be Mon Sep 17 00:00:00 2001 From: cpwu Date: Mon, 13 Jun 2022 18:20:11 +0800 Subject: [PATCH 34/34] fix case --- tests/system-test/1-insert/create_retentions.py | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/tests/system-test/1-insert/create_retentions.py b/tests/system-test/1-insert/create_retentions.py index bde499d91a..313c643822 100644 --- a/tests/system-test/1-insert/create_retentions.py +++ b/tests/system-test/1-insert/create_retentions.py @@ -67,11 +67,19 @@ class TDTestCase: ] @property - def create_stable_sql_err(self): + def create_stable_sql_current(self): return [ f"create stable stb1 ({PRIMARY_COL} timestamp, {INT_COL} int) tags (tag1 int) rollup(avg) delay 5", ] + def test_create_stb(self): + tdSql.execute("use db2") + for err_sql in self.create_stable_sql_err: + tdSql.error(err_sql) + for cur_sql in self.create_stable_sql_current: + tdSql.execute(cur_sql) + tdSql.query("show stables") + tdSql.checkRows(len(self.create_stable_sql_current)) def test_create_databases(self): for err_sql in self.create_databases_sql_err: @@ -84,6 +92,7 @@ class TDTestCase: def all_test(self): self.test_create_databases() + self.test_create_stb() def __create_tb(self): tdSql.prepare()