Merge pull request #4785 from taosdata/xiaoping/add_test_case

[TD-2354]<test>: add test case for cache last_row

tests/pytest/fulltest.sh

@@ -221,11 +221,14 @@ python3 ./test.py -f functions/function_sum.py -r 1
 python3 ./test.py -f functions/function_top.py -r 1
 python3 ./test.py -f functions/function_twa.py -r 1
 python3 ./test.py -f functions/function_twa_test2.py
+python3 ./test.py -f functions/all_null_value.py
 python3 queryCount.py
 python3 ./test.py -f query/queryGroupbyWithInterval.py
 python3 client/twoClients.py
-python3 test.py -f query/queryInterval.py
-python3 test.py -f query/queryFillTest.py
+python3 ./test.py -f query/queryInterval.py
+python3 ./test.py -f query/queryFillTest.py
+python3 ./test.py -f query/last_row_cache.py
+python3 ./test.py -f query/last_cache.py
 
 # tools
 python3 test.py -f tools/taosdemoTest.py

tests/pytest/functions/all_null_value.py

+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+
+
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor())
+
+        self.rowNum = 10
+        self.ts = 1537146000000
+        
+    def run(self):
+        tdSql.prepare()
+        
+        tdSql.execute("create table st(ts timestamp, c1 int, c2 int)")        
+        for i in range(self.rowNum):
+            tdSql.execute("insert into st values(%d, null, null)" % (self.ts + i))
+
+        tdSql.query("select avg(c1) from st")
+        tdSql.checkRows(0)
+
+        tdSql.query("select max(c1) from st")
+        tdSql.checkRows(0)
+
+        tdSql.query("select min(c1) from st")
+        tdSql.checkRows(0)
+
+        tdSql.query("select bottom(c1, 1) from st")
+        tdSql.checkRows(0)
+
+        tdSql.query("select top(c1, 1) from st")
+        tdSql.checkRows(0)
+
+        tdSql.query("select diff(c1) from st")
+        tdSql.checkRows(0)
+
+        tdSql.query("select first(c1) from st")
+        tdSql.checkRows(0)
+
+        tdSql.query("select last(c1) from st")
+        tdSql.checkRows(0)
+
+        tdSql.query("select last_row(c1) from st")
+        tdSql.checkRows(1)
+        tdSql.checkData(0, 0, None)
+
+        tdSql.query("select count(c1) from st")
+        tdSql.checkRows(0)
+
+        tdSql.query("select leastsquares(c1, 1, 1) from st")
+        tdSql.checkRows(0)    
+
+        tdSql.query("select c1 + c2 from st")
+        tdSql.checkRows(10)
+
+        tdSql.query("select spread(c1) from st")
+        tdSql.checkRows(0)
+
+        # tdSql.query("select stddev(c1) from st")
+        # tdSql.checkRows(0)
+
+        tdSql.query("select sum(c1) from st")
+        tdSql.checkRows(0)
+
+        tdSql.query("select twa(c1) from st")
+        tdSql.checkRows(0)
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/functions/function_max.py

@@ -70,6 +70,15 @@ class TDTestCase:
         tdSql.query("select max(col6) from test1")
         tdSql.checkData(0, 0, np.max(floatData))
 
+        # test case: https://jira.taosdata.com:18080/browse/TD-2583
+        tdSql.execute("create database test days 2")
+        tdSql.execute("create table car(ts timestamp, speed int)")
+        tdSql.execute("insert into car values(now, -1)")
+        tdSql.execute("insert into car values(now-10d, null)")
+
+        tdSql.query("select max(speed) from car")
+        tdSql.checkData(0, 0, -1)
+        
     def stop(self):
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)

tests/pytest/functions/function_min.py

@@ -70,6 +70,15 @@ class TDTestCase:
         tdSql.query("select min(col6) from test1")
         tdSql.checkData(0, 0, np.min(floatData))
 
+        # test case: https://jira.taosdata.com:18080/browse/TD-2583
+        tdSql.execute("create database test days 2")
+        tdSql.execute("create table car(ts timestamp, speed int)")
+        tdSql.execute("insert into car values(now, 1)")
+        tdSql.execute("insert into car values(now-10d, null)")
+
+        tdSql.query("select min(speed) from car")
+        tdSql.checkData(0, 0, 1)
+        
     def stop(self):
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)

tests/pytest/functions/function_percentile.py

@@ -143,6 +143,14 @@ class TDTestCase:
         tdSql.query("select apercentile(voltage, 20) from meters")
         print("apercentile result: %s" % tdSql.getData(0, 0))
 
