[TD-225]merge develop

cmake/install.inc

@@ -32,7 +32,7 @@ ELSEIF (TD_WINDOWS)
   #INSTALL(TARGETS taos RUNTIME DESTINATION driver)
   #INSTALL(TARGETS shell RUNTIME DESTINATION .)
   IF (TD_MVN_INSTALLED)
-    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.15-dist.jar DESTINATION connector/jdbc)
+    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.16-dist.jar DESTINATION connector/jdbc)
   ENDIF ()
 ELSEIF (TD_DARWIN)
   SET(TD_MAKE_INSTALL_SH "${TD_COMMUNITY_DIR}/packaging/tools/make_install.sh")

cmake/version.inc

@@ -4,7 +4,7 @@ PROJECT(TDengine)
 IF (DEFINED VERNUMBER)
   SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "2.0.13.0")
+  SET(TD_VER_NUMBER "2.0.14.0")
 ENDIF ()
 
 IF (DEFINED VERCOMPATIBLE)

documentation20/webdocs/markdowndocs/TAOS SQL-ch.md

@@ -68,7 +68,9 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
   2) UPDATE 标志数据库支持更新相同时间戳数据；
 
   3) 数据库名最大长度为33；
+
   4) 一条SQL 语句的最大长度为65480个字符；
+
   5) 数据库还有更多与存储相关的配置参数，请参见系统管理。
 
 - **显示系统当前参数**
@@ -119,6 +121,7 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
     **Tips**: 以上所有参数修改后都可以用show databases来确认是否修改成功。
 
 - **显示系统所有数据库**
+
     ```mysql
     SHOW DATABASES;
     ```
@@ -130,10 +133,15 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
     CREATE TABLE [IF NOT EXISTS] tb_name (timestamp_field_name TIMESTAMP, field1_name data_type1 [, field2_name data_type2 ...]);
     ```
     说明：
+
     1) 表的第一个字段必须是TIMESTAMP，并且系统自动将其设为主键；
+
     2) 表名最大长度为192；
+
     3) 表的每行长度不能超过16k个字符;
+
     4) 子表名只能由字母、数字和下划线组成，且不能以数字开头
+
     5) 使用数据类型binary或nchar，需指定其最长的字节数，如binary(20)，表示20字节；
 
 - **以超级表为模板创建数据表**
@@ -149,7 +157,12 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
     CREATE TABLE [IF NOT EXISTS] tb_name1 USING stb_name TAGS (tag_value1, ...) tb_name2 USING stb_name TAGS (tag_value2, ...) ...;
     ```
     以更快的速度批量创建大量数据表。（服务器端 2.0.14 及以上版本）
-    说明：批量建表方式要求数据表必须以超级表为模板。
+    
+    说明：
+
+    1）批量建表方式要求数据表必须以超级表为模板。
+
+    2）在不超出 SQL 语句长度限制的前提下，单条语句中的建表数量建议控制在 1000～3000 之间，将会获得比较理想的建表速度。
 
 - **删除数据表**
 
@@ -164,7 +177,9 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
     ```
 
     显示当前数据库下的所有数据表信息。
+
     说明：可在like中使用通配符进行名称的匹配，这一通配符字符串最长不能超过24字节。
+
     通配符匹配：1）’%’ (百分号)匹配0到任意个字符；2）’\_’下划线匹配一个字符。
 
 - **在线修改显示字符宽度**
@@ -185,7 +200,9 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
     ALTER TABLE tb_name ADD COLUMN field_name data_type;
     ```
     说明：
+
     1) 列的最大个数为1024，最小个数为2；
+
     2) 列名最大长度为64；
 
 - **表删除列**
@@ -204,9 +221,13 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
     创建STable, 与创建表的SQL语法相似，但需指定TAGS字段的名称和类型
 
     说明：
+
     1) TAGS 列的数据类型不能是timestamp类型；
+
     2) TAGS 列名不能与其他列名相同；
+
     3) TAGS 列名不能为预留关键字；
+
     4) TAGS 最多允许128个，至少1个，总长度不超过16k个字符。
 
 - **删除超级表**
@@ -333,7 +354,9 @@ SELECT select_expr [, select_expr ...]
     [LIMIT limit_val [, OFFSET offset_val]]
     [>> export_file]
 ```
+
 说明：针对 insert 类型的 SQL 语句，我们采用的流式解析策略，在发现后面的错误之前，前面正确的部分SQL仍会执行。下面的sql中，insert语句是无效的，但是d1001仍会被创建。
+
 ```mysql
 taos> CREATE TABLE meters(ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS(location BINARY(30), groupId INT);
 Query OK, 0 row(s) affected (0.008245s)
@@ -614,10 +637,20 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     SELECT COUNT([*|field_name]) FROM tb_name [WHERE clause];
     ```
     功能说明：统计表/超级表中记录行数或某列的非空值个数。
+
     返回结果数据类型：长整型INT64。
+
     应用字段：应用全部字段。
+
     适用于：表、超级表。
-    说明：1）可以使用星号*来替代具体的字段，使用星号(*)返回全部记录数量。2）针对同一表的（不包含NULL值）字段查询结果均相同。3）如果统计对象是具体的列，则返回该列中非NULL值的记录数量。
+
+    说明：
+
+    1）可以使用星号*来替代具体的字段，使用星号(*)返回全部记录数量。
+
+    2）针对同一表的（不包含NULL值）字段查询结果均相同。
+
+    3）如果统计对象是具体的列，则返回该列中非NULL值的记录数量。
 
     示例：
     ```mysql
@@ -639,8 +672,11 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     SELECT AVG(field_name) FROM tb_name [WHERE clause];
     ```
     功能说明：统计表/超级表中某列的平均值。
+
     返回结果数据类型：双精度浮点数Double。
+
     应用字段：不能应用在timestamp、binary、nchar、bool字段。
+
     适用于：表、超级表。
 
     示例：
@@ -663,8 +699,11 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     SELECT TWA(field_name) FROM tb_name WHERE clause;
     ```
     功能说明：时间加权平均函数。统计表/超级表中某列在一段时间内的时间加权平均。
+
     返回结果数据类型：双精度浮点数Double。
+
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
+
     适用于：表、超级表。
 
 - **SUM**
@@ -672,8 +711,11 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     SELECT SUM(field_name) FROM tb_name [WHERE clause];
     ```
     功能说明：统计表/超级表中某列的和。
+
     返回结果数据类型：双精度浮点数Double和长整型INT64。
+
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
+
     适用于：表、超级表。
 
     示例：
@@ -696,9 +738,12 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     SELECT STDDEV(field_name) FROM tb_name [WHERE clause];
     ```
     功能说明：统计表中某列的均方差。
+
     返回结果数据类型：双精度浮点数Double。
+
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
-    适用于：表。
+
+    适用于：表。（从 2.0.15 版本开始，本函数也支持超级表）
 
     示例：
     ```mysql
@@ -714,9 +759,13 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     SELECT LEASTSQUARES(field_name, start_val, step_val) FROM tb_name [WHERE clause];
     ```
     功能说明：统计表中某列的值是主键（时间戳）的拟合直线方程。start_val是自变量初始值，step_val是自变量的步长值。
+
     返回结果数据类型：字符串表达式（斜率, 截距）。
+
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
+
     说明：自变量是时间戳，因变量是该列的值。
+
     适用于：表。
 
     示例：
@@ -735,7 +784,9 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     SELECT MIN(field_name) FROM {tb_name | stb_name} [WHERE clause];
     ```
     功能说明：统计表/超级表中某列的值最小值。
+
     返回结果数据类型：同应用的字段。
+
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
 
     示例：
@@ -758,7 +809,9 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     SELECT MAX(field_name) FROM { tb_name | stb_name } [WHERE clause];
     ```
     功能说明：统计表/超级表中某列的值最大值。
+
     返回结果数据类型：同应用的字段。
+
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
 
     示例：
@@ -781,9 +834,18 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     SELECT FIRST(field_name) FROM { tb_name | stb_name } [WHERE clause];
     ```
     功能说明：统计表/超级表中某列的值最先写入的非NULL值。
+
     返回结果数据类型：同应用的字段。
+
     应用字段：所有字段。
-    说明：1）如果要返回各个列的首个（时间戳最小）非NULL值，可以使用FIRST(\*)；2) 如果结果集中的某列全部为NULL值，则该列的返回结果也是NULL；3) 如果结果集中所有列全部为NULL值，则不返回结果。
+
+    说明：
+
+    1）如果要返回各个列的首个（时间戳最小）非NULL值，可以使用FIRST(\*)；
+
+    2) 如果结果集中的某列全部为NULL值，则该列的返回结果也是NULL；
+
+    3) 如果结果集中所有列全部为NULL值，则不返回结果。
 
     示例：
     ```mysql
@@ -805,9 +867,16 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     SELECT LAST(field_name) FROM { tb_name | stb_name } [WHERE clause];
     ```
     功能说明：统计表/超级表中某列的值最后写入的非NULL值。
+
     返回结果数据类型：同应用的字段。
+
     应用字段：所有字段。
-    说明：1）如果要返回各个列的最后（时间戳最大）一个非NULL值，可以使用LAST(\*)；2）如果结果集中的某列全部为NULL值，则该列的返回结果也是NULL；如果结果集中所有列全部为NULL值，则不返回结果。
+
+    说明：
+
+    1）如果要返回各个列的最后（时间戳最大）一个非NULL值，可以使用LAST(\*)；
+
+    2）如果结果集中的某列全部为NULL值，则该列的返回结果也是NULL；如果结果集中所有列全部为NULL值，则不返回结果。
 
     示例：
     ```mysql
@@ -829,9 +898,16 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     SELECT TOP(field_name, K) FROM { tb_name | stb_name } [WHERE clause];
     ```
     功能说明： 统计表/超级表中某列的值最大*k*个非NULL值。若多于k个列值并列最大，则返回时间戳小的。
+
     返回结果数据类型：同应用的字段。
+
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
-    说明：1）*k*值取值范围1≤*k*≤100；2）系统同时返回该记录关联的时间戳列。
+
+    说明：
+
+    1）*k*值取值范围1≤*k*≤100；
+
+    2）系统同时返回该记录关联的时间戳列。
 
     示例：
     ```mysql
@@ -856,9 +932,16 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     SELECT BOTTOM(field_name, K) FROM { tb_name | stb_name } [WHERE clause];
     ```
     功能说明：统计表/超级表中某列的值最小*k*个非NULL值。若多于k个列值并列最小，则返回时间戳小的。
+
     返回结果数据类型：同应用的字段。
+
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
-    说明：1）*k*值取值范围1≤*k*≤100；2）系统同时返回该记录关联的时间戳列。
+
+    说明：
+
+    1）*k*值取值范围1≤*k*≤100；
+
+    2）系统同时返回该记录关联的时间戳列。
 
     示例：
     ```mysql
@@ -882,8 +965,11 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     SELECT PERCENTILE(field_name, P) FROM { tb_name } [WHERE clause];
     ```
     功能说明：统计表中某列的值百分比分位数。
+
     返回结果数据类型： 双精度浮点数Double。
+
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
+
     说明：*P*值取值范围0≤*P*≤100，为0的时候等同于MIN，为100的时候等同于MAX。
 
     示例：
@@ -900,9 +986,13 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     SELECT APERCENTILE(field_name, P) FROM { tb_name | stb_name } [WHERE clause];
     ```
     功能说明：统计表中某列的值百分比分位数，与PERCENTILE函数相似，但是返回近似结果。
+
     返回结果数据类型： 双精度浮点数Double。
+
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
+
     说明：*P*值取值范围0≤*P*≤100，为0的时候等同于MIN，为100的时候等同于MAX。推荐使用```APERCENTILE```函数，该函数性能远胜于```PERCENTILE```函数
+
     ```mysql
     taos> SELECT APERCENTILE(current, 20) FROM d1001;
     apercentile(current, 20)  |
@@ -916,8 +1006,11 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     SELECT LAST_ROW(field_name) FROM { tb_name | stb_name };
     ```
     功能说明：返回表（超级表）的最后一条记录。
+
     返回结果数据类型：同应用的字段。
+
     应用字段：所有字段。
+
     说明：与last函数不同，last_row不支持时间范围限制，强制返回最后一条记录。
 
     示例：
@@ -941,8 +1034,11 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     SELECT DIFF(field_name) FROM tb_name [WHERE clause];
     ```
     功能说明：统计表中某列的值与前一行对应值的差。
+
     返回结果数据类型： 同应用字段。
+
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
+
     说明：输出结果行数是范围内总行数减一，第一行没有结果输出。
 
     示例：
@@ -960,8 +1056,11 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     SELECT SPREAD(field_name) FROM { tb_name | stb_name } [WHERE clause];
     ```
     功能说明：统计表/超级表中某列的最大值和最小值之差。
+
     返回结果数据类型： 双精度浮点数。
+
     应用字段：不能应用在binary、nchar、bool类型字段。
+
     说明：可用于TIMESTAMP字段，此时表示记录的时间覆盖范围。
 
     示例：
@@ -985,9 +1084,16 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     SELECT field_name [+|-|*|/|%][Value|field_name] FROM { tb_name | stb_name }  [WHERE clause];
     ```
     功能说明：统计表/超级表中某列或多列间的值加、减、乘、除、取余计算结果。
+
     返回结果数据类型：双精度浮点数。
+
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
-    说明：1）支持两列或多列之间进行计算，可使用括号控制计算优先级;2）NULL字段不参与计算，如果参与计算的某行中包含NULL，该行的计算结果为NULL。
+
+    说明：
+
+    1）支持两列或多列之间进行计算，可使用括号控制计算优先级；
+
+    2）NULL字段不参与计算，如果参与计算的某行中包含NULL，该行的计算结果为NULL。
 
     ```mysql
     taos> SELECT current + voltage * phase FROM d1001;
@@ -1051,7 +1157,7 @@ SELECT AVG(current), MAX(current), LEASTSQUARES(current, start_val, step_val), P
 - 数据库名最大长度为32
 - 表名最大长度为192，每行数据最大长度16k个字符
 - 列名最大长度为64，最多允许1024列，最少需要2列，第一列必须是时间戳
-- 标签最多允许128个，可以0个，标签总长度不超过16k个字符
+- 标签最多允许128个，可以1个，标签总长度不超过16k个字符
 - SQL语句最大长度65480个字符，但可通过系统配置参数maxSQLLength修改，最长可配置为1M
 - 库的数目，超级表的数目、表的数目，系统不做限制，仅受系统资源限制
 

documentation20/webdocs/markdowndocs/administrator-ch.md

@@ -255,7 +255,7 @@ taos -C  或  taos --dump-config
 CREATE USER <user_name> PASS <'password'>;
 ```
 
-创建用户，并指定用户名和密码，密码需要用单引号引起来,单引号为英文半角
+创建用户，并指定用户名和密码，密码需要用单引号引起来，单引号为英文半角
 
 ```sql
 DROP USER <user_name>;
@@ -267,13 +267,15 @@ DROP USER <user_name>;
 ALTER USER <user_name> PASS <'password'>;
 ```
 
-修改用户密码, 为避免被转换为小写，密码需要用单引号引用,单引号为英文半角
+修改用户密码，为避免被转换为小写，密码需要用单引号引用，单引号为英文半角
 
 ```sql
-ALTER USER <user_name> PRIVILEGE <super|write|read>;
+ALTER USER <user_name> PRIVILEGE <write|read>;
 ```
 
-修改用户权限为：super/write/read，不需要添加单引号
+修改用户权限为：write 或 read，不需要添加单引号
+
+说明：系统内共有 super/write/read 三种权限级别，但目前不允许通过 alter 指令把 super 权限赋予用户。
 
 ```mysql
 SHOW USERS;
@@ -432,11 +434,12 @@ TDengine的所有可执行文件默认存放在 _/usr/local/taos/bin_ 目录下
 - 数据库名：不能包含“.”以及特殊字符，不能超过32个字符
 - 表名：不能包含“.”以及特殊字符，与所属数据库名一起，不能超过192个字符
 - 表的列名：不能包含特殊字符，不能超过64个字符
+- 数据库名、表名、列名，都不能以数字开头
 - 表的列数：不能超过1024列
 - 记录的最大长度：包括时间戳8 byte，不能超过16KB
 - 单条SQL语句默认最大字符串长度：65480 byte
 - 数据库副本数：不能超过3
-- 用户名：不能超过20个byte
+- 用户名：不能超过23个byte
 - 用户密码：不能超过15个byte
 - 标签(Tags)数量：不能超过128个
 - 标签的总长度：不能超过16Kbyte

documentation20/webdocs/markdowndocs/architecture-ch.md

@@ -248,7 +248,7 @@ Master Vnode遵循下面的写入流程：
 1. Master vnode收到应用的数据插入请求，验证OK，进入下一步；
 2. 如果系统配置参数walLevel大于0，vnode将把该请求的原始数据包写入数据库日志文件WAL。如果walLevel设置为2，而且fsync设置为0，TDengine还将WAL数据立即落盘，以保证即使宕机，也能从数据库日志文件中恢复数据，避免数据的丢失；
 3. 如果有多个副本，vnode将把数据包转发给同一虚拟节点组内slave vnodes, 该转发包带有数据的版本号(version)；
-4. 写入内存，并加记录加入到skip list；
+4. 写入内存，并将记录加入到skip list；
 5. Master vnode返回确认信息给应用，表示写入成功。
 6. 如果第2，3，4步中任何一步失败，将直接返回错误给应用。
 
@@ -372,7 +372,7 @@ select count(*) from d1001 interval(1h);
 select count(*) from d1001 interval(1h) fill(prev);
 ```
 
-针对d1001设备采集数据统计每小时记录数，如果某一个小时不存在数据，这返回之前一个小时的统计数据。TDengine提供前向插值(prev)、线性插值(linear)、NULL值填充(NULL)、特定值填充(value)。
+针对d1001设备采集数据统计每小时记录数，如果某一个小时不存在数据，则返回之前一个小时的统计数据。TDengine提供前向插值(prev)、线性插值(linear)、NULL值填充(NULL)、特定值填充(value)。
 
 ### 多表聚合查询
 TDengine对每个数据采集点单独建表，但在实际应用中经常需要对不同的采集点数据进行聚合。为高效的进行聚合操作，TDengine引入超级表（STable）的概念。超级表用来代表一特定类型的数据采集点，它是包含多张表的表集合，集合里每张表的模式（schema）完全一致，但每张表都带有自己的静态标签，标签可以多个，可以随时增加、删除和修改。 应用可通过指定标签的过滤条件，对一个STable下的全部或部分表进行聚合或统计操作，这样大大简化应用的开发。其具体流程如下图所示：

documentation20/webdocs/markdowndocs/cluster-ch.md

@@ -218,7 +218,7 @@ SHOW MNODES;
 
 如果一个数据节点离线，TDengine集群将自动检测到。有如下两种情况：
 
-- 该数据节点离线超过一定时间（taos.cfg里配置参数offlineThreshold控制时长)，系统将自动把该数据节点删除，产生系统报警信息，触发负载均衡流程。如果该被删除的数据节点重现上线时，它将无法加入集群，需要系统管理员重新将其添加进集群才会开始工作。
+- 该数据节点离线超过一定时间（taos.cfg里配置参数offlineThreshold控制时长)，系统将自动把该数据节点删除，产生系统报警信息，触发负载均衡流程。如果该被删除的数据节点重新上线时，它将无法加入集群，需要系统管理员重新将其添加进集群才会开始工作。
 - 离线后，在offlineThreshold的时长内重新上线，系统将自动启动数据恢复流程，等数据完全恢复后，该节点将开始正常工作。
 
 **注意：**如果一个虚拟节点组（包括mnode组）里所归属的每个数据节点都处于离线或unsynced状态，必须等该虚拟节点组里的所有数据节点都上线、都能交换状态信息后，才能选出Master，该虚拟节点组才能对外提供服务。比如整个集群有3个数据节点，副本数为3，如果3个数据节点都宕机，然后2个数据节点重启，是无法工作的，只有等3个数据节点都重启成功，才能对外服务。
@@ -227,5 +227,5 @@ SHOW MNODES;
 
 如果副本数为偶数，当一个vnode group里一半vnode不工作时，是无法从中选出master的。同理，一半mnode不工作时，是无法选出mnode的master的，因为存在“split brain”问题。为解决这个问题，TDengine引入了arbitrator的概念。Arbitrator模拟一个vnode或mnode在工作，但只简单的负责网络连接，不处理任何数据插入或访问。只要包含arbitrator在内，超过半数的vnode或mnode工作，那么该vnode group或mnode组就可以正常的提供数据插入或查询服务。比如对于副本数为2的情形，如果一个节点A离线，但另外一个节点B正常，而且能连接到arbitrator, 那么节点B就能正常工作。
 
-TDengine提供一个执行程序tarbitrator, 找任何一台Linux服务器运行它即可。请点击[安装包下载](https://www.taosdata.com/cn/all-downloads/)，在TDengine Arbitrator Linux一节中，选择适合的版本下载并安装。该程序对系统资源几乎没有要求，只需要保证有网络连接即可。该应用的命令行参数`-p`可以指定其对外服务的端口号，缺省是6042。配置每个taosd实例时，可以在配置文件taos.cfg里将参数arbitrator设置为arbitrator的End Point。如果该参数配置了，当副本数为偶数数，系统将自动连接配置的arbitrator。如果副本数为奇数，即使配置了arbitrator, 系统也不会去建立连接。
+TDengine提供一个执行程序tarbitrator, 找任何一台Linux服务器运行它即可。请点击[安装包下载](https://www.taosdata.com/cn/all-downloads/)，在TDengine Arbitrator Linux一节中，选择适合的版本下载并安装。该程序对系统资源几乎没有要求，只需要保证有网络连接即可。该应用的命令行参数`-p`可以指定其对外服务的端口号，缺省是6042。配置每个taosd实例时，可以在配置文件taos.cfg里将参数arbitrator设置为arbitrator的End Point。如果该参数配置了，当副本数为偶数时，系统将自动连接配置的arbitrator。如果副本数为奇数，即使配置了arbitrator, 系统也不会去建立连接。
 

documentation20/webdocs/markdowndocs/cluster.md

@@ -89,6 +89,8 @@ SHOW DNODES;
 ```
 它将列出集群中所有的dnode,每个dnode的fqdn:port, 状态(ready, offline等），vnode数目，还未使用的vnode数目等信息。在添加或删除一个节点后，可以使用该命令查看。
 
+如果集群配置了Arbitrator，那么它也会在这个节点列表中显示出来，其role列的值会是“arb”。
+
 ###查看虚拟节点组
 
 为充分利用多核技术，并提供scalability，数据需要分片处理。因此TDengine会将一个DB的数据切分成多份，存放在多个vnode里。这些vnode可能分布在多个dnode里，这样就实现了水平扩展。一个vnode仅仅属于一个DB，但一个DB可以有多个vnode。vnode的是mnode根据当前系统资源的情况，自动进行分配的，无需任何人工干预。
@@ -139,4 +141,6 @@ SHOW MNODES;
 
 如果副本数为偶数，当一个vnode group里一半vnode不工作时，是无法从中选出master的。同理，一半mnode不工作时，是无法选出mnode的master的，因为存在“split brain”问题。为解决这个问题，TDengine引入了arbitrator的概念。Arbitrator模拟一个vnode或mnode在工作，但只简单的负责网络连接，不处理任何数据插入或访问。只要包含arbitrator在内，超过半数的vnode或mnode工作，那么该vnode group或mnode组就可以正常的提供数据插入或查询服务。比如对于副本数为2的情形，如果一个节点A离线，但另外一个节点B正常，而且能连接到arbitrator, 那么节点B就能正常工作。
 
-TDengine安装包里带有一个执行程序tarbitrator, 找任何一台Linux服务器运行它即可。该程序对系统资源几乎没有要求，只需要保证有网络连接即可。该应用的命令行参数`-p`可以指定其对外服务的端口号，缺省是6030。配置每个taosd实例时，可以在配置文件taos.cfg里将参数arbitrator设置为arbitrator的End Point。如果该参数配置了，当副本数为偶数数，系统将自动连接配置的arbitrator。
+TDengine安装包里带有一个执行程序tarbitrator, 找任何一台Linux服务器运行它即可。该程序对系统资源几乎没有要求，只需要保证有网络连接即可。该应用的命令行参数`-p`可以指定其对外服务的端口号，缺省是6030。配置每个taosd实例时，可以在配置文件taos.cfg里将参数arbitrator设置为Arbitrator的End Point。如果该参数配置了，当副本数为偶数时，系统将自动连接配置的Arbitrator。
+
+在配置了Arbitrator的情况下，它也会显示在“show dnodes;”指令给出的节点列表中。

documentation20/webdocs/markdowndocs/connector-ch.md

@@ -252,7 +252,7 @@ C/C++的API类似于MySQL的C API。应用程序使用时，需要包含TDengine
 
 - `void taos_free_result(TAOS_RES *res)`
 
-  释放查询结果集以及相关的资源。查询完成后，务必调用该API释放资源，否则可能导致应用内存泄露。
+  释放查询结果集以及相关的资源。查询完成后，务必调用该API释放资源，否则可能导致应用内存泄露。但也需注意，释放资源后，如果再调用`taos_consume`等获取查询结果的函数，将导致应用Crash。
 
 - `char *taos_errstr(TAOS_RES *res)`
 
@@ -262,11 +262,11 @@ C/C++的API类似于MySQL的C API。应用程序使用时，需要包含TDengine
 
   获取最近一次API调用失败的原因，返回值为错误代码。
 
-**注意**：对于每个数据库应用，2.0及以上版本 TDengine 推荐只建立一个连接。同时在应用中将该连接 (TAOS*) 结构体传递到不同的线程共享使用。基于 TAOS 结构体发出的查询、写入等操作具有多线程安全性。C 语言的连接器可以按照需求动态建立面向数据库的新连接（该过程对用户不可见），同时建议只有在程序最后退出的时候才调用 taos_close 关闭连接。
+**注意**：2.0及以上版本 TDengine 推荐数据库应用的每个线程都建立一个独立的连接，或基于线程建立连接池。而不推荐在应用中将该连接 (TAOS\*) 结构体传递到不同的线程共享使用。基于 TAOS 结构体发出的查询、写入等操作具有多线程安全性，但 “USE statement” 等状态量有可能在线程之间相互干扰。此外，C 语言的连接器可以按照需求动态建立面向数据库的新连接（该过程对用户不可见），同时建议只有在程序最后退出的时候才调用 taos_close 关闭连接。
 
 ### 异步查询API
 
-同步API之外，TDengine还提供性能更高的异步调用API处理数据插入、查询操作。在软硬件环境相同的情况下，异步API处理数据插入的速度比同步API快2~4倍。异步API采用非阻塞式的调用方式，在系统真正完成某个具体数据库操作前，立即返回。调用的线程可以去处理其他工作，从而可以提升整个应用的性能。异步API在网络延迟严重的情况下，优点尤为突出。
+同步API之外，TDengine还提供性能更高的异步调用API处理数据插入、查询操作。在软硬件环境相同的情况下，异步API处理数据插入的速度比同步API快2\~4倍。异步API采用非阻塞式的调用方式，在系统真正完成某个具体数据库操作前，立即返回。调用的线程可以去处理其他工作，从而可以提升整个应用的性能。异步API在网络延迟严重的情况下，优点尤为突出。
 
 异步API都需要应用提供相应的回调函数，回调函数参数设置如下：前两个参数都是一致的，第三个参数依不同的API而定。第一个参数param是应用调用异步API时提供给系统的，用于回调时，应用能够找回具体操作的上下文，依具体实现而定。第二个参数是SQL操作的结果集，如果为空，比如insert操作，表示没有记录返回，如果不为空，比如select操作，表示有记录返回。
 
@@ -288,13 +288,6 @@ C/C++的API类似于MySQL的C API。应用程序使用时，需要包含TDengine
     * res：`taos_query_a`回调时返回的结果集
     * fp：回调函数。其参数`param`是用户可定义的传递给回调函数的参数结构体；`numOfRows`是获取到的数据的行数（不是整个查询结果集的函数）。 在回调函数中，应用可以通过调用`taos_fetch_row`前向迭代获取批量记录中每一行记录。读完一块内的所有记录后，应用需要在回调函数中继续调用`taos_fetch_rows_a`获取下一批记录进行处理，直到返回的记录数（numOfRows）为零（结果返回完成）或记录数为负值（查询出错）。
 
-- `void taos_fetch_row_a(TAOS_RES *res, void (*fp)(void *param, TAOS_RES *, TAOS_ROW row), void *param);`
-
-  异步获取一条记录。其中：
-
-    * res：`taos_query_a`回调时返回的结果集
-    * fp：回调函数。其参数`param`是应用提供的一个用于回调的参数。回调时，第三个参数`row`指向一行记录。不同于`taos_fetch_rows_a`，应用无需调用`taos_fetch_row`来获取一行数据，更加简单，但数据提取性能不及批量获取的API。
-
 TDengine的异步API均采用非阻塞调用模式。应用程序可以用多线程同时打开多张表，并可以同时对每张打开的表进行查询或者插入操作。需要指出的是，**客户端应用必须确保对同一张表的操作完全串行化**，即对同一个表的插入或查询操作未完成时（未返回时），不能够执行第二个插入或查询操作。
 
 ### 参数绑定API
@@ -425,7 +418,7 @@ cd C:\TDengine\connector\python\windows
 python -m pip install python3\
 ```
 
-*如果机器上没有pip命令，用户可将src/connector/python/python3或src/connector/python/python2下的taos文件夹拷贝到应用程序的目录使用。
+* 如果机器上没有pip命令，用户可将src/connector/python/python3或src/connector/python/python2下的taos文件夹拷贝到应用程序的目录使用。
 对于windows 客户端，安装TDengine windows 客户端后，将C:\TDengine\driver\taos.dll拷贝到C:\windows\system32目录下即可。
 
 ### 使用
@@ -442,7 +435,7 @@ import taos
 conn = taos.connect(host="127.0.0.1", user="root", password="taosdata", config="/etc/taos")
 c1 = conn.cursor()
 ```
-*<em>host</em> 是TDengine 服务端所有IP, <em>config</em> 为客户端配置文件所在目录
+* <em>host</em> 是TDengine 服务端所有IP, <em>config</em> 为客户端配置文件所在目录
 
 * 写入数据
 ```python
@@ -510,17 +503,17 @@ conn.close()
 
 用户可通过python的帮助信息直接查看模块的使用信息，或者参考tests/examples/python中的示例程序。以下为部分常用类和方法：
 
-- _TDengineConnection_类
+- _TDengineConnection_ 类
 
   参考python中help(taos.TDengineConnection)。
-  这个类对应客户端和TDengine建立的一个连接。在客户端多线程的场景下，这个连接实例可以是每个线程申请一个，也可以多线程共享一个连接。
+  这个类对应客户端和TDengine建立的一个连接。在客户端多线程的场景下，推荐每个线程申请一个独立的连接实例，而不建议多线程共享一个连接。
 
-- _TDengineCursor_类
+- _TDengineCursor_ 类
 
   参考python中help(taos.TDengineCursor)。
   这个类对应客户端进行的写入、查询操作。在客户端多线程的场景下，这个游标实例必须保持线程独享，不能夸线程共享使用，否则会导致返回结果出现错误。
 
-- _connect_方法
+- _connect_ 方法
 
   用于生成taos.TDengineConnection的实例。
 
@@ -800,7 +793,7 @@ go env -w GOPROXY=https://goproxy.io,direct
 
 - `sql.Open(DRIVER_NAME string, dataSourceName string) *DB` 
 
-  该API用来打开DB，返回一个类型为*DB的对象，一般情况下，DRIVER_NAME设置为字符串`taosSql`, dataSourceName设置为字符串`user:password@/tcp(host:port)/dbname`，如果客户想要用多个goroutine并发访问TDengine, 那么需要在各个goroutine中分别创建一个sql.Open对象并用之访问TDengine
+  该API用来打开DB，返回一个类型为\*DB的对象，一般情况下，DRIVER_NAME设置为字符串`taosSql`, dataSourceName设置为字符串`user:password@/tcp(host:port)/dbname`，如果客户想要用多个goroutine并发访问TDengine, 那么需要在各个goroutine中分别创建一个sql.Open对象并用之访问TDengine
 
   **注意**： 该API成功创建的时候，并没有做权限等检查，只有在真正执行Query或者Exec的时候才能真正的去创建连接，并同时检查user/password/host/port是不是合法。 另外，由于整个驱动程序大部分实现都下沉到taosSql所依赖的libtaos中。所以，sql.Open本身特别轻量。 
 
@@ -822,7 +815,7 @@ go env -w GOPROXY=https://goproxy.io,direct
 
 - `func (s *Stmt) Query(args ...interface{}) (*Rows, error)`
 
-  sql.Open内置的方法，Query executes a prepared query statement with the given arguments and returns the query results as a *Rows.
+  sql.Open内置的方法，Query executes a prepared query statement with the given arguments and returns the query results as a \*Rows.
 
 - `func (s *Stmt) Close() error`
 
@@ -894,7 +887,7 @@ Node-example-raw.js
 
 验证方法：
 
-1. 新建安装验证目录，例如：~/tdengine-test，拷贝github上nodejsChecker.js源程序。下载地址：（https://github.com/taosdata/TDengine/tree/develop/tests/examples/nodejs/nodejsChecker.js）。
+1. 新建安装验证目录，例如：\~/tdengine-test，拷贝github上nodejsChecker.js源程序。下载地址：（https://github.com/taosdata/TDengine/tree/develop/tests/examples/nodejs/nodejsChecker.js）。
 
 2. 在命令中执行以下命令：
 

documentation20/webdocs/markdowndocs/faq-ch.md

 # 常见问题
 
+## 0. 怎么报告问题？
+
+如果 FAQ 中的信息不能够帮到您，需要 TDengine 技术团队的技术支持与协助，请将以下两个目录中内容打包：
+1. /var/log/taos （如果没有修改过默认路径）
+2. /etc/taos
+
+附上必要的问题描述，包括使用的 TDengine 版本信息、平台环境信息、发生该问题的执行操作、出现问题的表征及大概的时间，在<a href='https://github.com/taosdata/TDengine'> GitHub</a>提交Issue。
+
+为了保证有足够的debug信息，如果问题能够重复，请修改/etc/taos/taos.cfg文件，最后面添加一行“debugFlag 135"(不带引号本身），然后重启taosd, 重复问题，然后再递交。也可以通过如下SQL语句，临时设置taosd的日志级别。
+```
+    alter dnode <dnode_id> debugFlag 135;
+```
+但系统正常运行时，请一定将debugFlag设置为131，否则会产生大量的日志信息，降低系统效率。
+
 ## 1. TDengine2.0之前的版本升级到2.0及以上的版本应该注意什么？☆☆☆
 
 2.0版本在之前版本的基础上，进行了完全的重构，配置文件和数据文件是不兼容的。在升级之前务必进行如下操作：
@@ -118,16 +132,8 @@ TDengine是根据hostname唯一标志一台机器的，在数据文件从机器A
 - 2.0.7.0 及以后的版本，到/var/lib/taos/dnode下，修复dnodeEps.json的dnodeId对应的FQDN，重启。确保机器内所有机器的此文件是完全相同的。
 - 1.x 和 2.x 版本的存储结构不兼容，需要使用迁移工具或者自己开发应用导出导入数据。
 
-## 17. 怎么报告问题？
+## 17. TDengine 是否支持删除或更新已经写入的数据？
 
-如果 FAQ 中的信息不能够帮到您，需要 TDengine 技术团队的技术支持与协助，请将以下两个目录中内容打包：
-1. /var/log/taos
-2. /etc/taos
+TDengine 目前尚不支持删除功能，未来根据用户需求可能会支持。
 
-附上必要的问题描述，以及发生该问题的执行操作，出现问题的表征及大概的时间，在<a href='https://github.com/taosdata/TDengine'> GitHub</a>提交Issue。
-
+从 2.0.8.0 开始，TDengine 支持更新已经写入数据的功能。使用更新功能需要在创建数据库时使用 UPDATE 1 参数，之后可以使用 INSERT INTO 命令更新已经写入的相同时间戳数据。UPDATE 参数不支持 ALTER DATABASE 命令修改。没有使用 UPDATE 1 参数创建的数据库，写入相同时间戳的数据不会修改之前的数据，也不会报错。
\ No newline at end of file
-为了保证有足够的debug信息，如果问题能够重复，请修改/etc/taos/taos.cfg文件，最后面添加一行“debugFlag 135"(不带引号本身），然后重启taosd, 重复问题，然后再递交。也可以通过如下SQL语句，临时设置taosd的日志级别。
-```
-    alter dnode <dnode_id> debugFlag 135;
-```
-但系统正常运行时，请一定将debugFlag设置为131，否则会产生大量的日志信息，降低系统效率。

packaging/cfg/taos.cfg

@@ -162,10 +162,10 @@
 # stop writing logs when the disk size of the log folder is less than this value
 # minimalLogDirGB       0.1
 
-# stop writing temporary files when the disk size of the log folder is less than this value
+# stop writing temporary files when the disk size of the tmp folder is less than this value
 # minimalTmpDirGB       0.1
 
-# stop writing data when the disk size of the log folder is less than this value
+# if disk free space is less than this value, taosd service exit directly within startup process
 # minimalDataDirGB      0.1
 
 # One mnode is equal to the number of vnode consumed

snap/snapcraft.yaml

 name: tdengine
 base: core18
-version: '2.0.13.0'
+version: '2.0.14.0'
 icon: snap/gui/t-dengine.svg
 summary: an open-source big data platform designed and optimized for IoT. 
 description: |
@@ -72,7 +72,7 @@ parts:
       - usr/bin/taosd
       - usr/bin/taos
       - usr/bin/taosdemo
-      - usr/lib/libtaos.so.2.0.13.0
+      - usr/lib/libtaos.so.2.0.14.0
       - usr/lib/libtaos.so.1
       - usr/lib/libtaos.so
 

src/client/inc/tscSubquery.h

@@ -47,7 +47,6 @@ void tscLockByThread(int64_t *lockedBy);
 
 void tscUnlockByThread(int64_t *lockedBy);
 
-
 #ifdef __cplusplus
 }
 #endif

src/client/inc/tsclient.h

@@ -317,7 +317,8 @@ typedef struct STscObj {
 } STscObj;
 
 typedef struct SSubqueryState {
-  int32_t  numOfRemain;         // the number of remain unfinished subquery
+  pthread_mutex_t mutex;
+  int8_t  *states;
   int32_t  numOfSub;            // the number of total sub-queries
   uint64_t numOfRetrievedRows;  // total number of points in this query
 } SSubqueryState;

src/client/src/tscLocalMerge.c

@@ -1422,6 +1422,10 @@ int32_t tscDoLocalMerge(SSqlObj *pSql) {
   tscResetForNextRetrieve(pRes);
 
   if (pSql->signature != pSql || pRes == NULL || pRes->pLocalMerger == NULL) {  // all data has been processed
+    if (pRes->code == TSDB_CODE_SUCCESS) {
+      return pRes->code;
+    }
+
     tscError("%p local merge abort due to error occurs, code:%s", pSql, tstrerror(pRes->code));
     return pRes->code;
   }

src/client/src/tscSQLParser.c

@@ -264,6 +264,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     case TSDB_SQL_DROP_DB: {
       const char* msg2 = "invalid name";
       const char* msg3 = "param name too long";
+      const char* msg4 = "table is not super table";
 
       SStrToken* pzName = taosArrayGet(pInfo->pMiscInfo->a, 0);
       if ((pInfo->type != TSDB_SQL_DROP_DNODE) && (tscValidateName(pzName) != TSDB_CODE_SUCCESS)) {
@@ -284,6 +285,18 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
         if(code != TSDB_CODE_SUCCESS) {
           return code; 
         }
+
+        if (pInfo->pMiscInfo->tableType == TSDB_SUPER_TABLE) {
+          code = tscGetTableMeta(pSql, pTableMetaInfo);
+          if (code != TSDB_CODE_SUCCESS) {
+            return code;
+          }
+
+          if (!UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
+            return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+          }
+        }
+        
       } else if (pInfo->type == TSDB_SQL_DROP_DNODE) {
         pzName->n = strdequote(pzName->z);
         strncpy(pCmd->payload, pzName->z, pzName->n);
@@ -4803,6 +4816,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   const char* msg17 = "invalid column name";
   const char* msg18 = "primary timestamp column cannot be dropped";
   const char* msg19 = "invalid new tag name";
+  const char* msg20 = "table is not super table";
 
   int32_t code = TSDB_CODE_SUCCESS;
 
@@ -4828,6 +4842,10 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
   STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
 
+  if (pAlterSQL->tableType == TSDB_SUPER_TABLE && !(UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo))) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg20);
+  }
+
   if (pAlterSQL->type == TSDB_ALTER_TABLE_ADD_TAG_COLUMN || pAlterSQL->type == TSDB_ALTER_TABLE_DROP_TAG_COLUMN ||
       pAlterSQL->type == TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN) {
     if (UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo)) {
@@ -6119,8 +6137,10 @@ void tscPrintSelectClause(SSqlObj* pSql, int32_t subClauseIndex) {
     int32_t tmpLen = 0;
     tmpLen =
         sprintf(tmpBuf, "%s(uid:%" PRId64 ", %d)", aAggs[pExpr->functionId].aName, pExpr->uid, pExpr->colInfo.colId);
+
     if (tmpLen + offset >= totalBufSize - 1) break;
 
+
     offset += sprintf(str + offset, "%s", tmpBuf);
 
     if (i < size - 1) {
@@ -6130,6 +6150,7 @@ void tscPrintSelectClause(SSqlObj* pSql, int32_t subClauseIndex) {
 
   assert(offset < totalBufSize);
   str[offset] = ']';
+  assert(offset < totalBufSize);
   tscDebug("%p select clause:%s", pSql, str);
 }
 

src/client/src/tscServer.c

@@ -2180,7 +2180,7 @@ int tscProcessDropTableRsp(SSqlObj *pSql) {
   taosHashRemove(tscTableMetaInfo, name, strnlen(name, TSDB_TABLE_FNAME_LEN));
   tscDebug("%p remove table meta after drop table:%s, numOfRemain:%d", pSql, name, (int32_t) taosHashGetSize(tscTableMetaInfo));
 
-  assert(pTableMetaInfo->pTableMeta == NULL);
+  pTableMetaInfo->pTableMeta = NULL;
   return 0;
 }
 

src/client/src/tscSubquery.c

@@ -55,6 +55,58 @@ static void skipRemainValue(STSBuf* pTSBuf, tVariant* tag1) {
   }
 }
 
+static void subquerySetState(SSqlObj *pSql, SSubqueryState *subState, int idx, int8_t state) {
+  assert(idx < subState->numOfSub);
+  assert(subState->states);
+
+  pthread_mutex_lock(&subState->mutex);
+  
+  tscDebug("subquery:%p,%d state set to %d", pSql, idx, state);
+  
+  subState->states[idx] = state;
+
+  pthread_mutex_unlock(&subState->mutex);
+}
+
+static bool allSubqueryDone(SSqlObj *pParentSql) {
+  bool done = true;
+  SSubqueryState *subState = &pParentSql->subState;
+
+  //lock in caller
+  
+  for (int i = 0; i < subState->numOfSub; i++) {
+    if (0 == subState->states[i]) {
+      tscDebug("%p subquery:%p,%d is NOT finished, total:%d", pParentSql, pParentSql->pSubs[i], i, subState->numOfSub);
+      done = false;
+      break;
+    } else {
+      tscDebug("%p subquery:%p,%d is finished, total:%d", pParentSql, pParentSql->pSubs[i], i, subState->numOfSub);
+    }
+  }
+
+  return done;
+}
+
+static bool subAndCheckDone(SSqlObj *pSql, SSqlObj *pParentSql, int idx) {
+  SSubqueryState *subState = &pParentSql->subState;
+
+  assert(idx < subState->numOfSub);
+
+  pthread_mutex_lock(&subState->mutex);
+
+  tscDebug("%p subquery:%p,%d state set to 1", pParentSql, pSql, idx);
+  
+  subState->states[idx] = 1;
+
+  bool done = allSubqueryDone(pParentSql);
+
+  pthread_mutex_unlock(&subState->mutex);
+
+  return done;
+}
+
+
+
 static int64_t doTSBlockIntersect(SSqlObj* pSql, SJoinSupporter* pSupporter1, SJoinSupporter* pSupporter2, STimeWindow * win) {
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, pSql->cmd.clauseIndex);
 
@@ -367,10 +419,6 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
   // scan all subquery, if one sub query has only ts, ignore it
   tscDebug("%p start to launch secondary subqueries, %d out of %d needs to query", pSql, numOfSub, pSql->subState.numOfSub);
 
-  //the subqueries that do not actually launch the secondary query to virtual node is set as completed.
-  SSubqueryState* pState = &pSql->subState;
-  pState->numOfRemain = numOfSub;
-
   bool success = true;
   
   for (int32_t i = 0; i < pSql->subState.numOfSub; ++i) {
@@ -404,6 +452,7 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
       break;
     }
     
+
     tscClearSubqueryInfo(&pNew->cmd);
     pSql->pSubs[i] = pNew;
   
@@ -480,6 +529,8 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
       }
     }
 
+    subquerySetState(pPrevSub, &pSql->subState, i, 0);
+    
     size_t numOfCols = taosArrayGetSize(pQueryInfo->colList);
     tscDebug("%p subquery:%p tableIndex:%d, vgroupIndex:%d, type:%d, exprInfo:%" PRIzu ", colList:%" PRIzu ", fieldsInfo:%d, name:%s",
              pSql, pNew, 0, pTableMetaInfo->vgroupIndex, pQueryInfo->type, taosArrayGetSize(pQueryInfo->exprList),
@@ -517,20 +568,25 @@ void freeJoinSubqueryObj(SSqlObj* pSql) {
     SJoinSupporter* p = pSub->param;
     tscDestroyJoinSupporter(p);
 
-    if (pSub->res.code == TSDB_CODE_SUCCESS) {
     taos_free_result(pSub);
+    pSql->pSubs[i] = NULL;
   }
+
+  if (pSql->subState.states) {
+    pthread_mutex_destroy(&pSql->subState.mutex);
   }
   
+  tfree(pSql->subState.states);
+  
+  
   pSql->subState.numOfSub = 0;
 }
 
-static void quitAllSubquery(SSqlObj* pSqlObj, SJoinSupporter* pSupporter) {
-  assert(pSqlObj->subState.numOfRemain > 0);
-
-  if (atomic_sub_fetch_32(&pSqlObj->subState.numOfRemain, 1) <= 0) {
+static void quitAllSubquery(SSqlObj* pSqlSub, SSqlObj* pSqlObj, SJoinSupporter* pSupporter) {
+  if (subAndCheckDone(pSqlSub, pSqlObj, pSupporter->subqueryIndex)) {
     tscError("%p all subquery return and query failed, global code:%s", pSqlObj, tstrerror(pSqlObj->res.code));  
     freeJoinSubqueryObj(pSqlObj);
+    return;
   }
 
   //tscDestroyJoinSupporter(pSupporter);
@@ -777,6 +833,15 @@ static void tidTagRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
   assert(TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_TAG_FILTER_QUERY));
 
+  if (pParentSql->res.code != TSDB_CODE_SUCCESS) {
+    tscError("%p abort query due to other subquery failure. code:%d, global code:%d", pSql, numOfRows, pParentSql->res.code);
+    quitAllSubquery(pSql, pParentSql, pSupporter);
+
+    tscAsyncResultOnError(pParentSql);
+
+    return;
+  }
+
   // check for the error code firstly
   if (taos_errno(pSql) != TSDB_CODE_SUCCESS) {
     // todo retry if other subqueries are not failed
@@ -785,7 +850,7 @@ static void tidTagRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
     tscError("%p sub query failed, code:%s, index:%d", pSql, tstrerror(numOfRows), pSupporter->subqueryIndex);
 
     pParentSql->res.code = numOfRows;
-    quitAllSubquery(pParentSql, pSupporter);
+    quitAllSubquery(pSql, pParentSql, pSupporter);
 
     tscAsyncResultOnError(pParentSql);
     return;
@@ -802,7 +867,7 @@ static void tidTagRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
       tscError("%p failed to malloc memory", pSql);
 
       pParentSql->res.code = TAOS_SYSTEM_ERROR(errno);
-      quitAllSubquery(pParentSql, pSupporter);
+      quitAllSubquery(pSql, pParentSql, pSupporter);
 
       tscAsyncResultOnError(pParentSql);
       return;
@@ -844,7 +909,8 @@ static void tidTagRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
 
   // no data exists in next vnode, mark the <tid, tags> query completed
   // only when there is no subquery exits any more, proceeds to get the intersect of the <tid, tags> tuple sets.
-  if (atomic_sub_fetch_32(&pParentSql->subState.numOfRemain, 1) > 0) {
+  if (!subAndCheckDone(pSql, pParentSql, pSupporter->subqueryIndex)) {
+    tscDebug("%p tagRetrieve:%p,%d completed, total:%d", pParentSql, tres, pSupporter->subqueryIndex, pParentSql->subState.numOfSub);
     return;
   }  
 
@@ -891,7 +957,9 @@ static void tidTagRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
     ((SJoinSupporter*)psub2->param)->pVgroupTables =  tscVgroupTableInfoDup(pTableMetaInfo2->pVgroupTables);
 
     pParentSql->subState.numOfSub = 2;
-    pParentSql->subState.numOfRemain = pParentSql->subState.numOfSub;
+    
+    memset(pParentSql->subState.states, 0, sizeof(pParentSql->subState.states[0]) * pParentSql->subState.numOfSub);
+    tscDebug("%p reset all sub states to 0", pParentSql);
     
     for (int32_t m = 0; m < pParentSql->subState.numOfSub; ++m) {
       SSqlObj* sub = pParentSql->pSubs[m];
@@ -915,6 +983,15 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
   assert(!TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_JOIN_SEC_STAGE));
 
+  if (pParentSql->res.code != TSDB_CODE_SUCCESS) {
+    tscError("%p abort query due to other subquery failure. code:%d, global code:%d", pSql, numOfRows, pParentSql->res.code);
+    quitAllSubquery(pSql, pParentSql, pSupporter);
+
+    tscAsyncResultOnError(pParentSql);
+
+    return;
+  }
+
   // check for the error code firstly
   if (taos_errno(pSql) != TSDB_CODE_SUCCESS) {
     // todo retry if other subqueries are not failed yet 
@@ -922,7 +999,7 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
     tscError("%p sub query failed, code:%s, index:%d", pSql, tstrerror(numOfRows), pSupporter->subqueryIndex);
 
     pParentSql->res.code = numOfRows;
-    quitAllSubquery(pParentSql, pSupporter);
+    quitAllSubquery(pSql, pParentSql, pSupporter);
 
     tscAsyncResultOnError(pParentSql);
     return;
@@ -937,7 +1014,7 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
         
         pParentSql->res.code = TAOS_SYSTEM_ERROR(errno);
 
-        quitAllSubquery(pParentSql, pSupporter);
+        quitAllSubquery(pSql, pParentSql, pSupporter);
         
         tscAsyncResultOnError(pParentSql);
 
@@ -955,7 +1032,7 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
 
       pParentSql->res.code = TAOS_SYSTEM_ERROR(errno);
 
-      quitAllSubquery(pParentSql, pSupporter);
+      quitAllSubquery(pSql, pParentSql, pSupporter);
       
       tscAsyncResultOnError(pParentSql);
 
@@ -1009,7 +1086,7 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
     return;
   }
 
-  if (atomic_sub_fetch_32(&pParentSql->subState.numOfRemain, 1) > 0) {
+  if (!subAndCheckDone(pSql, pParentSql, pSupporter->subqueryIndex)) {
     return;
   }  
 
@@ -1049,6 +1126,17 @@ static void joinRetrieveFinalResCallback(void* param, TAOS_RES* tres, int numOfR
   SSqlRes* pRes = &pSql->res;
 
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
+
+  if (pParentSql->res.code != TSDB_CODE_SUCCESS) {
+    tscError("%p abort query due to other subquery failure. code:%d, global code:%d", pSql, numOfRows, pParentSql->res.code);
+    quitAllSubquery(pSql, pParentSql, pSupporter);
+
+    tscAsyncResultOnError(pParentSql);
+
+    return;
+  }
+
+  
   if (taos_errno(pSql) != TSDB_CODE_SUCCESS) {
     assert(numOfRows == taos_errno(pSql));
 
@@ -1088,9 +1176,8 @@ static void joinRetrieveFinalResCallback(void* param, TAOS_RES* tres, int numOfR
     }
   }
 
-  assert(pState->numOfRemain > 0);
-  if (atomic_sub_fetch_32(&pState->numOfRemain, 1) > 0) {
-    tscDebug("%p sub:%p completed, remain:%d, total:%d", pParentSql, tres, pState->numOfRemain, pState->numOfSub);
+  if (!subAndCheckDone(pSql, pParentSql, pSupporter->subqueryIndex)) {
+    tscDebug("%p sub:%p,%d completed, total:%d", pParentSql, tres, pSupporter->subqueryIndex, pState->numOfSub);
     return;
   }
 
@@ -1205,16 +1292,17 @@ void tscFetchDatablockForSubquery(SSqlObj* pSql) {
       }
     }
 
-    // get the number of subquery that need to retrieve the next vnode.
+
     if (orderedPrjQuery) {
       for (int32_t i = 0; i < pSql->subState.numOfSub; ++i) {
         SSqlObj* pSub = pSql->pSubs[i];
         if (pSub != NULL && pSub->res.row >= pSub->res.numOfRows && pSub->res.completed) {
-          pSql->subState.numOfRemain++;
+          subquerySetState(pSub, &pSql->subState, i, 0);
         }
       }
     }
     
+
     for (int32_t i = 0; i < pSql->subState.numOfSub; ++i) {
       SSqlObj* pSub = pSql->pSubs[i];
       if (pSub == NULL) {
@@ -1270,7 +1358,19 @@ void tscFetchDatablockForSubquery(SSqlObj* pSql) {
   // retrieve data from current vnode.
   tscDebug("%p retrieve data from %d subqueries", pSql, numOfFetch);
   SJoinSupporter* pSupporter = NULL;
-  pSql->subState.numOfRemain = numOfFetch;
+
+  for (int32_t i = 0; i < pSql->subState.numOfSub; ++i) {
+    SSqlObj* pSql1 = pSql->pSubs[i];
+    if (pSql1 == NULL) {
+      continue;
+    }
+
+    SSqlRes* pRes1 = &pSql1->res;
+
+    if (pRes1->row >= pRes1->numOfRows) {
+      subquerySetState(pSql1, &pSql->subState, i, 0);
+    }
+  }
 
   for (int32_t i = 0; i < pSql->subState.numOfSub; ++i) {
     SSqlObj* pSql1 = pSql->pSubs[i];
@@ -1372,7 +1472,8 @@ void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {
   // retrieve actual query results from vnode during the second stage join subquery
   if (pParentSql->res.code != TSDB_CODE_SUCCESS) {
     tscError("%p abort query due to other subquery failure. code:%d, global code:%d", pSql, code, pParentSql->res.code);
-    quitAllSubquery(pParentSql, pSupporter);
+    quitAllSubquery(pSql, pParentSql, pSupporter);
+
     tscAsyncResultOnError(pParentSql);
 
     return;
@@ -1384,7 +1485,8 @@ void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {
 
     tscError("%p abort query, code:%s, global code:%s", pSql, tstrerror(code), tstrerror(pParentSql->res.code));
     pParentSql->res.code = code;
-    quitAllSubquery(pParentSql, pSupporter);
+
+    quitAllSubquery(pSql, pParentSql, pSupporter);
     tscAsyncResultOnError(pParentSql);
 
     return;
@@ -1408,7 +1510,7 @@ void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {
 
   // In case of consequence query from other vnode, do not wait for other query response here.
   if (!(pTableMetaInfo->vgroupIndex > 0 && tscNonOrderedProjectionQueryOnSTable(pQueryInfo, 0))) {
-    if (atomic_sub_fetch_32(&pParentSql->subState.numOfRemain, 1) > 0) {
+    if (!subAndCheckDone(pSql, pParentSql, pSupporter->subqueryIndex)) {
       return;
     }      
   }
@@ -1422,6 +1524,7 @@ void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {
   if (pTableMetaInfo->vgroupIndex > 0 && tscNonOrderedProjectionQueryOnSTable(pQueryInfo, 0)) {
     pSql->fp = joinRetrieveFinalResCallback;  // continue retrieve data
     pSql->cmd.command = TSDB_SQL_FETCH;
+    
     tscProcessSql(pSql);
   } else {  // first retrieve from vnode during the secondary stage sub-query
     // set the command flag must be after the semaphore been correctly set.
@@ -1457,8 +1560,7 @@ int32_t tscCreateJoinSubquery(SSqlObj *pSql, int16_t tableIndex, SJoinSupporter
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
   
-  pSql->pSubs[pSql->subState.numOfRemain++] = pNew;
-  assert(pSql->subState.numOfRemain <= pSql->subState.numOfSub);
+  pSql->pSubs[tableIndex] = pNew;
   
   if (QUERY_IS_JOIN_QUERY(pQueryInfo->type)) {
     addGroupInfoForSubquery(pSql, pNew, 0, tableIndex);
@@ -1590,6 +1692,19 @@ void tscHandleMasterJoinQuery(SSqlObj* pSql) {
   int32_t code = TSDB_CODE_SUCCESS;
   pSql->subState.numOfSub = pQueryInfo->numOfTables;
 
+  if (pSql->subState.states == NULL) {
+    pSql->subState.states = calloc(pSql->subState.numOfSub, sizeof(*pSql->subState.states));
+    if (pSql->subState.states == NULL) {
+      code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+      goto _error;
+    }
+    
+    pthread_mutex_init(&pSql->subState.mutex, NULL);
+  }
+
+  memset(pSql->subState.states, 0, sizeof(*pSql->subState.states) * pSql->subState.numOfSub);
+  tscDebug("%p reset all sub states to 0", pSql);
+  
   bool hasEmptySub = false;
 
   tscDebug("%p start subquery, total:%d", pSql, pQueryInfo->numOfTables);
@@ -1622,14 +1737,25 @@ void tscHandleMasterJoinQuery(SSqlObj* pSql) {
     pSql->cmd.command = TSDB_SQL_RETRIEVE_EMPTY_RESULT;
     (*pSql->fp)(pSql->param, pSql, 0);
   } else {
+    int fail = 0;
     for (int32_t i = 0; i < pSql->subState.numOfSub; ++i) {
       SSqlObj* pSub = pSql->pSubs[i];
+      if (fail) {
+        (*pSub->fp)(pSub->param, pSub, 0);
+        continue;
+      }
+      
       if ((code = tscProcessSql(pSub)) != TSDB_CODE_SUCCESS) {
-        pSql->subState.numOfRemain = i - 1;  // the already sent request will continue and do not go to the error process routine
-        break;
+        pRes->code = code;
+        (*pSub->fp)(pSub->param, pSub, 0);
+        fail = 1;
       }
     }
 
+    if(fail) {
+      return;
+    }
+
     pSql->cmd.command = TSDB_SQL_TABLE_JOIN_RETRIEVE;
   }
 
@@ -1728,7 +1854,21 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
     return ret;
   }
 
-  pState->numOfRemain = pState->numOfSub;
+  if (pState->states == NULL) {
+    pState->states = calloc(pState->numOfSub, sizeof(*pState->states));
+    if (pState->states == NULL) {
+      pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+      tscAsyncResultOnError(pSql);
+      tfree(pMemoryBuf);
+      return ret;
+    }
+
+    pthread_mutex_init(&pState->mutex, NULL);
+  }
+
+  memset(pState->states, 0, sizeof(*pState->states) * pState->numOfSub);
+  tscDebug("%p reset all sub states to 0", pSql);
+  
   pRes->code = TSDB_CODE_SUCCESS;
   
   int32_t i = 0;
@@ -1877,7 +2017,6 @@ void tscHandleSubqueryError(SRetrieveSupport *trsupport, SSqlObj *pSql, int numO
   assert(pSql != NULL);
 
   SSubqueryState* pState = &pParentSql->subState;
-  assert(pState->numOfRemain <= pState->numOfSub && pState->numOfRemain >= 0);
 
   // retrieved in subquery failed. OR query cancelled in retrieve phase.
   if (taos_errno(pSql) == TSDB_CODE_SUCCESS && pParentSql->res.code != TSDB_CODE_SUCCESS) {
@@ -1908,10 +2047,8 @@ void tscHandleSubqueryError(SRetrieveSupport *trsupport, SSqlObj *pSql, int numO
     }
   }
 
-  int32_t remain = -1;
-  if ((remain = atomic_sub_fetch_32(&pState->numOfRemain, 1)) > 0) {
-    tscDebug("%p sub:%p orderOfSub:%d freed, finished subqueries:%d", pParentSql, pSql, trsupport->subqueryIndex,
-        pState->numOfSub - remain);
+  if (!subAndCheckDone(pSql, pParentSql, subqueryIndex)) {
+    tscDebug("%p sub:%p,%d freed, not finished, total:%d", pParentSql, pSql, trsupport->subqueryIndex, pState->numOfSub);
 
     tscFreeRetrieveSup(pSql);
     return;
@@ -1980,10 +2117,8 @@ static void tscAllDataRetrievedFromDnode(SRetrieveSupport *trsupport, SSqlObj* p
     return;
   }
   
-  int32_t remain = -1;
-  if ((remain = atomic_sub_fetch_32(&pParentSql->subState.numOfRemain, 1)) > 0) {
-    tscDebug("%p sub:%p orderOfSub:%d freed, finished subqueries:%d", pParentSql, pSql, trsupport->subqueryIndex,
-        pState->numOfSub - remain);
+  if (!subAndCheckDone(pSql, pParentSql, idx)) {
+    tscDebug("%p sub:%p orderOfSub:%d freed, not finished", pParentSql, pSql, trsupport->subqueryIndex);
 
     tscFreeRetrieveSup(pSql);
     return;
@@ -2033,7 +2168,6 @@ static void tscRetrieveFromDnodeCallBack(void *param, TAOS_RES *tres, int numOfR
   SSqlObj *         pParentSql = trsupport->pParentSql;
 
   SSubqueryState* pState = &pParentSql->subState;
-  assert(pState->numOfRemain <= pState->numOfSub && pState->numOfRemain >= 0);
   
   STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0, 0);
   SVgroupInfo  *pVgroup = &pTableMetaInfo->vgroupList->vgroups[0];
@@ -2254,7 +2388,8 @@ static void multiVnodeInsertFinalize(void* param, TAOS_RES* tres, int numOfRows)
     }
   }
 
-  if (atomic_sub_fetch_32(&pParentObj->subState.numOfRemain, 1) > 0) {
+  if (!subAndCheckDone(tres, pParentObj, pSupporter->index)) {
+    tscDebug("%p insert:%p,%d completed, total:%d", pParentObj, tres, pSupporter->index, pParentObj->subState.numOfSub);
     return;
   }
 
@@ -2288,6 +2423,8 @@ static void multiVnodeInsertFinalize(void* param, TAOS_RES* tres, int numOfRows)
         STableMetaInfo* pMasterTableMetaInfo = tscGetTableMetaInfoFromCmd(&pParentObj->cmd, pSql->cmd.clauseIndex, 0);
         tscAddTableMetaInfo(pQueryInfo, &pMasterTableMetaInfo->name, NULL, NULL, NULL, NULL);
 
+        subquerySetState(pSql, &pParentObj->subState, i, 0);
+
         tscDebug("%p, failed sub:%d, %p", pParentObj, i, pSql);
       }
     }
@@ -2303,7 +2440,6 @@ static void multiVnodeInsertFinalize(void* param, TAOS_RES* tres, int numOfRows)
     }
 
     pParentObj->cmd.parseFinished = false;
-    pParentObj->subState.numOfRemain = numOfFailed;
 
     tscResetSqlCmdObj(&pParentObj->cmd);
 
@@ -2379,7 +2515,19 @@ int32_t tscHandleMultivnodeInsert(SSqlObj *pSql) {
   // the number of already initialized subqueries
   int32_t numOfSub = 0;
 
-  pSql->subState.numOfRemain = pSql->subState.numOfSub;
+  if (pSql->subState.states == NULL) {
+    pSql->subState.states = calloc(pSql->subState.numOfSub, sizeof(*pSql->subState.states));
+    if (pSql->subState.states == NULL) {
+      pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+      goto _error;
+    }
+
+    pthread_mutex_init(&pSql->subState.mutex, NULL);
+  }
+
+  memset(pSql->subState.states, 0, sizeof(*pSql->subState.states) * pSql->subState.numOfSub);
+  tscDebug("%p reset all sub states to 0", pSql);
+
   pSql->pSubs = calloc(pSql->subState.numOfSub, POINTER_BYTES);
   if (pSql->pSubs == NULL) {
     goto _error;

src/client/src/tscUtil.c

@@ -426,6 +426,12 @@ static void tscFreeSubobj(SSqlObj* pSql) {
     pSql->pSubs[i] = NULL;
   }
 
+  if (pSql->subState.states) {
+    pthread_mutex_destroy(&pSql->subState.mutex);
+  }
+
+  tfree(pSql->subState.states);
+
   pSql->subState.numOfSub = 0;
 }
 

src/common/src/tvariant.c

@@ -399,6 +399,7 @@ static int32_t toNchar(tVariant *pVariant, char **pDest, int32_t *pDestSize) {
     pVariant->wpz = (wchar_t *)tmp;
   } else {
     int32_t output = 0;
+
     bool ret = taosMbsToUcs4(pDst, nLen, *pDest, (nLen + 1) * TSDB_NCHAR_SIZE, &output);
     if (!ret) {
       return -1;

src/connector/jdbc/.classpath

-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" output="target/classes" path="src/main/java">
-		<attributes>
-			<attribute name="optional" value="true"/>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
-		<attributes>
-			<attribute name="optional" value="true"/>
-			<attribute name="maven.pomderived" value="true"/>
-			<attribute name="test" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="output" path="target/classes"/>
-</classpath>

src/connector/jdbc/.project

-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>taos-jdbcdriver</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.m2e.core.maven2Builder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-		<nature>org.eclipse.m2e.core.maven2Nature</nature>
-	</natures>
-</projectDescription>

src/connector/jdbc/CMakeLists.txt

@@ -8,7 +8,7 @@ IF (TD_MVN_INSTALLED)
   ADD_CUSTOM_COMMAND(OUTPUT ${JDBC_CMD_NAME}
     POST_BUILD
     COMMAND mvn -Dmaven.test.skip=true install -f ${CMAKE_CURRENT_SOURCE_DIR}/pom.xml
-    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.15-dist.jar ${LIBRARY_OUTPUT_PATH}
+    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.16-dist.jar ${LIBRARY_OUTPUT_PATH}
     COMMAND mvn -Dmaven.test.skip=true clean -f ${CMAKE_CURRENT_SOURCE_DIR}/pom.xml
     COMMENT "build jdbc driver")
   ADD_CUSTOM_TARGET(${JDBC_TARGET_NAME} ALL WORKING_DIRECTORY ${EXECUTABLE_OUTPUT_PATH} DEPENDS ${JDBC_CMD_NAME})

src/connector/jdbc/deploy-pom.xml

@@ -5,7 +5,7 @@
 
   <groupId>com.taosdata.jdbc</groupId>
   <artifactId>taos-jdbcdriver</artifactId>
-  <version>2.0.15</version>
+  <version>2.0.16</version>
   <packaging>jar</packaging>
 
   <name>JDBCDriver</name>

src/connector/jdbc/pom.xml

@@ -3,7 +3,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.taosdata.jdbc</groupId>
     <artifactId>taos-jdbcdriver</artifactId>
-    <version>2.0.15</version>
+    <version>2.0.16</version>
     <packaging>jar</packaging>
     <name>JDBCDriver</name>
     <url>https://github.com/taosdata/TDengine/tree/master/src/connector/jdbc</url>
@@ -49,6 +49,7 @@
                 </exclusion>
             </exclusions>
         </dependency>
+
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
@@ -56,12 +57,6 @@
             <scope>test</scope>
         </dependency>
 
-        <dependency>
-            <groupId>mysql</groupId>
-            <artifactId>mysql-connector-java</artifactId>
-            <version>5.1.47</version>
-        </dependency>
-
         <!-- for restful -->
         <dependency>
             <groupId>org.apache.httpcomponents</groupId>
@@ -79,12 +74,6 @@
             <version>1.2.58</version>
         </dependency>
 
-        <dependency>
-            <groupId>mysql</groupId>
-            <artifactId>mysql-connector-java</artifactId>
-            <version>5.1.49</version>
-        </dependency>
-
     </dependencies>
 
     <build>

src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractDatabaseMetaData.java

@@ -497,12 +497,12 @@ public abstract class AbstractDatabaseMetaData implements DatabaseMetaData {
 
     public ResultSet getProcedures(String catalog, String schemaPattern, String procedureNamePattern)
             throws SQLException {
-        throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        return null;
     }
 
     public ResultSet getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern,
                                          String columnNamePattern) throws SQLException {
-        throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        return null;
     }
 
     public abstract ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String[] types)

src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDatabaseMetaData.java

@@ -20,13 +20,11 @@ import java.util.List;
 
 public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
 
-    private String dbProductName = null;
-    private String url = null;
-    private String userName = null;
-    private Connection conn = null;
+    private String url;
+    private String userName;
+    private Connection conn;
 
-    public TSDBDatabaseMetaData(String dbProductName, String url, String userName) {
-        this.dbProductName = dbProductName;
+    public TSDBDatabaseMetaData(String url, String userName) {
         this.url = url;
         this.userName = userName;
     }
@@ -35,12 +33,17 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
         this.conn = conn;
     }
 
+    @Override
     public <T> T unwrap(Class<T> iface) throws SQLException {
-        return null;
+        try {
+            return iface.cast(this);
+        } catch (ClassCastException cce) {
+            throw new SQLException("Unable to unwrap to " + iface.toString());
+        }
     }
 
     public boolean isWrapperFor(Class<?> iface) throws SQLException {
-        return false;
+        return iface.isInstance(this);
     }
 
     public boolean allProceduresAreCallable() throws SQLException {
@@ -80,11 +83,11 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
     }
 
     public String getDatabaseProductName() throws SQLException {
-        return this.dbProductName;
+        return "TDengine";
     }
 
     public String getDatabaseProductVersion() throws SQLException {
-        return "1.5.1";
+        return "2.0.x.x";
     }
 
     public String getDriverName() throws SQLException {
@@ -92,7 +95,7 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
     }
 
     public String getDriverVersion() throws SQLException {
-        return "1.0.0";
+        return "2.0.x";
     }
 
     public int getDriverMajorVersion() {
@@ -111,7 +114,9 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
         return false;
     }
 
+
     public boolean supportsMixedCaseIdentifiers() throws SQLException {
+        //像database、table这些对象的标识符，在存储时是否采用大小写混合的模式
         return false;
     }
 
@@ -120,7 +125,7 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
     }
 
     public boolean storesLowerCaseIdentifiers() throws SQLException {
-        return false;
+        return true;
     }
 
     public boolean storesMixedCaseIdentifiers() throws SQLException {
@@ -128,6 +133,7 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
     }
 
     public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException {
+        //像database、table这些对象的标识符，在存储时是否采用大小写混合、并带引号的模式
         return false;
     }
 
@@ -188,10 +194,12 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
     }
 
     public boolean nullPlusNonNullIsNull() throws SQLException {
+        // null + non-null != null
         return false;
     }
 
     public boolean supportsConvert() throws SQLException {
+        // 是否支持转换函数convert
         return false;
     }
 
@@ -216,7 +224,7 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
     }
 
     public boolean supportsGroupBy() throws SQLException {
-        return false;
+        return true;
     }
 
     public boolean supportsGroupByUnrelated() throws SQLException {
@@ -488,7 +496,7 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
     }
 
     public int getDefaultTransactionIsolation() throws SQLException {
-        return 0;
+        return Connection.TRANSACTION_NONE;
     }
 
     public boolean supportsTransactions() throws SQLException {
@@ -496,6 +504,8 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
     }
 
     public boolean supportsTransactionIsolationLevel(int level) throws SQLException {
+        if (level == Connection.TRANSACTION_NONE)
+            return true;
         return false;
     }
 
@@ -517,28 +527,27 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
 
     public ResultSet getProcedures(String catalog, String schemaPattern, String procedureNamePattern)
             throws SQLException {
-        throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        return null;
     }
 
     public ResultSet getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern,
                                          String columnNamePattern) throws SQLException {
-        throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
+        return null;
     }
 
-    public ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String[] types)
-            throws SQLException {
-        Statement stmt = null;
-        if (null != conn && !conn.isClosed()) {
-            stmt = conn.createStatement();
-            if (catalog == null || catalog.length() < 1) {
-                catalog = conn.getCatalog();
+    public ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String[] types) throws SQLException {
+        if (conn == null || conn.isClosed()) {
+            throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));
         }
+
+        try (Statement stmt = conn.createStatement()) {
+            if (catalog == null || catalog.isEmpty())
+                return null;
+
             stmt.executeUpdate("use " + catalog);
             ResultSet resultSet0 = stmt.executeQuery("show tables");
             GetTablesResultSet getTablesResultSet = new GetTablesResultSet(resultSet0, catalog, schemaPattern, tableNamePattern, types);
             return getTablesResultSet;
-        } else {
-            throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));
         }
     }
 
@@ -547,14 +556,12 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
     }
 
     public ResultSet getCatalogs() throws SQLException {
+        if (conn == null || conn.isClosed())
+            throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));
 
-        if (conn != null && !conn.isClosed()) {
-            Statement stmt = conn.createStatement();
-            ResultSet resultSet0 = stmt.executeQuery("show databases");
-            CatalogResultSet resultSet = new CatalogResultSet(resultSet0);
-            return resultSet;
-        } else {
-            return getEmptyResultSet();
+        try (Statement stmt = conn.createStatement()) {
+            ResultSet rs = stmt.executeQuery("show databases");
+            return new CatalogResultSet(rs);
         }
     }
 
@@ -562,7 +569,7 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
         DatabaseMetaDataResultSet resultSet = new DatabaseMetaDataResultSet();
 
         // set up ColumnMetaDataList
-        List<ColumnMetaData> columnMetaDataList = new ArrayList<ColumnMetaData>(1);
+        List<ColumnMetaData> columnMetaDataList = new ArrayList<>(1);
         ColumnMetaData colMetaData = new ColumnMetaData();
         colMetaData.setColIndex(0);
         colMetaData.setColName("TABLE_TYPE");
@@ -571,7 +578,7 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
         columnMetaDataList.add(colMetaData);
 
         // set up rowDataList
-        List<TSDBResultSetRowData> rowDataList = new ArrayList<TSDBResultSetRowData>(2);
+        List<TSDBResultSetRowData> rowDataList = new ArrayList<>(2);
         TSDBResultSetRowData rowData = new TSDBResultSetRowData();
         rowData.setString(0, "TABLE");
         rowDataList.add(rowData);
@@ -591,11 +598,10 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
         Statement stmt = null;
         if (null != conn && !conn.isClosed()) {
             stmt = conn.createStatement();
-            if (catalog == null || catalog.length() < 1) {
-                catalog = conn.getCatalog();
-            }
-            stmt.executeUpdate("use " + catalog);
+            if (catalog == null || catalog.isEmpty())
+                return null;
 
+            stmt.executeUpdate("use " + catalog);
             DatabaseMetaDataResultSet resultSet = new DatabaseMetaDataResultSet();
             // set up ColumnMetaDataList
             List<ColumnMetaData> columnMetaDataList = new ArrayList<>(24);
@@ -851,7 +857,7 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
     }
 
     public Connection getConnection() throws SQLException {
-        return null;
+        return this.conn;
     }
 
     public boolean supportsSavepoints() throws SQLException {
@@ -884,15 +890,17 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
     }
 
     public boolean supportsResultSetHoldability(int holdability) throws SQLException {
+        if (holdability == ResultSet.HOLD_CURSORS_OVER_COMMIT)
+            return true;
         return false;
     }
 
     public int getResultSetHoldability() throws SQLException {
-        return 0;
+        return ResultSet.HOLD_CURSORS_OVER_COMMIT;
     }
 
     public int getDatabaseMajorVersion() throws SQLException {
-        return 0;
+        return 2;
     }
 
     public int getDatabaseMinorVersion() throws SQLException {
@@ -900,7 +908,7 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
     }
 
     public int getJDBCMajorVersion() throws SQLException {
-        return 0;
+        return 2;
     }
 
     public int getJDBCMinorVersion() throws SQLException {

src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java

@@ -214,7 +214,7 @@ public class TSDBDriver extends AbstractTaosDriver {
             urlProps.setProperty(TSDBDriver.PROPERTY_KEY_HOST, url);
         }
         
-        this.dbMetaData = new TSDBDatabaseMetaData(dbProductName, urlForMeta, urlProps.getProperty(TSDBDriver.PROPERTY_KEY_USER));
+        this.dbMetaData = new TSDBDatabaseMetaData(urlForMeta, urlProps.getProperty(TSDBDriver.PROPERTY_KEY_USER));
         return urlProps;
     }
 

src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSet.java

@@ -39,7 +39,6 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
-@SuppressWarnings("unused")
 public class TSDBResultSet implements ResultSet {
 	private TSDBJNIConnector jniConnector = null;
 
@@ -104,6 +103,7 @@ public class TSDBResultSet implements ResultSet {
 	}
 
 	public TSDBResultSet() {
+		
 	}
 
 	public TSDBResultSet(TSDBJNIConnector connector, long resultSetPointer) throws SQLException {

src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBStatement.java

@@ -17,6 +17,7 @@ package com.taosdata.jdbc;
 import java.sql.*;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.TimeUnit;
 
 public class TSDBStatement implements Statement {
     private TSDBJNIConnector connector = null;
@@ -68,7 +69,6 @@ public class TSDBStatement implements Statement {
         pSql = this.connector.executeQuery(sql);
 
         long resultSetPointer = this.connector.getResultSet();
-
         if (resultSetPointer == TSDBConstants.JNI_CONNECTION_NULL) {
             this.connector.freeResultSet(pSql);
             throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));

src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulDatabaseMetaData.java

@@ -8,7 +8,6 @@ import java.util.List;
 
 public class RestfulDatabaseMetaData extends AbstractDatabaseMetaData {
 
-
     private final String url;
     private final String userName;
     private final Connection connection;

src/connector/jdbc/src/test/java/com/taosdata/jdbc/DatabaseMetaDataTest.java

-package com.taosdata.jdbc;
-
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.sql.*;
-import java.util.Properties;
-
-public class DatabaseMetaDataTest {
-    static Connection connection = null;
-    static PreparedStatement statement = null;
-    static String dbName = "test";
-    static String tName = "t0";
-    static String host = "localhost";
-
-    @BeforeClass
-    public static void createConnection() throws SQLException {
-        try {
-            Class.forName("com.taosdata.jdbc.TSDBDriver");
-        } catch (ClassNotFoundException e) {
-            return;
-        }
-        Properties properties = new Properties();
-        properties.setProperty(TSDBDriver.PROPERTY_KEY_HOST, host);
-        properties.setProperty(TSDBDriver.PROPERTY_KEY_USER, "root");
-        properties.setProperty(TSDBDriver.PROPERTY_KEY_PASSWORD, "taosdata");
-        properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
-        properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
-        properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
-        connection = DriverManager.getConnection("jdbc:TAOS://" + host + ":0/", properties);
-
-        String sql = "drop database if exists " + dbName;
-        statement = connection.prepareStatement(sql);
-        statement.executeUpdate("create database if not exists " + dbName);
-        statement.executeUpdate("create table if not exists " + dbName + "." + tName + " (ts timestamp, k int, v int)");
-    }
-
-    @Test
-    public void testMetaDataTest() throws SQLException {
-        DatabaseMetaData databaseMetaData = connection.getMetaData();
-        ResultSet resultSet = databaseMetaData.getTables(dbName, "t*", "t*", new String[]{"t"});
-        while (resultSet.next()) {
-            for (int i = 1; i <= resultSet.getMetaData().getColumnCount(); i++) {
-                System.out.printf("%d: %s\n", i, resultSet.getString(i));
-            }
-        }
-        resultSet.close();
-        databaseMetaData.isWrapperFor(null);
-        databaseMetaData.allProceduresAreCallable();
-        databaseMetaData.allTablesAreSelectable();
-        databaseMetaData.getURL();
-        databaseMetaData.getUserName();
-        databaseMetaData.isReadOnly();
-        databaseMetaData.nullsAreSortedHigh();
-        databaseMetaData.nullsAreSortedLow();
-        databaseMetaData.nullsAreSortedAtStart();
-        databaseMetaData.nullsAreSortedAtEnd();
-        databaseMetaData.getDatabaseProductName();
-        databaseMetaData.getDatabaseProductVersion();
-        databaseMetaData.getDriverName();
-        databaseMetaData.getDriverVersion();
-        databaseMetaData.getDriverMajorVersion();
-        databaseMetaData.getDriverMinorVersion();
-        databaseMetaData.usesLocalFiles();
-        databaseMetaData.usesLocalFilePerTable();
-        databaseMetaData.supportsMixedCaseIdentifiers();
-        databaseMetaData.storesUpperCaseIdentifiers();
-        databaseMetaData.storesLowerCaseIdentifiers();
-        databaseMetaData.storesMixedCaseIdentifiers();
-        databaseMetaData.supportsMixedCaseQuotedIdentifiers();
-        databaseMetaData.storesUpperCaseQuotedIdentifiers();
-        databaseMetaData.storesLowerCaseQuotedIdentifiers();
-        databaseMetaData.storesMixedCaseQuotedIdentifiers();
-        databaseMetaData.getIdentifierQuoteString();
-        databaseMetaData.getSQLKeywords();
-        databaseMetaData.getNumericFunctions();
-        databaseMetaData.getStringFunctions();
-        databaseMetaData.getSystemFunctions();
-        databaseMetaData.getTimeDateFunctions();
-        databaseMetaData.getSearchStringEscape();
-        databaseMetaData.getExtraNameCharacters();
-        databaseMetaData.supportsAlterTableWithAddColumn();
-        databaseMetaData.supportsAlterTableWithDropColumn();
-        databaseMetaData.supportsColumnAliasing();
-        databaseMetaData.nullPlusNonNullIsNull();
-        databaseMetaData.supportsConvert();
-        databaseMetaData.supportsConvert(0, 0);
-        databaseMetaData.supportsTableCorrelationNames();
-        databaseMetaData.supportsDifferentTableCorrelationNames();
-        databaseMetaData.supportsExpressionsInOrderBy();
-        databaseMetaData.supportsOrderByUnrelated();
-        databaseMetaData.supportsGroupBy();
-        databaseMetaData.supportsGroupByUnrelated();
-        databaseMetaData.supportsGroupByBeyondSelect();
-        databaseMetaData.supportsLikeEscapeClause();
-        databaseMetaData.supportsMultipleResultSets();
-        databaseMetaData.supportsMultipleTransactions();
-        databaseMetaData.supportsNonNullableColumns();
-        databaseMetaData.supportsMinimumSQLGrammar();
-        databaseMetaData.supportsCoreSQLGrammar();
-        databaseMetaData.supportsExtendedSQLGrammar();
-        databaseMetaData.supportsANSI92EntryLevelSQL();
-        databaseMetaData.supportsANSI92IntermediateSQL();
-        databaseMetaData.supportsANSI92FullSQL();
-        databaseMetaData.supportsIntegrityEnhancementFacility();
-        databaseMetaData.supportsOuterJoins();
-        databaseMetaData.supportsFullOuterJoins();
-        databaseMetaData.supportsLimitedOuterJoins();
-        databaseMetaData.getSchemaTerm();
-        databaseMetaData.getProcedureTerm();
-        databaseMetaData.getCatalogTerm();
-        databaseMetaData.isCatalogAtStart();
-        databaseMetaData.getCatalogSeparator();
-        databaseMetaData.supportsSchemasInDataManipulation();
-        databaseMetaData.supportsSchemasInProcedureCalls();
-        databaseMetaData.supportsSchemasInTableDefinitions();
-        databaseMetaData.supportsSchemasInIndexDefinitions();
-        databaseMetaData.supportsSchemasInPrivilegeDefinitions();
-        databaseMetaData.supportsCatalogsInDataManipulation();
-        databaseMetaData.supportsCatalogsInProcedureCalls();
-        databaseMetaData.supportsCatalogsInTableDefinitions();
-        databaseMetaData.supportsCatalogsInIndexDefinitions();
-        databaseMetaData.supportsCatalogsInPrivilegeDefinitions();
-        databaseMetaData.supportsPositionedDelete();
-        databaseMetaData.supportsPositionedUpdate();
-        databaseMetaData.supportsSelectForUpdate();
-        databaseMetaData.supportsStoredProcedures();
-        databaseMetaData.supportsSubqueriesInComparisons();
-        databaseMetaData.supportsSubqueriesInExists();
-        databaseMetaData.supportsSubqueriesInIns();
-        databaseMetaData.supportsSubqueriesInQuantifieds();
-        databaseMetaData.supportsCorrelatedSubqueries();
-        databaseMetaData.supportsUnion();
-        databaseMetaData.supportsUnionAll();
-        databaseMetaData.supportsOpenCursorsAcrossCommit();
-        databaseMetaData.supportsOpenCursorsAcrossRollback();
-        databaseMetaData.supportsOpenStatementsAcrossCommit();
-        databaseMetaData.supportsOpenStatementsAcrossRollback();
-        databaseMetaData.getMaxBinaryLiteralLength();
-        databaseMetaData.getMaxCharLiteralLength();
-        databaseMetaData.getMaxColumnNameLength();
-        databaseMetaData.getMaxColumnsInGroupBy();
-        databaseMetaData.getMaxColumnsInIndex();
-        databaseMetaData.getMaxColumnsInOrderBy();
-        databaseMetaData.getMaxColumnsInSelect();
-        databaseMetaData.getMaxColumnsInTable();
-        databaseMetaData.getMaxConnections();
-        databaseMetaData.getMaxCursorNameLength();
-        databaseMetaData.getMaxIndexLength();
-        databaseMetaData.getMaxSchemaNameLength();
-        databaseMetaData.getMaxProcedureNameLength();
-        databaseMetaData.getMaxCatalogNameLength();
-        databaseMetaData.getMaxRowSize();
-        databaseMetaData.doesMaxRowSizeIncludeBlobs();
-        databaseMetaData.getMaxStatementLength();
-        databaseMetaData.getMaxStatements();
-        databaseMetaData.getMaxTableNameLength();
-        databaseMetaData.getMaxTablesInSelect();
-        databaseMetaData.getMaxUserNameLength();
-        databaseMetaData.getDefaultTransactionIsolation();
-        databaseMetaData.supportsTransactions();
-        databaseMetaData.supportsTransactionIsolationLevel(0);
-        databaseMetaData.supportsDataDefinitionAndDataManipulationTransactions();
-        databaseMetaData.supportsDataManipulationTransactionsOnly();
-        databaseMetaData.dataDefinitionCausesTransactionCommit();
-        databaseMetaData.dataDefinitionIgnoredInTransactions();
-        try {
-            databaseMetaData.getProcedures("", "", "");
-        } catch (Exception e) {
-        }
-        try {
-            databaseMetaData.getProcedureColumns("", "", "", "");
-        } catch (Exception e) {
-        }
-        try {
-            databaseMetaData.getTables("", "", "", new String[]{""});
-        } catch (Exception e) {
-        }
-        databaseMetaData.getSchemas();
-        databaseMetaData.getCatalogs();
-//        databaseMetaData.getTableTypes();
-
-        databaseMetaData.getColumns(dbName, "", tName, "");
-        databaseMetaData.getColumnPrivileges("", "", "", "");
-        databaseMetaData.getTablePrivileges("", "", "");
-        databaseMetaData.getBestRowIdentifier("", "", "", 0, false);
-        databaseMetaData.getVersionColumns("", "", "");
-        databaseMetaData.getPrimaryKeys("", "", "");
-        databaseMetaData.getImportedKeys("", "", "");
-        databaseMetaData.getExportedKeys("", "", "");
-        databaseMetaData.getCrossReference("", "", "", "", "", "");
-        databaseMetaData.getTypeInfo();
-        databaseMetaData.getIndexInfo("", "", "", false, false);
-        databaseMetaData.supportsResultSetType(0);
-        databaseMetaData.supportsResultSetConcurrency(0, 0);
-        databaseMetaData.ownUpdatesAreVisible(0);
-        databaseMetaData.ownDeletesAreVisible(0);
-        databaseMetaData.ownInsertsAreVisible(0);
-        databaseMetaData.othersUpdatesAreVisible(0);
-        databaseMetaData.othersDeletesAreVisible(0);
-        databaseMetaData.othersInsertsAreVisible(0);
-        databaseMetaData.updatesAreDetected(0);
-        databaseMetaData.deletesAreDetected(0);
-        databaseMetaData.insertsAreDetected(0);
-        databaseMetaData.supportsBatchUpdates();
-        databaseMetaData.getUDTs("", "", "", new int[]{0});
-        databaseMetaData.getConnection();
-        databaseMetaData.supportsSavepoints();
-        databaseMetaData.supportsNamedParameters();
-        databaseMetaData.supportsMultipleOpenResults();
-        databaseMetaData.supportsGetGeneratedKeys();
-        databaseMetaData.getSuperTypes("", "", "");
-        databaseMetaData.getSuperTables("", "", "");
-        databaseMetaData.getAttributes("", "", "", "");
-        databaseMetaData.supportsResultSetHoldability(0);
-        databaseMetaData.getResultSetHoldability();
-        databaseMetaData.getDatabaseMajorVersion();
-        databaseMetaData.getDatabaseMinorVersion();
-        databaseMetaData.getJDBCMajorVersion();
-        databaseMetaData.getJDBCMinorVersion();
-        databaseMetaData.getSQLStateType();
-        databaseMetaData.locatorsUpdateCopy();
-        databaseMetaData.supportsStatementPooling();
-        databaseMetaData.getRowIdLifetime();
-        databaseMetaData.getSchemas("", "");
-        databaseMetaData.supportsStoredFunctionsUsingCallSyntax();
-        databaseMetaData.autoCommitFailureClosesAllResultSets();
-        databaseMetaData.getClientInfoProperties();
-        databaseMetaData.getFunctions("", "", "");
-        databaseMetaData.getFunctionColumns("", "", "", "");
-        databaseMetaData.getPseudoColumns("", "", "", "");
-        databaseMetaData.generatedKeyAlwaysReturned();
-
-    }
-
-    @AfterClass
-    public static void close() throws Exception {
-        statement.executeUpdate("drop database " + dbName);
-        statement.close();
-        connection.close();
-        Thread.sleep(10);
-
-    }
-}

src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBDatabaseMetaDataTest.java

+package com.taosdata.jdbc;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Properties;
+
+public class TSDBDatabaseMetaDataTest {
+    private TSDBDatabaseMetaData metaData;
+    private static final String host = "localhost";
+
+    @Before
+    public void before() throws ClassNotFoundException, SQLException {
+        Class.forName("com.taosdata.jdbc.TSDBDriver");
+        Properties properties = new Properties();
+        properties.setProperty(TSDBDriver.PROPERTY_KEY_HOST, host);
+        properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
+        properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
+        properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
+        metaData = (TSDBDatabaseMetaData) DriverManager.getConnection("jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata", properties).getMetaData();
+    }
+
+    @Test
+    public void unwrap() throws SQLException {
+        TSDBDatabaseMetaData unwrap = metaData.unwrap(TSDBDatabaseMetaData.class);
+        Assert.assertNotNull(unwrap);
+    }
+
+    @Test
+    public void isWrapperFor() throws SQLException {
+        Assert.assertTrue(metaData.isWrapperFor(TSDBDatabaseMetaData.class));
+    }
+
+    @Test
+    public void allProceduresAreCallable() throws SQLException {
+        Assert.assertFalse(metaData.allProceduresAreCallable());
+    }
+
+    @Test
+    public void allTablesAreSelectable() throws SQLException {
+        Assert.assertFalse(metaData.allTablesAreSelectable());
+    }
+
+    @Test
+    public void getURL() throws SQLException {
+        Assert.assertEquals("jdbc:TAOS://localhost:6030/?user=root&password=taosdata", metaData.getURL());
+    }
+
+    @Test
+    public void getUserName() throws SQLException {
+        Assert.assertEquals("root", metaData.getUserName());
+    }
+
+    @Test
+    public void isReadOnly() throws SQLException {
+        Assert.assertFalse(metaData.isReadOnly());
+    }
+
+    @Test
+    public void nullsAreSortedHigh() throws SQLException {
+        Assert.assertFalse(metaData.nullsAreSortedHigh());
+    }
+
+    @Test
+    public void nullsAreSortedLow() throws SQLException {
+        Assert.assertTrue(metaData.nullsAreSortedLow());
+    }
+
+    @Test
+    public void nullsAreSortedAtStart() throws SQLException {
+        Assert.assertTrue(metaData.nullsAreSortedAtStart());
+    }
+
+    @Test
+    public void nullsAreSortedAtEnd() throws SQLException {
+        Assert.assertFalse(metaData.nullsAreSortedAtEnd());
+    }
+
+    @Test
+    public void getDatabaseProductName() throws SQLException {
+        Assert.assertEquals("TDengine", metaData.getDatabaseProductName());
+    }
+
+    @Test
+    public void getDatabaseProductVersion() throws SQLException {
+        Assert.assertEquals("2.0.x.x", metaData.getDatabaseProductVersion());
+    }
+
+    @Test
+    public void getDriverName() throws SQLException {
+        Assert.assertEquals("com.taosdata.jdbc.TSDBDriver", metaData.getDriverName());
+    }
+
+    @Test
+    public void getDriverVersion() throws SQLException {
+        Assert.assertEquals("2.0.x", metaData.getDriverVersion());
+    }
+
+    @Test
+    public void getDriverMajorVersion() {
+        Assert.assertEquals(2, metaData.getDriverMajorVersion());
+    }
+
+    @Test
+    public void getDriverMinorVersion() {
+        Assert.assertEquals(0, metaData.getDriverMinorVersion());
+    }
+
+    @Test
+    public void usesLocalFiles() throws SQLException {
+        Assert.assertFalse(metaData.usesLocalFiles());
+    }
+
+    @Test
+    public void usesLocalFilePerTable() throws SQLException {
+        Assert.assertFalse(metaData.usesLocalFilePerTable());
+    }
+
+    @Test
+    public void supportsMixedCaseIdentifiers() throws SQLException {
+        Assert.assertFalse(metaData.supportsMixedCaseIdentifiers());
+    }
+
+    @Test
+    public void storesUpperCaseIdentifiers() throws SQLException {
+        Assert.assertFalse(metaData.storesUpperCaseIdentifiers());
+    }
+
+    @Test
+    public void storesLowerCaseIdentifiers() throws SQLException {
+        Assert.assertTrue(metaData.storesLowerCaseIdentifiers());
+    }
+
+    @Test
+    public void storesMixedCaseIdentifiers() throws SQLException {
+        Assert.assertFalse(metaData.storesMixedCaseIdentifiers());
+    }
+
+    @Test
+    public void supportsMixedCaseQuotedIdentifiers() throws SQLException {
+        Assert.assertFalse(metaData.supportsMixedCaseQuotedIdentifiers());
+    }
+
+    @Test
+    public void storesUpperCaseQuotedIdentifiers() throws SQLException {
+        Assert.assertFalse(metaData.storesUpperCaseQuotedIdentifiers());
+    }
+
+    @Test
+    public void storesLowerCaseQuotedIdentifiers() throws SQLException {
+        Assert.assertFalse(metaData.storesLowerCaseQuotedIdentifiers());
+    }
+
+    @Test
+    public void storesMixedCaseQuotedIdentifiers() throws SQLException {
+        Assert.assertFalse(metaData.storesMixedCaseQuotedIdentifiers());
+    }
+
+    @Test
+    public void getIdentifierQuoteString() throws SQLException {
+        Assert.assertEquals(" ", metaData.getIdentifierQuoteString());
+    }
+
+    @Test
+    public void getSQLKeywords() throws SQLException {
+        Assert.assertEquals(null, metaData.getSQLKeywords());
+    }
+
+    @Test
+    public void getNumericFunctions() throws SQLException {
+        Assert.assertEquals(null, metaData.getNumericFunctions());
+    }
+
+    @Test
+    public void getStringFunctions() throws SQLException {
+        Assert.assertEquals(null, metaData.getStringFunctions());
+    }
+
+    @Test
+    public void getSystemFunctions() throws SQLException {
+        Assert.assertEquals(null, metaData.getSystemFunctions());
+    }
+
+    @Test
+    public void getTimeDateFunctions() throws SQLException {
+        Assert.assertEquals(null, metaData.getTimeDateFunctions());
+    }
+
+    @Test
+    public void getSearchStringEscape() throws SQLException {
+        Assert.assertEquals(null, metaData.getSearchStringEscape());
+    }
+
+    @Test
+    public void getExtraNameCharacters() throws SQLException {
+        Assert.assertEquals(null, metaData.getExtraNameCharacters());
+    }
+
+    @Test
+    public void supportsAlterTableWithAddColumn() throws SQLException {
+        Assert.assertTrue(metaData.supportsAlterTableWithAddColumn());
+    }
+
+    @Test
+    public void supportsAlterTableWithDropColumn() throws SQLException {
+        Assert.assertTrue(metaData.supportsAlterTableWithDropColumn());
+    }
+
+    @Test
+    public void supportsColumnAliasing() throws SQLException {
+        Assert.assertTrue(metaData.supportsColumnAliasing());
+    }
+
+    @Test
+    public void nullPlusNonNullIsNull() throws SQLException {
+        Assert.assertFalse(metaData.nullPlusNonNullIsNull());
+    }
+
+    @Test
+    public void supportsConvert() throws SQLException {
+        Assert.assertFalse(metaData.supportsConvert());
+    }
+
+    @Test
+    public void testSupportsConvert() throws SQLException {
+        Assert.assertFalse(metaData.supportsConvert(1, 1));
+    }
+
+    @Test
+    public void supportsTableCorrelationNames() throws SQLException {
+        Assert.assertFalse(metaData.supportsTableCorrelationNames());
+    }
+
+    @Test
+    public void supportsDifferentTableCorrelationNames() throws SQLException {
+        Assert.assertFalse(metaData.supportsDifferentTableCorrelationNames());
+    }
+
+    @Test
+    public void supportsExpressionsInOrderBy() throws SQLException {
+        Assert.assertFalse(metaData.supportsExpressionsInOrderBy());
+    }
+
+    @Test
+    public void supportsOrderByUnrelated() throws SQLException {
+        Assert.assertFalse(metaData.supportsOrderByUnrelated());
+    }
+
+    @Test
+    public void supportsGroupBy() throws SQLException {
+        Assert.assertTrue(metaData.supportsGroupBy());
+    }
+
+    @Test
+    public void supportsGroupByUnrelated() throws SQLException {
+        Assert.assertFalse(metaData.supportsGroupByUnrelated());
+    }
+
+    @Test
+    public void supportsGroupByBeyondSelect() throws SQLException {
+        Assert.assertFalse(metaData.supportsGroupByBeyondSelect());
+    }
+
+    @Test
+    public void supportsLikeEscapeClause() throws SQLException {
+        Assert.assertFalse(metaData.supportsLikeEscapeClause());
+    }
+
+    @Test
+    public void supportsMultipleResultSets() throws SQLException {
+        Assert.assertFalse(metaData.supportsMultipleResultSets());
+    }
+
+    @Test
+    public void supportsMultipleTransactions() throws SQLException {
+        Assert.assertFalse(metaData.supportsMultipleTransactions());
+    }
+
+    @Test
+    public void supportsNonNullableColumns() throws SQLException {
+        Assert.assertFalse(metaData.supportsNonNullableColumns());
+    }
+
+    @Test
+    public void supportsMinimumSQLGrammar() throws SQLException {
+        Assert.assertFalse(metaData.supportsMinimumSQLGrammar());
+    }
+
+    @Test
+    public void supportsCoreSQLGrammar() throws SQLException {
+        Assert.assertFalse(metaData.supportsCoreSQLGrammar());
+    }
+
+    @Test
+    public void supportsExtendedSQLGrammar() throws SQLException {
+        Assert.assertFalse(metaData.supportsExtendedSQLGrammar());
+    }
+
+    @Test
+    public void supportsANSI92EntryLevelSQL() throws SQLException {
+        Assert.assertFalse(metaData.supportsANSI92EntryLevelSQL());
+    }
+
+    @Test
+    public void supportsANSI92IntermediateSQL() throws SQLException {
+        Assert.assertFalse(metaData.supportsANSI92IntermediateSQL());
+    }
+
+    @Test
+    public void supportsANSI92FullSQL() throws SQLException {
+        Assert.assertFalse(metaData.supportsANSI92FullSQL());
+    }
+
+    @Test
+    public void supportsIntegrityEnhancementFacility() throws SQLException {
+        Assert.assertFalse(metaData.supportsIntegrityEnhancementFacility());
+    }
+
+    @Test
+    public void supportsOuterJoins() throws SQLException {
+        Assert.assertFalse(metaData.supportsOuterJoins());
+    }
+
+    @Test
+    public void supportsFullOuterJoins() throws SQLException {
+        Assert.assertFalse(metaData.supportsFullOuterJoins());
+    }
+
+    @Test
+    public void supportsLimitedOuterJoins() throws SQLException {
+        Assert.assertFalse(metaData.supportsLimitedOuterJoins());
+    }
+
+    @Test
+    public void getSchemaTerm() throws SQLException {
+        Assert.assertNull(metaData.getSchemaTerm());
+    }
+
+    @Test
+    public void getProcedureTerm() throws SQLException {
+        Assert.assertNull(metaData.getProcedureTerm());
+    }
+
+    @Test
+    public void getCatalogTerm() throws SQLException {
+        Assert.assertEquals("database", metaData.getCatalogTerm());
+    }
+
+    @Test
+    public void isCatalogAtStart() throws SQLException {
+        Assert.assertTrue(metaData.isCatalogAtStart());
+    }
+
+    @Test
+    public void getCatalogSeparator() throws SQLException {
+        Assert.assertEquals(".", metaData.getCatalogSeparator());
+    }
+
+    @Test
+    public void supportsSchemasInDataManipulation() throws SQLException {
+        Assert.assertFalse(metaData.supportsSchemasInDataManipulation());
+    }
+
+    @Test
+    public void supportsSchemasInProcedureCalls() throws SQLException {
+        Assert.assertFalse(metaData.supportsSchemasInProcedureCalls());
+    }
+
+    @Test
+    public void supportsSchemasInTableDefinitions() throws SQLException {
+        Assert.assertFalse(metaData.supportsSchemasInTableDefinitions());
+    }
+
+    @Test
+    public void supportsSchemasInIndexDefinitions() throws SQLException {
+        Assert.assertFalse(metaData.supportsSchemasInIndexDefinitions());
+    }
+
+    @Test
+    public void supportsSchemasInPrivilegeDefinitions() throws SQLException {
+        Assert.assertFalse(metaData.supportsSchemasInPrivilegeDefinitions());
+    }
+
+    @Test
+    public void supportsCatalogsInDataManipulation() throws SQLException {
+        Assert.assertTrue(metaData.supportsCatalogsInDataManipulation());
+    }
+
+    @Test
+    public void supportsCatalogsInProcedureCalls() throws SQLException {
+        Assert.assertFalse(metaData.supportsCatalogsInProcedureCalls());
+    }
+
+    @Test
+    public void supportsCatalogsInTableDefinitions() throws SQLException {
+        Assert.assertFalse(metaData.supportsCatalogsInTableDefinitions());
+    }
+
+    @Test
+    public void supportsCatalogsInIndexDefinitions() throws SQLException {
+        Assert.assertFalse(metaData.supportsCatalogsInIndexDefinitions());
+    }
+
+    @Test
+    public void supportsCatalogsInPrivilegeDefinitions() throws SQLException {
+        Assert.assertFalse(metaData.supportsCatalogsInPrivilegeDefinitions());
+    }
+
+    @Test
+    public void supportsPositionedDelete() throws SQLException {
+        Assert.assertFalse(metaData.supportsPositionedDelete());
+    }
+
+    @Test
+    public void supportsPositionedUpdate() throws SQLException {
+        Assert.assertFalse(metaData.supportsPositionedUpdate());
+    }
+
+    @Test
+    public void supportsSelectForUpdate() throws SQLException {
+        Assert.assertFalse(metaData.supportsSelectForUpdate());
+    }
+
+    @Test
+    public void supportsStoredProcedures() throws SQLException {
+        Assert.assertFalse(metaData.supportsStoredProcedures());
+    }
+
+    @Test
+    public void supportsSubqueriesInComparisons() throws SQLException {
+        Assert.assertFalse(metaData.supportsSubqueriesInComparisons());
+    }
+
+    @Test
+    public void supportsSubqueriesInExists() throws SQLException {
+        Assert.assertFalse(metaData.supportsSubqueriesInExists());
+    }
+
+    @Test
+    public void supportsSubqueriesInIns() throws SQLException {
+        Assert.assertFalse(metaData.supportsSubqueriesInIns());
+    }
+
+    @Test
+    public void supportsSubqueriesInQuantifieds() throws SQLException {
+        Assert.assertFalse(metaData.supportsSubqueriesInQuantifieds());
+    }
+
+    @Test
+    public void supportsCorrelatedSubqueries() throws SQLException {
+        Assert.assertFalse(metaData.supportsCorrelatedSubqueries());
+    }
+
+    @Test
+    public void supportsUnion() throws SQLException {
+        Assert.assertFalse(metaData.supportsUnion());
+    }
+
+    @Test
+    public void supportsUnionAll() throws SQLException {
+        Assert.assertFalse(metaData.supportsUnionAll());
+    }
+
+    @Test
+    public void supportsOpenCursorsAcrossCommit() throws SQLException {
+        Assert.assertFalse(metaData.supportsOpenCursorsAcrossCommit());
+    }
+
+    @Test
+    public void supportsOpenCursorsAcrossRollback() throws SQLException {
+        Assert.assertFalse(metaData.supportsOpenCursorsAcrossRollback());
+    }
+
+    @Test
+    public void supportsOpenStatementsAcrossCommit() throws SQLException {
+        Assert.assertFalse(metaData.supportsOpenStatementsAcrossCommit());
+    }
+
+    @Test
+    public void supportsOpenStatementsAcrossRollback() throws SQLException {
+        Assert.assertFalse(metaData.supportsOpenStatementsAcrossRollback());
+    }
+
+    @Test
+    public void getMaxBinaryLiteralLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxBinaryLiteralLength());
+    }
+
+    @Test
+    public void getMaxCharLiteralLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxCharLiteralLength());
+    }
+
+    @Test
+    public void getMaxColumnNameLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxColumnNameLength());
+    }
+
+    @Test
+    public void getMaxColumnsInGroupBy() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxColumnsInGroupBy());
+    }
+
+    @Test
+    public void getMaxColumnsInIndex() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxColumnsInIndex());
+    }
+
+    @Test
+    public void getMaxColumnsInOrderBy() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxColumnsInOrderBy());
+    }
+
+    @Test
+    public void getMaxColumnsInSelect() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxColumnsInSelect());
+    }
+
+    @Test
+    public void getMaxColumnsInTable() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxColumnsInTable());
+    }
+
+    @Test
+    public void getMaxConnections() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxConnections());
+    }
+
+    @Test
+    public void getMaxCursorNameLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxCursorNameLength());
+    }
+
+    @Test
+    public void getMaxIndexLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxIndexLength());
+    }
+
+    @Test
+    public void getMaxSchemaNameLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxSchemaNameLength());
+    }
+
+    @Test
+    public void getMaxProcedureNameLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxProcedureNameLength());
+    }
+
+    @Test
+    public void getMaxCatalogNameLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxCatalogNameLength());
+    }
+
+    @Test
+    public void getMaxRowSize() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxRowSize());
+    }
+
+    @Test
+    public void doesMaxRowSizeIncludeBlobs() throws SQLException {
+        Assert.assertFalse(metaData.doesMaxRowSizeIncludeBlobs());
+    }
+
+    @Test
+    public void getMaxStatementLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxStatementLength());
+    }
+
+    @Test
+    public void getMaxStatements() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxStatements());
+    }
+
+    @Test
+    public void getMaxTableNameLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxTableNameLength());
+    }
+
+    @Test
+    public void getMaxTablesInSelect() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxTablesInSelect());
+    }
+
+    @Test
+    public void getMaxUserNameLength() throws SQLException {
+        Assert.assertEquals(0, metaData.getMaxUserNameLength());
+    }
+
+    @Test
+    public void getDefaultTransactionIsolation() throws SQLException {
+        Assert.assertEquals(Connection.TRANSACTION_NONE, metaData.getDefaultTransactionIsolation());
+    }
+
+    @Test
+    public void supportsTransactions() throws SQLException {
+        Assert.assertFalse(metaData.supportsTransactions());
+    }
+
+    @Test
+    public void supportsTransactionIsolationLevel() throws SQLException {
+        Assert.assertTrue(metaData.supportsTransactionIsolationLevel(Connection.TRANSACTION_NONE));
+        Assert.assertFalse(metaData.supportsTransactionIsolationLevel(Connection.TRANSACTION_READ_COMMITTED));
+        Assert.assertFalse(metaData.supportsTransactionIsolationLevel(Connection.TRANSACTION_READ_UNCOMMITTED));
+        Assert.assertFalse(metaData.supportsTransactionIsolationLevel(Connection.TRANSACTION_REPEATABLE_READ));
+        Assert.assertFalse(metaData.supportsTransactionIsolationLevel(Connection.TRANSACTION_SERIALIZABLE));
+    }
+
+    @Test
+    public void supportsDataDefinitionAndDataManipulationTransactions() throws SQLException {
+        Assert.assertFalse(metaData.supportsDataDefinitionAndDataManipulationTransactions());
+    }
+
+    @Test
+    public void supportsDataManipulationTransactionsOnly() throws SQLException {
+        Assert.assertFalse(metaData.supportsDataManipulationTransactionsOnly());
+    }
+
+    @Test
+    public void dataDefinitionCausesTransactionCommit() throws SQLException {
+        Assert.assertFalse(metaData.dataDefinitionCausesTransactionCommit());
+    }
+
+    @Test
+    public void dataDefinitionIgnoredInTransactions() throws SQLException {
+        Assert.assertFalse(metaData.dataDefinitionIgnoredInTransactions());
+    }
+
+    @Test
+    public void getProcedures() throws SQLException {
+        Assert.assertNull(metaData.getProcedures("*", "*", "*"));
+    }
+
+    @Test
+    public void getProcedureColumns() throws SQLException {
+        Assert.assertNull(metaData.getProcedureColumns("*", "*", "*", "*"));
+    }
+
+    @Test
+    public void getTables() throws SQLException {
+        Assert.assertNull(metaData.getTables("", "", "*", null));
+    }
+
+    @Test
+    public void getSchemas() throws SQLException {
+        Assert.assertNotNull(metaData.getSchemas());
+    }
+
+    @Test
+    public void getCatalogs() throws SQLException {
+        Assert.assertNotNull(metaData.getCatalogs());
+    }
+
+    @Test
+    public void getTableTypes() throws SQLException {
+        Assert.assertNotNull(metaData.getTableTypes());
+    }
+
+    @Test
+    public void getColumns() throws SQLException {
+        Assert.assertNotNull(metaData.getColumns("", "", "", ""));
+    }
+
+    @Test
+    public void getColumnPrivileges() throws SQLException {
+        Assert.assertNotNull(metaData.getColumnPrivileges("", "", "", ""));
+    }
+
+    @Test
+    public void getTablePrivileges() throws SQLException {
+        Assert.assertNotNull(metaData.getTablePrivileges("", "", ""));
+    }
+
+    @Test
+    public void getBestRowIdentifier() throws SQLException {
+        Assert.assertNotNull(metaData.getBestRowIdentifier("", "", "", 0, false));
+    }
+
+    @Test
+    public void getVersionColumns() throws SQLException {
+        Assert.assertNotNull(metaData.getVersionColumns("", "", ""));
+    }
+
+    @Test
+    public void getPrimaryKeys() throws SQLException {
+        Assert.assertNotNull(metaData.getPrimaryKeys("", "", ""));
+    }
+
+    @Test
+    public void getImportedKeys() throws SQLException {
+        Assert.assertNotNull(metaData.getImportedKeys("", "", ""));
+    }
+
+    @Test
+    public void getExportedKeys() throws SQLException {
+        Assert.assertNotNull(metaData.getExportedKeys("", "", ""));
+    }
+
+    @Test
+    public void getCrossReference() throws SQLException {
+        Assert.assertNotNull(metaData.getCrossReference("", "", "", "", "", ""));
+    }
+
+    @Test
+    public void getTypeInfo() throws SQLException {
+        Assert.assertNotNull(metaData.getTypeInfo());
+    }
+
+    @Test
+    public void getIndexInfo() throws SQLException {
+        Assert.assertNotNull(metaData.getIndexInfo("", "", "", false, false));
+    }
+
+    @Test
+    public void supportsResultSetType() throws SQLException {
+        Assert.assertFalse(metaData.supportsResultSetType(0));
+    }
+
+    @Test
+    public void supportsResultSetConcurrency() throws SQLException {
+        Assert.assertFalse(metaData.supportsResultSetConcurrency(0, 0));
+    }
+
+    @Test
+    public void ownUpdatesAreVisible() throws SQLException {
+        Assert.assertFalse(metaData.ownUpdatesAreVisible(0));
+    }
+
+    @Test
+    public void ownDeletesAreVisible() throws SQLException {
+        Assert.assertFalse(metaData.ownDeletesAreVisible(0));
+    }
+
+    @Test
+    public void ownInsertsAreVisible() throws SQLException {
+        Assert.assertFalse(metaData.ownInsertsAreVisible(0));
+    }
+
+    @Test
+    public void othersUpdatesAreVisible() throws SQLException {
+        Assert.assertFalse(metaData.othersUpdatesAreVisible(0));
+    }
+
+    @Test
+    public void othersDeletesAreVisible() throws SQLException {
+        Assert.assertFalse(metaData.othersDeletesAreVisible(0));
+    }
+
+    @Test
+    public void othersInsertsAreVisible() throws SQLException {
+        Assert.assertFalse(metaData.othersInsertsAreVisible(0));
+    }
+
+    @Test
+    public void updatesAreDetected() throws SQLException {
+        Assert.assertFalse(metaData.updatesAreDetected(0));
+    }
+
+    @Test
+    public void deletesAreDetected() throws SQLException {
+        Assert.assertFalse(metaData.deletesAreDetected(0));
+    }
+
+    @Test
+    public void insertsAreDetected() throws SQLException {
+        Assert.assertFalse(metaData.insertsAreDetected(0));
+    }
+
+    @Test
+    public void supportsBatchUpdates() throws SQLException {
+        Assert.assertFalse(metaData.supportsBatchUpdates());
+    }
+
+    @Test
+    public void getUDTs() throws SQLException {
+        Assert.assertNotNull(metaData.getUDTs("", "", "", null));
+    }
+
+    @Test
+    public void getConnection() throws SQLException {
+        Assert.assertNotNull(metaData.getConnection());
+    }
+
+    @Test
+    public void supportsSavepoints() throws SQLException {
+        Assert.assertFalse(metaData.supportsSavepoints());
+    }
+
+    @Test
+    public void supportsNamedParameters() throws SQLException {
+        Assert.assertFalse(metaData.supportsNamedParameters());
+    }
+
+    @Test
+    public void supportsMultipleOpenResults() throws SQLException {
+        Assert.assertFalse(metaData.supportsMultipleOpenResults());
+    }
+
+    @Test
+    public void supportsGetGeneratedKeys() throws SQLException {
+        Assert.assertFalse(metaData.supportsGetGeneratedKeys());
+    }
+
+    @Test
+    public void getSuperTypes() throws SQLException {
+        Assert.assertNotNull(metaData.getSuperTypes("", "", ""));
+    }
+
+    @Test
+    public void getSuperTables() throws SQLException {
+        Assert.assertNotNull(metaData.getSuperTables("", "", ""));
+    }
+
+    @Test
+    public void getAttributes() throws SQLException {
+        Assert.assertNotNull(metaData.getAttributes("", "", "", ""));
+    }
+
+    @Test
+    public void supportsResultSetHoldability() throws SQLException {
+        Assert.assertTrue(metaData.supportsResultSetHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT));
+        Assert.assertFalse(metaData.supportsResultSetHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT));
+    }
+
+    @Test
+    public void getResultSetHoldability() throws SQLException {
+        Assert.assertEquals(1, metaData.getResultSetHoldability());
+    }
+
+    @Test
+    public void getDatabaseMajorVersion() throws SQLException {
+        Assert.assertEquals(2, metaData.getDatabaseMajorVersion());
+    }
+
+    @Test
+    public void getDatabaseMinorVersion() throws SQLException {
+        Assert.assertEquals(0, metaData.getDatabaseMinorVersion());
+    }
+
+    @Test
+    public void getJDBCMajorVersion() throws SQLException {
+        Assert.assertEquals(2, metaData.getJDBCMajorVersion());
+    }
+
+    @Test
+    public void getJDBCMinorVersion() throws SQLException {
+        Assert.assertEquals(0, metaData.getJDBCMinorVersion());
+    }
+
+    @Test
+    public void getSQLStateType() throws SQLException {
+        Assert.assertEquals(0, metaData.getSQLStateType());
+    }
+
+    @Test
+    public void locatorsUpdateCopy() throws SQLException {
+        Assert.assertFalse(metaData.locatorsUpdateCopy());
+    }
+
+    @Test
+    public void supportsStatementPooling() throws SQLException {
+        Assert.assertFalse(metaData.supportsStatementPooling());
+    }
+
+    @Test
+    public void getRowIdLifetime() throws SQLException {
+        Assert.assertNull(metaData.getRowIdLifetime());
+    }
+
+    @Test
+    public void testGetSchemas() throws SQLException {
+        Assert.assertNull(metaData.getSchemas());
+    }
+
+    @Test
+    public void supportsStoredFunctionsUsingCallSyntax() throws SQLException {
+        Assert.assertFalse(metaData.supportsStoredFunctionsUsingCallSyntax());
+    }
+
+    @Test
+    public void autoCommitFailureClosesAllResultSets() throws SQLException {
+        Assert.assertFalse(metaData.autoCommitFailureClosesAllResultSets());
+    }
+
+    @Test
+    public void getClientInfoProperties() throws SQLException {
+        Assert.assertNotNull(metaData.getClientInfoProperties());
+    }
+
+    @Test
+    public void getFunctions() throws SQLException {
+        Assert.assertNotNull(metaData.getFunctions("", "", ""));
+    }
+
+    @Test
+    public void getFunctionColumns() throws SQLException {
+        Assert.assertNotNull(metaData.getFunctionColumns("", "", "", ""));
+    }
+
+    @Test
+    public void getPseudoColumns() throws SQLException {
+        Assert.assertNotNull(metaData.getPseudoColumns("", "", "", ""));
+    }
+
+    @Test
+    public void generatedKeyAlwaysReturned() throws SQLException {
+        Assert.assertFalse(metaData.generatedKeyAlwaysReturned());
+    }
+}
\ No newline at end of file

src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/MultiThreadsWithSameStatmentTest.java

+package com.taosdata.jdbc.cases;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.sql.*;
+import java.util.concurrent.TimeUnit;
+
+public class MultiThreadsWithSameStatmentTest {
+
+
+    private class Service {
+        public Connection conn;
+        public Statement stmt;
+
+        public Service() {
+            try {
+                Class.forName("com.taosdata.jdbc.TSDBDriver");
+                conn = DriverManager.getConnection("jdbc:TAOS://localhost:6030/?user=root&password=taosdata");
+                stmt = conn.createStatement();
+                stmt.execute("create database if not exists jdbctest");
+                stmt.executeUpdate("create table if not exists jdbctest.weather (ts timestamp, f1 int)");
+            } catch (ClassNotFoundException | SQLException e) {
+                e.printStackTrace();
+            }
+        }
+
+        public void release() {
+            try {
+                stmt.close();
+                conn.close();
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Before
+    public void before() {
+    }
+
+    @Test
+    public void test() {
+        Thread t1 = new Thread(() -> {
+            try {
+                Service service = new Service();
+                ResultSet resultSet = service.stmt.executeQuery("select * from jdbctest.weather");
+                while (resultSet.next()) {
+                    ResultSetMetaData metaData = resultSet.getMetaData();
+                    for (int i = 1; i <= metaData.getColumnCount(); i++) {
+                        System.out.print(metaData.getColumnLabel(i) + ": " + resultSet.getString(i));
+                    }
+                    System.out.println();
+                }
+                resultSet.close();
+                service.release();
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+        });
+
+        Thread t2 = new Thread(() -> {
+            while (true) {
+                try {
+                    Service service = new Service();
+                    service.stmt.executeUpdate("insert into jdbctest.weather values(now,1)");
+                    service.release();
+                } catch (SQLException e) {
+                    e.printStackTrace();
+                }
+            }
+
+        });
+        t1.start();
+        sleep(1000);
+        t2.start();
+    }
+
+    private void sleep(long mills) {
+        try {
+            TimeUnit.MILLISECONDS.sleep(mills);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @After
+    public void after() {
+    }
+}

src/connector/python/linux/python2/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="taos",
-    version="2.0.3",
+    version="2.0.4",
     author="Taosdata Inc.",
     author_email="support@taosdata.com",
     description="TDengine python client package",

src/connector/python/linux/python2/taos/cursor.py

@@ -184,7 +184,7 @@ class TDengineCursor(object):
 
         return False
 
-    def fetchall(self):
+    def fetchall_row(self):
         """Fetch all (remaining) rows of a query result, returning them as a sequence of sequences (e.g. a list of tuples). Note that the cursor's arraysize attribute can affect the performance of this operation.
         """
         if self._result is None or self._fields is None:
@@ -203,7 +203,7 @@ class TDengineCursor(object):
             for i in range(len(self._fields)):
                 buffer[i].extend(block[i])
         return list(map(tuple, zip(*buffer)))
-    def fetchall_block(self):
+    def fetchall(self):
         if self._result is None or self._fields is None:
             raise OperationalError("Invalid use of fetchall")
 

src/connector/python/linux/python3/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="taos",
-    version="2.0.3",
+    version="2.0.4",
     author="Taosdata Inc.",
     author_email="support@taosdata.com",
     description="TDengine python client package",

src/connector/python/linux/python3/taos/cursor.py

@@ -192,7 +192,7 @@ class TDengineCursor(object):
 
         return False
 
-    def fetchall(self):
+    def fetchall_row(self):
         """Fetch all (remaining) rows of a query result, returning them as a sequence of sequences (e.g. a list of tuples). Note that the cursor's arraysize attribute can affect the performance of this operation.
         """
         if self._result is None or self._fields is None:
@@ -212,7 +212,7 @@ class TDengineCursor(object):
                 buffer[i].extend(block[i])
         return list(map(tuple, zip(*buffer)))
 
-    def fetchall_block(self):
+    def fetchall(self):
         if self._result is None or self._fields is None:
             raise OperationalError("Invalid use of fetchall")
 

src/connector/python/windows/python2/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="taos",
-    version="2.0.3",
+    version="2.0.4",
     author="Taosdata Inc.",
     author_email="support@taosdata.com",
     description="TDengine python client package",

src/connector/python/windows/python2/taos/cursor.py

@@ -138,7 +138,7 @@ class TDengineCursor(object):
     def fetchmany(self):
         pass
 
-    def fetchall(self):
+    def fetchall_row(self):
         """Fetch all (remaining) rows of a query result, returning them as a sequence of sequences (e.g. a list of tuples). Note that the cursor's arraysize attribute can affect the performance of this operation.
         """
         if self._result is None or self._fields is None:
@@ -158,7 +158,7 @@ class TDengineCursor(object):
                 buffer[i].extend(block[i])
         return list(map(tuple, zip(*buffer)))
         
-    def fetchall_block(self):
+    def fetchall(self):
         if self._result is None or self._fields is None:
             raise OperationalError("Invalid use of fetchall")
 

src/connector/python/windows/python3/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="taos",
-    version="2.0.3",
+    version="2.0.4",
     author="Taosdata Inc.",
     author_email="support@taosdata.com",
     description="TDengine python client package",

src/connector/python/windows/python3/taos/cursor.py

@@ -139,7 +139,7 @@ class TDengineCursor(object):
     def fetchmany(self):
         pass
 
-    def fetchall(self):
+    def fetchall_row(self):
         """Fetch all (remaining) rows of a query result, returning them as a sequence of sequences (e.g. a list of tuples). Note that the cursor's arraysize attribute can affect the performance of this operation.
         """
         if self._result is None or self._fields is None:
@@ -159,7 +159,7 @@ class TDengineCursor(object):
                 buffer[i].extend(block[i])
         return list(map(tuple, zip(*buffer)))
 
-    def fetchall_block(self):
+    def fetchall(self):
         if self._result is None or self._fields is None:
             raise OperationalError("Invalid use of fetchall")
 

src/inc/taosdef.h

@@ -357,7 +357,7 @@ do { \
 #define TSDB_PORT_HTTP                         11
 #define TSDB_PORT_ARBITRATOR                   12
 
-#define TSDB_MAX_WAL_SIZE    (1024*1024*2)
+#define TSDB_MAX_WAL_SIZE    (1024*1024*3)
 
 typedef enum {
   TAOS_QTYPE_RPC   = 0,

src/inc/ttokendef.h

@@ -82,145 +82,145 @@
 #define TK_STABLES                         64
 #define TK_VGROUPS                         65
 #define TK_DROP                            66
-#define TK_DNODE                           67
-#define TK_USER                            68
-#define TK_ACCOUNT                         69
-#define TK_USE                             70
-#define TK_DESCRIBE                        71
-#define TK_ALTER                           72
-#define TK_PASS                            73
-#define TK_PRIVILEGE                       74
-#define TK_LOCAL                           75
-#define TK_IF                              76
-#define TK_EXISTS                          77
-#define TK_PPS                             78
-#define TK_TSERIES                         79
-#define TK_DBS                             80
-#define TK_STORAGE                         81
-#define TK_QTIME                           82
-#define TK_CONNS                           83
-#define TK_STATE                           84
-#define TK_KEEP                            85
-#define TK_CACHE                           86
-#define TK_REPLICA                         87
-#define TK_QUORUM                          88
-#define TK_DAYS                            89
-#define TK_MINROWS                         90
-#define TK_MAXROWS                         91
-#define TK_BLOCKS                          92
-#define TK_CTIME                           93
-#define TK_WAL                             94
-#define TK_FSYNC                           95
-#define TK_COMP                            96
-#define TK_PRECISION                       97
-#define TK_UPDATE                          98
-#define TK_CACHELAST                       99
-#define TK_LP                             100
-#define TK_RP                             101
-#define TK_UNSIGNED                       102
-#define TK_TAGS                           103
-#define TK_USING                          104
-#define TK_AS                             105
-#define TK_COMMA                          106
-#define TK_NULL                           107
-#define TK_SELECT                         108
-#define TK_UNION                          109
-#define TK_ALL                            110
-#define TK_FROM                           111
-#define TK_VARIABLE                       112
-#define TK_INTERVAL                       113
-#define TK_FILL                           114
-#define TK_SLIDING                        115
-#define TK_ORDER                          116
-#define TK_BY                             117
-#define TK_ASC                            118
-#define TK_DESC                           119
-#define TK_GROUP                          120
-#define TK_HAVING                         121
-#define TK_LIMIT                          122
-#define TK_OFFSET                         123
-#define TK_SLIMIT                         124
-#define TK_SOFFSET                        125
-#define TK_WHERE                          126
-#define TK_NOW                            127
-#define TK_RESET                          128
-#define TK_QUERY                          129
-#define TK_ADD                            130
-#define TK_COLUMN                         131
-#define TK_TAG                            132
-#define TK_CHANGE                         133
-#define TK_SET                            134
-#define TK_KILL                           135
-#define TK_CONNECTION                     136
-#define TK_STREAM                         137
-#define TK_COLON                          138
-#define TK_ABORT                          139
-#define TK_AFTER                          140
-#define TK_ATTACH                         141
-#define TK_BEFORE                         142
-#define TK_BEGIN                          143
-#define TK_CASCADE                        144
-#define TK_CLUSTER                        145
-#define TK_CONFLICT                       146
-#define TK_COPY                           147
-#define TK_DEFERRED                       148
-#define TK_DELIMITERS                     149
-#define TK_DETACH                         150
-#define TK_EACH                           151
-#define TK_END                            152
-#define TK_EXPLAIN                        153
-#define TK_FAIL                           154
-#define TK_FOR                            155
-#define TK_IGNORE                         156
-#define TK_IMMEDIATE                      157
-#define TK_INITIALLY                      158
-#define TK_INSTEAD                        159
-#define TK_MATCH                          160
-#define TK_KEY                            161
-#define TK_OF                             162
-#define TK_RAISE                          163
-#define TK_REPLACE                        164
-#define TK_RESTRICT                       165
-#define TK_ROW                            166
-#define TK_STATEMENT                      167
-#define TK_TRIGGER                        168
-#define TK_VIEW                           169
-#define TK_COUNT                          170
-#define TK_SUM                            171
-#define TK_AVG                            172
-#define TK_MIN                            173
-#define TK_MAX                            174
-#define TK_FIRST                          175
-#define TK_LAST                           176
-#define TK_TOP                            177
-#define TK_BOTTOM                         178
-#define TK_STDDEV                         179
-#define TK_PERCENTILE                     180
-#define TK_APERCENTILE                    181
-#define TK_LEASTSQUARES                   182
-#define TK_HISTOGRAM                      183
-#define TK_DIFF                           184
-#define TK_SPREAD                         185
-#define TK_TWA                            186
-#define TK_INTERP                         187
-#define TK_LAST_ROW                       188
-#define TK_RATE                           189
-#define TK_IRATE                          190
-#define TK_SUM_RATE                       191
-#define TK_SUM_IRATE                      192
-#define TK_AVG_RATE                       193
-#define TK_AVG_IRATE                      194
-#define TK_TBID                           195
-#define TK_SEMI                           196
-#define TK_NONE                           197
-#define TK_PREV                           198
-#define TK_LINEAR                         199
-#define TK_IMPORT                         200
-#define TK_METRIC                         201
-#define TK_TBNAME                         202
-#define TK_JOIN                           203
-#define TK_METRICS                        204
-#define TK_STABLE                         205
+#define TK_STABLE                          67
+#define TK_DNODE                           68
+#define TK_USER                            69
+#define TK_ACCOUNT                         70
+#define TK_USE                             71
+#define TK_DESCRIBE                        72
+#define TK_ALTER                           73
+#define TK_PASS                            74
+#define TK_PRIVILEGE                       75
+#define TK_LOCAL                           76
+#define TK_IF                              77
+#define TK_EXISTS                          78
+#define TK_PPS                             79
+#define TK_TSERIES                         80
+#define TK_DBS                             81
+#define TK_STORAGE                         82
+#define TK_QTIME                           83
+#define TK_CONNS                           84
+#define TK_STATE                           85
+#define TK_KEEP                            86
+#define TK_CACHE                           87
+#define TK_REPLICA                         88
+#define TK_QUORUM                          89
+#define TK_DAYS                            90
+#define TK_MINROWS                         91
+#define TK_MAXROWS                         92
+#define TK_BLOCKS                          93
+#define TK_CTIME                           94
+#define TK_WAL                             95
+#define TK_FSYNC                           96
+#define TK_COMP                            97
+#define TK_PRECISION                       98
+#define TK_UPDATE                          99
+#define TK_CACHELAST                      100
+#define TK_LP                             101
+#define TK_RP                             102
+#define TK_UNSIGNED                       103
+#define TK_TAGS                           104
+#define TK_USING                          105
+#define TK_AS                             106
+#define TK_COMMA                          107
+#define TK_NULL                           108
+#define TK_SELECT                         109
+#define TK_UNION                          110
+#define TK_ALL                            111
+#define TK_FROM                           112
+#define TK_VARIABLE                       113
+#define TK_INTERVAL                       114
+#define TK_FILL                           115
+#define TK_SLIDING                        116
+#define TK_ORDER                          117
+#define TK_BY                             118
+#define TK_ASC                            119
+#define TK_DESC                           120
+#define TK_GROUP                          121
+#define TK_HAVING                         122
+#define TK_LIMIT                          123
+#define TK_OFFSET                         124
+#define TK_SLIMIT                         125
+#define TK_SOFFSET                        126
+#define TK_WHERE                          127
+#define TK_NOW                            128
+#define TK_RESET                          129
+#define TK_QUERY                          130
+#define TK_ADD                            131
+#define TK_COLUMN                         132
+#define TK_TAG                            133
+#define TK_CHANGE                         134
+#define TK_SET                            135
+#define TK_KILL                           136
+#define TK_CONNECTION                     137
+#define TK_STREAM                         138
+#define TK_COLON                          139
+#define TK_ABORT                          140
+#define TK_AFTER                          141
+#define TK_ATTACH                         142
+#define TK_BEFORE                         143
+#define TK_BEGIN                          144
+#define TK_CASCADE                        145
+#define TK_CLUSTER                        146
+#define TK_CONFLICT                       147
+#define TK_COPY                           148
+#define TK_DEFERRED                       149
+#define TK_DELIMITERS                     150
+#define TK_DETACH                         151
+#define TK_EACH                           152
+#define TK_END                            153
+#define TK_EXPLAIN                        154
+#define TK_FAIL                           155
+#define TK_FOR                            156
+#define TK_IGNORE                         157
+#define TK_IMMEDIATE                      158
+#define TK_INITIALLY                      159
+#define TK_INSTEAD                        160
+#define TK_MATCH                          161
+#define TK_KEY                            162
+#define TK_OF                             163
+#define TK_RAISE                          164
+#define TK_REPLACE                        165
+#define TK_RESTRICT                       166
+#define TK_ROW                            167
+#define TK_STATEMENT                      168
+#define TK_TRIGGER                        169
+#define TK_VIEW                           170
+#define TK_COUNT                          171
+#define TK_SUM                            172
+#define TK_AVG                            173
+#define TK_MIN                            174
+#define TK_MAX                            175
+#define TK_FIRST                          176
+#define TK_LAST                           177
+#define TK_TOP                            178
+#define TK_BOTTOM                         179
+#define TK_STDDEV                         180
+#define TK_PERCENTILE                     181
+#define TK_APERCENTILE                    182
+#define TK_LEASTSQUARES                   183
+#define TK_HISTOGRAM                      184
+#define TK_DIFF                           185
+#define TK_SPREAD                         186
+#define TK_TWA                            187
+#define TK_INTERP                         188
+#define TK_LAST_ROW                       189
+#define TK_RATE                           190
+#define TK_IRATE                          191
+#define TK_SUM_RATE                       192
+#define TK_SUM_IRATE                      193
+#define TK_AVG_RATE                       194
+#define TK_AVG_IRATE                      195
+#define TK_TBID                           196
+#define TK_SEMI                           197
+#define TK_NONE                           198
+#define TK_PREV                           199
+#define TK_LINEAR                         200
+#define TK_IMPORT                         201
+#define TK_METRIC                         202
+#define TK_TBNAME                         203
+#define TK_JOIN                           204
+#define TK_METRICS                        205
 #define TK_INSERT                         206
 #define TK_INTO                           207
 #define TK_VALUES                         208

src/kit/taosdemox/taosdemox.c

@@ -1085,8 +1085,8 @@ static void printfQueryMeta() {
   printf("database name:           \033[33m%s\033[0m\n", g_queryInfo.dbName);
 
   printf("\n");
-  printf("super table query info:                   \n");  
-  printf("rate:           \033[33m%d\033[0m\n", g_queryInfo.superQueryInfo.rate);
+  printf("specified table query info:                   \n");  
+  printf("query interval: \033[33m%d\033[0m\n", g_queryInfo.superQueryInfo.rate);
   printf("concurrent:     \033[33m%d\033[0m\n", g_queryInfo.superQueryInfo.concurrent);
   printf("sqlCount:       \033[33m%d\033[0m\n", g_queryInfo.superQueryInfo.sqlCount); 
 
@@ -1102,11 +1102,11 @@ static void printfQueryMeta() {
     printf("  sql[%d]: \033[33m%s\033[0m\n", i, g_queryInfo.superQueryInfo.sql[i]);
   }
   printf("\n");
-  printf("sub table query info:                   \n");  
-  printf("rate:           \033[33m%d\033[0m\n", g_queryInfo.subQueryInfo.rate);
+  printf("super table query info:                   \n");  
+  printf("query interval: \033[33m%d\033[0m\n", g_queryInfo.subQueryInfo.rate);
   printf("threadCnt:      \033[33m%d\033[0m\n", g_queryInfo.subQueryInfo.threadCnt);
   printf("childTblCount:  \033[33m%d\033[0m\n", g_queryInfo.subQueryInfo.childTblCount);
-  printf("childTblPrefix: \033[33m%s\033[0m\n", g_queryInfo.subQueryInfo.childTblPrefix);
+  printf("stable name:    \033[33m%s\033[0m\n", g_queryInfo.subQueryInfo.sTblName);
 
   if (SUBSCRIBE_MODE == g_jsonType) {
     printf("mod:            \033[33m%d\033[0m\n", g_queryInfo.subQueryInfo.subscribeMode);
@@ -4020,23 +4020,23 @@ void *superQueryProcess(void *sarg) {
         }
         selectAndGetResult(winfo->taos, g_queryInfo.superQueryInfo.sql[i], tmpFile); 
         int64_t t2 = taosGetTimestampUs();          
-        printf("taosc select sql return, Spent %f s\n", (t2 - t1)/1000000.0);          
+        printf("=[taosc] thread[%"PRIu64"] complete one sql, Spent %f s\n", (uint64_t)pthread_self(), (t2 - t1)/1000000.0);          
       } else {
         #ifdef TD_LOWA_CURL
         int64_t t1 = taosGetTimestampUs();
         int retCode = curlProceSql(g_queryInfo.host, g_queryInfo.port, g_queryInfo.superQueryInfo.sql[i], winfo->curl_handle);
         int64_t t2 = taosGetTimestampUs();          
-        printf("http select sql return, Spent %f s \n", (t2 - t1)/1000000.0);
+        printf("=[restful] thread[%"PRIu64"] complete one sql, Spent %f s\n", (uint64_t)pthread_self(), (t2 - t1)/1000000.0);
         
         if (0 != retCode) {
-          printf("========curl return fail, threadID[%d]\n", winfo->threadID);
+          printf("====curl return fail, threadID[%d]\n", winfo->threadID);
           return NULL;
         }
         #endif
       }   
     }
     et = taosGetTimestampMs();
-    printf("========thread[%"PRIu64"] complete all sqls to super table once queries duration:%.6fs\n\n", (uint64_t)pthread_self(), (double)(et - st)/1000.0);
+    printf("==thread[%"PRIu64"] complete all sqls to specify tables once queries duration:%.6fs\n\n", (uint64_t)pthread_self(), (double)(et - st)/1000.0);
   }
   return NULL;
 }
@@ -4065,7 +4065,7 @@ void *subQueryProcess(void *sarg) {
   char sqlstr[1024];
   threadInfo *winfo = (threadInfo *)sarg; 
   int64_t st = 0;
-  int64_t et = 0;
+  int64_t et = g_queryInfo.subQueryInfo.rate*1000;
   while (1) {
     if (g_queryInfo.subQueryInfo.rate && (et - st) < g_queryInfo.subQueryInfo.rate*1000) {
       taosMsleep(g_queryInfo.subQueryInfo.rate*1000 - (et - st)); // ms
@@ -4085,17 +4085,12 @@ void *subQueryProcess(void *sarg) {
       }
     }
     et = taosGetTimestampMs();
-    printf("========thread[%"PRIu64"] complete all sqls to allocate all sub-tables once queries duration:%.4fs\n\n", (uint64_t)pthread_self(), (double)(et - st)/1000.0);
+    printf("####thread[%"PRIu64"] complete all sqls to allocate all sub-tables[%d - %d] once queries duration:%.4fs\n\n", (uint64_t)pthread_self(), winfo->start_table_id, winfo->end_table_id, (double)(et - st)/1000.0);
   }
   return NULL;
 }
 
 int queryTestProcess() {
-  printfQueryMeta();
-
-  printf("Press enter key to continue\n\n");
-  (void)getchar();
-
   TAOS * taos = NULL;  
   taos_init();
   taos = taos_connect(g_queryInfo.host, g_queryInfo.user, g_queryInfo.password, g_queryInfo.dbName, g_queryInfo.port);
@@ -4108,9 +4103,13 @@ int queryTestProcess() {
     (void)getAllChildNameOfSuperTable(taos, g_queryInfo.dbName, g_queryInfo.subQueryInfo.sTblName, &g_queryInfo.subQueryInfo.childTblName, &g_queryInfo.subQueryInfo.childTblCount);
   }  
   
+  printfQueryMeta();
+  printf("Press enter key to continue\n\n");
+  (void)getchar();
+  
   pthread_t  *pids  = NULL;
   threadInfo *infos = NULL;
-  //==== create sub threads for query from super table
+  //==== create sub threads for query from specify table
   if (g_queryInfo.superQueryInfo.sqlCount > 0 && g_queryInfo.superQueryInfo.concurrent > 0) {
     
     pids  = malloc(g_queryInfo.superQueryInfo.concurrent * sizeof(pthread_t));
@@ -4146,7 +4145,7 @@ int queryTestProcess() {
   
   pthread_t  *pidsOfSub  = NULL;
   threadInfo *infosOfSub = NULL;
-  //==== create sub threads for query from sub table
+  //==== create sub threads for query from all sub table of the super table
   if ((g_queryInfo.subQueryInfo.sqlCount > 0) && (g_queryInfo.subQueryInfo.threadCnt > 0)) {
     pidsOfSub  = malloc(g_queryInfo.subQueryInfo.threadCnt * sizeof(pthread_t));
     infosOfSub = malloc(g_queryInfo.subQueryInfo.threadCnt * sizeof(threadInfo));
@@ -4177,6 +4176,7 @@ int queryTestProcess() {
       
       t_info->start_table_id = last;
       t_info->end_table_id = i < b ? last + a : last + a - 1;
+      last = t_info->end_table_id + 1;
       t_info->taos = taos;
       pthread_create(pidsOfSub + i, NULL, subQueryProcess, t_info);
     }

src/mnode/src/mnodeProfile.c

@@ -385,12 +385,22 @@ static int32_t mnodeRetrieveQueries(SShowObj *pShow, char *data, int32_t rows, v
   SConnObj *pConnObj = NULL;
   int32_t   cols = 0;
   char *    pWrite;
+  void *    pIter;
   char      str[TSDB_IPv4ADDR_LEN + 6] = {0};
 
   while (numOfRows < rows) {
-    pShow->pIter = mnodeGetNextConn(pShow->pIter, &pConnObj);
-    if (pConnObj == NULL) break;
+    pIter = mnodeGetNextConn(pShow->pIter, &pConnObj);
+    if (pConnObj == NULL) {
+      pShow->pIter = pIter;
+      break;
+    }
+
+    if (numOfRows + pConnObj->numOfQueries >= rows) {
+      mnodeCancelGetNextConn(pIter);
+      break;
+    }
 
+    pShow->pIter = pIter;
     for (int32_t i = 0; i < pConnObj->numOfQueries; ++i) {
       SQueryDesc *pDesc = pConnObj->pQueries + i;
       cols = 0;
@@ -518,12 +528,22 @@ static int32_t mnodeRetrieveStreams(SShowObj *pShow, char *data, int32_t rows, v
   SConnObj *pConnObj = NULL;
   int32_t   cols = 0;
   char *    pWrite;
+  void *    pIter;
   char      ipStr[TSDB_IPv4ADDR_LEN + 6];
 
   while (numOfRows < rows) {
-    pShow->pIter = mnodeGetNextConn(pShow->pIter, &pConnObj);
-    if (pConnObj == NULL) break;
+    pIter = mnodeGetNextConn(pShow->pIter, &pConnObj);
+    if (pConnObj == NULL) {
+      pShow->pIter = pIter;
+      break;
+    }
+
+    if (numOfRows + pConnObj->numOfStreams >= rows) {
+      mnodeCancelGetNextConn(pIter);
+      break;
+    }
 
+    pShow->pIter = pIter;
     for (int32_t i = 0; i < pConnObj->numOfStreams; ++i) {
       SStreamDesc *pDesc = pConnObj->pStreams + i;
       cols = 0;

src/query/inc/qSqlparser.h

@@ -98,6 +98,7 @@ typedef struct SCreateTableSQL {
 
 typedef struct SAlterTableInfo {
   SStrToken     name;
+  int16_t       tableType;
   int16_t       type;
   STagData      tagData;
   SArray       *pAddColumns; // SArray<TAOS_FIELD>
@@ -151,11 +152,9 @@ typedef struct SUserInfo {
 } SUserInfo;
 
 typedef struct SMiscInfo {
-//  int32_t    nTokens; /* Number of expressions on the list */
-//  int32_t    nAlloc;  /* Number of entries allocated below */
-//  SStrToken *a;       /* one entry for element */
   SArray    *a;         // SArray<SStrToken>
   bool       existsCheck;
+  int16_t    tableType;
   SUserInfo  user;
   union {
     SCreateDbInfo   dbOpt;
@@ -245,7 +244,7 @@ SCreateTableSQL *tSetCreateSqlElems(SArray *pCols, SArray *pTags, SQuerySQL *pSe
 
 void tSqlExprNodeDestroy(tSQLExpr *pExpr);
 
-SAlterTableInfo *  tAlterTableSqlElems(SStrToken *pTableName, SArray *pCols, SArray *pVals, int32_t type);
+SAlterTableInfo *  tAlterTableSqlElems(SStrToken *pTableName, SArray *pCols, SArray *pVals, int32_t type, int16_t tableTable);
 SCreatedTableInfo createNewChildTableInfo(SStrToken *pTableName, SArray *pTagVals, SStrToken *pToken, SStrToken* igExists);
 
 void destroyAllSelectClause(SSubclauseInfo *pSql);
@@ -262,12 +261,10 @@ void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pTableNameToken, SStrToken
 void SqlInfoDestroy(SSqlInfo *pInfo);
 
 void setDCLSQLElems(SSqlInfo *pInfo, int32_t type, int32_t nParams, ...);
-void setDropDbTableInfo(SSqlInfo *pInfo, int32_t type, SStrToken* pToken, SStrToken* existsCheck);
+void setDropDbTableInfo(SSqlInfo *pInfo, int32_t type, SStrToken* pToken, SStrToken* existsCheck,int16_t tableType);
 void setShowOptions(SSqlInfo *pInfo, int32_t type, SStrToken* prefix, SStrToken* pPatterns);
 
-SMiscInfo *tTokenListAppend(SMiscInfo *pTokenList, SStrToken *pToken);
-
-void setCreateDBSQL(SSqlInfo *pInfo, int32_t type, SStrToken *pToken, SCreateDbInfo *pDB, SStrToken *pIgExists);
+void setCreateDbInfo(SSqlInfo *pInfo, int32_t type, SStrToken *pToken, SCreateDbInfo *pDB, SStrToken *pIgExists);
 
 void setCreateAcctSql(SSqlInfo *pInfo, int32_t type, SStrToken *pName, SStrToken *pPwd, SCreateAcctInfo *pAcctInfo);
 void setCreateUserSql(SSqlInfo *pInfo, SStrToken *pName, SStrToken *pPasswd);

src/query/inc/sql.y

@@ -131,10 +131,16 @@ cmd ::= SHOW dbPrefix(X) VGROUPS ids(Y).    {
 //drop configure for tables
 cmd ::= DROP TABLE ifexists(Y) ids(X) cpxName(Z).   {
     X.n += Z.n;
-    setDropDbTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &X, &Y);
+    setDropDbTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &X, &Y, -1);
 }
 
-cmd ::= DROP DATABASE ifexists(Y) ids(X).    { setDropDbTableInfo(pInfo, TSDB_SQL_DROP_DB, &X, &Y); }
+//drop stable
+cmd ::= DROP STABLE ifexists(Y) ids(X) cpxName(Z).   {
+    X.n += Z.n;
+    setDropDbTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &X, &Y, TSDB_SUPER_TABLE);
+}
+
+cmd ::= DROP DATABASE ifexists(Y) ids(X).    { setDropDbTableInfo(pInfo, TSDB_SQL_DROP_DB, &X, &Y, -1); }
 cmd ::= DROP DNODE ids(X).       { setDCLSQLElems(pInfo, TSDB_SQL_DROP_DNODE, 1, &X);    }
 cmd ::= DROP USER ids(X).        { setDCLSQLElems(pInfo, TSDB_SQL_DROP_USER, 1, &X);     }
 cmd ::= DROP ACCOUNT ids(X).     { setDCLSQLElems(pInfo, TSDB_SQL_DROP_ACCT, 1, &X);  }
@@ -305,6 +311,8 @@ signed(A) ::= MINUS INTEGER(X).   { A = -strtol(X.z, NULL, 10);}
 
 ////////////////////////////////// The CREATE TABLE statement ///////////////////////////////
 cmd ::= CREATE TABLE create_table_args. {}
+cmd ::= CREATE TABLE create_stable_args. {}
+cmd ::= CREATE STABLE create_stable_args. {}
 cmd ::= CREATE TABLE create_table_list(Z). { pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = Z;}
 
 %type create_table_list{SCreateTableSQL*}
@@ -333,7 +341,8 @@ create_table_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) LP columnlist(X) RP. {
 }
 
 // create super table
-create_table_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) LP columnlist(X) RP TAGS LP columnlist(Y) RP. {
+%type create_stable_args{SCreateTableSQL*}
+create_stable_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) LP columnlist(X) RP TAGS LP columnlist(Y) RP. {
   A = tSetCreateSqlElems(X, Y, NULL, TSQL_CREATE_STABLE);
   setSqlInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
 
@@ -683,7 +692,7 @@ cmd ::= RESET QUERY CACHE.  { setDCLSQLElems(pInfo, TSDB_SQL_RESET_CACHE, 0);}
 ///////////////////////////////////ALTER TABLE statement//////////////////////////////////
 cmd ::= ALTER TABLE ids(X) cpxName(F) ADD COLUMN columnlist(A).     {
     X.n += F.n;
-    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&X, A, NULL, TSDB_ALTER_TABLE_ADD_COLUMN);
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&X, A, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
 
@@ -693,14 +702,14 @@ cmd ::= ALTER TABLE ids(X) cpxName(F) DROP COLUMN ids(A).     {
     toTSDBType(A.type);
     SArray* K = tVariantListAppendToken(NULL, &A, -1);
 
-    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&X, NULL, K, TSDB_ALTER_TABLE_DROP_COLUMN);
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&X, NULL, K, TSDB_ALTER_TABLE_DROP_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
 
 //////////////////////////////////ALTER TAGS statement/////////////////////////////////////
 cmd ::= ALTER TABLE ids(X) cpxName(Y) ADD TAG columnlist(A).        {
     X.n += Y.n;
-    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&X, A, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN);
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&X, A, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
 cmd ::= ALTER TABLE ids(X) cpxName(Z) DROP TAG ids(Y).          {
@@ -709,7 +718,7 @@ cmd ::= ALTER TABLE ids(X) cpxName(Z) DROP TAG ids(Y).          {
     toTSDBType(Y.type);
     SArray* A = tVariantListAppendToken(NULL, &Y, -1);
 
-    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&X, NULL, A, TSDB_ALTER_TABLE_DROP_TAG_COLUMN);
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&X, NULL, A, TSDB_ALTER_TABLE_DROP_TAG_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
 
@@ -722,7 +731,7 @@ cmd ::= ALTER TABLE ids(X) cpxName(F) CHANGE TAG ids(Y) ids(Z). {
     toTSDBType(Z.type);
     A = tVariantListAppendToken(A, &Z, -1);
 
-    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&X, NULL, A, TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN);
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&X, NULL, A, TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
 
@@ -733,7 +742,54 @@ cmd ::= ALTER TABLE ids(X) cpxName(F) SET TAG ids(Y) EQ tagitem(Z).     {
     SArray* A = tVariantListAppendToken(NULL, &Y, -1);
     A = tVariantListAppend(A, &Z, -1);
 
-    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&X, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL);
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&X, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, -1);
+    setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
+}
+
+
+///////////////////////////////////ALTER STABLE statement//////////////////////////////////
+cmd ::= ALTER STABLE ids(X) cpxName(F) ADD COLUMN columnlist(A).     {
+    X.n += F.n;
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&X, A, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE);
+    setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
+}
+
+cmd ::= ALTER STABLE ids(X) cpxName(F) DROP COLUMN ids(A).     {
+    X.n += F.n;
+
+    toTSDBType(A.type);
+    SArray* K = tVariantListAppendToken(NULL, &A, -1);
+
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&X, NULL, K, TSDB_ALTER_TABLE_DROP_COLUMN, TSDB_SUPER_TABLE);
+    setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
+}
+
+//////////////////////////////////ALTER TAGS statement/////////////////////////////////////
+cmd ::= ALTER STABLE ids(X) cpxName(Y) ADD TAG columnlist(A).        {
+    X.n += Y.n;
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&X, A, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE);
+    setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
+}
+cmd ::= ALTER STABLE ids(X) cpxName(Z) DROP TAG ids(Y).          {
+    X.n += Z.n;
+
+    toTSDBType(Y.type);
+    SArray* A = tVariantListAppendToken(NULL, &Y, -1);
+
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&X, NULL, A, TSDB_ALTER_TABLE_DROP_TAG_COLUMN, TSDB_SUPER_TABLE);
+    setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
+}
+
+cmd ::= ALTER STABLE ids(X) cpxName(F) CHANGE TAG ids(Y) ids(Z). {
+    X.n += F.n;
+
+    toTSDBType(Y.type);
+    SArray* A = tVariantListAppendToken(NULL, &Y, -1);
+
+    toTSDBType(Z.type);
+    A = tVariantListAppendToken(A, &Z, -1);
+
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&X, NULL, A, TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
 

src/query/src/qExecutor.c

@@ -1875,6 +1875,7 @@ static int32_t setCtxTagColumnInfo(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx
   return TSDB_CODE_SUCCESS;
 }
 
+// todo refactor
 static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int16_t order) {
   qDebug("QInfo:%p setup runtime env", GET_QINFO_ADDR(pRuntimeEnv));
   SQuery *pQuery = pRuntimeEnv->pQuery;
@@ -3168,6 +3169,10 @@ void copyResToQueryResultBuf(SQInfo *pQInfo, SQuery *pQuery) {
   // all results in current group have been returned to client, try next group
   if (pGroupResInfo->index >= taosArrayGetSize(pGroupResInfo->pRows)) {
     // current results of group has been sent to client, try next group
+    pGroupResInfo->index = 0;
+    pGroupResInfo->rowId = 0;
+    taosArrayClear(pGroupResInfo->pRows);
+
     if (mergeGroupResult(pQInfo) != TSDB_CODE_SUCCESS) {
       return;  // failed to save data in the disk
     }
@@ -3845,11 +3850,6 @@ void setExecutionContext(SQInfo *pQInfo, int32_t groupIndex, TSKEY nextKey) {
 
   // lastKey needs to be updated
   pTableQueryInfo->lastKey = nextKey;
-
-  if (pRuntimeEnv->hasTagResults || pRuntimeEnv->pTsBuf != NULL) {
-    setAdditionalInfo(pQInfo, pTableQueryInfo->pTable, pTableQueryInfo);
-  }
-
   if (pRuntimeEnv->prevGroupId != INT32_MIN && pRuntimeEnv->prevGroupId == groupIndex) {
     return;
   }
@@ -4775,19 +4775,17 @@ static void enableExecutionForNextTable(SQueryRuntimeEnv *pRuntimeEnv) {
   }
 }
 
-// TODO refactor: setAdditionalInfo
 static FORCE_INLINE void setEnvForEachBlock(SQInfo* pQInfo, STableQueryInfo* pTableQueryInfo, SDataBlockInfo* pBlockInfo) {
   SQueryRuntimeEnv* pRuntimeEnv = &pQInfo->runtimeEnv;
   SQuery* pQuery = pQInfo->runtimeEnv.pQuery;
   int32_t step = GET_FORWARD_DIRECTION_FACTOR(pQuery->order.order);
 
-  if (QUERY_IS_INTERVAL_QUERY(pQuery)) {
-    TSKEY nextKey = pBlockInfo->window.skey;
-    setIntervalQueryRange(pQInfo, nextKey);
-
   if (pRuntimeEnv->hasTagResults || pRuntimeEnv->pTsBuf != NULL) {
     setAdditionalInfo(pQInfo, pTableQueryInfo->pTable, pTableQueryInfo);
   }
+
+  if (QUERY_IS_INTERVAL_QUERY(pQuery)) {
+    setIntervalQueryRange(pQInfo, pBlockInfo->window.skey);
   } else {  // non-interval query
     setExecutionContext(pQInfo, pTableQueryInfo->groupIndex, pBlockInfo->window.ekey + step);
   }
@@ -5467,7 +5465,7 @@ static void doRestoreContext(SQInfo *pQInfo) {
   SET_MASTER_SCAN_FLAG(pRuntimeEnv);
 }
 
-static void doCloseAllTimeWindowAfterScan(SQInfo *pQInfo) {
+static void doCloseAllTimeWindow(SQInfo *pQInfo) {
   SQuery *pQuery = pQInfo->runtimeEnv.pQuery;
 
   if (QUERY_IS_INTERVAL_QUERY(pQuery)) {
@@ -5519,7 +5517,7 @@ static void multiTableQueryProcess(SQInfo *pQInfo) {
   }
 
   // close all time window results
-  doCloseAllTimeWindowAfterScan(pQInfo);
+  doCloseAllTimeWindow(pQInfo);
 
   if (needReverseScan(pQuery)) {
     int32_t code = doSaveContext(pQInfo);
@@ -5844,8 +5842,7 @@ static void stableQueryImpl(SQInfo *pQInfo) {
       (isFixedOutputQuery(pRuntimeEnv) && (!isPointInterpoQuery(pQuery)) && (!pRuntimeEnv->groupbyColumn))) {
     multiTableQueryProcess(pQInfo);
   } else {
-    assert((pQuery->checkResultBuf == 1 && pQuery->interval.interval == 0) || isPointInterpoQuery(pQuery) ||
-           pRuntimeEnv->groupbyColumn);
+    assert(pQuery->checkResultBuf == 1 || isPointInterpoQuery(pQuery) || pRuntimeEnv->groupbyColumn);
 
     sequentialTableProcess(pQInfo);
   }
@@ -6373,7 +6370,7 @@ static int32_t createQueryFuncExprFromMsg(SQueryTableMsg *pQueryMsg, int32_t num
     if (functId == TSDB_FUNC_TOP || functId == TSDB_FUNC_BOTTOM) {
       int32_t j = getColumnIndexInSource(pQueryMsg, &pExprs[i].base, pTagCols);
       if (j < 0 || j >= pQueryMsg->numOfCols) {
-        assert(0);
+        return TSDB_CODE_QRY_INVALID_MSG;
       } else {
         SColumnInfo *pCol = &pQueryMsg->colList[j];
         int32_t ret =
@@ -6638,7 +6635,7 @@ static SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SSqlGroupbyExpr *pGrou
   pQInfo->runtimeEnv.summary.tableInfoSize += (pTableGroupInfo->numOfTables * sizeof(STableQueryInfo));
 
   pQInfo->runtimeEnv.pResultRowHashTable = taosHashInit(pTableGroupInfo->numOfTables, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
-  pQInfo->runtimeEnv.keyBuf = malloc(TSDB_MAX_BYTES_PER_ROW);
+  pQInfo->runtimeEnv.keyBuf = malloc(TSDB_MAX_BYTES_PER_ROW);  // todo opt size
   pQInfo->runtimeEnv.pool = initResultRowPool(getResultRowSize(&pQInfo->runtimeEnv));
   pQInfo->runtimeEnv.prevRow = malloc(POINTER_BYTES * pQuery->numOfCols + srcSize);
 

src/query/src/qParserImpl.c

@@ -585,11 +585,12 @@ SCreatedTableInfo createNewChildTableInfo(SStrToken *pTableName, SArray *pTagVal
   return info;
 }
 
-SAlterTableInfo *tAlterTableSqlElems(SStrToken *pTableName, SArray *pCols, SArray *pVals, int32_t type) {
+SAlterTableInfo *tAlterTableSqlElems(SStrToken *pTableName, SArray *pCols, SArray *pVals, int32_t type, int16_t tableType) {
   SAlterTableInfo *pAlterTable = calloc(1, sizeof(SAlterTableInfo));
   
   pAlterTable->name = *pTableName;
   pAlterTable->type = type;
+  pAlterTable->tableType = tableType;
 
   if (type == TSDB_ALTER_TABLE_ADD_COLUMN || type == TSDB_ALTER_TABLE_ADD_TAG_COLUMN) {
     pAlterTable->pAddColumns = pCols;
@@ -696,18 +697,6 @@ void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pTableNameToken, SStrToken
   pInfo->pCreateTableInfo->existCheck = (pIfNotExists->n != 0);
 }
 
-SMiscInfo *tTokenListAppend(SMiscInfo *pMiscInfo, SStrToken *pToken) {
-  assert(pToken != NULL);
-
-  if (pMiscInfo == NULL) {
-    pMiscInfo = calloc(1, sizeof(SMiscInfo));
-    pMiscInfo->a = taosArrayInit(8, sizeof(SStrToken));
-  }
-
-  taosArrayPush(pMiscInfo->a, pToken);
-  return pMiscInfo;
-}
-
 void setDCLSQLElems(SSqlInfo *pInfo, int32_t type, int32_t nParam, ...) {
   pInfo->type = type;
   if (nParam == 0) {
@@ -724,15 +713,23 @@ void setDCLSQLElems(SSqlInfo *pInfo, int32_t type, int32_t nParam, ...) {
 
   while ((nParam--) > 0) {
     SStrToken *pToken = va_arg(va, SStrToken *);
-    pInfo->pMiscInfo = tTokenListAppend(pInfo->pMiscInfo, pToken);
+    taosArrayPush(pInfo->pMiscInfo->a, pToken);
   }
   va_end(va);
 }
 
-void setDropDbTableInfo(SSqlInfo *pInfo, int32_t type, SStrToken* pToken, SStrToken* existsCheck) {
+void setDropDbTableInfo(SSqlInfo *pInfo, int32_t type, SStrToken* pToken, SStrToken* existsCheck, int16_t tableType) {
   pInfo->type = type;
-  pInfo->pMiscInfo = tTokenListAppend(pInfo->pMiscInfo, pToken);
+
+  if (pInfo->pMiscInfo == NULL) {
+    pInfo->pMiscInfo = (SMiscInfo *)calloc(1, sizeof(SMiscInfo));
+    pInfo->pMiscInfo->a = taosArrayInit(4, sizeof(SStrToken));
+  }
+
+  taosArrayPush(pInfo->pMiscInfo->a, pToken);
+
   pInfo->pMiscInfo->existsCheck = (existsCheck->n == 1);
+  pInfo->pMiscInfo->tableType = tableType;
 }
 
 void setShowOptions(SSqlInfo *pInfo, int32_t type, SStrToken* prefix, SStrToken* pPatterns) {
@@ -758,7 +755,7 @@ void setShowOptions(SSqlInfo *pInfo, int32_t type, SStrToken* prefix, SStrToken*
   }
 }
 
-void setCreateDBSQL(SSqlInfo *pInfo, int32_t type, SStrToken *pToken, SCreateDbInfo *pDB, SStrToken *pIgExists) {
+void setCreateDbInfo(SSqlInfo *pInfo, int32_t type, SStrToken *pToken, SCreateDbInfo *pDB, SStrToken *pIgExists) {
   pInfo->type = type;
   if (pInfo->pMiscInfo == NULL) {
     pInfo->pMiscInfo = calloc(1, sizeof(SMiscInfo));

src/query/src/sql.c

@@ -97,27 +97,27 @@
 #endif
 /************* Begin control #defines *****************************************/
 #define YYCODETYPE unsigned short int
-#define YYNOCODE 279
+#define YYNOCODE 280
 #define YYACTIONTYPE unsigned short int
 #define ParseTOKENTYPE SStrToken
 typedef union {
   int yyinit;
   ParseTOKENTYPE yy0;
+  SQuerySQL* yy30;
   SCreateTableSQL* yy38;
-  SCreateAcctInfo yy71;
-  tSQLExpr* yy78;
-  int yy96;
-  SQuerySQL* yy148;
-  SCreatedTableInfo yy152;
+  SCreatedTableInfo yy78;
+  SLimitVal yy126;
+  int yy130;
+  SArray* yy135;
   SSubclauseInfo* yy153;
-  tSQLExprList* yy166;
-  SLimitVal yy167;
-  TAOS_FIELD yy183;
-  SCreateDbInfo yy234;
-  int64_t yy325;
-  SIntervalVal yy400;
-  SArray* yy421;
-  tVariant yy430;
+  SIntervalVal yy160;
+  TAOS_FIELD yy181;
+  SCreateDbInfo yy256;
+  tSQLExprList* yy266;
+  SCreateAcctInfo yy277;
+  tVariant yy308;
+  tSQLExpr* yy316;
+  int64_t yy531;
 } YYMINORTYPE;
 #ifndef YYSTACKDEPTH
 #define YYSTACKDEPTH 100
@@ -127,17 +127,17 @@ typedef union {
 #define ParseARG_FETCH SSqlInfo* pInfo = yypParser->pInfo
 #define ParseARG_STORE yypParser->pInfo = pInfo
 #define YYFALLBACK 1
-#define YYNSTATE             258
-#define YYNRULE              240
+#define YYNSTATE             282
+#define YYNRULE              248
 #define YYNTOKEN             209
-#define YY_MAX_SHIFT         257
-#define YY_MIN_SHIFTREDUCE   431
-#define YY_MAX_SHIFTREDUCE   670
-#define YY_ERROR_ACTION      671
-#define YY_ACCEPT_ACTION     672
-#define YY_NO_ACTION         673
-#define YY_MIN_REDUCE        674
-#define YY_MAX_REDUCE        913
+#define YY_MAX_SHIFT         281
+#define YY_MIN_SHIFTREDUCE   461
+#define YY_MAX_SHIFTREDUCE   708
+#define YY_ERROR_ACTION      709
+#define YY_ACCEPT_ACTION     710
+#define YY_NO_ACTION         711
+#define YY_MIN_REDUCE        712
+#define YY_MAX_REDUCE        959
 /************* End control #defines *******************************************/
 
 /* Define the yytestcase() macro to be a no-op if is not already defined
@@ -203,228 +203,243 @@ typedef union {
 **  yy_default[]       Default action for each state.
 **
 *********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (586)
+#define YY_ACTTAB_COUNT (622)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */   143,  474,  143,   23,  672,  257,  165,  547,  827,  475,
- /*    10 */   900,  168,  901,   37,   38,   12,   39,   40,  816,   23,
- /*    20 */   173,   31,  474,  474,  210,   43,   41,   45,   42,  805,
- /*    30 */   475,  475,  163,   36,   35,  232,  231,   34,   33,   32,
- /*    40 */    37,   38,  801,   39,   40,  816,  110,  173,   31,  162,
- /*    50 */   255,  210,   43,   41,   45,   42,  176,   66,  802,  195,
- /*    60 */    36,   35,  178,  824,   34,   33,   32,  432,  433,  434,
- /*    70 */   435,  436,  437,  438,  439,  440,  441,  442,  443,  256,
- /*    80 */   179,  225,  185,   37,   38,  805,   39,   40,  796,  242,
- /*    90 */   173,   31,  143,  180,  210,   43,   41,   45,   42,  110,
- /*   100 */   110,  167,  901,   36,   35,   57,  853,   34,   33,   32,
- /*   110 */    17,  223,  250,  249,  222,  221,  220,  248,  219,  247,
- /*   120 */   246,  245,  218,  244,  243,  803,  142,  774,  624,  762,
- /*   130 */   763,  764,  765,  766,  767,  768,  769,  770,  771,  772,
- /*   140 */   773,  775,  776,   38,  181,   39,   40,  229,  228,  173,
- /*   150 */    31,  605,  606,  210,   43,   41,   45,   42,  207,  854,
- /*   160 */    61,  205,   36,   35,   23,  110,   34,   33,   32,  188,
- /*   170 */    39,   40,   23,  251,  173,   31,  192,  191,  210,   43,
- /*   180 */    41,   45,   42,   34,   33,   32,  105,   36,   35,  104,
- /*   190 */   147,   34,   33,   32,  172,  637,  805,   28,  628,  897,
- /*   200 */   631,  177,  634,  802,  172,  637,  896,   13,  628,  230,
- /*   210 */   631,  802,  634,   18,  172,  637,  794,  895,  628,   63,
- /*   220 */   631,   28,  634,  155,  574,   62,  169,  170,   23,  156,
- /*   230 */   209,   29,  197,   92,   91,  150,  169,  170,   77,   76,
- /*   240 */   582,   17,  198,  250,  249,  159,  169,  170,  248,  626,
- /*   250 */   247,  246,  245,  715,  244,  243,  133,  211,  780,   80,
- /*   260 */   160,  778,  779,   18,  242,  234,  781,  802,  783,  784,
- /*   270 */   782,   28,  785,  786,   43,   41,   45,   42,  724,  579,
- /*   280 */    64,  133,   36,   35,   19,  627,   34,   33,   32,    3,
- /*   290 */   124,  194,  225,   44,  910,   72,   68,   71,  158,   11,
- /*   300 */    10,  566,  592,   44,  563,  636,  564,  107,  565,  793,
- /*   310 */    22,  795,  630,   44,  633,  636,  716,   36,   35,  133,
- /*   320 */   635,   34,   33,   32,  171,  636,  596,   49,   78,   82,
- /*   330 */   635,   48,  182,  183,   87,   90,   81,  137,  135,  629,
- /*   340 */   635,  632,   84,   95,   94,   93,   50,    9,  145,  640,
- /*   350 */    52,   65,  120,  254,  253,   98,  597,  656,  638,  555,
- /*   360 */   146,   15,   14,   14,   24,    4,   55,   53,  546,  213,
- /*   370 */   556,  570,  148,  571,   24,   48,  568,  149,  569,   89,
- /*   380 */    88,  103,  101,  153,  154,  152,  141,  151,  144,  804,
- /*   390 */   864,  863,  818,  174,  860,  859,  175,  233,  826,  846,
- /*   400 */   831,  833,  106,  121,  845,  122,  567,  119,  123,  726,
- /*   410 */   217,  139,   26,  226,  102,  723,   28,  227,  909,   74,
- /*   420 */   908,  906,  125,  744,   27,   25,  196,  140,  713,  591,
- /*   430 */    83,  711,   85,   86,  199,  709,  708,  184,   54,  134,
- /*   440 */   706,  164,  705,  704,  703,  702,  136,  700,  698,  696,
- /*   450 */   694,  692,  138,  203,   58,   59,   51,  847,  815,   46,
- /*   460 */   208,  206,  204,  202,  200,   30,   79,  235,  236,  237,
- /*   470 */   238,  239,  240,  241,  161,  215,  216,  252,  670,  187,
- /*   480 */   186,  669,   69,  189,  157,  190,  668,  193,  661,  707,
- /*   490 */   197,  576,   60,   56,  593,   96,  128,   97,  127,  745,
- /*   500 */   126,  130,  129,  131,  132,  701,  693,  113,  111,  118,
- /*   510 */   116,  114,  112,  115,  800,    1,  117,    2,  166,   20,
- /*   520 */   108,  201,    6,  598,  109,    7,  639,    5,    8,   21,
- /*   530 */    16,   67,  212,  641,  214,  515,   65,  511,  509,  508,
- /*   540 */   507,  504,  478,  224,   70,   47,   73,   75,   24,  549,
- /*   550 */   548,  545,  499,  497,  489,  495,  491,  493,  487,  485,
- /*   560 */   517,  516,  514,  513,  512,  510,  506,  505,   48,  476,
- /*   570 */   447,  445,  674,  673,  673,  673,  673,  673,  673,  673,
- /*   580 */   673,  673,  673,  673,   99,  100,
+ /*     0 */   158,  505,  158,  710,  281,  857,   15,  578,  182,  506,
+ /*    10 */   941,  185,  942,   41,   42,  157,   43,   44,   26,  179,
+ /*    20 */   190,   35,  505,  505,  231,   47,   45,   49,   46,  868,
+ /*    30 */   506,  506,  846,   40,   39,  256,  255,   38,   37,   36,
+ /*    40 */    41,   42,  162,   43,   44,  857,  951,  190,   35,  178,
+ /*    50 */   279,  231,   47,   45,   49,   46,  180,  195,  843,  214,
+ /*    60 */    40,   39,  938,   61,   38,   37,   36,  462,  463,  464,
+ /*    70 */   465,  466,  467,  468,  469,  470,  471,  472,  473,  280,
+ /*    80 */   198,  846,  204,   41,   42,  865,   43,   44,  246,  266,
+ /*    90 */   190,   35,  158,  834,  231,   47,   45,   49,   46,  122,
+ /*   100 */   122,  184,  942,   40,   39,  122,   62,   38,   37,   36,
+ /*   110 */    20,  244,  274,  273,  243,  242,  241,  272,  240,  271,
+ /*   120 */   270,  269,  239,  268,  267,   38,   37,   36,  813,  657,
+ /*   130 */   801,  802,  803,  804,  805,  806,  807,  808,  809,  810,
+ /*   140 */   811,  812,  814,  815,   42,  200,   43,   44,  253,  252,
+ /*   150 */   190,   35,  937,  275,  231,   47,   45,   49,   46,  228,
+ /*   160 */   895,   66,  226,   40,   39,  115,  894,   38,   37,   36,
+ /*   170 */    26,   43,   44,   32,   26,  190,   35,  846,  207,  231,
+ /*   180 */    47,   45,   49,   46,   26,  211,  210,  754,   40,   39,
+ /*   190 */   146,  845,   38,   37,   36,  189,  670,  117,  835,  661,
+ /*   200 */    71,  664,   26,  667,  763,  189,  670,  146,  193,  661,
+ /*   210 */   843,  664,  194,  667,  843,  189,  670,   16,   26,  661,
+ /*   220 */   936,  664,  249,  667,  843,   10,   21,  186,  187,   70,
+ /*   230 */   132,  230,  837,  166,   32,  196,   69,  186,  187,  167,
+ /*   240 */   250,  615,  843,  122,  102,  101,  165,  186,  187,  174,
+ /*   250 */    20,   26,  274,  273,  219,  905,  254,  272,  843,  271,
+ /*   260 */   270,  269,  607,  268,  267,  832,  833,   25,  836,  819,
+ /*   270 */   216,   90,  817,  818,   21,  246,  266,  820,   68,  822,
+ /*   280 */   823,  821,   32,  824,  825,   47,   45,   49,   46,  258,
+ /*   290 */    33,  843,  199,   40,   39,   48,   26,   38,   37,   36,
+ /*   300 */   197,  217,  213,  248,   67,   48,   27,  669,  659,  173,
+ /*   310 */   278,  277,  109,  755,  232,   48,  146,  669,  599,  638,
+ /*   320 */   639,  596,  668,  597,  844,  598,  612,  669,  175,   40,
+ /*   330 */    39,   22,  668,   38,   37,   36,  842,  160,  625,   88,
+ /*   340 */    92,  188,  668,  119,  660,   82,   97,  100,   91,  201,
+ /*   350 */   202,   99,   98,  629,   94,    3,  136,  161,   52,  152,
+ /*   360 */   148,   29,   77,   73,   76,  150,  105,  104,  103,  630,
+ /*   370 */   689,  671,   53,   56,   18,   17,   17,  663,  163,  666,
+ /*   380 */   662,  588,  665,    4,   81,   80,   27,  234,  589,  164,
+ /*   390 */    57,   54,   27,   52,   12,   11,   87,   86,   59,  603,
+ /*   400 */   577,  604,   14,   13,  601,  170,  602,  673,  114,  112,
+ /*   410 */   171,  169,  156,  168,  159,  859,  904,  191,  901,  116,
+ /*   420 */   900,  192,  257,  867,  600,  872,  874,  887,  118,  886,
+ /*   430 */   133,  134,   32,  131,  135,  765,  238,  154,   30,  247,
+ /*   440 */   762,  956,   78,  955,  953,  137,  251,  950,   84,  113,
+ /*   450 */   949,  947,  138,  783,   31,   28,  155,  752,   93,  750,
+ /*   460 */   215,   95,   96,  748,  624,   58,  747,  203,  147,  745,
+ /*   470 */   744,  743,  742,  220,  741,   55,  149,   50,  181,  229,
+ /*   480 */   224,  856,  227,  124,  151,  738,  736,  734,  732,  730,
+ /*   490 */   225,  223,  221,  153,   34,  218,   89,   63,   64,  259,
+ /*   500 */   260,  888,  261,  262,  264,  263,  265,  276,  708,  205,
+ /*   510 */   206,  707,  208,  209,  706,  176,  236,  237,  694,  177,
+ /*   520 */   172,  212,   74,  216,   65,  609,  746,   60,  233,  106,
+ /*   530 */     6,  183,  740,  141,  107,  140,  784,  139,  142,  144,
+ /*   540 */   143,  145,  739,    1,  108,  841,  731,    2,  626,  129,
+ /*   550 */   127,  125,  123,  126,  128,  120,  222,  130,  631,  121,
+ /*   560 */    23,    7,    8,  672,   24,    5,    9,  674,   19,   72,
+ /*   570 */   235,  546,  542,   70,  540,  539,  538,  535,  509,  245,
+ /*   580 */    79,   75,   27,   83,   51,  580,  579,  576,  530,  528,
+ /*   590 */   520,  526,  522,   85,  524,  518,  516,  548,  547,  545,
+ /*   600 */   544,  543,  541,  537,  536,   52,  507,  477,  475,  110,
+ /*   610 */   712,  711,  711,  711,  711,  711,  711,  711,  711,  711,
+ /*   620 */   711,  111,
 };
 static const YYCODETYPE yy_lookahead[] = {
- /*     0 */   267,    1,  267,  213,  210,  211,  230,    5,  213,    9,
- /*    10 */   277,  276,  277,   13,   14,  267,   16,   17,  251,  213,
- /*    20 */    20,   21,    1,    1,   24,   25,   26,   27,   28,  253,
- /*    30 */     9,    9,  265,   33,   34,   33,   34,   37,   38,   39,
- /*    40 */    13,   14,  252,   16,   17,  251,  213,   20,   21,  212,
- /*    50 */   213,   24,   25,   26,   27,   28,  250,  218,  252,  265,
- /*    60 */    33,   34,  230,  268,   37,   38,   39,   45,   46,   47,
+ /*     0 */   268,    1,  268,  210,  211,  252,  268,    5,  230,    9,
+ /*    10 */   278,  277,  278,   13,   14,  268,   16,   17,  213,  266,
+ /*    20 */    20,   21,    1,    1,   24,   25,   26,   27,   28,  213,
+ /*    30 */     9,    9,  254,   33,   34,   33,   34,   37,   38,   39,
+ /*    40 */    13,   14,  268,   16,   17,  252,  254,   20,   21,  212,
+ /*    50 */   213,   24,   25,   26,   27,   28,  251,  230,  253,  266,
+ /*    60 */    33,   34,  268,  218,   37,   38,   39,   45,   46,   47,
  /*    70 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
- /*    80 */    66,   76,   60,   13,   14,  253,   16,   17,  249,   78,
- /*    90 */    20,   21,  267,  213,   24,   25,   26,   27,   28,  213,
- /*   100 */   213,  276,  277,   33,   34,  105,  273,   37,   38,   39,
- /*   110 */    85,   86,   87,   88,   89,   90,   91,   92,   93,   94,
- /*   120 */    95,   96,   97,   98,   99,  245,  267,  229,  101,  231,
- /*   130 */   232,  233,  234,  235,  236,  237,  238,  239,  240,  241,
- /*   140 */   242,  243,  244,   14,  130,   16,   17,  133,  134,   20,
- /*   150 */    21,  118,  119,   24,   25,   26,   27,   28,  271,  273,
- /*   160 */   273,  275,   33,   34,  213,  213,   37,   38,   39,  129,
- /*   170 */    16,   17,  213,  230,   20,   21,  136,  137,   24,   25,
- /*   180 */    26,   27,   28,   37,   38,   39,  213,   33,   34,  100,
- /*   190 */   267,   37,   38,   39,    1,    2,  253,  108,    5,  267,
- /*   200 */     7,  250,    9,  252,    1,    2,  267,   44,    5,  250,
- /*   210 */     7,  252,    9,  100,    1,    2,    0,  267,    5,  254,
- /*   220 */     7,  108,    9,   60,  101,  273,   33,   34,  213,   66,
- /*   230 */    37,  266,  109,   70,   71,   72,   33,   34,  131,  132,
- /*   240 */    37,   85,  269,   87,   88,  267,   33,   34,   92,    1,
- /*   250 */    94,   95,   96,  217,   98,   99,  220,   15,  229,   73,
- /*   260 */   267,  232,  233,  100,   78,  250,  237,  252,  239,  240,
- /*   270 */   241,  108,  243,  244,   25,   26,   27,   28,  217,  106,
- /*   280 */   218,  220,   33,   34,  111,   37,   37,   38,   39,   61,
- /*   290 */    62,  128,   76,  100,  253,   67,   68,   69,  135,  131,
- /*   300 */   132,    2,  101,  100,    5,  112,    7,  106,    9,  247,
- /*   310 */   248,  249,    5,  100,    7,  112,  217,   33,   34,  220,
- /*   320 */   127,   37,   38,   39,   59,  112,  101,  106,   61,   62,
- /*   330 */   127,  106,   33,   34,   67,   68,   69,   61,   62,    5,
- /*   340 */   127,    7,   75,   67,   68,   69,  125,  100,  267,  107,
- /*   350 */   106,  104,  105,   63,   64,   65,  101,  101,  101,  101,
- /*   360 */   267,  106,  106,  106,  106,  100,  100,  123,  102,  101,
- /*   370 */   101,    5,  267,    7,  106,  106,    5,  267,    7,   73,
- /*   380 */    74,   61,   62,  267,  267,  267,  267,  267,  267,  253,
- /*   390 */   246,  246,  251,  246,  246,  246,  246,  246,  213,  274,
- /*   400 */   213,  213,  213,  213,  274,  213,  107,  255,  213,  213,
- /*   410 */   213,  213,  213,  213,   59,  213,  108,  213,  213,  213,
- /*   420 */   213,  213,  213,  213,  213,  213,  251,  213,  213,  112,
- /*   430 */   213,  213,  213,  213,  270,  213,  213,  213,  122,  213,
- /*   440 */   213,  270,  213,  213,  213,  213,  213,  213,  213,  213,
- /*   450 */   213,  213,  213,  270,  214,  214,  124,  214,  264,  121,
- /*   460 */   116,  120,  115,  114,  113,  126,   84,   83,   49,   80,
- /*   470 */    82,   53,   81,   79,  214,  214,  214,   76,    5,    5,
- /*   480 */   138,    5,  218,  138,  214,    5,    5,  129,   86,  214,
- /*   490 */   109,  101,  106,  110,  101,  215,  222,  215,  226,  228,
- /*   500 */   227,  223,  225,  224,  221,  214,  214,  261,  263,  256,
- /*   510 */   258,  260,  262,  259,  251,  219,  257,  216,    1,  106,
- /*   520 */   100,  100,  117,  101,  100,  117,  101,  100,  100,  106,
- /*   530 */   100,   73,  103,  107,  103,    9,  104,    5,    5,    5,
- /*   540 */     5,    5,   77,   15,   73,   16,  132,  132,  106,    5,
- /*   550 */     5,  101,    5,    5,    5,    5,    5,    5,    5,    5,
- /*   560 */     5,    5,    5,    5,    5,    5,    5,    5,  106,   77,
- /*   570 */    59,   58,    0,  278,  278,  278,  278,  278,  278,  278,
- /*   580 */   278,  278,  278,  278,   21,   21,  278,  278,  278,  278,
- /*   590 */   278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
- /*   600 */   278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
- /*   610 */   278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
- /*   620 */   278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
- /*   630 */   278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
- /*   640 */   278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
- /*   650 */   278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
- /*   660 */   278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
- /*   670 */   278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
- /*   680 */   278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
- /*   690 */   278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
- /*   700 */   278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
- /*   710 */   278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
- /*   720 */   278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
- /*   730 */   278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
- /*   740 */   278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
- /*   750 */   278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
- /*   760 */   278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
- /*   770 */   278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
- /*   780 */   278,  278,  278,  278,  278,  278,  278,  278,  278,  278,
- /*   790 */   278,  278,  278,  278,  278,
+ /*    80 */    66,  254,   60,   13,   14,  269,   16,   17,   77,   79,
+ /*    90 */    20,   21,  268,  248,   24,   25,   26,   27,   28,  213,
+ /*   100 */   213,  277,  278,   33,   34,  213,  106,   37,   38,   39,
+ /*   110 */    86,   87,   88,   89,   90,   91,   92,   93,   94,   95,
+ /*   120 */    96,   97,   98,   99,  100,   37,   38,   39,  229,  102,
+ /*   130 */   231,  232,  233,  234,  235,  236,  237,  238,  239,  240,
+ /*   140 */   241,  242,  243,  244,   14,  131,   16,   17,  134,  135,
+ /*   150 */    20,   21,  268,  230,   24,   25,   26,   27,   28,  272,
+ /*   160 */   274,  274,  276,   33,   34,  101,  274,   37,   38,   39,
+ /*   170 */   213,   16,   17,  109,  213,   20,   21,  254,  130,   24,
+ /*   180 */    25,   26,   27,   28,  213,  137,  138,  217,   33,   34,
+ /*   190 */   220,  254,   37,   38,   39,    1,    2,  213,    0,    5,
+ /*   200 */   218,    7,  213,    9,  217,    1,    2,  220,  251,    5,
+ /*   210 */   253,    7,  251,    9,  253,    1,    2,   44,  213,    5,
+ /*   220 */   268,    7,  251,    9,  253,  101,  101,   33,   34,  105,
+ /*   230 */   106,   37,  250,   60,  109,   66,  218,   33,   34,   66,
+ /*   240 */   251,   37,  253,  213,   71,   72,   73,   33,   34,  268,
+ /*   250 */    86,  213,   88,   89,  270,  246,  251,   93,  253,   95,
+ /*   260 */    96,   97,  102,   99,  100,  247,  248,  249,  250,  229,
+ /*   270 */   110,   74,  232,  233,  101,   77,   79,  237,  255,  239,
+ /*   280 */   240,  241,  109,  243,  244,   25,   26,   27,   28,  251,
+ /*   290 */   267,  253,  213,   33,   34,  101,  213,   37,   38,   39,
+ /*   300 */   131,  102,  129,  134,  274,  101,  107,  113,    1,  136,
+ /*   310 */    63,   64,   65,  217,   15,  101,  220,  113,    2,  119,
+ /*   320 */   120,    5,  128,    7,  245,    9,  107,  113,  268,   33,
+ /*   330 */    34,  112,  128,   37,   38,   39,  253,  268,  102,   61,
+ /*   340 */    62,   59,  128,  107,   37,   67,   68,   69,   70,   33,
+ /*   350 */    34,   74,   75,  102,   76,   61,   62,  268,  107,   61,
+ /*   360 */    62,   67,   68,   69,   70,   67,   68,   69,   70,  102,
+ /*   370 */   102,  102,  107,  107,  107,  107,  107,    5,  268,    7,
+ /*   380 */     5,  102,    7,  101,  132,  133,  107,  102,  102,  268,
+ /*   390 */   124,  126,  107,  107,  132,  133,  132,  133,  101,    5,
+ /*   400 */   103,    7,  132,  133,    5,  268,    7,  108,   61,   62,
+ /*   410 */   268,  268,  268,  268,  268,  252,  246,  246,  246,  213,
+ /*   420 */   246,  246,  246,  213,  108,  213,  213,  275,  213,  275,
+ /*   430 */   213,  213,  109,  256,  213,  213,  213,  213,  213,  213,
+ /*   440 */   213,  213,  213,  213,  213,  213,  213,  213,  213,   59,
+ /*   450 */   213,  213,  213,  213,  213,  213,  213,  213,  213,  213,
+ /*   460 */   252,  213,  213,  213,  113,  123,  213,  213,  213,  213,
+ /*   470 */   213,  213,  213,  271,  213,  125,  213,  122,  271,  117,
+ /*   480 */   271,  265,  121,  263,  213,  213,  213,  213,  213,  213,
+ /*   490 */   116,  115,  114,  213,  127,  214,   85,  214,  214,   84,
+ /*   500 */    49,  214,   81,   83,   82,   53,   80,   77,    5,  139,
+ /*   510 */     5,    5,  139,    5,    5,  214,  214,  214,   87,  214,
+ /*   520 */   214,  130,  218,  110,  107,  102,  214,  111,  104,  215,
+ /*   530 */   101,    1,  214,  222,  215,  226,  228,  227,  225,  224,
+ /*   540 */   223,  221,  214,  219,  215,  252,  214,  216,  102,  258,
+ /*   550 */   260,  262,  264,  261,  259,  101,  101,  257,  102,  101,
+ /*   560 */   107,  118,  118,  102,  107,  101,  101,  108,  101,   74,
+ /*   570 */   104,    9,    5,  105,    5,    5,    5,    5,   78,   15,
+ /*   580 */   133,   74,  107,  133,   16,    5,    5,  102,    5,    5,
+ /*   590 */     5,    5,    5,  133,    5,    5,    5,    5,    5,    5,
+ /*   600 */     5,    5,    5,    5,    5,  107,   78,   59,   58,   21,
+ /*   610 */     0,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   620 */   279,   21,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   630 */   279,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   640 */   279,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   650 */   279,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   660 */   279,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   670 */   279,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   680 */   279,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   690 */   279,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   700 */   279,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   710 */   279,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   720 */   279,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   730 */   279,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   740 */   279,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   750 */   279,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   760 */   279,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   770 */   279,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   780 */   279,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   790 */   279,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   800 */   279,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   810 */   279,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   820 */   279,  279,  279,  279,  279,  279,  279,  279,  279,  279,
+ /*   830 */   279,
 };
-#define YY_SHIFT_COUNT    (257)
+#define YY_SHIFT_COUNT    (281)
 #define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (572)
+#define YY_SHIFT_MAX      (610)
 static const unsigned short int yy_shift_ofst[] = {
- /*     0 */   163,   25,  156,    5,  193,  213,   21,   21,   21,   21,
- /*    10 */    21,   21,    0,   22,  213,  299,  299,  299,  113,   21,
- /*    20 */    21,   21,  216,   21,   21,  186,   11,   11,  586,  203,
- /*    30 */   213,  213,  213,  213,  213,  213,  213,  213,  213,  213,
- /*    40 */   213,  213,  213,  213,  213,  213,  213,  299,  299,    2,
- /*    50 */     2,    2,    2,    2,    2,    2,   89,   21,   21,   21,
- /*    60 */    21,   33,   33,  173,   21,   21,   21,   21,   21,   21,
+ /*     0 */   173,   24,  164,   11,  194,  214,   21,   21,   21,   21,
+ /*    10 */    21,   21,   21,   21,   21,    0,   22,  214,  316,  316,
+ /*    20 */   316,  125,   21,   21,   21,  198,   21,   21,  197,   11,
+ /*    30 */    10,   10,  622,  204,  214,  214,  214,  214,  214,  214,
+ /*    40 */   214,  214,  214,  214,  214,  214,  214,  214,  214,  214,
+ /*    50 */   214,  316,  316,    2,    2,    2,    2,    2,    2,    2,
+ /*    60 */    64,   21,   21,   21,   21,   21,  200,  200,  219,   21,
  /*    70 */    21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
  /*    80 */    21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
  /*    90 */    21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
- /*   100 */    21,   21,   21,   21,  308,  355,  355,  317,  317,  317,
- /*   110 */   355,  316,  332,  338,  344,  341,  347,  349,  351,  339,
- /*   120 */   308,  355,  355,  355,    5,  355,  382,  384,  419,  389,
- /*   130 */   388,  418,  391,  394,  355,  401,  355,  401,  355,  586,
- /*   140 */   586,   27,   70,   70,   70,  129,  154,  249,  249,  249,
- /*   150 */   267,  284,  284,  284,  284,  228,  276,   14,   40,  146,
- /*   160 */   146,  247,  290,  123,  201,  225,  255,  256,  257,  307,
- /*   170 */   334,  248,  265,  242,  221,  244,  258,  268,  269,  107,
- /*   180 */   266,  168,  366,  371,  306,  320,  473,  342,  474,  476,
- /*   190 */   345,  480,  481,  402,  358,  381,  390,  383,  386,  393,
- /*   200 */   420,  517,  421,  422,  424,  413,  405,  423,  408,  425,
- /*   210 */   427,  426,  428,  429,  430,  431,  432,  458,  526,  532,
- /*   220 */   533,  534,  535,  536,  465,  528,  471,  529,  414,  415,
- /*   230 */   442,  544,  545,  450,  442,  547,  548,  549,  550,  551,
- /*   240 */   552,  553,  554,  555,  556,  557,  558,  559,  560,  561,
- /*   250 */   562,  462,  492,  563,  564,  511,  513,  572,
+ /*   100 */    21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
+ /*   110 */    21,   21,   21,   21,   21,  323,  390,  390,  390,  351,
+ /*   120 */   351,  351,  390,  342,  350,  355,  362,  361,  374,  376,
+ /*   130 */   378,  367,  323,  390,  390,  390,   11,  390,  390,  411,
+ /*   140 */   415,  451,  421,  420,  452,  422,  426,  390,  430,  390,
+ /*   150 */   430,  390,  430,  390,  622,  622,   27,   70,   70,   70,
+ /*   160 */   130,  155,  260,  260,  260,  278,  294,  298,  296,  296,
+ /*   170 */   296,  296,   14,   48,   88,   88,  124,  169,  247,  160,
+ /*   180 */   199,  236,  251,  267,  268,  269,  372,  375,  307,  282,
+ /*   190 */   299,  265,  266,  279,  285,  286,  252,  262,  264,  297,
+ /*   200 */   270,  394,  399,  277,  347,  503,  370,  505,  506,  373,
+ /*   210 */   508,  509,  431,  391,  413,  423,  416,  424,  429,  417,
+ /*   220 */   446,  454,  530,  455,  456,  458,  453,  443,  457,  444,
+ /*   230 */   461,  464,  459,  465,  424,  467,  466,  468,  495,  562,
+ /*   240 */   567,  569,  570,  571,  572,  500,  564,  507,  447,  475,
+ /*   250 */   475,  568,  450,  460,  475,  580,  581,  485,  475,  583,
+ /*   260 */   584,  585,  586,  587,  589,  590,  591,  592,  593,  594,
+ /*   270 */   595,  596,  597,  598,  599,  498,  528,  588,  600,  548,
+ /*   280 */   550,  610,
 };
-#define YY_REDUCE_COUNT (140)
-#define YY_REDUCE_MIN   (-267)
-#define YY_REDUCE_MAX   (301)
+#define YY_REDUCE_COUNT (155)
+#define YY_REDUCE_MIN   (-268)
+#define YY_REDUCE_MAX   (332)
 static const short yy_reduce_ofst[] = {
- /*     0 */  -206, -102,   29,   62, -265, -175, -114, -113, -194,  -49,
- /*    10 */   -41,   15, -205, -163, -267, -224, -168,  -57, -233,  -27,
- /*    20 */  -167,  -48, -161, -120, -210,   36,   61,   99,  -35, -252,
- /*    30 */  -141,  -77,  -68,  -61,  -50,  -22,   -7,   81,   93,  105,
- /*    40 */   110,  116,  117,  118,  119,  120,  121,   41,  136,  144,
- /*    50 */   145,  147,  148,  149,  150,  151,  141,  185,  187,  188,
- /*    60 */   189,  125,  130,  152,  190,  192,  195,  196,  197,  198,
- /*    70 */   199,  200,  202,  204,  205,  206,  207,  208,  209,  210,
- /*    80 */   211,  212,  214,  215,  217,  218,  219,  220,  222,  223,
- /*    90 */   224,  226,  227,  229,  230,  231,  232,  233,  234,  235,
- /*   100 */   236,  237,  238,  239,  175,  240,  241,  164,  171,  183,
- /*   110 */   243,  194,  245,  250,  246,  251,  254,  252,  259,  253,
- /*   120 */   263,  260,  261,  262,  264,  270,  271,  273,  272,  274,
- /*   130 */   277,  278,  279,  283,  275,  280,  291,  282,  292,  296,
- /*   140 */   301,
+ /*     0 */  -207, -101,   40,   18, -266, -176, -195, -114, -113,  -43,
+ /*    10 */   -39,  -29,  -11,    5,   38, -184, -163, -268, -222, -173,
+ /*    20 */   -77, -247,  -16, -108,   30,  -18,   79,   83,  -30, -155,
+ /*    30 */   -13,   96,   23, -262, -253, -226, -206, -116,  -48,  -19,
+ /*    40 */    60,   69,   89,  110,  121,  137,  142,  143,  144,  145,
+ /*    50 */   146, -208,  -63,    9,  170,  171,  172,  174,  175,  176,
+ /*    60 */   163,  206,  210,  212,  213,  215,  152,  154,  177,  217,
+ /*    70 */   218,  221,  222,  223,  224,  225,  226,  227,  228,  229,
+ /*    80 */   230,  231,  232,  233,  234,  235,  237,  238,  239,  240,
+ /*    90 */   241,  242,  243,  244,  245,  246,  248,  249,  250,  253,
+ /*   100 */   254,  255,  256,  257,  258,  259,  261,  263,  271,  272,
+ /*   110 */   273,  274,  275,  276,  280,  208,  281,  283,  284,  202,
+ /*   120 */   207,  209,  287,  216,  288,  220,  289,  292,  290,  295,
+ /*   130 */   291,  300,  293,  301,  302,  303,  304,  305,  306,  308,
+ /*   140 */   310,  309,  311,  313,  317,  315,  320,  312,  314,  318,
+ /*   150 */   319,  328,  329,  332,  324,  331,
 };
 static const YYACTIONTYPE yy_default[] = {
- /*     0 */   671,  725,  714,  722,  903,  903,  671,  671,  671,  671,
- /*    10 */   671,  671,  828,  689,  903,  671,  671,  671,  671,  671,
- /*    20 */   671,  671,  722,  671,  671,  727,  727,  727,  823,  671,
- /*    30 */   671,  671,  671,  671,  671,  671,  671,  671,  671,  671,
- /*    40 */   671,  671,  671,  671,  671,  671,  671,  671,  671,  671,
- /*    50 */   671,  671,  671,  671,  671,  671,  671,  671,  830,  832,
- /*    60 */   671,  850,  850,  821,  671,  671,  671,  671,  671,  671,
- /*    70 */   671,  671,  671,  671,  671,  671,  671,  671,  671,  671,
- /*    80 */   671,  671,  671,  712,  671,  710,  671,  671,  671,  671,
- /*    90 */   671,  671,  671,  671,  671,  671,  671,  671,  699,  671,
- /*   100 */   671,  671,  671,  671,  671,  691,  691,  671,  671,  671,
- /*   110 */   691,  857,  861,  855,  843,  851,  842,  838,  837,  865,
- /*   120 */   671,  691,  691,  691,  722,  691,  743,  741,  739,  731,
- /*   130 */   737,  733,  735,  729,  691,  720,  691,  720,  691,  761,
- /*   140 */   777,  671,  866,  902,  856,  892,  891,  898,  890,  889,
- /*   150 */   671,  885,  886,  888,  887,  671,  671,  671,  671,  894,
- /*   160 */   893,  671,  671,  671,  671,  671,  671,  671,  671,  671,
- /*   170 */   671,  671,  868,  671,  862,  858,  671,  671,  671,  671,
- /*   180 */   787,  671,  671,  671,  671,  671,  671,  671,  671,  671,
- /*   190 */   671,  671,  671,  671,  671,  820,  671,  671,  829,  671,
- /*   200 */   671,  671,  671,  671,  671,  852,  671,  844,  671,  671,
- /*   210 */   671,  671,  671,  797,  671,  671,  671,  671,  671,  671,
- /*   220 */   671,  671,  671,  671,  671,  671,  671,  671,  671,  671,
- /*   230 */   907,  671,  671,  671,  905,  671,  671,  671,  671,  671,
- /*   240 */   671,  671,  671,  671,  671,  671,  671,  671,  671,  671,
- /*   250 */   671,  746,  671,  697,  695,  671,  687,  671,
+ /*     0 */   709,  764,  753,  761,  944,  944,  709,  709,  709,  709,
+ /*    10 */   709,  709,  709,  709,  709,  869,  727,  944,  709,  709,
+ /*    20 */   709,  709,  709,  709,  709,  761,  709,  709,  766,  761,
+ /*    30 */   766,  766,  864,  709,  709,  709,  709,  709,  709,  709,
+ /*    40 */   709,  709,  709,  709,  709,  709,  709,  709,  709,  709,
+ /*    50 */   709,  709,  709,  709,  709,  709,  709,  709,  709,  709,
+ /*    60 */   709,  709,  709,  871,  873,  709,  891,  891,  862,  709,
+ /*    70 */   709,  709,  709,  709,  709,  709,  709,  709,  709,  709,
+ /*    80 */   709,  709,  709,  709,  709,  709,  709,  709,  709,  709,
+ /*    90 */   709,  709,  709,  751,  709,  749,  709,  709,  709,  709,
+ /*   100 */   709,  709,  709,  709,  709,  709,  709,  709,  709,  737,
+ /*   110 */   709,  709,  709,  709,  709,  709,  729,  729,  729,  709,
+ /*   120 */   709,  709,  729,  898,  902,  896,  884,  892,  883,  879,
+ /*   130 */   878,  906,  709,  729,  729,  729,  761,  729,  729,  782,
+ /*   140 */   780,  778,  770,  776,  772,  774,  768,  729,  759,  729,
+ /*   150 */   759,  729,  759,  729,  800,  816,  709,  907,  943,  897,
+ /*   160 */   933,  932,  939,  931,  930,  709,  709,  709,  926,  927,
+ /*   170 */   929,  928,  709,  709,  935,  934,  709,  709,  709,  709,
+ /*   180 */   709,  709,  709,  709,  709,  709,  709,  709,  709,  909,
+ /*   190 */   709,  903,  899,  709,  709,  709,  709,  709,  709,  826,
+ /*   200 */   709,  709,  709,  709,  709,  709,  709,  709,  709,  709,
+ /*   210 */   709,  709,  709,  709,  861,  709,  709,  709,  709,  870,
+ /*   220 */   709,  709,  709,  709,  709,  709,  893,  709,  885,  709,
+ /*   230 */   709,  709,  709,  709,  838,  709,  709,  709,  709,  709,
+ /*   240 */   709,  709,  709,  709,  709,  709,  709,  709,  709,  954,
+ /*   250 */   952,  709,  709,  709,  948,  709,  709,  709,  946,  709,
+ /*   260 */   709,  709,  709,  709,  709,  709,  709,  709,  709,  709,
+ /*   270 */   709,  709,  709,  709,  709,  785,  709,  735,  733,  709,
+ /*   280 */   725,  709,
 };
 /********** End of lemon-generated parsing tables *****************************/
 
@@ -511,6 +526,7 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*    STABLES => nothing */
     0,  /*    VGROUPS => nothing */
     0,  /*       DROP => nothing */
+    1,  /*     STABLE => ID */
     0,  /*      DNODE => nothing */
     0,  /*       USER => nothing */
     0,  /*    ACCOUNT => nothing */
@@ -649,7 +665,6 @@ static const YYCODETYPE yyFallback[] = {
     1,  /*     TBNAME => ID */
     1,  /*       JOIN => ID */
     1,  /*    METRICS => ID */
-    1,  /*     STABLE => ID */
     1,  /*     INSERT => ID */
     1,  /*       INTO => ID */
     1,  /*     VALUES => ID */
@@ -806,145 +821,145 @@ static const char *const yyTokenName[] = {
   /*   64 */ "STABLES",
   /*   65 */ "VGROUPS",
   /*   66 */ "DROP",
-  /*   67 */ "DNODE",
-  /*   68 */ "USER",
-  /*   69 */ "ACCOUNT",
-  /*   70 */ "USE",
-  /*   71 */ "DESCRIBE",
-  /*   72 */ "ALTER",
-  /*   73 */ "PASS",
-  /*   74 */ "PRIVILEGE",
-  /*   75 */ "LOCAL",
-  /*   76 */ "IF",
-  /*   77 */ "EXISTS",
-  /*   78 */ "PPS",
-  /*   79 */ "TSERIES",
-  /*   80 */ "DBS",
-  /*   81 */ "STORAGE",
-  /*   82 */ "QTIME",
-  /*   83 */ "CONNS",
-  /*   84 */ "STATE",
-  /*   85 */ "KEEP",
-  /*   86 */ "CACHE",
-  /*   87 */ "REPLICA",
-  /*   88 */ "QUORUM",
-  /*   89 */ "DAYS",
-  /*   90 */ "MINROWS",
-  /*   91 */ "MAXROWS",
-  /*   92 */ "BLOCKS",
-  /*   93 */ "CTIME",
-  /*   94 */ "WAL",
-  /*   95 */ "FSYNC",
-  /*   96 */ "COMP",
-  /*   97 */ "PRECISION",
-  /*   98 */ "UPDATE",
-  /*   99 */ "CACHELAST",
-  /*  100 */ "LP",
-  /*  101 */ "RP",
-  /*  102 */ "UNSIGNED",
-  /*  103 */ "TAGS",
-  /*  104 */ "USING",
-  /*  105 */ "AS",
-  /*  106 */ "COMMA",
-  /*  107 */ "NULL",
-  /*  108 */ "SELECT",
-  /*  109 */ "UNION",
-  /*  110 */ "ALL",
-  /*  111 */ "FROM",
-  /*  112 */ "VARIABLE",
-  /*  113 */ "INTERVAL",
-  /*  114 */ "FILL",
-  /*  115 */ "SLIDING",
-  /*  116 */ "ORDER",
-  /*  117 */ "BY",
-  /*  118 */ "ASC",
-  /*  119 */ "DESC",
-  /*  120 */ "GROUP",
-  /*  121 */ "HAVING",
-  /*  122 */ "LIMIT",
-  /*  123 */ "OFFSET",
-  /*  124 */ "SLIMIT",
-  /*  125 */ "SOFFSET",
-  /*  126 */ "WHERE",
-  /*  127 */ "NOW",
-  /*  128 */ "RESET",
-  /*  129 */ "QUERY",
-  /*  130 */ "ADD",
-  /*  131 */ "COLUMN",
-  /*  132 */ "TAG",
-  /*  133 */ "CHANGE",
-  /*  134 */ "SET",
-  /*  135 */ "KILL",
-  /*  136 */ "CONNECTION",
-  /*  137 */ "STREAM",
-  /*  138 */ "COLON",
-  /*  139 */ "ABORT",
-  /*  140 */ "AFTER",
-  /*  141 */ "ATTACH",
-  /*  142 */ "BEFORE",
-  /*  143 */ "BEGIN",
-  /*  144 */ "CASCADE",
-  /*  145 */ "CLUSTER",
-  /*  146 */ "CONFLICT",
-  /*  147 */ "COPY",
-  /*  148 */ "DEFERRED",
-  /*  149 */ "DELIMITERS",
-  /*  150 */ "DETACH",
-  /*  151 */ "EACH",
-  /*  152 */ "END",
-  /*  153 */ "EXPLAIN",
-  /*  154 */ "FAIL",
-  /*  155 */ "FOR",
-  /*  156 */ "IGNORE",
-  /*  157 */ "IMMEDIATE",
-  /*  158 */ "INITIALLY",
-  /*  159 */ "INSTEAD",
-  /*  160 */ "MATCH",
-  /*  161 */ "KEY",
-  /*  162 */ "OF",
-  /*  163 */ "RAISE",
-  /*  164 */ "REPLACE",
-  /*  165 */ "RESTRICT",
-  /*  166 */ "ROW",
-  /*  167 */ "STATEMENT",
-  /*  168 */ "TRIGGER",
-  /*  169 */ "VIEW",
-  /*  170 */ "COUNT",
-  /*  171 */ "SUM",
-  /*  172 */ "AVG",
-  /*  173 */ "MIN",
-  /*  174 */ "MAX",
-  /*  175 */ "FIRST",
-  /*  176 */ "LAST",
-  /*  177 */ "TOP",
-  /*  178 */ "BOTTOM",
-  /*  179 */ "STDDEV",
-  /*  180 */ "PERCENTILE",
-  /*  181 */ "APERCENTILE",
-  /*  182 */ "LEASTSQUARES",
-  /*  183 */ "HISTOGRAM",
-  /*  184 */ "DIFF",
-  /*  185 */ "SPREAD",
-  /*  186 */ "TWA",
-  /*  187 */ "INTERP",
-  /*  188 */ "LAST_ROW",
-  /*  189 */ "RATE",
-  /*  190 */ "IRATE",
-  /*  191 */ "SUM_RATE",
-  /*  192 */ "SUM_IRATE",
-  /*  193 */ "AVG_RATE",
-  /*  194 */ "AVG_IRATE",
-  /*  195 */ "TBID",
-  /*  196 */ "SEMI",
-  /*  197 */ "NONE",
-  /*  198 */ "PREV",
-  /*  199 */ "LINEAR",
-  /*  200 */ "IMPORT",
-  /*  201 */ "METRIC",
-  /*  202 */ "TBNAME",
-  /*  203 */ "JOIN",
-  /*  204 */ "METRICS",
-  /*  205 */ "STABLE",
+  /*   67 */ "STABLE",
+  /*   68 */ "DNODE",
+  /*   69 */ "USER",
+  /*   70 */ "ACCOUNT",
+  /*   71 */ "USE",
+  /*   72 */ "DESCRIBE",
+  /*   73 */ "ALTER",
+  /*   74 */ "PASS",
+  /*   75 */ "PRIVILEGE",
+  /*   76 */ "LOCAL",
+  /*   77 */ "IF",
+  /*   78 */ "EXISTS",
+  /*   79 */ "PPS",
+  /*   80 */ "TSERIES",
+  /*   81 */ "DBS",
+  /*   82 */ "STORAGE",
+  /*   83 */ "QTIME",
+  /*   84 */ "CONNS",
+  /*   85 */ "STATE",
+  /*   86 */ "KEEP",
+  /*   87 */ "CACHE",
+  /*   88 */ "REPLICA",
+  /*   89 */ "QUORUM",
+  /*   90 */ "DAYS",
+  /*   91 */ "MINROWS",
+  /*   92 */ "MAXROWS",
+  /*   93 */ "BLOCKS",
+  /*   94 */ "CTIME",
+  /*   95 */ "WAL",
+  /*   96 */ "FSYNC",
+  /*   97 */ "COMP",
+  /*   98 */ "PRECISION",
+  /*   99 */ "UPDATE",
+  /*  100 */ "CACHELAST",
+  /*  101 */ "LP",
+  /*  102 */ "RP",
+  /*  103 */ "UNSIGNED",
+  /*  104 */ "TAGS",
+  /*  105 */ "USING",
+  /*  106 */ "AS",
+  /*  107 */ "COMMA",
+  /*  108 */ "NULL",
+  /*  109 */ "SELECT",
+  /*  110 */ "UNION",
+  /*  111 */ "ALL",
+  /*  112 */ "FROM",
+  /*  113 */ "VARIABLE",
+  /*  114 */ "INTERVAL",
+  /*  115 */ "FILL",
+  /*  116 */ "SLIDING",
+  /*  117 */ "ORDER",
+  /*  118 */ "BY",
+  /*  119 */ "ASC",
+  /*  120 */ "DESC",
+  /*  121 */ "GROUP",
+  /*  122 */ "HAVING",
+  /*  123 */ "LIMIT",
+  /*  124 */ "OFFSET",
+  /*  125 */ "SLIMIT",
+  /*  126 */ "SOFFSET",
+  /*  127 */ "WHERE",
+  /*  128 */ "NOW",
+  /*  129 */ "RESET",
+  /*  130 */ "QUERY",
+  /*  131 */ "ADD",
+  /*  132 */ "COLUMN",
+  /*  133 */ "TAG",
+  /*  134 */ "CHANGE",
+  /*  135 */ "SET",
+  /*  136 */ "KILL",
+  /*  137 */ "CONNECTION",
+  /*  138 */ "STREAM",
+  /*  139 */ "COLON",
+  /*  140 */ "ABORT",
+  /*  141 */ "AFTER",
+  /*  142 */ "ATTACH",
+  /*  143 */ "BEFORE",
+  /*  144 */ "BEGIN",
+  /*  145 */ "CASCADE",
+  /*  146 */ "CLUSTER",
+  /*  147 */ "CONFLICT",
+  /*  148 */ "COPY",
+  /*  149 */ "DEFERRED",
+  /*  150 */ "DELIMITERS",
+  /*  151 */ "DETACH",
+  /*  152 */ "EACH",
+  /*  153 */ "END",
+  /*  154 */ "EXPLAIN",
+  /*  155 */ "FAIL",
+  /*  156 */ "FOR",
+  /*  157 */ "IGNORE",
+  /*  158 */ "IMMEDIATE",
+  /*  159 */ "INITIALLY",
+  /*  160 */ "INSTEAD",
+  /*  161 */ "MATCH",
+  /*  162 */ "KEY",
+  /*  163 */ "OF",
+  /*  164 */ "RAISE",
+  /*  165 */ "REPLACE",
+  /*  166 */ "RESTRICT",
+  /*  167 */ "ROW",
+  /*  168 */ "STATEMENT",
+  /*  169 */ "TRIGGER",
+  /*  170 */ "VIEW",
+  /*  171 */ "COUNT",
+  /*  172 */ "SUM",
+  /*  173 */ "AVG",
+  /*  174 */ "MIN",
+  /*  175 */ "MAX",
+  /*  176 */ "FIRST",
+  /*  177 */ "LAST",
+  /*  178 */ "TOP",
+  /*  179 */ "BOTTOM",
+  /*  180 */ "STDDEV",
+  /*  181 */ "PERCENTILE",
+  /*  182 */ "APERCENTILE",
+  /*  183 */ "LEASTSQUARES",
+  /*  184 */ "HISTOGRAM",
+  /*  185 */ "DIFF",
+  /*  186 */ "SPREAD",
+  /*  187 */ "TWA",
+  /*  188 */ "INTERP",
+  /*  189 */ "LAST_ROW",
+  /*  190 */ "RATE",
+  /*  191 */ "IRATE",
+  /*  192 */ "SUM_RATE",
+  /*  193 */ "SUM_IRATE",
+  /*  194 */ "AVG_RATE",
+  /*  195 */ "AVG_IRATE",
+  /*  196 */ "TBID",
+  /*  197 */ "SEMI",
+  /*  198 */ "NONE",
+  /*  199 */ "PREV",
+  /*  200 */ "LINEAR",
+  /*  201 */ "IMPORT",
+  /*  202 */ "METRIC",
+  /*  203 */ "TBNAME",
+  /*  204 */ "JOIN",
+  /*  205 */ "METRICS",
   /*  206 */ "INSERT",
   /*  207 */ "INTO",
   /*  208 */ "VALUES",
@@ -987,36 +1002,37 @@ static const char *const yyTokenName[] = {
   /*  245 */ "typename",
   /*  246 */ "signed",
   /*  247 */ "create_table_args",
-  /*  248 */ "create_table_list",
-  /*  249 */ "create_from_stable",
-  /*  250 */ "columnlist",
-  /*  251 */ "select",
-  /*  252 */ "column",
-  /*  253 */ "tagitem",
-  /*  254 */ "selcollist",
-  /*  255 */ "from",
-  /*  256 */ "where_opt",
-  /*  257 */ "interval_opt",
-  /*  258 */ "fill_opt",
-  /*  259 */ "sliding_opt",
-  /*  260 */ "groupby_opt",
-  /*  261 */ "orderby_opt",
-  /*  262 */ "having_opt",
-  /*  263 */ "slimit_opt",
-  /*  264 */ "limit_opt",
-  /*  265 */ "union",
-  /*  266 */ "sclp",
-  /*  267 */ "expr",
-  /*  268 */ "as",
-  /*  269 */ "tablelist",
-  /*  270 */ "tmvar",
-  /*  271 */ "sortlist",
-  /*  272 */ "sortitem",
-  /*  273 */ "item",
-  /*  274 */ "sortorder",
-  /*  275 */ "grouplist",
-  /*  276 */ "exprlist",
-  /*  277 */ "expritem",
+  /*  248 */ "create_stable_args",
+  /*  249 */ "create_table_list",
+  /*  250 */ "create_from_stable",
+  /*  251 */ "columnlist",
+  /*  252 */ "select",
+  /*  253 */ "column",
+  /*  254 */ "tagitem",
+  /*  255 */ "selcollist",
+  /*  256 */ "from",
+  /*  257 */ "where_opt",
+  /*  258 */ "interval_opt",
+  /*  259 */ "fill_opt",
+  /*  260 */ "sliding_opt",
+  /*  261 */ "groupby_opt",
+  /*  262 */ "orderby_opt",
+  /*  263 */ "having_opt",
+  /*  264 */ "slimit_opt",
+  /*  265 */ "limit_opt",
+  /*  266 */ "union",
+  /*  267 */ "sclp",
+  /*  268 */ "expr",
+  /*  269 */ "as",
+  /*  270 */ "tablelist",
+  /*  271 */ "tmvar",
+  /*  272 */ "sortlist",
+  /*  273 */ "sortitem",
+  /*  274 */ "item",
+  /*  275 */ "sortorder",
+  /*  276 */ "grouplist",
+  /*  277 */ "exprlist",
+  /*  278 */ "expritem",
 };
 #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
 
@@ -1052,218 +1068,226 @@ static const char *const yyRuleName[] = {
  /*  25 */ "cmd ::= SHOW dbPrefix VGROUPS",
  /*  26 */ "cmd ::= SHOW dbPrefix VGROUPS ids",
  /*  27 */ "cmd ::= DROP TABLE ifexists ids cpxName",
- /*  28 */ "cmd ::= DROP DATABASE ifexists ids",
- /*  29 */ "cmd ::= DROP DNODE ids",
- /*  30 */ "cmd ::= DROP USER ids",
- /*  31 */ "cmd ::= DROP ACCOUNT ids",
- /*  32 */ "cmd ::= USE ids",
- /*  33 */ "cmd ::= DESCRIBE ids cpxName",
- /*  34 */ "cmd ::= ALTER USER ids PASS ids",
- /*  35 */ "cmd ::= ALTER USER ids PRIVILEGE ids",
- /*  36 */ "cmd ::= ALTER DNODE ids ids",
- /*  37 */ "cmd ::= ALTER DNODE ids ids ids",
- /*  38 */ "cmd ::= ALTER LOCAL ids",
- /*  39 */ "cmd ::= ALTER LOCAL ids ids",
- /*  40 */ "cmd ::= ALTER DATABASE ids alter_db_optr",
- /*  41 */ "cmd ::= ALTER ACCOUNT ids acct_optr",
- /*  42 */ "cmd ::= ALTER ACCOUNT ids PASS ids acct_optr",
- /*  43 */ "ids ::= ID",
- /*  44 */ "ids ::= STRING",
- /*  45 */ "ifexists ::= IF EXISTS",
- /*  46 */ "ifexists ::=",
- /*  47 */ "ifnotexists ::= IF NOT EXISTS",
- /*  48 */ "ifnotexists ::=",
- /*  49 */ "cmd ::= CREATE DNODE ids",
- /*  50 */ "cmd ::= CREATE ACCOUNT ids PASS ids acct_optr",
- /*  51 */ "cmd ::= CREATE DATABASE ifnotexists ids db_optr",
- /*  52 */ "cmd ::= CREATE USER ids PASS ids",
- /*  53 */ "pps ::=",
- /*  54 */ "pps ::= PPS INTEGER",
- /*  55 */ "tseries ::=",
- /*  56 */ "tseries ::= TSERIES INTEGER",
- /*  57 */ "dbs ::=",
- /*  58 */ "dbs ::= DBS INTEGER",
- /*  59 */ "streams ::=",
- /*  60 */ "streams ::= STREAMS INTEGER",
- /*  61 */ "storage ::=",
- /*  62 */ "storage ::= STORAGE INTEGER",
- /*  63 */ "qtime ::=",
- /*  64 */ "qtime ::= QTIME INTEGER",
- /*  65 */ "users ::=",
- /*  66 */ "users ::= USERS INTEGER",
- /*  67 */ "conns ::=",
- /*  68 */ "conns ::= CONNS INTEGER",
- /*  69 */ "state ::=",
- /*  70 */ "state ::= STATE ids",
- /*  71 */ "acct_optr ::= pps tseries storage streams qtime dbs users conns state",
- /*  72 */ "keep ::= KEEP tagitemlist",
- /*  73 */ "cache ::= CACHE INTEGER",
- /*  74 */ "replica ::= REPLICA INTEGER",
- /*  75 */ "quorum ::= QUORUM INTEGER",
- /*  76 */ "days ::= DAYS INTEGER",
- /*  77 */ "minrows ::= MINROWS INTEGER",
- /*  78 */ "maxrows ::= MAXROWS INTEGER",
- /*  79 */ "blocks ::= BLOCKS INTEGER",
- /*  80 */ "ctime ::= CTIME INTEGER",
- /*  81 */ "wal ::= WAL INTEGER",
- /*  82 */ "fsync ::= FSYNC INTEGER",
- /*  83 */ "comp ::= COMP INTEGER",
- /*  84 */ "prec ::= PRECISION STRING",
- /*  85 */ "update ::= UPDATE INTEGER",
- /*  86 */ "cachelast ::= CACHELAST INTEGER",
- /*  87 */ "db_optr ::=",
- /*  88 */ "db_optr ::= db_optr cache",
- /*  89 */ "db_optr ::= db_optr replica",
- /*  90 */ "db_optr ::= db_optr quorum",
- /*  91 */ "db_optr ::= db_optr days",
- /*  92 */ "db_optr ::= db_optr minrows",
- /*  93 */ "db_optr ::= db_optr maxrows",
- /*  94 */ "db_optr ::= db_optr blocks",
- /*  95 */ "db_optr ::= db_optr ctime",
- /*  96 */ "db_optr ::= db_optr wal",
- /*  97 */ "db_optr ::= db_optr fsync",
- /*  98 */ "db_optr ::= db_optr comp",
- /*  99 */ "db_optr ::= db_optr prec",
- /* 100 */ "db_optr ::= db_optr keep",
- /* 101 */ "db_optr ::= db_optr update",
- /* 102 */ "db_optr ::= db_optr cachelast",
- /* 103 */ "alter_db_optr ::=",
- /* 104 */ "alter_db_optr ::= alter_db_optr replica",
- /* 105 */ "alter_db_optr ::= alter_db_optr quorum",
- /* 106 */ "alter_db_optr ::= alter_db_optr keep",
- /* 107 */ "alter_db_optr ::= alter_db_optr blocks",
- /* 108 */ "alter_db_optr ::= alter_db_optr comp",
- /* 109 */ "alter_db_optr ::= alter_db_optr wal",
- /* 110 */ "alter_db_optr ::= alter_db_optr fsync",
- /* 111 */ "alter_db_optr ::= alter_db_optr update",
- /* 112 */ "alter_db_optr ::= alter_db_optr cachelast",
- /* 113 */ "typename ::= ids",
- /* 114 */ "typename ::= ids LP signed RP",
- /* 115 */ "typename ::= ids UNSIGNED",
- /* 116 */ "signed ::= INTEGER",
- /* 117 */ "signed ::= PLUS INTEGER",
- /* 118 */ "signed ::= MINUS INTEGER",
- /* 119 */ "cmd ::= CREATE TABLE create_table_args",
- /* 120 */ "cmd ::= CREATE TABLE create_table_list",
- /* 121 */ "create_table_list ::= create_from_stable",
- /* 122 */ "create_table_list ::= create_table_list create_from_stable",
- /* 123 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP",
- /* 124 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP",
- /* 125 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP",
- /* 126 */ "create_table_args ::= ifnotexists ids cpxName AS select",
- /* 127 */ "columnlist ::= columnlist COMMA column",
- /* 128 */ "columnlist ::= column",
- /* 129 */ "column ::= ids typename",
- /* 130 */ "tagitemlist ::= tagitemlist COMMA tagitem",
- /* 131 */ "tagitemlist ::= tagitem",
- /* 132 */ "tagitem ::= INTEGER",
- /* 133 */ "tagitem ::= FLOAT",
- /* 134 */ "tagitem ::= STRING",
- /* 135 */ "tagitem ::= BOOL",
- /* 136 */ "tagitem ::= NULL",
- /* 137 */ "tagitem ::= MINUS INTEGER",
- /* 138 */ "tagitem ::= MINUS FLOAT",
- /* 139 */ "tagitem ::= PLUS INTEGER",
- /* 140 */ "tagitem ::= PLUS FLOAT",
- /* 141 */ "select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt",
- /* 142 */ "union ::= select",
- /* 143 */ "union ::= LP union RP",
- /* 144 */ "union ::= union UNION ALL select",
- /* 145 */ "union ::= union UNION ALL LP select RP",
- /* 146 */ "cmd ::= union",
- /* 147 */ "select ::= SELECT selcollist",
- /* 148 */ "sclp ::= selcollist COMMA",
- /* 149 */ "sclp ::=",
- /* 150 */ "selcollist ::= sclp expr as",
- /* 151 */ "selcollist ::= sclp STAR",
- /* 152 */ "as ::= AS ids",
- /* 153 */ "as ::= ids",
- /* 154 */ "as ::=",
- /* 155 */ "from ::= FROM tablelist",
- /* 156 */ "tablelist ::= ids cpxName",
- /* 157 */ "tablelist ::= ids cpxName ids",
- /* 158 */ "tablelist ::= tablelist COMMA ids cpxName",
- /* 159 */ "tablelist ::= tablelist COMMA ids cpxName ids",
- /* 160 */ "tmvar ::= VARIABLE",
- /* 161 */ "interval_opt ::= INTERVAL LP tmvar RP",
- /* 162 */ "interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP",
- /* 163 */ "interval_opt ::=",
- /* 164 */ "fill_opt ::=",
- /* 165 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
- /* 166 */ "fill_opt ::= FILL LP ID RP",
- /* 167 */ "sliding_opt ::= SLIDING LP tmvar RP",
- /* 168 */ "sliding_opt ::=",
- /* 169 */ "orderby_opt ::=",
- /* 170 */ "orderby_opt ::= ORDER BY sortlist",
- /* 171 */ "sortlist ::= sortlist COMMA item sortorder",
- /* 172 */ "sortlist ::= item sortorder",
- /* 173 */ "item ::= ids cpxName",
- /* 174 */ "sortorder ::= ASC",
- /* 175 */ "sortorder ::= DESC",
- /* 176 */ "sortorder ::=",
- /* 177 */ "groupby_opt ::=",
- /* 178 */ "groupby_opt ::= GROUP BY grouplist",
- /* 179 */ "grouplist ::= grouplist COMMA item",
- /* 180 */ "grouplist ::= item",
- /* 181 */ "having_opt ::=",
- /* 182 */ "having_opt ::= HAVING expr",
- /* 183 */ "limit_opt ::=",
- /* 184 */ "limit_opt ::= LIMIT signed",
- /* 185 */ "limit_opt ::= LIMIT signed OFFSET signed",
- /* 186 */ "limit_opt ::= LIMIT signed COMMA signed",
- /* 187 */ "slimit_opt ::=",
- /* 188 */ "slimit_opt ::= SLIMIT signed",
- /* 189 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
- /* 190 */ "slimit_opt ::= SLIMIT signed COMMA signed",
- /* 191 */ "where_opt ::=",
- /* 192 */ "where_opt ::= WHERE expr",
- /* 193 */ "expr ::= LP expr RP",
- /* 194 */ "expr ::= ID",
- /* 195 */ "expr ::= ID DOT ID",
- /* 196 */ "expr ::= ID DOT STAR",
- /* 197 */ "expr ::= INTEGER",
- /* 198 */ "expr ::= MINUS INTEGER",
- /* 199 */ "expr ::= PLUS INTEGER",
- /* 200 */ "expr ::= FLOAT",
- /* 201 */ "expr ::= MINUS FLOAT",
- /* 202 */ "expr ::= PLUS FLOAT",
- /* 203 */ "expr ::= STRING",
- /* 204 */ "expr ::= NOW",
- /* 205 */ "expr ::= VARIABLE",
- /* 206 */ "expr ::= BOOL",
- /* 207 */ "expr ::= ID LP exprlist RP",
- /* 208 */ "expr ::= ID LP STAR RP",
- /* 209 */ "expr ::= expr IS NULL",
- /* 210 */ "expr ::= expr IS NOT NULL",
- /* 211 */ "expr ::= expr LT expr",
- /* 212 */ "expr ::= expr GT expr",
- /* 213 */ "expr ::= expr LE expr",
- /* 214 */ "expr ::= expr GE expr",
- /* 215 */ "expr ::= expr NE expr",
- /* 216 */ "expr ::= expr EQ expr",
- /* 217 */ "expr ::= expr AND expr",
- /* 218 */ "expr ::= expr OR expr",
- /* 219 */ "expr ::= expr PLUS expr",
- /* 220 */ "expr ::= expr MINUS expr",
- /* 221 */ "expr ::= expr STAR expr",
- /* 222 */ "expr ::= expr SLASH expr",
- /* 223 */ "expr ::= expr REM expr",
- /* 224 */ "expr ::= expr LIKE expr",
- /* 225 */ "expr ::= expr IN LP exprlist RP",
- /* 226 */ "exprlist ::= exprlist COMMA expritem",
- /* 227 */ "exprlist ::= expritem",
- /* 228 */ "expritem ::= expr",
- /* 229 */ "expritem ::=",
- /* 230 */ "cmd ::= RESET QUERY CACHE",
- /* 231 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
- /* 232 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
- /* 233 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
- /* 234 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
- /* 235 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
- /* 236 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
- /* 237 */ "cmd ::= KILL CONNECTION INTEGER",
- /* 238 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
- /* 239 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
+ /*  28 */ "cmd ::= DROP STABLE ifexists ids cpxName",
+ /*  29 */ "cmd ::= DROP DATABASE ifexists ids",
+ /*  30 */ "cmd ::= DROP DNODE ids",
+ /*  31 */ "cmd ::= DROP USER ids",
+ /*  32 */ "cmd ::= DROP ACCOUNT ids",
+ /*  33 */ "cmd ::= USE ids",
+ /*  34 */ "cmd ::= DESCRIBE ids cpxName",
+ /*  35 */ "cmd ::= ALTER USER ids PASS ids",
+ /*  36 */ "cmd ::= ALTER USER ids PRIVILEGE ids",
+ /*  37 */ "cmd ::= ALTER DNODE ids ids",
+ /*  38 */ "cmd ::= ALTER DNODE ids ids ids",
+ /*  39 */ "cmd ::= ALTER LOCAL ids",
+ /*  40 */ "cmd ::= ALTER LOCAL ids ids",
+ /*  41 */ "cmd ::= ALTER DATABASE ids alter_db_optr",
+ /*  42 */ "cmd ::= ALTER ACCOUNT ids acct_optr",
+ /*  43 */ "cmd ::= ALTER ACCOUNT ids PASS ids acct_optr",
+ /*  44 */ "ids ::= ID",
+ /*  45 */ "ids ::= STRING",
+ /*  46 */ "ifexists ::= IF EXISTS",
+ /*  47 */ "ifexists ::=",
+ /*  48 */ "ifnotexists ::= IF NOT EXISTS",
+ /*  49 */ "ifnotexists ::=",
+ /*  50 */ "cmd ::= CREATE DNODE ids",
+ /*  51 */ "cmd ::= CREATE ACCOUNT ids PASS ids acct_optr",
+ /*  52 */ "cmd ::= CREATE DATABASE ifnotexists ids db_optr",
+ /*  53 */ "cmd ::= CREATE USER ids PASS ids",
+ /*  54 */ "pps ::=",
+ /*  55 */ "pps ::= PPS INTEGER",
+ /*  56 */ "tseries ::=",
+ /*  57 */ "tseries ::= TSERIES INTEGER",
+ /*  58 */ "dbs ::=",
+ /*  59 */ "dbs ::= DBS INTEGER",
+ /*  60 */ "streams ::=",
+ /*  61 */ "streams ::= STREAMS INTEGER",
+ /*  62 */ "storage ::=",
+ /*  63 */ "storage ::= STORAGE INTEGER",
+ /*  64 */ "qtime ::=",
+ /*  65 */ "qtime ::= QTIME INTEGER",
+ /*  66 */ "users ::=",
+ /*  67 */ "users ::= USERS INTEGER",
+ /*  68 */ "conns ::=",
+ /*  69 */ "conns ::= CONNS INTEGER",
+ /*  70 */ "state ::=",
+ /*  71 */ "state ::= STATE ids",
+ /*  72 */ "acct_optr ::= pps tseries storage streams qtime dbs users conns state",
+ /*  73 */ "keep ::= KEEP tagitemlist",
+ /*  74 */ "cache ::= CACHE INTEGER",
+ /*  75 */ "replica ::= REPLICA INTEGER",
+ /*  76 */ "quorum ::= QUORUM INTEGER",
+ /*  77 */ "days ::= DAYS INTEGER",
+ /*  78 */ "minrows ::= MINROWS INTEGER",
+ /*  79 */ "maxrows ::= MAXROWS INTEGER",
+ /*  80 */ "blocks ::= BLOCKS INTEGER",
+ /*  81 */ "ctime ::= CTIME INTEGER",
+ /*  82 */ "wal ::= WAL INTEGER",
+ /*  83 */ "fsync ::= FSYNC INTEGER",
+ /*  84 */ "comp ::= COMP INTEGER",
+ /*  85 */ "prec ::= PRECISION STRING",
+ /*  86 */ "update ::= UPDATE INTEGER",
+ /*  87 */ "cachelast ::= CACHELAST INTEGER",
+ /*  88 */ "db_optr ::=",
+ /*  89 */ "db_optr ::= db_optr cache",
+ /*  90 */ "db_optr ::= db_optr replica",
+ /*  91 */ "db_optr ::= db_optr quorum",
+ /*  92 */ "db_optr ::= db_optr days",
+ /*  93 */ "db_optr ::= db_optr minrows",
+ /*  94 */ "db_optr ::= db_optr maxrows",
+ /*  95 */ "db_optr ::= db_optr blocks",
+ /*  96 */ "db_optr ::= db_optr ctime",
+ /*  97 */ "db_optr ::= db_optr wal",
+ /*  98 */ "db_optr ::= db_optr fsync",
+ /*  99 */ "db_optr ::= db_optr comp",
+ /* 100 */ "db_optr ::= db_optr prec",
+ /* 101 */ "db_optr ::= db_optr keep",
+ /* 102 */ "db_optr ::= db_optr update",
+ /* 103 */ "db_optr ::= db_optr cachelast",
+ /* 104 */ "alter_db_optr ::=",
+ /* 105 */ "alter_db_optr ::= alter_db_optr replica",
+ /* 106 */ "alter_db_optr ::= alter_db_optr quorum",
+ /* 107 */ "alter_db_optr ::= alter_db_optr keep",
+ /* 108 */ "alter_db_optr ::= alter_db_optr blocks",
+ /* 109 */ "alter_db_optr ::= alter_db_optr comp",
+ /* 110 */ "alter_db_optr ::= alter_db_optr wal",
+ /* 111 */ "alter_db_optr ::= alter_db_optr fsync",
+ /* 112 */ "alter_db_optr ::= alter_db_optr update",
+ /* 113 */ "alter_db_optr ::= alter_db_optr cachelast",
+ /* 114 */ "typename ::= ids",
+ /* 115 */ "typename ::= ids LP signed RP",
+ /* 116 */ "typename ::= ids UNSIGNED",
+ /* 117 */ "signed ::= INTEGER",
+ /* 118 */ "signed ::= PLUS INTEGER",
+ /* 119 */ "signed ::= MINUS INTEGER",
+ /* 120 */ "cmd ::= CREATE TABLE create_table_args",
+ /* 121 */ "cmd ::= CREATE TABLE create_stable_args",
+ /* 122 */ "cmd ::= CREATE STABLE create_stable_args",
+ /* 123 */ "cmd ::= CREATE TABLE create_table_list",
+ /* 124 */ "create_table_list ::= create_from_stable",
+ /* 125 */ "create_table_list ::= create_table_list create_from_stable",
+ /* 126 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP",
+ /* 127 */ "create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP",
+ /* 128 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP",
+ /* 129 */ "create_table_args ::= ifnotexists ids cpxName AS select",
+ /* 130 */ "columnlist ::= columnlist COMMA column",
+ /* 131 */ "columnlist ::= column",
+ /* 132 */ "column ::= ids typename",
+ /* 133 */ "tagitemlist ::= tagitemlist COMMA tagitem",
+ /* 134 */ "tagitemlist ::= tagitem",
+ /* 135 */ "tagitem ::= INTEGER",
+ /* 136 */ "tagitem ::= FLOAT",
+ /* 137 */ "tagitem ::= STRING",
+ /* 138 */ "tagitem ::= BOOL",
+ /* 139 */ "tagitem ::= NULL",
+ /* 140 */ "tagitem ::= MINUS INTEGER",
+ /* 141 */ "tagitem ::= MINUS FLOAT",
+ /* 142 */ "tagitem ::= PLUS INTEGER",
+ /* 143 */ "tagitem ::= PLUS FLOAT",
+ /* 144 */ "select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt",
+ /* 145 */ "union ::= select",
+ /* 146 */ "union ::= LP union RP",
+ /* 147 */ "union ::= union UNION ALL select",
+ /* 148 */ "union ::= union UNION ALL LP select RP",
+ /* 149 */ "cmd ::= union",
+ /* 150 */ "select ::= SELECT selcollist",
+ /* 151 */ "sclp ::= selcollist COMMA",
+ /* 152 */ "sclp ::=",
+ /* 153 */ "selcollist ::= sclp expr as",
+ /* 154 */ "selcollist ::= sclp STAR",
+ /* 155 */ "as ::= AS ids",
+ /* 156 */ "as ::= ids",
+ /* 157 */ "as ::=",
+ /* 158 */ "from ::= FROM tablelist",
+ /* 159 */ "tablelist ::= ids cpxName",
+ /* 160 */ "tablelist ::= ids cpxName ids",
+ /* 161 */ "tablelist ::= tablelist COMMA ids cpxName",
+ /* 162 */ "tablelist ::= tablelist COMMA ids cpxName ids",
+ /* 163 */ "tmvar ::= VARIABLE",
+ /* 164 */ "interval_opt ::= INTERVAL LP tmvar RP",
+ /* 165 */ "interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP",
+ /* 166 */ "interval_opt ::=",
+ /* 167 */ "fill_opt ::=",
+ /* 168 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
+ /* 169 */ "fill_opt ::= FILL LP ID RP",
+ /* 170 */ "sliding_opt ::= SLIDING LP tmvar RP",
+ /* 171 */ "sliding_opt ::=",
+ /* 172 */ "orderby_opt ::=",
+ /* 173 */ "orderby_opt ::= ORDER BY sortlist",
+ /* 174 */ "sortlist ::= sortlist COMMA item sortorder",
+ /* 175 */ "sortlist ::= item sortorder",
+ /* 176 */ "item ::= ids cpxName",
+ /* 177 */ "sortorder ::= ASC",
+ /* 178 */ "sortorder ::= DESC",
+ /* 179 */ "sortorder ::=",
+ /* 180 */ "groupby_opt ::=",
+ /* 181 */ "groupby_opt ::= GROUP BY grouplist",
+ /* 182 */ "grouplist ::= grouplist COMMA item",
+ /* 183 */ "grouplist ::= item",
+ /* 184 */ "having_opt ::=",
+ /* 185 */ "having_opt ::= HAVING expr",
+ /* 186 */ "limit_opt ::=",
+ /* 187 */ "limit_opt ::= LIMIT signed",
+ /* 188 */ "limit_opt ::= LIMIT signed OFFSET signed",
+ /* 189 */ "limit_opt ::= LIMIT signed COMMA signed",
+ /* 190 */ "slimit_opt ::=",
+ /* 191 */ "slimit_opt ::= SLIMIT signed",
+ /* 192 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
+ /* 193 */ "slimit_opt ::= SLIMIT signed COMMA signed",
+ /* 194 */ "where_opt ::=",
+ /* 195 */ "where_opt ::= WHERE expr",
+ /* 196 */ "expr ::= LP expr RP",
+ /* 197 */ "expr ::= ID",
+ /* 198 */ "expr ::= ID DOT ID",
+ /* 199 */ "expr ::= ID DOT STAR",
+ /* 200 */ "expr ::= INTEGER",
+ /* 201 */ "expr ::= MINUS INTEGER",
+ /* 202 */ "expr ::= PLUS INTEGER",
+ /* 203 */ "expr ::= FLOAT",
+ /* 204 */ "expr ::= MINUS FLOAT",
+ /* 205 */ "expr ::= PLUS FLOAT",
+ /* 206 */ "expr ::= STRING",
+ /* 207 */ "expr ::= NOW",
+ /* 208 */ "expr ::= VARIABLE",
+ /* 209 */ "expr ::= BOOL",
+ /* 210 */ "expr ::= ID LP exprlist RP",
+ /* 211 */ "expr ::= ID LP STAR RP",
+ /* 212 */ "expr ::= expr IS NULL",
+ /* 213 */ "expr ::= expr IS NOT NULL",
+ /* 214 */ "expr ::= expr LT expr",
+ /* 215 */ "expr ::= expr GT expr",
+ /* 216 */ "expr ::= expr LE expr",
+ /* 217 */ "expr ::= expr GE expr",
+ /* 218 */ "expr ::= expr NE expr",
+ /* 219 */ "expr ::= expr EQ expr",
+ /* 220 */ "expr ::= expr AND expr",
+ /* 221 */ "expr ::= expr OR expr",
+ /* 222 */ "expr ::= expr PLUS expr",
+ /* 223 */ "expr ::= expr MINUS expr",
+ /* 224 */ "expr ::= expr STAR expr",
+ /* 225 */ "expr ::= expr SLASH expr",
+ /* 226 */ "expr ::= expr REM expr",
+ /* 227 */ "expr ::= expr LIKE expr",
+ /* 228 */ "expr ::= expr IN LP exprlist RP",
+ /* 229 */ "exprlist ::= exprlist COMMA expritem",
+ /* 230 */ "exprlist ::= expritem",
+ /* 231 */ "expritem ::= expr",
+ /* 232 */ "expritem ::=",
+ /* 233 */ "cmd ::= RESET QUERY CACHE",
+ /* 234 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
+ /* 235 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
+ /* 236 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
+ /* 237 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
+ /* 238 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
+ /* 239 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
+ /* 240 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist",
+ /* 241 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids",
+ /* 242 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist",
+ /* 243 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids",
+ /* 244 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids",
+ /* 245 */ "cmd ::= KILL CONNECTION INTEGER",
+ /* 246 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
+ /* 247 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
 };
 #endif /* NDEBUG */
 
@@ -1386,49 +1410,49 @@ static void yy_destructor(
 /********* Begin destructor definitions ***************************************/
     case 229: /* keep */
     case 230: /* tagitemlist */
-    case 250: /* columnlist */
-    case 258: /* fill_opt */
-    case 260: /* groupby_opt */
-    case 261: /* orderby_opt */
-    case 271: /* sortlist */
-    case 275: /* grouplist */
+    case 251: /* columnlist */
+    case 259: /* fill_opt */
+    case 261: /* groupby_opt */
+    case 262: /* orderby_opt */
+    case 272: /* sortlist */
+    case 276: /* grouplist */
 {
-taosArrayDestroy((yypminor->yy421));
+taosArrayDestroy((yypminor->yy135));
 }
       break;
-    case 248: /* create_table_list */
+    case 249: /* create_table_list */
 {
 destroyCreateTableSql((yypminor->yy38));
 }
       break;
-    case 251: /* select */
+    case 252: /* select */
 {
-doDestroyQuerySql((yypminor->yy148));
+doDestroyQuerySql((yypminor->yy30));
 }
       break;
-    case 254: /* selcollist */
-    case 266: /* sclp */
-    case 276: /* exprlist */
+    case 255: /* selcollist */
+    case 267: /* sclp */
+    case 277: /* exprlist */
 {
-tSqlExprListDestroy((yypminor->yy166));
+tSqlExprListDestroy((yypminor->yy266));
 }
       break;
-    case 256: /* where_opt */
-    case 262: /* having_opt */
-    case 267: /* expr */
-    case 277: /* expritem */
+    case 257: /* where_opt */
+    case 263: /* having_opt */
+    case 268: /* expr */
+    case 278: /* expritem */
 {
-tSqlExprDestroy((yypminor->yy78));
+tSqlExprDestroy((yypminor->yy316));
 }
       break;
-    case 265: /* union */
+    case 266: /* union */
 {
 destroyAllSelectClause((yypminor->yy153));
 }
       break;
-    case 272: /* sortitem */
+    case 273: /* sortitem */
 {
-tVariantDestroy(&(yypminor->yy430));
+tVariantDestroy(&(yypminor->yy308));
 }
       break;
 /********* End destructor definitions *****************************************/
@@ -1750,218 +1774,226 @@ static const struct {
   {  211,   -3 }, /* (25) cmd ::= SHOW dbPrefix VGROUPS */
   {  211,   -4 }, /* (26) cmd ::= SHOW dbPrefix VGROUPS ids */
   {  211,   -5 }, /* (27) cmd ::= DROP TABLE ifexists ids cpxName */
-  {  211,   -4 }, /* (28) cmd ::= DROP DATABASE ifexists ids */
-  {  211,   -3 }, /* (29) cmd ::= DROP DNODE ids */
-  {  211,   -3 }, /* (30) cmd ::= DROP USER ids */
-  {  211,   -3 }, /* (31) cmd ::= DROP ACCOUNT ids */
-  {  211,   -2 }, /* (32) cmd ::= USE ids */
-  {  211,   -3 }, /* (33) cmd ::= DESCRIBE ids cpxName */
-  {  211,   -5 }, /* (34) cmd ::= ALTER USER ids PASS ids */
-  {  211,   -5 }, /* (35) cmd ::= ALTER USER ids PRIVILEGE ids */
-  {  211,   -4 }, /* (36) cmd ::= ALTER DNODE ids ids */
-  {  211,   -5 }, /* (37) cmd ::= ALTER DNODE ids ids ids */
-  {  211,   -3 }, /* (38) cmd ::= ALTER LOCAL ids */
-  {  211,   -4 }, /* (39) cmd ::= ALTER LOCAL ids ids */
-  {  211,   -4 }, /* (40) cmd ::= ALTER DATABASE ids alter_db_optr */
-  {  211,   -4 }, /* (41) cmd ::= ALTER ACCOUNT ids acct_optr */
-  {  211,   -6 }, /* (42) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
-  {  213,   -1 }, /* (43) ids ::= ID */
-  {  213,   -1 }, /* (44) ids ::= STRING */
-  {  215,   -2 }, /* (45) ifexists ::= IF EXISTS */
-  {  215,    0 }, /* (46) ifexists ::= */
-  {  218,   -3 }, /* (47) ifnotexists ::= IF NOT EXISTS */
-  {  218,    0 }, /* (48) ifnotexists ::= */
-  {  211,   -3 }, /* (49) cmd ::= CREATE DNODE ids */
-  {  211,   -6 }, /* (50) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
-  {  211,   -5 }, /* (51) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
-  {  211,   -5 }, /* (52) cmd ::= CREATE USER ids PASS ids */
-  {  220,    0 }, /* (53) pps ::= */
-  {  220,   -2 }, /* (54) pps ::= PPS INTEGER */
-  {  221,    0 }, /* (55) tseries ::= */
-  {  221,   -2 }, /* (56) tseries ::= TSERIES INTEGER */
-  {  222,    0 }, /* (57) dbs ::= */
-  {  222,   -2 }, /* (58) dbs ::= DBS INTEGER */
-  {  223,    0 }, /* (59) streams ::= */
-  {  223,   -2 }, /* (60) streams ::= STREAMS INTEGER */
-  {  224,    0 }, /* (61) storage ::= */
-  {  224,   -2 }, /* (62) storage ::= STORAGE INTEGER */
-  {  225,    0 }, /* (63) qtime ::= */
-  {  225,   -2 }, /* (64) qtime ::= QTIME INTEGER */
-  {  226,    0 }, /* (65) users ::= */
-  {  226,   -2 }, /* (66) users ::= USERS INTEGER */
-  {  227,    0 }, /* (67) conns ::= */
-  {  227,   -2 }, /* (68) conns ::= CONNS INTEGER */
-  {  228,    0 }, /* (69) state ::= */
-  {  228,   -2 }, /* (70) state ::= STATE ids */
-  {  217,   -9 }, /* (71) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
-  {  229,   -2 }, /* (72) keep ::= KEEP tagitemlist */
-  {  231,   -2 }, /* (73) cache ::= CACHE INTEGER */
-  {  232,   -2 }, /* (74) replica ::= REPLICA INTEGER */
-  {  233,   -2 }, /* (75) quorum ::= QUORUM INTEGER */
-  {  234,   -2 }, /* (76) days ::= DAYS INTEGER */
-  {  235,   -2 }, /* (77) minrows ::= MINROWS INTEGER */
-  {  236,   -2 }, /* (78) maxrows ::= MAXROWS INTEGER */
-  {  237,   -2 }, /* (79) blocks ::= BLOCKS INTEGER */
-  {  238,   -2 }, /* (80) ctime ::= CTIME INTEGER */
-  {  239,   -2 }, /* (81) wal ::= WAL INTEGER */
-  {  240,   -2 }, /* (82) fsync ::= FSYNC INTEGER */
-  {  241,   -2 }, /* (83) comp ::= COMP INTEGER */
-  {  242,   -2 }, /* (84) prec ::= PRECISION STRING */
-  {  243,   -2 }, /* (85) update ::= UPDATE INTEGER */
-  {  244,   -2 }, /* (86) cachelast ::= CACHELAST INTEGER */
-  {  219,    0 }, /* (87) db_optr ::= */
-  {  219,   -2 }, /* (88) db_optr ::= db_optr cache */
-  {  219,   -2 }, /* (89) db_optr ::= db_optr replica */
-  {  219,   -2 }, /* (90) db_optr ::= db_optr quorum */
-  {  219,   -2 }, /* (91) db_optr ::= db_optr days */
-  {  219,   -2 }, /* (92) db_optr ::= db_optr minrows */
-  {  219,   -2 }, /* (93) db_optr ::= db_optr maxrows */
-  {  219,   -2 }, /* (94) db_optr ::= db_optr blocks */
-  {  219,   -2 }, /* (95) db_optr ::= db_optr ctime */
-  {  219,   -2 }, /* (96) db_optr ::= db_optr wal */
-  {  219,   -2 }, /* (97) db_optr ::= db_optr fsync */
-  {  219,   -2 }, /* (98) db_optr ::= db_optr comp */
-  {  219,   -2 }, /* (99) db_optr ::= db_optr prec */
-  {  219,   -2 }, /* (100) db_optr ::= db_optr keep */
-  {  219,   -2 }, /* (101) db_optr ::= db_optr update */
-  {  219,   -2 }, /* (102) db_optr ::= db_optr cachelast */
-  {  216,    0 }, /* (103) alter_db_optr ::= */
-  {  216,   -2 }, /* (104) alter_db_optr ::= alter_db_optr replica */
-  {  216,   -2 }, /* (105) alter_db_optr ::= alter_db_optr quorum */
-  {  216,   -2 }, /* (106) alter_db_optr ::= alter_db_optr keep */
-  {  216,   -2 }, /* (107) alter_db_optr ::= alter_db_optr blocks */
-  {  216,   -2 }, /* (108) alter_db_optr ::= alter_db_optr comp */
-  {  216,   -2 }, /* (109) alter_db_optr ::= alter_db_optr wal */
-  {  216,   -2 }, /* (110) alter_db_optr ::= alter_db_optr fsync */
-  {  216,   -2 }, /* (111) alter_db_optr ::= alter_db_optr update */
-  {  216,   -2 }, /* (112) alter_db_optr ::= alter_db_optr cachelast */
-  {  245,   -1 }, /* (113) typename ::= ids */
-  {  245,   -4 }, /* (114) typename ::= ids LP signed RP */
-  {  245,   -2 }, /* (115) typename ::= ids UNSIGNED */
-  {  246,   -1 }, /* (116) signed ::= INTEGER */
-  {  246,   -2 }, /* (117) signed ::= PLUS INTEGER */
-  {  246,   -2 }, /* (118) signed ::= MINUS INTEGER */
-  {  211,   -3 }, /* (119) cmd ::= CREATE TABLE create_table_args */
-  {  211,   -3 }, /* (120) cmd ::= CREATE TABLE create_table_list */
-  {  248,   -1 }, /* (121) create_table_list ::= create_from_stable */
-  {  248,   -2 }, /* (122) create_table_list ::= create_table_list create_from_stable */
-  {  247,   -6 }, /* (123) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
-  {  247,  -10 }, /* (124) create_table_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
-  {  249,  -10 }, /* (125) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
-  {  247,   -5 }, /* (126) create_table_args ::= ifnotexists ids cpxName AS select */
-  {  250,   -3 }, /* (127) columnlist ::= columnlist COMMA column */
-  {  250,   -1 }, /* (128) columnlist ::= column */
-  {  252,   -2 }, /* (129) column ::= ids typename */
-  {  230,   -3 }, /* (130) tagitemlist ::= tagitemlist COMMA tagitem */
-  {  230,   -1 }, /* (131) tagitemlist ::= tagitem */
-  {  253,   -1 }, /* (132) tagitem ::= INTEGER */
-  {  253,   -1 }, /* (133) tagitem ::= FLOAT */
-  {  253,   -1 }, /* (134) tagitem ::= STRING */
-  {  253,   -1 }, /* (135) tagitem ::= BOOL */
-  {  253,   -1 }, /* (136) tagitem ::= NULL */
-  {  253,   -2 }, /* (137) tagitem ::= MINUS INTEGER */
-  {  253,   -2 }, /* (138) tagitem ::= MINUS FLOAT */
-  {  253,   -2 }, /* (139) tagitem ::= PLUS INTEGER */
-  {  253,   -2 }, /* (140) tagitem ::= PLUS FLOAT */
-  {  251,  -12 }, /* (141) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
-  {  265,   -1 }, /* (142) union ::= select */
-  {  265,   -3 }, /* (143) union ::= LP union RP */
-  {  265,   -4 }, /* (144) union ::= union UNION ALL select */
-  {  265,   -6 }, /* (145) union ::= union UNION ALL LP select RP */
-  {  211,   -1 }, /* (146) cmd ::= union */
-  {  251,   -2 }, /* (147) select ::= SELECT selcollist */
-  {  266,   -2 }, /* (148) sclp ::= selcollist COMMA */
-  {  266,    0 }, /* (149) sclp ::= */
-  {  254,   -3 }, /* (150) selcollist ::= sclp expr as */
-  {  254,   -2 }, /* (151) selcollist ::= sclp STAR */
-  {  268,   -2 }, /* (152) as ::= AS ids */
-  {  268,   -1 }, /* (153) as ::= ids */
-  {  268,    0 }, /* (154) as ::= */
-  {  255,   -2 }, /* (155) from ::= FROM tablelist */
-  {  269,   -2 }, /* (156) tablelist ::= ids cpxName */
-  {  269,   -3 }, /* (157) tablelist ::= ids cpxName ids */
-  {  269,   -4 }, /* (158) tablelist ::= tablelist COMMA ids cpxName */
-  {  269,   -5 }, /* (159) tablelist ::= tablelist COMMA ids cpxName ids */
-  {  270,   -1 }, /* (160) tmvar ::= VARIABLE */
-  {  257,   -4 }, /* (161) interval_opt ::= INTERVAL LP tmvar RP */
-  {  257,   -6 }, /* (162) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
-  {  257,    0 }, /* (163) interval_opt ::= */
-  {  258,    0 }, /* (164) fill_opt ::= */
-  {  258,   -6 }, /* (165) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
-  {  258,   -4 }, /* (166) fill_opt ::= FILL LP ID RP */
-  {  259,   -4 }, /* (167) sliding_opt ::= SLIDING LP tmvar RP */
-  {  259,    0 }, /* (168) sliding_opt ::= */
-  {  261,    0 }, /* (169) orderby_opt ::= */
-  {  261,   -3 }, /* (170) orderby_opt ::= ORDER BY sortlist */
-  {  271,   -4 }, /* (171) sortlist ::= sortlist COMMA item sortorder */
-  {  271,   -2 }, /* (172) sortlist ::= item sortorder */
-  {  273,   -2 }, /* (173) item ::= ids cpxName */
-  {  274,   -1 }, /* (174) sortorder ::= ASC */
-  {  274,   -1 }, /* (175) sortorder ::= DESC */
-  {  274,    0 }, /* (176) sortorder ::= */
-  {  260,    0 }, /* (177) groupby_opt ::= */
-  {  260,   -3 }, /* (178) groupby_opt ::= GROUP BY grouplist */
-  {  275,   -3 }, /* (179) grouplist ::= grouplist COMMA item */
-  {  275,   -1 }, /* (180) grouplist ::= item */
-  {  262,    0 }, /* (181) having_opt ::= */
-  {  262,   -2 }, /* (182) having_opt ::= HAVING expr */
-  {  264,    0 }, /* (183) limit_opt ::= */
-  {  264,   -2 }, /* (184) limit_opt ::= LIMIT signed */
-  {  264,   -4 }, /* (185) limit_opt ::= LIMIT signed OFFSET signed */
-  {  264,   -4 }, /* (186) limit_opt ::= LIMIT signed COMMA signed */
-  {  263,    0 }, /* (187) slimit_opt ::= */
-  {  263,   -2 }, /* (188) slimit_opt ::= SLIMIT signed */
-  {  263,   -4 }, /* (189) slimit_opt ::= SLIMIT signed SOFFSET signed */
-  {  263,   -4 }, /* (190) slimit_opt ::= SLIMIT signed COMMA signed */
-  {  256,    0 }, /* (191) where_opt ::= */
-  {  256,   -2 }, /* (192) where_opt ::= WHERE expr */
-  {  267,   -3 }, /* (193) expr ::= LP expr RP */
-  {  267,   -1 }, /* (194) expr ::= ID */
-  {  267,   -3 }, /* (195) expr ::= ID DOT ID */
-  {  267,   -3 }, /* (196) expr ::= ID DOT STAR */
-  {  267,   -1 }, /* (197) expr ::= INTEGER */
-  {  267,   -2 }, /* (198) expr ::= MINUS INTEGER */
-  {  267,   -2 }, /* (199) expr ::= PLUS INTEGER */
-  {  267,   -1 }, /* (200) expr ::= FLOAT */
-  {  267,   -2 }, /* (201) expr ::= MINUS FLOAT */
-  {  267,   -2 }, /* (202) expr ::= PLUS FLOAT */
-  {  267,   -1 }, /* (203) expr ::= STRING */
-  {  267,   -1 }, /* (204) expr ::= NOW */
-  {  267,   -1 }, /* (205) expr ::= VARIABLE */
-  {  267,   -1 }, /* (206) expr ::= BOOL */
-  {  267,   -4 }, /* (207) expr ::= ID LP exprlist RP */
-  {  267,   -4 }, /* (208) expr ::= ID LP STAR RP */
-  {  267,   -3 }, /* (209) expr ::= expr IS NULL */
-  {  267,   -4 }, /* (210) expr ::= expr IS NOT NULL */
-  {  267,   -3 }, /* (211) expr ::= expr LT expr */
-  {  267,   -3 }, /* (212) expr ::= expr GT expr */
-  {  267,   -3 }, /* (213) expr ::= expr LE expr */
-  {  267,   -3 }, /* (214) expr ::= expr GE expr */
-  {  267,   -3 }, /* (215) expr ::= expr NE expr */
-  {  267,   -3 }, /* (216) expr ::= expr EQ expr */
-  {  267,   -3 }, /* (217) expr ::= expr AND expr */
-  {  267,   -3 }, /* (218) expr ::= expr OR expr */
-  {  267,   -3 }, /* (219) expr ::= expr PLUS expr */
-  {  267,   -3 }, /* (220) expr ::= expr MINUS expr */
-  {  267,   -3 }, /* (221) expr ::= expr STAR expr */
-  {  267,   -3 }, /* (222) expr ::= expr SLASH expr */
-  {  267,   -3 }, /* (223) expr ::= expr REM expr */
-  {  267,   -3 }, /* (224) expr ::= expr LIKE expr */
-  {  267,   -5 }, /* (225) expr ::= expr IN LP exprlist RP */
-  {  276,   -3 }, /* (226) exprlist ::= exprlist COMMA expritem */
-  {  276,   -1 }, /* (227) exprlist ::= expritem */
-  {  277,   -1 }, /* (228) expritem ::= expr */
-  {  277,    0 }, /* (229) expritem ::= */
-  {  211,   -3 }, /* (230) cmd ::= RESET QUERY CACHE */
-  {  211,   -7 }, /* (231) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
-  {  211,   -7 }, /* (232) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
-  {  211,   -7 }, /* (233) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
-  {  211,   -7 }, /* (234) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
-  {  211,   -8 }, /* (235) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
-  {  211,   -9 }, /* (236) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
-  {  211,   -3 }, /* (237) cmd ::= KILL CONNECTION INTEGER */
-  {  211,   -5 }, /* (238) cmd ::= KILL STREAM INTEGER COLON INTEGER */
-  {  211,   -5 }, /* (239) cmd ::= KILL QUERY INTEGER COLON INTEGER */
+  {  211,   -5 }, /* (28) cmd ::= DROP STABLE ifexists ids cpxName */
+  {  211,   -4 }, /* (29) cmd ::= DROP DATABASE ifexists ids */
+  {  211,   -3 }, /* (30) cmd ::= DROP DNODE ids */
+  {  211,   -3 }, /* (31) cmd ::= DROP USER ids */
+  {  211,   -3 }, /* (32) cmd ::= DROP ACCOUNT ids */
+  {  211,   -2 }, /* (33) cmd ::= USE ids */
+  {  211,   -3 }, /* (34) cmd ::= DESCRIBE ids cpxName */
+  {  211,   -5 }, /* (35) cmd ::= ALTER USER ids PASS ids */
+  {  211,   -5 }, /* (36) cmd ::= ALTER USER ids PRIVILEGE ids */
+  {  211,   -4 }, /* (37) cmd ::= ALTER DNODE ids ids */
+  {  211,   -5 }, /* (38) cmd ::= ALTER DNODE ids ids ids */
+  {  211,   -3 }, /* (39) cmd ::= ALTER LOCAL ids */
+  {  211,   -4 }, /* (40) cmd ::= ALTER LOCAL ids ids */
+  {  211,   -4 }, /* (41) cmd ::= ALTER DATABASE ids alter_db_optr */
+  {  211,   -4 }, /* (42) cmd ::= ALTER ACCOUNT ids acct_optr */
+  {  211,   -6 }, /* (43) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
+  {  213,   -1 }, /* (44) ids ::= ID */
+  {  213,   -1 }, /* (45) ids ::= STRING */
+  {  215,   -2 }, /* (46) ifexists ::= IF EXISTS */
+  {  215,    0 }, /* (47) ifexists ::= */
+  {  218,   -3 }, /* (48) ifnotexists ::= IF NOT EXISTS */
+  {  218,    0 }, /* (49) ifnotexists ::= */
+  {  211,   -3 }, /* (50) cmd ::= CREATE DNODE ids */
+  {  211,   -6 }, /* (51) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
+  {  211,   -5 }, /* (52) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
+  {  211,   -5 }, /* (53) cmd ::= CREATE USER ids PASS ids */
+  {  220,    0 }, /* (54) pps ::= */
+  {  220,   -2 }, /* (55) pps ::= PPS INTEGER */
+  {  221,    0 }, /* (56) tseries ::= */
+  {  221,   -2 }, /* (57) tseries ::= TSERIES INTEGER */
+  {  222,    0 }, /* (58) dbs ::= */
+  {  222,   -2 }, /* (59) dbs ::= DBS INTEGER */
+  {  223,    0 }, /* (60) streams ::= */
+  {  223,   -2 }, /* (61) streams ::= STREAMS INTEGER */
+  {  224,    0 }, /* (62) storage ::= */
+  {  224,   -2 }, /* (63) storage ::= STORAGE INTEGER */
+  {  225,    0 }, /* (64) qtime ::= */
+  {  225,   -2 }, /* (65) qtime ::= QTIME INTEGER */
+  {  226,    0 }, /* (66) users ::= */
+  {  226,   -2 }, /* (67) users ::= USERS INTEGER */
+  {  227,    0 }, /* (68) conns ::= */
+  {  227,   -2 }, /* (69) conns ::= CONNS INTEGER */
+  {  228,    0 }, /* (70) state ::= */
+  {  228,   -2 }, /* (71) state ::= STATE ids */
+  {  217,   -9 }, /* (72) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
+  {  229,   -2 }, /* (73) keep ::= KEEP tagitemlist */
+  {  231,   -2 }, /* (74) cache ::= CACHE INTEGER */
+  {  232,   -2 }, /* (75) replica ::= REPLICA INTEGER */
+  {  233,   -2 }, /* (76) quorum ::= QUORUM INTEGER */
+  {  234,   -2 }, /* (77) days ::= DAYS INTEGER */
+  {  235,   -2 }, /* (78) minrows ::= MINROWS INTEGER */
+  {  236,   -2 }, /* (79) maxrows ::= MAXROWS INTEGER */
+  {  237,   -2 }, /* (80) blocks ::= BLOCKS INTEGER */
+  {  238,   -2 }, /* (81) ctime ::= CTIME INTEGER */
+  {  239,   -2 }, /* (82) wal ::= WAL INTEGER */
+  {  240,   -2 }, /* (83) fsync ::= FSYNC INTEGER */
+  {  241,   -2 }, /* (84) comp ::= COMP INTEGER */
+  {  242,   -2 }, /* (85) prec ::= PRECISION STRING */
+  {  243,   -2 }, /* (86) update ::= UPDATE INTEGER */
+  {  244,   -2 }, /* (87) cachelast ::= CACHELAST INTEGER */
+  {  219,    0 }, /* (88) db_optr ::= */
+  {  219,   -2 }, /* (89) db_optr ::= db_optr cache */
+  {  219,   -2 }, /* (90) db_optr ::= db_optr replica */
+  {  219,   -2 }, /* (91) db_optr ::= db_optr quorum */
+  {  219,   -2 }, /* (92) db_optr ::= db_optr days */
+  {  219,   -2 }, /* (93) db_optr ::= db_optr minrows */
+  {  219,   -2 }, /* (94) db_optr ::= db_optr maxrows */
+  {  219,   -2 }, /* (95) db_optr ::= db_optr blocks */
+  {  219,   -2 }, /* (96) db_optr ::= db_optr ctime */
+  {  219,   -2 }, /* (97) db_optr ::= db_optr wal */
+  {  219,   -2 }, /* (98) db_optr ::= db_optr fsync */
+  {  219,   -2 }, /* (99) db_optr ::= db_optr comp */
+  {  219,   -2 }, /* (100) db_optr ::= db_optr prec */
+  {  219,   -2 }, /* (101) db_optr ::= db_optr keep */
+  {  219,   -2 }, /* (102) db_optr ::= db_optr update */
+  {  219,   -2 }, /* (103) db_optr ::= db_optr cachelast */
+  {  216,    0 }, /* (104) alter_db_optr ::= */
+  {  216,   -2 }, /* (105) alter_db_optr ::= alter_db_optr replica */
+  {  216,   -2 }, /* (106) alter_db_optr ::= alter_db_optr quorum */
+  {  216,   -2 }, /* (107) alter_db_optr ::= alter_db_optr keep */
+  {  216,   -2 }, /* (108) alter_db_optr ::= alter_db_optr blocks */
+  {  216,   -2 }, /* (109) alter_db_optr ::= alter_db_optr comp */
+  {  216,   -2 }, /* (110) alter_db_optr ::= alter_db_optr wal */
+  {  216,   -2 }, /* (111) alter_db_optr ::= alter_db_optr fsync */
+  {  216,   -2 }, /* (112) alter_db_optr ::= alter_db_optr update */
+  {  216,   -2 }, /* (113) alter_db_optr ::= alter_db_optr cachelast */
+  {  245,   -1 }, /* (114) typename ::= ids */
+  {  245,   -4 }, /* (115) typename ::= ids LP signed RP */
+  {  245,   -2 }, /* (116) typename ::= ids UNSIGNED */
+  {  246,   -1 }, /* (117) signed ::= INTEGER */
+  {  246,   -2 }, /* (118) signed ::= PLUS INTEGER */
+  {  246,   -2 }, /* (119) signed ::= MINUS INTEGER */
+  {  211,   -3 }, /* (120) cmd ::= CREATE TABLE create_table_args */
+  {  211,   -3 }, /* (121) cmd ::= CREATE TABLE create_stable_args */
+  {  211,   -3 }, /* (122) cmd ::= CREATE STABLE create_stable_args */
+  {  211,   -3 }, /* (123) cmd ::= CREATE TABLE create_table_list */
+  {  249,   -1 }, /* (124) create_table_list ::= create_from_stable */
+  {  249,   -2 }, /* (125) create_table_list ::= create_table_list create_from_stable */
+  {  247,   -6 }, /* (126) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
+  {  248,  -10 }, /* (127) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
+  {  250,  -10 }, /* (128) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
+  {  247,   -5 }, /* (129) create_table_args ::= ifnotexists ids cpxName AS select */
+  {  251,   -3 }, /* (130) columnlist ::= columnlist COMMA column */
+  {  251,   -1 }, /* (131) columnlist ::= column */
+  {  253,   -2 }, /* (132) column ::= ids typename */
+  {  230,   -3 }, /* (133) tagitemlist ::= tagitemlist COMMA tagitem */
+  {  230,   -1 }, /* (134) tagitemlist ::= tagitem */
+  {  254,   -1 }, /* (135) tagitem ::= INTEGER */
+  {  254,   -1 }, /* (136) tagitem ::= FLOAT */
+  {  254,   -1 }, /* (137) tagitem ::= STRING */
+  {  254,   -1 }, /* (138) tagitem ::= BOOL */
+  {  254,   -1 }, /* (139) tagitem ::= NULL */
+  {  254,   -2 }, /* (140) tagitem ::= MINUS INTEGER */
+  {  254,   -2 }, /* (141) tagitem ::= MINUS FLOAT */
+  {  254,   -2 }, /* (142) tagitem ::= PLUS INTEGER */
+  {  254,   -2 }, /* (143) tagitem ::= PLUS FLOAT */
+  {  252,  -12 }, /* (144) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
+  {  266,   -1 }, /* (145) union ::= select */
+  {  266,   -3 }, /* (146) union ::= LP union RP */
+  {  266,   -4 }, /* (147) union ::= union UNION ALL select */
+  {  266,   -6 }, /* (148) union ::= union UNION ALL LP select RP */
+  {  211,   -1 }, /* (149) cmd ::= union */
+  {  252,   -2 }, /* (150) select ::= SELECT selcollist */
+  {  267,   -2 }, /* (151) sclp ::= selcollist COMMA */
+  {  267,    0 }, /* (152) sclp ::= */
+  {  255,   -3 }, /* (153) selcollist ::= sclp expr as */
+  {  255,   -2 }, /* (154) selcollist ::= sclp STAR */
+  {  269,   -2 }, /* (155) as ::= AS ids */
+  {  269,   -1 }, /* (156) as ::= ids */
+  {  269,    0 }, /* (157) as ::= */
+  {  256,   -2 }, /* (158) from ::= FROM tablelist */
+  {  270,   -2 }, /* (159) tablelist ::= ids cpxName */
+  {  270,   -3 }, /* (160) tablelist ::= ids cpxName ids */
+  {  270,   -4 }, /* (161) tablelist ::= tablelist COMMA ids cpxName */
+  {  270,   -5 }, /* (162) tablelist ::= tablelist COMMA ids cpxName ids */
+  {  271,   -1 }, /* (163) tmvar ::= VARIABLE */
+  {  258,   -4 }, /* (164) interval_opt ::= INTERVAL LP tmvar RP */
+  {  258,   -6 }, /* (165) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
+  {  258,    0 }, /* (166) interval_opt ::= */
+  {  259,    0 }, /* (167) fill_opt ::= */
+  {  259,   -6 }, /* (168) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+  {  259,   -4 }, /* (169) fill_opt ::= FILL LP ID RP */
+  {  260,   -4 }, /* (170) sliding_opt ::= SLIDING LP tmvar RP */
+  {  260,    0 }, /* (171) sliding_opt ::= */
+  {  262,    0 }, /* (172) orderby_opt ::= */
+  {  262,   -3 }, /* (173) orderby_opt ::= ORDER BY sortlist */
+  {  272,   -4 }, /* (174) sortlist ::= sortlist COMMA item sortorder */
+  {  272,   -2 }, /* (175) sortlist ::= item sortorder */
+  {  274,   -2 }, /* (176) item ::= ids cpxName */
+  {  275,   -1 }, /* (177) sortorder ::= ASC */
+  {  275,   -1 }, /* (178) sortorder ::= DESC */
+  {  275,    0 }, /* (179) sortorder ::= */
+  {  261,    0 }, /* (180) groupby_opt ::= */
+  {  261,   -3 }, /* (181) groupby_opt ::= GROUP BY grouplist */
+  {  276,   -3 }, /* (182) grouplist ::= grouplist COMMA item */
+  {  276,   -1 }, /* (183) grouplist ::= item */
+  {  263,    0 }, /* (184) having_opt ::= */
+  {  263,   -2 }, /* (185) having_opt ::= HAVING expr */
+  {  265,    0 }, /* (186) limit_opt ::= */
+  {  265,   -2 }, /* (187) limit_opt ::= LIMIT signed */
+  {  265,   -4 }, /* (188) limit_opt ::= LIMIT signed OFFSET signed */
+  {  265,   -4 }, /* (189) limit_opt ::= LIMIT signed COMMA signed */
+  {  264,    0 }, /* (190) slimit_opt ::= */
+  {  264,   -2 }, /* (191) slimit_opt ::= SLIMIT signed */
+  {  264,   -4 }, /* (192) slimit_opt ::= SLIMIT signed SOFFSET signed */
+  {  264,   -4 }, /* (193) slimit_opt ::= SLIMIT signed COMMA signed */
+  {  257,    0 }, /* (194) where_opt ::= */
+  {  257,   -2 }, /* (195) where_opt ::= WHERE expr */
+  {  268,   -3 }, /* (196) expr ::= LP expr RP */
+  {  268,   -1 }, /* (197) expr ::= ID */
+  {  268,   -3 }, /* (198) expr ::= ID DOT ID */
+  {  268,   -3 }, /* (199) expr ::= ID DOT STAR */
+  {  268,   -1 }, /* (200) expr ::= INTEGER */
+  {  268,   -2 }, /* (201) expr ::= MINUS INTEGER */
+  {  268,   -2 }, /* (202) expr ::= PLUS INTEGER */
+  {  268,   -1 }, /* (203) expr ::= FLOAT */
+  {  268,   -2 }, /* (204) expr ::= MINUS FLOAT */
+  {  268,   -2 }, /* (205) expr ::= PLUS FLOAT */
+  {  268,   -1 }, /* (206) expr ::= STRING */
+  {  268,   -1 }, /* (207) expr ::= NOW */
+  {  268,   -1 }, /* (208) expr ::= VARIABLE */
+  {  268,   -1 }, /* (209) expr ::= BOOL */
+  {  268,   -4 }, /* (210) expr ::= ID LP exprlist RP */
+  {  268,   -4 }, /* (211) expr ::= ID LP STAR RP */
+  {  268,   -3 }, /* (212) expr ::= expr IS NULL */
+  {  268,   -4 }, /* (213) expr ::= expr IS NOT NULL */
+  {  268,   -3 }, /* (214) expr ::= expr LT expr */
+  {  268,   -3 }, /* (215) expr ::= expr GT expr */
+  {  268,   -3 }, /* (216) expr ::= expr LE expr */
+  {  268,   -3 }, /* (217) expr ::= expr GE expr */
+  {  268,   -3 }, /* (218) expr ::= expr NE expr */
+  {  268,   -3 }, /* (219) expr ::= expr EQ expr */
+  {  268,   -3 }, /* (220) expr ::= expr AND expr */
+  {  268,   -3 }, /* (221) expr ::= expr OR expr */
+  {  268,   -3 }, /* (222) expr ::= expr PLUS expr */
+  {  268,   -3 }, /* (223) expr ::= expr MINUS expr */
+  {  268,   -3 }, /* (224) expr ::= expr STAR expr */
+  {  268,   -3 }, /* (225) expr ::= expr SLASH expr */
+  {  268,   -3 }, /* (226) expr ::= expr REM expr */
+  {  268,   -3 }, /* (227) expr ::= expr LIKE expr */
+  {  268,   -5 }, /* (228) expr ::= expr IN LP exprlist RP */
+  {  277,   -3 }, /* (229) exprlist ::= exprlist COMMA expritem */
+  {  277,   -1 }, /* (230) exprlist ::= expritem */
+  {  278,   -1 }, /* (231) expritem ::= expr */
+  {  278,    0 }, /* (232) expritem ::= */
+  {  211,   -3 }, /* (233) cmd ::= RESET QUERY CACHE */
+  {  211,   -7 }, /* (234) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+  {  211,   -7 }, /* (235) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+  {  211,   -7 }, /* (236) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+  {  211,   -7 }, /* (237) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+  {  211,   -8 }, /* (238) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+  {  211,   -9 }, /* (239) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+  {  211,   -7 }, /* (240) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
+  {  211,   -7 }, /* (241) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
+  {  211,   -7 }, /* (242) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
+  {  211,   -7 }, /* (243) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
+  {  211,   -8 }, /* (244) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
+  {  211,   -3 }, /* (245) cmd ::= KILL CONNECTION INTEGER */
+  {  211,   -5 }, /* (246) cmd ::= KILL STREAM INTEGER COLON INTEGER */
+  {  211,   -5 }, /* (247) cmd ::= KILL QUERY INTEGER COLON INTEGER */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -2042,7 +2074,9 @@ static void yy_reduce(
 /********** Begin reduce actions **********************************************/
         YYMINORTYPE yylhsminor;
       case 0: /* program ::= cmd */
-      case 119: /* cmd ::= CREATE TABLE create_table_args */ yytestcase(yyruleno==119);
+      case 120: /* cmd ::= CREATE TABLE create_table_args */ yytestcase(yyruleno==120);
+      case 121: /* cmd ::= CREATE TABLE create_stable_args */ yytestcase(yyruleno==121);
+      case 122: /* cmd ::= CREATE STABLE create_stable_args */ yytestcase(yyruleno==122);
 {}
         break;
       case 1: /* cmd ::= SHOW DATABASES */
@@ -2150,275 +2184,283 @@ static void yy_reduce(
       case 27: /* cmd ::= DROP TABLE ifexists ids cpxName */
 {
     yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
-    setDropDbTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &yymsp[-1].minor.yy0, &yymsp[-2].minor.yy0);
+    setDropDbTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &yymsp[-1].minor.yy0, &yymsp[-2].minor.yy0, -1);
+}
+        break;
+      case 28: /* cmd ::= DROP STABLE ifexists ids cpxName */
+{
+    yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
+    setDropDbTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &yymsp[-1].minor.yy0, &yymsp[-2].minor.yy0, TSDB_SUPER_TABLE);
 }
         break;
-      case 28: /* cmd ::= DROP DATABASE ifexists ids */
-{ setDropDbTableInfo(pInfo, TSDB_SQL_DROP_DB, &yymsp[0].minor.yy0, &yymsp[-1].minor.yy0); }
+      case 29: /* cmd ::= DROP DATABASE ifexists ids */
+{ setDropDbTableInfo(pInfo, TSDB_SQL_DROP_DB, &yymsp[0].minor.yy0, &yymsp[-1].minor.yy0, -1); }
         break;
-      case 29: /* cmd ::= DROP DNODE ids */
+      case 30: /* cmd ::= DROP DNODE ids */
 { setDCLSQLElems(pInfo, TSDB_SQL_DROP_DNODE, 1, &yymsp[0].minor.yy0);    }
         break;
-      case 30: /* cmd ::= DROP USER ids */
+      case 31: /* cmd ::= DROP USER ids */
 { setDCLSQLElems(pInfo, TSDB_SQL_DROP_USER, 1, &yymsp[0].minor.yy0);     }
         break;
-      case 31: /* cmd ::= DROP ACCOUNT ids */
+      case 32: /* cmd ::= DROP ACCOUNT ids */
 { setDCLSQLElems(pInfo, TSDB_SQL_DROP_ACCT, 1, &yymsp[0].minor.yy0);  }
         break;
-      case 32: /* cmd ::= USE ids */
+      case 33: /* cmd ::= USE ids */
 { setDCLSQLElems(pInfo, TSDB_SQL_USE_DB, 1, &yymsp[0].minor.yy0);}
         break;
-      case 33: /* cmd ::= DESCRIBE ids cpxName */
+      case 34: /* cmd ::= DESCRIBE ids cpxName */
 {
     yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
     setDCLSQLElems(pInfo, TSDB_SQL_DESCRIBE_TABLE, 1, &yymsp[-1].minor.yy0);
 }
         break;
-      case 34: /* cmd ::= ALTER USER ids PASS ids */
+      case 35: /* cmd ::= ALTER USER ids PASS ids */
 { setAlterUserSql(pInfo, TSDB_ALTER_USER_PASSWD, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, NULL);    }
         break;
-      case 35: /* cmd ::= ALTER USER ids PRIVILEGE ids */
+      case 36: /* cmd ::= ALTER USER ids PRIVILEGE ids */
 { setAlterUserSql(pInfo, TSDB_ALTER_USER_PRIVILEGES, &yymsp[-2].minor.yy0, NULL, &yymsp[0].minor.yy0);}
         break;
-      case 36: /* cmd ::= ALTER DNODE ids ids */
+      case 37: /* cmd ::= ALTER DNODE ids ids */
 { setDCLSQLElems(pInfo, TSDB_SQL_CFG_DNODE, 2, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);          }
         break;
-      case 37: /* cmd ::= ALTER DNODE ids ids ids */
+      case 38: /* cmd ::= ALTER DNODE ids ids ids */
 { setDCLSQLElems(pInfo, TSDB_SQL_CFG_DNODE, 3, &yymsp[-2].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);      }
         break;
-      case 38: /* cmd ::= ALTER LOCAL ids */
+      case 39: /* cmd ::= ALTER LOCAL ids */
 { setDCLSQLElems(pInfo, TSDB_SQL_CFG_LOCAL, 1, &yymsp[0].minor.yy0);              }
         break;
-      case 39: /* cmd ::= ALTER LOCAL ids ids */
+      case 40: /* cmd ::= ALTER LOCAL ids ids */
 { setDCLSQLElems(pInfo, TSDB_SQL_CFG_LOCAL, 2, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);          }
         break;
-      case 40: /* cmd ::= ALTER DATABASE ids alter_db_optr */
-{ SStrToken t = {0};  setCreateDBSQL(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy234, &t);}
+      case 41: /* cmd ::= ALTER DATABASE ids alter_db_optr */
+{ SStrToken t = {0};
+        setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy256, &t);}
         break;
-      case 41: /* cmd ::= ALTER ACCOUNT ids acct_optr */
-{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy71);}
+      case 42: /* cmd ::= ALTER ACCOUNT ids acct_optr */
+{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy277);}
         break;
-      case 42: /* cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
-{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy71);}
+      case 43: /* cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
+{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy277);}
         break;
-      case 43: /* ids ::= ID */
-      case 44: /* ids ::= STRING */ yytestcase(yyruleno==44);
+      case 44: /* ids ::= ID */
+      case 45: /* ids ::= STRING */ yytestcase(yyruleno==45);
 {yylhsminor.yy0 = yymsp[0].minor.yy0; }
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 45: /* ifexists ::= IF EXISTS */
+      case 46: /* ifexists ::= IF EXISTS */
 { yymsp[-1].minor.yy0.n = 1;}
         break;
-      case 46: /* ifexists ::= */
-      case 48: /* ifnotexists ::= */ yytestcase(yyruleno==48);
+      case 47: /* ifexists ::= */
+      case 49: /* ifnotexists ::= */ yytestcase(yyruleno==49);
 { yymsp[1].minor.yy0.n = 0;}
         break;
-      case 47: /* ifnotexists ::= IF NOT EXISTS */
+      case 48: /* ifnotexists ::= IF NOT EXISTS */
 { yymsp[-2].minor.yy0.n = 1;}
         break;
-      case 49: /* cmd ::= CREATE DNODE ids */
+      case 50: /* cmd ::= CREATE DNODE ids */
 { setDCLSQLElems(pInfo, TSDB_SQL_CREATE_DNODE, 1, &yymsp[0].minor.yy0);}
         break;
-      case 50: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
-{ setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy71);}
+      case 51: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
+{ setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy277);}
         break;
-      case 51: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */
-{ setCreateDBSQL(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy234, &yymsp[-2].minor.yy0);}
+      case 52: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */
+{
+        setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy256, &yymsp[-2].minor.yy0);}
         break;
-      case 52: /* cmd ::= CREATE USER ids PASS ids */
+      case 53: /* cmd ::= CREATE USER ids PASS ids */
 { setCreateUserSql(pInfo, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);}
         break;
-      case 53: /* pps ::= */
-      case 55: /* tseries ::= */ yytestcase(yyruleno==55);
-      case 57: /* dbs ::= */ yytestcase(yyruleno==57);
-      case 59: /* streams ::= */ yytestcase(yyruleno==59);
-      case 61: /* storage ::= */ yytestcase(yyruleno==61);
-      case 63: /* qtime ::= */ yytestcase(yyruleno==63);
-      case 65: /* users ::= */ yytestcase(yyruleno==65);
-      case 67: /* conns ::= */ yytestcase(yyruleno==67);
-      case 69: /* state ::= */ yytestcase(yyruleno==69);
+      case 54: /* pps ::= */
+      case 56: /* tseries ::= */ yytestcase(yyruleno==56);
+      case 58: /* dbs ::= */ yytestcase(yyruleno==58);
+      case 60: /* streams ::= */ yytestcase(yyruleno==60);
+      case 62: /* storage ::= */ yytestcase(yyruleno==62);
+      case 64: /* qtime ::= */ yytestcase(yyruleno==64);
+      case 66: /* users ::= */ yytestcase(yyruleno==66);
+      case 68: /* conns ::= */ yytestcase(yyruleno==68);
+      case 70: /* state ::= */ yytestcase(yyruleno==70);
 { yymsp[1].minor.yy0.n = 0;   }
         break;
-      case 54: /* pps ::= PPS INTEGER */
-      case 56: /* tseries ::= TSERIES INTEGER */ yytestcase(yyruleno==56);
-      case 58: /* dbs ::= DBS INTEGER */ yytestcase(yyruleno==58);
-      case 60: /* streams ::= STREAMS INTEGER */ yytestcase(yyruleno==60);
-      case 62: /* storage ::= STORAGE INTEGER */ yytestcase(yyruleno==62);
-      case 64: /* qtime ::= QTIME INTEGER */ yytestcase(yyruleno==64);
-      case 66: /* users ::= USERS INTEGER */ yytestcase(yyruleno==66);
-      case 68: /* conns ::= CONNS INTEGER */ yytestcase(yyruleno==68);
-      case 70: /* state ::= STATE ids */ yytestcase(yyruleno==70);
+      case 55: /* pps ::= PPS INTEGER */
+      case 57: /* tseries ::= TSERIES INTEGER */ yytestcase(yyruleno==57);
+      case 59: /* dbs ::= DBS INTEGER */ yytestcase(yyruleno==59);
+      case 61: /* streams ::= STREAMS INTEGER */ yytestcase(yyruleno==61);
+      case 63: /* storage ::= STORAGE INTEGER */ yytestcase(yyruleno==63);
+      case 65: /* qtime ::= QTIME INTEGER */ yytestcase(yyruleno==65);
+      case 67: /* users ::= USERS INTEGER */ yytestcase(yyruleno==67);
+      case 69: /* conns ::= CONNS INTEGER */ yytestcase(yyruleno==69);
+      case 71: /* state ::= STATE ids */ yytestcase(yyruleno==71);
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;     }
         break;
-      case 71: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */
+      case 72: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */
 {
-    yylhsminor.yy71.maxUsers   = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
-    yylhsminor.yy71.maxDbs     = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
-    yylhsminor.yy71.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
-    yylhsminor.yy71.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
-    yylhsminor.yy71.maxPointsPerSecond     = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
-    yylhsminor.yy71.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
-    yylhsminor.yy71.maxQueryTime   = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
-    yylhsminor.yy71.maxConnections   = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
-    yylhsminor.yy71.stat    = yymsp[0].minor.yy0;
-}
-  yymsp[-8].minor.yy71 = yylhsminor.yy71;
-        break;
-      case 72: /* keep ::= KEEP tagitemlist */
-{ yymsp[-1].minor.yy421 = yymsp[0].minor.yy421; }
-        break;
-      case 73: /* cache ::= CACHE INTEGER */
-      case 74: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==74);
-      case 75: /* quorum ::= QUORUM INTEGER */ yytestcase(yyruleno==75);
-      case 76: /* days ::= DAYS INTEGER */ yytestcase(yyruleno==76);
-      case 77: /* minrows ::= MINROWS INTEGER */ yytestcase(yyruleno==77);
-      case 78: /* maxrows ::= MAXROWS INTEGER */ yytestcase(yyruleno==78);
-      case 79: /* blocks ::= BLOCKS INTEGER */ yytestcase(yyruleno==79);
-      case 80: /* ctime ::= CTIME INTEGER */ yytestcase(yyruleno==80);
-      case 81: /* wal ::= WAL INTEGER */ yytestcase(yyruleno==81);
-      case 82: /* fsync ::= FSYNC INTEGER */ yytestcase(yyruleno==82);
-      case 83: /* comp ::= COMP INTEGER */ yytestcase(yyruleno==83);
-      case 84: /* prec ::= PRECISION STRING */ yytestcase(yyruleno==84);
-      case 85: /* update ::= UPDATE INTEGER */ yytestcase(yyruleno==85);
-      case 86: /* cachelast ::= CACHELAST INTEGER */ yytestcase(yyruleno==86);
+    yylhsminor.yy277.maxUsers   = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
+    yylhsminor.yy277.maxDbs     = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
+    yylhsminor.yy277.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
+    yylhsminor.yy277.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
+    yylhsminor.yy277.maxPointsPerSecond     = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
+    yylhsminor.yy277.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
+    yylhsminor.yy277.maxQueryTime   = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
+    yylhsminor.yy277.maxConnections   = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
+    yylhsminor.yy277.stat    = yymsp[0].minor.yy0;
+}
+  yymsp[-8].minor.yy277 = yylhsminor.yy277;
+        break;
+      case 73: /* keep ::= KEEP tagitemlist */
+{ yymsp[-1].minor.yy135 = yymsp[0].minor.yy135; }
+        break;
+      case 74: /* cache ::= CACHE INTEGER */
+      case 75: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==75);
+      case 76: /* quorum ::= QUORUM INTEGER */ yytestcase(yyruleno==76);
+      case 77: /* days ::= DAYS INTEGER */ yytestcase(yyruleno==77);
+      case 78: /* minrows ::= MINROWS INTEGER */ yytestcase(yyruleno==78);
+      case 79: /* maxrows ::= MAXROWS INTEGER */ yytestcase(yyruleno==79);
+      case 80: /* blocks ::= BLOCKS INTEGER */ yytestcase(yyruleno==80);
+      case 81: /* ctime ::= CTIME INTEGER */ yytestcase(yyruleno==81);
+      case 82: /* wal ::= WAL INTEGER */ yytestcase(yyruleno==82);
+      case 83: /* fsync ::= FSYNC INTEGER */ yytestcase(yyruleno==83);
+      case 84: /* comp ::= COMP INTEGER */ yytestcase(yyruleno==84);
+      case 85: /* prec ::= PRECISION STRING */ yytestcase(yyruleno==85);
+      case 86: /* update ::= UPDATE INTEGER */ yytestcase(yyruleno==86);
+      case 87: /* cachelast ::= CACHELAST INTEGER */ yytestcase(yyruleno==87);
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
         break;
-      case 87: /* db_optr ::= */
-{setDefaultCreateDbOption(&yymsp[1].minor.yy234);}
-        break;
-      case 88: /* db_optr ::= db_optr cache */
-{ yylhsminor.yy234 = yymsp[-1].minor.yy234; yylhsminor.yy234.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy234 = yylhsminor.yy234;
-        break;
-      case 89: /* db_optr ::= db_optr replica */
-      case 104: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==104);
-{ yylhsminor.yy234 = yymsp[-1].minor.yy234; yylhsminor.yy234.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy234 = yylhsminor.yy234;
-        break;
-      case 90: /* db_optr ::= db_optr quorum */
-      case 105: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==105);
-{ yylhsminor.yy234 = yymsp[-1].minor.yy234; yylhsminor.yy234.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy234 = yylhsminor.yy234;
-        break;
-      case 91: /* db_optr ::= db_optr days */
-{ yylhsminor.yy234 = yymsp[-1].minor.yy234; yylhsminor.yy234.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy234 = yylhsminor.yy234;
-        break;
-      case 92: /* db_optr ::= db_optr minrows */
-{ yylhsminor.yy234 = yymsp[-1].minor.yy234; yylhsminor.yy234.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
-  yymsp[-1].minor.yy234 = yylhsminor.yy234;
-        break;
-      case 93: /* db_optr ::= db_optr maxrows */
-{ yylhsminor.yy234 = yymsp[-1].minor.yy234; yylhsminor.yy234.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
-  yymsp[-1].minor.yy234 = yylhsminor.yy234;
-        break;
-      case 94: /* db_optr ::= db_optr blocks */
-      case 107: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==107);
-{ yylhsminor.yy234 = yymsp[-1].minor.yy234; yylhsminor.yy234.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy234 = yylhsminor.yy234;
-        break;
-      case 95: /* db_optr ::= db_optr ctime */
-{ yylhsminor.yy234 = yymsp[-1].minor.yy234; yylhsminor.yy234.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy234 = yylhsminor.yy234;
-        break;
-      case 96: /* db_optr ::= db_optr wal */
-      case 109: /* alter_db_optr ::= alter_db_optr wal */ yytestcase(yyruleno==109);
-{ yylhsminor.yy234 = yymsp[-1].minor.yy234; yylhsminor.yy234.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy234 = yylhsminor.yy234;
-        break;
-      case 97: /* db_optr ::= db_optr fsync */
-      case 110: /* alter_db_optr ::= alter_db_optr fsync */ yytestcase(yyruleno==110);
-{ yylhsminor.yy234 = yymsp[-1].minor.yy234; yylhsminor.yy234.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy234 = yylhsminor.yy234;
-        break;
-      case 98: /* db_optr ::= db_optr comp */
-      case 108: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==108);
-{ yylhsminor.yy234 = yymsp[-1].minor.yy234; yylhsminor.yy234.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy234 = yylhsminor.yy234;
-        break;
-      case 99: /* db_optr ::= db_optr prec */
-{ yylhsminor.yy234 = yymsp[-1].minor.yy234; yylhsminor.yy234.precision = yymsp[0].minor.yy0; }
-  yymsp[-1].minor.yy234 = yylhsminor.yy234;
-        break;
-      case 100: /* db_optr ::= db_optr keep */
-      case 106: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==106);
-{ yylhsminor.yy234 = yymsp[-1].minor.yy234; yylhsminor.yy234.keep = yymsp[0].minor.yy421; }
-  yymsp[-1].minor.yy234 = yylhsminor.yy234;
-        break;
-      case 101: /* db_optr ::= db_optr update */
-      case 111: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==111);
-{ yylhsminor.yy234 = yymsp[-1].minor.yy234; yylhsminor.yy234.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy234 = yylhsminor.yy234;
-        break;
-      case 102: /* db_optr ::= db_optr cachelast */
-      case 112: /* alter_db_optr ::= alter_db_optr cachelast */ yytestcase(yyruleno==112);
-{ yylhsminor.yy234 = yymsp[-1].minor.yy234; yylhsminor.yy234.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy234 = yylhsminor.yy234;
-        break;
-      case 103: /* alter_db_optr ::= */
-{ setDefaultCreateDbOption(&yymsp[1].minor.yy234);}
-        break;
-      case 113: /* typename ::= ids */
+      case 88: /* db_optr ::= */
+{setDefaultCreateDbOption(&yymsp[1].minor.yy256);}
+        break;
+      case 89: /* db_optr ::= db_optr cache */
+{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy256 = yylhsminor.yy256;
+        break;
+      case 90: /* db_optr ::= db_optr replica */
+      case 105: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==105);
+{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy256 = yylhsminor.yy256;
+        break;
+      case 91: /* db_optr ::= db_optr quorum */
+      case 106: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==106);
+{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy256 = yylhsminor.yy256;
+        break;
+      case 92: /* db_optr ::= db_optr days */
+{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy256 = yylhsminor.yy256;
+        break;
+      case 93: /* db_optr ::= db_optr minrows */
+{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+  yymsp[-1].minor.yy256 = yylhsminor.yy256;
+        break;
+      case 94: /* db_optr ::= db_optr maxrows */
+{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+  yymsp[-1].minor.yy256 = yylhsminor.yy256;
+        break;
+      case 95: /* db_optr ::= db_optr blocks */
+      case 108: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==108);
+{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy256 = yylhsminor.yy256;
+        break;
+      case 96: /* db_optr ::= db_optr ctime */
+{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy256 = yylhsminor.yy256;
+        break;
+      case 97: /* db_optr ::= db_optr wal */
+      case 110: /* alter_db_optr ::= alter_db_optr wal */ yytestcase(yyruleno==110);
+{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy256 = yylhsminor.yy256;
+        break;
+      case 98: /* db_optr ::= db_optr fsync */
+      case 111: /* alter_db_optr ::= alter_db_optr fsync */ yytestcase(yyruleno==111);
+{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy256 = yylhsminor.yy256;
+        break;
+      case 99: /* db_optr ::= db_optr comp */
+      case 109: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==109);
+{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy256 = yylhsminor.yy256;
+        break;
+      case 100: /* db_optr ::= db_optr prec */
+{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.precision = yymsp[0].minor.yy0; }
+  yymsp[-1].minor.yy256 = yylhsminor.yy256;
+        break;
+      case 101: /* db_optr ::= db_optr keep */
+      case 107: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==107);
+{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.keep = yymsp[0].minor.yy135; }
+  yymsp[-1].minor.yy256 = yylhsminor.yy256;
+        break;
+      case 102: /* db_optr ::= db_optr update */
+      case 112: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==112);
+{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy256 = yylhsminor.yy256;
+        break;
+      case 103: /* db_optr ::= db_optr cachelast */
+      case 113: /* alter_db_optr ::= alter_db_optr cachelast */ yytestcase(yyruleno==113);
+{ yylhsminor.yy256 = yymsp[-1].minor.yy256; yylhsminor.yy256.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy256 = yylhsminor.yy256;
+        break;
+      case 104: /* alter_db_optr ::= */
+{ setDefaultCreateDbOption(&yymsp[1].minor.yy256);}
+        break;
+      case 114: /* typename ::= ids */
 { 
   yymsp[0].minor.yy0.type = 0;
-  tSqlSetColumnType (&yylhsminor.yy183, &yymsp[0].minor.yy0);
+  tSqlSetColumnType (&yylhsminor.yy181, &yymsp[0].minor.yy0);
 }
-  yymsp[0].minor.yy183 = yylhsminor.yy183;
+  yymsp[0].minor.yy181 = yylhsminor.yy181;
         break;
-      case 114: /* typename ::= ids LP signed RP */
+      case 115: /* typename ::= ids LP signed RP */
 {
-  if (yymsp[-1].minor.yy325 <= 0) {
+  if (yymsp[-1].minor.yy531 <= 0) {
     yymsp[-3].minor.yy0.type = 0;
-    tSqlSetColumnType(&yylhsminor.yy183, &yymsp[-3].minor.yy0);
+    tSqlSetColumnType(&yylhsminor.yy181, &yymsp[-3].minor.yy0);
   } else {
-    yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy325;  // negative value of name length
-    tSqlSetColumnType(&yylhsminor.yy183, &yymsp[-3].minor.yy0);
+    yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy531;  // negative value of name length
+    tSqlSetColumnType(&yylhsminor.yy181, &yymsp[-3].minor.yy0);
   }
 }
-  yymsp[-3].minor.yy183 = yylhsminor.yy183;
+  yymsp[-3].minor.yy181 = yylhsminor.yy181;
         break;
-      case 115: /* typename ::= ids UNSIGNED */
+      case 116: /* typename ::= ids UNSIGNED */
 {
   yymsp[-1].minor.yy0.type = 0;
   yymsp[-1].minor.yy0.n = ((yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z);
-  tSqlSetColumnType (&yylhsminor.yy183, &yymsp[-1].minor.yy0);
+  tSqlSetColumnType (&yylhsminor.yy181, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy183 = yylhsminor.yy183;
+  yymsp[-1].minor.yy181 = yylhsminor.yy181;
         break;
-      case 116: /* signed ::= INTEGER */
-{ yylhsminor.yy325 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[0].minor.yy325 = yylhsminor.yy325;
+      case 117: /* signed ::= INTEGER */
+{ yylhsminor.yy531 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[0].minor.yy531 = yylhsminor.yy531;
         break;
-      case 117: /* signed ::= PLUS INTEGER */
-{ yymsp[-1].minor.yy325 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+      case 118: /* signed ::= PLUS INTEGER */
+{ yymsp[-1].minor.yy531 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
         break;
-      case 118: /* signed ::= MINUS INTEGER */
-{ yymsp[-1].minor.yy325 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
+      case 119: /* signed ::= MINUS INTEGER */
+{ yymsp[-1].minor.yy531 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
         break;
-      case 120: /* cmd ::= CREATE TABLE create_table_list */
+      case 123: /* cmd ::= CREATE TABLE create_table_list */
 { pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy38;}
         break;
-      case 121: /* create_table_list ::= create_from_stable */
+      case 124: /* create_table_list ::= create_from_stable */
 {
   SCreateTableSQL* pCreateTable = calloc(1, sizeof(SCreateTableSQL));
   pCreateTable->childTableInfo = taosArrayInit(4, sizeof(SCreatedTableInfo));
 
-  taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy152);
+  taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy78);
   pCreateTable->type = TSQL_CREATE_TABLE_FROM_STABLE;
   yylhsminor.yy38 = pCreateTable;
 }
   yymsp[0].minor.yy38 = yylhsminor.yy38;
         break;
-      case 122: /* create_table_list ::= create_table_list create_from_stable */
+      case 125: /* create_table_list ::= create_table_list create_from_stable */
 {
-  taosArrayPush(yymsp[-1].minor.yy38->childTableInfo, &yymsp[0].minor.yy152);
+  taosArrayPush(yymsp[-1].minor.yy38->childTableInfo, &yymsp[0].minor.yy78);
   yylhsminor.yy38 = yymsp[-1].minor.yy38;
 }
   yymsp[-1].minor.yy38 = yylhsminor.yy38;
         break;
-      case 123: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
+      case 126: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
 {
-  yylhsminor.yy38 = tSetCreateSqlElems(yymsp[-1].minor.yy421, NULL, NULL, TSQL_CREATE_TABLE);
+  yylhsminor.yy38 = tSetCreateSqlElems(yymsp[-1].minor.yy135, NULL, NULL, TSQL_CREATE_TABLE);
   setSqlInfo(pInfo, yylhsminor.yy38, NULL, TSDB_SQL_CREATE_TABLE);
 
   yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
@@ -2426,9 +2468,9 @@ static void yy_reduce(
 }
   yymsp[-5].minor.yy38 = yylhsminor.yy38;
         break;
-      case 124: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
+      case 127: /* create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
 {
-  yylhsminor.yy38 = tSetCreateSqlElems(yymsp[-5].minor.yy421, yymsp[-1].minor.yy421, NULL, TSQL_CREATE_STABLE);
+  yylhsminor.yy38 = tSetCreateSqlElems(yymsp[-5].minor.yy135, yymsp[-1].minor.yy135, NULL, TSQL_CREATE_STABLE);
   setSqlInfo(pInfo, yylhsminor.yy38, NULL, TSDB_SQL_CREATE_TABLE);
 
   yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
@@ -2436,17 +2478,17 @@ static void yy_reduce(
 }
   yymsp[-9].minor.yy38 = yylhsminor.yy38;
         break;
-      case 125: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
+      case 128: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
 {
   yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
   yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
-  yylhsminor.yy152 = createNewChildTableInfo(&yymsp[-5].minor.yy0, yymsp[-1].minor.yy421, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
+  yylhsminor.yy78 = createNewChildTableInfo(&yymsp[-5].minor.yy0, yymsp[-1].minor.yy135, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
 }
-  yymsp[-9].minor.yy152 = yylhsminor.yy152;
+  yymsp[-9].minor.yy78 = yylhsminor.yy78;
         break;
-      case 126: /* create_table_args ::= ifnotexists ids cpxName AS select */
+      case 129: /* create_table_args ::= ifnotexists ids cpxName AS select */
 {
-  yylhsminor.yy38 = tSetCreateSqlElems(NULL, NULL, yymsp[0].minor.yy148, TSQL_CREATE_STREAM);
+  yylhsminor.yy38 = tSetCreateSqlElems(NULL, NULL, yymsp[0].minor.yy30, TSQL_CREATE_STREAM);
   setSqlInfo(pInfo, yylhsminor.yy38, NULL, TSDB_SQL_CREATE_TABLE);
 
   yymsp[-3].minor.yy0.n += yymsp[-2].minor.yy0.n;
@@ -2454,451 +2496,451 @@ static void yy_reduce(
 }
   yymsp[-4].minor.yy38 = yylhsminor.yy38;
         break;
-      case 127: /* columnlist ::= columnlist COMMA column */
-{taosArrayPush(yymsp[-2].minor.yy421, &yymsp[0].minor.yy183); yylhsminor.yy421 = yymsp[-2].minor.yy421;  }
-  yymsp[-2].minor.yy421 = yylhsminor.yy421;
+      case 130: /* columnlist ::= columnlist COMMA column */
+{taosArrayPush(yymsp[-2].minor.yy135, &yymsp[0].minor.yy181); yylhsminor.yy135 = yymsp[-2].minor.yy135;  }
+  yymsp[-2].minor.yy135 = yylhsminor.yy135;
         break;
-      case 128: /* columnlist ::= column */
-{yylhsminor.yy421 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy421, &yymsp[0].minor.yy183);}
-  yymsp[0].minor.yy421 = yylhsminor.yy421;
+      case 131: /* columnlist ::= column */
+{yylhsminor.yy135 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy135, &yymsp[0].minor.yy181);}
+  yymsp[0].minor.yy135 = yylhsminor.yy135;
         break;
-      case 129: /* column ::= ids typename */
+      case 132: /* column ::= ids typename */
 {
-  tSqlSetColumnInfo(&yylhsminor.yy183, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy183);
+  tSqlSetColumnInfo(&yylhsminor.yy181, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy181);
 }
-  yymsp[-1].minor.yy183 = yylhsminor.yy183;
+  yymsp[-1].minor.yy181 = yylhsminor.yy181;
         break;
-      case 130: /* tagitemlist ::= tagitemlist COMMA tagitem */
-{ yylhsminor.yy421 = tVariantListAppend(yymsp[-2].minor.yy421, &yymsp[0].minor.yy430, -1);    }
-  yymsp[-2].minor.yy421 = yylhsminor.yy421;
+      case 133: /* tagitemlist ::= tagitemlist COMMA tagitem */
+{ yylhsminor.yy135 = tVariantListAppend(yymsp[-2].minor.yy135, &yymsp[0].minor.yy308, -1);    }
+  yymsp[-2].minor.yy135 = yylhsminor.yy135;
         break;
-      case 131: /* tagitemlist ::= tagitem */
-{ yylhsminor.yy421 = tVariantListAppend(NULL, &yymsp[0].minor.yy430, -1); }
-  yymsp[0].minor.yy421 = yylhsminor.yy421;
+      case 134: /* tagitemlist ::= tagitem */
+{ yylhsminor.yy135 = tVariantListAppend(NULL, &yymsp[0].minor.yy308, -1); }
+  yymsp[0].minor.yy135 = yylhsminor.yy135;
         break;
-      case 132: /* tagitem ::= INTEGER */
-      case 133: /* tagitem ::= FLOAT */ yytestcase(yyruleno==133);
-      case 134: /* tagitem ::= STRING */ yytestcase(yyruleno==134);
-      case 135: /* tagitem ::= BOOL */ yytestcase(yyruleno==135);
-{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy430, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy430 = yylhsminor.yy430;
+      case 135: /* tagitem ::= INTEGER */
+      case 136: /* tagitem ::= FLOAT */ yytestcase(yyruleno==136);
+      case 137: /* tagitem ::= STRING */ yytestcase(yyruleno==137);
+      case 138: /* tagitem ::= BOOL */ yytestcase(yyruleno==138);
+{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy308, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy308 = yylhsminor.yy308;
         break;
-      case 136: /* tagitem ::= NULL */
-{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy430, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy430 = yylhsminor.yy430;
+      case 139: /* tagitem ::= NULL */
+{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy308, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy308 = yylhsminor.yy308;
         break;
-      case 137: /* tagitem ::= MINUS INTEGER */
-      case 138: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==138);
-      case 139: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==139);
-      case 140: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==140);
+      case 140: /* tagitem ::= MINUS INTEGER */
+      case 141: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==141);
+      case 142: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==142);
+      case 143: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==143);
 {
     yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
     yymsp[-1].minor.yy0.type = yymsp[0].minor.yy0.type;
     toTSDBType(yymsp[-1].minor.yy0.type);
-    tVariantCreate(&yylhsminor.yy430, &yymsp[-1].minor.yy0);
+    tVariantCreate(&yylhsminor.yy308, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy430 = yylhsminor.yy430;
+  yymsp[-1].minor.yy308 = yylhsminor.yy308;
         break;
-      case 141: /* select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
+      case 144: /* select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
 {
-  yylhsminor.yy148 = tSetQuerySqlElems(&yymsp[-11].minor.yy0, yymsp[-10].minor.yy166, yymsp[-9].minor.yy421, yymsp[-8].minor.yy78, yymsp[-4].minor.yy421, yymsp[-3].minor.yy421, &yymsp[-7].minor.yy400, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy421, &yymsp[0].minor.yy167, &yymsp[-1].minor.yy167);
+  yylhsminor.yy30 = tSetQuerySqlElems(&yymsp[-11].minor.yy0, yymsp[-10].minor.yy266, yymsp[-9].minor.yy135, yymsp[-8].minor.yy316, yymsp[-4].minor.yy135, yymsp[-3].minor.yy135, &yymsp[-7].minor.yy160, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy135, &yymsp[0].minor.yy126, &yymsp[-1].minor.yy126);
 }
-  yymsp[-11].minor.yy148 = yylhsminor.yy148;
+  yymsp[-11].minor.yy30 = yylhsminor.yy30;
         break;
-      case 142: /* union ::= select */
-{ yylhsminor.yy153 = setSubclause(NULL, yymsp[0].minor.yy148); }
+      case 145: /* union ::= select */
+{ yylhsminor.yy153 = setSubclause(NULL, yymsp[0].minor.yy30); }
   yymsp[0].minor.yy153 = yylhsminor.yy153;
         break;
-      case 143: /* union ::= LP union RP */
+      case 146: /* union ::= LP union RP */
 { yymsp[-2].minor.yy153 = yymsp[-1].minor.yy153; }
         break;
-      case 144: /* union ::= union UNION ALL select */
-{ yylhsminor.yy153 = appendSelectClause(yymsp[-3].minor.yy153, yymsp[0].minor.yy148); }
+      case 147: /* union ::= union UNION ALL select */
+{ yylhsminor.yy153 = appendSelectClause(yymsp[-3].minor.yy153, yymsp[0].minor.yy30); }
   yymsp[-3].minor.yy153 = yylhsminor.yy153;
         break;
-      case 145: /* union ::= union UNION ALL LP select RP */
-{ yylhsminor.yy153 = appendSelectClause(yymsp[-5].minor.yy153, yymsp[-1].minor.yy148); }
+      case 148: /* union ::= union UNION ALL LP select RP */
+{ yylhsminor.yy153 = appendSelectClause(yymsp[-5].minor.yy153, yymsp[-1].minor.yy30); }
   yymsp[-5].minor.yy153 = yylhsminor.yy153;
         break;
-      case 146: /* cmd ::= union */
+      case 149: /* cmd ::= union */
 { setSqlInfo(pInfo, yymsp[0].minor.yy153, NULL, TSDB_SQL_SELECT); }
         break;
-      case 147: /* select ::= SELECT selcollist */
+      case 150: /* select ::= SELECT selcollist */
 {
-  yylhsminor.yy148 = tSetQuerySqlElems(&yymsp[-1].minor.yy0, yymsp[0].minor.yy166, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+  yylhsminor.yy30 = tSetQuerySqlElems(&yymsp[-1].minor.yy0, yymsp[0].minor.yy266, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
-  yymsp[-1].minor.yy148 = yylhsminor.yy148;
+  yymsp[-1].minor.yy30 = yylhsminor.yy30;
         break;
-      case 148: /* sclp ::= selcollist COMMA */
-{yylhsminor.yy166 = yymsp[-1].minor.yy166;}
-  yymsp[-1].minor.yy166 = yylhsminor.yy166;
+      case 151: /* sclp ::= selcollist COMMA */
+{yylhsminor.yy266 = yymsp[-1].minor.yy266;}
+  yymsp[-1].minor.yy266 = yylhsminor.yy266;
         break;
-      case 149: /* sclp ::= */
-{yymsp[1].minor.yy166 = 0;}
+      case 152: /* sclp ::= */
+{yymsp[1].minor.yy266 = 0;}
         break;
-      case 150: /* selcollist ::= sclp expr as */
+      case 153: /* selcollist ::= sclp expr as */
 {
-   yylhsminor.yy166 = tSqlExprListAppend(yymsp[-2].minor.yy166, yymsp[-1].minor.yy78, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
+   yylhsminor.yy266 = tSqlExprListAppend(yymsp[-2].minor.yy266, yymsp[-1].minor.yy316, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
 }
-  yymsp[-2].minor.yy166 = yylhsminor.yy166;
+  yymsp[-2].minor.yy266 = yylhsminor.yy266;
         break;
-      case 151: /* selcollist ::= sclp STAR */
+      case 154: /* selcollist ::= sclp STAR */
 {
    tSQLExpr *pNode = tSqlExprIdValueCreate(NULL, TK_ALL);
-   yylhsminor.yy166 = tSqlExprListAppend(yymsp[-1].minor.yy166, pNode, 0);
+   yylhsminor.yy266 = tSqlExprListAppend(yymsp[-1].minor.yy266, pNode, 0);
 }
-  yymsp[-1].minor.yy166 = yylhsminor.yy166;
+  yymsp[-1].minor.yy266 = yylhsminor.yy266;
         break;
-      case 152: /* as ::= AS ids */
+      case 155: /* as ::= AS ids */
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;    }
         break;
-      case 153: /* as ::= ids */
+      case 156: /* as ::= ids */
 { yylhsminor.yy0 = yymsp[0].minor.yy0;    }
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 154: /* as ::= */
+      case 157: /* as ::= */
 { yymsp[1].minor.yy0.n = 0;  }
         break;
-      case 155: /* from ::= FROM tablelist */
-{yymsp[-1].minor.yy421 = yymsp[0].minor.yy421;}
+      case 158: /* from ::= FROM tablelist */
+{yymsp[-1].minor.yy135 = yymsp[0].minor.yy135;}
         break;
-      case 156: /* tablelist ::= ids cpxName */
+      case 159: /* tablelist ::= ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
-  yylhsminor.yy421 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
-  yylhsminor.yy421 = tVariantListAppendToken(yylhsminor.yy421, &yymsp[-1].minor.yy0, -1);  // table alias name
+  yylhsminor.yy135 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
+  yylhsminor.yy135 = tVariantListAppendToken(yylhsminor.yy135, &yymsp[-1].minor.yy0, -1);  // table alias name
 }
-  yymsp[-1].minor.yy421 = yylhsminor.yy421;
+  yymsp[-1].minor.yy135 = yylhsminor.yy135;
         break;
-      case 157: /* tablelist ::= ids cpxName ids */
+      case 160: /* tablelist ::= ids cpxName ids */
 {
   toTSDBType(yymsp[-2].minor.yy0.type);
   toTSDBType(yymsp[0].minor.yy0.type);
   yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
-  yylhsminor.yy421 = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
-  yylhsminor.yy421 = tVariantListAppendToken(yylhsminor.yy421, &yymsp[0].minor.yy0, -1);
+  yylhsminor.yy135 = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
+  yylhsminor.yy135 = tVariantListAppendToken(yylhsminor.yy135, &yymsp[0].minor.yy0, -1);
 }
-  yymsp[-2].minor.yy421 = yylhsminor.yy421;
+  yymsp[-2].minor.yy135 = yylhsminor.yy135;
         break;
-      case 158: /* tablelist ::= tablelist COMMA ids cpxName */
+      case 161: /* tablelist ::= tablelist COMMA ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
-  yylhsminor.yy421 = tVariantListAppendToken(yymsp[-3].minor.yy421, &yymsp[-1].minor.yy0, -1);
-  yylhsminor.yy421 = tVariantListAppendToken(yylhsminor.yy421, &yymsp[-1].minor.yy0, -1);
+  yylhsminor.yy135 = tVariantListAppendToken(yymsp[-3].minor.yy135, &yymsp[-1].minor.yy0, -1);
+  yylhsminor.yy135 = tVariantListAppendToken(yylhsminor.yy135, &yymsp[-1].minor.yy0, -1);
 }
-  yymsp[-3].minor.yy421 = yylhsminor.yy421;
+  yymsp[-3].minor.yy135 = yylhsminor.yy135;
         break;
-      case 159: /* tablelist ::= tablelist COMMA ids cpxName ids */
+      case 162: /* tablelist ::= tablelist COMMA ids cpxName ids */
 {
   toTSDBType(yymsp[-2].minor.yy0.type);
   toTSDBType(yymsp[0].minor.yy0.type);
   yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
-  yylhsminor.yy421 = tVariantListAppendToken(yymsp[-4].minor.yy421, &yymsp[-2].minor.yy0, -1);
-  yylhsminor.yy421 = tVariantListAppendToken(yylhsminor.yy421, &yymsp[0].minor.yy0, -1);
+  yylhsminor.yy135 = tVariantListAppendToken(yymsp[-4].minor.yy135, &yymsp[-2].minor.yy0, -1);
+  yylhsminor.yy135 = tVariantListAppendToken(yylhsminor.yy135, &yymsp[0].minor.yy0, -1);
 }
-  yymsp[-4].minor.yy421 = yylhsminor.yy421;
+  yymsp[-4].minor.yy135 = yylhsminor.yy135;
         break;
-      case 160: /* tmvar ::= VARIABLE */
+      case 163: /* tmvar ::= VARIABLE */
 {yylhsminor.yy0 = yymsp[0].minor.yy0;}
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 161: /* interval_opt ::= INTERVAL LP tmvar RP */
-{yymsp[-3].minor.yy400.interval = yymsp[-1].minor.yy0; yymsp[-3].minor.yy400.offset.n = 0; yymsp[-3].minor.yy400.offset.z = NULL; yymsp[-3].minor.yy400.offset.type = 0;}
+      case 164: /* interval_opt ::= INTERVAL LP tmvar RP */
+{yymsp[-3].minor.yy160.interval = yymsp[-1].minor.yy0; yymsp[-3].minor.yy160.offset.n = 0; yymsp[-3].minor.yy160.offset.z = NULL; yymsp[-3].minor.yy160.offset.type = 0;}
         break;
-      case 162: /* interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
-{yymsp[-5].minor.yy400.interval = yymsp[-3].minor.yy0; yymsp[-5].minor.yy400.offset = yymsp[-1].minor.yy0;}
+      case 165: /* interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
+{yymsp[-5].minor.yy160.interval = yymsp[-3].minor.yy0; yymsp[-5].minor.yy160.offset = yymsp[-1].minor.yy0;}
         break;
-      case 163: /* interval_opt ::= */
-{memset(&yymsp[1].minor.yy400, 0, sizeof(yymsp[1].minor.yy400));}
+      case 166: /* interval_opt ::= */
+{memset(&yymsp[1].minor.yy160, 0, sizeof(yymsp[1].minor.yy160));}
         break;
-      case 164: /* fill_opt ::= */
-{yymsp[1].minor.yy421 = 0;     }
+      case 167: /* fill_opt ::= */
+{yymsp[1].minor.yy135 = 0;     }
         break;
-      case 165: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+      case 168: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
 {
     tVariant A = {0};
     toTSDBType(yymsp[-3].minor.yy0.type);
     tVariantCreate(&A, &yymsp[-3].minor.yy0);
 
-    tVariantListInsert(yymsp[-1].minor.yy421, &A, -1, 0);
-    yymsp[-5].minor.yy421 = yymsp[-1].minor.yy421;
+    tVariantListInsert(yymsp[-1].minor.yy135, &A, -1, 0);
+    yymsp[-5].minor.yy135 = yymsp[-1].minor.yy135;
 }
         break;
-      case 166: /* fill_opt ::= FILL LP ID RP */
+      case 169: /* fill_opt ::= FILL LP ID RP */
 {
     toTSDBType(yymsp[-1].minor.yy0.type);
-    yymsp[-3].minor.yy421 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
+    yymsp[-3].minor.yy135 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
 }
         break;
-      case 167: /* sliding_opt ::= SLIDING LP tmvar RP */
+      case 170: /* sliding_opt ::= SLIDING LP tmvar RP */
 {yymsp[-3].minor.yy0 = yymsp[-1].minor.yy0;     }
         break;
-      case 168: /* sliding_opt ::= */
+      case 171: /* sliding_opt ::= */
 {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0;   }
         break;
-      case 169: /* orderby_opt ::= */
-{yymsp[1].minor.yy421 = 0;}
+      case 172: /* orderby_opt ::= */
+{yymsp[1].minor.yy135 = 0;}
         break;
-      case 170: /* orderby_opt ::= ORDER BY sortlist */
-{yymsp[-2].minor.yy421 = yymsp[0].minor.yy421;}
+      case 173: /* orderby_opt ::= ORDER BY sortlist */
+{yymsp[-2].minor.yy135 = yymsp[0].minor.yy135;}
         break;
-      case 171: /* sortlist ::= sortlist COMMA item sortorder */
+      case 174: /* sortlist ::= sortlist COMMA item sortorder */
 {
-    yylhsminor.yy421 = tVariantListAppend(yymsp[-3].minor.yy421, &yymsp[-1].minor.yy430, yymsp[0].minor.yy96);
+    yylhsminor.yy135 = tVariantListAppend(yymsp[-3].minor.yy135, &yymsp[-1].minor.yy308, yymsp[0].minor.yy130);
 }
-  yymsp[-3].minor.yy421 = yylhsminor.yy421;
+  yymsp[-3].minor.yy135 = yylhsminor.yy135;
         break;
-      case 172: /* sortlist ::= item sortorder */
+      case 175: /* sortlist ::= item sortorder */
 {
-  yylhsminor.yy421 = tVariantListAppend(NULL, &yymsp[-1].minor.yy430, yymsp[0].minor.yy96);
+  yylhsminor.yy135 = tVariantListAppend(NULL, &yymsp[-1].minor.yy308, yymsp[0].minor.yy130);
 }
-  yymsp[-1].minor.yy421 = yylhsminor.yy421;
+  yymsp[-1].minor.yy135 = yylhsminor.yy135;
         break;
-      case 173: /* item ::= ids cpxName */
+      case 176: /* item ::= ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
 
-  tVariantCreate(&yylhsminor.yy430, &yymsp[-1].minor.yy0);
+  tVariantCreate(&yylhsminor.yy308, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy430 = yylhsminor.yy430;
+  yymsp[-1].minor.yy308 = yylhsminor.yy308;
         break;
-      case 174: /* sortorder ::= ASC */
-{ yymsp[0].minor.yy96 = TSDB_ORDER_ASC; }
+      case 177: /* sortorder ::= ASC */
+{ yymsp[0].minor.yy130 = TSDB_ORDER_ASC; }
         break;
-      case 175: /* sortorder ::= DESC */
-{ yymsp[0].minor.yy96 = TSDB_ORDER_DESC;}
+      case 178: /* sortorder ::= DESC */
+{ yymsp[0].minor.yy130 = TSDB_ORDER_DESC;}
         break;
-      case 176: /* sortorder ::= */
-{ yymsp[1].minor.yy96 = TSDB_ORDER_ASC; }
+      case 179: /* sortorder ::= */
+{ yymsp[1].minor.yy130 = TSDB_ORDER_ASC; }
         break;
-      case 177: /* groupby_opt ::= */
-{ yymsp[1].minor.yy421 = 0;}
+      case 180: /* groupby_opt ::= */
+{ yymsp[1].minor.yy135 = 0;}
         break;
-      case 178: /* groupby_opt ::= GROUP BY grouplist */
-{ yymsp[-2].minor.yy421 = yymsp[0].minor.yy421;}
+      case 181: /* groupby_opt ::= GROUP BY grouplist */
+{ yymsp[-2].minor.yy135 = yymsp[0].minor.yy135;}
         break;
-      case 179: /* grouplist ::= grouplist COMMA item */
+      case 182: /* grouplist ::= grouplist COMMA item */
 {
-  yylhsminor.yy421 = tVariantListAppend(yymsp[-2].minor.yy421, &yymsp[0].minor.yy430, -1);
+  yylhsminor.yy135 = tVariantListAppend(yymsp[-2].minor.yy135, &yymsp[0].minor.yy308, -1);
 }
-  yymsp[-2].minor.yy421 = yylhsminor.yy421;
+  yymsp[-2].minor.yy135 = yylhsminor.yy135;
         break;
-      case 180: /* grouplist ::= item */
+      case 183: /* grouplist ::= item */
 {
-  yylhsminor.yy421 = tVariantListAppend(NULL, &yymsp[0].minor.yy430, -1);
+  yylhsminor.yy135 = tVariantListAppend(NULL, &yymsp[0].minor.yy308, -1);
 }
-  yymsp[0].minor.yy421 = yylhsminor.yy421;
+  yymsp[0].minor.yy135 = yylhsminor.yy135;
         break;
-      case 181: /* having_opt ::= */
-      case 191: /* where_opt ::= */ yytestcase(yyruleno==191);
-      case 229: /* expritem ::= */ yytestcase(yyruleno==229);
-{yymsp[1].minor.yy78 = 0;}
+      case 184: /* having_opt ::= */
+      case 194: /* where_opt ::= */ yytestcase(yyruleno==194);
+      case 232: /* expritem ::= */ yytestcase(yyruleno==232);
+{yymsp[1].minor.yy316 = 0;}
         break;
-      case 182: /* having_opt ::= HAVING expr */
-      case 192: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==192);
-{yymsp[-1].minor.yy78 = yymsp[0].minor.yy78;}
+      case 185: /* having_opt ::= HAVING expr */
+      case 195: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==195);
+{yymsp[-1].minor.yy316 = yymsp[0].minor.yy316;}
         break;
-      case 183: /* limit_opt ::= */
-      case 187: /* slimit_opt ::= */ yytestcase(yyruleno==187);
-{yymsp[1].minor.yy167.limit = -1; yymsp[1].minor.yy167.offset = 0;}
+      case 186: /* limit_opt ::= */
+      case 190: /* slimit_opt ::= */ yytestcase(yyruleno==190);
+{yymsp[1].minor.yy126.limit = -1; yymsp[1].minor.yy126.offset = 0;}
         break;
-      case 184: /* limit_opt ::= LIMIT signed */
-      case 188: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==188);
-{yymsp[-1].minor.yy167.limit = yymsp[0].minor.yy325;  yymsp[-1].minor.yy167.offset = 0;}
+      case 187: /* limit_opt ::= LIMIT signed */
+      case 191: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==191);
+{yymsp[-1].minor.yy126.limit = yymsp[0].minor.yy531;  yymsp[-1].minor.yy126.offset = 0;}
         break;
-      case 185: /* limit_opt ::= LIMIT signed OFFSET signed */
-{ yymsp[-3].minor.yy167.limit = yymsp[-2].minor.yy325;  yymsp[-3].minor.yy167.offset = yymsp[0].minor.yy325;}
+      case 188: /* limit_opt ::= LIMIT signed OFFSET signed */
+{ yymsp[-3].minor.yy126.limit = yymsp[-2].minor.yy531;  yymsp[-3].minor.yy126.offset = yymsp[0].minor.yy531;}
         break;
-      case 186: /* limit_opt ::= LIMIT signed COMMA signed */
-{ yymsp[-3].minor.yy167.limit = yymsp[0].minor.yy325;  yymsp[-3].minor.yy167.offset = yymsp[-2].minor.yy325;}
+      case 189: /* limit_opt ::= LIMIT signed COMMA signed */
+{ yymsp[-3].minor.yy126.limit = yymsp[0].minor.yy531;  yymsp[-3].minor.yy126.offset = yymsp[-2].minor.yy531;}
         break;
-      case 189: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
-{yymsp[-3].minor.yy167.limit = yymsp[-2].minor.yy325;  yymsp[-3].minor.yy167.offset = yymsp[0].minor.yy325;}
+      case 192: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
+{yymsp[-3].minor.yy126.limit = yymsp[-2].minor.yy531;  yymsp[-3].minor.yy126.offset = yymsp[0].minor.yy531;}
         break;
-      case 190: /* slimit_opt ::= SLIMIT signed COMMA signed */
-{yymsp[-3].minor.yy167.limit = yymsp[0].minor.yy325;  yymsp[-3].minor.yy167.offset = yymsp[-2].minor.yy325;}
+      case 193: /* slimit_opt ::= SLIMIT signed COMMA signed */
+{yymsp[-3].minor.yy126.limit = yymsp[0].minor.yy531;  yymsp[-3].minor.yy126.offset = yymsp[-2].minor.yy531;}
         break;
-      case 193: /* expr ::= LP expr RP */
-{yylhsminor.yy78 = yymsp[-1].minor.yy78; yylhsminor.yy78->token.z = yymsp[-2].minor.yy0.z; yylhsminor.yy78->token.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
-  yymsp[-2].minor.yy78 = yylhsminor.yy78;
+      case 196: /* expr ::= LP expr RP */
+{yylhsminor.yy316 = yymsp[-1].minor.yy316; yylhsminor.yy316->token.z = yymsp[-2].minor.yy0.z; yylhsminor.yy316->token.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
+  yymsp[-2].minor.yy316 = yylhsminor.yy316;
         break;
-      case 194: /* expr ::= ID */
-{ yylhsminor.yy78 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_ID);}
-  yymsp[0].minor.yy78 = yylhsminor.yy78;
+      case 197: /* expr ::= ID */
+{ yylhsminor.yy316 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_ID);}
+  yymsp[0].minor.yy316 = yylhsminor.yy316;
         break;
-      case 195: /* expr ::= ID DOT ID */
-{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy78 = tSqlExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ID);}
-  yymsp[-2].minor.yy78 = yylhsminor.yy78;
+      case 198: /* expr ::= ID DOT ID */
+{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy316 = tSqlExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ID);}
+  yymsp[-2].minor.yy316 = yylhsminor.yy316;
         break;
-      case 196: /* expr ::= ID DOT STAR */
-{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy78 = tSqlExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ALL);}
-  yymsp[-2].minor.yy78 = yylhsminor.yy78;
+      case 199: /* expr ::= ID DOT STAR */
+{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy316 = tSqlExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ALL);}
+  yymsp[-2].minor.yy316 = yylhsminor.yy316;
         break;
-      case 197: /* expr ::= INTEGER */
-{ yylhsminor.yy78 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_INTEGER);}
-  yymsp[0].minor.yy78 = yylhsminor.yy78;
+      case 200: /* expr ::= INTEGER */
+{ yylhsminor.yy316 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_INTEGER);}
+  yymsp[0].minor.yy316 = yylhsminor.yy316;
         break;
-      case 198: /* expr ::= MINUS INTEGER */
-      case 199: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==199);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy78 = tSqlExprIdValueCreate(&yymsp[-1].minor.yy0, TK_INTEGER);}
-  yymsp[-1].minor.yy78 = yylhsminor.yy78;
+      case 201: /* expr ::= MINUS INTEGER */
+      case 202: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==202);
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy316 = tSqlExprIdValueCreate(&yymsp[-1].minor.yy0, TK_INTEGER);}
+  yymsp[-1].minor.yy316 = yylhsminor.yy316;
         break;
-      case 200: /* expr ::= FLOAT */
-{ yylhsminor.yy78 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_FLOAT);}
-  yymsp[0].minor.yy78 = yylhsminor.yy78;
+      case 203: /* expr ::= FLOAT */
+{ yylhsminor.yy316 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_FLOAT);}
+  yymsp[0].minor.yy316 = yylhsminor.yy316;
         break;
-      case 201: /* expr ::= MINUS FLOAT */
-      case 202: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==202);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy78 = tSqlExprIdValueCreate(&yymsp[-1].minor.yy0, TK_FLOAT);}
-  yymsp[-1].minor.yy78 = yylhsminor.yy78;
+      case 204: /* expr ::= MINUS FLOAT */
+      case 205: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==205);
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy316 = tSqlExprIdValueCreate(&yymsp[-1].minor.yy0, TK_FLOAT);}
+  yymsp[-1].minor.yy316 = yylhsminor.yy316;
         break;
-      case 203: /* expr ::= STRING */
-{ yylhsminor.yy78 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_STRING);}
-  yymsp[0].minor.yy78 = yylhsminor.yy78;
+      case 206: /* expr ::= STRING */
+{ yylhsminor.yy316 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_STRING);}
+  yymsp[0].minor.yy316 = yylhsminor.yy316;
         break;
-      case 204: /* expr ::= NOW */
-{ yylhsminor.yy78 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_NOW); }
-  yymsp[0].minor.yy78 = yylhsminor.yy78;
+      case 207: /* expr ::= NOW */
+{ yylhsminor.yy316 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_NOW); }
+  yymsp[0].minor.yy316 = yylhsminor.yy316;
         break;
-      case 205: /* expr ::= VARIABLE */
-{ yylhsminor.yy78 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_VARIABLE);}
-  yymsp[0].minor.yy78 = yylhsminor.yy78;
+      case 208: /* expr ::= VARIABLE */
+{ yylhsminor.yy316 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_VARIABLE);}
+  yymsp[0].minor.yy316 = yylhsminor.yy316;
         break;
-      case 206: /* expr ::= BOOL */
-{ yylhsminor.yy78 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_BOOL);}
-  yymsp[0].minor.yy78 = yylhsminor.yy78;
+      case 209: /* expr ::= BOOL */
+{ yylhsminor.yy316 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_BOOL);}
+  yymsp[0].minor.yy316 = yylhsminor.yy316;
         break;
-      case 207: /* expr ::= ID LP exprlist RP */
-{ yylhsminor.yy78 = tSqlExprCreateFunction(yymsp[-1].minor.yy166, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
-  yymsp[-3].minor.yy78 = yylhsminor.yy78;
+      case 210: /* expr ::= ID LP exprlist RP */
+{ yylhsminor.yy316 = tSqlExprCreateFunction(yymsp[-1].minor.yy266, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
+  yymsp[-3].minor.yy316 = yylhsminor.yy316;
         break;
-      case 208: /* expr ::= ID LP STAR RP */
-{ yylhsminor.yy78 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
-  yymsp[-3].minor.yy78 = yylhsminor.yy78;
+      case 211: /* expr ::= ID LP STAR RP */
+{ yylhsminor.yy316 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
+  yymsp[-3].minor.yy316 = yylhsminor.yy316;
         break;
-      case 209: /* expr ::= expr IS NULL */
-{yylhsminor.yy78 = tSqlExprCreate(yymsp[-2].minor.yy78, NULL, TK_ISNULL);}
-  yymsp[-2].minor.yy78 = yylhsminor.yy78;
+      case 212: /* expr ::= expr IS NULL */
+{yylhsminor.yy316 = tSqlExprCreate(yymsp[-2].minor.yy316, NULL, TK_ISNULL);}
+  yymsp[-2].minor.yy316 = yylhsminor.yy316;
         break;
-      case 210: /* expr ::= expr IS NOT NULL */
-{yylhsminor.yy78 = tSqlExprCreate(yymsp[-3].minor.yy78, NULL, TK_NOTNULL);}
-  yymsp[-3].minor.yy78 = yylhsminor.yy78;
+      case 213: /* expr ::= expr IS NOT NULL */
+{yylhsminor.yy316 = tSqlExprCreate(yymsp[-3].minor.yy316, NULL, TK_NOTNULL);}
+  yymsp[-3].minor.yy316 = yylhsminor.yy316;
         break;
-      case 211: /* expr ::= expr LT expr */
-{yylhsminor.yy78 = tSqlExprCreate(yymsp[-2].minor.yy78, yymsp[0].minor.yy78, TK_LT);}
-  yymsp[-2].minor.yy78 = yylhsminor.yy78;
+      case 214: /* expr ::= expr LT expr */
+{yylhsminor.yy316 = tSqlExprCreate(yymsp[-2].minor.yy316, yymsp[0].minor.yy316, TK_LT);}
+  yymsp[-2].minor.yy316 = yylhsminor.yy316;
         break;
-      case 212: /* expr ::= expr GT expr */
-{yylhsminor.yy78 = tSqlExprCreate(yymsp[-2].minor.yy78, yymsp[0].minor.yy78, TK_GT);}
-  yymsp[-2].minor.yy78 = yylhsminor.yy78;
+      case 215: /* expr ::= expr GT expr */
+{yylhsminor.yy316 = tSqlExprCreate(yymsp[-2].minor.yy316, yymsp[0].minor.yy316, TK_GT);}
+  yymsp[-2].minor.yy316 = yylhsminor.yy316;
         break;
-      case 213: /* expr ::= expr LE expr */
-{yylhsminor.yy78 = tSqlExprCreate(yymsp[-2].minor.yy78, yymsp[0].minor.yy78, TK_LE);}
-  yymsp[-2].minor.yy78 = yylhsminor.yy78;
+      case 216: /* expr ::= expr LE expr */
+{yylhsminor.yy316 = tSqlExprCreate(yymsp[-2].minor.yy316, yymsp[0].minor.yy316, TK_LE);}
+  yymsp[-2].minor.yy316 = yylhsminor.yy316;
         break;
-      case 214: /* expr ::= expr GE expr */
-{yylhsminor.yy78 = tSqlExprCreate(yymsp[-2].minor.yy78, yymsp[0].minor.yy78, TK_GE);}
-  yymsp[-2].minor.yy78 = yylhsminor.yy78;
+      case 217: /* expr ::= expr GE expr */
+{yylhsminor.yy316 = tSqlExprCreate(yymsp[-2].minor.yy316, yymsp[0].minor.yy316, TK_GE);}
+  yymsp[-2].minor.yy316 = yylhsminor.yy316;
         break;
-      case 215: /* expr ::= expr NE expr */
-{yylhsminor.yy78 = tSqlExprCreate(yymsp[-2].minor.yy78, yymsp[0].minor.yy78, TK_NE);}
-  yymsp[-2].minor.yy78 = yylhsminor.yy78;
+      case 218: /* expr ::= expr NE expr */
+{yylhsminor.yy316 = tSqlExprCreate(yymsp[-2].minor.yy316, yymsp[0].minor.yy316, TK_NE);}
+  yymsp[-2].minor.yy316 = yylhsminor.yy316;
         break;
-      case 216: /* expr ::= expr EQ expr */
-{yylhsminor.yy78 = tSqlExprCreate(yymsp[-2].minor.yy78, yymsp[0].minor.yy78, TK_EQ);}
-  yymsp[-2].minor.yy78 = yylhsminor.yy78;
+      case 219: /* expr ::= expr EQ expr */
+{yylhsminor.yy316 = tSqlExprCreate(yymsp[-2].minor.yy316, yymsp[0].minor.yy316, TK_EQ);}
+  yymsp[-2].minor.yy316 = yylhsminor.yy316;
         break;
-      case 217: /* expr ::= expr AND expr */
-{yylhsminor.yy78 = tSqlExprCreate(yymsp[-2].minor.yy78, yymsp[0].minor.yy78, TK_AND);}
-  yymsp[-2].minor.yy78 = yylhsminor.yy78;
+      case 220: /* expr ::= expr AND expr */
+{yylhsminor.yy316 = tSqlExprCreate(yymsp[-2].minor.yy316, yymsp[0].minor.yy316, TK_AND);}
+  yymsp[-2].minor.yy316 = yylhsminor.yy316;
         break;
-      case 218: /* expr ::= expr OR expr */
-{yylhsminor.yy78 = tSqlExprCreate(yymsp[-2].minor.yy78, yymsp[0].minor.yy78, TK_OR); }
-  yymsp[-2].minor.yy78 = yylhsminor.yy78;
+      case 221: /* expr ::= expr OR expr */
+{yylhsminor.yy316 = tSqlExprCreate(yymsp[-2].minor.yy316, yymsp[0].minor.yy316, TK_OR); }
+  yymsp[-2].minor.yy316 = yylhsminor.yy316;
         break;
-      case 219: /* expr ::= expr PLUS expr */
-{yylhsminor.yy78 = tSqlExprCreate(yymsp[-2].minor.yy78, yymsp[0].minor.yy78, TK_PLUS);  }
-  yymsp[-2].minor.yy78 = yylhsminor.yy78;
+      case 222: /* expr ::= expr PLUS expr */
+{yylhsminor.yy316 = tSqlExprCreate(yymsp[-2].minor.yy316, yymsp[0].minor.yy316, TK_PLUS);  }
+  yymsp[-2].minor.yy316 = yylhsminor.yy316;
         break;
-      case 220: /* expr ::= expr MINUS expr */
-{yylhsminor.yy78 = tSqlExprCreate(yymsp[-2].minor.yy78, yymsp[0].minor.yy78, TK_MINUS); }
-  yymsp[-2].minor.yy78 = yylhsminor.yy78;
+      case 223: /* expr ::= expr MINUS expr */
+{yylhsminor.yy316 = tSqlExprCreate(yymsp[-2].minor.yy316, yymsp[0].minor.yy316, TK_MINUS); }
+  yymsp[-2].minor.yy316 = yylhsminor.yy316;
         break;
-      case 221: /* expr ::= expr STAR expr */
-{yylhsminor.yy78 = tSqlExprCreate(yymsp[-2].minor.yy78, yymsp[0].minor.yy78, TK_STAR);  }
-  yymsp[-2].minor.yy78 = yylhsminor.yy78;
+      case 224: /* expr ::= expr STAR expr */
+{yylhsminor.yy316 = tSqlExprCreate(yymsp[-2].minor.yy316, yymsp[0].minor.yy316, TK_STAR);  }
+  yymsp[-2].minor.yy316 = yylhsminor.yy316;
         break;
-      case 222: /* expr ::= expr SLASH expr */
-{yylhsminor.yy78 = tSqlExprCreate(yymsp[-2].minor.yy78, yymsp[0].minor.yy78, TK_DIVIDE);}
-  yymsp[-2].minor.yy78 = yylhsminor.yy78;
+      case 225: /* expr ::= expr SLASH expr */
+{yylhsminor.yy316 = tSqlExprCreate(yymsp[-2].minor.yy316, yymsp[0].minor.yy316, TK_DIVIDE);}
+  yymsp[-2].minor.yy316 = yylhsminor.yy316;
         break;
-      case 223: /* expr ::= expr REM expr */
-{yylhsminor.yy78 = tSqlExprCreate(yymsp[-2].minor.yy78, yymsp[0].minor.yy78, TK_REM);   }
-  yymsp[-2].minor.yy78 = yylhsminor.yy78;
+      case 226: /* expr ::= expr REM expr */
+{yylhsminor.yy316 = tSqlExprCreate(yymsp[-2].minor.yy316, yymsp[0].minor.yy316, TK_REM);   }
+  yymsp[-2].minor.yy316 = yylhsminor.yy316;
         break;
-      case 224: /* expr ::= expr LIKE expr */
-{yylhsminor.yy78 = tSqlExprCreate(yymsp[-2].minor.yy78, yymsp[0].minor.yy78, TK_LIKE);  }
-  yymsp[-2].minor.yy78 = yylhsminor.yy78;
+      case 227: /* expr ::= expr LIKE expr */
+{yylhsminor.yy316 = tSqlExprCreate(yymsp[-2].minor.yy316, yymsp[0].minor.yy316, TK_LIKE);  }
+  yymsp[-2].minor.yy316 = yylhsminor.yy316;
         break;
-      case 225: /* expr ::= expr IN LP exprlist RP */
-{yylhsminor.yy78 = tSqlExprCreate(yymsp[-4].minor.yy78, (tSQLExpr*)yymsp[-1].minor.yy166, TK_IN); }
-  yymsp[-4].minor.yy78 = yylhsminor.yy78;
+      case 228: /* expr ::= expr IN LP exprlist RP */
+{yylhsminor.yy316 = tSqlExprCreate(yymsp[-4].minor.yy316, (tSQLExpr*)yymsp[-1].minor.yy266, TK_IN); }
+  yymsp[-4].minor.yy316 = yylhsminor.yy316;
         break;
-      case 226: /* exprlist ::= exprlist COMMA expritem */
-{yylhsminor.yy166 = tSqlExprListAppend(yymsp[-2].minor.yy166,yymsp[0].minor.yy78,0);}
-  yymsp[-2].minor.yy166 = yylhsminor.yy166;
+      case 229: /* exprlist ::= exprlist COMMA expritem */
+{yylhsminor.yy266 = tSqlExprListAppend(yymsp[-2].minor.yy266,yymsp[0].minor.yy316,0);}
+  yymsp[-2].minor.yy266 = yylhsminor.yy266;
         break;
-      case 227: /* exprlist ::= expritem */
-{yylhsminor.yy166 = tSqlExprListAppend(0,yymsp[0].minor.yy78,0);}
-  yymsp[0].minor.yy166 = yylhsminor.yy166;
+      case 230: /* exprlist ::= expritem */
+{yylhsminor.yy266 = tSqlExprListAppend(0,yymsp[0].minor.yy316,0);}
+  yymsp[0].minor.yy266 = yylhsminor.yy266;
         break;
-      case 228: /* expritem ::= expr */
-{yylhsminor.yy78 = yymsp[0].minor.yy78;}
-  yymsp[0].minor.yy78 = yylhsminor.yy78;
+      case 231: /* expritem ::= expr */
+{yylhsminor.yy316 = yymsp[0].minor.yy316;}
+  yymsp[0].minor.yy316 = yylhsminor.yy316;
         break;
-      case 230: /* cmd ::= RESET QUERY CACHE */
+      case 233: /* cmd ::= RESET QUERY CACHE */
 { setDCLSQLElems(pInfo, TSDB_SQL_RESET_CACHE, 0);}
         break;
-      case 231: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+      case 234: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy421, NULL, TSDB_ALTER_TABLE_ADD_COLUMN);
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy135, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 232: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+      case 235: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
     toTSDBType(yymsp[0].minor.yy0.type);
     SArray* K = tVariantListAppendToken(NULL, &yymsp[0].minor.yy0, -1);
 
-    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, NULL, K, TSDB_ALTER_TABLE_DROP_COLUMN);
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, NULL, K, TSDB_ALTER_TABLE_DROP_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 233: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+      case 236: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy421, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN);
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy135, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 234: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+      case 237: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
     toTSDBType(yymsp[0].minor.yy0.type);
     SArray* A = tVariantListAppendToken(NULL, &yymsp[0].minor.yy0, -1);
 
-    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, NULL, A, TSDB_ALTER_TABLE_DROP_TAG_COLUMN);
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, NULL, A, TSDB_ALTER_TABLE_DROP_TAG_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 235: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+      case 238: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
 {
     yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
 
@@ -2908,29 +2950,79 @@ static void yy_reduce(
     toTSDBType(yymsp[0].minor.yy0.type);
     A = tVariantListAppendToken(A, &yymsp[0].minor.yy0, -1);
 
-    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-5].minor.yy0, NULL, A, TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN);
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-5].minor.yy0, NULL, A, TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 236: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+      case 239: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
 {
     yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n;
 
     toTSDBType(yymsp[-2].minor.yy0.type);
     SArray* A = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
-    A = tVariantListAppend(A, &yymsp[0].minor.yy430, -1);
+    A = tVariantListAppend(A, &yymsp[0].minor.yy308, -1);
+
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, -1);
+    setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
+}
+        break;
+      case 240: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
+{
+    yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy135, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE);
+    setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
+}
+        break;
+      case 241: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
+{
+    yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
+
+    toTSDBType(yymsp[0].minor.yy0.type);
+    SArray* K = tVariantListAppendToken(NULL, &yymsp[0].minor.yy0, -1);
+
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, NULL, K, TSDB_ALTER_TABLE_DROP_COLUMN, TSDB_SUPER_TABLE);
+    setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
+}
+        break;
+      case 242: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
+{
+    yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy135, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE);
+    setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
+}
+        break;
+      case 243: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
+{
+    yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
+
+    toTSDBType(yymsp[0].minor.yy0.type);
+    SArray* A = tVariantListAppendToken(NULL, &yymsp[0].minor.yy0, -1);
+
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, NULL, A, TSDB_ALTER_TABLE_DROP_TAG_COLUMN, TSDB_SUPER_TABLE);
+    setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
+}
+        break;
+      case 244: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
+{
+    yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
+
+    toTSDBType(yymsp[-1].minor.yy0.type);
+    SArray* A = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
+
+    toTSDBType(yymsp[0].minor.yy0.type);
+    A = tVariantListAppendToken(A, &yymsp[0].minor.yy0, -1);
 
-    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL);
+    SAlterTableInfo* pAlterTable = tAlterTableSqlElems(&yymsp[-5].minor.yy0, NULL, A, TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 237: /* cmd ::= KILL CONNECTION INTEGER */
+      case 245: /* cmd ::= KILL CONNECTION INTEGER */
 {setKillSql(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);}
         break;
-      case 238: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
+      case 246: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
 {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_STREAM, &yymsp[-2].minor.yy0);}
         break;
-      case 239: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
+      case 247: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
 {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_QUERY, &yymsp[-2].minor.yy0);}
         break;
       default:

src/sync/src/syncMain.c

@@ -568,7 +568,7 @@ static void syncStartCheckPeerConn(SSyncPeer *pPeer) {
   int32_t ret = strcmp(pPeer->fqdn, tsNodeFqdn);
   if (pPeer->nodeId == 0 || (ret > 0) || (ret == 0 && pPeer->port > tsSyncPort)) {
     int32_t checkMs = 100 + (pNode->vgId * 10) % 100;
-    if (pNode->vgId > 1) checkMs = tsStatusInterval * 1000 + checkMs;
+
     sDebug("%s, check peer connection after %d ms", pPeer->id, checkMs);
     taosTmrReset(syncCheckPeerConnection, checkMs, (void *)pPeer->rid, tsSyncTmrCtrl, &pPeer->timer);
   }

src/sync/src/syncRetrieve.c

@@ -475,7 +475,8 @@ void *syncRetrieveData(void *param) {
   SSyncNode *pNode = pPeer->pSyncNode;
 
   taosBlockSIGPIPE();
-  sInfo("%s, start to retrieve data, sstatus:%s", pPeer->id, syncStatus[pPeer->sstatus]);
+  sInfo("%s, start to retrieve data, sstatus:%s, numOfRetrieves:%d", pPeer->id, syncStatus[pPeer->sstatus],
+        pPeer->numOfRetrieves);
 
   if (pNode->notifyFlowCtrl) (*pNode->notifyFlowCtrl)(pNode->vgId, pPeer->numOfRetrieves);
 
@@ -497,9 +498,11 @@ void *syncRetrieveData(void *param) {
     pPeer->numOfRetrieves++;
   } else {
     pPeer->numOfRetrieves = 0;
-    if (pNode->notifyFlowCtrl) (*pNode->notifyFlowCtrl)(pNode->vgId, 0);
+    // if (pNode->notifyFlowCtrl) (*pNode->notifyFlowCtrl)(pNode->vgId, 0);
   }
 
+  if (pNode->notifyFlowCtrl) (*pNode->notifyFlowCtrl)(pNode->vgId, 0);
+
   pPeer->fileChanged = 0;
   taosClose(pPeer->syncFd);
 

src/vnode/src/vnodeWrite.c

@@ -308,7 +308,7 @@ static void vnodeFlowCtrlMsgToWQueue(void *param, void *tmrId) {
   if (pVnode->flowctrlLevel <= 0) code = TSDB_CODE_VND_IS_FLOWCTRL;
 
   pWrite->processedCount++;
-  if (pWrite->processedCount > 100) {
+  if (pWrite->processedCount >= 100) {
     vError("vgId:%d, msg:%p, failed to process since %s, retry:%d", pVnode->vgId, pWrite, tstrerror(code),
            pWrite->processedCount);
     pWrite->processedCount = 1;

tests/examples/JDBC/taosdemo/readme.md

+
+
 需求：
 1. 可以读lowa的配置文件
-2. 支持对JNI方式和Restful方式的taos-driver
+2. 支持JDBC-JNI和JDBC-restful
\ No newline at end of file
+3. 读取配置文件，持续执行查询
\ No newline at end of file

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/TaosDemoApplication.java

@@ -19,14 +19,13 @@ import java.util.Map;
 
 public class TaosDemoApplication {
 
-    private static Logger logger = Logger.getLogger(TaosDemoApplication.class);
+    private static final Logger logger = Logger.getLogger(TaosDemoApplication.class);
 
     public static void main(String[] args) throws IOException {
         // 读配置参数
         JdbcTaosdemoConfig config = new JdbcTaosdemoConfig(args);
         boolean isHelp = Arrays.asList(args).contains("--help");
         if (isHelp || config.host == null || config.host.isEmpty()) {
-//        if (isHelp) {
             JdbcTaosdemoConfig.printHelp();
             System.exit(0);
         }
@@ -75,7 +74,7 @@ public class TaosDemoApplication {
             }
         }
         end = System.currentTimeMillis();
-        logger.error(">>> create table time cost : " + (end - start) + " ms.");
+        logger.info(">>> create table time cost : " + (end - start) + " ms.");
         /**********************************************************************************/
         // 插入
         long tableSize = config.numOfTables;
@@ -90,7 +89,7 @@ public class TaosDemoApplication {
         // multi threads to insert
         int affectedRows = subTableService.insertMultiThreads(superTableMeta, threadSize, tableSize, startTime, gap, config);
         end = System.currentTimeMillis();
-        logger.error("insert " + affectedRows + " rows, time cost: " + (end - start) + " ms");
+        logger.info("insert " + affectedRows + " rows, time cost: " + (end - start) + " ms");
         /**********************************************************************************/
         // 删除表
         if (config.dropTable) {
@@ -108,5 +107,4 @@ public class TaosDemoApplication {
         return startTime;
     }
 
-
 }

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/dao/DatabaseMapperImpl.java

@@ -21,27 +21,27 @@ public class DatabaseMapperImpl implements DatabaseMapper {
     public void createDatabase(String dbname) {
         String sql = "create database if not exists " + dbname;
         jdbcTemplate.execute(sql);
-        logger.info("SQL >>> " + sql);
+        logger.debug("SQL >>> " + sql);
     }
 
     @Override
     public void dropDatabase(String dbname) {
         String sql = "drop database if exists " + dbname;
         jdbcTemplate.update(sql);
-        logger.info("SQL >>> " + sql);
+        logger.debug("SQL >>> " + sql);
     }
 
     @Override
     public void createDatabaseWithParameters(Map<String, String> map) {
         String sql = SqlSpeller.createDatabase(map);
         jdbcTemplate.execute(sql);
-        logger.info("SQL >>> " + sql);
+        logger.debug("SQL >>> " + sql);
     }
 
     @Override
     public void useDatabase(String dbname) {
         String sql = "use " + dbname;
         jdbcTemplate.execute(sql);
-        logger.info("SQL >>> " + sql);
+        logger.debug("SQL >>> " + sql);
     }
 }

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/dao/SubTableMapperImpl.java

@@ -21,14 +21,14 @@ public class SubTableMapperImpl implements SubTableMapper {
     @Override
     public void createUsingSuperTable(SubTableMeta subTableMeta) {
         String sql = SqlSpeller.createTableUsingSuperTable(subTableMeta);
-        logger.info("SQL >>> " + sql);
+        logger.debug("SQL >>> " + sql);
         jdbcTemplate.execute(sql);
     }
 
     @Override
     public int insertOneTableMultiValues(SubTableValue subTableValue) {
         String sql = SqlSpeller.insertOneTableMultiValues(subTableValue);
-        logger.info("SQL >>> " + sql);
+        logger.debug("SQL >>> " + sql);
 
         int affectRows = 0;
         try {
@@ -42,7 +42,7 @@ public class SubTableMapperImpl implements SubTableMapper {
     @Override
     public int insertOneTableMultiValuesUsingSuperTable(SubTableValue subTableValue) {
         String sql = SqlSpeller.insertOneTableMultiValuesUsingSuperTable(subTableValue);
-        logger.info("SQL >>> " + sql);
+        logger.debug("SQL >>> " + sql);
 
         int affectRows = 0;
         try {
@@ -56,7 +56,7 @@ public class SubTableMapperImpl implements SubTableMapper {
     @Override
     public int insertMultiTableMultiValues(List<SubTableValue> tables) {
         String sql = SqlSpeller.insertMultiSubTableMultiValues(tables);
-        logger.info("SQL >>> " + sql);
+        logger.debug("SQL >>> " + sql);
         int affectRows = 0;
         try {
             affectRows = jdbcTemplate.update(sql);
@@ -69,7 +69,7 @@ public class SubTableMapperImpl implements SubTableMapper {
     @Override
     public int insertMultiTableMultiValuesUsingSuperTable(List<SubTableValue> tables) {
         String sql = SqlSpeller.insertMultiTableMultiValuesUsingSuperTable(tables);
-        logger.info("SQL >>> " + sql);
+        logger.debug("SQL >>> " + sql);
         int affectRows = 0;
         try {
             affectRows = jdbcTemplate.update(sql);

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/dao/SuperTableMapperImpl.java

@@ -18,14 +18,14 @@ public class SuperTableMapperImpl implements SuperTableMapper {
     @Override
     public void createSuperTable(SuperTableMeta tableMetadata) {
         String sql = SqlSpeller.createSuperTable(tableMetadata);
-        logger.info("SQL >>> " + sql);
+        logger.debug("SQL >>> " + sql);
         jdbcTemplate.execute(sql);
     }
 
     @Override
     public void dropSuperTable(String database, String name) {
         String sql = "drop table if exists " + database + "." + name;
-        logger.info("SQL >>> " + sql);
+        logger.debug("SQL >>> " + sql);
         jdbcTemplate.execute(sql);
     }
 }

tests/examples/JDBC/taosdemo/src/main/java/com/taosdata/taosdemo/dao/TableMapperImpl.java

 package com.taosdata.taosdemo.dao;
 
-import com.taosdata.taosdemo.dao.TableMapper;
 import com.taosdata.taosdemo.domain.TableMeta;
 import com.taosdata.taosdemo.domain.TableValue;
 import com.taosdata.taosdemo.utils.SqlSpeller;
+import org.apache.log4j.Logger;
 import org.springframework.jdbc.core.JdbcTemplate;
 
 import java.util.List;
 
 public class TableMapperImpl implements TableMapper {
+    private static final Logger logger = Logger.getLogger(TableMapperImpl.class);
     private JdbcTemplate template;
 
     @Override
     public void create(TableMeta tableMeta) {
         String sql = SqlSpeller.createTable(tableMeta);
+        logger.debug("SQL >>> " + sql);
         template.execute(sql);
     }
 
     @Override
     public int insertOneTableMultiValues(TableValue values) {
         String sql = SqlSpeller.insertOneTableMultiValues(values);
+        logger.debug("SQL >>> " + sql);
         return template.update(sql);
     }
 
     @Override
     public int insertOneTableMultiValuesWithColumns(TableValue values) {
         String sql = SqlSpeller.insertOneTableMultiValuesWithColumns(values);
+        logger.debug("SQL >>> " + sql);
         return template.update(sql);
     }
 
     @Override
     public int insertMultiTableMultiValues(List<TableValue> tables) {
         String sql = SqlSpeller.insertMultiTableMultiValues(tables);
+        logger.debug("SQL >>> " + sql);
         return template.update(sql);
     }
 
     @Override
     public int insertMultiTableMultiValuesWithColumns(List<TableValue> tables) {
         String sql = SqlSpeller.insertMultiTableMultiValuesWithColumns(tables);
+        logger.debug("SQL >>> " + sql);
         return template.update(sql);
     }
 }

tests/examples/JDBC/taosdemo/src/main/resources/log4j.properties

 ### 设置###
-log4j.rootLogger=error,stdout
+log4j.rootLogger=info,stdout
 ### 输出信息到控制抬 ###
 log4j.appender.stdout=org.apache.log4j.ConsoleAppender
 log4j.appender.stdout.Target=System.out

tests/examples/c/CMakeLists.txt

@@ -3,6 +3,6 @@ PROJECT(TDengine)
 IF (TD_LINUX)
   INCLUDE_DIRECTORIES(. ${TD_COMMUNITY_DIR}/src/inc ${TD_COMMUNITY_DIR}/src/client/inc  ${TD_COMMUNITY_DIR}/inc)
   AUX_SOURCE_DIRECTORY(. SRC)
-  ADD_EXECUTABLE(demo demo.c)
+  ADD_EXECUTABLE(demo apitest.c)
   TARGET_LINK_LIBRARIES(demo taos_static trpc tutil pthread )
 ENDIF ()

tests/perftest-scripts/perftest-taosdemo.sh

@@ -16,6 +16,9 @@ fi
 logDir=`grep "^logDir" /etc/taos/taos.cfg | awk '{print $2}'`
 dataDir=`grep "^dataDir" /etc/taos/taos.cfg | awk '{print $2}'`
 
+[ -z "$logDir" ] && logDir="/var/log/taos"
+[ -z "$dataDir" ] && dataDir="/var/lib/taos"
+
 # Coloured Echoes 
 function red_echo      { echo -e "\033[31m$@\033[0m";   }
 function green_echo    { echo -e "\033[32m$@\033[0m";   }

tests/perftest-scripts/perftest-tsdb-compare-13d.sh

@@ -16,6 +16,9 @@ fi
 logDir=`grep "^logDir" /etc/taos/taos.cfg | awk '{print $2}'`
 dataDir=`grep "^dataDir" /etc/taos/taos.cfg | awk '{print $2}'`
 
+[ -z "$logDir" ] && logDir="/var/log/taos"
+[ -z "$dataDir" ] && dataDir="/var/lib/taos"
+
 # Coloured Echoes                                                                                                       #
 function red_echo      { echo -e "\033[31m$@\033[0m";   }                                                               #
 function green_echo    { echo -e "\033[32m$@\033[0m";   }                                                               #

tests/perftest-scripts/perftest-tsdb-compare-1d.sh

@@ -16,6 +16,9 @@ fi
 logDir=`grep "^logDir" /etc/taos/taos.cfg | awk '{print $2}'`
 dataDir=`grep "^dataDir" /etc/taos/taos.cfg | awk '{print $2}'`
 
+[ -z "$logDir" ] && logDir="/var/log/taos"
+[ -z "$dataDir" ] && dataDir="/var/lib/taos"
+
 # Coloured Echoes                                                                                                       #
 function red_echo      { echo -e "\033[31m$@\033[0m";   }                                                               #
 function green_echo    { echo -e "\033[32m$@\033[0m";   }                                                               #

tests/perftest-scripts/perftest-tsdb-compare-var10k-int100s.sh

@@ -16,6 +16,9 @@ fi
 logDir=`grep "^logDir" /etc/taos/taos.cfg | awk '{print $2}'`
 dataDir=`grep "^dataDir" /etc/taos/taos.cfg | awk '{print $2}'`
 
+[ -z "$logDir" ] && logDir="/var/log/taos"
+[ -z "$dataDir" ] && dataDir="/var/lib/taos"
+
 # Coloured Echoes                                                                                                       #
 function red_echo      { echo -e "\033[31m$@\033[0m";   }                                                               #
 function green_echo    { echo -e "\033[32m$@\033[0m";   }                                                               #

tests/perftest-scripts/perftest-tsdb-compare-var10k-int10s.sh

@@ -16,6 +16,9 @@ fi
 logDir=`grep "^logDir" /etc/taos/taos.cfg | awk '{print $2}'`
 dataDir=`grep "^dataDir" /etc/taos/taos.cfg | awk '{print $2}'`
 
+[ -z "$logDir" ] && logDir="/var/log/taos"
+[ -z "$dataDir" ] && dataDir="/var/lib/taos"
+
 # Coloured Echoes                                                                                                       #
 function red_echo      { echo -e "\033[31m$@\033[0m";   }                                                               #
 function green_echo    { echo -e "\033[32m$@\033[0m";   }                                                               #

tests/pytest/cluster/clusterEnvSetup/Dockerfile

+FROM ubuntu:latest AS builder
+ 
+ARG PACKAGE=TDengine-server-1.6.5.10-Linux-x64.tar.gz
+ARG EXTRACTDIR=TDengine-enterprise-server
+ARG CONTENT=taos.tar.gz
+ 
+WORKDIR /root
+ 
+COPY ${PACKAGE} .
+ 
+RUN tar -zxf ${PACKAGE}
+RUN mv ${EXTRACTDIR}/driver ./lib
+RUN tar -zxf ${EXTRACTDIR}/${CONTENT}
+ 
+FROM ubuntu:latest
+ 
+WORKDIR /root
+
+RUN apt-get update
+RUN apt-get install -y vim tmux net-tools
+RUN echo 'alias ll="ls -l --color=auto"' >> /root/.bashrc
+ 
+COPY --from=builder /root/bin/taosd /usr/bin
+COPY --from=builder /root/bin/taos /usr/bin
+COPY --from=builder /root/cfg/taos.cfg /etc/taos/
+COPY --from=builder /root/lib/libtaos.so.* /usr/lib/libtaos.so.1
+ 
+ENV LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/usr/lib"
+ENV LC_CTYPE=en_US.UTF-8
+ENV LANG=en_US.UTF-8
+ 
+EXPOSE 6030-6041/tcp 6060/tcp 6030-6039/udp
+ 
+# VOLUME [ "/var/lib/taos", "/var/log/taos", "/etc/taos" ]
+ 
+CMD [ "bash" ]

tests/pytest/cluster/clusterEnvSetup/buildClusterEnv.sh

+#!/bin/bash
+echo "Executing buildClusterEnv.sh"
+DOCKER_DIR=/data
+CURR_DIR=`pwd`
+
+if [ $# != 4 ]; then 
+  echo "argument list need input : "
+  echo "  -n numOfNodes"
+  echo "  -v version"  
+  exit 1
+fi
+
+NUM_OF_NODES=
+VERSION=
+while getopts "n:v:" arg
+do
+  case $arg in
+    n)
+      NUM_OF_NODES=$OPTARG
+      ;;
+    v)
+      VERSION=$OPTARG
+      ;;    
+    ?)
+      echo "unkonwn argument"
+      ;;
+  esac
+done
+
+
+function createDIR {
+  for i in {1.. $2}
+  do    
+    mkdir -p /data/node$i/data
+    mkdir -p /data/node$i/log
+    mkdir -p /data/node$i/cfg
+  done
+}
+
+function cleanEnv {    
+  for i in {1..3}
+  do
+    echo /data/node$i/data/*
+    rm -rf /data/node$i/data/*
+    echo /data/node$i/log/*
+    rm -rf /data/node$i/log/*
+  done
+}
+
+function prepareBuild {
+
+  if [ -d $CURR_DIR/../../../../release ]; then
+    echo release exists
+    rm -rf $CURR_DIR/../../../../release/*
+  fi
+
+  cd $CURR_DIR/../../../../packaging
+  ./release.sh -v edge -n $VERSION >> /dev/null
+
+  if [ ! -f $CURR_DIR/../../../../release/TDengine-server-$VERSION-Linux-x64.tar.gz ]; then
+    echo "no TDengine install package found"
+    exit 1
+  fi
+
+  cd $CURR_DIR/../../../../release
+  mv TDengine-server-$VERSION-Linux-x64.tar.gz $DOCKER_DIR
+  
+  rm -rf $DOCKER_DIR/*.yml
+  cd $CURR_DIR
+
+  cp docker-compose.yml  $DOCKER_DIR
+  cp Dockerfile $DOCKER_DIR
+
+  if [ $NUM_OF_NODES -eq 4 ]; then
+    cp ../node4.yml $DOCKER_DIR
+  fi
+
+  if [ $NUM_OF_NODES -eq 5 ]; then
+    cp ../node5.yml $DOCKER_DIR
+  fi
+}
+
+function clusterUp {
+  
+  cd $DOCKER_DIR
+
+  if [ $NUM_OF_NODES -eq 3 ]; then
+    PACKAGE=TDengine-server-$VERSION-Linux-x64.tar.gz DIR=TDengine-server-$VERSION docker-compose up -d
+  fi
+
+  if [ $NUM_OF_NODES -eq 4 ]; then
+    PACKAGE=TDengine-server-$VERSION-Linux-x64.tar.gz DIR=TDengine-server-$VERSION docker-compose -f docker-compose.yml -f node4.yml up -d
+  fi
+
+  if [ $NUM_OF_NODES -eq 5 ]; then
+    PACKAGE=TDengine-server-$VERSION-Linux-x64.tar.gz DIR=TDengine-server-$VERSION docker-compose -f docker-compose.yml -f node4.yml -f node5.yml up -d
+  fi
+}
+
+cleanEnv 
+# prepareBuild
+# clusterUp
\ No newline at end of file

tests/pytest/cluster/clusterEnvSetup/docker-compose.yml

+version: '3.7'
+
+services: 
+  td2.0-node1:
+     build:
+       context: .
+       args:
+         - PACKAGE=${PACKAGE}
+         - EXTRACTDIR=${DIR}
+     image: 'tdengine:2.0.13.1'
+     container_name: 'td2.0-node1'     
+     cap_add:
+       - ALL
+     stdin_open: true
+     tty: true
+     environment:
+       TZ: "Asia/Shanghai"
+     command: >
+       sh -c "ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && 
+       echo $TZ > /etc/timezone &&
+       exec my-main-application"
+     volumes: 
+       # bind data directory
+       - type: bind
+         source: /data/node1/data
+         target: /var/lib/taos
+       # bind log directory
+       - type: bind
+         source: /data/node1/log
+         target: /var/log/taos
+       # bind configuration
+       - type: bind
+         source: /data/node1/cfg
+         target: /etc/taos
+       - type: bind
+         source: /data
+         target: /root     
+     networks:
+         taos_update_net:
+             ipv4_address: 172.27.0.7
+     command: taosd
+
+  td2.0-node2:
+     build:
+       context: .
+       args:
+         - PACKAGE=${PACKAGE}
+         - EXTRACTDIR=${DIR}
+     image: 'tdengine:2.0.13.1'
+     container_name: 'td2.0-node2'     
+     cap_add:
+       - ALL
+     stdin_open: true
+     tty: true
+     environment:
+       TZ: "Asia/Shanghai"
+     command: >
+       sh -c "ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && 
+       echo $TZ > /etc/timezone &&
+       exec my-main-application"
+     volumes: 
+       # bind data directory
+       - type: bind
+         source: /data/node2/data
+         target: /var/lib/taos
+       # bind log directory
+       - type: bind
+         source: /data/node2/log
+         target: /var/log/taos
+       # bind configuration
+       - type: bind
+         source: /data/node2/cfg
+         target: /etc/taos
+       - type: bind
+         source: /data
+         target: /root
+     networks:
+         taos_update_net:
+             ipv4_address: 172.27.0.8
+     command: taosd
+
+  td2.0-node3:
+     build:
+       context: .
+       args:
+         - PACKAGE=${PACKAGE}
+         - EXTRACTDIR=${DIR}
+     image: 'tdengine:2.0.13.1'
+     container_name: 'td2.0-node3'     
+     cap_add:
+       - ALL
+     stdin_open: true
+     tty: true
+     environment:
+       TZ: "Asia/Shanghai"
+     command: >
+       sh -c "ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && 
+       echo $TZ > /etc/timezone &&
+       exec my-main-application"
+     volumes: 
+       # bind data directory
+       - type: bind
+         source: /data/node3/data
+         target: /var/lib/taos
+       # bind log directory
+       - type: bind
+         source: /data/node3/log
+         target: /var/log/taos
+       # bind configuration
+       - type: bind
+         source: /data/node3/cfg
+         target: /etc/taos
+       - type: bind
+         source: /data
+         target: /root     
+     networks:
+         taos_update_net:
+             ipv4_address: 172.27.0.9
+     command: taosd
+
+networks:
+  taos_update_net:
+#    external: true
+     ipam:
+       driver: default
+       config:
+         - subnet: "172.27.0.0/24"

tests/pytest/cluster/clusterEnvSetup/node4.yml

+version: '3.7'
+
+services: 
+  td2.0-node4:
+     build:
+       context: .
+       args:
+         - PACKAGE=${PACKAGE}
+         - EXTRACTDIR=${DIR}
+     image: 'tdengine:2.0.13.1'
+     container_name: 'td2.0-node4'     
+     cap_add:
+       - ALL
+     stdin_open: true
+     tty: true
+     environment:
+       TZ: "Asia/Shanghai"
+     command: >
+       sh -c "ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && 
+       echo $TZ > /etc/timezone &&
+       exec my-main-application"
+     volumes: 
+       # bind data directory
+       - type: bind
+         source: /data/node4/data
+         target: /var/lib/taos
+       # bind log directory
+       - type: bind
+         source: /data/node4/log
+         target: /var/log/taos
+       # bind configuration
+       - type: bind
+         source: /data/node4/cfg
+         target: /etc/taos
+       - type: bind
+         source: /data
+         target: /root     
+     networks:
+         taos_update_net:
+             ipv4_address: 172.27.0.10
+     command: taosd
\ No newline at end of file

tests/pytest/cluster/clusterEnvSetup/node5.yml

+version: '3.7'
+
+services: 
+  td2.0-node5:
+     build:
+       context: .
+       args:
+         - PACKAGE=${PACKAGE}
+         - EXTRACTDIR=${DIR}
+     image: 'tdengine:2.0.13.1'
+     container_name: 'td2.0-node5'     
+     cap_add:
+       - ALL
+     stdin_open: true
+     tty: true
+     environment:
+       TZ: "Asia/Shanghai"
+     command: >
+       sh -c "ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && 
+       echo $TZ > /etc/timezone &&
+       exec my-main-application"
+     volumes: 
+       # bind data directory
+       - type: bind
+         source: /data/node5/data
+         target: /var/lib/taos
+       # bind log directory
+       - type: bind
+         source: /data/node5/log
+         target: /var/log/taos
+       # bind configuration
+       - type: bind
+         source: /data/node5/cfg
+         target: /etc/taos
+       - type: bind
+         source: /data
+         target: /root     
+     networks:
+         taos_update_net:
+             ipv4_address: 172.27.0.11
+     command: taosd
\ No newline at end of file

tests/script/general/http/restful_full.sim

@@ -15,6 +15,7 @@ print ===============  step1 - login
 system_content curl 127.0.0.1:7111/rest/
 print 1-> $system_content
 if $system_content != @{"status":"error","code":4357,"desc":"no auth info input"}@ then
+  print $system_content
   return -1
 endi
 

tests/script/general/parser/function.sim

@@ -383,3 +383,27 @@ sql create table cars(ts timestamp, c int) tags(id int);
 sql create table car1 using cars tags(1);
 sql create table car2 using cars tags(2);
 sql insert into car1 (ts, c) values (now,1) car2(ts, c) values(now, 2);
+
+print ========================> TD-2700
+sql create table t1(ts timestamp, k int);
+sql insert into t1 values(1500000001000, 0);
+sql select sum(k) from t1 interval(1d) sliding(1h);
+if $rows != 24 then
+  return -1
+endi
+
+print ========================> TD-2740
+sql drop table if exists m1;
+sql create table m1(ts timestamp, k int) tags(a int);
+sql create table tm0 using m1 tags(0);
+sql create table tm1 using m1 tags(1);
+sql create table tm2 using m1 tags(2);
+sql create table tm3 using m1 tags(3);
+sql insert into tm0 values('2020-1-1 1:1:1', 0);
+sql insert into tm1 values('2020-1-5 1:1:1', 0);
+sql insert into tm2 values('2020-1-7 1:1:1', 0);
+sql insert into tm3 values('2020-1-1 1:1:1', 0);
+sql select count from m1 where ts='2020-1-1 1:1:1' interval(1h) group by tbname;
+if $rows != 2 then
+  return -1
+endi
\ No newline at end of file

tests/script/general/parser/join.sim

@@ -415,6 +415,7 @@ sql select count(join_mt0.c1), sum(join_mt1.c2), first(join_mt0.c5), last(join_m
 
 $val = 100
 if $rows != $val then
+   print $rows
    return -1
 endi