Merge pull request #2259 from taosdata/morefiltertests

Add test cases for all support data types

tests/pytest/fulltest.sh

@@ -134,6 +134,9 @@ python3 ./test.py -f query/filter.py
 python3 ./test.py -f query/filterCombo.py
 python3 ./test.py -f query/queryNormal.py
 python3 ./test.py -f query/queryError.py
+python3 ./test.py -f query/filterAllIntTypes.py
+python3 ./test.py -f query/filterFloatAndDouble.py
+python3 ./test.py -f query/filterOtherTypes.py
 
 #stream
 python3 ./test.py -f stream/stream1.py

tests/pytest/query/filterAllIntTypes.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.powers = [7, 15, 31, 63]
+        self.types = ["tinyint", "smallint", "int", "bigint"]
+        self.rowNum = 10
+        self.ts = 1537146000000       
+        
+    def run(self):
+        tdSql.prepare()
+
+        for i in range(len(self.powers)):
+            curType = self.types[i]
+            print("======= Verify filter for %s type =========" % (curType))
+            tdLog.debug(
+                "create table st%s(ts timestamp, num %s) tags(id %s)" % (curType, curType, curType))
+            tdSql.execute(
+                "create table st%s(ts timestamp, num %s) tags(id %s)" % (curType, curType, curType))
+            
+            #create 10 tables, insert 10 rows for each table
+            for j in range(self.rowNum):            
+                tdSql.execute("create table st%s%d using st%s tags(%d)" % (curType, j + 1, curType, j + 1))
+                for k in range(self.rowNum):                
+                    tdSql.execute("insert into st%s%d values(%d, %d)" % (curType, j + 1, self.ts + k + 1, j * 10 + k + 1))
+            
+            tdSql.error("insert into st%s10 values(%d, %d)" % (curType, self.ts + 11, pow(2, self.powers[i])))
+            tdSql.execute("insert into st%s10 values(%d, %d)" % (curType, self.ts + 12, pow(2, self.powers[i]) - 1))
+            tdSql.error("insert into st%s10 values(%d, %d)" % (curType, self.ts + 13, pow(-2, self.powers[i])))
+            tdSql.execute("insert into st%s10 values(%d, %d)" % (curType, self.ts + 14, pow(-2, self.powers[i]) + 1)) 
+
+            # > for int type on column
+            tdSql.query("select * from st%s where num > 50" % curType)
+            tdSql.checkRows(51)
+
+            # >= for int type on column
+            tdSql.query("select * from st%s where num >= 50" % curType)
+            tdSql.checkRows(52)
+
+            # = for int type on column
+            tdSql.query("select * from st%s where num = 50" % curType)
+            tdSql.checkRows(1)
+
+            # < for int type on column
+            tdSql.query("select * from st%s where num < 50" % curType)
+            tdSql.checkRows(50)
+
+            # <= for int type on column
+            tdSql.query("select * from st%s where num <= 50" % curType)
+            tdSql.checkRows(51)
+
+            # <> for int type on column
+            tdSql.query("select * from st%s where num <> 50" % curType)
+            tdSql.checkRows(101)
+
+            # != for int type on column
+            tdSql.query("select * from st%s where num != 50" % curType)
+            tdSql.checkRows(101)
+
+            # > for int type on tag
+            tdSql.query("select * from st%s where id > 5" % curType)
+            tdSql.checkRows(52)
+
+            # >= for int type on tag
+            tdSql.query("select * from st%s where id >= 5" % curType)
+            tdSql.checkRows(62)
+
+            # = for int type on tag
+            tdSql.query("select * from st%s where id = 5" % curType)
+            tdSql.checkRows(10)
+
+            # < for int type on tag
+            tdSql.query("select * from st%s where id < 5" % curType)
+            tdSql.checkRows(40)
+
+            # <= for int type on tag
+            tdSql.query("select * from st%s where id <= 5" % curType)
+            tdSql.checkRows(50)
+
+            # <> for int type on tag
+            tdSql.query("select * from st%s where id <> 5" % curType)
+            tdSql.checkRows(92)
+
+            # != for int type on tag
+            tdSql.query("select * from st%s where id != 5" % curType)
+            tdSql.checkRows(92)            
+
+            print("======= Verify filter for %s type finished =========" % curType)
+                                                   
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/query/filterFloatAndDouble.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()
+
+        print("======= Verify filter for float and double type =========")
+        tdLog.debug(
+                "create table st(ts timestamp, num float, speed double) tags(tagcol1 float, tagcol2 double)")
+        tdSql.execute(
+                "create table st(ts timestamp, num float, speed double) tags(tagcol1 float, tagcol2 double)")
+                
+        for j in range(self.rowNum):             
+            tdSql.execute(
+                "insert into st1 using st tags(1.1, 2.3) values(%d, %f, %f)" % (self.ts + j + 1, 1.1 * (j + 1), 2.3 * (j + 1)))    
+
+        # > for float type on column
+        tdSql.query("select * from st where num > 5.5")
+        tdSql.checkRows(5)
+        
+        # >= for float type on column
+        tdSql.query("select * from st where num >= 5.5")
+        tdSql.checkRows(6)
+
+        # = for float type on column
+        tdSql.query("select * from st where num = 5.5")
+        tdSql.checkRows(1)
+
+        # <> for float type on column
+        tdSql.query("select * from st where num <> 5.5")
+        tdSql.checkRows(9)
+
+        # != for float type on column
+        tdSql.query("select * from st where num != 5.5")
+        tdSql.checkRows(9)
+
+        # <= for float type on column
+        tdSql.query("select * from st where num <= 5.5")
+        tdSql.checkRows(5)
+
+        # < for float type on column
+        tdSql.query("select * from st where num < 5.5")
+        tdSql.checkRows(4)
+
+        # > for float type on tag
+        tdSql.query("select * from st where tagcol1 > 1.1")
+        tdSql.checkRows(0)
+        
+        # >= for float type on tag
+        tdSql.query("select * from st where tagcol1 >= 1.1")
+        tdSql.checkRows(10)
+        
+        # = for float type on tag
+        tdSql.query("select * from st where tagcol1 = 1.1")
+        tdSql.checkRows(10)
+
+        # <> for float type on tag
+        tdSql.query("select * from st where tagcol1 <> 1.1")
+        tdSql.checkRows(0)
+
+        # != for float type on tag
+        tdSql.query("select * from st where tagcol1 != 1.1")
+        tdSql.checkRows(0)
+        
+        # <= for float type on tag
+        tdSql.query("select * from st where tagcol1 <= 1.1")
+        tdSql.checkRows(10)
+
+        # < for float type on tag
+        tdSql.query("select * from st where tagcol1 < 1.1")
+        tdSql.checkRows(0)
+        
+        # > for double type on column
+        tdSql.query("select * from st where speed > 11.5")
+        tdSql.checkRows(5)
+        
+        # >= for double type on column
+        tdSql.query("select * from st where speed >= 11.5")
+        tdSql.checkRows(6)
+
+        # = for double type on column
+        tdSql.query("select * from st where speed = 11.5")
+        tdSql.checkRows(1)
+
+        # <> for double type on column
+        tdSql.query("select * from st where speed <> 11.5")
+        tdSql.checkRows(9)
+
+        # != for double type on column
+        tdSql.query("select * from st where speed != 11.5")
+        tdSql.checkRows(9)
+
+        # <= for double type on column
+        tdSql.query("select * from st where speed <= 11.5")
+        tdSql.checkRows(5)
+
+        # < for double type on column
+        tdSql.query("select * from st where speed < 11.5")
+        tdSql.checkRows(4)
+
+        # > for double type on tag
+        tdSql.query("select * from st where tagcol2 > 2.3")
+        tdSql.checkRows(0)
+        
+        # >= for double type on tag
+        tdSql.query("select * from st where tagcol2 >= 2.3")
+        tdSql.checkRows(10)
+        
+        # = for double type on tag
+        tdSql.query("select * from st where tagcol2 = 2.3")
+        tdSql.checkRows(10)
+
+        # <> for double type on tag
+        tdSql.query("select * from st where tagcol2 <> 2.3")
+        tdSql.checkRows(0)
+
+        # != for double type on tag
+        tdSql.query("select * from st where tagcol2 != 2.3")
+        tdSql.checkRows(0)
+        
+        # <= for double type on tag
+        tdSql.query("select * from st where tagcol2 <= 2.3")
+        tdSql.checkRows(10)
+
+        # < for double type on tag
+        tdSql.query("select * from st where tagcol2 < 2.3")
+        tdSql.checkRows(0)
+                                           
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/pytest/query/filterOtherTypes.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.ts = 1537146000000
+        
+    def run(self):
+        tdSql.prepare()
+                
+        print("======= Verify filter for bool, nchar and binary type =========")
+        tdLog.debug(
+            "create table st(ts timestamp, tbcol1 bool, tbcol2 nchar(10), tbcol3 binary(20)) tags(tagcol1 bool, tagcol2 nchar(10), tagcol3 binary(10))")
+        tdSql.execute(
+            "create table st(ts timestamp, tbcol1 bool, tbcol2 nchar(10), tbcol3 binary(20)) tags(tagcol1 bool, tagcol2 nchar(10), tagcol3 binary(10))")                
+
+        tdSql.execute("create table st1 using st tags(true, 'table1', '水表')")
+        for i in range(1, 6):                
+            tdSql.execute("insert into st1 values(%d, %d, 'taosdata%d', '涛思数据%d')" % (self.ts + i, i % 2, i, i)) 
+
+        tdSql.execute("create table st2 using st tags(false, 'table2', '电表')")
+        for i in range(6, 11):                
+            tdSql.execute("insert into st2 values(%d, %d, 'taosdata%d', '涛思数据%d')" % (self.ts + i, i % 2, i, i))  
+
+        # =============Verify stable columns====================
+        # > for bool type on column
+        tdSql.error("select * from st where tbcol1 > false")
+
+        # >= for bool type on column
+        tdSql.error("select * from st where tbcol1 >= false") 
+
+        # = for bool type on column
+        tdSql.query("select * from st where tbcol1 = false")
+        tdSql.checkRows(5)
+
+        # <> for bool type on column
+        tdSql.query("select * from st where tbcol1 <> true")
+        tdSql.checkRows(5)
+
+        # != for bool type on column
+        tdSql.query("select * from st where tbcol1 != true")
+        tdSql.checkRows(5)
+
+        # > for bool type on column
+        tdSql.error("select * from st where tbcol1 < true")
+
+        # >= for bool type on column
+        tdSql.error("select * from st where tbcol1 <= true")
+
+        # % for bool type on column
+        tdSql.error("select * from st where tbcol1 like '%'")
+
+        # _ for bool type on column
+        tdSql.error("select * from st where tbcol1 like '____'")
+
+        # > for nchar type on column
+        tdSql.error("select * from st where tbcol2 > 'taosdata'")
+
+        # >= for nchar type on column
+        tdSql.error("select * from st where tbcol2 >= 'taosdata'") 
+
+        # = for nchar type on column
+        tdSql.query("select * from st where tbcol2 = 'taosdata1'")
+        tdSql.checkRows(1)
+
+        # <> for nchar type on column
+        tdSql.query("select * from st where tbcol2 <> 'taosdata1'")        
+        tdSql.checkRows(9)
+
+        # != for nchar type on column
+        tdSql.query("select * from st where tbcol2 != 'taosdata1'")        
+        tdSql.checkRows(9)
+
+        # > for nchar type on column
+        tdSql.error("select * from st where tbcol2 < 'taodata'")
+
+        # >= for nchar type on column
+        tdSql.error("select * from st where tbcol2 <= 'taodata'")
+
+        # % for nchar type on column case 1
+        tdSql.query("select * from st where tbcol2 like '%'")        
+        tdSql.checkRows(10)
+
+        # % for nchar type on column case 2
+        tdSql.query("select * from st where tbcol2 like 'a%'")        
+        tdSql.checkRows(0)
+
+        # % for nchar type on column case 3
+        tdSql.query("select * from st where tbcol2 like 't%_'")        
+        tdSql.checkRows(10)
+
+        # % for nchar type on column case 4
+        tdSql.query("select * from st where tbcol2 like '%1'")        
+        # tdSql.checkRows(2)
+
+        # _ for nchar type on column case 1
+        tdSql.query("select * from st where tbcol2 like '____________'") 
+        tdSql.checkRows(0)       
+
+        # _ for nchar type on column case 2
+        tdSql.query("select * from st where tbcol2 like '__________'")        
+        tdSql.checkRows(1)
+
+        # _ for nchar type on column case 3
+        tdSql.query("select * from st where tbcol2 like '_________'")        
+        tdSql.checkRows(9)
+
+        # _ for nchar type on column case 4
+        tdSql.query("select * from st where tbcol2 like 't________'")        
+        tdSql.checkRows(9)
+
+        # _ for nchar type on column case 5
+        tdSql.query("select * from st where tbcol2 like '%________'")        
+        tdSql.checkRows(10)
+
+        # > for binary type on column
+        tdSql.error("select * from st where tbcol3 > '涛思数据'")
+
+        # >= for binary type on column
+        tdSql.error("select * from st where tbcol3 >= '涛思数据'") 
+
+        # = for binary type on column
+        tdSql.query("select * from st where tbcol3 = '涛思数据1'")
+        tdSql.checkRows(1)
+
+        # <> for binary type on column
+        tdSql.query("select * from st where tbcol3 <> '涛思数据1'")        
+        tdSql.checkRows(9)
+
+        # != for binary type on column
+        tdSql.query("select * from st where tbcol3 != '涛思数据1'")        
+        tdSql.checkRows(9)
+
+        # > for binary type on column
+        tdSql.error("select * from st where tbcol3 < '涛思数据'")
+
+        # >= for binary type on column
+        tdSql.error("select * from st where tbcol3 <= '涛思数据'")
+
+        # % for binary type on column case 1
+        tdSql.query("select * from st where tbcol3 like '%'")        
+        tdSql.checkRows(10)
+
+        # % for binary type on column case 2
+        tdSql.query("select * from st where tbcol3 like '陶%'")        
+        tdSql.checkRows(0)
+
+        # % for binary type on column case 3
+        tdSql.query("select * from st where tbcol3 like '涛%_'")        
+        tdSql.checkRows(10)
+
+        # % for binary type on column case 4
+        tdSql.query("select * from st where tbcol3 like '%1'")        
+        tdSql.checkRows(1)
+
+        # _ for binary type on column case 1
+        tdSql.query("select * from st where tbcol3 like '_______'") 
+        tdSql.checkRows(0)       
+
+        # _ for binary type on column case 2
+        tdSql.query("select * from st where tbcol3 like '______'")        
+        tdSql.checkRows(1)
+
+        # _ for binary type on column case 2
+        tdSql.query("select * from st where tbcol3 like '_____'")        
+        tdSql.checkRows(9)
+
+        # _ for binary type on column case 3
+        tdSql.query("select * from st where tbcol3 like '____'")        
+        tdSql.checkRows(0)
+
+        # _ for binary type on column case 4
+        tdSql.query("select * from st where tbcol3 like 't____'")        
+        tdSql.checkRows(0)
+
+        # =============Verify stable tags====================
+        # > for bool type on tag
+        tdSql.error("select * from st where tagcol1 > false")
+
+        # >= for bool type on tag
+        tdSql.error("select * from st where tagcol1 >= false") 
+
+        # = for bool type on tag
+        tdSql.query("select * from st where tagcol1 = false")
+        tdSql.checkRows(5)
+
+        # <> for bool type on tag
+        tdSql.query("select * from st where tagcol1 <> true")
+        tdSql.checkRows(5)
+
+        # != for bool type on tag
+        tdSql.query("select * from st where tagcol1 != true")
+        tdSql.checkRows(5)
+
+        # > for bool type on tag
+        tdSql.error("select * from st where tagcol1 < true")
+
+        # >= for bool type on tag
+        tdSql.error("select * from st where tagcol1 <= true")
+
+        # % for bool type on tag
+        tdSql.error("select * from st where tagcol1 like '%'")
+
+        # _ for bool type on tag
+        tdSql.error("select * from st where tagcol1 like '____'")
+
+        # > for nchar type on tag
+        tdSql.error("select * from st where tagcol2 > 'table'")
+
+        # >= for nchar type on tag
+        tdSql.error("select * from st where tagcol2 >= 'table'") 
+
+        # = for nchar type on tag
+        tdSql.query("select * from st where tagcol2 = 'table1'")
+        tdSql.checkRows(5)
+
+        # <> for nchar type on tag
+        tdSql.query("select * from st where tagcol2 <> 'table1'")        
+        tdSql.checkRows(5)
+
+        # != for nchar type on tag
+        tdSql.query("select * from st where tagcol2 != 'table'")        
+        tdSql.checkRows(10)
+
+        # > for nchar type on tag
+        tdSql.error("select * from st where tagcol2 < 'table'")
+
+        # >= for nchar type on tag
+        tdSql.error("select * from st where tagcol2 <= 'table'")
+
+        # % for nchar type on tag case 1
+        tdSql.query("select * from st where tagcol2 like '%'")        
+        tdSql.checkRows(10)
+
+        # % for nchar type on tag case 2
+        tdSql.query("select * from st where tagcol2 like 'a%'")        
+        tdSql.checkRows(0)
+
+        # % for nchar type on tag case 3
+        tdSql.query("select * from st where tagcol2 like 't%_'")        
+        tdSql.checkRows(10)
+
+        # % for nchar type on tag case 4
+        tdSql.query("select * from st where tagcol2 like '%1'")        
+        tdSql.checkRows(5)
+
+        # _ for nchar type on tag case 1
+        tdSql.query("select * from st where tagcol2 like '_______'") 
+        tdSql.checkRows(0)       
+
+        # _ for nchar type on tag case 2
+        tdSql.query("select * from st where tagcol2 like '______'")        
+        tdSql.checkRows(10)
+
+        # _ for nchar type on tag case 3
+        tdSql.query("select * from st where tagcol2 like 't_____'")        
+        tdSql.checkRows(10)
+
+        # _ for nchar type on tag case 4
+        tdSql.query("select * from st where tagcol2 like 's________'")        
+        tdSql.checkRows(0)
+
+        # _ for nchar type on tag case 5
+        tdSql.query("select * from st where tagcol2 like '%__'")        
+        tdSql.checkRows(10)
+
+        # > for binary type on tag
+        tdSql.error("select * from st where tagcol3 > '表'")
+
+        # >= for binary type on tag
+        tdSql.error("select * from st where tagcol3 >= '表'") 
+
+        # = for binary type on tag
+        tdSql.query("select * from st where tagcol3 = '水表'")
+        tdSql.checkRows(5)
+
+        # <> for binary type on tag
+        tdSql.query("select * from st where tagcol3 <> '水表'")        
+        tdSql.checkRows(5)
+
+        # != for binary type on tag
+        tdSql.query("select * from st where tagcol3 != '水表'")        
+        tdSql.checkRows(5)
+
+        # > for binary type on tag
+        tdSql.error("select * from st where tagcol3 < '水表'")
+
+        # >= for binary type on tag
+        tdSql.error("select * from st where tagcol3 <= '水表'")
+
+        # % for binary type on tag case 1
+        tdSql.query("select * from st where tagcol3 like '%'")        
+        tdSql.checkRows(10)
+
+        # % for binary type on tag case 2
+        tdSql.query("select * from st where tagcol3 like '水%'")        
+        tdSql.checkRows(5)
+
+        # % for binary type on tag case 3
+        tdSql.query("select * from st where tagcol3 like '数%_'")        
+        tdSql.checkRows(0)
+
+        # % for binary type on tag case 4
+        tdSql.query("select * from st where tagcol3 like '%表'")        
+        tdSql.checkRows(10)
+
+        # % for binary type on tag case 5
+        tdSql.query("select * from st where tagcol3 like '%据'")        
+        tdSql.checkRows(0)
+
+        # _ for binary type on tag case 1
+        tdSql.query("select * from st where tagcol3 like '__'") 
+        tdSql.checkRows(10)       
+
+        # _ for binary type on tag case 2
+        tdSql.query("select * from st where tagcol3 like '水_'")        
+        tdSql.checkRows(5)
+
+        # _ for binary type on tag case 2
+        tdSql.query("select * from st where tagcol3 like '_表'")        
+        tdSql.checkRows(10)
+
+        # _ for binary type on tag case 3
+        tdSql.query("select * from st where tagcol3 like '___'")        
+        tdSql.checkRows(0)
+
+        # _ for binary type on tag case 4
+        tdSql.query("select * from st where tagcol3 like '数_'")        
+        tdSql.checkRows(0)
+
+        # _ for binary type on tag case 5
+        tdSql.query("select * from st where tagcol3 like '_据'")        
+        tdSql.checkRows(0)
+                                                   
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)    
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())
+

tests/pytest/regressiontest.sh

@@ -131,6 +131,8 @@ python3 ./test.py -f user/pass_len.py
 
 #query
 python3 ./test.py -f query/filter.py
+python3 ./test.py -f query/filterAllIntTypes.py
+python3 ./test.py -f query/filterFloatAndDouble.py
 
 
 #stream