Merge branch 'develop' into xiaoping/add_test_case

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)

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);

src/client/inc/tsclient.h

@@ -99,6 +99,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;

src/client/src/tscLocal.c

@@ -23,7 +23,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) {
@@ -272,14 +295,511 @@ 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 = (int16_t)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);
+
+  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);
+    free(query);
+    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) {
+      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s %s(%d),", pSchema[i].name,tDataTypeDesc[pSchema[i].type].aName,pSchema->bytes);
+    } else {
+      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", ")");
+
+  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) {
+      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result),"%s %s(%d),", pSchema[i].name,tDataTypeDesc[pSchema[i].type].aName,pSchema->bytes);
+    } else {
+      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s %s,", pSchema[i].name, tDataTypeDesc[type].aName); 
+    }
+  }
+  snprintf(result + strlen(result) - 1, TSDB_MAX_BINARY_LEN - strlen(result), "%s %s", ")", "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) {
+      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - strlen(result), "%s %s(%d),", pSchema[i].name,tDataTypeDesc[pSchema[i].type].aName,pSchema->bytes);
+    } else {
+      snprintf(result + strlen(result), TSDB_MAX_BINARY_LEN - 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 = (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);
+  } 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) {
+    code = tscSCreateBuildResult(pSql, SCREATE_BUILD_TABLE, tableName, result);
+  } 
+  free(result);
+  return code;
+}
+
+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;
@@ -287,7 +807,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);
 
@@ -297,15 +817,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;
@@ -316,7 +836,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);
 
@@ -326,49 +846,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;
@@ -379,9 +903,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));
@@ -393,23 +917,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);
 }
 
@@ -428,6 +952,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(tscMetaCache);
     pRes->code = TSDB_CODE_SUCCESS;
@@ -447,12 +975,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;
 }

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) {

src/client/src/tscSQLParser.c

@@ -368,7 +368,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";
@@ -5722,7 +5755,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);
   }
 

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);
   

src/client/src/tscServer.c

@@ -2093,6 +2093,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;
@@ -2379,6 +2382,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;

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);
   }
 
@@ -476,6 +477,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 ||

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;
@@ -572,6 +567,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 +575,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);
@@ -619,10 +616,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);
   }
 }

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;
@@ -278,7 +279,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;
@@ -1383,7 +1384,7 @@ static void doCleanupSubqueries(SSqlObj *pSql, int32_t numOfSubs, SSubqueryState
     taosTFree(pSupport->localBuffer);
     taosTFree(pSupport);
     
-    tscFreeSqlObj(pSub);
+    taos_free_result(pSub);
   }
   
   free(pState);

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;
@@ -1743,13 +1788,12 @@ 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;
   pCmd->command = cmd;
   pCmd->parseFinished = 1;
+  pCmd->autoCreated = pSql->cmd.autoCreated;
 
   if (tscAddSubqueryInfo(pCmd) != TSDB_CODE_SUCCESS) {
     tscFreeSqlObj(pNew);
@@ -1777,7 +1821,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;
@@ -1869,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) {

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

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;
 

go @ 06ec30a0

-Subproject commit 8c58c512b6acda8bcdfa48fdc7140227b5221766
+Subproject commit 06ec30a0f1762e8169bf6b9045c82bcaa52bcdf0

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>

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;
         }
 

src/inc/taosmsg.h

@@ -673,6 +673,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;

src/inc/ttokendef.h

@@ -16,6 +16,7 @@
 #ifndef TDENGINE_TTOKENDEF_H
 #define TDENGINE_TTOKENDEF_H
 
+
 #define TK_ID                               1
 #define TK_BOOL                             2
 #define TK_TINYINT                          3
@@ -75,24 +76,24 @@
 #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_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
@@ -222,7 +223,6 @@
 #define TK_INTO                           204
 #define TK_VALUES                         205
 
-
 #define TK_SPACE                          300
 #define TK_COMMENT                        301
 #define TK_ILLEGAL                        302

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 *);

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) {

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;

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;
@@ -2090,6 +2093,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);

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++;
   }

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 };

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;
     }
   }
 

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;
 }
 

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);
 }

src/query/src/sql.c

@@ -23,7 +23,6 @@
 ** input grammar file:
 */
 #include <stdio.h>
-#include <assert.h>
 /************ Begin %include sections from the grammar ************************/
 
 #include <stdio.h>
@@ -77,10 +76,8 @@
 **                       zero the stack is dynamically sized using realloc()
 **    ParseARG_SDECL     A static variable declaration for the %extra_argument
 **    ParseARG_PDECL     A parameter declaration for the %extra_argument
-**    ParseARG_PARAM     Code to pass %extra_argument as a subroutine parameter
 **    ParseARG_STORE     Code to store %extra_argument into yypParser
 **    ParseARG_FETCH     Code to extract %extra_argument from yypParser
-**    ParseCTX_*         As ParseARG_ except for %extra_context
 **    YYERRORSYMBOL      is the code number of the error symbol.  If not
 **                       defined, then do no error processing.
 **    YYNSTATE           the combined number of states.
@@ -100,56 +97,48 @@
 #endif
 /************* Begin control #defines *****************************************/
 #define YYCODETYPE unsigned short int
-#define YYNOCODE 270
+#define YYNOCODE 272
 #define YYACTIONTYPE unsigned short int
 #define ParseTOKENTYPE SStrToken
 typedef union {
   int yyinit;
   ParseTOKENTYPE yy0;
-  int yy112;
-  SCreateDBInfo yy118;
-  tVariantList* yy156;
-  tSQLExprList* yy158;
-  tSQLExpr* yy190;
-  SSubclauseInfo* yy333;
-  SIntervalVal yy340;
-  TAOS_FIELD yy343;
-  int64_t yy369;
-  SCreateTableSQL* yy398;
-  SLimitVal yy414;
-  SQuerySQL* yy444;
-  SCreateAcctSQL yy479;
-  tVariant yy506;
-  tFieldList* yy511;
+  SSubclauseInfo* yy25;
+  tSQLExpr* yy66;
+  SCreateAcctSQL yy73;
+  int yy82;
+  SQuerySQL* yy150;
+  SCreateDBInfo yy158;
+  TAOS_FIELD yy181;
+  SLimitVal yy188;
+  tSQLExprList* yy224;
+  int64_t yy271;
+  tVariant yy312;
+  SIntervalVal yy314;
+  SCreateTableSQL* yy374;
+  tFieldList* yy449;
+  tVariantList* yy494;
 } YYMINORTYPE;
 #ifndef YYSTACKDEPTH
 #define YYSTACKDEPTH 100
 #endif
 #define ParseARG_SDECL SSqlInfo* pInfo;
 #define ParseARG_PDECL ,SSqlInfo* pInfo
-#define ParseARG_PARAM ,pInfo
-#define ParseARG_FETCH SSqlInfo* pInfo=yypParser->pInfo;
-#define ParseARG_STORE yypParser->pInfo=pInfo;
-#define ParseCTX_SDECL
-#define ParseCTX_PDECL
-#define ParseCTX_PARAM
-#define ParseCTX_FETCH
-#define ParseCTX_STORE
+#define ParseARG_FETCH SSqlInfo* pInfo = yypParser->pInfo
+#define ParseARG_STORE yypParser->pInfo = pInfo
 #define YYFALLBACK 1
-#define YYNSTATE             248
-#define YYNRULE              228
-#define YYNRULE_WITH_ACTION  228
+#define YYNSTATE             252
+#define YYNRULE              230
 #define YYNTOKEN             206