+        # Test case for: https://jira.taosdata.com:18080/browse/TD-2609
+        tdSql.execute("create table st(ts timestamp, k int)")
+        tdSql.execute("insert into st values(now, -100)")
+        tdSql.query("select apercentile(k, 20) from st")
+        tdSql.checkData(0, 0, -100.00)
+
+
+        
     def stop(self):
         tdSql.close()
         tdLog.success("%s successfully executed" % __file__)

tests/pytest/functions/function_twa_test2.py

@@ -132,6 +132,22 @@ class TDTestCase:
         tdSql.query('select twa(c) from t4 interval(10s)')
         tdSql.checkData(0,1,10.999)
 
+        # Test case: https://jira.taosdata.com:18080/browse/TD-2624
+        tdSql.execute("create database test keep 7300")
+        tdSql.execute("use test")
+        tdSql.execute("create table st(ts timestamp, k int)")
+        tdSql.execute("insert into st values('2011-01-02 18:42:45.326', -1)")
+        tdSql.execute("insert into st values('2020-07-30 17:44:06.283', 0)")
+        tdSql.execute("insert into st values('2020-07-30 17:44:19.578', 9999999)")
+        tdSql.execute("insert into st values('2020-07-30 17:46:06.417', NULL)")
+        tdSql.execute("insert into st values('2020-11-09 18:42:25.538', 0)")
+        tdSql.execute("insert into st values('2020-12-29 17:43:11.641', 0)")
+        tdSql.execute("insert into st values('2020-12-29 18:43:17.129', 0)")
+        tdSql.execute("insert into st values('2020-12-29 18:46:19.109', NULL)")
+        tdSql.execute("insert into st values('2021-01-03 18:40:40.065', 0)")
+
+        tdSql.query("select twa(k),first(ts) as taos1  from st where k <50 interval(17s)")
+        tdSql.checkRows(6)
 
     def stop(self):
         tdSql.close()

tests/pytest/pytest_2.sh

@@ -16,3 +16,6 @@ python3 ./test.py -f update/bug_td2279.py
 
 # wal
 python3 ./test.py -f wal/addOldWalTest.py
+
+# function
+python3 ./test.py -f functions/all_null_value.py
\ No newline at end of file

tests/pytest/query/last_cache.py

+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import tdLog
+from util.cases import tdCases
+from util.sql import tdSql
+from util.dnodes import tdDnodes
+
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor(), logSql)
+
+        self.tables = 10
+        self.rows = 20
+        self.perfix = 't'
+        self.ts = 1601481600000
+    
+    def insertData(self):
+        print("==============step1")        
+        tdSql.execute("create table st (ts timestamp, c1 int) tags(t1 int)")
+        
+        for i in range(self.tables):
+            tdSql.execute("create table %s%d using st tags(%d)" % (self.perfix, i, i))
+            for j in range(self.rows):
+                tc = self.ts + j * 60000
+                tdSql.execute("insert into %s%d values(%d, %d)" %(self.perfix, i, tc, j))
+
+    def executeQueries(self):
+        print("==============step2")
+        tdSql.query("select last(c1) from %s%d" % (self.perfix, 1))
+        tdSql.checkData(0, 0, 19)
+
+        tdSql.query("select last(c1) from %s%d where ts <= %d" % (self.perfix, 1, self.ts + 4 * 60000))
+        tdSql.checkData(0, 0, 4)
+
+        tdSql.query("select last(c1) as b from %s%d" % (self.perfix, 1))
+        tdSql.checkData(0, 0, 19)
+
+        tdSql.query("select last(c1) from %s%d interval(1m)" % (self.perfix, 1))
+        tdSql.checkData(1, 1, 1)
+
+        tdSql.query("select last(c1) from %s%d interval(1d)" % (self.perfix, 1))
+        tdSql.checkData(0, 1, 19)
+
+        tdSql.query("select last(c1) from %s%d where ts <= %d interval(1m)" % (self.perfix, 1, self.ts + 4 * 60000))
+        tdSql.checkRows(5)
+        tdSql.checkData(1, 1, 1)
+
+        tdSql.query("select last(c1) from st")
+        tdSql.checkData(0, 0, 19)
+
+        tdSql.query("select last(c1) as c from st where ts <= %d" % (self.ts + 4 * 60000))
+        tdSql.checkData(0, 0, 4)
+
+        tdSql.query("select last(c1) as c from st where t1 <= 5")
+        tdSql.checkData(0, 0, 19)
+
+        tdSql.query("select last(c1) as c from st where t1 <= 5 and ts <= %d" % (self.ts + 4 * 60000))
+        tdSql.checkData(0, 0, 4)
+
+        tdSql.query("select last(c1) from st interval(1m)")        
+        tdSql.checkData(1, 1, 1)
+
+        tdSql.query("select last(c1) from st interval(1d)")        
+        tdSql.checkData(0, 1, 19)
+
+        tdSql.query("select last(c1) from st group by t1")
+        tdSql.checkRows(10)
+        tdSql.checkData(0, 0, 19)
+
+        tdSql.query("select last(c1) as c from st where ts <= %d interval(1m) group by t1" % (self.ts + 4 * 60000))
+        tdSql.checkData(1, 1, 1)
+        tdSql.checkRows(50)
+
+    def run(self):
+        tdSql.prepare()
+
+        # last_cache_0.sim
+        tdSql.execute("create database test1 cachelast 0")
+        tdSql.execute("use test1")
+        self.insertData()
+        self.executeQueries()
+        
+        tdSql.execute("alter database test1 cachelast 1")        
+        self.executeQueries()
+        tdDnodes.stop(1)
+        tdDnodes.start(1)
+        self.executeQueries()
+
+        tdSql.execute("alter database test1 cachelast 0")        
+        self.executeQueries()
+        tdDnodes.stop(1)
+        tdDnodes.start(1)
+        self.executeQueries()
+
+        # last_cache_1.sim
+        tdSql.execute("create database test2 cachelast 1")
+        tdSql.execute("use test2")
+        self.insertData()
+        self.executeQueries()
+        
+        tdSql.execute("alter database test2 cachelast 0")        
+        self.executeQueries()
+        tdDnodes.stop(1)
+        tdDnodes.start(1)
+        self.executeQueries()
+
+        tdSql.execute("alter database test2 cachelast 1")        
+        self.executeQueries()
+        tdDnodes.stop(1)
+        tdDnodes.start(1)
+        self.executeQueries()
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/query/last_row_cache.py

