Merge branch 'develop' into feature/sangshuduo/TD-2971-python-connector-support-unsigned

.gitignore

@@ -79,3 +79,15 @@ tests/comparisonTest/opentsdb/opentsdbtest/.settings/
 tests/examples/JDBC/JDBCDemo/.classpath
 tests/examples/JDBC/JDBCDemo/.project
 tests/examples/JDBC/JDBCDemo/.settings/
+
+# Emacs
+# -*- mode: gitignore; -*-
+*~
+\#*\#
+/.emacs.desktop
+/.emacs.desktop.lock
+*.elc
+auto-save-list
+tramp
+.\#*
+TAGS

Jenkinsfile

@@ -5,7 +5,7 @@ node {
     git url: 'https://github.com/taosdata/TDengine.git'
 }
 
-def kipstage=0
+def skipstage=0
 def abortPreviousBuilds() {
   def currentJobName = env.JOB_NAME
   def currentBuildNumber = env.BUILD_NUMBER.toInteger()
@@ -88,8 +88,9 @@ pipeline {
           git checkout -qf FETCH_HEAD
           '''
           script{
-            skipstage=sh(script:"git --no-pager diff --name-only FETCH_HEAD develop|grep -v -E '.*md|//src//connector|Jenkinsfile|test-all.sh' || echo 0 ",returnStdout:true) 
+            env.skipstage=sh(script:"cd ${WORKSPACE}.tes && git --no-pager diff --name-only FETCH_HEAD develop|grep -v -E '.*md|//src//connector|Jenkinsfile|test-all.sh' || echo 0 ",returnStdout:true) 
           }
+          println env.skipstage
           sh'''
           rm -rf ${WORKSPACE}.tes
           '''
@@ -101,7 +102,7 @@ pipeline {
         when {
               changeRequest()
                expression {
-                    skipstage != 0
+                    env.skipstage != 0
               }
           }
       parallel {

documentation20/cn/04.model/docs.md

@@ -43,7 +43,7 @@ CREATE STABLE meters (ts timestamp, current float, voltage int, phase float) TAG
 ## <a class="anchor" id="create-table"></a>创建表
 
 TDengine对每个数据采集点需要独立建表。与标准的关系型数据一样，一张表有表名，Schema，但除此之外，还可以带有一到多个标签。创建时，需要使用超级表做模板，同时指定标签的具体值。以表一中的智能电表为例，可以使用如下的SQL命令建表：
-```cmd
+```mysql
 CREATE TABLE d1001 USING meters TAGS ("Beijing.Chaoyang", 2);
 ```
 其中d1001是表名，meters是超级表的表名，后面紧跟标签Location的具体标签值”Beijing.Chaoyang"，标签groupId的具体标签值2。虽然在创建表时，需要指定标签值，但可以事后修改。详细细则请见 [TAOS SQL 的表管理](https://www.taosdata.com/cn/documentation/taos-sql#table) 章节。
@@ -54,10 +54,12 @@ TDengine建议将数据采集点的全局唯一ID作为表名(比如设备序列
 
 **自动建表**：在某些特殊场景中，用户在写数据时并不确定某个数据采集点的表是否存在，此时可在写入数据时使用自动建表语法来创建不存在的表，若该表已存在则不会建立新表。比如：
 
-```cmd
+```mysql
 INSERT INTO d1001 USING METERS TAGS ("Beijng.Chaoyang", 2) VALUES (now, 10.2, 219, 0.32);
 ```
-上述SQL语句将记录(now, 10.2, 219, 0.32) 插入进表d1001。如果表d1001还未创建，则使用超级表meters做模板自动创建，同时打上标签值“Beijing.Chaoyang", 2。  
+上述SQL语句将记录 (now, 10.2, 219, 0.32) 插入表d1001。如果表d1001还未创建，则使用超级表meters做模板自动创建，同时打上标签值“Beijing.Chaoyang", 2。  
+
+关于自动建表的详细语法请参见 [插入记录时自动建表](https://www.taosdata.com/cn/documentation/taos-sql#auto_create_table) 章节。
 
 ## 多列模型 vs 单列模型
 

documentation20/cn/08.connector/docs.md

@@ -24,6 +24,7 @@ TDengine提供了丰富的应用程序开发接口，其中包括C/C++、Java、
 * 在没有安装TDengine服务端软件的系统中使用连接器（除RESTful外）访问 TDengine 数据库，需要安装相应版本的客户端安装包来使应用驱动（Linux系统中文件名为libtaos.so，Windows系统中为taos.dll）被安装在系统中，否则会产生无法找到相应库文件的错误。
 * 所有执行 SQL 语句的 API，例如 C/C++ Connector 中的 `tao_query`、`taos_query_a`、`taos_subscribe` 等，以及其它语言中与它们对应的API，每次都只能执行一条 SQL 语句，如果实际参数中包含了多条语句，它们的行为是未定义的。
 * 升级到TDengine到2.0.8.0版本的用户，必须更新JDBC连接TDengine必须升级taos-jdbcdriver到2.0.12及以上。
+* 无论选用何种编程语言的连接器，2.0 及以上版本的 TDengine 推荐数据库应用的每个线程都建立一个独立的连接，或基于线程建立连接池，以避免连接内的“USE statement”状态量在线程之间相互干扰（但连接的查询和写入操作都是线程安全的）。
 
 ## <a class="anchor" id="driver"></a>安装连接器驱动步骤
 
@@ -238,13 +239,13 @@ C/C++的API类似于MySQL的C API。应用程序使用时，需要包含TDengine
 
   获取查询结果集每列数据的属性（数据类型、名字、字节数），与taos_num_fileds配合使用，可用来解析`taos_fetch_row`返回的一个元组(一行)的数据。 `TAOS_FIELD` 的结构如下：
 
-  ```c
-  typedef struct taosField {
+```c
+typedef struct taosField {
   char     name[65];  // 列名
   uint8_t  type;      // 数据类型
   int16_t  bytes;     // 字节数
-  } TAOS_FIELD;
-  ```
+} TAOS_FIELD;
+```
 
 - `void taos_stop_query(TAOS_RES *res)`
 
@@ -266,7 +267,7 @@ C/C++的API类似于MySQL的C API。应用程序使用时，需要包含TDengine
 
 ### 异步查询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操作，表示有记录返回。
 
@@ -896,7 +897,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/cn/11.administrator/docs.md

@@ -102,7 +102,7 @@ taosd -C
 - maxSQLLength：单条SQL语句允许最长限制。默认值：65380字节。
 - telemetryReporting: 是否允许 TDengine 采集和上报基本使用信息，0表示不允许，1表示允许。 默认值：1。
 - stream: 是否启用连续查询（流计算功能），0表示不允许，1表示允许。 默认值：1。
-- queryBufferSize: 为所有并发查询占用保留的内存大小。计算规则可以根据实际应用可能的最大并发数和表的数字相乘，再乘 170 。单位为字节。
+- queryBufferSize: 为所有并发查询占用保留的内存大小。计算规则可以根据实际应用可能的最大并发数和表的数字相乘，再乘 170 。单位为 MB（2.0.15 以前的版本中，此参数的单位是字节）。
 - ratioOfQueryCores: 设置查询线程的最大数量。最小值0 表示只有1个查询线程；最大值2表示最大建立2倍CPU核数的查询线程。默认为1，表示最大和CPU核数相等的查询线程。该值可以为小数，即0.5表示最大建立CPU核数一半的查询线程。
 
 **注意：**对于端口，TDengine会使用从serverPort起13个连续的TCP和UDP端口号，请务必在防火墙打开。因此如果是缺省配置，需要打开从6030到6042共13个端口，而且必须TCP和UDP都打开。

documentation20/cn/12.taos-sql/docs.md

@@ -152,6 +152,14 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
     ```
     以指定的超级表为模板，指定 tags 的值来创建数据表。
 
+- **以超级表为模板创建数据表，并指定具体的 tags 列**
+
+    ```mysql
+    CREATE TABLE [IF NOT EXISTS] tb_name USING stb_name (tag_name1, ...) TAGS (tag_value1, ...);
+    ```
+    以指定的超级表为模板，指定一部分 tags 列的值来创建数据表。（没被指定的 tags 列会设为空值。）  
+    说明：从 2.0.17 版本开始支持这种方式。在之前的版本中，不允许指定 tags 列，而必须显式给出所有 tags 列的取值。
+
 - **批量创建数据表**
 
     ```mysql
@@ -267,6 +275,7 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
     ```
 
 ## <a class="anchor" id="tags"></a>超级表 STable 中 TAG 管理
+
 - **添加标签**
 
     ```mysql
@@ -305,7 +314,7 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
 
 - **插入一条记录，数据对应到指定的列**
     ```mysql
-    INSERT INTO tb_name (field1_name, ...) VALUES (field1_value, ...)
+    INSERT INTO tb_name (field1_name, ...) VALUES (field1_value1, ...);
     ```
     向表tb_name中插入一条记录，数据对应到指定的列。SQL语句中没有出现的列，数据库将自动填充为NULL。主键（时间戳）不能为NULL。
 
@@ -339,25 +348,19 @@ TDengine缺省的时间戳是毫秒精度，但通过修改配置参数enableMic
     1) 如果时间戳为0，系统将自动使用服务器当前时间作为该记录的时间戳；
     2) 允许插入的最老记录的时间戳，是相对于当前服务器时间，减去配置的keep值（数据保留的天数），允许插入的最新记录的时间戳，是相对于当前服务器时间，加上配置的days值（数据文件存储数据的时间跨度，单位为天）。keep和days都是可以在创建数据库时指定的，缺省值分别是3650天和10天。
 
-**历史记录写入**：可使用IMPORT或者INSERT命令，IMPORT的语法，功能与INSERT完全一样。
-
-## <a class="anchor" id="select"></a>数据查询
+- <a class="anchor" id="auto_create_table"></a>**插入记录时自动建表**
+    ```mysql
+    INSERT INTO tb_name USING stb_name TAGS (tag_value1, ...) VALUES (field_value1, ...);
+    ```
+    如果用户在写数据时并不确定某个表是否存在，此时可以在写入数据时使用自动建表语法来创建不存在的表，若该表已存在则不会建立新表。自动建表时，要求必须以超级表为模板，并写明数据表的 tags 取值。
 
-### 查询语法：
+- **插入记录时自动建表，并指定具体的 tags 列**
+    ```mysql
+    INSERT INTO tb_name USING stb_name (tag_name1, ...) TAGS (tag_value1, ...) VALUES (field_value1, ...);
+    ```
+    在自动建表时，可以只是指定部分 tags 列的取值，未被指定的 tags 列将取为空值。
 
-```mysql
-SELECT select_expr [, select_expr ...]
-    FROM {tb_name_list}
-    [WHERE where_condition]
-    [INTERVAL (interval_val [, interval_offset])]
-    [FILL fill_val]
-    [SLIDING fill_val]
-    [GROUP BY col_list]
-    [ORDER BY col_list { DESC | ASC }]
-    [SLIMIT limit_val [, SOFFSET offset_val]]
-    [LIMIT limit_val [, OFFSET offset_val]]
-    [>> export_file]
-```
+**历史记录写入**：可使用IMPORT或者INSERT命令，IMPORT的语法，功能与INSERT完全一样。
 
 说明：针对 insert 类型的 SQL 语句，我们采用的流式解析策略，在发现后面的错误之前，前面正确的部分SQL仍会执行。下面的sql中，insert语句是无效的，但是d1001仍会被创建。
 
@@ -385,6 +388,24 @@ taos> SHOW TABLES;
 Query OK, 1 row(s) in set (0.001091s)
 ```
 
+## <a class="anchor" id="select"></a>数据查询
+
+### 查询语法：
+
+```mysql
+SELECT select_expr [, select_expr ...]
+    FROM {tb_name_list}
+    [WHERE where_condition]
+    [INTERVAL (interval_val [, interval_offset])]
+    [FILL fill_val]
+    [SLIDING fill_val]
+    [GROUP BY col_list]
+    [ORDER BY col_list { DESC | ASC }]
+    [SLIMIT limit_val [, SOFFSET offset_val]]
+    [LIMIT limit_val [, OFFSET offset_val]]
+    [>> export_file];
+```
+
 #### SELECT子句
 
 一个选择子句可以是联合查询（UNION）和另一个查询的子查询（SUBQUERY）。

documentation20/cn/13.faq/docs.md

@@ -140,3 +140,20 @@ TDengine是根据hostname唯一标志一台机器的，在数据文件从机器A
 - 2.0.7.0 及以后的版本，到/var/lib/taos/dnode下，修复dnodeEps.json的dnodeId对应的FQDN，重启。确保机器内所有机器的此文件是完全相同的。
 - 1.x 和 2.x 版本的存储结构不兼容，需要使用迁移工具或者自己开发应用导出导入数据。
 
+## 17. 如何在命令行程序 taos 中临时调整日志级别
+
+为了调试方便，从 2.0.16 版本开始，命令行程序 taos 新增了与日志记录相关的两条指令：
+
+```mysql
+ALTER LOCAL flag_name flag_value;
+```
+
+其含义是，在当前的命令行程序下，修改一个特定模块的日志记录级别（只对当前命令行程序有效，如果 taos 命令行程序重启，则需要重新设置）：
+- flag_name 的取值可以是：debugFlag，cDebugFlag，tmrDebugFlag，uDebugFlag，rpcDebugFlag
+- flag_value 的取值可以是：131（输出错误和警告日志），135（ 输出错误、警告和调试日志），143（ 输出错误、警告、调试和跟踪日志）
+
+```mysql
+ALTER LOCAL RESETLOG;
+```
+
+其含义是，清空本机所有由客户端生成的日志文件。

packaging/rpm/tdengine.spec

@@ -9,6 +9,7 @@ Summary:	tdengine from taosdata
 Group:	  Application/Database
 License:	AGPL
 URL:		  www.taosdata.com
+AutoReqProv: no
 
 #BuildRoot:  %_topdir/BUILDROOT
 BuildRoot:   %{_tmppath}/%{name}-%{version}-%{release}-root 

src/client/src/tscSQLParser.c

@@ -6375,16 +6375,14 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
     // get table meta from mnode
     code = tNameExtractFullName(&pStableMetaInfo->name, pCreateTableInfo->tagdata.name);
 
-    SArray* pList = pCreateTableInfo->pTagVals;
+    SArray* pValList = pCreateTableInfo->pTagVals;
     code = tscGetTableMeta(pSql, pStableMetaInfo);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
     }
 
-    size_t size = taosArrayGetSize(pList);
-    if (tscGetNumOfTags(pStableMetaInfo->pTableMeta) != size) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
-    }
+    size_t valSize = taosArrayGetSize(pValList);
+
 
     // too long tag values will return invalid sql, not be truncated automatically
     SSchema  *pTagSchema = tscGetTableTagSchema(pStableMetaInfo->pTableMeta);
@@ -6395,10 +6393,84 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
       return TSDB_CODE_TSC_OUT_OF_MEMORY;
     }
 
+
+    SArray* pNameList = NULL;
+    size_t nameSize = 0;
+    int32_t schemaSize = tscGetNumOfTags(pStableMetaInfo->pTableMeta);
     int32_t ret = TSDB_CODE_SUCCESS;
-    for (int32_t i = 0; i < size; ++i) {
+
+    if (pCreateTableInfo->pTagNames) {
+      pNameList = pCreateTableInfo->pTagNames;
+      nameSize = taosArrayGetSize(pNameList);
+
+      if (valSize != nameSize) {
+        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+      }
+
+      if (schemaSize < valSize) {
+        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+      }
+
+      bool findColumnIndex = false;
+
+      for (int32_t i = 0; i < nameSize; ++i) {
+        SStrToken* sToken = taosArrayGet(pNameList, i);
+        if (TK_STRING == sToken->type) {
+          tscDequoteAndTrimToken(sToken);
+        }
+
+        tVariantListItem* pItem = taosArrayGet(pValList, i);
+
+        findColumnIndex = false;
+      
+        // todo speedup by using hash list
+        for (int32_t t = 0; t < schemaSize; ++t) {
+          if (strncmp(sToken->z, pTagSchema[t].name, sToken->n) == 0 && strlen(pTagSchema[t].name) == sToken->n) {
+            SSchema*          pSchema = &pTagSchema[t];
+            
+            char tagVal[TSDB_MAX_TAGS_LEN];
+            if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) {
+              if (pItem->pVar.nLen > pSchema->bytes) {
+                tdDestroyKVRowBuilder(&kvRowBuilder);
+                return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+              }
+            }
+            
+            ret = tVariantDump(&(pItem->pVar), tagVal, pSchema->type, true);
+            
+            // check again after the convert since it may be converted from binary to nchar.
+            if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) {
+              int16_t len = varDataTLen(tagVal);
+              if (len > pSchema->bytes) {
+                tdDestroyKVRowBuilder(&kvRowBuilder);
+                return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+              }
+            }
+            
+            if (ret != TSDB_CODE_SUCCESS) {
+              tdDestroyKVRowBuilder(&kvRowBuilder);
+              return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+            }
+            
+            tdAddColToKVRow(&kvRowBuilder, pSchema->colId, pSchema->type, tagVal);
+
+            findColumnIndex = true;
+            break;
+          }
+        }
+
+        if (!findColumnIndex) {
+          return tscInvalidSQLErrMsg(pCmd->payload, "invalid tag name", sToken->z);
+        }   
+      }
+    } else {
+      if (schemaSize != valSize) {
+        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+      }
+
+      for (int32_t i = 0; i < valSize; ++i) {
         SSchema*          pSchema = &pTagSchema[i];
-      tVariantListItem* pItem = taosArrayGet(pList, i);
+        tVariantListItem* pItem = taosArrayGet(pValList, i);
       
         char tagVal[TSDB_MAX_TAGS_LEN];
         if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) {
@@ -6426,6 +6498,7 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
       
         tdAddColToKVRow(&kvRowBuilder, pSchema->colId, pSchema->type, tagVal);
       }
+    }
 
     SKVRow row = tdGetKVRowFromBuilder(&kvRowBuilder);
     tdDestroyKVRowBuilder(&kvRowBuilder);

src/client/src/tscSql.c

@@ -52,7 +52,9 @@ static bool validPassword(const char* passwd) {
 
 static SSqlObj *taosConnectImpl(const char *ip, const char *user, const char *pass, const char *auth, const char *db,
                          uint16_t port, void (*fp)(void *, TAOS_RES *, int), void *param, TAOS **taos) {
-  taos_init();
+  if (taos_init()) {
+    return NULL;
+  }
 
   if (!validUserName(user)) {
     terrno = TSDB_CODE_TSC_INVALID_USER_LENGTH;

src/client/src/tscSystem.c

@@ -47,6 +47,7 @@ void      *tscRpcCache;            // cache to keep rpc obj
 int32_t   tscNumOfThreads = 1;     // num of rpc threads  
 static    pthread_mutex_t rpcObjMutex; // mutex to protect open the rpc obj concurrently 
 static pthread_once_t tscinit = PTHREAD_ONCE_INIT;
+static volatile int tscInitRes = 0;
 
 void tscCheckDiskUsage(void *UNUSED_PARAM(para), void *UNUSED_PARAM(param)) {
   taosGetDisk();
@@ -137,7 +138,11 @@ void taos_init_imp(void) {
     }
 
     taosReadGlobalCfg();
-    taosCheckGlobalCfg();
+    if (taosCheckGlobalCfg()) {
+      tscInitRes = -1;
+      return;
+    }
+    
     taosInitNotes();
 
     rpcInit();
@@ -159,6 +164,7 @@ void taos_init_imp(void) {
   tscQhandle = taosInitScheduler(queueSize, tscNumOfThreads, "tsc");
   if (NULL == tscQhandle) {
     tscError("failed to init scheduler");
+    tscInitRes = -1;
     return;
   }
 
@@ -187,7 +193,7 @@ void taos_init_imp(void) {
   tscDebug("client is initialized successfully");
 }
 
-void taos_init() { pthread_once(&tscinit, taos_init_imp); }
+int taos_init() {     pthread_once(&tscinit, taos_init_imp);  return tscInitRes;}
 
 // this function may be called by user or system, or by both simultaneously.
 void taos_cleanup(void) {

src/common/src/tglobal.c

@@ -373,6 +373,23 @@ static void taosCheckDataDirCfg() {
   }
 }
 
+static int32_t taosCheckTmpDir(void) {
+  if (strlen(tsTempDir) <= 0){
+    uError("tempDir is not set");
+    return -1;
+  }
+
+  DIR *dir = opendir(tsTempDir);
+  if (dir == NULL) {
+    uError("can not open tempDir:%s, error:%s", tsTempDir, strerror(errno));
+    return -1;
+  }
+
+  closedir(dir);
+
+  return 0;
+}
+
 static void doInitGlobalConfig(void) {
   osInit();
   srand(taosSafeRand());
@@ -1488,6 +1505,11 @@ int32_t taosCheckGlobalCfg() {
   }
 
   taosCheckDataDirCfg();
+
+  if (taosCheckTmpDir()) {
+    return -1;
+  }
+  
   taosGetSystemInfo();
 
   tsSetLocale();

src/inc/taos.h

@@ -68,7 +68,7 @@ typedef struct taosField {
   #define DLL_EXPORT 
 #endif
 
-DLL_EXPORT void  taos_init();
+DLL_EXPORT int  taos_init();
 DLL_EXPORT void  taos_cleanup(void);
 DLL_EXPORT int   taos_options(TSDB_OPTION option, const void *arg, ...);
 DLL_EXPORT TAOS *taos_connect(const char *ip, const char *user, const char *pass, const char *db, uint16_t port);

src/inc/ttokendef.h

@@ -122,8 +122,8 @@
 #define TK_UNSIGNED                       103
 #define TK_TAGS                           104
 #define TK_USING                          105
-#define TK_AS                             106
-#define TK_COMMA                          107
+#define TK_COMMA                          106
+#define TK_AS                             107
 #define TK_NULL                           108
 #define TK_SELECT                         109
 #define TK_UNION                          110
@@ -228,6 +228,7 @@
 #define TK_VALUES                         209
 
 
+
 #define TK_SPACE                          300
 #define TK_COMMENT                        301
 #define TK_ILLEGAL                        302

src/kit/shell/src/shellEngine.c

@@ -76,7 +76,11 @@ TAOS *shellInit(SShellArguments *args) {
     args->user = TSDB_DEFAULT_USER;
   }
 
-  taos_init();
+  if (taos_init()) {
+    printf("failed to init taos\n");
+    fflush(stdout);
+    return NULL;
+  }
 
   // Connect to the database.
   TAOS *con = NULL;

src/kit/shell/src/shellMain.c

@@ -110,7 +110,10 @@ int main(int argc, char* argv[]) {
   }
 
   if (args.netTestRole && args.netTestRole[0] != 0) {
-    taos_init();
+    if (taos_init()) {
+      printf("Failed to init taos");
+      exit(EXIT_FAILURE);
+    }
     taosNetTest(args.netTestRole, args.host, args.port, args.pktLen);
     exit(0);
   }

src/kit/taosdemo/taosdemo.c

@@ -711,7 +711,11 @@ int main(int argc, char *argv[]) {
   fprintf(fp, "###################################################################\n\n");
   fprintf(fp, "|  WRecords  | Records/Second | Requests/Second |  WLatency(ms) |\n");
 
-  taos_init();
+  if (taos_init()) {
+    fprintf(stderr, "Failed to init taos\n");
+    return 1;
+  }
+  
   TAOS *taos = taos_connect(ip_addr, user, pass, NULL, port);
   if (taos == NULL) {
     fprintf(stderr, "Failed to connect to TDengine, reason:%s\n", taos_errstr(NULL));

src/kit/taosdemox/taosdemox.c

@@ -1971,7 +1971,11 @@ static int createSuperTable(TAOS * taos, char* dbName, SSuperTable*  superTbls,
 static int createDatabases() {
   TAOS * taos = NULL;
   int    ret = 0;
-  taos_init();
+  if (taos_init()) {
+    fprintf(stderr, "Failed to init taos\n");
+    exit(-1);
+  }
+  
   taos = taos_connect(g_Dbs.host, g_Dbs.user, g_Dbs.password, NULL, g_Dbs.port);
   if (taos == NULL) {
     fprintf(stderr, "Failed to connect to TDengine, reason:%s\n", taos_errstr(NULL));
@@ -4496,7 +4500,11 @@ void *subQueryProcess(void *sarg) {
 
 int queryTestProcess() {
   TAOS * taos = NULL;  
-  taos_init();
+  if (taos_init()) {
+    fprintf(stderr, "Failed to init taos\n");
+    exit(-1);
+  }
+  
   taos = taos_connect(g_queryInfo.host, g_queryInfo.user, g_queryInfo.password, NULL, g_queryInfo.port);
   if (taos == NULL) {
     fprintf(stderr, "Failed to connect to TDengine, reason:%s\n", taos_errstr(NULL));
@@ -4772,7 +4780,11 @@ int subscribeTestProcess() {
   }
 
   TAOS * taos = NULL;  
-  taos_init();
+  if (taos_init()) {
+    fprintf(stderr, "Failed to init taos\n");
+    exit(-1);
+  }
+  
   taos = taos_connect(g_queryInfo.host, g_queryInfo.user, g_queryInfo.password, g_queryInfo.dbName, g_queryInfo.port);
   if (taos == NULL) {
     fprintf(stderr, "Failed to connect to TDengine, reason:%s\n", taos_errstr(NULL));

src/plugins/monitor/src/monMain.c

@@ -103,7 +103,9 @@ int32_t monInitSystem() {
 }
 
 int32_t monStartSystem() {
-  taos_init();
+  if (taos_init()) {
+    return -1;
+  }
   tsMonitor.start = 1;
   monExecuteSQLFp = monExecuteSQL;
   monInfo("monitor module start");

src/query/inc/qSqlparser.h

@@ -76,6 +76,7 @@ typedef struct SQuerySQL {
 typedef struct SCreatedTableInfo {
   SStrToken  name;        // table name token
   SStrToken  stableName;  // super table name token , for using clause
+  SArray    *pTagNames;   // create by using super table, tag name
   SArray    *pTagVals;    // create by using super table, tag value
   char      *fullname;    // table full name
   STagData   tagdata;     // true tag data, super table full name is in STagData
@@ -246,7 +247,7 @@ SCreateTableSQL *tSetCreateSqlElems(SArray *pCols, SArray *pTags, SQuerySQL *pSe
 void tSqlExprNodeDestroy(tSQLExpr *pExpr);
 
 SAlterTableInfo *  tAlterTableSqlElems(SStrToken *pTableName, SArray *pCols, SArray *pVals, int32_t type, int16_t tableTable);
-SCreatedTableInfo createNewChildTableInfo(SStrToken *pTableName, SArray *pTagVals, SStrToken *pToken, SStrToken* igExists);
+SCreatedTableInfo createNewChildTableInfo(SStrToken *pTableName, SArray *pTagNames, SArray *pTagVals, SStrToken *pToken, SStrToken* igExists);
 
 void destroyAllSelectClause(SSubclauseInfo *pSql);
 void doDestroyQuerySql(SQuerySQL *pSql);

src/query/inc/sql.y

@@ -356,9 +356,20 @@ create_stable_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) LP columnlist(X) RP T
 create_from_stable(A) ::= ifnotexists(U) ids(V) cpxName(Z) USING ids(X) cpxName(F) TAGS LP tagitemlist(Y) RP.  {
   X.n += F.n;
   V.n += Z.n;
-  A = createNewChildTableInfo(&X, Y, &V, &U);
+  A = createNewChildTableInfo(&X, NULL, Y, &V, &U);
 }
 
+create_from_stable(A) ::= ifnotexists(U) ids(V) cpxName(Z) USING ids(X) cpxName(F) LP tagNamelist(P) RP TAGS LP tagitemlist(Y) RP.  {
+  X.n += F.n;
+  V.n += Z.n;
+  A = createNewChildTableInfo(&X, P, Y, &V, &U);
+}
+
+%type tagNamelist{SArray*}
+%destructor tagNamelist {taosArrayDestroy($$);}
+tagNamelist(A) ::= tagNamelist(X) COMMA ids(Y).  {taosArrayPush(X, &Y); A = X;  }
+tagNamelist(A) ::= ids(X).                      {A = taosArrayInit(4, sizeof(SStrToken)); taosArrayPush(A, &X);}
+
 // create stream
 // create table table_name as select count(*) from super_table_name interval(time)
 create_table_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) AS select(S). {

src/query/src/qAggMain.c

@@ -2574,6 +2574,10 @@ static void bottom_function(SQLFunctionCtx *pCtx) {
   
   STopBotInfo *pRes = getTopBotOutputInfo(pCtx);
   
+  if ((void *)pRes->res[0] != (void *)((char *)pRes + sizeof(STopBotInfo) + POINTER_BYTES * pCtx->param[0].i64)) {
+    buildTopBotStruct(pRes, pCtx);
+  }
+  
   for (int32_t i = 0; i < pCtx->size; ++i) {
     char *data = GET_INPUT_DATA(pCtx, i);
     TSKEY ts = GET_TS_DATA(pCtx, i);
@@ -2608,6 +2612,11 @@ static void bottom_function_f(SQLFunctionCtx *pCtx, int32_t index) {
   }
   
   STopBotInfo *pRes = getTopBotOutputInfo(pCtx);
+
+  if ((void *)pRes->res[0] != (void *)((char *)pRes + sizeof(STopBotInfo) + POINTER_BYTES * pCtx->param[0].i64)) {
+    buildTopBotStruct(pRes, pCtx);
+  }
+  
   SET_VAL(pCtx, 1, 1);
   do_bottom_function_add(pRes, (int32_t)pCtx->param[0].i64, pData, ts, pCtx->inputType, &pCtx->tagInfo, NULL, 0);
   

src/query/src/qParserImpl.c

@@ -497,6 +497,7 @@ static void freeVariant(void *pItem) {
 
 void freeCreateTableInfo(void* p) {
   SCreatedTableInfo* pInfo = (SCreatedTableInfo*) p;  
+  taosArrayDestroy(pInfo->pTagNames);
   taosArrayDestroyEx(pInfo->pTagVals, freeVariant);
   tfree(pInfo->fullname);
   tfree(pInfo->tagdata.data);
@@ -574,11 +575,12 @@ SCreateTableSQL *tSetCreateSqlElems(SArray *pCols, SArray *pTags, SQuerySQL *pSe
   return pCreate;
 }
 
-SCreatedTableInfo createNewChildTableInfo(SStrToken *pTableName, SArray *pTagVals, SStrToken *pToken, SStrToken* igExists) {
+SCreatedTableInfo createNewChildTableInfo(SStrToken *pTableName, SArray *pTagNames, SArray *pTagVals, SStrToken *pToken, SStrToken* igExists) {
   SCreatedTableInfo info;
   memset(&info, 0, sizeof(SCreatedTableInfo));
 
   info.name       = *pToken;
+  info.pTagNames  = pTagNames;
   info.pTagVals   = pTagVals;
   info.stableName = *pTableName;
   info.igExist    = (igExists->n > 0)? 1:0;

src/query/src/sql.c

@@ -23,6 +23,7 @@
 ** input grammar file:
 */
 #include <stdio.h>
+#include <assert.h>
 /************ Begin %include sections from the grammar ************************/
 
 #include <stdio.h>
@@ -76,8 +77,10 @@
 **                       zero the stack is dynamically sized using realloc()
 **    ParseARG_SDECL     A static variable declaration for the %extra_argument
 **    ParseARG_PDECL     A parameter declaration for the %extra_argument
+**    ParseARG_PARAM     Code to pass %extra_argument as a subroutine parameter
 **    ParseARG_STORE     Code to store %extra_argument into yypParser
 **    ParseARG_FETCH     Code to extract %extra_argument from yypParser
+**    ParseCTX_*         As ParseARG_ except for %extra_context
 **    YYERRORSYMBOL      is the code number of the error symbol.  If not
 **                       defined, then do no error processing.
 **    YYNSTATE           the combined number of states.
@@ -97,7 +100,7 @@
 #endif
 /************* Begin control #defines *****************************************/
 #define YYCODETYPE unsigned short int
-#define YYNOCODE 282
+#define YYNOCODE 281
 #define YYACTIONTYPE unsigned short int
 #define ParseTOKENTYPE SStrToken
 typedef union {
@@ -124,21 +127,29 @@ typedef union {
 #endif
 #define ParseARG_SDECL SSqlInfo* pInfo;
 #define ParseARG_PDECL ,SSqlInfo* pInfo
-#define ParseARG_FETCH SSqlInfo* pInfo = yypParser->pInfo
-#define ParseARG_STORE yypParser->pInfo = pInfo
+#define ParseARG_PARAM ,pInfo
+#define ParseARG_FETCH SSqlInfo* pInfo=yypParser->pInfo;
+#define ParseARG_STORE yypParser->pInfo=pInfo;
+#define ParseCTX_SDECL
+#define ParseCTX_PDECL
+#define ParseCTX_PARAM
+#define ParseCTX_FETCH
+#define ParseCTX_STORE
 #define YYFALLBACK 1
-#define YYNSTATE             283
-#define YYNRULE              250
+#define YYNSTATE             290
+#define YYNRULE              253
+#define YYNRULE_WITH_ACTION  253
 #define YYNTOKEN             210
-#define YY_MAX_SHIFT         282
-#define YY_MIN_SHIFTREDUCE   463
-#define YY_MAX_SHIFTREDUCE   712
-#define YY_ERROR_ACTION      713
-#define YY_ACCEPT_ACTION     714
-#define YY_NO_ACTION         715
-#define YY_MIN_REDUCE        716
-#define YY_MAX_REDUCE        965
+#define YY_MAX_SHIFT         289
+#define YY_MIN_SHIFTREDUCE   473
+#define YY_MAX_SHIFTREDUCE   725
+#define YY_ERROR_ACTION      726
+#define YY_ACCEPT_ACTION     727
+#define YY_NO_ACTION         728
+#define YY_MIN_REDUCE        729
+#define YY_MAX_REDUCE        981
 /************* End control #defines *******************************************/
+#define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))
 
 /* Define the yytestcase() macro to be a no-op if is not already defined
 ** otherwise.
@@ -203,135 +214,136 @@ typedef union {
 **  yy_default[]       Default action for each state.
 **
 *********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (615)
+#define YY_ACTTAB_COUNT (627)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */   872,  507,  159,  714,  282,  159,   15,  580,  183,  508,
- /*    10 */   663,  186,  948,   41,   42,  947,   43,   44,   26,  158,
- /*    20 */   191,   35,  507,  507,  232,   47,   45,   49,   46,  163,
- /*    30 */   508,  508,  850,   40,   39,  257,  256,   38,   37,   36,
- /*    40 */    41,   42,  118,   43,   44,  861,  664,  191,   35,  179,
- /*    50 */   280,  232,   47,   45,   49,   46,  181,  869,  847,  215,
- /*    60 */    40,   39,  957,  123,   38,   37,   36,  464,  465,  466,
- /*    70 */   467,  468,  469,  470,  471,  472,  473,  474,  475,  281,
- /*    80 */    91,  196,  205,   41,   42,  267,   43,   44,  839,  247,
- /*    90 */   191,   35,  159,  944,  232,   47,   45,   49,   46,  123,
- /*   100 */   220,  185,  948,   40,   39,  850,   62,   38,   37,   36,
- /*   110 */    20,  245,  275,  274,  244,  243,  242,  273,  241,  272,
- /*   120 */   271,  270,  240,  269,  268,  901,  267,  227,  817,  661,
- /*   130 */   805,  806,  807,  808,  809,  810,  811,  812,  813,  814,
- /*   140 */   815,  816,  818,  819,   42,  208,   43,   44,  642,  643,
- /*   150 */   191,   35,  212,  211,  232,   47,   45,   49,   46,  229,
- /*   160 */   861,   67,   21,   40,   39,  247,  276,   38,   37,   36,
- /*   170 */    32,   43,   44,  197,  180,  191,   35,  849,   70,  232,
- /*   180 */    47,   45,   49,   46,   16,   38,   37,   36,   40,   39,
- /*   190 */   850,  123,   38,   37,   36,  190,  674,   72,   26,  665,
- /*   200 */   167,  668,  667,  671,  670,   61,  168,  836,  837,   25,
- /*   210 */   840,  103,  102,  166,  190,  674,  758,  199,  665,  147,
- /*   220 */   668,  767,  671,   20,  147,  275,  274,  187,  188,  841,
- /*   230 */   273,  231,  272,  271,  270,  838,  269,  268,  846,  198,
- /*   240 */   823,   21,  249,  821,  822,  943,  187,  188,  824,   32,
- /*   250 */   826,  827,  825,  900,  828,  829,  123,    3,  137,   47,
- /*   260 */    45,   49,   46,   29,   78,   74,   77,   40,   39,  617,
- /*   270 */   214,   38,   37,   36,  233,  601,  759,  174,  598,  147,
- /*   280 */   599,   26,  600,  201,   89,   93,  254,  253,   26,  942,
- /*   290 */    83,   98,  101,   92,   26,   48,  153,  149,   26,   95,
- /*   300 */   175,   26,  151,  106,  105,  104,  202,  203,  673,   26,
- /*   310 */    69,   40,   39,  200,   48,   38,   37,   36,   68,  194,
- /*   320 */    10,  847,   63,  672,   71,  133,  195,  673,  847,  279,
- /*   330 */   278,  110,  250,  666,  847,  669,  251,  614,  847,  255,
- /*   340 */   116,  847,  672,   22,  621,  848,  609,  259,   32,  847,
- /*   350 */   218,  629,  633,  634,  217,   27,  120,   52,   18,  693,
- /*   360 */   675,  189,   53,  176,   17,   17,  590,  677,   56,  235,
- /*   370 */   591,   27,  100,   99,   27,   52,   82,   81,   12,   11,
- /*   380 */   161,  602,   54,   59,  162,  579,   57,   88,   87,   14,
- /*   390 */    13,  605,  603,  606,  604,  115,  113,  164,  165,  171,
- /*   400 */   911,  172,  170,    4,  157,  169,  160,  910,  192,  907,
- /*   410 */   906,  193,  258,  117,  871,   33,  878,  880,  119,  863,
- /*   420 */   893,  892,  134,  135,  132,  136,  769,   32,  239,  155,
- /*   430 */    30,  248,  766,  216,  962,   79,  961,  114,  959,  138,
- /*   440 */   252,  956,   85,  955,  628,  953,  221,  139,  182,  225,
- /*   450 */   787,   31,   28,   58,  156,  756,   94,  860,   55,   50,
- /*   460 */   754,   96,  230,  124,  228,  125,   97,  752,  126,  127,
- /*   470 */   226,  128,  224,  222,  751,   34,  204,  148,   90,  749,
- /*   480 */   260,  261,  262,  748,  747,  746,  745,  263,  150,  152,
- /*   490 */   742,  740,  264,  738,  736,  734,  265,  154,  266,  219,
- /*   500 */    64,   65,  894,  277,  712,  206,  207,  177,  237,  238,
- /*   510 */   711,  178,  173,  209,   75,  210,  710,  698,  217,  213,
- /*   520 */   750,  611,  107,   60,  744,  234,  142,  141,  788,  140,
- /*   530 */   143,  144,  146,  145,    1,  108,  743,    2,  109,  735,
- /*   540 */    66,    6,  184,  630,  845,  121,  223,  131,  129,  130,
- /*   550 */   635,  122,    5,   23,    7,    8,   24,  676,    9,   19,
- /*   560 */   678,   71,   73,  236,  548,  544,  542,  541,  540,  537,
- /*   570 */   511,  246,   76,   27,   51,  582,   80,   84,  581,  578,
- /*   580 */   532,   86,  530,  522,  528,  524,  526,  520,  518,  550,
- /*   590 */   549,  547,  546,  545,  543,  539,  538,   52,  509,  479,
- /*   600 */   477,  716,  715,  715,  715,  715,  715,  715,  715,  715,
- /*   610 */   715,  715,  715,  111,  112,
+ /*     0 */   888,  517,  727,  289,  517,  182,  287,  590,   28,  518,
+ /*    10 */    15,  161,  518,   43,   44,  771,   45,   46,  150,  162,
+ /*    20 */   194,   37,  126,  517,  238,   49,   47,   51,   48,  963,
+ /*    30 */   166,  518,  186,   42,   41,  264,  263,   40,   39,   38,
+ /*    40 */    43,   44,  877,   45,   46,  877,  184,  194,   37,  863,
+ /*    50 */   121,  238,   49,   47,   51,   48,  183,  866,  885,  221,
+ /*    60 */    42,   41,  126,  126,   40,   39,   38,  474,  475,  476,
+ /*    70 */   477,  478,  479,  480,  481,  482,  483,  484,  485,  288,
+ /*    80 */    43,   44,  211,   45,   46,  916,  254,  194,   37,  162,
+ /*    90 */   630,  238,   49,   47,   51,   48,   71,   94,  189,  964,
+ /*   100 */    42,   41,  274,  960,   40,   39,   38,   64,   65,  226,
+ /*   110 */    21,  252,  282,  281,  251,  250,  249,  280,  248,  279,
+ /*   120 */   278,  277,  247,  276,  275,  917,   70,  233,  830,  674,
+ /*   130 */   818,  819,  820,  821,  822,  823,  824,  825,  826,  827,
+ /*   140 */   828,  829,  831,  832,   44,  199,   45,   46,  274,   28,
+ /*   150 */   194,   37,  162,  959,  238,   49,   47,   51,   48,  860,
+ /*   160 */   201,  188,  964,   42,   41,  634,  214,   40,   39,   38,
+ /*   170 */   866,   45,   46,  218,  217,  194,   37,  958,   72,  238,
+ /*   180 */    49,   47,   51,   48,   16,  866,  205,  197,   42,   41,
+ /*   190 */   863,  283,   40,   39,   38,  193,  687,   22,  200,  678,
+ /*   200 */   170,  681,  203,  684,  178,   34,  171,  849,  850,   27,
+ /*   210 */   853,  106,  105,  169,  193,  687,  866,  179,  678,   75,
+ /*   220 */   681,  780,  684,   21,  150,  282,  281,  190,  191,  164,
+ /*   230 */   280,  237,  279,  278,  277,  614,  276,  275,  611,   10,
+ /*   240 */   612,   22,  613,   74,  165,  136,  190,  191,   63,   34,
+ /*   250 */   836,  854,  207,  834,  835,  261,  260,  167,  837,  852,
+ /*   260 */   839,  840,  838,  126,  841,  842,  208,  209,  204,  168,
+ /*   270 */   220,  256,   49,   47,   51,   48,   28,  177,  851,  927,
+ /*   280 */    42,   41,   92,   96,   40,   39,   38,   28,   86,  101,
+ /*   290 */   104,   95,    3,  140,   28,   50,   28,   98,   31,   81,
+ /*   300 */    77,   80,   28,  156,  152,  119,   28,  206,  686,  154,
+ /*   310 */   109,  108,  107,   34,   50,   42,   41,  862,  224,   40,
+ /*   320 */    39,   38,   29,  685,  235,  198,   69,  686,  863,   40,
+ /*   330 */    39,   38,  257,  192,  258,  863,  254,  863,  676,  864,
+ /*   340 */   262,  615,  685,  863,  266,  655,  656,  863,  286,  285,
+ /*   350 */   113,  772,  627,  622,  150,  680,  642,  683,  646,   23,
+ /*   360 */   123,  223,   54,  647,  706,  688,  239,   18,   17,   17,
+ /*   370 */   679,   55,  682,   26,  677,    4,  244,   58,  600,  241,
+ /*   380 */   602,  243,   29,   29,   54,   73,  601,  174,   85,   84,
+ /*   390 */    54,  175,   56,   12,   11,  173,   59,   91,   90,   61,
+ /*   400 */   973,  589,   14,   13,  618,  616,  619,  617,  103,  102,
+ /*   410 */   118,  116,  160,  172,  163,  865,  926,  195,  923,  922,
+ /*   420 */   196,  265,  879,  120,  887,   35,  909,  894,  896,  908,
+ /*   430 */   122,  137,  859,  135,   34,  138,  139,  782,  222,  246,
+ /*   440 */   158,   32,  255,  779,  117,  978,  641,   82,  977,  975,
+ /*   450 */   141,  259,  972,   88,  971,  227,  969,  142,  800,  690,
+ /*   460 */   185,   33,   30,  159,  231,  769,   97,   60,  876,  128,
+ /*   470 */   767,   99,   57,  127,  236,   52,  234,  232,  230,  100,
+ /*   480 */   765,  764,  130,  210,  228,   36,  151,   93,  762,  267,
+ /*   490 */   268,  269,  270,  761,  760,  271,  759,  272,  273,  758,
+ /*   500 */   153,  155,  755,  753,  751,  284,  749,  747,  157,  725,
+ /*   510 */   225,   66,  212,   67,  910,  213,  724,  215,  216,  723,
+ /*   520 */   180,  202,  711,  245,  219,  181,  176,  223,   78,  624,
+ /*   530 */    62,  763,    6,  240,  110,  111,   68,  757,  145,  643,
+ /*   540 */   144,  801,  143,  146,  147,  149,  148,  756,    1,  124,
+ /*   550 */   112,  187,  748,  229,  125,    2,  648,  861,    7,    8,
+ /*   560 */   689,   24,  133,  131,  129,  132,  134,   25,    5,    9,
+ /*   570 */   691,   19,   20,  242,   76,  558,  554,   74,  552,  551,
+ /*   580 */   550,  547,  253,  521,   83,   29,   79,  592,   53,  591,
+ /*   590 */    87,   89,  588,  542,  540,  532,  538,  534,  536,  530,
+ /*   600 */   528,  560,  559,  557,  556,  555,  553,  549,  548,   54,
+ /*   610 */   519,  489,  487,  729,  728,  728,  728,  728,  728,  728,
+ /*   620 */   728,  728,  728,  728,  728,  114,  115,
 };
 static const YYCODETYPE yy_lookahead[] = {
- /*     0 */   214,    1,  270,  211,  212,  270,  270,    5,  231,    9,
- /*    10 */     1,  279,  280,   13,   14,  280,   16,   17,  214,  270,
- /*    20 */    20,   21,    1,    1,   24,   25,   26,   27,   28,  270,
- /*    30 */     9,    9,  255,   33,   34,   33,   34,   37,   38,   39,
- /*    40 */    13,   14,  214,   16,   17,  253,   37,   20,   21,  213,
- /*    50 */   214,   24,   25,   26,   27,   28,  252,  271,  254,  267,
- /*    60 */    33,   34,  255,  214,   37,   38,   39,   45,   46,   47,
+ /*     0 */   213,    1,  210,  211,    1,  212,  213,    5,  213,    9,
+ /*    10 */   270,  270,    9,   13,   14,  217,   16,   17,  220,  270,
+ /*    20 */    20,   21,  213,    1,   24,   25,   26,   27,   28,  280,
+ /*    30 */   270,    9,  230,   33,   34,   33,   34,   37,   38,   39,
+ /*    40 */    13,   14,  253,   16,   17,  253,  251,   20,   21,  254,
+ /*    50 */   213,   24,   25,   26,   27,   28,  267,  255,  271,  267,
+ /*    60 */    33,   34,  213,  213,   37,   38,   39,   45,   46,   47,
  /*    70 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
- /*    80 */    74,  231,   60,   13,   14,   79,   16,   17,    0,   77,
- /*    90 */    20,   21,  270,  270,   24,   25,   26,   27,   28,  214,
- /*   100 */   272,  279,  280,   33,   34,  255,  106,   37,   38,   39,
+ /*    80 */    13,   14,   60,   16,   17,  276,   77,   20,   21,  270,
+ /*    90 */    37,   24,   25,   26,   27,   28,  256,   74,  279,  280,
+ /*   100 */    33,   34,   79,  270,   37,   38,   39,  107,  268,  272,
  /*   110 */    86,   87,   88,   89,   90,   91,   92,   93,   94,   95,
- /*   120 */    96,   97,   98,   99,  100,  276,   79,  278,  230,  102,
- /*   130 */   232,  233,  234,  235,  236,  237,  238,  239,  240,  241,
- /*   140 */   242,  243,  244,  245,   14,  131,   16,   17,  120,  121,
- /*   150 */    20,   21,  138,  139,   24,   25,   26,   27,   28,  274,
- /*   160 */   253,  276,  101,   33,   34,   77,  231,   37,   38,   39,
- /*   170 */   109,   16,   17,   66,  267,   20,   21,  255,  219,   24,
- /*   180 */    25,   26,   27,   28,   44,   37,   38,   39,   33,   34,
- /*   190 */   255,  214,   37,   38,   39,    1,    2,  219,  214,    5,
- /*   200 */    60,    7,    5,    9,    7,  219,   66,  248,  249,  250,
- /*   210 */   251,   71,   72,   73,    1,    2,  218,   66,    5,  221,
- /*   220 */     7,  218,    9,   86,  221,   88,   89,   33,   34,  251,
- /*   230 */    93,   37,   95,   96,   97,  249,   99,  100,  254,  132,
- /*   240 */   230,  101,  135,  233,  234,  270,   33,   34,  238,  109,
- /*   250 */   240,  241,  242,  276,  244,  245,  214,   61,   62,   25,
- /*   260 */    26,   27,   28,   67,   68,   69,   70,   33,   34,   37,
- /*   270 */   130,   37,   38,   39,   15,    2,  218,  137,    5,  221,
- /*   280 */     7,  214,    9,  132,   61,   62,  135,  136,  214,  270,
- /*   290 */    67,   68,   69,   70,  214,  101,   61,   62,  214,   76,
- /*   300 */   270,  214,   67,   68,   69,   70,   33,   34,  114,  214,
- /*   310 */   256,   33,   34,  214,  101,   37,   38,   39,  276,  252,
- /*   320 */   101,  254,  268,  129,  105,  106,  252,  114,  254,   63,
- /*   330 */    64,   65,  252,    5,  254,    7,  252,  107,  254,  252,
- /*   340 */   101,  254,  129,  113,  112,  246,  102,  252,  109,  254,
- /*   350 */   102,  102,  102,  102,  110,  107,  107,  107,  107,  102,
- /*   360 */   102,   59,  107,  270,  107,  107,  102,  108,  107,  102,
- /*   370 */   102,  107,   74,   75,  107,  107,  133,  134,  133,  134,
- /*   380 */   270,  108,  127,  101,  270,  103,  125,  133,  134,  133,
- /*   390 */   134,    5,    5,    7,    7,   61,   62,  270,  270,  270,
- /*   400 */   247,  270,  270,  101,  270,  270,  270,  247,  247,  247,
- /*   410 */   247,  247,  247,  214,  214,  269,  214,  214,  214,  253,
- /*   420 */   277,  277,  214,  214,  257,  214,  214,  109,  214,  214,
- /*   430 */   214,  214,  214,  253,  214,  214,  214,   59,  214,  214,
- /*   440 */   214,  214,  214,  214,  114,  214,  273,  214,  273,  273,
- /*   450 */   214,  214,  214,  124,  214,  214,  214,  266,  126,  123,
- /*   460 */   214,  214,  118,  265,  122,  264,  214,  214,  263,  262,
- /*   470 */   117,  261,  116,  115,  214,  128,  214,  214,   85,  214,
- /*   480 */    84,   49,   81,  214,  214,  214,  214,   83,  214,  214,
- /*   490 */   214,  214,   53,  214,  214,  214,   82,  214,   80,  215,
- /*   500 */   215,  215,  215,   77,    5,  140,    5,  215,  215,  215,
- /*   510 */     5,  215,  215,  140,  219,    5,    5,   87,  110,  131,
- /*   520 */   215,  102,  216,  111,  215,  104,  223,  227,  229,  228,
- /*   530 */   226,  224,  222,  225,  220,  216,  215,  217,  216,  215,
- /*   540 */   107,  101,    1,  102,  253,  101,  101,  258,  260,  259,
- /*   550 */   102,  101,  101,  107,  119,  119,  107,  102,  101,  101,
- /*   560 */   108,  105,   74,  104,    9,    5,    5,    5,    5,    5,
- /*   570 */    78,   15,   74,  107,   16,    5,  134,  134,    5,  102,
- /*   580 */     5,  134,    5,    5,    5,    5,    5,    5,    5,    5,
- /*   590 */     5,    5,    5,    5,    5,    5,    5,  107,   78,   59,
- /*   600 */    58,    0,  281,  281,  281,  281,  281,  281,  281,  281,
- /*   610 */   281,  281,  281,   21,   21,  281,  281,  281,  281,  281,
- /*   620 */   281,  281,  281,  281,  281,  281,  281,  281,  281,  281,
+ /*   120 */    96,   97,   98,   99,  100,  276,  276,  278,  229,  102,
+ /*   130 */   231,  232,  233,  234,  235,  236,  237,  238,  239,  240,
+ /*   140 */   241,  242,  243,  244,   14,  230,   16,   17,   79,  213,
+ /*   150 */    20,   21,  270,  270,   24,   25,   26,   27,   28,  213,
+ /*   160 */   230,  279,  280,   33,   34,  112,  131,   37,   38,   39,
+ /*   170 */   255,   16,   17,  138,  139,   20,   21,  270,  218,   24,
+ /*   180 */    25,   26,   27,   28,   44,  255,   66,  251,   33,   34,
+ /*   190 */   254,  230,   37,   38,   39,    1,    2,  101,  252,    5,
+ /*   200 */    60,    7,   66,    9,  270,  109,   66,  247,  248,  249,
+ /*   210 */   250,   71,   72,   73,    1,    2,  255,  270,    5,  218,
+ /*   220 */     7,  217,    9,   86,  220,   88,   89,   33,   34,  270,
+ /*   230 */    93,   37,   95,   96,   97,    2,   99,  100,    5,  101,
+ /*   240 */     7,  101,    9,  105,  270,  107,   33,   34,  218,  109,
+ /*   250 */   229,  250,  132,  232,  233,  135,  136,  270,  237,    0,
+ /*   260 */   239,  240,  241,  213,  243,  244,   33,   34,  132,  270,
+ /*   270 */   130,  135,   25,   26,   27,   28,  213,  137,  248,  246,
+ /*   280 */    33,   34,   61,   62,   37,   38,   39,  213,   67,   68,
+ /*   290 */    69,   70,   61,   62,  213,  101,  213,   76,   67,   68,
+ /*   300 */    69,   70,  213,   61,   62,  101,  213,  213,  114,   67,
+ /*   310 */    68,   69,   70,  109,  101,   33,   34,  254,  102,   37,
+ /*   320 */    38,   39,  106,  129,  274,  251,  276,  114,  254,   37,
+ /*   330 */    38,   39,  251,   59,  251,  254,   77,  254,    1,  245,
+ /*   340 */   251,  108,  129,  254,  251,  120,  121,  254,   63,   64,
+ /*   350 */    65,  217,  106,  102,  220,    5,  102,    7,  102,  113,
+ /*   360 */   106,  110,  106,  102,  102,  102,   15,  106,  106,  106,
+ /*   370 */     5,  106,    7,  101,   37,  101,  104,  106,  102,  102,
+ /*   380 */   102,  102,  106,  106,  106,  106,  102,  270,  133,  134,
+ /*   390 */   106,  270,  127,  133,  134,  270,  125,  133,  134,  101,
+ /*   400 */   255,  103,  133,  134,    5,    5,    7,    7,   74,   75,
+ /*   410 */    61,   62,  270,  270,  270,  255,  246,  246,  246,  246,
+ /*   420 */   246,  246,  253,  213,  213,  269,  277,  213,  213,  277,
+ /*   430 */   213,  213,  213,  257,  109,  213,  213,  213,  253,  213,
+ /*   440 */   213,  213,  213,  213,   59,  213,  114,  213,  213,  213,
+ /*   450 */   213,  213,  213,  213,  213,  273,  213,  213,  213,  108,
+ /*   460 */   273,  213,  213,  213,  273,  213,  213,  124,  266,  264,
+ /*   470 */   213,  213,  126,  265,  118,  123,  122,  117,  116,  213,
+ /*   480 */   213,  213,  262,  213,  115,  128,  213,   85,  213,   84,
+ /*   490 */    49,   81,   83,  213,  213,   53,  213,   82,   80,  213,
+ /*   500 */   213,  213,  213,  213,  213,   77,  213,  213,  213,    5,
+ /*   510 */   214,  214,  140,  214,  214,    5,    5,  140,    5,    5,
+ /*   520 */   214,  214,   87,  214,  131,  214,  214,  110,  218,  102,
+ /*   530 */   111,  214,  101,  104,  215,  215,  106,  214,  222,  102,
+ /*   540 */   226,  228,  227,  225,  223,  221,  224,  214,  219,  101,
+ /*   550 */   215,    1,  214,  101,  101,  216,  102,  253,  119,  119,
+ /*   560 */   102,  106,  259,  261,  263,  260,  258,  106,  101,  101,
+ /*   570 */   108,  101,  101,  104,   74,    9,    5,  105,    5,    5,
+ /*   580 */     5,    5,   15,   78,  134,  106,   74,    5,   16,    5,
+ /*   590 */   134,  134,  102,    5,    5,    5,    5,    5,    5,    5,
+ /*   600 */     5,    5,    5,    5,    5,    5,    5,    5,    5,  106,
+ /*   610 */    78,   59,   58,    0,  281,  281,  281,  281,  281,  281,
+ /*   620 */   281,  281,  281,  281,  281,   21,   21,  281,  281,  281,
  /*   630 */   281,  281,  281,  281,  281,  281,  281,  281,  281,  281,
  /*   640 */   281,  281,  281,  281,  281,  281,  281,  281,  281,  281,
  /*   650 */   281,  281,  281,  281,  281,  281,  281,  281,  281,  281,
@@ -351,93 +363,94 @@ static const YYCODETYPE yy_lookahead[] = {
  /*   790 */   281,  281,  281,  281,  281,  281,  281,  281,  281,  281,
  /*   800 */   281,  281,  281,  281,  281,  281,  281,  281,  281,  281,
  /*   810 */   281,  281,  281,  281,  281,  281,  281,  281,  281,  281,
- /*   820 */   281,  281,  281,  281,  281,
+ /*   820 */   281,  281,  281,  281,  281,  281,  281,  281,  281,  281,
+ /*   830 */   281,  281,  281,  281,  281,  281,  281,
 };
-#define YY_SHIFT_COUNT    (282)
+#define YY_SHIFT_COUNT    (289)
 #define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (601)
+#define YY_SHIFT_MAX      (613)
 static const unsigned short int yy_shift_ofst[] = {
- /*     0 */   140,   24,  137,   12,  194,  213,   21,   21,   21,   21,
- /*    10 */    21,   21,   21,   21,   21,    0,   22,  213,  273,  273,
- /*    20 */   273,   61,   21,   21,   21,   88,   21,   21,    6,   12,
- /*    30 */    47,   47,  615,  213,  213,  213,  213,  213,  213,  213,
+ /*     0 */   140,   24,  137,    9,  194,  213,    3,    3,    3,    3,
+ /*    10 */     3,    3,    3,    3,    3,    0,   22,  213,  233,  233,
+ /*    20 */   233,  233,   96,    3,    3,    3,    3,  259,    3,    3,
+ /*    30 */    23,    9,   69,   69,  627,  213,  213,  213,  213,  213,
  /*    40 */   213,  213,  213,  213,  213,  213,  213,  213,  213,  213,
- /*    50 */   213,  273,  273,    2,    2,    2,    2,    2,    2,    2,
- /*    60 */   239,   21,   21,  232,   21,   21,   21,   28,   28,  230,
- /*    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,   21,   21,   21,   21,   21,   21,
- /*   110 */    21,   21,   21,   21,   21,   21,  318,  378,  378,  378,
- /*   120 */   330,  330,  330,  378,  329,  332,  336,  344,  342,  353,
- /*   130 */   356,  358,  347,  318,  378,  378,  378,   12,  378,  378,
- /*   140 */   393,  396,  432,  401,  404,  439,  414,  418,  378,  426,
- /*   150 */   378,  426,  378,  426,  378,  615,  615,   27,   70,   70,
- /*   160 */    70,  130,  155,  234,  234,  234,  223,  196,  235,  278,
- /*   170 */   278,  278,  278,  151,   14,  148,  148,  219,  107,  266,
- /*   180 */   244,  248,  249,  250,  251,  257,  258,  197,  328,    9,
- /*   190 */   302,  259,  255,  261,  264,  267,  268,  243,  245,  254,
- /*   200 */   282,  256,  386,  387,  298,  334,  499,  365,  501,  505,
- /*   210 */   373,  510,  511,  430,  388,  408,  419,  412,  421,  440,
- /*   220 */   433,  441,  444,  541,  445,  448,  450,  446,  435,  449,
- /*   230 */   436,  455,  451,  452,  457,  421,  458,  459,  456,  488,
- /*   240 */   555,  560,  561,  562,  563,  564,  492,  556,  498,  442,
- /*   250 */   466,  466,  558,  443,  447,  466,  570,  573,  477,  466,
- /*   260 */   575,  577,  578,  579,  580,  581,  582,  583,  584,  585,
- /*   270 */   586,  587,  588,  589,  590,  591,  490,  520,  592,  593,
- /*   280 */   540,  542,  601,
+ /*    50 */   213,  213,  213,  233,  233,    2,    2,    2,    2,    2,
+ /*    60 */     2,    2,  204,    3,    3,   53,    3,    3,    3,  225,
+ /*    70 */   225,  246,    3,    3,    3,    3,    3,    3,    3,    3,
+ /*    80 */     3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+ /*    90 */     3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+ /*   100 */     3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+ /*   110 */     3,    3,    3,    3,    3,    3,    3,    3,    3,  325,
+ /*   120 */   385,  385,  385,  332,  332,  332,  385,  343,  346,  352,
+ /*   130 */   356,  354,  360,  362,  369,  357,  325,  385,  385,  385,
+ /*   140 */     9,  385,  385,  402,  405,  441,  410,  409,  442,  415,
+ /*   150 */   418,  385,  428,  385,  428,  385,  428,  385,  627,  627,
+ /*   160 */    27,   67,   67,   67,  130,  155,  247,  247,  247,  221,
+ /*   170 */   231,  242,  282,  282,  282,  282,  120,   35,  292,  292,
+ /*   180 */   138,  136,  285,  251,  216,  254,  256,  261,  262,  263,
+ /*   190 */   350,  365,  337,  274,  351,  265,  271,  276,  277,  278,
+ /*   200 */   279,  284,  272,  255,  260,  264,  298,  269,  399,  400,
+ /*   210 */   334,  349,  504,  372,  510,  511,  377,  513,  514,  435,
+ /*   220 */   393,  417,  427,  419,  429,  431,  430,  437,  448,  550,
+ /*   230 */   452,  454,  453,  455,  439,  461,  440,  458,  467,  462,
+ /*   240 */   468,  429,  470,  469,  471,  472,  500,  566,  571,  573,
+ /*   250 */   574,  575,  576,  505,  567,  512,  450,  479,  479,  572,
+ /*   260 */   456,  457,  479,  582,  584,  490,  479,  588,  589,  590,
+ /*   270 */   591,  592,  593,  594,  595,  596,  597,  598,  599,  600,
+ /*   280 */   601,  602,  603,  503,  532,  604,  605,  552,  554,  613,
 };
-#define YY_REDUCE_COUNT (156)
-#define YY_REDUCE_MIN   (-268)
-#define YY_REDUCE_MAX   (324)
+#define YY_REDUCE_COUNT (159)
+#define YY_REDUCE_MIN   (-260)
+#define YY_REDUCE_MAX   (339)
 static const short yy_reduce_ofst[] = {
- /*     0 */  -208, -102,   10,  -41, -268, -178, -196, -151, -115,   67,
- /*    10 */    74,   80,   84,   87,   95, -214, -164, -265, -223, -150,
- /*    20 */   -65,  -93, -172,  -23,   42,  -22,   99,  -16,   -2,  -14,
- /*    30 */     3,   58,   54, -264, -251, -241, -177,  -25,   19,   30,
- /*    40 */    93,  110,  114,  127,  128,  129,  131,  132,  134,  135,
- /*    50 */   136, -193,  -78,  153,  160,  161,  162,  163,  164,  165,
- /*    60 */   166,  199,  200,  146,  202,  203,  204,  143,  144,  167,
- /*    70 */   208,  209,  211,  212,  214,  215,  216,  217,  218,  220,
- /*    80 */   221,  222,  224,  225,  226,  227,  228,  229,  231,  233,
- /*    90 */   236,  237,  238,  240,  241,  242,  246,  247,  252,  253,
- /*   100 */   260,  262,  263,  265,  269,  270,  271,  272,  274,  275,
- /*   110 */   276,  277,  279,  280,  281,  283,  180,  284,  285,  286,
- /*   120 */   173,  175,  176,  287,  191,  198,  201,  205,  207,  210,
- /*   130 */   288,  290,  289,  291,  292,  293,  294,  295,  296,  297,
- /*   140 */   299,  301,  300,  303,  304,  307,  308,  310,  305,  306,
- /*   150 */   309,  319,  321,  322,  324,  314,  320,
+ /*     0 */  -208, -101,   21,  -40, -181, -118, -205, -151,   50,  -64,
+ /*    10 */    74,   81,   83,   89,   93, -213, -207, -251, -198,  -85,
+ /*    20 */   -70,  -39, -211, -163, -191, -150,  -54,    1,   94,   63,
+ /*    30 */  -202,   30,    4,  134, -160, -260, -259, -240, -167, -117,
+ /*    40 */   -93,  -66,  -53,  -41,  -26,  -13,   -1,  117,  121,  125,
+ /*    50 */   142,  143,  144,  145,  160,   33,  170,  171,  172,  173,
+ /*    60 */   174,  175,  169,  210,  211,  156,  214,  215,  217,  149,
+ /*    70 */   152,  176,  218,  219,  222,  223,  224,  226,  227,  228,
+ /*    80 */   229,  230,  232,  234,  235,  236,  237,  238,  239,  240,
+ /*    90 */   241,  243,  244,  245,  248,  249,  250,  252,  253,  257,
+ /*   100 */   258,  266,  267,  268,  270,  273,  275,  280,  281,  283,
+ /*   110 */   286,  287,  288,  289,  290,  291,  293,  294,  295,  185,
+ /*   120 */   296,  297,  299,  182,  187,  191,  300,  202,  208,  205,
+ /*   130 */   301,  220,  302,  305,  303,  308,  304,  306,  307,  309,
+ /*   140 */   310,  311,  312,  313,  315,  314,  316,  318,  321,  322,
+ /*   150 */   324,  317,  319,  323,  320,  333,  335,  338,  329,  339,
 };
 static const YYACTIONTYPE yy_default[] = {
- /*     0 */   713,  768,  757,  765,  950,  950,  713,  713,  713,  713,
- /*    10 */   713,  713,  713,  713,  713,  873,  731,  950,  713,  713,
- /*    20 */   713,  713,  713,  713,  713,  765,  713,  713,  770,  765,
- /*    30 */   770,  770,  868,  713,  713,  713,  713,  713,  713,  713,
- /*    40 */   713,  713,  713,  713,  713,  713,  713,  713,  713,  713,
- /*    50 */   713,  713,  713,  713,  713,  713,  713,  713,  713,  713,
- /*    60 */   713,  713,  713,  875,  877,  879,  713,  897,  897,  866,
- /*    70 */   713,  713,  713,  713,  713,  713,  713,  713,  713,  713,
- /*    80 */   713,  713,  713,  713,  713,  713,  713,  713,  713,  713,
- /*    90 */   713,  713,  713,  713,  755,  713,  753,  713,  713,  713,
- /*   100 */   713,  713,  713,  713,  713,  713,  713,  713,  713,  713,
- /*   110 */   741,  713,  713,  713,  713,  713,  713,  733,  733,  733,
- /*   120 */   713,  713,  713,  733,  904,  908,  902,  890,  898,  889,
- /*   130 */   885,  884,  912,  713,  733,  733,  733,  765,  733,  733,
- /*   140 */   786,  784,  782,  774,  780,  776,  778,  772,  733,  763,
- /*   150 */   733,  763,  733,  763,  733,  804,  820,  713,  913,  949,
- /*   160 */   903,  939,  938,  945,  937,  936,  713,  713,  713,  932,
- /*   170 */   933,  935,  934,  713,  713,  941,  940,  713,  713,  713,
- /*   180 */   713,  713,  713,  713,  713,  713,  713,  713,  713,  713,
- /*   190 */   915,  713,  909,  905,  713,  713,  713,  713,  713,  713,
- /*   200 */   830,  713,  713,  713,  713,  713,  713,  713,  713,  713,
- /*   210 */   713,  713,  713,  713,  713,  865,  713,  713,  713,  713,
- /*   220 */   876,  713,  713,  713,  713,  713,  713,  899,  713,  891,
- /*   230 */   713,  713,  713,  713,  713,  842,  713,  713,  713,  713,
- /*   240 */   713,  713,  713,  713,  713,  713,  713,  713,  713,  713,
- /*   250 */   960,  958,  713,  713,  713,  954,  713,  713,  713,  952,
- /*   260 */   713,  713,  713,  713,  713,  713,  713,  713,  713,  713,
- /*   270 */   713,  713,  713,  713,  713,  713,  789,  713,  739,  737,
- /*   280 */   713,  729,  713,
+ /*     0 */   726,  781,  770,  778,  966,  966,  726,  726,  726,  726,
+ /*    10 */   726,  726,  726,  726,  726,  889,  744,  966,  726,  726,
+ /*    20 */   726,  726,  726,  726,  726,  726,  726,  778,  726,  726,
+ /*    30 */   783,  778,  783,  783,  884,  726,  726,  726,  726,  726,
+ /*    40 */   726,  726,  726,  726,  726,  726,  726,  726,  726,  726,
+ /*    50 */   726,  726,  726,  726,  726,  726,  726,  726,  726,  726,
+ /*    60 */   726,  726,  726,  726,  726,  891,  893,  895,  726,  913,
+ /*    70 */   913,  882,  726,  726,  726,  726,  726,  726,  726,  726,
+ /*    80 */   726,  726,  726,  726,  726,  726,  726,  726,  726,  726,
+ /*    90 */   726,  726,  726,  726,  726,  726,  726,  768,  726,  766,
+ /*   100 */   726,  726,  726,  726,  726,  726,  726,  726,  726,  726,
+ /*   110 */   726,  726,  726,  754,  726,  726,  726,  726,  726,  726,
+ /*   120 */   746,  746,  746,  726,  726,  726,  746,  920,  924,  918,
+ /*   130 */   906,  914,  905,  901,  900,  928,  726,  746,  746,  746,
+ /*   140 */   778,  746,  746,  799,  797,  795,  787,  793,  789,  791,
+ /*   150 */   785,  746,  776,  746,  776,  746,  776,  746,  817,  833,
+ /*   160 */   726,  929,  965,  919,  955,  954,  961,  953,  952,  726,
+ /*   170 */   726,  726,  948,  949,  951,  950,  726,  726,  957,  956,
+ /*   180 */   726,  726,  726,  726,  726,  726,  726,  726,  726,  726,
+ /*   190 */   726,  726,  726,  931,  726,  925,  921,  726,  726,  726,
+ /*   200 */   726,  726,  726,  726,  726,  726,  843,  726,  726,  726,
+ /*   210 */   726,  726,  726,  726,  726,  726,  726,  726,  726,  726,
+ /*   220 */   726,  881,  726,  726,  726,  726,  892,  726,  726,  726,
+ /*   230 */   726,  726,  726,  915,  726,  907,  726,  726,  726,  726,
+ /*   240 */   726,  855,  726,  726,  726,  726,  726,  726,  726,  726,
+ /*   250 */   726,  726,  726,  726,  726,  726,  726,  976,  974,  726,
+ /*   260 */   726,  726,  970,  726,  726,  726,  968,  726,  726,  726,
+ /*   270 */   726,  726,  726,  726,  726,  726,  726,  726,  726,  726,
+ /*   280 */   726,  726,  726,  802,  726,  752,  750,  726,  742,  726,
 };
 /********** End of lemon-generated parsing tables *****************************/
 
@@ -563,8 +576,8 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*   UNSIGNED => nothing */
     0,  /*       TAGS => nothing */
     0,  /*      USING => nothing */
-    0,  /*         AS => nothing */
     0,  /*      COMMA => nothing */
+    0,  /*         AS => nothing */
     1,  /*       NULL => ID */
     0,  /*     SELECT => nothing */
     0,  /*      UNION => nothing */
@@ -706,6 +719,7 @@ struct yyParser {
   int yyerrcnt;                 /* Shifts left before out of the error */
 #endif
   ParseARG_SDECL                /* A place to hold %extra_argument */
+  ParseCTX_SDECL                /* A place to hold %extra_context */
 #if YYSTACKDEPTH<=0
   int yystksz;                  /* Current side of the stack */
   yyStackEntry *yystack;        /* The parser's stack */
@@ -859,8 +873,8 @@ static const char *const yyTokenName[] = {
   /*  103 */ "UNSIGNED",
   /*  104 */ "TAGS",
   /*  105 */ "USING",
-  /*  106 */ "AS",
-  /*  107 */ "COMMA",
+  /*  106 */ "COMMA",
+  /*  107 */ "AS",
   /*  108 */ "NULL",
   /*  109 */ "SELECT",
   /*  110 */ "UNION",
@@ -963,49 +977,49 @@ static const char *const yyTokenName[] = {
   /*  207 */ "INSERT",
   /*  208 */ "INTO",
   /*  209 */ "VALUES",
-  /*  210 */ "error",
-  /*  211 */ "program",
-  /*  212 */ "cmd",
-  /*  213 */ "dbPrefix",
-  /*  214 */ "ids",
-  /*  215 */ "cpxName",
-  /*  216 */ "ifexists",
-  /*  217 */ "alter_db_optr",
-  /*  218 */ "acct_optr",
-  /*  219 */ "ifnotexists",
-  /*  220 */ "db_optr",
-  /*  221 */ "pps",
-  /*  222 */ "tseries",
-  /*  223 */ "dbs",
-  /*  224 */ "streams",
-  /*  225 */ "storage",
-  /*  226 */ "qtime",
-  /*  227 */ "users",
-  /*  228 */ "conns",
-  /*  229 */ "state",
-  /*  230 */ "keep",
-  /*  231 */ "tagitemlist",
-  /*  232 */ "cache",
-  /*  233 */ "replica",
-  /*  234 */ "quorum",
-  /*  235 */ "days",
-  /*  236 */ "minrows",
-  /*  237 */ "maxrows",
-  /*  238 */ "blocks",
-  /*  239 */ "ctime",
-  /*  240 */ "wal",
-  /*  241 */ "fsync",
-  /*  242 */ "comp",
-  /*  243 */ "prec",
-  /*  244 */ "update",
-  /*  245 */ "cachelast",
-  /*  246 */ "typename",
-  /*  247 */ "signed",
-  /*  248 */ "create_table_args",
-  /*  249 */ "create_stable_args",
-  /*  250 */ "create_table_list",
-  /*  251 */ "create_from_stable",
-  /*  252 */ "columnlist",
+  /*  210 */ "program",
+  /*  211 */ "cmd",
+  /*  212 */ "dbPrefix",
+  /*  213 */ "ids",
+  /*  214 */ "cpxName",
+  /*  215 */ "ifexists",
+  /*  216 */ "alter_db_optr",
+  /*  217 */ "acct_optr",
+  /*  218 */ "ifnotexists",
+  /*  219 */ "db_optr",
+  /*  220 */ "pps",
+  /*  221 */ "tseries",
+  /*  222 */ "dbs",
+  /*  223 */ "streams",
+  /*  224 */ "storage",
+  /*  225 */ "qtime",
+  /*  226 */ "users",
+  /*  227 */ "conns",
+  /*  228 */ "state",
+  /*  229 */ "keep",
+  /*  230 */ "tagitemlist",
+  /*  231 */ "cache",
+  /*  232 */ "replica",
+  /*  233 */ "quorum",
+  /*  234 */ "days",
+  /*  235 */ "minrows",
+  /*  236 */ "maxrows",
+  /*  237 */ "blocks",
+  /*  238 */ "ctime",
+  /*  239 */ "wal",
+  /*  240 */ "fsync",
+  /*  241 */ "comp",
+  /*  242 */ "prec",
+  /*  243 */ "update",
+  /*  244 */ "cachelast",
+  /*  245 */ "typename",
+  /*  246 */ "signed",
+  /*  247 */ "create_table_args",
+  /*  248 */ "create_stable_args",
+  /*  249 */ "create_table_list",
+  /*  250 */ "create_from_stable",
+  /*  251 */ "columnlist",
+  /*  252 */ "tagNamelist",
   /*  253 */ "select",
   /*  254 */ "column",
   /*  255 */ "tagitem",
@@ -1170,127 +1184,130 @@ static const char *const yyRuleName[] = {
  /* 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 distinct expr as",
- /* 154 */ "selcollist ::= sclp STAR",
- /* 155 */ "as ::= AS ids",
- /* 156 */ "as ::= ids",
- /* 157 */ "as ::=",
- /* 158 */ "distinct ::= DISTINCT",
- /* 159 */ "distinct ::=",
- /* 160 */ "from ::= FROM tablelist",
- /* 161 */ "tablelist ::= ids cpxName",
- /* 162 */ "tablelist ::= ids cpxName ids",
- /* 163 */ "tablelist ::= tablelist COMMA ids cpxName",
- /* 164 */ "tablelist ::= tablelist COMMA ids cpxName ids",
- /* 165 */ "tmvar ::= VARIABLE",
- /* 166 */ "interval_opt ::= INTERVAL LP tmvar RP",
- /* 167 */ "interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP",
- /* 168 */ "interval_opt ::=",
- /* 169 */ "fill_opt ::=",
- /* 170 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
- /* 171 */ "fill_opt ::= FILL LP ID RP",
- /* 172 */ "sliding_opt ::= SLIDING LP tmvar RP",
- /* 173 */ "sliding_opt ::=",
- /* 174 */ "orderby_opt ::=",
- /* 175 */ "orderby_opt ::= ORDER BY sortlist",
- /* 176 */ "sortlist ::= sortlist COMMA item sortorder",
- /* 177 */ "sortlist ::= item sortorder",
- /* 178 */ "item ::= ids cpxName",
- /* 179 */ "sortorder ::= ASC",
- /* 180 */ "sortorder ::= DESC",
- /* 181 */ "sortorder ::=",
- /* 182 */ "groupby_opt ::=",
- /* 183 */ "groupby_opt ::= GROUP BY grouplist",
- /* 184 */ "grouplist ::= grouplist COMMA item",
- /* 185 */ "grouplist ::= item",
- /* 186 */ "having_opt ::=",
- /* 187 */ "having_opt ::= HAVING expr",
- /* 188 */ "limit_opt ::=",
- /* 189 */ "limit_opt ::= LIMIT signed",
- /* 190 */ "limit_opt ::= LIMIT signed OFFSET signed",
- /* 191 */ "limit_opt ::= LIMIT signed COMMA signed",
- /* 192 */ "slimit_opt ::=",
- /* 193 */ "slimit_opt ::= SLIMIT signed",
- /* 194 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
- /* 195 */ "slimit_opt ::= SLIMIT signed COMMA signed",
- /* 196 */ "where_opt ::=",
- /* 197 */ "where_opt ::= WHERE expr",
- /* 198 */ "expr ::= LP expr RP",
- /* 199 */ "expr ::= ID",
- /* 200 */ "expr ::= ID DOT ID",
- /* 201 */ "expr ::= ID DOT STAR",
- /* 202 */ "expr ::= INTEGER",
- /* 203 */ "expr ::= MINUS INTEGER",
- /* 204 */ "expr ::= PLUS INTEGER",
- /* 205 */ "expr ::= FLOAT",
- /* 206 */ "expr ::= MINUS FLOAT",
- /* 207 */ "expr ::= PLUS FLOAT",
- /* 208 */ "expr ::= STRING",
- /* 209 */ "expr ::= NOW",
- /* 210 */ "expr ::= VARIABLE",
- /* 211 */ "expr ::= BOOL",
- /* 212 */ "expr ::= ID LP exprlist RP",
- /* 213 */ "expr ::= ID LP STAR RP",
- /* 214 */ "expr ::= expr IS NULL",
- /* 215 */ "expr ::= expr IS NOT NULL",
- /* 216 */ "expr ::= expr LT expr",
- /* 217 */ "expr ::= expr GT expr",
- /* 218 */ "expr ::= expr LE expr",
- /* 219 */ "expr ::= expr GE expr",
- /* 220 */ "expr ::= expr NE expr",
- /* 221 */ "expr ::= expr EQ expr",
- /* 222 */ "expr ::= expr AND expr",
- /* 223 */ "expr ::= expr OR expr",
- /* 224 */ "expr ::= expr PLUS expr",
- /* 225 */ "expr ::= expr MINUS expr",
- /* 226 */ "expr ::= expr STAR expr",
- /* 227 */ "expr ::= expr SLASH expr",
- /* 228 */ "expr ::= expr REM expr",
- /* 229 */ "expr ::= expr LIKE expr",
- /* 230 */ "expr ::= expr IN LP exprlist RP",
- /* 231 */ "exprlist ::= exprlist COMMA expritem",
- /* 232 */ "exprlist ::= expritem",
- /* 233 */ "expritem ::= expr",
- /* 234 */ "expritem ::=",
- /* 235 */ "cmd ::= RESET QUERY CACHE",
- /* 236 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
- /* 237 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
- /* 238 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
- /* 239 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
- /* 240 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
- /* 241 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
- /* 242 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist",
- /* 243 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids",
- /* 244 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist",
- /* 245 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids",
- /* 246 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids",
- /* 247 */ "cmd ::= KILL CONNECTION INTEGER",
- /* 248 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
- /* 249 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
+ /* 129 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP",
+ /* 130 */ "tagNamelist ::= tagNamelist COMMA ids",
+ /* 131 */ "tagNamelist ::= ids",
+ /* 132 */ "create_table_args ::= ifnotexists ids cpxName AS select",
+ /* 133 */ "columnlist ::= columnlist COMMA column",
+ /* 134 */ "columnlist ::= column",
+ /* 135 */ "column ::= ids typename",
+ /* 136 */ "tagitemlist ::= tagitemlist COMMA tagitem",
+ /* 137 */ "tagitemlist ::= tagitem",
+ /* 138 */ "tagitem ::= INTEGER",
+ /* 139 */ "tagitem ::= FLOAT",
+ /* 140 */ "tagitem ::= STRING",
+ /* 141 */ "tagitem ::= BOOL",
+ /* 142 */ "tagitem ::= NULL",
+ /* 143 */ "tagitem ::= MINUS INTEGER",
+ /* 144 */ "tagitem ::= MINUS FLOAT",
+ /* 145 */ "tagitem ::= PLUS INTEGER",
+ /* 146 */ "tagitem ::= PLUS FLOAT",
+ /* 147 */ "select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt",
+ /* 148 */ "union ::= select",
+ /* 149 */ "union ::= LP union RP",
+ /* 150 */ "union ::= union UNION ALL select",
+ /* 151 */ "union ::= union UNION ALL LP select RP",
+ /* 152 */ "cmd ::= union",
+ /* 153 */ "select ::= SELECT selcollist",
+ /* 154 */ "sclp ::= selcollist COMMA",
+ /* 155 */ "sclp ::=",
+ /* 156 */ "selcollist ::= sclp distinct expr as",
+ /* 157 */ "selcollist ::= sclp STAR",
+ /* 158 */ "as ::= AS ids",
+ /* 159 */ "as ::= ids",
+ /* 160 */ "as ::=",
+ /* 161 */ "distinct ::= DISTINCT",
+ /* 162 */ "distinct ::=",
+ /* 163 */ "from ::= FROM tablelist",
+ /* 164 */ "tablelist ::= ids cpxName",
+ /* 165 */ "tablelist ::= ids cpxName ids",
+ /* 166 */ "tablelist ::= tablelist COMMA ids cpxName",
+ /* 167 */ "tablelist ::= tablelist COMMA ids cpxName ids",
+ /* 168 */ "tmvar ::= VARIABLE",
+ /* 169 */ "interval_opt ::= INTERVAL LP tmvar RP",
+ /* 170 */ "interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP",
+ /* 171 */ "interval_opt ::=",
+ /* 172 */ "fill_opt ::=",
+ /* 173 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
+ /* 174 */ "fill_opt ::= FILL LP ID RP",
+ /* 175 */ "sliding_opt ::= SLIDING LP tmvar RP",
+ /* 176 */ "sliding_opt ::=",
+ /* 177 */ "orderby_opt ::=",
+ /* 178 */ "orderby_opt ::= ORDER BY sortlist",
+ /* 179 */ "sortlist ::= sortlist COMMA item sortorder",
+ /* 180 */ "sortlist ::= item sortorder",
+ /* 181 */ "item ::= ids cpxName",
+ /* 182 */ "sortorder ::= ASC",
+ /* 183 */ "sortorder ::= DESC",
+ /* 184 */ "sortorder ::=",
+ /* 185 */ "groupby_opt ::=",
+ /* 186 */ "groupby_opt ::= GROUP BY grouplist",
+ /* 187 */ "grouplist ::= grouplist COMMA item",
+ /* 188 */ "grouplist ::= item",
+ /* 189 */ "having_opt ::=",
+ /* 190 */ "having_opt ::= HAVING expr",
+ /* 191 */ "limit_opt ::=",
+ /* 192 */ "limit_opt ::= LIMIT signed",
+ /* 193 */ "limit_opt ::= LIMIT signed OFFSET signed",
+ /* 194 */ "limit_opt ::= LIMIT signed COMMA signed",
+ /* 195 */ "slimit_opt ::=",
+ /* 196 */ "slimit_opt ::= SLIMIT signed",
+ /* 197 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
+ /* 198 */ "slimit_opt ::= SLIMIT signed COMMA signed",
+ /* 199 */ "where_opt ::=",
+ /* 200 */ "where_opt ::= WHERE expr",
+ /* 201 */ "expr ::= LP expr RP",
+ /* 202 */ "expr ::= ID",
+ /* 203 */ "expr ::= ID DOT ID",
+ /* 204 */ "expr ::= ID DOT STAR",
+ /* 205 */ "expr ::= INTEGER",
+ /* 206 */ "expr ::= MINUS INTEGER",
+ /* 207 */ "expr ::= PLUS INTEGER",
+ /* 208 */ "expr ::= FLOAT",
+ /* 209 */ "expr ::= MINUS FLOAT",
+ /* 210 */ "expr ::= PLUS FLOAT",
+ /* 211 */ "expr ::= STRING",
+ /* 212 */ "expr ::= NOW",
+ /* 213 */ "expr ::= VARIABLE",
+ /* 214 */ "expr ::= BOOL",
+ /* 215 */ "expr ::= ID LP exprlist RP",
+ /* 216 */ "expr ::= ID LP STAR RP",
+ /* 217 */ "expr ::= expr IS NULL",
+ /* 218 */ "expr ::= expr IS NOT NULL",
+ /* 219 */ "expr ::= expr LT expr",
+ /* 220 */ "expr ::= expr GT expr",
+ /* 221 */ "expr ::= expr LE expr",
+ /* 222 */ "expr ::= expr GE expr",
+ /* 223 */ "expr ::= expr NE expr",
+ /* 224 */ "expr ::= expr EQ expr",
+ /* 225 */ "expr ::= expr AND expr",
+ /* 226 */ "expr ::= expr OR expr",
+ /* 227 */ "expr ::= expr PLUS expr",
+ /* 228 */ "expr ::= expr MINUS expr",
+ /* 229 */ "expr ::= expr STAR expr",
+ /* 230 */ "expr ::= expr SLASH expr",
+ /* 231 */ "expr ::= expr REM expr",
+ /* 232 */ "expr ::= expr LIKE expr",
+ /* 233 */ "expr ::= expr IN LP exprlist RP",
+ /* 234 */ "exprlist ::= exprlist COMMA expritem",
+ /* 235 */ "exprlist ::= expritem",
+ /* 236 */ "expritem ::= expr",
+ /* 237 */ "expritem ::=",
+ /* 238 */ "cmd ::= RESET QUERY CACHE",
+ /* 239 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
+ /* 240 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
+ /* 241 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
+ /* 242 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
+ /* 243 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
+ /* 244 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
+ /* 245 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist",
+ /* 246 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids",
+ /* 247 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist",
+ /* 248 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids",
+ /* 249 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids",
+ /* 250 */ "cmd ::= KILL CONNECTION INTEGER",
+ /* 251 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
+ /* 252 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
 };
 #endif /* NDEBUG */
 
@@ -1339,28 +1356,29 @@ static int yyGrowStack(yyParser *p){
 
 /* Initialize a new parser that has already been allocated.
 */
-void ParseInit(void *yypParser){
-  yyParser *pParser = (yyParser*)yypParser;
+void ParseInit(void *yypRawParser ParseCTX_PDECL){
+  yyParser *yypParser = (yyParser*)yypRawParser;
+  ParseCTX_STORE
 #ifdef YYTRACKMAXSTACKDEPTH
-  pParser->yyhwm = 0;
+  yypParser->yyhwm = 0;
 #endif
 #if YYSTACKDEPTH<=0
-  pParser->yytos = NULL;
-  pParser->yystack = NULL;
-  pParser->yystksz = 0;
-  if( yyGrowStack(pParser) ){
-    pParser->yystack = &pParser->yystk0;
-    pParser->yystksz = 1;
+  yypParser->yytos = NULL;
+  yypParser->yystack = NULL;
+  yypParser->yystksz = 0;
+  if( yyGrowStack(yypParser) ){
+    yypParser->yystack = &yypParser->yystk0;
+    yypParser->yystksz = 1;
   }
 #endif
 #ifndef YYNOERRORRECOVERY
-  pParser->yyerrcnt = -1;
+  yypParser->yyerrcnt = -1;
 #endif
-  pParser->yytos = pParser->yystack;
-  pParser->yystack[0].stateno = 0;
-  pParser->yystack[0].major = 0;
+  yypParser->yytos = yypParser->yystack;
+  yypParser->yystack[0].stateno = 0;
+  yypParser->yystack[0].major = 0;
 #if YYSTACKDEPTH>0
-  pParser->yystackEnd = &pParser->yystack[YYSTACKDEPTH-1];
+  yypParser->yystackEnd = &yypParser->yystack[YYSTACKDEPTH-1];
 #endif
 }
 
@@ -1377,11 +1395,14 @@ void ParseInit(void *yypParser){
 ** A pointer to a parser.  This pointer is used in subsequent calls
 ** to Parse and ParseFree.
 */
-void *ParseAlloc(void *(*mallocProc)(YYMALLOCARGTYPE)){
-  yyParser *pParser;
-  pParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) );
-  if( pParser ) ParseInit(pParser);
-  return pParser;
+void *ParseAlloc(void *(*mallocProc)(YYMALLOCARGTYPE) ParseCTX_PDECL){
+  yyParser *yypParser;
+  yypParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) );
+  if( yypParser ){
+    ParseCTX_STORE
+    ParseInit(yypParser ParseCTX_PARAM);
+  }
+  return (void*)yypParser;
 }
 #endif /* Parse_ENGINEALWAYSONSTACK */
 
@@ -1398,7 +1419,8 @@ static void yy_destructor(
   YYCODETYPE yymajor,     /* Type code for object to destroy */
   YYMINORTYPE *yypminor   /* The object to be destroyed */
 ){
-  ParseARG_FETCH;
+  ParseARG_FETCH
+  ParseCTX_FETCH
   switch( yymajor ){
     /* Here is inserted the actions which take place when a
     ** terminal or non-terminal is destroyed.  This can happen
@@ -1411,9 +1433,10 @@ static void yy_destructor(
     ** inside the C code.
     */
 /********* Begin destructor definitions ***************************************/
-    case 230: /* keep */
-    case 231: /* tagitemlist */
-    case 252: /* columnlist */
+    case 229: /* keep */
+    case 230: /* tagitemlist */
+    case 251: /* columnlist */
+    case 252: /* tagNamelist */
     case 260: /* fill_opt */
     case 262: /* groupby_opt */
     case 263: /* orderby_opt */
@@ -1423,7 +1446,7 @@ static void yy_destructor(
 taosArrayDestroy((yypminor->yy247));
 }
       break;
-    case 250: /* create_table_list */
+    case 249: /* create_table_list */
 {
 destroyCreateTableSql((yypminor->yy358));
 }
@@ -1567,12 +1590,11 @@ int ParseCoverage(FILE *out){
 ** Find the appropriate action for a parser given the terminal
 ** look-ahead token iLookAhead.
 */
-static unsigned int yy_find_shift_action(
-  yyParser *pParser,        /* The parser */
-  YYCODETYPE iLookAhead     /* The look-ahead token */
+static YYACTIONTYPE yy_find_shift_action(
+  YYCODETYPE iLookAhead,    /* The look-ahead token */
+  YYACTIONTYPE stateno      /* Current state number */
 ){
   int i;
-  int stateno = pParser->yytos->stateno;
 
   if( stateno>YY_MAX_SHIFT ) return stateno;
   assert( stateno <= YY_SHIFT_COUNT );
@@ -1581,15 +1603,19 @@ static unsigned int yy_find_shift_action(
 #endif
   do{
     i = yy_shift_ofst[stateno];
-    assert( i>=0 && i+YYNTOKEN<=sizeof(yy_lookahead)/sizeof(yy_lookahead[0]) );
+    assert( i>=0 );
+    assert( i<=YY_ACTTAB_COUNT );
+    assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD );
     assert( iLookAhead!=YYNOCODE );
     assert( iLookAhead < YYNTOKEN );
     i += iLookAhead;
+    assert( i<(int)YY_NLOOKAHEAD );
     if( yy_lookahead[i]!=iLookAhead ){
 #ifdef YYFALLBACK
       YYCODETYPE iFallback;            /* Fallback token */
-      if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
-             && (iFallback = yyFallback[iLookAhead])!=0 ){
+      assert( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0]) );
+      iFallback = yyFallback[iLookAhead];
+      if( iFallback!=0 ){
 #ifndef NDEBUG
         if( yyTraceFILE ){
           fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
@@ -1604,15 +1630,8 @@ static unsigned int yy_find_shift_action(
 #ifdef YYWILDCARD
       {
         int j = i - iLookAhead + YYWILDCARD;
-        if( 
-#if YY_SHIFT_MIN+YYWILDCARD<0
-          j>=0 &&
-#endif
-#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
-          j<YY_ACTTAB_COUNT &&
-#endif
-          yy_lookahead[j]==YYWILDCARD && iLookAhead>0
-        ){
+        assert( j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) );
+        if( yy_lookahead[j]==YYWILDCARD && iLookAhead>0 ){
 #ifndef NDEBUG
           if( yyTraceFILE ){
             fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
@@ -1626,6 +1645,7 @@ static unsigned int yy_find_shift_action(
 #endif /* YYWILDCARD */
       return yy_default[stateno];
     }else{
+      assert( i>=0 && i<sizeof(yy_action)/sizeof(yy_action[0]) );
       return yy_action[i];
     }
   }while(1);
@@ -1635,8 +1655,8 @@ static unsigned int yy_find_shift_action(
 ** Find the appropriate action for a parser given the non-terminal
 ** look-ahead token iLookAhead.
 */
-static int yy_find_reduce_action(
-  int stateno,              /* Current state number */
+static YYACTIONTYPE yy_find_reduce_action(
+  YYACTIONTYPE stateno,     /* Current state number */
   YYCODETYPE iLookAhead     /* The look-ahead token */
 ){
   int i;
@@ -1665,7 +1685,8 @@ static int yy_find_reduce_action(
 ** The following routine is called if the stack overflows.
 */
 static void yyStackOverflow(yyParser *yypParser){
-   ParseARG_FETCH;
+   ParseARG_FETCH
+   ParseCTX_FETCH
 #ifndef NDEBUG
    if( yyTraceFILE ){
      fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
@@ -1676,7 +1697,8 @@ static void yyStackOverflow(yyParser *yypParser){
    ** stack every overflows */
 /******** Begin %stack_overflow code ******************************************/
 /******** End %stack_overflow code ********************************************/
-   ParseARG_STORE; /* Suppress warning about unused %extra_argument var */
+   ParseARG_STORE /* Suppress warning about unused %extra_argument var */
+   ParseCTX_STORE
 }
 
 /*
@@ -1705,8 +1727,8 @@ static void yyTraceShift(yyParser *yypParser, int yyNewState, const char *zTag){
 */
 static void yy_shift(
   yyParser *yypParser,          /* The parser to be shifted */
-  int yyNewState,               /* The new state to shift in */
-  int yyMajor,                  /* The major token to shift in */
+  YYACTIONTYPE yyNewState,      /* The new state to shift in */
+  YYCODETYPE yyMajor,           /* The major token to shift in */
   ParseTOKENTYPE yyMinor        /* The minor token to shift in */
 ){
   yyStackEntry *yytos;
@@ -1736,269 +1758,526 @@ static void yy_shift(
     yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
   }
   yytos = yypParser->yytos;
-  yytos->stateno = (YYACTIONTYPE)yyNewState;
-  yytos->major = (YYCODETYPE)yyMajor;
+  yytos->stateno = yyNewState;
+  yytos->major = yyMajor;
   yytos->minor.yy0 = yyMinor;
   yyTraceShift(yypParser, yyNewState, "Shift");
 }
 
-/* The following table contains information about every rule that
-** is used during the reduce.
-*/
-static const struct {
-  YYCODETYPE lhs;       /* Symbol on the left-hand side of the rule */
-  signed char nrhs;     /* Negative of the number of RHS symbols in the rule */
-} yyRuleInfo[] = {
-  {  211,   -1 }, /* (0) program ::= cmd */
-  {  212,   -2 }, /* (1) cmd ::= SHOW DATABASES */
-  {  212,   -2 }, /* (2) cmd ::= SHOW MNODES */
-  {  212,   -2 }, /* (3) cmd ::= SHOW DNODES */
-  {  212,   -2 }, /* (4) cmd ::= SHOW ACCOUNTS */
-  {  212,   -2 }, /* (5) cmd ::= SHOW USERS */
-  {  212,   -2 }, /* (6) cmd ::= SHOW MODULES */
-  {  212,   -2 }, /* (7) cmd ::= SHOW QUERIES */
-  {  212,   -2 }, /* (8) cmd ::= SHOW CONNECTIONS */
-  {  212,   -2 }, /* (9) cmd ::= SHOW STREAMS */
-  {  212,   -2 }, /* (10) cmd ::= SHOW VARIABLES */
-  {  212,   -2 }, /* (11) cmd ::= SHOW SCORES */
-  {  212,   -2 }, /* (12) cmd ::= SHOW GRANTS */
-  {  212,   -2 }, /* (13) cmd ::= SHOW VNODES */
-  {  212,   -3 }, /* (14) cmd ::= SHOW VNODES IPTOKEN */
-  {  213,    0 }, /* (15) dbPrefix ::= */
-  {  213,   -2 }, /* (16) dbPrefix ::= ids DOT */
-  {  215,    0 }, /* (17) cpxName ::= */
-  {  215,   -2 }, /* (18) cpxName ::= DOT ids */
-  {  212,   -5 }, /* (19) cmd ::= SHOW CREATE TABLE ids cpxName */
-  {  212,   -4 }, /* (20) cmd ::= SHOW CREATE DATABASE ids */
-  {  212,   -3 }, /* (21) cmd ::= SHOW dbPrefix TABLES */
-  {  212,   -5 }, /* (22) cmd ::= SHOW dbPrefix TABLES LIKE ids */
-  {  212,   -3 }, /* (23) cmd ::= SHOW dbPrefix STABLES */
-  {  212,   -5 }, /* (24) cmd ::= SHOW dbPrefix STABLES LIKE ids */
-  {  212,   -3 }, /* (25) cmd ::= SHOW dbPrefix VGROUPS */
-  {  212,   -4 }, /* (26) cmd ::= SHOW dbPrefix VGROUPS ids */
-  {  212,   -5 }, /* (27) cmd ::= DROP TABLE ifexists ids cpxName */
-  {  212,   -5 }, /* (28) cmd ::= DROP STABLE ifexists ids cpxName */
-  {  212,   -4 }, /* (29) cmd ::= DROP DATABASE ifexists ids */
-  {  212,   -3 }, /* (30) cmd ::= DROP DNODE ids */
-  {  212,   -3 }, /* (31) cmd ::= DROP USER ids */
-  {  212,   -3 }, /* (32) cmd ::= DROP ACCOUNT ids */
-  {  212,   -2 }, /* (33) cmd ::= USE ids */
-  {  212,   -3 }, /* (34) cmd ::= DESCRIBE ids cpxName */
-  {  212,   -5 }, /* (35) cmd ::= ALTER USER ids PASS ids */
-  {  212,   -5 }, /* (36) cmd ::= ALTER USER ids PRIVILEGE ids */
-  {  212,   -4 }, /* (37) cmd ::= ALTER DNODE ids ids */
-  {  212,   -5 }, /* (38) cmd ::= ALTER DNODE ids ids ids */
-  {  212,   -3 }, /* (39) cmd ::= ALTER LOCAL ids */
-  {  212,   -4 }, /* (40) cmd ::= ALTER LOCAL ids ids */
-  {  212,   -4 }, /* (41) cmd ::= ALTER DATABASE ids alter_db_optr */
-  {  212,   -4 }, /* (42) cmd ::= ALTER ACCOUNT ids acct_optr */
-  {  212,   -6 }, /* (43) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
-  {  214,   -1 }, /* (44) ids ::= ID */
-  {  214,   -1 }, /* (45) ids ::= STRING */
-  {  216,   -2 }, /* (46) ifexists ::= IF EXISTS */
-  {  216,    0 }, /* (47) ifexists ::= */
-  {  219,   -3 }, /* (48) ifnotexists ::= IF NOT EXISTS */
-  {  219,    0 }, /* (49) ifnotexists ::= */
-  {  212,   -3 }, /* (50) cmd ::= CREATE DNODE ids */
-  {  212,   -6 }, /* (51) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
-  {  212,   -5 }, /* (52) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
-  {  212,   -5 }, /* (53) cmd ::= CREATE USER ids PASS ids */
-  {  221,    0 }, /* (54) pps ::= */
-  {  221,   -2 }, /* (55) pps ::= PPS INTEGER */
-  {  222,    0 }, /* (56) tseries ::= */
-  {  222,   -2 }, /* (57) tseries ::= TSERIES INTEGER */
-  {  223,    0 }, /* (58) dbs ::= */
-  {  223,   -2 }, /* (59) dbs ::= DBS INTEGER */
-  {  224,    0 }, /* (60) streams ::= */
-  {  224,   -2 }, /* (61) streams ::= STREAMS INTEGER */
-  {  225,    0 }, /* (62) storage ::= */
-  {  225,   -2 }, /* (63) storage ::= STORAGE INTEGER */
-  {  226,    0 }, /* (64) qtime ::= */
-  {  226,   -2 }, /* (65) qtime ::= QTIME INTEGER */
-  {  227,    0 }, /* (66) users ::= */
-  {  227,   -2 }, /* (67) users ::= USERS INTEGER */
-  {  228,    0 }, /* (68) conns ::= */
-  {  228,   -2 }, /* (69) conns ::= CONNS INTEGER */
-  {  229,    0 }, /* (70) state ::= */
-  {  229,   -2 }, /* (71) state ::= STATE ids */
-  {  218,   -9 }, /* (72) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
-  {  230,   -2 }, /* (73) keep ::= KEEP tagitemlist */
-  {  232,   -2 }, /* (74) cache ::= CACHE INTEGER */
-  {  233,   -2 }, /* (75) replica ::= REPLICA INTEGER */
-  {  234,   -2 }, /* (76) quorum ::= QUORUM INTEGER */
-  {  235,   -2 }, /* (77) days ::= DAYS INTEGER */
-  {  236,   -2 }, /* (78) minrows ::= MINROWS INTEGER */
-  {  237,   -2 }, /* (79) maxrows ::= MAXROWS INTEGER */
-  {  238,   -2 }, /* (80) blocks ::= BLOCKS INTEGER */
-  {  239,   -2 }, /* (81) ctime ::= CTIME INTEGER */
-  {  240,   -2 }, /* (82) wal ::= WAL INTEGER */
-  {  241,   -2 }, /* (83) fsync ::= FSYNC INTEGER */
-  {  242,   -2 }, /* (84) comp ::= COMP INTEGER */
-  {  243,   -2 }, /* (85) prec ::= PRECISION STRING */
-  {  244,   -2 }, /* (86) update ::= UPDATE INTEGER */
-  {  245,   -2 }, /* (87) cachelast ::= CACHELAST INTEGER */
-  {  220,    0 }, /* (88) db_optr ::= */
-  {  220,   -2 }, /* (89) db_optr ::= db_optr cache */
-  {  220,   -2 }, /* (90) db_optr ::= db_optr replica */
-  {  220,   -2 }, /* (91) db_optr ::= db_optr quorum */
-  {  220,   -2 }, /* (92) db_optr ::= db_optr days */
-  {  220,   -2 }, /* (93) db_optr ::= db_optr minrows */
-  {  220,   -2 }, /* (94) db_optr ::= db_optr maxrows */
-  {  220,   -2 }, /* (95) db_optr ::= db_optr blocks */
-  {  220,   -2 }, /* (96) db_optr ::= db_optr ctime */
-  {  220,   -2 }, /* (97) db_optr ::= db_optr wal */
-  {  220,   -2 }, /* (98) db_optr ::= db_optr fsync */
-  {  220,   -2 }, /* (99) db_optr ::= db_optr comp */
-  {  220,   -2 }, /* (100) db_optr ::= db_optr prec */
-  {  220,   -2 }, /* (101) db_optr ::= db_optr keep */
-  {  220,   -2 }, /* (102) db_optr ::= db_optr update */
-  {  220,   -2 }, /* (103) db_optr ::= db_optr cachelast */
-  {  217,    0 }, /* (104) alter_db_optr ::= */
-  {  217,   -2 }, /* (105) alter_db_optr ::= alter_db_optr replica */
-  {  217,   -2 }, /* (106) alter_db_optr ::= alter_db_optr quorum */
-  {  217,   -2 }, /* (107) alter_db_optr ::= alter_db_optr keep */
-  {  217,   -2 }, /* (108) alter_db_optr ::= alter_db_optr blocks */
-  {  217,   -2 }, /* (109) alter_db_optr ::= alter_db_optr comp */
-  {  217,   -2 }, /* (110) alter_db_optr ::= alter_db_optr wal */
-  {  217,   -2 }, /* (111) alter_db_optr ::= alter_db_optr fsync */
-  {  217,   -2 }, /* (112) alter_db_optr ::= alter_db_optr update */
-  {  217,   -2 }, /* (113) alter_db_optr ::= alter_db_optr cachelast */
-  {  246,   -1 }, /* (114) typename ::= ids */
-  {  246,   -4 }, /* (115) typename ::= ids LP signed RP */
-  {  246,   -2 }, /* (116) typename ::= ids UNSIGNED */
-  {  247,   -1 }, /* (117) signed ::= INTEGER */
-  {  247,   -2 }, /* (118) signed ::= PLUS INTEGER */
-  {  247,   -2 }, /* (119) signed ::= MINUS INTEGER */
-  {  212,   -3 }, /* (120) cmd ::= CREATE TABLE create_table_args */
-  {  212,   -3 }, /* (121) cmd ::= CREATE TABLE create_stable_args */
-  {  212,   -3 }, /* (122) cmd ::= CREATE STABLE create_stable_args */
-  {  212,   -3 }, /* (123) cmd ::= CREATE TABLE create_table_list */
-  {  250,   -1 }, /* (124) create_table_list ::= create_from_stable */
-  {  250,   -2 }, /* (125) create_table_list ::= create_table_list create_from_stable */
-  {  248,   -6 }, /* (126) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
-  {  249,  -10 }, /* (127) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
-  {  251,  -10 }, /* (128) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
-  {  248,   -5 }, /* (129) create_table_args ::= ifnotexists ids cpxName AS select */
-  {  252,   -3 }, /* (130) columnlist ::= columnlist COMMA column */
-  {  252,   -1 }, /* (131) columnlist ::= column */
-  {  254,   -2 }, /* (132) column ::= ids typename */
-  {  231,   -3 }, /* (133) tagitemlist ::= tagitemlist COMMA tagitem */
-  {  231,   -1 }, /* (134) tagitemlist ::= tagitem */
-  {  255,   -1 }, /* (135) tagitem ::= INTEGER */
-  {  255,   -1 }, /* (136) tagitem ::= FLOAT */
-  {  255,   -1 }, /* (137) tagitem ::= STRING */
-  {  255,   -1 }, /* (138) tagitem ::= BOOL */
-  {  255,   -1 }, /* (139) tagitem ::= NULL */
-  {  255,   -2 }, /* (140) tagitem ::= MINUS INTEGER */
-  {  255,   -2 }, /* (141) tagitem ::= MINUS FLOAT */
-  {  255,   -2 }, /* (142) tagitem ::= PLUS INTEGER */
-  {  255,   -2 }, /* (143) tagitem ::= PLUS FLOAT */
-  {  253,  -12 }, /* (144) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
-  {  267,   -1 }, /* (145) union ::= select */
-  {  267,   -3 }, /* (146) union ::= LP union RP */
-  {  267,   -4 }, /* (147) union ::= union UNION ALL select */
-  {  267,   -6 }, /* (148) union ::= union UNION ALL LP select RP */
-  {  212,   -1 }, /* (149) cmd ::= union */
-  {  253,   -2 }, /* (150) select ::= SELECT selcollist */
-  {  268,   -2 }, /* (151) sclp ::= selcollist COMMA */
-  {  268,    0 }, /* (152) sclp ::= */
-  {  256,   -4 }, /* (153) selcollist ::= sclp distinct expr as */
-  {  256,   -2 }, /* (154) selcollist ::= sclp STAR */
-  {  271,   -2 }, /* (155) as ::= AS ids */
-  {  271,   -1 }, /* (156) as ::= ids */
-  {  271,    0 }, /* (157) as ::= */
-  {  269,   -1 }, /* (158) distinct ::= DISTINCT */
-  {  269,    0 }, /* (159) distinct ::= */
-  {  257,   -2 }, /* (160) from ::= FROM tablelist */
-  {  272,   -2 }, /* (161) tablelist ::= ids cpxName */
-  {  272,   -3 }, /* (162) tablelist ::= ids cpxName ids */
-  {  272,   -4 }, /* (163) tablelist ::= tablelist COMMA ids cpxName */
-  {  272,   -5 }, /* (164) tablelist ::= tablelist COMMA ids cpxName ids */
-  {  273,   -1 }, /* (165) tmvar ::= VARIABLE */
-  {  259,   -4 }, /* (166) interval_opt ::= INTERVAL LP tmvar RP */
-  {  259,   -6 }, /* (167) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
-  {  259,    0 }, /* (168) interval_opt ::= */
-  {  260,    0 }, /* (169) fill_opt ::= */
-  {  260,   -6 }, /* (170) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
-  {  260,   -4 }, /* (171) fill_opt ::= FILL LP ID RP */
-  {  261,   -4 }, /* (172) sliding_opt ::= SLIDING LP tmvar RP */
-  {  261,    0 }, /* (173) sliding_opt ::= */
-  {  263,    0 }, /* (174) orderby_opt ::= */
-  {  263,   -3 }, /* (175) orderby_opt ::= ORDER BY sortlist */
-  {  274,   -4 }, /* (176) sortlist ::= sortlist COMMA item sortorder */
-  {  274,   -2 }, /* (177) sortlist ::= item sortorder */
-  {  276,   -2 }, /* (178) item ::= ids cpxName */
-  {  277,   -1 }, /* (179) sortorder ::= ASC */
-  {  277,   -1 }, /* (180) sortorder ::= DESC */
-  {  277,    0 }, /* (181) sortorder ::= */
-  {  262,    0 }, /* (182) groupby_opt ::= */
-  {  262,   -3 }, /* (183) groupby_opt ::= GROUP BY grouplist */
-  {  278,   -3 }, /* (184) grouplist ::= grouplist COMMA item */
-  {  278,   -1 }, /* (185) grouplist ::= item */
-  {  264,    0 }, /* (186) having_opt ::= */
-  {  264,   -2 }, /* (187) having_opt ::= HAVING expr */
-  {  266,    0 }, /* (188) limit_opt ::= */
-  {  266,   -2 }, /* (189) limit_opt ::= LIMIT signed */
-  {  266,   -4 }, /* (190) limit_opt ::= LIMIT signed OFFSET signed */
-  {  266,   -4 }, /* (191) limit_opt ::= LIMIT signed COMMA signed */
-  {  265,    0 }, /* (192) slimit_opt ::= */
-  {  265,   -2 }, /* (193) slimit_opt ::= SLIMIT signed */
-  {  265,   -4 }, /* (194) slimit_opt ::= SLIMIT signed SOFFSET signed */
-  {  265,   -4 }, /* (195) slimit_opt ::= SLIMIT signed COMMA signed */
-  {  258,    0 }, /* (196) where_opt ::= */
-  {  258,   -2 }, /* (197) where_opt ::= WHERE expr */
-  {  270,   -3 }, /* (198) expr ::= LP expr RP */
-  {  270,   -1 }, /* (199) expr ::= ID */
-  {  270,   -3 }, /* (200) expr ::= ID DOT ID */
-  {  270,   -3 }, /* (201) expr ::= ID DOT STAR */
-  {  270,   -1 }, /* (202) expr ::= INTEGER */
-  {  270,   -2 }, /* (203) expr ::= MINUS INTEGER */
-  {  270,   -2 }, /* (204) expr ::= PLUS INTEGER */
-  {  270,   -1 }, /* (205) expr ::= FLOAT */
-  {  270,   -2 }, /* (206) expr ::= MINUS FLOAT */
-  {  270,   -2 }, /* (207) expr ::= PLUS FLOAT */
-  {  270,   -1 }, /* (208) expr ::= STRING */
-  {  270,   -1 }, /* (209) expr ::= NOW */
-  {  270,   -1 }, /* (210) expr ::= VARIABLE */
-  {  270,   -1 }, /* (211) expr ::= BOOL */
-  {  270,   -4 }, /* (212) expr ::= ID LP exprlist RP */
-  {  270,   -4 }, /* (213) expr ::= ID LP STAR RP */
-  {  270,   -3 }, /* (214) expr ::= expr IS NULL */
-  {  270,   -4 }, /* (215) expr ::= expr IS NOT NULL */
-  {  270,   -3 }, /* (216) expr ::= expr LT expr */
-  {  270,   -3 }, /* (217) expr ::= expr GT expr */
-  {  270,   -3 }, /* (218) expr ::= expr LE expr */
-  {  270,   -3 }, /* (219) expr ::= expr GE expr */
-  {  270,   -3 }, /* (220) expr ::= expr NE expr */
-  {  270,   -3 }, /* (221) expr ::= expr EQ expr */
-  {  270,   -3 }, /* (222) expr ::= expr AND expr */
-  {  270,   -3 }, /* (223) expr ::= expr OR expr */
-  {  270,   -3 }, /* (224) expr ::= expr PLUS expr */
-  {  270,   -3 }, /* (225) expr ::= expr MINUS expr */
-  {  270,   -3 }, /* (226) expr ::= expr STAR expr */
-  {  270,   -3 }, /* (227) expr ::= expr SLASH expr */
-  {  270,   -3 }, /* (228) expr ::= expr REM expr */
-  {  270,   -3 }, /* (229) expr ::= expr LIKE expr */
-  {  270,   -5 }, /* (230) expr ::= expr IN LP exprlist RP */
-  {  279,   -3 }, /* (231) exprlist ::= exprlist COMMA expritem */
-  {  279,   -1 }, /* (232) exprlist ::= expritem */
-  {  280,   -1 }, /* (233) expritem ::= expr */
-  {  280,    0 }, /* (234) expritem ::= */
-  {  212,   -3 }, /* (235) cmd ::= RESET QUERY CACHE */
-  {  212,   -7 }, /* (236) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
-  {  212,   -7 }, /* (237) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
-  {  212,   -7 }, /* (238) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
-  {  212,   -7 }, /* (239) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
-  {  212,   -8 }, /* (240) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
-  {  212,   -9 }, /* (241) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
-  {  212,   -7 }, /* (242) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
-  {  212,   -7 }, /* (243) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
-  {  212,   -7 }, /* (244) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
-  {  212,   -7 }, /* (245) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
-  {  212,   -8 }, /* (246) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
-  {  212,   -3 }, /* (247) cmd ::= KILL CONNECTION INTEGER */
-  {  212,   -5 }, /* (248) cmd ::= KILL STREAM INTEGER COLON INTEGER */
-  {  212,   -5 }, /* (249) cmd ::= KILL QUERY INTEGER COLON INTEGER */
+/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side
+** of that rule */
+static const YYCODETYPE yyRuleInfoLhs[] = {
+   210,  /* (0) program ::= cmd */
+   211,  /* (1) cmd ::= SHOW DATABASES */
+   211,  /* (2) cmd ::= SHOW MNODES */
+   211,  /* (3) cmd ::= SHOW DNODES */
+   211,  /* (4) cmd ::= SHOW ACCOUNTS */
+   211,  /* (5) cmd ::= SHOW USERS */
+   211,  /* (6) cmd ::= SHOW MODULES */
+   211,  /* (7) cmd ::= SHOW QUERIES */
+   211,  /* (8) cmd ::= SHOW CONNECTIONS */
+   211,  /* (9) cmd ::= SHOW STREAMS */
+   211,  /* (10) cmd ::= SHOW VARIABLES */
+   211,  /* (11) cmd ::= SHOW SCORES */
+   211,  /* (12) cmd ::= SHOW GRANTS */
+   211,  /* (13) cmd ::= SHOW VNODES */
+   211,  /* (14) cmd ::= SHOW VNODES IPTOKEN */
+   212,  /* (15) dbPrefix ::= */
+   212,  /* (16) dbPrefix ::= ids DOT */
+   214,  /* (17) cpxName ::= */
+   214,  /* (18) cpxName ::= DOT ids */
+   211,  /* (19) cmd ::= SHOW CREATE TABLE ids cpxName */
+   211,  /* (20) cmd ::= SHOW CREATE DATABASE ids */
+   211,  /* (21) cmd ::= SHOW dbPrefix TABLES */
+   211,  /* (22) cmd ::= SHOW dbPrefix TABLES LIKE ids */
+   211,  /* (23) cmd ::= SHOW dbPrefix STABLES */
+   211,  /* (24) cmd ::= SHOW dbPrefix STABLES LIKE ids */
+   211,  /* (25) cmd ::= SHOW dbPrefix VGROUPS */
+   211,  /* (26) cmd ::= SHOW dbPrefix VGROUPS ids */
+   211,  /* (27) cmd ::= DROP TABLE ifexists ids cpxName */
+   211,  /* (28) cmd ::= DROP STABLE ifexists ids cpxName */
+   211,  /* (29) cmd ::= DROP DATABASE ifexists ids */
+   211,  /* (30) cmd ::= DROP DNODE ids */
+   211,  /* (31) cmd ::= DROP USER ids */
+   211,  /* (32) cmd ::= DROP ACCOUNT ids */
+   211,  /* (33) cmd ::= USE ids */
+   211,  /* (34) cmd ::= DESCRIBE ids cpxName */
+   211,  /* (35) cmd ::= ALTER USER ids PASS ids */
+   211,  /* (36) cmd ::= ALTER USER ids PRIVILEGE ids */
+   211,  /* (37) cmd ::= ALTER DNODE ids ids */
+   211,  /* (38) cmd ::= ALTER DNODE ids ids ids */
+   211,  /* (39) cmd ::= ALTER LOCAL ids */
+   211,  /* (40) cmd ::= ALTER LOCAL ids ids */
+   211,  /* (41) cmd ::= ALTER DATABASE ids alter_db_optr */
+   211,  /* (42) cmd ::= ALTER ACCOUNT ids acct_optr */
+   211,  /* (43) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
+   213,  /* (44) ids ::= ID */
+   213,  /* (45) ids ::= STRING */
+   215,  /* (46) ifexists ::= IF EXISTS */
+   215,  /* (47) ifexists ::= */
+   218,  /* (48) ifnotexists ::= IF NOT EXISTS */
+   218,  /* (49) ifnotexists ::= */
+   211,  /* (50) cmd ::= CREATE DNODE ids */
+   211,  /* (51) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
+   211,  /* (52) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
+   211,  /* (53) cmd ::= CREATE USER ids PASS ids */
+   220,  /* (54) pps ::= */
+   220,  /* (55) pps ::= PPS INTEGER */
+   221,  /* (56) tseries ::= */
+   221,  /* (57) tseries ::= TSERIES INTEGER */
+   222,  /* (58) dbs ::= */
+   222,  /* (59) dbs ::= DBS INTEGER */
+   223,  /* (60) streams ::= */
+   223,  /* (61) streams ::= STREAMS INTEGER */
+   224,  /* (62) storage ::= */
+   224,  /* (63) storage ::= STORAGE INTEGER */
+   225,  /* (64) qtime ::= */
+   225,  /* (65) qtime ::= QTIME INTEGER */
+   226,  /* (66) users ::= */
+   226,  /* (67) users ::= USERS INTEGER */
+   227,  /* (68) conns ::= */
+   227,  /* (69) conns ::= CONNS INTEGER */
+   228,  /* (70) state ::= */
+   228,  /* (71) state ::= STATE ids */
+   217,  /* (72) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
+   229,  /* (73) keep ::= KEEP tagitemlist */
+   231,  /* (74) cache ::= CACHE INTEGER */
+   232,  /* (75) replica ::= REPLICA INTEGER */
+   233,  /* (76) quorum ::= QUORUM INTEGER */
+   234,  /* (77) days ::= DAYS INTEGER */
+   235,  /* (78) minrows ::= MINROWS INTEGER */
+   236,  /* (79) maxrows ::= MAXROWS INTEGER */
+   237,  /* (80) blocks ::= BLOCKS INTEGER */
+   238,  /* (81) ctime ::= CTIME INTEGER */
+   239,  /* (82) wal ::= WAL INTEGER */
+   240,  /* (83) fsync ::= FSYNC INTEGER */
+   241,  /* (84) comp ::= COMP INTEGER */
+   242,  /* (85) prec ::= PRECISION STRING */
+   243,  /* (86) update ::= UPDATE INTEGER */
+   244,  /* (87) cachelast ::= CACHELAST INTEGER */
+   219,  /* (88) db_optr ::= */
+   219,  /* (89) db_optr ::= db_optr cache */
+   219,  /* (90) db_optr ::= db_optr replica */
+   219,  /* (91) db_optr ::= db_optr quorum */
+   219,  /* (92) db_optr ::= db_optr days */
+   219,  /* (93) db_optr ::= db_optr minrows */
+   219,  /* (94) db_optr ::= db_optr maxrows */
+   219,  /* (95) db_optr ::= db_optr blocks */
+   219,  /* (96) db_optr ::= db_optr ctime */
+   219,  /* (97) db_optr ::= db_optr wal */
+   219,  /* (98) db_optr ::= db_optr fsync */
+   219,  /* (99) db_optr ::= db_optr comp */
+   219,  /* (100) db_optr ::= db_optr prec */
+   219,  /* (101) db_optr ::= db_optr keep */
+   219,  /* (102) db_optr ::= db_optr update */
+   219,  /* (103) db_optr ::= db_optr cachelast */
+   216,  /* (104) alter_db_optr ::= */
+   216,  /* (105) alter_db_optr ::= alter_db_optr replica */
+   216,  /* (106) alter_db_optr ::= alter_db_optr quorum */
+   216,  /* (107) alter_db_optr ::= alter_db_optr keep */
+   216,  /* (108) alter_db_optr ::= alter_db_optr blocks */
+   216,  /* (109) alter_db_optr ::= alter_db_optr comp */
+   216,  /* (110) alter_db_optr ::= alter_db_optr wal */
+   216,  /* (111) alter_db_optr ::= alter_db_optr fsync */
+   216,  /* (112) alter_db_optr ::= alter_db_optr update */
+   216,  /* (113) alter_db_optr ::= alter_db_optr cachelast */
+   245,  /* (114) typename ::= ids */
+   245,  /* (115) typename ::= ids LP signed RP */
+   245,  /* (116) typename ::= ids UNSIGNED */
+   246,  /* (117) signed ::= INTEGER */
+   246,  /* (118) signed ::= PLUS INTEGER */
+   246,  /* (119) signed ::= MINUS INTEGER */
+   211,  /* (120) cmd ::= CREATE TABLE create_table_args */
+   211,  /* (121) cmd ::= CREATE TABLE create_stable_args */
+   211,  /* (122) cmd ::= CREATE STABLE create_stable_args */
+   211,  /* (123) cmd ::= CREATE TABLE create_table_list */
+   249,  /* (124) create_table_list ::= create_from_stable */
+   249,  /* (125) create_table_list ::= create_table_list create_from_stable */
+   247,  /* (126) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
+   248,  /* (127) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
+   250,  /* (128) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
+   250,  /* (129) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
+   252,  /* (130) tagNamelist ::= tagNamelist COMMA ids */
+   252,  /* (131) tagNamelist ::= ids */
+   247,  /* (132) create_table_args ::= ifnotexists ids cpxName AS select */
+   251,  /* (133) columnlist ::= columnlist COMMA column */
+   251,  /* (134) columnlist ::= column */
+   254,  /* (135) column ::= ids typename */
+   230,  /* (136) tagitemlist ::= tagitemlist COMMA tagitem */
+   230,  /* (137) tagitemlist ::= tagitem */
+   255,  /* (138) tagitem ::= INTEGER */
+   255,  /* (139) tagitem ::= FLOAT */
+   255,  /* (140) tagitem ::= STRING */
+   255,  /* (141) tagitem ::= BOOL */
+   255,  /* (142) tagitem ::= NULL */
+   255,  /* (143) tagitem ::= MINUS INTEGER */
+   255,  /* (144) tagitem ::= MINUS FLOAT */
+   255,  /* (145) tagitem ::= PLUS INTEGER */
+   255,  /* (146) tagitem ::= PLUS FLOAT */
+   253,  /* (147) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
+   267,  /* (148) union ::= select */
+   267,  /* (149) union ::= LP union RP */
+   267,  /* (150) union ::= union UNION ALL select */
+   267,  /* (151) union ::= union UNION ALL LP select RP */
+   211,  /* (152) cmd ::= union */
+   253,  /* (153) select ::= SELECT selcollist */
+   268,  /* (154) sclp ::= selcollist COMMA */
+   268,  /* (155) sclp ::= */
+   256,  /* (156) selcollist ::= sclp distinct expr as */
+   256,  /* (157) selcollist ::= sclp STAR */
+   271,  /* (158) as ::= AS ids */
+   271,  /* (159) as ::= ids */
+   271,  /* (160) as ::= */
+   269,  /* (161) distinct ::= DISTINCT */
+   269,  /* (162) distinct ::= */
+   257,  /* (163) from ::= FROM tablelist */
+   272,  /* (164) tablelist ::= ids cpxName */
+   272,  /* (165) tablelist ::= ids cpxName ids */
+   272,  /* (166) tablelist ::= tablelist COMMA ids cpxName */
+   272,  /* (167) tablelist ::= tablelist COMMA ids cpxName ids */
+   273,  /* (168) tmvar ::= VARIABLE */
+   259,  /* (169) interval_opt ::= INTERVAL LP tmvar RP */
+   259,  /* (170) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
+   259,  /* (171) interval_opt ::= */
+   260,  /* (172) fill_opt ::= */
+   260,  /* (173) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+   260,  /* (174) fill_opt ::= FILL LP ID RP */
+   261,  /* (175) sliding_opt ::= SLIDING LP tmvar RP */
+   261,  /* (176) sliding_opt ::= */
+   263,  /* (177) orderby_opt ::= */
+   263,  /* (178) orderby_opt ::= ORDER BY sortlist */
+   274,  /* (179) sortlist ::= sortlist COMMA item sortorder */
+   274,  /* (180) sortlist ::= item sortorder */
+   276,  /* (181) item ::= ids cpxName */
+   277,  /* (182) sortorder ::= ASC */
+   277,  /* (183) sortorder ::= DESC */
+   277,  /* (184) sortorder ::= */
+   262,  /* (185) groupby_opt ::= */
+   262,  /* (186) groupby_opt ::= GROUP BY grouplist */
+   278,  /* (187) grouplist ::= grouplist COMMA item */
+   278,  /* (188) grouplist ::= item */
+   264,  /* (189) having_opt ::= */
+   264,  /* (190) having_opt ::= HAVING expr */
+   266,  /* (191) limit_opt ::= */
+   266,  /* (192) limit_opt ::= LIMIT signed */
+   266,  /* (193) limit_opt ::= LIMIT signed OFFSET signed */
+   266,  /* (194) limit_opt ::= LIMIT signed COMMA signed */
+   265,  /* (195) slimit_opt ::= */
+   265,  /* (196) slimit_opt ::= SLIMIT signed */
+   265,  /* (197) slimit_opt ::= SLIMIT signed SOFFSET signed */
+   265,  /* (198) slimit_opt ::= SLIMIT signed COMMA signed */
+   258,  /* (199) where_opt ::= */
+   258,  /* (200) where_opt ::= WHERE expr */
+   270,  /* (201) expr ::= LP expr RP */
+   270,  /* (202) expr ::= ID */
+   270,  /* (203) expr ::= ID DOT ID */
+   270,  /* (204) expr ::= ID DOT STAR */
+   270,  /* (205) expr ::= INTEGER */
+   270,  /* (206) expr ::= MINUS INTEGER */
+   270,  /* (207) expr ::= PLUS INTEGER */
+   270,  /* (208) expr ::= FLOAT */
+   270,  /* (209) expr ::= MINUS FLOAT */
+   270,  /* (210) expr ::= PLUS FLOAT */
+   270,  /* (211) expr ::= STRING */
+   270,  /* (212) expr ::= NOW */
+   270,  /* (213) expr ::= VARIABLE */
+   270,  /* (214) expr ::= BOOL */
+   270,  /* (215) expr ::= ID LP exprlist RP */
+   270,  /* (216) expr ::= ID LP STAR RP */
+   270,  /* (217) expr ::= expr IS NULL */
+   270,  /* (218) expr ::= expr IS NOT NULL */
+   270,  /* (219) expr ::= expr LT expr */
+   270,  /* (220) expr ::= expr GT expr */
+   270,  /* (221) expr ::= expr LE expr */
+   270,  /* (222) expr ::= expr GE expr */
+   270,  /* (223) expr ::= expr NE expr */
+   270,  /* (224) expr ::= expr EQ expr */
+   270,  /* (225) expr ::= expr AND expr */
+   270,  /* (226) expr ::= expr OR expr */
+   270,  /* (227) expr ::= expr PLUS expr */
+   270,  /* (228) expr ::= expr MINUS expr */
+   270,  /* (229) expr ::= expr STAR expr */
+   270,  /* (230) expr ::= expr SLASH expr */
+   270,  /* (231) expr ::= expr REM expr */
+   270,  /* (232) expr ::= expr LIKE expr */
+   270,  /* (233) expr ::= expr IN LP exprlist RP */
+   279,  /* (234) exprlist ::= exprlist COMMA expritem */
+   279,  /* (235) exprlist ::= expritem */
+   280,  /* (236) expritem ::= expr */
+   280,  /* (237) expritem ::= */
+   211,  /* (238) cmd ::= RESET QUERY CACHE */
+   211,  /* (239) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+   211,  /* (240) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+   211,  /* (241) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+   211,  /* (242) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+   211,  /* (243) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+   211,  /* (244) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+   211,  /* (245) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
+   211,  /* (246) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
+   211,  /* (247) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
+   211,  /* (248) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
+   211,  /* (249) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
+   211,  /* (250) cmd ::= KILL CONNECTION INTEGER */
+   211,  /* (251) cmd ::= KILL STREAM INTEGER COLON INTEGER */
+   211,  /* (252) cmd ::= KILL QUERY INTEGER COLON INTEGER */
+};
+
+/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number
+** of symbols on the right-hand side of that rule. */
+static const signed char yyRuleInfoNRhs[] = {
+   -1,  /* (0) program ::= cmd */
+   -2,  /* (1) cmd ::= SHOW DATABASES */
+   -2,  /* (2) cmd ::= SHOW MNODES */
+   -2,  /* (3) cmd ::= SHOW DNODES */
+   -2,  /* (4) cmd ::= SHOW ACCOUNTS */
+   -2,  /* (5) cmd ::= SHOW USERS */
+   -2,  /* (6) cmd ::= SHOW MODULES */
+   -2,  /* (7) cmd ::= SHOW QUERIES */
+   -2,  /* (8) cmd ::= SHOW CONNECTIONS */
+   -2,  /* (9) cmd ::= SHOW STREAMS */
+   -2,  /* (10) cmd ::= SHOW VARIABLES */
+   -2,  /* (11) cmd ::= SHOW SCORES */
+   -2,  /* (12) cmd ::= SHOW GRANTS */
+   -2,  /* (13) cmd ::= SHOW VNODES */
+   -3,  /* (14) cmd ::= SHOW VNODES IPTOKEN */
+    0,  /* (15) dbPrefix ::= */
+   -2,  /* (16) dbPrefix ::= ids DOT */
+    0,  /* (17) cpxName ::= */
+   -2,  /* (18) cpxName ::= DOT ids */
+   -5,  /* (19) cmd ::= SHOW CREATE TABLE ids cpxName */
+   -4,  /* (20) cmd ::= SHOW CREATE DATABASE ids */
+   -3,  /* (21) cmd ::= SHOW dbPrefix TABLES */
+   -5,  /* (22) cmd ::= SHOW dbPrefix TABLES LIKE ids */
+   -3,  /* (23) cmd ::= SHOW dbPrefix STABLES */
+   -5,  /* (24) cmd ::= SHOW dbPrefix STABLES LIKE ids */
+   -3,  /* (25) cmd ::= SHOW dbPrefix VGROUPS */
+   -4,  /* (26) cmd ::= SHOW dbPrefix VGROUPS ids */
+   -5,  /* (27) cmd ::= DROP TABLE ifexists ids cpxName */
+   -5,  /* (28) cmd ::= DROP STABLE ifexists ids cpxName */
+   -4,  /* (29) cmd ::= DROP DATABASE ifexists ids */
+   -3,  /* (30) cmd ::= DROP DNODE ids */
+   -3,  /* (31) cmd ::= DROP USER ids */
+   -3,  /* (32) cmd ::= DROP ACCOUNT ids */
+   -2,  /* (33) cmd ::= USE ids */
+   -3,  /* (34) cmd ::= DESCRIBE ids cpxName */
+   -5,  /* (35) cmd ::= ALTER USER ids PASS ids */
+   -5,  /* (36) cmd ::= ALTER USER ids PRIVILEGE ids */
+   -4,  /* (37) cmd ::= ALTER DNODE ids ids */
+   -5,  /* (38) cmd ::= ALTER DNODE ids ids ids */
+   -3,  /* (39) cmd ::= ALTER LOCAL ids */
+   -4,  /* (40) cmd ::= ALTER LOCAL ids ids */
+   -4,  /* (41) cmd ::= ALTER DATABASE ids alter_db_optr */
+   -4,  /* (42) cmd ::= ALTER ACCOUNT ids acct_optr */
+   -6,  /* (43) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
+   -1,  /* (44) ids ::= ID */
+   -1,  /* (45) ids ::= STRING */
+   -2,  /* (46) ifexists ::= IF EXISTS */
+    0,  /* (47) ifexists ::= */
+   -3,  /* (48) ifnotexists ::= IF NOT EXISTS */
+    0,  /* (49) ifnotexists ::= */
+   -3,  /* (50) cmd ::= CREATE DNODE ids */
+   -6,  /* (51) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
+   -5,  /* (52) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
+   -5,  /* (53) cmd ::= CREATE USER ids PASS ids */
+    0,  /* (54) pps ::= */
+   -2,  /* (55) pps ::= PPS INTEGER */
+    0,  /* (56) tseries ::= */
+   -2,  /* (57) tseries ::= TSERIES INTEGER */
+    0,  /* (58) dbs ::= */
+   -2,  /* (59) dbs ::= DBS INTEGER */
+    0,  /* (60) streams ::= */
+   -2,  /* (61) streams ::= STREAMS INTEGER */
+    0,  /* (62) storage ::= */
+   -2,  /* (63) storage ::= STORAGE INTEGER */
+    0,  /* (64) qtime ::= */
+   -2,  /* (65) qtime ::= QTIME INTEGER */
+    0,  /* (66) users ::= */
+   -2,  /* (67) users ::= USERS INTEGER */
+    0,  /* (68) conns ::= */
+   -2,  /* (69) conns ::= CONNS INTEGER */
+    0,  /* (70) state ::= */
+   -2,  /* (71) state ::= STATE ids */
+   -9,  /* (72) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
+   -2,  /* (73) keep ::= KEEP tagitemlist */
+   -2,  /* (74) cache ::= CACHE INTEGER */
+   -2,  /* (75) replica ::= REPLICA INTEGER */
+   -2,  /* (76) quorum ::= QUORUM INTEGER */
+   -2,  /* (77) days ::= DAYS INTEGER */
+   -2,  /* (78) minrows ::= MINROWS INTEGER */
+   -2,  /* (79) maxrows ::= MAXROWS INTEGER */
+   -2,  /* (80) blocks ::= BLOCKS INTEGER */
+   -2,  /* (81) ctime ::= CTIME INTEGER */
+   -2,  /* (82) wal ::= WAL INTEGER */
+   -2,  /* (83) fsync ::= FSYNC INTEGER */
+   -2,  /* (84) comp ::= COMP INTEGER */
+   -2,  /* (85) prec ::= PRECISION STRING */
+   -2,  /* (86) update ::= UPDATE INTEGER */
+   -2,  /* (87) cachelast ::= CACHELAST INTEGER */
+    0,  /* (88) db_optr ::= */
+   -2,  /* (89) db_optr ::= db_optr cache */
+   -2,  /* (90) db_optr ::= db_optr replica */
+   -2,  /* (91) db_optr ::= db_optr quorum */
+   -2,  /* (92) db_optr ::= db_optr days */
+   -2,  /* (93) db_optr ::= db_optr minrows */
+   -2,  /* (94) db_optr ::= db_optr maxrows */
+   -2,  /* (95) db_optr ::= db_optr blocks */
+   -2,  /* (96) db_optr ::= db_optr ctime */
+   -2,  /* (97) db_optr ::= db_optr wal */
+   -2,  /* (98) db_optr ::= db_optr fsync */
+   -2,  /* (99) db_optr ::= db_optr comp */
+   -2,  /* (100) db_optr ::= db_optr prec */
+   -2,  /* (101) db_optr ::= db_optr keep */
+   -2,  /* (102) db_optr ::= db_optr update */
+   -2,  /* (103) db_optr ::= db_optr cachelast */
+    0,  /* (104) alter_db_optr ::= */
+   -2,  /* (105) alter_db_optr ::= alter_db_optr replica */
+   -2,  /* (106) alter_db_optr ::= alter_db_optr quorum */
+   -2,  /* (107) alter_db_optr ::= alter_db_optr keep */
+   -2,  /* (108) alter_db_optr ::= alter_db_optr blocks */
+   -2,  /* (109) alter_db_optr ::= alter_db_optr comp */
+   -2,  /* (110) alter_db_optr ::= alter_db_optr wal */
+   -2,  /* (111) alter_db_optr ::= alter_db_optr fsync */
+   -2,  /* (112) alter_db_optr ::= alter_db_optr update */
+   -2,  /* (113) alter_db_optr ::= alter_db_optr cachelast */
+   -1,  /* (114) typename ::= ids */
+   -4,  /* (115) typename ::= ids LP signed RP */
+   -2,  /* (116) typename ::= ids UNSIGNED */
+   -1,  /* (117) signed ::= INTEGER */
+   -2,  /* (118) signed ::= PLUS INTEGER */
+   -2,  /* (119) signed ::= MINUS INTEGER */
+   -3,  /* (120) cmd ::= CREATE TABLE create_table_args */
+   -3,  /* (121) cmd ::= CREATE TABLE create_stable_args */
+   -3,  /* (122) cmd ::= CREATE STABLE create_stable_args */
+   -3,  /* (123) cmd ::= CREATE TABLE create_table_list */
+   -1,  /* (124) create_table_list ::= create_from_stable */
+   -2,  /* (125) create_table_list ::= create_table_list create_from_stable */
+   -6,  /* (126) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
+  -10,  /* (127) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
+  -10,  /* (128) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
+  -13,  /* (129) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
+   -3,  /* (130) tagNamelist ::= tagNamelist COMMA ids */
+   -1,  /* (131) tagNamelist ::= ids */
+   -5,  /* (132) create_table_args ::= ifnotexists ids cpxName AS select */
+   -3,  /* (133) columnlist ::= columnlist COMMA column */
+   -1,  /* (134) columnlist ::= column */
+   -2,  /* (135) column ::= ids typename */
+   -3,  /* (136) tagitemlist ::= tagitemlist COMMA tagitem */
+   -1,  /* (137) tagitemlist ::= tagitem */
+   -1,  /* (138) tagitem ::= INTEGER */
+   -1,  /* (139) tagitem ::= FLOAT */
+   -1,  /* (140) tagitem ::= STRING */
+   -1,  /* (141) tagitem ::= BOOL */
+   -1,  /* (142) tagitem ::= NULL */
+   -2,  /* (143) tagitem ::= MINUS INTEGER */
+   -2,  /* (144) tagitem ::= MINUS FLOAT */
+   -2,  /* (145) tagitem ::= PLUS INTEGER */
+   -2,  /* (146) tagitem ::= PLUS FLOAT */
+  -12,  /* (147) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
+   -1,  /* (148) union ::= select */
+   -3,  /* (149) union ::= LP union RP */
+   -4,  /* (150) union ::= union UNION ALL select */
+   -6,  /* (151) union ::= union UNION ALL LP select RP */
+   -1,  /* (152) cmd ::= union */
+   -2,  /* (153) select ::= SELECT selcollist */
+   -2,  /* (154) sclp ::= selcollist COMMA */
+    0,  /* (155) sclp ::= */
+   -4,  /* (156) selcollist ::= sclp distinct expr as */
+   -2,  /* (157) selcollist ::= sclp STAR */
+   -2,  /* (158) as ::= AS ids */
+   -1,  /* (159) as ::= ids */
+    0,  /* (160) as ::= */
+   -1,  /* (161) distinct ::= DISTINCT */
+    0,  /* (162) distinct ::= */
+   -2,  /* (163) from ::= FROM tablelist */
+   -2,  /* (164) tablelist ::= ids cpxName */
+   -3,  /* (165) tablelist ::= ids cpxName ids */
+   -4,  /* (166) tablelist ::= tablelist COMMA ids cpxName */
+   -5,  /* (167) tablelist ::= tablelist COMMA ids cpxName ids */
+   -1,  /* (168) tmvar ::= VARIABLE */
+   -4,  /* (169) interval_opt ::= INTERVAL LP tmvar RP */
+   -6,  /* (170) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
+    0,  /* (171) interval_opt ::= */
+    0,  /* (172) fill_opt ::= */
+   -6,  /* (173) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+   -4,  /* (174) fill_opt ::= FILL LP ID RP */
+   -4,  /* (175) sliding_opt ::= SLIDING LP tmvar RP */
+    0,  /* (176) sliding_opt ::= */
+    0,  /* (177) orderby_opt ::= */
+   -3,  /* (178) orderby_opt ::= ORDER BY sortlist */
+   -4,  /* (179) sortlist ::= sortlist COMMA item sortorder */
+   -2,  /* (180) sortlist ::= item sortorder */
+   -2,  /* (181) item ::= ids cpxName */
+   -1,  /* (182) sortorder ::= ASC */
+   -1,  /* (183) sortorder ::= DESC */
+    0,  /* (184) sortorder ::= */
+    0,  /* (185) groupby_opt ::= */
+   -3,  /* (186) groupby_opt ::= GROUP BY grouplist */
+   -3,  /* (187) grouplist ::= grouplist COMMA item */
+   -1,  /* (188) grouplist ::= item */
+    0,  /* (189) having_opt ::= */
+   -2,  /* (190) having_opt ::= HAVING expr */
+    0,  /* (191) limit_opt ::= */
+   -2,  /* (192) limit_opt ::= LIMIT signed */
+   -4,  /* (193) limit_opt ::= LIMIT signed OFFSET signed */
+   -4,  /* (194) limit_opt ::= LIMIT signed COMMA signed */
+    0,  /* (195) slimit_opt ::= */
+   -2,  /* (196) slimit_opt ::= SLIMIT signed */
+   -4,  /* (197) slimit_opt ::= SLIMIT signed SOFFSET signed */
+   -4,  /* (198) slimit_opt ::= SLIMIT signed COMMA signed */
+    0,  /* (199) where_opt ::= */
+   -2,  /* (200) where_opt ::= WHERE expr */
+   -3,  /* (201) expr ::= LP expr RP */
+   -1,  /* (202) expr ::= ID */
+   -3,  /* (203) expr ::= ID DOT ID */
+   -3,  /* (204) expr ::= ID DOT STAR */
+   -1,  /* (205) expr ::= INTEGER */
+   -2,  /* (206) expr ::= MINUS INTEGER */
+   -2,  /* (207) expr ::= PLUS INTEGER */
+   -1,  /* (208) expr ::= FLOAT */
+   -2,  /* (209) expr ::= MINUS FLOAT */
+   -2,  /* (210) expr ::= PLUS FLOAT */
+   -1,  /* (211) expr ::= STRING */
+   -1,  /* (212) expr ::= NOW */
+   -1,  /* (213) expr ::= VARIABLE */
+   -1,  /* (214) expr ::= BOOL */
+   -4,  /* (215) expr ::= ID LP exprlist RP */
+   -4,  /* (216) expr ::= ID LP STAR RP */
+   -3,  /* (217) expr ::= expr IS NULL */
+   -4,  /* (218) expr ::= expr IS NOT NULL */
+   -3,  /* (219) expr ::= expr LT expr */
+   -3,  /* (220) expr ::= expr GT expr */
+   -3,  /* (221) expr ::= expr LE expr */
+   -3,  /* (222) expr ::= expr GE expr */
+   -3,  /* (223) expr ::= expr NE expr */
+   -3,  /* (224) expr ::= expr EQ expr */
+   -3,  /* (225) expr ::= expr AND expr */
+   -3,  /* (226) expr ::= expr OR expr */
+   -3,  /* (227) expr ::= expr PLUS expr */
+   -3,  /* (228) expr ::= expr MINUS expr */
+   -3,  /* (229) expr ::= expr STAR expr */
+   -3,  /* (230) expr ::= expr SLASH expr */
+   -3,  /* (231) expr ::= expr REM expr */
+   -3,  /* (232) expr ::= expr LIKE expr */
+   -5,  /* (233) expr ::= expr IN LP exprlist RP */
+   -3,  /* (234) exprlist ::= exprlist COMMA expritem */
+   -1,  /* (235) exprlist ::= expritem */
+   -1,  /* (236) expritem ::= expr */
+    0,  /* (237) expritem ::= */
+   -3,  /* (238) cmd ::= RESET QUERY CACHE */
+   -7,  /* (239) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+   -7,  /* (240) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+   -7,  /* (241) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+   -7,  /* (242) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+   -8,  /* (243) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+   -9,  /* (244) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+   -7,  /* (245) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
+   -7,  /* (246) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
+   -7,  /* (247) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
+   -7,  /* (248) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
+   -8,  /* (249) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
+   -3,  /* (250) cmd ::= KILL CONNECTION INTEGER */
+   -5,  /* (251) cmd ::= KILL STREAM INTEGER COLON INTEGER */
+   -5,  /* (252) cmd ::= KILL QUERY INTEGER COLON INTEGER */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -2013,30 +2292,34 @@ static void yy_accept(yyParser*);  /* Forward Declaration */
 ** only called from one place, optimizing compilers will in-line it, which
 ** means that the extra parameters have no performance impact.
 */
-static void yy_reduce(
+static YYACTIONTYPE yy_reduce(
   yyParser *yypParser,         /* The parser */
   unsigned int yyruleno,       /* Number of the rule by which to reduce */
   int yyLookahead,             /* Lookahead token, or YYNOCODE if none */
   ParseTOKENTYPE yyLookaheadToken  /* Value of the lookahead token */
+  ParseCTX_PDECL                   /* %extra_context */
 ){
   int yygoto;                     /* The next state */
-  int yyact;                      /* The next action */
+  YYACTIONTYPE yyact;             /* The next action */
   yyStackEntry *yymsp;            /* The top of the parser's stack */
   int yysize;                     /* Amount to pop the stack */
-  ParseARG_FETCH;
+  ParseARG_FETCH
   (void)yyLookahead;
   (void)yyLookaheadToken;
   yymsp = yypParser->yytos;
 #ifndef NDEBUG
   if( yyTraceFILE && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
-    yysize = yyRuleInfo[yyruleno].nrhs;
+    yysize = yyRuleInfoNRhs[yyruleno];
     if( yysize ){
-      fprintf(yyTraceFILE, "%sReduce %d [%s], go to state %d.\n",
+      fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",
         yyTracePrompt,
-        yyruleno, yyRuleName[yyruleno], yymsp[yysize].stateno);
+        yyruleno, yyRuleName[yyruleno],
+        yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action",
+        yymsp[yysize].stateno);
     }else{
-      fprintf(yyTraceFILE, "%sReduce %d [%s].\n",
-        yyTracePrompt, yyruleno, yyRuleName[yyruleno]);
+      fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n",
+        yyTracePrompt, yyruleno, yyRuleName[yyruleno],
+        yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action");
     }
   }
 #endif /* NDEBUG */
@@ -2044,7 +2327,7 @@ static void yy_reduce(
   /* Check that the stack is large enough to grow by a single entry
   ** if the RHS of the rule is empty.  This ensures that there is room
   ** enough on the stack to push the LHS value */
-  if( yyRuleInfo[yyruleno].nrhs==0 ){
+  if( yyRuleInfoNRhs[yyruleno]==0 ){
 #ifdef YYTRACKMAXSTACKDEPTH
     if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
       yypParser->yyhwm++;
@@ -2054,13 +2337,19 @@ static void yy_reduce(
 #if YYSTACKDEPTH>0 
     if( yypParser->yytos>=yypParser->yystackEnd ){
       yyStackOverflow(yypParser);
-      return;
+      /* The call to yyStackOverflow() above pops the stack until it is
+      ** empty, causing the main parser loop to exit.  So the return value
+      ** is never used and does not matter. */
+      return 0;
     }
 #else
     if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){
       if( yyGrowStack(yypParser) ){
         yyStackOverflow(yypParser);
-        return;
+        /* The call to yyStackOverflow() above pops the stack until it is
+        ** empty, causing the main parser loop to exit.  So the return value
+        ** is never used and does not matter. */
+        return 0;
       }
       yymsp = yypParser->yytos;
     }
@@ -2256,7 +2545,7 @@ static void yy_reduce(
         break;
       case 47: /* ifexists ::= */
       case 49: /* ifnotexists ::= */ yytestcase(yyruleno==49);
-      case 159: /* distinct ::= */ yytestcase(yyruleno==159);
+      case 162: /* distinct ::= */ yytestcase(yyruleno==162);
 { yymsp[1].minor.yy0.n = 0;}
         break;
       case 48: /* ifnotexists ::= IF NOT EXISTS */
@@ -2486,11 +2775,27 @@ static void yy_reduce(
 {
   yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
   yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
-  yylhsminor.yy42 = createNewChildTableInfo(&yymsp[-5].minor.yy0, yymsp[-1].minor.yy247, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
+  yylhsminor.yy42 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy247, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
 }
   yymsp[-9].minor.yy42 = yylhsminor.yy42;
         break;
-      case 129: /* create_table_args ::= ifnotexists ids cpxName AS select */
+      case 129: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
+{
+  yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
+  yymsp[-11].minor.yy0.n += yymsp[-10].minor.yy0.n;
+  yylhsminor.yy42 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy247, yymsp[-1].minor.yy247, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0);
+}
+  yymsp[-12].minor.yy42 = yylhsminor.yy42;
+        break;
+      case 130: /* tagNamelist ::= tagNamelist COMMA ids */
+{taosArrayPush(yymsp[-2].minor.yy247, &yymsp[0].minor.yy0); yylhsminor.yy247 = yymsp[-2].minor.yy247;  }
+  yymsp[-2].minor.yy247 = yylhsminor.yy247;
+        break;
+      case 131: /* tagNamelist ::= ids */
+{yylhsminor.yy247 = taosArrayInit(4, sizeof(SStrToken)); taosArrayPush(yylhsminor.yy247, &yymsp[0].minor.yy0);}
+  yymsp[0].minor.yy247 = yylhsminor.yy247;
+        break;
+      case 132: /* create_table_args ::= ifnotexists ids cpxName AS select */
 {
   yylhsminor.yy358 = tSetCreateSqlElems(NULL, NULL, yymsp[0].minor.yy114, TSQL_CREATE_STREAM);
   setSqlInfo(pInfo, yylhsminor.yy358, NULL, TSDB_SQL_CREATE_TABLE);
@@ -2500,43 +2805,43 @@ static void yy_reduce(
 }
   yymsp[-4].minor.yy358 = yylhsminor.yy358;
         break;
-      case 130: /* columnlist ::= columnlist COMMA column */
+      case 133: /* columnlist ::= columnlist COMMA column */
 {taosArrayPush(yymsp[-2].minor.yy247, &yymsp[0].minor.yy179); yylhsminor.yy247 = yymsp[-2].minor.yy247;  }
   yymsp[-2].minor.yy247 = yylhsminor.yy247;
         break;
-      case 131: /* columnlist ::= column */
+      case 134: /* columnlist ::= column */
 {yylhsminor.yy247 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy247, &yymsp[0].minor.yy179);}
   yymsp[0].minor.yy247 = yylhsminor.yy247;
         break;
-      case 132: /* column ::= ids typename */
+      case 135: /* column ::= ids typename */
 {
   tSqlSetColumnInfo(&yylhsminor.yy179, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy179);
 }
   yymsp[-1].minor.yy179 = yylhsminor.yy179;
         break;
-      case 133: /* tagitemlist ::= tagitemlist COMMA tagitem */
+      case 136: /* tagitemlist ::= tagitemlist COMMA tagitem */
 { yylhsminor.yy247 = tVariantListAppend(yymsp[-2].minor.yy247, &yymsp[0].minor.yy378, -1);    }
   yymsp[-2].minor.yy247 = yylhsminor.yy247;
         break;
-      case 134: /* tagitemlist ::= tagitem */
+      case 137: /* tagitemlist ::= tagitem */
 { yylhsminor.yy247 = tVariantListAppend(NULL, &yymsp[0].minor.yy378, -1); }
   yymsp[0].minor.yy247 = yylhsminor.yy247;
         break;
-      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);
+      case 138: /* tagitem ::= INTEGER */
+      case 139: /* tagitem ::= FLOAT */ yytestcase(yyruleno==139);
+      case 140: /* tagitem ::= STRING */ yytestcase(yyruleno==140);
+      case 141: /* tagitem ::= BOOL */ yytestcase(yyruleno==141);
 { toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy378, &yymsp[0].minor.yy0); }
   yymsp[0].minor.yy378 = yylhsminor.yy378;
         break;
-      case 139: /* tagitem ::= NULL */
+      case 142: /* tagitem ::= NULL */
 { yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy378, &yymsp[0].minor.yy0); }
   yymsp[0].minor.yy378 = yylhsminor.yy378;
         break;
-      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);
+      case 143: /* tagitem ::= MINUS INTEGER */
+      case 144: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==144);
+      case 145: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==145);
+      case 146: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==146);
 {
     yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
     yymsp[-1].minor.yy0.type = yymsp[0].minor.yy0.type;
@@ -2545,74 +2850,74 @@ static void yy_reduce(
 }
   yymsp[-1].minor.yy378 = yylhsminor.yy378;
         break;
-      case 144: /* select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
+      case 147: /* select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
 {
   yylhsminor.yy114 = tSetQuerySqlElems(&yymsp[-11].minor.yy0, yymsp[-10].minor.yy522, yymsp[-9].minor.yy247, yymsp[-8].minor.yy326, yymsp[-4].minor.yy247, yymsp[-3].minor.yy247, &yymsp[-7].minor.yy430, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy247, &yymsp[0].minor.yy204, &yymsp[-1].minor.yy204);
 }
   yymsp[-11].minor.yy114 = yylhsminor.yy114;
         break;
-      case 145: /* union ::= select */
+      case 148: /* union ::= select */
 { yylhsminor.yy219 = setSubclause(NULL, yymsp[0].minor.yy114); }
   yymsp[0].minor.yy219 = yylhsminor.yy219;
         break;
-      case 146: /* union ::= LP union RP */
+      case 149: /* union ::= LP union RP */
 { yymsp[-2].minor.yy219 = yymsp[-1].minor.yy219; }
         break;
-      case 147: /* union ::= union UNION ALL select */
+      case 150: /* union ::= union UNION ALL select */
 { yylhsminor.yy219 = appendSelectClause(yymsp[-3].minor.yy219, yymsp[0].minor.yy114); }
   yymsp[-3].minor.yy219 = yylhsminor.yy219;
         break;
-      case 148: /* union ::= union UNION ALL LP select RP */
+      case 151: /* union ::= union UNION ALL LP select RP */
 { yylhsminor.yy219 = appendSelectClause(yymsp[-5].minor.yy219, yymsp[-1].minor.yy114); }
   yymsp[-5].minor.yy219 = yylhsminor.yy219;
         break;
-      case 149: /* cmd ::= union */
+      case 152: /* cmd ::= union */
 { setSqlInfo(pInfo, yymsp[0].minor.yy219, NULL, TSDB_SQL_SELECT); }
         break;
-      case 150: /* select ::= SELECT selcollist */
+      case 153: /* select ::= SELECT selcollist */
 {
   yylhsminor.yy114 = tSetQuerySqlElems(&yymsp[-1].minor.yy0, yymsp[0].minor.yy522, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
   yymsp[-1].minor.yy114 = yylhsminor.yy114;
         break;
-      case 151: /* sclp ::= selcollist COMMA */
+      case 154: /* sclp ::= selcollist COMMA */
 {yylhsminor.yy522 = yymsp[-1].minor.yy522;}
   yymsp[-1].minor.yy522 = yylhsminor.yy522;
         break;
-      case 152: /* sclp ::= */
+      case 155: /* sclp ::= */
 {yymsp[1].minor.yy522 = 0;}
         break;
-      case 153: /* selcollist ::= sclp distinct expr as */
+      case 156: /* selcollist ::= sclp distinct expr as */
 {
    yylhsminor.yy522 = tSqlExprListAppend(yymsp[-3].minor.yy522, yymsp[-1].minor.yy326,  yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
 }
   yymsp[-3].minor.yy522 = yylhsminor.yy522;
         break;
-      case 154: /* selcollist ::= sclp STAR */
+      case 157: /* selcollist ::= sclp STAR */
 {
    tSQLExpr *pNode = tSqlExprIdValueCreate(NULL, TK_ALL);
    yylhsminor.yy522 = tSqlExprListAppend(yymsp[-1].minor.yy522, pNode, 0, 0);
 }
   yymsp[-1].minor.yy522 = yylhsminor.yy522;
         break;
-      case 155: /* as ::= AS ids */
+      case 158: /* as ::= AS ids */
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;    }
         break;
-      case 156: /* as ::= ids */
+      case 159: /* as ::= ids */
 { yylhsminor.yy0 = yymsp[0].minor.yy0;    }
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 157: /* as ::= */
+      case 160: /* as ::= */
 { yymsp[1].minor.yy0.n = 0;  }
         break;
-      case 158: /* distinct ::= DISTINCT */
+      case 161: /* distinct ::= DISTINCT */
 { yylhsminor.yy0 = yymsp[0].minor.yy0;  }
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 160: /* from ::= FROM tablelist */
+      case 163: /* from ::= FROM tablelist */
 {yymsp[-1].minor.yy247 = yymsp[0].minor.yy247;}
         break;
-      case 161: /* tablelist ::= ids cpxName */
+      case 164: /* tablelist ::= ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
@@ -2621,7 +2926,7 @@ static void yy_reduce(
 }
   yymsp[-1].minor.yy247 = yylhsminor.yy247;
         break;
-      case 162: /* tablelist ::= ids cpxName ids */
+      case 165: /* tablelist ::= ids cpxName ids */
 {
   toTSDBType(yymsp[-2].minor.yy0.type);
   toTSDBType(yymsp[0].minor.yy0.type);
@@ -2631,7 +2936,7 @@ static void yy_reduce(
 }
   yymsp[-2].minor.yy247 = yylhsminor.yy247;
         break;
-      case 163: /* tablelist ::= tablelist COMMA ids cpxName */
+      case 166: /* tablelist ::= tablelist COMMA ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
@@ -2640,7 +2945,7 @@ static void yy_reduce(
 }
   yymsp[-3].minor.yy247 = yylhsminor.yy247;
         break;
-      case 164: /* tablelist ::= tablelist COMMA ids cpxName ids */
+      case 167: /* tablelist ::= tablelist COMMA ids cpxName ids */
 {
   toTSDBType(yymsp[-2].minor.yy0.type);
   toTSDBType(yymsp[0].minor.yy0.type);
@@ -2650,23 +2955,23 @@ static void yy_reduce(
 }
   yymsp[-4].minor.yy247 = yylhsminor.yy247;
         break;
-      case 165: /* tmvar ::= VARIABLE */
+      case 168: /* tmvar ::= VARIABLE */
 {yylhsminor.yy0 = yymsp[0].minor.yy0;}
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 166: /* interval_opt ::= INTERVAL LP tmvar RP */
+      case 169: /* interval_opt ::= INTERVAL LP tmvar RP */
 {yymsp[-3].minor.yy430.interval = yymsp[-1].minor.yy0; yymsp[-3].minor.yy430.offset.n = 0; yymsp[-3].minor.yy430.offset.z = NULL; yymsp[-3].minor.yy430.offset.type = 0;}
         break;
-      case 167: /* interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
+      case 170: /* interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
 {yymsp[-5].minor.yy430.interval = yymsp[-3].minor.yy0; yymsp[-5].minor.yy430.offset = yymsp[-1].minor.yy0;}
         break;
-      case 168: /* interval_opt ::= */
+      case 171: /* interval_opt ::= */
 {memset(&yymsp[1].minor.yy430, 0, sizeof(yymsp[1].minor.yy430));}
         break;
-      case 169: /* fill_opt ::= */
+      case 172: /* fill_opt ::= */
 {yymsp[1].minor.yy247 = 0;     }
         break;
-      case 170: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+      case 173: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
 {
     tVariant A = {0};
     toTSDBType(yymsp[-3].minor.yy0.type);
@@ -2676,37 +2981,37 @@ static void yy_reduce(
     yymsp[-5].minor.yy247 = yymsp[-1].minor.yy247;
 }
         break;
-      case 171: /* fill_opt ::= FILL LP ID RP */
+      case 174: /* fill_opt ::= FILL LP ID RP */
 {
     toTSDBType(yymsp[-1].minor.yy0.type);
     yymsp[-3].minor.yy247 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
 }
         break;
-      case 172: /* sliding_opt ::= SLIDING LP tmvar RP */
+      case 175: /* sliding_opt ::= SLIDING LP tmvar RP */
 {yymsp[-3].minor.yy0 = yymsp[-1].minor.yy0;     }
         break;
-      case 173: /* sliding_opt ::= */
+      case 176: /* sliding_opt ::= */
 {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0;   }
         break;
-      case 174: /* orderby_opt ::= */
+      case 177: /* orderby_opt ::= */
 {yymsp[1].minor.yy247 = 0;}
         break;
-      case 175: /* orderby_opt ::= ORDER BY sortlist */
+      case 178: /* orderby_opt ::= ORDER BY sortlist */
 {yymsp[-2].minor.yy247 = yymsp[0].minor.yy247;}
         break;
-      case 176: /* sortlist ::= sortlist COMMA item sortorder */
+      case 179: /* sortlist ::= sortlist COMMA item sortorder */
 {
     yylhsminor.yy247 = tVariantListAppend(yymsp[-3].minor.yy247, &yymsp[-1].minor.yy378, yymsp[0].minor.yy222);
 }
   yymsp[-3].minor.yy247 = yylhsminor.yy247;
         break;
-      case 177: /* sortlist ::= item sortorder */
+      case 180: /* sortlist ::= item sortorder */
 {
   yylhsminor.yy247 = tVariantListAppend(NULL, &yymsp[-1].minor.yy378, yymsp[0].minor.yy222);
 }
   yymsp[-1].minor.yy247 = yylhsminor.yy247;
         break;
-      case 178: /* item ::= ids cpxName */
+      case 181: /* item ::= ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
@@ -2715,211 +3020,211 @@ static void yy_reduce(
 }
   yymsp[-1].minor.yy378 = yylhsminor.yy378;
         break;
-      case 179: /* sortorder ::= ASC */
+      case 182: /* sortorder ::= ASC */
 { yymsp[0].minor.yy222 = TSDB_ORDER_ASC; }
         break;
-      case 180: /* sortorder ::= DESC */
+      case 183: /* sortorder ::= DESC */
 { yymsp[0].minor.yy222 = TSDB_ORDER_DESC;}
         break;
-      case 181: /* sortorder ::= */
+      case 184: /* sortorder ::= */
 { yymsp[1].minor.yy222 = TSDB_ORDER_ASC; }
         break;
-      case 182: /* groupby_opt ::= */
+      case 185: /* groupby_opt ::= */
 { yymsp[1].minor.yy247 = 0;}
         break;
-      case 183: /* groupby_opt ::= GROUP BY grouplist */
+      case 186: /* groupby_opt ::= GROUP BY grouplist */
 { yymsp[-2].minor.yy247 = yymsp[0].minor.yy247;}
         break;
-      case 184: /* grouplist ::= grouplist COMMA item */
+      case 187: /* grouplist ::= grouplist COMMA item */
 {
   yylhsminor.yy247 = tVariantListAppend(yymsp[-2].minor.yy247, &yymsp[0].minor.yy378, -1);
 }
   yymsp[-2].minor.yy247 = yylhsminor.yy247;
         break;
-      case 185: /* grouplist ::= item */
+      case 188: /* grouplist ::= item */
 {
   yylhsminor.yy247 = tVariantListAppend(NULL, &yymsp[0].minor.yy378, -1);
 }
   yymsp[0].minor.yy247 = yylhsminor.yy247;
         break;
-      case 186: /* having_opt ::= */
-      case 196: /* where_opt ::= */ yytestcase(yyruleno==196);
-      case 234: /* expritem ::= */ yytestcase(yyruleno==234);
+      case 189: /* having_opt ::= */
+      case 199: /* where_opt ::= */ yytestcase(yyruleno==199);
+      case 237: /* expritem ::= */ yytestcase(yyruleno==237);
 {yymsp[1].minor.yy326 = 0;}
         break;
-      case 187: /* having_opt ::= HAVING expr */
-      case 197: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==197);
+      case 190: /* having_opt ::= HAVING expr */
+      case 200: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==200);
 {yymsp[-1].minor.yy326 = yymsp[0].minor.yy326;}
         break;
-      case 188: /* limit_opt ::= */
-      case 192: /* slimit_opt ::= */ yytestcase(yyruleno==192);
+      case 191: /* limit_opt ::= */
+      case 195: /* slimit_opt ::= */ yytestcase(yyruleno==195);
 {yymsp[1].minor.yy204.limit = -1; yymsp[1].minor.yy204.offset = 0;}
         break;
-      case 189: /* limit_opt ::= LIMIT signed */
-      case 193: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==193);
+      case 192: /* limit_opt ::= LIMIT signed */
+      case 196: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==196);
 {yymsp[-1].minor.yy204.limit = yymsp[0].minor.yy403;  yymsp[-1].minor.yy204.offset = 0;}
         break;
-      case 190: /* limit_opt ::= LIMIT signed OFFSET signed */
+      case 193: /* limit_opt ::= LIMIT signed OFFSET signed */
 { yymsp[-3].minor.yy204.limit = yymsp[-2].minor.yy403;  yymsp[-3].minor.yy204.offset = yymsp[0].minor.yy403;}
         break;
-      case 191: /* limit_opt ::= LIMIT signed COMMA signed */
+      case 194: /* limit_opt ::= LIMIT signed COMMA signed */
 { yymsp[-3].minor.yy204.limit = yymsp[0].minor.yy403;  yymsp[-3].minor.yy204.offset = yymsp[-2].minor.yy403;}
         break;
-      case 194: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
+      case 197: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
 {yymsp[-3].minor.yy204.limit = yymsp[-2].minor.yy403;  yymsp[-3].minor.yy204.offset = yymsp[0].minor.yy403;}
         break;
-      case 195: /* slimit_opt ::= SLIMIT signed COMMA signed */
+      case 198: /* slimit_opt ::= SLIMIT signed COMMA signed */
 {yymsp[-3].minor.yy204.limit = yymsp[0].minor.yy403;  yymsp[-3].minor.yy204.offset = yymsp[-2].minor.yy403;}
         break;
-      case 198: /* expr ::= LP expr RP */
+      case 201: /* expr ::= LP expr RP */
 {yylhsminor.yy326 = yymsp[-1].minor.yy326; yylhsminor.yy326->token.z = yymsp[-2].minor.yy0.z; yylhsminor.yy326->token.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
   yymsp[-2].minor.yy326 = yylhsminor.yy326;
         break;
-      case 199: /* expr ::= ID */
+      case 202: /* expr ::= ID */
 { yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_ID);}
   yymsp[0].minor.yy326 = yylhsminor.yy326;
         break;
-      case 200: /* expr ::= ID DOT ID */
+      case 203: /* expr ::= ID DOT ID */
 { yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ID);}
   yymsp[-2].minor.yy326 = yylhsminor.yy326;
         break;
-      case 201: /* expr ::= ID DOT STAR */
+      case 204: /* expr ::= ID DOT STAR */
 { yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ALL);}
   yymsp[-2].minor.yy326 = yylhsminor.yy326;
         break;
-      case 202: /* expr ::= INTEGER */
+      case 205: /* expr ::= INTEGER */
 { yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_INTEGER);}
   yymsp[0].minor.yy326 = yylhsminor.yy326;
         break;
-      case 203: /* expr ::= MINUS INTEGER */
-      case 204: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==204);
+      case 206: /* expr ::= MINUS INTEGER */
+      case 207: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==207);
 { yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[-1].minor.yy0, TK_INTEGER);}
   yymsp[-1].minor.yy326 = yylhsminor.yy326;
         break;
-      case 205: /* expr ::= FLOAT */
+      case 208: /* expr ::= FLOAT */
 { yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_FLOAT);}
   yymsp[0].minor.yy326 = yylhsminor.yy326;
         break;
-      case 206: /* expr ::= MINUS FLOAT */
-      case 207: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==207);
+      case 209: /* expr ::= MINUS FLOAT */
+      case 210: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==210);
 { yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[-1].minor.yy0, TK_FLOAT);}
   yymsp[-1].minor.yy326 = yylhsminor.yy326;
         break;
-      case 208: /* expr ::= STRING */
+      case 211: /* expr ::= STRING */
 { yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_STRING);}
   yymsp[0].minor.yy326 = yylhsminor.yy326;
         break;
-      case 209: /* expr ::= NOW */
+      case 212: /* expr ::= NOW */
 { yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_NOW); }
   yymsp[0].minor.yy326 = yylhsminor.yy326;
         break;
-      case 210: /* expr ::= VARIABLE */
+      case 213: /* expr ::= VARIABLE */
 { yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_VARIABLE);}
   yymsp[0].minor.yy326 = yylhsminor.yy326;
         break;
-      case 211: /* expr ::= BOOL */
+      case 214: /* expr ::= BOOL */
 { yylhsminor.yy326 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_BOOL);}
   yymsp[0].minor.yy326 = yylhsminor.yy326;
         break;
-      case 212: /* expr ::= ID LP exprlist RP */
+      case 215: /* expr ::= ID LP exprlist RP */
 { yylhsminor.yy326 = tSqlExprCreateFunction(yymsp[-1].minor.yy522, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
   yymsp[-3].minor.yy326 = yylhsminor.yy326;
         break;
-      case 213: /* expr ::= ID LP STAR RP */
+      case 216: /* expr ::= ID LP STAR RP */
 { yylhsminor.yy326 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
   yymsp[-3].minor.yy326 = yylhsminor.yy326;
         break;
-      case 214: /* expr ::= expr IS NULL */
+      case 217: /* expr ::= expr IS NULL */
 {yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, NULL, TK_ISNULL);}
   yymsp[-2].minor.yy326 = yylhsminor.yy326;
         break;
-      case 215: /* expr ::= expr IS NOT NULL */
+      case 218: /* expr ::= expr IS NOT NULL */
 {yylhsminor.yy326 = tSqlExprCreate(yymsp[-3].minor.yy326, NULL, TK_NOTNULL);}
   yymsp[-3].minor.yy326 = yylhsminor.yy326;
         break;
-      case 216: /* expr ::= expr LT expr */
+      case 219: /* expr ::= expr LT expr */
 {yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_LT);}
   yymsp[-2].minor.yy326 = yylhsminor.yy326;
         break;
-      case 217: /* expr ::= expr GT expr */
+      case 220: /* expr ::= expr GT expr */
 {yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_GT);}
   yymsp[-2].minor.yy326 = yylhsminor.yy326;
         break;
-      case 218: /* expr ::= expr LE expr */
+      case 221: /* expr ::= expr LE expr */
 {yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_LE);}
   yymsp[-2].minor.yy326 = yylhsminor.yy326;
         break;
-      case 219: /* expr ::= expr GE expr */
+      case 222: /* expr ::= expr GE expr */
 {yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_GE);}
   yymsp[-2].minor.yy326 = yylhsminor.yy326;
         break;
-      case 220: /* expr ::= expr NE expr */
+      case 223: /* expr ::= expr NE expr */
 {yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_NE);}
   yymsp[-2].minor.yy326 = yylhsminor.yy326;
         break;
-      case 221: /* expr ::= expr EQ expr */
+      case 224: /* expr ::= expr EQ expr */
 {yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_EQ);}
   yymsp[-2].minor.yy326 = yylhsminor.yy326;
         break;
-      case 222: /* expr ::= expr AND expr */
+      case 225: /* expr ::= expr AND expr */
 {yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_AND);}
   yymsp[-2].minor.yy326 = yylhsminor.yy326;
         break;
-      case 223: /* expr ::= expr OR expr */
+      case 226: /* expr ::= expr OR expr */
 {yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_OR); }
   yymsp[-2].minor.yy326 = yylhsminor.yy326;
         break;
-      case 224: /* expr ::= expr PLUS expr */
+      case 227: /* expr ::= expr PLUS expr */
 {yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_PLUS);  }
   yymsp[-2].minor.yy326 = yylhsminor.yy326;
         break;
-      case 225: /* expr ::= expr MINUS expr */
+      case 228: /* expr ::= expr MINUS expr */
 {yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_MINUS); }
   yymsp[-2].minor.yy326 = yylhsminor.yy326;
         break;
-      case 226: /* expr ::= expr STAR expr */
+      case 229: /* expr ::= expr STAR expr */
 {yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_STAR);  }
   yymsp[-2].minor.yy326 = yylhsminor.yy326;
         break;
-      case 227: /* expr ::= expr SLASH expr */
+      case 230: /* expr ::= expr SLASH expr */
 {yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_DIVIDE);}
   yymsp[-2].minor.yy326 = yylhsminor.yy326;
         break;
-      case 228: /* expr ::= expr REM expr */
+      case 231: /* expr ::= expr REM expr */
 {yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_REM);   }
   yymsp[-2].minor.yy326 = yylhsminor.yy326;
         break;
-      case 229: /* expr ::= expr LIKE expr */
+      case 232: /* expr ::= expr LIKE expr */
 {yylhsminor.yy326 = tSqlExprCreate(yymsp[-2].minor.yy326, yymsp[0].minor.yy326, TK_LIKE);  }
   yymsp[-2].minor.yy326 = yylhsminor.yy326;
         break;
-      case 230: /* expr ::= expr IN LP exprlist RP */
+      case 233: /* expr ::= expr IN LP exprlist RP */
 {yylhsminor.yy326 = tSqlExprCreate(yymsp[-4].minor.yy326, (tSQLExpr*)yymsp[-1].minor.yy522, TK_IN); }
   yymsp[-4].minor.yy326 = yylhsminor.yy326;
         break;
-      case 231: /* exprlist ::= exprlist COMMA expritem */
+      case 234: /* exprlist ::= exprlist COMMA expritem */
 {yylhsminor.yy522 = tSqlExprListAppend(yymsp[-2].minor.yy522,yymsp[0].minor.yy326,0, 0);}
   yymsp[-2].minor.yy522 = yylhsminor.yy522;
         break;
-      case 232: /* exprlist ::= expritem */
+      case 235: /* exprlist ::= expritem */
 {yylhsminor.yy522 = tSqlExprListAppend(0,yymsp[0].minor.yy326,0, 0);}
   yymsp[0].minor.yy522 = yylhsminor.yy522;
         break;
-      case 233: /* expritem ::= expr */
+      case 236: /* expritem ::= expr */
 {yylhsminor.yy326 = yymsp[0].minor.yy326;}
   yymsp[0].minor.yy326 = yylhsminor.yy326;
         break;
-      case 235: /* cmd ::= RESET QUERY CACHE */
+      case 238: /* cmd ::= RESET QUERY CACHE */
 { setDCLSQLElems(pInfo, TSDB_SQL_RESET_CACHE, 0);}
         break;
-      case 236: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+      case 239: /* 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.yy247, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 237: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+      case 240: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -2930,14 +3235,14 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 238: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+      case 241: /* 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.yy247, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 239: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+      case 242: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -2948,7 +3253,7 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 240: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+      case 243: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
 {
     yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
 
@@ -2962,7 +3267,7 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 241: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+      case 244: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
 {
     yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n;
 
@@ -2974,14 +3279,14 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 242: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
+      case 245: /* 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.yy247, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 243: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
+      case 246: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -2992,14 +3297,14 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 244: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
+      case 247: /* 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.yy247, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 245: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
+      case 248: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -3010,7 +3315,7 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 246: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
+      case 249: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
 {
     yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
 
@@ -3024,22 +3329,22 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 247: /* cmd ::= KILL CONNECTION INTEGER */
+      case 250: /* cmd ::= KILL CONNECTION INTEGER */
 {setKillSql(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);}
         break;
-      case 248: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
+      case 251: /* 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 249: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
+      case 252: /* 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:
         break;
 /********** End reduce actions ************************************************/
   };
-  assert( yyruleno<sizeof(yyRuleInfo)/sizeof(yyRuleInfo[0]) );
-  yygoto = yyRuleInfo[yyruleno].lhs;
-  yysize = yyRuleInfo[yyruleno].nrhs;
+  assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) );
+  yygoto = yyRuleInfoLhs[yyruleno];
+  yysize = yyRuleInfoNRhs[yyruleno];
   yyact = yy_find_reduce_action(yymsp[yysize].stateno,(YYCODETYPE)yygoto);
 
   /* There are no SHIFTREDUCE actions on nonterminals because the table
@@ -3054,6 +3359,7 @@ static void yy_reduce(
   yymsp->stateno = (YYACTIONTYPE)yyact;
   yymsp->major = (YYCODETYPE)yygoto;
   yyTraceShift(yypParser, yyact, "... then shift");
+  return yyact;
 }
 
 /*
@@ -3063,7 +3369,8 @@ static void yy_reduce(
 static void yy_parse_failed(
   yyParser *yypParser           /* The parser */
 ){
-  ParseARG_FETCH;
+  ParseARG_FETCH
+  ParseCTX_FETCH
 #ifndef NDEBUG
   if( yyTraceFILE ){
     fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);
@@ -3074,7 +3381,8 @@ static void yy_parse_failed(
   ** parser fails */
 /************ Begin %parse_failure code ***************************************/
 /************ End %parse_failure code *****************************************/
-  ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
+  ParseARG_STORE /* Suppress warning about unused %extra_argument variable */
+  ParseCTX_STORE
 }
 #endif /* YYNOERRORRECOVERY */
 
@@ -3086,7 +3394,8 @@ static void yy_syntax_error(
   int yymajor,                   /* The major type of the error token */
   ParseTOKENTYPE yyminor         /* The minor type of the error token */
 ){
-  ParseARG_FETCH;
+  ParseARG_FETCH
+  ParseCTX_FETCH
 #define TOKEN yyminor
 /************ Begin %syntax_error code ****************************************/
 
@@ -3112,7 +3421,8 @@ static void yy_syntax_error(
 
   assert(len <= outputBufLen);
 /************ End %syntax_error code ******************************************/
-  ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
+  ParseARG_STORE /* Suppress warning about unused %extra_argument variable */
+  ParseCTX_STORE
 }
 
 /*
@@ -3121,7 +3431,8 @@ static void yy_syntax_error(
 static void yy_accept(
   yyParser *yypParser           /* The parser */
 ){
-  ParseARG_FETCH;
+  ParseARG_FETCH
+  ParseCTX_FETCH
 #ifndef NDEBUG
   if( yyTraceFILE ){
     fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
@@ -3136,7 +3447,8 @@ static void yy_accept(
 /*********** Begin %parse_accept code *****************************************/
 
 /*********** End %parse_accept code *******************************************/
-  ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
+  ParseARG_STORE /* Suppress warning about unused %extra_argument variable */
+  ParseCTX_STORE
 }
 
 /* The main parser program.
@@ -3165,45 +3477,47 @@ void Parse(
   ParseARG_PDECL               /* Optional %extra_argument parameter */
 ){
   YYMINORTYPE yyminorunion;
-  unsigned int yyact;   /* The parser action. */
+  YYACTIONTYPE yyact;   /* The parser action. */
 #if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
   int yyendofinput;     /* True if we are at the end of input */
 #endif
 #ifdef YYERRORSYMBOL
   int yyerrorhit = 0;   /* True if yymajor has invoked an error */
 #endif
-  yyParser *yypParser;  /* The parser */
+  yyParser *yypParser = (yyParser*)yyp;  /* The parser */
+  ParseCTX_FETCH
+  ParseARG_STORE
 
-  yypParser = (yyParser*)yyp;
   assert( yypParser->yytos!=0 );
 #if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
   yyendofinput = (yymajor==0);
 #endif
-  ParseARG_STORE;
 
+  yyact = yypParser->yytos->stateno;
 #ifndef NDEBUG
   if( yyTraceFILE ){
-    int stateno = yypParser->yytos->stateno;
-    if( stateno < YY_MIN_REDUCE ){
+    if( yyact < YY_MIN_REDUCE ){
       fprintf(yyTraceFILE,"%sInput '%s' in state %d\n",
-              yyTracePrompt,yyTokenName[yymajor],stateno);
+              yyTracePrompt,yyTokenName[yymajor],yyact);
     }else{
       fprintf(yyTraceFILE,"%sInput '%s' with pending reduce %d\n",
-              yyTracePrompt,yyTokenName[yymajor],stateno-YY_MIN_REDUCE);
+              yyTracePrompt,yyTokenName[yymajor],yyact-YY_MIN_REDUCE);
     }
   }
 #endif
 
   do{
-    yyact = yy_find_shift_action(yypParser,(YYCODETYPE)yymajor);
+    assert( yyact==yypParser->yytos->stateno );
+    yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact);
     if( yyact >= YY_MIN_REDUCE ){
-      yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor,yyminor);
+      yyact = yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor,
+                        yyminor ParseCTX_PARAM);
     }else if( yyact <= YY_MAX_SHIFTREDUCE ){
-      yy_shift(yypParser,yyact,yymajor,yyminor);
+      yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor);
 #ifndef YYNOERRORRECOVERY
       yypParser->yyerrcnt--;
 #endif
-      yymajor = YYNOCODE;
+      break;
     }else if( yyact==YY_ACCEPT_ACTION ){
       yypParser->yytos--;
       yy_accept(yypParser);
@@ -3254,10 +3568,9 @@ void Parse(
         yymajor = YYNOCODE;
       }else{
         while( yypParser->yytos >= yypParser->yystack
-            && yymx != YYERRORSYMBOL
             && (yyact = yy_find_reduce_action(
                         yypParser->yytos->stateno,
-                        YYERRORSYMBOL)) >= YY_MIN_REDUCE
+                        YYERRORSYMBOL)) > YY_MAX_SHIFTREDUCE
         ){
           yy_pop_parser_stack(yypParser);
         }
@@ -3274,6 +3587,8 @@ void Parse(
       }
       yypParser->yyerrcnt = 3;
       yyerrorhit = 1;
+      if( yymajor==YYNOCODE ) break;
+      yyact = yypParser->yytos->stateno;
 #elif defined(YYNOERRORRECOVERY)
       /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
       ** do any kind of error recovery.  Instead, simply invoke the syntax
@@ -3284,8 +3599,7 @@ void Parse(
       */
       yy_syntax_error(yypParser,yymajor, yyminor);
       yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
-      yymajor = YYNOCODE;
-      
+      break;
 #else  /* YYERRORSYMBOL is not defined */
       /* This is what we do if the grammar does not define ERROR:
       **
@@ -3307,10 +3621,10 @@ void Parse(
         yypParser->yyerrcnt = -1;
 #endif
       }
-      yymajor = YYNOCODE;
+      break;
 #endif
     }
-  }while( yymajor!=YYNOCODE && yypParser->yytos>yypParser->yystack );
+  }while( yypParser->yytos>yypParser->yystack );
 #ifndef NDEBUG
   if( yyTraceFILE ){
     yyStackEntry *i;
@@ -3325,3 +3639,17 @@ void Parse(
 #endif
   return;
 }
+
+/*
+** Return the fallback token corresponding to canonical token iToken, or
+** 0 if iToken has no fallback.
+*/
+int ParseFallback(int iToken){
+#ifdef YYFALLBACK
+  assert( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) );
+  return yyFallback[iToken];
+#else
+  (void)iToken;
+  return 0;
+#endif
+}

src/tsdb/src/tsdbMeta.c

@@ -50,7 +50,8 @@ int tsdbCreateTable(STsdbRepo *repo, STableCfg *pCfg) {
   STsdbMeta *pMeta = pRepo->tsdbMeta;
   STable *   super = NULL;
   STable *   table = NULL;
-  int        newSuper = 0;
+  bool       newSuper = false;
+  bool       superChanged = false;
   int        tid = pCfg->tableId.tid;
   STable *   pTable = NULL;
 
@@ -85,7 +86,7 @@ int tsdbCreateTable(STsdbRepo *repo, STableCfg *pCfg) {
   if (pCfg->type == TSDB_CHILD_TABLE) {
     super = tsdbGetTableByUid(pMeta, pCfg->superUid);
     if (super == NULL) {  // super table not exists, try to create it
-      newSuper = 1;
+      newSuper = true;
       super = tsdbCreateTableFromCfg(pCfg, true);
       if (super == NULL) goto _err;
     } else {
@@ -93,6 +94,17 @@ int tsdbCreateTable(STsdbRepo *repo, STableCfg *pCfg) {
         terrno = TSDB_CODE_TDB_IVD_CREATE_TABLE_INFO;
         goto _err;
       }
+
+      if (schemaVersion(pCfg->tagSchema) > schemaVersion(super->tagSchema)) {
+        // tag schema out of date, need to update super table tag version
+        STSchema *pOldSchema = super->tagSchema;
+        TSDB_WLOCK_TABLE(super);
+        super->tagSchema = tdDupSchema(pCfg->tagSchema);
+        TSDB_WUNLOCK_TABLE(super);
+        tdFreeSchema(pOldSchema);
+
+        superChanged = true;
+      }
     }
   }
 
@@ -117,7 +129,7 @@ int tsdbCreateTable(STsdbRepo *repo, STableCfg *pCfg) {
   // TODO: refactor duplicate codes
   int   tlen = 0;
   void *pBuf = NULL;
-  if (newSuper) {
+  if (newSuper || superChanged) {
     tlen = tsdbGetTableEncodeSize(TSDB_UPDATE_META, super);
     pBuf = tsdbAllocBytes(pRepo, tlen);
     if (pBuf == NULL) goto _err;

src/wal/CMakeLists.txt

 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 PROJECT(TDengine)
 
+ADD_DEFINITIONS(-DWAL_CHECKSUM_WHOLE)
+
 INCLUDE_DIRECTORIES(inc)
 AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/src SRC)
 

src/wal/src/walWrite.c

@@ -111,6 +111,28 @@ void walRemoveAllOldFiles(void *handle) {
   pthread_mutex_unlock(&pWal->mutex);
 }
 
+#if defined(WAL_CHECKSUM_WHOLE)
+
+static void walUpdateChecksum(SWalHead *pHead) {
+  pHead->sver = 1;
+  pHead->cksum = 0;
+  pHead->cksum = taosCalcChecksum(0, (uint8_t *)pHead, sizeof(*pHead) + pHead->len);
+}
+
+static int walValidateChecksum(SWalHead *pHead) {
+  if (pHead->sver == 0) { // for compatible with wal before sver 1
+    return taosCheckChecksumWhole((uint8_t *)pHead, sizeof(*pHead));
+  } else if (pHead->sver == 1) {
+    uint32_t cksum = pHead->cksum;
+    pHead->cksum = 0;
+    return taosCheckChecksum((uint8_t *)pHead, sizeof(*pHead) + pHead->len, cksum);
+  }
+
+  return 0;
+}
+
+#endif
+
 int32_t walWrite(void *handle, SWalHead *pHead) {
   if (handle == NULL) return -1;
 
@@ -123,7 +145,13 @@ int32_t walWrite(void *handle, SWalHead *pHead) {
   if (pHead->version <= pWal->version) return 0;
 
   pHead->signature = WAL_SIGNATURE;
+#if defined(WAL_CHECKSUM_WHOLE)
+  walUpdateChecksum(pHead);
+#else
+  pHead->sver = 0;
   taosCalcChecksumAppend(0, (uint8_t *)pHead, sizeof(SWalHead));
+#endif
+
   int32_t contLen = pHead->len + sizeof(SWalHead);
 
   pthread_mutex_lock(&pWal->mutex);
@@ -246,16 +274,40 @@ static int32_t walSkipCorruptedRecord(SWal *pWal, SWalHead *pHead, int64_t tfd,
       continue;
     }
 
+#if defined(WAL_CHECKSUM_WHOLE)
+    if (pHead->sver == 0 && walValidateChecksum(pHead)) {
+      wInfo("vgId:%d, wal head cksum check passed, offset:%" PRId64, pWal->vgId, pos);
+      *offset = pos;
+      return TSDB_CODE_SUCCESS;
+    }
+
+    if (pHead->sver == 1) {
+      if (tfRead(tfd, pHead->cont, pHead->len) < pHead->len) {
+	wError("vgId:%d, read to end of corrupted wal file, offset:%" PRId64, pWal->vgId, pos);
+	return TSDB_CODE_WAL_FILE_CORRUPTED;
+      }
+
+      if (walValidateChecksum(pHead)) {
+	wInfo("vgId:%d, wal whole cksum check passed, offset:%" PRId64, pWal->vgId, pos);
+	*offset = pos;
+	return TSDB_CODE_SUCCESS;
+      }
+    }
+
+#else
     if (taosCheckChecksumWhole((uint8_t *)pHead, sizeof(SWalHead))) {
       wInfo("vgId:%d, wal head cksum check passed, offset:%" PRId64, pWal->vgId, pos);
       *offset = pos;
       return TSDB_CODE_SUCCESS;
     }
+
+#endif
   }
 
   return TSDB_CODE_WAL_FILE_CORRUPTED;
 }
 
+
 static int32_t walRestoreWalFile(SWal *pWal, void *pVnode, FWalWrite writeFp, char *name, int64_t fileId) {
   int32_t size = WAL_MAX_SIZE;
   void *  buffer = tmalloc(size);
@@ -293,6 +345,51 @@ static int32_t walRestoreWalFile(SWal *pWal, void *pVnode, FWalWrite writeFp, ch
       break;
     }
 
+#if defined(WAL_CHECKSUM_WHOLE)
+    if (pHead->sver == 0 && !walValidateChecksum(pHead)) {
+      wError("vgId:%d, file:%s, wal head cksum is messed up, hver:%" PRIu64 " len:%d offset:%" PRId64, pWal->vgId, name,
+             pHead->version, pHead->len, offset);
+      code = walSkipCorruptedRecord(pWal, pHead, tfd, &offset);
+      if (code != TSDB_CODE_SUCCESS) {
+        walFtruncate(pWal, tfd, offset);
+        break;
+      }
+    }
+
+    if (pHead->len < 0 || pHead->len > size - sizeof(SWalHead)) {
+      wError("vgId:%d, file:%s, wal head len out of range, hver:%" PRIu64 " len:%d offset:%" PRId64, pWal->vgId, name,
+             pHead->version, pHead->len, offset);
+      code = walSkipCorruptedRecord(pWal, pHead, tfd, &offset);
+      if (code != TSDB_CODE_SUCCESS) {
+        walFtruncate(pWal, tfd, offset);
+        break;
+      }
+    }
+
+    ret = (int32_t)tfRead(tfd, pHead->cont, pHead->len);
+    if (ret < 0) {
+      wError("vgId:%d, file:%s, failed to read wal body since %s", pWal->vgId, name, strerror(errno));
+      code = TAOS_SYSTEM_ERROR(errno);
+      break;
+    }
+
+    if (ret < pHead->len) {
+      wError("vgId:%d, file:%s, failed to read wal body, ret:%d len:%d", pWal->vgId, name, ret, pHead->len);
+      offset += sizeof(SWalHead);
+      continue;
+    }
+
+    if (pHead->sver == 1 && !walValidateChecksum(pHead)) {
+      wError("vgId:%d, file:%s, wal whole cksum is messed up, hver:%" PRIu64 " len:%d offset:%" PRId64, pWal->vgId, name,
+             pHead->version, pHead->len, offset);
+      code = walSkipCorruptedRecord(pWal, pHead, tfd, &offset);
+      if (code != TSDB_CODE_SUCCESS) {
+        walFtruncate(pWal, tfd, offset);
+        break;
+      }
+    }
+
+#else
     if (!taosCheckChecksumWhole((uint8_t *)pHead, sizeof(SWalHead))) {
       wError("vgId:%d, file:%s, wal head cksum is messed up, hver:%" PRIu64 " len:%d offset:%" PRId64, pWal->vgId, name,
              pHead->version, pHead->len, offset);
@@ -326,6 +423,7 @@ static int32_t walRestoreWalFile(SWal *pWal, void *pVnode, FWalWrite writeFp, ch
       continue;
     }
 
+#endif
     offset = offset + sizeof(SWalHead) + pHead->len;
 
     wTrace("vgId:%d, restore wal, fileId:%" PRId64 " hver:%" PRIu64 " wver:%" PRIu64 " len:%d", pWal->vgId,

tests/Jenkinsfile

@@ -109,6 +109,13 @@ pipeline {
                 java --class-path=../../../../src/connector/jdbc/target:$JAVA_HOME/jre/lib/ext -jar target/JDBCDemo-SNAPSHOT-jar-with-dependencies.jar -host 127.0.0.1
                 '''
             }
+            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                sh '''
+                cp -rf ${WKC}/tests/examples/nodejs ${JENKINS_HOME}/workspace/
+                cd ${JENKINS_HOME}/workspace/nodejs
+                node nodejsChecker.js host=localhost
+                '''
+            }
             catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
                 sh '''
                 cd ${JENKINS_HOME}/workspace/C#NET/src/CheckC#

tests/examples/c/demo.c

@@ -62,7 +62,10 @@ int main(int argc, char *argv[]) {
   }
 
   // init TAOS
-  taos_init();
+  if (taos_init()) {
+    exit(1);
+  }
+  
   TAOS *taos = taos_connect(argv[1], "root", "taosdata", NULL, 0);
   if (taos == NULL) {
     printf("failed to connect to server, reason:%s\n", "null taos"/*taos_errstr(taos)*/);

tests/examples/c/prepare.c

@@ -23,7 +23,10 @@ int main(int argc, char *argv[])
   }
 
   // init TAOS
-  taos_init();
+  if (taos_init()) {
+    printf("failed to init taos\n");
+    exit(1);
+  }
 
   taos = taos_connect(argv[1], "root", "taosdata", NULL, 0);
   if (taos == NULL) {

tests/examples/c/stream.c

@@ -55,7 +55,10 @@ int main(int argc, char *argv[])
   } 
 
   // init TAOS
-  taos_init();
+  if (taos_init()) {
+    printf("failed to init taos\n");
+    exit(1);
+  }
 
   strcpy(db_name, argv[2]);
   strcpy(tbl_name, argv[3]);

tests/examples/c/subscribe.c

@@ -217,7 +217,10 @@ int main(int argc, char *argv[]) {
   }
 
   // init TAOS
-  taos_init();
+  if (taos_init()) {
+    printf("failed to init taos\n");
+    exit(1);
+  }
 
   TAOS* taos = taos_connect(host, user, passwd, "", 0);
   if (taos == NULL) {

tests/perftest-scripts/perftest-query.sh

@@ -39,6 +39,8 @@ function buildTDengine {
 	cd $WORK_DIR/TDengine
 
 	git remote update > /dev/null
+	git reset --hard HEAD
+	git checkout develop
 	REMOTE_COMMIT=`git rev-parse --short remotes/origin/develop`
 	LOCAL_COMMIT=`git rev-parse --short @`
 
@@ -54,14 +56,15 @@ function buildTDengine {
 		cd debug
 		rm -rf *
 		cmake .. > /dev/null
-		make > /dev/null
-		make install
+		make && make install > /dev/null		
 	fi
 }
 
 function runQueryPerfTest {
 	[ -f $PERFORMANCE_TEST_REPORT ] && rm $PERFORMANCE_TEST_REPORT
 	nohup $WORK_DIR/TDengine/debug/build/bin/taosd -c /etc/taosperf/ > /dev/null 2>&1 &
+	echoInfo "Wait TDengine to start"
+	sleep 60
 	echoInfo "Run Performance Test"	
 	cd $WORK_DIR/TDengine/tests/pytest
 	
@@ -104,6 +107,7 @@ function sendReport {
 stopTaosd
 buildTDengine
 runQueryPerfTest
+stopTaosd
 
 echoInfo "Send Report"
 sendReport

tests/pytest/crash_gen/crash_gen_main.py

@@ -354,10 +354,11 @@ class ThreadCoordinator:
                 # end, and maybe signal them to stop
             if isinstance(err, CrashGenError): # our own transition failure
                 Logging.info("State transition error")
+                # TODO: saw an error here once, let's print out stack info for err?
                 traceback.print_stack()
                 transitionFailed = True
                 self._te = None  # Not running any more
-                self._execStats.registerFailure("State transition error")
+                self._execStats.registerFailure("State transition error: {}".format(err))
             else:
                 raise
         # return transitionFailed # Why did we have this??!!
@@ -882,8 +883,12 @@ class StateMechine:
         self._stateWeights = [1, 2, 10, 40]
 
     def init(self, dbc: DbConn): # late initailization, don't save the dbConn
+        try:
             self._curState = self._findCurrentState(dbc)  # starting state
-        Logging.debug("Found Starting State: {}".format(self._curState))
+        except taos.error.ProgrammingError as err:            
+            Logging.error("Failed to initialized state machine, cannot find current state: {}".format(err))
+            traceback.print_stack()
+            raise # re-throw
 
     # TODO: seems no lnoger used, remove?
     def getCurrentState(self):
@@ -951,6 +956,8 @@ class StateMechine:
 
     # We transition the system to a new state by examining the current state itself
     def transition(self, tasks, dbc: DbConn):
+        global gSvcMgr
+        
         if (len(tasks) == 0):  # before 1st step, or otherwise empty
             Logging.debug("[STT] Starting State: {}".format(self._curState))
             return  # do nothing
@@ -2370,7 +2377,7 @@ class MainExec:
             '-n',
             '--dynamic-db-table-names',
             action='store_true',
-            help='Use non-fixed names for dbs/tables, useful for multi-instance executions (default: false)')        
+            help='Use non-fixed names for dbs/tables, for -b, useful for multi-instance executions (default: false)')        
         parser.add_argument(
             '-o',
             '--num-dnodes',

tests/pytest/crash_gen/db.py

@@ -15,6 +15,7 @@ from util.log import *
 from .misc import Logging, CrashGenError, Helper, Dice
 import os
 import datetime
+import traceback
 # from .service_manager import TdeInstance
 
 class DbConn:
@@ -349,6 +350,7 @@ class DbConnNative(DbConn):
 
     def execute(self, sql):
         if (not self.isOpen):
+            traceback.print_stack()
             raise CrashGenError(
                 "Cannot exec SQL unless db connection is open", CrashGenError.DB_CONNECTION_NOT_OPEN)
         Logging.debug("[SQL] Executing SQL: {}".format(sql))
@@ -361,6 +363,7 @@ class DbConnNative(DbConn):
 
     def query(self, sql):  # return rows affected
         if (not self.isOpen):
+            traceback.print_stack()
             raise CrashGenError(
                 "Cannot query database until connection is open, restarting?", CrashGenError.DB_CONNECTION_NOT_OPEN)
         Logging.debug("[SQL] Executing SQL: {}".format(sql))

tests/pytest/fulltest.sh

@@ -66,7 +66,7 @@ python3 ./test.py -f tag_lite/int.py
 python3 ./test.py -f tag_lite/set.py
 python3 ./test.py -f tag_lite/smallint.py
 python3 ./test.py -f tag_lite/tinyint.py
-
+python3 ./test.py -f tag_lite/alter_tag.py
 #python3 ./test.py -f dbmgmt/database-name-boundary.py
 
 python3 ./test.py -f import_merge/importBlock1HO.py

tests/pytest/pytest_1.sh

@@ -16,10 +16,10 @@ python3 ./test.py -f insert/nchar.py
 python3 ./test.py -f insert/nchar-unicode.py
 python3 ./test.py -f insert/multi.py
 python3 ./test.py -f insert/randomNullCommit.py
-#python3 insert/retentionpolicy.py
+python3 insert/retentionpolicy.py
 python3 ./test.py -f insert/alterTableAndInsert.py
 python3 ./test.py -f insert/insertIntoTwoTables.py
-#python3 ./test.py -f insert/before_1970.py
+python3 ./test.py -f insert/before_1970.py
 python3 bug2265.py
 
 #table

tests/pytest/pytest_4.sh

@@ -23,4 +23,11 @@ python3 ./test.py -f functions/function_sum.py -r 1
 python3 ./test.py -f functions/function_top.py -r 1
 python3 ./test.py -f functions/function_twa.py -r 1
 python3 ./test.py -f functions/function_twa_test2.py
-python3 ./test.py -f functions/function_stddev_td2555.pyhao
+python3 ./test.py -f functions/function_stddev_td2555.py
\ No newline at end of file
+python3 ./test.py -f insert/metadataUpdate.py
+python3 ./test.py -f tools/taosdemoTest2.py
+python3 ./test.py -f query/last_cache.py
+python3 ./test.py -f query/last_row_cache.py
+python3 ./test.py -f account/account_create.py
+python3 ./test.py -f alter/alter_table.py
+python3 ./test.py -f query/queryGroupbySort.py
\ No newline at end of file

tests/pytest/tag_lite/alter_tag.py

+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+from util.log import tdLog
+from util.cases import tdCases
+from util.sql import tdSql
+from util.dnodes import tdDnodes
+
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor(), logSql)
+
+        self.ts = 1538548685000
+
+    def run(self):
+        tdSql.prepare()
+
+        print("==============step1")
+        tdSql.execute(
+            "CREATE TABLE IF NOT EXISTS ampere (ts TIMESTAMP(8),ampere DOUBLE(8)) TAGS (device_name BINARY(50),build_id BINARY(50),project_id BINARY(50),alias BINARY(50))")
+        tdSql.execute("insert into d1001 using ampere tags('test', '2', '2', '2') VALUES (now, 123)")
+        tdSql.execute("ALTER TABLE ampere ADD TAG variable_id BINARY(50)")
+
+        print("==============step2")
+
+        tdSql.execute("insert into d1002 using ampere tags('test', '2', '2', '2', 'test') VALUES (now, 124)")
+
+        tdSql.query("select * from ampere")
+        tdSql.checkRows(2)
+        tdSql.checkData(0, 6, None)
+        tdSql.checkData(1, 6, 'test')        
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

tests/script/general/parser/create_tb_with_tag_name.sim

+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -i 1
+system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2
+system sh/exec.sh -n dnode1 -s start
+
+sleep 100
+sql connect
+print ======================== dnode1 start
+
+$db = testdb
+
+sql create database $db
+sql use $db
+
+sql create stable st2 (ts timestamp, f1 int) tags (id int, t1 int, t2 nchar(4), t3 double)
+
+
+sql insert into tb1 using st2 (id, t1) tags(1,2) values (now, 1)
+
+sql select id,t1,t2,t3 from tb1
+
+if $rows != 1 then
+  return -1
+endi
+
+if $data00 != 1 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != NULL then 
+  return -1
+endi
+if $data03 != NULL then 
+  return -1
+endi
+
+sql create table tb2 using st2 (t2,t3) tags ("12",22.0)
+
+sql select id,t1,t2,t3 from tb2;
+
+if $rows != 1 then
+  return -1
+endi
+
+if $data00 != NULL then 
+  return -1
+endi
+if $data01 != NULL then 
+  return -1
+endi
+if $data02 != 12 then 
+  return -1
+endi
+if $data03 != 22.000000000 then 
+  return -1
+endi
+
+
+sql create table tb3 using st2 tags (1,2,"3",33.0);
+
+sql select id,t1,t2,t3 from tb3;
+
+
+if $rows != 1 then
+  return -1
+endi
+
+if $data00 != 1 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 3 then 
+  return -1
+endi
+if $data03 != 33.000000000 then 
+  return -1
+endi
+
+sql insert into tb4 using st2 tags(1,2,"33",44.0) values (now, 1);
+
+sql select id,t1,t2,t3 from tb4;
+
+if $rows != 1 then
+  return -1
+endi
+
+if $data00 != 1 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != 33 then 
+  return -1
+endi
+if $data03 != 44.000000000 then 
+  return -1
+endi
+
+sql_error create table tb5 using st2() tags (3,3,"3",33.0);
+
+sql_error create table tb6 using st2 (id,t1) tags (3,3,"3",33.0);
+
+sql_error create table tb7 using st2 (id,t1) tags (3);
+
+sql_error create table tb8 using st2 (ide) tags (3);
+
+sql_error create table tb9 using st2 (id);
+
+sql_error create table tb10 using st2 (id t1) tags (1,1);
+
+sql_error create table tb10 using st2 (id,,t1) tags (1,1,1);
+
+sql_error create table tb11 using st2 (id,t1,) tags (1,1,1);
+
+sql create table tb12 using st2 (t1,id) tags (2,1);
+
+sql select id,t1,t2,t3 from tb12;
+if $rows != 1 then
+  return -1
+endi
+
+if $data00 != 1 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != NULL then 
+  return -1
+endi
+if $data03 != NULL then 
+  return -1
+endi
+
+sql create table tb13 using st2 ("t1",'id') tags (2,1);
+
+sql select id,t1,t2,t3 from tb13;
+
+if $rows != 1 then
+  return -1
+endi
+
+if $data00 != 1 then 
+  return -1
+endi
+if $data01 != 2 then 
+  return -1
+endi
+if $data02 != NULL then 
+  return -1
+endi
+if $data03 != NULL then 
+  return -1
+endi
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT

tests/script/jenkins/basic_2.txt

@@ -72,4 +72,3 @@ cd ../../../debug; make
 ./test.sh -f unique/cluster/cache.sim
 ./test.sh -f unique/cluster/vgroup100.sim
 
-./test.sh -f unique/column/replica3.sim
\ No newline at end of file

tests/script/jenkins/basic_4.txt

@@ -36,3 +36,11 @@
 ./test.sh -f general/stable/show.sim
 ./test.sh -f general/stable/values.sim
 ./test.sh -f general/stable/vnode3.sim
+
+./test.sh -f unique/column/replica3.sim
+./test.sh -f issue/TD-2713.sim
+./test.sh -f general/parser/select_distinct_tag.sim
+./test.sh -f unique/mnode/mgmt30.sim
+./test.sh -f issue/TD-2677.sim
+./test.sh -f issue/TD-2680.sim
+./test.sh -f unique/dnode/lossdata.sim
\ No newline at end of file

tests/tsim/src/simSystem.c

@@ -81,7 +81,9 @@ char *simParseHostName(char *varName) {
 }
 
 bool simSystemInit() {
-  taos_init();
+  if (taos_init()) {
+    return false;
+  }
   taosGetFqdn(simHostName);
   simInitsimCmdList();
   memset(simScriptList, 0, sizeof(SScript *) * MAX_MAIN_SCRIPT_NUM);