-#define YY_MAX_SHIFT         247
-#define YY_MIN_SHIFTREDUCE   410
-#define YY_MAX_SHIFTREDUCE   637
-#define YY_ERROR_ACTION      638
-#define YY_ACCEPT_ACTION     639
-#define YY_NO_ACTION         640
-#define YY_MIN_REDUCE        641
-#define YY_MAX_REDUCE        868
+#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 YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))
 
 /* Define the yytestcase() macro to be a no-op if is not already defined
 ** otherwise.
@@ -214,219 +203,223 @@ typedef union {
 **  yy_default[]       Default action for each state.
 **
 *********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (560)
+#define YY_ACTTAB_COUNT (566)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */   741,  451,   11,  739,  740,  639,  247,  451,  742,  452,
- /*    10 */   744,  745,  743,   35,   36,  452,   37,   38,  156,  245,
- /*    20 */   167,   29,  138,  137,  202,   41,   39,   43,   40,  106,
- /*    30 */   517,  162,  856,   34,   33,  782,  138,   32,   31,   30,
- /*    40 */    35,   36,  771,   37,   38,  161,  856,  167,   29,  771,
- /*    50 */   106,  202,   41,   39,   43,   40,  187,  159,  223,  222,
- /*    60 */    34,   33,  138,  157,   32,   31,   30,   35,   36,  451,
- /*    70 */    37,   38,  855,  142,  167,   29,  760,  452,  202,   41,
- /*    80 */    39,   43,   40,  199,   78,   60,  779,   34,   33,  234,
- /*    90 */   234,   32,   31,   30,   21,   41,   39,   43,   40,   32,
- /*   100 */    31,   30,   56,   34,   33,  852,  808,   32,   31,   30,
- /*   110 */    21,   21,  106,  411,  412,  413,  414,  415,  416,  417,
- /*   120 */   418,  419,  420,  421,  422,  246,  591,  171,   36,  757,
- /*   130 */    37,   38,  225,   50,  167,   29,   21,   62,  202,   41,
- /*   140 */    39,   43,   40,  172,  221,  757,  757,   34,   33,   27,
- /*   150 */    51,   32,   31,   30,    8,   37,   38,   63,  116,  167,
- /*   160 */    29,  101,  758,  202,   41,   39,   43,   40,  809,  226,
- /*   170 */   197,  757,   34,   33,  170,  851,   32,   31,   30,   16,
- /*   180 */   214,  240,  239,  213,  212,  211,  238,  210,  237,  236,
- /*   190 */   235,  209,  737,  760,  725,  726,  727,  728,  729,  730,
- /*   200 */   731,  732,  733,  734,  735,  736,  166,  604,   12,  241,
- /*   210 */   595,   17,  598,  190,  601,  559,  166,  604,   26,  103,
- /*   220 */   595,  597,  598,  600,  601,   34,   33,  151,  760,   32,
- /*   230 */    31,   30,   21,   90,   89,  145,  572,  573,  163,  164,
- /*   240 */   173,  150,  201,   76,   80,   85,   88,   79,  163,  164,
- /*   250 */   166,  604,  549,   82,  595,  106,  598,  100,  601,  244,
- /*   260 */   243,   97,   17,   16,   26,  240,  239,  756,  680,   26,
- /*   270 */   238,  129,  237,  236,  235,  119,  120,   70,   66,   69,
- /*   280 */   203,  165,  163,  164,  689,  533,  180,  129,  530,  186,
- /*   290 */   531,  850,  532,  184,  183,  596,  153,  599,  133,  131,
- /*   300 */    93,   92,   91,   42,  174,  546,  681,  220,  219,  129,
- /*   310 */    18,   61,  541,   42,  603,  593,  175,  176,  563,  189,
- /*   320 */     3,   47,   46,  537,  603,  538,  564,  623,  605,  602,
- /*   330 */    14,   13,   13,  154,  523,   75,   74,  522,   46,  602,
- /*   340 */    48,   22,  207,  535,  155,  536,   22,   42,   10,    9,
- /*   350 */   140,  594,   87,   86,  141,  143,  144,  148,  603,  149,
- /*   360 */   147,  136,  146,  139,  865,  759,  819,  818,  168,  607,
- /*   370 */   815,  814,  169,  602,  751,  224,  781,  773,  786,  788,
- /*   380 */   102,  801,  117,  800,  115,  118,   26,  534,  188,  691,
- /*   390 */   208,  134,   24,  217,  688,  218,  864,   72,  863,  861,
- /*   400 */   121,   95,  709,   25,   23,  135,  678,   81,  558,  676,
- /*   410 */    83,  191,   84,  674,  158,  673,  195,  177,  130,  671,
- /*   420 */    52,  670,  770,  669,   49,   44,  668,  107,  108,  200,
- /*   430 */   667,  194,  659,  132,  665,  663,  198,  196,  192,  661,
- /*   440 */    28,   57,   58,  802,  216,   77,  227,  228,  229,  230,
- /*   450 */   231,  232,  205,  233,  242,   53,  637,  178,  179,  636,
- /*   460 */   152,   64,   67,  182,  181,  672,  635,  628,   94,   96,
- /*   470 */   185,  666,  124,   55,  123,  710,  122,  125,  126,  128,
- /*   480 */   127,    1,    2,  189,  755,  543,   59,  560,  111,  109,
- /*   490 */   112,  110,  104,  113,  114,  160,   19,  193,    5,  565,
- /*   500 */   105,    6,  606,    4,   20,   15,  204,    7,  608,   65,
- /*   510 */   206,  492,  488,  486,  485,  484,  481,  455,  215,   68,
- /*   520 */    45,   71,   22,  519,   73,  518,  516,   54,  476,  474,
- /*   530 */   466,  472,  468,  470,  464,  462,  491,  490,  489,  487,
- /*   540 */   483,  482,   46,  453,  426,  424,  641,  640,  640,  640,
- /*   550 */   640,  640,  640,  640,  640,  640,  640,  640,   98,   99,
+ /*     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 */   225,    1,  259,  228,  229,  206,  207,    1,  233,    9,
- /*    10 */   235,  236,  237,   13,   14,    9,   16,   17,  208,  209,
- /*    20 */    20,   21,  259,  259,   24,   25,   26,   27,   28,  209,
- /*    30 */     5,  268,  269,   33,   34,  209,  259,   37,   38,   39,
- /*    40 */    13,   14,  243,   16,   17,  268,  269,   20,   21,  243,
- /*    50 */   209,   24,   25,   26,   27,   28,  257,  226,   33,   34,
- /*    60 */    33,   34,  259,  257,   37,   38,   39,   13,   14,    1,
- /*    70 */    16,   17,  269,  259,   20,   21,  245,    9,   24,   25,
- /*    80 */    26,   27,   28,  263,   72,  265,  260,   33,   34,   78,
- /*    90 */    78,   37,   38,   39,  209,   25,   26,   27,   28,   37,
- /*   100 */    38,   39,  102,   33,   34,  259,  265,   37,   38,   39,
- /*   110 */   209,  209,  209,   45,   46,   47,   48,   49,   50,   51,
- /*   120 */    52,   53,   54,   55,   56,   57,   99,  242,   14,  244,
- /*   130 */    16,   17,  209,  103,   20,   21,  209,  246,   24,   25,
- /*   140 */    26,   27,   28,  242,  242,  244,  244,   33,   34,  258,
- /*   150 */   120,   37,   38,   39,   98,   16,   17,  101,  102,   20,
- /*   160 */    21,  209,  239,   24,   25,   26,   27,   28,  265,  242,
- /*   170 */   267,  244,   33,   34,  226,  259,   37,   38,   39,   85,
- /*   180 */    86,   87,   88,   89,   90,   91,   92,   93,   94,   95,
- /*   190 */    96,   97,  225,  245,  227,  228,  229,  230,  231,  232,
- /*   200 */   233,  234,  235,  236,  237,  238,    1,    2,   44,  226,
- /*   210 */     5,   98,    7,  261,    9,   99,    1,    2,  105,  103,
- /*   220 */     5,    5,    7,    7,    9,   33,   34,   63,  245,   37,
- /*   230 */    38,   39,  209,   69,   70,   71,  115,  116,   33,   34,
- /*   240 */    63,   77,   37,   64,   65,   66,   67,   68,   33,   34,
- /*   250 */     1,    2,   37,   74,    5,  209,    7,   98,    9,   60,
- /*   260 */    61,   62,   98,   85,  105,   87,   88,  244,  213,  105,
- /*   270 */    92,  216,   94,   95,   96,   64,   65,   66,   67,   68,
- /*   280 */    15,   59,   33,   34,  213,    2,  126,  216,    5,  125,
- /*   290 */     7,  259,    9,  133,  134,    5,  132,    7,   64,   65,
- /*   300 */    66,   67,   68,   98,  127,  103,  213,  130,  131,  216,
- /*   310 */   108,  265,   99,   98,  109,    1,   33,   34,   99,  106,
- /*   320 */    98,  103,  103,    5,  109,    7,   99,   99,   99,  124,
- /*   330 */   103,  103,  103,  259,   99,  128,  129,   99,  103,  124,
- /*   340 */   122,  103,   99,    5,  259,    7,  103,   98,  128,  129,
- /*   350 */   259,   37,   72,   73,  259,  259,  259,  259,  109,  259,
- /*   360 */   259,  259,  259,  259,  245,  245,  240,  240,  240,  104,
- /*   370 */   240,  240,  240,  124,  241,  240,  209,  243,  209,  209,
- /*   380 */   209,  266,  209,  266,  247,  209,  105,  104,  243,  209,
- /*   390 */   209,  209,  209,  209,  209,  209,  209,  209,  209,  209,
- /*   400 */   209,   59,  209,  209,  209,  209,  209,  209,  109,  209,
- /*   410 */   209,  262,  209,  209,  262,  209,  262,  209,  209,  209,
- /*   420 */   119,  209,  256,  209,  121,  118,  209,  255,  254,  113,
- /*   430 */   209,  111,  209,  209,  209,  209,  117,  112,  110,  209,
- /*   440 */   123,  210,  210,  210,   75,   84,   83,   49,   80,   82,
- /*   450 */    53,   81,  210,   79,   75,  210,    5,  135,    5,    5,
- /*   460 */   210,  214,  214,    5,  135,  210,    5,   86,  211,  211,
- /*   470 */   126,  210,  218,  107,  222,  224,  223,  221,  219,  217,
- /*   480 */   220,  215,  212,  106,  243,   99,  103,   99,  251,  253,
- /*   490 */   250,  252,   98,  249,  248,    1,  103,   98,  114,   99,
- /*   500 */    98,  114,   99,   98,  103,   98,  100,   98,  104,   72,
- /*   510 */   100,    9,    5,    5,    5,    5,    5,   76,   15,   72,
- /*   520 */    16,  129,  103,    5,  129,    5,   99,   98,    5,    5,
- /*   530 */     5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
- /*   540 */     5,    5,  103,   76,   59,   58,    0,  270,  270,  270,
- /*   550 */   270,  270,  270,  270,  270,  270,  270,  270,   21,   21,
- /*   560 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   570 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   580 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   590 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   600 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   610 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   620 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   630 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   640 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   650 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   660 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   670 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   680 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   690 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   700 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   710 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   720 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   730 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   740 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   750 */   270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
- /*   760 */   270,  270,  270,  270,  270,  270,
+ /*     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,
+ /*   600 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   610 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   620 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   630 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   640 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   650 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   660 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   670 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   680 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   690 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   700 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   710 */   271,  271,  271,  271,  271,  271,  271,  271,  271,  271,
+ /*   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,  271,  271,  271,  271,  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      (546)
+#define YY_SHIFT_MAX      (552)
 static const unsigned short int yy_shift_ofst[] = {
- /*     0 */   164,   94,  178,  205,  249,    6,    6,    6,    6,    6,
- /*    10 */     6,    0,   68,  249,  283,  283,  283,  113,    6,    6,
- /*    20 */     6,    6,    6,   12,   11,   11,  560,  215,  249,  249,
- /*    30 */   249,  249,  249,  249,  249,  249,  249,  249,  249,  249,
- /*    40 */   249,  249,  249,  249,  249,  283,  283,   25,   25,   25,
- /*    50 */    25,   25,   25,   56,   25,  159,    6,    6,    6,    6,
- /*    60 */   121,  121,  202,    6,    6,    6,    6,    6,    6,    6,
+ /*     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 */   281,  342,  342,  299,  299,  299,  342,  301,  303,  307,
- /*   110 */   316,  319,  325,  320,  328,  317,  281,  342,  342,  369,
- /*   120 */   369,  342,  361,  363,  398,  368,  367,  397,  370,  374,
- /*   130 */   342,  379,  342,  379,  560,  560,   27,   54,   54,   54,
- /*   140 */   114,  139,   70,   70,   70,  179,  192,  192,  192,  192,
- /*   150 */   211,  234,  177,  160,   62,   62,  199,  213,  116,  219,
- /*   160 */   227,  228,  229,  216,  290,  314,  222,  265,  218,   30,
- /*   170 */   235,  238,  243,  207,  220,  318,  338,  280,  451,  322,
- /*   180 */   453,  454,  329,  458,  461,  381,  344,  377,  386,  366,
- /*   190 */   383,  388,  394,  494,  399,  400,  402,  393,  384,  401,
- /*   200 */   387,  403,  405,  404,  407,  406,  409,  410,  437,  502,
- /*   210 */   507,  508,  509,  510,  511,  441,  503,  447,  504,  392,
- /*   220 */   395,  419,  518,  520,  427,  429,  419,  523,  524,  525,
- /*   230 */   526,  527,  528,  529,  530,  531,  532,  533,  534,  535,
- /*   240 */   536,  439,  467,  537,  538,  485,  487,  546,
+ /*   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 (135)
-#define YY_REDUCE_MIN   (-257)
-#define YY_REDUCE_MAX   (270)
+#define YY_REDUCE_COUNT (138)
+#define YY_REDUCE_MIN   (-258)
+#define YY_REDUCE_MAX   (277)
 static const short yy_reduce_ofst[] = {
- /*     0 */  -201,  -33, -225, -237, -223,  -97, -180, -115,  -99,  -98,
- /*    10 */   -73, -174, -190, -197, -169,  -52,  -17, -194,  -48, -159,
- /*    20 */    46,  -77,   23,   55,   71,   93, -109, -257, -236, -186,
- /*    30 */  -154,  -84,   32,   74,   85,   91,   95,   96,   97,   98,
- /*    40 */   100,  101,  102,  103,  104,  119,  120,  126,  127,  128,
- /*    50 */   130,  131,  132,  133,  135,  134,  167,  169,  170,  171,
- /*    60 */   115,  117,  137,  173,  176,  180,  181,  182,  183,  184,
- /*    70 */   185,  186,  187,  188,  189,  190,  191,  193,  194,  195,
- /*    80 */   196,  197,  198,  200,  201,  203,  204,  206,  208,  209,
- /*    90 */   210,  212,  214,  217,  221,  223,  224,  225,  226,  230,
- /*   100 */   145,  231,  232,  149,  152,  154,  233,  166,  172,  174,
- /*   110 */   236,  239,  237,  240,  244,  246,  241,  242,  245,  247,
- /*   120 */   248,  250,  251,  253,  252,  254,  256,  259,  260,  262,
- /*   130 */   255,  257,  261,  258,  266,  270,
+ /*     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 */   638,  690,  679,  858,  858,  638,  638,  638,  638,  638,
- /*    10 */   638,  783,  656,  858,  638,  638,  638,  638,  638,  638,
- /*    20 */   638,  638,  638,  692,  692,  692,  778,  638,  638,  638,
- /*    30 */   638,  638,  638,  638,  638,  638,  638,  638,  638,  638,
- /*    40 */   638,  638,  638,  638,  638,  638,  638,  638,  638,  638,
- /*    50 */   638,  638,  638,  638,  638,  638,  638,  785,  787,  638,
- /*    60 */   805,  805,  776,  638,  638,  638,  638,  638,  638,  638,
- /*    70 */   638,  638,  638,  638,  638,  638,  638,  638,  638,  638,
- /*    80 */   638,  677,  638,  675,  638,  638,  638,  638,  638,  638,
- /*    90 */   638,  638,  638,  638,  638,  638,  638,  664,  638,  638,
- /*   100 */   638,  658,  658,  638,  638,  638,  658,  812,  816,  810,
- /*   110 */   798,  806,  797,  793,  792,  820,  638,  658,  658,  687,
- /*   120 */   687,  658,  708,  706,  704,  696,  702,  698,  700,  694,
- /*   130 */   658,  685,  658,  685,  724,  738,  638,  821,  857,  811,
- /*   140 */   847,  846,  853,  845,  844,  638,  840,  841,  843,  842,
- /*   150 */   638,  638,  638,  638,  849,  848,  638,  638,  638,  638,
- /*   160 */   638,  638,  638,  638,  638,  638,  823,  638,  817,  813,
- /*   170 */   638,  638,  638,  638,  638,  638,  638,  638,  638,  638,
- /*   180 */   638,  638,  638,  638,  638,  638,  638,  775,  638,  638,
- /*   190 */   784,  638,  638,  638,  638,  638,  638,  807,  638,  799,
- /*   200 */   638,  638,  638,  638,  638,  638,  638,  752,  638,  638,
- /*   210 */   638,  638,  638,  638,  638,  638,  638,  638,  638,  638,
- /*   220 */   638,  862,  638,  638,  638,  746,  860,  638,  638,  638,
- /*   230 */   638,  638,  638,  638,  638,  638,  638,  638,  638,  638,
- /*   240 */   638,  711,  638,  662,  660,  638,  654,  638,
+ /*     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 *****************************/
 
