From a5d6851cbeeab12bda42348b58cd6370ecfc88f1 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Wed, 24 Feb 2021 13:15:23 +0800 Subject: [PATCH 01/26] implement compact interfaces --- src/inc/tsdb.h | 3 +++ src/tsdb/inc/tsdbCommitQueue.h | 4 +++- src/tsdb/inc/tsdbCompact.h | 28 ++++++++++++++++++++++++++++ src/tsdb/inc/tsdbint.h | 2 ++ src/tsdb/src/tsdbCommitQueue.c | 23 +++++++++++++++++------ src/tsdb/src/tsdbCompact.c | 6 +++++- src/tsdb/src/tsdbMemTable.c | 2 +- 7 files changed, 59 insertions(+), 9 deletions(-) create mode 100644 src/tsdb/inc/tsdbCompact.h diff --git a/src/inc/tsdb.h b/src/inc/tsdb.h index 78cd2927c7..d6c9fed971 100644 --- a/src/inc/tsdb.h +++ b/src/inc/tsdb.h @@ -355,6 +355,9 @@ void tsdbDecCommitRef(int vgId); int tsdbSyncSend(void *pRepo, SOCKET socketFd); int tsdbSyncRecv(void *pRepo, SOCKET socketFd); +// For TSDB Compact +int tsdbCompact(STsdbRepo *pRepo); + #ifdef __cplusplus } #endif diff --git a/src/tsdb/inc/tsdbCommitQueue.h b/src/tsdb/inc/tsdbCommitQueue.h index c2353391f9..6342c036b7 100644 --- a/src/tsdb/inc/tsdbCommitQueue.h +++ b/src/tsdb/inc/tsdbCommitQueue.h @@ -16,6 +16,8 @@ #ifndef _TD_TSDB_COMMIT_QUEUE_H_ #define _TD_TSDB_COMMIT_QUEUE_H_ -int tsdbScheduleCommit(STsdbRepo *pRepo); +typedef enum { COMMIT_REQ, COMPACT_REQ } TSDB_REQ_T; + +int tsdbScheduleCommit(STsdbRepo *pRepo, TSDB_REQ_T req); #endif /* _TD_TSDB_COMMIT_QUEUE_H_ */ \ No newline at end of file diff --git a/src/tsdb/inc/tsdbCompact.h b/src/tsdb/inc/tsdbCompact.h new file mode 100644 index 0000000000..5a382de5e0 --- /dev/null +++ b/src/tsdb/inc/tsdbCompact.h @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * This program is free software: you can use, redistribute, and/or modify + * it under the terms of the GNU Affero General Public License, version 3 + * or later ("AGPL"), as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ +#ifndef _TD_TSDB_COMPACT_H_ +#define _TD_TSDB_COMPACT_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +void *tsdbCompactImpl(STsdbRepo *pRepo); + +#ifdef __cplusplus +} +#endif + +#endif /* _TD_TSDB_COMPACT_H_ */ \ No newline at end of file diff --git a/src/tsdb/inc/tsdbint.h b/src/tsdb/inc/tsdbint.h index 074ff20f22..0a448d8194 100644 --- a/src/tsdb/inc/tsdbint.h +++ b/src/tsdb/inc/tsdbint.h @@ -64,6 +64,8 @@ extern "C" { #include "tsdbReadImpl.h" // Commit #include "tsdbCommit.h" +// Compact +#include "tsdbCompact.h" // Commit Queue #include "tsdbCommitQueue.h" // Main definitions diff --git a/src/tsdb/src/tsdbCommitQueue.c b/src/tsdb/src/tsdbCommitQueue.c index 9e8e4acd7e..d515faf861 100644 --- a/src/tsdb/src/tsdbCommitQueue.c +++ b/src/tsdb/src/tsdbCommitQueue.c @@ -26,8 +26,9 @@ typedef struct { } SCommitQueue; typedef struct { + TSDB_REQ_T req; STsdbRepo *pRepo; -} SCommitReq; +} SReq; static void *tsdbLoopCommit(void *arg); @@ -90,16 +91,17 @@ void tsdbDestroyCommitQueue() { pthread_mutex_destroy(&(pQueue->lock)); } -int tsdbScheduleCommit(STsdbRepo *pRepo) { +int tsdbScheduleCommit(STsdbRepo *pRepo, TSDB_REQ_T req) { SCommitQueue *pQueue = &tsCommitQueue; - SListNode *pNode = (SListNode *)calloc(1, sizeof(SListNode) + sizeof(SCommitReq)); + SListNode *pNode = (SListNode *)calloc(1, sizeof(SListNode) + sizeof(SReq)); if (pNode == NULL) { terrno = TSDB_CODE_TDB_OUT_OF_MEMORY; return -1; } - ((SCommitReq *)pNode->data)->pRepo = pRepo; + ((SReq *)pNode->data)->req = req; + ((SReq *)pNode->data)->pRepo = pRepo; pthread_mutex_lock(&(pQueue->lock)); @@ -116,6 +118,7 @@ static void *tsdbLoopCommit(void *arg) { SCommitQueue *pQueue = &tsCommitQueue; SListNode * pNode = NULL; STsdbRepo * pRepo = NULL; + TSDB_REQ_T req; while (true) { pthread_mutex_lock(&(pQueue->lock)); @@ -136,9 +139,17 @@ static void *tsdbLoopCommit(void *arg) { pthread_mutex_unlock(&(pQueue->lock)); - pRepo = ((SCommitReq *)pNode->data)->pRepo; + req = ((SReq *)pNode->data)->req; + pRepo = ((SReq *)pNode->data)->pRepo; + + if (req == COMMIT_REQ) { + tsdbCommitData(pRepo); + } else if (req == COMPACT_REQ) { + tsdbCompactImpl(pRepo); + } else { + ASSERT(0); + } - tsdbCommitData(pRepo); listNodeFree(pNode); } diff --git a/src/tsdb/src/tsdbCompact.c b/src/tsdb/src/tsdbCompact.c index 6dea4a4e57..d8cd558424 100644 --- a/src/tsdb/src/tsdbCompact.c +++ b/src/tsdb/src/tsdbCompact.c @@ -11,4 +11,8 @@ * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . - */ \ No newline at end of file + */ +#include "tsdb.h" + +int tsdbCompact(STsdbRepo *pRepo) { return 0; } +void *tsdbCompactImpl(STsdbRepo *pRepo) { return NULL; } \ No newline at end of file diff --git a/src/tsdb/src/tsdbMemTable.c b/src/tsdb/src/tsdbMemTable.c index 73a1270799..2e4a73e56b 100644 --- a/src/tsdb/src/tsdbMemTable.c +++ b/src/tsdb/src/tsdbMemTable.c @@ -232,7 +232,7 @@ int tsdbAsyncCommit(STsdbRepo *pRepo) { if (tsdbLockRepo(pRepo) < 0) return -1; pRepo->imem = pRepo->mem; pRepo->mem = NULL; - tsdbScheduleCommit(pRepo); + tsdbScheduleCommit(pRepo, COMMIT_REQ); if (tsdbUnlockRepo(pRepo) < 0) return -1; return 0; From a46e84dce78a0f22b2dfed290b0e52a5a39f4f32 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Thu, 25 Feb 2021 15:26:57 +0800 Subject: [PATCH 02/26] partial work --- src/inc/tfs.h | 2 + src/tsdb/inc/tsdbCommit.h | 7 + src/tsdb/src/tsdbCommit.c | 330 ++++++++++++++++++++------------------ 3 files changed, 182 insertions(+), 157 deletions(-) diff --git a/src/inc/tfs.h b/src/inc/tfs.h index 76e9b17a62..26ae033ac6 100644 --- a/src/inc/tfs.h +++ b/src/inc/tfs.h @@ -31,6 +31,8 @@ typedef struct { #define TFS_UNDECIDED_ID -1 #define TFS_PRIMARY_LEVEL 0 #define TFS_PRIMARY_ID 0 +#define TFS_MIN_LEVEL 0 +#define TFS_MAX_LEVEL (TSDB_MAX_TIERS - 1) // FS APIs ==================================== typedef struct { diff --git a/src/tsdb/inc/tsdbCommit.h b/src/tsdb/inc/tsdbCommit.h index 5e740081d1..9612d15018 100644 --- a/src/tsdb/inc/tsdbCommit.h +++ b/src/tsdb/inc/tsdbCommit.h @@ -29,10 +29,17 @@ typedef struct { int64_t size; } SKVRecord; +#define TSDB_DEFAULT_BLOCK_ROWS(maxRows) ((maxRows)*4 / 5) + void tsdbGetRtnSnap(STsdbRepo *pRepo, SRtn *pRtn); int tsdbEncodeKVRecord(void **buf, SKVRecord *pRecord); void *tsdbDecodeKVRecord(void *buf, SKVRecord *pRecord); void *tsdbCommitData(STsdbRepo *pRepo); +int tsdbApplyRtnOnFSet(STsdbRepo *pRepo, SDFileSet *pSet, SRtn *pRtn); +int tsdbWriteBlockInfoImpl(SDFile *pHeadf, STable *pTable, SArray *pSupA, SArray *pSubA, void **ppBuf, SBlockIdx *pIdx); +int tsdbWriteBlockIdx(SDFile *pHeadf, SArray *pIdxA, void **ppBuf); +int tsdbWriteBlockImpl(STsdbRepo *pRepo, STable *pTable, SDFile *pDFile, SDataCols *pDataCols, SBlock *pBlock, + bool isLast, bool isSuper, void **ppBuf, void **ppCBuf); static FORCE_INLINE int tsdbGetFidLevel(int fid, SRtn *pRtn) { if (fid >= pRtn->maxFid) { diff --git a/src/tsdb/src/tsdbCommit.c b/src/tsdb/src/tsdbCommit.c index a4cc316725..5656db69a4 100644 --- a/src/tsdb/src/tsdbCommit.c +++ b/src/tsdb/src/tsdbCommit.c @@ -45,7 +45,7 @@ typedef struct { #define TSDB_COMMIT_LAST_FILE(ch) TSDB_DFILE_IN_SET(TSDB_COMMIT_WRITE_FSET(ch), TSDB_FILE_LAST) #define TSDB_COMMIT_BUF(ch) TSDB_READ_BUF(&((ch)->readh)) #define TSDB_COMMIT_COMP_BUF(ch) TSDB_READ_COMP_BUF(&((ch)->readh)) -#define TSDB_COMMIT_DEFAULT_ROWS(ch) (TSDB_COMMIT_REPO(ch)->config.maxRowsPerFileBlock * 4 / 5) +#define TSDB_COMMIT_DEFAULT_ROWS(ch) TSDB_DEFAULT_BLOCK_ROWS(TSDB_COMMIT_REPO(ch)->config.maxRowsPerFileBlock) #define TSDB_COMMIT_TXN_VERSION(ch) FS_TXN_VERSION(REPO_FS(TSDB_COMMIT_REPO(ch))) static int tsdbCommitMeta(STsdbRepo *pRepo); @@ -66,7 +66,6 @@ static int tsdbCommitToTable(SCommitH *pCommith, int tid); static int tsdbSetCommitTable(SCommitH *pCommith, STable *pTable); static int tsdbComparKeyBlock(const void *arg1, const void *arg2); static int tsdbWriteBlockInfo(SCommitH *pCommih); -static int tsdbWriteBlockIdx(SCommitH *pCommih); static int tsdbCommitMemData(SCommitH *pCommith, SCommitIter *pIter, TSKEY keyLimit, bool toData); static int tsdbMergeMemData(SCommitH *pCommith, SCommitIter *pIter, int bidx); static int tsdbMoveBlock(SCommitH *pCommith, int bidx); @@ -81,7 +80,6 @@ static bool tsdbCanAddSubBlock(SCommitH *pCommith, SBlock *pBlock, SMergeInfo *p static void tsdbLoadAndMergeFromCache(SDataCols *pDataCols, int *iter, SCommitIter *pCommitIter, SDataCols *pTarget, TSKEY maxKey, int maxRows, int8_t update); static int tsdbApplyRtn(STsdbRepo *pRepo); -static int tsdbApplyRtnOnFSet(STsdbRepo *pRepo, SDFileSet *pSet, SRtn *pRtn); void *tsdbCommitData(STsdbRepo *pRepo) { tsdbStartCommit(pRepo); @@ -109,6 +107,151 @@ _err: return NULL; } +int tsdbApplyRtnOnFSet(STsdbRepo *pRepo, SDFileSet *pSet, SRtn *pRtn) { + SDiskID did; + SDFileSet nSet; + STsdbFS * pfs = REPO_FS(pRepo); + int level; + + ASSERT(pSet->fid >= pRtn->minFid); + + level = tsdbGetFidLevel(pSet->fid, pRtn); + + tfsAllocDisk(level, &(did.level), &(did.id)); + if (did.level == TFS_UNDECIDED_LEVEL) { + terrno = TSDB_CODE_TDB_NO_AVAIL_DISK; + return -1; + } + + if (did.level > TSDB_FSET_LEVEL(pSet)) { + // Need to move the FSET to higher level + tsdbInitDFileSet(&nSet, did, REPO_ID(pRepo), pSet->fid, FS_TXN_VERSION(pfs)); + + if (tsdbCopyDFileSet(pSet, &nSet) < 0) { + tsdbError("vgId:%d failed to copy FSET %d from level %d to level %d since %s", REPO_ID(pRepo), pSet->fid, + TSDB_FSET_LEVEL(pSet), did.level, tstrerror(terrno)); + return -1; + } + + if (tsdbUpdateDFileSet(pfs, &nSet) < 0) { + return -1; + } + + tsdbInfo("vgId:%d FSET %d is copied from level %d disk id %d to level %d disk id %d", REPO_ID(pRepo), pSet->fid, + TSDB_FSET_LEVEL(pSet), TSDB_FSET_ID(pSet), did.level, did.id); + } else { + // On a correct level + if (tsdbUpdateDFileSet(pfs, pSet) < 0) { + return -1; + } + } + + return 0; +} + +int tsdbWriteBlockInfoImpl(SDFile *pHeadf, STable *pTable, SArray *pSupA, SArray *pSubA, void **ppBuf, + SBlockIdx *pIdx) { + size_t nSupBlocks; + size_t nSubBlocks; + uint32_t tlen; + SBlockInfo *pBlkInfo; + int64_t offset; + SBlock * pBlock; + + memset(pIdx, 0, sizeof(*pIdx)); + + nSupBlocks = taosArrayGetSize(pSupA); + nSubBlocks = (pSubA == NULL) ? 0 : taosArrayGetSize(pSubA); + + if (nSupBlocks <= 0) { + // No data (data all deleted) + return 0; + } + + tlen = (uint32_t)(sizeof(SBlockInfo) + sizeof(SBlock) * (nSupBlocks + nSubBlocks) + sizeof(TSCKSUM)); + if (tsdbMakeRoom(ppBuf, tlen) < 0) return -1; + pBlkInfo = *ppBuf; + + pBlkInfo->delimiter = TSDB_FILE_DELIMITER; + pBlkInfo->tid = TABLE_TID(pTable); + pBlkInfo->uid = TABLE_UID(pTable); + + memcpy((void *)(pBlkInfo->blocks), taosArrayGet(pSupA, 0), nSupBlocks * sizeof(SBlock)); + if (nSubBlocks > 0) { + memcpy((void *)(pBlkInfo->blocks + nSupBlocks), taosArrayGet(pSubA, 0), nSubBlocks * sizeof(SBlock)); + + for (int i = 0; i < nSupBlocks; i++) { + pBlock = pBlkInfo->blocks + i; + + if (pBlock->numOfSubBlocks > 1) { + pBlock->offset += (sizeof(SBlockInfo) + sizeof(SBlock) * nSupBlocks); + } + } + } + + taosCalcChecksumAppend(0, (uint8_t *)pBlkInfo, tlen); + + if (tsdbAppendDFile(pHeadf, (void *)pBlkInfo, tlen, &offset) < 0) { + return -1; + } + + tsdbUpdateDFileMagic(pHeadf, POINTER_SHIFT(pBlkInfo, tlen - sizeof(TSCKSUM))); + + // Set pIdx + pBlock = taosArrayGetLast(pSupA); + + pIdx->tid = TABLE_TID(pTable); + pIdx->uid = TABLE_UID(pTable); + pIdx->hasLast = pBlock->last ? 1 : 0; + pIdx->maxKey = pBlock->keyLast; + pIdx->numOfBlocks = (uint32_t)nSupBlocks; + pIdx->len = tlen; + pIdx->offset = (uint32_t)offset; + + return 0; +} + +int tsdbWriteBlockIdx(SDFile *pHeadf, SArray *pIdxA, void **ppBuf) { + SBlockIdx *pBlkIdx; + size_t nidx = taosArrayGetSize(pIdxA); + int tlen = 0, size; + int64_t offset; + + if (nidx <= 0) { + // All data are deleted + pHeadf->info.offset = 0; + pHeadf->info.len = 0; + return 0; + } + + for (size_t i = 0; i < nidx; i++) { + pBlkIdx = (SBlockIdx *)taosArrayGet(pIdxA, i); + + size = tsdbEncodeSBlockIdx(NULL, pBlkIdx); + if (tsdbMakeRoom(ppBuf, tlen + size) < 0) return -1; + + void *ptr = POINTER_SHIFT(*ppBuf, tlen); + tsdbEncodeSBlockIdx(&ptr, pBlkIdx); + + tlen += size; + } + + tlen += sizeof(TSCKSUM); + if (tsdbMakeRoom(ppBuf, tlen) < 0) return -1; + taosCalcChecksumAppend(0, (uint8_t *)(*ppBuf), tlen); + + if (tsdbAppendDFile(pHeadf, *ppBuf, tlen, &offset) < tlen) { + return -1; + } + + tsdbUpdateDFileMagic(pHeadf, POINTER_SHIFT(*ppBuf, tlen - sizeof(TSCKSUM))); + pHeadf->info.offset = (uint32_t)offset; + pHeadf->info.len = tlen; + + return 0; +} + + // =================== Commit Meta Data static int tsdbCommitMeta(STsdbRepo *pRepo) { STsdbFS * pfs = REPO_FS(pRepo); @@ -438,7 +581,8 @@ static int tsdbCommitToFile(SCommitH *pCommith, SDFileSet *pSet, int fid) { } } - if (tsdbWriteBlockIdx(pCommith) < 0) { + if (tsdbWriteBlockIdx(TSDB_COMMIT_HEAD_FILE(pCommith), pCommith->aBlkIdx, (void **)(&(TSDB_COMMIT_BUF(pCommith)))) < + 0) { tsdbError("vgId:%d failed to write SBlockIdx part to FSET %d since %s", REPO_ID(pRepo), fid, tstrerror(terrno)); tsdbCloseCommitFile(pCommith, true); // revert the file change @@ -738,23 +882,21 @@ static int tsdbComparKeyBlock(const void *arg1, const void *arg2) { } } -static int tsdbWriteBlock(SCommitH *pCommith, SDFile *pDFile, SDataCols *pDataCols, SBlock *pBlock, bool isLast, - bool isSuper) { - STsdbRepo * pRepo = TSDB_COMMIT_REPO(pCommith); +int tsdbWriteBlockImpl(STsdbRepo *pRepo, STable *pTable, SDFile *pDFile, SDataCols *pDataCols, SBlock *pBlock, + bool isLast, bool isSuper, void **ppBuf, void **ppCBuf) { STsdbCfg * pCfg = REPO_CFG(pRepo); SBlockData *pBlockData; int64_t offset = 0; - STable * pTable = TSDB_COMMIT_TABLE(pCommith); int rowsToWrite = pDataCols->numOfRows; ASSERT(rowsToWrite > 0 && rowsToWrite <= pCfg->maxRowsPerFileBlock); ASSERT((!isLast) || rowsToWrite < pCfg->minRowsPerFileBlock); // Make buffer space - if (tsdbMakeRoom((void **)(&TSDB_COMMIT_BUF(pCommith)), TSDB_BLOCK_STATIS_SIZE(pDataCols->numOfCols)) < 0) { + if (tsdbMakeRoom(ppBuf, TSDB_BLOCK_STATIS_SIZE(pDataCols->numOfCols)) < 0) { return -1; } - pBlockData = (SBlockData *)TSDB_COMMIT_BUF(pCommith); + pBlockData = (SBlockData *)(*ppBuf); // Get # of cols not all NULL(not including key column) int nColsNotAllNull = 0; @@ -800,23 +942,23 @@ static int tsdbWriteBlock(SCommitH *pCommith, SDFile *pDFile, SDataCols *pDataCo void * tptr; // Make room - if (tsdbMakeRoom((void **)(&TSDB_COMMIT_BUF(pCommith)), lsize + tlen + COMP_OVERFLOW_BYTES + sizeof(TSCKSUM)) < 0) { + if (tsdbMakeRoom(ppBuf, lsize + tlen + COMP_OVERFLOW_BYTES + sizeof(TSCKSUM)) < 0) { return -1; } - pBlockData = (SBlockData *)TSDB_COMMIT_BUF(pCommith); + pBlockData = (SBlockData *)(*ppBuf); pBlockCol = pBlockData->cols + tcol; tptr = POINTER_SHIFT(pBlockData, lsize); if (pCfg->compression == TWO_STAGE_COMP && - tsdbMakeRoom((void **)(&TSDB_COMMIT_COMP_BUF(pCommith)), tlen + COMP_OVERFLOW_BYTES) < 0) { + tsdbMakeRoom(ppCBuf, tlen + COMP_OVERFLOW_BYTES) < 0) { return -1; } // Compress or just copy if (pCfg->compression) { flen = (*(tDataTypes[pDataCol->type].compFunc))((char *)pDataCol->pData, tlen, rowsToWrite, tptr, - tlen + COMP_OVERFLOW_BYTES, pCfg->compression, - TSDB_COMMIT_COMP_BUF(pCommith), tlen + COMP_OVERFLOW_BYTES); + tlen + COMP_OVERFLOW_BYTES, pCfg->compression, *ppCBuf, + tlen + COMP_OVERFLOW_BYTES); } else { flen = tlen; memcpy(tptr, pDataCol->pData, flen); @@ -872,68 +1014,27 @@ static int tsdbWriteBlock(SCommitH *pCommith, SDFile *pDFile, SDataCols *pDataCo return 0; } +static int tsdbWriteBlock(SCommitH *pCommith, SDFile *pDFile, SDataCols *pDataCols, SBlock *pBlock, bool isLast, + bool isSuper) { + return tsdbWriteBlockImpl(TSDB_COMMIT_REPO(pCommith), TSDB_COMMIT_TABLE(pCommith), pDFile, pDataCols, pBlock, isLast, + isSuper, (void **)(&(TSDB_COMMIT_BUF(pCommith))), + (void **)(&(TSDB_COMMIT_COMP_BUF(pCommith)))); +} + + static int tsdbWriteBlockInfo(SCommitH *pCommih) { - SDFile * pHeadf = TSDB_COMMIT_HEAD_FILE(pCommih); - SBlockIdx blkIdx; - STable * pTable = TSDB_COMMIT_TABLE(pCommih); - SBlock * pBlock; - size_t nSupBlocks; - size_t nSubBlocks; - uint32_t tlen; - SBlockInfo *pBlkInfo; - int64_t offset; + SDFile * pHeadf = TSDB_COMMIT_HEAD_FILE(pCommih); + SBlockIdx blkIdx; + STable * pTable = TSDB_COMMIT_TABLE(pCommih); - nSupBlocks = taosArrayGetSize(pCommih->aSupBlk); - nSubBlocks = taosArrayGetSize(pCommih->aSubBlk); - - if (nSupBlocks <= 0) { - // No data (data all deleted) - return 0; - } - - tlen = (uint32_t)(sizeof(SBlockInfo) + sizeof(SBlock) * (nSupBlocks + nSubBlocks) + sizeof(TSCKSUM)); - - // Write SBlockInfo part - if (tsdbMakeRoom((void **)(&(TSDB_COMMIT_BUF(pCommih))), tlen) < 0) return -1; - pBlkInfo = TSDB_COMMIT_BUF(pCommih); - - pBlkInfo->delimiter = TSDB_FILE_DELIMITER; - pBlkInfo->tid = TABLE_TID(pTable); - pBlkInfo->uid = TABLE_UID(pTable); - - memcpy((void *)(pBlkInfo->blocks), taosArrayGet(pCommih->aSupBlk, 0), nSupBlocks * sizeof(SBlock)); - if (nSubBlocks > 0) { - memcpy((void *)(pBlkInfo->blocks + nSupBlocks), taosArrayGet(pCommih->aSubBlk, 0), nSubBlocks * sizeof(SBlock)); - - for (int i = 0; i < nSupBlocks; i++) { - pBlock = pBlkInfo->blocks + i; - - if (pBlock->numOfSubBlocks > 1) { - pBlock->offset += (sizeof(SBlockInfo) + sizeof(SBlock) * nSupBlocks); - } - } - } - - taosCalcChecksumAppend(0, (uint8_t *)pBlkInfo, tlen); - - if (tsdbAppendDFile(pHeadf, TSDB_COMMIT_BUF(pCommih), tlen, &offset) < 0) { + if (tsdbWriteBlockInfoImpl(pHeadf, pTable, pCommih->aSupBlk, pCommih->aSubBlk, (void **)(&(TSDB_COMMIT_BUF(pCommih))), + &blkIdx) < 0) { return -1; } - tsdbUpdateDFileMagic(pHeadf, POINTER_SHIFT(pBlkInfo, tlen - sizeof(TSCKSUM))); - - // Set blkIdx - pBlock = taosArrayGet(pCommih->aSupBlk, nSupBlocks - 1); - - blkIdx.tid = TABLE_TID(pTable); - blkIdx.uid = TABLE_UID(pTable); - blkIdx.hasLast = pBlock->last ? 1 : 0; - blkIdx.maxKey = pBlock->keyLast; - blkIdx.numOfBlocks = (uint32_t)nSupBlocks; - blkIdx.len = tlen; - blkIdx.offset = (uint32_t)offset; - - ASSERT(blkIdx.numOfBlocks > 0); + if (blkIdx.numOfBlocks == 0) { + return 0; + } if (taosArrayPush(pCommih->aBlkIdx, (void *)(&blkIdx)) == NULL) { terrno = TSDB_CODE_TDB_OUT_OF_MEMORY; @@ -943,49 +1044,6 @@ static int tsdbWriteBlockInfo(SCommitH *pCommih) { return 0; } -static int tsdbWriteBlockIdx(SCommitH *pCommih) { - SBlockIdx *pBlkIdx; - SDFile * pHeadf = TSDB_COMMIT_HEAD_FILE(pCommih); - size_t nidx = taosArrayGetSize(pCommih->aBlkIdx); - int tlen = 0, size; - int64_t offset; - - if (nidx <= 0) { - // All data are deleted - pHeadf->info.offset = 0; - pHeadf->info.len = 0; - return 0; - } - - for (size_t i = 0; i < nidx; i++) { - pBlkIdx = (SBlockIdx *)taosArrayGet(pCommih->aBlkIdx, i); - - size = tsdbEncodeSBlockIdx(NULL, pBlkIdx); - if (tsdbMakeRoom((void **)(&TSDB_COMMIT_BUF(pCommih)), tlen + size) < 0) return -1; - - void *ptr = POINTER_SHIFT(TSDB_COMMIT_BUF(pCommih), tlen); - tsdbEncodeSBlockIdx(&ptr, pBlkIdx); - - tlen += size; - } - - tlen += sizeof(TSCKSUM); - if (tsdbMakeRoom((void **)(&TSDB_COMMIT_BUF(pCommih)), tlen) < 0) return -1; - taosCalcChecksumAppend(0, (uint8_t *)TSDB_COMMIT_BUF(pCommih), tlen); - - if (tsdbAppendDFile(pHeadf, TSDB_COMMIT_BUF(pCommih), tlen, &offset) < tlen) { - tsdbError("vgId:%d failed to write block index part to file %s since %s", TSDB_COMMIT_REPO_ID(pCommih), - TSDB_FILE_FULL_NAME(pHeadf), tstrerror(terrno)); - return -1; - } - - tsdbUpdateDFileMagic(pHeadf, POINTER_SHIFT(TSDB_COMMIT_BUF(pCommih), tlen - sizeof(TSCKSUM))); - pHeadf->info.offset = (uint32_t)offset; - pHeadf->info.len = tlen; - - return 0; -} - static int tsdbCommitMemData(SCommitH *pCommith, SCommitIter *pIter, TSKEY keyLimit, bool toData) { STsdbRepo *pRepo = TSDB_COMMIT_REPO(pCommith); STsdbCfg * pCfg = REPO_CFG(pRepo); @@ -1438,45 +1496,3 @@ static int tsdbApplyRtn(STsdbRepo *pRepo) { return 0; } - -static int tsdbApplyRtnOnFSet(STsdbRepo *pRepo, SDFileSet *pSet, SRtn *pRtn) { - SDiskID did; - SDFileSet nSet; - STsdbFS * pfs = REPO_FS(pRepo); - int level; - - ASSERT(pSet->fid >= pRtn->minFid); - - level = tsdbGetFidLevel(pSet->fid, pRtn); - - tfsAllocDisk(level, &(did.level), &(did.id)); - if (did.level == TFS_UNDECIDED_LEVEL) { - terrno = TSDB_CODE_TDB_NO_AVAIL_DISK; - return -1; - } - - if (did.level > TSDB_FSET_LEVEL(pSet)) { - // Need to move the FSET to higher level - tsdbInitDFileSet(&nSet, did, REPO_ID(pRepo), pSet->fid, FS_TXN_VERSION(pfs)); - - if (tsdbCopyDFileSet(pSet, &nSet) < 0) { - tsdbError("vgId:%d failed to copy FSET %d from level %d to level %d since %s", REPO_ID(pRepo), pSet->fid, - TSDB_FSET_LEVEL(pSet), did.level, tstrerror(terrno)); - return -1; - } - - if (tsdbUpdateDFileSet(pfs, &nSet) < 0) { - return -1; - } - - tsdbInfo("vgId:%d FSET %d is copied from level %d disk id %d to level %d disk id %d", REPO_ID(pRepo), pSet->fid, - TSDB_FSET_LEVEL(pSet), TSDB_FSET_ID(pSet), did.level, did.id); - } else { - // On a correct level - if (tsdbUpdateDFileSet(pfs, pSet) < 0) { - return -1; - } - } - - return 0; -} \ No newline at end of file From afc352547714d73172b6936f4a3a9fea77828744 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Tue, 2 Mar 2021 09:21:27 +0800 Subject: [PATCH 03/26] fix return value check problem --- src/tsdb/src/tsdbCommit.c | 4 ++-- src/tsdb/src/tsdbFS.c | 2 +- src/tsdb/src/tsdbReadImpl.c | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/tsdb/src/tsdbCommit.c b/src/tsdb/src/tsdbCommit.c index 5656db69a4..e1f3cbb5f5 100644 --- a/src/tsdb/src/tsdbCommit.c +++ b/src/tsdb/src/tsdbCommit.c @@ -1188,12 +1188,12 @@ static int tsdbMoveBlock(SCommitH *pCommith, int bidx) { } static int tsdbCommitAddBlock(SCommitH *pCommith, const SBlock *pSupBlock, const SBlock *pSubBlocks, int nSubBlocks) { - if (taosArrayPush(pCommith->aSupBlk, pSupBlock) < 0) { + if (taosArrayPush(pCommith->aSupBlk, pSupBlock) == NULL) { terrno = TSDB_CODE_TDB_OUT_OF_MEMORY; return -1; } - if (pSubBlocks && taosArrayPushBatch(pCommith->aSubBlk, pSubBlocks, nSubBlocks) < 0) { + if (pSubBlocks && taosArrayPushBatch(pCommith->aSubBlk, pSubBlocks, nSubBlocks) == NULL) { terrno = TSDB_CODE_TDB_OUT_OF_MEMORY; return -1; } diff --git a/src/tsdb/src/tsdbFS.c b/src/tsdb/src/tsdbFS.c index cbff4fbeaa..17d5f8f66f 100644 --- a/src/tsdb/src/tsdbFS.c +++ b/src/tsdb/src/tsdbFS.c @@ -1045,7 +1045,7 @@ static int tsdbRestoreDFileSet(STsdbRepo *pRepo) { int code = regexec(®ex, bname, 0, NULL, 0); if (code == 0) { - if (taosArrayPush(fArray, (void *)pf) < 0) { + if (taosArrayPush(fArray, (void *)pf) == NULL) { terrno = TSDB_CODE_TDB_OUT_OF_MEMORY; tfsClosedir(tdir); taosArrayDestroy(fArray); diff --git a/src/tsdb/src/tsdbReadImpl.c b/src/tsdb/src/tsdbReadImpl.c index 572706d45e..7212ae1636 100644 --- a/src/tsdb/src/tsdbReadImpl.c +++ b/src/tsdb/src/tsdbReadImpl.c @@ -139,7 +139,7 @@ int tsdbLoadBlockIdx(SReadH *pReadh) { ptr = tsdbDecodeSBlockIdx(ptr, &blkIdx); ASSERT(ptr != NULL); - if (taosArrayPush(pReadh->aBlkIdx, (void *)(&blkIdx)) < 0) { + if (taosArrayPush(pReadh->aBlkIdx, (void *)(&blkIdx)) == NULL) { terrno = TSDB_CODE_TDB_OUT_OF_MEMORY; return -1; } From 3449f023ac6ec84e4d65979734027636649484f0 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Tue, 2 Mar 2021 13:30:11 +0800 Subject: [PATCH 04/26] change merge datacols interface --- src/common/inc/tdataformat.h | 2 +- src/common/src/tdataformat.c | 15 ++++++++++----- src/tsdb/src/tsdbReadImpl.c | 4 ++-- 3 files changed, 13 insertions(+), 8 deletions(-) diff --git a/src/common/inc/tdataformat.h b/src/common/inc/tdataformat.h index 959654d158..308f5a1e58 100644 --- a/src/common/inc/tdataformat.h +++ b/src/common/inc/tdataformat.h @@ -296,7 +296,7 @@ int tdInitDataCols(SDataCols *pCols, STSchema *pSchema); SDataCols *tdDupDataCols(SDataCols *pCols, bool keepData); SDataCols *tdFreeDataCols(SDataCols *pCols); void tdAppendDataRowToDataCol(SDataRow row, STSchema *pSchema, SDataCols *pCols); -int tdMergeDataCols(SDataCols *target, SDataCols *src, int rowsToMerge); +int tdMergeDataCols(SDataCols *target, SDataCols *source, int rowsToMerge, int *pOffset); // ----------------- K-V data row structure /* diff --git a/src/common/src/tdataformat.c b/src/common/src/tdataformat.c index f5b84e4c9a..db73905119 100644 --- a/src/common/src/tdataformat.c +++ b/src/common/src/tdataformat.c @@ -441,30 +441,35 @@ void tdAppendDataRowToDataCol(SDataRow row, STSchema *pSchema, SDataCols *pCols) pCols->numOfRows++; } -int tdMergeDataCols(SDataCols *target, SDataCols *source, int rowsToMerge) { +int tdMergeDataCols(SDataCols *target, SDataCols *source, int rowsToMerge, int *pOffset) { ASSERT(rowsToMerge > 0 && rowsToMerge <= source->numOfRows); ASSERT(target->numOfCols == source->numOfCols); + int offset = 0; + + if (pOffset == NULL) { + pOffset = &offset; + } SDataCols *pTarget = NULL; - if (dataColsKeyLast(target) < dataColsKeyFirst(source)) { // No overlap + if ((target->numOfRows == 0) || (dataColsKeyLast(target) < dataColsKeyFirst(source))) { // No overlap ASSERT(target->numOfRows + rowsToMerge <= target->maxPoints); for (int i = 0; i < rowsToMerge; i++) { for (int j = 0; j < source->numOfCols; j++) { if (source->cols[j].len > 0) { - dataColAppendVal(target->cols + j, tdGetColDataOfRow(source->cols + j, i), target->numOfRows, + dataColAppendVal(target->cols + j, tdGetColDataOfRow(source->cols + j, i + (*pOffset)), target->numOfRows, target->maxPoints); } } target->numOfRows++; + (*pOffset)++; } } else { pTarget = tdDupDataCols(target, true); if (pTarget == NULL) goto _err; int iter1 = 0; - int iter2 = 0; - tdMergeTwoDataCols(target, pTarget, &iter1, pTarget->numOfRows, source, &iter2, source->numOfRows, + tdMergeTwoDataCols(target, pTarget, &iter1, pTarget->numOfRows, source, pOffset, source->numOfRows, pTarget->numOfRows + rowsToMerge); } diff --git a/src/tsdb/src/tsdbReadImpl.c b/src/tsdb/src/tsdbReadImpl.c index 7212ae1636..dd14dc700f 100644 --- a/src/tsdb/src/tsdbReadImpl.c +++ b/src/tsdb/src/tsdbReadImpl.c @@ -258,7 +258,7 @@ int tsdbLoadBlockData(SReadH *pReadh, SBlock *pBlock, SBlockInfo *pBlkInfo) { for (int i = 1; i < pBlock->numOfSubBlocks; i++) { iBlock++; if (tsdbLoadBlockDataImpl(pReadh, iBlock, pReadh->pDCols[1]) < 0) return -1; - if (tdMergeDataCols(pReadh->pDCols[0], pReadh->pDCols[1], pReadh->pDCols[1]->numOfRows) < 0) return -1; + if (tdMergeDataCols(pReadh->pDCols[0], pReadh->pDCols[1], pReadh->pDCols[1]->numOfRows, NULL) < 0) return -1; } ASSERT(pReadh->pDCols[0]->numOfRows == pBlock->numOfRows); @@ -284,7 +284,7 @@ int tsdbLoadBlockDataCols(SReadH *pReadh, SBlock *pBlock, SBlockInfo *pBlkInfo, for (int i = 1; i < pBlock->numOfSubBlocks; i++) { iBlock++; if (tsdbLoadBlockDataColsImpl(pReadh, iBlock, pReadh->pDCols[1], colIds, numOfColsIds) < 0) return -1; - if (tdMergeDataCols(pReadh->pDCols[0], pReadh->pDCols[1], pReadh->pDCols[1]->numOfRows) < 0) return -1; + if (tdMergeDataCols(pReadh->pDCols[0], pReadh->pDCols[1], pReadh->pDCols[1]->numOfRows, NULL) < 0) return -1; } ASSERT(pReadh->pDCols[0]->numOfRows == pBlock->numOfRows); From bd8cb525559b28582b7a890636562bc0afdbbd39 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Fri, 5 Mar 2021 13:25:56 +0800 Subject: [PATCH 05/26] make compact as a plugin interface --- src/tsdb/CMakeLists.txt | 4 ++++ src/tsdb/src/tsdbCompact.c | 6 +++++- 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/src/tsdb/CMakeLists.txt b/src/tsdb/CMakeLists.txt index 31d52aae7d..8080a61a6c 100644 --- a/src/tsdb/CMakeLists.txt +++ b/src/tsdb/CMakeLists.txt @@ -6,6 +6,10 @@ AUX_SOURCE_DIRECTORY(src SRC) ADD_LIBRARY(tsdb ${SRC}) TARGET_LINK_LIBRARIES(tsdb tfs common tutil) +IF (TD_TSDB_PLUGINS) + TARGET_LINK_LIBRARIES(tsdb tsdbPlugins) +ENDIF () + IF (TD_LINUX) # Someone has no gtest directory, so comment it # ADD_SUBDIRECTORY(tests) diff --git a/src/tsdb/src/tsdbCompact.c b/src/tsdb/src/tsdbCompact.c index d8cd558424..635bba388a 100644 --- a/src/tsdb/src/tsdbCompact.c +++ b/src/tsdb/src/tsdbCompact.c @@ -14,5 +14,9 @@ */ #include "tsdb.h" +#ifndef _TSDB_PLUGINS + int tsdbCompact(STsdbRepo *pRepo) { return 0; } -void *tsdbCompactImpl(STsdbRepo *pRepo) { return NULL; } \ No newline at end of file +void *tsdbCompactImpl(STsdbRepo *pRepo) { return NULL; } + +#endif \ No newline at end of file From 261e50e23e5bc34723032c4f96e8908d24bb69ce Mon Sep 17 00:00:00 2001 From: tickduan <417921451@qq.com> Date: Sat, 22 May 2021 15:11:45 +0800 Subject: [PATCH 06/26] cq can continue with output table last row time --- src/client/src/tscStream.c | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c index f0f87f26db..267fa0c0fe 100644 --- a/src/client/src/tscStream.c +++ b/src/client/src/tscStream.c @@ -539,6 +539,31 @@ static int64_t tscGetLaunchTimestamp(const SSqlStream *pStream) { return (pStream->precision == TSDB_TIME_PRECISION_MICRO) ? timer / 1000L : timer; } +// +// get tableName last row time, if have error return zero. +// +static int64_t tscGetStreamTableLastTime(SSqlObj* pSql, SSqlStream* pStream, const char* tableName) { + + int64_t last_time = 0; + char sql[128] = ""; + sprintf(sql, "select last_row(*) from %s;", tableName); + + // query sql + TAOS_RES* res = taos_query(pSql->pTscObj, sql); + if(res == NULL) + return 0; + + // only fetch one row + TAOS_ROW row = taos_fetch_row(res); + if( row[0] ) { + last_time = *((int64_t*)row[0]); + } + + // free and return + taos_free_result(res); + return last_time; +} + static void tscCreateStream(void *param, TAOS_RES *res, int code) { SSqlStream* pStream = (SSqlStream*)param; SSqlObj* pSql = pStream->pSql; @@ -572,6 +597,13 @@ static void tscCreateStream(void *param, TAOS_RES *res, int code) { pStream->stime = tscGetStreamStartTimestamp(pSql, pStream, pStream->stime); + // set output table last record time to stime if have, why do this, because continue with last break + int64_t last_time = tscGetStreamTableLastTime(pSql, pStream, pStream->dstTable); + if(last_time > 0 && last_time > pStream->stime) { + // can replace stime with last row time + pStream->stime = last_time; + } + int64_t starttime = tscGetLaunchTimestamp(pStream); pCmd->command = TSDB_SQL_SELECT; From 1ee65f6c86bdbfc5402fd7ee0048249e07ac9a2a Mon Sep 17 00:00:00 2001 From: tickduan <417921451@qq.com> Date: Sat, 22 May 2021 15:39:46 +0800 Subject: [PATCH 07/26] modify stream retry defalut delay from 10ms to 10*1000ms --- src/client/src/tscStream.c | 4 ++-- src/common/inc/tglobal.h | 2 +- src/common/src/tglobal.c | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c index 267fa0c0fe..0f6a403582 100644 --- a/src/client/src/tscStream.c +++ b/src/client/src/tscStream.c @@ -48,8 +48,8 @@ static bool isProjectStream(SQueryInfo* pQueryInfo) { static int64_t tscGetRetryDelayTime(SSqlStream* pStream, int64_t slidingTime, int16_t prec) { float retryRangeFactor = 0.3f; - int64_t retryDelta = (int64_t)(tsStreamCompRetryDelay * retryRangeFactor); - retryDelta = ((rand() % retryDelta) + tsStreamCompRetryDelay) * 1000L; + int64_t retryDelta = (int64_t)(tsRetryStreamCompDelay * retryRangeFactor); + retryDelta = ((rand() % retryDelta) + tsRetryStreamCompDelay) * 1000L; if (pStream->interval.intervalUnit != 'n' && pStream->interval.intervalUnit != 'y') { // change to ms diff --git a/src/common/inc/tglobal.h b/src/common/inc/tglobal.h index 26475834d5..1e66ce3f0c 100644 --- a/src/common/inc/tglobal.h +++ b/src/common/inc/tglobal.h @@ -74,7 +74,7 @@ extern int32_t tsMinSlidingTime; extern int32_t tsMinIntervalTime; extern int32_t tsMaxStreamComputDelay; extern int32_t tsStreamCompStartDelay; -extern int32_t tsStreamCompRetryDelay; +extern int32_t tsRetryStreamCompDelay; extern float tsStreamComputDelayRatio; // the delayed computing ration of the whole time window extern int32_t tsProjectExecInterval; extern int64_t tsMaxRetentWindow; diff --git a/src/common/src/tglobal.c b/src/common/src/tglobal.c index c3c159ee45..2f18c8f73a 100644 --- a/src/common/src/tglobal.c +++ b/src/common/src/tglobal.c @@ -92,7 +92,7 @@ int32_t tsMaxStreamComputDelay = 20000; int32_t tsStreamCompStartDelay = 10000; // the stream computing delay time after executing failed, change accordingly -int32_t tsStreamCompRetryDelay = 10; +int32_t tsRetryStreamCompDelay = 10*1000; // The delayed computing ration. 10% of the whole computing time window by default. float tsStreamComputDelayRatio = 0.1f; @@ -696,7 +696,7 @@ static void doInitGlobalConfig(void) { taosInitConfigOption(cfg); cfg.option = "retryStreamCompDelay"; - cfg.ptr = &tsStreamCompRetryDelay; + cfg.ptr = &tsRetryStreamCompDelay; cfg.valType = TAOS_CFG_VTYPE_INT32; cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW; cfg.minValue = 10; From 4b4199ce415076bdb4f0a7244e9aef21fb876fe5 Mon Sep 17 00:00:00 2001 From: tickduan <417921451@qq.com> Date: Wed, 26 May 2021 20:50:00 +0800 Subject: [PATCH 08/26] cq support continue query from last stop time --- src/client/inc/tsclient.h | 1 + src/client/src/tscStream.c | 41 +++++++++++++++++++++++++++++--------- 2 files changed, 33 insertions(+), 9 deletions(-) diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h index 4bfd3bc88f..0e63fa3551 100644 --- a/src/client/inc/tsclient.h +++ b/src/client/inc/tsclient.h @@ -422,6 +422,7 @@ typedef struct SSqlStream { int64_t ctime; // stream created time int64_t stime; // stream next executed time int64_t etime; // stream end query time, when time is larger then etime, the stream will be closed + int64_t ltime; // stream last row time in stream table SInterval interval; void * pTimer; diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c index 0f6a403582..9094f95dfc 100644 --- a/src/client/src/tscStream.c +++ b/src/client/src/tscStream.c @@ -538,12 +538,11 @@ static int64_t tscGetLaunchTimestamp(const SSqlStream *pStream) { return (pStream->precision == TSDB_TIME_PRECISION_MICRO) ? timer / 1000L : timer; } - +///* // // get tableName last row time, if have error return zero. // static int64_t tscGetStreamTableLastTime(SSqlObj* pSql, SSqlStream* pStream, const char* tableName) { - int64_t last_time = 0; char sql[128] = ""; sprintf(sql, "select last_row(*) from %s;", tableName); @@ -555,7 +554,7 @@ static int64_t tscGetStreamTableLastTime(SSqlObj* pSql, SSqlStream* pStream, con // only fetch one row TAOS_ROW row = taos_fetch_row(res); - if( row[0] ) { + if( row && row[0] ) { last_time = *((int64_t*)row[0]); } @@ -563,7 +562,7 @@ static int64_t tscGetStreamTableLastTime(SSqlObj* pSql, SSqlStream* pStream, con taos_free_result(res); return last_time; } - +//*/ static void tscCreateStream(void *param, TAOS_RES *res, int code) { SSqlStream* pStream = (SSqlStream*)param; SSqlObj* pSql = pStream->pSql; @@ -597,10 +596,14 @@ static void tscCreateStream(void *param, TAOS_RES *res, int code) { pStream->stime = tscGetStreamStartTimestamp(pSql, pStream, pStream->stime); - // set output table last record time to stime if have, why do this, because continue with last break - int64_t last_time = tscGetStreamTableLastTime(pSql, pStream, pStream->dstTable); + // set output table last record time to stime if have, why do this, because continue with last brea + const char* dstTable = pStream->dstTable? pStream->dstTable: ""; + int64_t last_time = tscGetStreamTableLastTime(pSql, pStream, dstTable); + pStream->ltime = last_time; + tscDebug(" CQ get table=%s lasttime=%"PRId64" end.", dstTable, last_time); if(last_time > 0 && last_time > pStream->stime) { // can replace stime with last row time + tscDebug(" CQ set table %s stime=%"PRId64" with lasttime=%"PRId64" ", dstTable, pStream->stime, last_time); pStream->stime = last_time; } @@ -619,6 +622,24 @@ void tscSetStreamDestTable(SSqlStream* pStream, const char* dstTable) { pStream->dstTable = dstTable; } +// already run on another thread +void tscCreateStreamThread(SSchedMsg* pMsg) { + tscDebug(" new thread Sched call tscCreateStream begin..."); + tscCreateStream(pMsg->ahandle, NULL, 0); + tscDebug(" new thread Sched call tscCreateStream end."); + return ; +} + +// parsesql async response return and change run thread +void tsParseSqlRet(void* param, TAOS_RES* res, int code) { + SSchedMsg schedMsg = { 0 }; + schedMsg.fp = tscCreateStreamThread; + schedMsg.ahandle = param; + schedMsg.thandle = res; + schedMsg.msg = NULL; + taosScheduleTask(tscQhandle, &schedMsg); +} + TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *param, TAOS_RES *, TAOS_ROW row), int64_t stime, void *param, void (*callback)(void *)) { STscObj *pObj = (STscObj *)taos; @@ -664,15 +685,17 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p tscDebugL("%p SQL: %s", pSql, pSql->sqlstr); tsem_init(&pSql->rspSem, 0, 0); - pSql->fp = tscCreateStream; - pSql->fetchFp = tscCreateStream; + pSql->fp = tsParseSqlRet; + pSql->fetchFp = tsParseSqlRet; registerSqlObj(pSql); int32_t code = tsParseSql(pSql, true); if (code == TSDB_CODE_SUCCESS) { tscCreateStream(pStream, pSql, code); - } else if (code != TSDB_CODE_TSC_ACTION_IN_PROGRESS) { + } else if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) { + tscDebug(" cq parseSql IN Process pass. "); + } else { tscError("0x%"PRIx64" open stream failed, sql:%s, code:%s", pSql->self, sqlstr, tstrerror(code)); taosReleaseRef(tscObjRef, pSql->self); free(pStream); From 398397bcaaa082b004b0b359fcdbfe849e57b7de Mon Sep 17 00:00:00 2001 From: tickduan <417921451@qq.com> Date: Fri, 28 May 2021 11:10:20 +0800 Subject: [PATCH 09/26] change to asynchrous call mode with support last time query --- src/client/src/tscStream.c | 127 +++++++++++++++++++++---------------- src/cq/src/cqMain.c | 7 +- 2 files changed, 79 insertions(+), 55 deletions(-) diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c index 9094f95dfc..7e6132b7c8 100644 --- a/src/client/src/tscStream.c +++ b/src/client/src/tscStream.c @@ -25,6 +25,7 @@ #include "tutil.h" #include "tscProfile.h" +#include "tscSubquery.h" static void tscProcessStreamQueryCallback(void *param, TAOS_RES *tres, int numOfRows); static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOfRows); @@ -538,31 +539,7 @@ static int64_t tscGetLaunchTimestamp(const SSqlStream *pStream) { return (pStream->precision == TSDB_TIME_PRECISION_MICRO) ? timer / 1000L : timer; } -///* -// -// get tableName last row time, if have error return zero. -// -static int64_t tscGetStreamTableLastTime(SSqlObj* pSql, SSqlStream* pStream, const char* tableName) { - int64_t last_time = 0; - char sql[128] = ""; - sprintf(sql, "select last_row(*) from %s;", tableName); - // query sql - TAOS_RES* res = taos_query(pSql->pTscObj, sql); - if(res == NULL) - return 0; - - // only fetch one row - TAOS_ROW row = taos_fetch_row(res); - if( row && row[0] ) { - last_time = *((int64_t*)row[0]); - } - - // free and return - taos_free_result(res); - return last_time; -} -//*/ static void tscCreateStream(void *param, TAOS_RES *res, int code) { SSqlStream* pStream = (SSqlStream*)param; SSqlObj* pSql = pStream->pSql; @@ -596,15 +573,12 @@ static void tscCreateStream(void *param, TAOS_RES *res, int code) { pStream->stime = tscGetStreamStartTimestamp(pSql, pStream, pStream->stime); - // set output table last record time to stime if have, why do this, because continue with last brea + // set stime with ltime if ltime > stime const char* dstTable = pStream->dstTable? pStream->dstTable: ""; - int64_t last_time = tscGetStreamTableLastTime(pSql, pStream, dstTable); - pStream->ltime = last_time; - tscDebug(" CQ get table=%s lasttime=%"PRId64" end.", dstTable, last_time); - if(last_time > 0 && last_time > pStream->stime) { - // can replace stime with last row time - tscDebug(" CQ set table %s stime=%"PRId64" with lasttime=%"PRId64" ", dstTable, pStream->stime, last_time); - pStream->stime = last_time; + tscDebug(" CQ table=%s ltime is %"PRId64, dstTable, pStream->ltime); + if(pStream->ltime > 0 && pStream->ltime > pStream->stime) { + tscWarn(" CQ set stream %s stime=%"PRId64" replace with ltime=%"PRId64" ", dstTable, pStream->stime, pStream->ltime); + pStream->stime = pStream->ltime; } int64_t starttime = tscGetLaunchTimestamp(pStream); @@ -622,25 +596,66 @@ void tscSetStreamDestTable(SSqlStream* pStream, const char* dstTable) { pStream->dstTable = dstTable; } -// already run on another thread -void tscCreateStreamThread(SSchedMsg* pMsg) { - tscDebug(" new thread Sched call tscCreateStream begin..."); - tscCreateStream(pMsg->ahandle, NULL, 0); - tscDebug(" new thread Sched call tscCreateStream end."); +// fetchFp call back +void fetchFpStreamLastRow(void* param ,TAOS_RES* res, int num) { + SSqlStream* pStream = (SSqlStream*)param; + SSqlObj* pSql = res; + + // get row data set to ltime + tscSetSqlOwner(pSql); + TAOS_ROW row = doSetResultRowData(pSql); + if( row && row[0] ) { + pStream->ltime = *((int64_t*)row[0]); + const char* dstTable = pStream->dstTable? pStream->dstTable: ""; + tscDebug(" CQ stream table=%s last row time=%"PRId64" .", dstTable, pStream->ltime); + } + tscClearSqlOwner(pSql); + + // no condition call + tscCreateStream(param, pStream->pSql, TSDB_CODE_SUCCESS); + taos_free_result(res); +} + +// fp callback +void fpStreamLastRow(void* param ,TAOS_RES* res, int code) { + // check result successful + if (code != TSDB_CODE_SUCCESS) { + tscCreateStream(param, res, TSDB_CODE_SUCCESS); + taos_free_result(res); + return ; + } + + // asynchronous fetch last row data + taos_fetch_rows_a(res, fetchFpStreamLastRow, param); +} + +void cbParseSql(void* param, TAOS_RES* res, int code) { + // check result successful + SSqlStream* pStream = (SSqlStream*)param; + SSqlObj* pSql = pStream->pSql; + SSqlCmd* pCmd = &pSql->cmd; + if (code != TSDB_CODE_SUCCESS) { + pSql->res.code = code; + tscDebug("0x%"PRIx64" open stream parse sql failed, sql:%s, reason:%s, code:%s", pSql->self, pSql->sqlstr, pCmd->payload, tstrerror(code)); + pStream->fp(pStream->param, NULL, NULL); + return; + } + + // check dstTable valid + if(pStream->dstTable == NULL || strlen(pStream->dstTable) == 0) { + tscDebug(" cbParseSql dstTable is empty."); + tscCreateStream(param, res, code); + return ; + } + + // query stream last row time async + char sql[128] = ""; + sprintf(sql, "select last_row(*) from %s;", pStream->dstTable); + taos_query_a(pSql->pTscObj, sql, fpStreamLastRow, param); return ; } -// parsesql async response return and change run thread -void tsParseSqlRet(void* param, TAOS_RES* res, int code) { - SSchedMsg schedMsg = { 0 }; - schedMsg.fp = tscCreateStreamThread; - schedMsg.ahandle = param; - schedMsg.thandle = res; - schedMsg.msg = NULL; - taosScheduleTask(tscQhandle, &schedMsg); -} - -TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *param, TAOS_RES *, TAOS_ROW row), +TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* dstTable, const char *sqlstr, void (*fp)(void *param, TAOS_RES *, TAOS_ROW row), int64_t stime, void *param, void (*callback)(void *)) { STscObj *pObj = (STscObj *)taos; if (pObj == NULL || pObj->signature != pObj) return NULL; @@ -671,6 +686,7 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p pSql->pStream = pStream; pSql->param = pStream; pSql->maxRetry = TSDB_MAX_REPLICA; + tscSetStreamDestTable(pStream, dstTable); pSql->sqlstr = calloc(1, strlen(sqlstr) + 1); if (pSql->sqlstr == NULL) { @@ -685,16 +701,16 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p tscDebugL("%p SQL: %s", pSql, pSql->sqlstr); tsem_init(&pSql->rspSem, 0, 0); - pSql->fp = tsParseSqlRet; - pSql->fetchFp = tsParseSqlRet; + pSql->fp = cbParseSql; + pSql->fetchFp = cbParseSql; registerSqlObj(pSql); - + int32_t code = tsParseSql(pSql, true); if (code == TSDB_CODE_SUCCESS) { - tscCreateStream(pStream, pSql, code); + cbParseSql(pStream, pSql, code); } else if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) { - tscDebug(" cq parseSql IN Process pass. "); + tscDebug(" CQ taso_open_stream IN Process. sql=%s", sqlstr); } else { tscError("0x%"PRIx64" open stream failed, sql:%s, code:%s", pSql->self, sqlstr, tstrerror(code)); taosReleaseRef(tscObjRef, pSql->self); @@ -705,6 +721,11 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p return pStream; } +TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *param, TAOS_RES *, TAOS_ROW row), + int64_t stime, void *param, void (*callback)(void *)) { + return taos_open_stream_withname(taos, "", sqlstr, fp, stime, param, callback); +} + void taos_close_stream(TAOS_STREAM *handle) { SSqlStream *pStream = (SSqlStream *)handle; diff --git a/src/cq/src/cqMain.c b/src/cq/src/cqMain.c index 5d5d5f339e..ee4be02b90 100644 --- a/src/cq/src/cqMain.c +++ b/src/cq/src/cqMain.c @@ -437,6 +437,10 @@ static void cqProcessCreateTimer(void *param, void *tmrId) { taosReleaseRef(cqObjRef, (int64_t)param); } +// inner implement in tscStream.c +TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* desName, const char *sqlstr, void (*fp)(void *param, TAOS_RES *, TAOS_ROW row), + int64_t stime, void *param, void (*callback)(void *)); + static void cqCreateStream(SCqContext *pContext, SCqObj *pObj) { pObj->pContext = pContext; @@ -449,11 +453,10 @@ static void cqCreateStream(SCqContext *pContext, SCqObj *pObj) { pObj->tmrId = 0; if (pObj->pStream == NULL) { - pObj->pStream = taos_open_stream(pContext->dbConn, pObj->sqlStr, cqProcessStreamRes, INT64_MIN, (void *)pObj->rid, NULL); + pObj->pStream = taos_open_stream_withname(pContext->dbConn, pObj->dstTable, pObj->sqlStr, cqProcessStreamRes, INT64_MIN, (void *)pObj->rid, NULL); // TODO the pObj->pStream may be released if error happens if (pObj->pStream) { - tscSetStreamDestTable(pObj->pStream, pObj->dstTable); pContext->num++; cDebug("vgId:%d, id:%d CQ:%s is opened", pContext->vgId, pObj->tid, pObj->sqlStr); } else { From c7764d44780c89e7b1f46c80e4e96dfeea3068f2 Mon Sep 17 00:00:00 2001 From: tickduan <417921451@qq.com> Date: Fri, 28 May 2021 13:00:12 +0800 Subject: [PATCH 10/26] ltime > stime to do replace --- src/client/src/tscStream.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c index 7e6132b7c8..2226c3d95d 100644 --- a/src/client/src/tscStream.c +++ b/src/client/src/tscStream.c @@ -576,7 +576,7 @@ static void tscCreateStream(void *param, TAOS_RES *res, int code) { // set stime with ltime if ltime > stime const char* dstTable = pStream->dstTable? pStream->dstTable: ""; tscDebug(" CQ table=%s ltime is %"PRId64, dstTable, pStream->ltime); - if(pStream->ltime > 0 && pStream->ltime > pStream->stime) { + if(pStream->ltime > pStream->stime) { tscWarn(" CQ set stream %s stime=%"PRId64" replace with ltime=%"PRId64" ", dstTable, pStream->stime, pStream->ltime); pStream->stime = pStream->ltime; } From ef58f09931fe7cffbf16894596b3e5097f7bd7c1 Mon Sep 17 00:00:00 2001 From: dapan1121 <89396746@qq.com> Date: Fri, 28 May 2021 19:09:55 +0800 Subject: [PATCH 11/26] support alter column length --- src/client/src/tscSQLParser.c | 32 +- src/inc/ttokendef.h | 100 +- src/mnode/src/mnodeTable.c | 12 +- src/query/inc/sql.y | 14 +- src/query/src/qSqlParser.c | 2 +- src/query/src/sql.c | 1664 ++++++++++++++++++++------------- src/util/src/ttokenizer.c | 3 +- 7 files changed, 1110 insertions(+), 717 deletions(-) diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c index 61b659f96c..d5141fad10 100644 --- a/src/client/src/tscSQLParser.c +++ b/src/client/src/tscSQLParser.c @@ -5074,6 +5074,8 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { const char* msg18 = "primary timestamp column cannot be dropped"; const char* msg19 = "invalid new tag name"; const char* msg20 = "table is not super table"; + const char* msg21 = "only binary/nchar column length could be altered"; + const char* msg22 = "invalid column length"; int32_t code = TSDB_CODE_SUCCESS; @@ -5110,7 +5112,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { } } else if ((pAlterSQL->type == TSDB_ALTER_TABLE_UPDATE_TAG_VAL) && (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo))) { return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4); - } else if ((pAlterSQL->type == TSDB_ALTER_TABLE_ADD_COLUMN || pAlterSQL->type == TSDB_ALTER_TABLE_DROP_COLUMN) && + } else if ((pAlterSQL->type == TSDB_ALTER_TABLE_ADD_COLUMN || pAlterSQL->type == TSDB_ALTER_TABLE_DROP_COLUMN || pAlterSQL->type == TSDB_ALTER_TABLE_CHANGE_COLUMN) && UTIL_TABLE_IS_CHILD_TABLE(pTableMetaInfo)) { return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6); } @@ -5326,6 +5328,34 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { tstrncpy(name1, pItem->pVar.pz, sizeof(name1)); TAOS_FIELD f = tscCreateField(TSDB_DATA_TYPE_INT, name1, tDataTypes[TSDB_DATA_TYPE_INT].bytes); tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f); + } else if (pAlterSQL->type == TSDB_ALTER_TABLE_CHANGE_COLUMN) { + if (taosArrayGetSize(pAlterSQL->pAddColumns) != 2) { + return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), NULL); + } + + tVariantListItem* pItem = taosArrayGet(pAlterSQL->pAddColumns, 0); + + SColumnIndex columnIndex = COLUMN_INDEX_INITIALIZER; + SStrToken name = {.type = TK_STRING, .z = pItem->pVar.pz, .n = pItem->pVar.nLen}; + if (getColumnIndexByName(pCmd, &name, pQueryInfo, &columnIndex) != TSDB_CODE_SUCCESS) { + return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg17); + } + + SSchema* pColSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, columnIndex.columnIndex); + + if (pColSchema->type != TSDB_DATA_TYPE_BINARY && pColSchema->type != TSDB_DATA_TYPE_NCHAR) { + return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg21); + } + + pItem = taosArrayGet(pAlterSQL->pAddColumns, 1); + int64_t nlen = 0; + + if (tVariantDump(&pItem->pVar, (char *)&nlen, TSDB_DATA_TYPE_BIGINT, false) < 0 || nlen <= 0) { + return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg22); + } + + TAOS_FIELD f = tscCreateField(pColSchema->type, name.z, nlen); + tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f); } return TSDB_CODE_SUCCESS; diff --git a/src/inc/ttokendef.h b/src/inc/ttokendef.h index ef3f8ed1fb..51272e15f5 100644 --- a/src/inc/ttokendef.h +++ b/src/inc/ttokendef.h @@ -155,54 +155,58 @@ #define TK_SYNCDB 136 #define TK_ADD 137 #define TK_COLUMN 138 -#define TK_TAG 139 -#define TK_CHANGE 140 -#define TK_SET 141 -#define TK_KILL 142 -#define TK_CONNECTION 143 -#define TK_STREAM 144 -#define TK_COLON 145 -#define TK_ABORT 146 -#define TK_AFTER 147 -#define TK_ATTACH 148 -#define TK_BEFORE 149 -#define TK_BEGIN 150 -#define TK_CASCADE 151 -#define TK_CLUSTER 152 -#define TK_CONFLICT 153 -#define TK_COPY 154 -#define TK_DEFERRED 155 -#define TK_DELIMITERS 156 -#define TK_DETACH 157 -#define TK_EACH 158 -#define TK_END 159 -#define TK_EXPLAIN 160 -#define TK_FAIL 161 -#define TK_FOR 162 -#define TK_IGNORE 163 -#define TK_IMMEDIATE 164 -#define TK_INITIALLY 165 -#define TK_INSTEAD 166 -#define TK_MATCH 167 -#define TK_KEY 168 -#define TK_OF 169 -#define TK_RAISE 170 -#define TK_REPLACE 171 -#define TK_RESTRICT 172 -#define TK_ROW 173 -#define TK_STATEMENT 174 -#define TK_TRIGGER 175 -#define TK_VIEW 176 -#define TK_SEMI 177 -#define TK_NONE 178 -#define TK_PREV 179 -#define TK_LINEAR 180 -#define TK_IMPORT 181 -#define TK_TBNAME 182 -#define TK_JOIN 183 -#define TK_INSERT 184 -#define TK_INTO 185 -#define TK_VALUES 186 +#define TK_LENGTH 139 +#define TK_TAG 140 +#define TK_CHANGE 141 +#define TK_SET 142 +#define TK_KILL 143 +#define TK_CONNECTION 144 +#define TK_STREAM 145 +#define TK_COLON 146 +#define TK_ABORT 147 +#define TK_AFTER 148 +#define TK_ATTACH 149 +#define TK_BEFORE 150 +#define TK_BEGIN 151 +#define TK_CASCADE 152 +#define TK_CLUSTER 153 +#define TK_CONFLICT 154 +#define TK_COPY 155 +#define TK_DEFERRED 156 +#define TK_DELIMITERS 157 +#define TK_DETACH 158 +#define TK_EACH 159 +#define TK_END 160 +#define TK_EXPLAIN 161 +#define TK_FAIL 162 +#define TK_FOR 163 +#define TK_IGNORE 164 +#define TK_IMMEDIATE 165 +#define TK_INITIALLY 166 +#define TK_INSTEAD 167 +#define TK_MATCH 168 +#define TK_KEY 169 +#define TK_OF 170 +#define TK_RAISE 171 +#define TK_REPLACE 172 +#define TK_RESTRICT 173 +#define TK_ROW 174 +#define TK_STATEMENT 175 +#define TK_TRIGGER 176 +#define TK_VIEW 177 +#define TK_SEMI 178 +#define TK_NONE 179 +#define TK_PREV 180 +#define TK_LINEAR 181 +#define TK_IMPORT 182 +#define TK_TBNAME 183 +#define TK_JOIN 184 +#define TK_INSERT 185 +#define TK_INTO 186 +#define TK_VALUES 187 + + + #define TK_SPACE 300 diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c index 4e879537e4..89d13a4c12 100644 --- a/src/mnode/src/mnodeTable.c +++ b/src/mnode/src/mnodeTable.c @@ -3100,7 +3100,10 @@ static int32_t mnodeProcessAlterTableMsg(SMnodeMsg *pMsg) { } else if (pAlter->type == TSDB_ALTER_TABLE_DROP_COLUMN) { code = mnodeDropSuperTableColumn(pMsg, pAlter->schema[0].name); } else if (pAlter->type == TSDB_ALTER_TABLE_CHANGE_COLUMN) { - code = mnodeChangeSuperTableColumn(pMsg, pAlter->schema[0].name, pAlter->schema[1].name); + //code = mnodeChangeSuperTableColumn(pMsg, pAlter->schema[0].name, pAlter->schema[1].name); + (void)mnodeChangeSuperTableColumn; + mError("change table[%s] column[%s] length to [%d] is not processed", pAlter->tableFname, pAlter->schema[0].name, pAlter->schema[0].bytes); + code = TSDB_CODE_SUCCESS; } else { } } else { @@ -3112,7 +3115,10 @@ static int32_t mnodeProcessAlterTableMsg(SMnodeMsg *pMsg) { } else if (pAlter->type == TSDB_ALTER_TABLE_DROP_COLUMN) { code = mnodeDropNormalTableColumn(pMsg, pAlter->schema[0].name); } else if (pAlter->type == TSDB_ALTER_TABLE_CHANGE_COLUMN) { - code = mnodeChangeNormalTableColumn(pMsg, pAlter->schema[0].name, pAlter->schema[1].name); + //code = mnodeChangeNormalTableColumn(pMsg, pAlter->schema[0].name, pAlter->schema[1].name); + (void)mnodeChangeNormalTableColumn; + mError("change table[%s] column[%s] length to [%d] is not processed", pAlter->tableFname, pAlter->schema[0].name, pAlter->schema[0].bytes); + code = TSDB_CODE_SUCCESS; } else { } } @@ -3303,4 +3309,4 @@ int32_t mnodeCompactTables() { mnodeCompactChildTables(); return 0; -} \ No newline at end of file +} diff --git a/src/query/inc/sql.y b/src/query/inc/sql.y index 8ef8ef0e2b..62f7da9f9c 100644 --- a/src/query/inc/sql.y +++ b/src/query/inc/sql.y @@ -28,7 +28,7 @@ #include #include "qSqlparser.h" #include "tcmdtype.h" -#include "tstoken.h" +#include "ttoken.h" #include "ttokendef.h" #include "tutil.h" #include "tvariant.h" @@ -748,6 +748,18 @@ cmd ::= ALTER TABLE ids(X) cpxName(F) DROP COLUMN ids(A). { setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } +cmd ::= ALTER TABLE ids(X) cpxName(F) ALTER COLUMN LENGTH ids(A) INTEGER(Z). { + X.n += F.n; + + toTSDBType(A.type); + SArray* K = tVariantListAppendToken(NULL, &A, -1); + toTSDBType(Z.type); + K = tVariantListAppendToken(K, &Z, -1); + + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&X, K, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1); + setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); +} + //////////////////////////////////ALTER TAGS statement///////////////////////////////////// cmd ::= ALTER TABLE ids(X) cpxName(Y) ADD TAG columnlist(A). { X.n += Y.n; diff --git a/src/query/src/qSqlParser.c b/src/query/src/qSqlParser.c index 2459439b7b..959de7530d 100644 --- a/src/query/src/qSqlParser.c +++ b/src/query/src/qSqlParser.c @@ -885,7 +885,7 @@ SAlterTableInfo *tSetAlterTableInfo(SStrToken *pTableName, SArray *pCols, SArray pAlterTable->type = type; pAlterTable->tableType = tableType; - if (type == TSDB_ALTER_TABLE_ADD_COLUMN || type == TSDB_ALTER_TABLE_ADD_TAG_COLUMN) { + if (type == TSDB_ALTER_TABLE_ADD_COLUMN || type == TSDB_ALTER_TABLE_ADD_TAG_COLUMN || type == TSDB_ALTER_TABLE_CHANGE_COLUMN) { pAlterTable->pAddColumns = pCols; assert(pVals == NULL); } else { diff --git a/src/query/src/sql.c b/src/query/src/sql.c index 5a5038be79..ca840ea4dc 100644 --- a/src/query/src/sql.c +++ b/src/query/src/sql.c @@ -23,13 +23,14 @@ ** input grammar file: */ #include +#include /************ Begin %include sections from the grammar ************************/ -#include -#include #include #include #include +#include +#include #include "qSqlparser.h" #include "tcmdtype.h" #include "ttoken.h" @@ -76,8 +77,10 @@ ** zero the stack is dynamically sized using realloc() ** ParseARG_SDECL A static variable declaration for the %extra_argument ** ParseARG_PDECL A parameter declaration for the %extra_argument +** ParseARG_PARAM Code to pass %extra_argument as a subroutine parameter ** ParseARG_STORE Code to store %extra_argument into yypParser ** ParseARG_FETCH Code to extract %extra_argument from yypParser +** ParseCTX_* As ParseARG_ except for %extra_context ** YYERRORSYMBOL is the code number of the error symbol. If not ** defined, then do no error processing. ** YYNSTATE the combined number of states. @@ -97,7 +100,7 @@ #endif /************* Begin control #defines *****************************************/ #define YYCODETYPE unsigned short int -#define YYNOCODE 264 +#define YYNOCODE 263 #define YYACTIONTYPE unsigned short int #define ParseTOKENTYPE SStrToken typedef union { @@ -124,21 +127,29 @@ typedef union { #endif #define ParseARG_SDECL SSqlInfo* pInfo; #define ParseARG_PDECL ,SSqlInfo* pInfo -#define ParseARG_FETCH SSqlInfo* pInfo = yypParser->pInfo -#define ParseARG_STORE yypParser->pInfo = pInfo +#define ParseARG_PARAM ,pInfo +#define ParseARG_FETCH SSqlInfo* pInfo=yypParser->pInfo; +#define ParseARG_STORE yypParser->pInfo=pInfo; +#define ParseCTX_SDECL +#define ParseCTX_PDECL +#define ParseCTX_PARAM +#define ParseCTX_FETCH +#define ParseCTX_STORE #define YYFALLBACK 1 -#define YYNSTATE 317 -#define YYNRULE 270 -#define YYNTOKEN 187 -#define YY_MAX_SHIFT 316 -#define YY_MIN_SHIFTREDUCE 511 -#define YY_MAX_SHIFTREDUCE 780 -#define YY_ERROR_ACTION 781 -#define YY_ACCEPT_ACTION 782 -#define YY_NO_ACTION 783 -#define YY_MIN_REDUCE 784 -#define YY_MAX_REDUCE 1053 +#define YYNSTATE 321 +#define YYNRULE 271 +#define YYNRULE_WITH_ACTION 271 +#define YYNTOKEN 188 +#define YY_MAX_SHIFT 320 +#define YY_MIN_SHIFTREDUCE 516 +#define YY_MAX_SHIFTREDUCE 786 +#define YY_ERROR_ACTION 787 +#define YY_ACCEPT_ACTION 788 +#define YY_NO_ACTION 789 +#define YY_MIN_REDUCE 790 +#define YY_MAX_REDUCE 1060 /************* End control #defines *******************************************/ +#define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) /* Define the yytestcase() macro to be a no-op if is not already defined ** otherwise. @@ -205,145 +216,145 @@ typedef union { *********** Begin parsing tables **********************************************/ #define YY_ACTTAB_COUNT (685) static const YYACTIONTYPE yy_action[] = { - /* 0 */ 925, 559, 206, 314, 211, 141, 952, 3, 168, 560, - /* 10 */ 782, 316, 134, 47, 48, 141, 51, 52, 30, 183, - /* 20 */ 217, 41, 183, 50, 264, 55, 53, 57, 54, 1034, - /* 30 */ 931, 214, 1035, 46, 45, 17, 183, 44, 43, 42, - /* 40 */ 47, 48, 223, 51, 52, 213, 1035, 217, 41, 559, - /* 50 */ 50, 264, 55, 53, 57, 54, 943, 560, 181, 208, - /* 60 */ 46, 45, 928, 222, 44, 43, 42, 48, 949, 51, - /* 70 */ 52, 244, 983, 217, 41, 249, 50, 264, 55, 53, - /* 80 */ 57, 54, 984, 638, 259, 85, 46, 45, 280, 931, - /* 90 */ 44, 43, 42, 512, 513, 514, 515, 516, 517, 518, - /* 100 */ 519, 520, 521, 522, 523, 524, 315, 943, 187, 207, - /* 110 */ 70, 290, 289, 47, 48, 30, 51, 52, 300, 919, - /* 120 */ 217, 41, 209, 50, 264, 55, 53, 57, 54, 44, - /* 130 */ 43, 42, 724, 46, 45, 674, 224, 44, 43, 42, - /* 140 */ 47, 49, 24, 51, 52, 228, 141, 217, 41, 559, - /* 150 */ 50, 264, 55, 53, 57, 54, 220, 560, 105, 928, - /* 160 */ 46, 45, 931, 300, 44, 43, 42, 23, 278, 309, - /* 170 */ 308, 277, 276, 275, 307, 274, 306, 305, 304, 273, - /* 180 */ 303, 302, 891, 30, 879, 880, 881, 882, 883, 884, - /* 190 */ 885, 886, 887, 888, 889, 890, 892, 893, 51, 52, - /* 200 */ 830, 1031, 217, 41, 167, 50, 264, 55, 53, 57, - /* 210 */ 54, 261, 18, 78, 230, 46, 45, 287, 286, 44, - /* 220 */ 43, 42, 216, 739, 221, 30, 728, 928, 731, 192, - /* 230 */ 734, 216, 739, 310, 1030, 728, 193, 731, 236, 734, - /* 240 */ 30, 118, 117, 191, 677, 559, 240, 239, 55, 53, - /* 250 */ 57, 54, 25, 560, 202, 203, 46, 45, 263, 931, - /* 260 */ 44, 43, 42, 202, 203, 74, 283, 61, 23, 928, - /* 270 */ 309, 308, 74, 36, 730, 307, 733, 306, 305, 304, - /* 280 */ 36, 303, 302, 899, 927, 662, 897, 898, 659, 62, - /* 290 */ 660, 900, 661, 902, 903, 901, 82, 904, 905, 103, - /* 300 */ 97, 108, 243, 917, 68, 30, 107, 113, 116, 106, - /* 310 */ 199, 5, 33, 157, 141, 110, 231, 232, 156, 92, - /* 320 */ 87, 91, 681, 226, 30, 56, 30, 914, 915, 29, - /* 330 */ 918, 729, 740, 732, 56, 175, 173, 171, 736, 1, - /* 340 */ 155, 740, 170, 121, 120, 119, 284, 736, 229, 928, - /* 350 */ 265, 46, 45, 69, 735, 44, 43, 42, 839, 666, - /* 360 */ 12, 667, 167, 735, 84, 288, 81, 292, 928, 215, - /* 370 */ 928, 313, 312, 126, 132, 130, 129, 80, 705, 706, - /* 380 */ 831, 79, 280, 929, 167, 916, 737, 245, 726, 684, - /* 390 */ 71, 31, 227, 994, 663, 282, 690, 247, 696, 697, - /* 400 */ 136, 760, 60, 20, 741, 19, 64, 648, 19, 241, - /* 410 */ 267, 31, 650, 6, 31, 269, 60, 1029, 649, 83, - /* 420 */ 28, 200, 60, 270, 727, 201, 65, 96, 95, 185, - /* 430 */ 14, 13, 993, 102, 101, 67, 218, 637, 16, 15, - /* 440 */ 664, 186, 665, 738, 115, 114, 743, 188, 182, 189, - /* 450 */ 190, 196, 197, 195, 180, 194, 184, 133, 1045, 990, - /* 460 */ 930, 989, 219, 291, 39, 951, 959, 944, 961, 135, - /* 470 */ 139, 976, 248, 975, 926, 131, 152, 151, 924, 153, - /* 480 */ 250, 154, 689, 210, 252, 150, 257, 145, 142, 842, - /* 490 */ 941, 143, 272, 144, 262, 37, 146, 66, 58, 178, - /* 500 */ 63, 260, 34, 258, 256, 281, 838, 147, 1050, 254, - /* 510 */ 93, 1049, 1047, 158, 285, 1044, 99, 148, 1043, 1041, - /* 520 */ 159, 860, 251, 35, 32, 38, 149, 179, 827, 109, - /* 530 */ 825, 111, 112, 823, 822, 233, 169, 820, 819, 818, - /* 540 */ 817, 816, 815, 172, 174, 40, 812, 810, 808, 806, - /* 550 */ 176, 803, 177, 301, 246, 72, 75, 104, 253, 977, - /* 560 */ 293, 294, 295, 296, 297, 204, 225, 298, 271, 299, - /* 570 */ 311, 780, 205, 198, 234, 88, 89, 235, 779, 237, - /* 580 */ 238, 778, 766, 765, 242, 247, 821, 814, 162, 266, - /* 590 */ 122, 861, 160, 165, 161, 164, 163, 166, 123, 124, - /* 600 */ 813, 805, 895, 125, 804, 2, 8, 73, 4, 669, - /* 610 */ 76, 691, 137, 212, 694, 86, 138, 77, 907, 255, - /* 620 */ 9, 698, 140, 26, 742, 7, 27, 11, 10, 21, - /* 630 */ 84, 744, 22, 268, 601, 597, 595, 594, 593, 590, - /* 640 */ 563, 279, 94, 90, 31, 59, 640, 639, 636, 585, - /* 650 */ 583, 98, 575, 581, 577, 579, 573, 571, 604, 603, - /* 660 */ 602, 600, 599, 100, 598, 596, 592, 591, 60, 561, - /* 670 */ 528, 784, 526, 783, 783, 783, 783, 783, 783, 127, - /* 680 */ 783, 783, 783, 783, 128, + /* 0 */ 135, 564, 207, 318, 212, 142, 958, 230, 142, 565, + /* 10 */ 788, 320, 17, 47, 48, 142, 51, 52, 30, 184, + /* 20 */ 218, 41, 184, 50, 265, 55, 53, 57, 54, 1040, + /* 30 */ 937, 215, 1041, 46, 45, 182, 184, 44, 43, 42, + /* 40 */ 47, 48, 935, 51, 52, 214, 1041, 218, 41, 564, + /* 50 */ 50, 265, 55, 53, 57, 54, 949, 565, 188, 209, + /* 60 */ 46, 45, 934, 250, 44, 43, 42, 48, 955, 51, + /* 70 */ 52, 245, 989, 218, 41, 79, 50, 265, 55, 53, + /* 80 */ 57, 54, 990, 106, 260, 281, 46, 45, 304, 227, + /* 90 */ 44, 43, 42, 517, 518, 519, 520, 521, 522, 523, + /* 100 */ 524, 525, 526, 527, 528, 529, 319, 643, 85, 208, + /* 110 */ 70, 564, 304, 47, 48, 30, 51, 52, 1037, 565, + /* 120 */ 218, 41, 923, 50, 265, 55, 53, 57, 54, 44, + /* 130 */ 43, 42, 729, 46, 45, 294, 293, 44, 43, 42, + /* 140 */ 47, 49, 925, 51, 52, 1036, 142, 218, 41, 564, + /* 150 */ 50, 265, 55, 53, 57, 54, 221, 565, 228, 934, + /* 160 */ 46, 45, 283, 1052, 44, 43, 42, 23, 279, 313, + /* 170 */ 312, 278, 277, 276, 311, 275, 310, 309, 308, 274, + /* 180 */ 307, 306, 897, 30, 885, 886, 887, 888, 889, 890, + /* 190 */ 891, 892, 893, 894, 895, 896, 898, 899, 51, 52, + /* 200 */ 836, 281, 218, 41, 168, 50, 265, 55, 53, 57, + /* 210 */ 54, 262, 18, 78, 25, 46, 45, 1, 156, 44, + /* 220 */ 43, 42, 217, 744, 222, 30, 733, 934, 736, 193, + /* 230 */ 739, 217, 744, 223, 12, 733, 194, 736, 84, 739, + /* 240 */ 81, 119, 118, 192, 317, 316, 127, 225, 55, 53, + /* 250 */ 57, 54, 949, 731, 203, 204, 46, 45, 264, 937, + /* 260 */ 44, 43, 42, 203, 204, 1035, 284, 210, 23, 934, + /* 270 */ 313, 312, 74, 937, 735, 311, 738, 310, 309, 308, + /* 280 */ 36, 307, 306, 905, 201, 667, 903, 904, 664, 732, + /* 290 */ 665, 906, 666, 908, 909, 907, 82, 910, 911, 104, + /* 300 */ 97, 109, 244, 202, 68, 30, 108, 114, 117, 107, + /* 310 */ 74, 200, 5, 33, 158, 111, 232, 233, 36, 157, + /* 320 */ 92, 87, 91, 682, 229, 56, 30, 920, 921, 29, + /* 330 */ 924, 291, 745, 30, 56, 176, 174, 172, 741, 314, + /* 340 */ 931, 745, 171, 122, 121, 120, 285, 741, 30, 934, + /* 350 */ 237, 46, 45, 69, 740, 44, 43, 42, 689, 241, + /* 360 */ 240, 266, 734, 740, 737, 937, 248, 292, 80, 61, + /* 370 */ 934, 133, 131, 130, 296, 3, 169, 934, 186, 845, + /* 380 */ 837, 71, 224, 168, 168, 922, 742, 710, 711, 679, + /* 390 */ 216, 62, 933, 231, 668, 187, 24, 288, 287, 246, + /* 400 */ 695, 686, 701, 31, 137, 702, 60, 765, 746, 20, + /* 410 */ 64, 19, 19, 653, 189, 268, 655, 31, 270, 31, + /* 420 */ 60, 654, 83, 28, 183, 60, 271, 96, 190, 95, + /* 430 */ 65, 14, 1000, 13, 6, 67, 103, 642, 102, 671, + /* 440 */ 669, 672, 670, 16, 191, 15, 116, 115, 197, 198, + /* 450 */ 196, 181, 195, 185, 936, 999, 219, 748, 996, 995, + /* 460 */ 220, 295, 242, 134, 39, 957, 965, 967, 136, 950, + /* 470 */ 249, 982, 140, 981, 743, 932, 152, 132, 153, 930, + /* 480 */ 251, 154, 155, 848, 694, 305, 147, 273, 947, 143, + /* 490 */ 37, 263, 144, 145, 211, 179, 66, 34, 282, 253, + /* 500 */ 258, 63, 58, 844, 261, 1057, 93, 259, 1056, 146, + /* 510 */ 257, 1054, 159, 286, 1051, 99, 289, 1050, 1047, 160, + /* 520 */ 866, 148, 255, 35, 32, 38, 180, 833, 110, 831, + /* 530 */ 112, 113, 829, 828, 234, 170, 826, 252, 825, 824, + /* 540 */ 823, 822, 821, 173, 175, 818, 816, 814, 40, 812, + /* 550 */ 177, 809, 178, 105, 247, 72, 75, 254, 983, 297, + /* 560 */ 298, 299, 300, 301, 302, 303, 315, 786, 205, 226, + /* 570 */ 235, 272, 236, 785, 238, 239, 206, 199, 88, 784, + /* 580 */ 89, 771, 770, 243, 248, 76, 827, 674, 267, 8, + /* 590 */ 123, 696, 124, 163, 162, 867, 161, 164, 165, 167, + /* 600 */ 166, 820, 2, 125, 819, 901, 126, 811, 4, 73, + /* 610 */ 810, 138, 151, 149, 150, 139, 699, 77, 913, 213, + /* 620 */ 256, 26, 703, 141, 9, 10, 747, 27, 7, 11, + /* 630 */ 21, 749, 22, 86, 269, 606, 602, 84, 600, 599, + /* 640 */ 598, 595, 280, 568, 94, 90, 31, 774, 59, 645, + /* 650 */ 644, 641, 590, 588, 98, 100, 580, 586, 582, 584, + /* 660 */ 578, 101, 576, 609, 608, 607, 605, 604, 290, 603, + /* 670 */ 601, 597, 596, 60, 566, 533, 531, 128, 790, 789, + /* 680 */ 789, 789, 789, 789, 129, }; static const YYCODETYPE yy_lookahead[] = { - /* 0 */ 191, 1, 190, 191, 210, 191, 191, 194, 195, 9, - /* 10 */ 188, 189, 191, 13, 14, 191, 16, 17, 191, 252, + /* 0 */ 191, 1, 190, 191, 210, 191, 191, 191, 191, 9, + /* 10 */ 188, 189, 252, 13, 14, 191, 16, 17, 191, 252, /* 20 */ 20, 21, 252, 23, 24, 25, 26, 27, 28, 262, /* 30 */ 236, 261, 262, 33, 34, 252, 252, 37, 38, 39, - /* 40 */ 13, 14, 233, 16, 17, 261, 262, 20, 21, 1, + /* 40 */ 13, 14, 226, 16, 17, 261, 262, 20, 21, 1, /* 50 */ 23, 24, 25, 26, 27, 28, 234, 9, 252, 232, - /* 60 */ 33, 34, 235, 210, 37, 38, 39, 14, 253, 16, - /* 70 */ 17, 249, 258, 20, 21, 254, 23, 24, 25, 26, - /* 80 */ 27, 28, 258, 5, 260, 197, 33, 34, 79, 236, + /* 60 */ 33, 34, 235, 254, 37, 38, 39, 14, 253, 16, + /* 70 */ 17, 249, 258, 20, 21, 258, 23, 24, 25, 26, + /* 80 */ 27, 28, 258, 76, 260, 79, 33, 34, 81, 68, /* 90 */ 37, 38, 39, 45, 46, 47, 48, 49, 50, 51, - /* 100 */ 52, 53, 54, 55, 56, 57, 58, 234, 252, 61, - /* 110 */ 110, 33, 34, 13, 14, 191, 16, 17, 81, 231, - /* 120 */ 20, 21, 249, 23, 24, 25, 26, 27, 28, 37, - /* 130 */ 38, 39, 105, 33, 34, 109, 210, 37, 38, 39, - /* 140 */ 13, 14, 116, 16, 17, 68, 191, 20, 21, 1, - /* 150 */ 23, 24, 25, 26, 27, 28, 232, 9, 76, 235, - /* 160 */ 33, 34, 236, 81, 37, 38, 39, 88, 89, 90, + /* 100 */ 52, 53, 54, 55, 56, 57, 58, 5, 197, 61, + /* 110 */ 110, 1, 81, 13, 14, 191, 16, 17, 252, 9, + /* 120 */ 20, 21, 0, 23, 24, 25, 26, 27, 28, 37, + /* 130 */ 38, 39, 105, 33, 34, 33, 34, 37, 38, 39, + /* 140 */ 13, 14, 231, 16, 17, 252, 191, 20, 21, 1, + /* 150 */ 23, 24, 25, 26, 27, 28, 232, 9, 137, 235, + /* 160 */ 33, 34, 141, 236, 37, 38, 39, 88, 89, 90, /* 170 */ 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, /* 180 */ 101, 102, 209, 191, 211, 212, 213, 214, 215, 216, /* 190 */ 217, 218, 219, 220, 221, 222, 223, 224, 16, 17, - /* 200 */ 196, 252, 20, 21, 200, 23, 24, 25, 26, 27, - /* 210 */ 28, 256, 44, 258, 137, 33, 34, 140, 141, 37, + /* 200 */ 196, 79, 20, 21, 200, 23, 24, 25, 26, 27, + /* 210 */ 28, 256, 44, 258, 104, 33, 34, 198, 199, 37, /* 220 */ 38, 39, 1, 2, 232, 191, 5, 235, 7, 61, - /* 230 */ 9, 1, 2, 210, 252, 5, 68, 7, 135, 9, - /* 240 */ 191, 73, 74, 75, 37, 1, 143, 144, 25, 26, - /* 250 */ 27, 28, 104, 9, 33, 34, 33, 34, 37, 236, - /* 260 */ 37, 38, 39, 33, 34, 104, 232, 109, 88, 235, - /* 270 */ 90, 91, 104, 112, 5, 95, 7, 97, 98, 99, - /* 280 */ 112, 101, 102, 209, 235, 2, 212, 213, 5, 131, + /* 230 */ 9, 1, 2, 210, 104, 5, 68, 7, 108, 9, + /* 240 */ 110, 73, 74, 75, 65, 66, 67, 210, 25, 26, + /* 250 */ 27, 28, 234, 1, 33, 34, 33, 34, 37, 236, + /* 260 */ 37, 38, 39, 33, 34, 252, 232, 249, 88, 235, + /* 270 */ 90, 91, 104, 236, 5, 95, 7, 97, 98, 99, + /* 280 */ 112, 101, 102, 209, 252, 2, 212, 213, 5, 37, /* 290 */ 7, 217, 9, 219, 220, 221, 197, 223, 224, 62, - /* 300 */ 63, 64, 134, 0, 136, 191, 69, 70, 71, 72, - /* 310 */ 142, 62, 63, 64, 191, 78, 33, 34, 69, 70, - /* 320 */ 71, 72, 115, 68, 191, 104, 191, 228, 229, 230, - /* 330 */ 231, 5, 111, 7, 104, 62, 63, 64, 117, 198, - /* 340 */ 199, 111, 69, 70, 71, 72, 232, 117, 191, 235, - /* 350 */ 15, 33, 34, 197, 133, 37, 38, 39, 196, 5, - /* 360 */ 104, 7, 200, 133, 108, 232, 110, 232, 235, 60, - /* 370 */ 235, 65, 66, 67, 62, 63, 64, 237, 124, 125, - /* 380 */ 196, 258, 79, 226, 200, 229, 117, 105, 1, 105, - /* 390 */ 250, 109, 137, 227, 111, 140, 105, 113, 105, 105, - /* 400 */ 109, 105, 109, 109, 105, 109, 109, 105, 109, 191, - /* 410 */ 105, 109, 105, 104, 109, 105, 109, 252, 105, 109, - /* 420 */ 104, 252, 109, 107, 37, 252, 129, 138, 139, 252, - /* 430 */ 138, 139, 227, 138, 139, 104, 227, 106, 138, 139, - /* 440 */ 5, 252, 7, 117, 76, 77, 111, 252, 252, 252, - /* 450 */ 252, 252, 252, 252, 252, 252, 252, 191, 236, 227, - /* 460 */ 236, 227, 227, 227, 251, 191, 191, 234, 191, 191, - /* 470 */ 191, 259, 234, 259, 234, 60, 191, 238, 191, 191, - /* 480 */ 255, 191, 117, 255, 255, 239, 255, 244, 247, 191, - /* 490 */ 248, 246, 191, 245, 122, 191, 243, 128, 127, 191, - /* 500 */ 130, 126, 191, 121, 120, 191, 191, 242, 191, 119, - /* 510 */ 191, 191, 191, 191, 191, 191, 191, 241, 191, 191, - /* 520 */ 191, 191, 118, 191, 191, 191, 240, 191, 191, 191, - /* 530 */ 191, 191, 191, 191, 191, 191, 191, 191, 191, 191, - /* 540 */ 191, 191, 191, 191, 191, 132, 191, 191, 191, 191, - /* 550 */ 191, 191, 191, 103, 192, 192, 192, 87, 192, 192, - /* 560 */ 86, 50, 83, 85, 54, 192, 192, 84, 192, 82, - /* 570 */ 79, 5, 192, 192, 145, 197, 197, 5, 5, 145, - /* 580 */ 5, 5, 90, 89, 135, 113, 192, 192, 202, 107, - /* 590 */ 193, 208, 207, 204, 206, 203, 205, 201, 193, 193, - /* 600 */ 192, 192, 225, 193, 192, 198, 104, 114, 194, 105, - /* 610 */ 109, 105, 104, 1, 105, 76, 109, 104, 225, 104, - /* 620 */ 123, 105, 104, 109, 105, 104, 109, 104, 123, 104, - /* 630 */ 108, 111, 104, 107, 9, 5, 5, 5, 5, 5, - /* 640 */ 80, 15, 139, 76, 109, 16, 5, 5, 105, 5, - /* 650 */ 5, 139, 5, 5, 5, 5, 5, 5, 5, 5, - /* 660 */ 5, 5, 5, 139, 5, 5, 5, 5, 109, 80, - /* 670 */ 60, 0, 59, 263, 263, 263, 263, 263, 263, 21, + /* 300 */ 63, 64, 134, 252, 136, 191, 69, 70, 71, 72, + /* 310 */ 104, 143, 62, 63, 64, 78, 33, 34, 112, 69, + /* 320 */ 70, 71, 72, 37, 68, 104, 191, 228, 229, 230, + /* 330 */ 231, 75, 111, 191, 104, 62, 63, 64, 117, 210, + /* 340 */ 191, 111, 69, 70, 71, 72, 232, 117, 191, 235, + /* 350 */ 135, 33, 34, 197, 133, 37, 38, 39, 105, 144, + /* 360 */ 145, 15, 5, 133, 7, 236, 113, 232, 237, 109, + /* 370 */ 235, 62, 63, 64, 232, 194, 195, 235, 252, 196, + /* 380 */ 196, 250, 233, 200, 200, 229, 117, 124, 125, 109, + /* 390 */ 60, 131, 235, 137, 111, 252, 116, 141, 142, 105, + /* 400 */ 105, 115, 105, 109, 109, 105, 109, 105, 105, 109, + /* 410 */ 109, 109, 109, 105, 252, 105, 105, 109, 105, 109, + /* 420 */ 109, 105, 109, 104, 252, 109, 107, 138, 252, 140, + /* 430 */ 129, 138, 227, 140, 104, 104, 138, 106, 140, 5, + /* 440 */ 5, 7, 7, 138, 252, 140, 76, 77, 252, 252, + /* 450 */ 252, 252, 252, 252, 236, 227, 227, 111, 227, 227, + /* 460 */ 227, 227, 191, 191, 251, 191, 191, 191, 191, 234, + /* 470 */ 234, 259, 191, 259, 117, 234, 238, 60, 191, 191, + /* 480 */ 255, 191, 191, 191, 117, 103, 243, 191, 248, 247, + /* 490 */ 191, 122, 246, 245, 255, 191, 128, 191, 191, 255, + /* 500 */ 255, 130, 127, 191, 126, 191, 191, 121, 191, 244, + /* 510 */ 120, 191, 191, 191, 191, 191, 191, 191, 191, 191, + /* 520 */ 191, 242, 119, 191, 191, 191, 191, 191, 191, 191, + /* 530 */ 191, 191, 191, 191, 191, 191, 191, 118, 191, 191, + /* 540 */ 191, 191, 191, 191, 191, 191, 191, 191, 132, 191, + /* 550 */ 191, 191, 191, 87, 192, 192, 192, 192, 192, 86, + /* 560 */ 50, 83, 85, 54, 84, 82, 79, 5, 192, 192, + /* 570 */ 146, 192, 5, 5, 146, 5, 192, 192, 197, 5, + /* 580 */ 197, 90, 89, 135, 113, 109, 192, 105, 107, 104, + /* 590 */ 193, 105, 193, 202, 206, 208, 207, 205, 203, 201, + /* 600 */ 204, 192, 198, 193, 192, 225, 193, 192, 194, 114, + /* 610 */ 192, 104, 239, 241, 240, 109, 105, 104, 225, 1, + /* 620 */ 104, 109, 105, 104, 123, 123, 105, 109, 104, 104, + /* 630 */ 104, 111, 104, 76, 107, 9, 5, 108, 5, 5, + /* 640 */ 5, 5, 15, 80, 140, 76, 109, 5, 16, 5, + /* 650 */ 5, 105, 5, 5, 140, 140, 5, 5, 5, 5, + /* 660 */ 5, 139, 5, 5, 5, 5, 5, 5, 138, 5, + /* 670 */ 5, 5, 5, 109, 80, 60, 59, 21, 0, 263, /* 680 */ 263, 263, 263, 263, 21, 263, 263, 263, 263, 263, /* 690 */ 263, 263, 263, 263, 263, 263, 263, 263, 263, 263, /* 700 */ 263, 263, 263, 263, 263, 263, 263, 263, 263, 263, @@ -363,101 +374,104 @@ static const YYCODETYPE yy_lookahead[] = { /* 840 */ 263, 263, 263, 263, 263, 263, 263, 263, 263, 263, /* 850 */ 263, 263, 263, 263, 263, 263, 263, 263, 263, 263, /* 860 */ 263, 263, 263, 263, 263, 263, 263, 263, 263, 263, - /* 870 */ 263, 263, + /* 870 */ 263, 263, 263, }; -#define YY_SHIFT_COUNT (316) +#define YY_SHIFT_COUNT (320) #define YY_SHIFT_MIN (0) -#define YY_SHIFT_MAX (671) +#define YY_SHIFT_MAX (678) static const unsigned short int yy_shift_ofst[] = { - /* 0 */ 168, 79, 79, 180, 180, 9, 221, 230, 244, 244, - /* 10 */ 244, 244, 244, 244, 244, 244, 244, 0, 48, 230, - /* 20 */ 283, 283, 283, 283, 148, 161, 244, 244, 244, 303, - /* 30 */ 244, 244, 82, 9, 37, 37, 685, 685, 685, 230, + /* 0 */ 168, 79, 79, 180, 180, 6, 221, 230, 148, 148, + /* 10 */ 148, 148, 148, 148, 148, 148, 148, 0, 48, 230, + /* 20 */ 283, 283, 283, 283, 110, 206, 148, 148, 148, 122, + /* 30 */ 148, 148, 7, 6, 31, 31, 685, 685, 685, 230, /* 40 */ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, /* 50 */ 230, 230, 230, 230, 230, 230, 230, 230, 230, 283, - /* 60 */ 283, 78, 78, 78, 78, 78, 78, 78, 244, 244, - /* 70 */ 244, 207, 244, 161, 161, 244, 244, 244, 254, 254, - /* 80 */ 26, 161, 244, 244, 244, 244, 244, 244, 244, 244, - /* 90 */ 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, - /* 100 */ 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, - /* 110 */ 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, - /* 120 */ 244, 244, 244, 244, 244, 244, 244, 244, 244, 244, - /* 130 */ 244, 244, 244, 415, 415, 415, 365, 365, 365, 415, - /* 140 */ 365, 415, 369, 370, 371, 372, 375, 382, 384, 390, - /* 150 */ 404, 413, 415, 415, 415, 450, 9, 9, 415, 415, - /* 160 */ 470, 474, 511, 479, 478, 510, 483, 487, 450, 415, - /* 170 */ 491, 491, 415, 491, 415, 491, 415, 415, 685, 685, - /* 180 */ 27, 100, 127, 100, 100, 53, 182, 223, 223, 223, - /* 190 */ 223, 237, 249, 273, 318, 318, 318, 318, 77, 103, - /* 200 */ 92, 92, 269, 326, 256, 255, 306, 312, 282, 284, - /* 210 */ 291, 293, 294, 296, 299, 387, 309, 335, 158, 297, - /* 220 */ 302, 305, 307, 310, 313, 316, 289, 292, 295, 331, - /* 230 */ 300, 354, 435, 368, 566, 429, 572, 573, 434, 575, - /* 240 */ 576, 492, 494, 449, 472, 482, 502, 493, 504, 501, - /* 250 */ 506, 508, 509, 507, 513, 612, 515, 516, 518, 514, - /* 260 */ 497, 517, 505, 519, 521, 520, 523, 482, 525, 526, - /* 270 */ 528, 522, 539, 625, 630, 631, 632, 633, 634, 560, - /* 280 */ 626, 567, 503, 535, 535, 629, 512, 524, 535, 641, - /* 290 */ 642, 543, 535, 644, 645, 647, 648, 649, 650, 651, - /* 300 */ 652, 653, 654, 655, 656, 657, 659, 660, 661, 662, - /* 310 */ 559, 589, 658, 663, 610, 613, 671, + /* 60 */ 283, 102, 102, 102, 102, 102, 102, 102, 148, 148, + /* 70 */ 148, 286, 148, 206, 206, 148, 148, 148, 263, 263, + /* 80 */ 280, 206, 148, 148, 148, 148, 148, 148, 148, 148, + /* 90 */ 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, + /* 100 */ 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, + /* 110 */ 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, + /* 120 */ 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, + /* 130 */ 148, 148, 148, 148, 417, 417, 417, 367, 367, 367, + /* 140 */ 417, 367, 417, 368, 371, 375, 369, 378, 386, 390, + /* 150 */ 403, 419, 416, 417, 417, 417, 382, 6, 6, 417, + /* 160 */ 417, 466, 473, 510, 478, 477, 509, 480, 483, 382, + /* 170 */ 417, 487, 487, 417, 487, 417, 487, 417, 417, 685, + /* 180 */ 685, 27, 100, 127, 100, 100, 53, 182, 223, 223, + /* 190 */ 223, 223, 237, 250, 273, 318, 318, 318, 318, 256, + /* 200 */ 215, 92, 92, 269, 357, 130, 21, 179, 309, 294, + /* 210 */ 253, 295, 297, 300, 302, 303, 252, 330, 346, 260, + /* 220 */ 301, 308, 310, 311, 313, 316, 319, 289, 293, 298, + /* 230 */ 331, 305, 434, 435, 370, 562, 424, 567, 568, 428, + /* 240 */ 570, 574, 491, 493, 448, 471, 481, 485, 495, 482, + /* 250 */ 476, 486, 507, 511, 506, 513, 618, 516, 517, 519, + /* 260 */ 512, 501, 518, 502, 521, 524, 520, 525, 481, 526, + /* 270 */ 527, 528, 529, 557, 626, 631, 633, 634, 635, 636, + /* 280 */ 563, 627, 569, 504, 537, 537, 632, 514, 515, 642, + /* 290 */ 522, 530, 537, 644, 645, 546, 537, 647, 648, 651, + /* 300 */ 652, 653, 654, 655, 657, 658, 659, 660, 661, 662, + /* 310 */ 664, 665, 666, 667, 564, 594, 656, 663, 615, 617, + /* 320 */ 678, }; -#define YY_REDUCE_COUNT (179) -#define YY_REDUCE_MIN (-233) -#define YY_REDUCE_MAX (414) +#define YY_REDUCE_COUNT (180) +#define YY_REDUCE_MIN (-240) +#define YY_REDUCE_MAX (418) static const short yy_reduce_ofst[] = { /* 0 */ -178, -27, -27, 74, 74, 99, -230, -216, -173, -176, - /* 10 */ -45, -76, -8, 34, 114, 133, 135, -185, -188, -233, - /* 20 */ -206, -147, -74, 23, -179, -127, -186, 123, -191, -112, - /* 30 */ 157, 49, 4, 156, 162, 184, 140, 141, -187, -217, - /* 40 */ -194, -144, -51, -18, 165, 169, 173, 177, 189, 195, - /* 50 */ 196, 197, 198, 199, 200, 201, 202, 203, 204, 222, - /* 60 */ 224, 166, 205, 209, 232, 234, 235, 236, 218, 266, - /* 70 */ 274, 213, 275, 233, 238, 277, 278, 279, 212, 214, - /* 80 */ 239, 240, 285, 287, 288, 290, 298, 301, 304, 308, - /* 90 */ 311, 314, 315, 317, 319, 320, 321, 322, 323, 324, - /* 100 */ 325, 327, 328, 329, 330, 332, 333, 334, 336, 337, - /* 110 */ 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, - /* 120 */ 348, 349, 350, 351, 352, 353, 355, 356, 357, 358, - /* 130 */ 359, 360, 361, 362, 363, 364, 225, 228, 229, 366, - /* 140 */ 231, 367, 242, 241, 245, 248, 243, 253, 265, 276, - /* 150 */ 286, 246, 373, 374, 376, 377, 378, 379, 380, 381, - /* 160 */ 383, 385, 388, 386, 391, 392, 389, 396, 393, 394, - /* 170 */ 397, 405, 395, 406, 408, 410, 409, 412, 407, 414, + /* 10 */ -45, -76, -8, 34, 114, 135, 142, -185, -188, -233, + /* 20 */ -206, 23, 37, 129, -191, 18, -186, -183, 149, -89, + /* 30 */ -184, 157, 4, 156, 183, 184, 131, 19, 181, -240, + /* 40 */ -217, -194, -134, -107, 13, 32, 51, 126, 143, 162, + /* 50 */ 172, 176, 192, 196, 197, 198, 199, 200, 201, -73, + /* 60 */ 218, 205, 228, 229, 231, 232, 233, 234, 271, 272, + /* 70 */ 274, 213, 275, 235, 236, 276, 277, 281, 212, 214, + /* 80 */ 238, 241, 287, 288, 290, 291, 292, 296, 299, 304, + /* 90 */ 306, 307, 312, 314, 315, 317, 320, 321, 322, 323, + /* 100 */ 324, 325, 326, 327, 328, 329, 332, 333, 334, 335, + /* 110 */ 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, + /* 120 */ 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, + /* 130 */ 358, 359, 360, 361, 362, 363, 364, 225, 239, 244, + /* 140 */ 365, 245, 366, 240, 242, 246, 248, 265, 243, 279, + /* 150 */ 372, 374, 373, 376, 377, 379, 380, 381, 383, 384, + /* 160 */ 385, 387, 389, 388, 391, 392, 395, 396, 398, 393, + /* 170 */ 394, 397, 399, 409, 410, 412, 413, 415, 418, 404, + /* 180 */ 414, }; static const YYACTIONTYPE yy_default[] = { - /* 0 */ 781, 894, 840, 906, 828, 837, 1037, 1037, 781, 781, - /* 10 */ 781, 781, 781, 781, 781, 781, 781, 953, 800, 1037, - /* 20 */ 781, 781, 781, 781, 781, 781, 781, 781, 781, 837, - /* 30 */ 781, 781, 843, 837, 843, 843, 948, 878, 896, 781, - /* 40 */ 781, 781, 781, 781, 781, 781, 781, 781, 781, 781, - /* 50 */ 781, 781, 781, 781, 781, 781, 781, 781, 781, 781, - /* 60 */ 781, 781, 781, 781, 781, 781, 781, 781, 781, 781, - /* 70 */ 781, 955, 958, 781, 781, 960, 781, 781, 980, 980, - /* 80 */ 946, 781, 781, 781, 781, 781, 781, 781, 781, 781, - /* 90 */ 781, 781, 781, 781, 781, 781, 781, 781, 781, 781, - /* 100 */ 781, 781, 781, 781, 781, 781, 781, 781, 781, 826, - /* 110 */ 781, 824, 781, 781, 781, 781, 781, 781, 781, 781, - /* 120 */ 781, 781, 781, 781, 781, 781, 811, 781, 781, 781, - /* 130 */ 781, 781, 781, 802, 802, 802, 781, 781, 781, 802, - /* 140 */ 781, 802, 987, 991, 985, 973, 981, 972, 968, 966, - /* 150 */ 965, 995, 802, 802, 802, 841, 837, 837, 802, 802, - /* 160 */ 859, 857, 855, 847, 853, 849, 851, 845, 829, 802, - /* 170 */ 835, 835, 802, 835, 802, 835, 802, 802, 878, 896, - /* 180 */ 781, 996, 781, 1036, 986, 1026, 1025, 1032, 1024, 1023, - /* 190 */ 1022, 781, 781, 781, 1018, 1019, 1021, 1020, 781, 781, - /* 200 */ 1028, 1027, 781, 781, 781, 781, 781, 781, 781, 781, - /* 210 */ 781, 781, 781, 781, 781, 781, 998, 781, 992, 988, - /* 220 */ 781, 781, 781, 781, 781, 781, 781, 781, 781, 908, - /* 230 */ 781, 781, 781, 781, 781, 781, 781, 781, 781, 781, - /* 240 */ 781, 781, 781, 781, 945, 781, 781, 781, 781, 956, - /* 250 */ 781, 781, 781, 781, 781, 781, 781, 781, 781, 982, - /* 260 */ 781, 974, 781, 781, 781, 781, 781, 920, 781, 781, - /* 270 */ 781, 781, 781, 781, 781, 781, 781, 781, 781, 781, - /* 280 */ 781, 781, 781, 1048, 1046, 781, 781, 781, 1042, 781, - /* 290 */ 781, 781, 1040, 781, 781, 781, 781, 781, 781, 781, - /* 300 */ 781, 781, 781, 781, 781, 781, 781, 781, 781, 781, - /* 310 */ 862, 781, 809, 807, 781, 798, 781, + /* 0 */ 787, 900, 846, 912, 834, 843, 1043, 1043, 787, 787, + /* 10 */ 787, 787, 787, 787, 787, 787, 787, 959, 806, 1043, + /* 20 */ 787, 787, 787, 787, 787, 787, 787, 787, 787, 843, + /* 30 */ 787, 787, 849, 843, 849, 849, 954, 884, 902, 787, + /* 40 */ 787, 787, 787, 787, 787, 787, 787, 787, 787, 787, + /* 50 */ 787, 787, 787, 787, 787, 787, 787, 787, 787, 787, + /* 60 */ 787, 787, 787, 787, 787, 787, 787, 787, 787, 787, + /* 70 */ 787, 961, 964, 787, 787, 966, 787, 787, 986, 986, + /* 80 */ 952, 787, 787, 787, 787, 787, 787, 787, 787, 787, + /* 90 */ 787, 787, 787, 787, 787, 787, 787, 787, 787, 787, + /* 100 */ 787, 787, 787, 787, 787, 787, 787, 787, 787, 787, + /* 110 */ 832, 787, 830, 787, 787, 787, 787, 787, 787, 787, + /* 120 */ 787, 787, 787, 787, 787, 787, 787, 817, 787, 787, + /* 130 */ 787, 787, 787, 787, 808, 808, 808, 787, 787, 787, + /* 140 */ 808, 787, 808, 993, 997, 991, 979, 987, 978, 974, + /* 150 */ 972, 971, 1001, 808, 808, 808, 847, 843, 843, 808, + /* 160 */ 808, 865, 863, 861, 853, 859, 855, 857, 851, 835, + /* 170 */ 808, 841, 841, 808, 841, 808, 841, 808, 808, 884, + /* 180 */ 902, 787, 1002, 787, 1042, 992, 1032, 1031, 1038, 1030, + /* 190 */ 1029, 1028, 787, 787, 787, 1024, 1025, 1027, 1026, 787, + /* 200 */ 787, 1034, 1033, 787, 787, 787, 787, 787, 787, 787, + /* 210 */ 787, 787, 787, 787, 787, 787, 787, 1004, 787, 998, + /* 220 */ 994, 787, 787, 787, 787, 787, 787, 787, 787, 787, + /* 230 */ 914, 787, 787, 787, 787, 787, 787, 787, 787, 787, + /* 240 */ 787, 787, 787, 787, 787, 951, 787, 787, 787, 787, + /* 250 */ 962, 787, 787, 787, 787, 787, 787, 787, 787, 787, + /* 260 */ 988, 787, 980, 787, 787, 787, 787, 787, 926, 787, + /* 270 */ 787, 787, 787, 787, 787, 787, 787, 787, 787, 787, + /* 280 */ 787, 787, 787, 787, 1055, 1053, 787, 787, 787, 787, + /* 290 */ 787, 787, 1049, 787, 787, 787, 1046, 787, 787, 787, + /* 300 */ 787, 787, 787, 787, 787, 787, 787, 787, 787, 787, + /* 310 */ 787, 787, 787, 787, 868, 787, 815, 813, 787, 804, + /* 320 */ 787, }; /********** End of lemon-generated parsing tables *****************************/ @@ -616,6 +630,7 @@ static const YYCODETYPE yyFallback[] = { 0, /* SYNCDB => nothing */ 0, /* ADD => nothing */ 0, /* COLUMN => nothing */ + 0, /* LENGTH => nothing */ 0, /* TAG => nothing */ 0, /* CHANGE => nothing */ 0, /* SET => nothing */ @@ -703,6 +718,7 @@ struct yyParser { int yyerrcnt; /* Shifts left before out of the error */ #endif ParseARG_SDECL /* A place to hold %extra_argument */ + ParseCTX_SDECL /* A place to hold %extra_context */ #if YYSTACKDEPTH<=0 int yystksz; /* Current side of the stack */ yyStackEntry *yystack; /* The parser's stack */ @@ -889,55 +905,55 @@ static const char *const yyTokenName[] = { /* 136 */ "SYNCDB", /* 137 */ "ADD", /* 138 */ "COLUMN", - /* 139 */ "TAG", - /* 140 */ "CHANGE", - /* 141 */ "SET", - /* 142 */ "KILL", - /* 143 */ "CONNECTION", - /* 144 */ "STREAM", - /* 145 */ "COLON", - /* 146 */ "ABORT", - /* 147 */ "AFTER", - /* 148 */ "ATTACH", - /* 149 */ "BEFORE", - /* 150 */ "BEGIN", - /* 151 */ "CASCADE", - /* 152 */ "CLUSTER", - /* 153 */ "CONFLICT", - /* 154 */ "COPY", - /* 155 */ "DEFERRED", - /* 156 */ "DELIMITERS", - /* 157 */ "DETACH", - /* 158 */ "EACH", - /* 159 */ "END", - /* 160 */ "EXPLAIN", - /* 161 */ "FAIL", - /* 162 */ "FOR", - /* 163 */ "IGNORE", - /* 164 */ "IMMEDIATE", - /* 165 */ "INITIALLY", - /* 166 */ "INSTEAD", - /* 167 */ "MATCH", - /* 168 */ "KEY", - /* 169 */ "OF", - /* 170 */ "RAISE", - /* 171 */ "REPLACE", - /* 172 */ "RESTRICT", - /* 173 */ "ROW", - /* 174 */ "STATEMENT", - /* 175 */ "TRIGGER", - /* 176 */ "VIEW", - /* 177 */ "SEMI", - /* 178 */ "NONE", - /* 179 */ "PREV", - /* 180 */ "LINEAR", - /* 181 */ "IMPORT", - /* 182 */ "TBNAME", - /* 183 */ "JOIN", - /* 184 */ "INSERT", - /* 185 */ "INTO", - /* 186 */ "VALUES", - /* 187 */ "error", + /* 139 */ "LENGTH", + /* 140 */ "TAG", + /* 141 */ "CHANGE", + /* 142 */ "SET", + /* 143 */ "KILL", + /* 144 */ "CONNECTION", + /* 145 */ "STREAM", + /* 146 */ "COLON", + /* 147 */ "ABORT", + /* 148 */ "AFTER", + /* 149 */ "ATTACH", + /* 150 */ "BEFORE", + /* 151 */ "BEGIN", + /* 152 */ "CASCADE", + /* 153 */ "CLUSTER", + /* 154 */ "CONFLICT", + /* 155 */ "COPY", + /* 156 */ "DEFERRED", + /* 157 */ "DELIMITERS", + /* 158 */ "DETACH", + /* 159 */ "EACH", + /* 160 */ "END", + /* 161 */ "EXPLAIN", + /* 162 */ "FAIL", + /* 163 */ "FOR", + /* 164 */ "IGNORE", + /* 165 */ "IMMEDIATE", + /* 166 */ "INITIALLY", + /* 167 */ "INSTEAD", + /* 168 */ "MATCH", + /* 169 */ "KEY", + /* 170 */ "OF", + /* 171 */ "RAISE", + /* 172 */ "REPLACE", + /* 173 */ "RESTRICT", + /* 174 */ "ROW", + /* 175 */ "STATEMENT", + /* 176 */ "TRIGGER", + /* 177 */ "VIEW", + /* 178 */ "SEMI", + /* 179 */ "NONE", + /* 180 */ "PREV", + /* 181 */ "LINEAR", + /* 182 */ "IMPORT", + /* 183 */ "TBNAME", + /* 184 */ "JOIN", + /* 185 */ "INSERT", + /* 186 */ "INTO", + /* 187 */ "VALUES", /* 188 */ "program", /* 189 */ "cmd", /* 190 */ "dbPrefix", @@ -1278,18 +1294,19 @@ static const char *const yyRuleName[] = { /* 255 */ "cmd ::= SYNCDB ids REPLICA", /* 256 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist", /* 257 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids", - /* 258 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist", - /* 259 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids", - /* 260 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids", - /* 261 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem", - /* 262 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist", - /* 263 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids", - /* 264 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist", - /* 265 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids", - /* 266 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids", - /* 267 */ "cmd ::= KILL CONNECTION INTEGER", - /* 268 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER", - /* 269 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER", + /* 258 */ "cmd ::= ALTER TABLE ids cpxName ALTER COLUMN LENGTH ids INTEGER", + /* 259 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist", + /* 260 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids", + /* 261 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids", + /* 262 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem", + /* 263 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist", + /* 264 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids", + /* 265 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist", + /* 266 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids", + /* 267 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids", + /* 268 */ "cmd ::= KILL CONNECTION INTEGER", + /* 269 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER", + /* 270 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER", }; #endif /* NDEBUG */ @@ -1338,28 +1355,29 @@ static int yyGrowStack(yyParser *p){ /* Initialize a new parser that has already been allocated. */ -void ParseInit(void *yypParser){ - yyParser *pParser = (yyParser*)yypParser; +void ParseInit(void *yypRawParser ParseCTX_PDECL){ + yyParser *yypParser = (yyParser*)yypRawParser; + ParseCTX_STORE #ifdef YYTRACKMAXSTACKDEPTH - pParser->yyhwm = 0; + yypParser->yyhwm = 0; #endif #if YYSTACKDEPTH<=0 - pParser->yytos = NULL; - pParser->yystack = NULL; - pParser->yystksz = 0; - if( yyGrowStack(pParser) ){ - pParser->yystack = &pParser->yystk0; - pParser->yystksz = 1; + yypParser->yytos = NULL; + yypParser->yystack = NULL; + yypParser->yystksz = 0; + if( yyGrowStack(yypParser) ){ + yypParser->yystack = &yypParser->yystk0; + yypParser->yystksz = 1; } #endif #ifndef YYNOERRORRECOVERY - pParser->yyerrcnt = -1; + yypParser->yyerrcnt = -1; #endif - pParser->yytos = pParser->yystack; - pParser->yystack[0].stateno = 0; - pParser->yystack[0].major = 0; + yypParser->yytos = yypParser->yystack; + yypParser->yystack[0].stateno = 0; + yypParser->yystack[0].major = 0; #if YYSTACKDEPTH>0 - pParser->yystackEnd = &pParser->yystack[YYSTACKDEPTH-1]; + yypParser->yystackEnd = &yypParser->yystack[YYSTACKDEPTH-1]; #endif } @@ -1376,11 +1394,14 @@ void ParseInit(void *yypParser){ ** A pointer to a parser. This pointer is used in subsequent calls ** to Parse and ParseFree. */ -void *ParseAlloc(void *(*mallocProc)(YYMALLOCARGTYPE)){ - yyParser *pParser; - pParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) ); - if( pParser ) ParseInit(pParser); - return pParser; +void *ParseAlloc(void *(*mallocProc)(YYMALLOCARGTYPE) ParseCTX_PDECL){ + yyParser *yypParser; + yypParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) ); + if( yypParser ){ + ParseCTX_STORE + ParseInit(yypParser ParseCTX_PARAM); + } + return (void*)yypParser; } #endif /* Parse_ENGINEALWAYSONSTACK */ @@ -1397,7 +1418,8 @@ static void yy_destructor( YYCODETYPE yymajor, /* Type code for object to destroy */ YYMINORTYPE *yypminor /* The object to be destroyed */ ){ - ParseARG_FETCH; + ParseARG_FETCH + ParseCTX_FETCH switch( yymajor ){ /* Here is inserted the actions which take place when a ** terminal or non-terminal is destroyed. This can happen @@ -1573,13 +1595,12 @@ int ParseCoverage(FILE *out){ ** Find the appropriate action for a parser given the terminal ** look-ahead token iLookAhead. */ -static unsigned int yy_find_shift_action( - yyParser *pParser, /* The parser */ - YYCODETYPE iLookAhead /* The look-ahead token */ +static YYACTIONTYPE yy_find_shift_action( + YYCODETYPE iLookAhead, /* The look-ahead token */ + YYACTIONTYPE stateno /* Current state number */ ){ int i; - int stateno = pParser->yytos->stateno; - + if( stateno>YY_MAX_SHIFT ) return stateno; assert( stateno <= YY_SHIFT_COUNT ); #if defined(YYCOVERAGE) @@ -1587,15 +1608,19 @@ static unsigned int yy_find_shift_action( #endif do{ i = yy_shift_ofst[stateno]; - assert( i>=0 && i+YYNTOKEN<=sizeof(yy_lookahead)/sizeof(yy_lookahead[0]) ); + assert( i>=0 ); + assert( i<=YY_ACTTAB_COUNT ); + assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD ); assert( iLookAhead!=YYNOCODE ); assert( iLookAhead < YYNTOKEN ); i += iLookAhead; + assert( i<(int)YY_NLOOKAHEAD ); if( yy_lookahead[i]!=iLookAhead ){ #ifdef YYFALLBACK YYCODETYPE iFallback; /* Fallback token */ - if( iLookAhead %s\n", @@ -1610,15 +1635,8 @@ static unsigned int yy_find_shift_action( #ifdef YYWILDCARD { int j = i - iLookAhead + YYWILDCARD; - if( -#if YY_SHIFT_MIN+YYWILDCARD<0 - j>=0 && -#endif -#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT - j0 - ){ + assert( j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) ); + if( yy_lookahead[j]==YYWILDCARD && iLookAhead>0 ){ #ifndef NDEBUG if( yyTraceFILE ){ fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n", @@ -1632,6 +1650,7 @@ static unsigned int yy_find_shift_action( #endif /* YYWILDCARD */ return yy_default[stateno]; }else{ + assert( i>=0 && iyytos; - yytos->stateno = (YYACTIONTYPE)yyNewState; - yytos->major = (YYCODETYPE)yyMajor; + yytos->stateno = yyNewState; + yytos->major = yyMajor; yytos->minor.yy0 = yyMinor; yyTraceShift(yypParser, yyNewState, "Shift"); } -/* The following table contains information about every rule that -** is used during the reduce. -*/ -static const struct { - YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */ - signed char nrhs; /* Negative of the number of RHS symbols in the rule */ -} yyRuleInfo[] = { - { 188, -1 }, /* (0) program ::= cmd */ - { 189, -2 }, /* (1) cmd ::= SHOW DATABASES */ - { 189, -2 }, /* (2) cmd ::= SHOW TOPICS */ - { 189, -2 }, /* (3) cmd ::= SHOW MNODES */ - { 189, -2 }, /* (4) cmd ::= SHOW DNODES */ - { 189, -2 }, /* (5) cmd ::= SHOW ACCOUNTS */ - { 189, -2 }, /* (6) cmd ::= SHOW USERS */ - { 189, -2 }, /* (7) cmd ::= SHOW MODULES */ - { 189, -2 }, /* (8) cmd ::= SHOW QUERIES */ - { 189, -2 }, /* (9) cmd ::= SHOW CONNECTIONS */ - { 189, -2 }, /* (10) cmd ::= SHOW STREAMS */ - { 189, -2 }, /* (11) cmd ::= SHOW VARIABLES */ - { 189, -2 }, /* (12) cmd ::= SHOW SCORES */ - { 189, -2 }, /* (13) cmd ::= SHOW GRANTS */ - { 189, -2 }, /* (14) cmd ::= SHOW VNODES */ - { 189, -3 }, /* (15) cmd ::= SHOW VNODES IPTOKEN */ - { 190, 0 }, /* (16) dbPrefix ::= */ - { 190, -2 }, /* (17) dbPrefix ::= ids DOT */ - { 192, 0 }, /* (18) cpxName ::= */ - { 192, -2 }, /* (19) cpxName ::= DOT ids */ - { 189, -5 }, /* (20) cmd ::= SHOW CREATE TABLE ids cpxName */ - { 189, -5 }, /* (21) cmd ::= SHOW CREATE STABLE ids cpxName */ - { 189, -4 }, /* (22) cmd ::= SHOW CREATE DATABASE ids */ - { 189, -3 }, /* (23) cmd ::= SHOW dbPrefix TABLES */ - { 189, -5 }, /* (24) cmd ::= SHOW dbPrefix TABLES LIKE ids */ - { 189, -3 }, /* (25) cmd ::= SHOW dbPrefix STABLES */ - { 189, -5 }, /* (26) cmd ::= SHOW dbPrefix STABLES LIKE ids */ - { 189, -3 }, /* (27) cmd ::= SHOW dbPrefix VGROUPS */ - { 189, -4 }, /* (28) cmd ::= SHOW dbPrefix VGROUPS ids */ - { 189, -5 }, /* (29) cmd ::= DROP TABLE ifexists ids cpxName */ - { 189, -5 }, /* (30) cmd ::= DROP STABLE ifexists ids cpxName */ - { 189, -4 }, /* (31) cmd ::= DROP DATABASE ifexists ids */ - { 189, -4 }, /* (32) cmd ::= DROP TOPIC ifexists ids */ - { 189, -3 }, /* (33) cmd ::= DROP DNODE ids */ - { 189, -3 }, /* (34) cmd ::= DROP USER ids */ - { 189, -3 }, /* (35) cmd ::= DROP ACCOUNT ids */ - { 189, -2 }, /* (36) cmd ::= USE ids */ - { 189, -3 }, /* (37) cmd ::= DESCRIBE ids cpxName */ - { 189, -5 }, /* (38) cmd ::= ALTER USER ids PASS ids */ - { 189, -5 }, /* (39) cmd ::= ALTER USER ids PRIVILEGE ids */ - { 189, -4 }, /* (40) cmd ::= ALTER DNODE ids ids */ - { 189, -5 }, /* (41) cmd ::= ALTER DNODE ids ids ids */ - { 189, -3 }, /* (42) cmd ::= ALTER LOCAL ids */ - { 189, -4 }, /* (43) cmd ::= ALTER LOCAL ids ids */ - { 189, -4 }, /* (44) cmd ::= ALTER DATABASE ids alter_db_optr */ - { 189, -4 }, /* (45) cmd ::= ALTER TOPIC ids alter_topic_optr */ - { 189, -4 }, /* (46) cmd ::= ALTER ACCOUNT ids acct_optr */ - { 189, -6 }, /* (47) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */ - { 191, -1 }, /* (48) ids ::= ID */ - { 191, -1 }, /* (49) ids ::= STRING */ - { 193, -2 }, /* (50) ifexists ::= IF EXISTS */ - { 193, 0 }, /* (51) ifexists ::= */ - { 197, -3 }, /* (52) ifnotexists ::= IF NOT EXISTS */ - { 197, 0 }, /* (53) ifnotexists ::= */ - { 189, -3 }, /* (54) cmd ::= CREATE DNODE ids */ - { 189, -6 }, /* (55) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */ - { 189, -5 }, /* (56) cmd ::= CREATE DATABASE ifnotexists ids db_optr */ - { 189, -5 }, /* (57) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ - { 189, -5 }, /* (58) cmd ::= CREATE USER ids PASS ids */ - { 200, 0 }, /* (59) pps ::= */ - { 200, -2 }, /* (60) pps ::= PPS INTEGER */ - { 201, 0 }, /* (61) tseries ::= */ - { 201, -2 }, /* (62) tseries ::= TSERIES INTEGER */ - { 202, 0 }, /* (63) dbs ::= */ - { 202, -2 }, /* (64) dbs ::= DBS INTEGER */ - { 203, 0 }, /* (65) streams ::= */ - { 203, -2 }, /* (66) streams ::= STREAMS INTEGER */ - { 204, 0 }, /* (67) storage ::= */ - { 204, -2 }, /* (68) storage ::= STORAGE INTEGER */ - { 205, 0 }, /* (69) qtime ::= */ - { 205, -2 }, /* (70) qtime ::= QTIME INTEGER */ - { 206, 0 }, /* (71) users ::= */ - { 206, -2 }, /* (72) users ::= USERS INTEGER */ - { 207, 0 }, /* (73) conns ::= */ - { 207, -2 }, /* (74) conns ::= CONNS INTEGER */ - { 208, 0 }, /* (75) state ::= */ - { 208, -2 }, /* (76) state ::= STATE ids */ - { 196, -9 }, /* (77) acct_optr ::= pps tseries storage streams qtime dbs users conns state */ - { 209, -2 }, /* (78) keep ::= KEEP tagitemlist */ - { 211, -2 }, /* (79) cache ::= CACHE INTEGER */ - { 212, -2 }, /* (80) replica ::= REPLICA INTEGER */ - { 213, -2 }, /* (81) quorum ::= QUORUM INTEGER */ - { 214, -2 }, /* (82) days ::= DAYS INTEGER */ - { 215, -2 }, /* (83) minrows ::= MINROWS INTEGER */ - { 216, -2 }, /* (84) maxrows ::= MAXROWS INTEGER */ - { 217, -2 }, /* (85) blocks ::= BLOCKS INTEGER */ - { 218, -2 }, /* (86) ctime ::= CTIME INTEGER */ - { 219, -2 }, /* (87) wal ::= WAL INTEGER */ - { 220, -2 }, /* (88) fsync ::= FSYNC INTEGER */ - { 221, -2 }, /* (89) comp ::= COMP INTEGER */ - { 222, -2 }, /* (90) prec ::= PRECISION STRING */ - { 223, -2 }, /* (91) update ::= UPDATE INTEGER */ - { 224, -2 }, /* (92) cachelast ::= CACHELAST INTEGER */ - { 225, -2 }, /* (93) partitions ::= PARTITIONS INTEGER */ - { 198, 0 }, /* (94) db_optr ::= */ - { 198, -2 }, /* (95) db_optr ::= db_optr cache */ - { 198, -2 }, /* (96) db_optr ::= db_optr replica */ - { 198, -2 }, /* (97) db_optr ::= db_optr quorum */ - { 198, -2 }, /* (98) db_optr ::= db_optr days */ - { 198, -2 }, /* (99) db_optr ::= db_optr minrows */ - { 198, -2 }, /* (100) db_optr ::= db_optr maxrows */ - { 198, -2 }, /* (101) db_optr ::= db_optr blocks */ - { 198, -2 }, /* (102) db_optr ::= db_optr ctime */ - { 198, -2 }, /* (103) db_optr ::= db_optr wal */ - { 198, -2 }, /* (104) db_optr ::= db_optr fsync */ - { 198, -2 }, /* (105) db_optr ::= db_optr comp */ - { 198, -2 }, /* (106) db_optr ::= db_optr prec */ - { 198, -2 }, /* (107) db_optr ::= db_optr keep */ - { 198, -2 }, /* (108) db_optr ::= db_optr update */ - { 198, -2 }, /* (109) db_optr ::= db_optr cachelast */ - { 199, -1 }, /* (110) topic_optr ::= db_optr */ - { 199, -2 }, /* (111) topic_optr ::= topic_optr partitions */ - { 194, 0 }, /* (112) alter_db_optr ::= */ - { 194, -2 }, /* (113) alter_db_optr ::= alter_db_optr replica */ - { 194, -2 }, /* (114) alter_db_optr ::= alter_db_optr quorum */ - { 194, -2 }, /* (115) alter_db_optr ::= alter_db_optr keep */ - { 194, -2 }, /* (116) alter_db_optr ::= alter_db_optr blocks */ - { 194, -2 }, /* (117) alter_db_optr ::= alter_db_optr comp */ - { 194, -2 }, /* (118) alter_db_optr ::= alter_db_optr wal */ - { 194, -2 }, /* (119) alter_db_optr ::= alter_db_optr fsync */ - { 194, -2 }, /* (120) alter_db_optr ::= alter_db_optr update */ - { 194, -2 }, /* (121) alter_db_optr ::= alter_db_optr cachelast */ - { 195, -1 }, /* (122) alter_topic_optr ::= alter_db_optr */ - { 195, -2 }, /* (123) alter_topic_optr ::= alter_topic_optr partitions */ - { 226, -1 }, /* (124) typename ::= ids */ - { 226, -4 }, /* (125) typename ::= ids LP signed RP */ - { 226, -2 }, /* (126) typename ::= ids UNSIGNED */ - { 227, -1 }, /* (127) signed ::= INTEGER */ - { 227, -2 }, /* (128) signed ::= PLUS INTEGER */ - { 227, -2 }, /* (129) signed ::= MINUS INTEGER */ - { 189, -3 }, /* (130) cmd ::= CREATE TABLE create_table_args */ - { 189, -3 }, /* (131) cmd ::= CREATE TABLE create_stable_args */ - { 189, -3 }, /* (132) cmd ::= CREATE STABLE create_stable_args */ - { 189, -3 }, /* (133) cmd ::= CREATE TABLE create_table_list */ - { 230, -1 }, /* (134) create_table_list ::= create_from_stable */ - { 230, -2 }, /* (135) create_table_list ::= create_table_list create_from_stable */ - { 228, -6 }, /* (136) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */ - { 229, -10 }, /* (137) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */ - { 231, -10 }, /* (138) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */ - { 231, -13 }, /* (139) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */ - { 233, -3 }, /* (140) tagNamelist ::= tagNamelist COMMA ids */ - { 233, -1 }, /* (141) tagNamelist ::= ids */ - { 228, -5 }, /* (142) create_table_args ::= ifnotexists ids cpxName AS select */ - { 232, -3 }, /* (143) columnlist ::= columnlist COMMA column */ - { 232, -1 }, /* (144) columnlist ::= column */ - { 235, -2 }, /* (145) column ::= ids typename */ - { 210, -3 }, /* (146) tagitemlist ::= tagitemlist COMMA tagitem */ - { 210, -1 }, /* (147) tagitemlist ::= tagitem */ - { 236, -1 }, /* (148) tagitem ::= INTEGER */ - { 236, -1 }, /* (149) tagitem ::= FLOAT */ - { 236, -1 }, /* (150) tagitem ::= STRING */ - { 236, -1 }, /* (151) tagitem ::= BOOL */ - { 236, -1 }, /* (152) tagitem ::= NULL */ - { 236, -2 }, /* (153) tagitem ::= MINUS INTEGER */ - { 236, -2 }, /* (154) tagitem ::= MINUS FLOAT */ - { 236, -2 }, /* (155) tagitem ::= PLUS INTEGER */ - { 236, -2 }, /* (156) tagitem ::= PLUS FLOAT */ - { 234, -13 }, /* (157) select ::= SELECT selcollist from where_opt interval_opt session_option fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */ - { 234, -3 }, /* (158) select ::= LP select RP */ - { 249, -1 }, /* (159) union ::= select */ - { 249, -4 }, /* (160) union ::= union UNION ALL select */ - { 189, -1 }, /* (161) cmd ::= union */ - { 234, -2 }, /* (162) select ::= SELECT selcollist */ - { 250, -2 }, /* (163) sclp ::= selcollist COMMA */ - { 250, 0 }, /* (164) sclp ::= */ - { 237, -4 }, /* (165) selcollist ::= sclp distinct expr as */ - { 237, -2 }, /* (166) selcollist ::= sclp STAR */ - { 253, -2 }, /* (167) as ::= AS ids */ - { 253, -1 }, /* (168) as ::= ids */ - { 253, 0 }, /* (169) as ::= */ - { 251, -1 }, /* (170) distinct ::= DISTINCT */ - { 251, 0 }, /* (171) distinct ::= */ - { 238, -2 }, /* (172) from ::= FROM tablelist */ - { 238, -4 }, /* (173) from ::= FROM LP union RP */ - { 254, -2 }, /* (174) tablelist ::= ids cpxName */ - { 254, -3 }, /* (175) tablelist ::= ids cpxName ids */ - { 254, -4 }, /* (176) tablelist ::= tablelist COMMA ids cpxName */ - { 254, -5 }, /* (177) tablelist ::= tablelist COMMA ids cpxName ids */ - { 255, -1 }, /* (178) tmvar ::= VARIABLE */ - { 240, -4 }, /* (179) interval_opt ::= INTERVAL LP tmvar RP */ - { 240, -6 }, /* (180) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */ - { 240, 0 }, /* (181) interval_opt ::= */ - { 241, 0 }, /* (182) session_option ::= */ - { 241, -7 }, /* (183) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */ - { 242, 0 }, /* (184) fill_opt ::= */ - { 242, -6 }, /* (185) fill_opt ::= FILL LP ID COMMA tagitemlist RP */ - { 242, -4 }, /* (186) fill_opt ::= FILL LP ID RP */ - { 243, -4 }, /* (187) sliding_opt ::= SLIDING LP tmvar RP */ - { 243, 0 }, /* (188) sliding_opt ::= */ - { 245, 0 }, /* (189) orderby_opt ::= */ - { 245, -3 }, /* (190) orderby_opt ::= ORDER BY sortlist */ - { 256, -4 }, /* (191) sortlist ::= sortlist COMMA item sortorder */ - { 256, -2 }, /* (192) sortlist ::= item sortorder */ - { 258, -2 }, /* (193) item ::= ids cpxName */ - { 259, -1 }, /* (194) sortorder ::= ASC */ - { 259, -1 }, /* (195) sortorder ::= DESC */ - { 259, 0 }, /* (196) sortorder ::= */ - { 244, 0 }, /* (197) groupby_opt ::= */ - { 244, -3 }, /* (198) groupby_opt ::= GROUP BY grouplist */ - { 260, -3 }, /* (199) grouplist ::= grouplist COMMA item */ - { 260, -1 }, /* (200) grouplist ::= item */ - { 246, 0 }, /* (201) having_opt ::= */ - { 246, -2 }, /* (202) having_opt ::= HAVING expr */ - { 248, 0 }, /* (203) limit_opt ::= */ - { 248, -2 }, /* (204) limit_opt ::= LIMIT signed */ - { 248, -4 }, /* (205) limit_opt ::= LIMIT signed OFFSET signed */ - { 248, -4 }, /* (206) limit_opt ::= LIMIT signed COMMA signed */ - { 247, 0 }, /* (207) slimit_opt ::= */ - { 247, -2 }, /* (208) slimit_opt ::= SLIMIT signed */ - { 247, -4 }, /* (209) slimit_opt ::= SLIMIT signed SOFFSET signed */ - { 247, -4 }, /* (210) slimit_opt ::= SLIMIT signed COMMA signed */ - { 239, 0 }, /* (211) where_opt ::= */ - { 239, -2 }, /* (212) where_opt ::= WHERE expr */ - { 252, -3 }, /* (213) expr ::= LP expr RP */ - { 252, -1 }, /* (214) expr ::= ID */ - { 252, -3 }, /* (215) expr ::= ID DOT ID */ - { 252, -3 }, /* (216) expr ::= ID DOT STAR */ - { 252, -1 }, /* (217) expr ::= INTEGER */ - { 252, -2 }, /* (218) expr ::= MINUS INTEGER */ - { 252, -2 }, /* (219) expr ::= PLUS INTEGER */ - { 252, -1 }, /* (220) expr ::= FLOAT */ - { 252, -2 }, /* (221) expr ::= MINUS FLOAT */ - { 252, -2 }, /* (222) expr ::= PLUS FLOAT */ - { 252, -1 }, /* (223) expr ::= STRING */ - { 252, -1 }, /* (224) expr ::= NOW */ - { 252, -1 }, /* (225) expr ::= VARIABLE */ - { 252, -2 }, /* (226) expr ::= PLUS VARIABLE */ - { 252, -2 }, /* (227) expr ::= MINUS VARIABLE */ - { 252, -1 }, /* (228) expr ::= BOOL */ - { 252, -1 }, /* (229) expr ::= NULL */ - { 252, -4 }, /* (230) expr ::= ID LP exprlist RP */ - { 252, -4 }, /* (231) expr ::= ID LP STAR RP */ - { 252, -3 }, /* (232) expr ::= expr IS NULL */ - { 252, -4 }, /* (233) expr ::= expr IS NOT NULL */ - { 252, -3 }, /* (234) expr ::= expr LT expr */ - { 252, -3 }, /* (235) expr ::= expr GT expr */ - { 252, -3 }, /* (236) expr ::= expr LE expr */ - { 252, -3 }, /* (237) expr ::= expr GE expr */ - { 252, -3 }, /* (238) expr ::= expr NE expr */ - { 252, -3 }, /* (239) expr ::= expr EQ expr */ - { 252, -5 }, /* (240) expr ::= expr BETWEEN expr AND expr */ - { 252, -3 }, /* (241) expr ::= expr AND expr */ - { 252, -3 }, /* (242) expr ::= expr OR expr */ - { 252, -3 }, /* (243) expr ::= expr PLUS expr */ - { 252, -3 }, /* (244) expr ::= expr MINUS expr */ - { 252, -3 }, /* (245) expr ::= expr STAR expr */ - { 252, -3 }, /* (246) expr ::= expr SLASH expr */ - { 252, -3 }, /* (247) expr ::= expr REM expr */ - { 252, -3 }, /* (248) expr ::= expr LIKE expr */ - { 252, -5 }, /* (249) expr ::= expr IN LP exprlist RP */ - { 261, -3 }, /* (250) exprlist ::= exprlist COMMA expritem */ - { 261, -1 }, /* (251) exprlist ::= expritem */ - { 262, -1 }, /* (252) expritem ::= expr */ - { 262, 0 }, /* (253) expritem ::= */ - { 189, -3 }, /* (254) cmd ::= RESET QUERY CACHE */ - { 189, -3 }, /* (255) cmd ::= SYNCDB ids REPLICA */ - { 189, -7 }, /* (256) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */ - { 189, -7 }, /* (257) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */ - { 189, -7 }, /* (258) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ - { 189, -7 }, /* (259) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ - { 189, -8 }, /* (260) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ - { 189, -9 }, /* (261) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ - { 189, -7 }, /* (262) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ - { 189, -7 }, /* (263) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ - { 189, -7 }, /* (264) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ - { 189, -7 }, /* (265) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ - { 189, -8 }, /* (266) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ - { 189, -3 }, /* (267) cmd ::= KILL CONNECTION INTEGER */ - { 189, -5 }, /* (268) cmd ::= KILL STREAM INTEGER COLON INTEGER */ - { 189, -5 }, /* (269) cmd ::= KILL QUERY INTEGER COLON INTEGER */ +/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side +** of that rule */ +static const YYCODETYPE yyRuleInfoLhs[] = { + 188, /* (0) program ::= cmd */ + 189, /* (1) cmd ::= SHOW DATABASES */ + 189, /* (2) cmd ::= SHOW TOPICS */ + 189, /* (3) cmd ::= SHOW MNODES */ + 189, /* (4) cmd ::= SHOW DNODES */ + 189, /* (5) cmd ::= SHOW ACCOUNTS */ + 189, /* (6) cmd ::= SHOW USERS */ + 189, /* (7) cmd ::= SHOW MODULES */ + 189, /* (8) cmd ::= SHOW QUERIES */ + 189, /* (9) cmd ::= SHOW CONNECTIONS */ + 189, /* (10) cmd ::= SHOW STREAMS */ + 189, /* (11) cmd ::= SHOW VARIABLES */ + 189, /* (12) cmd ::= SHOW SCORES */ + 189, /* (13) cmd ::= SHOW GRANTS */ + 189, /* (14) cmd ::= SHOW VNODES */ + 189, /* (15) cmd ::= SHOW VNODES IPTOKEN */ + 190, /* (16) dbPrefix ::= */ + 190, /* (17) dbPrefix ::= ids DOT */ + 192, /* (18) cpxName ::= */ + 192, /* (19) cpxName ::= DOT ids */ + 189, /* (20) cmd ::= SHOW CREATE TABLE ids cpxName */ + 189, /* (21) cmd ::= SHOW CREATE STABLE ids cpxName */ + 189, /* (22) cmd ::= SHOW CREATE DATABASE ids */ + 189, /* (23) cmd ::= SHOW dbPrefix TABLES */ + 189, /* (24) cmd ::= SHOW dbPrefix TABLES LIKE ids */ + 189, /* (25) cmd ::= SHOW dbPrefix STABLES */ + 189, /* (26) cmd ::= SHOW dbPrefix STABLES LIKE ids */ + 189, /* (27) cmd ::= SHOW dbPrefix VGROUPS */ + 189, /* (28) cmd ::= SHOW dbPrefix VGROUPS ids */ + 189, /* (29) cmd ::= DROP TABLE ifexists ids cpxName */ + 189, /* (30) cmd ::= DROP STABLE ifexists ids cpxName */ + 189, /* (31) cmd ::= DROP DATABASE ifexists ids */ + 189, /* (32) cmd ::= DROP TOPIC ifexists ids */ + 189, /* (33) cmd ::= DROP DNODE ids */ + 189, /* (34) cmd ::= DROP USER ids */ + 189, /* (35) cmd ::= DROP ACCOUNT ids */ + 189, /* (36) cmd ::= USE ids */ + 189, /* (37) cmd ::= DESCRIBE ids cpxName */ + 189, /* (38) cmd ::= ALTER USER ids PASS ids */ + 189, /* (39) cmd ::= ALTER USER ids PRIVILEGE ids */ + 189, /* (40) cmd ::= ALTER DNODE ids ids */ + 189, /* (41) cmd ::= ALTER DNODE ids ids ids */ + 189, /* (42) cmd ::= ALTER LOCAL ids */ + 189, /* (43) cmd ::= ALTER LOCAL ids ids */ + 189, /* (44) cmd ::= ALTER DATABASE ids alter_db_optr */ + 189, /* (45) cmd ::= ALTER TOPIC ids alter_topic_optr */ + 189, /* (46) cmd ::= ALTER ACCOUNT ids acct_optr */ + 189, /* (47) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */ + 191, /* (48) ids ::= ID */ + 191, /* (49) ids ::= STRING */ + 193, /* (50) ifexists ::= IF EXISTS */ + 193, /* (51) ifexists ::= */ + 197, /* (52) ifnotexists ::= IF NOT EXISTS */ + 197, /* (53) ifnotexists ::= */ + 189, /* (54) cmd ::= CREATE DNODE ids */ + 189, /* (55) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */ + 189, /* (56) cmd ::= CREATE DATABASE ifnotexists ids db_optr */ + 189, /* (57) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ + 189, /* (58) cmd ::= CREATE USER ids PASS ids */ + 200, /* (59) pps ::= */ + 200, /* (60) pps ::= PPS INTEGER */ + 201, /* (61) tseries ::= */ + 201, /* (62) tseries ::= TSERIES INTEGER */ + 202, /* (63) dbs ::= */ + 202, /* (64) dbs ::= DBS INTEGER */ + 203, /* (65) streams ::= */ + 203, /* (66) streams ::= STREAMS INTEGER */ + 204, /* (67) storage ::= */ + 204, /* (68) storage ::= STORAGE INTEGER */ + 205, /* (69) qtime ::= */ + 205, /* (70) qtime ::= QTIME INTEGER */ + 206, /* (71) users ::= */ + 206, /* (72) users ::= USERS INTEGER */ + 207, /* (73) conns ::= */ + 207, /* (74) conns ::= CONNS INTEGER */ + 208, /* (75) state ::= */ + 208, /* (76) state ::= STATE ids */ + 196, /* (77) acct_optr ::= pps tseries storage streams qtime dbs users conns state */ + 209, /* (78) keep ::= KEEP tagitemlist */ + 211, /* (79) cache ::= CACHE INTEGER */ + 212, /* (80) replica ::= REPLICA INTEGER */ + 213, /* (81) quorum ::= QUORUM INTEGER */ + 214, /* (82) days ::= DAYS INTEGER */ + 215, /* (83) minrows ::= MINROWS INTEGER */ + 216, /* (84) maxrows ::= MAXROWS INTEGER */ + 217, /* (85) blocks ::= BLOCKS INTEGER */ + 218, /* (86) ctime ::= CTIME INTEGER */ + 219, /* (87) wal ::= WAL INTEGER */ + 220, /* (88) fsync ::= FSYNC INTEGER */ + 221, /* (89) comp ::= COMP INTEGER */ + 222, /* (90) prec ::= PRECISION STRING */ + 223, /* (91) update ::= UPDATE INTEGER */ + 224, /* (92) cachelast ::= CACHELAST INTEGER */ + 225, /* (93) partitions ::= PARTITIONS INTEGER */ + 198, /* (94) db_optr ::= */ + 198, /* (95) db_optr ::= db_optr cache */ + 198, /* (96) db_optr ::= db_optr replica */ + 198, /* (97) db_optr ::= db_optr quorum */ + 198, /* (98) db_optr ::= db_optr days */ + 198, /* (99) db_optr ::= db_optr minrows */ + 198, /* (100) db_optr ::= db_optr maxrows */ + 198, /* (101) db_optr ::= db_optr blocks */ + 198, /* (102) db_optr ::= db_optr ctime */ + 198, /* (103) db_optr ::= db_optr wal */ + 198, /* (104) db_optr ::= db_optr fsync */ + 198, /* (105) db_optr ::= db_optr comp */ + 198, /* (106) db_optr ::= db_optr prec */ + 198, /* (107) db_optr ::= db_optr keep */ + 198, /* (108) db_optr ::= db_optr update */ + 198, /* (109) db_optr ::= db_optr cachelast */ + 199, /* (110) topic_optr ::= db_optr */ + 199, /* (111) topic_optr ::= topic_optr partitions */ + 194, /* (112) alter_db_optr ::= */ + 194, /* (113) alter_db_optr ::= alter_db_optr replica */ + 194, /* (114) alter_db_optr ::= alter_db_optr quorum */ + 194, /* (115) alter_db_optr ::= alter_db_optr keep */ + 194, /* (116) alter_db_optr ::= alter_db_optr blocks */ + 194, /* (117) alter_db_optr ::= alter_db_optr comp */ + 194, /* (118) alter_db_optr ::= alter_db_optr wal */ + 194, /* (119) alter_db_optr ::= alter_db_optr fsync */ + 194, /* (120) alter_db_optr ::= alter_db_optr update */ + 194, /* (121) alter_db_optr ::= alter_db_optr cachelast */ + 195, /* (122) alter_topic_optr ::= alter_db_optr */ + 195, /* (123) alter_topic_optr ::= alter_topic_optr partitions */ + 226, /* (124) typename ::= ids */ + 226, /* (125) typename ::= ids LP signed RP */ + 226, /* (126) typename ::= ids UNSIGNED */ + 227, /* (127) signed ::= INTEGER */ + 227, /* (128) signed ::= PLUS INTEGER */ + 227, /* (129) signed ::= MINUS INTEGER */ + 189, /* (130) cmd ::= CREATE TABLE create_table_args */ + 189, /* (131) cmd ::= CREATE TABLE create_stable_args */ + 189, /* (132) cmd ::= CREATE STABLE create_stable_args */ + 189, /* (133) cmd ::= CREATE TABLE create_table_list */ + 230, /* (134) create_table_list ::= create_from_stable */ + 230, /* (135) create_table_list ::= create_table_list create_from_stable */ + 228, /* (136) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */ + 229, /* (137) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */ + 231, /* (138) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */ + 231, /* (139) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */ + 233, /* (140) tagNamelist ::= tagNamelist COMMA ids */ + 233, /* (141) tagNamelist ::= ids */ + 228, /* (142) create_table_args ::= ifnotexists ids cpxName AS select */ + 232, /* (143) columnlist ::= columnlist COMMA column */ + 232, /* (144) columnlist ::= column */ + 235, /* (145) column ::= ids typename */ + 210, /* (146) tagitemlist ::= tagitemlist COMMA tagitem */ + 210, /* (147) tagitemlist ::= tagitem */ + 236, /* (148) tagitem ::= INTEGER */ + 236, /* (149) tagitem ::= FLOAT */ + 236, /* (150) tagitem ::= STRING */ + 236, /* (151) tagitem ::= BOOL */ + 236, /* (152) tagitem ::= NULL */ + 236, /* (153) tagitem ::= MINUS INTEGER */ + 236, /* (154) tagitem ::= MINUS FLOAT */ + 236, /* (155) tagitem ::= PLUS INTEGER */ + 236, /* (156) tagitem ::= PLUS FLOAT */ + 234, /* (157) select ::= SELECT selcollist from where_opt interval_opt session_option fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */ + 234, /* (158) select ::= LP select RP */ + 249, /* (159) union ::= select */ + 249, /* (160) union ::= union UNION ALL select */ + 189, /* (161) cmd ::= union */ + 234, /* (162) select ::= SELECT selcollist */ + 250, /* (163) sclp ::= selcollist COMMA */ + 250, /* (164) sclp ::= */ + 237, /* (165) selcollist ::= sclp distinct expr as */ + 237, /* (166) selcollist ::= sclp STAR */ + 253, /* (167) as ::= AS ids */ + 253, /* (168) as ::= ids */ + 253, /* (169) as ::= */ + 251, /* (170) distinct ::= DISTINCT */ + 251, /* (171) distinct ::= */ + 238, /* (172) from ::= FROM tablelist */ + 238, /* (173) from ::= FROM LP union RP */ + 254, /* (174) tablelist ::= ids cpxName */ + 254, /* (175) tablelist ::= ids cpxName ids */ + 254, /* (176) tablelist ::= tablelist COMMA ids cpxName */ + 254, /* (177) tablelist ::= tablelist COMMA ids cpxName ids */ + 255, /* (178) tmvar ::= VARIABLE */ + 240, /* (179) interval_opt ::= INTERVAL LP tmvar RP */ + 240, /* (180) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */ + 240, /* (181) interval_opt ::= */ + 241, /* (182) session_option ::= */ + 241, /* (183) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */ + 242, /* (184) fill_opt ::= */ + 242, /* (185) fill_opt ::= FILL LP ID COMMA tagitemlist RP */ + 242, /* (186) fill_opt ::= FILL LP ID RP */ + 243, /* (187) sliding_opt ::= SLIDING LP tmvar RP */ + 243, /* (188) sliding_opt ::= */ + 245, /* (189) orderby_opt ::= */ + 245, /* (190) orderby_opt ::= ORDER BY sortlist */ + 256, /* (191) sortlist ::= sortlist COMMA item sortorder */ + 256, /* (192) sortlist ::= item sortorder */ + 258, /* (193) item ::= ids cpxName */ + 259, /* (194) sortorder ::= ASC */ + 259, /* (195) sortorder ::= DESC */ + 259, /* (196) sortorder ::= */ + 244, /* (197) groupby_opt ::= */ + 244, /* (198) groupby_opt ::= GROUP BY grouplist */ + 260, /* (199) grouplist ::= grouplist COMMA item */ + 260, /* (200) grouplist ::= item */ + 246, /* (201) having_opt ::= */ + 246, /* (202) having_opt ::= HAVING expr */ + 248, /* (203) limit_opt ::= */ + 248, /* (204) limit_opt ::= LIMIT signed */ + 248, /* (205) limit_opt ::= LIMIT signed OFFSET signed */ + 248, /* (206) limit_opt ::= LIMIT signed COMMA signed */ + 247, /* (207) slimit_opt ::= */ + 247, /* (208) slimit_opt ::= SLIMIT signed */ + 247, /* (209) slimit_opt ::= SLIMIT signed SOFFSET signed */ + 247, /* (210) slimit_opt ::= SLIMIT signed COMMA signed */ + 239, /* (211) where_opt ::= */ + 239, /* (212) where_opt ::= WHERE expr */ + 252, /* (213) expr ::= LP expr RP */ + 252, /* (214) expr ::= ID */ + 252, /* (215) expr ::= ID DOT ID */ + 252, /* (216) expr ::= ID DOT STAR */ + 252, /* (217) expr ::= INTEGER */ + 252, /* (218) expr ::= MINUS INTEGER */ + 252, /* (219) expr ::= PLUS INTEGER */ + 252, /* (220) expr ::= FLOAT */ + 252, /* (221) expr ::= MINUS FLOAT */ + 252, /* (222) expr ::= PLUS FLOAT */ + 252, /* (223) expr ::= STRING */ + 252, /* (224) expr ::= NOW */ + 252, /* (225) expr ::= VARIABLE */ + 252, /* (226) expr ::= PLUS VARIABLE */ + 252, /* (227) expr ::= MINUS VARIABLE */ + 252, /* (228) expr ::= BOOL */ + 252, /* (229) expr ::= NULL */ + 252, /* (230) expr ::= ID LP exprlist RP */ + 252, /* (231) expr ::= ID LP STAR RP */ + 252, /* (232) expr ::= expr IS NULL */ + 252, /* (233) expr ::= expr IS NOT NULL */ + 252, /* (234) expr ::= expr LT expr */ + 252, /* (235) expr ::= expr GT expr */ + 252, /* (236) expr ::= expr LE expr */ + 252, /* (237) expr ::= expr GE expr */ + 252, /* (238) expr ::= expr NE expr */ + 252, /* (239) expr ::= expr EQ expr */ + 252, /* (240) expr ::= expr BETWEEN expr AND expr */ + 252, /* (241) expr ::= expr AND expr */ + 252, /* (242) expr ::= expr OR expr */ + 252, /* (243) expr ::= expr PLUS expr */ + 252, /* (244) expr ::= expr MINUS expr */ + 252, /* (245) expr ::= expr STAR expr */ + 252, /* (246) expr ::= expr SLASH expr */ + 252, /* (247) expr ::= expr REM expr */ + 252, /* (248) expr ::= expr LIKE expr */ + 252, /* (249) expr ::= expr IN LP exprlist RP */ + 261, /* (250) exprlist ::= exprlist COMMA expritem */ + 261, /* (251) exprlist ::= expritem */ + 262, /* (252) expritem ::= expr */ + 262, /* (253) expritem ::= */ + 189, /* (254) cmd ::= RESET QUERY CACHE */ + 189, /* (255) cmd ::= SYNCDB ids REPLICA */ + 189, /* (256) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */ + 189, /* (257) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */ + 189, /* (258) cmd ::= ALTER TABLE ids cpxName ALTER COLUMN LENGTH ids INTEGER */ + 189, /* (259) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ + 189, /* (260) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ + 189, /* (261) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ + 189, /* (262) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ + 189, /* (263) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ + 189, /* (264) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ + 189, /* (265) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ + 189, /* (266) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ + 189, /* (267) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ + 189, /* (268) cmd ::= KILL CONNECTION INTEGER */ + 189, /* (269) cmd ::= KILL STREAM INTEGER COLON INTEGER */ + 189, /* (270) cmd ::= KILL QUERY INTEGER COLON INTEGER */ +}; + +/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number +** of symbols on the right-hand side of that rule. */ +static const signed char yyRuleInfoNRhs[] = { + -1, /* (0) program ::= cmd */ + -2, /* (1) cmd ::= SHOW DATABASES */ + -2, /* (2) cmd ::= SHOW TOPICS */ + -2, /* (3) cmd ::= SHOW MNODES */ + -2, /* (4) cmd ::= SHOW DNODES */ + -2, /* (5) cmd ::= SHOW ACCOUNTS */ + -2, /* (6) cmd ::= SHOW USERS */ + -2, /* (7) cmd ::= SHOW MODULES */ + -2, /* (8) cmd ::= SHOW QUERIES */ + -2, /* (9) cmd ::= SHOW CONNECTIONS */ + -2, /* (10) cmd ::= SHOW STREAMS */ + -2, /* (11) cmd ::= SHOW VARIABLES */ + -2, /* (12) cmd ::= SHOW SCORES */ + -2, /* (13) cmd ::= SHOW GRANTS */ + -2, /* (14) cmd ::= SHOW VNODES */ + -3, /* (15) cmd ::= SHOW VNODES IPTOKEN */ + 0, /* (16) dbPrefix ::= */ + -2, /* (17) dbPrefix ::= ids DOT */ + 0, /* (18) cpxName ::= */ + -2, /* (19) cpxName ::= DOT ids */ + -5, /* (20) cmd ::= SHOW CREATE TABLE ids cpxName */ + -5, /* (21) cmd ::= SHOW CREATE STABLE ids cpxName */ + -4, /* (22) cmd ::= SHOW CREATE DATABASE ids */ + -3, /* (23) cmd ::= SHOW dbPrefix TABLES */ + -5, /* (24) cmd ::= SHOW dbPrefix TABLES LIKE ids */ + -3, /* (25) cmd ::= SHOW dbPrefix STABLES */ + -5, /* (26) cmd ::= SHOW dbPrefix STABLES LIKE ids */ + -3, /* (27) cmd ::= SHOW dbPrefix VGROUPS */ + -4, /* (28) cmd ::= SHOW dbPrefix VGROUPS ids */ + -5, /* (29) cmd ::= DROP TABLE ifexists ids cpxName */ + -5, /* (30) cmd ::= DROP STABLE ifexists ids cpxName */ + -4, /* (31) cmd ::= DROP DATABASE ifexists ids */ + -4, /* (32) cmd ::= DROP TOPIC ifexists ids */ + -3, /* (33) cmd ::= DROP DNODE ids */ + -3, /* (34) cmd ::= DROP USER ids */ + -3, /* (35) cmd ::= DROP ACCOUNT ids */ + -2, /* (36) cmd ::= USE ids */ + -3, /* (37) cmd ::= DESCRIBE ids cpxName */ + -5, /* (38) cmd ::= ALTER USER ids PASS ids */ + -5, /* (39) cmd ::= ALTER USER ids PRIVILEGE ids */ + -4, /* (40) cmd ::= ALTER DNODE ids ids */ + -5, /* (41) cmd ::= ALTER DNODE ids ids ids */ + -3, /* (42) cmd ::= ALTER LOCAL ids */ + -4, /* (43) cmd ::= ALTER LOCAL ids ids */ + -4, /* (44) cmd ::= ALTER DATABASE ids alter_db_optr */ + -4, /* (45) cmd ::= ALTER TOPIC ids alter_topic_optr */ + -4, /* (46) cmd ::= ALTER ACCOUNT ids acct_optr */ + -6, /* (47) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */ + -1, /* (48) ids ::= ID */ + -1, /* (49) ids ::= STRING */ + -2, /* (50) ifexists ::= IF EXISTS */ + 0, /* (51) ifexists ::= */ + -3, /* (52) ifnotexists ::= IF NOT EXISTS */ + 0, /* (53) ifnotexists ::= */ + -3, /* (54) cmd ::= CREATE DNODE ids */ + -6, /* (55) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */ + -5, /* (56) cmd ::= CREATE DATABASE ifnotexists ids db_optr */ + -5, /* (57) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ + -5, /* (58) cmd ::= CREATE USER ids PASS ids */ + 0, /* (59) pps ::= */ + -2, /* (60) pps ::= PPS INTEGER */ + 0, /* (61) tseries ::= */ + -2, /* (62) tseries ::= TSERIES INTEGER */ + 0, /* (63) dbs ::= */ + -2, /* (64) dbs ::= DBS INTEGER */ + 0, /* (65) streams ::= */ + -2, /* (66) streams ::= STREAMS INTEGER */ + 0, /* (67) storage ::= */ + -2, /* (68) storage ::= STORAGE INTEGER */ + 0, /* (69) qtime ::= */ + -2, /* (70) qtime ::= QTIME INTEGER */ + 0, /* (71) users ::= */ + -2, /* (72) users ::= USERS INTEGER */ + 0, /* (73) conns ::= */ + -2, /* (74) conns ::= CONNS INTEGER */ + 0, /* (75) state ::= */ + -2, /* (76) state ::= STATE ids */ + -9, /* (77) acct_optr ::= pps tseries storage streams qtime dbs users conns state */ + -2, /* (78) keep ::= KEEP tagitemlist */ + -2, /* (79) cache ::= CACHE INTEGER */ + -2, /* (80) replica ::= REPLICA INTEGER */ + -2, /* (81) quorum ::= QUORUM INTEGER */ + -2, /* (82) days ::= DAYS INTEGER */ + -2, /* (83) minrows ::= MINROWS INTEGER */ + -2, /* (84) maxrows ::= MAXROWS INTEGER */ + -2, /* (85) blocks ::= BLOCKS INTEGER */ + -2, /* (86) ctime ::= CTIME INTEGER */ + -2, /* (87) wal ::= WAL INTEGER */ + -2, /* (88) fsync ::= FSYNC INTEGER */ + -2, /* (89) comp ::= COMP INTEGER */ + -2, /* (90) prec ::= PRECISION STRING */ + -2, /* (91) update ::= UPDATE INTEGER */ + -2, /* (92) cachelast ::= CACHELAST INTEGER */ + -2, /* (93) partitions ::= PARTITIONS INTEGER */ + 0, /* (94) db_optr ::= */ + -2, /* (95) db_optr ::= db_optr cache */ + -2, /* (96) db_optr ::= db_optr replica */ + -2, /* (97) db_optr ::= db_optr quorum */ + -2, /* (98) db_optr ::= db_optr days */ + -2, /* (99) db_optr ::= db_optr minrows */ + -2, /* (100) db_optr ::= db_optr maxrows */ + -2, /* (101) db_optr ::= db_optr blocks */ + -2, /* (102) db_optr ::= db_optr ctime */ + -2, /* (103) db_optr ::= db_optr wal */ + -2, /* (104) db_optr ::= db_optr fsync */ + -2, /* (105) db_optr ::= db_optr comp */ + -2, /* (106) db_optr ::= db_optr prec */ + -2, /* (107) db_optr ::= db_optr keep */ + -2, /* (108) db_optr ::= db_optr update */ + -2, /* (109) db_optr ::= db_optr cachelast */ + -1, /* (110) topic_optr ::= db_optr */ + -2, /* (111) topic_optr ::= topic_optr partitions */ + 0, /* (112) alter_db_optr ::= */ + -2, /* (113) alter_db_optr ::= alter_db_optr replica */ + -2, /* (114) alter_db_optr ::= alter_db_optr quorum */ + -2, /* (115) alter_db_optr ::= alter_db_optr keep */ + -2, /* (116) alter_db_optr ::= alter_db_optr blocks */ + -2, /* (117) alter_db_optr ::= alter_db_optr comp */ + -2, /* (118) alter_db_optr ::= alter_db_optr wal */ + -2, /* (119) alter_db_optr ::= alter_db_optr fsync */ + -2, /* (120) alter_db_optr ::= alter_db_optr update */ + -2, /* (121) alter_db_optr ::= alter_db_optr cachelast */ + -1, /* (122) alter_topic_optr ::= alter_db_optr */ + -2, /* (123) alter_topic_optr ::= alter_topic_optr partitions */ + -1, /* (124) typename ::= ids */ + -4, /* (125) typename ::= ids LP signed RP */ + -2, /* (126) typename ::= ids UNSIGNED */ + -1, /* (127) signed ::= INTEGER */ + -2, /* (128) signed ::= PLUS INTEGER */ + -2, /* (129) signed ::= MINUS INTEGER */ + -3, /* (130) cmd ::= CREATE TABLE create_table_args */ + -3, /* (131) cmd ::= CREATE TABLE create_stable_args */ + -3, /* (132) cmd ::= CREATE STABLE create_stable_args */ + -3, /* (133) cmd ::= CREATE TABLE create_table_list */ + -1, /* (134) create_table_list ::= create_from_stable */ + -2, /* (135) create_table_list ::= create_table_list create_from_stable */ + -6, /* (136) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */ + -10, /* (137) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */ + -10, /* (138) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */ + -13, /* (139) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */ + -3, /* (140) tagNamelist ::= tagNamelist COMMA ids */ + -1, /* (141) tagNamelist ::= ids */ + -5, /* (142) create_table_args ::= ifnotexists ids cpxName AS select */ + -3, /* (143) columnlist ::= columnlist COMMA column */ + -1, /* (144) columnlist ::= column */ + -2, /* (145) column ::= ids typename */ + -3, /* (146) tagitemlist ::= tagitemlist COMMA tagitem */ + -1, /* (147) tagitemlist ::= tagitem */ + -1, /* (148) tagitem ::= INTEGER */ + -1, /* (149) tagitem ::= FLOAT */ + -1, /* (150) tagitem ::= STRING */ + -1, /* (151) tagitem ::= BOOL */ + -1, /* (152) tagitem ::= NULL */ + -2, /* (153) tagitem ::= MINUS INTEGER */ + -2, /* (154) tagitem ::= MINUS FLOAT */ + -2, /* (155) tagitem ::= PLUS INTEGER */ + -2, /* (156) tagitem ::= PLUS FLOAT */ + -13, /* (157) select ::= SELECT selcollist from where_opt interval_opt session_option fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */ + -3, /* (158) select ::= LP select RP */ + -1, /* (159) union ::= select */ + -4, /* (160) union ::= union UNION ALL select */ + -1, /* (161) cmd ::= union */ + -2, /* (162) select ::= SELECT selcollist */ + -2, /* (163) sclp ::= selcollist COMMA */ + 0, /* (164) sclp ::= */ + -4, /* (165) selcollist ::= sclp distinct expr as */ + -2, /* (166) selcollist ::= sclp STAR */ + -2, /* (167) as ::= AS ids */ + -1, /* (168) as ::= ids */ + 0, /* (169) as ::= */ + -1, /* (170) distinct ::= DISTINCT */ + 0, /* (171) distinct ::= */ + -2, /* (172) from ::= FROM tablelist */ + -4, /* (173) from ::= FROM LP union RP */ + -2, /* (174) tablelist ::= ids cpxName */ + -3, /* (175) tablelist ::= ids cpxName ids */ + -4, /* (176) tablelist ::= tablelist COMMA ids cpxName */ + -5, /* (177) tablelist ::= tablelist COMMA ids cpxName ids */ + -1, /* (178) tmvar ::= VARIABLE */ + -4, /* (179) interval_opt ::= INTERVAL LP tmvar RP */ + -6, /* (180) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */ + 0, /* (181) interval_opt ::= */ + 0, /* (182) session_option ::= */ + -7, /* (183) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */ + 0, /* (184) fill_opt ::= */ + -6, /* (185) fill_opt ::= FILL LP ID COMMA tagitemlist RP */ + -4, /* (186) fill_opt ::= FILL LP ID RP */ + -4, /* (187) sliding_opt ::= SLIDING LP tmvar RP */ + 0, /* (188) sliding_opt ::= */ + 0, /* (189) orderby_opt ::= */ + -3, /* (190) orderby_opt ::= ORDER BY sortlist */ + -4, /* (191) sortlist ::= sortlist COMMA item sortorder */ + -2, /* (192) sortlist ::= item sortorder */ + -2, /* (193) item ::= ids cpxName */ + -1, /* (194) sortorder ::= ASC */ + -1, /* (195) sortorder ::= DESC */ + 0, /* (196) sortorder ::= */ + 0, /* (197) groupby_opt ::= */ + -3, /* (198) groupby_opt ::= GROUP BY grouplist */ + -3, /* (199) grouplist ::= grouplist COMMA item */ + -1, /* (200) grouplist ::= item */ + 0, /* (201) having_opt ::= */ + -2, /* (202) having_opt ::= HAVING expr */ + 0, /* (203) limit_opt ::= */ + -2, /* (204) limit_opt ::= LIMIT signed */ + -4, /* (205) limit_opt ::= LIMIT signed OFFSET signed */ + -4, /* (206) limit_opt ::= LIMIT signed COMMA signed */ + 0, /* (207) slimit_opt ::= */ + -2, /* (208) slimit_opt ::= SLIMIT signed */ + -4, /* (209) slimit_opt ::= SLIMIT signed SOFFSET signed */ + -4, /* (210) slimit_opt ::= SLIMIT signed COMMA signed */ + 0, /* (211) where_opt ::= */ + -2, /* (212) where_opt ::= WHERE expr */ + -3, /* (213) expr ::= LP expr RP */ + -1, /* (214) expr ::= ID */ + -3, /* (215) expr ::= ID DOT ID */ + -3, /* (216) expr ::= ID DOT STAR */ + -1, /* (217) expr ::= INTEGER */ + -2, /* (218) expr ::= MINUS INTEGER */ + -2, /* (219) expr ::= PLUS INTEGER */ + -1, /* (220) expr ::= FLOAT */ + -2, /* (221) expr ::= MINUS FLOAT */ + -2, /* (222) expr ::= PLUS FLOAT */ + -1, /* (223) expr ::= STRING */ + -1, /* (224) expr ::= NOW */ + -1, /* (225) expr ::= VARIABLE */ + -2, /* (226) expr ::= PLUS VARIABLE */ + -2, /* (227) expr ::= MINUS VARIABLE */ + -1, /* (228) expr ::= BOOL */ + -1, /* (229) expr ::= NULL */ + -4, /* (230) expr ::= ID LP exprlist RP */ + -4, /* (231) expr ::= ID LP STAR RP */ + -3, /* (232) expr ::= expr IS NULL */ + -4, /* (233) expr ::= expr IS NOT NULL */ + -3, /* (234) expr ::= expr LT expr */ + -3, /* (235) expr ::= expr GT expr */ + -3, /* (236) expr ::= expr LE expr */ + -3, /* (237) expr ::= expr GE expr */ + -3, /* (238) expr ::= expr NE expr */ + -3, /* (239) expr ::= expr EQ expr */ + -5, /* (240) expr ::= expr BETWEEN expr AND expr */ + -3, /* (241) expr ::= expr AND expr */ + -3, /* (242) expr ::= expr OR expr */ + -3, /* (243) expr ::= expr PLUS expr */ + -3, /* (244) expr ::= expr MINUS expr */ + -3, /* (245) expr ::= expr STAR expr */ + -3, /* (246) expr ::= expr SLASH expr */ + -3, /* (247) expr ::= expr REM expr */ + -3, /* (248) expr ::= expr LIKE expr */ + -5, /* (249) expr ::= expr IN LP exprlist RP */ + -3, /* (250) exprlist ::= exprlist COMMA expritem */ + -1, /* (251) exprlist ::= expritem */ + -1, /* (252) expritem ::= expr */ + 0, /* (253) expritem ::= */ + -3, /* (254) cmd ::= RESET QUERY CACHE */ + -3, /* (255) cmd ::= SYNCDB ids REPLICA */ + -7, /* (256) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */ + -7, /* (257) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */ + -9, /* (258) cmd ::= ALTER TABLE ids cpxName ALTER COLUMN LENGTH ids INTEGER */ + -7, /* (259) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ + -7, /* (260) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ + -8, /* (261) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ + -9, /* (262) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ + -7, /* (263) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ + -7, /* (264) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ + -7, /* (265) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ + -7, /* (266) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ + -8, /* (267) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ + -3, /* (268) cmd ::= KILL CONNECTION INTEGER */ + -5, /* (269) cmd ::= KILL STREAM INTEGER COLON INTEGER */ + -5, /* (270) cmd ::= KILL QUERY INTEGER COLON INTEGER */ }; static void yy_accept(yyParser*); /* Forward Declaration */ @@ -2039,30 +2333,34 @@ static void yy_accept(yyParser*); /* Forward Declaration */ ** only called from one place, optimizing compilers will in-line it, which ** means that the extra parameters have no performance impact. */ -static void yy_reduce( +static YYACTIONTYPE yy_reduce( yyParser *yypParser, /* The parser */ unsigned int yyruleno, /* Number of the rule by which to reduce */ int yyLookahead, /* Lookahead token, or YYNOCODE if none */ ParseTOKENTYPE yyLookaheadToken /* Value of the lookahead token */ + ParseCTX_PDECL /* %extra_context */ ){ int yygoto; /* The next state */ - int yyact; /* The next action */ + YYACTIONTYPE yyact; /* The next action */ yyStackEntry *yymsp; /* The top of the parser's stack */ int yysize; /* Amount to pop the stack */ - ParseARG_FETCH; + ParseARG_FETCH (void)yyLookahead; (void)yyLookaheadToken; yymsp = yypParser->yytos; #ifndef NDEBUG if( yyTraceFILE && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){ - yysize = yyRuleInfo[yyruleno].nrhs; + yysize = yyRuleInfoNRhs[yyruleno]; if( yysize ){ - fprintf(yyTraceFILE, "%sReduce %d [%s], go to state %d.\n", + fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n", yyTracePrompt, - yyruleno, yyRuleName[yyruleno], yymsp[yysize].stateno); + yyruleno, yyRuleName[yyruleno], + yyrulenoyytos - yypParser->yystack)>yypParser->yyhwm ){ yypParser->yyhwm++; @@ -2080,13 +2378,19 @@ static void yy_reduce( #if YYSTACKDEPTH>0 if( yypParser->yytos>=yypParser->yystackEnd ){ yyStackOverflow(yypParser); - return; + /* The call to yyStackOverflow() above pops the stack until it is + ** empty, causing the main parser loop to exit. So the return value + ** is never used and does not matter. */ + return 0; } #else if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){ if( yyGrowStack(yypParser) ){ yyStackOverflow(yypParser); - return; + /* The call to yyStackOverflow() above pops the stack until it is + ** empty, causing the main parser loop to exit. So the return value + ** is never used and does not matter. */ + return 0; } yymsp = yypParser->yytos; } @@ -3010,14 +3314,27 @@ static void yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 258: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ + case 258: /* cmd ::= ALTER TABLE ids cpxName ALTER COLUMN LENGTH ids INTEGER */ +{ + yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n; + + toTSDBType(yymsp[-1].minor.yy0.type); + SArray* K = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1); + toTSDBType(yymsp[0].minor.yy0.type); + K = tVariantListAppendToken(K, &yymsp[0].minor.yy0, -1); + + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, K, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1); + setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); +} + break; + case 259: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy159, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 259: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ + case 260: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; @@ -3028,7 +3345,7 @@ static void yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 260: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ + case 261: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ { yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n; @@ -3042,7 +3359,7 @@ static void yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 261: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ + case 262: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ { yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n; @@ -3054,14 +3371,14 @@ static void yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 262: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ + case 263: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy159, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 263: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ + case 264: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; @@ -3072,14 +3389,14 @@ static void yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 264: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ + case 265: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy159, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 265: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ + case 266: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; @@ -3090,7 +3407,7 @@ static void yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 266: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ + case 267: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ { yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n; @@ -3104,22 +3421,22 @@ static void yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 267: /* cmd ::= KILL CONNECTION INTEGER */ + case 268: /* cmd ::= KILL CONNECTION INTEGER */ {setKillSql(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);} break; - case 268: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */ + case 269: /* 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 269: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */ + case 270: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */ {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_QUERY, &yymsp[-2].minor.yy0);} break; default: break; /********** End reduce actions ************************************************/ }; - assert( yyrulenostateno = (YYACTIONTYPE)yyact; yymsp->major = (YYCODETYPE)yygoto; yyTraceShift(yypParser, yyact, "... then shift"); + return yyact; } /* @@ -3143,7 +3461,8 @@ static void yy_reduce( static void yy_parse_failed( yyParser *yypParser /* The parser */ ){ - ParseARG_FETCH; + ParseARG_FETCH + ParseCTX_FETCH #ifndef NDEBUG if( yyTraceFILE ){ fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt); @@ -3154,7 +3473,8 @@ static void yy_parse_failed( ** parser fails */ /************ Begin %parse_failure code ***************************************/ /************ End %parse_failure code *****************************************/ - ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ + ParseARG_STORE /* Suppress warning about unused %extra_argument variable */ + ParseCTX_STORE } #endif /* YYNOERRORRECOVERY */ @@ -3166,7 +3486,8 @@ static void yy_syntax_error( int yymajor, /* The major type of the error token */ ParseTOKENTYPE yyminor /* The minor type of the error token */ ){ - ParseARG_FETCH; + ParseARG_FETCH + ParseCTX_FETCH #define TOKEN yyminor /************ Begin %syntax_error code ****************************************/ @@ -3192,7 +3513,8 @@ static void yy_syntax_error( assert(len <= outputBufLen); /************ End %syntax_error code ******************************************/ - ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ + ParseARG_STORE /* Suppress warning about unused %extra_argument variable */ + ParseCTX_STORE } /* @@ -3201,7 +3523,8 @@ static void yy_syntax_error( static void yy_accept( yyParser *yypParser /* The parser */ ){ - ParseARG_FETCH; + ParseARG_FETCH + ParseCTX_FETCH #ifndef NDEBUG if( yyTraceFILE ){ fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt); @@ -3216,7 +3539,8 @@ static void yy_accept( /*********** Begin %parse_accept code *****************************************/ /*********** End %parse_accept code *******************************************/ - ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ + ParseARG_STORE /* Suppress warning about unused %extra_argument variable */ + ParseCTX_STORE } /* The main parser program. @@ -3245,45 +3569,47 @@ void Parse( ParseARG_PDECL /* Optional %extra_argument parameter */ ){ YYMINORTYPE yyminorunion; - unsigned int yyact; /* The parser action. */ + YYACTIONTYPE yyact; /* The parser action. */ #if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY) int yyendofinput; /* True if we are at the end of input */ #endif #ifdef YYERRORSYMBOL int yyerrorhit = 0; /* True if yymajor has invoked an error */ #endif - yyParser *yypParser; /* The parser */ + yyParser *yypParser = (yyParser*)yyp; /* The parser */ + ParseCTX_FETCH + ParseARG_STORE - yypParser = (yyParser*)yyp; assert( yypParser->yytos!=0 ); #if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY) yyendofinput = (yymajor==0); #endif - ParseARG_STORE; + yyact = yypParser->yytos->stateno; #ifndef NDEBUG if( yyTraceFILE ){ - int stateno = yypParser->yytos->stateno; - if( stateno < YY_MIN_REDUCE ){ + if( yyact < YY_MIN_REDUCE ){ fprintf(yyTraceFILE,"%sInput '%s' in state %d\n", - yyTracePrompt,yyTokenName[yymajor],stateno); + yyTracePrompt,yyTokenName[yymajor],yyact); }else{ fprintf(yyTraceFILE,"%sInput '%s' with pending reduce %d\n", - yyTracePrompt,yyTokenName[yymajor],stateno-YY_MIN_REDUCE); + yyTracePrompt,yyTokenName[yymajor],yyact-YY_MIN_REDUCE); } } #endif do{ - yyact = yy_find_shift_action(yypParser,(YYCODETYPE)yymajor); + assert( yyact==yypParser->yytos->stateno ); + yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact); if( yyact >= YY_MIN_REDUCE ){ - yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor,yyminor); + yyact = yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor, + yyminor ParseCTX_PARAM); }else if( yyact <= YY_MAX_SHIFTREDUCE ){ - yy_shift(yypParser,yyact,yymajor,yyminor); + yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor); #ifndef YYNOERRORRECOVERY yypParser->yyerrcnt--; #endif - yymajor = YYNOCODE; + break; }else if( yyact==YY_ACCEPT_ACTION ){ yypParser->yytos--; yy_accept(yypParser); @@ -3334,10 +3660,9 @@ void Parse( yymajor = YYNOCODE; }else{ while( yypParser->yytos >= yypParser->yystack - && yymx != YYERRORSYMBOL && (yyact = yy_find_reduce_action( yypParser->yytos->stateno, - YYERRORSYMBOL)) >= YY_MIN_REDUCE + YYERRORSYMBOL)) > YY_MAX_SHIFTREDUCE ){ yy_pop_parser_stack(yypParser); } @@ -3354,6 +3679,8 @@ void Parse( } yypParser->yyerrcnt = 3; yyerrorhit = 1; + if( yymajor==YYNOCODE ) break; + yyact = yypParser->yytos->stateno; #elif defined(YYNOERRORRECOVERY) /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to ** do any kind of error recovery. Instead, simply invoke the syntax @@ -3364,8 +3691,7 @@ void Parse( */ yy_syntax_error(yypParser,yymajor, yyminor); yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); - yymajor = YYNOCODE; - + break; #else /* YYERRORSYMBOL is not defined */ /* This is what we do if the grammar does not define ERROR: ** @@ -3387,10 +3713,10 @@ void Parse( yypParser->yyerrcnt = -1; #endif } - yymajor = YYNOCODE; + break; #endif } - }while( yymajor!=YYNOCODE && yypParser->yytos>yypParser->yystack ); + }while( yypParser->yytos>yypParser->yystack ); #ifndef NDEBUG if( yyTraceFILE ){ yyStackEntry *i; @@ -3405,3 +3731,17 @@ void Parse( #endif return; } + +/* +** Return the fallback token corresponding to canonical token iToken, or +** 0 if iToken has no fallback. +*/ +int ParseFallback(int iToken){ +#ifdef YYFALLBACK + assert( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) ); + return yyFallback[iToken]; +#else + (void)iToken; + return 0; +#endif +} diff --git a/src/util/src/ttokenizer.c b/src/util/src/ttokenizer.c index 93d4570ea8..3d917f2393 100644 --- a/src/util/src/ttokenizer.c +++ b/src/util/src/ttokenizer.c @@ -217,7 +217,8 @@ static SKeyword keywordTable[] = { {"DISTINCT", TK_DISTINCT}, {"PARTITIONS", TK_PARTITIONS}, {"TOPIC", TK_TOPIC}, - {"TOPICS", TK_TOPICS} + {"TOPICS", TK_TOPICS}, + {"LENGTH", TK_LENGTH} }; static const char isIdChar[] = { From ca4289388c76c7737513b8586c395dcfa299d921 Mon Sep 17 00:00:00 2001 From: dapan1121 <89396746@qq.com> Date: Mon, 31 May 2021 09:28:19 +0800 Subject: [PATCH 12/26] add test case --- tests/script/general/parser/alter_column.sim | 43 ++++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 tests/script/general/parser/alter_column.sim diff --git a/tests/script/general/parser/alter_column.sim b/tests/script/general/parser/alter_column.sim new file mode 100644 index 0000000000..47e59d76d2 --- /dev/null +++ b/tests/script/general/parser/alter_column.sim @@ -0,0 +1,43 @@ +system sh/stop_dnodes.sh + +system sh/deploy.sh -n dnode1 -i 1 +system sh/cfg.sh -n dnode1 -c walLevel -v 1 +system sh/exec.sh -n dnode1 -s start +sleep 100 +sql connect + +$dbPrefix = m_alt_db +$tbPrefix = m_alt_tb +$mtPrefix = m_alt_mt +$tbNum = 10 +$rowNum = 5 +$totalNum = $tbNum * $rowNum +$ts0 = 1537146000000 +$delta = 600000 +print ========== alter.sim +$i = 0 +$db = $dbPrefix . $i +$mt = $mtPrefix . $i + +sql drop database if exists $db +sql create database $db +sql use $db +##### alter table test, simeplest case +sql create table tb (ts timestamp, c1 int, c2 binary(10), c3 nchar(10)) +sql insert into tb values (now, 1, "1", "1") +sql alter table tb alter column length c2 20; +if $rows != 0 then + return -1 +endi +sql alter table tb alter column length c3 20; +if $rows != 0 then + return -1 +endi + +##### ILLEGAL OPERATIONS + +# try dropping columns that are defined in metric +sql_error alter table tb alter column length c1 10; + + +system sh/exec.sh -n dnode1 -s stop -x SIGINT From 0bb4e921c8e1e6656438ed5baca22feb92a140f9 Mon Sep 17 00:00:00 2001 From: dapan1121 <89396746@qq.com> Date: Mon, 31 May 2021 11:22:50 +0800 Subject: [PATCH 13/26] support stable --- src/client/src/tscSQLParser.c | 8 +- src/inc/ttokendef.h | 1 + src/query/inc/sql.y | 12 + src/query/src/sql.c | 476 ++++++++++--------- tests/script/general/parser/alter_column.sim | 4 +- 5 files changed, 267 insertions(+), 234 deletions(-) diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c index ae235ebdda..b0ffab1298 100644 --- a/src/client/src/tscSQLParser.c +++ b/src/client/src/tscSQLParser.c @@ -5335,7 +5335,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f); } else if (pAlterSQL->type == TSDB_ALTER_TABLE_CHANGE_COLUMN) { if (taosArrayGetSize(pAlterSQL->pAddColumns) != 2) { - return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), NULL); + return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), NULL); } tVariantListItem* pItem = taosArrayGet(pAlterSQL->pAddColumns, 0); @@ -5343,20 +5343,20 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { SColumnIndex columnIndex = COLUMN_INDEX_INITIALIZER; SStrToken name = {.type = TK_STRING, .z = pItem->pVar.pz, .n = pItem->pVar.nLen}; if (getColumnIndexByName(pCmd, &name, pQueryInfo, &columnIndex) != TSDB_CODE_SUCCESS) { - return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg17); + return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg17); } SSchema* pColSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, columnIndex.columnIndex); if (pColSchema->type != TSDB_DATA_TYPE_BINARY && pColSchema->type != TSDB_DATA_TYPE_NCHAR) { - return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg21); + return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg21); } pItem = taosArrayGet(pAlterSQL->pAddColumns, 1); int64_t nlen = 0; if (tVariantDump(&pItem->pVar, (char *)&nlen, TSDB_DATA_TYPE_BIGINT, false) < 0 || nlen <= 0) { - return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg22); + return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg22); } TAOS_FIELD f = tscCreateField(pColSchema->type, name.z, nlen); diff --git a/src/inc/ttokendef.h b/src/inc/ttokendef.h index 795779a297..e5f1472317 100644 --- a/src/inc/ttokendef.h +++ b/src/inc/ttokendef.h @@ -210,6 +210,7 @@ + #define TK_SPACE 300 #define TK_COMMENT 301 #define TK_ILLEGAL 302 diff --git a/src/query/inc/sql.y b/src/query/inc/sql.y index d1327c43c2..3a6e1c0cc0 100644 --- a/src/query/inc/sql.y +++ b/src/query/inc/sql.y @@ -824,6 +824,18 @@ cmd ::= ALTER STABLE ids(X) cpxName(F) DROP COLUMN ids(A). { setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } +cmd ::= ALTER STABLE ids(X) cpxName(F) ALTER COLUMN LENGTH ids(A) INTEGER(Z). { + X.n += F.n; + + toTSDBType(A.type); + SArray* K = tVariantListAppendToken(NULL, &A, -1); + toTSDBType(Z.type); + K = tVariantListAppendToken(K, &Z, -1); + + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&X, K, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE); + setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); +} + //////////////////////////////////ALTER TAGS statement///////////////////////////////////// cmd ::= ALTER STABLE ids(X) cpxName(Y) ADD TAG columnlist(A). { X.n += Y.n; diff --git a/src/query/src/sql.c b/src/query/src/sql.c index 79b919869d..560e499228 100644 --- a/src/query/src/sql.c +++ b/src/query/src/sql.c @@ -136,18 +136,18 @@ typedef union { #define ParseCTX_FETCH #define ParseCTX_STORE #define YYFALLBACK 1 -#define YYNSTATE 327 -#define YYNRULE 274 -#define YYNRULE_WITH_ACTION 274 +#define YYNSTATE 331 +#define YYNRULE 275 +#define YYNRULE_WITH_ACTION 275 #define YYNTOKEN 188 -#define YY_MAX_SHIFT 326 -#define YY_MIN_SHIFTREDUCE 523 -#define YY_MAX_SHIFTREDUCE 796 -#define YY_ERROR_ACTION 797 -#define YY_ACCEPT_ACTION 798 -#define YY_NO_ACTION 799 -#define YY_MIN_REDUCE 800 -#define YY_MAX_REDUCE 1073 +#define YY_MAX_SHIFT 330 +#define YY_MIN_SHIFTREDUCE 528 +#define YY_MAX_SHIFTREDUCE 802 +#define YY_ERROR_ACTION 803 +#define YY_ACCEPT_ACTION 804 +#define YY_NO_ACTION 805 +#define YY_MIN_REDUCE 806 +#define YY_MAX_REDUCE 1080 /************* End control #defines *******************************************/ #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) @@ -214,78 +214,78 @@ typedef union { ** yy_default[] Default action for each state. ** *********** Begin parsing tables **********************************************/ -#define YY_ACTTAB_COUNT (694) +#define YY_ACTTAB_COUNT (697) static const YYACTIONTYPE yy_action[] = { - /* 0 */ 968, 571, 210, 324, 70, 18, 216, 959, 187, 572, - /* 10 */ 798, 326, 185, 48, 49, 145, 52, 53, 219, 1054, - /* 20 */ 222, 42, 213, 51, 271, 56, 54, 58, 55, 933, - /* 30 */ 650, 187, 947, 47, 46, 187, 932, 45, 44, 43, - /* 40 */ 48, 49, 1053, 52, 53, 218, 1054, 222, 42, 571, - /* 50 */ 51, 271, 56, 54, 58, 55, 959, 572, 300, 299, - /* 60 */ 47, 46, 965, 145, 45, 44, 43, 49, 31, 52, - /* 70 */ 53, 249, 138, 222, 42, 83, 51, 271, 56, 54, - /* 80 */ 58, 55, 287, 1003, 88, 266, 47, 46, 72, 231, - /* 90 */ 45, 44, 43, 524, 525, 526, 527, 528, 529, 530, - /* 100 */ 531, 532, 533, 534, 535, 536, 325, 234, 287, 211, - /* 110 */ 71, 571, 943, 48, 49, 31, 52, 53, 935, 572, - /* 120 */ 222, 42, 571, 51, 271, 56, 54, 58, 55, 268, - /* 130 */ 572, 81, 739, 47, 46, 256, 255, 45, 44, 43, - /* 140 */ 48, 50, 945, 52, 53, 145, 310, 222, 42, 77, - /* 150 */ 51, 271, 56, 54, 58, 55, 212, 37, 232, 944, - /* 160 */ 47, 46, 289, 191, 45, 44, 43, 24, 285, 319, - /* 170 */ 318, 284, 283, 282, 317, 281, 316, 315, 314, 280, - /* 180 */ 313, 312, 907, 31, 895, 896, 897, 898, 899, 900, - /* 190 */ 901, 902, 903, 904, 905, 906, 908, 909, 52, 53, - /* 200 */ 846, 1050, 222, 42, 171, 51, 271, 56, 54, 58, - /* 210 */ 55, 941, 19, 1002, 25, 47, 46, 1049, 959, 45, - /* 220 */ 44, 43, 221, 754, 225, 31, 743, 944, 746, 196, - /* 230 */ 749, 221, 754, 214, 13, 743, 197, 746, 87, 749, - /* 240 */ 84, 122, 121, 195, 45, 44, 43, 109, 56, 54, - /* 250 */ 58, 55, 310, 228, 206, 207, 47, 46, 270, 74, - /* 260 */ 45, 44, 43, 206, 207, 75, 226, 252, 24, 944, - /* 270 */ 319, 318, 77, 252, 745, 317, 748, 316, 315, 314, - /* 280 */ 37, 313, 312, 915, 1048, 674, 913, 914, 671, 204, - /* 290 */ 672, 916, 673, 918, 919, 917, 85, 920, 921, 107, - /* 300 */ 100, 112, 248, 686, 69, 31, 111, 117, 120, 110, - /* 310 */ 8, 203, 5, 34, 161, 114, 236, 237, 689, 160, - /* 320 */ 95, 90, 94, 31, 233, 57, 272, 930, 931, 30, - /* 330 */ 934, 297, 755, 31, 57, 179, 177, 175, 751, 31, - /* 340 */ 145, 755, 174, 125, 124, 123, 290, 751, 220, 944, - /* 350 */ 241, 47, 46, 205, 750, 45, 44, 43, 855, 245, - /* 360 */ 244, 189, 171, 750, 291, 227, 744, 944, 747, 229, - /* 370 */ 323, 322, 130, 320, 298, 847, 99, 944, 98, 171, - /* 380 */ 302, 1, 159, 944, 3, 172, 752, 136, 134, 133, - /* 390 */ 741, 947, 6, 235, 675, 947, 693, 294, 293, 947, - /* 400 */ 720, 721, 250, 705, 65, 711, 32, 140, 82, 61, - /* 410 */ 62, 712, 775, 756, 660, 21, 20, 20, 32, 274, - /* 420 */ 1065, 662, 758, 32, 66, 61, 742, 276, 678, 661, - /* 430 */ 679, 86, 63, 61, 29, 946, 68, 277, 649, 190, - /* 440 */ 15, 106, 14, 105, 676, 192, 677, 186, 17, 193, - /* 450 */ 16, 119, 118, 194, 200, 201, 199, 184, 198, 1013, - /* 460 */ 188, 1012, 223, 1009, 40, 246, 1008, 224, 301, 137, - /* 470 */ 967, 978, 995, 975, 994, 976, 960, 253, 753, 135, - /* 480 */ 980, 139, 143, 155, 156, 942, 251, 940, 704, 257, - /* 490 */ 157, 311, 911, 154, 146, 158, 957, 149, 147, 269, - /* 500 */ 215, 59, 259, 858, 279, 264, 38, 67, 182, 148, - /* 510 */ 35, 288, 854, 64, 1070, 265, 267, 96, 1069, 1067, - /* 520 */ 162, 263, 292, 261, 1064, 102, 295, 1063, 1060, 163, - /* 530 */ 876, 36, 33, 39, 183, 843, 113, 841, 115, 116, - /* 540 */ 839, 838, 238, 173, 836, 835, 834, 833, 832, 831, - /* 550 */ 176, 178, 258, 828, 826, 824, 822, 180, 819, 181, - /* 560 */ 41, 73, 78, 108, 260, 996, 303, 304, 305, 306, - /* 570 */ 307, 308, 309, 208, 321, 796, 230, 278, 239, 240, - /* 580 */ 795, 242, 243, 91, 92, 209, 794, 202, 781, 780, - /* 590 */ 247, 252, 9, 273, 681, 837, 76, 26, 165, 877, - /* 600 */ 166, 126, 167, 164, 169, 168, 170, 127, 830, 2, - /* 610 */ 128, 129, 829, 821, 820, 254, 79, 706, 4, 150, - /* 620 */ 151, 152, 153, 141, 923, 709, 80, 142, 217, 262, - /* 630 */ 27, 713, 144, 10, 11, 757, 28, 7, 12, 22, - /* 640 */ 759, 23, 89, 275, 613, 609, 87, 607, 606, 605, - /* 650 */ 602, 575, 286, 97, 93, 32, 784, 60, 652, 651, - /* 660 */ 648, 597, 595, 101, 103, 587, 593, 589, 591, 585, - /* 670 */ 104, 583, 616, 615, 614, 612, 611, 296, 610, 608, - /* 680 */ 604, 603, 61, 573, 540, 538, 131, 800, 799, 799, - /* 690 */ 799, 799, 799, 132, + /* 0 */ 974, 576, 211, 328, 70, 18, 217, 965, 188, 577, + /* 10 */ 804, 330, 186, 48, 49, 146, 52, 53, 220, 1060, + /* 20 */ 223, 42, 214, 51, 272, 56, 54, 58, 55, 939, + /* 30 */ 655, 188, 953, 47, 46, 188, 938, 45, 44, 43, + /* 40 */ 48, 49, 1059, 52, 53, 219, 1060, 223, 42, 576, + /* 50 */ 51, 272, 56, 54, 58, 55, 965, 577, 304, 303, + /* 60 */ 47, 46, 971, 146, 45, 44, 43, 49, 31, 52, + /* 70 */ 53, 250, 139, 223, 42, 83, 51, 272, 56, 54, + /* 80 */ 58, 55, 288, 1009, 88, 267, 47, 46, 72, 314, + /* 90 */ 45, 44, 43, 529, 530, 531, 532, 533, 534, 535, + /* 100 */ 536, 537, 538, 539, 540, 541, 329, 235, 288, 212, + /* 110 */ 71, 576, 949, 48, 49, 31, 52, 53, 941, 577, + /* 120 */ 223, 42, 576, 51, 272, 56, 54, 58, 55, 269, + /* 130 */ 577, 81, 744, 47, 46, 257, 256, 45, 44, 43, + /* 140 */ 48, 50, 951, 52, 53, 146, 192, 223, 42, 77, + /* 150 */ 51, 272, 56, 54, 58, 55, 213, 37, 947, 950, + /* 160 */ 47, 46, 1, 160, 45, 44, 43, 24, 286, 323, + /* 170 */ 322, 285, 284, 283, 321, 282, 320, 319, 318, 281, + /* 180 */ 317, 316, 913, 31, 901, 902, 903, 904, 905, 906, + /* 190 */ 907, 908, 909, 910, 911, 912, 914, 915, 52, 53, + /* 200 */ 229, 29, 223, 42, 278, 51, 272, 56, 54, 58, + /* 210 */ 55, 694, 19, 1008, 25, 47, 46, 746, 965, 45, + /* 220 */ 44, 43, 222, 759, 226, 31, 748, 950, 751, 197, + /* 230 */ 754, 222, 759, 215, 13, 748, 198, 751, 87, 754, + /* 240 */ 84, 123, 122, 196, 45, 44, 43, 110, 56, 54, + /* 250 */ 58, 55, 314, 747, 208, 209, 47, 46, 271, 74, + /* 260 */ 45, 44, 43, 208, 209, 75, 227, 253, 24, 950, + /* 270 */ 323, 322, 77, 253, 750, 321, 753, 320, 319, 318, + /* 280 */ 37, 317, 316, 921, 1056, 679, 919, 920, 676, 698, + /* 290 */ 677, 922, 678, 924, 925, 923, 85, 926, 927, 108, + /* 300 */ 101, 113, 249, 691, 69, 31, 112, 118, 121, 111, + /* 310 */ 8, 205, 5, 34, 162, 115, 237, 238, 273, 161, + /* 320 */ 95, 90, 94, 31, 234, 57, 232, 936, 937, 30, + /* 330 */ 940, 301, 760, 293, 57, 180, 178, 176, 756, 31, + /* 340 */ 31, 760, 175, 126, 125, 124, 294, 756, 146, 950, + /* 350 */ 242, 47, 46, 1055, 755, 45, 44, 43, 1054, 246, + /* 360 */ 245, 228, 230, 755, 295, 324, 749, 950, 752, 852, + /* 370 */ 327, 326, 131, 172, 137, 135, 134, 3, 173, 1071, + /* 380 */ 302, 306, 221, 950, 950, 861, 757, 953, 953, 172, + /* 390 */ 62, 953, 853, 236, 680, 233, 172, 298, 297, 290, + /* 400 */ 725, 726, 251, 710, 716, 717, 32, 141, 61, 21, + /* 410 */ 65, 780, 63, 761, 763, 20, 82, 20, 665, 275, + /* 420 */ 667, 277, 32, 32, 61, 86, 6, 100, 666, 99, + /* 430 */ 66, 15, 61, 14, 107, 68, 106, 654, 206, 683, + /* 440 */ 17, 684, 16, 681, 207, 682, 120, 119, 952, 190, + /* 450 */ 191, 193, 187, 194, 195, 201, 202, 200, 185, 1019, + /* 460 */ 199, 189, 1018, 224, 40, 1015, 1014, 225, 305, 247, + /* 470 */ 138, 973, 156, 984, 1001, 981, 982, 966, 758, 254, + /* 480 */ 1000, 986, 140, 144, 136, 948, 157, 258, 148, 216, + /* 490 */ 709, 917, 963, 147, 149, 946, 150, 151, 158, 266, + /* 500 */ 159, 864, 280, 260, 265, 67, 64, 59, 38, 270, + /* 510 */ 183, 35, 289, 264, 268, 860, 1077, 96, 291, 1076, + /* 520 */ 1073, 163, 262, 296, 1070, 103, 299, 1069, 1066, 164, + /* 530 */ 882, 36, 33, 39, 184, 849, 114, 847, 116, 117, + /* 540 */ 845, 844, 239, 174, 842, 841, 840, 839, 838, 837, + /* 550 */ 177, 179, 41, 834, 832, 830, 828, 181, 825, 182, + /* 560 */ 259, 252, 315, 73, 78, 109, 261, 1002, 307, 308, + /* 570 */ 309, 310, 311, 312, 210, 313, 231, 325, 279, 802, + /* 580 */ 241, 240, 801, 204, 203, 243, 91, 92, 244, 800, + /* 590 */ 843, 786, 785, 248, 127, 274, 253, 686, 836, 167, + /* 600 */ 128, 166, 883, 165, 168, 169, 171, 129, 170, 835, + /* 610 */ 2, 130, 9, 827, 826, 26, 76, 4, 255, 79, + /* 620 */ 711, 152, 153, 154, 155, 929, 142, 218, 714, 143, + /* 630 */ 80, 263, 764, 718, 145, 10, 11, 762, 27, 7, + /* 640 */ 28, 12, 22, 276, 23, 89, 618, 87, 614, 612, + /* 650 */ 611, 610, 607, 580, 287, 93, 97, 796, 32, 789, + /* 660 */ 657, 656, 653, 98, 60, 102, 602, 600, 592, 598, + /* 670 */ 594, 292, 596, 590, 104, 588, 621, 620, 619, 617, + /* 680 */ 105, 300, 616, 615, 613, 609, 608, 61, 578, 545, + /* 690 */ 132, 543, 806, 805, 805, 805, 133, }; static const YYCODETYPE yy_lookahead[] = { /* 0 */ 191, 1, 190, 191, 197, 252, 210, 234, 252, 9, @@ -296,68 +296,68 @@ static const YYCODETYPE yy_lookahead[] = { /* 50 */ 23, 24, 25, 26, 27, 28, 234, 9, 33, 34, /* 60 */ 33, 34, 253, 191, 37, 38, 39, 14, 191, 16, /* 70 */ 17, 249, 191, 20, 21, 237, 23, 24, 25, 26, - /* 80 */ 27, 28, 79, 259, 197, 261, 33, 34, 250, 68, + /* 80 */ 27, 28, 79, 259, 197, 261, 33, 34, 250, 81, /* 90 */ 37, 38, 39, 45, 46, 47, 48, 49, 50, 51, /* 100 */ 52, 53, 54, 55, 56, 57, 58, 191, 79, 61, /* 110 */ 110, 1, 235, 13, 14, 191, 16, 17, 231, 9, /* 120 */ 20, 21, 1, 23, 24, 25, 26, 27, 28, 257, /* 130 */ 9, 259, 105, 33, 34, 254, 255, 37, 38, 39, - /* 140 */ 13, 14, 226, 16, 17, 191, 81, 20, 21, 104, - /* 150 */ 23, 24, 25, 26, 27, 28, 232, 112, 137, 235, - /* 160 */ 33, 34, 141, 252, 37, 38, 39, 88, 89, 90, + /* 140 */ 13, 14, 226, 16, 17, 191, 252, 20, 21, 104, + /* 150 */ 23, 24, 25, 26, 27, 28, 232, 112, 191, 235, + /* 160 */ 33, 34, 198, 199, 37, 38, 39, 88, 89, 90, /* 170 */ 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, /* 180 */ 101, 102, 209, 191, 211, 212, 213, 214, 215, 216, /* 190 */ 217, 218, 219, 220, 221, 222, 223, 224, 16, 17, - /* 200 */ 196, 252, 20, 21, 200, 23, 24, 25, 26, 27, - /* 210 */ 28, 191, 44, 259, 104, 33, 34, 252, 234, 37, + /* 200 */ 233, 104, 20, 21, 107, 23, 24, 25, 26, 27, + /* 210 */ 28, 37, 44, 259, 104, 33, 34, 1, 234, 37, /* 220 */ 38, 39, 1, 2, 232, 191, 5, 235, 7, 61, /* 230 */ 9, 1, 2, 249, 104, 5, 68, 7, 108, 9, /* 240 */ 110, 73, 74, 75, 37, 38, 39, 76, 25, 26, - /* 250 */ 27, 28, 81, 233, 33, 34, 33, 34, 37, 105, + /* 250 */ 27, 28, 81, 37, 33, 34, 33, 34, 37, 105, /* 260 */ 37, 38, 39, 33, 34, 105, 232, 113, 88, 235, /* 270 */ 90, 91, 104, 113, 5, 95, 7, 97, 98, 99, - /* 280 */ 112, 101, 102, 209, 252, 2, 212, 213, 5, 252, + /* 280 */ 112, 101, 102, 209, 252, 2, 212, 213, 5, 115, /* 290 */ 7, 217, 9, 219, 220, 221, 197, 223, 224, 62, /* 300 */ 63, 64, 134, 109, 136, 191, 69, 70, 71, 72, - /* 310 */ 116, 143, 62, 63, 64, 78, 33, 34, 37, 69, - /* 320 */ 70, 71, 72, 191, 68, 104, 15, 228, 229, 230, - /* 330 */ 231, 75, 111, 191, 104, 62, 63, 64, 117, 191, - /* 340 */ 191, 111, 69, 70, 71, 72, 232, 117, 60, 235, - /* 350 */ 135, 33, 34, 252, 133, 37, 38, 39, 196, 144, - /* 360 */ 145, 252, 200, 133, 232, 210, 5, 235, 7, 210, - /* 370 */ 65, 66, 67, 210, 232, 196, 138, 235, 140, 200, - /* 380 */ 232, 198, 199, 235, 194, 195, 117, 62, 63, 64, - /* 390 */ 1, 236, 104, 137, 111, 236, 115, 141, 142, 236, - /* 400 */ 124, 125, 105, 105, 109, 105, 109, 109, 259, 109, - /* 410 */ 109, 105, 105, 105, 105, 109, 109, 109, 109, 105, - /* 420 */ 236, 105, 111, 109, 129, 109, 37, 105, 5, 105, - /* 430 */ 7, 109, 131, 109, 104, 236, 104, 107, 106, 252, - /* 440 */ 138, 138, 140, 140, 5, 252, 7, 252, 138, 252, - /* 450 */ 140, 76, 77, 252, 252, 252, 252, 252, 252, 227, - /* 460 */ 252, 227, 227, 227, 251, 191, 227, 227, 227, 191, - /* 470 */ 191, 191, 260, 191, 260, 191, 234, 234, 117, 60, - /* 480 */ 191, 191, 191, 238, 191, 234, 192, 191, 117, 256, - /* 490 */ 191, 103, 225, 239, 247, 191, 248, 244, 246, 122, - /* 500 */ 256, 127, 256, 191, 191, 256, 191, 128, 191, 245, - /* 510 */ 191, 191, 191, 130, 191, 121, 126, 191, 191, 191, - /* 520 */ 191, 120, 191, 119, 191, 191, 191, 191, 191, 191, + /* 310 */ 116, 143, 62, 63, 64, 78, 33, 34, 15, 69, + /* 320 */ 70, 71, 72, 191, 68, 104, 68, 228, 229, 230, + /* 330 */ 231, 75, 111, 75, 104, 62, 63, 64, 117, 191, + /* 340 */ 191, 111, 69, 70, 71, 72, 232, 117, 191, 235, + /* 350 */ 135, 33, 34, 252, 133, 37, 38, 39, 252, 144, + /* 360 */ 145, 210, 210, 133, 232, 210, 5, 235, 7, 196, + /* 370 */ 65, 66, 67, 200, 62, 63, 64, 194, 195, 236, + /* 380 */ 232, 232, 60, 235, 235, 196, 117, 236, 236, 200, + /* 390 */ 109, 236, 196, 137, 111, 137, 200, 141, 142, 141, + /* 400 */ 124, 125, 105, 105, 105, 105, 109, 109, 109, 109, + /* 410 */ 109, 105, 131, 105, 111, 109, 259, 109, 105, 105, + /* 420 */ 105, 105, 109, 109, 109, 109, 104, 138, 105, 140, + /* 430 */ 129, 138, 109, 140, 138, 104, 140, 106, 252, 5, + /* 440 */ 138, 7, 140, 5, 252, 7, 76, 77, 236, 252, + /* 450 */ 252, 252, 252, 252, 252, 252, 252, 252, 252, 227, + /* 460 */ 252, 252, 227, 227, 251, 227, 227, 227, 227, 191, + /* 470 */ 191, 191, 238, 191, 260, 191, 191, 234, 117, 234, + /* 480 */ 260, 191, 191, 191, 60, 234, 191, 256, 246, 256, + /* 490 */ 117, 225, 248, 247, 245, 191, 244, 243, 191, 121, + /* 500 */ 191, 191, 191, 256, 256, 128, 130, 127, 191, 122, + /* 510 */ 191, 191, 191, 120, 126, 191, 191, 191, 191, 191, + /* 520 */ 191, 191, 119, 191, 191, 191, 191, 191, 191, 191, /* 530 */ 191, 191, 191, 191, 191, 191, 191, 191, 191, 191, /* 540 */ 191, 191, 191, 191, 191, 191, 191, 191, 191, 191, - /* 550 */ 191, 191, 118, 191, 191, 191, 191, 191, 191, 191, - /* 560 */ 132, 192, 192, 87, 192, 192, 86, 50, 83, 85, - /* 570 */ 54, 84, 82, 192, 79, 5, 192, 192, 146, 5, - /* 580 */ 5, 146, 5, 197, 197, 192, 5, 192, 90, 89, - /* 590 */ 135, 113, 104, 107, 105, 192, 114, 104, 206, 208, - /* 600 */ 202, 193, 205, 207, 204, 203, 201, 193, 192, 198, - /* 610 */ 193, 193, 192, 192, 192, 109, 109, 105, 194, 243, - /* 620 */ 242, 241, 240, 104, 225, 105, 104, 109, 1, 104, - /* 630 */ 109, 105, 104, 123, 123, 105, 109, 104, 104, 104, - /* 640 */ 111, 104, 76, 107, 9, 5, 108, 5, 5, 5, - /* 650 */ 5, 80, 15, 140, 76, 109, 5, 16, 5, 5, - /* 660 */ 105, 5, 5, 140, 140, 5, 5, 5, 5, 5, - /* 670 */ 139, 5, 5, 5, 5, 5, 5, 138, 5, 5, - /* 680 */ 5, 5, 109, 80, 60, 59, 21, 0, 264, 264, - /* 690 */ 264, 264, 264, 21, 264, 264, 264, 264, 264, 264, + /* 550 */ 191, 191, 132, 191, 191, 191, 191, 191, 191, 191, + /* 560 */ 118, 192, 103, 192, 192, 87, 192, 192, 86, 50, + /* 570 */ 83, 85, 54, 84, 192, 82, 192, 79, 192, 5, + /* 580 */ 5, 146, 5, 192, 192, 146, 197, 197, 5, 5, + /* 590 */ 192, 90, 89, 135, 193, 107, 113, 105, 192, 202, + /* 600 */ 193, 206, 208, 207, 205, 203, 201, 193, 204, 192, + /* 610 */ 198, 193, 104, 192, 192, 104, 114, 194, 109, 109, + /* 620 */ 105, 242, 241, 240, 239, 225, 104, 1, 105, 109, + /* 630 */ 104, 104, 111, 105, 104, 123, 123, 105, 109, 104, + /* 640 */ 109, 104, 104, 107, 104, 76, 9, 108, 5, 5, + /* 650 */ 5, 5, 5, 80, 15, 76, 140, 5, 109, 5, + /* 660 */ 5, 5, 105, 139, 16, 140, 5, 5, 5, 5, + /* 670 */ 5, 138, 5, 5, 140, 5, 5, 5, 5, 5, + /* 680 */ 139, 138, 5, 5, 5, 5, 5, 109, 80, 60, + /* 690 */ 21, 59, 0, 264, 264, 264, 21, 264, 264, 264, /* 700 */ 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, /* 710 */ 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, /* 720 */ 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, @@ -376,104 +376,106 @@ static const YYCODETYPE yy_lookahead[] = { /* 850 */ 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, /* 860 */ 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, /* 870 */ 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, - /* 880 */ 264, 264, + /* 880 */ 264, 264, 264, 264, 264, }; -#define YY_SHIFT_COUNT (326) +#define YY_SHIFT_COUNT (330) #define YY_SHIFT_MIN (0) -#define YY_SHIFT_MAX (687) +#define YY_SHIFT_MAX (692) static const unsigned short int yy_shift_ofst[] = { /* 0 */ 168, 79, 79, 180, 180, 3, 221, 230, 110, 121, /* 10 */ 121, 121, 121, 121, 121, 121, 121, 121, 0, 48, /* 20 */ 230, 283, 283, 283, 283, 45, 45, 121, 121, 121, - /* 30 */ 29, 121, 121, 171, 3, 65, 65, 694, 694, 694, + /* 30 */ 29, 121, 121, 171, 3, 8, 8, 697, 697, 697, /* 40 */ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, /* 50 */ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, /* 60 */ 283, 283, 25, 25, 25, 25, 25, 25, 25, 121, - /* 70 */ 121, 121, 281, 121, 121, 121, 45, 45, 121, 121, + /* 70 */ 121, 121, 174, 121, 121, 121, 45, 45, 121, 121, /* 80 */ 121, 276, 276, 194, 45, 121, 121, 121, 121, 121, /* 90 */ 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, /* 100 */ 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, /* 110 */ 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, /* 120 */ 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, - /* 130 */ 121, 121, 121, 121, 121, 121, 121, 419, 419, 419, - /* 140 */ 371, 371, 371, 419, 371, 419, 379, 383, 374, 377, - /* 150 */ 390, 394, 401, 404, 434, 428, 419, 419, 419, 388, - /* 160 */ 3, 3, 419, 419, 476, 480, 517, 485, 484, 516, - /* 170 */ 487, 490, 388, 419, 495, 495, 419, 495, 419, 495, - /* 180 */ 419, 419, 694, 694, 27, 100, 127, 100, 100, 53, - /* 190 */ 182, 223, 223, 223, 223, 237, 250, 273, 318, 318, - /* 200 */ 318, 318, 256, 215, 207, 207, 269, 361, 130, 21, - /* 210 */ 305, 325, 297, 154, 160, 298, 300, 306, 307, 308, - /* 220 */ 389, 288, 311, 301, 295, 309, 314, 316, 322, 324, - /* 230 */ 330, 238, 302, 303, 332, 310, 423, 439, 375, 570, - /* 240 */ 432, 574, 575, 435, 577, 581, 498, 500, 455, 478, - /* 250 */ 486, 488, 482, 489, 493, 506, 507, 512, 519, 520, - /* 260 */ 518, 522, 627, 525, 526, 528, 521, 510, 527, 511, - /* 270 */ 530, 533, 529, 534, 486, 535, 536, 537, 538, 566, - /* 280 */ 635, 640, 642, 643, 644, 645, 571, 637, 578, 513, - /* 290 */ 546, 546, 641, 523, 524, 651, 531, 539, 546, 653, - /* 300 */ 654, 555, 546, 656, 657, 660, 661, 662, 663, 664, - /* 310 */ 666, 667, 668, 669, 670, 671, 673, 674, 675, 676, - /* 320 */ 573, 603, 665, 672, 624, 626, 687, + /* 130 */ 121, 121, 121, 121, 121, 121, 121, 121, 424, 424, + /* 140 */ 424, 373, 373, 373, 424, 373, 424, 377, 376, 380, + /* 150 */ 387, 388, 378, 393, 403, 442, 420, 424, 424, 424, + /* 160 */ 459, 3, 3, 424, 424, 478, 482, 519, 487, 486, + /* 170 */ 518, 489, 493, 459, 424, 498, 498, 424, 498, 424, + /* 180 */ 498, 424, 424, 697, 697, 27, 100, 127, 100, 100, + /* 190 */ 53, 182, 223, 223, 223, 223, 237, 250, 273, 318, + /* 200 */ 318, 318, 318, 256, 258, 215, 207, 207, 269, 361, + /* 210 */ 130, 305, 312, 297, 154, 160, 298, 299, 300, 306, + /* 220 */ 308, 216, 322, 303, 281, 301, 313, 314, 315, 316, + /* 230 */ 323, 97, 289, 293, 296, 331, 302, 434, 438, 370, + /* 240 */ 574, 435, 575, 577, 439, 583, 584, 501, 503, 458, + /* 250 */ 483, 488, 508, 502, 492, 511, 509, 510, 515, 522, + /* 260 */ 523, 520, 526, 626, 527, 528, 530, 529, 512, 531, + /* 270 */ 513, 532, 535, 521, 537, 488, 538, 536, 540, 539, + /* 280 */ 569, 637, 643, 644, 645, 646, 647, 573, 639, 579, + /* 290 */ 516, 652, 524, 533, 549, 549, 648, 525, 534, 654, + /* 300 */ 541, 543, 549, 655, 656, 557, 549, 661, 662, 663, + /* 310 */ 664, 665, 667, 668, 670, 671, 672, 673, 674, 677, + /* 320 */ 678, 679, 680, 681, 578, 608, 669, 675, 629, 632, + /* 330 */ 692, }; -#define YY_REDUCE_COUNT (183) +#define YY_REDUCE_COUNT (184) #define YY_REDUCE_MIN (-247) -#define YY_REDUCE_MAX (424) +#define YY_REDUCE_MAX (423) static const short yy_reduce_ofst[] = { /* 0 */ -178, -27, -27, 74, 74, 99, -244, -217, -119, -76, - /* 10 */ -176, -128, -8, 34, 114, 132, 142, 148, -191, -188, - /* 20 */ -221, -204, 155, 159, 163, -227, -16, -46, 149, 20, - /* 30 */ -113, -84, -123, 4, -193, 162, 179, -162, 183, 190, - /* 40 */ -247, -240, -89, -51, -35, 32, 37, 101, 109, 187, - /* 50 */ 193, 195, 197, 201, 202, 203, 204, 205, 206, 208, - /* 60 */ 184, 199, 232, 234, 235, 236, 239, 240, 241, 274, - /* 70 */ 278, 279, 213, 280, 282, 284, 242, 243, 289, 290, - /* 80 */ 291, 212, 214, 245, 251, 293, 296, 299, 304, 312, - /* 90 */ 313, 315, 317, 319, 320, 321, 323, 326, 327, 328, - /* 100 */ 329, 331, 333, 334, 335, 336, 337, 338, 339, 340, - /* 110 */ 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - /* 120 */ 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - /* 130 */ 362, 363, 364, 365, 366, 367, 368, 294, 369, 370, - /* 140 */ 233, 244, 246, 372, 249, 373, 248, 247, 252, 264, - /* 150 */ 253, 376, 378, 380, 382, 254, 381, 384, 385, 267, - /* 160 */ 386, 387, 393, 395, 391, 396, 392, 398, 397, 402, - /* 170 */ 400, 405, 399, 403, 408, 414, 416, 417, 420, 418, - /* 180 */ 421, 422, 411, 424, + /* 10 */ -176, -128, -8, 34, 114, 132, 148, 149, -191, -188, + /* 20 */ -221, -204, 151, 152, 155, -227, -16, -46, 157, -33, + /* 30 */ -113, -84, -123, 173, -193, 189, 196, -162, -36, 183, + /* 40 */ -247, -240, -106, 32, 101, 106, 186, 192, 197, 198, + /* 50 */ 199, 200, 201, 202, 203, 204, 205, 206, 208, 209, + /* 60 */ 143, 212, 232, 235, 236, 238, 239, 240, 241, 278, + /* 70 */ 279, 280, 213, 282, 284, 285, 243, 245, 290, 291, + /* 80 */ 292, 214, 220, 234, 251, 295, 304, 307, 309, 310, + /* 90 */ 311, 317, 319, 320, 321, 324, 325, 326, 327, 328, + /* 100 */ 329, 330, 332, 333, 334, 335, 336, 337, 338, 339, + /* 110 */ 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, + /* 120 */ 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + /* 130 */ 360, 362, 363, 364, 365, 366, 367, 368, 369, 371, + /* 140 */ 372, 231, 233, 247, 374, 248, 375, 244, 246, 242, + /* 150 */ 249, 252, 254, 379, 381, 383, 385, 382, 384, 386, + /* 160 */ 266, 389, 390, 391, 392, 394, 396, 395, 397, 399, + /* 170 */ 402, 404, 405, 400, 398, 401, 407, 406, 414, 417, + /* 180 */ 418, 421, 422, 412, 423, }; static const YYACTIONTYPE yy_default[] = { - /* 0 */ 797, 910, 856, 922, 844, 853, 1056, 1056, 797, 797, - /* 10 */ 797, 797, 797, 797, 797, 797, 797, 797, 969, 816, - /* 20 */ 1056, 797, 797, 797, 797, 797, 797, 797, 797, 797, - /* 30 */ 853, 797, 797, 859, 853, 859, 859, 964, 894, 912, - /* 40 */ 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - /* 50 */ 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - /* 60 */ 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - /* 70 */ 797, 797, 971, 977, 974, 797, 797, 797, 979, 797, - /* 80 */ 797, 999, 999, 962, 797, 797, 797, 797, 797, 797, - /* 90 */ 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - /* 100 */ 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - /* 110 */ 797, 797, 797, 842, 797, 840, 797, 797, 797, 797, - /* 120 */ 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - /* 130 */ 827, 797, 797, 797, 797, 797, 797, 818, 818, 818, - /* 140 */ 797, 797, 797, 818, 797, 818, 1006, 1010, 1004, 992, - /* 150 */ 1000, 991, 987, 985, 984, 1014, 818, 818, 818, 857, - /* 160 */ 853, 853, 818, 818, 875, 873, 871, 863, 869, 865, - /* 170 */ 867, 861, 845, 818, 851, 851, 818, 851, 818, 851, - /* 180 */ 818, 818, 894, 912, 797, 1015, 797, 1055, 1005, 1045, - /* 190 */ 1044, 1051, 1043, 1042, 1041, 797, 797, 797, 1037, 1038, - /* 200 */ 1040, 1039, 797, 797, 1047, 1046, 797, 797, 797, 797, - /* 210 */ 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - /* 220 */ 797, 1017, 797, 1011, 1007, 797, 797, 797, 797, 797, - /* 230 */ 797, 797, 797, 797, 924, 797, 797, 797, 797, 797, - /* 240 */ 797, 797, 797, 797, 797, 797, 797, 797, 797, 961, - /* 250 */ 797, 797, 797, 797, 797, 973, 972, 797, 797, 797, - /* 260 */ 797, 797, 797, 797, 797, 797, 1001, 797, 993, 797, - /* 270 */ 797, 797, 797, 797, 936, 797, 797, 797, 797, 797, - /* 280 */ 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - /* 290 */ 1068, 1066, 797, 797, 797, 797, 797, 797, 1062, 797, - /* 300 */ 797, 797, 1059, 797, 797, 797, 797, 797, 797, 797, - /* 310 */ 797, 797, 797, 797, 797, 797, 797, 797, 797, 797, - /* 320 */ 878, 797, 825, 823, 797, 814, 797, + /* 0 */ 803, 916, 862, 928, 850, 859, 1062, 1062, 803, 803, + /* 10 */ 803, 803, 803, 803, 803, 803, 803, 803, 975, 822, + /* 20 */ 1062, 803, 803, 803, 803, 803, 803, 803, 803, 803, + /* 30 */ 859, 803, 803, 865, 859, 865, 865, 970, 900, 918, + /* 40 */ 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, + /* 50 */ 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, + /* 60 */ 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, + /* 70 */ 803, 803, 977, 983, 980, 803, 803, 803, 985, 803, + /* 80 */ 803, 1005, 1005, 968, 803, 803, 803, 803, 803, 803, + /* 90 */ 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, + /* 100 */ 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, + /* 110 */ 803, 803, 803, 803, 848, 803, 846, 803, 803, 803, + /* 120 */ 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, + /* 130 */ 803, 833, 803, 803, 803, 803, 803, 803, 824, 824, + /* 140 */ 824, 803, 803, 803, 824, 803, 824, 1012, 1016, 1010, + /* 150 */ 998, 1006, 997, 993, 991, 990, 1020, 824, 824, 824, + /* 160 */ 863, 859, 859, 824, 824, 881, 879, 877, 869, 875, + /* 170 */ 871, 873, 867, 851, 824, 857, 857, 824, 857, 824, + /* 180 */ 857, 824, 824, 900, 918, 803, 1021, 803, 1061, 1011, + /* 190 */ 1051, 1050, 1057, 1049, 1048, 1047, 803, 803, 803, 1043, + /* 200 */ 1044, 1046, 1045, 803, 803, 803, 1053, 1052, 803, 803, + /* 210 */ 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, + /* 220 */ 803, 803, 1023, 803, 1017, 1013, 803, 803, 803, 803, + /* 230 */ 803, 803, 803, 803, 803, 930, 803, 803, 803, 803, + /* 240 */ 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, + /* 250 */ 967, 803, 803, 803, 803, 803, 979, 978, 803, 803, + /* 260 */ 803, 803, 803, 803, 803, 803, 803, 1007, 803, 999, + /* 270 */ 803, 803, 803, 803, 803, 942, 803, 803, 803, 803, + /* 280 */ 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, + /* 290 */ 803, 803, 803, 803, 1075, 1072, 803, 803, 803, 803, + /* 300 */ 803, 803, 1068, 803, 803, 803, 1065, 803, 803, 803, + /* 310 */ 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, + /* 320 */ 803, 803, 803, 803, 884, 803, 831, 829, 803, 820, + /* 330 */ 803, }; /********** End of lemon-generated parsing tables *****************************/ @@ -1307,12 +1309,13 @@ static const char *const yyRuleName[] = { /* 265 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem", /* 266 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist", /* 267 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids", - /* 268 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist", - /* 269 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids", - /* 270 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids", - /* 271 */ "cmd ::= KILL CONNECTION INTEGER", - /* 272 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER", - /* 273 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER", + /* 268 */ "cmd ::= ALTER STABLE ids cpxName ALTER COLUMN LENGTH ids INTEGER", + /* 269 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist", + /* 270 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids", + /* 271 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids", + /* 272 */ "cmd ::= KILL CONNECTION INTEGER", + /* 273 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER", + /* 274 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER", }; #endif /* NDEBUG */ @@ -2047,12 +2050,13 @@ static const YYCODETYPE yyRuleInfoLhs[] = { 189, /* (265) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ 189, /* (266) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ 189, /* (267) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ - 189, /* (268) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ - 189, /* (269) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ - 189, /* (270) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ - 189, /* (271) cmd ::= KILL CONNECTION INTEGER */ - 189, /* (272) cmd ::= KILL STREAM INTEGER COLON INTEGER */ - 189, /* (273) cmd ::= KILL QUERY INTEGER COLON INTEGER */ + 189, /* (268) cmd ::= ALTER STABLE ids cpxName ALTER COLUMN LENGTH ids INTEGER */ + 189, /* (269) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ + 189, /* (270) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ + 189, /* (271) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ + 189, /* (272) cmd ::= KILL CONNECTION INTEGER */ + 189, /* (273) cmd ::= KILL STREAM INTEGER COLON INTEGER */ + 189, /* (274) cmd ::= KILL QUERY INTEGER COLON INTEGER */ }; /* For rule J, yyRuleInfoNRhs[J] contains the negative of the number @@ -2326,12 +2330,13 @@ static const signed char yyRuleInfoNRhs[] = { -9, /* (265) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ -7, /* (266) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ -7, /* (267) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ - -7, /* (268) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ - -7, /* (269) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ - -8, /* (270) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ - -3, /* (271) cmd ::= KILL CONNECTION INTEGER */ - -5, /* (272) cmd ::= KILL STREAM INTEGER COLON INTEGER */ - -5, /* (273) cmd ::= KILL QUERY INTEGER COLON INTEGER */ + -9, /* (268) cmd ::= ALTER STABLE ids cpxName ALTER COLUMN LENGTH ids INTEGER */ + -7, /* (269) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ + -7, /* (270) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ + -8, /* (271) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ + -3, /* (272) cmd ::= KILL CONNECTION INTEGER */ + -5, /* (273) cmd ::= KILL STREAM INTEGER COLON INTEGER */ + -5, /* (274) cmd ::= KILL QUERY INTEGER COLON INTEGER */ }; static void yy_accept(yyParser*); /* Forward Declaration */ @@ -3410,14 +3415,27 @@ static YYACTIONTYPE yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 268: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ + case 268: /* cmd ::= ALTER STABLE ids cpxName ALTER COLUMN LENGTH ids INTEGER */ +{ + yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n; + + toTSDBType(yymsp[-1].minor.yy0.type); + SArray* K = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1); + toTSDBType(yymsp[0].minor.yy0.type); + K = tVariantListAppendToken(K, &yymsp[0].minor.yy0, -1); + + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, K, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE); + setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); +} + break; + case 269: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy285, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 269: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ + case 270: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; @@ -3428,7 +3446,7 @@ static YYACTIONTYPE yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 270: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ + case 271: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ { yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n; @@ -3442,13 +3460,13 @@ static YYACTIONTYPE yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 271: /* cmd ::= KILL CONNECTION INTEGER */ + case 272: /* cmd ::= KILL CONNECTION INTEGER */ {setKillSql(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);} break; - case 272: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */ + case 273: /* 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 273: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */ + case 274: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */ {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_QUERY, &yymsp[-2].minor.yy0);} break; default: diff --git a/tests/script/general/parser/alter_column.sim b/tests/script/general/parser/alter_column.sim index 12c117c096..7f30498d06 100644 --- a/tests/script/general/parser/alter_column.sim +++ b/tests/script/general/parser/alter_column.sim @@ -38,7 +38,7 @@ endi sql create stable stb (ts timestamp, c1 int, c2 binary(10), c3 nchar(10)) tags(id int) sql create table tb1 using stb tags(1) sql insert into tb1 values (now, 1, "1", "1") -sql alter table stb alter column length c2 20; +sql alter stable stb alter column length c2 20; if $rows != 0 then return -1 endi @@ -47,7 +47,9 @@ endi # try dropping columns that are defined in metric sql_error alter table tb alter column length c1 10; +sql_error alter stable tb alter column length c2 10; sql_error alter table tb1 alter column length c2 10; +sql_error alter stable tb1 alter column length c2 10; system sh/exec.sh -n dnode1 -s stop -x SIGINT From 5276ccc334775167313e641313353193ac9b2b31 Mon Sep 17 00:00:00 2001 From: lichuang Date: Mon, 31 May 2021 11:56:19 +0800 Subject: [PATCH 14/26] [TD-1568]fix tdMergeDataCols bug --- src/common/src/tdataformat.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/common/src/tdataformat.c b/src/common/src/tdataformat.c index db73905119..7ae34d532c 100644 --- a/src/common/src/tdataformat.c +++ b/src/common/src/tdataformat.c @@ -462,8 +462,8 @@ int tdMergeDataCols(SDataCols *target, SDataCols *source, int rowsToMerge, int * } } target->numOfRows++; - (*pOffset)++; } + (*pOffset) += rowsToMerge; } else { pTarget = tdDupDataCols(target, true); if (pTarget == NULL) goto _err; From 424cd0123b52eaf6b0e54947c812b08947cae108 Mon Sep 17 00:00:00 2001 From: dapan1121 <89396746@qq.com> Date: Mon, 31 May 2021 15:42:50 +0800 Subject: [PATCH 15/26] fix windows compile error --- src/client/src/tscSQLParser.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c index b0ffab1298..978fbaf521 100644 --- a/src/client/src/tscSQLParser.c +++ b/src/client/src/tscSQLParser.c @@ -5353,9 +5353,9 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { } pItem = taosArrayGet(pAlterSQL->pAddColumns, 1); - int64_t nlen = 0; + int16_t nlen = 0; - if (tVariantDump(&pItem->pVar, (char *)&nlen, TSDB_DATA_TYPE_BIGINT, false) < 0 || nlen <= 0) { + if (tVariantDump(&pItem->pVar, (char *)&nlen, TSDB_DATA_TYPE_SMALLINT, false) < 0 || nlen <= 0) { return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg22); } From d5965c461a1bc0519fee465c438b7b3e078299ce Mon Sep 17 00:00:00 2001 From: tickduan <417921451@qq.com> Date: Mon, 31 May 2021 15:51:43 +0800 Subject: [PATCH 16/26] must ltime >0 to replace --- src/client/src/tscStream.c | 4 ++-- tests/pytest/util/dnodes.py | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c index 2226c3d95d..3998f99afe 100644 --- a/src/client/src/tscStream.c +++ b/src/client/src/tscStream.c @@ -576,8 +576,8 @@ static void tscCreateStream(void *param, TAOS_RES *res, int code) { // set stime with ltime if ltime > stime const char* dstTable = pStream->dstTable? pStream->dstTable: ""; tscDebug(" CQ table=%s ltime is %"PRId64, dstTable, pStream->ltime); - if(pStream->ltime > pStream->stime) { - tscWarn(" CQ set stream %s stime=%"PRId64" replace with ltime=%"PRId64" ", dstTable, pStream->stime, pStream->ltime); + if(pStream->ltime > 0 && pStream->ltime > pStream->stime) { + tscWarn(" CQ set stream %s stime=%"PRId64" replace with ltime=%"PRId64" if ltime>0 ", dstTable, pStream->stime, pStream->ltime); pStream->stime = pStream->ltime; } diff --git a/tests/pytest/util/dnodes.py b/tests/pytest/util/dnodes.py index 6eaf4e18af..0f71ffd0a3 100644 --- a/tests/pytest/util/dnodes.py +++ b/tests/pytest/util/dnodes.py @@ -432,7 +432,7 @@ class TDDnodes: self.simDeployed = False def init(self, path): - psCmd = "ps -ef|grep -w taosd| grep -v grep | awk '{print $2}'" + psCmd = "ps -ef|grep -w taosd| grep -v grep| grep -v defunct | awk '{print $2}'" processID = subprocess.check_output(psCmd, shell=True).decode("utf-8") while(processID): killCmd = "kill -TERM %s > /dev/null 2>&1" % processID @@ -545,14 +545,14 @@ class TDDnodes: for i in range(len(self.dnodes)): self.dnodes[i].stop() - psCmd = "ps -ef | grep -w taosd | grep 'root' | grep -v grep | awk '{print $2}'" + psCmd = "ps -ef | grep -w taosd | grep 'root' | grep -v grep| grep -v defunct | awk '{print $2}'" processID = subprocess.check_output(psCmd, shell=True).decode("utf-8") if processID: cmd = "sudo systemctl stop taosd" os.system(cmd) # if os.system(cmd) != 0 : # tdLog.exit(cmd) - psCmd = "ps -ef|grep -w taosd| grep -v grep | awk '{print $2}'" + psCmd = "ps -ef|grep -w taosd| grep -v grep| grep -v defunct | awk '{print $2}'" processID = subprocess.check_output(psCmd, shell=True).decode("utf-8") while(processID): killCmd = "kill -TERM %s > /dev/null 2>&1" % processID From e4a6d251d91892d8328460b1d09f501fa920d33e Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Mon, 31 May 2021 18:00:14 +0800 Subject: [PATCH 17/26] [TD-4294] --- tests/pytest/functions/function_session.py | 85 ++++++++++++++ .../pytest/functions/function_stateWindow.py | 109 ++++++++++++++++++ 2 files changed, 194 insertions(+) create mode 100644 tests/pytest/functions/function_session.py create mode 100644 tests/pytest/functions/function_stateWindow.py diff --git a/tests/pytest/functions/function_session.py b/tests/pytest/functions/function_session.py new file mode 100644 index 0000000000..9165440737 --- /dev/null +++ b/tests/pytest/functions/function_session.py @@ -0,0 +1,85 @@ +################################################################### +# Copyright (c) 2016 by TAOS Technologies, Inc. +# All rights reserved. +# +# This file is proprietary and confidential to TAOS Technologies. +# No part of this file may be reproduced, stored, transmitted, +# disclosed or used in any form or by any means other than as +# expressly provided by the written permission from Jianhui Tao +# +################################################################### + +# -*- coding: utf-8 -*- + +import sys +import taos +from util.log import * +from util.cases import * +from util.sql import * +#import numpy as np + + +class TDTestCase: + def init(self, conn, logSql): + tdLog.debug("start to execute %s" % __file__) + tdSql.init(conn.cursor()) + + self.rowNum = 10 + self.ts = 1537146000000 + + def run(self): + tdSql.prepare() + + tdSql.execute('''create table test(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double, + col7 bool, col8 binary(20), col9 nchar(20), col11 tinyint unsigned, col12 smallint unsigned, col13 int unsigned, col14 bigint unsigned) tags(loc nchar(20))''') + tdSql.execute("create table test1 using test tags('beijing')") + for i in range(self.rowNum): + tdSql.execute("insert into test1 values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)" + % (self.ts + i, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1)) + + # operation not allowed on super table + tdSql.error("select count(*) from test session(ts, 1s)") + # operation not allowde on col pro + tdSql.error("select * from test1 session(ts, 1s)") + # operation not allowed on col except primary ts + tdSql.error("select * from test1 session(col1, 1s)") + + tdSql.query("select count(*) from test1 session(ts, 1s)") + + tdSql.checkRows(1) + tdSql.checkData(0, 1, 10) + # append more data + + for i in range(self.rowNum): + tdSql.execute("insert into test1 values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)" + % (self.ts + 2000, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1)) + + tdSql.query("select count(*) from test1 session(ts, 1s)") + tdSql.checkRows(2) + tdSql.checkData(0, 1, 10) + tdSql.checkData(1, 1, 1) + + tdSql.query("select count(*) from test1 session(ts, 1m)") + tdSql.checkRows(1) + tdSql.checkData(0, 1, 11) + + tdSql.query("select first(col1) from test1 session(ts, 1s)") + tdSql.checkRows(2) + tdSql.checkData(0, 1, 1) + tdSql.checkData(1, 1, 1) + + tdSql.query("select first(col1), last(col2) from test1 session(ts, 1s)") + tdSql.checkRows(2) + tdSql.checkData(0, 1, 1) + tdSql.checkData(0, 2, 10) + tdSql.checkData(1, 1, 1) + tdSql.checkData(1, 1, 1) + + # add more function + + def stop(self): + tdSql.close() + tdLog.success("%s successfully executed" % __file__) + +tdCases.addWindows(__file__, TDTestCase()) +tdCases.addLinux(__file__, TDTestCase()) diff --git a/tests/pytest/functions/function_stateWindow.py b/tests/pytest/functions/function_stateWindow.py new file mode 100644 index 0000000000..8f05b32164 --- /dev/null +++ b/tests/pytest/functions/function_stateWindow.py @@ -0,0 +1,109 @@ +################################################################### +# Copyright (c) 2016 by TAOS Technologies, Inc. +# All rights reserved. +# +# This file is proprietary and confidential to TAOS Technologies. +# No part of this file may be reproduced, stored, transmitted, +# disclosed or used in any form or by any means other than as +# expressly provided by the written permission from Jianhui Tao +# +################################################################### + +# -*- coding: utf-8 -*- + +import sys +import taos +from util.log import * +from util.cases import * +from util.sql import * +#import numpy as np + + +class TDTestCase: + def init(self, conn, logSql): + tdLog.debug("start to execute %s" % __file__) + tdSql.init(conn.cursor()) + + self.rowNum = 10 + self.ts = 1537146000000 + + def run(self): + tdSql.prepare() + + tdSql.execute('''create table test(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double, + col7 bool, col8 binary(20), col9 nchar(20), col11 tinyint unsigned, col12 smallint unsigned, col13 int unsigned, col14 bigint unsigned) tags(loc nchar(20))''') + tdSql.execute("create table test1 using test tags('beijing')") + col0 = 0 + for i in range(self.rowNum): + tdSql.execute("insert into test1 values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)" + % (self.ts + i, col0, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1)) + + # operation not allowed on super table + tdSql.error("select count(*) from test session(ts, 1s)") + # operation not allowde on col pro + tdSql.error("select * from test1 session(ts, 1s)") + # operation not allowed on col except primary ts + tdSql.error("select * from test1 session(col1, 1s)") + + tdSql.query("select count(*) from test1 state_window(col1)") + + tdSql.checkRows(1) + tdSql.checkData(0, 0, self.rowNum) + # append more data + + col0 = col0 + 1 + for i in range(self.rowNum): + tdSql.execute("insert into test1 values(%d, %d, %d, %d, %d, %f, %f, %d, 'taosdata%d', '涛思数据%d', %d, %d, %d, %d)" + % (self.ts + i + 10000, col0, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1)) + + tdSql.query("select count(*) from test1 state_window(col1)") + + tdSql.checkRows(2) + tdSql.checkData(0, 0, self.rowNum) + tdSql.checkData(1, 0, self.rowNum) + + + tdSql.query("select first(col1) from test1 state_window(col1)") + tdSql.checkRows(2) + col0 = col0 - 1 + tdSql.checkData(0, 0, col0) + col0 = col0 + 1 + tdSql.checkData(1, 0, col0) + + tdSql.query("select first(col2) from test1 state_window(col1)") + tdSql.checkRows(2) + tdSql.checkData(0, 0, 1) + tdSql.checkData(1, 0, 1) + + tdSql.query("select count(col1), first(col2) from test1 state_window(col1)") + tdSql.checkRows(2) + tdSql.checkData(0, 0, 10) + tdSql.checkData(0, 1, 1) + + tdSql.checkData(1, 0, 10) + tdSql.checkData(1, 1, 1) + + + #tdSql.query("select count(*) from test1 session(ts, 1m)") + #tdSql.checkRows(1) + #tdSql.checkData(0, 1, 11) + + #tdSql.query("select first(col1) from test1 session(ts, 1s)") + #tdSql.checkRows(2) + #tdSql.checkData(0, 1, 1) + #tdSql.checkData(1, 1, 1) + + #tdSql.query("select first(col1), last(col2) from test1 session(ts, 1s)") + #tdSql.checkRows(2) + #tdSql.checkData(0, 1, 1) + #tdSql.checkData(0, 2, 10) + #tdSql.checkData(1, 1, 1) + #tdSql.checkData(1, 1, 1) + + + def stop(self): + tdSql.close() + tdLog.success("%s successfully executed" % __file__) + +tdCases.addWindows(__file__, TDTestCase()) +tdCases.addLinux(__file__, TDTestCase()) From f6e0d1926f51961a5c0d2d1f875cfb7c32d8c074 Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Mon, 31 May 2021 18:45:35 +0800 Subject: [PATCH 18/26] [TD-4294] --- tests/pytest/fulltest.sh | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/pytest/fulltest.sh b/tests/pytest/fulltest.sh index c5aba24867..f069897ea9 100755 --- a/tests/pytest/fulltest.sh +++ b/tests/pytest/fulltest.sh @@ -314,6 +314,8 @@ python3 ./test.py -f query/last_row_cache.py python3 ./test.py -f account/account_create.py python3 ./test.py -f alter/alter_table.py python3 ./test.py -f query/queryGroupbySort.py +python3 ./test.py -f functions/function_session.py +python3 ./test.py -f functions/function_stateWindow.py python3 ./test.py -f insert/unsignedInt.py python3 ./test.py -f insert/unsignedBigint.py From edd05ea486d618af8bbb7b8baaae115253ec7b09 Mon Sep 17 00:00:00 2001 From: tickduan <417921451@qq.com> Date: Mon, 31 May 2021 19:49:47 +0800 Subject: [PATCH 19/26] INT64_MIN default to ltime --- src/client/src/tscStream.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c index 3998f99afe..0401d1f3b2 100644 --- a/src/client/src/tscStream.c +++ b/src/client/src/tscStream.c @@ -576,7 +576,7 @@ static void tscCreateStream(void *param, TAOS_RES *res, int code) { // set stime with ltime if ltime > stime const char* dstTable = pStream->dstTable? pStream->dstTable: ""; tscDebug(" CQ table=%s ltime is %"PRId64, dstTable, pStream->ltime); - if(pStream->ltime > 0 && pStream->ltime > pStream->stime) { + if(pStream->ltime != INT64_MIN && pStream->ltime > pStream->stime) { tscWarn(" CQ set stream %s stime=%"PRId64" replace with ltime=%"PRId64" if ltime>0 ", dstTable, pStream->stime, pStream->ltime); pStream->stime = pStream->ltime; } @@ -678,6 +678,7 @@ TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* dstTable, const c return NULL; } + pStream->ltime = INT64_MIN; pStream->stime = stime; pStream->fp = fp; pStream->callback = callback; From 8543ac4e65ec0899837a6fd2c4944f6b1e888442 Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Mon, 31 May 2021 20:48:09 +0800 Subject: [PATCH 20/26] [TD-4294] --- tests/pytest/functions/function_session.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/pytest/functions/function_session.py b/tests/pytest/functions/function_session.py index 9165440737..21b6d088ff 100644 --- a/tests/pytest/functions/function_session.py +++ b/tests/pytest/functions/function_session.py @@ -68,6 +68,7 @@ class TDTestCase: tdSql.checkData(0, 1, 1) tdSql.checkData(1, 1, 1) + tdSql.query("select first(col1), last(col2) from test1 session(ts, 1s)") tdSql.checkRows(2) tdSql.checkData(0, 1, 1) From 9c8507cd7c17d0419b45f268ed757170f23a4755 Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Mon, 31 May 2021 23:29:59 +0800 Subject: [PATCH 21/26] [TD-4506] return valid msg when no db specified --- src/client/src/tscSQLParser.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c index f34434e66c..d255abe602 100644 --- a/src/client/src/tscSQLParser.c +++ b/src/client/src/tscSQLParser.c @@ -7186,8 +7186,9 @@ static int32_t getTableNameFromSqlNode(SSqlNode* pSqlNode, SArray* tableNameList } SName name = {0}; - if (tscSetTableFullName(&name, t, pSql) != TSDB_CODE_SUCCESS) { - return invalidOperationMsg(msgBuf, msg1); + int32_t code = tscSetTableFullName(&name, t, pSql); + if (code != TSDB_CODE_SUCCESS) { + return code; } taosArrayPush(tableNameList, &name); From ce7bfcf02452a206c7236ceb9daab399585f5298 Mon Sep 17 00:00:00 2001 From: dapan1121 <89396746@qq.com> Date: Tue, 1 Jun 2021 08:28:45 +0800 Subject: [PATCH 22/26] fix case issue --- tests/pytest/query/queryInsertValue.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/pytest/query/queryInsertValue.py b/tests/pytest/query/queryInsertValue.py index 856801b4ee..a6b2a88008 100644 --- a/tests/pytest/query/queryInsertValue.py +++ b/tests/pytest/query/queryInsertValue.py @@ -45,7 +45,7 @@ class TDTestCase: tdSql.query("select * from st") tdSql.checkRows(1) - tdSql.execute("alter table st add column length int") + tdSql.execute("alter table st add column len int") tdSql.execute("insert into t1 values(now, 1, 2)") tdSql.query("select last(*) from st") tdSql.checkData(0, 2, 2); From f7d725e34afdc3c8ca98630c559676c44e6eef3c Mon Sep 17 00:00:00 2001 From: Minglei Jin Date: Tue, 1 Jun 2021 20:48:09 +0800 Subject: [PATCH 23/26] [TD-3078]: fix arbitrator create time --- src/common/inc/tglobal.h | 1 + src/common/src/tglobal.c | 1 + src/inc/taosdef.h | 2 ++ src/mnode/src/mnodeDnode.c | 2 +- src/sync/src/syncMain.c | 7 ++++++- 5 files changed, 11 insertions(+), 2 deletions(-) diff --git a/src/common/inc/tglobal.h b/src/common/inc/tglobal.h index 1e66ce3f0c..07d614d5ef 100644 --- a/src/common/inc/tglobal.h +++ b/src/common/inc/tglobal.h @@ -39,6 +39,7 @@ extern int8_t tsEnableTelemetryReporting; extern char tsEmail[]; extern char tsArbitrator[]; extern int8_t tsArbOnline; +extern int64_t tsArbOnlineTimestamp; extern int32_t tsDnodeId; // common diff --git a/src/common/src/tglobal.c b/src/common/src/tglobal.c index e2237bbee6..ed91695569 100644 --- a/src/common/src/tglobal.c +++ b/src/common/src/tglobal.c @@ -42,6 +42,7 @@ int32_t tsNumOfMnodes = 3; int8_t tsEnableVnodeBak = 1; int8_t tsEnableTelemetryReporting = 1; int8_t tsArbOnline = 0; +int64_t tsArbOnlineTimestamp = TSDB_ARB_DUMMY_TIME; char tsEmail[TSDB_FQDN_LEN] = {0}; int32_t tsDnodeId = 0; diff --git a/src/inc/taosdef.h b/src/inc/taosdef.h index 024bc198df..672d460f2c 100644 --- a/src/inc/taosdef.h +++ b/src/inc/taosdef.h @@ -373,6 +373,8 @@ do { \ #define TSDB_MAX_WAL_SIZE (1024*1024*3) +#define TSDB_ARB_DUMMY_TIME 4765104000000 // 2121-01-01 00:00:00.000, :P + typedef enum { TAOS_QTYPE_RPC = 0, TAOS_QTYPE_FWD = 1, diff --git a/src/mnode/src/mnodeDnode.c b/src/mnode/src/mnodeDnode.c index b513da29f4..1acb91beab 100644 --- a/src/mnode/src/mnodeDnode.c +++ b/src/mnode/src/mnodeDnode.c @@ -941,7 +941,7 @@ static int32_t mnodeRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, vo cols++; pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; - *(int64_t *)pWrite = 0; + *(int64_t *)pWrite = tsArbOnlineTimestamp; cols++; pWrite = data + pShow->offset[cols] * rows + pShow->bytes[cols] * numOfRows; diff --git a/src/sync/src/syncMain.c b/src/sync/src/syncMain.c index e44b76d9b0..8ce37cbf78 100644 --- a/src/sync/src/syncMain.c +++ b/src/sync/src/syncMain.c @@ -1150,7 +1150,12 @@ static void syncSetupPeerConnection(SSyncPeer *pPeer) { pPeer->peerFd = connFd; pPeer->role = TAOS_SYNC_ROLE_UNSYNCED; pPeer->pConn = syncAllocateTcpConn(tsTcpPool, pPeer->rid, connFd); - if (pPeer->isArb) tsArbOnline = 1; + if (pPeer->isArb) { + tsArbOnline = 1; + if (tsArbOnlineTimestamp == TSDB_ARB_DUMMY_TIME) { + tsArbOnlineTimestamp = taosGetTimestampMs(); + } + } } else { sDebug("%s, failed to setup peer connection to server since %s, try later", pPeer->id, strerror(errno)); taosCloseSocket(connFd); From b00ba324f34879b112195fe3d3d741926625e962 Mon Sep 17 00:00:00 2001 From: dapan1121 <89396746@qq.com> Date: Wed, 2 Jun 2021 14:04:20 +0800 Subject: [PATCH 24/26] support modify tag column length --- src/client/src/tscSQLParser.c | 77 ++- src/inc/taosmsg.h | 1 + src/inc/ttokendef.h | 5 +- src/mnode/src/mnodeTable.c | 5 + src/query/inc/sql.y | 42 +- src/query/src/qSqlParser.c | 2 +- src/query/src/sql.c | 569 ++++++++++--------- src/util/src/ttokenizer.c | 2 +- tests/script/general/parser/alter_column.sim | 81 ++- 9 files changed, 472 insertions(+), 312 deletions(-) diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c index 978fbaf521..80768b64f2 100644 --- a/src/client/src/tscSQLParser.c +++ b/src/client/src/tscSQLParser.c @@ -5079,8 +5079,10 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { const char* msg18 = "primary timestamp column cannot be dropped"; const char* msg19 = "invalid new tag name"; const char* msg20 = "table is not super table"; - const char* msg21 = "only binary/nchar column length could be altered"; - const char* msg22 = "invalid column length"; + const char* msg21 = "only binary/nchar column length could be modified"; + const char* msg22 = "new column length should be bigger than old one"; + const char* msg23 = "only column length coulbe be modified"; + const char* msg24 = "invalid binary/nchar column length"; int32_t code = TSDB_CODE_SUCCESS; @@ -5111,8 +5113,8 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { } if (pAlterSQL->type == TSDB_ALTER_TABLE_ADD_TAG_COLUMN || pAlterSQL->type == TSDB_ALTER_TABLE_DROP_TAG_COLUMN || - pAlterSQL->type == TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN) { - if (UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo)) { + pAlterSQL->type == TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN || pAlterSQL->type == TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN) { + if (!UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) { return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3); } } else if ((pAlterSQL->type == TSDB_ALTER_TABLE_UPDATE_TAG_VAL) && (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo))) { @@ -5334,14 +5336,18 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { TAOS_FIELD f = tscCreateField(TSDB_DATA_TYPE_INT, name1, tDataTypes[TSDB_DATA_TYPE_INT].bytes); tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f); } else if (pAlterSQL->type == TSDB_ALTER_TABLE_CHANGE_COLUMN) { - if (taosArrayGetSize(pAlterSQL->pAddColumns) != 2) { - return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), NULL); + if (taosArrayGetSize(pAlterSQL->pAddColumns) >= 2) { + return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg16); } - tVariantListItem* pItem = taosArrayGet(pAlterSQL->pAddColumns, 0); + + TAOS_FIELD* pItem = taosArrayGet(pAlterSQL->pAddColumns, 0); + if (pItem->type != TSDB_DATA_TYPE_BINARY && pItem->type != TSDB_DATA_TYPE_NCHAR) { + return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg21); + } SColumnIndex columnIndex = COLUMN_INDEX_INITIALIZER; - SStrToken name = {.type = TK_STRING, .z = pItem->pVar.pz, .n = pItem->pVar.nLen}; + SStrToken name = {.type = TK_STRING, .z = pItem->name, .n = strlen(pItem->name)}; if (getColumnIndexByName(pCmd, &name, pQueryInfo, &columnIndex) != TSDB_CODE_SUCCESS) { return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg17); } @@ -5352,14 +5358,61 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg21); } - pItem = taosArrayGet(pAlterSQL->pAddColumns, 1); - int16_t nlen = 0; + if (pItem->type != pColSchema->type) { + return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg23); + } - if (tVariantDump(&pItem->pVar, (char *)&nlen, TSDB_DATA_TYPE_SMALLINT, false) < 0 || nlen <= 0) { + if ((pItem->type == TSDB_DATA_TYPE_BINARY && (pItem->bytes <= 0 || pItem->bytes > TSDB_MAX_BINARY_LEN)) || + (pItem->type == TSDB_DATA_TYPE_NCHAR && (pItem->bytes <= 0 || pItem->bytes > TSDB_MAX_NCHAR_LEN))) { + return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg24); + } + + if (pItem->bytes <= pColSchema->bytes) { return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg22); } - TAOS_FIELD f = tscCreateField(pColSchema->type, name.z, nlen); + TAOS_FIELD f = tscCreateField(pColSchema->type, name.z, pItem->bytes); + tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f); + }else if (pAlterSQL->type == TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN) { + if (taosArrayGetSize(pAlterSQL->pAddColumns) >= 2) { + return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg16); + } + + TAOS_FIELD* pItem = taosArrayGet(pAlterSQL->pAddColumns, 0); + if (pItem->type != TSDB_DATA_TYPE_BINARY && pItem->type != TSDB_DATA_TYPE_NCHAR) { + return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg21); + } + + SColumnIndex columnIndex = COLUMN_INDEX_INITIALIZER; + SStrToken name = {.type = TK_STRING, .z = pItem->name, .n = strlen(pItem->name)}; + if (getColumnIndexByName(pCmd, &name, pQueryInfo, &columnIndex) != TSDB_CODE_SUCCESS) { + return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg17); + } + + SSchema* pColSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, columnIndex.columnIndex); + + if (columnIndex.columnIndex < tscGetNumOfColumns(pTableMetaInfo->pTableMeta)) { + return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg10); + } + + if (pColSchema->type != TSDB_DATA_TYPE_BINARY && pColSchema->type != TSDB_DATA_TYPE_NCHAR) { + return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg21); + } + + if (pItem->type != pColSchema->type) { + return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg23); + } + + if ((pItem->type == TSDB_DATA_TYPE_BINARY && (pItem->bytes <= 0 || pItem->bytes > TSDB_MAX_BINARY_LEN)) || + (pItem->type == TSDB_DATA_TYPE_NCHAR && (pItem->bytes <= 0 || pItem->bytes > TSDB_MAX_NCHAR_LEN))) { + return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg24); + } + + if (pItem->bytes <= pColSchema->bytes) { + return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg22); + } + + TAOS_FIELD f = tscCreateField(pColSchema->type, name.z, pItem->bytes); tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f); } diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h index ff3cc6e956..413f72720e 100644 --- a/src/inc/taosmsg.h +++ b/src/inc/taosmsg.h @@ -161,6 +161,7 @@ enum _mgmt_table { #define TSDB_ALTER_TABLE_ADD_COLUMN 5 #define TSDB_ALTER_TABLE_DROP_COLUMN 6 #define TSDB_ALTER_TABLE_CHANGE_COLUMN 7 +#define TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN 8 #define TSDB_FILL_NONE 0 #define TSDB_FILL_NULL 1 diff --git a/src/inc/ttokendef.h b/src/inc/ttokendef.h index e5f1472317..e0c9abed18 100644 --- a/src/inc/ttokendef.h +++ b/src/inc/ttokendef.h @@ -155,7 +155,7 @@ #define TK_SYNCDB 136 #define TK_ADD 137 #define TK_COLUMN 138 -#define TK_LENGTH 139 +#define TK_MODIFY 139 #define TK_TAG 140 #define TK_CHANGE 141 #define TK_SET 142 @@ -211,6 +211,9 @@ + + + #define TK_SPACE 300 #define TK_COMMENT 301 #define TK_ILLEGAL 302 diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c index 6eca87514b..5b699c5e24 100644 --- a/src/mnode/src/mnodeTable.c +++ b/src/mnode/src/mnodeTable.c @@ -3218,6 +3218,11 @@ static int32_t mnodeProcessAlterTableMsg(SMnodeMsg *pMsg) { (void)mnodeChangeSuperTableColumn; mError("change table[%s] column[%s] length to [%d] is not processed", pAlter->tableFname, pAlter->schema[0].name, pAlter->schema[0].bytes); code = TSDB_CODE_SUCCESS; + } else if (pAlter->type == TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN) { + //code = mnodeChangeSuperTableColumn(pMsg, pAlter->schema[0].name, pAlter->schema[1].name); + (void)mnodeChangeSuperTableColumn; + mError("change table[%s] tag[%s] length to [%d] is not processed", pAlter->tableFname, pAlter->schema[0].name, pAlter->schema[0].bytes); + code = TSDB_CODE_SUCCESS; } else { } } else { diff --git a/src/query/inc/sql.y b/src/query/inc/sql.y index 3a6e1c0cc0..1b173a272f 100644 --- a/src/query/inc/sql.y +++ b/src/query/inc/sql.y @@ -754,15 +754,9 @@ cmd ::= ALTER TABLE ids(X) cpxName(F) DROP COLUMN ids(A). { setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } -cmd ::= ALTER TABLE ids(X) cpxName(F) ALTER COLUMN LENGTH ids(A) INTEGER(Z). { +cmd ::= ALTER TABLE ids(X) cpxName(F) MODIFY COLUMN columnlist(A). { X.n += F.n; - - toTSDBType(A.type); - SArray* K = tVariantListAppendToken(NULL, &A, -1); - toTSDBType(Z.type); - K = tVariantListAppendToken(K, &Z, -1); - - SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&X, K, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1); + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&X, A, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } @@ -806,6 +800,11 @@ cmd ::= ALTER TABLE ids(X) cpxName(F) SET TAG ids(Y) EQ tagitem(Z). { setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } +cmd ::= ALTER TABLE ids(X) cpxName(F) MODIFY TAG columnlist(A). { + X.n += F.n; + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&X, A, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, -1); + setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); +} ///////////////////////////////////ALTER STABLE statement////////////////////////////////// cmd ::= ALTER STABLE ids(X) cpxName(F) ADD COLUMN columnlist(A). { @@ -824,15 +823,9 @@ cmd ::= ALTER STABLE ids(X) cpxName(F) DROP COLUMN ids(A). { setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } -cmd ::= ALTER STABLE ids(X) cpxName(F) ALTER COLUMN LENGTH ids(A) INTEGER(Z). { +cmd ::= ALTER STABLE ids(X) cpxName(F) MODIFY COLUMN columnlist(A). { X.n += F.n; - - toTSDBType(A.type); - SArray* K = tVariantListAppendToken(NULL, &A, -1); - toTSDBType(Z.type); - K = tVariantListAppendToken(K, &Z, -1); - - SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&X, K, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE); + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&X, A, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } @@ -865,6 +858,23 @@ cmd ::= ALTER STABLE ids(X) cpxName(F) CHANGE TAG ids(Y) ids(Z). { setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } +cmd ::= ALTER STABLE ids(X) cpxName(F) SET TAG ids(Y) EQ tagitem(Z). { + X.n += F.n; + + toTSDBType(Y.type); + SArray* A = tVariantListAppendToken(NULL, &Y, -1); + A = tVariantListAppend(A, &Z, -1); + + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&X, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, TSDB_SUPER_TABLE); + setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); +} + +cmd ::= ALTER STABLE ids(X) cpxName(F) MODIFY TAG columnlist(A). { + X.n += F.n; + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&X, A, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, TSDB_SUPER_TABLE); + setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); +} + ////////////////////////////////////////kill statement/////////////////////////////////////// cmd ::= KILL CONNECTION INTEGER(Y). {setKillSql(pInfo, TSDB_SQL_KILL_CONNECTION, &Y);} cmd ::= KILL STREAM INTEGER(X) COLON(Z) INTEGER(Y). {X.n += (Z.n + Y.n); setKillSql(pInfo, TSDB_SQL_KILL_STREAM, &X);} diff --git a/src/query/src/qSqlParser.c b/src/query/src/qSqlParser.c index b912c9ffdc..d41b474953 100644 --- a/src/query/src/qSqlParser.c +++ b/src/query/src/qSqlParser.c @@ -887,7 +887,7 @@ SAlterTableInfo *tSetAlterTableInfo(SStrToken *pTableName, SArray *pCols, SArray pAlterTable->type = type; pAlterTable->tableType = tableType; - if (type == TSDB_ALTER_TABLE_ADD_COLUMN || type == TSDB_ALTER_TABLE_ADD_TAG_COLUMN || type == TSDB_ALTER_TABLE_CHANGE_COLUMN) { + if (type == TSDB_ALTER_TABLE_ADD_COLUMN || type == TSDB_ALTER_TABLE_ADD_TAG_COLUMN || type == TSDB_ALTER_TABLE_CHANGE_COLUMN || type == TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN) { pAlterTable->pAddColumns = pCols; assert(pVals == NULL); } else { diff --git a/src/query/src/sql.c b/src/query/src/sql.c index 560e499228..588da79883 100644 --- a/src/query/src/sql.c +++ b/src/query/src/sql.c @@ -136,18 +136,18 @@ typedef union { #define ParseCTX_FETCH #define ParseCTX_STORE #define YYFALLBACK 1 -#define YYNSTATE 331 -#define YYNRULE 275 -#define YYNRULE_WITH_ACTION 275 +#define YYNSTATE 337 +#define YYNRULE 278 +#define YYNRULE_WITH_ACTION 278 #define YYNTOKEN 188 -#define YY_MAX_SHIFT 330 -#define YY_MIN_SHIFTREDUCE 528 -#define YY_MAX_SHIFTREDUCE 802 -#define YY_ERROR_ACTION 803 -#define YY_ACCEPT_ACTION 804 -#define YY_NO_ACTION 805 -#define YY_MIN_REDUCE 806 -#define YY_MAX_REDUCE 1080 +#define YY_MAX_SHIFT 336 +#define YY_MIN_SHIFTREDUCE 533 +#define YY_MAX_SHIFTREDUCE 810 +#define YY_ERROR_ACTION 811 +#define YY_ACCEPT_ACTION 812 +#define YY_NO_ACTION 813 +#define YY_MIN_REDUCE 814 +#define YY_MAX_REDUCE 1091 /************* End control #defines *******************************************/ #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) @@ -214,78 +214,79 @@ typedef union { ** yy_default[] Default action for each state. ** *********** Begin parsing tables **********************************************/ -#define YY_ACTTAB_COUNT (697) +#define YY_ACTTAB_COUNT (707) static const YYACTIONTYPE yy_action[] = { - /* 0 */ 974, 576, 211, 328, 70, 18, 217, 965, 188, 577, - /* 10 */ 804, 330, 186, 48, 49, 146, 52, 53, 220, 1060, - /* 20 */ 223, 42, 214, 51, 272, 56, 54, 58, 55, 939, - /* 30 */ 655, 188, 953, 47, 46, 188, 938, 45, 44, 43, - /* 40 */ 48, 49, 1059, 52, 53, 219, 1060, 223, 42, 576, - /* 50 */ 51, 272, 56, 54, 58, 55, 965, 577, 304, 303, - /* 60 */ 47, 46, 971, 146, 45, 44, 43, 49, 31, 52, - /* 70 */ 53, 250, 139, 223, 42, 83, 51, 272, 56, 54, - /* 80 */ 58, 55, 288, 1009, 88, 267, 47, 46, 72, 314, - /* 90 */ 45, 44, 43, 529, 530, 531, 532, 533, 534, 535, - /* 100 */ 536, 537, 538, 539, 540, 541, 329, 235, 288, 212, - /* 110 */ 71, 576, 949, 48, 49, 31, 52, 53, 941, 577, - /* 120 */ 223, 42, 576, 51, 272, 56, 54, 58, 55, 269, - /* 130 */ 577, 81, 744, 47, 46, 257, 256, 45, 44, 43, - /* 140 */ 48, 50, 951, 52, 53, 146, 192, 223, 42, 77, - /* 150 */ 51, 272, 56, 54, 58, 55, 213, 37, 947, 950, - /* 160 */ 47, 46, 1, 160, 45, 44, 43, 24, 286, 323, - /* 170 */ 322, 285, 284, 283, 321, 282, 320, 319, 318, 281, - /* 180 */ 317, 316, 913, 31, 901, 902, 903, 904, 905, 906, - /* 190 */ 907, 908, 909, 910, 911, 912, 914, 915, 52, 53, - /* 200 */ 229, 29, 223, 42, 278, 51, 272, 56, 54, 58, - /* 210 */ 55, 694, 19, 1008, 25, 47, 46, 746, 965, 45, - /* 220 */ 44, 43, 222, 759, 226, 31, 748, 950, 751, 197, - /* 230 */ 754, 222, 759, 215, 13, 748, 198, 751, 87, 754, - /* 240 */ 84, 123, 122, 196, 45, 44, 43, 110, 56, 54, - /* 250 */ 58, 55, 314, 747, 208, 209, 47, 46, 271, 74, - /* 260 */ 45, 44, 43, 208, 209, 75, 227, 253, 24, 950, - /* 270 */ 323, 322, 77, 253, 750, 321, 753, 320, 319, 318, - /* 280 */ 37, 317, 316, 921, 1056, 679, 919, 920, 676, 698, - /* 290 */ 677, 922, 678, 924, 925, 923, 85, 926, 927, 108, - /* 300 */ 101, 113, 249, 691, 69, 31, 112, 118, 121, 111, - /* 310 */ 8, 205, 5, 34, 162, 115, 237, 238, 273, 161, - /* 320 */ 95, 90, 94, 31, 234, 57, 232, 936, 937, 30, - /* 330 */ 940, 301, 760, 293, 57, 180, 178, 176, 756, 31, - /* 340 */ 31, 760, 175, 126, 125, 124, 294, 756, 146, 950, - /* 350 */ 242, 47, 46, 1055, 755, 45, 44, 43, 1054, 246, - /* 360 */ 245, 228, 230, 755, 295, 324, 749, 950, 752, 852, - /* 370 */ 327, 326, 131, 172, 137, 135, 134, 3, 173, 1071, - /* 380 */ 302, 306, 221, 950, 950, 861, 757, 953, 953, 172, - /* 390 */ 62, 953, 853, 236, 680, 233, 172, 298, 297, 290, - /* 400 */ 725, 726, 251, 710, 716, 717, 32, 141, 61, 21, - /* 410 */ 65, 780, 63, 761, 763, 20, 82, 20, 665, 275, - /* 420 */ 667, 277, 32, 32, 61, 86, 6, 100, 666, 99, - /* 430 */ 66, 15, 61, 14, 107, 68, 106, 654, 206, 683, - /* 440 */ 17, 684, 16, 681, 207, 682, 120, 119, 952, 190, - /* 450 */ 191, 193, 187, 194, 195, 201, 202, 200, 185, 1019, - /* 460 */ 199, 189, 1018, 224, 40, 1015, 1014, 225, 305, 247, - /* 470 */ 138, 973, 156, 984, 1001, 981, 982, 966, 758, 254, - /* 480 */ 1000, 986, 140, 144, 136, 948, 157, 258, 148, 216, - /* 490 */ 709, 917, 963, 147, 149, 946, 150, 151, 158, 266, - /* 500 */ 159, 864, 280, 260, 265, 67, 64, 59, 38, 270, - /* 510 */ 183, 35, 289, 264, 268, 860, 1077, 96, 291, 1076, - /* 520 */ 1073, 163, 262, 296, 1070, 103, 299, 1069, 1066, 164, - /* 530 */ 882, 36, 33, 39, 184, 849, 114, 847, 116, 117, - /* 540 */ 845, 844, 239, 174, 842, 841, 840, 839, 838, 837, - /* 550 */ 177, 179, 41, 834, 832, 830, 828, 181, 825, 182, - /* 560 */ 259, 252, 315, 73, 78, 109, 261, 1002, 307, 308, - /* 570 */ 309, 310, 311, 312, 210, 313, 231, 325, 279, 802, - /* 580 */ 241, 240, 801, 204, 203, 243, 91, 92, 244, 800, - /* 590 */ 843, 786, 785, 248, 127, 274, 253, 686, 836, 167, - /* 600 */ 128, 166, 883, 165, 168, 169, 171, 129, 170, 835, - /* 610 */ 2, 130, 9, 827, 826, 26, 76, 4, 255, 79, - /* 620 */ 711, 152, 153, 154, 155, 929, 142, 218, 714, 143, - /* 630 */ 80, 263, 764, 718, 145, 10, 11, 762, 27, 7, - /* 640 */ 28, 12, 22, 276, 23, 89, 618, 87, 614, 612, - /* 650 */ 611, 610, 607, 580, 287, 93, 97, 796, 32, 789, - /* 660 */ 657, 656, 653, 98, 60, 102, 602, 600, 592, 598, - /* 670 */ 594, 292, 596, 590, 104, 588, 621, 620, 619, 617, - /* 680 */ 105, 300, 616, 615, 613, 609, 608, 61, 578, 545, - /* 690 */ 132, 543, 806, 805, 805, 805, 133, + /* 0 */ 982, 581, 215, 334, 75, 22, 221, 973, 192, 582, + /* 10 */ 812, 336, 190, 52, 53, 150, 56, 57, 224, 1068, + /* 20 */ 227, 46, 218, 55, 278, 60, 58, 62, 59, 947, + /* 30 */ 660, 192, 961, 51, 50, 192, 946, 49, 48, 47, + /* 40 */ 52, 53, 1067, 56, 57, 223, 1068, 227, 46, 581, + /* 50 */ 55, 278, 60, 58, 62, 59, 973, 582, 310, 309, + /* 60 */ 51, 50, 979, 150, 49, 48, 47, 53, 35, 56, + /* 70 */ 57, 256, 143, 227, 46, 88, 55, 278, 60, 58, + /* 80 */ 62, 59, 294, 1017, 93, 273, 51, 50, 77, 320, + /* 90 */ 49, 48, 47, 534, 535, 536, 537, 538, 539, 540, + /* 100 */ 541, 542, 543, 544, 545, 546, 335, 241, 294, 216, + /* 110 */ 76, 581, 957, 52, 53, 35, 56, 57, 949, 582, + /* 120 */ 227, 46, 581, 55, 278, 60, 58, 62, 59, 275, + /* 130 */ 582, 86, 749, 51, 50, 263, 262, 49, 48, 47, + /* 140 */ 52, 54, 959, 56, 57, 150, 196, 227, 46, 82, + /* 150 */ 55, 278, 60, 58, 62, 59, 217, 41, 955, 958, + /* 160 */ 51, 50, 1, 164, 49, 48, 47, 28, 292, 329, + /* 170 */ 328, 291, 290, 289, 327, 288, 326, 325, 324, 287, + /* 180 */ 323, 322, 921, 35, 909, 910, 911, 912, 913, 914, + /* 190 */ 915, 916, 917, 918, 919, 920, 922, 923, 56, 57, + /* 200 */ 233, 1064, 227, 46, 696, 55, 278, 60, 58, 62, + /* 210 */ 59, 8, 23, 1016, 29, 51, 50, 1063, 973, 49, + /* 220 */ 48, 47, 226, 764, 230, 35, 753, 958, 756, 201, + /* 230 */ 759, 226, 764, 219, 1062, 753, 202, 756, 755, 759, + /* 240 */ 758, 127, 126, 200, 49, 48, 47, 210, 60, 58, + /* 250 */ 62, 59, 3, 177, 212, 213, 51, 50, 277, 79, + /* 260 */ 49, 48, 47, 212, 213, 80, 231, 259, 28, 958, + /* 270 */ 329, 328, 82, 259, 754, 327, 757, 326, 325, 324, + /* 280 */ 41, 323, 322, 929, 114, 684, 927, 928, 681, 320, + /* 290 */ 682, 930, 683, 932, 933, 931, 90, 934, 935, 112, + /* 300 */ 106, 117, 255, 150, 74, 35, 116, 122, 125, 115, + /* 310 */ 237, 209, 5, 38, 166, 119, 243, 244, 211, 165, + /* 320 */ 100, 95, 99, 35, 240, 61, 225, 944, 945, 34, + /* 330 */ 948, 35, 765, 35, 61, 184, 182, 180, 761, 232, + /* 340 */ 234, 765, 179, 130, 129, 128, 299, 761, 35, 958, + /* 350 */ 762, 51, 50, 699, 760, 49, 48, 47, 35, 248, + /* 360 */ 35, 330, 35, 760, 300, 961, 961, 958, 252, 251, + /* 370 */ 6, 87, 301, 279, 302, 958, 13, 958, 194, 238, + /* 380 */ 92, 236, 89, 298, 297, 70, 763, 961, 751, 306, + /* 390 */ 124, 123, 958, 242, 685, 239, 860, 305, 304, 307, + /* 400 */ 176, 308, 958, 312, 958, 71, 958, 333, 332, 135, + /* 410 */ 141, 139, 138, 869, 257, 861, 67, 176, 36, 176, + /* 420 */ 730, 731, 715, 1087, 752, 721, 145, 195, 722, 66, + /* 430 */ 785, 703, 25, 766, 24, 670, 281, 24, 68, 36, + /* 440 */ 36, 672, 283, 671, 197, 66, 91, 66, 33, 191, + /* 450 */ 15, 284, 14, 105, 73, 104, 659, 198, 199, 17, + /* 460 */ 19, 16, 18, 205, 111, 21, 110, 20, 688, 768, + /* 470 */ 689, 686, 206, 687, 204, 1079, 960, 189, 203, 193, + /* 480 */ 1027, 1026, 228, 253, 1023, 1022, 229, 311, 142, 981, + /* 490 */ 992, 989, 44, 990, 994, 974, 260, 144, 1009, 148, + /* 500 */ 140, 160, 956, 1008, 161, 264, 925, 220, 266, 714, + /* 510 */ 954, 321, 971, 156, 151, 162, 152, 158, 276, 153, + /* 520 */ 163, 271, 63, 872, 286, 42, 187, 72, 69, 274, + /* 530 */ 39, 295, 868, 154, 296, 272, 1086, 102, 1085, 270, + /* 540 */ 1082, 268, 167, 303, 1078, 108, 1077, 1074, 168, 265, + /* 550 */ 890, 40, 37, 43, 188, 857, 118, 855, 120, 121, + /* 560 */ 853, 852, 245, 178, 850, 849, 848, 847, 846, 845, + /* 570 */ 181, 183, 842, 840, 838, 836, 185, 833, 45, 186, + /* 580 */ 113, 258, 78, 83, 313, 267, 1010, 314, 315, 316, + /* 590 */ 317, 318, 319, 214, 235, 331, 810, 285, 246, 247, + /* 600 */ 809, 207, 208, 96, 97, 249, 250, 808, 791, 790, + /* 610 */ 254, 81, 259, 851, 691, 280, 844, 171, 170, 891, + /* 620 */ 169, 172, 174, 173, 175, 131, 132, 133, 843, 4, + /* 630 */ 134, 835, 9, 834, 30, 261, 2, 716, 84, 146, + /* 640 */ 155, 157, 937, 159, 719, 85, 222, 147, 269, 31, + /* 650 */ 723, 149, 32, 767, 10, 7, 11, 769, 12, 26, + /* 660 */ 282, 27, 94, 623, 92, 619, 617, 616, 615, 612, + /* 670 */ 585, 293, 98, 64, 101, 36, 662, 661, 658, 607, + /* 680 */ 605, 65, 103, 597, 603, 599, 601, 595, 593, 107, + /* 690 */ 109, 626, 625, 624, 622, 621, 620, 618, 614, 613, + /* 700 */ 583, 66, 550, 548, 814, 136, 137, }; static const YYCODETYPE yy_lookahead[] = { /* 0 */ 191, 1, 190, 191, 197, 252, 210, 234, 252, 9, @@ -308,57 +309,57 @@ static const YYCODETYPE yy_lookahead[] = { /* 170 */ 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, /* 180 */ 101, 102, 209, 191, 211, 212, 213, 214, 215, 216, /* 190 */ 217, 218, 219, 220, 221, 222, 223, 224, 16, 17, - /* 200 */ 233, 104, 20, 21, 107, 23, 24, 25, 26, 27, - /* 210 */ 28, 37, 44, 259, 104, 33, 34, 1, 234, 37, + /* 200 */ 233, 252, 20, 21, 109, 23, 24, 25, 26, 27, + /* 210 */ 28, 116, 44, 259, 104, 33, 34, 252, 234, 37, /* 220 */ 38, 39, 1, 2, 232, 191, 5, 235, 7, 61, - /* 230 */ 9, 1, 2, 249, 104, 5, 68, 7, 108, 9, - /* 240 */ 110, 73, 74, 75, 37, 38, 39, 76, 25, 26, - /* 250 */ 27, 28, 81, 37, 33, 34, 33, 34, 37, 105, + /* 230 */ 9, 1, 2, 249, 252, 5, 68, 7, 5, 9, + /* 240 */ 7, 73, 74, 75, 37, 38, 39, 252, 25, 26, + /* 250 */ 27, 28, 194, 195, 33, 34, 33, 34, 37, 105, /* 260 */ 37, 38, 39, 33, 34, 105, 232, 113, 88, 235, /* 270 */ 90, 91, 104, 113, 5, 95, 7, 97, 98, 99, - /* 280 */ 112, 101, 102, 209, 252, 2, 212, 213, 5, 115, + /* 280 */ 112, 101, 102, 209, 76, 2, 212, 213, 5, 81, /* 290 */ 7, 217, 9, 219, 220, 221, 197, 223, 224, 62, - /* 300 */ 63, 64, 134, 109, 136, 191, 69, 70, 71, 72, - /* 310 */ 116, 143, 62, 63, 64, 78, 33, 34, 15, 69, - /* 320 */ 70, 71, 72, 191, 68, 104, 68, 228, 229, 230, - /* 330 */ 231, 75, 111, 75, 104, 62, 63, 64, 117, 191, - /* 340 */ 191, 111, 69, 70, 71, 72, 232, 117, 191, 235, - /* 350 */ 135, 33, 34, 252, 133, 37, 38, 39, 252, 144, - /* 360 */ 145, 210, 210, 133, 232, 210, 5, 235, 7, 196, - /* 370 */ 65, 66, 67, 200, 62, 63, 64, 194, 195, 236, - /* 380 */ 232, 232, 60, 235, 235, 196, 117, 236, 236, 200, - /* 390 */ 109, 236, 196, 137, 111, 137, 200, 141, 142, 141, - /* 400 */ 124, 125, 105, 105, 105, 105, 109, 109, 109, 109, - /* 410 */ 109, 105, 131, 105, 111, 109, 259, 109, 105, 105, - /* 420 */ 105, 105, 109, 109, 109, 109, 104, 138, 105, 140, - /* 430 */ 129, 138, 109, 140, 138, 104, 140, 106, 252, 5, - /* 440 */ 138, 7, 140, 5, 252, 7, 76, 77, 236, 252, - /* 450 */ 252, 252, 252, 252, 252, 252, 252, 252, 252, 227, - /* 460 */ 252, 252, 227, 227, 251, 227, 227, 227, 227, 191, - /* 470 */ 191, 191, 238, 191, 260, 191, 191, 234, 117, 234, - /* 480 */ 260, 191, 191, 191, 60, 234, 191, 256, 246, 256, - /* 490 */ 117, 225, 248, 247, 245, 191, 244, 243, 191, 121, - /* 500 */ 191, 191, 191, 256, 256, 128, 130, 127, 191, 122, - /* 510 */ 191, 191, 191, 120, 126, 191, 191, 191, 191, 191, - /* 520 */ 191, 191, 119, 191, 191, 191, 191, 191, 191, 191, - /* 530 */ 191, 191, 191, 191, 191, 191, 191, 191, 191, 191, - /* 540 */ 191, 191, 191, 191, 191, 191, 191, 191, 191, 191, - /* 550 */ 191, 191, 132, 191, 191, 191, 191, 191, 191, 191, - /* 560 */ 118, 192, 103, 192, 192, 87, 192, 192, 86, 50, - /* 570 */ 83, 85, 54, 84, 192, 82, 192, 79, 192, 5, - /* 580 */ 5, 146, 5, 192, 192, 146, 197, 197, 5, 5, - /* 590 */ 192, 90, 89, 135, 193, 107, 113, 105, 192, 202, - /* 600 */ 193, 206, 208, 207, 205, 203, 201, 193, 204, 192, - /* 610 */ 198, 193, 104, 192, 192, 104, 114, 194, 109, 109, - /* 620 */ 105, 242, 241, 240, 239, 225, 104, 1, 105, 109, - /* 630 */ 104, 104, 111, 105, 104, 123, 123, 105, 109, 104, - /* 640 */ 109, 104, 104, 107, 104, 76, 9, 108, 5, 5, - /* 650 */ 5, 5, 5, 80, 15, 76, 140, 5, 109, 5, - /* 660 */ 5, 5, 105, 139, 16, 140, 5, 5, 5, 5, - /* 670 */ 5, 138, 5, 5, 140, 5, 5, 5, 5, 5, - /* 680 */ 139, 138, 5, 5, 5, 5, 5, 109, 80, 60, - /* 690 */ 21, 59, 0, 264, 264, 264, 21, 264, 264, 264, - /* 700 */ 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, + /* 300 */ 63, 64, 134, 191, 136, 191, 69, 70, 71, 72, + /* 310 */ 68, 143, 62, 63, 64, 78, 33, 34, 252, 69, + /* 320 */ 70, 71, 72, 191, 68, 104, 60, 228, 229, 230, + /* 330 */ 231, 191, 111, 191, 104, 62, 63, 64, 117, 210, + /* 340 */ 210, 111, 69, 70, 71, 72, 232, 117, 191, 235, + /* 350 */ 117, 33, 34, 37, 133, 37, 38, 39, 191, 135, + /* 360 */ 191, 210, 191, 133, 232, 236, 236, 235, 144, 145, + /* 370 */ 104, 259, 232, 15, 232, 235, 104, 235, 252, 137, + /* 380 */ 108, 139, 110, 141, 142, 109, 117, 236, 1, 232, + /* 390 */ 76, 77, 235, 137, 111, 139, 196, 141, 142, 232, + /* 400 */ 200, 232, 235, 232, 235, 129, 235, 65, 66, 67, + /* 410 */ 62, 63, 64, 196, 105, 196, 109, 200, 109, 200, + /* 420 */ 124, 125, 105, 236, 37, 105, 109, 252, 105, 109, + /* 430 */ 105, 115, 109, 105, 109, 105, 105, 109, 131, 109, + /* 440 */ 109, 105, 105, 105, 252, 109, 109, 109, 104, 252, + /* 450 */ 138, 107, 140, 138, 104, 140, 106, 252, 252, 138, + /* 460 */ 138, 140, 140, 252, 138, 138, 140, 140, 5, 111, + /* 470 */ 7, 5, 252, 7, 252, 236, 236, 252, 252, 252, + /* 480 */ 227, 227, 227, 191, 227, 227, 227, 227, 191, 191, + /* 490 */ 191, 191, 251, 191, 191, 234, 234, 191, 260, 191, + /* 500 */ 60, 238, 234, 260, 191, 256, 225, 256, 256, 117, + /* 510 */ 191, 103, 248, 242, 247, 191, 246, 240, 122, 245, + /* 520 */ 191, 256, 127, 191, 191, 191, 191, 128, 130, 126, + /* 530 */ 191, 191, 191, 244, 191, 121, 191, 191, 191, 120, + /* 540 */ 191, 119, 191, 191, 191, 191, 191, 191, 191, 118, + /* 550 */ 191, 191, 191, 191, 191, 191, 191, 191, 191, 191, + /* 560 */ 191, 191, 191, 191, 191, 191, 191, 191, 191, 191, + /* 570 */ 191, 191, 191, 191, 191, 191, 191, 191, 132, 191, + /* 580 */ 87, 192, 192, 192, 86, 192, 192, 50, 83, 85, + /* 590 */ 54, 84, 82, 192, 192, 79, 5, 192, 146, 5, + /* 600 */ 5, 192, 192, 197, 197, 146, 5, 5, 90, 89, + /* 610 */ 135, 114, 113, 192, 105, 107, 192, 202, 206, 208, + /* 620 */ 207, 205, 204, 203, 201, 193, 193, 193, 192, 194, + /* 630 */ 193, 192, 104, 192, 104, 109, 198, 105, 109, 104, + /* 640 */ 243, 241, 225, 239, 105, 104, 1, 109, 104, 109, + /* 650 */ 105, 104, 109, 105, 123, 104, 123, 111, 104, 104, + /* 660 */ 107, 104, 76, 9, 108, 5, 5, 5, 5, 5, + /* 670 */ 80, 15, 76, 16, 140, 109, 5, 5, 105, 5, + /* 680 */ 5, 16, 140, 5, 5, 5, 5, 5, 5, 140, + /* 690 */ 140, 5, 5, 5, 5, 5, 5, 5, 5, 5, + /* 700 */ 80, 109, 60, 59, 0, 21, 21, 264, 264, 264, /* 710 */ 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, /* 720 */ 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, /* 730 */ 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, @@ -376,106 +377,107 @@ static const YYCODETYPE yy_lookahead[] = { /* 850 */ 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, /* 860 */ 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, /* 870 */ 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, - /* 880 */ 264, 264, 264, 264, 264, + /* 880 */ 264, 264, 264, 264, 264, 264, 264, 264, 264, 264, + /* 890 */ 264, 264, 264, 264, 264, }; -#define YY_SHIFT_COUNT (330) +#define YY_SHIFT_COUNT (336) #define YY_SHIFT_MIN (0) -#define YY_SHIFT_MAX (692) +#define YY_SHIFT_MAX (704) static const unsigned short int yy_shift_ofst[] = { /* 0 */ 168, 79, 79, 180, 180, 3, 221, 230, 110, 121, - /* 10 */ 121, 121, 121, 121, 121, 121, 121, 121, 0, 48, - /* 20 */ 230, 283, 283, 283, 283, 45, 45, 121, 121, 121, - /* 30 */ 29, 121, 121, 171, 3, 8, 8, 697, 697, 697, - /* 40 */ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, + /* 10 */ 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, + /* 20 */ 121, 121, 0, 48, 230, 283, 283, 283, 283, 45, + /* 30 */ 45, 121, 121, 121, 29, 121, 121, 208, 3, 8, + /* 40 */ 8, 707, 707, 707, 230, 230, 230, 230, 230, 230, /* 50 */ 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, - /* 60 */ 283, 283, 25, 25, 25, 25, 25, 25, 25, 121, - /* 70 */ 121, 121, 174, 121, 121, 121, 45, 45, 121, 121, - /* 80 */ 121, 276, 276, 194, 45, 121, 121, 121, 121, 121, + /* 60 */ 230, 230, 230, 230, 283, 283, 283, 25, 25, 25, + /* 70 */ 25, 25, 25, 25, 121, 121, 121, 316, 121, 121, + /* 80 */ 121, 45, 45, 121, 121, 121, 296, 296, 95, 45, /* 90 */ 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, /* 100 */ 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, /* 110 */ 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, /* 120 */ 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, - /* 130 */ 121, 121, 121, 121, 121, 121, 121, 121, 424, 424, - /* 140 */ 424, 373, 373, 373, 424, 373, 424, 377, 376, 380, - /* 150 */ 387, 388, 378, 393, 403, 442, 420, 424, 424, 424, - /* 160 */ 459, 3, 3, 424, 424, 478, 482, 519, 487, 486, - /* 170 */ 518, 489, 493, 459, 424, 498, 498, 424, 498, 424, - /* 180 */ 498, 424, 424, 697, 697, 27, 100, 127, 100, 100, - /* 190 */ 53, 182, 223, 223, 223, 223, 237, 250, 273, 318, - /* 200 */ 318, 318, 318, 256, 258, 215, 207, 207, 269, 361, - /* 210 */ 130, 305, 312, 297, 154, 160, 298, 299, 300, 306, - /* 220 */ 308, 216, 322, 303, 281, 301, 313, 314, 315, 316, - /* 230 */ 323, 97, 289, 293, 296, 331, 302, 434, 438, 370, - /* 240 */ 574, 435, 575, 577, 439, 583, 584, 501, 503, 458, - /* 250 */ 483, 488, 508, 502, 492, 511, 509, 510, 515, 522, - /* 260 */ 523, 520, 526, 626, 527, 528, 530, 529, 512, 531, - /* 270 */ 513, 532, 535, 521, 537, 488, 538, 536, 540, 539, - /* 280 */ 569, 637, 643, 644, 645, 646, 647, 573, 639, 579, - /* 290 */ 516, 652, 524, 533, 549, 549, 648, 525, 534, 654, - /* 300 */ 541, 543, 549, 655, 656, 557, 549, 661, 662, 663, - /* 310 */ 664, 665, 667, 668, 670, 671, 672, 673, 674, 677, - /* 320 */ 678, 679, 680, 681, 578, 608, 669, 675, 629, 632, - /* 330 */ 692, + /* 130 */ 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, + /* 140 */ 121, 121, 440, 440, 440, 392, 392, 392, 440, 392, + /* 150 */ 440, 399, 398, 395, 396, 403, 414, 419, 422, 431, + /* 160 */ 446, 440, 440, 440, 408, 3, 3, 440, 440, 493, + /* 170 */ 498, 537, 505, 504, 536, 507, 510, 408, 440, 516, + /* 180 */ 516, 440, 516, 440, 516, 440, 440, 707, 707, 27, + /* 190 */ 100, 127, 100, 100, 53, 182, 223, 223, 223, 223, + /* 200 */ 237, 250, 273, 318, 318, 318, 318, 242, 256, 224, + /* 210 */ 207, 207, 233, 269, 272, 342, 348, 309, 154, 160, + /* 220 */ 317, 320, 323, 325, 328, 387, 266, 358, 307, 276, + /* 230 */ 330, 331, 336, 337, 338, 344, 312, 315, 321, 322, + /* 240 */ 326, 350, 327, 463, 466, 314, 591, 452, 594, 595, + /* 250 */ 459, 601, 602, 518, 520, 475, 499, 508, 528, 497, + /* 260 */ 509, 530, 526, 529, 532, 535, 539, 538, 541, 645, + /* 270 */ 544, 545, 547, 540, 531, 543, 533, 548, 551, 546, + /* 280 */ 554, 508, 555, 553, 557, 556, 586, 654, 660, 661, + /* 290 */ 662, 663, 664, 590, 656, 596, 657, 534, 542, 566, + /* 300 */ 566, 566, 566, 665, 549, 550, 566, 566, 566, 671, + /* 310 */ 672, 573, 566, 674, 675, 678, 679, 680, 681, 682, + /* 320 */ 683, 686, 687, 688, 689, 690, 691, 692, 693, 694, + /* 330 */ 592, 620, 684, 685, 642, 644, 704, }; -#define YY_REDUCE_COUNT (184) +#define YY_REDUCE_COUNT (188) #define YY_REDUCE_MIN (-247) -#define YY_REDUCE_MAX (423) +#define YY_REDUCE_MAX (441) static const short yy_reduce_ofst[] = { /* 0 */ -178, -27, -27, 74, 74, 99, -244, -217, -119, -76, - /* 10 */ -176, -128, -8, 34, 114, 132, 148, 149, -191, -188, - /* 20 */ -221, -204, 151, 152, 155, -227, -16, -46, 157, -33, - /* 30 */ -113, -84, -123, 173, -193, 189, 196, -162, -36, 183, - /* 40 */ -247, -240, -106, 32, 101, 106, 186, 192, 197, 198, - /* 50 */ 199, 200, 201, 202, 203, 204, 205, 206, 208, 209, - /* 60 */ 143, 212, 232, 235, 236, 238, 239, 240, 241, 278, - /* 70 */ 279, 280, 213, 282, 284, 285, 243, 245, 290, 291, - /* 80 */ 292, 214, 220, 234, 251, 295, 304, 307, 309, 310, - /* 90 */ 311, 317, 319, 320, 321, 324, 325, 326, 327, 328, - /* 100 */ 329, 330, 332, 333, 334, 335, 336, 337, 338, 339, - /* 110 */ 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, - /* 120 */ 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - /* 130 */ 360, 362, 363, 364, 365, 366, 367, 368, 369, 371, - /* 140 */ 372, 231, 233, 247, 374, 248, 375, 244, 246, 242, - /* 150 */ 249, 252, 254, 379, 381, 383, 385, 382, 384, 386, - /* 160 */ 266, 389, 390, 391, 392, 394, 396, 395, 397, 399, - /* 170 */ 402, 404, 405, 400, 398, 401, 407, 406, 414, 417, - /* 180 */ 418, 421, 422, 412, 423, + /* 10 */ -176, -128, -8, 34, 114, 132, 140, 142, 157, 167, + /* 20 */ 169, 171, -191, -188, -221, -204, 129, 130, 151, -227, + /* 30 */ -16, -46, 112, -33, -113, -84, -123, 200, -193, 217, + /* 40 */ 219, -162, -36, 58, -247, -240, -106, -51, -35, -18, + /* 50 */ -5, 66, 126, 175, 192, 197, 205, 206, 211, 220, + /* 60 */ 222, 225, 226, 227, 187, 239, 240, 253, 254, 255, + /* 70 */ 257, 258, 259, 260, 292, 297, 298, 241, 299, 300, + /* 80 */ 302, 261, 262, 303, 306, 308, 238, 243, 263, 268, + /* 90 */ 313, 319, 324, 329, 332, 333, 334, 335, 339, 340, + /* 100 */ 341, 343, 345, 346, 347, 349, 351, 352, 353, 354, + /* 110 */ 355, 356, 357, 359, 360, 361, 362, 363, 364, 365, + /* 120 */ 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + /* 130 */ 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, + /* 140 */ 386, 388, 389, 390, 391, 249, 251, 252, 393, 265, + /* 150 */ 394, 264, 267, 270, 274, 289, 397, 271, 400, 277, + /* 160 */ 404, 401, 402, 405, 281, 406, 407, 409, 410, 411, + /* 170 */ 413, 412, 415, 416, 420, 418, 423, 417, 421, 432, + /* 180 */ 433, 424, 434, 436, 437, 439, 441, 438, 435, }; static const YYACTIONTYPE yy_default[] = { - /* 0 */ 803, 916, 862, 928, 850, 859, 1062, 1062, 803, 803, - /* 10 */ 803, 803, 803, 803, 803, 803, 803, 803, 975, 822, - /* 20 */ 1062, 803, 803, 803, 803, 803, 803, 803, 803, 803, - /* 30 */ 859, 803, 803, 865, 859, 865, 865, 970, 900, 918, - /* 40 */ 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, - /* 50 */ 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, - /* 60 */ 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, - /* 70 */ 803, 803, 977, 983, 980, 803, 803, 803, 985, 803, - /* 80 */ 803, 1005, 1005, 968, 803, 803, 803, 803, 803, 803, - /* 90 */ 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, - /* 100 */ 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, - /* 110 */ 803, 803, 803, 803, 848, 803, 846, 803, 803, 803, - /* 120 */ 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, - /* 130 */ 803, 833, 803, 803, 803, 803, 803, 803, 824, 824, - /* 140 */ 824, 803, 803, 803, 824, 803, 824, 1012, 1016, 1010, - /* 150 */ 998, 1006, 997, 993, 991, 990, 1020, 824, 824, 824, - /* 160 */ 863, 859, 859, 824, 824, 881, 879, 877, 869, 875, - /* 170 */ 871, 873, 867, 851, 824, 857, 857, 824, 857, 824, - /* 180 */ 857, 824, 824, 900, 918, 803, 1021, 803, 1061, 1011, - /* 190 */ 1051, 1050, 1057, 1049, 1048, 1047, 803, 803, 803, 1043, - /* 200 */ 1044, 1046, 1045, 803, 803, 803, 1053, 1052, 803, 803, - /* 210 */ 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, - /* 220 */ 803, 803, 1023, 803, 1017, 1013, 803, 803, 803, 803, - /* 230 */ 803, 803, 803, 803, 803, 930, 803, 803, 803, 803, - /* 240 */ 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, - /* 250 */ 967, 803, 803, 803, 803, 803, 979, 978, 803, 803, - /* 260 */ 803, 803, 803, 803, 803, 803, 803, 1007, 803, 999, - /* 270 */ 803, 803, 803, 803, 803, 942, 803, 803, 803, 803, - /* 280 */ 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, - /* 290 */ 803, 803, 803, 803, 1075, 1072, 803, 803, 803, 803, - /* 300 */ 803, 803, 1068, 803, 803, 803, 1065, 803, 803, 803, - /* 310 */ 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, - /* 320 */ 803, 803, 803, 803, 884, 803, 831, 829, 803, 820, - /* 330 */ 803, + /* 0 */ 811, 924, 870, 936, 858, 867, 1070, 1070, 811, 811, + /* 10 */ 811, 811, 811, 811, 811, 811, 811, 811, 811, 811, + /* 20 */ 811, 811, 983, 830, 1070, 811, 811, 811, 811, 811, + /* 30 */ 811, 811, 811, 811, 867, 811, 811, 873, 867, 873, + /* 40 */ 873, 978, 908, 926, 811, 811, 811, 811, 811, 811, + /* 50 */ 811, 811, 811, 811, 811, 811, 811, 811, 811, 811, + /* 60 */ 811, 811, 811, 811, 811, 811, 811, 811, 811, 811, + /* 70 */ 811, 811, 811, 811, 811, 811, 811, 985, 991, 988, + /* 80 */ 811, 811, 811, 993, 811, 811, 1013, 1013, 976, 811, + /* 90 */ 811, 811, 811, 811, 811, 811, 811, 811, 811, 811, + /* 100 */ 811, 811, 811, 811, 811, 811, 811, 811, 811, 811, + /* 110 */ 811, 811, 811, 811, 811, 811, 811, 811, 856, 811, + /* 120 */ 854, 811, 811, 811, 811, 811, 811, 811, 811, 811, + /* 130 */ 811, 811, 811, 811, 811, 841, 811, 811, 811, 811, + /* 140 */ 811, 811, 832, 832, 832, 811, 811, 811, 832, 811, + /* 150 */ 832, 1020, 1024, 1018, 1006, 1014, 1005, 1001, 999, 998, + /* 160 */ 1028, 832, 832, 832, 871, 867, 867, 832, 832, 889, + /* 170 */ 887, 885, 877, 883, 879, 881, 875, 859, 832, 865, + /* 180 */ 865, 832, 865, 832, 865, 832, 832, 908, 926, 811, + /* 190 */ 1029, 811, 1069, 1019, 1059, 1058, 1065, 1057, 1056, 1055, + /* 200 */ 811, 811, 811, 1051, 1052, 1054, 1053, 811, 811, 811, + /* 210 */ 1061, 1060, 811, 811, 811, 811, 811, 811, 811, 811, + /* 220 */ 811, 811, 811, 811, 811, 811, 1031, 811, 1025, 1021, + /* 230 */ 811, 811, 811, 811, 811, 811, 811, 811, 811, 811, + /* 240 */ 811, 938, 811, 811, 811, 811, 811, 811, 811, 811, + /* 250 */ 811, 811, 811, 811, 811, 811, 975, 811, 811, 811, + /* 260 */ 811, 811, 987, 986, 811, 811, 811, 811, 811, 811, + /* 270 */ 811, 811, 811, 1015, 811, 1007, 811, 811, 811, 811, + /* 280 */ 811, 950, 811, 811, 811, 811, 811, 811, 811, 811, + /* 290 */ 811, 811, 811, 811, 811, 811, 811, 811, 811, 1088, + /* 300 */ 1083, 1084, 1081, 811, 811, 811, 1080, 1075, 1076, 811, + /* 310 */ 811, 811, 1073, 811, 811, 811, 811, 811, 811, 811, + /* 320 */ 811, 811, 811, 811, 811, 811, 811, 811, 811, 811, + /* 330 */ 892, 811, 839, 837, 811, 828, 811, }; /********** End of lemon-generated parsing tables *****************************/ @@ -634,7 +636,7 @@ static const YYCODETYPE yyFallback[] = { 0, /* SYNCDB => nothing */ 0, /* ADD => nothing */ 0, /* COLUMN => nothing */ - 0, /* LENGTH => nothing */ + 0, /* MODIFY => nothing */ 0, /* TAG => nothing */ 0, /* CHANGE => nothing */ 0, /* SET => nothing */ @@ -909,7 +911,7 @@ static const char *const yyTokenName[] = { /* 136 */ "SYNCDB", /* 137 */ "ADD", /* 138 */ "COLUMN", - /* 139 */ "LENGTH", + /* 139 */ "MODIFY", /* 140 */ "TAG", /* 141 */ "CHANGE", /* 142 */ "SET", @@ -1302,20 +1304,23 @@ static const char *const yyRuleName[] = { /* 258 */ "cmd ::= SYNCDB ids REPLICA", /* 259 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist", /* 260 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids", - /* 261 */ "cmd ::= ALTER TABLE ids cpxName ALTER COLUMN LENGTH ids INTEGER", + /* 261 */ "cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist", /* 262 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist", /* 263 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids", /* 264 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids", /* 265 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem", - /* 266 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist", - /* 267 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids", - /* 268 */ "cmd ::= ALTER STABLE ids cpxName ALTER COLUMN LENGTH ids INTEGER", - /* 269 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist", - /* 270 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids", - /* 271 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids", - /* 272 */ "cmd ::= KILL CONNECTION INTEGER", - /* 273 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER", - /* 274 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER", + /* 266 */ "cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist", + /* 267 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist", + /* 268 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids", + /* 269 */ "cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist", + /* 270 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist", + /* 271 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids", + /* 272 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids", + /* 273 */ "cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem", + /* 274 */ "cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist", + /* 275 */ "cmd ::= KILL CONNECTION INTEGER", + /* 276 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER", + /* 277 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER", }; #endif /* NDEBUG */ @@ -2043,20 +2048,23 @@ static const YYCODETYPE yyRuleInfoLhs[] = { 189, /* (258) cmd ::= SYNCDB ids REPLICA */ 189, /* (259) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */ 189, /* (260) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */ - 189, /* (261) cmd ::= ALTER TABLE ids cpxName ALTER COLUMN LENGTH ids INTEGER */ + 189, /* (261) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */ 189, /* (262) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ 189, /* (263) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ 189, /* (264) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ 189, /* (265) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ - 189, /* (266) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ - 189, /* (267) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ - 189, /* (268) cmd ::= ALTER STABLE ids cpxName ALTER COLUMN LENGTH ids INTEGER */ - 189, /* (269) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ - 189, /* (270) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ - 189, /* (271) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ - 189, /* (272) cmd ::= KILL CONNECTION INTEGER */ - 189, /* (273) cmd ::= KILL STREAM INTEGER COLON INTEGER */ - 189, /* (274) cmd ::= KILL QUERY INTEGER COLON INTEGER */ + 189, /* (266) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */ + 189, /* (267) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ + 189, /* (268) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ + 189, /* (269) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */ + 189, /* (270) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ + 189, /* (271) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ + 189, /* (272) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ + 189, /* (273) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */ + 189, /* (274) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */ + 189, /* (275) cmd ::= KILL CONNECTION INTEGER */ + 189, /* (276) cmd ::= KILL STREAM INTEGER COLON INTEGER */ + 189, /* (277) cmd ::= KILL QUERY INTEGER COLON INTEGER */ }; /* For rule J, yyRuleInfoNRhs[J] contains the negative of the number @@ -2323,20 +2331,23 @@ static const signed char yyRuleInfoNRhs[] = { -3, /* (258) cmd ::= SYNCDB ids REPLICA */ -7, /* (259) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */ -7, /* (260) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */ - -9, /* (261) cmd ::= ALTER TABLE ids cpxName ALTER COLUMN LENGTH ids INTEGER */ + -7, /* (261) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */ -7, /* (262) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ -7, /* (263) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ -8, /* (264) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ -9, /* (265) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ - -7, /* (266) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ - -7, /* (267) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ - -9, /* (268) cmd ::= ALTER STABLE ids cpxName ALTER COLUMN LENGTH ids INTEGER */ - -7, /* (269) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ - -7, /* (270) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ - -8, /* (271) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ - -3, /* (272) cmd ::= KILL CONNECTION INTEGER */ - -5, /* (273) cmd ::= KILL STREAM INTEGER COLON INTEGER */ - -5, /* (274) cmd ::= KILL QUERY INTEGER COLON INTEGER */ + -7, /* (266) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */ + -7, /* (267) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ + -7, /* (268) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ + -7, /* (269) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */ + -7, /* (270) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ + -7, /* (271) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ + -8, /* (272) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ + -9, /* (273) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */ + -7, /* (274) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */ + -3, /* (275) cmd ::= KILL CONNECTION INTEGER */ + -5, /* (276) cmd ::= KILL STREAM INTEGER COLON INTEGER */ + -5, /* (277) cmd ::= KILL QUERY INTEGER COLON INTEGER */ }; static void yy_accept(yyParser*); /* Forward Declaration */ @@ -3340,16 +3351,10 @@ static YYACTIONTYPE yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 261: /* cmd ::= ALTER TABLE ids cpxName ALTER COLUMN LENGTH ids INTEGER */ + case 261: /* cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */ { - yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n; - - toTSDBType(yymsp[-1].minor.yy0.type); - SArray* K = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1); - toTSDBType(yymsp[0].minor.yy0.type); - K = tVariantListAppendToken(K, &yymsp[0].minor.yy0, -1); - - SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, K, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1); + yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy285, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; @@ -3397,14 +3402,21 @@ static YYACTIONTYPE yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 266: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ + case 266: /* cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */ +{ + yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy285, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, -1); + setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); +} + break; + case 267: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy285, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 267: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ + case 268: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; @@ -3415,27 +3427,21 @@ static YYACTIONTYPE yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 268: /* cmd ::= ALTER STABLE ids cpxName ALTER COLUMN LENGTH ids INTEGER */ + case 269: /* cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */ { - yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n; - - toTSDBType(yymsp[-1].minor.yy0.type); - SArray* K = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1); - toTSDBType(yymsp[0].minor.yy0.type); - K = tVariantListAppendToken(K, &yymsp[0].minor.yy0, -1); - - SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, K, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE); + yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy285, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 269: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ + case 270: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy285, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE); setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 270: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ + case 271: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ { yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; @@ -3446,7 +3452,7 @@ static YYACTIONTYPE yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 271: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ + case 272: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ { yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n; @@ -3460,13 +3466,32 @@ static YYACTIONTYPE yy_reduce( setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); } break; - case 272: /* cmd ::= KILL CONNECTION INTEGER */ + case 273: /* cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */ +{ + yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n; + + toTSDBType(yymsp[-2].minor.yy0.type); + SArray* A = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1); + A = tVariantListAppend(A, &yymsp[0].minor.yy362, -1); + + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, TSDB_SUPER_TABLE); + setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); +} + break; + case 274: /* cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */ +{ + yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; + SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy285, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, TSDB_SUPER_TABLE); + setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); +} + break; + case 275: /* cmd ::= KILL CONNECTION INTEGER */ {setKillSql(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);} break; - case 273: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */ + case 276: /* 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 274: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */ + case 277: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */ {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_QUERY, &yymsp[-2].minor.yy0);} break; default: diff --git a/src/util/src/ttokenizer.c b/src/util/src/ttokenizer.c index 24852abbf2..0e661e84c5 100644 --- a/src/util/src/ttokenizer.c +++ b/src/util/src/ttokenizer.c @@ -218,7 +218,7 @@ static SKeyword keywordTable[] = { {"PARTITIONS", TK_PARTITIONS}, {"TOPIC", TK_TOPIC}, {"TOPICS", TK_TOPICS}, - {"LENGTH", TK_LENGTH} + {"MODIFY", TK_MODIFY} }; static const char isIdChar[] = { diff --git a/tests/script/general/parser/alter_column.sim b/tests/script/general/parser/alter_column.sim index 7f30498d06..fe109352d1 100644 --- a/tests/script/general/parser/alter_column.sim +++ b/tests/script/general/parser/alter_column.sim @@ -25,20 +25,49 @@ sql use $db ##### alter table test, simeplest case sql create table tb (ts timestamp, c1 int, c2 binary(10), c3 nchar(10)) sql insert into tb values (now, 1, "1", "1") -sql alter table tb alter column length c2 20; +sql alter table tb modify column c2 binary(20); if $rows != 0 then return -1 endi -sql alter table tb alter column length c3 20; +sql alter table tb modify column c3 nchar(20); if $rows != 0 then return -1 endi -sql create stable stb (ts timestamp, c1 int, c2 binary(10), c3 nchar(10)) tags(id int) -sql create table tb1 using stb tags(1) +sql create stable stb (ts timestamp, c1 int, c2 binary(10), c3 nchar(10)) tags(id1 int, id2 binary(10), id3 nchar(10)) +sql create table tb1 using stb tags(1, "a", "b") sql insert into tb1 values (now, 1, "1", "1") -sql alter stable stb alter column length c2 20; +sql alter stable stb modify column c2 binary(20); +if $rows != 0 then + return -1 +endi +sql alter table stb modify column c2 binary(30); +if $rows != 0 then + return -1 +endi +sql alter stable stb modify column c3 nchar(20); +if $rows != 0 then + return -1 +endi +sql alter table stb modify column c3 nchar(30); +if $rows != 0 then + return -1 +endi + +sql alter table stb modify tag id2 binary(11); +if $rows != 0 then + return -1 +endi +sql alter stable stb modify tag id2 binary(11); +if $rows != 0 then + return -1 +endi +sql alter table stb modify tag id3 nchar(11); +if $rows != 0 then + return -1 +endi +sql alter stable stb modify tag id3 nchar(11); if $rows != 0 then return -1 endi @@ -46,10 +75,44 @@ endi ##### ILLEGAL OPERATIONS # try dropping columns that are defined in metric -sql_error alter table tb alter column length c1 10; -sql_error alter stable tb alter column length c2 10; -sql_error alter table tb1 alter column length c2 10; -sql_error alter stable tb1 alter column length c2 10; +sql_error alter table tb modify column c1 binary(10); +sql_error alter table tb modify column c1 double; +sql_error alter table tb modify column c2 int; +sql_error alter table tb modify column c2 binary(10); +sql_error alter table tb modify column c2 binary(9); +sql_error alter table tb modify column c2 binary(-9); +sql_error alter table tb modify column c2 binary(0); +sql_error alter table tb modify column c2 binary(17000); +sql_error alter table tb modify column c2 nchar(30); +sql_error alter table tb modify column c3 double; +sql_error alter table tb modify column c3 nchar(10); +sql_error alter table tb modify column c3 nchar(0); +sql_error alter table tb modify column c3 nchar(-1); +sql_error alter table tb modify column c3 binary(80); +sql_error alter table tb modify column c3 nchar(17000); +sql_error alter table tb modify column c3 nchar(100), c2 binary(30); +sql_error alter table tb modify column c1 nchar(100), c2 binary(30); +sql_error alter stable tb modify column c2 binary(30); +sql_error alter table tb modify tag c2 binary(30); +sql_error alter table stb modify tag id2 binary(10); +sql_error alter table stb modify tag id2 nchar(30); +sql_error alter stable stb modify tag id2 binary(10); +sql_error alter stable stb modify tag id2 nchar(30); +sql_error alter table stb modify tag id3 nchar(10); +sql_error alter table stb modify tag id3 binary(30); +sql_error alter stable stb modify tag id3 nchar(10); +sql_error alter stable stb modify tag id3 binary(30); +sql_error alter stable stb modify tag id1 binary(30); +sql_error alter stable stb modify tag c1 binary(30); + + +sql_error alter table tb1 modify column c2 binary(30); +sql_error alter table tb1 modify column c3 nchar(30); +sql_error alter table tb1 modify tag id2 binary(30); +sql_error alter table tb1 modify tag id3 nchar(30); +sql_error alter stable tb1 modify tag id2 binary(30); +sql_error alter stable tb1 modify tag id3 nchar(30); +sql_error alter stable tb1 modify column c2 binary(30); system sh/exec.sh -n dnode1 -s stop -x SIGINT From 2bcd1f5a597f0d5a4acc1d340845fed48e729186 Mon Sep 17 00:00:00 2001 From: dapan1121 <89396746@qq.com> Date: Wed, 2 Jun 2021 15:25:32 +0800 Subject: [PATCH 25/26] fix windows compile issue --- src/client/src/tscSQLParser.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c index e41a9cb56b..a634362cf2 100644 --- a/src/client/src/tscSQLParser.c +++ b/src/client/src/tscSQLParser.c @@ -5410,7 +5410,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { } SColumnIndex columnIndex = COLUMN_INDEX_INITIALIZER; - SStrToken name = {.type = TK_STRING, .z = pItem->name, .n = strlen(pItem->name)}; + SStrToken name = {.type = TK_STRING, .z = pItem->name, .n = (uint32_t)strlen(pItem->name)}; if (getColumnIndexByName(pCmd, &name, pQueryInfo, &columnIndex) != TSDB_CODE_SUCCESS) { return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg17); } @@ -5447,7 +5447,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) { } SColumnIndex columnIndex = COLUMN_INDEX_INITIALIZER; - SStrToken name = {.type = TK_STRING, .z = pItem->name, .n = strlen(pItem->name)}; + SStrToken name = {.type = TK_STRING, .z = pItem->name, .n = (uint32_t)strlen(pItem->name)}; if (getColumnIndexByName(pCmd, &name, pQueryInfo, &columnIndex) != TSDB_CODE_SUCCESS) { return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg17); } From b141d31939151c9903f1680bb0d96606b4f26ac1 Mon Sep 17 00:00:00 2001 From: Shuduo Sang Date: Wed, 2 Jun 2021 23:11:44 +0800 Subject: [PATCH 26/26] [TD-4507]: disable jdbc build on windows for appveyor. (#6352) --- .appveyor.yml | 98 ++++++++++++++++++++++++------------------------- cmake/env.inc | 14 ++++--- cmake/input.inc | 6 +++ 3 files changed, 63 insertions(+), 55 deletions(-) diff --git a/.appveyor.yml b/.appveyor.yml index ee1dc91767..e7802b3d0d 100644 --- a/.appveyor.yml +++ b/.appveyor.yml @@ -1,49 +1,49 @@ -version: 1.0.{build} -image: - - Visual Studio 2015 - - macos -environment: - matrix: - - ARCH: amd64 - - ARCH: x86 -matrix: - exclude: - - image: macos - ARCH: x86 -for: - - - matrix: - only: - - image: Visual Studio 2015 - clone_folder: c:\dev\TDengine - clone_depth: 1 - - init: - - call "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" %ARCH% - - before_build: - - cd c:\dev\TDengine - - md build - - build_script: - - cd build - - cmake -G "NMake Makefiles" .. - - nmake install - - - matrix: - only: - - image: macos - clone_depth: 1 - - build_script: - - mkdir debug - - cd debug - - cmake .. > /dev/null - - make > /dev/null -notifications: -- provider: Email - to: - - sangshuduo@gmail.com - on_build_success: true - on_build_failure: true - on_build_status_changed: true +version: 1.0.{build} +image: + - Visual Studio 2015 + - macos +environment: + matrix: + - ARCH: amd64 + - ARCH: x86 +matrix: + exclude: + - image: macos + ARCH: x86 +for: + - + matrix: + only: + - image: Visual Studio 2015 + clone_folder: c:\dev\TDengine + clone_depth: 1 + + init: + - call "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" %ARCH% + + before_build: + - cd c:\dev\TDengine + - md build + + build_script: + - cd build + - cmake -G "NMake Makefiles" .. -DBUILD_JDBC=false + - nmake install + - + matrix: + only: + - image: macos + clone_depth: 1 + + build_script: + - mkdir debug + - cd debug + - cmake .. > /dev/null + - make > /dev/null +notifications: +- provider: Email + to: + - sangshuduo@gmail.com + on_build_success: true + on_build_failure: true + on_build_status_changed: true diff --git a/cmake/env.inc b/cmake/env.inc index 3989993953..6c1ce8fd89 100755 --- a/cmake/env.inc +++ b/cmake/env.inc @@ -14,11 +14,13 @@ MESSAGE(STATUS "Project binary files output path: " ${PROJECT_BINARY_DIR}) MESSAGE(STATUS "Project executable files output path: " ${EXECUTABLE_OUTPUT_PATH}) MESSAGE(STATUS "Project library files output path: " ${LIBRARY_OUTPUT_PATH}) -FIND_PROGRAM(TD_MVN_INSTALLED mvn) -IF (TD_MVN_INSTALLED) - MESSAGE(STATUS "MVN is installed and JDBC will be compiled") -ELSE () - MESSAGE(STATUS "MVN is not installed and JDBC is not compiled") +IF (TD_BUILD_JDBC) + FIND_PROGRAM(TD_MVN_INSTALLED mvn) + IF (TD_MVN_INSTALLED) + MESSAGE(STATUS "MVN is installed and JDBC will be compiled") + ELSE () + MESSAGE(STATUS "MVN is not installed and JDBC is not compiled") + ENDIF () ENDIF () # @@ -55,4 +57,4 @@ ELSE () SET(CMAKE_BUILD_TYPE "Debug") MESSAGE(STATUS "Build Debug Version as default") ENDIF() -ENDIF () \ No newline at end of file +ENDIF () diff --git a/cmake/input.inc b/cmake/input.inc index 543114ad09..9b72a35d94 100755 --- a/cmake/input.inc +++ b/cmake/input.inc @@ -77,3 +77,9 @@ IF (${JEMALLOC_ENABLED} MATCHES "true") SET(TD_JEMALLOC_ENABLED TRUE) MESSAGE(STATUS "build with jemalloc enabled") ENDIF () + +SET(TD_BUILD_JDBC TRUE) + +IF (${BUILD_JDBC} MATCHES "false") + SET(TD_BUILD_JDBC FALSE) +ENDIF ()