+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import tdLog
+from util.cases import tdCases
+from util.sql import tdSql
+from util.dnodes import tdDnodes
+
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor(), logSql)
+
+        self.tables = 10
+        self.rows = 20
+        self.perfix = 't'
+        self.ts = 1601481600000
+    
+    def insertData(self):
+        print("==============step1")        
+        tdSql.execute("create table st (ts timestamp, c1 int) tags(t1 int)")
+        
+        for i in range(self.tables):
+            tdSql.execute("create table %s%d using st tags(%d)" % (self.perfix, i, i))
+            for j in range(self.rows):
+                tc = self.ts + j * 60000
+                tdSql.execute("insert into %s%d values(%d, %d)" %(self.perfix, i, tc, j))    
+
+    def executeQueries(self):
+        print("==============step2")
+        tdSql.query("select last_row(c1) from %s%d" % (self.perfix, 1))
+        tdSql.checkData(0, 0, 19)
+
+        tdSql.query("select last_row(c1) from %s%d where ts <= %d" % (self.perfix, 1, self.ts + 4 * 60000))
+        tdSql.checkData(0, 0, 4)
+
+        tdSql.query("select last_row(c1) as b from %s%d" % (self.perfix, 1))
+        tdSql.checkData(0, 0, 19)
+
+        tdSql.query("select last_row(c1) from st")
+        tdSql.checkData(0, 0, 19)
+
+        tdSql.query("select last_row(c1) as c from st where ts <= %d" % (self.ts + 4 * 60000))
+        tdSql.checkData(0, 0, 4)
+
+        tdSql.query("select last_row(c1) as c from st where t1 < 5")
+        tdSql.checkData(0, 0, 19)
+
+        tdSql.query("select last_row(c1) as c from st where t1 <= 5 and ts <= %d" % (self.ts + 4 * 60000))
+        tdSql.checkData(0, 0, 4)        
+
+        tdSql.query("select last_row(c1) as c from st group by t1")
+        tdSql.checkRows(10)
+        tdSql.checkData(0, 0, 19)        
+
+        tc = self.ts + 1 * 3600000
+        tdSql.execute("insert into %s%d values(%d, %d)" %(self.perfix, 1, tc, 10))
+
+        tc = self.ts + 3 * 3600000
+        tdSql.execute("insert into %s%d values(%d, null)" %(self.perfix, 1, tc))
+
+        tc = self.ts + 5 * 3600000
+        tdSql.execute("insert into %s%d values(%d, %d)" %(self.perfix, 1, tc, -1))
+
+        tc = self.ts + 7 * 3600000
+        tdSql.execute("insert into %s%d values(%d, null)" %(self.perfix, 1, tc))
+
+    def insertData2(self):
+        tc = self.ts + 1 * 3600000
+        tdSql.execute("insert into %s%d values(%d, %d)" %(self.perfix, 1, tc, 10))
+
+        tc = self.ts + 3 * 3600000
+        tdSql.execute("insert into %s%d values(%d, null)" %(self.perfix, 1, tc))
+
+        tc = self.ts + 5 * 3600000
+        tdSql.execute("insert into %s%d values(%d, %d)" %(self.perfix, 1, tc, -1))
+
+        tc = self.ts + 7 * 3600000
+        tdSql.execute("insert into %s%d values(%d, null)" %(self.perfix, 1, tc))
+
+    def executeQueries2(self): 
+        # For stable
+        tc = self.ts + 6 * 3600000
+        tdSql.query("select last_row(c1) from st where ts < %d " % tc)        
+        tdSql.checkData(0, 0, -1)
+
+        tc = self.ts + 8 * 3600000
+        tdSql.query("select last_row(*) from st where ts < %d " % tc)        
+        tdSql.checkData(0, 1, None)
+
+        tdSql.query("select last_row(*) from st")        
+        tdSql.checkData(0, 1, None)
+
+        tc = self.ts + 4 * 3600000
+        tdSql.query("select last_row(*) from st where ts < %d " % tc)        
+        tdSql.checkData(0, 1, None)
+
+        tc1 = self.ts + 1 * 3600000
+        tc2 = self.ts + 4 * 3600000
+        tdSql.query("select last_row(*) from st where ts > %d and ts <= %d" % (tc1, tc2))
+        tdSql.checkData(0, 1, None)
+
+        # For table
+        tc = self.ts + 6 * 3600000
+        tdSql.query("select last_row(*) from %s%d where ts <= %d" % (self.perfix, 1, tc))
+        tdSql.checkData(0, 1, -1)
+
+        tc = self.ts + 8 * 3600000
+        tdSql.query("select last_row(*) from %s%d where ts <= %d" % (self.perfix, 1, tc))
+        tdSql.checkData(0, 1, None)
+
+        tdSql.query("select last_row(*) from %s%d" % (self.perfix, 1))
+        tdSql.checkData(0, 1, None)
+
+        tc = self.ts + 4 * 3600000
+        tdSql.query("select last_row(*) from %s%d where ts <= %d" % (self.perfix, 1, tc))
+        tdSql.checkData(0, 1, None)
+
+        tc1 = self.ts + 1 * 3600000
+        tc2 = self.ts + 4 * 3600000
+        tdSql.query("select last_row(*) from st where ts > %d and ts <= %d" % (tc1, tc2))
+        tdSql.checkData(0, 1, None)
+        
+    def run(self):
+        tdSql.prepare()
+        
+        print("============== last_row_cache_0.sim")
+        tdSql.execute("create database test1 cachelast 0")
+        tdSql.execute("use test1")
+        self.insertData()
+        self.executeQueries()
+        self.insertData2()
+        self.executeQueries2()
+        
+        print("============== alter last cache")
+        tdSql.execute("alter database test1 cachelast 1")                
+        self.executeQueries2()
+        tdDnodes.stop(1)
+        tdDnodes.start(1)
+        self.executeQueries2()
+
+        tdSql.execute("alter database test1 cachelast 0")        
+        self.executeQueries2()
+        tdDnodes.stop(1)
+        tdDnodes.start(1)
+        self.executeQueries2()
+
+        print("============== last_row_cache_1.sim")
+        tdSql.execute("create database test2 cachelast 1")
+        tdSql.execute("use test2")
+        self.insertData()
+        self.executeQueries()
+        self.insertData2()
+        self.executeQueries2()
+        
+        tdSql.execute("alter database test2 cachelast 0")        
+        self.executeQueries2()
+        tdDnodes.stop(1)
+        tdDnodes.start(1)
+        self.executeQueries2()
+
+        tdSql.execute("alter database test2 cachelast 1")        
+        self.executeQueries2()
+        tdDnodes.stop(1)
+        tdDnodes.start(1)
+        self.executeQueries2()
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/query/queryInterval.py

@@ -85,6 +85,22 @@ class TDTestCase:
         tdSql.query("select last(*) from t interval(1s)")
         tdSql.checkRows(10000)
 
+        # test case for https://jira.taosdata.com:18080/browse/TD-2601
+        newTs = 1601481600000
+
+        tdSql.execute("create database test2")
+        tdSql.execute("use test2")
+        tdSql.execute("create table t (ts timestamp, voltage int)")
+        for i in range(100):
+            tdSql.execute("insert into t values(%d, %d)" % (newTs + i * 10000000, i))
+        
+        tdSql.query("select sum(voltage) from t where ts >='2020-10-01 00:00:00' and ts <='2020-12-01 00:00:00' interval(1n) fill(NULL)")
+        tdSql.checkRows(3)
+        tdSql.checkData(0, 1, 4950)
+        tdSql.checkData(1, 1, None)
+        tdSql.checkData(2, 1, None)
+
+        
 
     def stop(self):
         tdSql.close()