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

Merge pull request #16100 from taosdata/cpwu/3.0 

Test: add case to support rest API
This commit is contained in:
Hui Li 2022-08-15 15:41:14 +08:00 committed by GitHub
parent 13979382dd 6cf09fb5eb
commit 4d8efb0b33
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 857 additions and 911 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
tests/pytest/util/taosadapter.py
View File

@ -238,19 +238,23 @@ class TAdapter:
if self.running != 0: if self.running != 0:
psCmd = f"ps -ef|grep -w {toBeKilled}| grep -v grep | awk '{{print $2}}'" psCmd = f"ps -ef|grep -w {toBeKilled}| grep -v grep | awk '{{print $2}}'"
# psCmd = f"pgrep {toBeKilled}"
processID = subprocess.check_output( processID = subprocess.check_output(
psCmd, shell=True).decode("utf-8") psCmd, shell=True)
while(processID): while(processID):
killCmd = f"kill {signal} {processID} > /dev/null 2>&1" killCmd = f"pkill {signal} {processID} > /dev/null 2>&1"
os.system(killCmd) os.system(killCmd)
time.sleep(1) time.sleep(1)
processID = subprocess.check_output( processID = subprocess.check_output(
psCmd, shell=True).decode("utf-8") psCmd, shell=True).decode("utf-8")
if not platform.system().lower() == 'windows': if not platform.system().lower() == 'windows':
for port in range(6030, 6041): port = 6041
fuserCmd = f"fuser -k -n tcp {port} > /dev/null" fuserCmd = f"fuser -k -n tcp {port} > /dev/null"
os.system(fuserCmd) os.system(fuserCmd)
# for port in range(6030, 6041):
# fuserCmd = f"fuser -k -n tcp {port} > /dev/null"
# os.system(fuserCmd)
self.running = 0 self.running = 0
tdLog.debug(f"taosadapter is stopped by kill {signal}") tdLog.debug(f"taosadapter is stopped by kill {signal}")

610
tests/system-test/2-query/json_tag.py
View File