@@ -506,12 +499,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 */
@@ -523,7 +517,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 */
@@ -691,7 +684,6 @@ struct yyParser {
   int yyerrcnt;                 /* Shifts left before out of the error */
 #endif
   ParseARG_SDECL                /* A place to hold %extra_argument */
-  ParseCTX_SDECL                /* A place to hold %extra_context */
 #if YYSTACKDEPTH<=0
   int yystksz;                  /* Current side of the stack */
   yyStackEntry *yystack;        /* The parser's stack */
@@ -799,24 +791,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",
@@ -945,70 +937,71 @@ static const char *const yyTokenName[] = {
   /*  203 */ "INSERT",
   /*  204 */ "INTO",
   /*  205 */ "VALUES",
-  /*  206 */ "program",
-  /*  207 */ "cmd",
-  /*  208 */ "dbPrefix",
-  /*  209 */ "ids",
-  /*  210 */ "cpxName",
-  /*  211 */ "ifexists",
-  /*  212 */ "alter_db_optr",
-  /*  213 */ "acct_optr",
-  /*  214 */ "ifnotexists",
-  /*  215 */ "db_optr",
-  /*  216 */ "pps",
-  /*  217 */ "tseries",
-  /*  218 */ "dbs",
-  /*  219 */ "streams",
-  /*  220 */ "storage",
-  /*  221 */ "qtime",
-  /*  222 */ "users",
-  /*  223 */ "conns",
-  /*  224 */ "state",
-  /*  225 */ "keep",
-  /*  226 */ "tagitemlist",
-  /*  227 */ "cache",
-  /*  228 */ "replica",
-  /*  229 */ "quorum",
-  /*  230 */ "days",
-  /*  231 */ "minrows",
-  /*  232 */ "maxrows",
-  /*  233 */ "blocks",
-  /*  234 */ "ctime",
-  /*  235 */ "wal",
-  /*  236 */ "fsync",
-  /*  237 */ "comp",
-  /*  238 */ "prec",
-  /*  239 */ "typename",
-  /*  240 */ "signed",
-  /*  241 */ "create_table_args",
-  /*  242 */ "columnlist",
-  /*  243 */ "select",
-  /*  244 */ "column",
-  /*  245 */ "tagitem",
-  /*  246 */ "selcollist",
-  /*  247 */ "from",
-  /*  248 */ "where_opt",
-  /*  249 */ "interval_opt",
-  /*  250 */ "fill_opt",
-  /*  251 */ "sliding_opt",
-  /*  252 */ "groupby_opt",
-  /*  253 */ "orderby_opt",
-  /*  254 */ "having_opt",
-  /*  255 */ "slimit_opt",
-  /*  256 */ "limit_opt",
-  /*  257 */ "union",
-  /*  258 */ "sclp",
-  /*  259 */ "expr",
-  /*  260 */ "as",
-  /*  261 */ "tablelist",
-  /*  262 */ "tmvar",
-  /*  263 */ "sortlist",
-  /*  264 */ "sortitem",
-  /*  265 */ "item",
-  /*  266 */ "sortorder",
-  /*  267 */ "grouplist",
-  /*  268 */ "exprlist",
-  /*  269 */ "expritem",
+  /*  206 */ "error",
+  /*  207 */ "program",
+  /*  208 */ "cmd",
+  /*  209 */ "dbPrefix",
+  /*  210 */ "ids",
+  /*  211 */ "cpxName",
+  /*  212 */ "ifexists",
+  /*  213 */ "alter_db_optr",
+  /*  214 */ "acct_optr",
+  /*  215 */ "ifnotexists",
+  /*  216 */ "db_optr",
+  /*  217 */ "pps",
+  /*  218 */ "tseries",
+  /*  219 */ "dbs",
+  /*  220 */ "streams",
+  /*  221 */ "storage",
+  /*  222 */ "qtime",
+  /*  223 */ "users",
+  /*  224 */ "conns",
+  /*  225 */ "state",
+  /*  226 */ "keep",
+  /*  227 */ "tagitemlist",
+  /*  228 */ "cache",
+  /*  229 */ "replica",
+  /*  230 */ "quorum",
+  /*  231 */ "days",
+  /*  232 */ "minrows",
+  /*  233 */ "maxrows",
+  /*  234 */ "blocks",
+  /*  235 */ "ctime",
+  /*  236 */ "wal",
+  /*  237 */ "fsync",
+  /*  238 */ "comp",
+  /*  239 */ "prec",
+  /*  240 */ "typename",
+  /*  241 */ "signed",
+  /*  242 */ "create_table_args",
+  /*  243 */ "columnlist",
+  /*  244 */ "select",
+  /*  245 */ "column",
+  /*  246 */ "tagitem",
+  /*  247 */ "selcollist",
+  /*  248 */ "from",
+  /*  249 */ "where_opt",
+  /*  250 */ "interval_opt",
+  /*  251 */ "fill_opt",
+  /*  252 */ "sliding_opt",
+  /*  253 */ "groupby_opt",
+  /*  254 */ "orderby_opt",
+  /*  255 */ "having_opt",
+  /*  256 */ "slimit_opt",
+  /*  257 */ "limit_opt",
+  /*  258 */ "union",
+  /*  259 */ "sclp",
+  /*  260 */ "expr",
+  /*  261 */ "as",
+  /*  262 */ "tablelist",
+  /*  263 */ "tmvar",
+  /*  264 */ "sortlist",
+  /*  265 */ "sortitem",
+  /*  266 */ "item",
+  /*  267 */ "sortorder",
+  /*  268 */ "grouplist",
+  /*  269 */ "exprlist",
+  /*  270 */ "expritem",
 };
 #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
 
@@ -1035,215 +1028,217 @@ 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 ::= INTERVAL LP tmvar COMMA tmvar RP",
- /* 151 */ "interval_opt ::=",
- /* 152 */ "fill_opt ::=",
- /* 153 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
- /* 154 */ "fill_opt ::= FILL LP ID RP",
- /* 155 */ "sliding_opt ::= SLIDING LP tmvar RP",
- /* 156 */ "sliding_opt ::=",
- /* 157 */ "orderby_opt ::=",
- /* 158 */ "orderby_opt ::= ORDER BY sortlist",
- /* 159 */ "sortlist ::= sortlist COMMA item sortorder",
- /* 160 */ "sortlist ::= item sortorder",
- /* 161 */ "item ::= ids cpxName",
- /* 162 */ "sortorder ::= ASC",
- /* 163 */ "sortorder ::= DESC",
- /* 164 */ "sortorder ::=",
- /* 165 */ "groupby_opt ::=",
- /* 166 */ "groupby_opt ::= GROUP BY grouplist",
- /* 167 */ "grouplist ::= grouplist COMMA item",
- /* 168 */ "grouplist ::= item",
- /* 169 */ "having_opt ::=",
- /* 170 */ "having_opt ::= HAVING expr",
- /* 171 */ "limit_opt ::=",
- /* 172 */ "limit_opt ::= LIMIT signed",
- /* 173 */ "limit_opt ::= LIMIT signed OFFSET signed",
- /* 174 */ "limit_opt ::= LIMIT signed COMMA signed",
- /* 175 */ "slimit_opt ::=",
- /* 176 */ "slimit_opt ::= SLIMIT signed",
- /* 177 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
- /* 178 */ "slimit_opt ::= SLIMIT signed COMMA signed",
- /* 179 */ "where_opt ::=",
- /* 180 */ "where_opt ::= WHERE expr",
- /* 181 */ "expr ::= LP expr RP",
- /* 182 */ "expr ::= ID",
- /* 183 */ "expr ::= ID DOT ID",
- /* 184 */ "expr ::= ID DOT STAR",
- /* 185 */ "expr ::= INTEGER",
- /* 186 */ "expr ::= MINUS INTEGER",
- /* 187 */ "expr ::= PLUS INTEGER",
- /* 188 */ "expr ::= FLOAT",
- /* 189 */ "expr ::= MINUS FLOAT",
- /* 190 */ "expr ::= PLUS FLOAT",
- /* 191 */ "expr ::= STRING",
- /* 192 */ "expr ::= NOW",
- /* 193 */ "expr ::= VARIABLE",
- /* 194 */ "expr ::= BOOL",
- /* 195 */ "expr ::= ID LP exprlist RP",
- /* 196 */ "expr ::= ID LP STAR RP",
- /* 197 */ "expr ::= expr IS NULL",
- /* 198 */ "expr ::= expr IS NOT NULL",
- /* 199 */ "expr ::= expr LT expr",
- /* 200 */ "expr ::= expr GT expr",
- /* 201 */ "expr ::= expr LE expr",
- /* 202 */ "expr ::= expr GE expr",
- /* 203 */ "expr ::= expr NE expr",
- /* 204 */ "expr ::= expr EQ expr",
- /* 205 */ "expr ::= expr AND expr",
- /* 206 */ "expr ::= expr OR expr",
- /* 207 */ "expr ::= expr PLUS expr",
- /* 208 */ "expr ::= expr MINUS expr",
- /* 209 */ "expr ::= expr STAR expr",
- /* 210 */ "expr ::= expr SLASH expr",
- /* 211 */ "expr ::= expr REM expr",
- /* 212 */ "expr ::= expr LIKE expr",
- /* 213 */ "expr ::= expr IN LP exprlist RP",
- /* 214 */ "exprlist ::= exprlist COMMA expritem",
- /* 215 */ "exprlist ::= expritem",
- /* 216 */ "expritem ::= expr",
- /* 217 */ "expritem ::=",
- /* 218 */ "cmd ::= RESET QUERY CACHE",
- /* 219 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
- /* 220 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
- /* 221 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
- /* 222 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
- /* 223 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
- /* 224 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
- /* 225 */ "cmd ::= KILL CONNECTION INTEGER",
- /* 226 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
- /* 227 */ "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 ::= 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 */
 
@@ -1292,29 +1287,28 @@ static int yyGrowStack(yyParser *p){
 
 /* Initialize a new parser that has already been allocated.
 */
-void ParseInit(void *yypRawParser ParseCTX_PDECL){
-  yyParser *yypParser = (yyParser*)yypRawParser;
-  ParseCTX_STORE
+void ParseInit(void *yypParser){
+  yyParser *pParser = (yyParser*)yypParser;
 #ifdef YYTRACKMAXSTACKDEPTH
-  yypParser->yyhwm = 0;
+  pParser->yyhwm = 0;
 #endif
 #if YYSTACKDEPTH<=0
-  yypParser->yytos = NULL;
-  yypParser->yystack = NULL;
-  yypParser->yystksz = 0;
-  if( yyGrowStack(yypParser) ){
-    yypParser->yystack = &yypParser->yystk0;
-    yypParser->yystksz = 1;
+  pParser->yytos = NULL;
+  pParser->yystack = NULL;
+  pParser->yystksz = 0;
+  if( yyGrowStack(pParser) ){
+    pParser->yystack = &pParser->yystk0;
+    pParser->yystksz = 1;
   }
 #endif
 #ifndef YYNOERRORRECOVERY
-  yypParser->yyerrcnt = -1;
+  pParser->yyerrcnt = -1;
 #endif
-  yypParser->yytos = yypParser->yystack;
-  yypParser->yystack[0].stateno = 0;
-  yypParser->yystack[0].major = 0;
+  pParser->yytos = pParser->yystack;
+  pParser->yystack[0].stateno = 0;
+  pParser->yystack[0].major = 0;
 #if YYSTACKDEPTH>0
-  yypParser->yystackEnd = &yypParser->yystack[YYSTACKDEPTH-1];
+  pParser->yystackEnd = &pParser->yystack[YYSTACKDEPTH-1];
 #endif
 }
 
@@ -1331,14 +1325,11 @@ void ParseInit(void *yypRawParser ParseCTX_PDECL){
 ** A pointer to a parser.  This pointer is used in subsequent calls
 ** to Parse and ParseFree.
 */
-void *ParseAlloc(void *(*mallocProc)(YYMALLOCARGTYPE) ParseCTX_PDECL){
-  yyParser *yypParser;
-  yypParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) );
-  if( yypParser ){
-    ParseCTX_STORE
-    ParseInit(yypParser ParseCTX_PARAM);
-  }
-  return (void*)yypParser;
+void *ParseAlloc(void *(*mallocProc)(YYMALLOCARGTYPE)){
+  yyParser *pParser;
+  pParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) );
+  if( pParser ) ParseInit(pParser);
+  return pParser;
 }
 #endif /* Parse_ENGINEALWAYSONSTACK */
 
@@ -1355,8 +1346,7 @@ static void yy_destructor(
   YYCODETYPE yymajor,     /* Type code for object to destroy */
   YYMINORTYPE *yypminor   /* The object to be destroyed */
 ){
-  ParseARG_FETCH
-  ParseCTX_FETCH
+  ParseARG_FETCH;
   switch( yymajor ){
     /* Here is inserted the actions which take place when a
     ** terminal or non-terminal is destroyed.  This can happen
@@ -1369,50 +1359,50 @@ static void yy_destructor(
     ** inside the C code.
     */
 /********* Begin destructor definitions ***************************************/
-    case 225: /* keep */
-    case 226: /* tagitemlist */
-    case 250: /* fill_opt */
-    case 252: /* groupby_opt */
-    case 253: /* orderby_opt */
-    case 263: /* sortlist */
-    case 267: /* grouplist */
+    case 226: /* keep */
+    case 227: /* tagitemlist */
+    case 251: /* fill_opt */
+    case 253: /* groupby_opt */
+    case 254: /* orderby_opt */
+    case 264: /* sortlist */
+    case 268: /* grouplist */
 {
-tVariantListDestroy((yypminor->yy156));
+tVariantListDestroy((yypminor->yy494));
 }
       break;
-    case 242: /* columnlist */
+    case 243: /* columnlist */
 {
-tFieldListDestroy((yypminor->yy511));
+tFieldListDestroy((yypminor->yy449));
 }
       break;
-    case 243: /* select */
+    case 244: /* select */
 {
-doDestroyQuerySql((yypminor->yy444));
+doDestroyQuerySql((yypminor->yy150));
 }
       break;
-    case 246: /* selcollist */
-    case 258: /* sclp */
-    case 268: /* exprlist */
+    case 247: /* selcollist */
+    case 259: /* sclp */
+    case 269: /* exprlist */
 {
-tSQLExprListDestroy((yypminor->yy158));
+tSQLExprListDestroy((yypminor->yy224));
 }
       break;
-    case 248: /* where_opt */
-    case 254: /* having_opt */
-    case 259: /* expr */
-    case 269: /* expritem */
+    case 249: /* where_opt */
+    case 255: /* having_opt */
+    case 260: /* expr */
+    case 270: /* expritem */
 {
-tSQLExprDestroy((yypminor->yy190));
+tSQLExprDestroy((yypminor->yy66));
 }
       break;
-    case 257: /* union */
+    case 258: /* union */
 {
-destroyAllSelectClause((yypminor->yy333));
+destroyAllSelectClause((yypminor->yy25));
 }
       break;
-    case 264: /* sortitem */
+    case 265: /* sortitem */
 {
-tVariantDestroy(&(yypminor->yy506));
+tVariantDestroy(&(yypminor->yy312));
 }
       break;
 /********* End destructor definitions *****************************************/
@@ -1524,12 +1514,13 @@ int ParseCoverage(FILE *out){
 ** Find the appropriate action for a parser given the terminal
 ** look-ahead token iLookAhead.
 */
-static YYACTIONTYPE yy_find_shift_action(
-  YYCODETYPE iLookAhead,    /* The look-ahead token */
-  YYACTIONTYPE stateno      /* Current state number */
+static unsigned int yy_find_shift_action(
+  yyParser *pParser,        /* The parser */
+  YYCODETYPE iLookAhead     /* The look-ahead token */
 ){
   int i;
-
+  int stateno = pParser->yytos->stateno;
+ 
   if( stateno>YY_MAX_SHIFT ) return stateno;
   assert( stateno <= YY_SHIFT_COUNT );
 #if defined(YYCOVERAGE)
@@ -1537,19 +1528,15 @@ static YYACTIONTYPE yy_find_shift_action(
 #endif
   do{
     i = yy_shift_ofst[stateno];
-    assert( i>=0 );
-    assert( i<=YY_ACTTAB_COUNT );
-    assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD );
+    assert( i>=0 && i+YYNTOKEN<=sizeof(yy_lookahead)/sizeof(yy_lookahead[0]) );
     assert( iLookAhead!=YYNOCODE );
     assert( iLookAhead < YYNTOKEN );
     i += iLookAhead;
-    assert( i<(int)YY_NLOOKAHEAD );
     if( yy_lookahead[i]!=iLookAhead ){
 #ifdef YYFALLBACK
       YYCODETYPE iFallback;            /* Fallback token */
-      assert( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0]) );
-      iFallback = yyFallback[iLookAhead];
-      if( iFallback!=0 ){
+      if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
+             && (iFallback = yyFallback[iLookAhead])!=0 ){
 #ifndef NDEBUG
         if( yyTraceFILE ){
           fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
@@ -1564,8 +1551,15 @@ static YYACTIONTYPE yy_find_shift_action(
 #ifdef YYWILDCARD
       {
         int j = i - iLookAhead + YYWILDCARD;
-        assert( j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) );
-        if( yy_lookahead[j]==YYWILDCARD && iLookAhead>0 ){
+        if( 
+#if YY_SHIFT_MIN+YYWILDCARD<0
+          j>=0 &&
+#endif
+#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
+          j<YY_ACTTAB_COUNT &&
+#endif
+          yy_lookahead[j]==YYWILDCARD && iLookAhead>0
+        ){
 #ifndef NDEBUG
           if( yyTraceFILE ){
             fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
@@ -1579,7 +1573,6 @@ static YYACTIONTYPE yy_find_shift_action(
 #endif /* YYWILDCARD */
       return yy_default[stateno];
     }else{
-      assert( i>=0 && i<sizeof(yy_action)/sizeof(yy_action[0]) );
       return yy_action[i];
     }
   }while(1);
@@ -1589,8 +1582,8 @@ static YYACTIONTYPE yy_find_shift_action(
 ** Find the appropriate action for a parser given the non-terminal
 ** look-ahead token iLookAhead.
 */
-static YYACTIONTYPE yy_find_reduce_action(
-  YYACTIONTYPE stateno,     /* Current state number */
+static int yy_find_reduce_action(
+  int stateno,              /* Current state number */
   YYCODETYPE iLookAhead     /* The look-ahead token */
 ){
   int i;
@@ -1619,8 +1612,7 @@ static YYACTIONTYPE yy_find_reduce_action(
 ** The following routine is called if the stack overflows.
 */
 static void yyStackOverflow(yyParser *yypParser){
-   ParseARG_FETCH
-   ParseCTX_FETCH
+   ParseARG_FETCH;
 #ifndef NDEBUG
    if( yyTraceFILE ){
      fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
@@ -1631,8 +1623,7 @@ static void yyStackOverflow(yyParser *yypParser){
    ** stack every overflows */
 /******** Begin %stack_overflow code ******************************************/
 /******** End %stack_overflow code ********************************************/
-   ParseARG_STORE /* Suppress warning about unused %extra_argument var */
-   ParseCTX_STORE
+   ParseARG_STORE; /* Suppress warning about unused %extra_argument var */
 }
 
 /*
@@ -1661,8 +1652,8 @@ static void yyTraceShift(yyParser *yypParser, int yyNewState, const char *zTag){
 */
 static void yy_shift(
   yyParser *yypParser,          /* The parser to be shifted */
-  YYACTIONTYPE yyNewState,      /* The new state to shift in */
-  YYCODETYPE yyMajor,           /* The major token to shift in */
+  int yyNewState,               /* The new state to shift in */
+  int yyMajor,                  /* The major token to shift in */
   ParseTOKENTYPE yyMinor        /* The minor token to shift in */
 ){
   yyStackEntry *yytos;
@@ -1692,476 +1683,249 @@ static void yy_shift(
     yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
   }
   yytos = yypParser->yytos;
-  yytos->stateno = yyNewState;
-  yytos->major = yyMajor;
+  yytos->stateno = (YYACTIONTYPE)yyNewState;
+  yytos->major = (YYCODETYPE)yyMajor;
   yytos->minor.yy0 = yyMinor;
   yyTraceShift(yypParser, yyNewState, "Shift");
 }
 
-/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side
-** of that rule */
-static const YYCODETYPE yyRuleInfoLhs[] = {
-   206,  /* (0) program ::= cmd */
-   207,  /* (1) cmd ::= SHOW DATABASES */
-   207,  /* (2) cmd ::= SHOW MNODES */
-   207,  /* (3) cmd ::= SHOW DNODES */
-   207,  /* (4) cmd ::= SHOW ACCOUNTS */
-   207,  /* (5) cmd ::= SHOW USERS */
-   207,  /* (6) cmd ::= SHOW MODULES */
-   207,  /* (7) cmd ::= SHOW QUERIES */
-   207,  /* (8) cmd ::= SHOW CONNECTIONS */
-   207,  /* (9) cmd ::= SHOW STREAMS */
-   207,  /* (10) cmd ::= SHOW VARIABLES */
-   207,  /* (11) cmd ::= SHOW SCORES */
-   207,  /* (12) cmd ::= SHOW GRANTS */
-   207,  /* (13) cmd ::= SHOW VNODES */
-   207,  /* (14) cmd ::= SHOW VNODES IPTOKEN */
-   208,  /* (15) dbPrefix ::= */
-   208,  /* (16) dbPrefix ::= ids DOT */
-   210,  /* (17) cpxName ::= */
-   210,  /* (18) cpxName ::= DOT ids */
-   207,  /* (19) cmd ::= SHOW dbPrefix TABLES */
-   207,  /* (20) cmd ::= SHOW dbPrefix TABLES LIKE ids */
-   207,  /* (21) cmd ::= SHOW dbPrefix STABLES */
-   207,  /* (22) cmd ::= SHOW dbPrefix STABLES LIKE ids */
-   207,  /* (23) cmd ::= SHOW dbPrefix VGROUPS */
-   207,  /* (24) cmd ::= SHOW dbPrefix VGROUPS ids */
-   207,  /* (25) cmd ::= DROP TABLE ifexists ids cpxName */
-   207,  /* (26) cmd ::= DROP DATABASE ifexists ids */
-   207,  /* (27) cmd ::= DROP DNODE ids */
-   207,  /* (28) cmd ::= DROP USER ids */
-   207,  /* (29) cmd ::= DROP ACCOUNT ids */
-   207,  /* (30) cmd ::= USE ids */
-   207,  /* (31) cmd ::= DESCRIBE ids cpxName */
-   207,  /* (32) cmd ::= ALTER USER ids PASS ids */
-   207,  /* (33) cmd ::= ALTER USER ids PRIVILEGE ids */
-   207,  /* (34) cmd ::= ALTER DNODE ids ids */
-   207,  /* (35) cmd ::= ALTER DNODE ids ids ids */
-   207,  /* (36) cmd ::= ALTER LOCAL ids */
-   207,  /* (37) cmd ::= ALTER LOCAL ids ids */
-   207,  /* (38) cmd ::= ALTER DATABASE ids alter_db_optr */
-   207,  /* (39) cmd ::= ALTER ACCOUNT ids acct_optr */
-   207,  /* (40) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
-   209,  /* (41) ids ::= ID */
-   209,  /* (42) ids ::= STRING */
-   211,  /* (43) ifexists ::= IF EXISTS */
-   211,  /* (44) ifexists ::= */
-   214,  /* (45) ifnotexists ::= IF NOT EXISTS */
-   214,  /* (46) ifnotexists ::= */
-   207,  /* (47) cmd ::= CREATE DNODE ids */
-   207,  /* (48) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
-   207,  /* (49) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
-   207,  /* (50) cmd ::= CREATE USER ids PASS ids */
-   216,  /* (51) pps ::= */
-   216,  /* (52) pps ::= PPS INTEGER */
-   217,  /* (53) tseries ::= */
-   217,  /* (54) tseries ::= TSERIES INTEGER */
-   218,  /* (55) dbs ::= */
-   218,  /* (56) dbs ::= DBS INTEGER */
-   219,  /* (57) streams ::= */
-   219,  /* (58) streams ::= STREAMS INTEGER */
-   220,  /* (59) storage ::= */
-   220,  /* (60) storage ::= STORAGE INTEGER */
-   221,  /* (61) qtime ::= */
-   221,  /* (62) qtime ::= QTIME INTEGER */
-   222,  /* (63) users ::= */
-   222,  /* (64) users ::= USERS INTEGER */
-   223,  /* (65) conns ::= */
-   223,  /* (66) conns ::= CONNS INTEGER */
-   224,  /* (67) state ::= */
-   224,  /* (68) state ::= STATE ids */
-   213,  /* (69) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
-   225,  /* (70) keep ::= KEEP tagitemlist */
-   227,  /* (71) cache ::= CACHE INTEGER */
-   228,  /* (72) replica ::= REPLICA INTEGER */
-   229,  /* (73) quorum ::= QUORUM INTEGER */
-   230,  /* (74) days ::= DAYS INTEGER */
-   231,  /* (75) minrows ::= MINROWS INTEGER */
-   232,  /* (76) maxrows ::= MAXROWS INTEGER */
-   233,  /* (77) blocks ::= BLOCKS INTEGER */
-   234,  /* (78) ctime ::= CTIME INTEGER */
-   235,  /* (79) wal ::= WAL INTEGER */
-   236,  /* (80) fsync ::= FSYNC INTEGER */
-   237,  /* (81) comp ::= COMP INTEGER */
-   238,  /* (82) prec ::= PRECISION STRING */
-   215,  /* (83) db_optr ::= */
-   215,  /* (84) db_optr ::= db_optr cache */
-   215,  /* (85) db_optr ::= db_optr replica */
-   215,  /* (86) db_optr ::= db_optr quorum */
-   215,  /* (87) db_optr ::= db_optr days */
-   215,  /* (88) db_optr ::= db_optr minrows */
-   215,  /* (89) db_optr ::= db_optr maxrows */
-   215,  /* (90) db_optr ::= db_optr blocks */
-   215,  /* (91) db_optr ::= db_optr ctime */
-   215,  /* (92) db_optr ::= db_optr wal */
-   215,  /* (93) db_optr ::= db_optr fsync */
-   215,  /* (94) db_optr ::= db_optr comp */
-   215,  /* (95) db_optr ::= db_optr prec */
-   215,  /* (96) db_optr ::= db_optr keep */
-   212,  /* (97) alter_db_optr ::= */
-   212,  /* (98) alter_db_optr ::= alter_db_optr replica */
-   212,  /* (99) alter_db_optr ::= alter_db_optr quorum */
-   212,  /* (100) alter_db_optr ::= alter_db_optr keep */
-   212,  /* (101) alter_db_optr ::= alter_db_optr blocks */
-   212,  /* (102) alter_db_optr ::= alter_db_optr comp */
-   212,  /* (103) alter_db_optr ::= alter_db_optr wal */
-   212,  /* (104) alter_db_optr ::= alter_db_optr fsync */
-   239,  /* (105) typename ::= ids */
-   239,  /* (106) typename ::= ids LP signed RP */
-   240,  /* (107) signed ::= INTEGER */
-   240,  /* (108) signed ::= PLUS INTEGER */
-   240,  /* (109) signed ::= MINUS INTEGER */
-   207,  /* (110) cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args */
-   241,  /* (111) create_table_args ::= LP columnlist RP */
-   241,  /* (112) create_table_args ::= LP columnlist RP TAGS LP columnlist RP */
-   241,  /* (113) create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP */
-   241,  /* (114) create_table_args ::= AS select */
-   242,  /* (115) columnlist ::= columnlist COMMA column */
-   242,  /* (116) columnlist ::= column */
-   244,  /* (117) column ::= ids typename */
-   226,  /* (118) tagitemlist ::= tagitemlist COMMA tagitem */
-   226,  /* (119) tagitemlist ::= tagitem */
-   245,  /* (120) tagitem ::= INTEGER */
-   245,  /* (121) tagitem ::= FLOAT */
-   245,  /* (122) tagitem ::= STRING */
-   245,  /* (123) tagitem ::= BOOL */
-   245,  /* (124) tagitem ::= NULL */
-   245,  /* (125) tagitem ::= MINUS INTEGER */
-   245,  /* (126) tagitem ::= MINUS FLOAT */
-   245,  /* (127) tagitem ::= PLUS INTEGER */
-   245,  /* (128) tagitem ::= PLUS FLOAT */
-   243,  /* (129) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
-   257,  /* (130) union ::= select */
-   257,  /* (131) union ::= LP union RP */
-   257,  /* (132) union ::= union UNION ALL select */
-   257,  /* (133) union ::= union UNION ALL LP select RP */
-   207,  /* (134) cmd ::= union */
-   243,  /* (135) select ::= SELECT selcollist */
-   258,  /* (136) sclp ::= selcollist COMMA */
-   258,  /* (137) sclp ::= */
-   246,  /* (138) selcollist ::= sclp expr as */
-   246,  /* (139) selcollist ::= sclp STAR */
-   260,  /* (140) as ::= AS ids */
-   260,  /* (141) as ::= ids */
-   260,  /* (142) as ::= */
-   247,  /* (143) from ::= FROM tablelist */
-   261,  /* (144) tablelist ::= ids cpxName */
-   261,  /* (145) tablelist ::= ids cpxName ids */
-   261,  /* (146) tablelist ::= tablelist COMMA ids cpxName */
-   261,  /* (147) tablelist ::= tablelist COMMA ids cpxName ids */
-   262,  /* (148) tmvar ::= VARIABLE */
-   249,  /* (149) interval_opt ::= INTERVAL LP tmvar RP */
-   249,  /* (150) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
-   249,  /* (151) interval_opt ::= */
-   250,  /* (152) fill_opt ::= */
-   250,  /* (153) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
-   250,  /* (154) fill_opt ::= FILL LP ID RP */
-   251,  /* (155) sliding_opt ::= SLIDING LP tmvar RP */
-   251,  /* (156) sliding_opt ::= */
-   253,  /* (157) orderby_opt ::= */
-   253,  /* (158) orderby_opt ::= ORDER BY sortlist */
-   263,  /* (159) sortlist ::= sortlist COMMA item sortorder */
-   263,  /* (160) sortlist ::= item sortorder */
-   265,  /* (161) item ::= ids cpxName */
-   266,  /* (162) sortorder ::= ASC */
-   266,  /* (163) sortorder ::= DESC */
-   266,  /* (164) sortorder ::= */
-   252,  /* (165) groupby_opt ::= */
-   252,  /* (166) groupby_opt ::= GROUP BY grouplist */
-   267,  /* (167) grouplist ::= grouplist COMMA item */
-   267,  /* (168) grouplist ::= item */
-   254,  /* (169) having_opt ::= */
-   254,  /* (170) having_opt ::= HAVING expr */
-   256,  /* (171) limit_opt ::= */
-   256,  /* (172) limit_opt ::= LIMIT signed */
-   256,  /* (173) limit_opt ::= LIMIT signed OFFSET signed */
-   256,  /* (174) limit_opt ::= LIMIT signed COMMA signed */
-   255,  /* (175) slimit_opt ::= */
-   255,  /* (176) slimit_opt ::= SLIMIT signed */
-   255,  /* (177) slimit_opt ::= SLIMIT signed SOFFSET signed */
-   255,  /* (178) slimit_opt ::= SLIMIT signed COMMA signed */
-   248,  /* (179) where_opt ::= */
-   248,  /* (180) where_opt ::= WHERE expr */
-   259,  /* (181) expr ::= LP expr RP */
-   259,  /* (182) expr ::= ID */
-   259,  /* (183) expr ::= ID DOT ID */
-   259,  /* (184) expr ::= ID DOT STAR */
-   259,  /* (185) expr ::= INTEGER */
-   259,  /* (186) expr ::= MINUS INTEGER */
-   259,  /* (187) expr ::= PLUS INTEGER */
-   259,  /* (188) expr ::= FLOAT */
-   259,  /* (189) expr ::= MINUS FLOAT */
-   259,  /* (190) expr ::= PLUS FLOAT */
-   259,  /* (191) expr ::= STRING */
-   259,  /* (192) expr ::= NOW */
-   259,  /* (193) expr ::= VARIABLE */
-   259,  /* (194) expr ::= BOOL */
-   259,  /* (195) expr ::= ID LP exprlist RP */
-   259,  /* (196) expr ::= ID LP STAR RP */
-   259,  /* (197) expr ::= expr IS NULL */
-   259,  /* (198) expr ::= expr IS NOT NULL */
-   259,  /* (199) expr ::= expr LT expr */
-   259,  /* (200) expr ::= expr GT expr */
-   259,  /* (201) expr ::= expr LE expr */
-   259,  /* (202) expr ::= expr GE expr */
-   259,  /* (203) expr ::= expr NE expr */
-   259,  /* (204) expr ::= expr EQ expr */
-   259,  /* (205) expr ::= expr AND expr */
-   259,  /* (206) expr ::= expr OR expr */
-   259,  /* (207) expr ::= expr PLUS expr */
-   259,  /* (208) expr ::= expr MINUS expr */
-   259,  /* (209) expr ::= expr STAR expr */
-   259,  /* (210) expr ::= expr SLASH expr */
-   259,  /* (211) expr ::= expr REM expr */
-   259,  /* (212) expr ::= expr LIKE expr */
-   259,  /* (213) expr ::= expr IN LP exprlist RP */
-   268,  /* (214) exprlist ::= exprlist COMMA expritem */
-   268,  /* (215) exprlist ::= expritem */
-   269,  /* (216) expritem ::= expr */
-   269,  /* (217) expritem ::= */
-   207,  /* (218) cmd ::= RESET QUERY CACHE */
-   207,  /* (219) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
-   207,  /* (220) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
-   207,  /* (221) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
-   207,  /* (222) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
-   207,  /* (223) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
-   207,  /* (224) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
-   207,  /* (225) cmd ::= KILL CONNECTION INTEGER */
-   207,  /* (226) cmd ::= KILL STREAM INTEGER COLON INTEGER */
-   207,  /* (227) cmd ::= KILL QUERY INTEGER COLON INTEGER */
-};
-
-/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number
-** of symbols on the right-hand side of that rule. */
-static const signed char yyRuleInfoNRhs[] = {
-   -1,  /* (0) program ::= cmd */
-   -2,  /* (1) cmd ::= SHOW DATABASES */
-   -2,  /* (2) cmd ::= SHOW MNODES */
-   -2,  /* (3) cmd ::= SHOW DNODES */
-   -2,  /* (4) cmd ::= SHOW ACCOUNTS */
-   -2,  /* (5) cmd ::= SHOW USERS */
-   -2,  /* (6) cmd ::= SHOW MODULES */
-   -2,  /* (7) cmd ::= SHOW QUERIES */
-   -2,  /* (8) cmd ::= SHOW CONNECTIONS */
-   -2,  /* (9) cmd ::= SHOW STREAMS */
-   -2,  /* (10) cmd ::= SHOW VARIABLES */
-   -2,  /* (11) cmd ::= SHOW SCORES */
-   -2,  /* (12) cmd ::= SHOW GRANTS */
-   -2,  /* (13) cmd ::= SHOW VNODES */
-   -3,  /* (14) cmd ::= SHOW VNODES IPTOKEN */
-    0,  /* (15) dbPrefix ::= */
-   -2,  /* (16) dbPrefix ::= ids DOT */
-    0,  /* (17) cpxName ::= */
-   -2,  /* (18) cpxName ::= DOT ids */
-   -3,  /* (19) cmd ::= SHOW dbPrefix TABLES */
-   -5,  /* (20) cmd ::= SHOW dbPrefix TABLES LIKE ids */
-   -3,  /* (21) cmd ::= SHOW dbPrefix STABLES */
-   -5,  /* (22) cmd ::= SHOW dbPrefix STABLES LIKE ids */
-   -3,  /* (23) cmd ::= SHOW dbPrefix VGROUPS */
-   -4,  /* (24) cmd ::= SHOW dbPrefix VGROUPS ids */
-   -5,  /* (25) cmd ::= DROP TABLE ifexists ids cpxName */
-   -4,  /* (26) cmd ::= DROP DATABASE ifexists ids */
-   -3,  /* (27) cmd ::= DROP DNODE ids */
-   -3,  /* (28) cmd ::= DROP USER ids */
-   -3,  /* (29) cmd ::= DROP ACCOUNT ids */
-   -2,  /* (30) cmd ::= USE ids */
-   -3,  /* (31) cmd ::= DESCRIBE ids cpxName */
-   -5,  /* (32) cmd ::= ALTER USER ids PASS ids */
-   -5,  /* (33) cmd ::= ALTER USER ids PRIVILEGE ids */
-   -4,  /* (34) cmd ::= ALTER DNODE ids ids */
-   -5,  /* (35) cmd ::= ALTER DNODE ids ids ids */
-   -3,  /* (36) cmd ::= ALTER LOCAL ids */
-   -4,  /* (37) cmd ::= ALTER LOCAL ids ids */
-   -4,  /* (38) cmd ::= ALTER DATABASE ids alter_db_optr */
-   -4,  /* (39) cmd ::= ALTER ACCOUNT ids acct_optr */
-   -6,  /* (40) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
-   -1,  /* (41) ids ::= ID */
-   -1,  /* (42) ids ::= STRING */
-   -2,  /* (43) ifexists ::= IF EXISTS */
-    0,  /* (44) ifexists ::= */
-   -3,  /* (45) ifnotexists ::= IF NOT EXISTS */
-    0,  /* (46) ifnotexists ::= */
-   -3,  /* (47) cmd ::= CREATE DNODE ids */
-   -6,  /* (48) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
-   -5,  /* (49) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
-   -5,  /* (50) cmd ::= CREATE USER ids PASS ids */
-    0,  /* (51) pps ::= */
-   -2,  /* (52) pps ::= PPS INTEGER */
-    0,  /* (53) tseries ::= */
-   -2,  /* (54) tseries ::= TSERIES INTEGER */
-    0,  /* (55) dbs ::= */
-   -2,  /* (56) dbs ::= DBS INTEGER */
-    0,  /* (57) streams ::= */
-   -2,  /* (58) streams ::= STREAMS INTEGER */
-    0,  /* (59) storage ::= */
-   -2,  /* (60) storage ::= STORAGE INTEGER */
-    0,  /* (61) qtime ::= */
-   -2,  /* (62) qtime ::= QTIME INTEGER */
-    0,  /* (63) users ::= */
-   -2,  /* (64) users ::= USERS INTEGER */
-    0,  /* (65) conns ::= */
-   -2,  /* (66) conns ::= CONNS INTEGER */
-    0,  /* (67) state ::= */
-   -2,  /* (68) state ::= STATE ids */
-   -9,  /* (69) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
-   -2,  /* (70) keep ::= KEEP tagitemlist */
-   -2,  /* (71) cache ::= CACHE INTEGER */
-   -2,  /* (72) replica ::= REPLICA INTEGER */
-   -2,  /* (73) quorum ::= QUORUM INTEGER */
-   -2,  /* (74) days ::= DAYS INTEGER */
-   -2,  /* (75) minrows ::= MINROWS INTEGER */
-   -2,  /* (76) maxrows ::= MAXROWS INTEGER */
-   -2,  /* (77) blocks ::= BLOCKS INTEGER */
-   -2,  /* (78) ctime ::= CTIME INTEGER */
-   -2,  /* (79) wal ::= WAL INTEGER */
-   -2,  /* (80) fsync ::= FSYNC INTEGER */
-   -2,  /* (81) comp ::= COMP INTEGER */
-   -2,  /* (82) prec ::= PRECISION STRING */
-    0,  /* (83) db_optr ::= */
-   -2,  /* (84) db_optr ::= db_optr cache */
-   -2,  /* (85) db_optr ::= db_optr replica */
-   -2,  /* (86) db_optr ::= db_optr quorum */
-   -2,  /* (87) db_optr ::= db_optr days */
-   -2,  /* (88) db_optr ::= db_optr minrows */
-   -2,  /* (89) db_optr ::= db_optr maxrows */
-   -2,  /* (90) db_optr ::= db_optr blocks */
-   -2,  /* (91) db_optr ::= db_optr ctime */
-   -2,  /* (92) db_optr ::= db_optr wal */
-   -2,  /* (93) db_optr ::= db_optr fsync */
-   -2,  /* (94) db_optr ::= db_optr comp */
-   -2,  /* (95) db_optr ::= db_optr prec */
-   -2,  /* (96) db_optr ::= db_optr keep */
-    0,  /* (97) alter_db_optr ::= */
-   -2,  /* (98) alter_db_optr ::= alter_db_optr replica */
-   -2,  /* (99) alter_db_optr ::= alter_db_optr quorum */
-   -2,  /* (100) alter_db_optr ::= alter_db_optr keep */
-   -2,  /* (101) alter_db_optr ::= alter_db_optr blocks */
-   -2,  /* (102) alter_db_optr ::= alter_db_optr comp */
-   -2,  /* (103) alter_db_optr ::= alter_db_optr wal */
-   -2,  /* (104) alter_db_optr ::= alter_db_optr fsync */
-   -1,  /* (105) typename ::= ids */
-   -4,  /* (106) typename ::= ids LP signed RP */
-   -1,  /* (107) signed ::= INTEGER */
-   -2,  /* (108) signed ::= PLUS INTEGER */
-   -2,  /* (109) signed ::= MINUS INTEGER */
-   -6,  /* (110) cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args */
-   -3,  /* (111) create_table_args ::= LP columnlist RP */
-   -7,  /* (112) create_table_args ::= LP columnlist RP TAGS LP columnlist RP */
-   -7,  /* (113) create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP */
-   -2,  /* (114) create_table_args ::= AS select */
-   -3,  /* (115) columnlist ::= columnlist COMMA column */
-   -1,  /* (116) columnlist ::= column */
-   -2,  /* (117) column ::= ids typename */
-   -3,  /* (118) tagitemlist ::= tagitemlist COMMA tagitem */
-   -1,  /* (119) tagitemlist ::= tagitem */
-   -1,  /* (120) tagitem ::= INTEGER */
-   -1,  /* (121) tagitem ::= FLOAT */
-   -1,  /* (122) tagitem ::= STRING */
-   -1,  /* (123) tagitem ::= BOOL */
-   -1,  /* (124) tagitem ::= NULL */
-   -2,  /* (125) tagitem ::= MINUS INTEGER */
-   -2,  /* (126) tagitem ::= MINUS FLOAT */
-   -2,  /* (127) tagitem ::= PLUS INTEGER */
-   -2,  /* (128) tagitem ::= PLUS FLOAT */
-  -12,  /* (129) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
-   -1,  /* (130) union ::= select */
-   -3,  /* (131) union ::= LP union RP */
-   -4,  /* (132) union ::= union UNION ALL select */
-   -6,  /* (133) union ::= union UNION ALL LP select RP */
-   -1,  /* (134) cmd ::= union */
-   -2,  /* (135) select ::= SELECT selcollist */
-   -2,  /* (136) sclp ::= selcollist COMMA */
-    0,  /* (137) sclp ::= */
-   -3,  /* (138) selcollist ::= sclp expr as */
-   -2,  /* (139) selcollist ::= sclp STAR */
-   -2,  /* (140) as ::= AS ids */
-   -1,  /* (141) as ::= ids */
-    0,  /* (142) as ::= */
-   -2,  /* (143) from ::= FROM tablelist */
-   -2,  /* (144) tablelist ::= ids cpxName */
-   -3,  /* (145) tablelist ::= ids cpxName ids */
-   -4,  /* (146) tablelist ::= tablelist COMMA ids cpxName */
-   -5,  /* (147) tablelist ::= tablelist COMMA ids cpxName ids */
-   -1,  /* (148) tmvar ::= VARIABLE */
-   -4,  /* (149) interval_opt ::= INTERVAL LP tmvar RP */
-   -6,  /* (150) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
-    0,  /* (151) interval_opt ::= */
-    0,  /* (152) fill_opt ::= */
-   -6,  /* (153) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
-   -4,  /* (154) fill_opt ::= FILL LP ID RP */
-   -4,  /* (155) sliding_opt ::= SLIDING LP tmvar RP */
-    0,  /* (156) sliding_opt ::= */
-    0,  /* (157) orderby_opt ::= */
-   -3,  /* (158) orderby_opt ::= ORDER BY sortlist */
-   -4,  /* (159) sortlist ::= sortlist COMMA item sortorder */
-   -2,  /* (160) sortlist ::= item sortorder */
-   -2,  /* (161) item ::= ids cpxName */
-   -1,  /* (162) sortorder ::= ASC */
-   -1,  /* (163) sortorder ::= DESC */
-    0,  /* (164) sortorder ::= */
-    0,  /* (165) groupby_opt ::= */
-   -3,  /* (166) groupby_opt ::= GROUP BY grouplist */
-   -3,  /* (167) grouplist ::= grouplist COMMA item */
-   -1,  /* (168) grouplist ::= item */
-    0,  /* (169) having_opt ::= */
-   -2,  /* (170) having_opt ::= HAVING expr */
-    0,  /* (171) limit_opt ::= */
-   -2,  /* (172) limit_opt ::= LIMIT signed */
-   -4,  /* (173) limit_opt ::= LIMIT signed OFFSET signed */
-   -4,  /* (174) limit_opt ::= LIMIT signed COMMA signed */
-    0,  /* (175) slimit_opt ::= */
-   -2,  /* (176) slimit_opt ::= SLIMIT signed */
-   -4,  /* (177) slimit_opt ::= SLIMIT signed SOFFSET signed */
-   -4,  /* (178) slimit_opt ::= SLIMIT signed COMMA signed */
-    0,  /* (179) where_opt ::= */
-   -2,  /* (180) where_opt ::= WHERE expr */
-   -3,  /* (181) expr ::= LP expr RP */
-   -1,  /* (182) expr ::= ID */
-   -3,  /* (183) expr ::= ID DOT ID */
-   -3,  /* (184) expr ::= ID DOT STAR */
-   -1,  /* (185) expr ::= INTEGER */
-   -2,  /* (186) expr ::= MINUS INTEGER */
-   -2,  /* (187) expr ::= PLUS INTEGER */
-   -1,  /* (188) expr ::= FLOAT */
-   -2,  /* (189) expr ::= MINUS FLOAT */
-   -2,  /* (190) expr ::= PLUS FLOAT */
-   -1,  /* (191) expr ::= STRING */
-   -1,  /* (192) expr ::= NOW */
-   -1,  /* (193) expr ::= VARIABLE */
-   -1,  /* (194) expr ::= BOOL */
-   -4,  /* (195) expr ::= ID LP exprlist RP */
-   -4,  /* (196) expr ::= ID LP STAR RP */
-   -3,  /* (197) expr ::= expr IS NULL */
-   -4,  /* (198) expr ::= expr IS NOT NULL */
-   -3,  /* (199) expr ::= expr LT expr */
-   -3,  /* (200) expr ::= expr GT expr */
-   -3,  /* (201) expr ::= expr LE expr */
-   -3,  /* (202) expr ::= expr GE expr */
-   -3,  /* (203) expr ::= expr NE expr */
-   -3,  /* (204) expr ::= expr EQ expr */
-   -3,  /* (205) expr ::= expr AND expr */
-   -3,  /* (206) expr ::= expr OR expr */
-   -3,  /* (207) expr ::= expr PLUS expr */
-   -3,  /* (208) expr ::= expr MINUS expr */
-   -3,  /* (209) expr ::= expr STAR expr */
-   -3,  /* (210) expr ::= expr SLASH expr */
-   -3,  /* (211) expr ::= expr REM expr */
-   -3,  /* (212) expr ::= expr LIKE expr */
-   -5,  /* (213) expr ::= expr IN LP exprlist RP */
-   -3,  /* (214) exprlist ::= exprlist COMMA expritem */
-   -1,  /* (215) exprlist ::= expritem */
-   -1,  /* (216) expritem ::= expr */
-    0,  /* (217) expritem ::= */
-   -3,  /* (218) cmd ::= RESET QUERY CACHE */
-   -7,  /* (219) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
-   -7,  /* (220) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
-   -7,  /* (221) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
-   -7,  /* (222) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
-   -8,  /* (223) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
-   -9,  /* (224) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
-   -3,  /* (225) cmd ::= KILL CONNECTION INTEGER */
-   -5,  /* (226) cmd ::= KILL STREAM INTEGER COLON INTEGER */
-   -5,  /* (227) cmd ::= KILL QUERY INTEGER COLON INTEGER */
+/* The following table contains information about every rule that
+** is used during the reduce.
+*/
+static const struct {
+  YYCODETYPE lhs;       /* Symbol on the left-hand side of the rule */
+  signed char nrhs;     /* Negative of the number of RHS symbols in the rule */
+} yyRuleInfo[] = {
+  {  207,   -1 }, /* (0) program ::= cmd */
+  {  208,   -2 }, /* (1) cmd ::= SHOW DATABASES */
+  {  208,   -2 }, /* (2) cmd ::= SHOW MNODES */
+  {  208,   -2 }, /* (3) cmd ::= SHOW DNODES */
+  {  208,   -2 }, /* (4) cmd ::= SHOW ACCOUNTS */
+  {  208,   -2 }, /* (5) cmd ::= SHOW USERS */
+  {  208,   -2 }, /* (6) cmd ::= SHOW MODULES */
+  {  208,   -2 }, /* (7) cmd ::= SHOW QUERIES */
+  {  208,   -2 }, /* (8) cmd ::= SHOW CONNECTIONS */
+  {  208,   -2 }, /* (9) cmd ::= SHOW STREAMS */
+  {  208,   -2 }, /* (10) cmd ::= SHOW VARIABLES */
+  {  208,   -2 }, /* (11) cmd ::= SHOW SCORES */
+  {  208,   -2 }, /* (12) cmd ::= SHOW GRANTS */
+  {  208,   -2 }, /* (13) cmd ::= SHOW VNODES */
+  {  208,   -3 }, /* (14) cmd ::= SHOW VNODES IPTOKEN */
+  {  209,    0 }, /* (15) dbPrefix ::= */
+  {  209,   -2 }, /* (16) dbPrefix ::= ids DOT */
+  {  211,    0 }, /* (17) cpxName ::= */
+  {  211,   -2 }, /* (18) cpxName ::= DOT ids */
+  {  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,   -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 */
@@ -2176,34 +1940,30 @@ static void yy_accept(yyParser*);  /* Forward Declaration */
 ** only called from one place, optimizing compilers will in-line it, which
 ** means that the extra parameters have no performance impact.
 */
-static YYACTIONTYPE yy_reduce(
+static void yy_reduce(
   yyParser *yypParser,         /* The parser */
   unsigned int yyruleno,       /* Number of the rule by which to reduce */
   int yyLookahead,             /* Lookahead token, or YYNOCODE if none */
   ParseTOKENTYPE yyLookaheadToken  /* Value of the lookahead token */
-  ParseCTX_PDECL                   /* %extra_context */
 ){
   int yygoto;                     /* The next state */
-  YYACTIONTYPE yyact;             /* The next action */
+  int yyact;                      /* The next action */
   yyStackEntry *yymsp;            /* The top of the parser's stack */
   int yysize;                     /* Amount to pop the stack */
-  ParseARG_FETCH
+  ParseARG_FETCH;
   (void)yyLookahead;
   (void)yyLookaheadToken;
   yymsp = yypParser->yytos;
 #ifndef NDEBUG
   if( yyTraceFILE && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
-    yysize = yyRuleInfoNRhs[yyruleno];
+    yysize = yyRuleInfo[yyruleno].nrhs;
     if( yysize ){
-      fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",
+      fprintf(yyTraceFILE, "%sReduce %d [%s], go to state %d.\n",
         yyTracePrompt,
-        yyruleno, yyRuleName[yyruleno],
-        yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action",
-        yymsp[yysize].stateno);
+        yyruleno, yyRuleName[yyruleno], yymsp[yysize].stateno);
     }else{
-      fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n",
-        yyTracePrompt, yyruleno, yyRuleName[yyruleno],
-        yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action");
+      fprintf(yyTraceFILE, "%sReduce %d [%s].\n",
+        yyTracePrompt, yyruleno, yyRuleName[yyruleno]);
     }
   }
 #endif /* NDEBUG */
@@ -2211,7 +1971,7 @@ static YYACTIONTYPE yy_reduce(
   /* Check that the stack is large enough to grow by a single entry
   ** if the RHS of the rule is empty.  This ensures that there is room
   ** enough on the stack to push the LHS value */
-  if( yyRuleInfoNRhs[yyruleno]==0 ){
+  if( yyRuleInfo[yyruleno].nrhs==0 ){
 #ifdef YYTRACKMAXSTACKDEPTH
     if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
       yypParser->yyhwm++;
@@ -2221,19 +1981,13 @@ static YYACTIONTYPE yy_reduce(
 #if YYSTACKDEPTH>0 
     if( yypParser->yytos>=yypParser->yystackEnd ){
       yyStackOverflow(yypParser);
-      /* The call to yyStackOverflow() above pops the stack until it is
-      ** empty, causing the main parser loop to exit.  So the return value
-      ** is never used and does not matter. */
-      return 0;
+      return;
     }
 #else
     if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){
       if( yyGrowStack(yypParser) ){
         yyStackOverflow(yypParser);
-        /* The call to yyStackOverflow() above pops the stack until it is
-        ** empty, causing the main parser loop to exit.  So the return value
-        ** is never used and does not matter. */
-        return 0;
+        return;
       }
       yymsp = yypParser->yytos;
     }
@@ -2309,708 +2063,719 @@ static YYACTIONTYPE 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 */
-{ SStrToken t = {0};  setCreateDBSQL(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy118, &t);}
+      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 */
-{ setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy479);}
+      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 */
-{ setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy479);}
+      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 */
-{ setCreateAcctSQL(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy479);}
+      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 */
-{ setCreateDBSQL(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy118, &yymsp[-2].minor.yy0);}
+      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.yy479.maxUsers   = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
-    yylhsminor.yy479.maxDbs     = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
-    yylhsminor.yy479.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
-    yylhsminor.yy479.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
-    yylhsminor.yy479.maxPointsPerSecond     = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
-    yylhsminor.yy479.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
-    yylhsminor.yy479.maxQueryTime   = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
-    yylhsminor.yy479.maxConnections   = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
-    yylhsminor.yy479.stat    = yymsp[0].minor.yy0;
-}
-  yymsp[-8].minor.yy479 = yylhsminor.yy479;
-        break;
-      case 70: /* keep ::= KEEP tagitemlist */
-{ yymsp[-1].minor.yy156 = yymsp[0].minor.yy156; }
-        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);
+    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;
+    yylhsminor.yy73.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
+    yylhsminor.yy73.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
+    yylhsminor.yy73.maxPointsPerSecond     = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
+    yylhsminor.yy73.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
+    yylhsminor.yy73.maxQueryTime   = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
+    yylhsminor.yy73.maxConnections   = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
+    yylhsminor.yy73.stat    = yymsp[0].minor.yy0;
+}
+  yymsp[-8].minor.yy73 = yylhsminor.yy73;
+        break;
+      case 72: /* keep ::= KEEP tagitemlist */
+{ yymsp[-1].minor.yy494 = yymsp[0].minor.yy494; }
+        break;
+      case 73: /* cache ::= CACHE INTEGER */
+      case 74: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==74);
+      case 75: /* quorum ::= QUORUM INTEGER */ yytestcase(yyruleno==75);
+      case 76: /* days ::= DAYS INTEGER */ yytestcase(yyruleno==76);
+      case 77: /* minrows ::= MINROWS INTEGER */ yytestcase(yyruleno==77);
+      case 78: /* maxrows ::= MAXROWS INTEGER */ yytestcase(yyruleno==78);
+      case 79: /* blocks ::= BLOCKS INTEGER */ yytestcase(yyruleno==79);
+      case 80: /* ctime ::= CTIME INTEGER */ yytestcase(yyruleno==80);
+      case 81: /* wal ::= WAL INTEGER */ yytestcase(yyruleno==81);
+      case 82: /* fsync ::= FSYNC INTEGER */ yytestcase(yyruleno==82);
+      case 83: /* comp ::= COMP INTEGER */ yytestcase(yyruleno==83);
+      case 84: /* prec ::= PRECISION STRING */ yytestcase(yyruleno==84);
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
         break;
-      case 83: /* db_optr ::= */
-{setDefaultCreateDbOption(&yymsp[1].minor.yy118);}
+      case 85: /* db_optr ::= */
+{setDefaultCreateDbOption(&yymsp[1].minor.yy158);}
         break;
-      case 84: /* db_optr ::= db_optr cache */
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy118 = yylhsminor.yy118;
+      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);
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy118 = yylhsminor.yy118;
+      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);
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy118 = yylhsminor.yy118;
+      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 */
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy118 = yylhsminor.yy118;
+      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 */
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
-  yymsp[-1].minor.yy118 = yylhsminor.yy118;
+      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 */
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
-  yymsp[-1].minor.yy118 = yylhsminor.yy118;
+      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);
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy118 = yylhsminor.yy118;
+      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 */
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy118 = yylhsminor.yy118;
+      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);
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy118 = yylhsminor.yy118;
+      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);
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy118 = yylhsminor.yy118;
+      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);
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy118 = yylhsminor.yy118;
+      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 */
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.precision = yymsp[0].minor.yy0; }
-  yymsp[-1].minor.yy118 = yylhsminor.yy118;
+      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);
-{ yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118.keep = yymsp[0].minor.yy156; }
-  yymsp[-1].minor.yy118 = yylhsminor.yy118;
+      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 ::= */
-{ setDefaultCreateDbOption(&yymsp[1].minor.yy118);}
+      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.yy343, &yymsp[0].minor.yy0); 
+  tSQLSetColumnType (&yylhsminor.yy181, &yymsp[0].minor.yy0); 
 }
-  yymsp[0].minor.yy343 = yylhsminor.yy343;
+  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.yy369 <= 0) {
+    if (yymsp[-1].minor.yy271 <= 0) {
       yymsp[-3].minor.yy0.type = 0;
-      tSQLSetColumnType(&yylhsminor.yy343, &yymsp[-3].minor.yy0);
+      tSQLSetColumnType(&yylhsminor.yy181, &yymsp[-3].minor.yy0);
     } else {
-      yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy369;          // negative value of name length
-      tSQLSetColumnType(&yylhsminor.yy343, &yymsp[-3].minor.yy0);
+      yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy271;          // negative value of name length
+      tSQLSetColumnType(&yylhsminor.yy181, &yymsp[-3].minor.yy0);
     }
 }
-  yymsp[-3].minor.yy343 = yylhsminor.yy343;
+  yymsp[-3].minor.yy181 = yylhsminor.yy181;
         break;
-      case 107: /* signed ::= INTEGER */
-{ yylhsminor.yy369 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[0].minor.yy369 = yylhsminor.yy369;
+      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 */
-{ yymsp[-1].minor.yy369 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+      case 110: /* signed ::= PLUS INTEGER */
+{ yymsp[-1].minor.yy271 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
         break;
-      case 109: /* signed ::= MINUS INTEGER */
-{ yymsp[-1].minor.yy369 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
+      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.yy398 = tSetCreateSQLElems(yymsp[-1].minor.yy511, NULL, NULL, NULL, NULL, TSQL_CREATE_TABLE);
-    setSQLInfo(pInfo, yymsp[-2].minor.yy398, NULL, TSDB_SQL_CREATE_TABLE);
+    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.yy398 = tSetCreateSQLElems(yymsp[-5].minor.yy511, yymsp[-1].minor.yy511, NULL, NULL, NULL, TSQL_CREATE_STABLE);
-    setSQLInfo(pInfo, yymsp[-6].minor.yy398, NULL, TSDB_SQL_CREATE_TABLE);
+    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.yy398 = tSetCreateSQLElems(NULL, NULL, &yymsp[-5].minor.yy0, yymsp[-1].minor.yy156, NULL, TSQL_CREATE_TABLE_FROM_STABLE);
-    setSQLInfo(pInfo, yymsp[-6].minor.yy398, NULL, TSDB_SQL_CREATE_TABLE);
+    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.yy398 = tSetCreateSQLElems(NULL, NULL, NULL, NULL, yymsp[0].minor.yy444, TSQL_CREATE_STREAM);
-    setSQLInfo(pInfo, yymsp[-1].minor.yy398, NULL, TSDB_SQL_CREATE_TABLE);
+    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 */
-{yylhsminor.yy511 = tFieldListAppend(yymsp[-2].minor.yy511, &yymsp[0].minor.yy343);   }
-  yymsp[-2].minor.yy511 = yylhsminor.yy511;
+      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 */
-{yylhsminor.yy511 = tFieldListAppend(NULL, &yymsp[0].minor.yy343);}
-  yymsp[0].minor.yy511 = yylhsminor.yy511;
+      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.yy343, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy343);
+    tSQLSetColumnInfo(&yylhsminor.yy181, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy181);
 }
-  yymsp[-1].minor.yy343 = yylhsminor.yy343;
+  yymsp[-1].minor.yy181 = yylhsminor.yy181;
         break;
-      case 118: /* tagitemlist ::= tagitemlist COMMA tagitem */
-{ yylhsminor.yy156 = tVariantListAppend(yymsp[-2].minor.yy156, &yymsp[0].minor.yy506, -1);    }
-  yymsp[-2].minor.yy156 = yylhsminor.yy156;
+      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 */
-{ yylhsminor.yy156 = tVariantListAppend(NULL, &yymsp[0].minor.yy506, -1); }
-  yymsp[0].minor.yy156 = yylhsminor.yy156;
+      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);
-{toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy506, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy506 = yylhsminor.yy506;
+      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 */
-{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy506, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy506 = yylhsminor.yy506;
+      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;
     toTSDBType(yymsp[-1].minor.yy0.type);
-    tVariantCreate(&yylhsminor.yy506, &yymsp[-1].minor.yy0);
+    tVariantCreate(&yylhsminor.yy312, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy506 = yylhsminor.yy506;
+  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.yy444 = tSetQuerySQLElems(&yymsp[-11].minor.yy0, yymsp[-10].minor.yy158, yymsp[-9].minor.yy156, yymsp[-8].minor.yy190, yymsp[-4].minor.yy156, yymsp[-3].minor.yy156, &yymsp[-7].minor.yy340, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy156, &yymsp[0].minor.yy414, &yymsp[-1].minor.yy414);
+  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.yy444 = yylhsminor.yy444;
+  yymsp[-11].minor.yy150 = yylhsminor.yy150;
         break;
-      case 130: /* union ::= select */
-{ yylhsminor.yy333 = setSubclause(NULL, yymsp[0].minor.yy444); }
-  yymsp[0].minor.yy333 = yylhsminor.yy333;
+      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 */
-{ yymsp[-2].minor.yy333 = yymsp[-1].minor.yy333; }
+      case 133: /* union ::= LP union RP */
+{ yymsp[-2].minor.yy25 = yymsp[-1].minor.yy25; }
         break;
-      case 132: /* union ::= union UNION ALL select */
-{ yylhsminor.yy333 = appendSelectClause(yymsp[-3].minor.yy333, yymsp[0].minor.yy444); }
-  yymsp[-3].minor.yy333 = yylhsminor.yy333;
+      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 */
-{ yylhsminor.yy333 = appendSelectClause(yymsp[-5].minor.yy333, yymsp[-1].minor.yy444); }
-  yymsp[-5].minor.yy333 = yylhsminor.yy333;
+      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 */
-{ setSQLInfo(pInfo, yymsp[0].minor.yy333, NULL, TSDB_SQL_SELECT); }
+      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.yy444 = tSetQuerySQLElems(&yymsp[-1].minor.yy0, yymsp[0].minor.yy158, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+  yylhsminor.yy150 = tSetQuerySQLElems(&yymsp[-1].minor.yy0, yymsp[0].minor.yy224, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
-  yymsp[-1].minor.yy444 = yylhsminor.yy444;
+  yymsp[-1].minor.yy150 = yylhsminor.yy150;
         break;
-      case 136: /* sclp ::= selcollist COMMA */
-{yylhsminor.yy158 = yymsp[-1].minor.yy158;}
-  yymsp[-1].minor.yy158 = yylhsminor.yy158;
+      case 138: /* sclp ::= selcollist COMMA */
+{yylhsminor.yy224 = yymsp[-1].minor.yy224;}
+  yymsp[-1].minor.yy224 = yylhsminor.yy224;
         break;
-      case 137: /* sclp ::= */
-{yymsp[1].minor.yy158 = 0;}
+      case 139: /* sclp ::= */
+{yymsp[1].minor.yy224 = 0;}
         break;
-      case 138: /* selcollist ::= sclp expr as */
+      case 140: /* selcollist ::= sclp expr as */
 {
-   yylhsminor.yy158 = tSQLExprListAppend(yymsp[-2].minor.yy158, yymsp[-1].minor.yy190, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
+   yylhsminor.yy224 = tSQLExprListAppend(yymsp[-2].minor.yy224, yymsp[-1].minor.yy66, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
 }
-  yymsp[-2].minor.yy158 = yylhsminor.yy158;
+  yymsp[-2].minor.yy224 = yylhsminor.yy224;
         break;
-      case 139: /* selcollist ::= sclp STAR */
+      case 141: /* selcollist ::= sclp STAR */
 {
    tSQLExpr *pNode = tSQLExprIdValueCreate(NULL, TK_ALL);
-   yylhsminor.yy158 = tSQLExprListAppend(yymsp[-1].minor.yy158, pNode, 0);
+   yylhsminor.yy224 = tSQLExprListAppend(yymsp[-1].minor.yy224, pNode, 0);
 }
-  yymsp[-1].minor.yy158 = yylhsminor.yy158;
+  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 */
-{yymsp[-1].minor.yy156 = yymsp[0].minor.yy156;}
+      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;
-  yylhsminor.yy156 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
-  yylhsminor.yy156 = tVariantListAppendToken(yylhsminor.yy156, &yymsp[-1].minor.yy0, -1);  // table alias name
+  yylhsminor.yy494 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
+  yylhsminor.yy494 = tVariantListAppendToken(yylhsminor.yy494, &yymsp[-1].minor.yy0, -1);  // table alias name
 }
-  yymsp[-1].minor.yy156 = yylhsminor.yy156;
+  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);
    yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
-   yylhsminor.yy156 = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
-   yylhsminor.yy156 = tVariantListAppendToken(yylhsminor.yy156, &yymsp[0].minor.yy0, -1);
+   yylhsminor.yy494 = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
+   yylhsminor.yy494 = tVariantListAppendToken(yylhsminor.yy494, &yymsp[0].minor.yy0, -1);
 }
-  yymsp[-2].minor.yy156 = yylhsminor.yy156;
+  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;
-  yylhsminor.yy156 = tVariantListAppendToken(yymsp[-3].minor.yy156, &yymsp[-1].minor.yy0, -1);
-  yylhsminor.yy156 = tVariantListAppendToken(yylhsminor.yy156, &yymsp[-1].minor.yy0, -1);
+  yylhsminor.yy494 = tVariantListAppendToken(yymsp[-3].minor.yy494, &yymsp[-1].minor.yy0, -1);
+  yylhsminor.yy494 = tVariantListAppendToken(yylhsminor.yy494, &yymsp[-1].minor.yy0, -1);
 }
-  yymsp[-3].minor.yy156 = yylhsminor.yy156;
+  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);
    yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
-   yylhsminor.yy156 = tVariantListAppendToken(yymsp[-4].minor.yy156, &yymsp[-2].minor.yy0, -1);
-   yylhsminor.yy156 = tVariantListAppendToken(yylhsminor.yy156, &yymsp[0].minor.yy0, -1);
+   yylhsminor.yy494 = tVariantListAppendToken(yymsp[-4].minor.yy494, &yymsp[-2].minor.yy0, -1);
+   yylhsminor.yy494 = tVariantListAppendToken(yylhsminor.yy494, &yymsp[0].minor.yy0, -1);
 }
-  yymsp[-4].minor.yy156 = yylhsminor.yy156;
+  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 */
-{yymsp[-3].minor.yy340.interval = yymsp[-1].minor.yy0; yymsp[-3].minor.yy340.offset.n = 0; yymsp[-3].minor.yy340.offset.z = NULL; yymsp[-3].minor.yy340.offset.type = 0;}
+      case 151: /* interval_opt ::= INTERVAL LP tmvar RP */
+{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 150: /* interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
-{yymsp[-5].minor.yy340.interval = yymsp[-3].minor.yy0; yymsp[-5].minor.yy340.offset = yymsp[-1].minor.yy0;}
+      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 151: /* interval_opt ::= */
-{memset(&yymsp[1].minor.yy340, 0, sizeof(yymsp[1].minor.yy340));}
+      case 153: /* interval_opt ::= */
+{memset(&yymsp[1].minor.yy314, 0, sizeof(yymsp[1].minor.yy314));}
         break;
-      case 152: /* fill_opt ::= */
-{yymsp[1].minor.yy156 = 0;     }
+      case 154: /* fill_opt ::= */
+{yymsp[1].minor.yy494 = 0;     }
         break;
-      case 153: /* 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);
     tVariantCreate(&A, &yymsp[-3].minor.yy0);
 
-    tVariantListInsert(yymsp[-1].minor.yy156, &A, -1, 0);
-    yymsp[-5].minor.yy156 = yymsp[-1].minor.yy156;
+    tVariantListInsert(yymsp[-1].minor.yy494, &A, -1, 0);
+    yymsp[-5].minor.yy494 = yymsp[-1].minor.yy494;
 }
         break;
-      case 154: /* fill_opt ::= FILL LP ID RP */
+      case 156: /* fill_opt ::= FILL LP ID RP */
 {
     toTSDBType(yymsp[-1].minor.yy0.type);
-    yymsp[-3].minor.yy156 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
+    yymsp[-3].minor.yy494 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
 }
         break;
-      case 155: /* sliding_opt ::= SLIDING LP tmvar RP */
+      case 157: /* sliding_opt ::= SLIDING LP tmvar RP */
 {yymsp[-3].minor.yy0 = yymsp[-1].minor.yy0;     }
         break;
-      case 156: /* sliding_opt ::= */
+      case 158: /* sliding_opt ::= */
 {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0;   }
         break;
-      case 157: /* orderby_opt ::= */
-      case 165: /* groupby_opt ::= */ yytestcase(yyruleno==165);
-{yymsp[1].minor.yy156 = 0;}
+      case 159: /* orderby_opt ::= */
+      case 167: /* groupby_opt ::= */ yytestcase(yyruleno==167);
+{yymsp[1].minor.yy494 = 0;}
         break;
-      case 158: /* orderby_opt ::= ORDER BY sortlist */
-      case 166: /* groupby_opt ::= GROUP BY grouplist */ yytestcase(yyruleno==166);
-{yymsp[-2].minor.yy156 = yymsp[0].minor.yy156;}
+      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 159: /* sortlist ::= sortlist COMMA item sortorder */
+      case 161: /* sortlist ::= sortlist COMMA item sortorder */
 {
-    yylhsminor.yy156 = tVariantListAppend(yymsp[-3].minor.yy156, &yymsp[-1].minor.yy506, yymsp[0].minor.yy112);
+    yylhsminor.yy494 = tVariantListAppend(yymsp[-3].minor.yy494, &yymsp[-1].minor.yy312, yymsp[0].minor.yy82);
 }
-  yymsp[-3].minor.yy156 = yylhsminor.yy156;
+  yymsp[-3].minor.yy494 = yylhsminor.yy494;
         break;
-      case 160: /* sortlist ::= item sortorder */
+      case 162: /* sortlist ::= item sortorder */
 {
-  yylhsminor.yy156 = tVariantListAppend(NULL, &yymsp[-1].minor.yy506, yymsp[0].minor.yy112);
+  yylhsminor.yy494 = tVariantListAppend(NULL, &yymsp[-1].minor.yy312, yymsp[0].minor.yy82);
 }
-  yymsp[-1].minor.yy156 = yylhsminor.yy156;
+  yymsp[-1].minor.yy494 = yylhsminor.yy494;
         break;
-      case 161: /* item ::= ids cpxName */
+      case 163: /* item ::= ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
 
-  tVariantCreate(&yylhsminor.yy506, &yymsp[-1].minor.yy0);
+  tVariantCreate(&yylhsminor.yy312, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy506 = yylhsminor.yy506;
+  yymsp[-1].minor.yy312 = yylhsminor.yy312;
         break;
-      case 162: /* sortorder ::= ASC */
-{yymsp[0].minor.yy112 = TSDB_ORDER_ASC; }
+      case 164: /* sortorder ::= ASC */
+{yymsp[0].minor.yy82 = TSDB_ORDER_ASC; }
         break;
-      case 163: /* sortorder ::= DESC */
-{yymsp[0].minor.yy112 = TSDB_ORDER_DESC;}
+      case 165: /* sortorder ::= DESC */
+{yymsp[0].minor.yy82 = TSDB_ORDER_DESC;}
         break;
-      case 164: /* sortorder ::= */
-{yymsp[1].minor.yy112 = TSDB_ORDER_ASC;}
+      case 166: /* sortorder ::= */
+{yymsp[1].minor.yy82 = TSDB_ORDER_ASC;}
         break;
-      case 167: /* grouplist ::= grouplist COMMA item */
+      case 169: /* grouplist ::= grouplist COMMA item */
 {
-  yylhsminor.yy156 = tVariantListAppend(yymsp[-2].minor.yy156, &yymsp[0].minor.yy506, -1);
+  yylhsminor.yy494 = tVariantListAppend(yymsp[-2].minor.yy494, &yymsp[0].minor.yy312, -1);
 }
-  yymsp[-2].minor.yy156 = yylhsminor.yy156;
+  yymsp[-2].minor.yy494 = yylhsminor.yy494;
         break;
-      case 168: /* grouplist ::= item */
+      case 170: /* grouplist ::= item */
 {
-  yylhsminor.yy156 = tVariantListAppend(NULL, &yymsp[0].minor.yy506, -1);
+  yylhsminor.yy494 = tVariantListAppend(NULL, &yymsp[0].minor.yy312, -1);
 }
-  yymsp[0].minor.yy156 = yylhsminor.yy156;
+  yymsp[0].minor.yy494 = yylhsminor.yy494;
         break;
-      case 169: /* having_opt ::= */
-      case 179: /* where_opt ::= */ yytestcase(yyruleno==179);
-      case 217: /* expritem ::= */ yytestcase(yyruleno==217);
-{yymsp[1].minor.yy190 = 0;}
+      case 171: /* having_opt ::= */
+      case 181: /* where_opt ::= */ yytestcase(yyruleno==181);
+      case 219: /* expritem ::= */ yytestcase(yyruleno==219);
+{yymsp[1].minor.yy66 = 0;}
         break;
-      case 170: /* having_opt ::= HAVING expr */
-      case 180: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==180);
-{yymsp[-1].minor.yy190 = yymsp[0].minor.yy190;}
+      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 171: /* limit_opt ::= */
-      case 175: /* slimit_opt ::= */ yytestcase(yyruleno==175);
-{yymsp[1].minor.yy414.limit = -1; yymsp[1].minor.yy414.offset = 0;}
+      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 172: /* limit_opt ::= LIMIT signed */
-      case 176: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==176);
-{yymsp[-1].minor.yy414.limit = yymsp[0].minor.yy369;  yymsp[-1].minor.yy414.offset = 0;}
+      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 173: /* limit_opt ::= LIMIT signed OFFSET signed */
-      case 177: /* slimit_opt ::= SLIMIT signed SOFFSET signed */ yytestcase(yyruleno==177);
-{yymsp[-3].minor.yy414.limit = yymsp[-2].minor.yy369;  yymsp[-3].minor.yy414.offset = yymsp[0].minor.yy369;}
+      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 174: /* limit_opt ::= LIMIT signed COMMA signed */
-      case 178: /* slimit_opt ::= SLIMIT signed COMMA signed */ yytestcase(yyruleno==178);
-{yymsp[-3].minor.yy414.limit = yymsp[0].minor.yy369;  yymsp[-3].minor.yy414.offset = yymsp[-2].minor.yy369;}
+      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 181: /* expr ::= LP expr RP */
-{yymsp[-2].minor.yy190 = yymsp[-1].minor.yy190; }
+      case 183: /* expr ::= LP expr RP */
+{yymsp[-2].minor.yy66 = yymsp[-1].minor.yy66; }
         break;
-      case 182: /* expr ::= ID */
-{yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_ID);}
-  yymsp[0].minor.yy190 = yylhsminor.yy190;
+      case 184: /* expr ::= ID */
+{yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_ID);}
+  yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 183: /* expr ::= ID DOT ID */
-{yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ID);}
-  yymsp[-2].minor.yy190 = yylhsminor.yy190;
+      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 184: /* expr ::= ID DOT STAR */
-{yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ALL);}
-  yymsp[-2].minor.yy190 = yylhsminor.yy190;
+      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 185: /* expr ::= INTEGER */
-{yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_INTEGER);}
-  yymsp[0].minor.yy190 = yylhsminor.yy190;
+      case 187: /* expr ::= INTEGER */
+{yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_INTEGER);}
+  yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 186: /* expr ::= MINUS INTEGER */
-      case 187: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==187);
-{yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_INTEGER);}
-  yymsp[-1].minor.yy190 = yylhsminor.yy190;
+      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 188: /* expr ::= FLOAT */
-{yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_FLOAT);}
-  yymsp[0].minor.yy190 = yylhsminor.yy190;
+      case 190: /* expr ::= FLOAT */
+{yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_FLOAT);}
+  yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 189: /* expr ::= MINUS FLOAT */
-      case 190: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==190);
-{yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_FLOAT);}
-  yymsp[-1].minor.yy190 = yylhsminor.yy190;
+      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 191: /* expr ::= STRING */
-{yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_STRING);}
-  yymsp[0].minor.yy190 = yylhsminor.yy190;
+      case 193: /* expr ::= STRING */
+{yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_STRING);}
+  yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 192: /* expr ::= NOW */
-{yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_NOW); }
-  yymsp[0].minor.yy190 = yylhsminor.yy190;
+      case 194: /* expr ::= NOW */
+{yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_NOW); }
+  yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 193: /* expr ::= VARIABLE */
-{yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_VARIABLE);}
-  yymsp[0].minor.yy190 = yylhsminor.yy190;
+      case 195: /* expr ::= VARIABLE */
+{yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_VARIABLE);}
+  yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 194: /* expr ::= BOOL */
-{yylhsminor.yy190 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_BOOL);}
-  yymsp[0].minor.yy190 = yylhsminor.yy190;
+      case 196: /* expr ::= BOOL */
+{yylhsminor.yy66 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_BOOL);}
+  yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 195: /* expr ::= ID LP exprlist RP */
-{ yylhsminor.yy190 = tSQLExprCreateFunction(yymsp[-1].minor.yy158, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
-  yymsp[-3].minor.yy190 = yylhsminor.yy190;
+      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 196: /* expr ::= ID LP STAR RP */
-{ yylhsminor.yy190 = tSQLExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
-  yymsp[-3].minor.yy190 = yylhsminor.yy190;
+      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 197: /* expr ::= expr IS NULL */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, NULL, TK_ISNULL);}
-  yymsp[-2].minor.yy190 = yylhsminor.yy190;
+      case 199: /* expr ::= expr IS NULL */
+{yylhsminor.yy66 = tSQLExprCreate(yymsp[-2].minor.yy66, NULL, TK_ISNULL);}
+  yymsp[-2].minor.yy66 = yylhsminor.yy66;
         break;
-      case 198: /* expr ::= expr IS NOT NULL */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-3].minor.yy190, NULL, TK_NOTNULL);}
-  yymsp[-3].minor.yy190 = yylhsminor.yy190;
+      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 199: /* expr ::= expr LT expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_LT);}
-  yymsp[-2].minor.yy190 = yylhsminor.yy190;
+      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 200: /* expr ::= expr GT expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_GT);}
-  yymsp[-2].minor.yy190 = yylhsminor.yy190;
+      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 201: /* expr ::= expr LE expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_LE);}
-  yymsp[-2].minor.yy190 = yylhsminor.yy190;
+      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 202: /* expr ::= expr GE expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_GE);}
-  yymsp[-2].minor.yy190 = yylhsminor.yy190;
+      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 203: /* expr ::= expr NE expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_NE);}
-  yymsp[-2].minor.yy190 = yylhsminor.yy190;
+      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 204: /* expr ::= expr EQ expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_EQ);}
-  yymsp[-2].minor.yy190 = yylhsminor.yy190;
+      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 205: /* expr ::= expr AND expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_AND);}
-  yymsp[-2].minor.yy190 = yylhsminor.yy190;
+      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 206: /* expr ::= expr OR expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_OR); }
-  yymsp[-2].minor.yy190 = yylhsminor.yy190;
+      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 207: /* expr ::= expr PLUS expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_PLUS);  }
-  yymsp[-2].minor.yy190 = yylhsminor.yy190;
+      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 208: /* expr ::= expr MINUS expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_MINUS); }
-  yymsp[-2].minor.yy190 = yylhsminor.yy190;
+      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 209: /* expr ::= expr STAR expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_STAR);  }
-  yymsp[-2].minor.yy190 = yylhsminor.yy190;
+      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 210: /* expr ::= expr SLASH expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_DIVIDE);}
-  yymsp[-2].minor.yy190 = yylhsminor.yy190;
+      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 211: /* expr ::= expr REM expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_REM);   }
-  yymsp[-2].minor.yy190 = yylhsminor.yy190;
+      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 212: /* expr ::= expr LIKE expr */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-2].minor.yy190, yymsp[0].minor.yy190, TK_LIKE);  }
-  yymsp[-2].minor.yy190 = yylhsminor.yy190;
+      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 213: /* expr ::= expr IN LP exprlist RP */
-{yylhsminor.yy190 = tSQLExprCreate(yymsp[-4].minor.yy190, (tSQLExpr*)yymsp[-1].minor.yy158, TK_IN); }
-  yymsp[-4].minor.yy190 = yylhsminor.yy190;
+      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 214: /* exprlist ::= exprlist COMMA expritem */
-{yylhsminor.yy158 = tSQLExprListAppend(yymsp[-2].minor.yy158,yymsp[0].minor.yy190,0);}
-  yymsp[-2].minor.yy158 = yylhsminor.yy158;
+      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 215: /* exprlist ::= expritem */
-{yylhsminor.yy158 = tSQLExprListAppend(0,yymsp[0].minor.yy190,0);}
-  yymsp[0].minor.yy158 = yylhsminor.yy158;
+      case 217: /* exprlist ::= expritem */
+{yylhsminor.yy224 = tSQLExprListAppend(0,yymsp[0].minor.yy66,0);}
+  yymsp[0].minor.yy224 = yylhsminor.yy224;
         break;
