From b5599027e6c41202002356ad77ff6fa8b94deefb Mon Sep 17 00:00:00 2001 From: "wenzhouwww@live.cn" Date: Fri, 8 Jul 2022 20:00:22 +0800 Subject: [PATCH 01/30] test: add test case for count about partition by tbname and interval --- tests/system-test/2-query/count_partition.py | 176 +++++++++++++++++++ tests/system-test/fulltest.sh | 4 +- 2 files changed, 179 insertions(+), 1 deletion(-) create mode 100644 tests/system-test/2-query/count_partition.py diff --git a/tests/system-test/2-query/count_partition.py b/tests/system-test/2-query/count_partition.py new file mode 100644 index 0000000000..c1fbd2b784 --- /dev/null +++ b/tests/system-test/2-query/count_partition.py @@ -0,0 +1,176 @@ +# author : wenzhouwww +from util.log import * +from util.sql import * +from util.cases import * + +class TDTestCase: + def init(self, conn, logSql): + tdLog.debug("start to execute %s" % __file__) + tdSql.init(conn.cursor()) + + self.row_nums = 10 + self.tb_nums = 10 + self.ts = 1537146000000 + + def prepare_datas(self, stb_name , tb_nums , row_nums ): + tdSql.execute(" use db ") + tdSql.execute(f" create stable {stb_name} (ts timestamp , c1 int , c2 bigint , c3 float , c4 double , c5 smallint , c6 tinyint , c7 bool , c8 binary(36) , c9 nchar(36) , uc1 int unsigned,\ + uc2 bigint unsigned ,uc3 smallint unsigned , uc4 tinyint unsigned ) tags(t1 timestamp , t2 int , t3 bigint , t4 float , t5 double , t6 smallint , t7 tinyint , t8 bool , t9 binary(36)\ + , t10 nchar(36) , t11 int unsigned , t12 bigint unsigned ,t13 smallint unsigned , t14 tinyint unsigned ) ") + + for i in range(tb_nums): + tbname = f"sub_{stb_name}_{i}" + ts = self.ts + i*10000 + tdSql.execute(f"create table {tbname} using {stb_name} tags ({ts} , {i} , {i}*10 ,{i}*1.0,{i}*1.0 , 1 , 2, 'true', 'binary_{i}' ,'nchar_{i}',{i},{i},10,20 )") + + for row in range(row_nums): + ts = self.ts + row*1000 + tdSql.execute(f"insert into {tbname} values({ts} , {row} , {row} , {row} , {row} , 1 , 2 , 'true' , 'binary_{row}' , 'nchar_{row}' , {row} , {row} , 1 ,2 )") + + for null in range(5): + ts = self.ts + row_nums*1000 + null*1000 + tdSql.execute(f"insert into {tbname} values({ts} , NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL )") + + def basic_query(self): + tdSql.query("select count(*) from stb") + tdSql.checkData(0,0,(self.row_nums + 5 )*self.tb_nums) + tdSql.query("select count(c1) from stb") + tdSql.checkData(0,0,(self.row_nums )*self.tb_nums) + tdSql.query(" select tbname , count(*) from stb partition by tbname ") + tdSql.checkRows(self.tb_nums) + tdSql.query(" select count(c1) from stb group by t1 order by t1 ") + tdSql.checkRows(self.tb_nums) + tdSql.error(" select count(c1) from stb group by c1 order by t1 ") + tdSql.error(" select count(t1) from stb group by c1 order by t1 ") + tdSql.query(" select count(c1) from stb group by tbname order by tbname ") + tdSql.checkRows(self.tb_nums) + # bug need fix + # tdSql.query(" select count(t1) from stb group by t2 order by t2 ") + # tdSql.checkRows(self.tb_nums) + tdSql.query(" select count(c1) from stb group by c1 order by c1 ") + tdSql.checkRows(self.row_nums+1) + + tdSql.query(" select c1 , count(c1) from stb group by c1 order by c1 ") + tdSql.checkRows(self.row_nums+1) + + tdSql.query("select count(c1) from stb group by abs(c1) order by abs(c1)") + tdSql.checkRows(self.row_nums+1) + tdSql.query("select abs(c1+c3), count(c1+c3) from stb group by abs(c1+c3) order by abs(c1+c3)") + tdSql.checkRows(self.row_nums+1) + tdSql.query("select count(c1+c3)+max(c2) ,abs(c1) from stb group by abs(c1) order by abs(c1)") + tdSql.checkRows(self.row_nums+1) + tdSql.error("select count(c1+c3)+max(c2) ,abs(c1) ,abs(t1) from stb group by abs(c1) order by abs(t1)+c2") + tdSql.error("select count(c1+c3)+max(c2) ,abs(c1) from stb group by abs(c1) order by abs(c1)+c2") + tdSql.query("select abs(c1+c3)+abs(c2) , count(c1+c3)+count(c2) from stb group by abs(c1+c3)+abs(c2) order by abs(c1+c3)+abs(c2)") + tdSql.checkRows(self.row_nums+1) + + tdSql.query("select count(c1) , count(t2) from stb where abs(c1+t2)=1 partition by tbname") + tdSql.checkRows(2) + tdSql.query("select count(c1) from stb where abs(c1+t2)=1 partition by tbname") + tdSql.checkRows(2) + + tdSql.query("select tbname , count(c1) from stb partition by tbname order by tbname") + tdSql.checkRows(self.tb_nums) + tdSql.checkData(0,1,self.row_nums) + + tdSql.error("select tbname , count(c1) from stb partition by t1 order by t1") + tdSql.error("select tbname , count(t1) from stb partition by t1 order by t1") + tdSql.error("select tbname , count(t1) from stb partition by t2 order by t2") + + # # bug need fix + # tdSql.query("select t2 , count(t1) from stb partition by t2 order by t2") + # tdSql.checkRows(self.tb_nums) + + tdSql.query("select tbname , count(c1) from stb partition by tbname order by tbname") + tdSql.checkRows(self.tb_nums) + tdSql.checkData(0,1,self.row_nums) + + + tdSql.error("select tbname , count(c1) from stb partition by t2 order by t2") + + tdSql.query("select c2, count(c1) from stb partition by c2 order by c2 desc") + tdSql.checkRows(self.tb_nums+1) + tdSql.checkData(0,1,self.tb_nums) + + tdSql.error("select tbname , count(c1) from stb partition by c1 order by c2") + + + tdSql.query("select tbname , abs(t2) from stb partition by c2 order by t2") + tdSql.checkRows(self.tb_nums*(self.row_nums+5)) + + tdSql.query("select count(c1) , count(t2) from stb partition by c2 ") + tdSql.checkRows(self.row_nums+1) + tdSql.checkData(0,1,self.row_nums) + + tdSql.query("select count(c1) , count(t2) ,c2 from stb partition by c2 order by c2") + tdSql.checkRows(self.row_nums+1) + + tdSql.query("select count(c1) , count(t1) ,max(c2) ,tbname from stb partition by tbname order by tbname") + tdSql.checkRows(self.tb_nums) + tdSql.checkCols(4) + + tdSql.query("select count(c1) , count(t2) ,t1 from stb partition by t1 order by t1") + tdSql.checkRows(self.tb_nums) + tdSql.checkData(0,0,self.row_nums) + + tdSql.query("select count(c1) , count(t1) ,abs(c1) from stb partition by abs(c1) order by abs(c1)") + tdSql.checkRows(self.row_nums+1) + + + tdSql.query("select count(ceil(c2)) , count(floor(t2)) ,count(floor(c2)) from stb partition by abs(c2) order by abs(c2)") + tdSql.checkRows(self.row_nums+1) + + + tdSql.query("select count(ceil(c1-2)) , count(floor(t2+1)) ,max(c2-c1) from stb partition by abs(floor(c1)) order by abs(floor(c1))") + tdSql.checkRows(self.row_nums+1) + + + # interval + tdSql.query("select count(c1) from stb interval(2s) sliding(1s)") + + # bug need fix + + # tdSql.query('select max(c1) from stb where ts>="2022-07-06 16:00:00.000 " and ts < "2022-07-06 17:00:00.000 " interval(50s) sliding(30s) fill(NULL)') + # tdSql.checkRows(40) + # tdSql.checkData(0,0,None) + + # tdSql.query(" select tbname , count(c1) from stb partition by tbname interval(10s) slimit 5 soffset 1 ") + + # tdSql.query("select tbname , count(c1) from stb partition by tbname interval(10s)") + + # tdSql.query("select tbname , count(c1) from sub_stb_1 partition by tbname interval(10s)") + # tdSql.checkData(0,0,'sub_stb_1') + # tdSql.checkData(0,1,self.row_nums) + + # tdSql.query(" select tbname , count(c1) from stb partition by tbname order by tbname slimit 5 soffset 0 ") + # tdSql.checkRows(5) + + # tdSql.query(" select tbname , count(c1) from stb partition by tbname order by tbname slimit 5 soffset 1 ") + # tdSql.checkRows(5) + + # tdSql.query(" select tbname , count(c1) from sub_stb_1 partition by tbname interval(10s) sliding(5s) ") + + # tdSql.query(f'select max(c1) from stb where ts>={self.ts} and ts < {self.ts}+1000 interval(50s) sliding(30s)') + # tdSql.query(f'select tbname , count(c1) from stb where ts>={self.ts} and ts < {self.ts}+1000 interval(50s) sliding(30s)') + + + def run(self): + tdSql.prepare() + self.prepare_datas("stb",self.tb_nums,self.row_nums) + self.basic_query() + + # # coverage case for taosd crash about bug fix + tdSql.query(" select sum(c1) from stb where t2+10 >1 ") + tdSql.query(" select count(c1),count(t1) from stb where -t2<1 ") + tdSql.query(" select tbname ,max(ceil(c1)) from stb group by tbname ") + tdSql.query(" select avg(abs(c1)) , tbname from stb group by tbname ") + tdSql.query(" select t1,c1 from stb where abs(t2+c1)=1 ") + + + def stop(self): + tdSql.close() + tdLog.success("%s successfully executed" % __file__) + + +tdCases.addWindows(__file__, TDTestCase()) +tdCases.addLinux(__file__, TDTestCase()) \ No newline at end of file diff --git a/tests/system-test/fulltest.sh b/tests/system-test/fulltest.sh index 409fb5e930..091a5a586c 100755 --- a/tests/system-test/fulltest.sh +++ b/tests/system-test/fulltest.sh @@ -118,7 +118,7 @@ python3 ./test.py -f 2-query/distribute_agg_stddev.py python3 ./test.py -f 2-query/twa.py python3 ./test.py -f 2-query/irate.py python3 ./test.py -f 2-query/and_or_for_byte.py - +python3 ./test.py -f 2-query/count_partition.py python3 ./test.py -f 2-query/function_null.py python3 ./test.py -f 2-query/queryQnode.py @@ -262,6 +262,7 @@ python3 ./test.py -f 2-query/distribute_agg_stddev.py -Q 2 python3 ./test.py -f 2-query/twa.py -Q 2 python3 ./test.py -f 2-query/irate.py -Q 2 python3 ./test.py -f 2-query/function_null.py -Q 2 +python3 ./test.py -f 2-query/count_partition.py -Q 2 #------------querPolicy 3----------- @@ -347,3 +348,4 @@ python3 ./test.py -f 2-query/distribute_agg_stddev.py -Q 3 python3 ./test.py -f 2-query/twa.py -Q 3 python3 ./test.py -f 2-query/irate.py -Q 3 python3 ./test.py -f 2-query/function_null.py -Q 3 +python3 ./test.py -f 2-query/count_partition.py -Q 3 From 12e56b2f97d7d360f0ebf1502af94645a77b272d Mon Sep 17 00:00:00 2001 From: "wenzhouwww@live.cn" Date: Sun, 10 Jul 2022 20:05:16 +0800 Subject: [PATCH 02/30] update --- tests/system-test/2-query/count_partition.py | 26 +-- tests/system-test/2-query/max_partition.py | 189 +++++++++++++++++++ tests/system-test/fulltest.sh | 3 + 3 files changed, 205 insertions(+), 13 deletions(-) create mode 100644 tests/system-test/2-query/max_partition.py diff --git a/tests/system-test/2-query/count_partition.py b/tests/system-test/2-query/count_partition.py index c1fbd2b784..a25b4c09c1 100644 --- a/tests/system-test/2-query/count_partition.py +++ b/tests/system-test/2-query/count_partition.py @@ -113,8 +113,9 @@ class TDTestCase: tdSql.checkRows(self.tb_nums) tdSql.checkData(0,0,self.row_nums) - tdSql.query("select count(c1) , count(t1) ,abs(c1) from stb partition by abs(c1) order by abs(c1)") - tdSql.checkRows(self.row_nums+1) + # bug need fix + # tdSql.query("select count(c1) , count(t1) ,abs(c1) from stb partition by abs(c1) order by abs(c1)") + # tdSql.checkRows(self.row_nums+1) tdSql.query("select count(ceil(c2)) , count(floor(t2)) ,count(floor(c2)) from stb partition by abs(c2) order by abs(c2)") @@ -130,17 +131,15 @@ class TDTestCase: # bug need fix - # tdSql.query('select max(c1) from stb where ts>="2022-07-06 16:00:00.000 " and ts < "2022-07-06 17:00:00.000 " interval(50s) sliding(30s) fill(NULL)') - # tdSql.checkRows(40) - # tdSql.checkData(0,0,None) + tdSql.query('select max(c1) from stb where ts>="2022-07-06 16:00:00.000 " and ts < "2022-07-06 17:00:00.000 " interval(50s) sliding(30s) fill(NULL)') - # tdSql.query(" select tbname , count(c1) from stb partition by tbname interval(10s) slimit 5 soffset 1 ") + tdSql.query(" select tbname , count(c1) from stb partition by tbname interval(10s) slimit 5 soffset 1 ") - # tdSql.query("select tbname , count(c1) from stb partition by tbname interval(10s)") + tdSql.query("select tbname , count(c1) from stb partition by tbname interval(10s)") - # tdSql.query("select tbname , count(c1) from sub_stb_1 partition by tbname interval(10s)") - # tdSql.checkData(0,0,'sub_stb_1') - # tdSql.checkData(0,1,self.row_nums) + tdSql.query("select tbname , count(c1) from sub_stb_1 partition by tbname interval(10s)") + tdSql.checkData(0,0,'sub_stb_1') + tdSql.checkData(0,1,self.row_nums) # tdSql.query(" select tbname , count(c1) from stb partition by tbname order by tbname slimit 5 soffset 0 ") # tdSql.checkRows(5) @@ -148,10 +147,11 @@ class TDTestCase: # tdSql.query(" select tbname , count(c1) from stb partition by tbname order by tbname slimit 5 soffset 1 ") # tdSql.checkRows(5) - # tdSql.query(" select tbname , count(c1) from sub_stb_1 partition by tbname interval(10s) sliding(5s) ") + tdSql.query(" select tbname , count(c1) from sub_stb_1 partition by tbname interval(10s) sliding(5s) ") - # tdSql.query(f'select max(c1) from stb where ts>={self.ts} and ts < {self.ts}+1000 interval(50s) sliding(30s)') - # tdSql.query(f'select tbname , count(c1) from stb where ts>={self.ts} and ts < {self.ts}+1000 interval(50s) sliding(30s)') + tdSql.query(f'select max(c1) from stb where ts>={self.ts} and ts < {self.ts}+10000 partition by tbname interval(50s) sliding(30s)') + tdSql.query(f'select max(c1) from stb where ts>={self.ts} and ts < {self.ts}+10000 interval(50s) sliding(30s)') + tdSql.query(f'select tbname , count(c1) from stb where ts>={self.ts} and ts < {self.ts}+10000 partition by tbname interval(50s) sliding(30s)') def run(self): diff --git a/tests/system-test/2-query/max_partition.py b/tests/system-test/2-query/max_partition.py new file mode 100644 index 0000000000..90b8d25cb1 --- /dev/null +++ b/tests/system-test/2-query/max_partition.py @@ -0,0 +1,189 @@ +# author : wenzhouwww +from util.log import * +from util.sql import * +from util.cases import * + +class TDTestCase: + def init(self, conn, logSql): + tdLog.debug("start to execute %s" % __file__) + tdSql.init(conn.cursor()) + + self.row_nums = 10 + self.tb_nums = 10 + self.ts = 1537146000000 + + def prepare_datas(self, stb_name , tb_nums , row_nums ): + tdSql.execute(" use db ") + tdSql.execute(f" create stable {stb_name} (ts timestamp , c1 int , c2 bigint , c3 float , c4 double , c5 smallint , c6 tinyint , c7 bool , c8 binary(36) , c9 nchar(36) , uc1 int unsigned,\ + uc2 bigint unsigned ,uc3 smallint unsigned , uc4 tinyint unsigned ) tags(t1 timestamp , t2 int , t3 bigint , t4 float , t5 double , t6 smallint , t7 tinyint , t8 bool , t9 binary(36)\ + , t10 nchar(36) , t11 int unsigned , t12 bigint unsigned ,t13 smallint unsigned , t14 tinyint unsigned ) ") + + for i in range(tb_nums): + tbname = f"sub_{stb_name}_{i}" + ts = self.ts + i*10000 + tdSql.execute(f"create table {tbname} using {stb_name} tags ({ts} , {i} , {i}*10 ,{i}*1.0,{i}*1.0 , 1 , 2, 'true', 'binary_{i}' ,'nchar_{i}',{i},{i},10,20 )") + + for row in range(row_nums): + ts = self.ts + row*1000 + tdSql.execute(f"insert into {tbname} values({ts} , {row} , {row} , {row} , {row} , 1 , 2 , 'true' , 'binary_{row}' , 'nchar_{row}' , {row} , {row} , 1 ,2 )") + + for null in range(5): + ts = self.ts + row_nums*1000 + null*1000 + tdSql.execute(f"insert into {tbname} values({ts} , NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL , NULL )") + + def basic_query(self): + tdSql.query("select count(*) from stb") + tdSql.checkData(0,0,(self.row_nums + 5 )*self.tb_nums) + tdSql.query("select max(c1) from stb") + tdSql.checkData(0,0,(self.row_nums -1)) + tdSql.query(" select tbname , max(c1) from stb partition by tbname ") + tdSql.checkRows(self.tb_nums) + tdSql.query(" select max(c1) from stb group by t1 order by t1 ") + tdSql.checkRows(self.tb_nums) + tdSql.query(" select max(c1) from stb group by c1 order by t1 ") + tdSql.query(" select max(t2) from stb group by c1 order by t1 ") + tdSql.query(" select max(c1) from stb group by tbname order by tbname ") + tdSql.checkRows(self.tb_nums) + # bug need fix + # tdSql.query(" select max(t1) from stb group by t2 order by t2 ") + # tdSql.checkRows(self.tb_nums) + tdSql.query(" select max(c1) from stb group by c1 order by c1 ") + tdSql.checkRows(self.row_nums+1) + + tdSql.query(" select c1 , max(c1) from stb group by c1 order by c1 ") + tdSql.checkRows(self.row_nums+1) + + # support selective functions + tdSql.query(" select c1 ,c2 ,c3 , max(c1) ,c4 ,c5 ,t11 from stb group by c1 order by c1 desc ") + tdSql.checkRows(self.row_nums+1) + + tdSql.query(" select c1, tbname , max(c1) ,c4 ,c5 ,t11 from stb group by c1 order by c1 desc ") + tdSql.checkRows(self.row_nums+1) + + # bug need fix + # tdSql.query(" select tbname , max(c1) from sub_stb_1 where c1 is null group by c1 order by c1 desc ") + # tdSql.checkRows(1) + # tdSql.checkData(0,0,"sub_stb_1") + + tdSql.query("select max(c1) ,c2 ,t2,tbname from stb group by abs(c1) order by abs(c1)") + tdSql.checkRows(self.row_nums+1) + tdSql.query("select abs(c1+c3), count(c1+c3) ,max(c1+t2) from stb group by abs(c1+c3) order by abs(c1+c3)") + tdSql.checkRows(self.row_nums+1) + tdSql.query("select max(c1+c3)+min(c2) ,abs(c1) from stb group by abs(c1) order by abs(c1)") + tdSql.checkRows(self.row_nums+1) + tdSql.error("select count(c1+c3)+max(c2) ,abs(c1) ,abs(t1) from stb group by abs(c1) order by abs(t1)+c2") + tdSql.error("select count(c1+c3)+max(c2) ,abs(c1) from stb group by abs(c1) order by abs(c1)+c2") + tdSql.query("select abs(c1+c3)+abs(c2) , count(c1+c3)+max(c2) from stb group by abs(c1+c3)+abs(c2) order by abs(c1+c3)+abs(c2)") + tdSql.checkRows(self.row_nums+1) + + tdSql.query(" select max(c1) , max(t2) from stb where abs(c1+t2)=1 partition by tbname ") + tdSql.checkRows(2) + tdSql.query(" select max(c1) from stb where abs(c1+t2)=1 partition by tbname ") + tdSql.checkRows(2) + + tdSql.query(" select tbname , max(c1) from stb partition by tbname order by tbname ") + tdSql.checkRows(self.tb_nums) + tdSql.checkData(0,1,self.row_nums-1) + + tdSql.query("select tbname , max(c2) from stb partition by t1 order by t1") + tdSql.query("select tbname , max(t2) from stb partition by t1 order by t1") + tdSql.query("select tbname , max(t2) from stb partition by t2 order by t2") + + # # bug need fix + # tdSql.query("select t2 , max(t2) from stb partition by t2 order by t2") + # tdSql.checkRows(self.tb_nums) + + tdSql.query("select tbname , max(c1) from stb partition by tbname order by tbname") + tdSql.checkRows(self.tb_nums) + tdSql.checkData(0,1,self.row_nums-1) + + + tdSql.query("select tbname , max(c1) from stb partition by t2 order by t2") + + tdSql.query("select c2, max(c1) from stb partition by c2 order by c2 desc") + tdSql.checkRows(self.tb_nums+1) + tdSql.checkData(0,1,self.row_nums-1) + + tdSql.query("select tbname , max(c1) from stb partition by c1 order by c2") + + + tdSql.query("select tbname , abs(t2) from stb partition by c2 order by t2") + tdSql.checkRows(self.tb_nums*(self.row_nums+5)) + + tdSql.query("select max(c1) , count(t2) from stb partition by c2 ") + tdSql.checkRows(self.row_nums+1) + tdSql.checkData(0,1,self.row_nums) + + tdSql.query("select count(c1) , max(t2) ,c2 from stb partition by c2 order by c2") + tdSql.checkRows(self.row_nums+1) + + tdSql.query("select count(c1) , count(t1) ,max(c2) ,tbname from stb partition by tbname order by tbname") + tdSql.checkRows(self.tb_nums) + tdSql.checkCols(4) + + tdSql.query("select count(c1) , max(t2) ,t1 from stb partition by t1 order by t1") + tdSql.checkRows(self.tb_nums) + tdSql.checkData(0,0,self.row_nums) + + # bug need fix + # tdSql.query("select count(c1) , max(t1) ,abs(c1) from stb partition by abs(c1) order by abs(c1)") + # tdSql.checkRows(self.row_nums+1) + + + tdSql.query("select max(ceil(c2)) , max(floor(t2)) ,max(floor(c2)) from stb partition by abs(c2) order by abs(c2)") + tdSql.checkRows(self.row_nums+1) + + + tdSql.query("select max(ceil(c1-2)) , max(floor(t2+1)) ,max(c2-c1) from stb partition by abs(floor(c1)) order by abs(floor(c1))") + tdSql.checkRows(self.row_nums+1) + + + # interval + tdSql.query("select max(c1) from stb interval(2s) sliding(1s)") + + # bug need fix + + tdSql.query('select max(c1) from stb where ts>="2022-07-06 16:00:00.000 " and ts < "2022-07-06 17:00:00.000 " interval(50s) sliding(30s) fill(NULL)') + + tdSql.query(" select tbname , count(c1) from stb partition by tbname interval(10s) slimit 5 soffset 1 ") + + tdSql.query("select tbname , max(c1) from stb partition by tbname interval(10s)") + tdSql.checkRows(self.row_nums*2) + + tdSql.query("select tbname , count(c1) from sub_stb_1 partition by tbname interval(10s)") + tdSql.checkData(0,0,'sub_stb_1') + tdSql.checkData(0,1,self.row_nums) + + # bug need fix + # tdSql.query(" select tbname , max(c1) from stb partition by tbname order by tbname slimit 5 soffset 0 ") + # tdSql.checkRows(5) + + # tdSql.query(" select tbname , max(c1) from stb partition by tbname order by tbname slimit 5 soffset 1 ") + # tdSql.checkRows(5) + + tdSql.query(" select tbname , max(c1) from sub_stb_1 partition by tbname interval(10s) sliding(5s) ") + + tdSql.query(f'select max(c1) from stb where ts>={self.ts} and ts < {self.ts}+1000 interval(50s) sliding(30s)') + tdSql.query(f'select tbname , max(c1) from stb where ts>={self.ts} and ts < {self.ts}+1000 interval(50s) sliding(30s)') + + + def run(self): + tdSql.prepare() + self.prepare_datas("stb",self.tb_nums,self.row_nums) + self.basic_query() + + # # coverage case for taosd crash about bug fix + tdSql.query(" select sum(c1) from stb where t2+10 >1 ") + tdSql.query(" select count(c1),count(t1) from stb where -t2<1 ") + tdSql.query(" select tbname ,max(ceil(c1)) from stb group by tbname ") + tdSql.query(" select avg(abs(c1)) , tbname from stb group by tbname ") + tdSql.query(" select t1,c1 from stb where abs(t2+c1)=1 ") + + + def stop(self): + tdSql.close() + tdLog.success("%s successfully executed" % __file__) + + +tdCases.addWindows(__file__, TDTestCase()) +tdCases.addLinux(__file__, TDTestCase()) \ No newline at end of file diff --git a/tests/system-test/fulltest.sh b/tests/system-test/fulltest.sh index 091a5a586c..15e6ecd61c 100755 --- a/tests/system-test/fulltest.sh +++ b/tests/system-test/fulltest.sh @@ -121,6 +121,7 @@ python3 ./test.py -f 2-query/and_or_for_byte.py python3 ./test.py -f 2-query/count_partition.py python3 ./test.py -f 2-query/function_null.py python3 ./test.py -f 2-query/queryQnode.py +python3 ./test.py -f 2-query/max_partition.py #python3 ./test.py -f 6-cluster/5dnode1mnode.py #python3 ./test.py -f 6-cluster/5dnode2mnode.py -N 5 -M 3 @@ -263,6 +264,7 @@ python3 ./test.py -f 2-query/twa.py -Q 2 python3 ./test.py -f 2-query/irate.py -Q 2 python3 ./test.py -f 2-query/function_null.py -Q 2 python3 ./test.py -f 2-query/count_partition.py -Q 2 +python3 ./test.py -f 2-query/max_partition.py -Q 2 #------------querPolicy 3----------- @@ -349,3 +351,4 @@ python3 ./test.py -f 2-query/twa.py -Q 3 python3 ./test.py -f 2-query/irate.py -Q 3 python3 ./test.py -f 2-query/function_null.py -Q 3 python3 ./test.py -f 2-query/count_partition.py -Q 3 +python3 ./test.py -f 2-query/max_partition.py -Q 3 \ No newline at end of file From 6f501bb33da213a8fa1a2a86db0656a1654f9fb0 Mon Sep 17 00:00:00 2001 From: "slzhou@taodata.com" Date: Tue, 12 Jul 2022 09:59:11 +0800 Subject: [PATCH 03/30] fix: select tag from st will tag blocks composed of num of records --- source/libs/planner/src/planLogicCreater.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/source/libs/planner/src/planLogicCreater.c b/source/libs/planner/src/planLogicCreater.c index cb38e1fc18..c29a03f617 100644 --- a/source/libs/planner/src/planLogicCreater.c +++ b/source/libs/planner/src/planLogicCreater.c @@ -162,12 +162,11 @@ static EScanType getScanType(SLogicPlanContext* pCxt, SNodeList* pScanPseudoCols } if (NULL == pScanCols) { - // select count(*) from t return NULL == pScanPseudoCols ? SCAN_TYPE_TABLE : ((FUNCTION_TYPE_BLOCK_DIST_INFO == ((SFunctionNode*)nodesListGetNode(pScanPseudoCols, 0))->funcType) ? SCAN_TYPE_BLOCK_INFO - : SCAN_TYPE_TAG); + : SCAN_TYPE_TABLE); } if (TSDB_SYSTEM_TABLE == tableType) { @@ -181,7 +180,7 @@ static EScanType getScanType(SLogicPlanContext* pCxt, SNodeList* pScanPseudoCols } } - return SCAN_TYPE_TAG; + return SCAN_TYPE_TABLE; } static SNode* createPrimaryKeyCol(uint64_t tableId) { From 487f1e0f52e804a46c87f96afa8e4ef93876f767 Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Tue, 12 Jul 2022 10:55:51 +0800 Subject: [PATCH 04/30] enh(query): avg function adoption for MIA operator TD-17254 --- source/libs/function/src/builtinsimpl.c | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c index 359352951f..404274ee52 100644 --- a/source/libs/function/src/builtinsimpl.c +++ b/source/libs/function/src/builtinsimpl.c @@ -907,11 +907,13 @@ int32_t avgFunctionMerge(SqlFunctionCtx* pCtx) { SAvgRes* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx)); - int32_t start = pInput->startRowIndex; - char* data = colDataGetData(pCol, start); - SAvgRes* pInputInfo = (SAvgRes*)varDataVal(data); + int32_t start = pInput->startRowIndex; - avgTransferInfo(pInputInfo, pInfo); + for(int32_t i = start; i < start + pInput->numOfRows; ++i) { + char* data = colDataGetData(pCol, i); + SAvgRes* pInputInfo = (SAvgRes*)varDataVal(data); + avgTransferInfo(pInputInfo, pInfo); + } SET_VAL(GET_RES_INFO(pCtx), 1, 1); @@ -4164,10 +4166,10 @@ int32_t histogramFunctionMerge(SqlFunctionCtx* pCtx) { SHistoFuncInfo* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx)); - int32_t start = pInput->startRowIndex; + int32_t start = pInput->startRowIndex; for(int32_t i = start; i < start + pInput->numOfRows; ++i) { - char* data = colDataGetData(pCol, i); + char* data = colDataGetData(pCol, i); SHistoFuncInfo* pInputInfo = (SHistoFuncInfo*)varDataVal(data); histogramTransferInfo(pInputInfo, pInfo); } From 884b35928a907a070cddd3f01b1dfccf94aa55bd Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Tue, 12 Jul 2022 10:55:51 +0800 Subject: [PATCH 05/30] enh(query): apercentile function adoption for MIA operator TD-17254 --- source/libs/function/src/builtinsimpl.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c index 404274ee52..c6f9565bda 100644 --- a/source/libs/function/src/builtinsimpl.c +++ b/source/libs/function/src/builtinsimpl.c @@ -2514,11 +2514,13 @@ int32_t apercentileFunctionMerge(SqlFunctionCtx* pCtx) { SAPercentileInfo* pInfo = GET_ROWCELL_INTERBUF(pResInfo); - int32_t start = pInput->startRowIndex; - char* data = colDataGetData(pCol, start); - SAPercentileInfo* pInputInfo = (SAPercentileInfo*)varDataVal(data); + int32_t start = pInput->startRowIndex; - apercentileTransferInfo(pInputInfo, pInfo); + for(int32_t i = start; i < start + pInput->numOfRows; ++i) { + char* data = colDataGetData(pCol, i); + SAPercentileInfo* pInputInfo = (SAPercentileInfo*)varDataVal(data); + apercentileTransferInfo(pInputInfo, pInfo); + } SET_VAL(pResInfo, 1, 1); return TSDB_CODE_SUCCESS; From ec4874f6b65150b2e10e65eb229d6dd588667155 Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Tue, 12 Jul 2022 10:55:51 +0800 Subject: [PATCH 06/30] enh(query): spread function adoption for MIA operator TD-17254 --- source/libs/function/src/builtinsimpl.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c index c6f9565bda..1a4821b982 100644 --- a/source/libs/function/src/builtinsimpl.c +++ b/source/libs/function/src/builtinsimpl.c @@ -3707,11 +3707,13 @@ int32_t spreadFunctionMerge(SqlFunctionCtx* pCtx) { SSpreadInfo* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx)); - int32_t start = pInput->startRowIndex; - char* data = colDataGetData(pCol, start); - SSpreadInfo* pInputInfo = (SSpreadInfo*)varDataVal(data); + int32_t start = pInput->startRowIndex; - spreadTransferInfo(pInputInfo, pInfo); + for(int32_t i = start; i < start + pInput->numOfRows; ++i) { + char* data = colDataGetData(pCol, i); + SSpreadInfo* pInputInfo = (SSpreadInfo*)varDataVal(data); + spreadTransferInfo(pInputInfo, pInfo); + } SET_VAL(GET_RES_INFO(pCtx), 1, 1); From 76482161f5aa9fe6007131b3e645e6cf68efed3e Mon Sep 17 00:00:00 2001 From: "slzhou@taodata.com" Date: Tue, 12 Jul 2022 11:37:57 +0800 Subject: [PATCH 07/30] feat: modify test case that defaults to table scan when query tags --- tests/system-test/2-query/abs.py | 6 ++-- tests/system-test/2-query/json_tag.py | 49 ++++++++------------------- 2 files changed, 17 insertions(+), 38 deletions(-) diff --git a/tests/system-test/2-query/abs.py b/tests/system-test/2-query/abs.py index 5e5bb0df3c..7ebb2eba8c 100644 --- a/tests/system-test/2-query/abs.py +++ b/tests/system-test/2-query/abs.py @@ -538,9 +538,9 @@ class TDTestCase: tdSql.query("select c1 ,t1 from stb1 where t1 =0 ") tdSql.checkRows(13) tdSql.query("select t1 from stb1 where t1 >0 ") - tdSql.checkRows(3) + tdSql.checkRows(12) tdSql.query("select t1 from stb1 where t1 =3 ") - tdSql.checkRows(1) + tdSql.checkRows(12) # tdSql.query("select sum(t1) from (select c1 ,t1 from stb1)") # tdSql.checkData(0,0,61) # tdSql.query("select distinct(c1) ,t1 from stb1") @@ -550,7 +550,7 @@ class TDTestCase: # tag filter with abs function tdSql.query("select t1 from stb1 where abs(t1)=1") - tdSql.checkRows(1) + tdSql.checkRows(0) tdSql.query("select t1 from stb1 where abs(c1+t1)=1") tdSql.checkRows(1) tdSql.checkData(0,0,0) diff --git a/tests/system-test/2-query/json_tag.py b/tests/system-test/2-query/json_tag.py index f66f0f67ab..70aca9fd93 100644 --- a/tests/system-test/2-query/json_tag.py +++ b/tests/system-test/2-query/json_tag.py @@ -57,7 +57,7 @@ class TDTestCase: # 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.checkData(0, 0, '{" ":90,"1tag$":2,"tag1":null}') + tdSql.checkRows(0); tdSql.query("select ts,jtag from jsons1 order by ts limit 2,3") tdSql.checkData(0, 0, '2020-06-02 09:17:08.000') @@ -153,38 +153,17 @@ class TDTestCase: #test scalar operation tdSql.query("select jtag contains 'tag1',jtag->'tag1' from jsons1 order by jtag->'tag1'") - tdSql.checkRows(13) - tdSql.checkData(0, 0, False) - tdSql.checkData(5, 0, True) - tdSql.checkData(12, 0, True) + tdSql.checkRows(9) tdSql.query("select jtag->'tag1' like 'fe%',jtag->'tag1' from jsons1 order by jtag->'tag1'") - tdSql.checkRows(13) - tdSql.checkData(10, 0, False) - tdSql.checkData(11, 0, False) - tdSql.checkData(12, 0, True) + tdSql.checkRows(9) tdSql.query("select jtag->'tag1' not like 'fe%',jtag->'tag1' from jsons1 order by jtag->'tag1'") - tdSql.checkRows(13) - tdSql.checkData(10, 0, False) - tdSql.checkData(11, 0, True) - tdSql.checkData(12, 0, False) + tdSql.checkRows(9) tdSql.query("select jtag->'tag1' match 'fe',jtag->'tag1' from jsons1 order by jtag->'tag1'") - tdSql.checkRows(13) - tdSql.checkData(10, 0, False) - tdSql.checkData(11, 0, False) - tdSql.checkData(12, 0, True) + tdSql.checkRows(9) tdSql.query("select jtag->'tag1' nmatch 'fe',jtag->'tag1' from jsons1 order by jtag->'tag1'") - tdSql.checkRows(13) - tdSql.checkData(10, 0, False) - tdSql.checkData(11, 0, True) - tdSql.checkData(12, 0, False) + tdSql.checkRows(9) tdSql.query("select jtag->'tag1',jtag->'tag1'>='a' from jsons1 order by jtag->'tag1'") - tdSql.checkRows(13) - tdSql.checkData(0, 0, None) - tdSql.checkData(0, 1, False) - tdSql.checkData(7, 0, "false") - tdSql.checkData(7, 1, False) - tdSql.checkData(8, 1, False) - tdSql.checkData(12, 1, True) + tdSql.checkRows(9) # test select normal column tdSql.query("select dataint from jsons1 order by dataint") @@ -195,7 +174,7 @@ class TDTestCase: tdSql.query("select * from jsons1") tdSql.checkRows(9) tdSql.query("select jtag from jsons1") - tdSql.checkRows(13) + tdSql.checkRows(9) tdSql.query("select * from jsons1 where jtag is null") tdSql.checkRows(1) tdSql.query("select * from jsons1 where jtag is not null") @@ -227,7 +206,7 @@ class TDTestCase: tdSql.checkData(0, 0, None) tdSql.query("select jtag->'tag1' from jsons1") - tdSql.checkRows(13) + tdSql.checkRows(9) # test header name res = tdSql.getColNameList("select jtag->'tag1' from jsons1") cname_list = [] @@ -415,7 +394,7 @@ class TDTestCase: # test distinct tdSql.execute("insert into jsons1_14 using jsons1 tags('{\"tag1\":\"收到货\",\"tag2\":\"\",\"tag3\":null}') values(1591062628000, 2, NULL, '你就会', 'dws')") tdSql.query("select distinct jtag->'tag1' from jsons1") - tdSql.checkRows(8) + tdSql.checkRows(7) # tdSql.query("select distinct jtag from jsons1") # tdSql.checkRows(9) @@ -523,12 +502,12 @@ class TDTestCase: # union all tdSql.query("select jtag->'tag1' from jsons1 union all select jtag->'tag2' from jsons2") - tdSql.checkRows(17) + tdSql.checkRows(13) tdSql.query("select jtag->'tag1' from jsons1_1 union all select jtag->'tag2' from jsons2_1") - tdSql.checkRows(2) + tdSql.checkRows(3) tdSql.query("select jtag->'tag1' from jsons1_1 union all select jtag->'tag1' from jsons2_1") - tdSql.checkRows(2) + tdSql.checkRows(3) tdSql.query("select dataint,jtag->'tag1',tbname from jsons1 union all select dataint,jtag->'tag1',tbname from jsons2") tdSql.checkRows(13) tdSql.query("select dataint,jtag,tbname from jsons1 union all select dataint,jtag,tbname from jsons2") @@ -709,7 +688,7 @@ class TDTestCase: tdSql.checkData(0, 0, None) tdSql.execute("CREATE TABLE if not exists jsons1_20 using jsons1 tags(NULL)") tdSql.query("select jtag from jsons1_20") - tdSql.checkData(0, 0, None) + tdSql.checkRows(0) tdSql.execute("insert into jsons1_21 using jsons1 tags(NULL) values(1591061628000, 11, false, '你就会','')") tdSql.query("select jtag from jsons1_21") tdSql.checkData(0, 0, None) From 7f875b51202db8baad2e32974d69a7341e263a63 Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Tue, 12 Jul 2022 10:55:51 +0800 Subject: [PATCH 08/30] enh(query): elapsed function adoption for MIA operator TD-17254 --- source/libs/function/src/builtinsimpl.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c index 1a4821b982..4f88ebc9ab 100644 --- a/source/libs/function/src/builtinsimpl.c +++ b/source/libs/function/src/builtinsimpl.c @@ -3879,11 +3879,13 @@ int32_t elapsedFunctionMerge(SqlFunctionCtx* pCtx) { SElapsedInfo* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx)); - int32_t start = pInput->startRowIndex; - char* data = colDataGetData(pCol, start); - SElapsedInfo* pInputInfo = (SElapsedInfo*)varDataVal(data); + int32_t start = pInput->startRowIndex; - elapsedTransferInfo(pInputInfo, pInfo); + for(int32_t i = start; i < start + pInput->numOfRows; ++i) { + char* data = colDataGetData(pCol, i); + SElapsedInfo* pInputInfo = (SElapsedInfo*)varDataVal(data); + elapsedTransferInfo(pInputInfo, pInfo); + } SET_VAL(GET_RES_INFO(pCtx), 1, 1); return TSDB_CODE_SUCCESS; From 7d95ac2a46b46886fd9d3ca5d6f046af5d538c9f Mon Sep 17 00:00:00 2001 From: gccgdb1234 Date: Tue, 12 Jul 2022 12:03:40 +0800 Subject: [PATCH 09/30] doc: change develop->insert for 3.0 --- docs/en/07-develop/03-insert-data/01-sql-writing.mdx | 10 +++++----- docs/zh/07-develop/03-insert-data/01-sql-writing.mdx | 10 +++++----- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/docs/en/07-develop/03-insert-data/01-sql-writing.mdx b/docs/en/07-develop/03-insert-data/01-sql-writing.mdx index d8c4453f40..4bd5e31b6f 100644 --- a/docs/en/07-develop/03-insert-data/01-sql-writing.mdx +++ b/docs/en/07-develop/03-insert-data/01-sql-writing.mdx @@ -42,7 +42,7 @@ INSERT INTO d1001 VALUES (1538548684000, 10.2, 220, 0.23) (1538548696650, 10.3, ### Insert into Multiple Tables -Data can be inserted into multiple tables in the same SQL statement. The example below inserts 2 rows into table "d1001" and 1 row into table "d1002". +Data can be inserted into multiple tables in single SQL statement. The example below inserts 2 rows into table "d1001" and 1 row into table "d1002". ```sql INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6, 218, 0.33) d1002 VALUES (1538548696800, 12.3, 221, 0.31); @@ -52,15 +52,15 @@ For more details about `INSERT` please refer to [INSERT](/taos-sql/insert). :::info -- Inserting in batches can improve performance. Normally, the higher the batch size, the better the performance. Please note that a single row can't exceed 48K bytes and each SQL statement can't exceed 1MB. -- Inserting with multiple threads can also improve performance. However, depending on the system resources on the application side and the server side, when the number of inserting threads grows beyond a specific point the performance may drop instead of improving. The proper number of threads needs to be tested in a specific environment to find the best number. +- Inserting in batches can improve performance. Normally, the higher the batch size, the better the performance. Please note that a single row can't exceed 48 KB bytes and each SQL statement can't exceed 1 MB. +- Inserting with multiple threads can also improve performance. However, depending on the system resources on the application side and the server side, when the number of inserting threads grows beyond a specific point the performance may drop instead of improving. The proper number of threads needs to be tested in a specific environment to find the best number. The proper number of threads may be impacted by the system resources on the server side, the system resources on the client side, the table schemas, etc. ::: :::warning -- If the timestamp for the row to be inserted already exists in the table, the behavior depends on the value of parameter `UPDATE`. If it's set to 0 (the default value), the row will be discarded. If it's set to 1, the new values will override the old values for the same row. -- The timestamp to be inserted must be newer than the timestamp of subtracting current time by the parameter `KEEP`. If `KEEP` is set to 3650 days, then the data older than 3650 days ago can't be inserted. The timestamp to be inserted can't be newer than the timestamp of current time plus parameter `DAYS`. If `DAYS` is set to 2, the data newer than 2 days later can't be inserted. +- If the timestamp for the row to be inserted already exists in the table, the old data will be overritten by the new values for the columns for which new values are provided, columns for which no new values are provided are not impacted. +- The timestamp to be inserted must be newer than the timestamp of subtracting current time by the parameter `KEEP`. If `KEEP` is set to 3650 days, then the data older than 3650 days ago can't be inserted. The timestamp to be inserted can't be newer than the timestamp of current time plus parameter `DURATION`. If `DAYS` is set to 2, the data newer than 2 days later can't be inserted. ::: diff --git a/docs/zh/07-develop/03-insert-data/01-sql-writing.mdx b/docs/zh/07-develop/03-insert-data/01-sql-writing.mdx index 99a92573c8..214cbdaa96 100644 --- a/docs/zh/07-develop/03-insert-data/01-sql-writing.mdx +++ b/docs/zh/07-develop/03-insert-data/01-sql-writing.mdx @@ -52,15 +52,15 @@ INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6, :::info -- 要提高写入效率，需要批量写入。一批写入的记录条数越多，插入效率就越高。但一条记录不能超过 48K，一条 SQL 语句总长度不能超过 1M 。 -- TDengine 支持多线程同时写入，要进一步提高写入速度，一个客户端需要打开 20 个以上的线程同时写。但线程数达到一定数量后，无法再提高，甚至还会下降，因为线程频繁切换，带来额外开销。 +- 要提高写入效率，需要批量写入。一般来说一批写入的记录条数越多，插入效率就越高。但一条记录不能超过 48K，一条 SQL 语句总长度不能超过 1M 。 +- TDengine 支持多线程同时写入，要进一步提高写入速度，一个客户端需要打开多个同时写。但线程数达到一定数量后，无法再提高，甚至还会下降，因为线程频繁切换，会带来额外开销，合适的线程数量与服务端的处理能力，服务端的具体配置，数据库的参数，数据定义的 Schema，写入数据的 Batch Size 等很多因素相关。一般来说，服务端和客户端处理能力越强，所能支持的并发写入的线程可以越多；数据库配置时的 vgroups 越多（但仍然要在服务端的处理能力以内）则所能支持的并发写入越多；数据定义的 Schema 越简单，所能支持的并发写入越多。 ::: :::warning -- 对同一张表，如果新插入记录的时间戳已经存在，默认情形下（UPDATE=0）新记录将被直接抛弃，也就是说，在一张表里，时间戳必须是唯一的。如果应用自动生成记录，很有可能生成的时间戳是一样的，这样，成功插入的记录条数会小于应用插入的记录条数。如果在创建数据库时使用了 UPDATE 1 选项，插入相同时间戳的新记录将覆盖原有记录。 -- 写入的数据的时间戳必须大于当前时间减去配置参数 keep 的时间。如果 keep 配置为 3650 天，那么无法写入比 3650 天还早的数据。写入数据的时间戳也不能大于当前时间加配置参数 days。如果 days 为 2，那么无法写入比当前时间还晚 2 天的数据。 +- 对同一张表，如果新插入记录的时间戳已经存在，则指定了新值的列会用新值覆盖旧值，而没有指定新值的列则不受影响。 +- 写入的数据的时间戳必须大于当前时间减去配置参数 keep 的时间。如果 keep 配置为 3650 天，那么无法写入比 3650 天还早的数据。写入数据的时间戳也不能大于当前时间加配置参数 duration。如果 duration 为 2，那么无法写入比当前时间还晚 2 天的数据。 ::: @@ -104,7 +104,7 @@ INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6, ### 参数绑定写入 -TDengine 也提供了支持参数绑定的 Prepare API，与 MySQL 类似，这些 API 目前也仅支持用问号 `?` 来代表待绑定的参数。从 2.1.1.0 和 2.1.2.0 版本开始，TDengine 大幅改进了参数绑定接口对数据写入（INSERT）场景的支持。这样在通过参数绑定接口写入数据时，就避免了 SQL 语法解析的资源消耗，从而在绝大多数情况下显著提升写入性能。 +TDengine 也提供了支持参数绑定的 Prepare API，与 MySQL 类似，这些 API 目前也仅支持用问号 `?` 来代表待绑定的参数。在通过参数绑定接口写入数据时，就避免了 SQL 语法解析的资源消耗，从而在绝大多数情况下显著提升写入性能。 需要注意的是，只有使用原生连接的连接器，才能使用参数绑定功能。 From d577505c88a9d347b60a8d19ed1b02be41ca3220 Mon Sep 17 00:00:00 2001 From: gccgdb1234 Date: Tue, 12 Jul 2022 12:06:07 +0800 Subject: [PATCH 10/30] doc: change develop->insert --- docs/en/07-develop/03-insert-data/01-sql-writing.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/en/07-develop/03-insert-data/01-sql-writing.mdx b/docs/en/07-develop/03-insert-data/01-sql-writing.mdx index 4bd5e31b6f..da0e87abbc 100644 --- a/docs/en/07-develop/03-insert-data/01-sql-writing.mdx +++ b/docs/en/07-develop/03-insert-data/01-sql-writing.mdx @@ -101,7 +101,7 @@ For more details about `INSERT` please refer to [INSERT](/taos-sql/insert). ### Insert with Parameter Binding -TDengine also provides API support for parameter binding. Similar to MySQL, only `?` can be used in these APIs to represent the parameters to bind. From version 2.1.1.0 and 2.1.2.0, parameter binding support for inserting data has improved significantly to improve the insert performance by avoiding the cost of parsing SQL statements. +TDengine also provides API support for parameter binding. Similar to MySQL, only `?` can be used in these APIs to represent the parameters to bind. Parameter binding support for inserting data has improved significantly to improve the insert performance by avoiding the cost of parsing SQL statements. Parameter binding is available only with native connection. From cacfb720fb866ee654f40e84f3f2aba7bc97d58e Mon Sep 17 00:00:00 2001 From: "slzhou@taodata.com" Date: Tue, 12 Jul 2022 12:27:48 +0800 Subject: [PATCH 11/30] fix: fix test case of selecting tag from super table --- tests/system-test/2-query/and_or_for_byte.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/system-test/2-query/and_or_for_byte.py b/tests/system-test/2-query/and_or_for_byte.py index aab9cce040..416e62c0f2 100644 --- a/tests/system-test/2-query/and_or_for_byte.py +++ b/tests/system-test/2-query/and_or_for_byte.py @@ -495,9 +495,9 @@ class TDTestCase: tdSql.checkRows(13) self.check_function("&", False ,"t1","c1+2","abs(c2)") tdSql.query("select t1 from stb1 where t1 >0 ") - tdSql.checkRows(3) + tdSql.checkRows(12) tdSql.query("select t1 from stb1 where t1 =3 ") - tdSql.checkRows(1) + tdSql.checkRows(12) # tdSql.query("select sum(t1) from (select c1 ,t1 from stb1)") # tdSql.checkData(0,0,61) # tdSql.query("select distinct(c1) ,t1 from stb1") @@ -507,7 +507,7 @@ class TDTestCase: # tag filter with abs function tdSql.query("select t1 from stb1 where abs(t1)=1") - tdSql.checkRows(1) + tdSql.checkRows(0) tdSql.query("select t1 from stb1 where abs(c1+t1)=1") tdSql.checkRows(1) tdSql.checkData(0,0,0) From ba7d72c752a067037a21bb011f6aff02f12c44ff Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Tue, 12 Jul 2022 10:55:51 +0800 Subject: [PATCH 12/30] enh(query): first/last function adoption for MIA operator TD-17254 --- source/libs/function/src/builtinsimpl.c | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c index 4f88ebc9ab..b7a2ea3edd 100644 --- a/source/libs/function/src/builtinsimpl.c +++ b/source/libs/function/src/builtinsimpl.c @@ -2881,13 +2881,17 @@ static int32_t firstLastFunctionMergeImpl(SqlFunctionCtx* pCtx, bool isFirstQuer SFirstLastRes* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx)); - int32_t start = pInput->startRowIndex; - char* data = colDataGetData(pCol, start); - SFirstLastRes* pInputInfo = (SFirstLastRes*)varDataVal(data); + int32_t start = pInput->startRowIndex; + int32_t numOfElems = 0; - firstLastTransferInfo(pCtx, pInputInfo, pInfo, isFirstQuery); - - int32_t numOfElems = pInputInfo->hasResult ? 1 : 0; + for(int32_t i = start; i < start + pInput->numOfRows; ++i) { + char* data = colDataGetData(pCol, i); + SFirstLastRes* pInputInfo = (SFirstLastRes*)varDataVal(data); + firstLastTransferInfo(pCtx, pInputInfo, pInfo, isFirstQuery); + if (!numOfElems) { + numOfElems = pInputInfo->hasResult ? 1 : 0; + } + } SET_VAL(GET_RES_INFO(pCtx), numOfElems, 1); From 4d73720fb8561fbe5a803fa51cea1878f2ae87bd Mon Sep 17 00:00:00 2001 From: Haojun Liao Date: Tue, 12 Jul 2022 13:45:41 +0800 Subject: [PATCH 13/30] fix(query): set the ts to be the time window start key value when filling timestamp column. --- source/libs/executor/inc/tfill.h | 5 +-- source/libs/executor/src/executorimpl.c | 4 ++- source/libs/executor/src/tfill.c | 42 ++++++++++++++----------- 3 files changed, 30 insertions(+), 21 deletions(-) diff --git a/source/libs/executor/inc/tfill.h b/source/libs/executor/inc/tfill.h index 3b80b262ca..0349632b9a 100644 --- a/source/libs/executor/inc/tfill.h +++ b/source/libs/executor/inc/tfill.h @@ -42,6 +42,7 @@ typedef struct SFillInfo { TSKEY start; // start timestamp TSKEY end; // endKey for fill TSKEY currentKey; // current active timestamp, the value may be changed during the fill procedure. + int32_t tsSlotId; // primary time stamp slot id int32_t order; // order [TSDB_ORDER_ASC|TSDB_ORDER_DESC] int32_t type; // fill type int32_t numOfRows; // number of rows in the input data block @@ -74,8 +75,8 @@ struct SFillColInfo* createFillColInfo(SExprInfo* pExpr, int32_t numOfOutput, co bool taosFillHasMoreResults(struct SFillInfo* pFillInfo); SFillInfo* taosCreateFillInfo(int32_t order, TSKEY skey, int32_t numOfTags, int32_t capacity, int32_t numOfCols, - SInterval* pInterval, int32_t fillType, - struct SFillColInfo* pCol, const char* id); + SInterval* pInterval, int32_t fillType, struct SFillColInfo* pCol, int32_t slotId, + const char* id); void* taosDestroyFillInfo(struct SFillInfo *pFillInfo); int64_t taosFillResultDataBlock(struct SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity); diff --git a/source/libs/executor/src/executorimpl.c b/source/libs/executor/src/executorimpl.c index ac80432052..e9a244b573 100644 --- a/source/libs/executor/src/executorimpl.c +++ b/source/libs/executor/src/executorimpl.c @@ -4013,10 +4013,12 @@ static int32_t initFillInfo(SFillOperatorInfo* pInfo, SExprInfo* pExpr, int32_t w = getFirstQualifiedTimeWindow(win.skey, &w, pInterval, TSDB_ORDER_ASC); int32_t order = TSDB_ORDER_ASC; - pInfo->pFillInfo = taosCreateFillInfo(order, w.skey, 0, capacity, numOfCols, pInterval, fillType, pColInfo, id); + pInfo->pFillInfo = taosCreateFillInfo(order, w.skey, 0, capacity, numOfCols, pInterval, + fillType, pColInfo, pInfo->primaryTsCol, id); pInfo->win = win; pInfo->p = taosMemoryCalloc(numOfCols, POINTER_BYTES); + if (pInfo->pFillInfo == NULL || pInfo->p == NULL) { taosMemoryFree(pInfo->pFillInfo); taosMemoryFree(pInfo->p); diff --git a/source/libs/executor/src/tfill.c b/source/libs/executor/src/tfill.c index b0e2166baf..c008c7c4a9 100644 --- a/source/libs/executor/src/tfill.c +++ b/source/libs/executor/src/tfill.c @@ -14,6 +14,7 @@ */ #include "os.h" +#include "query.h" #include "taosdef.h" #include "tmsg.h" #include "ttypes.h" @@ -48,14 +49,15 @@ static void setTagsValue(SFillInfo* pFillInfo, void** data, int32_t genRows) { } } -static void setNullRow(SSDataBlock* pBlock, int32_t numOfCol, int32_t rowIndex) { +static void setNullRow(SSDataBlock* pBlock, int64_t ts, int32_t rowIndex) { // the first are always the timestamp column, so start from the second column. for (int32_t i = 0; i < taosArrayGetSize(pBlock->pDataBlock); ++i) { SColumnInfoData* p = taosArrayGet(pBlock->pDataBlock, i); - if (p->info.type == TSDB_DATA_TYPE_TIMESTAMP && i == 0) { - continue; + if (p->info.type == TSDB_DATA_TYPE_TIMESTAMP) { + colDataAppend(p, rowIndex, (const char*)&ts, false); + } else { + colDataAppendNULL(p, rowIndex); } - colDataAppendNULL(p, rowIndex); } } @@ -64,16 +66,17 @@ static void setNullRow(SSDataBlock* pBlock, int32_t numOfCol, int32_t rowIndex) static void doSetVal(SColumnInfoData* pDstColInfoData, int32_t rowIndex, const SGroupKeys* pKey); -static void doFillOneRowResult(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock* pSrcBlock, int64_t ts, - bool outOfBound) { +static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock* pSrcBlock, int64_t ts, + bool outOfBound) { SPoint point1, point2, point; int32_t step = GET_FORWARD_DIRECTION_FACTOR(pFillInfo->order); // set the primary timestamp column value int32_t index = pFillInfo->numOfCurrent; - SColumnInfoData* pCol0 = taosArrayGet(pBlock->pDataBlock, 0); + SColumnInfoData* pCol0 = taosArrayGet(pBlock->pDataBlock, pFillInfo->tsSlotId); char* val = colDataGetData(pCol0, index); + // set the primary timestamp value *(TSKEY*)val = pFillInfo->currentKey; // set the other values @@ -92,7 +95,7 @@ static void doFillOneRowResult(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSData } } else if (pFillInfo->type == TSDB_FILL_NEXT) { SArray* p = FILL_IS_ASC_FILL(pFillInfo) ? pFillInfo->next : pFillInfo->prev; - + // todo refactor: start from 0 not 1 for (int32_t i = 1; i < pFillInfo->numOfCols; ++i) { SFillColInfo* pCol = &pFillInfo->pFillCol[i]; if (TSDB_COL_IS_TAG(pCol->flag)) { @@ -106,7 +109,7 @@ static void doFillOneRowResult(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSData } else if (pFillInfo->type == TSDB_FILL_LINEAR) { // TODO : linear interpolation supports NULL value if (outOfBound) { - setNullRow(pBlock, pFillInfo->numOfCols, index); + setNullRow(pBlock, pFillInfo->currentKey, index); } else { for (int32_t i = 1; i < pFillInfo->numOfCols; ++i) { SFillColInfo* pCol = &pFillInfo->pFillCol[i]; @@ -143,7 +146,7 @@ static void doFillOneRowResult(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSData } } } else if (pFillInfo->type == TSDB_FILL_NULL) { // fill with NULL - setNullRow(pBlock, pFillInfo->numOfCols, index); + setNullRow(pBlock, pFillInfo->currentKey, index); } else { // fill with user specified value for each column for (int32_t i = 1; i < pFillInfo->numOfCols; ++i) { SFillColInfo* pCol = &pFillInfo->pFillCol[i]; @@ -166,6 +169,8 @@ static void doFillOneRowResult(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSData int64_t v = 0; GET_TYPED_DATA(v, int64_t, pVar->nType, &pVar->i); colDataAppend(pDst, index, (char*)&v, false); + } else if (pDst->info.type == TSDB_DATA_TYPE_TIMESTAMP) { + colDataAppend(pDst, index, (const char*)&pFillInfo->currentKey, false); } } } @@ -247,7 +252,7 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t // fill the gap between two input rows while (((pFillInfo->currentKey < ts && ascFill) || (pFillInfo->currentKey > ts && !ascFill)) && pFillInfo->numOfCurrent < outputRows) { - doFillOneRowResult(pFillInfo, pBlock, pFillInfo->pSrcBlock, ts, false); + doFillOneRow(pFillInfo, pBlock, pFillInfo->pSrcBlock, ts, false); } // output buffer is full, abort @@ -343,7 +348,7 @@ static int64_t appendFilledResult(SFillInfo* pFillInfo, SSDataBlock* pBlock, int */ pFillInfo->numOfCurrent = 0; while (pFillInfo->numOfCurrent < resultCapacity) { - doFillOneRowResult(pFillInfo, pBlock, pFillInfo->pSrcBlock, pFillInfo->start, true); + doFillOneRow(pFillInfo, pBlock, pFillInfo->pSrcBlock, pFillInfo->start, true); } pFillInfo->numOfTotal += pFillInfo->numOfCurrent; @@ -408,7 +413,7 @@ static int32_t taosNumOfRemainRows(SFillInfo* pFillInfo) { } struct SFillInfo* taosCreateFillInfo(int32_t order, TSKEY skey, int32_t numOfTags, int32_t capacity, int32_t numOfCols, - SInterval* pInterval, int32_t fillType, struct SFillColInfo* pCol, + SInterval* pInterval, int32_t fillType, struct SFillColInfo* pCol, int32_t primaryTsSlotId, const char* id) { if (fillType == TSDB_FILL_NONE) { return NULL; @@ -420,6 +425,8 @@ struct SFillInfo* taosCreateFillInfo(int32_t order, TSKEY skey, int32_t numOfTag return NULL; } + pFillInfo->tsSlotId = primaryTsSlotId; + taosResetFillInfo(pFillInfo, skey); pFillInfo->order = order; @@ -589,11 +596,10 @@ int64_t taosFillResultDataBlock(SFillInfo* pFillInfo, SSDataBlock* p, int32_t ca assert(numOfRes == pFillInfo->numOfCurrent); } - // qDebug("fill:%p, generated fill result, src block:%d, index:%d, brange:%"PRId64"-%"PRId64", currentKey:%"PRId64", - // current:%d, total:%d, %p", - // pFillInfo, pFillInfo->numOfRows, pFillInfo->index, pFillInfo->start, pFillInfo->end, pFillInfo->currentKey, - // pFillInfo->numOfCurrent, - // pFillInfo->numOfTotal, pFillInfo->handle); + qDebug("fill:%p, generated fill result, src block:%d, index:%d, brange:%" PRId64 "-%" PRId64 ", currentKey:%" PRId64 + ", current : % d, total : % d, %s", pFillInfo, + pFillInfo->numOfRows, pFillInfo->index, pFillInfo->start, pFillInfo->end, pFillInfo->currentKey, + pFillInfo->numOfCurrent, pFillInfo->numOfTotal, pFillInfo->id); return numOfRes; } From 66f2835af12413a95b29194b4f6ec4674d4d7a65 Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Tue, 12 Jul 2022 10:55:51 +0800 Subject: [PATCH 14/30] enh(query): hyperloglog function adoption for MIA operator TD-17254 --- source/libs/function/src/builtinsimpl.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c index b7a2ea3edd..9aad34d609 100644 --- a/source/libs/function/src/builtinsimpl.c +++ b/source/libs/function/src/builtinsimpl.c @@ -4397,11 +4397,13 @@ int32_t hllFunctionMerge(SqlFunctionCtx* pCtx) { SHLLInfo* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx)); - int32_t start = pInput->startRowIndex; - char* data = colDataGetData(pCol, start); - SHLLInfo* pInputInfo = (SHLLInfo*)varDataVal(data); + int32_t start = pInput->startRowIndex; - hllTransferInfo(pInputInfo, pInfo); + for(int32_t i = start; i < start + pInput->numOfRows; ++i) { + char* data = colDataGetData(pCol, i); + SHLLInfo* pInputInfo = (SHLLInfo*)varDataVal(data); + hllTransferInfo(pInputInfo, pInfo); + } SET_VAL(GET_RES_INFO(pCtx), 1, 1); return TSDB_CODE_SUCCESS; From 8957a91ab3af4c27cbfd51759fe28277bf5f218c Mon Sep 17 00:00:00 2001 From: dapan1121 Date: Tue, 12 Jul 2022 13:56:15 +0800 Subject: [PATCH 15/30] fix: add more columns in show stable res --- source/client/src/clientEnv.c | 5 ++++- source/client/src/clientHb.c | 7 ++----- source/common/src/systable.c | 7 +++++-- source/dnode/mnode/impl/src/mndStb.c | 30 +++++++++++++++++++++++++++- source/libs/catalog/src/catalog.c | 1 + 5 files changed, 41 insertions(+), 9 deletions(-) diff --git a/source/client/src/clientEnv.c b/source/client/src/clientEnv.c index ba92ed238b..6805e4d501 100644 --- a/source/client/src/clientEnv.c +++ b/source/client/src/clientEnv.c @@ -189,12 +189,15 @@ void destroyTscObj(void *pObj) { SClientHbKey connKey = {.tscRid = pTscObj->id, .connType = pTscObj->connType}; hbDeregisterConn(pTscObj->pAppInfo->pAppHbMgr, connKey); - int64_t connNum = atomic_sub_fetch_64(&pTscObj->pAppInfo->numOfConns, 1); + destroyAllRequests(pTscObj->pRequests); + taosHashCleanup(pTscObj->pRequests); + schedulerStopQueryHb(pTscObj->pAppInfo->pTransporter); tscDebug("connObj 0x%" PRIx64 " p:%p destroyed, remain inst totalConn:%" PRId64, pTscObj->id, pTscObj, pTscObj->pAppInfo->numOfConns); + int64_t connNum = atomic_sub_fetch_64(&pTscObj->pAppInfo->numOfConns, 1); if (0 == connNum) { destroyAppInst(pTscObj->pAppInfo); } diff --git a/source/client/src/clientHb.c b/source/client/src/clientHb.c index e2d75d39e3..2a9d113108 100644 --- a/source/client/src/clientHb.c +++ b/source/client/src/clientHb.c @@ -671,8 +671,7 @@ static void *hbThreadFunc(void *param) { } #endif while (1) { - int8_t threadStop = atomic_val_compare_exchange_8(&clientHbMgr.threadStop, 1, 2); - if (1 == threadStop) { + if (1 == clientHbMgr.threadStop) { break; } @@ -760,9 +759,7 @@ static void hbStopThread() { return; } - while (2 != atomic_load_8(&clientHbMgr.threadStop)) { - taosUsleep(10); - } + taosThreadJoin(clientHbMgr.thread, NULL); tscDebug("hb thread stopped"); } diff --git a/source/common/src/systable.c b/source/common/src/systable.c index ba8a8e1220..08997bcaf8 100644 --- a/source/common/src/systable.c +++ b/source/common/src/systable.c @@ -123,6 +123,9 @@ static const SSysDbTableSchema userStbsSchema[] = { {.name = "tags", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, {.name = "last_update", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP}, {.name = "table_comment", .bytes = TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR}, + {.name = "watermark", .bytes = 64 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR}, + {.name = "max_delay", .bytes = 64 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR}, + {.name = "rollup", .bytes = 128 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR}, }; static const SSysDbTableSchema streamSchema[] = { @@ -146,8 +149,8 @@ static const SSysDbTableSchema userTblsSchema[] = { {.name = "uid", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT}, {.name = "vgroup_id", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, {.name = "ttl", .bytes = 4, .type = TSDB_DATA_TYPE_INT}, - {.name = "table_comment", .bytes = TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR}, - {.name = "type", .bytes = 20 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR}, + {.name = "table_comment", .bytes = TSDB_TB_COMMENT_LEN - 1 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR}, + {.name = "type", .bytes = 21 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR}, }; static const SSysDbTableSchema userTblDistSchema[] = { diff --git a/source/dnode/mnode/impl/src/mndStb.c b/source/dnode/mnode/impl/src/mndStb.c index 1c234cf280..1e57625028 100644 --- a/source/dnode/mnode/impl/src/mndStb.c +++ b/source/dnode/mnode/impl/src/mndStb.c @@ -2109,7 +2109,7 @@ static int32_t mndRetrieveStb(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBloc pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); colDataAppend(pColInfo, numOfRows, (const char *)&pStb->updateTime, false); // number of tables - pColInfo = taosArrayGet(pBlock->pDataBlock, cols); + pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); if (pStb->commentLen > 0) { char comment[TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(comment, pStb->comment); @@ -2122,6 +2122,34 @@ static int32_t mndRetrieveStb(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBloc colDataAppendNULL(pColInfo, numOfRows); } + char watermark[64 + VARSTR_HEADER_SIZE] = {0}; + sprintf(varDataVal(watermark), "%" PRId64 "a,%" PRId64 "a", pStb->watermark[0], pStb->watermark[1]); + varDataSetLen(watermark, strlen(varDataVal(watermark))); + + pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); + colDataAppend(pColInfo, numOfRows, (const char *)watermark, false); + + char maxDelay[64 + VARSTR_HEADER_SIZE] = {0}; + sprintf(varDataVal(maxDelay), "%" PRId64 "a,%" PRId64 "a", pStb->maxdelay[0], pStb->maxdelay[1]); + varDataSetLen(maxDelay, strlen(varDataVal(maxDelay))); + + pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); + colDataAppend(pColInfo, numOfRows, (const char *)maxDelay, false); + + char rollup[128 + VARSTR_HEADER_SIZE] = {0}; + int32_t rollupNum = (int32_t)taosArrayGetSize(pStb->pFuncs); + for (int32_t i = 0; i < rollupNum; ++i) { + char *funcName = taosArrayGet(pStb->pFuncs, i); + if (i) { + strcat(varDataVal(rollup), ", "); + } + strcat(varDataVal(rollup), funcName); + } + varDataSetLen(rollup, strlen(varDataVal(rollup))); + + pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); + colDataAppend(pColInfo, numOfRows, (const char *)rollup, false); + numOfRows++; sdbRelease(pSdb, pStb); } diff --git a/source/libs/catalog/src/catalog.c b/source/libs/catalog/src/catalog.c index 3a7ad4a2d6..ca50702894 100644 --- a/source/libs/catalog/src/catalog.c +++ b/source/libs/catalog/src/catalog.c @@ -1293,6 +1293,7 @@ void catalogDestroy(void) { if (!taosCheckCurrentInDll()) { ctgClearCacheEnqueue(NULL, true, true, true); + taosThreadJoin(gCtgMgmt.updateThread, NULL); } taosHashCleanup(gCtgMgmt.pCluster); From 6c5e8bae55dc7da7f6e2dd7636c4b1eb267132ce Mon Sep 17 00:00:00 2001 From: Cary Xu Date: Tue, 12 Jul 2022 14:14:42 +0800 Subject: [PATCH 16/30] fix: use correct keep2 when set least ts for query --- source/dnode/vnode/src/sma/smaRollup.c | 13 +++++++------ source/dnode/vnode/src/tsdb/tsdbRead.c | 8 ++++---- 2 files changed, 11 insertions(+), 10 deletions(-) diff --git a/source/dnode/vnode/src/sma/smaRollup.c b/source/dnode/vnode/src/sma/smaRollup.c index 14497c6f9b..06ffb639de 100644 --- a/source/dnode/vnode/src/sma/smaRollup.c +++ b/source/dnode/vnode/src/sma/smaRollup.c @@ -65,9 +65,12 @@ struct SRSmaInfo { static SRSmaInfo *tdGetRSmaInfoByItem(SRSmaInfoItem *pItem) { // adapt accordingly if definition of SRSmaInfo update - int32_t rsmaInfoHeadLen = sizeof(int64_t) + sizeof(STSchema *); - ASSERT(pItem->level == 0 || pItem->level == 1); - return (SRSmaInfo *)POINTER_SHIFT(pItem, -sizeof(SRSmaInfoItem) * pItem->level - rsmaInfoHeadLen); + SRSmaInfo *pResult = NULL; + int32_t rsmaInfoHeadLen = sizeof(int64_t) + sizeof(STSchema *); + ASSERT(pItem->level == TSDB_RETENTION_L1 || pItem->level == TSDB_RETENTION_L2); + pResult = (SRSmaInfo *)POINTER_SHIFT(pItem, -(sizeof(SRSmaInfoItem) * (pItem->level - 1) + rsmaInfoHeadLen)); + ASSERT(pResult->pTSchema->numOfCols > 1); + return pResult; } struct SRSmaQTaskInfoItem { @@ -276,7 +279,7 @@ static int32_t tdSetRSmaInfoItemParams(SSma *pSma, SRSmaParam *param, SRSmaStat if (pItem->maxDelay > TSDB_MAX_ROLLUP_MAX_DELAY) { pItem->maxDelay = TSDB_MAX_ROLLUP_MAX_DELAY; } - pItem->level = idx; + pItem->level = idx == 0 ? TSDB_RETENTION_L1 : TSDB_RETENTION_L2; smaInfo("vgId:%d table:%" PRIi64 " level:%" PRIi8 " maxdelay:%" PRIi64 " watermark:%" PRIi64 ", finally maxdelay:%" PRIi32, SMA_VID(pSma), pRSmaInfo->suid, idx + 1, param->maxdelay[idx], param->watermark[idx], pItem->maxDelay); @@ -1236,8 +1239,6 @@ static void tdRSmaFetchTrigger(void *param, void *tmrId) { SRSmaInfo *pRSmaInfo = tdGetRSmaInfoByItem(pItem); - ASSERT(pRSmaInfo->items[pItem->level].level == pItem->level); - int8_t fetchTriggerStat = atomic_val_compare_exchange_8(&pItem->triggerStat, TASK_TRIGGER_STAT_ACTIVE, TASK_TRIGGER_STAT_INACTIVE); switch (fetchTriggerStat) { diff --git a/source/dnode/vnode/src/tsdb/tsdbRead.c b/source/dnode/vnode/src/tsdb/tsdbRead.c index 5f796bbab9..6e68d30a08 100644 --- a/source/dnode/vnode/src/tsdb/tsdbRead.c +++ b/source/dnode/vnode/src/tsdb/tsdbRead.c @@ -400,7 +400,7 @@ static int32_t tsdbReaderCreate(SVnode* pVnode, SQueryTableDataCond* pCond, STsd pReader->idStr = (idstr != NULL) ? strdup(idstr) : NULL; pReader->verRange = getQueryVerRange(pVnode, pCond, level); pReader->type = pCond->type; - pReader->window = updateQueryTimeWindow(pVnode->pTsdb, &pCond->twindows); + pReader->window = updateQueryTimeWindow(pReader->pTsdb, &pCond->twindows); ASSERT(pCond->numOfCols > 0); @@ -2203,15 +2203,15 @@ static STsdb* getTsdbByRetentions(SVnode* pVnode, TSKEY winSKey, SRetention* ret if (level == TSDB_RETENTION_L0) { *pLevel = TSDB_RETENTION_L0; - tsdbDebug("vgId:%d, read handle %p rsma level %d is selected to query %s", vgId, TSDB_RETENTION_L0, str); + tsdbDebug("vgId:%d, rsma level %d is selected to query %s", vgId, TSDB_RETENTION_L0, str); return VND_RSMA0(pVnode); } else if (level == TSDB_RETENTION_L1) { *pLevel = TSDB_RETENTION_L1; - tsdbDebug("vgId:%d, read handle %p rsma level %d is selected to query %s", vgId, TSDB_RETENTION_L1, str); + tsdbDebug("vgId:%d, rsma level %d is selected to query %s", vgId, TSDB_RETENTION_L1, str); return VND_RSMA1(pVnode); } else { *pLevel = TSDB_RETENTION_L2; - tsdbDebug("vgId:%d, read handle %p rsma level %d is selected to query %s", vgId, TSDB_RETENTION_L2, str); + tsdbDebug("vgId:%d, rsma level %d is selected to query %s", vgId, TSDB_RETENTION_L2, str); return VND_RSMA2(pVnode); } } From fdf878c3e8a39af59a1d1fc308c81a19e69de333 Mon Sep 17 00:00:00 2001 From: Ganlin Zhao Date: Tue, 12 Jul 2022 10:55:51 +0800 Subject: [PATCH 17/30] enh(query): agg function adoption for MIA operator TD-17254 --- source/libs/function/src/builtinsimpl.c | 195 ++++++++++++------------ 1 file changed, 98 insertions(+), 97 deletions(-) diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c index 9aad34d609..cd550b39cf 100644 --- a/source/libs/function/src/builtinsimpl.c +++ b/source/libs/function/src/builtinsimpl.c @@ -338,6 +338,104 @@ typedef struct SGroupKeyInfo { } \ } while (0) +#define LIST_ADD_N(_res, _col, _start, _rows, _t, numOfElem) \ + do { \ + _t* d = (_t*)(_col->pData); \ + for (int32_t i = (_start); i < (_rows) + (_start); ++i) { \ + if (((_col)->hasNull) && colDataIsNull_f((_col)->nullbitmap, i)) { \ + continue; \ + }; \ + (_res) += (d)[i]; \ + (numOfElem)++; \ + } \ + } while (0) + +#define LIST_SUB_N(_res, _col, _start, _rows, _t, numOfElem) \ + do { \ + _t* d = (_t*)(_col->pData); \ + for (int32_t i = (_start); i < (_rows) + (_start); ++i) { \ + if (((_col)->hasNull) && colDataIsNull_f((_col)->nullbitmap, i)) { \ + continue; \ + }; \ + (_res) -= (d)[i]; \ + (numOfElem)++; \ + } \ + } while (0) + +#define LIST_AVG_N(sumT, T) \ + do { \ + T* plist = (T*)pCol->pData; \ + for (int32_t i = start; i < numOfRows + pInput->startRowIndex; ++i) { \ + if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) { \ + continue; \ + } \ + \ + numOfElem += 1; \ + pAvgRes->count -= 1; \ + sumT -= plist[i]; \ + } \ + } while (0) + +#define LIST_STDDEV_SUB_N(sumT, T) \ + do { \ + T* plist = (T*)pCol->pData; \ + for (int32_t i = start; i < numOfRows + start; ++i) { \ + if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) { \ + continue; \ + } \ + numOfElem += 1; \ + pStddevRes->count -= 1; \ + sumT -= plist[i]; \ + pStddevRes->quadraticISum -= plist[i] * plist[i]; \ + } \ + } while (0) + +#define LEASTSQR_CAL(p, x, y, index, step) \ + do { \ + (p)[0][0] += (double)(x) * (x); \ + (p)[0][1] += (double)(x); \ + (p)[0][2] += (double)(x) * (y)[index]; \ + (p)[1][2] += (y)[index]; \ + (x) += step; \ + } while (0) + + +#define STATE_COMP(_op, _lval, _param) STATE_COMP_IMPL(_op, _lval, GET_STATE_VAL(_param)) + +#define GET_STATE_VAL(param) ((param.nType == TSDB_DATA_TYPE_BIGINT) ? (param.i) : (param.d)) + +#define STATE_COMP_IMPL(_op, _lval, _rval) \ + do { \ + switch (_op) { \ + case STATE_OPER_LT: \ + return ((_lval) < (_rval)); \ + break; \ + case STATE_OPER_GT: \ + return ((_lval) > (_rval)); \ + break; \ + case STATE_OPER_LE: \ + return ((_lval) <= (_rval)); \ + break; \ + case STATE_OPER_GE: \ + return ((_lval) >= (_rval)); \ + break; \ + case STATE_OPER_NE: \ + return ((_lval) != (_rval)); \ + break; \ + case STATE_OPER_EQ: \ + return ((_lval) == (_rval)); \ + break; \ + default: \ + break; \ + } \ + } while (0) + +#define INIT_INTP_POINT(_p, _k, _v) \ + do { \ + (_p).key = (_k); \ + (_p).val = (_v); \ + } while (0) + bool dummyGetEnv(SFunctionNode* UNUSED_PARAM(pFunc), SFuncExecEnv* UNUSED_PARAM(pEnv)) { return true; } bool dummyInit(SqlFunctionCtx* UNUSED_PARAM(pCtx), SResultRowEntryInfo* UNUSED_PARAM(pResultInfo)) { return true; } @@ -499,30 +597,6 @@ int32_t combineFunction(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx) { return TSDB_CODE_SUCCESS; } -#define LIST_ADD_N(_res, _col, _start, _rows, _t, numOfElem) \ - do { \ - _t* d = (_t*)(_col->pData); \ - for (int32_t i = (_start); i < (_rows) + (_start); ++i) { \ - if (((_col)->hasNull) && colDataIsNull_f((_col)->nullbitmap, i)) { \ - continue; \ - }; \ - (_res) += (d)[i]; \ - (numOfElem)++; \ - } \ - } while (0) - -#define LIST_SUB_N(_res, _col, _start, _rows, _t, numOfElem) \ - do { \ - _t* d = (_t*)(_col->pData); \ - for (int32_t i = (_start); i < (_rows) + (_start); ++i) { \ - if (((_col)->hasNull) && colDataIsNull_f((_col)->nullbitmap, i)) { \ - continue; \ - }; \ - (_res) -= (d)[i]; \ - (numOfElem)++; \ - } \ - } while (0) - int32_t sumFunction(SqlFunctionCtx* pCtx) { int32_t numOfElem = 0; @@ -920,20 +994,6 @@ int32_t avgFunctionMerge(SqlFunctionCtx* pCtx) { return TSDB_CODE_SUCCESS; } -#define LIST_AVG_N(sumT, T) \ - do { \ - T* plist = (T*)pCol->pData; \ - for (int32_t i = start; i < numOfRows + pInput->startRowIndex; ++i) { \ - if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) { \ - continue; \ - } \ - \ - numOfElem += 1; \ - pAvgRes->count -= 1; \ - sumT -= plist[i]; \ - } \ - } while (0) - int32_t avgInvertFunction(SqlFunctionCtx* pCtx) { int32_t numOfElem = 0; @@ -1884,20 +1944,6 @@ int32_t stddevFunctionMerge(SqlFunctionCtx* pCtx) { return TSDB_CODE_SUCCESS; } -#define LIST_STDDEV_SUB_N(sumT, T) \ - do { \ - T* plist = (T*)pCol->pData; \ - for (int32_t i = start; i < numOfRows + start; ++i) { \ - if (pCol->hasNull && colDataIsNull_f(pCol->nullbitmap, i)) { \ - continue; \ - } \ - numOfElem += 1; \ - pStddevRes->count -= 1; \ - sumT -= plist[i]; \ - pStddevRes->quadraticISum -= plist[i] * plist[i]; \ - } \ - } while (0) - int32_t stddevInvertFunction(SqlFunctionCtx* pCtx) { int32_t numOfElem = 0; @@ -2046,15 +2092,6 @@ bool leastSQRFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInf return true; } -#define LEASTSQR_CAL(p, x, y, index, step) \ - do { \ - (p)[0][0] += (double)(x) * (x); \ - (p)[0][1] += (double)(x); \ - (p)[0][2] += (double)(x) * (y)[index]; \ - (p)[1][2] += (y)[index]; \ - (x) += step; \ - } while (0) - int32_t leastSQRFunction(SqlFunctionCtx* pCtx) { int32_t numOfElem = 0; @@ -4477,36 +4514,6 @@ static int8_t getStateOpType(char* opStr) { return opType; } -#define GET_STATE_VAL(param) ((param.nType == TSDB_DATA_TYPE_BIGINT) ? (param.i) : (param.d)) - -#define STATE_COMP(_op, _lval, _param) STATE_COMP_IMPL(_op, _lval, GET_STATE_VAL(_param)) - -#define STATE_COMP_IMPL(_op, _lval, _rval) \ - do { \ - switch (_op) { \ - case STATE_OPER_LT: \ - return ((_lval) < (_rval)); \ - break; \ - case STATE_OPER_GT: \ - return ((_lval) > (_rval)); \ - break; \ - case STATE_OPER_LE: \ - return ((_lval) <= (_rval)); \ - break; \ - case STATE_OPER_GE: \ - return ((_lval) >= (_rval)); \ - break; \ - case STATE_OPER_NE: \ - return ((_lval) != (_rval)); \ - break; \ - case STATE_OPER_EQ: \ - return ((_lval) == (_rval)); \ - break; \ - default: \ - break; \ - } \ - } while (0) - static bool checkStateOp(int8_t op, SColumnInfoData* pCol, int32_t index, SVariant param) { char* data = colDataGetData(pCol, index); switch (pCol->info.type) { @@ -5214,12 +5221,6 @@ static double twa_get_area(SPoint1 s, SPoint1 e) { return val; } -#define INIT_INTP_POINT(_p, _k, _v) \ - do { \ - (_p).key = (_k); \ - (_p).val = (_v); \ - } while (0) - int32_t twaFunction(SqlFunctionCtx* pCtx) { SInputColumnInfoData* pInput = &pCtx->input; SColumnInfoData* pInputCol = pInput->pData[0]; From 129b289bdf8f60a2df03dee4fef1165d0daab086 Mon Sep 17 00:00:00 2001 From: Minghao Li Date: Tue, 12 Jul 2022 14:34:18 +0800 Subject: [PATCH 18/30] refactor(sync): do leader transfer --- source/libs/sync/src/syncMain.c | 39 ++++++++------------------------- 1 file changed, 9 insertions(+), 30 deletions(-) diff --git a/source/libs/sync/src/syncMain.c b/source/libs/sync/src/syncMain.c index e1c3d4bb33..6093d622b7 100644 --- a/source/libs/sync/src/syncMain.c +++ b/source/libs/sync/src/syncMain.c @@ -273,16 +273,8 @@ int32_t syncLeaderTransfer(int64_t rid) { } ASSERT(rid == pSyncNode->rid); - if (pSyncNode->peersNum == 0) { - taosReleaseRef(tsNodeRefId, pSyncNode->rid); - terrno = TSDB_CODE_SYN_INTERNAL_ERROR; - return -1; - } - - SNodeInfo newLeader = (pSyncNode->peersNodeInfo)[0]; + int32_t ret = syncNodeLeaderTransfer(pSyncNode); taosReleaseRef(tsNodeRefId, pSyncNode->rid); - - int32_t ret = syncLeaderTransferTo(rid, newLeader); return ret; } @@ -293,25 +285,8 @@ int32_t syncLeaderTransferTo(int64_t rid, SNodeInfo newLeader) { return -1; } ASSERT(rid == pSyncNode->rid); - int32_t ret = 0; - if (pSyncNode->replicaNum == 1) { - sError("only one replica, cannot drop leader"); - taosReleaseRef(tsNodeRefId, pSyncNode->rid); - terrno = TSDB_CODE_SYN_ONE_REPLICA; - return -1; - } - - SyncLeaderTransfer* pMsg = syncLeaderTransferBuild(pSyncNode->vgId); - pMsg->newLeaderId.addr = syncUtilAddr2U64(newLeader.nodeFqdn, newLeader.nodePort); - pMsg->newLeaderId.vgId = pSyncNode->vgId; - pMsg->newNodeInfo = newLeader; - ASSERT(pMsg != NULL); - SRpcMsg rpcMsg = {0}; - syncLeaderTransfer2RpcMsg(pMsg, &rpcMsg); - syncLeaderTransferDestroy(pMsg); - - ret = syncNodePropose(pSyncNode, &rpcMsg, false); + int32_t ret = syncNodeLeaderTransferTo(pSyncNode, newLeader); taosReleaseRef(tsNodeRefId, pSyncNode->rid); return ret; } @@ -337,6 +312,12 @@ int32_t syncNodeLeaderTransferTo(SSyncNode* pSyncNode, SNodeInfo newLeader) { return -1; } + do { + char logBuf[128]; + snprintf(logBuf, sizeof(logBuf), "begin leader transfer to %s:%u", newLeader.nodeFqdn, newLeader.nodePort); + syncNodeEventLog(pSyncNode, logBuf); + } while (0); + SyncLeaderTransfer* pMsg = syncLeaderTransferBuild(pSyncNode->vgId); pMsg->newLeaderId.addr = syncUtilAddr2U64(newLeader.nodeFqdn, newLeader.nodePort); pMsg->newLeaderId.vgId = pSyncNode->vgId; @@ -1147,8 +1128,6 @@ void syncNodeStartStandBy(SSyncNode* pSyncNode) { void syncNodeClose(SSyncNode* pSyncNode) { syncNodeEventLog(pSyncNode, "sync close"); - // leader transfer - int32_t ret; ASSERT(pSyncNode != NULL); @@ -2643,7 +2622,7 @@ const char* syncStr(ESyncState state) { static int32_t syncDoLeaderTransfer(SSyncNode* ths, SRpcMsg* pRpcMsg, SSyncRaftEntry* pEntry) { SyncLeaderTransfer* pSyncLeaderTransfer = syncLeaderTransferFromRpcMsg2(pRpcMsg); - syncNodeEventLog(ths, "begin leader transfer"); + syncNodeEventLog(ths, "do leader transfer"); bool sameId = syncUtilSameId(&(pSyncLeaderTransfer->newLeaderId), &(ths->myRaftId)); bool sameNodeInfo = strcmp(pSyncLeaderTransfer->newNodeInfo.nodeFqdn, ths->myNodeInfo.nodeFqdn) == 0 && From 37ebcdeaaa68f56ca78808a64ced84bafb55a718 Mon Sep 17 00:00:00 2001 From: Minghao Li Date: Tue, 12 Jul 2022 14:36:38 +0800 Subject: [PATCH 19/30] refactor(sync): add elect case --- tests/script/tsim/sync/electTest.sim | 193 +++++++++++++++++++++++++++ 1 file changed, 193 insertions(+) create mode 100644 tests/script/tsim/sync/electTest.sim diff --git a/tests/script/tsim/sync/electTest.sim b/tests/script/tsim/sync/electTest.sim new file mode 100644 index 0000000000..5433434014 --- /dev/null +++ b/tests/script/tsim/sync/electTest.sim @@ -0,0 +1,193 @@ +system sh/stop_dnodes.sh +system sh/deploy.sh -n dnode1 -i 1 +system sh/deploy.sh -n dnode2 -i 2 +system sh/deploy.sh -n dnode3 -i 3 +system sh/deploy.sh -n dnode4 -i 4 + +system sh/cfg.sh -n dnode1 -c supportVnodes -v 0 + +system sh/exec.sh -n dnode1 -s start +system sh/exec.sh -n dnode2 -s start +system sh/exec.sh -n dnode3 -s start +system sh/exec.sh -n dnode4 -s start + +$loop_cnt = 0 +check_dnode_ready: + $loop_cnt = $loop_cnt + 1 + sleep 200 + if $loop_cnt == 10 then + print ====> dnode not ready! + return -1 + endi +sql show dnodes +print ===> $rows $data[0][0] $data[0][1] $data[0][2] $data[0][3] $data[0][4] $data[0][5] $data[0][6] +print ===> $rows $data[1][0] $data[1][1] $data[1][2] $data[1][3] $data[1][4] $data[1][5] $data[1][6] +print ===> $rows $data[2][0] $data[2][1] $data[2][2] $data[2][3] $data[2][4] $data[2][5] $data[2][6] +print ===> $rows $data[3][0] $data[3][1] $data[3][2] $data[3][3] $data[3][4] $data[3][5] $data[3][6] +if $data[0][0] != 1 then + return -1 +endi +if $data[0][4] != ready then + goto check_dnode_ready +endi + +sql connect +sql create dnode $hostname port 7200 +sql create dnode $hostname port 7300 +sql create dnode $hostname port 7400 + +$loop_cnt = 0 +check_dnode_ready_1: +$loop_cnt = $loop_cnt + 1 +sleep 200 +if $loop_cnt == 10 then + print ====> dnodes not ready! + return -1 +endi +sql show dnodes +print ===> $rows $data[0][0] $data[0][1] $data[0][2] $data[0][3] $data[0][4] $data[0][5] $data[0][6] +print ===> $rows $data[1][0] $data[1][1] $data[1][2] $data[1][3] $data[1][4] $data[1][5] $data[1][6] +print ===> $rows $data[2][0] $data[2][1] $data[2][2] $data[2][3] $data[2][4] $data[2][5] $data[2][6] +print ===> $rows $data[3][0] $data[3][1] $data[3][2] $data[3][3] $data[3][4] $data[3][5] $data[3][6] +if $data[0][4] != ready then + goto check_dnode_ready_1 +endi +if $data[1][4] != ready then + goto check_dnode_ready_1 +endi +if $data[2][4] != ready then + goto check_dnode_ready_1 +endi +if $data[3][4] != ready then + goto check_dnode_ready_1 +endi + +$replica = 3 +$vgroups = 1 + +print ============= create database +sql create database db replica $replica vgroups $vgroups + +$loop_cnt = 0 +check_db_ready: +$loop_cnt = $loop_cnt + 1 +sleep 200 +if $loop_cnt == 100 then + print ====> db not ready! + return -1 +endi +sql show databases +print ===> rows: $rows +print $data[2][0] $data[2][1] $data[2][2] $data[2][3] $data[2][4] $data[2][5] $data[2][6] $data[2][7] $data[2][8] $data[2][9] $data[2][6] $data[2][11] $data[2][12] $data[2][13] $data[2][14] $data[2][15] $data[2][16] $data[2][17] $data[2][18] $data[2][19] +if $rows != 3 then + return -1 +endi +if $data[2][19] != ready then + goto check_db_ready +endi + +sql use db + +$loop_cnt = 0 +check_vg_ready: +$loop_cnt = $loop_cnt + 1 +sleep 200 +if $loop_cnt == 300 then + print ====> vgroups not ready! + return -1 +endi + +sql show vgroups +print ===> rows: $rows +print $data[0][0] $data[0][1] $data[0][2] $data[0][3] $data[0][4] $data[0][5] $data[0][6] $data[0][7] $data[0][8] $data[0][9] $data[0][10] $data[0][11] + +if $rows != $vgroups then + return -1 +endi + +if $data[0][4] == leader then + if $data[0][6] == follower then + if $data[0][8] == follower then + print ---- vgroup $data[0][0] leader locate on dnode $data[0][3] + endi + endi +elif $data[0][6] == leader then + if $data[0][4] == follower then + if $data[0][8] == follower then + print ---- vgroup $data[0][0] leader locate on dnode $data[0][5] + endi + endi +elif $data[0][8] == leader then + if $data[0][4] == follower then + if $data[0][6] == follower then + print ---- vgroup $data[0][0] leader locate on dnode $data[0][7] + endi + endi +else + goto check_vg_ready +endi + + +vg_ready: +print ====> create stable/child table +sql create table stb (ts timestamp, c1 int, c2 float, c3 double) tags (t1 int) + +sql show stables +if $rows != 1 then + return -1 +endi + +sql create table ct1 using stb tags(1000) + + +print ===> write 100 records +$N = 100 +$count = 0 +while $count < $N + $ms = 1591200000000 + $count + sql insert into ct1 values( $ms , $count , 2.1, 3.1) + $count = $count + 1 +endw + + +#sql flush database db; + + +sleep 3000 + + +print ===> stop dnode1 dnode2 dnode3 dnode4 +system sh/exec.sh -n dnode1 -s stop -x SIGINT +system sh/exec.sh -n dnode2 -s stop -x SIGINT +system sh/exec.sh -n dnode3 -s stop -x SIGINT +system sh/exec.sh -n dnode4 -s stop -x SIGINT + + + +######################################################## +print ===> start dnode1 dnode2 dnode3 dnode4 +system sh/exec.sh -n dnode1 -s start +system sh/exec.sh -n dnode2 -s start +system sh/exec.sh -n dnode3 -s start +system sh/exec.sh -n dnode4 -s start + +sleep 3000 + +print =============== query data +sql connect +sql use db +sql select * from ct1 +print rows: $rows +print $data00 $data01 $data02 +if $rows != 100 then + return -1 +endi + +#system sh/exec.sh -n dnode1 -s stop -x SIGINT +#system sh/exec.sh -n dnode2 -s stop -x SIGINT +#system sh/exec.sh -n dnode3 -s stop -x SIGINT +#system sh/exec.sh -n dnode4 -s stop -x SIGINT +######################################################### + + + From e9d4948e84a4babe23c718947a97c294353095bd Mon Sep 17 00:00:00 2001 From: Shengliang Guan Date: Tue, 12 Jul 2022 14:46:52 +0800 Subject: [PATCH 20/30] enh: transfer leader before close vnode and mnode --- include/dnode/mnode/mnode.h | 1 + source/dnode/mgmt/mgmt_mnode/src/mmInt.c | 1 + source/dnode/mgmt/mgmt_vnode/src/vmInt.c | 4 +++- source/dnode/mnode/impl/src/mndMain.c | 6 ++++++ source/dnode/vnode/inc/vnode.h | 1 + source/dnode/vnode/src/vnd/vnodeOpen.c | 6 ++++++ 6 files changed, 18 insertions(+), 1 deletion(-) diff --git a/include/dnode/mnode/mnode.h b/include/dnode/mnode/mnode.h index 70056783ea..3bed77d682 100644 --- a/include/dnode/mnode/mnode.h +++ b/include/dnode/mnode/mnode.h @@ -52,6 +52,7 @@ SMnode *mndOpen(const char *path, const SMnodeOpt *pOption); * @param pMnode The mnode object to close. */ void mndClose(SMnode *pMnode); +void mndPreClose(SMnode *pMnode); /** * @brief Start mnode diff --git a/source/dnode/mgmt/mgmt_mnode/src/mmInt.c b/source/dnode/mgmt/mgmt_mnode/src/mmInt.c index 012e61d239..84491a82b0 100644 --- a/source/dnode/mgmt/mgmt_mnode/src/mmInt.c +++ b/source/dnode/mgmt/mgmt_mnode/src/mmInt.c @@ -150,6 +150,7 @@ static void mmStop(SMnodeMgmt *pMgmt) { dDebug("mnode-mgmt start to stop"); taosThreadRwlockWrlock(&pMgmt->lock); pMgmt->stopped = 1; + mndPreClose(pMgmt->pMnode); taosThreadRwlockUnlock(&pMgmt->lock); mndStop(pMgmt->pMnode); diff --git a/source/dnode/mgmt/mgmt_vnode/src/vmInt.c b/source/dnode/mgmt/mgmt_vnode/src/vmInt.c index 051e5defb0..eac9052289 100644 --- a/source/dnode/mgmt/mgmt_vnode/src/vmInt.c +++ b/source/dnode/mgmt/mgmt_vnode/src/vmInt.c @@ -75,11 +75,13 @@ int32_t vmOpenVnode(SVnodeMgmt *pMgmt, SWrapperCfg *pCfg, SVnode *pImpl) { void vmCloseVnode(SVnodeMgmt *pMgmt, SVnodeObj *pVnode) { char path[TSDB_FILENAME_LEN] = {0}; + vnodePreClose(pVnode->pImpl); + taosThreadRwlockWrlock(&pMgmt->lock); taosHashRemove(pMgmt->hash, &pVnode->vgId, sizeof(int32_t)); taosThreadRwlockUnlock(&pMgmt->lock); - vmReleaseVnode(pMgmt, pVnode); + while (pVnode->refCount > 0) taosMsleep(10); dTrace("vgId:%d, wait for vnode queue is empty", pVnode->vgId); diff --git a/source/dnode/mnode/impl/src/mndMain.c b/source/dnode/mnode/impl/src/mndMain.c index 861aa82a93..df8dc42d17 100644 --- a/source/dnode/mnode/impl/src/mndMain.c +++ b/source/dnode/mnode/impl/src/mndMain.c @@ -366,6 +366,12 @@ SMnode *mndOpen(const char *path, const SMnodeOpt *pOption) { return pMnode; } +void mndPreClose(SMnode *pMnode) { + if (pMnode != NULL) { + syncLeaderTransfer(pMnode->syncMgmt.sync); + } +} + void mndClose(SMnode *pMnode) { if (pMnode != NULL) { mDebug("start to close mnode"); diff --git a/source/dnode/vnode/inc/vnode.h b/source/dnode/vnode/inc/vnode.h index bba4bdb2b1..8f2d3bde09 100644 --- a/source/dnode/vnode/inc/vnode.h +++ b/source/dnode/vnode/inc/vnode.h @@ -51,6 +51,7 @@ void vnodeCleanup(); int32_t vnodeCreate(const char *path, SVnodeCfg *pCfg, STfs *pTfs); void vnodeDestroy(const char *path, STfs *pTfs); SVnode *vnodeOpen(const char *path, STfs *pTfs, SMsgCb msgCb); +void vnodePreClose(SVnode *pVnode); void vnodeClose(SVnode *pVnode); int32_t vnodeStart(SVnode *pVnode); diff --git a/source/dnode/vnode/src/vnd/vnodeOpen.c b/source/dnode/vnode/src/vnd/vnodeOpen.c index cf95040585..0914827950 100644 --- a/source/dnode/vnode/src/vnd/vnodeOpen.c +++ b/source/dnode/vnode/src/vnd/vnodeOpen.c @@ -175,6 +175,12 @@ _err: return NULL; } +void vnodePreClose(SVnode *pVnode) { + if (pVnode) { + syncLeaderTransfer(pVnode->sync); + } +} + void vnodeClose(SVnode *pVnode) { if (pVnode) { vnodeCommit(pVnode); From 9813094f16c18e9916ad00c22502d0d9233739c1 Mon Sep 17 00:00:00 2001 From: dapan1121 Date: Tue, 12 Jul 2022 14:51:32 +0800 Subject: [PATCH 21/30] fix: fix lock and set plan addr issue --- include/util/tlockfree.h | 3 +- source/libs/catalog/inc/catalogInt.h | 32 +++++++++--------- source/libs/qworker/inc/qwInt.h | 32 +++++++++--------- source/libs/scheduler/inc/schInt.h | 32 +++++++++--------- source/libs/scheduler/src/schTask.c | 5 ++- source/util/src/tlockfree.c | 50 ++++++---------------------- 6 files changed, 62 insertions(+), 92 deletions(-) diff --git a/include/util/tlockfree.h b/include/util/tlockfree.h index 54a90d7b71..8db6be8860 100644 --- a/include/util/tlockfree.h +++ b/include/util/tlockfree.h @@ -69,10 +69,9 @@ typedef void (*_ref_fn_t)(const void *pObj); #define T_REF_VAL_GET(x) (x)->_ref.val // single writer multiple reader lock -typedef volatile int64_t SRWLatch; +typedef volatile int32_t SRWLatch; void taosInitRWLatch(SRWLatch *pLatch); -void taosInitReentrantRWLatch(SRWLatch *pLatch); void taosWLockLatch(SRWLatch *pLatch); void taosWUnLockLatch(SRWLatch *pLatch); void taosRLockLatch(SRWLatch *pLatch); diff --git a/source/libs/catalog/inc/catalogInt.h b/source/libs/catalog/inc/catalogInt.h index 598a754c50..dce7adfea9 100644 --- a/source/libs/catalog/inc/catalogInt.h +++ b/source/libs/catalog/inc/catalogInt.h @@ -482,33 +482,33 @@ typedef struct SCtgOperation { #define CTG_LOCK(type, _lock) do { \ if (CTG_READ == (type)) { \ - assert(atomic_load_64((_lock)) >= 0); \ - CTG_LOCK_DEBUG("CTG RLOCK%p:%" PRIx64 ", %s:%d B", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32((_lock)) >= 0); \ + CTG_LOCK_DEBUG("CTG RLOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ taosRLockLatch(_lock); \ - CTG_LOCK_DEBUG("CTG RLOCK%p:%" PRIx64 ", %s:%d E", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ - assert(atomic_load_64((_lock)) > 0); \ + CTG_LOCK_DEBUG("CTG RLOCK%p:%d, %s:%d E", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32((_lock)) > 0); \ } else { \ - assert(atomic_load_64((_lock)) >= 0); \ - CTG_LOCK_DEBUG("CTG WLOCK%p:%" PRIx64 ", %s:%d B", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32((_lock)) >= 0); \ + CTG_LOCK_DEBUG("CTG WLOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ taosWLockLatch(_lock); \ - CTG_LOCK_DEBUG("CTG WLOCK%p:%" PRIx64 ", %s:%d E", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ - assert(atomic_load_64((_lock)) == TD_RWLATCH_WRITE_FLAG_COPY); \ + CTG_LOCK_DEBUG("CTG WLOCK%p:%d, %s:%d E", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32((_lock)) == TD_RWLATCH_WRITE_FLAG_COPY); \ } \ } while (0) #define CTG_UNLOCK(type, _lock) do { \ if (CTG_READ == (type)) { \ - assert(atomic_load_64((_lock)) > 0); \ - CTG_LOCK_DEBUG("CTG RULOCK%p:%" PRIx64 ", %s:%d B", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32((_lock)) > 0); \ + CTG_LOCK_DEBUG("CTG RULOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ taosRUnLockLatch(_lock); \ - CTG_LOCK_DEBUG("CTG RULOCK%p:%" PRIx64 ", %s:%d E", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ - assert(atomic_load_64((_lock)) >= 0); \ + CTG_LOCK_DEBUG("CTG RULOCK%p:%d, %s:%d E", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32((_lock)) >= 0); \ } else { \ - assert(atomic_load_64((_lock)) == TD_RWLATCH_WRITE_FLAG_COPY); \ - CTG_LOCK_DEBUG("CTG WULOCK%p:%" PRIx64 ", %s:%d B", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32((_lock)) == TD_RWLATCH_WRITE_FLAG_COPY); \ + CTG_LOCK_DEBUG("CTG WULOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ taosWUnLockLatch(_lock); \ - CTG_LOCK_DEBUG("CTG WULOCK%p:%" PRIx64 ", %s:%d E", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ - assert(atomic_load_64((_lock)) >= 0); \ + CTG_LOCK_DEBUG("CTG WULOCK%p:%d, %s:%d E", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32((_lock)) >= 0); \ } \ } while (0) diff --git a/source/libs/qworker/inc/qwInt.h b/source/libs/qworker/inc/qwInt.h index b35e0e2fc4..539643c390 100644 --- a/source/libs/qworker/inc/qwInt.h +++ b/source/libs/qworker/inc/qwInt.h @@ -316,34 +316,34 @@ typedef struct SQWorkerMgmt { #define QW_LOCK(type, _lock) \ do { \ if (QW_READ == (type)) { \ - assert(atomic_load_64((_lock)) >= 0); \ - QW_LOCK_DEBUG("QW RLOCK%p:%" PRIx64 ", %s:%d B", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32((_lock)) >= 0); \ + QW_LOCK_DEBUG("QW RLOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ taosRLockLatch(_lock); \ - QW_LOCK_DEBUG("QW RLOCK%p:%" PRIx64 ", %s:%d E", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ - assert(atomic_load_64((_lock)) > 0); \ + QW_LOCK_DEBUG("QW RLOCK%p:%d, %s:%d E", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32((_lock)) > 0); \ } else { \ - assert(atomic_load_64((_lock)) >= 0); \ - QW_LOCK_DEBUG("QW WLOCK%p:%" PRIx64 ", %s:%d B", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32((_lock)) >= 0); \ + QW_LOCK_DEBUG("QW WLOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ taosWLockLatch(_lock); \ - QW_LOCK_DEBUG("QW WLOCK%p:%" PRIx64 ", %s:%d E", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ - assert(atomic_load_64((_lock)) == TD_RWLATCH_WRITE_FLAG_COPY); \ + QW_LOCK_DEBUG("QW WLOCK%p:%d, %s:%d E", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32((_lock)) == TD_RWLATCH_WRITE_FLAG_COPY); \ } \ } while (0) #define QW_UNLOCK(type, _lock) \ do { \ if (QW_READ == (type)) { \ - assert(atomic_load_64((_lock)) > 0); \ - QW_LOCK_DEBUG("QW RULOCK%p:%" PRIx64 ", %s:%d B", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32((_lock)) > 0); \ + QW_LOCK_DEBUG("QW RULOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ taosRUnLockLatch(_lock); \ - QW_LOCK_DEBUG("QW RULOCK%p:%" PRIx64 ", %s:%d E", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ - assert(atomic_load_64((_lock)) >= 0); \ + QW_LOCK_DEBUG("QW RULOCK%p:%d, %s:%d E", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32((_lock)) >= 0); \ } else { \ - assert(atomic_load_64((_lock)) == TD_RWLATCH_WRITE_FLAG_COPY); \ - QW_LOCK_DEBUG("QW WULOCK%p:%" PRIx64 ", %s:%d B", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32((_lock)) == TD_RWLATCH_WRITE_FLAG_COPY); \ + QW_LOCK_DEBUG("QW WULOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ taosWUnLockLatch(_lock); \ - QW_LOCK_DEBUG("QW WULOCK%p:%" PRIx64 ", %s:%d E", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ - assert(atomic_load_64((_lock)) >= 0); \ + QW_LOCK_DEBUG("QW WULOCK%p:%d, %s:%d E", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32((_lock)) >= 0); \ } \ } while (0) diff --git a/source/libs/scheduler/inc/schInt.h b/source/libs/scheduler/inc/schInt.h index e5c7e37479..0a0d319025 100644 --- a/source/libs/scheduler/inc/schInt.h +++ b/source/libs/scheduler/inc/schInt.h @@ -367,33 +367,33 @@ extern SSchedulerMgmt schMgmt; #define SCH_LOCK(type, _lock) do { \ if (SCH_READ == (type)) { \ - assert(atomic_load_64(_lock) >= 0); \ - SCH_LOCK_DEBUG("SCH RLOCK%p:%" PRIx64 ", %s:%d B", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32(_lock) >= 0); \ + SCH_LOCK_DEBUG("SCH RLOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ taosRLockLatch(_lock); \ - SCH_LOCK_DEBUG("SCH RLOCK%p:%" PRIx64 ", %s:%d E", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ - assert(atomic_load_64(_lock) > 0); \ + SCH_LOCK_DEBUG("SCH RLOCK%p:%d, %s:%d E", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32(_lock) > 0); \ } else { \ - assert(atomic_load_64(_lock) >= 0); \ - SCH_LOCK_DEBUG("SCH WLOCK%p:%" PRIx64 ", %s:%d B", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32(_lock) >= 0); \ + SCH_LOCK_DEBUG("SCH WLOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ taosWLockLatch(_lock); \ - SCH_LOCK_DEBUG("SCH WLOCK%p:%" PRIx64 ", %s:%d E", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ - assert(atomic_load_64(_lock) & TD_RWLATCH_WRITE_FLAG_COPY); \ + SCH_LOCK_DEBUG("SCH WLOCK%p:%d, %s:%d E", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32(_lock) == TD_RWLATCH_WRITE_FLAG_COPY); \ } \ } while (0) #define SCH_UNLOCK(type, _lock) do { \ if (SCH_READ == (type)) { \ - assert(atomic_load_64((_lock)) > 0); \ - SCH_LOCK_DEBUG("SCH RULOCK%p:%" PRIx64 ", %s:%d B", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32((_lock)) > 0); \ + SCH_LOCK_DEBUG("SCH RULOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ taosRUnLockLatch(_lock); \ - SCH_LOCK_DEBUG("SCH RULOCK%p:%" PRIx64 ", %s:%d E", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ - assert(atomic_load_64((_lock)) >= 0); \ + SCH_LOCK_DEBUG("SCH RULOCK%p:%d, %s:%d E", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32((_lock)) >= 0); \ } else { \ - assert(atomic_load_64((_lock)) & TD_RWLATCH_WRITE_FLAG_COPY); \ - SCH_LOCK_DEBUG("SCH WULOCK%p:%" PRIx64 ", %s:%d B", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32((_lock)) & TD_RWLATCH_WRITE_FLAG_COPY); \ + SCH_LOCK_DEBUG("SCH WULOCK%p:%d, %s:%d B", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ taosWUnLockLatch(_lock); \ - SCH_LOCK_DEBUG("SCH WULOCK%p:%" PRIx64 ", %s:%d E", (_lock), atomic_load_64(_lock), __FILE__, __LINE__); \ - assert(atomic_load_64((_lock)) >= 0); \ + SCH_LOCK_DEBUG("SCH WULOCK%p:%d, %s:%d E", (_lock), atomic_load_32(_lock), __FILE__, __LINE__); \ + assert(atomic_load_32((_lock)) >= 0); \ } \ } while (0) diff --git a/source/libs/scheduler/src/schTask.c b/source/libs/scheduler/src/schTask.c index a6621d279d..b4fddb7d23 100644 --- a/source/libs/scheduler/src/schTask.c +++ b/source/libs/scheduler/src/schTask.c @@ -60,7 +60,6 @@ int32_t schInitTask(SSchJob *pJob, SSchTask *pTask, SSubplan *pPlan, SSchLevel * if (NULL == pTask->execNodes || NULL == pTask->profile.execTime) { SCH_ERR_JRET(TSDB_CODE_QRY_OUT_OF_MEMORY); } - taosInitReentrantRWLatch(&pTask->lock); SCH_SET_TASK_STATUS(pTask, JOB_TASK_STATUS_INIT); @@ -264,7 +263,7 @@ int32_t schProcessOnTaskSuccess(SSchJob *pJob, SSchTask *pTask) { SSchTask *parent = *(SSchTask **)taosArrayGet(pTask->parents, i); int32_t readyNum = atomic_add_fetch_32(&parent->childReady, 1); - SCH_LOCK_TASK(parent); + SCH_LOCK(SCH_WRITE, &parent->planLock); SDownstreamSourceNode source = {.type = QUERY_NODE_DOWNSTREAM_SOURCE, .taskId = pTask->taskId, .schedId = schMgmt.sId, @@ -273,7 +272,7 @@ int32_t schProcessOnTaskSuccess(SSchJob *pJob, SSchTask *pTask) { .fetchMsgType = SCH_FETCH_TYPE(pTask), }; qSetSubplanExecutionNode(parent->plan, pTask->plan->id.groupId, &source); - SCH_UNLOCK_TASK(parent); + SCH_UNLOCK(SCH_WRITE, &parent->planLock); if (SCH_TASK_READY_FOR_LAUNCH(readyNum, parent)) { SCH_TASK_DLOG("all %d children task done, start to launch parent task 0x%" PRIx64, readyNum, parent->taskId); diff --git a/source/util/src/tlockfree.c b/source/util/src/tlockfree.c index 3cab16ee83..69ab6c1a52 100644 --- a/source/util/src/tlockfree.c +++ b/source/util/src/tlockfree.c @@ -17,10 +17,8 @@ #include "tlockfree.h" #define TD_RWLATCH_WRITE_FLAG 0x40000000 -#define TD_RWLATCH_REENTRANT_FLAG 0x4000000000000000 void taosInitRWLatch(SRWLatch *pLatch) { *pLatch = 0; } -void taosInitReentrantRWLatch(SRWLatch *pLatch) { *pLatch = TD_RWLATCH_REENTRANT_FLAG; } void taosWLockLatch(SRWLatch *pLatch) { SRWLatch oLatch, nLatch; @@ -28,14 +26,8 @@ void taosWLockLatch(SRWLatch *pLatch) { // Set write flag while (1) { - oLatch = atomic_load_64(pLatch); + oLatch = atomic_load_32(pLatch); if (oLatch & TD_RWLATCH_WRITE_FLAG) { - if (oLatch & TD_RWLATCH_REENTRANT_FLAG) { - nLatch = (((oLatch >> 32) + 1) << 32) | (oLatch & 0xFFFFFFFF); - if (atomic_val_compare_exchange_64(pLatch, oLatch, nLatch) == oLatch) break; - - continue; - } nLoops++; if (nLoops > 1000) { sched_yield(); @@ -45,14 +37,14 @@ void taosWLockLatch(SRWLatch *pLatch) { } nLatch = oLatch | TD_RWLATCH_WRITE_FLAG; - if (atomic_val_compare_exchange_64(pLatch, oLatch, nLatch) == oLatch) break; + if (atomic_val_compare_exchange_32(pLatch, oLatch, nLatch) == oLatch) break; } // wait for all reads end nLoops = 0; while (1) { - oLatch = atomic_load_64(pLatch); - if (0 == (oLatch & 0xFFFFFFF)) break; + oLatch = atomic_load_32(pLatch); + if (0 == oLatch) break; nLoops++; if (nLoops > 1000) { sched_yield(); @@ -64,47 +56,27 @@ void taosWLockLatch(SRWLatch *pLatch) { // no reentrant int32_t taosWTryLockLatch(SRWLatch *pLatch) { SRWLatch oLatch, nLatch; - oLatch = atomic_load_64(pLatch); - if (oLatch << 2) { + oLatch = atomic_load_32(pLatch); + if (oLatch) { return -1; } nLatch = oLatch | TD_RWLATCH_WRITE_FLAG; - if (atomic_val_compare_exchange_64(pLatch, oLatch, nLatch) == oLatch) { + if (atomic_val_compare_exchange_32(pLatch, oLatch, nLatch) == oLatch) { return 0; } return -1; } -void taosWUnLockLatch(SRWLatch *pLatch) { - SRWLatch oLatch, nLatch, wLatch; - - while (1) { - oLatch = atomic_load_64(pLatch); - - if (0 == (oLatch & TD_RWLATCH_REENTRANT_FLAG)) { - atomic_store_64(pLatch, 0); - break; - } - - wLatch = ((oLatch << 2) >> 34); - if (wLatch) { - nLatch = ((--wLatch) << 32) | TD_RWLATCH_REENTRANT_FLAG | TD_RWLATCH_WRITE_FLAG; - } else { - nLatch = TD_RWLATCH_REENTRANT_FLAG; - } - - if (atomic_val_compare_exchange_64(pLatch, oLatch, nLatch) == oLatch) break; - } -} +void taosWUnLockLatch(SRWLatch *pLatch) { atomic_store_32(pLatch, 0); } void taosRLockLatch(SRWLatch *pLatch) { SRWLatch oLatch, nLatch; int32_t nLoops = 0; while (1) { - oLatch = atomic_load_64(pLatch); + oLatch = atomic_load_32(pLatch); if (oLatch & TD_RWLATCH_WRITE_FLAG) { nLoops++; if (nLoops > 1000) { @@ -115,8 +87,8 @@ void taosRLockLatch(SRWLatch *pLatch) { } nLatch = oLatch + 1; - if (atomic_val_compare_exchange_64(pLatch, oLatch, nLatch) == oLatch) break; + if (atomic_val_compare_exchange_32(pLatch, oLatch, nLatch) == oLatch) break; } } -void taosRUnLockLatch(SRWLatch *pLatch) { atomic_fetch_sub_64(pLatch, 1); } +void taosRUnLockLatch(SRWLatch *pLatch) { atomic_fetch_sub_32(pLatch, 1); } From cea0a7849a1a00fa32efaf31b96249575a7dadbb Mon Sep 17 00:00:00 2001 From: dapan1121 Date: Tue, 12 Jul 2022 15:03:32 +0800 Subject: [PATCH 22/30] fix: fix lock issue --- source/util/src/tlockfree.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/util/src/tlockfree.c b/source/util/src/tlockfree.c index 69ab6c1a52..6f7b6f6901 100644 --- a/source/util/src/tlockfree.c +++ b/source/util/src/tlockfree.c @@ -44,7 +44,7 @@ void taosWLockLatch(SRWLatch *pLatch) { nLoops = 0; while (1) { oLatch = atomic_load_32(pLatch); - if (0 == oLatch) break; + if (oLatch == TD_RWLATCH_WRITE_FLAG) break; nLoops++; if (nLoops > 1000) { sched_yield(); From 96f9274fef73be521a866df88b760e25c23e22bb Mon Sep 17 00:00:00 2001 From: Minghao Li Date: Tue, 12 Jul 2022 15:04:32 +0800 Subject: [PATCH 23/30] refactor(sync): add timer routines --- source/dnode/mnode/impl/src/mndSync.c | 1 + source/dnode/vnode/src/vnd/vnodeSync.c | 2 +- source/libs/sync/inc/syncEnv.h | 2 +- source/libs/sync/src/syncMain.c | 30 +++++++------------------- source/libs/sync/src/syncTimeout.c | 12 +++++++++-- 5 files changed, 21 insertions(+), 26 deletions(-) diff --git a/source/dnode/mnode/impl/src/mndSync.c b/source/dnode/mnode/impl/src/mndSync.c index d77b39003a..bcf926e5ee 100644 --- a/source/dnode/mnode/impl/src/mndSync.c +++ b/source/dnode/mnode/impl/src/mndSync.c @@ -199,6 +199,7 @@ int32_t mndInitSync(SMnode *pMnode) { } // decrease election timer + setPingTimerMS(pMgmt->sync, 5000); setElectTimerMS(pMgmt->sync, 600); setHeartbeatTimerMS(pMgmt->sync, 300); diff --git a/source/dnode/vnode/src/vnd/vnodeSync.c b/source/dnode/vnode/src/vnd/vnodeSync.c index 97ce8eaab7..bdcfe208d6 100644 --- a/source/dnode/vnode/src/vnd/vnodeSync.c +++ b/source/dnode/vnode/src/vnd/vnodeSync.c @@ -569,7 +569,7 @@ int32_t vnodeSyncOpen(SVnode *pVnode, char *path) { return -1; } - setPingTimerMS(pVnode->sync, 3000); + setPingTimerMS(pVnode->sync, 5000); setElectTimerMS(pVnode->sync, 500); setHeartbeatTimerMS(pVnode->sync, 100); return 0; diff --git a/source/libs/sync/inc/syncEnv.h b/source/libs/sync/inc/syncEnv.h index beddec64c5..dd032f1481 100644 --- a/source/libs/sync/inc/syncEnv.h +++ b/source/libs/sync/inc/syncEnv.h @@ -30,7 +30,7 @@ extern "C" { #define TIMER_MAX_MS 0x7FFFFFFF #define ENV_TICK_TIMER_MS 1000 -#define PING_TIMER_MS 1000 +#define PING_TIMER_MS 5000 #define ELECT_TIMER_MS_MIN 1300 #define ELECT_TIMER_MS_MAX (ELECT_TIMER_MS_MIN * 2) #define ELECT_TIMER_MS_RANGE (ELECT_TIMER_MS_MAX - ELECT_TIMER_MS_MIN) diff --git a/source/libs/sync/src/syncMain.c b/source/libs/sync/src/syncMain.c index 6093d622b7..abc0f53611 100644 --- a/source/libs/sync/src/syncMain.c +++ b/source/libs/sync/src/syncMain.c @@ -1099,19 +1099,13 @@ void syncNodeStart(SSyncNode* pSyncNode) { // Raft 3.6.2 Committing entries from previous terms syncNodeAppendNoop(pSyncNode); syncMaybeAdvanceCommitIndex(pSyncNode); - - return; + } else { + syncNodeBecomeFollower(pSyncNode, "first start"); } - syncNodeBecomeFollower(pSyncNode, "first start"); - - // int32_t ret = 0; - // ret = syncNodeStartPingTimer(pSyncNode); - // ASSERT(ret == 0); - - if (gRaftDetailLog) { - syncNodeLog2("==state change become leader immediately==", pSyncNode); - } + int32_t ret = 0; + ret = syncNodeStartPingTimer(pSyncNode); + ASSERT(ret == 0); } void syncNodeStartStandBy(SSyncNode* pSyncNode) { @@ -1162,14 +1156,6 @@ void syncNodeClose(SSyncNode* pSyncNode) { pSyncNode->pNewNodeReceiver = NULL; } - /* - if (pSyncNode->pSnapshot != NULL) { - taosMemoryFree(pSyncNode->pSnapshot); - } - */ - - // tsem_destroy(&pSyncNode->restoreSem); - // free memory in syncFreeNode // taosMemoryFree(pSyncNode); } @@ -1234,7 +1220,7 @@ int32_t syncNodeStartPingTimer(SSyncNode* pSyncNode) { &pSyncNode->pPingTimer); atomic_store_64(&pSyncNode->pingTimerLogicClock, pSyncNode->pingTimerLogicClockUser); } else { - sError("sync env is stop, syncNodeStartPingTimer"); + sError("vgId:%d, start ping timer error, sync env is stop", pSyncNode->vgId); } return ret; } @@ -1255,7 +1241,7 @@ int32_t syncNodeStartElectTimer(SSyncNode* pSyncNode, int32_t ms) { &pSyncNode->pElectTimer); atomic_store_64(&pSyncNode->electTimerLogicClock, pSyncNode->electTimerLogicClockUser); } else { - sError("sync env is stop, syncNodeStartElectTimer"); + sError("vgId:%d, start elect timer error, sync env is stop", pSyncNode->vgId); } return ret; } @@ -1295,7 +1281,7 @@ int32_t syncNodeStartHeartbeatTimer(SSyncNode* pSyncNode) { &pSyncNode->pHeartbeatTimer); atomic_store_64(&pSyncNode->heartbeatTimerLogicClock, pSyncNode->heartbeatTimerLogicClockUser); } else { - sError("sync env is stop, syncNodeStartHeartbeatTimer"); + sError("vgId:%d, start heartbeat timer error, sync env is stop", pSyncNode->vgId); } return ret; } diff --git a/source/libs/sync/src/syncTimeout.c b/source/libs/sync/src/syncTimeout.c index 0d3a3c3cc5..52181a3da8 100644 --- a/source/libs/sync/src/syncTimeout.c +++ b/source/libs/sync/src/syncTimeout.c @@ -17,6 +17,11 @@ #include "syncElection.h" #include "syncReplication.h" +int32_t syncNodeTimerRoutine(SSyncNode* ths) { + syncNodeEventLog(ths, "timer routines ... "); + return 0; +} + int32_t syncNodeOnTimeoutCb(SSyncNode* ths, SyncTimeout* pMsg) { int32_t ret = 0; syncTimeoutLog2("==syncNodeOnTimeoutCb==", pMsg); @@ -24,8 +29,11 @@ int32_t syncNodeOnTimeoutCb(SSyncNode* ths, SyncTimeout* pMsg) { if (pMsg->timeoutType == SYNC_TIMEOUT_PING) { if (atomic_load_64(&ths->pingTimerLogicClockUser) <= pMsg->logicClock) { ++(ths->pingTimerCounter); + // syncNodePingAll(ths); - syncNodePingPeers(ths); + // syncNodePingPeers(ths); + + syncNodeTimerRoutine(ths); } } else if (pMsg->timeoutType == SYNC_TIMEOUT_ELECTION) { @@ -40,7 +48,7 @@ int32_t syncNodeOnTimeoutCb(SSyncNode* ths, SyncTimeout* pMsg) { syncNodeReplicate(ths); } } else { - sTrace("unknown timeoutType:%d", pMsg->timeoutType); + sError("vgId:%d, unknown timeout-type:%d", ths->vgId, pMsg->timeoutType); } return ret; From 8b894921010aaa939dcfdafbb66c3ce0c6989a89 Mon Sep 17 00:00:00 2001 From: Xiaoyu Wang Date: Tue, 12 Jul 2022 15:11:55 +0800 Subject: [PATCH 24/30] fix: some problems of parser --- source/common/src/tglobal.c | 2 +- source/libs/nodes/src/nodesCodeFuncs.c | 1 - source/libs/nodes/src/nodesUtilFuncs.c | 5 +- source/libs/parser/inc/sql.y | 1 + source/libs/parser/src/parInsert.c | 5 +- source/libs/parser/src/parTranslater.c | 28 +- source/libs/parser/src/parUtil.c | 2 +- source/libs/parser/src/sql.c | 2198 ++++++++++++------------ 8 files changed, 1115 insertions(+), 1127 deletions(-) diff --git a/source/common/src/tglobal.c b/source/common/src/tglobal.c index f19d17d034..357f258951 100644 --- a/source/common/src/tglobal.c +++ b/source/common/src/tglobal.c @@ -114,7 +114,7 @@ int32_t tsMinSlidingTime = 10; // the maxinum number of distict query result int32_t tsMaxNumOfDistinctResults = 1000 * 10000; -// 1 us for interval time range, changed accordingly +// 1 database precision unit for interval time range, changed accordingly int32_t tsMinIntervalTime = 1; // 20sec, the maximum value of stream computing delay, changed accordingly diff --git a/source/libs/nodes/src/nodesCodeFuncs.c b/source/libs/nodes/src/nodesCodeFuncs.c index 294488a38d..3c285cc7f1 100644 --- a/source/libs/nodes/src/nodesCodeFuncs.c +++ b/source/libs/nodes/src/nodesCodeFuncs.c @@ -2481,7 +2481,6 @@ static int32_t jsonToSubplan(const SJson* pJson, void* pObj) { int32_t code = tjsonToObject(pJson, jkSubplanId, jsonToSubplanId, &pNode->id); if (TSDB_CODE_SUCCESS == code) { tjsonGetNumberValue(pJson, jkSubplanType, pNode->subplanType, code); - ; } if (TSDB_CODE_SUCCESS == code) { code = tjsonGetIntValue(pJson, jkSubplanMsgType, &pNode->msgType); diff --git a/source/libs/nodes/src/nodesUtilFuncs.c b/source/libs/nodes/src/nodesUtilFuncs.c index 897b575e10..4abb8f5c2c 100644 --- a/source/libs/nodes/src/nodesUtilFuncs.c +++ b/source/libs/nodes/src/nodesUtilFuncs.c @@ -956,7 +956,8 @@ void nodesDestroyNode(SNode* pNode) { } case QUERY_NODE_PHYSICAL_SUBPLAN: { SSubplan* pSubplan = (SSubplan*)pNode; - nodesDestroyList(pSubplan->pChildren); + // nodesDestroyList(pSubplan->pChildren); + nodesClearList(pSubplan->pChildren); nodesDestroyNode((SNode*)pSubplan->pNode); nodesDestroyNode((SNode*)pSubplan->pDataSink); nodesDestroyNode((SNode*)pSubplan->pTagCond); @@ -972,7 +973,7 @@ void nodesDestroyNode(SNode* pNode) { SNode* pElement = NULL; FOREACH(pElement, pPlan->pSubplans) { if (first) { - first = false; + // first = false; nodesDestroyNode(pElement); } else { nodesClearList(((SNodeListNode*)pElement)->pNodeList); diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y index cd0b5c1d6c..606d35a65b 100644 --- a/source/libs/parser/inc/sql.y +++ b/source/libs/parser/inc/sql.y @@ -556,6 +556,7 @@ signed_literal(A) ::= TIMESTAMP NK_STRING(B). signed_literal(A) ::= duration_literal(B). { A = releaseRawExprNode(pCxt, B); } signed_literal(A) ::= NULL(B). { A = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &B); } signed_literal(A) ::= literal_func(B). { A = releaseRawExprNode(pCxt, B); } +signed_literal(A) ::= NK_QUESTION(B). { A = createPlaceholderValueNode(pCxt, &B); } %type literal_list { SNodeList* } %destructor literal_list { nodesDestroyList($$); } diff --git a/source/libs/parser/src/parInsert.c b/source/libs/parser/src/parInsert.c index 2494c5a8a7..f986d24a7e 100644 --- a/source/libs/parser/src/parInsert.c +++ b/source/libs/parser/src/parInsert.c @@ -133,7 +133,10 @@ static int32_t createSName(SName* pName, SToken* pTableName, int32_t acctId, con assert(*p == TS_PATH_DELIMITER[0]); int32_t dbLen = p - pTableName->z; - char name[TSDB_DB_FNAME_LEN] = {0}; + if (dbLen <= 0) { + return buildInvalidOperationMsg(pMsgBuf, msg2); + } + char name[TSDB_DB_FNAME_LEN] = {0}; strncpy(name, pTableName->z, dbLen); dbLen = strdequote(name); diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index f417f0e084..da393bb883 100644 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -2173,14 +2173,28 @@ static int64_t getMonthsFromTimeVal(int64_t val, int32_t fromPrecision, char uni return -1; } +static const char* getPrecisionStr(uint8_t precision) { + switch (precision) { + case TSDB_TIME_PRECISION_MILLI: + return TSDB_TIME_PRECISION_MILLI_STR; + case TSDB_TIME_PRECISION_MICRO: + return TSDB_TIME_PRECISION_MICRO_STR; + case TSDB_TIME_PRECISION_NANO: + return TSDB_TIME_PRECISION_NANO_STR; + default: + break; + } + return "unknown"; +} + static int32_t checkIntervalWindow(STranslateContext* pCxt, SIntervalWindowNode* pInterval) { uint8_t precision = ((SColumnNode*)pInterval->pCol)->node.resType.precision; SValueNode* pInter = (SValueNode*)pInterval->pInterval; bool valInter = TIME_IS_VAR_DURATION(pInter->unit); - if (pInter->datum.i <= 0 || - (!valInter && convertTimePrecision(pInter->datum.i, precision, TSDB_TIME_PRECISION_MICRO) < tsMinIntervalTime)) { - return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INTER_VALUE_TOO_SMALL, tsMinIntervalTime); + if (pInter->datum.i <= 0 || (!valInter && pInter->datum.i < tsMinIntervalTime)) { + return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INTER_VALUE_TOO_SMALL, tsMinIntervalTime, + getPrecisionStr(precision)); } if (NULL != pInterval->pOffset) { @@ -2754,6 +2768,11 @@ static int32_t translateInsertProject(STranslateContext* pCxt, SInsertStmt* pIns } } + if (NULL == pPrimaryKeyExpr) { + return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_COLUMNS_NUM, + "Primary timestamp column can not be null"); + } + return addOrderByPrimaryKeyToQuery(pCxt, pPrimaryKeyExpr, pInsert->pQuery); } @@ -2998,8 +3017,7 @@ static int32_t checkDatabaseOptions(STranslateContext* pCxt, const char* pDbName int32_t code = checkRangeOption(pCxt, "buffer", pOptions->buffer, TSDB_MIN_BUFFER_PER_VNODE, TSDB_MAX_BUFFER_PER_VNODE); if (TSDB_CODE_SUCCESS == code) { - code = checkRangeOption(pCxt, "cacheLast", pOptions->cacheLast, TSDB_MIN_DB_CACHE_LAST, - TSDB_MAX_DB_CACHE_LAST); + code = checkRangeOption(pCxt, "cacheLast", pOptions->cacheLast, TSDB_MIN_DB_CACHE_LAST, TSDB_MAX_DB_CACHE_LAST); } if (TSDB_CODE_SUCCESS == code) { code = checkRangeOption(pCxt, "cacheLastSize", pOptions->cacheLastSize, TSDB_MIN_DB_CACHE_LAST_SIZE, diff --git a/source/libs/parser/src/parUtil.c b/source/libs/parser/src/parUtil.c index 7a23338035..dedd9cabfc 100644 --- a/source/libs/parser/src/parUtil.c +++ b/source/libs/parser/src/parUtil.c @@ -60,7 +60,7 @@ static char* getSyntaxErrFormat(int32_t errCode) { case TSDB_CODE_PAR_EXPRIE_STATEMENT: return "This statement is no longer supported"; case TSDB_CODE_PAR_INTER_VALUE_TOO_SMALL: - return "Interval cannot be less than %d us"; + return "Interval cannot be less than %d %s"; case TSDB_CODE_PAR_DB_NOT_SPECIFIED: return "Database not specified"; case TSDB_CODE_PAR_INVALID_IDENTIFIER_NAME: diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c index cb09860758..d01050ceeb 100644 --- a/source/libs/parser/src/sql.c +++ b/source/libs/parser/src/sql.c @@ -140,16 +140,16 @@ typedef union { #define ParseCTX_STORE #define YYFALLBACK 1 #define YYNSTATE 666 -#define YYNRULE 488 +#define YYNRULE 489 #define YYNTOKEN 255 #define YY_MAX_SHIFT 665 -#define YY_MIN_SHIFTREDUCE 969 -#define YY_MAX_SHIFTREDUCE 1456 -#define YY_ERROR_ACTION 1457 -#define YY_ACCEPT_ACTION 1458 -#define YY_NO_ACTION 1459 -#define YY_MIN_REDUCE 1460 -#define YY_MAX_REDUCE 1947 +#define YY_MIN_SHIFTREDUCE 970 +#define YY_MAX_SHIFTREDUCE 1458 +#define YY_ERROR_ACTION 1459 +#define YY_ACCEPT_ACTION 1460 +#define YY_NO_ACTION 1461 +#define YY_MIN_REDUCE 1462 +#define YY_MAX_REDUCE 1950 /************* End control #defines *******************************************/ #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) @@ -216,260 +216,240 @@ typedef union { ** yy_default[] Default action for each state. ** *********** Begin parsing tables **********************************************/ -#define YY_ACTTAB_COUNT (2520) +#define YY_ACTTAB_COUNT (2318) static const YYACTIONTYPE yy_action[] = { - /* 0 */ 529, 1698, 433, 552, 434, 1495, 441, 1587, 434, 1495, - /* 10 */ 1769, 113, 39, 37, 386, 62, 517, 1583, 471, 380, - /* 20 */ 338, 1766, 1258, 1002, 324, 79, 1782, 1695, 1598, 30, - /* 30 */ 260, 122, 143, 1333, 103, 1256, 1554, 102, 101, 100, - /* 40 */ 99, 98, 97, 96, 95, 94, 1591, 1762, 1768, 327, - /* 50 */ 71, 302, 557, 1925, 1800, 555, 1328, 1512, 1283, 574, - /* 60 */ 1925, 14, 581, 1006, 1007, 500, 1924, 1752, 1264, 580, - /* 70 */ 1922, 120, 1594, 159, 39, 37, 1396, 1922, 498, 487, - /* 80 */ 496, 529, 338, 557, 1258, 1, 250, 1867, 551, 1019, - /* 90 */ 550, 1018, 164, 1925, 1813, 1333, 61, 1256, 89, 1783, - /* 100 */ 583, 1785, 1786, 579, 469, 574, 161, 662, 1859, 1598, - /* 110 */ 1922, 343, 305, 1855, 1643, 1645, 71, 61, 1328, 1020, - /* 120 */ 43, 1335, 1336, 14, 1925, 1461, 1925, 33, 32, 117, - /* 130 */ 1264, 40, 38, 36, 35, 34, 475, 161, 1593, 160, - /* 140 */ 142, 1922, 1472, 1922, 1483, 1782, 103, 2, 214, 102, - /* 150 */ 101, 100, 99, 98, 97, 96, 95, 94, 474, 1155, - /* 160 */ 1156, 486, 485, 484, 170, 1925, 1259, 483, 1257, 662, - /* 170 */ 118, 480, 325, 1800, 479, 478, 477, 1458, 1923, 74, - /* 180 */ 140, 556, 1922, 1335, 1336, 1752, 1752, 555, 580, 1600, - /* 190 */ 1644, 1645, 69, 1262, 1263, 68, 1311, 1312, 1314, 1315, - /* 200 */ 1316, 1317, 1318, 576, 572, 1326, 1327, 1329, 1330, 1331, - /* 210 */ 1332, 1334, 1337, 1813, 36, 35, 34, 90, 1783, 583, - /* 220 */ 1785, 1786, 579, 529, 574, 162, 371, 1859, 1259, 555, - /* 230 */ 1257, 329, 1855, 154, 113, 419, 162, 350, 1482, 33, + /* 0 */ 529, 1700, 433, 552, 434, 1497, 441, 1589, 434, 1497, + /* 10 */ 1772, 113, 39, 37, 386, 62, 517, 1585, 471, 380, + /* 20 */ 338, 1768, 1259, 1003, 324, 79, 1785, 1697, 1600, 30, + /* 30 */ 260, 122, 143, 1335, 103, 1257, 1556, 102, 101, 100, + /* 40 */ 99, 98, 97, 96, 95, 94, 1593, 1764, 1770, 327, + /* 50 */ 71, 302, 557, 1928, 1803, 555, 1330, 1514, 1285, 574, + /* 60 */ 1928, 14, 581, 1007, 1008, 500, 1927, 1754, 1265, 580, + /* 70 */ 1925, 120, 1596, 159, 39, 37, 1398, 1925, 498, 487, + /* 80 */ 496, 529, 338, 557, 1259, 1, 250, 1870, 551, 1020, + /* 90 */ 550, 1019, 164, 1928, 1816, 1335, 61, 1257, 89, 1786, + /* 100 */ 583, 1788, 1789, 579, 469, 574, 161, 662, 1862, 1600, + /* 110 */ 1925, 343, 305, 1858, 1645, 1647, 71, 61, 1330, 1021, + /* 120 */ 43, 1337, 1338, 14, 1928, 1463, 1928, 33, 32, 117, + /* 130 */ 1265, 40, 38, 36, 35, 34, 475, 161, 1595, 160, + /* 140 */ 142, 1925, 1474, 1925, 1485, 1785, 103, 2, 214, 102, + /* 150 */ 101, 100, 99, 98, 97, 96, 95, 94, 474, 1156, + /* 160 */ 1157, 486, 485, 484, 170, 1928, 1260, 483, 1258, 662, + /* 170 */ 118, 480, 325, 1803, 479, 478, 477, 1460, 1926, 74, + /* 180 */ 140, 556, 1925, 1337, 1338, 1754, 1754, 555, 580, 1602, + /* 190 */ 1646, 1647, 69, 1263, 1264, 68, 1313, 1314, 1316, 1317, + /* 200 */ 1318, 1319, 1320, 576, 572, 1328, 1329, 1331, 1332, 1333, + /* 210 */ 1334, 1336, 1339, 1816, 36, 35, 34, 90, 1786, 583, + /* 220 */ 1788, 1789, 579, 529, 574, 162, 371, 1862, 1260, 555, + /* 230 */ 1258, 329, 1858, 154, 113, 419, 162, 350, 1484, 33, /* 240 */ 32, 476, 450, 40, 38, 36, 35, 34, 373, 369, - /* 250 */ 1283, 1598, 552, 1886, 1393, 1262, 1263, 162, 1311, 1312, - /* 260 */ 1314, 1315, 1316, 1317, 1318, 576, 572, 1326, 1327, 1329, - /* 270 */ 1330, 1331, 1332, 1334, 1337, 39, 37, 1453, 1925, 1752, - /* 280 */ 122, 174, 173, 338, 220, 1258, 40, 38, 36, 35, - /* 290 */ 34, 159, 306, 61, 42, 1922, 1333, 1739, 1256, 1113, - /* 300 */ 605, 604, 603, 1117, 602, 1119, 1120, 601, 1122, 598, - /* 310 */ 1800, 1128, 595, 1130, 1131, 592, 589, 1296, 545, 1328, - /* 320 */ 120, 1782, 33, 32, 14, 1355, 40, 38, 36, 35, - /* 330 */ 34, 1264, 39, 37, 554, 155, 1867, 1868, 86, 1872, - /* 340 */ 338, 552, 1258, 1769, 359, 1650, 1238, 1239, 2, 1800, - /* 350 */ 341, 119, 326, 1333, 1766, 1256, 544, 581, 140, 1590, - /* 360 */ 344, 1648, 1752, 529, 580, 1400, 1452, 1600, 140, 122, - /* 370 */ 662, 1282, 1282, 379, 165, 378, 1328, 1600, 557, 1356, - /* 380 */ 1762, 1768, 333, 1576, 1335, 1336, 1460, 432, 1264, 1813, - /* 390 */ 436, 1598, 574, 89, 1783, 583, 1785, 1786, 579, 1481, - /* 400 */ 574, 440, 1361, 1859, 436, 8, 215, 305, 1855, 120, - /* 410 */ 112, 111, 110, 109, 108, 107, 106, 105, 104, 1925, - /* 420 */ 482, 481, 632, 630, 156, 1867, 1868, 662, 1872, 1259, - /* 430 */ 208, 1257, 159, 162, 162, 61, 1922, 75, 516, 1480, - /* 440 */ 1752, 1335, 1336, 450, 29, 336, 1350, 1351, 1352, 1353, - /* 450 */ 1354, 1358, 1359, 1360, 1479, 315, 1262, 1263, 546, 1311, - /* 460 */ 1312, 1314, 1315, 1316, 1317, 1318, 576, 572, 1326, 1327, - /* 470 */ 1329, 1330, 1331, 1332, 1334, 1337, 1392, 33, 32, 1925, - /* 480 */ 1752, 40, 38, 36, 35, 34, 1259, 1357, 1257, 73, - /* 490 */ 304, 1650, 159, 519, 541, 1752, 1922, 33, 32, 348, - /* 500 */ 1284, 40, 38, 36, 35, 34, 316, 1649, 314, 313, - /* 510 */ 1362, 473, 616, 1262, 1263, 475, 1311, 1312, 1314, 1315, - /* 520 */ 1316, 1317, 1318, 576, 572, 1326, 1327, 1329, 1330, 1331, - /* 530 */ 1332, 1334, 1337, 39, 37, 1338, 438, 474, 1006, 1007, - /* 540 */ 1925, 338, 1280, 1258, 1782, 162, 1874, 1478, 1313, 1019, - /* 550 */ 306, 1018, 27, 159, 1333, 1427, 1256, 1922, 1589, 33, - /* 560 */ 32, 221, 222, 40, 38, 36, 35, 34, 1285, 1766, - /* 570 */ 1871, 552, 1800, 547, 542, 162, 1574, 1328, 1281, 1020, - /* 580 */ 556, 529, 529, 1355, 153, 1752, 1477, 580, 1752, 1264, - /* 590 */ 39, 37, 384, 385, 22, 1762, 1768, 1637, 338, 122, - /* 600 */ 1258, 1522, 1075, 11, 10, 140, 9, 574, 1650, 1598, - /* 610 */ 1598, 1333, 1813, 1256, 1601, 342, 90, 1783, 583, 1785, - /* 620 */ 1786, 579, 304, 574, 1648, 519, 1859, 1752, 662, 529, - /* 630 */ 329, 1855, 154, 252, 1328, 1077, 616, 1356, 1874, 120, - /* 640 */ 389, 1473, 1335, 1336, 158, 1343, 1264, 1694, 1688, 299, - /* 650 */ 517, 1282, 1885, 1264, 157, 1867, 1868, 1598, 1872, 172, - /* 660 */ 1361, 1696, 1870, 9, 639, 638, 637, 636, 346, 561, + /* 250 */ 1285, 1600, 552, 1889, 1395, 1263, 1264, 162, 1313, 1314, + /* 260 */ 1316, 1317, 1318, 1319, 1320, 576, 572, 1328, 1329, 1331, + /* 270 */ 1332, 1333, 1334, 1336, 1339, 39, 37, 1455, 1928, 1754, + /* 280 */ 122, 174, 173, 338, 220, 1259, 40, 38, 36, 35, + /* 290 */ 34, 159, 306, 61, 42, 1925, 1335, 1741, 1257, 1114, + /* 300 */ 605, 604, 603, 1118, 602, 1120, 1121, 601, 1123, 598, + /* 310 */ 1803, 1129, 595, 1131, 1132, 592, 589, 1298, 545, 1330, + /* 320 */ 120, 1785, 33, 32, 14, 1357, 40, 38, 36, 35, + /* 330 */ 34, 1265, 39, 37, 554, 155, 1870, 1871, 86, 1875, + /* 340 */ 338, 552, 1259, 1772, 359, 1652, 1239, 1240, 2, 1803, + /* 350 */ 341, 119, 326, 1335, 1768, 1257, 544, 581, 140, 1592, + /* 360 */ 344, 1650, 1754, 529, 580, 1402, 1454, 1602, 140, 122, + /* 370 */ 662, 1284, 1284, 379, 165, 378, 1330, 1602, 557, 1358, + /* 380 */ 1764, 1770, 333, 1578, 1337, 1338, 1462, 432, 1265, 1816, + /* 390 */ 436, 1600, 574, 89, 1786, 583, 1788, 1789, 579, 1483, + /* 400 */ 574, 440, 1363, 1862, 436, 8, 215, 305, 1858, 120, + /* 410 */ 112, 111, 110, 109, 108, 107, 106, 105, 104, 1928, + /* 420 */ 482, 481, 632, 630, 156, 1870, 1871, 662, 1875, 1260, + /* 430 */ 208, 1258, 159, 162, 162, 61, 1925, 75, 516, 1482, + /* 440 */ 1754, 1337, 1338, 450, 29, 336, 1352, 1353, 1354, 1355, + /* 450 */ 1356, 1360, 1361, 1362, 1481, 315, 1263, 1264, 546, 1313, + /* 460 */ 1314, 1316, 1317, 1318, 1319, 1320, 576, 572, 1328, 1329, + /* 470 */ 1331, 1332, 1333, 1334, 1336, 1339, 1394, 33, 32, 1928, + /* 480 */ 1754, 40, 38, 36, 35, 34, 1260, 1359, 1258, 73, + /* 490 */ 304, 1652, 159, 519, 541, 1754, 1925, 33, 32, 348, + /* 500 */ 1286, 40, 38, 36, 35, 34, 316, 1651, 314, 313, + /* 510 */ 1364, 473, 616, 1263, 1264, 475, 1313, 1314, 1316, 1317, + /* 520 */ 1318, 1319, 1320, 576, 572, 1328, 1329, 1331, 1332, 1333, + /* 530 */ 1334, 1336, 1339, 39, 37, 1340, 438, 474, 1007, 1008, + /* 540 */ 1928, 338, 1282, 1259, 1785, 162, 1877, 1480, 1315, 1020, + /* 550 */ 306, 1019, 27, 159, 1335, 1429, 1257, 1925, 1591, 33, + /* 560 */ 32, 221, 222, 40, 38, 36, 35, 34, 1287, 1768, + /* 570 */ 1874, 552, 1803, 547, 542, 162, 1576, 1330, 1283, 1021, + /* 580 */ 556, 529, 529, 1357, 153, 1754, 1479, 580, 1754, 1265, + /* 590 */ 39, 37, 384, 385, 22, 1764, 1770, 1639, 338, 122, + /* 600 */ 1259, 1524, 1076, 11, 10, 140, 9, 574, 1652, 1600, + /* 610 */ 1600, 1335, 1816, 1257, 1603, 342, 90, 1786, 583, 1788, + /* 620 */ 1789, 579, 304, 574, 1650, 519, 1862, 1754, 662, 529, + /* 630 */ 329, 1858, 154, 252, 1330, 1078, 616, 1358, 1877, 120, + /* 640 */ 389, 1557, 1337, 1338, 158, 1345, 1265, 1696, 1690, 299, + /* 650 */ 517, 1284, 1888, 1265, 157, 1870, 1871, 1600, 1875, 172, + /* 660 */ 1363, 1698, 1873, 9, 639, 638, 637, 636, 346, 1587, /* 670 */ 635, 634, 633, 123, 628, 627, 626, 625, 624, 623, - /* 680 */ 622, 621, 133, 617, 1525, 662, 1282, 1259, 1369, 1257, - /* 690 */ 33, 32, 1874, 1476, 40, 38, 36, 35, 34, 1335, - /* 700 */ 1336, 232, 29, 336, 1350, 1351, 1352, 1353, 1354, 1358, - /* 710 */ 1359, 1360, 7, 1475, 1262, 1263, 1869, 1311, 1312, 1314, - /* 720 */ 1315, 1316, 1317, 1318, 576, 572, 1326, 1327, 1329, 1330, - /* 730 */ 1331, 1332, 1334, 1337, 1752, 33, 32, 1879, 1389, 40, - /* 740 */ 38, 36, 35, 34, 1259, 608, 1257, 486, 485, 484, - /* 750 */ 44, 4, 1258, 483, 1752, 272, 118, 480, 1628, 619, - /* 760 */ 479, 478, 477, 1474, 1585, 1256, 1417, 1693, 1407, 299, - /* 770 */ 612, 1262, 1263, 1641, 1311, 1312, 1314, 1315, 1316, 1317, - /* 780 */ 1318, 576, 572, 1326, 1327, 1329, 1330, 1331, 1332, 1334, - /* 790 */ 1337, 39, 37, 301, 613, 1280, 614, 1641, 1264, 338, - /* 800 */ 1581, 1258, 412, 1782, 1752, 424, 211, 538, 1415, 1416, - /* 810 */ 1418, 1419, 1333, 1296, 1256, 131, 130, 611, 610, 609, - /* 820 */ 11, 10, 397, 1575, 425, 575, 399, 59, 1313, 529, - /* 830 */ 529, 1800, 529, 1471, 620, 1328, 1570, 662, 1573, 581, - /* 840 */ 404, 405, 26, 449, 1752, 509, 580, 1264, 33, 32, - /* 850 */ 1507, 1505, 40, 38, 36, 35, 34, 1598, 1598, 390, - /* 860 */ 1598, 33, 32, 1313, 2, 40, 38, 36, 35, 34, - /* 870 */ 562, 1813, 489, 492, 1752, 91, 1783, 583, 1785, 1786, - /* 880 */ 579, 28, 574, 607, 631, 1859, 662, 33, 32, 1858, - /* 890 */ 1855, 40, 38, 36, 35, 34, 1259, 1389, 1257, 423, - /* 900 */ 1335, 1336, 418, 417, 416, 415, 414, 411, 410, 409, + /* 680 */ 622, 621, 133, 617, 1527, 662, 1284, 1260, 1371, 1258, + /* 690 */ 33, 32, 1877, 1478, 40, 38, 36, 35, 34, 1337, + /* 700 */ 1338, 232, 29, 336, 1352, 1353, 1354, 1355, 1356, 1360, + /* 710 */ 1361, 1362, 7, 1477, 1263, 1264, 1872, 1313, 1314, 1316, + /* 720 */ 1317, 1318, 1319, 1320, 576, 572, 1328, 1329, 1331, 1332, + /* 730 */ 1333, 1334, 1336, 1339, 1754, 33, 32, 1882, 1391, 40, + /* 740 */ 38, 36, 35, 34, 1260, 561, 1258, 486, 485, 484, + /* 750 */ 44, 4, 1259, 483, 1754, 272, 118, 480, 1630, 608, + /* 760 */ 479, 478, 477, 1476, 619, 1257, 1419, 1695, 1409, 299, + /* 770 */ 612, 1263, 1264, 1643, 1313, 1314, 1316, 1317, 1318, 1319, + /* 780 */ 1320, 576, 572, 1328, 1329, 1331, 1332, 1333, 1334, 1336, + /* 790 */ 1339, 39, 37, 301, 613, 1282, 614, 1643, 1265, 338, + /* 800 */ 1583, 1259, 412, 1785, 1754, 424, 1268, 538, 1417, 1418, + /* 810 */ 1420, 1421, 1335, 1298, 1257, 131, 130, 611, 610, 609, + /* 820 */ 11, 10, 397, 529, 425, 211, 399, 631, 1315, 529, + /* 830 */ 529, 1803, 529, 1473, 404, 1330, 620, 662, 1572, 581, + /* 840 */ 405, 449, 26, 1597, 1754, 59, 580, 1265, 33, 32, + /* 850 */ 1509, 1600, 40, 38, 36, 35, 34, 1600, 1600, 390, + /* 860 */ 1600, 33, 32, 1315, 2, 40, 38, 36, 35, 34, + /* 870 */ 374, 1816, 489, 570, 1754, 91, 1786, 583, 1788, 1789, + /* 880 */ 579, 28, 574, 1457, 1458, 1862, 662, 33, 32, 1861, + /* 890 */ 1858, 40, 38, 36, 35, 34, 1260, 1391, 1258, 423, + /* 900 */ 1337, 1338, 418, 417, 416, 415, 414, 411, 410, 409, /* 910 */ 408, 407, 403, 402, 401, 400, 394, 393, 392, 391, - /* 920 */ 614, 388, 387, 1262, 1263, 529, 1470, 374, 199, 141, - /* 930 */ 1555, 197, 564, 529, 278, 614, 1595, 52, 513, 131, - /* 940 */ 130, 611, 610, 609, 1727, 1259, 255, 1257, 276, 58, - /* 950 */ 41, 219, 57, 1598, 131, 130, 611, 610, 609, 1267, - /* 960 */ 1770, 1598, 502, 1469, 1782, 1455, 1456, 1752, 177, 429, - /* 970 */ 427, 1766, 1262, 1263, 1468, 1311, 1312, 1314, 1315, 1316, - /* 980 */ 1317, 1318, 576, 572, 1326, 1327, 1329, 1330, 1331, 1332, - /* 990 */ 1334, 1337, 1800, 1206, 223, 539, 61, 1762, 1768, 529, - /* 1000 */ 581, 468, 529, 1925, 1752, 1752, 139, 580, 1467, 574, - /* 1010 */ 510, 1266, 1466, 514, 529, 1752, 159, 1772, 201, 1465, - /* 1020 */ 1922, 200, 1464, 203, 1463, 527, 202, 1598, 570, 503, - /* 1030 */ 1598, 1801, 1813, 244, 88, 125, 90, 1783, 583, 1785, - /* 1040 */ 1786, 579, 1598, 574, 529, 1782, 1859, 529, 529, 1752, - /* 1050 */ 329, 1855, 1938, 1752, 205, 528, 1774, 204, 261, 345, - /* 1060 */ 1752, 1893, 552, 1752, 1046, 1752, 559, 128, 1501, 66, - /* 1070 */ 65, 383, 1598, 1800, 169, 1598, 1598, 347, 522, 85, - /* 1080 */ 377, 581, 129, 50, 335, 334, 1752, 1496, 580, 82, - /* 1090 */ 122, 236, 1270, 300, 1272, 1638, 367, 1047, 365, 361, - /* 1100 */ 357, 166, 352, 349, 249, 1333, 1889, 1265, 254, 553, - /* 1110 */ 229, 557, 257, 1813, 50, 3, 657, 90, 1783, 583, - /* 1120 */ 1785, 1786, 579, 1782, 574, 1106, 1414, 1859, 1328, 41, - /* 1130 */ 120, 329, 1855, 1938, 239, 565, 162, 41, 491, 259, - /* 1140 */ 1264, 80, 1916, 587, 1269, 250, 1867, 551, 53, 550, - /* 1150 */ 5, 1800, 1925, 501, 351, 1280, 354, 1363, 128, 581, - /* 1160 */ 1347, 358, 1222, 129, 1752, 159, 580, 207, 311, 1922, - /* 1170 */ 114, 128, 1319, 1075, 312, 406, 1782, 268, 1690, 569, - /* 1180 */ 271, 494, 171, 413, 421, 488, 1134, 420, 422, 1286, - /* 1190 */ 206, 1813, 426, 428, 430, 90, 1783, 583, 1785, 1786, - /* 1200 */ 579, 1138, 574, 431, 1800, 1859, 1145, 439, 1289, 329, - /* 1210 */ 1855, 1938, 581, 1143, 132, 442, 180, 1752, 56, 580, - /* 1220 */ 1878, 55, 443, 182, 1288, 1290, 445, 444, 1782, 185, - /* 1230 */ 447, 187, 1287, 557, 189, 451, 70, 448, 1273, 470, - /* 1240 */ 1268, 472, 192, 1588, 1813, 303, 196, 1732, 285, 1783, - /* 1250 */ 583, 1785, 1786, 579, 1584, 574, 1800, 93, 269, 198, - /* 1260 */ 134, 135, 504, 1586, 581, 1276, 1582, 136, 137, 1752, - /* 1270 */ 209, 580, 505, 212, 1925, 511, 572, 1326, 1327, 1329, - /* 1280 */ 1330, 1331, 1332, 515, 508, 557, 216, 161, 518, 537, - /* 1290 */ 227, 1922, 321, 1782, 126, 1731, 1813, 127, 1700, 520, - /* 1300 */ 285, 1783, 583, 1785, 1786, 579, 323, 574, 523, 1782, - /* 1310 */ 225, 524, 270, 525, 78, 1599, 1285, 1890, 533, 535, - /* 1320 */ 540, 1800, 234, 238, 1900, 536, 1925, 328, 6, 581, - /* 1330 */ 543, 549, 534, 532, 1752, 531, 580, 1800, 248, 159, - /* 1340 */ 1389, 121, 1284, 1922, 566, 578, 563, 48, 1899, 330, - /* 1350 */ 1752, 1875, 580, 1840, 585, 1881, 245, 243, 1642, 148, - /* 1360 */ 247, 1813, 273, 264, 1782, 91, 1783, 583, 1785, 1786, - /* 1370 */ 579, 246, 574, 1571, 658, 1859, 1782, 1813, 659, 568, - /* 1380 */ 1855, 293, 1783, 583, 1785, 1786, 579, 577, 574, 571, - /* 1390 */ 1831, 661, 1800, 51, 147, 275, 1746, 1921, 253, 286, - /* 1400 */ 581, 296, 295, 277, 1800, 1752, 560, 580, 256, 1941, - /* 1410 */ 567, 63, 581, 258, 1745, 1744, 64, 1752, 1743, 580, - /* 1420 */ 353, 1740, 355, 356, 1250, 1251, 167, 360, 1738, 362, - /* 1430 */ 363, 364, 1813, 1737, 366, 1736, 144, 1783, 583, 1785, - /* 1440 */ 1786, 579, 368, 574, 1813, 1735, 370, 1734, 91, 1783, - /* 1450 */ 583, 1785, 1786, 579, 1782, 574, 1717, 372, 1859, 375, - /* 1460 */ 168, 376, 1225, 1856, 1224, 1711, 1710, 381, 1782, 382, - /* 1470 */ 1709, 1708, 1194, 1683, 1682, 1681, 67, 1680, 1782, 1679, - /* 1480 */ 558, 1939, 1800, 1678, 1677, 1676, 395, 322, 396, 1675, - /* 1490 */ 581, 398, 1674, 1673, 1672, 1752, 1800, 580, 1671, 1670, - /* 1500 */ 1669, 530, 1668, 1667, 581, 1666, 1800, 1665, 1664, 1752, - /* 1510 */ 1663, 580, 1662, 1661, 581, 1660, 1659, 1658, 124, 1752, - /* 1520 */ 1657, 580, 1813, 1656, 1655, 1654, 294, 1783, 583, 1785, - /* 1530 */ 1786, 579, 1653, 574, 1652, 1782, 1813, 1651, 1527, 1526, - /* 1540 */ 294, 1783, 583, 1785, 1786, 579, 1813, 574, 1524, 1196, - /* 1550 */ 289, 1783, 583, 1785, 1786, 579, 1492, 574, 1491, 1782, - /* 1560 */ 175, 178, 176, 1800, 152, 115, 1009, 1008, 435, 179, - /* 1570 */ 116, 581, 1725, 1719, 437, 1707, 1752, 186, 580, 184, - /* 1580 */ 1706, 1692, 1577, 1523, 1521, 1782, 452, 1800, 548, 453, - /* 1590 */ 1519, 1517, 1039, 454, 456, 578, 457, 460, 1515, 458, - /* 1600 */ 1752, 1504, 580, 1813, 461, 462, 464, 144, 1783, 583, - /* 1610 */ 1785, 1786, 579, 1800, 574, 465, 466, 1503, 337, 1488, - /* 1620 */ 1579, 581, 1149, 1578, 1148, 195, 1752, 1813, 580, 49, - /* 1630 */ 1074, 293, 1783, 583, 1785, 1786, 579, 629, 574, 1782, - /* 1640 */ 1832, 1073, 1072, 631, 1071, 1068, 1067, 1066, 1065, 1513, - /* 1650 */ 317, 1508, 1940, 1813, 318, 665, 1506, 294, 1783, 583, - /* 1660 */ 1785, 1786, 579, 490, 574, 319, 493, 1800, 1487, 267, - /* 1670 */ 495, 1486, 339, 497, 1485, 581, 499, 92, 1724, 1232, - /* 1680 */ 1752, 1718, 580, 151, 506, 1705, 138, 1703, 655, 651, - /* 1690 */ 647, 643, 265, 1704, 54, 213, 507, 1702, 1701, 320, - /* 1700 */ 15, 1699, 512, 1691, 218, 226, 224, 1813, 41, 76, - /* 1710 */ 77, 294, 1783, 583, 1785, 1786, 579, 194, 574, 231, - /* 1720 */ 87, 521, 1782, 230, 82, 228, 16, 23, 242, 47, - /* 1730 */ 233, 146, 1429, 235, 1411, 237, 467, 463, 459, 455, - /* 1740 */ 193, 1413, 1242, 145, 240, 24, 1782, 1406, 241, 81, - /* 1750 */ 1800, 10, 1772, 25, 1441, 1386, 526, 251, 581, 45, - /* 1760 */ 46, 1385, 1771, 1752, 149, 580, 1446, 18, 72, 1435, - /* 1770 */ 1440, 191, 331, 1445, 1800, 1444, 332, 1274, 1348, 17, - /* 1780 */ 1816, 573, 581, 1304, 13, 19, 1323, 1752, 217, 580, - /* 1790 */ 1813, 150, 163, 1321, 279, 1783, 583, 1785, 1786, 579, - /* 1800 */ 31, 574, 1782, 586, 1112, 584, 1320, 12, 20, 1230, - /* 1810 */ 21, 210, 1135, 340, 1813, 588, 590, 582, 280, 1783, - /* 1820 */ 583, 1785, 1786, 579, 591, 574, 593, 596, 599, 1132, - /* 1830 */ 1800, 606, 594, 190, 183, 597, 188, 1129, 581, 1123, - /* 1840 */ 446, 1127, 1121, 1752, 1782, 580, 1144, 600, 83, 84, - /* 1850 */ 60, 262, 1140, 1126, 1782, 1062, 1037, 1125, 615, 181, - /* 1860 */ 618, 1124, 263, 1081, 1060, 1055, 1782, 1059, 1058, 1057, - /* 1870 */ 1813, 1056, 1800, 1054, 281, 1783, 583, 1785, 1786, 579, - /* 1880 */ 581, 574, 1800, 1053, 1078, 1752, 1076, 580, 1050, 1049, - /* 1890 */ 581, 1048, 1045, 1044, 1800, 1752, 1043, 580, 1042, 1520, - /* 1900 */ 640, 642, 581, 1518, 644, 646, 641, 1752, 1516, 580, - /* 1910 */ 648, 645, 1813, 650, 649, 1514, 288, 1783, 583, 1785, - /* 1920 */ 1786, 579, 1813, 574, 652, 653, 290, 1783, 583, 1785, - /* 1930 */ 1786, 579, 654, 574, 1813, 656, 999, 1484, 282, 1783, - /* 1940 */ 583, 1785, 1786, 579, 1502, 574, 266, 1782, 660, 1459, - /* 1950 */ 1260, 274, 663, 664, 1459, 1459, 1459, 1459, 1459, 1459, - /* 1960 */ 1459, 1459, 1459, 1459, 1459, 1459, 1782, 1459, 1459, 1459, - /* 1970 */ 1459, 1459, 1459, 1459, 1459, 1800, 1459, 1459, 1459, 1459, - /* 1980 */ 1459, 1459, 1459, 581, 1459, 1459, 1459, 1459, 1752, 1459, - /* 1990 */ 580, 1459, 1459, 1459, 1800, 1459, 1459, 1459, 1459, 1459, - /* 2000 */ 1459, 1459, 581, 1459, 1459, 1459, 1459, 1752, 1459, 580, - /* 2010 */ 1459, 1459, 1459, 1459, 1459, 1813, 1459, 1459, 1459, 291, - /* 2020 */ 1783, 583, 1785, 1786, 579, 1459, 574, 1782, 1459, 1459, - /* 2030 */ 1459, 1459, 1459, 1459, 1813, 1459, 1459, 1459, 283, 1783, - /* 2040 */ 583, 1785, 1786, 579, 1459, 574, 1782, 1459, 1459, 1459, - /* 2050 */ 1459, 1459, 1459, 1459, 1459, 1800, 1459, 1459, 1459, 1459, - /* 2060 */ 1459, 1459, 1459, 581, 1459, 1459, 1459, 1459, 1752, 1459, - /* 2070 */ 580, 1459, 1459, 1459, 1800, 1459, 1459, 1459, 1459, 1459, - /* 2080 */ 1459, 1459, 581, 1459, 1459, 1459, 1459, 1752, 1459, 580, - /* 2090 */ 1459, 1459, 1459, 1459, 1459, 1813, 1459, 1459, 1459, 292, - /* 2100 */ 1783, 583, 1785, 1786, 579, 1459, 574, 1459, 1459, 1459, - /* 2110 */ 1459, 1459, 1459, 1782, 1813, 1459, 1459, 1459, 284, 1783, - /* 2120 */ 583, 1785, 1786, 579, 1459, 574, 1459, 1459, 1459, 1782, - /* 2130 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1782, - /* 2140 */ 1459, 1800, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 581, - /* 2150 */ 1459, 1459, 1459, 1459, 1752, 1459, 580, 1800, 1459, 1459, - /* 2160 */ 1459, 1459, 1459, 1459, 1459, 581, 1459, 1800, 1459, 1459, - /* 2170 */ 1752, 1459, 580, 1459, 1459, 581, 1459, 1459, 1459, 1459, - /* 2180 */ 1752, 1813, 580, 1459, 1459, 297, 1783, 583, 1785, 1786, - /* 2190 */ 579, 1459, 574, 1782, 1459, 1459, 1459, 1813, 1459, 1459, - /* 2200 */ 1459, 298, 1783, 583, 1785, 1786, 579, 1813, 574, 1459, - /* 2210 */ 1459, 1794, 1783, 583, 1785, 1786, 579, 1459, 574, 1459, - /* 2220 */ 1459, 1800, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 581, - /* 2230 */ 1459, 1459, 1459, 1459, 1752, 1459, 580, 1459, 1459, 1459, - /* 2240 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1782, 1459, 1459, - /* 2250 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, - /* 2260 */ 1459, 1813, 1459, 1459, 1459, 1793, 1783, 583, 1785, 1786, - /* 2270 */ 579, 1459, 574, 1459, 1459, 1800, 1459, 1459, 1459, 1459, - /* 2280 */ 1459, 1459, 1459, 581, 1459, 1459, 1459, 1459, 1752, 1459, - /* 2290 */ 580, 1459, 1459, 1459, 1459, 1459, 1459, 1782, 1459, 1459, - /* 2300 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, - /* 2310 */ 1459, 1459, 1459, 1459, 1782, 1813, 1459, 1459, 1459, 1792, - /* 2320 */ 1783, 583, 1785, 1786, 579, 1800, 574, 1459, 1459, 1459, - /* 2330 */ 1459, 1459, 1459, 581, 1459, 1459, 1459, 1459, 1752, 1459, - /* 2340 */ 580, 1459, 1800, 1459, 1459, 1459, 1459, 1459, 1459, 1459, - /* 2350 */ 581, 1459, 1459, 1459, 1459, 1752, 1459, 580, 1459, 1459, - /* 2360 */ 1459, 1459, 1459, 1459, 1459, 1813, 1459, 1459, 1459, 309, - /* 2370 */ 1783, 583, 1785, 1786, 579, 1459, 574, 1782, 1459, 1459, - /* 2380 */ 1459, 1459, 1813, 1459, 1459, 1459, 308, 1783, 583, 1785, - /* 2390 */ 1786, 579, 1459, 574, 1459, 1459, 1459, 1459, 1782, 1459, - /* 2400 */ 1459, 1459, 1459, 1459, 1459, 1800, 1459, 1459, 1459, 1459, - /* 2410 */ 1459, 1459, 1459, 581, 1459, 1459, 1459, 1459, 1752, 1459, - /* 2420 */ 580, 1459, 1459, 1459, 1459, 1459, 1800, 1459, 1459, 1459, - /* 2430 */ 1459, 1459, 1459, 1459, 581, 1459, 1459, 1459, 1459, 1752, - /* 2440 */ 1782, 580, 1459, 1459, 1459, 1813, 1459, 1459, 1459, 310, - /* 2450 */ 1783, 583, 1785, 1786, 579, 1459, 574, 1459, 1459, 1459, - /* 2460 */ 1459, 1459, 1459, 1459, 1459, 1459, 1813, 1459, 1800, 1459, - /* 2470 */ 307, 1783, 583, 1785, 1786, 579, 581, 574, 1459, 1459, - /* 2480 */ 1459, 1752, 1459, 580, 1459, 1459, 1459, 1459, 1459, 1459, - /* 2490 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, - /* 2500 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1813, 1459, - /* 2510 */ 1459, 1459, 287, 1783, 583, 1785, 1786, 579, 1459, 574, + /* 920 */ 575, 388, 387, 1263, 1264, 529, 564, 529, 1507, 141, + /* 930 */ 1472, 529, 199, 529, 278, 197, 1729, 201, 510, 1271, + /* 940 */ 200, 1047, 514, 194, 527, 1260, 562, 1258, 276, 58, + /* 950 */ 492, 203, 57, 1600, 202, 1600, 607, 146, 502, 1600, + /* 960 */ 509, 1600, 467, 463, 459, 455, 193, 1785, 177, 429, + /* 970 */ 427, 1754, 1263, 1264, 1048, 1313, 1314, 1316, 1317, 1318, + /* 980 */ 1319, 1320, 576, 572, 1328, 1329, 1331, 1332, 1333, 1334, + /* 990 */ 1336, 1339, 335, 334, 72, 1803, 61, 191, 529, 1928, + /* 1000 */ 529, 205, 1273, 581, 204, 1349, 139, 1475, 1754, 528, + /* 1010 */ 580, 261, 159, 1335, 1773, 1266, 1925, 52, 513, 529, + /* 1020 */ 255, 539, 85, 468, 1471, 1768, 1600, 1470, 1600, 1267, + /* 1030 */ 345, 1469, 82, 41, 88, 1816, 1330, 1577, 1468, 90, + /* 1040 */ 1786, 583, 1788, 1789, 579, 1785, 574, 1600, 1265, 1862, + /* 1050 */ 1467, 1764, 1770, 329, 1858, 1941, 1503, 503, 244, 190, + /* 1060 */ 183, 1575, 188, 574, 1896, 1754, 446, 1466, 1754, 66, + /* 1070 */ 65, 383, 1754, 1803, 169, 1465, 1207, 1804, 347, 1754, + /* 1080 */ 377, 581, 219, 125, 559, 181, 1754, 569, 580, 1775, + /* 1090 */ 1498, 1754, 1640, 300, 128, 129, 367, 50, 365, 361, + /* 1100 */ 357, 166, 352, 349, 657, 1892, 236, 50, 1754, 41, + /* 1110 */ 249, 553, 254, 1816, 257, 259, 1754, 90, 1786, 583, + /* 1120 */ 1788, 1789, 579, 1785, 574, 223, 522, 1862, 1777, 565, + /* 1130 */ 80, 329, 1858, 1941, 614, 3, 162, 229, 1107, 41, + /* 1140 */ 1416, 53, 1919, 5, 351, 1282, 1274, 354, 1269, 239, + /* 1150 */ 1365, 1803, 1321, 131, 130, 611, 610, 609, 614, 581, + /* 1160 */ 587, 128, 1270, 358, 1754, 1785, 580, 311, 1076, 129, + /* 1170 */ 114, 128, 312, 1277, 1279, 1223, 268, 131, 130, 611, + /* 1180 */ 610, 609, 271, 406, 572, 1328, 1329, 1331, 1332, 1333, + /* 1190 */ 1334, 1816, 1692, 1803, 171, 90, 1786, 583, 1788, 1789, + /* 1200 */ 579, 581, 574, 1135, 1139, 1862, 1754, 413, 580, 329, + /* 1210 */ 1858, 1941, 1146, 1144, 132, 421, 426, 420, 422, 428, + /* 1220 */ 1881, 430, 557, 1288, 431, 439, 1785, 180, 1291, 442, + /* 1230 */ 443, 182, 1290, 1816, 444, 1292, 1785, 285, 1786, 583, + /* 1240 */ 1788, 1789, 579, 445, 574, 491, 185, 447, 1289, 187, + /* 1250 */ 448, 189, 70, 451, 1803, 192, 470, 472, 1590, 196, + /* 1260 */ 501, 1586, 581, 1928, 1803, 303, 1734, 1754, 93, 580, + /* 1270 */ 198, 209, 581, 269, 207, 134, 161, 1754, 135, 580, + /* 1280 */ 1925, 1588, 504, 557, 1584, 136, 137, 508, 494, 505, + /* 1290 */ 212, 511, 488, 1785, 1816, 515, 216, 206, 285, 1786, + /* 1300 */ 583, 1788, 1789, 579, 1816, 574, 537, 1785, 91, 1786, + /* 1310 */ 583, 1788, 1789, 579, 126, 574, 518, 1733, 1862, 1702, + /* 1320 */ 321, 1803, 568, 1858, 1928, 56, 520, 523, 55, 578, + /* 1330 */ 323, 127, 524, 525, 1754, 1803, 580, 159, 225, 227, + /* 1340 */ 270, 1925, 1601, 581, 78, 1287, 533, 540, 1754, 535, + /* 1350 */ 580, 234, 1893, 1903, 536, 1902, 238, 1785, 328, 543, + /* 1360 */ 6, 1816, 1884, 549, 534, 293, 1786, 583, 1788, 1789, + /* 1370 */ 579, 577, 574, 571, 1834, 1816, 243, 1785, 148, 144, + /* 1380 */ 1786, 583, 1788, 1789, 579, 1803, 574, 532, 531, 248, + /* 1390 */ 1391, 245, 246, 581, 121, 247, 1286, 1878, 1754, 566, + /* 1400 */ 580, 563, 48, 330, 253, 1803, 1924, 1573, 1644, 273, + /* 1410 */ 322, 658, 585, 581, 560, 1944, 1843, 264, 1754, 661, + /* 1420 */ 580, 51, 659, 558, 1942, 1816, 147, 277, 256, 91, + /* 1430 */ 1786, 583, 1788, 1789, 579, 1748, 574, 286, 275, 1862, + /* 1440 */ 567, 258, 296, 1785, 1859, 1816, 63, 295, 1747, 294, + /* 1450 */ 1786, 583, 1788, 1789, 579, 1785, 574, 1746, 64, 1745, + /* 1460 */ 353, 1742, 355, 1251, 356, 1785, 1252, 167, 360, 1740, + /* 1470 */ 364, 1803, 362, 363, 1739, 366, 530, 1738, 368, 581, + /* 1480 */ 1737, 1736, 370, 1803, 1754, 1719, 580, 372, 168, 375, + /* 1490 */ 376, 581, 1226, 1803, 1225, 1713, 1754, 1712, 580, 381, + /* 1500 */ 382, 581, 1711, 1710, 1195, 1685, 1754, 1684, 580, 1683, + /* 1510 */ 67, 1816, 1682, 1681, 1680, 294, 1786, 583, 1788, 1789, + /* 1520 */ 579, 1785, 574, 1816, 1679, 1678, 396, 289, 1786, 583, + /* 1530 */ 1788, 1789, 579, 1816, 574, 1785, 395, 144, 1786, 583, + /* 1540 */ 1788, 1789, 579, 1677, 574, 398, 1676, 1675, 1674, 1803, + /* 1550 */ 124, 1662, 1661, 1660, 1659, 1658, 1657, 578, 1673, 1672, + /* 1560 */ 1671, 1670, 1754, 1803, 580, 548, 1669, 1668, 337, 1667, + /* 1570 */ 1666, 581, 1665, 1664, 1663, 1656, 1754, 1655, 580, 1197, + /* 1580 */ 1654, 1653, 1943, 1529, 175, 1528, 176, 1526, 1785, 1816, + /* 1590 */ 1494, 178, 1010, 293, 1786, 583, 1788, 1789, 579, 1493, + /* 1600 */ 574, 115, 1835, 1816, 179, 1009, 152, 294, 1786, 583, + /* 1610 */ 1788, 1789, 579, 665, 574, 453, 1803, 435, 116, 1727, + /* 1620 */ 1721, 339, 437, 1709, 581, 184, 1708, 267, 186, 1754, + /* 1630 */ 1785, 580, 1694, 1579, 1525, 1523, 452, 454, 1521, 456, + /* 1640 */ 457, 151, 1519, 460, 1785, 458, 655, 651, 647, 643, + /* 1650 */ 265, 1040, 461, 462, 1517, 466, 1816, 464, 1803, 465, + /* 1660 */ 294, 1786, 583, 1788, 1789, 579, 581, 574, 1506, 1505, + /* 1670 */ 1490, 1754, 1803, 580, 1581, 1150, 49, 1149, 87, 1580, + /* 1680 */ 581, 230, 1075, 1074, 195, 1754, 1073, 580, 1072, 629, + /* 1690 */ 1515, 1069, 631, 1068, 1067, 1066, 1510, 317, 1816, 318, + /* 1700 */ 1508, 490, 279, 1786, 583, 1788, 1789, 579, 1785, 574, + /* 1710 */ 319, 493, 1816, 1489, 526, 495, 280, 1786, 583, 1788, + /* 1720 */ 1789, 579, 1488, 574, 497, 1487, 499, 92, 1726, 1233, + /* 1730 */ 1785, 1720, 506, 1707, 1705, 1706, 1803, 54, 1704, 1703, + /* 1740 */ 1701, 1693, 226, 231, 581, 82, 217, 213, 507, 1754, + /* 1750 */ 1785, 580, 218, 320, 41, 16, 15, 512, 1803, 1431, + /* 1760 */ 138, 521, 228, 224, 47, 242, 581, 1231, 76, 210, + /* 1770 */ 77, 1754, 23, 580, 17, 241, 1816, 1243, 1803, 235, + /* 1780 */ 281, 1786, 583, 1788, 1789, 579, 581, 574, 1413, 1775, + /* 1790 */ 233, 1754, 1785, 580, 237, 25, 251, 145, 1816, 46, + /* 1800 */ 1415, 240, 288, 1786, 583, 1788, 1789, 579, 1785, 574, + /* 1810 */ 1408, 24, 81, 1774, 149, 1388, 1387, 18, 1816, 1443, + /* 1820 */ 1803, 1442, 290, 1786, 583, 1788, 1789, 579, 581, 574, + /* 1830 */ 45, 1448, 1437, 1754, 331, 580, 1803, 1447, 13, 1446, + /* 1840 */ 332, 10, 1275, 19, 581, 1819, 1306, 1325, 573, 1754, + /* 1850 */ 1323, 580, 1322, 150, 1350, 31, 12, 20, 163, 582, + /* 1860 */ 1816, 1785, 21, 586, 282, 1786, 583, 1788, 1789, 579, + /* 1870 */ 340, 574, 584, 1785, 1136, 588, 1816, 1133, 590, 591, + /* 1880 */ 291, 1786, 583, 1788, 1789, 579, 593, 574, 594, 1803, + /* 1890 */ 596, 599, 1130, 1113, 1124, 597, 600, 581, 1128, 1122, + /* 1900 */ 83, 1803, 1754, 84, 580, 1127, 1126, 1125, 1145, 581, + /* 1910 */ 262, 606, 60, 1141, 1754, 1785, 580, 1063, 1082, 1038, + /* 1920 */ 615, 618, 263, 1061, 1060, 1785, 1056, 1059, 1058, 1816, + /* 1930 */ 1057, 1055, 1054, 283, 1786, 583, 1788, 1789, 579, 1785, + /* 1940 */ 574, 1816, 1079, 1803, 1077, 292, 1786, 583, 1788, 1789, + /* 1950 */ 579, 581, 574, 1803, 1051, 1050, 1754, 1049, 580, 1046, + /* 1960 */ 1045, 581, 1044, 1043, 1522, 640, 1754, 1803, 580, 1520, + /* 1970 */ 641, 642, 644, 645, 646, 581, 1518, 648, 649, 1516, + /* 1980 */ 1754, 652, 580, 1816, 650, 653, 654, 284, 1786, 583, + /* 1990 */ 1788, 1789, 579, 1816, 574, 1785, 1504, 297, 1786, 583, + /* 2000 */ 1788, 1789, 579, 656, 574, 1785, 1000, 1816, 1486, 266, + /* 2010 */ 660, 298, 1786, 583, 1788, 1789, 579, 1785, 574, 1261, + /* 2020 */ 274, 663, 664, 1803, 1461, 1461, 1461, 1461, 1461, 1461, + /* 2030 */ 1461, 581, 1461, 1803, 1461, 1461, 1754, 1461, 580, 1461, + /* 2040 */ 1461, 581, 1461, 1461, 1461, 1803, 1754, 1461, 580, 1461, + /* 2050 */ 1461, 1461, 1461, 581, 1461, 1461, 1461, 1461, 1754, 1461, + /* 2060 */ 580, 1461, 1461, 1816, 1461, 1461, 1461, 1797, 1786, 583, + /* 2070 */ 1788, 1789, 579, 1816, 574, 1461, 1461, 1796, 1786, 583, + /* 2080 */ 1788, 1789, 579, 1785, 574, 1816, 1461, 1461, 1461, 1795, + /* 2090 */ 1786, 583, 1788, 1789, 579, 1785, 574, 1461, 1461, 1461, + /* 2100 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, + /* 2110 */ 1461, 1803, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 581, + /* 2120 */ 1461, 1461, 1461, 1803, 1754, 1461, 580, 1461, 1461, 1461, + /* 2130 */ 1461, 581, 1461, 1461, 1461, 1461, 1754, 1461, 580, 1461, + /* 2140 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1785, 1461, + /* 2150 */ 1461, 1816, 1461, 1461, 1461, 309, 1786, 583, 1788, 1789, + /* 2160 */ 579, 1461, 574, 1816, 1461, 1461, 1461, 308, 1786, 583, + /* 2170 */ 1788, 1789, 579, 1461, 574, 1461, 1803, 1461, 1461, 1461, + /* 2180 */ 1461, 1461, 1461, 1461, 581, 1461, 1461, 1461, 1461, 1754, + /* 2190 */ 1461, 580, 1461, 1461, 1461, 1461, 1461, 1461, 1785, 1461, + /* 2200 */ 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1785, 1461, + /* 2210 */ 552, 1461, 1461, 1461, 1461, 1461, 1816, 1461, 1461, 1461, + /* 2220 */ 310, 1786, 583, 1788, 1789, 579, 1803, 574, 1461, 1461, + /* 2230 */ 1461, 1461, 1461, 1461, 581, 1461, 1803, 1461, 122, 1754, + /* 2240 */ 1461, 580, 1461, 1461, 581, 1461, 1461, 1461, 1461, 1754, + /* 2250 */ 1461, 580, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 557, + /* 2260 */ 1461, 1461, 1461, 1461, 1461, 1461, 1816, 1461, 1461, 1461, + /* 2270 */ 307, 1786, 583, 1788, 1789, 579, 1816, 574, 120, 1461, + /* 2280 */ 287, 1786, 583, 1788, 1789, 579, 1461, 574, 1461, 1461, + /* 2290 */ 1461, 1461, 1461, 250, 1870, 551, 1461, 550, 1461, 1461, + /* 2300 */ 1928, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, 1461, + /* 2310 */ 1461, 1461, 1461, 159, 1461, 1461, 1461, 1925, }; static const YYCODETYPE yy_lookahead[] = { /* 0 */ 266, 0, 262, 266, 264, 265, 262, 287, 264, 265, @@ -536,9 +516,9 @@ static const YYCODETYPE yy_lookahead[] = { /* 610 */ 294, 33, 326, 35, 295, 293, 330, 331, 332, 333, /* 620 */ 334, 335, 177, 337, 302, 180, 340, 299, 107, 266, /* 630 */ 344, 345, 346, 153, 56, 68, 60, 148, 328, 334, - /* 640 */ 277, 259, 121, 122, 358, 14, 68, 311, 294, 313, + /* 640 */ 277, 275, 121, 122, 358, 14, 68, 311, 294, 313, /* 650 */ 301, 20, 366, 68, 349, 350, 351, 294, 353, 305, - /* 660 */ 171, 312, 352, 85, 63, 64, 65, 66, 67, 43, + /* 660 */ 171, 312, 352, 85, 63, 64, 65, 66, 67, 287, /* 670 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, /* 680 */ 79, 80, 81, 82, 0, 107, 20, 166, 86, 168, /* 690 */ 8, 9, 328, 258, 12, 13, 14, 15, 16, 121, @@ -546,195 +526,175 @@ static const YYCODETYPE yy_lookahead[] = { /* 710 */ 221, 222, 39, 258, 193, 194, 352, 196, 197, 198, /* 720 */ 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, /* 730 */ 209, 210, 211, 212, 299, 8, 9, 223, 224, 12, - /* 740 */ 13, 14, 15, 16, 166, 96, 168, 63, 64, 65, - /* 750 */ 42, 43, 22, 69, 299, 279, 72, 73, 282, 68, - /* 760 */ 76, 77, 78, 258, 287, 35, 193, 311, 86, 313, + /* 740 */ 13, 14, 15, 16, 166, 43, 168, 63, 64, 65, + /* 750 */ 42, 43, 22, 69, 299, 279, 72, 73, 282, 96, + /* 760 */ 76, 77, 78, 258, 68, 35, 193, 311, 86, 313, /* 770 */ 296, 193, 194, 299, 196, 197, 198, 199, 200, 201, /* 780 */ 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, /* 790 */ 212, 12, 13, 18, 296, 20, 97, 299, 68, 20, - /* 800 */ 287, 22, 27, 258, 299, 30, 287, 234, 235, 236, + /* 800 */ 287, 22, 27, 258, 299, 30, 35, 234, 235, 236, /* 810 */ 237, 238, 33, 86, 35, 116, 117, 118, 119, 120, - /* 820 */ 1, 2, 47, 0, 49, 287, 51, 3, 197, 266, - /* 830 */ 266, 286, 266, 258, 274, 56, 276, 107, 0, 294, - /* 840 */ 277, 277, 2, 277, 299, 319, 301, 68, 8, 9, - /* 850 */ 0, 0, 12, 13, 14, 15, 16, 294, 294, 84, + /* 820 */ 1, 2, 47, 266, 49, 287, 51, 43, 197, 266, + /* 830 */ 266, 286, 266, 258, 277, 56, 274, 107, 276, 294, + /* 840 */ 277, 277, 2, 277, 299, 3, 301, 68, 8, 9, + /* 850 */ 0, 294, 12, 13, 14, 15, 16, 294, 294, 84, /* 860 */ 294, 8, 9, 197, 85, 12, 13, 14, 15, 16, - /* 870 */ 244, 326, 22, 22, 299, 330, 331, 332, 333, 334, - /* 880 */ 335, 2, 337, 287, 43, 340, 107, 8, 9, 344, + /* 870 */ 86, 326, 22, 61, 299, 330, 331, 332, 333, 334, + /* 880 */ 335, 2, 337, 121, 122, 340, 107, 8, 9, 344, /* 890 */ 345, 12, 13, 14, 15, 16, 166, 224, 168, 124, /* 900 */ 121, 122, 127, 128, 129, 130, 131, 132, 133, 134, /* 910 */ 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - /* 920 */ 97, 146, 147, 193, 194, 266, 258, 86, 89, 18, - /* 930 */ 275, 92, 43, 266, 23, 97, 277, 153, 154, 116, - /* 940 */ 117, 118, 119, 120, 277, 166, 376, 168, 37, 38, - /* 950 */ 43, 43, 41, 294, 116, 117, 118, 119, 120, 35, - /* 960 */ 288, 294, 315, 258, 258, 121, 122, 299, 57, 58, - /* 970 */ 59, 299, 193, 194, 258, 196, 197, 198, 199, 200, + /* 920 */ 287, 146, 147, 193, 194, 266, 43, 266, 0, 18, + /* 930 */ 258, 266, 89, 266, 23, 92, 277, 89, 277, 168, + /* 940 */ 92, 35, 277, 33, 277, 166, 244, 168, 37, 38, + /* 950 */ 22, 89, 41, 294, 92, 294, 287, 47, 315, 294, + /* 960 */ 319, 294, 52, 53, 54, 55, 56, 258, 57, 58, + /* 970 */ 59, 299, 193, 194, 68, 196, 197, 198, 199, 200, /* 980 */ 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, - /* 990 */ 211, 212, 286, 86, 86, 367, 85, 325, 326, 266, - /* 1000 */ 294, 267, 266, 356, 299, 299, 153, 301, 258, 337, - /* 1010 */ 277, 35, 258, 277, 266, 299, 369, 46, 89, 258, - /* 1020 */ 373, 92, 258, 89, 258, 277, 92, 294, 61, 322, - /* 1030 */ 294, 286, 326, 363, 123, 43, 330, 331, 332, 333, - /* 1040 */ 334, 335, 294, 337, 266, 258, 340, 266, 266, 299, - /* 1050 */ 344, 345, 346, 299, 89, 277, 85, 92, 277, 277, - /* 1060 */ 299, 355, 266, 299, 35, 299, 242, 43, 0, 158, - /* 1070 */ 159, 160, 294, 286, 163, 294, 294, 267, 86, 85, - /* 1080 */ 169, 294, 43, 43, 12, 13, 299, 265, 301, 95, - /* 1090 */ 294, 43, 168, 182, 22, 298, 185, 68, 187, 188, - /* 1100 */ 189, 190, 191, 192, 347, 33, 329, 35, 370, 354, - /* 1110 */ 86, 315, 370, 326, 43, 357, 48, 330, 331, 332, - /* 1120 */ 333, 334, 335, 258, 337, 86, 86, 340, 56, 43, - /* 1130 */ 334, 344, 345, 346, 86, 246, 225, 43, 4, 370, - /* 1140 */ 68, 85, 355, 43, 168, 349, 350, 351, 290, 353, - /* 1150 */ 227, 286, 356, 19, 324, 20, 266, 86, 43, 294, - /* 1160 */ 193, 47, 164, 43, 299, 369, 301, 33, 323, 373, - /* 1170 */ 43, 43, 86, 35, 272, 266, 258, 317, 266, 107, - /* 1180 */ 86, 47, 42, 306, 148, 51, 86, 304, 304, 20, - /* 1190 */ 56, 326, 266, 266, 266, 330, 331, 332, 333, 334, - /* 1200 */ 335, 86, 337, 260, 286, 340, 86, 260, 20, 344, - /* 1210 */ 345, 346, 294, 86, 86, 321, 270, 299, 84, 301, - /* 1220 */ 355, 87, 301, 270, 20, 20, 316, 314, 258, 270, - /* 1230 */ 314, 270, 20, 315, 270, 266, 270, 307, 166, 260, - /* 1240 */ 168, 286, 270, 286, 326, 260, 286, 299, 330, 331, - /* 1250 */ 332, 333, 334, 335, 286, 337, 286, 266, 321, 286, - /* 1260 */ 286, 286, 174, 286, 294, 193, 286, 286, 286, 299, - /* 1270 */ 268, 301, 320, 268, 356, 266, 204, 205, 206, 207, - /* 1280 */ 208, 209, 210, 266, 301, 315, 268, 369, 299, 232, - /* 1290 */ 268, 373, 314, 258, 310, 299, 326, 310, 299, 299, - /* 1300 */ 330, 331, 332, 333, 334, 335, 299, 337, 150, 258, - /* 1310 */ 294, 308, 282, 307, 268, 294, 20, 329, 299, 299, - /* 1320 */ 233, 286, 310, 310, 362, 299, 356, 299, 239, 294, - /* 1330 */ 299, 157, 241, 240, 299, 228, 301, 286, 324, 369, - /* 1340 */ 224, 294, 20, 373, 245, 294, 243, 85, 362, 248, - /* 1350 */ 299, 328, 301, 343, 290, 365, 361, 364, 299, 362, - /* 1360 */ 359, 326, 266, 268, 258, 330, 331, 332, 333, 334, - /* 1370 */ 335, 360, 337, 276, 36, 340, 258, 326, 261, 344, - /* 1380 */ 345, 330, 331, 332, 333, 334, 335, 336, 337, 338, - /* 1390 */ 339, 260, 286, 318, 313, 269, 0, 372, 371, 280, - /* 1400 */ 294, 280, 280, 256, 286, 299, 372, 301, 371, 377, - /* 1410 */ 372, 176, 294, 371, 0, 0, 42, 299, 0, 301, - /* 1420 */ 76, 0, 35, 186, 35, 35, 35, 186, 0, 35, - /* 1430 */ 35, 186, 326, 0, 186, 0, 330, 331, 332, 333, - /* 1440 */ 334, 335, 35, 337, 326, 0, 22, 0, 330, 331, - /* 1450 */ 332, 333, 334, 335, 258, 337, 0, 35, 340, 171, - /* 1460 */ 85, 170, 168, 345, 166, 0, 0, 162, 258, 161, - /* 1470 */ 0, 0, 46, 0, 0, 0, 145, 0, 258, 0, - /* 1480 */ 374, 375, 286, 0, 0, 0, 140, 291, 35, 0, - /* 1490 */ 294, 140, 0, 0, 0, 299, 286, 301, 0, 0, - /* 1500 */ 0, 291, 0, 0, 294, 0, 286, 0, 0, 299, - /* 1510 */ 0, 301, 0, 0, 294, 0, 0, 0, 42, 299, - /* 1520 */ 0, 301, 326, 0, 0, 0, 330, 331, 332, 333, - /* 1530 */ 334, 335, 0, 337, 0, 258, 326, 0, 0, 0, - /* 1540 */ 330, 331, 332, 333, 334, 335, 326, 337, 0, 22, - /* 1550 */ 330, 331, 332, 333, 334, 335, 0, 337, 0, 258, - /* 1560 */ 56, 42, 56, 286, 43, 39, 14, 14, 46, 40, - /* 1570 */ 39, 294, 0, 0, 46, 0, 299, 157, 301, 39, - /* 1580 */ 0, 0, 0, 0, 0, 258, 35, 286, 368, 47, - /* 1590 */ 0, 0, 62, 39, 35, 294, 47, 35, 0, 39, - /* 1600 */ 299, 0, 301, 326, 47, 39, 35, 330, 331, 332, - /* 1610 */ 333, 334, 335, 286, 337, 47, 39, 0, 291, 0, - /* 1620 */ 0, 294, 35, 0, 22, 92, 299, 326, 301, 94, - /* 1630 */ 35, 330, 331, 332, 333, 334, 335, 43, 337, 258, - /* 1640 */ 339, 35, 35, 43, 35, 35, 35, 35, 35, 0, - /* 1650 */ 22, 0, 375, 326, 22, 19, 0, 330, 331, 332, - /* 1660 */ 333, 334, 335, 49, 337, 22, 35, 286, 0, 33, - /* 1670 */ 35, 0, 291, 35, 0, 294, 22, 20, 0, 35, - /* 1680 */ 299, 0, 301, 47, 22, 0, 172, 0, 52, 53, - /* 1690 */ 54, 55, 56, 0, 153, 150, 153, 0, 0, 153, - /* 1700 */ 85, 0, 155, 0, 86, 39, 85, 326, 43, 85, - /* 1710 */ 85, 330, 331, 332, 333, 334, 335, 33, 337, 46, - /* 1720 */ 84, 151, 258, 87, 95, 149, 229, 85, 46, 43, - /* 1730 */ 85, 47, 86, 86, 86, 85, 52, 53, 54, 55, - /* 1740 */ 56, 86, 181, 85, 85, 85, 258, 86, 43, 85, - /* 1750 */ 286, 2, 46, 43, 35, 86, 120, 46, 294, 223, - /* 1760 */ 43, 86, 46, 299, 46, 301, 86, 43, 84, 86, - /* 1770 */ 35, 87, 35, 35, 286, 35, 35, 22, 193, 229, - /* 1780 */ 85, 85, 294, 22, 229, 43, 86, 299, 152, 301, - /* 1790 */ 326, 46, 46, 86, 330, 331, 332, 333, 334, 335, - /* 1800 */ 85, 337, 258, 35, 22, 96, 86, 85, 85, 173, - /* 1810 */ 85, 175, 86, 35, 326, 85, 35, 195, 330, 331, - /* 1820 */ 332, 333, 334, 335, 85, 337, 35, 35, 35, 86, - /* 1830 */ 286, 97, 85, 149, 150, 85, 152, 86, 294, 86, - /* 1840 */ 156, 109, 86, 299, 258, 301, 35, 85, 85, 85, - /* 1850 */ 85, 43, 22, 109, 258, 35, 62, 109, 61, 175, - /* 1860 */ 83, 109, 43, 68, 35, 22, 258, 35, 35, 35, - /* 1870 */ 326, 35, 286, 35, 330, 331, 332, 333, 334, 335, - /* 1880 */ 294, 337, 286, 35, 68, 299, 35, 301, 35, 35, - /* 1890 */ 294, 35, 35, 35, 286, 299, 35, 301, 35, 0, - /* 1900 */ 35, 39, 294, 0, 35, 39, 47, 299, 0, 301, - /* 1910 */ 35, 47, 326, 39, 47, 0, 330, 331, 332, 333, - /* 1920 */ 334, 335, 326, 337, 35, 47, 330, 331, 332, 333, - /* 1930 */ 334, 335, 39, 337, 326, 35, 35, 0, 330, 331, - /* 1940 */ 332, 333, 334, 335, 0, 337, 22, 258, 21, 378, - /* 1950 */ 22, 22, 21, 20, 378, 378, 378, 378, 378, 378, - /* 1960 */ 378, 378, 378, 378, 378, 378, 258, 378, 378, 378, - /* 1970 */ 378, 378, 378, 378, 378, 286, 378, 378, 378, 378, - /* 1980 */ 378, 378, 378, 294, 378, 378, 378, 378, 299, 378, - /* 1990 */ 301, 378, 378, 378, 286, 378, 378, 378, 378, 378, - /* 2000 */ 378, 378, 294, 378, 378, 378, 378, 299, 378, 301, - /* 2010 */ 378, 378, 378, 378, 378, 326, 378, 378, 378, 330, - /* 2020 */ 331, 332, 333, 334, 335, 378, 337, 258, 378, 378, - /* 2030 */ 378, 378, 378, 378, 326, 378, 378, 378, 330, 331, - /* 2040 */ 332, 333, 334, 335, 378, 337, 258, 378, 378, 378, - /* 2050 */ 378, 378, 378, 378, 378, 286, 378, 378, 378, 378, - /* 2060 */ 378, 378, 378, 294, 378, 378, 378, 378, 299, 378, - /* 2070 */ 301, 378, 378, 378, 286, 378, 378, 378, 378, 378, - /* 2080 */ 378, 378, 294, 378, 378, 378, 378, 299, 378, 301, - /* 2090 */ 378, 378, 378, 378, 378, 326, 378, 378, 378, 330, - /* 2100 */ 331, 332, 333, 334, 335, 378, 337, 378, 378, 378, - /* 2110 */ 378, 378, 378, 258, 326, 378, 378, 378, 330, 331, - /* 2120 */ 332, 333, 334, 335, 378, 337, 378, 378, 378, 258, - /* 2130 */ 378, 378, 378, 378, 378, 378, 378, 378, 378, 258, - /* 2140 */ 378, 286, 378, 378, 378, 378, 378, 378, 378, 294, - /* 2150 */ 378, 378, 378, 378, 299, 378, 301, 286, 378, 378, - /* 2160 */ 378, 378, 378, 378, 378, 294, 378, 286, 378, 378, - /* 2170 */ 299, 378, 301, 378, 378, 294, 378, 378, 378, 378, - /* 2180 */ 299, 326, 301, 378, 378, 330, 331, 332, 333, 334, - /* 2190 */ 335, 378, 337, 258, 378, 378, 378, 326, 378, 378, - /* 2200 */ 378, 330, 331, 332, 333, 334, 335, 326, 337, 378, - /* 2210 */ 378, 330, 331, 332, 333, 334, 335, 378, 337, 378, - /* 2220 */ 378, 286, 378, 378, 378, 378, 378, 378, 378, 294, - /* 2230 */ 378, 378, 378, 378, 299, 378, 301, 378, 378, 378, - /* 2240 */ 378, 378, 378, 378, 378, 378, 378, 258, 378, 378, - /* 2250 */ 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, - /* 2260 */ 378, 326, 378, 378, 378, 330, 331, 332, 333, 334, - /* 2270 */ 335, 378, 337, 378, 378, 286, 378, 378, 378, 378, - /* 2280 */ 378, 378, 378, 294, 378, 378, 378, 378, 299, 378, - /* 2290 */ 301, 378, 378, 378, 378, 378, 378, 258, 378, 378, - /* 2300 */ 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, - /* 2310 */ 378, 378, 378, 378, 258, 326, 378, 378, 378, 330, - /* 2320 */ 331, 332, 333, 334, 335, 286, 337, 378, 378, 378, - /* 2330 */ 378, 378, 378, 294, 378, 378, 378, 378, 299, 378, - /* 2340 */ 301, 378, 286, 378, 378, 378, 378, 378, 378, 378, - /* 2350 */ 294, 378, 378, 378, 378, 299, 378, 301, 378, 378, - /* 2360 */ 378, 378, 378, 378, 378, 326, 378, 378, 378, 330, - /* 2370 */ 331, 332, 333, 334, 335, 378, 337, 258, 378, 378, - /* 2380 */ 378, 378, 326, 378, 378, 378, 330, 331, 332, 333, - /* 2390 */ 334, 335, 378, 337, 378, 378, 378, 378, 258, 378, - /* 2400 */ 378, 378, 378, 378, 378, 286, 378, 378, 378, 378, - /* 2410 */ 378, 378, 378, 294, 378, 378, 378, 378, 299, 378, - /* 2420 */ 301, 378, 378, 378, 378, 378, 286, 378, 378, 378, - /* 2430 */ 378, 378, 378, 378, 294, 378, 378, 378, 378, 299, - /* 2440 */ 258, 301, 378, 378, 378, 326, 378, 378, 378, 330, - /* 2450 */ 331, 332, 333, 334, 335, 378, 337, 378, 378, 378, - /* 2460 */ 378, 378, 378, 378, 378, 378, 326, 378, 286, 378, - /* 2470 */ 330, 331, 332, 333, 334, 335, 294, 337, 378, 378, - /* 2480 */ 378, 299, 378, 301, 378, 378, 378, 378, 378, 378, - /* 2490 */ 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, - /* 2500 */ 378, 378, 378, 378, 378, 378, 378, 378, 326, 378, - /* 2510 */ 378, 378, 330, 331, 332, 333, 334, 335, 378, 337, + /* 990 */ 211, 212, 12, 13, 84, 286, 85, 87, 266, 356, + /* 1000 */ 266, 89, 22, 294, 92, 193, 153, 259, 299, 277, + /* 1010 */ 301, 277, 369, 33, 288, 35, 373, 153, 154, 266, + /* 1020 */ 376, 367, 85, 267, 258, 299, 294, 258, 294, 35, + /* 1030 */ 277, 258, 95, 43, 123, 326, 56, 0, 258, 330, + /* 1040 */ 331, 332, 333, 334, 335, 258, 337, 294, 68, 340, + /* 1050 */ 258, 325, 326, 344, 345, 346, 0, 322, 363, 149, + /* 1060 */ 150, 0, 152, 337, 355, 299, 156, 258, 299, 158, + /* 1070 */ 159, 160, 299, 286, 163, 258, 86, 286, 267, 299, + /* 1080 */ 169, 294, 43, 43, 242, 175, 299, 107, 301, 46, + /* 1090 */ 265, 299, 298, 182, 43, 43, 185, 43, 187, 188, + /* 1100 */ 189, 190, 191, 192, 48, 329, 43, 43, 299, 43, + /* 1110 */ 347, 354, 370, 326, 370, 370, 299, 330, 331, 332, + /* 1120 */ 333, 334, 335, 258, 337, 86, 86, 340, 85, 246, + /* 1130 */ 85, 344, 345, 346, 97, 357, 225, 86, 86, 43, + /* 1140 */ 86, 290, 355, 227, 324, 20, 166, 266, 168, 86, + /* 1150 */ 86, 286, 86, 116, 117, 118, 119, 120, 97, 294, + /* 1160 */ 43, 43, 168, 47, 299, 258, 301, 323, 35, 43, + /* 1170 */ 43, 43, 272, 193, 194, 164, 317, 116, 117, 118, + /* 1180 */ 119, 120, 86, 266, 204, 205, 206, 207, 208, 209, + /* 1190 */ 210, 326, 266, 286, 42, 330, 331, 332, 333, 334, + /* 1200 */ 335, 294, 337, 86, 86, 340, 299, 306, 301, 344, + /* 1210 */ 345, 346, 86, 86, 86, 148, 266, 304, 304, 266, + /* 1220 */ 355, 266, 315, 20, 260, 260, 258, 270, 20, 321, + /* 1230 */ 301, 270, 20, 326, 314, 20, 258, 330, 331, 332, + /* 1240 */ 333, 334, 335, 316, 337, 4, 270, 314, 20, 270, + /* 1250 */ 307, 270, 270, 266, 286, 270, 260, 286, 286, 286, + /* 1260 */ 19, 286, 294, 356, 286, 260, 299, 299, 266, 301, + /* 1270 */ 286, 268, 294, 321, 33, 286, 369, 299, 286, 301, + /* 1280 */ 373, 286, 174, 315, 286, 286, 286, 301, 47, 320, + /* 1290 */ 268, 266, 51, 258, 326, 266, 268, 56, 330, 331, + /* 1300 */ 332, 333, 334, 335, 326, 337, 232, 258, 330, 331, + /* 1310 */ 332, 333, 334, 335, 310, 337, 299, 299, 340, 299, + /* 1320 */ 314, 286, 344, 345, 356, 84, 299, 150, 87, 294, + /* 1330 */ 299, 310, 308, 307, 299, 286, 301, 369, 294, 268, + /* 1340 */ 282, 373, 294, 294, 268, 20, 299, 233, 299, 299, + /* 1350 */ 301, 310, 329, 362, 299, 362, 310, 258, 299, 299, + /* 1360 */ 239, 326, 365, 157, 241, 330, 331, 332, 333, 334, + /* 1370 */ 335, 336, 337, 338, 339, 326, 364, 258, 362, 330, + /* 1380 */ 331, 332, 333, 334, 335, 286, 337, 240, 228, 324, + /* 1390 */ 224, 361, 360, 294, 294, 359, 20, 328, 299, 245, + /* 1400 */ 301, 243, 85, 248, 371, 286, 372, 276, 299, 266, + /* 1410 */ 291, 36, 290, 294, 372, 377, 343, 268, 299, 260, + /* 1420 */ 301, 318, 261, 374, 375, 326, 313, 256, 371, 330, + /* 1430 */ 331, 332, 333, 334, 335, 0, 337, 280, 269, 340, + /* 1440 */ 372, 371, 280, 258, 345, 326, 176, 280, 0, 330, + /* 1450 */ 331, 332, 333, 334, 335, 258, 337, 0, 42, 0, + /* 1460 */ 76, 0, 35, 35, 186, 258, 35, 35, 186, 0, + /* 1470 */ 186, 286, 35, 35, 0, 186, 291, 0, 35, 294, + /* 1480 */ 0, 0, 22, 286, 299, 0, 301, 35, 85, 171, + /* 1490 */ 170, 294, 168, 286, 166, 0, 299, 0, 301, 162, + /* 1500 */ 161, 294, 0, 0, 46, 0, 299, 0, 301, 0, + /* 1510 */ 145, 326, 0, 0, 0, 330, 331, 332, 333, 334, + /* 1520 */ 335, 258, 337, 326, 0, 0, 35, 330, 331, 332, + /* 1530 */ 333, 334, 335, 326, 337, 258, 140, 330, 331, 332, + /* 1540 */ 333, 334, 335, 0, 337, 140, 0, 0, 0, 286, + /* 1550 */ 42, 0, 0, 0, 0, 0, 0, 294, 0, 0, + /* 1560 */ 0, 0, 299, 286, 301, 368, 0, 0, 291, 0, + /* 1570 */ 0, 294, 0, 0, 0, 0, 299, 0, 301, 22, + /* 1580 */ 0, 0, 375, 0, 56, 0, 56, 0, 258, 326, + /* 1590 */ 0, 42, 14, 330, 331, 332, 333, 334, 335, 0, + /* 1600 */ 337, 39, 339, 326, 40, 14, 43, 330, 331, 332, + /* 1610 */ 333, 334, 335, 19, 337, 47, 286, 46, 39, 0, + /* 1620 */ 0, 291, 46, 0, 294, 39, 0, 33, 157, 299, + /* 1630 */ 258, 301, 0, 0, 0, 0, 35, 39, 0, 35, + /* 1640 */ 47, 47, 0, 35, 258, 39, 52, 53, 54, 55, + /* 1650 */ 56, 62, 47, 39, 0, 39, 326, 35, 286, 47, + /* 1660 */ 330, 331, 332, 333, 334, 335, 294, 337, 0, 0, + /* 1670 */ 0, 299, 286, 301, 0, 35, 94, 22, 84, 0, + /* 1680 */ 294, 87, 35, 35, 92, 299, 35, 301, 35, 43, + /* 1690 */ 0, 35, 43, 35, 35, 35, 0, 22, 326, 22, + /* 1700 */ 0, 49, 330, 331, 332, 333, 334, 335, 258, 337, + /* 1710 */ 22, 35, 326, 0, 120, 35, 330, 331, 332, 333, + /* 1720 */ 334, 335, 0, 337, 35, 0, 22, 20, 0, 35, + /* 1730 */ 258, 0, 22, 0, 0, 0, 286, 153, 0, 0, + /* 1740 */ 0, 0, 39, 46, 294, 95, 152, 150, 153, 299, + /* 1750 */ 258, 301, 86, 153, 43, 229, 85, 155, 286, 86, + /* 1760 */ 172, 151, 149, 85, 43, 46, 294, 173, 85, 175, + /* 1770 */ 85, 299, 85, 301, 229, 43, 326, 181, 286, 86, + /* 1780 */ 330, 331, 332, 333, 334, 335, 294, 337, 86, 46, + /* 1790 */ 85, 299, 258, 301, 85, 43, 46, 85, 326, 43, + /* 1800 */ 86, 85, 330, 331, 332, 333, 334, 335, 258, 337, + /* 1810 */ 86, 85, 85, 46, 46, 86, 86, 43, 326, 35, + /* 1820 */ 286, 35, 330, 331, 332, 333, 334, 335, 294, 337, + /* 1830 */ 223, 86, 86, 299, 35, 301, 286, 35, 229, 35, + /* 1840 */ 35, 2, 22, 43, 294, 85, 22, 86, 85, 299, + /* 1850 */ 86, 301, 86, 46, 193, 85, 85, 85, 46, 195, + /* 1860 */ 326, 258, 85, 35, 330, 331, 332, 333, 334, 335, + /* 1870 */ 35, 337, 96, 258, 86, 85, 326, 86, 35, 85, + /* 1880 */ 330, 331, 332, 333, 334, 335, 35, 337, 85, 286, + /* 1890 */ 35, 35, 86, 22, 86, 85, 85, 294, 109, 86, + /* 1900 */ 85, 286, 299, 85, 301, 109, 109, 109, 35, 294, + /* 1910 */ 43, 97, 85, 22, 299, 258, 301, 35, 68, 62, + /* 1920 */ 61, 83, 43, 35, 35, 258, 22, 35, 35, 326, + /* 1930 */ 35, 35, 35, 330, 331, 332, 333, 334, 335, 258, + /* 1940 */ 337, 326, 68, 286, 35, 330, 331, 332, 333, 334, + /* 1950 */ 335, 294, 337, 286, 35, 35, 299, 35, 301, 35, + /* 1960 */ 35, 294, 35, 35, 0, 35, 299, 286, 301, 0, + /* 1970 */ 47, 39, 35, 47, 39, 294, 0, 35, 47, 0, + /* 1980 */ 299, 35, 301, 326, 39, 47, 39, 330, 331, 332, + /* 1990 */ 333, 334, 335, 326, 337, 258, 0, 330, 331, 332, + /* 2000 */ 333, 334, 335, 35, 337, 258, 35, 326, 0, 22, + /* 2010 */ 21, 330, 331, 332, 333, 334, 335, 258, 337, 22, + /* 2020 */ 22, 21, 20, 286, 378, 378, 378, 378, 378, 378, + /* 2030 */ 378, 294, 378, 286, 378, 378, 299, 378, 301, 378, + /* 2040 */ 378, 294, 378, 378, 378, 286, 299, 378, 301, 378, + /* 2050 */ 378, 378, 378, 294, 378, 378, 378, 378, 299, 378, + /* 2060 */ 301, 378, 378, 326, 378, 378, 378, 330, 331, 332, + /* 2070 */ 333, 334, 335, 326, 337, 378, 378, 330, 331, 332, + /* 2080 */ 333, 334, 335, 258, 337, 326, 378, 378, 378, 330, + /* 2090 */ 331, 332, 333, 334, 335, 258, 337, 378, 378, 378, + /* 2100 */ 378, 378, 378, 378, 378, 378, 378, 378, 378, 378, + /* 2110 */ 378, 286, 378, 378, 378, 378, 378, 378, 378, 294, + /* 2120 */ 378, 378, 378, 286, 299, 378, 301, 378, 378, 378, + /* 2130 */ 378, 294, 378, 378, 378, 378, 299, 378, 301, 378, + /* 2140 */ 378, 378, 378, 378, 378, 378, 378, 378, 258, 378, + /* 2150 */ 378, 326, 378, 378, 378, 330, 331, 332, 333, 334, + /* 2160 */ 335, 378, 337, 326, 378, 378, 378, 330, 331, 332, + /* 2170 */ 333, 334, 335, 378, 337, 378, 286, 378, 378, 378, + /* 2180 */ 378, 378, 378, 378, 294, 378, 378, 378, 378, 299, + /* 2190 */ 378, 301, 378, 378, 378, 378, 378, 378, 258, 378, + /* 2200 */ 378, 378, 378, 378, 378, 378, 378, 378, 258, 378, + /* 2210 */ 266, 378, 378, 378, 378, 378, 326, 378, 378, 378, + /* 2220 */ 330, 331, 332, 333, 334, 335, 286, 337, 378, 378, + /* 2230 */ 378, 378, 378, 378, 294, 378, 286, 378, 294, 299, + /* 2240 */ 378, 301, 378, 378, 294, 378, 378, 378, 378, 299, + /* 2250 */ 378, 301, 378, 378, 378, 378, 378, 378, 378, 315, + /* 2260 */ 378, 378, 378, 378, 378, 378, 326, 378, 378, 378, + /* 2270 */ 330, 331, 332, 333, 334, 335, 326, 337, 334, 378, + /* 2280 */ 330, 331, 332, 333, 334, 335, 378, 337, 378, 378, + /* 2290 */ 378, 378, 378, 349, 350, 351, 378, 353, 378, 378, + /* 2300 */ 356, 378, 378, 378, 378, 378, 378, 378, 378, 378, + /* 2310 */ 378, 378, 378, 369, 378, 378, 378, 373, }; #define YY_SHIFT_COUNT (665) #define YY_SHIFT_MIN (0) -#define YY_SHIFT_MAX (1944) +#define YY_SHIFT_MAX (2008) static const unsigned short int yy_shift_ofst[] = { /* 0 */ 911, 0, 0, 62, 62, 263, 263, 263, 320, 320, /* 10 */ 263, 263, 521, 578, 779, 578, 578, 578, 578, 578, /* 20 */ 578, 578, 578, 578, 578, 578, 578, 578, 578, 578, /* 30 */ 578, 578, 578, 578, 578, 578, 578, 578, 578, 578, - /* 40 */ 578, 578, 209, 209, 35, 35, 35, 1072, 1072, 1072, - /* 50 */ 1072, 208, 350, 32, 32, 167, 167, 19, 19, 11, + /* 40 */ 578, 578, 209, 209, 35, 35, 35, 980, 980, 980, + /* 50 */ 980, 208, 350, 32, 32, 167, 167, 19, 19, 11, /* 60 */ 38, 32, 32, 167, 167, 167, 167, 167, 167, 167, /* 70 */ 167, 167, 182, 167, 167, 167, 230, 352, 167, 167, /* 80 */ 352, 438, 167, 352, 352, 352, 167, 452, 775, 231, @@ -742,162 +702,162 @@ static const unsigned short int yy_shift_ofst[] = { /* 100 */ 730, 730, 730, 730, 730, 730, 730, 730, 730, 730, /* 110 */ 730, 730, 730, 418, 38, 522, 522, 383, 567, 576, /* 120 */ 480, 480, 480, 567, 558, 230, 1, 1, 352, 352, - /* 130 */ 585, 585, 649, 691, 201, 201, 201, 201, 201, 201, - /* 140 */ 201, 1636, 125, 684, 119, 573, 69, 313, 343, 351, - /* 150 */ 631, 529, 494, 39, 548, 514, 673, 514, 708, 824, - /* 160 */ 824, 824, 250, 666, 1056, 923, 1135, 1114, 1138, 998, - /* 170 */ 1135, 1135, 1140, 1036, 1036, 1135, 1135, 1135, 1169, 1169, - /* 180 */ 1188, 182, 230, 182, 1204, 1205, 182, 1204, 182, 1212, - /* 190 */ 182, 182, 1135, 182, 1169, 352, 352, 352, 352, 352, - /* 200 */ 352, 352, 352, 352, 352, 352, 1135, 1169, 585, 1188, - /* 210 */ 452, 1088, 230, 452, 1135, 1135, 1204, 452, 1057, 585, - /* 220 */ 585, 585, 585, 1057, 585, 1158, 558, 1212, 452, 649, - /* 230 */ 452, 558, 1296, 585, 1087, 1057, 585, 585, 1087, 1057, - /* 240 */ 585, 585, 352, 1089, 1174, 1087, 1091, 1093, 1107, 923, - /* 250 */ 1116, 558, 1322, 1099, 1103, 1101, 1099, 1103, 1099, 1103, - /* 260 */ 1262, 1056, 585, 691, 1135, 452, 1338, 1169, 2520, 2520, - /* 270 */ 2520, 2520, 2520, 2520, 2520, 601, 1684, 386, 1134, 469, - /* 280 */ 551, 682, 840, 879, 853, 727, 823, 314, 314, 314, - /* 290 */ 314, 314, 314, 314, 314, 838, 699, 274, 274, 445, + /* 130 */ 585, 585, 663, 696, 201, 201, 201, 201, 201, 201, + /* 140 */ 201, 1594, 125, 684, 119, 573, 69, 313, 343, 351, + /* 150 */ 631, 529, 494, 39, 548, 514, 673, 514, 708, 842, + /* 160 */ 842, 842, 250, 666, 1045, 916, 1125, 1116, 1133, 1011, + /* 170 */ 1125, 1125, 1152, 1067, 1067, 1125, 1125, 1125, 1203, 1203, + /* 180 */ 1208, 182, 230, 182, 1212, 1215, 182, 1212, 182, 1228, + /* 190 */ 182, 182, 1125, 182, 1203, 352, 352, 352, 352, 352, + /* 200 */ 352, 352, 352, 352, 352, 352, 1125, 1203, 585, 1208, + /* 210 */ 452, 1108, 230, 452, 1125, 1125, 1212, 452, 1074, 585, + /* 220 */ 585, 585, 585, 1074, 585, 1177, 558, 1228, 452, 663, + /* 230 */ 452, 558, 1325, 585, 1114, 1074, 585, 585, 1114, 1074, + /* 240 */ 585, 585, 352, 1121, 1206, 1114, 1123, 1147, 1160, 916, + /* 250 */ 1166, 558, 1376, 1154, 1158, 1155, 1154, 1158, 1154, 1158, + /* 260 */ 1317, 1045, 585, 696, 1125, 452, 1375, 1203, 2318, 2318, + /* 270 */ 2318, 2318, 2318, 2318, 2318, 601, 910, 386, 1241, 469, + /* 280 */ 551, 682, 840, 879, 853, 727, 1037, 314, 314, 314, + /* 290 */ 314, 314, 314, 314, 314, 1061, 699, 274, 274, 445, /* 300 */ 65, 108, 156, 44, 168, 602, 339, 200, 200, 200, - /* 310 */ 200, 297, 841, 839, 929, 934, 965, 57, 850, 851, - /* 320 */ 92, 784, 907, 908, 992, 1024, 1039, 1040, 1048, 819, - /* 330 */ 844, 626, 889, 1071, 924, 976, 967, 1086, 971, 1094, - /* 340 */ 1100, 1115, 1120, 1127, 1128, 994, 1029, 1068, 1396, 1235, - /* 350 */ 1414, 1415, 1374, 1418, 1344, 1421, 1387, 1237, 1389, 1390, - /* 360 */ 1391, 1241, 1428, 1394, 1395, 1245, 1433, 1248, 1435, 1407, - /* 370 */ 1445, 1424, 1447, 1422, 1456, 1375, 1288, 1291, 1294, 1298, - /* 380 */ 1465, 1466, 1305, 1308, 1470, 1471, 1426, 1473, 1474, 1475, - /* 390 */ 1331, 1477, 1479, 1483, 1484, 1485, 1346, 1453, 1489, 1351, - /* 400 */ 1492, 1493, 1494, 1498, 1499, 1500, 1502, 1503, 1505, 1507, - /* 410 */ 1508, 1510, 1512, 1513, 1476, 1515, 1516, 1517, 1520, 1523, - /* 420 */ 1524, 1527, 1525, 1532, 1534, 1537, 1538, 1504, 1539, 1506, - /* 430 */ 1548, 1556, 1519, 1526, 1521, 1552, 1522, 1553, 1528, 1558, - /* 440 */ 1529, 1531, 1572, 1573, 1575, 1540, 1420, 1580, 1581, 1582, - /* 450 */ 1530, 1583, 1584, 1551, 1542, 1554, 1590, 1559, 1549, 1560, - /* 460 */ 1591, 1562, 1557, 1566, 1598, 1571, 1568, 1577, 1601, 1617, - /* 470 */ 1619, 1620, 1535, 1533, 1587, 1602, 1623, 1595, 1606, 1607, - /* 480 */ 1609, 1594, 1600, 1610, 1611, 1612, 1613, 1649, 1628, 1651, - /* 490 */ 1632, 1614, 1656, 1643, 1631, 1668, 1635, 1671, 1638, 1674, - /* 500 */ 1654, 1657, 1678, 1541, 1644, 1681, 1514, 1662, 1543, 1545, - /* 510 */ 1685, 1687, 1546, 1547, 1693, 1697, 1698, 1615, 1618, 1561, - /* 520 */ 1701, 1621, 1570, 1624, 1703, 1666, 1576, 1625, 1629, 1673, - /* 530 */ 1665, 1497, 1642, 1646, 1645, 1647, 1648, 1650, 1686, 1655, - /* 540 */ 1658, 1659, 1660, 1661, 1705, 1682, 1706, 1664, 1710, 1550, - /* 550 */ 1669, 1675, 1711, 1536, 1717, 1716, 1718, 1680, 1724, 1555, - /* 560 */ 1683, 1719, 1735, 1737, 1738, 1740, 1741, 1683, 1749, 1755, - /* 570 */ 1585, 1742, 1695, 1700, 1696, 1707, 1715, 1720, 1745, 1722, - /* 580 */ 1723, 1746, 1761, 1622, 1725, 1709, 1726, 1768, 1778, 1730, - /* 590 */ 1743, 1781, 1739, 1751, 1791, 1747, 1753, 1792, 1750, 1756, - /* 600 */ 1793, 1762, 1732, 1744, 1748, 1752, 1782, 1734, 1763, 1764, - /* 610 */ 1811, 1765, 1808, 1808, 1830, 1794, 1797, 1820, 1795, 1777, - /* 620 */ 1819, 1829, 1832, 1833, 1834, 1836, 1843, 1838, 1848, 1816, - /* 630 */ 1594, 1851, 1600, 1853, 1854, 1856, 1857, 1858, 1861, 1863, - /* 640 */ 1899, 1865, 1859, 1862, 1903, 1869, 1864, 1866, 1908, 1875, - /* 650 */ 1867, 1874, 1915, 1889, 1878, 1893, 1944, 1900, 1901, 1937, - /* 660 */ 1924, 1927, 1928, 1929, 1931, 1933, + /* 310 */ 200, 297, 784, 843, 848, 862, 912, 57, 850, 928, + /* 320 */ 92, 864, 990, 1039, 1040, 1051, 1052, 1054, 1063, 819, + /* 330 */ 762, 702, 883, 1064, 771, 994, 812, 1066, 1043, 1096, + /* 340 */ 1117, 1118, 1126, 1127, 1128, 937, 906, 1056, 1435, 1270, + /* 350 */ 1448, 1457, 1416, 1459, 1384, 1461, 1427, 1278, 1428, 1431, + /* 360 */ 1432, 1282, 1469, 1437, 1438, 1284, 1474, 1289, 1477, 1443, + /* 370 */ 1480, 1460, 1481, 1452, 1485, 1403, 1318, 1320, 1324, 1328, + /* 380 */ 1495, 1497, 1337, 1339, 1502, 1503, 1458, 1505, 1507, 1509, + /* 390 */ 1365, 1512, 1513, 1514, 1524, 1525, 1396, 1491, 1543, 1405, + /* 400 */ 1546, 1547, 1548, 1558, 1559, 1560, 1561, 1566, 1567, 1569, + /* 410 */ 1570, 1572, 1573, 1574, 1508, 1551, 1552, 1553, 1554, 1555, + /* 420 */ 1556, 1557, 1575, 1577, 1580, 1581, 1583, 1528, 1585, 1530, + /* 430 */ 1587, 1590, 1549, 1562, 1563, 1578, 1571, 1591, 1576, 1599, + /* 440 */ 1564, 1579, 1619, 1620, 1623, 1586, 1471, 1626, 1632, 1633, + /* 450 */ 1589, 1634, 1635, 1601, 1568, 1598, 1638, 1604, 1593, 1606, + /* 460 */ 1642, 1608, 1605, 1614, 1654, 1622, 1612, 1616, 1668, 1669, + /* 470 */ 1670, 1674, 1582, 1592, 1640, 1655, 1679, 1647, 1648, 1651, + /* 480 */ 1653, 1646, 1649, 1656, 1658, 1659, 1660, 1690, 1675, 1696, + /* 490 */ 1677, 1652, 1700, 1688, 1676, 1713, 1680, 1722, 1689, 1725, + /* 500 */ 1704, 1707, 1728, 1584, 1694, 1731, 1588, 1710, 1595, 1597, + /* 510 */ 1733, 1734, 1600, 1602, 1735, 1738, 1739, 1671, 1666, 1596, + /* 520 */ 1740, 1678, 1610, 1683, 1741, 1703, 1613, 1685, 1650, 1697, + /* 530 */ 1711, 1526, 1687, 1673, 1705, 1693, 1702, 1709, 1721, 1714, + /* 540 */ 1712, 1716, 1726, 1724, 1732, 1719, 1743, 1727, 1752, 1545, + /* 550 */ 1729, 1730, 1750, 1607, 1756, 1767, 1768, 1745, 1774, 1609, + /* 560 */ 1746, 1784, 1786, 1799, 1802, 1804, 1805, 1746, 1839, 1820, + /* 570 */ 1661, 1800, 1760, 1761, 1763, 1764, 1770, 1766, 1807, 1771, + /* 580 */ 1772, 1812, 1824, 1664, 1777, 1776, 1788, 1828, 1835, 1790, + /* 590 */ 1791, 1843, 1794, 1806, 1851, 1803, 1808, 1855, 1810, 1813, + /* 600 */ 1856, 1811, 1789, 1796, 1797, 1798, 1871, 1814, 1815, 1818, + /* 610 */ 1873, 1827, 1867, 1867, 1891, 1857, 1859, 1882, 1850, 1838, + /* 620 */ 1879, 1888, 1889, 1892, 1893, 1895, 1904, 1896, 1897, 1874, + /* 630 */ 1646, 1909, 1649, 1919, 1920, 1922, 1924, 1925, 1927, 1928, + /* 640 */ 1964, 1930, 1923, 1932, 1969, 1937, 1926, 1935, 1976, 1942, + /* 650 */ 1931, 1945, 1979, 1946, 1938, 1947, 1996, 1968, 1971, 2008, + /* 660 */ 1987, 1989, 1997, 1998, 2000, 2002, }; #define YY_REDUCE_COUNT (274) #define YY_REDUCE_MIN (-312) -#define YY_REDUCE_MAX (2182) +#define YY_REDUCE_MAX (1950) static const short yy_reduce_ofst[] = { - /* 0 */ -78, -232, 63, 286, -113, 706, 787, 865, 918, 970, - /* 10 */ 545, 1035, 1051, 1106, 1118, 1196, 1210, 1220, 1277, 1301, - /* 20 */ 1327, 1381, 1464, 1488, 1544, 1586, 1596, 1608, 1689, 1708, - /* 30 */ 1769, 1788, 1855, 1871, 1881, 1935, 1989, 2039, 2056, 2119, - /* 40 */ 2140, 2182, -263, 796, -14, 75, 305, -278, 55, 270, - /* 50 */ 672, -296, 123, 184, 647, -266, -43, -260, -256, -303, - /* 60 */ -186, -230, -191, -185, 97, 315, 316, 363, 563, 564, - /* 70 */ 566, 659, -154, 667, 733, 736, -285, -106, 748, 778, - /* 80 */ 59, 24, 781, 72, 322, 82, 782, 70, -252, -312, + /* 0 */ -78, -232, 63, 286, -113, 709, 787, 865, 907, 968, + /* 10 */ 545, 978, 1035, 1049, 1099, 1119, 1185, 1197, 1207, 1263, + /* 20 */ 1277, 1330, 1372, 1386, 1450, 1472, 1492, 1534, 1550, 1603, + /* 30 */ 1615, 1657, 1667, 1681, 1737, 1747, 1759, 1825, 1837, 1890, + /* 40 */ 1940, 1950, -263, 1944, -14, 75, 305, -278, 55, 270, + /* 50 */ 726, -296, 123, 184, 643, -266, -43, -260, -256, -303, + /* 60 */ -186, -230, -191, -185, 97, 315, 316, 363, 557, 563, + /* 70 */ 564, 566, -154, 659, 661, 665, -285, -106, 667, 732, + /* 80 */ 59, 24, 734, 72, 322, 82, 753, 70, -252, -312, /* 90 */ -312, -312, -117, -239, -114, -20, 141, 181, 196, 289, - /* 100 */ 328, 435, 455, 505, 575, 668, 705, 716, 750, 754, - /* 110 */ 761, 764, 766, 299, -110, 124, 138, -220, 148, -243, + /* 100 */ 328, 435, 455, 505, 575, 672, 766, 769, 773, 780, + /* 110 */ 792, 809, 817, 299, -110, 124, 138, -220, 148, -243, /* 120 */ 218, 310, 364, 150, 354, 349, 336, 456, 319, 205, - /* 130 */ 474, 498, 476, 560, -280, -270, 477, 513, 519, 538, - /* 140 */ 596, 526, 382, 655, 570, 628, 734, 707, 670, 745, - /* 150 */ 745, 810, 822, 797, 777, 755, 755, 755, 757, 738, - /* 160 */ 742, 769, 758, 745, 858, 830, 890, 845, 902, 860, - /* 170 */ 909, 912, 877, 883, 884, 926, 927, 928, 943, 947, - /* 180 */ 894, 946, 921, 953, 913, 910, 959, 916, 961, 930, - /* 190 */ 964, 966, 969, 972, 979, 955, 957, 960, 968, 973, - /* 200 */ 974, 975, 977, 980, 981, 982, 991, 985, 948, 937, - /* 210 */ 1002, 952, 983, 1005, 1009, 1017, 978, 1018, 984, 989, - /* 220 */ 996, 999, 1000, 987, 1007, 1003, 1016, 1006, 1022, 1030, - /* 230 */ 1046, 1021, 988, 1019, 962, 1012, 1020, 1026, 986, 1013, - /* 240 */ 1028, 1031, 745, 990, 993, 997, 995, 1011, 1001, 1014, - /* 250 */ 755, 1047, 1023, 1025, 1027, 1032, 1034, 1037, 1038, 1042, - /* 260 */ 1010, 1064, 1059, 1097, 1096, 1095, 1117, 1131, 1075, 1081, - /* 270 */ 1119, 1121, 1122, 1126, 1147, + /* 130 */ 474, 498, 476, 562, -280, -270, 382, 513, 538, 633, + /* 140 */ 669, 641, 748, 366, 644, 654, 756, 735, 695, 791, + /* 150 */ 791, 811, 825, 794, 776, 757, 757, 757, 763, 742, + /* 160 */ 744, 745, 778, 791, 851, 820, 881, 844, 900, 859, + /* 170 */ 917, 926, 901, 913, 914, 950, 953, 955, 964, 965, + /* 180 */ 908, 957, 929, 961, 920, 927, 976, 933, 979, 943, + /* 190 */ 981, 982, 987, 985, 996, 971, 972, 973, 975, 984, + /* 200 */ 989, 992, 995, 998, 999, 1000, 1002, 1005, 967, 952, + /* 210 */ 1003, 969, 986, 1022, 1025, 1029, 1006, 1028, 1004, 1017, + /* 220 */ 1018, 1020, 1027, 1021, 1031, 1024, 1044, 1026, 1071, 1058, + /* 230 */ 1076, 1048, 1023, 1047, 991, 1041, 1050, 1055, 993, 1046, + /* 240 */ 1059, 1060, 791, 997, 1012, 1016, 1030, 1032, 1036, 1065, + /* 250 */ 757, 1100, 1069, 1034, 1033, 1038, 1042, 1057, 1068, 1070, + /* 260 */ 1073, 1122, 1109, 1131, 1143, 1149, 1161, 1159, 1103, 1113, + /* 270 */ 1157, 1162, 1167, 1169, 1171, }; static const YYACTIONTYPE yy_default[] = { - /* 0 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 10 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 20 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 30 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 40 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 50 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 60 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 70 */ 1457, 1457, 1531, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 80 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1529, 1684, 1457, - /* 90 */ 1861, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 100 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 110 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1531, 1457, 1529, - /* 120 */ 1873, 1873, 1873, 1457, 1457, 1457, 1728, 1728, 1457, 1457, - /* 130 */ 1457, 1457, 1627, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 140 */ 1457, 1720, 1457, 1457, 1942, 1457, 1457, 1726, 1896, 1457, - /* 150 */ 1457, 1457, 1457, 1580, 1888, 1865, 1879, 1866, 1863, 1927, - /* 160 */ 1927, 1927, 1882, 1457, 1596, 1892, 1457, 1457, 1457, 1712, - /* 170 */ 1457, 1457, 1689, 1686, 1686, 1457, 1457, 1457, 1457, 1457, - /* 180 */ 1457, 1531, 1457, 1531, 1457, 1457, 1531, 1457, 1531, 1457, - /* 190 */ 1531, 1531, 1457, 1531, 1457, 1457, 1457, 1457, 1457, 1457, - /* 200 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 210 */ 1529, 1722, 1457, 1529, 1457, 1457, 1457, 1529, 1901, 1457, - /* 220 */ 1457, 1457, 1457, 1901, 1457, 1457, 1457, 1457, 1529, 1457, - /* 230 */ 1529, 1457, 1457, 1457, 1903, 1901, 1457, 1457, 1903, 1901, - /* 240 */ 1457, 1457, 1457, 1915, 1911, 1903, 1919, 1917, 1894, 1892, - /* 250 */ 1879, 1457, 1457, 1933, 1929, 1945, 1933, 1929, 1933, 1929, - /* 260 */ 1457, 1596, 1457, 1457, 1457, 1529, 1489, 1457, 1714, 1728, - /* 270 */ 1630, 1630, 1630, 1532, 1462, 1457, 1457, 1457, 1457, 1457, - /* 280 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1799, 1914, 1913, - /* 290 */ 1837, 1836, 1835, 1833, 1798, 1457, 1592, 1797, 1796, 1457, - /* 300 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1790, 1791, 1789, - /* 310 */ 1788, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 320 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1862, - /* 330 */ 1457, 1930, 1934, 1457, 1457, 1457, 1457, 1457, 1773, 1457, - /* 340 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 350 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 360 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 370 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 380 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 390 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 400 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 410 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 420 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 430 */ 1457, 1457, 1457, 1457, 1494, 1457, 1457, 1457, 1457, 1457, - /* 440 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 450 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 460 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 470 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 480 */ 1457, 1561, 1560, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 490 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 500 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 510 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 520 */ 1732, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 530 */ 1895, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 540 */ 1457, 1457, 1457, 1457, 1457, 1457, 1773, 1457, 1912, 1457, - /* 550 */ 1872, 1868, 1457, 1457, 1864, 1772, 1457, 1457, 1928, 1457, - /* 560 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1857, 1457, - /* 570 */ 1457, 1830, 1815, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 580 */ 1457, 1457, 1457, 1784, 1457, 1457, 1457, 1457, 1457, 1624, - /* 590 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 600 */ 1457, 1457, 1609, 1607, 1606, 1605, 1457, 1602, 1457, 1457, - /* 610 */ 1457, 1457, 1633, 1632, 1457, 1457, 1457, 1457, 1457, 1457, - /* 620 */ 1552, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 630 */ 1543, 1457, 1542, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 640 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 650 */ 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, 1457, - /* 660 */ 1457, 1457, 1457, 1457, 1457, 1457, + /* 0 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 10 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 20 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 30 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 40 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 50 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 60 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 70 */ 1459, 1459, 1533, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 80 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1531, 1686, 1459, + /* 90 */ 1864, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 100 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 110 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1533, 1459, 1531, + /* 120 */ 1876, 1876, 1876, 1459, 1459, 1459, 1730, 1730, 1459, 1459, + /* 130 */ 1459, 1459, 1629, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 140 */ 1459, 1722, 1459, 1459, 1945, 1459, 1459, 1728, 1899, 1459, + /* 150 */ 1459, 1459, 1459, 1582, 1891, 1868, 1882, 1869, 1866, 1930, + /* 160 */ 1930, 1930, 1885, 1459, 1598, 1895, 1459, 1459, 1459, 1714, + /* 170 */ 1459, 1459, 1691, 1688, 1688, 1459, 1459, 1459, 1459, 1459, + /* 180 */ 1459, 1533, 1459, 1533, 1459, 1459, 1533, 1459, 1533, 1459, + /* 190 */ 1533, 1533, 1459, 1533, 1459, 1459, 1459, 1459, 1459, 1459, + /* 200 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 210 */ 1531, 1724, 1459, 1531, 1459, 1459, 1459, 1531, 1904, 1459, + /* 220 */ 1459, 1459, 1459, 1904, 1459, 1459, 1459, 1459, 1531, 1459, + /* 230 */ 1531, 1459, 1459, 1459, 1906, 1904, 1459, 1459, 1906, 1904, + /* 240 */ 1459, 1459, 1459, 1918, 1914, 1906, 1922, 1920, 1897, 1895, + /* 250 */ 1882, 1459, 1459, 1936, 1932, 1948, 1936, 1932, 1936, 1932, + /* 260 */ 1459, 1598, 1459, 1459, 1459, 1531, 1491, 1459, 1716, 1730, + /* 270 */ 1632, 1632, 1632, 1534, 1464, 1459, 1459, 1459, 1459, 1459, + /* 280 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1802, 1917, 1916, + /* 290 */ 1840, 1839, 1838, 1836, 1801, 1459, 1594, 1800, 1799, 1459, + /* 300 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1793, 1794, 1792, + /* 310 */ 1791, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 320 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1865, + /* 330 */ 1459, 1933, 1937, 1459, 1459, 1459, 1459, 1459, 1776, 1459, + /* 340 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 350 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 360 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 370 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 380 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 390 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 400 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 410 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 420 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 430 */ 1459, 1459, 1459, 1459, 1496, 1459, 1459, 1459, 1459, 1459, + /* 440 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 450 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 460 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 470 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 480 */ 1459, 1563, 1562, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 490 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 500 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 510 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 520 */ 1734, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 530 */ 1898, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 540 */ 1459, 1459, 1459, 1459, 1459, 1459, 1776, 1459, 1915, 1459, + /* 550 */ 1875, 1871, 1459, 1459, 1867, 1775, 1459, 1459, 1931, 1459, + /* 560 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1860, 1459, + /* 570 */ 1459, 1833, 1818, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 580 */ 1459, 1459, 1459, 1787, 1459, 1459, 1459, 1459, 1459, 1626, + /* 590 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 600 */ 1459, 1459, 1611, 1609, 1608, 1607, 1459, 1604, 1459, 1459, + /* 610 */ 1459, 1459, 1635, 1634, 1459, 1459, 1459, 1459, 1459, 1459, + /* 620 */ 1554, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 630 */ 1545, 1459, 1544, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 640 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 650 */ 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, 1459, + /* 660 */ 1459, 1459, 1459, 1459, 1459, 1459, }; /********** End of lemon-generated parsing tables *****************************/ @@ -1953,185 +1913,186 @@ static const char *const yyRuleName[] = { /* 306 */ "signed_literal ::= duration_literal", /* 307 */ "signed_literal ::= NULL", /* 308 */ "signed_literal ::= literal_func", - /* 309 */ "literal_list ::= signed_literal", - /* 310 */ "literal_list ::= literal_list NK_COMMA signed_literal", - /* 311 */ "db_name ::= NK_ID", - /* 312 */ "table_name ::= NK_ID", - /* 313 */ "column_name ::= NK_ID", - /* 314 */ "function_name ::= NK_ID", - /* 315 */ "table_alias ::= NK_ID", - /* 316 */ "column_alias ::= NK_ID", - /* 317 */ "user_name ::= NK_ID", - /* 318 */ "index_name ::= NK_ID", - /* 319 */ "topic_name ::= NK_ID", - /* 320 */ "stream_name ::= NK_ID", - /* 321 */ "cgroup_name ::= NK_ID", - /* 322 */ "expression ::= literal", - /* 323 */ "expression ::= pseudo_column", - /* 324 */ "expression ::= column_reference", - /* 325 */ "expression ::= function_expression", - /* 326 */ "expression ::= subquery", - /* 327 */ "expression ::= NK_LP expression NK_RP", - /* 328 */ "expression ::= NK_PLUS expression", - /* 329 */ "expression ::= NK_MINUS expression", - /* 330 */ "expression ::= expression NK_PLUS expression", - /* 331 */ "expression ::= expression NK_MINUS expression", - /* 332 */ "expression ::= expression NK_STAR expression", - /* 333 */ "expression ::= expression NK_SLASH expression", - /* 334 */ "expression ::= expression NK_REM expression", - /* 335 */ "expression ::= column_reference NK_ARROW NK_STRING", - /* 336 */ "expression ::= expression NK_BITAND expression", - /* 337 */ "expression ::= expression NK_BITOR expression", - /* 338 */ "expression_list ::= expression", - /* 339 */ "expression_list ::= expression_list NK_COMMA expression", - /* 340 */ "column_reference ::= column_name", - /* 341 */ "column_reference ::= table_name NK_DOT column_name", - /* 342 */ "pseudo_column ::= ROWTS", - /* 343 */ "pseudo_column ::= TBNAME", - /* 344 */ "pseudo_column ::= table_name NK_DOT TBNAME", - /* 345 */ "pseudo_column ::= QSTARTTS", - /* 346 */ "pseudo_column ::= QENDTS", - /* 347 */ "pseudo_column ::= WSTARTTS", - /* 348 */ "pseudo_column ::= WENDTS", - /* 349 */ "pseudo_column ::= WDURATION", - /* 350 */ "function_expression ::= function_name NK_LP expression_list NK_RP", - /* 351 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP", - /* 352 */ "function_expression ::= CAST NK_LP expression AS type_name NK_RP", - /* 353 */ "function_expression ::= literal_func", - /* 354 */ "literal_func ::= noarg_func NK_LP NK_RP", - /* 355 */ "literal_func ::= NOW", - /* 356 */ "noarg_func ::= NOW", - /* 357 */ "noarg_func ::= TODAY", - /* 358 */ "noarg_func ::= TIMEZONE", - /* 359 */ "noarg_func ::= DATABASE", - /* 360 */ "noarg_func ::= CLIENT_VERSION", - /* 361 */ "noarg_func ::= SERVER_VERSION", - /* 362 */ "noarg_func ::= SERVER_STATUS", - /* 363 */ "noarg_func ::= CURRENT_USER", - /* 364 */ "noarg_func ::= USER", - /* 365 */ "star_func ::= COUNT", - /* 366 */ "star_func ::= FIRST", - /* 367 */ "star_func ::= LAST", - /* 368 */ "star_func ::= LAST_ROW", - /* 369 */ "star_func_para_list ::= NK_STAR", - /* 370 */ "star_func_para_list ::= other_para_list", - /* 371 */ "other_para_list ::= star_func_para", - /* 372 */ "other_para_list ::= other_para_list NK_COMMA star_func_para", - /* 373 */ "star_func_para ::= expression", - /* 374 */ "star_func_para ::= table_name NK_DOT NK_STAR", - /* 375 */ "predicate ::= expression compare_op expression", - /* 376 */ "predicate ::= expression BETWEEN expression AND expression", - /* 377 */ "predicate ::= expression NOT BETWEEN expression AND expression", - /* 378 */ "predicate ::= expression IS NULL", - /* 379 */ "predicate ::= expression IS NOT NULL", - /* 380 */ "predicate ::= expression in_op in_predicate_value", - /* 381 */ "compare_op ::= NK_LT", - /* 382 */ "compare_op ::= NK_GT", - /* 383 */ "compare_op ::= NK_LE", - /* 384 */ "compare_op ::= NK_GE", - /* 385 */ "compare_op ::= NK_NE", - /* 386 */ "compare_op ::= NK_EQ", - /* 387 */ "compare_op ::= LIKE", - /* 388 */ "compare_op ::= NOT LIKE", - /* 389 */ "compare_op ::= MATCH", - /* 390 */ "compare_op ::= NMATCH", - /* 391 */ "compare_op ::= CONTAINS", - /* 392 */ "in_op ::= IN", - /* 393 */ "in_op ::= NOT IN", - /* 394 */ "in_predicate_value ::= NK_LP literal_list NK_RP", - /* 395 */ "boolean_value_expression ::= boolean_primary", - /* 396 */ "boolean_value_expression ::= NOT boolean_primary", - /* 397 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression", - /* 398 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression", - /* 399 */ "boolean_primary ::= predicate", - /* 400 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP", - /* 401 */ "common_expression ::= expression", - /* 402 */ "common_expression ::= boolean_value_expression", - /* 403 */ "from_clause_opt ::=", - /* 404 */ "from_clause_opt ::= FROM table_reference_list", - /* 405 */ "table_reference_list ::= table_reference", - /* 406 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference", - /* 407 */ "table_reference ::= table_primary", - /* 408 */ "table_reference ::= joined_table", - /* 409 */ "table_primary ::= table_name alias_opt", - /* 410 */ "table_primary ::= db_name NK_DOT table_name alias_opt", - /* 411 */ "table_primary ::= subquery alias_opt", - /* 412 */ "table_primary ::= parenthesized_joined_table", - /* 413 */ "alias_opt ::=", - /* 414 */ "alias_opt ::= table_alias", - /* 415 */ "alias_opt ::= AS table_alias", - /* 416 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP", - /* 417 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP", - /* 418 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition", - /* 419 */ "join_type ::=", - /* 420 */ "join_type ::= INNER", - /* 421 */ "query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt", - /* 422 */ "set_quantifier_opt ::=", - /* 423 */ "set_quantifier_opt ::= DISTINCT", - /* 424 */ "set_quantifier_opt ::= ALL", - /* 425 */ "select_list ::= select_item", - /* 426 */ "select_list ::= select_list NK_COMMA select_item", - /* 427 */ "select_item ::= NK_STAR", - /* 428 */ "select_item ::= common_expression", - /* 429 */ "select_item ::= common_expression column_alias", - /* 430 */ "select_item ::= common_expression AS column_alias", - /* 431 */ "select_item ::= table_name NK_DOT NK_STAR", - /* 432 */ "where_clause_opt ::=", - /* 433 */ "where_clause_opt ::= WHERE search_condition", - /* 434 */ "partition_by_clause_opt ::=", - /* 435 */ "partition_by_clause_opt ::= PARTITION BY expression_list", - /* 436 */ "twindow_clause_opt ::=", - /* 437 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP", - /* 438 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP", - /* 439 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt", - /* 440 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt", - /* 441 */ "sliding_opt ::=", - /* 442 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP", - /* 443 */ "fill_opt ::=", - /* 444 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", - /* 445 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP", - /* 446 */ "fill_mode ::= NONE", - /* 447 */ "fill_mode ::= PREV", - /* 448 */ "fill_mode ::= NULL", - /* 449 */ "fill_mode ::= LINEAR", - /* 450 */ "fill_mode ::= NEXT", - /* 451 */ "group_by_clause_opt ::=", - /* 452 */ "group_by_clause_opt ::= GROUP BY group_by_list", - /* 453 */ "group_by_list ::= expression", - /* 454 */ "group_by_list ::= group_by_list NK_COMMA expression", - /* 455 */ "having_clause_opt ::=", - /* 456 */ "having_clause_opt ::= HAVING search_condition", - /* 457 */ "range_opt ::=", - /* 458 */ "range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP", - /* 459 */ "every_opt ::=", - /* 460 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP", - /* 461 */ "query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt", - /* 462 */ "query_expression_body ::= query_primary", - /* 463 */ "query_expression_body ::= query_expression_body UNION ALL query_expression_body", - /* 464 */ "query_expression_body ::= query_expression_body UNION query_expression_body", - /* 465 */ "query_primary ::= query_specification", - /* 466 */ "query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP", - /* 467 */ "order_by_clause_opt ::=", - /* 468 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", - /* 469 */ "slimit_clause_opt ::=", - /* 470 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", - /* 471 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", - /* 472 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 473 */ "limit_clause_opt ::=", - /* 474 */ "limit_clause_opt ::= LIMIT NK_INTEGER", - /* 475 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", - /* 476 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 477 */ "subquery ::= NK_LP query_expression NK_RP", - /* 478 */ "search_condition ::= common_expression", - /* 479 */ "sort_specification_list ::= sort_specification", - /* 480 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", - /* 481 */ "sort_specification ::= expression ordering_specification_opt null_ordering_opt", - /* 482 */ "ordering_specification_opt ::=", - /* 483 */ "ordering_specification_opt ::= ASC", - /* 484 */ "ordering_specification_opt ::= DESC", - /* 485 */ "null_ordering_opt ::=", - /* 486 */ "null_ordering_opt ::= NULLS FIRST", - /* 487 */ "null_ordering_opt ::= NULLS LAST", + /* 309 */ "signed_literal ::= NK_QUESTION", + /* 310 */ "literal_list ::= signed_literal", + /* 311 */ "literal_list ::= literal_list NK_COMMA signed_literal", + /* 312 */ "db_name ::= NK_ID", + /* 313 */ "table_name ::= NK_ID", + /* 314 */ "column_name ::= NK_ID", + /* 315 */ "function_name ::= NK_ID", + /* 316 */ "table_alias ::= NK_ID", + /* 317 */ "column_alias ::= NK_ID", + /* 318 */ "user_name ::= NK_ID", + /* 319 */ "index_name ::= NK_ID", + /* 320 */ "topic_name ::= NK_ID", + /* 321 */ "stream_name ::= NK_ID", + /* 322 */ "cgroup_name ::= NK_ID", + /* 323 */ "expression ::= literal", + /* 324 */ "expression ::= pseudo_column", + /* 325 */ "expression ::= column_reference", + /* 326 */ "expression ::= function_expression", + /* 327 */ "expression ::= subquery", + /* 328 */ "expression ::= NK_LP expression NK_RP", + /* 329 */ "expression ::= NK_PLUS expression", + /* 330 */ "expression ::= NK_MINUS expression", + /* 331 */ "expression ::= expression NK_PLUS expression", + /* 332 */ "expression ::= expression NK_MINUS expression", + /* 333 */ "expression ::= expression NK_STAR expression", + /* 334 */ "expression ::= expression NK_SLASH expression", + /* 335 */ "expression ::= expression NK_REM expression", + /* 336 */ "expression ::= column_reference NK_ARROW NK_STRING", + /* 337 */ "expression ::= expression NK_BITAND expression", + /* 338 */ "expression ::= expression NK_BITOR expression", + /* 339 */ "expression_list ::= expression", + /* 340 */ "expression_list ::= expression_list NK_COMMA expression", + /* 341 */ "column_reference ::= column_name", + /* 342 */ "column_reference ::= table_name NK_DOT column_name", + /* 343 */ "pseudo_column ::= ROWTS", + /* 344 */ "pseudo_column ::= TBNAME", + /* 345 */ "pseudo_column ::= table_name NK_DOT TBNAME", + /* 346 */ "pseudo_column ::= QSTARTTS", + /* 347 */ "pseudo_column ::= QENDTS", + /* 348 */ "pseudo_column ::= WSTARTTS", + /* 349 */ "pseudo_column ::= WENDTS", + /* 350 */ "pseudo_column ::= WDURATION", + /* 351 */ "function_expression ::= function_name NK_LP expression_list NK_RP", + /* 352 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP", + /* 353 */ "function_expression ::= CAST NK_LP expression AS type_name NK_RP", + /* 354 */ "function_expression ::= literal_func", + /* 355 */ "literal_func ::= noarg_func NK_LP NK_RP", + /* 356 */ "literal_func ::= NOW", + /* 357 */ "noarg_func ::= NOW", + /* 358 */ "noarg_func ::= TODAY", + /* 359 */ "noarg_func ::= TIMEZONE", + /* 360 */ "noarg_func ::= DATABASE", + /* 361 */ "noarg_func ::= CLIENT_VERSION", + /* 362 */ "noarg_func ::= SERVER_VERSION", + /* 363 */ "noarg_func ::= SERVER_STATUS", + /* 364 */ "noarg_func ::= CURRENT_USER", + /* 365 */ "noarg_func ::= USER", + /* 366 */ "star_func ::= COUNT", + /* 367 */ "star_func ::= FIRST", + /* 368 */ "star_func ::= LAST", + /* 369 */ "star_func ::= LAST_ROW", + /* 370 */ "star_func_para_list ::= NK_STAR", + /* 371 */ "star_func_para_list ::= other_para_list", + /* 372 */ "other_para_list ::= star_func_para", + /* 373 */ "other_para_list ::= other_para_list NK_COMMA star_func_para", + /* 374 */ "star_func_para ::= expression", + /* 375 */ "star_func_para ::= table_name NK_DOT NK_STAR", + /* 376 */ "predicate ::= expression compare_op expression", + /* 377 */ "predicate ::= expression BETWEEN expression AND expression", + /* 378 */ "predicate ::= expression NOT BETWEEN expression AND expression", + /* 379 */ "predicate ::= expression IS NULL", + /* 380 */ "predicate ::= expression IS NOT NULL", + /* 381 */ "predicate ::= expression in_op in_predicate_value", + /* 382 */ "compare_op ::= NK_LT", + /* 383 */ "compare_op ::= NK_GT", + /* 384 */ "compare_op ::= NK_LE", + /* 385 */ "compare_op ::= NK_GE", + /* 386 */ "compare_op ::= NK_NE", + /* 387 */ "compare_op ::= NK_EQ", + /* 388 */ "compare_op ::= LIKE", + /* 389 */ "compare_op ::= NOT LIKE", + /* 390 */ "compare_op ::= MATCH", + /* 391 */ "compare_op ::= NMATCH", + /* 392 */ "compare_op ::= CONTAINS", + /* 393 */ "in_op ::= IN", + /* 394 */ "in_op ::= NOT IN", + /* 395 */ "in_predicate_value ::= NK_LP literal_list NK_RP", + /* 396 */ "boolean_value_expression ::= boolean_primary", + /* 397 */ "boolean_value_expression ::= NOT boolean_primary", + /* 398 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression", + /* 399 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression", + /* 400 */ "boolean_primary ::= predicate", + /* 401 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP", + /* 402 */ "common_expression ::= expression", + /* 403 */ "common_expression ::= boolean_value_expression", + /* 404 */ "from_clause_opt ::=", + /* 405 */ "from_clause_opt ::= FROM table_reference_list", + /* 406 */ "table_reference_list ::= table_reference", + /* 407 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference", + /* 408 */ "table_reference ::= table_primary", + /* 409 */ "table_reference ::= joined_table", + /* 410 */ "table_primary ::= table_name alias_opt", + /* 411 */ "table_primary ::= db_name NK_DOT table_name alias_opt", + /* 412 */ "table_primary ::= subquery alias_opt", + /* 413 */ "table_primary ::= parenthesized_joined_table", + /* 414 */ "alias_opt ::=", + /* 415 */ "alias_opt ::= table_alias", + /* 416 */ "alias_opt ::= AS table_alias", + /* 417 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP", + /* 418 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP", + /* 419 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition", + /* 420 */ "join_type ::=", + /* 421 */ "join_type ::= INNER", + /* 422 */ "query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt", + /* 423 */ "set_quantifier_opt ::=", + /* 424 */ "set_quantifier_opt ::= DISTINCT", + /* 425 */ "set_quantifier_opt ::= ALL", + /* 426 */ "select_list ::= select_item", + /* 427 */ "select_list ::= select_list NK_COMMA select_item", + /* 428 */ "select_item ::= NK_STAR", + /* 429 */ "select_item ::= common_expression", + /* 430 */ "select_item ::= common_expression column_alias", + /* 431 */ "select_item ::= common_expression AS column_alias", + /* 432 */ "select_item ::= table_name NK_DOT NK_STAR", + /* 433 */ "where_clause_opt ::=", + /* 434 */ "where_clause_opt ::= WHERE search_condition", + /* 435 */ "partition_by_clause_opt ::=", + /* 436 */ "partition_by_clause_opt ::= PARTITION BY expression_list", + /* 437 */ "twindow_clause_opt ::=", + /* 438 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP", + /* 439 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP", + /* 440 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt", + /* 441 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt", + /* 442 */ "sliding_opt ::=", + /* 443 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP", + /* 444 */ "fill_opt ::=", + /* 445 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", + /* 446 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP", + /* 447 */ "fill_mode ::= NONE", + /* 448 */ "fill_mode ::= PREV", + /* 449 */ "fill_mode ::= NULL", + /* 450 */ "fill_mode ::= LINEAR", + /* 451 */ "fill_mode ::= NEXT", + /* 452 */ "group_by_clause_opt ::=", + /* 453 */ "group_by_clause_opt ::= GROUP BY group_by_list", + /* 454 */ "group_by_list ::= expression", + /* 455 */ "group_by_list ::= group_by_list NK_COMMA expression", + /* 456 */ "having_clause_opt ::=", + /* 457 */ "having_clause_opt ::= HAVING search_condition", + /* 458 */ "range_opt ::=", + /* 459 */ "range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP", + /* 460 */ "every_opt ::=", + /* 461 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP", + /* 462 */ "query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt", + /* 463 */ "query_expression_body ::= query_primary", + /* 464 */ "query_expression_body ::= query_expression_body UNION ALL query_expression_body", + /* 465 */ "query_expression_body ::= query_expression_body UNION query_expression_body", + /* 466 */ "query_primary ::= query_specification", + /* 467 */ "query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP", + /* 468 */ "order_by_clause_opt ::=", + /* 469 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", + /* 470 */ "slimit_clause_opt ::=", + /* 471 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", + /* 472 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", + /* 473 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 474 */ "limit_clause_opt ::=", + /* 475 */ "limit_clause_opt ::= LIMIT NK_INTEGER", + /* 476 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", + /* 477 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 478 */ "subquery ::= NK_LP query_expression NK_RP", + /* 479 */ "search_condition ::= common_expression", + /* 480 */ "sort_specification_list ::= sort_specification", + /* 481 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", + /* 482 */ "sort_specification ::= expression ordering_specification_opt null_ordering_opt", + /* 483 */ "ordering_specification_opt ::=", + /* 484 */ "ordering_specification_opt ::= ASC", + /* 485 */ "ordering_specification_opt ::= DESC", + /* 486 */ "null_ordering_opt ::=", + /* 487 */ "null_ordering_opt ::= NULLS FIRST", + /* 488 */ "null_ordering_opt ::= NULLS LAST", }; #endif /* NDEBUG */ @@ -3040,185 +3001,186 @@ static const struct { { 288, -1 }, /* (306) signed_literal ::= duration_literal */ { 288, -1 }, /* (307) signed_literal ::= NULL */ { 288, -1 }, /* (308) signed_literal ::= literal_func */ - { 327, -1 }, /* (309) literal_list ::= signed_literal */ - { 327, -3 }, /* (310) literal_list ::= literal_list NK_COMMA signed_literal */ - { 266, -1 }, /* (311) db_name ::= NK_ID */ - { 294, -1 }, /* (312) table_name ::= NK_ID */ - { 286, -1 }, /* (313) column_name ::= NK_ID */ - { 301, -1 }, /* (314) function_name ::= NK_ID */ - { 328, -1 }, /* (315) table_alias ::= NK_ID */ - { 329, -1 }, /* (316) column_alias ::= NK_ID */ - { 260, -1 }, /* (317) user_name ::= NK_ID */ - { 307, -1 }, /* (318) index_name ::= NK_ID */ - { 314, -1 }, /* (319) topic_name ::= NK_ID */ - { 321, -1 }, /* (320) stream_name ::= NK_ID */ - { 316, -1 }, /* (321) cgroup_name ::= NK_ID */ - { 330, -1 }, /* (322) expression ::= literal */ - { 330, -1 }, /* (323) expression ::= pseudo_column */ - { 330, -1 }, /* (324) expression ::= column_reference */ - { 330, -1 }, /* (325) expression ::= function_expression */ - { 330, -1 }, /* (326) expression ::= subquery */ - { 330, -3 }, /* (327) expression ::= NK_LP expression NK_RP */ - { 330, -2 }, /* (328) expression ::= NK_PLUS expression */ - { 330, -2 }, /* (329) expression ::= NK_MINUS expression */ - { 330, -3 }, /* (330) expression ::= expression NK_PLUS expression */ - { 330, -3 }, /* (331) expression ::= expression NK_MINUS expression */ - { 330, -3 }, /* (332) expression ::= expression NK_STAR expression */ - { 330, -3 }, /* (333) expression ::= expression NK_SLASH expression */ - { 330, -3 }, /* (334) expression ::= expression NK_REM expression */ - { 330, -3 }, /* (335) expression ::= column_reference NK_ARROW NK_STRING */ - { 330, -3 }, /* (336) expression ::= expression NK_BITAND expression */ - { 330, -3 }, /* (337) expression ::= expression NK_BITOR expression */ - { 291, -1 }, /* (338) expression_list ::= expression */ - { 291, -3 }, /* (339) expression_list ::= expression_list NK_COMMA expression */ - { 332, -1 }, /* (340) column_reference ::= column_name */ - { 332, -3 }, /* (341) column_reference ::= table_name NK_DOT column_name */ - { 331, -1 }, /* (342) pseudo_column ::= ROWTS */ - { 331, -1 }, /* (343) pseudo_column ::= TBNAME */ - { 331, -3 }, /* (344) pseudo_column ::= table_name NK_DOT TBNAME */ - { 331, -1 }, /* (345) pseudo_column ::= QSTARTTS */ - { 331, -1 }, /* (346) pseudo_column ::= QENDTS */ - { 331, -1 }, /* (347) pseudo_column ::= WSTARTTS */ - { 331, -1 }, /* (348) pseudo_column ::= WENDTS */ - { 331, -1 }, /* (349) pseudo_column ::= WDURATION */ - { 333, -4 }, /* (350) function_expression ::= function_name NK_LP expression_list NK_RP */ - { 333, -4 }, /* (351) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ - { 333, -6 }, /* (352) function_expression ::= CAST NK_LP expression AS type_name NK_RP */ - { 333, -1 }, /* (353) function_expression ::= literal_func */ - { 326, -3 }, /* (354) literal_func ::= noarg_func NK_LP NK_RP */ - { 326, -1 }, /* (355) literal_func ::= NOW */ - { 337, -1 }, /* (356) noarg_func ::= NOW */ - { 337, -1 }, /* (357) noarg_func ::= TODAY */ - { 337, -1 }, /* (358) noarg_func ::= TIMEZONE */ - { 337, -1 }, /* (359) noarg_func ::= DATABASE */ - { 337, -1 }, /* (360) noarg_func ::= CLIENT_VERSION */ - { 337, -1 }, /* (361) noarg_func ::= SERVER_VERSION */ - { 337, -1 }, /* (362) noarg_func ::= SERVER_STATUS */ - { 337, -1 }, /* (363) noarg_func ::= CURRENT_USER */ - { 337, -1 }, /* (364) noarg_func ::= USER */ - { 335, -1 }, /* (365) star_func ::= COUNT */ - { 335, -1 }, /* (366) star_func ::= FIRST */ - { 335, -1 }, /* (367) star_func ::= LAST */ - { 335, -1 }, /* (368) star_func ::= LAST_ROW */ - { 336, -1 }, /* (369) star_func_para_list ::= NK_STAR */ - { 336, -1 }, /* (370) star_func_para_list ::= other_para_list */ - { 338, -1 }, /* (371) other_para_list ::= star_func_para */ - { 338, -3 }, /* (372) other_para_list ::= other_para_list NK_COMMA star_func_para */ - { 339, -1 }, /* (373) star_func_para ::= expression */ - { 339, -3 }, /* (374) star_func_para ::= table_name NK_DOT NK_STAR */ - { 340, -3 }, /* (375) predicate ::= expression compare_op expression */ - { 340, -5 }, /* (376) predicate ::= expression BETWEEN expression AND expression */ - { 340, -6 }, /* (377) predicate ::= expression NOT BETWEEN expression AND expression */ - { 340, -3 }, /* (378) predicate ::= expression IS NULL */ - { 340, -4 }, /* (379) predicate ::= expression IS NOT NULL */ - { 340, -3 }, /* (380) predicate ::= expression in_op in_predicate_value */ - { 341, -1 }, /* (381) compare_op ::= NK_LT */ - { 341, -1 }, /* (382) compare_op ::= NK_GT */ - { 341, -1 }, /* (383) compare_op ::= NK_LE */ - { 341, -1 }, /* (384) compare_op ::= NK_GE */ - { 341, -1 }, /* (385) compare_op ::= NK_NE */ - { 341, -1 }, /* (386) compare_op ::= NK_EQ */ - { 341, -1 }, /* (387) compare_op ::= LIKE */ - { 341, -2 }, /* (388) compare_op ::= NOT LIKE */ - { 341, -1 }, /* (389) compare_op ::= MATCH */ - { 341, -1 }, /* (390) compare_op ::= NMATCH */ - { 341, -1 }, /* (391) compare_op ::= CONTAINS */ - { 342, -1 }, /* (392) in_op ::= IN */ - { 342, -2 }, /* (393) in_op ::= NOT IN */ - { 343, -3 }, /* (394) in_predicate_value ::= NK_LP literal_list NK_RP */ - { 344, -1 }, /* (395) boolean_value_expression ::= boolean_primary */ - { 344, -2 }, /* (396) boolean_value_expression ::= NOT boolean_primary */ - { 344, -3 }, /* (397) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ - { 344, -3 }, /* (398) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ - { 345, -1 }, /* (399) boolean_primary ::= predicate */ - { 345, -3 }, /* (400) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ - { 346, -1 }, /* (401) common_expression ::= expression */ - { 346, -1 }, /* (402) common_expression ::= boolean_value_expression */ - { 347, 0 }, /* (403) from_clause_opt ::= */ - { 347, -2 }, /* (404) from_clause_opt ::= FROM table_reference_list */ - { 348, -1 }, /* (405) table_reference_list ::= table_reference */ - { 348, -3 }, /* (406) table_reference_list ::= table_reference_list NK_COMMA table_reference */ - { 349, -1 }, /* (407) table_reference ::= table_primary */ - { 349, -1 }, /* (408) table_reference ::= joined_table */ - { 350, -2 }, /* (409) table_primary ::= table_name alias_opt */ - { 350, -4 }, /* (410) table_primary ::= db_name NK_DOT table_name alias_opt */ - { 350, -2 }, /* (411) table_primary ::= subquery alias_opt */ - { 350, -1 }, /* (412) table_primary ::= parenthesized_joined_table */ - { 352, 0 }, /* (413) alias_opt ::= */ - { 352, -1 }, /* (414) alias_opt ::= table_alias */ - { 352, -2 }, /* (415) alias_opt ::= AS table_alias */ - { 353, -3 }, /* (416) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - { 353, -3 }, /* (417) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ - { 351, -6 }, /* (418) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ - { 354, 0 }, /* (419) join_type ::= */ - { 354, -1 }, /* (420) join_type ::= INNER */ - { 356, -12 }, /* (421) query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ - { 357, 0 }, /* (422) set_quantifier_opt ::= */ - { 357, -1 }, /* (423) set_quantifier_opt ::= DISTINCT */ - { 357, -1 }, /* (424) set_quantifier_opt ::= ALL */ - { 358, -1 }, /* (425) select_list ::= select_item */ - { 358, -3 }, /* (426) select_list ::= select_list NK_COMMA select_item */ - { 366, -1 }, /* (427) select_item ::= NK_STAR */ - { 366, -1 }, /* (428) select_item ::= common_expression */ - { 366, -2 }, /* (429) select_item ::= common_expression column_alias */ - { 366, -3 }, /* (430) select_item ::= common_expression AS column_alias */ - { 366, -3 }, /* (431) select_item ::= table_name NK_DOT NK_STAR */ - { 324, 0 }, /* (432) where_clause_opt ::= */ - { 324, -2 }, /* (433) where_clause_opt ::= WHERE search_condition */ - { 359, 0 }, /* (434) partition_by_clause_opt ::= */ - { 359, -3 }, /* (435) partition_by_clause_opt ::= PARTITION BY expression_list */ - { 363, 0 }, /* (436) twindow_clause_opt ::= */ - { 363, -6 }, /* (437) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ - { 363, -4 }, /* (438) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */ - { 363, -6 }, /* (439) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ - { 363, -8 }, /* (440) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ - { 310, 0 }, /* (441) sliding_opt ::= */ - { 310, -4 }, /* (442) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ - { 362, 0 }, /* (443) fill_opt ::= */ - { 362, -4 }, /* (444) fill_opt ::= FILL NK_LP fill_mode NK_RP */ - { 362, -6 }, /* (445) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ - { 367, -1 }, /* (446) fill_mode ::= NONE */ - { 367, -1 }, /* (447) fill_mode ::= PREV */ - { 367, -1 }, /* (448) fill_mode ::= NULL */ - { 367, -1 }, /* (449) fill_mode ::= LINEAR */ - { 367, -1 }, /* (450) fill_mode ::= NEXT */ - { 364, 0 }, /* (451) group_by_clause_opt ::= */ - { 364, -3 }, /* (452) group_by_clause_opt ::= GROUP BY group_by_list */ - { 368, -1 }, /* (453) group_by_list ::= expression */ - { 368, -3 }, /* (454) group_by_list ::= group_by_list NK_COMMA expression */ - { 365, 0 }, /* (455) having_clause_opt ::= */ - { 365, -2 }, /* (456) having_clause_opt ::= HAVING search_condition */ - { 360, 0 }, /* (457) range_opt ::= */ - { 360, -6 }, /* (458) range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP */ - { 361, 0 }, /* (459) every_opt ::= */ - { 361, -4 }, /* (460) every_opt ::= EVERY NK_LP duration_literal NK_RP */ - { 315, -4 }, /* (461) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ - { 369, -1 }, /* (462) query_expression_body ::= query_primary */ - { 369, -4 }, /* (463) query_expression_body ::= query_expression_body UNION ALL query_expression_body */ - { 369, -3 }, /* (464) query_expression_body ::= query_expression_body UNION query_expression_body */ - { 373, -1 }, /* (465) query_primary ::= query_specification */ - { 373, -6 }, /* (466) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */ - { 370, 0 }, /* (467) order_by_clause_opt ::= */ - { 370, -3 }, /* (468) order_by_clause_opt ::= ORDER BY sort_specification_list */ - { 371, 0 }, /* (469) slimit_clause_opt ::= */ - { 371, -2 }, /* (470) slimit_clause_opt ::= SLIMIT NK_INTEGER */ - { 371, -4 }, /* (471) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - { 371, -4 }, /* (472) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - { 372, 0 }, /* (473) limit_clause_opt ::= */ - { 372, -2 }, /* (474) limit_clause_opt ::= LIMIT NK_INTEGER */ - { 372, -4 }, /* (475) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ - { 372, -4 }, /* (476) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - { 334, -3 }, /* (477) subquery ::= NK_LP query_expression NK_RP */ - { 355, -1 }, /* (478) search_condition ::= common_expression */ - { 374, -1 }, /* (479) sort_specification_list ::= sort_specification */ - { 374, -3 }, /* (480) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ - { 375, -3 }, /* (481) sort_specification ::= expression ordering_specification_opt null_ordering_opt */ - { 376, 0 }, /* (482) ordering_specification_opt ::= */ - { 376, -1 }, /* (483) ordering_specification_opt ::= ASC */ - { 376, -1 }, /* (484) ordering_specification_opt ::= DESC */ - { 377, 0 }, /* (485) null_ordering_opt ::= */ - { 377, -2 }, /* (486) null_ordering_opt ::= NULLS FIRST */ - { 377, -2 }, /* (487) null_ordering_opt ::= NULLS LAST */ + { 288, -1 }, /* (309) signed_literal ::= NK_QUESTION */ + { 327, -1 }, /* (310) literal_list ::= signed_literal */ + { 327, -3 }, /* (311) literal_list ::= literal_list NK_COMMA signed_literal */ + { 266, -1 }, /* (312) db_name ::= NK_ID */ + { 294, -1 }, /* (313) table_name ::= NK_ID */ + { 286, -1 }, /* (314) column_name ::= NK_ID */ + { 301, -1 }, /* (315) function_name ::= NK_ID */ + { 328, -1 }, /* (316) table_alias ::= NK_ID */ + { 329, -1 }, /* (317) column_alias ::= NK_ID */ + { 260, -1 }, /* (318) user_name ::= NK_ID */ + { 307, -1 }, /* (319) index_name ::= NK_ID */ + { 314, -1 }, /* (320) topic_name ::= NK_ID */ + { 321, -1 }, /* (321) stream_name ::= NK_ID */ + { 316, -1 }, /* (322) cgroup_name ::= NK_ID */ + { 330, -1 }, /* (323) expression ::= literal */ + { 330, -1 }, /* (324) expression ::= pseudo_column */ + { 330, -1 }, /* (325) expression ::= column_reference */ + { 330, -1 }, /* (326) expression ::= function_expression */ + { 330, -1 }, /* (327) expression ::= subquery */ + { 330, -3 }, /* (328) expression ::= NK_LP expression NK_RP */ + { 330, -2 }, /* (329) expression ::= NK_PLUS expression */ + { 330, -2 }, /* (330) expression ::= NK_MINUS expression */ + { 330, -3 }, /* (331) expression ::= expression NK_PLUS expression */ + { 330, -3 }, /* (332) expression ::= expression NK_MINUS expression */ + { 330, -3 }, /* (333) expression ::= expression NK_STAR expression */ + { 330, -3 }, /* (334) expression ::= expression NK_SLASH expression */ + { 330, -3 }, /* (335) expression ::= expression NK_REM expression */ + { 330, -3 }, /* (336) expression ::= column_reference NK_ARROW NK_STRING */ + { 330, -3 }, /* (337) expression ::= expression NK_BITAND expression */ + { 330, -3 }, /* (338) expression ::= expression NK_BITOR expression */ + { 291, -1 }, /* (339) expression_list ::= expression */ + { 291, -3 }, /* (340) expression_list ::= expression_list NK_COMMA expression */ + { 332, -1 }, /* (341) column_reference ::= column_name */ + { 332, -3 }, /* (342) column_reference ::= table_name NK_DOT column_name */ + { 331, -1 }, /* (343) pseudo_column ::= ROWTS */ + { 331, -1 }, /* (344) pseudo_column ::= TBNAME */ + { 331, -3 }, /* (345) pseudo_column ::= table_name NK_DOT TBNAME */ + { 331, -1 }, /* (346) pseudo_column ::= QSTARTTS */ + { 331, -1 }, /* (347) pseudo_column ::= QENDTS */ + { 331, -1 }, /* (348) pseudo_column ::= WSTARTTS */ + { 331, -1 }, /* (349) pseudo_column ::= WENDTS */ + { 331, -1 }, /* (350) pseudo_column ::= WDURATION */ + { 333, -4 }, /* (351) function_expression ::= function_name NK_LP expression_list NK_RP */ + { 333, -4 }, /* (352) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ + { 333, -6 }, /* (353) function_expression ::= CAST NK_LP expression AS type_name NK_RP */ + { 333, -1 }, /* (354) function_expression ::= literal_func */ + { 326, -3 }, /* (355) literal_func ::= noarg_func NK_LP NK_RP */ + { 326, -1 }, /* (356) literal_func ::= NOW */ + { 337, -1 }, /* (357) noarg_func ::= NOW */ + { 337, -1 }, /* (358) noarg_func ::= TODAY */ + { 337, -1 }, /* (359) noarg_func ::= TIMEZONE */ + { 337, -1 }, /* (360) noarg_func ::= DATABASE */ + { 337, -1 }, /* (361) noarg_func ::= CLIENT_VERSION */ + { 337, -1 }, /* (362) noarg_func ::= SERVER_VERSION */ + { 337, -1 }, /* (363) noarg_func ::= SERVER_STATUS */ + { 337, -1 }, /* (364) noarg_func ::= CURRENT_USER */ + { 337, -1 }, /* (365) noarg_func ::= USER */ + { 335, -1 }, /* (366) star_func ::= COUNT */ + { 335, -1 }, /* (367) star_func ::= FIRST */ + { 335, -1 }, /* (368) star_func ::= LAST */ + { 335, -1 }, /* (369) star_func ::= LAST_ROW */ + { 336, -1 }, /* (370) star_func_para_list ::= NK_STAR */ + { 336, -1 }, /* (371) star_func_para_list ::= other_para_list */ + { 338, -1 }, /* (372) other_para_list ::= star_func_para */ + { 338, -3 }, /* (373) other_para_list ::= other_para_list NK_COMMA star_func_para */ + { 339, -1 }, /* (374) star_func_para ::= expression */ + { 339, -3 }, /* (375) star_func_para ::= table_name NK_DOT NK_STAR */ + { 340, -3 }, /* (376) predicate ::= expression compare_op expression */ + { 340, -5 }, /* (377) predicate ::= expression BETWEEN expression AND expression */ + { 340, -6 }, /* (378) predicate ::= expression NOT BETWEEN expression AND expression */ + { 340, -3 }, /* (379) predicate ::= expression IS NULL */ + { 340, -4 }, /* (380) predicate ::= expression IS NOT NULL */ + { 340, -3 }, /* (381) predicate ::= expression in_op in_predicate_value */ + { 341, -1 }, /* (382) compare_op ::= NK_LT */ + { 341, -1 }, /* (383) compare_op ::= NK_GT */ + { 341, -1 }, /* (384) compare_op ::= NK_LE */ + { 341, -1 }, /* (385) compare_op ::= NK_GE */ + { 341, -1 }, /* (386) compare_op ::= NK_NE */ + { 341, -1 }, /* (387) compare_op ::= NK_EQ */ + { 341, -1 }, /* (388) compare_op ::= LIKE */ + { 341, -2 }, /* (389) compare_op ::= NOT LIKE */ + { 341, -1 }, /* (390) compare_op ::= MATCH */ + { 341, -1 }, /* (391) compare_op ::= NMATCH */ + { 341, -1 }, /* (392) compare_op ::= CONTAINS */ + { 342, -1 }, /* (393) in_op ::= IN */ + { 342, -2 }, /* (394) in_op ::= NOT IN */ + { 343, -3 }, /* (395) in_predicate_value ::= NK_LP literal_list NK_RP */ + { 344, -1 }, /* (396) boolean_value_expression ::= boolean_primary */ + { 344, -2 }, /* (397) boolean_value_expression ::= NOT boolean_primary */ + { 344, -3 }, /* (398) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ + { 344, -3 }, /* (399) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ + { 345, -1 }, /* (400) boolean_primary ::= predicate */ + { 345, -3 }, /* (401) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ + { 346, -1 }, /* (402) common_expression ::= expression */ + { 346, -1 }, /* (403) common_expression ::= boolean_value_expression */ + { 347, 0 }, /* (404) from_clause_opt ::= */ + { 347, -2 }, /* (405) from_clause_opt ::= FROM table_reference_list */ + { 348, -1 }, /* (406) table_reference_list ::= table_reference */ + { 348, -3 }, /* (407) table_reference_list ::= table_reference_list NK_COMMA table_reference */ + { 349, -1 }, /* (408) table_reference ::= table_primary */ + { 349, -1 }, /* (409) table_reference ::= joined_table */ + { 350, -2 }, /* (410) table_primary ::= table_name alias_opt */ + { 350, -4 }, /* (411) table_primary ::= db_name NK_DOT table_name alias_opt */ + { 350, -2 }, /* (412) table_primary ::= subquery alias_opt */ + { 350, -1 }, /* (413) table_primary ::= parenthesized_joined_table */ + { 352, 0 }, /* (414) alias_opt ::= */ + { 352, -1 }, /* (415) alias_opt ::= table_alias */ + { 352, -2 }, /* (416) alias_opt ::= AS table_alias */ + { 353, -3 }, /* (417) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ + { 353, -3 }, /* (418) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ + { 351, -6 }, /* (419) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ + { 354, 0 }, /* (420) join_type ::= */ + { 354, -1 }, /* (421) join_type ::= INNER */ + { 356, -12 }, /* (422) query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ + { 357, 0 }, /* (423) set_quantifier_opt ::= */ + { 357, -1 }, /* (424) set_quantifier_opt ::= DISTINCT */ + { 357, -1 }, /* (425) set_quantifier_opt ::= ALL */ + { 358, -1 }, /* (426) select_list ::= select_item */ + { 358, -3 }, /* (427) select_list ::= select_list NK_COMMA select_item */ + { 366, -1 }, /* (428) select_item ::= NK_STAR */ + { 366, -1 }, /* (429) select_item ::= common_expression */ + { 366, -2 }, /* (430) select_item ::= common_expression column_alias */ + { 366, -3 }, /* (431) select_item ::= common_expression AS column_alias */ + { 366, -3 }, /* (432) select_item ::= table_name NK_DOT NK_STAR */ + { 324, 0 }, /* (433) where_clause_opt ::= */ + { 324, -2 }, /* (434) where_clause_opt ::= WHERE search_condition */ + { 359, 0 }, /* (435) partition_by_clause_opt ::= */ + { 359, -3 }, /* (436) partition_by_clause_opt ::= PARTITION BY expression_list */ + { 363, 0 }, /* (437) twindow_clause_opt ::= */ + { 363, -6 }, /* (438) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ + { 363, -4 }, /* (439) twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */ + { 363, -6 }, /* (440) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ + { 363, -8 }, /* (441) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ + { 310, 0 }, /* (442) sliding_opt ::= */ + { 310, -4 }, /* (443) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ + { 362, 0 }, /* (444) fill_opt ::= */ + { 362, -4 }, /* (445) fill_opt ::= FILL NK_LP fill_mode NK_RP */ + { 362, -6 }, /* (446) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ + { 367, -1 }, /* (447) fill_mode ::= NONE */ + { 367, -1 }, /* (448) fill_mode ::= PREV */ + { 367, -1 }, /* (449) fill_mode ::= NULL */ + { 367, -1 }, /* (450) fill_mode ::= LINEAR */ + { 367, -1 }, /* (451) fill_mode ::= NEXT */ + { 364, 0 }, /* (452) group_by_clause_opt ::= */ + { 364, -3 }, /* (453) group_by_clause_opt ::= GROUP BY group_by_list */ + { 368, -1 }, /* (454) group_by_list ::= expression */ + { 368, -3 }, /* (455) group_by_list ::= group_by_list NK_COMMA expression */ + { 365, 0 }, /* (456) having_clause_opt ::= */ + { 365, -2 }, /* (457) having_clause_opt ::= HAVING search_condition */ + { 360, 0 }, /* (458) range_opt ::= */ + { 360, -6 }, /* (459) range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP */ + { 361, 0 }, /* (460) every_opt ::= */ + { 361, -4 }, /* (461) every_opt ::= EVERY NK_LP duration_literal NK_RP */ + { 315, -4 }, /* (462) query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ + { 369, -1 }, /* (463) query_expression_body ::= query_primary */ + { 369, -4 }, /* (464) query_expression_body ::= query_expression_body UNION ALL query_expression_body */ + { 369, -3 }, /* (465) query_expression_body ::= query_expression_body UNION query_expression_body */ + { 373, -1 }, /* (466) query_primary ::= query_specification */ + { 373, -6 }, /* (467) query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */ + { 370, 0 }, /* (468) order_by_clause_opt ::= */ + { 370, -3 }, /* (469) order_by_clause_opt ::= ORDER BY sort_specification_list */ + { 371, 0 }, /* (470) slimit_clause_opt ::= */ + { 371, -2 }, /* (471) slimit_clause_opt ::= SLIMIT NK_INTEGER */ + { 371, -4 }, /* (472) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + { 371, -4 }, /* (473) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + { 372, 0 }, /* (474) limit_clause_opt ::= */ + { 372, -2 }, /* (475) limit_clause_opt ::= LIMIT NK_INTEGER */ + { 372, -4 }, /* (476) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ + { 372, -4 }, /* (477) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + { 334, -3 }, /* (478) subquery ::= NK_LP query_expression NK_RP */ + { 355, -1 }, /* (479) search_condition ::= common_expression */ + { 374, -1 }, /* (480) sort_specification_list ::= sort_specification */ + { 374, -3 }, /* (481) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ + { 375, -3 }, /* (482) sort_specification ::= expression ordering_specification_opt null_ordering_opt */ + { 376, 0 }, /* (483) ordering_specification_opt ::= */ + { 376, -1 }, /* (484) ordering_specification_opt ::= ASC */ + { 376, -1 }, /* (485) ordering_specification_opt ::= DESC */ + { 377, 0 }, /* (486) null_ordering_opt ::= */ + { 377, -2 }, /* (487) null_ordering_opt ::= NULLS FIRST */ + { 377, -2 }, /* (488) null_ordering_opt ::= NULLS LAST */ }; static void yy_accept(yyParser*); /* Forward Declaration */ @@ -3434,30 +3396,30 @@ static YYACTIONTYPE yy_reduce( case 49: /* dnode_endpoint ::= NK_STRING */ case 50: /* dnode_endpoint ::= NK_ID */ yytestcase(yyruleno==50); case 51: /* dnode_endpoint ::= NK_IPTOKEN */ yytestcase(yyruleno==51); - case 311: /* db_name ::= NK_ID */ yytestcase(yyruleno==311); - case 312: /* table_name ::= NK_ID */ yytestcase(yyruleno==312); - case 313: /* column_name ::= NK_ID */ yytestcase(yyruleno==313); - case 314: /* function_name ::= NK_ID */ yytestcase(yyruleno==314); - case 315: /* table_alias ::= NK_ID */ yytestcase(yyruleno==315); - case 316: /* column_alias ::= NK_ID */ yytestcase(yyruleno==316); - case 317: /* user_name ::= NK_ID */ yytestcase(yyruleno==317); - case 318: /* index_name ::= NK_ID */ yytestcase(yyruleno==318); - case 319: /* topic_name ::= NK_ID */ yytestcase(yyruleno==319); - case 320: /* stream_name ::= NK_ID */ yytestcase(yyruleno==320); - case 321: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==321); - case 356: /* noarg_func ::= NOW */ yytestcase(yyruleno==356); - case 357: /* noarg_func ::= TODAY */ yytestcase(yyruleno==357); - case 358: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==358); - case 359: /* noarg_func ::= DATABASE */ yytestcase(yyruleno==359); - case 360: /* noarg_func ::= CLIENT_VERSION */ yytestcase(yyruleno==360); - case 361: /* noarg_func ::= SERVER_VERSION */ yytestcase(yyruleno==361); - case 362: /* noarg_func ::= SERVER_STATUS */ yytestcase(yyruleno==362); - case 363: /* noarg_func ::= CURRENT_USER */ yytestcase(yyruleno==363); - case 364: /* noarg_func ::= USER */ yytestcase(yyruleno==364); - case 365: /* star_func ::= COUNT */ yytestcase(yyruleno==365); - case 366: /* star_func ::= FIRST */ yytestcase(yyruleno==366); - case 367: /* star_func ::= LAST */ yytestcase(yyruleno==367); - case 368: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==368); + case 312: /* db_name ::= NK_ID */ yytestcase(yyruleno==312); + case 313: /* table_name ::= NK_ID */ yytestcase(yyruleno==313); + case 314: /* column_name ::= NK_ID */ yytestcase(yyruleno==314); + case 315: /* function_name ::= NK_ID */ yytestcase(yyruleno==315); + case 316: /* table_alias ::= NK_ID */ yytestcase(yyruleno==316); + case 317: /* column_alias ::= NK_ID */ yytestcase(yyruleno==317); + case 318: /* user_name ::= NK_ID */ yytestcase(yyruleno==318); + case 319: /* index_name ::= NK_ID */ yytestcase(yyruleno==319); + case 320: /* topic_name ::= NK_ID */ yytestcase(yyruleno==320); + case 321: /* stream_name ::= NK_ID */ yytestcase(yyruleno==321); + case 322: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==322); + case 357: /* noarg_func ::= NOW */ yytestcase(yyruleno==357); + case 358: /* noarg_func ::= TODAY */ yytestcase(yyruleno==358); + case 359: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==359); + case 360: /* noarg_func ::= DATABASE */ yytestcase(yyruleno==360); + case 361: /* noarg_func ::= CLIENT_VERSION */ yytestcase(yyruleno==361); + case 362: /* noarg_func ::= SERVER_VERSION */ yytestcase(yyruleno==362); + case 363: /* noarg_func ::= SERVER_STATUS */ yytestcase(yyruleno==363); + case 364: /* noarg_func ::= CURRENT_USER */ yytestcase(yyruleno==364); + case 365: /* noarg_func ::= USER */ yytestcase(yyruleno==365); + case 366: /* star_func ::= COUNT */ yytestcase(yyruleno==366); + case 367: /* star_func ::= FIRST */ yytestcase(yyruleno==367); + case 368: /* star_func ::= LAST */ yytestcase(yyruleno==368); + case 369: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==369); { yylhsminor.yy533 = yymsp[0].minor.yy0; } yymsp[0].minor.yy533 = yylhsminor.yy533; break; @@ -3516,7 +3478,7 @@ static YYACTIONTYPE yy_reduce( case 71: /* exists_opt ::= */ yytestcase(yyruleno==71); case 252: /* analyze_opt ::= */ yytestcase(yyruleno==252); case 260: /* agg_func_opt ::= */ yytestcase(yyruleno==260); - case 422: /* set_quantifier_opt ::= */ yytestcase(yyruleno==422); + case 423: /* set_quantifier_opt ::= */ yytestcase(yyruleno==423); { yymsp[1].minor.yy173 = false; } break; case 70: /* exists_opt ::= IF EXISTS */ @@ -3663,10 +3625,10 @@ static YYACTIONTYPE yy_reduce( case 183: /* rollup_func_list ::= rollup_func_name */ yytestcase(yyruleno==183); case 188: /* col_name_list ::= col_name */ yytestcase(yyruleno==188); case 235: /* func_list ::= func */ yytestcase(yyruleno==235); - case 309: /* literal_list ::= signed_literal */ yytestcase(yyruleno==309); - case 371: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==371); - case 425: /* select_list ::= select_item */ yytestcase(yyruleno==425); - case 479: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==479); + case 310: /* literal_list ::= signed_literal */ yytestcase(yyruleno==310); + case 372: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==372); + case 426: /* select_list ::= select_item */ yytestcase(yyruleno==426); + case 480: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==480); { yylhsminor.yy712 = createNodeList(pCxt, yymsp[0].minor.yy560); } yymsp[0].minor.yy712 = yylhsminor.yy712; break; @@ -3675,10 +3637,10 @@ static YYACTIONTYPE yy_reduce( case 184: /* rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ yytestcase(yyruleno==184); case 189: /* col_name_list ::= col_name_list NK_COMMA col_name */ yytestcase(yyruleno==189); case 236: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==236); - case 310: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==310); - case 372: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==372); - case 426: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==426); - case 480: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==480); + case 311: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==311); + case 373: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==373); + case 427: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==427); + case 481: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==481); { yylhsminor.yy712 = addNodeToList(pCxt, yymsp[-2].minor.yy712, yymsp[0].minor.yy560); } yymsp[-2].minor.yy712 = yylhsminor.yy712; break; @@ -3761,9 +3723,9 @@ static YYACTIONTYPE yy_reduce( break; case 136: /* specific_cols_opt ::= */ case 167: /* tags_def_opt ::= */ yytestcase(yyruleno==167); - case 434: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==434); - case 451: /* group_by_clause_opt ::= */ yytestcase(yyruleno==451); - case 467: /* order_by_clause_opt ::= */ yytestcase(yyruleno==467); + case 435: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==435); + case 452: /* group_by_clause_opt ::= */ yytestcase(yyruleno==452); + case 468: /* order_by_clause_opt ::= */ yytestcase(yyruleno==468); { yymsp[1].minor.yy712 = NULL; } break; case 137: /* specific_cols_opt ::= NK_LP col_name_list NK_RP */ @@ -3853,7 +3815,7 @@ static YYACTIONTYPE yy_reduce( { yymsp[-5].minor.yy196 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; case 168: /* tags_def_opt ::= tags_def */ - case 370: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==370); + case 371: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==371); { yylhsminor.yy712 = yymsp[0].minor.yy712; } yymsp[0].minor.yy712 = yylhsminor.yy712; break; @@ -3902,12 +3864,12 @@ static YYACTIONTYPE yy_reduce( { yymsp[-1].minor.yy389.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy389.val = yymsp[0].minor.yy0; } break; case 181: /* duration_list ::= duration_literal */ - case 338: /* expression_list ::= expression */ yytestcase(yyruleno==338); + case 339: /* expression_list ::= expression */ yytestcase(yyruleno==339); { yylhsminor.yy712 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy560)); } yymsp[0].minor.yy712 = yylhsminor.yy712; break; case 182: /* duration_list ::= duration_list NK_COMMA duration_literal */ - case 339: /* expression_list ::= expression_list NK_COMMA expression */ yytestcase(yyruleno==339); + case 340: /* expression_list ::= expression_list NK_COMMA expression */ yytestcase(yyruleno==340); { yylhsminor.yy712 = addNodeToList(pCxt, yymsp[-2].minor.yy712, releaseRawExprNode(pCxt, yymsp[0].minor.yy560)); } yymsp[-2].minor.yy712 = yylhsminor.yy712; break; @@ -4031,16 +3993,16 @@ static YYACTIONTYPE yy_reduce( break; case 226: /* like_pattern_opt ::= */ case 266: /* into_opt ::= */ yytestcase(yyruleno==266); - case 403: /* from_clause_opt ::= */ yytestcase(yyruleno==403); - case 432: /* where_clause_opt ::= */ yytestcase(yyruleno==432); - case 436: /* twindow_clause_opt ::= */ yytestcase(yyruleno==436); - case 441: /* sliding_opt ::= */ yytestcase(yyruleno==441); - case 443: /* fill_opt ::= */ yytestcase(yyruleno==443); - case 455: /* having_clause_opt ::= */ yytestcase(yyruleno==455); - case 457: /* range_opt ::= */ yytestcase(yyruleno==457); - case 459: /* every_opt ::= */ yytestcase(yyruleno==459); - case 469: /* slimit_clause_opt ::= */ yytestcase(yyruleno==469); - case 473: /* limit_clause_opt ::= */ yytestcase(yyruleno==473); + case 404: /* from_clause_opt ::= */ yytestcase(yyruleno==404); + case 433: /* where_clause_opt ::= */ yytestcase(yyruleno==433); + case 437: /* twindow_clause_opt ::= */ yytestcase(yyruleno==437); + case 442: /* sliding_opt ::= */ yytestcase(yyruleno==442); + case 444: /* fill_opt ::= */ yytestcase(yyruleno==444); + case 456: /* having_clause_opt ::= */ yytestcase(yyruleno==456); + case 458: /* range_opt ::= */ yytestcase(yyruleno==458); + case 460: /* every_opt ::= */ yytestcase(yyruleno==460); + case 470: /* slimit_clause_opt ::= */ yytestcase(yyruleno==470); + case 474: /* limit_clause_opt ::= */ yytestcase(yyruleno==474); { yymsp[1].minor.yy560 = NULL; } break; case 227: /* like_pattern_opt ::= LIKE NK_STRING */ @@ -4115,7 +4077,7 @@ static YYACTIONTYPE yy_reduce( break; case 253: /* analyze_opt ::= ANALYZE */ case 261: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==261); - case 423: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==423); + case 424: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==424); { yymsp[0].minor.yy173 = true; } break; case 254: /* explain_options ::= */ @@ -4151,9 +4113,9 @@ static YYACTIONTYPE yy_reduce( { pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy173, &yymsp[0].minor.yy533); } break; case 267: /* into_opt ::= INTO full_table_name */ - case 404: /* from_clause_opt ::= FROM table_reference_list */ yytestcase(yyruleno==404); - case 433: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==433); - case 456: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==456); + case 405: /* from_clause_opt ::= FROM table_reference_list */ yytestcase(yyruleno==405); + case 434: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==434); + case 457: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==457); { yymsp[-1].minor.yy560 = yymsp[0].minor.yy560; } break; case 269: /* stream_options ::= stream_options TRIGGER AT_ONCE */ @@ -4227,22 +4189,22 @@ static YYACTIONTYPE yy_reduce( break; case 292: /* literal ::= duration_literal */ case 302: /* signed_literal ::= signed */ yytestcase(yyruleno==302); - case 322: /* expression ::= literal */ yytestcase(yyruleno==322); - case 323: /* expression ::= pseudo_column */ yytestcase(yyruleno==323); - case 324: /* expression ::= column_reference */ yytestcase(yyruleno==324); - case 325: /* expression ::= function_expression */ yytestcase(yyruleno==325); - case 326: /* expression ::= subquery */ yytestcase(yyruleno==326); - case 353: /* function_expression ::= literal_func */ yytestcase(yyruleno==353); - case 395: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==395); - case 399: /* boolean_primary ::= predicate */ yytestcase(yyruleno==399); - case 401: /* common_expression ::= expression */ yytestcase(yyruleno==401); - case 402: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==402); - case 405: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==405); - case 407: /* table_reference ::= table_primary */ yytestcase(yyruleno==407); - case 408: /* table_reference ::= joined_table */ yytestcase(yyruleno==408); - case 412: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==412); - case 462: /* query_expression_body ::= query_primary */ yytestcase(yyruleno==462); - case 465: /* query_primary ::= query_specification */ yytestcase(yyruleno==465); + case 323: /* expression ::= literal */ yytestcase(yyruleno==323); + case 324: /* expression ::= pseudo_column */ yytestcase(yyruleno==324); + case 325: /* expression ::= column_reference */ yytestcase(yyruleno==325); + case 326: /* expression ::= function_expression */ yytestcase(yyruleno==326); + case 327: /* expression ::= subquery */ yytestcase(yyruleno==327); + case 354: /* function_expression ::= literal_func */ yytestcase(yyruleno==354); + case 396: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==396); + case 400: /* boolean_primary ::= predicate */ yytestcase(yyruleno==400); + case 402: /* common_expression ::= expression */ yytestcase(yyruleno==402); + case 403: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==403); + case 406: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==406); + case 408: /* table_reference ::= table_primary */ yytestcase(yyruleno==408); + case 409: /* table_reference ::= joined_table */ yytestcase(yyruleno==409); + case 413: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==413); + case 463: /* query_expression_body ::= query_primary */ yytestcase(yyruleno==463); + case 466: /* query_primary ::= query_specification */ yytestcase(yyruleno==466); { yylhsminor.yy560 = yymsp[0].minor.yy560; } yymsp[0].minor.yy560 = yylhsminor.yy560; break; @@ -4301,9 +4263,9 @@ static YYACTIONTYPE yy_reduce( break; case 306: /* signed_literal ::= duration_literal */ case 308: /* signed_literal ::= literal_func */ yytestcase(yyruleno==308); - case 373: /* star_func_para ::= expression */ yytestcase(yyruleno==373); - case 428: /* select_item ::= common_expression */ yytestcase(yyruleno==428); - case 478: /* search_condition ::= common_expression */ yytestcase(yyruleno==478); + case 374: /* star_func_para ::= expression */ yytestcase(yyruleno==374); + case 429: /* select_item ::= common_expression */ yytestcase(yyruleno==429); + case 479: /* search_condition ::= common_expression */ yytestcase(yyruleno==479); { yylhsminor.yy560 = releaseRawExprNode(pCxt, yymsp[0].minor.yy560); } yymsp[0].minor.yy560 = yylhsminor.yy560; break; @@ -4311,26 +4273,30 @@ static YYACTIONTYPE yy_reduce( { yylhsminor.yy560 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); } yymsp[0].minor.yy560 = yylhsminor.yy560; break; - case 327: /* expression ::= NK_LP expression NK_RP */ - case 400: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==400); + case 309: /* signed_literal ::= NK_QUESTION */ +{ yylhsminor.yy560 = createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy560 = yylhsminor.yy560; + break; + case 328: /* expression ::= NK_LP expression NK_RP */ + case 401: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==401); { yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy560)); } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 328: /* expression ::= NK_PLUS expression */ + case 329: /* expression ::= NK_PLUS expression */ { SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560); yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy560)); } yymsp[-1].minor.yy560 = yylhsminor.yy560; break; - case 329: /* expression ::= NK_MINUS expression */ + case 330: /* expression ::= NK_MINUS expression */ { SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560); yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy560), NULL)); } yymsp[-1].minor.yy560 = yylhsminor.yy560; break; - case 330: /* expression ::= expression NK_PLUS expression */ + case 331: /* expression ::= expression NK_PLUS expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560); @@ -4338,7 +4304,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 331: /* expression ::= expression NK_MINUS expression */ + case 332: /* expression ::= expression NK_MINUS expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560); @@ -4346,7 +4312,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 332: /* expression ::= expression NK_STAR expression */ + case 333: /* expression ::= expression NK_STAR expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560); @@ -4354,7 +4320,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 333: /* expression ::= expression NK_SLASH expression */ + case 334: /* expression ::= expression NK_SLASH expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560); @@ -4362,7 +4328,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 334: /* expression ::= expression NK_REM expression */ + case 335: /* expression ::= expression NK_REM expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560); @@ -4370,14 +4336,14 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 335: /* expression ::= column_reference NK_ARROW NK_STRING */ + case 336: /* expression ::= column_reference NK_ARROW NK_STRING */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560); yylhsminor.yy560 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy560), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0))); } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 336: /* expression ::= expression NK_BITAND expression */ + case 337: /* expression ::= expression NK_BITAND expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560); @@ -4385,7 +4351,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 337: /* expression ::= expression NK_BITOR expression */ + case 338: /* expression ::= expression NK_BITOR expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560); @@ -4393,53 +4359,53 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 340: /* column_reference ::= column_name */ + case 341: /* column_reference ::= column_name */ { yylhsminor.yy560 = createRawExprNode(pCxt, &yymsp[0].minor.yy533, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy533)); } yymsp[0].minor.yy560 = yylhsminor.yy560; break; - case 341: /* column_reference ::= table_name NK_DOT column_name */ + case 342: /* column_reference ::= table_name NK_DOT column_name */ { yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy533, &yymsp[0].minor.yy533, createColumnNode(pCxt, &yymsp[-2].minor.yy533, &yymsp[0].minor.yy533)); } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 342: /* pseudo_column ::= ROWTS */ - case 343: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==343); - case 345: /* pseudo_column ::= QSTARTTS */ yytestcase(yyruleno==345); - case 346: /* pseudo_column ::= QENDTS */ yytestcase(yyruleno==346); - case 347: /* pseudo_column ::= WSTARTTS */ yytestcase(yyruleno==347); - case 348: /* pseudo_column ::= WENDTS */ yytestcase(yyruleno==348); - case 349: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==349); - case 355: /* literal_func ::= NOW */ yytestcase(yyruleno==355); + case 343: /* pseudo_column ::= ROWTS */ + case 344: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==344); + case 346: /* pseudo_column ::= QSTARTTS */ yytestcase(yyruleno==346); + case 347: /* pseudo_column ::= QENDTS */ yytestcase(yyruleno==347); + case 348: /* pseudo_column ::= WSTARTTS */ yytestcase(yyruleno==348); + case 349: /* pseudo_column ::= WENDTS */ yytestcase(yyruleno==349); + case 350: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==350); + case 356: /* literal_func ::= NOW */ yytestcase(yyruleno==356); { yylhsminor.yy560 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); } yymsp[0].minor.yy560 = yylhsminor.yy560; break; - case 344: /* pseudo_column ::= table_name NK_DOT TBNAME */ + case 345: /* pseudo_column ::= table_name NK_DOT TBNAME */ { yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy533, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy533)))); } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 350: /* function_expression ::= function_name NK_LP expression_list NK_RP */ - case 351: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==351); + case 351: /* function_expression ::= function_name NK_LP expression_list NK_RP */ + case 352: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==352); { yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy533, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy533, yymsp[-1].minor.yy712)); } yymsp[-3].minor.yy560 = yylhsminor.yy560; break; - case 352: /* function_expression ::= CAST NK_LP expression AS type_name NK_RP */ + case 353: /* function_expression ::= CAST NK_LP expression AS type_name NK_RP */ { yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy560), yymsp[-1].minor.yy196)); } yymsp[-5].minor.yy560 = yylhsminor.yy560; break; - case 354: /* literal_func ::= noarg_func NK_LP NK_RP */ + case 355: /* literal_func ::= noarg_func NK_LP NK_RP */ { yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy533, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy533, NULL)); } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 369: /* star_func_para_list ::= NK_STAR */ + case 370: /* star_func_para_list ::= NK_STAR */ { yylhsminor.yy712 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy712 = yylhsminor.yy712; break; - case 374: /* star_func_para ::= table_name NK_DOT NK_STAR */ - case 431: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==431); + case 375: /* star_func_para ::= table_name NK_DOT NK_STAR */ + case 432: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==432); { yylhsminor.yy560 = createColumnNode(pCxt, &yymsp[-2].minor.yy533, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 375: /* predicate ::= expression compare_op expression */ - case 380: /* predicate ::= expression in_op in_predicate_value */ yytestcase(yyruleno==380); + case 376: /* predicate ::= expression compare_op expression */ + case 381: /* predicate ::= expression in_op in_predicate_value */ yytestcase(yyruleno==381); { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560); @@ -4447,7 +4413,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 376: /* predicate ::= expression BETWEEN expression AND expression */ + case 377: /* predicate ::= expression BETWEEN expression AND expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy560); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560); @@ -4455,7 +4421,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-4].minor.yy560 = yylhsminor.yy560; break; - case 377: /* predicate ::= expression NOT BETWEEN expression AND expression */ + case 378: /* predicate ::= expression NOT BETWEEN expression AND expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy560); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560); @@ -4463,71 +4429,71 @@ static YYACTIONTYPE yy_reduce( } yymsp[-5].minor.yy560 = yylhsminor.yy560; break; - case 378: /* predicate ::= expression IS NULL */ + case 379: /* predicate ::= expression IS NULL */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560); yylhsminor.yy560 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy560), NULL)); } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 379: /* predicate ::= expression IS NOT NULL */ + case 380: /* predicate ::= expression IS NOT NULL */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy560); yylhsminor.yy560 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy560), NULL)); } yymsp[-3].minor.yy560 = yylhsminor.yy560; break; - case 381: /* compare_op ::= NK_LT */ + case 382: /* compare_op ::= NK_LT */ { yymsp[0].minor.yy128 = OP_TYPE_LOWER_THAN; } break; - case 382: /* compare_op ::= NK_GT */ + case 383: /* compare_op ::= NK_GT */ { yymsp[0].minor.yy128 = OP_TYPE_GREATER_THAN; } break; - case 383: /* compare_op ::= NK_LE */ + case 384: /* compare_op ::= NK_LE */ { yymsp[0].minor.yy128 = OP_TYPE_LOWER_EQUAL; } break; - case 384: /* compare_op ::= NK_GE */ + case 385: /* compare_op ::= NK_GE */ { yymsp[0].minor.yy128 = OP_TYPE_GREATER_EQUAL; } break; - case 385: /* compare_op ::= NK_NE */ + case 386: /* compare_op ::= NK_NE */ { yymsp[0].minor.yy128 = OP_TYPE_NOT_EQUAL; } break; - case 386: /* compare_op ::= NK_EQ */ + case 387: /* compare_op ::= NK_EQ */ { yymsp[0].minor.yy128 = OP_TYPE_EQUAL; } break; - case 387: /* compare_op ::= LIKE */ + case 388: /* compare_op ::= LIKE */ { yymsp[0].minor.yy128 = OP_TYPE_LIKE; } break; - case 388: /* compare_op ::= NOT LIKE */ + case 389: /* compare_op ::= NOT LIKE */ { yymsp[-1].minor.yy128 = OP_TYPE_NOT_LIKE; } break; - case 389: /* compare_op ::= MATCH */ + case 390: /* compare_op ::= MATCH */ { yymsp[0].minor.yy128 = OP_TYPE_MATCH; } break; - case 390: /* compare_op ::= NMATCH */ + case 391: /* compare_op ::= NMATCH */ { yymsp[0].minor.yy128 = OP_TYPE_NMATCH; } break; - case 391: /* compare_op ::= CONTAINS */ + case 392: /* compare_op ::= CONTAINS */ { yymsp[0].minor.yy128 = OP_TYPE_JSON_CONTAINS; } break; - case 392: /* in_op ::= IN */ + case 393: /* in_op ::= IN */ { yymsp[0].minor.yy128 = OP_TYPE_IN; } break; - case 393: /* in_op ::= NOT IN */ + case 394: /* in_op ::= NOT IN */ { yymsp[-1].minor.yy128 = OP_TYPE_NOT_IN; } break; - case 394: /* in_predicate_value ::= NK_LP literal_list NK_RP */ + case 395: /* in_predicate_value ::= NK_LP literal_list NK_RP */ { yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy712)); } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 396: /* boolean_value_expression ::= NOT boolean_primary */ + case 397: /* boolean_value_expression ::= NOT boolean_primary */ { SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560); yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy560), NULL)); } yymsp[-1].minor.yy560 = yylhsminor.yy560; break; - case 397: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ + case 398: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560); @@ -4535,7 +4501,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 398: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ + case 399: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy560); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy560); @@ -4543,47 +4509,47 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 406: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */ + case 407: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */ { yylhsminor.yy560 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy560, yymsp[0].minor.yy560, NULL); } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 409: /* table_primary ::= table_name alias_opt */ + case 410: /* table_primary ::= table_name alias_opt */ { yylhsminor.yy560 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy533, &yymsp[0].minor.yy533); } yymsp[-1].minor.yy560 = yylhsminor.yy560; break; - case 410: /* table_primary ::= db_name NK_DOT table_name alias_opt */ + case 411: /* table_primary ::= db_name NK_DOT table_name alias_opt */ { yylhsminor.yy560 = createRealTableNode(pCxt, &yymsp[-3].minor.yy533, &yymsp[-1].minor.yy533, &yymsp[0].minor.yy533); } yymsp[-3].minor.yy560 = yylhsminor.yy560; break; - case 411: /* table_primary ::= subquery alias_opt */ + case 412: /* table_primary ::= subquery alias_opt */ { yylhsminor.yy560 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy560), &yymsp[0].minor.yy533); } yymsp[-1].minor.yy560 = yylhsminor.yy560; break; - case 413: /* alias_opt ::= */ + case 414: /* alias_opt ::= */ { yymsp[1].minor.yy533 = nil_token; } break; - case 414: /* alias_opt ::= table_alias */ + case 415: /* alias_opt ::= table_alias */ { yylhsminor.yy533 = yymsp[0].minor.yy533; } yymsp[0].minor.yy533 = yylhsminor.yy533; break; - case 415: /* alias_opt ::= AS table_alias */ + case 416: /* alias_opt ::= AS table_alias */ { yymsp[-1].minor.yy533 = yymsp[0].minor.yy533; } break; - case 416: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - case 417: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==417); + case 417: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */ + case 418: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==418); { yymsp[-2].minor.yy560 = yymsp[-1].minor.yy560; } break; - case 418: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ + case 419: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ { yylhsminor.yy560 = createJoinTableNode(pCxt, yymsp[-4].minor.yy36, yymsp[-5].minor.yy560, yymsp[-2].minor.yy560, yymsp[0].minor.yy560); } yymsp[-5].minor.yy560 = yylhsminor.yy560; break; - case 419: /* join_type ::= */ + case 420: /* join_type ::= */ { yymsp[1].minor.yy36 = JOIN_TYPE_INNER; } break; - case 420: /* join_type ::= INNER */ + case 421: /* join_type ::= INNER */ { yymsp[0].minor.yy36 = JOIN_TYPE_INNER; } break; - case 421: /* query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ + case 422: /* query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ { yymsp[-11].minor.yy560 = createSelectStmt(pCxt, yymsp[-10].minor.yy173, yymsp[-9].minor.yy712, yymsp[-8].minor.yy560); yymsp[-11].minor.yy560 = addWhereClause(pCxt, yymsp[-11].minor.yy560, yymsp[-7].minor.yy560); @@ -4596,75 +4562,75 @@ static YYACTIONTYPE yy_reduce( yymsp[-11].minor.yy560 = addFillClause(pCxt, yymsp[-11].minor.yy560, yymsp[-3].minor.yy560); } break; - case 424: /* set_quantifier_opt ::= ALL */ + case 425: /* set_quantifier_opt ::= ALL */ { yymsp[0].minor.yy173 = false; } break; - case 427: /* select_item ::= NK_STAR */ + case 428: /* select_item ::= NK_STAR */ { yylhsminor.yy560 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0); } yymsp[0].minor.yy560 = yylhsminor.yy560; break; - case 429: /* select_item ::= common_expression column_alias */ + case 430: /* select_item ::= common_expression column_alias */ { yylhsminor.yy560 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy560), &yymsp[0].minor.yy533); } yymsp[-1].minor.yy560 = yylhsminor.yy560; break; - case 430: /* select_item ::= common_expression AS column_alias */ + case 431: /* select_item ::= common_expression AS column_alias */ { yylhsminor.yy560 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy560), &yymsp[0].minor.yy533); } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 435: /* partition_by_clause_opt ::= PARTITION BY expression_list */ - case 452: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==452); - case 468: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==468); + case 436: /* partition_by_clause_opt ::= PARTITION BY expression_list */ + case 453: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==453); + case 469: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==469); { yymsp[-2].minor.yy712 = yymsp[0].minor.yy712; } break; - case 437: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ + case 438: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ { yymsp[-5].minor.yy560 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy560), releaseRawExprNode(pCxt, yymsp[-1].minor.yy560)); } break; - case 438: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */ + case 439: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expression NK_RP */ { yymsp[-3].minor.yy560 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy560)); } break; - case 439: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ + case 440: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ { yymsp[-5].minor.yy560 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy560), NULL, yymsp[-1].minor.yy560, yymsp[0].minor.yy560); } break; - case 440: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ + case 441: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ { yymsp[-7].minor.yy560 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy560), releaseRawExprNode(pCxt, yymsp[-3].minor.yy560), yymsp[-1].minor.yy560, yymsp[0].minor.yy560); } break; - case 442: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ - case 460: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==460); + case 443: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ + case 461: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==461); { yymsp[-3].minor.yy560 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy560); } break; - case 444: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ + case 445: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ { yymsp[-3].minor.yy560 = createFillNode(pCxt, yymsp[-1].minor.yy18, NULL); } break; - case 445: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ + case 446: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ { yymsp[-5].minor.yy560 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy712)); } break; - case 446: /* fill_mode ::= NONE */ + case 447: /* fill_mode ::= NONE */ { yymsp[0].minor.yy18 = FILL_MODE_NONE; } break; - case 447: /* fill_mode ::= PREV */ + case 448: /* fill_mode ::= PREV */ { yymsp[0].minor.yy18 = FILL_MODE_PREV; } break; - case 448: /* fill_mode ::= NULL */ + case 449: /* fill_mode ::= NULL */ { yymsp[0].minor.yy18 = FILL_MODE_NULL; } break; - case 449: /* fill_mode ::= LINEAR */ + case 450: /* fill_mode ::= LINEAR */ { yymsp[0].minor.yy18 = FILL_MODE_LINEAR; } break; - case 450: /* fill_mode ::= NEXT */ + case 451: /* fill_mode ::= NEXT */ { yymsp[0].minor.yy18 = FILL_MODE_NEXT; } break; - case 453: /* group_by_list ::= expression */ + case 454: /* group_by_list ::= expression */ { yylhsminor.yy712 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy560))); } yymsp[0].minor.yy712 = yylhsminor.yy712; break; - case 454: /* group_by_list ::= group_by_list NK_COMMA expression */ + case 455: /* group_by_list ::= group_by_list NK_COMMA expression */ { yylhsminor.yy712 = addNodeToList(pCxt, yymsp[-2].minor.yy712, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy560))); } yymsp[-2].minor.yy712 = yylhsminor.yy712; break; - case 458: /* range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP */ + case 459: /* range_opt ::= RANGE NK_LP expression NK_COMMA expression NK_RP */ { yymsp[-5].minor.yy560 = createInterpTimeRange(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy560), releaseRawExprNode(pCxt, yymsp[-1].minor.yy560)); } break; - case 461: /* query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ + case 462: /* query_expression ::= query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt */ { yylhsminor.yy560 = addOrderByClause(pCxt, yymsp[-3].minor.yy560, yymsp[-2].minor.yy712); yylhsminor.yy560 = addSlimitClause(pCxt, yylhsminor.yy560, yymsp[-1].minor.yy560); @@ -4672,57 +4638,57 @@ static YYACTIONTYPE yy_reduce( } yymsp[-3].minor.yy560 = yylhsminor.yy560; break; - case 463: /* query_expression_body ::= query_expression_body UNION ALL query_expression_body */ + case 464: /* query_expression_body ::= query_expression_body UNION ALL query_expression_body */ { yylhsminor.yy560 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy560, yymsp[0].minor.yy560); } yymsp[-3].minor.yy560 = yylhsminor.yy560; break; - case 464: /* query_expression_body ::= query_expression_body UNION query_expression_body */ + case 465: /* query_expression_body ::= query_expression_body UNION query_expression_body */ { yylhsminor.yy560 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy560, yymsp[0].minor.yy560); } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 466: /* query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */ + case 467: /* query_primary ::= NK_LP query_expression_body order_by_clause_opt slimit_clause_opt limit_clause_opt NK_RP */ { yymsp[-5].minor.yy560 = addOrderByClause(pCxt, yymsp[-4].minor.yy560, yymsp[-3].minor.yy712); yymsp[-5].minor.yy560 = addSlimitClause(pCxt, yymsp[-5].minor.yy560, yymsp[-2].minor.yy560); yymsp[-5].minor.yy560 = addLimitClause(pCxt, yymsp[-5].minor.yy560, yymsp[-1].minor.yy560); } break; - case 470: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ - case 474: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==474); + case 471: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ + case 475: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==475); { yymsp[-1].minor.yy560 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); } break; - case 471: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - case 475: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==475); + case 472: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + case 476: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==476); { yymsp[-3].minor.yy560 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } break; - case 472: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - case 476: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==476); + case 473: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + case 477: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==477); { yymsp[-3].minor.yy560 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); } break; - case 477: /* subquery ::= NK_LP query_expression NK_RP */ + case 478: /* subquery ::= NK_LP query_expression NK_RP */ { yylhsminor.yy560 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy560); } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 481: /* sort_specification ::= expression ordering_specification_opt null_ordering_opt */ + case 482: /* sort_specification ::= expression ordering_specification_opt null_ordering_opt */ { yylhsminor.yy560 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy560), yymsp[-1].minor.yy218, yymsp[0].minor.yy109); } yymsp[-2].minor.yy560 = yylhsminor.yy560; break; - case 482: /* ordering_specification_opt ::= */ + case 483: /* ordering_specification_opt ::= */ { yymsp[1].minor.yy218 = ORDER_ASC; } break; - case 483: /* ordering_specification_opt ::= ASC */ + case 484: /* ordering_specification_opt ::= ASC */ { yymsp[0].minor.yy218 = ORDER_ASC; } break; - case 484: /* ordering_specification_opt ::= DESC */ + case 485: /* ordering_specification_opt ::= DESC */ { yymsp[0].minor.yy218 = ORDER_DESC; } break; - case 485: /* null_ordering_opt ::= */ + case 486: /* null_ordering_opt ::= */ { yymsp[1].minor.yy109 = NULL_ORDER_DEFAULT; } break; - case 486: /* null_ordering_opt ::= NULLS FIRST */ + case 487: /* null_ordering_opt ::= NULLS FIRST */ { yymsp[-1].minor.yy109 = NULL_ORDER_FIRST; } break; - case 487: /* null_ordering_opt ::= NULLS LAST */ + case 488: /* null_ordering_opt ::= NULLS LAST */ { yymsp[-1].minor.yy109 = NULL_ORDER_LAST; } break; default: From 6cef3baa95578a056cfccdc6e2f8fb24a776dd28 Mon Sep 17 00:00:00 2001 From: Haojun Liao Date: Tue, 12 Jul 2022 15:17:39 +0800 Subject: [PATCH 25/30] fix(query): set correct number of result rows for taos_fetch_raw_block_a --- source/client/inc/clientInt.h | 1 + source/client/src/clientMain.c | 20 +++++++++++++++----- 2 files changed, 16 insertions(+), 5 deletions(-) diff --git a/source/client/inc/clientInt.h b/source/client/inc/clientInt.h index 91f21f6e6a..641d235dd1 100644 --- a/source/client/inc/clientInt.h +++ b/source/client/inc/clientInt.h @@ -169,6 +169,7 @@ typedef struct SReqResultInfo { uint32_t numOfRows; uint64_t totalRows; uint32_t current; + bool localResultFetched; bool completed; int32_t precision; bool convertUcs4; diff --git a/source/client/src/clientMain.c b/source/client/src/clientMain.c index 12de522cbc..d3fdfa7a39 100644 --- a/source/client/src/clientMain.c +++ b/source/client/src/clientMain.c @@ -852,23 +852,33 @@ void taos_fetch_rows_a(TAOS_RES *res, __taos_async_fn_t fp, void *param) { } // all data has returned to App already, no need to try again - if ((pResultInfo->pData == NULL || pResultInfo->current >= pResultInfo->numOfRows) && pResultInfo->completed) { + if (pResultInfo->completed && (pRequest->body.queryJob != 0)) { pResultInfo->numOfRows = 0; pRequest->body.fetchFp(param, pRequest, pResultInfo->numOfRows); return; } // it is a local executed query, no need to do async fetch - if (pResultInfo->current < pResultInfo->numOfRows && pRequest->body.queryJob == 0) { - pRequest->body.fetchFp(param, pRequest, pResultInfo->numOfRows); + if (pRequest->body.queryJob == 0) { + ASSERT(pResultInfo->completed && pResultInfo->numOfRows >= 0); + if (pResultInfo->localResultFetched) { + pResultInfo->numOfRows = 0; + pResultInfo->current = 0; + pRequest->body.fetchFp(param, pRequest, pResultInfo->numOfRows); + } else { + pResultInfo->localResultFetched = true; + pRequest->body.fetchFp(param, pRequest, pResultInfo->numOfRows); + } return; } + SSchedulerReq req = { .syncReq = false, .fetchFp = fetchCallback, .cbParam = pRequest, }; + schedulerFetchRows(pRequest->body.queryJob, &req); } @@ -880,10 +890,10 @@ void taos_fetch_raw_block_a(TAOS_RES *res, __taos_async_fn_t fp, void *param) { SReqResultInfo *pResultInfo = &pRequest->body.resInfo; // set the current block is all consumed - pResultInfo->current = pResultInfo->numOfRows; pResultInfo->convertUcs4 = false; - taos_fetch_rows_a(res, fp, param); + // it is a local executed query, no need to do async fetch + taos_fetch_rows_a(pRequest, fp, param); } const void *taos_get_raw_block(TAOS_RES *res) { From 573a354ff39a53f9cd0917f23da7ad87dd76004a Mon Sep 17 00:00:00 2001 From: plum-lihui Date: Tue, 12 Jul 2022 15:19:54 +0800 Subject: [PATCH 26/30] test: add test case for tmq --- tests/system-test/7-tmq/tmqAutoCreateTbl.py | 193 +++++--------------- tests/system-test/fulltest.sh | 4 +- 2 files changed, 51 insertions(+), 146 deletions(-) diff --git a/tests/system-test/7-tmq/tmqAutoCreateTbl.py b/tests/system-test/7-tmq/tmqAutoCreateTbl.py index 6a9f10ebbf..1622ad7621 100644 --- a/tests/system-test/7-tmq/tmqAutoCreateTbl.py +++ b/tests/system-test/7-tmq/tmqAutoCreateTbl.py @@ -16,9 +16,9 @@ from tmqCommon import * class TDTestCase: def __init__(self): - self.vgroups = 2 - self.ctbNum = 100 - self.rowsPerTbl = 10000 + self.vgroups = 4 + self.ctbNum = 1000 + self.rowsPerTbl = 1000 def init(self, conn, logSql): tdLog.debug(f"start to excute {__file__}") @@ -29,7 +29,7 @@ class TDTestCase: paraDict = {'dbName': 'dbt', 'dropFlag': 1, 'event': '', - 'vgroups': 3, + 'vgroups': 4, 'stbName': 'stb', 'colPrefix': 'c', 'tagPrefix': 't', @@ -37,14 +37,14 @@ class TDTestCase: 'tagSchema': [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'BINARY', 'len':32, 'count':1},{'type': 'NCHAR', 'len':32, 'count':1}], 'ctbPrefix': 'ctb', 'ctbStartIdx': 0, - 'ctbNum': 500, + 'ctbNum': 1000, 'rowsPerTbl': 1000, - 'batchNum': 500, + 'batchNum': 400, 'startTs': 1640966400000, # 2022-01-01 00:00:00.000 'pollDelay': 3, 'showMsg': 1, 'showRow': 1, - 'snapshot': 0} + 'snapshot': 1} paraDict['vgroups'] = self.vgroups paraDict['ctbNum'] = self.ctbNum @@ -54,20 +54,21 @@ class TDTestCase: tdCom.create_database(tdSql, paraDict["dbName"],paraDict["dropFlag"], vgroups=paraDict["vgroups"],replica=1) tdLog.info("create stb") tmqCom.create_stable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"]) - tdLog.info("create ctb") - tmqCom.create_ctable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"],ctbPrefix=paraDict['ctbPrefix'], - ctbNum=paraDict["ctbNum"],ctbStartIdx=paraDict['ctbStartIdx']) - tdLog.info("insert data") - tmqCom.insert_data_interlaceByMultiTbl(tsql=tdSql,dbName=paraDict["dbName"],ctbPrefix=paraDict["ctbPrefix"], - ctbNum=paraDict["ctbNum"],rowsPerTbl=paraDict["rowsPerTbl"],batchNum=paraDict["batchNum"], - startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx']) + # tdLog.info("create ctb") + # tmqCom.create_ctable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"],ctbPrefix=paraDict['ctbPrefix'], + # ctbNum=paraDict["ctbNum"],ctbStartIdx=paraDict['ctbStartIdx']) + # tdLog.info("insert data") + # tmqCom.insert_data_interlaceByMultiTbl(tsql=tdSql,dbName=paraDict["dbName"],ctbPrefix=paraDict["ctbPrefix"], + # ctbNum=paraDict["ctbNum"],rowsPerTbl=paraDict["rowsPerTbl"],batchNum=paraDict["batchNum"], + # startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx']) + + tmqCom.insert_data_with_autoCreateTbl(tdSql,paraDict["dbName"],paraDict["stbName"],"ctbx",paraDict["ctbNum"],paraDict["rowsPerTbl"],paraDict["batchNum"]) - tdLog.info("restart taosd to ensure that the data falls into the disk") - # tdDnodes.stop(1) - # tdDnodes.start(1) - tdSql.query("flush database %s"%(paraDict['dbName'])) + # tdLog.info("restart taosd to ensure that the data falls into the disk") + # tdSql.query("flush database %s"%(paraDict['dbName'])) return + # 自动建表完成数据插入，启动消费 def tmqCase1(self): tdLog.printNoPrefix("======== test case 1: ") paraDict = {'dbName': 'dbt', @@ -90,28 +91,23 @@ class TDTestCase: 'showRow': 1, 'snapshot': 1} - # paraDict['vgroups'] = self.vgroups - # paraDict['ctbNum'] = self.ctbNum - # paraDict['rowsPerTbl'] = self.rowsPerTbl + paraDict['vgroups'] = self.vgroups + paraDict['ctbNum'] = self.ctbNum + paraDict['rowsPerTbl'] = self.rowsPerTbl - tmqCom.initConsumerTable() - tdCom.create_database(tdSql, paraDict["dbName"],paraDict["dropFlag"], vgroups=paraDict["vgroups"],replica=1) - tdLog.info("create stb") - tmqCom.create_stable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"]) - tdLog.info("create ctb") - tmqCom.create_ctable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"],ctbPrefix=paraDict['ctbPrefix'], - ctbNum=paraDict["ctbNum"],ctbStartIdx=paraDict['ctbStartIdx']) - tdLog.info("insert data") - tmqCom.insert_data_interlaceByMultiTbl(tsql=tdSql,dbName=paraDict["dbName"],ctbPrefix=paraDict["ctbPrefix"], - ctbNum=paraDict["ctbNum"],rowsPerTbl=paraDict["rowsPerTbl"],batchNum=paraDict["batchNum"], - startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx']) + # tmqCom.initConsumerTable() + # tdCom.create_database(tdSql, paraDict["dbName"],paraDict["dropFlag"], vgroups=paraDict["vgroups"],replica=1) + # tdLog.info("create stb") + # tmqCom.create_stable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"]) + # tdLog.info("insert data by auto create ctb") + # tmqCom.insert_data_with_autoCreateTbl(tdSql,paraDict["dbName"],paraDict["stbName"],"ctb",paraDict["ctbNum"],paraDict["rowsPerTbl"],paraDict["batchNum"]) tdLog.info("create topics from stb1") topicFromStb1 = 'topic_stb1' queryString = "select ts, c1, c2 from %s.%s"%(paraDict['dbName'], paraDict['stbName']) sqlString = "create topic %s as %s" %(topicFromStb1, queryString) tdLog.info("create topic sql: %s"%sqlString) - tdSql.execute(sqlString) + tdSql.execute(sqlString) consumerId = 0 expectrowcnt = paraDict["rowsPerTbl"] * paraDict["ctbNum"] @@ -120,19 +116,12 @@ class TDTestCase: ifManualCommit = 0 keyList = 'group.id:cgrp1,\ enable.auto.commit:true,\ - auto.commit.interval.ms:500,\ + auto.commit.interval.ms:1000,\ auto.offset.reset:earliest' tmqCom.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit) tdLog.info("start consume processor") tmqCom.startTmqSimProcess(pollDelay=paraDict['pollDelay'],dbName=paraDict["dbName"],showMsg=paraDict['showMsg'], showRow=paraDict['showRow'],snapshot=paraDict['snapshot']) - - # time.sleep(3) - tmqCom.getStartCommitNotifyFromTmqsim() - tdLog.info("================= restart dnode ===========================") - tdDnodes.stop(1) - tdDnodes.start(1) - time.sleep(5) tdLog.info("insert process end, and start to check consume result") expectRows = 1 @@ -172,23 +161,23 @@ class TDTestCase: 'pollDelay': 5, 'showMsg': 1, 'showRow': 1, - 'snapshot': 1} + 'snapshot': 0} - # paraDict['vgroups'] = self.vgroups - # paraDict['ctbNum'] = self.ctbNum - # paraDict['rowsPerTbl'] = self.rowsPerTbl + paraDict['vgroups'] = self.vgroups + paraDict['ctbNum'] = self.ctbNum + paraDict['rowsPerTbl'] = self.rowsPerTbl tmqCom.initConsumerTable() - tdCom.create_database(tdSql, paraDict["dbName"],paraDict["dropFlag"], vgroups=paraDict["vgroups"],replica=1) - tdLog.info("create stb") - tmqCom.create_stable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"]) - tdLog.info("create ctb") - tmqCom.create_ctable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"],ctbPrefix=paraDict['ctbPrefix'], - ctbNum=paraDict["ctbNum"],ctbStartIdx=paraDict['ctbStartIdx']) - tdLog.info("insert data") - tmqCom.insert_data_interlaceByMultiTbl(tsql=tdSql,dbName=paraDict["dbName"],ctbPrefix=paraDict["ctbPrefix"], - ctbNum=paraDict["ctbNum"],rowsPerTbl=paraDict["rowsPerTbl"],batchNum=paraDict["batchNum"], - startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx']) + # tdCom.create_database(tdSql, paraDict["dbName"],paraDict["dropFlag"], vgroups=paraDict["vgroups"],replica=1) + # tdLog.info("create stb") + # tmqCom.create_stable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"]) + # tdLog.info("create ctb") + # tmqCom.create_ctable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"],ctbPrefix=paraDict['ctbPrefix'], + # ctbNum=paraDict["ctbNum"],ctbStartIdx=paraDict['ctbStartIdx']) + # tdLog.info("insert data") + # tmqCom.insert_data_interlaceByMultiTbl(tsql=tdSql,dbName=paraDict["dbName"],ctbPrefix=paraDict["ctbPrefix"], + # ctbNum=paraDict["ctbNum"],rowsPerTbl=paraDict["rowsPerTbl"],batchNum=paraDict["batchNum"], + # startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx']) tdLog.info("create topics from stb1") topicFromStb1 = 'topic_stb1' queryString = "select ts, c1, c2 from %s.%s"%(paraDict['dbName'], paraDict['stbName']) @@ -211,14 +200,8 @@ class TDTestCase: tmqCom.startTmqSimProcess(pollDelay=paraDict['pollDelay'],dbName=paraDict["dbName"],showMsg=paraDict['showMsg'], showRow=paraDict['showRow'],snapshot=paraDict['snapshot']) tdLog.info("create some new child table and insert data ") - tmqCom.insert_data_with_autoCreateTbl(tdSql,paraDict["dbName"],paraDict["stbName"],"ctb",paraDict["ctbNum"],paraDict["rowsPerTbl"],paraDict["batchNum"]) + tmqCom.insert_data_with_autoCreateTbl(tdSql,paraDict["dbName"],paraDict["stbName"],"ctby",paraDict["ctbNum"],paraDict["rowsPerTbl"],paraDict["batchNum"]) - tmqCom.getStartCommitNotifyFromTmqsim() - tdLog.info("================= restart dnode ===========================") - tdDnodes.stop(1) - tdDnodes.start(1) - time.sleep(5) - tdLog.info("insert process end, and start to check consume result") expectRows = 1 resultList = tmqCom.selectConsumeResult(expectRows) @@ -237,91 +220,13 @@ class TDTestCase: tdLog.printNoPrefix("======== test case 2 end ...... ") - # 自动建表完成数据插入，启动消费 - def tmqCase3(self): - tdLog.printNoPrefix("======== test case 3: ") - paraDict = {'dbName': 'dbt', - 'dropFlag': 1, - 'event': '', - 'vgroups': 4, - 'stbName': 'stb', - 'colPrefix': 'c', - 'tagPrefix': 't', - 'colSchema': [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'BINARY', 'len':32, 'count':1},{'type': 'NCHAR', 'len':32, 'count':1},{'type': 'TIMESTAMP', 'count':1}], - 'tagSchema': [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'BINARY', 'len':32, 'count':1},{'type': 'NCHAR', 'len':32, 'count':1}], - 'ctbPrefix': 'ctb', - 'ctbStartIdx': 0, - 'ctbNum': 1000, - 'rowsPerTbl': 1000, - 'batchNum': 400, - 'startTs': 1640966400000, # 2022-01-01 00:00:00.000 - 'pollDelay': 5, - 'showMsg': 1, - 'showRow': 1, - 'snapshot': 1} - - paraDict['vgroups'] = self.vgroups - paraDict['ctbNum'] = self.ctbNum - paraDict['rowsPerTbl'] = self.rowsPerTbl - - tmqCom.initConsumerTable() - tdCom.create_database(tdSql, paraDict["dbName"],paraDict["dropFlag"], vgroups=paraDict["vgroups"],replica=1) - tdLog.info("create stb") - tmqCom.create_stable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"]) - tdLog.info("insert data by auto create ctb") - tmqCom.insert_data_with_autoCreateTbl(tdSql,paraDict["dbName"],paraDict["stbName"],"ctb",paraDict["ctbNum"],paraDict["rowsPerTbl"],paraDict["batchNum"]) - - tdLog.info("create topics from stb1") - topicFromStb1 = 'topic_stb1' - queryString = "select ts, c1, c2 from %s.%s"%(paraDict['dbName'], paraDict['stbName']) - sqlString = "create topic %s as %s" %(topicFromStb1, queryString) - tdLog.info("create topic sql: %s"%sqlString) - tdSql.execute(sqlString) - - consumerId = 0 - expectrowcnt = paraDict["rowsPerTbl"] * paraDict["ctbNum"] - topicList = topicFromStb1 - ifcheckdata = 0 - ifManualCommit = 0 - keyList = 'group.id:cgrp1,\ - enable.auto.commit:true,\ - auto.commit.interval.ms:1000,\ - auto.offset.reset:earliest' - tmqCom.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit) - - tdLog.info("start consume processor") - tmqCom.startTmqSimProcess(pollDelay=paraDict['pollDelay'],dbName=paraDict["dbName"],showMsg=paraDict['showMsg'], showRow=paraDict['showRow'],snapshot=paraDict['snapshot']) - - # tdLog.info("================= restart dnode ===========================") - # tdDnodes.stop(1) - # tdDnodes.start(1) - # time.sleep(2) - - tdLog.info("insert process end, and start to check consume result") - expectRows = 1 - resultList = tmqCom.selectConsumeResult(expectRows) - totalConsumeRows = 0 - for i in range(expectRows): - totalConsumeRows += resultList[i] - - tdSql.query(queryString) - totalRowsInserted = tdSql.getRows() - - if totalConsumeRows != totalRowsInserted: - tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, totalRowsInserted)) - tdLog.exit("tmq consume rows error!") - - tdSql.query("drop topic %s"%topicFromStb1) - - tdLog.printNoPrefix("======== test case 3 end ...... ") - def run(self): tdSql.prepare() - - # self.tmqCase1() - # self.tmqCase2() - self.tmqCase3() + self.prepareTestEnv() + self.tmqCase1() + # self.tmqCase2() TD-17267 + def stop(self): tdSql.close() diff --git a/tests/system-test/fulltest.sh b/tests/system-test/fulltest.sh index 3b0dd76a30..71be73221d 100755 --- a/tests/system-test/fulltest.sh +++ b/tests/system-test/fulltest.sh @@ -174,8 +174,8 @@ python3 ./test.py -f 7-tmq/tmqConsFromTsdb-mutilVg-mutilCtb.py python3 ./test.py -f 7-tmq/tmqConsFromTsdb1-1ctb-funcNFilter.py python3 ./test.py -f 7-tmq/tmqConsFromTsdb1-mutilVg-mutilCtb-funcNFilter.py python3 ./test.py -f 7-tmq/tmqConsFromTsdb1-mutilVg-mutilCtb.py - - +python3 ./test.py -f 7-tmq/tmqAutoCreateTbl.py +#python3 ./test.py -f 7-tmq/tmqDnode.py #------------querPolicy 2----------- From 3801d746952508a6d471642392289abe191d738e Mon Sep 17 00:00:00 2001 From: plum-lihui Date: Tue, 12 Jul 2022 15:21:54 +0800 Subject: [PATCH 27/30] test: add case for tmq --- tests/system-test/7-tmq/tmqDnodeRestart.py | 253 +++++++++++++++++++++ tests/system-test/fulltest.sh | 2 +- 2 files changed, 254 insertions(+), 1 deletion(-) create mode 100644 tests/system-test/7-tmq/tmqDnodeRestart.py diff --git a/tests/system-test/7-tmq/tmqDnodeRestart.py b/tests/system-test/7-tmq/tmqDnodeRestart.py new file mode 100644 index 0000000000..8354991578 --- /dev/null +++ b/tests/system-test/7-tmq/tmqDnodeRestart.py @@ -0,0 +1,253 @@ + +import taos +import sys +import time +import socket +import os +import threading +from enum import Enum + +from util.log import * +from util.sql import * +from util.cases import * +from util.dnodes import * +sys.path.append("./7-tmq") +from tmqCommon import * + +class TDTestCase: + def __init__(self): + self.vgroups = 2 + self.ctbNum = 100 + self.rowsPerTbl = 10000 + + def init(self, conn, logSql): + tdLog.debug(f"start to excute {__file__}") + tdSql.init(conn.cursor(), False) + + def prepareTestEnv(self): + tdLog.printNoPrefix("======== prepare test env include database, stable, ctables, and insert data: ") + paraDict = {'dbName': 'dbt', + 'dropFlag': 1, + 'event': '', + 'vgroups': 3, + 'stbName': 'stb', + 'colPrefix': 'c', + 'tagPrefix': 't', + 'colSchema': [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'BINARY', 'len':32, 'count':1},{'type': 'NCHAR', 'len':32, 'count':1},{'type': 'TIMESTAMP', 'count':1}], + 'tagSchema': [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'BINARY', 'len':32, 'count':1},{'type': 'NCHAR', 'len':32, 'count':1}], + 'ctbPrefix': 'ctb', + 'ctbStartIdx': 0, + 'ctbNum': 500, + 'rowsPerTbl': 1000, + 'batchNum': 500, + 'startTs': 1640966400000, # 2022-01-01 00:00:00.000 + 'pollDelay': 3, + 'showMsg': 1, + 'showRow': 1, + 'snapshot': 0} + + paraDict['vgroups'] = self.vgroups + paraDict['ctbNum'] = self.ctbNum + paraDict['rowsPerTbl'] = self.rowsPerTbl + + tmqCom.initConsumerTable() + tdCom.create_database(tdSql, paraDict["dbName"],paraDict["dropFlag"], vgroups=paraDict["vgroups"],replica=1) + tdLog.info("create stb") + tmqCom.create_stable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"]) + tdLog.info("create ctb") + tmqCom.create_ctable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"],ctbPrefix=paraDict['ctbPrefix'], + ctbNum=paraDict["ctbNum"],ctbStartIdx=paraDict['ctbStartIdx']) + tdLog.info("insert data") + tmqCom.insert_data_interlaceByMultiTbl(tsql=tdSql,dbName=paraDict["dbName"],ctbPrefix=paraDict["ctbPrefix"], + ctbNum=paraDict["ctbNum"],rowsPerTbl=paraDict["rowsPerTbl"],batchNum=paraDict["batchNum"], + startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx']) + + tdLog.info("restart taosd to ensure that the data falls into the disk") + # tdDnodes.stop(1) + # tdDnodes.start(1) + tdSql.query("flush database %s"%(paraDict['dbName'])) + return + + def tmqCase1(self): + tdLog.printNoPrefix("======== test case 1: ") + paraDict = {'dbName': 'dbt', + 'dropFlag': 1, + 'event': '', + 'vgroups': 4, + 'stbName': 'stb', + 'colPrefix': 'c', + 'tagPrefix': 't', + 'colSchema': [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'BINARY', 'len':32, 'count':1},{'type': 'NCHAR', 'len':32, 'count':1},{'type': 'TIMESTAMP', 'count':1}], + 'tagSchema': [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'BINARY', 'len':32, 'count':1},{'type': 'NCHAR', 'len':32, 'count':1}], + 'ctbPrefix': 'ctb', + 'ctbStartIdx': 0, + 'ctbNum': 1000, + 'rowsPerTbl': 1000, + 'batchNum': 400, + 'startTs': 1640966400000, # 2022-01-01 00:00:00.000 + 'pollDelay': 5, + 'showMsg': 1, + 'showRow': 1, + 'snapshot': 1} + + # paraDict['vgroups'] = self.vgroups + # paraDict['ctbNum'] = self.ctbNum + # paraDict['rowsPerTbl'] = self.rowsPerTbl + + tmqCom.initConsumerTable() + tdCom.create_database(tdSql, paraDict["dbName"],paraDict["dropFlag"], vgroups=paraDict["vgroups"],replica=1) + tdLog.info("create stb") + tmqCom.create_stable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"]) + tdLog.info("create ctb") + tmqCom.create_ctable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"],ctbPrefix=paraDict['ctbPrefix'], + ctbNum=paraDict["ctbNum"],ctbStartIdx=paraDict['ctbStartIdx']) + tdLog.info("insert data") + tmqCom.insert_data_interlaceByMultiTbl(tsql=tdSql,dbName=paraDict["dbName"],ctbPrefix=paraDict["ctbPrefix"], + ctbNum=paraDict["ctbNum"],rowsPerTbl=paraDict["rowsPerTbl"],batchNum=paraDict["batchNum"], + startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx']) + + tdLog.info("create topics from stb1") + topicFromStb1 = 'topic_stb1' + queryString = "select ts, c1, c2 from %s.%s"%(paraDict['dbName'], paraDict['stbName']) + sqlString = "create topic %s as %s" %(topicFromStb1, queryString) + tdLog.info("create topic sql: %s"%sqlString) + tdSql.execute(sqlString) + + consumerId = 0 + expectrowcnt = paraDict["rowsPerTbl"] * paraDict["ctbNum"] + topicList = topicFromStb1 + ifcheckdata = 0 + ifManualCommit = 0 + keyList = 'group.id:cgrp1,\ + enable.auto.commit:true,\ + auto.commit.interval.ms:500,\ + auto.offset.reset:earliest' + tmqCom.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit) + + tdLog.info("start consume processor") + tmqCom.startTmqSimProcess(pollDelay=paraDict['pollDelay'],dbName=paraDict["dbName"],showMsg=paraDict['showMsg'], showRow=paraDict['showRow'],snapshot=paraDict['snapshot']) + + # time.sleep(3) + tmqCom.getStartCommitNotifyFromTmqsim() + tdLog.info("================= restart dnode ===========================") + tdDnodes.stop(1) + tdDnodes.start(1) + time.sleep(5) + + tdLog.info("insert process end, and start to check consume result") + expectRows = 1 + resultList = tmqCom.selectConsumeResult(expectRows) + totalConsumeRows = 0 + for i in range(expectRows): + totalConsumeRows += resultList[i] + + tdSql.query(queryString) + totalRowsInserted = tdSql.getRows() + + if totalConsumeRows != totalRowsInserted: + tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, totalRowsInserted)) + tdLog.exit("tmq consume rows error!") + + tdSql.query("drop topic %s"%topicFromStb1) + + tdLog.printNoPrefix("======== test case 1 end ...... ") + + def tmqCase2(self): + tdLog.printNoPrefix("======== test case 2: ") + paraDict = {'dbName': 'dbt', + 'dropFlag': 1, + 'event': '', + 'vgroups': 4, + 'stbName': 'stb', + 'colPrefix': 'c', + 'tagPrefix': 't', + 'colSchema': [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'BINARY', 'len':32, 'count':1},{'type': 'NCHAR', 'len':32, 'count':1},{'type': 'TIMESTAMP', 'count':1}], + 'tagSchema': [{'type': 'INT', 'count':1},{'type': 'BIGINT', 'count':1},{'type': 'DOUBLE', 'count':1},{'type': 'BINARY', 'len':32, 'count':1},{'type': 'NCHAR', 'len':32, 'count':1}], + 'ctbPrefix': 'ctb', + 'ctbStartIdx': 0, + 'ctbNum': 1000, + 'rowsPerTbl': 1000, + 'batchNum': 1000, + 'startTs': 1640966400000, # 2022-01-01 00:00:00.000 + 'pollDelay': 5, + 'showMsg': 1, + 'showRow': 1, + 'snapshot': 1} + + # paraDict['vgroups'] = self.vgroups + # paraDict['ctbNum'] = self.ctbNum + # paraDict['rowsPerTbl'] = self.rowsPerTbl + + tmqCom.initConsumerTable() + tdCom.create_database(tdSql, paraDict["dbName"],paraDict["dropFlag"], vgroups=paraDict["vgroups"],replica=1) + tdLog.info("create stb") + tmqCom.create_stable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"]) + tdLog.info("create ctb") + tmqCom.create_ctable(tdSql, dbName=paraDict["dbName"],stbName=paraDict["stbName"],ctbPrefix=paraDict['ctbPrefix'], + ctbNum=paraDict["ctbNum"],ctbStartIdx=paraDict['ctbStartIdx']) + tdLog.info("insert data") + tmqCom.insert_data_interlaceByMultiTbl(tsql=tdSql,dbName=paraDict["dbName"],ctbPrefix=paraDict["ctbPrefix"], + ctbNum=paraDict["ctbNum"],rowsPerTbl=paraDict["rowsPerTbl"],batchNum=paraDict["batchNum"], + startTs=paraDict["startTs"],ctbStartIdx=paraDict['ctbStartIdx']) + tdLog.info("create topics from stb1") + topicFromStb1 = 'topic_stb1' + queryString = "select ts, c1, c2 from %s.%s"%(paraDict['dbName'], paraDict['stbName']) + sqlString = "create topic %s as %s" %(topicFromStb1, queryString) + tdLog.info("create topic sql: %s"%sqlString) + tdSql.execute(sqlString) + + consumerId = 0 + expectrowcnt = paraDict["rowsPerTbl"] * paraDict["ctbNum"] * 2 + topicList = topicFromStb1 + ifcheckdata = 0 + ifManualCommit = 0 + keyList = 'group.id:cgrp1,\ + enable.auto.commit:true,\ + auto.commit.interval.ms:1000,\ + auto.offset.reset:earliest' + tmqCom.insertConsumerInfo(consumerId, expectrowcnt,topicList,keyList,ifcheckdata,ifManualCommit) + + tdLog.info("start consume processor") + tmqCom.startTmqSimProcess(pollDelay=paraDict['pollDelay'],dbName=paraDict["dbName"],showMsg=paraDict['showMsg'], showRow=paraDict['showRow'],snapshot=paraDict['snapshot']) + + tdLog.info("create some new child table and insert data ") + tmqCom.insert_data_with_autoCreateTbl(tdSql,paraDict["dbName"],paraDict["stbName"],"ctb",paraDict["ctbNum"],paraDict["rowsPerTbl"],paraDict["batchNum"]) + + tmqCom.getStartCommitNotifyFromTmqsim() + tdLog.info("================= restart dnode ===========================") + tdDnodes.stop(1) + tdDnodes.start(1) + time.sleep(5) + + tdLog.info("insert process end, and start to check consume result") + expectRows = 1 + resultList = tmqCom.selectConsumeResult(expectRows) + totalConsumeRows = 0 + for i in range(expectRows): + totalConsumeRows += resultList[i] + + tdSql.query(queryString) + totalRowsInserted = tdSql.getRows() + + if totalConsumeRows != totalRowsInserted: + tdLog.info("act consume rows: %d, expect consume rows: %d"%(totalConsumeRows, totalRowsInserted)) + tdLog.exit("tmq consume rows error!") + + tdSql.query("drop topic %s"%topicFromStb1) + + tdLog.printNoPrefix("======== test case 2 end ...... ") + + def run(self): + tdSql.prepare() + + self.tmqCase1() + self.tmqCase2() + + def stop(self): + tdSql.close() + tdLog.success(f"{__file__} successfully executed") + +event = threading.Event() + +tdCases.addLinux(__file__, TDTestCase()) +tdCases.addWindows(__file__, TDTestCase()) diff --git a/tests/system-test/fulltest.sh b/tests/system-test/fulltest.sh index 71be73221d..6df6f4040c 100755 --- a/tests/system-test/fulltest.sh +++ b/tests/system-test/fulltest.sh @@ -175,7 +175,7 @@ python3 ./test.py -f 7-tmq/tmqConsFromTsdb1-1ctb-funcNFilter.py python3 ./test.py -f 7-tmq/tmqConsFromTsdb1-mutilVg-mutilCtb-funcNFilter.py python3 ./test.py -f 7-tmq/tmqConsFromTsdb1-mutilVg-mutilCtb.py python3 ./test.py -f 7-tmq/tmqAutoCreateTbl.py -#python3 ./test.py -f 7-tmq/tmqDnode.py +#python3 ./test.py -f 7-tmq/tmqDnodeRestart.py #------------querPolicy 2----------- From 24090f0fc3077d1f4b72d842dd385fa1df336fc7 Mon Sep 17 00:00:00 2001 From: Haojun Liao Date: Tue, 12 Jul 2022 15:30:38 +0800 Subject: [PATCH 28/30] refactor: do some internal refactor. --- source/libs/executor/src/executorimpl.c | 19 +---- source/libs/executor/src/scanoperator.c | 98 ------------------------- source/libs/function/src/builtinsimpl.c | 11 ++- 3 files changed, 11 insertions(+), 117 deletions(-) diff --git a/source/libs/executor/src/executorimpl.c b/source/libs/executor/src/executorimpl.c index e9a244b573..2ae09e0434 100644 --- a/source/libs/executor/src/executorimpl.c +++ b/source/libs/executor/src/executorimpl.c @@ -538,7 +538,7 @@ static int32_t doSetInputDataBlock(SOperatorInfo* pOperator, SqlFunctionCtx* pCt return code; } -static int32_t doAggregateImpl(SOperatorInfo* pOperator, TSKEY startTs, SqlFunctionCtx* pCtx) { +static int32_t doAggregateImpl(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx) { for (int32_t k = 0; k < pOperator->exprSupp.numOfExprs; ++k) { if (functionNeedToExecute(&pCtx[k])) { // todo add a dummy funtion to avoid process check @@ -2969,25 +2969,10 @@ static int32_t doOpenAggregateOptr(SOperatorInfo* pOperator) { // the pDataBlock are always the same one, no need to call this again setExecutionContext(pOperator, pOperator->exprSupp.numOfExprs, pBlock->info.groupId, pAggInfo); setInputDataBlock(pOperator, pSup->pCtx, pBlock, order, scanFlag, true); - code = doAggregateImpl(pOperator, 0, pSup->pCtx); + code = doAggregateImpl(pOperator, pSup->pCtx); if (code != 0) { longjmp(pTaskInfo->env, code); } - -#if 0 // test for encode/decode result info - if(pOperator->fpSet.encodeResultRow){ - char *result = NULL; - int32_t length = 0; - pOperator->fpSet.encodeResultRow(pOperator, &result, &length); - SAggSupporter* pSup = &pAggInfo->aggSup; - taosHashClear(pSup->pResultRowHashTable); - pInfo->resultRowInfo.size = 0; - pOperator->fpSet.decodeResultRow(pOperator, result); - if(result){ - taosMemoryFree(result); - } - } -#endif } closeAllResultRows(&pAggInfo->binfo.resultRowInfo); diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c index 6ab3effc85..f3c240b6f2 100644 --- a/source/libs/executor/src/scanoperator.c +++ b/source/libs/executor/src/scanoperator.c @@ -2860,101 +2860,3 @@ _error: return NULL; } -static SSDataBlock* doScanLastrow(SOperatorInfo* pOperator) { - if (pOperator->status == OP_EXEC_DONE) { - return NULL; - } - - SLastrowScanInfo* pInfo = pOperator->info; - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - - int32_t size = taosArrayGetSize(pInfo->pTableList); - if (size == 0) { - setTaskStatus(pTaskInfo, TASK_COMPLETED); - return NULL; - } - - // check if it is a group by tbname - if (size == taosArrayGetSize(pInfo->pTableList)) { - blockDataCleanup(pInfo->pRes); - tsdbRetrieveLastRow(pInfo->pLastrowReader, pInfo->pRes, pInfo->pSlotIds); - return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes; - } else { - // todo fetch the result for each group - } - - return pInfo->pRes->info.rows == 0 ? NULL : pInfo->pRes; -} - -static void destroyLastrowScanOperator(void* param, int32_t numOfOutput) { - SLastrowScanInfo* pInfo = (SLastrowScanInfo*)param; - blockDataDestroy(pInfo->pRes); - tsdbLastrowReaderClose(pInfo->pLastrowReader); - - taosMemoryFreeClear(param); -} - -SOperatorInfo* createLastrowScanOperator(SLastRowScanPhysiNode* pScanNode, SReadHandle* readHandle, SArray* pTableList, - SExecTaskInfo* pTaskInfo) { - SLastrowScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SLastrowScanInfo)); - SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); - if (pInfo == NULL || pOperator == NULL) { - goto _error; - } - - pInfo->pTableList = pTableList; - pInfo->readHandle = *readHandle; - pInfo->pRes = createResDataBlock(pScanNode->node.pOutputDataBlockDesc); - - int32_t numOfCols = 0; - pInfo->pColMatchInfo = extractColMatchInfo(pScanNode->pScanCols, pScanNode->node.pOutputDataBlockDesc, &numOfCols, - COL_MATCH_FROM_COL_ID); - int32_t* pCols = taosMemoryMalloc(numOfCols * sizeof(int32_t)); - for (int32_t i = 0; i < numOfCols; ++i) { - SColMatchInfo* pColMatch = taosArrayGet(pInfo->pColMatchInfo, i); - pCols[i] = pColMatch->colId; - } - - pInfo->pSlotIds = taosMemoryMalloc(numOfCols * sizeof(pInfo->pSlotIds[0])); - for (int32_t i = 0; i < numOfCols; ++i) { - SColMatchInfo* pColMatch = taosArrayGet(pInfo->pColMatchInfo, i); - for (int32_t j = 0; j < pTaskInfo->schemaVer.sw->nCols; ++j) { - if (pColMatch->colId == pTaskInfo->schemaVer.sw->pSchema[j].colId && - pColMatch->colId == PRIMARYKEY_TIMESTAMP_COL_ID) { - pInfo->pSlotIds[pColMatch->targetSlotId] = -1; - break; - } - - if (pColMatch->colId == pTaskInfo->schemaVer.sw->pSchema[j].colId) { - pInfo->pSlotIds[pColMatch->targetSlotId] = j; - break; - } - } - } - - tsdbLastRowReaderOpen(readHandle->vnode, LASTROW_RETRIEVE_TYPE_ALL, pTableList, pCols, numOfCols, - &pInfo->pLastrowReader); - taosMemoryFree(pCols); - - pOperator->name = "LastrowScanOperator"; - pOperator->operatorType = QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN; - pOperator->blocking = false; - pOperator->status = OP_NOT_OPENED; - pOperator->info = pInfo; - pOperator->pTaskInfo = pTaskInfo; - pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock); - - initResultSizeInfo(pOperator, 1024); - blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); - - pOperator->fpSet = - createOperatorFpSet(operatorDummyOpenFn, doScanLastrow, NULL, NULL, destroyLastrowScanOperator, NULL, NULL, NULL); - pOperator->cost.openCost = 0; - return pOperator; - -_error: - pTaskInfo->code = TSDB_CODE_OUT_OF_MEMORY; - taosMemoryFree(pInfo); - taosMemoryFree(pOperator); - return NULL; -} diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c index 932bfb8793..5dee2e8480 100644 --- a/source/libs/function/src/builtinsimpl.c +++ b/source/libs/function/src/builtinsimpl.c @@ -2729,7 +2729,6 @@ int32_t firstFunction(SqlFunctionCtx* pCtx) { } } pInfo->hasResult = true; - // DO_UPDATE_TAG_COLUMNS(pCtx, ts); pResInfo->numOfRes = 1; break; } @@ -2826,7 +2825,6 @@ int32_t lastFunction(SqlFunctionCtx* pCtx) { } pInfo->hasResult = true; pResInfo->numOfRes = 1; - // DO_UPDATE_TAG_COLUMNS(pCtx, ts); } break; } @@ -5980,6 +5978,15 @@ int32_t lastrowFunction(SqlFunctionCtx* pCtx) { pInfo->hasResult = true; pResInfo->numOfRes = 1; + + if (pCtx->subsidiaries.num > 0) { + STuplePos* pTuplePos = (STuplePos*)(pInfo->buf + bytes + sizeof(TSKEY)); + if (!pInfo->hasResult) { + saveTupleData(pCtx, i, pCtx->pSrcBlock, pTuplePos); + } else { + copyTupleData(pCtx, i, pCtx->pSrcBlock, pTuplePos); + } + } } } From c2748ffd13403d02488a99dac010f63d59277f1e Mon Sep 17 00:00:00 2001 From: Shuduo Sang Date: Tue, 12 Jul 2022 15:39:12 +0800 Subject: [PATCH 29/30] chore: update libtaos ws submodule for3.0 (#14810) * chore: add libtaos-ws for 3.0 * chore: update taosws-rs * chore: add libtaosws to install/remove script * chore: update taosws-rs * chore: update taosws-rs * chore: update taos-tools, taosws-rs for 3.0 * fix: packaging/tools/make_install.sh for 3.0 * chore: update taos-tools * chore: fix release script for 3.0 * chore: update taosws-rs for 3.0 --- tools/taosws-rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/taosws-rs b/tools/taosws-rs index 7a94ffab45..6dccac192a 160000 --- a/tools/taosws-rs +++ b/tools/taosws-rs @@ -1 +1 @@ -Subproject commit 7a94ffab45f08e16f09b3f430fe75d717054adb6 +Subproject commit 6dccac192a2ae7dd78718ab926201aab5419327a From f54a4322c2f329c39e5c4727c900e71cf7383050 Mon Sep 17 00:00:00 2001 From: dapan1121 Date: Tue, 12 Jul 2022 16:04:18 +0800 Subject: [PATCH 30/30] fix: fix load table info issue --- source/client/src/clientImpl.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/source/client/src/clientImpl.c b/source/client/src/clientImpl.c index 25ba63fd34..3605f49a5c 100644 --- a/source/client/src/clientImpl.c +++ b/source/client/src/clientImpl.c @@ -1905,6 +1905,10 @@ int32_t appendTbToReq(SArray* pList, int32_t pos1, int32_t len1, int32_t pos2, i tbLen = len1; } + if (dbLen <= 0 || tbLen <= 0) { + return -1; + } + if (tNameSetDbName(&name, acctId, dbName, dbLen)) { return -1; }