From 5ed10d3a4c0014ae590e8437baced296b74db97e Mon Sep 17 00:00:00 2001
From: yihaoDeng <yhdeng@taosdata.com>
Date: Sun, 13 Sep 2020 21:18:55 +0000
Subject: [PATCH 01/35] suppport cmd show-create-table and show-create-db

---
 src/client/inc/tsclient.h      |   1 +
 src/client/src/tscLocal.c      | 580 +++++++++++++++++++++++++++++++--
 src/client/src/tscSQLParser.c  |  33 ++
 src/client/src/tscSchemaUtil.c |   1 +
 src/client/src/tscServer.c     |   7 +
 src/client/src/tscSql.c        |   2 +
 src/client/src/tscSubquery.c   |   1 +
 src/common/inc/tcmdtype.h      |   3 +
 src/inc/taosmsg.h              |   1 +
 src/inc/ttokendef.h            | 198 +++++------
 src/mnode/src/mnodeTable.c     |   3 +
 src/query/inc/sql.y            |  10 +
 12 files changed, 716 insertions(+), 124 deletions(-)

diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index 5f4a46ddad..8bb146b1ad 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -98,6 +98,7 @@ typedef struct STableMeta {
   uint8_t        tableType;
   int16_t        sversion;
   int16_t        tversion;
+  char           sTableId[TSDB_TABLE_FNAME_LEN];
   SCMVgroupInfo  vgroupInfo;
   SCMCorVgroupInfo  corVgroupInfo;
   STableId       id;
diff --git a/src/client/src/tscLocal.c b/src/client/src/tscLocal.c
index b240d357a8..6d48350f73 100644
--- a/src/client/src/tscLocal.c
+++ b/src/client/src/tscLocal.c
@@ -24,7 +24,30 @@
 #include "tscUtil.h"
 #include "tschemautil.h"
 #include "tsclient.h"
+#include "taos.h"
+#include "tscSubquery.h"
 
+#define STR_NOCASE_EQUAL(str1, len1, str2, len2) ((len1 == len2) && 0 == strncasecmp(str1, str2, len1)) 
+
+typedef enum BuildType {
+  SCREATE_BUILD_TABLE = 1, 
+  SCREATE_BUILD_DB    = 2, 
+} BuildType; 
+
+typedef enum Stage {
+  SCREATE_CALLBACK_QUERY    = 1,
+  SCREATE_CALLBACK_RETRIEVE = 2,
+} Stage;
+
+// support 'show create table'   
+typedef struct SCreateBuilder {
+  char sTableName[TSDB_TABLE_FNAME_LEN];
+  char buf[TSDB_TABLE_FNAME_LEN];
+  SSqlObj *pParentSql; 
+  SSqlObj *pInterSql;
+  int32_t (*fp)(void *para, char* result);
+  Stage callStage;
+} SCreateBuilder; 
 static void tscSetLocalQueryResult(SSqlObj *pSql, const char *val, const char *columnName, int16_t type, size_t valueLength);
 
 static int32_t getToStringLength(const char *pData, int32_t length, int32_t type) {
@@ -273,14 +296,512 @@ static int32_t tscProcessDescribeTable(SSqlObj *pSql) {
   tscFieldInfoUpdateOffset(pQueryInfo);
   return tscSetValueToResObj(pSql, rowLen);
 }
+static int32_t tscGetNthFieldResult(TAOS_ROW row, TAOS_FIELD* fields, int *lengths, int idx, char *result) {
+  const char *val = row[idx];
+  if (val == NULL) {
+    sprintf(result, "%s", TSDB_DATA_NULL_STR);
+    return -1;
+  } 
+  uint8_t type = fields[idx].type;
+  int32_t length = lengths[idx]; 
 
+  switch (type) {
+    case TSDB_DATA_TYPE_BOOL: 
+      sprintf(result, "%s", ((((int)(*((char *)val))) == 1) ? "true" : "false"));
+      break;
+    case TSDB_DATA_TYPE_TINYINT:
+      sprintf(result, "%d", (int)(*((char *)val)));
+      break;
+    case TSDB_DATA_TYPE_SMALLINT: 
+      sprintf(result, "%d", (int)(*((short *)val)));
+      break;
+    case TSDB_DATA_TYPE_INT:
+      sprintf(result, "%d", *((int *)val));
+      break;
+    case TSDB_DATA_TYPE_BIGINT: 
+      sprintf(result, "%"PRId64, *((int64_t *)val)); 
+      break;
+    case TSDB_DATA_TYPE_FLOAT:
+      sprintf(result, "%f", GET_FLOAT_VAL(val)); 
+      break;
+    case TSDB_DATA_TYPE_DOUBLE:
+      sprintf(result, "%f", GET_DOUBLE_VAL(val)); 
+      break;
+    case TSDB_DATA_TYPE_NCHAR:
+    case TSDB_DATA_TYPE_BINARY:
+      memcpy(result, val, length); 
+      break;
+    case TSDB_DATA_TYPE_TIMESTAMP:
+      ///formatTimestamp(buf, *(int64_t*)val, TSDB_TIME_PRECISION_MICRO);
+      //memcpy(result, val, strlen(buf));
+      sprintf(result, "%"PRId64, *((int64_t *)val)); 
+      break;
+    default:
+      break; 
+  }
+  return 0;
+} 
+
+void tscSCreateCallBack(void *param, TAOS_RES *tres, int code) {
+  if (param == NULL || tres == NULL) {
+    return;
+  }  
+  SCreateBuilder *builder = (SCreateBuilder *)(param);
+  SSqlObj *pParentSql = builder->pParentSql;  
+  SSqlObj *pSql = (SSqlObj *)tres; 
+
+  SSqlRes *pRes = &pParentSql->res;
+  pRes->code = taos_errno(pSql); 
+  if (pRes->code != TSDB_CODE_SUCCESS) {
+    taos_free_result(pSql);  
+    free(builder);
+    tscQueueAsyncRes(pParentSql);
+    return;
+  }
+
+  if (builder->callStage == SCREATE_CALLBACK_QUERY) {
+    taos_fetch_rows_a(tres, tscSCreateCallBack, param);    
+    builder->callStage = SCREATE_CALLBACK_RETRIEVE;
+  } else {
+    char *result = calloc(1, TSDB_MAX_BINARY_LEN);
+    pRes->code = builder->fp(builder, result);
+
+    taos_free_result(pSql);  
+    free(builder);
+    free(result);
+
+    if (pRes->code == TSDB_CODE_SUCCESS) {
+      (*pParentSql->fp)(pParentSql->param, pParentSql, code);  
+    } else {
+      tscQueueAsyncRes(pParentSql);
+    }
+  }
+}
+
+TAOS_ROW tscFetchRow(void *param) {
+  SCreateBuilder *builder = (SCreateBuilder *)param;
+  if (builder == NULL) {
+    return NULL;
+  } 
+  SSqlObj *pSql = builder->pInterSql;
+  if (pSql == NULL || pSql->signature != pSql) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return NULL;
+  }
+  
+  SSqlCmd *pCmd = &pSql->cmd;
+  SSqlRes *pRes = &pSql->res;
+  
+  if (pRes->qhandle == 0 ||
+      pCmd->command == TSDB_SQL_RETRIEVE_EMPTY_RESULT ||
+      pCmd->command == TSDB_SQL_INSERT) {
+    return NULL;
+  }
+
+  // set the sql object owner
+  tscSetSqlOwner(pSql);
+
+  // current data set are exhausted, fetch more data from node
+  if (pRes->row >= pRes->numOfRows && (pRes->completed != true || hasMoreVnodesToTry(pSql) || hasMoreClauseToTry(pSql)) &&
+      (pCmd->command == TSDB_SQL_RETRIEVE ||
+       pCmd->command == TSDB_SQL_RETRIEVE_LOCALMERGE ||
+       pCmd->command == TSDB_SQL_TABLE_JOIN_RETRIEVE ||
+       pCmd->command == TSDB_SQL_FETCH ||
+       pCmd->command == TSDB_SQL_SHOW ||
+       pCmd->command == TSDB_SQL_SHOW_CREATE_TABLE ||
+       pCmd->command == TSDB_SQL_SHOW_CREATE_DATABASE ||
+       pCmd->command == TSDB_SQL_SELECT ||
+       pCmd->command == TSDB_SQL_DESCRIBE_TABLE ||
+       pCmd->command == TSDB_SQL_SERV_STATUS ||
+       pCmd->command == TSDB_SQL_CURRENT_DB ||
+       pCmd->command == TSDB_SQL_SERV_VERSION ||
+       pCmd->command == TSDB_SQL_CLI_VERSION ||
+       pCmd->command == TSDB_SQL_CURRENT_USER )) {
+    taos_fetch_rows_a(pSql, tscSCreateCallBack, param);
+    return NULL;
+  }
+
+  void* data = doSetResultRowData(pSql, true);
+
+  tscClearSqlOwner(pSql);
+  return data;
+}
+static int32_t tscGetTableTagValue(SCreateBuilder *builder, char *result) {
+  TAOS_ROW row = tscFetchRow(builder);
+  SSqlObj* pSql = builder->pInterSql;
+
+  if (row == NULL) {
+   return TSDB_CODE_MND_INVALID_TABLE_NAME;
+  }
+
+  int32_t* lengths = taos_fetch_lengths(pSql);  
+  int num_fields = taos_num_fields(pSql);
+  TAOS_FIELD *fields = taos_fetch_fields(pSql);
+
+  char buf[TSDB_COL_NAME_LEN + 16]; 
+  for (int i = 0; i < num_fields; i++) {
+    memset(buf, 0, sizeof(buf));
+    int32_t ret = tscGetNthFieldResult(row, fields, lengths, i, buf);
+
+    if (i == 0) {
+      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s", "(");
+    } 
+    if ((fields[i].type == TSDB_DATA_TYPE_NCHAR 
+        || fields[i].type == TSDB_DATA_TYPE_BINARY 
+        || fields[i].type == TSDB_DATA_TYPE_TIMESTAMP) && 0 == ret) {
+      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "\"%s\",", buf);
+    } else {
+      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s,", buf);
+    }
+    if (i == num_fields - 1) {
+      sprintf(result + strlen(result) - 1, "%s", ")");
+    }
+  }  
+
+  if (0 == strlen(result)) {
+   return TSDB_CODE_MND_INVALID_TABLE_NAME; 
+  }
+  return TSDB_CODE_SUCCESS;
+}
+
+
+// build 'show create table/database' result fields 
+static int32_t tscSCreateBuildResultFields(SSqlObj *pSql, BuildType type, const char *ddl) {
+  int32_t  rowLen = 0;
+  int16_t  ddlLen = strlen(ddl); 
+  SColumnIndex index = {0};
+  pSql->cmd.numOfCols = 2;
+
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  pQueryInfo->order.order = TSDB_ORDER_ASC;
+
+  TAOS_FIELD f; 
+  if (type == SCREATE_BUILD_TABLE) {
+    f.type  = TSDB_DATA_TYPE_BINARY;
+    f.bytes = (TSDB_COL_NAME_LEN - 1) + VARSTR_HEADER_SIZE;
+    tstrncpy(f.name, "Table", sizeof(f.name));
+  } else {
+    f.type  = TSDB_DATA_TYPE_BINARY;
+    f.bytes =  (TSDB_DB_NAME_LEN - 1) + VARSTR_HEADER_SIZE;
+    tstrncpy(f.name, "Database", sizeof(f.name));
+  } 
+
+  SFieldSupInfo* pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
+  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY,
+      f.bytes, f.bytes - VARSTR_HEADER_SIZE, false);
+
+  rowLen += f.bytes; 
+
+  f.bytes = (int16_t)(ddlLen + VARSTR_HEADER_SIZE);
+  f.type = TSDB_DATA_TYPE_BINARY;
+  if (type == SCREATE_BUILD_TABLE) {
+    tstrncpy(f.name, "Create Table", sizeof(f.name));
+  } else {
+    tstrncpy(f.name, "Create Database", sizeof(f.name));
+  }
+
+  pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
+  pInfo->pSqlExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, 
+      (int16_t)(ddlLen + VARSTR_HEADER_SIZE), ddlLen, false);
+
+  rowLen += ddlLen + VARSTR_HEADER_SIZE;
+
+  return rowLen;
+}
+static int32_t tscSCreateSetValueToResObj(SSqlObj *pSql, int32_t rowLen, const char *tableName, const char *ddl) {
+  SSqlRes *pRes = &pSql->res;
+
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  int32_t numOfRows = 1;
+  if (strlen(ddl) == 0) {
+    
+  }
+  tscInitResObjForLocalQuery(pSql, numOfRows, rowLen);
+
+  TAOS_FIELD *pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, 0);
+  char* dst = pRes->data + tscFieldInfoGetOffset(pQueryInfo, 0) * numOfRows;
+  STR_WITH_MAXSIZE_TO_VARSTR(dst, tableName, pField->bytes);
+
+  pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, 1);
+  dst = pRes->data + tscFieldInfoGetOffset(pQueryInfo, 1) * numOfRows;
+  STR_WITH_MAXSIZE_TO_VARSTR(dst, ddl, pField->bytes);
+  return 0;
+}
+static int32_t tscSCreateBuildResult(SSqlObj *pSql, BuildType type, const char *str, const char *result) {
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0); 
+  int32_t rowLen = tscSCreateBuildResultFields(pSql, type, result);
+
+  tscFieldInfoUpdateOffset(pQueryInfo);
+  return tscSCreateSetValueToResObj(pSql, rowLen, str, result);  
+}
+int32_t tscRebuildCreateTableStatement(void *param,char *result) {
+  SCreateBuilder *builder = (SCreateBuilder *)param;
+  int32_t code = TSDB_CODE_SUCCESS;
+
+  char *buf = calloc(1,TSDB_MAX_BINARY_LEN);
+  if (buf == NULL) {
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  code = tscGetTableTagValue(builder, buf);
+  if (code == TSDB_CODE_SUCCESS) {
+    snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "CREATE TABLE %s USING %s TAGS %s", builder->buf, builder->sTableName, buf);
+    code = tscSCreateBuildResult(builder->pParentSql, SCREATE_BUILD_TABLE, builder->buf, result);    
+  }  
+  free(buf);
+  return code;
+}
+
+static int32_t tscGetDBInfo(SCreateBuilder *builder, char *result) {
+  TAOS_ROW row = tscFetchRow(builder);
+  if (row == NULL) {
+   return TSDB_CODE_MND_DB_NOT_SELECTED; 
+  }
+  const char *showColumns[] = {"REPLICA", "QUORUM", "DAYS", "KEEP", "BLOCKS", NULL};
+
+  SSqlObj *pSql = builder->pInterSql;
+  TAOS_FIELD *fields = taos_fetch_fields(pSql);
+  int num_fields = taos_num_fields(pSql);
+
+  char buf[TSDB_DB_NAME_LEN + 64] = {0}; 
+  do {
+    int32_t* lengths = taos_fetch_lengths(pSql);  
+    int32_t ret = tscGetNthFieldResult(row, fields, lengths, 0, buf);
+    if (0 == ret && STR_NOCASE_EQUAL(buf, strlen(buf), builder->buf, strlen(builder->buf))) {
+      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "CREATE DATABASE %s", buf);  
+      for (int i = 1; i < num_fields; i++) {
+        for (int j = 0; showColumns[j] != NULL; j++) {
+          if (STR_NOCASE_EQUAL(fields[i].name, strlen(fields[i].name), showColumns[j], strlen(showColumns[j]))) {
+            memset(buf, 0, sizeof(buf));
+            ret = tscGetNthFieldResult(row, fields, lengths, i, buf);
+            if (ret == 0) {
+              snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), " %s %s", showColumns[j], buf); 
+            }
+          }
+        }
+      }
+      break;
+    } 
+    
+    row = tscFetchRow(builder);
+  } while (row != NULL);
+
+  if (0 == strlen(result)) {
+   return TSDB_CODE_MND_DB_NOT_SELECTED; 
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+int32_t tscRebuildCreateDBStatement(void *param,char *result) {
+  SCreateBuilder *builder = (SCreateBuilder *)param;
+  int32_t code = TSDB_CODE_SUCCESS;
+
+  char *buf = calloc(1, TSDB_MAX_BINARY_LEN);
+  if (buf == NULL) {
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+  code = tscGetDBInfo(param, buf);  
+  if (code == TSDB_CODE_SUCCESS) {
+    code = tscSCreateBuildResult(builder->pParentSql, SCREATE_BUILD_DB, builder->buf, buf);    
+  }
+  free(buf);
+  return code;
+}
+
+static int32_t tscGetTableTagColumnName(SSqlObj *pSql, char **result) {
+  char *buf = (char *)malloc(TSDB_MAX_BINARY_LEN);
+  if (buf == NULL) {
+    return TSDB_CODE_TSC_OUT_OF_MEMORY; 
+  }
+  buf[0] = 0;
+
+  STableMeta *pMeta = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0, 0)->pTableMeta; 
+  if (pMeta->tableType == TSDB_SUPER_TABLE || pMeta->tableType == TSDB_NORMAL_TABLE ||
+      pMeta->tableType == TSDB_STREAM_TABLE) {
+    free(buf);
+    return TSDB_CODE_TSC_INVALID_VALUE;
+  } 
+
+  SSchema *pTagsSchema = tscGetTableTagSchema(pMeta);  
+  int32_t numOfTags = tscGetNumOfTags(pMeta);
+  for (int32_t i = 0; i < numOfTags; i++) {
+    if (i != numOfTags - 1) {
+      snprintf(buf + strlen(buf), TSDB_MAX_BINARY_LEN - strlen(buf), "%s,", pTagsSchema[i].name);  
+    } else {
+      snprintf(buf + strlen(buf), TSDB_MAX_BINARY_LEN - strlen(buf), "%s", pTagsSchema[i].name);
+    }
+  }   
+
+  *result = buf;
+  return TSDB_CODE_SUCCESS;
+}  
+static int32_t tscRebuildDDLForSubTable(SSqlObj *pSql, const char *tableName, char *ddl) {
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+
+  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+  STableMeta *    pMeta = pTableMetaInfo->pTableMeta;
+
+  SSqlObj *pInterSql = (SSqlObj *)calloc(1, sizeof(SSqlObj)); 
+  if (pInterSql == NULL) {
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }  
+
+  SCreateBuilder *param = (SCreateBuilder *)malloc(sizeof(SCreateBuilder));    
+  if (param == NULL) {
+    free(pInterSql);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  char fullName[TSDB_TABLE_FNAME_LEN] = {0};
+  extractDBName(pTableMetaInfo->name, fullName);
+  extractTableName(pMeta->sTableId, param->sTableName);
+  snprintf(fullName + strlen(fullName), TSDB_TABLE_FNAME_LEN - strlen(fullName),  ".%s", param->sTableName);
+  extractTableName(pTableMetaInfo->name, param->buf);
+
+  //tstrncpy(param->tableName, pTableMetaInfo->name, TSDB_TABLE_FNAME_LEN);
+  param->pParentSql = pSql;
+  param->pInterSql  = pInterSql;
+  param->fp         = tscRebuildCreateTableStatement;
+  param->callStage  = SCREATE_CALLBACK_QUERY;
+
+  char *query = (char *)calloc(1, TSDB_MAX_BINARY_LEN); 
+  if (query == NULL) {
+    free(param);
+    free(pInterSql);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  char *columns = NULL;
+  int32_t code = tscGetTableTagColumnName(pSql, &columns) ;
+  if (code != TSDB_CODE_SUCCESS) {
+    free(param); 
+    free(pInterSql);
+    return code;
+  }
+
+  snprintf(query + strlen(query), TSDB_MAX_BINARY_LEN - strlen(query), "SELECT %s FROM %s WHERE TBNAME IN(\'%s\')", columns, fullName, param->buf);
+  doAsyncQuery(pSql->pTscObj, pInterSql, tscSCreateCallBack, param, query, strlen(query));
+  free(query);
+  free(columns);
+
+  return TSDB_CODE_TSC_ACTION_IN_PROGRESS; 
+}
+static int32_t tscRebuildDDLForNormalTable(SSqlObj *pSql, const char *tableName, char *ddl) {
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+  STableMeta *    pMeta = pTableMetaInfo->pTableMeta;
+
+  int32_t numOfRows = tscGetNumOfColumns(pMeta);
+  SSchema *pSchema = tscGetTableSchema(pMeta);
+
+  char *result = ddl;
+  sprintf(result, "create table %s (", tableName);
+  for (int32_t i = 0; i < numOfRows; ++i) {
+    uint8_t type = pSchema[i].type;
+    if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {
+      sprintf(result + strlen(result), "%s %s(%d),", pSchema[i].name,tDataTypeDesc[pSchema[i].type].aName,pSchema->bytes);
+    } else {
+      sprintf(result + strlen(result), "%s %s,", pSchema[i].name, tDataTypeDesc[pSchema[i].type].aName); 
+    }
+  }
+  sprintf(result + strlen(result) - 1, "%s", ")");
+
+  return TSDB_CODE_SUCCESS;
+}
+static int32_t tscRebuildDDLForSuperTable(SSqlObj *pSql, const char *tableName, char *ddl) {
+  char *result = ddl;
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+  STableMeta *    pMeta = pTableMetaInfo->pTableMeta;
+
+  int32_t numOfRows = tscGetNumOfColumns(pMeta);
+  int32_t totalRows = numOfRows + tscGetNumOfTags(pMeta);
+  SSchema *pSchema = tscGetTableSchema(pMeta);
+
+  sprintf(result, "create table %s (", tableName);
+  for (int32_t i = 0; i < numOfRows; ++i) {
+    uint8_t type = pSchema[i].type;
+    if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {
+      sprintf(result + strlen(result), "%s %s(%d),", pSchema[i].name,tDataTypeDesc[pSchema[i].type].aName,pSchema->bytes);
+    } else {
+      sprintf(result + strlen(result), "%s %s,", pSchema[i].name, tDataTypeDesc[type].aName); 
+    }
+  }
+  sprintf(result + strlen(result) - 1, "%s ", ")");
+
+  sprintf(result + strlen(result), "TAGS (");
+  for (int32_t i = numOfRows; i < totalRows; i++) {
+    uint8_t type = pSchema[i].type;
+    if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {
+      sprintf(result + strlen(result), "%s %s(%d),", pSchema[i].name,tDataTypeDesc[pSchema[i].type].aName,pSchema->bytes);
+    } else {
+      sprintf(result + strlen(result), "%s %s,", pSchema[i].name, tDataTypeDesc[type].aName); 
+    }
+
+  }
+  sprintf(result + strlen(result) - 1, "%s", ")");
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t tscProcessShowCreateTable(SSqlObj *pSql) {
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+  assert(pTableMetaInfo->pTableMeta != NULL);
+
+  char tableName[TSDB_TABLE_NAME_LEN] = {0};
+  extractTableName(pTableMetaInfo->name, tableName);
+
+  char result[TSDB_MAX_BYTES_PER_ROW] = {0};
+  int32_t code = TSDB_CODE_SUCCESS;
+  if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
+    code = tscRebuildDDLForSuperTable(pSql, tableName, result);
+  } else if (UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo)) {
+    code = tscRebuildDDLForNormalTable(pSql, tableName, result);
+  } else if (UTIL_TABLE_IS_CHILD_TABLE(pTableMetaInfo)) {
+    code = tscRebuildDDLForSubTable(pSql, tableName, result);
+  } else {
+    code = TSDB_CODE_TSC_INVALID_VALUE;
+  }
+
+  if (code != TSDB_CODE_SUCCESS) {
+    return code;
+  }
+  return tscSCreateBuildResult(pSql, SCREATE_BUILD_TABLE, tableName, result);
+}
+
+static int32_t tscProcessShowCreateDatabase(SSqlObj *pSql) {
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+
+  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+
+  SSqlObj *pInterSql = (SSqlObj *)calloc(1, sizeof(SSqlObj)); 
+  if (pInterSql == NULL) {
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }  
+
+  SCreateBuilder *param = (SCreateBuilder *)malloc(sizeof(SCreateBuilder));    
+  if (param == NULL) {
+    free(pInterSql);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+  extractTableName(pTableMetaInfo->name, param->buf);
+  param->pParentSql = pSql;
+  param->pInterSql  = pInterSql;
+  param->fp         = tscRebuildCreateDBStatement;
+  param->callStage  = SCREATE_CALLBACK_QUERY;
+   
+  const char *query = "show databases";
+  doAsyncQuery(pSql->pTscObj, pInterSql, tscSCreateCallBack, param, query, strlen(query));
+  return TSDB_CODE_TSC_ACTION_IN_PROGRESS;
+}
 static int32_t tscProcessCurrentUser(SSqlObj *pSql) {
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
-  
+
   SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
   pExpr->resBytes = TSDB_USER_LEN + TSDB_DATA_TYPE_BINARY;
   pExpr->resType = TSDB_DATA_TYPE_BINARY;
-  
+
   char* vx = calloc(1, pExpr->resBytes);
   if (vx == NULL) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -288,7 +809,7 @@ static int32_t tscProcessCurrentUser(SSqlObj *pSql) {
 
   size_t size = sizeof(pSql->pTscObj->user);
   STR_WITH_MAXSIZE_TO_VARSTR(vx, pSql->pTscObj->user, size);
-  
+
   tscSetLocalQueryResult(pSql, vx, pExpr->aliasName, pExpr->resType, pExpr->resBytes);
   free(vx);
 
@@ -298,15 +819,15 @@ static int32_t tscProcessCurrentUser(SSqlObj *pSql) {
 static int32_t tscProcessCurrentDB(SSqlObj *pSql) {
   char db[TSDB_DB_NAME_LEN] = {0};
   extractDBName(pSql->pTscObj->db, db);
-  
+
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, pSql->cmd.clauseIndex);
-  
+
   SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
   pExpr->resType = TSDB_DATA_TYPE_BINARY;
-  
+
   size_t t = strlen(db);
   pExpr->resBytes = TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE;
-  
+
   char* vx = calloc(1, pExpr->resBytes);
   if (vx == NULL) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -317,7 +838,7 @@ static int32_t tscProcessCurrentDB(SSqlObj *pSql) {
   } else {
     STR_WITH_SIZE_TO_VARSTR(vx, db, (VarDataLenT)t);
   }
-  
+
   tscSetLocalQueryResult(pSql, vx, pExpr->aliasName, pExpr->resType, pExpr->resBytes);
   free(vx);
 
@@ -327,49 +848,53 @@ static int32_t tscProcessCurrentDB(SSqlObj *pSql) {
 static int32_t tscProcessServerVer(SSqlObj *pSql) {
   const char* v = pSql->pTscObj->sversion;
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, pSql->cmd.clauseIndex);
-  
+
   SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
   pExpr->resType = TSDB_DATA_TYPE_BINARY;
-  
+
   size_t t = strlen(v);
   pExpr->resBytes = (int16_t)(t + VARSTR_HEADER_SIZE);
-  
+
   char* vx = calloc(1, pExpr->resBytes);
   if (vx == NULL) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
+
   }
 
   STR_WITH_SIZE_TO_VARSTR(vx, v, (VarDataLenT)t);
   tscSetLocalQueryResult(pSql, vx, pExpr->aliasName, pExpr->resType, pExpr->resBytes);
-  
+
   free(vx);
   return TSDB_CODE_SUCCESS;
+
 }
 
 static int32_t tscProcessClientVer(SSqlObj *pSql) {
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
-  
+
   SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
   pExpr->resType = TSDB_DATA_TYPE_BINARY;
-  
+
   size_t t = strlen(version);
   pExpr->resBytes = (int16_t)(t + VARSTR_HEADER_SIZE);
-  
+
   char* v = calloc(1, pExpr->resBytes);
   if (v == NULL) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
+
   }
 
   STR_WITH_SIZE_TO_VARSTR(v, version, (VarDataLenT)t);
   tscSetLocalQueryResult(pSql, v, pExpr->aliasName, pExpr->resType, pExpr->resBytes);
-  
+
   free(v);
   return TSDB_CODE_SUCCESS;
+
 }
 
 static int32_t tscProcessServStatus(SSqlObj *pSql) {
   STscObj* pObj = pSql->pTscObj;
-  
+
   if (pObj->pHb != NULL) {
     if (pObj->pHb->res.code == TSDB_CODE_RPC_NETWORK_UNAVAIL) {
       pSql->res.code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
@@ -380,9 +905,9 @@ static int32_t tscProcessServStatus(SSqlObj *pSql) {
       return pSql->res.code;
     }
   }
-  
+
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
-  
+
   SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
   int32_t val = 1;
   tscSetLocalQueryResult(pSql, (char*) &val, pExpr->aliasName, TSDB_DATA_TYPE_INT, sizeof(int32_t));
@@ -394,23 +919,23 @@ void tscSetLocalQueryResult(SSqlObj *pSql, const char *val, const char *columnNa
   SSqlRes *pRes = &pSql->res;
 
   pCmd->numOfCols = 1;
-  
+
   SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
   pQueryInfo->order.order = TSDB_ORDER_ASC;
-  
+
   tscFieldInfoClear(&pQueryInfo->fieldsInfo);
   pQueryInfo->fieldsInfo.pFields = taosArrayInit(1, sizeof(TAOS_FIELD));
   pQueryInfo->fieldsInfo.pSupportInfo = taosArrayInit(1, sizeof(SFieldSupInfo));
-  
+
   TAOS_FIELD f = tscCreateField((int8_t)type, columnName, (int16_t)valueLength);
   tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  
+
   tscInitResObjForLocalQuery(pSql, 1, (int32_t)valueLength);
 
   TAOS_FIELD *pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, 0);
   SFieldSupInfo* pInfo = tscFieldInfoGetSupp(&pQueryInfo->fieldsInfo, 0);
   pInfo->pSqlExpr = taosArrayGetP(pQueryInfo->exprList, 0);
-  
+
   memcpy(pRes->data, val, pField->bytes);
 }
 
@@ -429,6 +954,10 @@ int tscProcessLocalCmd(SSqlObj *pSql) {
      */
     pRes->qhandle = 0x1;
     pRes->numOfRows = 0;
+  } else if (pCmd->command == TSDB_SQL_SHOW_CREATE_TABLE) {
+    pRes->code = tscProcessShowCreateTable(pSql); 
+  } else if (pCmd->command == TSDB_SQL_SHOW_CREATE_DATABASE) {
+    pRes->code = tscProcessShowCreateDatabase(pSql); 
   } else if (pCmd->command == TSDB_SQL_RESET_CACHE) {
     taosCacheEmpty(tscCacheHandle);
     pRes->code = TSDB_CODE_SUCCESS;
@@ -448,12 +977,13 @@ int tscProcessLocalCmd(SSqlObj *pSql) {
   }
 
   // keep the code in local variable in order to avoid invalid read in case of async query
+
   int32_t code = pRes->code;
   if (code == TSDB_CODE_SUCCESS) {
     (*pSql->fp)(pSql->param, pSql, code);
+  } else if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS){
   } else {
     tscQueueAsyncRes(pSql);
   }
-
   return code;
 }
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index c248b08ddd..631ee4acc1 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -366,7 +366,40 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
       return tscGetTableMeta(pSql, pTableMetaInfo);
     }
+    case TSDB_SQL_SHOW_CREATE_TABLE: {
+      SStrToken*  pToken = &pInfo->pDCLInfo->a[0];
+      const char* msg1 = "invalid table name";
+      const char* msg2 = "table name is too long";
 
+      if (tscValidateName(pToken) != TSDB_CODE_SUCCESS) {
+        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      }
+
+      if (!tscValidateTableNameLength(pToken->n)) {
+        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      }
+
+      if (tscSetTableFullName(pTableMetaInfo, pToken, pSql) != TSDB_CODE_SUCCESS) {
+        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      }
+      return tscGetTableMeta(pSql, pTableMetaInfo);
+    }
+    case TSDB_SQL_SHOW_CREATE_DATABASE: {
+      const char* msg1 = "invalid database name";
+      const char* msg2 = "table name is too long";
+      SStrToken*  pToken = &pInfo->pDCLInfo->a[0];
+
+      if (tscValidateName(pToken) != TSDB_CODE_SUCCESS) {
+        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      }
+      if (pToken->n > TSDB_DB_NAME_LEN) {
+        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      }
+      if (tscSetTableFullName(pTableMetaInfo, pToken, pSql) != TSDB_CODE_SUCCESS) {
+        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      }
+      return TSDB_CODE_SUCCESS; 
+    }                                
     case TSDB_SQL_CFG_DNODE: {
       const char* msg2 = "invalid configure options or values, such as resetlog / debugFlag 135 / balance 'vnode:2-dnode:2' / monitor 1 ";
       const char* msg3 = "invalid dnode ep";
diff --git a/src/client/src/tscSchemaUtil.c b/src/client/src/tscSchemaUtil.c
index 244bb81164..1e841c68fd 100644
--- a/src/client/src/tscSchemaUtil.c
+++ b/src/client/src/tscSchemaUtil.c
@@ -170,6 +170,7 @@ STableMeta* tscCreateTableMetaFromMsg(STableMetaMsg* pTableMetaMsg, size_t* size
 
   pTableMeta->sversion = pTableMetaMsg->sversion;
   pTableMeta->tversion = pTableMetaMsg->tversion;
+  tstrncpy(pTableMeta->sTableId, pTableMetaMsg->sTableId, TSDB_TABLE_FNAME_LEN);
   
   memcpy(pTableMeta->schema, pTableMetaMsg->schema, schemaSize);
   
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index ae2013cd2b..9c8b94cc2d 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -2072,6 +2072,9 @@ int tscProcessAlterDbMsgRsp(SSqlObj *pSql) {
   UNUSED(pSql);
   return 0;
 }
+int tscProcessShowCreateRsp(SSqlObj *pSql) {
+  return tscLocalResultCommonBuilder(pSql, 1);
+}
 
 int tscProcessQueryRsp(SSqlObj *pSql) {
   SSqlRes *pRes = &pSql->res;
@@ -2343,6 +2346,10 @@ void tscInitMsgsFp() {
   tscProcessMsgRsp[TSDB_SQL_ALTER_TABLE] = tscProcessAlterTableMsgRsp;
   tscProcessMsgRsp[TSDB_SQL_ALTER_DB] = tscProcessAlterDbMsgRsp;
 
+  tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_TABLE] = tscProcessShowCreateRsp;
+  tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_DATABASE] = tscProcessShowCreateRsp;
+  
+
   tscKeepConn[TSDB_SQL_SHOW] = 1;
   tscKeepConn[TSDB_SQL_RETRIEVE] = 1;
   tscKeepConn[TSDB_SQL_SELECT] = 1;
diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index 9fa4db999f..24768c243b 100644
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -451,6 +451,8 @@ TAOS_ROW taos_fetch_row(TAOS_RES *res) {
        pCmd->command == TSDB_SQL_TABLE_JOIN_RETRIEVE ||
        pCmd->command == TSDB_SQL_FETCH ||
        pCmd->command == TSDB_SQL_SHOW ||
+       pCmd->command == TSDB_SQL_SHOW_CREATE_TABLE ||
+       pCmd->command == TSDB_SQL_SHOW_CREATE_DATABASE ||
        pCmd->command == TSDB_SQL_SELECT ||
        pCmd->command == TSDB_SQL_DESCRIBE_TABLE ||
        pCmd->command == TSDB_SQL_SERV_STATUS ||
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index e264fa9b33..abfe8b8813 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -23,6 +23,7 @@
 #include "tscSubquery.h"
 #include "tschemautil.h"
 #include "tsclient.h"
+#include "tscSubquery.h"
 
 typedef struct SInsertSupporter {
   SSubqueryState* pState;
diff --git a/src/common/inc/tcmdtype.h b/src/common/inc/tcmdtype.h
index 90fb5bf478..69bbccd67e 100644
--- a/src/common/inc/tcmdtype.h
+++ b/src/common/inc/tcmdtype.h
@@ -78,6 +78,9 @@ enum {
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_RETRIEVE_LOCALMERGE, "retrieve-localmerge" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_TABLE_JOIN_RETRIEVE, "join-retrieve" )
 
+  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_SHOW_CREATE_TABLE, "show-create-table")
+  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_SHOW_CREATE_DATABASE, "show-create-database")
+
   /*
    * build empty result instead of accessing dnode to fetch result
    * reset the client cache
diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h
index e2df886320..f33d26c53b 100644
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
@@ -677,6 +677,7 @@ typedef struct {
 typedef struct STableMetaMsg {
   int32_t       contLen;
   char          tableId[TSDB_TABLE_FNAME_LEN];   // table id
+  char          sTableId[TSDB_TABLE_FNAME_LEN];
   uint8_t       numOfTags;
   uint8_t       precision;
   uint8_t       tableType;
diff --git a/src/inc/ttokendef.h b/src/inc/ttokendef.h
index c5831a9b8a..bc49d3c81b 100644
--- a/src/inc/ttokendef.h
+++ b/src/inc/ttokendef.h
@@ -16,105 +16,105 @@
 #ifndef TDENGINE_TTOKENDEF_H
 #define TDENGINE_TTOKENDEF_H
 
-#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_OR                              13
-#define TK_AND                             14
-#define TK_NOT                             15
-#define TK_EQ                              16
-#define TK_NE                              17
-#define TK_ISNULL                          18
-#define TK_NOTNULL                         19
-#define TK_IS                              20
-#define TK_LIKE                            21
-#define TK_GLOB                            22
-#define TK_BETWEEN                         23
-#define TK_IN                              24
-#define TK_GT                              25
-#define TK_GE                              26
-#define TK_LT                              27
-#define TK_LE                              28
-#define TK_BITAND                          29
-#define TK_BITOR                           30
-#define TK_LSHIFT                          31
-#define TK_RSHIFT                          32
-#define TK_PLUS                            33
-#define TK_MINUS                           34
-#define TK_DIVIDE                          35
-#define TK_TIMES                           36
-#define TK_STAR                            37
-#define TK_SLASH                           38
-#define TK_REM                             39
-#define TK_CONCAT                          40
-#define TK_UMINUS                          41
-#define TK_UPLUS                           42
-#define TK_BITNOT                          43
-#define TK_SHOW                            44
-#define TK_DATABASES                       45
-#define TK_MNODES                          46
-#define TK_DNODES                          47
-#define TK_ACCOUNTS                        48
-#define TK_USERS                           49
-#define TK_MODULES                         50
-#define TK_QUERIES                         51
-#define TK_CONNECTIONS                     52
-#define TK_STREAMS                         53
-#define TK_VARIABLES                       54
-#define TK_SCORES                          55
-#define TK_GRANTS                          56
-#define TK_VNODES                          57
-#define TK_IPTOKEN                         58
-#define TK_DOT                             59
-#define TK_TABLES                          60
-#define TK_STABLES                         61
-#define TK_VGROUPS                         62
-#define TK_DROP                            63
-#define TK_TABLE                           64
-#define TK_DATABASE                        65
-#define TK_DNODE                           66
-#define TK_USER                            67
-#define TK_ACCOUNT                         68
-#define TK_USE                             69
-#define TK_DESCRIBE                        70
-#define TK_ALTER                           71
-#define TK_PASS                            72
-#define TK_PRIVILEGE                       73
-#define TK_LOCAL                           74
-#define TK_IF                              75
-#define TK_EXISTS                          76
-#define TK_CREATE                          77
-#define TK_PPS                             78
-#define TK_TSERIES                         79
-#define TK_DBS                             80
-#define TK_STORAGE                         81
-#define TK_QTIME                           82
-#define TK_CONNS                           83
-#define TK_STATE                           84
-#define TK_KEEP                            85
-#define TK_CACHE                           86
-#define TK_REPLICA                         87
-#define TK_QUORUM                          88
-#define TK_DAYS                            89
-#define TK_MINROWS                         90
-#define TK_MAXROWS                         91
-#define TK_BLOCKS                          92
-#define TK_CTIME                           93
-#define TK_WAL                             94
-#define TK_FSYNC                           95
-#define TK_COMP                            96
-#define TK_PRECISION                       97
-#define TK_LP                              98
-#define TK_RP                              99
+#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_OR                             13
+#define TK_AND                            14
+#define TK_NOT                            15
+#define TK_EQ                             16
+#define TK_NE                             17
+#define TK_ISNULL                         18
+#define TK_NOTNULL                        19
+#define TK_IS                             20
+#define TK_LIKE                           21
+#define TK_GLOB                           22
+#define TK_BETWEEN                        23
+#define TK_IN                             24
+#define TK_GT                             25
+#define TK_GE                             26
+#define TK_LT                             27
+#define TK_LE                             28
+#define TK_BITAND                         29
+#define TK_BITOR                          30
+#define TK_LSHIFT                         31
+#define TK_RSHIFT                         32
+#define TK_PLUS                           33
+#define TK_MINUS                          34
+#define TK_DIVIDE                         35
+#define TK_TIMES                          36
+#define TK_STAR                           37
+#define TK_SLASH                          38
+#define TK_REM                            39
+#define TK_CONCAT                         40
+#define TK_UMINUS                         41
+#define TK_UPLUS                          42
+#define TK_BITNOT                         43
+#define TK_SHOW                           44
+#define TK_DATABASES                      45
+#define TK_MNODES                         46
+#define TK_DNODES                         47
+#define TK_ACCOUNTS                       48
+#define TK_USERS                          49
+#define TK_MODULES                        50
+#define TK_QUERIES                        51
+#define TK_CONNECTIONS                    52
+#define TK_STREAMS                        53
+#define TK_VARIABLES                      54
+#define TK_SCORES                         55
+#define TK_GRANTS                         56
+#define TK_VNODES                         57
+#define TK_IPTOKEN                        58
+#define TK_DOT                            59
+#define TK_CREATE                         60
+#define TK_TABLE                          61
+#define TK_DATABASE                       62
+#define TK_TABLES                         63
+#define TK_STABLES                        64
+#define TK_VGROUPS                        65
+#define TK_DROP                           66
+#define TK_DNODE                          67
+#define TK_USER                           68
+#define TK_ACCOUNT                        69
+#define TK_USE                            70
+#define TK_DESCRIBE                       71
+#define TK_ALTER                          72
+#define TK_PASS                           73
+#define TK_PRIVILEGE                      74
+#define TK_LOCAL                          75
+#define TK_IF                             76
+#define TK_EXISTS                         77
+#define TK_PPS                            78
+#define TK_TSERIES                        79
+#define TK_DBS                            80
+#define TK_STORAGE                        81
+#define TK_QTIME                          82
+#define TK_CONNS                          83
+#define TK_STATE                          84
+#define TK_KEEP                           85
+#define TK_CACHE                          86
+#define TK_REPLICA                        87
+#define TK_QUORUM                         88
+#define TK_DAYS                           89
+#define TK_MINROWS                        90
+#define TK_MAXROWS                        91
+#define TK_BLOCKS                         92
+#define TK_CTIME                          93
+#define TK_WAL                            94
+#define TK_FSYNC                          95
+#define TK_COMP                           96
+#define TK_PRECISION                      97
+#define TK_LP                             98
+#define TK_RP                             99
 #define TK_TAGS                           100
 #define TK_USING                          101
 #define TK_AS                             102
diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index 4400927e9b..72e4f196a7 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -2090,6 +2090,9 @@ static int32_t mnodeDoGetChildTableMeta(SMnodeMsg *pMsg, STableMetaMsg *pMeta) {
   pMeta->precision = pDb->cfg.precision;
   pMeta->tableType = pTable->info.type;
   tstrncpy(pMeta->tableId, pTable->info.tableId, TSDB_TABLE_FNAME_LEN);
+  if (pTable->superTable) {
+    tstrncpy(pMeta->sTableId, pTable->superTable->info.tableId, TSDB_TABLE_FNAME_LEN);
+  }
 
   if (pTable->info.type == TSDB_CHILD_TABLE) {
     pMeta->sversion     = htons(pTable->superTable->sversion);
diff --git a/src/query/inc/sql.y b/src/query/inc/sql.y
index 79aec2f349..0196ff68a2 100644
--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
@@ -80,6 +80,7 @@ cmd ::= SHOW GRANTS.     { setShowOptions(pInfo, TSDB_MGMT_TABLE_GRANTS, 0, 0);
 cmd ::= SHOW VNODES.                { setShowOptions(pInfo, TSDB_MGMT_TABLE_VNODES, 0, 0); }
 cmd ::= SHOW VNODES IPTOKEN(X).     { setShowOptions(pInfo, TSDB_MGMT_TABLE_VNODES, &X, 0); }
 
+
 %type dbPrefix {SStrToken}
 dbPrefix(A) ::=.                   {A.n = 0; A.type = 0;}
 dbPrefix(A) ::= ids(X) DOT.        {A = X;  }
@@ -88,6 +89,15 @@ dbPrefix(A) ::= ids(X) DOT.        {A = X;  }
 cpxName(A) ::= .             {A.n = 0;  }
 cpxName(A) ::= DOT ids(Y).   {A = Y; A.n += 1;    }
 
+cmd ::= SHOW CREATE TABLE ids(X) cpxName(Y).    {
+   X.n += Y.n;
+   setDCLSQLElems(pInfo, TSDB_SQL_SHOW_CREATE_TABLE, 1, &X);
+}    
+
+cmd ::= SHOW CREATE DATABASE ids(X). {
+  setDCLSQLElems(pInfo, TSDB_SQL_SHOW_CREATE_DATABASE, 1, &X);
+} 
+
 cmd ::= SHOW dbPrefix(X) TABLES.         {
     setShowOptions(pInfo, TSDB_MGMT_TABLE_TABLE, &X, 0);
 }

From 48ac122e4ab17f08f262d0d1a77fc473d90d560e Mon Sep 17 00:00:00 2001
From: yihaoDeng <yhdeng@taosdata.com>
Date: Sun, 13 Sep 2020 21:42:47 +0000
Subject: [PATCH 02/35] fix bug

---
 src/client/src/tscLocal.c | 27 +++++++++++++--------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/src/client/src/tscLocal.c b/src/client/src/tscLocal.c
index 6d48350f73..b25573e255 100644
--- a/src/client/src/tscLocal.c
+++ b/src/client/src/tscLocal.c
@@ -699,9 +699,9 @@ static int32_t tscRebuildDDLForNormalTable(SSqlObj *pSql, const char *tableName,
   for (int32_t i = 0; i < numOfRows; ++i) {
     uint8_t type = pSchema[i].type;
     if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {
-      sprintf(result + strlen(result), "%s %s(%d),", pSchema[i].name,tDataTypeDesc[pSchema[i].type].aName,pSchema->bytes);
+      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s %s(%d),", pSchema[i].name,tDataTypeDesc[pSchema[i].type].aName,pSchema->bytes);
     } else {
-      sprintf(result + strlen(result), "%s %s,", pSchema[i].name, tDataTypeDesc[pSchema[i].type].aName); 
+      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s %s,", pSchema[i].name, tDataTypeDesc[pSchema[i].type].aName); 
     }
   }
   sprintf(result + strlen(result) - 1, "%s", ")");
@@ -722,22 +722,20 @@ static int32_t tscRebuildDDLForSuperTable(SSqlObj *pSql, const char *tableName,
   for (int32_t i = 0; i < numOfRows; ++i) {
     uint8_t type = pSchema[i].type;
     if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {
-      sprintf(result + strlen(result), "%s %s(%d),", pSchema[i].name,tDataTypeDesc[pSchema[i].type].aName,pSchema->bytes);
+      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result),"%s %s(%d),", pSchema[i].name,tDataTypeDesc[pSchema[i].type].aName,pSchema->bytes);
     } else {
-      sprintf(result + strlen(result), "%s %s,", pSchema[i].name, tDataTypeDesc[type].aName); 
+      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s %s,", pSchema[i].name, tDataTypeDesc[type].aName); 
     }
   }
-  sprintf(result + strlen(result) - 1, "%s ", ")");
+  snprintf(result + strlen(result) - 1, TSDB_MAX_BINARY_LEN - strlen(result), "%s %s", ")", "TAGS (");
 
-  sprintf(result + strlen(result), "TAGS (");
   for (int32_t i = numOfRows; i < totalRows; i++) {
     uint8_t type = pSchema[i].type;
     if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {
-      sprintf(result + strlen(result), "%s %s(%d),", pSchema[i].name,tDataTypeDesc[pSchema[i].type].aName,pSchema->bytes);
+      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s %s(%d),", pSchema[i].name,tDataTypeDesc[pSchema[i].type].aName,pSchema->bytes);
     } else {
-      sprintf(result + strlen(result), "%s %s,", pSchema[i].name, tDataTypeDesc[type].aName); 
+      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s %s,", pSchema[i].name, tDataTypeDesc[type].aName); 
     }
-
   }
   sprintf(result + strlen(result) - 1, "%s", ")");
 
@@ -752,7 +750,7 @@ static int32_t tscProcessShowCreateTable(SSqlObj *pSql) {
   char tableName[TSDB_TABLE_NAME_LEN] = {0};
   extractTableName(pTableMetaInfo->name, tableName);
 
-  char result[TSDB_MAX_BYTES_PER_ROW] = {0};
+  char *result = (char *)calloc(1, TSDB_MAX_BINARY_LEN);
   int32_t code = TSDB_CODE_SUCCESS;
   if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
     code = tscRebuildDDLForSuperTable(pSql, tableName, result);
@@ -764,10 +762,11 @@ static int32_t tscProcessShowCreateTable(SSqlObj *pSql) {
     code = TSDB_CODE_TSC_INVALID_VALUE;
   }
 
-  if (code != TSDB_CODE_SUCCESS) {
-    return code;
-  }
-  return tscSCreateBuildResult(pSql, SCREATE_BUILD_TABLE, tableName, result);
+  if (code == TSDB_CODE_SUCCESS) {
+    code = tscSCreateBuildResult(pSql, SCREATE_BUILD_TABLE, tableName, result);
+  } 
+  free(result);
+  return code;
 }
 
 static int32_t tscProcessShowCreateDatabase(SSqlObj *pSql) {

From 670c6c7d87b97baefde6332bd4cae63b28a7c0b7 Mon Sep 17 00:00:00 2001
From: yihaoDeng <yhdeng@taosdata.com>
Date: Sun, 13 Sep 2020 21:59:59 +0000
Subject: [PATCH 03/35] fix bug

---
 src/client/src/tscLocal.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/client/src/tscLocal.c b/src/client/src/tscLocal.c
index b25573e255..c0a958a2c8 100644
--- a/src/client/src/tscLocal.c
+++ b/src/client/src/tscLocal.c
@@ -658,7 +658,6 @@ static int32_t tscRebuildDDLForSubTable(SSqlObj *pSql, const char *tableName, ch
   snprintf(fullName + strlen(fullName), TSDB_TABLE_FNAME_LEN - strlen(fullName),  ".%s", param->sTableName);
   extractTableName(pTableMetaInfo->name, param->buf);
 
-  //tstrncpy(param->tableName, pTableMetaInfo->name, TSDB_TABLE_FNAME_LEN);
   param->pParentSql = pSql;
   param->pInterSql  = pInterSql;
   param->fp         = tscRebuildCreateTableStatement;
@@ -676,6 +675,7 @@ static int32_t tscRebuildDDLForSubTable(SSqlObj *pSql, const char *tableName, ch
   if (code != TSDB_CODE_SUCCESS) {
     free(param); 
     free(pInterSql);
+    free(query);
     return code;
   }
 

From ed1267a0d75a84dc68f604a233fb4cbf0d9b6c34 Mon Sep 17 00:00:00 2001
From: yihaoDeng <yhdeng@taosdata.com>
Date: Sun, 13 Sep 2020 23:12:29 +0000
Subject: [PATCH 04/35] update sql.c

---
 src/inc/ttokendef.h |  200 +++---
 src/query/src/sql.c | 1679 ++++++++++++++++++++++---------------------
 2 files changed, 948 insertions(+), 931 deletions(-)

diff --git a/src/inc/ttokendef.h b/src/inc/ttokendef.h
index bc49d3c81b..a94cdaad15 100644
--- a/src/inc/ttokendef.h
+++ b/src/inc/ttokendef.h
@@ -16,105 +16,106 @@
 #ifndef TDENGINE_TTOKENDEF_H
 #define TDENGINE_TTOKENDEF_H
 
-#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_OR                             13
-#define TK_AND                            14
-#define TK_NOT                            15
-#define TK_EQ                             16
-#define TK_NE                             17
-#define TK_ISNULL                         18
-#define TK_NOTNULL                        19
-#define TK_IS                             20
-#define TK_LIKE                           21
-#define TK_GLOB                           22
-#define TK_BETWEEN                        23
-#define TK_IN                             24
-#define TK_GT                             25
-#define TK_GE                             26
-#define TK_LT                             27
-#define TK_LE                             28
-#define TK_BITAND                         29
-#define TK_BITOR                          30
-#define TK_LSHIFT                         31
-#define TK_RSHIFT                         32
-#define TK_PLUS                           33
-#define TK_MINUS                          34
-#define TK_DIVIDE                         35
-#define TK_TIMES                          36
-#define TK_STAR                           37
-#define TK_SLASH                          38
-#define TK_REM                            39
-#define TK_CONCAT                         40
-#define TK_UMINUS                         41
-#define TK_UPLUS                          42
-#define TK_BITNOT                         43
-#define TK_SHOW                           44
-#define TK_DATABASES                      45
-#define TK_MNODES                         46
-#define TK_DNODES                         47
-#define TK_ACCOUNTS                       48
-#define TK_USERS                          49
-#define TK_MODULES                        50
-#define TK_QUERIES                        51
-#define TK_CONNECTIONS                    52
-#define TK_STREAMS                        53
-#define TK_VARIABLES                      54
-#define TK_SCORES                         55
-#define TK_GRANTS                         56
-#define TK_VNODES                         57
-#define TK_IPTOKEN                        58
-#define TK_DOT                            59
-#define TK_CREATE                         60
-#define TK_TABLE                          61
-#define TK_DATABASE                       62
-#define TK_TABLES                         63
-#define TK_STABLES                        64
-#define TK_VGROUPS                        65
-#define TK_DROP                           66
-#define TK_DNODE                          67
-#define TK_USER                           68
-#define TK_ACCOUNT                        69
-#define TK_USE                            70
-#define TK_DESCRIBE                       71
-#define TK_ALTER                          72
-#define TK_PASS                           73
-#define TK_PRIVILEGE                      74
-#define TK_LOCAL                          75
-#define TK_IF                             76
-#define TK_EXISTS                         77
-#define TK_PPS                            78
-#define TK_TSERIES                        79
-#define TK_DBS                            80
-#define TK_STORAGE                        81
-#define TK_QTIME                          82
-#define TK_CONNS                          83
-#define TK_STATE                          84
-#define TK_KEEP                           85
-#define TK_CACHE                          86
-#define TK_REPLICA                        87
-#define TK_QUORUM                         88
-#define TK_DAYS                           89
-#define TK_MINROWS                        90
-#define TK_MAXROWS                        91
-#define TK_BLOCKS                         92
-#define TK_CTIME                          93
-#define TK_WAL                            94
-#define TK_FSYNC                          95
-#define TK_COMP                           96
-#define TK_PRECISION                      97
-#define TK_LP                             98
-#define TK_RP                             99
+
+#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_OR                              13
+#define TK_AND                             14
+#define TK_NOT                             15
+#define TK_EQ                              16
+#define TK_NE                              17
+#define TK_ISNULL                          18
+#define TK_NOTNULL                         19
+#define TK_IS                              20
+#define TK_LIKE                            21
+#define TK_GLOB                            22
+#define TK_BETWEEN                         23
+#define TK_IN                              24
+#define TK_GT                              25
+#define TK_GE                              26
+#define TK_LT                              27
+#define TK_LE                              28
+#define TK_BITAND                          29
+#define TK_BITOR                           30
+#define TK_LSHIFT                          31
+#define TK_RSHIFT                          32
+#define TK_PLUS                            33
+#define TK_MINUS                           34
+#define TK_DIVIDE                          35
+#define TK_TIMES                           36
+#define TK_STAR                            37
+#define TK_SLASH                           38
+#define TK_REM                             39
+#define TK_CONCAT                          40
+#define TK_UMINUS                          41
+#define TK_UPLUS                           42
+#define TK_BITNOT                          43
+#define TK_SHOW                            44
+#define TK_DATABASES                       45
+#define TK_MNODES                          46
+#define TK_DNODES                          47
+#define TK_ACCOUNTS                        48
+#define TK_USERS                           49
+#define TK_MODULES                         50
+#define TK_QUERIES                         51
+#define TK_CONNECTIONS                     52
+#define TK_STREAMS                         53
+#define TK_VARIABLES                       54
+#define TK_SCORES                          55
+#define TK_GRANTS                          56
+#define TK_VNODES                          57
+#define TK_IPTOKEN                         58
+#define TK_DOT                             59
+#define TK_CREATE                          60
+#define TK_TABLE                           61
+#define TK_DATABASE                        62
+#define TK_TABLES                          63
+#define TK_STABLES                         64
+#define TK_VGROUPS                         65
+#define TK_DROP                            66
+#define TK_DNODE                           67
+#define TK_USER                            68
+#define TK_ACCOUNT                         69
+#define TK_USE                             70
+#define TK_DESCRIBE                        71
+#define TK_ALTER                           72
+#define TK_PASS                            73
+#define TK_PRIVILEGE                       74
+#define TK_LOCAL                           75
+#define TK_IF                              76
+#define TK_EXISTS                          77
+#define TK_PPS                             78
+#define TK_TSERIES                         79
+#define TK_DBS                             80
+#define TK_STORAGE                         81
+#define TK_QTIME                           82
+#define TK_CONNS                           83
+#define TK_STATE                           84
+#define TK_KEEP                            85
+#define TK_CACHE                           86
+#define TK_REPLICA                         87
+#define TK_QUORUM                          88
+#define TK_DAYS                            89
+#define TK_MINROWS                         90
+#define TK_MAXROWS                         91
+#define TK_BLOCKS                          92
+#define TK_CTIME                           93
+#define TK_WAL                             94
+#define TK_FSYNC                           95
+#define TK_COMP                            96
+#define TK_PRECISION                       97
+#define TK_LP                              98
+#define TK_RP                              99
 #define TK_TAGS                           100
 #define TK_USING                          101
 #define TK_AS                             102
@@ -222,7 +223,6 @@
 #define TK_INTO                           204
 #define TK_VALUES                         205
 
-
 #define TK_SPACE                          300
 #define TK_COMMENT                        301
 #define TK_ILLEGAL                        302
diff --git a/src/query/src/sql.c b/src/query/src/sql.c
index 373e57963c..3c160aab3b 100644
--- a/src/query/src/sql.c
+++ b/src/query/src/sql.c
@@ -126,17 +126,17 @@ typedef union {
 #define ParseARG_FETCH SSqlInfo* pInfo = yypParser->pInfo
 #define ParseARG_STORE yypParser->pInfo = pInfo
 #define YYFALLBACK 1
-#define YYNSTATE             244
-#define YYNRULE              225
+#define YYNSTATE             248
+#define YYNRULE              227
 #define YYNTOKEN             206
-#define YY_MAX_SHIFT         243
-#define YY_MIN_SHIFTREDUCE   403
-#define YY_MAX_SHIFTREDUCE   627
-#define YY_ERROR_ACTION      628
-#define YY_ACCEPT_ACTION     629
-#define YY_NO_ACTION         630
-#define YY_MIN_REDUCE        631
-#define YY_MAX_REDUCE        855
+#define YY_MAX_SHIFT         247
+#define YY_MIN_SHIFTREDUCE   409
+#define YY_MAX_SHIFTREDUCE   635
+#define YY_ERROR_ACTION      636
+#define YY_ACCEPT_ACTION     637
+#define YY_NO_ACTION         638
+#define YY_MIN_REDUCE        639
+#define YY_MAX_REDUCE        865
 /************* End control #defines *******************************************/
 
 /* Define the yytestcase() macro to be a no-op if is not already defined
@@ -202,121 +202,122 @@ typedef union {
 **  yy_default[]       Default action for each state.
 **
 *********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (549)
+#define YY_ACTTAB_COUNT (555)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */   731,  444,  221,  729,  730,  629,  243,  510,  732,  445,
- /*    10 */   734,  735,  733,   41,   43,  526,   35,   36,  523,   11,
- /*    20 */   524,   29,  525,  444,  199,   39,   37,   40,   38,  155,
- /*    30 */   241,  445,  748,   34,   33,  219,  218,   32,   31,   30,
- /*    40 */    41,   43,  761,   35,   36,  136,  172,  173,   29,  137,
- /*    50 */    21,  199,   39,   37,   40,   38,  184,  141,  160,  843,
- /*    60 */    34,   33,  839,  772,   32,   31,   30,  404,  405,  406,
- /*    70 */   407,  408,  409,  410,  411,  412,  413,  414,  415,  242,
- /*    80 */    41,   43,  230,   35,   36,  746,   62,  137,   29,  137,
- /*    90 */    21,  199,   39,   37,   40,   38,  159,  843,   27,  842,
- /*   100 */    34,   33,   56,  838,   32,   31,   30,  105,   43,    8,
- /*   110 */    35,   36,   63,  115,  769,   29,  761,  527,  199,   39,
- /*   120 */    37,   40,   38,  168,  539,  747,  583,   34,   33,   18,
- /*   130 */   156,   32,   31,   30,   16,  210,  236,  235,  209,  208,
- /*   140 */   207,  234,  206,  233,  232,  231,  205,  727,  105,  715,
- /*   150 */   716,  717,  718,  719,  720,  721,  722,  723,  724,  725,
- /*   160 */   726,   35,   36,  798,  837,  194,   29,  177,  157,  199,
- /*   170 */    39,   37,   40,   38,  181,  180,   21,   21,   34,   33,
- /*   180 */   444,   12,   32,   31,   30,  164,  596,  750,  445,  587,
- /*   190 */   153,  590,  154,  593,  105,  164,  596,   21,   17,  587,
- /*   200 */   150,  590,  196,  593,   60,   26,   90,   89,  144,  169,
- /*   210 */   217,  747,  747,   16,  149,  236,  235,  161,  162,  167,
- /*   220 */   234,  198,  233,  232,  231,  142,  670,  161,  162,  128,
- /*   230 */   222,  542,  747,  164,  596,   17,  143,  587,  750,  590,
- /*   240 */   105,  593,   26,   39,   37,   40,   38,  100,  170,  145,
- /*   250 */   797,   34,   33,  101,   26,   32,   31,   30,   32,   31,
- /*   260 */    30,   78,  183,  564,  565,  161,  162,  230,  589,  152,
- /*   270 */   592,   76,   80,   85,   88,   79,  240,  239,   97,   34,
- /*   280 */    33,   82,   42,   32,   31,   30,  118,  119,   70,   66,
- /*   290 */    69,  237,   42,  595,  679,  163,   61,  128,  132,  130,
- /*   300 */    93,   92,   91,  595,  671,  187,  585,  128,  594,  588,
- /*   310 */   750,  591,  171,  534,   47,  216,  215,  146,  594,  555,
- /*   320 */   186,  147,  556,   46,  613,  148,   14,  597,   13,  139,
- /*   330 */    42,   13,   50,   48,    3,  135,   75,   74,  140,  516,
- /*   340 */   515,  595,  586,   46,   22,  138,  203,   10,    9,   51,
- /*   350 */    22,  852,  530,  528,  531,  529,  594,   87,   86,  749,
- /*   360 */   808,  807,  165,  804,  803,  166,  771,  741,  220,  776,
- /*   370 */   763,  778,  102,  790,  789,  116,  117,  114,  681,  204,
- /*   380 */   133,   24,  213,  678,  214,  851,   72,  850,  848,   26,
- /*   390 */   120,  699,   25,   23,  185,   95,  134,  668,   81,  551,
- /*   400 */   666,   83,   84,  664,  188,  663,  174,  129,  661,  660,
- /*   410 */   659,  658,  657,  649,  131,  655,  653,  192,   52,  651,
- /*   420 */   760,   57,   49,   58,  791,   44,  197,  195,  193,  191,
- /*   430 */   189,   28,  212,   77,  223,  224,  225,  226,  227,  228,
- /*   440 */   229,  238,  627,  176,  175,  626,  201,  178,  179,   53,
- /*   450 */   625,  618,  182,  536,   64,  151,  186,   67,  552,   55,
- /*   460 */   103,  158,  662,   59,  200,   94,   96,  123,  700,  121,
- /*   470 */   126,  106,  107,  122,  124,  125,  127,  112,  108,  109,
- /*   480 */   113,  745,  110,  656,  111,    1,    2,  190,    5,  557,
- /*   490 */   104,   19,    6,  598,   20,    4,   15,    7,   65,  485,
- /*   500 */   202,  481,  479,  478,  477,  474,  448,  211,   68,   45,
- /*   510 */    71,   73,   22,  512,  511,  509,   54,  469,  467,  459,
- /*   520 */   465,  461,  463,  457,  455,  484,  483,  482,  480,  476,
- /*   530 */   475,   46,  446,  419,  417,  631,  630,  630,  630,  630,
- /*   540 */   630,  630,  630,  630,  630,  630,  630,   98,   99,
+ /*     0 */    11,  452,  140,  452,  158,  245,   21,  139,  144,  453,
+ /*    10 */   140,  453,  852,   41,   43,  771,   35,   36,  849,  163,
+ /*    20 */   853,   29,  452,  848,  203,   39,   37,   40,   38,  159,
+ /*    30 */   453,  782,  741,   34,   33,  739,  740,   32,   31,   30,
+ /*    40 */   742,  756,  744,  745,  743,  107,  160,  410,  411,  412,
+ /*    50 */   413,  414,  415,  416,  417,  418,  419,  420,  421,  246,
+ /*    60 */   637,  247,  178,   41,   43,  760,   35,   36,  225,  107,
+ /*    70 */   140,   29,  170,  847,  203,   39,   37,   40,   38,  162,
+ /*    80 */   853,  518,  779,   34,   33,  103,  156,   32,   31,   30,
+ /*    90 */   234,  760,   41,   43,  157,   35,   36,  771,  758,  200,
+ /*   100 */    29,   60,   56,  203,   39,   37,   40,   38,   17,  223,
+ /*   110 */   222,  188,   34,   33,  145,   26,   32,   31,   30,   43,
+ /*   120 */     8,   35,   36,   63,  117,  808,   29,  198,  146,  203,
+ /*   130 */    39,   37,   40,   38,   32,   31,   30,  191,   34,   33,
+ /*   140 */   181,  107,   32,   31,   30,  241,   21,  185,  184,  591,
+ /*   150 */    16,  214,  240,  239,  213,  212,  211,  238,  210,  237,
+ /*   160 */   236,  235,  209,  737,  760,  725,  726,  727,  728,  729,
+ /*   170 */   730,  731,  732,  733,  734,  735,  736,   35,   36,  171,
+ /*   180 */   680,  757,   29,  130,  148,  203,   39,   37,   40,   38,
+ /*   190 */   244,  243,   96,  149,   34,   33,  107,  807,   32,   31,
+ /*   200 */    30,  167,  604,   78,   12,  595,   62,  598,  234,  601,
+ /*   210 */   689,  167,  604,  130,  150,  595,  173,  598,   27,  601,
+ /*   220 */   152,  167,  604,  572,  573,  595,  153,  598,  151,  601,
+ /*   230 */    90,   89,  147,  164,  165,   34,   33,  202,  142,   32,
+ /*   240 */    31,   30,  681,  164,  165,  130,  818,  550,   39,   37,
+ /*   250 */    40,   38,   61,  164,  165,  563,   34,   33,   17,   46,
+ /*   260 */    32,   31,   30,  102,   16,   26,  240,  239,  564,   21,
+ /*   270 */    26,  238,   14,  237,  236,  235,  597,  174,  600,  547,
+ /*   280 */   220,  219,   76,   80,   18,  187,  166,   21,   85,   88,
+ /*   290 */    79,  138,  155,  120,  121,   21,   82,  593,   42,   70,
+ /*   300 */    66,   69,  172,  542,  757,  134,  132,  143,   42,  603,
+ /*   310 */   190,   93,   92,   91,  596,  141,  599,  621,   42,  603,
+ /*   320 */   221,   13,  757,  605,  602,    3,  862,   13,  226,  603,
+ /*   330 */   757,   47,  534,  594,  602,  531,   50,  532,  538,  533,
+ /*   340 */   539,  524,  523,  817,  602,   46,   22,  207,   87,   86,
+ /*   350 */    48,   22,  759,   51,   75,   74,  101,   99,   10,    9,
+ /*   360 */   536,  168,  537,  175,  176,  814,  813,  169,  781,  786,
+ /*   370 */   751,  800,  224,  773,  788,   26,  104,  799,  118,  189,
+ /*   380 */   116,  119,  691,  208,  136,   24,  100,  217,  688,  559,
+ /*   390 */   218,  861,   72,  860,  858,  122,  709,   25,   23,  137,
+ /*   400 */   678,   81,  676,   83,   84,  674,  673,  177,  131,  671,
+ /*   410 */   192,  670,  196,  669,  770,  668,  667,  133,  665,  663,
+ /*   420 */    52,  661,  659,  657,  135,   49,   57,   58,  801,   44,
+ /*   430 */   201,  199,  197,  195,  535,  193,   28,  216,   77,  227,
+ /*   440 */   228,  230,  229,  231,  232,  233,  242,  635,  180,  205,
+ /*   450 */    53,  179,  634,  182,  183,   64,   67,  154,  633,  626,
+ /*   460 */   186,  161,  105,  672,  190,   94,  544,  666,  658,  125,
+ /*   470 */   710,  123,  124,  126,  127,  108,  128,  109,  129,  110,
+ /*   480 */    95,  755,  111,  112,  115,  113,  114,    2,    1,   55,
+ /*   490 */    59,  560,  194,    5,  565,  106,   19,    6,  606,   20,
+ /*   500 */     4,   15,   65,    7,  204,  493,  206,  489,  487,  486,
+ /*   510 */   485,  482,  456,  215,   68,   45,   22,   71,   73,  520,
+ /*   520 */   519,  517,   54,  477,  475,  467,  473,  469,  471,  465,
+ /*   530 */   463,  492,  491,  490,  488,  484,  483,   46,  454,  425,
+ /*   540 */   423,  639,  638,  638,  638,  638,  638,  638,  638,  638,
+ /*   550 */   638,  638,  638,   97,   98,
 };
 static const YYCODETYPE yy_lookahead[] = {
- /*     0 */   226,    1,  210,  229,  230,  207,  208,    5,  234,    9,
- /*    10 */   236,  237,  238,   13,   14,    2,   16,   17,    5,  260,
- /*    20 */     7,   21,    9,    1,   24,   25,   26,   27,   28,  209,
- /*    30 */   210,    9,  240,   33,   34,   33,   34,   37,   38,   39,
- /*    40 */    13,   14,  244,   16,   17,  260,   33,   34,   21,  260,
- /*    50 */   210,   24,   25,   26,   27,   28,  258,  260,  269,  270,
- /*    60 */    33,   34,  260,  210,   37,   38,   39,   45,   46,   47,
- /*    70 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
- /*    80 */    13,   14,   78,   16,   17,  245,  247,  260,   21,  260,
- /*    90 */   210,   24,   25,   26,   27,   28,  269,  270,  259,  270,
- /*   100 */    33,   34,  102,  260,   37,   38,   39,  210,   14,   98,
- /*   110 */    16,   17,  101,  102,  261,   21,  244,  104,   24,   25,
- /*   120 */    26,   27,   28,  243,  103,  245,   99,   33,   34,  108,
- /*   130 */   258,   37,   38,   39,   85,   86,   87,   88,   89,   90,
- /*   140 */    91,   92,   93,   94,   95,   96,   97,  226,  210,  228,
- /*   150 */   229,  230,  231,  232,  233,  234,  235,  236,  237,  238,
- /*   160 */   239,   16,   17,  266,  260,  268,   21,  126,  227,   24,
- /*   170 */    25,   26,   27,   28,  133,  134,  210,  210,   33,   34,
- /*   180 */     1,   44,   37,   38,   39,    1,    2,  246,    9,    5,
- /*   190 */   260,    7,  260,    9,  210,    1,    2,  210,   98,    5,
- /*   200 */    63,    7,  264,    9,  266,  105,   69,   70,   71,  243,
- /*   210 */   243,  245,  245,   85,   77,   87,   88,   33,   34,  227,
- /*   220 */    92,   37,   94,   95,   96,  260,  214,   33,   34,  217,
- /*   230 */   243,   37,  245,    1,    2,   98,  260,    5,  246,    7,
- /*   240 */   210,    9,  105,   25,   26,   27,   28,   98,   63,  260,
- /*   250 */   266,   33,   34,  210,  105,   37,   38,   39,   37,   38,
- /*   260 */    39,   72,  125,  115,  116,   33,   34,   78,    5,  132,
- /*   270 */     7,   64,   65,   66,   67,   68,   60,   61,   62,   33,
- /*   280 */    34,   74,   98,   37,   38,   39,   64,   65,   66,   67,
- /*   290 */    68,  227,   98,  109,  214,   59,  266,  217,   64,   65,
- /*   300 */    66,   67,   68,  109,  214,  262,    1,  217,  124,    5,
- /*   310 */   246,    7,  127,   99,  103,  130,  131,  260,  124,   99,
- /*   320 */   106,  260,   99,  103,   99,  260,  103,   99,  103,  260,
- /*   330 */    98,  103,  103,  122,   98,  260,  128,  129,  260,   99,
- /*   340 */    99,  109,   37,  103,  103,  260,   99,  128,  129,  120,
- /*   350 */   103,  246,    5,    5,    7,    7,  124,   72,   73,  246,
- /*   360 */   241,  241,  241,  241,  241,  241,  210,  242,  241,  210,
- /*   370 */   244,  210,  210,  267,  267,  210,  210,  248,  210,  210,
- /*   380 */   210,  210,  210,  210,  210,  210,  210,  210,  210,  105,
- /*   390 */   210,  210,  210,  210,  244,   59,  210,  210,  210,  109,
- /*   400 */   210,  210,  210,  210,  263,  210,  210,  210,  210,  210,
- /*   410 */   210,  210,  210,  210,  210,  210,  210,  263,  119,  210,
- /*   420 */   257,  211,  121,  211,  211,  118,  113,  117,  112,  111,
- /*   430 */   110,  123,   75,   84,   83,   49,   80,   82,   53,   81,
- /*   440 */    79,   75,    5,    5,  135,    5,  211,  135,    5,  211,
- /*   450 */     5,   86,  126,   99,  215,  211,  106,  215,   99,  107,
- /*   460 */    98,    1,  211,  103,  100,  212,  212,  219,  225,  224,
- /*   470 */   221,  256,  255,  223,  222,  220,  218,  250,  254,  253,
- /*   480 */   249,  244,  252,  211,  251,  216,  213,   98,  114,   99,
- /*   490 */    98,  103,  114,   99,  103,   98,   98,   98,   72,    9,
- /*   500 */   100,    5,    5,    5,    5,    5,   76,   15,   72,   16,
- /*   510 */   129,  129,  103,    5,    5,   99,   98,    5,    5,    5,
- /*   520 */     5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
- /*   530 */     5,  103,   76,   59,   58,    0,  271,  271,  271,  271,
- /*   540 */   271,  271,  271,  271,  271,  271,  271,   21,   21,  271,
- /*   550 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*     0 */   260,    1,  260,    1,  209,  210,  210,  260,  260,    9,
+ /*    10 */   260,    9,  270,   13,   14,  244,   16,   17,  260,  269,
+ /*    20 */   270,   21,    1,  260,   24,   25,   26,   27,   28,  258,
+ /*    30 */     9,  210,  226,   33,   34,  229,  230,   37,   38,   39,
+ /*    40 */   234,  245,  236,  237,  238,  210,  227,   45,   46,   47,
+ /*    50 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
+ /*    60 */   207,  208,   60,   13,   14,  246,   16,   17,  210,  210,
+ /*    70 */   260,   21,  227,  260,   24,   25,   26,   27,   28,  269,
+ /*    80 */   270,    5,  261,   33,   34,  210,  260,   37,   38,   39,
+ /*    90 */    78,  246,   13,   14,  260,   16,   17,  244,  240,  264,
+ /*   100 */    21,  266,  102,   24,   25,   26,   27,   28,   98,   33,
+ /*   110 */    34,  258,   33,   34,  260,  105,   37,   38,   39,   14,
+ /*   120 */    98,   16,   17,  101,  102,  266,   21,  268,  260,   24,
+ /*   130 */    25,   26,   27,   28,   37,   38,   39,  262,   33,   34,
+ /*   140 */   126,  210,   37,   38,   39,  227,  210,  133,  134,   99,
+ /*   150 */    85,   86,   87,   88,   89,   90,   91,   92,   93,   94,
+ /*   160 */    95,   96,   97,  226,  246,  228,  229,  230,  231,  232,
+ /*   170 */   233,  234,  235,  236,  237,  238,  239,   16,   17,  243,
+ /*   180 */   214,  245,   21,  217,  260,   24,   25,   26,   27,   28,
+ /*   190 */    63,   64,   65,  260,   33,   34,  210,  266,   37,   38,
+ /*   200 */    39,    1,    2,   73,   44,    5,  247,    7,   78,    9,
+ /*   210 */   214,    1,    2,  217,  260,    5,   66,    7,  259,    9,
+ /*   220 */    60,    1,    2,  115,  116,    5,   66,    7,  260,    9,
+ /*   230 */    70,   71,   72,   33,   34,   33,   34,   37,  260,   37,
+ /*   240 */    38,   39,  214,   33,   34,  217,  241,   37,   25,   26,
+ /*   250 */    27,   28,  266,   33,   34,   99,   33,   34,   98,  103,
+ /*   260 */    37,   38,   39,   98,   85,  105,   87,   88,   99,  210,
+ /*   270 */   105,   92,  103,   94,   95,   96,    5,  127,    7,  103,
+ /*   280 */   130,  131,   61,   62,  108,  125,   59,  210,   67,   68,
+ /*   290 */    69,  260,  132,   61,   62,  210,   75,    1,   98,   67,
+ /*   300 */    68,   69,  243,   99,  245,   61,   62,  260,   98,  109,
+ /*   310 */   106,   67,   68,   69,    5,  260,    7,   99,   98,  109,
+ /*   320 */   243,  103,  245,   99,  124,   98,  246,  103,  243,  109,
+ /*   330 */   245,  103,    2,   37,  124,    5,  103,    7,    5,    9,
+ /*   340 */     7,   99,   99,  241,  124,  103,  103,   99,   73,   74,
+ /*   350 */   122,  103,  246,  120,  128,  129,   61,   62,  128,  129,
+ /*   360 */     5,  241,    7,   33,   34,  241,  241,  241,  210,  210,
+ /*   370 */   242,  267,  241,  244,  210,  105,  210,  267,  210,  244,
+ /*   380 */   248,  210,  210,  210,  210,  210,   59,  210,  210,  109,
+ /*   390 */   210,  210,  210,  210,  210,  210,  210,  210,  210,  210,
+ /*   400 */   210,  210,  210,  210,  210,  210,  210,  210,  210,  210,
+ /*   410 */   263,  210,  263,  210,  257,  210,  210,  210,  210,  210,
+ /*   420 */   119,  210,  210,  210,  210,  121,  211,  211,  211,  118,
+ /*   430 */   113,  117,  112,  111,  104,  110,  123,   76,   84,   83,
+ /*   440 */    49,   82,   80,   53,   81,   79,   76,    5,    5,  211,
+ /*   450 */   211,  135,    5,  135,    5,  215,  215,  211,    5,   86,
+ /*   460 */   126,    1,   98,  211,  106,  212,   99,  211,  211,  219,
+ /*   470 */   225,  224,  223,  222,  220,  256,  221,  255,  218,  254,
+ /*   480 */   212,  244,  253,  252,  249,  251,  250,  213,  216,  107,
+ /*   490 */   103,   99,   98,  114,   99,   98,  103,  114,   99,  103,
+ /*   500 */    98,   98,   73,   98,  100,    9,  100,    5,    5,    5,
+ /*   510 */     5,    5,   77,   15,   73,   16,  103,  129,  129,    5,
+ /*   520 */     5,   99,   98,    5,    5,    5,    5,    5,    5,    5,
+ /*   530 */     5,    5,    5,    5,    5,    5,    5,  103,   77,   59,
+ /*   540 */    58,    0,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   550 */   271,  271,  271,   21,   21,  271,  271,  271,  271,  271,
  /*   560 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
  /*   570 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
  /*   580 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
@@ -336,83 +337,84 @@ static const YYCODETYPE yy_lookahead[] = {
  /*   720 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
  /*   730 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
  /*   740 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
- /*   750 */   271,  271,  271,  271,  271,
+ /*   750 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   760 */   271,
 };
-#define YY_SHIFT_COUNT    (243)
+#define YY_SHIFT_COUNT    (247)
 #define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (535)
+#define YY_SHIFT_MAX      (541)
 static const unsigned short int yy_shift_ofst[] = {
- /*     0 */   137,   49,  128,  184,  232,  179,  179,  179,  179,  179,
- /*    10 */   179,    0,   22,  232,   13,   13,   13,  100,  179,  179,
- /*    20 */   179,  179,  179,  189,    4,    4,  549,  194,  232,  232,
- /*    30 */   232,  232,  232,  232,  232,  232,  232,  232,  232,  232,
- /*    40 */   232,  232,  232,  232,  232,   13,   13,    2,    2,    2,
- /*    50 */     2,    2,    2,   11,    2,  149,  179,  179,  179,  179,
- /*    60 */   148,  148,   21,  179,  179,  179,  179,  179,  179,  179,
- /*    70 */   179,  179,  179,  179,  179,  179,  179,  179,  179,  179,
- /*    80 */   179,  179,  179,  179,  179,  179,  179,  179,  179,  179,
- /*    90 */   179,  179,  179,  179,  179,  179,  179,  179,  179,  179,
- /*   100 */   284,  336,  336,  290,  290,  336,  299,  301,  307,  313,
- /*   110 */   310,  316,  318,  320,  308,  284,  336,  336,  357,  357,
- /*   120 */   336,  349,  351,  386,  356,  355,  385,  358,  361,  336,
- /*   130 */   366,  336,  366,  549,  549,   27,   67,   67,   67,   94,
- /*   140 */   145,  218,  218,  218,  207,  246,  246,  246,  246,  222,
- /*   150 */   234,  185,   41,  221,  221,  216,  214,  220,  223,  225,
- /*   160 */   228,  263,  304,  305,  236,  211,  229,  240,  241,  247,
- /*   170 */   208,  219,  347,  348,  285,  437,  309,  438,  440,  312,
- /*   180 */   443,  445,  365,  326,  350,  354,  352,  360,  359,  362,
- /*   190 */   460,  389,  390,  392,  388,  374,  391,  378,  394,  397,
- /*   200 */   398,  364,  399,  400,  426,  490,  496,  497,  498,  499,
- /*   210 */   500,  430,  492,  436,  493,  381,  382,  409,  508,  509,
- /*   220 */   416,  418,  409,  512,  513,  514,  515,  516,  517,  518,
- /*   230 */   519,  520,  521,  522,  523,  524,  525,  428,  456,  526,
- /*   240 */   527,  474,  476,  535,
+ /*     0 */   160,   65,  179,  200,  220,   21,   21,   21,   21,   21,
+ /*    10 */    21,    0,    2,  220,  330,  330,  330,   10,   21,   21,
+ /*    20 */    21,   21,   21,  130,   12,   12,  555,  210,  220,  220,
+ /*    30 */   220,  220,  220,  220,  220,  220,  220,  220,  220,  220,
+ /*    40 */   220,  220,  220,  220,  220,  330,  330,   76,   76,   76,
+ /*    50 */    76,   76,   76,   22,   76,  165,   21,   21,   21,   21,
+ /*    60 */   108,  108,  176,   21,   21,   21,   21,   21,   21,   21,
+ /*    70 */    21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
+ /*    80 */    21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
+ /*    90 */    21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
+ /*   100 */    21,   21,  270,  327,  327,  280,  280,  327,  301,  304,
+ /*   110 */   311,  317,  314,  320,  322,  325,  313,  270,  327,  327,
+ /*   120 */   361,  361,  327,  354,  356,  391,  362,  359,  390,  363,
+ /*   130 */   366,  327,  370,  327,  370,  327,  555,  555,   50,   79,
+ /*   140 */    79,   79,  105,  161,  223,  223,  223,  221,  202,  202,
+ /*   150 */   202,  202,  232,  244,  150,   14,   97,   97,  127,  204,
+ /*   160 */   156,  169,  218,  224,  271,  309,  296,  227,  228,  233,
+ /*   170 */   242,  243,  248,  226,  230,  333,  355,  275,  295,  442,
+ /*   180 */   316,  443,  447,  318,  449,  453,  373,  334,  358,  367,
+ /*   190 */   382,  387,  392,  364,  460,  394,  395,  397,  393,  379,
+ /*   200 */   396,  383,  399,  402,  403,  404,  405,  406,  429,  496,
+ /*   210 */   502,  503,  504,  505,  506,  435,  498,  441,  499,  388,
+ /*   220 */   389,  413,  514,  515,  422,  424,  413,  518,  519,  520,
+ /*   230 */   521,  522,  523,  524,  525,  526,  527,  528,  529,  530,
+ /*   240 */   531,  434,  461,  532,  533,  480,  482,  541,
 };
-#define YY_REDUCE_COUNT (134)
-#define YY_REDUCE_MIN   (-241)
-#define YY_REDUCE_MAX   (273)
+#define YY_REDUCE_COUNT (137)
+#define YY_REDUCE_MIN   (-260)
+#define YY_REDUCE_MAX   (274)
 static const short yy_reduce_ofst[] = {
- /*     0 */  -202,  -79, -226, -211, -173, -103,  -62, -120,  -34,  -33,
- /*    10 */   -13, -147, -180, -171,  -59,   -8,   64, -128,   43,  -16,
- /*    20 */    30, -208, -160,   12,   80,   90, -161, -241, -215, -203,
- /*    30 */  -198, -157,  -96,  -70,  -68,  -35,  -24,  -11,   57,   61,
- /*    40 */    65,   69,   75,   78,   85,  105,  113,  119,  120,  121,
- /*    50 */   122,  123,  124,  125,  127,  126,  156,  159,  161,  162,
- /*    60 */   106,  107,  129,  165,  166,  168,  169,  170,  171,  172,
- /*    70 */   173,  174,  175,  176,  177,  178,  180,  181,  182,  183,
- /*    80 */   186,  187,  188,  190,  191,  192,  193,  195,  196,  197,
- /*    90 */   198,  199,  200,  201,  202,  203,  204,  205,  206,  209,
- /*   100 */   150,  210,  212,  141,  154,  213,  163,  215,  217,  224,
- /*   110 */   226,  230,  233,  227,  231,  237,  235,  238,  239,  242,
- /*   120 */   244,  243,  245,  250,  248,  252,  255,  249,  258,  251,
- /*   130 */   253,  272,  254,  269,  273,
+ /*     0 */  -147,  -63, -194, -250, -190, -141, -165,  -64,   59,   77,
+ /*    10 */    85, -179, -205, -258, -181, -155,  -82, -229, -125,  -69,
+ /*    20 */   -14, -142, -204,  -34,   -4,   28,  -41, -260, -253, -252,
+ /*    30 */  -242, -237, -187, -174, -166, -146, -132,  -76,  -67,  -46,
+ /*    40 */   -32,  -22,   31,   47,   55,   80,  106,    5,  102,  120,
+ /*    50 */   124,  125,  126,  128,  131,  129,  158,  159,  164,  166,
+ /*    60 */   104,  110,  132,  168,  171,  172,  173,  174,  175,  177,
+ /*    70 */   178,  180,  181,  182,  183,  184,  185,  186,  187,  188,
+ /*    80 */   189,  190,  191,  192,  193,  194,  195,  196,  197,  198,
+ /*    90 */   199,  201,  203,  205,  206,  207,  208,  209,  211,  212,
+ /*   100 */   213,  214,  135,  215,  216,  147,  149,  217,  157,  219,
+ /*   110 */   222,  225,  229,  231,  234,  236,  235,  237,  238,  239,
+ /*   120 */   240,  241,  246,  245,  247,  249,  250,  251,  254,  255,
+ /*   130 */   260,  252,  253,  256,  268,  257,  272,  274,
 };
 static const YYACTIONTYPE yy_default[] = {
- /*     0 */   628,  680,  669,  845,  845,  628,  628,  628,  628,  628,
- /*    10 */   628,  773,  646,  845,  628,  628,  628,  628,  628,  628,
- /*    20 */   628,  628,  628,  682,  682,  682,  768,  628,  628,  628,
- /*    30 */   628,  628,  628,  628,  628,  628,  628,  628,  628,  628,
- /*    40 */   628,  628,  628,  628,  628,  628,  628,  628,  628,  628,
- /*    50 */   628,  628,  628,  628,  628,  628,  628,  775,  777,  628,
- /*    60 */   794,  794,  766,  628,  628,  628,  628,  628,  628,  628,
- /*    70 */   628,  628,  628,  628,  628,  628,  628,  628,  628,  628,
- /*    80 */   628,  667,  628,  665,  628,  628,  628,  628,  628,  628,
- /*    90 */   628,  628,  628,  628,  628,  628,  628,  654,  628,  628,
- /*   100 */   628,  648,  648,  628,  628,  648,  801,  805,  799,  787,
- /*   110 */   795,  786,  782,  781,  809,  628,  648,  648,  677,  677,
- /*   120 */   648,  698,  696,  694,  686,  692,  688,  690,  684,  648,
- /*   130 */   675,  648,  675,  714,  728,  628,  810,  844,  800,  828,
- /*   140 */   827,  840,  834,  833,  628,  832,  831,  830,  829,  628,
- /*   150 */   628,  628,  628,  836,  835,  628,  628,  628,  628,  628,
- /*   160 */   628,  628,  628,  628,  812,  806,  802,  628,  628,  628,
- /*   170 */   628,  628,  628,  628,  628,  628,  628,  628,  628,  628,
- /*   180 */   628,  628,  628,  628,  765,  628,  628,  774,  628,  628,
- /*   190 */   628,  628,  628,  628,  796,  628,  788,  628,  628,  628,
- /*   200 */   628,  628,  628,  742,  628,  628,  628,  628,  628,  628,
- /*   210 */   628,  628,  628,  628,  628,  628,  628,  849,  628,  628,
- /*   220 */   628,  736,  847,  628,  628,  628,  628,  628,  628,  628,
- /*   230 */   628,  628,  628,  628,  628,  628,  628,  701,  628,  652,
- /*   240 */   650,  628,  644,  628,
+ /*     0 */   636,  690,  679,  855,  855,  636,  636,  636,  636,  636,
+ /*    10 */   636,  783,  654,  855,  636,  636,  636,  636,  636,  636,
+ /*    20 */   636,  636,  636,  692,  692,  692,  778,  636,  636,  636,
+ /*    30 */   636,  636,  636,  636,  636,  636,  636,  636,  636,  636,
+ /*    40 */   636,  636,  636,  636,  636,  636,  636,  636,  636,  636,
+ /*    50 */   636,  636,  636,  636,  636,  636,  636,  785,  787,  636,
+ /*    60 */   804,  804,  776,  636,  636,  636,  636,  636,  636,  636,
+ /*    70 */   636,  636,  636,  636,  636,  636,  636,  636,  636,  636,
+ /*    80 */   636,  677,  636,  675,  636,  636,  636,  636,  636,  636,
+ /*    90 */   636,  636,  636,  636,  636,  636,  664,  636,  636,  636,
+ /*   100 */   636,  636,  636,  656,  656,  636,  636,  656,  811,  815,
+ /*   110 */   809,  797,  805,  796,  792,  791,  819,  636,  656,  656,
+ /*   120 */   687,  687,  656,  708,  706,  704,  696,  702,  698,  700,
+ /*   130 */   694,  656,  685,  656,  685,  656,  724,  738,  636,  820,
+ /*   140 */   854,  810,  838,  837,  850,  844,  843,  636,  842,  841,
+ /*   150 */   840,  839,  636,  636,  636,  636,  846,  845,  636,  636,
+ /*   160 */   636,  636,  636,  636,  636,  636,  636,  822,  816,  812,
+ /*   170 */   636,  636,  636,  636,  636,  636,  636,  636,  636,  636,
+ /*   180 */   636,  636,  636,  636,  636,  636,  636,  636,  775,  636,
+ /*   190 */   636,  784,  636,  636,  636,  636,  636,  636,  806,  636,
+ /*   200 */   798,  636,  636,  636,  636,  636,  636,  752,  636,  636,
+ /*   210 */   636,  636,  636,  636,  636,  636,  636,  636,  636,  636,
+ /*   220 */   636,  859,  636,  636,  636,  746,  857,  636,  636,  636,
+ /*   230 */   636,  636,  636,  636,  636,  636,  636,  636,  636,  636,
+ /*   240 */   636,  711,  636,  662,  660,  636,  652,  636,
 };
 /********** End of lemon-generated parsing tables *****************************/
 
@@ -492,12 +494,13 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*     VNODES => nothing */
     1,  /*    IPTOKEN => ID */
     0,  /*        DOT => nothing */
+    0,  /*     CREATE => nothing */
+    0,  /*      TABLE => nothing */
+    1,  /*   DATABASE => ID */
     0,  /*     TABLES => nothing */
     0,  /*    STABLES => nothing */
     0,  /*    VGROUPS => nothing */
     0,  /*       DROP => nothing */
-    0,  /*      TABLE => nothing */
-    1,  /*   DATABASE => ID */
     0,  /*      DNODE => nothing */
     0,  /*       USER => nothing */
     0,  /*    ACCOUNT => nothing */
@@ -509,7 +512,6 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*      LOCAL => nothing */
     0,  /*         IF => nothing */
     0,  /*     EXISTS => nothing */
-    0,  /*     CREATE => nothing */
     0,  /*        PPS => nothing */
     0,  /*    TSERIES => nothing */
     0,  /*        DBS => nothing */
@@ -784,24 +786,24 @@ static const char *const yyTokenName[] = {
   /*   57 */ "VNODES",
   /*   58 */ "IPTOKEN",
   /*   59 */ "DOT",
-  /*   60 */ "TABLES",
-  /*   61 */ "STABLES",
-  /*   62 */ "VGROUPS",
-  /*   63 */ "DROP",
-  /*   64 */ "TABLE",
-  /*   65 */ "DATABASE",
-  /*   66 */ "DNODE",
-  /*   67 */ "USER",
-  /*   68 */ "ACCOUNT",
-  /*   69 */ "USE",
-  /*   70 */ "DESCRIBE",
-  /*   71 */ "ALTER",
-  /*   72 */ "PASS",
-  /*   73 */ "PRIVILEGE",
-  /*   74 */ "LOCAL",
-  /*   75 */ "IF",
-  /*   76 */ "EXISTS",
-  /*   77 */ "CREATE",
+  /*   60 */ "CREATE",
+  /*   61 */ "TABLE",
+  /*   62 */ "DATABASE",
+  /*   63 */ "TABLES",
+  /*   64 */ "STABLES",
+  /*   65 */ "VGROUPS",
+  /*   66 */ "DROP",
+  /*   67 */ "DNODE",
+  /*   68 */ "USER",
+  /*   69 */ "ACCOUNT",
+  /*   70 */ "USE",
+  /*   71 */ "DESCRIBE",
+  /*   72 */ "ALTER",
+  /*   73 */ "PASS",
+  /*   74 */ "PRIVILEGE",
+  /*   75 */ "LOCAL",
+  /*   76 */ "IF",
+  /*   77 */ "EXISTS",
   /*   78 */ "PPS",
   /*   79 */ "TSERIES",
   /*   80 */ "DBS",
@@ -1021,212 +1023,214 @@ static const char *const yyRuleName[] = {
  /*  16 */ "dbPrefix ::= ids DOT",
  /*  17 */ "cpxName ::=",
  /*  18 */ "cpxName ::= DOT ids",
- /*  19 */ "cmd ::= SHOW dbPrefix TABLES",
- /*  20 */ "cmd ::= SHOW dbPrefix TABLES LIKE ids",
- /*  21 */ "cmd ::= SHOW dbPrefix STABLES",
- /*  22 */ "cmd ::= SHOW dbPrefix STABLES LIKE ids",
- /*  23 */ "cmd ::= SHOW dbPrefix VGROUPS",
- /*  24 */ "cmd ::= SHOW dbPrefix VGROUPS ids",
- /*  25 */ "cmd ::= DROP TABLE ifexists ids cpxName",
- /*  26 */ "cmd ::= DROP DATABASE ifexists ids",
- /*  27 */ "cmd ::= DROP DNODE ids",
- /*  28 */ "cmd ::= DROP USER ids",
- /*  29 */ "cmd ::= DROP ACCOUNT ids",
- /*  30 */ "cmd ::= USE ids",
- /*  31 */ "cmd ::= DESCRIBE ids cpxName",
- /*  32 */ "cmd ::= ALTER USER ids PASS ids",
- /*  33 */ "cmd ::= ALTER USER ids PRIVILEGE ids",
- /*  34 */ "cmd ::= ALTER DNODE ids ids",
- /*  35 */ "cmd ::= ALTER DNODE ids ids ids",
- /*  36 */ "cmd ::= ALTER LOCAL ids",
- /*  37 */ "cmd ::= ALTER LOCAL ids ids",
- /*  38 */ "cmd ::= ALTER DATABASE ids alter_db_optr",
- /*  39 */ "cmd ::= ALTER ACCOUNT ids acct_optr",
- /*  40 */ "cmd ::= ALTER ACCOUNT ids PASS ids acct_optr",
- /*  41 */ "ids ::= ID",
- /*  42 */ "ids ::= STRING",
- /*  43 */ "ifexists ::= IF EXISTS",
- /*  44 */ "ifexists ::=",
- /*  45 */ "ifnotexists ::= IF NOT EXISTS",
- /*  46 */ "ifnotexists ::=",
- /*  47 */ "cmd ::= CREATE DNODE ids",
- /*  48 */ "cmd ::= CREATE ACCOUNT ids PASS ids acct_optr",
- /*  49 */ "cmd ::= CREATE DATABASE ifnotexists ids db_optr",
- /*  50 */ "cmd ::= CREATE USER ids PASS ids",
- /*  51 */ "pps ::=",
- /*  52 */ "pps ::= PPS INTEGER",
- /*  53 */ "tseries ::=",
- /*  54 */ "tseries ::= TSERIES INTEGER",
- /*  55 */ "dbs ::=",
- /*  56 */ "dbs ::= DBS INTEGER",
- /*  57 */ "streams ::=",
- /*  58 */ "streams ::= STREAMS INTEGER",
- /*  59 */ "storage ::=",
- /*  60 */ "storage ::= STORAGE INTEGER",
- /*  61 */ "qtime ::=",
- /*  62 */ "qtime ::= QTIME INTEGER",
- /*  63 */ "users ::=",
- /*  64 */ "users ::= USERS INTEGER",
- /*  65 */ "conns ::=",
- /*  66 */ "conns ::= CONNS INTEGER",
- /*  67 */ "state ::=",
- /*  68 */ "state ::= STATE ids",
- /*  69 */ "acct_optr ::= pps tseries storage streams qtime dbs users conns state",
- /*  70 */ "keep ::= KEEP tagitemlist",
- /*  71 */ "cache ::= CACHE INTEGER",
- /*  72 */ "replica ::= REPLICA INTEGER",
- /*  73 */ "quorum ::= QUORUM INTEGER",
- /*  74 */ "days ::= DAYS INTEGER",
- /*  75 */ "minrows ::= MINROWS INTEGER",
- /*  76 */ "maxrows ::= MAXROWS INTEGER",
- /*  77 */ "blocks ::= BLOCKS INTEGER",
- /*  78 */ "ctime ::= CTIME INTEGER",
- /*  79 */ "wal ::= WAL INTEGER",
- /*  80 */ "fsync ::= FSYNC INTEGER",
- /*  81 */ "comp ::= COMP INTEGER",
- /*  82 */ "prec ::= PRECISION STRING",
- /*  83 */ "db_optr ::=",
- /*  84 */ "db_optr ::= db_optr cache",
- /*  85 */ "db_optr ::= db_optr replica",
- /*  86 */ "db_optr ::= db_optr quorum",
- /*  87 */ "db_optr ::= db_optr days",
- /*  88 */ "db_optr ::= db_optr minrows",
- /*  89 */ "db_optr ::= db_optr maxrows",
- /*  90 */ "db_optr ::= db_optr blocks",
- /*  91 */ "db_optr ::= db_optr ctime",
- /*  92 */ "db_optr ::= db_optr wal",
- /*  93 */ "db_optr ::= db_optr fsync",
- /*  94 */ "db_optr ::= db_optr comp",
- /*  95 */ "db_optr ::= db_optr prec",
- /*  96 */ "db_optr ::= db_optr keep",
- /*  97 */ "alter_db_optr ::=",
- /*  98 */ "alter_db_optr ::= alter_db_optr replica",
- /*  99 */ "alter_db_optr ::= alter_db_optr quorum",
- /* 100 */ "alter_db_optr ::= alter_db_optr keep",
- /* 101 */ "alter_db_optr ::= alter_db_optr blocks",
- /* 102 */ "alter_db_optr ::= alter_db_optr comp",
- /* 103 */ "alter_db_optr ::= alter_db_optr wal",
- /* 104 */ "alter_db_optr ::= alter_db_optr fsync",
- /* 105 */ "typename ::= ids",
- /* 106 */ "typename ::= ids LP signed RP",
- /* 107 */ "signed ::= INTEGER",
- /* 108 */ "signed ::= PLUS INTEGER",
- /* 109 */ "signed ::= MINUS INTEGER",
- /* 110 */ "cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args",
- /* 111 */ "create_table_args ::= LP columnlist RP",
- /* 112 */ "create_table_args ::= LP columnlist RP TAGS LP columnlist RP",
- /* 113 */ "create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP",
- /* 114 */ "create_table_args ::= AS select",
- /* 115 */ "columnlist ::= columnlist COMMA column",
- /* 116 */ "columnlist ::= column",
- /* 117 */ "column ::= ids typename",
- /* 118 */ "tagitemlist ::= tagitemlist COMMA tagitem",
- /* 119 */ "tagitemlist ::= tagitem",
- /* 120 */ "tagitem ::= INTEGER",
- /* 121 */ "tagitem ::= FLOAT",
- /* 122 */ "tagitem ::= STRING",
- /* 123 */ "tagitem ::= BOOL",
- /* 124 */ "tagitem ::= NULL",
- /* 125 */ "tagitem ::= MINUS INTEGER",
- /* 126 */ "tagitem ::= MINUS FLOAT",
- /* 127 */ "tagitem ::= PLUS INTEGER",
- /* 128 */ "tagitem ::= PLUS FLOAT",
- /* 129 */ "select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt",
- /* 130 */ "union ::= select",
- /* 131 */ "union ::= LP union RP",
- /* 132 */ "union ::= union UNION ALL select",
- /* 133 */ "union ::= union UNION ALL LP select RP",
- /* 134 */ "cmd ::= union",
- /* 135 */ "select ::= SELECT selcollist",
- /* 136 */ "sclp ::= selcollist COMMA",
- /* 137 */ "sclp ::=",
- /* 138 */ "selcollist ::= sclp expr as",
- /* 139 */ "selcollist ::= sclp STAR",
- /* 140 */ "as ::= AS ids",
- /* 141 */ "as ::= ids",
- /* 142 */ "as ::=",
- /* 143 */ "from ::= FROM tablelist",
- /* 144 */ "tablelist ::= ids cpxName",
- /* 145 */ "tablelist ::= ids cpxName ids",
- /* 146 */ "tablelist ::= tablelist COMMA ids cpxName",
- /* 147 */ "tablelist ::= tablelist COMMA ids cpxName ids",
- /* 148 */ "tmvar ::= VARIABLE",
- /* 149 */ "interval_opt ::= INTERVAL LP tmvar RP",
- /* 150 */ "interval_opt ::=",
- /* 151 */ "fill_opt ::=",
- /* 152 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
- /* 153 */ "fill_opt ::= FILL LP ID RP",
- /* 154 */ "sliding_opt ::= SLIDING LP tmvar RP",
- /* 155 */ "sliding_opt ::=",
- /* 156 */ "orderby_opt ::=",
- /* 157 */ "orderby_opt ::= ORDER BY sortlist",
- /* 158 */ "sortlist ::= sortlist COMMA item sortorder",
- /* 159 */ "sortlist ::= item sortorder",
- /* 160 */ "item ::= ids cpxName",
- /* 161 */ "sortorder ::= ASC",
- /* 162 */ "sortorder ::= DESC",
- /* 163 */ "sortorder ::=",
- /* 164 */ "groupby_opt ::=",
- /* 165 */ "groupby_opt ::= GROUP BY grouplist",
- /* 166 */ "grouplist ::= grouplist COMMA item",
- /* 167 */ "grouplist ::= item",
- /* 168 */ "having_opt ::=",
- /* 169 */ "having_opt ::= HAVING expr",
- /* 170 */ "limit_opt ::=",
- /* 171 */ "limit_opt ::= LIMIT signed",
- /* 172 */ "limit_opt ::= LIMIT signed OFFSET signed",
- /* 173 */ "limit_opt ::= LIMIT signed COMMA signed",
- /* 174 */ "slimit_opt ::=",
- /* 175 */ "slimit_opt ::= SLIMIT signed",
- /* 176 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
- /* 177 */ "slimit_opt ::= SLIMIT signed COMMA signed",
- /* 178 */ "where_opt ::=",
- /* 179 */ "where_opt ::= WHERE expr",
- /* 180 */ "expr ::= LP expr RP",
- /* 181 */ "expr ::= ID",
- /* 182 */ "expr ::= ID DOT ID",
- /* 183 */ "expr ::= ID DOT STAR",
- /* 184 */ "expr ::= INTEGER",
- /* 185 */ "expr ::= MINUS INTEGER",
- /* 186 */ "expr ::= PLUS INTEGER",
- /* 187 */ "expr ::= FLOAT",
- /* 188 */ "expr ::= MINUS FLOAT",
- /* 189 */ "expr ::= PLUS FLOAT",
- /* 190 */ "expr ::= STRING",
- /* 191 */ "expr ::= NOW",
- /* 192 */ "expr ::= VARIABLE",
- /* 193 */ "expr ::= BOOL",
- /* 194 */ "expr ::= ID LP exprlist RP",
- /* 195 */ "expr ::= ID LP STAR RP",
- /* 196 */ "expr ::= expr AND expr",
- /* 197 */ "expr ::= expr OR expr",
- /* 198 */ "expr ::= expr LT expr",
- /* 199 */ "expr ::= expr GT expr",
- /* 200 */ "expr ::= expr LE expr",
- /* 201 */ "expr ::= expr GE expr",
- /* 202 */ "expr ::= expr NE expr",
- /* 203 */ "expr ::= expr EQ expr",
- /* 204 */ "expr ::= expr PLUS expr",
- /* 205 */ "expr ::= expr MINUS expr",
- /* 206 */ "expr ::= expr STAR expr",
- /* 207 */ "expr ::= expr SLASH expr",
- /* 208 */ "expr ::= expr REM expr",
- /* 209 */ "expr ::= expr LIKE expr",
- /* 210 */ "expr ::= expr IN LP exprlist RP",
- /* 211 */ "exprlist ::= exprlist COMMA expritem",
- /* 212 */ "exprlist ::= expritem",
- /* 213 */ "expritem ::= expr",
- /* 214 */ "expritem ::=",
- /* 215 */ "cmd ::= RESET QUERY CACHE",
- /* 216 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
- /* 217 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
- /* 218 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
- /* 219 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
- /* 220 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
- /* 221 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
- /* 222 */ "cmd ::= KILL CONNECTION INTEGER",
- /* 223 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
- /* 224 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
+ /*  19 */ "cmd ::= SHOW CREATE TABLE ids cpxName",
+ /*  20 */ "cmd ::= SHOW CREATE DATABASE ids",
+ /*  21 */ "cmd ::= SHOW dbPrefix TABLES",
+ /*  22 */ "cmd ::= SHOW dbPrefix TABLES LIKE ids",
+ /*  23 */ "cmd ::= SHOW dbPrefix STABLES",
+ /*  24 */ "cmd ::= SHOW dbPrefix STABLES LIKE ids",
+ /*  25 */ "cmd ::= SHOW dbPrefix VGROUPS",
+ /*  26 */ "cmd ::= SHOW dbPrefix VGROUPS ids",
+ /*  27 */ "cmd ::= DROP TABLE ifexists ids cpxName",
+ /*  28 */ "cmd ::= DROP DATABASE ifexists ids",
+ /*  29 */ "cmd ::= DROP DNODE ids",
+ /*  30 */ "cmd ::= DROP USER ids",
+ /*  31 */ "cmd ::= DROP ACCOUNT ids",
+ /*  32 */ "cmd ::= USE ids",
+ /*  33 */ "cmd ::= DESCRIBE ids cpxName",
+ /*  34 */ "cmd ::= ALTER USER ids PASS ids",
+ /*  35 */ "cmd ::= ALTER USER ids PRIVILEGE ids",
+ /*  36 */ "cmd ::= ALTER DNODE ids ids",
+ /*  37 */ "cmd ::= ALTER DNODE ids ids ids",
+ /*  38 */ "cmd ::= ALTER LOCAL ids",
+ /*  39 */ "cmd ::= ALTER LOCAL ids ids",
+ /*  40 */ "cmd ::= ALTER DATABASE ids alter_db_optr",
+ /*  41 */ "cmd ::= ALTER ACCOUNT ids acct_optr",
+ /*  42 */ "cmd ::= ALTER ACCOUNT ids PASS ids acct_optr",
+ /*  43 */ "ids ::= ID",
+ /*  44 */ "ids ::= STRING",
+ /*  45 */ "ifexists ::= IF EXISTS",
+ /*  46 */ "ifexists ::=",
+ /*  47 */ "ifnotexists ::= IF NOT EXISTS",
+ /*  48 */ "ifnotexists ::=",
+ /*  49 */ "cmd ::= CREATE DNODE ids",
+ /*  50 */ "cmd ::= CREATE ACCOUNT ids PASS ids acct_optr",
+ /*  51 */ "cmd ::= CREATE DATABASE ifnotexists ids db_optr",
+ /*  52 */ "cmd ::= CREATE USER ids PASS ids",
+ /*  53 */ "pps ::=",
+ /*  54 */ "pps ::= PPS INTEGER",
+ /*  55 */ "tseries ::=",
+ /*  56 */ "tseries ::= TSERIES INTEGER",
+ /*  57 */ "dbs ::=",
+ /*  58 */ "dbs ::= DBS INTEGER",
+ /*  59 */ "streams ::=",
+ /*  60 */ "streams ::= STREAMS INTEGER",
+ /*  61 */ "storage ::=",
+ /*  62 */ "storage ::= STORAGE INTEGER",
+ /*  63 */ "qtime ::=",
+ /*  64 */ "qtime ::= QTIME INTEGER",
+ /*  65 */ "users ::=",
+ /*  66 */ "users ::= USERS INTEGER",
+ /*  67 */ "conns ::=",
+ /*  68 */ "conns ::= CONNS INTEGER",
+ /*  69 */ "state ::=",
+ /*  70 */ "state ::= STATE ids",
+ /*  71 */ "acct_optr ::= pps tseries storage streams qtime dbs users conns state",
+ /*  72 */ "keep ::= KEEP tagitemlist",
+ /*  73 */ "cache ::= CACHE INTEGER",
+ /*  74 */ "replica ::= REPLICA INTEGER",
+ /*  75 */ "quorum ::= QUORUM INTEGER",
+ /*  76 */ "days ::= DAYS INTEGER",
+ /*  77 */ "minrows ::= MINROWS INTEGER",
+ /*  78 */ "maxrows ::= MAXROWS INTEGER",
+ /*  79 */ "blocks ::= BLOCKS INTEGER",
+ /*  80 */ "ctime ::= CTIME INTEGER",
+ /*  81 */ "wal ::= WAL INTEGER",
+ /*  82 */ "fsync ::= FSYNC INTEGER",
+ /*  83 */ "comp ::= COMP INTEGER",
+ /*  84 */ "prec ::= PRECISION STRING",
+ /*  85 */ "db_optr ::=",
+ /*  86 */ "db_optr ::= db_optr cache",
+ /*  87 */ "db_optr ::= db_optr replica",
+ /*  88 */ "db_optr ::= db_optr quorum",
+ /*  89 */ "db_optr ::= db_optr days",
+ /*  90 */ "db_optr ::= db_optr minrows",
+ /*  91 */ "db_optr ::= db_optr maxrows",
+ /*  92 */ "db_optr ::= db_optr blocks",
+ /*  93 */ "db_optr ::= db_optr ctime",
+ /*  94 */ "db_optr ::= db_optr wal",
+ /*  95 */ "db_optr ::= db_optr fsync",
+ /*  96 */ "db_optr ::= db_optr comp",
+ /*  97 */ "db_optr ::= db_optr prec",
+ /*  98 */ "db_optr ::= db_optr keep",
+ /*  99 */ "alter_db_optr ::=",
+ /* 100 */ "alter_db_optr ::= alter_db_optr replica",
+ /* 101 */ "alter_db_optr ::= alter_db_optr quorum",
+ /* 102 */ "alter_db_optr ::= alter_db_optr keep",
+ /* 103 */ "alter_db_optr ::= alter_db_optr blocks",
+ /* 104 */ "alter_db_optr ::= alter_db_optr comp",
+ /* 105 */ "alter_db_optr ::= alter_db_optr wal",
+ /* 106 */ "alter_db_optr ::= alter_db_optr fsync",
+ /* 107 */ "typename ::= ids",
+ /* 108 */ "typename ::= ids LP signed RP",
+ /* 109 */ "signed ::= INTEGER",
+ /* 110 */ "signed ::= PLUS INTEGER",
+ /* 111 */ "signed ::= MINUS INTEGER",
+ /* 112 */ "cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args",
+ /* 113 */ "create_table_args ::= LP columnlist RP",
+ /* 114 */ "create_table_args ::= LP columnlist RP TAGS LP columnlist RP",
+ /* 115 */ "create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP",
+ /* 116 */ "create_table_args ::= AS select",
+ /* 117 */ "columnlist ::= columnlist COMMA column",
+ /* 118 */ "columnlist ::= column",
+ /* 119 */ "column ::= ids typename",
+ /* 120 */ "tagitemlist ::= tagitemlist COMMA tagitem",
+ /* 121 */ "tagitemlist ::= tagitem",
+ /* 122 */ "tagitem ::= INTEGER",
+ /* 123 */ "tagitem ::= FLOAT",
+ /* 124 */ "tagitem ::= STRING",
+ /* 125 */ "tagitem ::= BOOL",
+ /* 126 */ "tagitem ::= NULL",
+ /* 127 */ "tagitem ::= MINUS INTEGER",
+ /* 128 */ "tagitem ::= MINUS FLOAT",
+ /* 129 */ "tagitem ::= PLUS INTEGER",
+ /* 130 */ "tagitem ::= PLUS FLOAT",
+ /* 131 */ "select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt",
+ /* 132 */ "union ::= select",
+ /* 133 */ "union ::= LP union RP",
+ /* 134 */ "union ::= union UNION ALL select",
+ /* 135 */ "union ::= union UNION ALL LP select RP",
+ /* 136 */ "cmd ::= union",
+ /* 137 */ "select ::= SELECT selcollist",
+ /* 138 */ "sclp ::= selcollist COMMA",
+ /* 139 */ "sclp ::=",
+ /* 140 */ "selcollist ::= sclp expr as",
+ /* 141 */ "selcollist ::= sclp STAR",
+ /* 142 */ "as ::= AS ids",
+ /* 143 */ "as ::= ids",
+ /* 144 */ "as ::=",
+ /* 145 */ "from ::= FROM tablelist",
+ /* 146 */ "tablelist ::= ids cpxName",
+ /* 147 */ "tablelist ::= ids cpxName ids",
+ /* 148 */ "tablelist ::= tablelist COMMA ids cpxName",
+ /* 149 */ "tablelist ::= tablelist COMMA ids cpxName ids",
+ /* 150 */ "tmvar ::= VARIABLE",
+ /* 151 */ "interval_opt ::= INTERVAL LP tmvar RP",
+ /* 152 */ "interval_opt ::=",
+ /* 153 */ "fill_opt ::=",
+ /* 154 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
+ /* 155 */ "fill_opt ::= FILL LP ID RP",
+ /* 156 */ "sliding_opt ::= SLIDING LP tmvar RP",
+ /* 157 */ "sliding_opt ::=",
+ /* 158 */ "orderby_opt ::=",
+ /* 159 */ "orderby_opt ::= ORDER BY sortlist",
+ /* 160 */ "sortlist ::= sortlist COMMA item sortorder",
+ /* 161 */ "sortlist ::= item sortorder",
+ /* 162 */ "item ::= ids cpxName",
+ /* 163 */ "sortorder ::= ASC",
+ /* 164 */ "sortorder ::= DESC",
+ /* 165 */ "sortorder ::=",
+ /* 166 */ "groupby_opt ::=",
+ /* 167 */ "groupby_opt ::= GROUP BY grouplist",
+ /* 168 */ "grouplist ::= grouplist COMMA item",
+ /* 169 */ "grouplist ::= item",
+ /* 170 */ "having_opt ::=",
+ /* 171 */ "having_opt ::= HAVING expr",
+ /* 172 */ "limit_opt ::=",
+ /* 173 */ "limit_opt ::= LIMIT signed",
+ /* 174 */ "limit_opt ::= LIMIT signed OFFSET signed",
+ /* 175 */ "limit_opt ::= LIMIT signed COMMA signed",
+ /* 176 */ "slimit_opt ::=",
+ /* 177 */ "slimit_opt ::= SLIMIT signed",
+ /* 178 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
+ /* 179 */ "slimit_opt ::= SLIMIT signed COMMA signed",
+ /* 180 */ "where_opt ::=",
+ /* 181 */ "where_opt ::= WHERE expr",
+ /* 182 */ "expr ::= LP expr RP",
+ /* 183 */ "expr ::= ID",
+ /* 184 */ "expr ::= ID DOT ID",
+ /* 185 */ "expr ::= ID DOT STAR",
+ /* 186 */ "expr ::= INTEGER",
+ /* 187 */ "expr ::= MINUS INTEGER",
+ /* 188 */ "expr ::= PLUS INTEGER",
+ /* 189 */ "expr ::= FLOAT",
+ /* 190 */ "expr ::= MINUS FLOAT",
+ /* 191 */ "expr ::= PLUS FLOAT",
+ /* 192 */ "expr ::= STRING",
+ /* 193 */ "expr ::= NOW",
+ /* 194 */ "expr ::= VARIABLE",
+ /* 195 */ "expr ::= BOOL",
+ /* 196 */ "expr ::= ID LP exprlist RP",
+ /* 197 */ "expr ::= ID LP STAR RP",
+ /* 198 */ "expr ::= expr AND expr",
+ /* 199 */ "expr ::= expr OR expr",
+ /* 200 */ "expr ::= expr LT expr",
+ /* 201 */ "expr ::= expr GT expr",
+ /* 202 */ "expr ::= expr LE expr",
+ /* 203 */ "expr ::= expr GE expr",
+ /* 204 */ "expr ::= expr NE expr",
+ /* 205 */ "expr ::= expr EQ expr",
+ /* 206 */ "expr ::= expr PLUS expr",
+ /* 207 */ "expr ::= expr MINUS expr",
+ /* 208 */ "expr ::= expr STAR expr",
+ /* 209 */ "expr ::= expr SLASH expr",
+ /* 210 */ "expr ::= expr REM expr",
+ /* 211 */ "expr ::= expr LIKE expr",
+ /* 212 */ "expr ::= expr IN LP exprlist RP",
+ /* 213 */ "exprlist ::= exprlist COMMA expritem",
+ /* 214 */ "exprlist ::= expritem",
+ /* 215 */ "expritem ::= expr",
+ /* 216 */ "expritem ::=",
+ /* 217 */ "cmd ::= RESET QUERY CACHE",
+ /* 218 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
+ /* 219 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
+ /* 220 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
+ /* 221 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
+ /* 222 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
+ /* 223 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
+ /* 224 */ "cmd ::= KILL CONNECTION INTEGER",
+ /* 225 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
+ /* 226 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
 };
 #endif /* NDEBUG */
 
@@ -1703,212 +1707,214 @@ static const struct {
   {  209,   -2 }, /* (16) dbPrefix ::= ids DOT */
   {  211,    0 }, /* (17) cpxName ::= */
   {  211,   -2 }, /* (18) cpxName ::= DOT ids */
-  {  208,   -3 }, /* (19) cmd ::= SHOW dbPrefix TABLES */
-  {  208,   -5 }, /* (20) cmd ::= SHOW dbPrefix TABLES LIKE ids */
-  {  208,   -3 }, /* (21) cmd ::= SHOW dbPrefix STABLES */
-  {  208,   -5 }, /* (22) cmd ::= SHOW dbPrefix STABLES LIKE ids */
-  {  208,   -3 }, /* (23) cmd ::= SHOW dbPrefix VGROUPS */
-  {  208,   -4 }, /* (24) cmd ::= SHOW dbPrefix VGROUPS ids */
-  {  208,   -5 }, /* (25) cmd ::= DROP TABLE ifexists ids cpxName */
-  {  208,   -4 }, /* (26) cmd ::= DROP DATABASE ifexists ids */
-  {  208,   -3 }, /* (27) cmd ::= DROP DNODE ids */
-  {  208,   -3 }, /* (28) cmd ::= DROP USER ids */
-  {  208,   -3 }, /* (29) cmd ::= DROP ACCOUNT ids */
-  {  208,   -2 }, /* (30) cmd ::= USE ids */
-  {  208,   -3 }, /* (31) cmd ::= DESCRIBE ids cpxName */
-  {  208,   -5 }, /* (32) cmd ::= ALTER USER ids PASS ids */
-  {  208,   -5 }, /* (33) cmd ::= ALTER USER ids PRIVILEGE ids */
-  {  208,   -4 }, /* (34) cmd ::= ALTER DNODE ids ids */
-  {  208,   -5 }, /* (35) cmd ::= ALTER DNODE ids ids ids */
-  {  208,   -3 }, /* (36) cmd ::= ALTER LOCAL ids */
-  {  208,   -4 }, /* (37) cmd ::= ALTER LOCAL ids ids */
-  {  208,   -4 }, /* (38) cmd ::= ALTER DATABASE ids alter_db_optr */
-  {  208,   -4 }, /* (39) cmd ::= ALTER ACCOUNT ids acct_optr */
-  {  208,   -6 }, /* (40) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
-  {  210,   -1 }, /* (41) ids ::= ID */
-  {  210,   -1 }, /* (42) ids ::= STRING */
-  {  212,   -2 }, /* (43) ifexists ::= IF EXISTS */
-  {  212,    0 }, /* (44) ifexists ::= */
-  {  215,   -3 }, /* (45) ifnotexists ::= IF NOT EXISTS */
-  {  215,    0 }, /* (46) ifnotexists ::= */
-  {  208,   -3 }, /* (47) cmd ::= CREATE DNODE ids */
-  {  208,   -6 }, /* (48) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
-  {  208,   -5 }, /* (49) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
-  {  208,   -5 }, /* (50) cmd ::= CREATE USER ids PASS ids */
-  {  217,    0 }, /* (51) pps ::= */
-  {  217,   -2 }, /* (52) pps ::= PPS INTEGER */
-  {  218,    0 }, /* (53) tseries ::= */
-  {  218,   -2 }, /* (54) tseries ::= TSERIES INTEGER */
-  {  219,    0 }, /* (55) dbs ::= */
-  {  219,   -2 }, /* (56) dbs ::= DBS INTEGER */
-  {  220,    0 }, /* (57) streams ::= */
-  {  220,   -2 }, /* (58) streams ::= STREAMS INTEGER */
-  {  221,    0 }, /* (59) storage ::= */
-  {  221,   -2 }, /* (60) storage ::= STORAGE INTEGER */
-  {  222,    0 }, /* (61) qtime ::= */
-  {  222,   -2 }, /* (62) qtime ::= QTIME INTEGER */
-  {  223,    0 }, /* (63) users ::= */
-  {  223,   -2 }, /* (64) users ::= USERS INTEGER */
-  {  224,    0 }, /* (65) conns ::= */
-  {  224,   -2 }, /* (66) conns ::= CONNS INTEGER */
-  {  225,    0 }, /* (67) state ::= */
-  {  225,   -2 }, /* (68) state ::= STATE ids */
-  {  214,   -9 }, /* (69) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
-  {  226,   -2 }, /* (70) keep ::= KEEP tagitemlist */
-  {  228,   -2 }, /* (71) cache ::= CACHE INTEGER */
-  {  229,   -2 }, /* (72) replica ::= REPLICA INTEGER */
-  {  230,   -2 }, /* (73) quorum ::= QUORUM INTEGER */
-  {  231,   -2 }, /* (74) days ::= DAYS INTEGER */
-  {  232,   -2 }, /* (75) minrows ::= MINROWS INTEGER */
-  {  233,   -2 }, /* (76) maxrows ::= MAXROWS INTEGER */
-  {  234,   -2 }, /* (77) blocks ::= BLOCKS INTEGER */
-  {  235,   -2 }, /* (78) ctime ::= CTIME INTEGER */
-  {  236,   -2 }, /* (79) wal ::= WAL INTEGER */
-  {  237,   -2 }, /* (80) fsync ::= FSYNC INTEGER */
-  {  238,   -2 }, /* (81) comp ::= COMP INTEGER */
-  {  239,   -2 }, /* (82) prec ::= PRECISION STRING */
-  {  216,    0 }, /* (83) db_optr ::= */
-  {  216,   -2 }, /* (84) db_optr ::= db_optr cache */
-  {  216,   -2 }, /* (85) db_optr ::= db_optr replica */
-  {  216,   -2 }, /* (86) db_optr ::= db_optr quorum */
-  {  216,   -2 }, /* (87) db_optr ::= db_optr days */
-  {  216,   -2 }, /* (88) db_optr ::= db_optr minrows */
-  {  216,   -2 }, /* (89) db_optr ::= db_optr maxrows */
-  {  216,   -2 }, /* (90) db_optr ::= db_optr blocks */
-  {  216,   -2 }, /* (91) db_optr ::= db_optr ctime */
-  {  216,   -2 }, /* (92) db_optr ::= db_optr wal */
-  {  216,   -2 }, /* (93) db_optr ::= db_optr fsync */
-  {  216,   -2 }, /* (94) db_optr ::= db_optr comp */
-  {  216,   -2 }, /* (95) db_optr ::= db_optr prec */
-  {  216,   -2 }, /* (96) db_optr ::= db_optr keep */
-  {  213,    0 }, /* (97) alter_db_optr ::= */
-  {  213,   -2 }, /* (98) alter_db_optr ::= alter_db_optr replica */
-  {  213,   -2 }, /* (99) alter_db_optr ::= alter_db_optr quorum */
-  {  213,   -2 }, /* (100) alter_db_optr ::= alter_db_optr keep */
-  {  213,   -2 }, /* (101) alter_db_optr ::= alter_db_optr blocks */
-  {  213,   -2 }, /* (102) alter_db_optr ::= alter_db_optr comp */
-  {  213,   -2 }, /* (103) alter_db_optr ::= alter_db_optr wal */
-  {  213,   -2 }, /* (104) alter_db_optr ::= alter_db_optr fsync */
-  {  240,   -1 }, /* (105) typename ::= ids */
-  {  240,   -4 }, /* (106) typename ::= ids LP signed RP */
-  {  241,   -1 }, /* (107) signed ::= INTEGER */
-  {  241,   -2 }, /* (108) signed ::= PLUS INTEGER */
-  {  241,   -2 }, /* (109) signed ::= MINUS INTEGER */
-  {  208,   -6 }, /* (110) cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args */
-  {  242,   -3 }, /* (111) create_table_args ::= LP columnlist RP */
-  {  242,   -7 }, /* (112) create_table_args ::= LP columnlist RP TAGS LP columnlist RP */
-  {  242,   -7 }, /* (113) create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP */
-  {  242,   -2 }, /* (114) create_table_args ::= AS select */
-  {  243,   -3 }, /* (115) columnlist ::= columnlist COMMA column */
-  {  243,   -1 }, /* (116) columnlist ::= column */
-  {  245,   -2 }, /* (117) column ::= ids typename */
-  {  227,   -3 }, /* (118) tagitemlist ::= tagitemlist COMMA tagitem */
-  {  227,   -1 }, /* (119) tagitemlist ::= tagitem */
-  {  246,   -1 }, /* (120) tagitem ::= INTEGER */
-  {  246,   -1 }, /* (121) tagitem ::= FLOAT */
-  {  246,   -1 }, /* (122) tagitem ::= STRING */
-  {  246,   -1 }, /* (123) tagitem ::= BOOL */
-  {  246,   -1 }, /* (124) tagitem ::= NULL */
-  {  246,   -2 }, /* (125) tagitem ::= MINUS INTEGER */
-  {  246,   -2 }, /* (126) tagitem ::= MINUS FLOAT */
-  {  246,   -2 }, /* (127) tagitem ::= PLUS INTEGER */
-  {  246,   -2 }, /* (128) tagitem ::= PLUS FLOAT */
-  {  244,  -12 }, /* (129) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
-  {  258,   -1 }, /* (130) union ::= select */
-  {  258,   -3 }, /* (131) union ::= LP union RP */
-  {  258,   -4 }, /* (132) union ::= union UNION ALL select */
-  {  258,   -6 }, /* (133) union ::= union UNION ALL LP select RP */
-  {  208,   -1 }, /* (134) cmd ::= union */
-  {  244,   -2 }, /* (135) select ::= SELECT selcollist */
-  {  259,   -2 }, /* (136) sclp ::= selcollist COMMA */
-  {  259,    0 }, /* (137) sclp ::= */
-  {  247,   -3 }, /* (138) selcollist ::= sclp expr as */
-  {  247,   -2 }, /* (139) selcollist ::= sclp STAR */
-  {  261,   -2 }, /* (140) as ::= AS ids */
-  {  261,   -1 }, /* (141) as ::= ids */
-  {  261,    0 }, /* (142) as ::= */
-  {  248,   -2 }, /* (143) from ::= FROM tablelist */
-  {  262,   -2 }, /* (144) tablelist ::= ids cpxName */
-  {  262,   -3 }, /* (145) tablelist ::= ids cpxName ids */
-  {  262,   -4 }, /* (146) tablelist ::= tablelist COMMA ids cpxName */
-  {  262,   -5 }, /* (147) tablelist ::= tablelist COMMA ids cpxName ids */
-  {  263,   -1 }, /* (148) tmvar ::= VARIABLE */
-  {  250,   -4 }, /* (149) interval_opt ::= INTERVAL LP tmvar RP */
-  {  250,    0 }, /* (150) interval_opt ::= */
-  {  251,    0 }, /* (151) fill_opt ::= */
-  {  251,   -6 }, /* (152) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
-  {  251,   -4 }, /* (153) fill_opt ::= FILL LP ID RP */
-  {  252,   -4 }, /* (154) sliding_opt ::= SLIDING LP tmvar RP */
-  {  252,    0 }, /* (155) sliding_opt ::= */
-  {  254,    0 }, /* (156) orderby_opt ::= */
-  {  254,   -3 }, /* (157) orderby_opt ::= ORDER BY sortlist */
-  {  264,   -4 }, /* (158) sortlist ::= sortlist COMMA item sortorder */
-  {  264,   -2 }, /* (159) sortlist ::= item sortorder */
-  {  266,   -2 }, /* (160) item ::= ids cpxName */
-  {  267,   -1 }, /* (161) sortorder ::= ASC */
-  {  267,   -1 }, /* (162) sortorder ::= DESC */
-  {  267,    0 }, /* (163) sortorder ::= */
-  {  253,    0 }, /* (164) groupby_opt ::= */
-  {  253,   -3 }, /* (165) groupby_opt ::= GROUP BY grouplist */
-  {  268,   -3 }, /* (166) grouplist ::= grouplist COMMA item */
-  {  268,   -1 }, /* (167) grouplist ::= item */
-  {  255,    0 }, /* (168) having_opt ::= */
-  {  255,   -2 }, /* (169) having_opt ::= HAVING expr */
-  {  257,    0 }, /* (170) limit_opt ::= */
-  {  257,   -2 }, /* (171) limit_opt ::= LIMIT signed */
-  {  257,   -4 }, /* (172) limit_opt ::= LIMIT signed OFFSET signed */
-  {  257,   -4 }, /* (173) limit_opt ::= LIMIT signed COMMA signed */
-  {  256,    0 }, /* (174) slimit_opt ::= */
-  {  256,   -2 }, /* (175) slimit_opt ::= SLIMIT signed */
-  {  256,   -4 }, /* (176) slimit_opt ::= SLIMIT signed SOFFSET signed */
-  {  256,   -4 }, /* (177) slimit_opt ::= SLIMIT signed COMMA signed */
-  {  249,    0 }, /* (178) where_opt ::= */
-  {  249,   -2 }, /* (179) where_opt ::= WHERE expr */
-  {  260,   -3 }, /* (180) expr ::= LP expr RP */
-  {  260,   -1 }, /* (181) expr ::= ID */
-  {  260,   -3 }, /* (182) expr ::= ID DOT ID */
-  {  260,   -3 }, /* (183) expr ::= ID DOT STAR */
-  {  260,   -1 }, /* (184) expr ::= INTEGER */
-  {  260,   -2 }, /* (185) expr ::= MINUS INTEGER */
-  {  260,   -2 }, /* (186) expr ::= PLUS INTEGER */
-  {  260,   -1 }, /* (187) expr ::= FLOAT */
-  {  260,   -2 }, /* (188) expr ::= MINUS FLOAT */
-  {  260,   -2 }, /* (189) expr ::= PLUS FLOAT */
-  {  260,   -1 }, /* (190) expr ::= STRING */
-  {  260,   -1 }, /* (191) expr ::= NOW */
-  {  260,   -1 }, /* (192) expr ::= VARIABLE */
-  {  260,   -1 }, /* (193) expr ::= BOOL */
-  {  260,   -4 }, /* (194) expr ::= ID LP exprlist RP */
-  {  260,   -4 }, /* (195) expr ::= ID LP STAR RP */
-  {  260,   -3 }, /* (196) expr ::= expr AND expr */
-  {  260,   -3 }, /* (197) expr ::= expr OR expr */
-  {  260,   -3 }, /* (198) expr ::= expr LT expr */
-  {  260,   -3 }, /* (199) expr ::= expr GT expr */
-  {  260,   -3 }, /* (200) expr ::= expr LE expr */
-  {  260,   -3 }, /* (201) expr ::= expr GE expr */
-  {  260,   -3 }, /* (202) expr ::= expr NE expr */
-  {  260,   -3 }, /* (203) expr ::= expr EQ expr */
-  {  260,   -3 }, /* (204) expr ::= expr PLUS expr */
-  {  260,   -3 }, /* (205) expr ::= expr MINUS expr */
-  {  260,   -3 }, /* (206) expr ::= expr STAR expr */
-  {  260,   -3 }, /* (207) expr ::= expr SLASH expr */
-  {  260,   -3 }, /* (208) expr ::= expr REM expr */
-  {  260,   -3 }, /* (209) expr ::= expr LIKE expr */
-  {  260,   -5 }, /* (210) expr ::= expr IN LP exprlist RP */
-  {  269,   -3 }, /* (211) exprlist ::= exprlist COMMA expritem */
-  {  269,   -1 }, /* (212) exprlist ::= expritem */
-  {  270,   -1 }, /* (213) expritem ::= expr */
-  {  270,    0 }, /* (214) expritem ::= */
-  {  208,   -3 }, /* (215) cmd ::= RESET QUERY CACHE */
-  {  208,   -7 }, /* (216) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
-  {  208,   -7 }, /* (217) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
-  {  208,   -7 }, /* (218) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
-  {  208,   -7 }, /* (219) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
-  {  208,   -8 }, /* (220) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
-  {  208,   -9 }, /* (221) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
-  {  208,   -3 }, /* (222) cmd ::= KILL CONNECTION INTEGER */
-  {  208,   -5 }, /* (223) cmd ::= KILL STREAM INTEGER COLON INTEGER */
-  {  208,   -5 }, /* (224) cmd ::= KILL QUERY INTEGER COLON INTEGER */
+  {  208,   -5 }, /* (19) cmd ::= SHOW CREATE TABLE ids cpxName */
+  {  208,   -4 }, /* (20) cmd ::= SHOW CREATE DATABASE ids */
+  {  208,   -3 }, /* (21) cmd ::= SHOW dbPrefix TABLES */
+  {  208,   -5 }, /* (22) cmd ::= SHOW dbPrefix TABLES LIKE ids */
+  {  208,   -3 }, /* (23) cmd ::= SHOW dbPrefix STABLES */
+  {  208,   -5 }, /* (24) cmd ::= SHOW dbPrefix STABLES LIKE ids */
+  {  208,   -3 }, /* (25) cmd ::= SHOW dbPrefix VGROUPS */
+  {  208,   -4 }, /* (26) cmd ::= SHOW dbPrefix VGROUPS ids */
+  {  208,   -5 }, /* (27) cmd ::= DROP TABLE ifexists ids cpxName */
+  {  208,   -4 }, /* (28) cmd ::= DROP DATABASE ifexists ids */
+  {  208,   -3 }, /* (29) cmd ::= DROP DNODE ids */
+  {  208,   -3 }, /* (30) cmd ::= DROP USER ids */
+  {  208,   -3 }, /* (31) cmd ::= DROP ACCOUNT ids */
+  {  208,   -2 }, /* (32) cmd ::= USE ids */
+  {  208,   -3 }, /* (33) cmd ::= DESCRIBE ids cpxName */
+  {  208,   -5 }, /* (34) cmd ::= ALTER USER ids PASS ids */
+  {  208,   -5 }, /* (35) cmd ::= ALTER USER ids PRIVILEGE ids */
+  {  208,   -4 }, /* (36) cmd ::= ALTER DNODE ids ids */
+  {  208,   -5 }, /* (37) cmd ::= ALTER DNODE ids ids ids */
+  {  208,   -3 }, /* (38) cmd ::= ALTER LOCAL ids */
+  {  208,   -4 }, /* (39) cmd ::= ALTER LOCAL ids ids */
+  {  208,   -4 }, /* (40) cmd ::= ALTER DATABASE ids alter_db_optr */
+  {  208,   -4 }, /* (41) cmd ::= ALTER ACCOUNT ids acct_optr */
+  {  208,   -6 }, /* (42) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
+  {  210,   -1 }, /* (43) ids ::= ID */
+  {  210,   -1 }, /* (44) ids ::= STRING */
+  {  212,   -2 }, /* (45) ifexists ::= IF EXISTS */
+  {  212,    0 }, /* (46) ifexists ::= */
+  {  215,   -3 }, /* (47) ifnotexists ::= IF NOT EXISTS */
+  {  215,    0 }, /* (48) ifnotexists ::= */
+  {  208,   -3 }, /* (49) cmd ::= CREATE DNODE ids */
+  {  208,   -6 }, /* (50) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
+  {  208,   -5 }, /* (51) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
+  {  208,   -5 }, /* (52) cmd ::= CREATE USER ids PASS ids */
+  {  217,    0 }, /* (53) pps ::= */
+  {  217,   -2 }, /* (54) pps ::= PPS INTEGER */
+  {  218,    0 }, /* (55) tseries ::= */
+  {  218,   -2 }, /* (56) tseries ::= TSERIES INTEGER */
+  {  219,    0 }, /* (57) dbs ::= */
+  {  219,   -2 }, /* (58) dbs ::= DBS INTEGER */
+  {  220,    0 }, /* (59) streams ::= */
+  {  220,   -2 }, /* (60) streams ::= STREAMS INTEGER */
+  {  221,    0 }, /* (61) storage ::= */
+  {  221,   -2 }, /* (62) storage ::= STORAGE INTEGER */
+  {  222,    0 }, /* (63) qtime ::= */
+  {  222,   -2 }, /* (64) qtime ::= QTIME INTEGER */
+  {  223,    0 }, /* (65) users ::= */
+  {  223,   -2 }, /* (66) users ::= USERS INTEGER */
+  {  224,    0 }, /* (67) conns ::= */
+  {  224,   -2 }, /* (68) conns ::= CONNS INTEGER */
+  {  225,    0 }, /* (69) state ::= */
+  {  225,   -2 }, /* (70) state ::= STATE ids */
+  {  214,   -9 }, /* (71) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
+  {  226,   -2 }, /* (72) keep ::= KEEP tagitemlist */
+  {  228,   -2 }, /* (73) cache ::= CACHE INTEGER */
+  {  229,   -2 }, /* (74) replica ::= REPLICA INTEGER */
+  {  230,   -2 }, /* (75) quorum ::= QUORUM INTEGER */
+  {  231,   -2 }, /* (76) days ::= DAYS INTEGER */
+  {  232,   -2 }, /* (77) minrows ::= MINROWS INTEGER */
+  {  233,   -2 }, /* (78) maxrows ::= MAXROWS INTEGER */
+  {  234,   -2 }, /* (79) blocks ::= BLOCKS INTEGER */
+  {  235,   -2 }, /* (80) ctime ::= CTIME INTEGER */
+  {  236,   -2 }, /* (81) wal ::= WAL INTEGER */
+  {  237,   -2 }, /* (82) fsync ::= FSYNC INTEGER */
+  {  238,   -2 }, /* (83) comp ::= COMP INTEGER */
+  {  239,   -2 }, /* (84) prec ::= PRECISION STRING */
+  {  216,    0 }, /* (85) db_optr ::= */
+  {  216,   -2 }, /* (86) db_optr ::= db_optr cache */
+  {  216,   -2 }, /* (87) db_optr ::= db_optr replica */
+  {  216,   -2 }, /* (88) db_optr ::= db_optr quorum */
+  {  216,   -2 }, /* (89) db_optr ::= db_optr days */
+  {  216,   -2 }, /* (90) db_optr ::= db_optr minrows */
+  {  216,   -2 }, /* (91) db_optr ::= db_optr maxrows */
+  {  216,   -2 }, /* (92) db_optr ::= db_optr blocks */
+  {  216,   -2 }, /* (93) db_optr ::= db_optr ctime */
+  {  216,   -2 }, /* (94) db_optr ::= db_optr wal */
+  {  216,   -2 }, /* (95) db_optr ::= db_optr fsync */
+  {  216,   -2 }, /* (96) db_optr ::= db_optr comp */
+  {  216,   -2 }, /* (97) db_optr ::= db_optr prec */
+  {  216,   -2 }, /* (98) db_optr ::= db_optr keep */
+  {  213,    0 }, /* (99) alter_db_optr ::= */
+  {  213,   -2 }, /* (100) alter_db_optr ::= alter_db_optr replica */
+  {  213,   -2 }, /* (101) alter_db_optr ::= alter_db_optr quorum */
+  {  213,   -2 }, /* (102) alter_db_optr ::= alter_db_optr keep */
+  {  213,   -2 }, /* (103) alter_db_optr ::= alter_db_optr blocks */
+  {  213,   -2 }, /* (104) alter_db_optr ::= alter_db_optr comp */
+  {  213,   -2 }, /* (105) alter_db_optr ::= alter_db_optr wal */
+  {  213,   -2 }, /* (106) alter_db_optr ::= alter_db_optr fsync */
+  {  240,   -1 }, /* (107) typename ::= ids */
+  {  240,   -4 }, /* (108) typename ::= ids LP signed RP */
+  {  241,   -1 }, /* (109) signed ::= INTEGER */
+  {  241,   -2 }, /* (110) signed ::= PLUS INTEGER */
+  {  241,   -2 }, /* (111) signed ::= MINUS INTEGER */
+  {  208,   -6 }, /* (112) cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args */
+  {  242,   -3 }, /* (113) create_table_args ::= LP columnlist RP */
+  {  242,   -7 }, /* (114) create_table_args ::= LP columnlist RP TAGS LP columnlist RP */
+  {  242,   -7 }, /* (115) create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP */
+  {  242,   -2 }, /* (116) create_table_args ::= AS select */
+  {  243,   -3 }, /* (117) columnlist ::= columnlist COMMA column */
+  {  243,   -1 }, /* (118) columnlist ::= column */
+  {  245,   -2 }, /* (119) column ::= ids typename */
+  {  227,   -3 }, /* (120) tagitemlist ::= tagitemlist COMMA tagitem */
+  {  227,   -1 }, /* (121) tagitemlist ::= tagitem */
+  {  246,   -1 }, /* (122) tagitem ::= INTEGER */
+  {  246,   -1 }, /* (123) tagitem ::= FLOAT */
+  {  246,   -1 }, /* (124) tagitem ::= STRING */
+  {  246,   -1 }, /* (125) tagitem ::= BOOL */
+  {  246,   -1 }, /* (126) tagitem ::= NULL */
+  {  246,   -2 }, /* (127) tagitem ::= MINUS INTEGER */
+  {  246,   -2 }, /* (128) tagitem ::= MINUS FLOAT */
+  {  246,   -2 }, /* (129) tagitem ::= PLUS INTEGER */
+  {  246,   -2 }, /* (130) tagitem ::= PLUS FLOAT */
+  {  244,  -12 }, /* (131) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
+  {  258,   -1 }, /* (132) union ::= select */
+  {  258,   -3 }, /* (133) union ::= LP union RP */
+  {  258,   -4 }, /* (134) union ::= union UNION ALL select */
+  {  258,   -6 }, /* (135) union ::= union UNION ALL LP select RP */
+  {  208,   -1 }, /* (136) cmd ::= union */
+  {  244,   -2 }, /* (137) select ::= SELECT selcollist */
+  {  259,   -2 }, /* (138) sclp ::= selcollist COMMA */
+  {  259,    0 }, /* (139) sclp ::= */
+  {  247,   -3 }, /* (140) selcollist ::= sclp expr as */
+  {  247,   -2 }, /* (141) selcollist ::= sclp STAR */
+  {  261,   -2 }, /* (142) as ::= AS ids */
+  {  261,   -1 }, /* (143) as ::= ids */
+  {  261,    0 }, /* (144) as ::= */
+  {  248,   -2 }, /* (145) from ::= FROM tablelist */
+  {  262,   -2 }, /* (146) tablelist ::= ids cpxName */
+  {  262,   -3 }, /* (147) tablelist ::= ids cpxName ids */
+  {  262,   -4 }, /* (148) tablelist ::= tablelist COMMA ids cpxName */
+  {  262,   -5 }, /* (149) tablelist ::= tablelist COMMA ids cpxName ids */
+  {  263,   -1 }, /* (150) tmvar ::= VARIABLE */
+  {  250,   -4 }, /* (151) interval_opt ::= INTERVAL LP tmvar RP */
+  {  250,    0 }, /* (152) interval_opt ::= */
+  {  251,    0 }, /* (153) fill_opt ::= */
+  {  251,   -6 }, /* (154) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+  {  251,   -4 }, /* (155) fill_opt ::= FILL LP ID RP */
+  {  252,   -4 }, /* (156) sliding_opt ::= SLIDING LP tmvar RP */
+  {  252,    0 }, /* (157) sliding_opt ::= */
+  {  254,    0 }, /* (158) orderby_opt ::= */
+  {  254,   -3 }, /* (159) orderby_opt ::= ORDER BY sortlist */
+  {  264,   -4 }, /* (160) sortlist ::= sortlist COMMA item sortorder */
+  {  264,   -2 }, /* (161) sortlist ::= item sortorder */
+  {  266,   -2 }, /* (162) item ::= ids cpxName */
+  {  267,   -1 }, /* (163) sortorder ::= ASC */
+  {  267,   -1 }, /* (164) sortorder ::= DESC */
+  {  267,    0 }, /* (165) sortorder ::= */
+  {  253,    0 }, /* (166) groupby_opt ::= */
+  {  253,   -3 }, /* (167) groupby_opt ::= GROUP BY grouplist */
+  {  268,   -3 }, /* (168) grouplist ::= grouplist COMMA item */
+  {  268,   -1 }, /* (169) grouplist ::= item */
+  {  255,    0 }, /* (170) having_opt ::= */
+  {  255,   -2 }, /* (171) having_opt ::= HAVING expr */
+  {  257,    0 }, /* (172) limit_opt ::= */
+  {  257,   -2 }, /* (173) limit_opt ::= LIMIT signed */
+  {  257,   -4 }, /* (174) limit_opt ::= LIMIT signed OFFSET signed */
+  {  257,   -4 }, /* (175) limit_opt ::= LIMIT signed COMMA signed */
+  {  256,    0 }, /* (176) slimit_opt ::= */
+  {  256,   -2 }, /* (177) slimit_opt ::= SLIMIT signed */
+  {  256,   -4 }, /* (178) slimit_opt ::= SLIMIT signed SOFFSET signed */
+  {  256,   -4 }, /* (179) slimit_opt ::= SLIMIT signed COMMA signed */
+  {  249,    0 }, /* (180) where_opt ::= */
+  {  249,   -2 }, /* (181) where_opt ::= WHERE expr */
+  {  260,   -3 }, /* (182) expr ::= LP expr RP */
+  {  260,   -1 }, /* (183) expr ::= ID */
+  {  260,   -3 }, /* (184) expr ::= ID DOT ID */
+  {  260,   -3 }, /* (185) expr ::= ID DOT STAR */
+  {  260,   -1 }, /* (186) expr ::= INTEGER */
+  {  260,   -2 }, /* (187) expr ::= MINUS INTEGER */
+  {  260,   -2 }, /* (188) expr ::= PLUS INTEGER */
+  {  260,   -1 }, /* (189) expr ::= FLOAT */
+  {  260,   -2 }, /* (190) expr ::= MINUS FLOAT */
+  {  260,   -2 }, /* (191) expr ::= PLUS FLOAT */
+  {  260,   -1 }, /* (192) expr ::= STRING */
+  {  260,   -1 }, /* (193) expr ::= NOW */
+  {  260,   -1 }, /* (194) expr ::= VARIABLE */
+  {  260,   -1 }, /* (195) expr ::= BOOL */
+  {  260,   -4 }, /* (196) expr ::= ID LP exprlist RP */
+  {  260,   -4 }, /* (197) expr ::= ID LP STAR RP */
+  {  260,   -3 }, /* (198) expr ::= expr AND expr */
+  {  260,   -3 }, /* (199) expr ::= expr OR expr */
+  {  260,   -3 }, /* (200) expr ::= expr LT expr */
+  {  260,   -3 }, /* (201) expr ::= expr GT expr */
+  {  260,   -3 }, /* (202) expr ::= expr LE expr */
+  {  260,   -3 }, /* (203) expr ::= expr GE expr */
+  {  260,   -3 }, /* (204) expr ::= expr NE expr */
+  {  260,   -3 }, /* (205) expr ::= expr EQ expr */
+  {  260,   -3 }, /* (206) expr ::= expr PLUS expr */
+  {  260,   -3 }, /* (207) expr ::= expr MINUS expr */
+  {  260,   -3 }, /* (208) expr ::= expr STAR expr */
+  {  260,   -3 }, /* (209) expr ::= expr SLASH expr */
+  {  260,   -3 }, /* (210) expr ::= expr REM expr */
+  {  260,   -3 }, /* (211) expr ::= expr LIKE expr */
+  {  260,   -5 }, /* (212) expr ::= expr IN LP exprlist RP */
+  {  269,   -3 }, /* (213) exprlist ::= exprlist COMMA expritem */
+  {  269,   -1 }, /* (214) exprlist ::= expritem */
+  {  270,   -1 }, /* (215) expritem ::= expr */
+  {  270,    0 }, /* (216) expritem ::= */
+  {  208,   -3 }, /* (217) cmd ::= RESET QUERY CACHE */
+  {  208,   -7 }, /* (218) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+  {  208,   -7 }, /* (219) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+  {  208,   -7 }, /* (220) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+  {  208,   -7 }, /* (221) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+  {  208,   -8 }, /* (222) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+  {  208,   -9 }, /* (223) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+  {  208,   -3 }, /* (224) cmd ::= KILL CONNECTION INTEGER */
+  {  208,   -5 }, /* (225) cmd ::= KILL STREAM INTEGER COLON INTEGER */
+  {  208,   -5 }, /* (226) cmd ::= KILL QUERY INTEGER COLON INTEGER */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -2046,146 +2052,157 @@ static void yy_reduce(
       case 18: /* cpxName ::= DOT ids */
 {yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n += 1;    }
         break;
-      case 19: /* cmd ::= SHOW dbPrefix TABLES */
+      case 19: /* cmd ::= SHOW CREATE TABLE ids cpxName */
+{
+   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
+   setDCLSQLElems(pInfo, TSDB_SQL_SHOW_CREATE_TABLE, 1, &yymsp[-1].minor.yy0);
+}
+        break;
+      case 20: /* cmd ::= SHOW CREATE DATABASE ids */
+{
+  setDCLSQLElems(pInfo, TSDB_SQL_SHOW_CREATE_DATABASE, 1, &yymsp[0].minor.yy0);
+}
+        break;
+      case 21: /* cmd ::= SHOW dbPrefix TABLES */
 {
     setShowOptions(pInfo, TSDB_MGMT_TABLE_TABLE, &yymsp[-1].minor.yy0, 0);
 }
         break;
-      case 20: /* cmd ::= SHOW dbPrefix TABLES LIKE ids */
+      case 22: /* cmd ::= SHOW dbPrefix TABLES LIKE ids */
 {
     setShowOptions(pInfo, TSDB_MGMT_TABLE_TABLE, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0);
 }
         break;
-      case 21: /* cmd ::= SHOW dbPrefix STABLES */
+      case 23: /* cmd ::= SHOW dbPrefix STABLES */
 {
     setShowOptions(pInfo, TSDB_MGMT_TABLE_METRIC, &yymsp[-1].minor.yy0, 0);
 }
         break;
-      case 22: /* cmd ::= SHOW dbPrefix STABLES LIKE ids */
+      case 24: /* cmd ::= SHOW dbPrefix STABLES LIKE ids */
 {
     SStrToken token;
     setDBName(&token, &yymsp[-3].minor.yy0);
     setShowOptions(pInfo, TSDB_MGMT_TABLE_METRIC, &token, &yymsp[0].minor.yy0);
 }
         break;
-      case 23: /* cmd ::= SHOW dbPrefix VGROUPS */
+      case 25: /* cmd ::= SHOW dbPrefix VGROUPS */
 {
     SStrToken token;
     setDBName(&token, &yymsp[-1].minor.yy0);
     setShowOptions(pInfo, TSDB_MGMT_TABLE_VGROUP, &token, 0);
 }
         break;
-      case 24: /* cmd ::= SHOW dbPrefix VGROUPS ids */
+      case 26: /* cmd ::= SHOW dbPrefix VGROUPS ids */
 {
     SStrToken token;
     setDBName(&token, &yymsp[-2].minor.yy0);    
     setShowOptions(pInfo, TSDB_MGMT_TABLE_VGROUP, &token, &yymsp[0].minor.yy0);
 }
         break;
-      case 25: /* cmd ::= DROP TABLE ifexists ids cpxName */
+      case 27: /* cmd ::= DROP TABLE ifexists ids cpxName */
 {
     yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
     setDropDBTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &yymsp[-1].minor.yy0, &yymsp[-2].minor.yy0);
 }
         break;
-      case 26: /* cmd ::= DROP DATABASE ifexists ids */
+      case 28: /* cmd ::= DROP DATABASE ifexists ids */
 { setDropDBTableInfo(pInfo, TSDB_SQL_DROP_DB, &yymsp[0].minor.yy0, &yymsp[-1].minor.yy0); }
         break;
-      case 27: /* cmd ::= DROP DNODE ids */
+      case 29: /* cmd ::= DROP DNODE ids */
 { setDCLSQLElems(pInfo, TSDB_SQL_DROP_DNODE, 1, &yymsp[0].minor.yy0);    }
         break;
-      case 28: /* cmd ::= DROP USER ids */
+      case 30: /* cmd ::= DROP USER ids */
 { setDCLSQLElems(pInfo, TSDB_SQL_DROP_USER, 1, &yymsp[0].minor.yy0);     }
         break;
-      case 29: /* cmd ::= DROP ACCOUNT ids */
+      case 31: /* cmd ::= DROP ACCOUNT ids */
 { setDCLSQLElems(pInfo, TSDB_SQL_DROP_ACCT, 1, &yymsp[0].minor.yy0);  }
         break;
-      case 30: /* cmd ::= USE ids */
+      case 32: /* cmd ::= USE ids */
 { setDCLSQLElems(pInfo, TSDB_SQL_USE_DB, 1, &yymsp[0].minor.yy0);}
         break;
-      case 31: /* cmd ::= DESCRIBE ids cpxName */
+      case 33: /* cmd ::= DESCRIBE ids cpxName */
 {
     yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
     setDCLSQLElems(pInfo, TSDB_SQL_DESCRIBE_TABLE, 1, &yymsp[-1].minor.yy0);
 }
         break;
-      case 32: /* cmd ::= ALTER USER ids PASS ids */
+      case 34: /* cmd ::= ALTER USER ids PASS ids */
 { setAlterUserSQL(pInfo, TSDB_ALTER_USER_PASSWD, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, NULL);    }
         break;
-      case 33: /* cmd ::= ALTER USER ids PRIVILEGE ids */
+      case 35: /* cmd ::= ALTER USER ids PRIVILEGE ids */
 { setAlterUserSQL(pInfo, TSDB_ALTER_USER_PRIVILEGES, &yymsp[-2].minor.yy0, NULL, &yymsp[0].minor.yy0);}
         break;
-      case 34: /* cmd ::= ALTER DNODE ids ids */
+      case 36: /* cmd ::= ALTER DNODE ids ids */
 { setDCLSQLElems(pInfo, TSDB_SQL_CFG_DNODE, 2, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);          }
         break;
-      case 35: /* cmd ::= ALTER DNODE ids ids ids */
+      case 37: /* cmd ::= ALTER DNODE ids ids ids */
 { setDCLSQLElems(pInfo, TSDB_SQL_CFG_DNODE, 3, &yymsp[-2].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);      }
         break;
-      case 36: /* cmd ::= ALTER LOCAL ids */
+      case 38: /* cmd ::= ALTER LOCAL ids */
 { setDCLSQLElems(pInfo, TSDB_SQL_CFG_LOCAL, 1, &yymsp[0].minor.yy0);              }
         break;
-      case 37: /* cmd ::= ALTER LOCAL ids ids */
+      case 39: /* cmd ::= ALTER LOCAL ids ids */
 { setDCLSQLElems(pInfo, TSDB_SQL_CFG_LOCAL, 2, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);          }
         break;
-      case 38: /* cmd ::= ALTER DATABASE ids alter_db_optr */
+      case 40: /* cmd ::= ALTER DATABASE ids alter_db_optr */
 { SStrToken t = {0};  setCreateDBSQL(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy158, &t);}
         break;
-      case 39: /* cmd ::= ALTER ACCOUNT ids acct_optr */
+      case 41: /* cmd ::= ALTER ACCOUNT ids acct_optr */
 { setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy73);}
         break;
-      case 40: /* cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
+      case 42: /* cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
 { setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy73);}
         break;
-      case 41: /* ids ::= ID */
-      case 42: /* ids ::= STRING */ yytestcase(yyruleno==42);
+      case 43: /* ids ::= ID */
+      case 44: /* ids ::= STRING */ yytestcase(yyruleno==44);
 {yylhsminor.yy0 = yymsp[0].minor.yy0; }
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 43: /* ifexists ::= IF EXISTS */
+      case 45: /* ifexists ::= IF EXISTS */
 {yymsp[-1].minor.yy0.n = 1;}
         break;
-      case 44: /* ifexists ::= */
-      case 46: /* ifnotexists ::= */ yytestcase(yyruleno==46);
+      case 46: /* ifexists ::= */
+      case 48: /* ifnotexists ::= */ yytestcase(yyruleno==48);
 {yymsp[1].minor.yy0.n = 0;}
         break;
-      case 45: /* ifnotexists ::= IF NOT EXISTS */
+      case 47: /* ifnotexists ::= IF NOT EXISTS */
 {yymsp[-2].minor.yy0.n = 1;}
         break;
-      case 47: /* cmd ::= CREATE DNODE ids */
+      case 49: /* cmd ::= CREATE DNODE ids */
 { setDCLSQLElems(pInfo, TSDB_SQL_CREATE_DNODE, 1, &yymsp[0].minor.yy0);}
         break;
-      case 48: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
+      case 50: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
 { setCreateAcctSQL(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy73);}
         break;
-      case 49: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */
+      case 51: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */
 { setCreateDBSQL(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy158, &yymsp[-2].minor.yy0);}
         break;
-      case 50: /* cmd ::= CREATE USER ids PASS ids */
+      case 52: /* cmd ::= CREATE USER ids PASS ids */
 { setCreateUserSQL(pInfo, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);}
         break;
-      case 51: /* pps ::= */
-      case 53: /* tseries ::= */ yytestcase(yyruleno==53);
-      case 55: /* dbs ::= */ yytestcase(yyruleno==55);
-      case 57: /* streams ::= */ yytestcase(yyruleno==57);
-      case 59: /* storage ::= */ yytestcase(yyruleno==59);
-      case 61: /* qtime ::= */ yytestcase(yyruleno==61);
-      case 63: /* users ::= */ yytestcase(yyruleno==63);
-      case 65: /* conns ::= */ yytestcase(yyruleno==65);
-      case 67: /* state ::= */ yytestcase(yyruleno==67);
+      case 53: /* pps ::= */
+      case 55: /* tseries ::= */ yytestcase(yyruleno==55);
+      case 57: /* dbs ::= */ yytestcase(yyruleno==57);
+      case 59: /* streams ::= */ yytestcase(yyruleno==59);
+      case 61: /* storage ::= */ yytestcase(yyruleno==61);
+      case 63: /* qtime ::= */ yytestcase(yyruleno==63);
+      case 65: /* users ::= */ yytestcase(yyruleno==65);
+      case 67: /* conns ::= */ yytestcase(yyruleno==67);
+      case 69: /* state ::= */ yytestcase(yyruleno==69);
 {yymsp[1].minor.yy0.n = 0;   }
         break;
-      case 52: /* pps ::= PPS INTEGER */
-      case 54: /* tseries ::= TSERIES INTEGER */ yytestcase(yyruleno==54);
-      case 56: /* dbs ::= DBS INTEGER */ yytestcase(yyruleno==56);
-      case 58: /* streams ::= STREAMS INTEGER */ yytestcase(yyruleno==58);
-      case 60: /* storage ::= STORAGE INTEGER */ yytestcase(yyruleno==60);
-      case 62: /* qtime ::= QTIME INTEGER */ yytestcase(yyruleno==62);
-      case 64: /* users ::= USERS INTEGER */ yytestcase(yyruleno==64);
-      case 66: /* conns ::= CONNS INTEGER */ yytestcase(yyruleno==66);
-      case 68: /* state ::= STATE ids */ yytestcase(yyruleno==68);
+      case 54: /* pps ::= PPS INTEGER */
+      case 56: /* tseries ::= TSERIES INTEGER */ yytestcase(yyruleno==56);
+      case 58: /* dbs ::= DBS INTEGER */ yytestcase(yyruleno==58);
+      case 60: /* streams ::= STREAMS INTEGER */ yytestcase(yyruleno==60);
+      case 62: /* storage ::= STORAGE INTEGER */ yytestcase(yyruleno==62);
+      case 64: /* qtime ::= QTIME INTEGER */ yytestcase(yyruleno==64);
+      case 66: /* users ::= USERS INTEGER */ yytestcase(yyruleno==66);
+      case 68: /* conns ::= CONNS INTEGER */ yytestcase(yyruleno==68);
+      case 70: /* state ::= STATE ids */ yytestcase(yyruleno==70);
 {yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;     }
         break;
-      case 69: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */
+      case 71: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */
 {
     yylhsminor.yy73.maxUsers   = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
     yylhsminor.yy73.maxDbs     = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
@@ -2199,96 +2216,96 @@ static void yy_reduce(
 }
   yymsp[-8].minor.yy73 = yylhsminor.yy73;
         break;
-      case 70: /* keep ::= KEEP tagitemlist */
+      case 72: /* keep ::= KEEP tagitemlist */
 { yymsp[-1].minor.yy494 = yymsp[0].minor.yy494; }
         break;
-      case 71: /* cache ::= CACHE INTEGER */
-      case 72: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==72);
-      case 73: /* quorum ::= QUORUM INTEGER */ yytestcase(yyruleno==73);
-      case 74: /* days ::= DAYS INTEGER */ yytestcase(yyruleno==74);
-      case 75: /* minrows ::= MINROWS INTEGER */ yytestcase(yyruleno==75);
-      case 76: /* maxrows ::= MAXROWS INTEGER */ yytestcase(yyruleno==76);
-      case 77: /* blocks ::= BLOCKS INTEGER */ yytestcase(yyruleno==77);
-      case 78: /* ctime ::= CTIME INTEGER */ yytestcase(yyruleno==78);
-      case 79: /* wal ::= WAL INTEGER */ yytestcase(yyruleno==79);
-      case 80: /* fsync ::= FSYNC INTEGER */ yytestcase(yyruleno==80);
-      case 81: /* comp ::= COMP INTEGER */ yytestcase(yyruleno==81);
-      case 82: /* prec ::= PRECISION STRING */ yytestcase(yyruleno==82);
+      case 73: /* cache ::= CACHE INTEGER */
+      case 74: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==74);
+      case 75: /* quorum ::= QUORUM INTEGER */ yytestcase(yyruleno==75);
+      case 76: /* days ::= DAYS INTEGER */ yytestcase(yyruleno==76);
+      case 77: /* minrows ::= MINROWS INTEGER */ yytestcase(yyruleno==77);
+      case 78: /* maxrows ::= MAXROWS INTEGER */ yytestcase(yyruleno==78);
+      case 79: /* blocks ::= BLOCKS INTEGER */ yytestcase(yyruleno==79);
+      case 80: /* ctime ::= CTIME INTEGER */ yytestcase(yyruleno==80);
+      case 81: /* wal ::= WAL INTEGER */ yytestcase(yyruleno==81);
+      case 82: /* fsync ::= FSYNC INTEGER */ yytestcase(yyruleno==82);
+      case 83: /* comp ::= COMP INTEGER */ yytestcase(yyruleno==83);
+      case 84: /* prec ::= PRECISION STRING */ yytestcase(yyruleno==84);
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
         break;
-      case 83: /* db_optr ::= */
+      case 85: /* db_optr ::= */
 {setDefaultCreateDbOption(&yymsp[1].minor.yy158);}
         break;
-      case 84: /* db_optr ::= db_optr cache */
+      case 86: /* db_optr ::= db_optr cache */
 { yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 85: /* db_optr ::= db_optr replica */
-      case 98: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==98);
+      case 87: /* db_optr ::= db_optr replica */
+      case 100: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==100);
 { yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 86: /* db_optr ::= db_optr quorum */
-      case 99: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==99);
+      case 88: /* db_optr ::= db_optr quorum */
+      case 101: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==101);
 { yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 87: /* db_optr ::= db_optr days */
+      case 89: /* db_optr ::= db_optr days */
 { yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 88: /* db_optr ::= db_optr minrows */
+      case 90: /* db_optr ::= db_optr minrows */
 { yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
   yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 89: /* db_optr ::= db_optr maxrows */
+      case 91: /* db_optr ::= db_optr maxrows */
 { yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
   yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 90: /* db_optr ::= db_optr blocks */
-      case 101: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==101);
+      case 92: /* db_optr ::= db_optr blocks */
+      case 103: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==103);
 { yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 91: /* db_optr ::= db_optr ctime */
+      case 93: /* db_optr ::= db_optr ctime */
 { yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 92: /* db_optr ::= db_optr wal */
-      case 103: /* alter_db_optr ::= alter_db_optr wal */ yytestcase(yyruleno==103);
+      case 94: /* db_optr ::= db_optr wal */
+      case 105: /* alter_db_optr ::= alter_db_optr wal */ yytestcase(yyruleno==105);
 { yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 93: /* db_optr ::= db_optr fsync */
-      case 104: /* alter_db_optr ::= alter_db_optr fsync */ yytestcase(yyruleno==104);
+      case 95: /* db_optr ::= db_optr fsync */
+      case 106: /* alter_db_optr ::= alter_db_optr fsync */ yytestcase(yyruleno==106);
 { yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 94: /* db_optr ::= db_optr comp */
-      case 102: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==102);
+      case 96: /* db_optr ::= db_optr comp */
+      case 104: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==104);
 { yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 95: /* db_optr ::= db_optr prec */
+      case 97: /* db_optr ::= db_optr prec */
 { yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.precision = yymsp[0].minor.yy0; }
   yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 96: /* db_optr ::= db_optr keep */
-      case 100: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==100);
+      case 98: /* db_optr ::= db_optr keep */
+      case 102: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==102);
 { yylhsminor.yy158 = yymsp[-1].minor.yy158; yylhsminor.yy158.keep = yymsp[0].minor.yy494; }
   yymsp[-1].minor.yy158 = yylhsminor.yy158;
         break;
-      case 97: /* alter_db_optr ::= */
+      case 99: /* alter_db_optr ::= */
 { setDefaultCreateDbOption(&yymsp[1].minor.yy158);}
         break;
-      case 105: /* typename ::= ids */
+      case 107: /* typename ::= ids */
 { 
   yymsp[0].minor.yy0.type = 0;
   tSQLSetColumnType (&yylhsminor.yy181, &yymsp[0].minor.yy0); 
 }
   yymsp[0].minor.yy181 = yylhsminor.yy181;
         break;
-      case 106: /* typename ::= ids LP signed RP */
+      case 108: /* typename ::= ids LP signed RP */
 {
     if (yymsp[-1].minor.yy271 <= 0) {
       yymsp[-3].minor.yy0.type = 0;
@@ -2300,84 +2317,84 @@ static void yy_reduce(
 }
   yymsp[-3].minor.yy181 = yylhsminor.yy181;
         break;
-      case 107: /* signed ::= INTEGER */
+      case 109: /* signed ::= INTEGER */
 { yylhsminor.yy271 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
   yymsp[0].minor.yy271 = yylhsminor.yy271;
         break;
-      case 108: /* signed ::= PLUS INTEGER */
+      case 110: /* signed ::= PLUS INTEGER */
 { yymsp[-1].minor.yy271 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
         break;
-      case 109: /* signed ::= MINUS INTEGER */
+      case 111: /* signed ::= MINUS INTEGER */
 { yymsp[-1].minor.yy271 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
         break;
-      case 110: /* cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args */
+      case 112: /* cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args */
 {
     yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
     setCreatedTableName(pInfo, &yymsp[-2].minor.yy0, &yymsp[-3].minor.yy0);
 }
         break;
-      case 111: /* create_table_args ::= LP columnlist RP */
+      case 113: /* create_table_args ::= LP columnlist RP */
 {
     yymsp[-2].minor.yy374 = tSetCreateSQLElems(yymsp[-1].minor.yy449, NULL, NULL, NULL, NULL, TSQL_CREATE_TABLE);
     setSQLInfo(pInfo, yymsp[-2].minor.yy374, NULL, TSDB_SQL_CREATE_TABLE);
 }
         break;
-      case 112: /* create_table_args ::= LP columnlist RP TAGS LP columnlist RP */
+      case 114: /* create_table_args ::= LP columnlist RP TAGS LP columnlist RP */
 {
     yymsp[-6].minor.yy374 = tSetCreateSQLElems(yymsp[-5].minor.yy449, yymsp[-1].minor.yy449, NULL, NULL, NULL, TSQL_CREATE_STABLE);
     setSQLInfo(pInfo, yymsp[-6].minor.yy374, NULL, TSDB_SQL_CREATE_TABLE);
 }
         break;
-      case 113: /* create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP */
+      case 115: /* create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP */
 {
     yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
     yymsp[-6].minor.yy374 = tSetCreateSQLElems(NULL, NULL, &yymsp[-5].minor.yy0, yymsp[-1].minor.yy494, NULL, TSQL_CREATE_TABLE_FROM_STABLE);
     setSQLInfo(pInfo, yymsp[-6].minor.yy374, NULL, TSDB_SQL_CREATE_TABLE);
 }
         break;
-      case 114: /* create_table_args ::= AS select */
+      case 116: /* create_table_args ::= AS select */
 {
     yymsp[-1].minor.yy374 = tSetCreateSQLElems(NULL, NULL, NULL, NULL, yymsp[0].minor.yy150, TSQL_CREATE_STREAM);
     setSQLInfo(pInfo, yymsp[-1].minor.yy374, NULL, TSDB_SQL_CREATE_TABLE);
 }
         break;
-      case 115: /* columnlist ::= columnlist COMMA column */
+      case 117: /* columnlist ::= columnlist COMMA column */
 {yylhsminor.yy449 = tFieldListAppend(yymsp[-2].minor.yy449, &yymsp[0].minor.yy181);   }
   yymsp[-2].minor.yy449 = yylhsminor.yy449;
         break;
-      case 116: /* columnlist ::= column */
+      case 118: /* columnlist ::= column */
 {yylhsminor.yy449 = tFieldListAppend(NULL, &yymsp[0].minor.yy181);}
   yymsp[0].minor.yy449 = yylhsminor.yy449;
         break;
-      case 117: /* column ::= ids typename */
+      case 119: /* column ::= ids typename */
 {
     tSQLSetColumnInfo(&yylhsminor.yy181, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy181);
 }
   yymsp[-1].minor.yy181 = yylhsminor.yy181;
         break;
-      case 118: /* tagitemlist ::= tagitemlist COMMA tagitem */
+      case 120: /* tagitemlist ::= tagitemlist COMMA tagitem */
 { yylhsminor.yy494 = tVariantListAppend(yymsp[-2].minor.yy494, &yymsp[0].minor.yy312, -1);    }
   yymsp[-2].minor.yy494 = yylhsminor.yy494;
         break;
-      case 119: /* tagitemlist ::= tagitem */
+      case 121: /* tagitemlist ::= tagitem */
 { yylhsminor.yy494 = tVariantListAppend(NULL, &yymsp[0].minor.yy312, -1); }
   yymsp[0].minor.yy494 = yylhsminor.yy494;
         break;
-      case 120: /* tagitem ::= INTEGER */
-      case 121: /* tagitem ::= FLOAT */ yytestcase(yyruleno==121);
-      case 122: /* tagitem ::= STRING */ yytestcase(yyruleno==122);
-      case 123: /* tagitem ::= BOOL */ yytestcase(yyruleno==123);
+      case 122: /* tagitem ::= INTEGER */
+      case 123: /* tagitem ::= FLOAT */ yytestcase(yyruleno==123);
+      case 124: /* tagitem ::= STRING */ yytestcase(yyruleno==124);
+      case 125: /* tagitem ::= BOOL */ yytestcase(yyruleno==125);
 {toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy312, &yymsp[0].minor.yy0); }
   yymsp[0].minor.yy312 = yylhsminor.yy312;
         break;
-      case 124: /* tagitem ::= NULL */
+      case 126: /* tagitem ::= NULL */
 { yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy312, &yymsp[0].minor.yy0); }
   yymsp[0].minor.yy312 = yylhsminor.yy312;
         break;
-      case 125: /* tagitem ::= MINUS INTEGER */
-      case 126: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==126);
-      case 127: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==127);
-      case 128: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==128);
+      case 127: /* tagitem ::= MINUS INTEGER */
+      case 128: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==128);
+      case 129: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==129);
+      case 130: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==130);
 {
     yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
     yymsp[-1].minor.yy0.type = yymsp[0].minor.yy0.type;
@@ -2386,70 +2403,70 @@ static void yy_reduce(
 }
   yymsp[-1].minor.yy312 = yylhsminor.yy312;
         break;
-      case 129: /* select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
+      case 131: /* select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
 {
   yylhsminor.yy150 = tSetQuerySQLElems(&yymsp[-11].minor.yy0, yymsp[-10].minor.yy224, yymsp[-9].minor.yy494, yymsp[-8].minor.yy66, yymsp[-4].minor.yy494, yymsp[-3].minor.yy494, &yymsp[-7].minor.yy0, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy494, &yymsp[0].minor.yy188, &yymsp[-1].minor.yy188);
 }
   yymsp[-11].minor.yy150 = yylhsminor.yy150;
         break;
-      case 130: /* union ::= select */
+      case 132: /* union ::= select */
 { yylhsminor.yy25 = setSubclause(NULL, yymsp[0].minor.yy150); }
   yymsp[0].minor.yy25 = yylhsminor.yy25;
         break;
-      case 131: /* union ::= LP union RP */
+      case 133: /* union ::= LP union RP */
 { yymsp[-2].minor.yy25 = yymsp[-1].minor.yy25; }
         break;
-      case 132: /* union ::= union UNION ALL select */
+      case 134: /* union ::= union UNION ALL select */
 { yylhsminor.yy25 = appendSelectClause(yymsp[-3].minor.yy25, yymsp[0].minor.yy150); }
   yymsp[-3].minor.yy25 = yylhsminor.yy25;
         break;
-      case 133: /* union ::= union UNION ALL LP select RP */
+      case 135: /* union ::= union UNION ALL LP select RP */
 { yylhsminor.yy25 = appendSelectClause(yymsp[-5].minor.yy25, yymsp[-1].minor.yy150); }
   yymsp[-5].minor.yy25 = yylhsminor.yy25;
         break;
-      case 134: /* cmd ::= union */
+      case 136: /* cmd ::= union */
 { setSQLInfo(pInfo, yymsp[0].minor.yy25, NULL, TSDB_SQL_SELECT); }
         break;
-      case 135: /* select ::= SELECT selcollist */
+      case 137: /* select ::= SELECT selcollist */
 {
   yylhsminor.yy150 = tSetQuerySQLElems(&yymsp[-1].minor.yy0, yymsp[0].minor.yy224, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
   yymsp[-1].minor.yy150 = yylhsminor.yy150;
         break;
-      case 136: /* sclp ::= selcollist COMMA */
+      case 138: /* sclp ::= selcollist COMMA */
 {yylhsminor.yy224 = yymsp[-1].minor.yy224;}
   yymsp[-1].minor.yy224 = yylhsminor.yy224;
         break;
-      case 137: /* sclp ::= */
+      case 139: /* sclp ::= */
 {yymsp[1].minor.yy224 = 0;}
         break;
-      case 138: /* selcollist ::= sclp expr as */
+      case 140: /* selcollist ::= sclp expr as */
 {
    yylhsminor.yy224 = tSQLExprListAppend(yymsp[-2].minor.yy224, yymsp[-1].minor.yy66, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
 }
   yymsp[-2].minor.yy224 = yylhsminor.yy224;
         break;
-      case 139: /* selcollist ::= sclp STAR */
+      case 141: /* selcollist ::= sclp STAR */
 {
    tSQLExpr *pNode = tSQLExprIdValueCreate(NULL, TK_ALL);
    yylhsminor.yy224 = tSQLExprListAppend(yymsp[-1].minor.yy224, pNode, 0);
 }
   yymsp[-1].minor.yy224 = yylhsminor.yy224;
         break;
-      case 140: /* as ::= AS ids */
+      case 142: /* as ::= AS ids */
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;    }
         break;
-      case 141: /* as ::= ids */
+      case 143: /* as ::= ids */
 { yylhsminor.yy0 = yymsp[0].minor.yy0;    }
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 142: /* as ::= */
+      case 144: /* as ::= */
 { yymsp[1].minor.yy0.n = 0;  }
         break;
-      case 143: /* from ::= FROM tablelist */
+      case 145: /* from ::= FROM tablelist */
 {yymsp[-1].minor.yy494 = yymsp[0].minor.yy494;}
         break;
-      case 144: /* tablelist ::= ids cpxName */
+      case 146: /* tablelist ::= ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
@@ -2458,7 +2475,7 @@ static void yy_reduce(
 }
   yymsp[-1].minor.yy494 = yylhsminor.yy494;
         break;
-      case 145: /* tablelist ::= ids cpxName ids */
+      case 147: /* tablelist ::= ids cpxName ids */
 {
    toTSDBType(yymsp[-2].minor.yy0.type);
    toTSDBType(yymsp[0].minor.yy0.type);
@@ -2468,7 +2485,7 @@ static void yy_reduce(
 }
   yymsp[-2].minor.yy494 = yylhsminor.yy494;
         break;
-      case 146: /* tablelist ::= tablelist COMMA ids cpxName */
+      case 148: /* tablelist ::= tablelist COMMA ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
@@ -2477,7 +2494,7 @@ static void yy_reduce(
 }
   yymsp[-3].minor.yy494 = yylhsminor.yy494;
         break;
-      case 147: /* tablelist ::= tablelist COMMA ids cpxName ids */
+      case 149: /* tablelist ::= tablelist COMMA ids cpxName ids */
 {
    toTSDBType(yymsp[-2].minor.yy0.type);
    toTSDBType(yymsp[0].minor.yy0.type);
@@ -2487,22 +2504,22 @@ static void yy_reduce(
 }
   yymsp[-4].minor.yy494 = yylhsminor.yy494;
         break;
-      case 148: /* tmvar ::= VARIABLE */
+      case 150: /* tmvar ::= VARIABLE */
 {yylhsminor.yy0 = yymsp[0].minor.yy0;}
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 149: /* interval_opt ::= INTERVAL LP tmvar RP */
-      case 154: /* sliding_opt ::= SLIDING LP tmvar RP */ yytestcase(yyruleno==154);
+      case 151: /* interval_opt ::= INTERVAL LP tmvar RP */
+      case 156: /* sliding_opt ::= SLIDING LP tmvar RP */ yytestcase(yyruleno==156);
 {yymsp[-3].minor.yy0 = yymsp[-1].minor.yy0;     }
         break;
-      case 150: /* interval_opt ::= */
-      case 155: /* sliding_opt ::= */ yytestcase(yyruleno==155);
+      case 152: /* interval_opt ::= */
+      case 157: /* sliding_opt ::= */ yytestcase(yyruleno==157);
 {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0;   }
         break;
-      case 151: /* fill_opt ::= */
+      case 153: /* fill_opt ::= */
 {yymsp[1].minor.yy494 = 0;     }
         break;
-      case 152: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+      case 154: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
 {
     tVariant A = {0};
     toTSDBType(yymsp[-3].minor.yy0.type);
@@ -2512,33 +2529,33 @@ static void yy_reduce(
     yymsp[-5].minor.yy494 = yymsp[-1].minor.yy494;
 }
         break;
-      case 153: /* fill_opt ::= FILL LP ID RP */
+      case 155: /* fill_opt ::= FILL LP ID RP */
 {
     toTSDBType(yymsp[-1].minor.yy0.type);
     yymsp[-3].minor.yy494 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
 }
         break;
-      case 156: /* orderby_opt ::= */
-      case 164: /* groupby_opt ::= */ yytestcase(yyruleno==164);
+      case 158: /* orderby_opt ::= */
+      case 166: /* groupby_opt ::= */ yytestcase(yyruleno==166);
 {yymsp[1].minor.yy494 = 0;}
         break;
-      case 157: /* orderby_opt ::= ORDER BY sortlist */
-      case 165: /* groupby_opt ::= GROUP BY grouplist */ yytestcase(yyruleno==165);
+      case 159: /* orderby_opt ::= ORDER BY sortlist */
+      case 167: /* groupby_opt ::= GROUP BY grouplist */ yytestcase(yyruleno==167);
 {yymsp[-2].minor.yy494 = yymsp[0].minor.yy494;}
         break;
-      case 158: /* sortlist ::= sortlist COMMA item sortorder */
+      case 160: /* sortlist ::= sortlist COMMA item sortorder */
 {
     yylhsminor.yy494 = tVariantListAppend(yymsp[-3].minor.yy494, &yymsp[-1].minor.yy312, yymsp[0].minor.yy82);
 }
   yymsp[-3].minor.yy494 = yylhsminor.yy494;
         break;
-      case 159: /* sortlist ::= item sortorder */
+      case 161: /* sortlist ::= item sortorder */
 {
   yylhsminor.yy494 = tVariantListAppend(NULL, &yymsp[-1].minor.yy312, yymsp[0].minor.yy82);
 }
   yymsp[-1].minor.yy494 = yylhsminor.yy494;
         break;
-      case 160: /* item ::= ids cpxName */
+      case 162: /* item ::= ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
@@ -2547,196 +2564,196 @@ static void yy_reduce(
 }
   yymsp[-1].minor.yy312 = yylhsminor.yy312;
         break;
-      case 161: /* sortorder ::= ASC */
+      case 163: /* sortorder ::= ASC */
 {yymsp[0].minor.yy82 = TSDB_ORDER_ASC; }
         break;
-      case 162: /* sortorder ::= DESC */
+      case 164: /* sortorder ::= DESC */
 {yymsp[0].minor.yy82 = TSDB_ORDER_DESC;}
         break;
-      case 163: /* sortorder ::= */
+      case 165: /* sortorder ::= */
 {yymsp[1].minor.yy82 = TSDB_ORDER_ASC;}
         break;
-      case 166: /* grouplist ::= grouplist COMMA item */
+      case 168: /* grouplist ::= grouplist COMMA item */
 {
   yylhsminor.yy494 = tVariantListAppend(yymsp[-2].minor.yy494, &yymsp[0].minor.yy312, -1);
 }
   yymsp[-2].minor.yy494 = yylhsminor.yy494;
         break;
-      case 167: /* grouplist ::= item */
+      case 169: /* grouplist ::= item */
 {
   yylhsminor.yy494 = tVariantListAppend(NULL, &yymsp[0].minor.yy312, -1);
 }
   yymsp[0].minor.yy494 = yylhsminor.yy494;
         break;
-      case 168: /* having_opt ::= */
-      case 178: /* where_opt ::= */ yytestcase(yyruleno==178);
-      case 214: /* expritem ::= */ yytestcase(yyruleno==214);
+      case 170: /* having_opt ::= */
+      case 180: /* where_opt ::= */ yytestcase(yyruleno==180);
+      case 216: /* expritem ::= */ yytestcase(yyruleno==216);
 {yymsp[1].minor.yy66 = 0;}
         break;
-      case 169: /* having_opt ::= HAVING expr */
-      case 179: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==179);
+      case 171: /* having_opt ::= HAVING expr */
+      case 181: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==181);
 {yymsp[-1].minor.yy66 = yymsp[0].minor.yy66;}
         break;
-      case 170: /* limit_opt ::= */
-      case 174: /* slimit_opt ::= */ yytestcase(yyruleno==174);
+      case 172: /* limit_opt ::= */
+      case 176: /* slimit_opt ::= */ yytestcase(yyruleno==176);
 {yymsp[1].minor.yy188.limit = -1; yymsp[1].minor.yy188.offset = 0;}
         break;
-      case 171: /* limit_opt ::= LIMIT signed */
-      case 175: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==175);
+      case 173: /* limit_opt ::= LIMIT signed */
+      case 177: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==177);
 {yymsp[-1].minor.yy188.limit = yymsp[0].minor.yy271;  yymsp[-1].minor.yy188.offset = 0;}
         break;
-      case 172: /* limit_opt ::= LIMIT signed OFFSET signed */
-      case 176: /* slimit_opt ::= SLIMIT signed SOFFSET signed */ yytestcase(yyruleno==176);
+      case 174: /* limit_opt ::= LIMIT signed OFFSET signed */
+      case 178: /* slimit_opt ::= SLIMIT signed SOFFSET signed */ yytestcase(yyruleno==178);
 {yymsp[-3].minor.yy188.limit = yymsp[-2].minor.yy271;  yymsp[-3].minor.yy188.offset = yymsp[0].minor.yy271;}
         break;
-      case 173: /* limit_opt ::= LIMIT signed COMMA signed */
-      case 177: /* slimit_opt ::= SLIMIT signed COMMA signed */ yytestcase(yyruleno==177);
+      case 175: /* limit_opt ::= LIMIT signed COMMA signed */
+      case 179: /* slimit_opt ::= SLIMIT signed COMMA signed */ yytestcase(yyruleno==179);
 {yymsp[-3].minor.yy188.limit = yymsp[0].minor.yy271;  yymsp[-3].minor.yy188.offset = yymsp[-2].minor.yy271;}
         break;
-      case 180: /* expr ::= LP expr RP */
+      case 182: /* expr ::= LP expr RP */
 {yymsp[-2].minor.yy66 = yymsp[-1].minor.yy66; }
         break;
-      case 181: /* expr ::= ID */
+      case 183: /* expr ::= ID */
 {yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_ID);}
   yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 182: /* expr ::= ID DOT ID */
+      case 184: /* expr ::= ID DOT ID */
 {yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ID);}
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 183: /* expr ::= ID DOT STAR */
+      case 185: /* expr ::= ID DOT STAR */
 {yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ALL);}
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 184: /* expr ::= INTEGER */
+      case 186: /* expr ::= INTEGER */
 {yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_INTEGER);}
   yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 185: /* expr ::= MINUS INTEGER */
-      case 186: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==186);
+      case 187: /* expr ::= MINUS INTEGER */
+      case 188: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==188);
 {yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_INTEGER);}
   yymsp[-1].minor.yy66 = yylhsminor.yy66;
         break;
-      case 187: /* expr ::= FLOAT */
+      case 189: /* expr ::= FLOAT */
 {yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_FLOAT);}
   yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 188: /* expr ::= MINUS FLOAT */
-      case 189: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==189);
+      case 190: /* expr ::= MINUS FLOAT */
+      case 191: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==191);
 {yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_FLOAT);}
   yymsp[-1].minor.yy66 = yylhsminor.yy66;
         break;
-      case 190: /* expr ::= STRING */
+      case 192: /* expr ::= STRING */
 {yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_STRING);}
   yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 191: /* expr ::= NOW */
+      case 193: /* expr ::= NOW */
 {yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_NOW); }
   yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 192: /* expr ::= VARIABLE */
+      case 194: /* expr ::= VARIABLE */
 {yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_VARIABLE);}
   yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 193: /* expr ::= BOOL */
+      case 195: /* expr ::= BOOL */
 {yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_BOOL);}
   yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 194: /* expr ::= ID LP exprlist RP */
+      case 196: /* expr ::= ID LP exprlist RP */
 {
   yylhsminor.yy66 = tSQLExprCreateFunction(yymsp[-1].minor.yy224, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type);
 }
   yymsp[-3].minor.yy66 = yylhsminor.yy66;
         break;
-      case 195: /* expr ::= ID LP STAR RP */
+      case 197: /* expr ::= ID LP STAR RP */
 {
   yylhsminor.yy66 = tSQLExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type);
 }
   yymsp[-3].minor.yy66 = yylhsminor.yy66;
         break;
-      case 196: /* expr ::= expr AND expr */
+      case 198: /* expr ::= expr AND expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_AND);}
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 197: /* expr ::= expr OR expr */
+      case 199: /* expr ::= expr OR expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_OR); }
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 198: /* expr ::= expr LT expr */
+      case 200: /* expr ::= expr LT expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_LT);}
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 199: /* expr ::= expr GT expr */
+      case 201: /* expr ::= expr GT expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_GT);}
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 200: /* expr ::= expr LE expr */
+      case 202: /* expr ::= expr LE expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_LE);}
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 201: /* expr ::= expr GE expr */
+      case 203: /* expr ::= expr GE expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_GE);}
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 202: /* expr ::= expr NE expr */
+      case 204: /* expr ::= expr NE expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_NE);}
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 203: /* expr ::= expr EQ expr */
+      case 205: /* expr ::= expr EQ expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_EQ);}
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 204: /* expr ::= expr PLUS expr */
+      case 206: /* expr ::= expr PLUS expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_PLUS);  }
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 205: /* expr ::= expr MINUS expr */
+      case 207: /* expr ::= expr MINUS expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_MINUS); }
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 206: /* expr ::= expr STAR expr */
+      case 208: /* expr ::= expr STAR expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_STAR);  }
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 207: /* expr ::= expr SLASH expr */
+      case 209: /* expr ::= expr SLASH expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_DIVIDE);}
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 208: /* expr ::= expr REM expr */
+      case 210: /* expr ::= expr REM expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_REM);   }
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 209: /* expr ::= expr LIKE expr */
+      case 211: /* expr ::= expr LIKE expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_LIKE);  }
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 210: /* expr ::= expr IN LP exprlist RP */
+      case 212: /* expr ::= expr IN LP exprlist RP */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-4].minor.yy66, (tSQLExpr*)yymsp[-1].minor.yy224, TK_IN); }
   yymsp[-4].minor.yy66 = yylhsminor.yy66;
         break;
-      case 211: /* exprlist ::= exprlist COMMA expritem */
+      case 213: /* exprlist ::= exprlist COMMA expritem */
 {yylhsminor.yy224 = tSQLExprListAppend(yymsp[-2].minor.yy224,yymsp[0].minor.yy66,0);}
   yymsp[-2].minor.yy224 = yylhsminor.yy224;
         break;
-      case 212: /* exprlist ::= expritem */
+      case 214: /* exprlist ::= expritem */
 {yylhsminor.yy224 = tSQLExprListAppend(0,yymsp[0].minor.yy66,0);}
   yymsp[0].minor.yy224 = yylhsminor.yy224;
         break;
-      case 213: /* expritem ::= expr */
+      case 215: /* expritem ::= expr */
 {yylhsminor.yy66 = yymsp[0].minor.yy66;}
   yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 215: /* cmd ::= RESET QUERY CACHE */
+      case 217: /* cmd ::= RESET QUERY CACHE */
 { setDCLSQLElems(pInfo, TSDB_SQL_RESET_CACHE, 0);}
         break;
-      case 216: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+      case 218: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
     SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy449, NULL, TSDB_ALTER_TABLE_ADD_COLUMN);
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 217: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+      case 219: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -2747,14 +2764,14 @@ static void yy_reduce(
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 218: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+      case 220: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
     SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy449, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN);
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 219: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+      case 221: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -2765,7 +2782,7 @@ static void yy_reduce(
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 220: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+      case 222: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
 {
     yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
 
@@ -2779,7 +2796,7 @@ static void yy_reduce(
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 221: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+      case 223: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
 {
     yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n;
 
@@ -2791,13 +2808,13 @@ static void yy_reduce(
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 222: /* cmd ::= KILL CONNECTION INTEGER */
+      case 224: /* cmd ::= KILL CONNECTION INTEGER */
 {setKillSQL(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);}
         break;
-      case 223: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
+      case 225: /* 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 224: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
+      case 226: /* 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:

From 2c988d9f80a07a6987cec9edbe13d2e2fe59063b Mon Sep 17 00:00:00 2001
From: yihaoDeng <yhdeng@taosdata.com>
Date: Mon, 14 Sep 2020 00:45:18 +0000
Subject: [PATCH 05/35] add test

---
 tests/script/general/db/show_create_db.sim    | 32 +++++++
 tests/script/general/db/show_create_table.sim | 87 +++++++++++++++++++
 2 files changed, 119 insertions(+)
 create mode 100644 tests/script/general/db/show_create_db.sim
 create mode 100644 tests/script/general/db/show_create_table.sim

diff --git a/tests/script/general/db/show_create_db.sim b/tests/script/general/db/show_create_db.sim
new file mode 100644
index 0000000000..baa7b253e1
--- /dev/null
+++ b/tests/script/general/db/show_create_db.sim
@@ -0,0 +1,32 @@
+system sh/stop_dnodes.sh
+
+system sh/deploy.sh -n dnode1 -i 1
+system sh/cfg.sh -n dnode1 -c walLevel -v 0
+
+system sh/exec.sh -n dnode1 -s start
+sleep 3000
+sql connect
+
+print =============== step2
+sql create database db
+sql show create database db
+
+if $rows != 1 then 
+  return -1
+endi
+
+print =============== step3
+sql use db
+sql show create database db
+
+if $rows != 1 then 
+  return -1
+endi
+
+if $data00 != db then 
+  return -1
+endi  
+
+sql drop database db
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
diff --git a/tests/script/general/db/show_create_table.sim b/tests/script/general/db/show_create_table.sim
new file mode 100644
index 0000000000..8338638709
--- /dev/null
+++ b/tests/script/general/db/show_create_table.sim
@@ -0,0 +1,87 @@
+system sh/stop_dnodes.sh
+
+system sh/deploy.sh -n dnode1 -i 1
+system sh/cfg.sh -n dnode1 -c walLevel -v 0
+
+system sh/exec.sh -n dnode1 -s start
+sleep 3000
+sql connect
+
+print ===============create three type table
+sql create database db
+sql use db
+sql create table meters(ts timestamp, f binary(8)) tags(loc int, zone binary(8))
+sql create table t0 using meters tags(1,'ch')
+sql create table normalTbl(ts timestamp, zone binary(8))
+
+sql use db
+sql show create table meters 
+if $rows != 1 then 
+  return -1
+endi
+
+print ===============check sub table
+sql show create table t0
+if $rows != 1 then 
+  return -1
+endi
+if $data00 == 't0' then
+  return -1
+endi
+
+print ===============check normal table
+
+sql show create table normalTbl 
+if $rows != 1 then 
+  return -1
+endi
+
+if $data00 == 'normalTbl' then
+  return -1
+endi
+
+print ===============check super table
+sql show create table meters 
+if $rows != 1 then 
+  return -1
+endi
+
+if $data00 == 'meters' then
+  return -1
+endi
+
+print ===============check sub table with prefix
+
+sql show create table db.t0
+if $rows != 1 then 
+  return -1
+endi
+
+if $data00 == 't0' then
+  return -1
+endi
+
+print ===============check normal table with prefix
+sql show create table db.normalTbl 
+if $rows != 1 then 
+  return -1
+endi
+
+if $data00 == 'normalTbl' then
+  return -1
+endi
+
+
+print ===============check super table with prefix
+sql show create table db.meters 
+if $rows != 1 then 
+  return -1
+endi
+
+if $data00 == 'meters' then
+  return -1
+endi
+
+sql drop database db
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT

From b4f6b07258c1e7845fea12e3f9e8d30513a89022 Mon Sep 17 00:00:00 2001
From: yihaoDeng <yhdeng@taosdata.com>
Date: Mon, 14 Sep 2020 00:51:22 +0000
Subject: [PATCH 06/35] add test for show-create test

---
 tests/script/fullGeneralSuite.sim | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/script/fullGeneralSuite.sim b/tests/script/fullGeneralSuite.sim
index d137e53d27..870a1ce3d0 100644
--- a/tests/script/fullGeneralSuite.sim
+++ b/tests/script/fullGeneralSuite.sim
@@ -221,3 +221,5 @@ run general/stream/table_del.sim
 run general/stream/metrics_del.sim
 run general/stream/table_replica1_vnoden.sim
 run general/stream/metrics_replica1_vnoden.sim
+run general/db/show_create_db.sim
+run general/db/show_create_table.sim

From 6f908d0397e7a2d21fcc3bd2c4e084588156226d Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Thu, 17 Sep 2020 15:49:20 +0800
Subject: [PATCH 07/35] compile error in windows

---
 src/client/src/tscLocal.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/client/src/tscLocal.c b/src/client/src/tscLocal.c
index 12ee052ef5..030b033653 100644
--- a/src/client/src/tscLocal.c
+++ b/src/client/src/tscLocal.c
@@ -467,7 +467,7 @@ static int32_t tscGetTableTagValue(SCreateBuilder *builder, char *result) {
 // build 'show create table/database' result fields 
 static int32_t tscSCreateBuildResultFields(SSqlObj *pSql, BuildType type, const char *ddl) {
   int32_t  rowLen = 0;
-  int16_t  ddlLen = strlen(ddl); 
+  int16_t  ddlLen = (int16_t)strlen(ddl); 
   SColumnIndex index = {0};
   pSql->cmd.numOfCols = 2;
 

From f982f2df5edcd9c7a7421d9cdd19ae766a7fd9da Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Mon, 21 Sep 2020 15:17:27 +0800
Subject: [PATCH 08/35] [td-225] fix bugs in regression test.

---
 src/client/src/tscStream.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c
index 4a1f4d9d87..da9497dda5 100644
--- a/src/client/src/tscStream.c
+++ b/src/client/src/tscStream.c
@@ -615,10 +615,9 @@ void taos_close_stream(TAOS_STREAM *handle) {
     tscDebug("%p stream:%p is closed", pSql, pStream);
     // notify CQ to release the pStream object
     pStream->fp(pStream->param, NULL, NULL);
+    taos_free_result(pSql);
 
-    tscFreeSqlObj(pSql);
     pStream->pSql = NULL;
-
     taosTFree(pStream);
   }
 }

From 47d974994c0b8c2199518fc654ae2eb577d5a539 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Mon, 21 Sep 2020 15:23:17 +0800
Subject: [PATCH 09/35] [td-225] fix bugs in regression test.

---
 src/client/src/tscStream.c   | 4 ++--
 src/client/src/tscSubquery.c | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c
index da9497dda5..88dcfc2bb3 100644
--- a/src/client/src/tscStream.c
+++ b/src/client/src/tscStream.c
@@ -615,9 +615,9 @@ void taos_close_stream(TAOS_STREAM *handle) {
     tscDebug("%p stream:%p is closed", pSql, pStream);
     // notify CQ to release the pStream object
     pStream->fp(pStream->param, NULL, NULL);
-    taos_free_result(pSql);
-
     pStream->pSql = NULL;
+
+    taos_free_result(pSql);
     taosTFree(pStream);
   }
 }
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index f9bb180810..a6304c5ef3 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -1383,7 +1383,7 @@ static void doCleanupSubqueries(SSqlObj *pSql, int32_t numOfSubs, SSubqueryState
     taosTFree(pSupport->localBuffer);
     taosTFree(pSupport);
     
-    tscFreeSqlObj(pSub);
+    taos_free_result(pSub);
   }
   
   free(pState);

From f91fccd82e53ea7735a608dcaafa439ab9228f05 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Mon, 21 Sep 2020 15:41:29 +0800
Subject: [PATCH 10/35] [td-225] fix bugs in regression test.

---
 src/client/src/tscSubquery.c | 2 +-
 src/client/src/tscUtil.c     | 3 ---
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index a6304c5ef3..e66b361191 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -278,7 +278,7 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
       tscDebug("%p subIndex: %d, no need to launch query, ignore it", pSql, i);
     
       tscDestroyJoinSupporter(pSupporter);
-      tscFreeSqlObj(pPrevSub);
+      taos_free_result(pPrevSub);
     
       pSql->pSubs[i] = NULL;
       continue;
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 38fb63f18e..20c3bc2cb6 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -1743,8 +1743,6 @@ SSqlObj* createSimpleSubObj(SSqlObj* pSql, void (*fp)(), void* param, int32_t cm
   }
 
   pNew->pTscObj = pSql->pTscObj;
-  T_REF_INC(pNew->pTscObj);
-
   pNew->signature = pNew;
 
   SSqlCmd* pCmd = &pNew->cmd;
@@ -1777,7 +1775,6 @@ SSqlObj* createSimpleSubObj(SSqlObj* pSql, void (*fp)(), void* param, int32_t cm
   tscAddTableMetaInfo(pQueryInfo, pMasterTableMetaInfo->name, NULL, NULL, NULL);
 
   T_REF_INC(pNew->pTscObj);
-
   uint64_t p = (uint64_t) pNew;
   pNew->self = taosCachePut(tscObjCache, &p, sizeof(uint64_t), &pNew, sizeof(uint64_t), 2 * 600 * 1000);
   return pNew;

From d8a9ead27a3a987adeb10b77a095b28f58afc4d3 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Mon, 21 Sep 2020 16:06:55 +0800
Subject: [PATCH 11/35] [td-225] fix bugs in regression test.

---
 src/client/src/tscStream.c | 3 ++-
 src/util/src/tcache.c      | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c
index 478787671f..fed9caebbe 100644
--- a/src/client/src/tscStream.c
+++ b/src/client/src/tscStream.c
@@ -572,6 +572,7 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p
   pStream->pSql = pSql;
   pSql->pStream = pStream;
   pSql->param = pStream;
+  pSql->maxRetry = TSDB_MAX_REPLICA;
 
   pSql->sqlstr = calloc(1, strlen(sqlstr) + 1);
   if (pSql->sqlstr == NULL) {
@@ -579,6 +580,7 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p
     tscFreeSqlObj(pSql);
     return NULL;
   }
+
   strtolower(pSql->sqlstr, sqlstr);
 
   tscDebugL("%p SQL: %s", pSql, pSql->sqlstr);
@@ -612,7 +614,6 @@ void taos_close_stream(TAOS_STREAM *handle) {
    * Here, we need a check before release memory
    */
   if (pSql->signature == pSql) {
-    T_REF_DEC(pSql->pTscObj);
     tscRemoveFromStreamList(pStream, pSql);
 
     taosTmrStopA(&(pStream->pTimer));
diff --git a/src/util/src/tcache.c b/src/util/src/tcache.c
index e1dd521547..a6376e49ad 100644
--- a/src/util/src/tcache.c
+++ b/src/util/src/tcache.c
@@ -266,7 +266,7 @@ void *taosCacheAcquireByKey(SCacheObj *pCacheObj, const void *key, size_t keyLen
 
   if (taosHashGetSize(pCacheObj->pHashTable) == 0) {
     atomic_add_fetch_32(&pCacheObj->statistics.missCount, 1);
-    uError("cache:%s, key:%p, not in cache, retrieved failed, reason: empty sqlObj cache", pCacheObj->name, key);
+    uError("cache:%s, key:%p, not in cache, retrieved failed, reason: empty cache", pCacheObj->name, key);
     return NULL;
   }
 

From c84ecd4c1bd2caad1d8ee8e7c94c8d31a58ab01b Mon Sep 17 00:00:00 2001
From: Bomin Zhang <bmzhang@taosdata.com>
Date: Mon, 21 Sep 2020 16:24:12 +0800
Subject: [PATCH 12/35] use cache in subscribe & prepare

---
 src/client/src/tscPrepare.c |  6 +++++-
 src/client/src/tscSub.c     | 14 +++++++++++++-
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/src/client/src/tscPrepare.c b/src/client/src/tscPrepare.c
index 620e8ea57a..c4ca6793ff 100644
--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -546,6 +546,10 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
     pSql->cmd.numOfParams = 0;
     pSql->cmd.batchSize   = 0;
     
+    uint64_t handle = (uint64_t) pSql;
+    pSql->self = taosCachePut(tscObjCache, &handle, sizeof(uint64_t), &pSql, sizeof(uint64_t), 2*3600*1000);
+    T_REF_INC(pSql->pTscObj);
+
     int32_t code = tsParseSql(pSql, true);
     if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
       // wait for the callback function to post the semaphore
@@ -574,7 +578,7 @@ int taos_stmt_close(TAOS_STMT* stmt) {
     free(normal->sql);
   }
 
-  tscFreeSqlObj(pStmt->pSql);
+  taos_free_result(pStmt->pSql);
   free(pStmt);
   return TSDB_CODE_SUCCESS;
 }
diff --git a/src/client/src/tscSub.c b/src/client/src/tscSub.c
index 76bce19668..760c5f5a51 100644
--- a/src/client/src/tscSub.c
+++ b/src/client/src/tscSub.c
@@ -152,6 +152,10 @@ static SSub* tscCreateSubscription(STscObj* pObj, const char* topic, const char*
     goto fail;
   }
 
+  uint64_t handle = (uint64_t) pSql;
+  pSql->self = taosCachePut(tscObjCache, &handle, sizeof(uint64_t), &pSql, sizeof(uint64_t), 2*3600*1000);
+  T_REF_INC(pSql->pTscObj);
+
   code = tsParseSql(pSql, false);
   if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
     tsem_wait(&pSub->sem);
@@ -173,7 +177,11 @@ static SSub* tscCreateSubscription(STscObj* pObj, const char* topic, const char*
 fail:
   tscError("tscCreateSubscription failed at line %d, reason: %s", line, tstrerror(code));
   if (pSql != NULL) {
-    tscFreeSqlObj(pSql);
+    if (pSql->self != NULL) {
+      taos_free_result(pSql);
+    } else {
+      tscFreeSqlObj(pSql);
+    }
     pSql = NULL;
   }
   if (pSub != NULL) {
@@ -494,6 +502,10 @@ void taos_unsubscribe(TAOS_SUB *tsub, int keepProgress) {
     }
   }
 
+  if (pSub->pSql != NULL) {
+    taos_free_result(pSub->pSql);
+  }
+
   tscFreeSqlObj(pSub->pSql);
   taosArrayDestroy(pSub->progress);
   tsem_destroy(&pSub->sem);

From 04c20b25ad22ebc843a82bacc0b9f766cd6ea56f Mon Sep 17 00:00:00 2001
From: Hui Li <huili@taosdata.com>
Date: Mon, 21 Sep 2020 18:28:36 +0800
Subject: [PATCH 13/35] fix binary length

---
 src/connector/go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/connector/go b/src/connector/go
index 8c58c512b6..f4f6b76812 160000
--- a/src/connector/go
+++ b/src/connector/go
@@ -1 +1 @@
-Subproject commit 8c58c512b6acda8bcdfa48fdc7140227b5221766
+Subproject commit f4f6b768124a634b3c2408351c4d91df20f8de3f

From ba968b813c09b9f5be8efccb3d19228633f35631 Mon Sep 17 00:00:00 2001
From: yihaoDeng <yhdeng@taosdata.com>
Date: Mon, 21 Sep 2020 13:42:48 +0000
Subject: [PATCH 14/35] fix bug TD-1521

---
 src/mnode/src/mnodeTable.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index a35f09cd8d..cb606df692 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -1384,6 +1384,9 @@ int32_t mnodeRetrieveShowSuperTables(SShowObj *pShow, char *data, int32_t rows,
   }
 
   pShow->numOfReads += numOfRows;
+  const int32_t NUM_OF_COLUMNS = 5;
+
+  mnodeVacuumResult(data, NUM_OF_COLUMNS, numOfRows, rows, pShow);
   mnodeDecDbRef(pDb);
 
   return numOfRows;

From 6b3dcdda9c1ece432fb6d653ebdff0464daf5e46 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Tue, 22 Sep 2020 11:42:50 +0800
Subject: [PATCH 15/35] TD-1453

---
 src/vnode/src/vnodeRead.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/vnode/src/vnodeRead.c b/src/vnode/src/vnodeRead.c
index 017eeaf426..58e97075ac 100644
--- a/src/vnode/src/vnodeRead.c
+++ b/src/vnode/src/vnodeRead.c
@@ -58,7 +58,8 @@ int32_t vnodeProcessRead(void *param, SReadMsg *pReadMsg) {
     return TSDB_CODE_APP_NOT_READY;
 
   // TODO: Later, let slave to support query
-  if (pVnode->syncCfg.replica > 1 && pVnode->role != TAOS_SYNC_ROLE_MASTER) {
+  // if (pVnode->syncCfg.replica > 1 && pVnode->role != TAOS_SYNC_ROLE_MASTER) {
+  if (pVnode->role != TAOS_SYNC_ROLE_SLAVE && pVnode->role != TAOS_SYNC_ROLE_MASTER) { 
     vDebug("vgId:%d, msgType:%s not processed, replica:%d role:%d", pVnode->vgId, taosMsg[msgType], pVnode->syncCfg.replica, pVnode->role);
     return TSDB_CODE_APP_NOT_READY;
   }

From 67efcff7adab751b043c6ad5c3762ff5fbf40a1d Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 22 Sep 2020 13:47:18 +0800
Subject: [PATCH 16/35] [td-225] fix bugs in regression test.

---
 src/client/src/tscSql.c | 5 +++--
 src/util/src/tcache.c   | 1 -
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index 598ec7e546..8b79b0278b 100644
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -264,12 +264,13 @@ void taos_close(TAOS *taos) {
   }
 
   SSqlObj* pHb = pObj->pHb;
-  if (pHb != NULL) {
+  if (pHb != NULL && atomic_val_compare_exchange_ptr(&pObj->pHb, pHb, 0) == pHb) {
     if (pHb->pRpcCtx != NULL) {  // wait for rsp from dnode
       rpcCancelRequest(pHb->pRpcCtx);
+      pHb->pRpcCtx = NULL;
     }
 
-    pObj->pHb = NULL;
+    tscDebug("%p, HB is freed", pHb);
     taos_free_result(pHb);
   }
 
diff --git a/src/util/src/tcache.c b/src/util/src/tcache.c
index a6376e49ad..337513940a 100644
--- a/src/util/src/tcache.c
+++ b/src/util/src/tcache.c
@@ -266,7 +266,6 @@ void *taosCacheAcquireByKey(SCacheObj *pCacheObj, const void *key, size_t keyLen
 
   if (taosHashGetSize(pCacheObj->pHashTable) == 0) {
     atomic_add_fetch_32(&pCacheObj->statistics.missCount, 1);
-    uError("cache:%s, key:%p, not in cache, retrieved failed, reason: empty cache", pCacheObj->name, key);
     return NULL;
   }
 

From 7b2fbddfa7b4dae4a9c1e9b9627e2543fa8c808d Mon Sep 17 00:00:00 2001
From: liuyq-617 <yqliu@taosdata.com>
Date: Tue, 22 Sep 2020 14:06:22 +0800
Subject: [PATCH 17/35] [TD-1386] <test> add test case for retention

---
 tests/pytest/insert/retentionpolicy.py | 108 +++++++++++++++++++++++++
 tests/pytest/test.sh                   |   1 +
 2 files changed, 109 insertions(+)
 create mode 100644 tests/pytest/insert/retentionpolicy.py

diff --git a/tests/pytest/insert/retentionpolicy.py b/tests/pytest/insert/retentionpolicy.py
new file mode 100644
index 0000000000..bd294a24f3
--- /dev/null
+++ b/tests/pytest/insert/retentionpolicy.py
@@ -0,0 +1,108 @@
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import os
+import datetime
+sys.path.insert(0, os.getcwd())
+import taos
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class TDTestRetetion:
+    def init(self):
+        self.queryRows=0
+        tdLog.debug("start to execute %s" % __file__)
+        tdLog.info("prepare cluster")
+        tdDnodes.init("")
+        tdDnodes.setTestCluster(False)
+        tdDnodes.setValgrind(False)
+        tdDnodes.stopAll()
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+        print(tdDnodes.getDnodesRootDir())
+        self.conn = taos.connect(config=tdDnodes.getSimCfgPath())
+        tdSql.init(self.conn.cursor())
+        tdSql.execute('reset query cache')
+    def checkRows(self, expectRows,sql):
+        if self.queryRows == expectRows:
+            tdLog.info("sql:%s, queryRows:%d == expect:%d" % (sql, self.queryRows, expectRows))
+        else:
+            caller = inspect.getframeinfo(inspect.stack()[1][0])
+            args = (caller.filename, caller.lineno, sql, self.queryRows, expectRows)
+            os.system("timedatectl set-ntp true")
+            tdLog.exit("%s(%d) failed: sql:%s, queryRows:%d != expect:%d" % args)
+
+    def run(self):
+        
+        tdLog.info("=============== step1")
+        tdSql.execute('create database test keep 3 days 1;')
+        tdSql.execute('use test;')
+        tdSql.execute('create table test(ts timestamp,i int);')
+
+        cmd = 'insert into test values(now-2d,11)(now-1d,11)(now,11)(now+1d,11);'
+        tdLog.info(cmd)
+        tdSql.execute(cmd)
+        tdSql.query('select * from test')
+        tdSql.checkRows(4)
+
+        tdLog.info("=============== step2")
+        tdDnodes.stop(1)
+        os.system("timedatectl set-ntp false")
+        os.system("date -s $(date -d \"${DATE} 2 days\" \"+%Y%m%d\")")
+        tdDnodes.start(1)
+        cmd = 'insert into test values(now,11);'
+        tdLog.info(cmd)
+        tdSql.execute(cmd)
+        tdSql.query('select * from test')
+        tdSql.checkRows(5)
+
+        tdLog.info("=============== step3")
+        tdDnodes.stop(1)
+        os.system("date -s $(date -d \"${DATE} 2 days\" \"+%Y%m%d\")")
+        tdDnodes.start(1)
+        cmd = 'insert into test values(now-1d,11);'
+        tdLog.info(cmd)
+        tdSql.execute(cmd)
+        tdSql.query('select * from test')
+        tdSql.checkRows(6)
+        tdLog.info("=============== step4")
+        tdDnodes.stop(1)
+        tdDnodes.start(1)
+        cmd = 'insert into test values(now,11);'
+        tdLog.info(cmd)
+        tdSql.execute(cmd)
+        tdSql.query('select * from test')
+        tdSql.checkRows(7)
+
+        tdLog.info("=============== step5")
+        tdDnodes.stop(1)
+        tdDnodes.start(1)
+        cmd='select * from test where ts > now-1d'
+        queryRows=tdSql.query('select * from test where ts > now-1d')
+        self.checkRows(1,cmd)
+
+    def stop(self):
+        os.system("timedatectl set-ntp true")
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+clients = TDTestRetetion()
+clients.init()
+clients.run()
+clients.stop()
+
diff --git a/tests/pytest/test.sh b/tests/pytest/test.sh
index fbb9ba9879..d76c88c6ea 100755
--- a/tests/pytest/test.sh
+++ b/tests/pytest/test.sh
@@ -12,6 +12,7 @@ else
   TAOS_DIR=$CURR_DIR/../..
 fi
 TAOSD_DIR=`find $TAOS_DIR -name "taosd"|grep bin|head -n1`
+TAOS_BIN_DIR=`echo $TAOSD_DIR|rev|cut -d '/' -f 3,4,5,6|rev`/bin
 LIB_DIR=`echo $TAOSD_DIR|rev|cut -d '/' -f 3,4,5,6|rev`/lib
 export PYTHONPATH=$(pwd)/../../src/connector/python/linux/python3
 export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$LIB_DIR

From 5fe097a4022677ac94d6fe9092f32f2b0854619c Mon Sep 17 00:00:00 2001
From: liuyq-617 <yqliu@taosdata.com>
Date: Tue, 22 Sep 2020 14:18:30 +0800
Subject: [PATCH 18/35] [TD-1386] <test> add test case for retention

---
 tests/pytest/fulltest.sh | 1 +
 tests/pytest/test.sh     | 1 -
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/pytest/fulltest.sh b/tests/pytest/fulltest.sh
index 9ebf1584e2..1ed2f688a8 100755
--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
@@ -16,6 +16,7 @@ python3 ./test.py -f insert/nchar.py
 python3 ./test.py -f insert/nchar-unicode.py
 python3 ./test.py -f insert/multi.py
 python3 ./test.py -f insert/randomNullCommit.py
+python3 insert/retentionpolicy.py
 
 python3 ./test.py -f table/column_name.py
 python3 ./test.py -f table/column_num.py
diff --git a/tests/pytest/test.sh b/tests/pytest/test.sh
index d76c88c6ea..fbb9ba9879 100755
--- a/tests/pytest/test.sh
+++ b/tests/pytest/test.sh
@@ -12,7 +12,6 @@ else
   TAOS_DIR=$CURR_DIR/../..
 fi
 TAOSD_DIR=`find $TAOS_DIR -name "taosd"|grep bin|head -n1`
-TAOS_BIN_DIR=`echo $TAOSD_DIR|rev|cut -d '/' -f 3,4,5,6|rev`/bin
 LIB_DIR=`echo $TAOSD_DIR|rev|cut -d '/' -f 3,4,5,6|rev`/lib
 export PYTHONPATH=$(pwd)/../../src/connector/python/linux/python3
 export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$LIB_DIR

From eb0f6a1e45504ffa54f28418252965c65a612e49 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 22 Sep 2020 14:22:45 +0800
Subject: [PATCH 19/35] [td-1544]

---
 src/mnode/src/mnodeShow.c | 6 ++++--
 src/util/src/tcache.c     | 2 +-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/mnode/src/mnodeShow.c b/src/mnode/src/mnodeShow.c
index f66ef6b7a3..f2caf30564 100644
--- a/src/mnode/src/mnodeShow.c
+++ b/src/mnode/src/mnodeShow.c
@@ -65,7 +65,7 @@ int32_t mnodeInitShow() {
   mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_CONNECT, mnodeProcessConnectMsg);
   mnodeAddReadMsgHandle(TSDB_MSG_TYPE_CM_USE_DB, mnodeProcessUseMsg);
   
-  tsMnodeShowCache = taosCacheInit(TSDB_DATA_TYPE_BIGINT, 5, false, mnodeFreeShowObj, "show");
+  tsMnodeShowCache = taosCacheInit(TSDB_DATA_TYPE_BIGINT, 5, true, mnodeFreeShowObj, "show");
   return 0;
 }
 
@@ -389,10 +389,12 @@ static bool mnodeAccquireShowObj(SShowObj *pShow) {
 }
 
 static void* mnodePutShowObj(SShowObj *pShow) {
+  const int32_t DEFAULT_SHOWHANDLE_LIFE_SPAN = tsShellActivityTimer * 6 * 1000;
+
   if (tsMnodeShowCache != NULL) {
     pShow->index = atomic_add_fetch_32(&tsShowObjIndex, 1);
     uint64_t handleVal = (uint64_t)pShow;
-    SShowObj **ppShow = taosCachePut(tsMnodeShowCache, &handleVal, sizeof(int64_t), &pShow, sizeof(int64_t), 6000);
+    SShowObj **ppShow = taosCachePut(tsMnodeShowCache, &handleVal, sizeof(int64_t), &pShow, sizeof(int64_t), DEFAULT_SHOWHANDLE_LIFE_SPAN);
     pShow->ppShow = (void**)ppShow;
     mDebug("%p, show is put into cache, data:%p index:%d", pShow, ppShow, pShow->index);
     return pShow;
diff --git a/src/util/src/tcache.c b/src/util/src/tcache.c
index 337513940a..49b9996cf4 100644
--- a/src/util/src/tcache.c
+++ b/src/util/src/tcache.c
@@ -279,7 +279,7 @@ void *taosCacheAcquireByKey(SCacheObj *pCacheObj, const void *key, size_t keyLen
     uDebug("cache:%s, key:%p, %p is retrieved from cache, refcnt:%d", pCacheObj->name, key, pData, T_REF_VAL_GET(ptNode));
   } else {
     atomic_add_fetch_32(&pCacheObj->statistics.missCount, 1);
-    uError("cache:%s, key:%p, not in cache, retrieved failed", pCacheObj->name, key);
+    uDebug("cache:%s, key:%p, not in cache, retrieved failed", pCacheObj->name, key);
   }
 
   atomic_add_fetch_32(&pCacheObj->statistics.totalAccess, 1);

From 8f610e98d124dea16306d4ec84d19d2a1f6c0132 Mon Sep 17 00:00:00 2001
From: Hui Li <huili@taosdata.com>
Date: Tue, 22 Sep 2020 14:54:25 +0800
Subject: [PATCH 20/35] [TD-1465]

---
 src/connector/go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/connector/go b/src/connector/go
index f4f6b76812..06ec30a0f1 160000
--- a/src/connector/go
+++ b/src/connector/go
@@ -1 +1 @@
-Subproject commit f4f6b768124a634b3c2408351c4d91df20f8de3f
+Subproject commit 06ec30a0f1762e8169bf6b9045c82bcaa52bcdf0

From d10a3cdd113884c13f20c8a8c85d0ea868eef428 Mon Sep 17 00:00:00 2001
From: Hui Li <huili@taosdata.com>
Date: Tue, 22 Sep 2020 15:28:12 +0800
Subject: [PATCH 21/35] [update version info]

---
 cmake/version.inc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmake/version.inc b/cmake/version.inc
index 52d62fca65..aa8a4b6463 100644
--- a/cmake/version.inc
+++ b/cmake/version.inc
@@ -4,7 +4,7 @@ PROJECT(TDengine)
 IF (DEFINED VERNUMBER)
   SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "2.0.3.0")
+  SET(TD_VER_NUMBER "2.0.4.0")
 ENDIF ()
 
 IF (DEFINED VERCOMPATIBLE)

From f4605ba05ee1e5d1fff6dd312f8a6358c340e2bf Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Tue, 22 Sep 2020 15:28:35 +0800
Subject: [PATCH 22/35] TD-1451

---
 src/common/src/tglobal.c           |  2 +-
 src/plugins/http/inc/httpJson.h    |  2 +-
 src/plugins/http/src/httpJson.c    | 10 +++++-----
 src/plugins/http/src/httpUtil.c    | 14 ++++++++++----
 tests/script/general/http/gzip.sim | 16 ++++++++++++++--
 tests/script/jenkins/basic.txt     |  1 +
 6 files changed, 32 insertions(+), 13 deletions(-)

diff --git a/src/common/src/tglobal.c b/src/common/src/tglobal.c
index 94ec6fde0f..a75e712f38 100644
--- a/src/common/src/tglobal.c
+++ b/src/common/src/tglobal.c
@@ -131,7 +131,7 @@ uint16_t tsHttpPort = 6041;  // only tcp, range tcp[6041]
 int32_t  tsHttpCacheSessions = 1000;
 int32_t  tsHttpSessionExpire = 36000;
 int32_t  tsHttpMaxThreads = 2;
-int32_t  tsHttpEnableCompress = 0;
+int32_t  tsHttpEnableCompress = 1;
 int32_t  tsHttpEnableRecordSql = 0;
 int32_t  tsTelegrafUseFieldNum = 0;
 
diff --git a/src/plugins/http/inc/httpJson.h b/src/plugins/http/inc/httpJson.h
index ac0a632137..fcb74253b9 100644
--- a/src/plugins/http/inc/httpJson.h
+++ b/src/plugins/http/inc/httpJson.h
@@ -19,7 +19,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 
-#define JSON_BUFFER_SIZE 10240
+#define JSON_BUFFER_SIZE 16384
 struct HttpContext;
 
 enum { JsonNumber, JsonString, JsonBoolean, JsonArray, JsonObject, JsonNull };
diff --git a/src/plugins/http/src/httpJson.c b/src/plugins/http/src/httpJson.c
index e9a8947df2..7600fb3e43 100644
--- a/src/plugins/http/src/httpJson.c
+++ b/src/plugins/http/src/httpJson.c
@@ -52,12 +52,12 @@ int32_t httpWriteBufByFd(struct HttpContext* pContext, const char* buf, int32_t
     }
 
     if (len < 0) {
-      httpDebug("context:%p, fd:%d, socket write errno:%d, times:%d", pContext, pContext->fd, errno, countWait);
+      httpDebug("context:%p, fd:%d, socket write errno:%d:%s, times:%d", pContext, pContext->fd, errno, strerror(errno), countWait);
       if (++countWait > HTTP_WRITE_RETRY_TIMES) break;
       taosMsleep(HTTP_WRITE_WAIT_TIME_MS);
       continue;
     } else if (len == 0) {
-      httpDebug("context:%p, fd:%d, socket write errno:%d, connect already closed", pContext, pContext->fd, errno);
+      httpDebug("context:%p, fd:%d, socket write errno:%d:%s, connect already closed", pContext, pContext->fd, errno, strerror(errno));
       break;
     } else {
       countWait = 0;
@@ -131,14 +131,14 @@ int32_t httpWriteJsonBufBody(JsonBuf* buf, bool isTheLast) {
         httpWriteBufNoTrace(buf->pContext, sLen, len);
         remain = httpWriteBufNoTrace(buf->pContext, (const char*)compressBuf, compressBufLen);
       } else {
-        httpTrace("context:%p, fd:%d, last:%d, compress already dumped, response:\n%s", buf->pContext,
+        httpDebug("context:%p, fd:%d, last:%d, compress already dumped, response:\n%s", buf->pContext,
                   buf->pContext->fd, isTheLast, buf->buf);
-        return 0;  // there is no data to dump.
+        remain = 0;  // there is no data to dump.
       }
     } else {
       httpError("context:%p, fd:%d, failed to compress data, chunkSize:%" PRIu64 ", last:%d, error:%d, response:\n%s",
                 buf->pContext, buf->pContext->fd, srcLen, isTheLast, ret, buf->buf);
-      return 0;
+      remain = 0;
     }
   }
 
diff --git a/src/plugins/http/src/httpUtil.c b/src/plugins/http/src/httpUtil.c
index 2c8879f880..39168ee96d 100644
--- a/src/plugins/http/src/httpUtil.c
+++ b/src/plugins/http/src/httpUtil.c
@@ -406,15 +406,21 @@ int32_t httpGzipCompressInit(HttpContext *pContext) {
 
 int32_t httpGzipCompress(HttpContext *pContext, char *srcData, int32_t nSrcData, char *destData, int32_t *nDestData, bool isTheLast) {
   int32_t err = 0;
+  int32_t lastTotalLen = (int32_t) (pContext->gzipStream.total_out);
   pContext->gzipStream.next_in = (Bytef *) srcData;
   pContext->gzipStream.avail_in = (uLong) nSrcData;
   pContext->gzipStream.next_out = (Bytef *) destData;
   pContext->gzipStream.avail_out = (uLong) (*nDestData);
 
-  while (pContext->gzipStream.avail_in != 0 && pContext->gzipStream.total_out < (uLong) (*nDestData)) {
+  while (pContext->gzipStream.avail_in != 0) {
     if (deflate(&pContext->gzipStream, Z_FULL_FLUSH) != Z_OK) {
       return -1;
     }
+
+    int32_t cacheLen = pContext->gzipStream.total_out - lastTotalLen;
+    if (cacheLen >= *nDestData) {
+      return -2;
+    }
   }
 
   if (pContext->gzipStream.avail_in != 0) {
@@ -427,16 +433,16 @@ int32_t httpGzipCompress(HttpContext *pContext, char *srcData, int32_t nSrcData,
         break;
       }
       if (err != Z_OK) {
-        return -2;
+        return -3;
       }
     }
 
     if (deflateEnd(&pContext->gzipStream) != Z_OK) {
-      return -3;
+      return -4;
     }
   }
 
-  *nDestData = (int32_t) (pContext->gzipStream.total_out);
+  *nDestData = (int32_t) (pContext->gzipStream.total_out) - lastTotalLen;
   return 0;
 }
 
diff --git a/tests/script/general/http/gzip.sim b/tests/script/general/http/gzip.sim
index 0289e337a6..9c77567abb 100644
--- a/tests/script/general/http/gzip.sim
+++ b/tests/script/general/http/gzip.sim
@@ -3,7 +3,7 @@ sleep 3000
 system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c wallevel -v 0
 system sh/cfg.sh -n dnode1 -c http -v 1
-system sh/cfg.sh -n dnode1 -c maxSQLLength -v 7340032
+system sh/cfg.sh -n dnode1 -c maxSQLLength -v 340032
 system sh/exec.sh -n dnode1 -s start
 
 sleep 3000
@@ -18,10 +18,22 @@ sql use d1
 sql create table table_rest (ts timestamp, i int) 
 print sql length is 270KB
 restful d1 table_rest 1591072800 10000 gzip
+restful d1 table_rest 1591172800 10000 gzip
+restful d1 table_rest 1591272800 10000 gzip
+restful d1 table_rest 1591372800 10000 gzip
+restful d1 table_rest 1591472800 10000 gzip
+restful d1 table_rest 1591572800 10000 gzip
+restful d1 table_rest 1591672800 10000 gzip
+restful d1 table_rest 1591772800 10000 gzip
+restful d1 table_rest 1591872800 10000 gzip
+restful d1 table_rest 1591972800 10000 gzip
+
 sql select * from table_rest;
 print rows: $rows
-if $rows != 10000 then
+if $rows != 100000 then
   return -1
 endi
 
+system curl -H 'Authorization: Taosd /KfeAzX/f9na8qdtNZmtONryp201ma04bEl8LcvLUd7a8qdtNZmtONryp201ma04' -d 'select * from d1.table_rest' 127.0.0.1:7111/rest/sql --compressed
+
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
\ No newline at end of file
diff --git a/tests/script/jenkins/basic.txt b/tests/script/jenkins/basic.txt
index adb22aa265..9e42adfea9 100644
--- a/tests/script/jenkins/basic.txt
+++ b/tests/script/jenkins/basic.txt
@@ -79,6 +79,7 @@ cd ../../../debug; make
 
 ./test.sh -f general/http/autocreate.sim
 ./test.sh -f general/http/chunked.sim
+./test.sh -f general/http/gzip.sim
 ./test.sh -f general/http/restful.sim
 ./test.sh -f general/http/restful_insert.sim
 ./test.sh -f general/http/restful_limit.sim

From 4a3104f7fe9d3342f98939f053be44feddc2f69d Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 22 Sep 2020 15:51:15 +0800
Subject: [PATCH 23/35] [td-1371] update the sql.c

---
 src/query/src/sql.c | 884 +++++++++++++++++++++++---------------------
 1 file changed, 453 insertions(+), 431 deletions(-)

diff --git a/src/query/src/sql.c b/src/query/src/sql.c
index 3c160aab3b..a18efdeb74 100644
--- a/src/query/src/sql.c
+++ b/src/query/src/sql.c
@@ -114,6 +114,7 @@ typedef union {
   tSQLExprList* yy224;
   int64_t yy271;
   tVariant yy312;
+  SIntervalVal yy314;
   SCreateTableSQL* yy374;
   tFieldList* yy449;
   tVariantList* yy494;
@@ -126,17 +127,17 @@ typedef union {
 #define ParseARG_FETCH SSqlInfo* pInfo = yypParser->pInfo
 #define ParseARG_STORE yypParser->pInfo = pInfo
 #define YYFALLBACK 1
-#define YYNSTATE             248
-#define YYNRULE              227
+#define YYNSTATE             252
+#define YYNRULE              230
 #define YYNTOKEN             206
-#define YY_MAX_SHIFT         247
-#define YY_MIN_SHIFTREDUCE   409
-#define YY_MAX_SHIFTREDUCE   635
-#define YY_ERROR_ACTION      636
-#define YY_ACCEPT_ACTION     637
-#define YY_NO_ACTION         638
-#define YY_MIN_REDUCE        639
-#define YY_MAX_REDUCE        865
+#define YY_MAX_SHIFT         251
+#define YY_MIN_SHIFTREDUCE   416
+#define YY_MAX_SHIFTREDUCE   645
+#define YY_ERROR_ACTION      646
+#define YY_ACCEPT_ACTION     647
+#define YY_NO_ACTION         648
+#define YY_MIN_REDUCE        649
+#define YY_MAX_REDUCE        878
 /************* End control #defines *******************************************/
 
 /* Define the yytestcase() macro to be a no-op if is not already defined
@@ -202,123 +203,124 @@ typedef union {
 **  yy_default[]       Default action for each state.
 **
 *********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (555)
+#define YY_ACTTAB_COUNT (566)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */    11,  452,  140,  452,  158,  245,   21,  139,  144,  453,
- /*    10 */   140,  453,  852,   41,   43,  771,   35,   36,  849,  163,
- /*    20 */   853,   29,  452,  848,  203,   39,   37,   40,   38,  159,
- /*    30 */   453,  782,  741,   34,   33,  739,  740,   32,   31,   30,
- /*    40 */   742,  756,  744,  745,  743,  107,  160,  410,  411,  412,
- /*    50 */   413,  414,  415,  416,  417,  418,  419,  420,  421,  246,
- /*    60 */   637,  247,  178,   41,   43,  760,   35,   36,  225,  107,
- /*    70 */   140,   29,  170,  847,  203,   39,   37,   40,   38,  162,
- /*    80 */   853,  518,  779,   34,   33,  103,  156,   32,   31,   30,
- /*    90 */   234,  760,   41,   43,  157,   35,   36,  771,  758,  200,
- /*   100 */    29,   60,   56,  203,   39,   37,   40,   38,   17,  223,
- /*   110 */   222,  188,   34,   33,  145,   26,   32,   31,   30,   43,
- /*   120 */     8,   35,   36,   63,  117,  808,   29,  198,  146,  203,
- /*   130 */    39,   37,   40,   38,   32,   31,   30,  191,   34,   33,
- /*   140 */   181,  107,   32,   31,   30,  241,   21,  185,  184,  591,
- /*   150 */    16,  214,  240,  239,  213,  212,  211,  238,  210,  237,
- /*   160 */   236,  235,  209,  737,  760,  725,  726,  727,  728,  729,
- /*   170 */   730,  731,  732,  733,  734,  735,  736,   35,   36,  171,
- /*   180 */   680,  757,   29,  130,  148,  203,   39,   37,   40,   38,
- /*   190 */   244,  243,   96,  149,   34,   33,  107,  807,   32,   31,
- /*   200 */    30,  167,  604,   78,   12,  595,   62,  598,  234,  601,
- /*   210 */   689,  167,  604,  130,  150,  595,  173,  598,   27,  601,
- /*   220 */   152,  167,  604,  572,  573,  595,  153,  598,  151,  601,
- /*   230 */    90,   89,  147,  164,  165,   34,   33,  202,  142,   32,
- /*   240 */    31,   30,  681,  164,  165,  130,  818,  550,   39,   37,
- /*   250 */    40,   38,   61,  164,  165,  563,   34,   33,   17,   46,
- /*   260 */    32,   31,   30,  102,   16,   26,  240,  239,  564,   21,
- /*   270 */    26,  238,   14,  237,  236,  235,  597,  174,  600,  547,
- /*   280 */   220,  219,   76,   80,   18,  187,  166,   21,   85,   88,
- /*   290 */    79,  138,  155,  120,  121,   21,   82,  593,   42,   70,
- /*   300 */    66,   69,  172,  542,  757,  134,  132,  143,   42,  603,
- /*   310 */   190,   93,   92,   91,  596,  141,  599,  621,   42,  603,
- /*   320 */   221,   13,  757,  605,  602,    3,  862,   13,  226,  603,
- /*   330 */   757,   47,  534,  594,  602,  531,   50,  532,  538,  533,
- /*   340 */   539,  524,  523,  817,  602,   46,   22,  207,   87,   86,
- /*   350 */    48,   22,  759,   51,   75,   74,  101,   99,   10,    9,
- /*   360 */   536,  168,  537,  175,  176,  814,  813,  169,  781,  786,
- /*   370 */   751,  800,  224,  773,  788,   26,  104,  799,  118,  189,
- /*   380 */   116,  119,  691,  208,  136,   24,  100,  217,  688,  559,
- /*   390 */   218,  861,   72,  860,  858,  122,  709,   25,   23,  137,
- /*   400 */   678,   81,  676,   83,   84,  674,  673,  177,  131,  671,
- /*   410 */   192,  670,  196,  669,  770,  668,  667,  133,  665,  663,
- /*   420 */    52,  661,  659,  657,  135,   49,   57,   58,  801,   44,
- /*   430 */   201,  199,  197,  195,  535,  193,   28,  216,   77,  227,
- /*   440 */   228,  230,  229,  231,  232,  233,  242,  635,  180,  205,
- /*   450 */    53,  179,  634,  182,  183,   64,   67,  154,  633,  626,
- /*   460 */   186,  161,  105,  672,  190,   94,  544,  666,  658,  125,
- /*   470 */   710,  123,  124,  126,  127,  108,  128,  109,  129,  110,
- /*   480 */    95,  755,  111,  112,  115,  113,  114,    2,    1,   55,
- /*   490 */    59,  560,  194,    5,  565,  106,   19,    6,  606,   20,
- /*   500 */     4,   15,   65,    7,  204,  493,  206,  489,  487,  486,
- /*   510 */   485,  482,  456,  215,   68,   45,   22,   71,   73,  520,
- /*   520 */   519,  517,   54,  477,  475,  467,  473,  469,  471,  465,
- /*   530 */   463,  492,  491,  490,  488,  484,  483,   46,  454,  425,
- /*   540 */   423,  639,  638,  638,  638,  638,  638,  638,  638,  638,
- /*   550 */   638,  638,  638,   97,   98,
+ /*     0 */   751,  459,   11,  749,  750,  647,  251,  459,  752,  460,
+ /*    10 */   754,  755,  753,   35,   36,  460,   37,   38,  159,  249,
+ /*    20 */   170,   29,  141,  459,  206,   41,   39,   43,   40,  140,
+ /*    30 */   145,  460,  865,   34,   33,  862,  141,   32,   31,   30,
+ /*    40 */    35,   36,  781,   37,   38,  165,  866,  170,   29,  141,
+ /*    50 */    62,  206,   41,   39,   43,   40,  191,  525,  164,  866,
+ /*    60 */    34,   33,   27,   21,   32,   31,   30,  417,  418,  419,
+ /*    70 */   420,  421,  422,  423,  424,  425,  426,  427,  428,  250,
+ /*    80 */    35,   36,  181,   37,   38,  227,  226,  170,   29,  781,
+ /*    90 */   176,  206,   41,   39,   43,   40,  174,  162,  767,  792,
+ /*   100 */    34,   33,   56,  160,   32,   31,   30,   21,   36,    8,
+ /*   110 */    37,   38,   63,  118,  170,   29,  770,  108,  206,   41,
+ /*   120 */    39,   43,   40,   32,   31,   30,  599,   34,   33,   78,
+ /*   130 */   875,   32,   31,   30,  238,   37,   38,  108,  238,  170,
+ /*   140 */    29,  184,  766,  206,   41,   39,   43,   40,  188,  187,
+ /*   150 */   789,  177,   34,   33,  224,  223,   32,   31,   30,   16,
+ /*   160 */   218,  244,  243,  217,  216,  215,  242,  214,  241,  240,
+ /*   170 */   239,  213,  747,  818,  735,  736,  737,  738,  739,  740,
+ /*   180 */   741,  742,  743,  744,  745,  746,  169,  612,  103,   12,
+ /*   190 */   603,   17,  606,  819,  609,  201,  169,  612,   26,  108,
+ /*   200 */   603,  108,  606,  861,  609,  153,  169,  612,  173,  567,
+ /*   210 */   603,  154,  606,  105,  609,   90,   89,  148,  166,  167,
+ /*   220 */    34,   33,  205,  102,   32,   31,   30,  770,  166,  167,
+ /*   230 */    26,   21,  557,   41,   39,   43,   40,  549,  166,  167,
+ /*   240 */   194,   34,   33,   17,  193,   32,   31,   30,  860,   16,
+ /*   250 */    26,  244,  243,  203,   21,   60,  242,   61,  241,  240,
+ /*   260 */   239,  248,  247,   96,  175,  229,  767,   76,   80,  245,
+ /*   270 */   190,  554,   21,   85,   88,   79,   18,  156,  121,  122,
+ /*   280 */   605,   82,  608,   42,   70,   66,   69,  225,  770,  767,
+ /*   290 */   135,  133,  601,   42,  611,  768,   93,   92,   91,  690,
+ /*   300 */   168,  207,  131,   42,  611,  230,  545,  767,  546,  610,
+ /*   310 */   699,  157,  691,  131,  611,  131,  604,  541,  607,  610,
+ /*   320 */   538,  571,  539,   47,  540,   46,  580,  581,  602,  610,
+ /*   330 */   572,  631,  613,   50,   14,   13,   13,  531,  543,    3,
+ /*   340 */   544,   46,   48,  530,   75,   74,  811,   22,  178,  179,
+ /*   350 */    51,  211,   10,    9,  829,   22,   87,   86,  101,   99,
+ /*   360 */   158,  143,  144,  146,  147,  151,  152,  150,  139,  149,
+ /*   370 */   769,  142,  828,  171,  825,  824,  172,  791,  761,  796,
+ /*   380 */   228,  783,  798,  104,  810,  119,  120,  701,  117,  212,
+ /*   390 */   615,  137,   24,  221,  698,   26,  222,  192,  874,   72,
+ /*   400 */   873,  871,  123,  719,   25,  100,   23,  138,  566,  688,
+ /*   410 */    81,  686,   83,   84,  684,  195,  780,  683,  161,  542,
+ /*   420 */   180,  199,  132,  681,  680,  679,   52,   49,  678,  677,
+ /*   430 */   109,  134,   44,  675,  204,  673,  671,  669,  667,  202,
+ /*   440 */   200,  198,  196,   28,  136,  220,   57,   58,  812,   77,
+ /*   450 */   231,  232,  233,  234,  235,  236,  237,  246,  209,  645,
+ /*   460 */    53,  182,  183,  644,  110,   64,   67,  155,  186,  185,
+ /*   470 */   682,  643,   94,  636,  676,  189,  126,  125,  720,  124,
+ /*   480 */   127,  128,  130,  129,   95,  668,    1,  551,  193,  765,
+ /*   490 */     2,   55,  113,  111,  114,  112,  115,  116,   59,  568,
+ /*   500 */   163,  106,  197,    5,  573,  107,    6,   65,  614,   19,
+ /*   510 */     4,   20,   15,  208,  616,    7,  210,  500,  496,  494,
+ /*   520 */   493,  492,  489,  463,  219,   68,   45,   71,   73,   22,
+ /*   530 */   527,  526,  524,   54,  484,  482,  474,  480,  476,  478,
+ /*   540 */   472,  470,  499,  498,  497,  495,  491,  490,   46,  461,
+ /*   550 */   432,  430,  649,  648,  648,  648,  648,  648,  648,  648,
+ /*   560 */   648,  648,  648,  648,   97,   98,
 };
 static const YYCODETYPE yy_lookahead[] = {
- /*     0 */   260,    1,  260,    1,  209,  210,  210,  260,  260,    9,
- /*    10 */   260,    9,  270,   13,   14,  244,   16,   17,  260,  269,
- /*    20 */   270,   21,    1,  260,   24,   25,   26,   27,   28,  258,
- /*    30 */     9,  210,  226,   33,   34,  229,  230,   37,   38,   39,
- /*    40 */   234,  245,  236,  237,  238,  210,  227,   45,   46,   47,
- /*    50 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
- /*    60 */   207,  208,   60,   13,   14,  246,   16,   17,  210,  210,
- /*    70 */   260,   21,  227,  260,   24,   25,   26,   27,   28,  269,
- /*    80 */   270,    5,  261,   33,   34,  210,  260,   37,   38,   39,
- /*    90 */    78,  246,   13,   14,  260,   16,   17,  244,  240,  264,
- /*   100 */    21,  266,  102,   24,   25,   26,   27,   28,   98,   33,
- /*   110 */    34,  258,   33,   34,  260,  105,   37,   38,   39,   14,
- /*   120 */    98,   16,   17,  101,  102,  266,   21,  268,  260,   24,
- /*   130 */    25,   26,   27,   28,   37,   38,   39,  262,   33,   34,
- /*   140 */   126,  210,   37,   38,   39,  227,  210,  133,  134,   99,
- /*   150 */    85,   86,   87,   88,   89,   90,   91,   92,   93,   94,
- /*   160 */    95,   96,   97,  226,  246,  228,  229,  230,  231,  232,
- /*   170 */   233,  234,  235,  236,  237,  238,  239,   16,   17,  243,
- /*   180 */   214,  245,   21,  217,  260,   24,   25,   26,   27,   28,
- /*   190 */    63,   64,   65,  260,   33,   34,  210,  266,   37,   38,
- /*   200 */    39,    1,    2,   73,   44,    5,  247,    7,   78,    9,
- /*   210 */   214,    1,    2,  217,  260,    5,   66,    7,  259,    9,
- /*   220 */    60,    1,    2,  115,  116,    5,   66,    7,  260,    9,
- /*   230 */    70,   71,   72,   33,   34,   33,   34,   37,  260,   37,
- /*   240 */    38,   39,  214,   33,   34,  217,  241,   37,   25,   26,
- /*   250 */    27,   28,  266,   33,   34,   99,   33,   34,   98,  103,
- /*   260 */    37,   38,   39,   98,   85,  105,   87,   88,   99,  210,
- /*   270 */   105,   92,  103,   94,   95,   96,    5,  127,    7,  103,
- /*   280 */   130,  131,   61,   62,  108,  125,   59,  210,   67,   68,
- /*   290 */    69,  260,  132,   61,   62,  210,   75,    1,   98,   67,
- /*   300 */    68,   69,  243,   99,  245,   61,   62,  260,   98,  109,
- /*   310 */   106,   67,   68,   69,    5,  260,    7,   99,   98,  109,
- /*   320 */   243,  103,  245,   99,  124,   98,  246,  103,  243,  109,
- /*   330 */   245,  103,    2,   37,  124,    5,  103,    7,    5,    9,
- /*   340 */     7,   99,   99,  241,  124,  103,  103,   99,   73,   74,
- /*   350 */   122,  103,  246,  120,  128,  129,   61,   62,  128,  129,
- /*   360 */     5,  241,    7,   33,   34,  241,  241,  241,  210,  210,
- /*   370 */   242,  267,  241,  244,  210,  105,  210,  267,  210,  244,
- /*   380 */   248,  210,  210,  210,  210,  210,   59,  210,  210,  109,
- /*   390 */   210,  210,  210,  210,  210,  210,  210,  210,  210,  210,
- /*   400 */   210,  210,  210,  210,  210,  210,  210,  210,  210,  210,
- /*   410 */   263,  210,  263,  210,  257,  210,  210,  210,  210,  210,
- /*   420 */   119,  210,  210,  210,  210,  121,  211,  211,  211,  118,
- /*   430 */   113,  117,  112,  111,  104,  110,  123,   76,   84,   83,
- /*   440 */    49,   82,   80,   53,   81,   79,   76,    5,    5,  211,
- /*   450 */   211,  135,    5,  135,    5,  215,  215,  211,    5,   86,
- /*   460 */   126,    1,   98,  211,  106,  212,   99,  211,  211,  219,
- /*   470 */   225,  224,  223,  222,  220,  256,  221,  255,  218,  254,
- /*   480 */   212,  244,  253,  252,  249,  251,  250,  213,  216,  107,
- /*   490 */   103,   99,   98,  114,   99,   98,  103,  114,   99,  103,
- /*   500 */    98,   98,   73,   98,  100,    9,  100,    5,    5,    5,
- /*   510 */     5,    5,   77,   15,   73,   16,  103,  129,  129,    5,
- /*   520 */     5,   99,   98,    5,    5,    5,    5,    5,    5,    5,
- /*   530 */     5,    5,    5,    5,    5,    5,    5,  103,   77,   59,
- /*   540 */    58,    0,  271,  271,  271,  271,  271,  271,  271,  271,
- /*   550 */   271,  271,  271,   21,   21,  271,  271,  271,  271,  271,
- /*   560 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*     0 */   226,    1,  260,  229,  230,  207,  208,    1,  234,    9,
+ /*    10 */   236,  237,  238,   13,   14,    9,   16,   17,  209,  210,
+ /*    20 */    20,   21,  260,    1,   24,   25,   26,   27,   28,  260,
+ /*    30 */   260,    9,  270,   33,   34,  260,  260,   37,   38,   39,
+ /*    40 */    13,   14,  244,   16,   17,  269,  270,   20,   21,  260,
+ /*    50 */   247,   24,   25,   26,   27,   28,  258,    5,  269,  270,
+ /*    60 */    33,   34,  259,  210,   37,   38,   39,   45,   46,   47,
+ /*    70 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
+ /*    80 */    13,   14,   60,   16,   17,   33,   34,   20,   21,  244,
+ /*    90 */    66,   24,   25,   26,   27,   28,  243,  227,  245,  210,
+ /*   100 */    33,   34,  102,  258,   37,   38,   39,  210,   14,   98,
+ /*   110 */    16,   17,  101,  102,   20,   21,  246,  210,   24,   25,
+ /*   120 */    26,   27,   28,   37,   38,   39,   99,   33,   34,   73,
+ /*   130 */   246,   37,   38,   39,   78,   16,   17,  210,   78,   20,
+ /*   140 */    21,  126,  245,   24,   25,   26,   27,   28,  133,  134,
+ /*   150 */   261,  127,   33,   34,  130,  131,   37,   38,   39,   85,
+ /*   160 */    86,   87,   88,   89,   90,   91,   92,   93,   94,   95,
+ /*   170 */    96,   97,  226,  266,  228,  229,  230,  231,  232,  233,
+ /*   180 */   234,  235,  236,  237,  238,  239,    1,    2,  210,   44,
+ /*   190 */     5,   98,    7,  266,    9,  268,    1,    2,  105,  210,
+ /*   200 */     5,  210,    7,  260,    9,   60,    1,    2,  227,   99,
+ /*   210 */     5,   66,    7,  103,    9,   70,   71,   72,   33,   34,
+ /*   220 */    33,   34,   37,   98,   37,   38,   39,  246,   33,   34,
+ /*   230 */   105,  210,   37,   25,   26,   27,   28,   99,   33,   34,
+ /*   240 */   262,   33,   34,   98,  106,   37,   38,   39,  260,   85,
+ /*   250 */   105,   87,   88,  264,  210,  266,   92,  266,   94,   95,
+ /*   260 */    96,   63,   64,   65,  243,  210,  245,   61,   62,  227,
+ /*   270 */   125,  103,  210,   67,   68,   69,  108,  132,   61,   62,
+ /*   280 */     5,   75,    7,   98,   67,   68,   69,  243,  246,  245,
+ /*   290 */    61,   62,    1,   98,  109,  240,   67,   68,   69,  214,
+ /*   300 */    59,   15,  217,   98,  109,  243,    5,  245,    7,  124,
+ /*   310 */   214,  260,  214,  217,  109,  217,    5,    2,    7,  124,
+ /*   320 */     5,   99,    7,  103,    9,  103,  115,  116,   37,  124,
+ /*   330 */    99,   99,   99,  103,  103,  103,  103,   99,    5,   98,
+ /*   340 */     7,  103,  122,   99,  128,  129,  267,  103,   33,   34,
+ /*   350 */   120,   99,  128,  129,  241,  103,   73,   74,   61,   62,
+ /*   360 */   260,  260,  260,  260,  260,  260,  260,  260,  260,  260,
+ /*   370 */   246,  260,  241,  241,  241,  241,  241,  210,  242,  210,
+ /*   380 */   241,  244,  210,  210,  267,  210,  210,  210,  248,  210,
+ /*   390 */   104,  210,  210,  210,  210,  105,  210,  244,  210,  210,
+ /*   400 */   210,  210,  210,  210,  210,   59,  210,  210,  109,  210,
+ /*   410 */   210,  210,  210,  210,  210,  263,  257,  210,  263,  104,
+ /*   420 */   210,  263,  210,  210,  210,  210,  119,  121,  210,  210,
+ /*   430 */   256,  210,  118,  210,  113,  210,  210,  210,  210,  117,
+ /*   440 */   112,  111,  110,  123,  210,   76,  211,  211,  211,   84,
+ /*   450 */    83,   49,   80,   82,   53,   81,   79,   76,  211,    5,
+ /*   460 */   211,  135,    5,    5,  255,  215,  215,  211,    5,  135,
+ /*   470 */   211,    5,  212,   86,  211,  126,  219,  223,  225,  224,
+ /*   480 */   222,  220,  218,  221,  212,  211,  216,   99,  106,  244,
+ /*   490 */   213,  107,  252,  254,  251,  253,  250,  249,  103,   99,
+ /*   500 */     1,   98,   98,  114,   99,   98,  114,   73,   99,  103,
+ /*   510 */    98,  103,   98,  100,  104,   98,  100,    9,    5,    5,
+ /*   520 */     5,    5,    5,   77,   15,   73,   16,  129,  129,  103,
+ /*   530 */     5,    5,   99,   98,    5,    5,    5,    5,    5,    5,
+ /*   540 */     5,    5,    5,    5,    5,    5,    5,    5,  103,   77,
+ /*   550 */    59,   58,    0,  271,  271,  271,  271,  271,  271,  271,
+ /*   560 */   271,  271,  271,  271,   21,   21,  271,  271,  271,  271,
  /*   570 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
  /*   580 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
  /*   590 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
@@ -338,83 +340,86 @@ static const YYCODETYPE yy_lookahead[] = {
  /*   730 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
  /*   740 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
  /*   750 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
- /*   760 */   271,
+ /*   760 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   770 */   271,  271,
 };
-#define YY_SHIFT_COUNT    (247)
+#define YY_SHIFT_COUNT    (251)
 #define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (541)
+#define YY_SHIFT_MAX      (552)
 static const unsigned short int yy_shift_ofst[] = {
- /*     0 */   160,   65,  179,  200,  220,   21,   21,   21,   21,   21,
- /*    10 */    21,    0,    2,  220,  330,  330,  330,   10,   21,   21,
- /*    20 */    21,   21,   21,  130,   12,   12,  555,  210,  220,  220,
- /*    30 */   220,  220,  220,  220,  220,  220,  220,  220,  220,  220,
- /*    40 */   220,  220,  220,  220,  220,  330,  330,   76,   76,   76,
- /*    50 */    76,   76,   76,   22,   76,  165,   21,   21,   21,   21,
- /*    60 */   108,  108,  176,   21,   21,   21,   21,   21,   21,   21,
- /*    70 */    21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
- /*    80 */    21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
- /*    90 */    21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
- /*   100 */    21,   21,  270,  327,  327,  280,  280,  327,  301,  304,
- /*   110 */   311,  317,  314,  320,  322,  325,  313,  270,  327,  327,
- /*   120 */   361,  361,  327,  354,  356,  391,  362,  359,  390,  363,
- /*   130 */   366,  327,  370,  327,  370,  327,  555,  555,   50,   79,
- /*   140 */    79,   79,  105,  161,  223,  223,  223,  221,  202,  202,
- /*   150 */   202,  202,  232,  244,  150,   14,   97,   97,  127,  204,
- /*   160 */   156,  169,  218,  224,  271,  309,  296,  227,  228,  233,
- /*   170 */   242,  243,  248,  226,  230,  333,  355,  275,  295,  442,
- /*   180 */   316,  443,  447,  318,  449,  453,  373,  334,  358,  367,
- /*   190 */   382,  387,  392,  364,  460,  394,  395,  397,  393,  379,
- /*   200 */   396,  383,  399,  402,  403,  404,  405,  406,  429,  496,
- /*   210 */   502,  503,  504,  505,  506,  435,  498,  441,  499,  388,
- /*   220 */   389,  413,  514,  515,  422,  424,  413,  518,  519,  520,
- /*   230 */   521,  522,  523,  524,  525,  526,  527,  528,  529,  530,
- /*   240 */   531,  434,  461,  532,  533,  480,  482,  541,
+ /*     0 */   145,   74,  164,  185,  205,    6,    6,    6,    6,    6,
+ /*    10 */     6,    0,   22,  205,  315,  315,  315,   93,    6,    6,
+ /*    20 */     6,    6,    6,   56,   60,   60,  566,  195,  205,  205,
+ /*    30 */   205,  205,  205,  205,  205,  205,  205,  205,  205,  205,
+ /*    40 */   205,  205,  205,  205,  205,  315,  315,   52,   52,   52,
+ /*    50 */    52,   52,   52,   11,   52,  125,    6,    6,    6,    6,
+ /*    60 */   211,  211,  168,    6,    6,    6,    6,    6,    6,    6,
+ /*    70 */     6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
+ /*    80 */     6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
+ /*    90 */     6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
+ /*   100 */     6,    6,  290,  346,  346,  299,  299,  299,  346,  307,
+ /*   110 */   306,  314,  321,  322,  328,  330,  332,  320,  290,  346,
+ /*   120 */   346,  369,  369,  346,  365,  367,  402,  372,  371,  401,
+ /*   130 */   374,  377,  346,  381,  346,  381,  346,  566,  566,   27,
+ /*   140 */    67,   67,   67,   94,  119,  208,  208,  208,  206,  187,
+ /*   150 */   187,  187,  187,  217,  229,   24,   15,   86,   86,  198,
+ /*   160 */   138,  110,  222,  231,  232,  233,  275,  311,  291,  241,
+ /*   170 */   286,  220,  230,  238,  244,  252,  216,  224,  301,  333,
+ /*   180 */   283,  297,  454,  326,  457,  458,  334,  463,  466,  387,
+ /*   190 */   349,  382,  388,  384,  395,  400,  403,  499,  404,  405,
+ /*   200 */   407,  406,  389,  408,  392,  409,  412,  410,  414,  413,
+ /*   210 */   417,  416,  434,  508,  513,  514,  515,  516,  517,  446,
+ /*   220 */   509,  452,  510,  398,  399,  426,  525,  526,  433,  435,
+ /*   230 */   426,  529,  530,  531,  532,  533,  534,  535,  536,  537,
+ /*   240 */   538,  539,  540,  541,  542,  445,  472,  543,  544,  491,
+ /*   250 */   493,  552,
 };
-#define YY_REDUCE_COUNT (137)
-#define YY_REDUCE_MIN   (-260)
-#define YY_REDUCE_MAX   (274)
+#define YY_REDUCE_COUNT (138)
+#define YY_REDUCE_MIN   (-258)
+#define YY_REDUCE_MAX   (277)
 static const short yy_reduce_ofst[] = {
- /*     0 */  -147,  -63, -194, -250, -190, -141, -165,  -64,   59,   77,
- /*    10 */    85, -179, -205, -258, -181, -155,  -82, -229, -125,  -69,
- /*    20 */   -14, -142, -204,  -34,   -4,   28,  -41, -260, -253, -252,
- /*    30 */  -242, -237, -187, -174, -166, -146, -132,  -76,  -67,  -46,
- /*    40 */   -32,  -22,   31,   47,   55,   80,  106,    5,  102,  120,
- /*    50 */   124,  125,  126,  128,  131,  129,  158,  159,  164,  166,
- /*    60 */   104,  110,  132,  168,  171,  172,  173,  174,  175,  177,
- /*    70 */   178,  180,  181,  182,  183,  184,  185,  186,  187,  188,
- /*    80 */   189,  190,  191,  192,  193,  194,  195,  196,  197,  198,
- /*    90 */   199,  201,  203,  205,  206,  207,  208,  209,  211,  212,
- /*   100 */   213,  214,  135,  215,  216,  147,  149,  217,  157,  219,
- /*   110 */   222,  225,  229,  231,  234,  236,  235,  237,  238,  239,
- /*   120 */   240,  241,  246,  245,  247,  249,  250,  251,  254,  255,
- /*   130 */   260,  252,  253,  256,  268,  257,  272,  274,
+ /*     0 */  -202,  -54, -226, -224, -211,  -73,  -11, -147,   21,   44,
+ /*    10 */    62, -111, -191, -238, -130,  -19,   42, -155,  -22,  -93,
+ /*    20 */    -9,   55, -103,   85,   96,   98, -197, -258, -231, -230,
+ /*    30 */  -225,  -57,  -12,   51,  100,  101,  102,  103,  104,  105,
+ /*    40 */   106,  107,  108,  109,  111, -116,  124,  113,  131,  132,
+ /*    50 */   133,  134,  135,  136,  139,  137,  167,  169,  172,  173,
+ /*    60 */    79,  117,  140,  175,  176,  177,  179,  181,  182,  183,
+ /*    70 */   184,  186,  188,  189,  190,  191,  192,  193,  194,  196,
+ /*    80 */   197,  199,  200,  201,  202,  203,  204,  207,  210,  212,
+ /*    90 */   213,  214,  215,  218,  219,  221,  223,  225,  226,  227,
+ /*   100 */   228,  234,  153,  235,  236,  152,  155,  158,  237,  159,
+ /*   110 */   174,  209,  239,  242,  240,  243,  246,  248,  245,  247,
+ /*   120 */   249,  250,  251,  256,  253,  255,  254,  257,  258,  261,
+ /*   130 */   262,  264,  259,  260,  263,  272,  274,  270,  277,
 };
 static const YYACTIONTYPE yy_default[] = {
- /*     0 */   636,  690,  679,  855,  855,  636,  636,  636,  636,  636,
- /*    10 */   636,  783,  654,  855,  636,  636,  636,  636,  636,  636,
- /*    20 */   636,  636,  636,  692,  692,  692,  778,  636,  636,  636,
- /*    30 */   636,  636,  636,  636,  636,  636,  636,  636,  636,  636,
- /*    40 */   636,  636,  636,  636,  636,  636,  636,  636,  636,  636,
- /*    50 */   636,  636,  636,  636,  636,  636,  636,  785,  787,  636,
- /*    60 */   804,  804,  776,  636,  636,  636,  636,  636,  636,  636,
- /*    70 */   636,  636,  636,  636,  636,  636,  636,  636,  636,  636,
- /*    80 */   636,  677,  636,  675,  636,  636,  636,  636,  636,  636,
- /*    90 */   636,  636,  636,  636,  636,  636,  664,  636,  636,  636,
- /*   100 */   636,  636,  636,  656,  656,  636,  636,  656,  811,  815,
- /*   110 */   809,  797,  805,  796,  792,  791,  819,  636,  656,  656,
- /*   120 */   687,  687,  656,  708,  706,  704,  696,  702,  698,  700,
- /*   130 */   694,  656,  685,  656,  685,  656,  724,  738,  636,  820,
- /*   140 */   854,  810,  838,  837,  850,  844,  843,  636,  842,  841,
- /*   150 */   840,  839,  636,  636,  636,  636,  846,  845,  636,  636,
- /*   160 */   636,  636,  636,  636,  636,  636,  636,  822,  816,  812,
- /*   170 */   636,  636,  636,  636,  636,  636,  636,  636,  636,  636,
- /*   180 */   636,  636,  636,  636,  636,  636,  636,  636,  775,  636,
- /*   190 */   636,  784,  636,  636,  636,  636,  636,  636,  806,  636,
- /*   200 */   798,  636,  636,  636,  636,  636,  636,  752,  636,  636,
- /*   210 */   636,  636,  636,  636,  636,  636,  636,  636,  636,  636,
- /*   220 */   636,  859,  636,  636,  636,  746,  857,  636,  636,  636,
- /*   230 */   636,  636,  636,  636,  636,  636,  636,  636,  636,  636,
- /*   240 */   636,  711,  636,  662,  660,  636,  652,  636,
+ /*     0 */   646,  700,  689,  868,  868,  646,  646,  646,  646,  646,
+ /*    10 */   646,  793,  664,  868,  646,  646,  646,  646,  646,  646,
+ /*    20 */   646,  646,  646,  702,  702,  702,  788,  646,  646,  646,
+ /*    30 */   646,  646,  646,  646,  646,  646,  646,  646,  646,  646,
+ /*    40 */   646,  646,  646,  646,  646,  646,  646,  646,  646,  646,
+ /*    50 */   646,  646,  646,  646,  646,  646,  646,  795,  797,  646,
+ /*    60 */   815,  815,  786,  646,  646,  646,  646,  646,  646,  646,
+ /*    70 */   646,  646,  646,  646,  646,  646,  646,  646,  646,  646,
+ /*    80 */   646,  687,  646,  685,  646,  646,  646,  646,  646,  646,
+ /*    90 */   646,  646,  646,  646,  646,  646,  674,  646,  646,  646,
+ /*   100 */   646,  646,  646,  666,  666,  646,  646,  646,  666,  822,
+ /*   110 */   826,  820,  808,  816,  807,  803,  802,  830,  646,  666,
+ /*   120 */   666,  697,  697,  666,  718,  716,  714,  706,  712,  708,
+ /*   130 */   710,  704,  666,  695,  666,  695,  666,  734,  748,  646,
+ /*   140 */   831,  867,  821,  857,  856,  863,  855,  854,  646,  850,
+ /*   150 */   851,  853,  852,  646,  646,  646,  646,  859,  858,  646,
+ /*   160 */   646,  646,  646,  646,  646,  646,  646,  646,  646,  833,
+ /*   170 */   646,  827,  823,  646,  646,  646,  646,  646,  646,  646,
+ /*   180 */   646,  646,  646,  646,  646,  646,  646,  646,  646,  646,
+ /*   190 */   646,  785,  646,  646,  794,  646,  646,  646,  646,  646,
+ /*   200 */   646,  817,  646,  809,  646,  646,  646,  646,  646,  646,
+ /*   210 */   646,  762,  646,  646,  646,  646,  646,  646,  646,  646,
+ /*   220 */   646,  646,  646,  646,  646,  872,  646,  646,  646,  756,
+ /*   230 */   870,  646,  646,  646,  646,  646,  646,  646,  646,  646,
+ /*   240 */   646,  646,  646,  646,  646,  721,  646,  672,  670,  646,
+ /*   250 */   662,  646,
 };
 /********** End of lemon-generated parsing tables *****************************/
 
@@ -1156,81 +1161,84 @@ static const char *const yyRuleName[] = {
  /* 149 */ "tablelist ::= tablelist COMMA ids cpxName ids",
  /* 150 */ "tmvar ::= VARIABLE",
  /* 151 */ "interval_opt ::= INTERVAL LP tmvar RP",
- /* 152 */ "interval_opt ::=",
- /* 153 */ "fill_opt ::=",
- /* 154 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
- /* 155 */ "fill_opt ::= FILL LP ID RP",
- /* 156 */ "sliding_opt ::= SLIDING LP tmvar RP",
- /* 157 */ "sliding_opt ::=",
- /* 158 */ "orderby_opt ::=",
- /* 159 */ "orderby_opt ::= ORDER BY sortlist",
- /* 160 */ "sortlist ::= sortlist COMMA item sortorder",
- /* 161 */ "sortlist ::= item sortorder",
- /* 162 */ "item ::= ids cpxName",
- /* 163 */ "sortorder ::= ASC",
- /* 164 */ "sortorder ::= DESC",
- /* 165 */ "sortorder ::=",
- /* 166 */ "groupby_opt ::=",
- /* 167 */ "groupby_opt ::= GROUP BY grouplist",
- /* 168 */ "grouplist ::= grouplist COMMA item",
- /* 169 */ "grouplist ::= item",
- /* 170 */ "having_opt ::=",
- /* 171 */ "having_opt ::= HAVING expr",
- /* 172 */ "limit_opt ::=",
- /* 173 */ "limit_opt ::= LIMIT signed",
- /* 174 */ "limit_opt ::= LIMIT signed OFFSET signed",
- /* 175 */ "limit_opt ::= LIMIT signed COMMA signed",
- /* 176 */ "slimit_opt ::=",
- /* 177 */ "slimit_opt ::= SLIMIT signed",
- /* 178 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
- /* 179 */ "slimit_opt ::= SLIMIT signed COMMA signed",
- /* 180 */ "where_opt ::=",
- /* 181 */ "where_opt ::= WHERE expr",
- /* 182 */ "expr ::= LP expr RP",
- /* 183 */ "expr ::= ID",
- /* 184 */ "expr ::= ID DOT ID",
- /* 185 */ "expr ::= ID DOT STAR",
- /* 186 */ "expr ::= INTEGER",
- /* 187 */ "expr ::= MINUS INTEGER",
- /* 188 */ "expr ::= PLUS INTEGER",
- /* 189 */ "expr ::= FLOAT",
- /* 190 */ "expr ::= MINUS FLOAT",
- /* 191 */ "expr ::= PLUS FLOAT",
- /* 192 */ "expr ::= STRING",
- /* 193 */ "expr ::= NOW",
- /* 194 */ "expr ::= VARIABLE",
- /* 195 */ "expr ::= BOOL",
- /* 196 */ "expr ::= ID LP exprlist RP",
- /* 197 */ "expr ::= ID LP STAR RP",
- /* 198 */ "expr ::= expr AND expr",
- /* 199 */ "expr ::= expr OR expr",
- /* 200 */ "expr ::= expr LT expr",
- /* 201 */ "expr ::= expr GT expr",
- /* 202 */ "expr ::= expr LE expr",
- /* 203 */ "expr ::= expr GE expr",
- /* 204 */ "expr ::= expr NE expr",
- /* 205 */ "expr ::= expr EQ expr",
- /* 206 */ "expr ::= expr PLUS expr",
- /* 207 */ "expr ::= expr MINUS expr",
- /* 208 */ "expr ::= expr STAR expr",
- /* 209 */ "expr ::= expr SLASH expr",
- /* 210 */ "expr ::= expr REM expr",
- /* 211 */ "expr ::= expr LIKE expr",
- /* 212 */ "expr ::= expr IN LP exprlist RP",
- /* 213 */ "exprlist ::= exprlist COMMA expritem",
- /* 214 */ "exprlist ::= expritem",
- /* 215 */ "expritem ::= expr",
- /* 216 */ "expritem ::=",
- /* 217 */ "cmd ::= RESET QUERY CACHE",
- /* 218 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
- /* 219 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
- /* 220 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
- /* 221 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
- /* 222 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
- /* 223 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
- /* 224 */ "cmd ::= KILL CONNECTION INTEGER",
- /* 225 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
- /* 226 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
+ /* 152 */ "interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP",
+ /* 153 */ "interval_opt ::=",
+ /* 154 */ "fill_opt ::=",
+ /* 155 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
+ /* 156 */ "fill_opt ::= FILL LP ID RP",
+ /* 157 */ "sliding_opt ::= SLIDING LP tmvar RP",
+ /* 158 */ "sliding_opt ::=",
+ /* 159 */ "orderby_opt ::=",
+ /* 160 */ "orderby_opt ::= ORDER BY sortlist",
+ /* 161 */ "sortlist ::= sortlist COMMA item sortorder",
+ /* 162 */ "sortlist ::= item sortorder",
+ /* 163 */ "item ::= ids cpxName",
+ /* 164 */ "sortorder ::= ASC",
+ /* 165 */ "sortorder ::= DESC",
+ /* 166 */ "sortorder ::=",
+ /* 167 */ "groupby_opt ::=",
+ /* 168 */ "groupby_opt ::= GROUP BY grouplist",
+ /* 169 */ "grouplist ::= grouplist COMMA item",
+ /* 170 */ "grouplist ::= item",
+ /* 171 */ "having_opt ::=",
+ /* 172 */ "having_opt ::= HAVING expr",
+ /* 173 */ "limit_opt ::=",
+ /* 174 */ "limit_opt ::= LIMIT signed",
+ /* 175 */ "limit_opt ::= LIMIT signed OFFSET signed",
+ /* 176 */ "limit_opt ::= LIMIT signed COMMA signed",
+ /* 177 */ "slimit_opt ::=",
+ /* 178 */ "slimit_opt ::= SLIMIT signed",
+ /* 179 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
+ /* 180 */ "slimit_opt ::= SLIMIT signed COMMA signed",
+ /* 181 */ "where_opt ::=",
+ /* 182 */ "where_opt ::= WHERE expr",
+ /* 183 */ "expr ::= LP expr RP",
+ /* 184 */ "expr ::= ID",
+ /* 185 */ "expr ::= ID DOT ID",
+ /* 186 */ "expr ::= ID DOT STAR",
+ /* 187 */ "expr ::= INTEGER",
+ /* 188 */ "expr ::= MINUS INTEGER",
+ /* 189 */ "expr ::= PLUS INTEGER",
+ /* 190 */ "expr ::= FLOAT",
+ /* 191 */ "expr ::= MINUS FLOAT",
+ /* 192 */ "expr ::= PLUS FLOAT",
+ /* 193 */ "expr ::= STRING",
+ /* 194 */ "expr ::= NOW",
+ /* 195 */ "expr ::= VARIABLE",
+ /* 196 */ "expr ::= BOOL",
+ /* 197 */ "expr ::= ID LP exprlist RP",
+ /* 198 */ "expr ::= ID LP STAR RP",
+ /* 199 */ "expr ::= expr IS NULL",
+ /* 200 */ "expr ::= expr IS NOT NULL",
+ /* 201 */ "expr ::= expr LT expr",
+ /* 202 */ "expr ::= expr GT expr",
+ /* 203 */ "expr ::= expr LE expr",
+ /* 204 */ "expr ::= expr GE expr",
+ /* 205 */ "expr ::= expr NE expr",
+ /* 206 */ "expr ::= expr EQ expr",
+ /* 207 */ "expr ::= expr AND expr",
+ /* 208 */ "expr ::= expr OR expr",
+ /* 209 */ "expr ::= expr PLUS expr",
+ /* 210 */ "expr ::= expr MINUS expr",
+ /* 211 */ "expr ::= expr STAR expr",
+ /* 212 */ "expr ::= expr SLASH expr",
+ /* 213 */ "expr ::= expr REM expr",
+ /* 214 */ "expr ::= expr LIKE expr",
+ /* 215 */ "expr ::= expr IN LP exprlist RP",
+ /* 216 */ "exprlist ::= exprlist COMMA expritem",
+ /* 217 */ "exprlist ::= expritem",
+ /* 218 */ "expritem ::= expr",
+ /* 219 */ "expritem ::=",
+ /* 220 */ "cmd ::= RESET QUERY CACHE",
+ /* 221 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
+ /* 222 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
+ /* 223 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
+ /* 224 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
+ /* 225 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
+ /* 226 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
+ /* 227 */ "cmd ::= KILL CONNECTION INTEGER",
+ /* 228 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
+ /* 229 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
 };
 #endif /* NDEBUG */
 
@@ -1840,81 +1848,84 @@ static const struct {
   {  262,   -5 }, /* (149) tablelist ::= tablelist COMMA ids cpxName ids */
   {  263,   -1 }, /* (150) tmvar ::= VARIABLE */
   {  250,   -4 }, /* (151) interval_opt ::= INTERVAL LP tmvar RP */
-  {  250,    0 }, /* (152) interval_opt ::= */
-  {  251,    0 }, /* (153) fill_opt ::= */
-  {  251,   -6 }, /* (154) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
-  {  251,   -4 }, /* (155) fill_opt ::= FILL LP ID RP */
-  {  252,   -4 }, /* (156) sliding_opt ::= SLIDING LP tmvar RP */
-  {  252,    0 }, /* (157) sliding_opt ::= */
-  {  254,    0 }, /* (158) orderby_opt ::= */
-  {  254,   -3 }, /* (159) orderby_opt ::= ORDER BY sortlist */
-  {  264,   -4 }, /* (160) sortlist ::= sortlist COMMA item sortorder */
-  {  264,   -2 }, /* (161) sortlist ::= item sortorder */
-  {  266,   -2 }, /* (162) item ::= ids cpxName */
-  {  267,   -1 }, /* (163) sortorder ::= ASC */
-  {  267,   -1 }, /* (164) sortorder ::= DESC */
-  {  267,    0 }, /* (165) sortorder ::= */
-  {  253,    0 }, /* (166) groupby_opt ::= */
-  {  253,   -3 }, /* (167) groupby_opt ::= GROUP BY grouplist */
-  {  268,   -3 }, /* (168) grouplist ::= grouplist COMMA item */
-  {  268,   -1 }, /* (169) grouplist ::= item */
-  {  255,    0 }, /* (170) having_opt ::= */
-  {  255,   -2 }, /* (171) having_opt ::= HAVING expr */
-  {  257,    0 }, /* (172) limit_opt ::= */
-  {  257,   -2 }, /* (173) limit_opt ::= LIMIT signed */
-  {  257,   -4 }, /* (174) limit_opt ::= LIMIT signed OFFSET signed */
-  {  257,   -4 }, /* (175) limit_opt ::= LIMIT signed COMMA signed */
-  {  256,    0 }, /* (176) slimit_opt ::= */
-  {  256,   -2 }, /* (177) slimit_opt ::= SLIMIT signed */
-  {  256,   -4 }, /* (178) slimit_opt ::= SLIMIT signed SOFFSET signed */
-  {  256,   -4 }, /* (179) slimit_opt ::= SLIMIT signed COMMA signed */
-  {  249,    0 }, /* (180) where_opt ::= */
-  {  249,   -2 }, /* (181) where_opt ::= WHERE expr */
-  {  260,   -3 }, /* (182) expr ::= LP expr RP */
-  {  260,   -1 }, /* (183) expr ::= ID */
-  {  260,   -3 }, /* (184) expr ::= ID DOT ID */
-  {  260,   -3 }, /* (185) expr ::= ID DOT STAR */
-  {  260,   -1 }, /* (186) expr ::= INTEGER */
-  {  260,   -2 }, /* (187) expr ::= MINUS INTEGER */
-  {  260,   -2 }, /* (188) expr ::= PLUS INTEGER */
-  {  260,   -1 }, /* (189) expr ::= FLOAT */
-  {  260,   -2 }, /* (190) expr ::= MINUS FLOAT */
-  {  260,   -2 }, /* (191) expr ::= PLUS FLOAT */
-  {  260,   -1 }, /* (192) expr ::= STRING */
-  {  260,   -1 }, /* (193) expr ::= NOW */
-  {  260,   -1 }, /* (194) expr ::= VARIABLE */
-  {  260,   -1 }, /* (195) expr ::= BOOL */
-  {  260,   -4 }, /* (196) expr ::= ID LP exprlist RP */
-  {  260,   -4 }, /* (197) expr ::= ID LP STAR RP */
-  {  260,   -3 }, /* (198) expr ::= expr AND expr */
-  {  260,   -3 }, /* (199) expr ::= expr OR expr */
-  {  260,   -3 }, /* (200) expr ::= expr LT expr */
-  {  260,   -3 }, /* (201) expr ::= expr GT expr */
-  {  260,   -3 }, /* (202) expr ::= expr LE expr */
-  {  260,   -3 }, /* (203) expr ::= expr GE expr */
-  {  260,   -3 }, /* (204) expr ::= expr NE expr */
-  {  260,   -3 }, /* (205) expr ::= expr EQ expr */
-  {  260,   -3 }, /* (206) expr ::= expr PLUS expr */
-  {  260,   -3 }, /* (207) expr ::= expr MINUS expr */
-  {  260,   -3 }, /* (208) expr ::= expr STAR expr */
-  {  260,   -3 }, /* (209) expr ::= expr SLASH expr */
-  {  260,   -3 }, /* (210) expr ::= expr REM expr */
-  {  260,   -3 }, /* (211) expr ::= expr LIKE expr */
-  {  260,   -5 }, /* (212) expr ::= expr IN LP exprlist RP */
-  {  269,   -3 }, /* (213) exprlist ::= exprlist COMMA expritem */
-  {  269,   -1 }, /* (214) exprlist ::= expritem */
-  {  270,   -1 }, /* (215) expritem ::= expr */
-  {  270,    0 }, /* (216) expritem ::= */
-  {  208,   -3 }, /* (217) cmd ::= RESET QUERY CACHE */
-  {  208,   -7 }, /* (218) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
-  {  208,   -7 }, /* (219) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
-  {  208,   -7 }, /* (220) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
-  {  208,   -7 }, /* (221) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
-  {  208,   -8 }, /* (222) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
-  {  208,   -9 }, /* (223) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
-  {  208,   -3 }, /* (224) cmd ::= KILL CONNECTION INTEGER */
-  {  208,   -5 }, /* (225) cmd ::= KILL STREAM INTEGER COLON INTEGER */
-  {  208,   -5 }, /* (226) cmd ::= KILL QUERY INTEGER COLON INTEGER */
+  {  250,   -6 }, /* (152) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
+  {  250,    0 }, /* (153) interval_opt ::= */
+  {  251,    0 }, /* (154) fill_opt ::= */
+  {  251,   -6 }, /* (155) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+  {  251,   -4 }, /* (156) fill_opt ::= FILL LP ID RP */
+  {  252,   -4 }, /* (157) sliding_opt ::= SLIDING LP tmvar RP */
+  {  252,    0 }, /* (158) sliding_opt ::= */
+  {  254,    0 }, /* (159) orderby_opt ::= */
+  {  254,   -3 }, /* (160) orderby_opt ::= ORDER BY sortlist */
+  {  264,   -4 }, /* (161) sortlist ::= sortlist COMMA item sortorder */
+  {  264,   -2 }, /* (162) sortlist ::= item sortorder */
+  {  266,   -2 }, /* (163) item ::= ids cpxName */
+  {  267,   -1 }, /* (164) sortorder ::= ASC */
+  {  267,   -1 }, /* (165) sortorder ::= DESC */
+  {  267,    0 }, /* (166) sortorder ::= */
+  {  253,    0 }, /* (167) groupby_opt ::= */
+  {  253,   -3 }, /* (168) groupby_opt ::= GROUP BY grouplist */
+  {  268,   -3 }, /* (169) grouplist ::= grouplist COMMA item */
+  {  268,   -1 }, /* (170) grouplist ::= item */
+  {  255,    0 }, /* (171) having_opt ::= */
+  {  255,   -2 }, /* (172) having_opt ::= HAVING expr */
+  {  257,    0 }, /* (173) limit_opt ::= */
+  {  257,   -2 }, /* (174) limit_opt ::= LIMIT signed */
+  {  257,   -4 }, /* (175) limit_opt ::= LIMIT signed OFFSET signed */
+  {  257,   -4 }, /* (176) limit_opt ::= LIMIT signed COMMA signed */
+  {  256,    0 }, /* (177) slimit_opt ::= */
+  {  256,   -2 }, /* (178) slimit_opt ::= SLIMIT signed */
+  {  256,   -4 }, /* (179) slimit_opt ::= SLIMIT signed SOFFSET signed */
+  {  256,   -4 }, /* (180) slimit_opt ::= SLIMIT signed COMMA signed */
+  {  249,    0 }, /* (181) where_opt ::= */
+  {  249,   -2 }, /* (182) where_opt ::= WHERE expr */
+  {  260,   -3 }, /* (183) expr ::= LP expr RP */
+  {  260,   -1 }, /* (184) expr ::= ID */
+  {  260,   -3 }, /* (185) expr ::= ID DOT ID */
+  {  260,   -3 }, /* (186) expr ::= ID DOT STAR */
+  {  260,   -1 }, /* (187) expr ::= INTEGER */
+  {  260,   -2 }, /* (188) expr ::= MINUS INTEGER */
+  {  260,   -2 }, /* (189) expr ::= PLUS INTEGER */
+  {  260,   -1 }, /* (190) expr ::= FLOAT */
+  {  260,   -2 }, /* (191) expr ::= MINUS FLOAT */
+  {  260,   -2 }, /* (192) expr ::= PLUS FLOAT */
+  {  260,   -1 }, /* (193) expr ::= STRING */
+  {  260,   -1 }, /* (194) expr ::= NOW */
+  {  260,   -1 }, /* (195) expr ::= VARIABLE */
+  {  260,   -1 }, /* (196) expr ::= BOOL */
+  {  260,   -4 }, /* (197) expr ::= ID LP exprlist RP */
+  {  260,   -4 }, /* (198) expr ::= ID LP STAR RP */
+  {  260,   -3 }, /* (199) expr ::= expr IS NULL */
+  {  260,   -4 }, /* (200) expr ::= expr IS NOT NULL */
+  {  260,   -3 }, /* (201) expr ::= expr LT expr */
+  {  260,   -3 }, /* (202) expr ::= expr GT expr */
+  {  260,   -3 }, /* (203) expr ::= expr LE expr */
+  {  260,   -3 }, /* (204) expr ::= expr GE expr */
+  {  260,   -3 }, /* (205) expr ::= expr NE expr */
+  {  260,   -3 }, /* (206) expr ::= expr EQ expr */
+  {  260,   -3 }, /* (207) expr ::= expr AND expr */
+  {  260,   -3 }, /* (208) expr ::= expr OR expr */
+  {  260,   -3 }, /* (209) expr ::= expr PLUS expr */
+  {  260,   -3 }, /* (210) expr ::= expr MINUS expr */
+  {  260,   -3 }, /* (211) expr ::= expr STAR expr */
+  {  260,   -3 }, /* (212) expr ::= expr SLASH expr */
+  {  260,   -3 }, /* (213) expr ::= expr REM expr */
+  {  260,   -3 }, /* (214) expr ::= expr LIKE expr */
+  {  260,   -5 }, /* (215) expr ::= expr IN LP exprlist RP */
+  {  269,   -3 }, /* (216) exprlist ::= exprlist COMMA expritem */
+  {  269,   -1 }, /* (217) exprlist ::= expritem */
+  {  270,   -1 }, /* (218) expritem ::= expr */
+  {  270,    0 }, /* (219) expritem ::= */
+  {  208,   -3 }, /* (220) cmd ::= RESET QUERY CACHE */
+  {  208,   -7 }, /* (221) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+  {  208,   -7 }, /* (222) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+  {  208,   -7 }, /* (223) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+  {  208,   -7 }, /* (224) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+  {  208,   -8 }, /* (225) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+  {  208,   -9 }, /* (226) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+  {  208,   -3 }, /* (227) cmd ::= KILL CONNECTION INTEGER */
+  {  208,   -5 }, /* (228) cmd ::= KILL STREAM INTEGER COLON INTEGER */
+  {  208,   -5 }, /* (229) cmd ::= KILL QUERY INTEGER COLON INTEGER */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -2405,7 +2416,7 @@ static void yy_reduce(
         break;
       case 131: /* select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
 {
-  yylhsminor.yy150 = tSetQuerySQLElems(&yymsp[-11].minor.yy0, yymsp[-10].minor.yy224, yymsp[-9].minor.yy494, yymsp[-8].minor.yy66, yymsp[-4].minor.yy494, yymsp[-3].minor.yy494, &yymsp[-7].minor.yy0, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy494, &yymsp[0].minor.yy188, &yymsp[-1].minor.yy188);
+  yylhsminor.yy150 = tSetQuerySQLElems(&yymsp[-11].minor.yy0, yymsp[-10].minor.yy224, yymsp[-9].minor.yy494, yymsp[-8].minor.yy66, yymsp[-4].minor.yy494, yymsp[-3].minor.yy494, &yymsp[-7].minor.yy314, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy494, &yymsp[0].minor.yy188, &yymsp[-1].minor.yy188);
 }
   yymsp[-11].minor.yy150 = yylhsminor.yy150;
         break;
@@ -2509,17 +2520,18 @@ static void yy_reduce(
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
       case 151: /* interval_opt ::= INTERVAL LP tmvar RP */
-      case 156: /* sliding_opt ::= SLIDING LP tmvar RP */ yytestcase(yyruleno==156);
-{yymsp[-3].minor.yy0 = yymsp[-1].minor.yy0;     }
+{yymsp[-3].minor.yy314.interval = yymsp[-1].minor.yy0; yymsp[-3].minor.yy314.offset.n = 0; yymsp[-3].minor.yy314.offset.z = NULL; yymsp[-3].minor.yy314.offset.type = 0;}
         break;
-      case 152: /* interval_opt ::= */
-      case 157: /* sliding_opt ::= */ yytestcase(yyruleno==157);
-{yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0;   }
+      case 152: /* interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
+{yymsp[-5].minor.yy314.interval = yymsp[-3].minor.yy0; yymsp[-5].minor.yy314.offset = yymsp[-1].minor.yy0;}
         break;
-      case 153: /* fill_opt ::= */
+      case 153: /* interval_opt ::= */
+{memset(&yymsp[1].minor.yy314, 0, sizeof(yymsp[1].minor.yy314));}
+        break;
+      case 154: /* fill_opt ::= */
 {yymsp[1].minor.yy494 = 0;     }
         break;
-      case 154: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+      case 155: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
 {
     tVariant A = {0};
     toTSDBType(yymsp[-3].minor.yy0.type);
@@ -2529,33 +2541,39 @@ static void yy_reduce(
     yymsp[-5].minor.yy494 = yymsp[-1].minor.yy494;
 }
         break;
-      case 155: /* fill_opt ::= FILL LP ID RP */
+      case 156: /* fill_opt ::= FILL LP ID RP */
 {
     toTSDBType(yymsp[-1].minor.yy0.type);
     yymsp[-3].minor.yy494 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
 }
         break;
-      case 158: /* orderby_opt ::= */
-      case 166: /* groupby_opt ::= */ yytestcase(yyruleno==166);
+      case 157: /* sliding_opt ::= SLIDING LP tmvar RP */
+{yymsp[-3].minor.yy0 = yymsp[-1].minor.yy0;     }
+        break;
+      case 158: /* sliding_opt ::= */
+{yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0;   }
+        break;
+      case 159: /* orderby_opt ::= */
+      case 167: /* groupby_opt ::= */ yytestcase(yyruleno==167);
 {yymsp[1].minor.yy494 = 0;}
         break;
-      case 159: /* orderby_opt ::= ORDER BY sortlist */
-      case 167: /* groupby_opt ::= GROUP BY grouplist */ yytestcase(yyruleno==167);
+      case 160: /* orderby_opt ::= ORDER BY sortlist */
+      case 168: /* groupby_opt ::= GROUP BY grouplist */ yytestcase(yyruleno==168);
 {yymsp[-2].minor.yy494 = yymsp[0].minor.yy494;}
         break;
-      case 160: /* sortlist ::= sortlist COMMA item sortorder */
+      case 161: /* sortlist ::= sortlist COMMA item sortorder */
 {
     yylhsminor.yy494 = tVariantListAppend(yymsp[-3].minor.yy494, &yymsp[-1].minor.yy312, yymsp[0].minor.yy82);
 }
   yymsp[-3].minor.yy494 = yylhsminor.yy494;
         break;
-      case 161: /* sortlist ::= item sortorder */
+      case 162: /* sortlist ::= item sortorder */
 {
   yylhsminor.yy494 = tVariantListAppend(NULL, &yymsp[-1].minor.yy312, yymsp[0].minor.yy82);
 }
   yymsp[-1].minor.yy494 = yylhsminor.yy494;
         break;
-      case 162: /* item ::= ids cpxName */
+      case 163: /* item ::= ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
@@ -2564,196 +2582,200 @@ static void yy_reduce(
 }
   yymsp[-1].minor.yy312 = yylhsminor.yy312;
         break;
-      case 163: /* sortorder ::= ASC */
+      case 164: /* sortorder ::= ASC */
 {yymsp[0].minor.yy82 = TSDB_ORDER_ASC; }
         break;
-      case 164: /* sortorder ::= DESC */
+      case 165: /* sortorder ::= DESC */
 {yymsp[0].minor.yy82 = TSDB_ORDER_DESC;}
         break;
-      case 165: /* sortorder ::= */
+      case 166: /* sortorder ::= */
 {yymsp[1].minor.yy82 = TSDB_ORDER_ASC;}
         break;
-      case 168: /* grouplist ::= grouplist COMMA item */
+      case 169: /* grouplist ::= grouplist COMMA item */
 {
   yylhsminor.yy494 = tVariantListAppend(yymsp[-2].minor.yy494, &yymsp[0].minor.yy312, -1);
 }
   yymsp[-2].minor.yy494 = yylhsminor.yy494;
         break;
-      case 169: /* grouplist ::= item */
+      case 170: /* grouplist ::= item */
 {
   yylhsminor.yy494 = tVariantListAppend(NULL, &yymsp[0].minor.yy312, -1);
 }
   yymsp[0].minor.yy494 = yylhsminor.yy494;
         break;
-      case 170: /* having_opt ::= */
-      case 180: /* where_opt ::= */ yytestcase(yyruleno==180);
-      case 216: /* expritem ::= */ yytestcase(yyruleno==216);
+      case 171: /* having_opt ::= */
+      case 181: /* where_opt ::= */ yytestcase(yyruleno==181);
+      case 219: /* expritem ::= */ yytestcase(yyruleno==219);
 {yymsp[1].minor.yy66 = 0;}
         break;
-      case 171: /* having_opt ::= HAVING expr */
-      case 181: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==181);
+      case 172: /* having_opt ::= HAVING expr */
+      case 182: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==182);
 {yymsp[-1].minor.yy66 = yymsp[0].minor.yy66;}
         break;
-      case 172: /* limit_opt ::= */
-      case 176: /* slimit_opt ::= */ yytestcase(yyruleno==176);
+      case 173: /* limit_opt ::= */
+      case 177: /* slimit_opt ::= */ yytestcase(yyruleno==177);
 {yymsp[1].minor.yy188.limit = -1; yymsp[1].minor.yy188.offset = 0;}
         break;
-      case 173: /* limit_opt ::= LIMIT signed */
-      case 177: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==177);
+      case 174: /* limit_opt ::= LIMIT signed */
+      case 178: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==178);
 {yymsp[-1].minor.yy188.limit = yymsp[0].minor.yy271;  yymsp[-1].minor.yy188.offset = 0;}
         break;
-      case 174: /* limit_opt ::= LIMIT signed OFFSET signed */
-      case 178: /* slimit_opt ::= SLIMIT signed SOFFSET signed */ yytestcase(yyruleno==178);
+      case 175: /* limit_opt ::= LIMIT signed OFFSET signed */
+      case 179: /* slimit_opt ::= SLIMIT signed SOFFSET signed */ yytestcase(yyruleno==179);
 {yymsp[-3].minor.yy188.limit = yymsp[-2].minor.yy271;  yymsp[-3].minor.yy188.offset = yymsp[0].minor.yy271;}
         break;
-      case 175: /* limit_opt ::= LIMIT signed COMMA signed */
-      case 179: /* slimit_opt ::= SLIMIT signed COMMA signed */ yytestcase(yyruleno==179);
+      case 176: /* limit_opt ::= LIMIT signed COMMA signed */
+      case 180: /* slimit_opt ::= SLIMIT signed COMMA signed */ yytestcase(yyruleno==180);
 {yymsp[-3].minor.yy188.limit = yymsp[0].minor.yy271;  yymsp[-3].minor.yy188.offset = yymsp[-2].minor.yy271;}
         break;
-      case 182: /* expr ::= LP expr RP */
+      case 183: /* expr ::= LP expr RP */
 {yymsp[-2].minor.yy66 = yymsp[-1].minor.yy66; }
         break;
-      case 183: /* expr ::= ID */
+      case 184: /* expr ::= ID */
 {yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_ID);}
   yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 184: /* expr ::= ID DOT ID */
+      case 185: /* expr ::= ID DOT ID */
 {yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ID);}
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 185: /* expr ::= ID DOT STAR */
+      case 186: /* expr ::= ID DOT STAR */
 {yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ALL);}
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 186: /* expr ::= INTEGER */
+      case 187: /* expr ::= INTEGER */
 {yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_INTEGER);}
   yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 187: /* expr ::= MINUS INTEGER */
-      case 188: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==188);
+      case 188: /* expr ::= MINUS INTEGER */
+      case 189: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==189);
 {yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_INTEGER);}
   yymsp[-1].minor.yy66 = yylhsminor.yy66;
         break;
-      case 189: /* expr ::= FLOAT */
+      case 190: /* expr ::= FLOAT */
 {yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_FLOAT);}
   yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 190: /* expr ::= MINUS FLOAT */
-      case 191: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==191);
+      case 191: /* expr ::= MINUS FLOAT */
+      case 192: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==192);
 {yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_FLOAT);}
   yymsp[-1].minor.yy66 = yylhsminor.yy66;
         break;
-      case 192: /* expr ::= STRING */
+      case 193: /* expr ::= STRING */
 {yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_STRING);}
   yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 193: /* expr ::= NOW */
+      case 194: /* expr ::= NOW */
 {yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_NOW); }
   yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 194: /* expr ::= VARIABLE */
+      case 195: /* expr ::= VARIABLE */
 {yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_VARIABLE);}
   yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 195: /* expr ::= BOOL */
+      case 196: /* expr ::= BOOL */
 {yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_BOOL);}
   yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 196: /* expr ::= ID LP exprlist RP */
-{
-  yylhsminor.yy66 = tSQLExprCreateFunction(yymsp[-1].minor.yy224, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type);
-}
+      case 197: /* expr ::= ID LP exprlist RP */
+{ yylhsminor.yy66 = tSQLExprCreateFunction(yymsp[-1].minor.yy224, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
   yymsp[-3].minor.yy66 = yylhsminor.yy66;
         break;
-      case 197: /* expr ::= ID LP STAR RP */
-{
-  yylhsminor.yy66 = tSQLExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type);
-}
+      case 198: /* expr ::= ID LP STAR RP */
+{ yylhsminor.yy66 = tSQLExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
   yymsp[-3].minor.yy66 = yylhsminor.yy66;
         break;
-      case 198: /* expr ::= expr AND expr */
-{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_AND);}
+      case 199: /* expr ::= expr IS NULL */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, NULL, TK_ISNULL);}
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 199: /* expr ::= expr OR expr */
-{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_OR); }
-  yymsp[-2].minor.yy66 = yylhsminor.yy66;
+      case 200: /* expr ::= expr IS NOT NULL */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-3].minor.yy66, NULL, TK_NOTNULL);}
+  yymsp[-3].minor.yy66 = yylhsminor.yy66;
         break;
-      case 200: /* expr ::= expr LT expr */
+      case 201: /* expr ::= expr LT expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_LT);}
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 201: /* expr ::= expr GT expr */
+      case 202: /* expr ::= expr GT expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_GT);}
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 202: /* expr ::= expr LE expr */
+      case 203: /* expr ::= expr LE expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_LE);}
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 203: /* expr ::= expr GE expr */
+      case 204: /* expr ::= expr GE expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_GE);}
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 204: /* expr ::= expr NE expr */
+      case 205: /* expr ::= expr NE expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_NE);}
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 205: /* expr ::= expr EQ expr */
+      case 206: /* expr ::= expr EQ expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_EQ);}
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 206: /* expr ::= expr PLUS expr */
+      case 207: /* expr ::= expr AND expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_AND);}
+  yymsp[-2].minor.yy66 = yylhsminor.yy66;
+        break;
+      case 208: /* expr ::= expr OR expr */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_OR); }
+  yymsp[-2].minor.yy66 = yylhsminor.yy66;
+        break;
+      case 209: /* expr ::= expr PLUS expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_PLUS);  }
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 207: /* expr ::= expr MINUS expr */
+      case 210: /* expr ::= expr MINUS expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_MINUS); }
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 208: /* expr ::= expr STAR expr */
+      case 211: /* expr ::= expr STAR expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_STAR);  }
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 209: /* expr ::= expr SLASH expr */
+      case 212: /* expr ::= expr SLASH expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_DIVIDE);}
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 210: /* expr ::= expr REM expr */
+      case 213: /* expr ::= expr REM expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_REM);   }
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 211: /* expr ::= expr LIKE expr */
+      case 214: /* expr ::= expr LIKE expr */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, yymsp[0].minor.yy66, TK_LIKE);  }
   yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 212: /* expr ::= expr IN LP exprlist RP */
+      case 215: /* expr ::= expr IN LP exprlist RP */
 {yylhsminor.yy66 = tSQLExprCreate(yymsp[-4].minor.yy66, (tSQLExpr*)yymsp[-1].minor.yy224, TK_IN); }
   yymsp[-4].minor.yy66 = yylhsminor.yy66;
         break;
-      case 213: /* exprlist ::= exprlist COMMA expritem */
+      case 216: /* exprlist ::= exprlist COMMA expritem */
 {yylhsminor.yy224 = tSQLExprListAppend(yymsp[-2].minor.yy224,yymsp[0].minor.yy66,0);}
   yymsp[-2].minor.yy224 = yylhsminor.yy224;
         break;
-      case 214: /* exprlist ::= expritem */
+      case 217: /* exprlist ::= expritem */
 {yylhsminor.yy224 = tSQLExprListAppend(0,yymsp[0].minor.yy66,0);}
   yymsp[0].minor.yy224 = yylhsminor.yy224;
         break;
-      case 215: /* expritem ::= expr */
+      case 218: /* expritem ::= expr */
 {yylhsminor.yy66 = yymsp[0].minor.yy66;}
   yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 217: /* cmd ::= RESET QUERY CACHE */
+      case 220: /* cmd ::= RESET QUERY CACHE */
 { setDCLSQLElems(pInfo, TSDB_SQL_RESET_CACHE, 0);}
         break;
-      case 218: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+      case 221: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
     SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy449, NULL, TSDB_ALTER_TABLE_ADD_COLUMN);
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 219: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+      case 222: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -2764,14 +2786,14 @@ static void yy_reduce(
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 220: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+      case 223: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
     SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy449, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN);
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 221: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+      case 224: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -2782,7 +2804,7 @@ static void yy_reduce(
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 222: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+      case 225: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
 {
     yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
 
@@ -2796,7 +2818,7 @@ static void yy_reduce(
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 223: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+      case 226: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
 {
     yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n;
 
@@ -2808,13 +2830,13 @@ static void yy_reduce(
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 224: /* cmd ::= KILL CONNECTION INTEGER */
+      case 227: /* cmd ::= KILL CONNECTION INTEGER */
 {setKillSQL(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);}
         break;
-      case 225: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
+      case 228: /* 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 226: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
+      case 229: /* 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:

From 49d279e4f7b66e363e0fb192f7f621d0a37d24ec Mon Sep 17 00:00:00 2001
From: Bomin Zhang <bmzhang@taosdata.com>
Date: Tue, 22 Sep 2020 16:06:40 +0800
Subject: [PATCH 24/35] td-1262: stream support history data

---
 src/client/src/tscStream.c     | 19 ++++------
 tests/pytest/fulltest.sh       |  1 +
 tests/pytest/stream/history.py | 63 ++++++++++++++++++++++++++++++++++
 3 files changed, 71 insertions(+), 12 deletions(-)
 create mode 100644 tests/pytest/stream/history.py

diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c
index 1ebef4ce0f..ea5532cf48 100644
--- a/src/client/src/tscStream.c
+++ b/src/client/src/tscStream.c
@@ -136,7 +136,6 @@ static void tscProcessStreamTimer(void *handle, void *tmrId) {
       etime = pStream->stime + (etime - pStream->stime) / pStream->interval.interval * pStream->interval.interval;
     } else {
       etime = taosTimeTruncate(etime, &pStream->interval, pStream->precision);
-      //etime = taosGetIntervalStartTimestamp(etime, pStream->interval.sliding, pStream->interval.sliding, pStream->interval.slidingUnit, pStream->precision);
     }
     pQueryInfo->window.ekey = etime;
     if (pQueryInfo->window.skey >= pQueryInfo->window.ekey) {
@@ -454,17 +453,11 @@ static int64_t tscGetStreamStartTimestamp(SSqlObj *pSql, SSqlStream *pStream, in
     }
   } else {             // timewindow based aggregation stream
     if (stime == 0) {  // no data in meter till now
-      stime = pQueryInfo->window.skey;
-      if (stime == INT64_MIN) {
-        stime = (int64_t)taosGetTimestamp(pStream->precision);
-        stime = taosTimeTruncate(stime, &pStream->interval, pStream->precision);
-        stime = taosTimeTruncate(stime - 1, &pStream->interval, pStream->precision);
-        //stime = taosGetIntervalStartTimestamp(stime, pStream->interval.interval, pStream->interval.interval, pStream->interval.intervalUnit, pStream->precision);
-        //stime = taosGetIntervalStartTimestamp(stime - 1, pStream->interval.interval, pStream->interval.interval, pStream->interval.intervalUnit, pStream->precision);
-        tscWarn("%p stream:%p, last timestamp:0, reset to:%" PRId64, pSql, pStream, stime);
+      if (pQueryInfo->window.skey != INT64_MIN) {
+        stime = pQueryInfo->window.skey;
       }
+      stime = taosTimeTruncate(stime, &pStream->interval, pStream->precision);
     } else {
-      //int64_t newStime = taosGetIntervalStartTimestamp(stime, pStream->interval.interval, pStream->interval.interval, pStream->interval.intervalUnit, pStream->precision);
       int64_t newStime = taosTimeTruncate(stime, &pStream->interval, pStream->precision);
       if (newStime != stime) {
         tscWarn("%p stream:%p, last timestamp:%" PRId64 ", reset to:%" PRId64, pSql, pStream, stime, newStime);
@@ -477,8 +470,10 @@ static int64_t tscGetStreamStartTimestamp(SSqlObj *pSql, SSqlStream *pStream, in
 }
 
 static int64_t tscGetLaunchTimestamp(const SSqlStream *pStream) {
-  int64_t timer = pStream->stime - taosGetTimestamp(pStream->precision);
-  if (timer < 0) timer = 0;
+  int64_t timer = 0, now = taosGetTimestamp(pStream->precision);
+  if (pStream->stime > now) {
+    timer = pStream->stime - now;
+  }
 
   int64_t startDelay =
       (pStream->precision == TSDB_TIME_PRECISION_MICRO) ? tsStreamCompStartDelay * 1000L : tsStreamCompStartDelay;
diff --git a/tests/pytest/fulltest.sh b/tests/pytest/fulltest.sh
index 9ebf1584e2..ab8593a781 100755
--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
@@ -154,6 +154,7 @@ python3 ./test.py -f stream/new.py
 python3 ./test.py -f stream/stream1.py
 python3 ./test.py -f stream/stream2.py
 python3 ./test.py -f stream/parser.py
+python3 ./test.py -f stream/history.py
 
 #alter table
 python3 ./test.py -f alter/alter_table_crash.py
diff --git a/tests/pytest/stream/history.py b/tests/pytest/stream/history.py
new file mode 100644
index 0000000000..890580001c
--- /dev/null
+++ b/tests/pytest/stream/history.py
@@ -0,0 +1,63 @@
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import time
+import taos
+from util.log import tdLog
+from util.cases import tdCases
+from util.sql import tdSql
+
+
+class TDTestCase:
+    def init(self, conn, logSql):
+        tdLog.debug("start to execute %s" % __file__)
+        tdSql.init(conn.cursor(), logSql)
+
+    def run(self):
+        tdSql.prepare()
+
+        tdSql.execute("create table cars(ts timestamp, s int) tags(id int)")
+        tdSql.execute("create table car0 using cars tags(0)")
+        tdSql.execute("create table car1 using cars tags(1)")
+        tdSql.execute("create table car2 using cars tags(2)")
+        tdSql.execute("create table car3 using cars tags(3)")
+        tdSql.execute("create table car4 using cars tags(4)")
+
+        tdSql.execute("insert into car0 values('2019-01-01 00:00:00.103', 1)")
+        tdSql.execute("insert into car1 values('2019-01-01 00:00:00.234', 1)")
+        tdSql.execute("insert into car0 values('2019-01-01 00:00:01.012', 1)")
+        tdSql.execute("insert into car0 values('2019-01-01 00:00:02.003', 1)")
+        tdSql.execute("insert into car2 values('2019-01-01 00:00:02.328', 1)")
+        tdSql.execute("insert into car0 values('2019-01-01 00:00:03.139', 1)")
+        tdSql.execute("insert into car0 values('2019-01-01 00:00:04.348', 1)")
+        tdSql.execute("insert into car0 values('2019-01-01 00:00:05.783', 1)")
+        tdSql.execute("insert into car1 values('2019-01-01 00:00:01.893', 1)")
+        tdSql.execute("insert into car1 values('2019-01-01 00:00:02.712', 1)")
+        tdSql.execute("insert into car1 values('2019-01-01 00:00:03.982', 1)")
+        tdSql.execute("insert into car3 values('2019-01-01 00:00:01.389', 1)")
+        tdSql.execute("insert into car4 values('2019-01-01 00:00:01.829', 1)")
+
+        tdSql.execute("create table strm as select count(*) from cars interval(4s)")
+        tdSql.waitedQuery("select * from strm", 2, 100)
+        tdSql.checkData(0, 1, 11)
+        tdSql.checkData(1, 1, 2)
+
+
+    def stop(self):
+        tdSql.close()
+        tdLog.success("%s successfully executed" % __file__)
+
+
+tdCases.addWindows(__file__, TDTestCase())
+tdCases.addLinux(__file__, TDTestCase())

From 3e57707227d76690f4a889b0c355a28f4b386641 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Tue, 22 Sep 2020 17:11:24 +0800
Subject: [PATCH 25/35] TD-1388

---
 src/client/src/tscSQLParser.c            |  2 +-
 src/inc/twal.h                           |  1 +
 src/mnode/src/mnodeDb.c                  |  8 ++--
 src/vnode/src/vnodeMain.c                |  6 +++
 src/wal/src/walMain.c                    | 50 ++++++++++++++++++++++--
 tests/script/general/db/alter_option.sim | 15 ++++---
 6 files changed, 69 insertions(+), 13 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index a6efffe436..f19381fb29 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -5722,7 +5722,7 @@ int32_t tscCheckCreateDbParams(SSqlCmd* pCmd, SCMCreateDbMsg* pCreate) {
   char msg[512] = {0};
 
   if (pCreate->walLevel != -1 && (pCreate->walLevel < TSDB_MIN_WAL_LEVEL || pCreate->walLevel > TSDB_MAX_WAL_LEVEL)) {
-    snprintf(msg, tListLen(msg), "invalid db option walLevel: %d, only 0-2 allowed", pCreate->walLevel);
+    snprintf(msg, tListLen(msg), "invalid db option walLevel: %d, only 1-2 allowed", pCreate->walLevel);
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
   }
 
diff --git a/src/inc/twal.h b/src/inc/twal.h
index 4fdb7aa275..cf570aefdc 100644
--- a/src/inc/twal.h
+++ b/src/inc/twal.h
@@ -44,6 +44,7 @@ typedef void* twalh;  // WAL HANDLE
 typedef int (*FWalWrite)(void *ahandle, void *pHead, int type);
 
 twalh   walOpen(const char *path, const SWalCfg *pCfg);
+int     walAlter(twalh pWal, const SWalCfg *pCfg);
 void    walClose(twalh);
 int     walRenew(twalh);
 int     walWrite(twalh, SWalHead *);
diff --git a/src/mnode/src/mnodeDb.c b/src/mnode/src/mnodeDb.c
index 54c049d242..8558350950 100644
--- a/src/mnode/src/mnodeDb.c
+++ b/src/mnode/src/mnodeDb.c
@@ -910,13 +910,13 @@ static SDbCfg mnodeGetAlterDbOption(SDbObj *pDb, SCMAlterDbMsg *pAlter) {
   }
 
   if (walLevel > 0 && walLevel != pDb->cfg.walLevel) {
-    mError("db:%s, can't alter walLevel option", pDb->name);
-    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    mDebug("db:%s, walLevel:%d change to %d", pDb->name, pDb->cfg.walLevel, walLevel);
+    newCfg.walLevel = walLevel;
   }
 
   if (fsyncPeriod >= 0 && fsyncPeriod != pDb->cfg.fsyncPeriod) {
-    mError("db:%s, can't alter fsyncPeriod option", pDb->name);
-    terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+    mDebug("db:%s, fsyncPeriod:%d change to %d", pDb->name, pDb->cfg.fsyncPeriod, fsyncPeriod);
+    newCfg.fsyncPeriod = fsyncPeriod;
   }
 
   if (replications > 0 && replications != pDb->cfg.replications) {
diff --git a/src/vnode/src/vnodeMain.c b/src/vnode/src/vnodeMain.c
index a4e88fb946..353dbbf373 100644
--- a/src/vnode/src/vnodeMain.c
+++ b/src/vnode/src/vnodeMain.c
@@ -186,6 +186,12 @@ int32_t vnodeAlter(void *param, SMDCreateVnodeMsg *pVnodeCfg) {
     return code; 
   }
 
+  code = walAlter(pVnode->wal, &pVnode->walCfg);
+  if (code != TSDB_CODE_SUCCESS) {
+    pVnode->status = TAOS_VN_STATUS_READY;
+    return code;
+  }
+
   code = syncReconfig(pVnode->sync, &pVnode->syncCfg);
   if (code != TSDB_CODE_SUCCESS) {
     pVnode->status = TAOS_VN_STATUS_READY;
diff --git a/src/wal/src/walMain.c b/src/wal/src/walMain.c
index bebad69f32..a90c1b171c 100644
--- a/src/wal/src/walMain.c
+++ b/src/wal/src/walMain.c
@@ -69,6 +69,13 @@ static void walModuleInitFunc() {
     wDebug("WAL module is initialized");
 }
 
+static inline bool walNeedFsyncTimer(SWal *pWal) {
+  if (pWal->fsyncPeriod > 0 && pWal->level == TAOS_WAL_FSYNC) {
+    return true;
+  }
+  return false;
+}
+
 void *walOpen(const char *path, const SWalCfg *pCfg) {
   SWal *pWal = calloc(sizeof(SWal), 1);
   if (pWal == NULL) {
@@ -95,7 +102,7 @@ void *walOpen(const char *path, const SWalCfg *pCfg) {
   tstrncpy(pWal->path, path, sizeof(pWal->path));
   pthread_mutex_init(&pWal->mutex, NULL);
 
-  if (pWal->fsyncPeriod > 0  && pWal->level == TAOS_WAL_FSYNC) {
+  if (walNeedFsyncTimer(pWal)) {
     pWal->timer = taosTmrStart(walProcessFsyncTimer, pWal->fsyncPeriod, pWal, walTmrCtrl);
     if (pWal->timer == NULL) {
       terrno = TAOS_SYSTEM_ERROR(errno);
@@ -127,6 +134,37 @@ void *walOpen(const char *path, const SWalCfg *pCfg) {
   return pWal;
 }
 
+int walAlter(twalh wal, const SWalCfg *pCfg) {
+  SWal *pWal = wal;
+  if (pWal == NULL) {
+    return TSDB_CODE_WAL_APP_ERROR;
+  }
+
+  if (pWal->level == pCfg->walLevel && pWal->fsyncPeriod == pCfg->fsyncPeriod) {
+    wDebug("wal:%s, old walLevel:%d fsync:%d, new walLevel:%d fsync:%d not change", pWal->name, pWal->level,
+           pWal->fsyncPeriod, pCfg->walLevel, pCfg->fsyncPeriod);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  wInfo("wal:%s, change old walLevel:%d fsync:%d, new walLevel:%d fsync:%d", pWal->name, pWal->level, pWal->fsyncPeriod,
+        pCfg->walLevel, pCfg->fsyncPeriod);
+
+  pthread_mutex_lock(&pWal->mutex);
+  pWal->level = pCfg->walLevel;
+  pWal->fsyncPeriod = pCfg->fsyncPeriod;
+  if (walNeedFsyncTimer(pWal)) {
+    wInfo("wal:%s, reset fsync timer, walLevel:%d fsyncPeriod:%d", pWal->name, pWal->level, pWal->fsyncPeriod);
+    taosTmrReset(walProcessFsyncTimer, pWal->fsyncPeriod, pWal, &pWal->timer,walTmrCtrl);
+  } else {
+    wInfo("wal:%s, stop fsync timer, walLevel:%d fsyncPeriod:%d", pWal->name, pWal->level, pWal->fsyncPeriod);
+    taosTmrStop(pWal->timer);
+    pWal->timer = NULL;
+  }
+  pthread_mutex_unlock(&pWal->mutex);
+
+  return TSDB_CODE_SUCCESS;
+}
+
 void walClose(void *handle) {
   if (handle == NULL) return;
   
@@ -484,6 +522,12 @@ static void walProcessFsyncTimer(void *param, void *tmrId) {
   if (fsync(pWal->fd) < 0) {
     wError("wal:%s, fsync failed(%s)", pWal->name, strerror(errno));
   }
-  
-  pWal->timer = taosTmrStart(walProcessFsyncTimer, pWal->fsyncPeriod, pWal, walTmrCtrl);
+
+  if (walNeedFsyncTimer(pWal)) {
+    pWal->timer = taosTmrStart(walProcessFsyncTimer, pWal->fsyncPeriod, pWal, walTmrCtrl);
+  } else {
+    wInfo("wal:%s, stop fsync timer for walLevel:%d fsyncPeriod:%d", pWal->name, pWal->level, pWal->fsyncPeriod);
+    taosTmrStop(pWal->timer);
+    pWal->timer = NULL;
+  }
 }
diff --git a/tests/script/general/db/alter_option.sim b/tests/script/general/db/alter_option.sim
index 49c75966ca..c8aa2480c5 100644
--- a/tests/script/general/db/alter_option.sim
+++ b/tests/script/general/db/alter_option.sim
@@ -218,7 +218,10 @@ if $data12_db != 1 then
   return -1
 endi
 
-sql_error alter database db wal 2
+sql alter database db wal 1
+sql alter database db wal 2
+sql alter database db wal 1
+sql alter database db wal 2
 sql_error alter database db wal 0
 sql_error alter database db wal 3
 sql_error alter database db wal 4
@@ -226,11 +229,13 @@ sql_error alter database db wal -1
 sql_error alter database db wal 1000
 
 print ============== step fsync
-sql_error alter database db fsync 2
-sql_error alter database db fsync 3
-sql_error alter database db fsync 4
+sql alter database db fsync 0
+sql alter database db fsync 1
+sql alter database db fsync 3600
+sql alter database db fsync 18000
+sql alter database db fsync 180000
+sql_error alter database db fsync 180001
 sql_error alter database db fsync -1
-sql_error alter database db fsync 1000
 
 print ============== step comp
 sql show databases

From b8d0e57ae97b811f9fa9cdff48c183a4c21b39de Mon Sep 17 00:00:00 2001
From: liuyq-617 <yqliu@taosdata.com>
Date: Tue, 22 Sep 2020 17:22:23 +0800
Subject: [PATCH 26/35] [TD-1386] <test> add test case for retention

---
 tests/pytest/insert/retentionpolicy.py | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/tests/pytest/insert/retentionpolicy.py b/tests/pytest/insert/retentionpolicy.py
index bd294a24f3..c50de31cc4 100644
--- a/tests/pytest/insert/retentionpolicy.py
+++ b/tests/pytest/insert/retentionpolicy.py
@@ -67,8 +67,12 @@ class TDTestRetetion:
         cmd = 'insert into test values(now,11);'
         tdLog.info(cmd)
         tdSql.execute(cmd)
-        tdSql.query('select * from test')
-        tdSql.checkRows(5)
+        queryRows=tdSql.query('select * from test')
+        if queryRows==4:
+            tdSql.checkRows(4)
+            return 0
+        else:
+            tdSql.checkRows(5)
 
         tdLog.info("=============== step3")
         tdDnodes.stop(1)
@@ -77,7 +81,7 @@ class TDTestRetetion:
         cmd = 'insert into test values(now-1d,11);'
         tdLog.info(cmd)
         tdSql.execute(cmd)
-        tdSql.query('select * from test')
+        queryRows=tdSql.query('select * from test')
         tdSql.checkRows(6)
         tdLog.info("=============== step4")
         tdDnodes.stop(1)

From bec674296e65e642b55933f24eece27b4db86978 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Tue, 22 Sep 2020 18:01:11 +0800
Subject: [PATCH 27/35] TD-1368

---
 src/vnode/src/vnodeMain.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/vnode/src/vnodeMain.c b/src/vnode/src/vnodeMain.c
index 353dbbf373..d89c383d6a 100644
--- a/src/vnode/src/vnodeMain.c
+++ b/src/vnode/src/vnodeMain.c
@@ -396,6 +396,7 @@ void vnodeRelease(void *pVnodeRaw) {
     if (0 == tsEnableVnodeBak) {
       vInfo("vgId:%d, vnode backup not enabled", pVnode->vgId);
     } else {
+      taosRemoveDir(newDir);
       taosRename(rootDir, newDir);
     }
 

From a9850f47d0f96cde5837927ae851e463d0e2adfa Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Wed, 23 Sep 2020 10:55:44 +0800
Subject: [PATCH 28/35] TD-1425

---
 src/mnode/src/mnodeVgroup.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/mnode/src/mnodeVgroup.c b/src/mnode/src/mnodeVgroup.c
index aa6631ff83..9345bdae2c 100644
--- a/src/mnode/src/mnodeVgroup.c
+++ b/src/mnode/src/mnodeVgroup.c
@@ -660,13 +660,13 @@ static int32_t mnodeGetVgroupMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *p
   for (int32_t i = 0; i < pShow->maxReplica; ++i) {
     pShow->bytes[cols] = 2;
     pSchema[cols].type = TSDB_DATA_TYPE_SMALLINT;
-    strcpy(pSchema[cols].name, "dnode");
+    snprintf(pSchema[cols].name, TSDB_COL_NAME_LEN, "dnode%d", i + 1);
     pSchema[cols].bytes = htons(pShow->bytes[cols]);
     cols++;
 
     pShow->bytes[cols] = 9 + VARSTR_HEADER_SIZE;
     pSchema[cols].type = TSDB_DATA_TYPE_BINARY;
-    strcpy(pSchema[cols].name, "vstatus");
+    snprintf(pSchema[cols].name, TSDB_COL_NAME_LEN, "v%dstatus", i + 1);
     pSchema[cols].bytes = htons(pShow->bytes[cols]);
     cols++;
   }

From c346e0b0fc626b8180148abf01216f87b8ad6d85 Mon Sep 17 00:00:00 2001
From: Bomin Zhang <bmzhang@taosdata.com>
Date: Wed, 23 Sep 2020 11:09:41 +0800
Subject: [PATCH 29/35] fix TD-1469

---
 src/client/inc/tscUtil.h        |  1 +
 src/client/src/tscParseInsert.c |  3 +--
 src/client/src/tscUtil.c        | 46 +++++++++++++++++++++++++++++++++
 3 files changed, 48 insertions(+), 2 deletions(-)

diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index c4fba06426..79a792ab65 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -191,6 +191,7 @@ SColumn* tscColumnListInsert(SArray* pColList, SColumnIndex* colIndex);
 SArray* tscColumnListClone(const SArray* src, int16_t tableIndex);
 void tscColumnListDestroy(SArray* pColList);
 
+void tscDequoteAndTrimToken(SStrToken* pToken);
 int32_t tscValidateName(SStrToken* pToken);
 
 void tscIncStreamExecutionCount(void* pStream);
diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c
index 327aac22d1..6fd97c09e9 100644
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -1192,8 +1192,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
         str += index;
 
         if (TK_STRING == sToken.type) {
-          strdequote(sToken.z);
-          sToken.n = (uint32_t)strtrim(sToken.z);
+          tscDequoteAndTrimToken(&sToken);
         }
 
         if (sToken.type == TK_RP) {
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 38fb63f18e..de4a52aed4 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -1265,6 +1265,51 @@ static int32_t validateQuoteToken(SStrToken* pToken) {
   return TSDB_CODE_SUCCESS;
 }
 
+void tscDequoteAndTrimToken(SStrToken* pToken) {
+  assert(pToken->type == TK_STRING);
+
+  uint32_t first = 0, last = pToken->n;
+
+  // trim leading spaces
+  while (first < last) {
+    char c = pToken->z[first];
+    if (c != ' ' && c != '\t') {
+      break;
+    }
+    first++;
+  }
+
+  // trim ending spaces
+  while (first < last) {
+    char c = pToken->z[last - 1];
+    if (c != ' ' && c != '\t') {
+      break;
+    }
+    last--;
+  }
+
+  // there are still at least two characters
+  if (first < last - 1) {
+    char c = pToken->z[first];
+    // dequote
+    if ((c == '\'' || c == '"') && c == pToken->z[last - 1]) {
+      first++;
+      last--;
+    }
+  }
+
+  // left shift the string and pad spaces
+  for (uint32_t i = 0; i + first < last; i++) {
+    pToken->z[i] = pToken->z[first + i];
+  }
+  for (uint32_t i = last - first; i < pToken->n; i++) {
+    pToken->z[i] = ' ';
+  }
+
+  // adjust token length
+  pToken->n = last - first;
+}
+
 int32_t tscValidateName(SStrToken* pToken) {
   if (pToken->type != TK_STRING && pToken->type != TK_ID) {
     return TSDB_CODE_TSC_INVALID_SQL;
@@ -1750,6 +1795,7 @@ SSqlObj* createSimpleSubObj(SSqlObj* pSql, void (*fp)(), void* param, int32_t cm
   SSqlCmd* pCmd = &pNew->cmd;
   pCmd->command = cmd;
   pCmd->parseFinished = 1;
+  pCmd->autoCreated = pSql->cmd.autoCreated;
 
   if (tscAddSubqueryInfo(pCmd) != TSDB_CODE_SUCCESS) {
     tscFreeSqlObj(pNew);

From c83f211c250c5b6b39f8b2a979abc23295df22fd Mon Sep 17 00:00:00 2001
From: zyyang <zyyang@taosdata.com>
Date: Wed, 23 Sep 2020 11:11:28 +0800
Subject: [PATCH 30/35] [TD-1533]<fix>: fix the parse jdbc url error

---
 .../main/java/com/taosdata/example/JDBCConnectorChecker.java    | 2 --
 1 file changed, 2 deletions(-)

diff --git a/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JDBCConnectorChecker.java b/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JDBCConnectorChecker.java
index 1e801bc658..74e586d7fd 100644
--- a/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JDBCConnectorChecker.java
+++ b/tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JDBCConnectorChecker.java
@@ -11,7 +11,6 @@ public class JDBCConnectorChecker {
     private static String tbName = "weather";
     private Connection connection;
 
-
     /**
      * get connection
      **/
@@ -170,5 +169,4 @@ public class JDBCConnectorChecker {
         checker.close();
     }
 
-
 }

From 5e7c1236e4429fc74734744e1324db795b3f3cf5 Mon Sep 17 00:00:00 2001
From: zyyang <zyyang@taosdata.com>
Date: Wed, 23 Sep 2020 11:15:25 +0800
Subject: [PATCH 31/35] [TD-1533]<fix>: fix the jdbc url parse error

---
 src/connector/jdbc/deploy-pom.xml                             | 3 +--
 .../jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java      | 4 ++--
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/connector/jdbc/deploy-pom.xml b/src/connector/jdbc/deploy-pom.xml
index 766a58f9ba..3f6ebeff03 100755
--- a/src/connector/jdbc/deploy-pom.xml
+++ b/src/connector/jdbc/deploy-pom.xml
@@ -5,10 +5,9 @@
 
   <groupId>com.taosdata.jdbc</groupId>
   <artifactId>taos-jdbcdriver</artifactId>
-  <version>2.0.0-SNAPSHOT</version>
+  <version>2.0.6</version>
   <packaging>jar</packaging>
 
-
   <name>JDBCDriver</name>
   <url>https://github.com/taosdata/TDengine/tree/master/src/connector/jdbc</url>
   <description>TDengine JDBC Driver</description>
diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java
index bc649a31e1..13be9d538d 100755
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java
@@ -291,8 +291,8 @@ public class TSDBDriver implements java.sql.Driver {
             return null;
         }
 
-        String lowerUrl = url.toLowerCase();
-        if (!lowerUrl.startsWith(URL_PREFIX) && !lowerUrl.startsWith(URL_PREFIX1)) {
+//        String lowerUrl = url.toLowerCase();
+        if (!url.startsWith(URL_PREFIX) && !url.startsWith(URL_PREFIX1)) {
             return null;
         }
 

From 0bf112a2589601eee102ea3937cbdf656147226f Mon Sep 17 00:00:00 2001
From: liuyq-617 <yqliu@taosdata.com>
Date: Wed, 23 Sep 2020 11:42:34 +0800
Subject: [PATCH 32/35] [TD-1532] fix taosdemo case bug

---
 tests/pytest/tools/taosdemo.py | 24 ++++++++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/tests/pytest/tools/taosdemo.py b/tests/pytest/tools/taosdemo.py
index 54d33c90f3..5bf8ebaf03 100644
--- a/tests/pytest/tools/taosdemo.py
+++ b/tests/pytest/tools/taosdemo.py
@@ -16,6 +16,7 @@ import os
 from util.log import *
 from util.cases import *
 from util.sql import *
+from util.dnodes import *
 
 
 class TDTestCase:
@@ -25,11 +26,30 @@ class TDTestCase:
         
         self.numberOfTables = 10000
         self.numberOfRecords = 100
+    def getBuildPath(self):
+        selfPath = os.path.dirname(os.path.realpath(__file__))
 
+        if ("community" in selfPath):
+            projPath = selfPath[:selfPath.find("community")]
+        else:
+            projPath = selfPath[:selfPath.find("tests")]
+
+        for root, dirs, files in os.walk(projPath):
+            if ("taosd" in files):
+                rootRealPath = os.path.dirname(os.path.realpath(root))
+                if ("packaging" not in rootRealPath):
+                    buildPath = root[:len(root)-len("/build/bin")]
+                    break
+        return buildPath
     def run(self):
         tdSql.prepare()
-        
-        os.system("yes | taosdemo -t %d -n %d" % (self.numberOfTables, self.numberOfRecords))
+        buildPath = self.getBuildPath()
+        if (buildPath == ""):
+            tdLog.exit("taosd not found!")
+        else:
+            tdLog.info("taosd found in %s" % buildPath)
+        binPath = buildPath+ "/build/bin/"
+        os.system("yes | %staosdemo -t %d -n %d" % (binPath,self.numberOfTables, self.numberOfRecords))
 
         tdSql.execute("use test")
         tdSql.query("select count(*) from meters")

From 920343a0594b4531e07f41c706128a490a4ae991 Mon Sep 17 00:00:00 2001
From: Hui Li <huili@taosdata.com>
Date: Wed, 23 Sep 2020 15:21:31 +0800
Subject: [PATCH 33/35] [TD-1502]

---
 tests/gotest/batchtest.sh       |   5 +
 tests/gotest/case001/case001.go | 308 ++++++++++++++++++++++++++++++++
 tests/gotest/case001/case001.sh |  70 ++++++++
 tests/gotest/test.sh            |  42 +++++
 4 files changed, 425 insertions(+)
 create mode 100644 tests/gotest/batchtest.sh
 create mode 100644 tests/gotest/case001/case001.go
 create mode 100644 tests/gotest/case001/case001.sh
 create mode 100644 tests/gotest/test.sh

diff --git a/tests/gotest/batchtest.sh b/tests/gotest/batchtest.sh
new file mode 100644
index 0000000000..a027dd0d7c
--- /dev/null
+++ b/tests/gotest/batchtest.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+bash ./case001/case001.sh
+#bash ./case002/case002.sh
+#bash ./case003/case003.sh
diff --git a/tests/gotest/case001/case001.go b/tests/gotest/case001/case001.go
new file mode 100644
index 0000000000..1d5ede6d21
--- /dev/null
+++ b/tests/gotest/case001/case001.go
@@ -0,0 +1,308 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package main
+
+import (
+	"database/sql"
+	"fmt"
+	_ "github.com/taosdata/driver-go/taosSql"
+	"log"
+	"time"
+)
+
+func main() {
+	taosDriverName := "taosSql"
+	demodb := "demodb"
+	demot := "demot"
+
+	fmt.Printf("\n======== start demo test ========\n")
+	// open connect to taos server
+	db, err := sql.Open(taosDriverName, "root:taosdata@/tcp(192.168.1.217:7100)/")
+	if err != nil {
+		log.Fatalf("Open database error: %s\n", err)
+	}
+	defer db.Close()
+
+	drop_database(db, demodb)
+	create_database(db, demodb)
+	use_database(db, demodb)
+	create_table(db, demot)
+	insert_data(db, demot)
+	select_data(db, demot)
+
+	fmt.Printf("\n======== start stmt mode test ========\n")
+
+	demodbStmt := "demodbStmt"
+	demotStmt := "demotStmt"
+	drop_database_stmt(db, demodbStmt)
+	create_database_stmt(db, demodbStmt)
+	use_database_stmt(db, demodbStmt)
+	create_table_stmt(db, demotStmt)
+	insert_data_stmt(db, demotStmt)
+	select_data_stmt(db, demotStmt)
+
+	fmt.Printf("\n======== end demo test ========\n")
+}
+
+func drop_database(db *sql.DB, demodb string) {
+	st := time.Now().Nanosecond()
+	res, err := db.Exec("drop database if exists " + demodb)
+	checkErr(err, "drop database if exists "+demodb)
+
+	affectd, err := res.RowsAffected()
+	checkErr(err, "drop db, res.RowsAffected")
+
+	et := time.Now().Nanosecond()
+
+	fmt.Printf("drop database result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+
+	//sleep 50毫秒
+	time.Sleep(time.Duration(50)* time.Millisecond)
+}
+
+func create_database(db *sql.DB, demodb string) {
+	st := time.Now().Nanosecond()
+	// create database
+	res, err := db.Exec("create database " + demodb)
+	checkErr(err, "create db, db.Exec")
+
+	affectd, err := res.RowsAffected()
+	checkErr(err, "create db, res.RowsAffected")
+
+	et := time.Now().Nanosecond()
+
+	fmt.Printf("create database result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+
+	return
+}
+
+func use_database(db *sql.DB, demodb string) {
+	st := time.Now().Nanosecond()
+	// use database
+	res, err := db.Exec("use " + demodb) // notes: must no quote to db name
+	checkErr(err, "use db db.Exec")
+
+	affectd, err := res.RowsAffected()
+	checkErr(err, "use db, res.RowsAffected")
+
+	et := time.Now().Nanosecond()
+
+	fmt.Printf("use database result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func create_table(db *sql.DB, demot string) {
+	st := time.Now().Nanosecond()
+	// create table
+	res, err := db.Exec("create table " + demot + " (ts timestamp, id int, name binary(8), len tinyint, flag bool, notes binary(8), fv float, dv double)")
+	checkErr(err, "create table db.Exec")
+
+	affectd, err := res.RowsAffected()
+	checkErr(err, "create table res.RowsAffected")
+
+	et := time.Now().Nanosecond()
+	fmt.Printf("create table result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func insert_data(db *sql.DB, demot string) {
+	st := time.Now().Nanosecond()
+	// insert data
+	res, err := db.Exec("insert into " + demot +
+		" values (now, 100, 'beijing', 10,  true, 'one', 123.456, 123.456)" +
+		" (now+1s, 101, 'shanghai', 11, true, 'two', 789.123, 789.123)" +
+		" (now+2s, 102, 'shenzhen', 12,  false, 'three', 456.789, 456.789)")
+
+	checkErr(err, "insert data, db.Exec")
+
+	affectd, err := res.RowsAffected()
+	checkErr(err, "insert data res.RowsAffected")
+
+	et := time.Now().Nanosecond()
+	fmt.Printf("insert data result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func select_data(db *sql.DB, demot string) {
+	st := time.Now().Nanosecond()
+
+	rows, err := db.Query("select * from ? ", demot) // go text mode
+	checkErr(err, "select db.Query")
+
+	fmt.Printf("%10s%s%8s %5s %9s%s %s %8s%s %7s%s %8s%s %4s%s %5s%s\n", " ", "ts", " ", "id", " ", "name", " ", "len", " ", "flag", " ", "notes", " ", "fv", " ", " ", "dv")
+	var affectd int
+
+	//decoder := mahonia.NewDecoder("gbk") // 把原来ANSI格式的文本文件里的字符，用gbk进行解码。
+
+	for rows.Next() {
+		var ts string
+		var name string
+		var id int
+		var len int8
+		var flag bool
+		var notes string
+		var fv float32
+		var dv float64
+
+		err = rows.Scan(&ts, &id, &name, &len, &flag, &notes, &fv, &dv)
+		checkErr(err, "select rows.Scan")
+
+		fmt.Printf("%s|\t", ts)
+		fmt.Printf("%d|\t", id)
+		fmt.Printf("%10s|\t", name)
+		fmt.Printf("%d|\t", len)
+		fmt.Printf("%t|\t", flag)
+		fmt.Printf("%s|\t", notes)
+		fmt.Printf("%06.3f|\t", fv)
+		fmt.Printf("%09.6f|\n\n", dv)
+
+		affectd++
+	}
+
+	et := time.Now().Nanosecond()
+	fmt.Printf("select data result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+	//fmt.Printf("insert data result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1E9)
+}
+
+func drop_database_stmt(db *sql.DB, demodb string) {
+	st := time.Now().Nanosecond()
+	// drop test db
+	res, err := db.Exec("drop database if exists " + demodb)
+	checkErr(err, "drop database "+demodb)
+
+	affectd, err := res.RowsAffected()
+	checkErr(err, "drop db, res.RowsAffected")
+
+	et := time.Now().Nanosecond()
+	fmt.Printf("drop database result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func create_database_stmt(db *sql.DB, demodb string) {
+	st := time.Now().Nanosecond()
+	// create database
+	//var stmt interface{}
+	stmt, err := db.Prepare("create database ?")
+	checkErr(err, "create db, db.Prepare")
+
+	//var res driver.Result
+	res, err := stmt.Exec(demodb)
+	checkErr(err, "create db, stmt.Exec")
+
+	//fmt.Printf("Query OK, %d row(s) affected()", res.RowsAffected())
+	affectd, err := res.RowsAffected()
+	checkErr(err, "create db, res.RowsAffected")
+
+	et := time.Now().Nanosecond()
+	fmt.Printf("create database result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func use_database_stmt(db *sql.DB, demodb string) {
+	st := time.Now().Nanosecond()
+	// create database
+	//var stmt interface{}
+	stmt, err := db.Prepare("use " + demodb)
+	checkErr(err, "use db, db.Prepare")
+
+	res, err := stmt.Exec()
+	checkErr(err, "use db, stmt.Exec")
+
+	affectd, err := res.RowsAffected()
+	checkErr(err, "use db, res.RowsAffected")
+
+	et := time.Now().Nanosecond()
+	fmt.Printf("use database result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func create_table_stmt(db *sql.DB, demot string) {
+	st := time.Now().Nanosecond()
+	// create table
+	// (ts timestamp, id int, name binary(8), len tinyint, flag bool, notes binary(8), fv float, dv double)
+	stmt, err := db.Prepare("create table ? (? timestamp, ? int, ? binary(10), ? tinyint, ? bool, ? binary(8), ? float, ? double)")
+	checkErr(err, "create table db.Prepare")
+
+	res, err := stmt.Exec(demot, "ts", "id", "name", "len", "flag", "notes", "fv", "dv")
+	checkErr(err, "create table stmt.Exec")
+
+	affectd, err := res.RowsAffected()
+	checkErr(err, "create table res.RowsAffected")
+
+	et := time.Now().Nanosecond()
+	fmt.Printf("create table result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func insert_data_stmt(db *sql.DB, demot string) {
+	st := time.Now().Nanosecond()
+	// insert data into table
+	stmt, err := db.Prepare("insert into ? values(?, ?, ?, ?, ?, ?, ?, ?) (?, ?, ?, ?, ?, ?, ?, ?) (?, ?, ?, ?, ?, ?, ?, ?)")
+	checkErr(err, "insert db.Prepare")
+
+	res, err := stmt.Exec(demot, "now", 1000, "'haidian'", 6, true, "'AI world'", 6987.654, 321.987,
+		"now+1s", 1001, "'changyang'", 7, false, "'DeepMode'", 12356.456, 128634.456,
+		"now+2s", 1002, "'chuangping'", 8, true, "'database'", 3879.456, 65433478.456)
+	checkErr(err, "insert data, stmt.Exec")
+
+	affectd, err := res.RowsAffected()
+	checkErr(err, "res.RowsAffected")
+
+	et := time.Now().Nanosecond()
+	fmt.Printf("insert data result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func select_data_stmt(db *sql.DB, demot string) {
+	st := time.Now().Nanosecond()
+
+	stmt, err := db.Prepare("select ?, ?, ?, ?, ?, ?, ?, ? from ?") // go binary mode
+	checkErr(err, "db.Prepare")
+
+	rows, err := stmt.Query("ts", "id", "name", "len", "flag", "notes", "fv", "dv", demot)
+	checkErr(err, "stmt.Query")
+
+	fmt.Printf("%10s%s%8s %5s %8s%s %s %10s%s %7s%s %8s%s %11s%s %14s%s\n", " ", "ts", " ", "id", " ", "name", " ", "len", " ", "flag", " ", "notes", " ", "fv", " ", " ", "dv")
+	var affectd int
+	for rows.Next() {
+		var ts string
+		var name string
+		var id int
+		var len int8
+		var flag bool
+		var notes string
+		var fv float32
+		var dv float64
+
+		err = rows.Scan(&ts, &id, &name, &len, &flag, &notes, &fv, &dv)
+		//fmt.Println("start scan fields from row.rs, &fv:", &fv)
+		//err = rows.Scan(&fv)
+		checkErr(err, "rows.Scan")
+
+		fmt.Printf("%s|\t", ts)
+		fmt.Printf("%d|\t", id)
+		fmt.Printf("%10s|\t", name)
+		fmt.Printf("%d|\t", len)
+		fmt.Printf("%t|\t", flag)
+		fmt.Printf("%s|\t", notes)
+		fmt.Printf("%06.3f|\t", fv)
+		fmt.Printf("%09.6f|\n", dv)
+
+		affectd++
+
+	}
+
+	et := time.Now().Nanosecond()
+	fmt.Printf("select data result:\n %d row(s) affectd (%6.6fs)\n\n", affectd, (float32(et-st))/1e9)
+}
+
+func checkErr(err error, prompt string) {
+	if err != nil {
+		fmt.Printf("%s\n", prompt)
+		panic(err)
+	}
+}
diff --git a/tests/gotest/case001/case001.sh b/tests/gotest/case001/case001.sh
new file mode 100644
index 0000000000..5a9034c4d1
--- /dev/null
+++ b/tests/gotest/case001/case001.sh
@@ -0,0 +1,70 @@
+#!/bin/bash
+
+##################################################
+# 
+# Do go test 
+#
+##################################################
+
+set +e
+#set -x
+
+script_dir="$(dirname $(readlink -f $0))"
+#echo "pwd: $script_dir, para0: $0"
+
+execName=$0
+execName=`echo ${execName##*/}`
+goName=`echo ${execName%.*}`
+
+###### step 1: start one taosd
+scriptDir=$script_dir/../../script/sh
+bash $scriptDir/stop_dnodes.sh
+bash $scriptDir/deploy.sh -n dnode1 -i 1
+bash $scriptDir/cfg.sh -n dnode1 -c walLevel -v 0
+bash $scriptDir/exec.sh -n dnode1 -s start
+
+###### step 2: set config item
+TAOS_CFG=/etc/taos/taos.cfg
+HOSTNAME=`hostname -f`
+
+if [ ! -f ${TAOS_CFG} ]; then
+  touch -f $TAOS_CFG
+fi 
+
+echo " "                                           > $TAOS_CFG
+echo "firstEp            ${HOSTNAME}:7100"        >> $TAOS_CFG
+echo "secondEp           ${HOSTNAME}:7200"        >> $TAOS_CFG
+echo "serverPort         7100"                    >> $TAOS_CFG
+#echo "dataDir            $DATA_DIR"              >> $TAOS_CFG
+#echo "logDir             $LOG_DIR"               >> $TAOS_CFG
+#echo "scriptDir          ${CODE_DIR}/../script"  >> $TAOS_CFG
+echo "numOfLogLines      100000000"               >> $TAOS_CFG
+echo "dDebugFlag         135"                     >> $TAOS_CFG
+echo "mDebugFlag         135"                     >> $TAOS_CFG
+echo "sdbDebugFlag       135"                     >> $TAOS_CFG
+echo "rpcDebugFlag       135"                     >> $TAOS_CFG
+echo "tmrDebugFlag       131"                     >> $TAOS_CFG
+echo "cDebugFlag         135"                     >> $TAOS_CFG
+echo "httpDebugFlag      135"                     >> $TAOS_CFG
+echo "monitorDebugFlag   135"                     >> $TAOS_CFG
+echo "udebugFlag         135"                     >> $TAOS_CFG
+echo "tablemetakeeptimer 5"                       >> $TAOS_CFG
+echo "wal                0"                       >> $TAOS_CFG
+echo "asyncLog           0"                       >> $TAOS_CFG
+echo "locale             en_US.UTF-8"             >> $TAOS_CFG
+echo "enableCoreFile     1"                       >> $TAOS_CFG
+echo " "                                          >> $TAOS_CFG  
+
+ulimit -n 600000
+ulimit -c unlimited
+#
+##sudo sysctl -w kernel.core_pattern=$TOP_DIR/core.%p.%e
+#
+
+###### step 3: start build
+cd $script_dir
+rm -f go.*
+go mod init $goName
+go build 
+sleep  1s
+sudo ./$goName
diff --git a/tests/gotest/test.sh b/tests/gotest/test.sh
new file mode 100644
index 0000000000..fe80d44295
--- /dev/null
+++ b/tests/gotest/test.sh
@@ -0,0 +1,42 @@
+#!/bin/bash
+
+##################################################
+# 
+# Do go test 
+#
+##################################################
+
+set +e
+#set -x
+
+FILE_NAME=
+RELEASE=0
+while getopts "f:" arg
+do
+  case $arg in
+    f)
+      FILE_NAME=$OPTARG
+      echo "input file: $FILE_NAME"
+      ;;
+    ?)
+      echo "unknow argument"
+      ;;
+  esac
+done
+
+# start one taosd
+bash ../script/sh/stop_dnodes.sh
+bash ../script/sh/deploy.sh -n dnode1 -i 1
+bash ../script/sh/cfg.sh -n dnode1 -c walLevel -v 0
+bash ../script/sh/exec.sh -n dnode1 -s start
+
+# start build test go file
+caseDir=`echo ${FILE_NAME%/*}`
+echo "caseDir: $caseDir"
+cd $caseDir
+rm go.*
+go mod init $caseDir
+go build 
+sleep 1s
+./$caseDir
+

From 6989ed36963c039f5315ccd6b76173943be52734 Mon Sep 17 00:00:00 2001
From: liuyq-617 <yqliu@taosdata.com>
Date: Wed, 23 Sep 2020 17:24:34 +0800
Subject: [PATCH 34/35] remove test case stability

---
 tests/pytest/fulltest.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/pytest/fulltest.sh b/tests/pytest/fulltest.sh
index e219d76b97..597102a0f0 100755
--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
@@ -197,5 +197,5 @@ python3 test.py -f tools/taosdemo.py
 
 # subscribe
 python3 test.py -f subscribe/singlemeter.py
-python3 test.py -f subscribe/stability.py
+#python3 test.py -f subscribe/stability.py
 python3 test.py -f subscribe/supertable.py
\ No newline at end of file

From b2eddc776506fcca95a85611ce403365aac144b0 Mon Sep 17 00:00:00 2001
From: Bomin Zhang <bmzhang@taosdata.com>
Date: Thu, 24 Sep 2020 09:28:29 +0800
Subject: [PATCH 35/35] fix td-1558: fd(eventpoll) leaks

---
 src/client/src/tscUtil.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 23f412ddd1..77088f5b7c 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -1912,7 +1912,6 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void
 
   pNew->pTscObj = pSql->pTscObj;
   pNew->signature = pNew;
-  T_REF_INC(pNew->pTscObj);
 
   pNew->sqlstr = strdup(pSql->sqlstr);
   if (pNew->sqlstr == NULL) {