-      case 216: /* expritem ::= expr */
-{yylhsminor.yy190 = yymsp[0].minor.yy190;}
-  yymsp[0].minor.yy190 = yylhsminor.yy190;
+      case 218: /* expritem ::= expr */
+{yylhsminor.yy66 = yymsp[0].minor.yy66;}
+  yymsp[0].minor.yy66 = yylhsminor.yy66;
         break;
-      case 218: /* cmd ::= RESET QUERY CACHE */
+      case 220: /* cmd ::= RESET QUERY CACHE */
 { setDCLSQLElems(pInfo, TSDB_SQL_RESET_CACHE, 0);}
         break;
-      case 219: /* 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.yy511, NULL, TSDB_ALTER_TABLE_ADD_COLUMN);
+    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 220: /* 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;
 
@@ -3021,14 +2786,14 @@ static YYACTIONTYPE yy_reduce(
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 221: /* 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.yy511, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN);
+    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 222: /* 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;
 
@@ -3039,7 +2804,7 @@ static YYACTIONTYPE yy_reduce(
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 223: /* 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;
 
@@ -3053,34 +2818,34 @@ static YYACTIONTYPE yy_reduce(
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 224: /* 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;
 
     toTSDBType(yymsp[-2].minor.yy0.type);
     tVariantList* A = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
-    A = tVariantListAppend(A, &yymsp[0].minor.yy506, -1);
+    A = tVariantListAppend(A, &yymsp[0].minor.yy312, -1);
 
     SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL);
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 225: /* cmd ::= KILL CONNECTION INTEGER */
+      case 227: /* cmd ::= KILL CONNECTION INTEGER */
 {setKillSQL(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);}
         break;
