[TD-2425]<feature>: multi-table creation in one request.

src/client/inc/tscUtil.h

@@ -234,7 +234,7 @@ void tscVgroupTableCopy(SVgroupTableInfo* info, SVgroupTableInfo* pInfo);
 
 int  tscGetSTableVgroupInfo(SSqlObj* pSql, int32_t clauseIndex);
 int  tscGetTableMeta(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo);
-int  tscGetMeterMetaEx(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, bool createIfNotExists);
+int  tscGetTableMetaEx(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, bool createIfNotExists);
 
 void tscResetForNextRetrieve(SSqlRes* pRes);
 void tscDoQuery(SSqlObj* pSql);
@@ -287,6 +287,9 @@ bool tscSetSqlOwner(SSqlObj* pSql);
 void tscClearSqlOwner(SSqlObj* pSql);
 int32_t doArithmeticCalculate(SQueryInfo* pQueryInfo, tFilePage* pOutput, int32_t rowSize, int32_t finalRowSize);
 
+char*   serializeTagData(STagData* pTagData, char* pMsg);
+int32_t copyTagData(STagData* dst, const STagData* src);
+
 void* malloc_throw(size_t size);
 void* calloc_throw(size_t nmemb, size_t size);
 char* strdup_throw(const char* str);

src/client/inc/tsclient.h

@@ -246,7 +246,7 @@ typedef struct {
 
   int8_t       dataSourceType;     // load data from file or not
   int8_t       submitSchema;   // submit block is built with table schema
-  STagData    *pTagData;       // NOTE: pTagData->data is used as a variant length array
+  STagData     tagData;        // NOTE: pTagData->data is used as a variant length array
 
   STableMeta **pTableMetaList; // all involved tableMeta list of current insert sql statement.
   int32_t      numOfTables;

src/client/src/tscParseInsert.c

@@ -796,8 +796,6 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
     sToken = tStrGetToken(sql, &index, false, 0, NULL);
     sql += index;
 
-    tscAllocPayload(pCmd, sizeof(STagData));
-    
     //the source super table is moved to the secondary position of the pTableMetaInfo list
     if (pQueryInfo->numOfTables < 2) {
       tscAddEmptyMetaInfo(pQueryInfo);
@@ -809,13 +807,8 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
       return code;
     }
 
-    STagData *pTag = realloc(pCmd->pTagData, offsetof(STagData, data));
-    if (pTag == NULL) {
-      return TSDB_CODE_TSC_OUT_OF_MEMORY;
-    }
-    memset(pTag, 0, offsetof(STagData, data));
-    tstrncpy(pTag->name, pSTableMeterMetaInfo->name, sizeof(pTag->name));
-    pCmd->pTagData = pTag;
+    tstrncpy(pCmd->tagData.name, pSTableMeterMetaInfo->name, sizeof(pCmd->tagData.name));
+    pCmd->tagData.dataLen = 0;
 
     code = tscGetTableMeta(pSql, pSTableMeterMetaInfo);
     if (code != TSDB_CODE_SUCCESS) {
@@ -946,14 +939,15 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
     }
     tdSortKVRowByColIdx(row);
 
-    pTag = (STagData*)realloc(pCmd->pTagData, offsetof(STagData, data) + kvRowLen(row));
+    pCmd->tagData.dataLen = kvRowLen(row);
+    char* pTag = realloc(pCmd->tagData.data, pCmd->tagData.dataLen);
     if (pTag == NULL) {
       return TSDB_CODE_TSC_OUT_OF_MEMORY;
     }
-    pCmd->pTagData = pTag;
-    pTag->dataLen = htonl(kvRowLen(row));
-    kvRowCpy(pTag->data, row);
+
+    kvRowCpy(pTag, row);
     free(row);
+    pCmd->tagData.data = pTag;
 
     index = 0;
     sToken = tStrGetToken(sql, &index, false, 0, NULL);
@@ -972,7 +966,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
     }
 
     createTable = true;
-    code = tscGetMeterMetaEx(pSql, pTableMetaInfo, true);
+    code = tscGetTableMetaEx(pSql, pTableMetaInfo, true);
     if (TSDB_CODE_TSC_ACTION_IN_PROGRESS == code) {
       return code;
     }
@@ -983,7 +977,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
     } else {
       sql = sToken.z;
     }
-    code = tscGetMeterMetaEx(pSql, pTableMetaInfo, false);
+    code = tscGetTableMetaEx(pSql, pTableMetaInfo, false);
     
     if (pCmd->curSql == NULL) {
       assert(code == TSDB_CODE_TSC_ACTION_IN_PROGRESS);

src/client/src/tscSQLParser.c

@@ -1775,12 +1775,15 @@ void setResultColName(char* name, tSQLExprItem* pItem, int32_t functionId, SStrT
     int32_t len = MIN(pToken->n + 1, TSDB_COL_NAME_LEN);
     tstrncpy(uname, pToken->z, len);
 
+    if (tsKeepOriginalColumnName) { // keep the original column name
+      tstrncpy(name, uname, TSDB_COL_NAME_LEN);
+    } else {
       int32_t size = TSDB_COL_NAME_LEN + tListLen(aAggs[functionId].aName) + 2 + 1;
       char tmp[TSDB_COL_NAME_LEN + tListLen(aAggs[functionId].aName) + 2 + 1] = {0};
-
       snprintf(tmp, size, "%s(%s)", aAggs[functionId].aName, uname);
 
       tstrncpy(name, tmp, TSDB_COL_NAME_LEN);
+    }
   } else  { // use the user-input result column name
     int32_t len = MIN(pItem->pNode->token.n + 1, TSDB_COL_NAME_LEN);
     tstrncpy(name, pItem->pNode->token.z, len);
@@ -4910,6 +4913,8 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
     tVariantListItem* pItem = taosArrayGet(pVarList, 1);
     SSchema* pTagsSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, columnIndex.columnIndex);
+    pAlterSQL->tagData.data = calloc(1, pTagsSchema->bytes * TSDB_NCHAR_SIZE + VARSTR_HEADER_SIZE);
+
     if (tVariantDump(&pItem->pVar, pAlterSQL->tagData.data, pTagsSchema->type, true) != TSDB_CODE_SUCCESS) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg13);
     }
@@ -6149,38 +6154,41 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
   const int32_t TABLE_INDEX = 0;
   const int32_t STABLE_INDEX = 1;
 
-  STableMetaInfo* pStableMeterMetaInfo = tscGetMetaInfo(pQueryInfo, STABLE_INDEX);
+  STableMetaInfo* pStableMetaInfo = tscGetMetaInfo(pQueryInfo, STABLE_INDEX);
 
   // super table name, create table by using dst
-  SStrToken* pToken = &(pCreateTable->usingInfo.stableName);
+  int32_t numOfTables = taosArrayGetSize(pCreateTable->childTableInfo);
+  for(int32_t j = 0; j < numOfTables; ++j) {
+    SCreatedTableInfo* pCreateTableInfo = taosArrayGet(pCreateTable->childTableInfo, j);
 
+    SStrToken* pToken = &pCreateTableInfo->stableName;
     if (tscValidateName(pToken) != TSDB_CODE_SUCCESS) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
 
-  int32_t code = tscSetTableFullName(pStableMeterMetaInfo, pToken, pSql);
+    int32_t code = tscSetTableFullName(pStableMetaInfo, pToken, pSql);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
     }
 
-  // get meter meta from mnode
-  tstrncpy(pCreateTable->usingInfo.tagdata.name, pStableMeterMetaInfo->name, sizeof(pCreateTable->usingInfo.tagdata.name));
-  SArray* pList = pInfo->pCreateTableInfo->usingInfo.pTagVals;
+    // get table meta from mnode
+    tstrncpy(pCreateTableInfo->tagdata.name, pStableMetaInfo->name, tListLen(pCreateTableInfo->tagdata.name));
+    SArray* pList = pCreateTableInfo->pTagVals;
 
-  code = tscGetTableMeta(pSql, pStableMeterMetaInfo);
+    code = tscGetTableMeta(pSql, pStableMetaInfo);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
     }
 
     size_t size = taosArrayGetSize(pList);
-  if (tscGetNumOfTags(pStableMeterMetaInfo->pTableMeta) != size) {
+    if (tscGetNumOfTags(pStableMetaInfo->pTableMeta) != size) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
     }
 
     // too long tag values will return invalid sql, not be truncated automatically
-  SSchema* pTagSchema = tscGetTableTagSchema(pStableMeterMetaInfo->pTableMeta);
+    SSchema  *pTagSchema = tscGetTableTagSchema(pStableMetaInfo->pTableMeta);
+    STagData *pTag = &pCreateTableInfo->tagdata;
 
-  STagData* pTag = &pCreateTable->usingInfo.tagdata;
     SKVRowBuilder kvRowBuilder = {0};
     if (tdInitKVRowBuilder(&kvRowBuilder) < 0) {
       return TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -6215,8 +6223,6 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
       }
 
-
-
       tdAddColToKVRow(&kvRowBuilder, pSchema->colId, pSchema->type, tagVal);
     }
 
@@ -6227,20 +6233,28 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
     }
     tdSortKVRowByColIdx(row);
     pTag->dataLen = kvRowLen(row);
+
+    if (pTag->data == NULL) {
+      pTag->data = malloc(pTag->dataLen);
+    }
+
     kvRowCpy(pTag->data, row);
     free(row);
 
     // table name
-  if (tscValidateName(&pInfo->pCreateTableInfo->name) != TSDB_CODE_SUCCESS) {
+    if (tscValidateName(&(pCreateTableInfo->name)) != TSDB_CODE_SUCCESS) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
 
-  STableMetaInfo* pTableMeterMetaInfo = tscGetMetaInfo(pQueryInfo, TABLE_INDEX);
-  ret = tscSetTableFullName(pTableMeterMetaInfo, &pInfo->pCreateTableInfo->name, pSql);
+    STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, TABLE_INDEX);
+    ret = tscSetTableFullName(pTableMetaInfo, &pCreateTableInfo->name, pSql);
     if (ret != TSDB_CODE_SUCCESS) {
       return ret;
     }
 
+    pCreateTableInfo->fullname = strndup(pTableMetaInfo->name, TSDB_TABLE_FNAME_LEN);
+  }
+
   return TSDB_CODE_SUCCESS;
 }
 

src/client/src/tscServer.c

@@ -185,7 +185,7 @@ void tscProcessHeartBeatRsp(void *param, TAOS_RES *tres, int code) {
       pSql->res.code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
     }
 
