Skip to content

T
TDengine

taosdata / TDengine
1 年多 前同步成功

通知 1185
Star 22016
Fork 4786
T
TDengine
未验证 提交 1838b1ff 编写于 作者: H Hui Li 提交者： GitHub
浏览文件
操作

Merge pull request #8776 from taosdata/cpwu/test 

[TD-10461]<test> add case for csum/mavg functions
上级 513cf9e8 355f18e6
显示空白变更内容
内联 并排
Showing with 1856 addition and 0 deletion
src/client/src/tscGlobalmerge.c
浏览文件 @ 1838b1ff
......@@ -364,7 +364,9 @@ static int32_t createOrderDescriptor(tOrderDescriptor **pOrderDesc, SQueryInfo*
SExprInfo* pExprInfo = tscExprGet(pQueryInfo, j);
int32_t functionId = pExprInfo->base.functionId;
if (pColIndex->colId == pExprInfo->base.colInfo.colId && (functionId == TSDB_FUNC_PRJ || functionId == TSDB_FUNC_TAG || functionId == TSDB_FUNC_TAGPRJ)) {
orderColIndexList[i] = j;
break;
}
......
tests/pytest/fulltest.sh
浏览文件 @ 1838b1ff
......@@ -371,6 +371,8 @@ python3 ./test.py -f functions/function_irate.py
python3 ./test.py -f functions/function_ceil.py
python3 ./test.py -f functions/function_floor.py
python3 ./test.py -f functions/function_round.py
python3 ./test.py -f functions/function_mavg.py
python3 ./test.py -f functions/function_csum.py
python3 ./test.py -f insert/unsignedInt.py
python3 ./test.py -f insert/unsignedBigint.py
......
tests/pytest/functions/function_all_sample.py 0 → 100644
浏览文件 @ 1838b1ff
###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved.
#
# This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao
#
###################################################################
# -*- coding: utf-8 -*-
import sys
import subprocess
import random
import math
import numpy as np
import inspect
import re
import taos
from util.log import *
from util.cases import *
from util.sql import *
from util.dnodes import *
class TDTestCase:
def init(self, conn, logSql):
tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor())
def sample_query_form(self, sel="select", func="sample(", col="c1", m_comm =",", k=1,r_comm=")", alias="", fr="from",table_expr="t1", condition=""):
'''
sample function:
:param sel: string, must be "select", required parameters;
:param func: string, in this case must be "sample(", otherwise return other function, required parameters;
:param col: string, column name, required parameters;
:param m_comm: string, comma between col and k , required parameters;
:param k: int/float，the width of the sliding window, [1,100], required parameters;
:param r_comm: string, must be ")", use with "(" in func, required parameters;
:param alias: string, result column another name，or add other funtion;
:param fr: string, must be "from", required parameters;
:param table_expr: string or expression, data source（eg,table/stable name, result set）, required parameters;
:param condition: expression；
:return: sample query statement,default: select sample(c1, 1) from t1
'''
return f"{sel} {func} {col} {m_comm} {k} {r_comm} {alias} {fr} {table_expr} {condition}"
def checksample(self,sel="select", func="sample(", col="c1", m_comm =",", k=1,r_comm=")", alias="", fr="from",table_expr="t1", condition=""):
# print(self.sample_query_form(sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
# table_expr=table_expr, condition=condition))
line = sys._getframe().f_back.f_lineno
if not all([sel , func , col , m_comm , k , r_comm , fr , table_expr]):
print(f"case in {line}: ", end='')
return tdSql.error(self.sample_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
sql = "select * from t1"
collist = tdSql.getColNameList(sql)
if not isinstance(col, str):
print(f"case in {line}: ", end='')
return tdSql.error(self.sample_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
if len([x for x in col.split(",") if x.strip()]) != 1:
print(f"case in {line}: ", end='')
return tdSql.error(self.sample_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
col = col.replace(",", "").replace(" ","")
if any([re.compile('^[a-zA-Z]{1}.*$').match(col) is None , not col.replace(".","").isalnum()]):
print(f"case in {line}: ", end='')
return tdSql.error(self.sample_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
if '.' in col:
if any([col.split(".")[0] not in table_expr, col.split(".")[1] not in collist]):
print(f"case in {line}: ", end='')
return tdSql.error(self.sample_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
pass
if "." not in col:
if col not in collist:
print(f"case in {line}: ", end='')
return tdSql.error(self.sample_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
pass
# colname = col if "." not in col else col.split(".")[1]
# col_index = collist.index(colname)
# if any([tdSql.cursor.istype(col_index, "TIMESTAMP"), tdSql.cursor.istype(col_index, "BOOL")]):
# print(f"case in {line}: ", end='')
# return tdSql.error(self.sample_query_form(
# sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
# table_expr=table_expr, condition=condition
# ))
#
# if any([tdSql.cursor.istype(col_index, "BINARY") , tdSql.cursor.istype(col_index,"NCHAR")]):
# print(f"case in {line}: ", end='')
# return tdSql.error(self.sample_query_form(
# sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
# table_expr=table_expr, condition=condition
# ))
if any( [func != "sample(" , r_comm != ")" , fr != "from", sel != "select"]):
print(f"case in {line}: ", end='')
return tdSql.error(self.sample_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
if all(["(" not in table_expr, "stb" in table_expr, "group" not in condition.lower()]):
print(f"case in {line}: ", end='')
return tdSql.error(self.sample_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
if all(["group" in condition.lower(), "tbname" not in condition.lower()]):
print(f"case in {line}: ", end='')
return tdSql.error(self.sample_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
alias_list = ["tbname", "_c0", "st", "ts"]
if all([alias, "," not in alias]):
if any([ not alias.isalnum(), re.compile('^[a-zA-Z]{1}.*$').match(col) is None ]):
# actually， column alias also support "_"， but in this case，forbidden that。
print(f"case in {line}: ", end='')
return tdSql.error(self.sample_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
if all([alias, "," in alias]):
if all(parm != alias.lower().split(",")[1].strip() for parm in alias_list):
print(f"case in {line}: ", end='')
return tdSql.error(self.sample_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
pass
condition_exception = [ "-", "+", "/", "*", "~", "^", "insert", "distinct",
"count", "avg", "twa", "irate", "sum", "stddev", "leastquares",
"min", "max", "first", "last", "top", "bottom", "percentile",
"apercentile", "last_row", "interp", "diff", "derivative",
"spread", "ceil", "floor", "round", "interval", "fill", "slimit", "soffset"]
if "union" not in condition.lower():
if any(parm in condition.lower().strip() for parm in condition_exception):
print(f"case in {line}: ", end='')
return tdSql.error(self.sample_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
pass
if not any([isinstance(k, int) , isinstance(k, float)]) :
print(f"case in {line}: ", end='')
return tdSql.error(self.sample_query_form(
col=col, k=k, alias=alias, table_expr=table_expr, condition=condition
))
if not(1 <= k < 1001):
print(f"case in {line}: ", end='')
return tdSql.error(self.sample_query_form(
col=col, k=k, alias=alias, table_expr=table_expr, condition=condition
))
k = int(k // 1)
pre_sql = re.sub("sample\([a-z0-9 .,]*\)", f"count({col})", self.sample_query_form(
col=col, table_expr=table_expr, condition=condition
))
tdSql.query(pre_sql)
if tdSql.queryRows == 0:
tdSql.query(self.sample_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
print(f"case in {line}: ", end='')
tdSql.checkRows(0)
return
tdSql.query(self.sample_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
sample_result = tdSql.queryResult
sample_len = tdSql.queryRows
if "group" in condition:
tb_condition = condition.split("group by")[1].split(" ")[1]
tdSql.query(f"select distinct {tb_condition} from {table_expr}")
query_result = tdSql.queryResult
query_rows = tdSql.queryRows
clear_condition = re.sub('order by [0-9a-z]*|slimit [0-9]*|soffset [0-9]*', "", condition)
pre_row = 0
for i in range(query_rows):
group_name = query_result[i][0]
if "where" in clear_condition:
pre_condition = re.sub('group by [0-9a-z]*', f"and {tb_condition}='{group_name}' and {col} is not null", clear_condition)
else:
pre_condition = "where " + re.sub('group by [0-9a-z]*',f"{tb_condition}='{group_name}' and {col} is not null", clear_condition)
tdSql.query(f"select ts, {col} {alias} from {table_expr} {pre_condition}")
# pre_data = np.array(tdSql.queryResult)[np.array(tdSql.queryResult) != None]
# pre_sample = np.convolve(pre_data, np.ones(k), "valid")/k
pre_sample = tdSql.queryResult
pre_len = tdSql.queryRows
step = pre_len if pre_len < k else k
# tdSql.query(self.sample_query_form(
# sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
# table_expr=table_expr, condition=condition
# ))
for i in range(step):
if sample_result[pre_row:pre_row+step][i] not in pre_sample:
tdLog.exit(f"case in {line} is failed: sample data is not in {group_name}")
else:
tdLog.info(f"case in {line} is success: sample data is in {group_name}")
# for j in range(len(pre_sample)):
# print(f"case in {line}:", end='')
# tdSql.checkData(pre_row+j, 1, pre_sample[j])
pre_row += step
return
elif "union" in condition:
union_sql_0 = self.sample_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
).split("union all")[0]
union_sql_1 = self.sample_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
).split("union all")[1]
tdSql.query(union_sql_0)
# union_sample_0 = tdSql.queryResult
row_union_0 = tdSql.queryRows
tdSql.query(union_sql_1)
# union_sample_1 = tdSql.queryResult
row_union_1 = tdSql.queryRows
tdSql.query(self.sample_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
# for i in range(tdSql.queryRows):
# print(f"case in {line}: ", end='')
# if i < row_union_0:
# tdSql.checkData(i, 1, union_sample_0[i][1])
# else:
# tdSql.checkData(i, 1, union_sample_1[i-row_union_0][1])
if row_union_0 + row_union_1 != sample_len:
tdLog.exit(f"case in {line} is failed: sample data is not in {group_name}")
else:
tdLog.info(f"case in {line} is success: sample data is in {group_name}")
return
else:
if "where" in condition:
condition = re.sub('where', f"where {col} is not null and ", condition)
else:
condition = f"where {col} is not null" + condition
tdSql.query(f"select ts, {col}, {alias} from {table_expr} {re.sub('limit [0-9]*|offset [0-9]*','',condition)}")
# offset_val = condition.split("offset")[1].split(" ")[1] if "offset" in condition else 0
pre_sample = tdSql.queryResult
# pre_len = tdSql.queryRows
for i in range(sample_len):
if sample_result[pre_row:pre_row + step][i] not in pre_sample:
tdLog.exit(f"case in {line} is failed: sample data is not in {group_name}")
else:
tdLog.info(f"case in {line} is success: sample data is in {group_name}")
pass
def sample_current_query(self) :
# table schema :ts timestamp, c1 int, c2 float, c3 timestamp, c4 binary(16), c5 double, c6 bool
# c7 bigint, c8 smallint, c9 tinyint, c10 nchar(16)
# case1～6： numeric col:int/bigint/tinyint/smallint/float/double
self.checksample()
case2 = {"col": "c2"}
self.checksample(**case2)
case3 = {"col": "c5"}
self.checksample(**case3)
case4 = {"col": "c7"}
self.checksample(**case4)
case5 = {"col": "c8"}
self.checksample(**case5)
case6 = {"col": "c9"}
self.checksample(**case6)
# case7~8: nested query
case7 = {"table_expr": "(select c1 from stb1)"}
self.checksample(**case7)
case8 = {"table_expr": "(select sample(c1, 1) c1 from stb1 group by tbname)"}
self.checksample(**case8)
# case9~10: mix with tbname/ts/tag/col
# case9 = {"alias": ", tbname"}
# self.checksample(**case9)
case10 = {"alias": ", _c0"}
self.checksample(**case10)
# case11 = {"alias": ", st1"}
# self.checksample(**case11)
# case12 = {"alias": ", c1"}
# self.checksample(**case12)
# case13~15: with single condition
case13 = {"condition": "where c1 <= 10"}
self.checksample(**case13)
case14 = {"condition": "where c6 in (0, 1)"}
self.checksample(**case14)
case15 = {"condition": "where c1 between 1 and 10"}
self.checksample(**case15)
# case16: with multi-condition
case16 = {"condition": "where c6=1 or c6 =0"}
self.checksample(**case16)
# case17: only support normal table join
case17 = {
"col": "t1.c1",
"table_expr": "t1, t2",
"condition": "where t1.ts=t2.ts"
}
self.checksample(**case17)
# # case18~19: with group by
case19 = {
"table_expr": "stb1",
"condition": "group by tbname"
}
self.checksample(**case19)
# case20~21: with order by
case20 = {"condition": "order by ts"}
self.checksample(**case20)
case21 = {
"table_expr": "stb1",
"condition": "group by tbname order by tbname"
}
self.checksample(**case21)
# case22: with union
case22 = {
"condition": "union all select sample( c1 , 1 ) from t2"
}
self.checksample(**case22)
# case23: with limit/slimit
case23 = {
"condition": "limit 1"
}
self.checksample(**case23)
# case24: value k range[1, 100], can be int or float, k = floor(k)
case24 = {"k": 3}
self.checksample(**case24)
case25 = {"k": 2.999}
self.checksample(**case25)
case26 = {"k": 1000}
self.checksample(**case26)
case27 = {
"table_expr": "stb1",
"condition": "group by tbname slimit 1 "
}
self.checksample(**case27) # with slimit
case28 = {
"table_expr": "stb1",
"condition": "group by tbname slimit 1 soffset 1"
}
self.checksample(**case28) # with soffset
pass
def sample_error_query(self) -> None :
# unusual test
# form test
err1 = {"col": ""}
self.checksample(**err1) # no col
err2 = {"sel": ""}
self.checksample(**err2) # no select
err3 = {"func": "sample", "col": "", "m_comm": "", "k": "", "r_comm": ""}
self.checksample(**err3) # no sample condition: select sample from
err4 = {"col": "", "m_comm": "", "k": ""}
self.checksample(**err4) # no sample condition: select sample() from
err5 = {"func": "sample", "r_comm": ""}
self.checksample(**err5) # no brackets: select sample col, k from
err6 = {"fr": ""}
self.checksample(**err6) # no from
err7 = {"k": ""}
self.checksample(**err7) # no k
err8 = {"table_expr": ""}
self.checksample(**err8) # no table_expr
err9 = {"col": "st1"}
self.checksample(**err9) # col: tag
err10 = {"col": 1}
self.checksample(**err10) # col: value
err11 = {"col": "NULL"}
self.checksample(**err11) # col: NULL
err12 = {"col": "%_"}
self.checksample(**err12) # col: %_
err13 = {"col": "c3"}
self.checksample(**err13) # col: timestamp col
err14 = {"col": "_c0"}
# self.checksample(**err14) # col: Primary key
err15 = {"col": "avg(c1)"}
# self.checksample(**err15) # expr col
err16 = {"col": "c4"}
self.checksample(**err16) # binary col
err17 = {"col": "c10"}
self.checksample(**err17) # nchar col
err18 = {"col": "c6"}
self.checksample(**err18) # bool col
err19 = {"col": "'c1'"}
self.checksample(**err19) # col: string
err20 = {"col": None}
self.checksample(**err20) # col: None
err21 = {"col": "''"}
self.checksample(**err21) # col: ''
err22 = {"col": "tt1.c1"}
self.checksample(**err22) # not table_expr col
err23 = {"col": "t1"}
self.checksample(**err23) # tbname
err24 = {"col": "stb1"}
self.checksample(**err24) # stbname
err25 = {"col": "db"}
self.checksample(**err25) # datbasename
err26 = {"col": "True"}
self.checksample(**err26) # col: BOOL 1
err27 = {"col": True}
self.checksample(**err27) # col: BOOL 2
err28 = {"col": "*"}
self.checksample(**err28) # col: all col
err29 = {"func": "sample[", "r_comm": "]"}
self.checksample(**err29) # form: sample[col, k]
err30 = {"func": "sample{", "r_comm": "}"}
self.checksample(**err30) # form: sample{col, k}
err31 = {"col": "[c1]"}
self.checksample(**err31) # form: sample([col], k)
err32 = {"col": "c1, c2"}
self.checksample(**err32) # form: sample(col, col2, k)
err33 = {"col": "c1, 2"}
self.checksample(**err33) # form: sample(col, k1, k2)
err34 = {"alias": ", count(c1)"}
self.checksample(**err34) # mix with aggregate function 1
err35 = {"alias": ", avg(c1)"}
self.checksample(**err35) # mix with aggregate function 2
err36 = {"alias": ", min(c1)"}
self.checksample(**err36) # mix with select function 1
err37 = {"alias": ", top(c1, 5)"}
self.checksample(**err37) # mix with select function 2
err38 = {"alias": ", spread(c1)"}
self.checksample(**err38) # mix with calculation function 1
err39 = {"alias": ", diff(c1)"}
self.checksample(**err39) # mix with calculation function 2
err40 = {"alias": "+ 2"}
self.checksample(**err40) # mix with arithmetic 1
err41 = {"alias": "+ avg(c1)"}
self.checksample(**err41) # mix with arithmetic 2
err42 = {"alias": ", c1"}
self.checksample(**err42) # mix with other col
err43 = {"table_expr": "stb1"}
self.checksample(**err43) # select stb directly
err44 = {
"col": "stb1.c1",
"table_expr": "stb1, stb2",
"condition": "where stb1.ts=stb2.ts and stb1.st1=stb2.st2 order by stb1.ts"
}
self.checksample(**err44) # stb join
err45 = {
"condition": "where ts>0 and ts < now interval(1h) fill(next)"
}
self.checksample(**err45) # interval
err46 = {
"table_expr": "t1",
"condition": "group by c6"
}
# self.checksample(**err46) # group by normal col
err49 = {"k": "2021-01-01 00:00:00.000"}
self.checksample(**err49) # k: timestamp
err50 = {"k": False}
self.checksample(**err50) # k: False
err51 = {"k": "%"}
self.checksample(**err51) # k: special char
err52 = {"k": ""}
self.checksample(**err52) # k: ""
err53 = {"k": None}
self.checksample(**err53) # k: None
err54 = {"k": "NULL"}
self.checksample(**err54) # k: null
err55 = {"k": "binary(4)"}
self.checksample(**err55) # k: string
err56 = {"k": "c1"}
self.checksample(**err56) # k: sring，col name
err57 = {"col": "c1, 1, c2"}
self.checksample(**err57) # form: sample(col1, k1, col2, k2)
err58 = {"col": "c1 cc1"}
self.checksample(**err58) # form: sample(col newname, k)
err59 = {"k": "'1'"}
# self.checksample(**err59) # formL sample(colm, "1")
err60 = {"k": "-1-(-2)"}
# self.checksample(**err60) # formL sample(colm, -1-2)
err61 = {"k": 1001}
self.checksample(**err61) # k: right out of [1, 1000]
err62 = {"k": -1}
self.checksample(**err62) # k: negative number
err63 = {"k": 0}
self.checksample(**err63) # k: 0
err64 = {"k": 2**63-1}
self.checksample(**err64) # k: max(bigint)
err65 = {"k": 1-2**63}
# self.checksample(**err65) # k: min(bigint)
err66 = {"k": -2**63}
self.checksample(**err66) # k: NULL
err67 = {"k": 0.999999}
self.checksample(**err67) # k: left out of [1, 1000]
pass
def sample_test_data(self, tbnum:int, data_row:int, basetime:int) -> None :
for i in range(tbnum):
for j in range(data_row):
tdSql.execute(
f"insert into t{i} values ("
f"{basetime + (j+1)*10}, {random.randint(-200, -1)}, {random.uniform(200, -1)}, {basetime + random.randint(-200, -1)}, "
f"'binary_{j}', {random.uniform(-200, -1)}, {random.choice([0,1])}, {random.randint(-200,-1)}, "
f"{random.randint(-200, -1)}, {random.randint(-127, -1)}, 'nchar_{j}' )"
)
tdSql.execute(
f"insert into t{i} values ("
f"{basetime - (j+1) * 10}, {random.randint(1, 200)}, {random.uniform(1, 200)}, {basetime - random.randint(1, 200)}, "
f"'binary_{j}_1', {random.uniform(1, 200)}, {random.choice([0, 1])}, {random.randint(1,200)}, "
f"{random.randint(1,200)}, {random.randint(1,127)}, 'nchar_{j}_1' )"
)
tdSql.execute(
f"insert into tt{i} values ( {basetime-(j+1) * 10}, {random.randint(1, 200)} )"
)
pass
def sample_test_table(self,tbnum: int) -> None :
tdSql.execute("drop database if exists db")
tdSql.execute("create database if not exists db keep 3650")
tdSql.execute("use db")
tdSql.execute(
"create stable db.stb1 (\
ts timestamp, c1 int, c2 float, c3 timestamp, c4 binary(16), c5 double, c6 bool, \
c7 bigint, c8 smallint, c9 tinyint, c10 nchar(16)\
) \
tags(st1 int)"
)
tdSql.execute(
"create stable db.stb2 (ts timestamp, c1 int) tags(st2 int)"
)
for i in range(tbnum):
tdSql.execute(f"create table t{i} using stb1 tags({i})")
tdSql.execute(f"create table tt{i} using stb2 tags({i})")
pass
def sample_test_run(self) :
tdLog.printNoPrefix("==========TD-10594==========")
tbnum = 10
nowtime = int(round(time.time() * 1000))
per_table_rows = 100
self.sample_test_table(tbnum)
tdLog.printNoPrefix("######## no data test:")
self.sample_current_query()
self.sample_error_query()
tdLog.printNoPrefix("######## insert only NULL test:")
for i in range(tbnum):
tdSql.execute(f"insert into t{i}(ts) values ({nowtime - 5})")
tdSql.execute(f"insert into t{i}(ts) values ({nowtime + 5})")
self.sample_current_query()
self.sample_error_query()
tdLog.printNoPrefix("######## insert data in the range near the max(bigint/double):")
# self.sample_test_table(tbnum)
# tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values "
# f"({nowtime - (per_table_rows + 1) * 10}, {2**31-1}, {3.4*10**38}, {1.7*10**308}, {2**63-1})")
# tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values "
# f"({nowtime - (per_table_rows + 2) * 10}, {2**31-1}, {3.4*10**38}, {1.7*10**308}, {2**63-1})")
# self.sample_current_query()
# self.sample_error_query()
tdLog.printNoPrefix("######## insert data in the range near the min(bigint/double):")
# self.sample_test_table(tbnum)
# tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values "
# f"({nowtime - (per_table_rows + 1) * 10}, {1-2**31}, {-3.4*10**38}, {-1.7*10**308}, {1-2**63})")
# tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values "
# f"({nowtime - (per_table_rows + 2) * 10}, {1-2**31}, {-3.4*10**38}, {-1.7*10**308}, {512-2**63})")
# self.sample_current_query()
# self.sample_error_query()
tdLog.printNoPrefix("######## insert data without NULL data test:")
self.sample_test_table(tbnum)
self.sample_test_data(tbnum, per_table_rows, nowtime)
self.sample_current_query()
self.sample_error_query()
tdLog.printNoPrefix("######## insert data mix with NULL test:")
for i in range(tbnum):
tdSql.execute(f"insert into t{i}(ts) values ({nowtime})")
tdSql.execute(f"insert into t{i}(ts) values ({nowtime-(per_table_rows+3)*10})")
tdSql.execute(f"insert into t{i}(ts) values ({nowtime+(per_table_rows+3)*10})")
self.sample_current_query()
self.sample_error_query()
tdLog.printNoPrefix("######## check after WAL test:")
tdSql.query("show dnodes")
index = tdSql.getData(0, 0)
tdDnodes.stop(index)
tdDnodes.start(index)
self.sample_current_query()
self.sample_error_query()
def run(self):
import traceback
try:
# run in develop branch
self.sample_test_run()
pass
except Exception as e:
traceback.print_exc()
raise e
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase())
tests/pytest/functions/function_csum.py 0 → 100644
浏览文件 @ 1838b1ff
###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved.
#
# This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao
#
###################################################################
# -*- coding: utf-8 -*-
import sys
import subprocess
import random
import math
import numpy as np
import inspect
import re
from util.log import *
from util.cases import *
from util.sql import *
from util.dnodes import *
class TDTestCase:
def init(self, conn, logSql):
tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor())
def csum_query_form(self, col="c1", alias="", table_expr="t1", condition=""):
'''
csum function:
:param col: string, column name, required parameters;
:param alias: string, result column another name，or add other funtion;
:param table_expr: string or expression, data source（eg,table/stable name, result set）, required parameters;
:param condition: expression；
:param args: other funtions,like: ', last(col)',or give result column another name, like 'c2'
:return: csum query statement,default: select csum(c1) from t1
'''
return f"select csum({col}) {alias} from {table_expr} {condition}"
def checkcsum(self,col="c1", alias="", table_expr="t1", condition="" ):
line = sys._getframe().f_back.f_lineno
pre_sql = self.csum_query_form(
col=col, table_expr=table_expr, condition=condition
).replace("csum", "count")
tdSql.query(pre_sql)
if tdSql.queryRows == 0:
tdSql.query(self.csum_query_form(
col=col, alias=alias, table_expr=table_expr, condition=condition
))
print(f"case in {line}: ", end='')
tdSql.checkRows(0)
return
if "order by tbname" in condition:
tdSql.error(self.csum_query_form(
col=col, alias=alias, table_expr=table_expr, condition=condition
))
return
if "group" in condition:
tb_condition = condition.split("group by")[1].split(" ")[1]
tdSql.query(f"select distinct {tb_condition} from {table_expr}")
query_result = tdSql.queryResult
query_rows = tdSql.queryRows
clear_condition = re.sub('order by [0-9a-z]*|slimit [0-9]*|soffset [0-9]*', "", condition)
pre_row = 0
for i in range(query_rows):
group_name = query_result[i][0]
if "where" in clear_condition:
pre_condition = re.sub('group by [0-9a-z]*', f"{tb_condition}='{group_name}'", clear_condition)
else:
pre_condition = "where " + re.sub('group by [0-9a-z]*',f"{tb_condition}='{group_name}'", clear_condition)
tdSql.query(f"select {col} {alias} from {table_expr} {pre_condition}")
pre_data = np.array(tdSql.queryResult)[np.array(tdSql.queryResult) != None]
pre_csum = np.cumsum(pre_data)
tdSql.query(self.csum_query_form(
col=col, alias=alias, table_expr=table_expr, condition=condition
))
for j in range(len(pre_csum)):
print(f"case in {line}:", end='')
tdSql.checkData(pre_row+j, 1, pre_csum[j])
pre_row += len(pre_csum)
return
elif "union" in condition:
union_sql_0 = self.csum_query_form(
col=col, alias=alias, table_expr=table_expr, condition=condition
).split("union all")[0]
union_sql_1 = self.csum_query_form(
col=col, alias=alias, table_expr=table_expr, condition=condition
).split("union all")[1]
tdSql.query(union_sql_0)
union_csum_0 = tdSql.queryResult
row_union_0 = tdSql.queryRows
tdSql.query(union_sql_1)
union_csum_1 = tdSql.queryResult
tdSql.query(self.csum_query_form(
col=col, alias=alias, table_expr=table_expr, condition=condition
))
for i in range(tdSql.queryRows):
print(f"case in {line}: ", end='')
if i < row_union_0:
tdSql.checkData(i, 1, union_csum_0[i][1])
else:
tdSql.checkData(i, 1, union_csum_1[i-row_union_0][1])
return
else:
tdSql.query(f"select {col} from {table_expr} {re.sub('limit [0-9]*|offset [0-9]*','',condition)}")
offset_val = condition.split("offset")[1].split(" ")[1] if "offset" in condition else 0
pre_result = np.array(tdSql.queryResult)[np.array(tdSql.queryResult) != None]
pre_csum = np.cumsum(pre_result)[offset_val:]
tdSql.query(self.csum_query_form(
col=col, alias=alias, table_expr=table_expr, condition=condition
))
for i in range(tdSql.queryRows):
print(f"case in {line}: ", end='')
tdSql.checkData(i, 1, pre_csum[i])
pass
def csum_current_query(self) :
# table schema :ts timestamp, c1 int, c2 float, c3 timestamp, c4 binary(16), c5 double, c6 bool
# c7 bigint, c8 smallint, c9 tinyint, c10 nchar(16)
# case1～6： numeric col:int/bigint/tinyint/smallint/float/double
self.checkcsum()
case2 = {"col": "c2"}
self.checkcsum(**case2)
case3 = {"col": "c5"}
self.checkcsum(**case3)
case4 = {"col": "c7"}
self.checkcsum(**case4)
case5 = {"col": "c8"}
self.checkcsum(**case5)
case6 = {"col": "c9"}
self.checkcsum(**case6)
# case7~8: nested query
case7 = {"table_expr": "(select c1 from stb1)"}
self.checkcsum(**case7)
case8 = {"table_expr": "(select csum(c1) c1 from stb1 group by tbname)"}
self.checkcsum(**case8)
# case9~10: mix with tbname/ts/tag/col
case9 = {"alias": ", tbname"}
self.checkcsum(**case9)
case10 = {"alias": ", _c0"}
self.checkcsum(**case10)
case11 = {"alias": ", st1"}
self.checkcsum(**case11)
case12 = {"alias": ", c1"}
# self.checkcsum(**case12)
# case13~15: with single condition
case13 = {"condition": "where c1 <= 10"}
self.checkcsum(**case13)
case14 = {"condition": "where c6 in (0, 1)"}
self.checkcsum(**case14)
case15 = {"condition": "where c1 between 1 and 10"}
self.checkcsum(**case15)
# case16: with multi-condition
case16 = {"condition": "where c6=1 or c6 =0"}
self.checkcsum(**case16)
# case17: only support normal table join
case17 = {
"col": "t1.c1",
"table_expr": "t1, t2",
"condition": "where t1.ts=t2.ts"
}
self.checkcsum(**case17)
# # case18~19: with group by
# case18 = {
# "table_expr": "t1",
# "condition": "group by c6"
# }
# self.checkcsum(**case18)
case19 = {
"table_expr": "stb1",
"condition": "group by tbname"
}
self.checkcsum(**case19)
# case20~21: with order by
case20 = {"condition": "order by ts"}
self.checkcsum(**case20)
# case22: with union
case22 = {
"condition": "union all select csum(c1) from t2"
}
self.checkcsum(**case22)
# case23: with limit/slimit
case23 = {
"condition": "limit 1"
}
self.checkcsum(**case23)
# case24 = {
# "table_expr": "stb1",
# "condition": "group by tbname slimit 1 soffset 1"
# }
# self.checkcsum(**case24)
pass
def csum_error_query(self) -> None :
# unusual test
#
# table schema :ts timestamp, c1 int, c2 float, c3 timestamp, c4 binary(16), c5 double, c6 bool
# c7 bigint, c8 smallint, c9 tinyint, c10 nchar(16)
#
# form test
tdSql.error(self.csum_query_form(col="")) # no col
tdSql.error("csum(c1) from stb1") # no select
tdSql.error("select csum from t1") # no csum condition
tdSql.error("select csum c1 from t1") # no brackets
tdSql.error("select csum(c1) t1") # no from
tdSql.error("select csum( c1 ) from ") # no table_expr
tdSql.error(self.csum_query_form(col="st1")) # tag col
tdSql.error(self.csum_query_form(col=1)) # col is a value
tdSql.error(self.csum_query_form(col="'c1'")) # col is a string
tdSql.error(self.csum_query_form(col=None)) # col is NULL 1
tdSql.error(self.csum_query_form(col="NULL")) # col is NULL 2
tdSql.error(self.csum_query_form(col='""')) # col is ""
tdSql.error(self.csum_query_form(col='c%')) # col is spercial char 1
tdSql.error(self.csum_query_form(col='c_')) # col is spercial char 2
tdSql.error(self.csum_query_form(col='c.')) # col is spercial char 3
tdSql.error(self.csum_query_form(col='c3')) # timestamp col
tdSql.error(self.csum_query_form(col='ts')) # Primary key
tdSql.error(self.csum_query_form(col='avg(c1)')) # expr col
tdSql.error(self.csum_query_form(col='c6')) # bool col
tdSql.error(self.csum_query_form(col='c4')) # binary col
tdSql.error(self.csum_query_form(col='c10')) # nachr col
tdSql.error(self.csum_query_form(col='c10')) # not table_expr col
tdSql.error(self.csum_query_form(col='t1')) # tbname
tdSql.error(self.csum_query_form(col='stb1')) # stbname
tdSql.error(self.csum_query_form(col='db')) # datbasename
tdSql.error(self.csum_query_form(col=True)) # col is BOOL 1
tdSql.error(self.csum_query_form(col='True')) # col is BOOL 2
tdSql.error(self.csum_query_form(col='*')) # col is all col
tdSql.error("select csum[c1] from t1") # sql form error 1
tdSql.error("select csum{c1} from t1") # sql form error 2
tdSql.error(self.csum_query_form(col="[c1]")) # sql form error 3
tdSql.error(self.csum_query_form(col="c1, c2")) # sql form error 3
tdSql.error(self.csum_query_form(col="c1, 2")) # sql form error 3
tdSql.error(self.csum_query_form(alias=", count(c1)")) # mix with aggregate function 1
tdSql.error(self.csum_query_form(alias=", avg(c1)")) # mix with aggregate function 2
tdSql.error(self.csum_query_form(alias=", min(c1)")) # mix with select function 1
tdSql.error(self.csum_query_form(alias=", top(c1, 5)")) # mix with select function 2
tdSql.error(self.csum_query_form(alias=", spread(c1)")) # mix with calculation function 1
tdSql.error(self.csum_query_form(alias=", diff(c1)")) # mix with calculation function 2
tdSql.error(self.csum_query_form(alias=" + 2")) # mix with arithmetic 1
tdSql.error(self.csum_query_form(alias=" + avg(c1)")) # mix with arithmetic 2
tdSql.error(self.csum_query_form(alias=", c2")) # mix with other 1
tdSql.error(self.csum_query_form(table_expr="stb1")) # select stb directly
stb_join = {
"col": "stb1.c1",
"table_expr": "stb1, stb2",
"condition": "where stb1.ts=stb2.ts and stb1.st1=stb2.st2 order by stb1.ts"
}
tdSql.error(self.csum_query_form(**stb_join)) # stb join
interval_sql = {
"condition": "where ts>0 and ts < now interval(1h) fill(next)"
}
tdSql.error(self.csum_query_form(**interval_sql)) # interval
group_normal_col = {
"table_expr": "t1",
"condition": "group by c6"
}
tdSql.error(self.csum_query_form(**group_normal_col)) # group by normal col
slimit_soffset_sql = {
"table_expr": "stb1",
"condition": "group by tbname slimit 1 soffset 1"
}
# tdSql.error(self.csum_query_form(**slimit_soffset_sql))
order_by_tbname_sql = {
"table_expr": "stb1",
"condition": "group by tbname order by tbname"
}
tdSql.error(self.csum_query_form(**order_by_tbname_sql))
pass
def csum_test_data(self, tbnum:int, data_row:int, basetime:int) -> None :
for i in range(tbnum):
for j in range(data_row):
tdSql.execute(
f"insert into t{i} values ("
f"{basetime + (j+1)*10}, {random.randint(-200, -1)}, {random.uniform(200, -1)}, {basetime + random.randint(-200, -1)}, "
f"'binary_{j}', {random.uniform(-200, -1)}, {random.choice([0,1])}, {random.randint(-200,-1)}, "
f"{random.randint(-200, -1)}, {random.randint(-127, -1)}, 'nchar_{j}' )"
)
tdSql.execute(
f"insert into t{i} values ("
f"{basetime - (j+1) * 10}, {random.randint(1, 200)}, {random.uniform(1, 200)}, {basetime - random.randint(1, 200)}, "
f"'binary_{j}_1', {random.uniform(1, 200)}, {random.choice([0, 1])}, {random.randint(1,200)}, "
f"{random.randint(1,200)}, {random.randint(1,127)}, 'nchar_{j}_1' )"
)
tdSql.execute(
f"insert into tt{i} values ( {basetime-(j+1) * 10}, {random.randint(1, 200)} )"
)
pass
def csum_test_table(self,tbnum: int) -> None :
tdSql.execute("drop database if exists db")
tdSql.execute("create database if not exists db keep 3650")
tdSql.execute("use db")
tdSql.execute(
"create stable db.stb1 (\
ts timestamp, c1 int, c2 float, c3 timestamp, c4 binary(16), c5 double, c6 bool, \
c7 bigint, c8 smallint, c9 tinyint, c10 nchar(16)\
) \
tags(st1 int)"
)
tdSql.execute(
"create stable db.stb2 (ts timestamp, c1 int) tags(st2 int)"
)
for i in range(tbnum):
tdSql.execute(f"create table t{i} using stb1 tags({i})")
tdSql.execute(f"create table tt{i} using stb2 tags({i})")
pass
def csum_test_run(self) :
tdLog.printNoPrefix("==========TD-10594==========")
tbnum = 10
nowtime = int(round(time.time() * 1000))
per_table_rows = 100
self.csum_test_table(tbnum)
tdLog.printNoPrefix("######## no data test:")
self.csum_current_query()
self.csum_error_query()
tdLog.printNoPrefix("######## insert only NULL test:")
for i in range(tbnum):
tdSql.execute(f"insert into t{i}(ts) values ({nowtime - 5})")
tdSql.execute(f"insert into t{i}(ts) values ({nowtime + 5})")
self.csum_current_query()
self.csum_error_query()
tdLog.printNoPrefix("######## insert data in the range near the max(bigint/double):")
self.csum_test_table(tbnum)
tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values "
f"({nowtime - (per_table_rows + 1) * 10}, {2**31-1}, {3.4*10**38}, {1.7*10**308}, {2**63-1})")
tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values "
f"({nowtime - (per_table_rows + 2) * 10}, {2**31-1}, {3.4*10**38}, {1.7*10**308}, {2**63-1})")
self.csum_current_query()
self.csum_error_query()
tdLog.printNoPrefix("######## insert data in the range near the min(bigint/double):")
self.csum_test_table(tbnum)
tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values "
f"({nowtime - (per_table_rows + 1) * 10}, {1-2**31}, {-3.4*10**38}, {-1.7*10**308}, {1-2**63})")
tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values "
f"({nowtime - (per_table_rows + 2) * 10}, {1-2**31}, {-3.4*10**38}, {-1.7*10**308}, {512-2**63})")
self.csum_current_query()
self.csum_error_query()
tdLog.printNoPrefix("######## insert data without NULL data test:")
self.csum_test_table(tbnum)
self.csum_test_data(tbnum, per_table_rows, nowtime)
self.csum_current_query()
self.csum_error_query()
tdLog.printNoPrefix("######## insert data mix with NULL test:")
for i in range(tbnum):
tdSql.execute(f"insert into t{i}(ts) values ({nowtime})")
tdSql.execute(f"insert into t{i}(ts) values ({nowtime-(per_table_rows+3)*10})")
tdSql.execute(f"insert into t{i}(ts) values ({nowtime+(per_table_rows+3)*10})")
self.csum_current_query()
self.csum_error_query()
tdLog.printNoPrefix("######## check after WAL test:")
tdSql.query("show dnodes")
index = tdSql.getData(0, 0)
tdDnodes.stop(index)
tdDnodes.start(index)
self.csum_current_query()
self.csum_error_query()
def run(self):
import traceback
try:
# run in develop branch
self.csum_test_run()
pass
except Exception as e:
traceback.print_exc()
raise e
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase())
tests/pytest/functions/function_mavg.py 0 → 100644
浏览文件 @ 1838b1ff
###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved.
#
# This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao
#
###################################################################
# -*- coding: utf-8 -*-
import sys
import subprocess
import random
import math
import numpy as np
import inspect
import re
import taos
from util.log import *
from util.cases import *
from util.sql import *
from util.dnodes import *
class TDTestCase:
def init(self, conn, logSql):
tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor())
def mavg_query_form(self, sel="select", func="mavg(", col="c1", m_comm =",", k=1,r_comm=")", alias="", fr="from",table_expr="t1", condition=""):
'''
mavg function:
:param sel: string, must be "select", required parameters;
:param func: string, in this case must be "mavg(", otherwise return other function, required parameters;
:param col: string, column name, required parameters;
:param m_comm: string, comma between col and k , required parameters;
:param k: int/float，the width of the sliding window, [1,100], required parameters;
:param r_comm: string, must be ")", use with "(" in func, required parameters;
:param alias: string, result column another name，or add other funtion;
:param fr: string, must be "from", required parameters;
:param table_expr: string or expression, data source（eg,table/stable name, result set）, required parameters;
:param condition: expression；
:return: mavg query statement,default: select mavg(c1, 1) from t1
'''
return f"{sel} {func} {col} {m_comm} {k} {r_comm} {alias} {fr} {table_expr} {condition}"
def checkmavg(self,sel="select", func="mavg(", col="c1", m_comm =",", k=1,r_comm=")", alias="", fr="from",table_expr="t1", condition=""):
# print(self.mavg_query_form(sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
# table_expr=table_expr, condition=condition))
line = sys._getframe().f_back.f_lineno
if not all([sel , func , col , m_comm , k , r_comm , fr , table_expr]):
print(f"case in {line}: ", end='')
return tdSql.error(self.mavg_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
sql = "select * from t1"
collist = tdSql.getColNameList(sql)
if not isinstance(col, str):
print(f"case in {line}: ", end='')
return tdSql.error(self.mavg_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
if len([x for x in col.split(",") if x.strip()]) != 1:
print(f"case in {line}: ", end='')
return tdSql.error(self.mavg_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
col = col.replace(",", "").replace(" ", "")
if any([re.compile('^[a-zA-Z]{1}.*$').match(col) is None , not col.replace(".","").isalnum()]):
print(f"case in {line}: ", end='')
return tdSql.error(self.mavg_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
# if all(["," in col , len(col.split(",")) != 2]):
# print(f"case in {line}: ", end='')
# return tdSql.error(self.mavg_query_form(
# sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
# table_expr=table_expr, condition=condition
# ))
#
# if ("," in col):
# if (not col.split(",")[0].strip()) ^ (not col.split(",")[1].strip()):
# col = col.strip().split(",")[0] if not col.split(",")[1].strip() else col.strip().split(",")[1]
# else:
# print(f"case in {line}: ", end='')
# return tdSql.error(self.mavg_query_form(
# sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
# table_expr=table_expr, condition=condition
# ))
# pass
if '.' in col:
if any([col.split(".")[0] not in table_expr, col.split(".")[1] not in collist]):
print(f"case in {line}: ", end='')
return tdSql.error(self.mavg_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
pass
if "." not in col:
if col not in collist:
print(f"case in {line}: ", end='')
return tdSql.error(self.mavg_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
pass
colname = col if "." not in col else col.split(".")[1]
col_index = collist.index(colname)
if any([tdSql.cursor.istype(col_index, "TIMESTAMP"), tdSql.cursor.istype(col_index, "BOOL")]):
print(f"case in {line}: ", end='')
return tdSql.error(self.mavg_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
if any([tdSql.cursor.istype(col_index, "BINARY") , tdSql.cursor.istype(col_index,"NCHAR")]):
print(f"case in {line}: ", end='')
return tdSql.error(self.mavg_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
if any( [func != "mavg(" , r_comm != ")" , fr != "from", sel != "select"]):
print(f"case in {line}: ", end='')
return tdSql.error(self.mavg_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
if all(["(" not in table_expr, "stb" in table_expr, "group" not in condition.lower()]):
print(f"case in {line}: ", end='')
return tdSql.error(self.mavg_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
if "order by tbname" in condition.lower():
print(f"case in {line}: ", end='')
return tdSql.error(self.mavg_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
if all(["group" in condition.lower(), "tbname" not in condition.lower()]):
print(f"case in {line}: ", end='')
return tdSql.error(self.mavg_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
alias_list = ["tbname", "_c0", "st", "ts"]
if all([alias, "," not in alias, not alias.isalnum()]):
# actually， column alias also support "_"， but in this case，forbidden that。
print(f"case in {line}: ", end='')
return tdSql.error(self.mavg_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
if all([alias, "," in alias]):
if all(parm != alias.lower().split(",")[1].strip() for parm in alias_list):
print(f"case in {line}: ", end='')
return tdSql.error(self.mavg_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
pass
condition_exception = [ "-", "+", "/", "*", "~", "^", "insert", "distinct",
"count", "avg", "twa", "irate", "sum", "stddev", "leastquares",
"min", "max", "first", "last", "top", "bottom", "percentile",
"apercentile", "last_row", "interp", "diff", "derivative",
"spread", "ceil", "floor", "round", "interval", "fill", "slimit", "soffset"]
if "union" not in condition.lower():
if any(parm in condition.lower().strip() for parm in condition_exception):
print(f"case in {line}: ", end='')
return tdSql.error(self.mavg_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
pass
if not any([isinstance(k, int) , isinstance(k, float)]) :
print(f"case in {line}: ", end='')
return tdSql.error(self.mavg_query_form(
col=col, k=k, alias=alias, table_expr=table_expr, condition=condition
))
if not(1 <= k < 1001):
print(f"case in {line}: ", end='')
return tdSql.error(self.mavg_query_form(
col=col, k=k, alias=alias, table_expr=table_expr, condition=condition
))
k = int(k // 1)
pre_sql = re.sub("mavg\([a-z0-9 .,]*\)", f"count({col})", self.mavg_query_form(
col=col, table_expr=table_expr, condition=condition
))
tdSql.query(pre_sql)
if tdSql.queryRows == 0:
tdSql.query(self.mavg_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
print(f"case in {line}: ", end='')
tdSql.checkRows(0)
return
if "group" in condition:
tb_condition = condition.split("group by")[1].split(" ")[1]
tdSql.query(f"select distinct {tb_condition} from {table_expr}")
query_result = tdSql.queryResult
query_rows = tdSql.queryRows
clear_condition = re.sub('order by [0-9a-z]*|slimit [0-9]*|soffset [0-9]*', "", condition)
pre_row = 0
for i in range(query_rows):
group_name = query_result[i][0]
if "where" in clear_condition:
pre_condition = re.sub('group by [0-9a-z]*', f"{tb_condition}='{group_name}'", clear_condition)
else:
pre_condition = "where " + re.sub('group by [0-9a-z]*',f"{tb_condition}='{group_name}'", clear_condition)
tdSql.query(f"select {col} {alias} from {table_expr} {pre_condition}")
pre_data = np.array(tdSql.queryResult)[np.array(tdSql.queryResult) != None]
pre_mavg = np.convolve(pre_data, np.ones(k), "valid")/k
tdSql.query(self.mavg_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
for j in range(len(pre_mavg)):
print(f"case in {line}:", end='')
tdSql.checkData(pre_row+j, 1, pre_mavg[j])
pre_row += len(pre_mavg)
return
elif "union" in condition:
union_sql_0 = self.mavg_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
).split("union all")[0]
union_sql_1 = self.mavg_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
).split("union all")[1]
tdSql.query(union_sql_0)
union_mavg_0 = tdSql.queryResult
row_union_0 = tdSql.queryRows
tdSql.query(union_sql_1)
union_mavg_1 = tdSql.queryResult
tdSql.query(self.mavg_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
for i in range(tdSql.queryRows):
print(f"case in {line}: ", end='')
if i < row_union_0:
tdSql.checkData(i, 1, union_mavg_0[i][1])
else:
tdSql.checkData(i, 1, union_mavg_1[i-row_union_0][1])
return
else:
tdSql.query(f"select {col} from {table_expr} {re.sub('limit [0-9]*|offset [0-9]*','',condition)}")
offset_val = condition.split("offset")[1].split(" ")[1] if "offset" in condition else 0
pre_result = np.array(tdSql.queryResult)[np.array(tdSql.queryResult) != None]
pre_mavg = pre_mavg = np.convolve(pre_result, np.ones(k), "valid")[offset_val:]/k
tdSql.query(self.mavg_query_form(
sel=sel, func=func, col=col, m_comm=m_comm, k=k, r_comm=r_comm, alias=alias, fr=fr,
table_expr=table_expr, condition=condition
))
for i in range(tdSql.queryRows):
print(f"case in {line}: ", end='')
tdSql.checkData(i, 1, pre_mavg[i])
pass
def mavg_current_query(self) :
# table schema :ts timestamp, c1 int, c2 float, c3 timestamp, c4 binary(16), c5 double, c6 bool
# c7 bigint, c8 smallint, c9 tinyint, c10 nchar(16)
# case1～6： numeric col:int/bigint/tinyint/smallint/float/double
self.checkmavg()
case2 = {"col": "c2"}
self.checkmavg(**case2)
case3 = {"col": "c5"}
self.checkmavg(**case3)
case4 = {"col": "c7"}
self.checkmavg(**case4)
case5 = {"col": "c8"}
self.checkmavg(**case5)
case6 = {"col": "c9"}
self.checkmavg(**case6)
# case7~8: nested query
case7 = {"table_expr": "(select c1 from stb1)"}
self.checkmavg(**case7)
case8 = {"table_expr": "(select mavg(c1, 1) c1 from stb1 group by tbname)"}
self.checkmavg(**case8)
# case9~10: mix with tbname/ts/tag/col
# case9 = {"alias": ", tbname"}
# self.checkmavg(**case9)
case10 = {"alias": ", _c0"}
self.checkmavg(**case10)
# case11 = {"alias": ", st1"}
# self.checkmavg(**case11)
# case12 = {"alias": ", c1"}
# self.checkmavg(**case12)
# case13~15: with single condition
case13 = {"condition": "where c1 <= 10"}
self.checkmavg(**case13)
case14 = {"condition": "where c6 in (0, 1)"}
self.checkmavg(**case14)
case15 = {"condition": "where c1 between 1 and 10"}
self.checkmavg(**case15)
# case16: with multi-condition
case16 = {"condition": "where c6=1 or c6 =0"}
self.checkmavg(**case16)
# case17: only support normal table join
case17 = {
"col": "t1.c1",
"table_expr": "t1, t2",
"condition": "where t1.ts=t2.ts"
}
self.checkmavg(**case17)
# # case18~19: with group by
case19 = {
"table_expr": "stb1",
"condition": "group by tbname"
}
self.checkmavg(**case19)
# case20~21: with order by
case20 = {"condition": "order by ts"}
self.checkmavg(**case20)
#case21 = {
# "table_expr": "stb1",
# "condition": "group by tbname order by tbname"
#}
#self.checkmavg(**case21)
# case22: with union
case22 = {
"condition": "union all select mavg( c1 , 1 ) from t2"
}
self.checkmavg(**case22)
# case23: with limit/slimit
case23 = {
"condition": "limit 1"
}
self.checkmavg(**case23)
# case24: value k range[1, 100], can be int or float, k = floor(k)
case24 = {"k": 3}
self.checkmavg(**case24)
case25 = {"k": 2.999}
self.checkmavg(**case25)
case26 = {"k": 1000}
self.checkmavg(**case26)
pass
def mavg_error_query(self) -> None :
# unusual test
# form test
err1 = {"col": ""}
self.checkmavg(**err1) # no col
err2 = {"sel": ""}
self.checkmavg(**err2) # no select
err3 = {"func": "mavg", "col": "", "m_comm": "", "k": "", "r_comm": ""}
self.checkmavg(**err3) # no mavg condition: select mavg from
err4 = {"col": "", "m_comm": "", "k": ""}
self.checkmavg(**err4) # no mavg condition: select mavg() from
err5 = {"func": "mavg", "r_comm": ""}
self.checkmavg(**err5) # no brackets: select mavg col, k from
err6 = {"fr": ""}
self.checkmavg(**err6) # no from
err7 = {"k": ""}
self.checkmavg(**err7) # no k
err8 = {"table_expr": ""}
self.checkmavg(**err8) # no table_expr
err9 = {"col": "st1"}
self.checkmavg(**err9) # col: tag
err10 = {"col": 1}
self.checkmavg(**err10) # col: value
err11 = {"col": "NULL"}
self.checkmavg(**err11) # col: NULL
err12 = {"col": "%_"}
self.checkmavg(**err12) # col: %_
err13 = {"col": "c3"}
self.checkmavg(**err13) # col: timestamp col
err14 = {"col": "_c0"}
self.checkmavg(**err14) # col: Primary key
err15 = {"col": "avg(c1)"}
self.checkmavg(**err15) # expr col
err16 = {"col": "c4"}
self.checkmavg(**err16) # binary col
err17 = {"col": "c10"}
self.checkmavg(**err17) # nchar col
err18 = {"col": "c6"}
self.checkmavg(**err18) # bool col
err19 = {"col": "'c1'"}
self.checkmavg(**err19) # col: string
err20 = {"col": None}
self.checkmavg(**err20) # col: None
err21 = {"col": "''"}
self.checkmavg(**err21) # col: ''
err22 = {"col": "tt1.c1"}
self.checkmavg(**err22) # not table_expr col
err23 = {"col": "t1"}
self.checkmavg(**err23) # tbname
err24 = {"col": "stb1"}
self.checkmavg(**err24) # stbname
err25 = {"col": "db"}
self.checkmavg(**err25) # datbasename
err26 = {"col": "True"}
self.checkmavg(**err26) # col: BOOL 1
err27 = {"col": True}
self.checkmavg(**err27) # col: BOOL 2
err28 = {"col": "*"}
self.checkmavg(**err28) # col: all col
err29 = {"func": "mavg[", "r_comm": "]"}
self.checkmavg(**err29) # form: mavg[col, k]
err30 = {"func": "mavg{", "r_comm": "}"}
self.checkmavg(**err30) # form: mavg{col, k}
err31 = {"col": "[c1]"}
self.checkmavg(**err31) # form: mavg([col], k)
err32 = {"col": "c1, c2"}
self.checkmavg(**err32) # form: mavg(col, col2, k)
err33 = {"col": "c1, 2"}
self.checkmavg(**err33) # form: mavg(col, k1, k2)
err34 = {"alias": ", count(c1)"}
self.checkmavg(**err34) # mix with aggregate function 1
err35 = {"alias": ", avg(c1)"}
self.checkmavg(**err35) # mix with aggregate function 2
err36 = {"alias": ", min(c1)"}
self.checkmavg(**err36) # mix with select function 1
err37 = {"alias": ", top(c1, 5)"}
self.checkmavg(**err37) # mix with select function 2
err38 = {"alias": ", spread(c1)"}
self.checkmavg(**err38) # mix with calculation function 1
err39 = {"alias": ", diff(c1)"}
self.checkmavg(**err39) # mix with calculation function 2
err40 = {"alias": "+ 2"}
self.checkmavg(**err40) # mix with arithmetic 1
err41 = {"alias": "+ avg(c1)"}
self.checkmavg(**err41) # mix with arithmetic 2
err42 = {"alias": ", c1"}
self.checkmavg(**err42) # mix with other col
err43 = {"table_expr": "stb1"}
self.checkmavg(**err43) # select stb directly
err44 = {
"col": "stb1.c1",
"table_expr": "stb1, stb2",
"condition": "where stb1.ts=stb2.ts and stb1.st1=stb2.st2 order by stb1.ts"
}
self.checkmavg(**err44) # stb join
err45 = {
"condition": "where ts>0 and ts < now interval(1h) fill(next)"
}
self.checkmavg(**err45) # interval
err46 = {
"table_expr": "t1",
"condition": "group by c6"
}
self.checkmavg(**err46) # group by normal col
err47 = {
"table_expr": "stb1",
"condition": "group by tbname slimit 1 "
}
# self.checkmavg(**err47) # with slimit
err48 = {
"table_expr": "stb1",
"condition": "group by tbname slimit 1 soffset 1"
}
# self.checkmavg(**err48) # with soffset
err49 = {"k": "2021-01-01 00:00:00.000"}
self.checkmavg(**err49) # k: timestamp
err50 = {"k": False}
self.checkmavg(**err50) # k: False
err51 = {"k": "%"}
self.checkmavg(**err51) # k: special char
err52 = {"k": ""}
self.checkmavg(**err52) # k: ""
err53 = {"k": None}
self.checkmavg(**err53) # k: None
err54 = {"k": "NULL"}
self.checkmavg(**err54) # k: null
err55 = {"k": "binary(4)"}
self.checkmavg(**err55) # k: string
err56 = {"k": "c1"}
self.checkmavg(**err56) # k: sring，col name
err57 = {"col": "c1, 1, c2"}
self.checkmavg(**err57) # form: mavg(col1, k1, col2, k2)
err58 = {"col": "c1 cc1"}
self.checkmavg(**err58) # form: mavg(col newname, k)
err59 = {"k": "'1'"}
# self.checkmavg(**err59) # formL mavg(colm, "1")
err60 = {"k": "-1-(-2)"}
# self.checkmavg(**err60) # formL mavg(colm, -1-2)
err61 = {"k": 1001}
self.checkmavg(**err61) # k: right out of [1, 1000]
err62 = {"k": -1}
self.checkmavg(**err62) # k: negative number
err63 = {"k": 0}
self.checkmavg(**err63) # k: 0
err64 = {"k": 2**63-1}
self.checkmavg(**err64) # k: max(bigint)
err65 = {"k": 1-2**63}
# self.checkmavg(**err65) # k: min(bigint)
err66 = {"k": -2**63}
self.checkmavg(**err66) # k: NULL
err67 = {"k": 0.999999}
self.checkmavg(**err67) # k: left out of [1, 1000]
err68 = {
"table_expr": "stb1",
"condition": "group by tbname order by tbname" # order by tbname not supported
}
self.checkmavg(**err68)
pass
def mavg_test_data(self, tbnum:int, data_row:int, basetime:int) -> None :
for i in range(tbnum):
for j in range(data_row):
tdSql.execute(
f"insert into t{i} values ("
f"{basetime + (j+1)*10}, {random.randint(-200, -1)}, {random.uniform(200, -1)}, {basetime + random.randint(-200, -1)}, "
f"'binary_{j}', {random.uniform(-200, -1)}, {random.choice([0,1])}, {random.randint(-200,-1)}, "
f"{random.randint(-200, -1)}, {random.randint(-127, -1)}, 'nchar_{j}' )"
)
tdSql.execute(
f"insert into t{i} values ("
f"{basetime - (j+1) * 10}, {random.randint(1, 200)}, {random.uniform(1, 200)}, {basetime - random.randint(1, 200)}, "
f"'binary_{j}_1', {random.uniform(1, 200)}, {random.choice([0, 1])}, {random.randint(1,200)}, "
f"{random.randint(1,200)}, {random.randint(1,127)}, 'nchar_{j}_1' )"
)
tdSql.execute(
f"insert into tt{i} values ( {basetime-(j+1) * 10}, {random.randint(1, 200)} )"
)
pass
def mavg_test_table(self,tbnum: int) -> None :
tdSql.execute("drop database if exists db")
tdSql.execute("create database if not exists db keep 3650")
tdSql.execute("use db")
tdSql.execute(
"create stable db.stb1 (\
ts timestamp, c1 int, c2 float, c3 timestamp, c4 binary(16), c5 double, c6 bool, \
c7 bigint, c8 smallint, c9 tinyint, c10 nchar(16)\
) \
tags(st1 int)"
)
tdSql.execute(
"create stable db.stb2 (ts timestamp, c1 int) tags(st2 int)"
)
for i in range(tbnum):
tdSql.execute(f"create table t{i} using stb1 tags({i})")
tdSql.execute(f"create table tt{i} using stb2 tags({i})")
pass
def mavg_test_run(self) :
tdLog.printNoPrefix("==========TD-10594==========")
tbnum = 10
nowtime = int(round(time.time() * 1000))
per_table_rows = 100
self.mavg_test_table(tbnum)
tdLog.printNoPrefix("######## no data test:")
self.mavg_current_query()
self.mavg_error_query()
tdLog.printNoPrefix("######## insert only NULL test:")
for i in range(tbnum):
tdSql.execute(f"insert into t{i}(ts) values ({nowtime - 5})")
tdSql.execute(f"insert into t{i}(ts) values ({nowtime + 5})")
self.mavg_current_query()
self.mavg_error_query()
tdLog.printNoPrefix("######## insert data in the range near the max(bigint/double):")
# self.mavg_test_table(tbnum)
# tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values "
# f"({nowtime - (per_table_rows + 1) * 10}, {2**31-1}, {3.4*10**38}, {1.7*10**308}, {2**63-1})")
# tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values "
# f"({nowtime - (per_table_rows + 2) * 10}, {2**31-1}, {3.4*10**38}, {1.7*10**308}, {2**63-1})")
# self.mavg_current_query()
# self.mavg_error_query()
tdLog.printNoPrefix("######## insert data in the range near the min(bigint/double):")
# self.mavg_test_table(tbnum)
# tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values "
# f"({nowtime - (per_table_rows + 1) * 10}, {1-2**31}, {-3.4*10**38}, {-1.7*10**308}, {1-2**63})")
# tdSql.execute(f"insert into t1(ts, c1,c2,c5,c7) values "
# f"({nowtime - (per_table_rows + 2) * 10}, {1-2**31}, {-3.4*10**38}, {-1.7*10**308}, {512-2**63})")
# self.mavg_current_query()
# self.mavg_error_query()
tdLog.printNoPrefix("######## insert data without NULL data test:")
self.mavg_test_table(tbnum)
self.mavg_test_data(tbnum, per_table_rows, nowtime)
self.mavg_current_query()
self.mavg_error_query()
tdLog.printNoPrefix("######## insert data mix with NULL test:")
for i in range(tbnum):
tdSql.execute(f"insert into t{i}(ts) values ({nowtime})")
tdSql.execute(f"insert into t{i}(ts) values ({nowtime-(per_table_rows+3)*10})")
tdSql.execute(f"insert into t{i}(ts) values ({nowtime+(per_table_rows+3)*10})")
self.mavg_current_query()
self.mavg_error_query()
tdLog.printNoPrefix("######## check after WAL test:")
tdSql.query("show dnodes")
index = tdSql.getData(0, 0)
tdDnodes.stop(index)
tdDnodes.start(index)
self.mavg_current_query()
self.mavg_error_query()
def run(self):
import traceback
try:
# run in develop branch
self.mavg_test_run()
pass
except Exception as e:
traceback.print_exc()
raise e
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase())
tests/script/general/compute/csum.sim
浏览文件 @ 1838b1ff
......@@ -101,9 +101,16 @@ if $data11 != -2 then
endi
print ==========>TD10758
sql create database groupby_tbname
sql use groupby_tbname
sql create stable st(ts timestamp, c1 int) tags(t int);
sql create table ct1 using st tags(1)
sql insert into ct1 values(now, 1)(now+1s, 2)(now+2s, 3)
sql create table ct2 using st tags(2)
sql insert into ct2 values(now, 21)(now+1s, 22)(now+2s, 23)
sql create table ct3 using st tags(3)
sql insert into ct3 values(now, 31)(now+1s, 32)(now+2s, 33)
sql select csum(c1),ts,tbname,t from ct1
print $data10 , $data11 , $data12, $data13, $data14
if $data13 != ct1 then
......@@ -169,6 +176,81 @@ if $data14 != 1 then
return -1
endi
sql select mavg(c1,2),tbname from st group by tbname
print $data10 , $data11 , $data12 , $data13
if $data12 != ct1 then
return -1
endi
if $data13 != ct1 then
return -1
endi
sql select diff(c1),tbname from st group by tbname
print $data10 , $data11 , $data12 , $data13
if $data12 != ct1 then
return -1
endi
if $data13 != ct1 then
return -1
endi
sql select csum(c1),tbname from st group by tbname
print $data10 , $data11 , $data12, $data13, $data14
print $data10 , $data11 , $data12 , $data13
if $data12 != ct1 then
return -1
endi
if $data13 != ct1 then
return -1
endi
sql select csum(c1),t,tbname from st group by tbname limit 2
print $data10 , $data11 , $data12 , $data13 , $data14
print $data30 , $data31 , $data32 , $data33 , $data34
if $data13 != ct1 then
return -1
endi
if $data14 != ct1 then
return -1
endi
if $data33 != ct2 then
return -1
endi
if $data34 != ct2 then
return -1
endi
sql select mavg(c1,2),t,tbname from st group by tbname limit 2
print $data10 , $data11 , $data12 , $data13 , $data14
print $data30 , $data31 , $data32 , $data33 , $data34
if $data13 != ct1 then
return -1
endi
if $data14 != ct1 then
return -1
endi
if $data33 != ct2 then
return -1
endi
if $data34 != ct2 then
return -1
endi
sql select diff(c1),t,tbname from st group by tbname limit 2
print $data10 , $data11 , $data12 , $data13 , $data14
print $data30 , $data31 , $data32 , $data33 , $data34
if $data13 != ct1 then
return -1
endi
if $data14 != ct1 then
return -1
endi
if $data33 != ct2 then
return -1
endi
if $data34 != ct2 then
return -1
endi
sql drop database groupby_tbname
print =============== clear
sql drop database $db
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或