-      case 226: /* 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 227: /* 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:
         break;
 /********** End reduce actions ************************************************/
   };
-  assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) );
-  yygoto = yyRuleInfoLhs[yyruleno];
-  yysize = yyRuleInfoNRhs[yyruleno];
+  assert( yyruleno<sizeof(yyRuleInfo)/sizeof(yyRuleInfo[0]) );
+  yygoto = yyRuleInfo[yyruleno].lhs;
+  yysize = yyRuleInfo[yyruleno].nrhs;
   yyact = yy_find_reduce_action(yymsp[yysize].stateno,(YYCODETYPE)yygoto);
 
   /* There are no SHIFTREDUCE actions on nonterminals because the table
@@ -3095,7 +2860,6 @@ static YYACTIONTYPE yy_reduce(
   yymsp->stateno = (YYACTIONTYPE)yyact;
   yymsp->major = (YYCODETYPE)yygoto;
   yyTraceShift(yypParser, yyact, "... then shift");
-  return yyact;
 }
 
 /*
@@ -3105,8 +2869,7 @@ static YYACTIONTYPE yy_reduce(
 static void yy_parse_failed(
   yyParser *yypParser           /* The parser */
 ){
-  ParseARG_FETCH
-  ParseCTX_FETCH
+  ParseARG_FETCH;
 #ifndef NDEBUG
   if( yyTraceFILE ){
     fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);
@@ -3117,8 +2880,7 @@ static void yy_parse_failed(
   ** parser fails */
 /************ Begin %parse_failure code ***************************************/
 /************ End %parse_failure code *****************************************/
-  ParseARG_STORE /* Suppress warning about unused %extra_argument variable */
-  ParseCTX_STORE
+  ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
 }
 #endif /* YYNOERRORRECOVERY */
 
@@ -3130,8 +2892,7 @@ static void yy_syntax_error(
   int yymajor,                   /* The major type of the error token */
   ParseTOKENTYPE yyminor         /* The minor type of the error token */
 ){
-  ParseARG_FETCH
-  ParseCTX_FETCH
+  ParseARG_FETCH;
 #define TOKEN yyminor
 /************ Begin %syntax_error code ****************************************/
 
@@ -3157,8 +2918,7 @@ static void yy_syntax_error(
 
   assert(len <= outputBufLen);
 /************ End %syntax_error code ******************************************/
-  ParseARG_STORE /* Suppress warning about unused %extra_argument variable */
-  ParseCTX_STORE
+  ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
 }
 
 /*
@@ -3167,8 +2927,7 @@ static void yy_syntax_error(
 static void yy_accept(
   yyParser *yypParser           /* The parser */
 ){
-  ParseARG_FETCH
-  ParseCTX_FETCH
+  ParseARG_FETCH;
 #ifndef NDEBUG
   if( yyTraceFILE ){
     fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
@@ -3183,8 +2942,7 @@ static void yy_accept(
 /*********** Begin %parse_accept code *****************************************/
 
 /*********** End %parse_accept code *******************************************/
-  ParseARG_STORE /* Suppress warning about unused %extra_argument variable */
-  ParseCTX_STORE
+  ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
 }
 
 /* The main parser program.
@@ -3213,47 +2971,45 @@ void Parse(
   ParseARG_PDECL               /* Optional %extra_argument parameter */
 ){
   YYMINORTYPE yyminorunion;
-  YYACTIONTYPE yyact;   /* The parser action. */
+  unsigned int yyact;   /* The parser action. */
 #if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
   int yyendofinput;     /* True if we are at the end of input */
 #endif
 #ifdef YYERRORSYMBOL
   int yyerrorhit = 0;   /* True if yymajor has invoked an error */
 #endif
-  yyParser *yypParser = (yyParser*)yyp;  /* The parser */
-  ParseCTX_FETCH
-  ParseARG_STORE
+  yyParser *yypParser;  /* The parser */
 
+  yypParser = (yyParser*)yyp;
   assert( yypParser->yytos!=0 );
 #if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
   yyendofinput = (yymajor==0);
 #endif
+  ParseARG_STORE;
 
-  yyact = yypParser->yytos->stateno;
 #ifndef NDEBUG
   if( yyTraceFILE ){
-    if( yyact < YY_MIN_REDUCE ){
+    int stateno = yypParser->yytos->stateno;
+    if( stateno < YY_MIN_REDUCE ){
       fprintf(yyTraceFILE,"%sInput '%s' in state %d\n",
-              yyTracePrompt,yyTokenName[yymajor],yyact);
+              yyTracePrompt,yyTokenName[yymajor],stateno);
     }else{
       fprintf(yyTraceFILE,"%sInput '%s' with pending reduce %d\n",
-              yyTracePrompt,yyTokenName[yymajor],yyact-YY_MIN_REDUCE);
+              yyTracePrompt,yyTokenName[yymajor],stateno-YY_MIN_REDUCE);
     }
   }
 #endif
 
   do{
-    assert( yyact==yypParser->yytos->stateno );
-    yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact);
+    yyact = yy_find_shift_action(yypParser,(YYCODETYPE)yymajor);
     if( yyact >= YY_MIN_REDUCE ){
-      yyact = yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor,
-                        yyminor ParseCTX_PARAM);
+      yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor,yyminor);
     }else if( yyact <= YY_MAX_SHIFTREDUCE ){
-      yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor);
+      yy_shift(yypParser,yyact,yymajor,yyminor);
 #ifndef YYNOERRORRECOVERY
       yypParser->yyerrcnt--;
 #endif