-    if (pRes->buffer == NULL) {
+    if (pRes->length == NULL) {
       pRes->length = calloc(2,  sizeof(int32_t));
     }
 
@@ -193,7 +193,7 @@ void tscProcessHeartBeatRsp(void *param, TAOS_RES *tres, int code) {
     pRes->length[1] = online;
   } else {
     tscDebug("%" PRId64 " heartbeat failed, code:%s", pObj->hbrid, tstrerror(code));
-    if (pRes->buffer == NULL) {
+    if (pRes->length == NULL) {
       pRes->length = calloc(2, sizeof(int32_t));
     }
 
@@ -1267,10 +1267,10 @@ int32_t tscBuildKillMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   return TSDB_CODE_SUCCESS;
 }
 
+// TODO update it
 int tscEstimateCreateTableMsgLength(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &(pSql->cmd);
-
-  int32_t size = minMsgSize() + sizeof(SCMCreateTableMsg);
+  int32_t size = minMsgSize() + sizeof(SCMCreateTableMsg) + sizeof(SCreatedTableInfo);
 
   SCreateTableSQL *pCreateTableInfo = pInfo->pCreateTableInfo;
   if (pCreateTableInfo->type == TSQL_CREATE_TABLE_FROM_STABLE) {
@@ -1302,33 +1302,55 @@ int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
-
   SCMCreateTableMsg *pCreateTableMsg = (SCMCreateTableMsg *)pCmd->payload;
-  strcpy(pCreateTableMsg->tableId, pTableMetaInfo->name);
+
+  SCreateTableMsg* pCreateMsg = (SCreateTableMsg*)((char*) pCreateTableMsg + sizeof(SCMCreateTableMsg));
+  char* pMsg = NULL;
+
+  int8_t type = pInfo->pCreateTableInfo->type;
+  if (type == TSQL_CREATE_TABLE_FROM_STABLE) {  // create by using super table, tags value
+    SArray* list = pInfo->pCreateTableInfo->childTableInfo;
+
+    int32_t numOfTables = taosArrayGetSize(list);
+    pCreateTableMsg->numOfTables = htonl(numOfTables);
+
+    pMsg = (char*) pCreateMsg;
+    for(int32_t i = 0; i < numOfTables; ++i) {
+      SCreateTableMsg* pCreate = (SCreateTableMsg*) pMsg;
+
+      pCreate->numOfColumns = htons(pCmd->numOfCols);
+      pCreate->numOfTags = htons(pCmd->count);
+      pMsg += sizeof(SCreateTableMsg);
+
+      SCreatedTableInfo* p = taosArrayGet(list, i);
+      strcpy(pCreate->tableId, p->fullname);
+      pCreate->igExists = (p->igExist)? 1 : 0;
 
       // use dbinfo from table id without modifying current db info
-  tscGetDBInfoFromTableFullName(pTableMetaInfo->name, pCreateTableMsg->db);
+      tscGetDBInfoFromTableFullName(p->fullname, pCreate->db);
+      pMsg = serializeTagData(&p->tagdata, pMsg);
+
+      int32_t len = pMsg - (char*) pCreate;
+      pCreate->len = htonl(len);
+    }
+  } else {  // create (super) table
+    pCreateTableMsg->numOfTables = htonl(1); // only one table will be created
+
+    strcpy(pCreateMsg->tableId, pTableMetaInfo->name);
+
+    // use dbinfo from table id without modifying current db info
+    tscGetDBInfoFromTableFullName(pTableMetaInfo->name, pCreateMsg->db);
 
     SCreateTableSQL *pCreateTable = pInfo->pCreateTableInfo;
 
-  pCreateTableMsg->igExists = pCreateTable->existCheck ? 1 : 0;
-  pCreateTableMsg->numOfColumns = htons(pCmd->numOfCols);
-  pCreateTableMsg->numOfTags = htons(pCmd->count);
+    pCreateMsg->igExists = pCreateTable->existCheck ? 1 : 0;
+    pCreateMsg->numOfColumns = htons(pCmd->numOfCols);
+    pCreateMsg->numOfTags = htons(pCmd->count);
 
-  pCreateTableMsg->sqlLen = 0;
-  char *pMsg = (char *)pCreateTableMsg->schema;
+    pCreateMsg->sqlLen = 0;
+    pMsg = (char *)pCreateMsg->schema;
 
-  int8_t type = pInfo->pCreateTableInfo->type;
-  if (type == TSQL_CREATE_TABLE_FROM_STABLE) {  // create by using super table, tags value
-    STagData* pTag = &pInfo->pCreateTableInfo->usingInfo.tagdata;
-    *(int32_t*)pMsg = htonl(pTag->dataLen);
-    pMsg += sizeof(int32_t);
-    memcpy(pMsg, pTag->name, sizeof(pTag->name));
-    pMsg += sizeof(pTag->name);
-    memcpy(pMsg, pTag->data, pTag->dataLen);
-    pMsg += pTag->dataLen;
-  } else {  // create (super) table
-    pSchema = (SSchema *)pCreateTableMsg->schema;
+    pSchema = (SSchema *)pCreateMsg->schema;
 
     for (int i = 0; i < pCmd->numOfCols + pCmd->count; ++i) {
       TAOS_FIELD *pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, i);
@@ -1345,7 +1367,7 @@ int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
       SQuerySQL *pQuerySql = pInfo->pCreateTableInfo->pSelect;
 
       strncpy(pMsg, pQuerySql->selectToken.z, pQuerySql->selectToken.n + 1);
-      pCreateTableMsg->sqlLen = htons(pQuerySql->selectToken.n + 1);
+      pCreateMsg->sqlLen = htons(pQuerySql->selectToken.n + 1);
       pMsg += pQuerySql->selectToken.n + 1;
     }
   }
@@ -1622,13 +1644,8 @@ int tscBuildTableMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   char *pMsg = (char *)pInfoMsg + sizeof(STableInfoMsg);
 
-  if (pCmd->autoCreated && pCmd->pTagData != NULL) {
-    int len = htonl(pCmd->pTagData->dataLen);
-    if (len > 0) {
-      len += sizeof(pCmd->pTagData->name) + sizeof(pCmd->pTagData->dataLen);
-      memcpy(pInfoMsg->tags, pCmd->pTagData, len);
-      pMsg += len;
-    }
+  if (pCmd->autoCreated && pCmd->tagData.dataLen != 0) {
+    pMsg = serializeTagData(&pCmd->tagData, pMsg);
   }
 
   pCmd->payloadLen = (int32_t)(pMsg - (char*)pInfoMsg);
@@ -2174,10 +2191,7 @@ int tscProcessDropTableRsp(SSqlObj *pSql) {
    */
   tscDebug("%p force release table meta after drop table:%s", pSql, pTableMetaInfo->name);
   taosCacheRelease(tscMetaCache, (void **)&pTableMeta, true);
-
-  if (pTableMetaInfo->pTableMeta) {
-    taosCacheRelease(tscMetaCache, (void **)&(pTableMetaInfo->pTableMeta), true);
-  }
+  assert(pTableMetaInfo->pTableMeta == NULL);
 
   return 0;
 }
@@ -2285,7 +2299,7 @@ int tscProcessRetrieveRspFromNode(SSqlObj *pSql) {
 
 void tscTableMetaCallBack(void *param, TAOS_RES *res, int code);
 
-static int32_t getTableMetaFromMgmt(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
+static int32_t getTableMetaFromMnode(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
   SSqlObj *pNew = calloc(1, sizeof(SSqlObj));
   if (NULL == pNew) {
     tscError("%p malloc failed for new sqlobj to get table meta", pSql);
@@ -2312,15 +2326,13 @@ static int32_t getTableMetaFromMgmt(SSqlObj *pSql, STableMetaInfo *pTableMetaInf
 
   tstrncpy(pNewMeterMetaInfo->name, pTableMetaInfo->name, sizeof(pNewMeterMetaInfo->name));
 
-  if (pSql->cmd.pTagData != NULL) {
-    int size = offsetof(STagData, data) + htonl(pSql->cmd.pTagData->dataLen);
-    pNew->cmd.pTagData = calloc(1, size);
-    if (pNew->cmd.pTagData == NULL) {
+  if (pSql->cmd.autoCreated) {
+    int32_t code = copyTagData(&pNew->cmd.tagData, &pSql->cmd.tagData);
+    if (code != TSDB_CODE_SUCCESS) {
       tscError("%p malloc failed for new tag data to get table meta", pSql);
       tscFreeSqlObj(pNew);
       return TSDB_CODE_TSC_OUT_OF_MEMORY;
     }
-    memcpy(pNew->cmd.pTagData, pSql->cmd.pTagData, size);
   }
 
   tscDebug("%p new pSqlObj:%p to get tableMeta, auto create:%d", pSql, pNew, pNew->cmd.autoCreated);
@@ -2355,10 +2367,10 @@ int32_t tscGetTableMeta(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
     return TSDB_CODE_SUCCESS;
   }
   
-  return getTableMetaFromMgmt(pSql, pTableMetaInfo);
+  return getTableMetaFromMnode(pSql, pTableMetaInfo);
 }
 
-int tscGetMeterMetaEx(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo, bool createIfNotExists) {
+int tscGetTableMetaEx(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo, bool createIfNotExists) {
   pSql->cmd.autoCreated = createIfNotExists;
   return tscGetTableMeta(pSql, pTableMetaInfo);
 }
@@ -2382,7 +2394,7 @@ int tscRenewTableMeta(SSqlObj *pSql, int32_t tableIndex) {
   }
 
   taosCacheRelease(tscMetaCache, (void **)&(pTableMetaInfo->pTableMeta), true);
-  return getTableMetaFromMgmt(pSql, pTableMetaInfo);
+  return getTableMetaFromMnode(pSql, pTableMetaInfo);
 }
 
 static bool allVgroupInfoRetrieved(SSqlCmd* pCmd, int32_t clauseIndex) {

src/client/src/tscUtil.c

@@ -518,7 +518,8 @@ void tscFreeSqlObj(SSqlObj* pSql) {
   tscFreeSqlResult(pSql);
   tscResetSqlCmdObj(pCmd, false);
 
-  tfree(pCmd->pTagData);
+  tfree(pCmd->tagData.data);
+  pCmd->tagData.dataLen = 0;
   
   memset(pCmd->payload, 0, (size_t)pCmd->allocSize);
   tfree(pCmd->payload);
@@ -1937,16 +1938,12 @@ SSqlObj* createSimpleSubObj(SSqlObj* pSql, void (*fp)(), void* param, int32_t cm
   pCmd->parseFinished = 1;
   pCmd->autoCreated = pSql->cmd.autoCreated;
 
-  if (pSql->cmd.pTagData != NULL) {
-    int size = offsetof(STagData, data) + htonl(pSql->cmd.pTagData->dataLen);
-    pNew->cmd.pTagData = calloc(1, size);
-    if (pNew->cmd.pTagData == NULL) {
+  int32_t code = copyTagData(&pNew->cmd.tagData, &pSql->cmd.tagData);
+  if (code != TSDB_CODE_SUCCESS) {
     tscError("%p new subquery failed, unable to malloc tag data, tableIndex:%d", pSql, 0);
     free(pNew);
     return NULL;
   }
-    memcpy(pNew->cmd.pTagData, pSql->cmd.pTagData, size);
-  }
 
   if (tscAddSubqueryInfo(pCmd) != TSDB_CODE_SUCCESS) {
     tscFreeSqlObj(pNew);
@@ -2595,3 +2592,36 @@ void tscSVgroupInfoCopy(SVgroupInfo* dst, const SVgroupInfo* src) {
     dst->epAddr[i].fqdn = strdup(src->epAddr[i].fqdn);
   }
 }
+
+char* serializeTagData(STagData* pTagData, char* pMsg) {
+  int32_t n = strlen(pTagData->name);
+  *(int32_t*) pMsg = htonl(n);
+  pMsg += sizeof(n);
+
+  memcpy(pMsg, pTagData->name, n);
+  pMsg += n;
+
+  *(int32_t*)pMsg = htonl(pTagData->dataLen);
+  pMsg += sizeof(int32_t);
+
+  memcpy(pMsg, pTagData->data, pTagData->dataLen);
+  pMsg += pTagData->dataLen;
+
+  return pMsg;
+}
+
+int32_t copyTagData(STagData* dst, const STagData* src) {
+  dst->dataLen = src->dataLen;
+  tstrncpy(dst->name, src->name, tListLen(dst->name));
+
+  if (dst->dataLen > 0) {
+    dst->data = malloc(dst->dataLen);
+    if (dst->data == NULL) {
+      return -1;
+    }
+
+    memcpy(dst->data, src->data, dst->dataLen);
+  }
+
+  return 0;
+}
\ No newline at end of file

src/common/inc/tglobal.h

@@ -57,7 +57,9 @@ extern char     tsTempDir[];
 
 //query buffer management
 extern int32_t  tsQueryBufferSize;      // maximum allowed usage buffer for each data node during query processing
-extern int32_t  tsRetrieveBlockingModel;         // only 50% will be used in query processing
+extern int32_t  tsRetrieveBlockingModel;// retrieve threads will be blocked
+
+extern int32_t  tsKeepOriginalColumnName;
 
 // client
 extern int32_t tsTableMetaKeepTimer;

src/common/src/tglobal.c

@@ -110,6 +110,9 @@ int32_t tsQueryBufferSize = -1;
 // in retrieve blocking model, the retrieve threads will wait for the completion of the query processing.
 int32_t tsRetrieveBlockingModel = 0;
 
+// last_row(*), first(*), last_row(ts, col1, col2) query, the result fields will be the original column name
+int32_t tsKeepOriginalColumnName = 0;
+
 // db parameters
 int32_t tsCacheBlockSize = TSDB_DEFAULT_CACHE_BLOCK_SIZE;
 int32_t tsBlocksPerVnode = TSDB_DEFAULT_TOTAL_BLOCKS;
@@ -897,6 +900,16 @@ static void doInitGlobalConfig(void) {
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
   taosInitConfigOption(cfg);
 
+  cfg.option = "keepColumnName";
+  cfg.ptr = &tsKeepOriginalColumnName;
+  cfg.valType = TAOS_CFG_VTYPE_INT32;
+  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW | TSDB_CFG_CTYPE_B_CLIENT;
+  cfg.minValue = 0;
+  cfg.maxValue = 1;
+  cfg.ptrLength = 1;
+  cfg.unitType = TAOS_CFG_UTYPE_NONE;
+  taosInitConfigOption(cfg);
+
   // locale & charset
   cfg.option = "timezone";
   cfg.ptr = tsTimezone;

src/inc/taosmsg.h

@@ -266,6 +266,7 @@ typedef struct {
 } SMDCreateTableMsg;
 
 typedef struct {
+  int32_t len;  // one create table message
   char    tableId[TSDB_TABLE_FNAME_LEN];
   char    db[TSDB_ACCT_LEN + TSDB_DB_NAME_LEN];
   int8_t  igExists;
@@ -273,9 +274,13 @@ typedef struct {
   int16_t numOfTags;
   int16_t numOfColumns;
   int16_t sqlLen;  // the length of SQL, it starts after schema , sql is a null-terminated string
-  int32_t contLen;
   int8_t  reserved[16];
   char    schema[];
+} SCreateTableMsg;
+
+typedef struct {
+  int32_t numOfTables;
+  int32_t contLen;
 } SCMCreateTableMsg;
 
 typedef struct {
@@ -731,7 +736,7 @@ typedef struct SMultiTableMeta {
 typedef struct {
   int32_t dataLen;
   char    name[TSDB_TABLE_FNAME_LEN];
-  char data[TSDB_MAX_TAGS_LEN + TD_KV_ROW_HEAD_SIZE + sizeof(SColIdx) * TSDB_MAX_TAGS];
+  char   *data;
 } STagData;
 
 /*

src/mnode/src/mnodeTable.c

@@ -721,9 +721,16 @@ static void mnodeExtractTableName(char* tableId, char* name) {
 static int32_t mnodeProcessCreateTableMsg(SMnodeMsg *pMsg) {
   SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
 
-  if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pCreate->db);
+  int32_t numOfTables = htonl(pCreate->numOfTables);
+  int32_t contentLen = htonl(pCreate->contLen);
+  if (numOfTables == 0 || contentLen == 0) {
+    // todo return error
+  }
+
+  SCreateTableMsg *p = (SCreateTableMsg*)((char*) pCreate + sizeof(SCMCreateTableMsg));
+  if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(p->db);
   if (pMsg->pDb == NULL) {
-    mError("msg:%p, app:%p table:%s, failed to create, db not selected", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableId);
+    mError("msg:%p, app:%p table:%s, failed to create, db not selected", pMsg, pMsg->rpcMsg.ahandle, p->tableId);
     return TSDB_CODE_MND_DB_NOT_SELECTED;
   }
   
@@ -732,28 +739,28 @@ static int32_t mnodeProcessCreateTableMsg(SMnodeMsg *pMsg) {
     return TSDB_CODE_MND_DB_IN_DROPPING;
   }
 
-  if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pCreate->tableId);
+  if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(p->tableId);
   if (pMsg->pTable != NULL && pMsg->retry == 0) {
-    if (pCreate->getMeta) {
-      mDebug("msg:%p, app:%p table:%s, continue to get meta", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableId);
+    if (p->getMeta) {
+      mDebug("msg:%p, app:%p table:%s, continue to get meta", pMsg, pMsg->rpcMsg.ahandle, p->tableId);
       return mnodeGetChildTableMeta(pMsg);
-    } else if (pCreate->igExists) {
-      mDebug("msg:%p, app:%p table:%s, is already exist", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableId);
+    } else if (p->igExists) {
+      mDebug("msg:%p, app:%p table:%s, is already exist", pMsg, pMsg->rpcMsg.ahandle, p->tableId);
       return TSDB_CODE_SUCCESS;
     } else {
       mError("msg:%p, app:%p table:%s, failed to create, table already exist", pMsg, pMsg->rpcMsg.ahandle,
-             pCreate->tableId);
+             p->tableId);
       return TSDB_CODE_MND_TABLE_ALREADY_EXIST;
     }
   }
 
-  if (pCreate->numOfTags != 0) {
+  if (p->numOfTags != 0) {
     mDebug("msg:%p, app:%p table:%s, create stable msg is received from thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
-           pCreate->tableId, pMsg->rpcMsg.handle);
+           p->tableId, pMsg->rpcMsg.handle);
     return mnodeProcessCreateSuperTableMsg(pMsg);
   } else {
     mDebug("msg:%p, app:%p table:%s, create ctable msg is received from thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
-           pCreate->tableId, pMsg->rpcMsg.handle);
+           p->tableId, pMsg->rpcMsg.handle);
     return mnodeProcessCreateChildTableMsg(pMsg);
   }
 }
@@ -859,7 +866,13 @@ static int32_t mnodeCreateSuperTableCb(SMnodeMsg *pMsg, int32_t code) {
 static int32_t mnodeProcessCreateSuperTableMsg(SMnodeMsg *pMsg) {
   if (pMsg == NULL) return TSDB_CODE_MND_APP_ERROR;
 
-  SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
+  SCMCreateTableMsg *pCreate1 = pMsg->rpcMsg.pCont;
+  if (pCreate1->numOfTables == 0) {
+    // todo return to error message
+  }
+
+  SCreateTableMsg* pCreate = (SCreateTableMsg*)((char*)pCreate1 + sizeof(SCMCreateTableMsg));
+
   SSTableObj *   pStable = calloc(1, sizeof(SSTableObj));
   if (pStable == NULL) {
     mError("msg:%p, app:%p table:%s, failed to create, no enough memory", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableId);
@@ -1599,8 +1612,11 @@ static void mnodeProcessDropSuperTableRsp(SRpcMsg *rpcMsg) {
   mInfo("drop stable rsp received, result:%s", tstrerror(rpcMsg->code));
 }
 
-static void *mnodeBuildCreateChildTableMsg(SCMCreateTableMsg *pMsg, SCTableObj *pTable) {
-  STagData *  pTagData = NULL;
+static void *mnodeBuildCreateChildTableMsg(SCMCreateTableMsg *pCreateMsg, SCTableObj *pTable) {
+  SCreateTableMsg* pMsg = (SCreateTableMsg*) ((char*)pCreateMsg + sizeof(SCMCreateTableMsg));
+
+  char* tagData = NULL;
+
   int32_t tagDataLen = 0;
   int32_t totalCols = 0;
   int32_t contLen = 0;
@@ -1608,9 +1624,13 @@ static void *mnodeBuildCreateChildTableMsg(SCMCreateTableMsg *pMsg, SCTableObj *
     totalCols = pTable->superTable->numOfColumns + pTable->superTable->numOfTags;
     contLen = sizeof(SMDCreateTableMsg) + totalCols * sizeof(SSchema) + pTable->sqlLen;
     if (pMsg != NULL) {
-      pTagData = (STagData *)pMsg->schema;
-      tagDataLen = htonl(pTagData->dataLen);
+      int32_t nameLen = htonl(*(int32_t*)pMsg->schema);
+      char* p = pMsg->schema + nameLen + sizeof(int32_t);
+
+      tagDataLen = htonl(*(int32_t*) p);
       contLen += tagDataLen;
+
+      tagData = p + sizeof(int32_t);
     }
   } else {
     totalCols = pTable->numOfColumns;
@@ -1662,7 +1682,7 @@ static void *mnodeBuildCreateChildTableMsg(SCMCreateTableMsg *pMsg, SCTableObj *
   }
 
   if (pTable->info.type == TSDB_CHILD_TABLE && pMsg != NULL) {
-    memcpy(pCreate->data + totalCols * sizeof(SSchema), pTagData->data, tagDataLen);
+    memcpy(pCreate->data + totalCols * sizeof(SSchema), tagData, tagDataLen);
   }
 
   if (pTable->info.type == TSDB_STREAM_TABLE) {
@@ -1700,7 +1720,8 @@ static int32_t mnodeDoCreateChildTableFp(SMnodeMsg *pMsg) {
 
 static int32_t mnodeDoCreateChildTableCb(SMnodeMsg *pMsg, int32_t code) {
   SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
-  SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
+
+  SCreateTableMsg *pCreate = (SCreateTableMsg*) ((char*)pMsg->rpcMsg.pCont + sizeof(SCMCreateTableMsg));
   assert(pTable);
 
   if (code == TSDB_CODE_SUCCESS) {
@@ -1728,40 +1749,42 @@ static int32_t mnodeDoCreateChildTableCb(SMnodeMsg *pMsg, int32_t code) {
 
 static int32_t mnodeDoCreateChildTable(SMnodeMsg *pMsg, int32_t tid) {
   SVgObj *pVgroup = pMsg->pVgroup;
-  SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
+
+  SCMCreateTableMsg *p1 = pMsg->rpcMsg.pCont;
+  SCreateTableMsg   *pCreate = (SCreateTableMsg*)((char*)p1 + sizeof(SCMCreateTableMsg));
+
   SCTableObj *pTable = calloc(1, sizeof(SCTableObj));
   if (pTable == NULL) {
     mError("msg:%p, app:%p table:%s, failed to alloc memory", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableId);
     return TSDB_CODE_MND_OUT_OF_MEMORY;
   }
 
-  if (pCreate->numOfColumns == 0) {
-    pTable->info.type = TSDB_CHILD_TABLE;
-  } else {
-    pTable->info.type = TSDB_NORMAL_TABLE;
-  }
-
+  pTable->info.type    = (pCreate->numOfColumns == 0)? TSDB_CHILD_TABLE:TSDB_NORMAL_TABLE;
   pTable->info.tableId = strdup(pCreate->tableId);
   pTable->createdTime  = taosGetTimestampMs();
   pTable->tid          = tid;
   pTable->vgId         = pVgroup->vgId;
 
   if (pTable->info.type == TSDB_CHILD_TABLE) {
-    STagData *pTagData = (STagData *)pCreate->schema;  // it is a tag key
+    int32_t nameLen = htonl(*(int32_t*) pCreate->schema);
+    char* name = (char*)pCreate->schema + sizeof(int32_t);
+
+    char stableName[TSDB_TABLE_FNAME_LEN] = {0};
+    memcpy(stableName, name, nameLen);
 
     char prefix[64] = {0};
     size_t prefixLen = tableIdPrefix(pMsg->pDb->name, prefix, 64);
-    if (0 != strncasecmp(prefix, pTagData->name, prefixLen)) {
+    if (0 != strncasecmp(prefix, stableName, prefixLen)) {
       mError("msg:%p, app:%p table:%s, corresponding super table:%s not in this db", pMsg, pMsg->rpcMsg.ahandle,
-             pCreate->tableId, pTagData->name);
+             pCreate->tableId, stableName);
       mnodeDestroyChildTable(pTable);
       return TSDB_CODE_TDB_INVALID_CREATE_TB_MSG;
     }
 
-    if (pMsg->pSTable == NULL) pMsg->pSTable = mnodeGetSuperTable(pTagData->name);
+    if (pMsg->pSTable == NULL) pMsg->pSTable = mnodeGetSuperTable(stableName);
     if (pMsg->pSTable == NULL) {
       mError("msg:%p, app:%p table:%s, corresponding super table:%s does not exist", pMsg, pMsg->rpcMsg.ahandle,
-             pCreate->tableId, pTagData->name);
+             pCreate->tableId, stableName);
       mnodeDestroyChildTable(pTable);
       return TSDB_CODE_MND_INVALID_TABLE_NAME;
     }
@@ -1839,7 +1862,9 @@ static int32_t mnodeDoCreateChildTable(SMnodeMsg *pMsg, int32_t tid) {
 }
 
 static int32_t mnodeProcessCreateChildTableMsg(SMnodeMsg *pMsg) {
-  SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
+  //SCMCreateTableMsg* p1 = pMsg->rpcMsg.pCont; // there are several tables here.
+  SCreateTableMsg* pCreate = (SCreateTableMsg*)(pMsg->rpcMsg.pCont + sizeof(SCMCreateTableMsg));
+
   int32_t code = grantCheck(TSDB_GRANT_TIMESERIES);
   if (code != TSDB_CODE_SUCCESS) {
     mError("msg:%p, app:%p table:%s, failed to create, grant timeseries failed", pMsg, pMsg->rpcMsg.ahandle,
@@ -2187,15 +2212,23 @@ static int32_t mnodeDoGetChildTableMeta(SMnodeMsg *pMsg, STableMetaMsg *pMeta) {
 
 static int32_t mnodeAutoCreateChildTable(SMnodeMsg *pMsg) {
   STableInfoMsg *pInfo = pMsg->rpcMsg.pCont;
-  STagData *pTags = (STagData *)pInfo->tags;
-  int32_t tagLen = htonl(pTags->dataLen);
-  if (pTags->name[0] == 0) {
-    mError("msg:%p, app:%p table:%s, failed to create table on demand for stable is empty, tagLen:%d", pMsg,
+
+  char* p = pInfo->tags;
+  int32_t nameLen = htonl(*(int32_t*) p);
+  p += sizeof(int32_t);
+  p += nameLen;
+
+  int32_t tagLen = htonl(*(int32_t*) p);
+  p += sizeof(int32_t);
+
+  int32_t totalLen = nameLen + tagLen + sizeof(int32_t)*2;
+  if (tagLen == 0 || nameLen == 0) {
+    mError("msg:%p, app:%p table:%s, failed to create table on demand for super table is empty, tagLen:%d", pMsg,
            pMsg->rpcMsg.ahandle, pInfo->tableId, tagLen);
     return TSDB_CODE_MND_INVALID_STABLE_NAME;
   }
 
-  int32_t contLen = sizeof(SCMCreateTableMsg) + offsetof(STagData, data) + tagLen;
+  int32_t contLen = sizeof(SCMCreateTableMsg) + sizeof(SCreateTableMsg) + totalLen;
   SCMCreateTableMsg *pCreateMsg = calloc(1, contLen);
   if (pCreateMsg == NULL) {
     mError("msg:%p, app:%p table:%s, failed to create table while get meta info, no enough memory", pMsg,
@@ -2203,16 +2236,24 @@ static int32_t mnodeAutoCreateChildTable(SMnodeMsg *pMsg) {
     return TSDB_CODE_MND_OUT_OF_MEMORY;
   }
 
-  size_t size = sizeof(pInfo->tableId);
-  tstrncpy(pCreateMsg->tableId, pInfo->tableId, size);
-  tstrncpy(pCreateMsg->db, pMsg->pDb->name, sizeof(pCreateMsg->db));
-  pCreateMsg->igExists = 1;
-  pCreateMsg->getMeta = 1;
+  SCreateTableMsg* pCreate = (SCreateTableMsg*) ((char*) pCreateMsg + sizeof(SCMCreateTableMsg));
+
+  size_t size = tListLen(pInfo->tableId);
+  tstrncpy(pCreate->tableId, pInfo->tableId, size);
+  tstrncpy(pCreate->db, pMsg->pDb->name, sizeof(pCreate->db));
+  pCreate->igExists = 1;
+  pCreate->getMeta = 1;
+
+  pCreateMsg->numOfTables = htonl(1);
   pCreateMsg->contLen = htonl(contLen);
 
-  memcpy(pCreateMsg->schema, pTags, contLen - sizeof(SCMCreateTableMsg));
+  memcpy(pCreate->schema, pInfo->tags, totalLen);
+
+  char name[TSDB_TABLE_FNAME_LEN] = {0};
+  memcpy(name, pInfo->tags + sizeof(int32_t), nameLen);
+
   mDebug("msg:%p, app:%p table:%s, start to create on demand, tagLen:%d stable:%s", pMsg, pMsg->rpcMsg.ahandle,
-         pInfo->tableId, tagLen, pTags->name);
+         pInfo->tableId, tagLen, name);
 
   if (pMsg->rpcMsg.pCont != pMsg->pCont) {
     tfree(pMsg->rpcMsg.pCont);

src/os/inc/osString.h

@@ -39,7 +39,7 @@ extern "C" {
   do {                             \
     strncpy((dst), (src), (size)); \
     (dst)[(size)-1] = 0;           \
-  } while (0);
+  } while (0)
 
 #ifndef TAOS_OS_FUNC_STRING_STR2INT64
   int64_t tsosStr2int64(char *str);

src/query/inc/qSqlparser.h

@@ -73,22 +73,26 @@ typedef struct SQuerySQL {
   SStrToken            selectToken;  // sql string
 } SQuerySQL;
 
+typedef struct SCreatedTableInfo {
+  SStrToken  name;        // table name token
+  SStrToken  stableName;  // super table name token , for using clause
+  SArray    *pTagVals;    // create by using super table, tag value
+  char      *fullname;    // table full name
+  STagData   tagdata;     // true tag data, super table full name is in STagData
+  int8_t     igExist;     // ignore if exists
+} SCreatedTableInfo;
+
 typedef struct SCreateTableSQL {
-  struct SStrToken name;  // meter name, create table [meterName] xxx
+  SStrToken    name;  // table name, create table [name] xxx
+  int8_t       type;  // create normal table/from super table/ stream
   bool         existCheck;
 
-  int8_t           type; // create normal table/from super table/ stream
   struct {
     SArray    *pTagColumns; // SArray<TAOS_FIELD>
     SArray    *pColumns;    // SArray<TAOS_FIELD>
   } colInfo;
 
-  struct {
-    SStrToken      stableName;  // super table name, for using clause
-    SArray        *pTagVals;    // create by using metric, tag value
-    STagData       tagdata;
-  } usingInfo;
-  
+  SArray      *childTableInfo;        // SArray<SCreatedTableInfo>
   SQuerySQL   *pSelect;
 } SCreateTableSQL;
 
@@ -241,22 +245,23 @@ SQuerySQL *tSetQuerySQLElems(SStrToken *pSelectToken, tSQLExprList *pSelection,
                              SArray *pGroupby, SArray *pSortOrder, SIntervalVal *pInterval,
                              SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit, SLimitVal *pGLimit);
 
-SCreateTableSQL *tSetCreateSQLElems(SArray *pCols, SArray *pTags, SStrToken *pMetricName,
-                                    SArray *pTagVals, SQuerySQL *pSelect, int32_t type);
+SCreateTableSQL *tSetCreateSQLElems(SArray *pCols, SArray *pTags, SQuerySQL *pSelect, int32_t type);
 
 void tSQLExprNodeDestroy(tSQLExpr *pExpr);
 
-SAlterTableSQL *tAlterTableSQLElems(SStrToken *pMeterName, SArray *pCols, SArray *pVals, int32_t type);
+SAlterTableSQL *tAlterTableSQLElems(SStrToken *pTableName, SArray *pCols, SArray *pVals, int32_t type);
+SCreatedTableInfo createNewChildTableInfo(SStrToken *pTableName, SArray *pTagVals, SStrToken *pToken, SStrToken* igExists);
 
 void destroyAllSelectClause(SSubclauseInfo *pSql);
 void doDestroyQuerySql(SQuerySQL *pSql);
+void freeCreateTableInfo(void* p);
 
-SSqlInfo *      setSQLInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pMeterName, int32_t type);
+SSqlInfo       *setSQLInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pTableName, int32_t type);
 SSubclauseInfo *setSubclause(SSubclauseInfo *pClause, void *pSqlExprInfo);
 
 SSubclauseInfo *appendSelectClause(SSubclauseInfo *pInfo, void *pSubclause);
 
-void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pMeterName, SStrToken *pIfNotExists);
+void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pTableNameToken, SStrToken *pIfNotExists);
 
 void SQLInfoDestroy(SSqlInfo *pInfo);
 

src/query/inc/sql.y

@@ -168,12 +168,12 @@ ids(A) ::= ID(X).        {A = X; }
 ids(A) ::= STRING(X).    {A = X; }
 
 %type ifexists {SStrToken}
-ifexists(X) ::= IF EXISTS.          {X.n = 1;}
-ifexists(X) ::= .                   {X.n = 0;}
+ifexists(X) ::= IF EXISTS.          { X.n = 1;}
+ifexists(X) ::= .                   { X.n = 0;}
 
 %type ifnotexists {SStrToken}
-ifnotexists(X) ::= IF NOT EXISTS.   {X.n = 1;}
-ifnotexists(X) ::= .                {X.n = 0;}
+ifnotexists(X) ::= IF NOT EXISTS.   { X.n = 1;}
+ifnotexists(X) ::= .                { X.n = 0;}
 
 /////////////////////////////////THE CREATE STATEMENT///////////////////////////////////////
 //create option for dnode/db/user/account
@@ -183,32 +183,32 @@ cmd ::= CREATE ACCOUNT ids(X) PASS ids(Y) acct_optr(Z).
 cmd ::= CREATE DATABASE ifnotexists(Z) ids(X) db_optr(Y).  { setCreateDBSQL(pInfo, TSDB_SQL_CREATE_DB, &X, &Y, &Z);}
 cmd ::= CREATE USER ids(X) PASS ids(Y).     { setCreateUserSQL(pInfo, &X, &Y);}
 
-pps(Y) ::= .                                {Y.n = 0;   }
-pps(Y) ::= PPS INTEGER(X).                  {Y = X;     }
+pps(Y) ::= .                                { Y.n = 0;   }
+pps(Y) ::= PPS INTEGER(X).                  { Y = X;     }
 
-tseries(Y) ::= .                            {Y.n = 0;   }
-tseries(Y) ::= TSERIES INTEGER(X).          {Y = X;     }
+tseries(Y) ::= .                            { Y.n = 0;   }
+tseries(Y) ::= TSERIES INTEGER(X).          { Y = X;     }
 
-dbs(Y) ::= .                                {Y.n = 0;   }
-dbs(Y) ::= DBS INTEGER(X).                  {Y = X;     }
+dbs(Y) ::= .                                { Y.n = 0;   }
+dbs(Y) ::= DBS INTEGER(X).                  { Y = X;     }
 
-streams(Y) ::= .                            {Y.n = 0;   }
-streams(Y) ::= STREAMS INTEGER(X).          {Y = X;     }
+streams(Y) ::= .                            { Y.n = 0;   }
+streams(Y) ::= STREAMS INTEGER(X).          { Y = X;     }
 
-storage(Y) ::= .                            {Y.n = 0;   }
-storage(Y) ::= STORAGE INTEGER(X).          {Y = X;     }
+storage(Y) ::= .                            { Y.n = 0;   }
+storage(Y) ::= STORAGE INTEGER(X).          { Y = X;     }
 
-qtime(Y) ::= .                              {Y.n = 0;   }
-qtime(Y) ::= QTIME INTEGER(X).              {Y = X;     }
+qtime(Y) ::= .                              { Y.n = 0;   }
+qtime(Y) ::= QTIME INTEGER(X).              { Y = X;     }
 
-users(Y) ::= .                              {Y.n = 0;   }
-users(Y) ::= USERS INTEGER(X).              {Y = X;     }
+users(Y) ::= .                              { Y.n = 0;   }
+users(Y) ::= USERS INTEGER(X).              { Y = X;     }
 
-conns(Y) ::= .                              {Y.n = 0;   }
-conns(Y) ::= CONNS INTEGER(X).              {Y = X;     }
+conns(Y) ::= .                              { Y.n = 0;   }
+conns(Y) ::= CONNS INTEGER(X).              { Y = X;     }
 
-state(Y) ::= .                              {Y.n = 0;   }
-state(Y) ::= STATE ids(X).                  {Y = X;     }
+state(Y) ::= .                              { Y.n = 0;   }
+state(Y) ::= STATE ids(X).                  { Y = X;     }
 
 %type acct_optr {SCreateAcctSQL}
 acct_optr(Y) ::= pps(C) tseries(D) storage(P) streams(F) qtime(Q) dbs(E) users(K) conns(L) state(M). {
@@ -294,36 +294,60 @@ signed(A) ::= PLUS INTEGER(X).    { A = strtol(X.z, NULL, 10); }
 signed(A) ::= MINUS INTEGER(X).   { A = -strtol(X.z, NULL, 10);}
 
 ////////////////////////////////// The CREATE TABLE statement ///////////////////////////////
-cmd ::= CREATE TABLE ifnotexists(Y) ids(X) cpxName(Z) create_table_args.  {
-    X.n += Z.n;
-    setCreatedTableName(pInfo, &X, &Y);
+cmd ::= CREATE TABLE create_table_args. {}
+cmd ::= CREATE TABLE create_table_list(Z). { pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = Z;}
+
+%type create_table_list{SCreateTableSQL*}
+%destructor create_table_list{destroyCreateTableSQL($$);}
+create_table_list(A) ::= create_from_stable(Z). {
+  SCreateTableSQL* pCreateTable = calloc(1, sizeof(SCreateTableSQL));
+  pCreateTable->childTableInfo = taosArrayInit(4, sizeof(SCreatedTableInfo));
+
+  taosArrayPush(pCreateTable->childTableInfo, &Z);
+  pCreateTable->type = TSQL_CREATE_TABLE_FROM_STABLE;
+  A = pCreateTable;
+}
+
+create_table_list(A) ::= create_table_list(X) create_from_stable(Z). {
+  taosArrayPush(X->childTableInfo, &Z);
+  A = X;
 }
 
 %type create_table_args{SCreateTableSQL*}
-create_table_args(A) ::= LP columnlist(X) RP. {
-    A = tSetCreateSQLElems(X, NULL, NULL, NULL, NULL, TSQL_CREATE_TABLE);
+create_table_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) LP columnlist(X) RP. {
+  A = tSetCreateSQLElems(X, NULL, NULL, TSQL_CREATE_TABLE);
   setSQLInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
+
+  V.n += Z.n;
+  setCreatedTableName(pInfo, &V, &U);
 }
 
 // create super table
-create_table_args(A) ::= LP columnlist(X) RP TAGS LP columnlist(Y) RP. {
-    A = tSetCreateSQLElems(X, Y, NULL, NULL, NULL, TSQL_CREATE_STABLE);
+create_table_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) LP columnlist(X) RP TAGS LP columnlist(Y) RP. {
+  A = tSetCreateSQLElems(X, Y, NULL, TSQL_CREATE_STABLE);
   setSQLInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
+
+  V.n += Z.n;
+  setCreatedTableName(pInfo, &V, &U);
 }
 
 // create table by using super table
 // create table table_name using super_table_name tags(tag_values1, tag_values2)
-create_table_args(A) ::= USING ids(X) cpxName(F) TAGS LP tagitemlist(Y) RP.  {
+%type create_from_stable{SCreatedTableInfo}
+create_from_stable(A) ::= ifnotexists(U) ids(V) cpxName(Z) USING ids(X) cpxName(F) TAGS LP tagitemlist(Y) RP.  {
   X.n += F.n;
-    A = tSetCreateSQLElems(NULL, NULL, &X, Y, NULL, TSQL_CREATE_TABLE_FROM_STABLE);
-    setSQLInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
+  V.n += Z.n;
+  A = createNewChildTableInfo(&X, Y, &V, &U);
 }
 
 // create stream
 // create table table_name as select count(*) from super_table_name interval(time)
-create_table_args(A) ::= AS select(S). {
-    A = tSetCreateSQLElems(NULL, NULL, NULL, NULL, S, TSQL_CREATE_STREAM);
+create_table_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) AS select(S). {
+  A = tSetCreateSQLElems(NULL, NULL, S, TSQL_CREATE_STREAM);
   setSQLInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
+
+  U.n += Z.n;
+  setCreatedTableName(pInfo, &U, &V);
 }
 
 %type column{TAOS_FIELD}
@@ -345,10 +369,10 @@ column(A) ::= ids(X) typename(Y).          {
 tagitemlist(A) ::= tagitemlist(X) COMMA tagitem(Y). { A = tVariantListAppend(X, &Y, -1);    }
 tagitemlist(A) ::= tagitem(X).                      { A = tVariantListAppend(NULL, &X, -1); }
 
-tagitem(A) ::= INTEGER(X).      {toTSDBType(X.type); tVariantCreate(&A, &X); }
-tagitem(A) ::= FLOAT(X).        {toTSDBType(X.type); tVariantCreate(&A, &X); }
-tagitem(A) ::= STRING(X).       {toTSDBType(X.type); tVariantCreate(&A, &X); }
-tagitem(A) ::= BOOL(X).         {toTSDBType(X.type); tVariantCreate(&A, &X); }
+tagitem(A) ::= INTEGER(X).      { toTSDBType(X.type); tVariantCreate(&A, &X); }
+tagitem(A) ::= FLOAT(X).        { toTSDBType(X.type); tVariantCreate(&A, &X); }
+tagitem(A) ::= STRING(X).       { toTSDBType(X.type); tVariantCreate(&A, &X); }
+tagitem(A) ::= BOOL(X).         { toTSDBType(X.type); tVariantCreate(&A, &X); }
 tagitem(A) ::= NULL(X).         { X.type = 0; tVariantCreate(&A, &X); }
 
 tagitem(A) ::= MINUS(X) INTEGER(Y).{
@@ -526,9 +550,9 @@ item(A) ::= ids(X) cpxName(Y).   {
 }
 
 %type sortorder {int}
-sortorder(A) ::= ASC.           {A = TSDB_ORDER_ASC; }
-sortorder(A) ::= DESC.          {A = TSDB_ORDER_DESC;}
-sortorder(A) ::= .              {A = TSDB_ORDER_ASC;}  //default is descend order
+sortorder(A) ::= ASC.           { A = TSDB_ORDER_ASC; }
+sortorder(A) ::= DESC.          { A = TSDB_ORDER_DESC;}
+sortorder(A) ::= .              { A = TSDB_ORDER_ASC; }  // Ascending order by default
 
 //group by clause
 %type groupby_opt {SArray*}
@@ -536,8 +560,8 @@ sortorder(A) ::= .              {A = TSDB_ORDER_ASC;}  //default is descend orde
 %type grouplist {SArray*}
 %destructor grouplist {taosArrayDestroy($$);}
 
-groupby_opt(A) ::= .                       {A = 0;}
-groupby_opt(A) ::= GROUP BY grouplist(X).  {A = X;}
+groupby_opt(A) ::= .                       { A = 0;}
+groupby_opt(A) ::= GROUP BY grouplist(X).  { A = X;}
 
 grouplist(A) ::= grouplist(X) COMMA item(Y).    {
   A = tVariantListAppend(X, &Y, -1);
@@ -583,20 +607,20 @@ where_opt(A) ::= WHERE expr(X).       {A = X;}
 
 expr(A) ::= LP(X) expr(Y) RP(Z).       {A = Y; A->token.z = X.z; A->token.n = (Z.z - X.z + 1);}
 
-expr(A) ::= ID(X).               {A = tSQLExprIdValueCreate(&X, TK_ID);}
-expr(A) ::= ID(X) DOT ID(Y).     {X.n += (1+Y.n); A = tSQLExprIdValueCreate(&X, TK_ID);}
-expr(A) ::= ID(X) DOT STAR(Y).   {X.n += (1+Y.n); A = tSQLExprIdValueCreate(&X, TK_ALL);}
-
-expr(A) ::= INTEGER(X).          {A = tSQLExprIdValueCreate(&X, TK_INTEGER);}
-expr(A) ::= MINUS(X) INTEGER(Y). {X.n += Y.n; X.type = TK_INTEGER; A = tSQLExprIdValueCreate(&X, TK_INTEGER);}
-expr(A) ::= PLUS(X)  INTEGER(Y). {X.n += Y.n; X.type = TK_INTEGER; A = tSQLExprIdValueCreate(&X, TK_INTEGER);}
-expr(A) ::= FLOAT(X).            {A = tSQLExprIdValueCreate(&X, TK_FLOAT);}
-expr(A) ::= MINUS(X) FLOAT(Y).   {X.n += Y.n; X.type = TK_FLOAT; A = tSQLExprIdValueCreate(&X, TK_FLOAT);}
-expr(A) ::= PLUS(X) FLOAT(Y).    {X.n += Y.n; X.type = TK_FLOAT; A = tSQLExprIdValueCreate(&X, TK_FLOAT);}
-expr(A) ::= STRING(X).           {A = tSQLExprIdValueCreate(&X, TK_STRING);}
-expr(A) ::= NOW(X).              {A = tSQLExprIdValueCreate(&X, TK_NOW); }
-expr(A) ::= VARIABLE(X).         {A = tSQLExprIdValueCreate(&X, TK_VARIABLE);}
-expr(A) ::= BOOL(X).             {A = tSQLExprIdValueCreate(&X, TK_BOOL);}
+expr(A) ::= ID(X).               { A = tSQLExprIdValueCreate(&X, TK_ID);}
+expr(A) ::= ID(X) DOT ID(Y).     { X.n += (1+Y.n); A = tSQLExprIdValueCreate(&X, TK_ID);}
+expr(A) ::= ID(X) DOT STAR(Y).   { X.n += (1+Y.n); A = tSQLExprIdValueCreate(&X, TK_ALL);}
+
+expr(A) ::= INTEGER(X).          { A = tSQLExprIdValueCreate(&X, TK_INTEGER);}
+expr(A) ::= MINUS(X) INTEGER(Y). { X.n += Y.n; X.type = TK_INTEGER; A = tSQLExprIdValueCreate(&X, TK_INTEGER);}
+expr(A) ::= PLUS(X)  INTEGER(Y). { X.n += Y.n; X.type = TK_INTEGER; A = tSQLExprIdValueCreate(&X, TK_INTEGER);}
+expr(A) ::= FLOAT(X).            { A = tSQLExprIdValueCreate(&X, TK_FLOAT);}
+expr(A) ::= MINUS(X) FLOAT(Y).   { X.n += Y.n; X.type = TK_FLOAT; A = tSQLExprIdValueCreate(&X, TK_FLOAT);}
+expr(A) ::= PLUS(X) FLOAT(Y).    { X.n += Y.n; X.type = TK_FLOAT; A = tSQLExprIdValueCreate(&X, TK_FLOAT);}
+expr(A) ::= STRING(X).           { A = tSQLExprIdValueCreate(&X, TK_STRING);}
+expr(A) ::= NOW(X).              { A = tSQLExprIdValueCreate(&X, TK_NOW); }
+expr(A) ::= VARIABLE(X).         { A = tSQLExprIdValueCreate(&X, TK_VARIABLE);}
+expr(A) ::= BOOL(X).             { A = tSQLExprIdValueCreate(&X, TK_BOOL);}
 
 // ordinary functions: min(x), max(x), top(k, 20)
 expr(A) ::= ID(X) LP exprlist(Y) RP(E). { A = tSQLExprCreateFunction(Y, &X, &E, X.type); }

src/query/src/qParserImpl.c

@@ -474,11 +474,18 @@ SQuerySQL *tSetQuerySQLElems(SStrToken *pSelectToken, tSQLExprList *pSelection,
   return pQuery;
 }
 
-void freeVariant(void *pItem) {
+static void freeVariant(void *pItem) {
   tVariantListItem* p = (tVariantListItem*) pItem;
   tVariantDestroy(&p->pVar);
 }
 
+void freeCreateTableInfo(void* p) {
+  SCreatedTableInfo* pInfo = (SCreatedTableInfo*) p;
+  taosArrayDestroyEx(pInfo->pTagVals, freeVariant);
+  tfree(pInfo->fullname);
+  tfree(pInfo->tagdata.data);
+}
+
 void doDestroyQuerySql(SQuerySQL *pQuerySql) {
   if (pQuerySql == NULL) {
     return;
@@ -519,31 +526,30 @@ void destroyAllSelectClause(SSubclauseInfo *pClause) {
   tfree(pClause->pClause);
 }
 
-SCreateTableSQL *tSetCreateSQLElems(SArray *pCols, SArray *pTags, SStrToken *pStableName,
-                                    SArray *pTagVals, SQuerySQL *pSelect, int32_t type) {
+SCreateTableSQL *tSetCreateSQLElems(SArray *pCols, SArray *pTags, SQuerySQL *pSelect, int32_t type) {
   SCreateTableSQL *pCreate = calloc(1, sizeof(SCreateTableSQL));
 
   switch (type) {
     case TSQL_CREATE_TABLE: {
       pCreate->colInfo.pColumns = pCols;
-      assert(pTagVals == NULL && pTags == NULL);
+      assert(pTags == NULL);
       break;
     }
     case TSQL_CREATE_STABLE: {
       pCreate->colInfo.pColumns = pCols;
       pCreate->colInfo.pTagColumns = pTags;
-      assert(pTagVals == NULL && pTags != NULL && pCols != NULL);
-      break;
-    }
-    case TSQL_CREATE_TABLE_FROM_STABLE: {
-      pCreate->usingInfo.pTagVals = pTagVals;
-      pCreate->usingInfo.stableName = *pStableName;
+      assert(pTags != NULL && pCols != NULL);
       break;
     }
     case TSQL_CREATE_STREAM: {
       pCreate->pSelect = pSelect;
       break;
     }
+
+    case TSQL_CREATE_TABLE_FROM_STABLE: {
+      assert(0);
+    }
+
     default:
       assert(false);
   }
@@ -552,10 +558,20 @@ SCreateTableSQL *tSetCreateSQLElems(SArray *pCols, SArray *pTags, SStrToken *pSt
   return pCreate;
 }
 
-SAlterTableSQL *tAlterTableSQLElems(SStrToken *pMeterName, SArray *pCols, SArray *pVals, int32_t type) {
+SCreatedTableInfo createNewChildTableInfo(SStrToken *pTableName, SArray *pTagVals, SStrToken *pToken, SStrToken* igExists) {
+  SCreatedTableInfo info = {0};
+  info.name       = *pToken;
+  info.pTagVals   = pTagVals;
+  info.stableName = *pTableName;
+  info.igExist    = (igExists->n > 0)? 1:0;
+
+  return info;
+}
+
+SAlterTableSQL *tAlterTableSQLElems(SStrToken *pTableName, SArray *pCols, SArray *pVals, int32_t type) {
   SAlterTableSQL *pAlterTable = calloc(1, sizeof(SAlterTableSQL));
   
-  pAlterTable->name = *pMeterName;
+  pAlterTable->name = *pTableName;
   pAlterTable->type = type;
 
   if (type == TSDB_ALTER_TABLE_ADD_COLUMN || type == TSDB_ALTER_TABLE_ADD_TAG_COLUMN) {
@@ -573,24 +589,29 @@ SAlterTableSQL *tAlterTableSQLElems(SStrToken *pMeterName, SArray *pCols, SArray
   return pAlterTable;
 }
 
+void* destroyCreateTableSQL(SCreateTableSQL* pCreate) {
+  doDestroyQuerySql(pCreate->pSelect);
+
+  taosArrayDestroy(pCreate->colInfo.pColumns);
+  taosArrayDestroy(pCreate->colInfo.pTagColumns);
+
+  taosArrayDestroyEx(pCreate->childTableInfo, freeCreateTableInfo);
+  tfree(pCreate);
+
+  return NULL;
+}
+
 void SQLInfoDestroy(SSqlInfo *pInfo) {
   if (pInfo == NULL) return;
 
   if (pInfo->type == TSDB_SQL_SELECT) {
     destroyAllSelectClause(&pInfo->subclauseInfo);
   } else if (pInfo->type == TSDB_SQL_CREATE_TABLE) {
-    SCreateTableSQL *pCreateTableInfo = pInfo->pCreateTableInfo;
-    doDestroyQuerySql(pCreateTableInfo->pSelect);
-
-    taosArrayDestroy(pCreateTableInfo->colInfo.pColumns);
-    taosArrayDestroy(pCreateTableInfo->colInfo.pTagColumns);
-
-    taosArrayDestroyEx(pCreateTableInfo->usingInfo.pTagVals, freeVariant);
-    tfree(pInfo->pCreateTableInfo);
+    pInfo->pCreateTableInfo = destroyCreateTableSQL(pInfo->pCreateTableInfo);
   } else if (pInfo->type == TSDB_SQL_ALTER_TABLE) {
     taosArrayDestroyEx(pInfo->pAlterInfo->varList, freeVariant);
     taosArrayDestroy(pInfo->pAlterInfo->pAddColumns);
-    
+    tfree(pInfo->pAlterInfo->tagData.data);
     tfree(pInfo->pAlterInfo);
   } else {
     if (pInfo->pDCLInfo != NULL && pInfo->pDCLInfo->nAlloc > 0) {
@@ -624,7 +645,7 @@ SSubclauseInfo* setSubclause(SSubclauseInfo* pSubclause, void *pSqlExprInfo) {
   return pSubclause;
 }
 
-SSqlInfo* setSQLInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pMeterName, int32_t type) {
+SSqlInfo* setSQLInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pTableName, int32_t type) {
   pInfo->type = type;
   
   if (type == TSDB_SQL_SELECT) {
@@ -634,8 +655,8 @@ SSqlInfo* setSQLInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pMeterName,
     pInfo->pCreateTableInfo = pSqlExprInfo;
   }
   
-  if (pMeterName != NULL) {
-    pInfo->pCreateTableInfo->name = *pMeterName;
+  if (pTableName != NULL) {
+    pInfo->pCreateTableInfo->name = *pTableName;
   }
   
   return pInfo;
@@ -653,8 +674,8 @@ SSubclauseInfo* appendSelectClause(SSubclauseInfo *pQueryInfo, void *pSubclause)
   return pQueryInfo;
 }
 
-void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pMeterName, SStrToken *pIfNotExists) {
-  pInfo->pCreateTableInfo->name = *pMeterName;
+void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pTableNameToken, SStrToken *pIfNotExists) {
+  pInfo->pCreateTableInfo->name = *pTableNameToken;
   pInfo->pCreateTableInfo->existCheck = (pIfNotExists->n != 0);
 }
 

src/query/src/sql.c

@@ -97,26 +97,27 @@
 #endif
 /************* Begin control #defines *****************************************/
 #define YYCODETYPE unsigned short int
-#define YYNOCODE 274
+#define YYNOCODE 276
 #define YYACTIONTYPE unsigned short int
 #define ParseTOKENTYPE SStrToken
 typedef union {
   int yyinit;
   ParseTOKENTYPE yy0;
-  int yy46;
-  tSQLExpr* yy64;
-  tVariant yy134;
-  SCreateAcctSQL yy149;
-  SArray* yy165;
-  int64_t yy207;
-  SLimitVal yy216;
-  TAOS_FIELD yy223;
-  SSubclauseInfo* yy231;
-  SCreateDBInfo yy268;
-  tSQLExprList* yy290;
-  SQuerySQL* yy414;
-  SCreateTableSQL* yy470;
-  SIntervalVal yy532;
+  int yy42;
+  SQuerySQL* yy84;
+  SCreatedTableInfo yy96;
+  SArray* yy131;
+  SCreateDBInfo yy148;
+  TAOS_FIELD yy163;
+  SLimitVal yy284;
+  SCreateAcctSQL yy309;
+  tSQLExpr* yy420;
+  int64_t yy459;
+  tSQLExprList* yy478;
+  SSubclauseInfo* yy513;
+  tVariant yy516;
+  SIntervalVal yy530;
+  SCreateTableSQL* yy538;
 } YYMINORTYPE;
 #ifndef YYSTACKDEPTH
 #define YYSTACKDEPTH 100
@@ -126,17 +127,17 @@ typedef union {
 #define ParseARG_FETCH SSqlInfo* pInfo = yypParser->pInfo
 #define ParseARG_STORE yypParser->pInfo = pInfo
 #define YYFALLBACK 1
-#define YYNSTATE             253
-#define YYNRULE              233
+#define YYNSTATE             257
+#define YYNRULE              236
 #define YYNTOKEN             207
-#define YY_MAX_SHIFT         252
-#define YY_MIN_SHIFTREDUCE   420
-#define YY_MAX_SHIFTREDUCE   652
-#define YY_ERROR_ACTION      653
-#define YY_ACCEPT_ACTION     654
-#define YY_NO_ACTION         655
-#define YY_MIN_REDUCE        656
-#define YY_MAX_REDUCE        888
+#define YY_MAX_SHIFT         256
+#define YY_MIN_SHIFTREDUCE   426
+#define YY_MAX_SHIFTREDUCE   661
+#define YY_ERROR_ACTION      662
+#define YY_ACCEPT_ACTION     663
+#define YY_NO_ACTION         664
+#define YY_MIN_REDUCE        665
+#define YY_MAX_REDUCE        900
 /************* End control #defines *******************************************/
 
 /* Define the yytestcase() macro to be a no-op if is not already defined
@@ -202,224 +203,226 @@ typedef union {
 **  yy_default[]       Default action for each state.
 **
 *********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (571)
+#define YY_ACTTAB_COUNT (579)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */   108,  463,  141,   11,  654,  252,  802,  463,  140,  464,
- /*    10 */   162,  165,  876,   35,   36,  464,   37,   38,  159,  250,
- /*    20 */   170,   29,  141,  463,  206,   41,   39,   43,   40,  173,
- /*    30 */   780,  464,  875,   34,   33,  145,  141,   32,   31,   30,
- /*    40 */    35,   36,  791,   37,   38,  164,  876,  170,   29,  780,
- /*    50 */    21,  206,   41,   39,   43,   40,  191,  829,  799,  201,
- /*    60 */    34,   33,   21,   21,   32,   31,   30,  421,  422,  423,
- /*    70 */   424,  425,  426,  427,  428,  429,  430,  431,  432,  251,
- /*    80 */    35,   36,  181,   37,   38,  532,  776,  170,   29,  238,
- /*    90 */   246,  206,   41,   39,   43,   40,  174,  175,  777,  777,
- /*   100 */    34,   33,  872,   56,   32,   31,   30,  176,  871,   36,
- /*   110 */   780,   37,   38,  227,  226,  170,   29,  791,   17,  206,
- /*   120 */    41,   39,   43,   40,  108,   26,  870,  606,   34,   33,
- /*   130 */    78,  160,   32,   31,   30,  238,  157,   16,  218,  245,
- /*   140 */   244,  217,  216,  215,  243,  214,  242,  241,  240,  213,
- /*   150 */   239,  755,  103,  743,  744,  745,  746,  747,  748,  749,
- /*   160 */   750,  751,  752,  753,  754,  756,   37,   38,  229,  177,
- /*   170 */   170,   29,  224,  223,  206,   41,   39,   43,   40,  203,
- /*   180 */    62,   60,    8,   34,   33,   63,  118,   32,   31,   30,
- /*   190 */   169,  619,   27,   12,  610,  184,  613,  158,  616,  778,
- /*   200 */   169,  619,  188,  187,  610,  194,  613,  108,  616,  153,
- /*   210 */   169,  619,  561,  108,  610,  154,  613,   18,  616,   90,
- /*   220 */    89,  148,  166,  167,   34,   33,  205,  143,   32,   31,
- /*   230 */    30,  697,  166,  167,  131,  144,  564,   41,   39,   43,
- /*   240 */    40,  706,  166,  167,  131,   34,   33,  146,   17,   32,
- /*   250 */    31,   30,   32,   31,   30,   26,   16,  207,  245,  244,
- /*   260 */    21,  587,  588,  243,  828,  242,  241,  240,  698,  239,
- /*   270 */    61,  131,   76,   80,  147,  190,  102,  151,   85,   88,
- /*   280 */    79,  760,  156,   26,  758,  759,   82,   21,   42,  761,
- /*   290 */   556,  763,  764,  762,  225,  765,  777,  193,   42,  618,
- /*   300 */   249,  248,   96,  574,  121,  122,  608,  105,   42,  618,
- /*   310 */    70,   66,   69,  578,  617,  168,  579,   46,  152,  618,
- /*   320 */    14,  230,  548,  777,  617,  545,  638,  546,  150,  547,
- /*   330 */    13,  135,  133,  612,  617,  615,  139,   93,   92,   91,
- /*   340 */   620,  611,  609,  614,   13,   47,  538,  622,   50,  552,
- /*   350 */    46,  553,  537,  178,  179,    3,   22,  211,   75,   74,
- /*   360 */   149,   22,   10,    9,   48,   51,  142,  550,  885,  551,
- /*   370 */    87,   86,  101,   99,  779,  839,  838,  171,  835,  834,
- /*   380 */   172,  801,  771,  228,  806,  793,  808,  104,  821,  119,
- /*   390 */   820,  117,  120,  708,  212,  137,   24,  221,  705,  222,
- /*   400 */    26,  192,  100,  884,   72,  883,  881,  123,  726,   25,
- /*   410 */   573,   23,  138,  695,   49,   81,  693,   83,   84,  691,
- /*   420 */   790,  690,  195,  161,  199,  549,   57,   52,  180,  132,
- /*   430 */   688,  687,  686,  685,  684,  134,  682,  109,  680,  678,
- /*   440 */    44,  676,  674,  136,  204,  202,   58,  822,  200,  198,
- /*   450 */   196,  220,   77,   28,  231,  232,  233,  235,  652,  234,
- /*   460 */   236,  237,  247,  209,  183,   53,  651,  182,  185,  186,
- /*   470 */    64,   67,  155,  650,  643,  189,  193,  689,  558,   94,
- /*   480 */   683,  675,  126,  125,  727,  129,  124,  127,  128,   95,
- /*   490 */   130,    1,  114,  110,  111,  775,    2,   55,   59,  116,
- /*   500 */   112,  113,  115,  575,  106,  163,  197,    5,  580,  107,
- /*   510 */     6,   65,  621,   19,    4,   20,   15,  208,  623,    7,
- /*   520 */   210,  504,  500,  498,  497,  496,  493,  467,  219,   68,
- /*   530 */    45,   71,   73,   22,  534,  533,  531,  488,   54,  486,
- /*   540 */   478,  484,  480,  482,  476,  474,  505,  503,  502,  501,
- /*   550 */   499,  495,  494,   46,  465,  436,  434,  656,  655,  655,
- /*   560 */   655,  655,  655,  655,  655,  655,  655,  655,  655,   97,
- /*   570 */    98,
+ /*     0 */   143,  469,  663,  256,  469,  162,  254,   12,  814,  470,
+ /*    10 */   887,  142,  470,   37,   38,  147,   39,   40,  803,  233,
+ /*    20 */   173,   31,  884,  469,  209,   43,   41,   45,   42,   64,
+ /*    30 */   883,  470,  163,   36,   35,  105,  143,   34,   33,   32,
+ /*    40 */    37,   38,  803,   39,   40,  168,  888,  173,   31,  110,
+ /*    50 */   790,  209,   43,   41,   45,   42,  194,  780,   22,  782,
+ /*    60 */    36,   35,  811,  882,   34,   33,   32,  427,  428,  429,
+ /*    70 */   430,  431,  432,  433,  434,  435,  436,  437,  438,  255,
+ /*    80 */    37,   38,  184,   39,   40,  538,  224,  173,   31,  143,
+ /*    90 */   197,  209,   43,   41,   45,   42,  165,   23,  167,  888,
+ /*   100 */    36,   35,  242,   57,   34,   33,   32,  179,  841,   38,
+ /*   110 */   204,   39,   40,  231,  230,  173,   31,   49,  792,  209,
+ /*   120 */    43,   41,   45,   42,  253,  252,   98,  615,   36,   35,
+ /*   130 */   178,  781,   34,   33,   32,  788,   50,   17,  222,  249,
+ /*   140 */   248,  221,  220,  219,  247,  218,  246,  245,  244,  217,
+ /*   150 */   243,  764,  792,  752,  753,  754,  755,  756,  757,  758,
+ /*   160 */   759,  760,  761,  762,  763,  765,   39,   40,  110,  180,
+ /*   170 */   173,   31,  228,  227,  209,   43,   41,   45,   42,   34,
+ /*   180 */    33,   32,    9,   36,   35,   65,  120,   34,   33,   32,
+ /*   190 */   172,  628,   18,   13,  619,  110,  622,  210,  625,   28,
+ /*   200 */   172,  628,  110,  159,  619,  187,  622,  224,  625,  155,
+ /*   210 */   172,  628,  191,  190,  619,  156,  622,   66,  625,   92,
+ /*   220 */    91,  150,  169,  170,   36,   35,  208,  840,   34,   33,
+ /*   230 */    32,  160,  169,  170,  617,  250,  573,   43,   41,   45,
+ /*   240 */    42,  706,  169,  170,  133,   36,   35,  783,   18,   34,
+ /*   250 */    33,   32,  206,  104,   61,   28,   17,  792,  249,  248,
+ /*   260 */    28,   62,  145,  247,   23,  246,  245,  244,  146,  243,
+ /*   270 */   618,  715,   78,   82,  133,  193,  565,   23,   87,   90,
+ /*   280 */    81,  769,  158,  196,  767,  768,   84,  631,   44,  770,
+ /*   290 */    23,  772,  773,  771,  148,  774,   80,  149,   44,  627,
+ /*   300 */   176,  242,  789,  707,    3,  124,  133,   23,   44,  627,
+ /*   310 */    72,   68,   71,  177,  626,  789,  596,  597,  570,  627,
+ /*   320 */   805,   63,  557,   19,  626,  554,  229,  555,  789,  556,
+ /*   330 */   171,  137,  135,   29,  626,  153,  583,   95,   94,   93,
+ /*   340 */   107,  154,  587,  234,  588,  789,   48,  647,   15,   52,
+ /*   350 */   152,   14,  629,  181,  182,  141,   14,  621,  620,  624,
+ /*   360 */   623,  546,   89,   88,  212,   24,   53,  547,   24,  151,
+ /*   370 */     4,   48,  561,  144,  562,   77,   76,   11,   10,  897,
+ /*   380 */   559,  851,  560,  103,  101,  791,  850,  174,  847,  846,
+ /*   390 */   175,  232,  813,  833,  818,  820,  106,  832,  121,  122,
+ /*   400 */    28,  123,  102,  119,  717,  216,  139,   26,  225,  714,
+ /*   410 */   195,  582,  226,  896,   74,  895,  893,  125,  735,   27,
+ /*   420 */   198,   25,  164,  202,  140,  558,  704,   83,  702,   85,
+ /*   430 */    86,  700,  699,  183,   54,  134,  697,  696,  695,  694,
+ /*   440 */   693,  136,  691,  689,   46,  687,  685,  802,  683,  138,
+ /*   450 */    51,   58,   59,  834,  207,  205,  199,  203,  201,   30,
+ /*   460 */    79,  235,  236,  237,  238,  239,  240,  241,  251,  161,
+ /*   470 */   661,  214,  215,  186,  185,  660,  189,  157,  188,   69,
+ /*   480 */   659,  652,  192,   60,  196,  166,  567,  698,   56,  128,
+ /*   490 */    96,  692,  736,  126,  130,   97,  127,  129,  131,  132,
+ /*   500 */   684,    1,  584,  787,    2,  108,  200,  117,  113,  111,
+ /*   510 */   112,  114,  115,  116,  589,  118,  109,    5,    6,   20,
+ /*   520 */    21,  630,    8,    7,  632,  211,   16,  213,   67,  510,
+ /*   530 */    65,  506,  504,  503,  502,  499,  473,  223,   24,   70,
+ /*   540 */    47,   73,  540,  539,  537,   55,  494,  492,  484,  490,
+ /*   550 */    75,  486,  488,  482,  480,  511,  509,  508,  507,  505,
+ /*   560 */   501,  500,   48,  471,  442,  440,   99,  665,  664,  664,
+ /*   570 */   664,  664,  664,  664,  664,  664,  664,  664,  100,
 };
 static const YYCODETYPE yy_lookahead[] = {
- /*     0 */   211,    1,  262,  262,  208,  209,  211,    1,  262,    9,
- /*    10 */   228,  271,  272,   13,   14,    9,   16,   17,  210,  211,
- /*    20 */    20,   21,  262,    1,   24,   25,   26,   27,   28,  228,
- /*    30 */   248,    9,  272,   33,   34,  262,  262,   37,   38,   39,
- /*    40 */    13,   14,  246,   16,   17,  271,  272,   20,   21,  248,
- /*    50 */   211,   24,   25,   26,   27,   28,  260,  268,  263,  270,
- /*    60 */    33,   34,  211,  211,   37,   38,   39,   45,   46,   47,
+ /*     0 */   264,    1,  208,  209,    1,  210,  211,  264,  211,    9,
+ /*    10 */   274,  264,    9,   13,   14,  264,   16,   17,  248,  211,
+ /*    20 */    20,   21,  264,    1,   24,   25,   26,   27,   28,  216,
+ /*    30 */   264,    9,  262,   33,   34,  211,  264,   37,   38,   39,
+ /*    40 */    13,   14,  248,   16,   17,  273,  274,   20,   21,  211,
+ /*    50 */   242,   24,   25,   26,   27,   28,  262,  244,  245,  246,
+ /*    60 */    33,   34,  265,  264,   37,   38,   39,   45,   46,   47,
  /*    70 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
- /*    80 */    13,   14,   60,   16,   17,    5,  247,   20,   21,   78,
- /*    90 */   228,   24,   25,   26,   27,   28,  245,  245,  247,  247,
- /*   100 */    33,   34,  262,  103,   37,   38,   39,   66,  262,   14,
- /*   110 */   248,   16,   17,   33,   34,   20,   21,  246,   99,   24,
- /*   120 */    25,   26,   27,   28,  211,  106,  262,  100,   33,   34,
- /*   130 */    73,  260,   37,   38,   39,   78,  262,   85,   86,   87,
+ /*    80 */    13,   14,   60,   16,   17,    5,   76,   20,   21,  264,
+ /*    90 */   266,   24,   25,   26,   27,   28,  228,  211,  273,  274,
+ /*   100 */    33,   34,   78,  103,   37,   38,   39,   66,  270,   14,
+ /*   110 */   272,   16,   17,   33,   34,   20,   21,  104,  250,   24,
+ /*   120 */    25,   26,   27,   28,   63,   64,   65,  100,   33,   34,
+ /*   130 */   228,    0,   37,   38,   39,  249,  123,   85,   86,   87,
  /*   140 */    88,   89,   90,   91,   92,   93,   94,   95,   96,   97,
- /*   150 */    98,  227,  211,  229,  230,  231,  232,  233,  234,  235,
+ /*   150 */    98,  227,  250,  229,  230,  231,  232,  233,  234,  235,
  /*   160 */   236,  237,  238,  239,  240,  241,   16,   17,  211,  128,
- /*   170 */    20,   21,  131,  132,   24,   25,   26,   27,   28,  266,
- /*   180 */   249,  268,   99,   33,   34,  102,  103,   37,   38,   39,
- /*   190 */     1,    2,  261,   44,    5,  127,    7,  262,    9,  242,
- /*   200 */     1,    2,  134,  135,    5,  264,    7,  211,    9,   60,
- /*   210 */     1,    2,  104,  211,    5,   66,    7,  109,    9,   70,
- /*   220 */    71,   72,   33,   34,   33,   34,   37,  262,   37,   38,
- /*   230 */    39,  215,   33,   34,  218,  262,   37,   25,   26,   27,
- /*   240 */    28,  215,   33,   34,  218,   33,   34,  262,   99,   37,
- /*   250 */    38,   39,   37,   38,   39,  106,   85,   15,   87,   88,
- /*   260 */   211,  116,  117,   92,  268,   94,   95,   96,  215,   98,
- /*   270 */   268,  218,   61,   62,  262,  126,   99,  262,   67,   68,
- /*   280 */    69,  227,  133,  106,  230,  231,   75,  211,   99,  235,
- /*   290 */   100,  237,  238,  239,  245,  241,  247,  107,   99,  110,
- /*   300 */    63,   64,   65,  100,   61,   62,    1,  104,   99,  110,
- /*   310 */    67,   68,   69,  100,  125,   59,  100,  104,  262,  110,
- /*   320 */   104,  245,    2,  247,  125,    5,  100,    7,  262,    9,
- /*   330 */   104,   61,   62,    5,  125,    7,  262,   67,   68,   69,
- /*   340 */   100,    5,   37,    7,  104,  104,  100,  105,  104,    5,
- /*   350 */   104,    7,  100,   33,   34,   99,  104,  100,  129,  130,
- /*   360 */   262,  104,  129,  130,  123,  121,  262,    5,  248,    7,
- /*   370 */    73,   74,   61,   62,  248,  243,  243,  243,  243,  243,
- /*   380 */   243,  211,  244,  243,  211,  246,  211,  211,  269,  211,
- /*   390 */   269,  250,  211,  211,  211,  211,  211,  211,  211,  211,
- /*   400 */   106,  246,   59,  211,  211,  211,  211,  211,  211,  211,
- /*   410 */   110,  211,  211,  211,  122,  211,  211,  211,  211,  211,
- /*   420 */   259,  211,  265,  265,  265,  105,  212,  120,  211,  211,
- /*   430 */   211,  211,  211,  211,  211,  211,  211,  258,  211,  211,
- /*   440 */   119,  211,  211,  211,  114,  118,  212,  212,  113,  112,
- /*   450 */   111,   76,   84,  124,   83,   49,   80,   53,    5,   82,
- /*   460 */    81,   79,   76,  212,    5,  212,    5,  136,  136,    5,
- /*   470 */   216,  216,  212,    5,   86,  127,  107,  212,  100,  213,
- /*   480 */   212,  212,  220,  224,  226,  222,  225,  223,  221,  213,
- /*   490 */   219,  217,  253,  257,  256,  246,  214,  108,  104,  251,
- /*   500 */   255,  254,  252,  100,   99,    1,   99,  115,  100,   99,
- /*   510 */   115,   73,  100,  104,   99,  104,   99,  101,  105,   99,
- /*   520 */   101,    9,    5,    5,    5,    5,    5,   77,   15,   73,
- /*   530 */    16,  130,  130,  104,    5,    5,  100,    5,   99,    5,
- /*   540 */     5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
- /*   550 */     5,    5,    5,  104,   77,   59,   58,    0,  273,  273,
- /*   560 */   273,  273,  273,  273,  273,  273,  273,  273,  273,   21,
- /*   570 */    21,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   580 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   590 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   600 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   610 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   620 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   630 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   640 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   650 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   660 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   670 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   680 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   690 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   700 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   710 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   720 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   730 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   740 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   750 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   760 */   273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
- /*   770 */   273,  273,  273,  273,  273,  273,  273,  273,
+ /*   170 */    20,   21,  131,  132,   24,   25,   26,   27,   28,   37,
+ /*   180 */    38,   39,   99,   33,   34,  102,  103,   37,   38,   39,
+ /*   190 */     1,    2,   99,   44,    5,  211,    7,   15,    9,  106,
+ /*   200 */     1,    2,  211,  264,    5,  127,    7,   76,    9,   60,
+ /*   210 */     1,    2,  134,  135,    5,   66,    7,  216,    9,   70,
+ /*   220 */    71,   72,   33,   34,   33,   34,   37,  270,   37,   38,
+ /*   230 */    39,  264,   33,   34,    1,  228,   37,   25,   26,   27,
+ /*   240 */    28,  215,   33,   34,  218,   33,   34,  246,   99,   37,
+ /*   250 */    38,   39,  268,   99,  270,  106,   85,  250,   87,   88,
+ /*   260 */   106,  270,  264,   92,  211,   94,   95,   96,  264,   98,
+ /*   270 */    37,  215,   61,   62,  218,  126,  100,  211,   67,   68,
+ /*   280 */    69,  227,  133,  107,  230,  231,   75,  105,   99,  235,
+ /*   290 */   211,  237,  238,  239,  264,  241,   73,  264,   99,  110,
+ /*   300 */   247,   78,  249,  215,   61,   62,  218,  211,   99,  110,
+ /*   310 */    67,   68,   69,  247,  125,  249,  116,  117,  104,  110,
+ /*   320 */   248,  251,    2,  109,  125,    5,  247,    7,  249,    9,
+ /*   330 */    59,   61,   62,  263,  125,  264,  100,   67,   68,   69,
+ /*   340 */   104,  264,  100,  247,  100,  249,  104,  100,  104,  104,
+ /*   350 */   264,  104,  100,   33,   34,  264,  104,    5,    5,    7,
+ /*   360 */     7,  100,   73,   74,  100,  104,  121,  100,  104,  264,
+ /*   370 */    99,  104,    5,  264,    7,  129,  130,  129,  130,  250,
+ /*   380 */     5,  243,    7,   61,   62,  250,  243,  243,  243,  243,
+ /*   390 */   243,  243,  211,  271,  211,  211,  211,  271,  211,  211,
+ /*   400 */   106,  211,   59,  252,  211,  211,  211,  211,  211,  211,
+ /*   410 */   248,  110,  211,  211,  211,  211,  211,  211,  211,  211,
+ /*   420 */   267,  211,  267,  267,  211,  105,  211,  211,  211,  211,
+ /*   430 */   211,  211,  211,  211,  120,  211,  211,  211,  211,  211,
+ /*   440 */   211,  211,  211,  211,  119,  211,  211,  261,  211,  211,
+ /*   450 */   122,  212,  212,  212,  114,  118,  111,  113,  112,  124,
+ /*   460 */    84,   83,   49,   80,   82,   53,   81,   79,   76,  212,
+ /*   470 */     5,  212,  212,    5,  136,    5,    5,  212,  136,  216,
+ /*   480 */     5,   86,  127,  104,  107,    1,  100,  212,  108,  220,
+ /*   490 */   213,  212,  226,  225,  221,  213,  224,  223,  222,  219,
+ /*   500 */   212,  217,  100,  248,  214,   99,   99,  254,  258,  260,
+ /*   510 */   259,  257,  256,  255,  100,  253,   99,   99,  115,  104,
+ /*   520 */   104,  100,   99,  115,  105,  101,   99,  101,   73,    9,
+ /*   530 */   102,    5,    5,    5,    5,    5,   77,   15,  104,   73,
+ /*   540 */    16,  130,    5,    5,  100,   99,    5,    5,    5,    5,
+ /*   550 */   130,    5,    5,    5,    5,    5,    5,    5,    5,    5,
+ /*   560 */     5,    5,  104,   77,   59,   58,   21,    0,  275,  275,
+ /*   570 */   275,  275,  275,  275,  275,  275,  275,  275,   21,  275,
+ /*   580 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
+ /*   590 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
+ /*   600 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
+ /*   610 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
+ /*   620 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
+ /*   630 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
+ /*   640 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
+ /*   650 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
+ /*   660 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
+ /*   670 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
+ /*   680 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
+ /*   690 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
+ /*   700 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
+ /*   710 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
+ /*   720 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
+ /*   730 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
+ /*   740 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
+ /*   750 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
+ /*   760 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
+ /*   770 */   275,  275,  275,  275,  275,  275,  275,  275,  275,  275,
+ /*   780 */   275,  275,  275,  275,  275,  275,
 };
-#define YY_SHIFT_COUNT    (252)
+#define YY_SHIFT_COUNT    (256)
 #define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (557)
+#define YY_SHIFT_MAX      (567)
 static const unsigned short int yy_shift_ofst[] = {
- /*     0 */   149,   52,  171,  189,  209,    6,    6,    6,    6,    6,
- /*    10 */     6,    0,   22,  209,  320,  320,  320,   19,    6,    6,
- /*    20 */     6,    6,    6,   57,   11,   11,  571,  199,  209,  209,
+ /*     0 */   149,   52,  171,   10,  189,  209,    3,    3,    3,    3,
+ /*    10 */     3,    3,    0,   22,  209,  320,  320,  320,   93,    3,
+ /*    20 */     3,    3,  131,    3,    3,  223,   24,   24,  579,  199,
  /*    30 */   209,  209,  209,  209,  209,  209,  209,  209,  209,  209,
- /*    40 */   209,  209,  209,  209,  209,  320,  320,   80,   80,   80,
- /*    50 */    80,   80,   80,   83,   80,  177,    6,    6,    6,    6,
- /*    60 */   145,  145,  108,    6,    6,    6,    6,    6,    6,    6,
- /*    70 */     6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
- /*    80 */     6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
- /*    90 */     6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
- /*   100 */     6,    6,  294,  343,  343,  300,  300,  300,  343,  307,
- /*   110 */   292,  321,  330,  327,  335,  337,  339,  329,  294,  343,
- /*   120 */   343,  375,  375,  343,  368,  371,  406,  376,  377,  404,
- /*   130 */   379,  382,  343,  386,  343,  386,  343,  571,  571,   27,
- /*   140 */    67,   67,   67,   95,  150,  212,  212,  212,  211,  191,
- /*   150 */   191,  191,  191,  243,  270,   41,   68,  215,  215,  237,
- /*   160 */   190,  203,  213,  216,  226,  240,  328,  336,  305,  256,
- /*   170 */   242,  241,  244,  246,  252,  257,  229,  233,  344,  362,
- /*   180 */   297,  311,  453,  331,  459,  461,  332,  464,  468,  388,
- /*   190 */   348,  369,  378,  389,  394,  403,  405,  504,  407,  408,
- /*   200 */   410,  409,  392,  411,  395,  412,  415,  413,  417,  416,
- /*   210 */   420,  419,  438,  512,  517,  518,  519,  520,  521,  450,
- /*   220 */   513,  456,  514,  401,  402,  429,  529,  530,  436,  439,
- /*   230 */   429,  532,  534,  535,  536,  537,  538,  539,  540,  541,
- /*   240 */   542,  543,  544,  545,  546,  547,  449,  477,  548,  549,
- /*   250 */   496,  498,  557,
+ /*    40 */   209,  209,  209,  209,  209,  209,  209,  320,  320,   80,
+ /*    50 */    80,   80,   80,   80,   80,   80,  154,    3,    3,    3,
+ /*    60 */     3,  200,  200,  214,    3,    3,    3,    3,    3,    3,
+ /*    70 */     3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+ /*    80 */     3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+ /*    90 */     3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+ /*   100 */     3,    3,    3,    3,  294,  343,  343,  301,  301,  301,
+ /*   110 */   343,  314,  328,  325,  340,  337,  344,  346,  345,  335,
+ /*   120 */   294,  343,  343,  343,   10,  343,  376,  378,  413,  383,
+ /*   130 */   382,  412,  385,  388,  343,  392,  343,  392,  343,  579,
+ /*   140 */   579,   27,   67,   67,   67,   95,  150,  212,  212,  212,
+ /*   150 */   211,  191,  191,  191,  191,  243,  270,   41,   78,  142,
+ /*   160 */   142,   83,   61,  176,  236,  242,  244,  247,  252,  352,
+ /*   170 */   353,  233,  271,  182,   13,  245,  261,  264,  267,  246,
+ /*   180 */   248,  367,  375,  289,  322,  465,  338,  468,  470,  342,
+ /*   190 */   471,  475,  395,  355,  377,  386,  380,  379,  402,  406,
+ /*   200 */   484,  407,  414,  417,  415,  403,  416,  408,  421,  418,
+ /*   210 */   419,  423,  424,  427,  426,  428,  455,  520,  526,  527,
+ /*   220 */   528,  529,  530,  459,  522,  466,  524,  411,  420,  434,
+ /*   230 */   537,  538,  444,  446,  434,  541,  542,  543,  544,  546,
+ /*   240 */   547,  548,  549,  550,  551,  552,  553,  554,  555,  556,
+ /*   250 */   458,  486,  545,  557,  505,  507,  567,
 };
-#define YY_REDUCE_COUNT (138)
-#define YY_REDUCE_MIN   (-260)
-#define YY_REDUCE_MAX   (282)
+#define YY_REDUCE_COUNT (140)
+#define YY_REDUCE_MIN   (-264)
+#define YY_REDUCE_MAX   (290)
 static const short yy_reduce_ofst[] = {
- /*     0 */  -204,  -76,   54, -260, -226, -211,  -87, -149, -148,   49,
- /*    10 */    76, -205, -192, -240, -218, -199, -138, -129,  -59,   -4,
- /*    20 */     2,  -43, -161,   16,   26,   53,  -69, -259, -254, -227,
- /*    30 */  -160, -154, -136, -126,  -65,  -35,  -27,  -15,   12,   15,
- /*    40 */    56,   66,   74,   98,  104,  120,  126,  132,  133,  134,
- /*    50 */   135,  136,  137,  138,  140,  139,  170,  173,  175,  176,
- /*    60 */   119,  121,  141,  178,  181,  182,  183,  184,  185,  186,
- /*    70 */   187,  188,  192,  193,  194,  195,  196,  197,  198,  200,
- /*    80 */   201,  202,  204,  205,  206,  207,  208,  210,  217,  218,
- /*    90 */   219,  220,  221,  222,  223,  224,  225,  227,  228,  230,
- /*   100 */   231,  232,  155,  214,  234,  157,  158,  159,  235,  161,
- /*   110 */   179,  236,  238,  245,  247,  239,  250,  248,  249,  251,
- /*   120 */   253,  254,  255,  260,  258,  261,  259,  262,  264,  267,
- /*   130 */   263,  271,  265,  266,  268,  276,  269,  274,  282,
+ /*     0 */  -206,  -76,   54, -187, -228, -175, -162,  -16,   53,   66,
+ /*    10 */    79,   96, -203, -205, -264, -132,  -98,    7, -230, -176,
+ /*    20 */   -43,   -9,    1, -192, -114,   26,   56,   88,   70, -257,
+ /*    30 */  -253, -249, -242, -234, -201,  -61,  -33,   -2,    4,   30,
+ /*    40 */    33,   71,   77,   86,   91,  105,  109,  129,  135,  138,
+ /*    50 */   143,  144,  145,  146,  147,  148,   72,  181,  183,  184,
+ /*    60 */   185,  122,  126,  151,  187,  188,  190,  193,  194,  195,
+ /*    70 */   196,  197,  198,  201,  202,  203,  204,  205,  206,  207,
+ /*    80 */   208,  210,  213,  215,  216,  217,  218,  219,  220,  221,
+ /*    90 */   222,  224,  225,  226,  227,  228,  229,  230,  231,  232,
+ /*   100 */   234,  235,  237,  238,  162,  239,  240,  153,  155,  156,
+ /*   110 */   241,  186,  249,  251,  250,  254,  256,  258,  253,  262,
+ /*   120 */   255,  257,  259,  260,  263,  265,  266,  268,  272,  269,
+ /*   130 */   274,  273,  276,  280,  275,  277,  279,  282,  288,  284,
+ /*   140 */   290,
 };
 static const YYACTIONTYPE yy_default[] = {
- /*     0 */   653,  707,  696,  878,  878,  653,  653,  653,  653,  653,
- /*    10 */   653,  803,  671,  878,  653,  653,  653,  653,  653,  653,
- /*    20 */   653,  653,  653,  709,  709,  709,  798,  653,  653,  653,
- /*    30 */   653,  653,  653,  653,  653,  653,  653,  653,  653,  653,
- /*    40 */   653,  653,  653,  653,  653,  653,  653,  653,  653,  653,
- /*    50 */   653,  653,  653,  653,  653,  653,  653,  805,  807,  653,
- /*    60 */   825,  825,  796,  653,  653,  653,  653,  653,  653,  653,
- /*    70 */   653,  653,  653,  653,  653,  653,  653,  653,  653,  653,
- /*    80 */   653,  694,  653,  692,  653,  653,  653,  653,  653,  653,
- /*    90 */   653,  653,  653,  653,  653,  653,  681,  653,  653,  653,
- /*   100 */   653,  653,  653,  673,  673,  653,  653,  653,  673,  832,
- /*   110 */   836,  830,  818,  826,  817,  813,  812,  840,  653,  673,
- /*   120 */   673,  704,  704,  673,  725,  723,  721,  713,  719,  715,
- /*   130 */   717,  711,  673,  702,  673,  702,  673,  742,  757,  653,
- /*   140 */   841,  877,  831,  867,  866,  873,  865,  864,  653,  860,
- /*   150 */   861,  863,  862,  653,  653,  653,  653,  869,  868,  653,
- /*   160 */   653,  653,  653,  653,  653,  653,  653,  653,  653,  843,
- /*   170 */   653,  837,  833,  653,  653,  653,  653,  653,  653,  653,
- /*   180 */   653,  653,  653,  653,  653,  653,  653,  653,  653,  653,
- /*   190 */   653,  795,  653,  653,  804,  653,  653,  653,  653,  653,
- /*   200 */   653,  827,  653,  819,  653,  653,  653,  653,  653,  653,
- /*   210 */   653,  772,  653,  653,  653,  653,  653,  653,  653,  653,
- /*   220 */   653,  653,  653,  653,  653,  882,  653,  653,  653,  766,
- /*   230 */   880,  653,  653,  653,  653,  653,  653,  653,  653,  653,
- /*   240 */   653,  653,  653,  653,  653,  653,  728,  653,  679,  677,
- /*   250 */   653,  669,  653,
+ /*     0 */   662,  716,  705,  713,  890,  890,  662,  662,  662,  662,
+ /*    10 */   662,  662,  815,  680,  890,  662,  662,  662,  662,  662,
+ /*    20 */   662,  662,  713,  662,  662,  718,  718,  718,  810,  662,
+ /*    30 */   662,  662,  662,  662,  662,  662,  662,  662,  662,  662,
+ /*    40 */   662,  662,  662,  662,  662,  662,  662,  662,  662,  662,
+ /*    50 */   662,  662,  662,  662,  662,  662,  662,  662,  817,  819,
+ /*    60 */   662,  837,  837,  808,  662,  662,  662,  662,  662,  662,
+ /*    70 */   662,  662,  662,  662,  662,  662,  662,  662,  662,  662,
+ /*    80 */   662,  662,  662,  703,  662,  701,  662,  662,  662,  662,
+ /*    90 */   662,  662,  662,  662,  662,  662,  662,  662,  690,  662,
+ /*   100 */   662,  662,  662,  662,  662,  682,  682,  662,  662,  662,
+ /*   110 */   682,  844,  848,  842,  830,  838,  829,  825,  824,  852,
+ /*   120 */   662,  682,  682,  682,  713,  682,  734,  732,  730,  722,
+ /*   130 */   728,  724,  726,  720,  682,  711,  682,  711,  682,  751,
+ /*   140 */   766,  662,  853,  889,  843,  879,  878,  885,  877,  876,
+ /*   150 */   662,  872,  873,  875,  874,  662,  662,  662,  662,  881,
+ /*   160 */   880,  662,  662,  662,  662,  662,  662,  662,  662,  662,
+ /*   170 */   662,  662,  855,  662,  849,  845,  662,  662,  662,  662,
+ /*   180 */   662,  662,  662,  662,  662,  662,  662,  662,  662,  662,
+ /*   190 */   662,  662,  662,  662,  807,  662,  662,  816,  662,  662,
+ /*   200 */   662,  662,  662,  662,  839,  662,  831,  662,  662,  662,
+ /*   210 */   662,  662,  784,  662,  662,  662,  662,  662,  662,  662,
+ /*   220 */   662,  662,  662,  662,  662,  662,  662,  662,  662,  894,
+ /*   230 */   662,  662,  662,  775,  892,  662,  662,  662,  662,  662,
+ /*   240 */   662,  662,  662,  662,  662,  662,  662,  662,  662,  662,
+ /*   250 */   737,  662,  688,  686,  662,  678,  662,
 };
 /********** End of lemon-generated parsing tables *****************************/
 
@@ -977,34 +980,36 @@ static const char *const yyTokenName[] = {
   /*  242 */ "typename",
   /*  243 */ "signed",
   /*  244 */ "create_table_args",
-  /*  245 */ "columnlist",
-  /*  246 */ "select",
-  /*  247 */ "column",
-  /*  248 */ "tagitem",
-  /*  249 */ "selcollist",
-  /*  250 */ "from",
-  /*  251 */ "where_opt",
-  /*  252 */ "interval_opt",
-  /*  253 */ "fill_opt",
-  /*  254 */ "sliding_opt",
-  /*  255 */ "groupby_opt",
-  /*  256 */ "orderby_opt",
-  /*  257 */ "having_opt",
-  /*  258 */ "slimit_opt",
-  /*  259 */ "limit_opt",
-  /*  260 */ "union",
-  /*  261 */ "sclp",
-  /*  262 */ "expr",
-  /*  263 */ "as",
-  /*  264 */ "tablelist",
-  /*  265 */ "tmvar",
-  /*  266 */ "sortlist",
-  /*  267 */ "sortitem",
-  /*  268 */ "item",
-  /*  269 */ "sortorder",
-  /*  270 */ "grouplist",
-  /*  271 */ "exprlist",
-  /*  272 */ "expritem",
+  /*  245 */ "create_table_list",
+  /*  246 */ "create_from_stable",
+  /*  247 */ "columnlist",
+  /*  248 */ "select",
+  /*  249 */ "column",
+  /*  250 */ "tagitem",
+  /*  251 */ "selcollist",
+  /*  252 */ "from",
+  /*  253 */ "where_opt",
+  /*  254 */ "interval_opt",
+  /*  255 */ "fill_opt",
+  /*  256 */ "sliding_opt",
+  /*  257 */ "groupby_opt",
+  /*  258 */ "orderby_opt",
+  /*  259 */ "having_opt",
+  /*  260 */ "slimit_opt",
+  /*  261 */ "limit_opt",
+  /*  262 */ "union",
+  /*  263 */ "sclp",
+  /*  264 */ "expr",
+  /*  265 */ "as",
+  /*  266 */ "tablelist",
+  /*  267 */ "tmvar",
+  /*  268 */ "sortlist",
+  /*  269 */ "sortitem",
+  /*  270 */ "item",
+  /*  271 */ "sortorder",
+  /*  272 */ "grouplist",
+  /*  273 */ "exprlist",
+  /*  274 */ "expritem",
 };
 #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
 
@@ -1127,124 +1132,127 @@ static const char *const yyRuleName[] = {
  /* 112 */ "signed ::= INTEGER",
  /* 113 */ "signed ::= PLUS INTEGER",
  /* 114 */ "signed ::= MINUS INTEGER",
- /* 115 */ "cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args",
- /* 116 */ "create_table_args ::= LP columnlist RP",
- /* 117 */ "create_table_args ::= LP columnlist RP TAGS LP columnlist RP",
- /* 118 */ "create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP",
- /* 119 */ "create_table_args ::= AS select",
- /* 120 */ "columnlist ::= columnlist COMMA column",
- /* 121 */ "columnlist ::= column",
- /* 122 */ "column ::= ids typename",
- /* 123 */ "tagitemlist ::= tagitemlist COMMA tagitem",
- /* 124 */ "tagitemlist ::= tagitem",
- /* 125 */ "tagitem ::= INTEGER",
- /* 126 */ "tagitem ::= FLOAT",
- /* 127 */ "tagitem ::= STRING",
- /* 128 */ "tagitem ::= BOOL",
- /* 129 */ "tagitem ::= NULL",
- /* 130 */ "tagitem ::= MINUS INTEGER",
- /* 131 */ "tagitem ::= MINUS FLOAT",
- /* 132 */ "tagitem ::= PLUS INTEGER",
- /* 133 */ "tagitem ::= PLUS FLOAT",
- /* 134 */ "select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt",
- /* 135 */ "union ::= select",
- /* 136 */ "union ::= LP union RP",
- /* 137 */ "union ::= union UNION ALL select",
- /* 138 */ "union ::= union UNION ALL LP select RP",
- /* 139 */ "cmd ::= union",
- /* 140 */ "select ::= SELECT selcollist",
- /* 141 */ "sclp ::= selcollist COMMA",
- /* 142 */ "sclp ::=",
- /* 143 */ "selcollist ::= sclp expr as",
- /* 144 */ "selcollist ::= sclp STAR",
- /* 145 */ "as ::= AS ids",
- /* 146 */ "as ::= ids",
- /* 147 */ "as ::=",
- /* 148 */ "from ::= FROM tablelist",
- /* 149 */ "tablelist ::= ids cpxName",
- /* 150 */ "tablelist ::= ids cpxName ids",
- /* 151 */ "tablelist ::= tablelist COMMA ids cpxName",
- /* 152 */ "tablelist ::= tablelist COMMA ids cpxName ids",
- /* 153 */ "tmvar ::= VARIABLE",
- /* 154 */ "interval_opt ::= INTERVAL LP tmvar RP",
- /* 155 */ "interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP",
- /* 156 */ "interval_opt ::=",
- /* 157 */ "fill_opt ::=",
- /* 158 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
- /* 159 */ "fill_opt ::= FILL LP ID RP",
- /* 160 */ "sliding_opt ::= SLIDING LP tmvar RP",
- /* 161 */ "sliding_opt ::=",
- /* 162 */ "orderby_opt ::=",
- /* 163 */ "orderby_opt ::= ORDER BY sortlist",
- /* 164 */ "sortlist ::= sortlist COMMA item sortorder",
- /* 165 */ "sortlist ::= item sortorder",
- /* 166 */ "item ::= ids cpxName",
- /* 167 */ "sortorder ::= ASC",
- /* 168 */ "sortorder ::= DESC",
- /* 169 */ "sortorder ::=",
- /* 170 */ "groupby_opt ::=",
- /* 171 */ "groupby_opt ::= GROUP BY grouplist",
- /* 172 */ "grouplist ::= grouplist COMMA item",
- /* 173 */ "grouplist ::= item",
- /* 174 */ "having_opt ::=",
- /* 175 */ "having_opt ::= HAVING expr",
- /* 176 */ "limit_opt ::=",
- /* 177 */ "limit_opt ::= LIMIT signed",
- /* 178 */ "limit_opt ::= LIMIT signed OFFSET signed",
- /* 179 */ "limit_opt ::= LIMIT signed COMMA signed",
- /* 180 */ "slimit_opt ::=",
- /* 181 */ "slimit_opt ::= SLIMIT signed",
- /* 182 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
- /* 183 */ "slimit_opt ::= SLIMIT signed COMMA signed",
- /* 184 */ "where_opt ::=",
- /* 185 */ "where_opt ::= WHERE expr",
- /* 186 */ "expr ::= LP expr RP",
- /* 187 */ "expr ::= ID",
- /* 188 */ "expr ::= ID DOT ID",
- /* 189 */ "expr ::= ID DOT STAR",
- /* 190 */ "expr ::= INTEGER",
- /* 191 */ "expr ::= MINUS INTEGER",
- /* 192 */ "expr ::= PLUS INTEGER",
- /* 193 */ "expr ::= FLOAT",
- /* 194 */ "expr ::= MINUS FLOAT",
- /* 195 */ "expr ::= PLUS FLOAT",
- /* 196 */ "expr ::= STRING",
- /* 197 */ "expr ::= NOW",
- /* 198 */ "expr ::= VARIABLE",
- /* 199 */ "expr ::= BOOL",
- /* 200 */ "expr ::= ID LP exprlist RP",
- /* 201 */ "expr ::= ID LP STAR RP",
- /* 202 */ "expr ::= expr IS NULL",
- /* 203 */ "expr ::= expr IS NOT NULL",
- /* 204 */ "expr ::= expr LT expr",
- /* 205 */ "expr ::= expr GT expr",
- /* 206 */ "expr ::= expr LE expr",
- /* 207 */ "expr ::= expr GE expr",
- /* 208 */ "expr ::= expr NE expr",
- /* 209 */ "expr ::= expr EQ expr",
- /* 210 */ "expr ::= expr AND expr",
- /* 211 */ "expr ::= expr OR expr",
- /* 212 */ "expr ::= expr PLUS expr",
- /* 213 */ "expr ::= expr MINUS expr",
- /* 214 */ "expr ::= expr STAR expr",
- /* 215 */ "expr ::= expr SLASH expr",
- /* 216 */ "expr ::= expr REM expr",
- /* 217 */ "expr ::= expr LIKE expr",
- /* 218 */ "expr ::= expr IN LP exprlist RP",
- /* 219 */ "exprlist ::= exprlist COMMA expritem",
- /* 220 */ "exprlist ::= expritem",
- /* 221 */ "expritem ::= expr",
- /* 222 */ "expritem ::=",
- /* 223 */ "cmd ::= RESET QUERY CACHE",
- /* 224 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
- /* 225 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
- /* 226 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
- /* 227 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
- /* 228 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
- /* 229 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
- /* 230 */ "cmd ::= KILL CONNECTION INTEGER",
- /* 231 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
- /* 232 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
+ /* 115 */ "cmd ::= CREATE TABLE create_table_args",
+ /* 116 */ "cmd ::= CREATE TABLE create_table_list",
+ /* 117 */ "create_table_list ::= create_from_stable",
+ /* 118 */ "create_table_list ::= create_table_list create_from_stable",
+ /* 119 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP",
+ /* 120 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP",
+ /* 121 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP",
+ /* 122 */ "create_table_args ::= ifnotexists ids cpxName AS select",
+ /* 123 */ "columnlist ::= columnlist COMMA column",
+ /* 124 */ "columnlist ::= column",
+ /* 125 */ "column ::= ids typename",
+ /* 126 */ "tagitemlist ::= tagitemlist COMMA tagitem",
+ /* 127 */ "tagitemlist ::= tagitem",
+ /* 128 */ "tagitem ::= INTEGER",
+ /* 129 */ "tagitem ::= FLOAT",
+ /* 130 */ "tagitem ::= STRING",
+ /* 131 */ "tagitem ::= BOOL",
+ /* 132 */ "tagitem ::= NULL",
+ /* 133 */ "tagitem ::= MINUS INTEGER",
+ /* 134 */ "tagitem ::= MINUS FLOAT",
+ /* 135 */ "tagitem ::= PLUS INTEGER",
+ /* 136 */ "tagitem ::= PLUS FLOAT",
+ /* 137 */ "select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt",
+ /* 138 */ "union ::= select",
+ /* 139 */ "union ::= LP union RP",
+ /* 140 */ "union ::= union UNION ALL select",
+ /* 141 */ "union ::= union UNION ALL LP select RP",
+ /* 142 */ "cmd ::= union",
+ /* 143 */ "select ::= SELECT selcollist",
+ /* 144 */ "sclp ::= selcollist COMMA",
+ /* 145 */ "sclp ::=",
+ /* 146 */ "selcollist ::= sclp expr as",
+ /* 147 */ "selcollist ::= sclp STAR",
+ /* 148 */ "as ::= AS ids",
+ /* 149 */ "as ::= ids",
+ /* 150 */ "as ::=",
+ /* 151 */ "from ::= FROM tablelist",
+ /* 152 */ "tablelist ::= ids cpxName",
+ /* 153 */ "tablelist ::= ids cpxName ids",
+ /* 154 */ "tablelist ::= tablelist COMMA ids cpxName",
+ /* 155 */ "tablelist ::= tablelist COMMA ids cpxName ids",
+ /* 156 */ "tmvar ::= VARIABLE",
+ /* 157 */ "interval_opt ::= INTERVAL LP tmvar RP",
+ /* 158 */ "interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP",
+ /* 159 */ "interval_opt ::=",
+ /* 160 */ "fill_opt ::=",
+ /* 161 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
+ /* 162 */ "fill_opt ::= FILL LP ID RP",
+ /* 163 */ "sliding_opt ::= SLIDING LP tmvar RP",
+ /* 164 */ "sliding_opt ::=",
+ /* 165 */ "orderby_opt ::=",
+ /* 166 */ "orderby_opt ::= ORDER BY sortlist",
+ /* 167 */ "sortlist ::= sortlist COMMA item sortorder",
+ /* 168 */ "sortlist ::= item sortorder",
+ /* 169 */ "item ::= ids cpxName",
+ /* 170 */ "sortorder ::= ASC",
+ /* 171 */ "sortorder ::= DESC",
+ /* 172 */ "sortorder ::=",
+ /* 173 */ "groupby_opt ::=",
+ /* 174 */ "groupby_opt ::= GROUP BY grouplist",
+ /* 175 */ "grouplist ::= grouplist COMMA item",
+ /* 176 */ "grouplist ::= item",
+ /* 177 */ "having_opt ::=",
+ /* 178 */ "having_opt ::= HAVING expr",
+ /* 179 */ "limit_opt ::=",
+ /* 180 */ "limit_opt ::= LIMIT signed",
+ /* 181 */ "limit_opt ::= LIMIT signed OFFSET signed",
+ /* 182 */ "limit_opt ::= LIMIT signed COMMA signed",
+ /* 183 */ "slimit_opt ::=",
+ /* 184 */ "slimit_opt ::= SLIMIT signed",
+ /* 185 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
+ /* 186 */ "slimit_opt ::= SLIMIT signed COMMA signed",
+ /* 187 */ "where_opt ::=",
+ /* 188 */ "where_opt ::= WHERE expr",
+ /* 189 */ "expr ::= LP expr RP",
+ /* 190 */ "expr ::= ID",
+ /* 191 */ "expr ::= ID DOT ID",
+ /* 192 */ "expr ::= ID DOT STAR",
+ /* 193 */ "expr ::= INTEGER",
+ /* 194 */ "expr ::= MINUS INTEGER",
+ /* 195 */ "expr ::= PLUS INTEGER",
+ /* 196 */ "expr ::= FLOAT",
+ /* 197 */ "expr ::= MINUS FLOAT",
+ /* 198 */ "expr ::= PLUS FLOAT",
+ /* 199 */ "expr ::= STRING",
+ /* 200 */ "expr ::= NOW",
+ /* 201 */ "expr ::= VARIABLE",
+ /* 202 */ "expr ::= BOOL",
+ /* 203 */ "expr ::= ID LP exprlist RP",
+ /* 204 */ "expr ::= ID LP STAR RP",
+ /* 205 */ "expr ::= expr IS NULL",
+ /* 206 */ "expr ::= expr IS NOT NULL",
+ /* 207 */ "expr ::= expr LT expr",
+ /* 208 */ "expr ::= expr GT expr",
+ /* 209 */ "expr ::= expr LE expr",
+ /* 210 */ "expr ::= expr GE expr",
+ /* 211 */ "expr ::= expr NE expr",
+ /* 212 */ "expr ::= expr EQ expr",
+ /* 213 */ "expr ::= expr AND expr",
+ /* 214 */ "expr ::= expr OR expr",
+ /* 215 */ "expr ::= expr PLUS expr",
+ /* 216 */ "expr ::= expr MINUS expr",
+ /* 217 */ "expr ::= expr STAR expr",
+ /* 218 */ "expr ::= expr SLASH expr",
+ /* 219 */ "expr ::= expr REM expr",
+ /* 220 */ "expr ::= expr LIKE expr",
+ /* 221 */ "expr ::= expr IN LP exprlist RP",
+ /* 222 */ "exprlist ::= exprlist COMMA expritem",
+ /* 223 */ "exprlist ::= expritem",
+ /* 224 */ "expritem ::= expr",
+ /* 225 */ "expritem ::=",
+ /* 226 */ "cmd ::= RESET QUERY CACHE",
+ /* 227 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
+ /* 228 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
+ /* 229 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
+ /* 230 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
+ /* 231 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
+ /* 232 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
+ /* 233 */ "cmd ::= KILL CONNECTION INTEGER",
+ /* 234 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
+ /* 235 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
 };
 #endif /* NDEBUG */
 
@@ -1367,44 +1375,49 @@ static void yy_destructor(
 /********* Begin destructor definitions ***************************************/
     case 227: /* keep */
     case 228: /* tagitemlist */
-    case 245: /* columnlist */
-    case 253: /* fill_opt */
-    case 255: /* groupby_opt */
-    case 256: /* orderby_opt */
-    case 266: /* sortlist */
-    case 270: /* grouplist */
+    case 247: /* columnlist */
+    case 255: /* fill_opt */
+    case 257: /* groupby_opt */
+    case 258: /* orderby_opt */
+    case 268: /* sortlist */
+    case 272: /* grouplist */
 {
-taosArrayDestroy((yypminor->yy165));
+taosArrayDestroy((yypminor->yy131));
 }
       break;
-    case 246: /* select */
+    case 245: /* create_table_list */
 {
-doDestroyQuerySql((yypminor->yy414));
+destroyCreateTableSQL((yypminor->yy538));
 }
       break;
-    case 249: /* selcollist */
-    case 261: /* sclp */
-    case 271: /* exprlist */
+    case 248: /* select */
 {
-tSQLExprListDestroy((yypminor->yy290));
+doDestroyQuerySql((yypminor->yy84));
 }
       break;
-    case 251: /* where_opt */
-    case 257: /* having_opt */
-    case 262: /* expr */
-    case 272: /* expritem */
+    case 251: /* selcollist */
+    case 263: /* sclp */
+    case 273: /* exprlist */
 {
-tSQLExprDestroy((yypminor->yy64));
+tSQLExprListDestroy((yypminor->yy478));
 }
       break;
-    case 260: /* union */
+    case 253: /* where_opt */
+    case 259: /* having_opt */
+    case 264: /* expr */
+    case 274: /* expritem */
 {
-destroyAllSelectClause((yypminor->yy231));
+tSQLExprDestroy((yypminor->yy420));
 }
       break;
-    case 267: /* sortitem */
+    case 262: /* union */
 {
-tVariantDestroy(&(yypminor->yy134));
+destroyAllSelectClause((yypminor->yy513));
+}
+      break;
+    case 269: /* sortitem */
+{
+tVariantDestroy(&(yypminor->yy516));
 }
       break;
 /********* End destructor definitions *****************************************/
@@ -1813,124 +1826,127 @@ static const struct {
   {  243,   -1 }, /* (112) signed ::= INTEGER */
   {  243,   -2 }, /* (113) signed ::= PLUS INTEGER */
   {  243,   -2 }, /* (114) signed ::= MINUS INTEGER */
-  {  209,   -6 }, /* (115) cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args */
-  {  244,   -3 }, /* (116) create_table_args ::= LP columnlist RP */
-  {  244,   -7 }, /* (117) create_table_args ::= LP columnlist RP TAGS LP columnlist RP */
-  {  244,   -7 }, /* (118) create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP */
-  {  244,   -2 }, /* (119) create_table_args ::= AS select */
-  {  245,   -3 }, /* (120) columnlist ::= columnlist COMMA column */
-  {  245,   -1 }, /* (121) columnlist ::= column */
-  {  247,   -2 }, /* (122) column ::= ids typename */
-  {  228,   -3 }, /* (123) tagitemlist ::= tagitemlist COMMA tagitem */
-  {  228,   -1 }, /* (124) tagitemlist ::= tagitem */
-  {  248,   -1 }, /* (125) tagitem ::= INTEGER */
-  {  248,   -1 }, /* (126) tagitem ::= FLOAT */
-  {  248,   -1 }, /* (127) tagitem ::= STRING */
-  {  248,   -1 }, /* (128) tagitem ::= BOOL */
-  {  248,   -1 }, /* (129) tagitem ::= NULL */
-  {  248,   -2 }, /* (130) tagitem ::= MINUS INTEGER */
-  {  248,   -2 }, /* (131) tagitem ::= MINUS FLOAT */
-  {  248,   -2 }, /* (132) tagitem ::= PLUS INTEGER */
-  {  248,   -2 }, /* (133) tagitem ::= PLUS FLOAT */
-  {  246,  -12 }, /* (134) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
-  {  260,   -1 }, /* (135) union ::= select */
-  {  260,   -3 }, /* (136) union ::= LP union RP */
-  {  260,   -4 }, /* (137) union ::= union UNION ALL select */
-  {  260,   -6 }, /* (138) union ::= union UNION ALL LP select RP */
-  {  209,   -1 }, /* (139) cmd ::= union */
-  {  246,   -2 }, /* (140) select ::= SELECT selcollist */
-  {  261,   -2 }, /* (141) sclp ::= selcollist COMMA */
-  {  261,    0 }, /* (142) sclp ::= */
-  {  249,   -3 }, /* (143) selcollist ::= sclp expr as */
-  {  249,   -2 }, /* (144) selcollist ::= sclp STAR */
-  {  263,   -2 }, /* (145) as ::= AS ids */
-  {  263,   -1 }, /* (146) as ::= ids */
-  {  263,    0 }, /* (147) as ::= */
-  {  250,   -2 }, /* (148) from ::= FROM tablelist */
-  {  264,   -2 }, /* (149) tablelist ::= ids cpxName */
-  {  264,   -3 }, /* (150) tablelist ::= ids cpxName ids */
-  {  264,   -4 }, /* (151) tablelist ::= tablelist COMMA ids cpxName */
-  {  264,   -5 }, /* (152) tablelist ::= tablelist COMMA ids cpxName ids */
-  {  265,   -1 }, /* (153) tmvar ::= VARIABLE */
-  {  252,   -4 }, /* (154) interval_opt ::= INTERVAL LP tmvar RP */
-  {  252,   -6 }, /* (155) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
-  {  252,    0 }, /* (156) interval_opt ::= */
-  {  253,    0 }, /* (157) fill_opt ::= */
-  {  253,   -6 }, /* (158) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
-  {  253,   -4 }, /* (159) fill_opt ::= FILL LP ID RP */
-  {  254,   -4 }, /* (160) sliding_opt ::= SLIDING LP tmvar RP */
-  {  254,    0 }, /* (161) sliding_opt ::= */
-  {  256,    0 }, /* (162) orderby_opt ::= */
-  {  256,   -3 }, /* (163) orderby_opt ::= ORDER BY sortlist */
-  {  266,   -4 }, /* (164) sortlist ::= sortlist COMMA item sortorder */
-  {  266,   -2 }, /* (165) sortlist ::= item sortorder */
-  {  268,   -2 }, /* (166) item ::= ids cpxName */
-  {  269,   -1 }, /* (167) sortorder ::= ASC */
-  {  269,   -1 }, /* (168) sortorder ::= DESC */
-  {  269,    0 }, /* (169) sortorder ::= */
-  {  255,    0 }, /* (170) groupby_opt ::= */
-  {  255,   -3 }, /* (171) groupby_opt ::= GROUP BY grouplist */
-  {  270,   -3 }, /* (172) grouplist ::= grouplist COMMA item */
-  {  270,   -1 }, /* (173) grouplist ::= item */
-  {  257,    0 }, /* (174) having_opt ::= */
-  {  257,   -2 }, /* (175) having_opt ::= HAVING expr */
-  {  259,    0 }, /* (176) limit_opt ::= */
-  {  259,   -2 }, /* (177) limit_opt ::= LIMIT signed */
-  {  259,   -4 }, /* (178) limit_opt ::= LIMIT signed OFFSET signed */
-  {  259,   -4 }, /* (179) limit_opt ::= LIMIT signed COMMA signed */
-  {  258,    0 }, /* (180) slimit_opt ::= */
-  {  258,   -2 }, /* (181) slimit_opt ::= SLIMIT signed */
-  {  258,   -4 }, /* (182) slimit_opt ::= SLIMIT signed SOFFSET signed */
-  {  258,   -4 }, /* (183) slimit_opt ::= SLIMIT signed COMMA signed */
-  {  251,    0 }, /* (184) where_opt ::= */
-  {  251,   -2 }, /* (185) where_opt ::= WHERE expr */
-  {  262,   -3 }, /* (186) expr ::= LP expr RP */
-  {  262,   -1 }, /* (187) expr ::= ID */
-  {  262,   -3 }, /* (188) expr ::= ID DOT ID */
-  {  262,   -3 }, /* (189) expr ::= ID DOT STAR */
-  {  262,   -1 }, /* (190) expr ::= INTEGER */
-  {  262,   -2 }, /* (191) expr ::= MINUS INTEGER */
-  {  262,   -2 }, /* (192) expr ::= PLUS INTEGER */
-  {  262,   -1 }, /* (193) expr ::= FLOAT */
-  {  262,   -2 }, /* (194) expr ::= MINUS FLOAT */
-  {  262,   -2 }, /* (195) expr ::= PLUS FLOAT */
-  {  262,   -1 }, /* (196) expr ::= STRING */
-  {  262,   -1 }, /* (197) expr ::= NOW */
-  {  262,   -1 }, /* (198) expr ::= VARIABLE */
-  {  262,   -1 }, /* (199) expr ::= BOOL */
-  {  262,   -4 }, /* (200) expr ::= ID LP exprlist RP */
-  {  262,   -4 }, /* (201) expr ::= ID LP STAR RP */
-  {  262,   -3 }, /* (202) expr ::= expr IS NULL */
-  {  262,   -4 }, /* (203) expr ::= expr IS NOT NULL */
-  {  262,   -3 }, /* (204) expr ::= expr LT expr */
-  {  262,   -3 }, /* (205) expr ::= expr GT expr */
-  {  262,   -3 }, /* (206) expr ::= expr LE expr */
-  {  262,   -3 }, /* (207) expr ::= expr GE expr */
-  {  262,   -3 }, /* (208) expr ::= expr NE expr */
-  {  262,   -3 }, /* (209) expr ::= expr EQ expr */
-  {  262,   -3 }, /* (210) expr ::= expr AND expr */
-  {  262,   -3 }, /* (211) expr ::= expr OR expr */
-  {  262,   -3 }, /* (212) expr ::= expr PLUS expr */
-  {  262,   -3 }, /* (213) expr ::= expr MINUS expr */
-  {  262,   -3 }, /* (214) expr ::= expr STAR expr */
-  {  262,   -3 }, /* (215) expr ::= expr SLASH expr */
-  {  262,   -3 }, /* (216) expr ::= expr REM expr */
-  {  262,   -3 }, /* (217) expr ::= expr LIKE expr */
-  {  262,   -5 }, /* (218) expr ::= expr IN LP exprlist RP */
-  {  271,   -3 }, /* (219) exprlist ::= exprlist COMMA expritem */
-  {  271,   -1 }, /* (220) exprlist ::= expritem */
-  {  272,   -1 }, /* (221) expritem ::= expr */
-  {  272,    0 }, /* (222) expritem ::= */
-  {  209,   -3 }, /* (223) cmd ::= RESET QUERY CACHE */
-  {  209,   -7 }, /* (224) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
-  {  209,   -7 }, /* (225) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
-  {  209,   -7 }, /* (226) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
-  {  209,   -7 }, /* (227) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
-  {  209,   -8 }, /* (228) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
-  {  209,   -9 }, /* (229) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
-  {  209,   -3 }, /* (230) cmd ::= KILL CONNECTION INTEGER */
-  {  209,   -5 }, /* (231) cmd ::= KILL STREAM INTEGER COLON INTEGER */
-  {  209,   -5 }, /* (232) cmd ::= KILL QUERY INTEGER COLON INTEGER */
+  {  209,   -3 }, /* (115) cmd ::= CREATE TABLE create_table_args */
+  {  209,   -3 }, /* (116) cmd ::= CREATE TABLE create_table_list */
+  {  245,   -1 }, /* (117) create_table_list ::= create_from_stable */
+  {  245,   -2 }, /* (118) create_table_list ::= create_table_list create_from_stable */
+  {  244,   -6 }, /* (119) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
+  {  244,  -10 }, /* (120) create_table_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
+  {  246,  -10 }, /* (121) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
+  {  244,   -5 }, /* (122) create_table_args ::= ifnotexists ids cpxName AS select */
+  {  247,   -3 }, /* (123) columnlist ::= columnlist COMMA column */
+  {  247,   -1 }, /* (124) columnlist ::= column */
+  {  249,   -2 }, /* (125) column ::= ids typename */
+  {  228,   -3 }, /* (126) tagitemlist ::= tagitemlist COMMA tagitem */
+  {  228,   -1 }, /* (127) tagitemlist ::= tagitem */
+  {  250,   -1 }, /* (128) tagitem ::= INTEGER */
+  {  250,   -1 }, /* (129) tagitem ::= FLOAT */
+  {  250,   -1 }, /* (130) tagitem ::= STRING */
+  {  250,   -1 }, /* (131) tagitem ::= BOOL */
+  {  250,   -1 }, /* (132) tagitem ::= NULL */
+  {  250,   -2 }, /* (133) tagitem ::= MINUS INTEGER */
+  {  250,   -2 }, /* (134) tagitem ::= MINUS FLOAT */
+  {  250,   -2 }, /* (135) tagitem ::= PLUS INTEGER */
+  {  250,   -2 }, /* (136) tagitem ::= PLUS FLOAT */
+  {  248,  -12 }, /* (137) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
+  {  262,   -1 }, /* (138) union ::= select */
+  {  262,   -3 }, /* (139) union ::= LP union RP */
+  {  262,   -4 }, /* (140) union ::= union UNION ALL select */
+  {  262,   -6 }, /* (141) union ::= union UNION ALL LP select RP */
+  {  209,   -1 }, /* (142) cmd ::= union */
+  {  248,   -2 }, /* (143) select ::= SELECT selcollist */
+  {  263,   -2 }, /* (144) sclp ::= selcollist COMMA */
+  {  263,    0 }, /* (145) sclp ::= */
+  {  251,   -3 }, /* (146) selcollist ::= sclp expr as */
+  {  251,   -2 }, /* (147) selcollist ::= sclp STAR */
+  {  265,   -2 }, /* (148) as ::= AS ids */
+  {  265,   -1 }, /* (149) as ::= ids */
+  {  265,    0 }, /* (150) as ::= */
+  {  252,   -2 }, /* (151) from ::= FROM tablelist */
+  {  266,   -2 }, /* (152) tablelist ::= ids cpxName */
+  {  266,   -3 }, /* (153) tablelist ::= ids cpxName ids */
+  {  266,   -4 }, /* (154) tablelist ::= tablelist COMMA ids cpxName */
+  {  266,   -5 }, /* (155) tablelist ::= tablelist COMMA ids cpxName ids */
+  {  267,   -1 }, /* (156) tmvar ::= VARIABLE */
+  {  254,   -4 }, /* (157) interval_opt ::= INTERVAL LP tmvar RP */
+  {  254,   -6 }, /* (158) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
+  {  254,    0 }, /* (159) interval_opt ::= */
+  {  255,    0 }, /* (160) fill_opt ::= */
+  {  255,   -6 }, /* (161) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+  {  255,   -4 }, /* (162) fill_opt ::= FILL LP ID RP */
+  {  256,   -4 }, /* (163) sliding_opt ::= SLIDING LP tmvar RP */
+  {  256,    0 }, /* (164) sliding_opt ::= */
+  {  258,    0 }, /* (165) orderby_opt ::= */
+  {  258,   -3 }, /* (166) orderby_opt ::= ORDER BY sortlist */
+  {  268,   -4 }, /* (167) sortlist ::= sortlist COMMA item sortorder */
+  {  268,   -2 }, /* (168) sortlist ::= item sortorder */
+  {  270,   -2 }, /* (169) item ::= ids cpxName */
+  {  271,   -1 }, /* (170) sortorder ::= ASC */
+  {  271,   -1 }, /* (171) sortorder ::= DESC */
+  {  271,    0 }, /* (172) sortorder ::= */
+  {  257,    0 }, /* (173) groupby_opt ::= */
+  {  257,   -3 }, /* (174) groupby_opt ::= GROUP BY grouplist */
+  {  272,   -3 }, /* (175) grouplist ::= grouplist COMMA item */
+  {  272,   -1 }, /* (176) grouplist ::= item */
+  {  259,    0 }, /* (177) having_opt ::= */
+  {  259,   -2 }, /* (178) having_opt ::= HAVING expr */
+  {  261,    0 }, /* (179) limit_opt ::= */
+  {  261,   -2 }, /* (180) limit_opt ::= LIMIT signed */
+  {  261,   -4 }, /* (181) limit_opt ::= LIMIT signed OFFSET signed */
+  {  261,   -4 }, /* (182) limit_opt ::= LIMIT signed COMMA signed */
+  {  260,    0 }, /* (183) slimit_opt ::= */
+  {  260,   -2 }, /* (184) slimit_opt ::= SLIMIT signed */
+  {  260,   -4 }, /* (185) slimit_opt ::= SLIMIT signed SOFFSET signed */
+  {  260,   -4 }, /* (186) slimit_opt ::= SLIMIT signed COMMA signed */
+  {  253,    0 }, /* (187) where_opt ::= */
+  {  253,   -2 }, /* (188) where_opt ::= WHERE expr */
+  {  264,   -3 }, /* (189) expr ::= LP expr RP */
+  {  264,   -1 }, /* (190) expr ::= ID */
+  {  264,   -3 }, /* (191) expr ::= ID DOT ID */
+  {  264,   -3 }, /* (192) expr ::= ID DOT STAR */
+  {  264,   -1 }, /* (193) expr ::= INTEGER */
+  {  264,   -2 }, /* (194) expr ::= MINUS INTEGER */
+  {  264,   -2 }, /* (195) expr ::= PLUS INTEGER */
+  {  264,   -1 }, /* (196) expr ::= FLOAT */
+  {  264,   -2 }, /* (197) expr ::= MINUS FLOAT */
+  {  264,   -2 }, /* (198) expr ::= PLUS FLOAT */
+  {  264,   -1 }, /* (199) expr ::= STRING */
+  {  264,   -1 }, /* (200) expr ::= NOW */
+  {  264,   -1 }, /* (201) expr ::= VARIABLE */
+  {  264,   -1 }, /* (202) expr ::= BOOL */
+  {  264,   -4 }, /* (203) expr ::= ID LP exprlist RP */
+  {  264,   -4 }, /* (204) expr ::= ID LP STAR RP */
+  {  264,   -3 }, /* (205) expr ::= expr IS NULL */
+  {  264,   -4 }, /* (206) expr ::= expr IS NOT NULL */
+  {  264,   -3 }, /* (207) expr ::= expr LT expr */
+  {  264,   -3 }, /* (208) expr ::= expr GT expr */
+  {  264,   -3 }, /* (209) expr ::= expr LE expr */
+  {  264,   -3 }, /* (210) expr ::= expr GE expr */
+  {  264,   -3 }, /* (211) expr ::= expr NE expr */
+  {  264,   -3 }, /* (212) expr ::= expr EQ expr */
+  {  264,   -3 }, /* (213) expr ::= expr AND expr */
+  {  264,   -3 }, /* (214) expr ::= expr OR expr */
+  {  264,   -3 }, /* (215) expr ::= expr PLUS expr */
+  {  264,   -3 }, /* (216) expr ::= expr MINUS expr */
+  {  264,   -3 }, /* (217) expr ::= expr STAR expr */
+  {  264,   -3 }, /* (218) expr ::= expr SLASH expr */
+  {  264,   -3 }, /* (219) expr ::= expr REM expr */
+  {  264,   -3 }, /* (220) expr ::= expr LIKE expr */
+  {  264,   -5 }, /* (221) expr ::= expr IN LP exprlist RP */
+  {  273,   -3 }, /* (222) exprlist ::= exprlist COMMA expritem */
+  {  273,   -1 }, /* (223) exprlist ::= expritem */
+  {  274,   -1 }, /* (224) expritem ::= expr */
+  {  274,    0 }, /* (225) expritem ::= */
+  {  209,   -3 }, /* (226) cmd ::= RESET QUERY CACHE */
+  {  209,   -7 }, /* (227) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+  {  209,   -7 }, /* (228) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+  {  209,   -7 }, /* (229) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+  {  209,   -7 }, /* (230) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+  {  209,   -8 }, /* (231) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+  {  209,   -9 }, /* (232) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+  {  209,   -3 }, /* (233) cmd ::= KILL CONNECTION INTEGER */
+  {  209,   -5 }, /* (234) cmd ::= KILL STREAM INTEGER COLON INTEGER */
+  {  209,   -5 }, /* (235) cmd ::= KILL QUERY INTEGER COLON INTEGER */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -2011,6 +2027,7 @@ static void yy_reduce(
 /********** Begin reduce actions **********************************************/
         YYMINORTYPE yylhsminor;
       case 0: /* program ::= cmd */
+      case 115: /* cmd ::= CREATE TABLE create_table_args */ yytestcase(yyruleno==115);
 {}
         break;
       case 1: /* cmd ::= SHOW DATABASES */
@@ -2161,13 +2178,13 @@ static void yy_reduce(
 { setDCLSQLElems(pInfo, TSDB_SQL_CFG_LOCAL, 2, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);          }
         break;
       case 40: /* cmd ::= ALTER DATABASE ids alter_db_optr */
-{ SStrToken t = {0};  setCreateDBSQL(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy268, &t);}
+{ SStrToken t = {0};  setCreateDBSQL(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy148, &t);}
         break;
       case 41: /* cmd ::= ALTER ACCOUNT ids acct_optr */
-{ setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy149);}
+{ setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy309);}
         break;
       case 42: /* cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
-{ setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy149);}
+{ setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy309);}
         break;
       case 43: /* ids ::= ID */
       case 44: /* ids ::= STRING */ yytestcase(yyruleno==44);
@@ -2175,23 +2192,23 @@ static void yy_reduce(
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
       case 45: /* ifexists ::= IF EXISTS */
-{yymsp[-1].minor.yy0.n = 1;}
+{ yymsp[-1].minor.yy0.n = 1;}
         break;
       case 46: /* ifexists ::= */
       case 48: /* ifnotexists ::= */ yytestcase(yyruleno==48);
-{yymsp[1].minor.yy0.n = 0;}
+{ yymsp[1].minor.yy0.n = 0;}
         break;
       case 47: /* ifnotexists ::= IF NOT EXISTS */
-{yymsp[-2].minor.yy0.n = 1;}
+{ yymsp[-2].minor.yy0.n = 1;}
         break;
       case 49: /* cmd ::= CREATE DNODE ids */
 { setDCLSQLElems(pInfo, TSDB_SQL_CREATE_DNODE, 1, &yymsp[0].minor.yy0);}
         break;
       case 50: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
-{ setCreateAcctSQL(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy149);}
+{ setCreateAcctSQL(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy309);}
         break;
       case 51: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */
-{ setCreateDBSQL(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy268, &yymsp[-2].minor.yy0);}
+{ setCreateDBSQL(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy148, &yymsp[-2].minor.yy0);}
         break;
       case 52: /* cmd ::= CREATE USER ids PASS ids */
 { setCreateUserSQL(pInfo, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);}
@@ -2205,7 +2222,7 @@ static void yy_reduce(
       case 65: /* users ::= */ yytestcase(yyruleno==65);
       case 67: /* conns ::= */ yytestcase(yyruleno==67);
       case 69: /* state ::= */ yytestcase(yyruleno==69);
-{yymsp[1].minor.yy0.n = 0;   }
+{ yymsp[1].minor.yy0.n = 0;   }
         break;
       case 54: /* pps ::= PPS INTEGER */
       case 56: /* tseries ::= TSERIES INTEGER */ yytestcase(yyruleno==56);
@@ -2216,24 +2233,24 @@ static void yy_reduce(
       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;     }
+{ yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;     }
         break;
       case 71: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */
 {
-    yylhsminor.yy149.maxUsers   = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
-    yylhsminor.yy149.maxDbs     = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
-    yylhsminor.yy149.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
-    yylhsminor.yy149.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
-    yylhsminor.yy149.maxPointsPerSecond     = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
-    yylhsminor.yy149.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
-    yylhsminor.yy149.maxQueryTime   = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
-    yylhsminor.yy149.maxConnections   = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
-    yylhsminor.yy149.stat    = yymsp[0].minor.yy0;
-}
-  yymsp[-8].minor.yy149 = yylhsminor.yy149;
+    yylhsminor.yy309.maxUsers   = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
+    yylhsminor.yy309.maxDbs     = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
+    yylhsminor.yy309.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
+    yylhsminor.yy309.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
+    yylhsminor.yy309.maxPointsPerSecond     = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
+    yylhsminor.yy309.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
+    yylhsminor.yy309.maxQueryTime   = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
+    yylhsminor.yy309.maxConnections   = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
+    yylhsminor.yy309.stat    = yymsp[0].minor.yy0;
+}
+  yymsp[-8].minor.yy309 = yylhsminor.yy309;
         break;
       case 72: /* keep ::= KEEP tagitemlist */
-{ yymsp[-1].minor.yy165 = yymsp[0].minor.yy165; }
+{ yymsp[-1].minor.yy131 = yymsp[0].minor.yy131; }
         break;
       case 73: /* cache ::= CACHE INTEGER */
       case 74: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==74);
@@ -2251,547 +2268,579 @@ static void yy_reduce(
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
         break;
       case 86: /* db_optr ::= */
-{setDefaultCreateDbOption(&yymsp[1].minor.yy268);}
+{setDefaultCreateDbOption(&yymsp[1].minor.yy148);}
         break;
       case 87: /* db_optr ::= db_optr cache */
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy148 = yylhsminor.yy148;
         break;
       case 88: /* db_optr ::= db_optr replica */
       case 102: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==102);
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy148 = yylhsminor.yy148;
         break;
       case 89: /* db_optr ::= db_optr quorum */
       case 103: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==103);
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy148 = yylhsminor.yy148;
         break;
       case 90: /* db_optr ::= db_optr days */
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy148 = yylhsminor.yy148;
         break;
       case 91: /* db_optr ::= db_optr minrows */
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+  yymsp[-1].minor.yy148 = yylhsminor.yy148;
         break;
       case 92: /* db_optr ::= db_optr maxrows */
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+  yymsp[-1].minor.yy148 = yylhsminor.yy148;
         break;
       case 93: /* db_optr ::= db_optr blocks */
       case 105: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==105);
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy148 = yylhsminor.yy148;
         break;
       case 94: /* db_optr ::= db_optr ctime */
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy148 = yylhsminor.yy148;
         break;
       case 95: /* db_optr ::= db_optr wal */
       case 107: /* alter_db_optr ::= alter_db_optr wal */ yytestcase(yyruleno==107);
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy148 = yylhsminor.yy148;
         break;
       case 96: /* db_optr ::= db_optr fsync */
       case 108: /* alter_db_optr ::= alter_db_optr fsync */ yytestcase(yyruleno==108);
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy148 = yylhsminor.yy148;
         break;
       case 97: /* db_optr ::= db_optr comp */
       case 106: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==106);
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy148 = yylhsminor.yy148;
         break;
       case 98: /* db_optr ::= db_optr prec */
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.precision = yymsp[0].minor.yy0; }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.precision = yymsp[0].minor.yy0; }
+  yymsp[-1].minor.yy148 = yylhsminor.yy148;
         break;
       case 99: /* db_optr ::= db_optr keep */
       case 104: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==104);
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.keep = yymsp[0].minor.yy165; }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.keep = yymsp[0].minor.yy131; }
+  yymsp[-1].minor.yy148 = yylhsminor.yy148;
         break;
       case 100: /* db_optr ::= db_optr update */
       case 109: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==109);
-{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy268 = yylhsminor.yy268;
+{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy148 = yylhsminor.yy148;
         break;
       case 101: /* alter_db_optr ::= */
-{ setDefaultCreateDbOption(&yymsp[1].minor.yy268);}
+{ setDefaultCreateDbOption(&yymsp[1].minor.yy148);}
         break;
       case 110: /* typename ::= ids */
 { 
   yymsp[0].minor.yy0.type = 0;
-  tSQLSetColumnType (&yylhsminor.yy223, &yymsp[0].minor.yy0); 
+  tSQLSetColumnType (&yylhsminor.yy163, &yymsp[0].minor.yy0); 
 }
-  yymsp[0].minor.yy223 = yylhsminor.yy223;
+  yymsp[0].minor.yy163 = yylhsminor.yy163;
         break;
       case 111: /* typename ::= ids LP signed RP */
 {
-    if (yymsp[-1].minor.yy207 <= 0) {
+  if (yymsp[-1].minor.yy459 <= 0) {
     yymsp[-3].minor.yy0.type = 0;
-      tSQLSetColumnType(&yylhsminor.yy223, &yymsp[-3].minor.yy0);
+    tSQLSetColumnType(&yylhsminor.yy163, &yymsp[-3].minor.yy0);
   } else {
-      yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy207;          // negative value of name length
-      tSQLSetColumnType(&yylhsminor.yy223, &yymsp[-3].minor.yy0);
+    yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy459;  // negative value of name length
+    tSQLSetColumnType(&yylhsminor.yy163, &yymsp[-3].minor.yy0);
   }
 }
-  yymsp[-3].minor.yy223 = yylhsminor.yy223;
+  yymsp[-3].minor.yy163 = yylhsminor.yy163;
         break;
       case 112: /* signed ::= INTEGER */
-{ yylhsminor.yy207 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[0].minor.yy207 = yylhsminor.yy207;
+{ yylhsminor.yy459 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[0].minor.yy459 = yylhsminor.yy459;
         break;
       case 113: /* signed ::= PLUS INTEGER */
-{ yymsp[-1].minor.yy207 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+{ yymsp[-1].minor.yy459 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
         break;
       case 114: /* signed ::= MINUS INTEGER */
-{ yymsp[-1].minor.yy207 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
+{ yymsp[-1].minor.yy459 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
+        break;
+      case 116: /* cmd ::= CREATE TABLE create_table_list */
+{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy538;}
         break;
-      case 115: /* cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args */
+      case 117: /* create_table_list ::= create_from_stable */
 {
-    yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
-    setCreatedTableName(pInfo, &yymsp[-2].minor.yy0, &yymsp[-3].minor.yy0);
+  SCreateTableSQL* pCreateTable = calloc(1, sizeof(SCreateTableSQL));
+  pCreateTable->childTableInfo = taosArrayInit(4, sizeof(SCreatedTableInfo));
+
+  taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy96);
+  pCreateTable->type = TSQL_CREATE_TABLE_FROM_STABLE;
+  yylhsminor.yy538 = pCreateTable;
 }
+  yymsp[0].minor.yy538 = yylhsminor.yy538;
         break;
-      case 116: /* create_table_args ::= LP columnlist RP */
+      case 118: /* create_table_list ::= create_table_list create_from_stable */
 {
-    yymsp[-2].minor.yy470 = tSetCreateSQLElems(yymsp[-1].minor.yy165, NULL, NULL, NULL, NULL, TSQL_CREATE_TABLE);
-    setSQLInfo(pInfo, yymsp[-2].minor.yy470, NULL, TSDB_SQL_CREATE_TABLE);
+  taosArrayPush(yymsp[-1].minor.yy538->childTableInfo, &yymsp[0].minor.yy96);
+  yylhsminor.yy538 = yymsp[-1].minor.yy538;
 }
+  yymsp[-1].minor.yy538 = yylhsminor.yy538;
         break;
-      case 117: /* create_table_args ::= LP columnlist RP TAGS LP columnlist RP */
+      case 119: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
 {
-    yymsp[-6].minor.yy470 = tSetCreateSQLElems(yymsp[-5].minor.yy165, yymsp[-1].minor.yy165, NULL, NULL, NULL, TSQL_CREATE_STABLE);
-    setSQLInfo(pInfo, yymsp[-6].minor.yy470, NULL, TSDB_SQL_CREATE_TABLE);
+  yylhsminor.yy538 = tSetCreateSQLElems(yymsp[-1].minor.yy131, NULL, NULL, TSQL_CREATE_TABLE);
+  setSQLInfo(pInfo, yylhsminor.yy538, NULL, TSDB_SQL_CREATE_TABLE);
+
+  yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
+  setCreatedTableName(pInfo, &yymsp[-4].minor.yy0, &yymsp[-5].minor.yy0);
 }
+  yymsp[-5].minor.yy538 = yylhsminor.yy538;
         break;
-      case 118: /* create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP */
+      case 120: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
+{
+  yylhsminor.yy538 = tSetCreateSQLElems(yymsp[-5].minor.yy131, yymsp[-1].minor.yy131, NULL, TSQL_CREATE_STABLE);
+  setSQLInfo(pInfo, yylhsminor.yy538, NULL, TSDB_SQL_CREATE_TABLE);
+
+  yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
+  setCreatedTableName(pInfo, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
+}
+  yymsp[-9].minor.yy538 = yylhsminor.yy538;
+        break;
+      case 121: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
 {
   yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
-    yymsp[-6].minor.yy470 = tSetCreateSQLElems(NULL, NULL, &yymsp[-5].minor.yy0, yymsp[-1].minor.yy165, NULL, TSQL_CREATE_TABLE_FROM_STABLE);
-    setSQLInfo(pInfo, yymsp[-6].minor.yy470, NULL, TSDB_SQL_CREATE_TABLE);
+  yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
+  yylhsminor.yy96 = createNewChildTableInfo(&yymsp[-5].minor.yy0, yymsp[-1].minor.yy131, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
 }
+  yymsp[-9].minor.yy96 = yylhsminor.yy96;
         break;
-      case 119: /* create_table_args ::= AS select */
+      case 122: /* create_table_args ::= ifnotexists ids cpxName AS select */
 {
-    yymsp[-1].minor.yy470 = tSetCreateSQLElems(NULL, NULL, NULL, NULL, yymsp[0].minor.yy414, TSQL_CREATE_STREAM);
-    setSQLInfo(pInfo, yymsp[-1].minor.yy470, NULL, TSDB_SQL_CREATE_TABLE);
+  yylhsminor.yy538 = tSetCreateSQLElems(NULL, NULL, yymsp[0].minor.yy84, TSQL_CREATE_STREAM);
+  setSQLInfo(pInfo, yylhsminor.yy538, NULL, TSDB_SQL_CREATE_TABLE);
+
+  yymsp[-4].minor.yy0.n += yymsp[-2].minor.yy0.n;
+  setCreatedTableName(pInfo, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0);
 }
+  yymsp[-4].minor.yy538 = yylhsminor.yy538;
         break;
-      case 120: /* columnlist ::= columnlist COMMA column */
-{taosArrayPush(yymsp[-2].minor.yy165, &yymsp[0].minor.yy223); yylhsminor.yy165 = yymsp[-2].minor.yy165;  }
-  yymsp[-2].minor.yy165 = yylhsminor.yy165;
+      case 123: /* columnlist ::= columnlist COMMA column */
+{taosArrayPush(yymsp[-2].minor.yy131, &yymsp[0].minor.yy163); yylhsminor.yy131 = yymsp[-2].minor.yy131;  }
+  yymsp[-2].minor.yy131 = yylhsminor.yy131;
         break;
-      case 121: /* columnlist ::= column */
-{yylhsminor.yy165 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy165, &yymsp[0].minor.yy223);}
-  yymsp[0].minor.yy165 = yylhsminor.yy165;
+      case 124: /* columnlist ::= column */
+{yylhsminor.yy131 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy131, &yymsp[0].minor.yy163);}
+  yymsp[0].minor.yy131 = yylhsminor.yy131;
         break;
-      case 122: /* column ::= ids typename */
+      case 125: /* column ::= ids typename */
 {
-    tSQLSetColumnInfo(&yylhsminor.yy223, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy223);
+  tSQLSetColumnInfo(&yylhsminor.yy163, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy163);
 }
-  yymsp[-1].minor.yy223 = yylhsminor.yy223;
+  yymsp[-1].minor.yy163 = yylhsminor.yy163;
         break;
-      case 123: /* tagitemlist ::= tagitemlist COMMA tagitem */
-{ yylhsminor.yy165 = tVariantListAppend(yymsp[-2].minor.yy165, &yymsp[0].minor.yy134, -1);    }
-  yymsp[-2].minor.yy165 = yylhsminor.yy165;
+      case 126: /* tagitemlist ::= tagitemlist COMMA tagitem */
+{ yylhsminor.yy131 = tVariantListAppend(yymsp[-2].minor.yy131, &yymsp[0].minor.yy516, -1);    }
+  yymsp[-2].minor.yy131 = yylhsminor.yy131;
         break;
-      case 124: /* tagitemlist ::= tagitem */
-{ yylhsminor.yy165 = tVariantListAppend(NULL, &yymsp[0].minor.yy134, -1); }
-  yymsp[0].minor.yy165 = yylhsminor.yy165;
+      case 127: /* tagitemlist ::= tagitem */
+{ yylhsminor.yy131 = tVariantListAppend(NULL, &yymsp[0].minor.yy516, -1); }
+  yymsp[0].minor.yy131 = yylhsminor.yy131;
         break;
-      case 125: /* tagitem ::= INTEGER */
-      case 126: /* tagitem ::= FLOAT */ yytestcase(yyruleno==126);
-      case 127: /* tagitem ::= STRING */ yytestcase(yyruleno==127);
-      case 128: /* tagitem ::= BOOL */ yytestcase(yyruleno==128);
-{toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy134, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy134 = yylhsminor.yy134;
+      case 128: /* tagitem ::= INTEGER */
+      case 129: /* tagitem ::= FLOAT */ yytestcase(yyruleno==129);
+      case 130: /* tagitem ::= STRING */ yytestcase(yyruleno==130);
+      case 131: /* tagitem ::= BOOL */ yytestcase(yyruleno==131);
+{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy516, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy516 = yylhsminor.yy516;
         break;
-      case 129: /* tagitem ::= NULL */
-{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy134, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy134 = yylhsminor.yy134;
+      case 132: /* tagitem ::= NULL */
+{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy516, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy516 = yylhsminor.yy516;
         break;
-      case 130: /* tagitem ::= MINUS INTEGER */
-      case 131: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==131);
-      case 132: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==132);
-      case 133: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==133);
+      case 133: /* tagitem ::= MINUS INTEGER */
+      case 134: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==134);
+      case 135: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==135);
+      case 136: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==136);
 {
     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.yy134, &yymsp[-1].minor.yy0);
+    tVariantCreate(&yylhsminor.yy516, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy134 = yylhsminor.yy134;
+  yymsp[-1].minor.yy516 = yylhsminor.yy516;
         break;
-      case 134: /* select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
+      case 137: /* select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
 {
-  yylhsminor.yy414 = tSetQuerySQLElems(&yymsp[-11].minor.yy0, yymsp[-10].minor.yy290, yymsp[-9].minor.yy165, yymsp[-8].minor.yy64, yymsp[-4].minor.yy165, yymsp[-3].minor.yy165, &yymsp[-7].minor.yy532, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy165, &yymsp[0].minor.yy216, &yymsp[-1].minor.yy216);
+  yylhsminor.yy84 = tSetQuerySQLElems(&yymsp[-11].minor.yy0, yymsp[-10].minor.yy478, yymsp[-9].minor.yy131, yymsp[-8].minor.yy420, yymsp[-4].minor.yy131, yymsp[-3].minor.yy131, &yymsp[-7].minor.yy530, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy131, &yymsp[0].minor.yy284, &yymsp[-1].minor.yy284);
 }
-  yymsp[-11].minor.yy414 = yylhsminor.yy414;
+  yymsp[-11].minor.yy84 = yylhsminor.yy84;
         break;
-      case 135: /* union ::= select */
-{ yylhsminor.yy231 = setSubclause(NULL, yymsp[0].minor.yy414); }
-  yymsp[0].minor.yy231 = yylhsminor.yy231;
+      case 138: /* union ::= select */
+{ yylhsminor.yy513 = setSubclause(NULL, yymsp[0].minor.yy84); }
+  yymsp[0].minor.yy513 = yylhsminor.yy513;
         break;
-      case 136: /* union ::= LP union RP */
-{ yymsp[-2].minor.yy231 = yymsp[-1].minor.yy231; }
+      case 139: /* union ::= LP union RP */
+{ yymsp[-2].minor.yy513 = yymsp[-1].minor.yy513; }
         break;
-      case 137: /* union ::= union UNION ALL select */
-{ yylhsminor.yy231 = appendSelectClause(yymsp[-3].minor.yy231, yymsp[0].minor.yy414); }
-  yymsp[-3].minor.yy231 = yylhsminor.yy231;
+      case 140: /* union ::= union UNION ALL select */
+{ yylhsminor.yy513 = appendSelectClause(yymsp[-3].minor.yy513, yymsp[0].minor.yy84); }
+  yymsp[-3].minor.yy513 = yylhsminor.yy513;
         break;
-      case 138: /* union ::= union UNION ALL LP select RP */
-{ yylhsminor.yy231 = appendSelectClause(yymsp[-5].minor.yy231, yymsp[-1].minor.yy414); }
-  yymsp[-5].minor.yy231 = yylhsminor.yy231;
+      case 141: /* union ::= union UNION ALL LP select RP */
+{ yylhsminor.yy513 = appendSelectClause(yymsp[-5].minor.yy513, yymsp[-1].minor.yy84); }
+  yymsp[-5].minor.yy513 = yylhsminor.yy513;
         break;
-      case 139: /* cmd ::= union */
-{ setSQLInfo(pInfo, yymsp[0].minor.yy231, NULL, TSDB_SQL_SELECT); }
+      case 142: /* cmd ::= union */
+{ setSQLInfo(pInfo, yymsp[0].minor.yy513, NULL, TSDB_SQL_SELECT); }
         break;
-      case 140: /* select ::= SELECT selcollist */
+      case 143: /* select ::= SELECT selcollist */
 {
-  yylhsminor.yy414 = tSetQuerySQLElems(&yymsp[-1].minor.yy0, yymsp[0].minor.yy290, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+  yylhsminor.yy84 = tSetQuerySQLElems(&yymsp[-1].minor.yy0, yymsp[0].minor.yy478, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
-  yymsp[-1].minor.yy414 = yylhsminor.yy414;
+  yymsp[-1].minor.yy84 = yylhsminor.yy84;
         break;
-      case 141: /* sclp ::= selcollist COMMA */
-{yylhsminor.yy290 = yymsp[-1].minor.yy290;}
-  yymsp[-1].minor.yy290 = yylhsminor.yy290;
+      case 144: /* sclp ::= selcollist COMMA */
+{yylhsminor.yy478 = yymsp[-1].minor.yy478;}
+  yymsp[-1].minor.yy478 = yylhsminor.yy478;
         break;
-      case 142: /* sclp ::= */
-{yymsp[1].minor.yy290 = 0;}
+      case 145: /* sclp ::= */
+{yymsp[1].minor.yy478 = 0;}
         break;
-      case 143: /* selcollist ::= sclp expr as */
+      case 146: /* selcollist ::= sclp expr as */
 {
-   yylhsminor.yy290 = tSQLExprListAppend(yymsp[-2].minor.yy290, yymsp[-1].minor.yy64, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
+   yylhsminor.yy478 = tSQLExprListAppend(yymsp[-2].minor.yy478, yymsp[-1].minor.yy420, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
 }
-  yymsp[-2].minor.yy290 = yylhsminor.yy290;
+  yymsp[-2].minor.yy478 = yylhsminor.yy478;
         break;
-      case 144: /* selcollist ::= sclp STAR */
+      case 147: /* selcollist ::= sclp STAR */
 {
    tSQLExpr *pNode = tSQLExprIdValueCreate(NULL, TK_ALL);
-   yylhsminor.yy290 = tSQLExprListAppend(yymsp[-1].minor.yy290, pNode, 0);
+   yylhsminor.yy478 = tSQLExprListAppend(yymsp[-1].minor.yy478, pNode, 0);
 }
-  yymsp[-1].minor.yy290 = yylhsminor.yy290;
+  yymsp[-1].minor.yy478 = yylhsminor.yy478;
         break;
-      case 145: /* as ::= AS ids */
+      case 148: /* as ::= AS ids */
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;    }
         break;
-      case 146: /* as ::= ids */
+      case 149: /* as ::= ids */
 { yylhsminor.yy0 = yymsp[0].minor.yy0;    }
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 147: /* as ::= */
+      case 150: /* as ::= */
 { yymsp[1].minor.yy0.n = 0;  }
         break;
-      case 148: /* from ::= FROM tablelist */
-{yymsp[-1].minor.yy165 = yymsp[0].minor.yy165;}
+      case 151: /* from ::= FROM tablelist */
+{yymsp[-1].minor.yy131 = yymsp[0].minor.yy131;}
         break;
-      case 149: /* tablelist ::= ids cpxName */
+      case 152: /* tablelist ::= ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
-  yylhsminor.yy165 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
-  yylhsminor.yy165 = tVariantListAppendToken(yylhsminor.yy165, &yymsp[-1].minor.yy0, -1);  // table alias name
+  yylhsminor.yy131 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
+  yylhsminor.yy131 = tVariantListAppendToken(yylhsminor.yy131, &yymsp[-1].minor.yy0, -1);  // table alias name
 }
-  yymsp[-1].minor.yy165 = yylhsminor.yy165;
+  yymsp[-1].minor.yy131 = yylhsminor.yy131;
         break;
-      case 150: /* tablelist ::= ids cpxName ids */
+      case 153: /* 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.yy165 = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
-   yylhsminor.yy165 = tVariantListAppendToken(yylhsminor.yy165, &yymsp[0].minor.yy0, -1);
+  yylhsminor.yy131 = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
+  yylhsminor.yy131 = tVariantListAppendToken(yylhsminor.yy131, &yymsp[0].minor.yy0, -1);
 }
-  yymsp[-2].minor.yy165 = yylhsminor.yy165;
+  yymsp[-2].minor.yy131 = yylhsminor.yy131;
         break;
-      case 151: /* tablelist ::= tablelist COMMA ids cpxName */
+      case 154: /* tablelist ::= tablelist COMMA ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
-  yylhsminor.yy165 = tVariantListAppendToken(yymsp[-3].minor.yy165, &yymsp[-1].minor.yy0, -1);
-  yylhsminor.yy165 = tVariantListAppendToken(yylhsminor.yy165, &yymsp[-1].minor.yy0, -1);
+  yylhsminor.yy131 = tVariantListAppendToken(yymsp[-3].minor.yy131, &yymsp[-1].minor.yy0, -1);
+  yylhsminor.yy131 = tVariantListAppendToken(yylhsminor.yy131, &yymsp[-1].minor.yy0, -1);
 }
-  yymsp[-3].minor.yy165 = yylhsminor.yy165;
+  yymsp[-3].minor.yy131 = yylhsminor.yy131;
         break;
-      case 152: /* tablelist ::= tablelist COMMA ids cpxName ids */
+      case 155: /* 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.yy165 = tVariantListAppendToken(yymsp[-4].minor.yy165, &yymsp[-2].minor.yy0, -1);
-   yylhsminor.yy165 = tVariantListAppendToken(yylhsminor.yy165, &yymsp[0].minor.yy0, -1);
+  yylhsminor.yy131 = tVariantListAppendToken(yymsp[-4].minor.yy131, &yymsp[-2].minor.yy0, -1);
+  yylhsminor.yy131 = tVariantListAppendToken(yylhsminor.yy131, &yymsp[0].minor.yy0, -1);
 }
-  yymsp[-4].minor.yy165 = yylhsminor.yy165;
+  yymsp[-4].minor.yy131 = yylhsminor.yy131;
         break;
-      case 153: /* tmvar ::= VARIABLE */
+      case 156: /* tmvar ::= VARIABLE */
 {yylhsminor.yy0 = yymsp[0].minor.yy0;}
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 154: /* interval_opt ::= INTERVAL LP tmvar RP */
-{yymsp[-3].minor.yy532.interval = yymsp[-1].minor.yy0; yymsp[-3].minor.yy532.offset.n = 0; yymsp[-3].minor.yy532.offset.z = NULL; yymsp[-3].minor.yy532.offset.type = 0;}
+      case 157: /* interval_opt ::= INTERVAL LP tmvar RP */
+{yymsp[-3].minor.yy530.interval = yymsp[-1].minor.yy0; yymsp[-3].minor.yy530.offset.n = 0; yymsp[-3].minor.yy530.offset.z = NULL; yymsp[-3].minor.yy530.offset.type = 0;}
         break;
-      case 155: /* interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
-{yymsp[-5].minor.yy532.interval = yymsp[-3].minor.yy0; yymsp[-5].minor.yy532.offset = yymsp[-1].minor.yy0;}
+      case 158: /* interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
+{yymsp[-5].minor.yy530.interval = yymsp[-3].minor.yy0; yymsp[-5].minor.yy530.offset = yymsp[-1].minor.yy0;}
         break;
-      case 156: /* interval_opt ::= */
-{memset(&yymsp[1].minor.yy532, 0, sizeof(yymsp[1].minor.yy532));}
+      case 159: /* interval_opt ::= */
+{memset(&yymsp[1].minor.yy530, 0, sizeof(yymsp[1].minor.yy530));}
         break;
-      case 157: /* fill_opt ::= */
-{yymsp[1].minor.yy165 = 0;     }
+      case 160: /* fill_opt ::= */
+{yymsp[1].minor.yy131 = 0;     }
         break;
-      case 158: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+      case 161: /* 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.yy165, &A, -1, 0);
-    yymsp[-5].minor.yy165 = yymsp[-1].minor.yy165;
+    tVariantListInsert(yymsp[-1].minor.yy131, &A, -1, 0);
+    yymsp[-5].minor.yy131 = yymsp[-1].minor.yy131;
 }
         break;
-      case 159: /* fill_opt ::= FILL LP ID RP */
+      case 162: /* fill_opt ::= FILL LP ID RP */
 {
     toTSDBType(yymsp[-1].minor.yy0.type);
-    yymsp[-3].minor.yy165 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
+    yymsp[-3].minor.yy131 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
 }
         break;
-      case 160: /* sliding_opt ::= SLIDING LP tmvar RP */
+      case 163: /* sliding_opt ::= SLIDING LP tmvar RP */
 {yymsp[-3].minor.yy0 = yymsp[-1].minor.yy0;     }
         break;
-      case 161: /* sliding_opt ::= */
+      case 164: /* sliding_opt ::= */
 {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0;   }
         break;
-      case 162: /* orderby_opt ::= */
-      case 170: /* groupby_opt ::= */ yytestcase(yyruleno==170);
-{yymsp[1].minor.yy165 = 0;}
+      case 165: /* orderby_opt ::= */
+{yymsp[1].minor.yy131 = 0;}
         break;
-      case 163: /* orderby_opt ::= ORDER BY sortlist */
-      case 171: /* groupby_opt ::= GROUP BY grouplist */ yytestcase(yyruleno==171);
-{yymsp[-2].minor.yy165 = yymsp[0].minor.yy165;}
+      case 166: /* orderby_opt ::= ORDER BY sortlist */
+{yymsp[-2].minor.yy131 = yymsp[0].minor.yy131;}
         break;
-      case 164: /* sortlist ::= sortlist COMMA item sortorder */
+      case 167: /* sortlist ::= sortlist COMMA item sortorder */
 {
-    yylhsminor.yy165 = tVariantListAppend(yymsp[-3].minor.yy165, &yymsp[-1].minor.yy134, yymsp[0].minor.yy46);
+    yylhsminor.yy131 = tVariantListAppend(yymsp[-3].minor.yy131, &yymsp[-1].minor.yy516, yymsp[0].minor.yy42);
 }
-  yymsp[-3].minor.yy165 = yylhsminor.yy165;
+  yymsp[-3].minor.yy131 = yylhsminor.yy131;
         break;
-      case 165: /* sortlist ::= item sortorder */
+      case 168: /* sortlist ::= item sortorder */
 {
-  yylhsminor.yy165 = tVariantListAppend(NULL, &yymsp[-1].minor.yy134, yymsp[0].minor.yy46);
+  yylhsminor.yy131 = tVariantListAppend(NULL, &yymsp[-1].minor.yy516, yymsp[0].minor.yy42);
 }
-  yymsp[-1].minor.yy165 = yylhsminor.yy165;
+  yymsp[-1].minor.yy131 = yylhsminor.yy131;
         break;
-      case 166: /* item ::= ids cpxName */
+      case 169: /* item ::= ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
 
-  tVariantCreate(&yylhsminor.yy134, &yymsp[-1].minor.yy0);
+  tVariantCreate(&yylhsminor.yy516, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy134 = yylhsminor.yy134;
+  yymsp[-1].minor.yy516 = yylhsminor.yy516;
+        break;
+      case 170: /* sortorder ::= ASC */
+{ yymsp[0].minor.yy42 = TSDB_ORDER_ASC; }
+        break;
+      case 171: /* sortorder ::= DESC */
+{ yymsp[0].minor.yy42 = TSDB_ORDER_DESC;}
         break;
-      case 167: /* sortorder ::= ASC */
-{yymsp[0].minor.yy46 = TSDB_ORDER_ASC; }
+      case 172: /* sortorder ::= */
+{ yymsp[1].minor.yy42 = TSDB_ORDER_ASC; }
         break;
-      case 168: /* sortorder ::= DESC */
-{yymsp[0].minor.yy46 = TSDB_ORDER_DESC;}
+      case 173: /* groupby_opt ::= */
+{ yymsp[1].minor.yy131 = 0;}
         break;
-      case 169: /* sortorder ::= */
-{yymsp[1].minor.yy46 = TSDB_ORDER_ASC;}
+      case 174: /* groupby_opt ::= GROUP BY grouplist */
+{ yymsp[-2].minor.yy131 = yymsp[0].minor.yy131;}
         break;
-      case 172: /* grouplist ::= grouplist COMMA item */
+      case 175: /* grouplist ::= grouplist COMMA item */
 {
-  yylhsminor.yy165 = tVariantListAppend(yymsp[-2].minor.yy165, &yymsp[0].minor.yy134, -1);
+  yylhsminor.yy131 = tVariantListAppend(yymsp[-2].minor.yy131, &yymsp[0].minor.yy516, -1);
 }
-  yymsp[-2].minor.yy165 = yylhsminor.yy165;
+  yymsp[-2].minor.yy131 = yylhsminor.yy131;
         break;
-      case 173: /* grouplist ::= item */
+      case 176: /* grouplist ::= item */
 {
-  yylhsminor.yy165 = tVariantListAppend(NULL, &yymsp[0].minor.yy134, -1);
+  yylhsminor.yy131 = tVariantListAppend(NULL, &yymsp[0].minor.yy516, -1);
 }
-  yymsp[0].minor.yy165 = yylhsminor.yy165;
+  yymsp[0].minor.yy131 = yylhsminor.yy131;
         break;
-      case 174: /* having_opt ::= */
-      case 184: /* where_opt ::= */ yytestcase(yyruleno==184);
-      case 222: /* expritem ::= */ yytestcase(yyruleno==222);
-{yymsp[1].minor.yy64 = 0;}
+      case 177: /* having_opt ::= */
+      case 187: /* where_opt ::= */ yytestcase(yyruleno==187);
+      case 225: /* expritem ::= */ yytestcase(yyruleno==225);
+{yymsp[1].minor.yy420 = 0;}
         break;
-      case 175: /* having_opt ::= HAVING expr */
-      case 185: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==185);
-{yymsp[-1].minor.yy64 = yymsp[0].minor.yy64;}
+      case 178: /* having_opt ::= HAVING expr */
+      case 188: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==188);
+{yymsp[-1].minor.yy420 = yymsp[0].minor.yy420;}
         break;
-      case 176: /* limit_opt ::= */
-      case 180: /* slimit_opt ::= */ yytestcase(yyruleno==180);
-{yymsp[1].minor.yy216.limit = -1; yymsp[1].minor.yy216.offset = 0;}
+      case 179: /* limit_opt ::= */
+      case 183: /* slimit_opt ::= */ yytestcase(yyruleno==183);
+{yymsp[1].minor.yy284.limit = -1; yymsp[1].minor.yy284.offset = 0;}
         break;
-      case 177: /* limit_opt ::= LIMIT signed */
-      case 181: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==181);
-{yymsp[-1].minor.yy216.limit = yymsp[0].minor.yy207;  yymsp[-1].minor.yy216.offset = 0;}
+      case 180: /* limit_opt ::= LIMIT signed */
+      case 184: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==184);
+{yymsp[-1].minor.yy284.limit = yymsp[0].minor.yy459;  yymsp[-1].minor.yy284.offset = 0;}
         break;
-      case 178: /* limit_opt ::= LIMIT signed OFFSET signed */
-{ yymsp[-3].minor.yy216.limit = yymsp[-2].minor.yy207;  yymsp[-3].minor.yy216.offset = yymsp[0].minor.yy207;}
+      case 181: /* limit_opt ::= LIMIT signed OFFSET signed */
+{ yymsp[-3].minor.yy284.limit = yymsp[-2].minor.yy459;  yymsp[-3].minor.yy284.offset = yymsp[0].minor.yy459;}
         break;
-      case 179: /* limit_opt ::= LIMIT signed COMMA signed */
-{ yymsp[-3].minor.yy216.limit = yymsp[0].minor.yy207;  yymsp[-3].minor.yy216.offset = yymsp[-2].minor.yy207;}
+      case 182: /* limit_opt ::= LIMIT signed COMMA signed */
+{ yymsp[-3].minor.yy284.limit = yymsp[0].minor.yy459;  yymsp[-3].minor.yy284.offset = yymsp[-2].minor.yy459;}
         break;
-      case 182: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
-{yymsp[-3].minor.yy216.limit = yymsp[-2].minor.yy207;  yymsp[-3].minor.yy216.offset = yymsp[0].minor.yy207;}
+      case 185: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
+{yymsp[-3].minor.yy284.limit = yymsp[-2].minor.yy459;  yymsp[-3].minor.yy284.offset = yymsp[0].minor.yy459;}
         break;
-      case 183: /* slimit_opt ::= SLIMIT signed COMMA signed */
-{yymsp[-3].minor.yy216.limit = yymsp[0].minor.yy207;  yymsp[-3].minor.yy216.offset = yymsp[-2].minor.yy207;}
+      case 186: /* slimit_opt ::= SLIMIT signed COMMA signed */
+{yymsp[-3].minor.yy284.limit = yymsp[0].minor.yy459;  yymsp[-3].minor.yy284.offset = yymsp[-2].minor.yy459;}
         break;
-      case 186: /* expr ::= LP expr RP */
-{yylhsminor.yy64 = yymsp[-1].minor.yy64; yylhsminor.yy64->token.z = yymsp[-2].minor.yy0.z; yylhsminor.yy64->token.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 189: /* expr ::= LP expr RP */
+{yylhsminor.yy420 = yymsp[-1].minor.yy420; yylhsminor.yy420->token.z = yymsp[-2].minor.yy0.z; yylhsminor.yy420->token.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
+  yymsp[-2].minor.yy420 = yylhsminor.yy420;
         break;
-      case 187: /* expr ::= ID */
-{yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_ID);}
-  yymsp[0].minor.yy64 = yylhsminor.yy64;
+      case 190: /* expr ::= ID */
+{ yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_ID);}
+  yymsp[0].minor.yy420 = yylhsminor.yy420;
         break;
-      case 188: /* expr ::= ID DOT ID */
-{yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ID);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 191: /* expr ::= ID DOT ID */
+{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ID);}
+  yymsp[-2].minor.yy420 = yylhsminor.yy420;
         break;
-      case 189: /* expr ::= ID DOT STAR */
-{yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ALL);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 192: /* expr ::= ID DOT STAR */
+{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ALL);}
+  yymsp[-2].minor.yy420 = yylhsminor.yy420;
         break;
-      case 190: /* expr ::= INTEGER */
-{yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_INTEGER);}
-  yymsp[0].minor.yy64 = yylhsminor.yy64;
+      case 193: /* expr ::= INTEGER */
+{ yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_INTEGER);}
+  yymsp[0].minor.yy420 = yylhsminor.yy420;
         break;
-      case 191: /* expr ::= MINUS INTEGER */
-      case 192: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==192);
-{yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_INTEGER);}
-  yymsp[-1].minor.yy64 = yylhsminor.yy64;
+      case 194: /* expr ::= MINUS INTEGER */
+      case 195: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==195);
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_INTEGER);}
+  yymsp[-1].minor.yy420 = yylhsminor.yy420;
         break;
-      case 193: /* expr ::= FLOAT */
-{yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_FLOAT);}
-  yymsp[0].minor.yy64 = yylhsminor.yy64;
+      case 196: /* expr ::= FLOAT */
+{ yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_FLOAT);}
+  yymsp[0].minor.yy420 = yylhsminor.yy420;
         break;
-      case 194: /* expr ::= MINUS FLOAT */
-      case 195: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==195);
-{yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_FLOAT);}
-  yymsp[-1].minor.yy64 = yylhsminor.yy64;
+      case 197: /* expr ::= MINUS FLOAT */
+      case 198: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==198);
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_FLOAT);}
+  yymsp[-1].minor.yy420 = yylhsminor.yy420;
         break;
-      case 196: /* expr ::= STRING */
-{yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_STRING);}
-  yymsp[0].minor.yy64 = yylhsminor.yy64;
+      case 199: /* expr ::= STRING */
+{ yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_STRING);}
+  yymsp[0].minor.yy420 = yylhsminor.yy420;
         break;
-      case 197: /* expr ::= NOW */
-{yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_NOW); }
-  yymsp[0].minor.yy64 = yylhsminor.yy64;
+      case 200: /* expr ::= NOW */
+{ yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_NOW); }
+  yymsp[0].minor.yy420 = yylhsminor.yy420;
         break;
