diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h index 38550e6f08b1ab7f947b8c2c8904d35170b5548b..ae2d27e616066d83ccef0fe8824a82157dd33ca7 100644 --- a/src/client/inc/tscUtil.h +++ b/src/client/inc/tscUtil.h @@ -29,6 +29,14 @@ extern "C" { #include "tsched.h" #include "tsclient.h" +#define LABEL_SQL "sql:" +#define LABEL_TO " to:" +#define LABEL_SPLIT " split:" + +#define LABEL_SQL_LEN (sizeof(LABEL_SQL) - 1) +#define LABEL_TO_LEN (sizeof(LABEL_TO) - 1) +#define LABEL_SPLIT_LEN (sizeof(LABEL_SPLIT) - 1) + #define UTIL_TABLE_IS_SUPER_TABLE(metaInfo) \ (((metaInfo)->pTableMeta != NULL) && ((metaInfo)->pTableMeta->tableType == TSDB_SUPER_TABLE)) diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h index de439e64036999da0c9f6142ace7ebe1b847adbc..d677cacc059fffcccdaec7eaf0eea2f04614d7c5 100644 --- a/src/client/inc/tsclient.h +++ b/src/client/inc/tsclient.h @@ -406,6 +406,10 @@ typedef struct SSqlStream { int16_t precision; int64_t num; // number of computing count + int32_t dstCols; // dstTable has number of columns + char* to; + char* split; + /* * keep the number of current result in computing, * the value will be set to 0 before set timer for next computing diff --git a/src/client/src/taos.def b/src/client/src/taos.def index d64abb2ba858c30d252a2d92b7709ebc33618836..a8c95aa76690864db5f1c7bad3e39f5053e175d2 100644 --- a/src/client/src/taos.def +++ b/src/client/src/taos.def @@ -50,3 +50,4 @@ taos_stmt_bind_param_batch taos_stmt_bind_single_param_batch taos_is_null taos_insert_lines +taos_print_row_ex \ No newline at end of file diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c index 1e23e9e56eeabde993020f0a6c45b81390b33d08..9365db99d13020d544e00a33265704bb7ec77140 100644 --- a/src/client/src/tscSQLParser.c +++ b/src/client/src/tscSQLParser.c @@ -1341,6 +1341,7 @@ int32_t tscSetTableFullName(SName* pName, SStrToken* pTableName, SSqlObj* pSql) const char* msg3 = "no acctId"; const char* msg4 = "db name too long"; const char* msg5 = "table name too long"; + const char* msg6 = "table name empty"; SSqlCmd* pCmd = &pSql->cmd; int32_t code = TSDB_CODE_SUCCESS; @@ -1387,6 +1388,8 @@ int32_t tscSetTableFullName(SName* pName, SStrToken* pTableName, SSqlObj* pSql) if (pTableName->n >= TSDB_TABLE_NAME_LEN) { return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1); + } else if(pTableName->n == 0) { + return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6); } char name[TSDB_TABLE_FNAME_LEN] = {0}; @@ -7740,6 +7743,17 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) { return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1); } + // check to valid and create to name + if(pInfo->pCreateTableInfo->to.n > 0) { + if (tscValidateName(&pInfo->pCreateTableInfo->to) != TSDB_CODE_SUCCESS) { + return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1); + } + int32_t code = tscSetTableFullName(&pInfo->pCreateTableInfo->toSName, &pInfo->pCreateTableInfo->to, pSql); + if(code != TSDB_CODE_SUCCESS) { + return code; + } + } + SRelationInfo* pFromInfo = pInfo->pCreateTableInfo->pSelect->from; if (pFromInfo == NULL || taosArrayGetSize(pFromInfo->list) == 0) { return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6); diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c index d8551705c89053745536d55ffa794f6ce17e3ed6..b8cb5fea28c74cbfd6d4756d0121319abb424100 100644 --- a/src/client/src/tscServer.c +++ b/src/client/src/tscServer.c @@ -1626,11 +1626,49 @@ int tscEstimateCreateTableMsgLength(SSqlObj *pSql, SSqlInfo *pInfo) { if (pCreateTableInfo->pSelect != NULL) { size += (pCreateTableInfo->pSelect->sqlstr.n + 1); + // add size = create super table with same columns and 1 tags + if(pCreateTableInfo->to.n > 0) { + size += sizeof(SCreateTableMsg); + size += sizeof(SSchema) * (pCmd->numOfCols + 1); + size += pCreateTableInfo->to.n + 4; // to: + if(pCreateTableInfo->split.n > 0) + size += pCreateTableInfo->split.n + 7; // split: + } } return size + TSDB_EXTRA_PAYLOAD_SIZE; } +char* fillCreateSTableMsg(SCreateTableMsg* pCreateMsg, SCreateTableSql* pTableSql, SSqlCmd* pCmd, SSqlInfo *pInfo) { + // SET + SSchema* pSchema = (SSchema *)pCreateMsg->schema; + SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd); + pCreateMsg->igExists = 0; + pCreateMsg->sqlLen = 0; + + // FullName like acctID.dbName.tableName + tNameExtractFullName(&pInfo->pCreateTableInfo->toSName, pCreateMsg->tableName); + + // copy columns + pCreateMsg->numOfColumns = htons(pCmd->numOfCols); + for (int i = 0; i < pCmd->numOfCols; ++i) { + TAOS_FIELD *pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, i); + pSchema->type = pField->type; + strcpy(pSchema->name, pField->name); + pSchema->bytes = htons(pField->bytes); + + pSchema++; + } + // append one tag + pCreateMsg->numOfTags = htons(1); // only one tag immutable + pSchema->type = TSDB_DATA_TYPE_INT; + pSchema->bytes = htons(INT_BYTES); + strcpy(pSchema->name, "tag1"); + pSchema ++; + + return (char *)pSchema; +} + int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) { int msgLen = 0; int size = 0; @@ -1678,39 +1716,71 @@ int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) { pCreate->len = htonl(len); } } else { // create (super) table + // FIRST MSG + SCreateTableMsg* pCreate = pCreateMsg; pCreateTableMsg->numOfTables = htonl(1); // only one table will be created - - int32_t code = tNameExtractFullName(&pTableMetaInfo->name, pCreateMsg->tableName); + int32_t code = tNameExtractFullName(&pTableMetaInfo->name, pCreate->tableName); + bool to = pInfo->pCreateTableInfo->to.n > 0; assert(code == 0); SCreateTableSql *pCreateTable = pInfo->pCreateTableInfo; - pCreateMsg->igExists = pCreateTable->existCheck ? 1 : 0; - pCreateMsg->numOfColumns = htons(pCmd->numOfCols); - pCreateMsg->numOfTags = htons(pCmd->count); - - pCreateMsg->sqlLen = 0; - pMsg = (char *)pCreateMsg->schema; - - pSchema = (SSchema *)pCreateMsg->schema; - + pCreate->igExists = pCreateTable->existCheck ? 1 : 0; + pCreate->numOfColumns = htons(pCmd->numOfCols); + pCreate->numOfTags = htons(pCmd->count); + pCreate->sqlLen = 0; + pSchema = (SSchema *)pCreate->schema; + //copy schema for (int i = 0; i < pCmd->numOfCols + pCmd->count; ++i) { TAOS_FIELD *pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, i); - pSchema->type = pField->type; strcpy(pSchema->name, pField->name); pSchema->bytes = htons(pField->bytes); - pSchema++; } - + //copy stream sql if have pMsg = (char *)pSchema; if (type == TSQL_CREATE_STREAM) { // check if it is a stream sql SSqlNode *pQuerySql = pInfo->pCreateTableInfo->pSelect; + int16_t len = 0; + if(to) { + //sql: + strcpy(pMsg, LABEL_SQL); + len += LABEL_SQL_LEN; + len += tStrNCpy(pMsg + len, &pQuerySql->sqlstr); + //to + strcpy(pMsg + len, LABEL_TO); + len += LABEL_TO_LEN; + len += tStrNCpy(pMsg + len, &pInfo->pCreateTableInfo->to); + //split if + if(pInfo->pCreateTableInfo->split.n > 0) { + strcpy(pMsg + len, LABEL_SPLIT); + len += LABEL_SPLIT_LEN; + len += tStrNCpy(pMsg + len, &pInfo->pCreateTableInfo->split); + } + // append string end flag + pMsg[len++] = 0; + pMsg += len; + pCreate->sqlLen = htons(len); + } else { + len = pQuerySql->sqlstr.n; + strncpy(pMsg, pQuerySql->sqlstr.z, len); + pMsg[len++] = 0; // string end + pMsg += len; + pCreate->sqlLen = htons(len); + } + } + // calc first msg length + int32_t len = (int32_t)(pMsg - (char*)pCreate); + pCreate->len = htonl(len); - strncpy(pMsg, pQuerySql->sqlstr.z, pQuerySql->sqlstr.n + 1); - pCreateMsg->sqlLen = htons(pQuerySql->sqlstr.n + 1); - pMsg += pQuerySql->sqlstr.n + 1; + // filling second msg if to have value + if(to) { + pCreate = (SCreateTableMsg *)pMsg; + pMsg = fillCreateSTableMsg(pCreate, pCreateTable, pCmd, pInfo); + len = (int32_t)(pMsg - (char*)pCreate); + pCreate->len = htonl(len); + pCreateTableMsg->numOfTables = htonl(2); } } diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c index e292db30fd1983d78e3712238b2de6cd18638956..18145f5cf83fb248dfe92d2c6ae3a79e0f3d22a4 100644 --- a/src/client/src/tscSql.c +++ b/src/client/src/tscSql.c @@ -772,11 +772,15 @@ bool taos_is_null(TAOS_RES *res, int32_t row, int32_t col) { } int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields) { + return taos_print_row_ex(str, row, fields, num_fields, ' ', false); +} + +int taos_print_row_ex(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields, char split, bool addQuota) { int len = 0; for (int i = 0; i < num_fields; ++i) { if (i > 0) { - str[len++] = ' '; + str[len++] = split; } if (row[i] == NULL) { @@ -837,9 +841,23 @@ int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields) } else { assert(charLen <= fields[i].bytes * TSDB_NCHAR_SIZE && charLen >= 0); } + + // add pre quotaion if require + if(addQuota) { + *(str + len) = '\''; + len += 1; + } + // copy content memcpy(str + len, row[i], charLen); len += charLen; + + // add end quotaion if require + if(addQuota) { + *(str + len)= '\''; + len += 1; + } + } break; case TSDB_DATA_TYPE_TIMESTAMP: diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c index 923b2d74fe9d4f9195241d35ea11d6ac99a9fe8e..fcec0de8f65a3cd2a44537f269690514b907b6e6 100644 --- a/src/client/src/tscStream.c +++ b/src/client/src/tscStream.c @@ -265,9 +265,162 @@ static void tscStreamFillTimeGap(SSqlStream* pStream, TSKEY ts) { #endif } +// callback send values +void cbSendValues(void *param, TAOS_RES *res, int code) { + printf(" send values return code =%d \n", code); +} + +// append values +size_t appendValues(TAOS_FIELD* fields, int32_t numCols, TAOS_ROW row, char* pBuf, size_t bufLen, size_t curLen, bool *full) { + // calc buf is full + size_t needLen = 0; + size_t rowLen = 0; + int i; + for(i = 0; i < numCols; i++) { + needLen += fields[i].bytes; + } + + // estimate length for use + needLen += numCols * 5 + 20; + if(needLen >= bufLen - curLen) { + *full = true; + return 0; + } + + // row append to values + char* strRow = tmalloc(needLen); + char *value = pBuf + curLen; + + strcpy(value, "("); + rowLen += taos_print_row_ex(strRow, row, fields, numCols, ',', true); + strcat(value, strRow); + strcat(value, ")"); + rowLen +=2; + + tfree(strRow); + return rowLen; +} + +// send one table all rows for once +bool sendChildTalbe(STscObj *pTscObj, char *superName, char *tableName, TAOS_FIELD *fields, int32_t numCols, SArray *arr) { + int32_t bufLen = TSDB_MAX_SQL_LEN; + size_t numRows = taosArrayGetSize(arr); + if(numRows == 0) + return false; + if(numRows < 50) + bufLen /= 20; + else if(numRows < 500) + bufLen /= 5; + else + bufLen /= 2; + + char dbName[TSDB_DB_NAME_LEN] = ""; + char fullTable[TSDB_TABLE_FNAME_LEN]; + // obtain dbname + char * p = strstr(superName, "."); + if(p) { // if have db prefix , under this db create table + int32_t len = p - superName; + strncpy(dbName, superName, len); + dbName[len] = 0; // append str end + sprintf(fullTable, "%s.%s", dbName, tableName); + } else { + // no db prefix + strcpy(fullTable, tableName); + } + + char *pBuf = (char *)tmalloc(bufLen); + sprintf(pBuf, "insert into %s using %s tags(0) values ", fullTable, superName); + size_t curLen = strlen(pBuf); + TAOS_ROW row ; + bool full = false; + + for(size_t i = 0; i < numRows; i++) { + row = (TAOS_ROW)taosArrayGetP(arr, i); + if(row == NULL) + continue; + curLen += appendValues(fields, numCols, row, pBuf, bufLen - 100, curLen, &full); + if(full || i == numRows - 1) { // need send + // send current + strcat(pBuf, ";"); + taos_query_a(pTscObj, pBuf, cbSendValues, NULL); + + // reset for next + if(full) { + sprintf(pBuf, "insert into %s.%s using %s tags(0) values ", dbName, tableName, superName); + curLen = strlen(pBuf); + // retry append. if full is true again, ignore this row + curLen += appendValues(fields, numCols, row, pBuf, bufLen - 100, curLen, &full); + full = false; // reset to false + } + } + tfree(row); + } + + tfree(pBuf); + return true; +} + +// write cq result to another table +bool toAnotherTable(STscObj *pTscObj, char *superName, TAOS_FIELD *fields, int32_t numCols, SHashObj *tbHash) { + void *pIter = taosHashIterate(tbHash, NULL); + while(pIter) { + SArray *arr = *(SArray**)pIter; + if(arr) { + // get key as tableName + SHashNode *pNode = (SHashNode *)GET_HASH_PNODE(pIter); + char *data = (char *)GET_HASH_NODE_KEY(pNode); + uint32_t len = pNode->keyLen; + char *key = tmalloc(len + 1); + memcpy(key, data, len); + key[len] = 0; // string end '\0' + + // send all this table rows + sendChildTalbe(pTscObj, superName, key, fields, numCols, arr); + // release SArray + taosArrayDestroy(arr); + tfree(key); + } + pIter = taosHashIterate(tbHash, pIter); + } + + return true; +} + +// add row to hash to group by tbname +bool tbHashAdd(SHashObj *tbHash, TAOS_ROW row, TAOS_FIELD* fields, int32_t idx, int32_t numCols) { + void *v = row[idx]; + VarDataLenT len = varDataLen((char*)v - VARSTR_HEADER_SIZE); + char *key = v; + + // get array point from hash + SArray *arr = NULL; + // get arr from hash + void* pdata = taosHashGet(tbHash, key, len); + if(pdata) { + arr = *(SArray **)pdata; + } + // get arr from new + if(arr == NULL) { + arr = (SArray *)taosArrayInit(10, sizeof(TAOS_ROW)); + if(arr == NULL) { + tscError("tbHashAdd tbHash:%p, taosArrayInit(10,sizeof(TAOS_ROW) return NULL.", tbHash); + return false; + } + taosHashPut(tbHash, key, len, &arr, sizeof(SArray *)); + } + + // add to array + int32_t new_len = sizeof(void*) * numCols; + TAOS_ROW new_row = (TAOS_ROW)tmalloc(new_len); + memcpy(new_row, row, new_len); + taosArrayPush(arr, &new_row); + return true; +} + static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOfRows) { SSqlStream * pStream = (SSqlStream *)param; SSqlObj * pSql = (SSqlObj *)res; + bool toAnother = pStream->to != NULL; if (pSql == NULL || numOfRows < 0) { int64_t retryDelayTime = tscGetRetryDelayTime(pStream, pStream->interval.sliding, pStream->precision); @@ -281,18 +434,57 @@ static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOf STableMetaInfo *pTableMetaInfo = pQueryInfo->pTableMetaInfo[0]; if (numOfRows > 0) { // when reaching here the first execution of stream computing is successful. + // init hash + SHashObj* tbHash = NULL; + int32_t colIdx = 1; + TAOS_FIELD *fields = NULL; + int32_t dstColsNum = pStream->dstCols; + int32_t fieldsNum = 0; + + if(toAnother) { + //init hash + tbHash = taosHashInit(100, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK); + fields = taos_fetch_fields(res); + fieldsNum = tscNumOfFields(pQueryInfo); + if(dstColsNum == -1) + dstColsNum = fieldsNum; + //search split column + char *split = "tbname"; // default + if(pStream->split) + split = pStream->split; + for(int32_t i = 1; i < fieldsNum; i++ ) { + if(strcasecmp(fields[i].name, split) == 0 ) { + colIdx = i; + break; + } + } + } + + // save rows for(int32_t i = 0; i < numOfRows; ++i) { TAOS_ROW row = taos_fetch_row(res); if (row != NULL) { tscDebug("0x%"PRIx64" stream:%p fetch result", pSql->self, pStream); tscStreamFillTimeGap(pStream, *(TSKEY*)row[0]); pStream->stime = *(TSKEY *)row[0]; - // user callback function - (*pStream->fp)(pStream->param, res, row); + // write to another table if true + if(toAnother) { + tbHashAdd(tbHash, row, fields, colIdx, dstColsNum); + if(i == numOfRows - 1) //write last row to record last query time avoid query from begin for each + (*pStream->fp)(pStream->param, res, row); + } else { + (*pStream->fp)(pStream->param, res, row); + } pStream->numOfRes++; } } - + + // write Another + if(toAnother) { + toAnotherTable(pSql->pTscObj, pStream->to, fields, dstColsNum, tbHash); + taosHashCleanup(tbHash); + } + if (!pStream->isProject) { pStream->stime = taosTimeAdd(pStream->stime, pStream->interval.sliding, pStream->interval.slidingUnit, pStream->precision); } @@ -662,7 +854,50 @@ void cbParseSql(void* param, TAOS_RES* res, int code) { return ; } -TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* dstTable, const char *sqlstr, void (*fp)(void *param, TAOS_RES *, TAOS_ROW row), +void splitStreamSql(const char *str, char **sql, char **to, char **split) { + // OLD FORMAT only sql + if(strncmp(str, LABEL_SQL, LABEL_SQL_LEN) != 0) { + *sql = tmalloc(strlen(str) + 1); + if(*sql == NULL) + return ; + strcpy(*sql, str); + return ; + } + + // NEW FORMAT sql:...to:...split:... + char *p1 = strstr(str + LABEL_SQL_LEN, LABEL_TO); + if(p1 == NULL) { + char *p = (char *)str + LABEL_SQL_LEN; + *sql = (char *)tmalloc(strlen(p) + 1); + strcpy(*sql, p); + return ; + } + // SQL value + int32_t len = p1 - str - LABEL_SQL_LEN; + *sql = (char *)tmalloc(len + 1); + strncpy(*sql, str + LABEL_SQL_LEN, len); + sql[len] = 0; // str end + + // TO value + char *p2 = strstr(p1 + LABEL_TO_LEN, LABEL_SPLIT); + if(p2 == NULL) { + char *p = p1 + LABEL_TO_LEN; + *to = (char *)tmalloc(strlen(p) + 1); + strcpy(*to, p); + return ; + } + len = p2 - p1 - LABEL_TO_LEN; + *to = (char *)tmalloc(len + 1); + strncpy(*to, p1 + LABEL_TO_LEN, len); + to[len] = 0; // str end + + // SPLIT value + char *p = p2 + LABEL_SPLIT_LEN; + *split = (char *)tmalloc(strlen(p) + 1); + strcpy(*split, p); +} + +TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* dstTable, int32_t dstCols, const char *sqlstr, void (*fp)(void *param, TAOS_RES *, TAOS_ROW row), int64_t stime, void *param, void (*callback)(void *), void* cqhandle) { STscObj *pObj = (STscObj *)taos; if (pObj == NULL || pObj->signature != pObj) return NULL; @@ -698,6 +933,9 @@ TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* dstTable, const c pStream->param = param; pStream->pSql = pSql; pStream->cqhandle = cqhandle; + pStream->dstCols = dstCols; + pStream->to = NULL; + pStream->split = NULL; pSql->pStream = pStream; pSql->param = pStream; pSql->maxRetry = TSDB_MAX_REPLICA; @@ -706,7 +944,9 @@ TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* dstTable, const c pSql->pStream = pStream; pSql->param = pStream; pSql->maxRetry = TSDB_MAX_REPLICA; - pSql->sqlstr = calloc(1, strlen(sqlstr) + 1); + + // split stream sqlstr to sql,to,split + splitStreamSql(sqlstr, &pSql->sqlstr, &pStream->to, &pStream->split); if (pSql->sqlstr == NULL) { tscError("0x%"PRIx64" failed to malloc sql string buffer", pSql->self); tscFreeSqlObj(pSql); @@ -714,7 +954,7 @@ TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* dstTable, const c return NULL; } - strtolower(pSql->sqlstr, sqlstr); + strtolower(pSql->sqlstr, pSql->sqlstr); pSql->fp = tscCreateStream; pSql->fetchFp = tscCreateStream; pSql->cmd.resColumnId = TSDB_RES_COL_ID; @@ -746,7 +986,7 @@ TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* dstTable, const c TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *param, TAOS_RES *, TAOS_ROW row), int64_t stime, void *param, void (*callback)(void *)) { - return taos_open_stream_withname(taos, "", sqlstr, fp, stime, param, callback, NULL); + return taos_open_stream_withname(taos, "", -1, sqlstr, fp, stime, param, callback, NULL); } void taos_close_stream(TAOS_STREAM *handle) { @@ -772,6 +1012,16 @@ void taos_close_stream(TAOS_STREAM *handle) { pStream->fp(pStream->param, NULL, NULL); taos_free_result(pSql); + + // free malloc + if(pStream->to) { + tfree(pStream->to); + pStream->to = NULL; + } + if(pStream->split) { + tfree(pStream->split); + pStream->split = NULL; + } tfree(pStream); } } diff --git a/src/cq/src/cqMain.c b/src/cq/src/cqMain.c index aac5a1c665c1417069b3978d10c7b1406a6b02a4..a1affc0869dca0a177ffafc6ab3309328652a696 100644 --- a/src/cq/src/cqMain.c +++ b/src/cq/src/cqMain.c @@ -423,7 +423,7 @@ static void cqProcessCreateTimer(void *param, void *tmrId) { } // inner implement in tscStream.c -TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* desName, const char *sqlstr, void (*fp)(void *param, TAOS_RES *, TAOS_ROW row), +TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* desName, int32_t dstCols, const char *sqlstr, void (*fp)(void *param, TAOS_RES *, TAOS_ROW row), int64_t stime, void *param, void (*callback)(void *), void* cqhandle); static void cqCreateStream(SCqContext *pContext, SCqObj *pObj) { @@ -436,9 +436,11 @@ static void cqCreateStream(SCqContext *pContext, SCqObj *pObj) { } pObj->tmrId = 0; - + int32_t dstCols = -1; + if(pObj->pSchema) + dstCols = pObj->pSchema->numOfCols; if (pObj->pStream == NULL) { - pObj->pStream = taos_open_stream_withname(pContext->dbConn, pObj->dstTable, pObj->sqlStr, cqProcessStreamRes, \ + pObj->pStream = taos_open_stream_withname(pContext->dbConn, pObj->dstTable, dstCols, pObj->sqlStr, cqProcessStreamRes, \ INT64_MIN, (void *)pObj->rid, NULL, pContext); // TODO the pObj->pStream may be released if error happens diff --git a/src/inc/taos.h b/src/inc/taos.h index 6fa30737e71e8f40cee817386ad4d2c26661777f..0d7a426dae7abe79d2a5497d535a7e8029ed4b77 100644 --- a/src/inc/taos.h +++ b/src/inc/taos.h @@ -138,6 +138,7 @@ DLL_EXPORT int taos_affected_rows(TAOS_RES *res); DLL_EXPORT TAOS_FIELD *taos_fetch_fields(TAOS_RES *res); DLL_EXPORT int taos_select_db(TAOS *taos, const char *db); DLL_EXPORT int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields); +DLL_EXPORT int taos_print_row_ex(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields, char split, bool addQuota); DLL_EXPORT void taos_stop_query(TAOS_RES *res); DLL_EXPORT bool taos_is_null(TAOS_RES *res, int32_t row, int32_t col); DLL_EXPORT int taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows); diff --git a/src/inc/ttokendef.h b/src/inc/ttokendef.h index 5f6ecdd466fb112b0415e4f2d9095d6169ca4eb8..7b81a862a6719279f43b6d22ce444ad890f32666 100644 --- a/src/inc/ttokendef.h +++ b/src/inc/ttokendef.h @@ -133,85 +133,87 @@ #define TK_UNSIGNED 115 #define TK_TAGS 116 #define TK_USING 117 -#define TK_NULL 118 -#define TK_NOW 119 -#define TK_SELECT 120 -#define TK_UNION 121 -#define TK_ALL 122 -#define TK_DISTINCT 123 -#define TK_FROM 124 -#define TK_VARIABLE 125 -#define TK_INTERVAL 126 -#define TK_EVERY 127 -#define TK_SESSION 128 -#define TK_STATE_WINDOW 129 -#define TK_FILL 130 -#define TK_SLIDING 131 -#define TK_ORDER 132 -#define TK_BY 133 -#define TK_ASC 134 -#define TK_GROUP 135 -#define TK_HAVING 136 -#define TK_LIMIT 137 -#define TK_OFFSET 138 -#define TK_SLIMIT 139 -#define TK_SOFFSET 140 -#define TK_WHERE 141 -#define TK_RESET 142 -#define TK_QUERY 143 -#define TK_SYNCDB 144 -#define TK_ADD 145 -#define TK_COLUMN 146 -#define TK_MODIFY 147 -#define TK_TAG 148 -#define TK_CHANGE 149 -#define TK_SET 150 -#define TK_KILL 151 -#define TK_CONNECTION 152 -#define TK_STREAM 153 -#define TK_COLON 154 -#define TK_ABORT 155 -#define TK_AFTER 156 -#define TK_ATTACH 157 -#define TK_BEFORE 158 -#define TK_BEGIN 159 -#define TK_CASCADE 160 -#define TK_CLUSTER 161 -#define TK_CONFLICT 162 -#define TK_COPY 163 -#define TK_DEFERRED 164 -#define TK_DELIMITERS 165 -#define TK_DETACH 166 -#define TK_EACH 167 -#define TK_END 168 -#define TK_EXPLAIN 169 -#define TK_FAIL 170 -#define TK_FOR 171 -#define TK_IGNORE 172 -#define TK_IMMEDIATE 173 -#define TK_INITIALLY 174 -#define TK_INSTEAD 175 -#define TK_MATCH 176 -#define TK_KEY 177 -#define TK_OF 178 -#define TK_RAISE 179 -#define TK_REPLACE 180 -#define TK_RESTRICT 181 -#define TK_ROW 182 -#define TK_STATEMENT 183 -#define TK_TRIGGER 184 -#define TK_VIEW 185 -#define TK_SEMI 186 -#define TK_NONE 187 -#define TK_PREV 188 -#define TK_LINEAR 189 -#define TK_IMPORT 190 -#define TK_TBNAME 191 -#define TK_JOIN 192 -#define TK_INSERT 193 -#define TK_INTO 194 -#define TK_VALUES 195 -#define TK_FILE 196 +#define TK_TO 118 +#define TK_SPLIT 119 +#define TK_NULL 120 +#define TK_NOW 121 +#define TK_SELECT 122 +#define TK_UNION 123 +#define TK_ALL 124 +#define TK_DISTINCT 125 +#define TK_FROM 126 +#define TK_VARIABLE 127 +#define TK_INTERVAL 128 +#define TK_EVERY 129 +#define TK_SESSION 130 +#define TK_STATE_WINDOW 131 +#define TK_FILL 132 +#define TK_SLIDING 133 +#define TK_ORDER 134 +#define TK_BY 135 +#define TK_ASC 136 +#define TK_GROUP 137 +#define TK_HAVING 138 +#define TK_LIMIT 139 +#define TK_OFFSET 140 +#define TK_SLIMIT 141 +#define TK_SOFFSET 142 +#define TK_WHERE 143 +#define TK_RESET 144 +#define TK_QUERY 145 +#define TK_SYNCDB 146 +#define TK_ADD 147 +#define TK_COLUMN 148 +#define TK_MODIFY 149 +#define TK_TAG 150 +#define TK_CHANGE 151 +#define TK_SET 152 +#define TK_KILL 153 +#define TK_CONNECTION 154 +#define TK_STREAM 155 +#define TK_COLON 156 +#define TK_ABORT 157 +#define TK_AFTER 158 +#define TK_ATTACH 159 +#define TK_BEFORE 160 +#define TK_BEGIN 161 +#define TK_CASCADE 162 +#define TK_CLUSTER 163 +#define TK_CONFLICT 164 +#define TK_COPY 165 +#define TK_DEFERRED 166 +#define TK_DELIMITERS 167 +#define TK_DETACH 168 +#define TK_EACH 169 +#define TK_END 170 +#define TK_EXPLAIN 171 +#define TK_FAIL 172 +#define TK_FOR 173 +#define TK_IGNORE 174 +#define TK_IMMEDIATE 175 +#define TK_INITIALLY 176 +#define TK_INSTEAD 177 +#define TK_MATCH 178 +#define TK_KEY 179 +#define TK_OF 180 +#define TK_RAISE 181 +#define TK_REPLACE 182 +#define TK_RESTRICT 183 +#define TK_ROW 184 +#define TK_STATEMENT 185 +#define TK_TRIGGER 186 +#define TK_VIEW 187 +#define TK_SEMI 188 +#define TK_NONE 189 +#define TK_PREV 190 +#define TK_LINEAR 191 +#define TK_IMPORT 192 +#define TK_TBNAME 193 +#define TK_JOIN 194 +#define TK_INSERT 195 +#define TK_INTO 196 +#define TK_VALUES 197 +#define TK_FILE 198 #define TK_SPACE 300 diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c index e692f1d0b7fabc0f13ba8cf88c9c16e4c52e436e..956ac3be506f5f1eb4df2e05450c6eb82982e16e 100644 --- a/src/mnode/src/mnodeTable.c +++ b/src/mnode/src/mnodeTable.c @@ -845,15 +845,15 @@ static int32_t mnodeProcessBatchCreateTableMsg(SMnodeMsg *pMsg) { memcpy(pSubMsg->pCont + sizeof(SCMCreateTableMsg), p, htonl(p->len)); code = mnodeValidateCreateTableMsg(p, pSubMsg); - if (code == TSDB_CODE_SUCCESS || code == TSDB_CODE_MND_TABLE_ALREADY_EXIST) { - ++pSubMsg->pBatchMasterMsg->successed; - mnodeDestroySubMsg(pSubMsg); - continue; + if (code == TSDB_CODE_SUCCESS || ( p->igExists == 1 && code == TSDB_CODE_MND_TABLE_ALREADY_EXIST )) { + ++pSubMsg->pBatchMasterMsg->successed; + mnodeDestroySubMsg(pSubMsg); + continue; } if (code != TSDB_CODE_MND_ACTION_IN_PROGRESS) { - mnodeDestroySubMsg(pSubMsg); - return code; + mnodeDestroySubMsg(pSubMsg); + return code; } } @@ -1040,11 +1040,21 @@ static int32_t mnodeCreateSuperTableCb(SMnodeMsg *pMsg, int32_t code) { if (code == TSDB_CODE_SUCCESS) { mLInfo("stable:%s, is created in sdb, uid:%" PRIu64, pTable->info.tableId, pTable->uid); + if(pMsg->pBatchMasterMsg) + pMsg->pBatchMasterMsg->successed ++; } else { mError("msg:%p, app:%p stable:%s, failed to create in sdb, reason:%s", pMsg, pMsg->rpcMsg.ahandle, pTable->info.tableId, tstrerror(code)); SSdbRow desc = {.type = SDB_OPER_GLOBAL, .pObj = pTable, .pTable = tsSuperTableSdb}; sdbDeleteRow(&desc); + if(pMsg->pBatchMasterMsg) + pMsg->pBatchMasterMsg->received ++; + } + + // if super table create by batch msg, check done and send finished to client + if(pMsg->pBatchMasterMsg) { + if (pMsg->pBatchMasterMsg->successed + pMsg->pBatchMasterMsg->received >= pMsg->pBatchMasterMsg->expected) + dnodeSendRpcMWriteRsp(pMsg->pBatchMasterMsg, code); } return code; diff --git a/src/query/inc/qSqlparser.h b/src/query/inc/qSqlparser.h index c231c90996e00d84a70c7141eac69c5a59e20254..7385aa9d3afeddb8d16b4187a83a4015f1950263 100644 --- a/src/query/inc/qSqlparser.h +++ b/src/query/inc/qSqlparser.h @@ -25,6 +25,7 @@ extern "C" { #include "tstrbuild.h" #include "ttoken.h" #include "tvariant.h" +#include "tname.h" #define ParseTOKENTYPE SStrToken @@ -139,8 +140,11 @@ typedef struct SCreatedTableInfo { typedef struct SCreateTableSql { SStrToken name; // table name, create table [name] xxx + SStrToken to; // create stream to anohter table + SStrToken split; // split columns int8_t type; // create normal table/from super table/ stream bool existCheck; + SName toSName; struct { SArray *pTagColumns; // SArray @@ -313,6 +317,7 @@ SArray *setSubclause(SArray *pList, void *pSqlNode); SArray *appendSelectClause(SArray *pList, void *pSubclause); void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pTableNameToken, SStrToken *pIfNotExists); +void setCreatedStreamOpt(SSqlInfo *pInfo, SStrToken *pTo, SStrToken *pSplit); void SqlInfoDestroy(SSqlInfo *pInfo); diff --git a/src/query/inc/sql.y b/src/query/inc/sql.y index b19f42c3061dc22e841b3089858d8dc7e4811491..a7561874c2f165a179a81e8acfdf15aae8a2f977 100644 --- a/src/query/inc/sql.y +++ b/src/query/inc/sql.y @@ -413,14 +413,28 @@ tagNamelist(A) ::= ids(X). {A = taosArrayInit(4, sizeof(SSt // create stream // create table table_name as select count(*) from super_table_name interval(time) -create_table_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) AS select(S). { +create_table_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) to_opt(E) split_opt(F) AS select(S). { A = tSetCreateTableInfo(NULL, NULL, S, TSQL_CREATE_STREAM); setSqlInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE); + setCreatedStreamOpt(pInfo, &E, &F); V.n += Z.n; setCreatedTableName(pInfo, &V, &U); } +// to_opt +%type to_opt {SStrToken} +to_opt(A) ::= . {A.n = 0;} +to_opt(A) ::= TO ids(X) cpxName(Y). { + A = X; + A.n += Y.n; +} + +// split_opt +%type to_split {SStrToken} +split_opt(A) ::= . {A.n = 0;} +split_opt(A) ::= SPLIT ids(X). { A = X;} + %type column{TAOS_FIELD} %type columnlist{SArray*} %destructor columnlist {taosArrayDestroy($$);} diff --git a/src/query/src/qSqlParser.c b/src/query/src/qSqlParser.c index a512c7bf1a2a107998c4555ce9c442e2f501f49c..92b4620f407e726e2126b81c73d203c259ccfc36 100644 --- a/src/query/src/qSqlParser.c +++ b/src/query/src/qSqlParser.c @@ -1002,6 +1002,11 @@ void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pTableNameToken, SStrToken pInfo->pCreateTableInfo->existCheck = (pIfNotExists->n != 0); } +void setCreatedStreamOpt(SSqlInfo *pInfo, SStrToken *pTo, SStrToken *pSplit) { + pInfo->pCreateTableInfo->to = *pTo; + pInfo->pCreateTableInfo->split = *pSplit; +} + void setDCLSqlElems(SSqlInfo *pInfo, int32_t type, int32_t nParam, ...) { pInfo->type = type; if (nParam == 0) { diff --git a/src/query/src/sql.c b/src/query/src/sql.c index 1cb49982bdb62aad248efad6fddff031258e0fe4..ff3f5f452df82a29786078fb6fe9b73a08e273ca 100644 --- a/src/query/src/sql.c +++ b/src/query/src/sql.c @@ -100,29 +100,29 @@ #endif /************* Begin control #defines *****************************************/ #define YYCODETYPE unsigned short int -#define YYNOCODE 278 +#define YYNOCODE 283 #define YYACTIONTYPE unsigned short int #define ParseTOKENTYPE SStrToken typedef union { int yyinit; ParseTOKENTYPE yy0; - SRelationInfo* yy8; - SWindowStateVal yy40; - SSqlNode* yy56; - SCreateDbInfo yy90; - int yy96; - int32_t yy104; - SSessionWindowVal yy147; - SCreatedTableInfo yy152; - SLimitVal yy166; - SCreateAcctInfo yy171; - TAOS_FIELD yy183; - int64_t yy325; - SIntervalVal yy400; - SArray* yy421; - tVariant yy430; - SCreateTableSql* yy438; - tSqlExpr* yy439; + SIntervalVal yy66; + SCreateTableSql* yy86; + SArray* yy89; + tVariant yy112; + int32_t yy130; + int64_t yy145; + SRelationInfo* yy166; + SCreateAcctInfo yy307; + tSqlExpr* yy342; + int yy346; + SLimitVal yy372; + SSqlNode* yy378; + SWindowStateVal yy392; + SSessionWindowVal yy431; + TAOS_FIELD yy465; + SCreateDbInfo yy470; + SCreatedTableInfo yy506; } YYMINORTYPE; #ifndef YYSTACKDEPTH #define YYSTACKDEPTH 100 @@ -138,17 +138,17 @@ typedef union { #define ParseCTX_FETCH #define ParseCTX_STORE #define YYFALLBACK 1 -#define YYNSTATE 363 -#define YYNRULE 291 -#define YYNTOKEN 197 -#define YY_MAX_SHIFT 362 -#define YY_MIN_SHIFTREDUCE 571 -#define YY_MAX_SHIFTREDUCE 861 -#define YY_ERROR_ACTION 862 -#define YY_ACCEPT_ACTION 863 -#define YY_NO_ACTION 864 -#define YY_MIN_REDUCE 865 -#define YY_MAX_REDUCE 1155 +#define YYNSTATE 368 +#define YYNRULE 295 +#define YYNTOKEN 199 +#define YY_MAX_SHIFT 367 +#define YY_MIN_SHIFTREDUCE 578 +#define YY_MAX_SHIFTREDUCE 872 +#define YY_ERROR_ACTION 873 +#define YY_ACCEPT_ACTION 874 +#define YY_NO_ACTION 875 +#define YY_MIN_REDUCE 876 +#define YY_MAX_REDUCE 1170 /************* End control #defines *******************************************/ #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) @@ -215,289 +215,291 @@ typedef union { ** yy_default[] Default action for each state. ** *********** Begin parsing tables **********************************************/ -#define YY_ACTTAB_COUNT (757) +#define YY_ACTTAB_COUNT (764) static const YYACTIONTYPE yy_action[] = { - /* 0 */ 169, 622, 235, 622, 229, 360, 1020, 1042, 241, 623, - /* 10 */ 246, 623, 1020, 57, 58, 153, 61, 62, 280, 38, - /* 20 */ 249, 51, 622, 60, 318, 65, 63, 66, 64, 990, - /* 30 */ 623, 988, 989, 56, 55, 160, 991, 54, 53, 52, - /* 40 */ 992, 160, 993, 994, 863, 362, 1033, 572, 573, 574, - /* 50 */ 575, 576, 577, 578, 579, 580, 581, 582, 583, 584, - /* 60 */ 585, 361, 232, 231, 230, 57, 58, 1017, 61, 62, - /* 70 */ 207, 658, 249, 51, 1039, 60, 318, 65, 63, 66, - /* 80 */ 64, 1132, 1006, 278, 277, 56, 55, 80, 98, 54, - /* 90 */ 53, 52, 57, 58, 1033, 61, 62, 207, 86, 249, - /* 100 */ 51, 1014, 60, 318, 65, 63, 66, 64, 1131, 1081, - /* 110 */ 271, 290, 56, 55, 316, 1080, 54, 53, 52, 57, - /* 120 */ 59, 243, 61, 62, 1008, 1020, 249, 51, 95, 60, - /* 130 */ 318, 65, 63, 66, 64, 45, 800, 348, 1033, 56, - /* 140 */ 55, 160, 1019, 54, 53, 52, 58, 242, 61, 62, - /* 150 */ 765, 766, 249, 51, 233, 60, 318, 65, 63, 66, - /* 160 */ 64, 1003, 1004, 35, 1007, 56, 55, 316, 245, 54, - /* 170 */ 53, 52, 44, 314, 355, 354, 313, 312, 311, 353, - /* 180 */ 310, 309, 308, 352, 307, 351, 350, 982, 970, 971, - /* 190 */ 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, - /* 200 */ 983, 984, 61, 62, 24, 23, 249, 51, 263, 60, - /* 210 */ 318, 65, 63, 66, 64, 92, 79, 267, 266, 56, - /* 220 */ 55, 123, 210, 54, 53, 52, 248, 815, 207, 216, - /* 230 */ 804, 93, 807, 348, 810, 137, 136, 135, 215, 1132, - /* 240 */ 248, 815, 323, 86, 804, 81, 807, 258, 810, 250, - /* 250 */ 1005, 204, 65, 63, 66, 64, 160, 174, 227, 228, - /* 260 */ 56, 55, 319, 913, 54, 53, 52, 5, 41, 178, - /* 270 */ 188, 622, 227, 228, 177, 104, 109, 100, 108, 623, - /* 280 */ 45, 730, 356, 951, 727, 38, 728, 38, 729, 121, - /* 290 */ 115, 126, 252, 303, 38, 16, 125, 15, 131, 134, - /* 300 */ 124, 205, 270, 38, 78, 257, 782, 128, 67, 207, - /* 310 */ 746, 223, 254, 255, 3, 189, 198, 196, 194, 806, - /* 320 */ 1132, 809, 67, 193, 141, 140, 139, 138, 292, 239, - /* 330 */ 91, 240, 923, 1017, 44, 1017, 355, 354, 327, 188, - /* 340 */ 38, 353, 1017, 816, 811, 352, 38, 351, 350, 706, - /* 350 */ 812, 1016, 805, 29, 808, 211, 38, 816, 811, 38, - /* 360 */ 1091, 56, 55, 781, 812, 54, 53, 52, 253, 38, - /* 370 */ 251, 38, 326, 325, 38, 14, 1128, 338, 337, 94, - /* 380 */ 914, 259, 743, 256, 328, 333, 332, 188, 1017, 258, - /* 390 */ 329, 54, 53, 52, 1017, 258, 750, 731, 732, 175, - /* 400 */ 330, 1, 176, 334, 1017, 1018, 272, 1017, 9, 97, - /* 410 */ 83, 84, 34, 335, 71, 336, 762, 1017, 340, 1017, - /* 420 */ 39, 772, 1017, 359, 358, 599, 151, 149, 148, 773, - /* 430 */ 155, 74, 716, 802, 320, 68, 295, 718, 77, 813, - /* 440 */ 247, 133, 132, 26, 297, 298, 39, 274, 274, 717, - /* 450 */ 39, 68, 836, 817, 621, 114, 72, 113, 96, 18, - /* 460 */ 1127, 17, 6, 68, 1126, 225, 25, 25, 25, 803, - /* 470 */ 705, 75, 814, 735, 733, 736, 734, 20, 226, 19, - /* 480 */ 120, 22, 119, 21, 208, 209, 212, 206, 213, 1151, - /* 490 */ 214, 1143, 1034, 1090, 218, 237, 219, 220, 217, 203, - /* 500 */ 1087, 1086, 238, 339, 268, 152, 1041, 1052, 48, 1073, - /* 510 */ 1049, 1050, 275, 1072, 1015, 1054, 150, 154, 159, 286, - /* 520 */ 170, 171, 279, 1013, 172, 173, 162, 234, 281, 283, - /* 530 */ 928, 163, 165, 1031, 761, 161, 300, 819, 301, 302, - /* 540 */ 305, 306, 46, 201, 293, 164, 42, 289, 291, 317, - /* 550 */ 922, 324, 76, 73, 50, 287, 1150, 166, 111, 1149, - /* 560 */ 282, 1146, 285, 167, 179, 49, 331, 1142, 304, 122, - /* 570 */ 349, 117, 1141, 1138, 180, 948, 43, 40, 47, 341, - /* 580 */ 202, 910, 127, 908, 129, 130, 906, 905, 260, 191, - /* 590 */ 192, 902, 901, 900, 899, 898, 897, 896, 195, 197, - /* 600 */ 892, 890, 888, 199, 885, 200, 342, 273, 82, 87, - /* 610 */ 343, 284, 1074, 344, 345, 346, 347, 357, 861, 261, - /* 620 */ 262, 860, 224, 244, 299, 264, 265, 859, 842, 841, - /* 630 */ 269, 274, 221, 10, 85, 294, 927, 105, 926, 222, - /* 640 */ 106, 738, 276, 30, 88, 763, 904, 156, 903, 774, - /* 650 */ 142, 143, 895, 183, 182, 949, 181, 184, 185, 187, - /* 660 */ 186, 144, 894, 887, 950, 145, 986, 886, 2, 157, - /* 670 */ 168, 768, 33, 4, 158, 89, 236, 770, 90, 996, - /* 680 */ 288, 31, 11, 32, 12, 13, 27, 296, 28, 97, - /* 690 */ 99, 102, 36, 101, 636, 37, 103, 671, 669, 668, - /* 700 */ 667, 665, 664, 663, 660, 626, 315, 107, 7, 820, - /* 710 */ 818, 321, 8, 322, 110, 112, 69, 70, 116, 708, - /* 720 */ 707, 39, 118, 704, 652, 650, 642, 648, 644, 646, - /* 730 */ 640, 638, 674, 673, 672, 670, 666, 662, 661, 190, - /* 740 */ 589, 624, 587, 865, 864, 864, 864, 864, 864, 864, - /* 750 */ 864, 864, 864, 864, 864, 146, 147, + /* 0 */ 250, 629, 629, 629, 233, 365, 23, 249, 254, 630, + /* 10 */ 630, 630, 239, 57, 58, 665, 61, 62, 1057, 1035, + /* 20 */ 253, 51, 629, 60, 323, 65, 63, 66, 64, 1001, + /* 30 */ 630, 999, 1000, 56, 55, 209, 1002, 54, 53, 52, + /* 40 */ 1003, 210, 1004, 1005, 164, 874, 367, 579, 580, 581, + /* 50 */ 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, + /* 60 */ 592, 366, 325, 212, 234, 57, 58, 80, 61, 62, + /* 70 */ 212, 212, 253, 51, 1147, 60, 323, 65, 63, 66, + /* 80 */ 64, 1147, 1147, 212, 29, 56, 55, 83, 1054, 54, + /* 90 */ 53, 52, 57, 58, 1146, 61, 62, 1048, 1048, 253, + /* 100 */ 51, 1016, 60, 323, 65, 63, 66, 64, 54, 53, + /* 110 */ 52, 89, 56, 55, 275, 236, 54, 53, 52, 57, + /* 120 */ 59, 1095, 61, 62, 321, 1048, 253, 51, 98, 60, + /* 130 */ 323, 65, 63, 66, 64, 817, 811, 820, 164, 56, + /* 140 */ 55, 164, 237, 54, 53, 52, 58, 245, 61, 62, + /* 150 */ 45, 757, 253, 51, 1035, 60, 323, 65, 63, 66, + /* 160 */ 64, 1014, 1015, 35, 1018, 56, 55, 830, 164, 54, + /* 170 */ 53, 52, 44, 319, 360, 359, 318, 317, 316, 358, + /* 180 */ 315, 314, 313, 357, 312, 356, 355, 993, 981, 982, + /* 190 */ 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, + /* 200 */ 994, 995, 61, 62, 24, 38, 253, 51, 86, 60, + /* 210 */ 323, 65, 63, 66, 64, 1096, 296, 294, 94, 56, + /* 220 */ 55, 247, 215, 54, 53, 52, 252, 826, 1035, 221, + /* 230 */ 815, 157, 818, 173, 821, 140, 139, 138, 220, 761, + /* 240 */ 252, 826, 328, 89, 815, 95, 818, 278, 821, 235, + /* 250 */ 38, 284, 65, 63, 66, 64, 1032, 824, 231, 232, + /* 260 */ 56, 55, 324, 38, 54, 53, 52, 5, 41, 183, + /* 270 */ 1017, 256, 231, 232, 182, 107, 112, 103, 111, 101, + /* 280 */ 741, 713, 45, 738, 38, 739, 816, 740, 819, 124, + /* 290 */ 118, 129, 261, 308, 243, 262, 128, 34, 134, 137, + /* 300 */ 127, 1032, 282, 281, 274, 179, 79, 131, 67, 343, + /* 310 */ 342, 258, 259, 228, 1031, 1019, 203, 201, 199, 1025, + /* 320 */ 38, 216, 67, 198, 144, 143, 142, 141, 244, 44, + /* 330 */ 303, 360, 359, 56, 55, 1032, 358, 54, 53, 52, + /* 340 */ 357, 38, 356, 355, 38, 827, 822, 262, 14, 257, + /* 350 */ 126, 255, 823, 331, 330, 321, 38, 180, 38, 827, + /* 360 */ 822, 38, 353, 262, 332, 246, 823, 38, 793, 38, + /* 370 */ 263, 1032, 260, 1033, 338, 337, 353, 267, 364, 363, + /* 380 */ 606, 1143, 100, 81, 1142, 333, 271, 270, 334, 154, + /* 390 */ 152, 151, 1032, 71, 924, 1032, 776, 777, 742, 743, + /* 400 */ 335, 193, 339, 934, 754, 340, 74, 1032, 825, 1032, + /* 410 */ 193, 341, 1032, 345, 925, 361, 962, 96, 1032, 276, + /* 420 */ 1032, 193, 1, 181, 3, 194, 87, 792, 773, 783, + /* 430 */ 784, 84, 9, 39, 813, 723, 300, 72, 725, 302, + /* 440 */ 724, 847, 159, 68, 26, 828, 628, 251, 75, 39, + /* 450 */ 39, 78, 68, 99, 68, 25, 746, 1034, 747, 25, + /* 460 */ 25, 16, 117, 15, 116, 278, 18, 48, 17, 6, + /* 470 */ 814, 744, 20, 745, 19, 123, 22, 122, 21, 136, + /* 480 */ 135, 1141, 229, 712, 230, 1106, 213, 214, 217, 211, + /* 490 */ 1166, 218, 219, 223, 1158, 224, 1105, 241, 1102, 225, + /* 500 */ 222, 1101, 208, 242, 344, 272, 155, 175, 174, 156, + /* 510 */ 1049, 1030, 1056, 1067, 1088, 279, 153, 1064, 1065, 1069, + /* 520 */ 1026, 158, 163, 290, 176, 1087, 277, 1024, 1046, 283, + /* 530 */ 772, 177, 178, 939, 305, 306, 307, 168, 310, 311, + /* 540 */ 46, 206, 42, 322, 297, 933, 76, 238, 285, 329, + /* 550 */ 1165, 114, 1164, 73, 287, 1161, 165, 166, 50, 295, + /* 560 */ 184, 336, 1157, 167, 293, 120, 1156, 1153, 185, 959, + /* 570 */ 291, 43, 40, 47, 207, 921, 130, 919, 132, 133, + /* 580 */ 917, 916, 264, 196, 197, 913, 912, 911, 289, 910, + /* 590 */ 909, 908, 907, 200, 202, 903, 901, 899, 204, 896, + /* 600 */ 205, 286, 1028, 49, 85, 90, 82, 288, 1089, 309, + /* 610 */ 354, 125, 346, 347, 348, 349, 350, 351, 77, 248, + /* 620 */ 304, 352, 362, 872, 266, 265, 226, 871, 268, 227, + /* 630 */ 269, 938, 937, 108, 109, 145, 870, 853, 852, 273, + /* 640 */ 278, 299, 10, 30, 915, 914, 188, 146, 187, 960, + /* 650 */ 186, 906, 190, 189, 191, 192, 147, 905, 4, 2, + /* 660 */ 148, 997, 961, 88, 298, 898, 33, 897, 169, 170, + /* 670 */ 749, 171, 172, 280, 91, 774, 160, 1007, 785, 161, + /* 680 */ 162, 779, 92, 240, 781, 93, 292, 31, 11, 12, + /* 690 */ 32, 97, 13, 27, 301, 28, 100, 105, 104, 102, + /* 700 */ 643, 36, 37, 106, 676, 678, 675, 674, 672, 671, + /* 710 */ 670, 667, 320, 633, 110, 7, 326, 829, 831, 8, + /* 720 */ 327, 113, 115, 69, 70, 715, 39, 119, 714, 711, + /* 730 */ 121, 659, 657, 649, 655, 651, 653, 647, 645, 681, + /* 740 */ 680, 679, 677, 673, 669, 668, 195, 596, 631, 594, + /* 750 */ 876, 875, 875, 875, 875, 875, 875, 875, 875, 875, + /* 760 */ 875, 875, 149, 150, }; static const YYCODETYPE yy_lookahead[] = { - /* 0 */ 253, 1, 245, 1, 199, 200, 249, 200, 245, 9, - /* 10 */ 206, 9, 249, 13, 14, 200, 16, 17, 271, 200, - /* 20 */ 20, 21, 1, 23, 24, 25, 26, 27, 28, 223, - /* 30 */ 9, 225, 226, 33, 34, 200, 230, 37, 38, 39, - /* 40 */ 234, 200, 236, 237, 197, 198, 247, 45, 46, 47, + /* 0 */ 208, 1, 1, 1, 201, 202, 271, 208, 208, 9, + /* 10 */ 9, 9, 247, 13, 14, 5, 16, 17, 202, 254, + /* 20 */ 20, 21, 1, 23, 24, 25, 26, 27, 28, 225, + /* 30 */ 9, 227, 228, 33, 34, 271, 232, 37, 38, 39, + /* 40 */ 236, 271, 238, 239, 202, 199, 200, 45, 46, 47, /* 50 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - /* 60 */ 58, 59, 263, 244, 62, 13, 14, 248, 16, 17, - /* 70 */ 266, 5, 20, 21, 267, 23, 24, 25, 26, 27, - /* 80 */ 28, 277, 0, 268, 269, 33, 34, 87, 207, 37, - /* 90 */ 38, 39, 13, 14, 247, 16, 17, 266, 83, 20, - /* 100 */ 21, 200, 23, 24, 25, 26, 27, 28, 277, 274, - /* 110 */ 263, 276, 33, 34, 85, 274, 37, 38, 39, 13, - /* 120 */ 14, 245, 16, 17, 243, 249, 20, 21, 207, 23, - /* 130 */ 24, 25, 26, 27, 28, 120, 84, 91, 247, 33, - /* 140 */ 34, 200, 249, 37, 38, 39, 14, 246, 16, 17, - /* 150 */ 126, 127, 20, 21, 263, 23, 24, 25, 26, 27, - /* 160 */ 28, 240, 241, 242, 243, 33, 34, 85, 206, 37, + /* 60 */ 58, 59, 15, 271, 62, 13, 14, 209, 16, 17, + /* 70 */ 271, 271, 20, 21, 282, 23, 24, 25, 26, 27, + /* 80 */ 28, 282, 282, 271, 83, 33, 34, 87, 272, 37, + /* 90 */ 38, 39, 13, 14, 282, 16, 17, 251, 251, 20, + /* 100 */ 21, 243, 23, 24, 25, 26, 27, 28, 37, 38, + /* 110 */ 39, 83, 33, 34, 268, 268, 37, 38, 39, 13, + /* 120 */ 14, 279, 16, 17, 85, 251, 20, 21, 209, 23, + /* 130 */ 24, 25, 26, 27, 28, 5, 84, 7, 202, 33, + /* 140 */ 34, 202, 268, 37, 38, 39, 14, 247, 16, 17, + /* 150 */ 122, 37, 20, 21, 254, 23, 24, 25, 26, 27, + /* 160 */ 28, 242, 243, 244, 245, 33, 34, 120, 202, 37, /* 170 */ 38, 39, 99, 100, 101, 102, 103, 104, 105, 106, - /* 180 */ 107, 108, 109, 110, 111, 112, 113, 223, 224, 225, - /* 190 */ 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - /* 200 */ 236, 237, 16, 17, 44, 266, 20, 21, 143, 23, - /* 210 */ 24, 25, 26, 27, 28, 274, 207, 152, 153, 33, - /* 220 */ 34, 79, 62, 37, 38, 39, 1, 2, 266, 69, - /* 230 */ 5, 250, 7, 91, 9, 75, 76, 77, 78, 277, - /* 240 */ 1, 2, 82, 83, 5, 264, 7, 200, 9, 206, - /* 250 */ 241, 266, 25, 26, 27, 28, 200, 210, 33, 34, - /* 260 */ 33, 34, 37, 205, 37, 38, 39, 63, 64, 65, - /* 270 */ 212, 1, 33, 34, 70, 71, 72, 73, 74, 9, - /* 280 */ 120, 2, 221, 222, 5, 200, 7, 200, 9, 63, - /* 290 */ 64, 65, 69, 89, 200, 146, 70, 148, 72, 73, - /* 300 */ 74, 266, 142, 200, 144, 69, 77, 81, 83, 266, - /* 310 */ 37, 151, 33, 34, 203, 204, 63, 64, 65, 5, - /* 320 */ 277, 7, 83, 70, 71, 72, 73, 74, 272, 244, - /* 330 */ 274, 244, 205, 248, 99, 248, 101, 102, 244, 212, - /* 340 */ 200, 106, 248, 118, 119, 110, 200, 112, 113, 5, - /* 350 */ 125, 248, 5, 83, 7, 266, 200, 118, 119, 200, - /* 360 */ 239, 33, 34, 134, 125, 37, 38, 39, 145, 200, - /* 370 */ 147, 200, 149, 150, 200, 83, 266, 33, 34, 87, - /* 380 */ 205, 145, 98, 147, 244, 149, 150, 212, 248, 200, - /* 390 */ 244, 37, 38, 39, 248, 200, 123, 118, 119, 210, - /* 400 */ 244, 208, 209, 244, 248, 210, 84, 248, 124, 117, - /* 410 */ 84, 84, 83, 244, 98, 244, 84, 248, 244, 248, - /* 420 */ 98, 84, 248, 66, 67, 68, 63, 64, 65, 84, - /* 430 */ 98, 98, 84, 1, 15, 98, 84, 84, 83, 125, - /* 440 */ 61, 79, 80, 98, 84, 116, 98, 121, 121, 84, - /* 450 */ 98, 98, 84, 84, 84, 146, 140, 148, 98, 146, - /* 460 */ 266, 148, 83, 98, 266, 266, 98, 98, 98, 37, - /* 470 */ 115, 138, 125, 5, 5, 7, 7, 146, 266, 148, - /* 480 */ 146, 146, 148, 148, 266, 266, 266, 266, 266, 249, - /* 490 */ 266, 249, 247, 239, 266, 239, 266, 266, 266, 266, - /* 500 */ 239, 239, 239, 239, 200, 200, 200, 200, 265, 275, - /* 510 */ 200, 200, 247, 275, 247, 200, 61, 200, 200, 200, - /* 520 */ 251, 200, 270, 200, 200, 200, 260, 270, 270, 270, - /* 530 */ 200, 259, 257, 262, 125, 261, 200, 118, 200, 200, - /* 540 */ 200, 200, 200, 200, 132, 258, 200, 130, 135, 200, - /* 550 */ 200, 200, 137, 139, 136, 129, 200, 256, 200, 200, - /* 560 */ 131, 200, 128, 255, 200, 141, 200, 200, 90, 97, - /* 570 */ 114, 200, 200, 200, 200, 200, 200, 200, 200, 96, - /* 580 */ 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, - /* 590 */ 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, - /* 600 */ 200, 200, 200, 200, 200, 200, 51, 201, 201, 201, - /* 610 */ 93, 201, 201, 95, 55, 94, 92, 85, 5, 154, - /* 620 */ 5, 5, 201, 201, 201, 154, 5, 5, 101, 100, - /* 630 */ 143, 121, 201, 83, 122, 116, 211, 207, 211, 201, - /* 640 */ 207, 84, 98, 83, 98, 84, 201, 83, 201, 84, - /* 650 */ 202, 202, 201, 214, 218, 220, 219, 217, 215, 213, - /* 660 */ 216, 202, 201, 201, 222, 202, 238, 201, 208, 83, - /* 670 */ 254, 84, 252, 203, 98, 83, 1, 84, 83, 238, - /* 680 */ 83, 98, 133, 98, 133, 83, 83, 116, 83, 117, - /* 690 */ 79, 71, 88, 87, 5, 88, 87, 9, 5, 5, - /* 700 */ 5, 5, 5, 5, 5, 86, 15, 79, 83, 118, - /* 710 */ 84, 24, 83, 59, 148, 148, 16, 16, 148, 5, - /* 720 */ 5, 98, 148, 84, 5, 5, 5, 5, 5, 5, - /* 730 */ 5, 5, 5, 5, 5, 5, 5, 5, 5, 98, - /* 740 */ 61, 86, 60, 0, 278, 278, 278, 278, 278, 278, - /* 750 */ 278, 278, 278, 278, 278, 21, 21, 278, 278, 278, - /* 760 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, - /* 770 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, - /* 780 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, - /* 790 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, - /* 800 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, - /* 810 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, - /* 820 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, - /* 830 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, - /* 840 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, - /* 850 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, - /* 860 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, - /* 870 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, - /* 880 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, - /* 890 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, - /* 900 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, - /* 910 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, - /* 920 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, - /* 930 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, - /* 940 */ 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, - /* 950 */ 278, 278, 278, 278, + /* 180 */ 107, 108, 109, 110, 111, 112, 113, 225, 226, 227, + /* 190 */ 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + /* 200 */ 238, 239, 16, 17, 44, 202, 20, 21, 84, 23, + /* 210 */ 24, 25, 26, 27, 28, 279, 277, 281, 279, 33, + /* 220 */ 34, 247, 62, 37, 38, 39, 1, 2, 254, 69, + /* 230 */ 5, 202, 7, 258, 9, 75, 76, 77, 78, 125, + /* 240 */ 1, 2, 82, 83, 5, 279, 7, 123, 9, 246, + /* 250 */ 202, 276, 25, 26, 27, 28, 253, 127, 33, 34, + /* 260 */ 33, 34, 37, 202, 37, 38, 39, 63, 64, 65, + /* 270 */ 0, 69, 33, 34, 70, 71, 72, 73, 74, 209, + /* 280 */ 2, 5, 122, 5, 202, 7, 5, 9, 7, 63, + /* 290 */ 64, 65, 69, 89, 246, 202, 70, 83, 72, 73, + /* 300 */ 74, 253, 273, 274, 144, 212, 146, 81, 83, 33, + /* 310 */ 34, 33, 34, 153, 253, 245, 63, 64, 65, 202, + /* 320 */ 202, 271, 83, 70, 71, 72, 73, 74, 246, 99, + /* 330 */ 116, 101, 102, 33, 34, 253, 106, 37, 38, 39, + /* 340 */ 110, 202, 112, 113, 202, 120, 121, 202, 83, 147, + /* 350 */ 79, 149, 127, 151, 152, 85, 202, 212, 202, 120, + /* 360 */ 121, 202, 91, 202, 246, 248, 127, 202, 77, 202, + /* 370 */ 147, 253, 149, 212, 151, 152, 91, 145, 66, 67, + /* 380 */ 68, 271, 117, 118, 271, 246, 154, 155, 246, 63, + /* 390 */ 64, 65, 253, 98, 207, 253, 128, 129, 120, 121, + /* 400 */ 246, 214, 246, 207, 98, 246, 98, 253, 127, 253, + /* 410 */ 214, 246, 253, 246, 207, 223, 224, 255, 253, 84, + /* 420 */ 253, 214, 210, 211, 205, 206, 84, 136, 84, 84, + /* 430 */ 84, 269, 126, 98, 1, 84, 84, 142, 84, 84, + /* 440 */ 84, 84, 98, 98, 98, 84, 84, 61, 140, 98, + /* 450 */ 98, 83, 98, 98, 98, 98, 5, 254, 7, 98, + /* 460 */ 98, 148, 148, 150, 150, 123, 148, 270, 150, 83, + /* 470 */ 37, 5, 148, 7, 150, 148, 148, 150, 150, 79, + /* 480 */ 80, 271, 271, 115, 271, 241, 271, 271, 271, 271, + /* 490 */ 254, 271, 271, 271, 254, 271, 241, 241, 241, 271, + /* 500 */ 271, 241, 271, 241, 241, 202, 202, 249, 256, 202, + /* 510 */ 251, 202, 202, 202, 280, 251, 61, 202, 202, 202, + /* 520 */ 251, 202, 202, 202, 202, 280, 203, 202, 267, 275, + /* 530 */ 127, 202, 202, 202, 202, 202, 202, 263, 202, 202, + /* 540 */ 202, 202, 202, 202, 134, 202, 139, 275, 275, 202, + /* 550 */ 202, 202, 202, 141, 275, 202, 266, 265, 138, 137, + /* 560 */ 202, 202, 202, 264, 132, 202, 202, 202, 202, 202, + /* 570 */ 131, 202, 202, 202, 202, 202, 202, 202, 202, 202, + /* 580 */ 202, 202, 202, 202, 202, 202, 202, 202, 130, 202, + /* 590 */ 202, 202, 202, 202, 202, 202, 202, 202, 202, 202, + /* 600 */ 202, 133, 203, 143, 203, 203, 119, 203, 203, 90, + /* 610 */ 114, 97, 96, 51, 93, 95, 55, 94, 203, 203, + /* 620 */ 203, 92, 85, 5, 5, 156, 203, 5, 156, 203, + /* 630 */ 5, 213, 213, 209, 209, 204, 5, 101, 100, 145, + /* 640 */ 123, 116, 83, 83, 203, 203, 216, 204, 220, 222, + /* 650 */ 221, 203, 217, 219, 218, 215, 204, 203, 205, 210, + /* 660 */ 204, 240, 224, 124, 250, 203, 257, 203, 262, 261, + /* 670 */ 84, 260, 259, 98, 98, 84, 83, 240, 84, 83, + /* 680 */ 98, 84, 83, 1, 84, 83, 83, 98, 135, 135, + /* 690 */ 98, 87, 83, 83, 116, 83, 117, 71, 87, 79, + /* 700 */ 5, 88, 88, 87, 5, 9, 5, 5, 5, 5, + /* 710 */ 5, 5, 15, 86, 79, 83, 24, 84, 120, 83, + /* 720 */ 59, 150, 150, 16, 16, 5, 98, 150, 5, 84, + /* 730 */ 150, 5, 5, 5, 5, 5, 5, 5, 5, 5, + /* 740 */ 5, 5, 5, 5, 5, 5, 98, 61, 86, 60, + /* 750 */ 0, 283, 283, 283, 283, 283, 283, 283, 283, 283, + /* 760 */ 283, 283, 21, 21, 283, 283, 283, 283, 283, 283, + /* 770 */ 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + /* 780 */ 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + /* 790 */ 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + /* 800 */ 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + /* 810 */ 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + /* 820 */ 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + /* 830 */ 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + /* 840 */ 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + /* 850 */ 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + /* 860 */ 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + /* 870 */ 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + /* 880 */ 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + /* 890 */ 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + /* 900 */ 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + /* 910 */ 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + /* 920 */ 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + /* 930 */ 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + /* 940 */ 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + /* 950 */ 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + /* 960 */ 283, 283, 283, }; -#define YY_SHIFT_COUNT (362) +#define YY_SHIFT_COUNT (367) #define YY_SHIFT_MIN (0) -#define YY_SHIFT_MAX (743) +#define YY_SHIFT_MAX (750) static const unsigned short int yy_shift_ofst[] = { - /* 0 */ 160, 73, 73, 235, 235, 29, 225, 239, 239, 270, + /* 0 */ 160, 73, 73, 230, 230, 39, 225, 239, 239, 1, /* 10 */ 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, - /* 20 */ 21, 21, 21, 0, 2, 239, 279, 279, 279, 15, - /* 30 */ 15, 21, 21, 24, 21, 82, 21, 21, 21, 21, - /* 40 */ 142, 29, 46, 46, 66, 757, 757, 757, 239, 239, + /* 20 */ 21, 21, 21, 0, 2, 239, 278, 278, 278, 28, + /* 30 */ 28, 21, 21, 268, 21, 270, 21, 21, 21, 21, + /* 40 */ 271, 39, 285, 285, 10, 764, 764, 764, 239, 239, /* 50 */ 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, - /* 60 */ 239, 239, 239, 239, 239, 239, 239, 239, 279, 279, - /* 70 */ 279, 344, 344, 344, 344, 344, 344, 344, 21, 21, - /* 80 */ 21, 273, 21, 21, 21, 15, 15, 21, 21, 21, - /* 90 */ 21, 229, 229, 284, 15, 21, 21, 21, 21, 21, + /* 60 */ 239, 239, 239, 239, 239, 239, 239, 239, 278, 278, + /* 70 */ 278, 276, 276, 276, 276, 276, 276, 265, 276, 21, + /* 80 */ 21, 21, 21, 21, 114, 21, 21, 21, 28, 28, + /* 90 */ 21, 21, 21, 21, 291, 291, 306, 28, 21, 21, /* 100 */ 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, /* 110 */ 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, /* 120 */ 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, /* 130 */ 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, /* 140 */ 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, - /* 150 */ 21, 21, 455, 455, 455, 409, 409, 409, 409, 455, - /* 160 */ 455, 415, 414, 412, 418, 413, 417, 426, 434, 429, - /* 170 */ 424, 455, 455, 455, 478, 478, 456, 29, 29, 455, - /* 180 */ 455, 472, 483, 555, 517, 518, 559, 521, 524, 456, - /* 190 */ 66, 455, 455, 532, 532, 455, 532, 455, 532, 455, - /* 200 */ 455, 757, 757, 52, 79, 79, 106, 79, 132, 186, - /* 210 */ 204, 227, 227, 227, 227, 226, 253, 328, 328, 328, - /* 220 */ 328, 223, 236, 65, 292, 354, 354, 314, 347, 357, - /* 230 */ 363, 322, 326, 327, 332, 337, 345, 316, 333, 348, - /* 240 */ 352, 353, 360, 365, 329, 368, 369, 432, 379, 419, - /* 250 */ 370, 149, 309, 313, 468, 469, 331, 334, 355, 335, - /* 260 */ 362, 613, 465, 615, 616, 471, 621, 622, 527, 529, - /* 270 */ 487, 510, 519, 550, 512, 557, 560, 544, 546, 561, - /* 280 */ 564, 565, 586, 587, 576, 592, 593, 595, 675, 597, - /* 290 */ 583, 549, 585, 551, 602, 519, 603, 571, 605, 572, - /* 300 */ 611, 604, 606, 620, 689, 607, 609, 688, 693, 694, - /* 310 */ 695, 696, 697, 698, 699, 619, 691, 628, 625, 626, - /* 320 */ 591, 629, 687, 654, 700, 566, 567, 623, 623, 623, - /* 330 */ 623, 701, 570, 574, 623, 623, 623, 714, 715, 639, - /* 340 */ 623, 719, 720, 721, 722, 723, 724, 725, 726, 727, - /* 350 */ 728, 729, 730, 731, 732, 733, 641, 655, 734, 735, - /* 360 */ 679, 682, 743, + /* 150 */ 21, 21, 21, 21, 21, 455, 455, 455, 455, 403, + /* 160 */ 403, 403, 403, 455, 455, 407, 412, 410, 420, 422, + /* 170 */ 432, 439, 458, 468, 460, 487, 455, 455, 455, 519, + /* 180 */ 519, 496, 39, 39, 455, 455, 514, 516, 562, 521, + /* 190 */ 520, 561, 523, 529, 496, 10, 455, 455, 537, 537, + /* 200 */ 455, 537, 455, 537, 455, 455, 764, 764, 52, 79, + /* 210 */ 79, 106, 79, 132, 186, 204, 227, 227, 227, 227, + /* 220 */ 226, 253, 300, 300, 300, 300, 202, 223, 232, 71, + /* 230 */ 71, 130, 281, 312, 326, 335, 124, 342, 344, 345, + /* 240 */ 346, 295, 308, 351, 352, 354, 355, 356, 214, 357, + /* 250 */ 361, 433, 386, 47, 362, 313, 314, 318, 451, 466, + /* 260 */ 324, 327, 368, 328, 400, 618, 469, 619, 622, 472, + /* 270 */ 625, 631, 536, 538, 494, 517, 525, 559, 539, 586, + /* 280 */ 560, 575, 576, 591, 593, 594, 596, 597, 582, 599, + /* 290 */ 600, 602, 682, 603, 589, 553, 592, 554, 604, 609, + /* 300 */ 525, 610, 578, 612, 579, 620, 613, 611, 626, 695, + /* 310 */ 614, 616, 696, 699, 701, 702, 703, 704, 705, 706, + /* 320 */ 627, 697, 635, 632, 633, 598, 636, 692, 661, 707, + /* 330 */ 571, 572, 628, 628, 628, 628, 708, 577, 580, 628, + /* 340 */ 628, 628, 720, 723, 645, 628, 726, 727, 728, 729, + /* 350 */ 730, 731, 732, 733, 734, 735, 736, 737, 738, 739, + /* 360 */ 740, 648, 662, 741, 742, 686, 689, 750, }; -#define YY_REDUCE_COUNT (202) -#define YY_REDUCE_MIN (-253) -#define YY_REDUCE_MAX (470) +#define YY_REDUCE_COUNT (207) +#define YY_REDUCE_MIN (-265) +#define YY_REDUCE_MAX (464) static const short yy_reduce_ofst[] = { - /* 0 */ -153, -36, -36, -194, -194, -79, -196, -38, 43, -185, - /* 10 */ -181, -165, 56, 85, 87, 94, 140, 146, 156, 159, - /* 20 */ 169, 171, 174, -193, -195, -169, -243, -237, -124, -201, - /* 30 */ -109, -159, -59, -253, -99, -119, 47, 189, 195, 103, - /* 40 */ 58, 9, 127, 175, 61, -19, 193, 111, -61, -15, - /* 50 */ 35, 89, 110, 194, 198, 199, 212, 218, 219, 220, - /* 60 */ 221, 222, 224, 228, 230, 231, 232, 233, -107, 240, - /* 70 */ 242, 121, 254, 256, 261, 262, 263, 264, 304, 305, - /* 80 */ 306, 243, 307, 310, 311, 245, 265, 315, 317, 318, - /* 90 */ 319, 234, 238, 269, 267, 321, 323, 324, 325, 330, - /* 100 */ 336, 338, 339, 340, 341, 342, 343, 346, 349, 350, - /* 110 */ 351, 356, 358, 359, 361, 364, 366, 367, 371, 372, - /* 120 */ 373, 374, 375, 376, 377, 378, 380, 381, 382, 383, - /* 130 */ 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - /* 140 */ 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, - /* 150 */ 404, 405, 406, 407, 408, 252, 257, 258, 259, 410, - /* 160 */ 411, 271, 274, 266, 272, 287, 275, 301, 308, 416, - /* 170 */ 420, 421, 422, 423, 425, 427, 428, 430, 433, 431, - /* 180 */ 438, 435, 437, 436, 439, 440, 443, 444, 446, 441, - /* 190 */ 442, 445, 447, 448, 449, 451, 459, 461, 463, 462, - /* 200 */ 466, 460, 470, + /* 0 */ -154, -38, -38, -196, -196, -81, -208, -201, -200, 29, + /* 10 */ 3, -64, -61, 48, 82, 118, 139, 142, 154, 156, + /* 20 */ 159, 165, 167, -184, -197, -188, -235, -100, -26, -153, + /* 30 */ -126, -158, -34, -25, 117, 70, 93, 145, 161, 61, + /* 40 */ 187, -142, 196, 207, 192, 162, 212, 219, -265, -236, + /* 50 */ -230, 50, 110, 113, 210, 211, 213, 215, 216, 217, + /* 60 */ 218, 220, 221, 222, 224, 228, 229, 231, 203, 236, + /* 70 */ 240, 244, 255, 256, 257, 260, 262, 258, 263, 303, + /* 80 */ 304, 307, 309, 310, 197, 311, 315, 316, 259, 264, + /* 90 */ 317, 319, 320, 321, 234, 245, 252, 269, 322, 325, + /* 100 */ 329, 330, 331, 332, 333, 334, 336, 337, 338, 339, + /* 110 */ 340, 341, 343, 347, 348, 349, 350, 353, 358, 359, + /* 120 */ 360, 363, 364, 365, 366, 367, 369, 370, 371, 372, + /* 130 */ 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, + /* 140 */ 383, 384, 385, 387, 388, 389, 390, 391, 392, 393, + /* 150 */ 394, 395, 396, 397, 398, 323, 399, 401, 402, 254, + /* 160 */ 272, 273, 279, 404, 405, 261, 290, 292, 299, 274, + /* 170 */ 406, 408, 411, 413, 409, 414, 415, 416, 417, 418, + /* 180 */ 419, 421, 424, 425, 423, 426, 427, 429, 428, 430, + /* 190 */ 434, 435, 436, 440, 437, 438, 441, 442, 431, 443, + /* 200 */ 448, 452, 454, 456, 462, 464, 449, 453, }; static const YYACTIONTYPE yy_default[] = { - /* 0 */ 862, 985, 924, 995, 911, 921, 1134, 1134, 1134, 862, - /* 10 */ 862, 862, 862, 862, 862, 862, 862, 862, 862, 862, - /* 20 */ 862, 862, 862, 1043, 882, 1134, 862, 862, 862, 862, - /* 30 */ 862, 862, 862, 1058, 862, 921, 862, 862, 862, 862, - /* 40 */ 931, 921, 931, 931, 862, 1038, 969, 987, 862, 862, - /* 50 */ 862, 862, 862, 862, 862, 862, 862, 862, 862, 862, - /* 60 */ 862, 862, 862, 862, 862, 862, 862, 862, 862, 862, - /* 70 */ 862, 862, 862, 862, 862, 862, 862, 862, 862, 862, - /* 80 */ 862, 1045, 1051, 1048, 862, 862, 862, 1053, 862, 862, - /* 90 */ 862, 1077, 1077, 1036, 862, 862, 862, 862, 862, 862, - /* 100 */ 862, 862, 862, 862, 862, 862, 862, 862, 862, 862, - /* 110 */ 862, 862, 862, 862, 862, 862, 862, 862, 862, 862, - /* 120 */ 862, 862, 862, 862, 862, 862, 862, 909, 862, 907, - /* 130 */ 862, 862, 862, 862, 862, 862, 862, 862, 862, 862, - /* 140 */ 862, 862, 862, 862, 862, 862, 862, 862, 862, 862, - /* 150 */ 862, 862, 884, 884, 884, 862, 862, 862, 862, 884, - /* 160 */ 884, 1084, 1088, 1070, 1082, 1078, 1065, 1063, 1061, 1069, - /* 170 */ 1092, 884, 884, 884, 929, 929, 925, 921, 921, 884, - /* 180 */ 884, 947, 945, 943, 935, 941, 937, 939, 933, 912, - /* 190 */ 862, 884, 884, 919, 919, 884, 919, 884, 919, 884, - /* 200 */ 884, 969, 987, 862, 1093, 1083, 862, 1133, 1123, 1122, - /* 210 */ 862, 1129, 1121, 1120, 1119, 862, 862, 1115, 1118, 1117, - /* 220 */ 1116, 862, 862, 862, 862, 1125, 1124, 862, 862, 862, - /* 230 */ 862, 862, 862, 862, 862, 862, 862, 1089, 1085, 862, - /* 240 */ 862, 862, 862, 862, 862, 862, 862, 862, 1095, 862, - /* 250 */ 862, 862, 862, 862, 862, 862, 862, 862, 997, 862, - /* 260 */ 862, 862, 862, 862, 862, 862, 862, 862, 862, 862, - /* 270 */ 862, 1035, 862, 862, 862, 862, 862, 1047, 1046, 862, - /* 280 */ 862, 862, 862, 862, 862, 862, 862, 862, 862, 862, - /* 290 */ 1079, 862, 1071, 862, 862, 1009, 862, 862, 862, 862, - /* 300 */ 862, 862, 862, 862, 862, 862, 862, 862, 862, 862, - /* 310 */ 862, 862, 862, 862, 862, 862, 862, 862, 862, 862, - /* 320 */ 862, 862, 862, 862, 862, 862, 862, 1152, 1147, 1148, - /* 330 */ 1145, 862, 862, 862, 1144, 1139, 1140, 862, 862, 862, - /* 340 */ 1137, 862, 862, 862, 862, 862, 862, 862, 862, 862, - /* 350 */ 862, 862, 862, 862, 862, 862, 953, 862, 891, 889, - /* 360 */ 862, 880, 862, + /* 0 */ 873, 996, 935, 1006, 922, 932, 1149, 1149, 1149, 873, + /* 10 */ 873, 873, 873, 873, 873, 873, 873, 873, 873, 873, + /* 20 */ 873, 873, 873, 1058, 893, 1149, 873, 873, 873, 873, + /* 30 */ 873, 873, 873, 1073, 873, 932, 873, 873, 873, 873, + /* 40 */ 942, 932, 942, 942, 873, 1053, 980, 998, 873, 873, + /* 50 */ 873, 873, 873, 873, 873, 873, 873, 873, 873, 873, + /* 60 */ 873, 873, 873, 873, 873, 873, 873, 873, 873, 873, + /* 70 */ 873, 873, 873, 873, 873, 873, 873, 1027, 873, 873, + /* 80 */ 873, 873, 873, 873, 1060, 1066, 1063, 873, 873, 873, + /* 90 */ 1068, 873, 873, 873, 1092, 1092, 1051, 873, 873, 873, + /* 100 */ 873, 873, 873, 873, 873, 873, 873, 873, 873, 873, + /* 110 */ 873, 873, 873, 873, 873, 873, 873, 873, 873, 873, + /* 120 */ 873, 873, 873, 873, 873, 873, 873, 873, 873, 873, + /* 130 */ 920, 873, 918, 873, 873, 873, 873, 873, 873, 873, + /* 140 */ 873, 873, 873, 873, 873, 873, 873, 873, 873, 873, + /* 150 */ 873, 873, 873, 873, 873, 895, 895, 895, 895, 873, + /* 160 */ 873, 873, 873, 895, 895, 1099, 1103, 1085, 1097, 1093, + /* 170 */ 1080, 1078, 1076, 1084, 1107, 1029, 895, 895, 895, 940, + /* 180 */ 940, 936, 932, 932, 895, 895, 958, 956, 954, 946, + /* 190 */ 952, 948, 950, 944, 923, 873, 895, 895, 930, 930, + /* 200 */ 895, 930, 895, 930, 895, 895, 980, 998, 873, 1108, + /* 210 */ 1098, 873, 1148, 1138, 1137, 873, 1144, 1136, 1135, 1134, + /* 220 */ 873, 873, 1130, 1133, 1132, 1131, 873, 873, 873, 1140, + /* 230 */ 1139, 873, 873, 873, 873, 873, 873, 873, 873, 873, + /* 240 */ 873, 1104, 1100, 873, 873, 873, 873, 873, 873, 873, + /* 250 */ 873, 873, 1110, 873, 873, 873, 873, 873, 873, 873, + /* 260 */ 873, 873, 1008, 873, 873, 873, 873, 873, 873, 873, + /* 270 */ 873, 873, 873, 873, 873, 1050, 873, 873, 873, 873, + /* 280 */ 873, 1062, 1061, 873, 873, 873, 873, 873, 873, 873, + /* 290 */ 873, 873, 873, 873, 1094, 873, 1086, 873, 873, 873, + /* 300 */ 1020, 873, 873, 873, 873, 873, 873, 873, 873, 873, + /* 310 */ 873, 873, 873, 873, 873, 873, 873, 873, 873, 873, + /* 320 */ 873, 873, 873, 873, 873, 873, 873, 873, 873, 873, + /* 330 */ 873, 873, 1167, 1162, 1163, 1160, 873, 873, 873, 1159, + /* 340 */ 1154, 1155, 873, 873, 873, 1152, 873, 873, 873, 873, + /* 350 */ 873, 873, 873, 873, 873, 873, 873, 873, 873, 873, + /* 360 */ 873, 964, 873, 902, 900, 873, 891, 873, }; /********** End of lemon-generated parsing tables *****************************/ @@ -635,6 +637,8 @@ static const YYCODETYPE yyFallback[] = { 0, /* UNSIGNED => nothing */ 0, /* TAGS => nothing */ 0, /* USING => nothing */ + 0, /* TO => nothing */ + 0, /* SPLIT => nothing */ 1, /* NULL => ID */ 1, /* NOW => ID */ 0, /* SELECT => nothing */ @@ -919,166 +923,171 @@ static const char *const yyTokenName[] = { /* 115 */ "UNSIGNED", /* 116 */ "TAGS", /* 117 */ "USING", - /* 118 */ "NULL", - /* 119 */ "NOW", - /* 120 */ "SELECT", - /* 121 */ "UNION", - /* 122 */ "ALL", - /* 123 */ "DISTINCT", - /* 124 */ "FROM", - /* 125 */ "VARIABLE", - /* 126 */ "INTERVAL", - /* 127 */ "EVERY", - /* 128 */ "SESSION", - /* 129 */ "STATE_WINDOW", - /* 130 */ "FILL", - /* 131 */ "SLIDING", - /* 132 */ "ORDER", - /* 133 */ "BY", - /* 134 */ "ASC", - /* 135 */ "GROUP", - /* 136 */ "HAVING", - /* 137 */ "LIMIT", - /* 138 */ "OFFSET", - /* 139 */ "SLIMIT", - /* 140 */ "SOFFSET", - /* 141 */ "WHERE", - /* 142 */ "RESET", - /* 143 */ "QUERY", - /* 144 */ "SYNCDB", - /* 145 */ "ADD", - /* 146 */ "COLUMN", - /* 147 */ "MODIFY", - /* 148 */ "TAG", - /* 149 */ "CHANGE", - /* 150 */ "SET", - /* 151 */ "KILL", - /* 152 */ "CONNECTION", - /* 153 */ "STREAM", - /* 154 */ "COLON", - /* 155 */ "ABORT", - /* 156 */ "AFTER", - /* 157 */ "ATTACH", - /* 158 */ "BEFORE", - /* 159 */ "BEGIN", - /* 160 */ "CASCADE", - /* 161 */ "CLUSTER", - /* 162 */ "CONFLICT", - /* 163 */ "COPY", - /* 164 */ "DEFERRED", - /* 165 */ "DELIMITERS", - /* 166 */ "DETACH", - /* 167 */ "EACH", - /* 168 */ "END", - /* 169 */ "EXPLAIN", - /* 170 */ "FAIL", - /* 171 */ "FOR", - /* 172 */ "IGNORE", - /* 173 */ "IMMEDIATE", - /* 174 */ "INITIALLY", - /* 175 */ "INSTEAD", - /* 176 */ "MATCH", - /* 177 */ "KEY", - /* 178 */ "OF", - /* 179 */ "RAISE", - /* 180 */ "REPLACE", - /* 181 */ "RESTRICT", - /* 182 */ "ROW", - /* 183 */ "STATEMENT", - /* 184 */ "TRIGGER", - /* 185 */ "VIEW", - /* 186 */ "SEMI", - /* 187 */ "NONE", - /* 188 */ "PREV", - /* 189 */ "LINEAR", - /* 190 */ "IMPORT", - /* 191 */ "TBNAME", - /* 192 */ "JOIN", - /* 193 */ "INSERT", - /* 194 */ "INTO", - /* 195 */ "VALUES", - /* 196 */ "FILE", - /* 197 */ "program", - /* 198 */ "cmd", - /* 199 */ "dbPrefix", - /* 200 */ "ids", - /* 201 */ "cpxName", - /* 202 */ "ifexists", - /* 203 */ "alter_db_optr", - /* 204 */ "alter_topic_optr", - /* 205 */ "acct_optr", - /* 206 */ "exprlist", - /* 207 */ "ifnotexists", - /* 208 */ "db_optr", - /* 209 */ "topic_optr", - /* 210 */ "typename", - /* 211 */ "bufsize", - /* 212 */ "pps", - /* 213 */ "tseries", - /* 214 */ "dbs", - /* 215 */ "streams", - /* 216 */ "storage", - /* 217 */ "qtime", - /* 218 */ "users", - /* 219 */ "conns", - /* 220 */ "state", - /* 221 */ "intitemlist", - /* 222 */ "intitem", - /* 223 */ "keep", - /* 224 */ "cache", - /* 225 */ "replica", - /* 226 */ "quorum", - /* 227 */ "days", - /* 228 */ "minrows", - /* 229 */ "maxrows", - /* 230 */ "blocks", - /* 231 */ "ctime", - /* 232 */ "wal", - /* 233 */ "fsync", - /* 234 */ "comp", - /* 235 */ "prec", - /* 236 */ "update", - /* 237 */ "cachelast", - /* 238 */ "partitions", - /* 239 */ "signed", - /* 240 */ "create_table_args", - /* 241 */ "create_stable_args", - /* 242 */ "create_table_list", - /* 243 */ "create_from_stable", - /* 244 */ "columnlist", - /* 245 */ "tagitemlist", - /* 246 */ "tagNamelist", - /* 247 */ "select", - /* 248 */ "column", - /* 249 */ "tagitem", - /* 250 */ "selcollist", - /* 251 */ "from", - /* 252 */ "where_opt", - /* 253 */ "interval_option", - /* 254 */ "sliding_opt", - /* 255 */ "session_option", - /* 256 */ "windowstate_option", - /* 257 */ "fill_opt", - /* 258 */ "groupby_opt", - /* 259 */ "having_opt", - /* 260 */ "orderby_opt", - /* 261 */ "slimit_opt", - /* 262 */ "limit_opt", - /* 263 */ "union", - /* 264 */ "sclp", - /* 265 */ "distinct", - /* 266 */ "expr", - /* 267 */ "as", - /* 268 */ "tablelist", - /* 269 */ "sub", - /* 270 */ "tmvar", - /* 271 */ "intervalKey", - /* 272 */ "sortlist", - /* 273 */ "sortitem", - /* 274 */ "item", - /* 275 */ "sortorder", - /* 276 */ "grouplist", - /* 277 */ "expritem", + /* 118 */ "TO", + /* 119 */ "SPLIT", + /* 120 */ "NULL", + /* 121 */ "NOW", + /* 122 */ "SELECT", + /* 123 */ "UNION", + /* 124 */ "ALL", + /* 125 */ "DISTINCT", + /* 126 */ "FROM", + /* 127 */ "VARIABLE", + /* 128 */ "INTERVAL", + /* 129 */ "EVERY", + /* 130 */ "SESSION", + /* 131 */ "STATE_WINDOW", + /* 132 */ "FILL", + /* 133 */ "SLIDING", + /* 134 */ "ORDER", + /* 135 */ "BY", + /* 136 */ "ASC", + /* 137 */ "GROUP", + /* 138 */ "HAVING", + /* 139 */ "LIMIT", + /* 140 */ "OFFSET", + /* 141 */ "SLIMIT", + /* 142 */ "SOFFSET", + /* 143 */ "WHERE", + /* 144 */ "RESET", + /* 145 */ "QUERY", + /* 146 */ "SYNCDB", + /* 147 */ "ADD", + /* 148 */ "COLUMN", + /* 149 */ "MODIFY", + /* 150 */ "TAG", + /* 151 */ "CHANGE", + /* 152 */ "SET", + /* 153 */ "KILL", + /* 154 */ "CONNECTION", + /* 155 */ "STREAM", + /* 156 */ "COLON", + /* 157 */ "ABORT", + /* 158 */ "AFTER", + /* 159 */ "ATTACH", + /* 160 */ "BEFORE", + /* 161 */ "BEGIN", + /* 162 */ "CASCADE", + /* 163 */ "CLUSTER", + /* 164 */ "CONFLICT", + /* 165 */ "COPY", + /* 166 */ "DEFERRED", + /* 167 */ "DELIMITERS", + /* 168 */ "DETACH", + /* 169 */ "EACH", + /* 170 */ "END", + /* 171 */ "EXPLAIN", + /* 172 */ "FAIL", + /* 173 */ "FOR", + /* 174 */ "IGNORE", + /* 175 */ "IMMEDIATE", + /* 176 */ "INITIALLY", + /* 177 */ "INSTEAD", + /* 178 */ "MATCH", + /* 179 */ "KEY", + /* 180 */ "OF", + /* 181 */ "RAISE", + /* 182 */ "REPLACE", + /* 183 */ "RESTRICT", + /* 184 */ "ROW", + /* 185 */ "STATEMENT", + /* 186 */ "TRIGGER", + /* 187 */ "VIEW", + /* 188 */ "SEMI", + /* 189 */ "NONE", + /* 190 */ "PREV", + /* 191 */ "LINEAR", + /* 192 */ "IMPORT", + /* 193 */ "TBNAME", + /* 194 */ "JOIN", + /* 195 */ "INSERT", + /* 196 */ "INTO", + /* 197 */ "VALUES", + /* 198 */ "FILE", + /* 199 */ "program", + /* 200 */ "cmd", + /* 201 */ "dbPrefix", + /* 202 */ "ids", + /* 203 */ "cpxName", + /* 204 */ "ifexists", + /* 205 */ "alter_db_optr", + /* 206 */ "alter_topic_optr", + /* 207 */ "acct_optr", + /* 208 */ "exprlist", + /* 209 */ "ifnotexists", + /* 210 */ "db_optr", + /* 211 */ "topic_optr", + /* 212 */ "typename", + /* 213 */ "bufsize", + /* 214 */ "pps", + /* 215 */ "tseries", + /* 216 */ "dbs", + /* 217 */ "streams", + /* 218 */ "storage", + /* 219 */ "qtime", + /* 220 */ "users", + /* 221 */ "conns", + /* 222 */ "state", + /* 223 */ "intitemlist", + /* 224 */ "intitem", + /* 225 */ "keep", + /* 226 */ "cache", + /* 227 */ "replica", + /* 228 */ "quorum", + /* 229 */ "days", + /* 230 */ "minrows", + /* 231 */ "maxrows", + /* 232 */ "blocks", + /* 233 */ "ctime", + /* 234 */ "wal", + /* 235 */ "fsync", + /* 236 */ "comp", + /* 237 */ "prec", + /* 238 */ "update", + /* 239 */ "cachelast", + /* 240 */ "partitions", + /* 241 */ "signed", + /* 242 */ "create_table_args", + /* 243 */ "create_stable_args", + /* 244 */ "create_table_list", + /* 245 */ "create_from_stable", + /* 246 */ "columnlist", + /* 247 */ "tagitemlist", + /* 248 */ "tagNamelist", + /* 249 */ "to_opt", + /* 250 */ "split_opt", + /* 251 */ "select", + /* 252 */ "to_split", + /* 253 */ "column", + /* 254 */ "tagitem", + /* 255 */ "selcollist", + /* 256 */ "from", + /* 257 */ "where_opt", + /* 258 */ "interval_option", + /* 259 */ "sliding_opt", + /* 260 */ "session_option", + /* 261 */ "windowstate_option", + /* 262 */ "fill_opt", + /* 263 */ "groupby_opt", + /* 264 */ "having_opt", + /* 265 */ "orderby_opt", + /* 266 */ "slimit_opt", + /* 267 */ "limit_opt", + /* 268 */ "union", + /* 269 */ "sclp", + /* 270 */ "distinct", + /* 271 */ "expr", + /* 272 */ "as", + /* 273 */ "tablelist", + /* 274 */ "sub", + /* 275 */ "tmvar", + /* 276 */ "intervalKey", + /* 277 */ "sortlist", + /* 278 */ "sortitem", + /* 279 */ "item", + /* 280 */ "sortorder", + /* 281 */ "grouplist", + /* 282 */ "expritem", }; #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */ @@ -1236,147 +1245,151 @@ static const char *const yyRuleName[] = { /* 147 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP", /* 148 */ "tagNamelist ::= tagNamelist COMMA ids", /* 149 */ "tagNamelist ::= ids", - /* 150 */ "create_table_args ::= ifnotexists ids cpxName AS select", - /* 151 */ "columnlist ::= columnlist COMMA column", - /* 152 */ "columnlist ::= column", - /* 153 */ "column ::= ids typename", - /* 154 */ "tagitemlist ::= tagitemlist COMMA tagitem", - /* 155 */ "tagitemlist ::= tagitem", - /* 156 */ "tagitem ::= INTEGER", - /* 157 */ "tagitem ::= FLOAT", - /* 158 */ "tagitem ::= STRING", - /* 159 */ "tagitem ::= BOOL", - /* 160 */ "tagitem ::= NULL", - /* 161 */ "tagitem ::= NOW", - /* 162 */ "tagitem ::= MINUS INTEGER", - /* 163 */ "tagitem ::= MINUS FLOAT", - /* 164 */ "tagitem ::= PLUS INTEGER", - /* 165 */ "tagitem ::= PLUS FLOAT", - /* 166 */ "select ::= SELECT selcollist from where_opt interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt", - /* 167 */ "select ::= LP select RP", - /* 168 */ "union ::= select", - /* 169 */ "union ::= union UNION ALL select", - /* 170 */ "cmd ::= union", - /* 171 */ "select ::= SELECT selcollist", - /* 172 */ "sclp ::= selcollist COMMA", - /* 173 */ "sclp ::=", - /* 174 */ "selcollist ::= sclp distinct expr as", - /* 175 */ "selcollist ::= sclp STAR", - /* 176 */ "as ::= AS ids", - /* 177 */ "as ::= ids", - /* 178 */ "as ::=", - /* 179 */ "distinct ::= DISTINCT", - /* 180 */ "distinct ::=", - /* 181 */ "from ::= FROM tablelist", - /* 182 */ "from ::= FROM sub", - /* 183 */ "sub ::= LP union RP", - /* 184 */ "sub ::= LP union RP ids", - /* 185 */ "sub ::= sub COMMA LP union RP ids", - /* 186 */ "tablelist ::= ids cpxName", - /* 187 */ "tablelist ::= ids cpxName ids", - /* 188 */ "tablelist ::= tablelist COMMA ids cpxName", - /* 189 */ "tablelist ::= tablelist COMMA ids cpxName ids", - /* 190 */ "tmvar ::= VARIABLE", - /* 191 */ "interval_option ::= intervalKey LP tmvar RP", - /* 192 */ "interval_option ::= intervalKey LP tmvar COMMA tmvar RP", - /* 193 */ "interval_option ::=", - /* 194 */ "intervalKey ::= INTERVAL", - /* 195 */ "intervalKey ::= EVERY", - /* 196 */ "session_option ::=", - /* 197 */ "session_option ::= SESSION LP ids cpxName COMMA tmvar RP", - /* 198 */ "windowstate_option ::=", - /* 199 */ "windowstate_option ::= STATE_WINDOW LP ids RP", - /* 200 */ "fill_opt ::=", - /* 201 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP", - /* 202 */ "fill_opt ::= FILL LP ID RP", - /* 203 */ "sliding_opt ::= SLIDING LP tmvar RP", - /* 204 */ "sliding_opt ::=", - /* 205 */ "orderby_opt ::=", - /* 206 */ "orderby_opt ::= ORDER BY sortlist", - /* 207 */ "sortlist ::= sortlist COMMA item sortorder", - /* 208 */ "sortlist ::= item sortorder", - /* 209 */ "item ::= ids cpxName", - /* 210 */ "sortorder ::= ASC", - /* 211 */ "sortorder ::= DESC", - /* 212 */ "sortorder ::=", - /* 213 */ "groupby_opt ::=", - /* 214 */ "groupby_opt ::= GROUP BY grouplist", - /* 215 */ "grouplist ::= grouplist COMMA item", - /* 216 */ "grouplist ::= item", - /* 217 */ "having_opt ::=", - /* 218 */ "having_opt ::= HAVING expr", - /* 219 */ "limit_opt ::=", - /* 220 */ "limit_opt ::= LIMIT signed", - /* 221 */ "limit_opt ::= LIMIT signed OFFSET signed", - /* 222 */ "limit_opt ::= LIMIT signed COMMA signed", - /* 223 */ "slimit_opt ::=", - /* 224 */ "slimit_opt ::= SLIMIT signed", - /* 225 */ "slimit_opt ::= SLIMIT signed SOFFSET signed", - /* 226 */ "slimit_opt ::= SLIMIT signed COMMA signed", - /* 227 */ "where_opt ::=", - /* 228 */ "where_opt ::= WHERE expr", - /* 229 */ "expr ::= LP expr RP", - /* 230 */ "expr ::= ID", - /* 231 */ "expr ::= ID DOT ID", - /* 232 */ "expr ::= ID DOT STAR", - /* 233 */ "expr ::= INTEGER", - /* 234 */ "expr ::= MINUS INTEGER", - /* 235 */ "expr ::= PLUS INTEGER", - /* 236 */ "expr ::= FLOAT", - /* 237 */ "expr ::= MINUS FLOAT", - /* 238 */ "expr ::= PLUS FLOAT", - /* 239 */ "expr ::= STRING", - /* 240 */ "expr ::= NOW", - /* 241 */ "expr ::= VARIABLE", - /* 242 */ "expr ::= PLUS VARIABLE", - /* 243 */ "expr ::= MINUS VARIABLE", - /* 244 */ "expr ::= BOOL", - /* 245 */ "expr ::= NULL", - /* 246 */ "expr ::= ID LP exprlist RP", - /* 247 */ "expr ::= ID LP STAR RP", - /* 248 */ "expr ::= expr IS NULL", - /* 249 */ "expr ::= expr IS NOT NULL", - /* 250 */ "expr ::= expr LT expr", - /* 251 */ "expr ::= expr GT expr", - /* 252 */ "expr ::= expr LE expr", - /* 253 */ "expr ::= expr GE expr", - /* 254 */ "expr ::= expr NE expr", - /* 255 */ "expr ::= expr EQ expr", - /* 256 */ "expr ::= expr BETWEEN expr AND expr", - /* 257 */ "expr ::= expr AND expr", - /* 258 */ "expr ::= expr OR expr", - /* 259 */ "expr ::= expr PLUS expr", - /* 260 */ "expr ::= expr MINUS expr", - /* 261 */ "expr ::= expr STAR expr", - /* 262 */ "expr ::= expr SLASH expr", - /* 263 */ "expr ::= expr REM expr", - /* 264 */ "expr ::= expr LIKE expr", - /* 265 */ "expr ::= expr IN LP exprlist RP", - /* 266 */ "exprlist ::= exprlist COMMA expritem", - /* 267 */ "exprlist ::= expritem", - /* 268 */ "expritem ::= expr", - /* 269 */ "expritem ::=", - /* 270 */ "cmd ::= RESET QUERY CACHE", - /* 271 */ "cmd ::= SYNCDB ids REPLICA", - /* 272 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist", - /* 273 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids", - /* 274 */ "cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist", - /* 275 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist", - /* 276 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids", - /* 277 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids", - /* 278 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem", - /* 279 */ "cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist", - /* 280 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist", - /* 281 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids", - /* 282 */ "cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist", - /* 283 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist", - /* 284 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids", - /* 285 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids", - /* 286 */ "cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem", - /* 287 */ "cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist", - /* 288 */ "cmd ::= KILL CONNECTION INTEGER", - /* 289 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER", - /* 290 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER", + /* 150 */ "create_table_args ::= ifnotexists ids cpxName to_opt split_opt AS select", + /* 151 */ "to_opt ::=", + /* 152 */ "to_opt ::= TO ids cpxName", + /* 153 */ "split_opt ::=", + /* 154 */ "split_opt ::= SPLIT ids", + /* 155 */ "columnlist ::= columnlist COMMA column", + /* 156 */ "columnlist ::= column", + /* 157 */ "column ::= ids typename", + /* 158 */ "tagitemlist ::= tagitemlist COMMA tagitem", + /* 159 */ "tagitemlist ::= tagitem", + /* 160 */ "tagitem ::= INTEGER", + /* 161 */ "tagitem ::= FLOAT", + /* 162 */ "tagitem ::= STRING", + /* 163 */ "tagitem ::= BOOL", + /* 164 */ "tagitem ::= NULL", + /* 165 */ "tagitem ::= NOW", + /* 166 */ "tagitem ::= MINUS INTEGER", + /* 167 */ "tagitem ::= MINUS FLOAT", + /* 168 */ "tagitem ::= PLUS INTEGER", + /* 169 */ "tagitem ::= PLUS FLOAT", + /* 170 */ "select ::= SELECT selcollist from where_opt interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt", + /* 171 */ "select ::= LP select RP", + /* 172 */ "union ::= select", + /* 173 */ "union ::= union UNION ALL select", + /* 174 */ "cmd ::= union", + /* 175 */ "select ::= SELECT selcollist", + /* 176 */ "sclp ::= selcollist COMMA", + /* 177 */ "sclp ::=", + /* 178 */ "selcollist ::= sclp distinct expr as", + /* 179 */ "selcollist ::= sclp STAR", + /* 180 */ "as ::= AS ids", + /* 181 */ "as ::= ids", + /* 182 */ "as ::=", + /* 183 */ "distinct ::= DISTINCT", + /* 184 */ "distinct ::=", + /* 185 */ "from ::= FROM tablelist", + /* 186 */ "from ::= FROM sub", + /* 187 */ "sub ::= LP union RP", + /* 188 */ "sub ::= LP union RP ids", + /* 189 */ "sub ::= sub COMMA LP union RP ids", + /* 190 */ "tablelist ::= ids cpxName", + /* 191 */ "tablelist ::= ids cpxName ids", + /* 192 */ "tablelist ::= tablelist COMMA ids cpxName", + /* 193 */ "tablelist ::= tablelist COMMA ids cpxName ids", + /* 194 */ "tmvar ::= VARIABLE", + /* 195 */ "interval_option ::= intervalKey LP tmvar RP", + /* 196 */ "interval_option ::= intervalKey LP tmvar COMMA tmvar RP", + /* 197 */ "interval_option ::=", + /* 198 */ "intervalKey ::= INTERVAL", + /* 199 */ "intervalKey ::= EVERY", + /* 200 */ "session_option ::=", + /* 201 */ "session_option ::= SESSION LP ids cpxName COMMA tmvar RP", + /* 202 */ "windowstate_option ::=", + /* 203 */ "windowstate_option ::= STATE_WINDOW LP ids RP", + /* 204 */ "fill_opt ::=", + /* 205 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP", + /* 206 */ "fill_opt ::= FILL LP ID RP", + /* 207 */ "sliding_opt ::= SLIDING LP tmvar RP", + /* 208 */ "sliding_opt ::=", + /* 209 */ "orderby_opt ::=", + /* 210 */ "orderby_opt ::= ORDER BY sortlist", + /* 211 */ "sortlist ::= sortlist COMMA item sortorder", + /* 212 */ "sortlist ::= item sortorder", + /* 213 */ "item ::= ids cpxName", + /* 214 */ "sortorder ::= ASC", + /* 215 */ "sortorder ::= DESC", + /* 216 */ "sortorder ::=", + /* 217 */ "groupby_opt ::=", + /* 218 */ "groupby_opt ::= GROUP BY grouplist", + /* 219 */ "grouplist ::= grouplist COMMA item", + /* 220 */ "grouplist ::= item", + /* 221 */ "having_opt ::=", + /* 222 */ "having_opt ::= HAVING expr", + /* 223 */ "limit_opt ::=", + /* 224 */ "limit_opt ::= LIMIT signed", + /* 225 */ "limit_opt ::= LIMIT signed OFFSET signed", + /* 226 */ "limit_opt ::= LIMIT signed COMMA signed", + /* 227 */ "slimit_opt ::=", + /* 228 */ "slimit_opt ::= SLIMIT signed", + /* 229 */ "slimit_opt ::= SLIMIT signed SOFFSET signed", + /* 230 */ "slimit_opt ::= SLIMIT signed COMMA signed", + /* 231 */ "where_opt ::=", + /* 232 */ "where_opt ::= WHERE expr", + /* 233 */ "expr ::= LP expr RP", + /* 234 */ "expr ::= ID", + /* 235 */ "expr ::= ID DOT ID", + /* 236 */ "expr ::= ID DOT STAR", + /* 237 */ "expr ::= INTEGER", + /* 238 */ "expr ::= MINUS INTEGER", + /* 239 */ "expr ::= PLUS INTEGER", + /* 240 */ "expr ::= FLOAT", + /* 241 */ "expr ::= MINUS FLOAT", + /* 242 */ "expr ::= PLUS FLOAT", + /* 243 */ "expr ::= STRING", + /* 244 */ "expr ::= NOW", + /* 245 */ "expr ::= VARIABLE", + /* 246 */ "expr ::= PLUS VARIABLE", + /* 247 */ "expr ::= MINUS VARIABLE", + /* 248 */ "expr ::= BOOL", + /* 249 */ "expr ::= NULL", + /* 250 */ "expr ::= ID LP exprlist RP", + /* 251 */ "expr ::= ID LP STAR RP", + /* 252 */ "expr ::= expr IS NULL", + /* 253 */ "expr ::= expr IS NOT NULL", + /* 254 */ "expr ::= expr LT expr", + /* 255 */ "expr ::= expr GT expr", + /* 256 */ "expr ::= expr LE expr", + /* 257 */ "expr ::= expr GE expr", + /* 258 */ "expr ::= expr NE expr", + /* 259 */ "expr ::= expr EQ expr", + /* 260 */ "expr ::= expr BETWEEN expr AND expr", + /* 261 */ "expr ::= expr AND expr", + /* 262 */ "expr ::= expr OR expr", + /* 263 */ "expr ::= expr PLUS expr", + /* 264 */ "expr ::= expr MINUS expr", + /* 265 */ "expr ::= expr STAR expr", + /* 266 */ "expr ::= expr SLASH expr", + /* 267 */ "expr ::= expr REM expr", + /* 268 */ "expr ::= expr LIKE expr", + /* 269 */ "expr ::= expr IN LP exprlist RP", + /* 270 */ "exprlist ::= exprlist COMMA expritem", + /* 271 */ "exprlist ::= expritem", + /* 272 */ "expritem ::= expr", + /* 273 */ "expritem ::=", + /* 274 */ "cmd ::= RESET QUERY CACHE", + /* 275 */ "cmd ::= SYNCDB ids REPLICA", + /* 276 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist", + /* 277 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids", + /* 278 */ "cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist", + /* 279 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist", + /* 280 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids", + /* 281 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids", + /* 282 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem", + /* 283 */ "cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist", + /* 284 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist", + /* 285 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids", + /* 286 */ "cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist", + /* 287 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist", + /* 288 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids", + /* 289 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids", + /* 290 */ "cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem", + /* 291 */ "cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist", + /* 292 */ "cmd ::= KILL CONNECTION INTEGER", + /* 293 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER", + /* 294 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER", }; #endif /* NDEBUG */ @@ -1502,60 +1515,60 @@ static void yy_destructor( ** inside the C code. */ /********* Begin destructor definitions ***************************************/ - case 206: /* exprlist */ - case 250: /* selcollist */ - case 264: /* sclp */ + case 208: /* exprlist */ + case 255: /* selcollist */ + case 269: /* sclp */ { -tSqlExprListDestroy((yypminor->yy421)); +tSqlExprListDestroy((yypminor->yy89)); } break; - case 221: /* intitemlist */ - case 223: /* keep */ - case 244: /* columnlist */ - case 245: /* tagitemlist */ - case 246: /* tagNamelist */ - case 257: /* fill_opt */ - case 258: /* groupby_opt */ - case 260: /* orderby_opt */ - case 272: /* sortlist */ - case 276: /* grouplist */ -{ -taosArrayDestroy((yypminor->yy421)); + case 223: /* intitemlist */ + case 225: /* keep */ + case 246: /* columnlist */ + case 247: /* tagitemlist */ + case 248: /* tagNamelist */ + case 262: /* fill_opt */ + case 263: /* groupby_opt */ + case 265: /* orderby_opt */ + case 277: /* sortlist */ + case 281: /* grouplist */ +{ +taosArrayDestroy((yypminor->yy89)); } break; - case 242: /* create_table_list */ + case 244: /* create_table_list */ { -destroyCreateTableSql((yypminor->yy438)); +destroyCreateTableSql((yypminor->yy86)); } break; - case 247: /* select */ + case 251: /* select */ { -destroySqlNode((yypminor->yy56)); +destroySqlNode((yypminor->yy378)); } break; - case 251: /* from */ - case 268: /* tablelist */ - case 269: /* sub */ + case 256: /* from */ + case 273: /* tablelist */ + case 274: /* sub */ { -destroyRelationInfo((yypminor->yy8)); +destroyRelationInfo((yypminor->yy166)); } break; - case 252: /* where_opt */ - case 259: /* having_opt */ - case 266: /* expr */ - case 277: /* expritem */ + case 257: /* where_opt */ + case 264: /* having_opt */ + case 271: /* expr */ + case 282: /* expritem */ { -tSqlExprDestroy((yypminor->yy439)); +tSqlExprDestroy((yypminor->yy342)); } break; - case 263: /* union */ + case 268: /* union */ { -destroyAllSqlNode((yypminor->yy421)); +destroyAllSqlNode((yypminor->yy89)); } break; - case 273: /* sortitem */ + case 278: /* sortitem */ { -tVariantDestroy(&(yypminor->yy430)); +tVariantDestroy(&(yypminor->yy112)); } break; /********* End destructor definitions *****************************************/ @@ -1852,297 +1865,301 @@ static const struct { YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */ signed char nrhs; /* Negative of the number of RHS symbols in the rule */ } yyRuleInfo[] = { - { 197, -1 }, /* (0) program ::= cmd */ - { 198, -2 }, /* (1) cmd ::= SHOW DATABASES */ - { 198, -2 }, /* (2) cmd ::= SHOW TOPICS */ - { 198, -2 }, /* (3) cmd ::= SHOW FUNCTIONS */ - { 198, -2 }, /* (4) cmd ::= SHOW MNODES */ - { 198, -2 }, /* (5) cmd ::= SHOW DNODES */ - { 198, -2 }, /* (6) cmd ::= SHOW ACCOUNTS */ - { 198, -2 }, /* (7) cmd ::= SHOW USERS */ - { 198, -2 }, /* (8) cmd ::= SHOW MODULES */ - { 198, -2 }, /* (9) cmd ::= SHOW QUERIES */ - { 198, -2 }, /* (10) cmd ::= SHOW CONNECTIONS */ - { 198, -2 }, /* (11) cmd ::= SHOW STREAMS */ - { 198, -2 }, /* (12) cmd ::= SHOW VARIABLES */ - { 198, -2 }, /* (13) cmd ::= SHOW SCORES */ - { 198, -2 }, /* (14) cmd ::= SHOW GRANTS */ - { 198, -2 }, /* (15) cmd ::= SHOW VNODES */ - { 198, -3 }, /* (16) cmd ::= SHOW VNODES IPTOKEN */ - { 199, 0 }, /* (17) dbPrefix ::= */ - { 199, -2 }, /* (18) dbPrefix ::= ids DOT */ - { 201, 0 }, /* (19) cpxName ::= */ - { 201, -2 }, /* (20) cpxName ::= DOT ids */ - { 198, -5 }, /* (21) cmd ::= SHOW CREATE TABLE ids cpxName */ - { 198, -5 }, /* (22) cmd ::= SHOW CREATE STABLE ids cpxName */ - { 198, -4 }, /* (23) cmd ::= SHOW CREATE DATABASE ids */ - { 198, -3 }, /* (24) cmd ::= SHOW dbPrefix TABLES */ - { 198, -5 }, /* (25) cmd ::= SHOW dbPrefix TABLES LIKE ids */ - { 198, -3 }, /* (26) cmd ::= SHOW dbPrefix STABLES */ - { 198, -5 }, /* (27) cmd ::= SHOW dbPrefix STABLES LIKE ids */ - { 198, -3 }, /* (28) cmd ::= SHOW dbPrefix VGROUPS */ - { 198, -5 }, /* (29) cmd ::= DROP TABLE ifexists ids cpxName */ - { 198, -5 }, /* (30) cmd ::= DROP STABLE ifexists ids cpxName */ - { 198, -4 }, /* (31) cmd ::= DROP DATABASE ifexists ids */ - { 198, -4 }, /* (32) cmd ::= DROP TOPIC ifexists ids */ - { 198, -3 }, /* (33) cmd ::= DROP FUNCTION ids */ - { 198, -3 }, /* (34) cmd ::= DROP DNODE ids */ - { 198, -3 }, /* (35) cmd ::= DROP USER ids */ - { 198, -3 }, /* (36) cmd ::= DROP ACCOUNT ids */ - { 198, -2 }, /* (37) cmd ::= USE ids */ - { 198, -3 }, /* (38) cmd ::= DESCRIBE ids cpxName */ - { 198, -3 }, /* (39) cmd ::= DESC ids cpxName */ - { 198, -5 }, /* (40) cmd ::= ALTER USER ids PASS ids */ - { 198, -5 }, /* (41) cmd ::= ALTER USER ids PRIVILEGE ids */ - { 198, -4 }, /* (42) cmd ::= ALTER DNODE ids ids */ - { 198, -5 }, /* (43) cmd ::= ALTER DNODE ids ids ids */ - { 198, -3 }, /* (44) cmd ::= ALTER LOCAL ids */ - { 198, -4 }, /* (45) cmd ::= ALTER LOCAL ids ids */ - { 198, -4 }, /* (46) cmd ::= ALTER DATABASE ids alter_db_optr */ - { 198, -4 }, /* (47) cmd ::= ALTER TOPIC ids alter_topic_optr */ - { 198, -4 }, /* (48) cmd ::= ALTER ACCOUNT ids acct_optr */ - { 198, -6 }, /* (49) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */ - { 198, -6 }, /* (50) cmd ::= COMPACT VNODES IN LP exprlist RP */ - { 200, -1 }, /* (51) ids ::= ID */ - { 200, -1 }, /* (52) ids ::= STRING */ - { 202, -2 }, /* (53) ifexists ::= IF EXISTS */ - { 202, 0 }, /* (54) ifexists ::= */ - { 207, -3 }, /* (55) ifnotexists ::= IF NOT EXISTS */ - { 207, 0 }, /* (56) ifnotexists ::= */ - { 198, -3 }, /* (57) cmd ::= CREATE DNODE ids */ - { 198, -6 }, /* (58) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */ - { 198, -5 }, /* (59) cmd ::= CREATE DATABASE ifnotexists ids db_optr */ - { 198, -5 }, /* (60) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ - { 198, -8 }, /* (61) cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */ - { 198, -9 }, /* (62) cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */ - { 198, -5 }, /* (63) cmd ::= CREATE USER ids PASS ids */ - { 211, 0 }, /* (64) bufsize ::= */ - { 211, -2 }, /* (65) bufsize ::= BUFSIZE INTEGER */ - { 212, 0 }, /* (66) pps ::= */ - { 212, -2 }, /* (67) pps ::= PPS INTEGER */ - { 213, 0 }, /* (68) tseries ::= */ - { 213, -2 }, /* (69) tseries ::= TSERIES INTEGER */ - { 214, 0 }, /* (70) dbs ::= */ - { 214, -2 }, /* (71) dbs ::= DBS INTEGER */ - { 215, 0 }, /* (72) streams ::= */ - { 215, -2 }, /* (73) streams ::= STREAMS INTEGER */ - { 216, 0 }, /* (74) storage ::= */ - { 216, -2 }, /* (75) storage ::= STORAGE INTEGER */ - { 217, 0 }, /* (76) qtime ::= */ - { 217, -2 }, /* (77) qtime ::= QTIME INTEGER */ - { 218, 0 }, /* (78) users ::= */ - { 218, -2 }, /* (79) users ::= USERS INTEGER */ - { 219, 0 }, /* (80) conns ::= */ - { 219, -2 }, /* (81) conns ::= CONNS INTEGER */ - { 220, 0 }, /* (82) state ::= */ - { 220, -2 }, /* (83) state ::= STATE ids */ - { 205, -9 }, /* (84) acct_optr ::= pps tseries storage streams qtime dbs users conns state */ - { 221, -3 }, /* (85) intitemlist ::= intitemlist COMMA intitem */ - { 221, -1 }, /* (86) intitemlist ::= intitem */ - { 222, -1 }, /* (87) intitem ::= INTEGER */ - { 223, -2 }, /* (88) keep ::= KEEP intitemlist */ - { 224, -2 }, /* (89) cache ::= CACHE INTEGER */ - { 225, -2 }, /* (90) replica ::= REPLICA INTEGER */ - { 226, -2 }, /* (91) quorum ::= QUORUM INTEGER */ - { 227, -2 }, /* (92) days ::= DAYS INTEGER */ - { 228, -2 }, /* (93) minrows ::= MINROWS INTEGER */ - { 229, -2 }, /* (94) maxrows ::= MAXROWS INTEGER */ - { 230, -2 }, /* (95) blocks ::= BLOCKS INTEGER */ - { 231, -2 }, /* (96) ctime ::= CTIME INTEGER */ - { 232, -2 }, /* (97) wal ::= WAL INTEGER */ - { 233, -2 }, /* (98) fsync ::= FSYNC INTEGER */ - { 234, -2 }, /* (99) comp ::= COMP INTEGER */ - { 235, -2 }, /* (100) prec ::= PRECISION STRING */ - { 236, -2 }, /* (101) update ::= UPDATE INTEGER */ - { 237, -2 }, /* (102) cachelast ::= CACHELAST INTEGER */ - { 238, -2 }, /* (103) partitions ::= PARTITIONS INTEGER */ - { 208, 0 }, /* (104) db_optr ::= */ - { 208, -2 }, /* (105) db_optr ::= db_optr cache */ - { 208, -2 }, /* (106) db_optr ::= db_optr replica */ - { 208, -2 }, /* (107) db_optr ::= db_optr quorum */ - { 208, -2 }, /* (108) db_optr ::= db_optr days */ - { 208, -2 }, /* (109) db_optr ::= db_optr minrows */ - { 208, -2 }, /* (110) db_optr ::= db_optr maxrows */ - { 208, -2 }, /* (111) db_optr ::= db_optr blocks */ - { 208, -2 }, /* (112) db_optr ::= db_optr ctime */ - { 208, -2 }, /* (113) db_optr ::= db_optr wal */ - { 208, -2 }, /* (114) db_optr ::= db_optr fsync */ - { 208, -2 }, /* (115) db_optr ::= db_optr comp */ - { 208, -2 }, /* (116) db_optr ::= db_optr prec */ - { 208, -2 }, /* (117) db_optr ::= db_optr keep */ - { 208, -2 }, /* (118) db_optr ::= db_optr update */ - { 208, -2 }, /* (119) db_optr ::= db_optr cachelast */ - { 209, -1 }, /* (120) topic_optr ::= db_optr */ - { 209, -2 }, /* (121) topic_optr ::= topic_optr partitions */ - { 203, 0 }, /* (122) alter_db_optr ::= */ - { 203, -2 }, /* (123) alter_db_optr ::= alter_db_optr replica */ - { 203, -2 }, /* (124) alter_db_optr ::= alter_db_optr quorum */ - { 203, -2 }, /* (125) alter_db_optr ::= alter_db_optr keep */ - { 203, -2 }, /* (126) alter_db_optr ::= alter_db_optr blocks */ - { 203, -2 }, /* (127) alter_db_optr ::= alter_db_optr comp */ - { 203, -2 }, /* (128) alter_db_optr ::= alter_db_optr update */ - { 203, -2 }, /* (129) alter_db_optr ::= alter_db_optr cachelast */ - { 204, -1 }, /* (130) alter_topic_optr ::= alter_db_optr */ - { 204, -2 }, /* (131) alter_topic_optr ::= alter_topic_optr partitions */ - { 210, -1 }, /* (132) typename ::= ids */ - { 210, -4 }, /* (133) typename ::= ids LP signed RP */ - { 210, -2 }, /* (134) typename ::= ids UNSIGNED */ - { 239, -1 }, /* (135) signed ::= INTEGER */ - { 239, -2 }, /* (136) signed ::= PLUS INTEGER */ - { 239, -2 }, /* (137) signed ::= MINUS INTEGER */ - { 198, -3 }, /* (138) cmd ::= CREATE TABLE create_table_args */ - { 198, -3 }, /* (139) cmd ::= CREATE TABLE create_stable_args */ - { 198, -3 }, /* (140) cmd ::= CREATE STABLE create_stable_args */ - { 198, -3 }, /* (141) cmd ::= CREATE TABLE create_table_list */ - { 242, -1 }, /* (142) create_table_list ::= create_from_stable */ - { 242, -2 }, /* (143) create_table_list ::= create_table_list create_from_stable */ - { 240, -6 }, /* (144) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */ - { 241, -10 }, /* (145) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */ - { 243, -10 }, /* (146) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */ - { 243, -13 }, /* (147) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */ - { 246, -3 }, /* (148) tagNamelist ::= tagNamelist COMMA ids */ - { 246, -1 }, /* (149) tagNamelist ::= ids */ - { 240, -5 }, /* (150) create_table_args ::= ifnotexists ids cpxName AS select */ - { 244, -3 }, /* (151) columnlist ::= columnlist COMMA column */ - { 244, -1 }, /* (152) columnlist ::= column */ - { 248, -2 }, /* (153) column ::= ids typename */ - { 245, -3 }, /* (154) tagitemlist ::= tagitemlist COMMA tagitem */ - { 245, -1 }, /* (155) tagitemlist ::= tagitem */ - { 249, -1 }, /* (156) tagitem ::= INTEGER */ - { 249, -1 }, /* (157) tagitem ::= FLOAT */ - { 249, -1 }, /* (158) tagitem ::= STRING */ - { 249, -1 }, /* (159) tagitem ::= BOOL */ - { 249, -1 }, /* (160) tagitem ::= NULL */ - { 249, -1 }, /* (161) tagitem ::= NOW */ - { 249, -2 }, /* (162) tagitem ::= MINUS INTEGER */ - { 249, -2 }, /* (163) tagitem ::= MINUS FLOAT */ - { 249, -2 }, /* (164) tagitem ::= PLUS INTEGER */ - { 249, -2 }, /* (165) tagitem ::= PLUS FLOAT */ - { 247, -14 }, /* (166) select ::= SELECT selcollist from where_opt interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */ - { 247, -3 }, /* (167) select ::= LP select RP */ - { 263, -1 }, /* (168) union ::= select */ - { 263, -4 }, /* (169) union ::= union UNION ALL select */ - { 198, -1 }, /* (170) cmd ::= union */ - { 247, -2 }, /* (171) select ::= SELECT selcollist */ - { 264, -2 }, /* (172) sclp ::= selcollist COMMA */ - { 264, 0 }, /* (173) sclp ::= */ - { 250, -4 }, /* (174) selcollist ::= sclp distinct expr as */ - { 250, -2 }, /* (175) selcollist ::= sclp STAR */ - { 267, -2 }, /* (176) as ::= AS ids */ - { 267, -1 }, /* (177) as ::= ids */ - { 267, 0 }, /* (178) as ::= */ - { 265, -1 }, /* (179) distinct ::= DISTINCT */ - { 265, 0 }, /* (180) distinct ::= */ - { 251, -2 }, /* (181) from ::= FROM tablelist */ - { 251, -2 }, /* (182) from ::= FROM sub */ - { 269, -3 }, /* (183) sub ::= LP union RP */ - { 269, -4 }, /* (184) sub ::= LP union RP ids */ - { 269, -6 }, /* (185) sub ::= sub COMMA LP union RP ids */ - { 268, -2 }, /* (186) tablelist ::= ids cpxName */ - { 268, -3 }, /* (187) tablelist ::= ids cpxName ids */ - { 268, -4 }, /* (188) tablelist ::= tablelist COMMA ids cpxName */ - { 268, -5 }, /* (189) tablelist ::= tablelist COMMA ids cpxName ids */ - { 270, -1 }, /* (190) tmvar ::= VARIABLE */ - { 253, -4 }, /* (191) interval_option ::= intervalKey LP tmvar RP */ - { 253, -6 }, /* (192) interval_option ::= intervalKey LP tmvar COMMA tmvar RP */ - { 253, 0 }, /* (193) interval_option ::= */ - { 271, -1 }, /* (194) intervalKey ::= INTERVAL */ - { 271, -1 }, /* (195) intervalKey ::= EVERY */ - { 255, 0 }, /* (196) session_option ::= */ - { 255, -7 }, /* (197) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */ - { 256, 0 }, /* (198) windowstate_option ::= */ - { 256, -4 }, /* (199) windowstate_option ::= STATE_WINDOW LP ids RP */ - { 257, 0 }, /* (200) fill_opt ::= */ - { 257, -6 }, /* (201) fill_opt ::= FILL LP ID COMMA tagitemlist RP */ - { 257, -4 }, /* (202) fill_opt ::= FILL LP ID RP */ - { 254, -4 }, /* (203) sliding_opt ::= SLIDING LP tmvar RP */ - { 254, 0 }, /* (204) sliding_opt ::= */ - { 260, 0 }, /* (205) orderby_opt ::= */ - { 260, -3 }, /* (206) orderby_opt ::= ORDER BY sortlist */ - { 272, -4 }, /* (207) sortlist ::= sortlist COMMA item sortorder */ - { 272, -2 }, /* (208) sortlist ::= item sortorder */ - { 274, -2 }, /* (209) item ::= ids cpxName */ - { 275, -1 }, /* (210) sortorder ::= ASC */ - { 275, -1 }, /* (211) sortorder ::= DESC */ - { 275, 0 }, /* (212) sortorder ::= */ - { 258, 0 }, /* (213) groupby_opt ::= */ - { 258, -3 }, /* (214) groupby_opt ::= GROUP BY grouplist */ - { 276, -3 }, /* (215) grouplist ::= grouplist COMMA item */ - { 276, -1 }, /* (216) grouplist ::= item */ - { 259, 0 }, /* (217) having_opt ::= */ - { 259, -2 }, /* (218) having_opt ::= HAVING expr */ - { 262, 0 }, /* (219) limit_opt ::= */ - { 262, -2 }, /* (220) limit_opt ::= LIMIT signed */ - { 262, -4 }, /* (221) limit_opt ::= LIMIT signed OFFSET signed */ - { 262, -4 }, /* (222) limit_opt ::= LIMIT signed COMMA signed */ - { 261, 0 }, /* (223) slimit_opt ::= */ - { 261, -2 }, /* (224) slimit_opt ::= SLIMIT signed */ - { 261, -4 }, /* (225) slimit_opt ::= SLIMIT signed SOFFSET signed */ - { 261, -4 }, /* (226) slimit_opt ::= SLIMIT signed COMMA signed */ - { 252, 0 }, /* (227) where_opt ::= */ - { 252, -2 }, /* (228) where_opt ::= WHERE expr */ - { 266, -3 }, /* (229) expr ::= LP expr RP */ - { 266, -1 }, /* (230) expr ::= ID */ - { 266, -3 }, /* (231) expr ::= ID DOT ID */ - { 266, -3 }, /* (232) expr ::= ID DOT STAR */ - { 266, -1 }, /* (233) expr ::= INTEGER */ - { 266, -2 }, /* (234) expr ::= MINUS INTEGER */ - { 266, -2 }, /* (235) expr ::= PLUS INTEGER */ - { 266, -1 }, /* (236) expr ::= FLOAT */ - { 266, -2 }, /* (237) expr ::= MINUS FLOAT */ - { 266, -2 }, /* (238) expr ::= PLUS FLOAT */ - { 266, -1 }, /* (239) expr ::= STRING */ - { 266, -1 }, /* (240) expr ::= NOW */ - { 266, -1 }, /* (241) expr ::= VARIABLE */ - { 266, -2 }, /* (242) expr ::= PLUS VARIABLE */ - { 266, -2 }, /* (243) expr ::= MINUS VARIABLE */ - { 266, -1 }, /* (244) expr ::= BOOL */ - { 266, -1 }, /* (245) expr ::= NULL */ - { 266, -4 }, /* (246) expr ::= ID LP exprlist RP */ - { 266, -4 }, /* (247) expr ::= ID LP STAR RP */ - { 266, -3 }, /* (248) expr ::= expr IS NULL */ - { 266, -4 }, /* (249) expr ::= expr IS NOT NULL */ - { 266, -3 }, /* (250) expr ::= expr LT expr */ - { 266, -3 }, /* (251) expr ::= expr GT expr */ - { 266, -3 }, /* (252) expr ::= expr LE expr */ - { 266, -3 }, /* (253) expr ::= expr GE expr */ - { 266, -3 }, /* (254) expr ::= expr NE expr */ - { 266, -3 }, /* (255) expr ::= expr EQ expr */ - { 266, -5 }, /* (256) expr ::= expr BETWEEN expr AND expr */ - { 266, -3 }, /* (257) expr ::= expr AND expr */ - { 266, -3 }, /* (258) expr ::= expr OR expr */ - { 266, -3 }, /* (259) expr ::= expr PLUS expr */ - { 266, -3 }, /* (260) expr ::= expr MINUS expr */ - { 266, -3 }, /* (261) expr ::= expr STAR expr */ - { 266, -3 }, /* (262) expr ::= expr SLASH expr */ - { 266, -3 }, /* (263) expr ::= expr REM expr */ - { 266, -3 }, /* (264) expr ::= expr LIKE expr */ - { 266, -5 }, /* (265) expr ::= expr IN LP exprlist RP */ - { 206, -3 }, /* (266) exprlist ::= exprlist COMMA expritem */ - { 206, -1 }, /* (267) exprlist ::= expritem */ - { 277, -1 }, /* (268) expritem ::= expr */ - { 277, 0 }, /* (269) expritem ::= */ - { 198, -3 }, /* (270) cmd ::= RESET QUERY CACHE */ - { 198, -3 }, /* (271) cmd ::= SYNCDB ids REPLICA */ - { 198, -7 }, /* (272) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */ - { 198, -7 }, /* (273) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */ - { 198, -7 }, /* (274) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */ - { 198, -7 }, /* (275) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ - { 198, -7 }, /* (276) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ - { 198, -8 }, /* (277) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ - { 198, -9 }, /* (278) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ - { 198, -7 }, /* (279) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */ - { 198, -7 }, /* (280) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ - { 198, -7 }, /* (281) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ - { 198, -7 }, /* (282) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */ - { 198, -7 }, /* (283) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ - { 198, -7 }, /* (284) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ - { 198, -8 }, /* (285) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ - { 198, -9 }, /* (286) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */ - { 198, -7 }, /* (287) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */ - { 198, -3 }, /* (288) cmd ::= KILL CONNECTION INTEGER */ - { 198, -5 }, /* (289) cmd ::= KILL STREAM INTEGER COLON INTEGER */ - { 198, -5 }, /* (290) cmd ::= KILL QUERY INTEGER COLON INTEGER */ + { 199, -1 }, /* (0) program ::= cmd */ + { 200, -2 }, /* (1) cmd ::= SHOW DATABASES */ + { 200, -2 }, /* (2) cmd ::= SHOW TOPICS */ + { 200, -2 }, /* (3) cmd ::= SHOW FUNCTIONS */ + { 200, -2 }, /* (4) cmd ::= SHOW MNODES */ + { 200, -2 }, /* (5) cmd ::= SHOW DNODES */ + { 200, -2 }, /* (6) cmd ::= SHOW ACCOUNTS */ + { 200, -2 }, /* (7) cmd ::= SHOW USERS */ + { 200, -2 }, /* (8) cmd ::= SHOW MODULES */ + { 200, -2 }, /* (9) cmd ::= SHOW QUERIES */ + { 200, -2 }, /* (10) cmd ::= SHOW CONNECTIONS */ + { 200, -2 }, /* (11) cmd ::= SHOW STREAMS */ + { 200, -2 }, /* (12) cmd ::= SHOW VARIABLES */ + { 200, -2 }, /* (13) cmd ::= SHOW SCORES */ + { 200, -2 }, /* (14) cmd ::= SHOW GRANTS */ + { 200, -2 }, /* (15) cmd ::= SHOW VNODES */ + { 200, -3 }, /* (16) cmd ::= SHOW VNODES IPTOKEN */ + { 201, 0 }, /* (17) dbPrefix ::= */ + { 201, -2 }, /* (18) dbPrefix ::= ids DOT */ + { 203, 0 }, /* (19) cpxName ::= */ + { 203, -2 }, /* (20) cpxName ::= DOT ids */ + { 200, -5 }, /* (21) cmd ::= SHOW CREATE TABLE ids cpxName */ + { 200, -5 }, /* (22) cmd ::= SHOW CREATE STABLE ids cpxName */ + { 200, -4 }, /* (23) cmd ::= SHOW CREATE DATABASE ids */ + { 200, -3 }, /* (24) cmd ::= SHOW dbPrefix TABLES */ + { 200, -5 }, /* (25) cmd ::= SHOW dbPrefix TABLES LIKE ids */ + { 200, -3 }, /* (26) cmd ::= SHOW dbPrefix STABLES */ + { 200, -5 }, /* (27) cmd ::= SHOW dbPrefix STABLES LIKE ids */ + { 200, -3 }, /* (28) cmd ::= SHOW dbPrefix VGROUPS */ + { 200, -5 }, /* (29) cmd ::= DROP TABLE ifexists ids cpxName */ + { 200, -5 }, /* (30) cmd ::= DROP STABLE ifexists ids cpxName */ + { 200, -4 }, /* (31) cmd ::= DROP DATABASE ifexists ids */ + { 200, -4 }, /* (32) cmd ::= DROP TOPIC ifexists ids */ + { 200, -3 }, /* (33) cmd ::= DROP FUNCTION ids */ + { 200, -3 }, /* (34) cmd ::= DROP DNODE ids */ + { 200, -3 }, /* (35) cmd ::= DROP USER ids */ + { 200, -3 }, /* (36) cmd ::= DROP ACCOUNT ids */ + { 200, -2 }, /* (37) cmd ::= USE ids */ + { 200, -3 }, /* (38) cmd ::= DESCRIBE ids cpxName */ + { 200, -3 }, /* (39) cmd ::= DESC ids cpxName */ + { 200, -5 }, /* (40) cmd ::= ALTER USER ids PASS ids */ + { 200, -5 }, /* (41) cmd ::= ALTER USER ids PRIVILEGE ids */ + { 200, -4 }, /* (42) cmd ::= ALTER DNODE ids ids */ + { 200, -5 }, /* (43) cmd ::= ALTER DNODE ids ids ids */ + { 200, -3 }, /* (44) cmd ::= ALTER LOCAL ids */ + { 200, -4 }, /* (45) cmd ::= ALTER LOCAL ids ids */ + { 200, -4 }, /* (46) cmd ::= ALTER DATABASE ids alter_db_optr */ + { 200, -4 }, /* (47) cmd ::= ALTER TOPIC ids alter_topic_optr */ + { 200, -4 }, /* (48) cmd ::= ALTER ACCOUNT ids acct_optr */ + { 200, -6 }, /* (49) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */ + { 200, -6 }, /* (50) cmd ::= COMPACT VNODES IN LP exprlist RP */ + { 202, -1 }, /* (51) ids ::= ID */ + { 202, -1 }, /* (52) ids ::= STRING */ + { 204, -2 }, /* (53) ifexists ::= IF EXISTS */ + { 204, 0 }, /* (54) ifexists ::= */ + { 209, -3 }, /* (55) ifnotexists ::= IF NOT EXISTS */ + { 209, 0 }, /* (56) ifnotexists ::= */ + { 200, -3 }, /* (57) cmd ::= CREATE DNODE ids */ + { 200, -6 }, /* (58) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */ + { 200, -5 }, /* (59) cmd ::= CREATE DATABASE ifnotexists ids db_optr */ + { 200, -5 }, /* (60) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ + { 200, -8 }, /* (61) cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */ + { 200, -9 }, /* (62) cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */ + { 200, -5 }, /* (63) cmd ::= CREATE USER ids PASS ids */ + { 213, 0 }, /* (64) bufsize ::= */ + { 213, -2 }, /* (65) bufsize ::= BUFSIZE INTEGER */ + { 214, 0 }, /* (66) pps ::= */ + { 214, -2 }, /* (67) pps ::= PPS INTEGER */ + { 215, 0 }, /* (68) tseries ::= */ + { 215, -2 }, /* (69) tseries ::= TSERIES INTEGER */ + { 216, 0 }, /* (70) dbs ::= */ + { 216, -2 }, /* (71) dbs ::= DBS INTEGER */ + { 217, 0 }, /* (72) streams ::= */ + { 217, -2 }, /* (73) streams ::= STREAMS INTEGER */ + { 218, 0 }, /* (74) storage ::= */ + { 218, -2 }, /* (75) storage ::= STORAGE INTEGER */ + { 219, 0 }, /* (76) qtime ::= */ + { 219, -2 }, /* (77) qtime ::= QTIME INTEGER */ + { 220, 0 }, /* (78) users ::= */ + { 220, -2 }, /* (79) users ::= USERS INTEGER */ + { 221, 0 }, /* (80) conns ::= */ + { 221, -2 }, /* (81) conns ::= CONNS INTEGER */ + { 222, 0 }, /* (82) state ::= */ + { 222, -2 }, /* (83) state ::= STATE ids */ + { 207, -9 }, /* (84) acct_optr ::= pps tseries storage streams qtime dbs users conns state */ + { 223, -3 }, /* (85) intitemlist ::= intitemlist COMMA intitem */ + { 223, -1 }, /* (86) intitemlist ::= intitem */ + { 224, -1 }, /* (87) intitem ::= INTEGER */ + { 225, -2 }, /* (88) keep ::= KEEP intitemlist */ + { 226, -2 }, /* (89) cache ::= CACHE INTEGER */ + { 227, -2 }, /* (90) replica ::= REPLICA INTEGER */ + { 228, -2 }, /* (91) quorum ::= QUORUM INTEGER */ + { 229, -2 }, /* (92) days ::= DAYS INTEGER */ + { 230, -2 }, /* (93) minrows ::= MINROWS INTEGER */ + { 231, -2 }, /* (94) maxrows ::= MAXROWS INTEGER */ + { 232, -2 }, /* (95) blocks ::= BLOCKS INTEGER */ + { 233, -2 }, /* (96) ctime ::= CTIME INTEGER */ + { 234, -2 }, /* (97) wal ::= WAL INTEGER */ + { 235, -2 }, /* (98) fsync ::= FSYNC INTEGER */ + { 236, -2 }, /* (99) comp ::= COMP INTEGER */ + { 237, -2 }, /* (100) prec ::= PRECISION STRING */ + { 238, -2 }, /* (101) update ::= UPDATE INTEGER */ + { 239, -2 }, /* (102) cachelast ::= CACHELAST INTEGER */ + { 240, -2 }, /* (103) partitions ::= PARTITIONS INTEGER */ + { 210, 0 }, /* (104) db_optr ::= */ + { 210, -2 }, /* (105) db_optr ::= db_optr cache */ + { 210, -2 }, /* (106) db_optr ::= db_optr replica */ + { 210, -2 }, /* (107) db_optr ::= db_optr quorum */ + { 210, -2 }, /* (108) db_optr ::= db_optr days */ + { 210, -2 }, /* (109) db_optr ::= db_optr minrows */ + { 210, -2 }, /* (110) db_optr ::= db_optr maxrows */ + { 210, -2 }, /* (111) db_optr ::= db_optr blocks */ + { 210, -2 }, /* (112) db_optr ::= db_optr ctime */ + { 210, -2 }, /* (113) db_optr ::= db_optr wal */ + { 210, -2 }, /* (114) db_optr ::= db_optr fsync */ + { 210, -2 }, /* (115) db_optr ::= db_optr comp */ + { 210, -2 }, /* (116) db_optr ::= db_optr prec */ + { 210, -2 }, /* (117) db_optr ::= db_optr keep */ + { 210, -2 }, /* (118) db_optr ::= db_optr update */ + { 210, -2 }, /* (119) db_optr ::= db_optr cachelast */ + { 211, -1 }, /* (120) topic_optr ::= db_optr */ + { 211, -2 }, /* (121) topic_optr ::= topic_optr partitions */ + { 205, 0 }, /* (122) alter_db_optr ::= */ + { 205, -2 }, /* (123) alter_db_optr ::= alter_db_optr replica */ + { 205, -2 }, /* (124) alter_db_optr ::= alter_db_optr quorum */ + { 205, -2 }, /* (125) alter_db_optr ::= alter_db_optr keep */ + { 205, -2 }, /* (126) alter_db_optr ::= alter_db_optr blocks */ + { 205, -2 }, /* (127) alter_db_optr ::= alter_db_optr comp */ + { 205, -2 }, /* (128) alter_db_optr ::= alter_db_optr update */ + { 205, -2 }, /* (129) alter_db_optr ::= alter_db_optr cachelast */ + { 206, -1 }, /* (130) alter_topic_optr ::= alter_db_optr */ + { 206, -2 }, /* (131) alter_topic_optr ::= alter_topic_optr partitions */ + { 212, -1 }, /* (132) typename ::= ids */ + { 212, -4 }, /* (133) typename ::= ids LP signed RP */ + { 212, -2 }, /* (134) typename ::= ids UNSIGNED */ + { 241, -1 }, /* (135) signed ::= INTEGER */ + { 241, -2 }, /* (136) signed ::= PLUS INTEGER */ + { 241, -2 }, /* (137) signed ::= MINUS INTEGER */ + { 200, -3 }, /* (138) cmd ::= CREATE TABLE create_table_args */ + { 200, -3 }, /* (139) cmd ::= CREATE TABLE create_stable_args */ + { 200, -3 }, /* (140) cmd ::= CREATE STABLE create_stable_args */ + { 200, -3 }, /* (141) cmd ::= CREATE TABLE create_table_list */ + { 244, -1 }, /* (142) create_table_list ::= create_from_stable */ + { 244, -2 }, /* (143) create_table_list ::= create_table_list create_from_stable */ + { 242, -6 }, /* (144) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */ + { 243, -10 }, /* (145) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */ + { 245, -10 }, /* (146) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */ + { 245, -13 }, /* (147) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */ + { 248, -3 }, /* (148) tagNamelist ::= tagNamelist COMMA ids */ + { 248, -1 }, /* (149) tagNamelist ::= ids */ + { 242, -7 }, /* (150) create_table_args ::= ifnotexists ids cpxName to_opt split_opt AS select */ + { 249, 0 }, /* (151) to_opt ::= */ + { 249, -3 }, /* (152) to_opt ::= TO ids cpxName */ + { 250, 0 }, /* (153) split_opt ::= */ + { 250, -2 }, /* (154) split_opt ::= SPLIT ids */ + { 246, -3 }, /* (155) columnlist ::= columnlist COMMA column */ + { 246, -1 }, /* (156) columnlist ::= column */ + { 253, -2 }, /* (157) column ::= ids typename */ + { 247, -3 }, /* (158) tagitemlist ::= tagitemlist COMMA tagitem */ + { 247, -1 }, /* (159) tagitemlist ::= tagitem */ + { 254, -1 }, /* (160) tagitem ::= INTEGER */ + { 254, -1 }, /* (161) tagitem ::= FLOAT */ + { 254, -1 }, /* (162) tagitem ::= STRING */ + { 254, -1 }, /* (163) tagitem ::= BOOL */ + { 254, -1 }, /* (164) tagitem ::= NULL */ + { 254, -1 }, /* (165) tagitem ::= NOW */ + { 254, -2 }, /* (166) tagitem ::= MINUS INTEGER */ + { 254, -2 }, /* (167) tagitem ::= MINUS FLOAT */ + { 254, -2 }, /* (168) tagitem ::= PLUS INTEGER */ + { 254, -2 }, /* (169) tagitem ::= PLUS FLOAT */ + { 251, -14 }, /* (170) select ::= SELECT selcollist from where_opt interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */ + { 251, -3 }, /* (171) select ::= LP select RP */ + { 268, -1 }, /* (172) union ::= select */ + { 268, -4 }, /* (173) union ::= union UNION ALL select */ + { 200, -1 }, /* (174) cmd ::= union */ + { 251, -2 }, /* (175) select ::= SELECT selcollist */ + { 269, -2 }, /* (176) sclp ::= selcollist COMMA */ + { 269, 0 }, /* (177) sclp ::= */ + { 255, -4 }, /* (178) selcollist ::= sclp distinct expr as */ + { 255, -2 }, /* (179) selcollist ::= sclp STAR */ + { 272, -2 }, /* (180) as ::= AS ids */ + { 272, -1 }, /* (181) as ::= ids */ + { 272, 0 }, /* (182) as ::= */ + { 270, -1 }, /* (183) distinct ::= DISTINCT */ + { 270, 0 }, /* (184) distinct ::= */ + { 256, -2 }, /* (185) from ::= FROM tablelist */ + { 256, -2 }, /* (186) from ::= FROM sub */ + { 274, -3 }, /* (187) sub ::= LP union RP */ + { 274, -4 }, /* (188) sub ::= LP union RP ids */ + { 274, -6 }, /* (189) sub ::= sub COMMA LP union RP ids */ + { 273, -2 }, /* (190) tablelist ::= ids cpxName */ + { 273, -3 }, /* (191) tablelist ::= ids cpxName ids */ + { 273, -4 }, /* (192) tablelist ::= tablelist COMMA ids cpxName */ + { 273, -5 }, /* (193) tablelist ::= tablelist COMMA ids cpxName ids */ + { 275, -1 }, /* (194) tmvar ::= VARIABLE */ + { 258, -4 }, /* (195) interval_option ::= intervalKey LP tmvar RP */ + { 258, -6 }, /* (196) interval_option ::= intervalKey LP tmvar COMMA tmvar RP */ + { 258, 0 }, /* (197) interval_option ::= */ + { 276, -1 }, /* (198) intervalKey ::= INTERVAL */ + { 276, -1 }, /* (199) intervalKey ::= EVERY */ + { 260, 0 }, /* (200) session_option ::= */ + { 260, -7 }, /* (201) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */ + { 261, 0 }, /* (202) windowstate_option ::= */ + { 261, -4 }, /* (203) windowstate_option ::= STATE_WINDOW LP ids RP */ + { 262, 0 }, /* (204) fill_opt ::= */ + { 262, -6 }, /* (205) fill_opt ::= FILL LP ID COMMA tagitemlist RP */ + { 262, -4 }, /* (206) fill_opt ::= FILL LP ID RP */ + { 259, -4 }, /* (207) sliding_opt ::= SLIDING LP tmvar RP */ + { 259, 0 }, /* (208) sliding_opt ::= */ + { 265, 0 }, /* (209) orderby_opt ::= */ + { 265, -3 }, /* (210) orderby_opt ::= ORDER BY sortlist */ + { 277, -4 }, /* (211) sortlist ::= sortlist COMMA item sortorder */ + { 277, -2 }, /* (212) sortlist ::= item sortorder */ + { 279, -2 }, /* (213) item ::= ids cpxName */ + { 280, -1 }, /* (214) sortorder ::= ASC */ + { 280, -1 }, /* (215) sortorder ::= DESC */ + { 280, 0 }, /* (216) sortorder ::= */ + { 263, 0 }, /* (217) groupby_opt ::= */ + { 263, -3 }, /* (218) groupby_opt ::= GROUP BY grouplist */ + { 281, -3 }, /* (219) grouplist ::= grouplist COMMA item */ + { 281, -1 }, /* (220) grouplist ::= item */ + { 264, 0 }, /* (221) having_opt ::= */ + { 264, -2 }, /* (222) having_opt ::= HAVING expr */ + { 267, 0 }, /* (223) limit_opt ::= */ + { 267, -2 }, /* (224) limit_opt ::= LIMIT signed */ + { 267, -4 }, /* (225) limit_opt ::= LIMIT signed OFFSET signed */ + { 267, -4 }, /* (226) limit_opt ::= LIMIT signed COMMA signed */ + { 266, 0 }, /* (227) slimit_opt ::= */ + { 266, -2 }, /* (228) slimit_opt ::= SLIMIT signed */ + { 266, -4 }, /* (229) slimit_opt ::= SLIMIT signed SOFFSET signed */ + { 266, -4 }, /* (230) slimit_opt ::= SLIMIT signed COMMA signed */ + { 257, 0 }, /* (231) where_opt ::= */ + { 257, -2 }, /* (232) where_opt ::= WHERE expr */ + { 271, -3 }, /* (233) expr ::= LP expr RP */ + { 271, -1 }, /* (234) expr ::= ID */ + { 271, -3 }, /* (235) expr ::= ID DOT ID */ + { 271, -3 }, /* (236) expr ::= ID DOT STAR */ + { 271, -1 }, /* (237) expr ::= INTEGER */ + { 271, -2 }, /* (238) expr ::= MINUS INTEGER */ + { 271, -2 }, /* (239) expr ::= PLUS INTEGER */ + { 271, -1 }, /* (240) expr ::= FLOAT */ + { 271, -2 }, /* (241) expr ::= MINUS FLOAT */ + { 271, -2 }, /* (242) expr ::= PLUS FLOAT */ + { 271, -1 }, /* (243) expr ::= STRING */ + { 271, -1 }, /* (244) expr ::= NOW */ + { 271, -1 }, /* (245) expr ::= VARIABLE */ + { 271, -2 }, /* (246) expr ::= PLUS VARIABLE */ + { 271, -2 }, /* (247) expr ::= MINUS VARIABLE */ + { 271, -1 }, /* (248) expr ::= BOOL */ + { 271, -1 }, /* (249) expr ::= NULL */ + { 271, -4 }, /* (250) expr ::= ID LP exprlist RP */ + { 271, -4 }, /* (251) expr ::= ID LP STAR RP */ + { 271, -3 }, /* (252) expr ::= expr IS NULL */ + { 271, -4 }, /* (253) expr ::= expr IS NOT NULL */ + { 271, -3 }, /* (254) expr ::= expr LT expr */ + { 271, -3 }, /* (255) expr ::= expr GT expr */ + { 271, -3 }, /* (256) expr ::= expr LE expr */ + { 271, -3 }, /* (257) expr ::= expr GE expr */ + { 271, -3 }, /* (258) expr ::= expr NE expr */ + { 271, -3 }, /* (259) expr ::= expr EQ expr */ + { 271, -5 }, /* (260) expr ::= expr BETWEEN expr AND expr */ + { 271, -3 }, /* (261) expr ::= expr AND expr */ + { 271, -3 }, /* (262) expr ::= expr OR expr */ + { 271, -3 }, /* (263) expr ::= expr PLUS expr */ + { 271, -3 }, /* (264) expr ::= expr MINUS expr */ + { 271, -3 }, /* (265) expr ::= expr STAR expr */ + { 271, -3 }, /* (266) expr ::= expr SLASH expr */ + { 271, -3 }, /* (267) expr ::= expr REM expr */ + { 271, -3 }, /* (268) expr ::= expr LIKE expr */ + { 271, -5 }, /* (269) expr ::= expr IN LP exprlist RP */ + { 208, -3 }, /* (270) exprlist ::= exprlist COMMA expritem */ + { 208, -1 }, /* (271) exprlist ::= expritem */ + { 282, -1 }, /* (272) expritem ::= expr */ + { 282, 0 }, /* (273) expritem ::= */ + { 200, -3 }, /* (274) cmd ::= RESET QUERY CACHE */ + { 200, -3 }, /* (275) cmd ::= SYNCDB ids REPLICA */ + { 200, -7 }, /* (276) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */ + { 200, -7 }, /* (277) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */ + { 200, -7 }, /* (278) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */ + { 200, -7 }, /* (279) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ + { 200, -7 }, /* (280) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ + { 200, -8 }, /* (281) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ + { 200, -9 }, /* (282) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ + { 200, -7 }, /* (283) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */ + { 200, -7 }, /* (284) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ + { 200, -7 }, /* (285) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ + { 200, -7 }, /* (286) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */ + { 200, -7 }, /* (287) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ + { 200, -7 }, /* (288) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ + { 200, -8 }, /* (289) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ + { 200, -9 }, /* (290) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */ + { 200, -7 }, /* (291) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */ + { 200, -3 }, /* (292) cmd ::= KILL CONNECTION INTEGER */ + { 200, -5 }, /* (293) cmd ::= KILL STREAM INTEGER COLON INTEGER */ + { 200, -5 }, /* (294) cmd ::= KILL QUERY INTEGER COLON INTEGER */ }; static void yy_accept(yyParser*); /* Forward Declaration */ @@ -2402,16 +2419,16 @@ static YYACTIONTYPE yy_reduce( break; case 46: /* cmd ::= ALTER DATABASE ids alter_db_optr */ case 47: /* cmd ::= ALTER TOPIC ids alter_topic_optr */ yytestcase(yyruleno==47); -{ SStrToken t = {0}; setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy90, &t);} +{ SStrToken t = {0}; setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy470, &t);} break; case 48: /* cmd ::= ALTER ACCOUNT ids acct_optr */ -{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy171);} +{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy307);} break; case 49: /* cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */ -{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy171);} +{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy307);} break; case 50: /* cmd ::= COMPACT VNODES IN LP exprlist RP */ -{ setCompactVnodeSql(pInfo, TSDB_SQL_COMPACT_VNODE, yymsp[-1].minor.yy421);} +{ setCompactVnodeSql(pInfo, TSDB_SQL_COMPACT_VNODE, yymsp[-1].minor.yy89);} break; case 51: /* ids ::= ID */ case 52: /* ids ::= STRING */ yytestcase(yyruleno==52); @@ -2423,7 +2440,7 @@ static YYACTIONTYPE yy_reduce( break; case 54: /* ifexists ::= */ case 56: /* ifnotexists ::= */ yytestcase(yyruleno==56); - case 180: /* distinct ::= */ yytestcase(yyruleno==180); + case 184: /* distinct ::= */ yytestcase(yyruleno==184); { yymsp[1].minor.yy0.n = 0;} break; case 55: /* ifnotexists ::= IF NOT EXISTS */ @@ -2433,17 +2450,17 @@ static YYACTIONTYPE yy_reduce( { setDCLSqlElems(pInfo, TSDB_SQL_CREATE_DNODE, 1, &yymsp[0].minor.yy0);} break; case 58: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */ -{ setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy171);} +{ setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy307);} break; case 59: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */ case 60: /* cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ yytestcase(yyruleno==60); -{ setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy90, &yymsp[-2].minor.yy0);} +{ setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy470, &yymsp[-2].minor.yy0);} break; case 61: /* cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */ -{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy183, &yymsp[0].minor.yy0, 1);} +{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy465, &yymsp[0].minor.yy0, 1);} break; case 62: /* cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */ -{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy183, &yymsp[0].minor.yy0, 2);} +{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy465, &yymsp[0].minor.yy0, 2);} break; case 63: /* cmd ::= CREATE USER ids PASS ids */ { setCreateUserSql(pInfo, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);} @@ -2474,38 +2491,38 @@ static YYACTIONTYPE yy_reduce( break; case 84: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */ { - yylhsminor.yy171.maxUsers = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1; - yylhsminor.yy171.maxDbs = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1; - yylhsminor.yy171.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1; - yylhsminor.yy171.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1; - yylhsminor.yy171.maxPointsPerSecond = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1; - yylhsminor.yy171.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1; - yylhsminor.yy171.maxQueryTime = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1; - yylhsminor.yy171.maxConnections = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1; - yylhsminor.yy171.stat = yymsp[0].minor.yy0; + yylhsminor.yy307.maxUsers = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1; + yylhsminor.yy307.maxDbs = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1; + yylhsminor.yy307.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1; + yylhsminor.yy307.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1; + yylhsminor.yy307.maxPointsPerSecond = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1; + yylhsminor.yy307.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1; + yylhsminor.yy307.maxQueryTime = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1; + yylhsminor.yy307.maxConnections = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1; + yylhsminor.yy307.stat = yymsp[0].minor.yy0; } - yymsp[-8].minor.yy171 = yylhsminor.yy171; + yymsp[-8].minor.yy307 = yylhsminor.yy307; break; case 85: /* intitemlist ::= intitemlist COMMA intitem */ - case 154: /* tagitemlist ::= tagitemlist COMMA tagitem */ yytestcase(yyruleno==154); -{ yylhsminor.yy421 = tVariantListAppend(yymsp[-2].minor.yy421, &yymsp[0].minor.yy430, -1); } - yymsp[-2].minor.yy421 = yylhsminor.yy421; + case 158: /* tagitemlist ::= tagitemlist COMMA tagitem */ yytestcase(yyruleno==158); +{ yylhsminor.yy89 = tVariantListAppend(yymsp[-2].minor.yy89, &yymsp[0].minor.yy112, -1); } + yymsp[-2].minor.yy89 = yylhsminor.yy89; break; case 86: /* intitemlist ::= intitem */ - case 155: /* tagitemlist ::= tagitem */ yytestcase(yyruleno==155); -{ yylhsminor.yy421 = tVariantListAppend(NULL, &yymsp[0].minor.yy430, -1); } - yymsp[0].minor.yy421 = yylhsminor.yy421; + case 159: /* tagitemlist ::= tagitem */ yytestcase(yyruleno==159); +{ yylhsminor.yy89 = tVariantListAppend(NULL, &yymsp[0].minor.yy112, -1); } + yymsp[0].minor.yy89 = yylhsminor.yy89; break; case 87: /* intitem ::= INTEGER */ - case 156: /* tagitem ::= INTEGER */ yytestcase(yyruleno==156); - case 157: /* tagitem ::= FLOAT */ yytestcase(yyruleno==157); - case 158: /* tagitem ::= STRING */ yytestcase(yyruleno==158); - case 159: /* tagitem ::= BOOL */ yytestcase(yyruleno==159); -{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy430, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy430 = yylhsminor.yy430; + case 160: /* tagitem ::= INTEGER */ yytestcase(yyruleno==160); + case 161: /* tagitem ::= FLOAT */ yytestcase(yyruleno==161); + case 162: /* tagitem ::= STRING */ yytestcase(yyruleno==162); + case 163: /* tagitem ::= BOOL */ yytestcase(yyruleno==163); +{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy112, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy112 = yylhsminor.yy112; break; case 88: /* keep ::= KEEP intitemlist */ -{ yymsp[-1].minor.yy421 = yymsp[0].minor.yy421; } +{ yymsp[-1].minor.yy89 = yymsp[0].minor.yy89; } break; case 89: /* cache ::= CACHE INTEGER */ case 90: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==90); @@ -2525,644 +2542,658 @@ static YYACTIONTYPE yy_reduce( { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; } break; case 104: /* db_optr ::= */ -{setDefaultCreateDbOption(&yymsp[1].minor.yy90); yymsp[1].minor.yy90.dbType = TSDB_DB_TYPE_DEFAULT;} +{setDefaultCreateDbOption(&yymsp[1].minor.yy470); yymsp[1].minor.yy470.dbType = TSDB_DB_TYPE_DEFAULT;} break; case 105: /* db_optr ::= db_optr cache */ -{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy90 = yylhsminor.yy90; +{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy470 = yylhsminor.yy470; break; case 106: /* db_optr ::= db_optr replica */ case 123: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==123); -{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy90 = yylhsminor.yy90; +{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy470 = yylhsminor.yy470; break; case 107: /* db_optr ::= db_optr quorum */ case 124: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==124); -{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy90 = yylhsminor.yy90; +{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy470 = yylhsminor.yy470; break; case 108: /* db_optr ::= db_optr days */ -{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy90 = yylhsminor.yy90; +{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy470 = yylhsminor.yy470; break; case 109: /* db_optr ::= db_optr minrows */ -{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); } - yymsp[-1].minor.yy90 = yylhsminor.yy90; +{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); } + yymsp[-1].minor.yy470 = yylhsminor.yy470; break; case 110: /* db_optr ::= db_optr maxrows */ -{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); } - yymsp[-1].minor.yy90 = yylhsminor.yy90; +{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); } + yymsp[-1].minor.yy470 = yylhsminor.yy470; break; case 111: /* db_optr ::= db_optr blocks */ case 126: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==126); -{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy90 = yylhsminor.yy90; +{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy470 = yylhsminor.yy470; break; case 112: /* db_optr ::= db_optr ctime */ -{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy90 = yylhsminor.yy90; +{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy470 = yylhsminor.yy470; break; case 113: /* db_optr ::= db_optr wal */ -{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy90 = yylhsminor.yy90; +{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy470 = yylhsminor.yy470; break; case 114: /* db_optr ::= db_optr fsync */ -{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy90 = yylhsminor.yy90; +{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy470 = yylhsminor.yy470; break; case 115: /* db_optr ::= db_optr comp */ case 127: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==127); -{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy90 = yylhsminor.yy90; +{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy470 = yylhsminor.yy470; break; case 116: /* db_optr ::= db_optr prec */ -{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.precision = yymsp[0].minor.yy0; } - yymsp[-1].minor.yy90 = yylhsminor.yy90; +{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.precision = yymsp[0].minor.yy0; } + yymsp[-1].minor.yy470 = yylhsminor.yy470; break; case 117: /* db_optr ::= db_optr keep */ case 125: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==125); -{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.keep = yymsp[0].minor.yy421; } - yymsp[-1].minor.yy90 = yylhsminor.yy90; +{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.keep = yymsp[0].minor.yy89; } + yymsp[-1].minor.yy470 = yylhsminor.yy470; break; case 118: /* db_optr ::= db_optr update */ case 128: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==128); -{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy90 = yylhsminor.yy90; +{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy470 = yylhsminor.yy470; break; case 119: /* db_optr ::= db_optr cachelast */ case 129: /* alter_db_optr ::= alter_db_optr cachelast */ yytestcase(yyruleno==129); -{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy90 = yylhsminor.yy90; +{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy470 = yylhsminor.yy470; break; case 120: /* topic_optr ::= db_optr */ case 130: /* alter_topic_optr ::= alter_db_optr */ yytestcase(yyruleno==130); -{ yylhsminor.yy90 = yymsp[0].minor.yy90; yylhsminor.yy90.dbType = TSDB_DB_TYPE_TOPIC; } - yymsp[0].minor.yy90 = yylhsminor.yy90; +{ yylhsminor.yy470 = yymsp[0].minor.yy470; yylhsminor.yy470.dbType = TSDB_DB_TYPE_TOPIC; } + yymsp[0].minor.yy470 = yylhsminor.yy470; break; case 121: /* topic_optr ::= topic_optr partitions */ case 131: /* alter_topic_optr ::= alter_topic_optr partitions */ yytestcase(yyruleno==131); -{ yylhsminor.yy90 = yymsp[-1].minor.yy90; yylhsminor.yy90.partitions = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[-1].minor.yy90 = yylhsminor.yy90; +{ yylhsminor.yy470 = yymsp[-1].minor.yy470; yylhsminor.yy470.partitions = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[-1].minor.yy470 = yylhsminor.yy470; break; case 122: /* alter_db_optr ::= */ -{ setDefaultCreateDbOption(&yymsp[1].minor.yy90); yymsp[1].minor.yy90.dbType = TSDB_DB_TYPE_DEFAULT;} +{ setDefaultCreateDbOption(&yymsp[1].minor.yy470); yymsp[1].minor.yy470.dbType = TSDB_DB_TYPE_DEFAULT;} break; case 132: /* typename ::= ids */ { yymsp[0].minor.yy0.type = 0; - tSetColumnType (&yylhsminor.yy183, &yymsp[0].minor.yy0); + tSetColumnType (&yylhsminor.yy465, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy183 = yylhsminor.yy183; + yymsp[0].minor.yy465 = yylhsminor.yy465; break; case 133: /* typename ::= ids LP signed RP */ { - if (yymsp[-1].minor.yy325 <= 0) { + if (yymsp[-1].minor.yy145 <= 0) { yymsp[-3].minor.yy0.type = 0; - tSetColumnType(&yylhsminor.yy183, &yymsp[-3].minor.yy0); + tSetColumnType(&yylhsminor.yy465, &yymsp[-3].minor.yy0); } else { - yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy325; // negative value of name length - tSetColumnType(&yylhsminor.yy183, &yymsp[-3].minor.yy0); + yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy145; // negative value of name length + tSetColumnType(&yylhsminor.yy465, &yymsp[-3].minor.yy0); } } - yymsp[-3].minor.yy183 = yylhsminor.yy183; + yymsp[-3].minor.yy465 = yylhsminor.yy465; break; case 134: /* typename ::= ids UNSIGNED */ { yymsp[-1].minor.yy0.type = 0; yymsp[-1].minor.yy0.n = ((yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z); - tSetColumnType (&yylhsminor.yy183, &yymsp[-1].minor.yy0); + tSetColumnType (&yylhsminor.yy465, &yymsp[-1].minor.yy0); } - yymsp[-1].minor.yy183 = yylhsminor.yy183; + yymsp[-1].minor.yy465 = yylhsminor.yy465; break; case 135: /* signed ::= INTEGER */ -{ yylhsminor.yy325 = strtol(yymsp[0].minor.yy0.z, NULL, 10); } - yymsp[0].minor.yy325 = yylhsminor.yy325; +{ yylhsminor.yy145 = strtol(yymsp[0].minor.yy0.z, NULL, 10); } + yymsp[0].minor.yy145 = yylhsminor.yy145; break; case 136: /* signed ::= PLUS INTEGER */ -{ yymsp[-1].minor.yy325 = strtol(yymsp[0].minor.yy0.z, NULL, 10); } +{ yymsp[-1].minor.yy145 = strtol(yymsp[0].minor.yy0.z, NULL, 10); } break; case 137: /* signed ::= MINUS INTEGER */ -{ yymsp[-1].minor.yy325 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);} +{ yymsp[-1].minor.yy145 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);} break; case 141: /* cmd ::= CREATE TABLE create_table_list */ -{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy438;} +{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy86;} break; case 142: /* create_table_list ::= create_from_stable */ { SCreateTableSql* pCreateTable = calloc(1, sizeof(SCreateTableSql)); pCreateTable->childTableInfo = taosArrayInit(4, sizeof(SCreatedTableInfo)); - taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy152); + taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy506); pCreateTable->type = TSQL_CREATE_TABLE_FROM_STABLE; - yylhsminor.yy438 = pCreateTable; + yylhsminor.yy86 = pCreateTable; } - yymsp[0].minor.yy438 = yylhsminor.yy438; + yymsp[0].minor.yy86 = yylhsminor.yy86; break; case 143: /* create_table_list ::= create_table_list create_from_stable */ { - taosArrayPush(yymsp[-1].minor.yy438->childTableInfo, &yymsp[0].minor.yy152); - yylhsminor.yy438 = yymsp[-1].minor.yy438; + taosArrayPush(yymsp[-1].minor.yy86->childTableInfo, &yymsp[0].minor.yy506); + yylhsminor.yy86 = yymsp[-1].minor.yy86; } - yymsp[-1].minor.yy438 = yylhsminor.yy438; + yymsp[-1].minor.yy86 = yylhsminor.yy86; break; case 144: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */ { - yylhsminor.yy438 = tSetCreateTableInfo(yymsp[-1].minor.yy421, NULL, NULL, TSQL_CREATE_TABLE); - setSqlInfo(pInfo, yylhsminor.yy438, NULL, TSDB_SQL_CREATE_TABLE); + yylhsminor.yy86 = tSetCreateTableInfo(yymsp[-1].minor.yy89, NULL, NULL, TSQL_CREATE_TABLE); + setSqlInfo(pInfo, yylhsminor.yy86, 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.yy438 = yylhsminor.yy438; + yymsp[-5].minor.yy86 = yylhsminor.yy86; break; case 145: /* create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */ { - yylhsminor.yy438 = tSetCreateTableInfo(yymsp[-5].minor.yy421, yymsp[-1].minor.yy421, NULL, TSQL_CREATE_STABLE); - setSqlInfo(pInfo, yylhsminor.yy438, NULL, TSDB_SQL_CREATE_TABLE); + yylhsminor.yy86 = tSetCreateTableInfo(yymsp[-5].minor.yy89, yymsp[-1].minor.yy89, NULL, TSQL_CREATE_STABLE); + setSqlInfo(pInfo, yylhsminor.yy86, 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.yy438 = yylhsminor.yy438; + yymsp[-9].minor.yy86 = yylhsminor.yy86; break; case 146: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */ { yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n; yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n; - yylhsminor.yy152 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy421, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0); + yylhsminor.yy506 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy89, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0); } - yymsp[-9].minor.yy152 = yylhsminor.yy152; + yymsp[-9].minor.yy506 = yylhsminor.yy506; break; case 147: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */ { yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n; yymsp[-11].minor.yy0.n += yymsp[-10].minor.yy0.n; - yylhsminor.yy152 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy421, yymsp[-1].minor.yy421, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0); + yylhsminor.yy506 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy89, yymsp[-1].minor.yy89, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0); } - yymsp[-12].minor.yy152 = yylhsminor.yy152; + yymsp[-12].minor.yy506 = yylhsminor.yy506; break; case 148: /* tagNamelist ::= tagNamelist COMMA ids */ -{taosArrayPush(yymsp[-2].minor.yy421, &yymsp[0].minor.yy0); yylhsminor.yy421 = yymsp[-2].minor.yy421; } - yymsp[-2].minor.yy421 = yylhsminor.yy421; +{taosArrayPush(yymsp[-2].minor.yy89, &yymsp[0].minor.yy0); yylhsminor.yy89 = yymsp[-2].minor.yy89; } + yymsp[-2].minor.yy89 = yylhsminor.yy89; break; case 149: /* tagNamelist ::= ids */ -{yylhsminor.yy421 = taosArrayInit(4, sizeof(SStrToken)); taosArrayPush(yylhsminor.yy421, &yymsp[0].minor.yy0);} - yymsp[0].minor.yy421 = yylhsminor.yy421; +{yylhsminor.yy89 = taosArrayInit(4, sizeof(SStrToken)); taosArrayPush(yylhsminor.yy89, &yymsp[0].minor.yy0);} + yymsp[0].minor.yy89 = yylhsminor.yy89; break; - case 150: /* create_table_args ::= ifnotexists ids cpxName AS select */ + case 150: /* create_table_args ::= ifnotexists ids cpxName to_opt split_opt AS select */ { - yylhsminor.yy438 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy56, TSQL_CREATE_STREAM); - setSqlInfo(pInfo, yylhsminor.yy438, NULL, TSDB_SQL_CREATE_TABLE); + yylhsminor.yy86 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy378, TSQL_CREATE_STREAM); + setSqlInfo(pInfo, yylhsminor.yy86, NULL, TSDB_SQL_CREATE_TABLE); - yymsp[-3].minor.yy0.n += yymsp[-2].minor.yy0.n; - setCreatedTableName(pInfo, &yymsp[-3].minor.yy0, &yymsp[-4].minor.yy0); + setCreatedStreamOpt(pInfo, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0); + yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n; + setCreatedTableName(pInfo, &yymsp[-5].minor.yy0, &yymsp[-6].minor.yy0); +} + yymsp[-6].minor.yy86 = yylhsminor.yy86; + break; + case 151: /* to_opt ::= */ + case 153: /* split_opt ::= */ yytestcase(yyruleno==153); +{yymsp[1].minor.yy0.n = 0;} + break; + case 152: /* to_opt ::= TO ids cpxName */ +{ + yymsp[-2].minor.yy0 = yymsp[-1].minor.yy0; + yymsp[-2].minor.yy0.n += yymsp[0].minor.yy0.n; } - yymsp[-4].minor.yy438 = yylhsminor.yy438; break; - case 151: /* columnlist ::= columnlist COMMA column */ -{taosArrayPush(yymsp[-2].minor.yy421, &yymsp[0].minor.yy183); yylhsminor.yy421 = yymsp[-2].minor.yy421; } - yymsp[-2].minor.yy421 = yylhsminor.yy421; + case 154: /* split_opt ::= SPLIT ids */ +{ yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;} + break; + case 155: /* columnlist ::= columnlist COMMA column */ +{taosArrayPush(yymsp[-2].minor.yy89, &yymsp[0].minor.yy465); yylhsminor.yy89 = yymsp[-2].minor.yy89; } + yymsp[-2].minor.yy89 = yylhsminor.yy89; break; - case 152: /* columnlist ::= column */ -{yylhsminor.yy421 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy421, &yymsp[0].minor.yy183);} - yymsp[0].minor.yy421 = yylhsminor.yy421; + case 156: /* columnlist ::= column */ +{yylhsminor.yy89 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy89, &yymsp[0].minor.yy465);} + yymsp[0].minor.yy89 = yylhsminor.yy89; break; - case 153: /* column ::= ids typename */ + case 157: /* column ::= ids typename */ { - tSetColumnInfo(&yylhsminor.yy183, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy183); + tSetColumnInfo(&yylhsminor.yy465, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy465); } - yymsp[-1].minor.yy183 = yylhsminor.yy183; + yymsp[-1].minor.yy465 = yylhsminor.yy465; break; - case 160: /* tagitem ::= NULL */ -{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy430, &yymsp[0].minor.yy0); } - yymsp[0].minor.yy430 = yylhsminor.yy430; + case 164: /* tagitem ::= NULL */ +{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy112, &yymsp[0].minor.yy0); } + yymsp[0].minor.yy112 = yylhsminor.yy112; break; - case 161: /* tagitem ::= NOW */ -{ yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP; tVariantCreate(&yylhsminor.yy430, &yymsp[0].minor.yy0);} - yymsp[0].minor.yy430 = yylhsminor.yy430; + case 165: /* tagitem ::= NOW */ +{ yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP; tVariantCreate(&yylhsminor.yy112, &yymsp[0].minor.yy0);} + yymsp[0].minor.yy112 = yylhsminor.yy112; break; - case 162: /* tagitem ::= MINUS INTEGER */ - case 163: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==163); - case 164: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==164); - case 165: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==165); + case 166: /* tagitem ::= MINUS INTEGER */ + case 167: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==167); + case 168: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==168); + case 169: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==169); { 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.yy430, &yymsp[-1].minor.yy0); + tVariantCreate(&yylhsminor.yy112, &yymsp[-1].minor.yy0); } - yymsp[-1].minor.yy430 = yylhsminor.yy430; + yymsp[-1].minor.yy112 = yylhsminor.yy112; break; - case 166: /* select ::= SELECT selcollist from where_opt interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */ + case 170: /* select ::= SELECT selcollist from where_opt interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */ { - yylhsminor.yy56 = tSetQuerySqlNode(&yymsp[-13].minor.yy0, yymsp[-12].minor.yy421, yymsp[-11].minor.yy8, yymsp[-10].minor.yy439, yymsp[-4].minor.yy421, yymsp[-2].minor.yy421, &yymsp[-9].minor.yy400, &yymsp[-7].minor.yy147, &yymsp[-6].minor.yy40, &yymsp[-8].minor.yy0, yymsp[-5].minor.yy421, &yymsp[0].minor.yy166, &yymsp[-1].minor.yy166, yymsp[-3].minor.yy439); + yylhsminor.yy378 = tSetQuerySqlNode(&yymsp[-13].minor.yy0, yymsp[-12].minor.yy89, yymsp[-11].minor.yy166, yymsp[-10].minor.yy342, yymsp[-4].minor.yy89, yymsp[-2].minor.yy89, &yymsp[-9].minor.yy66, &yymsp[-7].minor.yy431, &yymsp[-6].minor.yy392, &yymsp[-8].minor.yy0, yymsp[-5].minor.yy89, &yymsp[0].minor.yy372, &yymsp[-1].minor.yy372, yymsp[-3].minor.yy342); } - yymsp[-13].minor.yy56 = yylhsminor.yy56; + yymsp[-13].minor.yy378 = yylhsminor.yy378; break; - case 167: /* select ::= LP select RP */ -{yymsp[-2].minor.yy56 = yymsp[-1].minor.yy56;} + case 171: /* select ::= LP select RP */ +{yymsp[-2].minor.yy378 = yymsp[-1].minor.yy378;} break; - case 168: /* union ::= select */ -{ yylhsminor.yy421 = setSubclause(NULL, yymsp[0].minor.yy56); } - yymsp[0].minor.yy421 = yylhsminor.yy421; + case 172: /* union ::= select */ +{ yylhsminor.yy89 = setSubclause(NULL, yymsp[0].minor.yy378); } + yymsp[0].minor.yy89 = yylhsminor.yy89; break; - case 169: /* union ::= union UNION ALL select */ -{ yylhsminor.yy421 = appendSelectClause(yymsp[-3].minor.yy421, yymsp[0].minor.yy56); } - yymsp[-3].minor.yy421 = yylhsminor.yy421; + case 173: /* union ::= union UNION ALL select */ +{ yylhsminor.yy89 = appendSelectClause(yymsp[-3].minor.yy89, yymsp[0].minor.yy378); } + yymsp[-3].minor.yy89 = yylhsminor.yy89; break; - case 170: /* cmd ::= union */ -{ setSqlInfo(pInfo, yymsp[0].minor.yy421, NULL, TSDB_SQL_SELECT); } + case 174: /* cmd ::= union */ +{ setSqlInfo(pInfo, yymsp[0].minor.yy89, NULL, TSDB_SQL_SELECT); } break; - case 171: /* select ::= SELECT selcollist */ + case 175: /* select ::= SELECT selcollist */ { - yylhsminor.yy56 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy421, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL); + yylhsminor.yy378 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy89, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL); } - yymsp[-1].minor.yy56 = yylhsminor.yy56; + yymsp[-1].minor.yy378 = yylhsminor.yy378; break; - case 172: /* sclp ::= selcollist COMMA */ -{yylhsminor.yy421 = yymsp[-1].minor.yy421;} - yymsp[-1].minor.yy421 = yylhsminor.yy421; + case 176: /* sclp ::= selcollist COMMA */ +{yylhsminor.yy89 = yymsp[-1].minor.yy89;} + yymsp[-1].minor.yy89 = yylhsminor.yy89; break; - case 173: /* sclp ::= */ - case 205: /* orderby_opt ::= */ yytestcase(yyruleno==205); -{yymsp[1].minor.yy421 = 0;} + case 177: /* sclp ::= */ + case 209: /* orderby_opt ::= */ yytestcase(yyruleno==209); +{yymsp[1].minor.yy89 = 0;} break; - case 174: /* selcollist ::= sclp distinct expr as */ + case 178: /* selcollist ::= sclp distinct expr as */ { - yylhsminor.yy421 = tSqlExprListAppend(yymsp[-3].minor.yy421, yymsp[-1].minor.yy439, yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0); + yylhsminor.yy89 = tSqlExprListAppend(yymsp[-3].minor.yy89, yymsp[-1].minor.yy342, yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0); } - yymsp[-3].minor.yy421 = yylhsminor.yy421; + yymsp[-3].minor.yy89 = yylhsminor.yy89; break; - case 175: /* selcollist ::= sclp STAR */ + case 179: /* selcollist ::= sclp STAR */ { tSqlExpr *pNode = tSqlExprCreateIdValue(NULL, TK_ALL); - yylhsminor.yy421 = tSqlExprListAppend(yymsp[-1].minor.yy421, pNode, 0, 0); + yylhsminor.yy89 = tSqlExprListAppend(yymsp[-1].minor.yy89, pNode, 0, 0); } - yymsp[-1].minor.yy421 = yylhsminor.yy421; + yymsp[-1].minor.yy89 = yylhsminor.yy89; break; - case 176: /* as ::= AS ids */ + case 180: /* as ::= AS ids */ { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; } break; - case 177: /* as ::= ids */ + case 181: /* as ::= ids */ { yylhsminor.yy0 = yymsp[0].minor.yy0; } yymsp[0].minor.yy0 = yylhsminor.yy0; break; - case 178: /* as ::= */ + case 182: /* as ::= */ { yymsp[1].minor.yy0.n = 0; } break; - case 179: /* distinct ::= DISTINCT */ + case 183: /* distinct ::= DISTINCT */ { yylhsminor.yy0 = yymsp[0].minor.yy0; } yymsp[0].minor.yy0 = yylhsminor.yy0; break; - case 181: /* from ::= FROM tablelist */ - case 182: /* from ::= FROM sub */ yytestcase(yyruleno==182); -{yymsp[-1].minor.yy8 = yymsp[0].minor.yy8;} + case 185: /* from ::= FROM tablelist */ + case 186: /* from ::= FROM sub */ yytestcase(yyruleno==186); +{yymsp[-1].minor.yy166 = yymsp[0].minor.yy166;} break; - case 183: /* sub ::= LP union RP */ -{yymsp[-2].minor.yy8 = addSubqueryElem(NULL, yymsp[-1].minor.yy421, NULL);} + case 187: /* sub ::= LP union RP */ +{yymsp[-2].minor.yy166 = addSubqueryElem(NULL, yymsp[-1].minor.yy89, NULL);} break; - case 184: /* sub ::= LP union RP ids */ -{yymsp[-3].minor.yy8 = addSubqueryElem(NULL, yymsp[-2].minor.yy421, &yymsp[0].minor.yy0);} + case 188: /* sub ::= LP union RP ids */ +{yymsp[-3].minor.yy166 = addSubqueryElem(NULL, yymsp[-2].minor.yy89, &yymsp[0].minor.yy0);} break; - case 185: /* sub ::= sub COMMA LP union RP ids */ -{yylhsminor.yy8 = addSubqueryElem(yymsp[-5].minor.yy8, yymsp[-2].minor.yy421, &yymsp[0].minor.yy0);} - yymsp[-5].minor.yy8 = yylhsminor.yy8; + case 189: /* sub ::= sub COMMA LP union RP ids */ +{yylhsminor.yy166 = addSubqueryElem(yymsp[-5].minor.yy166, yymsp[-2].minor.yy89, &yymsp[0].minor.yy0);} + yymsp[-5].minor.yy166 = yylhsminor.yy166; break; - case 186: /* tablelist ::= ids cpxName */ + case 190: /* tablelist ::= ids cpxName */ { yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; - yylhsminor.yy8 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL); + yylhsminor.yy166 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL); } - yymsp[-1].minor.yy8 = yylhsminor.yy8; + yymsp[-1].minor.yy166 = yylhsminor.yy166; break; - case 187: /* tablelist ::= ids cpxName ids */ + case 191: /* tablelist ::= ids cpxName ids */ { yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n; - yylhsminor.yy8 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); + yylhsminor.yy166 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } - yymsp[-2].minor.yy8 = yylhsminor.yy8; + yymsp[-2].minor.yy166 = yylhsminor.yy166; break; - case 188: /* tablelist ::= tablelist COMMA ids cpxName */ + case 192: /* tablelist ::= tablelist COMMA ids cpxName */ { yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; - yylhsminor.yy8 = setTableNameList(yymsp[-3].minor.yy8, &yymsp[-1].minor.yy0, NULL); + yylhsminor.yy166 = setTableNameList(yymsp[-3].minor.yy166, &yymsp[-1].minor.yy0, NULL); } - yymsp[-3].minor.yy8 = yylhsminor.yy8; + yymsp[-3].minor.yy166 = yylhsminor.yy166; break; - case 189: /* tablelist ::= tablelist COMMA ids cpxName ids */ + case 193: /* tablelist ::= tablelist COMMA ids cpxName ids */ { yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n; - yylhsminor.yy8 = setTableNameList(yymsp[-4].minor.yy8, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); + yylhsminor.yy166 = setTableNameList(yymsp[-4].minor.yy166, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } - yymsp[-4].minor.yy8 = yylhsminor.yy8; + yymsp[-4].minor.yy166 = yylhsminor.yy166; break; - case 190: /* tmvar ::= VARIABLE */ + case 194: /* tmvar ::= VARIABLE */ {yylhsminor.yy0 = yymsp[0].minor.yy0;} yymsp[0].minor.yy0 = yylhsminor.yy0; break; - case 191: /* interval_option ::= intervalKey LP tmvar RP */ -{yylhsminor.yy400.interval = yymsp[-1].minor.yy0; yylhsminor.yy400.offset.n = 0; yylhsminor.yy400.token = yymsp[-3].minor.yy104;} - yymsp[-3].minor.yy400 = yylhsminor.yy400; + case 195: /* interval_option ::= intervalKey LP tmvar RP */ +{yylhsminor.yy66.interval = yymsp[-1].minor.yy0; yylhsminor.yy66.offset.n = 0; yylhsminor.yy66.token = yymsp[-3].minor.yy130;} + yymsp[-3].minor.yy66 = yylhsminor.yy66; break; - case 192: /* interval_option ::= intervalKey LP tmvar COMMA tmvar RP */ -{yylhsminor.yy400.interval = yymsp[-3].minor.yy0; yylhsminor.yy400.offset = yymsp[-1].minor.yy0; yylhsminor.yy400.token = yymsp[-5].minor.yy104;} - yymsp[-5].minor.yy400 = yylhsminor.yy400; + case 196: /* interval_option ::= intervalKey LP tmvar COMMA tmvar RP */ +{yylhsminor.yy66.interval = yymsp[-3].minor.yy0; yylhsminor.yy66.offset = yymsp[-1].minor.yy0; yylhsminor.yy66.token = yymsp[-5].minor.yy130;} + yymsp[-5].minor.yy66 = yylhsminor.yy66; break; - case 193: /* interval_option ::= */ -{memset(&yymsp[1].minor.yy400, 0, sizeof(yymsp[1].minor.yy400));} + case 197: /* interval_option ::= */ +{memset(&yymsp[1].minor.yy66, 0, sizeof(yymsp[1].minor.yy66));} break; - case 194: /* intervalKey ::= INTERVAL */ -{yymsp[0].minor.yy104 = TK_INTERVAL;} + case 198: /* intervalKey ::= INTERVAL */ +{yymsp[0].minor.yy130 = TK_INTERVAL;} break; - case 195: /* intervalKey ::= EVERY */ -{yymsp[0].minor.yy104 = TK_EVERY; } + case 199: /* intervalKey ::= EVERY */ +{yymsp[0].minor.yy130 = TK_EVERY; } break; - case 196: /* session_option ::= */ -{yymsp[1].minor.yy147.col.n = 0; yymsp[1].minor.yy147.gap.n = 0;} + case 200: /* session_option ::= */ +{yymsp[1].minor.yy431.col.n = 0; yymsp[1].minor.yy431.gap.n = 0;} break; - case 197: /* session_option ::= SESSION LP ids cpxName COMMA tmvar RP */ + case 201: /* session_option ::= SESSION LP ids cpxName COMMA tmvar RP */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - yymsp[-6].minor.yy147.col = yymsp[-4].minor.yy0; - yymsp[-6].minor.yy147.gap = yymsp[-1].minor.yy0; + yymsp[-6].minor.yy431.col = yymsp[-4].minor.yy0; + yymsp[-6].minor.yy431.gap = yymsp[-1].minor.yy0; } break; - case 198: /* windowstate_option ::= */ -{ yymsp[1].minor.yy40.col.n = 0; yymsp[1].minor.yy40.col.z = NULL;} + case 202: /* windowstate_option ::= */ +{ yymsp[1].minor.yy392.col.n = 0; yymsp[1].minor.yy392.col.z = NULL;} break; - case 199: /* windowstate_option ::= STATE_WINDOW LP ids RP */ -{ yymsp[-3].minor.yy40.col = yymsp[-1].minor.yy0; } + case 203: /* windowstate_option ::= STATE_WINDOW LP ids RP */ +{ yymsp[-3].minor.yy392.col = yymsp[-1].minor.yy0; } break; - case 200: /* fill_opt ::= */ -{ yymsp[1].minor.yy421 = 0; } + case 204: /* fill_opt ::= */ +{ yymsp[1].minor.yy89 = 0; } break; - case 201: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */ + case 205: /* 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.yy421, &A, -1, 0); - yymsp[-5].minor.yy421 = yymsp[-1].minor.yy421; + tVariantListInsert(yymsp[-1].minor.yy89, &A, -1, 0); + yymsp[-5].minor.yy89 = yymsp[-1].minor.yy89; } break; - case 202: /* fill_opt ::= FILL LP ID RP */ + case 206: /* fill_opt ::= FILL LP ID RP */ { toTSDBType(yymsp[-1].minor.yy0.type); - yymsp[-3].minor.yy421 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1); + yymsp[-3].minor.yy89 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1); } break; - case 203: /* sliding_opt ::= SLIDING LP tmvar RP */ + case 207: /* sliding_opt ::= SLIDING LP tmvar RP */ {yymsp[-3].minor.yy0 = yymsp[-1].minor.yy0; } break; - case 204: /* sliding_opt ::= */ + case 208: /* sliding_opt ::= */ {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0; } break; - case 206: /* orderby_opt ::= ORDER BY sortlist */ -{yymsp[-2].minor.yy421 = yymsp[0].minor.yy421;} + case 210: /* orderby_opt ::= ORDER BY sortlist */ +{yymsp[-2].minor.yy89 = yymsp[0].minor.yy89;} break; - case 207: /* sortlist ::= sortlist COMMA item sortorder */ + case 211: /* sortlist ::= sortlist COMMA item sortorder */ { - yylhsminor.yy421 = tVariantListAppend(yymsp[-3].minor.yy421, &yymsp[-1].minor.yy430, yymsp[0].minor.yy96); + yylhsminor.yy89 = tVariantListAppend(yymsp[-3].minor.yy89, &yymsp[-1].minor.yy112, yymsp[0].minor.yy346); } - yymsp[-3].minor.yy421 = yylhsminor.yy421; + yymsp[-3].minor.yy89 = yylhsminor.yy89; break; - case 208: /* sortlist ::= item sortorder */ + case 212: /* sortlist ::= item sortorder */ { - yylhsminor.yy421 = tVariantListAppend(NULL, &yymsp[-1].minor.yy430, yymsp[0].minor.yy96); + yylhsminor.yy89 = tVariantListAppend(NULL, &yymsp[-1].minor.yy112, yymsp[0].minor.yy346); } - yymsp[-1].minor.yy421 = yylhsminor.yy421; + yymsp[-1].minor.yy89 = yylhsminor.yy89; break; - case 209: /* item ::= ids cpxName */ + case 213: /* item ::= ids cpxName */ { toTSDBType(yymsp[-1].minor.yy0.type); yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; - tVariantCreate(&yylhsminor.yy430, &yymsp[-1].minor.yy0); + tVariantCreate(&yylhsminor.yy112, &yymsp[-1].minor.yy0); } - yymsp[-1].minor.yy430 = yylhsminor.yy430; + yymsp[-1].minor.yy112 = yylhsminor.yy112; break; - case 210: /* sortorder ::= ASC */ -{ yymsp[0].minor.yy96 = TSDB_ORDER_ASC; } + case 214: /* sortorder ::= ASC */ +{ yymsp[0].minor.yy346 = TSDB_ORDER_ASC; } break; - case 211: /* sortorder ::= DESC */ -{ yymsp[0].minor.yy96 = TSDB_ORDER_DESC;} + case 215: /* sortorder ::= DESC */ +{ yymsp[0].minor.yy346 = TSDB_ORDER_DESC;} break; - case 212: /* sortorder ::= */ -{ yymsp[1].minor.yy96 = TSDB_ORDER_ASC; } + case 216: /* sortorder ::= */ +{ yymsp[1].minor.yy346 = TSDB_ORDER_ASC; } break; - case 213: /* groupby_opt ::= */ -{ yymsp[1].minor.yy421 = 0;} + case 217: /* groupby_opt ::= */ +{ yymsp[1].minor.yy89 = 0;} break; - case 214: /* groupby_opt ::= GROUP BY grouplist */ -{ yymsp[-2].minor.yy421 = yymsp[0].minor.yy421;} + case 218: /* groupby_opt ::= GROUP BY grouplist */ +{ yymsp[-2].minor.yy89 = yymsp[0].minor.yy89;} break; - case 215: /* grouplist ::= grouplist COMMA item */ + case 219: /* grouplist ::= grouplist COMMA item */ { - yylhsminor.yy421 = tVariantListAppend(yymsp[-2].minor.yy421, &yymsp[0].minor.yy430, -1); + yylhsminor.yy89 = tVariantListAppend(yymsp[-2].minor.yy89, &yymsp[0].minor.yy112, -1); } - yymsp[-2].minor.yy421 = yylhsminor.yy421; + yymsp[-2].minor.yy89 = yylhsminor.yy89; break; - case 216: /* grouplist ::= item */ + case 220: /* grouplist ::= item */ { - yylhsminor.yy421 = tVariantListAppend(NULL, &yymsp[0].minor.yy430, -1); + yylhsminor.yy89 = tVariantListAppend(NULL, &yymsp[0].minor.yy112, -1); } - yymsp[0].minor.yy421 = yylhsminor.yy421; + yymsp[0].minor.yy89 = yylhsminor.yy89; break; - case 217: /* having_opt ::= */ - case 227: /* where_opt ::= */ yytestcase(yyruleno==227); - case 269: /* expritem ::= */ yytestcase(yyruleno==269); -{yymsp[1].minor.yy439 = 0;} + case 221: /* having_opt ::= */ + case 231: /* where_opt ::= */ yytestcase(yyruleno==231); + case 273: /* expritem ::= */ yytestcase(yyruleno==273); +{yymsp[1].minor.yy342 = 0;} break; - case 218: /* having_opt ::= HAVING expr */ - case 228: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==228); -{yymsp[-1].minor.yy439 = yymsp[0].minor.yy439;} + case 222: /* having_opt ::= HAVING expr */ + case 232: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==232); +{yymsp[-1].minor.yy342 = yymsp[0].minor.yy342;} break; - case 219: /* limit_opt ::= */ - case 223: /* slimit_opt ::= */ yytestcase(yyruleno==223); -{yymsp[1].minor.yy166.limit = -1; yymsp[1].minor.yy166.offset = 0;} + case 223: /* limit_opt ::= */ + case 227: /* slimit_opt ::= */ yytestcase(yyruleno==227); +{yymsp[1].minor.yy372.limit = -1; yymsp[1].minor.yy372.offset = 0;} break; - case 220: /* limit_opt ::= LIMIT signed */ - case 224: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==224); -{yymsp[-1].minor.yy166.limit = yymsp[0].minor.yy325; yymsp[-1].minor.yy166.offset = 0;} + case 224: /* limit_opt ::= LIMIT signed */ + case 228: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==228); +{yymsp[-1].minor.yy372.limit = yymsp[0].minor.yy145; yymsp[-1].minor.yy372.offset = 0;} break; - case 221: /* limit_opt ::= LIMIT signed OFFSET signed */ -{ yymsp[-3].minor.yy166.limit = yymsp[-2].minor.yy325; yymsp[-3].minor.yy166.offset = yymsp[0].minor.yy325;} + case 225: /* limit_opt ::= LIMIT signed OFFSET signed */ +{ yymsp[-3].minor.yy372.limit = yymsp[-2].minor.yy145; yymsp[-3].minor.yy372.offset = yymsp[0].minor.yy145;} break; - case 222: /* limit_opt ::= LIMIT signed COMMA signed */ -{ yymsp[-3].minor.yy166.limit = yymsp[0].minor.yy325; yymsp[-3].minor.yy166.offset = yymsp[-2].minor.yy325;} + case 226: /* limit_opt ::= LIMIT signed COMMA signed */ +{ yymsp[-3].minor.yy372.limit = yymsp[0].minor.yy145; yymsp[-3].minor.yy372.offset = yymsp[-2].minor.yy145;} break; - case 225: /* slimit_opt ::= SLIMIT signed SOFFSET signed */ -{yymsp[-3].minor.yy166.limit = yymsp[-2].minor.yy325; yymsp[-3].minor.yy166.offset = yymsp[0].minor.yy325;} + case 229: /* slimit_opt ::= SLIMIT signed SOFFSET signed */ +{yymsp[-3].minor.yy372.limit = yymsp[-2].minor.yy145; yymsp[-3].minor.yy372.offset = yymsp[0].minor.yy145;} break; - case 226: /* slimit_opt ::= SLIMIT signed COMMA signed */ -{yymsp[-3].minor.yy166.limit = yymsp[0].minor.yy325; yymsp[-3].minor.yy166.offset = yymsp[-2].minor.yy325;} + case 230: /* slimit_opt ::= SLIMIT signed COMMA signed */ +{yymsp[-3].minor.yy372.limit = yymsp[0].minor.yy145; yymsp[-3].minor.yy372.offset = yymsp[-2].minor.yy145;} break; - case 229: /* expr ::= LP expr RP */ -{yylhsminor.yy439 = yymsp[-1].minor.yy439; yylhsminor.yy439->exprToken.z = yymsp[-2].minor.yy0.z; yylhsminor.yy439->exprToken.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);} - yymsp[-2].minor.yy439 = yylhsminor.yy439; + case 233: /* expr ::= LP expr RP */ +{yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342->exprToken.z = yymsp[-2].minor.yy0.z; yylhsminor.yy342->exprToken.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);} + yymsp[-2].minor.yy342 = yylhsminor.yy342; break; - case 230: /* expr ::= ID */ -{ yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_ID);} - yymsp[0].minor.yy439 = yylhsminor.yy439; + case 234: /* expr ::= ID */ +{ yylhsminor.yy342 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_ID);} + yymsp[0].minor.yy342 = yylhsminor.yy342; break; - case 231: /* expr ::= ID DOT ID */ -{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ID);} - yymsp[-2].minor.yy439 = yylhsminor.yy439; + case 235: /* expr ::= ID DOT ID */ +{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy342 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ID);} + yymsp[-2].minor.yy342 = yylhsminor.yy342; break; - case 232: /* expr ::= ID DOT STAR */ -{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ALL);} - yymsp[-2].minor.yy439 = yylhsminor.yy439; + case 236: /* expr ::= ID DOT STAR */ +{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy342 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ALL);} + yymsp[-2].minor.yy342 = yylhsminor.yy342; break; - case 233: /* expr ::= INTEGER */ -{ yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_INTEGER);} - yymsp[0].minor.yy439 = yylhsminor.yy439; + case 237: /* expr ::= INTEGER */ +{ yylhsminor.yy342 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_INTEGER);} + yymsp[0].minor.yy342 = yylhsminor.yy342; break; - case 234: /* expr ::= MINUS INTEGER */ - case 235: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==235); -{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_INTEGER);} - yymsp[-1].minor.yy439 = yylhsminor.yy439; + case 238: /* expr ::= MINUS INTEGER */ + case 239: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==239); +{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy342 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_INTEGER);} + yymsp[-1].minor.yy342 = yylhsminor.yy342; break; - case 236: /* expr ::= FLOAT */ -{ yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_FLOAT);} - yymsp[0].minor.yy439 = yylhsminor.yy439; + case 240: /* expr ::= FLOAT */ +{ yylhsminor.yy342 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_FLOAT);} + yymsp[0].minor.yy342 = yylhsminor.yy342; break; - case 237: /* expr ::= MINUS FLOAT */ - case 238: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==238); -{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_FLOAT);} - yymsp[-1].minor.yy439 = yylhsminor.yy439; + case 241: /* expr ::= MINUS FLOAT */ + case 242: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==242); +{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy342 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_FLOAT);} + yymsp[-1].minor.yy342 = yylhsminor.yy342; break; - case 239: /* expr ::= STRING */ -{ yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_STRING);} - yymsp[0].minor.yy439 = yylhsminor.yy439; + case 243: /* expr ::= STRING */ +{ yylhsminor.yy342 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_STRING);} + yymsp[0].minor.yy342 = yylhsminor.yy342; break; - case 240: /* expr ::= NOW */ -{ yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NOW); } - yymsp[0].minor.yy439 = yylhsminor.yy439; + case 244: /* expr ::= NOW */ +{ yylhsminor.yy342 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NOW); } + yymsp[0].minor.yy342 = yylhsminor.yy342; break; - case 241: /* expr ::= VARIABLE */ -{ yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_VARIABLE);} - yymsp[0].minor.yy439 = yylhsminor.yy439; + case 245: /* expr ::= VARIABLE */ +{ yylhsminor.yy342 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_VARIABLE);} + yymsp[0].minor.yy342 = yylhsminor.yy342; break; - case 242: /* expr ::= PLUS VARIABLE */ - case 243: /* expr ::= MINUS VARIABLE */ yytestcase(yyruleno==243); -{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_VARIABLE; yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_VARIABLE);} - yymsp[-1].minor.yy439 = yylhsminor.yy439; + case 246: /* expr ::= PLUS VARIABLE */ + case 247: /* expr ::= MINUS VARIABLE */ yytestcase(yyruleno==247); +{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_VARIABLE; yylhsminor.yy342 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_VARIABLE);} + yymsp[-1].minor.yy342 = yylhsminor.yy342; break; - case 244: /* expr ::= BOOL */ -{ yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_BOOL);} - yymsp[0].minor.yy439 = yylhsminor.yy439; + case 248: /* expr ::= BOOL */ +{ yylhsminor.yy342 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_BOOL);} + yymsp[0].minor.yy342 = yylhsminor.yy342; break; - case 245: /* expr ::= NULL */ -{ yylhsminor.yy439 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NULL);} - yymsp[0].minor.yy439 = yylhsminor.yy439; + case 249: /* expr ::= NULL */ +{ yylhsminor.yy342 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NULL);} + yymsp[0].minor.yy342 = yylhsminor.yy342; break; - case 246: /* expr ::= ID LP exprlist RP */ -{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy439 = tSqlExprCreateFunction(yymsp[-1].minor.yy421, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); } - yymsp[-3].minor.yy439 = yylhsminor.yy439; + case 250: /* expr ::= ID LP exprlist RP */ +{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy342 = tSqlExprCreateFunction(yymsp[-1].minor.yy89, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); } + yymsp[-3].minor.yy342 = yylhsminor.yy342; break; - case 247: /* expr ::= ID LP STAR RP */ -{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy439 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); } - yymsp[-3].minor.yy439 = yylhsminor.yy439; + case 251: /* expr ::= ID LP STAR RP */ +{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy342 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); } + yymsp[-3].minor.yy342 = yylhsminor.yy342; break; - case 248: /* expr ::= expr IS NULL */ -{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, NULL, TK_ISNULL);} - yymsp[-2].minor.yy439 = yylhsminor.yy439; + case 252: /* expr ::= expr IS NULL */ +{yylhsminor.yy342 = tSqlExprCreate(yymsp[-2].minor.yy342, NULL, TK_ISNULL);} + yymsp[-2].minor.yy342 = yylhsminor.yy342; break; - case 249: /* expr ::= expr IS NOT NULL */ -{yylhsminor.yy439 = tSqlExprCreate(yymsp[-3].minor.yy439, NULL, TK_NOTNULL);} - yymsp[-3].minor.yy439 = yylhsminor.yy439; + case 253: /* expr ::= expr IS NOT NULL */ +{yylhsminor.yy342 = tSqlExprCreate(yymsp[-3].minor.yy342, NULL, TK_NOTNULL);} + yymsp[-3].minor.yy342 = yylhsminor.yy342; break; - case 250: /* expr ::= expr LT expr */ -{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_LT);} - yymsp[-2].minor.yy439 = yylhsminor.yy439; + case 254: /* expr ::= expr LT expr */ +{yylhsminor.yy342 = tSqlExprCreate(yymsp[-2].minor.yy342, yymsp[0].minor.yy342, TK_LT);} + yymsp[-2].minor.yy342 = yylhsminor.yy342; break; - case 251: /* expr ::= expr GT expr */ -{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_GT);} - yymsp[-2].minor.yy439 = yylhsminor.yy439; + case 255: /* expr ::= expr GT expr */ +{yylhsminor.yy342 = tSqlExprCreate(yymsp[-2].minor.yy342, yymsp[0].minor.yy342, TK_GT);} + yymsp[-2].minor.yy342 = yylhsminor.yy342; break; - case 252: /* expr ::= expr LE expr */ -{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_LE);} - yymsp[-2].minor.yy439 = yylhsminor.yy439; + case 256: /* expr ::= expr LE expr */ +{yylhsminor.yy342 = tSqlExprCreate(yymsp[-2].minor.yy342, yymsp[0].minor.yy342, TK_LE);} + yymsp[-2].minor.yy342 = yylhsminor.yy342; break; - case 253: /* expr ::= expr GE expr */ -{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_GE);} - yymsp[-2].minor.yy439 = yylhsminor.yy439; + case 257: /* expr ::= expr GE expr */ +{yylhsminor.yy342 = tSqlExprCreate(yymsp[-2].minor.yy342, yymsp[0].minor.yy342, TK_GE);} + yymsp[-2].minor.yy342 = yylhsminor.yy342; break; - case 254: /* expr ::= expr NE expr */ -{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_NE);} - yymsp[-2].minor.yy439 = yylhsminor.yy439; + case 258: /* expr ::= expr NE expr */ +{yylhsminor.yy342 = tSqlExprCreate(yymsp[-2].minor.yy342, yymsp[0].minor.yy342, TK_NE);} + yymsp[-2].minor.yy342 = yylhsminor.yy342; break; - case 255: /* expr ::= expr EQ expr */ -{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_EQ);} - yymsp[-2].minor.yy439 = yylhsminor.yy439; + case 259: /* expr ::= expr EQ expr */ +{yylhsminor.yy342 = tSqlExprCreate(yymsp[-2].minor.yy342, yymsp[0].minor.yy342, TK_EQ);} + yymsp[-2].minor.yy342 = yylhsminor.yy342; break; - case 256: /* expr ::= expr BETWEEN expr AND expr */ -{ tSqlExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy439); yylhsminor.yy439 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy439, yymsp[-2].minor.yy439, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy439, TK_LE), TK_AND);} - yymsp[-4].minor.yy439 = yylhsminor.yy439; + case 260: /* expr ::= expr BETWEEN expr AND expr */ +{ tSqlExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy342); yylhsminor.yy342 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy342, yymsp[-2].minor.yy342, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy342, TK_LE), TK_AND);} + yymsp[-4].minor.yy342 = yylhsminor.yy342; break; - case 257: /* expr ::= expr AND expr */ -{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_AND);} - yymsp[-2].minor.yy439 = yylhsminor.yy439; + case 261: /* expr ::= expr AND expr */ +{yylhsminor.yy342 = tSqlExprCreate(yymsp[-2].minor.yy342, yymsp[0].minor.yy342, TK_AND);} + yymsp[-2].minor.yy342 = yylhsminor.yy342; break; - case 258: /* expr ::= expr OR expr */ -{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_OR); } - yymsp[-2].minor.yy439 = yylhsminor.yy439; + case 262: /* expr ::= expr OR expr */ +{yylhsminor.yy342 = tSqlExprCreate(yymsp[-2].minor.yy342, yymsp[0].minor.yy342, TK_OR); } + yymsp[-2].minor.yy342 = yylhsminor.yy342; break; - case 259: /* expr ::= expr PLUS expr */ -{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_PLUS); } - yymsp[-2].minor.yy439 = yylhsminor.yy439; + case 263: /* expr ::= expr PLUS expr */ +{yylhsminor.yy342 = tSqlExprCreate(yymsp[-2].minor.yy342, yymsp[0].minor.yy342, TK_PLUS); } + yymsp[-2].minor.yy342 = yylhsminor.yy342; break; - case 260: /* expr ::= expr MINUS expr */ -{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_MINUS); } - yymsp[-2].minor.yy439 = yylhsminor.yy439; + case 264: /* expr ::= expr MINUS expr */ +{yylhsminor.yy342 = tSqlExprCreate(yymsp[-2].minor.yy342, yymsp[0].minor.yy342, TK_MINUS); } + yymsp[-2].minor.yy342 = yylhsminor.yy342; break; - case 261: /* expr ::= expr STAR expr */ -{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_STAR); } - yymsp[-2].minor.yy439 = yylhsminor.yy439; + case 265: /* expr ::= expr STAR expr */ +{yylhsminor.yy342 = tSqlExprCreate(yymsp[-2].minor.yy342, yymsp[0].minor.yy342, TK_STAR); } + yymsp[-2].minor.yy342 = yylhsminor.yy342; break; - case 262: /* expr ::= expr SLASH expr */ -{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_DIVIDE);} - yymsp[-2].minor.yy439 = yylhsminor.yy439; + case 266: /* expr ::= expr SLASH expr */ +{yylhsminor.yy342 = tSqlExprCreate(yymsp[-2].minor.yy342, yymsp[0].minor.yy342, TK_DIVIDE);} + yymsp[-2].minor.yy342 = yylhsminor.yy342; break; - case 263: /* expr ::= expr REM expr */ -{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_REM); } - yymsp[-2].minor.yy439 = yylhsminor.yy439; + case 267: /* expr ::= expr REM expr */ +{yylhsminor.yy342 = tSqlExprCreate(yymsp[-2].minor.yy342, yymsp[0].minor.yy342, TK_REM); } + yymsp[-2].minor.yy342 = yylhsminor.yy342; break; - case 264: /* expr ::= expr LIKE expr */ -{yylhsminor.yy439 = tSqlExprCreate(yymsp[-2].minor.yy439, yymsp[0].minor.yy439, TK_LIKE); } - yymsp[-2].minor.yy439 = yylhsminor.yy439; + case 268: /* expr ::= expr LIKE expr */ +{yylhsminor.yy342 = tSqlExprCreate(yymsp[-2].minor.yy342, yymsp[0].minor.yy342, TK_LIKE); } + yymsp[-2].minor.yy342 = yylhsminor.yy342; break; - case 265: /* expr ::= expr IN LP exprlist RP */ -{yylhsminor.yy439 = tSqlExprCreate(yymsp[-4].minor.yy439, (tSqlExpr*)yymsp[-1].minor.yy421, TK_IN); } - yymsp[-4].minor.yy439 = yylhsminor.yy439; + case 269: /* expr ::= expr IN LP exprlist RP */ +{yylhsminor.yy342 = tSqlExprCreate(yymsp[-4].minor.yy342, (tSqlExpr*)yymsp[-1].minor.yy89, TK_IN); } + yymsp[-4].minor.yy342 = yylhsminor.yy342; break; - case 266: /* exprlist ::= exprlist COMMA expritem */ -{yylhsminor.yy421 = tSqlExprListAppend(yymsp[-2].minor.yy421,yymsp[0].minor.yy439,0, 0);} - yymsp[-2].minor.yy421 = yylhsminor.yy421; + case 270: /* exprlist ::= exprlist COMMA expritem */ +{yylhsminor.yy89 = tSqlExprListAppend(yymsp[-2].minor.yy89,yymsp[0].minor.yy342,0, 0);} + yymsp[-2].minor.yy89 = yylhsminor.yy89; break; - case 267: /* exprlist ::= expritem */ -{yylhsminor.yy421 = tSqlExprListAppend(0,yymsp[0].minor.yy439,0, 0);} - yymsp[0].minor.yy421 = yylhsminor.yy421; + case 271: /* exprlist ::= expritem */ +{yylhsminor.yy89 = tSqlExprListAppend(0,yymsp[0].minor.yy342,0, 0);} + yymsp[0].minor.yy89 = yylhsminor.yy89; break; - case 268: /* expritem ::= expr */ -{yylhsminor.yy439 = yymsp[0].minor.yy439;} - yymsp[0].minor.yy439 = yylhsminor.yy439; + case 272: /* expritem ::= expr */ +{yylhsminor.yy342 = yymsp[0].minor.yy342;} + yymsp[0].minor.yy342 = yylhsminor.yy342; break; - case 270: /* cmd ::= RESET QUERY CACHE */ + case 274: /* cmd ::= RESET QUERY CACHE */ { setDCLSqlElems(pInfo, TSDB_SQL_RESET_CACHE, 0);} break; - case 271: /* cmd ::= SYNCDB ids REPLICA */ + case 275: /* cmd ::= SYNCDB ids REPLICA */ { setDCLSqlElems(pInfo, TSDB_SQL_SYNC_DB_REPLICA, 1, &yymsp[-1].minor.yy0);} break; - case 272: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */ + case 276: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy421, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1); + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy89, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 273: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */ + case 277: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; @@ -3173,21 +3204,21 @@ static YYACTIONTYPE yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 274: /* cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */ + case 278: /* cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy421, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1); + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy89, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 275: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ + case 279: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy421, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1); + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy89, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 276: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ + case 280: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; @@ -3198,7 +3229,7 @@ static YYACTIONTYPE yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 277: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ + case 281: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ { yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n; @@ -3212,33 +3243,33 @@ static YYACTIONTYPE yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 278: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ + case 282: /* 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.yy430, -1); + A = tVariantListAppend(A, &yymsp[0].minor.yy112, -1); SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, -1); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 279: /* cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */ + case 283: /* cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy421, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, -1); + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy89, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, -1); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 280: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ + case 284: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy421, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE); + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy89, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 281: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ + case 285: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; @@ -3249,21 +3280,21 @@ static YYACTIONTYPE yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 282: /* cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */ + case 286: /* cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy421, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE); + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy89, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 283: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ + case 287: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy421, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE); + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy89, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 284: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ + case 288: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; @@ -3274,7 +3305,7 @@ static YYACTIONTYPE yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 285: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ + case 289: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ { yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n; @@ -3288,32 +3319,32 @@ static YYACTIONTYPE yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 286: /* cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */ + case 290: /* cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */ { yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n; toTSDBType(yymsp[-2].minor.yy0.type); SArray* A = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1); - A = tVariantListAppend(A, &yymsp[0].minor.yy430, -1); + A = tVariantListAppend(A, &yymsp[0].minor.yy112, -1); SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, TSDB_SUPER_TABLE); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 287: /* cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */ + case 291: /* cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; - SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy421, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, TSDB_SUPER_TABLE); + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy89, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, TSDB_SUPER_TABLE); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 288: /* cmd ::= KILL CONNECTION INTEGER */ + case 292: /* cmd ::= KILL CONNECTION INTEGER */ {setKillSql(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);} break; - case 289: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */ + case 293: /* 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 290: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */ + case 294: /* 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: diff --git a/src/util/inc/ttoken.h b/src/util/inc/ttoken.h index f62329183f82a57bcf65d136aaec65d8babd5f71..17f2bf5a79f9dd2c6650e4b0cb24a492c4d68e3a 100644 --- a/src/util/inc/ttoken.h +++ b/src/util/inc/ttoken.h @@ -63,6 +63,15 @@ uint32_t tGetToken(char *z, uint32_t *tokenType); */ SStrToken tStrGetToken(char *str, int32_t *i, bool isPrevOptr); +/** + * strcpy implement source from SStrToken + * + * @param dst copy to + * @param srcToken copy from + * @return size of copy successful bytes, not include '\0' + */ +int32_t tStrNCpy(char *dst, SStrToken* srcToken); + /** * check if it is a keyword or not * @param z diff --git a/src/util/src/ttokenizer.c b/src/util/src/ttokenizer.c index 9bc336d9e8bb41e76268641af7ca8c979ebb1c94..cd66f7c6406afbf67a080baea065744e36e7b896 100644 --- a/src/util/src/ttokenizer.c +++ b/src/util/src/ttokenizer.c @@ -227,6 +227,8 @@ static SKeyword keywordTable[] = { {"OUTPUTTYPE", TK_OUTPUTTYPE}, {"AGGREGATE", TK_AGGREGATE}, {"BUFSIZE", TK_BUFSIZE}, + {"TO", TK_TO}, + {"SPLIT", TK_SPLIT}, }; static const char isIdChar[] = { @@ -676,6 +678,18 @@ SStrToken tStrGetToken(char* str, int32_t* i, bool isPrevOptr) { return t0; } +/** + * strcpy implement source from SStrToken + * + * @param dst copy to + * @param srcToken copy from + * @return size of copy successful bytes + */ +int32_t tStrNCpy(char *dst, SStrToken* srcToken) { + strncpy(dst, srcToken->z, srcToken->n); + return srcToken->n; +} + bool taosIsKeyWordToken(const char* z, int32_t len) { return (tKeywordCode((char*)z, len) != TK_ID); }