-      break;
+      yymajor = YYNOCODE;
     }else if( yyact==YY_ACCEPT_ACTION ){
       yypParser->yytos--;
       yy_accept(yypParser);
@@ -3304,9 +3060,10 @@ void Parse(
         yymajor = YYNOCODE;
       }else{
         while( yypParser->yytos >= yypParser->yystack
+            && yymx != YYERRORSYMBOL
             && (yyact = yy_find_reduce_action(
                         yypParser->yytos->stateno,
-                        YYERRORSYMBOL)) > YY_MAX_SHIFTREDUCE
+                        YYERRORSYMBOL)) >= YY_MIN_REDUCE
         ){
           yy_pop_parser_stack(yypParser);
         }
@@ -3323,8 +3080,6 @@ void Parse(
       }
       yypParser->yyerrcnt = 3;
       yyerrorhit = 1;
-      if( yymajor==YYNOCODE ) break;
-      yyact = yypParser->yytos->stateno;
 #elif defined(YYNOERRORRECOVERY)
       /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
       ** do any kind of error recovery.  Instead, simply invoke the syntax
@@ -3335,7 +3090,8 @@ void Parse(
       */
       yy_syntax_error(yypParser,yymajor, yyminor);
       yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
-      break;
+      yymajor = YYNOCODE;
+      
 #else  /* YYERRORSYMBOL is not defined */
       /* This is what we do if the grammar does not define ERROR:
       **
@@ -3357,10 +3113,10 @@ void Parse(
         yypParser->yyerrcnt = -1;
 #endif
       }
-      break;
+      yymajor = YYNOCODE;
 #endif
     }
-  }while( yypParser->yytos>yypParser->yystack );
+  }while( yymajor!=YYNOCODE && yypParser->yytos>yypParser->yystack );
 #ifndef NDEBUG
   if( yyTraceFILE ){
     yyStackEntry *i;
@@ -3375,17 +3131,3 @@ void Parse(
 #endif
   return;
 }
-
-/*
-** Return the fallback token corresponding to canonical token iToken, or
-** 0 if iToken has no fallback.
-*/
-int ParseFallback(int iToken){
-#ifdef YYFALLBACK
-  assert( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) );
-  return yyFallback[iToken];
-#else
-  (void)iToken;
-  return 0;
-#endif
-}