-      case 198: /* expr ::= VARIABLE */
-{yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_VARIABLE);}
-  yymsp[0].minor.yy64 = yylhsminor.yy64;
+      case 201: /* expr ::= VARIABLE */
+{ yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_VARIABLE);}
+  yymsp[0].minor.yy420 = yylhsminor.yy420;
         break;
-      case 199: /* expr ::= BOOL */
-{yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_BOOL);}
-  yymsp[0].minor.yy64 = yylhsminor.yy64;
+      case 202: /* expr ::= BOOL */
+{ yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_BOOL);}
+  yymsp[0].minor.yy420 = yylhsminor.yy420;
         break;
-      case 200: /* expr ::= ID LP exprlist RP */
-{ yylhsminor.yy64 = tSQLExprCreateFunction(yymsp[-1].minor.yy290, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
-  yymsp[-3].minor.yy64 = yylhsminor.yy64;
+      case 203: /* expr ::= ID LP exprlist RP */
+{ yylhsminor.yy420 = tSQLExprCreateFunction(yymsp[-1].minor.yy478, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
+  yymsp[-3].minor.yy420 = yylhsminor.yy420;
         break;
-      case 201: /* expr ::= ID LP STAR RP */
-{ yylhsminor.yy64 = tSQLExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
-  yymsp[-3].minor.yy64 = yylhsminor.yy64;
+      case 204: /* expr ::= ID LP STAR RP */
+{ yylhsminor.yy420 = tSQLExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
+  yymsp[-3].minor.yy420 = yylhsminor.yy420;
         break;
-      case 202: /* expr ::= expr IS NULL */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, NULL, TK_ISNULL);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 205: /* expr ::= expr IS NULL */
+{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, NULL, TK_ISNULL);}
+  yymsp[-2].minor.yy420 = yylhsminor.yy420;
         break;
-      case 203: /* expr ::= expr IS NOT NULL */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-3].minor.yy64, NULL, TK_NOTNULL);}
-  yymsp[-3].minor.yy64 = yylhsminor.yy64;
+      case 206: /* expr ::= expr IS NOT NULL */
+{yylhsminor.yy420 = tSQLExprCreate(yymsp[-3].minor.yy420, NULL, TK_NOTNULL);}
+  yymsp[-3].minor.yy420 = yylhsminor.yy420;
         break;
-      case 204: /* expr ::= expr LT expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_LT);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 207: /* expr ::= expr LT expr */
+{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_LT);}
+  yymsp[-2].minor.yy420 = yylhsminor.yy420;
         break;
