Skip to content

TDengine
TDengine

adminstrot / TDengine
与 Fork 源项目一致

Fork自 taosdata / TDengine

通知 1
Star 1
Fork 0
TDengine
TDengine

体验新版 GitCode，发现更多精彩内容 >>

提交 40b3b5a4 编写于 作者: H Haojun Liao
浏览文件
操作

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

上级 261adee9
隐藏空白更改
内联 并排
Showing with 1397 addition and 1184 deletion
src/client/inc/tscUtil.h
浏览文件 @ 40b3b5a4
......@@ -234,7 +234,7 @@ void tscVgroupTableCopy(SVgroupTableInfo* info, SVgroupTableInfo* pInfo);
int tscGetSTableVgroupInfo(SSqlObj* pSql, int32_t clauseIndex);
int tscGetTableMeta(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo);
int tscGetMeterMetaEx(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, bool createIfNotExists);
int tscGetTableMetaEx(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, bool createIfNotExists);
void tscResetForNextRetrieve(SSqlRes* pRes);
void tscDoQuery(SSqlObj* pSql);
......@@ -287,6 +287,9 @@ bool tscSetSqlOwner(SSqlObj* pSql);
void tscClearSqlOwner(SSqlObj* pSql);
int32_t doArithmeticCalculate(SQueryInfo* pQueryInfo, tFilePage* pOutput, int32_t rowSize, int32_t finalRowSize);
char* serializeTagData(STagData* pTagData, char* pMsg);
int32_t copyTagData(STagData* dst, const STagData* src);
void* malloc_throw(size_t size);
void* calloc_throw(size_t nmemb, size_t size);
char* strdup_throw(const char* str);
......
src/client/inc/tsclient.h
浏览文件 @ 40b3b5a4
......@@ -246,7 +246,7 @@ typedef struct {
int8_t dataSourceType; // load data from file or not
int8_t submitSchema; // submit block is built with table schema
STagData *pTagData; // NOTE: pTagData->data is used as a variant length array
STagData tagData; // NOTE: pTagData->data is used as a variant length array
STableMeta **pTableMetaList; // all involved tableMeta list of current insert sql statement.
int32_t numOfTables;
......
src/client/src/tscParseInsert.c
浏览文件 @ 40b3b5a4
......@@ -796,8 +796,6 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
sToken = tStrGetToken(sql, &index, false, 0, NULL);
sql += index;
tscAllocPayload(pCmd, sizeof(STagData));
//the source super table is moved to the secondary position of the pTableMetaInfo list
if (pQueryInfo->numOfTables < 2) {
tscAddEmptyMetaInfo(pQueryInfo);
......@@ -809,13 +807,8 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
return code;
}
STagData *pTag = realloc(pCmd->pTagData, offsetof(STagData, data));
if (pTag == NULL) {
return TSDB_CODE_TSC_OUT_OF_MEMORY;
}
memset(pTag, 0, offsetof(STagData, data));
tstrncpy(pTag->name, pSTableMeterMetaInfo->name, sizeof(pTag->name));
pCmd->pTagData = pTag;
tstrncpy(pCmd->tagData.name, pSTableMeterMetaInfo->name, sizeof(pCmd->tagData.name));
pCmd->tagData.dataLen = 0;
code = tscGetTableMeta(pSql, pSTableMeterMetaInfo);
if (code != TSDB_CODE_SUCCESS) {
......@@ -946,14 +939,15 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
}
tdSortKVRowByColIdx(row);
pTag = (STagData*)realloc(pCmd->pTagData, offsetof(STagData, data) + kvRowLen(row));
pCmd->tagData.dataLen = kvRowLen(row);
char* pTag = realloc(pCmd->tagData.data, pCmd->tagData.dataLen);
if (pTag == NULL) {
return TSDB_CODE_TSC_OUT_OF_MEMORY;
}
pCmd->pTagData = pTag;
pTag->dataLen = htonl(kvRowLen(row));
kvRowCpy(pTag->data, row);
kvRowCpy(pTag, row);
free(row);
pCmd->tagData.data = pTag;
index = 0;
sToken = tStrGetToken(sql, &index, false, 0, NULL);
......@@ -972,7 +966,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
}
createTable = true;
code = tscGetMeterMetaEx(pSql, pTableMetaInfo, true);
code = tscGetTableMetaEx(pSql, pTableMetaInfo, true);
if (TSDB_CODE_TSC_ACTION_IN_PROGRESS == code) {
return code;
}
......@@ -983,7 +977,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
} else {
sql = sToken.z;
}
code = tscGetMeterMetaEx(pSql, pTableMetaInfo, false);
code = tscGetTableMetaEx(pSql, pTableMetaInfo, false);
if (pCmd->curSql == NULL) {
assert(code == TSDB_CODE_TSC_ACTION_IN_PROGRESS);
......
src/client/src/tscSQLParser.c
浏览文件 @ 40b3b5a4
......@@ -1775,12 +1775,15 @@ void setResultColName(char* name, tSQLExprItem* pItem, int32_t functionId, SStrT
int32_t len = MIN(pToken->n + 1, TSDB_COL_NAME_LEN);
tstrncpy(uname, pToken->z, len);
int32_t size = TSDB_COL_NAME_LEN + tListLen(aAggs[functionId].aName) + 2 + 1;
char tmp[TSDB_COL_NAME_LEN + tListLen(aAggs[functionId].aName) + 2 + 1] = {0};
snprintf(tmp, size, "%s(%s)", aAggs[functionId].aName, uname);
if (tsKeepOriginalColumnName) { // keep the original column name
tstrncpy(name, uname, TSDB_COL_NAME_LEN);
} else {
int32_t size = TSDB_COL_NAME_LEN + tListLen(aAggs[functionId].aName) + 2 + 1;
char tmp[TSDB_COL_NAME_LEN + tListLen(aAggs[functionId].aName) + 2 + 1] = {0};
snprintf(tmp, size, "%s(%s)", aAggs[functionId].aName, uname);
tstrncpy(name, tmp, TSDB_COL_NAME_LEN);
tstrncpy(name, tmp, TSDB_COL_NAME_LEN);
}
} else { // use the user-input result column name
int32_t len = MIN(pItem->pNode->token.n + 1, TSDB_COL_NAME_LEN);
tstrncpy(name, pItem->pNode->token.z, len);
......@@ -4910,6 +4913,8 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
tVariantListItem* pItem = taosArrayGet(pVarList, 1);
SSchema* pTagsSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, columnIndex.columnIndex);
pAlterSQL->tagData.data = calloc(1, pTagsSchema->bytes * TSDB_NCHAR_SIZE + VARSTR_HEADER_SIZE);
if (tVariantDump(&pItem->pVar, pAlterSQL->tagData.data, pTagsSchema->type, true) != TSDB_CODE_SUCCESS) {
return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg13);
}
......@@ -6149,96 +6154,105 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
const int32_t TABLE_INDEX = 0;
const int32_t STABLE_INDEX = 1;
STableMetaInfo* pStableMeterMetaInfo = tscGetMetaInfo(pQueryInfo, STABLE_INDEX);
STableMetaInfo* pStableMetaInfo = tscGetMetaInfo(pQueryInfo, STABLE_INDEX);
// super table name, create table by using dst
SStrToken* pToken = &(pCreateTable->usingInfo.stableName);
int32_t numOfTables = taosArrayGetSize(pCreateTable->childTableInfo);
for(int32_t j = 0; j < numOfTables; ++j) {
SCreatedTableInfo* pCreateTableInfo = taosArrayGet(pCreateTable->childTableInfo, j);
if (tscValidateName(pToken) != TSDB_CODE_SUCCESS) {
return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
}
SStrToken* pToken = &pCreateTableInfo->stableName;
if (tscValidateName(pToken) != TSDB_CODE_SUCCESS) {
return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
}
int32_t code = tscSetTableFullName(pStableMeterMetaInfo, pToken, pSql);
if (code != TSDB_CODE_SUCCESS) {
return code;
}
int32_t code = tscSetTableFullName(pStableMetaInfo, pToken, pSql);
if (code != TSDB_CODE_SUCCESS) {
return code;
}
// get meter meta from mnode
tstrncpy(pCreateTable->usingInfo.tagdata.name, pStableMeterMetaInfo->name, sizeof(pCreateTable->usingInfo.tagdata.name));
SArray* pList = pInfo->pCreateTableInfo->usingInfo.pTagVals;
// get table meta from mnode
tstrncpy(pCreateTableInfo->tagdata.name, pStableMetaInfo->name, tListLen(pCreateTableInfo->tagdata.name));
SArray* pList = pCreateTableInfo->pTagVals;
code = tscGetTableMeta(pSql, pStableMeterMetaInfo);
if (code != TSDB_CODE_SUCCESS) {
return code;
}
code = tscGetTableMeta(pSql, pStableMetaInfo);
if (code != TSDB_CODE_SUCCESS) {
return code;
}
size_t size = taosArrayGetSize(pList);
if (tscGetNumOfTags(pStableMeterMetaInfo->pTableMeta) != size) {
return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
}
size_t size = taosArrayGetSize(pList);
if (tscGetNumOfTags(pStableMetaInfo->pTableMeta) != size) {
return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
}
// too long tag values will return invalid sql, not be truncated automatically
SSchema* pTagSchema = tscGetTableTagSchema(pStableMeterMetaInfo->pTableMeta);
// too long tag values will return invalid sql, not be truncated automatically
SSchema *pTagSchema = tscGetTableTagSchema(pStableMetaInfo->pTableMeta);
STagData *pTag = &pCreateTableInfo->tagdata;
STagData* pTag = &pCreateTable->usingInfo.tagdata;
SKVRowBuilder kvRowBuilder = {0};
if (tdInitKVRowBuilder(&kvRowBuilder) < 0) {
return TSDB_CODE_TSC_OUT_OF_MEMORY;
}
SKVRowBuilder kvRowBuilder = {0};
if (tdInitKVRowBuilder(&kvRowBuilder) < 0) {
return TSDB_CODE_TSC_OUT_OF_MEMORY;
}
int32_t ret = TSDB_CODE_SUCCESS;
for (int32_t i = 0; i < size; ++i) {
SSchema* pSchema = &pTagSchema[i];
tVariantListItem* pItem = taosArrayGet(pList, i);
int32_t ret = TSDB_CODE_SUCCESS;
for (int32_t i = 0; i < size; ++i) {
SSchema* pSchema = &pTagSchema[i];
tVariantListItem* pItem = taosArrayGet(pList, i);
char tagVal[TSDB_MAX_TAGS_LEN];
if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) {
if (pItem->pVar.nLen > pSchema->bytes) {
tdDestroyKVRowBuilder(&kvRowBuilder);
return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
char tagVal[TSDB_MAX_TAGS_LEN];
if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) {
if (pItem->pVar.nLen > pSchema->bytes) {
tdDestroyKVRowBuilder(&kvRowBuilder);
return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
}
}
}
ret = tVariantDump(&(pItem->pVar), tagVal, pSchema->type, true);
ret = tVariantDump(&(pItem->pVar), tagVal, pSchema->type, true);
// check again after the convert since it may be converted from binary to nchar.
if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) {
int16_t len = varDataTLen(tagVal);
if (len > pSchema->bytes) {
// check again after the convert since it may be converted from binary to nchar.
if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) {
int16_t len = varDataTLen(tagVal);
if (len > pSchema->bytes) {
tdDestroyKVRowBuilder(&kvRowBuilder);
return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
}
}
if (ret != TSDB_CODE_SUCCESS) {
tdDestroyKVRowBuilder(&kvRowBuilder);
return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
}
}
if (ret != TSDB_CODE_SUCCESS) {
tdDestroyKVRowBuilder(&kvRowBuilder);
return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
tdAddColToKVRow(&kvRowBuilder, pSchema->colId, pSchema->type, tagVal);
}
SKVRow row = tdGetKVRowFromBuilder(&kvRowBuilder);
tdDestroyKVRowBuilder(&kvRowBuilder);
if (row == NULL) {
return TSDB_CODE_TSC_OUT_OF_MEMORY;
}
tdSortKVRowByColIdx(row);
pTag->dataLen = kvRowLen(row);
if (pTag->data == NULL) {
pTag->data = malloc(pTag->dataLen);
}
tdAddColToKVRow(&kvRowBuilder, pSchema->colId, pSchema->type, tagVal);
}
kvRowCpy(pTag->data, row);
free(row);
SKVRow row = tdGetKVRowFromBuilder(&kvRowBuilder);
tdDestroyKVRowBuilder(&kvRowBuilder);
if (row == NULL) {
return TSDB_CODE_TSC_OUT_OF_MEMORY;
}
tdSortKVRowByColIdx(row);
pTag->dataLen = kvRowLen(row);
kvRowCpy(pTag->data, row);
free(row);
// table name
if (tscValidateName(&(pCreateTableInfo->name)) != TSDB_CODE_SUCCESS) {
return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
}
// table name
if (tscValidateName(&pInfo->pCreateTableInfo->name) != TSDB_CODE_SUCCESS) {
return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
}
STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, TABLE_INDEX);
ret = tscSetTableFullName(pTableMetaInfo, &pCreateTableInfo->name, pSql);
if (ret != TSDB_CODE_SUCCESS) {
return ret;
}
STableMetaInfo* pTableMeterMetaInfo = tscGetMetaInfo(pQueryInfo, TABLE_INDEX);
ret = tscSetTableFullName(pTableMeterMetaInfo, &pInfo->pCreateTableInfo->name, pSql);
if (ret != TSDB_CODE_SUCCESS) {
return ret;
pCreateTableInfo->fullname = strndup(pTableMetaInfo->name, TSDB_TABLE_FNAME_LEN);
}
return TSDB_CODE_SUCCESS;
......
src/client/src/tscServer.c
浏览文件 @ 40b3b5a4
......@@ -185,7 +185,7 @@ void tscProcessHeartBeatRsp(void *param, TAOS_RES *tres, int code) {
pSql->res.code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
}
if (pRes->buffer == NULL) {
if (pRes->length == NULL) {
pRes->length = calloc(2, sizeof(int32_t));
}
......@@ -193,7 +193,7 @@ void tscProcessHeartBeatRsp(void *param, TAOS_RES *tres, int code) {
pRes->length[1] = online;
} else {
tscDebug("%" PRId64 " heartbeat failed, code:%s", pObj->hbrid, tstrerror(code));
if (pRes->buffer == NULL) {
if (pRes->length == NULL) {
pRes->length = calloc(2, sizeof(int32_t));
}
......@@ -1267,10 +1267,10 @@ int32_t tscBuildKillMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
return TSDB_CODE_SUCCESS;
}
// TODO update it
int tscEstimateCreateTableMsgLength(SSqlObj *pSql, SSqlInfo *pInfo) {
SSqlCmd *pCmd = &(pSql->cmd);
int32_t size = minMsgSize() + sizeof(SCMCreateTableMsg);
int32_t size = minMsgSize() + sizeof(SCMCreateTableMsg) + sizeof(SCreatedTableInfo);
SCreateTableSQL *pCreateTableInfo = pInfo->pCreateTableInfo;
if (pCreateTableInfo->type == TSQL_CREATE_TABLE_FROM_STABLE) {
......@@ -1302,33 +1302,55 @@ int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
return TSDB_CODE_TSC_OUT_OF_MEMORY;
}
SCMCreateTableMsg *pCreateTableMsg = (SCMCreateTableMsg *)pCmd->payload;
strcpy(pCreateTableMsg->tableId, pTableMetaInfo->name);
// use dbinfo from table id without modifying current db info
tscGetDBInfoFromTableFullName(pTableMetaInfo->name, pCreateTableMsg->db);
SCreateTableMsg* pCreateMsg = (SCreateTableMsg*)((char*) pCreateTableMsg + sizeof(SCMCreateTableMsg));
char* pMsg = NULL;
SCreateTableSQL *pCreateTable = pInfo->pCreateTableInfo;
int8_t type = pInfo->pCreateTableInfo->type;
if (type == TSQL_CREATE_TABLE_FROM_STABLE) { // create by using super table, tags value
SArray* list = pInfo->pCreateTableInfo->childTableInfo;
pCreateTableMsg->igExists = pCreateTable->existCheck ? 1 : 0;
pCreateTableMsg->numOfColumns = htons(pCmd->numOfCols);
pCreateTableMsg->numOfTags = htons(pCmd->count);
int32_t numOfTables = taosArrayGetSize(list);
pCreateTableMsg->numOfTables = htonl(numOfTables);
pCreateTableMsg->sqlLen = 0;
char *pMsg = (char *)pCreateTableMsg->schema;
pMsg = (char*) pCreateMsg;
for(int32_t i = 0; i < numOfTables; ++i) {
SCreateTableMsg* pCreate = (SCreateTableMsg*) pMsg;
int8_t type = pInfo->pCreateTableInfo->type;
if (type == TSQL_CREATE_TABLE_FROM_STABLE) { // create by using super table, tags value
STagData* pTag = &pInfo->pCreateTableInfo->usingInfo.tagdata;
*(int32_t*)pMsg = htonl(pTag->dataLen);
pMsg += sizeof(int32_t);
memcpy(pMsg, pTag->name, sizeof(pTag->name));
pMsg += sizeof(pTag->name);
memcpy(pMsg, pTag->data, pTag->dataLen);
pMsg += pTag->dataLen;
pCreate->numOfColumns = htons(pCmd->numOfCols);
pCreate->numOfTags = htons(pCmd->count);
pMsg += sizeof(SCreateTableMsg);
SCreatedTableInfo* p = taosArrayGet(list, i);
strcpy(pCreate->tableId, p->fullname);
pCreate->igExists = (p->igExist)? 1 : 0;
// use dbinfo from table id without modifying current db info
tscGetDBInfoFromTableFullName(p->fullname, pCreate->db);
pMsg = serializeTagData(&p->tagdata, pMsg);
int32_t len = pMsg - (char*) pCreate;
pCreate->len = htonl(len);
}
} else { // create (super) table
pSchema = (SSchema *)pCreateTableMsg->schema;
pCreateTableMsg->numOfTables = htonl(1); // only one table will be created
strcpy(pCreateMsg->tableId, pTableMetaInfo->name);
// use dbinfo from table id without modifying current db info
tscGetDBInfoFromTableFullName(pTableMetaInfo->name, pCreateMsg->db);
SCreateTableSQL *pCreateTable = pInfo->pCreateTableInfo;
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;
for (int i = 0; i < pCmd->numOfCols + pCmd->count; ++i) {
TAOS_FIELD *pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, i);
......@@ -1345,7 +1367,7 @@ int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
SQuerySQL *pQuerySql = pInfo->pCreateTableInfo->pSelect;
strncpy(pMsg, pQuerySql->selectToken.z, pQuerySql->selectToken.n + 1);
pCreateTableMsg->sqlLen = htons(pQuerySql->selectToken.n + 1);
pCreateMsg->sqlLen = htons(pQuerySql->selectToken.n + 1);
pMsg += pQuerySql->selectToken.n + 1;
}
}
......@@ -1622,13 +1644,8 @@ int tscBuildTableMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
char *pMsg = (char *)pInfoMsg + sizeof(STableInfoMsg);
if (pCmd->autoCreated && pCmd->pTagData != NULL) {
int len = htonl(pCmd->pTagData->dataLen);
if (len > 0) {
len += sizeof(pCmd->pTagData->name) + sizeof(pCmd->pTagData->dataLen);
memcpy(pInfoMsg->tags, pCmd->pTagData, len);
pMsg += len;
}
if (pCmd->autoCreated && pCmd->tagData.dataLen != 0) {
pMsg = serializeTagData(&pCmd->tagData, pMsg);
}
pCmd->payloadLen = (int32_t)(pMsg - (char*)pInfoMsg);
......@@ -2174,10 +2191,7 @@ int tscProcessDropTableRsp(SSqlObj *pSql) {
*/
tscDebug("%p force release table meta after drop table:%s", pSql, pTableMetaInfo->name);
taosCacheRelease(tscMetaCache, (void **)&pTableMeta, true);
if (pTableMetaInfo->pTableMeta) {
taosCacheRelease(tscMetaCache, (void **)&(pTableMetaInfo->pTableMeta), true);
}
assert(pTableMetaInfo->pTableMeta == NULL);
return 0;
}
......@@ -2285,7 +2299,7 @@ int tscProcessRetrieveRspFromNode(SSqlObj *pSql) {
void tscTableMetaCallBack(void *param, TAOS_RES *res, int code);
static int32_t getTableMetaFromMgmt(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
static int32_t getTableMetaFromMnode(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
SSqlObj *pNew = calloc(1, sizeof(SSqlObj));
if (NULL == pNew) {
tscError("%p malloc failed for new sqlobj to get table meta", pSql);
......@@ -2312,15 +2326,13 @@ static int32_t getTableMetaFromMgmt(SSqlObj *pSql, STableMetaInfo *pTableMetaInf
tstrncpy(pNewMeterMetaInfo->name, pTableMetaInfo->name, sizeof(pNewMeterMetaInfo->name));
if (pSql->cmd.pTagData != NULL) {
int size = offsetof(STagData, data) + htonl(pSql->cmd.pTagData->dataLen);
pNew->cmd.pTagData = calloc(1, size);
if (pNew->cmd.pTagData == NULL) {
if (pSql->cmd.autoCreated) {
int32_t code = copyTagData(&pNew->cmd.tagData, &pSql->cmd.tagData);
if (code != TSDB_CODE_SUCCESS) {
tscError("%p malloc failed for new tag data to get table meta", pSql);
tscFreeSqlObj(pNew);
return TSDB_CODE_TSC_OUT_OF_MEMORY;
}
memcpy(pNew->cmd.pTagData, pSql->cmd.pTagData, size);
}
tscDebug("%p new pSqlObj:%p to get tableMeta, auto create:%d", pSql, pNew, pNew->cmd.autoCreated);
......@@ -2355,10 +2367,10 @@ int32_t tscGetTableMeta(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
return TSDB_CODE_SUCCESS;
}
return getTableMetaFromMgmt(pSql, pTableMetaInfo);
return getTableMetaFromMnode(pSql, pTableMetaInfo);
}
int tscGetMeterMetaEx(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo, bool createIfNotExists) {
int tscGetTableMetaEx(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo, bool createIfNotExists) {
pSql->cmd.autoCreated = createIfNotExists;
return tscGetTableMeta(pSql, pTableMetaInfo);
}
......@@ -2382,7 +2394,7 @@ int tscRenewTableMeta(SSqlObj *pSql, int32_t tableIndex) {
}
taosCacheRelease(tscMetaCache, (void **)&(pTableMetaInfo->pTableMeta), true);
return getTableMetaFromMgmt(pSql, pTableMetaInfo);
return getTableMetaFromMnode(pSql, pTableMetaInfo);
}
static bool allVgroupInfoRetrieved(SSqlCmd* pCmd, int32_t clauseIndex) {
......
src/client/src/tscUtil.c
浏览文件 @ 40b3b5a4
......@@ -518,7 +518,8 @@ void tscFreeSqlObj(SSqlObj* pSql) {
tscFreeSqlResult(pSql);
tscResetSqlCmdObj(pCmd, false);
tfree(pCmd->pTagData);
tfree(pCmd->tagData.data);
pCmd->tagData.dataLen = 0;
memset(pCmd->payload, 0, (size_t)pCmd->allocSize);
tfree(pCmd->payload);
......@@ -1937,15 +1938,11 @@ SSqlObj* createSimpleSubObj(SSqlObj* pSql, void (*fp)(), void* param, int32_t cm
pCmd->parseFinished = 1;
pCmd->autoCreated = pSql->cmd.autoCreated;
if (pSql->cmd.pTagData != NULL) {
int size = offsetof(STagData, data) + htonl(pSql->cmd.pTagData->dataLen);
pNew->cmd.pTagData = calloc(1, size);
if (pNew->cmd.pTagData == NULL) {
tscError("%p new subquery failed, unable to malloc tag data, tableIndex:%d", pSql, 0);
free(pNew);
return NULL;
}
memcpy(pNew->cmd.pTagData, pSql->cmd.pTagData, size);
int32_t code = copyTagData(&pNew->cmd.tagData, &pSql->cmd.tagData);
if (code != TSDB_CODE_SUCCESS) {
tscError("%p new subquery failed, unable to malloc tag data, tableIndex:%d", pSql, 0);
free(pNew);
return NULL;
}
if (tscAddSubqueryInfo(pCmd) != TSDB_CODE_SUCCESS) {
......@@ -2595,3 +2592,36 @@ void tscSVgroupInfoCopy(SVgroupInfo* dst, const SVgroupInfo* src) {
dst->epAddr[i].fqdn = strdup(src->epAddr[i].fqdn);
}
}
char* serializeTagData(STagData* pTagData, char* pMsg) {
int32_t n = strlen(pTagData->name);
*(int32_t*) pMsg = htonl(n);
pMsg += sizeof(n);
memcpy(pMsg, pTagData->name, n);
pMsg += n;
*(int32_t*)pMsg = htonl(pTagData->dataLen);
pMsg += sizeof(int32_t);
memcpy(pMsg, pTagData->data, pTagData->dataLen);
pMsg += pTagData->dataLen;
return pMsg;
}
int32_t copyTagData(STagData* dst, const STagData* src) {
dst->dataLen = src->dataLen;
tstrncpy(dst->name, src->name, tListLen(dst->name));
if (dst->dataLen > 0) {
dst->data = malloc(dst->dataLen);
if (dst->data == NULL) {
return -1;
}
memcpy(dst->data, src->data, dst->dataLen);
}
return 0;
}
\ No newline at end of file
src/common/inc/tglobal.h
浏览文件 @ 40b3b5a4
......@@ -57,7 +57,9 @@ extern char tsTempDir[];
//query buffer management
extern int32_t tsQueryBufferSize; // maximum allowed usage buffer for each data node during query processing
extern int32_t tsRetrieveBlockingModel; // only 50% will be used in query processing
extern int32_t tsRetrieveBlockingModel;// retrieve threads will be blocked
extern int32_t tsKeepOriginalColumnName;
// client
extern int32_t tsTableMetaKeepTimer;
......
src/common/src/tglobal.c
浏览文件 @ 40b3b5a4
......@@ -110,6 +110,9 @@ int32_t tsQueryBufferSize = -1;
// in retrieve blocking model, the retrieve threads will wait for the completion of the query processing.
int32_t tsRetrieveBlockingModel = 0;
// last_row(*), first(*), last_row(ts, col1, col2) query, the result fields will be the original column name
int32_t tsKeepOriginalColumnName = 0;
// db parameters
int32_t tsCacheBlockSize = TSDB_DEFAULT_CACHE_BLOCK_SIZE;
int32_t tsBlocksPerVnode = TSDB_DEFAULT_TOTAL_BLOCKS;
......@@ -897,6 +900,16 @@ static void doInitGlobalConfig(void) {
cfg.unitType = TAOS_CFG_UTYPE_NONE;
taosInitConfigOption(cfg);
cfg.option = "keepColumnName";
cfg.ptr = &tsKeepOriginalColumnName;
cfg.valType = TAOS_CFG_VTYPE_INT32;
cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW | TSDB_CFG_CTYPE_B_CLIENT;
cfg.minValue = 0;
cfg.maxValue = 1;
cfg.ptrLength = 1;
cfg.unitType = TAOS_CFG_UTYPE_NONE;
taosInitConfigOption(cfg);
// locale & charset
cfg.option = "timezone";
cfg.ptr = tsTimezone;
......
src/inc/taosmsg.h
浏览文件 @ 40b3b5a4
......@@ -266,6 +266,7 @@ typedef struct {
} SMDCreateTableMsg;
typedef struct {
int32_t len; // one create table message
char tableId[TSDB_TABLE_FNAME_LEN];
char db[TSDB_ACCT_LEN + TSDB_DB_NAME_LEN];
int8_t igExists;
......@@ -273,9 +274,13 @@ typedef struct {
int16_t numOfTags;
int16_t numOfColumns;
int16_t sqlLen; // the length of SQL, it starts after schema , sql is a null-terminated string
int32_t contLen;
int8_t reserved[16];
char schema[];
} SCreateTableMsg;
typedef struct {
int32_t numOfTables;
int32_t contLen;
} SCMCreateTableMsg;
typedef struct {
......@@ -730,8 +735,8 @@ typedef struct SMultiTableMeta {
typedef struct {
int32_t dataLen;
char name[TSDB_TABLE_FNAME_LEN];
char data[TSDB_MAX_TAGS_LEN + TD_KV_ROW_HEAD_SIZE + sizeof(SColIdx) * TSDB_MAX_TAGS];
char name[TSDB_TABLE_FNAME_LEN];
char *data;
} STagData;
/*
......
src/mnode/src/mnodeTable.c
浏览文件 @ 40b3b5a4
......@@ -720,10 +720,17 @@ static void mnodeExtractTableName(char* tableId, char* name) {
static int32_t mnodeProcessCreateTableMsg(SMnodeMsg *pMsg) {
SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(pCreate->db);
int32_t numOfTables = htonl(pCreate->numOfTables);
int32_t contentLen = htonl(pCreate->contLen);
if (numOfTables == 0 || contentLen == 0) {
// todo return error
}
SCreateTableMsg *p = (SCreateTableMsg*)((char*) pCreate + sizeof(SCMCreateTableMsg));
if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDb(p->db);
if (pMsg->pDb == NULL) {
mError("msg:%p, app:%p table:%s, failed to create, db not selected", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableId);
mError("msg:%p, app:%p table:%s, failed to create, db not selected", pMsg, pMsg->rpcMsg.ahandle, p->tableId);
return TSDB_CODE_MND_DB_NOT_SELECTED;
}
......@@ -732,28 +739,28 @@ static int32_t mnodeProcessCreateTableMsg(SMnodeMsg *pMsg) {
return TSDB_CODE_MND_DB_IN_DROPPING;
}
if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(pCreate->tableId);
if (pMsg->pTable == NULL) pMsg->pTable = mnodeGetTable(p->tableId);
if (pMsg->pTable != NULL && pMsg->retry == 0) {
if (pCreate->getMeta) {
mDebug("msg:%p, app:%p table:%s, continue to get meta", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableId);
if (p->getMeta) {
mDebug("msg:%p, app:%p table:%s, continue to get meta", pMsg, pMsg->rpcMsg.ahandle, p->tableId);
return mnodeGetChildTableMeta(pMsg);
} else if (pCreate->igExists) {
mDebug("msg:%p, app:%p table:%s, is already exist", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableId);
} else if (p->igExists) {
mDebug("msg:%p, app:%p table:%s, is already exist", pMsg, pMsg->rpcMsg.ahandle, p->tableId);
return TSDB_CODE_SUCCESS;
} else {
mError("msg:%p, app:%p table:%s, failed to create, table already exist", pMsg, pMsg->rpcMsg.ahandle,
pCreate->tableId);
p->tableId);
return TSDB_CODE_MND_TABLE_ALREADY_EXIST;
}
}
if (pCreate->numOfTags != 0) {
if (p->numOfTags != 0) {
mDebug("msg:%p, app:%p table:%s, create stable msg is received from thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
pCreate->tableId, pMsg->rpcMsg.handle);
p->tableId, pMsg->rpcMsg.handle);
return mnodeProcessCreateSuperTableMsg(pMsg);
} else {
mDebug("msg:%p, app:%p table:%s, create ctable msg is received from thandle:%p", pMsg, pMsg->rpcMsg.ahandle,
pCreate->tableId, pMsg->rpcMsg.handle);
p->tableId, pMsg->rpcMsg.handle);
return mnodeProcessCreateChildTableMsg(pMsg);
}
}
......@@ -859,7 +866,13 @@ static int32_t mnodeCreateSuperTableCb(SMnodeMsg *pMsg, int32_t code) {
static int32_t mnodeProcessCreateSuperTableMsg(SMnodeMsg *pMsg) {
if (pMsg == NULL) return TSDB_CODE_MND_APP_ERROR;
SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
SCMCreateTableMsg *pCreate1 = pMsg->rpcMsg.pCont;
if (pCreate1->numOfTables == 0) {
// todo return to error message
}
SCreateTableMsg* pCreate = (SCreateTableMsg*)((char*)pCreate1 + sizeof(SCMCreateTableMsg));
SSTableObj * pStable = calloc(1, sizeof(SSTableObj));
if (pStable == NULL) {
mError("msg:%p, app:%p table:%s, failed to create, no enough memory", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableId);
......@@ -1599,8 +1612,11 @@ static void mnodeProcessDropSuperTableRsp(SRpcMsg *rpcMsg) {
mInfo("drop stable rsp received, result:%s", tstrerror(rpcMsg->code));
}
static void *mnodeBuildCreateChildTableMsg(SCMCreateTableMsg *pMsg, SCTableObj *pTable) {
STagData * pTagData = NULL;
static void *mnodeBuildCreateChildTableMsg(SCMCreateTableMsg *pCreateMsg, SCTableObj *pTable) {
SCreateTableMsg* pMsg = (SCreateTableMsg*) ((char*)pCreateMsg + sizeof(SCMCreateTableMsg));
char* tagData = NULL;
int32_t tagDataLen = 0;
int32_t totalCols = 0;
int32_t contLen = 0;
......@@ -1608,9 +1624,13 @@ static void *mnodeBuildCreateChildTableMsg(SCMCreateTableMsg *pMsg, SCTableObj *
totalCols = pTable->superTable->numOfColumns + pTable->superTable->numOfTags;
contLen = sizeof(SMDCreateTableMsg) + totalCols * sizeof(SSchema) + pTable->sqlLen;
if (pMsg != NULL) {
pTagData = (STagData *)pMsg->schema;
tagDataLen = htonl(pTagData->dataLen);
int32_t nameLen = htonl(*(int32_t*)pMsg->schema);
char* p = pMsg->schema + nameLen + sizeof(int32_t);
tagDataLen = htonl(*(int32_t*) p);
contLen += tagDataLen;
tagData = p + sizeof(int32_t);
}
} else {
totalCols = pTable->numOfColumns;
......@@ -1662,7 +1682,7 @@ static void *mnodeBuildCreateChildTableMsg(SCMCreateTableMsg *pMsg, SCTableObj *
}
if (pTable->info.type == TSDB_CHILD_TABLE && pMsg != NULL) {
memcpy(pCreate->data + totalCols * sizeof(SSchema), pTagData->data, tagDataLen);
memcpy(pCreate->data + totalCols * sizeof(SSchema), tagData, tagDataLen);
}
if (pTable->info.type == TSDB_STREAM_TABLE) {
......@@ -1700,7 +1720,8 @@ static int32_t mnodeDoCreateChildTableFp(SMnodeMsg *pMsg) {
static int32_t mnodeDoCreateChildTableCb(SMnodeMsg *pMsg, int32_t code) {
SCTableObj *pTable = (SCTableObj *)pMsg->pTable;
SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
SCreateTableMsg *pCreate = (SCreateTableMsg*) ((char*)pMsg->rpcMsg.pCont + sizeof(SCMCreateTableMsg));
assert(pTable);
if (code == TSDB_CODE_SUCCESS) {
......@@ -1728,40 +1749,42 @@ static int32_t mnodeDoCreateChildTableCb(SMnodeMsg *pMsg, int32_t code) {
static int32_t mnodeDoCreateChildTable(SMnodeMsg *pMsg, int32_t tid) {
SVgObj *pVgroup = pMsg->pVgroup;
SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
SCMCreateTableMsg *p1 = pMsg->rpcMsg.pCont;
SCreateTableMsg *pCreate = (SCreateTableMsg*)((char*)p1 + sizeof(SCMCreateTableMsg));
SCTableObj *pTable = calloc(1, sizeof(SCTableObj));
if (pTable == NULL) {
mError("msg:%p, app:%p table:%s, failed to alloc memory", pMsg, pMsg->rpcMsg.ahandle, pCreate->tableId);
return TSDB_CODE_MND_OUT_OF_MEMORY;
}
if (pCreate->numOfColumns == 0) {
pTable->info.type = TSDB_CHILD_TABLE;
} else {
pTable->info.type = TSDB_NORMAL_TABLE;
}
pTable->info.tableId = strdup(pCreate->tableId);
pTable->info.type = (pCreate->numOfColumns == 0)? TSDB_CHILD_TABLE:TSDB_NORMAL_TABLE;
pTable->info.tableId = strdup(pCreate->tableId);
pTable->createdTime = taosGetTimestampMs();
pTable->tid = tid;
pTable->vgId = pVgroup->vgId;
if (pTable->info.type == TSDB_CHILD_TABLE) {
STagData *pTagData = (STagData *)pCreate->schema; // it is a tag key
int32_t nameLen = htonl(*(int32_t*) pCreate->schema);
char* name = (char*)pCreate->schema + sizeof(int32_t);
char stableName[TSDB_TABLE_FNAME_LEN] = {0};
memcpy(stableName, name, nameLen);
char prefix[64] = {0};
size_t prefixLen = tableIdPrefix(pMsg->pDb->name, prefix, 64);
if (0 != strncasecmp(prefix, pTagData->name, prefixLen)) {
if (0 != strncasecmp(prefix, stableName, prefixLen)) {
mError("msg:%p, app:%p table:%s, corresponding super table:%s not in this db", pMsg, pMsg->rpcMsg.ahandle,
pCreate->tableId, pTagData->name);
pCreate->tableId, stableName);
mnodeDestroyChildTable(pTable);
return TSDB_CODE_TDB_INVALID_CREATE_TB_MSG;
}
if (pMsg->pSTable == NULL) pMsg->pSTable = mnodeGetSuperTable(pTagData->name);
if (pMsg->pSTable == NULL) pMsg->pSTable = mnodeGetSuperTable(stableName);
if (pMsg->pSTable == NULL) {
mError("msg:%p, app:%p table:%s, corresponding super table:%s does not exist", pMsg, pMsg->rpcMsg.ahandle,
pCreate->tableId, pTagData->name);
pCreate->tableId, stableName);
mnodeDestroyChildTable(pTable);
return TSDB_CODE_MND_INVALID_TABLE_NAME;
}
......@@ -1839,7 +1862,9 @@ static int32_t mnodeDoCreateChildTable(SMnodeMsg *pMsg, int32_t tid) {
}
static int32_t mnodeProcessCreateChildTableMsg(SMnodeMsg *pMsg) {
SCMCreateTableMsg *pCreate = pMsg->rpcMsg.pCont;
//SCMCreateTableMsg* p1 = pMsg->rpcMsg.pCont; // there are several tables here.
SCreateTableMsg* pCreate = (SCreateTableMsg*)(pMsg->rpcMsg.pCont + sizeof(SCMCreateTableMsg));
int32_t code = grantCheck(TSDB_GRANT_TIMESERIES);
if (code != TSDB_CODE_SUCCESS) {
mError("msg:%p, app:%p table:%s, failed to create, grant timeseries failed", pMsg, pMsg->rpcMsg.ahandle,
......@@ -2187,15 +2212,23 @@ static int32_t mnodeDoGetChildTableMeta(SMnodeMsg *pMsg, STableMetaMsg *pMeta) {
static int32_t mnodeAutoCreateChildTable(SMnodeMsg *pMsg) {
STableInfoMsg *pInfo = pMsg->rpcMsg.pCont;
STagData *pTags = (STagData *)pInfo->tags;
int32_t tagLen = htonl(pTags->dataLen);
if (pTags->name[0] == 0) {
mError("msg:%p, app:%p table:%s, failed to create table on demand for stable is empty, tagLen:%d", pMsg,
char* p = pInfo->tags;
int32_t nameLen = htonl(*(int32_t*) p);
p += sizeof(int32_t);
p += nameLen;
int32_t tagLen = htonl(*(int32_t*) p);
p += sizeof(int32_t);
int32_t totalLen = nameLen + tagLen + sizeof(int32_t)*2;
if (tagLen == 0 || nameLen == 0) {
mError("msg:%p, app:%p table:%s, failed to create table on demand for super table is empty, tagLen:%d", pMsg,
pMsg->rpcMsg.ahandle, pInfo->tableId, tagLen);
return TSDB_CODE_MND_INVALID_STABLE_NAME;
}
int32_t contLen = sizeof(SCMCreateTableMsg) + offsetof(STagData, data) + tagLen;
int32_t contLen = sizeof(SCMCreateTableMsg) + sizeof(SCreateTableMsg) + totalLen;
SCMCreateTableMsg *pCreateMsg = calloc(1, contLen);
if (pCreateMsg == NULL) {
mError("msg:%p, app:%p table:%s, failed to create table while get meta info, no enough memory", pMsg,
......@@ -2203,16 +2236,24 @@ static int32_t mnodeAutoCreateChildTable(SMnodeMsg *pMsg) {
return TSDB_CODE_MND_OUT_OF_MEMORY;
}
size_t size = sizeof(pInfo->tableId);
tstrncpy(pCreateMsg->tableId, pInfo->tableId, size);
tstrncpy(pCreateMsg->db, pMsg->pDb->name, sizeof(pCreateMsg->db));
pCreateMsg->igExists = 1;
pCreateMsg->getMeta = 1;
SCreateTableMsg* pCreate = (SCreateTableMsg*) ((char*) pCreateMsg + sizeof(SCMCreateTableMsg));
size_t size = tListLen(pInfo->tableId);
tstrncpy(pCreate->tableId, pInfo->tableId, size);
tstrncpy(pCreate->db, pMsg->pDb->name, sizeof(pCreate->db));
pCreate->igExists = 1;
pCreate->getMeta = 1;
pCreateMsg->numOfTables = htonl(1);
pCreateMsg->contLen = htonl(contLen);
memcpy(pCreateMsg->schema, pTags, contLen - sizeof(SCMCreateTableMsg));
memcpy(pCreate->schema, pInfo->tags, totalLen);
char name[TSDB_TABLE_FNAME_LEN] = {0};
memcpy(name, pInfo->tags + sizeof(int32_t), nameLen);
mDebug("msg:%p, app:%p table:%s, start to create on demand, tagLen:%d stable:%s", pMsg, pMsg->rpcMsg.ahandle,
pInfo->tableId, tagLen, pTags->name);
pInfo->tableId, tagLen, name);
if (pMsg->rpcMsg.pCont != pMsg->pCont) {
tfree(pMsg->rpcMsg.pCont);
......
src/os/inc/osString.h
浏览文件 @ 40b3b5a4
......@@ -39,7 +39,7 @@ extern "C" {
do { \
strncpy((dst), (src), (size)); \
(dst)[(size)-1] = 0; \
} while (0);
} while (0)
#ifndef TAOS_OS_FUNC_STRING_STR2INT64
int64_t tsosStr2int64(char *str);
......
src/query/inc/qSqlparser.h
浏览文件 @ 40b3b5a4
......@@ -73,23 +73,27 @@ typedef struct SQuerySQL {
SStrToken selectToken; // sql string
} SQuerySQL;
typedef struct SCreatedTableInfo {
SStrToken name; // table name token
SStrToken stableName; // super table name token , for using clause
SArray *pTagVals; // create by using super table, tag value
char *fullname; // table full name
STagData tagdata; // true tag data, super table full name is in STagData
int8_t igExist; // ignore if exists
} SCreatedTableInfo;
typedef struct SCreateTableSQL {
struct SStrToken name; // meter name, create table [meterName] xxx
bool existCheck;
int8_t type; // create normal table/from super table/ stream
SStrToken name; // table name, create table [name] xxx
int8_t type; // create normal table/from super table/ stream
bool existCheck;
struct {
SArray *pTagColumns; // SArray<TAOS_FIELD>
SArray *pColumns; // SArray<TAOS_FIELD>
SArray *pTagColumns; // SArray<TAOS_FIELD>
SArray *pColumns; // SArray<TAOS_FIELD>
} colInfo;
struct {
SStrToken stableName; // super table name, for using clause
SArray *pTagVals; // create by using metric, tag value
STagData tagdata;
} usingInfo;
SQuerySQL *pSelect;
SArray *childTableInfo; // SArray<SCreatedTableInfo>
SQuerySQL *pSelect;
} SCreateTableSQL;
typedef struct SAlterTableSQL {
......@@ -241,22 +245,23 @@ SQuerySQL *tSetQuerySQLElems(SStrToken *pSelectToken, tSQLExprList *pSelection,
SArray *pGroupby, SArray *pSortOrder, SIntervalVal *pInterval,
SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit, SLimitVal *pGLimit);
SCreateTableSQL *tSetCreateSQLElems(SArray *pCols, SArray *pTags, SStrToken *pMetricName,
SArray *pTagVals, SQuerySQL *pSelect, int32_t type);
SCreateTableSQL *tSetCreateSQLElems(SArray *pCols, SArray *pTags, SQuerySQL *pSelect, int32_t type);
void tSQLExprNodeDestroy(tSQLExpr *pExpr);
SAlterTableSQL *tAlterTableSQLElems(SStrToken *pMeterName, SArray *pCols, SArray *pVals, int32_t type);
SAlterTableSQL *tAlterTableSQLElems(SStrToken *pTableName, SArray *pCols, SArray *pVals, int32_t type);
SCreatedTableInfo createNewChildTableInfo(SStrToken *pTableName, SArray *pTagVals, SStrToken *pToken, SStrToken* igExists);
void destroyAllSelectClause(SSubclauseInfo *pSql);
void doDestroyQuerySql(SQuerySQL *pSql);
void freeCreateTableInfo(void* p);
SSqlInfo * setSQLInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pMeterName, int32_t type);
SSqlInfo *setSQLInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pTableName, int32_t type);
SSubclauseInfo *setSubclause(SSubclauseInfo *pClause, void *pSqlExprInfo);
SSubclauseInfo *appendSelectClause(SSubclauseInfo *pInfo, void *pSubclause);
void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pMeterName, SStrToken *pIfNotExists);
void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pTableNameToken, SStrToken *pIfNotExists);
void SQLInfoDestroy(SSqlInfo *pInfo);
......
src/query/inc/sql.y
浏览文件 @ 40b3b5a4
......@@ -168,12 +168,12 @@ ids(A) ::= ID(X). {A = X; }
ids(A) ::= STRING(X). {A = X; }
%type ifexists {SStrToken}
ifexists(X) ::= IF EXISTS. {X.n = 1;}
ifexists(X) ::= . {X.n = 0;}
ifexists(X) ::= IF EXISTS. { X.n = 1;}
ifexists(X) ::= . { X.n = 0;}
%type ifnotexists {SStrToken}
ifnotexists(X) ::= IF NOT EXISTS. {X.n = 1;}
ifnotexists(X) ::= . {X.n = 0;}
ifnotexists(X) ::= IF NOT EXISTS. { X.n = 1;}
ifnotexists(X) ::= . { X.n = 0;}
/////////////////////////////////THE CREATE STATEMENT///////////////////////////////////////
//create option for dnode/db/user/account
......@@ -183,32 +183,32 @@ cmd ::= CREATE ACCOUNT ids(X) PASS ids(Y) acct_optr(Z).
cmd ::= CREATE DATABASE ifnotexists(Z) ids(X) db_optr(Y). { setCreateDBSQL(pInfo, TSDB_SQL_CREATE_DB, &X, &Y, &Z);}
cmd ::= CREATE USER ids(X) PASS ids(Y). { setCreateUserSQL(pInfo, &X, &Y);}
pps(Y) ::= . {Y.n = 0; }
pps(Y) ::= PPS INTEGER(X). {Y = X; }
pps(Y) ::= . { Y.n = 0; }
pps(Y) ::= PPS INTEGER(X). { Y = X; }
tseries(Y) ::= . {Y.n = 0; }
tseries(Y) ::= TSERIES INTEGER(X). {Y = X; }
tseries(Y) ::= . { Y.n = 0; }
tseries(Y) ::= TSERIES INTEGER(X). { Y = X; }
dbs(Y) ::= . {Y.n = 0; }
dbs(Y) ::= DBS INTEGER(X). {Y = X; }
dbs(Y) ::= . { Y.n = 0; }
dbs(Y) ::= DBS INTEGER(X). { Y = X; }
streams(Y) ::= . {Y.n = 0; }
streams(Y) ::= STREAMS INTEGER(X). {Y = X; }
streams(Y) ::= . { Y.n = 0; }
streams(Y) ::= STREAMS INTEGER(X). { Y = X; }
storage(Y) ::= . {Y.n = 0; }
storage(Y) ::= STORAGE INTEGER(X). {Y = X; }
storage(Y) ::= . { Y.n = 0; }
storage(Y) ::= STORAGE INTEGER(X). { Y = X; }
qtime(Y) ::= . {Y.n = 0; }
qtime(Y) ::= QTIME INTEGER(X). {Y = X; }
qtime(Y) ::= . { Y.n = 0; }
qtime(Y) ::= QTIME INTEGER(X). { Y = X; }
users(Y) ::= . {Y.n = 0; }
users(Y) ::= USERS INTEGER(X). {Y = X; }
users(Y) ::= . { Y.n = 0; }
users(Y) ::= USERS INTEGER(X). { Y = X; }
conns(Y) ::= . {Y.n = 0; }
conns(Y) ::= CONNS INTEGER(X). {Y = X; }
conns(Y) ::= . { Y.n = 0; }
conns(Y) ::= CONNS INTEGER(X). { Y = X; }
state(Y) ::= . {Y.n = 0; }
state(Y) ::= STATE ids(X). {Y = X; }
state(Y) ::= . { Y.n = 0; }
state(Y) ::= STATE ids(X). { Y = X; }
%type acct_optr {SCreateAcctSQL}
acct_optr(Y) ::= pps(C) tseries(D) storage(P) streams(F) qtime(Q) dbs(E) users(K) conns(L) state(M). {
......@@ -269,7 +269,7 @@ alter_db_optr(Y) ::= alter_db_optr(Z) blocks(X). { Y = Z; Y.numOfBlocks = s
alter_db_optr(Y) ::= alter_db_optr(Z) comp(X). { Y = Z; Y.compressionLevel = strtol(X.z, NULL, 10); }
alter_db_optr(Y) ::= alter_db_optr(Z) wal(X). { Y = Z; Y.walLevel = strtol(X.z, NULL, 10); }
alter_db_optr(Y) ::= alter_db_optr(Z) fsync(X). { Y = Z; Y.fsyncPeriod = strtol(X.z, NULL, 10); }
alter_db_optr(Y) ::= alter_db_optr(Z) update(X). { Y = Z; Y.update = strtol(X.z, NULL, 10); }
alter_db_optr(Y) ::= alter_db_optr(Z) update(X). { Y = Z; Y.update = strtol(X.z, NULL, 10); }
%type typename {TAOS_FIELD}
typename(A) ::= ids(X). {
......@@ -279,13 +279,13 @@ typename(A) ::= ids(X). {
//define binary type, e.g., binary(10), nchar(10)
typename(A) ::= ids(X) LP signed(Y) RP. {
if (Y <= 0) {
X.type = 0;
tSQLSetColumnType(&A, &X);
} else {
X.type = -Y; // negative value of name length
tSQLSetColumnType(&A, &X);
}
if (Y <= 0) {
X.type = 0;
tSQLSetColumnType(&A, &X);
} else {
X.type = -Y; // negative value of name length
tSQLSetColumnType(&A, &X);
}
}
%type signed {int64_t}
......@@ -294,36 +294,60 @@ signed(A) ::= PLUS INTEGER(X). { A = strtol(X.z, NULL, 10); }
signed(A) ::= MINUS INTEGER(X). { A = -strtol(X.z, NULL, 10);}
////////////////////////////////// The CREATE TABLE statement ///////////////////////////////
cmd ::= CREATE TABLE ifnotexists(Y) ids(X) cpxName(Z) create_table_args. {
X.n += Z.n;
setCreatedTableName(pInfo, &X, &Y);
cmd ::= CREATE TABLE create_table_args. {}
cmd ::= CREATE TABLE create_table_list(Z). { pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = Z;}
%type create_table_list{SCreateTableSQL*}
%destructor create_table_list{destroyCreateTableSQL($$);}
create_table_list(A) ::= create_from_stable(Z). {
SCreateTableSQL* pCreateTable = calloc(1, sizeof(SCreateTableSQL));
pCreateTable->childTableInfo = taosArrayInit(4, sizeof(SCreatedTableInfo));
taosArrayPush(pCreateTable->childTableInfo, &Z);
pCreateTable->type = TSQL_CREATE_TABLE_FROM_STABLE;
A = pCreateTable;
}
create_table_list(A) ::= create_table_list(X) create_from_stable(Z). {
taosArrayPush(X->childTableInfo, &Z);
A = X;
}
%type create_table_args{SCreateTableSQL*}
create_table_args(A) ::= LP columnlist(X) RP. {
A = tSetCreateSQLElems(X, NULL, NULL, NULL, NULL, TSQL_CREATE_TABLE);
setSQLInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
create_table_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) LP columnlist(X) RP. {
A = tSetCreateSQLElems(X, NULL, NULL, TSQL_CREATE_TABLE);
setSQLInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
V.n += Z.n;
setCreatedTableName(pInfo, &V, &U);
}
// create super table
create_table_args(A) ::= LP columnlist(X) RP TAGS LP columnlist(Y) RP. {
A = tSetCreateSQLElems(X, Y, NULL, NULL, NULL, TSQL_CREATE_STABLE);
setSQLInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
create_table_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) LP columnlist(X) RP TAGS LP columnlist(Y) RP. {
A = tSetCreateSQLElems(X, Y, NULL, TSQL_CREATE_STABLE);
setSQLInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
V.n += Z.n;
setCreatedTableName(pInfo, &V, &U);
}
// create table by using super table
// create table table_name using super_table_name tags(tag_values1, tag_values2)
create_table_args(A) ::= USING ids(X) cpxName(F) TAGS LP tagitemlist(Y) RP. {
X.n += F.n;
A = tSetCreateSQLElems(NULL, NULL, &X, Y, NULL, TSQL_CREATE_TABLE_FROM_STABLE);
setSQLInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
%type create_from_stable{SCreatedTableInfo}
create_from_stable(A) ::= ifnotexists(U) ids(V) cpxName(Z) USING ids(X) cpxName(F) TAGS LP tagitemlist(Y) RP. {
X.n += F.n;
V.n += Z.n;
A = createNewChildTableInfo(&X, Y, &V, &U);
}
// create stream
// create table table_name as select count(*) from super_table_name interval(time)
create_table_args(A) ::= AS select(S). {
A = tSetCreateSQLElems(NULL, NULL, NULL, NULL, S, TSQL_CREATE_STREAM);
setSQLInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
create_table_args(A) ::= ifnotexists(U) ids(V) cpxName(Z) AS select(S). {
A = tSetCreateSQLElems(NULL, NULL, S, TSQL_CREATE_STREAM);
setSQLInfo(pInfo, A, NULL, TSDB_SQL_CREATE_TABLE);
U.n += Z.n;
setCreatedTableName(pInfo, &U, &V);
}
%type column{TAOS_FIELD}
......@@ -335,7 +359,7 @@ columnlist(A) ::= column(X). {A = taosArrayInit(4, sizeof(T
// The information used for a column is the name and type of column:
// tinyint smallint int bigint float double bool timestamp binary(x) nchar(x)
column(A) ::= ids(X) typename(Y). {
tSQLSetColumnInfo(&A, &X, &Y);
tSQLSetColumnInfo(&A, &X, &Y);
}
%type tagitemlist {SArray*}
......@@ -345,10 +369,10 @@ column(A) ::= ids(X) typename(Y). {
tagitemlist(A) ::= tagitemlist(X) COMMA tagitem(Y). { A = tVariantListAppend(X, &Y, -1); }
tagitemlist(A) ::= tagitem(X). { A = tVariantListAppend(NULL, &X, -1); }
tagitem(A) ::= INTEGER(X). {toTSDBType(X.type); tVariantCreate(&A, &X); }
tagitem(A) ::= FLOAT(X). {toTSDBType(X.type); tVariantCreate(&A, &X); }
tagitem(A) ::= STRING(X). {toTSDBType(X.type); tVariantCreate(&A, &X); }
tagitem(A) ::= BOOL(X). {toTSDBType(X.type); tVariantCreate(&A, &X); }
tagitem(A) ::= INTEGER(X). { toTSDBType(X.type); tVariantCreate(&A, &X); }
tagitem(A) ::= FLOAT(X). { toTSDBType(X.type); tVariantCreate(&A, &X); }
tagitem(A) ::= STRING(X). { toTSDBType(X.type); tVariantCreate(&A, &X); }
tagitem(A) ::= BOOL(X). { toTSDBType(X.type); tVariantCreate(&A, &X); }
tagitem(A) ::= NULL(X). { X.type = 0; tVariantCreate(&A, &X); }
tagitem(A) ::= MINUS(X) INTEGER(Y).{
......@@ -445,11 +469,11 @@ tablelist(A) ::= ids(X) cpxName(Y). {
}
tablelist(A) ::= ids(X) cpxName(Y) ids(Z). {
toTSDBType(X.type);
toTSDBType(Z.type);
X.n += Y.n;
A = tVariantListAppendToken(NULL, &X, -1);
A = tVariantListAppendToken(A, &Z, -1);
toTSDBType(X.type);
toTSDBType(Z.type);
X.n += Y.n;
A = tVariantListAppendToken(NULL, &X, -1);
A = tVariantListAppendToken(A, &Z, -1);
}
tablelist(A) ::= tablelist(Y) COMMA ids(X) cpxName(Z). {
......@@ -460,11 +484,11 @@ tablelist(A) ::= tablelist(Y) COMMA ids(X) cpxName(Z). {
}
tablelist(A) ::= tablelist(Y) COMMA ids(X) cpxName(Z) ids(F). {
toTSDBType(X.type);
toTSDBType(F.type);
X.n += Z.n;
A = tVariantListAppendToken(Y, &X, -1);
A = tVariantListAppendToken(A, &F, -1);
toTSDBType(X.type);
toTSDBType(F.type);
X.n += Z.n;
A = tVariantListAppendToken(Y, &X, -1);
A = tVariantListAppendToken(A, &F, -1);
}
// The value of interval should be the form of "number+[a,s,m,h,d,n,y]" or "now"
......@@ -526,9 +550,9 @@ item(A) ::= ids(X) cpxName(Y). {
}
%type sortorder {int}
sortorder(A) ::= ASC. {A = TSDB_ORDER_ASC; }
sortorder(A) ::= DESC. {A = TSDB_ORDER_DESC;}
sortorder(A) ::= . {A = TSDB_ORDER_ASC;} //default is descend order
sortorder(A) ::= ASC. { A = TSDB_ORDER_ASC; }
sortorder(A) ::= DESC. { A = TSDB_ORDER_DESC;}
sortorder(A) ::= . { A = TSDB_ORDER_ASC; } // Ascending order by default
//group by clause
%type groupby_opt {SArray*}
......@@ -536,8 +560,8 @@ sortorder(A) ::= . {A = TSDB_ORDER_ASC;} //default is descend orde
%type grouplist {SArray*}
%destructor grouplist {taosArrayDestroy($$);}
groupby_opt(A) ::= . {A = 0;}
groupby_opt(A) ::= GROUP BY grouplist(X). {A = X;}
groupby_opt(A) ::= . { A = 0;}
groupby_opt(A) ::= GROUP BY grouplist(X). { A = X;}
grouplist(A) ::= grouplist(X) COMMA item(Y). {
A = tVariantListAppend(X, &Y, -1);
......@@ -583,20 +607,20 @@ where_opt(A) ::= WHERE expr(X). {A = X;}
expr(A) ::= LP(X) expr(Y) RP(Z). {A = Y; A->token.z = X.z; A->token.n = (Z.z - X.z + 1);}
expr(A) ::= ID(X). {A = tSQLExprIdValueCreate(&X, TK_ID);}
expr(A) ::= ID(X) DOT ID(Y). {X.n += (1+Y.n); A = tSQLExprIdValueCreate(&X, TK_ID);}
expr(A) ::= ID(X) DOT STAR(Y). {X.n += (1+Y.n); A = tSQLExprIdValueCreate(&X, TK_ALL);}
expr(A) ::= INTEGER(X). {A = tSQLExprIdValueCreate(&X, TK_INTEGER);}
expr(A) ::= MINUS(X) INTEGER(Y). {X.n += Y.n; X.type = TK_INTEGER; A = tSQLExprIdValueCreate(&X, TK_INTEGER);}
expr(A) ::= PLUS(X) INTEGER(Y). {X.n += Y.n; X.type = TK_INTEGER; A = tSQLExprIdValueCreate(&X, TK_INTEGER);}
expr(A) ::= FLOAT(X). {A = tSQLExprIdValueCreate(&X, TK_FLOAT);}
expr(A) ::= MINUS(X) FLOAT(Y). {X.n += Y.n; X.type = TK_FLOAT; A = tSQLExprIdValueCreate(&X, TK_FLOAT);}
expr(A) ::= PLUS(X) FLOAT(Y). {X.n += Y.n; X.type = TK_FLOAT; A = tSQLExprIdValueCreate(&X, TK_FLOAT);}
expr(A) ::= STRING(X). {A = tSQLExprIdValueCreate(&X, TK_STRING);}
expr(A) ::= NOW(X). {A = tSQLExprIdValueCreate(&X, TK_NOW); }
expr(A) ::= VARIABLE(X). {A = tSQLExprIdValueCreate(&X, TK_VARIABLE);}
expr(A) ::= BOOL(X). {A = tSQLExprIdValueCreate(&X, TK_BOOL);}
expr(A) ::= ID(X). { A = tSQLExprIdValueCreate(&X, TK_ID);}
expr(A) ::= ID(X) DOT ID(Y). { X.n += (1+Y.n); A = tSQLExprIdValueCreate(&X, TK_ID);}
expr(A) ::= ID(X) DOT STAR(Y). { X.n += (1+Y.n); A = tSQLExprIdValueCreate(&X, TK_ALL);}
expr(A) ::= INTEGER(X). { A = tSQLExprIdValueCreate(&X, TK_INTEGER);}
expr(A) ::= MINUS(X) INTEGER(Y). { X.n += Y.n; X.type = TK_INTEGER; A = tSQLExprIdValueCreate(&X, TK_INTEGER);}
expr(A) ::= PLUS(X) INTEGER(Y). { X.n += Y.n; X.type = TK_INTEGER; A = tSQLExprIdValueCreate(&X, TK_INTEGER);}
expr(A) ::= FLOAT(X). { A = tSQLExprIdValueCreate(&X, TK_FLOAT);}
expr(A) ::= MINUS(X) FLOAT(Y). { X.n += Y.n; X.type = TK_FLOAT; A = tSQLExprIdValueCreate(&X, TK_FLOAT);}
expr(A) ::= PLUS(X) FLOAT(Y). { X.n += Y.n; X.type = TK_FLOAT; A = tSQLExprIdValueCreate(&X, TK_FLOAT);}
expr(A) ::= STRING(X). { A = tSQLExprIdValueCreate(&X, TK_STRING);}
expr(A) ::= NOW(X). { A = tSQLExprIdValueCreate(&X, TK_NOW); }
expr(A) ::= VARIABLE(X). { A = tSQLExprIdValueCreate(&X, TK_VARIABLE);}
expr(A) ::= BOOL(X). { A = tSQLExprIdValueCreate(&X, TK_BOOL);}
// ordinary functions: min(x), max(x), top(k, 20)
expr(A) ::= ID(X) LP exprlist(Y) RP(E). { A = tSQLExprCreateFunction(Y, &X, &E, X.type); }
......
src/query/src/qParserImpl.c
浏览文件 @ 40b3b5a4
......@@ -474,11 +474,18 @@ SQuerySQL *tSetQuerySQLElems(SStrToken *pSelectToken, tSQLExprList *pSelection,
return pQuery;
}
void freeVariant(void *pItem) {
static void freeVariant(void *pItem) {
tVariantListItem* p = (tVariantListItem*) pItem;
tVariantDestroy(&p->pVar);
}
void freeCreateTableInfo(void* p) {
SCreatedTableInfo* pInfo = (SCreatedTableInfo*) p;
taosArrayDestroyEx(pInfo->pTagVals, freeVariant);
tfree(pInfo->fullname);
tfree(pInfo->tagdata.data);
}
void doDestroyQuerySql(SQuerySQL *pQuerySql) {
if (pQuerySql == NULL) {
return;
......@@ -519,31 +526,30 @@ void destroyAllSelectClause(SSubclauseInfo *pClause) {
tfree(pClause->pClause);
}
SCreateTableSQL *tSetCreateSQLElems(SArray *pCols, SArray *pTags, SStrToken *pStableName,
SArray *pTagVals, SQuerySQL *pSelect, int32_t type) {
SCreateTableSQL *tSetCreateSQLElems(SArray *pCols, SArray *pTags, SQuerySQL *pSelect, int32_t type) {
SCreateTableSQL *pCreate = calloc(1, sizeof(SCreateTableSQL));
switch (type) {
case TSQL_CREATE_TABLE: {
pCreate->colInfo.pColumns = pCols;
assert(pTagVals == NULL && pTags == NULL);
assert(pTags == NULL);
break;
}
case TSQL_CREATE_STABLE: {
pCreate->colInfo.pColumns = pCols;
pCreate->colInfo.pTagColumns = pTags;
assert(pTagVals == NULL && pTags != NULL && pCols != NULL);
break;
}
case TSQL_CREATE_TABLE_FROM_STABLE: {
pCreate->usingInfo.pTagVals = pTagVals;
pCreate->usingInfo.stableName = *pStableName;
assert(pTags != NULL && pCols != NULL);
break;
}
case TSQL_CREATE_STREAM: {
pCreate->pSelect = pSelect;
break;
}
case TSQL_CREATE_TABLE_FROM_STABLE: {
assert(0);
}
default:
assert(false);
}
......@@ -552,10 +558,20 @@ SCreateTableSQL *tSetCreateSQLElems(SArray *pCols, SArray *pTags, SStrToken *pSt
return pCreate;
}
SAlterTableSQL *tAlterTableSQLElems(SStrToken *pMeterName, SArray *pCols, SArray *pVals, int32_t type) {
SCreatedTableInfo createNewChildTableInfo(SStrToken *pTableName, SArray *pTagVals, SStrToken *pToken, SStrToken* igExists) {
SCreatedTableInfo info = {0};
info.name = *pToken;
info.pTagVals = pTagVals;
info.stableName = *pTableName;
info.igExist = (igExists->n > 0)? 1:0;
return info;
}
SAlterTableSQL *tAlterTableSQLElems(SStrToken *pTableName, SArray *pCols, SArray *pVals, int32_t type) {
SAlterTableSQL *pAlterTable = calloc(1, sizeof(SAlterTableSQL));
pAlterTable->name = *pMeterName;
pAlterTable->name = *pTableName;
pAlterTable->type = type;
if (type == TSDB_ALTER_TABLE_ADD_COLUMN || type == TSDB_ALTER_TABLE_ADD_TAG_COLUMN) {
......@@ -573,24 +589,29 @@ SAlterTableSQL *tAlterTableSQLElems(SStrToken *pMeterName, SArray *pCols, SArray
return pAlterTable;
}
void* destroyCreateTableSQL(SCreateTableSQL* pCreate) {
doDestroyQuerySql(pCreate->pSelect);
taosArrayDestroy(pCreate->colInfo.pColumns);
taosArrayDestroy(pCreate->colInfo.pTagColumns);
taosArrayDestroyEx(pCreate->childTableInfo, freeCreateTableInfo);
tfree(pCreate);
return NULL;
}
void SQLInfoDestroy(SSqlInfo *pInfo) {
if (pInfo == NULL) return;
if (pInfo->type == TSDB_SQL_SELECT) {
destroyAllSelectClause(&pInfo->subclauseInfo);
} else if (pInfo->type == TSDB_SQL_CREATE_TABLE) {
SCreateTableSQL *pCreateTableInfo = pInfo->pCreateTableInfo;
doDestroyQuerySql(pCreateTableInfo->pSelect);
taosArrayDestroy(pCreateTableInfo->colInfo.pColumns);
taosArrayDestroy(pCreateTableInfo->colInfo.pTagColumns);
taosArrayDestroyEx(pCreateTableInfo->usingInfo.pTagVals, freeVariant);
tfree(pInfo->pCreateTableInfo);
pInfo->pCreateTableInfo = destroyCreateTableSQL(pInfo->pCreateTableInfo);
} else if (pInfo->type == TSDB_SQL_ALTER_TABLE) {
taosArrayDestroyEx(pInfo->pAlterInfo->varList, freeVariant);
taosArrayDestroy(pInfo->pAlterInfo->pAddColumns);
tfree(pInfo->pAlterInfo->tagData.data);
tfree(pInfo->pAlterInfo);
} else {
if (pInfo->pDCLInfo != NULL && pInfo->pDCLInfo->nAlloc > 0) {
......@@ -624,7 +645,7 @@ SSubclauseInfo* setSubclause(SSubclauseInfo* pSubclause, void *pSqlExprInfo) {
return pSubclause;
}
SSqlInfo* setSQLInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pMeterName, int32_t type) {
SSqlInfo* setSQLInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pTableName, int32_t type) {
pInfo->type = type;
if (type == TSDB_SQL_SELECT) {
......@@ -634,8 +655,8 @@ SSqlInfo* setSQLInfo(SSqlInfo *pInfo, void *pSqlExprInfo, SStrToken *pMeterName,
pInfo->pCreateTableInfo = pSqlExprInfo;
}
if (pMeterName != NULL) {
pInfo->pCreateTableInfo->name = *pMeterName;
if (pTableName != NULL) {
pInfo->pCreateTableInfo->name = *pTableName;
}
return pInfo;
......@@ -653,8 +674,8 @@ SSubclauseInfo* appendSelectClause(SSubclauseInfo *pQueryInfo, void *pSubclause)
return pQueryInfo;
}
void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pMeterName, SStrToken *pIfNotExists) {
pInfo->pCreateTableInfo->name = *pMeterName;
void setCreatedTableName(SSqlInfo *pInfo, SStrToken *pTableNameToken, SStrToken *pIfNotExists) {
pInfo->pCreateTableInfo->name = *pTableNameToken;
pInfo->pCreateTableInfo->existCheck = (pIfNotExists->n != 0);
}
......
src/query/src/sql.c
浏览文件 @ 40b3b5a4
......@@ -97,26 +97,27 @@
#endif
/************* Begin control #defines *****************************************/
#define YYCODETYPE unsigned short int
#define YYNOCODE 274
#define YYNOCODE 276
#define YYACTIONTYPE unsigned short int
#define ParseTOKENTYPE SStrToken
typedef union {
int yyinit;
ParseTOKENTYPE yy0;
int yy46;
tSQLExpr* yy64;
tVariant yy134;
SCreateAcctSQL yy149;
SArray* yy165;
int64_t yy207;
SLimitVal yy216;
TAOS_FIELD yy223;
SSubclauseInfo* yy231;
SCreateDBInfo yy268;
tSQLExprList* yy290;
SQuerySQL* yy414;
SCreateTableSQL* yy470;
SIntervalVal yy532;
int yy42;
SQuerySQL* yy84;
SCreatedTableInfo yy96;
SArray* yy131;
SCreateDBInfo yy148;
TAOS_FIELD yy163;
SLimitVal yy284;
SCreateAcctSQL yy309;
tSQLExpr* yy420;
int64_t yy459;
tSQLExprList* yy478;
SSubclauseInfo* yy513;
tVariant yy516;
SIntervalVal yy530;
SCreateTableSQL* yy538;
} YYMINORTYPE;
#ifndef YYSTACKDEPTH
#define YYSTACKDEPTH 100
......@@ -126,17 +127,17 @@ typedef union {
#define ParseARG_FETCH SSqlInfo* pInfo = yypParser->pInfo
#define ParseARG_STORE yypParser->pInfo = pInfo
#define YYFALLBACK 1
#define YYNSTATE 253
#define YYNRULE 233
#define YYNSTATE 257
#define YYNRULE 236
#define YYNTOKEN 207
#define YY_MAX_SHIFT 252
#define YY_MIN_SHIFTREDUCE 420
#define YY_MAX_SHIFTREDUCE 652
#define YY_ERROR_ACTION 653
#define YY_ACCEPT_ACTION 654
#define YY_NO_ACTION 655
#define YY_MIN_REDUCE 656
#define YY_MAX_REDUCE 888
#define YY_MAX_SHIFT 256
#define YY_MIN_SHIFTREDUCE 426
#define YY_MAX_SHIFTREDUCE 661
#define YY_ERROR_ACTION 662
#define YY_ACCEPT_ACTION 663
#define YY_NO_ACTION 664
#define YY_MIN_REDUCE 665
#define YY_MAX_REDUCE 900
/************* End control #defines *******************************************/
/* Define the yytestcase() macro to be a no-op if is not already defined
......@@ -202,224 +203,226 @@ typedef union {
** yy_default[] Default action for each state.
**
*********** Begin parsing tables **********************************************/
#define YY_ACTTAB_COUNT (571)
#define YY_ACTTAB_COUNT (579)
static const YYACTIONTYPE yy_action[] = {
/* 0 */ 108, 463, 141, 11, 654, 252, 802, 463, 140, 464,
/* 10 */ 162, 165, 876, 35, 36, 464, 37, 38, 159, 250,
/* 20 */ 170, 29, 141, 463, 206, 41, 39, 43, 40, 173,
/* 30 */ 780, 464, 875, 34, 33, 145, 141, 32, 31, 30,
/* 40 */ 35, 36, 791, 37, 38, 164, 876, 170, 29, 780,
/* 50 */ 21, 206, 41, 39, 43, 40, 191, 829, 799, 201,
/* 60 */ 34, 33, 21, 21, 32, 31, 30, 421, 422, 423,
/* 70 */ 424, 425, 426, 427, 428, 429, 430, 431, 432, 251,
/* 80 */ 35, 36, 181, 37, 38, 532, 776, 170, 29, 238,
/* 90 */ 246, 206, 41, 39, 43, 40, 174, 175, 777, 777,
/* 100 */ 34, 33, 872, 56, 32, 31, 30, 176, 871, 36,
/* 110 */ 780, 37, 38, 227, 226, 170, 29, 791, 17, 206,
/* 120 */ 41, 39, 43, 40, 108, 26, 870, 606, 34, 33,
/* 130 */ 78, 160, 32, 31, 30, 238, 157, 16, 218, 245,
/* 140 */ 244, 217, 216, 215, 243, 214, 242, 241, 240, 213,
/* 150 */ 239, 755, 103, 743, 744, 745, 746, 747, 748, 749,
/* 160 */ 750, 751, 752, 753, 754, 756, 37, 38, 229, 177,
/* 170 */ 170, 29, 224, 223, 206, 41, 39, 43, 40, 203,
/* 180 */ 62, 60, 8, 34, 33, 63, 118, 32, 31, 30,
/* 190 */ 169, 619, 27, 12, 610, 184, 613, 158, 616, 778,
/* 200 */ 169, 619, 188, 187, 610, 194, 613, 108, 616, 153,
/* 210 */ 169, 619, 561, 108, 610, 154, 613, 18, 616, 90,
/* 220 */ 89, 148, 166, 167, 34, 33, 205, 143, 32, 31,
/* 230 */ 30, 697, 166, 167, 131, 144, 564, 41, 39, 43,
/* 240 */ 40, 706, 166, 167, 131, 34, 33, 146, 17, 32,
/* 250 */ 31, 30, 32, 31, 30, 26, 16, 207, 245, 244,
/* 260 */ 21, 587, 588, 243, 828, 242, 241, 240, 698, 239,
/* 270 */ 61, 131, 76, 80, 147, 190, 102, 151, 85, 88,
/* 280 */ 79, 760, 156, 26, 758, 759, 82, 21, 42, 761,
/* 290 */ 556, 763, 764, 762, 225, 765, 777, 193, 42, 618,
/* 300 */ 249, 248, 96, 574, 121, 122, 608, 105, 42, 618,
/* 310 */ 70, 66, 69, 578, 617, 168, 579, 46, 152, 618,
/* 320 */ 14, 230, 548, 777, 617, 545, 638, 546, 150, 547,
/* 330 */ 13, 135, 133, 612, 617, 615, 139, 93, 92, 91,
/* 340 */ 620, 611, 609, 614, 13, 47, 538, 622, 50, 552,
/* 350 */ 46, 553, 537, 178, 179, 3, 22, 211, 75, 74,
/* 360 */ 149, 22, 10, 9, 48, 51, 142, 550, 885, 551,
/* 370 */ 87, 86, 101, 99, 779, 839, 838, 171, 835, 834,
/* 380 */ 172, 801, 771, 228, 806, 793, 808, 104, 821, 119,
/* 390 */ 820, 117, 120, 708, 212, 137, 24, 221, 705, 222,
/* 400 */ 26, 192, 100, 884, 72, 883, 881, 123, 726, 25,
/* 410 */ 573, 23, 138, 695, 49, 81, 693, 83, 84, 691,
/* 420 */ 790, 690, 195, 161, 199, 549, 57, 52, 180, 132,
/* 430 */ 688, 687, 686, 685, 684, 134, 682, 109, 680, 678,
/* 440 */ 44, 676, 674, 136, 204, 202, 58, 822, 200, 198,
/* 450 */ 196, 220, 77, 28, 231, 232, 233, 235, 652, 234,
/* 460 */ 236, 237, 247, 209, 183, 53, 651, 182, 185, 186,
/* 470 */ 64, 67, 155, 650, 643, 189, 193, 689, 558, 94,
/* 480 */ 683, 675, 126, 125, 727, 129, 124, 127, 128, 95,
/* 490 */ 130, 1, 114, 110, 111, 775, 2, 55, 59, 116,
/* 500 */ 112, 113, 115, 575, 106, 163, 197, 5, 580, 107,
/* 510 */ 6, 65, 621, 19, 4, 20, 15, 208, 623, 7,
/* 520 */ 210, 504, 500, 498, 497, 496, 493, 467, 219, 68,
/* 530 */ 45, 71, 73, 22, 534, 533, 531, 488, 54, 486,
/* 540 */ 478, 484, 480, 482, 476, 474, 505, 503, 502, 501,
/* 550 */ 499, 495, 494, 46, 465, 436, 434, 656, 655, 655,
/* 560 */ 655, 655, 655, 655, 655, 655, 655, 655, 655, 97,
/* 570 */ 98,
/* 0 */ 143, 469, 663, 256, 469, 162, 254, 12, 814, 470,
/* 10 */ 887, 142, 470, 37, 38, 147, 39, 40, 803, 233,
/* 20 */ 173, 31, 884, 469, 209, 43, 41, 45, 42, 64,
/* 30 */ 883, 470, 163, 36, 35, 105, 143, 34, 33, 32,
/* 40 */ 37, 38, 803, 39, 40, 168, 888, 173, 31, 110,
/* 50 */ 790, 209, 43, 41, 45, 42, 194, 780, 22, 782,
/* 60 */ 36, 35, 811, 882, 34, 33, 32, 427, 428, 429,
/* 70 */ 430, 431, 432, 433, 434, 435, 436, 437, 438, 255,
/* 80 */ 37, 38, 184, 39, 40, 538, 224, 173, 31, 143,
/* 90 */ 197, 209, 43, 41, 45, 42, 165, 23, 167, 888,
/* 100 */ 36, 35, 242, 57, 34, 33, 32, 179, 841, 38,
/* 110 */ 204, 39, 40, 231, 230, 173, 31, 49, 792, 209,
/* 120 */ 43, 41, 45, 42, 253, 252, 98, 615, 36, 35,
/* 130 */ 178, 781, 34, 33, 32, 788, 50, 17, 222, 249,
/* 140 */ 248, 221, 220, 219, 247, 218, 246, 245, 244, 217,
/* 150 */ 243, 764, 792, 752, 753, 754, 755, 756, 757, 758,
/* 160 */ 759, 760, 761, 762, 763, 765, 39, 40, 110, 180,
/* 170 */ 173, 31, 228, 227, 209, 43, 41, 45, 42, 34,
/* 180 */ 33, 32, 9, 36, 35, 65, 120, 34, 33, 32,
/* 190 */ 172, 628, 18, 13, 619, 110, 622, 210, 625, 28,
/* 200 */ 172, 628, 110, 159, 619, 187, 622, 224, 625, 155,
/* 210 */ 172, 628, 191, 190, 619, 156, 622, 66, 625, 92,
/* 220 */ 91, 150, 169, 170, 36, 35, 208, 840, 34, 33,
/* 230 */ 32, 160, 169, 170, 617, 250, 573, 43, 41, 45,
/* 240 */ 42, 706, 169, 170, 133, 36, 35, 783, 18, 34,
/* 250 */ 33, 32, 206, 104, 61, 28, 17, 792, 249, 248,
/* 260 */ 28, 62, 145, 247, 23, 246, 245, 244, 146, 243,
/* 270 */ 618, 715, 78, 82, 133, 193, 565, 23, 87, 90,
/* 280 */ 81, 769, 158, 196, 767, 768, 84, 631, 44, 770,
/* 290 */ 23, 772, 773, 771, 148, 774, 80, 149, 44, 627,
/* 300 */ 176, 242, 789, 707, 3, 124, 133, 23, 44, 627,
/* 310 */ 72, 68, 71, 177, 626, 789, 596, 597, 570, 627,
/* 320 */ 805, 63, 557, 19, 626, 554, 229, 555, 789, 556,
/* 330 */ 171, 137, 135, 29, 626, 153, 583, 95, 94, 93,
/* 340 */ 107, 154, 587, 234, 588, 789, 48, 647, 15, 52,
/* 350 */ 152, 14, 629, 181, 182, 141, 14, 621, 620, 624,
/* 360 */ 623, 546, 89, 88, 212, 24, 53, 547, 24, 151,
/* 370 */ 4, 48, 561, 144, 562, 77, 76, 11, 10, 897,
/* 380 */ 559, 851, 560, 103, 101, 791, 850, 174, 847, 846,
/* 390 */ 175, 232, 813, 833, 818, 820, 106, 832, 121, 122,
/* 400 */ 28, 123, 102, 119, 717, 216, 139, 26, 225, 714,
/* 410 */ 195, 582, 226, 896, 74, 895, 893, 125, 735, 27,
/* 420 */ 198, 25, 164, 202, 140, 558, 704, 83, 702, 85,
/* 430 */ 86, 700, 699, 183, 54, 134, 697, 696, 695, 694,
/* 440 */ 693, 136, 691, 689, 46, 687, 685, 802, 683, 138,
/* 450 */ 51, 58, 59, 834, 207, 205, 199, 203, 201, 30,
/* 460 */ 79, 235, 236, 237, 238, 239, 240, 241, 251, 161,
/* 470 */ 661, 214, 215, 186, 185, 660, 189, 157, 188, 69,
/* 480 */ 659, 652, 192, 60, 196, 166, 567, 698, 56, 128,
/* 490 */ 96, 692, 736, 126, 130, 97, 127, 129, 131, 132,
/* 500 */ 684, 1, 584, 787, 2, 108, 200, 117, 113, 111,
/* 510 */ 112, 114, 115, 116, 589, 118, 109, 5, 6, 20,
/* 520 */ 21, 630, 8, 7, 632, 211, 16, 213, 67, 510,
/* 530 */ 65, 506, 504, 503, 502, 499, 473, 223, 24, 70,
/* 540 */ 47, 73, 540, 539, 537, 55, 494, 492, 484, 490,
/* 550 */ 75, 486, 488, 482, 480, 511, 509, 508, 507, 505,
/* 560 */ 501, 500, 48, 471, 442, 440, 99, 665, 664, 664,
/* 570 */ 664, 664, 664, 664, 664, 664, 664, 664, 100,
};
static const YYCODETYPE yy_lookahead[] = {
/* 0 */ 211, 1, 262, 262, 208, 209, 211, 1, 262, 9,
/* 10 */ 228, 271, 272, 13, 14, 9, 16, 17, 210, 211,
/* 20 */ 20, 21, 262, 1, 24, 25, 26, 27, 28, 228,
/* 30 */ 248, 9, 272, 33, 34, 262, 262, 37, 38, 39,
/* 40 */ 13, 14, 246, 16, 17, 271, 272, 20, 21, 248,
/* 50 */ 211, 24, 25, 26, 27, 28, 260, 268, 263, 270,
/* 60 */ 33, 34, 211, 211, 37, 38, 39, 45, 46, 47,
/* 0 */ 264, 1, 208, 209, 1, 210, 211, 264, 211, 9,
/* 10 */ 274, 264, 9, 13, 14, 264, 16, 17, 248, 211,
/* 20 */ 20, 21, 264, 1, 24, 25, 26, 27, 28, 216,
/* 30 */ 264, 9, 262, 33, 34, 211, 264, 37, 38, 39,
/* 40 */ 13, 14, 248, 16, 17, 273, 274, 20, 21, 211,
/* 50 */ 242, 24, 25, 26, 27, 28, 262, 244, 245, 246,
/* 60 */ 33, 34, 265, 264, 37, 38, 39, 45, 46, 47,
/* 70 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
/* 80 */ 13, 14, 60, 16, 17, 5, 247, 20, 21, 78,
/* 90 */ 228, 24, 25, 26, 27, 28, 245, 245, 247, 247,
/* 100 */ 33, 34, 262, 103, 37, 38, 39, 66, 262, 14,
/* 110 */ 248, 16, 17, 33, 34, 20, 21, 246, 99, 24,
/* 120 */ 25, 26, 27, 28, 211, 106, 262, 100, 33, 34,
/* 130 */ 73, 260, 37, 38, 39, 78, 262, 85, 86, 87,
/* 80 */ 13, 14, 60, 16, 17, 5, 76, 20, 21, 264,
/* 90 */ 266, 24, 25, 26, 27, 28, 228, 211, 273, 274,
/* 100 */ 33, 34, 78, 103, 37, 38, 39, 66, 270, 14,
/* 110 */ 272, 16, 17, 33, 34, 20, 21, 104, 250, 24,
/* 120 */ 25, 26, 27, 28, 63, 64, 65, 100, 33, 34,
/* 130 */ 228, 0, 37, 38, 39, 249, 123, 85, 86, 87,
/* 140 */ 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
/* 150 */ 98, 227, 211, 229, 230, 231, 232, 233, 234, 235,
/* 150 */ 98, 227, 250, 229, 230, 231, 232, 233, 234, 235,
/* 160 */ 236, 237, 238, 239, 240, 241, 16, 17, 211, 128,
/* 170 */ 20, 21, 131, 132, 24, 25, 26, 27, 28, 266,
/* 180 */ 249, 268, 99, 33, 34, 102, 103, 37, 38, 39,
/* 190 */ 1, 2, 261, 44, 5, 127, 7, 262, 9, 242,
/* 200 */ 1, 2, 134, 135, 5, 264, 7, 211, 9, 60,
/* 210 */ 1, 2, 104, 211, 5, 66, 7, 109, 9, 70,
/* 220 */ 71, 72, 33, 34, 33, 34, 37, 262, 37, 38,
/* 230 */ 39, 215, 33, 34, 218, 262, 37, 25, 26, 27,
/* 240 */ 28, 215, 33, 34, 218, 33, 34, 262, 99, 37,
/* 250 */ 38, 39, 37, 38, 39, 106, 85, 15, 87, 88,
/* 260 */ 211, 116, 117, 92, 268, 94, 95, 96, 215, 98,
/* 270 */ 268, 218, 61, 62, 262, 126, 99, 262, 67, 68,
/* 280 */ 69, 227, 133, 106, 230, 231, 75, 211, 99, 235,
/* 290 */ 100, 237, 238, 239, 245, 241, 247, 107, 99, 110,
/* 300 */ 63, 64, 65, 100, 61, 62, 1, 104, 99, 110,
/* 310 */ 67, 68, 69, 100, 125, 59, 100, 104, 262, 110,
/* 320 */ 104, 245, 2, 247, 125, 5, 100, 7, 262, 9,
/* 330 */ 104, 61, 62, 5, 125, 7, 262, 67, 68, 69,
/* 340 */ 100, 5, 37, 7, 104, 104, 100, 105, 104, 5,
/* 350 */ 104, 7, 100, 33, 34, 99, 104, 100, 129, 130,
/* 360 */ 262, 104, 129, 130, 123, 121, 262, 5, 248, 7,
/* 370 */ 73, 74, 61, 62, 248, 243, 243, 243, 243, 243,
/* 380 */ 243, 211, 244, 243, 211, 246, 211, 211, 269, 211,
/* 390 */ 269, 250, 211, 211, 211, 211, 211, 211, 211, 211,
/* 400 */ 106, 246, 59, 211, 211, 211, 211, 211, 211, 211,
/* 410 */ 110, 211, 211, 211, 122, 211, 211, 211, 211, 211,
/* 420 */ 259, 211, 265, 265, 265, 105, 212, 120, 211, 211,
/* 430 */ 211, 211, 211, 211, 211, 211, 211, 258, 211, 211,
/* 440 */ 119, 211, 211, 211, 114, 118, 212, 212, 113, 112,
/* 450 */ 111, 76, 84, 124, 83, 49, 80, 53, 5, 82,
/* 460 */ 81, 79, 76, 212, 5, 212, 5, 136, 136, 5,
/* 470 */ 216, 216, 212, 5, 86, 127, 107, 212, 100, 213,
/* 480 */ 212, 212, 220, 224, 226, 222, 225, 223, 221, 213,
/* 490 */ 219, 217, 253, 257, 256, 246, 214, 108, 104, 251,
/* 500 */ 255, 254, 252, 100, 99, 1, 99, 115, 100, 99,
/* 510 */ 115, 73, 100, 104, 99, 104, 99, 101, 105, 99,
/* 520 */ 101, 9, 5, 5, 5, 5, 5, 77, 15, 73,
/* 530 */ 16, 130, 130, 104, 5, 5, 100, 5, 99, 5,
/* 540 */ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
/* 550 */ 5, 5, 5, 104, 77, 59, 58, 0, 273, 273,
/* 560 */ 273, 273, 273, 273, 273, 273, 273, 273, 273, 21,
/* 570 */ 21, 273, 273, 273, 273, 273, 273, 273, 273, 273,
/* 580 */ 273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
/* 590 */ 273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
/* 600 */ 273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
/* 610 */ 273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
/* 620 */ 273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
/* 630 */ 273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
/* 640 */ 273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
/* 650 */ 273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
/* 660 */ 273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
/* 670 */ 273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
/* 680 */ 273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
/* 690 */ 273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
/* 700 */ 273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
/* 710 */ 273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
/* 720 */ 273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
/* 730 */ 273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
/* 740 */ 273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
/* 750 */ 273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
/* 760 */ 273, 273, 273, 273, 273, 273, 273, 273, 273, 273,
/* 770 */ 273, 273, 273, 273, 273, 273, 273, 273,
/* 170 */ 20, 21, 131, 132, 24, 25, 26, 27, 28, 37,
/* 180 */ 38, 39, 99, 33, 34, 102, 103, 37, 38, 39,
/* 190 */ 1, 2, 99, 44, 5, 211, 7, 15, 9, 106,
/* 200 */ 1, 2, 211, 264, 5, 127, 7, 76, 9, 60,
/* 210 */ 1, 2, 134, 135, 5, 66, 7, 216, 9, 70,
/* 220 */ 71, 72, 33, 34, 33, 34, 37, 270, 37, 38,
/* 230 */ 39, 264, 33, 34, 1, 228, 37, 25, 26, 27,
/* 240 */ 28, 215, 33, 34, 218, 33, 34, 246, 99, 37,
/* 250 */ 38, 39, 268, 99, 270, 106, 85, 250, 87, 88,
/* 260 */ 106, 270, 264, 92, 211, 94, 95, 96, 264, 98,
/* 270 */ 37, 215, 61, 62, 218, 126, 100, 211, 67, 68,
/* 280 */ 69, 227, 133, 107, 230, 231, 75, 105, 99, 235,
/* 290 */ 211, 237, 238, 239, 264, 241, 73, 264, 99, 110,
/* 300 */ 247, 78, 249, 215, 61, 62, 218, 211, 99, 110,
/* 310 */ 67, 68, 69, 247, 125, 249, 116, 117, 104, 110,
/* 320 */ 248, 251, 2, 109, 125, 5, 247, 7, 249, 9,
/* 330 */ 59, 61, 62, 263, 125, 264, 100, 67, 68, 69,
/* 340 */ 104, 264, 100, 247, 100, 249, 104, 100, 104, 104,
/* 350 */ 264, 104, 100, 33, 34, 264, 104, 5, 5, 7,
/* 360 */ 7, 100, 73, 74, 100, 104, 121, 100, 104, 264,
/* 370 */ 99, 104, 5, 264, 7, 129, 130, 129, 130, 250,
/* 380 */ 5, 243, 7, 61, 62, 250, 243, 243, 243, 243,
/* 390 */ 243, 243, 211, 271, 211, 211, 211, 271, 211, 211,
/* 400 */ 106, 211, 59, 252, 211, 211, 211, 211, 211, 211,
/* 410 */ 248, 110, 211, 211, 211, 211, 211, 211, 211, 211,
/* 420 */ 267, 211, 267, 267, 211, 105, 211, 211, 211, 211,
/* 430 */ 211, 211, 211, 211, 120, 211, 211, 211, 211, 211,
/* 440 */ 211, 211, 211, 211, 119, 211, 211, 261, 211, 211,
/* 450 */ 122, 212, 212, 212, 114, 118, 111, 113, 112, 124,
/* 460 */ 84, 83, 49, 80, 82, 53, 81, 79, 76, 212,
/* 470 */ 5, 212, 212, 5, 136, 5, 5, 212, 136, 216,
/* 480 */ 5, 86, 127, 104, 107, 1, 100, 212, 108, 220,
/* 490 */ 213, 212, 226, 225, 221, 213, 224, 223, 222, 219,
/* 500 */ 212, 217, 100, 248, 214, 99, 99, 254, 258, 260,
/* 510 */ 259, 257, 256, 255, 100, 253, 99, 99, 115, 104,
/* 520 */ 104, 100, 99, 115, 105, 101, 99, 101, 73, 9,
/* 530 */ 102, 5, 5, 5, 5, 5, 77, 15, 104, 73,
/* 540 */ 16, 130, 5, 5, 100, 99, 5, 5, 5, 5,
/* 550 */ 130, 5, 5, 5, 5, 5, 5, 5, 5, 5,
/* 560 */ 5, 5, 104, 77, 59, 58, 21, 0, 275, 275,
/* 570 */ 275, 275, 275, 275, 275, 275, 275, 275, 21, 275,
/* 580 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275,
/* 590 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275,
/* 600 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275,
/* 610 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275,
/* 620 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275,
/* 630 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275,
/* 640 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275,
/* 650 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275,
/* 660 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275,
/* 670 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275,
/* 680 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275,
/* 690 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275,
/* 700 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275,
/* 710 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275,
/* 720 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275,
/* 730 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275,
/* 740 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275,
/* 750 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275,
/* 760 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275,
/* 770 */ 275, 275, 275, 275, 275, 275, 275, 275, 275, 275,
/* 780 */ 275, 275, 275, 275, 275, 275,
};
#define YY_SHIFT_COUNT (252)
#define YY_SHIFT_COUNT (256)
#define YY_SHIFT_MIN (0)
#define YY_SHIFT_MAX (557)
#define YY_SHIFT_MAX (567)
static const unsigned short int yy_shift_ofst[] = {
/* 0 */ 149, 52, 171, 189, 209, 6, 6, 6, 6, 6,
/* 10 */ 6, 0, 22, 209, 320, 320, 320, 19, 6, 6,
/* 20 */ 6, 6, 6, 57, 11, 11, 571, 199, 209, 209,
/* 0 */ 149, 52, 171, 10, 189, 209, 3, 3, 3, 3,
/* 10 */ 3, 3, 0, 22, 209, 320, 320, 320, 93, 3,
/* 20 */ 3, 3, 131, 3, 3, 223, 24, 24, 579, 199,
/* 30 */ 209, 209, 209, 209, 209, 209, 209, 209, 209, 209,
/* 40 */ 209, 209, 209, 209, 209, 320, 320, 80, 80, 80,
/* 50 */ 80, 80, 80, 83, 80, 177, 6, 6, 6, 6,
/* 60 */ 145, 145, 108, 6, 6, 6, 6, 6, 6, 6,
/* 70 */ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
/* 80 */ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
/* 90 */ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
/* 100 */ 6, 6, 294, 343, 343, 300, 300, 300, 343, 307,
/* 110 */ 292, 321, 330, 327, 335, 337, 339, 329, 294, 343,
/* 120 */ 343, 375, 375, 343, 368, 371, 406, 376, 377, 404,
/* 130 */ 379, 382, 343, 386, 343, 386, 343, 571, 571, 27,
/* 140 */ 67, 67, 67, 95, 150, 212, 212, 212, 211, 191,
/* 150 */ 191, 191, 191, 243, 270, 41, 68, 215, 215, 237,
/* 160 */ 190, 203, 213, 216, 226, 240, 328, 336, 305, 256,
/* 170 */ 242, 241, 244, 246, 252, 257, 229, 233, 344, 362,
/* 180 */ 297, 311, 453, 331, 459, 461, 332, 464, 468, 388,
/* 190 */ 348, 369, 378, 389, 394, 403, 405, 504, 407, 408,
/* 200 */ 410, 409, 392, 411, 395, 412, 415, 413, 417, 416,
/* 210 */ 420, 419, 438, 512, 517, 518, 519, 520, 521, 450,
/* 220 */ 513, 456, 514, 401, 402, 429, 529, 530, 436, 439,
/* 230 */ 429, 532, 534, 535, 536, 537, 538, 539, 540, 541,
/* 240 */ 542, 543, 544, 545, 546, 547, 449, 477, 548, 549,
/* 250 */ 496, 498, 557,
/* 40 */ 209, 209, 209, 209, 209, 209, 209, 320, 320, 80,
/* 50 */ 80, 80, 80, 80, 80, 80, 154, 3, 3, 3,
/* 60 */ 3, 200, 200, 214, 3, 3, 3, 3, 3, 3,
/* 70 */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
/* 80 */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
/* 90 */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
/* 100 */ 3, 3, 3, 3, 294, 343, 343, 301, 301, 301,
/* 110 */ 343, 314, 328, 325, 340, 337, 344, 346, 345, 335,
/* 120 */ 294, 343, 343, 343, 10, 343, 376, 378, 413, 383,
/* 130 */ 382, 412, 385, 388, 343, 392, 343, 392, 343, 579,
/* 140 */ 579, 27, 67, 67, 67, 95, 150, 212, 212, 212,
/* 150 */ 211, 191, 191, 191, 191, 243, 270, 41, 78, 142,
/* 160 */ 142, 83, 61, 176, 236, 242, 244, 247, 252, 352,
/* 170 */ 353, 233, 271, 182, 13, 245, 261, 264, 267, 246,
/* 180 */ 248, 367, 375, 289, 322, 465, 338, 468, 470, 342,
/* 190 */ 471, 475, 395, 355, 377, 386, 380, 379, 402, 406,
/* 200 */ 484, 407, 414, 417, 415, 403, 416, 408, 421, 418,
/* 210 */ 419, 423, 424, 427, 426, 428, 455, 520, 526, 527,
/* 220 */ 528, 529, 530, 459, 522, 466, 524, 411, 420, 434,
/* 230 */ 537, 538, 444, 446, 434, 541, 542, 543, 544, 546,
/* 240 */ 547, 548, 549, 550, 551, 552, 553, 554, 555, 556,
/* 250 */ 458, 486, 545, 557, 505, 507, 567,
};
#define YY_REDUCE_COUNT (138)
#define YY_REDUCE_MIN (-260)
#define YY_REDUCE_MAX (282)
#define YY_REDUCE_COUNT (140)
#define YY_REDUCE_MIN (-264)
#define YY_REDUCE_MAX (290)
static const short yy_reduce_ofst[] = {
/* 0 */ -204, -76, 54, -260, -226, -211, -87, -149, -148, 49,
/* 10 */ 76, -205, -192, -240, -218, -199, -138, -129, -59, -4,
/* 20 */ 2, -43, -161, 16, 26, 53, -69, -259, -254, -227,
/* 30 */ -160, -154, -136, -126, -65, -35, -27, -15, 12, 15,
/* 40 */ 56, 66, 74, 98, 104, 120, 126, 132, 133, 134,
/* 50 */ 135, 136, 137, 138, 140, 139, 170, 173, 175, 176,
/* 60 */ 119, 121, 141, 178, 181, 182, 183, 184, 185, 186,
/* 70 */ 187, 188, 192, 193, 194, 195, 196, 197, 198, 200,
/* 80 */ 201, 202, 204, 205, 206, 207, 208, 210, 217, 218,
/* 90 */ 219, 220, 221, 222, 223, 224, 225, 227, 228, 230,
/* 100 */ 231, 232, 155, 214, 234, 157, 158, 159, 235, 161,
/* 110 */ 179, 236, 238, 245, 247, 239, 250, 248, 249, 251,
/* 120 */ 253, 254, 255, 260, 258, 261, 259, 262, 264, 267,
/* 130 */ 263, 271, 265, 266, 268, 276, 269, 274, 282,
/* 0 */ -206, -76, 54, -187, -228, -175, -162, -16, 53, 66,
/* 10 */ 79, 96, -203, -205, -264, -132, -98, 7, -230, -176,
/* 20 */ -43, -9, 1, -192, -114, 26, 56, 88, 70, -257,
/* 30 */ -253, -249, -242, -234, -201, -61, -33, -2, 4, 30,
/* 40 */ 33, 71, 77, 86, 91, 105, 109, 129, 135, 138,
/* 50 */ 143, 144, 145, 146, 147, 148, 72, 181, 183, 184,
/* 60 */ 185, 122, 126, 151, 187, 188, 190, 193, 194, 195,
/* 70 */ 196, 197, 198, 201, 202, 203, 204, 205, 206, 207,
/* 80 */ 208, 210, 213, 215, 216, 217, 218, 219, 220, 221,
/* 90 */ 222, 224, 225, 226, 227, 228, 229, 230, 231, 232,
/* 100 */ 234, 235, 237, 238, 162, 239, 240, 153, 155, 156,
/* 110 */ 241, 186, 249, 251, 250, 254, 256, 258, 253, 262,
/* 120 */ 255, 257, 259, 260, 263, 265, 266, 268, 272, 269,
/* 130 */ 274, 273, 276, 280, 275, 277, 279, 282, 288, 284,
/* 140 */ 290,
};
static const YYACTIONTYPE yy_default[] = {
/* 0 */ 653, 707, 696, 878, 878, 653, 653, 653, 653, 653,
/* 10 */ 653, 803, 671, 878, 653, 653, 653, 653, 653, 653,
/* 20 */ 653, 653, 653, 709, 709, 709, 798, 653, 653, 653,
/* 30 */ 653, 653, 653, 653, 653, 653, 653, 653, 653, 653,
/* 40 */ 653, 653, 653, 653, 653, 653, 653, 653, 653, 653,
/* 50 */ 653, 653, 653, 653, 653, 653, 653, 805, 807, 653,
/* 60 */ 825, 825, 796, 653, 653, 653, 653, 653, 653, 653,
/* 70 */ 653, 653, 653, 653, 653, 653, 653, 653, 653, 653,
/* 80 */ 653, 694, 653, 692, 653, 653, 653, 653, 653, 653,
/* 90 */ 653, 653, 653, 653, 653, 653, 681, 653, 653, 653,
/* 100 */ 653, 653, 653, 673, 673, 653, 653, 653, 673, 832,
/* 110 */ 836, 830, 818, 826, 817, 813, 812, 840, 653, 673,
/* 120 */ 673, 704, 704, 673, 725, 723, 721, 713, 719, 715,
/* 130 */ 717, 711, 673, 702, 673, 702, 673, 742, 757, 653,
/* 140 */ 841, 877, 831, 867, 866, 873, 865, 864, 653, 860,
/* 150 */ 861, 863, 862, 653, 653, 653, 653, 869, 868, 653,
/* 160 */ 653, 653, 653, 653, 653, 653, 653, 653, 653, 843,
/* 170 */ 653, 837, 833, 653, 653, 653, 653, 653, 653, 653,
/* 180 */ 653, 653, 653, 653, 653, 653, 653, 653, 653, 653,
/* 190 */ 653, 795, 653, 653, 804, 653, 653, 653, 653, 653,
/* 200 */ 653, 827, 653, 819, 653, 653, 653, 653, 653, 653,
/* 210 */ 653, 772, 653, 653, 653, 653, 653, 653, 653, 653,
/* 220 */ 653, 653, 653, 653, 653, 882, 653, 653, 653, 766,
/* 230 */ 880, 653, 653, 653, 653, 653, 653, 653, 653, 653,
/* 240 */ 653, 653, 653, 653, 653, 653, 728, 653, 679, 677,
/* 250 */ 653, 669, 653,
/* 0 */ 662, 716, 705, 713, 890, 890, 662, 662, 662, 662,
/* 10 */ 662, 662, 815, 680, 890, 662, 662, 662, 662, 662,
/* 20 */ 662, 662, 713, 662, 662, 718, 718, 718, 810, 662,
/* 30 */ 662, 662, 662, 662, 662, 662, 662, 662, 662, 662,
/* 40 */ 662, 662, 662, 662, 662, 662, 662, 662, 662, 662,
/* 50 */ 662, 662, 662, 662, 662, 662, 662, 662, 817, 819,
/* 60 */ 662, 837, 837, 808, 662, 662, 662, 662, 662, 662,
/* 70 */ 662, 662, 662, 662, 662, 662, 662, 662, 662, 662,
/* 80 */ 662, 662, 662, 703, 662, 701, 662, 662, 662, 662,
/* 90 */ 662, 662, 662, 662, 662, 662, 662, 662, 690, 662,
/* 100 */ 662, 662, 662, 662, 662, 682, 682, 662, 662, 662,
/* 110 */ 682, 844, 848, 842, 830, 838, 829, 825, 824, 852,
/* 120 */ 662, 682, 682, 682, 713, 682, 734, 732, 730, 722,
/* 130 */ 728, 724, 726, 720, 682, 711, 682, 711, 682, 751,
/* 140 */ 766, 662, 853, 889, 843, 879, 878, 885, 877, 876,
/* 150 */ 662, 872, 873, 875, 874, 662, 662, 662, 662, 881,
/* 160 */ 880, 662, 662, 662, 662, 662, 662, 662, 662, 662,
/* 170 */ 662, 662, 855, 662, 849, 845, 662, 662, 662, 662,
/* 180 */ 662, 662, 662, 662, 662, 662, 662, 662, 662, 662,
/* 190 */ 662, 662, 662, 662, 807, 662, 662, 816, 662, 662,
/* 200 */ 662, 662, 662, 662, 839, 662, 831, 662, 662, 662,
/* 210 */ 662, 662, 784, 662, 662, 662, 662, 662, 662, 662,
/* 220 */ 662, 662, 662, 662, 662, 662, 662, 662, 662, 894,
/* 230 */ 662, 662, 662, 775, 892, 662, 662, 662, 662, 662,
/* 240 */ 662, 662, 662, 662, 662, 662, 662, 662, 662, 662,
/* 250 */ 737, 662, 688, 686, 662, 678, 662,
};
/********** End of lemon-generated parsing tables *****************************/
......@@ -977,34 +980,36 @@ static const char *const yyTokenName[] = {
/* 242 */ "typename",
/* 243 */ "signed",
/* 244 */ "create_table_args",
/* 245 */ "columnlist",
/* 246 */ "select",
/* 247 */ "column",
/* 248 */ "tagitem",
/* 249 */ "selcollist",
/* 250 */ "from",
/* 251 */ "where_opt",
/* 252 */ "interval_opt",
/* 253 */ "fill_opt",
/* 254 */ "sliding_opt",
/* 255 */ "groupby_opt",
/* 256 */ "orderby_opt",
/* 257 */ "having_opt",
/* 258 */ "slimit_opt",
/* 259 */ "limit_opt",
/* 260 */ "union",
/* 261 */ "sclp",
/* 262 */ "expr",
/* 263 */ "as",
/* 264 */ "tablelist",
/* 265 */ "tmvar",
/* 266 */ "sortlist",
/* 267 */ "sortitem",
/* 268 */ "item",
/* 269 */ "sortorder",
/* 270 */ "grouplist",
/* 271 */ "exprlist",
/* 272 */ "expritem",
/* 245 */ "create_table_list",
/* 246 */ "create_from_stable",
/* 247 */ "columnlist",
/* 248 */ "select",
/* 249 */ "column",
/* 250 */ "tagitem",
/* 251 */ "selcollist",
/* 252 */ "from",
/* 253 */ "where_opt",
/* 254 */ "interval_opt",
/* 255 */ "fill_opt",
/* 256 */ "sliding_opt",
/* 257 */ "groupby_opt",
/* 258 */ "orderby_opt",
/* 259 */ "having_opt",
/* 260 */ "slimit_opt",
/* 261 */ "limit_opt",
/* 262 */ "union",
/* 263 */ "sclp",
/* 264 */ "expr",
/* 265 */ "as",
/* 266 */ "tablelist",
/* 267 */ "tmvar",
/* 268 */ "sortlist",
/* 269 */ "sortitem",
/* 270 */ "item",
/* 271 */ "sortorder",
/* 272 */ "grouplist",
/* 273 */ "exprlist",
/* 274 */ "expritem",
};
#endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
......@@ -1127,124 +1132,127 @@ static const char *const yyRuleName[] = {
/* 112 */ "signed ::= INTEGER",
/* 113 */ "signed ::= PLUS INTEGER",
/* 114 */ "signed ::= MINUS INTEGER",
/* 115 */ "cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args",
/* 116 */ "create_table_args ::= LP columnlist RP",
/* 117 */ "create_table_args ::= LP columnlist RP TAGS LP columnlist RP",
/* 118 */ "create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP",
/* 119 */ "create_table_args ::= AS select",
/* 120 */ "columnlist ::= columnlist COMMA column",
/* 121 */ "columnlist ::= column",
/* 122 */ "column ::= ids typename",
/* 123 */ "tagitemlist ::= tagitemlist COMMA tagitem",
/* 124 */ "tagitemlist ::= tagitem",
/* 125 */ "tagitem ::= INTEGER",
/* 126 */ "tagitem ::= FLOAT",
/* 127 */ "tagitem ::= STRING",
/* 128 */ "tagitem ::= BOOL",
/* 129 */ "tagitem ::= NULL",
/* 130 */ "tagitem ::= MINUS INTEGER",
/* 131 */ "tagitem ::= MINUS FLOAT",
/* 132 */ "tagitem ::= PLUS INTEGER",
/* 133 */ "tagitem ::= PLUS FLOAT",
/* 134 */ "select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt",
/* 135 */ "union ::= select",
/* 136 */ "union ::= LP union RP",
/* 137 */ "union ::= union UNION ALL select",
/* 138 */ "union ::= union UNION ALL LP select RP",
/* 139 */ "cmd ::= union",
/* 140 */ "select ::= SELECT selcollist",
/* 141 */ "sclp ::= selcollist COMMA",
/* 142 */ "sclp ::=",
/* 143 */ "selcollist ::= sclp expr as",
/* 144 */ "selcollist ::= sclp STAR",
/* 145 */ "as ::= AS ids",
/* 146 */ "as ::= ids",
/* 147 */ "as ::=",
/* 148 */ "from ::= FROM tablelist",
/* 149 */ "tablelist ::= ids cpxName",
/* 150 */ "tablelist ::= ids cpxName ids",
/* 151 */ "tablelist ::= tablelist COMMA ids cpxName",
/* 152 */ "tablelist ::= tablelist COMMA ids cpxName ids",
/* 153 */ "tmvar ::= VARIABLE",
/* 154 */ "interval_opt ::= INTERVAL LP tmvar RP",
/* 155 */ "interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP",
/* 156 */ "interval_opt ::=",
/* 157 */ "fill_opt ::=",
/* 158 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
/* 159 */ "fill_opt ::= FILL LP ID RP",
/* 160 */ "sliding_opt ::= SLIDING LP tmvar RP",
/* 161 */ "sliding_opt ::=",
/* 162 */ "orderby_opt ::=",
/* 163 */ "orderby_opt ::= ORDER BY sortlist",
/* 164 */ "sortlist ::= sortlist COMMA item sortorder",
/* 165 */ "sortlist ::= item sortorder",
/* 166 */ "item ::= ids cpxName",
/* 167 */ "sortorder ::= ASC",
/* 168 */ "sortorder ::= DESC",
/* 169 */ "sortorder ::=",
/* 170 */ "groupby_opt ::=",
/* 171 */ "groupby_opt ::= GROUP BY grouplist",
/* 172 */ "grouplist ::= grouplist COMMA item",
/* 173 */ "grouplist ::= item",
/* 174 */ "having_opt ::=",
/* 175 */ "having_opt ::= HAVING expr",
/* 176 */ "limit_opt ::=",
/* 177 */ "limit_opt ::= LIMIT signed",
/* 178 */ "limit_opt ::= LIMIT signed OFFSET signed",
/* 179 */ "limit_opt ::= LIMIT signed COMMA signed",
/* 180 */ "slimit_opt ::=",
/* 181 */ "slimit_opt ::= SLIMIT signed",
/* 182 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
/* 183 */ "slimit_opt ::= SLIMIT signed COMMA signed",
/* 184 */ "where_opt ::=",
/* 185 */ "where_opt ::= WHERE expr",
/* 186 */ "expr ::= LP expr RP",
/* 187 */ "expr ::= ID",
/* 188 */ "expr ::= ID DOT ID",
/* 189 */ "expr ::= ID DOT STAR",
/* 190 */ "expr ::= INTEGER",
/* 191 */ "expr ::= MINUS INTEGER",
/* 192 */ "expr ::= PLUS INTEGER",
/* 193 */ "expr ::= FLOAT",
/* 194 */ "expr ::= MINUS FLOAT",
/* 195 */ "expr ::= PLUS FLOAT",
/* 196 */ "expr ::= STRING",
/* 197 */ "expr ::= NOW",
/* 198 */ "expr ::= VARIABLE",
/* 199 */ "expr ::= BOOL",
/* 200 */ "expr ::= ID LP exprlist RP",
/* 201 */ "expr ::= ID LP STAR RP",
/* 202 */ "expr ::= expr IS NULL",
/* 203 */ "expr ::= expr IS NOT NULL",
/* 204 */ "expr ::= expr LT expr",
/* 205 */ "expr ::= expr GT expr",
/* 206 */ "expr ::= expr LE expr",
/* 207 */ "expr ::= expr GE expr",
/* 208 */ "expr ::= expr NE expr",
/* 209 */ "expr ::= expr EQ expr",
/* 210 */ "expr ::= expr AND expr",
/* 211 */ "expr ::= expr OR expr",
/* 212 */ "expr ::= expr PLUS expr",
/* 213 */ "expr ::= expr MINUS expr",
/* 214 */ "expr ::= expr STAR expr",
/* 215 */ "expr ::= expr SLASH expr",
/* 216 */ "expr ::= expr REM expr",
/* 217 */ "expr ::= expr LIKE expr",
/* 218 */ "expr ::= expr IN LP exprlist RP",
/* 219 */ "exprlist ::= exprlist COMMA expritem",
/* 220 */ "exprlist ::= expritem",
/* 221 */ "expritem ::= expr",
/* 222 */ "expritem ::=",
/* 223 */ "cmd ::= RESET QUERY CACHE",
/* 224 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
/* 225 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
/* 226 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
/* 227 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
/* 228 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
/* 229 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
/* 230 */ "cmd ::= KILL CONNECTION INTEGER",
/* 231 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
/* 232 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
/* 115 */ "cmd ::= CREATE TABLE create_table_args",
/* 116 */ "cmd ::= CREATE TABLE create_table_list",
/* 117 */ "create_table_list ::= create_from_stable",
/* 118 */ "create_table_list ::= create_table_list create_from_stable",
/* 119 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP",
/* 120 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP",
/* 121 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP",
/* 122 */ "create_table_args ::= ifnotexists ids cpxName AS select",
/* 123 */ "columnlist ::= columnlist COMMA column",
/* 124 */ "columnlist ::= column",
/* 125 */ "column ::= ids typename",
/* 126 */ "tagitemlist ::= tagitemlist COMMA tagitem",
/* 127 */ "tagitemlist ::= tagitem",
/* 128 */ "tagitem ::= INTEGER",
/* 129 */ "tagitem ::= FLOAT",
/* 130 */ "tagitem ::= STRING",
/* 131 */ "tagitem ::= BOOL",
/* 132 */ "tagitem ::= NULL",
/* 133 */ "tagitem ::= MINUS INTEGER",
/* 134 */ "tagitem ::= MINUS FLOAT",
/* 135 */ "tagitem ::= PLUS INTEGER",
/* 136 */ "tagitem ::= PLUS FLOAT",
/* 137 */ "select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt",
/* 138 */ "union ::= select",
/* 139 */ "union ::= LP union RP",
/* 140 */ "union ::= union UNION ALL select",
/* 141 */ "union ::= union UNION ALL LP select RP",
/* 142 */ "cmd ::= union",
/* 143 */ "select ::= SELECT selcollist",
/* 144 */ "sclp ::= selcollist COMMA",
/* 145 */ "sclp ::=",
/* 146 */ "selcollist ::= sclp expr as",
/* 147 */ "selcollist ::= sclp STAR",
/* 148 */ "as ::= AS ids",
/* 149 */ "as ::= ids",
/* 150 */ "as ::=",
/* 151 */ "from ::= FROM tablelist",
/* 152 */ "tablelist ::= ids cpxName",
/* 153 */ "tablelist ::= ids cpxName ids",
/* 154 */ "tablelist ::= tablelist COMMA ids cpxName",
/* 155 */ "tablelist ::= tablelist COMMA ids cpxName ids",
/* 156 */ "tmvar ::= VARIABLE",
/* 157 */ "interval_opt ::= INTERVAL LP tmvar RP",
/* 158 */ "interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP",
/* 159 */ "interval_opt ::=",
/* 160 */ "fill_opt ::=",
/* 161 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
/* 162 */ "fill_opt ::= FILL LP ID RP",
/* 163 */ "sliding_opt ::= SLIDING LP tmvar RP",
/* 164 */ "sliding_opt ::=",
/* 165 */ "orderby_opt ::=",
/* 166 */ "orderby_opt ::= ORDER BY sortlist",
/* 167 */ "sortlist ::= sortlist COMMA item sortorder",
/* 168 */ "sortlist ::= item sortorder",
/* 169 */ "item ::= ids cpxName",
/* 170 */ "sortorder ::= ASC",
/* 171 */ "sortorder ::= DESC",
/* 172 */ "sortorder ::=",
/* 173 */ "groupby_opt ::=",
/* 174 */ "groupby_opt ::= GROUP BY grouplist",
/* 175 */ "grouplist ::= grouplist COMMA item",
/* 176 */ "grouplist ::= item",
/* 177 */ "having_opt ::=",
/* 178 */ "having_opt ::= HAVING expr",
/* 179 */ "limit_opt ::=",
/* 180 */ "limit_opt ::= LIMIT signed",
/* 181 */ "limit_opt ::= LIMIT signed OFFSET signed",
/* 182 */ "limit_opt ::= LIMIT signed COMMA signed",
/* 183 */ "slimit_opt ::=",
/* 184 */ "slimit_opt ::= SLIMIT signed",
/* 185 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
/* 186 */ "slimit_opt ::= SLIMIT signed COMMA signed",
/* 187 */ "where_opt ::=",
/* 188 */ "where_opt ::= WHERE expr",
/* 189 */ "expr ::= LP expr RP",
/* 190 */ "expr ::= ID",
/* 191 */ "expr ::= ID DOT ID",
/* 192 */ "expr ::= ID DOT STAR",
/* 193 */ "expr ::= INTEGER",
/* 194 */ "expr ::= MINUS INTEGER",
/* 195 */ "expr ::= PLUS INTEGER",
/* 196 */ "expr ::= FLOAT",
/* 197 */ "expr ::= MINUS FLOAT",
/* 198 */ "expr ::= PLUS FLOAT",
/* 199 */ "expr ::= STRING",
/* 200 */ "expr ::= NOW",
/* 201 */ "expr ::= VARIABLE",
/* 202 */ "expr ::= BOOL",
/* 203 */ "expr ::= ID LP exprlist RP",
/* 204 */ "expr ::= ID LP STAR RP",
/* 205 */ "expr ::= expr IS NULL",
/* 206 */ "expr ::= expr IS NOT NULL",
/* 207 */ "expr ::= expr LT expr",
/* 208 */ "expr ::= expr GT expr",
/* 209 */ "expr ::= expr LE expr",
/* 210 */ "expr ::= expr GE expr",
/* 211 */ "expr ::= expr NE expr",
/* 212 */ "expr ::= expr EQ expr",
/* 213 */ "expr ::= expr AND expr",
/* 214 */ "expr ::= expr OR expr",
/* 215 */ "expr ::= expr PLUS expr",
/* 216 */ "expr ::= expr MINUS expr",
/* 217 */ "expr ::= expr STAR expr",
/* 218 */ "expr ::= expr SLASH expr",
/* 219 */ "expr ::= expr REM expr",
/* 220 */ "expr ::= expr LIKE expr",
/* 221 */ "expr ::= expr IN LP exprlist RP",
/* 222 */ "exprlist ::= exprlist COMMA expritem",
/* 223 */ "exprlist ::= expritem",
/* 224 */ "expritem ::= expr",
/* 225 */ "expritem ::=",
/* 226 */ "cmd ::= RESET QUERY CACHE",
/* 227 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
/* 228 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
/* 229 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
/* 230 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
/* 231 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
/* 232 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
/* 233 */ "cmd ::= KILL CONNECTION INTEGER",
/* 234 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
/* 235 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
};
#endif /* NDEBUG */
......@@ -1367,44 +1375,49 @@ static void yy_destructor(
/********* Begin destructor definitions ***************************************/
case 227: /* keep */
case 228: /* tagitemlist */
case 245: /* columnlist */
case 253: /* fill_opt */
case 255: /* groupby_opt */
case 256: /* orderby_opt */
case 266: /* sortlist */
case 270: /* grouplist */
case 247: /* columnlist */
case 255: /* fill_opt */
case 257: /* groupby_opt */
case 258: /* orderby_opt */
case 268: /* sortlist */
case 272: /* grouplist */
{
taosArrayDestroy((yypminor->yy165));
taosArrayDestroy((yypminor->yy131));
}
break;
case 246: /* select */
case 245: /* create_table_list */
{
doDestroyQuerySql((yypminor->yy414));
destroyCreateTableSQL((yypminor->yy538));
}
break;
case 249: /* selcollist */
case 261: /* sclp */
case 271: /* exprlist */
case 248: /* select */
{
tSQLExprListDestroy((yypminor->yy290));
doDestroyQuerySql((yypminor->yy84));
}
break;
case 251: /* where_opt */
case 257: /* having_opt */
case 262: /* expr */
case 272: /* expritem */
case 251: /* selcollist */
case 263: /* sclp */
case 273: /* exprlist */
{
tSQLExprDestroy((yypminor->yy64));
tSQLExprListDestroy((yypminor->yy478));
}
break;
case 260: /* union */
case 253: /* where_opt */
case 259: /* having_opt */
case 264: /* expr */
case 274: /* expritem */
{
destroyAllSelectClause((yypminor->yy231));
tSQLExprDestroy((yypminor->yy420));
}
break;
case 267: /* sortitem */
case 262: /* union */
{
tVariantDestroy(&(yypminor->yy134));
destroyAllSelectClause((yypminor->yy513));
}
break;
case 269: /* sortitem */
{
tVariantDestroy(&(yypminor->yy516));
}
break;
/********* End destructor definitions *****************************************/
......@@ -1813,124 +1826,127 @@ static const struct {
{ 243, -1 }, /* (112) signed ::= INTEGER */
{ 243, -2 }, /* (113) signed ::= PLUS INTEGER */
{ 243, -2 }, /* (114) signed ::= MINUS INTEGER */
{ 209, -6 }, /* (115) cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args */
{ 244, -3 }, /* (116) create_table_args ::= LP columnlist RP */
{ 244, -7 }, /* (117) create_table_args ::= LP columnlist RP TAGS LP columnlist RP */
{ 244, -7 }, /* (118) create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP */
{ 244, -2 }, /* (119) create_table_args ::= AS select */
{ 245, -3 }, /* (120) columnlist ::= columnlist COMMA column */
{ 245, -1 }, /* (121) columnlist ::= column */
{ 247, -2 }, /* (122) column ::= ids typename */
{ 228, -3 }, /* (123) tagitemlist ::= tagitemlist COMMA tagitem */
{ 228, -1 }, /* (124) tagitemlist ::= tagitem */
{ 248, -1 }, /* (125) tagitem ::= INTEGER */
{ 248, -1 }, /* (126) tagitem ::= FLOAT */
{ 248, -1 }, /* (127) tagitem ::= STRING */
{ 248, -1 }, /* (128) tagitem ::= BOOL */
{ 248, -1 }, /* (129) tagitem ::= NULL */
{ 248, -2 }, /* (130) tagitem ::= MINUS INTEGER */
{ 248, -2 }, /* (131) tagitem ::= MINUS FLOAT */
{ 248, -2 }, /* (132) tagitem ::= PLUS INTEGER */
{ 248, -2 }, /* (133) tagitem ::= PLUS FLOAT */
{ 246, -12 }, /* (134) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
{ 260, -1 }, /* (135) union ::= select */
{ 260, -3 }, /* (136) union ::= LP union RP */
{ 260, -4 }, /* (137) union ::= union UNION ALL select */
{ 260, -6 }, /* (138) union ::= union UNION ALL LP select RP */
{ 209, -1 }, /* (139) cmd ::= union */
{ 246, -2 }, /* (140) select ::= SELECT selcollist */
{ 261, -2 }, /* (141) sclp ::= selcollist COMMA */
{ 261, 0 }, /* (142) sclp ::= */
{ 249, -3 }, /* (143) selcollist ::= sclp expr as */
{ 249, -2 }, /* (144) selcollist ::= sclp STAR */
{ 263, -2 }, /* (145) as ::= AS ids */
{ 263, -1 }, /* (146) as ::= ids */
{ 263, 0 }, /* (147) as ::= */
{ 250, -2 }, /* (148) from ::= FROM tablelist */
{ 264, -2 }, /* (149) tablelist ::= ids cpxName */
{ 264, -3 }, /* (150) tablelist ::= ids cpxName ids */
{ 264, -4 }, /* (151) tablelist ::= tablelist COMMA ids cpxName */
{ 264, -5 }, /* (152) tablelist ::= tablelist COMMA ids cpxName ids */
{ 265, -1 }, /* (153) tmvar ::= VARIABLE */
{ 252, -4 }, /* (154) interval_opt ::= INTERVAL LP tmvar RP */
{ 252, -6 }, /* (155) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
{ 252, 0 }, /* (156) interval_opt ::= */
{ 253, 0 }, /* (157) fill_opt ::= */
{ 253, -6 }, /* (158) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
{ 253, -4 }, /* (159) fill_opt ::= FILL LP ID RP */
{ 254, -4 }, /* (160) sliding_opt ::= SLIDING LP tmvar RP */
{ 254, 0 }, /* (161) sliding_opt ::= */
{ 256, 0 }, /* (162) orderby_opt ::= */
{ 256, -3 }, /* (163) orderby_opt ::= ORDER BY sortlist */
{ 266, -4 }, /* (164) sortlist ::= sortlist COMMA item sortorder */
{ 266, -2 }, /* (165) sortlist ::= item sortorder */
{ 268, -2 }, /* (166) item ::= ids cpxName */
{ 269, -1 }, /* (167) sortorder ::= ASC */
{ 269, -1 }, /* (168) sortorder ::= DESC */
{ 269, 0 }, /* (169) sortorder ::= */
{ 255, 0 }, /* (170) groupby_opt ::= */
{ 255, -3 }, /* (171) groupby_opt ::= GROUP BY grouplist */
{ 270, -3 }, /* (172) grouplist ::= grouplist COMMA item */
{ 270, -1 }, /* (173) grouplist ::= item */
{ 257, 0 }, /* (174) having_opt ::= */
{ 257, -2 }, /* (175) having_opt ::= HAVING expr */
{ 259, 0 }, /* (176) limit_opt ::= */
{ 259, -2 }, /* (177) limit_opt ::= LIMIT signed */
{ 259, -4 }, /* (178) limit_opt ::= LIMIT signed OFFSET signed */
{ 259, -4 }, /* (179) limit_opt ::= LIMIT signed COMMA signed */
{ 258, 0 }, /* (180) slimit_opt ::= */
{ 258, -2 }, /* (181) slimit_opt ::= SLIMIT signed */
{ 258, -4 }, /* (182) slimit_opt ::= SLIMIT signed SOFFSET signed */
{ 258, -4 }, /* (183) slimit_opt ::= SLIMIT signed COMMA signed */
{ 251, 0 }, /* (184) where_opt ::= */
{ 251, -2 }, /* (185) where_opt ::= WHERE expr */
{ 262, -3 }, /* (186) expr ::= LP expr RP */
{ 262, -1 }, /* (187) expr ::= ID */
{ 262, -3 }, /* (188) expr ::= ID DOT ID */
{ 262, -3 }, /* (189) expr ::= ID DOT STAR */
{ 262, -1 }, /* (190) expr ::= INTEGER */
{ 262, -2 }, /* (191) expr ::= MINUS INTEGER */
{ 262, -2 }, /* (192) expr ::= PLUS INTEGER */
{ 262, -1 }, /* (193) expr ::= FLOAT */
{ 262, -2 }, /* (194) expr ::= MINUS FLOAT */
{ 262, -2 }, /* (195) expr ::= PLUS FLOAT */
{ 262, -1 }, /* (196) expr ::= STRING */
{ 262, -1 }, /* (197) expr ::= NOW */
{ 262, -1 }, /* (198) expr ::= VARIABLE */
{ 262, -1 }, /* (199) expr ::= BOOL */
{ 262, -4 }, /* (200) expr ::= ID LP exprlist RP */
{ 262, -4 }, /* (201) expr ::= ID LP STAR RP */
{ 262, -3 }, /* (202) expr ::= expr IS NULL */
{ 262, -4 }, /* (203) expr ::= expr IS NOT NULL */
{ 262, -3 }, /* (204) expr ::= expr LT expr */
{ 262, -3 }, /* (205) expr ::= expr GT expr */
{ 262, -3 }, /* (206) expr ::= expr LE expr */
{ 262, -3 }, /* (207) expr ::= expr GE expr */
{ 262, -3 }, /* (208) expr ::= expr NE expr */
{ 262, -3 }, /* (209) expr ::= expr EQ expr */
{ 262, -3 }, /* (210) expr ::= expr AND expr */
{ 262, -3 }, /* (211) expr ::= expr OR expr */
{ 262, -3 }, /* (212) expr ::= expr PLUS expr */
{ 262, -3 }, /* (213) expr ::= expr MINUS expr */
{ 262, -3 }, /* (214) expr ::= expr STAR expr */
{ 262, -3 }, /* (215) expr ::= expr SLASH expr */
{ 262, -3 }, /* (216) expr ::= expr REM expr */
{ 262, -3 }, /* (217) expr ::= expr LIKE expr */
{ 262, -5 }, /* (218) expr ::= expr IN LP exprlist RP */
{ 271, -3 }, /* (219) exprlist ::= exprlist COMMA expritem */
{ 271, -1 }, /* (220) exprlist ::= expritem */
{ 272, -1 }, /* (221) expritem ::= expr */
{ 272, 0 }, /* (222) expritem ::= */
{ 209, -3 }, /* (223) cmd ::= RESET QUERY CACHE */
{ 209, -7 }, /* (224) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
{ 209, -7 }, /* (225) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
{ 209, -7 }, /* (226) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
{ 209, -7 }, /* (227) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
{ 209, -8 }, /* (228) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
{ 209, -9 }, /* (229) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
{ 209, -3 }, /* (230) cmd ::= KILL CONNECTION INTEGER */
{ 209, -5 }, /* (231) cmd ::= KILL STREAM INTEGER COLON INTEGER */
{ 209, -5 }, /* (232) cmd ::= KILL QUERY INTEGER COLON INTEGER */
{ 209, -3 }, /* (115) cmd ::= CREATE TABLE create_table_args */
{ 209, -3 }, /* (116) cmd ::= CREATE TABLE create_table_list */
{ 245, -1 }, /* (117) create_table_list ::= create_from_stable */
{ 245, -2 }, /* (118) create_table_list ::= create_table_list create_from_stable */
{ 244, -6 }, /* (119) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
{ 244, -10 }, /* (120) create_table_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
{ 246, -10 }, /* (121) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
{ 244, -5 }, /* (122) create_table_args ::= ifnotexists ids cpxName AS select */
{ 247, -3 }, /* (123) columnlist ::= columnlist COMMA column */
{ 247, -1 }, /* (124) columnlist ::= column */
{ 249, -2 }, /* (125) column ::= ids typename */
{ 228, -3 }, /* (126) tagitemlist ::= tagitemlist COMMA tagitem */
{ 228, -1 }, /* (127) tagitemlist ::= tagitem */
{ 250, -1 }, /* (128) tagitem ::= INTEGER */
{ 250, -1 }, /* (129) tagitem ::= FLOAT */
{ 250, -1 }, /* (130) tagitem ::= STRING */
{ 250, -1 }, /* (131) tagitem ::= BOOL */
{ 250, -1 }, /* (132) tagitem ::= NULL */
{ 250, -2 }, /* (133) tagitem ::= MINUS INTEGER */
{ 250, -2 }, /* (134) tagitem ::= MINUS FLOAT */
{ 250, -2 }, /* (135) tagitem ::= PLUS INTEGER */
{ 250, -2 }, /* (136) tagitem ::= PLUS FLOAT */
{ 248, -12 }, /* (137) select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
{ 262, -1 }, /* (138) union ::= select */
{ 262, -3 }, /* (139) union ::= LP union RP */
{ 262, -4 }, /* (140) union ::= union UNION ALL select */
{ 262, -6 }, /* (141) union ::= union UNION ALL LP select RP */
{ 209, -1 }, /* (142) cmd ::= union */
{ 248, -2 }, /* (143) select ::= SELECT selcollist */
{ 263, -2 }, /* (144) sclp ::= selcollist COMMA */
{ 263, 0 }, /* (145) sclp ::= */
{ 251, -3 }, /* (146) selcollist ::= sclp expr as */
{ 251, -2 }, /* (147) selcollist ::= sclp STAR */
{ 265, -2 }, /* (148) as ::= AS ids */
{ 265, -1 }, /* (149) as ::= ids */
{ 265, 0 }, /* (150) as ::= */
{ 252, -2 }, /* (151) from ::= FROM tablelist */
{ 266, -2 }, /* (152) tablelist ::= ids cpxName */
{ 266, -3 }, /* (153) tablelist ::= ids cpxName ids */
{ 266, -4 }, /* (154) tablelist ::= tablelist COMMA ids cpxName */
{ 266, -5 }, /* (155) tablelist ::= tablelist COMMA ids cpxName ids */
{ 267, -1 }, /* (156) tmvar ::= VARIABLE */
{ 254, -4 }, /* (157) interval_opt ::= INTERVAL LP tmvar RP */
{ 254, -6 }, /* (158) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
{ 254, 0 }, /* (159) interval_opt ::= */
{ 255, 0 }, /* (160) fill_opt ::= */
{ 255, -6 }, /* (161) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
{ 255, -4 }, /* (162) fill_opt ::= FILL LP ID RP */
{ 256, -4 }, /* (163) sliding_opt ::= SLIDING LP tmvar RP */
{ 256, 0 }, /* (164) sliding_opt ::= */
{ 258, 0 }, /* (165) orderby_opt ::= */
{ 258, -3 }, /* (166) orderby_opt ::= ORDER BY sortlist */
{ 268, -4 }, /* (167) sortlist ::= sortlist COMMA item sortorder */
{ 268, -2 }, /* (168) sortlist ::= item sortorder */
{ 270, -2 }, /* (169) item ::= ids cpxName */
{ 271, -1 }, /* (170) sortorder ::= ASC */
{ 271, -1 }, /* (171) sortorder ::= DESC */
{ 271, 0 }, /* (172) sortorder ::= */
{ 257, 0 }, /* (173) groupby_opt ::= */
{ 257, -3 }, /* (174) groupby_opt ::= GROUP BY grouplist */
{ 272, -3 }, /* (175) grouplist ::= grouplist COMMA item */
{ 272, -1 }, /* (176) grouplist ::= item */
{ 259, 0 }, /* (177) having_opt ::= */
{ 259, -2 }, /* (178) having_opt ::= HAVING expr */
{ 261, 0 }, /* (179) limit_opt ::= */
{ 261, -2 }, /* (180) limit_opt ::= LIMIT signed */
{ 261, -4 }, /* (181) limit_opt ::= LIMIT signed OFFSET signed */
{ 261, -4 }, /* (182) limit_opt ::= LIMIT signed COMMA signed */
{ 260, 0 }, /* (183) slimit_opt ::= */
{ 260, -2 }, /* (184) slimit_opt ::= SLIMIT signed */
{ 260, -4 }, /* (185) slimit_opt ::= SLIMIT signed SOFFSET signed */
{ 260, -4 }, /* (186) slimit_opt ::= SLIMIT signed COMMA signed */
{ 253, 0 }, /* (187) where_opt ::= */
{ 253, -2 }, /* (188) where_opt ::= WHERE expr */
{ 264, -3 }, /* (189) expr ::= LP expr RP */
{ 264, -1 }, /* (190) expr ::= ID */
{ 264, -3 }, /* (191) expr ::= ID DOT ID */
{ 264, -3 }, /* (192) expr ::= ID DOT STAR */
{ 264, -1 }, /* (193) expr ::= INTEGER */
{ 264, -2 }, /* (194) expr ::= MINUS INTEGER */
{ 264, -2 }, /* (195) expr ::= PLUS INTEGER */
{ 264, -1 }, /* (196) expr ::= FLOAT */
{ 264, -2 }, /* (197) expr ::= MINUS FLOAT */
{ 264, -2 }, /* (198) expr ::= PLUS FLOAT */
{ 264, -1 }, /* (199) expr ::= STRING */
{ 264, -1 }, /* (200) expr ::= NOW */
{ 264, -1 }, /* (201) expr ::= VARIABLE */
{ 264, -1 }, /* (202) expr ::= BOOL */
{ 264, -4 }, /* (203) expr ::= ID LP exprlist RP */
{ 264, -4 }, /* (204) expr ::= ID LP STAR RP */
{ 264, -3 }, /* (205) expr ::= expr IS NULL */
{ 264, -4 }, /* (206) expr ::= expr IS NOT NULL */
{ 264, -3 }, /* (207) expr ::= expr LT expr */
{ 264, -3 }, /* (208) expr ::= expr GT expr */
{ 264, -3 }, /* (209) expr ::= expr LE expr */
{ 264, -3 }, /* (210) expr ::= expr GE expr */
{ 264, -3 }, /* (211) expr ::= expr NE expr */
{ 264, -3 }, /* (212) expr ::= expr EQ expr */
{ 264, -3 }, /* (213) expr ::= expr AND expr */
{ 264, -3 }, /* (214) expr ::= expr OR expr */
{ 264, -3 }, /* (215) expr ::= expr PLUS expr */
{ 264, -3 }, /* (216) expr ::= expr MINUS expr */
{ 264, -3 }, /* (217) expr ::= expr STAR expr */
{ 264, -3 }, /* (218) expr ::= expr SLASH expr */
{ 264, -3 }, /* (219) expr ::= expr REM expr */
{ 264, -3 }, /* (220) expr ::= expr LIKE expr */
{ 264, -5 }, /* (221) expr ::= expr IN LP exprlist RP */
{ 273, -3 }, /* (222) exprlist ::= exprlist COMMA expritem */
{ 273, -1 }, /* (223) exprlist ::= expritem */
{ 274, -1 }, /* (224) expritem ::= expr */
{ 274, 0 }, /* (225) expritem ::= */
{ 209, -3 }, /* (226) cmd ::= RESET QUERY CACHE */
{ 209, -7 }, /* (227) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
{ 209, -7 }, /* (228) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
{ 209, -7 }, /* (229) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
{ 209, -7 }, /* (230) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
{ 209, -8 }, /* (231) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
{ 209, -9 }, /* (232) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
{ 209, -3 }, /* (233) cmd ::= KILL CONNECTION INTEGER */
{ 209, -5 }, /* (234) cmd ::= KILL STREAM INTEGER COLON INTEGER */
{ 209, -5 }, /* (235) cmd ::= KILL QUERY INTEGER COLON INTEGER */
};
static void yy_accept(yyParser*); /* Forward Declaration */
......@@ -2011,6 +2027,7 @@ static void yy_reduce(
/********** Begin reduce actions **********************************************/
YYMINORTYPE yylhsminor;
case 0: /* program ::= cmd */
case 115: /* cmd ::= CREATE TABLE create_table_args */ yytestcase(yyruleno==115);
{}
break;
case 1: /* cmd ::= SHOW DATABASES */
......@@ -2161,13 +2178,13 @@ static void yy_reduce(
{ setDCLSQLElems(pInfo, TSDB_SQL_CFG_LOCAL, 2, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); }
break;
case 40: /* cmd ::= ALTER DATABASE ids alter_db_optr */
{ SStrToken t = {0}; setCreateDBSQL(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy268, &t);}
{ SStrToken t = {0}; setCreateDBSQL(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy148, &t);}
break;
case 41: /* cmd ::= ALTER ACCOUNT ids acct_optr */
{ setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy149);}
{ setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy309);}
break;
case 42: /* cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
{ setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy149);}
{ setCreateAcctSQL(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy309);}
break;
case 43: /* ids ::= ID */
case 44: /* ids ::= STRING */ yytestcase(yyruleno==44);
......@@ -2175,23 +2192,23 @@ static void yy_reduce(
yymsp[0].minor.yy0 = yylhsminor.yy0;
break;
case 45: /* ifexists ::= IF EXISTS */
{yymsp[-1].minor.yy0.n = 1;}
{ yymsp[-1].minor.yy0.n = 1;}
break;
case 46: /* ifexists ::= */
case 48: /* ifnotexists ::= */ yytestcase(yyruleno==48);
{yymsp[1].minor.yy0.n = 0;}
{ yymsp[1].minor.yy0.n = 0;}
break;
case 47: /* ifnotexists ::= IF NOT EXISTS */
{yymsp[-2].minor.yy0.n = 1;}
{ yymsp[-2].minor.yy0.n = 1;}
break;
case 49: /* cmd ::= CREATE DNODE ids */
{ setDCLSQLElems(pInfo, TSDB_SQL_CREATE_DNODE, 1, &yymsp[0].minor.yy0);}
break;
case 50: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
{ setCreateAcctSQL(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy149);}
{ setCreateAcctSQL(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy309);}
break;
case 51: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */
{ setCreateDBSQL(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy268, &yymsp[-2].minor.yy0);}
{ setCreateDBSQL(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy148, &yymsp[-2].minor.yy0);}
break;
case 52: /* cmd ::= CREATE USER ids PASS ids */
{ setCreateUserSQL(pInfo, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);}
......@@ -2205,7 +2222,7 @@ static void yy_reduce(
case 65: /* users ::= */ yytestcase(yyruleno==65);
case 67: /* conns ::= */ yytestcase(yyruleno==67);
case 69: /* state ::= */ yytestcase(yyruleno==69);
{yymsp[1].minor.yy0.n = 0; }
{ yymsp[1].minor.yy0.n = 0; }
break;
case 54: /* pps ::= PPS INTEGER */
case 56: /* tseries ::= TSERIES INTEGER */ yytestcase(yyruleno==56);
......@@ -2216,24 +2233,24 @@ static void yy_reduce(
case 66: /* users ::= USERS INTEGER */ yytestcase(yyruleno==66);
case 68: /* conns ::= CONNS INTEGER */ yytestcase(yyruleno==68);
case 70: /* state ::= STATE ids */ yytestcase(yyruleno==70);
{yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
{ yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
break;
case 71: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */
{
yylhsminor.yy149.maxUsers = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
yylhsminor.yy149.maxDbs = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
yylhsminor.yy149.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
yylhsminor.yy149.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
yylhsminor.yy149.maxPointsPerSecond = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
yylhsminor.yy149.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
yylhsminor.yy149.maxQueryTime = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
yylhsminor.yy149.maxConnections = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
yylhsminor.yy149.stat = yymsp[0].minor.yy0;
}
yymsp[-8].minor.yy149 = yylhsminor.yy149;
yylhsminor.yy309.maxUsers = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
yylhsminor.yy309.maxDbs = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
yylhsminor.yy309.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
yylhsminor.yy309.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
yylhsminor.yy309.maxPointsPerSecond = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
yylhsminor.yy309.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
yylhsminor.yy309.maxQueryTime = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
yylhsminor.yy309.maxConnections = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
yylhsminor.yy309.stat = yymsp[0].minor.yy0;
}
yymsp[-8].minor.yy309 = yylhsminor.yy309;
break;
case 72: /* keep ::= KEEP tagitemlist */
{ yymsp[-1].minor.yy165 = yymsp[0].minor.yy165; }
{ yymsp[-1].minor.yy131 = yymsp[0].minor.yy131; }
break;
case 73: /* cache ::= CACHE INTEGER */
case 74: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==74);
......@@ -2251,547 +2268,579 @@ static void yy_reduce(
{ yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
break;
case 86: /* db_optr ::= */
{setDefaultCreateDbOption(&yymsp[1].minor.yy268);}
{setDefaultCreateDbOption(&yymsp[1].minor.yy148);}
break;
case 87: /* db_optr ::= db_optr cache */
{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy268 = yylhsminor.yy268;
{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy148 = yylhsminor.yy148;
break;
case 88: /* db_optr ::= db_optr replica */
case 102: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==102);
{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy268 = yylhsminor.yy268;
{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy148 = yylhsminor.yy148;
break;
case 89: /* db_optr ::= db_optr quorum */
case 103: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==103);
{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy268 = yylhsminor.yy268;
{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy148 = yylhsminor.yy148;
break;
case 90: /* db_optr ::= db_optr days */
{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy268 = yylhsminor.yy268;
{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy148 = yylhsminor.yy148;
break;
case 91: /* db_optr ::= db_optr minrows */
{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
yymsp[-1].minor.yy268 = yylhsminor.yy268;
{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
yymsp[-1].minor.yy148 = yylhsminor.yy148;
break;
case 92: /* db_optr ::= db_optr maxrows */
{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
yymsp[-1].minor.yy268 = yylhsminor.yy268;
{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
yymsp[-1].minor.yy148 = yylhsminor.yy148;
break;
case 93: /* db_optr ::= db_optr blocks */
case 105: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==105);
{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy268 = yylhsminor.yy268;
{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy148 = yylhsminor.yy148;
break;
case 94: /* db_optr ::= db_optr ctime */
{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy268 = yylhsminor.yy268;
{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy148 = yylhsminor.yy148;
break;
case 95: /* db_optr ::= db_optr wal */
case 107: /* alter_db_optr ::= alter_db_optr wal */ yytestcase(yyruleno==107);
{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy268 = yylhsminor.yy268;
{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy148 = yylhsminor.yy148;
break;
case 96: /* db_optr ::= db_optr fsync */
case 108: /* alter_db_optr ::= alter_db_optr fsync */ yytestcase(yyruleno==108);
{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy268 = yylhsminor.yy268;
{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy148 = yylhsminor.yy148;
break;
case 97: /* db_optr ::= db_optr comp */
case 106: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==106);
{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy268 = yylhsminor.yy268;
{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy148 = yylhsminor.yy148;
break;
case 98: /* db_optr ::= db_optr prec */
{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.precision = yymsp[0].minor.yy0; }
yymsp[-1].minor.yy268 = yylhsminor.yy268;
{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.precision = yymsp[0].minor.yy0; }
yymsp[-1].minor.yy148 = yylhsminor.yy148;
break;
case 99: /* db_optr ::= db_optr keep */
case 104: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==104);
{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.keep = yymsp[0].minor.yy165; }
yymsp[-1].minor.yy268 = yylhsminor.yy268;
{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.keep = yymsp[0].minor.yy131; }
yymsp[-1].minor.yy148 = yylhsminor.yy148;
break;
case 100: /* db_optr ::= db_optr update */
case 109: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==109);
{ yylhsminor.yy268 = yymsp[-1].minor.yy268; yylhsminor.yy268.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy268 = yylhsminor.yy268;
{ yylhsminor.yy148 = yymsp[-1].minor.yy148; yylhsminor.yy148.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy148 = yylhsminor.yy148;
break;
case 101: /* alter_db_optr ::= */
{ setDefaultCreateDbOption(&yymsp[1].minor.yy268);}
{ setDefaultCreateDbOption(&yymsp[1].minor.yy148);}
break;
case 110: /* typename ::= ids */
{
yymsp[0].minor.yy0.type = 0;
tSQLSetColumnType (&yylhsminor.yy223, &yymsp[0].minor.yy0);
tSQLSetColumnType (&yylhsminor.yy163, &yymsp[0].minor.yy0);
}
yymsp[0].minor.yy223 = yylhsminor.yy223;
yymsp[0].minor.yy163 = yylhsminor.yy163;
break;
case 111: /* typename ::= ids LP signed RP */
{
if (yymsp[-1].minor.yy207 <= 0) {
yymsp[-3].minor.yy0.type = 0;
tSQLSetColumnType(&yylhsminor.yy223, &yymsp[-3].minor.yy0);
} else {
yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy207; // negative value of name length
tSQLSetColumnType(&yylhsminor.yy223, &yymsp[-3].minor.yy0);
}
if (yymsp[-1].minor.yy459 <= 0) {
yymsp[-3].minor.yy0.type = 0;
tSQLSetColumnType(&yylhsminor.yy163, &yymsp[-3].minor.yy0);
} else {
yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy459; // negative value of name length
tSQLSetColumnType(&yylhsminor.yy163, &yymsp[-3].minor.yy0);
}
}
yymsp[-3].minor.yy223 = yylhsminor.yy223;
yymsp[-3].minor.yy163 = yylhsminor.yy163;
break;
case 112: /* signed ::= INTEGER */
{ yylhsminor.yy207 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[0].minor.yy207 = yylhsminor.yy207;
{ yylhsminor.yy459 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[0].minor.yy459 = yylhsminor.yy459;
break;
case 113: /* signed ::= PLUS INTEGER */
{ yymsp[-1].minor.yy207 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
{ yymsp[-1].minor.yy459 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
break;
case 114: /* signed ::= MINUS INTEGER */
{ yymsp[-1].minor.yy207 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
{ yymsp[-1].minor.yy459 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
break;
case 116: /* cmd ::= CREATE TABLE create_table_list */
{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy538;}
break;
case 117: /* create_table_list ::= create_from_stable */
{
SCreateTableSQL* pCreateTable = calloc(1, sizeof(SCreateTableSQL));
pCreateTable->childTableInfo = taosArrayInit(4, sizeof(SCreatedTableInfo));
taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy96);
pCreateTable->type = TSQL_CREATE_TABLE_FROM_STABLE;
yylhsminor.yy538 = pCreateTable;
}
yymsp[0].minor.yy538 = yylhsminor.yy538;
break;
case 115: /* cmd ::= CREATE TABLE ifnotexists ids cpxName create_table_args */
case 118: /* create_table_list ::= create_table_list create_from_stable */
{
yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
setCreatedTableName(pInfo, &yymsp[-2].minor.yy0, &yymsp[-3].minor.yy0);
taosArrayPush(yymsp[-1].minor.yy538->childTableInfo, &yymsp[0].minor.yy96);
yylhsminor.yy538 = yymsp[-1].minor.yy538;
}
yymsp[-1].minor.yy538 = yylhsminor.yy538;
break;
case 116: /* create_table_args ::= LP columnlist RP */
case 119: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
{
yymsp[-2].minor.yy470 = tSetCreateSQLElems(yymsp[-1].minor.yy165, NULL, NULL, NULL, NULL, TSQL_CREATE_TABLE);
setSQLInfo(pInfo, yymsp[-2].minor.yy470, NULL, TSDB_SQL_CREATE_TABLE);
yylhsminor.yy538 = tSetCreateSQLElems(yymsp[-1].minor.yy131, NULL, NULL, TSQL_CREATE_TABLE);
setSQLInfo(pInfo, yylhsminor.yy538, NULL, TSDB_SQL_CREATE_TABLE);
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
setCreatedTableName(pInfo, &yymsp[-4].minor.yy0, &yymsp[-5].minor.yy0);
}
yymsp[-5].minor.yy538 = yylhsminor.yy538;
break;
case 117: /* create_table_args ::= LP columnlist RP TAGS LP columnlist RP */
case 120: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
{
yymsp[-6].minor.yy470 = tSetCreateSQLElems(yymsp[-5].minor.yy165, yymsp[-1].minor.yy165, NULL, NULL, NULL, TSQL_CREATE_STABLE);
setSQLInfo(pInfo, yymsp[-6].minor.yy470, NULL, TSDB_SQL_CREATE_TABLE);
yylhsminor.yy538 = tSetCreateSQLElems(yymsp[-5].minor.yy131, yymsp[-1].minor.yy131, NULL, TSQL_CREATE_STABLE);
setSQLInfo(pInfo, yylhsminor.yy538, NULL, TSDB_SQL_CREATE_TABLE);
yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
setCreatedTableName(pInfo, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
}
yymsp[-9].minor.yy538 = yylhsminor.yy538;
break;
case 118: /* create_table_args ::= USING ids cpxName TAGS LP tagitemlist RP */
case 121: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
{
yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
yymsp[-6].minor.yy470 = tSetCreateSQLElems(NULL, NULL, &yymsp[-5].minor.yy0, yymsp[-1].minor.yy165, NULL, TSQL_CREATE_TABLE_FROM_STABLE);
setSQLInfo(pInfo, yymsp[-6].minor.yy470, NULL, TSDB_SQL_CREATE_TABLE);
yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
yylhsminor.yy96 = createNewChildTableInfo(&yymsp[-5].minor.yy0, yymsp[-1].minor.yy131, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
}
yymsp[-9].minor.yy96 = yylhsminor.yy96;
break;
case 119: /* create_table_args ::= AS select */
case 122: /* create_table_args ::= ifnotexists ids cpxName AS select */
{
yymsp[-1].minor.yy470 = tSetCreateSQLElems(NULL, NULL, NULL, NULL, yymsp[0].minor.yy414, TSQL_CREATE_STREAM);
setSQLInfo(pInfo, yymsp[-1].minor.yy470, NULL, TSDB_SQL_CREATE_TABLE);
yylhsminor.yy538 = tSetCreateSQLElems(NULL, NULL, yymsp[0].minor.yy84, TSQL_CREATE_STREAM);
setSQLInfo(pInfo, yylhsminor.yy538, NULL, TSDB_SQL_CREATE_TABLE);
yymsp[-4].minor.yy0.n += yymsp[-2].minor.yy0.n;
setCreatedTableName(pInfo, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0);
}
yymsp[-4].minor.yy538 = yylhsminor.yy538;
break;
case 120: /* columnlist ::= columnlist COMMA column */
{taosArrayPush(yymsp[-2].minor.yy165, &yymsp[0].minor.yy223); yylhsminor.yy165 = yymsp[-2].minor.yy165; }
yymsp[-2].minor.yy165 = yylhsminor.yy165;
case 123: /* columnlist ::= columnlist COMMA column */
{taosArrayPush(yymsp[-2].minor.yy131, &yymsp[0].minor.yy163); yylhsminor.yy131 = yymsp[-2].minor.yy131; }
yymsp[-2].minor.yy131 = yylhsminor.yy131;
break;
case 121: /* columnlist ::= column */
{yylhsminor.yy165 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy165, &yymsp[0].minor.yy223);}
yymsp[0].minor.yy165 = yylhsminor.yy165;
case 124: /* columnlist ::= column */
{yylhsminor.yy131 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy131, &yymsp[0].minor.yy163);}
yymsp[0].minor.yy131 = yylhsminor.yy131;
break;
case 122: /* column ::= ids typename */
case 125: /* column ::= ids typename */
{
tSQLSetColumnInfo(&yylhsminor.yy223, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy223);
tSQLSetColumnInfo(&yylhsminor.yy163, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy163);
}
yymsp[-1].minor.yy223 = yylhsminor.yy223;
yymsp[-1].minor.yy163 = yylhsminor.yy163;
break;
case 123: /* tagitemlist ::= tagitemlist COMMA tagitem */
{ yylhsminor.yy165 = tVariantListAppend(yymsp[-2].minor.yy165, &yymsp[0].minor.yy134, -1); }
yymsp[-2].minor.yy165 = yylhsminor.yy165;
case 126: /* tagitemlist ::= tagitemlist COMMA tagitem */
{ yylhsminor.yy131 = tVariantListAppend(yymsp[-2].minor.yy131, &yymsp[0].minor.yy516, -1); }
yymsp[-2].minor.yy131 = yylhsminor.yy131;
break;
case 124: /* tagitemlist ::= tagitem */
{ yylhsminor.yy165 = tVariantListAppend(NULL, &yymsp[0].minor.yy134, -1); }
yymsp[0].minor.yy165 = yylhsminor.yy165;
case 127: /* tagitemlist ::= tagitem */
{ yylhsminor.yy131 = tVariantListAppend(NULL, &yymsp[0].minor.yy516, -1); }
yymsp[0].minor.yy131 = yylhsminor.yy131;
break;
case 125: /* tagitem ::= INTEGER */
case 126: /* tagitem ::= FLOAT */ yytestcase(yyruleno==126);
case 127: /* tagitem ::= STRING */ yytestcase(yyruleno==127);
case 128: /* tagitem ::= BOOL */ yytestcase(yyruleno==128);
{toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy134, &yymsp[0].minor.yy0); }
yymsp[0].minor.yy134 = yylhsminor.yy134;
case 128: /* tagitem ::= INTEGER */
case 129: /* tagitem ::= FLOAT */ yytestcase(yyruleno==129);
case 130: /* tagitem ::= STRING */ yytestcase(yyruleno==130);
case 131: /* tagitem ::= BOOL */ yytestcase(yyruleno==131);
{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy516, &yymsp[0].minor.yy0); }
yymsp[0].minor.yy516 = yylhsminor.yy516;
break;
case 129: /* tagitem ::= NULL */
{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy134, &yymsp[0].minor.yy0); }
yymsp[0].minor.yy134 = yylhsminor.yy134;
case 132: /* tagitem ::= NULL */
{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy516, &yymsp[0].minor.yy0); }
yymsp[0].minor.yy516 = yylhsminor.yy516;
break;
case 130: /* tagitem ::= MINUS INTEGER */
case 131: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==131);
case 132: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==132);
case 133: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==133);
case 133: /* tagitem ::= MINUS INTEGER */
case 134: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==134);
case 135: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==135);
case 136: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==136);
{
yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
yymsp[-1].minor.yy0.type = yymsp[0].minor.yy0.type;
toTSDBType(yymsp[-1].minor.yy0.type);
tVariantCreate(&yylhsminor.yy134, &yymsp[-1].minor.yy0);
tVariantCreate(&yylhsminor.yy516, &yymsp[-1].minor.yy0);
}
yymsp[-1].minor.yy134 = yylhsminor.yy134;
yymsp[-1].minor.yy516 = yylhsminor.yy516;
break;
case 134: /* select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
case 137: /* select ::= SELECT selcollist from where_opt interval_opt fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
{
yylhsminor.yy414 = tSetQuerySQLElems(&yymsp[-11].minor.yy0, yymsp[-10].minor.yy290, yymsp[-9].minor.yy165, yymsp[-8].minor.yy64, yymsp[-4].minor.yy165, yymsp[-3].minor.yy165, &yymsp[-7].minor.yy532, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy165, &yymsp[0].minor.yy216, &yymsp[-1].minor.yy216);
yylhsminor.yy84 = tSetQuerySQLElems(&yymsp[-11].minor.yy0, yymsp[-10].minor.yy478, yymsp[-9].minor.yy131, yymsp[-8].minor.yy420, yymsp[-4].minor.yy131, yymsp[-3].minor.yy131, &yymsp[-7].minor.yy530, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy131, &yymsp[0].minor.yy284, &yymsp[-1].minor.yy284);
}
yymsp[-11].minor.yy414 = yylhsminor.yy414;
yymsp[-11].minor.yy84 = yylhsminor.yy84;
break;
case 135: /* union ::= select */
{ yylhsminor.yy231 = setSubclause(NULL, yymsp[0].minor.yy414); }
yymsp[0].minor.yy231 = yylhsminor.yy231;
case 138: /* union ::= select */
{ yylhsminor.yy513 = setSubclause(NULL, yymsp[0].minor.yy84); }
yymsp[0].minor.yy513 = yylhsminor.yy513;
break;
case 136: /* union ::= LP union RP */
{ yymsp[-2].minor.yy231 = yymsp[-1].minor.yy231; }
case 139: /* union ::= LP union RP */
{ yymsp[-2].minor.yy513 = yymsp[-1].minor.yy513; }
break;
case 137: /* union ::= union UNION ALL select */
{ yylhsminor.yy231 = appendSelectClause(yymsp[-3].minor.yy231, yymsp[0].minor.yy414); }
yymsp[-3].minor.yy231 = yylhsminor.yy231;
case 140: /* union ::= union UNION ALL select */
{ yylhsminor.yy513 = appendSelectClause(yymsp[-3].minor.yy513, yymsp[0].minor.yy84); }
yymsp[-3].minor.yy513 = yylhsminor.yy513;
break;
case 138: /* union ::= union UNION ALL LP select RP */
{ yylhsminor.yy231 = appendSelectClause(yymsp[-5].minor.yy231, yymsp[-1].minor.yy414); }
yymsp[-5].minor.yy231 = yylhsminor.yy231;
case 141: /* union ::= union UNION ALL LP select RP */
{ yylhsminor.yy513 = appendSelectClause(yymsp[-5].minor.yy513, yymsp[-1].minor.yy84); }
yymsp[-5].minor.yy513 = yylhsminor.yy513;
break;
case 139: /* cmd ::= union */
{ setSQLInfo(pInfo, yymsp[0].minor.yy231, NULL, TSDB_SQL_SELECT); }
case 142: /* cmd ::= union */
{ setSQLInfo(pInfo, yymsp[0].minor.yy513, NULL, TSDB_SQL_SELECT); }
break;
case 140: /* select ::= SELECT selcollist */
case 143: /* select ::= SELECT selcollist */
{
yylhsminor.yy414 = tSetQuerySQLElems(&yymsp[-1].minor.yy0, yymsp[0].minor.yy290, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
yylhsminor.yy84 = tSetQuerySQLElems(&yymsp[-1].minor.yy0, yymsp[0].minor.yy478, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
}
yymsp[-1].minor.yy414 = yylhsminor.yy414;
yymsp[-1].minor.yy84 = yylhsminor.yy84;
break;
case 141: /* sclp ::= selcollist COMMA */
{yylhsminor.yy290 = yymsp[-1].minor.yy290;}
yymsp[-1].minor.yy290 = yylhsminor.yy290;
case 144: /* sclp ::= selcollist COMMA */
{yylhsminor.yy478 = yymsp[-1].minor.yy478;}
yymsp[-1].minor.yy478 = yylhsminor.yy478;
break;
case 142: /* sclp ::= */
{yymsp[1].minor.yy290 = 0;}
case 145: /* sclp ::= */
{yymsp[1].minor.yy478 = 0;}
break;
case 143: /* selcollist ::= sclp expr as */
case 146: /* selcollist ::= sclp expr as */
{
yylhsminor.yy290 = tSQLExprListAppend(yymsp[-2].minor.yy290, yymsp[-1].minor.yy64, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
yylhsminor.yy478 = tSQLExprListAppend(yymsp[-2].minor.yy478, yymsp[-1].minor.yy420, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
}
yymsp[-2].minor.yy290 = yylhsminor.yy290;
yymsp[-2].minor.yy478 = yylhsminor.yy478;
break;
case 144: /* selcollist ::= sclp STAR */
case 147: /* selcollist ::= sclp STAR */
{
tSQLExpr *pNode = tSQLExprIdValueCreate(NULL, TK_ALL);
yylhsminor.yy290 = tSQLExprListAppend(yymsp[-1].minor.yy290, pNode, 0);
yylhsminor.yy478 = tSQLExprListAppend(yymsp[-1].minor.yy478, pNode, 0);
}
yymsp[-1].minor.yy290 = yylhsminor.yy290;
yymsp[-1].minor.yy478 = yylhsminor.yy478;
break;
case 145: /* as ::= AS ids */
case 148: /* as ::= AS ids */
{ yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
break;
case 146: /* as ::= ids */
case 149: /* as ::= ids */
{ yylhsminor.yy0 = yymsp[0].minor.yy0; }
yymsp[0].minor.yy0 = yylhsminor.yy0;
break;
case 147: /* as ::= */
case 150: /* as ::= */
{ yymsp[1].minor.yy0.n = 0; }
break;
case 148: /* from ::= FROM tablelist */
{yymsp[-1].minor.yy165 = yymsp[0].minor.yy165;}
case 151: /* from ::= FROM tablelist */
{yymsp[-1].minor.yy131 = yymsp[0].minor.yy131;}
break;
case 149: /* tablelist ::= ids cpxName */
case 152: /* tablelist ::= ids cpxName */
{
toTSDBType(yymsp[-1].minor.yy0.type);
yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
yylhsminor.yy165 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
yylhsminor.yy165 = tVariantListAppendToken(yylhsminor.yy165, &yymsp[-1].minor.yy0, -1); // table alias name
yylhsminor.yy131 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
yylhsminor.yy131 = tVariantListAppendToken(yylhsminor.yy131, &yymsp[-1].minor.yy0, -1); // table alias name
}
yymsp[-1].minor.yy165 = yylhsminor.yy165;
yymsp[-1].minor.yy131 = yylhsminor.yy131;
break;
case 150: /* tablelist ::= ids cpxName ids */
case 153: /* tablelist ::= ids cpxName ids */
{
toTSDBType(yymsp[-2].minor.yy0.type);
toTSDBType(yymsp[0].minor.yy0.type);
yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
yylhsminor.yy165 = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
yylhsminor.yy165 = tVariantListAppendToken(yylhsminor.yy165, &yymsp[0].minor.yy0, -1);
toTSDBType(yymsp[-2].minor.yy0.type);
toTSDBType(yymsp[0].minor.yy0.type);
yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
yylhsminor.yy131 = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
yylhsminor.yy131 = tVariantListAppendToken(yylhsminor.yy131, &yymsp[0].minor.yy0, -1);
}
yymsp[-2].minor.yy165 = yylhsminor.yy165;
yymsp[-2].minor.yy131 = yylhsminor.yy131;
break;
case 151: /* tablelist ::= tablelist COMMA ids cpxName */
case 154: /* tablelist ::= tablelist COMMA ids cpxName */
{
toTSDBType(yymsp[-1].minor.yy0.type);
yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
yylhsminor.yy165 = tVariantListAppendToken(yymsp[-3].minor.yy165, &yymsp[-1].minor.yy0, -1);
yylhsminor.yy165 = tVariantListAppendToken(yylhsminor.yy165, &yymsp[-1].minor.yy0, -1);
yylhsminor.yy131 = tVariantListAppendToken(yymsp[-3].minor.yy131, &yymsp[-1].minor.yy0, -1);
yylhsminor.yy131 = tVariantListAppendToken(yylhsminor.yy131, &yymsp[-1].minor.yy0, -1);
}
yymsp[-3].minor.yy165 = yylhsminor.yy165;
yymsp[-3].minor.yy131 = yylhsminor.yy131;
break;
case 152: /* tablelist ::= tablelist COMMA ids cpxName ids */
case 155: /* tablelist ::= tablelist COMMA ids cpxName ids */
{
toTSDBType(yymsp[-2].minor.yy0.type);
toTSDBType(yymsp[0].minor.yy0.type);
yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
yylhsminor.yy165 = tVariantListAppendToken(yymsp[-4].minor.yy165, &yymsp[-2].minor.yy0, -1);
yylhsminor.yy165 = tVariantListAppendToken(yylhsminor.yy165, &yymsp[0].minor.yy0, -1);
toTSDBType(yymsp[-2].minor.yy0.type);
toTSDBType(yymsp[0].minor.yy0.type);
yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
yylhsminor.yy131 = tVariantListAppendToken(yymsp[-4].minor.yy131, &yymsp[-2].minor.yy0, -1);
yylhsminor.yy131 = tVariantListAppendToken(yylhsminor.yy131, &yymsp[0].minor.yy0, -1);
}
yymsp[-4].minor.yy165 = yylhsminor.yy165;
yymsp[-4].minor.yy131 = yylhsminor.yy131;
break;
case 153: /* tmvar ::= VARIABLE */
case 156: /* tmvar ::= VARIABLE */
{yylhsminor.yy0 = yymsp[0].minor.yy0;}
yymsp[0].minor.yy0 = yylhsminor.yy0;
break;
case 154: /* interval_opt ::= INTERVAL LP tmvar RP */
{yymsp[-3].minor.yy532.interval = yymsp[-1].minor.yy0; yymsp[-3].minor.yy532.offset.n = 0; yymsp[-3].minor.yy532.offset.z = NULL; yymsp[-3].minor.yy532.offset.type = 0;}
case 157: /* interval_opt ::= INTERVAL LP tmvar RP */
{yymsp[-3].minor.yy530.interval = yymsp[-1].minor.yy0; yymsp[-3].minor.yy530.offset.n = 0; yymsp[-3].minor.yy530.offset.z = NULL; yymsp[-3].minor.yy530.offset.type = 0;}
break;
case 155: /* interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
{yymsp[-5].minor.yy532.interval = yymsp[-3].minor.yy0; yymsp[-5].minor.yy532.offset = yymsp[-1].minor.yy0;}
case 158: /* interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
{yymsp[-5].minor.yy530.interval = yymsp[-3].minor.yy0; yymsp[-5].minor.yy530.offset = yymsp[-1].minor.yy0;}
break;
case 156: /* interval_opt ::= */
{memset(&yymsp[1].minor.yy532, 0, sizeof(yymsp[1].minor.yy532));}
case 159: /* interval_opt ::= */
{memset(&yymsp[1].minor.yy530, 0, sizeof(yymsp[1].minor.yy530));}
break;
case 157: /* fill_opt ::= */
{yymsp[1].minor.yy165 = 0; }
case 160: /* fill_opt ::= */
{yymsp[1].minor.yy131 = 0; }
break;
case 158: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
case 161: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
{
tVariant A = {0};
toTSDBType(yymsp[-3].minor.yy0.type);
tVariantCreate(&A, &yymsp[-3].minor.yy0);
tVariantListInsert(yymsp[-1].minor.yy165, &A, -1, 0);
yymsp[-5].minor.yy165 = yymsp[-1].minor.yy165;
tVariantListInsert(yymsp[-1].minor.yy131, &A, -1, 0);
yymsp[-5].minor.yy131 = yymsp[-1].minor.yy131;
}
break;
case 159: /* fill_opt ::= FILL LP ID RP */
case 162: /* fill_opt ::= FILL LP ID RP */
{
toTSDBType(yymsp[-1].minor.yy0.type);
yymsp[-3].minor.yy165 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
yymsp[-3].minor.yy131 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
}
break;
case 160: /* sliding_opt ::= SLIDING LP tmvar RP */
case 163: /* sliding_opt ::= SLIDING LP tmvar RP */
{yymsp[-3].minor.yy0 = yymsp[-1].minor.yy0; }
break;
case 161: /* sliding_opt ::= */
case 164: /* sliding_opt ::= */
{yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0; }
break;
case 162: /* orderby_opt ::= */
case 170: /* groupby_opt ::= */ yytestcase(yyruleno==170);
{yymsp[1].minor.yy165 = 0;}
case 165: /* orderby_opt ::= */
{yymsp[1].minor.yy131 = 0;}
break;
case 163: /* orderby_opt ::= ORDER BY sortlist */
case 171: /* groupby_opt ::= GROUP BY grouplist */ yytestcase(yyruleno==171);
{yymsp[-2].minor.yy165 = yymsp[0].minor.yy165;}
case 166: /* orderby_opt ::= ORDER BY sortlist */
{yymsp[-2].minor.yy131 = yymsp[0].minor.yy131;}
break;
case 164: /* sortlist ::= sortlist COMMA item sortorder */
case 167: /* sortlist ::= sortlist COMMA item sortorder */
{
yylhsminor.yy165 = tVariantListAppend(yymsp[-3].minor.yy165, &yymsp[-1].minor.yy134, yymsp[0].minor.yy46);
yylhsminor.yy131 = tVariantListAppend(yymsp[-3].minor.yy131, &yymsp[-1].minor.yy516, yymsp[0].minor.yy42);
}
yymsp[-3].minor.yy165 = yylhsminor.yy165;
yymsp[-3].minor.yy131 = yylhsminor.yy131;
break;
case 165: /* sortlist ::= item sortorder */
case 168: /* sortlist ::= item sortorder */
{
yylhsminor.yy165 = tVariantListAppend(NULL, &yymsp[-1].minor.yy134, yymsp[0].minor.yy46);
yylhsminor.yy131 = tVariantListAppend(NULL, &yymsp[-1].minor.yy516, yymsp[0].minor.yy42);
}
yymsp[-1].minor.yy165 = yylhsminor.yy165;
yymsp[-1].minor.yy131 = yylhsminor.yy131;
break;
case 166: /* item ::= ids cpxName */
case 169: /* item ::= ids cpxName */
{
toTSDBType(yymsp[-1].minor.yy0.type);
yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
tVariantCreate(&yylhsminor.yy134, &yymsp[-1].minor.yy0);
tVariantCreate(&yylhsminor.yy516, &yymsp[-1].minor.yy0);
}
yymsp[-1].minor.yy134 = yylhsminor.yy134;
yymsp[-1].minor.yy516 = yylhsminor.yy516;
break;
case 170: /* sortorder ::= ASC */
{ yymsp[0].minor.yy42 = TSDB_ORDER_ASC; }
break;
case 171: /* sortorder ::= DESC */
{ yymsp[0].minor.yy42 = TSDB_ORDER_DESC;}
break;
case 167: /* sortorder ::= ASC */
{yymsp[0].minor.yy46 = TSDB_ORDER_ASC; }
case 172: /* sortorder ::= */
{ yymsp[1].minor.yy42 = TSDB_ORDER_ASC; }
break;
case 168: /* sortorder ::= DESC */
{yymsp[0].minor.yy46 = TSDB_ORDER_DESC;}
case 173: /* groupby_opt ::= */
{ yymsp[1].minor.yy131 = 0;}
break;
case 169: /* sortorder ::= */
{yymsp[1].minor.yy46 = TSDB_ORDER_ASC;}
case 174: /* groupby_opt ::= GROUP BY grouplist */
{ yymsp[-2].minor.yy131 = yymsp[0].minor.yy131;}
break;
case 172: /* grouplist ::= grouplist COMMA item */
case 175: /* grouplist ::= grouplist COMMA item */
{
yylhsminor.yy165 = tVariantListAppend(yymsp[-2].minor.yy165, &yymsp[0].minor.yy134, -1);
yylhsminor.yy131 = tVariantListAppend(yymsp[-2].minor.yy131, &yymsp[0].minor.yy516, -1);
}
yymsp[-2].minor.yy165 = yylhsminor.yy165;
yymsp[-2].minor.yy131 = yylhsminor.yy131;
break;
case 173: /* grouplist ::= item */
case 176: /* grouplist ::= item */
{
yylhsminor.yy165 = tVariantListAppend(NULL, &yymsp[0].minor.yy134, -1);
yylhsminor.yy131 = tVariantListAppend(NULL, &yymsp[0].minor.yy516, -1);
}
yymsp[0].minor.yy165 = yylhsminor.yy165;
yymsp[0].minor.yy131 = yylhsminor.yy131;
break;
case 174: /* having_opt ::= */
case 184: /* where_opt ::= */ yytestcase(yyruleno==184);
case 222: /* expritem ::= */ yytestcase(yyruleno==222);
{yymsp[1].minor.yy64 = 0;}
case 177: /* having_opt ::= */
case 187: /* where_opt ::= */ yytestcase(yyruleno==187);
case 225: /* expritem ::= */ yytestcase(yyruleno==225);
{yymsp[1].minor.yy420 = 0;}
break;
case 175: /* having_opt ::= HAVING expr */
case 185: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==185);
{yymsp[-1].minor.yy64 = yymsp[0].minor.yy64;}
case 178: /* having_opt ::= HAVING expr */
case 188: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==188);
{yymsp[-1].minor.yy420 = yymsp[0].minor.yy420;}
break;
case 176: /* limit_opt ::= */
case 180: /* slimit_opt ::= */ yytestcase(yyruleno==180);
{yymsp[1].minor.yy216.limit = -1; yymsp[1].minor.yy216.offset = 0;}
case 179: /* limit_opt ::= */
case 183: /* slimit_opt ::= */ yytestcase(yyruleno==183);
{yymsp[1].minor.yy284.limit = -1; yymsp[1].minor.yy284.offset = 0;}
break;
case 177: /* limit_opt ::= LIMIT signed */
case 181: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==181);
{yymsp[-1].minor.yy216.limit = yymsp[0].minor.yy207; yymsp[-1].minor.yy216.offset = 0;}
case 180: /* limit_opt ::= LIMIT signed */
case 184: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==184);
{yymsp[-1].minor.yy284.limit = yymsp[0].minor.yy459; yymsp[-1].minor.yy284.offset = 0;}
break;
case 178: /* limit_opt ::= LIMIT signed OFFSET signed */
{ yymsp[-3].minor.yy216.limit = yymsp[-2].minor.yy207; yymsp[-3].minor.yy216.offset = yymsp[0].minor.yy207;}
case 181: /* limit_opt ::= LIMIT signed OFFSET signed */
{ yymsp[-3].minor.yy284.limit = yymsp[-2].minor.yy459; yymsp[-3].minor.yy284.offset = yymsp[0].minor.yy459;}
break;
case 179: /* limit_opt ::= LIMIT signed COMMA signed */
{ yymsp[-3].minor.yy216.limit = yymsp[0].minor.yy207; yymsp[-3].minor.yy216.offset = yymsp[-2].minor.yy207;}
case 182: /* limit_opt ::= LIMIT signed COMMA signed */
{ yymsp[-3].minor.yy284.limit = yymsp[0].minor.yy459; yymsp[-3].minor.yy284.offset = yymsp[-2].minor.yy459;}
break;
case 182: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
{yymsp[-3].minor.yy216.limit = yymsp[-2].minor.yy207; yymsp[-3].minor.yy216.offset = yymsp[0].minor.yy207;}
case 185: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
{yymsp[-3].minor.yy284.limit = yymsp[-2].minor.yy459; yymsp[-3].minor.yy284.offset = yymsp[0].minor.yy459;}
break;
case 183: /* slimit_opt ::= SLIMIT signed COMMA signed */
{yymsp[-3].minor.yy216.limit = yymsp[0].minor.yy207; yymsp[-3].minor.yy216.offset = yymsp[-2].minor.yy207;}
case 186: /* slimit_opt ::= SLIMIT signed COMMA signed */
{yymsp[-3].minor.yy284.limit = yymsp[0].minor.yy459; yymsp[-3].minor.yy284.offset = yymsp[-2].minor.yy459;}
break;
case 186: /* expr ::= LP expr RP */
{yylhsminor.yy64 = yymsp[-1].minor.yy64; yylhsminor.yy64->token.z = yymsp[-2].minor.yy0.z; yylhsminor.yy64->token.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
yymsp[-2].minor.yy64 = yylhsminor.yy64;
case 189: /* expr ::= LP expr RP */
{yylhsminor.yy420 = yymsp[-1].minor.yy420; yylhsminor.yy420->token.z = yymsp[-2].minor.yy0.z; yylhsminor.yy420->token.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
yymsp[-2].minor.yy420 = yylhsminor.yy420;
break;
case 187: /* expr ::= ID */
{yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_ID);}
yymsp[0].minor.yy64 = yylhsminor.yy64;
case 190: /* expr ::= ID */
{ yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_ID);}
yymsp[0].minor.yy420 = yylhsminor.yy420;
break;
case 188: /* expr ::= ID DOT ID */
{yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ID);}
yymsp[-2].minor.yy64 = yylhsminor.yy64;
case 191: /* expr ::= ID DOT ID */
{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ID);}
yymsp[-2].minor.yy420 = yylhsminor.yy420;
break;
case 189: /* expr ::= ID DOT STAR */
{yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ALL);}
yymsp[-2].minor.yy64 = yylhsminor.yy64;
case 192: /* expr ::= ID DOT STAR */
{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[-2].minor.yy0, TK_ALL);}
yymsp[-2].minor.yy420 = yylhsminor.yy420;
break;
case 190: /* expr ::= INTEGER */
{yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_INTEGER);}
yymsp[0].minor.yy64 = yylhsminor.yy64;
case 193: /* expr ::= INTEGER */
{ yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_INTEGER);}
yymsp[0].minor.yy420 = yylhsminor.yy420;
break;
case 191: /* expr ::= MINUS INTEGER */
case 192: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==192);
{yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_INTEGER);}
yymsp[-1].minor.yy64 = yylhsminor.yy64;
case 194: /* expr ::= MINUS INTEGER */
case 195: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==195);
{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_INTEGER);}
yymsp[-1].minor.yy420 = yylhsminor.yy420;
break;
case 193: /* expr ::= FLOAT */
{yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_FLOAT);}
yymsp[0].minor.yy64 = yylhsminor.yy64;
case 196: /* expr ::= FLOAT */
{ yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_FLOAT);}
yymsp[0].minor.yy420 = yylhsminor.yy420;
break;
case 194: /* expr ::= MINUS FLOAT */
case 195: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==195);
{yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_FLOAT);}
yymsp[-1].minor.yy64 = yylhsminor.yy64;
case 197: /* expr ::= MINUS FLOAT */
case 198: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==198);
{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[-1].minor.yy0, TK_FLOAT);}
yymsp[-1].minor.yy420 = yylhsminor.yy420;
break;
case 196: /* expr ::= STRING */
{yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_STRING);}
yymsp[0].minor.yy64 = yylhsminor.yy64;
case 199: /* expr ::= STRING */
{ yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_STRING);}
yymsp[0].minor.yy420 = yylhsminor.yy420;
break;
case 197: /* expr ::= NOW */
{yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_NOW); }
yymsp[0].minor.yy64 = yylhsminor.yy64;
case 200: /* expr ::= NOW */
{ yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_NOW); }
yymsp[0].minor.yy420 = yylhsminor.yy420;
break;
case 198: /* expr ::= VARIABLE */
{yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_VARIABLE);}
yymsp[0].minor.yy64 = yylhsminor.yy64;
case 201: /* expr ::= VARIABLE */
{ yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_VARIABLE);}
yymsp[0].minor.yy420 = yylhsminor.yy420;
break;
case 199: /* expr ::= BOOL */
{yylhsminor.yy64 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_BOOL);}
yymsp[0].minor.yy64 = yylhsminor.yy64;
case 202: /* expr ::= BOOL */
{ yylhsminor.yy420 = tSQLExprIdValueCreate(&yymsp[0].minor.yy0, TK_BOOL);}
yymsp[0].minor.yy420 = yylhsminor.yy420;
break;
case 200: /* expr ::= ID LP exprlist RP */
{ yylhsminor.yy64 = tSQLExprCreateFunction(yymsp[-1].minor.yy290, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
yymsp[-3].minor.yy64 = yylhsminor.yy64;
case 203: /* expr ::= ID LP exprlist RP */
{ yylhsminor.yy420 = tSQLExprCreateFunction(yymsp[-1].minor.yy478, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
yymsp[-3].minor.yy420 = yylhsminor.yy420;
break;
case 201: /* expr ::= ID LP STAR RP */
{ yylhsminor.yy64 = tSQLExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
yymsp[-3].minor.yy64 = yylhsminor.yy64;
case 204: /* expr ::= ID LP STAR RP */
{ yylhsminor.yy420 = tSQLExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
yymsp[-3].minor.yy420 = yylhsminor.yy420;
break;
case 202: /* expr ::= expr IS NULL */
{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, NULL, TK_ISNULL);}
yymsp[-2].minor.yy64 = yylhsminor.yy64;
case 205: /* expr ::= expr IS NULL */
{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, NULL, TK_ISNULL);}
yymsp[-2].minor.yy420 = yylhsminor.yy420;
break;
case 203: /* expr ::= expr IS NOT NULL */
{yylhsminor.yy64 = tSQLExprCreate(yymsp[-3].minor.yy64, NULL, TK_NOTNULL);}
yymsp[-3].minor.yy64 = yylhsminor.yy64;
case 206: /* expr ::= expr IS NOT NULL */
{yylhsminor.yy420 = tSQLExprCreate(yymsp[-3].minor.yy420, NULL, TK_NOTNULL);}
yymsp[-3].minor.yy420 = yylhsminor.yy420;
break;
case 204: /* expr ::= expr LT expr */
{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_LT);}
yymsp[-2].minor.yy64 = yylhsminor.yy64;
case 207: /* expr ::= expr LT expr */
{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_LT);}
yymsp[-2].minor.yy420 = yylhsminor.yy420;
break;
case 205: /* expr ::= expr GT expr */
{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_GT);}
yymsp[-2].minor.yy64 = yylhsminor.yy64;
case 208: /* expr ::= expr GT expr */
{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_GT);}
yymsp[-2].minor.yy420 = yylhsminor.yy420;
break;
case 206: /* expr ::= expr LE expr */
{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_LE);}
yymsp[-2].minor.yy64 = yylhsminor.yy64;
case 209: /* expr ::= expr LE expr */
{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_LE);}
yymsp[-2].minor.yy420 = yylhsminor.yy420;
break;
case 207: /* expr ::= expr GE expr */
{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_GE);}
yymsp[-2].minor.yy64 = yylhsminor.yy64;
case 210: /* expr ::= expr GE expr */
{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_GE);}
yymsp[-2].minor.yy420 = yylhsminor.yy420;
break;
case 208: /* expr ::= expr NE expr */
{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_NE);}
yymsp[-2].minor.yy64 = yylhsminor.yy64;
case 211: /* expr ::= expr NE expr */
{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_NE);}
yymsp[-2].minor.yy420 = yylhsminor.yy420;
break;
case 209: /* expr ::= expr EQ expr */
{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_EQ);}
yymsp[-2].minor.yy64 = yylhsminor.yy64;
case 212: /* expr ::= expr EQ expr */
{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_EQ);}
yymsp[-2].minor.yy420 = yylhsminor.yy420;
break;
case 210: /* expr ::= expr AND expr */
{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_AND);}
yymsp[-2].minor.yy64 = yylhsminor.yy64;
case 213: /* expr ::= expr AND expr */
{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_AND);}
yymsp[-2].minor.yy420 = yylhsminor.yy420;
break;
case 211: /* expr ::= expr OR expr */
{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_OR); }
yymsp[-2].minor.yy64 = yylhsminor.yy64;
case 214: /* expr ::= expr OR expr */
{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_OR); }
yymsp[-2].minor.yy420 = yylhsminor.yy420;
break;
case 212: /* expr ::= expr PLUS expr */
{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_PLUS); }
yymsp[-2].minor.yy64 = yylhsminor.yy64;
case 215: /* expr ::= expr PLUS expr */
{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_PLUS); }
yymsp[-2].minor.yy420 = yylhsminor.yy420;
break;
case 213: /* expr ::= expr MINUS expr */
{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_MINUS); }
yymsp[-2].minor.yy64 = yylhsminor.yy64;
case 216: /* expr ::= expr MINUS expr */
{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_MINUS); }
yymsp[-2].minor.yy420 = yylhsminor.yy420;
break;
case 214: /* expr ::= expr STAR expr */
{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_STAR); }
yymsp[-2].minor.yy64 = yylhsminor.yy64;
case 217: /* expr ::= expr STAR expr */
{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_STAR); }
yymsp[-2].minor.yy420 = yylhsminor.yy420;
break;
case 215: /* expr ::= expr SLASH expr */
{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_DIVIDE);}
yymsp[-2].minor.yy64 = yylhsminor.yy64;
case 218: /* expr ::= expr SLASH expr */
{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_DIVIDE);}
yymsp[-2].minor.yy420 = yylhsminor.yy420;
break;
case 216: /* expr ::= expr REM expr */
{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_REM); }
yymsp[-2].minor.yy64 = yylhsminor.yy64;
case 219: /* expr ::= expr REM expr */
{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_REM); }
yymsp[-2].minor.yy420 = yylhsminor.yy420;
break;
case 217: /* expr ::= expr LIKE expr */
{yylhsminor.yy64 = tSQLExprCreate(yymsp[-2].minor.yy64, yymsp[0].minor.yy64, TK_LIKE); }
yymsp[-2].minor.yy64 = yylhsminor.yy64;
case 220: /* expr ::= expr LIKE expr */
{yylhsminor.yy420 = tSQLExprCreate(yymsp[-2].minor.yy420, yymsp[0].minor.yy420, TK_LIKE); }
yymsp[-2].minor.yy420 = yylhsminor.yy420;
break;
case 218: /* expr ::= expr IN LP exprlist RP */
{yylhsminor.yy64 = tSQLExprCreate(yymsp[-4].minor.yy64, (tSQLExpr*)yymsp[-1].minor.yy290, TK_IN); }
yymsp[-4].minor.yy64 = yylhsminor.yy64;
case 221: /* expr ::= expr IN LP exprlist RP */
{yylhsminor.yy420 = tSQLExprCreate(yymsp[-4].minor.yy420, (tSQLExpr*)yymsp[-1].minor.yy478, TK_IN); }
yymsp[-4].minor.yy420 = yylhsminor.yy420;
break;
case 219: /* exprlist ::= exprlist COMMA expritem */
{yylhsminor.yy290 = tSQLExprListAppend(yymsp[-2].minor.yy290,yymsp[0].minor.yy64,0);}
yymsp[-2].minor.yy290 = yylhsminor.yy290;
case 222: /* exprlist ::= exprlist COMMA expritem */
{yylhsminor.yy478 = tSQLExprListAppend(yymsp[-2].minor.yy478,yymsp[0].minor.yy420,0);}
yymsp[-2].minor.yy478 = yylhsminor.yy478;
break;
case 220: /* exprlist ::= expritem */
{yylhsminor.yy290 = tSQLExprListAppend(0,yymsp[0].minor.yy64,0);}
yymsp[0].minor.yy290 = yylhsminor.yy290;
case 223: /* exprlist ::= expritem */
{yylhsminor.yy478 = tSQLExprListAppend(0,yymsp[0].minor.yy420,0);}
yymsp[0].minor.yy478 = yylhsminor.yy478;
break;
case 221: /* expritem ::= expr */
{yylhsminor.yy64 = yymsp[0].minor.yy64;}
yymsp[0].minor.yy64 = yylhsminor.yy64;
case 224: /* expritem ::= expr */
{yylhsminor.yy420 = yymsp[0].minor.yy420;}
yymsp[0].minor.yy420 = yylhsminor.yy420;
break;
case 223: /* cmd ::= RESET QUERY CACHE */
case 226: /* cmd ::= RESET QUERY CACHE */
{ setDCLSQLElems(pInfo, TSDB_SQL_RESET_CACHE, 0);}
break;
case 224: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
case 227: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy165, NULL, TSDB_ALTER_TABLE_ADD_COLUMN);
SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy131, NULL, TSDB_ALTER_TABLE_ADD_COLUMN);
setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 225: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
case 228: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
......@@ -2802,14 +2851,14 @@ static void yy_reduce(
setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 226: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
case 229: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy165, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN);
SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-4].minor.yy0, yymsp[0].minor.yy131, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN);
setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 227: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
case 230: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
......@@ -2820,7 +2869,7 @@ static void yy_reduce(
setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 228: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
case 231: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
{
yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
......@@ -2834,25 +2883,25 @@ static void yy_reduce(
setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 229: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
case 232: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
{
yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n;
toTSDBType(yymsp[-2].minor.yy0.type);
SArray* A = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
A = tVariantListAppend(A, &yymsp[0].minor.yy134, -1);
A = tVariantListAppend(A, &yymsp[0].minor.yy516, -1);
SAlterTableSQL* pAlterTable = tAlterTableSQLElems(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL);
setSQLInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 230: /* cmd ::= KILL CONNECTION INTEGER */
case 233: /* cmd ::= KILL CONNECTION INTEGER */
{setKillSQL(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);}
break;
case 231: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
case 234: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
{yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSQL(pInfo, TSDB_SQL_KILL_STREAM, &yymsp[-2].minor.yy0);}
break;
case 232: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
case 235: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
{yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSQL(pInfo, TSDB_SQL_KILL_QUERY, &yymsp[-2].minor.yy0);}
break;
default:
......
src/util/inc/tstoken.h
浏览文件 @ 40b3b5a4
......@@ -31,7 +31,7 @@ extern "C" {
typedef struct SStrToken {
uint32_t n;
uint32_t type;
char * z;
char *z;
} SStrToken;
/**
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或