diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index ca6b1dd206f7711e6fe268b8a2448d1daa38287c..3dfaae820e0be57947569fd46c99e53c3effb214 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -29,6 +29,14 @@ extern "C" {
 #include "tsched.h"
 #include "tsclient.h"
 
+#define LABEL_SQL   "sql:"
+#define LABEL_TO    " to:"
+#define LABEL_SPLIT " split:"
+
+#define LABEL_SQL_LEN   (sizeof(LABEL_SQL) - 1)
+#define LABEL_TO_LEN    (sizeof(LABEL_TO) - 1)
+#define LABEL_SPLIT_LEN (sizeof(LABEL_SPLIT) - 1)
+
 #define UTIL_TABLE_IS_SUPER_TABLE(metaInfo) \
   (((metaInfo)->pTableMeta != NULL) && ((metaInfo)->pTableMeta->tableType == TSDB_SUPER_TABLE))
 
diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index c5e3cb727f85dafd2b51efe741cd635394908cfd..cd19dae3a88b3dfbb54c0c28d6e6908ec98a82c2 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -405,6 +405,10 @@ typedef struct SSqlStream {
   int16_t  precision;
   int64_t  num;  // number of computing count
 
+  int32_t dstCols;  // dstTable has number of columns 
+  char*   to;
+  char*   split;
+
   /*
    * keep the number of current result in computing,
    * the value will be set to 0 before set timer for next computing
@@ -484,6 +488,8 @@ TAOS *taos_connect_a(char *ip, char *user, char *pass, char *db, uint16_t port,
                      void *param, TAOS **taos);
 TAOS_RES* taos_query_h(TAOS* taos, const char *sqlstr, int64_t* res);
 TAOS_RES * taos_query_ra(TAOS *taos, const char *sqlstr, __async_cb_func_t fp, void *param);
+// get taos connection unused session number
+int32_t taos_unused_session(TAOS* taos);
 
 void waitForQueryRsp(void *param, TAOS_RES *tres, int code);
 
diff --git a/src/client/src/taos.def b/src/client/src/taos.def
index bcb705434b3847327cfb130896e0252871fbdad7..77eb9144657facc82dda70129dd77480a0f0b9e8 100644
--- a/src/client/src/taos.def
+++ b/src/client/src/taos.def
@@ -53,3 +53,4 @@ taos_is_null
 taos_insert_lines
 taos_schemaless_insert
 taos_result_block
+taos_print_row_ex
\ No newline at end of file
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 3b0954bc8926722aa9acd922b1084ba0e9f53602..b18b76c9672e6bebf02a4d2fa064b16192f37630 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -1443,6 +1443,7 @@ int32_t tscSetTableFullName(SName* pName, SStrToken* pTableName, SSqlObj* pSql,
   const char* msg3 = "no acctId";
   const char* msg4 = "db name too long";
   const char* msg5 = "table name too long";
+  const char* msg6 = "table name empty";
 
   SSqlCmd* pCmd = &pSql->cmd;
   int32_t  code = TSDB_CODE_SUCCESS;
@@ -1494,6 +1495,8 @@ int32_t tscSetTableFullName(SName* pName, SStrToken* pTableName, SSqlObj* pSql,
 
     if (pTableName->n >= TSDB_TABLE_NAME_LEN) {
       return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    } else if(pTableName->n == 0) {
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
     }
 
     char name[TSDB_TABLE_FNAME_LEN] = {0};
@@ -9081,6 +9084,18 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
   if (tscValidateName(pName, true, &dbIncluded1) != TSDB_CODE_SUCCESS) {
     return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
+  
+  // check to valid and create to name
+  if(pInfo->pCreateTableInfo->to.n > 0) {
+    bool dbInclude = false;
+    if (tscValidateName(&pInfo->pCreateTableInfo->to, false, &dbInclude) != TSDB_CODE_SUCCESS) {
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    }
+    int32_t code = tscSetTableFullName(&pInfo->pCreateTableInfo->toSName, &pInfo->pCreateTableInfo->to, pSql, dbInclude);
+    if(code != TSDB_CODE_SUCCESS) {
+      return code;
+    }
+  }
 
   SRelationInfo* pFromInfo = pInfo->pCreateTableInfo->pSelect->from;
   if (pFromInfo == NULL || taosArrayGetSize(pFromInfo->list) == 0) {
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 06338b8fd6b55df198148c0fc4b9be38f5894576..a3edca6ee229d459d4b9bee279c03750ef08132d 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -1546,11 +1546,49 @@ int tscEstimateCreateTableMsgLength(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   if (pCreateTableInfo->pSelect != NULL) {
     size += (pCreateTableInfo->pSelect->sqlstr.n + 1);
+    // add size = create super table with same columns and 1 tags
+    if(pCreateTableInfo->to.n > 0) {
+      size += sizeof(SCreateTableMsg);
+      size += sizeof(SSchema) * (pCmd->numOfCols + 1);
+      size += pCreateTableInfo->to.n + 4;  // to:
+      if(pCreateTableInfo->split.n > 0)
+        size += pCreateTableInfo->split.n + 7; // split:
+    }    
   }
 
   return size + TSDB_EXTRA_PAYLOAD_SIZE;
 }
 
+char* fillCreateSTableMsg(SCreateTableMsg* pCreateMsg, SCreateTableSql* pTableSql, SSqlCmd* pCmd, SSqlInfo *pInfo) {
+  // SET
+  SSchema*    pSchema    = (SSchema *)pCreateMsg->schema;
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
+  pCreateMsg->igExists   = 0;
+  pCreateMsg->sqlLen     = 0;
+
+  // FullName like acctID.dbName.tableName
+  tNameExtractFullName(&pInfo->pCreateTableInfo->toSName, pCreateMsg->tableName);
+
+  // copy columns
+  pCreateMsg->numOfColumns = htons(pCmd->numOfCols);
+  for (int i = 0; i < pCmd->numOfCols; ++i) {
+    TAOS_FIELD *pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, i);
+    pSchema->type = pField->type;
+    strcpy(pSchema->name, pField->name);
+    pSchema->bytes = htons(pField->bytes);
+
+    pSchema++;
+  }
+  // append one tag
+  pCreateMsg->numOfTags  = htons(1); // only one tag immutable
+  pSchema->type          = TSDB_DATA_TYPE_INT;
+  pSchema->bytes         = htons(INT_BYTES);
+  strcpy(pSchema->name, "tag1");
+  pSchema ++;
+
+  return (char *)pSchema;
+}
+
 int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   int      msgLen = 0;
   int      size = 0;
@@ -1608,39 +1646,71 @@ int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
       pCreate->len = htonl(len);
     }
   } else {  // create (super) table
+    // FIRST MSG
+    SCreateTableMsg* pCreate = pCreateMsg;
     pCreateTableMsg->numOfTables = htonl(1); // only one table will be created
-
-    int32_t code = tNameExtractFullName(&pTableMetaInfo->name, pCreateMsg->tableName);
+    int32_t code = tNameExtractFullName(&pTableMetaInfo->name, pCreate->tableName);
+    bool to = pInfo->pCreateTableInfo->to.n > 0;
     assert(code == 0);
 
     SCreateTableSql *pCreateTable = pInfo->pCreateTableInfo;
 
-    pCreateMsg->igExists = pCreateTable->existCheck ? 1 : 0;
-    pCreateMsg->numOfColumns = htons(pCmd->numOfCols);
-    pCreateMsg->numOfTags = htons(pCmd->count);
-
-    pCreateMsg->sqlLen = 0;
-    pMsg = (char *)pCreateMsg->schema;
-
-    pSchema = (SSchema *)pCreateMsg->schema;
-
+    pCreate->igExists = pCreateTable->existCheck ? 1 : 0;
+    pCreate->numOfColumns = htons(pCmd->numOfCols);
+    pCreate->numOfTags = htons(pCmd->count);
+    pCreate->sqlLen = 0;
+    pSchema = (SSchema *)pCreate->schema;
+    //copy schema
     for (int i = 0; i < pCmd->numOfCols + pCmd->count; ++i) {
       TAOS_FIELD *pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, i);
-
       pSchema->type = pField->type;
       strcpy(pSchema->name, pField->name);
       pSchema->bytes = htons(pField->bytes);
-
       pSchema++;
     }
-
+    //copy stream sql if have
     pMsg = (char *)pSchema;
     if (type == TSQL_CREATE_STREAM) {  // check if it is a stream sql
       SSqlNode *pQuerySql = pInfo->pCreateTableInfo->pSelect;
+      int16_t len = 0;
+      if(to) {
+        //sql:
+        strcpy(pMsg, LABEL_SQL);
+        len += LABEL_SQL_LEN;
+        len += tStrNCpy(pMsg + len, &pQuerySql->sqlstr);
+        //to
+        strcpy(pMsg + len, LABEL_TO);
+        len += LABEL_TO_LEN;
+        len += tStrNCpy(pMsg + len, &pInfo->pCreateTableInfo->to);
+        //split if
+        if(pInfo->pCreateTableInfo->split.n > 0) {
+          strcpy(pMsg + len, LABEL_SPLIT);
+          len += LABEL_SPLIT_LEN;
+          len += tStrNCpy(pMsg + len, &pInfo->pCreateTableInfo->split);
+        }
+        // append string end flag
+        pMsg[len++] = 0;
+        pMsg += len;
+        pCreate->sqlLen = htons(len);
+      } else {
+        len = pQuerySql->sqlstr.n;
+        strncpy(pMsg, pQuerySql->sqlstr.z, len);
+        pMsg[len++] = 0; // string end
+        pMsg += len;
+        pCreate->sqlLen = htons(len);
+      }
+    }
+    // calc first msg length
+    int32_t len = (int32_t)(pMsg - (char*)pCreate);
+    pCreate->len = htonl(len);
 
-      strncpy(pMsg, pQuerySql->sqlstr.z, pQuerySql->sqlstr.n + 1);
-      pCreateMsg->sqlLen = htons(pQuerySql->sqlstr.n + 1);
-      pMsg += pQuerySql->sqlstr.n + 1;
+    // filling second msg if to have value
+    if(to) {
+      pCreate = (SCreateTableMsg *)pMsg;
+      pMsg = fillCreateSTableMsg(pCreate, pCreateTable, pCmd, pInfo);
+      len = (int32_t)(pMsg - (char*)pCreate);
+      pCreate->len = htonl(len);
+      pCreateTableMsg->numOfTables = htonl(2); 
     }
   }
 
diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index 8eff6335774f60232f70b705efe978f1d7afa129..2b9dda4f0b1e165bab5bcd1f482efe81fe38e590 100644
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -28,6 +28,7 @@
 #include "tutil.h"
 #include "ttimer.h"
 #include "tscProfile.h"
+#include "tidpool.h"
 
 static char clusterDefaultId[] = "clusterDefaultId";
 static bool validImpl(const char* str, size_t maxsize) {
@@ -307,6 +308,25 @@ void taos_close(TAOS *taos) {
   taosRemoveRef(tscRefId, pObj->rid);
 }
 
+// get taos connection unused session number
+int32_t taos_unused_session(TAOS* taos) {
+  // param valid check
+  STscObj *pObj = (STscObj *)taos;
+  if (pObj == NULL || pObj->signature != pObj) {
+    tscError("pObj:%p is NULL or freed", pObj);
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return 0;
+  }
+  if(pObj->pRpcObj == NULL ) {
+    tscError("pObj:%p pRpcObj is NULL.", pObj);
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return 0;
+  }
+
+  // get number
+  return rpcUnusedSession(pObj->pRpcObj->pDnodeConn, false);
+}
+
 void waitForQueryRsp(void *param, TAOS_RES *tres, int code) {
   assert(tres != NULL);
   
@@ -807,13 +827,16 @@ bool taos_is_update_query(TAOS_RES *res) {
   SSqlCmd* pCmd = &pSql->cmd;
   return ((pCmd->command >= TSDB_SQL_INSERT && pCmd->command <= TSDB_SQL_DROP_DNODE) || TSDB_SQL_RESET_CACHE == pCmd->command || TSDB_SQL_USE_DB == pCmd->command);
 }
-
 int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields) {
+  return taos_print_row_ex(str, row, fields, num_fields, ' ', false);
+}
+
+int taos_print_row_ex(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields, char split, bool addQuota) {
   int len = 0;
 
   for (int i = 0; i < num_fields; ++i) {
     if (i > 0) {
-      str[len++] = ' ';
+      str[len++] = split;
     }
 
     if (row[i] == NULL) {
@@ -874,9 +897,23 @@ int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields)
         } else {
           assert(charLen <= fields[i].bytes * TSDB_NCHAR_SIZE && charLen >= 0);
         }
+        
+        // add pre quotaion if require
+        if(addQuota) {
+          *(str + len) = '\'';
+          len += 1;
+        }
 
+        // copy content
         memcpy(str + len, row[i], charLen);
         len += charLen;
+
+        // add end quotaion if require
+        if(addQuota) {
+          *(str + len)= '\'';
+          len += 1;
+        }
+
       } break;
 
       case TSDB_DATA_TYPE_TIMESTAMP:
@@ -893,6 +930,89 @@ int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields)
   return len;
 }
 
+// print field value to str
+int taos_print_field(char *str, void* value, TAOS_FIELD *field) {
+  // check valid
+  if (str == NULL || value == NULL || field == NULL) {
+    return 0;
+  }
+
+  // get value
+  int len = 0;
+  switch (field->type) {
+    //
+    // fixed length
+    //
+    case TSDB_DATA_TYPE_TINYINT:
+      len = sprintf(str, "%d", *((int8_t *)value));
+      break;
+
+    case TSDB_DATA_TYPE_UTINYINT:
+      len = sprintf(str, "%u", *((uint8_t *)value));
+      break;
+
+    case TSDB_DATA_TYPE_SMALLINT:
+      len = sprintf(str, "%d", *((int16_t *)value));
+      break;
+
+    case TSDB_DATA_TYPE_USMALLINT:
+      len = sprintf(str, "%u", *((uint16_t *)value));
+      break;
+
+    case TSDB_DATA_TYPE_INT:
+      len = sprintf(str, "%d", *((int32_t *)value));
+      break;
+
+    case TSDB_DATA_TYPE_UINT:
+      len = sprintf(str, "%u", *((uint32_t *)value));
+      break;
+
+    case TSDB_DATA_TYPE_BIGINT:
+      len = sprintf(str, "%" PRId64, *((int64_t *)value));
+      break;
+
+    case TSDB_DATA_TYPE_UBIGINT:
+      len = sprintf(str, "%" PRIu64, *((uint64_t *)value));
+      break;
+
+    case TSDB_DATA_TYPE_FLOAT: {
+      float fv = 0;
+      fv = GET_FLOAT_VAL(value);
+      len = sprintf(str, "%f", fv);
+    } break;
+
+    case TSDB_DATA_TYPE_DOUBLE: {
+      double dv = 0;
+      dv = GET_DOUBLE_VAL(value);
+      len = sprintf(str, "%lf", dv);
+    } break;
+
+    case TSDB_DATA_TYPE_TIMESTAMP:
+      len = sprintf(str, "%" PRId64, *((int64_t *)value));
+      break;
+    case TSDB_DATA_TYPE_BOOL:
+      len = sprintf(str, "%d", *((int8_t *)value));
+
+    // 
+    //  variant length
+    //
+    case TSDB_DATA_TYPE_BINARY:
+    case TSDB_DATA_TYPE_NCHAR: {
+      len = varDataLen((char*)value - VARSTR_HEADER_SIZE);
+      if (field->type == TSDB_DATA_TYPE_BINARY) {
+        assert(len <= field->bytes && len >= 0);
+      } else {
+        assert(len <= field->bytes * TSDB_NCHAR_SIZE && len >= 0);
+      }
+      memcpy(str, value, len);
+    } break;
+  
+    default:
+      break;
+  }
+  return len;
+}
+
 static void asyncCallback(void *param, TAOS_RES *tres, int code) {
   assert(param != NULL);
   SSqlObj *pSql = ((SSqlObj *)param);
diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c
index 2fa885ba7760a01e88eaecc114e1aced4cb11ea6..1fa6b2d78d6bbc5506104e4b18687adb3a62dea0 100644
--- a/src/client/src/tscStream.c
+++ b/src/client/src/tscStream.c
@@ -30,6 +30,7 @@ static void tscProcessStreamQueryCallback(void *param, TAOS_RES *tres, int numOf
 static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOfRows);
 static void tscSetNextLaunchTimer(SSqlStream *pStream, SSqlObj *pSql);
 static void tscSetRetryTimer(SSqlStream *pStream, SSqlObj *pSql, int64_t timer);
+static int64_t getLaunchTimeDelay(const SSqlStream* pStream);
 
 static int64_t getDelayValueAfterTimewindowClosed(SSqlStream* pStream, int64_t launchDelay) {
   return taosGetTimestamp(pStream->precision) + launchDelay - pStream->stime - 1;
@@ -49,7 +50,7 @@ static bool isProjectStream(SQueryInfo* pQueryInfo) {
 static int64_t tscGetRetryDelayTime(SSqlStream* pStream, int64_t slidingTime, int16_t prec) {
   float retryRangeFactor = 0.3f;
   int64_t retryDelta = (int64_t)(tsRetryStreamCompDelay * retryRangeFactor);
-  retryDelta = ((rand() % retryDelta) + tsRetryStreamCompDelay) * 1000L;
+  retryDelta = (rand() % retryDelta) + tsRetryStreamCompDelay;
 
   if (pStream->interval.intervalUnit != 'n' && pStream->interval.intervalUnit != 'y') {
     // change to ms
@@ -113,7 +114,7 @@ static void doLaunchQuery(void* param, TAOS_RES* tres, int32_t code) {
 
     pQueryInfo->command = TSDB_SQL_SELECT;
 
-    pSql->fp      = tscProcessStreamQueryCallback;
+    pSql->fp = tscProcessStreamQueryCallback;
     pSql->fetchFp = tscProcessStreamQueryCallback;
     executeQuery(pSql, pQueryInfo);
     tscIncStreamExecutionCount(pStream);
@@ -142,7 +143,6 @@ static void tscProcessStreamTimer(void *handle, void *tmrId) {
   if(pSql == NULL) {
     return ;
   }
-
   SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   tscDebug("0x%"PRIx64" add into timer", pSql->self);
 
@@ -160,18 +160,19 @@ static void tscProcessStreamTimer(void *handle, void *tmrId) {
   } else {
     pQueryInfo->window.skey = pStream->stime;
     int64_t etime = taosGetTimestamp(pStream->precision);
+    int64_t one = convertTimePrecision(1, TSDB_TIME_PRECISION_MILLI, pStream->precision);
     // delay to wait all data in last time window
     etime -= convertTimePrecision(tsMaxStreamComputDelay, TSDB_TIME_PRECISION_MILLI, pStream->precision);
     if (etime > pStream->etime) {
       etime = pStream->etime;
     } else if (pStream->interval.intervalUnit != 'y' && pStream->interval.intervalUnit != 'n') {
       if(pStream->stime == INT64_MIN) {
-        etime = taosTimeTruncate(etime, &pStream->interval, pStream->precision);
+        etime = taosTimeTruncate(etime, &pStream->interval, pStream->precision) - one;
       } else {
-        etime = pStream->stime + (etime - pStream->stime) / pStream->interval.interval * pStream->interval.interval;
+        etime = pStream->stime + (etime - pStream->stime) / pStream->interval.interval * pStream->interval.interval - one;
       }
     } else {
-      etime = taosTimeTruncate(etime, &pStream->interval, pStream->precision);
+      etime = taosTimeTruncate(etime, &pStream->interval, pStream->precision) - one;
     }
     pQueryInfo->window.ekey = etime;
     if (pQueryInfo->window.skey >= pQueryInfo->window.ekey) {
@@ -179,24 +180,39 @@ static void tscProcessStreamTimer(void *handle, void *tmrId) {
       if (pStream->interval.intervalUnit == 'y' || pStream->interval.intervalUnit == 'n') {
         timer = 86400 * 1000l;
       } else {
-        timer = convertTimePrecision(timer, pStream->precision, TSDB_TIME_PRECISION_MILLI);
+        int32_t loop = 10000;
+        int64_t next_time = pStream->stime; 
+        while(1) {
+          // get next time
+          next_time = taosTimeAdd(next_time, pStream->interval.sliding, pStream->interval.intervalUnit, TSDB_TIME_PRECISION_MILLI);
+          timer = next_time - taosGetTimestamp(pStream->precision); // next time - now()
+          if(timer < 0 && --loop > 0 ) {
+            //tscDebug("CQ next time < now so loop add sliding. next_time=%" PRId64, next_time);
+            continue;
+          }
+
+          // calc launch delay time
+          int64_t delay = getLaunchTimeDelay((const SSqlStream*)pStream);
+          timer += delay;
+          tscDebug("CQ execute next query after %" PRId64 "ms (delay=%" PRId64 ")", timer, delay);
+          break;
+        }  
       }
       tscSetRetryTimer(pStream, pSql, timer);
       return;
     }
   }
 
+  tscDebug("CQ ProcessStreamTimer skey=%" PRId64 " ekey=%" PRId64 " stime=%" PRId64 " etime=%" PRId64, pQueryInfo->window.skey, pQueryInfo->window.ekey, pStream->stime, pStream->etime);
   // launch stream computing in a new thread
-  SSchedMsg schedMsg = {0};
-  schedMsg.fp      = tscProcessStreamLaunchQuery;
+  SSchedMsg schedMsg = { 0 };
+  schedMsg.fp = tscProcessStreamLaunchQuery;
   schedMsg.ahandle = pStream;
   schedMsg.thandle = (void *)1;
-  schedMsg.msg     = NULL;
+  schedMsg.msg = NULL;
   taosScheduleTask(tscQhandle, &schedMsg);
 }
 
-static void cbParseSql(void* param, TAOS_RES* res, int code);
-
 static void tscProcessStreamQueryCallback(void *param, TAOS_RES *tres, int numOfRows) {
   SSqlStream *pStream = (SSqlStream *)param;
   if (tres == NULL || numOfRows < 0) {
@@ -204,28 +220,23 @@ static void tscProcessStreamQueryCallback(void *param, TAOS_RES *tres, int numOf
     tscError("0x%"PRIx64" stream:%p, query data failed, code:0x%08x, retry in %" PRId64 "ms", pStream->pSql->self,
         pStream, numOfRows, retryDelay);
 
-    SSqlObj* pSql = pStream->pSql;
+    STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pStream->pSql->cmd, 0);
 
-    tscFreeSqlResult(pSql);
-    tscFreeSubobj(pSql);
-    tfree(pSql->pSubs);
-    pSql->subState.numOfSub = 0;
+    char name[TSDB_TABLE_FNAME_LEN] = {0};
+    tNameExtractFullName(&pTableMetaInfo->name, name);
 
-    pSql->parseRetry = 0;
-    int32_t code = tsParseSql(pSql, true);
-    if (code == TSDB_CODE_SUCCESS) {
-      cbParseSql(pStream, pSql, code);
-    } else if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
-      tscDebug("0x%"PRIx64" CQ taso_open_stream IN Process", pSql->self);
-    } else {
-      tscError("0x%"PRIx64" open stream failed, code:%s", pSql->self, tstrerror(code));
-      taosReleaseRef(tscObjRef, pSql->self);
-      free(pStream);
-      return;
-    }
+    taosHashRemove(UTIL_GET_TABLEMETA(pStream->pSql), name, strnlen(name, TSDB_TABLE_FNAME_LEN));
+
+    tfree(pTableMetaInfo->pTableMeta);
 
-//    tscSetRetryTimer(pStream, pStream->pSql, retryDelay);
-//    return;
+    tscFreeSqlResult(pStream->pSql);
+    tscFreeSubobj(pStream->pSql);
+    tfree(pStream->pSql->pSubs);
+    pStream->pSql->subState.numOfSub = 0;
+
+    pTableMetaInfo->vgroupList = tscVgroupInfoClear(pTableMetaInfo->vgroupList);
+    tscSetRetryTimer(pStream, pStream->pSql, retryDelay);
+    return;
   }
 
   taos_fetch_rows_a(tres, tscProcessStreamRetrieveResult, param);
@@ -272,14 +283,233 @@ static void tscStreamFillTimeGap(SSqlStream* pStream, TSKEY ts) {
 #endif
 }
 
+// callback send values
+int32_t ok_cnt = 0;
+int32_t err_cnt = 0;
+void cbSendValues(void *param, TAOS_RES *res, int code) {
+  if(code < 0) {
+    err_cnt ++;
+    tscError("CQ Send Failed. code=0x%x ok_cnt=%d err_cnt=%d", code, ok_cnt,err_cnt);
+  } else {
+    ok_cnt ++;
+    tscInfo("CQ Send OK. row=%d ok_cnt=%d err_cnt=%d", code, ok_cnt, err_cnt);
+  }
+}
+
+// append values
+size_t appendValues(TAOS_FIELD* fields, int32_t numCols, TAOS_ROW row, char* pBuf, size_t bufLen, size_t curLen, bool *full) {
+  // calc buf is full
+  size_t needLen = 0;
+  size_t rowLen  = 0;
+  int i;
+  for(i = 0; i < numCols; i++) {
+    needLen += fields[i].bytes;
+  }
+
+  // estimate length for use
+  needLen += numCols * 5 + 20;
+  if(needLen >= bufLen - curLen) {
+    *full = true;
+    return 0;
+  }
+
+  // row append to values
+  char* strRow = tmalloc(needLen);
+  char *value = pBuf + curLen;
+
+  strcpy(value, "(");
+  rowLen += taos_print_row_ex(strRow, row, fields, numCols, ',', true);
+  strcat(value, strRow);
+  strcat(value, ")");
+  rowLen +=2;
+
+  tfree(strRow);
+  return rowLen;
+}
+
+bool sqlBufSend(TAOS *taos, char *sqlBuf) {
+  // if no enough free session, wait max 10s
+  int32_t sleepCnt = 0;
+  do {
+    int32_t session = taos_unused_session(taos);
+    if(session > 1000) {
+      break;
+    }
+    taosMsleep(500);
+    tscInfo("CQ session < 1000. session=%d Wait 0.5s cnt=%d", session, sleepCnt);
+  } while(++sleepCnt < 20);
+
+  strcat(sqlBuf, ";");
+  taos_query_ra(taos, sqlBuf, cbSendValues, NULL);
+  return true;
+}
+
+#define STR_SQL_INSERT "insert into "
+// send one table all rows for once
+bool sendChildTalbe(TAOS *taos, char *superName, char *tableName, TAOS_FIELD *fields, int32_t numCols, 
+                    SArray *arr, char* sqlBuf, int32_t bufLen) {
+
+  char dbName[TSDB_DB_NAME_LEN] = "";
+  char dbTable[TSDB_TABLE_FNAME_LEN];
+  size_t numRows = taosArrayGetSize(arr);
+  if(numRows == 0)
+    return false;
+  // obtain dbname
+  char * p = strstr(superName, ".");
+  if(p) { // if have db prefix , under this db create table
+    int32_t len = (int32_t)(p - superName);
+    strncpy(dbName, superName, len);
+    dbName[len] = 0; // append str end
+    sprintf(dbTable, "%s.%s", dbName, tableName);
+  } else {
+    // no db prefix
+    strcpy(dbTable, tableName);
+  }
+
+  // first enter
+  if(sqlBuf[0] == 0) {
+    strcpy(sqlBuf, STR_SQL_INSERT);
+  } else { // check need send
+   if( bufLen - strlen(sqlBuf) < 300) {
+     sqlBufSend(taos, sqlBuf);
+     strcpy(sqlBuf, STR_SQL_INSERT);
+   }
+  }
+
+  // init
+  int32_t preLen = (int32_t)strlen(sqlBuf);
+  char *subBuf = sqlBuf + preLen;
+  int32_t subLen = bufLen - preLen; 
+  sprintf(subBuf, " %s using %s tags(0) values ", dbTable, superName);
+  size_t curLen = strlen(subBuf);
+
+  TAOS_ROW row ;
+  bool full = false;
+
+  for(size_t i = 0; i < numRows; i++) {
+    row = (TAOS_ROW)taosArrayGetP(arr, i);
+    if(row == NULL)
+      continue;
+    if(subLen > 200)
+       curLen += appendValues(fields, numCols, row, subBuf, subLen - 100, curLen, &full);
+    else
+      full = true;
+    if(full) { // need send
+      // send current
+      sqlBufSend(taos, sqlBuf);
+
+      // init reset
+      strcpy(sqlBuf, STR_SQL_INSERT);
+      preLen = (int32_t)strlen(sqlBuf);
+      subBuf = sqlBuf + preLen;
+      subLen = bufLen - preLen; 
+      sprintf(subBuf, " %s using %s tags(0) values ", dbTable, superName);
+      curLen = strlen(subBuf);
+
+      // retry append. if full is true again, ignore this row
+      curLen += appendValues(fields, numCols, row, subBuf, subLen - 100, curLen, &full);
+      full = false; // reset to false
+    }
+    tfree(row);
+  }
+
+  return true;
+}
+
+// write cq result to another table
+bool toAnotherTable(STscObj *pTscObj, char *superName, TAOS_FIELD *fields, int32_t numCols, SHashObj *tbHash, int32_t numRows) {
+  
+  int32_t bufLen = TSDB_MAX_SQL_LEN/2 - 128;
+  char * sqlBuf = tmalloc(bufLen);
+  sqlBuf[0] = 0; // init
+  
+  ok_cnt = 0;
+  err_cnt = 0;
+  int cnt_table = 0;
+  void *pIter = taosHashIterate(tbHash, NULL);
+  while(pIter) {
+    SArray *arr = *(SArray**)pIter;
+    if(arr) {
+      // get key as tableName
+      SHashNode *pNode = (SHashNode *)GET_HASH_PNODE(pIter);
+      char *data = (char *)GET_HASH_NODE_KEY(pNode);
+      uint32_t len = pNode->keyLen;
+      char *key = tmalloc(len + 1);
+      memcpy(key, data, len);
+      key[len] = 0; // string end '\0'
+
+      // send all this table rows
+      sendChildTalbe(pTscObj, superName, key, fields, numCols, arr, sqlBuf, bufLen);
+      // release SArray
+      taosArrayDestroy(&arr);
+      tfree(key);
+      cnt_table ++;
+    }
+    pIter = taosHashIterate(tbHash, pIter);
+  }
+
+  if(sqlBuf[0]) {
+    sqlBufSend(pTscObj, sqlBuf);
+  }
+
+  tscInfo("CQ ===== stream %d rows write to %d tables ===== \n", numRows, cnt_table);
+  tfree(sqlBuf);
+
+  return true;
+}
+
+// add row to hash to group by tbname
+bool tbHashAdd(SHashObj *tbHash, TAOS_ROW row, TAOS_FIELD* fields, int32_t idx, int32_t numCols) {
+  void *v = row[idx];
+  TAOS_FIELD *field = &fields[idx];
+  VarDataLenT len = 0;
+  char str[128];
+  memset(str, 0, sizeof(str));
+  char *key = str;
+  
+  // get key and len
+  if(field->type == TSDB_DATA_TYPE_BINARY || field->type == TSDB_DATA_TYPE_NCHAR) {
+    key = v;
+    len = varDataLen((char*)v - VARSTR_HEADER_SIZE);
+  } else {
+    len = taos_print_field(str, v, field);
+  }
+  if(len == 0) {
+    return false;
+  }
+
+  // append key with len
+  SArray *arr = NULL;
+  void* pdata = taosHashGet(tbHash, key, len);
+  if(pdata) {
+    arr = *(SArray **)pdata;
+  }
+  // if group is null create new
+  if(arr == NULL) {
+    arr = (SArray *)taosArrayInit(10, sizeof(TAOS_ROW));
+    if(arr == NULL) {
+      tscError("tbHashAdd tbHash:%p, taosArrayInit(10,sizeof(TAOS_ROW) return NULL.", tbHash);
+      return false;
+    }
+    taosHashPut(tbHash, key, len, &arr, sizeof(SArray *));
+  }
+
+  // append to group
+  int32_t new_len = sizeof(void*) * numCols;
+  TAOS_ROW new_row = (TAOS_ROW)tmalloc(new_len);
+  memcpy(new_row, row, new_len);
+  taosArrayPush(arr, &new_row);
+  return true;
+}
+
 static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOfRows) {
   SSqlStream *    pStream = (SSqlStream *)param;
   SSqlObj *       pSql = (SSqlObj *)res;
+  bool toAnother = pStream->to != NULL;
 
   if (pSql == NULL || numOfRows < 0) {
     int64_t retryDelayTime = tscGetRetryDelayTime(pStream, pStream->interval.sliding, pStream->precision);
     tscError("stream:%p, retrieve data failed, code:0x%08x, retry in %" PRId64 " ms", pStream, numOfRows, retryDelayTime);
-  
     tscSetRetryTimer(pStream, pStream->pSql, retryDelayTime);
     return;
   }
@@ -288,23 +518,72 @@ static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOf
   STableMetaInfo *pTableMetaInfo = pQueryInfo->pTableMetaInfo[0];
 
   if (numOfRows > 0) { // when reaching here the first execution of stream computing is successful.
+    // init hash
+    SHashObj* tbHash = NULL;
+    int32_t colIdx = -1;
+    TAOS_FIELD *fields = NULL;
+    int32_t dstColsNum = pStream->dstCols;
+    int32_t fieldsNum = 0;
+
+    if(toAnother) {
+      //init hash
+      tbHash = taosHashInit(100, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
+      fields = taos_fetch_fields(res);
+      fieldsNum = tscNumOfFields(pQueryInfo);
+      if(dstColsNum == -1) 
+         dstColsNum = fieldsNum;
+      //search split column
+      char *split = "tbname"; // default
+      if(pStream->split)
+         split = pStream->split;
+      for(int32_t i = 1; i < fieldsNum; i++ ) {
+        if(strcasecmp(fields[i].name, split) == 0 ) {
+          colIdx = i;
+          break;
+        }
+      }
+
+      // set default with last fields if
+      if(colIdx == -1) { 
+        colIdx = fieldsNum - 1; 
+      }
+    }
+
+    // save rows
     for(int32_t i = 0; i < numOfRows; ++i) {
       TAOS_ROW row = taos_fetch_row(res);
       if (row != NULL) {
-        tscDebug("0x%"PRIx64" stream:%p fetch result", pSql->self, pStream);
+        tscDebug("0x%"PRIx64" stream:%p fetch result row=%d", pSql->self, pStream, i);
         tscStreamFillTimeGap(pStream, *(TSKEY*)row[0]);
         pStream->stime = *(TSKEY *)row[0];
-        // user callback function
-        (*pStream->fp)(pStream->param, res, row);
+        // write to another table if true
+        if(toAnother) {
+          tbHashAdd(tbHash, row, fields, colIdx, dstColsNum);
+          if(i == numOfRows - 1) //write last row to record last query time avoid query from begin for each
+            (*pStream->fp)(pStream->param, res, row); 
+        } else {
+          (*pStream->fp)(pStream->param, res, row);
+        }
         pStream->numOfRes++;
       }
     }
-
+    
+    // write Another
+    if(toAnother) {
+      toAnotherTable(pSql->pTscObj, pStream->to, fields, dstColsNum, tbHash, numOfRows);
+      taosHashCleanup(tbHash);
+    }
+      
     if (!pStream->isProject) {
       pStream->stime = taosTimeAdd(pStream->stime, pStream->interval.sliding, pStream->interval.slidingUnit, pStream->precision);
     }
+    int32_t code = TSDB_CODE_SUCCESS;
+    if(pQueryInfo && pQueryInfo->pQInfo)
+      code = pQueryInfo->pQInfo->code;
     // actually only one row is returned. this following is not necessary
-    taos_fetch_rows_a(res, tscProcessStreamRetrieveResult, pStream);
+    if(code == TSDB_CODE_SUCCESS) { 
+      taos_fetch_rows_a(res, tscProcessStreamRetrieveResult, pStream);
+    }
   } else {  // numOfRows == 0, all data has been retrieved
     pStream->useconds += pSql->res.useconds;
     if (pStream->numOfRes == 0) {
@@ -313,7 +592,6 @@ static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOf
         // todo set retry dynamic time
         int32_t retry = tsProjectExecInterval;
         tscError("0x%"PRIx64" stream:%p, retrieve no data, code:0x%08x, retry in %" PRId32 "ms", pSql->self, pStream, numOfRows, retry);
-
         tscSetRetryTimer(pStream, pStream->pSql, retry);
         return;
       }
@@ -378,28 +656,33 @@ static void tscSetRetryTimer(SSqlStream *pStream, SSqlObj *pSql, int64_t timer)
   taosTmrReset(tscProcessStreamTimer, (int32_t)timer, pStream, tscTmr, &pStream->pTimer);
 }
 
+// get need delay time for every launch to exeucte query, include first and next launch 
 static int64_t getLaunchTimeDelay(const SSqlStream* pStream) {
+  // step 1 read setting delay time in taos.cfg
   int64_t maxDelay = convertTimePrecision(tsMaxStreamComputDelay, TSDB_TIME_PRECISION_MILLI, pStream->precision);
-
-  int64_t delayDelta = maxDelay;
+  int64_t ratioDelay = maxDelay;
   if (pStream->interval.intervalUnit != 'n' && pStream->interval.intervalUnit != 'y') {
-    delayDelta = (int64_t)(pStream->interval.sliding * tsStreamComputDelayRatio);
-    if (delayDelta > maxDelay) {
-      delayDelta = maxDelay;
+    ratioDelay= (int64_t)(pStream->interval.sliding * tsStreamComputDelayRatio);
+    if (ratioDelay > maxDelay) {
+      ratioDelay = maxDelay;
     }
-    int64_t remainTimeWindow = pStream->interval.sliding - delayDelta;
+    int64_t remainTimeWindow = pStream->interval.sliding - ratioDelay;
     if (maxDelay > remainTimeWindow) {
       maxDelay = (int64_t)(remainTimeWindow / 1.5f);
     }
   }
   
-  int64_t currentDelay = (rand() % maxDelay);  // a random number
-  currentDelay += delayDelta;
+  // PART 2 calc allDelay = rand delay + fixed delay
+  int64_t allDelay = (rand() % maxDelay) + ratioDelay;
   if (pStream->interval.intervalUnit != 'n' && pStream->interval.intervalUnit != 'y') {
-    assert(currentDelay < pStream->interval.sliding);
+    if(allDelay >= pStream->interval.sliding) {
+      tscWarn("CQ delay >= sliding error. delay=%" PRId64 " sliding=%" PRId64 ". so set delay=sliding/2.", allDelay, pStream->interval.sliding);
+      allDelay = pStream->interval.sliding / 2;
+    }
   }
-  
-  return currentDelay;
+
+  tscDebug("getLanchDelay allDelay=%" PRId64 "(ratioDelay=%" PRId64 ")", allDelay, ratioDelay);
+  return allDelay;
 }
 
 
@@ -424,8 +707,8 @@ static void tscSetNextLaunchTimer(SSqlStream *pStream, SSqlObj *pSql) {
       return;
     }
   } else {
-    int64_t stime = taosTimeTruncate(pStream->stime - 1, &pStream->interval, pStream->precision);
-    if (stime >= pStream->etime) {
+    int64_t tsc_stime = taosTimeTruncate(pStream->stime - 1, &pStream->interval, pStream->precision);
+    if (tsc_stime >= pStream->etime) {
       tscDebug("0x%"PRIx64" stream:%p, stime:%" PRId64 " is larger than end time: %" PRId64 ", stop the stream", pStream->pSql->self, pStream,
                pStream->stime, pStream->etime);
       // TODO : How to terminate stream here
@@ -448,7 +731,6 @@ static void tscSetNextLaunchTimer(SSqlStream *pStream, SSqlObj *pSql) {
   timer += getLaunchTimeDelay(pStream);
   
   timer = convertTimePrecision(timer, pStream->precision, TSDB_TIME_PRECISION_MILLI);
-
   tscSetRetryTimer(pStream, pSql, timer);
 }
 
@@ -505,7 +787,7 @@ static int32_t tscSetSlidingWindowInfo(SSqlObj *pSql, SSqlStream *pStream) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int64_t tscGetStreamStartTimestamp(SSqlObj *pSql, SSqlStream *pStream, int64_t stime) {
+static int64_t tscGetStreamStartTimestamp(SSqlObj *pSql, SSqlStream *pStream, int64_t tsc_stime) {
   SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   
   if (pStream->isProject) {
@@ -513,43 +795,45 @@ static int64_t tscGetStreamStartTimestamp(SSqlObj *pSql, SSqlStream *pStream, in
     pStream->interval.interval = tsProjectExecInterval;
     pStream->interval.sliding = tsProjectExecInterval;
 
-    if (stime != INT64_MIN) {  // first projection start from the latest event timestamp
-      assert(stime >= pQueryInfo->window.skey);
-      stime += 1;  // exclude the last records from table
+    if (tsc_stime != INT64_MIN) {  // first projection start from the latest event timestamp
+      assert(tsc_stime >= pQueryInfo->window.skey);
+      tsc_stime += 1;  // exclude the last records from table
     } else {
-      stime = pQueryInfo->window.skey;
+      tsc_stime = pQueryInfo->window.skey;
     }
   } else {             // timewindow based aggregation stream
-    if (stime == INT64_MIN) {  // no data in meter till now
+    if (tsc_stime == INT64_MIN) {  // no data in meter till now
       if (pQueryInfo->window.skey != INT64_MIN) {
-        stime = pQueryInfo->window.skey;
+        tsc_stime = pQueryInfo->window.skey;
       } else {
-        return stime;
+        return tsc_stime;
       }
 
-      stime = taosTimeTruncate(stime, &pStream->interval, pStream->precision);
+      tsc_stime = taosTimeTruncate(tsc_stime, &pStream->interval, pStream->precision);
     } else {
-      int64_t newStime = taosTimeTruncate(stime, &pStream->interval, pStream->precision);
-      if (newStime != stime) {
-        tscWarn("0x%"PRIx64" stream:%p, last timestamp:%" PRId64 ", reset to:%" PRId64, pSql->self, pStream, stime, newStime);
-        stime = newStime;
+      int64_t newStime = taosTimeTruncate(tsc_stime, &pStream->interval, pStream->precision);
+      if (newStime != tsc_stime) {
+        tscWarn("0x%"PRIx64" stream:%p, last timestamp:%" PRId64 ", reset to:%" PRId64, pSql->self, pStream, tsc_stime, newStime);
+        tsc_stime = newStime;
       }
     }
   }
 
-  return stime;
+  return tsc_stime;
 }
 
-static int64_t tscGetLaunchTimestamp(const SSqlStream *pStream) {
+static int64_t tscGetFirstLaunchTime(const SSqlStream *pStream) {
+  // PART 1 now to stime span
   int64_t timer = 0, now = taosGetTimestamp(pStream->precision);
   if (pStream->stime > now) {
     timer = pStream->stime - now;
   }
 
-  int64_t startDelay = convertTimePrecision(tsStreamCompStartDelay, TSDB_TIME_PRECISION_MILLI, pStream->precision);
+  // PART 2 stream first Launch need delay, setting with taos.cfg 
+  timer += convertTimePrecision(tsFirstLaunchDelay, TSDB_TIME_PRECISION_MILLI, pStream->precision);
 
+  // PART 3 every launch need delay, include first and next launch 
   timer += getLaunchTimeDelay(pStream);
-  timer += startDelay;
   
   return convertTimePrecision(timer, pStream->precision, TSDB_TIME_PRECISION_MILLI);
 }
@@ -562,6 +846,7 @@ static void tscCreateStream(void *param, TAOS_RES *res, int code) {
   if (code != TSDB_CODE_SUCCESS) {
     pSql->res.code = code;
     tscError("0x%"PRIx64" open stream failed, sql:%s, reason:%s, code:%s", pSql->self, pSql->sqlstr, pCmd->payload, tstrerror(code));
+
     pStream->fp(pStream->param, NULL, NULL);
     return;
   }
@@ -588,17 +873,17 @@ static void tscCreateStream(void *param, TAOS_RES *res, int code) {
 
   // set stime with ltime if ltime > stime
   const char* dstTable = pStream->dstTable? pStream->dstTable: "";
-  tscDebug("0x%"PRIx64" CQ table %s ltime is %"PRId64, pSql->self, dstTable, pStream->ltime);
-
+  tscDebug(" CQ table=%s ltime is %"PRId64, dstTable, pStream->ltime);
   if(pStream->ltime != INT64_MIN && pStream->ltime > pStream->stime) {
-    tscWarn("0x%"PRIx64" CQ set stream %s stime=%"PRId64" replace with ltime=%"PRId64" if ltime > 0", pSql->self, dstTable, pStream->stime, pStream->ltime);
+    tscWarn(" CQ set stream %s stime=%"PRId64" replace with ltime=%"PRId64" if ltime>0  ", dstTable, pStream->stime, pStream->ltime);
     pStream->stime = pStream->ltime;
   }
 
-  int64_t starttime = tscGetLaunchTimestamp(pStream);
+  int64_t starttime = tscGetFirstLaunchTime(pStream);
   pCmd->command = TSDB_SQL_SELECT;
 
   tscAddIntoStreamList(pStream);
+
   taosTmrReset(tscProcessStreamTimer, (int32_t)starttime, pStream, tscTmr, &pStream->pTimer);
 
   tscDebug("0x%"PRIx64" stream:%p is opened, query on:%s, interval:%" PRId64 ", sliding:%" PRId64 ", first launched in:%" PRId64 ", sql:%s", pSql->self,
@@ -665,10 +950,54 @@ void cbParseSql(void* param, TAOS_RES* res, int code) {
   char sql[128] = "";
   sprintf(sql, "select last_row(*) from %s;", pStream->dstTable); 
   taos_query_a(pSql->pTscObj, sql, fpStreamLastRow, param);
+  return ;
+}
+
+void splitStreamSql(const char *str, char **sql, char **to, char **split) {
+  // OLD FORMAT only sql  
+  if(strncmp(str, LABEL_SQL, LABEL_SQL_LEN) != 0) {
+    *sql = tmalloc(strlen(str) + 1);
+    if(*sql == NULL)
+       return ;
+    strcpy(*sql, str);
+    return ;
+  }
+
+  // NEW FORMAT sql:...to:...split:...
+  char *p1 = strstr(str + LABEL_SQL_LEN, LABEL_TO);
+  if(p1 == NULL) {
+    char *p = (char *)str + LABEL_SQL_LEN;
+    *sql = (char *)tmalloc(strlen(p) + 1);
+    strcpy(*sql, p);
+    return ;
+  }
+  // SQL value
+  int32_t len = (int32_t)(p1 - str - LABEL_SQL_LEN);
+  *sql = (char *)tmalloc(len + 1);
+  strncpy(*sql, str + LABEL_SQL_LEN, len);
+  (*sql)[len] = 0;  // str end 
+
+  // TO value
+  char *p2 = strstr(p1 + LABEL_TO_LEN, LABEL_SPLIT);
+  if(p2 == NULL) {
+    char *p = p1 + LABEL_TO_LEN;
+    *to = (char *)tmalloc(strlen(p) + 1);
+    strcpy(*to, p);
+    return ;
+  }
+  len = (int32_t)(p2 - p1 - LABEL_TO_LEN);
+  *to = (char *)tmalloc(len + 1);
+  strncpy(*to, p1 + LABEL_TO_LEN, len);
+  (*to)[len] = 0;  // str end 
+
+  // SPLIT value
+  char *p = p2 + LABEL_SPLIT_LEN; 
+  *split = (char *)tmalloc(strlen(p) + 1);
+  strcpy(*split, p);
 }
 
-TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* dstTable, const char *sqlstr, void (*fp)(void *, TAOS_RES *, TAOS_ROW),
-                              int64_t stime, void *param, void (*callback)(void *), void* cqhandle) {
+TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* dstTable, int32_t dstCols, const char *sqlstr, void (*fp)(void *param, TAOS_RES *, TAOS_ROW row),
+                              int64_t tsc_stime, void *param, void (*callback)(void *), void* cqhandle) {
   STscObj *pObj = (STscObj *)taos;
   if (pObj == NULL || pObj->signature != pObj) return NULL;
 
@@ -697,19 +1026,26 @@ TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* dstTable, const c
   }
 
   pStream->ltime = INT64_MIN;
-  pStream->stime = stime;
+  pStream->stime = tsc_stime;
   pStream->fp = fp;
   pStream->callback = callback;
   pStream->param = param;
   pStream->pSql = pSql;
   pStream->cqhandle = cqhandle;
+  pStream->dstCols = dstCols;
+  pStream->to = NULL;
+  pStream->split = NULL; 
+  pSql->pStream = pStream;
+  pSql->param = pStream;
+  pSql->maxRetry = TSDB_MAX_REPLICA;
   tscSetStreamDestTable(pStream, dstTable);
 
   pSql->pStream  = pStream;
   pSql->param    = pStream;
   pSql->maxRetry = TSDB_MAX_REPLICA;
-
-  pSql->sqlstr   = calloc(1, strlen(sqlstr) + 1);
+  
+  // split stream sqlstr to sql,to,split
+  splitStreamSql(sqlstr, &pSql->sqlstr, &pStream->to, &pStream->split);
   if (pSql->sqlstr == NULL) {
     tscError("0x%"PRIx64" failed to malloc sql string buffer", pSql->self);
     tscFreeSqlObj(pSql);
@@ -717,7 +1053,7 @@ TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* dstTable, const c
     return NULL;
   }
 
-  strtolower(pSql->sqlstr, sqlstr);
+  strtolower(pSql->sqlstr, pSql->sqlstr);
   pSql->fp      = tscCreateStream;
   pSql->fetchFp = tscCreateStream;
   pSql->cmd.resColumnId = TSDB_RES_COL_ID;
@@ -729,13 +1065,14 @@ TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* dstTable, const c
 
   pSql->fp      = cbParseSql;
   pSql->fetchFp = cbParseSql;
+
   registerSqlObj(pSql);
 
   int32_t code = tsParseSql(pSql, true);
   if (code == TSDB_CODE_SUCCESS) {
     cbParseSql(pStream, pSql, code);
   } else if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
-     tscDebug("0x%"PRIx64" CQ taso_open_stream IN Process", pSql->self);
+     tscDebug(" CQ taos_open_stream IN Process. sql=%s", sqlstr);
   } else {
     tscError("0x%"PRIx64" open stream failed, sql:%s, code:%s", pSql->self, sqlstr, tstrerror(code));
     taosReleaseRef(tscObjRef, pSql->self);
@@ -746,9 +1083,9 @@ TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* dstTable, const c
   return pStream;
 }
 
-TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *, TAOS_RES *, TAOS_ROW),
-                              int64_t stime, void *param, void (*callback)(void *)) {  
-  return taos_open_stream_withname(taos, "", sqlstr, fp, stime, param, callback, NULL);
+TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *param, TAOS_RES *, TAOS_ROW row),
+                              int64_t tsc_stime, void *param, void (*callback)(void *)) {  
+  return taos_open_stream_withname(taos, "", -1, sqlstr, fp, tsc_stime, param, callback, NULL);
 }
 
 void taos_close_stream(TAOS_STREAM *handle) {
@@ -774,6 +1111,16 @@ void taos_close_stream(TAOS_STREAM *handle) {
     pStream->fp(pStream->param, NULL, NULL);
 
     taos_free_result(pSql);
+
+    // free malloc
+    if(pStream->to) {
+      tfree(pStream->to);
+      pStream->to = NULL;
+    }
+    if(pStream->split) {
+      tfree(pStream->split);
+      pStream->split = NULL;
+    }
     tfree(pStream);
   }
 }
diff --git a/src/common/inc/tglobal.h b/src/common/inc/tglobal.h
index e1a4fe6eb8409a1d43ea5e8099f97163c6c4b8c0..06ed93b110281756ade98d5e99dd4b57b4924fc3 100644
--- a/src/common/inc/tglobal.h
+++ b/src/common/inc/tglobal.h
@@ -83,7 +83,7 @@ extern int32_t tsMaxNumOfOrderedResults;
 extern int32_t tsMinSlidingTime;
 extern int32_t tsMinIntervalTime;
 extern int32_t tsMaxStreamComputDelay;
-extern int32_t tsStreamCompStartDelay;
+extern int32_t tsFirstLaunchDelay;
 extern int32_t tsRetryStreamCompDelay;
 extern float   tsStreamComputDelayRatio;  // the delayed computing ration of the whole time window
 extern int32_t tsProjectExecInterval;
diff --git a/src/common/src/tglobal.c b/src/common/src/tglobal.c
index 6b5f3c97dd7fdb94525109028a0002396d8f95d8..af92f264dfb613035944cf80d81baf4ab8abc2f4 100644
--- a/src/common/src/tglobal.c
+++ b/src/common/src/tglobal.c
@@ -107,11 +107,11 @@ int32_t tsMinIntervalTime = 1;
 // 20sec, the maximum value of stream computing delay, changed accordingly
 int32_t tsMaxStreamComputDelay = 20000;
 
-// 10sec, the first stream computing delay time after system launched successfully, changed accordingly
-int32_t tsStreamCompStartDelay = 10000;
+// 10sec, the stream first launched to execute delay time after system launched successfully, changed accordingly
+int32_t tsFirstLaunchDelay = 10000;
 
 // the stream computing delay time after executing failed, change accordingly
-int32_t tsRetryStreamCompDelay = 10 * 1000;
+int32_t tsRetryStreamCompDelay = 30 * 60 * 1000;
 
 // The delayed computing ration. 10% of the whole computing time window by default.
 float tsStreamComputDelayRatio = 0.1f;
@@ -798,7 +798,7 @@ static void doInitGlobalConfig(void) {
   taosInitConfigOption(cfg);
 
   cfg.option = "maxFirstStreamCompDelay";
-  cfg.ptr = &tsStreamCompStartDelay;
+  cfg.ptr = &tsFirstLaunchDelay;
   cfg.valType = TAOS_CFG_VTYPE_INT32;
   cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
   cfg.minValue = 1000;
diff --git a/src/cq/src/cqMain.c b/src/cq/src/cqMain.c
index aac5a1c665c1417069b3978d10c7b1406a6b02a4..a1affc0869dca0a177ffafc6ab3309328652a696 100644
--- a/src/cq/src/cqMain.c
+++ b/src/cq/src/cqMain.c
@@ -423,7 +423,7 @@ static void cqProcessCreateTimer(void *param, void *tmrId) {
 }
 
 // inner implement in tscStream.c
-TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* desName, const char *sqlstr, void (*fp)(void *param, TAOS_RES *, TAOS_ROW row),
+TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* desName, int32_t dstCols, const char *sqlstr, void (*fp)(void *param, TAOS_RES *, TAOS_ROW row),
                               int64_t stime, void *param, void (*callback)(void *), void* cqhandle);
 
 static void cqCreateStream(SCqContext *pContext, SCqObj *pObj) {
@@ -436,9 +436,11 @@ static void cqCreateStream(SCqContext *pContext, SCqObj *pObj) {
   }
 
   pObj->tmrId = 0;
-
+  int32_t dstCols = -1;
+  if(pObj->pSchema)
+    dstCols = pObj->pSchema->numOfCols;
   if (pObj->pStream == NULL) {
-    pObj->pStream = taos_open_stream_withname(pContext->dbConn, pObj->dstTable, pObj->sqlStr, cqProcessStreamRes, \
+    pObj->pStream = taos_open_stream_withname(pContext->dbConn, pObj->dstTable, dstCols, pObj->sqlStr, cqProcessStreamRes, \
                                                INT64_MIN, (void *)pObj->rid, NULL, pContext);
 
     // TODO the pObj->pStream may be released if error happens
diff --git a/src/inc/taos.h b/src/inc/taos.h
index ea8e1d9dad61bdd513e8beded93d996ae66137dd..80fbe4ef0846867d77d34ed9384e7bd3da9fe4db 100644
--- a/src/inc/taos.h
+++ b/src/inc/taos.h
@@ -173,7 +173,11 @@ DLL_EXPORT int taos_num_fields(TAOS_RES *res);
 DLL_EXPORT int taos_affected_rows(TAOS_RES *res);
 DLL_EXPORT TAOS_FIELD *taos_fetch_fields(TAOS_RES *res);
 DLL_EXPORT int taos_select_db(TAOS *taos, const char *db);
+// row to string
 DLL_EXPORT int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields);
+DLL_EXPORT int taos_print_row_ex(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields, char split, bool addQuota);
+// one field to string 
+DLL_EXPORT int taos_print_field(char *str, void* value, TAOS_FIELD *field);
 DLL_EXPORT void taos_stop_query(TAOS_RES *res);
 DLL_EXPORT bool taos_is_null(TAOS_RES *res, int32_t row, int32_t col);
 DLL_EXPORT bool taos_is_update_query(TAOS_RES *res);
diff --git a/src/inc/trpc.h b/src/inc/trpc.h
index 0ce2e3da14d1cec204fc755db13da53f08295bff..5e3fbd571ef4b6425f2e5a58c308c8fc9da0b12e 100644
--- a/src/inc/trpc.h
+++ b/src/inc/trpc.h
@@ -92,6 +92,7 @@ int   rpcGetConnInfo(void *thandle, SRpcConnInfo *pInfo);
 void  rpcSendRecv(void *shandle, SRpcEpSet *pEpSet, SRpcMsg *pReq, SRpcMsg *pRsp);
 int   rpcReportProgress(void *pConn, char *pCont, int contLen);
 void  rpcCancelRequest(int64_t rid);
+int32_t rpcUnusedSession(void * rpcInfo, bool bLock);
 
 #ifdef __cplusplus
 }
diff --git a/src/inc/ttokendef.h b/src/inc/ttokendef.h
index 7d721d21a0b85bb3e7119977f74f3e05e69cc361..a141aa7ffaf6f9e4e351abf931462efb1df3eb1e 100644
--- a/src/inc/ttokendef.h
+++ b/src/inc/ttokendef.h
@@ -136,86 +136,88 @@
 #define TK_UNSIGNED                       118
 #define TK_TAGS                           119
 #define TK_USING                          120
-#define TK_NULL                           121
-#define TK_NOW                            122
-#define TK_VARIABLE                       123
-#define TK_SELECT                         124
-#define TK_UNION                          125
-#define TK_ALL                            126
-#define TK_DISTINCT                       127
-#define TK_FROM                           128
-#define TK_RANGE                          129
-#define TK_INTERVAL                       130
-#define TK_EVERY                          131
-#define TK_SESSION                        132
-#define TK_STATE_WINDOW                   133
-#define TK_FILL                           134
-#define TK_SLIDING                        135
-#define TK_ORDER                          136
-#define TK_BY                             137
-#define TK_ASC                            138
-#define TK_GROUP                          139
-#define TK_HAVING                         140
-#define TK_LIMIT                          141
-#define TK_OFFSET                         142
-#define TK_SLIMIT                         143
-#define TK_SOFFSET                        144
-#define TK_WHERE                          145
-#define TK_RESET                          146
-#define TK_QUERY                          147
-#define TK_SYNCDB                         148
-#define TK_ADD                            149
-#define TK_COLUMN                         150
-#define TK_MODIFY                         151
-#define TK_TAG                            152
-#define TK_CHANGE                         153
-#define TK_SET                            154
-#define TK_KILL                           155
-#define TK_CONNECTION                     156
-#define TK_STREAM                         157
-#define TK_COLON                          158
-#define TK_ABORT                          159
-#define TK_AFTER                          160
-#define TK_ATTACH                         161
-#define TK_BEFORE                         162
-#define TK_BEGIN                          163
-#define TK_CASCADE                        164
-#define TK_CLUSTER                        165
-#define TK_CONFLICT                       166
-#define TK_COPY                           167
-#define TK_DEFERRED                       168
-#define TK_DELIMITERS                     169
-#define TK_DETACH                         170
-#define TK_EACH                           171
-#define TK_END                            172
-#define TK_EXPLAIN                        173
-#define TK_FAIL                           174
-#define TK_FOR                            175
-#define TK_IGNORE                         176
-#define TK_IMMEDIATE                      177
-#define TK_INITIALLY                      178
-#define TK_INSTEAD                        179
-#define TK_KEY                            180
-#define TK_OF                             181
-#define TK_RAISE                          182
-#define TK_REPLACE                        183
-#define TK_RESTRICT                       184
-#define TK_ROW                            185
-#define TK_STATEMENT                      186
-#define TK_TRIGGER                        187
-#define TK_VIEW                           188
-#define TK_IPTOKEN                        189
-#define TK_SEMI                           190
-#define TK_NONE                           191
-#define TK_PREV                           192
-#define TK_LINEAR                         193
-#define TK_IMPORT                         194
-#define TK_TBNAME                         195
-#define TK_JOIN                           196
-#define TK_INSERT                         197
-#define TK_INTO                           198
-#define TK_VALUES                         199
-#define TK_FILE                           200
+#define TK_TO                             121
+#define TK_SPLIT                          122
+#define TK_NULL                           123
+#define TK_NOW                            124
+#define TK_VARIABLE                       125
+#define TK_SELECT                         126
+#define TK_UNION                          127
+#define TK_ALL                            128
+#define TK_DISTINCT                       129
+#define TK_FROM                           130
+#define TK_RANGE                          131
+#define TK_INTERVAL                       132
+#define TK_EVERY                          133
+#define TK_SESSION                        134
+#define TK_STATE_WINDOW                   135
+#define TK_FILL                           136
+#define TK_SLIDING                        137
+#define TK_ORDER                          138
+#define TK_BY                             139
+#define TK_ASC                            140
+#define TK_GROUP                          141
+#define TK_HAVING                         142
+#define TK_LIMIT                          143
+#define TK_OFFSET                         144
+#define TK_SLIMIT                         145
+#define TK_SOFFSET                        146
+#define TK_WHERE                          147
+#define TK_RESET                          148
+#define TK_QUERY                          149
+#define TK_SYNCDB                         150
+#define TK_ADD                            151
+#define TK_COLUMN                         152
+#define TK_MODIFY                         153
+#define TK_TAG                            154
+#define TK_CHANGE                         155
+#define TK_SET                            156
+#define TK_KILL                           157
+#define TK_CONNECTION                     158
+#define TK_STREAM                         159
+#define TK_COLON                          160
+#define TK_ABORT                          161
+#define TK_AFTER                          162
+#define TK_ATTACH                         163
+#define TK_BEFORE                         164
+#define TK_BEGIN                          165
+#define TK_CASCADE                        166
+#define TK_CLUSTER                        167
+#define TK_CONFLICT                       168
+#define TK_COPY                           169
+#define TK_DEFERRED                       170
+#define TK_DELIMITERS                     171
+#define TK_DETACH                         172
+#define TK_EACH                           173
+#define TK_END                            174
+#define TK_EXPLAIN                        175
+#define TK_FAIL                           176
+#define TK_FOR                            177
+#define TK_IGNORE                         178
+#define TK_IMMEDIATE                      179
+#define TK_INITIALLY                      180
+#define TK_INSTEAD                        181
+#define TK_KEY                            182
+#define TK_OF                             183
+#define TK_RAISE                          184
+#define TK_REPLACE                        185
+#define TK_RESTRICT                       186
+#define TK_ROW                            187
+#define TK_STATEMENT                      188
+#define TK_TRIGGER                        189
+#define TK_VIEW                           190
+#define TK_IPTOKEN                        191
+#define TK_SEMI                           192
+#define TK_NONE                           193
+#define TK_PREV                           194
+#define TK_LINEAR                         195
+#define TK_IMPORT                         196
+#define TK_TBNAME                         197
+#define TK_JOIN                           198
+#define TK_INSERT                         199
+#define TK_INTO                           200
+#define TK_VALUES                         201
+#define TK_FILE                           202
 
 
 #define TK_SPACE                          300
diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index 2b49dcbcef679e8d54367a8d524657d02314b67f..074516a2fe5e94d50e7ec5345e3603017c2116df 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -851,15 +851,15 @@ static int32_t mnodeProcessBatchCreateTableMsg(SMnodeMsg *pMsg) {
       memcpy(pSubMsg->pCont + sizeof(SCMCreateTableMsg), p, htonl(p->len));
       code = mnodeValidateCreateTableMsg(p, pSubMsg);
 
-      if (code == TSDB_CODE_SUCCESS || code == TSDB_CODE_MND_TABLE_ALREADY_EXIST) {
-	++pSubMsg->pBatchMasterMsg->successed;
-	mnodeDestroySubMsg(pSubMsg);
-	continue;
+      if (code == TSDB_CODE_SUCCESS || ( p->igExists == 1 && code == TSDB_CODE_MND_TABLE_ALREADY_EXIST )) {
+        ++pSubMsg->pBatchMasterMsg->successed;
+        mnodeDestroySubMsg(pSubMsg);
+        continue;
       }
 
       if (code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-	mnodeDestroySubMsg(pSubMsg);
-	return code;
+        mnodeDestroySubMsg(pSubMsg);
+        return code;
       }
     }
 
@@ -1046,11 +1046,21 @@ static int32_t mnodeCreateSuperTableCb(SMnodeMsg *pMsg, int32_t code) {
 
   if (code == TSDB_CODE_SUCCESS) {
     mLInfo("stable:%s, is created in sdb, uid:%" PRIu64, pTable->info.tableId, pTable->uid);
+    if(pMsg->pBatchMasterMsg)
+      pMsg->pBatchMasterMsg->successed ++;    
   } else {
     mError("msg:%p, app:%p stable:%s, failed to create in sdb, reason:%s", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId,
            tstrerror(code));
     SSdbRow desc = {.type = SDB_OPER_GLOBAL, .pObj = pTable, .pTable = tsSuperTableSdb};
     sdbDeleteRow(&desc);
+    if(pMsg->pBatchMasterMsg)
+      pMsg->pBatchMasterMsg->received ++;
+  }
+
+  // if super table create by batch msg, check done and send finished to client
+  if(pMsg->pBatchMasterMsg) {
+    if (pMsg->pBatchMasterMsg->successed + pMsg->pBatchMasterMsg->received >= pMsg->pBatchMasterMsg->expected)
+      dnodeSendRpcMWriteRsp(pMsg->pBatchMasterMsg, code);    
   }
 
   return code;
diff --git a/src/query/inc/qSqlparser.h b/src/query/inc/qSqlparser.h
index f3253c0d8396582454f9d4ef39e09f6ade181d5f..14ddb185d2a960483d5a932ec414240f48305663 100644
--- a/src/query/inc/qSqlparser.h
+++ b/src/query/inc/qSqlparser.h
@@ -25,6 +25,7 @@ extern "C" {
 #include "tstrbuild.h"
 #include "ttoken.h"
 #include "tvariant.h"
+#include "tname.h"
 
 #define ParseTOKENTYPE SStrToken
 
@@ -156,8 +157,11 @@ typedef struct SCreatedTableInfo {
 
 typedef struct SCreateTableSql {
   SStrToken          name;  // table name, create table [name] xxx
+  SStrToken          to;    // create stream to anohter table  
+  SStrToken          split; // split columns  
   int8_t             type;  // create normal table/from super table/ stream
   bool               existCheck;
+  SName              toSName;
 
   struct {
     SArray          *pTagColumns; // SArray<TAOS_FIELD>
@@ -334,6 +338,7 @@ SArray   *setSubclause(SArray *pList, void *pSqlNode);
 SArray   *appendSelectClause(SArray *pList, void *pSubclause);
 
 void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pTableNameToken, SStrToken *pIfNotExists);
+void setCreatedStreamOpt(SSqlInfo *pInfo, SStrToken *pTo, SStrToken *pSplit);
 
 void SqlInfoDestroy(SSqlInfo *pInfo);
 
diff --git a/src/query/inc/sql.y b/src/query/inc/sql.y
index e8aea259ce3718b13d697e84db54ebd7fe8a6bd6..f6a488c75cf3c8e4644a21f8fa8d42e410547cb7 100644
--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
@@ -411,14 +411,28 @@ tagNamelist(A) ::= ids(X).                      {A = taosArrayInit(4, sizeof(SSt
 
 // 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). {
+create_table_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) to_opt(E) split_opt(F) AS select(S). {
   A = tSetCreateTableInfo(NULL, NULL, S, TSQL_CREATE_STREAM);
   setSqlInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
 
+  setCreatedStreamOpt(pInfo, &E, &F);
   V.n += Z.n;
   setCreatedTableName(pInfo, &V, &U);
 }
 
+// to_opt
+%type to_opt {SStrToken}
+to_opt(A) ::= . {A.n = 0;}
+to_opt(A) ::= TO ids(X) cpxName(Y). {
+   A = X;
+   A.n += Y.n;
+}
+
+// split_opt
+%type to_split {SStrToken}
+split_opt(A) ::= . {A.n = 0;}
+split_opt(A) ::= SPLIT ids(X). { A = X;}
+
 %type column{TAOS_FIELD}
 %type columnlist{SArray*}
 %destructor columnlist {taosArrayDestroy(&$$);}
diff --git a/src/query/src/qSqlParser.c b/src/query/src/qSqlParser.c
index 707be41c5842efe1810eb8a478e9e25ad402a8ba..a8ce8b3612dab0da7a3440373e37a59684275fed 100644
--- a/src/query/src/qSqlParser.c
+++ b/src/query/src/qSqlParser.c
@@ -1244,6 +1244,11 @@ void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pTableNameToken, SStrToken
   pInfo->pCreateTableInfo->existCheck = (pIfNotExists->n != 0);
 }
 
+void setCreatedStreamOpt(SSqlInfo *pInfo, SStrToken *pTo, SStrToken *pSplit) {
+  pInfo->pCreateTableInfo->to = *pTo;
+  pInfo->pCreateTableInfo->split = *pSplit;
+}
+
 void setDCLSqlElems(SSqlInfo *pInfo, int32_t type, int32_t nParam, ...) {
   pInfo->type = type;
   if (nParam == 0) {
diff --git a/src/query/src/queryMain.c b/src/query/src/queryMain.c
index a481f99cc8b4526a0f12dd73532ede8ccc8a53f8..b2941a8fe00511902165403bd0e36f6cad8219af 100644
--- a/src/query/src/queryMain.c
+++ b/src/query/src/queryMain.c
@@ -225,51 +225,6 @@ int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryMsg, qi
   return code;
 }
 
-#ifdef TEST_IMPL
-// wait moment
-int waitMoment(SQInfo* pQInfo){
-  if(pQInfo->sql) {
-    int ms = 0;
-    char* pcnt = strstr(pQInfo->sql, " count(*)");
-    if(pcnt) return 0;
-    
-    char* pos = strstr(pQInfo->sql, " t_");
-    if(pos){
-      pos += 3;
-      ms = atoi(pos);
-      while(*pos >= '0' && *pos <= '9'){
-        pos ++;
-      }
-      char unit_char = *pos;
-      if(unit_char == 'h'){
-        ms *= 3600*1000;
-      } else if(unit_char == 'm'){
-        ms *= 60*1000;
-      } else if(unit_char == 's'){
-        ms *= 1000;
-      }
-    }
-    if(ms == 0) return 0;
-    printf("test wait sleep %dms. sql=%s ...\n", ms, pQInfo->sql);
-    
-    if(ms < 1000) {
-      taosMsleep(ms);
-    } else {
-      int used_ms = 0;
-      while(used_ms < ms) {
-        taosMsleep(1000);
-        used_ms += 1000;
-        if(isQueryKilled(pQInfo)){
-          printf("test check query is canceled, sleep break.%s\n", pQInfo->sql);
-          break;
-        }
-      }
-    }
-  }
-  return 1;
-}
-#endif
-
 bool qTableQuery(qinfo_t qinfo, uint64_t *qId) {
   SQInfo *pQInfo = (SQInfo *)qinfo;
   assert(pQInfo && pQInfo->signature == pQInfo);
diff --git a/src/query/src/sql.c b/src/query/src/sql.c
index 38115561fbc7627f80f1bf8cd26dd4ad372ccae5..a278b6fca286efba46cc915530ba5aca7cbdf7e1 100644
--- a/src/query/src/sql.c
+++ b/src/query/src/sql.c
@@ -1,5 +1,3 @@
-/* This file is automatically generated by Lemon from input grammar
-** source file "sql.y". */
 /*
 ** 2000-05-29
 **
@@ -24,7 +22,10 @@
 ** The following is the concatenation of all %include directives from the
 ** input grammar file:
 */
+#include <stdio.h>
+#include <assert.h>
 /************ Begin %include sections from the grammar ************************/
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -37,211 +38,11 @@
 #include "tutil.h"
 #include "tvariant.h"
 /**************** End of %include directives **********************************/
-/* These constants specify the various numeric values for terminal symbols.
-***************** Begin token definitions *************************************/
-#ifndef TK_ID
-#define TK_ID                              1
-#define TK_BOOL                            2
-#define TK_TINYINT                         3
-#define TK_SMALLINT                        4
-#define TK_INTEGER                         5
-#define TK_BIGINT                          6
-#define TK_FLOAT                           7
-#define TK_DOUBLE                          8
-#define TK_STRING                          9
-#define TK_TIMESTAMP                      10
-#define TK_BINARY                         11
-#define TK_NCHAR                          12
-#define TK_JSON                           13
-#define TK_OR                             14
-#define TK_AND                            15
-#define TK_NOT                            16
-#define TK_EQ                             17
-#define TK_NE                             18
-#define TK_ISNULL                         19
-#define TK_NOTNULL                        20
-#define TK_IS                             21
-#define TK_LIKE                           22
-#define TK_MATCH                          23
-#define TK_NMATCH                         24
-#define TK_CONTAINS                       25
-#define TK_GLOB                           26
-#define TK_BETWEEN                        27
-#define TK_IN                             28
-#define TK_GT                             29
-#define TK_GE                             30
-#define TK_LT                             31
-#define TK_LE                             32
-#define TK_BITAND                         33
-#define TK_BITOR                          34
-#define TK_LSHIFT                         35
-#define TK_RSHIFT                         36
-#define TK_PLUS                           37
-#define TK_MINUS                          38
-#define TK_DIVIDE                         39
-#define TK_TIMES                          40
-#define TK_STAR                           41
-#define TK_SLASH                          42
-#define TK_REM                            43
-#define TK_UMINUS                         44
-#define TK_UPLUS                          45
-#define TK_BITNOT                         46
-#define TK_ARROW                          47
-#define TK_SHOW                           48
-#define TK_DATABASES                      49
-#define TK_TOPICS                         50
-#define TK_FUNCTIONS                      51
-#define TK_MNODES                         52
-#define TK_DNODES                         53
-#define TK_ACCOUNTS                       54
-#define TK_USERS                          55
-#define TK_MODULES                        56
-#define TK_QUERIES                        57
-#define TK_CONNECTIONS                    58
-#define TK_STREAMS                        59
-#define TK_VARIABLES                      60
-#define TK_SCORES                         61
-#define TK_GRANTS                         62
-#define TK_VNODES                         63
-#define TK_DOT                            64
-#define TK_CREATE                         65
-#define TK_TABLE                          66
-#define TK_STABLE                         67
-#define TK_DATABASE                       68
-#define TK_TABLES                         69
-#define TK_STABLES                        70
-#define TK_VGROUPS                        71
-#define TK_DROP                           72
-#define TK_TOPIC                          73
-#define TK_FUNCTION                       74
-#define TK_DNODE                          75
-#define TK_USER                           76
-#define TK_ACCOUNT                        77
-#define TK_USE                            78
-#define TK_DESCRIBE                       79
-#define TK_DESC                           80
-#define TK_ALTER                          81
-#define TK_PASS                           82
-#define TK_PRIVILEGE                      83
-#define TK_LOCAL                          84
-#define TK_COMPACT                        85
-#define TK_LP                             86
-#define TK_RP                             87
-#define TK_IF                             88
-#define TK_EXISTS                         89
-#define TK_AS                             90
-#define TK_OUTPUTTYPE                     91
-#define TK_AGGREGATE                      92
-#define TK_BUFSIZE                        93
-#define TK_PPS                            94
-#define TK_TSERIES                        95
-#define TK_DBS                            96
-#define TK_STORAGE                        97
-#define TK_QTIME                          98
-#define TK_CONNS                          99
-#define TK_STATE                          100
-#define TK_COMMA                          101
-#define TK_KEEP                           102
-#define TK_CACHE                          103
-#define TK_REPLICA                        104
-#define TK_QUORUM                         105
-#define TK_DAYS                           106
-#define TK_MINROWS                        107
-#define TK_MAXROWS                        108
-#define TK_BLOCKS                         109
-#define TK_CTIME                          110
-#define TK_WAL                            111
-#define TK_FSYNC                          112
-#define TK_COMP                           113
-#define TK_PRECISION                      114
-#define TK_UPDATE                         115
-#define TK_CACHELAST                      116
-#define TK_PARTITIONS                     117
-#define TK_UNSIGNED                       118
-#define TK_TAGS                           119
-#define TK_USING                          120
-#define TK_NULL                           121
-#define TK_NOW                            122
-#define TK_VARIABLE                       123
-#define TK_SELECT                         124
-#define TK_UNION                          125
-#define TK_ALL                            126
-#define TK_DISTINCT                       127
-#define TK_FROM                           128
-#define TK_RANGE                          129
-#define TK_INTERVAL                       130
-#define TK_EVERY                          131
-#define TK_SESSION                        132
-#define TK_STATE_WINDOW                   133
-#define TK_FILL                           134
-#define TK_SLIDING                        135
-#define TK_ORDER                          136
-#define TK_BY                             137
-#define TK_ASC                            138
-#define TK_GROUP                          139
-#define TK_HAVING                         140
-#define TK_LIMIT                          141
-#define TK_OFFSET                         142
-#define TK_SLIMIT                         143
-#define TK_SOFFSET                        144
-#define TK_WHERE                          145
-#define TK_RESET                          146
-#define TK_QUERY                          147
-#define TK_SYNCDB                         148
-#define TK_ADD                            149
-#define TK_COLUMN                         150
-#define TK_MODIFY                         151
-#define TK_TAG                            152
-#define TK_CHANGE                         153
-#define TK_SET                            154
-#define TK_KILL                           155
-#define TK_CONNECTION                     156
-#define TK_STREAM                         157
-#define TK_COLON                          158
-#define TK_ABORT                          159
-#define TK_AFTER                          160
-#define TK_ATTACH                         161
-#define TK_BEFORE                         162
-#define TK_BEGIN                          163
-#define TK_CASCADE                        164
-#define TK_CLUSTER                        165
-#define TK_CONFLICT                       166
-#define TK_COPY                           167
-#define TK_DEFERRED                       168
-#define TK_DELIMITERS                     169
-#define TK_DETACH                         170
-#define TK_EACH                           171
-#define TK_END                            172
-#define TK_EXPLAIN                        173
-#define TK_FAIL                           174
-#define TK_FOR                            175
-#define TK_IGNORE                         176
-#define TK_IMMEDIATE                      177
-#define TK_INITIALLY                      178
-#define TK_INSTEAD                        179
-#define TK_KEY                            180
-#define TK_OF                             181
-#define TK_RAISE                          182
-#define TK_REPLACE                        183
-#define TK_RESTRICT                       184
-#define TK_ROW                            185
-#define TK_STATEMENT                      186
-#define TK_TRIGGER                        187
-#define TK_VIEW                           188
-#define TK_IPTOKEN                        189
-#define TK_SEMI                           190
-#define TK_NONE                           191
-#define TK_PREV                           192
-#define TK_LINEAR                         193
-#define TK_IMPORT                         194
-#define TK_TBNAME                         195
-#define TK_JOIN                           196
-#define TK_INSERT                         197
-#define TK_INTO                           198
-#define TK_VALUES                         199
-#define TK_FILE                           200
-#endif
-/**************** End token definitions ***************************************/
+/* These constants specify the various numeric values for terminal symbols
+** in a format understandable to "makeheaders".  This section is blank unless
+** "lemon" is run with the "-m" command-line option.
+***************** Begin makeheaders token definitions *************************/
+/**************** End makeheaders token definitions ***************************/
 
 /* The next sections is a series of control #defines.
 ** various aspects of the generated parser.
@@ -299,30 +100,30 @@
 #endif
 /************* Begin control #defines *****************************************/
 #define YYCODETYPE unsigned short int
-#define YYNOCODE 284
+#define YYNOCODE 289
 #define YYACTIONTYPE unsigned short int
 #define ParseTOKENTYPE SStrToken
 typedef union {
   int yyinit;
   ParseTOKENTYPE yy0;
-  SCreateTableSql* yy6;
-  SSqlNode* yy16;
-  tSqlExpr* yy18;
-  SIntervalVal yy32;
-  SRelationInfo* yy36;
-  SLimitVal yy38;
-  SCreateAcctInfo yy51;
-  int64_t yy69;
-  SRangeVal yy124;
-  SSessionWindowVal yy155;
-  tVariant yy162;
-  SArray* yy189;
-  SCreatedTableInfo yy208;
-  TAOS_FIELD yy279;
-  SWindowStateVal yy336;
-  int yy420;
-  SCreateDbInfo yy470;
-  int32_t yy516;
+  SRangeVal yy22;
+  SCreatedTableInfo yy34;
+  tVariant yy54;
+  int64_t yy55;
+  SIntervalVal yy102;
+  SSessionWindowVal yy115;
+  SSqlNode* yy160;
+  SCreateAcctInfo yy205;
+  SArray* yy209;
+  SWindowStateVal yy290;
+  int yy332;
+  TAOS_FIELD yy369;
+  int32_t yy380;
+  SCreateTableSql* yy404;
+  SRelationInfo* yy530;
+  SLimitVal yy534;
+  SCreateDbInfo yy560;
+  tSqlExpr* yy574;
 } YYMINORTYPE;
 #ifndef YYSTACKDEPTH
 #define YYSTACKDEPTH 100
@@ -338,18 +139,17 @@ typedef union {
 #define ParseCTX_FETCH
 #define ParseCTX_STORE
 #define YYFALLBACK 1
-#define YYNSTATE             393
-#define YYNRULE              315
-#define YYNRULE_WITH_ACTION  315
-#define YYNTOKEN             201
-#define YY_MAX_SHIFT         392
-#define YY_MIN_SHIFTREDUCE   617
-#define YY_MAX_SHIFTREDUCE   931
-#define YY_ERROR_ACTION      932
-#define YY_ACCEPT_ACTION     933
-#define YY_NO_ACTION         934
-#define YY_MIN_REDUCE        935
-#define YY_MAX_REDUCE        1249
+#define YYNSTATE             398
+#define YYNRULE              319
+#define YYNTOKEN             203
+#define YY_MAX_SHIFT         397
+#define YY_MIN_SHIFTREDUCE   624
+#define YY_MAX_SHIFTREDUCE   942
+#define YY_ERROR_ACTION      943
+#define YY_ACCEPT_ACTION     944
+#define YY_NO_ACTION         945
+#define YY_MIN_REDUCE        946
+#define YY_MAX_REDUCE        1264
 /************* End control #defines *******************************************/
 #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))
 
@@ -416,313 +216,318 @@ typedef union {
 **  yy_default[]       Default action for each state.
 **
 *********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (845)
+#define YY_ACTTAB_COUNT (864)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */   102,  668,  668, 1166,  159, 1167,  310,  810,  258,  669,
- /*    10 */   669,  813,  391,  239,   37,   38,   24,   41,   42, 1084,
- /*    20 */  1076,  261,   31,   30,   29, 1089, 1223,   40,  342,   45,
- /*    30 */    43,   46,   44, 1073, 1074,   55, 1077,   36,   35,  296,
- /*    40 */   297,   34,   33,   32,   37,   38,  211,   41,   42,  248,
- /*    50 */    84,  261,   31,   30,   29,  212, 1223,   40,  342,   45,
- /*    60 */    43,   46,   44,  933,  392, 1223,  254,   36,   35,  209,
- /*    70 */   213,   34,   33,   32,  291,  290,  128,  122,  133, 1223,
- /*    80 */  1223, 1226, 1225,  132, 1075,  138,  141,  131,   37,   38,
- /*    90 */    85,   41,   42,  983,  135,  261,   31,   30,   29,  668,
- /*   100 */   194,   40,  342,   45,   43,   46,   44,  669,  338,  285,
- /*   110 */    13,   36,   35, 1105,  101,   34,   33,   32,   37,   38,
- /*   120 */    58,   41,   42,   60,  244,  261,   31,   30,   29,  218,
- /*   130 */   284,   40,  342,   45,   43,   46,   44,  314,   97, 1223,
- /*   140 */    96,   36,   35,  668,  104,   34,   33,   32,  338,   37,
- /*   150 */    39,  669,   41,   42, 1105,  174,  261,   31,   30,   29,
- /*   160 */  1114,  862,   40,  342,   45,   43,   46,   44,   34,   33,
- /*   170 */    32,  242,   36,   35,  300,  219,   34,   33,   32,  204,
- /*   180 */   202,  200,  377,   59,   51, 1223,  199,  148,  147,  146,
- /*   190 */   145,  618,  619,  620,  621,  622,  623,  624,  625,  626,
- /*   200 */   627,  628,  629,  630,  631,  157,  993,  240,   38,  276,
- /*   210 */    41,   42,   59,  194,  261,   31,   30,   29,  280,  279,
- /*   220 */    40,  342,   45,   43,   46,   44,  984,  220,  241, 1111,
- /*   230 */    36,   35, 1087,  194,   34,   33,   32, 1223,   41,   42,
- /*   240 */   385, 1021,  261,   31,   30,   29,  822,  823,   40,  342,
- /*   250 */    45,   43,   46,   44,  390,  388,  645,  251,   36,   35,
- /*   260 */   704, 1087,   34,   33,   32,   67,  336,  384,  383,  335,
- /*   270 */   334,  333,  382,  332,  331,  330,  381,  329,  380,  379,
- /*   280 */  1052, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048,
- /*   290 */  1049, 1050, 1051, 1053, 1054,  232,  877,   25, 1215,  866,
- /*   300 */  1164,  869, 1165,  872,  776,   59,   59,  773, 1223,  774,
- /*   310 */   868,  775,  871,  867,  217,  870,  232,  877,   59, 1245,
- /*   320 */   866,  225,  869, 1214,  872,  340,  264,  144,  143,  142,
- /*   330 */   224,  237,  238, 1223,  350,   91,    5,   62,  184,  266,
- /*   340 */   267,  257,  313,  183,  111,  116,  107,  115,  270,   59,
- /*   350 */   252,  354,  237,  238, 1087, 1087,  344,   45,   43,   46,
- /*   360 */    44,   67,  325,  384,  383,   36,   35, 1086,  382,   34,
- /*   370 */    33,   32,  381,   68,  380,  379,  100,   59,  262, 1060,
- /*   380 */    47, 1058, 1059,   36,   35, 1237, 1061,   34,   33,   32,
- /*   390 */  1062,   86, 1063, 1064,  355,  283,  341,   83, 1087,   59,
- /*   400 */   752,   47,  213,  265,  233,  263,  246,  353,  352,   59,
- /*   410 */  1090,   59, 1223,  292, 1226,  878,  873,  874,  340,   59,
- /*   420 */    59,   91,  356,  777,  268,  272, 1087,  269,  875,  362,
- /*   430 */   361,  876,  367,  366,  271,  260,  878,  873,  874,  213,
- /*   440 */   156,  154,  153,  253,  357,  180,  255, 1090, 1087, 1223,
- /*   450 */  1090, 1226, 1213,  235,  363,  130,  364,    6, 1087,   68,
- /*   460 */  1087,  236, 1223, 1223,  365,  369,  215,  377, 1087, 1087,
- /*   470 */   216, 1223,  221,  214,  222,  223, 1223, 1105,  105,  794,
- /*   480 */  1223,  227, 1223, 1223, 1223, 1223,  228,  271,  842,  229,
- /*   490 */   226, 1223,  791,  210,  243,  271, 1223,   88,  181, 1223,
- /*   500 */  1223,  271,   99, 1223,   98,   89,  343,    1,  182,  819,
- /*   510 */     3,  195, 1088,  829, 1078,  295,  294,  830,   76,   10,
- /*   520 */   762,   79,  317,  161,  764,  347,  319,   71,  763,  259,
- /*   530 */    54,   48,  346,  906,   60,  287,   60,  879,   71,  667,
- /*   540 */   103,  293,   71,  287, 1177,   82,  841,    9,   15, 1176,
- /*   550 */    14,    9,  249,    9,  345,  121,   17,  120,   16,  359,
- /*   560 */   358,   77,   80,  320,  783,  798,  784, 1173,  781,  865,
- /*   570 */   782,   19, 1172,   18,  127,  250,  126,  751,   21,  368,
- /*   580 */    20,  140,  139,  281,  158, 1113,   26, 1124, 1121, 1122,
- /*   590 */  1106,  288, 1126,  160, 1156,  165,  306, 1155, 1154, 1153,
- /*   600 */   176, 1085,  177, 1083,  178,  179,  998,  322,  155,  809,
- /*   610 */   323, 1103,  324,  299,  327,  328,   69,  207,   65,  339,
- /*   620 */   166,  315,  992,  245,  301,  167,  351,  303, 1244,   81,
- /*   630 */   882,   28,  118,   78, 1243, 1240,  168,  185,  169,  360,
- /*   640 */   311,  170,  309, 1236,  307,  124, 1235,  305, 1232,  171,
- /*   650 */   186, 1018,   66,  302,   61,  173,   70,  208,  980,  134,
- /*   660 */   978,  136,  298,  137,  976,  975,  273,  197,  198,  972,
- /*   670 */   971,  970,  969,  968,  967,  966,  201,  203,  958,  205,
- /*   680 */   955,   27,  206,  951,   53,  326,  286,   87,   92,  304,
- /*   690 */   378,  129,  370,  371,  372,  373,  374,  234,  256,  321,
- /*   700 */   375,  376,  386,  931,  274,  230,  275,  930,  231,  112,
- /*   710 */   997,  996,  277,  113,  278,  929,  912,  282,  911,  287,
- /*   720 */   316,   11,   90,  786,  974,   52,  973,  188, 1019,  187,
- /*   730 */   189,  190,  191,  193,  192,  149,  150,  965,    2, 1056,
- /*   740 */   151,  152,  964,  957,  956,  175, 1020,  172,    4,  289,
- /*   750 */    93,  818,   74,  816,  815,  812,  811,   75,  162, 1066,
- /*   760 */   820,  831,  163,  164,  825,   94,  247,  827,   95,  308,
- /*   770 */    63,   22,  345,  312,   12,   49,   64,   23,  318,   50,
- /*   780 */   104,  106,   56,  682,  108,  109,   57,  110,  717,  715,
- /*   790 */   714,  713,  711,  710,  709,  706,  672,  337,  114,    7,
- /*   800 */   903,  901,  881,  904,  880,  902,  883,    8,  348,  349,
- /*   810 */    72,  754,   73,  117,  753,  119,  750,  123,  125,   60,
- /*   820 */   698,  696,  688,  780,  694,  690,  779,  692,  686,  684,
- /*   830 */   720,  719,  718,  716,  712,  708,  707,  196,  670,  635,
- /*   840 */   387,  644,  642,  389,  935,
+ /*     0 */   105,  675, 1095, 1129,  944,  397,  262,  759,  675,  676,
+ /*    10 */  1181,  711, 1182,  314,   37,   38,  676,   41,   42,  396,
+ /*    20 */   243,  265,   31,   30,   29, 1087,  163,   40,  347,   45,
+ /*    30 */    43,   46,   44, 1084, 1085,   55, 1088,   36,   35,  372,
+ /*    40 */   371,   34,   33,   32,   37,   38,  252,   41,   42,  258,
+ /*    50 */    85,  265,   31,   30,   29,   24, 1120,   40,  347,   45,
+ /*    60 */    43,   46,   44,  318,  100, 1238,   99,   36,   35,  218,
+ /*    70 */   214,   34,   33,   32,  288, 1126,  131,  125,  136, 1238,
+ /*    80 */  1238, 1240, 1241,  135, 1086,  141,  144,  134,   37,   38,
+ /*    90 */    88,   41,   42,   51,  138,  265,   31,   30,   29,  295,
+ /*   100 */   294,   40,  347,   45,   43,   46,   44,  343,   34,   33,
+ /*   110 */    32,   36,   35,  343,  216,   34,   33,   32,   37,   38,
+ /*   120 */    58,   41,   42,   59, 1238,  265,   31,   30,   29,  275,
+ /*   130 */   675,   40,  347,   45,   43,   46,   44,  879,  676,  882,
+ /*   140 */   185,   36,   35,  675,  217,   34,   33,   32,   13,   37,
+ /*   150 */    39,  676,   41,   42, 1238,  382,  265,   31,   30,   29,
+ /*   160 */   280,  873,   40,  347,   45,   43,   46,   44,  245,  284,
+ /*   170 */   283, 1104,   36,   35,   59, 1102,   34,   33,   32,  209,
+ /*   180 */   207,  205,  107,   86,  390, 1032,  204,  151,  150,  149,
+ /*   190 */   148,  625,  626,  627,  628,  629,  630,  631,  632,  633,
+ /*   200 */   634,  635,  636,  637,  638,  160,  250,  244,   38, 1260,
+ /*   210 */    41,   42, 1252, 1105,  265,   31,   30,   29,  289,  255,
+ /*   220 */    40,  347,   45,   43,   46,   44, 1102,  395,  393,  652,
+ /*   230 */    36,   35,   60,  257,   34,   33,   32,  223,   41,   42,
+ /*   240 */  1105,  178,  265,   31,   30,   29,   59, 1238,   40,  347,
+ /*   250 */    45,   43,   46,   44,  159,  157,  156,  886,   36,   35,
+ /*   260 */   304,   94,   34,   33,   32,   67,  341,  389,  388,  340,
+ /*   270 */   339,  338,  387,  337,  336,  335,  386,  334,  385,  384,
+ /*   280 */    25, 1063, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058,
+ /*   290 */  1059, 1060, 1061, 1062, 1064, 1065,  802,  222, 1101,  237,
+ /*   300 */   888,   68,  296,  877,  230,  880,  878,  883,  881,  108,
+ /*   310 */   147,  146,  145,  229,  224,  237,  888,  355,   94,  877,
+ /*   320 */   259,  880,  275,  883, 1238,   10,   59, 1105,  261,   45,
+ /*   330 */    43,   46,   44,  186,  225,  241,  242,   36,   35,  349,
+ /*   340 */  1230,   34,   33,   32, 1238, 1089,    5,   62,  189,  297,
+ /*   350 */  1238,  241,  242,  188,  114,  119,  110,  118,   68,  787,
+ /*   360 */  1229,  268,  784, 1228,  785,  239,  786,  274, 1192,  240,
+ /*   370 */  1238,  256,  330, 1238,   67, 1238,  389,  388, 1102, 1238,
+ /*   380 */   287,  387,   84, 1120,   47,  386,  821,  385,  384,  238,
+ /*   390 */   824,  266,  218,  346,  270,  271, 1071,  103, 1069, 1070,
+ /*   400 */    47,  246, 1238, 1072, 1241,  833,  834, 1073,   59, 1074,
+ /*   410 */  1075,   59,   89,  853,   59,  345,   59,   59,  300,  301,
+ /*   420 */   805,  889,  884,  885,   36,   35,  887,   59,   34,   33,
+ /*   430 */    32,   59,  264,  220, 1179,  830, 1180,  889,  884,  885,
+ /*   440 */   269,   59,  267, 1238,  358,  357,  276,  221,  273,  165,
+ /*   450 */   367,  366, 1120,  359,    6,  218,  360, 1238, 1191,  361,
+ /*   460 */  1102,  362,  368, 1102,  352, 1238, 1102, 1241, 1102, 1102,
+ /*   470 */   247,  275,  369,  852,  226,  219,  370,  227,  228, 1102,
+ /*   480 */   788,  272,  348, 1102, 1238, 1238,  374, 1238, 1238,  275,
+ /*   490 */   994,  232,  233, 1102,  234,   91,  231,  199,  133,  215,
+ /*   500 */  1103, 1238, 1238,   76, 1238,  248, 1238, 1004,  809, 1238,
+ /*   510 */   382,  102,   92,  101,  199,  995,    1,  187,    3,  200,
+ /*   520 */   299,  298,  199,  840,  841,  345,  769,   79,  263,  322,
+ /*   530 */   771,  324,  770,   54,  351,  291,  917,   71,   48,  890,
+ /*   540 */    60,  674,  317,   60,   71,  106,   71,   15,   77,   14,
+ /*   550 */     9,   83,  291,    9,  285,    9,  350,  124,   17,  123,
+ /*   560 */    16,  794,  792,  795,  793,   19,  325,   18,  876,  253,
+ /*   570 */    80,  893,  364,  363,  130,   21,  129,   20,  143,  142,
+ /*   580 */  1188, 1187,  254,  758,  181,  373,   26,  161,  162, 1100,
+ /*   590 */  1128, 1139, 1171, 1136, 1137, 1141, 1121,  292,  164,  169,
+ /*   600 */  1170,  310, 1169, 1168,  180, 1096,  182,  158, 1094,  183,
+ /*   610 */   303,  820,  184,  171, 1009,  327,  328,  329,  249,  332,
+ /*   620 */   333,  172,   69,  212,   65,  344, 1003,  305, 1118,  356,
+ /*   630 */   170,  307, 1259,  121, 1258, 1255,  190,  365, 1251,  127,
+ /*   640 */  1250,   81,   78, 1247,  319,  191, 1029,   28,  315,  313,
+ /*   650 */   311,   66,  309,  306,  302,   61,   70,  176,  213,  173,
+ /*   660 */   991,  137,  989,  139,  140,  987,  986,  277,  202,  203,
+ /*   670 */    87,  983,  982,  981,  980,  979,  978,  977,  206,  208,
+ /*   680 */   969,  210,  966,   27,  211,  962,  331,  383,  290, 1098,
+ /*   690 */   132,   90,   95,  375,  308,  376,  377,  378,  379,  380,
+ /*   700 */   381,   82,  260,  391,  942,  278,  326,  279,  941,  281,
+ /*   710 */   282,  235,  940,  923,  922,  286,  115, 1008, 1007,  236,
+ /*   720 */   321,  116,  291,   11,   93,  797,  293,   52,   96,  829,
+ /*   730 */    74,  985,  827,  984,  823,  193, 1030,  194,  152,  192,
+ /*   740 */   153,  196,  195,  197,  198,  976, 1067,  320,  154,  975,
+ /*   750 */     4,  968,  179,  177,   53,  174,  175, 1031,  155,  967,
+ /*   760 */     2,  826,  822,   75,  168,  831, 1077,  166,  251,  842,
+ /*   770 */   167,   63,  836,   97,   22,  838,   98,  312,  350,  316,
+ /*   780 */    64,   12,   23,  104,   49,  323,   50,  107,  109,  112,
+ /*   790 */   689,  724,   56,  722,  111,  721,  720,  718,  717,   57,
+ /*   800 */   113,  716,  713,  679,  117,  342,    7,  914,  912,  915,
+ /*   810 */   892,  891,  913,    8,  353,  894,  354,   60,   72,  120,
+ /*   820 */   761,  791,  122,   73,  760,  126,  128,  757,  705,  703,
+ /*   830 */   695,  701,  697,  699,  790,  693,  691,  727,  726,  725,
+ /*   840 */   723,  719,  715,  714,  201,  677,  946,  642,  651,  649,
+ /*   850 */   945,  392,  945,  945,  945,  945,  945,  945,  945,  945,
+ /*   860 */   945,  945,  945,  394,
 };
 static const YYCODETYPE yy_lookahead[] = {
- /*     0 */   211,    1,    1,  279,  203,  281,  282,    5,  210,    9,
- /*    10 */     9,    9,  203,  204,   14,   15,  271,   17,   18,  203,
- /*    20 */     0,   21,   22,   23,   24,  253,  281,   27,   28,   29,
- /*    30 */    30,   31,   32,  244,  245,  246,  247,   37,   38,   37,
- /*    40 */    38,   41,   42,   43,   14,   15,  271,   17,   18,    1,
- /*    50 */   211,   21,   22,   23,   24,  271,  281,   27,   28,   29,
- /*    60 */    30,   31,   32,  201,  202,  281,  250,   37,   38,  271,
- /*    70 */   271,   41,   42,   43,  273,  274,   66,   67,   68,  281,
- /*    80 */   281,  283,  283,   73,  245,   75,   76,   77,   14,   15,
- /*    90 */    90,   17,   18,  209,   84,   21,   22,   23,   24,    1,
- /*   100 */   216,   27,   28,   29,   30,   31,   32,    9,   88,   87,
- /*   110 */    86,   37,   38,  251,   90,   41,   42,   43,   14,   15,
- /*   120 */    90,   17,   18,  101,  122,   21,   22,   23,   24,  271,
- /*   130 */   268,   27,   28,   29,   30,   31,   32,  278,  279,  281,
- /*   140 */   281,   37,   38,    1,  120,   41,   42,   43,   88,   14,
- /*   150 */    15,    9,   17,   18,  251,  258,   21,   22,   23,   24,
- /*   160 */   203,   87,   27,   28,   29,   30,   31,   32,   41,   42,
- /*   170 */    43,  268,   37,   38,  277,  271,   41,   42,   43,   66,
- /*   180 */    67,   68,   94,  203,   86,  281,   73,   74,   75,   76,
+ /*     0 */   213,    1,  205,  205,  203,  204,  212,    5,    1,    9,
+ /*    10 */   284,    5,  286,  287,   14,   15,    9,   17,   18,  205,
+ /*    20 */   206,   21,   22,   23,   24,    0,  205,   27,   28,   29,
+ /*    30 */    30,   31,   32,  246,  247,  248,  249,   37,   38,   37,
+ /*    40 */    38,   41,   42,   43,   14,   15,    1,   17,   18,  252,
+ /*    50 */   213,   21,   22,   23,   24,  276,  255,   27,   28,   29,
+ /*    60 */    30,   31,   32,  283,  284,  286,  286,   37,   38,  276,
+ /*    70 */   276,   41,   42,   43,  273,  277,   66,   67,   68,  286,
+ /*    80 */   286,  288,  288,   73,  247,   75,   76,   77,   14,   15,
+ /*    90 */    90,   17,   18,   86,   84,   21,   22,   23,   24,  278,
+ /*   100 */   279,   27,   28,   29,   30,   31,   32,   88,   41,   42,
+ /*   110 */    43,   37,   38,   88,  276,   41,   42,   43,   14,   15,
+ /*   120 */    90,   17,   18,  205,  286,   21,   22,   23,   24,  205,
+ /*   130 */     1,   27,   28,   29,   30,   31,   32,    5,    9,    7,
+ /*   140 */   216,   37,   38,    1,  276,   41,   42,   43,   86,   14,
+ /*   150 */    15,    9,   17,   18,  286,   94,   21,   22,   23,   24,
+ /*   160 */   149,   87,   27,   28,   29,   30,   31,   32,  250,  158,
+ /*   170 */   159,  258,   37,   38,  205,  257,   41,   42,   43,   66,
+ /*   180 */    67,   68,  120,  121,  227,  228,   73,   74,   75,   76,
  /*   190 */    77,   49,   50,   51,   52,   53,   54,   55,   56,   57,
- /*   200 */    58,   59,   60,   61,   62,   63,  209,   65,   15,  147,
- /*   210 */    17,   18,  203,  216,   21,   22,   23,   24,  156,  157,
- /*   220 */    27,   28,   29,   30,   31,   32,  209,  271,  248,  272,
- /*   230 */    37,   38,  252,  216,   41,   42,   43,  281,   17,   18,
- /*   240 */   225,  226,   21,   22,   23,   24,  130,  131,   27,   28,
- /*   250 */    29,   30,   31,   32,   69,   70,   71,  248,   37,   38,
- /*   260 */     5,  252,   41,   42,   43,  102,  103,  104,  105,  106,
+ /*   200 */    58,   59,   60,   61,   62,   63,  251,   65,   15,  258,
+ /*   210 */    17,   18,  258,  258,   21,   22,   23,   24,   87,  250,
+ /*   220 */    27,   28,   29,   30,   31,   32,  257,   69,   70,   71,
+ /*   230 */    37,   38,  101,  251,   41,   42,   43,  276,   17,   18,
+ /*   240 */   258,  263,   21,   22,   23,   24,  205,  286,   27,   28,
+ /*   250 */    29,   30,   31,   32,   66,   67,   68,  125,   37,   38,
+ /*   260 */   282,   86,   41,   42,   43,  102,  103,  104,  105,  106,
  /*   270 */   107,  108,  109,  110,  111,  112,  113,  114,  115,  116,
- /*   280 */   227,  228,  229,  230,  231,  232,  233,  234,  235,  236,
- /*   290 */   237,  238,  239,  240,  241,    1,    2,   48,  271,    5,
- /*   300 */   279,    7,  281,    9,    2,  203,  203,    5,  281,    7,
- /*   310 */     5,    9,    7,    5,   65,    7,    1,    2,  203,  253,
- /*   320 */     5,   72,    7,  271,    9,   47,   72,   78,   79,   80,
- /*   330 */    81,   37,   38,  281,   85,   86,   66,   67,   68,   37,
- /*   340 */    38,  210,   64,   73,   74,   75,   76,   77,   72,  203,
- /*   350 */   248,  248,   37,   38,  252,  252,   41,   29,   30,   31,
- /*   360 */    32,  102,   92,  104,  105,   37,   38,  252,  109,   41,
- /*   370 */    42,   43,  113,  124,  115,  116,  254,  203,  210,  227,
- /*   380 */    86,  229,  230,   37,   38,  253,  234,   41,   42,   43,
- /*   390 */   238,  269,  240,  241,  248,  146,   25,  148,  252,  203,
- /*   400 */     5,   86,  271,  149,  155,  151,  249,  153,  154,  203,
- /*   410 */   253,  203,  281,  276,  283,  121,  122,  123,   47,  203,
- /*   420 */   203,   86,  248,  121,  122,  149,  252,  151,  123,  153,
- /*   430 */   154,  123,   37,   38,  203,   64,  121,  122,  123,  271,
- /*   440 */    66,   67,   68,  249,  248,  214,  249,  253,  252,  281,
- /*   450 */   253,  283,  271,  271,  248,   82,  248,   86,  252,  124,
- /*   460 */   252,  271,  281,  281,  248,  248,  271,   94,  252,  252,
- /*   470 */   271,  281,  271,  271,  271,  271,  281,  251,  211,   41,
- /*   480 */   281,  271,  281,  281,  281,  281,  271,  203,   80,  271,
- /*   490 */   271,  281,  101,  271,  268,  203,  281,   87,  214,  281,
- /*   500 */   281,  203,  279,  281,  281,   87,  214,  212,  213,   87,
- /*   510 */   207,  208,  214,   87,  247,   37,   38,   87,  101,  128,
- /*   520 */    87,  101,   87,  101,   87,   16,   87,  101,   87,    1,
- /*   530 */    86,  101,   25,   87,  101,  125,  101,   87,  101,   87,
- /*   540 */   101,  276,  101,  125,  243,   86,  138,  101,  150,  243,
- /*   550 */   152,  101,  243,  101,   47,  150,  150,  152,  152,   37,
- /*   560 */    38,  144,  142,  119,    5,  127,    7,  243,    5,   41,
- /*   570 */     7,  150,  243,  152,  150,  243,  152,  118,  150,  243,
- /*   580 */   152,   82,   83,  203,  203,  203,  270,  203,  203,  203,
- /*   590 */   251,  251,  203,  203,  280,  203,  203,  280,  280,  280,
- /*   600 */   255,  251,  203,  203,  203,  203,  203,  203,   64,  123,
- /*   610 */   203,  267,  203,  275,  203,  203,  203,  203,  203,  203,
- /*   620 */   266,  136,  203,  275,  275,  265,  203,  275,  203,  141,
- /*   630 */   121,  140,  203,  143,  203,  203,  264,  203,  263,  203,
- /*   640 */   139,  262,  134,  203,  133,  203,  203,  132,  203,  261,
- /*   650 */   203,  203,  203,  135,  203,  259,  203,  203,  203,  203,
- /*   660 */   203,  203,  129,  203,  203,  203,  203,  203,  203,  203,
- /*   670 */   203,  203,  203,  203,  203,  203,  203,  203,  203,  203,
- /*   680 */   203,  145,  203,  203,  257,   93,  205,  205,  205,  205,
- /*   690 */   117,  100,   99,   55,   96,   98,   59,  205,  205,  205,
- /*   700 */    97,   95,   88,    5,  158,  205,    5,    5,  205,  211,
- /*   710 */   215,  215,  158,  211,    5,    5,  104,  147,  103,  125,
- /*   720 */   119,   86,  126,   87,  205,   86,  205,  222,  224,  223,
- /*   730 */   218,  221,  219,  217,  220,  206,  206,  205,  212,  242,
- /*   740 */   206,  206,  205,  205,  205,  256,  226,  260,  207,  101,
- /*   750 */   101,   87,  101,  123,  123,    5,    5,   86,   86,  242,
- /*   760 */    87,   87,   86,  101,   87,   86,    1,   87,   86,   86,
- /*   770 */   101,  137,   47,    1,   86,   86,  101,  137,  119,   86,
- /*   780 */   120,   82,   91,    5,   90,   74,   91,   90,    9,    5,
- /*   790 */     5,    5,    5,    5,    5,    5,   89,   16,   82,   86,
- /*   800 */     9,    9,   87,    9,   87,    9,  121,   86,   28,   63,
- /*   810 */    17,    5,   17,  152,    5,  152,   87,  152,  152,  101,
- /*   820 */     5,    5,    5,  123,    5,    5,  123,    5,    5,    5,
- /*   830 */     5,    5,    5,    5,    5,    5,    5,  101,   89,   64,
- /*   840 */    22,    9,    9,   22,    0,  284,  284,  284,  284,  284,
- /*   850 */   284,  284,  284,  284,  284,  284,  284,  284,  284,  284,
- /*   860 */   284,  284,  284,  284,  284,  284,  284,  284,  284,  284,
- /*   870 */   284,  284,  284,  284,  284,  284,  284,  284,  284,  284,
- /*   880 */   284,  284,  284,  284,  284,  284,  284,  284,  284,  284,
- /*   890 */   284,  284,  284,  284,  284,  284,  284,  284,  284,  284,
- /*   900 */   284,  284,  284,  284,  284,  284,  284,  284,  284,  284,
- /*   910 */   284,  284,  284,  284,  284,  284,  284,  284,  284,  284,
- /*   920 */   284,  284,  284,  284,  284,  284,  284,  284,  284,  284,
- /*   930 */   284,  284,  284,  284,  284,  284,  284,  284,  284,  284,
- /*   940 */   284,  284,  284,  284,  284,  284,  284,  284,  284,  284,
- /*   950 */   284,  284,  284,  284,  284,  284,  284,  284,  284,  284,
- /*   960 */   284,  284,  284,  284,  284,  284,  284,  284,  284,  284,
- /*   970 */   284,  284,  284,  284,  284,  284,  284,  284,  284,  284,
- /*   980 */   284,  284,  284,  284,  284,  284,  284,  284,  284,  284,
- /*   990 */   284,  284,  284,  284,  284,  284,  284,  284,  284,  284,
- /*  1000 */   284,  284,  284,  284,  284,  284,  284,  284,  284,  284,
- /*  1010 */   284,  284,  284,  284,  284,  284,  284,  284,  284,  284,
- /*  1020 */   284,  284,  284,  284,  284,  284,  284,  284,  284,  284,
- /*  1030 */   284,  284,  284,  284,  284,  284,  284,  284,  284,  284,
- /*  1040 */   284,  284,  284,  284,  284,  284,
+ /*   280 */    48,  229,  230,  231,  232,  233,  234,  235,  236,  237,
+ /*   290 */   238,  239,  240,  241,  242,  243,  101,   65,  257,    1,
+ /*   300 */     2,  126,  281,    5,   72,    7,    5,    9,    7,  213,
+ /*   310 */    78,   79,   80,   81,  276,    1,    2,   85,   86,    5,
+ /*   320 */   251,    7,  205,    9,  286,  130,  205,  258,  212,   29,
+ /*   330 */    30,   31,   32,  216,  276,   37,   38,   37,   38,   41,
+ /*   340 */   276,   41,   42,   43,  286,  249,   66,   67,   68,  281,
+ /*   350 */   286,   37,   38,   73,   74,   75,   76,   77,  126,    2,
+ /*   360 */   276,   72,    5,  276,    7,  276,    9,   72,  245,  276,
+ /*   370 */   286,  250,   92,  286,  102,  286,  104,  105,  257,  286,
+ /*   380 */   148,  109,  150,  255,   86,  113,    5,  115,  116,  157,
+ /*   390 */     9,  212,  276,   25,   37,   38,  229,  259,  231,  232,
+ /*   400 */    86,  273,  286,  236,  288,  132,  133,  240,  205,  242,
+ /*   410 */   243,  205,  274,   80,  205,   47,  205,  205,   37,   38,
+ /*   420 */    41,  123,  124,  125,   37,   38,  125,  205,   41,   42,
+ /*   430 */    43,  205,   64,  276,  284,   87,  286,  123,  124,  125,
+ /*   440 */   151,  205,  153,  286,  155,  156,  151,  276,  153,  101,
+ /*   450 */   155,  156,  255,  250,   86,  276,  250,  286,  245,  250,
+ /*   460 */   257,  250,  250,  257,   16,  286,  257,  288,  257,  257,
+ /*   470 */   273,  205,  250,  140,  276,  276,  250,  276,  276,  257,
+ /*   480 */   123,  124,  216,  257,  286,  286,  250,  286,  286,  205,
+ /*   490 */   211,  276,  276,  257,  276,   87,  276,  218,   82,  276,
+ /*   500 */   216,  286,  286,  101,  286,  124,  286,  211,  129,  286,
+ /*   510 */    94,  284,   87,  286,  218,  211,  214,  215,  209,  210,
+ /*   520 */    37,   38,  218,   87,   87,   47,   87,  101,    1,   87,
+ /*   530 */    87,   87,   87,   86,   25,  127,   87,  101,  101,   87,
+ /*   540 */   101,   87,   64,  101,  101,  101,  101,  152,  146,  154,
+ /*   550 */   101,   86,  127,  101,  205,  101,   47,  152,  152,  154,
+ /*   560 */   154,    5,    5,    7,    7,  152,  119,  154,   41,  245,
+ /*   570 */   144,  123,   37,   38,  152,  152,  154,  154,   82,   83,
+ /*   580 */   245,  245,  245,  118,  253,  245,  275,  205,  205,  205,
+ /*   590 */   205,  205,  285,  205,  205,  205,  255,  255,  205,  205,
+ /*   600 */   285,  205,  285,  285,  260,  255,  205,   64,  205,  205,
+ /*   610 */   280,  125,  205,  270,  205,  205,  205,  205,  280,  205,
+ /*   620 */   205,  269,  205,  205,  205,  205,  205,  280,  272,  205,
+ /*   630 */   271,  280,  205,  205,  205,  205,  205,  205,  205,  205,
+ /*   640 */   205,  143,  145,  205,  138,  205,  205,  142,  141,  136,
+ /*   650 */   135,  205,  134,  137,  131,  205,  205,  265,  205,  268,
+ /*   660 */   205,  205,  205,  205,  205,  205,  205,  205,  205,  205,
+ /*   670 */   122,  205,  205,  205,  205,  205,  205,  205,  205,  205,
+ /*   680 */   205,  205,  205,  147,  205,  205,   93,  117,  207,  207,
+ /*   690 */   100,  207,  207,   99,  207,   55,   96,   98,   59,   97,
+ /*   700 */    95,  207,  207,   88,    5,  160,  207,    5,    5,  160,
+ /*   710 */     5,  207,    5,  104,  103,  149,  213,  217,  217,  207,
+ /*   720 */   119,  213,  127,   86,  128,   87,  101,   86,  101,   87,
+ /*   730 */   101,  207,  125,  207,    5,  224,  226,  220,  208,  225,
+ /*   740 */   208,  221,  223,  222,  219,  207,  244,  254,  208,  207,
+ /*   750 */   209,  207,  261,  264,  262,  267,  266,  228,  208,  207,
+ /*   760 */   214,  125,    5,   86,  101,   87,  244,   86,    1,   87,
+ /*   770 */    86,  101,   87,   86,  139,   87,   86,   86,   47,    1,
+ /*   780 */   101,   86,  139,   90,   86,  119,   86,  120,   82,   74,
+ /*   790 */     5,    9,   91,    5,   90,    5,    5,    5,    5,   91,
+ /*   800 */    90,    5,    5,   89,   82,   16,   86,    9,    9,    9,
+ /*   810 */    87,   87,    9,   86,   28,  123,   63,  101,   17,  154,
+ /*   820 */     5,  125,  154,   17,    5,  154,  154,   87,    5,    5,
+ /*   830 */     5,    5,    5,    5,  125,    5,    5,    5,    5,    5,
+ /*   840 */     5,    5,    5,    5,  101,   89,    0,   64,    9,    9,
+ /*   850 */   289,   22,  289,  289,  289,  289,  289,  289,  289,  289,
+ /*   860 */   289,  289,  289,   22,  289,  289,  289,  289,  289,  289,
+ /*   870 */   289,  289,  289,  289,  289,  289,  289,  289,  289,  289,
+ /*   880 */   289,  289,  289,  289,  289,  289,  289,  289,  289,  289,
+ /*   890 */   289,  289,  289,  289,  289,  289,  289,  289,  289,  289,
+ /*   900 */   289,  289,  289,  289,  289,  289,  289,  289,  289,  289,
+ /*   910 */   289,  289,  289,  289,  289,  289,  289,  289,  289,  289,
+ /*   920 */   289,  289,  289,  289,  289,  289,  289,  289,  289,  289,
+ /*   930 */   289,  289,  289,  289,  289,  289,  289,  289,  289,  289,
+ /*   940 */   289,  289,  289,  289,  289,  289,  289,  289,  289,  289,
+ /*   950 */   289,  289,  289,  289,  289,  289,  289,  289,  289,  289,
+ /*   960 */   289,  289,  289,  289,  289,  289,  289,  289,  289,  289,
+ /*   970 */   289,  289,  289,  289,  289,  289,  289,  289,  289,  289,
+ /*   980 */   289,  289,  289,  289,  289,  289,  289,  289,  289,  289,
+ /*   990 */   289,  289,  289,  289,  289,  289,  289,  289,  289,  289,
+ /*  1000 */   289,  289,  289,  289,  289,  289,  289,  289,  289,  289,
+ /*  1010 */   289,  289,  289,  289,  289,  289,  289,  289,  289,  289,
+ /*  1020 */   289,  289,  289,  289,  289,  289,  289,  289,  289,  289,
+ /*  1030 */   289,  289,  289,  289,  289,  289,  289,  289,  289,  289,
+ /*  1040 */   289,  289,  289,  289,  289,  289,  289,  289,  289,  289,
+ /*  1050 */   289,  289,  289,  289,  289,  289,  289,  289,  289,  289,
+ /*  1060 */   289,  289,  289,  289,  289,  289,  289,
 };
-#define YY_SHIFT_COUNT    (392)
+#define YY_SHIFT_COUNT    (397)
 #define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (844)
+#define YY_SHIFT_MAX      (846)
 static const unsigned short int yy_shift_ofst[] = {
- /*     0 */   249,  163,  163,  259,  259,   60,  315,  294,  294,  294,
- /*    10 */    98,    1,    1,    1,    1,    1,    1,    1,    1,    1,
- /*    20 */     1,    1,   48,   48,    0,  142,  294,  294,  294,  294,
- /*    30 */   294,  294,  294,  294,  294,  294,  294,  294,  294,  294,
- /*    40 */   294,  294,  294,  294,  294,  294,  294,  294,  302,  302,
- /*    50 */   302,  335,  335,  116,    1,   20,    1,    1,    1,    1,
- /*    60 */     1,  373,   60,   48,   48,   88,   88,  255,  845,  845,
- /*    70 */   845,  302,  302,  302,    2,    2,  395,  395,  395,  395,
- /*    80 */   395,  395,  395,    1,    1,    1,  438,    1,    1,    1,
- /*    90 */   335,  335,    1,    1,    1,    1,  408,  408,  408,  408,
- /*   100 */   391,  335,    1,    1,    1,    1,    1,    1,    1,    1,
- /*   110 */     1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
- /*   120 */     1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
- /*   130 */     1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
- /*   140 */     1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
- /*   150 */     1,    1,    1,    1,    1,    1,    1,    1,  544,  544,
- /*   160 */   544,  486,  486,  486,  486,  544,  488,  490,  485,  491,
- /*   170 */   501,  508,  511,  515,  518,  533,  536,  544,  544,  544,
- /*   180 */   592,  592,  573,   60,   60,  544,  544,  591,  593,  638,
- /*   190 */   598,  597,  637,  603,  606,  573,  255,  544,  544,  614,
- /*   200 */   614,  544,  614,  544,  614,  544,  544,  845,  845,   30,
- /*   210 */    74,  104,  104,  104,  135,  193,  221,  270,  328,  328,
- /*   220 */   328,  328,  328,  328,   10,  113,  346,  346,  346,  346,
- /*   230 */   254,  276,  371,   62,   24,  127,  127,  305,  308,  185,
- /*   240 */   374,   22,  410,  418,  478,  422,  426,  430,  278,  417,
- /*   250 */   420,  433,  435,  437,  439,  441,  444,  446,  450,  507,
- /*   260 */   528,  509,  452,  398,  405,  406,  559,  563,  522,  421,
- /*   270 */   424,  459,  428,  499,  698,  546,  701,  702,  554,  709,
- /*   280 */   710,  612,  615,  570,  594,  601,  635,  596,  636,  639,
- /*   290 */   648,  649,  664,  651,  630,  631,  750,  751,  671,  673,
- /*   300 */   672,  674,  676,  677,  662,  679,  680,  682,  765,  683,
- /*   310 */   669,  634,  725,  772,  675,  640,  688,  601,  689,  659,
- /*   320 */   693,  660,  699,  691,  694,  711,  778,  695,  697,  779,
- /*   330 */   784,  785,  786,  787,  788,  789,  790,  707,  781,  716,
- /*   340 */   791,  792,  713,  715,  717,  794,  796,  685,  721,  780,
- /*   350 */   746,  793,  661,  663,  718,  718,  718,  718,  700,  703,
- /*   360 */   795,  665,  666,  718,  718,  718,  806,  809,  729,  718,
- /*   370 */   815,  816,  817,  819,  820,  822,  823,  824,  825,  826,
- /*   380 */   827,  828,  829,  830,  831,  736,  749,  832,  818,  833,
- /*   390 */   821,  775,  844,
+ /*     0 */   232,  163,  163,  272,  272,   19,  298,  314,  314,  314,
+ /*    10 */     7,  129,  129,  129,  129,  129,  129,  129,  129,  129,
+ /*    20 */   129,  129,   45,   45,    0,  142,  314,  314,  314,  314,
+ /*    30 */   314,  314,  314,  314,  314,  314,  314,  314,  314,  314,
+ /*    40 */   314,  314,  314,  314,  314,  314,  314,  314,  357,  357,
+ /*    50 */   357,  175,  175,  273,  129,   25,  129,  129,  129,  129,
+ /*    60 */   129,  416,   19,   45,   45,   61,   61,    6,  864,  864,
+ /*    70 */   864,  357,  357,  357,  381,  381,    2,    2,    2,    2,
+ /*    80 */     2,    2,   62,    2,  129,  129,  129,  129,  129,  379,
+ /*    90 */   129,  129,  129,  175,  175,  129,  129,  129,  129,  333,
+ /*   100 */   333,  333,  333,  195,  175,  129,  129,  129,  129,  129,
+ /*   110 */   129,  129,  129,  129,  129,  129,  129,  129,  129,  129,
+ /*   120 */   129,  129,  129,  129,  129,  129,  129,  129,  129,  129,
+ /*   130 */   129,  129,  129,  129,  129,  129,  129,  129,  129,  129,
+ /*   140 */   129,  129,  129,  129,  129,  129,  129,  129,  129,  129,
+ /*   150 */   129,  129,  129,  129,  129,  129,  129,  129,  129,  129,
+ /*   160 */   129,  543,  543,  543,  543,  486,  486,  486,  486,  543,
+ /*   170 */   498,  497,  506,  505,  507,  513,  515,  518,  516,  523,
+ /*   180 */   536,  548,  543,  543,  543,  593,  593,  570,   19,   19,
+ /*   190 */   543,  543,  590,  594,  640,  600,  599,  639,  602,  605,
+ /*   200 */   570,    6,  543,  543,  615,  615,  543,  615,  543,  615,
+ /*   210 */   543,  543,  864,  864,   30,   74,  104,  104,  104,  135,
+ /*   220 */   193,  221,  280,  300,  300,  300,  300,  300,  300,   10,
+ /*   230 */   113,  387,  387,  387,  387,  289,  295,  368,   11,   67,
+ /*   240 */    67,  132,  301,  158,  188,  131,  408,  425,  483,  348,
+ /*   250 */   436,  437,  478,  402,  426,  439,  442,  443,  444,  445,
+ /*   260 */   447,  449,  452,  509,  527,  448,  454,  395,  405,  406,
+ /*   270 */   556,  557,  535,  413,  422,  465,  423,  496,  699,  545,
+ /*   280 */   702,  703,  549,  705,  707,  609,  611,  566,  595,  601,
+ /*   290 */   637,  596,  638,  641,  625,  627,  642,  629,  607,  636,
+ /*   300 */   729,  757,  677,  678,  681,  682,  684,  685,  663,  687,
+ /*   310 */   688,  690,  767,  691,  670,  635,  731,  778,  679,  643,
+ /*   320 */   693,  695,  601,  698,  666,  700,  667,  706,  701,  704,
+ /*   330 */   715,  785,  708,  710,  782,  788,  790,  791,  792,  793,
+ /*   340 */   796,  797,  714,  789,  722,  798,  799,  720,  723,  724,
+ /*   350 */   800,  803,  692,  727,  786,  753,  801,  665,  668,  716,
+ /*   360 */   716,  716,  716,  696,  709,  806,  671,  672,  716,  716,
+ /*   370 */   716,  815,  819,  740,  716,  823,  824,  825,  826,  827,
+ /*   380 */   828,  830,  831,  832,  833,  834,  835,  836,  837,  838,
+ /*   390 */   743,  756,  839,  829,  840,  841,  783,  846,
 };
-#define YY_REDUCE_COUNT (208)
-#define YY_REDUCE_MIN   (-276)
-#define YY_REDUCE_MAX   (541)
+#define YY_REDUCE_COUNT (213)
+#define YY_REDUCE_MIN   (-274)
+#define YY_REDUCE_MAX   (552)
 static const short yy_reduce_ofst[] = {
- /*     0 */  -138,   53,   53,  152,  152, -211, -202,  131,  168, -201,
- /*    10 */  -199,  -20,    9,  102,  103,  146,  174,  196,  206,  208,
- /*    20 */   216,  217, -276, -141,  -43, -191, -255, -225, -216, -142,
- /*    30 */   -96,  -44,   27,   52,  181,  182,  190,  195,  199,  201,
- /*    40 */   202,  203,  204,  210,  215,  218,  219,  222,  157,  194,
- /*    50 */   197,  -97,  226, -103, -184,  267,  231,  284,  292,  298,
- /*    60 */   115, -116, -161,   21,  223,   -3,   17,   15,  122,  295,
- /*    70 */   303, -228,   66,  132,  137,  265,  301,  306,  309,  324,
- /*    80 */   329,  332,  336,  380,  381,  382,  316,  384,  385,  386,
- /*    90 */   339,  340,  389,  390,  392,  393,  314,  317,  318,  319,
- /*   100 */   345,  350,  399,  400,  401,  402,  403,  404,  407,  409,
- /*   110 */   411,  412,  413,  414,  415,  416,  419,  423,  425,  429,
- /*   120 */   431,  432,  434,  436,  440,  442,  443,  445,  447,  448,
- /*   130 */   449,  451,  453,  454,  455,  456,  457,  458,  460,  461,
- /*   140 */   462,  463,  464,  465,  466,  467,  468,  469,  470,  471,
- /*   150 */   472,  473,  474,  475,  476,  477,  479,  480,  481,  482,
- /*   160 */   483,  338,  348,  349,  352,  484,  344,  354,  360,  372,
- /*   170 */   375,  379,  388,  487,  396,  427,  489,  492,  493,  494,
- /*   180 */   495,  496,  497,  498,  502,  500,  503,  504,  506,  505,
- /*   190 */   512,  510,  513,  514,  516,  517,  520,  519,  521,  529,
- /*   200 */   530,  532,  534,  537,  535,  538,  539,  526,  541,
+ /*     0 */  -199,   52,   52,  167,  167, -213, -206,  116,  179, -207,
+ /*    10 */  -179,  -82,  -31,  121,  203,  206,  209,  211,  212,  222,
+ /*    20 */   226,  236, -274, -220, -202, -186, -221, -162, -132,  -39,
+ /*    30 */    38,   58,   64,   84,   87,   89,   93,  157,  171,  198,
+ /*    40 */   199,  201,  202,  215,  216,  218,  220,  223,  -45,  -18,
+ /*    50 */    69,  128,  197,  -22, -203,   96,  -76,  117,  266,  284,
+ /*    60 */    41,  279, -163,  150,  227,  296,  304,  -43,  138,  302,
+ /*    70 */   309,  -87,  -49,  -46,   21,   68,  123,  213,  324,  335,
+ /*    80 */   336,  337,  331,  340,  349,  382,  383,  384,  385,  311,
+ /*    90 */   386,  388,  389,  341,  342,  390,  393,  394,  396,  307,
+ /*   100 */   315,  317,  318,  344,  350,  401,  403,  404,  407,  409,
+ /*   110 */   410,  411,  412,  414,  415,  417,  418,  419,  420,  421,
+ /*   120 */   424,  427,  428,  429,  430,  431,  432,  433,  434,  435,
+ /*   130 */   438,  440,  441,  446,  450,  451,  453,  455,  456,  457,
+ /*   140 */   458,  459,  460,  461,  462,  463,  464,  466,  467,  468,
+ /*   150 */   469,  470,  471,  472,  473,  474,  475,  476,  477,  479,
+ /*   160 */   480,  481,  482,  484,  485,  330,  338,  347,  351,  487,
+ /*   170 */   356,  359,  343,  352,  391,  488,  490,  392,  489,  492,
+ /*   180 */   491,  493,  494,  495,  499,  500,  501,  502,  503,  508,
+ /*   190 */   504,  512,  510,  514,  511,  517,  519,  520,  521,  525,
+ /*   200 */   522,  529,  524,  526,  530,  532,  538,  540,  542,  550,
+ /*   210 */   544,  552,  546,  541,
 };
 static const YYACTIONTYPE yy_default[] = {
- /*     0 */   932, 1055,  994, 1065,  981,  991, 1228, 1228, 1228, 1228,
- /*    10 */   932,  932,  932,  932,  932,  932,  932,  932,  932,  932,
- /*    20 */   932,  932,  932,  932, 1115,  952,  932,  932,  932,  932,
- /*    30 */   932,  932,  932,  932,  932,  932,  932,  932,  932,  932,
- /*    40 */   932,  932,  932,  932,  932,  932,  932,  932,  932,  932,
- /*    50 */   932,  932,  932, 1139,  932,  991,  932,  932,  932,  932,
- /*    60 */   932, 1001,  991,  932,  932, 1001, 1001,  932, 1110, 1039,
- /*    70 */  1057,  932,  932,  932,  932,  932,  932,  932,  932,  932,
- /*    80 */   932,  932,  932,  932,  932,  932, 1117, 1123, 1120,  932,
- /*    90 */   932,  932, 1125,  932,  932,  932, 1161, 1161, 1161, 1161,
- /*   100 */  1108,  932,  932,  932,  932,  932,  932,  932,  932,  932,
- /*   110 */   932,  932,  932,  932,  932,  932,  932,  932,  932,  932,
- /*   120 */   932,  932,  932,  932,  932,  932,  932,  932,  932,  932,
- /*   130 */   932,  932,  932,  932,  979,  932,  977,  932,  932,  932,
- /*   140 */   932,  932,  932,  932,  932,  932,  932,  932,  932,  932,
- /*   150 */   932,  932,  932,  932,  932,  932,  932,  950,  954,  954,
- /*   160 */   954,  932,  932,  932,  932,  954, 1170, 1174, 1151, 1168,
- /*   170 */  1162, 1146, 1144, 1142, 1150, 1135, 1178,  954,  954,  954,
- /*   180 */   999,  999,  995,  991,  991,  954,  954, 1017, 1015, 1013,
- /*   190 */  1005, 1011, 1007, 1009, 1003,  982,  932,  954,  954,  989,
- /*   200 */   989,  954,  989,  954,  989,  954,  954, 1039, 1057, 1227,
- /*   210 */   932, 1179, 1169, 1227,  932, 1210, 1209,  932, 1218, 1217,
- /*   220 */  1216, 1208, 1207, 1206,  932,  932, 1202, 1205, 1204, 1203,
- /*   230 */   932,  932, 1181,  932,  932, 1212, 1211,  932,  932,  932,
- /*   240 */   932,  932,  932,  932, 1132,  932,  932,  932, 1157, 1175,
- /*   250 */  1171,  932,  932,  932,  932,  932,  932,  932,  932, 1182,
- /*   260 */   932,  932,  932,  932,  932,  932,  932,  932, 1096,  932,
- /*   270 */   932, 1067,  932,  932,  932,  932,  932,  932,  932,  932,
- /*   280 */   932,  932,  932,  932, 1107,  932,  932,  932,  932,  932,
- /*   290 */  1119, 1118,  932,  932,  932,  932,  932,  932,  932,  932,
- /*   300 */   932,  932,  932,  932,  932,  932,  932,  932,  932,  932,
- /*   310 */  1163,  932, 1158,  932, 1152,  932,  932, 1079,  932,  932,
- /*   320 */   932,  932,  932,  932,  932,  932,  932,  932,  932,  932,
- /*   330 */   932,  932,  932,  932,  932,  932,  932,  932,  932,  932,
- /*   340 */   932,  932,  932,  932,  932,  932,  932,  932,  932,  932,
- /*   350 */   932,  932,  932,  932, 1246, 1241, 1242, 1239,  932,  932,
- /*   360 */   932,  932,  932, 1238, 1233, 1234,  932,  932,  932, 1231,
- /*   370 */   932,  932,  932,  932,  932,  932,  932,  932,  932,  932,
- /*   380 */   932,  932,  932,  932,  932, 1023,  932,  932,  961,  932,
- /*   390 */   959,  932,  932,
+ /*     0 */   943, 1066, 1005, 1076,  992, 1002, 1243, 1243, 1243, 1243,
+ /*    10 */   943,  943,  943,  943,  943,  943,  943,  943,  943,  943,
+ /*    20 */   943,  943,  943,  943, 1130,  963,  943,  943,  943,  943,
+ /*    30 */   943,  943,  943,  943,  943,  943,  943,  943,  943,  943,
+ /*    40 */   943,  943,  943,  943,  943,  943,  943,  943,  943,  943,
+ /*    50 */   943,  943,  943, 1154,  943, 1002,  943,  943,  943,  943,
+ /*    60 */   943, 1012, 1002,  943,  943, 1012, 1012,  943, 1125, 1050,
+ /*    70 */  1068,  943,  943,  943,  943,  943,  943,  943,  943,  943,
+ /*    80 */   943,  943, 1097,  943,  943,  943,  943,  943,  943, 1132,
+ /*    90 */  1138, 1135,  943,  943,  943, 1140,  943,  943,  943, 1176,
+ /*   100 */  1176, 1176, 1176, 1123,  943,  943,  943,  943,  943,  943,
+ /*   110 */   943,  943,  943,  943,  943,  943,  943,  943,  943,  943,
+ /*   120 */   943,  943,  943,  943,  943,  943,  943,  943,  943,  943,
+ /*   130 */   943,  943,  943,  943,  943,  943,  943,  990,  943,  988,
+ /*   140 */   943,  943,  943,  943,  943,  943,  943,  943,  943,  943,
+ /*   150 */   943,  943,  943,  943,  943,  943,  943,  943,  943,  943,
+ /*   160 */   961,  965,  965,  965,  965,  943,  943,  943,  943,  965,
+ /*   170 */  1185, 1189, 1166, 1183, 1177, 1161, 1159, 1157, 1165, 1150,
+ /*   180 */  1193, 1099,  965,  965,  965, 1010, 1010, 1006, 1002, 1002,
+ /*   190 */   965,  965, 1028, 1026, 1024, 1016, 1022, 1018, 1020, 1014,
+ /*   200 */   993,  943,  965,  965, 1000, 1000,  965, 1000,  965, 1000,
+ /*   210 */   965,  965, 1050, 1068, 1242,  943, 1194, 1184, 1242,  943,
+ /*   220 */  1225, 1224,  943, 1233, 1232, 1231, 1223, 1222, 1221,  943,
+ /*   230 */   943, 1217, 1220, 1219, 1218,  943,  943, 1196,  943, 1227,
+ /*   240 */  1226,  943,  943,  943,  943,  943,  943,  943, 1147,  943,
+ /*   250 */   943,  943, 1172, 1190, 1186,  943,  943,  943,  943,  943,
+ /*   260 */   943,  943,  943, 1197,  943,  943,  943,  943,  943,  943,
+ /*   270 */   943,  943, 1111,  943,  943, 1078,  943,  943,  943,  943,
+ /*   280 */   943,  943,  943,  943,  943,  943,  943,  943, 1122,  943,
+ /*   290 */   943,  943,  943,  943, 1134, 1133,  943,  943,  943,  943,
+ /*   300 */   943,  943,  943,  943,  943,  943,  943,  943,  943,  943,
+ /*   310 */   943,  943,  943,  943, 1178,  943, 1173,  943, 1167,  943,
+ /*   320 */   943,  943, 1090,  943,  943,  943,  943,  943,  943,  943,
+ /*   330 */   943,  943,  943,  943,  943,  943,  943,  943,  943,  943,
+ /*   340 */   943,  943,  943,  943,  943,  943,  943,  943,  943,  943,
+ /*   350 */   943,  943,  943,  943,  943,  943,  943,  943,  943, 1261,
+ /*   360 */  1256, 1257, 1254,  943,  943,  943,  943,  943, 1253, 1248,
+ /*   370 */  1249,  943,  943,  943, 1246,  943,  943,  943,  943,  943,
+ /*   380 */   943,  943,  943,  943,  943,  943,  943,  943,  943,  943,
+ /*   390 */  1034,  943,  943,  972,  943,  970,  943,  943,
 };
 /********** End of lemon-generated parsing tables *****************************/
 
@@ -863,6 +668,8 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*   UNSIGNED => nothing */
     0,  /*       TAGS => nothing */
     0,  /*      USING => nothing */
+    0,  /*         TO => nothing */
+    0,  /*      SPLIT => nothing */
     1,  /*       NULL => ID */
     1,  /*        NOW => ID */
     0,  /*   VARIABLE => nothing */
@@ -996,7 +803,6 @@ typedef struct yyParser yyParser;
 
 #ifndef NDEBUG
 #include <stdio.h>
-#include <assert.h>
 static FILE *yyTraceFILE = 0;
 static char *yyTracePrompt = 0;
 #endif /* NDEBUG */
@@ -1152,169 +958,174 @@ static const char *const yyTokenName[] = {
   /*  118 */ "UNSIGNED",
   /*  119 */ "TAGS",
   /*  120 */ "USING",
-  /*  121 */ "NULL",
-  /*  122 */ "NOW",
-  /*  123 */ "VARIABLE",
-  /*  124 */ "SELECT",
-  /*  125 */ "UNION",
-  /*  126 */ "ALL",
-  /*  127 */ "DISTINCT",
-  /*  128 */ "FROM",
-  /*  129 */ "RANGE",
-  /*  130 */ "INTERVAL",
-  /*  131 */ "EVERY",
-  /*  132 */ "SESSION",
-  /*  133 */ "STATE_WINDOW",
-  /*  134 */ "FILL",
-  /*  135 */ "SLIDING",
-  /*  136 */ "ORDER",
-  /*  137 */ "BY",
-  /*  138 */ "ASC",
-  /*  139 */ "GROUP",
-  /*  140 */ "HAVING",
-  /*  141 */ "LIMIT",
-  /*  142 */ "OFFSET",
-  /*  143 */ "SLIMIT",
-  /*  144 */ "SOFFSET",
-  /*  145 */ "WHERE",
-  /*  146 */ "RESET",
-  /*  147 */ "QUERY",
-  /*  148 */ "SYNCDB",
-  /*  149 */ "ADD",
-  /*  150 */ "COLUMN",
-  /*  151 */ "MODIFY",
-  /*  152 */ "TAG",
-  /*  153 */ "CHANGE",
-  /*  154 */ "SET",
-  /*  155 */ "KILL",
-  /*  156 */ "CONNECTION",
-  /*  157 */ "STREAM",
-  /*  158 */ "COLON",
-  /*  159 */ "ABORT",
-  /*  160 */ "AFTER",
-  /*  161 */ "ATTACH",
-  /*  162 */ "BEFORE",
-  /*  163 */ "BEGIN",
-  /*  164 */ "CASCADE",
-  /*  165 */ "CLUSTER",
-  /*  166 */ "CONFLICT",
-  /*  167 */ "COPY",
-  /*  168 */ "DEFERRED",
-  /*  169 */ "DELIMITERS",
-  /*  170 */ "DETACH",
-  /*  171 */ "EACH",
-  /*  172 */ "END",
-  /*  173 */ "EXPLAIN",
-  /*  174 */ "FAIL",
-  /*  175 */ "FOR",
-  /*  176 */ "IGNORE",
-  /*  177 */ "IMMEDIATE",
-  /*  178 */ "INITIALLY",
-  /*  179 */ "INSTEAD",
-  /*  180 */ "KEY",
-  /*  181 */ "OF",
-  /*  182 */ "RAISE",
-  /*  183 */ "REPLACE",
-  /*  184 */ "RESTRICT",
-  /*  185 */ "ROW",
-  /*  186 */ "STATEMENT",
-  /*  187 */ "TRIGGER",
-  /*  188 */ "VIEW",
-  /*  189 */ "IPTOKEN",
-  /*  190 */ "SEMI",
-  /*  191 */ "NONE",
-  /*  192 */ "PREV",
-  /*  193 */ "LINEAR",
-  /*  194 */ "IMPORT",
-  /*  195 */ "TBNAME",
-  /*  196 */ "JOIN",
-  /*  197 */ "INSERT",
-  /*  198 */ "INTO",
-  /*  199 */ "VALUES",
-  /*  200 */ "FILE",
-  /*  201 */ "program",
-  /*  202 */ "cmd",
-  /*  203 */ "ids",
-  /*  204 */ "dbPrefix",
-  /*  205 */ "cpxName",
-  /*  206 */ "ifexists",
-  /*  207 */ "alter_db_optr",
-  /*  208 */ "alter_topic_optr",
-  /*  209 */ "acct_optr",
-  /*  210 */ "exprlist",
-  /*  211 */ "ifnotexists",
-  /*  212 */ "db_optr",
-  /*  213 */ "topic_optr",
-  /*  214 */ "typename",
-  /*  215 */ "bufsize",
-  /*  216 */ "pps",
-  /*  217 */ "tseries",
-  /*  218 */ "dbs",
-  /*  219 */ "streams",
-  /*  220 */ "storage",
-  /*  221 */ "qtime",
-  /*  222 */ "users",
-  /*  223 */ "conns",
-  /*  224 */ "state",
-  /*  225 */ "intitemlist",
-  /*  226 */ "intitem",
-  /*  227 */ "keep",
-  /*  228 */ "cache",
-  /*  229 */ "replica",
-  /*  230 */ "quorum",
-  /*  231 */ "days",
-  /*  232 */ "minrows",
-  /*  233 */ "maxrows",
-  /*  234 */ "blocks",
-  /*  235 */ "ctime",
-  /*  236 */ "wal",
-  /*  237 */ "fsync",
-  /*  238 */ "comp",
-  /*  239 */ "prec",
-  /*  240 */ "update",
-  /*  241 */ "cachelast",
-  /*  242 */ "partitions",
-  /*  243 */ "signed",
-  /*  244 */ "create_table_args",
-  /*  245 */ "create_stable_args",
-  /*  246 */ "create_table_list",
-  /*  247 */ "create_from_stable",
-  /*  248 */ "columnlist",
-  /*  249 */ "tagitemlist",
-  /*  250 */ "tagNamelist",
-  /*  251 */ "select",
-  /*  252 */ "column",
-  /*  253 */ "tagitem",
-  /*  254 */ "selcollist",
-  /*  255 */ "from",
-  /*  256 */ "where_opt",
-  /*  257 */ "range_option",
-  /*  258 */ "interval_option",
-  /*  259 */ "sliding_opt",
-  /*  260 */ "session_option",
-  /*  261 */ "windowstate_option",
-  /*  262 */ "fill_opt",
-  /*  263 */ "groupby_opt",
-  /*  264 */ "having_opt",
-  /*  265 */ "orderby_opt",
-  /*  266 */ "slimit_opt",
-  /*  267 */ "limit_opt",
-  /*  268 */ "union",
-  /*  269 */ "sclp",
-  /*  270 */ "distinct",
-  /*  271 */ "expr",
-  /*  272 */ "as",
-  /*  273 */ "tablelist",
-  /*  274 */ "sub",
-  /*  275 */ "tmvar",
-  /*  276 */ "timestamp",
-  /*  277 */ "intervalKey",
-  /*  278 */ "sortlist",
-  /*  279 */ "item",
-  /*  280 */ "sortorder",
-  /*  281 */ "arrow",
-  /*  282 */ "grouplist",
-  /*  283 */ "expritem",
+  /*  121 */ "TO",
+  /*  122 */ "SPLIT",
+  /*  123 */ "NULL",
+  /*  124 */ "NOW",
+  /*  125 */ "VARIABLE",
+  /*  126 */ "SELECT",
+  /*  127 */ "UNION",
+  /*  128 */ "ALL",
+  /*  129 */ "DISTINCT",
+  /*  130 */ "FROM",
+  /*  131 */ "RANGE",
+  /*  132 */ "INTERVAL",
+  /*  133 */ "EVERY",
+  /*  134 */ "SESSION",
+  /*  135 */ "STATE_WINDOW",
+  /*  136 */ "FILL",
+  /*  137 */ "SLIDING",
+  /*  138 */ "ORDER",
+  /*  139 */ "BY",
+  /*  140 */ "ASC",
+  /*  141 */ "GROUP",
+  /*  142 */ "HAVING",
+  /*  143 */ "LIMIT",
+  /*  144 */ "OFFSET",
+  /*  145 */ "SLIMIT",
+  /*  146 */ "SOFFSET",
+  /*  147 */ "WHERE",
+  /*  148 */ "RESET",
+  /*  149 */ "QUERY",
+  /*  150 */ "SYNCDB",
+  /*  151 */ "ADD",
+  /*  152 */ "COLUMN",
+  /*  153 */ "MODIFY",
+  /*  154 */ "TAG",
+  /*  155 */ "CHANGE",
+  /*  156 */ "SET",
+  /*  157 */ "KILL",
+  /*  158 */ "CONNECTION",
+  /*  159 */ "STREAM",
+  /*  160 */ "COLON",
+  /*  161 */ "ABORT",
+  /*  162 */ "AFTER",
+  /*  163 */ "ATTACH",
+  /*  164 */ "BEFORE",
+  /*  165 */ "BEGIN",
+  /*  166 */ "CASCADE",
+  /*  167 */ "CLUSTER",
+  /*  168 */ "CONFLICT",
+  /*  169 */ "COPY",
+  /*  170 */ "DEFERRED",
+  /*  171 */ "DELIMITERS",
+  /*  172 */ "DETACH",
+  /*  173 */ "EACH",
+  /*  174 */ "END",
+  /*  175 */ "EXPLAIN",
+  /*  176 */ "FAIL",
+  /*  177 */ "FOR",
+  /*  178 */ "IGNORE",
+  /*  179 */ "IMMEDIATE",
+  /*  180 */ "INITIALLY",
+  /*  181 */ "INSTEAD",
+  /*  182 */ "KEY",
+  /*  183 */ "OF",
+  /*  184 */ "RAISE",
+  /*  185 */ "REPLACE",
+  /*  186 */ "RESTRICT",
+  /*  187 */ "ROW",
+  /*  188 */ "STATEMENT",
+  /*  189 */ "TRIGGER",
+  /*  190 */ "VIEW",
+  /*  191 */ "IPTOKEN",
+  /*  192 */ "SEMI",
+  /*  193 */ "NONE",
+  /*  194 */ "PREV",
+  /*  195 */ "LINEAR",
+  /*  196 */ "IMPORT",
+  /*  197 */ "TBNAME",
+  /*  198 */ "JOIN",
+  /*  199 */ "INSERT",
+  /*  200 */ "INTO",
+  /*  201 */ "VALUES",
+  /*  202 */ "FILE",
+  /*  203 */ "program",
+  /*  204 */ "cmd",
+  /*  205 */ "ids",
+  /*  206 */ "dbPrefix",
+  /*  207 */ "cpxName",
+  /*  208 */ "ifexists",
+  /*  209 */ "alter_db_optr",
+  /*  210 */ "alter_topic_optr",
+  /*  211 */ "acct_optr",
+  /*  212 */ "exprlist",
+  /*  213 */ "ifnotexists",
+  /*  214 */ "db_optr",
+  /*  215 */ "topic_optr",
+  /*  216 */ "typename",
+  /*  217 */ "bufsize",
+  /*  218 */ "pps",
+  /*  219 */ "tseries",
+  /*  220 */ "dbs",
+  /*  221 */ "streams",
+  /*  222 */ "storage",
+  /*  223 */ "qtime",
+  /*  224 */ "users",
+  /*  225 */ "conns",
+  /*  226 */ "state",
+  /*  227 */ "intitemlist",
+  /*  228 */ "intitem",
+  /*  229 */ "keep",
+  /*  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 */ "partitions",
+  /*  245 */ "signed",
+  /*  246 */ "create_table_args",
+  /*  247 */ "create_stable_args",
+  /*  248 */ "create_table_list",
+  /*  249 */ "create_from_stable",
+  /*  250 */ "columnlist",
+  /*  251 */ "tagitemlist",
+  /*  252 */ "tagNamelist",
+  /*  253 */ "to_opt",
+  /*  254 */ "split_opt",
+  /*  255 */ "select",
+  /*  256 */ "to_split",
+  /*  257 */ "column",
+  /*  258 */ "tagitem",
+  /*  259 */ "selcollist",
+  /*  260 */ "from",
+  /*  261 */ "where_opt",
+  /*  262 */ "range_option",
+  /*  263 */ "interval_option",
+  /*  264 */ "sliding_opt",
+  /*  265 */ "session_option",
+  /*  266 */ "windowstate_option",
+  /*  267 */ "fill_opt",
+  /*  268 */ "groupby_opt",
+  /*  269 */ "having_opt",
+  /*  270 */ "orderby_opt",
+  /*  271 */ "slimit_opt",
+  /*  272 */ "limit_opt",
+  /*  273 */ "union",
+  /*  274 */ "sclp",
+  /*  275 */ "distinct",
+  /*  276 */ "expr",
+  /*  277 */ "as",
+  /*  278 */ "tablelist",
+  /*  279 */ "sub",
+  /*  280 */ "tmvar",
+  /*  281 */ "timestamp",
+  /*  282 */ "intervalKey",
+  /*  283 */ "sortlist",
+  /*  284 */ "item",
+  /*  285 */ "sortorder",
+  /*  286 */ "arrow",
+  /*  287 */ "grouplist",
+  /*  288 */ "expritem",
 };
 #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
 
@@ -1472,171 +1283,175 @@ static const char *const yyRuleName[] = {
  /* 147 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP",
  /* 148 */ "tagNamelist ::= tagNamelist COMMA ids",
  /* 149 */ "tagNamelist ::= ids",
- /* 150 */ "create_table_args ::= ifnotexists ids cpxName AS select",
- /* 151 */ "columnlist ::= columnlist COMMA column",
- /* 152 */ "columnlist ::= column",
- /* 153 */ "column ::= ids typename",
- /* 154 */ "tagitemlist ::= tagitemlist COMMA tagitem",
- /* 155 */ "tagitemlist ::= tagitem",
- /* 156 */ "tagitem ::= INTEGER",
- /* 157 */ "tagitem ::= FLOAT",
- /* 158 */ "tagitem ::= STRING",
- /* 159 */ "tagitem ::= BOOL",
- /* 160 */ "tagitem ::= NULL",
- /* 161 */ "tagitem ::= NOW",
- /* 162 */ "tagitem ::= NOW PLUS VARIABLE",
- /* 163 */ "tagitem ::= NOW MINUS VARIABLE",
- /* 164 */ "tagitem ::= MINUS INTEGER",
- /* 165 */ "tagitem ::= MINUS FLOAT",
- /* 166 */ "tagitem ::= PLUS INTEGER",
- /* 167 */ "tagitem ::= PLUS FLOAT",
- /* 168 */ "select ::= SELECT selcollist from where_opt range_option interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt",
- /* 169 */ "select ::= LP select RP",
- /* 170 */ "union ::= select",
- /* 171 */ "union ::= union UNION ALL select",
- /* 172 */ "cmd ::= union",
- /* 173 */ "select ::= SELECT selcollist",
- /* 174 */ "sclp ::= selcollist COMMA",
- /* 175 */ "sclp ::=",
- /* 176 */ "selcollist ::= sclp distinct expr as",
- /* 177 */ "selcollist ::= sclp STAR",
- /* 178 */ "as ::= AS ids",
- /* 179 */ "as ::= ids",
- /* 180 */ "as ::=",
- /* 181 */ "distinct ::= DISTINCT",
- /* 182 */ "distinct ::=",
- /* 183 */ "from ::= FROM tablelist",
- /* 184 */ "from ::= FROM sub",
- /* 185 */ "sub ::= LP union RP",
- /* 186 */ "sub ::= LP union RP ids",
- /* 187 */ "sub ::= sub COMMA LP union RP ids",
- /* 188 */ "tablelist ::= ids cpxName",
- /* 189 */ "tablelist ::= ids cpxName ids",
- /* 190 */ "tablelist ::= tablelist COMMA ids cpxName",
- /* 191 */ "tablelist ::= tablelist COMMA ids cpxName ids",
- /* 192 */ "tmvar ::= VARIABLE",
- /* 193 */ "timestamp ::= INTEGER",
- /* 194 */ "timestamp ::= MINUS INTEGER",
- /* 195 */ "timestamp ::= PLUS INTEGER",
- /* 196 */ "timestamp ::= STRING",
- /* 197 */ "timestamp ::= NOW",
- /* 198 */ "timestamp ::= NOW PLUS VARIABLE",
- /* 199 */ "timestamp ::= NOW MINUS VARIABLE",
- /* 200 */ "range_option ::=",
- /* 201 */ "range_option ::= RANGE LP timestamp COMMA timestamp RP",
- /* 202 */ "interval_option ::= intervalKey LP tmvar RP",
- /* 203 */ "interval_option ::= intervalKey LP tmvar COMMA tmvar RP",
- /* 204 */ "interval_option ::=",
- /* 205 */ "intervalKey ::= INTERVAL",
- /* 206 */ "intervalKey ::= EVERY",
- /* 207 */ "session_option ::=",
- /* 208 */ "session_option ::= SESSION LP ids cpxName COMMA tmvar RP",
- /* 209 */ "windowstate_option ::=",
- /* 210 */ "windowstate_option ::= STATE_WINDOW LP ids RP",
- /* 211 */ "fill_opt ::=",
- /* 212 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
- /* 213 */ "fill_opt ::= FILL LP ID RP",
- /* 214 */ "sliding_opt ::= SLIDING LP tmvar RP",
- /* 215 */ "sliding_opt ::=",
- /* 216 */ "orderby_opt ::=",
- /* 217 */ "orderby_opt ::= ORDER BY sortlist",
- /* 218 */ "sortlist ::= sortlist COMMA item sortorder",
- /* 219 */ "sortlist ::= sortlist COMMA arrow sortorder",
- /* 220 */ "sortlist ::= item sortorder",
- /* 221 */ "sortlist ::= arrow sortorder",
- /* 222 */ "item ::= ID",
- /* 223 */ "item ::= ID DOT ID",
- /* 224 */ "sortorder ::= ASC",
- /* 225 */ "sortorder ::= DESC",
- /* 226 */ "sortorder ::=",
- /* 227 */ "groupby_opt ::=",
- /* 228 */ "groupby_opt ::= GROUP BY grouplist",
- /* 229 */ "grouplist ::= grouplist COMMA item",
- /* 230 */ "grouplist ::= grouplist COMMA arrow",
- /* 231 */ "grouplist ::= item",
- /* 232 */ "grouplist ::= arrow",
- /* 233 */ "having_opt ::=",
- /* 234 */ "having_opt ::= HAVING expr",
- /* 235 */ "limit_opt ::=",
- /* 236 */ "limit_opt ::= LIMIT signed",
- /* 237 */ "limit_opt ::= LIMIT signed OFFSET signed",
- /* 238 */ "limit_opt ::= LIMIT signed COMMA signed",
- /* 239 */ "slimit_opt ::=",
- /* 240 */ "slimit_opt ::= SLIMIT signed",
- /* 241 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
- /* 242 */ "slimit_opt ::= SLIMIT signed COMMA signed",
- /* 243 */ "where_opt ::=",
- /* 244 */ "where_opt ::= WHERE expr",
- /* 245 */ "expr ::= LP expr RP",
- /* 246 */ "expr ::= ID",
- /* 247 */ "expr ::= ID DOT ID",
- /* 248 */ "expr ::= ID DOT STAR",
- /* 249 */ "expr ::= INTEGER",
- /* 250 */ "expr ::= MINUS INTEGER",
- /* 251 */ "expr ::= PLUS INTEGER",
- /* 252 */ "expr ::= FLOAT",
- /* 253 */ "expr ::= MINUS FLOAT",
- /* 254 */ "expr ::= PLUS FLOAT",
- /* 255 */ "expr ::= STRING",
- /* 256 */ "expr ::= NOW",
- /* 257 */ "expr ::= VARIABLE",
- /* 258 */ "expr ::= PLUS VARIABLE",
- /* 259 */ "expr ::= MINUS VARIABLE",
- /* 260 */ "expr ::= BOOL",
- /* 261 */ "expr ::= NULL",
- /* 262 */ "expr ::= ID LP exprlist RP",
- /* 263 */ "expr ::= ID LP STAR RP",
- /* 264 */ "expr ::= ID LP expr AS typename RP",
- /* 265 */ "expr ::= expr IS NULL",
- /* 266 */ "expr ::= expr IS NOT NULL",
- /* 267 */ "expr ::= expr LT expr",
- /* 268 */ "expr ::= expr GT expr",
- /* 269 */ "expr ::= expr LE expr",
- /* 270 */ "expr ::= expr GE expr",
- /* 271 */ "expr ::= expr NE expr",
- /* 272 */ "expr ::= expr EQ expr",
- /* 273 */ "expr ::= expr BETWEEN expr AND expr",
- /* 274 */ "expr ::= expr AND expr",
- /* 275 */ "expr ::= expr OR expr",
- /* 276 */ "expr ::= expr PLUS expr",
- /* 277 */ "expr ::= expr MINUS expr",
- /* 278 */ "expr ::= expr STAR expr",
- /* 279 */ "expr ::= expr SLASH expr",
- /* 280 */ "expr ::= expr REM expr",
- /* 281 */ "expr ::= expr LIKE expr",
- /* 282 */ "expr ::= expr MATCH expr",
- /* 283 */ "expr ::= expr NMATCH expr",
- /* 284 */ "expr ::= ID CONTAINS STRING",
- /* 285 */ "expr ::= ID DOT ID CONTAINS STRING",
- /* 286 */ "arrow ::= ID ARROW STRING",
- /* 287 */ "arrow ::= ID DOT ID ARROW STRING",
- /* 288 */ "expr ::= arrow",
- /* 289 */ "expr ::= expr IN LP exprlist RP",
- /* 290 */ "exprlist ::= exprlist COMMA expritem",
- /* 291 */ "exprlist ::= expritem",
- /* 292 */ "expritem ::= expr",
- /* 293 */ "expritem ::=",
- /* 294 */ "cmd ::= RESET QUERY CACHE",
- /* 295 */ "cmd ::= SYNCDB ids REPLICA",
- /* 296 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
- /* 297 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
- /* 298 */ "cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist",
- /* 299 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
- /* 300 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
- /* 301 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
- /* 302 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
- /* 303 */ "cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist",
- /* 304 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist",
- /* 305 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids",
- /* 306 */ "cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist",
- /* 307 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist",
- /* 308 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids",
- /* 309 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids",
- /* 310 */ "cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem",
- /* 311 */ "cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist",
- /* 312 */ "cmd ::= KILL CONNECTION INTEGER",
- /* 313 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
- /* 314 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
+ /* 150 */ "create_table_args ::= ifnotexists ids cpxName to_opt split_opt AS select",
+ /* 151 */ "to_opt ::=",
+ /* 152 */ "to_opt ::= TO ids cpxName",
+ /* 153 */ "split_opt ::=",
+ /* 154 */ "split_opt ::= SPLIT ids",
+ /* 155 */ "columnlist ::= columnlist COMMA column",
+ /* 156 */ "columnlist ::= column",
+ /* 157 */ "column ::= ids typename",
+ /* 158 */ "tagitemlist ::= tagitemlist COMMA tagitem",
+ /* 159 */ "tagitemlist ::= tagitem",
+ /* 160 */ "tagitem ::= INTEGER",
+ /* 161 */ "tagitem ::= FLOAT",
+ /* 162 */ "tagitem ::= STRING",
+ /* 163 */ "tagitem ::= BOOL",
+ /* 164 */ "tagitem ::= NULL",
+ /* 165 */ "tagitem ::= NOW",
+ /* 166 */ "tagitem ::= NOW PLUS VARIABLE",
+ /* 167 */ "tagitem ::= NOW MINUS VARIABLE",
+ /* 168 */ "tagitem ::= MINUS INTEGER",
+ /* 169 */ "tagitem ::= MINUS FLOAT",
+ /* 170 */ "tagitem ::= PLUS INTEGER",
+ /* 171 */ "tagitem ::= PLUS FLOAT",
+ /* 172 */ "select ::= SELECT selcollist from where_opt range_option interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt",
+ /* 173 */ "select ::= LP select RP",
+ /* 174 */ "union ::= select",
+ /* 175 */ "union ::= union UNION ALL select",
+ /* 176 */ "cmd ::= union",
+ /* 177 */ "select ::= SELECT selcollist",
+ /* 178 */ "sclp ::= selcollist COMMA",
+ /* 179 */ "sclp ::=",
+ /* 180 */ "selcollist ::= sclp distinct expr as",
+ /* 181 */ "selcollist ::= sclp STAR",
+ /* 182 */ "as ::= AS ids",
+ /* 183 */ "as ::= ids",
+ /* 184 */ "as ::=",
+ /* 185 */ "distinct ::= DISTINCT",
+ /* 186 */ "distinct ::=",
+ /* 187 */ "from ::= FROM tablelist",
+ /* 188 */ "from ::= FROM sub",
+ /* 189 */ "sub ::= LP union RP",
+ /* 190 */ "sub ::= LP union RP ids",
+ /* 191 */ "sub ::= sub COMMA LP union RP ids",
+ /* 192 */ "tablelist ::= ids cpxName",
+ /* 193 */ "tablelist ::= ids cpxName ids",
+ /* 194 */ "tablelist ::= tablelist COMMA ids cpxName",
+ /* 195 */ "tablelist ::= tablelist COMMA ids cpxName ids",
+ /* 196 */ "tmvar ::= VARIABLE",
+ /* 197 */ "timestamp ::= INTEGER",
+ /* 198 */ "timestamp ::= MINUS INTEGER",
+ /* 199 */ "timestamp ::= PLUS INTEGER",
+ /* 200 */ "timestamp ::= STRING",
+ /* 201 */ "timestamp ::= NOW",
+ /* 202 */ "timestamp ::= NOW PLUS VARIABLE",
+ /* 203 */ "timestamp ::= NOW MINUS VARIABLE",
+ /* 204 */ "range_option ::=",
+ /* 205 */ "range_option ::= RANGE LP timestamp COMMA timestamp RP",
+ /* 206 */ "interval_option ::= intervalKey LP tmvar RP",
+ /* 207 */ "interval_option ::= intervalKey LP tmvar COMMA tmvar RP",
+ /* 208 */ "interval_option ::=",
+ /* 209 */ "intervalKey ::= INTERVAL",
+ /* 210 */ "intervalKey ::= EVERY",
+ /* 211 */ "session_option ::=",
+ /* 212 */ "session_option ::= SESSION LP ids cpxName COMMA tmvar RP",
+ /* 213 */ "windowstate_option ::=",
+ /* 214 */ "windowstate_option ::= STATE_WINDOW LP ids RP",
+ /* 215 */ "fill_opt ::=",
+ /* 216 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
+ /* 217 */ "fill_opt ::= FILL LP ID RP",
+ /* 218 */ "sliding_opt ::= SLIDING LP tmvar RP",
+ /* 219 */ "sliding_opt ::=",
+ /* 220 */ "orderby_opt ::=",
+ /* 221 */ "orderby_opt ::= ORDER BY sortlist",
+ /* 222 */ "sortlist ::= sortlist COMMA item sortorder",
+ /* 223 */ "sortlist ::= sortlist COMMA arrow sortorder",
+ /* 224 */ "sortlist ::= item sortorder",
+ /* 225 */ "sortlist ::= arrow sortorder",
+ /* 226 */ "item ::= ID",
+ /* 227 */ "item ::= ID DOT ID",
+ /* 228 */ "sortorder ::= ASC",
+ /* 229 */ "sortorder ::= DESC",
+ /* 230 */ "sortorder ::=",
+ /* 231 */ "groupby_opt ::=",
+ /* 232 */ "groupby_opt ::= GROUP BY grouplist",
+ /* 233 */ "grouplist ::= grouplist COMMA item",
+ /* 234 */ "grouplist ::= grouplist COMMA arrow",
+ /* 235 */ "grouplist ::= item",
+ /* 236 */ "grouplist ::= arrow",
+ /* 237 */ "having_opt ::=",
+ /* 238 */ "having_opt ::= HAVING expr",
+ /* 239 */ "limit_opt ::=",
+ /* 240 */ "limit_opt ::= LIMIT signed",
+ /* 241 */ "limit_opt ::= LIMIT signed OFFSET signed",
+ /* 242 */ "limit_opt ::= LIMIT signed COMMA signed",
+ /* 243 */ "slimit_opt ::=",
+ /* 244 */ "slimit_opt ::= SLIMIT signed",
+ /* 245 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
+ /* 246 */ "slimit_opt ::= SLIMIT signed COMMA signed",
+ /* 247 */ "where_opt ::=",
+ /* 248 */ "where_opt ::= WHERE expr",
+ /* 249 */ "expr ::= LP expr RP",
+ /* 250 */ "expr ::= ID",
+ /* 251 */ "expr ::= ID DOT ID",
+ /* 252 */ "expr ::= ID DOT STAR",
+ /* 253 */ "expr ::= INTEGER",
+ /* 254 */ "expr ::= MINUS INTEGER",
+ /* 255 */ "expr ::= PLUS INTEGER",
+ /* 256 */ "expr ::= FLOAT",
+ /* 257 */ "expr ::= MINUS FLOAT",
+ /* 258 */ "expr ::= PLUS FLOAT",
+ /* 259 */ "expr ::= STRING",
+ /* 260 */ "expr ::= NOW",
+ /* 261 */ "expr ::= VARIABLE",
+ /* 262 */ "expr ::= PLUS VARIABLE",
+ /* 263 */ "expr ::= MINUS VARIABLE",
+ /* 264 */ "expr ::= BOOL",
+ /* 265 */ "expr ::= NULL",
+ /* 266 */ "expr ::= ID LP exprlist RP",
+ /* 267 */ "expr ::= ID LP STAR RP",
+ /* 268 */ "expr ::= ID LP expr AS typename RP",
+ /* 269 */ "expr ::= expr IS NULL",
+ /* 270 */ "expr ::= expr IS NOT NULL",
+ /* 271 */ "expr ::= expr LT expr",
+ /* 272 */ "expr ::= expr GT expr",
+ /* 273 */ "expr ::= expr LE expr",
+ /* 274 */ "expr ::= expr GE expr",
+ /* 275 */ "expr ::= expr NE expr",
+ /* 276 */ "expr ::= expr EQ expr",
+ /* 277 */ "expr ::= expr BETWEEN expr AND expr",
+ /* 278 */ "expr ::= expr AND expr",
+ /* 279 */ "expr ::= expr OR expr",
+ /* 280 */ "expr ::= expr PLUS expr",
+ /* 281 */ "expr ::= expr MINUS expr",
+ /* 282 */ "expr ::= expr STAR expr",
+ /* 283 */ "expr ::= expr SLASH expr",
+ /* 284 */ "expr ::= expr REM expr",
+ /* 285 */ "expr ::= expr LIKE expr",
+ /* 286 */ "expr ::= expr MATCH expr",
+ /* 287 */ "expr ::= expr NMATCH expr",
+ /* 288 */ "expr ::= ID CONTAINS STRING",
+ /* 289 */ "expr ::= ID DOT ID CONTAINS STRING",
+ /* 290 */ "arrow ::= ID ARROW STRING",
+ /* 291 */ "arrow ::= ID DOT ID ARROW STRING",
+ /* 292 */ "expr ::= arrow",
+ /* 293 */ "expr ::= expr IN LP exprlist RP",
+ /* 294 */ "exprlist ::= exprlist COMMA expritem",
+ /* 295 */ "exprlist ::= expritem",
+ /* 296 */ "expritem ::= expr",
+ /* 297 */ "expritem ::=",
+ /* 298 */ "cmd ::= RESET QUERY CACHE",
+ /* 299 */ "cmd ::= SYNCDB ids REPLICA",
+ /* 300 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
+ /* 301 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
+ /* 302 */ "cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist",
+ /* 303 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
+ /* 304 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
+ /* 305 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
+ /* 306 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
+ /* 307 */ "cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist",
+ /* 308 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist",
+ /* 309 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids",
+ /* 310 */ "cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist",
+ /* 311 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist",
+ /* 312 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids",
+ /* 313 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids",
+ /* 314 */ "cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem",
+ /* 315 */ "cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist",
+ /* 316 */ "cmd ::= KILL CONNECTION INTEGER",
+ /* 317 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
+ /* 318 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
 };
 #endif /* NDEBUG */
 
@@ -1762,57 +1577,57 @@ static void yy_destructor(
     ** inside the C code.
     */
 /********* Begin destructor definitions ***************************************/
-    case 210: /* exprlist */
-    case 254: /* selcollist */
-    case 269: /* sclp */
+    case 212: /* exprlist */
+    case 259: /* selcollist */
+    case 274: /* sclp */
 {
-tSqlExprListDestroy((yypminor->yy189));
+tSqlExprListDestroy((yypminor->yy209));
 }
       break;
-    case 225: /* intitemlist */
-    case 227: /* keep */
-    case 248: /* columnlist */
-    case 249: /* tagitemlist */
-    case 250: /* tagNamelist */
-    case 262: /* fill_opt */
-    case 263: /* groupby_opt */
-    case 265: /* orderby_opt */
-    case 278: /* sortlist */
-    case 282: /* grouplist */
-{
-taosArrayDestroy(&(yypminor->yy189));
+    case 227: /* intitemlist */
+    case 229: /* keep */
+    case 250: /* columnlist */
+    case 251: /* tagitemlist */
+    case 252: /* tagNamelist */
+    case 267: /* fill_opt */
+    case 268: /* groupby_opt */
+    case 270: /* orderby_opt */
+    case 283: /* sortlist */
+    case 287: /* grouplist */
+{
+taosArrayDestroy(&(yypminor->yy209));
 }
       break;
-    case 246: /* create_table_list */
+    case 248: /* create_table_list */
 {
-destroyCreateTableSql((yypminor->yy6));
+destroyCreateTableSql((yypminor->yy404));
 }
       break;
-    case 251: /* select */
+    case 255: /* select */
 {
-destroySqlNode((yypminor->yy16));
+destroySqlNode((yypminor->yy160));
 }
       break;
-    case 255: /* from */
-    case 273: /* tablelist */
-    case 274: /* sub */
+    case 260: /* from */
+    case 278: /* tablelist */
+    case 279: /* sub */
 {
-destroyRelationInfo((yypminor->yy36));
+destroyRelationInfo((yypminor->yy530));
 }
       break;
-    case 256: /* where_opt */
-    case 264: /* having_opt */
-    case 271: /* expr */
-    case 276: /* timestamp */
-    case 281: /* arrow */
-    case 283: /* expritem */
+    case 261: /* where_opt */
+    case 269: /* having_opt */
+    case 276: /* expr */
+    case 281: /* timestamp */
+    case 286: /* arrow */
+    case 288: /* expritem */
 {
-tSqlExprDestroy((yypminor->yy18));
+tSqlExprDestroy((yypminor->yy574));
 }
       break;
-    case 268: /* union */
+    case 273: /* union */
 {
-destroyAllSqlNode((yypminor->yy189));
+destroyAllSqlNode((yypminor->yy209));
 }
       break;
 /********* End destructor definitions *****************************************/
@@ -1938,18 +1753,15 @@ static YYACTIONTYPE yy_find_shift_action(
   do{
     i = yy_shift_ofst[stateno];
     assert( i>=0 );
-    assert( i<=YY_ACTTAB_COUNT );
-    assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD );
+    /* assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD ); */
     assert( iLookAhead!=YYNOCODE );
     assert( iLookAhead < YYNTOKEN );
     i += iLookAhead;
-    assert( i<(int)YY_NLOOKAHEAD );
-    if( yy_lookahead[i]!=iLookAhead ){
+    if( i>=YY_NLOOKAHEAD || yy_lookahead[i]!=iLookAhead ){
 #ifdef YYFALLBACK
       YYCODETYPE iFallback;            /* Fallback token */
-      assert( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0]) );
-      iFallback = yyFallback[iLookAhead];
-      if( iFallback!=0 ){
+      if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
+             && (iFallback = yyFallback[iLookAhead])!=0 ){
 #ifndef NDEBUG
         if( yyTraceFILE ){
           fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
@@ -1964,8 +1776,16 @@ static YYACTIONTYPE yy_find_shift_action(
 #ifdef YYWILDCARD
       {
         int j = i - iLookAhead + YYWILDCARD;
-        assert( j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) );
-        if( yy_lookahead[j]==YYWILDCARD && iLookAhead>0 ){
+        if( 
+#if YY_SHIFT_MIN+YYWILDCARD<0
+          j>=0 &&
+#endif
+#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
+          j<YY_ACTTAB_COUNT &&
+#endif
+          j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) &&
+          yy_lookahead[j]==YYWILDCARD && iLookAhead>0
+        ){
 #ifndef NDEBUG
           if( yyTraceFILE ){
             fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
@@ -1979,7 +1799,6 @@ static YYACTIONTYPE yy_find_shift_action(
 #endif /* YYWILDCARD */
       return yy_default[stateno];
     }else{
-      assert( i>=0 && i<(int)(sizeof(yy_action)/sizeof(yy_action[0])) );
       return yy_action[i];
     }
   }while(1);
@@ -2098,644 +1917,332 @@ static void yy_shift(
   yyTraceShift(yypParser, yyNewState, "Shift");
 }
 
-/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side
-** of that rule */
-static const YYCODETYPE yyRuleInfoLhs[] = {
-   201,  /* (0) program ::= cmd */
-   202,  /* (1) cmd ::= SHOW DATABASES */
-   202,  /* (2) cmd ::= SHOW TOPICS */
-   202,  /* (3) cmd ::= SHOW FUNCTIONS */
-   202,  /* (4) cmd ::= SHOW MNODES */
-   202,  /* (5) cmd ::= SHOW DNODES */
-   202,  /* (6) cmd ::= SHOW ACCOUNTS */
-   202,  /* (7) cmd ::= SHOW USERS */
-   202,  /* (8) cmd ::= SHOW MODULES */
-   202,  /* (9) cmd ::= SHOW QUERIES */
-   202,  /* (10) cmd ::= SHOW CONNECTIONS */
-   202,  /* (11) cmd ::= SHOW STREAMS */
-   202,  /* (12) cmd ::= SHOW VARIABLES */
-   202,  /* (13) cmd ::= SHOW SCORES */
-   202,  /* (14) cmd ::= SHOW GRANTS */
-   202,  /* (15) cmd ::= SHOW VNODES */
-   202,  /* (16) cmd ::= SHOW VNODES ids */
-   204,  /* (17) dbPrefix ::= */
-   204,  /* (18) dbPrefix ::= ids DOT */
-   205,  /* (19) cpxName ::= */
-   205,  /* (20) cpxName ::= DOT ids */
-   202,  /* (21) cmd ::= SHOW CREATE TABLE ids cpxName */
-   202,  /* (22) cmd ::= SHOW CREATE STABLE ids cpxName */
-   202,  /* (23) cmd ::= SHOW CREATE DATABASE ids */
-   202,  /* (24) cmd ::= SHOW dbPrefix TABLES */
-   202,  /* (25) cmd ::= SHOW dbPrefix TABLES LIKE STRING */
-   202,  /* (26) cmd ::= SHOW dbPrefix STABLES */
-   202,  /* (27) cmd ::= SHOW dbPrefix STABLES LIKE STRING */
-   202,  /* (28) cmd ::= SHOW dbPrefix VGROUPS */
-   202,  /* (29) cmd ::= DROP TABLE ifexists ids cpxName */
-   202,  /* (30) cmd ::= DROP STABLE ifexists ids cpxName */
-   202,  /* (31) cmd ::= DROP DATABASE ifexists ids */
-   202,  /* (32) cmd ::= DROP TOPIC ifexists ids */
-   202,  /* (33) cmd ::= DROP FUNCTION ids */
-   202,  /* (34) cmd ::= DROP DNODE ids */
-   202,  /* (35) cmd ::= DROP USER ids */
-   202,  /* (36) cmd ::= DROP ACCOUNT ids */
-   202,  /* (37) cmd ::= USE ids */
-   202,  /* (38) cmd ::= DESCRIBE ids cpxName */
-   202,  /* (39) cmd ::= DESC ids cpxName */
-   202,  /* (40) cmd ::= ALTER USER ids PASS ids */
-   202,  /* (41) cmd ::= ALTER USER ids PRIVILEGE ids */
-   202,  /* (42) cmd ::= ALTER DNODE ids ids */
-   202,  /* (43) cmd ::= ALTER DNODE ids ids ids */
-   202,  /* (44) cmd ::= ALTER LOCAL ids */
-   202,  /* (45) cmd ::= ALTER LOCAL ids ids */
-   202,  /* (46) cmd ::= ALTER DATABASE ids alter_db_optr */
-   202,  /* (47) cmd ::= ALTER TOPIC ids alter_topic_optr */
-   202,  /* (48) cmd ::= ALTER ACCOUNT ids acct_optr */
-   202,  /* (49) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
-   202,  /* (50) cmd ::= COMPACT VNODES IN LP exprlist RP */
-   203,  /* (51) ids ::= ID */
-   203,  /* (52) ids ::= STRING */
-   206,  /* (53) ifexists ::= IF EXISTS */
-   206,  /* (54) ifexists ::= */
-   211,  /* (55) ifnotexists ::= IF NOT EXISTS */
-   211,  /* (56) ifnotexists ::= */
-   202,  /* (57) cmd ::= CREATE DNODE ids */
-   202,  /* (58) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
-   202,  /* (59) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
-   202,  /* (60) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */
-   202,  /* (61) cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
-   202,  /* (62) cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
-   202,  /* (63) cmd ::= CREATE USER ids PASS ids */
-   215,  /* (64) bufsize ::= */
-   215,  /* (65) bufsize ::= BUFSIZE INTEGER */
-   216,  /* (66) pps ::= */
-   216,  /* (67) pps ::= PPS INTEGER */
-   217,  /* (68) tseries ::= */
-   217,  /* (69) tseries ::= TSERIES INTEGER */
-   218,  /* (70) dbs ::= */
-   218,  /* (71) dbs ::= DBS INTEGER */
-   219,  /* (72) streams ::= */
-   219,  /* (73) streams ::= STREAMS INTEGER */
-   220,  /* (74) storage ::= */
-   220,  /* (75) storage ::= STORAGE INTEGER */
-   221,  /* (76) qtime ::= */
-   221,  /* (77) qtime ::= QTIME INTEGER */
-   222,  /* (78) users ::= */
-   222,  /* (79) users ::= USERS INTEGER */
-   223,  /* (80) conns ::= */
-   223,  /* (81) conns ::= CONNS INTEGER */
-   224,  /* (82) state ::= */
-   224,  /* (83) state ::= STATE ids */
-   209,  /* (84) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
-   225,  /* (85) intitemlist ::= intitemlist COMMA intitem */
-   225,  /* (86) intitemlist ::= intitem */
-   226,  /* (87) intitem ::= INTEGER */
-   227,  /* (88) keep ::= KEEP intitemlist */
-   228,  /* (89) cache ::= CACHE INTEGER */
-   229,  /* (90) replica ::= REPLICA INTEGER */
-   230,  /* (91) quorum ::= QUORUM INTEGER */
-   231,  /* (92) days ::= DAYS INTEGER */
-   232,  /* (93) minrows ::= MINROWS INTEGER */
-   233,  /* (94) maxrows ::= MAXROWS INTEGER */
-   234,  /* (95) blocks ::= BLOCKS INTEGER */
-   235,  /* (96) ctime ::= CTIME INTEGER */
-   236,  /* (97) wal ::= WAL INTEGER */
-   237,  /* (98) fsync ::= FSYNC INTEGER */
-   238,  /* (99) comp ::= COMP INTEGER */
-   239,  /* (100) prec ::= PRECISION STRING */
-   240,  /* (101) update ::= UPDATE INTEGER */
-   241,  /* (102) cachelast ::= CACHELAST INTEGER */
-   242,  /* (103) partitions ::= PARTITIONS INTEGER */
-   212,  /* (104) db_optr ::= */
-   212,  /* (105) db_optr ::= db_optr cache */
-   212,  /* (106) db_optr ::= db_optr replica */
-   212,  /* (107) db_optr ::= db_optr quorum */
-   212,  /* (108) db_optr ::= db_optr days */
-   212,  /* (109) db_optr ::= db_optr minrows */
-   212,  /* (110) db_optr ::= db_optr maxrows */
-   212,  /* (111) db_optr ::= db_optr blocks */
-   212,  /* (112) db_optr ::= db_optr ctime */
-   212,  /* (113) db_optr ::= db_optr wal */
-   212,  /* (114) db_optr ::= db_optr fsync */
-   212,  /* (115) db_optr ::= db_optr comp */
-   212,  /* (116) db_optr ::= db_optr prec */
-   212,  /* (117) db_optr ::= db_optr keep */
-   212,  /* (118) db_optr ::= db_optr update */
-   212,  /* (119) db_optr ::= db_optr cachelast */
-   213,  /* (120) topic_optr ::= db_optr */
-   213,  /* (121) topic_optr ::= topic_optr partitions */
-   207,  /* (122) alter_db_optr ::= */
-   207,  /* (123) alter_db_optr ::= alter_db_optr replica */
-   207,  /* (124) alter_db_optr ::= alter_db_optr quorum */
-   207,  /* (125) alter_db_optr ::= alter_db_optr keep */
-   207,  /* (126) alter_db_optr ::= alter_db_optr blocks */
-   207,  /* (127) alter_db_optr ::= alter_db_optr comp */
-   207,  /* (128) alter_db_optr ::= alter_db_optr update */
-   207,  /* (129) alter_db_optr ::= alter_db_optr cachelast */
-   208,  /* (130) alter_topic_optr ::= alter_db_optr */
-   208,  /* (131) alter_topic_optr ::= alter_topic_optr partitions */
-   214,  /* (132) typename ::= ids */
-   214,  /* (133) typename ::= ids LP signed RP */
-   214,  /* (134) typename ::= ids UNSIGNED */
-   243,  /* (135) signed ::= INTEGER */
-   243,  /* (136) signed ::= PLUS INTEGER */
-   243,  /* (137) signed ::= MINUS INTEGER */
-   202,  /* (138) cmd ::= CREATE TABLE create_table_args */
-   202,  /* (139) cmd ::= CREATE TABLE create_stable_args */
-   202,  /* (140) cmd ::= CREATE STABLE create_stable_args */
-   202,  /* (141) cmd ::= CREATE TABLE create_table_list */
-   246,  /* (142) create_table_list ::= create_from_stable */
-   246,  /* (143) create_table_list ::= create_table_list create_from_stable */
-   244,  /* (144) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
-   245,  /* (145) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
-   247,  /* (146) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
-   247,  /* (147) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
-   250,  /* (148) tagNamelist ::= tagNamelist COMMA ids */
-   250,  /* (149) tagNamelist ::= ids */
-   244,  /* (150) create_table_args ::= ifnotexists ids cpxName AS select */
-   248,  /* (151) columnlist ::= columnlist COMMA column */
-   248,  /* (152) columnlist ::= column */
-   252,  /* (153) column ::= ids typename */
-   249,  /* (154) tagitemlist ::= tagitemlist COMMA tagitem */
-   249,  /* (155) tagitemlist ::= tagitem */
-   253,  /* (156) tagitem ::= INTEGER */
-   253,  /* (157) tagitem ::= FLOAT */
-   253,  /* (158) tagitem ::= STRING */
-   253,  /* (159) tagitem ::= BOOL */
-   253,  /* (160) tagitem ::= NULL */
-   253,  /* (161) tagitem ::= NOW */
-   253,  /* (162) tagitem ::= NOW PLUS VARIABLE */
-   253,  /* (163) tagitem ::= NOW MINUS VARIABLE */
-   253,  /* (164) tagitem ::= MINUS INTEGER */
-   253,  /* (165) tagitem ::= MINUS FLOAT */
-   253,  /* (166) tagitem ::= PLUS INTEGER */
-   253,  /* (167) tagitem ::= PLUS FLOAT */
-   251,  /* (168) select ::= SELECT selcollist from where_opt range_option interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
-   251,  /* (169) select ::= LP select RP */
-   268,  /* (170) union ::= select */
-   268,  /* (171) union ::= union UNION ALL select */
-   202,  /* (172) cmd ::= union */
-   251,  /* (173) select ::= SELECT selcollist */
-   269,  /* (174) sclp ::= selcollist COMMA */
-   269,  /* (175) sclp ::= */
-   254,  /* (176) selcollist ::= sclp distinct expr as */
-   254,  /* (177) selcollist ::= sclp STAR */
-   272,  /* (178) as ::= AS ids */
-   272,  /* (179) as ::= ids */
-   272,  /* (180) as ::= */
-   270,  /* (181) distinct ::= DISTINCT */
-   270,  /* (182) distinct ::= */
-   255,  /* (183) from ::= FROM tablelist */
-   255,  /* (184) from ::= FROM sub */
-   274,  /* (185) sub ::= LP union RP */
-   274,  /* (186) sub ::= LP union RP ids */
-   274,  /* (187) sub ::= sub COMMA LP union RP ids */
-   273,  /* (188) tablelist ::= ids cpxName */
-   273,  /* (189) tablelist ::= ids cpxName ids */
-   273,  /* (190) tablelist ::= tablelist COMMA ids cpxName */
-   273,  /* (191) tablelist ::= tablelist COMMA ids cpxName ids */
-   275,  /* (192) tmvar ::= VARIABLE */
-   276,  /* (193) timestamp ::= INTEGER */
-   276,  /* (194) timestamp ::= MINUS INTEGER */
-   276,  /* (195) timestamp ::= PLUS INTEGER */
-   276,  /* (196) timestamp ::= STRING */
-   276,  /* (197) timestamp ::= NOW */
-   276,  /* (198) timestamp ::= NOW PLUS VARIABLE */
-   276,  /* (199) timestamp ::= NOW MINUS VARIABLE */
-   257,  /* (200) range_option ::= */
-   257,  /* (201) range_option ::= RANGE LP timestamp COMMA timestamp RP */
-   258,  /* (202) interval_option ::= intervalKey LP tmvar RP */
-   258,  /* (203) interval_option ::= intervalKey LP tmvar COMMA tmvar RP */
-   258,  /* (204) interval_option ::= */
-   277,  /* (205) intervalKey ::= INTERVAL */
-   277,  /* (206) intervalKey ::= EVERY */
-   260,  /* (207) session_option ::= */
-   260,  /* (208) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
-   261,  /* (209) windowstate_option ::= */
-   261,  /* (210) windowstate_option ::= STATE_WINDOW LP ids RP */
-   262,  /* (211) fill_opt ::= */
-   262,  /* (212) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
-   262,  /* (213) fill_opt ::= FILL LP ID RP */
-   259,  /* (214) sliding_opt ::= SLIDING LP tmvar RP */
-   259,  /* (215) sliding_opt ::= */
-   265,  /* (216) orderby_opt ::= */
-   265,  /* (217) orderby_opt ::= ORDER BY sortlist */
-   278,  /* (218) sortlist ::= sortlist COMMA item sortorder */
-   278,  /* (219) sortlist ::= sortlist COMMA arrow sortorder */
-   278,  /* (220) sortlist ::= item sortorder */
-   278,  /* (221) sortlist ::= arrow sortorder */
-   279,  /* (222) item ::= ID */
-   279,  /* (223) item ::= ID DOT ID */
-   280,  /* (224) sortorder ::= ASC */
-   280,  /* (225) sortorder ::= DESC */
-   280,  /* (226) sortorder ::= */
-   263,  /* (227) groupby_opt ::= */
-   263,  /* (228) groupby_opt ::= GROUP BY grouplist */
-   282,  /* (229) grouplist ::= grouplist COMMA item */
-   282,  /* (230) grouplist ::= grouplist COMMA arrow */
-   282,  /* (231) grouplist ::= item */
-   282,  /* (232) grouplist ::= arrow */
-   264,  /* (233) having_opt ::= */
-   264,  /* (234) having_opt ::= HAVING expr */
-   267,  /* (235) limit_opt ::= */
-   267,  /* (236) limit_opt ::= LIMIT signed */
-   267,  /* (237) limit_opt ::= LIMIT signed OFFSET signed */
-   267,  /* (238) limit_opt ::= LIMIT signed COMMA signed */
-   266,  /* (239) slimit_opt ::= */
-   266,  /* (240) slimit_opt ::= SLIMIT signed */
-   266,  /* (241) slimit_opt ::= SLIMIT signed SOFFSET signed */
-   266,  /* (242) slimit_opt ::= SLIMIT signed COMMA signed */
-   256,  /* (243) where_opt ::= */
-   256,  /* (244) where_opt ::= WHERE expr */
-   271,  /* (245) expr ::= LP expr RP */
-   271,  /* (246) expr ::= ID */
-   271,  /* (247) expr ::= ID DOT ID */
-   271,  /* (248) expr ::= ID DOT STAR */
-   271,  /* (249) expr ::= INTEGER */
-   271,  /* (250) expr ::= MINUS INTEGER */
-   271,  /* (251) expr ::= PLUS INTEGER */
-   271,  /* (252) expr ::= FLOAT */
-   271,  /* (253) expr ::= MINUS FLOAT */
-   271,  /* (254) expr ::= PLUS FLOAT */
-   271,  /* (255) expr ::= STRING */
-   271,  /* (256) expr ::= NOW */
-   271,  /* (257) expr ::= VARIABLE */
-   271,  /* (258) expr ::= PLUS VARIABLE */
-   271,  /* (259) expr ::= MINUS VARIABLE */
-   271,  /* (260) expr ::= BOOL */
-   271,  /* (261) expr ::= NULL */
-   271,  /* (262) expr ::= ID LP exprlist RP */
-   271,  /* (263) expr ::= ID LP STAR RP */
-   271,  /* (264) expr ::= ID LP expr AS typename RP */
-   271,  /* (265) expr ::= expr IS NULL */
-   271,  /* (266) expr ::= expr IS NOT NULL */
-   271,  /* (267) expr ::= expr LT expr */
-   271,  /* (268) expr ::= expr GT expr */
-   271,  /* (269) expr ::= expr LE expr */
-   271,  /* (270) expr ::= expr GE expr */
-   271,  /* (271) expr ::= expr NE expr */
-   271,  /* (272) expr ::= expr EQ expr */
-   271,  /* (273) expr ::= expr BETWEEN expr AND expr */
-   271,  /* (274) expr ::= expr AND expr */
-   271,  /* (275) expr ::= expr OR expr */
-   271,  /* (276) expr ::= expr PLUS expr */
-   271,  /* (277) expr ::= expr MINUS expr */
-   271,  /* (278) expr ::= expr STAR expr */
-   271,  /* (279) expr ::= expr SLASH expr */
-   271,  /* (280) expr ::= expr REM expr */
-   271,  /* (281) expr ::= expr LIKE expr */
-   271,  /* (282) expr ::= expr MATCH expr */
-   271,  /* (283) expr ::= expr NMATCH expr */
-   271,  /* (284) expr ::= ID CONTAINS STRING */
-   271,  /* (285) expr ::= ID DOT ID CONTAINS STRING */
-   281,  /* (286) arrow ::= ID ARROW STRING */
-   281,  /* (287) arrow ::= ID DOT ID ARROW STRING */
-   271,  /* (288) expr ::= arrow */
-   271,  /* (289) expr ::= expr IN LP exprlist RP */
-   210,  /* (290) exprlist ::= exprlist COMMA expritem */
-   210,  /* (291) exprlist ::= expritem */
-   283,  /* (292) expritem ::= expr */
-   283,  /* (293) expritem ::= */
-   202,  /* (294) cmd ::= RESET QUERY CACHE */
-   202,  /* (295) cmd ::= SYNCDB ids REPLICA */
-   202,  /* (296) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
-   202,  /* (297) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
-   202,  /* (298) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
-   202,  /* (299) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
-   202,  /* (300) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
-   202,  /* (301) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
-   202,  /* (302) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
-   202,  /* (303) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
-   202,  /* (304) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
-   202,  /* (305) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
-   202,  /* (306) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
-   202,  /* (307) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
-   202,  /* (308) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
-   202,  /* (309) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
-   202,  /* (310) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
-   202,  /* (311) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
-   202,  /* (312) cmd ::= KILL CONNECTION INTEGER */
-   202,  /* (313) cmd ::= KILL STREAM INTEGER COLON INTEGER */
-   202,  /* (314) cmd ::= KILL QUERY INTEGER COLON INTEGER */
-};
-
-/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number
-** of symbols on the right-hand side of that rule. */
-static const signed char yyRuleInfoNRhs[] = {
-   -1,  /* (0) program ::= cmd */
-   -2,  /* (1) cmd ::= SHOW DATABASES */
-   -2,  /* (2) cmd ::= SHOW TOPICS */
-   -2,  /* (3) cmd ::= SHOW FUNCTIONS */
-   -2,  /* (4) cmd ::= SHOW MNODES */
-   -2,  /* (5) cmd ::= SHOW DNODES */
-   -2,  /* (6) cmd ::= SHOW ACCOUNTS */
-   -2,  /* (7) cmd ::= SHOW USERS */
-   -2,  /* (8) cmd ::= SHOW MODULES */
-   -2,  /* (9) cmd ::= SHOW QUERIES */
-   -2,  /* (10) cmd ::= SHOW CONNECTIONS */
-   -2,  /* (11) cmd ::= SHOW STREAMS */
-   -2,  /* (12) cmd ::= SHOW VARIABLES */
-   -2,  /* (13) cmd ::= SHOW SCORES */
-   -2,  /* (14) cmd ::= SHOW GRANTS */
-   -2,  /* (15) cmd ::= SHOW VNODES */
-   -3,  /* (16) cmd ::= SHOW VNODES ids */
-    0,  /* (17) dbPrefix ::= */
-   -2,  /* (18) dbPrefix ::= ids DOT */
-    0,  /* (19) cpxName ::= */
-   -2,  /* (20) cpxName ::= DOT ids */
-   -5,  /* (21) cmd ::= SHOW CREATE TABLE ids cpxName */
-   -5,  /* (22) cmd ::= SHOW CREATE STABLE ids cpxName */
-   -4,  /* (23) cmd ::= SHOW CREATE DATABASE ids */
-   -3,  /* (24) cmd ::= SHOW dbPrefix TABLES */
-   -5,  /* (25) cmd ::= SHOW dbPrefix TABLES LIKE STRING */
-   -3,  /* (26) cmd ::= SHOW dbPrefix STABLES */
-   -5,  /* (27) cmd ::= SHOW dbPrefix STABLES LIKE STRING */
-   -3,  /* (28) cmd ::= SHOW dbPrefix VGROUPS */
-   -5,  /* (29) cmd ::= DROP TABLE ifexists ids cpxName */
-   -5,  /* (30) cmd ::= DROP STABLE ifexists ids cpxName */
-   -4,  /* (31) cmd ::= DROP DATABASE ifexists ids */
-   -4,  /* (32) cmd ::= DROP TOPIC ifexists ids */
-   -3,  /* (33) cmd ::= DROP FUNCTION ids */
-   -3,  /* (34) cmd ::= DROP DNODE ids */
-   -3,  /* (35) cmd ::= DROP USER ids */
-   -3,  /* (36) cmd ::= DROP ACCOUNT ids */
-   -2,  /* (37) cmd ::= USE ids */
-   -3,  /* (38) cmd ::= DESCRIBE ids cpxName */
-   -3,  /* (39) cmd ::= DESC ids cpxName */
-   -5,  /* (40) cmd ::= ALTER USER ids PASS ids */
-   -5,  /* (41) cmd ::= ALTER USER ids PRIVILEGE ids */
-   -4,  /* (42) cmd ::= ALTER DNODE ids ids */
-   -5,  /* (43) cmd ::= ALTER DNODE ids ids ids */
-   -3,  /* (44) cmd ::= ALTER LOCAL ids */
-   -4,  /* (45) cmd ::= ALTER LOCAL ids ids */
-   -4,  /* (46) cmd ::= ALTER DATABASE ids alter_db_optr */
-   -4,  /* (47) cmd ::= ALTER TOPIC ids alter_topic_optr */
-   -4,  /* (48) cmd ::= ALTER ACCOUNT ids acct_optr */
-   -6,  /* (49) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
-   -6,  /* (50) cmd ::= COMPACT VNODES IN LP exprlist RP */
-   -1,  /* (51) ids ::= ID */
-   -1,  /* (52) ids ::= STRING */
-   -2,  /* (53) ifexists ::= IF EXISTS */
-    0,  /* (54) ifexists ::= */
-   -3,  /* (55) ifnotexists ::= IF NOT EXISTS */
-    0,  /* (56) ifnotexists ::= */
-   -3,  /* (57) cmd ::= CREATE DNODE ids */
-   -6,  /* (58) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
-   -5,  /* (59) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
-   -5,  /* (60) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */
-   -8,  /* (61) cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
-   -9,  /* (62) cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
-   -5,  /* (63) cmd ::= CREATE USER ids PASS ids */
-    0,  /* (64) bufsize ::= */
-   -2,  /* (65) bufsize ::= BUFSIZE INTEGER */
-    0,  /* (66) pps ::= */
-   -2,  /* (67) pps ::= PPS INTEGER */
-    0,  /* (68) tseries ::= */
-   -2,  /* (69) tseries ::= TSERIES INTEGER */
-    0,  /* (70) dbs ::= */
-   -2,  /* (71) dbs ::= DBS INTEGER */
-    0,  /* (72) streams ::= */
-   -2,  /* (73) streams ::= STREAMS INTEGER */
-    0,  /* (74) storage ::= */
-   -2,  /* (75) storage ::= STORAGE INTEGER */
-    0,  /* (76) qtime ::= */
-   -2,  /* (77) qtime ::= QTIME INTEGER */
-    0,  /* (78) users ::= */
-   -2,  /* (79) users ::= USERS INTEGER */
-    0,  /* (80) conns ::= */
-   -2,  /* (81) conns ::= CONNS INTEGER */
-    0,  /* (82) state ::= */
-   -2,  /* (83) state ::= STATE ids */
-   -9,  /* (84) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
-   -3,  /* (85) intitemlist ::= intitemlist COMMA intitem */
-   -1,  /* (86) intitemlist ::= intitem */
-   -1,  /* (87) intitem ::= INTEGER */
-   -2,  /* (88) keep ::= KEEP intitemlist */
-   -2,  /* (89) cache ::= CACHE INTEGER */
-   -2,  /* (90) replica ::= REPLICA INTEGER */
-   -2,  /* (91) quorum ::= QUORUM INTEGER */
-   -2,  /* (92) days ::= DAYS INTEGER */
-   -2,  /* (93) minrows ::= MINROWS INTEGER */
-   -2,  /* (94) maxrows ::= MAXROWS INTEGER */
-   -2,  /* (95) blocks ::= BLOCKS INTEGER */
-   -2,  /* (96) ctime ::= CTIME INTEGER */
-   -2,  /* (97) wal ::= WAL INTEGER */
-   -2,  /* (98) fsync ::= FSYNC INTEGER */
-   -2,  /* (99) comp ::= COMP INTEGER */
-   -2,  /* (100) prec ::= PRECISION STRING */
-   -2,  /* (101) update ::= UPDATE INTEGER */
-   -2,  /* (102) cachelast ::= CACHELAST INTEGER */
-   -2,  /* (103) partitions ::= PARTITIONS INTEGER */
-    0,  /* (104) db_optr ::= */
-   -2,  /* (105) db_optr ::= db_optr cache */
-   -2,  /* (106) db_optr ::= db_optr replica */
-   -2,  /* (107) db_optr ::= db_optr quorum */
-   -2,  /* (108) db_optr ::= db_optr days */
-   -2,  /* (109) db_optr ::= db_optr minrows */
-   -2,  /* (110) db_optr ::= db_optr maxrows */
-   -2,  /* (111) db_optr ::= db_optr blocks */
-   -2,  /* (112) db_optr ::= db_optr ctime */
-   -2,  /* (113) db_optr ::= db_optr wal */
-   -2,  /* (114) db_optr ::= db_optr fsync */
-   -2,  /* (115) db_optr ::= db_optr comp */
-   -2,  /* (116) db_optr ::= db_optr prec */
-   -2,  /* (117) db_optr ::= db_optr keep */
-   -2,  /* (118) db_optr ::= db_optr update */
-   -2,  /* (119) db_optr ::= db_optr cachelast */
-   -1,  /* (120) topic_optr ::= db_optr */
-   -2,  /* (121) topic_optr ::= topic_optr partitions */
-    0,  /* (122) alter_db_optr ::= */
-   -2,  /* (123) alter_db_optr ::= alter_db_optr replica */
-   -2,  /* (124) alter_db_optr ::= alter_db_optr quorum */
-   -2,  /* (125) alter_db_optr ::= alter_db_optr keep */
-   -2,  /* (126) alter_db_optr ::= alter_db_optr blocks */
-   -2,  /* (127) alter_db_optr ::= alter_db_optr comp */
-   -2,  /* (128) alter_db_optr ::= alter_db_optr update */
-   -2,  /* (129) alter_db_optr ::= alter_db_optr cachelast */
-   -1,  /* (130) alter_topic_optr ::= alter_db_optr */
-   -2,  /* (131) alter_topic_optr ::= alter_topic_optr partitions */
-   -1,  /* (132) typename ::= ids */
-   -4,  /* (133) typename ::= ids LP signed RP */
-   -2,  /* (134) typename ::= ids UNSIGNED */
-   -1,  /* (135) signed ::= INTEGER */
-   -2,  /* (136) signed ::= PLUS INTEGER */
-   -2,  /* (137) signed ::= MINUS INTEGER */
-   -3,  /* (138) cmd ::= CREATE TABLE create_table_args */
-   -3,  /* (139) cmd ::= CREATE TABLE create_stable_args */
-   -3,  /* (140) cmd ::= CREATE STABLE create_stable_args */
-   -3,  /* (141) cmd ::= CREATE TABLE create_table_list */
-   -1,  /* (142) create_table_list ::= create_from_stable */
-   -2,  /* (143) create_table_list ::= create_table_list create_from_stable */
-   -6,  /* (144) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
-  -10,  /* (145) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
-  -10,  /* (146) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
-  -13,  /* (147) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
-   -3,  /* (148) tagNamelist ::= tagNamelist COMMA ids */
-   -1,  /* (149) tagNamelist ::= ids */
-   -5,  /* (150) create_table_args ::= ifnotexists ids cpxName AS select */
-   -3,  /* (151) columnlist ::= columnlist COMMA column */
-   -1,  /* (152) columnlist ::= column */
-   -2,  /* (153) column ::= ids typename */
-   -3,  /* (154) tagitemlist ::= tagitemlist COMMA tagitem */
-   -1,  /* (155) tagitemlist ::= tagitem */
-   -1,  /* (156) tagitem ::= INTEGER */
-   -1,  /* (157) tagitem ::= FLOAT */
-   -1,  /* (158) tagitem ::= STRING */
-   -1,  /* (159) tagitem ::= BOOL */
-   -1,  /* (160) tagitem ::= NULL */
-   -1,  /* (161) tagitem ::= NOW */
-   -3,  /* (162) tagitem ::= NOW PLUS VARIABLE */
-   -3,  /* (163) tagitem ::= NOW MINUS VARIABLE */
-   -2,  /* (164) tagitem ::= MINUS INTEGER */
-   -2,  /* (165) tagitem ::= MINUS FLOAT */
-   -2,  /* (166) tagitem ::= PLUS INTEGER */
-   -2,  /* (167) tagitem ::= PLUS FLOAT */
-  -15,  /* (168) select ::= SELECT selcollist from where_opt range_option interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
-   -3,  /* (169) select ::= LP select RP */
-   -1,  /* (170) union ::= select */
-   -4,  /* (171) union ::= union UNION ALL select */
-   -1,  /* (172) cmd ::= union */
-   -2,  /* (173) select ::= SELECT selcollist */
-   -2,  /* (174) sclp ::= selcollist COMMA */
-    0,  /* (175) sclp ::= */
-   -4,  /* (176) selcollist ::= sclp distinct expr as */
-   -2,  /* (177) selcollist ::= sclp STAR */
-   -2,  /* (178) as ::= AS ids */
-   -1,  /* (179) as ::= ids */
-    0,  /* (180) as ::= */
-   -1,  /* (181) distinct ::= DISTINCT */
-    0,  /* (182) distinct ::= */
-   -2,  /* (183) from ::= FROM tablelist */
-   -2,  /* (184) from ::= FROM sub */
-   -3,  /* (185) sub ::= LP union RP */
-   -4,  /* (186) sub ::= LP union RP ids */
-   -6,  /* (187) sub ::= sub COMMA LP union RP ids */
-   -2,  /* (188) tablelist ::= ids cpxName */
-   -3,  /* (189) tablelist ::= ids cpxName ids */
-   -4,  /* (190) tablelist ::= tablelist COMMA ids cpxName */
-   -5,  /* (191) tablelist ::= tablelist COMMA ids cpxName ids */
-   -1,  /* (192) tmvar ::= VARIABLE */
-   -1,  /* (193) timestamp ::= INTEGER */
-   -2,  /* (194) timestamp ::= MINUS INTEGER */
-   -2,  /* (195) timestamp ::= PLUS INTEGER */
-   -1,  /* (196) timestamp ::= STRING */
-   -1,  /* (197) timestamp ::= NOW */
-   -3,  /* (198) timestamp ::= NOW PLUS VARIABLE */
-   -3,  /* (199) timestamp ::= NOW MINUS VARIABLE */
-    0,  /* (200) range_option ::= */
-   -6,  /* (201) range_option ::= RANGE LP timestamp COMMA timestamp RP */
-   -4,  /* (202) interval_option ::= intervalKey LP tmvar RP */
-   -6,  /* (203) interval_option ::= intervalKey LP tmvar COMMA tmvar RP */
-    0,  /* (204) interval_option ::= */
-   -1,  /* (205) intervalKey ::= INTERVAL */
-   -1,  /* (206) intervalKey ::= EVERY */
-    0,  /* (207) session_option ::= */
-   -7,  /* (208) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
-    0,  /* (209) windowstate_option ::= */
-   -4,  /* (210) windowstate_option ::= STATE_WINDOW LP ids RP */
-    0,  /* (211) fill_opt ::= */
-   -6,  /* (212) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
-   -4,  /* (213) fill_opt ::= FILL LP ID RP */
-   -4,  /* (214) sliding_opt ::= SLIDING LP tmvar RP */
-    0,  /* (215) sliding_opt ::= */
-    0,  /* (216) orderby_opt ::= */
-   -3,  /* (217) orderby_opt ::= ORDER BY sortlist */
-   -4,  /* (218) sortlist ::= sortlist COMMA item sortorder */
-   -4,  /* (219) sortlist ::= sortlist COMMA arrow sortorder */
-   -2,  /* (220) sortlist ::= item sortorder */
-   -2,  /* (221) sortlist ::= arrow sortorder */
-   -1,  /* (222) item ::= ID */
-   -3,  /* (223) item ::= ID DOT ID */
-   -1,  /* (224) sortorder ::= ASC */
-   -1,  /* (225) sortorder ::= DESC */
-    0,  /* (226) sortorder ::= */
-    0,  /* (227) groupby_opt ::= */
-   -3,  /* (228) groupby_opt ::= GROUP BY grouplist */
-   -3,  /* (229) grouplist ::= grouplist COMMA item */
-   -3,  /* (230) grouplist ::= grouplist COMMA arrow */
-   -1,  /* (231) grouplist ::= item */
-   -1,  /* (232) grouplist ::= arrow */
-    0,  /* (233) having_opt ::= */
-   -2,  /* (234) having_opt ::= HAVING expr */
-    0,  /* (235) limit_opt ::= */
-   -2,  /* (236) limit_opt ::= LIMIT signed */
-   -4,  /* (237) limit_opt ::= LIMIT signed OFFSET signed */
-   -4,  /* (238) limit_opt ::= LIMIT signed COMMA signed */
-    0,  /* (239) slimit_opt ::= */
-   -2,  /* (240) slimit_opt ::= SLIMIT signed */
-   -4,  /* (241) slimit_opt ::= SLIMIT signed SOFFSET signed */
-   -4,  /* (242) slimit_opt ::= SLIMIT signed COMMA signed */
-    0,  /* (243) where_opt ::= */
-   -2,  /* (244) where_opt ::= WHERE expr */
-   -3,  /* (245) expr ::= LP expr RP */
-   -1,  /* (246) expr ::= ID */
-   -3,  /* (247) expr ::= ID DOT ID */
-   -3,  /* (248) expr ::= ID DOT STAR */
-   -1,  /* (249) expr ::= INTEGER */
-   -2,  /* (250) expr ::= MINUS INTEGER */
-   -2,  /* (251) expr ::= PLUS INTEGER */
-   -1,  /* (252) expr ::= FLOAT */
-   -2,  /* (253) expr ::= MINUS FLOAT */
-   -2,  /* (254) expr ::= PLUS FLOAT */
-   -1,  /* (255) expr ::= STRING */
-   -1,  /* (256) expr ::= NOW */
-   -1,  /* (257) expr ::= VARIABLE */
-   -2,  /* (258) expr ::= PLUS VARIABLE */
-   -2,  /* (259) expr ::= MINUS VARIABLE */
-   -1,  /* (260) expr ::= BOOL */
-   -1,  /* (261) expr ::= NULL */
-   -4,  /* (262) expr ::= ID LP exprlist RP */
-   -4,  /* (263) expr ::= ID LP STAR RP */
-   -6,  /* (264) expr ::= ID LP expr AS typename RP */
-   -3,  /* (265) expr ::= expr IS NULL */
-   -4,  /* (266) expr ::= expr IS NOT NULL */
-   -3,  /* (267) expr ::= expr LT expr */
-   -3,  /* (268) expr ::= expr GT expr */
-   -3,  /* (269) expr ::= expr LE expr */
-   -3,  /* (270) expr ::= expr GE expr */
-   -3,  /* (271) expr ::= expr NE expr */
-   -3,  /* (272) expr ::= expr EQ expr */
-   -5,  /* (273) expr ::= expr BETWEEN expr AND expr */
-   -3,  /* (274) expr ::= expr AND expr */
-   -3,  /* (275) expr ::= expr OR expr */
-   -3,  /* (276) expr ::= expr PLUS expr */
-   -3,  /* (277) expr ::= expr MINUS expr */
-   -3,  /* (278) expr ::= expr STAR expr */
-   -3,  /* (279) expr ::= expr SLASH expr */
-   -3,  /* (280) expr ::= expr REM expr */
-   -3,  /* (281) expr ::= expr LIKE expr */
-   -3,  /* (282) expr ::= expr MATCH expr */
-   -3,  /* (283) expr ::= expr NMATCH expr */
-   -3,  /* (284) expr ::= ID CONTAINS STRING */
-   -5,  /* (285) expr ::= ID DOT ID CONTAINS STRING */
-   -3,  /* (286) arrow ::= ID ARROW STRING */
-   -5,  /* (287) arrow ::= ID DOT ID ARROW STRING */
-   -1,  /* (288) expr ::= arrow */
-   -5,  /* (289) expr ::= expr IN LP exprlist RP */
-   -3,  /* (290) exprlist ::= exprlist COMMA expritem */
-   -1,  /* (291) exprlist ::= expritem */
-   -1,  /* (292) expritem ::= expr */
-    0,  /* (293) expritem ::= */
-   -3,  /* (294) cmd ::= RESET QUERY CACHE */
-   -3,  /* (295) cmd ::= SYNCDB ids REPLICA */
-   -7,  /* (296) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
-   -7,  /* (297) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
-   -7,  /* (298) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
-   -7,  /* (299) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
-   -7,  /* (300) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
-   -8,  /* (301) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
-   -9,  /* (302) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
-   -7,  /* (303) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
-   -7,  /* (304) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
-   -7,  /* (305) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
-   -7,  /* (306) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
-   -7,  /* (307) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
-   -7,  /* (308) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
-   -8,  /* (309) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
-   -9,  /* (310) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
-   -7,  /* (311) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
-   -3,  /* (312) cmd ::= KILL CONNECTION INTEGER */
-   -5,  /* (313) cmd ::= KILL STREAM INTEGER COLON INTEGER */
-   -5,  /* (314) cmd ::= KILL QUERY INTEGER COLON INTEGER */
+/* The following table contains information about every rule that
+** is used during the reduce.
+*/
+static const struct {
+  YYCODETYPE lhs;       /* Symbol on the left-hand side of the rule */
+  signed char nrhs;     /* Negative of the number of RHS symbols in the rule */
+} yyRuleInfo[] = {
+  {  203,   -1 }, /* (0) program ::= cmd */
+  {  204,   -2 }, /* (1) cmd ::= SHOW DATABASES */
+  {  204,   -2 }, /* (2) cmd ::= SHOW TOPICS */
+  {  204,   -2 }, /* (3) cmd ::= SHOW FUNCTIONS */
+  {  204,   -2 }, /* (4) cmd ::= SHOW MNODES */
+  {  204,   -2 }, /* (5) cmd ::= SHOW DNODES */
+  {  204,   -2 }, /* (6) cmd ::= SHOW ACCOUNTS */
+  {  204,   -2 }, /* (7) cmd ::= SHOW USERS */
+  {  204,   -2 }, /* (8) cmd ::= SHOW MODULES */
+  {  204,   -2 }, /* (9) cmd ::= SHOW QUERIES */
+  {  204,   -2 }, /* (10) cmd ::= SHOW CONNECTIONS */
+  {  204,   -2 }, /* (11) cmd ::= SHOW STREAMS */
+  {  204,   -2 }, /* (12) cmd ::= SHOW VARIABLES */
+  {  204,   -2 }, /* (13) cmd ::= SHOW SCORES */
+  {  204,   -2 }, /* (14) cmd ::= SHOW GRANTS */
+  {  204,   -2 }, /* (15) cmd ::= SHOW VNODES */
+  {  204,   -3 }, /* (16) cmd ::= SHOW VNODES ids */
+  {  206,    0 }, /* (17) dbPrefix ::= */
+  {  206,   -2 }, /* (18) dbPrefix ::= ids DOT */
+  {  207,    0 }, /* (19) cpxName ::= */
+  {  207,   -2 }, /* (20) cpxName ::= DOT ids */
+  {  204,   -5 }, /* (21) cmd ::= SHOW CREATE TABLE ids cpxName */
+  {  204,   -5 }, /* (22) cmd ::= SHOW CREATE STABLE ids cpxName */
+  {  204,   -4 }, /* (23) cmd ::= SHOW CREATE DATABASE ids */
+  {  204,   -3 }, /* (24) cmd ::= SHOW dbPrefix TABLES */
+  {  204,   -5 }, /* (25) cmd ::= SHOW dbPrefix TABLES LIKE STRING */
+  {  204,   -3 }, /* (26) cmd ::= SHOW dbPrefix STABLES */
+  {  204,   -5 }, /* (27) cmd ::= SHOW dbPrefix STABLES LIKE STRING */
+  {  204,   -3 }, /* (28) cmd ::= SHOW dbPrefix VGROUPS */
+  {  204,   -5 }, /* (29) cmd ::= DROP TABLE ifexists ids cpxName */
+  {  204,   -5 }, /* (30) cmd ::= DROP STABLE ifexists ids cpxName */
+  {  204,   -4 }, /* (31) cmd ::= DROP DATABASE ifexists ids */
+  {  204,   -4 }, /* (32) cmd ::= DROP TOPIC ifexists ids */
+  {  204,   -3 }, /* (33) cmd ::= DROP FUNCTION ids */
+  {  204,   -3 }, /* (34) cmd ::= DROP DNODE ids */
+  {  204,   -3 }, /* (35) cmd ::= DROP USER ids */
+  {  204,   -3 }, /* (36) cmd ::= DROP ACCOUNT ids */
+  {  204,   -2 }, /* (37) cmd ::= USE ids */
+  {  204,   -3 }, /* (38) cmd ::= DESCRIBE ids cpxName */
+  {  204,   -3 }, /* (39) cmd ::= DESC ids cpxName */
+  {  204,   -5 }, /* (40) cmd ::= ALTER USER ids PASS ids */
+  {  204,   -5 }, /* (41) cmd ::= ALTER USER ids PRIVILEGE ids */
+  {  204,   -4 }, /* (42) cmd ::= ALTER DNODE ids ids */
+  {  204,   -5 }, /* (43) cmd ::= ALTER DNODE ids ids ids */
+  {  204,   -3 }, /* (44) cmd ::= ALTER LOCAL ids */
+  {  204,   -4 }, /* (45) cmd ::= ALTER LOCAL ids ids */
+  {  204,   -4 }, /* (46) cmd ::= ALTER DATABASE ids alter_db_optr */
+  {  204,   -4 }, /* (47) cmd ::= ALTER TOPIC ids alter_topic_optr */
+  {  204,   -4 }, /* (48) cmd ::= ALTER ACCOUNT ids acct_optr */
+  {  204,   -6 }, /* (49) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
+  {  204,   -6 }, /* (50) cmd ::= COMPACT VNODES IN LP exprlist RP */
+  {  205,   -1 }, /* (51) ids ::= ID */
+  {  205,   -1 }, /* (52) ids ::= STRING */
+  {  208,   -2 }, /* (53) ifexists ::= IF EXISTS */
+  {  208,    0 }, /* (54) ifexists ::= */
+  {  213,   -3 }, /* (55) ifnotexists ::= IF NOT EXISTS */
+  {  213,    0 }, /* (56) ifnotexists ::= */
+  {  204,   -3 }, /* (57) cmd ::= CREATE DNODE ids */
+  {  204,   -6 }, /* (58) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
+  {  204,   -5 }, /* (59) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
+  {  204,   -5 }, /* (60) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */
+  {  204,   -8 }, /* (61) cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
+  {  204,   -9 }, /* (62) cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
+  {  204,   -5 }, /* (63) cmd ::= CREATE USER ids PASS ids */
+  {  217,    0 }, /* (64) bufsize ::= */
+  {  217,   -2 }, /* (65) bufsize ::= BUFSIZE INTEGER */
+  {  218,    0 }, /* (66) pps ::= */
+  {  218,   -2 }, /* (67) pps ::= PPS INTEGER */
+  {  219,    0 }, /* (68) tseries ::= */
+  {  219,   -2 }, /* (69) tseries ::= TSERIES INTEGER */
+  {  220,    0 }, /* (70) dbs ::= */
+  {  220,   -2 }, /* (71) dbs ::= DBS INTEGER */
+  {  221,    0 }, /* (72) streams ::= */
+  {  221,   -2 }, /* (73) streams ::= STREAMS INTEGER */
+  {  222,    0 }, /* (74) storage ::= */
+  {  222,   -2 }, /* (75) storage ::= STORAGE INTEGER */
+  {  223,    0 }, /* (76) qtime ::= */
+  {  223,   -2 }, /* (77) qtime ::= QTIME INTEGER */
+  {  224,    0 }, /* (78) users ::= */
+  {  224,   -2 }, /* (79) users ::= USERS INTEGER */
+  {  225,    0 }, /* (80) conns ::= */
+  {  225,   -2 }, /* (81) conns ::= CONNS INTEGER */
+  {  226,    0 }, /* (82) state ::= */
+  {  226,   -2 }, /* (83) state ::= STATE ids */
+  {  211,   -9 }, /* (84) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
+  {  227,   -3 }, /* (85) intitemlist ::= intitemlist COMMA intitem */
+  {  227,   -1 }, /* (86) intitemlist ::= intitem */
+  {  228,   -1 }, /* (87) intitem ::= INTEGER */
+  {  229,   -2 }, /* (88) keep ::= KEEP intitemlist */
+  {  230,   -2 }, /* (89) cache ::= CACHE INTEGER */
+  {  231,   -2 }, /* (90) replica ::= REPLICA INTEGER */
+  {  232,   -2 }, /* (91) quorum ::= QUORUM INTEGER */
+  {  233,   -2 }, /* (92) days ::= DAYS INTEGER */
+  {  234,   -2 }, /* (93) minrows ::= MINROWS INTEGER */
+  {  235,   -2 }, /* (94) maxrows ::= MAXROWS INTEGER */
+  {  236,   -2 }, /* (95) blocks ::= BLOCKS INTEGER */
+  {  237,   -2 }, /* (96) ctime ::= CTIME INTEGER */
+  {  238,   -2 }, /* (97) wal ::= WAL INTEGER */
+  {  239,   -2 }, /* (98) fsync ::= FSYNC INTEGER */
+  {  240,   -2 }, /* (99) comp ::= COMP INTEGER */
+  {  241,   -2 }, /* (100) prec ::= PRECISION STRING */
+  {  242,   -2 }, /* (101) update ::= UPDATE INTEGER */
+  {  243,   -2 }, /* (102) cachelast ::= CACHELAST INTEGER */
+  {  244,   -2 }, /* (103) partitions ::= PARTITIONS INTEGER */
+  {  214,    0 }, /* (104) db_optr ::= */
+  {  214,   -2 }, /* (105) db_optr ::= db_optr cache */
+  {  214,   -2 }, /* (106) db_optr ::= db_optr replica */
+  {  214,   -2 }, /* (107) db_optr ::= db_optr quorum */
+  {  214,   -2 }, /* (108) db_optr ::= db_optr days */
+  {  214,   -2 }, /* (109) db_optr ::= db_optr minrows */
+  {  214,   -2 }, /* (110) db_optr ::= db_optr maxrows */
+  {  214,   -2 }, /* (111) db_optr ::= db_optr blocks */
+  {  214,   -2 }, /* (112) db_optr ::= db_optr ctime */
+  {  214,   -2 }, /* (113) db_optr ::= db_optr wal */
+  {  214,   -2 }, /* (114) db_optr ::= db_optr fsync */
+  {  214,   -2 }, /* (115) db_optr ::= db_optr comp */
+  {  214,   -2 }, /* (116) db_optr ::= db_optr prec */
+  {  214,   -2 }, /* (117) db_optr ::= db_optr keep */
+  {  214,   -2 }, /* (118) db_optr ::= db_optr update */
+  {  214,   -2 }, /* (119) db_optr ::= db_optr cachelast */
+  {  215,   -1 }, /* (120) topic_optr ::= db_optr */
+  {  215,   -2 }, /* (121) topic_optr ::= topic_optr partitions */
+  {  209,    0 }, /* (122) alter_db_optr ::= */
+  {  209,   -2 }, /* (123) alter_db_optr ::= alter_db_optr replica */
+  {  209,   -2 }, /* (124) alter_db_optr ::= alter_db_optr quorum */
+  {  209,   -2 }, /* (125) alter_db_optr ::= alter_db_optr keep */
+  {  209,   -2 }, /* (126) alter_db_optr ::= alter_db_optr blocks */
+  {  209,   -2 }, /* (127) alter_db_optr ::= alter_db_optr comp */
+  {  209,   -2 }, /* (128) alter_db_optr ::= alter_db_optr update */
+  {  209,   -2 }, /* (129) alter_db_optr ::= alter_db_optr cachelast */
+  {  210,   -1 }, /* (130) alter_topic_optr ::= alter_db_optr */
+  {  210,   -2 }, /* (131) alter_topic_optr ::= alter_topic_optr partitions */
+  {  216,   -1 }, /* (132) typename ::= ids */
+  {  216,   -4 }, /* (133) typename ::= ids LP signed RP */
+  {  216,   -2 }, /* (134) typename ::= ids UNSIGNED */
+  {  245,   -1 }, /* (135) signed ::= INTEGER */
+  {  245,   -2 }, /* (136) signed ::= PLUS INTEGER */
+  {  245,   -2 }, /* (137) signed ::= MINUS INTEGER */
+  {  204,   -3 }, /* (138) cmd ::= CREATE TABLE create_table_args */
+  {  204,   -3 }, /* (139) cmd ::= CREATE TABLE create_stable_args */
+  {  204,   -3 }, /* (140) cmd ::= CREATE STABLE create_stable_args */
+  {  204,   -3 }, /* (141) cmd ::= CREATE TABLE create_table_list */
+  {  248,   -1 }, /* (142) create_table_list ::= create_from_stable */
+  {  248,   -2 }, /* (143) create_table_list ::= create_table_list create_from_stable */
+  {  246,   -6 }, /* (144) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
+  {  247,  -10 }, /* (145) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
+  {  249,  -10 }, /* (146) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
+  {  249,  -13 }, /* (147) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
+  {  252,   -3 }, /* (148) tagNamelist ::= tagNamelist COMMA ids */
+  {  252,   -1 }, /* (149) tagNamelist ::= ids */
+  {  246,   -7 }, /* (150) create_table_args ::= ifnotexists ids cpxName to_opt split_opt AS select */
+  {  253,    0 }, /* (151) to_opt ::= */
+  {  253,   -3 }, /* (152) to_opt ::= TO ids cpxName */
+  {  254,    0 }, /* (153) split_opt ::= */
+  {  254,   -2 }, /* (154) split_opt ::= SPLIT ids */
+  {  250,   -3 }, /* (155) columnlist ::= columnlist COMMA column */
+  {  250,   -1 }, /* (156) columnlist ::= column */
+  {  257,   -2 }, /* (157) column ::= ids typename */
+  {  251,   -3 }, /* (158) tagitemlist ::= tagitemlist COMMA tagitem */
+  {  251,   -1 }, /* (159) tagitemlist ::= tagitem */
+  {  258,   -1 }, /* (160) tagitem ::= INTEGER */
+  {  258,   -1 }, /* (161) tagitem ::= FLOAT */
+  {  258,   -1 }, /* (162) tagitem ::= STRING */
+  {  258,   -1 }, /* (163) tagitem ::= BOOL */
+  {  258,   -1 }, /* (164) tagitem ::= NULL */
+  {  258,   -1 }, /* (165) tagitem ::= NOW */
+  {  258,   -3 }, /* (166) tagitem ::= NOW PLUS VARIABLE */
+  {  258,   -3 }, /* (167) tagitem ::= NOW MINUS VARIABLE */
+  {  258,   -2 }, /* (168) tagitem ::= MINUS INTEGER */
+  {  258,   -2 }, /* (169) tagitem ::= MINUS FLOAT */
+  {  258,   -2 }, /* (170) tagitem ::= PLUS INTEGER */
+  {  258,   -2 }, /* (171) tagitem ::= PLUS FLOAT */
+  {  255,  -15 }, /* (172) select ::= SELECT selcollist from where_opt range_option interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
+  {  255,   -3 }, /* (173) select ::= LP select RP */
+  {  273,   -1 }, /* (174) union ::= select */
+  {  273,   -4 }, /* (175) union ::= union UNION ALL select */
+  {  204,   -1 }, /* (176) cmd ::= union */
+  {  255,   -2 }, /* (177) select ::= SELECT selcollist */
+  {  274,   -2 }, /* (178) sclp ::= selcollist COMMA */
+  {  274,    0 }, /* (179) sclp ::= */
+  {  259,   -4 }, /* (180) selcollist ::= sclp distinct expr as */
+  {  259,   -2 }, /* (181) selcollist ::= sclp STAR */
+  {  277,   -2 }, /* (182) as ::= AS ids */
+  {  277,   -1 }, /* (183) as ::= ids */
+  {  277,    0 }, /* (184) as ::= */
+  {  275,   -1 }, /* (185) distinct ::= DISTINCT */
+  {  275,    0 }, /* (186) distinct ::= */
+  {  260,   -2 }, /* (187) from ::= FROM tablelist */
+  {  260,   -2 }, /* (188) from ::= FROM sub */
+  {  279,   -3 }, /* (189) sub ::= LP union RP */
+  {  279,   -4 }, /* (190) sub ::= LP union RP ids */
+  {  279,   -6 }, /* (191) sub ::= sub COMMA LP union RP ids */
+  {  278,   -2 }, /* (192) tablelist ::= ids cpxName */
+  {  278,   -3 }, /* (193) tablelist ::= ids cpxName ids */
+  {  278,   -4 }, /* (194) tablelist ::= tablelist COMMA ids cpxName */
+  {  278,   -5 }, /* (195) tablelist ::= tablelist COMMA ids cpxName ids */
+  {  280,   -1 }, /* (196) tmvar ::= VARIABLE */
+  {  281,   -1 }, /* (197) timestamp ::= INTEGER */
+  {  281,   -2 }, /* (198) timestamp ::= MINUS INTEGER */
+  {  281,   -2 }, /* (199) timestamp ::= PLUS INTEGER */
+  {  281,   -1 }, /* (200) timestamp ::= STRING */
+  {  281,   -1 }, /* (201) timestamp ::= NOW */
+  {  281,   -3 }, /* (202) timestamp ::= NOW PLUS VARIABLE */
+  {  281,   -3 }, /* (203) timestamp ::= NOW MINUS VARIABLE */
+  {  262,    0 }, /* (204) range_option ::= */
+  {  262,   -6 }, /* (205) range_option ::= RANGE LP timestamp COMMA timestamp RP */
+  {  263,   -4 }, /* (206) interval_option ::= intervalKey LP tmvar RP */
+  {  263,   -6 }, /* (207) interval_option ::= intervalKey LP tmvar COMMA tmvar RP */
+  {  263,    0 }, /* (208) interval_option ::= */
+  {  282,   -1 }, /* (209) intervalKey ::= INTERVAL */
+  {  282,   -1 }, /* (210) intervalKey ::= EVERY */
+  {  265,    0 }, /* (211) session_option ::= */
+  {  265,   -7 }, /* (212) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
+  {  266,    0 }, /* (213) windowstate_option ::= */
+  {  266,   -4 }, /* (214) windowstate_option ::= STATE_WINDOW LP ids RP */
+  {  267,    0 }, /* (215) fill_opt ::= */
+  {  267,   -6 }, /* (216) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+  {  267,   -4 }, /* (217) fill_opt ::= FILL LP ID RP */
+  {  264,   -4 }, /* (218) sliding_opt ::= SLIDING LP tmvar RP */
+  {  264,    0 }, /* (219) sliding_opt ::= */
+  {  270,    0 }, /* (220) orderby_opt ::= */
+  {  270,   -3 }, /* (221) orderby_opt ::= ORDER BY sortlist */
+  {  283,   -4 }, /* (222) sortlist ::= sortlist COMMA item sortorder */
+  {  283,   -4 }, /* (223) sortlist ::= sortlist COMMA arrow sortorder */
+  {  283,   -2 }, /* (224) sortlist ::= item sortorder */
+  {  283,   -2 }, /* (225) sortlist ::= arrow sortorder */
+  {  284,   -1 }, /* (226) item ::= ID */
+  {  284,   -3 }, /* (227) item ::= ID DOT ID */
+  {  285,   -1 }, /* (228) sortorder ::= ASC */
+  {  285,   -1 }, /* (229) sortorder ::= DESC */
+  {  285,    0 }, /* (230) sortorder ::= */
+  {  268,    0 }, /* (231) groupby_opt ::= */
+  {  268,   -3 }, /* (232) groupby_opt ::= GROUP BY grouplist */
+  {  287,   -3 }, /* (233) grouplist ::= grouplist COMMA item */
+  {  287,   -3 }, /* (234) grouplist ::= grouplist COMMA arrow */
+  {  287,   -1 }, /* (235) grouplist ::= item */
+  {  287,   -1 }, /* (236) grouplist ::= arrow */
+  {  269,    0 }, /* (237) having_opt ::= */
+  {  269,   -2 }, /* (238) having_opt ::= HAVING expr */
+  {  272,    0 }, /* (239) limit_opt ::= */
+  {  272,   -2 }, /* (240) limit_opt ::= LIMIT signed */
+  {  272,   -4 }, /* (241) limit_opt ::= LIMIT signed OFFSET signed */
+  {  272,   -4 }, /* (242) limit_opt ::= LIMIT signed COMMA signed */
+  {  271,    0 }, /* (243) slimit_opt ::= */
+  {  271,   -2 }, /* (244) slimit_opt ::= SLIMIT signed */
+  {  271,   -4 }, /* (245) slimit_opt ::= SLIMIT signed SOFFSET signed */
+  {  271,   -4 }, /* (246) slimit_opt ::= SLIMIT signed COMMA signed */
+  {  261,    0 }, /* (247) where_opt ::= */
+  {  261,   -2 }, /* (248) where_opt ::= WHERE expr */
+  {  276,   -3 }, /* (249) expr ::= LP expr RP */
+  {  276,   -1 }, /* (250) expr ::= ID */
+  {  276,   -3 }, /* (251) expr ::= ID DOT ID */
+  {  276,   -3 }, /* (252) expr ::= ID DOT STAR */
+  {  276,   -1 }, /* (253) expr ::= INTEGER */
+  {  276,   -2 }, /* (254) expr ::= MINUS INTEGER */
+  {  276,   -2 }, /* (255) expr ::= PLUS INTEGER */
+  {  276,   -1 }, /* (256) expr ::= FLOAT */
+  {  276,   -2 }, /* (257) expr ::= MINUS FLOAT */
+  {  276,   -2 }, /* (258) expr ::= PLUS FLOAT */
+  {  276,   -1 }, /* (259) expr ::= STRING */
+  {  276,   -1 }, /* (260) expr ::= NOW */
+  {  276,   -1 }, /* (261) expr ::= VARIABLE */
+  {  276,   -2 }, /* (262) expr ::= PLUS VARIABLE */
+  {  276,   -2 }, /* (263) expr ::= MINUS VARIABLE */
+  {  276,   -1 }, /* (264) expr ::= BOOL */
+  {  276,   -1 }, /* (265) expr ::= NULL */
+  {  276,   -4 }, /* (266) expr ::= ID LP exprlist RP */
+  {  276,   -4 }, /* (267) expr ::= ID LP STAR RP */
+  {  276,   -6 }, /* (268) expr ::= ID LP expr AS typename RP */
+  {  276,   -3 }, /* (269) expr ::= expr IS NULL */
+  {  276,   -4 }, /* (270) expr ::= expr IS NOT NULL */
+  {  276,   -3 }, /* (271) expr ::= expr LT expr */
+  {  276,   -3 }, /* (272) expr ::= expr GT expr */
+  {  276,   -3 }, /* (273) expr ::= expr LE expr */
+  {  276,   -3 }, /* (274) expr ::= expr GE expr */
+  {  276,   -3 }, /* (275) expr ::= expr NE expr */
+  {  276,   -3 }, /* (276) expr ::= expr EQ expr */
+  {  276,   -5 }, /* (277) expr ::= expr BETWEEN expr AND expr */
+  {  276,   -3 }, /* (278) expr ::= expr AND expr */
+  {  276,   -3 }, /* (279) expr ::= expr OR expr */
+  {  276,   -3 }, /* (280) expr ::= expr PLUS expr */
+  {  276,   -3 }, /* (281) expr ::= expr MINUS expr */
+  {  276,   -3 }, /* (282) expr ::= expr STAR expr */
+  {  276,   -3 }, /* (283) expr ::= expr SLASH expr */
+  {  276,   -3 }, /* (284) expr ::= expr REM expr */
+  {  276,   -3 }, /* (285) expr ::= expr LIKE expr */
+  {  276,   -3 }, /* (286) expr ::= expr MATCH expr */
+  {  276,   -3 }, /* (287) expr ::= expr NMATCH expr */
+  {  276,   -3 }, /* (288) expr ::= ID CONTAINS STRING */
+  {  276,   -5 }, /* (289) expr ::= ID DOT ID CONTAINS STRING */
+  {  286,   -3 }, /* (290) arrow ::= ID ARROW STRING */
+  {  286,   -5 }, /* (291) arrow ::= ID DOT ID ARROW STRING */
+  {  276,   -1 }, /* (292) expr ::= arrow */
+  {  276,   -5 }, /* (293) expr ::= expr IN LP exprlist RP */
+  {  212,   -3 }, /* (294) exprlist ::= exprlist COMMA expritem */
+  {  212,   -1 }, /* (295) exprlist ::= expritem */
+  {  288,   -1 }, /* (296) expritem ::= expr */
+  {  288,    0 }, /* (297) expritem ::= */
+  {  204,   -3 }, /* (298) cmd ::= RESET QUERY CACHE */
+  {  204,   -3 }, /* (299) cmd ::= SYNCDB ids REPLICA */
+  {  204,   -7 }, /* (300) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+  {  204,   -7 }, /* (301) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+  {  204,   -7 }, /* (302) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
+  {  204,   -7 }, /* (303) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+  {  204,   -7 }, /* (304) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+  {  204,   -8 }, /* (305) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+  {  204,   -9 }, /* (306) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+  {  204,   -7 }, /* (307) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
+  {  204,   -7 }, /* (308) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
+  {  204,   -7 }, /* (309) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
+  {  204,   -7 }, /* (310) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
+  {  204,   -7 }, /* (311) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
+  {  204,   -7 }, /* (312) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
+  {  204,   -8 }, /* (313) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
+  {  204,   -9 }, /* (314) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
+  {  204,   -7 }, /* (315) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
+  {  204,   -3 }, /* (316) cmd ::= KILL CONNECTION INTEGER */
+  {  204,   -5 }, /* (317) cmd ::= KILL STREAM INTEGER COLON INTEGER */
+  {  204,   -5 }, /* (318) cmd ::= KILL QUERY INTEGER COLON INTEGER */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -2765,6 +2272,51 @@ static YYACTIONTYPE yy_reduce(
   (void)yyLookahead;
   (void)yyLookaheadToken;
   yymsp = yypParser->yytos;
+#ifndef NDEBUG
+  if( yyTraceFILE && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
+    yysize = yyRuleInfo[yyruleno].nrhs;
+    if( yysize ){
+      fprintf(yyTraceFILE, "%sReduce %d [%s], go to state %d.\n",
+        yyTracePrompt,
+        yyruleno, yyRuleName[yyruleno], yymsp[yysize].stateno);
+    }else{
+      fprintf(yyTraceFILE, "%sReduce %d [%s].\n",
+        yyTracePrompt, yyruleno, yyRuleName[yyruleno]);
+    }
+  }
+#endif /* NDEBUG */
+
+  /* Check that the stack is large enough to grow by a single entry
+  ** if the RHS of the rule is empty.  This ensures that there is room
+  ** enough on the stack to push the LHS value */
+  if( yyRuleInfo[yyruleno].nrhs==0 ){
+#ifdef YYTRACKMAXSTACKDEPTH
+    if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
+      yypParser->yyhwm++;
+      assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack));
+    }
+#endif
+#if YYSTACKDEPTH>0 
+    if( yypParser->yytos>=yypParser->yystackEnd ){
+      yyStackOverflow(yypParser);
+      /* The call to yyStackOverflow() above pops the stack until it is
+      ** empty, causing the main parser loop to exit.  So the return value
+      ** is never used and does not matter. */
+      return 0;
+    }
+#else
+    if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){
+      if( yyGrowStack(yypParser) ){
+        yyStackOverflow(yypParser);
+        /* The call to yyStackOverflow() above pops the stack until it is
+        ** empty, causing the main parser loop to exit.  So the return value
+        ** is never used and does not matter. */
+        return 0;
+      }
+      yymsp = yypParser->yytos;
+    }
+#endif
+  }
 
   switch( yyruleno ){
   /* Beginning here are the reduction cases.  A typical example
@@ -2950,16 +2502,16 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 46: /* cmd ::= ALTER DATABASE ids alter_db_optr */
       case 47: /* cmd ::= ALTER TOPIC ids alter_topic_optr */ yytestcase(yyruleno==47);
-{ SStrToken t = {0};  setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy470, &t);}
+{ SStrToken t = {0};  setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy560, &t);}
         break;
       case 48: /* cmd ::= ALTER ACCOUNT ids acct_optr */
-{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy51);}
+{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy205);}
         break;
       case 49: /* 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.yy51);}
+{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy205);}
         break;
       case 50: /* cmd ::= COMPACT VNODES IN LP exprlist RP */
-{ setCompactVnodeSql(pInfo, TSDB_SQL_COMPACT_VNODE, yymsp[-1].minor.yy189);}
+{ setCompactVnodeSql(pInfo, TSDB_SQL_COMPACT_VNODE, yymsp[-1].minor.yy209);}
         break;
       case 51: /* ids ::= ID */
       case 52: /* ids ::= STRING */ yytestcase(yyruleno==52);
@@ -2971,7 +2523,7 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 54: /* ifexists ::= */
       case 56: /* ifnotexists ::= */ yytestcase(yyruleno==56);
-      case 182: /* distinct ::= */ yytestcase(yyruleno==182);
+      case 186: /* distinct ::= */ yytestcase(yyruleno==186);
 { yymsp[1].minor.yy0.n = 0;}
         break;
       case 55: /* ifnotexists ::= IF NOT EXISTS */
@@ -2981,17 +2533,17 @@ static YYACTIONTYPE yy_reduce(
 { setDCLSqlElems(pInfo, TSDB_SQL_CREATE_DNODE, 1, &yymsp[0].minor.yy0);}
         break;
       case 58: /* 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.yy51);}
+{ setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy205);}
         break;
       case 59: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */
       case 60: /* cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ yytestcase(yyruleno==60);
-{ setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy470, &yymsp[-2].minor.yy0);}
+{ setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy560, &yymsp[-2].minor.yy0);}
         break;
       case 61: /* cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
-{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy279, &yymsp[0].minor.yy0, 1);}
+{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy369, &yymsp[0].minor.yy0, 1);}
         break;
       case 62: /* cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
-{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy279, &yymsp[0].minor.yy0, 2);}
+{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy369, &yymsp[0].minor.yy0, 2);}
         break;
       case 63: /* cmd ::= CREATE USER ids PASS ids */
 { setCreateUserSql(pInfo, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);}
@@ -3022,38 +2574,38 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 84: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */
 {
-    yylhsminor.yy51.maxUsers   = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
-    yylhsminor.yy51.maxDbs     = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
-    yylhsminor.yy51.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
-    yylhsminor.yy51.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
-    yylhsminor.yy51.maxPointsPerSecond     = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
-    yylhsminor.yy51.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
-    yylhsminor.yy51.maxQueryTime   = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
-    yylhsminor.yy51.maxConnections   = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
-    yylhsminor.yy51.stat    = yymsp[0].minor.yy0;
+    yylhsminor.yy205.maxUsers   = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
+    yylhsminor.yy205.maxDbs     = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
+    yylhsminor.yy205.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
+    yylhsminor.yy205.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
+    yylhsminor.yy205.maxPointsPerSecond     = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
+    yylhsminor.yy205.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
+    yylhsminor.yy205.maxQueryTime   = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
+    yylhsminor.yy205.maxConnections   = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
+    yylhsminor.yy205.stat    = yymsp[0].minor.yy0;
 }
-  yymsp[-8].minor.yy51 = yylhsminor.yy51;
+  yymsp[-8].minor.yy205 = yylhsminor.yy205;
         break;
       case 85: /* intitemlist ::= intitemlist COMMA intitem */
-      case 154: /* tagitemlist ::= tagitemlist COMMA tagitem */ yytestcase(yyruleno==154);
-{ yylhsminor.yy189 = tVariantListAppend(yymsp[-2].minor.yy189, &yymsp[0].minor.yy162, -1);    }
-  yymsp[-2].minor.yy189 = yylhsminor.yy189;
+      case 158: /* tagitemlist ::= tagitemlist COMMA tagitem */ yytestcase(yyruleno==158);
+{ yylhsminor.yy209 = tVariantListAppend(yymsp[-2].minor.yy209, &yymsp[0].minor.yy54, -1);    }
+  yymsp[-2].minor.yy209 = yylhsminor.yy209;
         break;
       case 86: /* intitemlist ::= intitem */
-      case 155: /* tagitemlist ::= tagitem */ yytestcase(yyruleno==155);
-{ yylhsminor.yy189 = tVariantListAppend(NULL, &yymsp[0].minor.yy162, -1); }
-  yymsp[0].minor.yy189 = yylhsminor.yy189;
+      case 159: /* tagitemlist ::= tagitem */ yytestcase(yyruleno==159);
+{ yylhsminor.yy209 = tVariantListAppend(NULL, &yymsp[0].minor.yy54, -1); }
+  yymsp[0].minor.yy209 = yylhsminor.yy209;
         break;
       case 87: /* intitem ::= INTEGER */
-      case 156: /* tagitem ::= INTEGER */ yytestcase(yyruleno==156);
-      case 157: /* tagitem ::= FLOAT */ yytestcase(yyruleno==157);
-      case 158: /* tagitem ::= STRING */ yytestcase(yyruleno==158);
-      case 159: /* tagitem ::= BOOL */ yytestcase(yyruleno==159);
-{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy162, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy162 = yylhsminor.yy162;
+      case 160: /* tagitem ::= INTEGER */ yytestcase(yyruleno==160);
+      case 161: /* tagitem ::= FLOAT */ yytestcase(yyruleno==161);
+      case 162: /* tagitem ::= STRING */ yytestcase(yyruleno==162);
+      case 163: /* tagitem ::= BOOL */ yytestcase(yyruleno==163);
+{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy54, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy54 = yylhsminor.yy54;
         break;
       case 88: /* keep ::= KEEP intitemlist */
-{ yymsp[-1].minor.yy189 = yymsp[0].minor.yy189; }
+{ yymsp[-1].minor.yy209 = yymsp[0].minor.yy209; }
         break;
       case 89: /* cache ::= CACHE INTEGER */
       case 90: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==90);
@@ -3073,744 +2625,758 @@ static YYACTIONTYPE yy_reduce(
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
         break;
       case 104: /* db_optr ::= */
-{setDefaultCreateDbOption(&yymsp[1].minor.yy470); yymsp[1].minor.yy470.dbType = TSDB_DB_TYPE_DEFAULT;}
+{setDefaultCreateDbOption(&yymsp[1].minor.yy560); yymsp[1].minor.yy560.dbType = TSDB_DB_TYPE_DEFAULT;}
         break;
       case 105: /* db_optr ::= db_optr cache */
-{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy470 = yylhsminor.yy470;
+{ yylhsminor.yy560 = yymsp[-1].minor.yy560; yylhsminor.yy560.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
       case 106: /* db_optr ::= db_optr replica */
       case 123: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==123);
-{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy470 = yylhsminor.yy470;
+{ yylhsminor.yy560 = yymsp[-1].minor.yy560; yylhsminor.yy560.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
       case 107: /* db_optr ::= db_optr quorum */
       case 124: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==124);
-{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy470 = yylhsminor.yy470;
+{ yylhsminor.yy560 = yymsp[-1].minor.yy560; yylhsminor.yy560.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
       case 108: /* db_optr ::= db_optr days */
-{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy470 = yylhsminor.yy470;
+{ yylhsminor.yy560 = yymsp[-1].minor.yy560; yylhsminor.yy560.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
       case 109: /* db_optr ::= db_optr minrows */
-{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
-  yymsp[-1].minor.yy470 = yylhsminor.yy470;
+{ yylhsminor.yy560 = yymsp[-1].minor.yy560; yylhsminor.yy560.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+  yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
       case 110: /* db_optr ::= db_optr maxrows */
-{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
-  yymsp[-1].minor.yy470 = yylhsminor.yy470;
+{ yylhsminor.yy560 = yymsp[-1].minor.yy560; yylhsminor.yy560.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+  yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
       case 111: /* db_optr ::= db_optr blocks */
       case 126: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==126);
-{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy470 = yylhsminor.yy470;
+{ yylhsminor.yy560 = yymsp[-1].minor.yy560; yylhsminor.yy560.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
       case 112: /* db_optr ::= db_optr ctime */
-{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy470 = yylhsminor.yy470;
+{ yylhsminor.yy560 = yymsp[-1].minor.yy560; yylhsminor.yy560.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
       case 113: /* db_optr ::= db_optr wal */
-{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy470 = yylhsminor.yy470;
+{ yylhsminor.yy560 = yymsp[-1].minor.yy560; yylhsminor.yy560.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
       case 114: /* db_optr ::= db_optr fsync */
-{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy470 = yylhsminor.yy470;
+{ yylhsminor.yy560 = yymsp[-1].minor.yy560; yylhsminor.yy560.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
       case 115: /* db_optr ::= db_optr comp */
       case 127: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==127);
-{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy470 = yylhsminor.yy470;
+{ yylhsminor.yy560 = yymsp[-1].minor.yy560; yylhsminor.yy560.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
       case 116: /* db_optr ::= db_optr prec */
-{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.precision = yymsp[0].minor.yy0; }
-  yymsp[-1].minor.yy470 = yylhsminor.yy470;
+{ yylhsminor.yy560 = yymsp[-1].minor.yy560; yylhsminor.yy560.precision = yymsp[0].minor.yy0; }
+  yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
       case 117: /* db_optr ::= db_optr keep */
       case 125: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==125);
-{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.keep = yymsp[0].minor.yy189; }
-  yymsp[-1].minor.yy470 = yylhsminor.yy470;
+{ yylhsminor.yy560 = yymsp[-1].minor.yy560; yylhsminor.yy560.keep = yymsp[0].minor.yy209; }
+  yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
       case 118: /* db_optr ::= db_optr update */
       case 128: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==128);
-{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy470 = yylhsminor.yy470;
+{ yylhsminor.yy560 = yymsp[-1].minor.yy560; yylhsminor.yy560.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
       case 119: /* db_optr ::= db_optr cachelast */
       case 129: /* alter_db_optr ::= alter_db_optr cachelast */ yytestcase(yyruleno==129);
-{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy470 = yylhsminor.yy470;
+{ yylhsminor.yy560 = yymsp[-1].minor.yy560; yylhsminor.yy560.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
       case 120: /* topic_optr ::= db_optr */
       case 130: /* alter_topic_optr ::= alter_db_optr */ yytestcase(yyruleno==130);
-{ yylhsminor.yy470 = yymsp[0].minor.yy470; yylhsminor.yy470.dbType = TSDB_DB_TYPE_TOPIC; }
-  yymsp[0].minor.yy470 = yylhsminor.yy470;
+{ yylhsminor.yy560 = yymsp[0].minor.yy560; yylhsminor.yy560.dbType = TSDB_DB_TYPE_TOPIC; }
+  yymsp[0].minor.yy560 = yylhsminor.yy560;
         break;
       case 121: /* topic_optr ::= topic_optr partitions */
       case 131: /* alter_topic_optr ::= alter_topic_optr partitions */ yytestcase(yyruleno==131);
-{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.partitions = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy470 = yylhsminor.yy470;
+{ yylhsminor.yy560 = yymsp[-1].minor.yy560; yylhsminor.yy560.partitions = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy560 = yylhsminor.yy560;
         break;
       case 122: /* alter_db_optr ::= */
-{ setDefaultCreateDbOption(&yymsp[1].minor.yy470); yymsp[1].minor.yy470.dbType = TSDB_DB_TYPE_DEFAULT;}
+{ setDefaultCreateDbOption(&yymsp[1].minor.yy560); yymsp[1].minor.yy560.dbType = TSDB_DB_TYPE_DEFAULT;}
         break;
       case 132: /* typename ::= ids */
 {
   yymsp[0].minor.yy0.type = 0;
-  tSetColumnType (&yylhsminor.yy279, &yymsp[0].minor.yy0);
+  tSetColumnType (&yylhsminor.yy369, &yymsp[0].minor.yy0);
 }
-  yymsp[0].minor.yy279 = yylhsminor.yy279;
+  yymsp[0].minor.yy369 = yylhsminor.yy369;
         break;
       case 133: /* typename ::= ids LP signed RP */
 {
-  if (yymsp[-1].minor.yy69 <= 0) {
+  if (yymsp[-1].minor.yy55 <= 0) {
     yymsp[-3].minor.yy0.type = 0;
-    tSetColumnType(&yylhsminor.yy279, &yymsp[-3].minor.yy0);
+    tSetColumnType(&yylhsminor.yy369, &yymsp[-3].minor.yy0);
   } else {
-    yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy69;  // negative value of name length
-    tSetColumnType(&yylhsminor.yy279, &yymsp[-3].minor.yy0);
+    yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy55;  // negative value of name length
+    tSetColumnType(&yylhsminor.yy369, &yymsp[-3].minor.yy0);
   }
 }
-  yymsp[-3].minor.yy279 = yylhsminor.yy279;
+  yymsp[-3].minor.yy369 = yylhsminor.yy369;
         break;
       case 134: /* typename ::= ids UNSIGNED */
 {
   yymsp[-1].minor.yy0.type = 0;
   yymsp[-1].minor.yy0.n = ((yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z);
-  tSetColumnType (&yylhsminor.yy279, &yymsp[-1].minor.yy0);
+  tSetColumnType (&yylhsminor.yy369, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy279 = yylhsminor.yy279;
+  yymsp[-1].minor.yy369 = yylhsminor.yy369;
         break;
       case 135: /* signed ::= INTEGER */
-{ yylhsminor.yy69 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[0].minor.yy69 = yylhsminor.yy69;
+{ yylhsminor.yy55 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[0].minor.yy55 = yylhsminor.yy55;
         break;
       case 136: /* signed ::= PLUS INTEGER */
-{ yymsp[-1].minor.yy69 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+{ yymsp[-1].minor.yy55 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
         break;
       case 137: /* signed ::= MINUS INTEGER */
-{ yymsp[-1].minor.yy69 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
+{ yymsp[-1].minor.yy55 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
         break;
       case 141: /* cmd ::= CREATE TABLE create_table_list */
-{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy6;}
+{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy404;}
         break;
       case 142: /* create_table_list ::= create_from_stable */
 {
   SCreateTableSql* pCreateTable = calloc(1, sizeof(SCreateTableSql));
   pCreateTable->childTableInfo = taosArrayInit(4, sizeof(SCreatedTableInfo));
 
-  taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy208);
+  taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy34);
   pCreateTable->type = TSQL_CREATE_TABLE_FROM_STABLE;
-  yylhsminor.yy6 = pCreateTable;
+  yylhsminor.yy404 = pCreateTable;
 }
-  yymsp[0].minor.yy6 = yylhsminor.yy6;
+  yymsp[0].minor.yy404 = yylhsminor.yy404;
         break;
       case 143: /* create_table_list ::= create_table_list create_from_stable */
 {
-  taosArrayPush(yymsp[-1].minor.yy6->childTableInfo, &yymsp[0].minor.yy208);
-  yylhsminor.yy6 = yymsp[-1].minor.yy6;
+  taosArrayPush(yymsp[-1].minor.yy404->childTableInfo, &yymsp[0].minor.yy34);
+  yylhsminor.yy404 = yymsp[-1].minor.yy404;
 }
-  yymsp[-1].minor.yy6 = yylhsminor.yy6;
+  yymsp[-1].minor.yy404 = yylhsminor.yy404;
         break;
       case 144: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
 {
-  yylhsminor.yy6 = tSetCreateTableInfo(yymsp[-1].minor.yy189, NULL, NULL, TSQL_CREATE_TABLE);
-  setSqlInfo(pInfo, yylhsminor.yy6, NULL, TSDB_SQL_CREATE_TABLE);
+  yylhsminor.yy404 = tSetCreateTableInfo(yymsp[-1].minor.yy209, NULL, NULL, TSQL_CREATE_TABLE);
+  setSqlInfo(pInfo, yylhsminor.yy404, 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.yy6 = yylhsminor.yy6;
+  yymsp[-5].minor.yy404 = yylhsminor.yy404;
         break;
       case 145: /* create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
 {
-  yylhsminor.yy6 = tSetCreateTableInfo(yymsp[-5].minor.yy189, yymsp[-1].minor.yy189, NULL, TSQL_CREATE_STABLE);
-  setSqlInfo(pInfo, yylhsminor.yy6, NULL, TSDB_SQL_CREATE_TABLE);
+  yylhsminor.yy404 = tSetCreateTableInfo(yymsp[-5].minor.yy209, yymsp[-1].minor.yy209, NULL, TSQL_CREATE_STABLE);
+  setSqlInfo(pInfo, yylhsminor.yy404, 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.yy6 = yylhsminor.yy6;
+  yymsp[-9].minor.yy404 = yylhsminor.yy404;
         break;
       case 146: /* 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.yy208 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy189, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
+  yylhsminor.yy34 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy209, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
 }
-  yymsp[-9].minor.yy208 = yylhsminor.yy208;
+  yymsp[-9].minor.yy34 = yylhsminor.yy34;
         break;
       case 147: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
 {
   yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
   yymsp[-11].minor.yy0.n += yymsp[-10].minor.yy0.n;
-  yylhsminor.yy208 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy189, yymsp[-1].minor.yy189, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0);
+  yylhsminor.yy34 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy209, yymsp[-1].minor.yy209, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0);
 }
-  yymsp[-12].minor.yy208 = yylhsminor.yy208;
+  yymsp[-12].minor.yy34 = yylhsminor.yy34;
         break;
       case 148: /* tagNamelist ::= tagNamelist COMMA ids */
-{taosArrayPush(yymsp[-2].minor.yy189, &yymsp[0].minor.yy0); yylhsminor.yy189 = yymsp[-2].minor.yy189;  }
-  yymsp[-2].minor.yy189 = yylhsminor.yy189;
+{taosArrayPush(yymsp[-2].minor.yy209, &yymsp[0].minor.yy0); yylhsminor.yy209 = yymsp[-2].minor.yy209;  }
+  yymsp[-2].minor.yy209 = yylhsminor.yy209;
         break;
       case 149: /* tagNamelist ::= ids */
-{yylhsminor.yy189 = taosArrayInit(4, sizeof(SStrToken)); taosArrayPush(yylhsminor.yy189, &yymsp[0].minor.yy0);}
-  yymsp[0].minor.yy189 = yylhsminor.yy189;
+{yylhsminor.yy209 = taosArrayInit(4, sizeof(SStrToken)); taosArrayPush(yylhsminor.yy209, &yymsp[0].minor.yy0);}
+  yymsp[0].minor.yy209 = yylhsminor.yy209;
         break;
-      case 150: /* create_table_args ::= ifnotexists ids cpxName AS select */
+      case 150: /* create_table_args ::= ifnotexists ids cpxName to_opt split_opt AS select */
 {
-  yylhsminor.yy6 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy16, TSQL_CREATE_STREAM);
-  setSqlInfo(pInfo, yylhsminor.yy6, NULL, TSDB_SQL_CREATE_TABLE);
+  yylhsminor.yy404 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy160, TSQL_CREATE_STREAM);
+  setSqlInfo(pInfo, yylhsminor.yy404, 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);
+  setCreatedStreamOpt(pInfo, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0);
+  yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
+  setCreatedTableName(pInfo, &yymsp[-5].minor.yy0, &yymsp[-6].minor.yy0);
 }
-  yymsp[-4].minor.yy6 = yylhsminor.yy6;
+  yymsp[-6].minor.yy404 = yylhsminor.yy404;
+        break;
+      case 151: /* to_opt ::= */
+      case 153: /* split_opt ::= */ yytestcase(yyruleno==153);
+{yymsp[1].minor.yy0.n = 0;}
         break;
-      case 151: /* columnlist ::= columnlist COMMA column */
-{taosArrayPush(yymsp[-2].minor.yy189, &yymsp[0].minor.yy279); yylhsminor.yy189 = yymsp[-2].minor.yy189;  }
-  yymsp[-2].minor.yy189 = yylhsminor.yy189;
+      case 152: /* to_opt ::= TO ids cpxName */
+{
+   yymsp[-2].minor.yy0 = yymsp[-1].minor.yy0;
+   yymsp[-2].minor.yy0.n += yymsp[0].minor.yy0.n;
+}
         break;
-      case 152: /* columnlist ::= column */
-{yylhsminor.yy189 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy189, &yymsp[0].minor.yy279);}
-  yymsp[0].minor.yy189 = yylhsminor.yy189;
+      case 154: /* split_opt ::= SPLIT ids */
+{ yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;}
         break;
-      case 153: /* column ::= ids typename */
+      case 155: /* columnlist ::= columnlist COMMA column */
+{taosArrayPush(yymsp[-2].minor.yy209, &yymsp[0].minor.yy369); yylhsminor.yy209 = yymsp[-2].minor.yy209;  }
+  yymsp[-2].minor.yy209 = yylhsminor.yy209;
+        break;
+      case 156: /* columnlist ::= column */
+{yylhsminor.yy209 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy209, &yymsp[0].minor.yy369);}
+  yymsp[0].minor.yy209 = yylhsminor.yy209;
+        break;
+      case 157: /* column ::= ids typename */
 {
-  tSetColumnInfo(&yylhsminor.yy279, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy279);
+  tSetColumnInfo(&yylhsminor.yy369, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy369);
 }
-  yymsp[-1].minor.yy279 = yylhsminor.yy279;
+  yymsp[-1].minor.yy369 = yylhsminor.yy369;
         break;
-      case 160: /* tagitem ::= NULL */
-{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy162, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy162 = yylhsminor.yy162;
+      case 164: /* tagitem ::= NULL */
+{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy54, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy54 = yylhsminor.yy54;
         break;
-      case 161: /* tagitem ::= NOW */
-{ yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP; tVariantCreateExt(&yylhsminor.yy162, &yymsp[0].minor.yy0, TK_NOW, true);}
-  yymsp[0].minor.yy162 = yylhsminor.yy162;
+      case 165: /* tagitem ::= NOW */
+{ yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP; tVariantCreateExt(&yylhsminor.yy54, &yymsp[0].minor.yy0, TK_NOW, true);}
+  yymsp[0].minor.yy54 = yylhsminor.yy54;
         break;
-      case 162: /* tagitem ::= NOW PLUS VARIABLE */
+      case 166: /* tagitem ::= NOW PLUS VARIABLE */
 {
     yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP;
-    tVariantCreateExt(&yymsp[-2].minor.yy162, &yymsp[0].minor.yy0, TK_PLUS, true);
+    tVariantCreateExt(&yymsp[-2].minor.yy54, &yymsp[0].minor.yy0, TK_PLUS, true);
 }
         break;
-      case 163: /* tagitem ::= NOW MINUS VARIABLE */
+      case 167: /* tagitem ::= NOW MINUS VARIABLE */
 {
     yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP;
-    tVariantCreateExt(&yymsp[-2].minor.yy162, &yymsp[0].minor.yy0, TK_MINUS, true);
+    tVariantCreateExt(&yymsp[-2].minor.yy54, &yymsp[0].minor.yy0, TK_MINUS, true);
 }
         break;
-      case 164: /* tagitem ::= MINUS INTEGER */
-      case 165: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==165);
-      case 166: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==166);
-      case 167: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==167);
+      case 168: /* tagitem ::= MINUS INTEGER */
+      case 169: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==169);
+      case 170: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==170);
+      case 171: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==171);
 {
     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.yy162, &yymsp[-1].minor.yy0);
+    tVariantCreate(&yylhsminor.yy54, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy162 = yylhsminor.yy162;
+  yymsp[-1].minor.yy54 = yylhsminor.yy54;
         break;
-      case 168: /* select ::= SELECT selcollist from where_opt range_option interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
+      case 172: /* select ::= SELECT selcollist from where_opt range_option interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
 {
-  yylhsminor.yy16 = tSetQuerySqlNode(&yymsp[-14].minor.yy0, yymsp[-13].minor.yy189, yymsp[-12].minor.yy36, yymsp[-11].minor.yy18, yymsp[-4].minor.yy189, yymsp[-2].minor.yy189, &yymsp[-9].minor.yy32, &yymsp[-7].minor.yy155, &yymsp[-6].minor.yy336, &yymsp[-8].minor.yy0, yymsp[-5].minor.yy189, &yymsp[0].minor.yy38, &yymsp[-1].minor.yy38, yymsp[-3].minor.yy18, &yymsp[-10].minor.yy124);
+  yylhsminor.yy160 = tSetQuerySqlNode(&yymsp[-14].minor.yy0, yymsp[-13].minor.yy209, yymsp[-12].minor.yy530, yymsp[-11].minor.yy574, yymsp[-4].minor.yy209, yymsp[-2].minor.yy209, &yymsp[-9].minor.yy102, &yymsp[-7].minor.yy115, &yymsp[-6].minor.yy290, &yymsp[-8].minor.yy0, yymsp[-5].minor.yy209, &yymsp[0].minor.yy534, &yymsp[-1].minor.yy534, yymsp[-3].minor.yy574, &yymsp[-10].minor.yy22);
 }
-  yymsp[-14].minor.yy16 = yylhsminor.yy16;
+  yymsp[-14].minor.yy160 = yylhsminor.yy160;
         break;
-      case 169: /* select ::= LP select RP */
-{yymsp[-2].minor.yy16 = yymsp[-1].minor.yy16;}
+      case 173: /* select ::= LP select RP */
+{yymsp[-2].minor.yy160 = yymsp[-1].minor.yy160;}
         break;
-      case 170: /* union ::= select */
-{ yylhsminor.yy189 = setSubclause(NULL, yymsp[0].minor.yy16); }
-  yymsp[0].minor.yy189 = yylhsminor.yy189;
+      case 174: /* union ::= select */
+{ yylhsminor.yy209 = setSubclause(NULL, yymsp[0].minor.yy160); }
+  yymsp[0].minor.yy209 = yylhsminor.yy209;
         break;
-      case 171: /* union ::= union UNION ALL select */
-{ yylhsminor.yy189 = appendSelectClause(yymsp[-3].minor.yy189, yymsp[0].minor.yy16); }
-  yymsp[-3].minor.yy189 = yylhsminor.yy189;
+      case 175: /* union ::= union UNION ALL select */
+{ yylhsminor.yy209 = appendSelectClause(yymsp[-3].minor.yy209, yymsp[0].minor.yy160); }
+  yymsp[-3].minor.yy209 = yylhsminor.yy209;
         break;
-      case 172: /* cmd ::= union */
-{ setSqlInfo(pInfo, yymsp[0].minor.yy189, NULL, TSDB_SQL_SELECT); }
+      case 176: /* cmd ::= union */
+{ setSqlInfo(pInfo, yymsp[0].minor.yy209, NULL, TSDB_SQL_SELECT); }
         break;
-      case 173: /* select ::= SELECT selcollist */
+      case 177: /* select ::= SELECT selcollist */
 {
-  yylhsminor.yy16 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy189, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+  yylhsminor.yy160 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy209, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
-  yymsp[-1].minor.yy16 = yylhsminor.yy16;
+  yymsp[-1].minor.yy160 = yylhsminor.yy160;
         break;
-      case 174: /* sclp ::= selcollist COMMA */
-{yylhsminor.yy189 = yymsp[-1].minor.yy189;}
-  yymsp[-1].minor.yy189 = yylhsminor.yy189;
+      case 178: /* sclp ::= selcollist COMMA */
+{yylhsminor.yy209 = yymsp[-1].minor.yy209;}
+  yymsp[-1].minor.yy209 = yylhsminor.yy209;
         break;
-      case 175: /* sclp ::= */
-      case 216: /* orderby_opt ::= */ yytestcase(yyruleno==216);
-{yymsp[1].minor.yy189 = 0;}
+      case 179: /* sclp ::= */
+      case 220: /* orderby_opt ::= */ yytestcase(yyruleno==220);
+{yymsp[1].minor.yy209 = 0;}
         break;
-      case 176: /* selcollist ::= sclp distinct expr as */
+      case 180: /* selcollist ::= sclp distinct expr as */
 {
-   yylhsminor.yy189 = tSqlExprListAppend(yymsp[-3].minor.yy189, yymsp[-1].minor.yy18,  yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
+   yylhsminor.yy209 = tSqlExprListAppend(yymsp[-3].minor.yy209, yymsp[-1].minor.yy574,  yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
 }
-  yymsp[-3].minor.yy189 = yylhsminor.yy189;
+  yymsp[-3].minor.yy209 = yylhsminor.yy209;
         break;
-      case 177: /* selcollist ::= sclp STAR */
+      case 181: /* selcollist ::= sclp STAR */
 {
    tSqlExpr *pNode = tSqlExprCreateIdValue(pInfo, NULL, TK_ALL);
-   yylhsminor.yy189 = tSqlExprListAppend(yymsp[-1].minor.yy189, pNode, 0, 0);
+   yylhsminor.yy209 = tSqlExprListAppend(yymsp[-1].minor.yy209, pNode, 0, 0);
 }
-  yymsp[-1].minor.yy189 = yylhsminor.yy189;
+  yymsp[-1].minor.yy209 = yylhsminor.yy209;
         break;
-      case 178: /* as ::= AS ids */
+      case 182: /* as ::= AS ids */
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;    }
         break;
-      case 179: /* as ::= ids */
+      case 183: /* as ::= ids */
 { yylhsminor.yy0 = yymsp[0].minor.yy0;    }
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 180: /* as ::= */
+      case 184: /* as ::= */
 { yymsp[1].minor.yy0.n = 0;  }
         break;
-      case 181: /* distinct ::= DISTINCT */
+      case 185: /* distinct ::= DISTINCT */
 { yylhsminor.yy0 = yymsp[0].minor.yy0;  }
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 183: /* from ::= FROM tablelist */
-      case 184: /* from ::= FROM sub */ yytestcase(yyruleno==184);
-{yymsp[-1].minor.yy36 = yymsp[0].minor.yy36;}
+      case 187: /* from ::= FROM tablelist */
+      case 188: /* from ::= FROM sub */ yytestcase(yyruleno==188);
+{yymsp[-1].minor.yy530 = yymsp[0].minor.yy530;}
         break;
-      case 185: /* sub ::= LP union RP */
-{yymsp[-2].minor.yy36 = addSubqueryElem(NULL, yymsp[-1].minor.yy189, NULL);}
+      case 189: /* sub ::= LP union RP */
+{yymsp[-2].minor.yy530 = addSubqueryElem(NULL, yymsp[-1].minor.yy209, NULL);}
         break;
-      case 186: /* sub ::= LP union RP ids */
-{yymsp[-3].minor.yy36 = addSubqueryElem(NULL, yymsp[-2].minor.yy189, &yymsp[0].minor.yy0);}
+      case 190: /* sub ::= LP union RP ids */
+{yymsp[-3].minor.yy530 = addSubqueryElem(NULL, yymsp[-2].minor.yy209, &yymsp[0].minor.yy0);}
         break;
-      case 187: /* sub ::= sub COMMA LP union RP ids */
-{yylhsminor.yy36 = addSubqueryElem(yymsp[-5].minor.yy36, yymsp[-2].minor.yy189, &yymsp[0].minor.yy0);}
-  yymsp[-5].minor.yy36 = yylhsminor.yy36;
+      case 191: /* sub ::= sub COMMA LP union RP ids */
+{yylhsminor.yy530 = addSubqueryElem(yymsp[-5].minor.yy530, yymsp[-2].minor.yy209, &yymsp[0].minor.yy0);}
+  yymsp[-5].minor.yy530 = yylhsminor.yy530;
         break;
-      case 188: /* tablelist ::= ids cpxName */
+      case 192: /* tablelist ::= ids cpxName */
 {
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
-  yylhsminor.yy36 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL);
+  yylhsminor.yy530 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL);
 }
-  yymsp[-1].minor.yy36 = yylhsminor.yy36;
+  yymsp[-1].minor.yy530 = yylhsminor.yy530;
         break;
-      case 189: /* tablelist ::= ids cpxName ids */
+      case 193: /* tablelist ::= ids cpxName ids */
 {
   yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
-  yylhsminor.yy36 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
+  yylhsminor.yy530 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
 }
-  yymsp[-2].minor.yy36 = yylhsminor.yy36;
+  yymsp[-2].minor.yy530 = yylhsminor.yy530;
         break;
-      case 190: /* tablelist ::= tablelist COMMA ids cpxName */
+      case 194: /* tablelist ::= tablelist COMMA ids cpxName */
 {
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
-  yylhsminor.yy36 = setTableNameList(yymsp[-3].minor.yy36, &yymsp[-1].minor.yy0, NULL);
+  yylhsminor.yy530 = setTableNameList(yymsp[-3].minor.yy530, &yymsp[-1].minor.yy0, NULL);
 }
-  yymsp[-3].minor.yy36 = yylhsminor.yy36;
+  yymsp[-3].minor.yy530 = yylhsminor.yy530;
         break;
-      case 191: /* tablelist ::= tablelist COMMA ids cpxName ids */
+      case 195: /* tablelist ::= tablelist COMMA ids cpxName ids */
 {
   yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
-  yylhsminor.yy36 = setTableNameList(yymsp[-4].minor.yy36, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
+  yylhsminor.yy530 = setTableNameList(yymsp[-4].minor.yy530, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
 }
-  yymsp[-4].minor.yy36 = yylhsminor.yy36;
+  yymsp[-4].minor.yy530 = yylhsminor.yy530;
         break;
-      case 192: /* tmvar ::= VARIABLE */
+      case 196: /* tmvar ::= VARIABLE */
 {yylhsminor.yy0 = yymsp[0].minor.yy0;}
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 193: /* timestamp ::= INTEGER */
-{ yylhsminor.yy18 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_INTEGER);}
-  yymsp[0].minor.yy18 = yylhsminor.yy18;
+      case 197: /* timestamp ::= INTEGER */
+{ yylhsminor.yy574 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_INTEGER);}
+  yymsp[0].minor.yy574 = yylhsminor.yy574;
         break;
-      case 194: /* timestamp ::= MINUS INTEGER */
-      case 195: /* timestamp ::= PLUS INTEGER */ yytestcase(yyruleno==195);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy18 = tSqlExprCreateTimestamp(&yymsp[-1].minor.yy0, TK_INTEGER);}
-  yymsp[-1].minor.yy18 = yylhsminor.yy18;
+      case 198: /* timestamp ::= MINUS INTEGER */
+      case 199: /* timestamp ::= PLUS INTEGER */ yytestcase(yyruleno==199);
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy574 = tSqlExprCreateTimestamp(&yymsp[-1].minor.yy0, TK_INTEGER);}
+  yymsp[-1].minor.yy574 = yylhsminor.yy574;
         break;
-      case 196: /* timestamp ::= STRING */
-{ yylhsminor.yy18 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_STRING);}
-  yymsp[0].minor.yy18 = yylhsminor.yy18;
+      case 200: /* timestamp ::= STRING */
+{ yylhsminor.yy574 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_STRING);}
+  yymsp[0].minor.yy574 = yylhsminor.yy574;
         break;
-      case 197: /* timestamp ::= NOW */
-{ yylhsminor.yy18 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_NOW); }
-  yymsp[0].minor.yy18 = yylhsminor.yy18;
+      case 201: /* timestamp ::= NOW */
+{ yylhsminor.yy574 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_NOW); }
+  yymsp[0].minor.yy574 = yylhsminor.yy574;
         break;
-      case 198: /* timestamp ::= NOW PLUS VARIABLE */
-{yymsp[-2].minor.yy18 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_PLUS);  }
+      case 202: /* timestamp ::= NOW PLUS VARIABLE */
+{yymsp[-2].minor.yy574 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_PLUS);  }
         break;
-      case 199: /* timestamp ::= NOW MINUS VARIABLE */
-{yymsp[-2].minor.yy18 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_MINUS); }
+      case 203: /* timestamp ::= NOW MINUS VARIABLE */
+{yymsp[-2].minor.yy574 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_MINUS); }
         break;
-      case 200: /* range_option ::= */
-{yymsp[1].minor.yy124.start = 0; yymsp[1].minor.yy124.end = 0;}
+      case 204: /* range_option ::= */
+{yymsp[1].minor.yy22.start = 0; yymsp[1].minor.yy22.end = 0;}
         break;
-      case 201: /* range_option ::= RANGE LP timestamp COMMA timestamp RP */
-{yymsp[-5].minor.yy124.start = yymsp[-3].minor.yy18; yymsp[-5].minor.yy124.end = yymsp[-1].minor.yy18;}
+      case 205: /* range_option ::= RANGE LP timestamp COMMA timestamp RP */
+{yymsp[-5].minor.yy22.start = yymsp[-3].minor.yy574; yymsp[-5].minor.yy22.end = yymsp[-1].minor.yy574;}
         break;
-      case 202: /* interval_option ::= intervalKey LP tmvar RP */
-{yylhsminor.yy32.interval = yymsp[-1].minor.yy0; yylhsminor.yy32.offset.n = 0; yylhsminor.yy32.token = yymsp[-3].minor.yy516;}
-  yymsp[-3].minor.yy32 = yylhsminor.yy32;
+      case 206: /* interval_option ::= intervalKey LP tmvar RP */
+{yylhsminor.yy102.interval = yymsp[-1].minor.yy0; yylhsminor.yy102.offset.n = 0; yylhsminor.yy102.token = yymsp[-3].minor.yy380;}
+  yymsp[-3].minor.yy102 = yylhsminor.yy102;
         break;
-      case 203: /* interval_option ::= intervalKey LP tmvar COMMA tmvar RP */
-{yylhsminor.yy32.interval = yymsp[-3].minor.yy0; yylhsminor.yy32.offset = yymsp[-1].minor.yy0;   yylhsminor.yy32.token = yymsp[-5].minor.yy516;}
-  yymsp[-5].minor.yy32 = yylhsminor.yy32;
+      case 207: /* interval_option ::= intervalKey LP tmvar COMMA tmvar RP */
+{yylhsminor.yy102.interval = yymsp[-3].minor.yy0; yylhsminor.yy102.offset = yymsp[-1].minor.yy0;   yylhsminor.yy102.token = yymsp[-5].minor.yy380;}
+  yymsp[-5].minor.yy102 = yylhsminor.yy102;
         break;
-      case 204: /* interval_option ::= */
-{memset(&yymsp[1].minor.yy32, 0, sizeof(yymsp[1].minor.yy32));}
+      case 208: /* interval_option ::= */
+{memset(&yymsp[1].minor.yy102, 0, sizeof(yymsp[1].minor.yy102));}
         break;
-      case 205: /* intervalKey ::= INTERVAL */
-{yymsp[0].minor.yy516 = TK_INTERVAL;}
+      case 209: /* intervalKey ::= INTERVAL */
+{yymsp[0].minor.yy380 = TK_INTERVAL;}
         break;
-      case 206: /* intervalKey ::= EVERY */
-{yymsp[0].minor.yy516 = TK_EVERY;   }
+      case 210: /* intervalKey ::= EVERY */
+{yymsp[0].minor.yy380 = TK_EVERY;   }
         break;
-      case 207: /* session_option ::= */
-{yymsp[1].minor.yy155.col.n = 0; yymsp[1].minor.yy155.gap.n = 0;}
+      case 211: /* session_option ::= */
+{yymsp[1].minor.yy115.col.n = 0; yymsp[1].minor.yy115.gap.n = 0;}
         break;
-      case 208: /* session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
+      case 212: /* session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
 {
    yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-   yymsp[-6].minor.yy155.col = yymsp[-4].minor.yy0;
-   yymsp[-6].minor.yy155.gap = yymsp[-1].minor.yy0;
+   yymsp[-6].minor.yy115.col = yymsp[-4].minor.yy0;
+   yymsp[-6].minor.yy115.gap = yymsp[-1].minor.yy0;
 }
         break;
-      case 209: /* windowstate_option ::= */
-{ yymsp[1].minor.yy336.col.n = 0; yymsp[1].minor.yy336.col.z = NULL;}
+      case 213: /* windowstate_option ::= */
+{ yymsp[1].minor.yy290.col.n = 0; yymsp[1].minor.yy290.col.z = NULL;}
         break;
-      case 210: /* windowstate_option ::= STATE_WINDOW LP ids RP */
-{ yymsp[-3].minor.yy336.col = yymsp[-1].minor.yy0; }
+      case 214: /* windowstate_option ::= STATE_WINDOW LP ids RP */
+{ yymsp[-3].minor.yy290.col = yymsp[-1].minor.yy0; }
         break;
-      case 211: /* fill_opt ::= */
-{ yymsp[1].minor.yy189 = 0;     }
+      case 215: /* fill_opt ::= */
+{ yymsp[1].minor.yy209 = 0;     }
         break;
-      case 212: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+      case 216: /* 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.yy189, &A, -1, 0);
-    yymsp[-5].minor.yy189 = yymsp[-1].minor.yy189;
+    tVariantListInsert(yymsp[-1].minor.yy209, &A, -1, 0);
+    yymsp[-5].minor.yy209 = yymsp[-1].minor.yy209;
 }
         break;
-      case 213: /* fill_opt ::= FILL LP ID RP */
+      case 217: /* fill_opt ::= FILL LP ID RP */
 {
     toTSDBType(yymsp[-1].minor.yy0.type);
-    yymsp[-3].minor.yy189 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1, true);
+    yymsp[-3].minor.yy209 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1, true);
 }
         break;
-      case 214: /* sliding_opt ::= SLIDING LP tmvar RP */
+      case 218: /* sliding_opt ::= SLIDING LP tmvar RP */
 {yymsp[-3].minor.yy0 = yymsp[-1].minor.yy0;     }
         break;
-      case 215: /* sliding_opt ::= */
+      case 219: /* sliding_opt ::= */
 {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0;   }
         break;
-      case 217: /* orderby_opt ::= ORDER BY sortlist */
-{yymsp[-2].minor.yy189 = yymsp[0].minor.yy189;}
+      case 221: /* orderby_opt ::= ORDER BY sortlist */
+{yymsp[-2].minor.yy209 = yymsp[0].minor.yy209;}
         break;
-      case 218: /* sortlist ::= sortlist COMMA item sortorder */
+      case 222: /* sortlist ::= sortlist COMMA item sortorder */
 {
-  yylhsminor.yy189 = commonItemAppend(yymsp[-3].minor.yy189, &yymsp[-1].minor.yy162, NULL, false, yymsp[0].minor.yy420);
+  yylhsminor.yy209 = commonItemAppend(yymsp[-3].minor.yy209, &yymsp[-1].minor.yy54, NULL, false, yymsp[0].minor.yy332);
 }
-  yymsp[-3].minor.yy189 = yylhsminor.yy189;
+  yymsp[-3].minor.yy209 = yylhsminor.yy209;
         break;
-      case 219: /* sortlist ::= sortlist COMMA arrow sortorder */
+      case 223: /* sortlist ::= sortlist COMMA arrow sortorder */
 {
-  yylhsminor.yy189 = commonItemAppend(yymsp[-3].minor.yy189, NULL, yymsp[-1].minor.yy18, true, yymsp[0].minor.yy420);
+  yylhsminor.yy209 = commonItemAppend(yymsp[-3].minor.yy209, NULL, yymsp[-1].minor.yy574, true, yymsp[0].minor.yy332);
 }
-  yymsp[-3].minor.yy189 = yylhsminor.yy189;
+  yymsp[-3].minor.yy209 = yylhsminor.yy209;
         break;
-      case 220: /* sortlist ::= item sortorder */
+      case 224: /* sortlist ::= item sortorder */
 {
-  yylhsminor.yy189 = commonItemAppend(NULL, &yymsp[-1].minor.yy162, NULL, false, yymsp[0].minor.yy420);
+  yylhsminor.yy209 = commonItemAppend(NULL, &yymsp[-1].minor.yy54, NULL, false, yymsp[0].minor.yy332);
 }
-  yymsp[-1].minor.yy189 = yylhsminor.yy189;
+  yymsp[-1].minor.yy209 = yylhsminor.yy209;
         break;
-      case 221: /* sortlist ::= arrow sortorder */
+      case 225: /* sortlist ::= arrow sortorder */
 {
-  yylhsminor.yy189 = commonItemAppend(NULL, NULL, yymsp[-1].minor.yy18, true, yymsp[0].minor.yy420);
+  yylhsminor.yy209 = commonItemAppend(NULL, NULL, yymsp[-1].minor.yy574, true, yymsp[0].minor.yy332);
 }
-  yymsp[-1].minor.yy189 = yylhsminor.yy189;
+  yymsp[-1].minor.yy209 = yylhsminor.yy209;
         break;
-      case 222: /* item ::= ID */
+      case 226: /* item ::= ID */
 {
   toTSDBType(yymsp[0].minor.yy0.type);
-  tVariantCreate(&yylhsminor.yy162, &yymsp[0].minor.yy0);
+  tVariantCreate(&yylhsminor.yy54, &yymsp[0].minor.yy0);
 }
-  yymsp[0].minor.yy162 = yylhsminor.yy162;
+  yymsp[0].minor.yy54 = yylhsminor.yy54;
         break;
-      case 223: /* item ::= ID DOT ID */
+      case 227: /* item ::= ID DOT ID */
 {
   toTSDBType(yymsp[-2].minor.yy0.type);
   yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n);
-  tVariantCreate(&yylhsminor.yy162, &yymsp[-2].minor.yy0);
+  tVariantCreate(&yylhsminor.yy54, &yymsp[-2].minor.yy0);
 }
-  yymsp[-2].minor.yy162 = yylhsminor.yy162;
+  yymsp[-2].minor.yy54 = yylhsminor.yy54;
         break;
-      case 224: /* sortorder ::= ASC */
-{ yymsp[0].minor.yy420 = TSDB_ORDER_ASC; }
+      case 228: /* sortorder ::= ASC */
+{ yymsp[0].minor.yy332 = TSDB_ORDER_ASC; }
         break;
-      case 225: /* sortorder ::= DESC */
-{ yymsp[0].minor.yy420 = TSDB_ORDER_DESC;}
+      case 229: /* sortorder ::= DESC */
+{ yymsp[0].minor.yy332 = TSDB_ORDER_DESC;}
         break;
-      case 226: /* sortorder ::= */
-{ yymsp[1].minor.yy420 = TSDB_ORDER_ASC; }
+      case 230: /* sortorder ::= */
+{ yymsp[1].minor.yy332 = TSDB_ORDER_ASC; }
         break;
-      case 227: /* groupby_opt ::= */
-{ yymsp[1].minor.yy189 = 0;}
+      case 231: /* groupby_opt ::= */
+{ yymsp[1].minor.yy209 = 0;}
         break;
-      case 228: /* groupby_opt ::= GROUP BY grouplist */
-{ yymsp[-2].minor.yy189 = yymsp[0].minor.yy189;}
+      case 232: /* groupby_opt ::= GROUP BY grouplist */
+{ yymsp[-2].minor.yy209 = yymsp[0].minor.yy209;}
         break;
-      case 229: /* grouplist ::= grouplist COMMA item */
+      case 233: /* grouplist ::= grouplist COMMA item */
 {
-  yylhsminor.yy189 = commonItemAppend(yymsp[-2].minor.yy189, &yymsp[0].minor.yy162, NULL, false, -1);
+  yylhsminor.yy209 = commonItemAppend(yymsp[-2].minor.yy209, &yymsp[0].minor.yy54, NULL, false, -1);
 }
-  yymsp[-2].minor.yy189 = yylhsminor.yy189;
+  yymsp[-2].minor.yy209 = yylhsminor.yy209;
         break;
-      case 230: /* grouplist ::= grouplist COMMA arrow */
+      case 234: /* grouplist ::= grouplist COMMA arrow */
 {
-  yylhsminor.yy189 = commonItemAppend(yymsp[-2].minor.yy189, NULL, yymsp[0].minor.yy18, true, -1);
+  yylhsminor.yy209 = commonItemAppend(yymsp[-2].minor.yy209, NULL, yymsp[0].minor.yy574, true, -1);
 }
-  yymsp[-2].minor.yy189 = yylhsminor.yy189;
+  yymsp[-2].minor.yy209 = yylhsminor.yy209;
         break;
-      case 231: /* grouplist ::= item */
+      case 235: /* grouplist ::= item */
 {
-  yylhsminor.yy189 = commonItemAppend(NULL, &yymsp[0].minor.yy162, NULL, false, -1);
+  yylhsminor.yy209 = commonItemAppend(NULL, &yymsp[0].minor.yy54, NULL, false, -1);
 }
-  yymsp[0].minor.yy189 = yylhsminor.yy189;
+  yymsp[0].minor.yy209 = yylhsminor.yy209;
         break;
-      case 232: /* grouplist ::= arrow */
+      case 236: /* grouplist ::= arrow */
 {
-  yylhsminor.yy189 = commonItemAppend(NULL, NULL, yymsp[0].minor.yy18, true, -1);
+  yylhsminor.yy209 = commonItemAppend(NULL, NULL, yymsp[0].minor.yy574, true, -1);
 }
-  yymsp[0].minor.yy189 = yylhsminor.yy189;
+  yymsp[0].minor.yy209 = yylhsminor.yy209;
         break;
-      case 233: /* having_opt ::= */
-      case 243: /* where_opt ::= */ yytestcase(yyruleno==243);
-      case 293: /* expritem ::= */ yytestcase(yyruleno==293);
-{yymsp[1].minor.yy18 = 0;}
+      case 237: /* having_opt ::= */
+      case 247: /* where_opt ::= */ yytestcase(yyruleno==247);
+      case 297: /* expritem ::= */ yytestcase(yyruleno==297);
+{yymsp[1].minor.yy574 = 0;}
         break;
-      case 234: /* having_opt ::= HAVING expr */
-      case 244: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==244);
-{yymsp[-1].minor.yy18 = yymsp[0].minor.yy18;}
+      case 238: /* having_opt ::= HAVING expr */
+      case 248: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==248);
+{yymsp[-1].minor.yy574 = yymsp[0].minor.yy574;}
         break;
-      case 235: /* limit_opt ::= */
-      case 239: /* slimit_opt ::= */ yytestcase(yyruleno==239);
-{yymsp[1].minor.yy38.limit = -1; yymsp[1].minor.yy38.offset = 0;}
+      case 239: /* limit_opt ::= */
+      case 243: /* slimit_opt ::= */ yytestcase(yyruleno==243);
+{yymsp[1].minor.yy534.limit = -1; yymsp[1].minor.yy534.offset = 0;}
         break;
-      case 236: /* limit_opt ::= LIMIT signed */
-      case 240: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==240);
-{yymsp[-1].minor.yy38.limit = yymsp[0].minor.yy69;  yymsp[-1].minor.yy38.offset = 0;}
+      case 240: /* limit_opt ::= LIMIT signed */
+      case 244: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==244);
+{yymsp[-1].minor.yy534.limit = yymsp[0].minor.yy55;  yymsp[-1].minor.yy534.offset = 0;}
         break;
-      case 237: /* limit_opt ::= LIMIT signed OFFSET signed */
-{ yymsp[-3].minor.yy38.limit = yymsp[-2].minor.yy69;  yymsp[-3].minor.yy38.offset = yymsp[0].minor.yy69;}
+      case 241: /* limit_opt ::= LIMIT signed OFFSET signed */
+{ yymsp[-3].minor.yy534.limit = yymsp[-2].minor.yy55;  yymsp[-3].minor.yy534.offset = yymsp[0].minor.yy55;}
         break;
-      case 238: /* limit_opt ::= LIMIT signed COMMA signed */
-{ yymsp[-3].minor.yy38.limit = yymsp[0].minor.yy69;  yymsp[-3].minor.yy38.offset = yymsp[-2].minor.yy69;}
+      case 242: /* limit_opt ::= LIMIT signed COMMA signed */
+{ yymsp[-3].minor.yy534.limit = yymsp[0].minor.yy55;  yymsp[-3].minor.yy534.offset = yymsp[-2].minor.yy55;}
         break;
-      case 241: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
-{yymsp[-3].minor.yy38.limit = yymsp[-2].minor.yy69;  yymsp[-3].minor.yy38.offset = yymsp[0].minor.yy69;}
+      case 245: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
+{yymsp[-3].minor.yy534.limit = yymsp[-2].minor.yy55;  yymsp[-3].minor.yy534.offset = yymsp[0].minor.yy55;}
         break;
-      case 242: /* slimit_opt ::= SLIMIT signed COMMA signed */
-{yymsp[-3].minor.yy38.limit = yymsp[0].minor.yy69;  yymsp[-3].minor.yy38.offset = yymsp[-2].minor.yy69;}
+      case 246: /* slimit_opt ::= SLIMIT signed COMMA signed */
+{yymsp[-3].minor.yy534.limit = yymsp[0].minor.yy55;  yymsp[-3].minor.yy534.offset = yymsp[-2].minor.yy55;}
         break;
-      case 245: /* expr ::= LP expr RP */
-{yylhsminor.yy18 = yymsp[-1].minor.yy18; yylhsminor.yy18->exprToken.z = yymsp[-2].minor.yy0.z; yylhsminor.yy18->exprToken.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 249: /* expr ::= LP expr RP */
+{yylhsminor.yy574 = yymsp[-1].minor.yy574; yylhsminor.yy574->exprToken.z = yymsp[-2].minor.yy0.z; yylhsminor.yy574->exprToken.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 246: /* expr ::= ID */
-{ yylhsminor.yy18 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_ID);}
-  yymsp[0].minor.yy18 = yylhsminor.yy18;
+      case 250: /* expr ::= ID */
+{ yylhsminor.yy574 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_ID);}
+  yymsp[0].minor.yy574 = yylhsminor.yy574;
         break;
-      case 247: /* expr ::= ID DOT ID */
-{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy18 = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID);}
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 251: /* expr ::= ID DOT ID */
+{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy574 = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID);}
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 248: /* expr ::= ID DOT STAR */
-{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy18 = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ALL);}
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 252: /* expr ::= ID DOT STAR */
+{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy574 = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ALL);}
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 249: /* expr ::= INTEGER */
-{ yylhsminor.yy18 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_INTEGER);}
-  yymsp[0].minor.yy18 = yylhsminor.yy18;
+      case 253: /* expr ::= INTEGER */
+{ yylhsminor.yy574 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_INTEGER);}
+  yymsp[0].minor.yy574 = yylhsminor.yy574;
         break;
-      case 250: /* expr ::= MINUS INTEGER */
-      case 251: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==251);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy18 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_INTEGER);}
-  yymsp[-1].minor.yy18 = yylhsminor.yy18;
+      case 254: /* expr ::= MINUS INTEGER */
+      case 255: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==255);
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy574 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_INTEGER);}
+  yymsp[-1].minor.yy574 = yylhsminor.yy574;
         break;
-      case 252: /* expr ::= FLOAT */
-{ yylhsminor.yy18 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_FLOAT);}
-  yymsp[0].minor.yy18 = yylhsminor.yy18;
+      case 256: /* expr ::= FLOAT */
+{ yylhsminor.yy574 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_FLOAT);}
+  yymsp[0].minor.yy574 = yylhsminor.yy574;
         break;
-      case 253: /* expr ::= MINUS FLOAT */
-      case 254: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==254);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy18 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_FLOAT);}
-  yymsp[-1].minor.yy18 = yylhsminor.yy18;
+      case 257: /* expr ::= MINUS FLOAT */
+      case 258: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==258);
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy574 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_FLOAT);}
+  yymsp[-1].minor.yy574 = yylhsminor.yy574;
         break;
-      case 255: /* expr ::= STRING */
-{ yylhsminor.yy18 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING);}
-  yymsp[0].minor.yy18 = yylhsminor.yy18;
+      case 259: /* expr ::= STRING */
+{ yylhsminor.yy574 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING);}
+  yymsp[0].minor.yy574 = yylhsminor.yy574;
         break;
-      case 256: /* expr ::= NOW */
-{ yylhsminor.yy18 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_NOW); }
-  yymsp[0].minor.yy18 = yylhsminor.yy18;
+      case 260: /* expr ::= NOW */
+{ yylhsminor.yy574 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_NOW); }
+  yymsp[0].minor.yy574 = yylhsminor.yy574;
         break;
-      case 257: /* expr ::= VARIABLE */
-{ yylhsminor.yy18 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_VARIABLE);}
-  yymsp[0].minor.yy18 = yylhsminor.yy18;
+      case 261: /* expr ::= VARIABLE */
+{ yylhsminor.yy574 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_VARIABLE);}
+  yymsp[0].minor.yy574 = yylhsminor.yy574;
         break;
-      case 258: /* expr ::= PLUS VARIABLE */
-      case 259: /* expr ::= MINUS VARIABLE */ yytestcase(yyruleno==259);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_VARIABLE; yylhsminor.yy18 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_VARIABLE);}
-  yymsp[-1].minor.yy18 = yylhsminor.yy18;
+      case 262: /* expr ::= PLUS VARIABLE */
+      case 263: /* expr ::= MINUS VARIABLE */ yytestcase(yyruleno==263);
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_VARIABLE; yylhsminor.yy574 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_VARIABLE);}
+  yymsp[-1].minor.yy574 = yylhsminor.yy574;
         break;
-      case 260: /* expr ::= BOOL */
-{ yylhsminor.yy18 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_BOOL);}
-  yymsp[0].minor.yy18 = yylhsminor.yy18;
+      case 264: /* expr ::= BOOL */
+{ yylhsminor.yy574 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_BOOL);}
+  yymsp[0].minor.yy574 = yylhsminor.yy574;
         break;
-      case 261: /* expr ::= NULL */
-{ yylhsminor.yy18 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_NULL);}
-  yymsp[0].minor.yy18 = yylhsminor.yy18;
+      case 265: /* expr ::= NULL */
+{ yylhsminor.yy574 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_NULL);}
+  yymsp[0].minor.yy574 = yylhsminor.yy574;
         break;
-      case 262: /* expr ::= ID LP exprlist RP */
-{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy18 = tSqlExprCreateFunction(yymsp[-1].minor.yy189, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
-  yymsp[-3].minor.yy18 = yylhsminor.yy18;
+      case 266: /* expr ::= ID LP exprlist RP */
+{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy574 = tSqlExprCreateFunction(yymsp[-1].minor.yy209, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
+  yymsp[-3].minor.yy574 = yylhsminor.yy574;
         break;
-      case 263: /* expr ::= ID LP STAR RP */
-{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy18 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
-  yymsp[-3].minor.yy18 = yylhsminor.yy18;
+      case 267: /* expr ::= ID LP STAR RP */
+{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy574 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
+  yymsp[-3].minor.yy574 = yylhsminor.yy574;
         break;
-      case 264: /* expr ::= ID LP expr AS typename RP */
-{ tStrTokenAppend(pInfo->funcs, &yymsp[-5].minor.yy0); yylhsminor.yy18 = tSqlExprCreateFuncWithParams(pInfo, yymsp[-3].minor.yy18, &yymsp[-1].minor.yy279, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, yymsp[-5].minor.yy0.type); }
-  yymsp[-5].minor.yy18 = yylhsminor.yy18;
+      case 268: /* expr ::= ID LP expr AS typename RP */
+{ tStrTokenAppend(pInfo->funcs, &yymsp[-5].minor.yy0); yylhsminor.yy574 = tSqlExprCreateFuncWithParams(pInfo, yymsp[-3].minor.yy574, &yymsp[-1].minor.yy369, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, yymsp[-5].minor.yy0.type); }
+  yymsp[-5].minor.yy574 = yylhsminor.yy574;
         break;
-      case 265: /* expr ::= expr IS NULL */
-{yylhsminor.yy18 = tSqlExprCreate(yymsp[-2].minor.yy18, NULL, TK_ISNULL);}
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 269: /* expr ::= expr IS NULL */
+{yylhsminor.yy574 = tSqlExprCreate(yymsp[-2].minor.yy574, NULL, TK_ISNULL);}
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 266: /* expr ::= expr IS NOT NULL */
-{yylhsminor.yy18 = tSqlExprCreate(yymsp[-3].minor.yy18, NULL, TK_NOTNULL);}
-  yymsp[-3].minor.yy18 = yylhsminor.yy18;
+      case 270: /* expr ::= expr IS NOT NULL */
+{yylhsminor.yy574 = tSqlExprCreate(yymsp[-3].minor.yy574, NULL, TK_NOTNULL);}
+  yymsp[-3].minor.yy574 = yylhsminor.yy574;
         break;
-      case 267: /* expr ::= expr LT expr */
-{yylhsminor.yy18 = tSqlExprCreate(yymsp[-2].minor.yy18, yymsp[0].minor.yy18, TK_LT);}
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 271: /* expr ::= expr LT expr */
+{yylhsminor.yy574 = tSqlExprCreate(yymsp[-2].minor.yy574, yymsp[0].minor.yy574, TK_LT);}
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 268: /* expr ::= expr GT expr */
-{yylhsminor.yy18 = tSqlExprCreate(yymsp[-2].minor.yy18, yymsp[0].minor.yy18, TK_GT);}
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 272: /* expr ::= expr GT expr */
+{yylhsminor.yy574 = tSqlExprCreate(yymsp[-2].minor.yy574, yymsp[0].minor.yy574, TK_GT);}
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 269: /* expr ::= expr LE expr */
-{yylhsminor.yy18 = tSqlExprCreate(yymsp[-2].minor.yy18, yymsp[0].minor.yy18, TK_LE);}
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 273: /* expr ::= expr LE expr */
+{yylhsminor.yy574 = tSqlExprCreate(yymsp[-2].minor.yy574, yymsp[0].minor.yy574, TK_LE);}
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 270: /* expr ::= expr GE expr */
-{yylhsminor.yy18 = tSqlExprCreate(yymsp[-2].minor.yy18, yymsp[0].minor.yy18, TK_GE);}
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 274: /* expr ::= expr GE expr */
+{yylhsminor.yy574 = tSqlExprCreate(yymsp[-2].minor.yy574, yymsp[0].minor.yy574, TK_GE);}
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 271: /* expr ::= expr NE expr */
-{yylhsminor.yy18 = tSqlExprCreate(yymsp[-2].minor.yy18, yymsp[0].minor.yy18, TK_NE);}
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 275: /* expr ::= expr NE expr */
+{yylhsminor.yy574 = tSqlExprCreate(yymsp[-2].minor.yy574, yymsp[0].minor.yy574, TK_NE);}
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 272: /* expr ::= expr EQ expr */
-{yylhsminor.yy18 = tSqlExprCreate(yymsp[-2].minor.yy18, yymsp[0].minor.yy18, TK_EQ);}
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 276: /* expr ::= expr EQ expr */
+{yylhsminor.yy574 = tSqlExprCreate(yymsp[-2].minor.yy574, yymsp[0].minor.yy574, TK_EQ);}
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 273: /* expr ::= expr BETWEEN expr AND expr */
-{ tSqlExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy18); yylhsminor.yy18 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy18, yymsp[-2].minor.yy18, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy18, TK_LE), TK_AND);}
-  yymsp[-4].minor.yy18 = yylhsminor.yy18;
+      case 277: /* expr ::= expr BETWEEN expr AND expr */
+{ tSqlExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy574); yylhsminor.yy574 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy574, yymsp[-2].minor.yy574, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy574, TK_LE), TK_AND);}
+  yymsp[-4].minor.yy574 = yylhsminor.yy574;
         break;
-      case 274: /* expr ::= expr AND expr */
-{yylhsminor.yy18 = tSqlExprCreate(yymsp[-2].minor.yy18, yymsp[0].minor.yy18, TK_AND);}
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 278: /* expr ::= expr AND expr */
+{yylhsminor.yy574 = tSqlExprCreate(yymsp[-2].minor.yy574, yymsp[0].minor.yy574, TK_AND);}
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 275: /* expr ::= expr OR expr */
-{yylhsminor.yy18 = tSqlExprCreate(yymsp[-2].minor.yy18, yymsp[0].minor.yy18, TK_OR); }
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 279: /* expr ::= expr OR expr */
+{yylhsminor.yy574 = tSqlExprCreate(yymsp[-2].minor.yy574, yymsp[0].minor.yy574, TK_OR); }
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 276: /* expr ::= expr PLUS expr */
-{yylhsminor.yy18 = tSqlExprCreate(yymsp[-2].minor.yy18, yymsp[0].minor.yy18, TK_PLUS);  }
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 280: /* expr ::= expr PLUS expr */
+{yylhsminor.yy574 = tSqlExprCreate(yymsp[-2].minor.yy574, yymsp[0].minor.yy574, TK_PLUS);  }
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 277: /* expr ::= expr MINUS expr */
-{yylhsminor.yy18 = tSqlExprCreate(yymsp[-2].minor.yy18, yymsp[0].minor.yy18, TK_MINUS); }
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 281: /* expr ::= expr MINUS expr */
+{yylhsminor.yy574 = tSqlExprCreate(yymsp[-2].minor.yy574, yymsp[0].minor.yy574, TK_MINUS); }
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 278: /* expr ::= expr STAR expr */
-{yylhsminor.yy18 = tSqlExprCreate(yymsp[-2].minor.yy18, yymsp[0].minor.yy18, TK_STAR);  }
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 282: /* expr ::= expr STAR expr */
+{yylhsminor.yy574 = tSqlExprCreate(yymsp[-2].minor.yy574, yymsp[0].minor.yy574, TK_STAR);  }
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 279: /* expr ::= expr SLASH expr */
-{yylhsminor.yy18 = tSqlExprCreate(yymsp[-2].minor.yy18, yymsp[0].minor.yy18, TK_DIVIDE);}
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 283: /* expr ::= expr SLASH expr */
+{yylhsminor.yy574 = tSqlExprCreate(yymsp[-2].minor.yy574, yymsp[0].minor.yy574, TK_DIVIDE);}
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 280: /* expr ::= expr REM expr */
-{yylhsminor.yy18 = tSqlExprCreate(yymsp[-2].minor.yy18, yymsp[0].minor.yy18, TK_REM);   }
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 284: /* expr ::= expr REM expr */
+{yylhsminor.yy574 = tSqlExprCreate(yymsp[-2].minor.yy574, yymsp[0].minor.yy574, TK_REM);   }
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 281: /* expr ::= expr LIKE expr */
-{yylhsminor.yy18 = tSqlExprCreate(yymsp[-2].minor.yy18, yymsp[0].minor.yy18, TK_LIKE);  }
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 285: /* expr ::= expr LIKE expr */
+{yylhsminor.yy574 = tSqlExprCreate(yymsp[-2].minor.yy574, yymsp[0].minor.yy574, TK_LIKE);  }
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 282: /* expr ::= expr MATCH expr */
-{yylhsminor.yy18 = tSqlExprCreate(yymsp[-2].minor.yy18, yymsp[0].minor.yy18, TK_MATCH);  }
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 286: /* expr ::= expr MATCH expr */
+{yylhsminor.yy574 = tSqlExprCreate(yymsp[-2].minor.yy574, yymsp[0].minor.yy574, TK_MATCH);  }
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 283: /* expr ::= expr NMATCH expr */
-{yylhsminor.yy18 = tSqlExprCreate(yymsp[-2].minor.yy18, yymsp[0].minor.yy18, TK_NMATCH);  }
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 287: /* expr ::= expr NMATCH expr */
+{yylhsminor.yy574 = tSqlExprCreate(yymsp[-2].minor.yy574, yymsp[0].minor.yy574, TK_NMATCH);  }
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 284: /* expr ::= ID CONTAINS STRING */
-{ tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy18 = tSqlExprCreate(S, M, TK_CONTAINS);  }
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 288: /* expr ::= ID CONTAINS STRING */
+{ tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy574 = tSqlExprCreate(S, M, TK_CONTAINS);  }
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 285: /* expr ::= ID DOT ID CONTAINS STRING */
-{ yymsp[-4].minor.yy0.n += (1+yymsp[-2].minor.yy0.n); tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-4].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy18 = tSqlExprCreate(S, M, TK_CONTAINS);  }
-  yymsp[-4].minor.yy18 = yylhsminor.yy18;
+      case 289: /* expr ::= ID DOT ID CONTAINS STRING */
+{ yymsp[-4].minor.yy0.n += (1+yymsp[-2].minor.yy0.n); tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-4].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy574 = tSqlExprCreate(S, M, TK_CONTAINS);  }
+  yymsp[-4].minor.yy574 = yylhsminor.yy574;
         break;
-      case 286: /* arrow ::= ID ARROW STRING */
-{tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy18 = tSqlExprCreate(S, M, TK_ARROW);  }
-  yymsp[-2].minor.yy18 = yylhsminor.yy18;
+      case 290: /* arrow ::= ID ARROW STRING */
+{tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy574 = tSqlExprCreate(S, M, TK_ARROW);  }
+  yymsp[-2].minor.yy574 = yylhsminor.yy574;
         break;
-      case 287: /* arrow ::= ID DOT ID ARROW STRING */
-{yymsp[-4].minor.yy0.n += (1+yymsp[-2].minor.yy0.n); tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-4].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy18 = tSqlExprCreate(S, M, TK_ARROW);  }
-  yymsp[-4].minor.yy18 = yylhsminor.yy18;
+      case 291: /* arrow ::= ID DOT ID ARROW STRING */
+{yymsp[-4].minor.yy0.n += (1+yymsp[-2].minor.yy0.n); tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-4].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy574 = tSqlExprCreate(S, M, TK_ARROW);  }
+  yymsp[-4].minor.yy574 = yylhsminor.yy574;
         break;
-      case 288: /* expr ::= arrow */
-      case 292: /* expritem ::= expr */ yytestcase(yyruleno==292);
-{yylhsminor.yy18 = yymsp[0].minor.yy18;}
-  yymsp[0].minor.yy18 = yylhsminor.yy18;
+      case 292: /* expr ::= arrow */
+      case 296: /* expritem ::= expr */ yytestcase(yyruleno==296);
+{yylhsminor.yy574 = yymsp[0].minor.yy574;}
+  yymsp[0].minor.yy574 = yylhsminor.yy574;
         break;
-      case 289: /* expr ::= expr IN LP exprlist RP */
-{yylhsminor.yy18 = tSqlExprCreate(yymsp[-4].minor.yy18, (tSqlExpr*)yymsp[-1].minor.yy189, TK_IN); }
-  yymsp[-4].minor.yy18 = yylhsminor.yy18;
+      case 293: /* expr ::= expr IN LP exprlist RP */
+{yylhsminor.yy574 = tSqlExprCreate(yymsp[-4].minor.yy574, (tSqlExpr*)yymsp[-1].minor.yy209, TK_IN); }
+  yymsp[-4].minor.yy574 = yylhsminor.yy574;
         break;
-      case 290: /* exprlist ::= exprlist COMMA expritem */
-{yylhsminor.yy189 = tSqlExprListAppend(yymsp[-2].minor.yy189,yymsp[0].minor.yy18,0, 0);}
-  yymsp[-2].minor.yy189 = yylhsminor.yy189;
+      case 294: /* exprlist ::= exprlist COMMA expritem */
+{yylhsminor.yy209 = tSqlExprListAppend(yymsp[-2].minor.yy209,yymsp[0].minor.yy574,0, 0);}
+  yymsp[-2].minor.yy209 = yylhsminor.yy209;
         break;
-      case 291: /* exprlist ::= expritem */
-{yylhsminor.yy189 = tSqlExprListAppend(0,yymsp[0].minor.yy18,0, 0);}
-  yymsp[0].minor.yy189 = yylhsminor.yy189;
+      case 295: /* exprlist ::= expritem */
+{yylhsminor.yy209 = tSqlExprListAppend(0,yymsp[0].minor.yy574,0, 0);}
+  yymsp[0].minor.yy209 = yylhsminor.yy209;
         break;
-      case 294: /* cmd ::= RESET QUERY CACHE */
+      case 298: /* cmd ::= RESET QUERY CACHE */
 { setDCLSqlElems(pInfo, TSDB_SQL_RESET_CACHE, 0);}
         break;
-      case 295: /* cmd ::= SYNCDB ids REPLICA */
+      case 299: /* cmd ::= SYNCDB ids REPLICA */
 { setDCLSqlElems(pInfo, TSDB_SQL_SYNC_DB_REPLICA, 1, &yymsp[-1].minor.yy0);}
         break;
-      case 296: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+      case 300: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy189, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy209, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 297: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+      case 301: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -3821,21 +3387,21 @@ static YYACTIONTYPE yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 298: /* cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
+      case 302: /* cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy189, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy209, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 299: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+      case 303: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy189, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy209, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 300: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+      case 304: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -3846,7 +3412,7 @@ static YYACTIONTYPE yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 301: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+      case 305: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
 {
     yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
 
@@ -3860,33 +3426,33 @@ static YYACTIONTYPE yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 302: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+      case 306: /* 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, false);
-    A = tVariantListAppend(A, &yymsp[0].minor.yy162, -1);
+    A = tVariantListAppend(A, &yymsp[0].minor.yy54, -1);
 
     SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 303: /* cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
+      case 307: /* cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy189, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy209, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 304: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
+      case 308: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy189, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy209, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 305: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
+      case 309: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -3897,21 +3463,21 @@ static YYACTIONTYPE yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 306: /* cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
+      case 310: /* cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy189, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy209, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 307: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
+      case 311: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy189, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy209, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 308: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
+      case 312: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -3922,7 +3488,7 @@ static YYACTIONTYPE yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 309: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
+      case 313: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
 {
     yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
 
@@ -3936,41 +3502,41 @@ static YYACTIONTYPE yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 310: /* cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
+      case 314: /* cmd ::= ALTER STABLE 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, false);
-    A = tVariantListAppend(A, &yymsp[0].minor.yy162, -1);
+    A = tVariantListAppend(A, &yymsp[0].minor.yy54, -1);
 
     SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 311: /* cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
+      case 315: /* cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy189, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy209, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 312: /* cmd ::= KILL CONNECTION INTEGER */
+      case 316: /* cmd ::= KILL CONNECTION INTEGER */
 {setKillSql(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);}
         break;
-      case 313: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
+      case 317: /* 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 314: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
+      case 318: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
 {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_QUERY, &yymsp[-2].minor.yy0);}
         break;
       default:
         break;
 /********** End reduce actions ************************************************/
   };
-  assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) );
-  yygoto = yyRuleInfoLhs[yyruleno];
-  yysize = yyRuleInfoNRhs[yyruleno];
+  assert( yyruleno<sizeof(yyRuleInfo)/sizeof(yyRuleInfo[0]) );
+  yygoto = yyRuleInfo[yyruleno].lhs;
+  yysize = yyRuleInfo[yyruleno].nrhs;
   yyact = yy_find_reduce_action(yymsp[yysize].stateno,(YYCODETYPE)yygoto);
 
   /* There are no SHIFTREDUCE actions on nonterminals because the table
@@ -4132,56 +3698,12 @@ void Parse(
   }
 #endif
 
-  while(1){ /* Exit by "break" */
-    assert( yypParser->yytos>=yypParser->yystack );
+  do{
     assert( yyact==yypParser->yytos->stateno );
     yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact);
     if( yyact >= YY_MIN_REDUCE ){
-      unsigned int yyruleno = yyact - YY_MIN_REDUCE; /* Reduce by this rule */
-      assert( yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) );
-#ifndef NDEBUG
-      if( yyTraceFILE ){
-        int yysize = yyRuleInfoNRhs[yyruleno];
-        if( yysize ){
-          fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",
-            yyTracePrompt,
-            yyruleno, yyRuleName[yyruleno],
-            yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action",
-            yypParser->yytos[yysize].stateno);
-        }else{
-          fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n",
-            yyTracePrompt, yyruleno, yyRuleName[yyruleno],
-            yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action");
-        }
-      }
-#endif /* NDEBUG */
-
-      /* Check that the stack is large enough to grow by a single entry
-      ** if the RHS of the rule is empty.  This ensures that there is room
-      ** enough on the stack to push the LHS value */
-      if( yyRuleInfoNRhs[yyruleno]==0 ){
-#ifdef YYTRACKMAXSTACKDEPTH
-        if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
-          yypParser->yyhwm++;
-          assert( yypParser->yyhwm ==
-                  (int)(yypParser->yytos - yypParser->yystack));
-        }
-#endif
-#if YYSTACKDEPTH>0 
-        if( yypParser->yytos>=yypParser->yystackEnd ){
-          yyStackOverflow(yypParser);
-          break;
-        }
-#else
-        if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){
-          if( yyGrowStack(yypParser) ){
-            yyStackOverflow(yypParser);
-            break;
-          }
-        }
-#endif
-      }
-      yyact = yy_reduce(yypParser,yyruleno,yymajor,yyminor ParseCTX_PARAM);
+      yyact = yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor,
+                        yyminor ParseCTX_PARAM);
     }else if( yyact <= YY_MAX_SHIFTREDUCE ){
       yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor);
 #ifndef YYNOERRORRECOVERY
@@ -4237,13 +3759,14 @@ void Parse(
         yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion);
         yymajor = YYNOCODE;
       }else{
-        while( yypParser->yytos > yypParser->yystack ){
-          yyact = yy_find_reduce_action(yypParser->yytos->stateno,
-                                        YYERRORSYMBOL);
-          if( yyact<=YY_MAX_SHIFTREDUCE ) break;
+        while( yypParser->yytos >= yypParser->yystack
+            && (yyact = yy_find_reduce_action(
+                        yypParser->yytos->stateno,
+                        YYERRORSYMBOL)) > YY_MAX_SHIFTREDUCE
+        ){
           yy_pop_parser_stack(yypParser);
         }
-        if( yypParser->yytos <= yypParser->yystack || yymajor==0 ){
+        if( yypParser->yytos < yypParser->yystack || yymajor==0 ){
           yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
           yy_parse_failed(yypParser);
 #ifndef YYNOERRORRECOVERY
@@ -4293,7 +3816,7 @@ void Parse(
       break;
 #endif
     }
-  }
+  }while( yypParser->yytos>yypParser->yystack );
 #ifndef NDEBUG
   if( yyTraceFILE ){
     yyStackEntry *i;
@@ -4315,10 +3838,11 @@ void Parse(
 */
 int ParseFallback(int iToken){
 #ifdef YYFALLBACK
-  assert( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) );
-  return yyFallback[iToken];
+  if( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) ){
+    return yyFallback[iToken];
+  }
 #else
   (void)iToken;
-  return 0;
 #endif
+  return 0;
 }
diff --git a/src/rpc/src/rpcMain.c b/src/rpc/src/rpcMain.c
index 34e9ddf8193f999d598bd367ba75556a36cd0c78..dfeca03826d0bb36c4840ef01ad5acb05bf55ec3 100644
--- a/src/rpc/src/rpcMain.c
+++ b/src/rpc/src/rpcMain.c
@@ -1677,3 +1677,9 @@ static void rpcDecRef(SRpcInfo *pRpc)
   }
 }
 
+int32_t rpcUnusedSession(void * rpcInfo, bool bLock) {
+  SRpcInfo *info = (SRpcInfo *)rpcInfo;
+  if(info == NULL)
+     return 0;
+  return taosIdPoolNumOfFree(info->idPool, bLock);
+}
\ No newline at end of file
diff --git a/src/util/inc/tidpool.h b/src/util/inc/tidpool.h
index e4439439ced6522e26c8db4a560c50f5b0cb8a16..99dfd4bdc2accca9daf9edd0b807fae265b68633 100644
--- a/src/util/inc/tidpool.h
+++ b/src/util/inc/tidpool.h
@@ -36,6 +36,9 @@ int taosIdPoolNumOfUsed(void *handle);
 
 bool taosIdPoolMarkStatus(void *handle, int id);
 
+// get free count from pool , if bLock is true, locked pool than get free count, accuracy but slowly 
+int taosIdPoolNumOfFree(void *handle, bool bLock);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/util/inc/ttoken.h b/src/util/inc/ttoken.h
index f62329183f82a57bcf65d136aaec65d8babd5f71..17f2bf5a79f9dd2c6650e4b0cb24a492c4d68e3a 100644
--- a/src/util/inc/ttoken.h
+++ b/src/util/inc/ttoken.h
@@ -63,6 +63,15 @@ uint32_t tGetToken(char *z, uint32_t *tokenType);
  */
 SStrToken tStrGetToken(char *str, int32_t *i, bool isPrevOptr);
 
+/**
+ * strcpy implement source from SStrToken
+ *
+ * @param dst  copy to 
+ * @param srcToken copy from
+ * @return size of copy successful bytes, not include '\0'
+ */
+int32_t tStrNCpy(char *dst, SStrToken* srcToken);
+
 /**
  * check if it is a keyword or not
  * @param z
diff --git a/src/util/src/tidpool.c b/src/util/src/tidpool.c
index 61cecf54c0e14a4435ba72d317715cdec902068b..cacac259f0a2e1c42a216b40bb8678831872aa3a 100644
--- a/src/util/src/tidpool.c
+++ b/src/util/src/tidpool.c
@@ -163,4 +163,16 @@ int taosIdPoolMaxSize(void *handle) {
   pthread_mutex_unlock(&pIdPool->mutex);
 
   return ret;
+}
+
+// get free count from pool , if bLock is true, locked pool than get free count, accuracy but slowly 
+int taosIdPoolNumOfFree(void *handle, bool bLock) {
+  id_pool_t *pIdPool = handle;
+  if(bLock)
+    pthread_mutex_lock(&pIdPool->mutex);
+  
+  int ret = pIdPool->numOfFree;
+  if(bLock)
+    pthread_mutex_unlock(&pIdPool->mutex);
+  return ret;
 }
\ No newline at end of file
diff --git a/src/util/src/ttokenizer.c b/src/util/src/ttokenizer.c
index 8fca99291164a429867a090c98a61156daa40af2..dfb1f708a2514528c4fbaae34b0d8c15ecce8dd5 100644
--- a/src/util/src/ttokenizer.c
+++ b/src/util/src/ttokenizer.c
@@ -231,7 +231,9 @@ static SKeyword keywordTable[] = {
     {"AGGREGATE",    TK_AGGREGATE},
     {"BUFSIZE",      TK_BUFSIZE},
     {"RANGE",        TK_RANGE},
-    {"CONTAINS",     TK_CONTAINS}
+    {"CONTAINS",     TK_CONTAINS},
+    {"TO",           TK_TO},
+    {"SPLIT",        TK_SPLIT}   
 };
 
 static const char isIdChar[] = {
@@ -704,6 +706,18 @@ SStrToken tStrGetToken(char* str, int32_t* i, bool isPrevOptr) {
   return t0;
 }
 
+/**
+ * strcpy implement source from SStrToken
+ *
+ * @param dst  copy to 
+ * @param srcToken copy from
+ * @return size of copy successful bytes
+ */
+int32_t tStrNCpy(char *dst, SStrToken* srcToken) {
+  strncpy(dst, srcToken->z, srcToken->n);
+  return srcToken->n;
+}
+
 bool taosIsKeyWordToken(const char* z, int32_t len) {
   return (tKeywordCode((char*)z, len) != TK_ID);
 }