-      case 205: /* expr ::= expr GT expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_GT);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 208: /* expr ::= expr GT expr */
+{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_GT);}
+  yymsp[-2].minor.yy420 = yylhsminor.yy420;
         break;
-      case 206: /* expr ::= expr LE expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_LE);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 209: /* expr ::= expr LE expr */
+{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_LE);}
+  yymsp[-2].minor.yy420 = yylhsminor.yy420;
         break;
-      case 207: /* expr ::= expr GE expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_GE);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 210: /* expr ::= expr GE expr */
+{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_GE);}
+  yymsp[-2].minor.yy420 = yylhsminor.yy420;
         break;
-      case 208: /* expr ::= expr NE expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_NE);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 211: /* expr ::= expr NE expr */
+{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_NE);}
+  yymsp[-2].minor.yy420 = yylhsminor.yy420;
         break;
-      case 209: /* expr ::= expr EQ expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_EQ);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 212: /* expr ::= expr EQ expr */
+{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_EQ);}
+  yymsp[-2].minor.yy420 = yylhsminor.yy420;
         break;
-      case 210: /* expr ::= expr AND expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_AND);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 213: /* expr ::= expr AND expr */
+{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_AND);}
+  yymsp[-2].minor.yy420 = yylhsminor.yy420;
         break;