src/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 sqlObj cache", pCacheObj->name, key);
     return NULL;
   }
 
@@ -280,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);

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;
@@ -390,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);
     }
 

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;
   }

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;
+  }
 }

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();
     }
 
-
 }

tests/gotest/batchtest.sh

+#!/bin/bash
+
+bash ./case001/case001.sh
+#bash ./case002/case002.sh
+#bash ./case003/case003.sh

tests/gotest/case001/case001.go

+/*
+ * 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)
+	}
+}

tests/gotest/case001/case001.sh

+#!/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

tests/gotest/test.sh

+#!/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
+

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
@@ -154,6 +155,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
@@ -195,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

tests/pytest/insert/retentionpolicy.py

+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import 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)
+        queryRows=tdSql.query('select * from test')
+        if queryRows==4:
+            tdSql.checkRows(4)
+            return 0
+        else:
+            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)
+        queryRows=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()
+

tests/pytest/stream/history.py

+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import 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())

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")

tests/script/fullGeneralSuite.sim

@@ -220,3 +220,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

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

tests/script/general/db/show_create_db.sim

+system sh/stop_dnodes.sh
+
+system sh/deploy.sh -n dnode1 -i 1
+system sh/cfg.sh -n dnode1 -c walLevel -v 0
+
+system sh/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

tests/script/general/db/show_create_table.sim

+system sh/stop_dnodes.sh
+
+system sh/deploy.sh -n dnode1 -i 1
+system sh/cfg.sh -n dnode1 -c walLevel -v 0
+
+system sh/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

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

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