@ -1,25 +1,8 @@
###################################################################
# 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, db_test.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 -*- # -*- coding: utf-8 -*-
import imp
import sys
import taos
from util.log import tdLog from util.log import tdLog
from util.cases import tdCases from util.cases import tdCases
from util.sql import tdSql from util.sql import tdSql
import json
import os
class TDTestCase: class TDTestCase:
def caseDescription(self): def caseDescription(self):
@ -31,35 +14,33 @@ class TDTestCase:
return return
def init(self, conn, logSql): def init(self, conn, logSql):
self.testcasePath = os.path.split(__file__)[0]
self.testcaseFilename = os.path.split(__file__)[-1]
# os.system("rm -rf %s/%s.sql" % (self.testcasePath,self.testcaseFilename))
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor(), True) tdSql.init(conn.cursor(), False)
def run(self): def run(self):
# tdSql.prepare() # tdSql.prepare()
tdSql.execute('drop database if exists db') dbname = "db"
tdSql.execute('create database db vgroups 1') tdSql.execute(f'drop database if exists {dbname}')
tdSql.execute('use db') tdSql.execute(f'create database {dbname} vgroups 1')
tdSql.execute(f'use {dbname}')
print("============== STEP 1 ===== prepare data & validate json string") print("============== STEP 1 ===== prepare data & validate json string")
tdSql.error("create table if not exists jsons1(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json, tagint int)") tdSql.error(f"create table if not exists {dbname}.jsons1(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json, tagint int)")
tdSql.error("create table if not exists jsons1(ts timestamp, data json) tags(tagint int)") tdSql.error(f"create table if not exists {dbname}.jsons1(ts timestamp, data json) tags(tagint int)")
tdSql.execute("create table if not exists jsons1(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json)") tdSql.execute(f"create table if not exists {dbname}.jsons1(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json)")
tdSql.execute("insert into jsons1_1 using jsons1 tags('{\"tag1\":\"fff\",\"tag2\":5, \"tag3\":true}') values(1591060618000, 1, false, 'json1', '你是') (1591060608000, 23, true, '等等', 'json')") tdSql.execute(f"insert into {dbname}.jsons1_1 using {dbname}.jsons1 tags('{{\"tag1\":\"fff\",\"tag2\":5, \"tag3\":true}}') values(1591060618000, 1, false, 'json1', '你是') (1591060608000, 23, true, '等等', 'json')")
tdSql.execute("insert into jsons1_2 using jsons1 tags('{\"tag1\":5,\"tag2\":\"beijing\"}') values (1591060628000, 2, true, 'json2', 'sss')") tdSql.execute(f"insert into {dbname}.jsons1_2 using {dbname}.jsons1 tags('{{\"tag1\":5,\"tag2\":\"beijing\"}}') values (1591060628000, 2, true, 'json2', 'sss')")
tdSql.execute("insert into jsons1_3 using jsons1 tags('{\"tag1\":false,\"tag2\":\"beijing\"}') values (1591060668000, 3, false, 'json3', 'efwe')") tdSql.execute(f"insert into {dbname}.jsons1_3 using {dbname}.jsons1 tags('{{\"tag1\":false,\"tag2\":\"beijing\"}}') values (1591060668000, 3, false, 'json3', 'efwe')")
tdSql.execute("insert into jsons1_4 using jsons1 tags('{\"tag1\":null,\"tag2\":\"shanghai\",\"tag3\":\"hello\"}') values (1591060728000, 4, true, 'json4', '323sd')") tdSql.execute(f"insert into {dbname}.jsons1_4 using {dbname}.jsons1 tags('{{\"tag1\":null,\"tag2\":\"shanghai\",\"tag3\":\"hello\"}}') values (1591060728000, 4, true, 'json4', '323sd')")
tdSql.execute("insert into jsons1_5 using jsons1 tags('{\"tag1\":1.232, \"tag2\":null}') values(1591060928000, 1, false, '你就会', 'ewe')") tdSql.execute(f"insert into {dbname}.jsons1_5 using {dbname}.jsons1 tags('{{\"tag1\":1.232, \"tag2\":null}}') values(1591060928000, 1, false, '你就会', 'ewe')")
tdSql.execute("insert into jsons1_6 using jsons1 tags('{\"tag1\":11,\"tag2\":\"\",\"tag2\":null}') values(1591061628000, 11, false, '你就会','')") tdSql.execute(f"insert into {dbname}.jsons1_6 using {dbname}.jsons1 tags('{{\"tag1\":11,\"tag2\":\"\",\"tag2\":null}}') values(1591061628000, 11, false, '你就会','')")
tdSql.execute("insert into jsons1_7 using jsons1 tags('{\"tag1\":\"收到货\",\"tag2\":\"\",\"tag3\":null}') values(1591062628000, 2, NULL, '你就会', 'dws')") tdSql.execute(f"insert into {dbname}.jsons1_7 using {dbname}.jsons1 tags('{{\"tag1\":\"收到货\",\"tag2\":\"\",\"tag3\":null}}') values(1591062628000, 2, NULL, '你就会', 'dws')")
# test duplicate key using the first one. elimate empty key # test duplicate key using the first one. elimate empty key
tdSql.execute("CREATE TABLE if not exists jsons1_8 using jsons1 tags('{\"tag1\":null, \"tag1\":true, \"tag1\":45, \"1tag$\":2, \" \":90, \"\":32}')") tdSql.execute(f"create TABLE if not exists {dbname}.jsons1_8 using {dbname}.jsons1 tags('{{\"tag1\":null, \"tag1\":true, \"tag1\":45, \"1tag$\":2, \" \":90, \"\":32}}')")
tdSql.query("select jtag from jsons1_8") tdSql.query(f"select jtag from {dbname}.jsons1_8")
tdSql.checkRows(0); tdSql.checkRows(0)
tdSql.query("select ts,jtag from jsons1 order by ts limit 2,3") tdSql.query(f"select ts,jtag from {dbname}.jsons1 order by ts limit 2,3")
tdSql.checkData(0, 0, '2020-06-02 09:17:08.000') tdSql.checkData(0, 0, '2020-06-02 09:17:08.000')
tdSql.checkData(0, 1, '{"tag1":5,"tag2":"beijing"}') tdSql.checkData(0, 1, '{"tag1":5,"tag2":"beijing"}')
tdSql.checkData(1, 0, '2020-06-02 09:17:48.000') tdSql.checkData(1, 0, '2020-06-02 09:17:48.000')
@ -67,7 +48,7 @@ class TDTestCase:
tdSql.checkData(2, 0, '2020-06-02 09:18:48.000') tdSql.checkData(2, 0, '2020-06-02 09:18:48.000')
tdSql.checkData(2, 1, '{"tag1":null,"tag2":"shanghai","tag3":"hello"}') tdSql.checkData(2, 1, '{"tag1":null,"tag2":"shanghai","tag3":"hello"}')
tdSql.query("select ts,jtag->'tag1' from jsons1 order by ts limit 2,3") tdSql.query(f"select ts,jtag->'tag1' from {dbname}.jsons1 order by ts limit 2,3")
tdSql.checkData(0, 0, '2020-06-02 09:17:08.000') tdSql.checkData(0, 0, '2020-06-02 09:17:08.000')
tdSql.checkData(0, 1, '5.000000000') tdSql.checkData(0, 1, '5.000000000')
tdSql.checkData(1, 0, '2020-06-02 09:17:48.000') tdSql.checkData(1, 0, '2020-06-02 09:17:48.000')
@ -76,163 +57,163 @@ class TDTestCase:
tdSql.checkData(2, 1, 'null') tdSql.checkData(2, 1, 'null')
# test empty json string, save as jtag is NULL # test empty json string, save as jtag is NULL
tdSql.execute("insert into jsons1_9 using jsons1 tags('\t') values (1591062328000, 24, NULL, '你就会', '2sdw')") tdSql.execute(f"insert into {dbname}.jsons1_9 using {dbname}.jsons1 tags('\t') values (1591062328000, 24, NULL, '你就会', '2sdw')")
tdSql.execute("CREATE TABLE if not exists jsons1_10 using jsons1 tags('')") tdSql.execute(f"create TABLE if not exists {dbname}.jsons1_10 using {dbname}.jsons1 tags('')")
tdSql.execute("CREATE TABLE if not exists jsons1_11 using jsons1 tags(' ')") tdSql.execute(f"create TABLE if not exists {dbname}.jsons1_11 using {dbname}.jsons1 tags(' ')")
tdSql.execute("CREATE TABLE if not exists jsons1_12 using jsons1 tags('{}')") tdSql.execute(f"create TABLE if not exists {dbname}.jsons1_12 using {dbname}.jsons1 tags('{{}}')")
tdSql.execute("CREATE TABLE if not exists jsons1_13 using jsons1 tags('null')") tdSql.execute(f"create TABLE if not exists {dbname}.jsons1_13 using {dbname}.jsons1 tags('null')")
# test invalidate json # test invalidate json
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('\"efwewf\"')") tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('\"efwewf\"')")
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('3333')") tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('3333')")
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags(76)") tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags(76)")
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags(hell)") tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags(hell)")
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('33.33')") tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('33.33')")
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('false')") tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('false')")
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('[1,true]')") tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('[1,true]')")
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{222}')") tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('{{222}}')")
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{\"fe\"}')") tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('{{\"fe\"}}')")
# test invalidate json key, key must can be printed assic char # test invalidate json key, key must can be printed assic char
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{\"tag1\":[1,true]}')") tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('{{\"tag1\":[1,true]}}')")
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{\"tag1\":{}}')") tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('{{\"tag1\":{{}}}}')")
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{\"。loc\":\"fff\"}')") tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('{{\"。loc\":\"fff\"}}')")
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{\"\t\":\"fff\"}')") tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('{{\"\t\":\"fff\"}}')")
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{\"试试\":\"fff\"}')") tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('{{\"试试\":\"fff\"}}')")
# test invalidate json value, value number can not be inf,nan TD-12166 # test invalidate json value, value number can not be inf,nan TD-12166
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{\"k\":1.8e308}')") tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('{{\"k\":1.8e308}}')")
tdSql.error("CREATE TABLE if not exists jsons1_14 using jsons1 tags('{\"k\":-1.8e308}')") tdSql.error(f"create TABLE if not exists {dbname}.jsons1_14 using {dbname}.jsons1 tags('{{\"k\":-1.8e308}}')")
#test length limit #test length limit
char1= ''.join(['abcd']*64) char1= ''.join(['abcd']*64)
char3= ''.join(['abcd']*1021) char3= ''.join(['abcd']*1021)
print(len(char3)) # 4084 print(len(char3)) # 4084
tdSql.error("CREATE TABLE if not exists jsons1_15 using jsons1 tags('{\"%s1\":5}')" % char1) # len(key)=257 tdSql.error(f"create TABLE if not exists {dbname}.jsons1_15 using {dbname}.jsons1 tags('{{\"%s1\":5}}')" % char1) # len(key)=257
tdSql.execute("CREATE TABLE if not exists jsons1_15 using jsons1 tags('{\"%s\":5}')" % char1) # len(key)=256 tdSql.execute(f"create TABLE if not exists {dbname}.jsons1_15 using {dbname}.jsons1 tags('{{\"%s\":5}}')" % char1) # len(key)=256
tdSql.error("CREATE TABLE if not exists jsons1_16 using jsons1 tags('{\"TSSSS\":\"%s\"}')" % char3) # len(object)=4096 tdSql.error(f"create TABLE if not exists {dbname}.jsons1_16 using {dbname}.jsons1 tags('{{\"TSSSS\":\"%s\"}}')" % char3) # len(object)=4096
tdSql.execute("CREATE TABLE if not exists jsons1_16 using jsons1 tags('{\"TSSS\":\"%s\"}')" % char3) # len(object)=4095 tdSql.execute(f"create TABLE if not exists {dbname}.jsons1_16 using {dbname}.jsons1 tags('{{\"TSSS\":\"%s\"}}')" % char3) # len(object)=4095
tdSql.execute("drop table if exists jsons1_15") tdSql.execute(f"drop table if exists {dbname}.jsons1_15")
tdSql.execute("drop table if exists jsons1_16") tdSql.execute(f"drop table if exists {dbname}.jsons1_16")
print("============== STEP 2 ===== alter table json tag") print("============== STEP 2 ===== alter table json tag")
tdSql.error("ALTER STABLE jsons1 add tag tag2 nchar(20)") tdSql.error(f"ALTER stable {dbname}.jsons1 add tag tag2 nchar(20)")
tdSql.error("ALTER STABLE jsons1 drop tag jtag") tdSql.error(f"ALTER stable {dbname}.jsons1 drop tag jtag")
tdSql.error("ALTER TABLE jsons1 MODIFY TAG jtag nchar(128)") tdSql.error(f"ALTER table {dbname}.jsons1 MODIFY TAG jtag nchar(128)")
tdSql.execute("ALTER TABLE jsons1_1 SET TAG jtag='{\"tag1\":\"femail\",\"tag2\":35,\"tag3\":true}'") tdSql.execute(f"ALTER table {dbname}.jsons1_1 SET TAG jtag='{{\"tag1\":\"femail\",\"tag2\":35,\"tag3\":true}}'")
tdSql.query("select jtag from jsons1_1") tdSql.query(f"select jtag from {dbname}.jsons1_1")
tdSql.checkData(0, 0, '{"tag1":"femail","tag2":35,"tag3":true}') tdSql.checkData(0, 0, '{"tag1":"femail","tag2":35,"tag3":true}')
tdSql.execute("ALTER TABLE jsons1 rename TAG jtag jtag_new") tdSql.execute(f"ALTER table {dbname}.jsons1 rename TAG jtag jtag_new")
tdSql.execute("ALTER TABLE jsons1 rename TAG jtag_new jtag") tdSql.execute(f"ALTER table {dbname}.jsons1 rename TAG jtag_new jtag")
tdSql.execute("create table st(ts timestamp, i int) tags(t int)") tdSql.execute(f"create table {dbname}.st(ts timestamp, i int) tags(t int)")
tdSql.error("ALTER STABLE st add tag jtag json") tdSql.error(f"ALTER stable {dbname}.st add tag jtag json")
tdSql.error("ALTER STABLE st add column jtag json") tdSql.error(f"ALTER stable {dbname}.st add column jtag json")
print("============== STEP 3 ===== query table") print("============== STEP 3 ===== query table")
# test error syntax # test error syntax
tdSql.error("select * from jsons1 where jtag->tag1='beijing'") tdSql.error(f"select * from {dbname}.jsons1 where jtag->tag1='beijing'")
tdSql.error("select -> from jsons1") tdSql.error(f"select -> from {dbname}.jsons1")
tdSql.error("select * from jsons1 where contains") tdSql.error(f"select * from {dbname}.jsons1 where contains")
tdSql.error("select * from jsons1 where jtag->") tdSql.error(f"select * from {dbname}.jsons1 where jtag->")
tdSql.error("select jtag->location from jsons1") tdSql.error(f"select jtag->location from {dbname}.jsons1")
tdSql.error("select jtag contains location from jsons1") tdSql.error(f"select jtag contains location from {dbname}.jsons1")
tdSql.error("select * from jsons1 where jtag contains location") tdSql.error(f"select * from {dbname}.jsons1 where jtag contains location")
tdSql.query("select * from jsons1 where jtag contains''") tdSql.query(f"select * from {dbname}.jsons1 where jtag contains''")
tdSql.error("select * from jsons1 where jtag contains 'location'='beijing'") tdSql.error(f"select * from {dbname}.jsons1 where jtag contains 'location'='beijing'")
# test function error # test function error
tdSql.error("select avg(jtag->'tag1') from jsons1") tdSql.error(f"select avg(jtag->'tag1') from {dbname}.jsons1")
tdSql.error("select avg(jtag) from jsons1") tdSql.error(f"select avg(jtag) from {dbname}.jsons1")
tdSql.error("select min(jtag->'tag1') from jsons1") tdSql.error(f"select min(jtag->'tag1') from {dbname}.jsons1")
tdSql.error("select min(jtag) from jsons1") tdSql.error(f"select min(jtag) from {dbname}.jsons1")
tdSql.error("select ceil(jtag->'tag1') from jsons1") tdSql.error(f"select ceil(jtag->'tag1') from {dbname}.jsons1")
tdSql.error("select ceil(jtag) from jsons1") tdSql.error(f"select ceil(jtag) from {dbname}.jsons1")
#test scalar operation #test scalar operation
tdSql.query("select jtag contains 'tag1',jtag->'tag1' from jsons1 order by jtag->'tag1'") tdSql.query(f"select jtag contains 'tag1',jtag->'tag1' from {dbname}.jsons1 order by jtag->'tag1'")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.query("select jtag->'tag1' like 'fe%',jtag->'tag1' from jsons1 order by jtag->'tag1'") tdSql.query(f"select jtag->'tag1' like 'fe%',jtag->'tag1' from {dbname}.jsons1 order by jtag->'tag1'")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.query("select jtag->'tag1' not like 'fe%',jtag->'tag1' from jsons1 order by jtag->'tag1'") tdSql.query(f"select jtag->'tag1' not like 'fe%',jtag->'tag1' from {dbname}.jsons1 order by jtag->'tag1'")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.query("select jtag->'tag1' match 'fe',jtag->'tag1' from jsons1 order by jtag->'tag1'") tdSql.query(f"select jtag->'tag1' match 'fe',jtag->'tag1' from {dbname}.jsons1 order by jtag->'tag1'")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.query("select jtag->'tag1' nmatch 'fe',jtag->'tag1' from jsons1 order by jtag->'tag1'") tdSql.query(f"select jtag->'tag1' nmatch 'fe',jtag->'tag1' from {dbname}.jsons1 order by jtag->'tag1'")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.query("select jtag->'tag1',jtag->'tag1'>='a' from jsons1 order by jtag->'tag1'") tdSql.query(f"select jtag->'tag1',jtag->'tag1'>='a' from {dbname}.jsons1 order by jtag->'tag1'")
tdSql.checkRows(9) tdSql.checkRows(9)
# test select normal column # test select normal column
tdSql.query("select dataint from jsons1 order by dataint") tdSql.query(f"select dataint from {dbname}.jsons1 order by dataint")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.checkData(1, 0, 1) tdSql.checkData(1, 0, 1)
# test select json tag # test select json tag
tdSql.query("select * from jsons1") tdSql.query(f"select * from {dbname}.jsons1")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.query("select jtag from jsons1") tdSql.query(f"select jtag from {dbname}.jsons1")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.query("select * from jsons1 where jtag is null") tdSql.query(f"select * from {dbname}.jsons1 where jtag is null")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.query("select * from jsons1 where jtag is not null") tdSql.query(f"select * from {dbname}.jsons1 where jtag is not null")
tdSql.checkRows(8) tdSql.checkRows(8)
# test jtag is NULL # test jtag is NULL
tdSql.query("select jtag from jsons1_9") tdSql.query(f"select jtag from {dbname}.jsons1_9")
tdSql.checkData(0, 0, None) tdSql.checkData(0, 0, None)
# test select json tag->'key', value is string # test select json tag->'key', value is string
tdSql.query("select jtag->'tag1' from jsons1_1") tdSql.query(f"select jtag->'tag1' from {dbname}.jsons1_1")
tdSql.checkData(0, 0, '"femail"') tdSql.checkData(0, 0, '"femail"')
tdSql.query("select jtag->'tag2' from jsons1_6") tdSql.query(f"select jtag->'tag2' from {dbname}.jsons1_6")
tdSql.checkData(0, 0, '""') tdSql.checkData(0, 0, '""')
# test select json tag->'key', value is int # test select json tag->'key', value is int
tdSql.query("select jtag->'tag2' from jsons1_1") tdSql.query(f"select jtag->'tag2' from {dbname}.jsons1_1")
tdSql.checkData(0, 0, "35.000000000") tdSql.checkData(0, 0, "35.000000000")
# test select json tag->'key', value is bool # test select json tag->'key', value is bool
tdSql.query("select jtag->'tag3' from jsons1_1") tdSql.query(f"select jtag->'tag3' from {dbname}.jsons1_1")
tdSql.checkData(0, 0, "true") tdSql.checkData(0, 0, "true")
# test select json tag->'key', value is null # test select json tag->'key', value is null
tdSql.query("select jtag->'tag1' from jsons1_4") tdSql.query(f"select jtag->'tag1' from {dbname}.jsons1_4")
tdSql.checkData(0, 0, "null") tdSql.checkData(0, 0, "null")
# test select json tag->'key', value is double # test select json tag->'key', value is double
tdSql.query("select jtag->'tag1' from jsons1_5") tdSql.query(f"select jtag->'tag1' from {dbname}.jsons1_5")
tdSql.checkData(0, 0, "1.232000000") tdSql.checkData(0, 0, "1.232000000")
# test select json tag->'key', key is not exist # test select json tag->'key', key is not exist
tdSql.query("select jtag->'tag10' from jsons1_4") tdSql.query(f"select jtag->'tag10' from {dbname}.jsons1_4")
tdSql.checkData(0, 0, None) tdSql.checkData(0, 0, None)
tdSql.query("select jtag->'tag1' from jsons1") tdSql.query(f"select jtag->'tag1' from {dbname}.jsons1")
tdSql.checkRows(9) tdSql.checkRows(9)
# test header name # test header name
res = tdSql.getColNameList("select jtag->'tag1' from jsons1") res = tdSql.getColNameList(f"select jtag->'tag1' from {dbname}.jsons1")
cname_list = [] cname_list = []
cname_list.append("jtag->'tag1'") cname_list.append("jtag->'tag1'")
tdSql.checkColNameList(res, cname_list) tdSql.checkColNameList(res, cname_list)
# test where with json tag # test where with json tag
tdSql.query("select * from jsons1_1 where jtag is not null") tdSql.query(f"select * from {dbname}.jsons1_1 where jtag is not null")
tdSql.query("select * from jsons1 where jtag='{\"tag1\":11,\"tag2\":\"\"}'") tdSql.query(f"select * from {dbname}.jsons1 where jtag='{{\"tag1\":11,\"tag2\":\"\"}}'")
tdSql.error("select * from jsons1 where jtag->'tag1'={}") tdSql.error(f"select * from {dbname}.jsons1 where jtag->'tag1'={{}}")
# test json error # test json error
tdSql.error("select jtag + 1 from jsons1") tdSql.error(f"select jtag + 1 from {dbname}.jsons1")
tdSql.error("select jtag > 1 from jsons1") tdSql.error(f"select jtag > 1 from {dbname}.jsons1")
tdSql.error("select jtag like \"1\" from jsons1") tdSql.error(f"select jtag like \"1\" from {dbname}.jsons1")
tdSql.error("select jtag in (\"1\") from jsons1") tdSql.error(f"select jtag in (\"1\") from {dbname}.jsons1")
#tdSql.error("select jtag from jsons1 where jtag > 1") #tdSql.error(f"select jtag from {dbname}.jsons1 where jtag > 1")
#tdSql.error("select jtag from jsons1 where jtag like 'fsss'") #tdSql.error(f"select jtag from {dbname}.jsons1 where jtag like 'fsss'")
#tdSql.error("select jtag from jsons1 where jtag in (1)") #tdSql.error(f"select jtag from {dbname}.jsons1 where jtag in (1)")
# where json value is string # where json value is string
tdSql.query("select * from jsons1 where jtag->'tag2'='beijing'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag2'='beijing'")
tdSql.checkRows(2) tdSql.checkRows(2)
tdSql.query("select dataint,tbname,jtag->'tag1',jtag from jsons1 where jtag->'tag2'='beijing' order by dataint") tdSql.query(f"select dataint,tbname,jtag->'tag1',jtag from {dbname}.jsons1 where jtag->'tag2'='beijing' order by dataint")
tdSql.checkRows(2) tdSql.checkRows(2)
tdSql.checkData(0, 0, 2) tdSql.checkData(0, 0, 2)
tdSql.checkData(0, 1, 'jsons1_2') tdSql.checkData(0, 1, 'jsons1_2')
@ -243,180 +224,180 @@ class TDTestCase:
tdSql.checkData(1, 2, 'false') tdSql.checkData(1, 2, 'false')
tdSql.query("select * from jsons1 where jtag->'tag1'='beijing'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'='beijing'")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select * from jsons1 where jtag->'tag1'='收到货'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'='收到货'")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.query("select * from jsons1 where jtag->'tag2'>'beijing'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag2'>'beijing'")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.query("select * from jsons1 where jtag->'tag2'>='beijing'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag2'>='beijing'")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select * from jsons1 where jtag->'tag2'<'beijing'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag2'<'beijing'")
tdSql.checkRows(2) tdSql.checkRows(2)
tdSql.query("select * from jsons1 where jtag->'tag2'<='beijing'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag2'<='beijing'")
tdSql.checkRows(4) tdSql.checkRows(4)
tdSql.query("select * from jsons1 where jtag->'tag2'!='beijing'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag2'!='beijing'")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select * from jsons1 where jtag->'tag2'=''") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag2'=''")
tdSql.checkRows(2) tdSql.checkRows(2)
# where json value is int # where json value is int
tdSql.query("select * from jsons1 where jtag->'tag1'=5") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=5")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.checkData(0, 1, 2) tdSql.checkData(0, 1, 2)
tdSql.query("select * from jsons1 where jtag->'tag1'=10") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=10")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select * from jsons1 where jtag->'tag1'<54") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'<54")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select * from jsons1 where jtag->'tag1'<=11") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'<=11")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select * from jsons1 where jtag->'tag1'>4") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'>4")
tdSql.checkRows(2) tdSql.checkRows(2)
tdSql.query("select * from jsons1 where jtag->'tag1'>=5") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'>=5")
tdSql.checkRows(2) tdSql.checkRows(2)
tdSql.query("select * from jsons1 where jtag->'tag1'!=5") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'!=5")
tdSql.checkRows(2) tdSql.checkRows(2)
tdSql.query("select * from jsons1 where jtag->'tag1'!=55") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'!=55")
tdSql.checkRows(3) tdSql.checkRows(3)
# where json value is double # where json value is double
tdSql.query("select * from jsons1 where jtag->'tag1'=1.232") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=1.232")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.query("select * from jsons1 where jtag->'tag1'<1.232") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'<1.232")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select * from jsons1 where jtag->'tag1'<=1.232") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'<=1.232")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.query("select * from jsons1 where jtag->'tag1'>1.23") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'>1.23")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select * from jsons1 where jtag->'tag1'>=1.232") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'>=1.232")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select * from jsons1 where jtag->'tag1'!=1.232") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'!=1.232")
tdSql.checkRows(2) tdSql.checkRows(2)
tdSql.query("select * from jsons1 where jtag->'tag1'!=3.232") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'!=3.232")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select * from jsons1 where jtag->'tag1'/0=3") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'/0=3")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select * from jsons1 where jtag->'tag1'/5=1") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'/5=1")
tdSql.checkRows(1) tdSql.checkRows(1)
# where json value is bool # where json value is bool
tdSql.query("select * from jsons1 where jtag->'tag1'=true") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=true")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select * from jsons1 where jtag->'tag1'=false") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=false")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.query("select * from jsons1 where jtag->'tag1'!=false") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'!=false")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select * from jsons1 where jtag->'tag1'>false") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'>false")
tdSql.checkRows(0) tdSql.checkRows(0)
# where json value is null # where json value is null
tdSql.query("select * from jsons1 where jtag->'tag1'=null") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=null")
tdSql.checkRows(0) tdSql.checkRows(0)
# where json key is null # where json key is null
tdSql.query("select * from jsons1 where jtag->'tag_no_exist'=3") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag_no_exist'=3")
tdSql.checkRows(0) tdSql.checkRows(0)
# where json value is not exist # where json value is not exist
tdSql.query("select * from jsons1 where jtag->'tag1' is null") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1' is null")
tdSql.checkData(0, 0, 'jsons1_9') tdSql.checkData(0, 0, 'jsons1_9')
tdSql.checkRows(2) tdSql.checkRows(2)
tdSql.query("select * from jsons1 where jtag->'tag4' is null") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag4' is null")
tdSql.checkRows(9) tdSql.checkRows(9)
tdSql.query("select * from jsons1 where jtag->'tag3' is not null") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag3' is not null")
tdSql.checkRows(3) tdSql.checkRows(3)
# test contains # test contains
tdSql.query("select * from jsons1 where jtag contains 'tag1'") tdSql.query(f"select * from {dbname}.jsons1 where jtag contains 'tag1'")
tdSql.checkRows(8) tdSql.checkRows(8)
tdSql.query("select * from jsons1 where jtag contains 'tag3'") tdSql.query(f"select * from {dbname}.jsons1 where jtag contains 'tag3'")
tdSql.checkRows(4) tdSql.checkRows(4)
tdSql.query("select * from jsons1 where jtag contains 'tag_no_exist'") tdSql.query(f"select * from {dbname}.jsons1 where jtag contains 'tag_no_exist'")
tdSql.checkRows(0) tdSql.checkRows(0)
# test json tag in where condition with and/or # test json tag in where condition with and/or
tdSql.query("select * from jsons1 where jtag->'tag1'=false and jtag->'tag2'='beijing'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=false and jtag->'tag2'='beijing'")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.query("select * from jsons1 where jtag->'tag1'=false or jtag->'tag2'='beijing'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=false or jtag->'tag2'='beijing'")
tdSql.checkRows(2) tdSql.checkRows(2)
tdSql.query("select * from jsons1 where jtag->'tag1'=false and jtag->'tag2'='shanghai'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=false and jtag->'tag2'='shanghai'")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select * from jsons1 where jtag->'tag1'=false and jtag->'tag2'='shanghai'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=false and jtag->'tag2'='shanghai'")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select * from jsons1 where jtag->'tag1'=13 or jtag->'tag2'>35") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=13 or jtag->'tag2'>35")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select * from jsons1 where jtag->'tag1'=13 or jtag->'tag2'>35") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'=13 or jtag->'tag2'>35")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select * from jsons1 where jtag->'tag1' is not null and jtag contains 'tag3'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1' is not null and jtag contains 'tag3'")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select * from jsons1 where jtag->'tag1'='femail' and jtag contains 'tag3'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1'='femail' and jtag contains 'tag3'")
tdSql.checkRows(2) tdSql.checkRows(2)
# test with between and # test with between and
tdSql.query("select * from jsons1 where jtag->'tag1' between 1 and 30") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1' between 1 and 30")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select * from jsons1 where jtag->'tag1' between 'femail' and 'beijing'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1' between 'femail' and 'beijing'")
tdSql.checkRows(2) tdSql.checkRows(2)
# test with tbname/normal column # test with tbname/normal column
tdSql.query("select * from jsons1 where tbname = 'jsons1_1'") tdSql.query(f"select * from {dbname}.jsons1 where tbname = 'jsons1_1'")
tdSql.checkRows(2) tdSql.checkRows(2)
tdSql.query("select * from jsons1 where tbname = 'jsons1_1' and jtag contains 'tag3'") tdSql.query(f"select * from {dbname}.jsons1 where tbname = 'jsons1_1' and jtag contains 'tag3'")
tdSql.checkRows(2) tdSql.checkRows(2)
tdSql.query("select * from jsons1 where tbname = 'jsons1_1' and jtag contains 'tag3' and dataint=3") tdSql.query(f"select * from {dbname}.jsons1 where tbname = 'jsons1_1' and jtag contains 'tag3' and dataint=3")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select * from jsons1 where tbname = 'jsons1_1' and jtag contains 'tag3' and dataint=23") tdSql.query(f"select * from {dbname}.jsons1 where tbname = 'jsons1_1' and jtag contains 'tag3' and dataint=23")
tdSql.checkRows(1) tdSql.checkRows(1)
# test where condition like # test where condition like
tdSql.query("select * from jsons1 where jtag->'tag2' like 'bei%'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag2' like 'bei%'")
tdSql.checkRows(2) tdSql.checkRows(2)
tdSql.query("select * from jsons1 where jtag->'tag1' like 'fe%' and jtag->'tag2' is not null") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1' like 'fe%' and jtag->'tag2' is not null")
tdSql.checkRows(2) tdSql.checkRows(2)
# test where condition in no support in # test where condition in no support in
tdSql.error("select * from jsons1 where jtag->'tag1' in ('beijing')") tdSql.error(f"select * from {dbname}.jsons1 where jtag->'tag1' in ('beijing')")
# test where condition match/nmath # test where condition match/nmath
tdSql.query("select * from jsons1 where jtag->'tag1' match 'ma'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1' match 'ma'")
tdSql.checkRows(2) tdSql.checkRows(2)
tdSql.query("select * from jsons1 where jtag->'tag1' match 'ma$'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1' match 'ma$'")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select * from jsons1 where jtag->'tag2' match 'jing$'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag2' match 'jing$'")
tdSql.checkRows(2) tdSql.checkRows(2)
tdSql.query("select * from jsons1 where jtag->'tag1' match '收到'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1' match '收到'")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.query("select * from jsons1 where jtag->'tag1' nmatch 'ma'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'tag1' nmatch 'ma'")
tdSql.checkRows(1) tdSql.checkRows(1)
# test distinct # test distinct
tdSql.execute("insert into jsons1_14 using jsons1 tags('{\"tag1\":\"收到货\",\"tag2\":\"\",\"tag3\":null}') values(1591062628000, 2, NULL, '你就会', 'dws')") tdSql.execute(f"insert into {dbname}.jsons1_14 using {dbname}.jsons1 tags('{{\"tag1\":\"收到货\",\"tag2\":\"\",\"tag3\":null}}') values(1591062628000, 2, NULL, '你就会', 'dws')")
tdSql.query("select distinct jtag->'tag1' from jsons1") tdSql.query(f"select distinct jtag->'tag1' from {dbname}.jsons1")
tdSql.checkRows(8) tdSql.checkRows(8)
tdSql.error("select distinct jtag from jsons1") tdSql.error(f"select distinct jtag from {dbname}.jsons1")
#test dumplicate key with normal colomn #test dumplicate key with normal colomn
tdSql.execute("INSERT INTO jsons1_15 using jsons1 tags('{\"tbname\":\"tt\",\"databool\":true,\"datastr\":\"是是是\"}') values(1591060828000, 4, false, 'jjsf', \"你就会\")") tdSql.execute(f"insert into {dbname}.jsons1_15 using {dbname}.jsons1 tags('{{\"tbname\":\"tt\",\"databool\":true,\"datastr\":\"是是是\"}}') values(1591060828000, 4, false, 'jjsf', \"你就会\")")
tdSql.query("select * from jsons1 where jtag->'datastr' match '是' and datastr match 'js'") tdSql.query(f"select * from {dbname}.jsons1 where jtag->'datastr' match '是' and datastr match 'js'")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.query("select tbname,jtag->'tbname' from jsons1 where jtag->'tbname'='tt' and tbname='jsons1_15'") tdSql.query(f"select tbname,jtag->'tbname' from {dbname}.jsons1 where jtag->'tbname'='tt' and tbname='jsons1_15'")
tdSql.checkRows(1) tdSql.checkRows(1)
# test join # test join
tdSql.execute("create table if not exists jsons2(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json)") tdSql.execute(f"create table if not exists {dbname}.jsons2(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json)")
tdSql.execute("insert into jsons2_1 using jsons2 tags('{\"tag1\":\"fff\",\"tag2\":5, \"tag3\":true}') values(1591060618000, 2, false, 'json2', '你是2')") tdSql.execute(f"insert into {dbname}.jsons2_1 using {dbname}.jsons2 tags('{{\"tag1\":\"fff\",\"tag2\":5, \"tag3\":true}}') values(1591060618000, 2, false, 'json2', '你是2')")
tdSql.execute("insert into jsons2_2 using jsons2 tags('{\"tag1\":5,\"tag2\":null}') values (1591060628000, 2, true, 'json2', 'sss')") tdSql.execute(f"insert into {dbname}.jsons2_2 using {dbname}.jsons2 tags('{{\"tag1\":5,\"tag2\":null}}') values (1591060628000, 2, true, 'json2', 'sss')")
tdSql.execute("create table if not exists jsons3(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json)") tdSql.execute(f"create table if not exists {dbname}.jsons3(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json)")
tdSql.execute("insert into jsons3_1 using jsons3 tags('{\"tag1\":\"fff\",\"tag2\":5, \"tag3\":true}') values(1591060618000, 3, false, 'json3', '你是3')") tdSql.execute(f"insert into {dbname}.jsons3_1 using {dbname}.jsons3 tags('{{\"tag1\":\"fff\",\"tag2\":5, \"tag3\":true}}') values(1591060618000, 3, false, 'json3', '你是3')")
tdSql.execute("insert into jsons3_2 using jsons3 tags('{\"tag1\":5,\"tag2\":\"beijing\"}') values (1591060638000, 2, true, 'json3', 'sss')") tdSql.execute(f"insert into {dbname}.jsons3_2 using {dbname}.jsons3 tags('{{\"tag1\":5,\"tag2\":\"beijing\"}}') values (1591060638000, 2, true, 'json3', 'sss')")
tdSql.query("select 'sss',33,a.jtag->'tag3' from jsons2 a,jsons3 b where a.ts=b.ts and a.jtag->'tag1'=b.jtag->'tag1'") tdSql.query(f"select 'sss',33,a.jtag->'tag3' from {dbname}.jsons2 a,jsons3 b where a.ts=b.ts and a.jtag->'tag1'=b.jtag->'tag1'")
tdSql.checkData(0, 0, "sss") tdSql.checkData(0, 0, "sss")
tdSql.checkData(0, 2, "true") tdSql.checkData(0, 2, "true")
res = tdSql.getColNameList("select 'sss',33,a.jtag->'tag3' from jsons2 a,jsons3 b where a.ts=b.ts and a.jtag->'tag1'=b.jtag->'tag1'") res = tdSql.getColNameList(f"select 'sss',33,a.jtag->'tag3' from {dbname}.jsons2 a,jsons3 b where a.ts=b.ts and a.jtag->'tag1'=b.jtag->'tag1'")
cname_list = [] cname_list = []
cname_list.append("'sss'") cname_list.append("'sss'")
cname_list.append("33") cname_list.append("33")
@ -424,19 +405,19 @@ class TDTestCase:
tdSql.checkColNameList(res, cname_list) tdSql.checkColNameList(res, cname_list)
# #
# test group by & order by json tag # test group by & order by json tag
tdSql.query("select ts,jtag->'tag1' from jsons1 partition by jtag->'tag1' order by jtag->'tag1' desc") tdSql.query(f"select ts,jtag->'tag1' from {dbname}.jsons1 partition by jtag->'tag1' order by jtag->'tag1' desc")
tdSql.checkRows(11) tdSql.checkRows(11)
tdSql.checkData(0, 1, '"femail"') tdSql.checkData(0, 1, '"femail"')
tdSql.checkData(2, 1, '"收到货"') tdSql.checkData(2, 1, '"收到货"')
tdSql.checkData(7, 1, "false") tdSql.checkData(7, 1, "false")
tdSql.error("select count(*) from jsons1 group by jtag") tdSql.error(f"select count(*) from {dbname}.jsons1 group by jtag")
tdSql.error("select count(*) from jsons1 partition by jtag") tdSql.error(f"select count(*) from {dbname}.jsons1 partition by jtag")
tdSql.error("select count(*) from jsons1 group by jtag order by jtag") tdSql.error(f"select count(*) from {dbname}.jsons1 group by jtag order by jtag")
tdSql.error("select count(*) from jsons1 group by jtag->'tag1' order by jtag->'tag2'") tdSql.error(f"select count(*) from {dbname}.jsons1 group by jtag->'tag1' order by jtag->'tag2'")
tdSql.error("select count(*) from jsons1 group by jtag->'tag1' order by jtag") tdSql.error(f"select count(*) from {dbname}.jsons1 group by jtag->'tag1' order by jtag")
tdSql.query("select count(*),jtag->'tag1' from jsons1 group by jtag->'tag1' order by jtag->'tag1' desc") tdSql.query(f"select count(*),jtag->'tag1' from {dbname}.jsons1 group by jtag->'tag1' order by jtag->'tag1' desc")
tdSql.checkRows(8) tdSql.checkRows(8)
tdSql.checkData(0, 0, 2) tdSql.checkData(0, 0, 2)
tdSql.checkData(0, 1, '"femail"') tdSql.checkData(0, 1, '"femail"')
@ -447,7 +428,7 @@ class TDTestCase:
tdSql.checkData(5, 0, 1) tdSql.checkData(5, 0, 1)
tdSql.checkData(5, 1, "false") tdSql.checkData(5, 1, "false")
tdSql.query("select count(*),jtag->'tag1' from jsons1 group by jtag->'tag1' order by jtag->'tag1' asc") tdSql.query(f"select count(*),jtag->'tag1' from {dbname}.jsons1 group by jtag->'tag1' order by jtag->'tag1' asc")
tdSql.checkRows(8) tdSql.checkRows(8)
tdSql.checkData(0, 1, None) tdSql.checkData(0, 1, None)
tdSql.checkData(2, 0, 1) tdSql.checkData(2, 0, 1)
@ -458,7 +439,7 @@ class TDTestCase:
tdSql.checkData(7, 1, '"femail"') tdSql.checkData(7, 1, '"femail"')
# test stddev with group by json tag # test stddev with group by json tag
tdSql.query("select stddev(dataint),jtag->'tag1' from jsons1 group by jtag->'tag1' order by jtag->'tag1'") tdSql.query(f"select stddev(dataint),jtag->'tag1' from {dbname}.jsons1 group by jtag->'tag1' order by jtag->'tag1'")
tdSql.checkRows(8) tdSql.checkRows(8)
tdSql.checkData(0, 1, None) tdSql.checkData(0, 1, None)
tdSql.checkData(4, 0, 0) tdSql.checkData(4, 0, 0)
@ -466,222 +447,222 @@ class TDTestCase:
tdSql.checkData(7, 0, 11) tdSql.checkData(7, 0, 11)
tdSql.checkData(7, 1, '"femail"') tdSql.checkData(7, 1, '"femail"')
res = tdSql.getColNameList("select stddev(dataint),jsons1.jtag->'tag1' from jsons1 group by jsons1.jtag->'tag1' order by jtag->'tag1'") res = tdSql.getColNameList(f"select stddev(dataint),jsons1.jtag->'tag1' from {dbname}.jsons1 group by jsons1.jtag->'tag1' order by jtag->'tag1'")
cname_list = [] cname_list = []
cname_list.append("stddev(dataint)") cname_list.append("stddev(dataint)")
cname_list.append("jsons1.jtag->'tag1'") cname_list.append("jsons1.jtag->'tag1'")
tdSql.checkColNameList(res, cname_list) tdSql.checkColNameList(res, cname_list)
# test top/bottom with group by json tag # test top/bottom with group by json tag
tdSql.query("select top(dataint,2),jtag->'tag1' from jsons1 group by jtag->'tag1' order by jtag->'tag1'") tdSql.query(f"select top(dataint,2),jtag->'tag1' from {dbname}.jsons1 group by jtag->'tag1' order by jtag->'tag1'")
tdSql.checkRows(11) tdSql.checkRows(11)
tdSql.checkData(0, 1, None) tdSql.checkData(0, 1, None)
# test having # test having
tdSql.query("select count(*),jtag->'tag1' from jsons1 group by jtag->'tag1' having count(*) > 1") tdSql.query(f"select count(*),jtag->'tag1' from {dbname}.jsons1 group by jtag->'tag1' having count(*) > 1")
tdSql.checkRows(3) tdSql.checkRows(3)
# subquery with json tag # subquery with json tag
tdSql.query("select * from (select jtag, dataint from jsons1) order by dataint") tdSql.query(f"select * from (select jtag, dataint from {dbname}.jsons1) order by dataint")
tdSql.checkRows(11) tdSql.checkRows(11)
tdSql.checkData(1, 1, 1) tdSql.checkData(1, 1, 1)
tdSql.checkData(5, 0, '{"tag1":false,"tag2":"beijing"}') tdSql.checkData(5, 0, '{"tag1":false,"tag2":"beijing"}')
tdSql.error("select jtag->'tag1' from (select jtag->'tag1', dataint from jsons1)") tdSql.error(f"select jtag->'tag1' from (select jtag->'tag1', dataint from {dbname}.jsons1)")
tdSql.error("select t->'tag1' from (select jtag->'tag1' as t, dataint from jsons1)") tdSql.error(f"select t->'tag1' from (select jtag->'tag1' as t, dataint from {dbname}.jsons1)")
tdSql.error("select ts,jtag->'tag1' from (select jtag->'tag1',tbname,ts from jsons1 order by ts)") tdSql.error(f"select ts,jtag->'tag1' from (select jtag->'tag1',tbname,ts from {dbname}.jsons1 order by ts)")
# union all # union all
tdSql.query("select jtag->'tag1' from jsons1 union all select jtag->'tag2' from jsons2") tdSql.query(f"select jtag->'tag1' from {dbname}.jsons1 union all select jtag->'tag2' from {dbname}.jsons2")
tdSql.checkRows(13) tdSql.checkRows(13)
tdSql.query("select jtag->'tag1' from jsons1_1 union all select jtag->'tag2' from jsons2_1") tdSql.query(f"select jtag->'tag1' from {dbname}.jsons1_1 union all select jtag->'tag2' from {dbname}.jsons2_1")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select jtag->'tag1' from jsons1_1 union all select jtag->'tag1' from jsons2_1") tdSql.query(f"select jtag->'tag1' from {dbname}.jsons1_1 union all select jtag->'tag1' from {dbname}.jsons2_1")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select dataint,jtag->'tag1',tbname from jsons1 union all select dataint,jtag->'tag1',tbname from jsons2") tdSql.query(f"select dataint,jtag->'tag1',tbname from {dbname}.jsons1 union all select dataint,jtag->'tag1',tbname from {dbname}.jsons2")
tdSql.checkRows(13) tdSql.checkRows(13)
tdSql.query("select dataint,jtag,tbname from jsons1 union all select dataint,jtag,tbname from jsons2") tdSql.query(f"select dataint,jtag,tbname from {dbname}.jsons1 union all select dataint,jtag,tbname from {dbname}.jsons2")
tdSql.checkRows(13) tdSql.checkRows(13)
#show create table #show create table
tdSql.query("show create table jsons1") tdSql.query(f"show create table {dbname}.jsons1")
tdSql.checkData(0, 1, 'CREATE STABLE `jsons1` (`ts` TIMESTAMP, `dataint` INT, `databool` BOOL, `datastr` NCHAR(50), `datastrbin` VARCHAR(150)) TAGS (`jtag` JSON)') tdSql.checkData(0, 1, 'CREATE STABLE `jsons1` (`ts` TIMESTAMP, `dataint` INT, `databool` BOOL, `datastr` NCHAR(50), `datastrbin` VARCHAR(150)) TAGS (`jtag` JSON)')
#test aggregate function:count/avg/twa/irate/sum/stddev/leastsquares #test aggregate function:count/avg/twa/irate/sum/stddev/leastsquares
tdSql.query("select count(*) from jsons1 where jtag is not null") tdSql.query(f"select count(*) from {dbname}.jsons1 where jtag is not null")
tdSql.checkData(0, 0, 10) tdSql.checkData(0, 0, 10)
tdSql.query("select avg(dataint) from jsons1 where jtag is not null") tdSql.query(f"select avg(dataint) from {dbname}.jsons1 where jtag is not null")
tdSql.checkData(0, 0, 5.3) tdSql.checkData(0, 0, 5.3)
# tdSql.query("select twa(dataint) from jsons1 where jtag is not null") # tdSql.query(f"select twa(dataint) from {dbname}.jsons1 where jtag is not null")
# tdSql.checkData(0, 0, 28.386363636363637) # tdSql.checkData(0, 0, 28.386363636363637)
# tdSql.query("select irate(dataint) from jsons1 where jtag is not null") # tdSql.query(f"select irate(dataint) from {dbname}.jsons1 where jtag is not null")
tdSql.query("select sum(dataint) from jsons1 where jtag->'tag1' is not null") tdSql.query(f"select sum(dataint) from {dbname}.jsons1 where jtag->'tag1' is not null")
tdSql.checkData(0, 0, 45) tdSql.checkData(0, 0, 45)
tdSql.query("select stddev(dataint) from jsons1 where jtag->'tag1'>1") tdSql.query(f"select stddev(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
tdSql.checkData(0, 0, 4.496912521) tdSql.checkData(0, 0, 4.496912521)
tdSql.query("SELECT LEASTSQUARES(dataint, 1, 1) from jsons1 where jtag is not null") tdSql.query(f"select LEASTSQUARES(dataint, 1, 1) from {dbname}.jsons1 where jtag is not null")
#test selection function:min/max/first/last/top/bottom/percentile/apercentile/last_row/interp #test selection function:min/max/first/last/top/bottom/percentile/apercentile/last_row/interp
tdSql.query("select min(dataint) from jsons1 where jtag->'tag1'>1") tdSql.query(f"select min(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
tdSql.checkData(0, 0, 1) tdSql.checkData(0, 0, 1)
tdSql.query("select max(dataint) from jsons1 where jtag->'tag1'>1") tdSql.query(f"select max(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
tdSql.checkData(0, 0, 11) tdSql.checkData(0, 0, 11)
tdSql.query("select first(dataint) from jsons1 where jtag->'tag1'>1") tdSql.query(f"select first(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
tdSql.checkData(0, 0, 2) tdSql.checkData(0, 0, 2)
tdSql.query("select last(dataint) from jsons1 where jtag->'tag1'>1") tdSql.query(f"select last(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
tdSql.checkData(0, 0, 11) tdSql.checkData(0, 0, 11)
tdSql.query("select top(dataint,100) from jsons1 where jtag->'tag1'>1") tdSql.query(f"select top(dataint,100) from {dbname}.jsons1 where jtag->'tag1'>1")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select bottom(dataint,100) from jsons1 where jtag->'tag1'>1") tdSql.query(f"select bottom(dataint,100) from {dbname}.jsons1 where jtag->'tag1'>1")
tdSql.checkRows(3) tdSql.checkRows(3)
#tdSql.query("select percentile(dataint,20) from jsons1 where jtag->'tag1'>1") #tdSql.query(f"select percentile(dataint,20) from {dbname}.jsons1 where jtag->'tag1'>1")
tdSql.query("select apercentile(dataint, 50) from jsons1 where jtag->'tag1'>1") tdSql.query(f"select apercentile(dataint, 50) from {dbname}.jsons1 where jtag->'tag1'>1")
tdSql.checkData(0, 0, 1.5) tdSql.checkData(0, 0, 1.5)
# tdSql.query("select last_row(dataint) from jsons1 where jtag->'tag1'>1") # tdSql.query(f"select last_row(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
# tdSql.query("select interp(dataint) from jsons1 where ts = '2020-06-02 09:17:08.000' and jtag->'tag1'>1") # tdSql.query(f"select interp(dataint) from {dbname}.jsons1 where ts = '2020-06-02 09:17:08.000' and jtag->'tag1'>1")
#test calculation function:diff/derivative/spread/ceil/floor/round/ #test calculation function:diff/derivative/spread/ceil/floor/round/
tdSql.query("select diff(dataint) from jsons1 where jtag->'tag1'>1") tdSql.query(f"select diff(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
tdSql.checkRows(2) tdSql.checkRows(2)
# tdSql.checkData(0, 0, -1) # tdSql.checkData(0, 0, -1)
# tdSql.checkData(1, 0, 10) # tdSql.checkData(1, 0, 10)
tdSql.query("select derivative(dataint, 10m, 0) from jsons1 where jtag->'tag1'>1") tdSql.query(f"select derivative(dataint, 10m, 0) from {dbname}.jsons1 where jtag->'tag1'>1")
# tdSql.checkData(0, 0, -2) # tdSql.checkData(0, 0, -2)
tdSql.query("select spread(dataint) from jsons1 where jtag->'tag1'>1") tdSql.query(f"select spread(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
tdSql.checkData(0, 0, 10) tdSql.checkData(0, 0, 10)
tdSql.query("select ceil(dataint) from jsons1 where jtag->'tag1'>1") tdSql.query(f"select ceil(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select floor(dataint) from jsons1 where jtag->'tag1'>1") tdSql.query(f"select floor(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select round(dataint) from jsons1 where jtag->'tag1'>1") tdSql.query(f"select round(dataint) from {dbname}.jsons1 where jtag->'tag1'>1")
tdSql.checkRows(3) tdSql.checkRows(3)
#math function #math function
tdSql.query("select sin(dataint) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select sin(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select cos(dataint) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select cos(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select tan(dataint) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select tan(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select asin(dataint) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select asin(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select acos(dataint) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select acos(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select atan(dataint) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select atan(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select ceil(dataint) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select ceil(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select floor(dataint) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select floor(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select round(dataint) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select round(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select abs(dataint) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select abs(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select pow(dataint,5) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select pow(dataint,5) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select log(dataint,10) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select log(dataint,10) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select sqrt(dataint) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select sqrt(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select HISTOGRAM(dataint,'user_input','[1, 33, 555, 7777]',1) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select HISTOGRAM(dataint,'user_input','[1, 33, 555, 7777]',1) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select csum(dataint) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select csum(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select mavg(dataint,1) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select mavg(dataint,1) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select statecount(dataint,'GE',10) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select statecount(dataint,'GE',10) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select stateduration(dataint,'GE',0) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select stateduration(dataint,'GE',0) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select sample(dataint,3) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select sample(dataint,3) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select HYPERLOGLOG(dataint) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select HYPERLOGLOG(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.query("select twa(dataint) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select twa(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(1) tdSql.checkRows(1)
# function not ready # function not ready
tdSql.query("select tail(dataint,1) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select tail(dataint,1) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.query("select unique(dataint) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select unique(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select mode(dataint) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select mode(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.query("select irate(dataint) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select irate(dataint) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(1) tdSql.checkRows(1)
#str function #str function
tdSql.query("select upper(dataStr) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select upper(dataStr) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select ltrim(dataStr) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select ltrim(dataStr) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select lower(dataStr) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select lower(dataStr) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select rtrim(dataStr) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select rtrim(dataStr) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select LENGTH(dataStr) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select LENGTH(dataStr) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select CHAR_LENGTH(dataStr) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select CHAR_LENGTH(dataStr) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select SUBSTR(dataStr,5) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select SUBSTR(dataStr,5) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select CONCAT(dataStr,dataStrBin) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select CONCAT(dataStr,dataStrBin) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select CONCAT_ws('adad!@!@%$^$%$^$%^a',dataStr,dataStrBin) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select CONCAT_ws('adad!@!@%$^$%$^$%^a',dataStr,dataStrBin) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select CAST(dataStr as bigint) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select CAST(dataStr as bigint) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
#time function #time function
tdSql.query("select now() from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select now() from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select today() from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select today() from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select TIMEZONE() from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select TIMEZONE() from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select TO_ISO8601(ts) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select TO_ISO8601(ts) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select TO_UNIXTIMESTAMP(datastr) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select TO_UNIXTIMESTAMP(datastr) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select TIMETRUNCATE(ts,1s) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select TIMETRUNCATE(ts,1s) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select TIMEDIFF(ts,_c0) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select TIMEDIFF(ts,_c0) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select TIMEDIFF(ts,1u) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select TIMEDIFF(ts,1u) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.query("select ELAPSED(ts,1h) from jsons1 where jtag->'tag1'>1;") tdSql.query(f"select ELAPSED(ts,1h) from {dbname}.jsons1 where jtag->'tag1'>1;")
tdSql.checkRows(1) tdSql.checkRows(1)
# to_json() # to_json()
tdSql.query("select to_json('{\"abc\":123}') from jsons1_1") tdSql.query(f"select to_json('{{\"abc\":123}}') from {dbname}.jsons1_1")
tdSql.checkRows(2) tdSql.checkRows(2)
tdSql.checkData(0, 0, '{"abc":123}') tdSql.checkData(0, 0, '{"abc":123}')
tdSql.checkData(1, 0, '{"abc":123}') tdSql.checkData(1, 0, '{"abc":123}')
tdSql.query("select to_json('null') from jsons1_1") tdSql.query(f"select to_json('null') from {dbname}.jsons1_1")
tdSql.checkRows(2) tdSql.checkRows(2)
tdSql.checkData(0, 0, 'null') tdSql.checkData(0, 0, 'null')
tdSql.checkData(1, 0, 'null') tdSql.checkData(1, 0, 'null')
tdSql.query("select to_json('{\"key\"}') from jsons1_1") tdSql.query(f"select to_json('{{\"key\"}}') from {dbname}.jsons1_1")
tdSql.checkRows(2) tdSql.checkRows(2)
tdSql.checkData(0, 0, 'null') tdSql.checkData(0, 0, 'null')
tdSql.checkData(1, 0, 'null') tdSql.checkData(1, 0, 'null')
#test TD-12077 #test TD-12077
tdSql.execute("insert into jsons1_16 using jsons1 tags('{\"tag1\":\"收到货\",\"tag2\":\"\",\"tag3\":-2.111}') values(1591062628000, 2, NULL, '你就会', 'dws')") tdSql.execute(f"insert into {dbname}.jsons1_16 using {dbname}.jsons1 tags('{{\"tag1\":\"收到货\",\"tag2\":\"\",\"tag3\":-2.111}}') values(1591062628000, 2, NULL, '你就会', 'dws')")
tdSql.query("select jtag->'tag3' from jsons1_16") tdSql.query(f"select jtag->'tag3' from {dbname}.jsons1_16")
tdSql.checkData(0, 0, '-2.111000000') tdSql.checkData(0, 0, '-2.111000000')
# test TD-12452 # test TD-12452
tdSql.execute("ALTER TABLE jsons1_1 SET TAG jtag=NULL") tdSql.execute(f"ALTER table {dbname}.jsons1_1 SET TAG jtag=NULL")
tdSql.query("select jtag from jsons1_1") tdSql.query(f"select jtag from {dbname}.jsons1_1")
tdSql.checkData(0, 0, None) tdSql.checkData(0, 0, None)
tdSql.execute("CREATE TABLE if not exists jsons1_20 using jsons1 tags(NULL)") tdSql.execute(f"create TABLE if not exists {dbname}.jsons1_20 using {dbname}.jsons1 tags(NULL)")
tdSql.query("select jtag from jsons1_20") tdSql.query(f"select jtag from {dbname}.jsons1_20")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.execute("insert into jsons1_21 using jsons1 tags(NULL) values(1591061628000, 11, false, '你就会','')") tdSql.execute(f"insert into {dbname}.jsons1_21 using {dbname}.jsons1 tags(NULL) values(1591061628000, 11, false, '你就会','')")
tdSql.query("select jtag from jsons1_21") tdSql.query(f"select jtag from {dbname}.jsons1_21")
tdSql.checkData(0, 0, None) tdSql.checkData(0, 0, None)
# #
# #test TD-12389 # #test TD-12389
@ -691,23 +672,23 @@ class TDTestCase:
tdSql.checkData(5, 2, 4095) tdSql.checkData(5, 2, 4095)
# #
# #test TD-13918 # #test TD-13918
tdSql.execute("drop table if exists jsons_13918_1") tdSql.execute(f"drop table if exists {dbname}.jsons_13918_1")
tdSql.execute("drop table if exists jsons_13918_2") tdSql.execute(f"drop table if exists {dbname}.jsons_13918_2")
tdSql.execute("drop table if exists jsons_13918_3") tdSql.execute(f"drop table if exists {dbname}.jsons_13918_3")
tdSql.execute("drop table if exists jsons_13918_4") tdSql.execute(f"drop table if exists {dbname}.jsons_13918_4")
tdSql.execute("drop table if exists jsons_stb") tdSql.execute(f"drop table if exists {dbname}.jsons_stb")
tdSql.execute("create table jsons_stb (ts timestamp, dataInt int) tags (jtag json)") tdSql.execute(f"create table {dbname}.jsons_stb (ts timestamp, dataInt int) tags (jtag json)")
tdSql.error("create table jsons_13918_1 using jsons_stb tags ('nullx')") tdSql.error(f"create table {dbname}.jsons_13918_1 using {dbname}.jsons_stb tags ('nullx')")
tdSql.error("create table jsons_13918_2 using jsons_stb tags (nullx)") tdSql.error(f"create table {dbname}.jsons_13918_2 using {dbname}.jsons_stb tags (nullx)")
tdSql.error("insert into jsons_13918_3 using jsons_stb tags('NULLx') values(1591061628001, 11)") tdSql.error(f"insert into {dbname}.jsons_13918_3 using {dbname}.jsons_stb tags('NULLx') values(1591061628001, 11)")
tdSql.error("insert into jsons_13918_4 using jsons_stb tags(NULLx) values(1591061628002, 11)") tdSql.error(f"insert into {dbname}.jsons_13918_4 using {dbname}.jsons_stb tags(NULLx) values(1591061628002, 11)")
tdSql.execute("create table jsons_13918_1 using jsons_stb tags ('null')") tdSql.execute(f"create table {dbname}.jsons_13918_1 using {dbname}.jsons_stb tags ('null')")
tdSql.execute("create table jsons_13918_2 using jsons_stb tags (null)") tdSql.execute(f"create table {dbname}.jsons_13918_2 using {dbname}.jsons_stb tags (null)")
tdSql.execute("insert into jsons_13918_1 values(1591061628003, 11)") tdSql.execute(f"insert into {dbname}.jsons_13918_1 values(1591061628003, 11)")
tdSql.execute("insert into jsons_13918_2 values(1591061628004, 11)") tdSql.execute(f"insert into {dbname}.jsons_13918_2 values(1591061628004, 11)")
tdSql.execute("insert into jsons_13918_3 using jsons_stb tags('NULL') values(1591061628005, 11)") tdSql.execute(f"insert into {dbname}.jsons_13918_3 using {dbname}.jsons_stb tags('NULL') values(1591061628005, 11)")
tdSql.execute("insert into jsons_13918_4 using jsons_stb tags(\"NULL\") values(1591061628006, 11)") tdSql.execute(f"insert into {dbname}.jsons_13918_4 using {dbname}.jsons_stb tags(\"NULL\") values(1591061628006, 11)")
tdSql.query("select * from jsons_stb") tdSql.query(f"select * from {dbname}.jsons_stb")
tdSql.checkRows(4) tdSql.checkRows(4)
def stop(self): def stop(self):
@ -717,4 +698,3 @@ class TDTestCase:
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

23
tests/system-test/2-query/json_tag_large_tables.py
View File

@ -35,7 +35,7 @@ class TDTestCase:
self.testcaseFilename = os.path.split(__file__)[-1] self.testcaseFilename = os.path.split(__file__)[-1]
# os.system("rm -rf %s/%s.sql" % (self.testcasePath,self.testcaseFilename)) # os.system("rm -rf %s/%s.sql" % (self.testcasePath,self.testcaseFilename))
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor(), True) tdSql.init(conn.cursor(), False)
def run(self): def run(self):
# tdSql.prepare() # tdSql.prepare()
@ -47,24 +47,24 @@ class TDTestCase:
i = 0 i = 0
# add 100000 table # add 100000 table
tdSql.execute("create table if not exists jsons1(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json)") tdSql.execute("create table if not exists jsons1(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json)")
while i <= 10 0000: while i <= 100000:
sql = """insert into jsons1_{%d} using jsons1 tags('{"tag1":{%d}}') values(1591060618000, 1, false, 'json1', '你是') (1591060608000, 23, true, '等等', 'json')"""%(i, i) sql = """insert into jsons1_{%d} using jsons1 tags('{"tag1":{%d}}') values(1591060618000, 1, false, 'json1', '你是') (1591060608000, 23, true, '等等', 'json')"""%(i, i)
tdSql.execute(sql) tdSql.execute(sql)
i = i + 1 i = i + 1
// do query # do query
i = 0 i = 0
while i <= 10 0000: while i <= 100000:
sql = """select count(*) from jsons1 where jtag->'tag1' = %d"""%(i) sql = """select count(*) from jsons1 where jtag->'tag1' = %d"""%(i)
tdSql.query(sql) tdSql.query(sql)
if 1 != tdSql.getRows(): if 1 != tdSql.getRows():
print("err: %s"%(sql)) print("err: %s"%(sql))
while i <= 10000000 while i <= 10000000:
sql = """insert into jsons1_{%d} using jsons1 tags('{"tag1":{%d}}') values(1591060618000, 1, false, 'json1', '你是') (1591060608000, 23, true, '等等', 'json')"""%(i, i) sql = """insert into jsons1_{%d} using jsons1 tags('{"tag1":{%d}}') values(1591060618000, 1, false, 'json1', '你是') (1591060608000, 23, true, '等等', 'json')"""%(i, i)
tdSql.execute(sql) tdSql.execute(sql)
i = i + 1 i = i + 1
i = 0 i = 0
# drop super table # drop super table
tdSql.execute("create table if not exists jsons1(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json)") tdSql.execute("create table if not exists jsons1(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json)")
@ -76,7 +76,7 @@ class TDTestCase:
tdSql.execute('drop stable jsons1') tdSql.execute('drop stable jsons1')
# drop database # drop database
i = 0 i = 0
tdSql.execute("create table if not exists jsons1(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json)") tdSql.execute("create table if not exists jsons1(ts timestamp, dataInt int, dataBool bool, dataStr nchar(50), dataStrBin binary(150)) tags(jtag json)")
while i <= 100000: while i <= 100000:
@ -84,10 +84,10 @@ class TDTestCase:
tdSql.execute(sql) tdSql.execute(sql)
i = i + 1 i = i + 1
tdSql.execute('drop database db') tdSql.execute('drop database db')
# test duplicate key using the first one. elimate empty key # test duplicate key using the first one. elimate empty key
#tdSql.execute("CREATE TABLE if not exists jsons1_8 using jsons1 tags('{\"tag1\":null, \"tag1\":true, \"tag1\":45, \"1tag$\":2, \" \":90, \"\":32}')") tdSql.query("select jtag from jsons1_8") tdSql.checkRows(0); #tdSql.execute("CREATE TABLE if not exists jsons1_8 using jsons1 tags('{\"tag1\":null, \"tag1\":true, \"tag1\":45, \"1tag$\":2, \" \":90, \"\":32}')") tdSql.query("select jtag from jsons1_8") tdSql.checkRows(0);
#tdSql.query("select ts,jtag from jsons1 order by ts limit 2,3") #tdSql.query("select ts,jtag from jsons1 order by ts limit 2,3")
#tdSql.checkData(0, 0, '2020-06-02 09:17:08.000') #tdSql.checkData(0, 0, '2020-06-02 09:17:08.000')
#tdSql.checkData(0, 1, '{"tag1":5,"tag2":"beijing"}') #tdSql.checkData(0, 1, '{"tag1":5,"tag2":"beijing"}')
@ -704,4 +704,3 @@ class TDTestCase:
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

494
tests/system-test/2-query/last_row.py
View File

File diff suppressed because it is too large Load Diff

128
tests/system-test/2-query/leastsquares.py
View File

@ -26,6 +26,7 @@ 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 ]
DBNAME = "db"
class TDTestCase: class TDTestCase:
def init(self, conn, logSql): def init(self, conn, logSql):
@ -133,13 +134,13 @@ class TDTestCase:
return f"select leastsquares({select_clause}, {start_val}, {step_val}) from {from_clause} {where_condition} {group_condition}" return f"select leastsquares({select_clause}, {start_val}, {step_val}) from {from_clause} {where_condition} {group_condition}"
@property @property
def __tb_list(self): def __tb_list(self, dbname=DBNAME):
return [ return [
"ct1", f"{dbname}.ct1",
"ct4", f"{dbname}.ct4",
"t1", f"{dbname}.nt1",
"ct2", f"{dbname}.ct2",
"stb1", f"{dbname}.stb1",
] ]
@property @property
@ -161,36 +162,37 @@ class TDTestCase:
err_sqls = [] err_sqls = []
__no_join_tblist = self.__tb_list __no_join_tblist = self.__tb_list
for tb in __no_join_tblist: for tb in __no_join_tblist:
select_claus_list = self.__query_condition(tb) tbname = tb.split(".")[-1]
for select_claus in select_claus_list: select_claus_list = self.__query_condition(tbname)
group_claus = self.__group_condition(col=select_claus) for select_claus in select_claus_list:
where_claus = self.__where_condition(query_conditon=select_claus) group_claus = self.__group_condition(col=select_claus)
having_claus = self.__group_condition(col=select_claus, having=f"{select_claus} is not null") where_claus = self.__where_condition(query_conditon=select_claus)
for arg in self.start_step_val: having_claus = self.__group_condition(col=select_claus, having=f"{select_claus} is not null")
if not isinstance(arg,int) or isinstance(arg, bool) : for arg in self.start_step_val:
err_sqls.extend( 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),
self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg, where_condition=where_claus, group_condition=having_claus), 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, TS_COL in select_claus]): )
err_sqls.extend( 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), (
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),
self.__single_sql(select_clause=select_claus, from_clause=tb, start_val=arg, where_condition=where_claus, group_condition=having_claus), 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),
) )
else: )
current_sqls.extend( else:
( current_sqls.extend(
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=0),
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=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),
) )
)
# return filter(None, sqls) # return filter(None, sqls)
return list(filter(None, current_sqls)), list(filter(None, err_sqls)) return list(filter(None, current_sqls)), list(filter(None, err_sqls))
@ -207,25 +209,25 @@ class TDTestCase:
def __test_current(self): def __test_current(self):
# tdSql.query("explain select c1 from ct1") # tdSql.query("explain select c1 from {dbname}.ct1")
# tdSql.query("explain select 1 from ct2") # tdSql.query("explain select 1 from {dbname}.ct2")
# tdSql.query("explain select cast(ceil(c6) as bigint) from ct4 group by c6") # tdSql.query("explain select cast(ceil(c6) as bigint) from {dbname}.ct4 group by c6")
# tdSql.query("explain select count(c3) from ct4 group by c7 having count(c3) > 0") # tdSql.query("explain select count(c3) from {dbname}.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 ct2.c3 from {dbname}.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 stb1 where c1 is not null and c1 in (0, 1, 2) or c1 between 2 and 100 ")
self.leastsquares_check() self.leastsquares_check()
def __test_error(self): def __test_error(self, dbname=DBNAME):
tdLog.printNoPrefix("===step 0: err case, must return err") tdLog.printNoPrefix("===step 0: err case, must return err")
tdSql.error( "select leastsquares(c1) from ct8" ) tdSql.error( f"select leastsquares(c1) from {dbname}.ct8" )
tdSql.error( "select leastsquares(c1, 1) from ct1 " ) tdSql.error( f"select leastsquares(c1, 1) from {dbname}.ct1 " )
tdSql.error( "select leastsquares(c1, null, 1) from ct1 " ) tdSql.error( f"select leastsquares(c1, null, 1) from {dbname}.ct1 " )
tdSql.error( "select leastsquares(c1, 1, null) from ct1 " ) tdSql.error( f"select leastsquares(c1, 1, null) from {dbname}.ct1 " )
tdSql.error( "select leastsquares(null, 1, 1) from ct1 " ) tdSql.error( f"select leastsquares(null, 1, 1) from {dbname}.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']) tdSql.error( f'''select leastsquares(['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'])
from ct1 from {dbname}.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 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'] 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 ''' ) having ['c1 + c1', 'c1 + c2', 'c1 + c3', 'c1 + c4', 'c1 + c5', 'c1 + c6', 'c1 + c7', 'c1 + c8', 'c1 + c9', 'c1 + c10'] is not null ''' )
@ -234,16 +236,16 @@ class TDTestCase:
self.__test_error() self.__test_error()
self.__test_current() self.__test_current()
def __create_tb(self): def __create_tb(self, dbname=DBNAME):
tdLog.printNoPrefix("==========step1:create table") tdLog.printNoPrefix("==========step1:create table")
create_stb_sql = f'''create table stb1( create_stb_sql = f'''create table {dbname}.stb1(
ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint, ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint,
{FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool,
{BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp
) tags (t1 int) ) tags (t1 int)
''' '''
create_ntb_sql = f'''create table t1( create_ntb_sql = f'''create table {dbname}.nt1(
ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint, ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint,
{FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool,
{BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp
@ -253,30 +255,29 @@ class TDTestCase:
tdSql.execute(create_ntb_sql) tdSql.execute(create_ntb_sql)
for i in range(4): for i in range(4):
tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )') tdSql.execute(f'create table {dbname}.ct{i+1} using {dbname}.stb1 tags ( {i+1} )')
{ i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2}
def __insert_data(self, rows): def __insert_data(self, rows, dbname=DBNAME):
now_time = int(datetime.datetime.timestamp(datetime.datetime.now()) * 1000) now_time = int(datetime.datetime.timestamp(datetime.datetime.now()) * 1000)
for i in range(rows): for i in range(rows):
tdSql.execute( 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 {dbname}.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( 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 {dbname}.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( 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 {dbname}.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( tdSql.execute(
f'''insert into ct1 values f'''insert into {dbname}.ct1 values
( { now_time - rows * 5 }, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar_测试_0', { now_time + 8 } ) ( { 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 + 10000 }, { rows }, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar_测试_9', { now_time + 9 } )
''' '''
) )
tdSql.execute( tdSql.execute(
f'''insert into ct4 values f'''insert into {dbname}.ct4 values
( { now_time - rows * 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 )
( { now_time - rows * 3888000000 + 10800000 }, 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 + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
@ -292,7 +293,7 @@ class TDTestCase:
) )
tdSql.execute( tdSql.execute(
f'''insert into ct2 values f'''insert into {dbname}.ct2 values
( { now_time - rows * 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 )
( { now_time - rows * 3888000000 + 10800000 }, 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 + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
@ -308,13 +309,13 @@ class TDTestCase:
) )
for i in range(rows): for i in range(rows):
insert_data = f'''insert into t1 values insert_data = f'''insert into {dbname}.nt1 values
( { now_time - i * 3600000 }, {i}, {i * 11111}, { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2}, ( { 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 } )
''' '''
tdSql.execute(insert_data) tdSql.execute(insert_data)
tdSql.execute( tdSql.execute(
f'''insert into t1 values f'''insert into {dbname}.nt1 values
( { now_time + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ( { 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 // 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 - rows * 3600000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
@ -332,7 +333,7 @@ class TDTestCase:
def run(self): def run(self):
tdSql.prepare() tdSql.prepare(DBNAME)
tdLog.printNoPrefix("==========step1:create table") tdLog.printNoPrefix("==========step1:create table")
self.__create_tb() self.__create_tb()
@ -344,10 +345,9 @@ class TDTestCase:
tdLog.printNoPrefix("==========step3:all check") tdLog.printNoPrefix("==========step3:all check")
self.all_test() self.all_test()
tdDnodes.stop(1) tdSql.execute(f"flush database {DBNAME}")
tdDnodes.start(1)
tdSql.execute("use db") tdSql.execute(f"use {DBNAME}")
tdLog.printNoPrefix("==========step4:after wal, all check again ") tdLog.printNoPrefix("==========step4:after wal, all check again ")
self.all_test() self.all_test()

39
tests/system-test/2-query/length.py
View File

@ -19,6 +19,7 @@ TS_COL = "c10"
UN_CHAR_COL = [INT_COL, BINT_COL, SINT_COL, TINT_COL, FLOAT_COL, DOUBLE_COL, BOOL_COL, ] UN_CHAR_COL = [INT_COL, BINT_COL, SINT_COL, TINT_COL, FLOAT_COL, DOUBLE_COL, BOOL_COL, ]
CHAR_COL = [ BINARY_COL, NCHAR_COL, ] CHAR_COL = [ BINARY_COL, NCHAR_COL, ]
TS_TYPE_COL = [TS_COL] TS_TYPE_COL = [TS_COL]
DBNAME = "db"
class TDTestCase: class TDTestCase:
@ -102,16 +103,16 @@ class TDTestCase:
return sqls return sqls
def __test_current(self): def __test_current(self, dbname=DBNAME):
tdLog.printNoPrefix("==========current sql condition check , must return query ok==========") tdLog.printNoPrefix("==========current sql condition check , must return query ok==========")
tbname = ["ct1", "ct2", "ct4", "t1", "stb1"] tbname = [f"{dbname}.ct1", f"{dbname}.ct2", f"{dbname}.ct4", f"{dbname}.nt1", f"{dbname}.stb1"]
for tb in tbname: for tb in tbname:
self.__length_current_check(tb) self.__length_current_check(tb)
tdLog.printNoPrefix(f"==========current sql condition check in {tb} over==========") tdLog.printNoPrefix(f"==========current sql condition check in {tb} over==========")
def __test_error(self): def __test_error(self, dbname=DBNAME):
tdLog.printNoPrefix("==========err sql condition check , must return error==========") tdLog.printNoPrefix("==========err sql condition check , must return error==========")
tbname = ["ct1", "ct2", "ct4", "t1", "stb1"] tbname = [f"{dbname}.ct1", f"{dbname}.ct2", f"{dbname}.ct4", f"{dbname}.nt1", f"{dbname}.stb1"]
for tb in tbname: for tb in tbname:
for errsql in self.__length_err_check(tb): for errsql in self.__length_err_check(tb):
@ -124,17 +125,16 @@ class TDTestCase:
self.__test_error() self.__test_error()
def __create_tb(self): def __create_tb(self, dbname=DBNAME):
tdSql.prepare()
tdLog.printNoPrefix("==========step1:create table") tdLog.printNoPrefix("==========step1:create table")
create_stb_sql = f'''create table stb1( create_stb_sql = f'''create table {dbname}.stb1(
ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint, ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint,
{FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool,
{BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp
) tags (t1 int) ) tags (t1 int)
''' '''
create_ntb_sql = f'''create table t1( create_ntb_sql = f'''create table {dbname}.nt1(
ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint, ts timestamp, {INT_COL} int, {BINT_COL} bigint, {SINT_COL} smallint, {TINT_COL} tinyint,
{FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool, {FLOAT_COL} float, {DOUBLE_COL} double, {BOOL_COL} bool,
{BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp {BINARY_COL} binary(16), {NCHAR_COL} nchar(32), {TS_COL} timestamp
@ -144,29 +144,29 @@ class TDTestCase:
tdSql.execute(create_ntb_sql) tdSql.execute(create_ntb_sql)
for i in range(4): for i in range(4):
tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )') tdSql.execute(f'create table {dbname}.ct{i+1} using {dbname}.stb1 tags ( {i+1} )')
def __insert_data(self, rows): def __insert_data(self, rows, dbname=DBNAME):
now_time = int(datetime.datetime.timestamp(datetime.datetime.now()) * 1000) now_time = int(datetime.datetime.timestamp(datetime.datetime.now()) * 1000)
for i in range(rows): for i in range(rows):
tdSql.execute( 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 {dbname}.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( 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 {dbname}.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( 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 {dbname}.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( tdSql.execute(
f'''insert into ct1 values f'''insert into {dbname}.ct1 values
( { now_time - rows * 5 }, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar0', { now_time + 8 } ) ( { now_time - rows * 5 }, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar0', { now_time + 8 } )
( { now_time + 10000 }, { rows }, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar9', { now_time + 9 } ) ( { now_time + 10000 }, { rows }, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar9', { now_time + 9 } )
''' '''
) )
tdSql.execute( tdSql.execute(
f'''insert into ct4 values f'''insert into {dbname}.ct4 values
( { now_time - rows * 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 )
( { now_time - rows * 3888000000+ 10800000 }, 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 + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
@ -182,7 +182,7 @@ class TDTestCase:
) )
tdSql.execute( tdSql.execute(
f'''insert into ct2 values f'''insert into {dbname}.ct2 values
( { now_time - rows * 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 )
( { now_time - rows * 3888000000+ 10800000 }, 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 + 7776000000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
@ -198,13 +198,13 @@ class TDTestCase:
) )
for i in range(rows): for i in range(rows):
insert_data = f'''insert into t1 values insert_data = f'''insert into {dbname}.nt1 values
( { now_time - i * 3600000 }, {i}, {i * 11111}, { i % 32767 }, { i % 127}, { i * 1.11111 }, { i * 1000.1111 }, { i % 2}, ( { 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 } )
''' '''
tdSql.execute(insert_data) tdSql.execute(insert_data)
tdSql.execute( tdSql.execute(
f'''insert into t1 values f'''insert into {dbname}.nt1 values
( { now_time + 10800000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ( { 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 // 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 - rows * 3600000 }, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
@ -233,8 +233,7 @@ class TDTestCase:
tdLog.printNoPrefix("==========step3:all check") tdLog.printNoPrefix("==========step3:all check")
self.all_test() self.all_test()
tdDnodes.stop(1) tdSql.execute("flush database db")
tdDnodes.start(1)
tdSql.execute("use db") tdSql.execute("use db")

417
tests/system-test/2-query/log.py
View File

@ -10,48 +10,46 @@ from util.cases import *
class TDTestCase: class TDTestCase:
updatecfgDict = {'debugFlag': 143 ,"cDebugFlag":143,"uDebugFlag":143 ,"rpcDebugFlag":143 , "tmrDebugFlag":143 ,
"jniDebugFlag":143 ,"simDebugFlag":143,"dDebugFlag":143, "dDebugFlag":143,"vDebugFlag":143,"mDebugFlag":143,"qDebugFlag":143,
"wDebugFlag":143,"sDebugFlag":143,"tsdbDebugFlag":143,"tqDebugFlag":143 ,"fsDebugFlag":143 ,"udfDebugFlag":143}
def init(self, conn, logSql): def init(self, conn, logSql):
tdLog.debug(f"start to excute {__file__}") tdLog.debug(f"start to excute {__file__}")
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def prepare_datas(self): def prepare_datas(self, dbname="db"):
tdSql.execute( tdSql.execute(
'''create table stb1 f'''create table {dbname}.stb1
(ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp) (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp)
tags (t1 int) tags (t1 int)
''' '''
) )
tdSql.execute( tdSql.execute(
''' f'''
create table t1 create table {dbname}.t1
(ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp) (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp)
''' '''
) )
for i in range(4): for i in range(4):
tdSql.execute(f'create table ct{i+1} using stb1 tags ( {i+1} )') tdSql.execute(f'create table {dbname}.ct{i+1} using {dbname}.stb1 tags ( {i+1} )')
for i in range(9): for i in range(9):
tdSql.execute( tdSql.execute(
f"insert into ct1 values ( now()-{i*10}s, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a )" f"insert into {dbname}.ct1 values ( now()-{i*10}s, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a )"
) )
tdSql.execute( tdSql.execute(
f"insert into ct4 values ( now()-{i*90}d, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a )" f"insert into {dbname}.ct4 values ( now()-{i*90}d, {1*i}, {11111*i}, {111*i}, {11*i}, {1.11*i}, {11.11*i}, {i%2}, 'binary{i}', 'nchar{i}', now()+{1*i}a )"
) )
tdSql.execute("insert into ct1 values (now()-45s, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar0', now()+8a )") tdSql.execute(f"insert into {dbname}.ct1 values (now()-45s, 0, 0, 0, 0, 0, 0, 0, 'binary0', 'nchar0', now()+8a )")
tdSql.execute("insert into ct1 values (now()+10s, 9, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a )") tdSql.execute(f"insert into {dbname}.ct1 values (now()+10s, 9, -99999, -999, -99, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a )")
tdSql.execute("insert into ct1 values (now()+15s, 9, -99999, -999, -99, -9.99, NULL, 1, 'binary9', 'nchar9', now()+9a )") tdSql.execute(f"insert into {dbname}.ct1 values (now()+15s, 9, -99999, -999, -99, -9.99, NULL, 1, 'binary9', 'nchar9', now()+9a )")
tdSql.execute("insert into ct1 values (now()+20s, 9, -99999, -999, NULL, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a )") tdSql.execute(f"insert into {dbname}.ct1 values (now()+20s, 9, -99999, -999, NULL, -9.99, -99.99, 1, 'binary9', 'nchar9', now()+9a )")
tdSql.execute("insert into ct4 values (now()-810d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ") tdSql.execute(f"insert into {dbname}.ct4 values (now()-810d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
tdSql.execute("insert into ct4 values (now()-400d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ") tdSql.execute(f"insert into {dbname}.ct4 values (now()-400d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
tdSql.execute("insert into ct4 values (now()+90d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ") tdSql.execute(f"insert into {dbname}.ct4 values (now()+90d, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ")
tdSql.execute( tdSql.execute(
f'''insert into t1 values f'''insert into {dbname}.t1 values
( '2020-04-21 01:01:01.000', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL ) ( '2020-04-21 01:01:01.000', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL )
( '2020-10-21 01:01:01.000', 1, 11111, 111, 11, 1.11, 11.11, 1, "binary1", "nchar1", now()+1a ) ( '2020-10-21 01:01:01.000', 1, 11111, 111, 11, 1.11, 11.11, 1, "binary1", "nchar1", now()+1a )
( '2020-12-31 01:01:01.000', 2, 22222, 222, 22, 2.22, 22.22, 0, "binary2", "nchar2", now()+2a ) ( '2020-12-31 01:01:01.000', 2, 22222, 222, 22, 2.22, 22.22, 0, "binary2", "nchar2", now()+2a )
@ -185,68 +183,68 @@ class TDTestCase:
else: else:
tdLog.info("log value check pass , it work as expected ,sql is \"%s\" "%log_query ) tdLog.info("log value check pass , it work as expected ,sql is \"%s\" "%log_query )
def test_errors(self): def test_errors(self, dbname="db"):
error_sql_lists = [ error_sql_lists = [
"select log from t1", f"select log from {dbname}.t1",
# "select log(-+--+c1 ,2) from t1", # f"select log(-+--+c1 ,2) from {dbname}.t1",
# "select +-log(c1,2) from t1", # f"select +-log(c1,2) from {dbname}.t1",
# "select ++-log(c1,2) from t1", # f"select ++-log(c1,2) from {dbname}.t1",
# "select ++--log(c1,2) from t1", # f"select ++--log(c1,2) from {dbname}.t1",
# "select - -log(c1,2)*0 from t1", # f"select - -log(c1,2)*0 from {dbname}.t1",
# "select log(tbname+1,2) from t1 ", # f"select log(tbname+1,2) from {dbname}.t1 ",
"select log(123--123,2)==1 from t1", f"select log(123--123,2)==1 from {dbname}.t1",
"select log(c1,2) as 'd1' from t1", f"select log(c1,2) as 'd1' from {dbname}.t1",
"select log(c1 ,c2 ,2) from t1", f"select log(c1 ,c2 ,2) from {dbname}.t1",
"select log(c1 ,NULL ,2) from t1", f"select log(c1 ,NULL ,2) from {dbname}.t1",
"select log(, 2) from t1;", f"select log(, 2) from {dbname}.t1;",
"select log(log(c1, 2) ab from t1)", f"select log(log(c1, 2) ab from {dbname}.t1)",
"select log(c1 ,2 ) as int from t1", f"select log(c1 ,2 ) as int from {dbname}.t1",
"select log from stb1", f"select log from {dbname}.stb1",
# "select log(-+--+c1) from stb1", # f"select log(-+--+c1) from {dbname}.stb1",
# "select +-log(c1) from stb1", # f"select +-log(c1) from {dbname}.stb1",
# "select ++-log(c1) from stb1", # f"select ++-log(c1) from {dbname}.stb1",
# "select ++--log(c1) from stb1", # f"select ++--log(c1) from {dbname}.stb1",
# "select - -log(c1)*0 from stb1", # f"select - -log(c1)*0 from {dbname}.stb1",
# "select log(tbname+1) from stb1 ", # f"select log(tbname+1) from {dbname}.stb1 ",
"select log(123--123 ,2)==1 from stb1", f"select log(123--123 ,2)==1 from {dbname}.stb1",
"select log(c1 ,2) as 'd1' from stb1", f"select log(c1 ,2) as 'd1' from {dbname}.stb1",
"select log(c1 ,c2 ,2 ) from stb1", f"select log(c1 ,c2 ,2 ) from {dbname}.stb1",
"select log(c1 ,NULL,2) from stb1", f"select log(c1 ,NULL,2) from {dbname}.stb1",
"select log(,) from stb1;", f"select log(,) from {dbname}.stb1;",
"select log(log(c1 , 2) ab from stb1)", f"select log(log(c1 , 2) ab from {dbname}.stb1)",
"select log(c1 , 2) as int from stb1" f"select log(c1 , 2) as int from {dbname}.stb1"
] ]
for error_sql in error_sql_lists: for error_sql in error_sql_lists:
tdSql.error(error_sql) tdSql.error(error_sql)
def support_types(self): def support_types(self, dbname="db"):
type_error_sql_lists = [ type_error_sql_lists = [
"select log(ts ,2 ) from t1" , f"select log(ts ,2 ) from {dbname}.t1" ,
"select log(c7,c2 ) from t1", f"select log(c7,c2 ) from {dbname}.t1",
"select log(c8,c1 ) from t1", f"select log(c8,c1 ) from {dbname}.t1",
"select log(c9,c2 ) from t1", f"select log(c9,c2 ) from {dbname}.t1",
"select log(ts,c7 ) from ct1" , f"select log(ts,c7 ) from {dbname}.ct1" ,
"select log(c7,c9 ) from ct1", f"select log(c7,c9 ) from {dbname}.ct1",
"select log(c8,c2 ) from ct1", f"select log(c8,c2 ) from {dbname}.ct1",
"select log(c9,c1 ) from ct1", f"select log(c9,c1 ) from {dbname}.ct1",
"select log(ts,2 ) from ct3" , f"select log(ts,2 ) from {dbname}.ct3" ,
"select log(c7,2 ) from ct3", f"select log(c7,2 ) from {dbname}.ct3",
"select log(c8,2 ) from ct3", f"select log(c8,2 ) from {dbname}.ct3",
"select log(c9,2 ) from ct3", f"select log(c9,2 ) from {dbname}.ct3",
"select log(ts,2 ) from ct4" , f"select log(ts,2 ) from {dbname}.ct4" ,
"select log(c7,2 ) from ct4", f"select log(c7,2 ) from {dbname}.ct4",
"select log(c8,2 ) from ct4", f"select log(c8,2 ) from {dbname}.ct4",
"select log(c9,2 ) from ct4", f"select log(c9,2 ) from {dbname}.ct4",
"select log(ts,2 ) from stb1" , f"select log(ts,2 ) from {dbname}.stb1" ,
"select log(c7,2 ) from stb1", f"select log(c7,2 ) from {dbname}.stb1",
"select log(c8,2 ) from stb1", f"select log(c8,2 ) from {dbname}.stb1",
"select log(c9,2 ) from stb1" , f"select log(c9,2 ) from {dbname}.stb1" ,
"select log(ts,2 ) from stbbb1" , f"select log(ts,2 ) from {dbname}.stbbb1" ,
"select log(c7,2 ) from stbbb1", f"select log(c7,2 ) from {dbname}.stbbb1",
"select log(ts,2 ) from tbname", f"select log(ts,2 ) from {dbname}.tbname",
"select log(c9,2 ) from tbname" f"select log(c9,2 ) from {dbname}.tbname"
] ]
@ -255,98 +253,88 @@ class TDTestCase:
type_sql_lists = [ type_sql_lists = [
"select log(c1,2 ) from t1", f"select log(c1,2 ) from {dbname}.t1",
"select log(c2,2 ) from t1", f"select log(c2,2 ) from {dbname}.t1",
"select log(c3,2 ) from t1", f"select log(c3,2 ) from {dbname}.t1",
"select log(c4,2 ) from t1", f"select log(c4,2 ) from {dbname}.t1",
"select log(c5,2 ) from t1", f"select log(c5,2 ) from {dbname}.t1",
"select log(c6,2 ) from t1", f"select log(c6,2 ) from {dbname}.t1",
"select log(c1,2 ) from ct1", f"select log(c1,2 ) from {dbname}.ct1",
"select log(c2,2 ) from ct1", f"select log(c2,2 ) from {dbname}.ct1",
"select log(c3,2 ) from ct1", f"select log(c3,2 ) from {dbname}.ct1",
"select log(c4,2 ) from ct1", f"select log(c4,2 ) from {dbname}.ct1",
"select log(c5,2 ) from ct1", f"select log(c5,2 ) from {dbname}.ct1",
"select log(c6,2 ) from ct1", f"select log(c6,2 ) from {dbname}.ct1",
"select log(c1,2 ) from ct3", f"select log(c1,2 ) from {dbname}.ct3",
"select log(c2,2 ) from ct3", f"select log(c2,2 ) from {dbname}.ct3",
"select log(c3,2 ) from ct3", f"select log(c3,2 ) from {dbname}.ct3",
"select log(c4,2 ) from ct3", f"select log(c4,2 ) from {dbname}.ct3",
"select log(c5,2 ) from ct3", f"select log(c5,2 ) from {dbname}.ct3",
"select log(c6,2 ) from ct3", f"select log(c6,2 ) from {dbname}.ct3",
"select log(c1,2 ) from stb1", f"select log(c1,2 ) from {dbname}.stb1",
"select log(c2,2 ) from stb1", f"select log(c2,2 ) from {dbname}.stb1",
"select log(c3,2 ) from stb1", f"select log(c3,2 ) from {dbname}.stb1",
"select log(c4,2 ) from stb1", f"select log(c4,2 ) from {dbname}.stb1",
"select log(c5,2 ) from stb1", f"select log(c5,2 ) from {dbname}.stb1",
"select log(c6,2 ) from stb1", f"select log(c6,2 ) from {dbname}.stb1",
"select log(c6,2) as alisb from stb1", f"select log(c6,2) as alisb from {dbname}.stb1",
"select log(c6,2) alisb from stb1", f"select log(c6,2) alisb from {dbname}.stb1",
] ]
for type_sql in type_sql_lists: for type_sql in type_sql_lists:
tdSql.query(type_sql) tdSql.query(type_sql)
def basic_log_function(self): def basic_log_function(self, dbname="db"):
# basic query # basic query
tdSql.query("select c1 from ct3") tdSql.query(f"select c1 from {dbname}.ct3")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select c1 from t1") tdSql.query(f"select c1 from {dbname}.t1")
tdSql.checkRows(12) tdSql.checkRows(12)
tdSql.query("select c1 from stb1") tdSql.query(f"select c1 from {dbname}.stb1")
tdSql.checkRows(25) tdSql.checkRows(25)
# used for empty table , ct3 is empty # used for empty table , ct3 is empty
tdSql.query("select log(c1 ,2) from ct3") tdSql.query(f"select log(c1 ,2) from {dbname}.ct3")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select log(c2 ,2) from ct3") tdSql.query(f"select log(c2 ,2) from {dbname}.ct3")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select log(c3 ,2) from ct3") tdSql.query(f"select log(c3 ,2) from {dbname}.ct3")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select log(c4 ,2) from ct3") tdSql.query(f"select log(c4 ,2) from {dbname}.ct3")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select log(c5 ,2) from ct3") tdSql.query(f"select log(c5 ,2) from {dbname}.ct3")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select log(c6 ,2) from ct3") tdSql.query(f"select log(c6 ,2) from {dbname}.ct3")
tdSql.checkRows(0) tdSql.checkRows(0)
# # used for regular table # # used for regular table
tdSql.query("select log(c1 ,2) from t1") tdSql.query(f"select log(c1 ,2) from {dbname}.t1")
tdSql.checkData(0, 0, None) tdSql.checkData(0, 0, None)
tdSql.checkData(1 , 0, 0.000000000) tdSql.checkData(1 , 0, 0.000000000)
tdSql.checkData(3 , 0, 1.584962501) tdSql.checkData(3 , 0, 1.584962501)
tdSql.checkData(5 , 0, None) tdSql.checkData(5 , 0, None)
tdSql.query("select log(c1) from t1") tdSql.query(f"select log(c1) from {dbname}.t1")
tdSql.checkData(0, 0, None) tdSql.checkData(0, 0, None)
tdSql.checkData(1 , 0, 0.000000000) tdSql.checkData(1 , 0, 0.000000000)
tdSql.checkData(2 , 0, 0.693147181) tdSql.checkData(2 , 0, 0.693147181)
tdSql.checkData(3 , 0, 1.098612289) tdSql.checkData(3 , 0, 1.098612289)
tdSql.checkData(4 , 0, 1.386294361) tdSql.checkData(4 , 0, 1.386294361)
tdSql.query("select c1, c2, c3 , c4, c5 from t1") self.check_result_auto_log( f"select c1, c2, c3 , c4, c5 from {dbname}.t1", f"select log(c1), log(c2) ,log(c3), log(c4), log(c5) from {dbname}.t1")
tdSql.checkData(1, 4, 1.11000) self.check_result_auto_log2( f"select c1, c2, c3 , c4, c5 from {dbname}.t1", f"select log(c1 ,2), log(c2 ,2) ,log(c3, 2), log(c4 ,2), log(c5 ,2) from {dbname}.t1")
tdSql.checkData(3, 3, 33) self.check_result_auto_log__10( f"select c1, c2, c3 , c4, c5 from {dbname}.t1", f"select log(c1 ,1), log(c2 ,1) ,log(c3, 1), log(c4 ,1), log(c5 ,1) from {dbname}.t1")
tdSql.checkData(5, 4, None) self.check_result_auto_log__10( f"select c1, c2, c3 , c4, c5 from {dbname}.t1", f"select log(c1 ,-10), log(c2 ,-10) ,log(c3, -10), log(c4 ,-10), log(c5 ,-10) from {dbname}.t1")
tdSql.query("select ts,c1, c2, c3 , c4, c5 from t1")
tdSql.checkData(1, 5, 1.11000)
tdSql.checkData(3, 4, 33)
tdSql.checkData(5, 5, None)
self.check_result_auto_log( "select c1, c2, c3 , c4, c5 from t1", "select log(c1), log(c2) ,log(c3), log(c4), log(c5) from t1")
self.check_result_auto_log2( "select c1, c2, c3 , c4, c5 from t1", "select log(c1 ,2), log(c2 ,2) ,log(c3, 2), log(c4 ,2), log(c5 ,2) from t1")
self.check_result_auto_log1( "select c1, c2, c3 , c4, c5 from t1", "select log(c1 ,1), log(c2 ,1) ,log(c3, 1), log(c4 ,1), log(c5 ,1) from t1")
self.check_result_auto_log__10( "select c1, c2, c3 , c4, c5 from t1", "select log(c1 ,-10), log(c2 ,-10) ,log(c3, -10), log(c4 ,-10), log(c5 ,-10) from t1")
# used for sub table # used for sub table
tdSql.query("select c1 ,log(c1 ,3) from ct1") tdSql.query(f"select c1 ,log(c1 ,3) from {dbname}.ct1")
tdSql.checkData(0, 1, 1.892789261) tdSql.checkData(0, 1, 1.892789261)
tdSql.checkData(1 , 1, 1.771243749) tdSql.checkData(1 , 1, 1.771243749)
tdSql.checkData(3 , 1, 1.464973521) tdSql.checkData(3 , 1, 1.464973521)
@ -354,19 +342,19 @@ class TDTestCase:
# test bug fix for log(c1,c2) # test bug fix for log(c1,c2)
tdSql.query("select c1, c2 ,log(c1,c2) from ct1") tdSql.query(f"select c1, c2 ,log(c1,c2) from {dbname}.ct1")
tdSql.checkData(0 , 2, 0.182485070) tdSql.checkData(0 , 2, 0.182485070)
tdSql.checkData(1 , 2, 0.172791608) tdSql.checkData(1 , 2, 0.172791608)
tdSql.checkData(2 , 2, 0.161311499) tdSql.checkData(2 , 2, 0.161311499)
tdSql.checkData(3 , 2, 0.147315235) tdSql.checkData(3 , 2, 0.147315235)
tdSql.checkData(4 , 2, None) tdSql.checkData(4 , 2, None)
self.check_result_auto_log( "select c1, c2, c3 , c4, c5 from ct1", "select log(c1), log(c2) ,log(c3), log(c4), log(c5) from ct1") self.check_result_auto_log( f"select c1, c2, c3 , c4, c5 from {dbname}.ct1", f"select log(c1), log(c2) ,log(c3), log(c4), log(c5) from {dbname}.ct1")
self.check_result_auto_log2( "select c1, c2, c3 , c4, c5 from ct1", "select log(c1,2), log(c2,2) ,log(c3,2), log(c4,2), log(c5,2) from ct1") self.check_result_auto_log2( f"select c1, c2, c3 , c4, c5 from {dbname}.ct1", f"select log(c1,2), log(c2,2) ,log(c3,2), log(c4,2), log(c5,2) from {dbname}.ct1")
self.check_result_auto_log__10( "select c1, c2, c3 , c4, c5 from ct1", "select log(c1,-10), log(c2,-10) ,log(c3,-10), log(c4,-10), log(c5,-10) from ct1") self.check_result_auto_log__10( f"select c1, c2, c3 , c4, c5 from {dbname}.ct1", f"select log(c1,-10), log(c2,-10) ,log(c3,-10), log(c4,-10), log(c5,-10) from {dbname}.ct1")
# nest query for log functions # nest query for log functions
tdSql.query("select c1 , log(c1,3) ,log(log(c1,3),3) , log(log(log(c1,3),3),3) from ct1;") tdSql.query(f"select c1 , log(c1,3) ,log(log(c1,3),3) , log(log(log(c1,3),3),3) from {dbname}.ct1;")
tdSql.checkData(0 , 0 , 8) tdSql.checkData(0 , 0 , 8)
tdSql.checkData(0 , 1 , 1.892789261) tdSql.checkData(0 , 1 , 1.892789261)
tdSql.checkData(0 , 2 , 0.580779541) tdSql.checkData(0 , 2 , 0.580779541)
@ -384,36 +372,36 @@ class TDTestCase:
# # used for stable table # # used for stable table
tdSql.query("select log(c1, 2) from stb1") tdSql.query(f"select log(c1, 2) from {dbname}.stb1")
tdSql.checkRows(25) tdSql.checkRows(25)
# used for not exists table # used for not exists table
tdSql.error("select log(c1, 2) from stbbb1") tdSql.error(f"select log(c1, 2) from {dbname}.stbbb1")
tdSql.error("select log(c1, 2) from tbname") tdSql.error(f"select log(c1, 2) from {dbname}tbname")
tdSql.error("select log(c1, 2) from ct5") tdSql.error(f"select log(c1, 2) from {dbname}.ct5")
# mix with common col # mix with common col
tdSql.query("select c1, log(c1 ,2) from ct1") tdSql.query(f"select c1, log(c1 ,2) from {dbname}.ct1")
tdSql.checkData(0 , 0 ,8) tdSql.checkData(0 , 0 ,8)
tdSql.checkData(0 , 1 ,3.000000000) tdSql.checkData(0 , 1 ,3.000000000)
tdSql.checkData(4 , 0 ,0) tdSql.checkData(4 , 0 ,0)
tdSql.checkData(4 , 1 ,None) tdSql.checkData(4 , 1 ,None)
tdSql.query("select c1, log(c1,2) from ct4") tdSql.query(f"select c1, log(c1,2) from {dbname}.ct4")
tdSql.checkData(0 , 0 , None) tdSql.checkData(0 , 0 , None)
tdSql.checkData(0 , 1 ,None) tdSql.checkData(0 , 1 ,None)
tdSql.checkData(4 , 0 ,5) tdSql.checkData(4 , 0 ,5)
tdSql.checkData(4 , 1 ,2.321928095) tdSql.checkData(4 , 1 ,2.321928095)
tdSql.checkData(5 , 0 ,None) tdSql.checkData(5 , 0 ,None)
tdSql.checkData(5 , 1 ,None) tdSql.checkData(5 , 1 ,None)
tdSql.query("select c1, log(c1 ,2 ) from ct4 ") tdSql.query(f"select c1, log(c1 ,2 ) from {dbname}.ct4 ")
tdSql.checkData(0 , 0 ,None) tdSql.checkData(0 , 0 ,None)
tdSql.checkData(0 , 1 ,None) tdSql.checkData(0 , 1 ,None)
tdSql.checkData(4 , 0 ,5) tdSql.checkData(4 , 0 ,5)
tdSql.checkData(4 , 1 ,2.321928095) tdSql.checkData(4 , 1 ,2.321928095)
# mix with common functions # mix with common functions
tdSql.query("select c1, log(c1 ,2),c5, log(c5 ,2) from ct4 ") tdSql.query(f"select c1, log(c1 ,2),c5, log(c5 ,2) from {dbname}.ct4 ")
tdSql.checkData(0 , 0 ,None) tdSql.checkData(0 , 0 ,None)
tdSql.checkData(0 , 1 ,None) tdSql.checkData(0 , 1 ,None)
tdSql.checkData(0 , 2 ,None) tdSql.checkData(0 , 2 ,None)
@ -424,34 +412,34 @@ class TDTestCase:
tdSql.checkData(3 , 2 ,6.66000) tdSql.checkData(3 , 2 ,6.66000)
tdSql.checkData(3 , 3 ,2.735522144) tdSql.checkData(3 , 3 ,2.735522144)
tdSql.query("select c1, log(c1,1),c5, floor(c5 ) from stb1 ") tdSql.query(f"select c1, log(c1,1),c5, floor(c5 ) from {dbname}.stb1 ")
# # mix with agg functions , not support # # mix with agg functions , not support
tdSql.error("select c1, log(c1 ,2),c5, count(c5) from stb1 ") tdSql.error(f"select c1, log(c1 ,2),c5, count(c5) from {dbname}.stb1 ")
tdSql.error("select c1, log(c1 ,2),c5, count(c5) from ct1 ") tdSql.error(f"select c1, log(c1 ,2),c5, count(c5) from {dbname}.ct1 ")
tdSql.error("select log(c1 ,2), count(c5) from stb1 ") tdSql.error(f"select log(c1 ,2), count(c5) from {dbname}.stb1 ")
tdSql.error("select log(c1 ,2), count(c5) from ct1 ") tdSql.error(f"select log(c1 ,2), count(c5) from {dbname}.ct1 ")
tdSql.error("select c1, count(c5) from ct1 ") tdSql.error(f"select c1, count(c5) from {dbname}.ct1 ")
tdSql.error("select c1, count(c5) from stb1 ") tdSql.error(f"select c1, count(c5) from {dbname}.stb1 ")
# agg functions mix with agg functions # agg functions mix with agg functions
tdSql.query("select max(c5), count(c5) from stb1") tdSql.query(f"select max(c5), count(c5) from {dbname}.stb1")
tdSql.query("select max(c5), count(c5) from ct1") tdSql.query(f"select max(c5), count(c5) from {dbname}.ct1")
# bug fix for count # bug fix for count
tdSql.query("select count(c1) from ct4 ") tdSql.query(f"select count(c1) from {dbname}.ct4 ")
tdSql.checkData(0,0,9) tdSql.checkData(0,0,9)
tdSql.query("select count(*) from ct4 ") tdSql.query(f"select count(*) from {dbname}.ct4 ")
tdSql.checkData(0,0,12) tdSql.checkData(0,0,12)
tdSql.query("select count(c1) from stb1 ") tdSql.query(f"select count(c1) from {dbname}.stb1 ")
tdSql.checkData(0,0,22) tdSql.checkData(0,0,22)
tdSql.query("select count(*) from stb1 ") tdSql.query(f"select count(*) from {dbname}.stb1 ")
tdSql.checkData(0,0,25) tdSql.checkData(0,0,25)
# # bug fix for compute # # bug fix for compute
tdSql.query("select c1, log(c1 ,2) -0 ,log(c1-4 ,2)-0 from ct4 ") tdSql.query(f"select c1, log(c1 ,2) -0 ,log(c1-4 ,2)-0 from {dbname}.ct4 ")
tdSql.checkData(0, 0, None) tdSql.checkData(0, 0, None)
tdSql.checkData(0, 1, None) tdSql.checkData(0, 1, None)
tdSql.checkData(0, 2, None) tdSql.checkData(0, 2, None)
@ -459,7 +447,7 @@ class TDTestCase:
tdSql.checkData(1, 1, 3.000000000) tdSql.checkData(1, 1, 3.000000000)
tdSql.checkData(1, 2, 2.000000000) tdSql.checkData(1, 2, 2.000000000)
tdSql.query(" select c1, log(c1 ,2) -0 ,log(c1-0.1 ,2)-0.1 from ct4") tdSql.query(f"select c1, log(c1 ,2) -0 ,log(c1-0.1 ,2)-0.1 from {dbname}.ct4")
tdSql.checkData(0, 0, None) tdSql.checkData(0, 0, None)
tdSql.checkData(0, 1, None) tdSql.checkData(0, 1, None)
tdSql.checkData(0, 2, None) tdSql.checkData(0, 2, None)
@ -467,88 +455,87 @@ class TDTestCase:
tdSql.checkData(1, 1, 3.000000000) tdSql.checkData(1, 1, 3.000000000)
tdSql.checkData(1, 2, 2.881852653) tdSql.checkData(1, 2, 2.881852653)
tdSql.query("select c1, log(c1, -10), c2, log(c2, -10), c3, log(c3, -10) from ct1") tdSql.query(f"select c1, log(c1, -10), c2, log(c2, -10), c3, log(c3, -10) from {dbname}.ct1")
def test_big_number(self): def test_big_number(self, dbname="db"):
tdSql.query("select c1, log(c1, 100000000) from ct1") # bigint to double data overflow tdSql.query(f"select c1, log(c1, 100000000) from {dbname}.ct1") # bigint to double data overflow
tdSql.checkData(0, 1, 0.112886248) tdSql.checkData(0, 1, 0.112886248)
tdSql.checkData(1, 1, 0.105637255) tdSql.checkData(1, 1, 0.105637255)
tdSql.checkData(4, 1, None) tdSql.checkData(4, 1, None)
tdSql.query("select c1, log(c1, 10000000000000) from ct1") # bigint to double data overflow tdSql.query(f"select c1, log(c1, 10000000000000) from {dbname}.ct1") # bigint to double data overflow
tdSql.checkData(0, 1, 0.069468461) tdSql.checkData(0, 1, 0.069468461)
tdSql.checkData(1, 1, 0.065007542) tdSql.checkData(1, 1, 0.065007542)
tdSql.checkData(4, 1, None) tdSql.checkData(4, 1, None)
tdSql.query("select c1, log(c1, 10000000000000000000000000) from ct1") # bigint to double data overflow tdSql.query(f"select c1, log(c1, 10000000000000000000000000) from {dbname}.ct1") # bigint to double data overflow
tdSql.query("select c1, log(c1, 10000000000000000000000000.0) from ct1") # 10000000000000000000000000.0 is a double value tdSql.query(f"select c1, log(c1, 10000000000000000000000000.0) from {dbname}.ct1") # 10000000000000000000000000.0 is a double value
tdSql.checkData(0, 1, 0.036123599) tdSql.checkData(0, 1, 0.036123599)
tdSql.checkData(1, 1, 0.033803922) tdSql.checkData(1, 1, 0.033803922)
tdSql.checkData(4, 1, None) tdSql.checkData(4, 1, None)
tdSql.query("select c1, log(c1, 10000000000000000000000000000000000) from ct1") # bigint to double data overflow tdSql.query(f"select c1, log(c1, 10000000000000000000000000000000000) from {dbname}.ct1") # bigint to double data overflow
tdSql.query("select c1, log(c1, 10000000000000000000000000000000000.0) from ct1") # 10000000000000000000000000.0 is a double value tdSql.query(f"select c1, log(c1, 10000000000000000000000000000000000.0) from {dbname}.ct1") # 10000000000000000000000000.0 is a double value
tdSql.checkData(0, 1, 0.026561470) tdSql.checkData(0, 1, 0.026561470)
tdSql.checkData(1, 1, 0.024855825) tdSql.checkData(1, 1, 0.024855825)
tdSql.checkData(4, 1, None) tdSql.checkData(4, 1, None)
tdSql.query("select c1, log(c1, 10000000000000000000000000000000000000000) from ct1") # bigint to double data overflow tdSql.query(f"select c1, log(c1, 10000000000000000000000000000000000000000) from {dbname}.ct1") # bigint to double data overflow
tdSql.query("select c1, log(c1, 10000000000000000000000000000000000000000.0) from ct1") # 10000000000000000000000000.0 is a double value tdSql.query(f"select c1, log(c1, 10000000000000000000000000000000000000000.0) from {dbname}.ct1") # 10000000000000000000000000.0 is a double value
tdSql.checkData(0, 1, 0.022577250) tdSql.checkData(0, 1, 0.022577250)
tdSql.checkData(1, 1, 0.021127451) tdSql.checkData(1, 1, 0.021127451)
tdSql.checkData(4, 1, None) tdSql.checkData(4, 1, None)
tdSql.query("select c1, log(c1, 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) from ct1") # bigint to double data overflow tdSql.query(f"select c1, log(c1, 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) from {dbname}.ct1") # bigint to double data overflow
def log_base_test(self): def log_base_test(self, dbname="db"):
# base is an regular number ,int or double # base is an regular number ,int or double
tdSql.query("select c1, log(c1, 2) from ct1") tdSql.query(f"select c1, log(c1, 2) from {dbname}.ct1")
tdSql.checkData(0, 1,3.000000000) tdSql.checkData(0, 1,3.000000000)
tdSql.query("select c1, log(c1, 2.0) from ct1") tdSql.query(f"select c1, log(c1, 2.0) from {dbname}.ct1")
tdSql.checkData(0, 1, 3.000000000) tdSql.checkData(0, 1, 3.000000000)
tdSql.query("select c1, log(1, 2.0) from ct1") tdSql.query(f"select c1, log(1, 2.0) from {dbname}.ct1")
tdSql.checkData(0, 1, 0.000000000) tdSql.checkData(0, 1, 0.000000000)
tdSql.checkRows(13) tdSql.checkRows(13)
# # bug for compute in functions # # bug for compute in functions
# tdSql.query("select c1, abs(1/0) from ct1") # tdSql.query(f"select c1, abs(1/0) from {dbname}.ct1")
# tdSql.checkData(0, 0, 8) # tdSql.checkData(0, 0, 8)
# tdSql.checkData(0, 1, 1) # tdSql.checkData(0, 1, 1)
tdSql.query("select c1, log(1, 2.0) from ct1") tdSql.query(f"select c1, log(1, 2.0) from {dbname}.ct1")
tdSql.checkData(0, 1, 0.000000000) tdSql.checkData(0, 1, 0.000000000)
tdSql.checkRows(13) tdSql.checkRows(13)
# two cols start log(x,y) # two cols start log(x,y)
tdSql.query("select c1,c2, log(c1,c2) from ct1") tdSql.query(f"select c1,c2, log(c1,c2) from {dbname}.ct1")
tdSql.checkData(0, 2, 0.182485070) tdSql.checkData(0, 2, 0.182485070)
tdSql.checkData(1, 2, 0.172791608) tdSql.checkData(1, 2, 0.172791608)
tdSql.checkData(4, 2, None) tdSql.checkData(4, 2, None)
tdSql.query("select c1,c2, log(c2,c1) from ct1") tdSql.query(f"select c1,c2, log(c2,c1) from {dbname}.ct1")
tdSql.checkData(0, 2, 5.479900349) tdSql.checkData(0, 2, 5.479900349)
tdSql.checkData(1, 2, 5.787318105) tdSql.checkData(1, 2, 5.787318105)
tdSql.checkData(4, 2, None) tdSql.checkData(4, 2, None)
tdSql.query("select c1, log(2.0 , c1) from ct1") tdSql.query(f"select c1, log(2.0 , c1) from {dbname}.ct1")
tdSql.checkData(0, 1, 0.333333333) tdSql.checkData(0, 1, 0.333333333)
tdSql.checkData(1, 1, 0.356207187) tdSql.checkData(1, 1, 0.356207187)
tdSql.checkData(4, 1, None) tdSql.checkData(4, 1, None)
tdSql.query("select c1, log(2.0 , ceil(abs(c1))) from ct1") tdSql.query(f"select c1, log(2.0 , ceil(abs(c1))) from {dbname}.ct1")
tdSql.checkData(0, 1, 0.333333333) tdSql.checkData(0, 1, 0.333333333)
tdSql.checkData(1, 1, 0.356207187) tdSql.checkData(1, 1, 0.356207187)
tdSql.checkData(4, 1, None) tdSql.checkData(4, 1, None)
def abs_func_filter(self): def abs_func_filter(self, dbname="db"):
tdSql.execute("use db") tdSql.query(f"select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from {dbname}.ct4 where c1>5 ")
tdSql.query("select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from ct4 where c1>5 ")
tdSql.checkRows(3) tdSql.checkRows(3)
tdSql.checkData(0,0,8) tdSql.checkData(0,0,8)
tdSql.checkData(0,1,8.000000000) tdSql.checkData(0,1,8.000000000)
@ -556,7 +543,7 @@ class TDTestCase:
tdSql.checkData(0,3,7.900000000) tdSql.checkData(0,3,7.900000000)
tdSql.checkData(0,4,3.000000000) tdSql.checkData(0,4,3.000000000)
tdSql.query("select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from ct4 where c1=5 ") tdSql.query(f"select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from {dbname}.ct4 where c1=5 ")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.checkData(0,0,5) tdSql.checkData(0,0,5)
tdSql.checkData(0,1,5.000000000) tdSql.checkData(0,1,5.000000000)
@ -564,15 +551,7 @@ class TDTestCase:
tdSql.checkData(0,3,4.900000000) tdSql.checkData(0,3,4.900000000)
tdSql.checkData(0,4,2.000000000) tdSql.checkData(0,4,2.000000000)
tdSql.query("select c1, abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from ct4 where c1=5 ") tdSql.query(f"select c1,c2 , abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from {dbname}.ct4 where c1>log(c1,2) limit 1 ")
tdSql.checkRows(1)
tdSql.checkData(0,0,5)
tdSql.checkData(0,1,5.000000000)
tdSql.checkData(0,2,5.000000000)
tdSql.checkData(0,3,4.900000000)
tdSql.checkData(0,4,2.000000000)
tdSql.query("select c1,c2 , abs(c1) -0 ,ceil(c1-0.1)-0 ,floor(c1+0.1)-0.1 ,ceil(log(c1,2)-0.5) from ct4 where c1>log(c1,2) limit 1 ")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.checkData(0,0,8) tdSql.checkData(0,0,8)
tdSql.checkData(0,1,88888) tdSql.checkData(0,1,88888)
@ -581,46 +560,43 @@ class TDTestCase:
tdSql.checkData(0,4,7.900000000) tdSql.checkData(0,4,7.900000000)
tdSql.checkData(0,5,3.000000000) tdSql.checkData(0,5,3.000000000)
def log_Arithmetic(self):
pass
def check_boundary_values(self): def check_boundary_values(self, dbname="bound_test"):
tdSql.execute("drop database if exists bound_test") tdSql.execute(f"drop database if exists {dbname}")
tdSql.execute("create database if not exists bound_test") tdSql.execute(f"create database if not exists {dbname}")
time.sleep(3) time.sleep(3)
tdSql.execute("use bound_test")
tdSql.execute( tdSql.execute(
"create table stb_bound (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(32),c9 nchar(32), c10 timestamp) tags (t1 int);" f"create table {dbname}.stb_bound (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(32),c9 nchar(32), c10 timestamp) tags (t1 int);"
) )
tdSql.execute(f'create table sub1_bound using stb_bound tags ( 1 )') tdSql.execute(f'create table {dbname}.sub1_bound using {dbname}.stb_bound tags ( 1 )')
tdSql.execute( tdSql.execute(
f"insert into sub1_bound values ( now()-1s, 2147483647, 9223372036854775807, 32767, 127, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )" f"insert into {dbname}.sub1_bound values ( now()-1s, 2147483647, 9223372036854775807, 32767, 127, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
) )
tdSql.execute( tdSql.execute(
f"insert into sub1_bound values ( now()-1s, -2147483647, -9223372036854775807, -32767, -127, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )" f"insert into {dbname}.sub1_bound values ( now()-1s, -2147483647, -9223372036854775807, -32767, -127, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
) )
tdSql.execute( tdSql.execute(
f"insert into sub1_bound values ( now(), 2147483646, 9223372036854775806, 32766, 126, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )" f"insert into {dbname}.sub1_bound values ( now(), 2147483646, 9223372036854775806, 32766, 126, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
) )
tdSql.execute( tdSql.execute(
f"insert into sub1_bound values ( now(), -2147483646, -9223372036854775806, -32766, -126, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )" f"insert into {dbname}.sub1_bound values ( now(), -2147483646, -9223372036854775806, -32766, -126, -3.40E+38, -1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
) )
tdSql.error( tdSql.error(
f"insert into sub1_bound values ( now()+1s, 2147483648, 9223372036854775808, 32768, 128, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )" f"insert into {dbname}.sub1_bound values ( now()+1s, 2147483648, 9223372036854775808, 32768, 128, 3.40E+38, 1.7e+308, True, 'binary_tb1', 'nchar_tb1', now() )"
) )
self.check_result_auto_log( "select c1, c2, c3 , c4, c5 ,c6 from sub1_bound ", "select log(c1), log(c2) ,log(c3), log(c4), log(c5) ,log(c6) from sub1_bound") self.check_result_auto_log( f"select c1, c2, c3 , c4, c5 ,c6 from {dbname}.sub1_bound ", f"select log(c1), log(c2) ,log(c3), log(c4), log(c5) ,log(c6) from {dbname}.sub1_bound")
self.check_result_auto_log2( "select c1, c2, c3 , c4, c5 ,c6 from sub1_bound ", "select log(c1,2), log(c2,2) ,log(c3,2), log(c4,2), log(c5,2) ,log(c6,2) from sub1_bound") self.check_result_auto_log2( f"select c1, c2, c3 , c4, c5 ,c6 from {dbname}.sub1_bound ", f"select log(c1,2), log(c2,2) ,log(c3,2), log(c4,2), log(c5,2) ,log(c6,2) from {dbname}.sub1_bound")
self.check_result_auto_log__10( "select c1, c2, c3 , c4, c5 ,c6 from sub1_bound ", "select log(c1,-10), log(c2,-10) ,log(c3,-10), log(c4,-10), log(c5,-10) ,log(c6,-10) from sub1_bound") self.check_result_auto_log__10( f"select c1, c2, c3 , c4, c5 ,c6 from {dbname}.sub1_bound ", f"select log(c1,-10), log(c2,-10) ,log(c3,-10), log(c4,-10), log(c5,-10) ,log(c6,-10) from {dbname}.sub1_bound")
self.check_result_auto_log2( "select c1, c2, c3 , c3, c2 ,c1 from sub1_bound ", "select log(c1,2), log(c2,2) ,log(c3,2), log(c3,2), log(c2,2) ,log(c1,2) from sub1_bound") self.check_result_auto_log2( f"select c1, c2, c3 , c3, c2 ,c1 from {dbname}.sub1_bound ", f"select log(c1,2), log(c2,2) ,log(c3,2), log(c3,2), log(c2,2) ,log(c1,2) from {dbname}.sub1_bound")
self.check_result_auto_log( "select c1, c2, c3 , c3, c2 ,c1 from sub1_bound ", "select log(c1), log(c2) ,log(c3), log(c3), log(c2) ,log(c1) from sub1_bound") self.check_result_auto_log( f"select c1, c2, c3 , c3, c2 ,c1 from {dbname}.sub1_bound ", f"select log(c1), log(c2) ,log(c3), log(c3), log(c2) ,log(c1) from {dbname}.sub1_bound")
self.check_result_auto_log2("select abs(abs(abs(abs(abs(abs(abs(abs(abs(c1))))))))) nest_col_func from sub1_bound" , "select log(abs(c1) ,2) from sub1_bound" ) self.check_result_auto_log2(f"select abs(abs(abs(abs(abs(abs(abs(abs(abs(c1))))))))) nest_col_func from {dbname}.sub1_bound" , f"select log(abs(c1) ,2) from {dbname}.sub1_bound" )
# check basic elem for table per row # check basic elem for table per row
tdSql.query("select log(abs(c1),2) ,log(abs(c2),2) , log(abs(c3),2) , log(abs(c4),2), log(abs(c5),2), log(abs(c6),2) from sub1_bound ") tdSql.query(f"select log(abs(c1),2) ,log(abs(c2),2) , log(abs(c3),2) , log(abs(c4),2), log(abs(c5),2), log(abs(c6),2) from {dbname}.sub1_bound ")
tdSql.checkData(0,0,math.log(2147483647,2)) tdSql.checkData(0,0,math.log(2147483647,2))
tdSql.checkData(0,1,math.log(9223372036854775807 ,2)) tdSql.checkData(0,1,math.log(9223372036854775807 ,2))
tdSql.checkData(0,2,math.log(32767,2)) tdSql.checkData(0,2,math.log(32767,2))
@ -641,7 +617,7 @@ class TDTestCase:
tdSql.checkData(3,5,math.log(169999999999999993883079578865998174333346074304075874502773119193537729178160565864330091787584707988572262467983188919169916105593357174268369962062473635296474636515660464935663040684957844303524367815028553272712298986386310828644513212353921123253311675499856875650512437415429217994623324794855339589632.000000000,2)) tdSql.checkData(3,5,math.log(169999999999999993883079578865998174333346074304075874502773119193537729178160565864330091787584707988572262467983188919169916105593357174268369962062473635296474636515660464935663040684957844303524367815028553272712298986386310828644513212353921123253311675499856875650512437415429217994623324794855339589632.000000000,2))
# check basic elem for table per row # check basic elem for table per row
tdSql.query("select log(abs(c1)) ,log(abs(c2)) , log(abs(c3)) , log(abs(c4)), log(abs(c5)), log(abs(c6)) from sub1_bound ") tdSql.query(f"select log(abs(c1)) ,log(abs(c2)) , log(abs(c3)) , log(abs(c4)), log(abs(c5)), log(abs(c6)) from {dbname}.sub1_bound ")
tdSql.checkData(0,0,math.log(2147483647)) tdSql.checkData(0,0,math.log(2147483647))
tdSql.checkData(0,1,math.log(9223372036854775807)) tdSql.checkData(0,1,math.log(9223372036854775807))
tdSql.checkData(0,2,math.log(32767)) tdSql.checkData(0,2,math.log(32767))
@ -661,28 +637,25 @@ class TDTestCase:
tdSql.checkData(3,4,math.log(339999995214436424907732413799364296704.00000)) tdSql.checkData(3,4,math.log(339999995214436424907732413799364296704.00000))
tdSql.checkData(3,5,math.log(169999999999999993883079578865998174333346074304075874502773119193537729178160565864330091787584707988572262467983188919169916105593357174268369962062473635296474636515660464935663040684957844303524367815028553272712298986386310828644513212353921123253311675499856875650512437415429217994623324794855339589632.000000000)) tdSql.checkData(3,5,math.log(169999999999999993883079578865998174333346074304075874502773119193537729178160565864330091787584707988572262467983188919169916105593357174268369962062473635296474636515660464935663040684957844303524367815028553272712298986386310828644513212353921123253311675499856875650512437415429217994623324794855339589632.000000000))
# check + - * / in functions # check + - * / in functions
tdSql.query("select log(abs(c1+1) ,2) ,log(abs(c2),2) , log(abs(c3*1),2) , log(abs(c4/2),2), log(abs(c5) ,2)/2, log(abs(c6) ,2) from sub1_bound ") tdSql.query(f"select log(abs(c1+1) ,2) ,log(abs(c2),2) , log(abs(c3*1),2) , log(abs(c4/2),2), log(abs(c5) ,2)/2, log(abs(c6) ,2) from {dbname}.sub1_bound ")
tdSql.checkData(0,0,math.log(2147483648.000000000,2)) tdSql.checkData(0,0,math.log(2147483648.000000000,2))
tdSql.checkData(0,1,math.log(9223372036854775807,2)) tdSql.checkData(0,1,math.log(9223372036854775807,2))
tdSql.checkData(0,2,math.log(32767.000000000,2)) tdSql.checkData(0,2,math.log(32767.000000000,2))
tdSql.checkData(0,3,math.log(63.500000000,2)) tdSql.checkData(0,3,math.log(63.500000000,2))
tdSql.checkData(0,4,63.999401166) tdSql.checkData(0,4,63.999401166)
def support_super_table_test(self): def support_super_table_test(self, dbname="db"):
tdSql.execute(" use db ")
self.check_result_auto_log2( " select c5 from stb1 order by ts " , "select log(c5,2) from stb1 order by ts" )
self.check_result_auto_log2( " select c5 from stb1 order by tbname " , "select log(c5,2) from stb1 order by tbname" )
self.check_result_auto_log2( " select c5 from stb1 where c1 > 0 order by tbname " , "select log(c5,2) from stb1 where c1 > 0 order by tbname" )
self.check_result_auto_log2( " select c5 from stb1 where c1 > 0 order by tbname " , "select log(c5,2) from stb1 where c1 > 0 order by tbname" )
self.check_result_auto_log2( " select t1,c5 from stb1 order by ts " , "select log(t1,2), log(c5,2) from stb1 order by ts" ) self.check_result_auto_log2( f"select c5 from {dbname}.stb1 order by ts " , f"select log(c5,2) from {dbname}.stb1 order by ts" )
self.check_result_auto_log2( " select t1,c5 from stb1 order by tbname " , "select log(t1,2) ,log(c5,2) from stb1 order by tbname" ) self.check_result_auto_log2( f"select c5 from {dbname}.stb1 order by tbname " , f"select log(c5,2) from {dbname}.stb1 order by tbname" )
self.check_result_auto_log2( " select t1,c5 from stb1 where c1 > 0 order by tbname " , "select log(t1,2) ,log(c5,2) from stb1 where c1 > 0 order by tbname" ) self.check_result_auto_log2( f"select c5 from {dbname}.stb1 where c1 > 0 order by tbname " , f"select log(c5,2) from {dbname}.stb1 where c1 > 0 order by tbname" )
self.check_result_auto_log2( " select t1,c5 from stb1 where c1 > 0 order by tbname " , "select log(t1,2) , log(c5,2) from stb1 where c1 > 0 order by tbname" ) self.check_result_auto_log2( f"select c5 from {dbname}.stb1 where c1 > 0 order by tbname " , f"select log(c5,2) from {dbname}.stb1 where c1 > 0 order by tbname" )
pass
self.check_result_auto_log2( f"select t1,c5 from {dbname}.stb1 order by ts " , f"select log(t1,2), log(c5,2) from {dbname}.stb1 order by ts" )
self.check_result_auto_log2( f"select t1,c5 from {dbname}.stb1 order by tbname " , f"select log(t1,2) ,log(c5,2) from {dbname}.stb1 order by tbname" )
self.check_result_auto_log2( f"select t1,c5 from {dbname}.stb1 where c1 > 0 order by tbname " , f"select log(t1,2) ,log(c5,2) from {dbname}.stb1 where c1 > 0 order by tbname" )
self.check_result_auto_log2( f"select t1,c5 from {dbname}.stb1 where c1 > 0 order by tbname " , f"select log(t1,2) , log(c5,2) from {dbname}.stb1 where c1 > 0 order by tbname" )
def run(self): # sourcery skip: extract-duplicate-method, remove-redundant-fstring def run(self): # sourcery skip: extract-duplicate-method, remove-redundant-fstring
tdSql.prepare() tdSql.prepare()

19
tests/system-test/fulltest.sh
View File

@ -110,15 +110,20 @@ python3 ./test.py -f 2-query/histogram.py
python3 ./test.py -f 2-query/histogram.py -R python3 ./test.py -f 2-query/histogram.py -R
python3 ./test.py -f 2-query/hyperloglog.py python3 ./test.py -f 2-query/hyperloglog.py
python3 ./test.py -f 2-query/hyperloglog.py -R python3 ./test.py -f 2-query/hyperloglog.py -R
python3 ./test.py -f 2-query/interp.py
python3 ./test.py -f 2-query/interp.py -R
python3 ./test.py -f 2-query/irate.py python3 ./test.py -f 2-query/irate.py
# python3 ./test.py -f 2-query/irate.py -R # python3 ./test.py -f 2-query/irate.py -R
python3 ./test.py -f 2-query/join.py python3 ./test.py -f 2-query/join.py
python3 ./test.py -f 2-query/join.py -R python3 ./test.py -f 2-query/join.py -R
python3 ./test.py -f 2-query/last_row.py
python3 ./test.py -f 2-query/interp.py python3 ./test.py -f 2-query/last_row.py -R
python3 ./test.py -f 2-query/interp.py -R python3 ./test.py -f 2-query/last.py
python3 ./test.py -f 2-query/last.py -R
python3 ./test.py -f 2-query/leastsquares.py
python3 ./test.py -f 2-query/leastsquares.py -R
python3 ./test.py -f 2-query/length.py
python3 ./test.py -f 2-query/length.py -R
python3 ./test.py -f 1-insert/update_data.py python3 ./test.py -f 1-insert/update_data.py
@ -127,7 +132,6 @@ python3 ./test.py -f 1-insert/delete_data.py
python3 ./test.py -f 2-query/varchar.py python3 ./test.py -f 2-query/varchar.py
python3 ./test.py -f 2-query/ltrim.py python3 ./test.py -f 2-query/ltrim.py
python3 ./test.py -f 2-query/rtrim.py python3 ./test.py -f 2-query/rtrim.py
python3 ./test.py -f 2-query/length.py
python3 ./test.py -f 2-query/upper.py python3 ./test.py -f 2-query/upper.py
python3 ./test.py -f 2-query/lower.py python3 ./test.py -f 2-query/lower.py
python3 ./test.py -f 2-query/join2.py python3 ./test.py -f 2-query/join2.py
@ -136,7 +140,6 @@ python3 ./test.py -f 2-query/union.py
python3 ./test.py -f 2-query/union1.py python3 ./test.py -f 2-query/union1.py
python3 ./test.py -f 2-query/concat2.py python3 ./test.py -f 2-query/concat2.py
python3 ./test.py -f 2-query/spread.py python3 ./test.py -f 2-query/spread.py
python3 ./test.py -f 2-query/leastsquares.py
python3 ./test.py -f 2-query/timezone.py python3 ./test.py -f 2-query/timezone.py
@ -144,7 +147,6 @@ python3 ./test.py -f 2-query/Now.py
python3 ./test.py -f 2-query/Today.py python3 ./test.py -f 2-query/Today.py
python3 ./test.py -f 2-query/max.py python3 ./test.py -f 2-query/max.py
python3 ./test.py -f 2-query/min.py python3 ./test.py -f 2-query/min.py
python3 ./test.py -f 2-query/last.py
python3 ./test.py -f 2-query/To_iso8601.py python3 ./test.py -f 2-query/To_iso8601.py
python3 ./test.py -f 2-query/To_unixtimestamp.py python3 ./test.py -f 2-query/To_unixtimestamp.py
python3 ./test.py -f 2-query/timetruncate.py python3 ./test.py -f 2-query/timetruncate.py
@ -178,7 +180,6 @@ python3 ./test.py -f 2-query/ttl_comment.py
python3 ./test.py -f 2-query/twa.py python3 ./test.py -f 2-query/twa.py
python3 ./test.py -f 2-query/queryQnode.py python3 ./test.py -f 2-query/queryQnode.py
python3 ./test.py -f 2-query/max_partition.py python3 ./test.py -f 2-query/max_partition.py
python3 ./test.py -f 2-query/last_row.py
python3 ./test.py -f 2-query/tsbsQuery.py python3 ./test.py -f 2-query/tsbsQuery.py
python3 ./test.py -f 6-cluster/5dnode1mnode.py python3 ./test.py -f 6-cluster/5dnode1mnode.py

24
tests/system-test/test.py
View File

@ -194,7 +194,7 @@ if __name__ == "__main__":
processID = subprocess.check_output(psCmd, shell=True) processID = subprocess.check_output(psCmd, shell=True)
for port in range(6030, 6041): for port in range(6030, 6041):
usePortPID = "lsof -i tcp:%d | grep LISTEn | awk '{print $2}'" % port usePortPID = "lsof -i tcp:%d | grep LISTEN | awk '{print $2}'" % port
processID = subprocess.check_output(usePortPID, shell=True) processID = subprocess.check_output(usePortPID, shell=True)
if processID: if processID:
@ -206,11 +206,13 @@ if __name__ == "__main__":
time.sleep(2) time.sleep(2)
if restful: if restful:
toBeKilled = "taosadapter" toBeKilled = "taosadapt"
killCmd = "ps -ef|grep -w %s| grep -v grep | awk '{print $2}' | xargs kill -TERM > /dev/null 2>&1" % toBeKilled # killCmd = "ps -ef|grep -w %s| grep -v grep | awk '{print $2}' | xargs kill -TERM > /dev/null 2>&1" % toBeKilled
killCmd = f"pkill {toBeKilled}"
psCmd = "ps -ef|grep -w %s| grep -v grep | awk '{print $2}'" % toBeKilled psCmd = "ps -ef|grep -w %s| grep -v grep | awk '{print $2}'" % toBeKilled
# psCmd = f"pgrep {toBeKilled}"
processID = subprocess.check_output(psCmd, shell=True) processID = subprocess.check_output(psCmd, shell=True)
while(processID): while(processID):
@ -218,15 +220,15 @@ if __name__ == "__main__":
time.sleep(1) time.sleep(1)
processID = subprocess.check_output(psCmd, shell=True) processID = subprocess.check_output(psCmd, shell=True)
for port in range(6030, 6041): port = 6041
usePortPID = "lsof -i tcp:%d | grep LISTEn | awk '{print $2}'" % port usePortPID = f"lsof -i tcp:{port} | grep LISTEN | awk '{{print $2}}'"
processID = subprocess.check_output(usePortPID, shell=True) processID = subprocess.check_output(usePortPID, shell=True)
if processID: if processID:
killCmd = "kill -TERM %s" % processID killCmd = f"kill -TERM {processID}"
os.system(killCmd) os.system(killCmd)
fuserCmd = "fuser -k -n tcp %d" % port fuserCmd = f"fuser -k -n tcp {port}"
os.system(fuserCmd) os.system(fuserCmd)
tdLog.info('stop taosadapter') tdLog.info('stop taosadapter')