-      case 211: /* expr ::= expr OR expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_OR); }
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 214: /* expr ::= expr OR expr */
+{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_OR); }
+  yymsp[-2].minor.yy420 = yylhsminor.yy420;
         break;
-      case 212: /* expr ::= expr PLUS expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_PLUS);  }
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 215: /* expr ::= expr PLUS expr */
+{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_PLUS);  }
+  yymsp[-2].minor.yy420 = yylhsminor.yy420;
         break;
-      case 213: /* expr ::= expr MINUS expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_MINUS); }
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 216: /* expr ::= expr MINUS expr */
+{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_MINUS); }
+  yymsp[-2].minor.yy420 = yylhsminor.yy420;
         break;
-      case 214: /* expr ::= expr STAR expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_STAR);  }
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 217: /* expr ::= expr STAR expr */
+{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_STAR);  }
+  yymsp[-2].minor.yy420 = yylhsminor.yy420;
         break;
-      case 215: /* expr ::= expr SLASH expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_DIVIDE);}
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 218: /* expr ::= expr SLASH expr */
+{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_DIVIDE);}
+  yymsp[-2].minor.yy420 = yylhsminor.yy420;
         break;
-      case 216: /* expr ::= expr REM expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_REM);   }
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 219: /* expr ::= expr REM expr */
+{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_REM);   }
+  yymsp[-2].minor.yy420 = yylhsminor.yy420;
         break;
