Merge branch 'develop' into feature/TD-2502-v3

documentation20/webdocs/markdowndocs/Documentation-ch.md

@@ -128,5 +128,18 @@ TDengine是一个高效的存储、查询、分析时序大数据的平台，专
 
 ## [培训和FAQ](https://www.taosdata.com/cn/faq)
 
-- [FAQ](https://www.taosdata.com/cn/documentation20/faq)：常见问题与答案
-- [应用案列](https://www.taosdata.com/cn/blog/?categories=4)：一些使用实例来解释如何使用TDengine
+<ul>
+        <li><a l href="https://www.taosdata.com/blog/2020/12/25/2126.html">技术公开课：开源、高效的物联网大数据平台，TDengine内核技术剖析</a></li>
+        <li><a l href="https://www.taosdata.com/blog/2020/11/11/1941.html">TDengine视频教程-快速上手</a></li>
+        <li><a l href="https://www.taosdata.com/blog/2020/11/11/1945.html">TDengine视频教程-数据建模</a></li>
+        <li><a l href="https://www.taosdata.com/blog/2020/11/11/1961.html">TDengine视频教程-集群搭建</a></li>
+        <li><a l href="https://www.taosdata.com/blog/2020/11/11/1951.html">TDengine视频教程-Go Connector</a></li>
+        <li><a l href="https://www.taosdata.com/blog/2020/11/11/1955.html">TDengine视频教程-JDBC Connector</a></li>
+        <li><a l href="https://www.taosdata.com/blog/2020/11/11/1957.html">TDengine视频教程-NodeJS Connector</a></li>
+        <li><a l href="https://www.taosdata.com/blog/2020/11/11/1963.html">TDengine视频教程-Python Connector</a></li>
+        <li><a l href="https://www.taosdata.com/blog/2020/11/11/1965.html">TDengine视频教程-RESTful Connector</a></li>
+        <li><a l href="https://www.taosdata.com/blog/2020/11/11/1959.html">TDengine视频教程-“零”代码运维监控</a></li>
+        <li><a l href="https://www.taosdata.com/cn/documentation20/faq">FAQ：常见问题与答案</a></li>
+        <li><a l href="https://www.taosdata.com/cn/blog/?categories=4"> 应用案例：一些使用实例来解释如何使用TDengine</a></li>
+</ul>
+

documentation20/webdocs/markdowndocs/Getting Started-ch.md

@@ -20,7 +20,7 @@ TDengine的安装非常简单，从下载到安装成功仅仅只要几秒钟。
 - TDengine-server-2.0.10.0-Linux-x64.deb (2.7M)
 - TDengine-server-2.0.10.0-Linux-x64.tar.gz (4.5M)
 
-具体的安装过程，请参见<a href="https://www.taosdata.com/blog/2019/08/09/566.html">TDengine多种安装包的安装和卸载</a>。
+具体的安装过程，请参见<a href="https://www.taosdata.com/blog/2019/08/09/566.html">TDengine多种安装包的安装和卸载</a>以及<a href="https://www.taosdata.com/blog/2020/11/11/1941.html">视频教程</a>。
 
 ## 轻松启动
 

documentation20/webdocs/markdowndocs/Model-ch.md

@@ -59,3 +59,5 @@ INSERT INTO d1001 USING METERS TAGS ("Beijng.Chaoyang", 2) VALUES (now, 10.2, 21
 TDengine支持多列模型，只要物理量是一个数据采集点同时采集的（时间戳一致），这些量就可以作为不同列放在一张超级表里。但还有一种极限的设计，单列模型，每个采集的物理量都单独建表，因此每种类型的物理量都单独建立一超级表。比如电流、电压、相位，就建三张超级表。
 
 TDengine建议尽可能采用多列模型，因为插入效率以及存储效率更高。但对于有些场景，一个采集点的采集量的种类经常变化，这个时候，如果采用多列模型，就需要频繁修改超级表的结构定义，让应用变的复杂，这个时候，采用单列模型会显得简单。
+
+关于数据建模请参考<a href="https://www.taosdata.com/blog/2020/11/11/1945.html">视频教程</a>。

documentation20/webdocs/markdowndocs/cluster-ch.md

@@ -226,3 +226,5 @@ SHOW MNODES;
 如果副本数为偶数，当一个vnode group里一半vnode不工作时，是无法从中选出master的。同理，一半mnode不工作时，是无法选出mnode的master的，因为存在“split brain”问题。为解决这个问题，TDengine引入了arbitrator的概念。Arbitrator模拟一个vnode或mnode在工作，但只简单的负责网络连接，不处理任何数据插入或访问。只要包含arbitrator在内，超过半数的vnode或mnode工作，那么该vnode group或mnode组就可以正常的提供数据插入或查询服务。比如对于副本数为2的情形，如果一个节点A离线，但另外一个节点B正常，而且能连接到arbitrator, 那么节点B就能正常工作。
 
 TDengine提供一个执行程序tarbitrator, 找任何一台Linux服务器运行它即可。请点击[安装包下载](https://www.taosdata.com/cn/all-downloads/)，在TDengine Arbitrator Linux一节中，选择适合的版本下载并安装。该程序对系统资源几乎没有要求，只需要保证有网络连接即可。该应用的命令行参数`-p`可以指定其对外服务的端口号，缺省是6042。配置每个taosd实例时，可以在配置文件taos.cfg里将参数arbitrator设置为arbitrator的End Point。如果该参数配置了，当副本数为偶数数，系统将自动连接配置的arbitrator。如果副本数为奇数，即使配置了arbitrator, 系统也不会去建立连接。
+
+关于集群搭建请参考<a href="https://www.taosdata.com/blog/2020/11/11/1961.html">视频教程</a>。

documentation20/webdocs/markdowndocs/connector-ch.md

@@ -187,7 +187,7 @@ C/C++的API类似于MySQL的C API。应用程序使用时，需要包含TDengine
     - pass：密码
     - db：数据库名字，如果用户没有提供，也可以正常连接，用户可以通过该连接创建新的数据库，如果用户提供了数据库名字，则说明该数据库用户已经创建好，缺省使用该数据库
     - port：端口号
-  
+
   返回值为空表示失败。应用程序需要保存返回的参数，以便后续API调用。
 
 - `char *taos_get_server_info(TAOS *taos)`
@@ -336,7 +336,7 @@ TDengine的异步API均采用非阻塞调用模式。应用程序可以用多线
 - `TAOS_RES* taos_stmt_use_result(TAOS_STMT *stmt)`
 
   获取语句的结果集。结果集的使用方式与非参数化调用时一致，使用完成后，应对此结果集调用 `taos_free_result`以释放资源。
-  
+
 - `int taos_stmt_close(TAOS_STMT *stmt)`
 
   执行完毕，释放所有资源。
@@ -354,7 +354,7 @@ TDengine提供时间驱动的实时流式计算API。可以每隔一指定的时
     * stime：是流式计算开始的时间，如果是0，表示从现在开始，如果不为零，表示从指定的时间开始计算（UTC时间从1970/1/1算起的毫秒数）
     * param：是应用提供的用于回调的一个参数，回调时，提供给应用
     * callback: 第二个回调函数，会在连续查询自动停止时被调用。
-  
+
   返回值为NULL，表示创建成功，返回值不为空，表示成功。
 
 - `void taos_close_stream (TAOS_STREAM *tstr)`
@@ -394,6 +394,8 @@ TDengine提供时间驱动的实时流式计算API。可以每隔一指定的时
 
 ## Python Connector
 
+Python连接器的使用参见<a href="https://www.taosdata.com/blog/2020/11/11/1963.html">视频教程</a>
+
 ### 安装准备
 * 应用驱动安装请参考<a href="https://www.taosdata.com/cn/documentation/connector/#安装连接器驱动步骤">安装连接器驱动步骤</a>。
 * 已安装python 2.7 or >= 3.4
@@ -433,7 +435,7 @@ python -m pip install python3\
 * 导入TDengine客户端模块
 
 ```python
-import taos 
+import taos
 ```
 * 获取连接并获取游标对象
 ```python
@@ -445,7 +447,7 @@ c1 = conn.cursor()
 * 写入数据
 ```python
 import datetime
- 
+
 # 创建数据库
 c1.execute('create database db')
 c1.execute('use db')
@@ -473,7 +475,7 @@ numOfRows = c1.rowcount
 numOfCols = len(c1.description)
 for irow in range(numOfRows):
   print("Row%d: ts=%s, temperature=%d, humidity=%f" %(irow, data[irow][0], data[irow][1],data[irow][2]))
-  
+
 # 直接使用cursor 循环拉取查询结果
 c1.execute('select * from tb')
 for data in c1:
@@ -534,7 +536,7 @@ conn.close()
 
 ## RESTful Connector
 
-为支持各种不同类型平台的开发，TDengine提供符合REST设计标准的API，即RESTful API。为最大程度降低学习成本，不同于其他数据库RESTful API的设计方法，TDengine直接通过HTTP POST 请求BODY中包含的SQL语句来操作数据库，仅需要一个URL。 
+为支持各种不同类型平台的开发，TDengine提供符合REST设计标准的API，即RESTful API。为最大程度降低学习成本，不同于其他数据库RESTful API的设计方法，TDengine直接通过HTTP POST 请求BODY中包含的SQL语句来操作数据库，仅需要一个URL。RESTful连接器的使用参见<a href=https://www.taosdata.com/blog/2020/11/11/1965.html>视频教程</a>。
 
 ### HTTP请求格式 
 
@@ -779,7 +781,7 @@ https://www.taosdata.com/blog/2020/11/02/1901.html
 
 TDengine提供了GO驱动程序`taosSql`。 `taosSql`实现了GO语言的内置接口`database/sql/driver`。用户只需按如下方式引入包就可以在应用程序中访问TDengine, 详见`https://github.com/taosdata/driver-go/blob/develop/taosSql/driver_test.go`。
 
-使用 Go 连接器的示例代码请参考 https://github.com/taosdata/TDengine/tree/develop/tests/examples/go。
+使用 Go 连接器的示例代码请参考 https://github.com/taosdata/TDengine/tree/develop/tests/examples/go 以及<a href="https://www.taosdata.com/blog/2020/11/11/1951.html">视频教程</a>。
 
 ```Go
 import (
@@ -796,7 +798,7 @@ go env -w GOPROXY=https://goproxy.io,direct
 
 ### 常用API
 
-- sql.Open(DRIVER_NAME string, dataSourceName string) *DB` 
+- `sql.Open(DRIVER_NAME string, dataSourceName string) *DB` 
 
   该API用来打开DB，返回一个类型为*DB的对象，一般情况下，DRIVER_NAME设置为字符串`taosSql`, dataSourceName设置为字符串`user:password@/tcp(host:port)/dbname`，如果客户想要用多个goroutine并发访问TDengine, 那么需要在各个goroutine中分别创建一个sql.Open对象并用之访问TDengine
 
@@ -835,6 +837,8 @@ Node.js连接器支持的系统有：
 | **OS类型**   | Linux        | Win64    | Win32    | Linux    | Linux    |
 | **支持与否** | **支持**     | **支持** | **支持** | **支持** | **支持** |
 
+Node.js连接器的使用参见<a href="https://www.taosdata.com/blog/2020/11/11/1957.html">视频教程</a>
+
 ### 安装准备
 
 * 应用驱动安装请参考<a href="https://www.taosdata.com/cn/documentation/connector/#安装连接器驱动步骤">安装连接器驱动步骤</a>。
@@ -909,7 +913,7 @@ node nodejsChecker.js host=localhost
 
 #### 建立连接
 
-使用node.js连接器时，必须先<em>require</em> ```td2.0-connector```，然后使用 ```taos.connect``` 函数。```taos.connect``` 函数必须提供的参数是```host```，其它参数在没有提供的情况下会使用如下的默认值。最后需要初始化```cursor``` 来和TDengine服务端通信 
+使用node.js连接器时，必须先<em>require</em> `td2.0-connector`，然后使用 `taos.connect` 函数。`taos.connect` 函数必须提供的参数是`host`，其它参数在没有提供的情况下会使用如下的默认值。最后需要初始化`cursor` 来和TDengine服务端通信 
 
 ```javascript
 const taos = require('td2.0-connector');
@@ -945,13 +949,13 @@ TDengine目前还不支持update和delete语句。
 
 #### 查询
 
-可通过 ```cursor.query``` 函数来查询数据库。
+可通过 `cursor.query` 函数来查询数据库。
 
 ```javascript
 var query = cursor.query('show databases;')
 ```
 
-查询的结果可以通过 ```query.execute()``` 函数获取并打印出来
+查询的结果可以通过 `query.execute()` 函数获取并打印出来
 
 ```javascript
 var promise = query.execute();
@@ -959,7 +963,7 @@ promise.then(function(result) {
   result.pretty(); 
 });
 ```
-格式化查询语句还可以使用```query```的```bind```方法。如下面的示例：```query```会自动将提供的数值填入查询语句的```?```里。
+格式化查询语句还可以使用`query`的`bind`方法。如下面的示例：`query`会自动将提供的数值填入查询语句的`?`里。
 
 ```javascript
 var query = cursor.query('select * from meterinfo.meters where ts <= ? and areaid = ?;').bind(new Date(), 5);
@@ -967,7 +971,7 @@ query.execute().then(function(result) {
   result.pretty();
 })
 ```
-如果在```query```语句里提供第二个参数并设为```true```也可以立即获取查询结果。如下：
+如果在`query`语句里提供第二个参数并设为`true`也可以立即获取查询结果。如下：
 
 ```javascript
 var promise = cursor.query('select * from meterinfo.meters where v1 = 30;', true)
@@ -991,4 +995,4 @@ promise2.then(function(result) {
 ### 示例
 <a href="https://github.com/taosdata/TDengine/tree/master/tests/examples/nodejs/node-example.js">这里</a>提供了一个使用NodeJS 连接器建表，插入天气数据并查询插入的数据的代码示例
 
-<a href="https://github.com/taosdata/TDengine/tree/master/tests/examples/nodejs/node-example-raw.js">这里</a>同样是一个使用NodeJS 连接器建表，插入天气数据并查询插入的数据的代码示例，但和上面不同的是，该示例只使用`cursor`.
+<a href="https://github.com/taosdata/TDengine/tree/master/tests/examples/nodejs/node-example-raw.js">这里</a>同样是一个使用NodeJS 连接器建表，插入天气数据并查询插入的数据的代码示例，但和上面不同的是，该示例只使用`cursor`.
\ No newline at end of file

documentation20/webdocs/markdowndocs/connector-java-ch.md

@@ -6,6 +6,8 @@ Java连接器支持的系统有：
 | **OS类型**   | Linux        | Win64    | Win32    | Linux    | Linux    |
 | **支持与否** | **支持**     | **支持** | **支持** | **支持** | **支持** |
 
+Java连接器的使用请参见<a href=https://www.taosdata.com/blog/2020/11/11/1955.html>视频教程</a>。
+
 TDengine 为了方便 Java 应用使用，提供了遵循 JDBC 标准(3.0)API 规范的 `taos-jdbcdriver` 实现。目前可以通过 [Sonatype Repository][1] 搜索并下载。
 
 由于 TDengine 是使用 c 语言开发的，使用 taos-jdbcdriver 驱动包时需要依赖系统对应的本地函数库。

src/client/inc/tsclient.h

@@ -419,7 +419,7 @@ void tscCloseTscObj(void *pObj);
 // todo move to taos? or create a new file: taos_internal.h
 TAOS *taos_connect_a(char *ip, char *user, char *pass, char *db, uint16_t port, void (*fp)(void *, TAOS_RES *, int),
                      void *param, TAOS **taos);
-TAOS_RES* taos_query_h(TAOS* taos, const char *sqlstr, TAOS_RES** res);
+TAOS_RES* taos_query_h(TAOS* taos, const char *sqlstr, int64_t* res);
 void waitForQueryRsp(void *param, TAOS_RES *tres, int code);
 
 void doAsyncQuery(STscObj *pObj, SSqlObj *pSql, __async_cb_func_t fp, void *param, const char *sqlstr, size_t sqlLen);

src/client/src/tscSQLParser.c

@@ -5442,6 +5442,7 @@ static void setCreateDBOption(SCreateDbMsg* pMsg, SCreateDBInfo* pCreateDb) {
   pMsg->quorum = pCreateDb->quorum;
   pMsg->ignoreExist = pCreateDb->ignoreExists;
   pMsg->update = pCreateDb->update;
+  pMsg->cacheLastRow = pCreateDb->cachelast;
 }
 
 int32_t parseCreateDBOptions(SSqlCmd* pCmd, SCreateDBInfo* pCreateDbSql) {

src/client/src/tscServer.c

@@ -1247,7 +1247,7 @@ int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     pShowMsg->payloadLen = htons(pEpAddr->n);
   }
 
-  pCmd->payloadLen = sizeof(SShowMsg) + pShowMsg->payloadLen;
+  pCmd->payloadLen = sizeof(SShowMsg) + htons(pShowMsg->payloadLen);
   return TSDB_CODE_SUCCESS;
 }
 

src/client/src/tscSql.c

@@ -314,7 +314,7 @@ static void waitForRetrieveRsp(void *param, TAOS_RES *tres, int numOfRows) {
   tsem_post(&pSql->rspSem);
 }
 
-TAOS_RES* taos_query_c(TAOS *taos, const char *sqlstr, uint32_t sqlLen, TAOS_RES** res) {
+TAOS_RES* taos_query_c(TAOS *taos, const char *sqlstr, uint32_t sqlLen, int64_t* res) {
   STscObj *pObj = (STscObj *)taos;
   if (pObj == NULL || pObj->signature != pObj) {
     terrno = TSDB_CODE_TSC_DISCONNECTED;
@@ -340,7 +340,7 @@ TAOS_RES* taos_query_c(TAOS *taos, const char *sqlstr, uint32_t sqlLen, TAOS_RES
   doAsyncQuery(pObj, pSql, waitForQueryRsp, taos, sqlstr, sqlLen);
 
   if (res != NULL) {
-    *res = pSql;
+    atomic_store_64(res, pSql->self);
   }
 
   tsem_wait(&pSql->rspSem);
@@ -351,7 +351,7 @@ TAOS_RES* taos_query(TAOS *taos, const char *sqlstr) {
   return taos_query_c(taos, sqlstr, (uint32_t)strlen(sqlstr), NULL);
 }
 
-TAOS_RES* taos_query_h(TAOS* taos, const char *sqlstr, TAOS_RES** res) {
+TAOS_RES* taos_query_h(TAOS* taos, const char *sqlstr, int64_t* res) {
   return taos_query_c(taos, sqlstr, (uint32_t) strlen(sqlstr), res);
 }
 

src/common/inc/tglobal.h

@@ -94,6 +94,7 @@ extern int32_t tsFsyncPeriod;
 extern int32_t tsReplications;
 extern int32_t tsQuorum;
 extern int32_t tsUpdate;
+extern int32_t tsCacheLastRow;
 
 // balance
 extern int32_t tsEnableBalance;

src/common/src/tglobal.c

@@ -127,6 +127,7 @@ int32_t tsFsyncPeriod   = TSDB_DEFAULT_FSYNC_PERIOD;
 int32_t tsReplications  = TSDB_DEFAULT_DB_REPLICA_OPTION;
 int32_t tsQuorum        = TSDB_DEFAULT_DB_QUORUM_OPTION;
 int32_t tsUpdate        = TSDB_DEFAULT_DB_UPDATE_OPTION;
+int32_t tsCacheLastRow  = TSDB_DEFAULT_CACHE_BLOCK_SIZE;
 int32_t tsMaxVgroupsPerDb  = 0;
 int32_t tsMinTablePerVnode = TSDB_TABLES_STEP;
 int32_t tsMaxTablePerVnode = TSDB_DEFAULT_TABLES;

src/dnode/src/dnodeVMgmt.c

@@ -217,4 +217,4 @@ static int32_t dnodeProcessCreateMnodeMsg(SRpcMsg *pMsg) {
   dnodeStartMnode(&pCfg->mnodes);
 
   return TSDB_CODE_SUCCESS;
-}
+}
\ No newline at end of file

src/inc/taosdef.h

@@ -369,6 +369,10 @@ void tsDataSwap(void *pLeft, void *pRight, int32_t type, int32_t size, void* buf
 #define TSDB_MAX_DB_UPDATE              1
 #define TSDB_DEFAULT_DB_UPDATE_OPTION   0
 
+#define TSDB_MIN_DB_CACHE_LAST_ROW      0
+#define TSDB_MAX_DB_CACHE_LAST_ROW      1
+#define TSDB_DEFAULT_CACHE_LAST_ROW     0
+
 #define TSDB_MIN_FSYNC_PERIOD           0
 #define TSDB_MAX_FSYNC_PERIOD           180000   // millisecond
 #define TSDB_DEFAULT_FSYNC_PERIOD       3000     // three second

src/inc/taosmsg.h

@@ -549,7 +549,8 @@ typedef struct {
   int8_t   quorum;
   int8_t   ignoreExist;
   int8_t   update;
-  int8_t   reserve[9];
+  int8_t   cacheLastRow;
+  int8_t   reserve[8];
 } SCreateDbMsg, SAlterDbMsg;
 
 typedef struct {
@@ -661,8 +662,9 @@ typedef struct {
   int8_t   wals;
   int8_t   quorum;
   int8_t   update;
-  int8_t   reserved[11];
+  int8_t   cacheLastRow;
   int32_t  vgCfgVersion;
+  int8_t   reserved[10];
 } SVnodeCfg;
 
 typedef struct {

src/inc/tsdb.h

@@ -66,6 +66,7 @@ typedef struct {
   int8_t  precision;
   int8_t  compression;
   int8_t  update;
+  int8_t  cacheLastRow;
 } STsdbCfg;
 
 // --------- TSDB REPOSITORY USAGE STATISTICS
@@ -119,7 +120,7 @@ STableCfg *tsdbCreateTableCfgFromMsg(SMDCreateTableMsg *pMsg);
 int   tsdbCreateTable(TSDB_REPO_T *repo, STableCfg *pCfg);
 int   tsdbDropTable(TSDB_REPO_T *pRepo, STableId tableId);
 int   tsdbUpdateTableTagValue(TSDB_REPO_T *repo, SUpdateTableTagValMsg *pMsg);
-TSKEY tsdbGetTableLastKey(TSDB_REPO_T *repo, uint64_t uid);
+// TSKEY tsdbGetTableLastKey(TSDB_REPO_T *repo, uint64_t uid);
 
 uint32_t tsdbGetFileInfo(TSDB_REPO_T *repo, char *name, uint32_t *index, uint32_t eindex, int64_t *size);
 

src/inc/ttokendef.h

@@ -114,114 +114,115 @@
 #define TK_COMP                            96
 #define TK_PRECISION                       97
 #define TK_UPDATE                          98
-#define TK_LP                              99
-#define TK_RP                             100
-#define TK_TAGS                           101
-#define TK_USING                          102
-#define TK_AS                             103
-#define TK_COMMA                          104
-#define TK_NULL                           105
-#define TK_SELECT                         106
-#define TK_UNION                          107
-#define TK_ALL                            108
-#define TK_FROM                           109
-#define TK_VARIABLE                       110
-#define TK_INTERVAL                       111
-#define TK_FILL                           112
-#define TK_SLIDING                        113
-#define TK_ORDER                          114
-#define TK_BY                             115
-#define TK_ASC                            116
-#define TK_DESC                           117
-#define TK_GROUP                          118
-#define TK_HAVING                         119
-#define TK_LIMIT                          120
-#define TK_OFFSET                         121
-#define TK_SLIMIT                         122
-#define TK_SOFFSET                        123
-#define TK_WHERE                          124
-#define TK_NOW                            125
-#define TK_RESET                          126
-#define TK_QUERY                          127
-#define TK_ADD                            128
-#define TK_COLUMN                         129
-#define TK_TAG                            130
-#define TK_CHANGE                         131
-#define TK_SET                            132
-#define TK_KILL                           133
-#define TK_CONNECTION                     134
-#define TK_STREAM                         135
-#define TK_COLON                          136
-#define TK_ABORT                          137
-#define TK_AFTER                          138
-#define TK_ATTACH                         139
-#define TK_BEFORE                         140
-#define TK_BEGIN                          141
-#define TK_CASCADE                        142
-#define TK_CLUSTER                        143
-#define TK_CONFLICT                       144
-#define TK_COPY                           145
-#define TK_DEFERRED                       146
-#define TK_DELIMITERS                     147
-#define TK_DETACH                         148
-#define TK_EACH                           149
-#define TK_END                            150
-#define TK_EXPLAIN                        151
-#define TK_FAIL                           152
-#define TK_FOR                            153
-#define TK_IGNORE                         154
-#define TK_IMMEDIATE                      155
-#define TK_INITIALLY                      156
-#define TK_INSTEAD                        157
-#define TK_MATCH                          158
-#define TK_KEY                            159
-#define TK_OF                             160
-#define TK_RAISE                          161
-#define TK_REPLACE                        162
-#define TK_RESTRICT                       163
-#define TK_ROW                            164
-#define TK_STATEMENT                      165
-#define TK_TRIGGER                        166
-#define TK_VIEW                           167
-#define TK_COUNT                          168
-#define TK_SUM                            169
-#define TK_AVG                            170
-#define TK_MIN                            171
-#define TK_MAX                            172
-#define TK_FIRST                          173
-#define TK_LAST                           174
-#define TK_TOP                            175
-#define TK_BOTTOM                         176
-#define TK_STDDEV                         177
-#define TK_PERCENTILE                     178
-#define TK_APERCENTILE                    179
-#define TK_LEASTSQUARES                   180
-#define TK_HISTOGRAM                      181
-#define TK_DIFF                           182
-#define TK_SPREAD                         183
-#define TK_TWA                            184
-#define TK_INTERP                         185
-#define TK_LAST_ROW                       186
-#define TK_RATE                           187
-#define TK_IRATE                          188
-#define TK_SUM_RATE                       189
-#define TK_SUM_IRATE                      190
-#define TK_AVG_RATE                       191
-#define TK_AVG_IRATE                      192
-#define TK_TBID                           193
-#define TK_SEMI                           194
-#define TK_NONE                           195
-#define TK_PREV                           196
-#define TK_LINEAR                         197
-#define TK_IMPORT                         198
-#define TK_METRIC                         199
-#define TK_TBNAME                         200
-#define TK_JOIN                           201
-#define TK_METRICS                        202
-#define TK_STABLE                         203
-#define TK_INSERT                         204
-#define TK_INTO                           205
-#define TK_VALUES                         206
+#define TK_CACHELAST                       99
+#define TK_LP                             100
+#define TK_RP                             101
+#define TK_TAGS                           102
+#define TK_USING                          103
+#define TK_AS                             104
+#define TK_COMMA                          105
+#define TK_NULL                           106
+#define TK_SELECT                         107
+#define TK_UNION                          108
+#define TK_ALL                            109
+#define TK_FROM                           110
+#define TK_VARIABLE                       111
+#define TK_INTERVAL                       112
+#define TK_FILL                           113
+#define TK_SLIDING                        114
+#define TK_ORDER                          115
+#define TK_BY                             116
+#define TK_ASC                            117
+#define TK_DESC                           118
+#define TK_GROUP                          119
+#define TK_HAVING                         120
+#define TK_LIMIT                          121
+#define TK_OFFSET                         122
+#define TK_SLIMIT                         123
+#define TK_SOFFSET                        124
+#define TK_WHERE                          125
+#define TK_NOW                            126
+#define TK_RESET                          127
+#define TK_QUERY                          128
+#define TK_ADD                            129
+#define TK_COLUMN                         130
+#define TK_TAG                            131
+#define TK_CHANGE                         132
+#define TK_SET                            133
+#define TK_KILL                           134
+#define TK_CONNECTION                     135
+#define TK_STREAM                         136
+#define TK_COLON                          137
+#define TK_ABORT                          138
+#define TK_AFTER                          139
+#define TK_ATTACH                         140
+#define TK_BEFORE                         141
+#define TK_BEGIN                          142
+#define TK_CASCADE                        143
+#define TK_CLUSTER                        144
+#define TK_CONFLICT                       145
+#define TK_COPY                           146
+#define TK_DEFERRED                       147
+#define TK_DELIMITERS                     148
+#define TK_DETACH                         149
+#define TK_EACH                           150
+#define TK_END                            151
+#define TK_EXPLAIN                        152
+#define TK_FAIL                           153
+#define TK_FOR                            154
+#define TK_IGNORE                         155
+#define TK_IMMEDIATE                      156
+#define TK_INITIALLY                      157
+#define TK_INSTEAD                        158
+#define TK_MATCH                          159
+#define TK_KEY                            160
+#define TK_OF                             161
+#define TK_RAISE                          162
+#define TK_REPLACE                        163
+#define TK_RESTRICT                       164
+#define TK_ROW                            165
+#define TK_STATEMENT                      166
+#define TK_TRIGGER                        167
+#define TK_VIEW                           168
+#define TK_COUNT                          169
+#define TK_SUM                            170
+#define TK_AVG                            171
+#define TK_MIN                            172
+#define TK_MAX                            173
+#define TK_FIRST                          174
+#define TK_LAST                           175
+#define TK_TOP                            176
+#define TK_BOTTOM                         177
+#define TK_STDDEV                         178
+#define TK_PERCENTILE                     179
+#define TK_APERCENTILE                    180
+#define TK_LEASTSQUARES                   181
+#define TK_HISTOGRAM                      182
+#define TK_DIFF                           183
+#define TK_SPREAD                         184
+#define TK_TWA                            185
+#define TK_INTERP                         186
+#define TK_LAST_ROW                       187
+#define TK_RATE                           188
+#define TK_IRATE                          189
+#define TK_SUM_RATE                       190
+#define TK_SUM_IRATE                      191
+#define TK_AVG_RATE                       192
+#define TK_AVG_IRATE                      193
+#define TK_TBID                           194
+#define TK_SEMI                           195
+#define TK_NONE                           196
+#define TK_PREV                           197
+#define TK_LINEAR                         198
+#define TK_IMPORT                         199
+#define TK_METRIC                         200
+#define TK_TBNAME                         201
+#define TK_JOIN                           202
+#define TK_METRICS                        203
+#define TK_STABLE                         204
+#define TK_INSERT                         205
+#define TK_INTO                           206
+#define TK_VALUES                         207
 
 
 #define TK_SPACE                          300

src/kit/shell/src/shellEngine.c

@@ -302,14 +302,12 @@ void shellRunCommandOnServer(TAOS *con, char command[]) {
 
   st = taosGetTimestampUs();
 
-  TAOS_RES* tmpSql = NULL;
-  TAOS_RES* pSql = taos_query_h(con, command, &tmpSql);
+  TAOS_RES* pSql = taos_query_h(con, command, &result);
   if (taos_errno(pSql)) {
     taos_error(pSql, st);
     return;
   }
 
-  atomic_store_64(&result, ((SSqlObj*)tmpSql)->self);
   int64_t oresult = atomic_load_64(&result);
 
   if (regex_match(command, "^\\s*use\\s+[a-zA-Z0-9_]+\\s*;\\s*$", REG_EXTENDED | REG_ICASE)) {

src/mnode/inc/mnodeDef.h

@@ -174,7 +174,8 @@ typedef struct {
   int8_t  replications;
   int8_t  quorum;
   int8_t  update;
-  int8_t  reserved[11];
+  int8_t  cacheLastRow;
+  int8_t  reserved[10];
 } SDbCfg;
 
 typedef struct SDbObj {

src/mnode/src/mnodeDb.c

@@ -322,6 +322,11 @@ static int32_t mnodeCheckDbCfg(SDbCfg *pCfg) {
     return TSDB_CODE_MND_INVALID_DB_OPTION;
   }
 
+  if (pCfg->cacheLastRow < TSDB_MIN_DB_CACHE_LAST_ROW || pCfg->cacheLastRow > TSDB_MAX_DB_CACHE_LAST_ROW) {
+    mError("invalid db option cacheLastRow:%d valid range: [%d, %d]", pCfg->cacheLastRow, TSDB_MIN_DB_CACHE_LAST_ROW, TSDB_MAX_DB_CACHE_LAST_ROW);
+    return TSDB_CODE_MND_INVALID_DB_OPTION;
+  }
+
   return TSDB_CODE_SUCCESS;
 }
 
@@ -343,6 +348,7 @@ static void mnodeSetDefaultDbCfg(SDbCfg *pCfg) {
   if (pCfg->replications < 0) pCfg->replications = tsReplications;
   if (pCfg->quorum < 0) pCfg->quorum = tsQuorum;
   if (pCfg->update < 0) pCfg->update = tsUpdate;
+  if (pCfg->cacheLastRow < 0) pCfg->cacheLastRow = tsCacheLastRow;
 }
 
 static int32_t mnodeCreateDbCb(SMnodeMsg *pMsg, int32_t code) {
@@ -396,7 +402,8 @@ static int32_t mnodeCreateDb(SAcctObj *pAcct, SCreateDbMsg *pCreate, SMnodeMsg *
     .walLevel            = pCreate->walLevel,
     .replications        = pCreate->replications,
     .quorum              = pCreate->quorum,
-    .update              = pCreate->update
+    .update              = pCreate->update,
+    .cacheLastRow        = pCreate->cacheLastRow
   };
 
   mnodeSetDefaultDbCfg(&pDb->cfg);
@@ -605,6 +612,12 @@ static int32_t mnodeGetDbMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn
     strcpy(pSchema[cols].name, "comp");
     pSchema[cols].bytes = htons(pShow->bytes[cols]);
     cols++;
+
+    pShow->bytes[cols] = 1;
+    pSchema[cols].type = TSDB_DATA_TYPE_TINYINT;
+    strcpy(pSchema[cols].name, "cachelast");
+    pSchema[cols].bytes = htons(pShow->bytes[cols]);
+    cols++;
 #ifndef __CLOUD_VERSION__
   }
 #endif
@@ -750,6 +763,10 @@ static int32_t mnodeRetrieveDbs(SShowObj *pShow, char *data, int32_t rows, void
       pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
       *(int8_t *)pWrite = pDb->cfg.compression;
       cols++;
+
+      pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows;
+      *(int8_t *)pWrite = pDb->cfg.cacheLastRow;
+      cols++;
 #ifndef __CLOUD_VERSION__
     }
 #endif
@@ -864,6 +881,7 @@ static SDbCfg mnodeGetAlterDbOption(SDbObj *pDb, SAlterDbMsg *pAlter) {
   int8_t  quorum         = pAlter->quorum;
   int8_t  precision      = pAlter->precision;
   int8_t  update         = pAlter->update;
+  int8_t  cacheLastRow   = pAlter->cacheLastRow;
   
   terrno = TSDB_CODE_SUCCESS;
 
@@ -976,6 +994,11 @@ static SDbCfg mnodeGetAlterDbOption(SDbObj *pDb, SAlterDbMsg *pAlter) {
 #endif
   }
 
+  if (cacheLastRow >= 0 && cacheLastRow != pDb->cfg.cacheLastRow) {
+    mDebug("db:%s, cacheLastRow:%d change to %d", pDb->name, pDb->cfg.cacheLastRow, cacheLastRow);
+    newCfg.cacheLastRow = cacheLastRow;
+  }
+
   return newCfg;
 }
 

src/mnode/src/mnodeVgroup.c

@@ -863,6 +863,7 @@ static SCreateVnodeMsg *mnodeBuildVnodeMsg(SVgObj *pVgroup) {
   pCfg->wals                = 3;
   pCfg->quorum              = pDb->cfg.quorum;
   pCfg->update              = pDb->cfg.update;
+  pCfg->cacheLastRow        = pDb->cfg.cacheLastRow;
   
   SVnodeDesc *pNodes = pVnode->nodes;
   for (int32_t j = 0; j < pVgroup->numOfVnodes; ++j) {

src/query/inc/qSqlparser.h

@@ -120,7 +120,8 @@ typedef struct SCreateDBInfo {
   int32_t   compressionLevel;
   SStrToken precision;
   bool      ignoreExists;
-  int8_t    update; 
+  int8_t    update;
+  int8_t    cachelast; 
   
   SArray *keep;
 } SCreateDBInfo;

src/query/inc/sql.y

@@ -112,29 +112,29 @@ cmd ::= SHOW dbPrefix(X) STABLES.      {
 
 cmd ::= SHOW dbPrefix(X) STABLES LIKE ids(Y).      {
     SStrToken token;
-    setDBName(&token, &X);
+    setDbName(&token, &X);
     setShowOptions(pInfo, TSDB_MGMT_TABLE_METRIC, &token, &Y);
 }
 
 cmd ::= SHOW dbPrefix(X) VGROUPS.    {
     SStrToken token;
-    setDBName(&token, &X);
+    setDbName(&token, &X);
     setShowOptions(pInfo, TSDB_MGMT_TABLE_VGROUP, &token, 0);
 }
 
 cmd ::= SHOW dbPrefix(X) VGROUPS ids(Y).    {
     SStrToken token;
-    setDBName(&token, &X);    
+    setDbName(&token, &X);
     setShowOptions(pInfo, TSDB_MGMT_TABLE_VGROUP, &token, &Y);
 }
 
 //drop configure for tables
 cmd ::= DROP TABLE ifexists(Y) ids(X) cpxName(Z).   {
     X.n += Z.n;
-    setDropDBTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &X, &Y);
+    setDropDbTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &X, &Y);
 }
 
-cmd ::= DROP DATABASE ifexists(Y) ids(X).    { setDropDBTableInfo(pInfo, TSDB_SQL_DROP_DB, &X, &Y); }
+cmd ::= DROP DATABASE ifexists(Y) ids(X).    { setDropDbTableInfo(pInfo, TSDB_SQL_DROP_DB, &X, &Y); }
 cmd ::= DROP DNODE ids(X).       { setDCLSQLElems(pInfo, TSDB_SQL_DROP_DNODE, 1, &X);    }
 cmd ::= DROP USER ids(X).        { setDCLSQLElems(pInfo, TSDB_SQL_DROP_USER, 1, &X);     }
 cmd ::= DROP ACCOUNT ids(X).     { setDCLSQLElems(pInfo, TSDB_SQL_DROP_ACCT, 1, &X);  }
@@ -149,16 +149,16 @@ cmd ::= DESCRIBE ids(X) cpxName(Y). {
 }
 
 /////////////////////////////////THE ALTER STATEMENT////////////////////////////////////////
-cmd ::= ALTER USER ids(X) PASS ids(Y).          { setAlterUserSQL(pInfo, TSDB_ALTER_USER_PASSWD, &X, &Y, NULL);    }
-cmd ::= ALTER USER ids(X) PRIVILEGE ids(Y).     { setAlterUserSQL(pInfo, TSDB_ALTER_USER_PRIVILEGES, &X, NULL, &Y);}
+cmd ::= ALTER USER ids(X) PASS ids(Y).          { setAlterUserSql(pInfo, TSDB_ALTER_USER_PASSWD, &X, &Y, NULL);    }
+cmd ::= ALTER USER ids(X) PRIVILEGE ids(Y).     { setAlterUserSql(pInfo, TSDB_ALTER_USER_PRIVILEGES, &X, NULL, &Y);}
 cmd ::= ALTER DNODE ids(X) ids(Y).              { setDCLSQLElems(pInfo, TSDB_SQL_CFG_DNODE, 2, &X, &Y);          }
 cmd ::= ALTER DNODE ids(X) ids(Y) ids(Z).       { setDCLSQLElems(pInfo, TSDB_SQL_CFG_DNODE, 3, &X, &Y, &Z);      }
 cmd ::= ALTER LOCAL ids(X).                     { setDCLSQLElems(pInfo, TSDB_SQL_CFG_LOCAL, 1, &X);              }
 cmd ::= ALTER LOCAL ids(X) ids(Y).              { setDCLSQLElems(pInfo, TSDB_SQL_CFG_LOCAL, 2, &X, &Y);          }
 cmd ::= ALTER DATABASE ids(X) alter_db_optr(Y). { SStrToken t = {0};  setCreateDBSQL(pInfo, TSDB_SQL_ALTER_DB, &X, &Y, &t);}
 
-cmd ::= ALTER ACCOUNT ids(X) acct_optr(Z).      { setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &X, NULL, &Z);}
-cmd ::= ALTER ACCOUNT ids(X) PASS ids(Y) acct_optr(Z).      { setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &X, &Y, &Z);}
+cmd ::= ALTER ACCOUNT ids(X) acct_optr(Z).      { setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &X, NULL, &Z);}
+cmd ::= ALTER ACCOUNT ids(X) PASS ids(Y) acct_optr(Z).      { setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &X, &Y, &Z);}
 
 // An IDENTIFIER can be a generic identifier, or one of several keywords.
 // Any non-standard keyword can also be an identifier.
@@ -179,9 +179,9 @@ ifnotexists(X) ::= .                { X.n = 0;}
 //create option for dnode/db/user/account
 cmd ::= CREATE DNODE   ids(X).     { setDCLSQLElems(pInfo, TSDB_SQL_CREATE_DNODE, 1, &X);}
 cmd ::= CREATE ACCOUNT ids(X) PASS ids(Y) acct_optr(Z).
-                                { setCreateAcctSQL(pInfo, TSDB_SQL_CREATE_ACCT, &X, &Y, &Z);}
+                                { setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &X, &Y, &Z);}
 cmd ::= CREATE DATABASE ifnotexists(Z) ids(X) db_optr(Y).  { setCreateDBSQL(pInfo, TSDB_SQL_CREATE_DB, &X, &Y, &Z);}
-cmd ::= CREATE USER ids(X) PASS ids(Y).     { setCreateUserSQL(pInfo, &X, &Y);}
+cmd ::= CREATE USER ids(X) PASS ids(Y).     { setCreateUserSql(pInfo, &X, &Y);}
 
 pps(Y) ::= .                                { Y.n = 0;   }
 pps(Y) ::= PPS INTEGER(X).                  { Y = X;     }
@@ -240,6 +240,7 @@ fsync(Y)   ::= FSYNC INTEGER(X).              { Y = X; }
 comp(Y)    ::= COMP INTEGER(X).               { Y = X; }
 prec(Y)    ::= PRECISION STRING(X).           { Y = X; }
 update(Y)  ::= UPDATE INTEGER(X).             { Y = X; }     
+cachelast(Y) ::= CACHELAST INTEGER(X).        { Y = X; }
 
 %type db_optr {SCreateDBInfo}
 db_optr(Y) ::= . {setDefaultCreateDbOption(&Y);}
@@ -258,6 +259,7 @@ db_optr(Y) ::= db_optr(Z) comp(X).           { Y = Z; Y.compressionLevel = strto
 db_optr(Y) ::= db_optr(Z) prec(X).           { Y = Z; Y.precision = X; }
 db_optr(Y) ::= db_optr(Z) keep(X).           { Y = Z; Y.keep = X; }
 db_optr(Y) ::= db_optr(Z) update(X).         { Y = Z; Y.update = strtol(X.z, NULL, 10); }
+db_optr(Y) ::= db_optr(Z) cachelast(X).      { Y = Z; Y.cachelast = strtol(X.z, NULL, 10); }
 
 %type alter_db_optr {SCreateDBInfo}
 alter_db_optr(Y) ::= . { setDefaultCreateDbOption(&Y);}
@@ -270,21 +272,22 @@ alter_db_optr(Y) ::= alter_db_optr(Z) comp(X).        { Y = Z; Y.compressionLeve
 alter_db_optr(Y) ::= alter_db_optr(Z) wal(X).         { Y = Z; Y.walLevel = strtol(X.z, NULL, 10); }
 alter_db_optr(Y) ::= alter_db_optr(Z) fsync(X).       { Y = Z; Y.fsyncPeriod = strtol(X.z, NULL, 10); }
 alter_db_optr(Y) ::= alter_db_optr(Z) update(X).      { Y = Z; Y.update = strtol(X.z, NULL, 10); }
+alter_db_optr(Y) ::= alter_db_optr(Z) cachelast(X).   { Y = Z; Y.cachelast = strtol(X.z, NULL, 10); }
 
 %type typename {TAOS_FIELD}
 typename(A) ::= ids(X). { 
   X.type = 0;
-  tSQLSetColumnType (&A, &X); 
+  tSqlSetColumnType (&A, &X);
 }
 
 //define binary type, e.g., binary(10), nchar(10)
 typename(A) ::= ids(X) LP signed(Y) RP.    {
   if (Y <= 0) {
     X.type = 0;
-    tSQLSetColumnType(&A, &X);
+    tSqlSetColumnType(&A, &X);
   } else {
     X.type = -Y;  // negative value of name length
-    tSQLSetColumnType(&A, &X);
+    tSqlSetColumnType(&A, &X);
   }
 }
 
@@ -315,8 +318,8 @@ create_table_list(A) ::= create_table_list(X) create_from_stable(Z). {
 
 %type create_table_args{SCreateTableSQL*}
 create_table_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) LP columnlist(X) RP. {
-  A = tSetCreateSQLElems(X, NULL, NULL, TSQL_CREATE_TABLE);
-  setSQLInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
+  A = tSetCreateSqlElems(X, NULL, NULL, TSQL_CREATE_TABLE);
+  setSqlInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
 
   V.n += Z.n;
   setCreatedTableName(pInfo, &V, &U);
@@ -324,8 +327,8 @@ create_table_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) LP columnlist(X) RP. {
 
 // create super table
 create_table_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) LP columnlist(X) RP TAGS LP columnlist(Y) RP. {
-  A = tSetCreateSQLElems(X, Y, NULL, TSQL_CREATE_STABLE);
-  setSQLInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
+  A = tSetCreateSqlElems(X, Y, NULL, TSQL_CREATE_STABLE);
+  setSqlInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
 
   V.n += Z.n;
   setCreatedTableName(pInfo, &V, &U);
@@ -343,8 +346,8 @@ create_from_stable(A) ::= ifnotexists(U) ids(V) cpxName(Z) USING ids(X) cpxName(
 // 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). {
-  A = tSetCreateSQLElems(NULL, NULL, S, TSQL_CREATE_STREAM);
-  setSQLInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
+  A = tSetCreateSqlElems(NULL, NULL, S, TSQL_CREATE_STREAM);
+  setSqlInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
 
   V.n += Z.n;
   setCreatedTableName(pInfo, &V, &U);
@@ -359,7 +362,7 @@ columnlist(A) ::= column(X).                      {A = taosArrayInit(4, sizeof(T
 // The information used for a column is the name and type of column:
 // tinyint smallint int bigint float double bool timestamp binary(x) nchar(x)
 column(A) ::= ids(X) typename(Y).          {
-  tSQLSetColumnInfo(&A, &X, &Y);
+  tSqlSetColumnInfo(&A, &X, &Y);
 }
 
 %type tagitemlist {SArray*}
@@ -407,7 +410,7 @@ tagitem(A) ::= PLUS(X) FLOAT(Y).  {
 %type select {SQuerySQL*}
 %destructor select {doDestroyQuerySql($$);}
 select(A) ::= SELECT(T) selcollist(W) from(X) where_opt(Y) interval_opt(K) fill_opt(F) sliding_opt(S) groupby_opt(P) orderby_opt(Z) having_opt(N) slimit_opt(G) limit_opt(L). {
-  A = tSetQuerySQLElems(&T, W, X, Y, P, Z, &K, &S, F, &L, &G);
+  A = tSetQuerySqlElems(&T, W, X, Y, P, Z, &K, &S, F, &L, &G);
 }
 
 %type union {SSubclauseInfo*}
@@ -418,33 +421,33 @@ union(Y) ::= LP union(X) RP. { Y = X; }
 union(Y) ::= union(Z) UNION ALL select(X). { Y = appendSelectClause(Z, X); }
 union(Y) ::= union(Z) UNION ALL LP select(X) RP. { Y = appendSelectClause(Z, X); }
 
-cmd ::= union(X). { setSQLInfo(pInfo, X, NULL, TSDB_SQL_SELECT); }
+cmd ::= union(X). { setSqlInfo(pInfo, X, NULL, TSDB_SQL_SELECT); }
 
 // Support for the SQL exprssion without from & where subclauses, e.g.,
 // select current_database(),
 // select server_version(), select client_version(),
 // select server_state();
 select(A) ::= SELECT(T) selcollist(W). {
-  A = tSetQuerySQLElems(&T, W, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+  A = tSetQuerySqlElems(&T, W, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 // selcollist is a list of expressions that are to become the return
 // values of the SELECT statement.  The "*" in statements like
 // "SELECT * FROM ..." is encoded as a special expression with an opcode of TK_ALL.
 %type selcollist {tSQLExprList*}
-%destructor selcollist {tSQLExprListDestroy($$);}
+%destructor selcollist {tSqlExprListDestroy($$);}
 
 %type sclp {tSQLExprList*}
-%destructor sclp {tSQLExprListDestroy($$);}
+%destructor sclp {tSqlExprListDestroy($$);}
 sclp(A) ::= selcollist(X) COMMA.             {A = X;}
 sclp(A) ::= .                                {A = 0;}
 selcollist(A) ::= sclp(P) expr(X) as(Y).     {
-   A = tSQLExprListAppend(P, X, Y.n?&Y:0);
+   A = tSqlExprListAppend(P, X, Y.n?&Y:0);
 }
 
 selcollist(A) ::= sclp(P) STAR. {
-   tSQLExpr *pNode = tSQLExprIdValueCreate(NULL, TK_ALL);
-   A = tSQLExprListAppend(P, pNode, 0);
+   tSQLExpr *pNode = tSqlExprIdValueCreate(NULL, TK_ALL);
+   A = tSqlExprListAppend(P, pNode, 0);
 }
 
 // An option "AS <id>" phrase that can follow one of the expressions that
@@ -573,7 +576,7 @@ grouplist(A) ::= item(X).                       {
 
 //having clause, ignore the input condition in having
 %type having_opt {tSQLExpr*}
-%destructor having_opt {tSQLExprDestroy($$);}
+%destructor having_opt {tSqlExprDestroy($$);}
 having_opt(A) ::=.                  {A = 0;}
 having_opt(A) ::= HAVING expr(X).   {A = X;}
 
@@ -595,7 +598,7 @@ slimit_opt(A) ::= SLIMIT signed(X) COMMA  signed(Y).
                                        {A.limit = Y;  A.offset = X;}
 
 %type where_opt {tSQLExpr*}
-%destructor where_opt {tSQLExprDestroy($$);}
+%destructor where_opt {tSqlExprDestroy($$);}
 
 where_opt(A) ::= .                    {A = 0;}
 where_opt(A) ::= WHERE expr(X).       {A = X;}
@@ -603,67 +606,67 @@ where_opt(A) ::= WHERE expr(X).       {A = X;}
 /////////////////////////// Expression Processing /////////////////////////////
 //
 %type expr {tSQLExpr*}
-%destructor expr {tSQLExprDestroy($$);}
+%destructor expr {tSqlExprDestroy($$);}
 
 expr(A) ::= LP(X) expr(Y) RP(Z).       {A = Y; A->token.z = X.z; A->token.n = (Z.z - X.z + 1);}
 
-expr(A) ::= ID(X).               { A = tSQLExprIdValueCreate(&X, TK_ID);}
-expr(A) ::= ID(X) DOT ID(Y).     { X.n += (1+Y.n); A = tSQLExprIdValueCreate(&X, TK_ID);}
-expr(A) ::= ID(X) DOT STAR(Y).   { X.n += (1+Y.n); A = tSQLExprIdValueCreate(&X, TK_ALL);}
-
-expr(A) ::= INTEGER(X).          { A = tSQLExprIdValueCreate(&X, TK_INTEGER);}
-expr(A) ::= MINUS(X) INTEGER(Y). { X.n += Y.n; X.type = TK_INTEGER; A = tSQLExprIdValueCreate(&X, TK_INTEGER);}
-expr(A) ::= PLUS(X)  INTEGER(Y). { X.n += Y.n; X.type = TK_INTEGER; A = tSQLExprIdValueCreate(&X, TK_INTEGER);}
-expr(A) ::= FLOAT(X).            { A = tSQLExprIdValueCreate(&X, TK_FLOAT);}
-expr(A) ::= MINUS(X) FLOAT(Y).   { X.n += Y.n; X.type = TK_FLOAT; A = tSQLExprIdValueCreate(&X, TK_FLOAT);}
-expr(A) ::= PLUS(X) FLOAT(Y).    { X.n += Y.n; X.type = TK_FLOAT; A = tSQLExprIdValueCreate(&X, TK_FLOAT);}
-expr(A) ::= STRING(X).           { A = tSQLExprIdValueCreate(&X, TK_STRING);}
-expr(A) ::= NOW(X).              { A = tSQLExprIdValueCreate(&X, TK_NOW); }
-expr(A) ::= VARIABLE(X).         { A = tSQLExprIdValueCreate(&X, TK_VARIABLE);}
-expr(A) ::= BOOL(X).             { A = tSQLExprIdValueCreate(&X, TK_BOOL);}
+expr(A) ::= ID(X).               { A = tSqlExprIdValueCreate(&X, TK_ID);}
+expr(A) ::= ID(X) DOT ID(Y).     { X.n += (1+Y.n); A = tSqlExprIdValueCreate(&X, TK_ID);}
+expr(A) ::= ID(X) DOT STAR(Y).   { X.n += (1+Y.n); A = tSqlExprIdValueCreate(&X, TK_ALL);}
+
+expr(A) ::= INTEGER(X).          { A = tSqlExprIdValueCreate(&X, TK_INTEGER);}
+expr(A) ::= MINUS(X) INTEGER(Y). { X.n += Y.n; X.type = TK_INTEGER; A = tSqlExprIdValueCreate(&X, TK_INTEGER);}
+expr(A) ::= PLUS(X)  INTEGER(Y). { X.n += Y.n; X.type = TK_INTEGER; A = tSqlExprIdValueCreate(&X, TK_INTEGER);}
+expr(A) ::= FLOAT(X).            { A = tSqlExprIdValueCreate(&X, TK_FLOAT);}
+expr(A) ::= MINUS(X) FLOAT(Y).   { X.n += Y.n; X.type = TK_FLOAT; A = tSqlExprIdValueCreate(&X, TK_FLOAT);}
+expr(A) ::= PLUS(X) FLOAT(Y).    { X.n += Y.n; X.type = TK_FLOAT; A = tSqlExprIdValueCreate(&X, TK_FLOAT);}
+expr(A) ::= STRING(X).           { A = tSqlExprIdValueCreate(&X, TK_STRING);}
+expr(A) ::= NOW(X).              { A = tSqlExprIdValueCreate(&X, TK_NOW); }
+expr(A) ::= VARIABLE(X).         { A = tSqlExprIdValueCreate(&X, TK_VARIABLE);}
+expr(A) ::= BOOL(X).             { A = tSqlExprIdValueCreate(&X, TK_BOOL);}
 
 // ordinary functions: min(x), max(x), top(k, 20)
-expr(A) ::= ID(X) LP exprlist(Y) RP(E). { A = tSQLExprCreateFunction(Y, &X, &E, X.type); }
+expr(A) ::= ID(X) LP exprlist(Y) RP(E). { A = tSqlExprCreateFunction(Y, &X, &E, X.type); }
 
 // for parsing sql functions with wildcard for parameters. e.g., count(*)/first(*)/last(*) operation
-expr(A) ::= ID(X) LP STAR RP(Y).     { A = tSQLExprCreateFunction(NULL, &X, &Y, X.type); }
+expr(A) ::= ID(X) LP STAR RP(Y).     { A = tSqlExprCreateFunction(NULL, &X, &Y, X.type); }
 
 // is (not) null expression
-expr(A) ::= expr(X) IS NULL.           {A = tSQLExprCreate(X, NULL, TK_ISNULL);}
-expr(A) ::= expr(X) IS NOT NULL.       {A = tSQLExprCreate(X, NULL, TK_NOTNULL);}
+expr(A) ::= expr(X) IS NULL.           {A = tSqlExprCreate(X, NULL, TK_ISNULL);}
+expr(A) ::= expr(X) IS NOT NULL.       {A = tSqlExprCreate(X, NULL, TK_NOTNULL);}
 
 // relational expression
-expr(A) ::= expr(X) LT expr(Y).      {A = tSQLExprCreate(X, Y, TK_LT);}
-expr(A) ::= expr(X) GT expr(Y).      {A = tSQLExprCreate(X, Y, TK_GT);}
-expr(A) ::= expr(X) LE expr(Y).      {A = tSQLExprCreate(X, Y, TK_LE);}
-expr(A) ::= expr(X) GE expr(Y).      {A = tSQLExprCreate(X, Y, TK_GE);}
-expr(A) ::= expr(X) NE expr(Y).      {A = tSQLExprCreate(X, Y, TK_NE);}
-expr(A) ::= expr(X) EQ expr(Y).      {A = tSQLExprCreate(X, Y, TK_EQ);}
+expr(A) ::= expr(X) LT expr(Y).      {A = tSqlExprCreate(X, Y, TK_LT);}
+expr(A) ::= expr(X) GT expr(Y).      {A = tSqlExprCreate(X, Y, TK_GT);}
+expr(A) ::= expr(X) LE expr(Y).      {A = tSqlExprCreate(X, Y, TK_LE);}
+expr(A) ::= expr(X) GE expr(Y).      {A = tSqlExprCreate(X, Y, TK_GE);}
+expr(A) ::= expr(X) NE expr(Y).      {A = tSqlExprCreate(X, Y, TK_NE);}
+expr(A) ::= expr(X) EQ expr(Y).      {A = tSqlExprCreate(X, Y, TK_EQ);}
 
-expr(A) ::= expr(X) AND expr(Y).     {A = tSQLExprCreate(X, Y, TK_AND);}
-expr(A) ::= expr(X) OR  expr(Y).     {A = tSQLExprCreate(X, Y, TK_OR); }
+expr(A) ::= expr(X) AND expr(Y).     {A = tSqlExprCreate(X, Y, TK_AND);}
+expr(A) ::= expr(X) OR  expr(Y).     {A = tSqlExprCreate(X, Y, TK_OR); }
 
 // binary arithmetic expression
-expr(A) ::= expr(X) PLUS  expr(Y).   {A = tSQLExprCreate(X, Y, TK_PLUS);  }
-expr(A) ::= expr(X) MINUS expr(Y).   {A = tSQLExprCreate(X, Y, TK_MINUS); }
-expr(A) ::= expr(X) STAR  expr(Y).   {A = tSQLExprCreate(X, Y, TK_STAR);  }
-expr(A) ::= expr(X) SLASH expr(Y).   {A = tSQLExprCreate(X, Y, TK_DIVIDE);}
-expr(A) ::= expr(X) REM   expr(Y).   {A = tSQLExprCreate(X, Y, TK_REM);   }
+expr(A) ::= expr(X) PLUS  expr(Y).   {A = tSqlExprCreate(X, Y, TK_PLUS);  }
+expr(A) ::= expr(X) MINUS expr(Y).   {A = tSqlExprCreate(X, Y, TK_MINUS); }
+expr(A) ::= expr(X) STAR  expr(Y).   {A = tSqlExprCreate(X, Y, TK_STAR);  }
+expr(A) ::= expr(X) SLASH expr(Y).   {A = tSqlExprCreate(X, Y, TK_DIVIDE);}
+expr(A) ::= expr(X) REM   expr(Y).   {A = tSqlExprCreate(X, Y, TK_REM);   }
 
 // like expression
-expr(A) ::= expr(X) LIKE expr(Y).    {A = tSQLExprCreate(X, Y, TK_LIKE);  }
+expr(A) ::= expr(X) LIKE expr(Y).    {A = tSqlExprCreate(X, Y, TK_LIKE);  }
 
 //in expression
-expr(A) ::= expr(X) IN LP exprlist(Y) RP.   {A = tSQLExprCreate(X, (tSQLExpr*)Y, TK_IN); }
+expr(A) ::= expr(X) IN LP exprlist(Y) RP.   {A = tSqlExprCreate(X, (tSQLExpr*)Y, TK_IN); }
 
 %type exprlist {tSQLExprList*}
-%destructor exprlist {tSQLExprListDestroy($$);}
+%destructor exprlist {tSqlExprListDestroy($$);}
 
 %type expritem {tSQLExpr*}
-%destructor expritem {tSQLExprDestroy($$);}
+%destructor expritem {tSqlExprDestroy($$);}
 
-exprlist(A) ::= exprlist(X) COMMA expritem(Y). {A = tSQLExprListAppend(X,Y,0);}
-exprlist(A) ::= expritem(X).                   {A = tSQLExprListAppend(0,X,0);}
+exprlist(A) ::= exprlist(X) COMMA expritem(Y). {A = tSqlExprListAppend(X,Y,0);}
+exprlist(A) ::= expritem(X).                   {A = tSqlExprListAppend(0,X,0);}
 expritem(A) ::= expr(X).                       {A = X;}
 expritem(A) ::= .                              {A = 0;}
 
@@ -673,8 +676,8 @@ cmd ::= RESET QUERY CACHE.  { setDCLSQLElems(pInfo, TSDB_SQL_RESET_CACHE, 0);}
 ///////////////////////////////////ALTER TABLE statement//////////////////////////////////
 cmd ::= ALTER TABLE ids(X) cpxName(F) ADD COLUMN columnlist(A).     {
     X.n += F.n;
-    SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&X, A, NULL, TSDB_ALTER_TABLE_ADD_COLUMN);
-    setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
+    SAlterTableSQL* pAlterTable = tAlterTableSqlElems(&X, A, NULL, TSDB_ALTER_TABLE_ADD_COLUMN);
+    setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
 
 cmd ::= ALTER TABLE ids(X) cpxName(F) DROP COLUMN ids(A).     {
@@ -683,15 +686,15 @@ cmd ::= ALTER TABLE ids(X) cpxName(F) DROP COLUMN ids(A).     {
     toTSDBType(A.type);
     SArray* K = tVariantListAppendToken(NULL, &A, -1);
 
-    SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&X, NULL, K, TSDB_ALTER_TABLE_DROP_COLUMN);
-    setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
+    SAlterTableSQL* pAlterTable = tAlterTableSqlElems(&X, NULL, K, TSDB_ALTER_TABLE_DROP_COLUMN);
+    setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
 
 //////////////////////////////////ALTER TAGS statement/////////////////////////////////////
 cmd ::= ALTER TABLE ids(X) cpxName(Y) ADD TAG columnlist(A).        {
     X.n += Y.n;
-    SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&X, A, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN);
-    setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
+    SAlterTableSQL* pAlterTable = tAlterTableSqlElems(&X, A, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN);
+    setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
 cmd ::= ALTER TABLE ids(X) cpxName(Z) DROP TAG ids(Y).          {
     X.n += Z.n;
@@ -699,8 +702,8 @@ cmd ::= ALTER TABLE ids(X) cpxName(Z) DROP TAG ids(Y).          {
     toTSDBType(Y.type);
     SArray* A = tVariantListAppendToken(NULL, &Y, -1);
 
-    SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&X, NULL, A, TSDB_ALTER_TABLE_DROP_TAG_COLUMN);
-    setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
+    SAlterTableSQL* pAlterTable = tAlterTableSqlElems(&X, NULL, A, TSDB_ALTER_TABLE_DROP_TAG_COLUMN);
+    setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
 
 cmd ::= ALTER TABLE ids(X) cpxName(F) CHANGE TAG ids(Y) ids(Z). {
@@ -712,8 +715,8 @@ cmd ::= ALTER TABLE ids(X) cpxName(F) CHANGE TAG ids(Y) ids(Z). {
     toTSDBType(Z.type);
     A = tVariantListAppendToken(A, &Z, -1);
 
-    SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&X, NULL, A, TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN);
-    setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
+    SAlterTableSQL* pAlterTable = tAlterTableSqlElems(&X, NULL, A, TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN);
+    setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
 
 cmd ::= ALTER TABLE ids(X) cpxName(F) SET TAG ids(Y) EQ tagitem(Z).     {
@@ -723,14 +726,14 @@ cmd ::= ALTER TABLE ids(X) cpxName(F) SET TAG ids(Y) EQ tagitem(Z).     {
     SArray* A = tVariantListAppendToken(NULL, &Y, -1);
     A = tVariantListAppend(A, &Z, -1);
 
-    SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&X, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL);
-    setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
+    SAlterTableSQL* pAlterTable = tAlterTableSqlElems(&X, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL);
+    setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
 
 ////////////////////////////////////////kill statement///////////////////////////////////////
-cmd ::= KILL CONNECTION INTEGER(Y).   {setKillSQL(pInfo, TSDB_SQL_KILL_CONNECTION, &Y);}
-cmd ::= KILL STREAM INTEGER(X) COLON(Z) INTEGER(Y).       {X.n += (Z.n + Y.n); setKillSQL(pInfo, TSDB_SQL_KILL_STREAM, &X);}
-cmd ::= KILL QUERY INTEGER(X) COLON(Z) INTEGER(Y).        {X.n += (Z.n + Y.n); setKillSQL(pInfo, TSDB_SQL_KILL_QUERY, &X);}
+cmd ::= KILL CONNECTION INTEGER(Y).   {setKillSql(pInfo, TSDB_SQL_KILL_CONNECTION, &Y);}
+cmd ::= KILL STREAM INTEGER(X) COLON(Z) INTEGER(Y).       {X.n += (Z.n + Y.n); setKillSql(pInfo, TSDB_SQL_KILL_STREAM, &X);}
+cmd ::= KILL QUERY INTEGER(X) COLON(Z) INTEGER(Y).        {X.n += (Z.n + Y.n); setKillSql(pInfo, TSDB_SQL_KILL_QUERY, &X);}
 
 %fallback ID ABORT AFTER ASC ATTACH BEFORE BEGIN CASCADE CLUSTER CONFLICT COPY DATABASE DEFERRED
   DELIMITERS DESC DETACH EACH END EXPLAIN FAIL FOR GLOB IGNORE IMMEDIATE INITIALLY INSTEAD

src/query/src/qExecutor.c

@@ -4662,7 +4662,6 @@ static int32_t setupQueryHandle(void* tsdb, SQInfo* pQInfo, bool isSTableQuery)
 
     // update the query time window
     pQuery->window = cond.twindow;
-
     if (pQInfo->tableGroupInfo.numOfTables == 0) {
       pQInfo->tableqinfoGroupInfo.numOfTables = 0;
     } else {

src/query/src/qParserImpl.c

@@ -846,5 +846,6 @@ void setDefaultCreateDbOption(SCreateDBInfo *pDBInfo) {
   pDBInfo->keep = NULL;
 
   pDBInfo->update = -1;
+  pDBInfo->cachelast = 0;
   memset(&pDBInfo->precision, 0, sizeof(SStrToken));
 }

src/query/src/qTokenizer.c

@@ -238,6 +238,7 @@ static SKeyword keywordTable[] = {
     {"SUM_IRATE",    TK_SUM_IRATE},
     {"AVG_RATE",     TK_AVG_RATE},
     {"AVG_IRATE",    TK_AVG_IRATE},
+    {"CACHELAST",    TK_CACHELAST},
 };
 
 static const char isIdChar[] = {

src/query/src/sql.c

@@ -97,27 +97,27 @@
 #endif
 /************* Begin control #defines *****************************************/
 #define YYCODETYPE unsigned short int
-#define YYNOCODE 276
+#define YYNOCODE 278
 #define YYACTIONTYPE unsigned short int
 #define ParseTOKENTYPE SStrToken
 typedef union {
   int yyinit;
   ParseTOKENTYPE yy0;
-  int yy42;
-  SQuerySQL* yy84;
-  SCreatedTableInfo yy96;
-  SArray* yy131;
-  SCreateDBInfo yy148;
-  TAOS_FIELD yy163;
-  SLimitVal yy284;
-  SCreateAcctSQL yy309;
-  tSQLExpr* yy420;
-  int64_t yy459;
-  tSQLExprList* yy478;
-  SSubclauseInfo* yy513;
-  tVariant yy516;
-  SIntervalVal yy530;
-  SCreateTableSQL* yy538;
+  SQuerySQL* yy4;
+  SSubclauseInfo* yy13;
+  int yy70;
+  SCreatedTableInfo yy84;
+  SIntervalVal yy222;
+  TAOS_FIELD yy363;
+  tSQLExprList* yy382;
+  int64_t yy387;
+  SArray* yy403;
+  SLimitVal yy404;
+  SCreateTableSQL* yy436;
+  SCreateAcctSQL yy463;
+  SCreateDBInfo yy478;
+  tVariant yy488;
+  tSQLExpr* yy522;
 } YYMINORTYPE;
 #ifndef YYSTACKDEPTH
 #define YYSTACKDEPTH 100
@@ -127,17 +127,17 @@ typedef union {
 #define ParseARG_FETCH SSqlInfo* pInfo = yypParser->pInfo
 #define ParseARG_STORE yypParser->pInfo = pInfo
 #define YYFALLBACK 1
-#define YYNSTATE             257
-#define YYNRULE              236
-#define YYNTOKEN             207
-#define YY_MAX_SHIFT         256
-#define YY_MIN_SHIFTREDUCE   426
-#define YY_MAX_SHIFTREDUCE   661
-#define YY_ERROR_ACTION      662
-#define YY_ACCEPT_ACTION     663
-#define YY_NO_ACTION         664
-#define YY_MIN_REDUCE        665
-#define YY_MAX_REDUCE        900
+#define YYNSTATE             258
+#define YYNRULE              239
+#define YYNTOKEN             208
+#define YY_MAX_SHIFT         257
+#define YY_MIN_SHIFTREDUCE   430
+#define YY_MAX_SHIFTREDUCE   668
+#define YY_ERROR_ACTION      669
+#define YY_ACCEPT_ACTION     670
+#define YY_NO_ACTION         671
+#define YY_MIN_REDUCE        672
+#define YY_MAX_REDUCE        910
 /************* End control #defines *******************************************/
 
 /* Define the yytestcase() macro to be a no-op if is not already defined
@@ -203,226 +203,228 @@ typedef union {
 **  yy_default[]       Default action for each state.
 **
 *********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (579)
+#define YY_ACTTAB_COUNT (585)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */   143,  469,  663,  256,  469,  162,  254,   12,  814,  470,
- /*    10 */   887,  142,  470,   37,   38,  147,   39,   40,  803,  233,
- /*    20 */   173,   31,  884,  469,  209,   43,   41,   45,   42,   64,
- /*    30 */   883,  470,  163,   36,   35,  105,  143,   34,   33,   32,
- /*    40 */    37,   38,  803,   39,   40,  168,  888,  173,   31,  110,
- /*    50 */   790,  209,   43,   41,   45,   42,  194,  780,   22,  782,
- /*    60 */    36,   35,  811,  882,   34,   33,   32,  427,  428,  429,
- /*    70 */   430,  431,  432,  433,  434,  435,  436,  437,  438,  255,
- /*    80 */    37,   38,  184,   39,   40,  538,  224,  173,   31,  143,
- /*    90 */   197,  209,   43,   41,   45,   42,  165,   23,  167,  888,
- /*   100 */    36,   35,  242,   57,   34,   33,   32,  179,  841,   38,
- /*   110 */   204,   39,   40,  231,  230,  173,   31,   49,  792,  209,
- /*   120 */    43,   41,   45,   42,  253,  252,   98,  615,   36,   35,
- /*   130 */   178,  781,   34,   33,   32,  788,   50,   17,  222,  249,
- /*   140 */   248,  221,  220,  219,  247,  218,  246,  245,  244,  217,
- /*   150 */   243,  764,  792,  752,  753,  754,  755,  756,  757,  758,
- /*   160 */   759,  760,  761,  762,  763,  765,   39,   40,  110,  180,
- /*   170 */   173,   31,  228,  227,  209,   43,   41,   45,   42,   34,
- /*   180 */    33,   32,    9,   36,   35,   65,  120,   34,   33,   32,
- /*   190 */   172,  628,   18,   13,  619,  110,  622,  210,  625,   28,
- /*   200 */   172,  628,  110,  159,  619,  187,  622,  224,  625,  155,
- /*   210 */   172,  628,  191,  190,  619,  156,  622,   66,  625,   92,
- /*   220 */    91,  150,  169,  170,   36,   35,  208,  840,   34,   33,
- /*   230 */    32,  160,  169,  170,  617,  250,  573,   43,   41,   45,
- /*   240 */    42,  706,  169,  170,  133,   36,   35,  783,   18,   34,
- /*   250 */    33,   32,  206,  104,   61,   28,   17,  792,  249,  248,
- /*   260 */    28,   62,  145,  247,   23,  246,  245,  244,  146,  243,
- /*   270 */   618,  715,   78,   82,  133,  193,  565,   23,   87,   90,
- /*   280 */    81,  769,  158,  196,  767,  768,   84,  631,   44,  770,
- /*   290 */    23,  772,  773,  771,  148,  774,   80,  149,   44,  627,
- /*   300 */   176,  242,  789,  707,    3,  124,  133,   23,   44,  627,
- /*   310 */    72,   68,   71,  177,  626,  789,  596,  597,  570,  627,
- /*   320 */   805,   63,  557,   19,  626,  554,  229,  555,  789,  556,
- /*   330 */   171,  137,  135,   29,  626,  153,  583,   95,   94,   93,
- /*   340 */   107,  154,  587,  234,  588,  789,   48,  647,   15,   52,
- /*   350 */   152,   14,  629,  181,  182,  141,   14,  621,  620,  624,
- /*   360 */   623,  546,   89,   88,  212,   24,   53,  547,   24,  151,
- /*   370 */     4,   48,  561,  144,  562,   77,   76,   11,   10,  897,
- /*   380 */   559,  851,  560,  103,  101,  791,  850,  174,  847,  846,
- /*   390 */   175,  232,  813,  833,  818,  820,  106,  832,  121,  122,
- /*   400 */    28,  123,  102,  119,  717,  216,  139,   26,  225,  714,
- /*   410 */   195,  582,  226,  896,   74,  895,  893,  125,  735,   27,
- /*   420 */   198,   25,  164,  202,  140,  558,  704,   83,  702,   85,
- /*   430 */    86,  700,  699,  183,   54,  134,  697,  696,  695,  694,
- /*   440 */   693,  136,  691,  689,   46,  687,  685,  802,  683,  138,
- /*   450 */    51,   58,   59,  834,  207,  205,  199,  203,  201,   30,
- /*   460 */    79,  235,  236,  237,  238,  239,  240,  241,  251,  161,
- /*   470 */   661,  214,  215,  186,  185,  660,  189,  157,  188,   69,
- /*   480 */   659,  652,  192,   60,  196,  166,  567,  698,   56,  128,
- /*   490 */    96,  692,  736,  126,  130,   97,  127,  129,  131,  132,
- /*   500 */   684,    1,  584,  787,    2,  108,  200,  117,  113,  111,
- /*   510 */   112,  114,  115,  116,  589,  118,  109,    5,    6,   20,
- /*   520 */    21,  630,    8,    7,  632,  211,   16,  213,   67,  510,
- /*   530 */    65,  506,  504,  503,  502,  499,  473,  223,   24,   70,
- /*   540 */    47,   73,  540,  539,  537,   55,  494,  492,  484,  490,
- /*   550 */    75,  486,  488,  482,  480,  511,  509,  508,  507,  505,
- /*   560 */   501,  500,   48,  471,  442,  440,   99,  665,  664,  664,
- /*   570 */   664,  664,  664,  664,  664,  664,  664,  664,  100,
+ /*     0 */   143,  473,  143,   23,  670,  257,  165,  545,  824,  474,
+ /*    10 */   897,  168,  898,   37,   38,   12,   39,   40,  813,   23,
+ /*    20 */   173,   31,  473,  473,  209,   43,   41,   45,   42,  802,
+ /*    30 */   474,  474,  163,   36,   35,  231,  230,   34,   33,   32,
+ /*    40 */    37,   38,  798,   39,   40,  813,  105,  173,   31,  162,
+ /*    50 */   255,  209,   43,   41,   45,   42,  176,  178,  799,  194,
+ /*    60 */    36,   35,  233,  821,   34,   33,   32,  431,  432,  433,
+ /*    70 */   434,  435,  436,  437,  438,  439,  440,  441,  442,  256,
+ /*    80 */   802,  143,  184,   63,  179,   37,   38,  224,   39,   40,
+ /*    90 */   167,  898,  173,   31,  800,   29,  209,   43,   41,   45,
+ /*   100 */    42,  110,  197,  791,   57,   36,   35,  251,  210,   34,
+ /*   110 */    33,   32,  110,   17,  222,  250,  249,  221,  220,  219,
+ /*   120 */   248,  218,  247,  246,  245,  217,  244,  243,  622,  772,
+ /*   130 */   802,  760,  761,  762,  763,  764,  765,  766,  767,  768,
+ /*   140 */   769,  770,  771,  773,  774,  242,   38,  180,   39,   40,
+ /*   150 */   228,  227,  173,   31,  110,   18,  209,   43,   41,   45,
+ /*   160 */    42,  851,   28,  204,  110,   36,   35,   23,  187,   34,
+ /*   170 */    33,   32,  850,   39,   40,  191,  190,  173,   31,  224,
+ /*   180 */   624,  209,   43,   41,   45,   42,   34,   33,   32,    9,
+ /*   190 */    36,   35,   65,  120,   34,   33,   32,  172,  635,  638,
+ /*   200 */    66,  626,  104,  629,  177,  632,  799,  172,  635,   28,
+ /*   210 */    13,  626,  206,  629,   61,  632,  625,  172,  635,  142,
+ /*   220 */   572,  626,   23,  629,   62,  632,  155,  196,  147,  169,
+ /*   230 */   170,  793,  156,  208,  603,  604,   92,   91,  150,  169,
+ /*   240 */   170,  894,  713,  580,   17,  133,  250,  249,  893,  169,
+ /*   250 */   170,  248,   64,  247,  246,  245,  892,  244,  243,  229,
+ /*   260 */   778,  799,   80,  776,  777,  590,   18,  242,  779,  107,
+ /*   270 */   781,  782,  780,   28,  783,  784,   43,   41,   45,   42,
+ /*   280 */   159,  790,   22,  792,   36,   35,  160,  171,   34,   33,
+ /*   290 */    32,  722,  564,  193,  133,  561,   44,  562,   52,  563,
+ /*   300 */   158,  254,  253,   98,   36,   35,   44,  634,   34,   33,
+ /*   310 */    32,   23,  145,    3,  124,   53,   44,  634,  146,   72,
+ /*   320 */    68,   71,  633,  181,  182,  148,  714,  634,    4,  133,
+ /*   330 */    78,   82,  633,  137,  135,  149,   87,   90,   81,   95,
+ /*   340 */    94,   93,  633,  153,   84,  594,  577,  154,  234,   48,
+ /*   350 */   799,   19,   49,  152,  595,  654,  636,  141,   15,   14,
+ /*   360 */    14,  628,  627,  631,  630,  553,  212,  151,  554,   24,
+ /*   370 */    24,   50,   48,   77,   76,   11,   10,  568,  566,  569,
+ /*   380 */   567,   89,   88,  103,  101,  907,  144,  801,  861,  860,
+ /*   390 */   174,  857,  856,  175,  823,  232,  565,  828,  830,  106,
+ /*   400 */   843,  815,  842,  121,  122,   28,  119,  123,  195,  724,
+ /*   410 */   216,  139,   26,  225,  721,  226,  906,   74,  102,  905,
+ /*   420 */   903,  125,  742,   27,   25,  140,  711,   83,  589,  709,
+ /*   430 */    85,   86,  707,  706,  183,  134,  704,  703,  702,  701,
+ /*   440 */   198,  700,  136,  698,  696,  694,  692,  690,  138,  164,
+ /*   450 */    58,   54,   59,  202,   51,  844,   46,  812,  207,  205,
+ /*   460 */   203,  201,  199,   30,   79,  235,  236,  237,  238,  239,
+ /*   470 */   240,  161,  214,  241,  252,  215,  668,  186,  185,  157,
+ /*   480 */    69,  667,  188,  189,  666,  659,  192,  196,  166,  574,
+ /*   490 */   705,  591,   56,   96,  132,  743,  126,  128,  127,  129,
+ /*   500 */   130,  699,  111,  131,    1,   97,  116,  112,  113,  114,
+ /*   510 */   691,  797,   60,  117,  115,  118,    2,   20,  108,  200,
+ /*   520 */     6,  596,  109,    5,    7,  637,   21,    8,  211,   16,
+ /*   530 */   213,  639,   67,   65,  514,  510,  508,  507,  506,  503,
+ /*   540 */   477,  223,   70,   47,   73,   75,   24,  547,  546,  544,
+ /*   550 */    55,  498,  496,  488,  494,  490,  492,  486,  484,  516,
+ /*   560 */   515,  513,  512,  511,  509,  505,  504,   48,  475,  446,
+ /*   570 */   444,  672,  671,  671,  671,  671,  671,  671,  671,  671,
+ /*   580 */   671,  671,  671,   99,  100,
 };
 static const YYCODETYPE yy_lookahead[] = {
- /*     0 */   264,    1,  208,  209,    1,  210,  211,  264,  211,    9,
- /*    10 */   274,  264,    9,   13,   14,  264,   16,   17,  248,  211,
- /*    20 */    20,   21,  264,    1,   24,   25,   26,   27,   28,  216,
- /*    30 */   264,    9,  262,   33,   34,  211,  264,   37,   38,   39,
- /*    40 */    13,   14,  248,   16,   17,  273,  274,   20,   21,  211,
- /*    50 */   242,   24,   25,   26,   27,   28,  262,  244,  245,  246,
- /*    60 */    33,   34,  265,  264,   37,   38,   39,   45,   46,   47,
+ /*     0 */   266,    1,  266,  212,  209,  210,  229,    5,  212,    9,
+ /*    10 */   276,  275,  276,   13,   14,  266,   16,   17,  250,  212,
+ /*    20 */    20,   21,    1,    1,   24,   25,   26,   27,   28,  252,
+ /*    30 */     9,    9,  264,   33,   34,   33,   34,   37,   38,   39,
+ /*    40 */    13,   14,  251,   16,   17,  250,  212,   20,   21,  211,
+ /*    50 */   212,   24,   25,   26,   27,   28,  249,  229,  251,  264,
+ /*    60 */    33,   34,  212,  267,   37,   38,   39,   45,   46,   47,
  /*    70 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
- /*    80 */    13,   14,   60,   16,   17,    5,   76,   20,   21,  264,
- /*    90 */   266,   24,   25,   26,   27,   28,  228,  211,  273,  274,
- /*   100 */    33,   34,   78,  103,   37,   38,   39,   66,  270,   14,
- /*   110 */   272,   16,   17,   33,   34,   20,   21,  104,  250,   24,
- /*   120 */    25,   26,   27,   28,   63,   64,   65,  100,   33,   34,
- /*   130 */   228,    0,   37,   38,   39,  249,  123,   85,   86,   87,
- /*   140 */    88,   89,   90,   91,   92,   93,   94,   95,   96,   97,
- /*   150 */    98,  227,  250,  229,  230,  231,  232,  233,  234,  235,
- /*   160 */   236,  237,  238,  239,  240,  241,   16,   17,  211,  128,
- /*   170 */    20,   21,  131,  132,   24,   25,   26,   27,   28,   37,
- /*   180 */    38,   39,   99,   33,   34,  102,  103,   37,   38,   39,
- /*   190 */     1,    2,   99,   44,    5,  211,    7,   15,    9,  106,
- /*   200 */     1,    2,  211,  264,    5,  127,    7,   76,    9,   60,
- /*   210 */     1,    2,  134,  135,    5,   66,    7,  216,    9,   70,
- /*   220 */    71,   72,   33,   34,   33,   34,   37,  270,   37,   38,
- /*   230 */    39,  264,   33,   34,    1,  228,   37,   25,   26,   27,
- /*   240 */    28,  215,   33,   34,  218,   33,   34,  246,   99,   37,
- /*   250 */    38,   39,  268,   99,  270,  106,   85,  250,   87,   88,
- /*   260 */   106,  270,  264,   92,  211,   94,   95,   96,  264,   98,
- /*   270 */    37,  215,   61,   62,  218,  126,  100,  211,   67,   68,
- /*   280 */    69,  227,  133,  107,  230,  231,   75,  105,   99,  235,
- /*   290 */   211,  237,  238,  239,  264,  241,   73,  264,   99,  110,
- /*   300 */   247,   78,  249,  215,   61,   62,  218,  211,   99,  110,
- /*   310 */    67,   68,   69,  247,  125,  249,  116,  117,  104,  110,
- /*   320 */   248,  251,    2,  109,  125,    5,  247,    7,  249,    9,
- /*   330 */    59,   61,   62,  263,  125,  264,  100,   67,   68,   69,
- /*   340 */   104,  264,  100,  247,  100,  249,  104,  100,  104,  104,
- /*   350 */   264,  104,  100,   33,   34,  264,  104,    5,    5,    7,
- /*   360 */     7,  100,   73,   74,  100,  104,  121,  100,  104,  264,
- /*   370 */    99,  104,    5,  264,    7,  129,  130,  129,  130,  250,
- /*   380 */     5,  243,    7,   61,   62,  250,  243,  243,  243,  243,
- /*   390 */   243,  243,  211,  271,  211,  211,  211,  271,  211,  211,
- /*   400 */   106,  211,   59,  252,  211,  211,  211,  211,  211,  211,
- /*   410 */   248,  110,  211,  211,  211,  211,  211,  211,  211,  211,
- /*   420 */   267,  211,  267,  267,  211,  105,  211,  211,  211,  211,
- /*   430 */   211,  211,  211,  211,  120,  211,  211,  211,  211,  211,
- /*   440 */   211,  211,  211,  211,  119,  211,  211,  261,  211,  211,
- /*   450 */   122,  212,  212,  212,  114,  118,  111,  113,  112,  124,
- /*   460 */    84,   83,   49,   80,   82,   53,   81,   79,   76,  212,
- /*   470 */     5,  212,  212,    5,  136,    5,    5,  212,  136,  216,
- /*   480 */     5,   86,  127,  104,  107,    1,  100,  212,  108,  220,
- /*   490 */   213,  212,  226,  225,  221,  213,  224,  223,  222,  219,
- /*   500 */   212,  217,  100,  248,  214,   99,   99,  254,  258,  260,
- /*   510 */   259,  257,  256,  255,  100,  253,   99,   99,  115,  104,
- /*   520 */   104,  100,   99,  115,  105,  101,   99,  101,   73,    9,
- /*   530 */   102,    5,    5,    5,    5,    5,   77,   15,  104,   73,
- /*   540 */    16,  130,    5,    5,  100,   99,    5,    5,    5,    5,
- /*   550 */   130,    5,    5,    5,    5,    5,    5,    5,    5,    5,
- /*   560 */     5,    5,  104,   77,   59,   58,   21,    0,  275,  275,
- /*   570 */   275,  275,  275,  275,  275,  275,  275,  275,   21,  275,
- /*   580 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
- /*   590 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
- /*   600 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
- /*   610 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
- /*   620 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
- /*   630 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
- /*   640 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
- /*   650 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
- /*   660 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
- /*   670 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
- /*   680 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
- /*   690 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
- /*   700 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
- /*   710 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
- /*   720 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
- /*   730 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
- /*   740 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
- /*   750 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
- /*   760 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
- /*   770 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
- /*   780 */   275,  275,  275,  275,  275,  275,
+ /*    80 */   252,  266,   60,  253,   66,   13,   14,   76,   16,   17,
+ /*    90 */   275,  276,   20,   21,  244,  265,   24,   25,   26,   27,
+ /*   100 */    28,  212,  268,    0,  104,   33,   34,  229,   15,   37,
+ /*   110 */    38,   39,  212,   85,   86,   87,   88,   89,   90,   91,
+ /*   120 */    92,   93,   94,   95,   96,   97,   98,   99,  101,  228,
+ /*   130 */   252,  230,  231,  232,  233,  234,  235,  236,  237,  238,
+ /*   140 */   239,  240,  241,  242,  243,   78,   14,  129,   16,   17,
+ /*   150 */   132,  133,   20,   21,  212,  100,   24,   25,   26,   27,
+ /*   160 */    28,  272,  107,  274,  212,   33,   34,  212,  128,   37,
+ /*   170 */    38,   39,  272,   16,   17,  135,  136,   20,   21,   76,
+ /*   180 */     1,   24,   25,   26,   27,   28,   37,   38,   39,  100,
+ /*   190 */    33,   34,  103,  104,   37,   38,   39,    1,    2,  106,
+ /*   200 */   217,    5,  100,    7,  249,    9,  251,    1,    2,  107,
+ /*   210 */    44,    5,  270,    7,  272,    9,   37,    1,    2,  266,
+ /*   220 */   101,    5,  212,    7,  272,    9,   60,  108,  266,   33,
+ /*   230 */    34,  248,   66,   37,  117,  118,   70,   71,   72,   33,
+ /*   240 */    34,  266,  216,   37,   85,  219,   87,   88,  266,   33,
+ /*   250 */    34,   92,  217,   94,   95,   96,  266,   98,   99,  249,
+ /*   260 */   228,  251,   73,  231,  232,  101,  100,   78,  236,  105,
+ /*   270 */   238,  239,  240,  107,  242,  243,   25,   26,   27,   28,
+ /*   280 */   266,  246,  247,  248,   33,   34,  266,   59,   37,   38,
+ /*   290 */    39,  216,    2,  127,  219,    5,  100,    7,  105,    9,
+ /*   300 */   134,   63,   64,   65,   33,   34,  100,  111,   37,   38,
+ /*   310 */    39,  212,  266,   61,   62,  122,  100,  111,  266,   67,
+ /*   320 */    68,   69,  126,   33,   34,  266,  216,  111,  100,  219,
+ /*   330 */    61,   62,  126,   61,   62,  266,   67,   68,   69,   67,
+ /*   340 */    68,   69,  126,  266,   75,  101,  105,  266,  249,  105,
+ /*   350 */   251,  110,  105,  266,  101,  101,  101,  266,  105,  105,
+ /*   360 */   105,    5,    5,    7,    7,  101,  101,  266,  101,  105,
+ /*   370 */   105,  124,  105,  130,  131,  130,  131,    5,    5,    7,
+ /*   380 */     7,   73,   74,   61,   62,  252,  266,  252,  245,  245,
+ /*   390 */   245,  245,  245,  245,  212,  245,  106,  212,  212,  212,
+ /*   400 */   273,  250,  273,  212,  212,  107,  254,  212,  250,  212,
+ /*   410 */   212,  212,  212,  212,  212,  212,  212,  212,   59,  212,
+ /*   420 */   212,  212,  212,  212,  212,  212,  212,  212,  111,  212,
+ /*   430 */   212,  212,  212,  212,  212,  212,  212,  212,  212,  212,
+ /*   440 */   269,  212,  212,  212,  212,  212,  212,  212,  212,  269,
+ /*   450 */   213,  121,  213,  269,  123,  213,  120,  263,  115,  119,
+ /*   460 */   114,  113,  112,  125,   84,   83,   49,   80,   82,   53,
+ /*   470 */    81,  213,  213,   79,   76,  213,    5,    5,  137,  213,
+ /*   480 */   217,    5,  137,    5,    5,   86,  128,  108,    1,  101,
+ /*   490 */   213,  101,  109,  214,  220,  227,  226,  221,  225,  224,
+ /*   500 */   222,  213,  262,  223,  218,  214,  257,  261,  260,  259,
+ /*   510 */   213,  250,  105,  256,  258,  255,  215,  105,  100,  100,
+ /*   520 */   116,  101,  100,  100,  116,  101,  105,  100,  102,  100,
+ /*   530 */   102,  106,   73,  103,    9,    5,    5,    5,    5,    5,
+ /*   540 */    77,   15,   73,   16,  131,  131,  105,    5,    5,  101,
+ /*   550 */   100,    5,    5,    5,    5,    5,    5,    5,    5,    5,
+ /*   560 */     5,    5,    5,    5,    5,    5,    5,  105,   77,   59,
+ /*   570 */    58,    0,  277,  277,  277,  277,  277,  277,  277,  277,
+ /*   580 */   277,  277,  277,   21,   21,  277,  277,  277,  277,  277,
+ /*   590 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
+ /*   600 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
+ /*   610 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
+ /*   620 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
+ /*   630 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
+ /*   640 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
+ /*   650 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
+ /*   660 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
+ /*   670 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
+ /*   680 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
+ /*   690 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
+ /*   700 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
+ /*   710 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
+ /*   720 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
+ /*   730 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
+ /*   740 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
+ /*   750 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
+ /*   760 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
+ /*   770 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
+ /*   780 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
+ /*   790 */   277,  277,  277,
 };
-#define YY_SHIFT_COUNT    (256)
+#define YY_SHIFT_COUNT    (257)
 #define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (567)
+#define YY_SHIFT_MAX      (571)
 static const unsigned short int yy_shift_ofst[] = {
- /*     0 */   149,   52,  171,   10,  189,  209,    3,    3,    3,    3,
- /*    10 */     3,    3,    0,   22,  209,  320,  320,  320,   93,    3,
- /*    20 */     3,    3,  131,    3,    3,  223,   24,   24,  579,  199,
- /*    30 */   209,  209,  209,  209,  209,  209,  209,  209,  209,  209,
- /*    40 */   209,  209,  209,  209,  209,  209,  209,  320,  320,   80,
- /*    50 */    80,   80,   80,   80,   80,   80,  154,    3,    3,    3,
- /*    60 */     3,  200,  200,  214,    3,    3,    3,    3,    3,    3,
- /*    70 */     3,    3,    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,  294,  343,  343,  301,  301,  301,
- /*   110 */   343,  314,  328,  325,  340,  337,  344,  346,  345,  335,
- /*   120 */   294,  343,  343,  343,   10,  343,  376,  378,  413,  383,
- /*   130 */   382,  412,  385,  388,  343,  392,  343,  392,  343,  579,
- /*   140 */   579,   27,   67,   67,   67,   95,  150,  212,  212,  212,
- /*   150 */   211,  191,  191,  191,  191,  243,  270,   41,   78,  142,
- /*   160 */   142,   83,   61,  176,  236,  242,  244,  247,  252,  352,
- /*   170 */   353,  233,  271,  182,   13,  245,  261,  264,  267,  246,
- /*   180 */   248,  367,  375,  289,  322,  465,  338,  468,  470,  342,
- /*   190 */   471,  475,  395,  355,  377,  386,  380,  379,  402,  406,
- /*   200 */   484,  407,  414,  417,  415,  403,  416,  408,  421,  418,
- /*   210 */   419,  423,  424,  427,  426,  428,  455,  520,  526,  527,
- /*   220 */   528,  529,  530,  459,  522,  466,  524,  411,  420,  434,
- /*   230 */   537,  538,  444,  446,  434,  541,  542,  543,  544,  546,
- /*   240 */   547,  548,  549,  550,  551,  552,  553,  554,  555,  556,
- /*   250 */   458,  486,  545,  557,  505,  507,  567,
+ /*     0 */   166,   28,  159,   11,  196,  216,   21,   21,   21,   21,
+ /*    10 */    21,   21,    0,   22,  216,  290,  290,  290,   55,   21,
+ /*    20 */    21,   21,  103,   21,   21,  189,   67,   67,  585,  206,
+ /*    30 */   216,  216,  216,  216,  216,  216,  216,  216,  216,  216,
+ /*    40 */   216,  216,  216,  216,  216,  216,  216,  290,  290,    2,
+ /*    50 */     2,    2,    2,    2,    2,    2,  102,   21,   21,   21,
+ /*    60 */    21,  117,  117,  241,   21,   21,   21,   21,   21,   21,
+ /*    70 */    21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
+ /*    80 */    21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
+ /*    90 */    21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
+ /*   100 */    21,   21,   21,   21,  298,  359,  359,  317,  317,  317,
+ /*   110 */   359,  330,  331,  336,  343,  340,  346,  348,  350,  338,
+ /*   120 */   298,  359,  359,  359,   11,  359,  380,  382,  417,  387,
+ /*   130 */   386,  416,  389,  394,  359,  398,  359,  398,  359,  585,
+ /*   140 */   585,   27,   72,   72,   72,  132,  157,  251,  251,  251,
+ /*   150 */   269,  271,  271,  271,  271,  252,  272,   18,   40,  149,
+ /*   160 */   149,   89,  238,  119,  164,  244,  253,  254,  255,  356,
+ /*   170 */   357,  179,  228,   93,  247,  193,  264,  265,  267,  243,
+ /*   180 */   245,  372,  373,  308,  322,  471,  341,  472,  476,  345,
+ /*   190 */   478,  479,  399,  358,  379,  388,  383,  407,  390,  418,
+ /*   200 */   487,  419,  420,  422,  412,  404,  421,  408,  424,  423,
+ /*   210 */   425,  427,  426,  429,  428,  430,  459,  525,  530,  531,
+ /*   220 */   532,  533,  534,  463,  526,  469,  527,  413,  414,  441,
+ /*   230 */   542,  543,  448,  450,  441,  546,  547,  548,  549,  550,
+ /*   240 */   551,  552,  553,  554,  555,  556,  557,  558,  559,  560,
+ /*   250 */   561,  462,  491,  562,  563,  510,  512,  571,
 };
 #define YY_REDUCE_COUNT (140)
-#define YY_REDUCE_MIN   (-264)
-#define YY_REDUCE_MAX   (290)
+#define YY_REDUCE_MIN   (-266)
+#define YY_REDUCE_MAX   (301)
 static const short yy_reduce_ofst[] = {
- /*     0 */  -206,  -76,   54, -187, -228, -175, -162,  -16,   53,   66,
- /*    10 */    79,   96, -203, -205, -264, -132,  -98,    7, -230, -176,
- /*    20 */   -43,   -9,    1, -192, -114,   26,   56,   88,   70, -257,
- /*    30 */  -253, -249, -242, -234, -201,  -61,  -33,   -2,    4,   30,
- /*    40 */    33,   71,   77,   86,   91,  105,  109,  129,  135,  138,
- /*    50 */   143,  144,  145,  146,  147,  148,   72,  181,  183,  184,
- /*    60 */   185,  122,  126,  151,  187,  188,  190,  193,  194,  195,
- /*    70 */   196,  197,  198,  201,  202,  203,  204,  205,  206,  207,
- /*    80 */   208,  210,  213,  215,  216,  217,  218,  219,  220,  221,
- /*    90 */   222,  224,  225,  226,  227,  228,  229,  230,  231,  232,
- /*   100 */   234,  235,  237,  238,  162,  239,  240,  153,  155,  156,
- /*   110 */   241,  186,  249,  251,  250,  254,  256,  258,  253,  262,
- /*   120 */   255,  257,  259,  260,  263,  265,  266,  268,  272,  269,
- /*   130 */   274,  273,  276,  280,  275,  277,  279,  282,  288,  284,
- /*   140 */   290,
+ /*     0 */  -205,  -99,   32,   35, -264, -185, -111,  -58, -193,  -45,
+ /*    10 */    10,   99, -204, -162, -266, -223, -172, -122, -232, -166,
+ /*    20 */  -100,  -48,  -17, -150, -209,   26,   75,  110, -170, -251,
+ /*    30 */   -47,  -38,  -25,  -18,  -10,   14,   20,   46,   52,   59,
+ /*    40 */    69,   77,   81,   87,   91,  101,  120,  133,  135,  143,
+ /*    50 */   144,  145,  146,  147,  148,  150,  151,  182,  185,  186,
+ /*    60 */   187,  127,  129,  152,  191,  192,  195,  197,  198,  199,
+ /*    70 */   200,  201,  202,  203,  204,  205,  207,  208,  209,  210,
+ /*    80 */   211,  212,  213,  214,  215,  217,  218,  219,  220,  221,
+ /*    90 */   222,  223,  224,  225,  226,  227,  229,  230,  231,  232,
+ /*   100 */   233,  234,  235,  236,  158,  237,  239,  171,  180,  184,
+ /*   110 */   242,  194,  240,  246,  248,  250,  256,  249,  257,  260,
+ /*   120 */   261,  258,  259,  262,  263,  266,  268,  270,  273,  276,
+ /*   130 */   275,  278,  280,  274,  277,  279,  288,  291,  297,  286,
+ /*   140 */   301,
 };
 static const YYACTIONTYPE yy_default[] = {
- /*     0 */   662,  716,  705,  713,  890,  890,  662,  662,  662,  662,
- /*    10 */   662,  662,  815,  680,  890,  662,  662,  662,  662,  662,
- /*    20 */   662,  662,  713,  662,  662,  718,  718,  718,  810,  662,
- /*    30 */   662,  662,  662,  662,  662,  662,  662,  662,  662,  662,
- /*    40 */   662,  662,  662,  662,  662,  662,  662,  662,  662,  662,
- /*    50 */   662,  662,  662,  662,  662,  662,  662,  662,  817,  819,
- /*    60 */   662,  837,  837,  808,  662,  662,  662,  662,  662,  662,
- /*    70 */   662,  662,  662,  662,  662,  662,  662,  662,  662,  662,
- /*    80 */   662,  662,  662,  703,  662,  701,  662,  662,  662,  662,
- /*    90 */   662,  662,  662,  662,  662,  662,  662,  662,  690,  662,
- /*   100 */   662,  662,  662,  662,  662,  682,  682,  662,  662,  662,
- /*   110 */   682,  844,  848,  842,  830,  838,  829,  825,  824,  852,
- /*   120 */   662,  682,  682,  682,  713,  682,  734,  732,  730,  722,
- /*   130 */   728,  724,  726,  720,  682,  711,  682,  711,  682,  751,
- /*   140 */   766,  662,  853,  889,  843,  879,  878,  885,  877,  876,
- /*   150 */   662,  872,  873,  875,  874,  662,  662,  662,  662,  881,
- /*   160 */   880,  662,  662,  662,  662,  662,  662,  662,  662,  662,
- /*   170 */   662,  662,  855,  662,  849,  845,  662,  662,  662,  662,
- /*   180 */   662,  662,  662,  662,  662,  662,  662,  662,  662,  662,
- /*   190 */   662,  662,  662,  662,  807,  662,  662,  816,  662,  662,
- /*   200 */   662,  662,  662,  662,  839,  662,  831,  662,  662,  662,
- /*   210 */   662,  662,  784,  662,  662,  662,  662,  662,  662,  662,
- /*   220 */   662,  662,  662,  662,  662,  662,  662,  662,  662,  894,
- /*   230 */   662,  662,  662,  775,  892,  662,  662,  662,  662,  662,
- /*   240 */   662,  662,  662,  662,  662,  662,  662,  662,  662,  662,
- /*   250 */   737,  662,  688,  686,  662,  678,  662,
+ /*     0 */   669,  723,  712,  720,  900,  900,  669,  669,  669,  669,
+ /*    10 */   669,  669,  825,  687,  900,  669,  669,  669,  669,  669,
+ /*    20 */   669,  669,  720,  669,  669,  725,  725,  725,  820,  669,
+ /*    30 */   669,  669,  669,  669,  669,  669,  669,  669,  669,  669,
+ /*    40 */   669,  669,  669,  669,  669,  669,  669,  669,  669,  669,
+ /*    50 */   669,  669,  669,  669,  669,  669,  669,  669,  827,  829,
+ /*    60 */   669,  847,  847,  818,  669,  669,  669,  669,  669,  669,
+ /*    70 */   669,  669,  669,  669,  669,  669,  669,  669,  669,  669,
+ /*    80 */   669,  669,  669,  710,  669,  708,  669,  669,  669,  669,
+ /*    90 */   669,  669,  669,  669,  669,  669,  669,  669,  697,  669,
+ /*   100 */   669,  669,  669,  669,  669,  689,  689,  669,  669,  669,
+ /*   110 */   689,  854,  858,  852,  840,  848,  839,  835,  834,  862,
+ /*   120 */   669,  689,  689,  689,  720,  689,  741,  739,  737,  729,
+ /*   130 */   735,  731,  733,  727,  689,  718,  689,  718,  689,  759,
+ /*   140 */   775,  669,  863,  899,  853,  889,  888,  895,  887,  886,
+ /*   150 */   669,  882,  883,  885,  884,  669,  669,  669,  669,  891,
+ /*   160 */   890,  669,  669,  669,  669,  669,  669,  669,  669,  669,
+ /*   170 */   669,  669,  865,  669,  859,  855,  669,  669,  669,  669,
+ /*   180 */   669,  669,  669,  669,  669,  669,  669,  669,  669,  669,
+ /*   190 */   669,  669,  669,  669,  817,  669,  669,  826,  669,  669,
+ /*   200 */   669,  669,  669,  669,  849,  669,  841,  669,  669,  669,
+ /*   210 */   669,  669,  794,  669,  669,  669,  669,  669,  669,  669,
+ /*   220 */   669,  669,  669,  669,  669,  669,  669,  669,  669,  904,
+ /*   230 */   669,  669,  669,  785,  902,  669,  669,  669,  669,  669,
+ /*   240 */   669,  669,  669,  669,  669,  669,  669,  669,  669,  669,
+ /*   250 */   669,  744,  669,  695,  693,  669,  685,  669,
 };
 /********** End of lemon-generated parsing tables *****************************/
 
@@ -541,6 +543,7 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*       COMP => nothing */
     0,  /*  PRECISION => nothing */
     0,  /*     UPDATE => nothing */
+    0,  /*  CACHELAST => nothing */
     0,  /*         LP => nothing */
     0,  /*         RP => nothing */
     0,  /*       TAGS => nothing */
@@ -834,182 +837,184 @@ static const char *const yyTokenName[] = {
   /*   96 */ "COMP",
   /*   97 */ "PRECISION",
   /*   98 */ "UPDATE",
-  /*   99 */ "LP",
-  /*  100 */ "RP",
-  /*  101 */ "TAGS",
-  /*  102 */ "USING",
-  /*  103 */ "AS",
-  /*  104 */ "COMMA",
-  /*  105 */ "NULL",
-  /*  106 */ "SELECT",
-  /*  107 */ "UNION",
-  /*  108 */ "ALL",
-  /*  109 */ "FROM",
-  /*  110 */ "VARIABLE",
-  /*  111 */ "INTERVAL",
-  /*  112 */ "FILL",
-  /*  113 */ "SLIDING",
-  /*  114 */ "ORDER",
-  /*  115 */ "BY",
-  /*  116 */ "ASC",
-  /*  117 */ "DESC",
-  /*  118 */ "GROUP",
-  /*  119 */ "HAVING",
-  /*  120 */ "LIMIT",
-  /*  121 */ "OFFSET",
-  /*  122 */ "SLIMIT",
-  /*  123 */ "SOFFSET",
-  /*  124 */ "WHERE",
-  /*  125 */ "NOW",
-  /*  126 */ "RESET",
-  /*  127 */ "QUERY",
-  /*  128 */ "ADD",
-  /*  129 */ "COLUMN",
-  /*  130 */ "TAG",
-  /*  131 */ "CHANGE",
-  /*  132 */ "SET",
-  /*  133 */ "KILL",
-  /*  134 */ "CONNECTION",
-  /*  135 */ "STREAM",
-  /*  136 */ "COLON",
-  /*  137 */ "ABORT",
-  /*  138 */ "AFTER",
-  /*  139 */ "ATTACH",
-  /*  140 */ "BEFORE",
-  /*  141 */ "BEGIN",
-  /*  142 */ "CASCADE",
-  /*  143 */ "CLUSTER",
-  /*  144 */ "CONFLICT",
-  /*  145 */ "COPY",
-  /*  146 */ "DEFERRED",
-  /*  147 */ "DELIMITERS",
-  /*  148 */ "DETACH",
-  /*  149 */ "EACH",
-  /*  150 */ "END",
-  /*  151 */ "EXPLAIN",
-  /*  152 */ "FAIL",
-  /*  153 */ "FOR",
-  /*  154 */ "IGNORE",
-  /*  155 */ "IMMEDIATE",
-  /*  156 */ "INITIALLY",
-  /*  157 */ "INSTEAD",
-  /*  158 */ "MATCH",
-  /*  159 */ "KEY",
-  /*  160 */ "OF",
-  /*  161 */ "RAISE",
-  /*  162 */ "REPLACE",
-  /*  163 */ "RESTRICT",
-  /*  164 */ "ROW",
-  /*  165 */ "STATEMENT",
-  /*  166 */ "TRIGGER",
-  /*  167 */ "VIEW",
-  /*  168 */ "COUNT",
-  /*  169 */ "SUM",
-  /*  170 */ "AVG",
-  /*  171 */ "MIN",
-  /*  172 */ "MAX",
-  /*  173 */ "FIRST",
-  /*  174 */ "LAST",
-  /*  175 */ "TOP",
-  /*  176 */ "BOTTOM",
-  /*  177 */ "STDDEV",
-  /*  178 */ "PERCENTILE",
-  /*  179 */ "APERCENTILE",
-  /*  180 */ "LEASTSQUARES",
-  /*  181 */ "HISTOGRAM",
-  /*  182 */ "DIFF",
-  /*  183 */ "SPREAD",
-  /*  184 */ "TWA",
-  /*  185 */ "INTERP",
-  /*  186 */ "LAST_ROW",
-  /*  187 */ "RATE",
-  /*  188 */ "IRATE",
-  /*  189 */ "SUM_RATE",
-  /*  190 */ "SUM_IRATE",
-  /*  191 */ "AVG_RATE",
-  /*  192 */ "AVG_IRATE",
-  /*  193 */ "TBID",
-  /*  194 */ "SEMI",
-  /*  195 */ "NONE",
-  /*  196 */ "PREV",
-  /*  197 */ "LINEAR",
-  /*  198 */ "IMPORT",
-  /*  199 */ "METRIC",
-  /*  200 */ "TBNAME",
-  /*  201 */ "JOIN",
-  /*  202 */ "METRICS",
-  /*  203 */ "STABLE",
-  /*  204 */ "INSERT",
-  /*  205 */ "INTO",
-  /*  206 */ "VALUES",
-  /*  207 */ "error",
-  /*  208 */ "program",
-  /*  209 */ "cmd",
-  /*  210 */ "dbPrefix",
-  /*  211 */ "ids",
-  /*  212 */ "cpxName",
-  /*  213 */ "ifexists",
-  /*  214 */ "alter_db_optr",
-  /*  215 */ "acct_optr",
-  /*  216 */ "ifnotexists",
-  /*  217 */ "db_optr",
-  /*  218 */ "pps",
-  /*  219 */ "tseries",
-  /*  220 */ "dbs",
-  /*  221 */ "streams",
-  /*  222 */ "storage",
-  /*  223 */ "qtime",
-  /*  224 */ "users",
-  /*  225 */ "conns",
-  /*  226 */ "state",
-  /*  227 */ "keep",
-  /*  228 */ "tagitemlist",
-  /*  229 */ "cache",
-  /*  230 */ "replica",
-  /*  231 */ "quorum",
-  /*  232 */ "days",
-  /*  233 */ "minrows",
-  /*  234 */ "maxrows",
-  /*  235 */ "blocks",
-  /*  236 */ "ctime",
-  /*  237 */ "wal",
-  /*  238 */ "fsync",
-  /*  239 */ "comp",
-  /*  240 */ "prec",
-  /*  241 */ "update",
-  /*  242 */ "typename",
-  /*  243 */ "signed",
-  /*  244 */ "create_table_args",
-  /*  245 */ "create_table_list",
-  /*  246 */ "create_from_stable",
-  /*  247 */ "columnlist",
-  /*  248 */ "select",
-  /*  249 */ "column",
-  /*  250 */ "tagitem",
-  /*  251 */ "selcollist",
-  /*  252 */ "from",
-  /*  253 */ "where_opt",
-  /*  254 */ "interval_opt",
-  /*  255 */ "fill_opt",
-  /*  256 */ "sliding_opt",
-  /*  257 */ "groupby_opt",
-  /*  258 */ "orderby_opt",
-  /*  259 */ "having_opt",
-  /*  260 */ "slimit_opt",
-  /*  261 */ "limit_opt",
-  /*  262 */ "union",
-  /*  263 */ "sclp",
-  /*  264 */ "expr",
-  /*  265 */ "as",
-  /*  266 */ "tablelist",
-  /*  267 */ "tmvar",
-  /*  268 */ "sortlist",
-  /*  269 */ "sortitem",
-  /*  270 */ "item",
-  /*  271 */ "sortorder",
-  /*  272 */ "grouplist",
-  /*  273 */ "exprlist",
-  /*  274 */ "expritem",
+  /*   99 */ "CACHELAST",
+  /*  100 */ "LP",
+  /*  101 */ "RP",
+  /*  102 */ "TAGS",
+  /*  103 */ "USING",
+  /*  104 */ "AS",
+  /*  105 */ "COMMA",
+  /*  106 */ "NULL",
+  /*  107 */ "SELECT",
+  /*  108 */ "UNION",
+  /*  109 */ "ALL",
+  /*  110 */ "FROM",
+  /*  111 */ "VARIABLE",
+  /*  112 */ "INTERVAL",
+  /*  113 */ "FILL",
+  /*  114 */ "SLIDING",
+  /*  115 */ "ORDER",
+  /*  116 */ "BY",
+  /*  117 */ "ASC",
+  /*  118 */ "DESC",
+  /*  119 */ "GROUP",
+  /*  120 */ "HAVING",
+  /*  121 */ "LIMIT",
+  /*  122 */ "OFFSET",
+  /*  123 */ "SLIMIT",
+  /*  124 */ "SOFFSET",
+  /*  125 */ "WHERE",
+  /*  126 */ "NOW",
+  /*  127 */ "RESET",
+  /*  128 */ "QUERY",
+  /*  129 */ "ADD",
+  /*  130 */ "COLUMN",
+  /*  131 */ "TAG",
+  /*  132 */ "CHANGE",
+  /*  133 */ "SET",
+  /*  134 */ "KILL",
+  /*  135 */ "CONNECTION",
+  /*  136 */ "STREAM",
+  /*  137 */ "COLON",
+  /*  138 */ "ABORT",
+  /*  139 */ "AFTER",
+  /*  140 */ "ATTACH",
+  /*  141 */ "BEFORE",
+  /*  142 */ "BEGIN",
+  /*  143 */ "CASCADE",
+  /*  144 */ "CLUSTER",
+  /*  145 */ "CONFLICT",
+  /*  146 */ "COPY",
+  /*  147 */ "DEFERRED",
+  /*  148 */ "DELIMITERS",
+  /*  149 */ "DETACH",
+  /*  150 */ "EACH",
+  /*  151 */ "END",
+  /*  152 */ "EXPLAIN",
+  /*  153 */ "FAIL",
+  /*  154 */ "FOR",
+  /*  155 */ "IGNORE",
+  /*  156 */ "IMMEDIATE",
+  /*  157 */ "INITIALLY",
+  /*  158 */ "INSTEAD",
+  /*  159 */ "MATCH",
+  /*  160 */ "KEY",
+  /*  161 */ "OF",
+  /*  162 */ "RAISE",
+  /*  163 */ "REPLACE",
+  /*  164 */ "RESTRICT",
+  /*  165 */ "ROW",
+  /*  166 */ "STATEMENT",
+  /*  167 */ "TRIGGER",
+  /*  168 */ "VIEW",
+  /*  169 */ "COUNT",
+  /*  170 */ "SUM",
+  /*  171 */ "AVG",
+  /*  172 */ "MIN",
+  /*  173 */ "MAX",
+  /*  174 */ "FIRST",
+  /*  175 */ "LAST",
+  /*  176 */ "TOP",
+  /*  177 */ "BOTTOM",
+  /*  178 */ "STDDEV",
+  /*  179 */ "PERCENTILE",
+  /*  180 */ "APERCENTILE",
+  /*  181 */ "LEASTSQUARES",
+  /*  182 */ "HISTOGRAM",
+  /*  183 */ "DIFF",
+  /*  184 */ "SPREAD",
+  /*  185 */ "TWA",
+  /*  186 */ "INTERP",
+  /*  187 */ "LAST_ROW",
+  /*  188 */ "RATE",
+  /*  189 */ "IRATE",
+  /*  190 */ "SUM_RATE",
+  /*  191 */ "SUM_IRATE",
+  /*  192 */ "AVG_RATE",
+  /*  193 */ "AVG_IRATE",
+  /*  194 */ "TBID",
+  /*  195 */ "SEMI",
+  /*  196 */ "NONE",
+  /*  197 */ "PREV",
+  /*  198 */ "LINEAR",
+  /*  199 */ "IMPORT",
+  /*  200 */ "METRIC",
+  /*  201 */ "TBNAME",
+  /*  202 */ "JOIN",
+  /*  203 */ "METRICS",
+  /*  204 */ "STABLE",
+  /*  205 */ "INSERT",
+  /*  206 */ "INTO",
+  /*  207 */ "VALUES",
+  /*  208 */ "error",
+  /*  209 */ "program",
+  /*  210 */ "cmd",
+  /*  211 */ "dbPrefix",
+  /*  212 */ "ids",
+  /*  213 */ "cpxName",
+  /*  214 */ "ifexists",
+  /*  215 */ "alter_db_optr",
+  /*  216 */ "acct_optr",
+  /*  217 */ "ifnotexists",
+  /*  218 */ "db_optr",
+  /*  219 */ "pps",
+  /*  220 */ "tseries",
+  /*  221 */ "dbs",
+  /*  222 */ "streams",
+  /*  223 */ "storage",
+  /*  224 */ "qtime",
+  /*  225 */ "users",
+  /*  226 */ "conns",
+  /*  227 */ "state",
+  /*  228 */ "keep",
+  /*  229 */ "tagitemlist",
+  /*  230 */ "cache",
+  /*  231 */ "replica",
+  /*  232 */ "quorum",
+  /*  233 */ "days",
+  /*  234 */ "minrows",
+  /*  235 */ "maxrows",
+  /*  236 */ "blocks",
+  /*  237 */ "ctime",
+  /*  238 */ "wal",
+  /*  239 */ "fsync",
+  /*  240 */ "comp",
+  /*  241 */ "prec",
+  /*  242 */ "update",
+  /*  243 */ "cachelast",
+  /*  244 */ "typename",
+  /*  245 */ "signed",
+  /*  246 */ "create_table_args",
+  /*  247 */ "create_table_list",
+  /*  248 */ "create_from_stable",
+  /*  249 */ "columnlist",
+  /*  250 */ "select",
+  /*  251 */ "column",
+  /*  252 */ "tagitem",
+  /*  253 */ "selcollist",
+  /*  254 */ "from",
+  /*  255 */ "where_opt",
+  /*  256 */ "interval_opt",
+  /*  257 */ "fill_opt",
+  /*  258 */ "sliding_opt",
+  /*  259 */ "groupby_opt",
+  /*  260 */ "orderby_opt",
+  /*  261 */ "having_opt",
+  /*  262 */ "slimit_opt",
+  /*  263 */ "limit_opt",
+  /*  264 */ "union",
+  /*  265 */ "sclp",
+  /*  266 */ "expr",
+  /*  267 */ "as",
+  /*  268 */ "tablelist",
+  /*  269 */ "tmvar",
+  /*  270 */ "sortlist",
+  /*  271 */ "sortitem",
+  /*  272 */ "item",
+  /*  273 */ "sortorder",
+  /*  274 */ "grouplist",
+  /*  275 */ "exprlist",
+  /*  276 */ "expritem",
 };
 #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
 
@@ -1103,156 +1108,159 @@ static const char *const yyRuleName[] = {
  /*  83 */ "comp ::= COMP INTEGER",
  /*  84 */ "prec ::= PRECISION STRING",
  /*  85 */ "update ::= UPDATE INTEGER",
- /*  86 */ "db_optr ::=",
- /*  87 */ "db_optr ::= db_optr cache",
- /*  88 */ "db_optr ::= db_optr replica",
- /*  89 */ "db_optr ::= db_optr quorum",
- /*  90 */ "db_optr ::= db_optr days",
- /*  91 */ "db_optr ::= db_optr minrows",
- /*  92 */ "db_optr ::= db_optr maxrows",
- /*  93 */ "db_optr ::= db_optr blocks",
- /*  94 */ "db_optr ::= db_optr ctime",
- /*  95 */ "db_optr ::= db_optr wal",
- /*  96 */ "db_optr ::= db_optr fsync",
- /*  97 */ "db_optr ::= db_optr comp",
- /*  98 */ "db_optr ::= db_optr prec",
- /*  99 */ "db_optr ::= db_optr keep",
- /* 100 */ "db_optr ::= db_optr update",
- /* 101 */ "alter_db_optr ::=",
- /* 102 */ "alter_db_optr ::= alter_db_optr replica",
- /* 103 */ "alter_db_optr ::= alter_db_optr quorum",
- /* 104 */ "alter_db_optr ::= alter_db_optr keep",
- /* 105 */ "alter_db_optr ::= alter_db_optr blocks",
- /* 106 */ "alter_db_optr ::= alter_db_optr comp",
- /* 107 */ "alter_db_optr ::= alter_db_optr wal",
- /* 108 */ "alter_db_optr ::= alter_db_optr fsync",
- /* 109 */ "alter_db_optr ::= alter_db_optr update",
- /* 110 */ "typename ::= ids",
- /* 111 */ "typename ::= ids LP signed RP",
- /* 112 */ "signed ::= INTEGER",
- /* 113 */ "signed ::= PLUS INTEGER",
- /* 114 */ "signed ::= MINUS INTEGER",
- /* 115 */ "cmd ::= CREATE TABLE create_table_args",
- /* 116 */ "cmd ::= CREATE TABLE create_table_list",
- /* 117 */ "create_table_list ::= create_from_stable",
- /* 118 */ "create_table_list ::= create_table_list create_from_stable",
- /* 119 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP",
- /* 120 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP",
- /* 121 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP",
- /* 122 */ "create_table_args ::= ifnotexists ids cpxName AS select",
- /* 123 */ "columnlist ::= columnlist COMMA column",
- /* 124 */ "columnlist ::= column",
- /* 125 */ "column ::= ids typename",
- /* 126 */ "tagitemlist ::= tagitemlist COMMA tagitem",
- /* 127 */ "tagitemlist ::= tagitem",
- /* 128 */ "tagitem ::= INTEGER",
- /* 129 */ "tagitem ::= FLOAT",
- /* 130 */ "tagitem ::= STRING",
- /* 131 */ "tagitem ::= BOOL",
- /* 132 */ "tagitem ::= NULL",
- /* 133 */ "tagitem ::= MINUS INTEGER",
- /* 134 */ "tagitem ::= MINUS FLOAT",
- /* 135 */ "tagitem ::= PLUS INTEGER",
- /* 136 */ "tagitem ::= PLUS FLOAT",
- /* 137 */ "select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt",
- /* 138 */ "union ::= select",
- /* 139 */ "union ::= LP union RP",
- /* 140 */ "union ::= union UNION ALL select",
- /* 141 */ "union ::= union UNION ALL LP select RP",
- /* 142 */ "cmd ::= union",
- /* 143 */ "select ::= SELECT selcollist",
- /* 144 */ "sclp ::= selcollist COMMA",
- /* 145 */ "sclp ::=",
- /* 146 */ "selcollist ::= sclp expr as",
- /* 147 */ "selcollist ::= sclp STAR",
- /* 148 */ "as ::= AS ids",
- /* 149 */ "as ::= ids",
- /* 150 */ "as ::=",
- /* 151 */ "from ::= FROM tablelist",
- /* 152 */ "tablelist ::= ids cpxName",
- /* 153 */ "tablelist ::= ids cpxName ids",
- /* 154 */ "tablelist ::= tablelist COMMA ids cpxName",
- /* 155 */ "tablelist ::= tablelist COMMA ids cpxName ids",
- /* 156 */ "tmvar ::= VARIABLE",
- /* 157 */ "interval_opt ::= INTERVAL LP tmvar RP",
- /* 158 */ "interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP",
- /* 159 */ "interval_opt ::=",
- /* 160 */ "fill_opt ::=",
- /* 161 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
- /* 162 */ "fill_opt ::= FILL LP ID RP",
- /* 163 */ "sliding_opt ::= SLIDING LP tmvar RP",
- /* 164 */ "sliding_opt ::=",
- /* 165 */ "orderby_opt ::=",
- /* 166 */ "orderby_opt ::= ORDER BY sortlist",
- /* 167 */ "sortlist ::= sortlist COMMA item sortorder",
- /* 168 */ "sortlist ::= item sortorder",
- /* 169 */ "item ::= ids cpxName",
- /* 170 */ "sortorder ::= ASC",
- /* 171 */ "sortorder ::= DESC",
- /* 172 */ "sortorder ::=",
- /* 173 */ "groupby_opt ::=",
- /* 174 */ "groupby_opt ::= GROUP BY grouplist",
- /* 175 */ "grouplist ::= grouplist COMMA item",
- /* 176 */ "grouplist ::= item",
- /* 177 */ "having_opt ::=",
- /* 178 */ "having_opt ::= HAVING expr",
- /* 179 */ "limit_opt ::=",
- /* 180 */ "limit_opt ::= LIMIT signed",
- /* 181 */ "limit_opt ::= LIMIT signed OFFSET signed",
- /* 182 */ "limit_opt ::= LIMIT signed COMMA signed",
- /* 183 */ "slimit_opt ::=",
- /* 184 */ "slimit_opt ::= SLIMIT signed",
- /* 185 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
- /* 186 */ "slimit_opt ::= SLIMIT signed COMMA signed",
- /* 187 */ "where_opt ::=",
- /* 188 */ "where_opt ::= WHERE expr",
- /* 189 */ "expr ::= LP expr RP",
- /* 190 */ "expr ::= ID",
- /* 191 */ "expr ::= ID DOT ID",
- /* 192 */ "expr ::= ID DOT STAR",
- /* 193 */ "expr ::= INTEGER",
- /* 194 */ "expr ::= MINUS INTEGER",
- /* 195 */ "expr ::= PLUS INTEGER",
- /* 196 */ "expr ::= FLOAT",
- /* 197 */ "expr ::= MINUS FLOAT",
- /* 198 */ "expr ::= PLUS FLOAT",
- /* 199 */ "expr ::= STRING",
- /* 200 */ "expr ::= NOW",
- /* 201 */ "expr ::= VARIABLE",
- /* 202 */ "expr ::= BOOL",
- /* 203 */ "expr ::= ID LP exprlist RP",
- /* 204 */ "expr ::= ID LP STAR RP",
- /* 205 */ "expr ::= expr IS NULL",
- /* 206 */ "expr ::= expr IS NOT NULL",
- /* 207 */ "expr ::= expr LT expr",
- /* 208 */ "expr ::= expr GT expr",
- /* 209 */ "expr ::= expr LE expr",
- /* 210 */ "expr ::= expr GE expr",
- /* 211 */ "expr ::= expr NE expr",
- /* 212 */ "expr ::= expr EQ expr",
- /* 213 */ "expr ::= expr AND expr",
- /* 214 */ "expr ::= expr OR expr",
- /* 215 */ "expr ::= expr PLUS expr",
- /* 216 */ "expr ::= expr MINUS expr",
- /* 217 */ "expr ::= expr STAR expr",
- /* 218 */ "expr ::= expr SLASH expr",
- /* 219 */ "expr ::= expr REM expr",
- /* 220 */ "expr ::= expr LIKE expr",
- /* 221 */ "expr ::= expr IN LP exprlist RP",
- /* 222 */ "exprlist ::= exprlist COMMA expritem",
- /* 223 */ "exprlist ::= expritem",
- /* 224 */ "expritem ::= expr",
- /* 225 */ "expritem ::=",
- /* 226 */ "cmd ::= RESET QUERY CACHE",
- /* 227 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
- /* 228 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
- /* 229 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
- /* 230 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
- /* 231 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
- /* 232 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
- /* 233 */ "cmd ::= KILL CONNECTION INTEGER",
- /* 234 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
- /* 235 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
+ /*  86 */ "cachelast ::= CACHELAST INTEGER",
+ /*  87 */ "db_optr ::=",
+ /*  88 */ "db_optr ::= db_optr cache",
+ /*  89 */ "db_optr ::= db_optr replica",
+ /*  90 */ "db_optr ::= db_optr quorum",
+ /*  91 */ "db_optr ::= db_optr days",
+ /*  92 */ "db_optr ::= db_optr minrows",
+ /*  93 */ "db_optr ::= db_optr maxrows",
+ /*  94 */ "db_optr ::= db_optr blocks",
+ /*  95 */ "db_optr ::= db_optr ctime",
+ /*  96 */ "db_optr ::= db_optr wal",
+ /*  97 */ "db_optr ::= db_optr fsync",
+ /*  98 */ "db_optr ::= db_optr comp",
+ /*  99 */ "db_optr ::= db_optr prec",
+ /* 100 */ "db_optr ::= db_optr keep",
+ /* 101 */ "db_optr ::= db_optr update",
+ /* 102 */ "db_optr ::= db_optr cachelast",
+ /* 103 */ "alter_db_optr ::=",
+ /* 104 */ "alter_db_optr ::= alter_db_optr replica",
+ /* 105 */ "alter_db_optr ::= alter_db_optr quorum",
+ /* 106 */ "alter_db_optr ::= alter_db_optr keep",
+ /* 107 */ "alter_db_optr ::= alter_db_optr blocks",
+ /* 108 */ "alter_db_optr ::= alter_db_optr comp",
+ /* 109 */ "alter_db_optr ::= alter_db_optr wal",
+ /* 110 */ "alter_db_optr ::= alter_db_optr fsync",
+ /* 111 */ "alter_db_optr ::= alter_db_optr update",
+ /* 112 */ "alter_db_optr ::= alter_db_optr cachelast",
+ /* 113 */ "typename ::= ids",
+ /* 114 */ "typename ::= ids LP signed RP",
+ /* 115 */ "signed ::= INTEGER",
+ /* 116 */ "signed ::= PLUS INTEGER",
+ /* 117 */ "signed ::= MINUS INTEGER",
+ /* 118 */ "cmd ::= CREATE TABLE create_table_args",
+ /* 119 */ "cmd ::= CREATE TABLE create_table_list",
+ /* 120 */ "create_table_list ::= create_from_stable",
+ /* 121 */ "create_table_list ::= create_table_list create_from_stable",
+ /* 122 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP",
+ /* 123 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP",
+ /* 124 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP",
+ /* 125 */ "create_table_args ::= ifnotexists ids cpxName AS select",
+ /* 126 */ "columnlist ::= columnlist COMMA column",
+ /* 127 */ "columnlist ::= column",
+ /* 128 */ "column ::= ids typename",
+ /* 129 */ "tagitemlist ::= tagitemlist COMMA tagitem",
+ /* 130 */ "tagitemlist ::= tagitem",
+ /* 131 */ "tagitem ::= INTEGER",
+ /* 132 */ "tagitem ::= FLOAT",
+ /* 133 */ "tagitem ::= STRING",
+ /* 134 */ "tagitem ::= BOOL",
+ /* 135 */ "tagitem ::= NULL",
+ /* 136 */ "tagitem ::= MINUS INTEGER",
+ /* 137 */ "tagitem ::= MINUS FLOAT",
+ /* 138 */ "tagitem ::= PLUS INTEGER",
+ /* 139 */ "tagitem ::= PLUS FLOAT",
+ /* 140 */ "select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt",
+ /* 141 */ "union ::= select",
+ /* 142 */ "union ::= LP union RP",
+ /* 143 */ "union ::= union UNION ALL select",
+ /* 144 */ "union ::= union UNION ALL LP select RP",
+ /* 145 */ "cmd ::= union",
+ /* 146 */ "select ::= SELECT selcollist",
+ /* 147 */ "sclp ::= selcollist COMMA",
+ /* 148 */ "sclp ::=",
+ /* 149 */ "selcollist ::= sclp expr as",
+ /* 150 */ "selcollist ::= sclp STAR",
+ /* 151 */ "as ::= AS ids",
+ /* 152 */ "as ::= ids",
+ /* 153 */ "as ::=",
+ /* 154 */ "from ::= FROM tablelist",
+ /* 155 */ "tablelist ::= ids cpxName",
+ /* 156 */ "tablelist ::= ids cpxName ids",
+ /* 157 */ "tablelist ::= tablelist COMMA ids cpxName",
+ /* 158 */ "tablelist ::= tablelist COMMA ids cpxName ids",
+ /* 159 */ "tmvar ::= VARIABLE",
+ /* 160 */ "interval_opt ::= INTERVAL LP tmvar RP",
+ /* 161 */ "interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP",
+ /* 162 */ "interval_opt ::=",
+ /* 163 */ "fill_opt ::=",
+ /* 164 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
+ /* 165 */ "fill_opt ::= FILL LP ID RP",
+ /* 166 */ "sliding_opt ::= SLIDING LP tmvar RP",
+ /* 167 */ "sliding_opt ::=",
+ /* 168 */ "orderby_opt ::=",
+ /* 169 */ "orderby_opt ::= ORDER BY sortlist",
+ /* 170 */ "sortlist ::= sortlist COMMA item sortorder",
+ /* 171 */ "sortlist ::= item sortorder",
+ /* 172 */ "item ::= ids cpxName",
+ /* 173 */ "sortorder ::= ASC",
+ /* 174 */ "sortorder ::= DESC",
+ /* 175 */ "sortorder ::=",
+ /* 176 */ "groupby_opt ::=",
+ /* 177 */ "groupby_opt ::= GROUP BY grouplist",
+ /* 178 */ "grouplist ::= grouplist COMMA item",
+ /* 179 */ "grouplist ::= item",
+ /* 180 */ "having_opt ::=",
+ /* 181 */ "having_opt ::= HAVING expr",
+ /* 182 */ "limit_opt ::=",
+ /* 183 */ "limit_opt ::= LIMIT signed",
+ /* 184 */ "limit_opt ::= LIMIT signed OFFSET signed",
+ /* 185 */ "limit_opt ::= LIMIT signed COMMA signed",
+ /* 186 */ "slimit_opt ::=",
+ /* 187 */ "slimit_opt ::= SLIMIT signed",
+ /* 188 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
+ /* 189 */ "slimit_opt ::= SLIMIT signed COMMA signed",
+ /* 190 */ "where_opt ::=",
+ /* 191 */ "where_opt ::= WHERE expr",
+ /* 192 */ "expr ::= LP expr RP",
+ /* 193 */ "expr ::= ID",
+ /* 194 */ "expr ::= ID DOT ID",
+ /* 195 */ "expr ::= ID DOT STAR",
+ /* 196 */ "expr ::= INTEGER",
+ /* 197 */ "expr ::= MINUS INTEGER",
+ /* 198 */ "expr ::= PLUS INTEGER",
+ /* 199 */ "expr ::= FLOAT",
+ /* 200 */ "expr ::= MINUS FLOAT",
+ /* 201 */ "expr ::= PLUS FLOAT",
+ /* 202 */ "expr ::= STRING",
+ /* 203 */ "expr ::= NOW",
+ /* 204 */ "expr ::= VARIABLE",
+ /* 205 */ "expr ::= BOOL",
+ /* 206 */ "expr ::= ID LP exprlist RP",
+ /* 207 */ "expr ::= ID LP STAR RP",
+ /* 208 */ "expr ::= expr IS NULL",
+ /* 209 */ "expr ::= expr IS NOT NULL",
+ /* 210 */ "expr ::= expr LT expr",
+ /* 211 */ "expr ::= expr GT expr",
+ /* 212 */ "expr ::= expr LE expr",
+ /* 213 */ "expr ::= expr GE expr",
+ /* 214 */ "expr ::= expr NE expr",
+ /* 215 */ "expr ::= expr EQ expr",
+ /* 216 */ "expr ::= expr AND expr",
+ /* 217 */ "expr ::= expr OR expr",
+ /* 218 */ "expr ::= expr PLUS expr",
+ /* 219 */ "expr ::= expr MINUS expr",
+ /* 220 */ "expr ::= expr STAR expr",
+ /* 221 */ "expr ::= expr SLASH expr",
+ /* 222 */ "expr ::= expr REM expr",
+ /* 223 */ "expr ::= expr LIKE expr",
+ /* 224 */ "expr ::= expr IN LP exprlist RP",
+ /* 225 */ "exprlist ::= exprlist COMMA expritem",
+ /* 226 */ "exprlist ::= expritem",
+ /* 227 */ "expritem ::= expr",
+ /* 228 */ "expritem ::=",
+ /* 229 */ "cmd ::= RESET QUERY CACHE",
+ /* 230 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
+ /* 231 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
+ /* 232 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
+ /* 233 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
+ /* 234 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
+ /* 235 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
+ /* 236 */ "cmd ::= KILL CONNECTION INTEGER",
+ /* 237 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
+ /* 238 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
 };
 #endif /* NDEBUG */
 
@@ -1373,51 +1381,51 @@ static void yy_destructor(
     ** inside the C code.
     */
 /********* Begin destructor definitions ***************************************/
-    case 227: /* keep */
-    case 228: /* tagitemlist */
-    case 247: /* columnlist */
-    case 255: /* fill_opt */
-    case 257: /* groupby_opt */
-    case 258: /* orderby_opt */
-    case 268: /* sortlist */
-    case 272: /* grouplist */
+    case 228: /* keep */
+    case 229: /* tagitemlist */
+    case 249: /* columnlist */
+    case 257: /* fill_opt */
+    case 259: /* groupby_opt */
+    case 260: /* orderby_opt */
+    case 270: /* sortlist */
+    case 274: /* grouplist */
 {
-taosArrayDestroy((yypminor->yy131));
+taosArrayDestroy((yypminor->yy403));
 }
       break;
-    case 245: /* create_table_list */
+    case 247: /* create_table_list */
 {
-destroyCreateTableSql((yypminor->yy538));
+destroyCreateTableSql((yypminor->yy436));
 }
       break;
-    case 248: /* select */
+    case 250: /* select */
 {
-doDestroyQuerySql((yypminor->yy84));
+doDestroyQuerySql((yypminor->yy4));
 }
       break;
-    case 251: /* selcollist */
-    case 263: /* sclp */
-    case 273: /* exprlist */
+    case 253: /* selcollist */
+    case 265: /* sclp */
+    case 275: /* exprlist */
 {
-      tSqlExprListDestroy((yypminor->yy478));
+tSqlExprListDestroy((yypminor->yy382));
 }
       break;
-    case 253: /* where_opt */
-    case 259: /* having_opt */
-    case 264: /* expr */
-    case 274: /* expritem */
+    case 255: /* where_opt */
+    case 261: /* having_opt */
+    case 266: /* expr */
+    case 276: /* expritem */
 {
-      tSqlExprDestroy((yypminor->yy420));
+tSqlExprDestroy((yypminor->yy522));
 }
       break;
-    case 262: /* union */
+    case 264: /* union */
 {
-destroyAllSelectClause((yypminor->yy513));
+destroyAllSelectClause((yypminor->yy13));
 }
       break;
-    case 269: /* sortitem */
+    case 271: /* sortitem */
 {
-tVariantDestroy(&(yypminor->yy516));
+tVariantDestroy(&(yypminor->yy488));
 }
       break;
 /********* End destructor definitions *****************************************/
@@ -1711,242 +1719,245 @@ 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[] = {
-  {  208,   -1 }, /* (0) program ::= cmd */
-  {  209,   -2 }, /* (1) cmd ::= SHOW DATABASES */
-  {  209,   -2 }, /* (2) cmd ::= SHOW MNODES */
-  {  209,   -2 }, /* (3) cmd ::= SHOW DNODES */
-  {  209,   -2 }, /* (4) cmd ::= SHOW ACCOUNTS */
-  {  209,   -2 }, /* (5) cmd ::= SHOW USERS */
-  {  209,   -2 }, /* (6) cmd ::= SHOW MODULES */
-  {  209,   -2 }, /* (7) cmd ::= SHOW QUERIES */
-  {  209,   -2 }, /* (8) cmd ::= SHOW CONNECTIONS */
-  {  209,   -2 }, /* (9) cmd ::= SHOW STREAMS */
-  {  209,   -2 }, /* (10) cmd ::= SHOW VARIABLES */
-  {  209,   -2 }, /* (11) cmd ::= SHOW SCORES */
-  {  209,   -2 }, /* (12) cmd ::= SHOW GRANTS */
-  {  209,   -2 }, /* (13) cmd ::= SHOW VNODES */
-  {  209,   -3 }, /* (14) cmd ::= SHOW VNODES IPTOKEN */
-  {  210,    0 }, /* (15) dbPrefix ::= */
-  {  210,   -2 }, /* (16) dbPrefix ::= ids DOT */
-  {  212,    0 }, /* (17) cpxName ::= */
-  {  212,   -2 }, /* (18) cpxName ::= DOT ids */
-  {  209,   -5 }, /* (19) cmd ::= SHOW CREATE TABLE ids cpxName */
-  {  209,   -4 }, /* (20) cmd ::= SHOW CREATE DATABASE ids */
-  {  209,   -3 }, /* (21) cmd ::= SHOW dbPrefix TABLES */
-  {  209,   -5 }, /* (22) cmd ::= SHOW dbPrefix TABLES LIKE ids */
-  {  209,   -3 }, /* (23) cmd ::= SHOW dbPrefix STABLES */
-  {  209,   -5 }, /* (24) cmd ::= SHOW dbPrefix STABLES LIKE ids */
-  {  209,   -3 }, /* (25) cmd ::= SHOW dbPrefix VGROUPS */
-  {  209,   -4 }, /* (26) cmd ::= SHOW dbPrefix VGROUPS ids */
-  {  209,   -5 }, /* (27) cmd ::= DROP TABLE ifexists ids cpxName */
-  {  209,   -4 }, /* (28) cmd ::= DROP DATABASE ifexists ids */
-  {  209,   -3 }, /* (29) cmd ::= DROP DNODE ids */
-  {  209,   -3 }, /* (30) cmd ::= DROP USER ids */
-  {  209,   -3 }, /* (31) cmd ::= DROP ACCOUNT ids */
-  {  209,   -2 }, /* (32) cmd ::= USE ids */
-  {  209,   -3 }, /* (33) cmd ::= DESCRIBE ids cpxName */
-  {  209,   -5 }, /* (34) cmd ::= ALTER USER ids PASS ids */
-  {  209,   -5 }, /* (35) cmd ::= ALTER USER ids PRIVILEGE ids */
-  {  209,   -4 }, /* (36) cmd ::= ALTER DNODE ids ids */
-  {  209,   -5 }, /* (37) cmd ::= ALTER DNODE ids ids ids */
-  {  209,   -3 }, /* (38) cmd ::= ALTER LOCAL ids */
-  {  209,   -4 }, /* (39) cmd ::= ALTER LOCAL ids ids */
-  {  209,   -4 }, /* (40) cmd ::= ALTER DATABASE ids alter_db_optr */
-  {  209,   -4 }, /* (41) cmd ::= ALTER ACCOUNT ids acct_optr */
-  {  209,   -6 }, /* (42) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
-  {  211,   -1 }, /* (43) ids ::= ID */
-  {  211,   -1 }, /* (44) ids ::= STRING */
-  {  213,   -2 }, /* (45) ifexists ::= IF EXISTS */
-  {  213,    0 }, /* (46) ifexists ::= */
-  {  216,   -3 }, /* (47) ifnotexists ::= IF NOT EXISTS */
-  {  216,    0 }, /* (48) ifnotexists ::= */
-  {  209,   -3 }, /* (49) cmd ::= CREATE DNODE ids */
-  {  209,   -6 }, /* (50) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
-  {  209,   -5 }, /* (51) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
-  {  209,   -5 }, /* (52) cmd ::= CREATE USER ids PASS ids */
-  {  218,    0 }, /* (53) pps ::= */
-  {  218,   -2 }, /* (54) pps ::= PPS INTEGER */
-  {  219,    0 }, /* (55) tseries ::= */
-  {  219,   -2 }, /* (56) tseries ::= TSERIES INTEGER */
-  {  220,    0 }, /* (57) dbs ::= */
-  {  220,   -2 }, /* (58) dbs ::= DBS INTEGER */
-  {  221,    0 }, /* (59) streams ::= */
-  {  221,   -2 }, /* (60) streams ::= STREAMS INTEGER */
-  {  222,    0 }, /* (61) storage ::= */
-  {  222,   -2 }, /* (62) storage ::= STORAGE INTEGER */
-  {  223,    0 }, /* (63) qtime ::= */
-  {  223,   -2 }, /* (64) qtime ::= QTIME INTEGER */
-  {  224,    0 }, /* (65) users ::= */
-  {  224,   -2 }, /* (66) users ::= USERS INTEGER */
-  {  225,    0 }, /* (67) conns ::= */
-  {  225,   -2 }, /* (68) conns ::= CONNS INTEGER */
-  {  226,    0 }, /* (69) state ::= */
-  {  226,   -2 }, /* (70) state ::= STATE ids */
-  {  215,   -9 }, /* (71) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
-  {  227,   -2 }, /* (72) keep ::= KEEP tagitemlist */
-  {  229,   -2 }, /* (73) cache ::= CACHE INTEGER */
-  {  230,   -2 }, /* (74) replica ::= REPLICA INTEGER */
-  {  231,   -2 }, /* (75) quorum ::= QUORUM INTEGER */
-  {  232,   -2 }, /* (76) days ::= DAYS INTEGER */
-  {  233,   -2 }, /* (77) minrows ::= MINROWS INTEGER */
-  {  234,   -2 }, /* (78) maxrows ::= MAXROWS INTEGER */
-  {  235,   -2 }, /* (79) blocks ::= BLOCKS INTEGER */
-  {  236,   -2 }, /* (80) ctime ::= CTIME INTEGER */
-  {  237,   -2 }, /* (81) wal ::= WAL INTEGER */
-  {  238,   -2 }, /* (82) fsync ::= FSYNC INTEGER */
-  {  239,   -2 }, /* (83) comp ::= COMP INTEGER */
-  {  240,   -2 }, /* (84) prec ::= PRECISION STRING */
-  {  241,   -2 }, /* (85) update ::= UPDATE INTEGER */
-  {  217,    0 }, /* (86) db_optr ::= */
-  {  217,   -2 }, /* (87) db_optr ::= db_optr cache */
-  {  217,   -2 }, /* (88) db_optr ::= db_optr replica */
-  {  217,   -2 }, /* (89) db_optr ::= db_optr quorum */
-  {  217,   -2 }, /* (90) db_optr ::= db_optr days */
-  {  217,   -2 }, /* (91) db_optr ::= db_optr minrows */
-  {  217,   -2 }, /* (92) db_optr ::= db_optr maxrows */
-  {  217,   -2 }, /* (93) db_optr ::= db_optr blocks */
-  {  217,   -2 }, /* (94) db_optr ::= db_optr ctime */
-  {  217,   -2 }, /* (95) db_optr ::= db_optr wal */
-  {  217,   -2 }, /* (96) db_optr ::= db_optr fsync */
-  {  217,   -2 }, /* (97) db_optr ::= db_optr comp */
-  {  217,   -2 }, /* (98) db_optr ::= db_optr prec */
-  {  217,   -2 }, /* (99) db_optr ::= db_optr keep */
-  {  217,   -2 }, /* (100) db_optr ::= db_optr update */
-  {  214,    0 }, /* (101) alter_db_optr ::= */
-  {  214,   -2 }, /* (102) alter_db_optr ::= alter_db_optr replica */
-  {  214,   -2 }, /* (103) alter_db_optr ::= alter_db_optr quorum */
-  {  214,   -2 }, /* (104) alter_db_optr ::= alter_db_optr keep */
-  {  214,   -2 }, /* (105) alter_db_optr ::= alter_db_optr blocks */
-  {  214,   -2 }, /* (106) alter_db_optr ::= alter_db_optr comp */
-  {  214,   -2 }, /* (107) alter_db_optr ::= alter_db_optr wal */
-  {  214,   -2 }, /* (108) alter_db_optr ::= alter_db_optr fsync */
-  {  214,   -2 }, /* (109) alter_db_optr ::= alter_db_optr update */
-  {  242,   -1 }, /* (110) typename ::= ids */
-  {  242,   -4 }, /* (111) typename ::= ids LP signed RP */
-  {  243,   -1 }, /* (112) signed ::= INTEGER */
-  {  243,   -2 }, /* (113) signed ::= PLUS INTEGER */
-  {  243,   -2 }, /* (114) signed ::= MINUS INTEGER */
-  {  209,   -3 }, /* (115) cmd ::= CREATE TABLE create_table_args */
-  {  209,   -3 }, /* (116) cmd ::= CREATE TABLE create_table_list */
-  {  245,   -1 }, /* (117) create_table_list ::= create_from_stable */
-  {  245,   -2 }, /* (118) create_table_list ::= create_table_list create_from_stable */
-  {  244,   -6 }, /* (119) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
-  {  244,  -10 }, /* (120) create_table_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
-  {  246,  -10 }, /* (121) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
-  {  244,   -5 }, /* (122) create_table_args ::= ifnotexists ids cpxName AS select */
-  {  247,   -3 }, /* (123) columnlist ::= columnlist COMMA column */
-  {  247,   -1 }, /* (124) columnlist ::= column */
-  {  249,   -2 }, /* (125) column ::= ids typename */
-  {  228,   -3 }, /* (126) tagitemlist ::= tagitemlist COMMA tagitem */
-  {  228,   -1 }, /* (127) tagitemlist ::= tagitem */
-  {  250,   -1 }, /* (128) tagitem ::= INTEGER */
-  {  250,   -1 }, /* (129) tagitem ::= FLOAT */
-  {  250,   -1 }, /* (130) tagitem ::= STRING */
-  {  250,   -1 }, /* (131) tagitem ::= BOOL */
-  {  250,   -1 }, /* (132) tagitem ::= NULL */
-  {  250,   -2 }, /* (133) tagitem ::= MINUS INTEGER */
-  {  250,   -2 }, /* (134) tagitem ::= MINUS FLOAT */
-  {  250,   -2 }, /* (135) tagitem ::= PLUS INTEGER */
-  {  250,   -2 }, /* (136) tagitem ::= PLUS FLOAT */
-  {  248,  -12 }, /* (137) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
-  {  262,   -1 }, /* (138) union ::= select */
-  {  262,   -3 }, /* (139) union ::= LP union RP */
-  {  262,   -4 }, /* (140) union ::= union UNION ALL select */
-  {  262,   -6 }, /* (141) union ::= union UNION ALL LP select RP */
-  {  209,   -1 }, /* (142) cmd ::= union */
-  {  248,   -2 }, /* (143) select ::= SELECT selcollist */
-  {  263,   -2 }, /* (144) sclp ::= selcollist COMMA */
-  {  263,    0 }, /* (145) sclp ::= */
-  {  251,   -3 }, /* (146) selcollist ::= sclp expr as */
-  {  251,   -2 }, /* (147) selcollist ::= sclp STAR */
-  {  265,   -2 }, /* (148) as ::= AS ids */
-  {  265,   -1 }, /* (149) as ::= ids */
-  {  265,    0 }, /* (150) as ::= */
-  {  252,   -2 }, /* (151) from ::= FROM tablelist */
-  {  266,   -2 }, /* (152) tablelist ::= ids cpxName */
-  {  266,   -3 }, /* (153) tablelist ::= ids cpxName ids */
-  {  266,   -4 }, /* (154) tablelist ::= tablelist COMMA ids cpxName */
-  {  266,   -5 }, /* (155) tablelist ::= tablelist COMMA ids cpxName ids */
-  {  267,   -1 }, /* (156) tmvar ::= VARIABLE */
-  {  254,   -4 }, /* (157) interval_opt ::= INTERVAL LP tmvar RP */
-  {  254,   -6 }, /* (158) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
-  {  254,    0 }, /* (159) interval_opt ::= */
-  {  255,    0 }, /* (160) fill_opt ::= */
-  {  255,   -6 }, /* (161) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
-  {  255,   -4 }, /* (162) fill_opt ::= FILL LP ID RP */
-  {  256,   -4 }, /* (163) sliding_opt ::= SLIDING LP tmvar RP */
-  {  256,    0 }, /* (164) sliding_opt ::= */
-  {  258,    0 }, /* (165) orderby_opt ::= */
-  {  258,   -3 }, /* (166) orderby_opt ::= ORDER BY sortlist */
-  {  268,   -4 }, /* (167) sortlist ::= sortlist COMMA item sortorder */
-  {  268,   -2 }, /* (168) sortlist ::= item sortorder */
-  {  270,   -2 }, /* (169) item ::= ids cpxName */
-  {  271,   -1 }, /* (170) sortorder ::= ASC */
-  {  271,   -1 }, /* (171) sortorder ::= DESC */
-  {  271,    0 }, /* (172) sortorder ::= */
-  {  257,    0 }, /* (173) groupby_opt ::= */
-  {  257,   -3 }, /* (174) groupby_opt ::= GROUP BY grouplist */
-  {  272,   -3 }, /* (175) grouplist ::= grouplist COMMA item */
-  {  272,   -1 }, /* (176) grouplist ::= item */
-  {  259,    0 }, /* (177) having_opt ::= */
-  {  259,   -2 }, /* (178) having_opt ::= HAVING expr */
-  {  261,    0 }, /* (179) limit_opt ::= */
-  {  261,   -2 }, /* (180) limit_opt ::= LIMIT signed */
-  {  261,   -4 }, /* (181) limit_opt ::= LIMIT signed OFFSET signed */
-  {  261,   -4 }, /* (182) limit_opt ::= LIMIT signed COMMA signed */
-  {  260,    0 }, /* (183) slimit_opt ::= */
-  {  260,   -2 }, /* (184) slimit_opt ::= SLIMIT signed */
-  {  260,   -4 }, /* (185) slimit_opt ::= SLIMIT signed SOFFSET signed */
-  {  260,   -4 }, /* (186) slimit_opt ::= SLIMIT signed COMMA signed */
-  {  253,    0 }, /* (187) where_opt ::= */
-  {  253,   -2 }, /* (188) where_opt ::= WHERE expr */
-  {  264,   -3 }, /* (189) expr ::= LP expr RP */
-  {  264,   -1 }, /* (190) expr ::= ID */
-  {  264,   -3 }, /* (191) expr ::= ID DOT ID */
-  {  264,   -3 }, /* (192) expr ::= ID DOT STAR */
-  {  264,   -1 }, /* (193) expr ::= INTEGER */
-  {  264,   -2 }, /* (194) expr ::= MINUS INTEGER */
-  {  264,   -2 }, /* (195) expr ::= PLUS INTEGER */
-  {  264,   -1 }, /* (196) expr ::= FLOAT */
-  {  264,   -2 }, /* (197) expr ::= MINUS FLOAT */
-  {  264,   -2 }, /* (198) expr ::= PLUS FLOAT */
-  {  264,   -1 }, /* (199) expr ::= STRING */
-  {  264,   -1 }, /* (200) expr ::= NOW */
-  {  264,   -1 }, /* (201) expr ::= VARIABLE */
-  {  264,   -1 }, /* (202) expr ::= BOOL */
-  {  264,   -4 }, /* (203) expr ::= ID LP exprlist RP */
-  {  264,   -4 }, /* (204) expr ::= ID LP STAR RP */
-  {  264,   -3 }, /* (205) expr ::= expr IS NULL */
-  {  264,   -4 }, /* (206) expr ::= expr IS NOT NULL */
-  {  264,   -3 }, /* (207) expr ::= expr LT expr */
-  {  264,   -3 }, /* (208) expr ::= expr GT expr */
-  {  264,   -3 }, /* (209) expr ::= expr LE expr */
-  {  264,   -3 }, /* (210) expr ::= expr GE expr */
-  {  264,   -3 }, /* (211) expr ::= expr NE expr */
-  {  264,   -3 }, /* (212) expr ::= expr EQ expr */
-  {  264,   -3 }, /* (213) expr ::= expr AND expr */
-  {  264,   -3 }, /* (214) expr ::= expr OR expr */
-  {  264,   -3 }, /* (215) expr ::= expr PLUS expr */
-  {  264,   -3 }, /* (216) expr ::= expr MINUS expr */
-  {  264,   -3 }, /* (217) expr ::= expr STAR expr */
-  {  264,   -3 }, /* (218) expr ::= expr SLASH expr */
-  {  264,   -3 }, /* (219) expr ::= expr REM expr */
-  {  264,   -3 }, /* (220) expr ::= expr LIKE expr */
-  {  264,   -5 }, /* (221) expr ::= expr IN LP exprlist RP */
-  {  273,   -3 }, /* (222) exprlist ::= exprlist COMMA expritem */
-  {  273,   -1 }, /* (223) exprlist ::= expritem */
-  {  274,   -1 }, /* (224) expritem ::= expr */
-  {  274,    0 }, /* (225) expritem ::= */
-  {  209,   -3 }, /* (226) cmd ::= RESET QUERY CACHE */
-  {  209,   -7 }, /* (227) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
-  {  209,   -7 }, /* (228) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
-  {  209,   -7 }, /* (229) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
-  {  209,   -7 }, /* (230) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
-  {  209,   -8 }, /* (231) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
-  {  209,   -9 }, /* (232) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
-  {  209,   -3 }, /* (233) cmd ::= KILL CONNECTION INTEGER */
-  {  209,   -5 }, /* (234) cmd ::= KILL STREAM INTEGER COLON INTEGER */
-  {  209,   -5 }, /* (235) cmd ::= KILL QUERY INTEGER COLON INTEGER */
+  {  209,   -1 }, /* (0) program ::= cmd */
+  {  210,   -2 }, /* (1) cmd ::= SHOW DATABASES */
+  {  210,   -2 }, /* (2) cmd ::= SHOW MNODES */
+  {  210,   -2 }, /* (3) cmd ::= SHOW DNODES */
+  {  210,   -2 }, /* (4) cmd ::= SHOW ACCOUNTS */
+  {  210,   -2 }, /* (5) cmd ::= SHOW USERS */
+  {  210,   -2 }, /* (6) cmd ::= SHOW MODULES */
+  {  210,   -2 }, /* (7) cmd ::= SHOW QUERIES */
+  {  210,   -2 }, /* (8) cmd ::= SHOW CONNECTIONS */
+  {  210,   -2 }, /* (9) cmd ::= SHOW STREAMS */
+  {  210,   -2 }, /* (10) cmd ::= SHOW VARIABLES */
+  {  210,   -2 }, /* (11) cmd ::= SHOW SCORES */
+  {  210,   -2 }, /* (12) cmd ::= SHOW GRANTS */
+  {  210,   -2 }, /* (13) cmd ::= SHOW VNODES */
+  {  210,   -3 }, /* (14) cmd ::= SHOW VNODES IPTOKEN */
+  {  211,    0 }, /* (15) dbPrefix ::= */
+  {  211,   -2 }, /* (16) dbPrefix ::= ids DOT */
+  {  213,    0 }, /* (17) cpxName ::= */
+  {  213,   -2 }, /* (18) cpxName ::= DOT ids */
+  {  210,   -5 }, /* (19) cmd ::= SHOW CREATE TABLE ids cpxName */
+  {  210,   -4 }, /* (20) cmd ::= SHOW CREATE DATABASE ids */
+  {  210,   -3 }, /* (21) cmd ::= SHOW dbPrefix TABLES */
+  {  210,   -5 }, /* (22) cmd ::= SHOW dbPrefix TABLES LIKE ids */
+  {  210,   -3 }, /* (23) cmd ::= SHOW dbPrefix STABLES */
+  {  210,   -5 }, /* (24) cmd ::= SHOW dbPrefix STABLES LIKE ids */
+  {  210,   -3 }, /* (25) cmd ::= SHOW dbPrefix VGROUPS */
+  {  210,   -4 }, /* (26) cmd ::= SHOW dbPrefix VGROUPS ids */
+  {  210,   -5 }, /* (27) cmd ::= DROP TABLE ifexists ids cpxName */
+  {  210,   -4 }, /* (28) cmd ::= DROP DATABASE ifexists ids */
+  {  210,   -3 }, /* (29) cmd ::= DROP DNODE ids */
+  {  210,   -3 }, /* (30) cmd ::= DROP USER ids */
+  {  210,   -3 }, /* (31) cmd ::= DROP ACCOUNT ids */
+  {  210,   -2 }, /* (32) cmd ::= USE ids */
+  {  210,   -3 }, /* (33) cmd ::= DESCRIBE ids cpxName */
+  {  210,   -5 }, /* (34) cmd ::= ALTER USER ids PASS ids */
+  {  210,   -5 }, /* (35) cmd ::= ALTER USER ids PRIVILEGE ids */
+  {  210,   -4 }, /* (36) cmd ::= ALTER DNODE ids ids */
+  {  210,   -5 }, /* (37) cmd ::= ALTER DNODE ids ids ids */
+  {  210,   -3 }, /* (38) cmd ::= ALTER LOCAL ids */
+  {  210,   -4 }, /* (39) cmd ::= ALTER LOCAL ids ids */
+  {  210,   -4 }, /* (40) cmd ::= ALTER DATABASE ids alter_db_optr */
+  {  210,   -4 }, /* (41) cmd ::= ALTER ACCOUNT ids acct_optr */
+  {  210,   -6 }, /* (42) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
+  {  212,   -1 }, /* (43) ids ::= ID */
+  {  212,   -1 }, /* (44) ids ::= STRING */
+  {  214,   -2 }, /* (45) ifexists ::= IF EXISTS */
+  {  214,    0 }, /* (46) ifexists ::= */
+  {  217,   -3 }, /* (47) ifnotexists ::= IF NOT EXISTS */
+  {  217,    0 }, /* (48) ifnotexists ::= */
+  {  210,   -3 }, /* (49) cmd ::= CREATE DNODE ids */
+  {  210,   -6 }, /* (50) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
+  {  210,   -5 }, /* (51) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
+  {  210,   -5 }, /* (52) cmd ::= CREATE USER ids PASS ids */
+  {  219,    0 }, /* (53) pps ::= */
+  {  219,   -2 }, /* (54) pps ::= PPS INTEGER */
+  {  220,    0 }, /* (55) tseries ::= */
+  {  220,   -2 }, /* (56) tseries ::= TSERIES INTEGER */
+  {  221,    0 }, /* (57) dbs ::= */
+  {  221,   -2 }, /* (58) dbs ::= DBS INTEGER */
+  {  222,    0 }, /* (59) streams ::= */
+  {  222,   -2 }, /* (60) streams ::= STREAMS INTEGER */
+  {  223,    0 }, /* (61) storage ::= */
+  {  223,   -2 }, /* (62) storage ::= STORAGE INTEGER */
+  {  224,    0 }, /* (63) qtime ::= */
+  {  224,   -2 }, /* (64) qtime ::= QTIME INTEGER */
+  {  225,    0 }, /* (65) users ::= */
+  {  225,   -2 }, /* (66) users ::= USERS INTEGER */
+  {  226,    0 }, /* (67) conns ::= */
+  {  226,   -2 }, /* (68) conns ::= CONNS INTEGER */
+  {  227,    0 }, /* (69) state ::= */
+  {  227,   -2 }, /* (70) state ::= STATE ids */
+  {  216,   -9 }, /* (71) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
+  {  228,   -2 }, /* (72) keep ::= KEEP tagitemlist */
+  {  230,   -2 }, /* (73) cache ::= CACHE INTEGER */
+  {  231,   -2 }, /* (74) replica ::= REPLICA INTEGER */
+  {  232,   -2 }, /* (75) quorum ::= QUORUM INTEGER */
+  {  233,   -2 }, /* (76) days ::= DAYS INTEGER */
+  {  234,   -2 }, /* (77) minrows ::= MINROWS INTEGER */
+  {  235,   -2 }, /* (78) maxrows ::= MAXROWS INTEGER */
+  {  236,   -2 }, /* (79) blocks ::= BLOCKS INTEGER */
+  {  237,   -2 }, /* (80) ctime ::= CTIME INTEGER */
+  {  238,   -2 }, /* (81) wal ::= WAL INTEGER */
+  {  239,   -2 }, /* (82) fsync ::= FSYNC INTEGER */
+  {  240,   -2 }, /* (83) comp ::= COMP INTEGER */
+  {  241,   -2 }, /* (84) prec ::= PRECISION STRING */
+  {  242,   -2 }, /* (85) update ::= UPDATE INTEGER */
+  {  243,   -2 }, /* (86) cachelast ::= CACHELAST INTEGER */
+  {  218,    0 }, /* (87) db_optr ::= */
+  {  218,   -2 }, /* (88) db_optr ::= db_optr cache */
+  {  218,   -2 }, /* (89) db_optr ::= db_optr replica */
+  {  218,   -2 }, /* (90) db_optr ::= db_optr quorum */
+  {  218,   -2 }, /* (91) db_optr ::= db_optr days */
+  {  218,   -2 }, /* (92) db_optr ::= db_optr minrows */
+  {  218,   -2 }, /* (93) db_optr ::= db_optr maxrows */
+  {  218,   -2 }, /* (94) db_optr ::= db_optr blocks */
+  {  218,   -2 }, /* (95) db_optr ::= db_optr ctime */
+  {  218,   -2 }, /* (96) db_optr ::= db_optr wal */
+  {  218,   -2 }, /* (97) db_optr ::= db_optr fsync */
+  {  218,   -2 }, /* (98) db_optr ::= db_optr comp */
+  {  218,   -2 }, /* (99) db_optr ::= db_optr prec */
+  {  218,   -2 }, /* (100) db_optr ::= db_optr keep */
+  {  218,   -2 }, /* (101) db_optr ::= db_optr update */
+  {  218,   -2 }, /* (102) db_optr ::= db_optr cachelast */
+  {  215,    0 }, /* (103) alter_db_optr ::= */
+  {  215,   -2 }, /* (104) alter_db_optr ::= alter_db_optr replica */
+  {  215,   -2 }, /* (105) alter_db_optr ::= alter_db_optr quorum */
+  {  215,   -2 }, /* (106) alter_db_optr ::= alter_db_optr keep */
+  {  215,   -2 }, /* (107) alter_db_optr ::= alter_db_optr blocks */
+  {  215,   -2 }, /* (108) alter_db_optr ::= alter_db_optr comp */
+  {  215,   -2 }, /* (109) alter_db_optr ::= alter_db_optr wal */
+  {  215,   -2 }, /* (110) alter_db_optr ::= alter_db_optr fsync */
+  {  215,   -2 }, /* (111) alter_db_optr ::= alter_db_optr update */
+  {  215,   -2 }, /* (112) alter_db_optr ::= alter_db_optr cachelast */
+  {  244,   -1 }, /* (113) typename ::= ids */
+  {  244,   -4 }, /* (114) typename ::= ids LP signed RP */
+  {  245,   -1 }, /* (115) signed ::= INTEGER */
+  {  245,   -2 }, /* (116) signed ::= PLUS INTEGER */
+  {  245,   -2 }, /* (117) signed ::= MINUS INTEGER */
+  {  210,   -3 }, /* (118) cmd ::= CREATE TABLE create_table_args */
+  {  210,   -3 }, /* (119) cmd ::= CREATE TABLE create_table_list */
+  {  247,   -1 }, /* (120) create_table_list ::= create_from_stable */
+  {  247,   -2 }, /* (121) create_table_list ::= create_table_list create_from_stable */
+  {  246,   -6 }, /* (122) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
+  {  246,  -10 }, /* (123) create_table_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
+  {  248,  -10 }, /* (124) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
+  {  246,   -5 }, /* (125) create_table_args ::= ifnotexists ids cpxName AS select */
+  {  249,   -3 }, /* (126) columnlist ::= columnlist COMMA column */
+  {  249,   -1 }, /* (127) columnlist ::= column */
+  {  251,   -2 }, /* (128) column ::= ids typename */
+  {  229,   -3 }, /* (129) tagitemlist ::= tagitemlist COMMA tagitem */
+  {  229,   -1 }, /* (130) tagitemlist ::= tagitem */
+  {  252,   -1 }, /* (131) tagitem ::= INTEGER */
+  {  252,   -1 }, /* (132) tagitem ::= FLOAT */
+  {  252,   -1 }, /* (133) tagitem ::= STRING */
+  {  252,   -1 }, /* (134) tagitem ::= BOOL */
+  {  252,   -1 }, /* (135) tagitem ::= NULL */
+  {  252,   -2 }, /* (136) tagitem ::= MINUS INTEGER */
+  {  252,   -2 }, /* (137) tagitem ::= MINUS FLOAT */
+  {  252,   -2 }, /* (138) tagitem ::= PLUS INTEGER */
+  {  252,   -2 }, /* (139) tagitem ::= PLUS FLOAT */
+  {  250,  -12 }, /* (140) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
+  {  264,   -1 }, /* (141) union ::= select */
+  {  264,   -3 }, /* (142) union ::= LP union RP */
+  {  264,   -4 }, /* (143) union ::= union UNION ALL select */
+  {  264,   -6 }, /* (144) union ::= union UNION ALL LP select RP */
+  {  210,   -1 }, /* (145) cmd ::= union */
+  {  250,   -2 }, /* (146) select ::= SELECT selcollist */
+  {  265,   -2 }, /* (147) sclp ::= selcollist COMMA */
+  {  265,    0 }, /* (148) sclp ::= */
+  {  253,   -3 }, /* (149) selcollist ::= sclp expr as */
+  {  253,   -2 }, /* (150) selcollist ::= sclp STAR */
+  {  267,   -2 }, /* (151) as ::= AS ids */
+  {  267,   -1 }, /* (152) as ::= ids */
+  {  267,    0 }, /* (153) as ::= */
+  {  254,   -2 }, /* (154) from ::= FROM tablelist */
+  {  268,   -2 }, /* (155) tablelist ::= ids cpxName */
+  {  268,   -3 }, /* (156) tablelist ::= ids cpxName ids */
+  {  268,   -4 }, /* (157) tablelist ::= tablelist COMMA ids cpxName */
+  {  268,   -5 }, /* (158) tablelist ::= tablelist COMMA ids cpxName ids */
+  {  269,   -1 }, /* (159) tmvar ::= VARIABLE */
+  {  256,   -4 }, /* (160) interval_opt ::= INTERVAL LP tmvar RP */
+  {  256,   -6 }, /* (161) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
+  {  256,    0 }, /* (162) interval_opt ::= */
+  {  257,    0 }, /* (163) fill_opt ::= */
+  {  257,   -6 }, /* (164) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+  {  257,   -4 }, /* (165) fill_opt ::= FILL LP ID RP */
+  {  258,   -4 }, /* (166) sliding_opt ::= SLIDING LP tmvar RP */
+  {  258,    0 }, /* (167) sliding_opt ::= */
+  {  260,    0 }, /* (168) orderby_opt ::= */
+  {  260,   -3 }, /* (169) orderby_opt ::= ORDER BY sortlist */
+  {  270,   -4 }, /* (170) sortlist ::= sortlist COMMA item sortorder */
+  {  270,   -2 }, /* (171) sortlist ::= item sortorder */
+  {  272,   -2 }, /* (172) item ::= ids cpxName */
+  {  273,   -1 }, /* (173) sortorder ::= ASC */
+  {  273,   -1 }, /* (174) sortorder ::= DESC */
+  {  273,    0 }, /* (175) sortorder ::= */
+  {  259,    0 }, /* (176) groupby_opt ::= */
+  {  259,   -3 }, /* (177) groupby_opt ::= GROUP BY grouplist */
+  {  274,   -3 }, /* (178) grouplist ::= grouplist COMMA item */
+  {  274,   -1 }, /* (179) grouplist ::= item */
+  {  261,    0 }, /* (180) having_opt ::= */
+  {  261,   -2 }, /* (181) having_opt ::= HAVING expr */
+  {  263,    0 }, /* (182) limit_opt ::= */
+  {  263,   -2 }, /* (183) limit_opt ::= LIMIT signed */
+  {  263,   -4 }, /* (184) limit_opt ::= LIMIT signed OFFSET signed */
+  {  263,   -4 }, /* (185) limit_opt ::= LIMIT signed COMMA signed */
+  {  262,    0 }, /* (186) slimit_opt ::= */
+  {  262,   -2 }, /* (187) slimit_opt ::= SLIMIT signed */
+  {  262,   -4 }, /* (188) slimit_opt ::= SLIMIT signed SOFFSET signed */
+  {  262,   -4 }, /* (189) slimit_opt ::= SLIMIT signed COMMA signed */
+  {  255,    0 }, /* (190) where_opt ::= */
+  {  255,   -2 }, /* (191) where_opt ::= WHERE expr */
+  {  266,   -3 }, /* (192) expr ::= LP expr RP */
+  {  266,   -1 }, /* (193) expr ::= ID */
+  {  266,   -3 }, /* (194) expr ::= ID DOT ID */
+  {  266,   -3 }, /* (195) expr ::= ID DOT STAR */
+  {  266,   -1 }, /* (196) expr ::= INTEGER */
+  {  266,   -2 }, /* (197) expr ::= MINUS INTEGER */
+  {  266,   -2 }, /* (198) expr ::= PLUS INTEGER */
+  {  266,   -1 }, /* (199) expr ::= FLOAT */
+  {  266,   -2 }, /* (200) expr ::= MINUS FLOAT */
+  {  266,   -2 }, /* (201) expr ::= PLUS FLOAT */
+  {  266,   -1 }, /* (202) expr ::= STRING */
+  {  266,   -1 }, /* (203) expr ::= NOW */
+  {  266,   -1 }, /* (204) expr ::= VARIABLE */
+  {  266,   -1 }, /* (205) expr ::= BOOL */
+  {  266,   -4 }, /* (206) expr ::= ID LP exprlist RP */
+  {  266,   -4 }, /* (207) expr ::= ID LP STAR RP */
+  {  266,   -3 }, /* (208) expr ::= expr IS NULL */
+  {  266,   -4 }, /* (209) expr ::= expr IS NOT NULL */
+  {  266,   -3 }, /* (210) expr ::= expr LT expr */
+  {  266,   -3 }, /* (211) expr ::= expr GT expr */
+  {  266,   -3 }, /* (212) expr ::= expr LE expr */
+  {  266,   -3 }, /* (213) expr ::= expr GE expr */
+  {  266,   -3 }, /* (214) expr ::= expr NE expr */
+  {  266,   -3 }, /* (215) expr ::= expr EQ expr */
+  {  266,   -3 }, /* (216) expr ::= expr AND expr */
+  {  266,   -3 }, /* (217) expr ::= expr OR expr */
+  {  266,   -3 }, /* (218) expr ::= expr PLUS expr */
+  {  266,   -3 }, /* (219) expr ::= expr MINUS expr */
+  {  266,   -3 }, /* (220) expr ::= expr STAR expr */
+  {  266,   -3 }, /* (221) expr ::= expr SLASH expr */
+  {  266,   -3 }, /* (222) expr ::= expr REM expr */
+  {  266,   -3 }, /* (223) expr ::= expr LIKE expr */
+  {  266,   -5 }, /* (224) expr ::= expr IN LP exprlist RP */
+  {  275,   -3 }, /* (225) exprlist ::= exprlist COMMA expritem */
+  {  275,   -1 }, /* (226) exprlist ::= expritem */
+  {  276,   -1 }, /* (227) expritem ::= expr */
+  {  276,    0 }, /* (228) expritem ::= */
+  {  210,   -3 }, /* (229) cmd ::= RESET QUERY CACHE */
+  {  210,   -7 }, /* (230) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+  {  210,   -7 }, /* (231) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+  {  210,   -7 }, /* (232) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+  {  210,   -7 }, /* (233) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+  {  210,   -8 }, /* (234) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+  {  210,   -9 }, /* (235) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+  {  210,   -3 }, /* (236) cmd ::= KILL CONNECTION INTEGER */
+  {  210,   -5 }, /* (237) cmd ::= KILL STREAM INTEGER COLON INTEGER */
+  {  210,   -5 }, /* (238) cmd ::= KILL QUERY INTEGER COLON INTEGER */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -2027,7 +2038,7 @@ static void yy_reduce(
 /********** Begin reduce actions **********************************************/
         YYMINORTYPE yylhsminor;
       case 0: /* program ::= cmd */
-      case 115: /* cmd ::= CREATE TABLE create_table_args */ yytestcase(yyruleno==115);
+      case 118: /* cmd ::= CREATE TABLE create_table_args */ yytestcase(yyruleno==118);
 {}
         break;
       case 1: /* cmd ::= SHOW DATABASES */
@@ -2139,8 +2150,7 @@ static void yy_reduce(
 }
         break;
       case 28: /* cmd ::= DROP DATABASE ifexists ids */
-{
-        setDropDbTableInfo(pInfo, TSDB_SQL_DROP_DB, &yymsp[0].minor.yy0, &yymsp[-1].minor.yy0); }
+{ setDropDbTableInfo(pInfo, TSDB_SQL_DROP_DB, &yymsp[0].minor.yy0, &yymsp[-1].minor.yy0); }
         break;
       case 29: /* cmd ::= DROP DNODE ids */
 { setDCLSQLElems(pInfo, TSDB_SQL_DROP_DNODE, 1, &yymsp[0].minor.yy0);    }
@@ -2161,12 +2171,10 @@ static void yy_reduce(
 }
         break;
       case 34: /* cmd ::= ALTER USER ids PASS ids */
-{
-        setAlterUserSql(pInfo, TSDB_ALTER_USER_PASSWD, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, NULL);    }
+{ setAlterUserSql(pInfo, TSDB_ALTER_USER_PASSWD, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, NULL);    }
         break;
       case 35: /* cmd ::= ALTER USER ids PRIVILEGE ids */
-{
-        setAlterUserSql(pInfo, TSDB_ALTER_USER_PRIVILEGES, &yymsp[-2].minor.yy0, NULL, &yymsp[0].minor.yy0);}
+{ setAlterUserSql(pInfo, TSDB_ALTER_USER_PRIVILEGES, &yymsp[-2].minor.yy0, NULL, &yymsp[0].minor.yy0);}
         break;
       case 36: /* cmd ::= ALTER DNODE ids ids */
 { setDCLSQLElems(pInfo, TSDB_SQL_CFG_DNODE, 2, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);          }
@@ -2181,15 +2189,13 @@ static void yy_reduce(
 { setDCLSQLElems(pInfo, TSDB_SQL_CFG_LOCAL, 2, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);          }
         break;
       case 40: /* cmd ::= ALTER DATABASE ids alter_db_optr */
-{ SStrToken t = {0};  setCreateDBSQL(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy148, &t);}
+{ SStrToken t = {0};  setCreateDBSQL(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy478, &t);}
         break;
       case 41: /* cmd ::= ALTER ACCOUNT ids acct_optr */
-{
-        setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy309);}
+{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy463);}
         break;
       case 42: /* cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
-{
-        setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy309);}
+{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy463);}
         break;
       case 43: /* ids ::= ID */
       case 44: /* ids ::= STRING */ yytestcase(yyruleno==44);
@@ -2210,16 +2216,13 @@ static void yy_reduce(
 { setDCLSQLElems(pInfo, TSDB_SQL_CREATE_DNODE, 1, &yymsp[0].minor.yy0);}
         break;
       case 50: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
-{
-        setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0,
-                         &yymsp[0].minor.yy309);}
+{ setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy463);}
         break;
       case 51: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */
-{ setCreateDBSQL(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy148, &yymsp[-2].minor.yy0);}
+{ setCreateDBSQL(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy478, &yymsp[-2].minor.yy0);}
         break;
       case 52: /* cmd ::= CREATE USER ids PASS ids */
-{
-        setCreateUserSql(pInfo, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);}
+{ setCreateUserSql(pInfo, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);}
         break;
       case 53: /* pps ::= */
       case 55: /* tseries ::= */ yytestcase(yyruleno==55);
@@ -2245,20 +2248,20 @@ static void yy_reduce(
         break;
       case 71: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */
 {
-    yylhsminor.yy309.maxUsers   = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
-    yylhsminor.yy309.maxDbs     = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
-    yylhsminor.yy309.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
-    yylhsminor.yy309.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
-    yylhsminor.yy309.maxPointsPerSecond     = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
-    yylhsminor.yy309.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
-    yylhsminor.yy309.maxQueryTime   = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
-    yylhsminor.yy309.maxConnections   = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
-    yylhsminor.yy309.stat    = yymsp[0].minor.yy0;
-}
-  yymsp[-8].minor.yy309 = yylhsminor.yy309;
+    yylhsminor.yy463.maxUsers   = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
+    yylhsminor.yy463.maxDbs     = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
+    yylhsminor.yy463.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
+    yylhsminor.yy463.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
+    yylhsminor.yy463.maxPointsPerSecond     = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
+    yylhsminor.yy463.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
+    yylhsminor.yy463.maxQueryTime   = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
+    yylhsminor.yy463.maxConnections   = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
+    yylhsminor.yy463.stat    = yymsp[0].minor.yy0;
+}
+  yymsp[-8].minor.yy463 = yylhsminor.yy463;
         break;
       case 72: /* keep ::= KEEP tagitemlist */
-{ yymsp[-1].minor.yy131 = yymsp[0].minor.yy131; }
+{ yymsp[-1].minor.yy403 = yymsp[0].minor.yy403; }
         break;
       case 73: /* cache ::= CACHE INTEGER */
       case 74: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==74);
@@ -2273,591 +2276,588 @@ static void yy_reduce(
       case 83: /* comp ::= COMP INTEGER */ yytestcase(yyruleno==83);
       case 84: /* prec ::= PRECISION STRING */ yytestcase(yyruleno==84);
       case 85: /* update ::= UPDATE INTEGER */ yytestcase(yyruleno==85);
+      case 86: /* cachelast ::= CACHELAST INTEGER */ yytestcase(yyruleno==86);
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
         break;
-      case 86: /* db_optr ::= */
-{setDefaultCreateDbOption(&yymsp[1].minor.yy148);}
-        break;
-      case 87: /* db_optr ::= db_optr cache */
-{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy148 = yylhsminor.yy148;
-        break;
-      case 88: /* db_optr ::= db_optr replica */
-      case 102: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==102);
-{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy148 = yylhsminor.yy148;
-        break;
-      case 89: /* db_optr ::= db_optr quorum */
-      case 103: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==103);
-{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy148 = yylhsminor.yy148;
-        break;
-      case 90: /* db_optr ::= db_optr days */
-{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy148 = yylhsminor.yy148;
-        break;
-      case 91: /* db_optr ::= db_optr minrows */
-{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
-  yymsp[-1].minor.yy148 = yylhsminor.yy148;
-        break;
-      case 92: /* db_optr ::= db_optr maxrows */
-{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
-  yymsp[-1].minor.yy148 = yylhsminor.yy148;
-        break;
-      case 93: /* db_optr ::= db_optr blocks */
-      case 105: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==105);
-{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy148 = yylhsminor.yy148;
-        break;
-      case 94: /* db_optr ::= db_optr ctime */
-{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy148 = yylhsminor.yy148;
-        break;
-      case 95: /* db_optr ::= db_optr wal */
-      case 107: /* alter_db_optr ::= alter_db_optr wal */ yytestcase(yyruleno==107);
-{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy148 = yylhsminor.yy148;
-        break;
-      case 96: /* db_optr ::= db_optr fsync */
-      case 108: /* alter_db_optr ::= alter_db_optr fsync */ yytestcase(yyruleno==108);
-{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy148 = yylhsminor.yy148;
-        break;
-      case 97: /* db_optr ::= db_optr comp */
-      case 106: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==106);
-{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy148 = yylhsminor.yy148;
-        break;
-      case 98: /* db_optr ::= db_optr prec */
-{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.precision = yymsp[0].minor.yy0; }
-  yymsp[-1].minor.yy148 = yylhsminor.yy148;
-        break;
-      case 99: /* db_optr ::= db_optr keep */
-      case 104: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==104);
-{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.keep = yymsp[0].minor.yy131; }
-  yymsp[-1].minor.yy148 = yylhsminor.yy148;
-        break;
-      case 100: /* db_optr ::= db_optr update */
-      case 109: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==109);
-{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy148 = yylhsminor.yy148;
-        break;
-      case 101: /* alter_db_optr ::= */
-{ setDefaultCreateDbOption(&yymsp[1].minor.yy148);}
-        break;
-      case 110: /* typename ::= ids */
+      case 87: /* db_optr ::= */
+{setDefaultCreateDbOption(&yymsp[1].minor.yy478);}
+        break;
+      case 88: /* db_optr ::= db_optr cache */
+{ yylhsminor.yy478 = yymsp[-1].minor.yy478; yylhsminor.yy478.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy478 = yylhsminor.yy478;
+        break;
+      case 89: /* db_optr ::= db_optr replica */
+      case 104: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==104);
+{ yylhsminor.yy478 = yymsp[-1].minor.yy478; yylhsminor.yy478.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy478 = yylhsminor.yy478;
+        break;
+      case 90: /* db_optr ::= db_optr quorum */
+      case 105: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==105);
+{ yylhsminor.yy478 = yymsp[-1].minor.yy478; yylhsminor.yy478.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy478 = yylhsminor.yy478;
+        break;
+      case 91: /* db_optr ::= db_optr days */
+{ yylhsminor.yy478 = yymsp[-1].minor.yy478; yylhsminor.yy478.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy478 = yylhsminor.yy478;
+        break;
+      case 92: /* db_optr ::= db_optr minrows */
+{ yylhsminor.yy478 = yymsp[-1].minor.yy478; yylhsminor.yy478.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+  yymsp[-1].minor.yy478 = yylhsminor.yy478;
+        break;
+      case 93: /* db_optr ::= db_optr maxrows */
+{ yylhsminor.yy478 = yymsp[-1].minor.yy478; yylhsminor.yy478.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+  yymsp[-1].minor.yy478 = yylhsminor.yy478;
+        break;
+      case 94: /* db_optr ::= db_optr blocks */
+      case 107: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==107);
+{ yylhsminor.yy478 = yymsp[-1].minor.yy478; yylhsminor.yy478.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy478 = yylhsminor.yy478;
+        break;
+      case 95: /* db_optr ::= db_optr ctime */
+{ yylhsminor.yy478 = yymsp[-1].minor.yy478; yylhsminor.yy478.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy478 = yylhsminor.yy478;
+        break;
+      case 96: /* db_optr ::= db_optr wal */
+      case 109: /* alter_db_optr ::= alter_db_optr wal */ yytestcase(yyruleno==109);
+{ yylhsminor.yy478 = yymsp[-1].minor.yy478; yylhsminor.yy478.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy478 = yylhsminor.yy478;
+        break;
+      case 97: /* db_optr ::= db_optr fsync */
+      case 110: /* alter_db_optr ::= alter_db_optr fsync */ yytestcase(yyruleno==110);
+{ yylhsminor.yy478 = yymsp[-1].minor.yy478; yylhsminor.yy478.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy478 = yylhsminor.yy478;
+        break;
+      case 98: /* db_optr ::= db_optr comp */
+      case 108: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==108);
+{ yylhsminor.yy478 = yymsp[-1].minor.yy478; yylhsminor.yy478.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy478 = yylhsminor.yy478;
+        break;
+      case 99: /* db_optr ::= db_optr prec */
+{ yylhsminor.yy478 = yymsp[-1].minor.yy478; yylhsminor.yy478.precision = yymsp[0].minor.yy0; }
+  yymsp[-1].minor.yy478 = yylhsminor.yy478;
+        break;
+      case 100: /* db_optr ::= db_optr keep */
+      case 106: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==106);
+{ yylhsminor.yy478 = yymsp[-1].minor.yy478; yylhsminor.yy478.keep = yymsp[0].minor.yy403; }
+  yymsp[-1].minor.yy478 = yylhsminor.yy478;
+        break;
+      case 101: /* db_optr ::= db_optr update */
+      case 111: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==111);
+{ yylhsminor.yy478 = yymsp[-1].minor.yy478; yylhsminor.yy478.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy478 = yylhsminor.yy478;
+        break;
+      case 102: /* db_optr ::= db_optr cachelast */
+      case 112: /* alter_db_optr ::= alter_db_optr cachelast */ yytestcase(yyruleno==112);
+{ yylhsminor.yy478 = yymsp[-1].minor.yy478; yylhsminor.yy478.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy478 = yylhsminor.yy478;
+        break;
+      case 103: /* alter_db_optr ::= */
+{ setDefaultCreateDbOption(&yymsp[1].minor.yy478);}
+        break;
+      case 113: /* typename ::= ids */
 { 
   yymsp[0].minor.yy0.type = 0;
-  tSqlSetColumnType(&yylhsminor.yy163, &yymsp[0].minor.yy0);
+  tSqlSetColumnType (&yylhsminor.yy363, &yymsp[0].minor.yy0);
 }
-  yymsp[0].minor.yy163 = yylhsminor.yy163;
+  yymsp[0].minor.yy363 = yylhsminor.yy363;
         break;
-      case 111: /* typename ::= ids LP signed RP */
+      case 114: /* typename ::= ids LP signed RP */
 {
-  if (yymsp[-1].minor.yy459 <= 0) {
+  if (yymsp[-1].minor.yy387 <= 0) {
     yymsp[-3].minor.yy0.type = 0;
-    tSqlSetColumnType(&yylhsminor.yy163, &yymsp[-3].minor.yy0);
+    tSqlSetColumnType(&yylhsminor.yy363, &yymsp[-3].minor.yy0);
   } else {
-    yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy459;  // negative value of name length
-    tSqlSetColumnType(&yylhsminor.yy163, &yymsp[-3].minor.yy0);
+    yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy387;  // negative value of name length
+    tSqlSetColumnType(&yylhsminor.yy363, &yymsp[-3].minor.yy0);
   }
 }
-  yymsp[-3].minor.yy163 = yylhsminor.yy163;
+  yymsp[-3].minor.yy363 = yylhsminor.yy363;
         break;
-      case 112: /* signed ::= INTEGER */
-{ yylhsminor.yy459 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[0].minor.yy459 = yylhsminor.yy459;
+      case 115: /* signed ::= INTEGER */
+{ yylhsminor.yy387 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[0].minor.yy387 = yylhsminor.yy387;
         break;
-      case 113: /* signed ::= PLUS INTEGER */
-{ yymsp[-1].minor.yy459 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+      case 116: /* signed ::= PLUS INTEGER */
+{ yymsp[-1].minor.yy387 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
         break;
-      case 114: /* signed ::= MINUS INTEGER */
-{ yymsp[-1].minor.yy459 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
+      case 117: /* signed ::= MINUS INTEGER */
+{ yymsp[-1].minor.yy387 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
         break;
-      case 116: /* cmd ::= CREATE TABLE create_table_list */
-{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy538;}
+      case 119: /* cmd ::= CREATE TABLE create_table_list */
+{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy436;}
         break;
-      case 117: /* create_table_list ::= create_from_stable */
+      case 120: /* create_table_list ::= create_from_stable */
 {
   SCreateTableSQL* pCreateTable = calloc(1, sizeof(SCreateTableSQL));
   pCreateTable->childTableInfo = taosArrayInit(4, sizeof(SCreatedTableInfo));
 
-  taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy96);
+  taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy84);
   pCreateTable->type = TSQL_CREATE_TABLE_FROM_STABLE;
-  yylhsminor.yy538 = pCreateTable;
+  yylhsminor.yy436 = pCreateTable;
 }
-  yymsp[0].minor.yy538 = yylhsminor.yy538;
+  yymsp[0].minor.yy436 = yylhsminor.yy436;
         break;
-      case 118: /* create_table_list ::= create_table_list create_from_stable */
+      case 121: /* create_table_list ::= create_table_list create_from_stable */
 {
-  taosArrayPush(yymsp[-1].minor.yy538->childTableInfo, &yymsp[0].minor.yy96);
-  yylhsminor.yy538 = yymsp[-1].minor.yy538;
+  taosArrayPush(yymsp[-1].minor.yy436->childTableInfo, &yymsp[0].minor.yy84);
+  yylhsminor.yy436 = yymsp[-1].minor.yy436;
 }
-  yymsp[-1].minor.yy538 = yylhsminor.yy538;
+  yymsp[-1].minor.yy436 = yylhsminor.yy436;
         break;
-      case 119: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
+      case 122: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
 {
-  yylhsminor.yy538 = tSetCreateSqlElems(yymsp[-1].minor.yy131, NULL, NULL, TSQL_CREATE_TABLE);
-  setSqlInfo(pInfo, yylhsminor.yy538, NULL, TSDB_SQL_CREATE_TABLE);
+  yylhsminor.yy436 = tSetCreateSqlElems(yymsp[-1].minor.yy403, NULL, NULL, TSQL_CREATE_TABLE);
+  setSqlInfo(pInfo, yylhsminor.yy436, NULL, TSDB_SQL_CREATE_TABLE);
 
   yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
   setCreatedTableName(pInfo, &yymsp[-4].minor.yy0, &yymsp[-5].minor.yy0);
 }
-  yymsp[-5].minor.yy538 = yylhsminor.yy538;
+  yymsp[-5].minor.yy436 = yylhsminor.yy436;
         break;
-      case 120: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
+      case 123: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
 {
-  yylhsminor.yy538 = tSetCreateSqlElems(yymsp[-5].minor.yy131, yymsp[-1].minor.yy131, NULL, TSQL_CREATE_STABLE);
-  setSqlInfo(pInfo, yylhsminor.yy538, NULL, TSDB_SQL_CREATE_TABLE);
+  yylhsminor.yy436 = tSetCreateSqlElems(yymsp[-5].minor.yy403, yymsp[-1].minor.yy403, NULL, TSQL_CREATE_STABLE);
+  setSqlInfo(pInfo, yylhsminor.yy436, NULL, TSDB_SQL_CREATE_TABLE);
 
   yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
   setCreatedTableName(pInfo, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
 }
-  yymsp[-9].minor.yy538 = yylhsminor.yy538;
+  yymsp[-9].minor.yy436 = yylhsminor.yy436;
         break;
-      case 121: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
+      case 124: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
 {
   yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
   yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
-  yylhsminor.yy96 = createNewChildTableInfo(&yymsp[-5].minor.yy0, yymsp[-1].minor.yy131, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
+  yylhsminor.yy84 = createNewChildTableInfo(&yymsp[-5].minor.yy0, yymsp[-1].minor.yy403, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
 }
-  yymsp[-9].minor.yy96 = yylhsminor.yy96;
+  yymsp[-9].minor.yy84 = yylhsminor.yy84;
         break;
-      case 122: /* create_table_args ::= ifnotexists ids cpxName AS select */
+      case 125: /* create_table_args ::= ifnotexists ids cpxName AS select */
 {
-  yylhsminor.yy538 = tSetCreateSqlElems(NULL, NULL, yymsp[0].minor.yy84, TSQL_CREATE_STREAM);
-  setSqlInfo(pInfo, yylhsminor.yy538, NULL, TSDB_SQL_CREATE_TABLE);
+  yylhsminor.yy436 = tSetCreateSqlElems(NULL, NULL, yymsp[0].minor.yy4, TSQL_CREATE_STREAM);
+  setSqlInfo(pInfo, yylhsminor.yy436, NULL, TSDB_SQL_CREATE_TABLE);
 
   yymsp[-3].minor.yy0.n += yymsp[-2].minor.yy0.n;
   setCreatedTableName(pInfo, &yymsp[-3].minor.yy0, &yymsp[-4].minor.yy0);
 }
-  yymsp[-4].minor.yy538 = yylhsminor.yy538;
+  yymsp[-4].minor.yy436 = yylhsminor.yy436;
         break;
-      case 123: /* columnlist ::= columnlist COMMA column */
-{taosArrayPush(yymsp[-2].minor.yy131, &yymsp[0].minor.yy163); yylhsminor.yy131 = yymsp[-2].minor.yy131;  }
-  yymsp[-2].minor.yy131 = yylhsminor.yy131;
+      case 126: /* columnlist ::= columnlist COMMA column */
+{taosArrayPush(yymsp[-2].minor.yy403, &yymsp[0].minor.yy363); yylhsminor.yy403 = yymsp[-2].minor.yy403;  }
+  yymsp[-2].minor.yy403 = yylhsminor.yy403;
         break;
-      case 124: /* columnlist ::= column */
-{yylhsminor.yy131 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy131, &yymsp[0].minor.yy163);}
-  yymsp[0].minor.yy131 = yylhsminor.yy131;
+      case 127: /* columnlist ::= column */
+{yylhsminor.yy403 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy403, &yymsp[0].minor.yy363);}
+  yymsp[0].minor.yy403 = yylhsminor.yy403;
         break;
-      case 125: /* column ::= ids typename */
+      case 128: /* column ::= ids typename */
 {
-        tSqlSetColumnInfo(&yylhsminor.yy163, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy163);
+  tSqlSetColumnInfo(&yylhsminor.yy363, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy363);
 }
-  yymsp[-1].minor.yy163 = yylhsminor.yy163;
+  yymsp[-1].minor.yy363 = yylhsminor.yy363;
         break;
-      case 126: /* tagitemlist ::= tagitemlist COMMA tagitem */
-{ yylhsminor.yy131 = tVariantListAppend(yymsp[-2].minor.yy131, &yymsp[0].minor.yy516, -1);    }
-  yymsp[-2].minor.yy131 = yylhsminor.yy131;
+      case 129: /* tagitemlist ::= tagitemlist COMMA tagitem */
+{ yylhsminor.yy403 = tVariantListAppend(yymsp[-2].minor.yy403, &yymsp[0].minor.yy488, -1);    }
+  yymsp[-2].minor.yy403 = yylhsminor.yy403;
         break;
-      case 127: /* tagitemlist ::= tagitem */
-{ yylhsminor.yy131 = tVariantListAppend(NULL, &yymsp[0].minor.yy516, -1); }
-  yymsp[0].minor.yy131 = yylhsminor.yy131;
+      case 130: /* tagitemlist ::= tagitem */
+{ yylhsminor.yy403 = tVariantListAppend(NULL, &yymsp[0].minor.yy488, -1); }
+  yymsp[0].minor.yy403 = yylhsminor.yy403;
         break;
-      case 128: /* tagitem ::= INTEGER */
-      case 129: /* tagitem ::= FLOAT */ yytestcase(yyruleno==129);
-      case 130: /* tagitem ::= STRING */ yytestcase(yyruleno==130);
-      case 131: /* tagitem ::= BOOL */ yytestcase(yyruleno==131);
-{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy516, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy516 = yylhsminor.yy516;
+      case 131: /* tagitem ::= INTEGER */
+      case 132: /* tagitem ::= FLOAT */ yytestcase(yyruleno==132);
+      case 133: /* tagitem ::= STRING */ yytestcase(yyruleno==133);
+      case 134: /* tagitem ::= BOOL */ yytestcase(yyruleno==134);
+{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy488, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy488 = yylhsminor.yy488;
         break;
-      case 132: /* tagitem ::= NULL */
-{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy516, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy516 = yylhsminor.yy516;
+      case 135: /* tagitem ::= NULL */
+{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy488, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy488 = yylhsminor.yy488;
         break;
-      case 133: /* tagitem ::= MINUS INTEGER */
-      case 134: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==134);
-      case 135: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==135);
-      case 136: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==136);
+      case 136: /* tagitem ::= MINUS INTEGER */
+      case 137: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==137);
+      case 138: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==138);
+      case 139: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==139);
 {
     yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
     yymsp[-1].minor.yy0.type = yymsp[0].minor.yy0.type;
     toTSDBType(yymsp[-1].minor.yy0.type);
-    tVariantCreate(&yylhsminor.yy516, &yymsp[-1].minor.yy0);
+    tVariantCreate(&yylhsminor.yy488, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy516 = yylhsminor.yy516;
+  yymsp[-1].minor.yy488 = yylhsminor.yy488;
         break;
-      case 137: /* select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
+      case 140: /* select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
 {
-  yylhsminor.yy84 = tSetQuerySqlElems(&yymsp[-11].minor.yy0, yymsp[-10].minor.yy478, yymsp[-9].minor.yy131,
-                                            yymsp[-8].minor.yy420, yymsp[-4].minor.yy131, yymsp[-3].minor.yy131,
-                                            &yymsp[-7].minor.yy530, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy131,
-                                            &yymsp[0].minor.yy284, &yymsp[-1].minor.yy284);
+  yylhsminor.yy4 = tSetQuerySqlElems(&yymsp[-11].minor.yy0, yymsp[-10].minor.yy382, yymsp[-9].minor.yy403, yymsp[-8].minor.yy522, yymsp[-4].minor.yy403, yymsp[-3].minor.yy403, &yymsp[-7].minor.yy222, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy403, &yymsp[0].minor.yy404, &yymsp[-1].minor.yy404);
 }
-  yymsp[-11].minor.yy84 = yylhsminor.yy84;
+  yymsp[-11].minor.yy4 = yylhsminor.yy4;
         break;
-      case 138: /* union ::= select */
-{ yylhsminor.yy513 = setSubclause(NULL, yymsp[0].minor.yy84); }
-  yymsp[0].minor.yy513 = yylhsminor.yy513;
+      case 141: /* union ::= select */
+{ yylhsminor.yy13 = setSubclause(NULL, yymsp[0].minor.yy4); }
+  yymsp[0].minor.yy13 = yylhsminor.yy13;
         break;
-      case 139: /* union ::= LP union RP */
-{ yymsp[-2].minor.yy513 = yymsp[-1].minor.yy513; }
+      case 142: /* union ::= LP union RP */
+{ yymsp[-2].minor.yy13 = yymsp[-1].minor.yy13; }
         break;
-      case 140: /* union ::= union UNION ALL select */
-{ yylhsminor.yy513 = appendSelectClause(yymsp[-3].minor.yy513, yymsp[0].minor.yy84); }
-  yymsp[-3].minor.yy513 = yylhsminor.yy513;
+      case 143: /* union ::= union UNION ALL select */
+{ yylhsminor.yy13 = appendSelectClause(yymsp[-3].minor.yy13, yymsp[0].minor.yy4); }
+  yymsp[-3].minor.yy13 = yylhsminor.yy13;
         break;
-      case 141: /* union ::= union UNION ALL LP select RP */
-{ yylhsminor.yy513 = appendSelectClause(yymsp[-5].minor.yy513, yymsp[-1].minor.yy84); }
-  yymsp[-5].minor.yy513 = yylhsminor.yy513;
+      case 144: /* union ::= union UNION ALL LP select RP */
+{ yylhsminor.yy13 = appendSelectClause(yymsp[-5].minor.yy13, yymsp[-1].minor.yy4); }
+  yymsp[-5].minor.yy13 = yylhsminor.yy13;
         break;
-      case 142: /* cmd ::= union */
-{
-        setSqlInfo(pInfo, yymsp[0].minor.yy513, NULL, TSDB_SQL_SELECT); }
+      case 145: /* cmd ::= union */
+{ setSqlInfo(pInfo, yymsp[0].minor.yy13, NULL, TSDB_SQL_SELECT); }
         break;
-      case 143: /* select ::= SELECT selcollist */
+      case 146: /* select ::= SELECT selcollist */
 {
-  yylhsminor.yy84 = tSetQuerySqlElems(&yymsp[-1].minor.yy0, yymsp[0].minor.yy478, NULL, NULL, NULL, NULL, NULL,
-                                            NULL, NULL, NULL, NULL);
+  yylhsminor.yy4 = tSetQuerySqlElems(&yymsp[-1].minor.yy0, yymsp[0].minor.yy382, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
-  yymsp[-1].minor.yy84 = yylhsminor.yy84;
+  yymsp[-1].minor.yy4 = yylhsminor.yy4;
         break;
-      case 144: /* sclp ::= selcollist COMMA */
-{yylhsminor.yy478 = yymsp[-1].minor.yy478;}
-  yymsp[-1].minor.yy478 = yylhsminor.yy478;
+      case 147: /* sclp ::= selcollist COMMA */
+{yylhsminor.yy382 = yymsp[-1].minor.yy382;}
+  yymsp[-1].minor.yy382 = yylhsminor.yy382;
         break;
-      case 145: /* sclp ::= */
-{yymsp[1].minor.yy478 = 0;}
+      case 148: /* sclp ::= */
+{yymsp[1].minor.yy382 = 0;}
         break;
-      case 146: /* selcollist ::= sclp expr as */
+      case 149: /* selcollist ::= sclp expr as */
 {
-   yylhsminor.yy478 = tSqlExprListAppend(yymsp[-2].minor.yy478, yymsp[-1].minor.yy420,
-                                              yymsp[0].minor.yy0.n ? &yymsp[0].minor.yy0 : 0);
+   yylhsminor.yy382 = tSqlExprListAppend(yymsp[-2].minor.yy382, yymsp[-1].minor.yy522, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
 }
-  yymsp[-2].minor.yy478 = yylhsminor.yy478;
+  yymsp[-2].minor.yy382 = yylhsminor.yy382;
         break;
-      case 147: /* selcollist ::= sclp STAR */
+      case 150: /* selcollist ::= sclp STAR */
 {
    tSQLExpr *pNode = tSqlExprIdValueCreate(NULL, TK_ALL);
-   yylhsminor.yy478 = tSqlExprListAppend(yymsp[-1].minor.yy478, pNode, 0);
+   yylhsminor.yy382 = tSqlExprListAppend(yymsp[-1].minor.yy382, pNode, 0);
 }
-  yymsp[-1].minor.yy478 = yylhsminor.yy478;
+  yymsp[-1].minor.yy382 = yylhsminor.yy382;
         break;
-      case 148: /* as ::= AS ids */
+      case 151: /* as ::= AS ids */
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;    }
         break;
-      case 149: /* as ::= ids */
+      case 152: /* as ::= ids */
 { yylhsminor.yy0 = yymsp[0].minor.yy0;    }
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 150: /* as ::= */
+      case 153: /* as ::= */
 { yymsp[1].minor.yy0.n = 0;  }
         break;
-      case 151: /* from ::= FROM tablelist */
-{yymsp[-1].minor.yy131 = yymsp[0].minor.yy131;}
+      case 154: /* from ::= FROM tablelist */
+{yymsp[-1].minor.yy403 = yymsp[0].minor.yy403;}
         break;
-      case 152: /* tablelist ::= ids cpxName */
+      case 155: /* tablelist ::= ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
-  yylhsminor.yy131 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
-  yylhsminor.yy131 = tVariantListAppendToken(yylhsminor.yy131, &yymsp[-1].minor.yy0, -1);  // table alias name
+  yylhsminor.yy403 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
+  yylhsminor.yy403 = tVariantListAppendToken(yylhsminor.yy403, &yymsp[-1].minor.yy0, -1);  // table alias name
 }
-  yymsp[-1].minor.yy131 = yylhsminor.yy131;
+  yymsp[-1].minor.yy403 = yylhsminor.yy403;
         break;
-      case 153: /* tablelist ::= ids cpxName ids */
+      case 156: /* tablelist ::= ids cpxName ids */
 {
   toTSDBType(yymsp[-2].minor.yy0.type);
   toTSDBType(yymsp[0].minor.yy0.type);
   yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
-  yylhsminor.yy131 = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
-  yylhsminor.yy131 = tVariantListAppendToken(yylhsminor.yy131, &yymsp[0].minor.yy0, -1);
+  yylhsminor.yy403 = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
+  yylhsminor.yy403 = tVariantListAppendToken(yylhsminor.yy403, &yymsp[0].minor.yy0, -1);
 }
-  yymsp[-2].minor.yy131 = yylhsminor.yy131;
+  yymsp[-2].minor.yy403 = yylhsminor.yy403;
         break;
-      case 154: /* tablelist ::= tablelist COMMA ids cpxName */
+      case 157: /* tablelist ::= tablelist COMMA ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
-  yylhsminor.yy131 = tVariantListAppendToken(yymsp[-3].minor.yy131, &yymsp[-1].minor.yy0, -1);
-  yylhsminor.yy131 = tVariantListAppendToken(yylhsminor.yy131, &yymsp[-1].minor.yy0, -1);
+  yylhsminor.yy403 = tVariantListAppendToken(yymsp[-3].minor.yy403, &yymsp[-1].minor.yy0, -1);
+  yylhsminor.yy403 = tVariantListAppendToken(yylhsminor.yy403, &yymsp[-1].minor.yy0, -1);
 }
-  yymsp[-3].minor.yy131 = yylhsminor.yy131;
+  yymsp[-3].minor.yy403 = yylhsminor.yy403;
         break;
-      case 155: /* tablelist ::= tablelist COMMA ids cpxName ids */
+      case 158: /* tablelist ::= tablelist COMMA ids cpxName ids */
 {
   toTSDBType(yymsp[-2].minor.yy0.type);
   toTSDBType(yymsp[0].minor.yy0.type);
   yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
-  yylhsminor.yy131 = tVariantListAppendToken(yymsp[-4].minor.yy131, &yymsp[-2].minor.yy0, -1);
-  yylhsminor.yy131 = tVariantListAppendToken(yylhsminor.yy131, &yymsp[0].minor.yy0, -1);
+  yylhsminor.yy403 = tVariantListAppendToken(yymsp[-4].minor.yy403, &yymsp[-2].minor.yy0, -1);
+  yylhsminor.yy403 = tVariantListAppendToken(yylhsminor.yy403, &yymsp[0].minor.yy0, -1);
 }
-  yymsp[-4].minor.yy131 = yylhsminor.yy131;
+  yymsp[-4].minor.yy403 = yylhsminor.yy403;
         break;
-      case 156: /* tmvar ::= VARIABLE */
+      case 159: /* tmvar ::= VARIABLE */
 {yylhsminor.yy0 = yymsp[0].minor.yy0;}
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 157: /* interval_opt ::= INTERVAL LP tmvar RP */
-{yymsp[-3].minor.yy530.interval = yymsp[-1].minor.yy0; yymsp[-3].minor.yy530.offset.n = 0; yymsp[-3].minor.yy530.offset.z = NULL; yymsp[-3].minor.yy530.offset.type = 0;}
+      case 160: /* interval_opt ::= INTERVAL LP tmvar RP */
+{yymsp[-3].minor.yy222.interval = yymsp[-1].minor.yy0; yymsp[-3].minor.yy222.offset.n = 0; yymsp[-3].minor.yy222.offset.z = NULL; yymsp[-3].minor.yy222.offset.type = 0;}
         break;
-      case 158: /* interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
-{yymsp[-5].minor.yy530.interval = yymsp[-3].minor.yy0; yymsp[-5].minor.yy530.offset = yymsp[-1].minor.yy0;}
+      case 161: /* interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
+{yymsp[-5].minor.yy222.interval = yymsp[-3].minor.yy0; yymsp[-5].minor.yy222.offset = yymsp[-1].minor.yy0;}
         break;
-      case 159: /* interval_opt ::= */
-{memset(&yymsp[1].minor.yy530, 0, sizeof(yymsp[1].minor.yy530));}
+      case 162: /* interval_opt ::= */
+{memset(&yymsp[1].minor.yy222, 0, sizeof(yymsp[1].minor.yy222));}
         break;
-      case 160: /* fill_opt ::= */
-{yymsp[1].minor.yy131 = 0;     }
+      case 163: /* fill_opt ::= */
+{yymsp[1].minor.yy403 = 0;     }
         break;
-      case 161: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+      case 164: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
 {
     tVariant A = {0};
     toTSDBType(yymsp[-3].minor.yy0.type);
     tVariantCreate(&A, &yymsp[-3].minor.yy0);
 
-    tVariantListInsert(yymsp[-1].minor.yy131, &A, -1, 0);
-    yymsp[-5].minor.yy131 = yymsp[-1].minor.yy131;
+    tVariantListInsert(yymsp[-1].minor.yy403, &A, -1, 0);
+    yymsp[-5].minor.yy403 = yymsp[-1].minor.yy403;
 }
         break;
-      case 162: /* fill_opt ::= FILL LP ID RP */
+      case 165: /* fill_opt ::= FILL LP ID RP */
 {
     toTSDBType(yymsp[-1].minor.yy0.type);
-    yymsp[-3].minor.yy131 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
+    yymsp[-3].minor.yy403 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
 }
         break;
-      case 163: /* sliding_opt ::= SLIDING LP tmvar RP */
+      case 166: /* sliding_opt ::= SLIDING LP tmvar RP */
 {yymsp[-3].minor.yy0 = yymsp[-1].minor.yy0;     }
         break;
-      case 164: /* sliding_opt ::= */
+      case 167: /* sliding_opt ::= */
 {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0;   }
         break;
-      case 165: /* orderby_opt ::= */
-{yymsp[1].minor.yy131 = 0;}
+      case 168: /* orderby_opt ::= */
+{yymsp[1].minor.yy403 = 0;}
         break;
-      case 166: /* orderby_opt ::= ORDER BY sortlist */
-{yymsp[-2].minor.yy131 = yymsp[0].minor.yy131;}
+      case 169: /* orderby_opt ::= ORDER BY sortlist */
+{yymsp[-2].minor.yy403 = yymsp[0].minor.yy403;}
         break;
-      case 167: /* sortlist ::= sortlist COMMA item sortorder */
+      case 170: /* sortlist ::= sortlist COMMA item sortorder */
 {
-    yylhsminor.yy131 = tVariantListAppend(yymsp[-3].minor.yy131, &yymsp[-1].minor.yy516, yymsp[0].minor.yy42);
+    yylhsminor.yy403 = tVariantListAppend(yymsp[-3].minor.yy403, &yymsp[-1].minor.yy488, yymsp[0].minor.yy70);
 }
-  yymsp[-3].minor.yy131 = yylhsminor.yy131;
+  yymsp[-3].minor.yy403 = yylhsminor.yy403;
         break;
-      case 168: /* sortlist ::= item sortorder */
+      case 171: /* sortlist ::= item sortorder */
 {
-  yylhsminor.yy131 = tVariantListAppend(NULL, &yymsp[-1].minor.yy516, yymsp[0].minor.yy42);
+  yylhsminor.yy403 = tVariantListAppend(NULL, &yymsp[-1].minor.yy488, yymsp[0].minor.yy70);
 }
-  yymsp[-1].minor.yy131 = yylhsminor.yy131;
+  yymsp[-1].minor.yy403 = yylhsminor.yy403;
         break;
-      case 169: /* item ::= ids cpxName */
+      case 172: /* item ::= ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
 
-  tVariantCreate(&yylhsminor.yy516, &yymsp[-1].minor.yy0);
+  tVariantCreate(&yylhsminor.yy488, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy516 = yylhsminor.yy516;
+  yymsp[-1].minor.yy488 = yylhsminor.yy488;
         break;
-      case 170: /* sortorder ::= ASC */
-{ yymsp[0].minor.yy42 = TSDB_ORDER_ASC; }
+      case 173: /* sortorder ::= ASC */
+{ yymsp[0].minor.yy70 = TSDB_ORDER_ASC; }
         break;
-      case 171: /* sortorder ::= DESC */
-{ yymsp[0].minor.yy42 = TSDB_ORDER_DESC;}
+      case 174: /* sortorder ::= DESC */
+{ yymsp[0].minor.yy70 = TSDB_ORDER_DESC;}
         break;
-      case 172: /* sortorder ::= */
-{ yymsp[1].minor.yy42 = TSDB_ORDER_ASC; }
+      case 175: /* sortorder ::= */
+{ yymsp[1].minor.yy70 = TSDB_ORDER_ASC; }
         break;
-      case 173: /* groupby_opt ::= */
-{ yymsp[1].minor.yy131 = 0;}
+      case 176: /* groupby_opt ::= */
+{ yymsp[1].minor.yy403 = 0;}
         break;
-      case 174: /* groupby_opt ::= GROUP BY grouplist */
-{ yymsp[-2].minor.yy131 = yymsp[0].minor.yy131;}
+      case 177: /* groupby_opt ::= GROUP BY grouplist */
+{ yymsp[-2].minor.yy403 = yymsp[0].minor.yy403;}
         break;
-      case 175: /* grouplist ::= grouplist COMMA item */
+      case 178: /* grouplist ::= grouplist COMMA item */
 {
-  yylhsminor.yy131 = tVariantListAppend(yymsp[-2].minor.yy131, &yymsp[0].minor.yy516, -1);
+  yylhsminor.yy403 = tVariantListAppend(yymsp[-2].minor.yy403, &yymsp[0].minor.yy488, -1);
 }
-  yymsp[-2].minor.yy131 = yylhsminor.yy131;
+  yymsp[-2].minor.yy403 = yylhsminor.yy403;
         break;
-      case 176: /* grouplist ::= item */
+      case 179: /* grouplist ::= item */
 {
-  yylhsminor.yy131 = tVariantListAppend(NULL, &yymsp[0].minor.yy516, -1);
+  yylhsminor.yy403 = tVariantListAppend(NULL, &yymsp[0].minor.yy488, -1);
 }
-  yymsp[0].minor.yy131 = yylhsminor.yy131;
+  yymsp[0].minor.yy403 = yylhsminor.yy403;
         break;
-      case 177: /* having_opt ::= */
-      case 187: /* where_opt ::= */ yytestcase(yyruleno==187);
-      case 225: /* expritem ::= */ yytestcase(yyruleno==225);
-{yymsp[1].minor.yy420 = 0;}
+      case 180: /* having_opt ::= */
+      case 190: /* where_opt ::= */ yytestcase(yyruleno==190);
+      case 228: /* expritem ::= */ yytestcase(yyruleno==228);
+{yymsp[1].minor.yy522 = 0;}
         break;
-      case 178: /* having_opt ::= HAVING expr */
-      case 188: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==188);
-{yymsp[-1].minor.yy420 = yymsp[0].minor.yy420;}
+      case 181: /* having_opt ::= HAVING expr */
+      case 191: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==191);
+{yymsp[-1].minor.yy522 = yymsp[0].minor.yy522;}
         break;
-      case 179: /* limit_opt ::= */
-      case 183: /* slimit_opt ::= */ yytestcase(yyruleno==183);
-{yymsp[1].minor.yy284.limit = -1; yymsp[1].minor.yy284.offset = 0;}
+      case 182: /* limit_opt ::= */
+      case 186: /* slimit_opt ::= */ yytestcase(yyruleno==186);
+{yymsp[1].minor.yy404.limit = -1; yymsp[1].minor.yy404.offset = 0;}
         break;
-      case 180: /* limit_opt ::= LIMIT signed */
-      case 184: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==184);
-{yymsp[-1].minor.yy284.limit = yymsp[0].minor.yy459;  yymsp[-1].minor.yy284.offset = 0;}
+      case 183: /* limit_opt ::= LIMIT signed */
+      case 187: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==187);
+{yymsp[-1].minor.yy404.limit = yymsp[0].minor.yy387;  yymsp[-1].minor.yy404.offset = 0;}
         break;
-      case 181: /* limit_opt ::= LIMIT signed OFFSET signed */
-{ yymsp[-3].minor.yy284.limit = yymsp[-2].minor.yy459;  yymsp[-3].minor.yy284.offset = yymsp[0].minor.yy459;}
+      case 184: /* limit_opt ::= LIMIT signed OFFSET signed */
+{ yymsp[-3].minor.yy404.limit = yymsp[-2].minor.yy387;  yymsp[-3].minor.yy404.offset = yymsp[0].minor.yy387;}
         break;
-      case 182: /* limit_opt ::= LIMIT signed COMMA signed */
-{ yymsp[-3].minor.yy284.limit = yymsp[0].minor.yy459;  yymsp[-3].minor.yy284.offset = yymsp[-2].minor.yy459;}
+      case 185: /* limit_opt ::= LIMIT signed COMMA signed */
+{ yymsp[-3].minor.yy404.limit = yymsp[0].minor.yy387;  yymsp[-3].minor.yy404.offset = yymsp[-2].minor.yy387;}
         break;
-      case 185: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
-{yymsp[-3].minor.yy284.limit = yymsp[-2].minor.yy459;  yymsp[-3].minor.yy284.offset = yymsp[0].minor.yy459;}
+      case 188: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
+{yymsp[-3].minor.yy404.limit = yymsp[-2].minor.yy387;  yymsp[-3].minor.yy404.offset = yymsp[0].minor.yy387;}
         break;
-      case 186: /* slimit_opt ::= SLIMIT signed COMMA signed */
-{yymsp[-3].minor.yy284.limit = yymsp[0].minor.yy459;  yymsp[-3].minor.yy284.offset = yymsp[-2].minor.yy459;}
+      case 189: /* slimit_opt ::= SLIMIT signed COMMA signed */
+{yymsp[-3].minor.yy404.limit = yymsp[0].minor.yy387;  yymsp[-3].minor.yy404.offset = yymsp[-2].minor.yy387;}
         break;
-      case 189: /* expr ::= LP expr RP */
-{yylhsminor.yy420 = yymsp[-1].minor.yy420; yylhsminor.yy420->token.z = yymsp[-2].minor.yy0.z; yylhsminor.yy420->token.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
-  yymsp[-2].minor.yy420 = yylhsminor.yy420;
+      case 192: /* expr ::= LP expr RP */
+{yylhsminor.yy522 = yymsp[-1].minor.yy522; yylhsminor.yy522->token.z = yymsp[-2].minor.yy0.z; yylhsminor.yy522->token.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
+  yymsp[-2].minor.yy522 = yylhsminor.yy522;
         break;
-      case 190: /* expr ::= ID */
-{ yylhsminor.yy420 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_ID);}
-  yymsp[0].minor.yy420 = yylhsminor.yy420;
+      case 193: /* expr ::= ID */
+{ yylhsminor.yy522 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_ID);}
+  yymsp[0].minor.yy522 = yylhsminor.yy522;
         break;
-      case 191: /* expr ::= ID DOT ID */
-{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy420 = tSqlExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ID);}
-  yymsp[-2].minor.yy420 = yylhsminor.yy420;
+      case 194: /* expr ::= ID DOT ID */
+{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy522 = tSqlExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ID);}
+  yymsp[-2].minor.yy522 = yylhsminor.yy522;
         break;
-      case 192: /* expr ::= ID DOT STAR */
-{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy420 = tSqlExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ALL);}
-  yymsp[-2].minor.yy420 = yylhsminor.yy420;
+      case 195: /* expr ::= ID DOT STAR */
+{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy522 = tSqlExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ALL);}
+  yymsp[-2].minor.yy522 = yylhsminor.yy522;
         break;
-      case 193: /* expr ::= INTEGER */
-{ yylhsminor.yy420 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_INTEGER);}
-  yymsp[0].minor.yy420 = yylhsminor.yy420;
+      case 196: /* expr ::= INTEGER */
+{ yylhsminor.yy522 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_INTEGER);}
+  yymsp[0].minor.yy522 = yylhsminor.yy522;
         break;
-      case 194: /* expr ::= MINUS INTEGER */
-      case 195: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==195);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy420 = tSqlExprIdValueCreate(&yymsp[-1].minor.yy0, TK_INTEGER);}
-  yymsp[-1].minor.yy420 = yylhsminor.yy420;
+      case 197: /* expr ::= MINUS INTEGER */
+      case 198: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==198);
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy522 = tSqlExprIdValueCreate(&yymsp[-1].minor.yy0, TK_INTEGER);}
+  yymsp[-1].minor.yy522 = yylhsminor.yy522;
         break;
-      case 196: /* expr ::= FLOAT */
-{ yylhsminor.yy420 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_FLOAT);}
-  yymsp[0].minor.yy420 = yylhsminor.yy420;
+      case 199: /* expr ::= FLOAT */
+{ yylhsminor.yy522 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_FLOAT);}
+  yymsp[0].minor.yy522 = yylhsminor.yy522;
         break;
-      case 197: /* expr ::= MINUS FLOAT */
-      case 198: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==198);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy420 = tSqlExprIdValueCreate(&yymsp[-1].minor.yy0, TK_FLOAT);}
-  yymsp[-1].minor.yy420 = yylhsminor.yy420;
+      case 200: /* expr ::= MINUS FLOAT */
+      case 201: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==201);
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy522 = tSqlExprIdValueCreate(&yymsp[-1].minor.yy0, TK_FLOAT);}
+  yymsp[-1].minor.yy522 = yylhsminor.yy522;
         break;
-      case 199: /* expr ::= STRING */
-{ yylhsminor.yy420 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_STRING);}
-  yymsp[0].minor.yy420 = yylhsminor.yy420;
+      case 202: /* expr ::= STRING */
+{ yylhsminor.yy522 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_STRING);}
+  yymsp[0].minor.yy522 = yylhsminor.yy522;
         break;
-      case 200: /* expr ::= NOW */
-{ yylhsminor.yy420 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_NOW); }
-  yymsp[0].minor.yy420 = yylhsminor.yy420;
+      case 203: /* expr ::= NOW */
+{ yylhsminor.yy522 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_NOW); }
+  yymsp[0].minor.yy522 = yylhsminor.yy522;
         break;
-      case 201: /* expr ::= VARIABLE */
-{ yylhsminor.yy420 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_VARIABLE);}
-  yymsp[0].minor.yy420 = yylhsminor.yy420;
+      case 204: /* expr ::= VARIABLE */
+{ yylhsminor.yy522 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_VARIABLE);}
+  yymsp[0].minor.yy522 = yylhsminor.yy522;
         break;
-      case 202: /* expr ::= BOOL */
-{ yylhsminor.yy420 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_BOOL);}
-  yymsp[0].minor.yy420 = yylhsminor.yy420;
+      case 205: /* expr ::= BOOL */
+{ yylhsminor.yy522 = tSqlExprIdValueCreate(&yymsp[0].minor.yy0, TK_BOOL);}
+  yymsp[0].minor.yy522 = yylhsminor.yy522;
         break;
-      case 203: /* expr ::= ID LP exprlist RP */
-{ yylhsminor.yy420 = tSqlExprCreateFunction(yymsp[-1].minor.yy478, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0,
-                                                  yymsp[-3].minor.yy0.type); }
-  yymsp[-3].minor.yy420 = yylhsminor.yy420;
+      case 206: /* expr ::= ID LP exprlist RP */
+{ yylhsminor.yy522 = tSqlExprCreateFunction(yymsp[-1].minor.yy382, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
+  yymsp[-3].minor.yy522 = yylhsminor.yy522;
         break;
-      case 204: /* expr ::= ID LP STAR RP */
-{ yylhsminor.yy420 =
-            tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
-  yymsp[-3].minor.yy420 = yylhsminor.yy420;
+      case 207: /* expr ::= ID LP STAR RP */
+{ yylhsminor.yy522 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
+  yymsp[-3].minor.yy522 = yylhsminor.yy522;
         break;
-      case 205: /* expr ::= expr IS NULL */
-{yylhsminor.yy420 = tSqlExprCreate(yymsp[-2].minor.yy420, NULL, TK_ISNULL);}
-  yymsp[-2].minor.yy420 = yylhsminor.yy420;
+      case 208: /* expr ::= expr IS NULL */
+{yylhsminor.yy522 = tSqlExprCreate(yymsp[-2].minor.yy522, NULL, TK_ISNULL);}
+  yymsp[-2].minor.yy522 = yylhsminor.yy522;
         break;
-      case 206: /* expr ::= expr IS NOT NULL */
-{yylhsminor.yy420 = tSqlExprCreate(yymsp[-3].minor.yy420, NULL, TK_NOTNULL);}
-  yymsp[-3].minor.yy420 = yylhsminor.yy420;
+      case 209: /* expr ::= expr IS NOT NULL */
+{yylhsminor.yy522 = tSqlExprCreate(yymsp[-3].minor.yy522, NULL, TK_NOTNULL);}
+  yymsp[-3].minor.yy522 = yylhsminor.yy522;
         break;
-      case 207: /* expr ::= expr LT expr */
-{yylhsminor.yy420 = tSqlExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_LT);}
-  yymsp[-2].minor.yy420 = yylhsminor.yy420;
+      case 210: /* expr ::= expr LT expr */
+{yylhsminor.yy522 = tSqlExprCreate(yymsp[-2].minor.yy522, yymsp[0].minor.yy522, TK_LT);}
+  yymsp[-2].minor.yy522 = yylhsminor.yy522;
         break;
-      case 208: /* expr ::= expr GT expr */
-{yylhsminor.yy420 = tSqlExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_GT);}
-  yymsp[-2].minor.yy420 = yylhsminor.yy420;
+      case 211: /* expr ::= expr GT expr */
+{yylhsminor.yy522 = tSqlExprCreate(yymsp[-2].minor.yy522, yymsp[0].minor.yy522, TK_GT);}
+  yymsp[-2].minor.yy522 = yylhsminor.yy522;
         break;
-      case 209: /* expr ::= expr LE expr */
-{yylhsminor.yy420 = tSqlExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_LE);}
-  yymsp[-2].minor.yy420 = yylhsminor.yy420;
+      case 212: /* expr ::= expr LE expr */
+{yylhsminor.yy522 = tSqlExprCreate(yymsp[-2].minor.yy522, yymsp[0].minor.yy522, TK_LE);}
+  yymsp[-2].minor.yy522 = yylhsminor.yy522;
         break;
-      case 210: /* expr ::= expr GE expr */
-{yylhsminor.yy420 = tSqlExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_GE);}
-  yymsp[-2].minor.yy420 = yylhsminor.yy420;
+      case 213: /* expr ::= expr GE expr */
+{yylhsminor.yy522 = tSqlExprCreate(yymsp[-2].minor.yy522, yymsp[0].minor.yy522, TK_GE);}
+  yymsp[-2].minor.yy522 = yylhsminor.yy522;
         break;
-      case 211: /* expr ::= expr NE expr */
-{yylhsminor.yy420 = tSqlExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_NE);}
-  yymsp[-2].minor.yy420 = yylhsminor.yy420;
+      case 214: /* expr ::= expr NE expr */
+{yylhsminor.yy522 = tSqlExprCreate(yymsp[-2].minor.yy522, yymsp[0].minor.yy522, TK_NE);}
+  yymsp[-2].minor.yy522 = yylhsminor.yy522;
         break;
-      case 212: /* expr ::= expr EQ expr */
-{yylhsminor.yy420 = tSqlExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_EQ);}
-  yymsp[-2].minor.yy420 = yylhsminor.yy420;
+      case 215: /* expr ::= expr EQ expr */
+{yylhsminor.yy522 = tSqlExprCreate(yymsp[-2].minor.yy522, yymsp[0].minor.yy522, TK_EQ);}
+  yymsp[-2].minor.yy522 = yylhsminor.yy522;
         break;
-      case 213: /* expr ::= expr AND expr */
-{yylhsminor.yy420 = tSqlExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_AND);}
-  yymsp[-2].minor.yy420 = yylhsminor.yy420;
+      case 216: /* expr ::= expr AND expr */
+{yylhsminor.yy522 = tSqlExprCreate(yymsp[-2].minor.yy522, yymsp[0].minor.yy522, TK_AND);}
+  yymsp[-2].minor.yy522 = yylhsminor.yy522;
         break;
-      case 214: /* expr ::= expr OR expr */
-{yylhsminor.yy420 = tSqlExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_OR); }
-  yymsp[-2].minor.yy420 = yylhsminor.yy420;
+      case 217: /* expr ::= expr OR expr */
+{yylhsminor.yy522 = tSqlExprCreate(yymsp[-2].minor.yy522, yymsp[0].minor.yy522, TK_OR); }
+  yymsp[-2].minor.yy522 = yylhsminor.yy522;
         break;
-      case 215: /* expr ::= expr PLUS expr */
-{yylhsminor.yy420 = tSqlExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_PLUS);  }
-  yymsp[-2].minor.yy420 = yylhsminor.yy420;
+      case 218: /* expr ::= expr PLUS expr */
+{yylhsminor.yy522 = tSqlExprCreate(yymsp[-2].minor.yy522, yymsp[0].minor.yy522, TK_PLUS);  }
+  yymsp[-2].minor.yy522 = yylhsminor.yy522;
         break;
-      case 216: /* expr ::= expr MINUS expr */
-{yylhsminor.yy420 = tSqlExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_MINUS); }
-  yymsp[-2].minor.yy420 = yylhsminor.yy420;
+      case 219: /* expr ::= expr MINUS expr */
+{yylhsminor.yy522 = tSqlExprCreate(yymsp[-2].minor.yy522, yymsp[0].minor.yy522, TK_MINUS); }
+  yymsp[-2].minor.yy522 = yylhsminor.yy522;
         break;
-      case 217: /* expr ::= expr STAR expr */
-{yylhsminor.yy420 = tSqlExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_STAR);  }
-  yymsp[-2].minor.yy420 = yylhsminor.yy420;
+      case 220: /* expr ::= expr STAR expr */
+{yylhsminor.yy522 = tSqlExprCreate(yymsp[-2].minor.yy522, yymsp[0].minor.yy522, TK_STAR);  }
+  yymsp[-2].minor.yy522 = yylhsminor.yy522;
         break;
-      case 218: /* expr ::= expr SLASH expr */
-{yylhsminor.yy420 = tSqlExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_DIVIDE);}
-  yymsp[-2].minor.yy420 = yylhsminor.yy420;
+      case 221: /* expr ::= expr SLASH expr */
+{yylhsminor.yy522 = tSqlExprCreate(yymsp[-2].minor.yy522, yymsp[0].minor.yy522, TK_DIVIDE);}
+  yymsp[-2].minor.yy522 = yylhsminor.yy522;
         break;
-      case 219: /* expr ::= expr REM expr */
-{yylhsminor.yy420 = tSqlExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_REM);   }
-  yymsp[-2].minor.yy420 = yylhsminor.yy420;
+      case 222: /* expr ::= expr REM expr */
+{yylhsminor.yy522 = tSqlExprCreate(yymsp[-2].minor.yy522, yymsp[0].minor.yy522, TK_REM);   }
+  yymsp[-2].minor.yy522 = yylhsminor.yy522;
         break;
-      case 220: /* expr ::= expr LIKE expr */
-{yylhsminor.yy420 = tSqlExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_LIKE);  }
-  yymsp[-2].minor.yy420 = yylhsminor.yy420;
+      case 223: /* expr ::= expr LIKE expr */
+{yylhsminor.yy522 = tSqlExprCreate(yymsp[-2].minor.yy522, yymsp[0].minor.yy522, TK_LIKE);  }
+  yymsp[-2].minor.yy522 = yylhsminor.yy522;
         break;
-      case 221: /* expr ::= expr IN LP exprlist RP */
-{yylhsminor.yy420 = tSqlExprCreate(yymsp[-4].minor.yy420, (tSQLExpr *)yymsp[-1].minor.yy478, TK_IN); }
-  yymsp[-4].minor.yy420 = yylhsminor.yy420;
+      case 224: /* expr ::= expr IN LP exprlist RP */
+{yylhsminor.yy522 = tSqlExprCreate(yymsp[-4].minor.yy522, (tSQLExpr*)yymsp[-1].minor.yy382, TK_IN); }
+  yymsp[-4].minor.yy522 = yylhsminor.yy522;
         break;
-      case 222: /* exprlist ::= exprlist COMMA expritem */
-{yylhsminor.yy478 = tSqlExprListAppend(yymsp[-2].minor.yy478, yymsp[0].minor.yy420, 0);}
-  yymsp[-2].minor.yy478 = yylhsminor.yy478;
+      case 225: /* exprlist ::= exprlist COMMA expritem */
+{yylhsminor.yy382 = tSqlExprListAppend(yymsp[-2].minor.yy382,yymsp[0].minor.yy522,0);}
+  yymsp[-2].minor.yy382 = yylhsminor.yy382;
         break;
-      case 223: /* exprlist ::= expritem */
-{yylhsminor.yy478 = tSqlExprListAppend(0, yymsp[0].minor.yy420, 0);}
-  yymsp[0].minor.yy478 = yylhsminor.yy478;
+      case 226: /* exprlist ::= expritem */
+{yylhsminor.yy382 = tSqlExprListAppend(0,yymsp[0].minor.yy522,0);}
+  yymsp[0].minor.yy382 = yylhsminor.yy382;
         break;
-      case 224: /* expritem ::= expr */
-{yylhsminor.yy420 = yymsp[0].minor.yy420;}
-  yymsp[0].minor.yy420 = yylhsminor.yy420;
+      case 227: /* expritem ::= expr */
+{yylhsminor.yy522 = yymsp[0].minor.yy522;}
+  yymsp[0].minor.yy522 = yylhsminor.yy522;
         break;
-      case 226: /* cmd ::= RESET QUERY CACHE */
+      case 229: /* cmd ::= RESET QUERY CACHE */
 { setDCLSQLElems(pInfo, TSDB_SQL_RESET_CACHE, 0);}
         break;
-      case 227: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+      case 230: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableSQL* pAlterTable =
-        tAlterTableSqlElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy131, NULL, TSDB_ALTER_TABLE_ADD_COLUMN);
+    SAlterTableSQL* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy403, NULL, TSDB_ALTER_TABLE_ADD_COLUMN);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 228: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+      case 231: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -2868,15 +2868,14 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 229: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+      case 232: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableSQL* pAlterTable =
-        tAlterTableSqlElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy131, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN);
+    SAlterTableSQL* pAlterTable = tAlterTableSqlElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy403, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 230: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+      case 233: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -2887,7 +2886,7 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 231: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+      case 234: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
 {
     yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
 
@@ -2897,34 +2896,30 @@ static void yy_reduce(
     toTSDBType(yymsp[0].minor.yy0.type);
     A = tVariantListAppendToken(A, &yymsp[0].minor.yy0, -1);
 
-    SAlterTableSQL* pAlterTable =
-        tAlterTableSqlElems(&yymsp[-5].minor.yy0, NULL, A, TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN);
+    SAlterTableSQL* pAlterTable = tAlterTableSqlElems(&yymsp[-5].minor.yy0, NULL, A, TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 232: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+      case 235: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
 {
     yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n;
 
     toTSDBType(yymsp[-2].minor.yy0.type);
     SArray* A = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
-    A = tVariantListAppend(A, &yymsp[0].minor.yy516, -1);
+    A = tVariantListAppend(A, &yymsp[0].minor.yy488, -1);
 
     SAlterTableSQL* pAlterTable = tAlterTableSqlElems(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 233: /* cmd ::= KILL CONNECTION INTEGER */
-{
-        setKillSql(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);}
+      case 236: /* cmd ::= KILL CONNECTION INTEGER */
+{setKillSql(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);}
         break;
-      case 234: /* 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);}
+      case 237: /* 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 235: /* 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);}
+      case 238: /* 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;

src/tsdb/inc/tsdbMain.h

@@ -66,7 +66,8 @@ typedef struct STable {
   SSkipList*     pIndex;         // For TSDB_SUPER_TABLE, it is the skiplist index
   void*          eventHandler;   // TODO
   void*          streamHandler;  // TODO
-  TSKEY          lastKey;        // lastkey inserted in this table, initialized as 0, TODO: make a structure
+  TSKEY          lastKey;
+  SDataRow       lastRow;
   char*          sql;
   void*          cqhandle;
   SRWLatch       latch;  // TODO: implementa latch functions
@@ -360,8 +361,11 @@ typedef struct {
 #define TABLE_UID(t) (t)->tableId.uid
 #define TABLE_TID(t) (t)->tableId.tid
 #define TABLE_SUID(t) (t)->suid
-#define TABLE_LASTKEY(t) (t)->lastKey
 #define TSDB_META_FILE_MAGIC(m) KVSTORE_MAGIC((m)->pStore)
+#define TSDB_RLOCK_TABLE(t) taosRLockLatch(&((t)->latch))
+#define TSDB_RUNLOCK_TABLE(t) taosRUnLockLatch(&((t)->latch))
+#define TSDB_WLOCK_TABLE(t) taosWLockLatch(&((t)->latch))
+#define TSDB_WUNLOCK_TABLE(t) taosWUnLockLatch(&((t)->latch))
 
 STsdbMeta* tsdbNewMeta(STsdbCfg* pCfg);
 void       tsdbFreeMeta(STsdbMeta* pMeta);
@@ -391,7 +395,7 @@ static FORCE_INLINE STSchema* tsdbGetTableSchemaImpl(STable* pTable, bool lock,
   STSchema* pSchema = NULL;
   STSchema* pTSchema = NULL;
 
-  if (lock) taosRLockLatch(&(pDTable->latch));
+  if (lock) TSDB_RLOCK_TABLE(pDTable);
   if (version < 0) {  // get the latest version of schema
     pTSchema = pDTable->schema[pDTable->numOfSchemas - 1];
   } else {  // get the schema with version
@@ -413,7 +417,7 @@ static FORCE_INLINE STSchema* tsdbGetTableSchemaImpl(STable* pTable, bool lock,
   }
 
 _exit:
-  if (lock) taosRUnLockLatch(&(pDTable->latch));
+  if (lock) TSDB_RUNLOCK_TABLE(pDTable);
   return pSchema;
 }
 
@@ -433,6 +437,11 @@ static FORCE_INLINE STSchema *tsdbGetTableTagSchema(STable *pTable) {
   }
 }
 
+static FORCE_INLINE TSKEY tsdbGetTableLastKeyImpl(STable* pTable) {
+  ASSERT(pTable->lastRow == NULL || pTable->lastKey == dataRowKey(pTable->lastRow));
+  return pTable->lastKey;
+}
+
 // ------------------ tsdbBuffer.c
 #define TSDB_BUFFER_RESERVE 1024  // Reseve 1K as commit threshold
 

src/tsdb/src/tsdbCommit.c

@@ -225,7 +225,7 @@ static int tsdbCommitToFile(STsdbRepo *pRepo, int fid, SCommitIter *iters, SRWHe
     SCommitIter *pIter = iters + tid;
     if (pIter->pTable == NULL) continue;
 
-    taosRLockLatch(&(pIter->pTable->latch));
+    TSDB_RLOCK_TABLE(pIter->pTable);
 
     if (tsdbSetHelperTable(pHelper, pIter->pTable, pRepo) < 0) goto _err;
 
@@ -236,7 +236,7 @@ static int tsdbCommitToFile(STsdbRepo *pRepo, int fid, SCommitIter *iters, SRWHe
       }
 
       if (tsdbCommitTableData(pHelper, pIter, pDataCols, maxKey) < 0) {
-        taosRUnLockLatch(&(pIter->pTable->latch));
+        TSDB_RUNLOCK_TABLE(pIter->pTable);
         tsdbError("vgId:%d failed to write data of table %s tid %d uid %" PRIu64 " since %s", REPO_ID(pRepo),
                   TABLE_CHAR_NAME(pIter->pTable), TABLE_TID(pIter->pTable), TABLE_UID(pIter->pTable),
                   tstrerror(terrno));
@@ -244,7 +244,7 @@ static int tsdbCommitToFile(STsdbRepo *pRepo, int fid, SCommitIter *iters, SRWHe
       }
     }
 
-    taosRUnLockLatch(&(pIter->pTable->latch));
+    TSDB_RUNLOCK_TABLE(pIter->pTable);
 
     // Move the last block to the new .l file if neccessary
     if (tsdbMoveLastBlockIfNeccessary(pHelper) < 0) {

src/tsdb/src/tsdbMain.c

@@ -77,9 +77,9 @@ int32_t tsdbCreateRepo(char *rootDir, STsdbCfg *pCfg) {
 
   tsdbDebug(
       "vgId:%d tsdb env create succeed! cacheBlockSize %d totalBlocks %d daysPerFile %d keep "
-      "%d minRowsPerFileBlock %d maxRowsPerFileBlock %d precision %d compression %d",
+      "%d minRowsPerFileBlock %d maxRowsPerFileBlock %d precision %d compression %d update %d cacheLastRow %d",
       pCfg->tsdbId, pCfg->cacheBlockSize, pCfg->totalBlocks, pCfg->daysPerFile, pCfg->keep, pCfg->minRowsPerFileBlock,
-      pCfg->maxRowsPerFileBlock, pCfg->precision, pCfg->compression);
+      pCfg->maxRowsPerFileBlock, pCfg->precision, pCfg->compression, pCfg->update, pCfg->cacheLastRow);
   return 0;
 }
 
@@ -281,6 +281,10 @@ int32_t tsdbConfigRepo(TSDB_REPO_T *repo, STsdbCfg *pCfg) {
     config.totalBlocks = pCfg->totalBlocks;
     configChanged = true;
   }
+  if (pRCfg->cacheLastRow != pCfg->cacheLastRow) {
+    config.cacheLastRow = pCfg->cacheLastRow;
+    configChanged = true;
+  }
 
   if (configChanged) {
     if (tsdbSaveConfig(pRepo->rootDir, &config) < 0) {
@@ -475,6 +479,9 @@ static int32_t tsdbCheckAndSetDefaultCfg(STsdbCfg *pCfg) {
   // update check
   if (pCfg->update != 0) pCfg->update = 1;
 
+  // update cacheLastRow
+  if (pCfg->cacheLastRow != 0) pCfg->cacheLastRow = 1;
+
   return 0;
 
 _err:
@@ -692,10 +699,12 @@ static void tsdbFreeRepo(STsdbRepo *pRepo) {
   }
 }
 
-static int tsdbRestoreInfo(STsdbRepo *pRepo) {
+static int tsdbRestoreInfo(STsdbRepo *pRepo) { // TODO
   STsdbMeta * pMeta = pRepo->tsdbMeta;
   STsdbFileH *pFileH = pRepo->tsdbFileH;
   SFileGroup *pFGroup = NULL;
+  STsdbCfg *  pCfg = &(pRepo->config);
+  SCompBlock *pBlock = NULL;
 
   SFileGroupIter iter;
   SRWHelper      rhelper = {0};
@@ -713,7 +722,32 @@ static int tsdbRestoreInfo(STsdbRepo *pRepo) {
       if (tsdbSetHelperTable(&rhelper, pTable, pRepo) < 0) goto _err;
       SCompIdx *pIdx = &(rhelper.curCompIdx);
 
-      if (pIdx->offset > 0 && pTable->lastKey < pIdx->maxKey) pTable->lastKey = pIdx->maxKey;
+      TSKEY lastKey = tsdbGetTableLastKeyImpl(pTable);
+      if (pIdx->offset > 0 && lastKey < pIdx->maxKey) {
+        pTable->lastKey = pIdx->maxKey;
+        if (pCfg->cacheLastRow) { // load the block of data
+          if (tsdbLoadCompInfo(&rhelper, NULL) < 0) goto _err;
+
+          pBlock = rhelper.pCompInfo->blocks + pIdx->numOfBlocks - 1;
+          if (tsdbLoadBlockData(&rhelper, pBlock, NULL) < 0) goto _err;
+
+          // construct the data row
+          ASSERT(pTable->lastRow == NULL);
+          STSchema *pSchema = tsdbGetTableSchema(pTable);
+          pTable->lastRow = taosTMalloc(schemaTLen(pSchema));
+          if (pTable->lastRow == NULL) {
+            goto _err;
+          }
+
+          tdInitDataRow(pTable->lastRow, pSchema);
+          for (int icol = 0; icol < schemaNCols(pSchema); icol++) {
+            STColumn *pCol = schemaColAt(pSchema, icol);
+            SDataCol *pDataCol = rhelper.pDataCols[0]->cols + icol;
+            tdAppendColVal(pTable->lastRow, tdGetColDataOfRow(pDataCol, pBlock->numOfRows - 1), pCol->type, pCol->bytes,
+                           pCol->offset);
+          }
+        }
+      }
     }
   }
 
@@ -800,6 +834,7 @@ static int tsdbEncodeCfg(void **buf, STsdbCfg *pCfg) {
   tlen += taosEncodeFixedI8(buf, pCfg->precision);
   tlen += taosEncodeFixedI8(buf, pCfg->compression);
   tlen += taosEncodeFixedI8(buf, pCfg->update);
+  tlen += taosEncodeFixedI8(buf, pCfg->cacheLastRow);
 
   return tlen;
 }
@@ -817,6 +852,7 @@ static void *tsdbDecodeCfg(void *buf, STsdbCfg *pCfg) {
   buf = taosDecodeFixedI8(buf, &(pCfg->precision));
   buf = taosDecodeFixedI8(buf, &(pCfg->compression));
   buf = taosDecodeFixedI8(buf, &(pCfg->update));
+  buf = taosDecodeFixedI8(buf, &(pCfg->cacheLastRow));
 
   return buf;
 }

src/tsdb/src/tsdbMemTable.c

@@ -36,6 +36,7 @@ static int          tsdbGetSubmitMsgNext(SSubmitMsgIter *pIter, SSubmitBlk **pPB
 static int          tsdbCheckTableSchema(STsdbRepo *pRepo, SSubmitBlk *pBlock, STable *pTable);
 static int          tsdbInsertDataToTableImpl(STsdbRepo *pRepo, STable *pTable, void **rows, int rowCounter);
 static void         tsdbFreeRows(STsdbRepo *pRepo, void **rows, int rowCounter);
+static int          tsdbUpdateTableLatestInfo(STsdbRepo *pRepo, STable *pTable, SDataRow row);
 
 static FORCE_INLINE int tsdbCheckRowRange(STsdbRepo *pRepo, STable *pTable, SDataRow row, TSKEY minKey, TSKEY maxKey,
                                           TSKEY now);
@@ -663,9 +664,10 @@ static int tsdbCopyRowToMem(STsdbRepo *pRepo, SDataRow row, STable *pTable, void
       return -1;
     }
 
-    if (key > TABLE_LASTKEY(pTable)) {
+    TSKEY lastKey = tsdbGetTableLastKeyImpl(pTable);
+    if (key > lastKey) {
       tsdbTrace("vgId:%d skip to delete row key %" PRId64 " which is larger than table lastKey %" PRId64,
-                REPO_ID(pRepo), key, TABLE_LASTKEY(pTable));
+                REPO_ID(pRepo), key, lastKey);
       return 0;
     }
   }
@@ -846,8 +848,10 @@ static int tsdbInsertDataToTableImpl(STsdbRepo *pRepo, STable *pTable, void **ro
   if (pTableData->keyLast < dataRowKey(rows[rowCounter - 1])) pTableData->keyLast = dataRowKey(rows[rowCounter - 1]);
   pTableData->numOfRows += dsize;
 
-  // TODO: impl delete row thing
-  if (TABLE_LASTKEY(pTable) < dataRowKey(rows[rowCounter-1])) TABLE_LASTKEY(pTable) = dataRowKey(rows[rowCounter-1]);
+  // update table latest info
+  if (tsdbUpdateTableLatestInfo(pRepo, pTable, rows[rowCounter - 1]) < 0) {
+    return -1;
+  }
 
   return 0;
 }
@@ -889,4 +893,38 @@ static void tsdbFreeRows(STsdbRepo *pRepo, void **rows, int rowCounter) {
       }
     }
   }
+}
+
+static int tsdbUpdateTableLatestInfo(STsdbRepo *pRepo, STable *pTable, SDataRow row) {
+  STsdbCfg *pCfg = &pRepo->config;
+
+  if (tsdbGetTableLastKeyImpl(pTable) < dataRowKey(row)) {
+    if (pCfg->cacheLastRow || pTable->lastRow != NULL) {
+      SDataRow nrow = pTable->lastRow;
+      if (taosTSizeof(nrow) < dataRowLen(row)) {
+        SDataRow orow = nrow;
+        nrow = taosTMalloc(dataRowLen(row));
+        if (nrow == NULL) {
+          terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+          return -1;
+        }
+
+        dataRowCpy(nrow, row);
+        TSDB_WLOCK_TABLE(pTable);
+        pTable->lastKey = dataRowKey(row);
+        pTable->lastRow = nrow;
+        TSDB_WUNLOCK_TABLE(pTable);
+        taosTZfree(orow);
+      } else {
+        TSDB_WLOCK_TABLE(pTable);
+        pTable->lastKey = dataRowKey(row);
+        dataRowCpy(nrow, row);
+        TSDB_WUNLOCK_TABLE(pTable);
+      }
+    } else {
+      pTable->lastKey = dataRowKey(row);
+    }
+  }
+
+  return 0;
 }
\ No newline at end of file

src/tsdb/src/tsdbMeta.c

@@ -377,11 +377,11 @@ int tsdbUpdateTableTagValue(TSDB_REPO_T *repo, SUpdateTableTagValMsg *pMsg) {
 
   // Chage in memory
   if (pNewSchema != NULL) { // change super table tag schema
-    taosWLockLatch(&(pTable->pSuper->latch));
+    TSDB_WLOCK_TABLE(pTable->pSuper);
     STSchema *pOldSchema = pTable->pSuper->tagSchema;
     pTable->pSuper->tagSchema = pNewSchema;
     tdFreeSchema(pOldSchema);
-    taosWUnLockLatch(&(pTable->pSuper->latch));
+    TSDB_WUNLOCK_TABLE(pTable->pSuper);
   }
 
   bool      isChangeIndexCol = (pMsg->colId == colColId(schemaColAt(pTable->pSuper->tagSchema, 0)));
@@ -392,9 +392,9 @@ int tsdbUpdateTableTagValue(TSDB_REPO_T *repo, SUpdateTableTagValMsg *pMsg) {
     tsdbWLockRepoMeta(pRepo);
     tsdbRemoveTableFromIndex(pMeta, pTable);
   }
-  taosWLockLatch(&(pTable->latch));
+  TSDB_WLOCK_TABLE(pTable);
   tdSetKVRowDataOfCol(&(pTable->tagVal), pMsg->colId, pMsg->type, POINTER_SHIFT(pMsg->data, pMsg->schemaLen));
-  taosWUnLockLatch(&(pTable->latch));
+  TSDB_WUNLOCK_TABLE(pTable);
   if (isChangeIndexCol) {
     tsdbAddTableIntoIndex(pMeta, pTable, false);
     tsdbUnlockRepoMeta(pRepo);
@@ -587,7 +587,7 @@ void tsdbUpdateTableSchema(STsdbRepo *pRepo, STable *pTable, STSchema *pSchema,
   STable *pCTable = (TABLE_TYPE(pTable) == TSDB_CHILD_TABLE) ? pTable->pSuper : pTable;
   ASSERT(schemaVersion(pSchema) > schemaVersion(pCTable->schema[pCTable->numOfSchemas - 1]));
 
-  taosWLockLatch(&(pCTable->latch));
+  TSDB_WLOCK_TABLE(pCTable);
   if (pCTable->numOfSchemas < TSDB_MAX_TABLE_SCHEMAS) {
     pCTable->schema[pCTable->numOfSchemas++] = pSchema;
   } else {
@@ -599,7 +599,7 @@ void tsdbUpdateTableSchema(STsdbRepo *pRepo, STable *pTable, STSchema *pSchema,
 
   if (schemaNCols(pSchema) > pMeta->maxCols) pMeta->maxCols = schemaNCols(pSchema);
   if (schemaTLen(pSchema) > pMeta->maxRowBytes) pMeta->maxRowBytes = schemaTLen(pSchema);
-  taosWUnLockLatch(&(pCTable->latch));
+  TSDB_WUNLOCK_TABLE(pCTable);
 
   if (insertAct) {
     int   tlen = tsdbGetTableEncodeSize(TSDB_UPDATE_META, pCTable);
@@ -775,6 +775,7 @@ static void tsdbFreeTable(STable *pTable) {
     kvRowFree(pTable->tagVal);
 
     tSkipListDestroy(pTable->pIndex);
+    taosTZfree(pTable->lastRow);
     tfree(pTable->sql);
     free(pTable);
   }

src/tsdb/src/tsdbRead.c

@@ -110,6 +110,7 @@ typedef struct STsdbQueryHandle {
   SArray*        pTableCheckInfo;  // SArray<STableCheckInfo>
   int32_t        activeIndex;
   bool           checkFiles;       // check file stage
+  bool           cachelastrow;     // check if last row cached
   void*          qinfo;            // query info handle, for debug purpose
   int32_t        type;             // query type: retrieve all data blocks, 2. retrieve only last row, 3. retrieve direct prev|next rows
   SFileGroup*    pFileGroup;
@@ -133,7 +134,9 @@ typedef struct STableGroupSupporter {
   STSchema*  pTagSchema;
 } STableGroupSupporter;
 
-static STimeWindow changeTableGroupByLastrow(STableGroupInfo *groupList);
+static STimeWindow updateLastrowForEachGroup(STableGroupInfo *groupList);
+static int32_t checkForCachedLastRow(STsdbQueryHandle* pQueryHandle, STableGroupInfo *groupList);
+static int32_t tsdbGetCachedLastRow(STable* pTable, SDataRow* pRes, TSKEY* lastKey);
 
 static void    changeQueryHandleForInterpQuery(TsdbQueryHandleT pHandle);
 static void    doMergeTwoLevelData(STsdbQueryHandle* pQueryHandle, STableCheckInfo* pCheckInfo, SCompBlock* pBlock);
@@ -370,7 +373,7 @@ TsdbQueryHandleT* tsdbQueryTables(TSDB_REPO_T* tsdb, STsdbQueryCond* pCond, STab
 }
 
 TsdbQueryHandleT tsdbQueryLastRow(TSDB_REPO_T *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, void* qinfo, SMemRef* pMemRef) {
-  pCond->twindow = changeTableGroupByLastrow(groupList);
+  pCond->twindow = updateLastrowForEachGroup(groupList);
 
   // no qualified table
   if (groupList->numOfTables == 0) {
@@ -378,8 +381,14 @@ TsdbQueryHandleT tsdbQueryLastRow(TSDB_REPO_T *tsdb, STsdbQueryCond *pCond, STab
   }
 
   STsdbQueryHandle *pQueryHandle = (STsdbQueryHandle*) tsdbQueryTables(tsdb, pCond, groupList, qinfo, pMemRef);
+  int32_t code = checkForCachedLastRow(pQueryHandle, groupList);
+  if (code != TSDB_CODE_SUCCESS) { // set the numOfTables to be 0
+    terrno = code;
+    return NULL;
+  }
 
   assert(pCond->order == TSDB_ORDER_ASC && pCond->twindow.skey <= pCond->twindow.ekey);
+  pQueryHandle->type = TSDB_QUERY_TYPE_LAST;
   return pQueryHandle;
 }
 
@@ -2144,6 +2153,39 @@ bool tsdbNextDataBlock(TsdbQueryHandleT* pHandle) {
     // restore the pMemRef
     pQueryHandle->pMemRef = pMemRef;
     return ret;
+  } else if (pQueryHandle->type == TSDB_QUERY_TYPE_LAST && pQueryHandle->cachelastrow) {
+    // the last row is cached in buffer, return it directly.
+    // here note that the pQueryHandle->window must be the TS_INITIALIZER
+    int32_t numOfCols  = (int32_t)(QH_GET_NUM_OF_COLS(pQueryHandle));
+    SQueryFilePos* cur = &pQueryHandle->cur;
+
+    SDataRow pRow = NULL;
+    TSKEY    key  = TSKEY_INITIAL_VAL;
+    int32_t  step = ASCENDING_TRAVERSE(pQueryHandle->order)? 1:-1;
+
+    if (++pQueryHandle->activeIndex < numOfTables) {
+      STableCheckInfo* pCheckInfo = taosArrayGet(pQueryHandle->pTableCheckInfo, pQueryHandle->activeIndex);
+      int32_t ret = tsdbGetCachedLastRow(pCheckInfo->pTableObj, &pRow, &key);
+      if (ret != TSDB_CODE_SUCCESS) {
+        return false;
+      }
+
+      copyOneRowFromMem(pQueryHandle, pQueryHandle->outputCapacity, 0, pRow, numOfCols, pCheckInfo->pTableObj);
+      tfree(pRow);
+
+      // update the last key value
+      pCheckInfo->lastKey = key + step;
+
+      cur->rows     = 1;  // only one row
+      cur->lastKey  = key + step;
+      cur->mixBlock = true;
+      cur->win.skey = key;
+      cur->win.ekey = key;
+
+      return true;
+    }
+
+    return false;
   }
 
   if (pQueryHandle->checkFiles) {
@@ -2176,7 +2218,57 @@ bool tsdbNextDataBlock(TsdbQueryHandleT* pHandle) {
   return ret;
 }
 
-STimeWindow changeTableGroupByLastrow(STableGroupInfo *groupList) {
+/*
+ * 1. no data at all (pTable->lastKey = TSKEY_INITIAL_VAL), just return TSKEY_INITIAL_VAL
+ * 2. has data but not loaded, just return lastKey but not set pRes
+ * 3. has data and loaded, return lastKey and set pRes
+ */
+int32_t tsdbGetCachedLastRow(STable* pTable, SDataRow* pRes, TSKEY* lastKey) {
+  TSDB_RLOCK_TABLE(pTable);
+  *lastKey = pTable->lastKey;
+
+  if ((*lastKey) != TSKEY_INITIAL_VAL && pTable->lastRow) {
+    *pRes = tdDataRowDup(pTable->lastRow);
+    if (*pRes == NULL) {
+      TSDB_RUNLOCK_TABLE(pTable);
+      return TSDB_CODE_TDB_OUT_OF_MEMORY;
+    }
+  }
+
+  TSDB_RUNLOCK_TABLE(pTable);
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t checkForCachedLastRow(STsdbQueryHandle* pQueryHandle, STableGroupInfo *groupList) {
+  assert(pQueryHandle != NULL && groupList != NULL);
+
+  SDataRow pRow = NULL;
+  TSKEY    key = TSKEY_INITIAL_VAL;
+
+  SArray* group = taosArrayGetP(groupList->pGroupList, 0);
+  assert(group != NULL);
+
+  STableKeyInfo* pInfo = (STableKeyInfo*)taosArrayGet(group, 0);
+
+  int32_t code = tsdbGetCachedLastRow(pInfo->pTable, &pRow, &key);
+  if (code != TSDB_CODE_SUCCESS) {
+    pQueryHandle->cachelastrow = false;
+  } else {
+    pQueryHandle->cachelastrow = (pRow != NULL);
+  }
+
+  // update the tsdb query time range
+  if (pQueryHandle->cachelastrow) {
+    pQueryHandle->window      = TSWINDOW_INITIALIZER;
+    pQueryHandle->checkFiles  = false;
+    pQueryHandle->activeIndex = -1;  // start from -1
+  }
+
+  tfree(pRow);
+  return code;
+}
+
+STimeWindow updateLastrowForEachGroup(STableGroupInfo *groupList) {
   STimeWindow window = {INT64_MAX, INT64_MIN};
 
   int32_t totalNumOfTable = 0;
@@ -2191,16 +2283,16 @@ STimeWindow changeTableGroupByLastrow(STableGroupInfo *groupList) {
 
     size_t numOfTables = taosArrayGetSize(pGroup);
     for(int32_t i = 0; i < numOfTables; ++i) {
-      STableKeyInfo* pKeyInfo = (STableKeyInfo*) taosArrayGet(pGroup, i);
+      STableKeyInfo* pInfo = (STableKeyInfo*) taosArrayGet(pGroup, i);
 
       // if the lastKey equals to INT64_MIN, there is no data in this table
-      TSKEY lastKey = ((STable*)(pKeyInfo->pTable))->lastKey;
+      TSKEY lastKey = ((STable*)(pInfo->pTable))->lastKey;
       if (key < lastKey) {
         key = lastKey;
 
-        keyInfo.pTable  = pKeyInfo->pTable;
+        keyInfo.pTable  = pInfo->pTable;
         keyInfo.lastKey = key;
-        pKeyInfo->lastKey = key;
+        pInfo->lastKey  = key;
 
         if (key < window.skey) {
           window.skey = key;
@@ -2214,11 +2306,11 @@ STimeWindow changeTableGroupByLastrow(STableGroupInfo *groupList) {
 
     // clear current group, unref unused table
     for (int32_t i = 0; i < numOfTables; ++i) {
-      STableKeyInfo* pKeyInfo = (STableKeyInfo*)taosArrayGet(pGroup, i);
+      STableKeyInfo* pInfo = (STableKeyInfo*)taosArrayGet(pGroup, i);
 
       // keyInfo.pTable may be NULL here.
-      if (pKeyInfo->pTable != keyInfo.pTable) {
-        tsdbUnRefTable(pKeyInfo->pTable);
+      if (pInfo->pTable != keyInfo.pTable) {
+        tsdbUnRefTable(pInfo->pTable);
       }
     }
 

src/vnode/src/vnodeCfg.c

@@ -34,6 +34,7 @@ static void vnodeLoadCfg(SVnodeObj *pVnode, SCreateVnodeMsg* vnodeMsg) {
   pVnode->tsdbCfg.maxRowsPerFileBlock = vnodeMsg->cfg.maxRowsPerFileBlock;
   pVnode->tsdbCfg.precision = vnodeMsg->cfg.precision;
   pVnode->tsdbCfg.compression = vnodeMsg->cfg.compression;
+  pVnode->tsdbCfg.cacheLastRow = vnodeMsg->cfg.cacheLastRow;
   pVnode->walCfg.walLevel = vnodeMsg->cfg.walLevel;
   pVnode->walCfg.fsyncPeriod = vnodeMsg->cfg.fsyncPeriod;
   pVnode->walCfg.keep = TAOS_WAL_NOT_KEEP;
@@ -216,6 +217,15 @@ int32_t vnodeReadCfg(SVnodeObj *pVnode) {
   }
   vnodeMsg.cfg.quorum = (int8_t)quorum->valueint;
 
+  cJSON *cacheLastRow = cJSON_GetObjectItem(root, "cacheLastRow");
+  if (!cacheLastRow || cacheLastRow->type != cJSON_Number) {
+    vError("vgId: %d, failed to read %s, cacheLastRow not found", pVnode->vgId, file);
+    //goto PARSE_VCFG_ERROR;
+    vnodeMsg.cfg.cacheLastRow = 0;
+  } else {
+    vnodeMsg.cfg.cacheLastRow = (int8_t)cacheLastRow->valueint;
+  }
+
   cJSON *nodeInfos = cJSON_GetObjectItem(root, "nodeInfos");
   if (!nodeInfos || nodeInfos->type != cJSON_Array) {
     vError("vgId:%d, failed to read %s, nodeInfos not found", pVnode->vgId, file);
@@ -304,6 +314,7 @@ int32_t vnodeWriteCfg(SCreateVnodeMsg *pMsg) {
   len += snprintf(content + len, maxLen - len, "  \"replica\": %d,\n", pMsg->cfg.replications);
   len += snprintf(content + len, maxLen - len, "  \"wals\": %d,\n", pMsg->cfg.wals);
   len += snprintf(content + len, maxLen - len, "  \"quorum\": %d,\n", pMsg->cfg.quorum);
+  len += snprintf(content + len, maxLen - len, "  \"cacheLastRow\": %d,\n", pMsg->cfg.cacheLastRow);
   len += snprintf(content + len, maxLen - len, "  \"nodeInfos\": [{\n");
   for (int32_t i = 0; i < pMsg->cfg.replications; i++) {
     SVnodeDesc *node = &pMsg->nodes[i];

src/vnode/src/vnodeMain.c

@@ -86,6 +86,7 @@ int32_t vnodeCreate(SCreateVnodeMsg *pVnodeCfg) {
   tsdbCfg.precision           = pVnodeCfg->cfg.precision;
   tsdbCfg.compression         = pVnodeCfg->cfg.compression;
   tsdbCfg.update              = pVnodeCfg->cfg.update;
+  tsdbCfg.cacheLastRow        = pVnodeCfg->cfg.cacheLastRow;
 
   char tsdbDir[TSDB_FILENAME_LEN] = {0};
   sprintf(tsdbDir, "%s/vnode%d/tsdb", tsVnodeDir, pVnodeCfg->cfg.vgId);

tests/script/general/http/restful_full.sim

@@ -81,7 +81,7 @@ print ===============  step2 - no db
 #11
 system_content curl -H 'Authorization: Taosd /KfeAzX/f9na8qdtNZmtONryp201ma04bEl8LcvLUd7a8qdtNZmtONryp201ma04'  -d 'show databases' 127.0.0.1:7111/rest/sql
 print 11-> $system_content
-if $system_content != @{"status":"succ","head":["name","created_time","ntables","vgroups","replica","quorum","days","keep1,keep2,keep(D)","cache(MB)","blocks","minrows","maxrows","wallevel","fsync","comp","precision","update","status"],"data":[],"rows":0}@ then
+if $system_content != @{"status":"succ","head":["name","created_time","ntables","vgroups","replica","quorum","days","keep1,keep2,keep(D)","cache(MB)","blocks","minrows","maxrows","wallevel","fsync","comp","cachelast","precision","update","status"],"data":[],"rows":0}@ then
   return -1
 endi