-      case 217: /* expr ::= expr LIKE expr */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_LIKE);  }
-  yymsp[-2].minor.yy64 = yylhsminor.yy64;
+      case 220: /* expr ::= expr LIKE expr */
+{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_LIKE);  }
+  yymsp[-2].minor.yy420 = yylhsminor.yy420;
         break;
-      case 218: /* expr ::= expr IN LP exprlist RP */
-{yylhsminor.yy64 = tSQLExprCreate(yymsp[-4].minor.yy64, (tSQLExpr*)yymsp[-1].minor.yy290, TK_IN); }
-  yymsp[-4].minor.yy64 = yylhsminor.yy64;
+      case 221: /* expr ::= expr IN LP exprlist RP */
+{yylhsminor.yy420 = tSQLExprCreate(yymsp[-4].minor.yy420, (tSQLExpr*)yymsp[-1].minor.yy478, TK_IN); }
+  yymsp[-4].minor.yy420 = yylhsminor.yy420;
         break;
-      case 219: /* exprlist ::= exprlist COMMA expritem */
-{yylhsminor.yy290 = tSQLExprListAppend(yymsp[-2].minor.yy290,yymsp[0].minor.yy64,0);}
-  yymsp[-2].minor.yy290 = yylhsminor.yy290;
+      case 222: /* exprlist ::= exprlist COMMA expritem */
+{yylhsminor.yy478 = tSQLExprListAppend(yymsp[-2].minor.yy478,yymsp[0].minor.yy420,0);}
+  yymsp[-2].minor.yy478 = yylhsminor.yy478;
         break;
-      case 220: /* exprlist ::= expritem */
-{yylhsminor.yy290 = tSQLExprListAppend(0,yymsp[0].minor.yy64,0);}
-  yymsp[0].minor.yy290 = yylhsminor.yy290;
+      case 223: /* exprlist ::= expritem */
+{yylhsminor.yy478 = tSQLExprListAppend(0,yymsp[0].minor.yy420,0);}
+  yymsp[0].minor.yy478 = yylhsminor.yy478;
         break;
-      case 221: /* expritem ::= expr */
-{yylhsminor.yy64 = yymsp[0].minor.yy64;}
-  yymsp[0].minor.yy64 = yylhsminor.yy64;
+      case 224: /* expritem ::= expr */
+{yylhsminor.yy420 = yymsp[0].minor.yy420;}
+  yymsp[0].minor.yy420 = yylhsminor.yy420;
         break;
-      case 223: /* cmd ::= RESET QUERY CACHE */
+      case 226: /* cmd ::= RESET QUERY CACHE */
 { setDCLSQLElems(pInfo, TSDB_SQL_RESET_CACHE, 0);}
         break;
-      case 224: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+      case 227: /* 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.yy165, NULL, TSDB_ALTER_TABLE_ADD_COLUMN);
+    SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy131, NULL, TSDB_ALTER_TABLE_ADD_COLUMN);
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 225: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+      case 228: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -2802,14 +2851,14 @@ static void yy_reduce(
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 226: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+      case 229: /* 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.yy165, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN);
+    SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy131, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN);
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 227: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+      case 230: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -2820,7 +2869,7 @@ static void yy_reduce(
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 228: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+      case 231: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
 {
     yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
 
@@ -2834,25 +2883,25 @@ static void yy_reduce(
     setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 229: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+      case 232: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
 {
     yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n;
 
     toTSDBType(yymsp[-2].minor.yy0.type);
     SArray* A = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
-    A = tVariantListAppend(A, &yymsp[0].minor.yy134, -1);
+    A = tVariantListAppend(A, &yymsp[0].minor.yy516, -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 230: /* cmd ::= KILL CONNECTION INTEGER */
+      case 233: /* cmd ::= KILL CONNECTION INTEGER */
 {setKillSQL(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);}
         break;
-      case 231: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
+      case 234: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
 {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSQL(pInfo, TSDB_SQL_KILL_STREAM, &yymsp[-2].minor.yy0);}
         break;
-      case 232: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
+      case 235: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
 {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSQL(pInfo, TSDB_SQL_KILL_QUERY, &yymsp[-2].minor.yy0);}
         break;
       default:

src/util/inc/tstoken.h

@@ -31,7 +31,7 @@ extern "C" {
 typedef struct SStrToken {
   uint32_t n;
   uint32_t type;
-  char *   z;
+  char    *z;
 } SStrToken;
 
 /**