diff --git a/include/common/tdataformat.h b/include/common/tdataformat.h index b5971d8a9e..d7a62f5402 100644 --- a/include/common/tdataformat.h +++ b/include/common/tdataformat.h @@ -109,7 +109,7 @@ void tRowGet(SRow *pRow, STSchema *pTSchema, int32_t iCol, SColVal *pColVal); void tRowDestroy(SRow *pRow); void tRowSort(SArray *aRowP); int32_t tRowMerge(SArray *aRowP, STSchema *pTSchema, int8_t flag); -int32_t tRowAppendToColData(SRow *pRow, STSchema *pTSchema, SColData *aColData, int32_t nColData); +int32_t tRowUpsertColData(SRow *pRow, STSchema *pTSchema, SColData *aColData, int32_t nColData, int32_t flag); // SRowIter ================================ int32_t tRowIterOpen(SRow *pRow, STSchema *pTSchema, SRowIter **ppIter); @@ -137,6 +137,7 @@ void tColDataInit(SColData *pColData, int16_t cid, int8_t type, int8_t smaOn) void tColDataClear(SColData *pColData); void tColDataDeepClear(SColData *pColData); int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal); +int32_t tColDataUpdateValue(SColData *pColData, SColVal *pColVal, bool forward); void tColDataGetValue(SColData *pColData, int32_t iVal, SColVal *pColVal); uint8_t tColDataGetBitValue(const SColData *pColData, int32_t iVal); int32_t tColDataCopy(SColData *pColDataFrom, SColData *pColData, xMallocFn xMalloc, void *arg); @@ -200,6 +201,9 @@ struct SColData { int16_t cid; int8_t type; int8_t smaOn; + int32_t numOfNone; // # of none + int32_t numOfNull; // # of null + int32_t numOfValue; // # of vale int32_t nVal; uint8_t flag; uint8_t *pBitMap; diff --git a/include/common/tmsg.h b/include/common/tmsg.h index 7067ea0336..7d096a408b 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -1243,7 +1243,7 @@ int32_t tDeserializeSDropVnodeReq(void* buf, int32_t bufLen, SDropVnodeReq* pReq typedef struct { int64_t dbUid; char db[TSDB_DB_FNAME_LEN]; - int64_t reserved[8]; + int64_t compactStartTime; } SCompactVnodeReq; int32_t tSerializeSCompactVnodeReq(void* buf, int32_t bufLen, SCompactVnodeReq* pReq); diff --git a/include/common/ttokendef.h b/include/common/ttokendef.h index 25d52d4269..07649690f7 100644 --- a/include/common/ttokendef.h +++ b/include/common/ttokendef.h @@ -77,230 +77,230 @@ #define TK_USE 59 #define TK_FLUSH 60 #define TK_TRIM 61 -#define TK_IF 62 -#define TK_NOT 63 -#define TK_EXISTS 64 -#define TK_BUFFER 65 -#define TK_CACHEMODEL 66 -#define TK_CACHESIZE 67 -#define TK_COMP 68 -#define TK_DURATION 69 -#define TK_NK_VARIABLE 70 -#define TK_MAXROWS 71 -#define TK_MINROWS 72 -#define TK_KEEP 73 -#define TK_PAGES 74 -#define TK_PAGESIZE 75 -#define TK_TSDB_PAGESIZE 76 -#define TK_PRECISION 77 -#define TK_REPLICA 78 -#define TK_VGROUPS 79 -#define TK_SINGLE_STABLE 80 -#define TK_RETENTIONS 81 -#define TK_SCHEMALESS 82 -#define TK_WAL_LEVEL 83 -#define TK_WAL_FSYNC_PERIOD 84 -#define TK_WAL_RETENTION_PERIOD 85 -#define TK_WAL_RETENTION_SIZE 86 -#define TK_WAL_ROLL_PERIOD 87 -#define TK_WAL_SEGMENT_SIZE 88 -#define TK_STT_TRIGGER 89 -#define TK_TABLE_PREFIX 90 -#define TK_TABLE_SUFFIX 91 -#define TK_NK_COLON 92 -#define TK_MAX_SPEED 93 -#define TK_TABLE 94 -#define TK_NK_LP 95 -#define TK_NK_RP 96 -#define TK_STABLE 97 -#define TK_ADD 98 -#define TK_COLUMN 99 -#define TK_MODIFY 100 -#define TK_RENAME 101 -#define TK_TAG 102 -#define TK_SET 103 -#define TK_NK_EQ 104 -#define TK_USING 105 -#define TK_TAGS 106 -#define TK_COMMENT 107 -#define TK_BOOL 108 -#define TK_TINYINT 109 -#define TK_SMALLINT 110 -#define TK_INT 111 -#define TK_INTEGER 112 -#define TK_BIGINT 113 -#define TK_FLOAT 114 -#define TK_DOUBLE 115 -#define TK_BINARY 116 -#define TK_TIMESTAMP 117 -#define TK_NCHAR 118 -#define TK_UNSIGNED 119 -#define TK_JSON 120 -#define TK_VARCHAR 121 -#define TK_MEDIUMBLOB 122 -#define TK_BLOB 123 -#define TK_VARBINARY 124 -#define TK_DECIMAL 125 -#define TK_MAX_DELAY 126 -#define TK_WATERMARK 127 -#define TK_ROLLUP 128 -#define TK_TTL 129 -#define TK_SMA 130 -#define TK_DELETE_MARK 131 -#define TK_FIRST 132 -#define TK_LAST 133 -#define TK_SHOW 134 -#define TK_PRIVILEGES 135 -#define TK_DATABASES 136 -#define TK_TABLES 137 -#define TK_STABLES 138 -#define TK_MNODES 139 -#define TK_QNODES 140 -#define TK_FUNCTIONS 141 -#define TK_INDEXES 142 -#define TK_ACCOUNTS 143 -#define TK_APPS 144 -#define TK_CONNECTIONS 145 -#define TK_LICENCES 146 -#define TK_GRANTS 147 -#define TK_QUERIES 148 -#define TK_SCORES 149 -#define TK_TOPICS 150 -#define TK_VARIABLES 151 -#define TK_CLUSTER 152 -#define TK_BNODES 153 -#define TK_SNODES 154 -#define TK_TRANSACTIONS 155 -#define TK_DISTRIBUTED 156 -#define TK_CONSUMERS 157 -#define TK_SUBSCRIPTIONS 158 -#define TK_VNODES 159 -#define TK_ALIVE 160 -#define TK_LIKE 161 -#define TK_TBNAME 162 -#define TK_QTAGS 163 -#define TK_AS 164 -#define TK_INDEX 165 -#define TK_FUNCTION 166 -#define TK_INTERVAL 167 -#define TK_COUNT 168 -#define TK_LAST_ROW 169 -#define TK_TOPIC 170 -#define TK_WITH 171 -#define TK_META 172 -#define TK_CONSUMER 173 -#define TK_GROUP 174 -#define TK_DESC 175 -#define TK_DESCRIBE 176 -#define TK_RESET 177 -#define TK_QUERY 178 -#define TK_CACHE 179 -#define TK_EXPLAIN 180 -#define TK_ANALYZE 181 -#define TK_VERBOSE 182 -#define TK_NK_BOOL 183 -#define TK_RATIO 184 -#define TK_NK_FLOAT 185 -#define TK_OUTPUTTYPE 186 -#define TK_AGGREGATE 187 -#define TK_BUFSIZE 188 -#define TK_STREAM 189 -#define TK_INTO 190 -#define TK_TRIGGER 191 -#define TK_AT_ONCE 192 -#define TK_WINDOW_CLOSE 193 -#define TK_IGNORE 194 -#define TK_EXPIRED 195 -#define TK_FILL_HISTORY 196 -#define TK_SUBTABLE 197 -#define TK_KILL 198 -#define TK_CONNECTION 199 -#define TK_TRANSACTION 200 -#define TK_BALANCE 201 -#define TK_VGROUP 202 -#define TK_MERGE 203 -#define TK_REDISTRIBUTE 204 -#define TK_SPLIT 205 -#define TK_DELETE 206 -#define TK_INSERT 207 -#define TK_NULL 208 -#define TK_NK_QUESTION 209 -#define TK_NK_ARROW 210 -#define TK_ROWTS 211 -#define TK_QSTART 212 -#define TK_QEND 213 -#define TK_QDURATION 214 -#define TK_WSTART 215 -#define TK_WEND 216 -#define TK_WDURATION 217 -#define TK_IROWTS 218 -#define TK_ISFILLED 219 -#define TK_CAST 220 -#define TK_NOW 221 -#define TK_TODAY 222 -#define TK_TIMEZONE 223 -#define TK_CLIENT_VERSION 224 -#define TK_SERVER_VERSION 225 -#define TK_SERVER_STATUS 226 -#define TK_CURRENT_USER 227 -#define TK_CASE 228 -#define TK_END 229 -#define TK_WHEN 230 -#define TK_THEN 231 -#define TK_ELSE 232 -#define TK_BETWEEN 233 -#define TK_IS 234 -#define TK_NK_LT 235 -#define TK_NK_GT 236 -#define TK_NK_LE 237 -#define TK_NK_GE 238 -#define TK_NK_NE 239 -#define TK_MATCH 240 -#define TK_NMATCH 241 -#define TK_CONTAINS 242 -#define TK_IN 243 -#define TK_JOIN 244 -#define TK_INNER 245 -#define TK_SELECT 246 -#define TK_DISTINCT 247 -#define TK_WHERE 248 -#define TK_PARTITION 249 -#define TK_BY 250 -#define TK_SESSION 251 -#define TK_STATE_WINDOW 252 -#define TK_EVENT_WINDOW 253 -#define TK_START 254 -#define TK_SLIDING 255 -#define TK_FILL 256 -#define TK_VALUE 257 -#define TK_VALUE_F 258 -#define TK_NONE 259 -#define TK_PREV 260 -#define TK_NULL_F 261 -#define TK_LINEAR 262 -#define TK_NEXT 263 -#define TK_HAVING 264 -#define TK_RANGE 265 -#define TK_EVERY 266 -#define TK_ORDER 267 -#define TK_SLIMIT 268 -#define TK_SOFFSET 269 -#define TK_LIMIT 270 -#define TK_OFFSET 271 -#define TK_ASC 272 -#define TK_NULLS 273 -#define TK_ABORT 274 -#define TK_AFTER 275 -#define TK_ATTACH 276 -#define TK_BEFORE 277 -#define TK_BEGIN 278 -#define TK_BITAND 279 -#define TK_BITNOT 280 -#define TK_BITOR 281 -#define TK_BLOCKS 282 -#define TK_CHANGE 283 -#define TK_COMMA 284 -#define TK_COMPACT 285 +#define TK_COMPACT 62 +#define TK_IF 63 +#define TK_NOT 64 +#define TK_EXISTS 65 +#define TK_BUFFER 66 +#define TK_CACHEMODEL 67 +#define TK_CACHESIZE 68 +#define TK_COMP 69 +#define TK_DURATION 70 +#define TK_NK_VARIABLE 71 +#define TK_MAXROWS 72 +#define TK_MINROWS 73 +#define TK_KEEP 74 +#define TK_PAGES 75 +#define TK_PAGESIZE 76 +#define TK_TSDB_PAGESIZE 77 +#define TK_PRECISION 78 +#define TK_REPLICA 79 +#define TK_VGROUPS 80 +#define TK_SINGLE_STABLE 81 +#define TK_RETENTIONS 82 +#define TK_SCHEMALESS 83 +#define TK_WAL_LEVEL 84 +#define TK_WAL_FSYNC_PERIOD 85 +#define TK_WAL_RETENTION_PERIOD 86 +#define TK_WAL_RETENTION_SIZE 87 +#define TK_WAL_ROLL_PERIOD 88 +#define TK_WAL_SEGMENT_SIZE 89 +#define TK_STT_TRIGGER 90 +#define TK_TABLE_PREFIX 91 +#define TK_TABLE_SUFFIX 92 +#define TK_NK_COLON 93 +#define TK_MAX_SPEED 94 +#define TK_TABLE 95 +#define TK_NK_LP 96 +#define TK_NK_RP 97 +#define TK_STABLE 98 +#define TK_ADD 99 +#define TK_COLUMN 100 +#define TK_MODIFY 101 +#define TK_RENAME 102 +#define TK_TAG 103 +#define TK_SET 104 +#define TK_NK_EQ 105 +#define TK_USING 106 +#define TK_TAGS 107 +#define TK_COMMENT 108 +#define TK_BOOL 109 +#define TK_TINYINT 110 +#define TK_SMALLINT 111 +#define TK_INT 112 +#define TK_INTEGER 113 +#define TK_BIGINT 114 +#define TK_FLOAT 115 +#define TK_DOUBLE 116 +#define TK_BINARY 117 +#define TK_TIMESTAMP 118 +#define TK_NCHAR 119 +#define TK_UNSIGNED 120 +#define TK_JSON 121 +#define TK_VARCHAR 122 +#define TK_MEDIUMBLOB 123 +#define TK_BLOB 124 +#define TK_VARBINARY 125 +#define TK_DECIMAL 126 +#define TK_MAX_DELAY 127 +#define TK_WATERMARK 128 +#define TK_ROLLUP 129 +#define TK_TTL 130 +#define TK_SMA 131 +#define TK_DELETE_MARK 132 +#define TK_FIRST 133 +#define TK_LAST 134 +#define TK_SHOW 135 +#define TK_PRIVILEGES 136 +#define TK_DATABASES 137 +#define TK_TABLES 138 +#define TK_STABLES 139 +#define TK_MNODES 140 +#define TK_QNODES 141 +#define TK_FUNCTIONS 142 +#define TK_INDEXES 143 +#define TK_ACCOUNTS 144 +#define TK_APPS 145 +#define TK_CONNECTIONS 146 +#define TK_LICENCES 147 +#define TK_GRANTS 148 +#define TK_QUERIES 149 +#define TK_SCORES 150 +#define TK_TOPICS 151 +#define TK_VARIABLES 152 +#define TK_CLUSTER 153 +#define TK_BNODES 154 +#define TK_SNODES 155 +#define TK_TRANSACTIONS 156 +#define TK_DISTRIBUTED 157 +#define TK_CONSUMERS 158 +#define TK_SUBSCRIPTIONS 159 +#define TK_VNODES 160 +#define TK_ALIVE 161 +#define TK_LIKE 162 +#define TK_TBNAME 163 +#define TK_QTAGS 164 +#define TK_AS 165 +#define TK_INDEX 166 +#define TK_FUNCTION 167 +#define TK_INTERVAL 168 +#define TK_COUNT 169 +#define TK_LAST_ROW 170 +#define TK_TOPIC 171 +#define TK_WITH 172 +#define TK_META 173 +#define TK_CONSUMER 174 +#define TK_GROUP 175 +#define TK_DESC 176 +#define TK_DESCRIBE 177 +#define TK_RESET 178 +#define TK_QUERY 179 +#define TK_CACHE 180 +#define TK_EXPLAIN 181 +#define TK_ANALYZE 182 +#define TK_VERBOSE 183 +#define TK_NK_BOOL 184 +#define TK_RATIO 185 +#define TK_NK_FLOAT 186 +#define TK_OUTPUTTYPE 187 +#define TK_AGGREGATE 188 +#define TK_BUFSIZE 189 +#define TK_STREAM 190 +#define TK_INTO 191 +#define TK_TRIGGER 192 +#define TK_AT_ONCE 193 +#define TK_WINDOW_CLOSE 194 +#define TK_IGNORE 195 +#define TK_EXPIRED 196 +#define TK_FILL_HISTORY 197 +#define TK_SUBTABLE 198 +#define TK_KILL 199 +#define TK_CONNECTION 200 +#define TK_TRANSACTION 201 +#define TK_BALANCE 202 +#define TK_VGROUP 203 +#define TK_MERGE 204 +#define TK_REDISTRIBUTE 205 +#define TK_SPLIT 206 +#define TK_DELETE 207 +#define TK_INSERT 208 +#define TK_NULL 209 +#define TK_NK_QUESTION 210 +#define TK_NK_ARROW 211 +#define TK_ROWTS 212 +#define TK_QSTART 213 +#define TK_QEND 214 +#define TK_QDURATION 215 +#define TK_WSTART 216 +#define TK_WEND 217 +#define TK_WDURATION 218 +#define TK_IROWTS 219 +#define TK_ISFILLED 220 +#define TK_CAST 221 +#define TK_NOW 222 +#define TK_TODAY 223 +#define TK_TIMEZONE 224 +#define TK_CLIENT_VERSION 225 +#define TK_SERVER_VERSION 226 +#define TK_SERVER_STATUS 227 +#define TK_CURRENT_USER 228 +#define TK_CASE 229 +#define TK_END 230 +#define TK_WHEN 231 +#define TK_THEN 232 +#define TK_ELSE 233 +#define TK_BETWEEN 234 +#define TK_IS 235 +#define TK_NK_LT 236 +#define TK_NK_GT 237 +#define TK_NK_LE 238 +#define TK_NK_GE 239 +#define TK_NK_NE 240 +#define TK_MATCH 241 +#define TK_NMATCH 242 +#define TK_CONTAINS 243 +#define TK_IN 244 +#define TK_JOIN 245 +#define TK_INNER 246 +#define TK_SELECT 247 +#define TK_DISTINCT 248 +#define TK_WHERE 249 +#define TK_PARTITION 250 +#define TK_BY 251 +#define TK_SESSION 252 +#define TK_STATE_WINDOW 253 +#define TK_EVENT_WINDOW 254 +#define TK_START 255 +#define TK_SLIDING 256 +#define TK_FILL 257 +#define TK_VALUE 258 +#define TK_VALUE_F 259 +#define TK_NONE 260 +#define TK_PREV 261 +#define TK_NULL_F 262 +#define TK_LINEAR 263 +#define TK_NEXT 264 +#define TK_HAVING 265 +#define TK_RANGE 266 +#define TK_EVERY 267 +#define TK_ORDER 268 +#define TK_SLIMIT 269 +#define TK_SOFFSET 270 +#define TK_LIMIT 271 +#define TK_OFFSET 272 +#define TK_ASC 273 +#define TK_NULLS 274 +#define TK_ABORT 275 +#define TK_AFTER 276 +#define TK_ATTACH 277 +#define TK_BEFORE 278 +#define TK_BEGIN 279 +#define TK_BITAND 280 +#define TK_BITNOT 281 +#define TK_BITOR 282 +#define TK_BLOCKS 283 +#define TK_CHANGE 284 +#define TK_COMMA 285 #define TK_CONCAT 286 #define TK_CONFLICT 287 #define TK_COPY 288 diff --git a/include/libs/nodes/cmdnodes.h b/include/libs/nodes/cmdnodes.h index d77f2b6233..016a9e8281 100644 --- a/include/libs/nodes/cmdnodes.h +++ b/include/libs/nodes/cmdnodes.h @@ -124,6 +124,11 @@ typedef struct STrimDatabaseStmt { int32_t maxSpeed; } STrimDatabaseStmt; +typedef struct SCompactDatabaseStmt { + ENodeType type; + char dbName[TSDB_DB_NAME_LEN]; +} SCompactDatabaseStmt; + typedef struct STableOptions { ENodeType type; bool commentNull; diff --git a/include/libs/nodes/nodes.h b/include/libs/nodes/nodes.h index 24b436ec99..a2e4c76adc 100644 --- a/include/libs/nodes/nodes.h +++ b/include/libs/nodes/nodes.h @@ -155,7 +155,7 @@ typedef enum ENodeType { QUERY_NODE_EXPLAIN_STMT, QUERY_NODE_DESCRIBE_STMT, QUERY_NODE_RESET_QUERY_CACHE_STMT, - QUERY_NODE_COMPACT_STMT, + QUERY_NODE_COMPACT_DATABASE_STMT, QUERY_NODE_CREATE_FUNCTION_STMT, QUERY_NODE_DROP_FUNCTION_STMT, QUERY_NODE_CREATE_STREAM_STMT, diff --git a/include/util/trbtree.h b/include/util/trbtree.h index 7c93c8dd8d..e226419440 100644 --- a/include/util/trbtree.h +++ b/include/util/trbtree.h @@ -33,9 +33,12 @@ typedef int32_t (*tRBTreeCmprFn)(const SRBTreeNode *, const SRBTreeNode *); #define tRBTreeMax(T) ((T)->max == ((T)->NIL) ? NULL : (T)->max) void tRBTreeCreate(SRBTree *pTree, tRBTreeCmprFn cmprFn); +void tRBTreeClear(SRBTree *pTree); SRBTreeNode *tRBTreePut(SRBTree *pTree, SRBTreeNode *z); void tRBTreeDrop(SRBTree *pTree, SRBTreeNode *z); SRBTreeNode *tRBTreeDropByKey(SRBTree *pTree, void *pKey); +SRBTreeNode *tRBTreeDropMin(SRBTree *pTree); +SRBTreeNode *tRBTreeDropMax(SRBTree *pTree); SRBTreeNode *tRBTreeGet(SRBTree *pTree, const SRBTreeNode *pKeyNode); // SRBTreeIter ============================================= diff --git a/source/common/src/systable.c b/source/common/src/systable.c index 8791a81bbe..0e185fa1c0 100644 --- a/source/common/src/systable.c +++ b/source/common/src/systable.c @@ -230,6 +230,7 @@ static const SSysDbTableSchema vgroupsSchema[] = { {.name = "v4_status", .bytes = 9 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true}, {.name = "cacheload", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true}, {.name = "tsma", .bytes = 1, .type = TSDB_DATA_TYPE_TINYINT, .sysInfo = true}, + // {.name = "compact_start_time", .bytes = 8, .type = TSDB_DATA_TYPE_TIMESTAMP, .sysInfo = false}, }; static const SSysDbTableSchema smaSchema[] = { diff --git a/source/common/src/tdataformat.c b/source/common/src/tdataformat.c index 7b3038280a..7c0de3d6f0 100644 --- a/source/common/src/tdataformat.c +++ b/source/common/src/tdataformat.c @@ -21,6 +21,7 @@ #include "tlog.h" static int32_t (*tColDataAppendValueImpl[8][3])(SColData *pColData, uint8_t *pData, uint32_t nData); +static int32_t (*tColDataUpdateValueImpl[8][3])(SColData *pColData, uint8_t *pData, uint32_t nData, bool forward); // SBuffer ================================ void tBufferDestroy(SBuffer *pBuffer) { @@ -850,19 +851,19 @@ _exit: return &pIter->cv; } -static int32_t tRowAppendNoneToColData(SColData *aColData, int32_t nColData) { +static int32_t tRowNoneUpsertColData(SColData *aColData, int32_t nColData, int32_t flag) { int32_t code = 0; + if (flag) return code; + for (int32_t iColData = 0; iColData < nColData; iColData++) { - SColData *pColData = &aColData[iColData]; - code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NONE](pColData, NULL, 0); - if (code) goto _exit; + code = tColDataAppendValueImpl[aColData[iColData].flag][CV_FLAG_NONE](&aColData[iColData], NULL, 0); + if (code) return code; } -_exit: return code; } -static int32_t tRowAppendNullToColData(SColData *aColData, int32_t nColData, STSchema *pSchema) { +static int32_t tRowNullUpsertColData(SColData *aColData, int32_t nColData, STSchema *pSchema, int32_t flag) { int32_t code = 0; int32_t iColData = 0; @@ -873,21 +874,23 @@ static int32_t tRowAppendNullToColData(SColData *aColData, int32_t nColData, STS while (pColData) { if (pTColumn) { if (pTColumn->colId == pColData->cid) { // NULL - code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NULL](pColData, NULL, 0); + if (flag == 0) { + code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NULL](pColData, NULL, 0); + } else { + code = tColDataUpdateValueImpl[pColData->flag][CV_FLAG_NULL](pColData, NULL, 0, flag > 0); + } if (code) goto _exit; + pColData = (++iColData < nColData) ? &aColData[iColData] : NULL; pTColumn = (++iTColumn < pSchema->numOfCols) ? &pSchema->columns[iTColumn] : NULL; } else if (pTColumn->colId > pColData->cid) { // NONE - code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NONE](pColData, NULL, 0); - if (code) goto _exit; + if (flag == 0 && (code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NONE](pColData, NULL, 0))) goto _exit; pColData = (++iColData < nColData) ? &aColData[iColData] : NULL; } else { pTColumn = (++iTColumn < pSchema->numOfCols) ? &pSchema->columns[iTColumn] : NULL; } - } else { - code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NONE](pColData, NULL, 0); - if (code) goto _exit; - + } else { // NONE + if (flag == 0 && (code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NONE](pColData, NULL, 0))) goto _exit; pColData = (++iColData < nColData) ? &aColData[iColData] : NULL; } } @@ -895,7 +898,8 @@ static int32_t tRowAppendNullToColData(SColData *aColData, int32_t nColData, STS _exit: return code; } -static int32_t tRowAppendTupleToColData(SRow *pRow, STSchema *pTSchema, SColData *aColData, int32_t nColData) { +static int32_t tRowTupleUpsertColData(SRow *pRow, STSchema *pTSchema, SColData *aColData, int32_t nColData, + int32_t flag) { int32_t code = 0; int32_t iColData = 0; @@ -955,11 +959,15 @@ static int32_t tRowAppendTupleToColData(SRow *pRow, STSchema *pTSchema, SColData } if (bv == BIT_FLG_NONE) { - code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NONE](pColData, NULL, 0); - if (code) goto _exit; + if (flag == 0 && (code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NONE](pColData, NULL, 0))) + goto _exit; goto _continue; } else if (bv == BIT_FLG_NULL) { - code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NULL](pColData, NULL, 0); + if (flag == 0) { + code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NULL](pColData, NULL, 0); + } else { + code = tColDataUpdateValueImpl[pColData->flag][CV_FLAG_NULL](pColData, NULL, 0, flag > 0); + } if (code) goto _exit; goto _continue; } @@ -969,11 +977,20 @@ static int32_t tRowAppendTupleToColData(SRow *pRow, STSchema *pTSchema, SColData uint8_t *pData = pv + *(int32_t *)(pf + pTColumn->offset); uint32_t nData; pData += tGetU32v(pData, &nData); - code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_VALUE](pColData, pData, nData); + if (flag == 0) { + code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_VALUE](pColData, pData, nData); + } else { + code = tColDataUpdateValueImpl[pColData->flag][CV_FLAG_VALUE](pColData, pData, nData, flag > 0); + } if (code) goto _exit; } else { - code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_VALUE](pColData, pf + pTColumn->offset, - TYPE_BYTES[pColData->type]); + if (flag == 0) { + code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_VALUE](pColData, pf + pTColumn->offset, + TYPE_BYTES[pColData->type]); + } else { + code = tColDataUpdateValueImpl[pColData->flag][CV_FLAG_VALUE](pColData, pf + pTColumn->offset, + TYPE_BYTES[pColData->type], flag > 0); + } if (code) goto _exit; } @@ -981,17 +998,13 @@ static int32_t tRowAppendTupleToColData(SRow *pRow, STSchema *pTSchema, SColData pColData = (++iColData < nColData) ? &aColData[iColData] : NULL; pTColumn = (++iTColumn < pTSchema->numOfCols) ? &pTSchema->columns[iTColumn] : NULL; } else if (pTColumn->colId > pColData->cid) { // NONE - code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NONE](pColData, NULL, 0); - if (code) goto _exit; - + if (flag == 0 && (code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NONE](pColData, NULL, 0))) goto _exit; pColData = (++iColData < nColData) ? &aColData[iColData] : NULL; } else { pTColumn = (++iTColumn < pTSchema->numOfCols) ? &pTSchema->columns[iTColumn] : NULL; } } else { - code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NONE](pColData, NULL, 0); - if (code) goto _exit; - + if (flag == 0 && (code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NONE](pColData, NULL, 0))) goto _exit; pColData = (++iColData < nColData) ? &aColData[iColData] : NULL; } } @@ -999,7 +1012,7 @@ static int32_t tRowAppendTupleToColData(SRow *pRow, STSchema *pTSchema, SColData _exit: return code; } -static int32_t tRowAppendKVToColData(SRow *pRow, STSchema *pTSchema, SColData *aColData, int32_t nColData) { +static int32_t tRowKVUpsertColData(SRow *pRow, STSchema *pTSchema, SColData *aColData, int32_t nColData, int32_t flag) { int32_t code = 0; SKVIdx *pKVIdx = (SKVIdx *)pRow->data; @@ -1040,18 +1053,25 @@ static int32_t tRowAppendKVToColData(SRow *pRow, STSchema *pTSchema, SColData *a if (TABS(cid) == pTColumn->colId) { if (cid < 0) { - code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NULL](pColData, NULL, 0); + if (flag == 0) { + code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NULL](pColData, NULL, 0); + } else { + code = tColDataUpdateValueImpl[pColData->flag][CV_FLAG_NULL](pColData, NULL, 0, flag > 0); + } if (code) goto _exit; } else { + uint32_t nData; if (IS_VAR_DATA_TYPE(pTColumn->type)) { - uint32_t nData; pData += tGetU32v(pData, &nData); - code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_VALUE](pColData, pData, nData); - if (code) goto _exit; } else { - code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_VALUE](pColData, pData, 0); - if (code) goto _exit; + nData = 0; } + if (flag == 0) { + code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_VALUE](pColData, pData, nData); + } else { + code = tColDataUpdateValueImpl[pColData->flag][CV_FLAG_VALUE](pColData, pData, nData, flag > 0); + } + if (code) goto _exit; } iCol++; goto _continue; @@ -1062,22 +1082,19 @@ static int32_t tRowAppendKVToColData(SRow *pRow, STSchema *pTSchema, SColData *a } } - code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NONE](pColData, NULL, 0); - if (code) goto _exit; + if (flag == 0 && (code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NONE](pColData, NULL, 0))) goto _exit; _continue: pColData = (++iColData < nColData) ? &aColData[iColData] : NULL; pTColumn = (++iTColumn < pTSchema->numOfCols) ? &pTSchema->columns[iTColumn] : NULL; } else if (pTColumn->colId > pColData->cid) { - code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NONE](pColData, NULL, 0); - if (code) goto _exit; + if (flag == 0 && (code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NONE](pColData, NULL, 0))) goto _exit; pColData = (++iColData < nColData) ? &aColData[iColData] : NULL; } else { pTColumn = (++iTColumn < pTSchema->numOfCols) ? &pTSchema->columns[iTColumn] : NULL; } } else { - code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NONE](pColData, NULL, 0); - if (code) goto _exit; + if (flag == 0 && (code = tColDataAppendValueImpl[pColData->flag][CV_FLAG_NONE](pColData, NULL, 0))) goto _exit; pColData = (++iColData < nColData) ? &aColData[iColData] : NULL; } } @@ -1085,30 +1102,23 @@ static int32_t tRowAppendKVToColData(SRow *pRow, STSchema *pTSchema, SColData *a _exit: return code; } -int32_t tRowAppendToColData(SRow *pRow, STSchema *pTSchema, SColData *aColData, int32_t nColData) { +/* flag > 0: forward update + * flag == 0: append + * flag < 0: backward update + */ +int32_t tRowUpsertColData(SRow *pRow, STSchema *pTSchema, SColData *aColData, int32_t nColData, int32_t flag) { ASSERT(pRow->sver == pTSchema->version); ASSERT(nColData > 0); - int32_t code = 0; - if (pRow->flag == HAS_NONE) { - code = tRowAppendNoneToColData(aColData, nColData); - goto _exit; + return tRowNoneUpsertColData(aColData, nColData, flag); } else if (pRow->flag == HAS_NULL) { - code = tRowAppendNullToColData(aColData, nColData, pTSchema); - goto _exit; + return tRowNullUpsertColData(aColData, nColData, pTSchema, flag); + } else if (pRow->flag >> 4) { // KV row + return tRowKVUpsertColData(pRow, pTSchema, aColData, nColData, flag); + } else { // TUPLE row + return tRowTupleUpsertColData(pRow, pTSchema, aColData, nColData, flag); } - - if (pRow->flag >> 4) { // KV row - code = tRowAppendKVToColData(pRow, pTSchema, aColData, nColData); - if (code) goto _exit; - } else { - code = tRowAppendTupleToColData(pRow, pTSchema, aColData, nColData); - if (code) goto _exit; - } - -_exit: - return code; } // STag ======================================== @@ -1549,6 +1559,9 @@ void tColDataInit(SColData *pColData, int16_t cid, int8_t type, int8_t smaOn) { } void tColDataClear(SColData *pColData) { + pColData->numOfNone = 0; + pColData->numOfNull = 0; + pColData->numOfValue = 0; pColData->nVal = 0; pColData->flag = 0; pColData->nData = 0; @@ -1594,15 +1607,18 @@ _exit: } static FORCE_INLINE int32_t tColDataAppendValue00(SColData *pColData, uint8_t *pData, uint32_t nData) { pColData->flag = HAS_VALUE; + pColData->numOfValue++; return tColDataPutValue(pColData, pData, nData); } static FORCE_INLINE int32_t tColDataAppendValue01(SColData *pColData, uint8_t *pData, uint32_t nData) { pColData->flag = HAS_NONE; + pColData->numOfNone++; pColData->nVal++; return 0; } static FORCE_INLINE int32_t tColDataAppendValue02(SColData *pColData, uint8_t *pData, uint32_t nData) { pColData->flag = HAS_NULL; + pColData->numOfNull++; pColData->nVal++; return 0; } @@ -1617,6 +1633,7 @@ static FORCE_INLINE int32_t tColDataAppendValue10(SColData *pColData, uint8_t *p SET_BIT1_EX(pColData->pBitMap, pColData->nVal, 1); pColData->flag |= HAS_VALUE; + pColData->numOfValue++; if (pColData->nVal) { if (IS_VAR_DATA_TYPE(pColData->type)) { @@ -1636,6 +1653,7 @@ static FORCE_INLINE int32_t tColDataAppendValue10(SColData *pColData, uint8_t *p } static FORCE_INLINE int32_t tColDataAppendValue11(SColData *pColData, uint8_t *pData, uint32_t nData) { pColData->nVal++; + pColData->numOfNone++; return 0; } static FORCE_INLINE int32_t tColDataAppendValue12(SColData *pColData, uint8_t *pData, uint32_t nData) { @@ -1649,6 +1667,7 @@ static FORCE_INLINE int32_t tColDataAppendValue12(SColData *pColData, uint8_t *p SET_BIT1_EX(pColData->pBitMap, pColData->nVal, 1); pColData->flag |= HAS_NULL; + pColData->numOfNull++; pColData->nVal++; return code; @@ -1664,6 +1683,7 @@ static FORCE_INLINE int32_t tColDataAppendValue20(SColData *pColData, uint8_t *p SET_BIT1_EX(pColData->pBitMap, pColData->nVal, 1); pColData->flag |= HAS_VALUE; + pColData->numOfValue++; if (pColData->nVal) { if (IS_VAR_DATA_TYPE(pColData->type)) { @@ -1692,18 +1712,21 @@ static FORCE_INLINE int32_t tColDataAppendValue21(SColData *pColData, uint8_t *p SET_BIT1_EX(pColData->pBitMap, pColData->nVal, 0); pColData->flag |= HAS_NONE; + pColData->numOfNone++; pColData->nVal++; return code; } static FORCE_INLINE int32_t tColDataAppendValue22(SColData *pColData, uint8_t *pData, uint32_t nData) { pColData->nVal++; + pColData->numOfNull++; return 0; } static FORCE_INLINE int32_t tColDataAppendValue30(SColData *pColData, uint8_t *pData, uint32_t nData) { int32_t code = 0; pColData->flag |= HAS_VALUE; + pColData->numOfValue++; uint8_t *pBitMap = NULL; code = tRealloc(&pBitMap, BIT2_SIZE(pColData->nVal + 1)); @@ -1740,6 +1763,7 @@ static FORCE_INLINE int32_t tColDataAppendValue31(SColData *pColData, uint8_t *p if (code) return code; SET_BIT1_EX(pColData->pBitMap, pColData->nVal, 0); + pColData->numOfNone++; pColData->nVal++; return code; @@ -1751,15 +1775,20 @@ static FORCE_INLINE int32_t tColDataAppendValue32(SColData *pColData, uint8_t *p if (code) return code; SET_BIT1_EX(pColData->pBitMap, pColData->nVal, 1); + pColData->numOfNull++; pColData->nVal++; return code; } -#define tColDataAppendValue40 tColDataPutValue +static FORCE_INLINE int32_t tColDataAppendValue40(SColData *pColData, uint8_t *pData, uint32_t nData) { + pColData->numOfValue++; + return tColDataPutValue(pColData, pData, nData); +} static FORCE_INLINE int32_t tColDataAppendValue41(SColData *pColData, uint8_t *pData, uint32_t nData) { int32_t code = 0; pColData->flag |= HAS_NONE; + pColData->numOfNone++; int32_t nBit = BIT1_SIZE(pColData->nVal + 1); code = tRealloc(&pColData->pBitMap, nBit); @@ -1774,6 +1803,7 @@ static FORCE_INLINE int32_t tColDataAppendValue42(SColData *pColData, uint8_t *p int32_t code = 0; pColData->flag |= HAS_NULL; + pColData->numOfNull++; int32_t nBit = BIT1_SIZE(pColData->nVal + 1); code = tRealloc(&pColData->pBitMap, nBit); @@ -1791,6 +1821,7 @@ static FORCE_INLINE int32_t tColDataAppendValue50(SColData *pColData, uint8_t *p if (code) return code; SET_BIT1_EX(pColData->pBitMap, pColData->nVal, 1); + pColData->numOfValue++; return tColDataPutValue(pColData, pData, nData); } @@ -1801,6 +1832,7 @@ static FORCE_INLINE int32_t tColDataAppendValue51(SColData *pColData, uint8_t *p if (code) return code; SET_BIT1_EX(pColData->pBitMap, pColData->nVal, 0); + pColData->numOfNone++; return tColDataPutValue(pColData, NULL, 0); } @@ -1808,6 +1840,7 @@ static FORCE_INLINE int32_t tColDataAppendValue52(SColData *pColData, uint8_t *p int32_t code = 0; pColData->flag |= HAS_NULL; + pColData->numOfNull++; uint8_t *pBitMap = NULL; code = tRealloc(&pBitMap, BIT2_SIZE(pColData->nVal + 1)); @@ -1829,6 +1862,7 @@ static FORCE_INLINE int32_t tColDataAppendValue60(SColData *pColData, uint8_t *p code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1)); if (code) return code; SET_BIT1_EX(pColData->pBitMap, pColData->nVal, 1); + pColData->numOfValue++; return tColDataPutValue(pColData, pData, nData); } @@ -1836,6 +1870,7 @@ static FORCE_INLINE int32_t tColDataAppendValue61(SColData *pColData, uint8_t *p int32_t code = 0; pColData->flag |= HAS_NONE; + pColData->numOfNone++; uint8_t *pBitMap = NULL; code = tRealloc(&pBitMap, BIT2_SIZE(pColData->nVal + 1)); @@ -1857,6 +1892,7 @@ static FORCE_INLINE int32_t tColDataAppendValue62(SColData *pColData, uint8_t *p code = tRealloc(&pColData->pBitMap, BIT1_SIZE(pColData->nVal + 1)); if (code) return code; SET_BIT1_EX(pColData->pBitMap, pColData->nVal, 0); + pColData->numOfNull++; return tColDataPutValue(pColData, NULL, 0); } @@ -1866,6 +1902,7 @@ static FORCE_INLINE int32_t tColDataAppendValue70(SColData *pColData, uint8_t *p code = tRealloc(&pColData->pBitMap, BIT2_SIZE(pColData->nVal + 1)); if (code) return code; SET_BIT2_EX(pColData->pBitMap, pColData->nVal, 2); + pColData->numOfValue++; return tColDataPutValue(pColData, pData, nData); } @@ -1875,6 +1912,7 @@ static FORCE_INLINE int32_t tColDataAppendValue71(SColData *pColData, uint8_t *p code = tRealloc(&pColData->pBitMap, BIT2_SIZE(pColData->nVal + 1)); if (code) return code; SET_BIT2_EX(pColData->pBitMap, pColData->nVal, 0); + pColData->numOfNone++; return tColDataPutValue(pColData, NULL, 0); } @@ -1884,6 +1922,7 @@ static FORCE_INLINE int32_t tColDataAppendValue72(SColData *pColData, uint8_t *p code = tRealloc(&pColData->pBitMap, BIT2_SIZE(pColData->nVal + 1)); if (code) return code; SET_BIT2_EX(pColData->pBitMap, pColData->nVal, 1); + pColData->numOfNull++; return tColDataPutValue(pColData, NULL, 0); } @@ -1896,6 +1935,8 @@ static int32_t (*tColDataAppendValueImpl[8][3])(SColData *pColData, uint8_t *pDa {tColDataAppendValue50, tColDataAppendValue51, tColDataAppendValue52}, // HAS_VALUE|HAS_NONE {tColDataAppendValue60, tColDataAppendValue61, tColDataAppendValue62}, // HAS_VALUE|HAS_NULL {tColDataAppendValue70, tColDataAppendValue71, tColDataAppendValue72}, // HAS_VALUE|HAS_NULL|HAS_NONE + + // VALUE NONE NULL }; int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal) { ASSERT(pColData->cid == pColVal->cid && pColData->type == pColVal->type); @@ -1904,6 +1945,282 @@ int32_t tColDataAppendValue(SColData *pColData, SColVal *pColVal) { pColVal->value.nData); } +static FORCE_INLINE int32_t tColDataUpdateValue10(SColData *pColData, uint8_t *pData, uint32_t nData, bool forward) { + pColData->numOfNone--; + pColData->nVal--; + if (pColData->numOfNone) { + return tColDataAppendValue10(pColData, pData, nData); + } else { + pColData->flag = 0; + return tColDataAppendValue00(pColData, pData, nData); + } +} +static FORCE_INLINE int32_t tColDataUpdateValue12(SColData *pColData, uint8_t *pData, uint32_t nData, bool forward) { + pColData->numOfNone--; + pColData->nVal--; + if (pColData->numOfNone) { + return tColDataAppendValue12(pColData, pData, nData); + } else { + pColData->flag = 0; + return tColDataAppendValue02(pColData, pData, nData); + } + return 0; +} +static FORCE_INLINE int32_t tColDataUpdateValue20(SColData *pColData, uint8_t *pData, uint32_t nData, bool forward) { + if (forward) { + pColData->numOfNull--; + pColData->nVal--; + if (pColData->numOfNull) { + return tColDataAppendValue20(pColData, pData, nData); + } else { + pColData->flag = 0; + return tColDataAppendValue00(pColData, pData, nData); + } + } + return 0; +} +static FORCE_INLINE int32_t tColDataUpdateValue30(SColData *pColData, uint8_t *pData, uint32_t nData, bool forward) { + uint8_t bv = GET_BIT1(pColData->pBitMap, pColData->nVal - 1); + if (bv == 0) { // NONE == > VALUE + pColData->numOfNone--; + pColData->nVal--; + if (pColData->numOfNone) { + return tColDataAppendValue30(pColData, pData, nData); + } else { + pColData->flag = HAS_NULL; + return tColDataAppendValue20(pColData, pData, nData); + } + } else if (forward) { // NULL == > VALUE + pColData->numOfNull--; + pColData->nVal--; + if (pColData->numOfNull) { + return tColDataAppendValue30(pColData, pData, nData); + } else { + pColData->flag = HAS_NONE; + return tColDataAppendValue10(pColData, pData, nData); + } + } + return 0; +} +static FORCE_INLINE int32_t tColDataUpdateValue32(SColData *pColData, uint8_t *pData, uint32_t nData, bool forward) { + if (GET_BIT1(pColData->pBitMap, pColData->nVal - 1) == 0) { // NONE ==> NULL + pColData->numOfNone--; + pColData->numOfNull++; + if (pColData->numOfNone) { + SET_BIT1(pColData->pBitMap, pColData->nVal - 1, 1); + } else { + pColData->flag = HAS_NULL; + } + } + return 0; +} +static FORCE_INLINE int32_t tColDataUpdateValue40(SColData *pColData, uint8_t *pData, uint32_t nData, bool forward) { + if (forward) { + pColData->numOfValue--; + pColData->nVal--; + if (pColData->numOfValue) { + return tColDataAppendValue40(pColData, pData, nData); + } else { + pColData->flag = 0; + return tColDataAppendValue00(pColData, pData, nData); + } + } + return 0; +} +static FORCE_INLINE int32_t tColDataUpdateValue42(SColData *pColData, uint8_t *pData, uint32_t nData, bool forward) { + if (forward) { + pColData->numOfValue--; + pColData->nVal--; + if (pColData->numOfValue) { + return tColDataAppendValue42(pColData, pData, nData); + } else { + pColData->flag = 0; + return tColDataAppendValue02(pColData, pData, nData); + } + } + return 0; +} +static FORCE_INLINE int32_t tColDataUpdateValue50(SColData *pColData, uint8_t *pData, uint32_t nData, bool forward) { + uint8_t bv = GET_BIT1(pColData->pBitMap, pColData->nVal - 1); + if (bv == 0) { // NONE ==> VALUE + pColData->numOfNone--; + pColData->nVal--; + if (pColData->numOfNone) { + return tColDataAppendValue50(pColData, pData, nData); + } else { + pColData->flag = HAS_VALUE; + return tColDataAppendValue40(pColData, pData, nData); + } + } else if (forward) { // VALUE ==> VALUE + pColData->numOfValue--; + pColData->nVal--; + if (pColData->numOfValue) { + return tColDataAppendValue50(pColData, pData, nData); + } else { + pColData->flag = HAS_NONE; + return tColDataAppendValue10(pColData, pData, nData); + } + } + return 0; +} +static FORCE_INLINE int32_t tColDataUpdateValue52(SColData *pColData, uint8_t *pData, uint32_t nData, bool forward) { + uint8_t bv = GET_BIT1(pColData->pBitMap, pColData->nVal - 1); + if (bv == 0) { // NONE ==> NULL + pColData->numOfNone--; + pColData->nVal--; + if (pColData->numOfNone) { + return tColDataAppendValue52(pColData, pData, nData); + } else { + pColData->flag &= ~HAS_NONE; + return tColDataAppendValue42(pColData, pData, nData); + } + } else if (forward) { // VALUE ==> NULL + pColData->numOfValue--; + pColData->nVal--; + if (pColData->numOfValue) { + return tColDataAppendValue52(pColData, pData, nData); + } else { + pColData->flag &= ~HAS_VALUE; + return tColDataAppendValue12(pColData, pData, nData); + } + } + return 0; +} +static FORCE_INLINE int32_t tColDataUpdateValue60(SColData *pColData, uint8_t *pData, uint32_t nData, bool forward) { + if (forward) { + if (GET_BIT1(pColData->pBitMap, pColData->nVal - 1) == 0) { // NULL ==> VALUE + pColData->numOfNull--; + pColData->nVal--; + if (pColData->numOfNull) { + return tColDataAppendValue60(pColData, pData, nData); + } else { + pColData->flag = HAS_VALUE; + return tColDataAppendValue40(pColData, pData, nData); + } + } else { // VALUE ==> VALUE + pColData->numOfValue--; + pColData->nVal--; + if (pColData->numOfValue) { + return tColDataAppendValue60(pColData, pData, nData); + } else { + pColData->flag = HAS_NULL; + return tColDataAppendValue20(pColData, pData, nData); + } + } + } + return 0; +} +static FORCE_INLINE int32_t tColDataUpdateValue62(SColData *pColData, uint8_t *pData, uint32_t nData, bool forward) { + if (forward && (GET_BIT1(pColData->pBitMap, pColData->nVal - 1) == 1)) { // VALUE ==> NULL + pColData->numOfValue--; + pColData->nVal--; + if (pColData->numOfValue) { + return tColDataAppendValue62(pColData, pData, nData); + } else { + pColData->flag = HAS_NULL; + return tColDataAppendValue20(pColData, pData, nData); + } + } + return 0; +} +static FORCE_INLINE int32_t tColDataUpdateValue70(SColData *pColData, uint8_t *pData, uint32_t nData, bool forward) { + int32_t code = 0; + + uint8_t bv = GET_BIT2(pColData->pBitMap, pColData->nVal - 1); + if (bv == 0) { // NONE ==> VALUE + pColData->numOfNone--; + pColData->nVal--; + if (pColData->numOfNone) { + return tColDataAppendValue70(pColData, pData, nData); + } else { + for (int32_t iVal = 0; iVal < pColData->nVal; ++iVal) { + SET_BIT1(pColData->pBitMap, iVal, GET_BIT2(pColData->pBitMap, iVal) - 1); + } + pColData->flag &= ~HAS_NONE; + return tColDataAppendValue60(pColData, pData, nData); + } + } else if (bv == 1) { // NULL ==> VALUE + if (forward) { + pColData->numOfNull--; + pColData->nVal--; + if (pColData->numOfNull) { + return tColDataAppendValue70(pColData, pData, nData); + } else { + for (int32_t iVal = 0; iVal < pColData->nVal; ++iVal) { + SET_BIT1(pColData->pBitMap, iVal, GET_BIT2(pColData->pBitMap, iVal) ? 1 : 0); + } + pColData->flag &= ~HAS_NULL; + return tColDataAppendValue50(pColData, pData, nData); + } + } + } else if (bv == 2) { // VALUE ==> VALUE + if (forward) { + pColData->numOfValue--; + pColData->nVal--; + if (pColData->numOfValue) { + return tColDataAppendValue70(pColData, pData, nData); + } else { + return tColDataPutValue(pColData, pData, nData); + } + } + } else { + ASSERT(0); + } + return 0; +} +static int32_t tColDataUpdateValue72(SColData *pColData, uint8_t *pData, uint32_t nData, bool forward) { + uint8_t bv = GET_BIT2(pColData->pBitMap, pColData->nVal - 1); + ASSERT(bv < 3); + if (bv == 0) { // NONE ==> NULL + pColData->numOfNone--; + pColData->nVal--; + if (pColData->numOfNone) { + return tColDataAppendValue72(pColData, pData, nData); + } else { + for (int32_t iVal = 0; iVal < pColData->nVal; ++iVal) { + SET_BIT1(pColData->pBitMap, iVal, GET_BIT2(pColData->pBitMap, iVal) - 1); + } + pColData->flag &= ~HAS_NONE; + return tColDataAppendValue62(pColData, pData, nData); + } + } else if (bv == 2 && forward) { // VALUE ==> NULL + pColData->numOfValue--; + pColData->nVal--; + if (pColData->numOfValue) { + return tColDataAppendValue72(pColData, pData, nData); + } else { + for (int32_t iVal = 0; iVal < pColData->nVal; ++iVal) { + SET_BIT1(pColData->pBitMap, iVal, GET_BIT2(pColData->pBitMap, iVal)); + } + pColData->flag &= ~HAS_VALUE; + return tColDataAppendValue32(pColData, pData, nData); + } + } + return 0; +} +static int32_t (*tColDataUpdateValueImpl[8][3])(SColData *pColData, uint8_t *pData, uint32_t nData, bool forward) = { + {NULL, NULL, NULL}, // 0 + {tColDataUpdateValue10, NULL, tColDataUpdateValue12}, // HAS_NONE + {tColDataUpdateValue20, NULL, NULL}, // HAS_NULL + {tColDataUpdateValue30, NULL, tColDataUpdateValue32}, // HAS_NULL|HAS_NONE + {tColDataUpdateValue40, NULL, tColDataUpdateValue42}, // HAS_VALUE + {tColDataUpdateValue50, NULL, tColDataUpdateValue52}, // HAS_VALUE|HAS_NONE + {tColDataUpdateValue60, NULL, tColDataUpdateValue62}, // HAS_VALUE|HAS_NULL + {tColDataUpdateValue70, NULL, tColDataUpdateValue72}, // HAS_VALUE|HAS_NULL|HAS_NONE + + // VALUE NONE NULL +}; +int32_t tColDataUpdateValue(SColData *pColData, SColVal *pColVal, bool forward) { + ASSERT(pColData->cid == pColVal->cid && pColData->type == pColVal->type); + ASSERT(pColData->nVal > 0); + + if (tColDataUpdateValueImpl[pColData->flag][pColVal->flag] == NULL) return 0; + + return tColDataUpdateValueImpl[pColData->flag][pColVal->flag]( + pColData, IS_VAR_DATA_TYPE(pColData->type) ? pColVal->value.pData : (uint8_t *)&pColVal->value.val, + pColVal->value.nData, forward); +} + static FORCE_INLINE void tColDataGetValue1(SColData *pColData, int32_t iVal, SColVal *pColVal) { // HAS_NONE *pColVal = COL_VAL_NONE(pColData->cid, pColData->type); } diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index 322143b71f..f176ccf37f 100644 --- a/source/common/src/tmsg.c +++ b/source/common/src/tmsg.c @@ -3992,9 +3992,7 @@ int32_t tSerializeSCompactVnodeReq(void *buf, int32_t bufLen, SCompactVnodeReq * if (tStartEncode(&encoder) < 0) return -1; if (tEncodeI64(&encoder, pReq->dbUid) < 0) return -1; if (tEncodeCStr(&encoder, pReq->db) < 0) return -1; - for (int32_t i = 0; i < 8; ++i) { - if (tEncodeI64(&encoder, pReq->reserved[i]) < 0) return -1; - } + if (tEncodeI64(&encoder, pReq->compactStartTime) < 0) return -1; tEndEncode(&encoder); int32_t tlen = encoder.pos; @@ -4009,9 +4007,7 @@ int32_t tDeserializeSCompactVnodeReq(void *buf, int32_t bufLen, SCompactVnodeReq if (tStartDecode(&decoder) < 0) return -1; if (tDecodeI64(&decoder, &pReq->dbUid) < 0) return -1; if (tDecodeCStrTo(&decoder, pReq->db) < 0) return -1; - for (int32_t i = 0; i < 8; ++i) { - if (tDecodeI64(&decoder, &pReq->reserved[i]) < 0) return -1; - } + if (tDecodeI64(&decoder, &pReq->compactStartTime) < 0) return -1; tEndDecode(&decoder); tDecoderClear(&decoder); diff --git a/source/dnode/mnode/impl/inc/mndDef.h b/source/dnode/mnode/impl/inc/mndDef.h index 1cbd9bfb66..075122d85b 100644 --- a/source/dnode/mnode/impl/inc/mndDef.h +++ b/source/dnode/mnode/impl/inc/mndDef.h @@ -328,6 +328,7 @@ typedef struct { SDbCfg cfg; SRWLatch lock; int64_t stateTs; + int64_t compactStartTime; } SDbObj; typedef struct { diff --git a/source/dnode/mnode/impl/inc/mndVgroup.h b/source/dnode/mnode/impl/inc/mndVgroup.h index 765d4fd33d..51eb24f402 100644 --- a/source/dnode/mnode/impl/inc/mndVgroup.h +++ b/source/dnode/mnode/impl/inc/mndVgroup.h @@ -43,6 +43,7 @@ int32_t mndAddDropVnodeAction(SMnode *, STrans *pTrans, SDbObj *pDb, SVgObj *pVg int32_t mndSetMoveVgroupsInfoToTrans(SMnode *, STrans *pTrans, int32_t dropDnodeId, bool force); int32_t mndBuildAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb, SDbObj *pNewDb, SVgObj *pVgroup, SArray *pArray); +int32_t mndBuildCompactVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, int64_t compactTs); void *mndBuildCreateVnodeReq(SMnode *, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen); void *mndBuildDropVnodeReq(SMnode *, SDnodeObj *pDnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen); diff --git a/source/dnode/mnode/impl/src/mndDb.c b/source/dnode/mnode/impl/src/mndDb.c index ea1d3281d4..1943ab0b0f 100644 --- a/source/dnode/mnode/impl/src/mndDb.c +++ b/source/dnode/mnode/impl/src/mndDb.c @@ -30,7 +30,7 @@ #include "systable.h" #define DB_VER_NUMBER 1 -#define DB_RESERVE_SIZE 54 +#define DB_RESERVE_SIZE 46 static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw); static int32_t mndDbActionInsert(SSdb *pSdb, SDbObj *pDb); @@ -126,6 +126,7 @@ SSdbRaw *mndDbActionEncode(SDbObj *pDb) { SDB_SET_INT16(pRaw, dataPos, pDb->cfg.hashPrefix, _OVER) SDB_SET_INT16(pRaw, dataPos, pDb->cfg.hashSuffix, _OVER) SDB_SET_INT32(pRaw, dataPos, pDb->cfg.tsdbPageSize, _OVER) + SDB_SET_INT64(pRaw, dataPos, pDb->compactStartTime, _OVER) SDB_SET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER) SDB_SET_DATALEN(pRaw, dataPos, _OVER) @@ -215,6 +216,7 @@ static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw) { SDB_GET_INT16(pRaw, dataPos, &pDb->cfg.hashPrefix, _OVER) SDB_GET_INT16(pRaw, dataPos, &pDb->cfg.hashSuffix, _OVER) SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.tsdbPageSize, _OVER) + SDB_GET_INT64(pRaw, dataPos, &pDb->compactStartTime, _OVER) SDB_GET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER) taosInitRWLatch(&pDb->lock); @@ -274,6 +276,7 @@ static int32_t mndDbActionUpdate(SSdb *pSdb, SDbObj *pOld, SDbObj *pNew) { pOld->cfg.replications = pNew->cfg.replications; pOld->cfg.sstTrigger = pNew->cfg.sstTrigger; pOld->cfg.tsdbPageSize = pNew->cfg.tsdbPageSize; + pOld->compactStartTime = pNew->compactStartTime; taosWUnLockLatch(&pOld->lock); return 0; } @@ -1378,7 +1381,63 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbVgVersion *pDbs, int32_t numOfDbs, return 0; } -static int32_t mndCompactDb(SMnode *pMnode, SDbObj *pDb) { return 0; } +static int32_t mndSetCompactDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, int64_t compactTs) { + SDbObj dbObj = {0}; + memcpy(&dbObj, pDb, sizeof(SDbObj)); + dbObj.compactStartTime = compactTs; + + SSdbRaw *pCommitRaw = mndDbActionEncode(&dbObj); + if (pCommitRaw == NULL) return -1; + if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) { + sdbFreeRaw(pCommitRaw); + return -1; + } + + (void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY); + return 0; +} + +static int32_t mndSetCompactDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, int64_t compactTs) { + SSdb *pSdb = pMnode->pSdb; + void *pIter = NULL; + + while (1) { + SVgObj *pVgroup = NULL; + pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup); + if (pIter == NULL) break; + + if (mndVgroupInDb(pVgroup, pDb->uid)) { + if (mndBuildCompactVgroupAction(pMnode, pTrans, pDb, pVgroup, compactTs) != 0) { + sdbCancelFetch(pSdb, pIter); + sdbRelease(pSdb, pVgroup); + return -1; + } + } + + sdbRelease(pSdb, pVgroup); + } + + return 0; +} + +static int32_t mndCompactDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb) { + int64_t compactTs = taosGetTimestampMs(); + int32_t code = -1; + STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "compact-db"); + if (pTrans == NULL) goto _OVER; + + mInfo("trans:%d, used to compact db:%s", pTrans->id, pDb->name); + mndTransSetDbName(pTrans, pDb->name, NULL); + if (mndTrancCheckConflict(pMnode, pTrans) != 0) goto _OVER; + if (mndSetCompactDbCommitLogs(pMnode, pTrans, pDb, compactTs) != 0) goto _OVER; + if (mndSetCompactDbRedoActions(pMnode, pTrans, pDb, compactTs) != 0) goto _OVER; + if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER; + code = 0; + +_OVER: + mndTransDrop(pTrans); + return code; +} static int32_t mndProcessCompactDbReq(SRpcMsg *pReq) { SMnode *pMnode = pReq->info.node; @@ -1402,10 +1461,11 @@ static int32_t mndProcessCompactDbReq(SRpcMsg *pReq) { goto _OVER; } - code = mndCompactDb(pMnode, pDb); + code = mndCompactDb(pMnode, pReq, pDb); + if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS; _OVER: - if (code != 0) { + if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) { mError("db:%s, failed to process compact db req since %s", compactReq.db, terrstr()); } diff --git a/source/dnode/mnode/impl/src/mndVgroup.c b/source/dnode/mnode/impl/src/mndVgroup.c index 301b7354d9..20be2ee3bb 100644 --- a/source/dnode/mnode/impl/src/mndVgroup.c +++ b/source/dnode/mnode/impl/src/mndVgroup.c @@ -796,6 +796,13 @@ static int32_t mndRetrieveVgroups(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); colDataAppend(pColInfo, numOfRows, (const char *)&pVgroup->isTsma, false); + // pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); + // if (pDb == NULL || pDb->compactStartTime <= 0) { + // colDataAppendNULL(pColInfo, numOfRows); + // } else { + // colDataAppend(pColInfo, numOfRows, (const char *)&pDb->compactStartTime, false); + // } + numOfRows++; sdbRelease(pSdb, pVgroup); } @@ -1168,7 +1175,8 @@ int32_t mndAddAlterVnodeReplicaAction(SMnode *pMnode, STrans *pTrans, SDbObj *pD return 0; } -static int32_t mndAddDisableVnodeWriteAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, int32_t dnodeId) { +static int32_t mndAddDisableVnodeWriteAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, + int32_t dnodeId) { SDnodeObj *pDnode = mndAcquireDnode(pMnode, dnodeId); if (pDnode == NULL) return -1; @@ -2192,3 +2200,59 @@ _OVER: } bool mndVgroupInDb(SVgObj *pVgroup, int64_t dbUid) { return !pVgroup->isTsma && pVgroup->dbUid == dbUid; } + +static void *mndBuildCompactVnodeReq(SMnode *pMnode, SDbObj *pDb, SVgObj *pVgroup, int32_t *pContLen, + int64_t compactTs) { + SCompactVnodeReq compactReq = {0}; + compactReq.dbUid = pDb->uid; + compactReq.compactStartTime = compactTs; + tstrncpy(compactReq.db, pDb->name, TSDB_DB_FNAME_LEN); + + mInfo("vgId:%d, build compact vnode config req", pVgroup->vgId); + int32_t contLen = tSerializeSCompactVnodeReq(NULL, 0, &compactReq); + if (contLen < 0) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } + contLen += sizeof(SMsgHead); + + void *pReq = taosMemoryMalloc(contLen); + if (pReq == NULL) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } + + SMsgHead *pHead = pReq; + pHead->contLen = htonl(contLen); + pHead->vgId = htonl(pVgroup->vgId); + + tSerializeSCompactVnodeReq((char *)pReq + sizeof(SMsgHead), contLen, &compactReq); + *pContLen = contLen; + return pReq; +} + +static int32_t mndAddCompactVnodeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, + int64_t compactTs) { + STransAction action = {0}; + action.epSet = mndGetVgroupEpset(pMnode, pVgroup); + + int32_t contLen = 0; + void *pReq = mndBuildCompactVnodeReq(pMnode, pDb, pVgroup, &contLen, compactTs); + if (pReq == NULL) return -1; + + action.pCont = pReq; + action.contLen = contLen; + action.msgType = TDMT_VND_COMPACT; + + if (mndTransAppendRedoAction(pTrans, &action) != 0) { + taosMemoryFree(pReq); + return -1; + } + + return 0; +} + +int32_t mndBuildCompactVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, int64_t compactTs) { + if (mndAddCompactVnodeAction(pMnode, pTrans, pDb, pVgroup, compactTs) != 0) return -1; + return 0; +} \ No newline at end of file diff --git a/source/dnode/vnode/CMakeLists.txt b/source/dnode/vnode/CMakeLists.txt index 1f7a059ffc..ea7046886e 100644 --- a/source/dnode/vnode/CMakeLists.txt +++ b/source/dnode/vnode/CMakeLists.txt @@ -14,6 +14,7 @@ target_sources( "src/vnd/vnodeSvr.c" "src/vnd/vnodeSync.c" "src/vnd/vnodeSnapshot.c" + "src/vnd/vnodeCompact.c" # meta "src/meta/metaOpen.c" @@ -53,6 +54,7 @@ target_sources( "src/tsdb/tsdbDiskData.c" "src/tsdb/tsdbCompact.c" "src/tsdb/tsdbMergeTree.c" + "src/tsdb/tsdbDataIter.c" # tq "src/tq/tq.c" diff --git a/source/dnode/vnode/src/inc/tsdb.h b/source/dnode/vnode/src/inc/tsdb.h index 18222cbf21..5e97e75025 100644 --- a/source/dnode/vnode/src/inc/tsdb.h +++ b/source/dnode/vnode/src/inc/tsdb.h @@ -69,6 +69,8 @@ typedef struct SDiskCol SDiskCol; typedef struct SDiskData SDiskData; typedef struct SDiskDataBuilder SDiskDataBuilder; typedef struct SBlkInfo SBlkInfo; +typedef struct STsdbDataIter2 STsdbDataIter2; +typedef struct STsdbFilterInfo STsdbFilterInfo; #define TSDBROW_ROW_FMT ((int8_t)0x0) #define TSDBROW_COL_FMT ((int8_t)0x1) @@ -163,6 +165,8 @@ void tBlockDataDestroy(SBlockData *pBlockData); int32_t tBlockDataInit(SBlockData *pBlockData, TABLEID *pId, STSchema *pTSchema, int16_t *aCid, int32_t nCid); void tBlockDataReset(SBlockData *pBlockData); int32_t tBlockDataAppendRow(SBlockData *pBlockData, TSDBROW *pRow, STSchema *pTSchema, int64_t uid); +int32_t tBlockDataTryUpsertRow(SBlockData *pBlockData, TSDBROW *pRow, int64_t uid); +int32_t tBlockDataUpsertRow(SBlockData *pBlockData, TSDBROW *pRow, STSchema *pTSchema, int64_t uid); void tBlockDataClear(SBlockData *pBlockData); void tBlockDataGetColData(SBlockData *pBlockData, int16_t cid, SColData **ppColData); int32_t tCmprBlockData(SBlockData *pBlockData, int8_t cmprAlg, uint8_t **ppOut, int32_t *szOut, uint8_t *aBuf[], @@ -277,6 +281,7 @@ int32_t tsdbReadDataBlk(SDataFReader *pReader, SBlockIdx *pBlockIdx, SMapData *m int32_t tsdbReadSttBlk(SDataFReader *pReader, int32_t iStt, SArray *aSttBlk); int32_t tsdbReadBlockSma(SDataFReader *pReader, SDataBlk *pBlock, SArray *aColumnDataAgg); int32_t tsdbReadDataBlock(SDataFReader *pReader, SDataBlk *pBlock, SBlockData *pBlockData); +int32_t tsdbReadDataBlockEx(SDataFReader *pReader, SDataBlk *pDataBlk, SBlockData *pBlockData); int32_t tsdbReadSttBlock(SDataFReader *pReader, int32_t iStt, SSttBlk *pSttBlk, SBlockData *pBlockData); int32_t tsdbReadSttBlockEx(SDataFReader *pReader, int32_t iStt, SSttBlk *pSttBlk, SBlockData *pBlockData); // SDelFWriter @@ -308,6 +313,26 @@ int32_t tDiskDataBuilderInit(SDiskDataBuilder *pBuilder, STSchema *pTSchema, TAB int32_t tDiskDataBuilderClear(SDiskDataBuilder *pBuilder); int32_t tDiskDataAddRow(SDiskDataBuilder *pBuilder, TSDBROW *pRow, STSchema *pTSchema, TABLEID *pId); int32_t tGnrtDiskData(SDiskDataBuilder *pBuilder, const SDiskData **ppDiskData, const SBlkInfo **ppBlkInfo); +// tsdbDataIter.c ============================================================================================== +#define TSDB_MEM_TABLE_DATA_ITER 0 +#define TSDB_DATA_FILE_DATA_ITER 1 +#define TSDB_STT_FILE_DATA_ITER 2 +#define TSDB_TOMB_FILE_DATA_ITER 3 + +#define TSDB_FILTER_FLAG_BY_VERSION 0x1 +#define TSDB_FILTER_FLAG_BY_TABLEID 0x2 + +#define TSDB_RBTN_TO_DATA_ITER(pNode) ((STsdbDataIter2 *)(((char *)pNode) - offsetof(STsdbDataIter2, rbtn))) +/* open */ +int32_t tsdbOpenDataFileDataIter(SDataFReader *pReader, STsdbDataIter2 **ppIter); +int32_t tsdbOpenSttFileDataIter(SDataFReader *pReader, int32_t iStt, STsdbDataIter2 **ppIter); +int32_t tsdbOpenTombFileDataIter(SDelFReader *pReader, STsdbDataIter2 **ppIter); +/* close */ +void tsdbCloseDataIter2(STsdbDataIter2 *pIter); +/* cmpr */ +int32_t tsdbDataIterCmprFn(const SRBTreeNode *pNode1, const SRBTreeNode *pNode2); +/* next */ +int32_t tsdbDataIterNext2(STsdbDataIter2 *pIter, STsdbFilterInfo *pFilterInfo); // structs ======================= struct STsdbFS { @@ -644,6 +669,7 @@ struct SDataFReader { uint8_t *aBuf[3]; }; +// NOTE: do NOT change the order of the fields typedef struct { int64_t suid; int64_t uid; @@ -830,6 +856,65 @@ static FORCE_INLINE TSDBROW *tsdbTbDataIterGet(STbDataIter *pIter) { return pIter->pRow; } +int32_t tRowInfoCmprFn(const void *p1, const void *p2); + +typedef struct { + int64_t suid; + int64_t uid; + SDelData delData; +} SDelInfo; + +struct STsdbDataIter2 { + STsdbDataIter2 *next; + SRBTreeNode rbtn; + + int32_t type; + SRowInfo rowInfo; + SDelInfo delInfo; + union { + // TSDB_MEM_TABLE_DATA_ITER + struct { + SMemTable *pMemTable; + } mIter; + + // TSDB_DATA_FILE_DATA_ITER + struct { + SDataFReader *pReader; + SArray *aBlockIdx; // SArray + SMapData mDataBlk; + SBlockData bData; + int32_t iBlockIdx; + int32_t iDataBlk; + int32_t iRow; + } dIter; + + // TSDB_STT_FILE_DATA_ITER + struct { + SDataFReader *pReader; + int32_t iStt; + SArray *aSttBlk; + SBlockData bData; + int32_t iSttBlk; + int32_t iRow; + } sIter; + // TSDB_TOMB_FILE_DATA_ITER + struct { + SDelFReader *pReader; + SArray *aDelIdx; + SArray *aDelData; + int32_t iDelIdx; + int32_t iDelData; + } tIter; + }; +}; + +struct STsdbFilterInfo { + int32_t flag; + int64_t sver; + int64_t ever; + TABLEID tbid; +}; + #ifdef __cplusplus } #endif diff --git a/source/dnode/vnode/src/inc/vnd.h b/source/dnode/vnode/src/inc/vnd.h index e0d0e9408b..f06548bbdd 100644 --- a/source/dnode/vnode/src/inc/vnd.h +++ b/source/dnode/vnode/src/inc/vnd.h @@ -106,6 +106,10 @@ int32_t vnodeSyncCommit(SVnode* pVnode); int32_t vnodeAsyncCommit(SVnode* pVnode); bool vnodeShouldRollback(SVnode* pVnode); +// vnodeCompact.c +int32_t vnodeAsyncCompact(SVnode* pVnode); +int32_t vnodeSyncCompact(SVnode* pVnode); + // vnodeSync.c int32_t vnodeSyncOpen(SVnode* pVnode, char* path); int32_t vnodeSyncStart(SVnode* pVnode); diff --git a/source/dnode/vnode/src/inc/vnodeInt.h b/source/dnode/vnode/src/inc/vnodeInt.h index 84330b279f..f420f2ff8d 100644 --- a/source/dnode/vnode/src/inc/vnodeInt.h +++ b/source/dnode/vnode/src/inc/vnodeInt.h @@ -450,8 +450,10 @@ struct SCommitInfo { SVnodeInfo info; SVnode* pVnode; TXN* txn; -}; + // APIs + int32_t (*commitFn)(STsdb* pTsdb, SCommitInfo* pInfo); +}; #ifdef __cplusplus } #endif diff --git a/source/dnode/vnode/src/tsdb/tsdbCompact.c b/source/dnode/vnode/src/tsdb/tsdbCompact.c index fb3917be64..75023f3ef2 100644 --- a/source/dnode/vnode/src/tsdb/tsdbCompact.c +++ b/source/dnode/vnode/src/tsdb/tsdbCompact.c @@ -15,13 +15,654 @@ #include "tsdb.h" +extern int32_t tsdbUpdateTableSchema(SMeta *pMeta, int64_t suid, int64_t uid, SSkmInfo *pSkmInfo); +extern int32_t tsdbWriteDataBlock(SDataFWriter *pWriter, SBlockData *pBlockData, SMapData *mDataBlk, int8_t cmprAlg); +extern int32_t tsdbWriteSttBlock(SDataFWriter *pWriter, SBlockData *pBlockData, SArray *aSttBlk, int8_t cmprAlg); + typedef struct { STsdb *pTsdb; + int64_t commitID; + int8_t cmprAlg; + int32_t maxRows; + int32_t minRows; + STsdbFS fs; + + int32_t fid; + TABLEID tbid; + SSkmInfo tbSkm; + + // Tombstone + SDelFReader *pDelFReader; + SArray *aDelIdx; // SArray + SArray *aDelData; // SArray + SArray *aSkyLine; // SArray + int32_t iDelIdx; + int32_t iSkyLine; + TSDBKEY *pDKey; + TSDBKEY dKey; + + // Reader + SDataFReader *pReader; + STsdbDataIter2 *iterList; // list of iterators + STsdbDataIter2 *pIter; + SRBTree rbt; + + // Writer + SDataFWriter *pWriter; + SArray *aBlockIdx; // SArray + SMapData mDataBlk; // SMapData + SArray *aSttBlk; // SArray + SBlockData bData; + SBlockData sData; } STsdbCompactor; -int32_t tsdbCompact(STsdb *pTsdb) { +static int32_t tsdbCommitCompact(STsdbCompactor *pCompactor) { int32_t code = 0; - // TODO + int32_t lino = 0; + + STsdb *pTsdb = pCompactor->pTsdb; + + code = tsdbFSPrepareCommit(pTsdb, &pCompactor->fs); + TSDB_CHECK_CODE(code, lino, _exit); + + taosThreadRwlockWrlock(&pTsdb->rwLock); + + code = tsdbFSCommit(pTsdb); + if (code) { + taosThreadRwlockUnlock(&pTsdb->rwLock); + TSDB_CHECK_CODE(code, lino, _exit); + } + + taosThreadRwlockUnlock(&pTsdb->rwLock); + +_exit: + if (code) { + tsdbError("vgId:%d %s failed at line %d since %s", TD_VID(pTsdb->pVnode), __func__, lino, tstrerror(code)); + } + return code; +} + +static int32_t tsdbAbortCompact(STsdbCompactor *pCompactor) { + int32_t code = 0; + int32_t lino = 0; + + STsdb *pTsdb = pCompactor->pTsdb; + + // TODO + ASSERT(0); + +_exit: + if (code) { + tsdbError("vgId:%d %s failed at line %d since %s", TD_VID(pTsdb->pVnode), __func__, lino, tstrerror(code)); + } else { + tsdbInfo("vgId:%d %s done", TD_VID(pTsdb->pVnode), __func__); + } + return code; +} + +static int32_t tsdbCompactWriteTableDataStart(STsdbCompactor *pCompactor, TABLEID *pId) { + int32_t code = 0; + int32_t lino = 0; + + pCompactor->tbid = *pId; + + // tombstone + for (;;) { + if (pCompactor->iDelIdx >= taosArrayGetSize(pCompactor->aDelIdx)) { + pCompactor->pDKey = NULL; + break; + } + + SDelIdx *pDelIdx = (SDelIdx *)taosArrayGet(pCompactor->aDelIdx, pCompactor->iDelIdx); + int32_t c = tTABLEIDCmprFn(pDelIdx, &pCompactor->tbid); + if (c < 0) { + pCompactor->iDelIdx++; + } else if (c == 0) { + pCompactor->iDelIdx++; + + code = tsdbReadDelData(pCompactor->pDelFReader, pDelIdx, pCompactor->aDelData); + TSDB_CHECK_CODE(code, lino, _exit); + + code = tsdbBuildDeleteSkyline(pCompactor->aDelData, 0, taosArrayGetSize(pCompactor->aDelData) - 1, + pCompactor->aSkyLine); + TSDB_CHECK_CODE(code, lino, _exit); + + pCompactor->iSkyLine = 0; + if (pCompactor->iSkyLine < taosArrayGetSize(pCompactor->aSkyLine)) { + TSDBKEY *pKey = (TSDBKEY *)taosArrayGet(pCompactor->aSkyLine, pCompactor->iSkyLine); + + pCompactor->dKey.version = 0; + pCompactor->dKey.ts = pKey->ts; + pCompactor->pDKey = &pCompactor->dKey; + } else { + pCompactor->pDKey = NULL; + } + break; + } else { + pCompactor->pDKey = NULL; + break; + } + } + + // writer + code = tsdbUpdateTableSchema(pCompactor->pTsdb->pVnode->pMeta, pId->suid, pId->uid, &pCompactor->tbSkm); + TSDB_CHECK_CODE(code, lino, _exit); + + tMapDataReset(&pCompactor->mDataBlk); + + code = tBlockDataInit(&pCompactor->bData, pId, pCompactor->tbSkm.pTSchema, NULL, 0); + TSDB_CHECK_CODE(code, lino, _exit); + + if (!TABLE_SAME_SCHEMA(pCompactor->sData.suid, pCompactor->sData.uid, pId->suid, pId->uid)) { + if (pCompactor->sData.nRow > 0) { + code = tsdbWriteSttBlock(pCompactor->pWriter, &pCompactor->sData, pCompactor->aSttBlk, pCompactor->cmprAlg); + TSDB_CHECK_CODE(code, lino, _exit); + } + + TABLEID tbid = {.suid = pId->suid, .uid = pId->suid ? 0 : pId->uid}; + code = tBlockDataInit(&pCompactor->sData, &tbid, pCompactor->tbSkm.pTSchema, NULL, 0); + TSDB_CHECK_CODE(code, lino, _exit); + } + +_exit: + if (code) { + tsdbError("vgId:%d %s failed at line %d since %s", TD_VID(pCompactor->pTsdb->pVnode), __func__, lino, + tstrerror(code)); + } else { + tsdbDebug("vgId:%d %s done, suid:%" PRId64 " uid:%" PRId64, TD_VID(pCompactor->pTsdb->pVnode), __func__, pId->suid, + pId->uid); + } + return code; +} + +static int32_t tsdbCompactWriteTableDataEnd(STsdbCompactor *pCompactor) { + int32_t code = 0; + int32_t lino = 0; + + if (pCompactor->bData.nRow > 0) { + if (pCompactor->bData.nRow < pCompactor->minRows) { + for (int32_t iRow = 0; iRow < pCompactor->bData.nRow; iRow++) { + code = tBlockDataAppendRow(&pCompactor->sData, &tsdbRowFromBlockData(&pCompactor->bData, iRow), NULL, + pCompactor->tbid.uid); + TSDB_CHECK_CODE(code, lino, _exit); + + if (pCompactor->sData.nRow >= pCompactor->maxRows) { + code = tsdbWriteSttBlock(pCompactor->pWriter, &pCompactor->sData, pCompactor->aSttBlk, pCompactor->cmprAlg); + TSDB_CHECK_CODE(code, lino, _exit); + } + } + tBlockDataClear(&pCompactor->bData); + } else { + code = tsdbWriteDataBlock(pCompactor->pWriter, &pCompactor->bData, &pCompactor->mDataBlk, pCompactor->cmprAlg); + TSDB_CHECK_CODE(code, lino, _exit); + } + } + + if (pCompactor->mDataBlk.nItem > 0) { + SBlockIdx *pBlockIdx = (SBlockIdx *)taosArrayReserve(pCompactor->aBlockIdx, 1); + if (pBlockIdx == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + TSDB_CHECK_CODE(code, lino, _exit); + } + + pBlockIdx->suid = pCompactor->tbid.suid; + pBlockIdx->uid = pCompactor->tbid.uid; + + code = tsdbWriteDataBlk(pCompactor->pWriter, &pCompactor->mDataBlk, pBlockIdx); + TSDB_CHECK_CODE(code, lino, _exit); + } + +_exit: + if (code) { + tsdbError("vgId:%d %s failed at line %d since %s", TD_VID(pCompactor->pTsdb->pVnode), __func__, lino, + tstrerror(code)); + } else { + tsdbDebug("vgId:%d %s done, suid:%" PRId64 " uid:%" PRId64, TD_VID(pCompactor->pTsdb->pVnode), __func__, + pCompactor->tbid.suid, pCompactor->tbid.uid); + } + return code; +} + +static bool tsdbCompactRowIsDeleted(STsdbCompactor *pCompactor, TSDBROW *pRow) { + TSDBKEY tKey = TSDBROW_KEY(pRow); + TSDBKEY *aKey = (TSDBKEY *)TARRAY_DATA(pCompactor->aSkyLine); + int32_t nKey = TARRAY_SIZE(pCompactor->aSkyLine); + + if (tKey.ts > pCompactor->pDKey->ts) { + do { + pCompactor->pDKey->version = aKey[pCompactor->iSkyLine].version; + pCompactor->iSkyLine++; + if (pCompactor->iSkyLine < nKey) { + pCompactor->dKey.ts = aKey[pCompactor->iSkyLine].ts; + } else { + if (pCompactor->pDKey->version == 0) { + pCompactor->pDKey = NULL; + return false; + } else { + pCompactor->pDKey->ts = INT64_MAX; + } + } + } while (tKey.ts > pCompactor->pDKey->ts); + } + + if (tKey.ts < pCompactor->pDKey->ts) { + if (tKey.version > pCompactor->pDKey->version) { + return false; + } else { + return true; + } + } else if (tKey.ts == pCompactor->pDKey->ts) { + ASSERT(pCompactor->iSkyLine < nKey); + if (tKey.version > TMAX(pCompactor->pDKey->version, aKey[pCompactor->iSkyLine].version)) { + return false; + } else { + return true; + } + } + + return false; +} + +static int32_t tsdbCompactWriteTableData(STsdbCompactor *pCompactor, SRowInfo *pRowInfo) { + int32_t code = 0; + int32_t lino = 0; + + // start a new table data write if need + if (pRowInfo == NULL || pRowInfo->uid != pCompactor->tbid.uid) { + if (pCompactor->tbid.uid) { + code = tsdbCompactWriteTableDataEnd(pCompactor); + TSDB_CHECK_CODE(code, lino, _exit); + } + + if (pRowInfo == NULL) { + if (pCompactor->sData.nRow > 0) { + code = tsdbWriteSttBlock(pCompactor->pWriter, &pCompactor->sData, pCompactor->aSttBlk, pCompactor->cmprAlg); + TSDB_CHECK_CODE(code, lino, _exit); + } + return code; + } + + code = tsdbCompactWriteTableDataStart(pCompactor, (TABLEID *)pRowInfo); + TSDB_CHECK_CODE(code, lino, _exit); + } + + // check if row is deleted + if (pCompactor->pDKey && tsdbCompactRowIsDeleted(pCompactor, &pRowInfo->row)) goto _exit; + + if (tBlockDataTryUpsertRow(&pCompactor->bData, &pRowInfo->row, pRowInfo->uid) > pCompactor->maxRows) { + code = tsdbWriteDataBlock(pCompactor->pWriter, &pCompactor->bData, &pCompactor->mDataBlk, pCompactor->cmprAlg); + TSDB_CHECK_CODE(code, lino, _exit); + } + + code = tBlockDataUpsertRow(&pCompactor->bData, &pRowInfo->row, NULL, pRowInfo->uid); + TSDB_CHECK_CODE(code, lino, _exit); + +_exit: + if (code) { + tsdbError("vgId:%d %s failed at line %d since %s", TD_VID(pCompactor->pTsdb->pVnode), __func__, lino, + tstrerror(code)); + } else if (pRowInfo) { + tsdbTrace("vgId:%d %s done, suid:%" PRId64 " uid:%" PRId64 " ts:%" PRId64 " version:%" PRId64, + TD_VID(pCompactor->pTsdb->pVnode), __func__, pRowInfo->suid, pRowInfo->uid, TSDBROW_TS(&pRowInfo->row), + TSDBROW_VERSION(&pRowInfo->row)); + } + return code; +} + +static bool tsdbCompactTableIsDropped(STsdbCompactor *pCompactor) { + SMetaInfo info; + + if (pCompactor->pIter->rowInfo.uid == pCompactor->tbid.uid) return false; + if (metaGetInfo(pCompactor->pTsdb->pVnode->pMeta, pCompactor->tbid.uid, &info, NULL)) { + return true; + } + return false; +} +static int32_t tsdbCompactNextRow(STsdbCompactor *pCompactor, SRowInfo **ppRowInfo) { + int32_t code = 0; + int32_t lino = 0; + + for (;;) { + if (pCompactor->pIter) { + code = tsdbDataIterNext2(pCompactor->pIter, NULL); + TSDB_CHECK_CODE(code, lino, _exit); + + if (pCompactor->pIter->rowInfo.suid == 0 && pCompactor->pIter->rowInfo.uid == 0) { + pCompactor->pIter = NULL; + } else { + SRBTreeNode *pNode = tRBTreeMin(&pCompactor->rbt); + if (pNode) { + int32_t c = tsdbDataIterCmprFn(&pCompactor->pIter->rbtn, pNode); + if (c > 0) { + tRBTreePut(&pCompactor->rbt, &pCompactor->pIter->rbtn); + pCompactor->pIter = NULL; + } else if (c == 0) { + ASSERT(0); + } + } + } + } + + if (pCompactor->pIter == NULL) { + SRBTreeNode *pNode = tRBTreeDropMin(&pCompactor->rbt); + if (pNode) { + pCompactor->pIter = TSDB_RBTN_TO_DATA_ITER(pNode); + } + } + + if (pCompactor->pIter) { + if (tsdbCompactTableIsDropped(pCompactor)) { + TABLEID tbid = {.suid = pCompactor->pIter->rowInfo.suid, .uid = pCompactor->pIter->rowInfo.uid}; + tRBTreeClear(&pCompactor->rbt); + for (pCompactor->pIter = pCompactor->iterList; pCompactor->pIter; pCompactor->pIter = pCompactor->pIter->next) { + code = tsdbDataIterNext2(pCompactor->pIter, + &(STsdbFilterInfo){.flag = TSDB_FILTER_FLAG_BY_TABLEID, .tbid = tbid}); + TSDB_CHECK_CODE(code, lino, _exit); + + if (pCompactor->pIter->rowInfo.suid || pCompactor->pIter->rowInfo.uid) { + tRBTreePut(&pCompactor->rbt, &pCompactor->pIter->rbtn); + } + } + } else { + *ppRowInfo = &pCompactor->pIter->rowInfo; + break; + } + } else { + *ppRowInfo = NULL; + break; + } + } + +_exit: + if (code) { + tsdbError("vgId:%d %s failed at line %d since %s", TD_VID(pCompactor->pTsdb->pVnode), __func__, lino, + tstrerror(code)); + } + return code; +} + +static int32_t tsdbCompactFileSetStart(STsdbCompactor *pCompactor, SDFileSet *pSet) { + int32_t code = 0; + int32_t lino = 0; + + pCompactor->fid = pSet->fid; + pCompactor->tbid = (TABLEID){0}; + + /* tombstone */ + pCompactor->iDelIdx = 0; + + /* reader */ + code = tsdbDataFReaderOpen(&pCompactor->pReader, pCompactor->pTsdb, pSet); + TSDB_CHECK_CODE(code, lino, _exit); + + code = tsdbOpenDataFileDataIter(pCompactor->pReader, &pCompactor->pIter); + TSDB_CHECK_CODE(code, lino, _exit); + + tRBTreeCreate(&pCompactor->rbt, tsdbDataIterCmprFn); + if (pCompactor->pIter) { + pCompactor->pIter->next = pCompactor->iterList; + pCompactor->iterList = pCompactor->pIter; + + code = tsdbDataIterNext2(pCompactor->pIter, NULL); + TSDB_CHECK_CODE(code, lino, _exit); + + ASSERT(pCompactor->pIter->rowInfo.suid || pCompactor->pIter->rowInfo.uid); + tRBTreePut(&pCompactor->rbt, &pCompactor->pIter->rbtn); + } + + for (int32_t iStt = 0; iStt < pSet->nSttF; iStt++) { + code = tsdbOpenSttFileDataIter(pCompactor->pReader, iStt, &pCompactor->pIter); + TSDB_CHECK_CODE(code, lino, _exit); + + if (pCompactor->pIter) { + pCompactor->pIter->next = pCompactor->iterList; + pCompactor->iterList = pCompactor->pIter; + + code = tsdbDataIterNext2(pCompactor->pIter, NULL); + TSDB_CHECK_CODE(code, lino, _exit); + + ASSERT(pCompactor->pIter->rowInfo.suid || pCompactor->pIter->rowInfo.uid); + tRBTreePut(&pCompactor->rbt, &pCompactor->pIter->rbtn); + } + } + pCompactor->pIter = NULL; + + /* writer */ + code = tsdbDataFWriterOpen(&pCompactor->pWriter, pCompactor->pTsdb, + &(SDFileSet){.fid = pCompactor->fid, + .diskId = pSet->diskId, + .pHeadF = &(SHeadFile){.commitID = pCompactor->commitID}, + .pDataF = &(SDataFile){.commitID = pCompactor->commitID}, + .pSmaF = &(SSmaFile){.commitID = pCompactor->commitID}, + .nSttF = 1, + .aSttF = {&(SSttFile){.commitID = pCompactor->commitID}}}); + TSDB_CHECK_CODE(code, lino, _exit); + + if (pCompactor->aBlockIdx) { + taosArrayClear(pCompactor->aBlockIdx); + } else if ((pCompactor->aBlockIdx = taosArrayInit(0, sizeof(SBlockIdx))) == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + TSDB_CHECK_CODE(code, lino, _exit); + } + + tMapDataReset(&pCompactor->mDataBlk); + + if (pCompactor->aSttBlk) { + taosArrayClear(pCompactor->aSttBlk); + } else if ((pCompactor->aSttBlk = taosArrayInit(0, sizeof(SSttBlk))) == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + TSDB_CHECK_CODE(code, lino, _exit); + } + + tBlockDataReset(&pCompactor->bData); + tBlockDataReset(&pCompactor->sData); + +_exit: + if (code) { + tsdbError("vgId:%d %s failed at line %d since %s, fid:%d", TD_VID(pCompactor->pTsdb->pVnode), __func__, lino, + tstrerror(code), pCompactor->fid); + } else { + tsdbInfo("vgId:%d %s done, fid:%d", TD_VID(pCompactor->pTsdb->pVnode), __func__, pCompactor->fid); + } + return code; +} + +static int32_t tsdbCompactFileSetEnd(STsdbCompactor *pCompactor) { + int32_t code = 0; + int32_t lino = 0; + + ASSERT(pCompactor->bData.nRow == 0); + ASSERT(pCompactor->sData.nRow == 0); + + /* update files */ + code = tsdbWriteSttBlk(pCompactor->pWriter, pCompactor->aSttBlk); + TSDB_CHECK_CODE(code, lino, _exit); + + code = tsdbWriteBlockIdx(pCompactor->pWriter, pCompactor->aBlockIdx); + TSDB_CHECK_CODE(code, lino, _exit); + + code = tsdbUpdateDFileSetHeader(pCompactor->pWriter); + TSDB_CHECK_CODE(code, lino, _exit); + + code = tsdbFSUpsertFSet(&pCompactor->fs, &pCompactor->pWriter->wSet); + TSDB_CHECK_CODE(code, lino, _exit); + + code = tsdbDataFWriterClose(&pCompactor->pWriter, 1); + TSDB_CHECK_CODE(code, lino, _exit); + + code = tsdbDataFReaderClose(&pCompactor->pReader); + TSDB_CHECK_CODE(code, lino, _exit); + + /* do clear */ + while ((pCompactor->pIter = pCompactor->iterList) != NULL) { + pCompactor->iterList = pCompactor->pIter->next; + tsdbCloseDataIter2(pCompactor->pIter); + } + + tBlockDataReset(&pCompactor->bData); + tBlockDataReset(&pCompactor->sData); + +_exit: + if (code) { + tsdbError("vgId:%d %s failed at line %d since %s, fid:%d", TD_VID(pCompactor->pTsdb->pVnode), __func__, lino, + tstrerror(code), pCompactor->fid); + } else { + tsdbInfo("vgId:%d %s done, fid:%d", TD_VID(pCompactor->pTsdb->pVnode), __func__, pCompactor->fid); + } + return code; +} + +static int32_t tsdbCompactFileSet(STsdbCompactor *pCompactor, SDFileSet *pSet) { + int32_t code = 0; + int32_t lino = 0; + + // start compact + code = tsdbCompactFileSetStart(pCompactor, pSet); + TSDB_CHECK_CODE(code, lino, _exit); + + // do compact, end with a NULL row + SRowInfo *pRowInfo; + do { + code = tsdbCompactNextRow(pCompactor, &pRowInfo); + TSDB_CHECK_CODE(code, lino, _exit); + + code = tsdbCompactWriteTableData(pCompactor, pRowInfo); + TSDB_CHECK_CODE(code, lino, _exit); + } while (pRowInfo); + + // end compact + code = tsdbCompactFileSetEnd(pCompactor); + TSDB_CHECK_CODE(code, lino, _exit); + +_exit: + if (code) { + tsdbError("vgId:%d %s failed at line %d since %s, fid:%d", TD_VID(pCompactor->pTsdb->pVnode), __func__, lino, + tstrerror(code), pCompactor->fid); + if (pCompactor->pWriter) tsdbDataFWriterClose(&pCompactor->pWriter, 0); + while ((pCompactor->pIter = pCompactor->iterList)) { + pCompactor->iterList = pCompactor->pIter->next; + tsdbCloseDataIter2(pCompactor->pIter); + } + if (pCompactor->pReader) tsdbDataFReaderClose(&pCompactor->pReader); + } + return code; +} + +static void tsdbEndCompact(STsdbCompactor *pCompactor) { + // writer + tBlockDataDestroy(&pCompactor->sData); + tBlockDataDestroy(&pCompactor->bData); + taosArrayDestroy(pCompactor->aSttBlk); + tMapDataClear(&pCompactor->mDataBlk); + taosArrayDestroy(pCompactor->aBlockIdx); + + // reader + + // tombstone + taosArrayDestroy(pCompactor->aSkyLine); + taosArrayDestroy(pCompactor->aDelData); + taosArrayDestroy(pCompactor->aDelIdx); + + // others + tDestroyTSchema(pCompactor->tbSkm.pTSchema); + tsdbFSDestroy(&pCompactor->fs); + + tsdbInfo("vgId:%d %s done, commit ID:%" PRId64, TD_VID(pCompactor->pTsdb->pVnode), __func__, pCompactor->commitID); +} + +static int32_t tsdbBeginCompact(STsdb *pTsdb, STsdbCompactor *pCompactor) { + int32_t code = 0; + int32_t lino = 0; + + pCompactor->pTsdb = pTsdb; + pCompactor->commitID = 0; // TODO + pCompactor->cmprAlg = pTsdb->pVnode->config.tsdbCfg.compression; + pCompactor->maxRows = pTsdb->pVnode->config.tsdbCfg.maxRows; + pCompactor->minRows = pTsdb->pVnode->config.tsdbCfg.minRows; + pCompactor->fid = INT32_MIN; + + code = tsdbFSCopy(pTsdb, &pCompactor->fs); + TSDB_CHECK_CODE(code, lino, _exit); + + /* tombstone */ + if (pCompactor->fs.pDelFile) { + code = tsdbDelFReaderOpen(&pCompactor->pDelFReader, pCompactor->fs.pDelFile, pTsdb); + TSDB_CHECK_CODE(code, lino, _exit); + + if ((pCompactor->aDelIdx = taosArrayInit(0, sizeof(SDelIdx))) == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + TSDB_CHECK_CODE(code, lino, _exit); + } + + if ((pCompactor->aDelData = taosArrayInit(0, sizeof(SDelData))) == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + TSDB_CHECK_CODE(code, lino, _exit); + } + + if ((pCompactor->aSkyLine = taosArrayInit(0, sizeof(TSDBKEY))) == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + TSDB_CHECK_CODE(code, lino, _exit); + } + + code = tsdbReadDelIdx(pCompactor->pDelFReader, pCompactor->aDelIdx); + TSDB_CHECK_CODE(code, lino, _exit); + } + + /* reader */ + + /* writer */ + code = tBlockDataCreate(&pCompactor->bData); + TSDB_CHECK_CODE(code, lino, _exit); + + code = tBlockDataCreate(&pCompactor->sData); + TSDB_CHECK_CODE(code, lino, _exit); + +_exit: + if (code) { + tsdbError("vgId:%d %s failed at line %d since %s, commit ID:%" PRId64, TD_VID(pTsdb->pVnode), __func__, lino, + tstrerror(code), pCompactor->commitID); + tBlockDataDestroy(&pCompactor->sData); + tBlockDataDestroy(&pCompactor->bData); + if (pCompactor->fs.pDelFile) { + taosArrayDestroy(pCompactor->aSkyLine); + taosArrayDestroy(pCompactor->aDelData); + taosArrayDestroy(pCompactor->aDelIdx); + if (pCompactor->pDelFReader) tsdbDelFReaderClose(&pCompactor->pDelFReader); + } + tsdbFSDestroy(&pCompactor->fs); + } else { + tsdbInfo("vgId:%d %s done, commit ID:%" PRId64, TD_VID(pTsdb->pVnode), __func__, pCompactor->commitID); + } + return code; +} + +int32_t tsdbCompact(STsdb *pTsdb, int32_t flag) { + int32_t code = 0; + + STsdbCompactor *pCompactor = &(STsdbCompactor){0}; + + if ((code = tsdbBeginCompact(pTsdb, pCompactor))) return code; + + for (;;) { + SDFileSet *pSet = (SDFileSet *)taosArraySearch(pCompactor->fs.aDFileSet, &(SDFileSet){.fid = pCompactor->fid}, + tDFileSetCmprFn, TD_GT); + if (pSet == NULL) { + pCompactor->fid = INT32_MAX; + break; + } + + if ((code = tsdbCompactFileSet(pCompactor, pSet))) goto _exit; + } + + if ((code = tsdbFSUpsertDelFile(&pCompactor->fs, NULL))) goto _exit; + +_exit: + if (code) { + tsdbAbortCompact(pCompactor); + } else { + tsdbCommitCompact(pCompactor); + } + tsdbEndCompact(pCompactor); return code; } diff --git a/source/dnode/vnode/src/tsdb/tsdbDataIter.c b/source/dnode/vnode/src/tsdb/tsdbDataIter.c new file mode 100644 index 0000000000..2f49781276 --- /dev/null +++ b/source/dnode/vnode/src/tsdb/tsdbDataIter.c @@ -0,0 +1,458 @@ +/* + * 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 . + */ + +#include "tsdb.h" + +// STsdbDataIter2 +/* open */ +int32_t tsdbOpenDataFileDataIter(SDataFReader* pReader, STsdbDataIter2** ppIter) { + int32_t code = 0; + int32_t lino = 0; + + // create handle + STsdbDataIter2* pIter = (STsdbDataIter2*)taosMemoryCalloc(1, sizeof(*pIter)); + if (pIter == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + TSDB_CHECK_CODE(code, lino, _exit); + } + + pIter->type = TSDB_DATA_FILE_DATA_ITER; + pIter->dIter.pReader = pReader; + if ((pIter->dIter.aBlockIdx = taosArrayInit(0, sizeof(SBlockIdx))) == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + TSDB_CHECK_CODE(code, lino, _exit); + } + + code = tBlockDataCreate(&pIter->dIter.bData); + TSDB_CHECK_CODE(code, lino, _exit); + + pIter->dIter.iBlockIdx = 0; + pIter->dIter.iDataBlk = 0; + pIter->dIter.iRow = 0; + + // read data + code = tsdbReadBlockIdx(pReader, pIter->dIter.aBlockIdx); + TSDB_CHECK_CODE(code, lino, _exit); + + if (taosArrayGetSize(pIter->dIter.aBlockIdx) == 0) goto _clear; + +_exit: + if (code) { + if (pIter) { + _clear: + tBlockDataDestroy(&pIter->dIter.bData); + taosArrayDestroy(pIter->dIter.aBlockIdx); + taosMemoryFree(pIter); + pIter = NULL; + } + } + *ppIter = pIter; + return code; +} + +int32_t tsdbOpenSttFileDataIter(SDataFReader* pReader, int32_t iStt, STsdbDataIter2** ppIter) { + int32_t code = 0; + int32_t lino = 0; + + // create handle + STsdbDataIter2* pIter = (STsdbDataIter2*)taosMemoryCalloc(1, sizeof(*pIter)); + if (pIter == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + TSDB_CHECK_CODE(code, lino, _exit); + } + + pIter->type = TSDB_STT_FILE_DATA_ITER; + pIter->sIter.pReader = pReader; + pIter->sIter.iStt = iStt; + pIter->sIter.aSttBlk = taosArrayInit(0, sizeof(SSttBlk)); + if (pIter->sIter.aSttBlk == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + TSDB_CHECK_CODE(code, lino, _exit); + } + + code = tBlockDataCreate(&pIter->sIter.bData); + TSDB_CHECK_CODE(code, lino, _exit); + + pIter->sIter.iSttBlk = 0; + pIter->sIter.iRow = 0; + + // read data + code = tsdbReadSttBlk(pReader, iStt, pIter->sIter.aSttBlk); + TSDB_CHECK_CODE(code, lino, _exit); + + if (taosArrayGetSize(pIter->sIter.aSttBlk) == 0) goto _clear; + +_exit: + if (code) { + if (pIter) { + _clear: + taosArrayDestroy(pIter->sIter.aSttBlk); + tBlockDataDestroy(&pIter->sIter.bData); + taosMemoryFree(pIter); + pIter = NULL; + } + } + *ppIter = pIter; + return code; +} + +int32_t tsdbOpenTombFileDataIter(SDelFReader* pReader, STsdbDataIter2** ppIter) { + int32_t code = 0; + int32_t lino = 0; + + STsdbDataIter2* pIter = (STsdbDataIter2*)taosMemoryCalloc(1, sizeof(*pIter)); + if (pIter == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + TSDB_CHECK_CODE(code, lino, _exit); + } + pIter->type = TSDB_TOMB_FILE_DATA_ITER; + + pIter->tIter.pReader = pReader; + if ((pIter->tIter.aDelIdx = taosArrayInit(0, sizeof(SDelIdx))) == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + TSDB_CHECK_CODE(code, lino, _exit); + } + if ((pIter->tIter.aDelData = taosArrayInit(0, sizeof(SDelData))) == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + TSDB_CHECK_CODE(code, lino, _exit); + } + + code = tsdbReadDelIdx(pReader, pIter->tIter.aDelIdx); + TSDB_CHECK_CODE(code, lino, _exit); + + if (taosArrayGetSize(pIter->tIter.aDelIdx) == 0) goto _clear; + + pIter->tIter.iDelIdx = 0; + pIter->tIter.iDelData = 0; + +_exit: + if (code) { + if (pIter) { + _clear: + taosArrayDestroy(pIter->tIter.aDelIdx); + taosArrayDestroy(pIter->tIter.aDelData); + taosMemoryFree(pIter); + pIter = NULL; + } + } + *ppIter = pIter; + return code; +} + +/* close */ +static void tsdbCloseDataFileDataIter(STsdbDataIter2* pIter) { + tBlockDataDestroy(&pIter->dIter.bData); + tMapDataClear(&pIter->dIter.mDataBlk); + taosArrayDestroy(pIter->dIter.aBlockIdx); + taosMemoryFree(pIter); +} + +static void tsdbCloseSttFileDataIter(STsdbDataIter2* pIter) { + tBlockDataDestroy(&pIter->sIter.bData); + taosArrayDestroy(pIter->sIter.aSttBlk); + taosMemoryFree(pIter); +} + +static void tsdbCloseTombFileDataIter(STsdbDataIter2* pIter) { + taosArrayDestroy(pIter->tIter.aDelData); + taosArrayDestroy(pIter->tIter.aDelIdx); + taosMemoryFree(pIter); +} + +void tsdbCloseDataIter2(STsdbDataIter2* pIter) { + if (pIter->type == TSDB_MEM_TABLE_DATA_ITER) { + ASSERT(0); + } else if (pIter->type == TSDB_DATA_FILE_DATA_ITER) { + tsdbCloseDataFileDataIter(pIter); + } else if (pIter->type == TSDB_STT_FILE_DATA_ITER) { + tsdbCloseSttFileDataIter(pIter); + } else if (pIter->type == TSDB_TOMB_FILE_DATA_ITER) { + tsdbCloseTombFileDataIter(pIter); + } else { + ASSERT(0); + } +} + +/* cmpr */ +int32_t tsdbDataIterCmprFn(const SRBTreeNode* pNode1, const SRBTreeNode* pNode2) { + STsdbDataIter2* pIter1 = TSDB_RBTN_TO_DATA_ITER(pNode1); + STsdbDataIter2* pIter2 = TSDB_RBTN_TO_DATA_ITER(pNode2); + return tRowInfoCmprFn(&pIter1->rowInfo, &pIter2->rowInfo); +} + +/* seek */ + +/* iter next */ +static int32_t tsdbDataFileDataIterNext(STsdbDataIter2* pIter, STsdbFilterInfo* pFilterInfo) { + int32_t code = 0; + int32_t lino = 0; + + for (;;) { + while (pIter->dIter.iRow < pIter->dIter.bData.nRow) { + if (pFilterInfo) { + if (pFilterInfo->flag & TSDB_FILTER_FLAG_BY_TABLEID) { + if (pFilterInfo->tbid.uid == pIter->dIter.bData.uid) { + pIter->dIter.iRow = pIter->dIter.bData.nRow; + continue; + } + } + + if (pFilterInfo->flag & TSDB_FILTER_FLAG_BY_VERSION) { + if (pIter->dIter.bData.aVersion[pIter->dIter.iRow] < pFilterInfo->sver || + pIter->dIter.bData.aVersion[pIter->dIter.iRow] > pFilterInfo->ever) { + pIter->dIter.iRow++; + continue; + } + } + } + + ASSERT(pIter->rowInfo.suid == pIter->dIter.bData.suid); + ASSERT(pIter->rowInfo.uid = pIter->dIter.bData.uid); + pIter->rowInfo.row = tsdbRowFromBlockData(&pIter->dIter.bData, pIter->dIter.iRow); + pIter->dIter.iRow++; + goto _exit; + } + + for (;;) { + while (pIter->dIter.iDataBlk < pIter->dIter.mDataBlk.nItem) { + SDataBlk dataBlk; + tMapDataGetItemByIdx(&pIter->dIter.mDataBlk, pIter->dIter.iDataBlk, &dataBlk, tGetDataBlk); + + // filter + if (pFilterInfo) { + if (pFilterInfo->flag & TSDB_FILTER_FLAG_BY_TABLEID) { + if (tTABLEIDCmprFn(&pFilterInfo->tbid, &pIter->rowInfo) == 0) { + pIter->dIter.iDataBlk = pIter->dIter.mDataBlk.nItem; + continue; + } + } + + if (pFilterInfo->flag & TSDB_FILTER_FLAG_BY_VERSION) { + if (pFilterInfo->sver > dataBlk.maxVer || pFilterInfo->ever < dataBlk.minVer) { + pIter->dIter.iDataBlk++; + continue; + } + } + } + + code = tsdbReadDataBlockEx(pIter->dIter.pReader, &dataBlk, &pIter->dIter.bData); + TSDB_CHECK_CODE(code, lino, _exit); + + pIter->dIter.iDataBlk++; + pIter->dIter.iRow = 0; + + break; + } + + if (pIter->dIter.iRow < pIter->dIter.bData.nRow) break; + + for (;;) { + if (pIter->dIter.iBlockIdx < taosArrayGetSize(pIter->dIter.aBlockIdx)) { + SBlockIdx* pBlockIdx = taosArrayGet(pIter->dIter.aBlockIdx, pIter->dIter.iBlockIdx); + + if (pFilterInfo && (pFilterInfo->flag & TSDB_FILTER_FLAG_BY_TABLEID)) { + int32_t c = tTABLEIDCmprFn(pBlockIdx, &pFilterInfo->tbid); + if (c == 0) { + pIter->dIter.iBlockIdx++; + continue; + } else if (c < 0) { + ASSERT(0); + } + } + + code = tsdbReadDataBlk(pIter->dIter.pReader, pBlockIdx, &pIter->dIter.mDataBlk); + TSDB_CHECK_CODE(code, lino, _exit); + + pIter->rowInfo.suid = pBlockIdx->suid; + pIter->rowInfo.uid = pBlockIdx->uid; + + pIter->dIter.iBlockIdx++; + pIter->dIter.iDataBlk = 0; + + break; + } else { + pIter->rowInfo = (SRowInfo){0}; + goto _exit; + } + } + } + } + +_exit: + if (code) { + tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; +} + +static int32_t tsdbSttFileDataIterNext(STsdbDataIter2* pIter, STsdbFilterInfo* pFilterInfo) { + int32_t code = 0; + int32_t lino = 0; + + for (;;) { + while (pIter->sIter.iRow < pIter->sIter.bData.nRow) { + if (pFilterInfo) { + if (pFilterInfo->flag & TSDB_FILTER_FLAG_BY_TABLEID) { + int64_t uid = pIter->sIter.bData.uid ? pIter->sIter.bData.uid : pIter->sIter.bData.aUid[pIter->sIter.iRow]; + if (pFilterInfo->tbid.uid == uid) { + pIter->sIter.iRow++; + continue; + } + } + + if (pFilterInfo->flag & TSDB_FILTER_FLAG_BY_VERSION) { + if (pFilterInfo->sver > pIter->sIter.bData.aVersion[pIter->sIter.iRow] || + pFilterInfo->ever < pIter->sIter.bData.aVersion[pIter->sIter.iRow]) { + pIter->sIter.iRow++; + continue; + } + } + } + + pIter->rowInfo.suid = pIter->sIter.bData.suid; + pIter->rowInfo.uid = pIter->sIter.bData.uid ? pIter->sIter.bData.uid : pIter->sIter.bData.aUid[pIter->sIter.iRow]; + pIter->rowInfo.row = tsdbRowFromBlockData(&pIter->sIter.bData, pIter->sIter.iRow); + pIter->sIter.iRow++; + goto _exit; + } + + for (;;) { + if (pIter->sIter.iSttBlk < taosArrayGetSize(pIter->sIter.aSttBlk)) { + SSttBlk* pSttBlk = taosArrayGet(pIter->sIter.aSttBlk, pIter->sIter.iSttBlk); + + if (pFilterInfo) { + if (pFilterInfo->flag & TSDB_FILTER_FLAG_BY_TABLEID) { + if (pSttBlk->suid == pFilterInfo->tbid.suid && pSttBlk->minUid == pFilterInfo->tbid.uid && + pSttBlk->maxUid == pFilterInfo->tbid.uid) { + pIter->sIter.iSttBlk++; + continue; + } + } + + if (pFilterInfo->flag & TSDB_FILTER_FLAG_BY_VERSION) { + if (pFilterInfo->sver > pSttBlk->maxVer || pFilterInfo->ever < pSttBlk->minVer) { + pIter->sIter.iSttBlk++; + continue; + } + } + } + + code = tsdbReadSttBlockEx(pIter->sIter.pReader, pIter->sIter.iStt, pSttBlk, &pIter->sIter.bData); + TSDB_CHECK_CODE(code, lino, _exit); + + pIter->sIter.iRow = 0; + pIter->sIter.iSttBlk++; + break; + } else { + pIter->rowInfo = (SRowInfo){0}; + goto _exit; + } + } + } + +_exit: + if (code) { + tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; +} + +static int32_t tsdbTombFileDataIterNext(STsdbDataIter2* pIter, STsdbFilterInfo* pFilterInfo) { + int32_t code = 0; + int32_t lino = 0; + + for (;;) { + while (pIter->tIter.iDelData < taosArrayGetSize(pIter->tIter.aDelData)) { + SDelData* pDelData = taosArrayGet(pIter->tIter.aDelData, pIter->tIter.iDelData); + + if (pFilterInfo) { + if (pFilterInfo->flag & TSDB_FILTER_FLAG_BY_VERSION) { + if (pFilterInfo->sver > pDelData->version || pFilterInfo->ever < pDelData->version) { + pIter->tIter.iDelData++; + continue; + } + } + } + + pIter->delInfo.delData = *pDelData; + pIter->tIter.iDelData++; + goto _exit; + } + + for (;;) { + if (pIter->tIter.iDelIdx < taosArrayGetSize(pIter->tIter.aDelIdx)) { + SDelIdx* pDelIdx = taosArrayGet(pIter->tIter.aDelIdx, pIter->tIter.iDelIdx); + + code = tsdbReadDelData(pIter->tIter.pReader, pDelIdx, pIter->tIter.aDelData); + TSDB_CHECK_CODE(code, lino, _exit); + + pIter->delInfo.suid = pDelIdx->suid; + pIter->delInfo.uid = pDelIdx->uid; + pIter->tIter.iDelData = 0; + pIter->tIter.iDelIdx++; + break; + } else { + pIter->delInfo = (SDelInfo){0}; + goto _exit; + } + } + } + +_exit: + if (code) { + tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; +} + +int32_t tsdbDataIterNext2(STsdbDataIter2* pIter, STsdbFilterInfo* pFilterInfo) { + int32_t code = 0; + + if (pIter->type == TSDB_MEM_TABLE_DATA_ITER) { + ASSERT(0); + return code; + } else if (pIter->type == TSDB_DATA_FILE_DATA_ITER) { + return tsdbDataFileDataIterNext(pIter, pFilterInfo); + } else if (pIter->type == TSDB_STT_FILE_DATA_ITER) { + return tsdbSttFileDataIterNext(pIter, pFilterInfo); + } else if (pIter->type == TSDB_TOMB_FILE_DATA_ITER) { + return tsdbTombFileDataIterNext(pIter, pFilterInfo); + } else { + ASSERT(0); + return code; + } +} + +/* get */ + +// STsdbFSetIter +typedef struct STsdbFSetDataIter { + STsdb* pTsdb; + int32_t flags; + + /* tombstone */ + SDelFReader* pDelFReader; + SArray* aDelIdx; // SArray + SArray* aDelData; // SArray + SArray* aSkeyLine; // SArray + int32_t iDelIdx; + int32_t iSkyLine; + + /* time-series data */ + SDataFReader* pReader; + STsdbDataIter2* iterList; + STsdbDataIter2* pIter; + SRBTree rbt; +} STsdbFSetDataIter; diff --git a/source/dnode/vnode/src/tsdb/tsdbFS.c b/source/dnode/vnode/src/tsdb/tsdbFS.c index 51fdc69a95..5519d43012 100644 --- a/source/dnode/vnode/src/tsdb/tsdbFS.c +++ b/source/dnode/vnode/src/tsdb/tsdbFS.c @@ -629,7 +629,15 @@ static int32_t tsdbFSApplyChange(STsdb *pTsdb, STsdbFS *pFS) { } } } else { - ASSERT(pTsdb->fs.pDelFile == NULL); + if (pTsdb->fs.pDelFile) { + nRef = atomic_sub_fetch_32(&pTsdb->fs.pDelFile->nRef, 1); + if (nRef == 0) { + tsdbDelFileName(pTsdb, pTsdb->fs.pDelFile, fname); + (void)taosRemoveFile(fname); + taosMemoryFree(pTsdb->fs.pDelFile); + } + pTsdb->fs.pDelFile = NULL; + } } // aDFileSet @@ -906,14 +914,21 @@ _exit: int32_t tsdbFSUpsertDelFile(STsdbFS *pFS, SDelFile *pDelFile) { int32_t code = 0; - if (pFS->pDelFile == NULL) { - pFS->pDelFile = (SDelFile *)taosMemoryMalloc(sizeof(SDelFile)); + if (pDelFile) { if (pFS->pDelFile == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _exit; + pFS->pDelFile = (SDelFile *)taosMemoryMalloc(sizeof(SDelFile)); + if (pFS->pDelFile == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _exit; + } + } + *pFS->pDelFile = *pDelFile; + } else { + if (pFS->pDelFile) { + taosMemoryFree(pFS->pDelFile); + pFS->pDelFile = NULL; } } - *pFS->pDelFile = *pDelFile; _exit: return code; diff --git a/source/dnode/vnode/src/tsdb/tsdbSnapshot.c b/source/dnode/vnode/src/tsdb/tsdbSnapshot.c index a04d7b8a5d..9f57887d48 100644 --- a/source/dnode/vnode/src/tsdb/tsdbSnapshot.c +++ b/source/dnode/vnode/src/tsdb/tsdbSnapshot.c @@ -15,457 +15,10 @@ #include "tsdb.h" -extern int32_t tsdbReadDataBlockEx(SDataFReader* pReader, SDataBlk* pDataBlk, SBlockData* pBlockData); extern int32_t tsdbUpdateTableSchema(SMeta* pMeta, int64_t suid, int64_t uid, SSkmInfo* pSkmInfo); extern int32_t tsdbWriteDataBlock(SDataFWriter* pWriter, SBlockData* pBlockData, SMapData* mDataBlk, int8_t cmprAlg); extern int32_t tsdbWriteSttBlock(SDataFWriter* pWriter, SBlockData* pBlockData, SArray* aSttBlk, int8_t cmprAlg); -// STsdbDataIter2 ======================================== -#define TSDB_MEM_TABLE_DATA_ITER 0 -#define TSDB_DATA_FILE_DATA_ITER 1 -#define TSDB_STT_FILE_DATA_ITER 2 -#define TSDB_TOMB_FILE_DATA_ITER 3 - -typedef struct STsdbDataIter2 STsdbDataIter2; -typedef struct STsdbFilterInfo STsdbFilterInfo; - -typedef struct { - int64_t suid; - int64_t uid; - SDelData delData; -} SDelInfo; - -struct STsdbDataIter2 { - STsdbDataIter2* next; - SRBTreeNode rbtn; - - int32_t type; - SRowInfo rowInfo; - SDelInfo delInfo; - union { - // TSDB_MEM_TABLE_DATA_ITER - struct { - SMemTable* pMemTable; - } mIter; - - // TSDB_DATA_FILE_DATA_ITER - struct { - SDataFReader* pReader; - SArray* aBlockIdx; // SArray - SMapData mDataBlk; - SBlockData bData; - int32_t iBlockIdx; - int32_t iDataBlk; - int32_t iRow; - } dIter; - - // TSDB_STT_FILE_DATA_ITER - struct { - SDataFReader* pReader; - int32_t iStt; - SArray* aSttBlk; - SBlockData bData; - int32_t iSttBlk; - int32_t iRow; - } sIter; - // TSDB_TOMB_FILE_DATA_ITER - struct { - SDelFReader* pReader; - SArray* aDelIdx; - SArray* aDelData; - int32_t iDelIdx; - int32_t iDelData; - } tIter; - }; -}; - -#define TSDB_FILTER_FLAG_BY_VERSION 0x1 -struct STsdbFilterInfo { - int32_t flag; - int64_t sver; - int64_t ever; -}; - -#define TSDB_RBTN_TO_DATA_ITER(pNode) ((STsdbDataIter2*)(((char*)pNode) - offsetof(STsdbDataIter2, rbtn))) - -/* open */ -static int32_t tsdbOpenDataFileDataIter(SDataFReader* pReader, STsdbDataIter2** ppIter) { - int32_t code = 0; - int32_t lino = 0; - - // create handle - STsdbDataIter2* pIter = (STsdbDataIter2*)taosMemoryCalloc(1, sizeof(*pIter)); - if (pIter == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _exit); - } - - pIter->type = TSDB_DATA_FILE_DATA_ITER; - pIter->dIter.pReader = pReader; - if ((pIter->dIter.aBlockIdx = taosArrayInit(0, sizeof(SBlockIdx))) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _exit); - } - - code = tBlockDataCreate(&pIter->dIter.bData); - TSDB_CHECK_CODE(code, lino, _exit); - - pIter->dIter.iBlockIdx = 0; - pIter->dIter.iDataBlk = 0; - pIter->dIter.iRow = 0; - - // read data - code = tsdbReadBlockIdx(pReader, pIter->dIter.aBlockIdx); - TSDB_CHECK_CODE(code, lino, _exit); - - if (taosArrayGetSize(pIter->dIter.aBlockIdx) == 0) goto _clear; - -_exit: - if (code) { - if (pIter) { - _clear: - tBlockDataDestroy(&pIter->dIter.bData); - taosArrayDestroy(pIter->dIter.aBlockIdx); - taosMemoryFree(pIter); - pIter = NULL; - } - } - *ppIter = pIter; - return code; -} - -static int32_t tsdbOpenSttFileDataIter(SDataFReader* pReader, int32_t iStt, STsdbDataIter2** ppIter) { - int32_t code = 0; - int32_t lino = 0; - - // create handle - STsdbDataIter2* pIter = (STsdbDataIter2*)taosMemoryCalloc(1, sizeof(*pIter)); - if (pIter == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _exit); - } - - pIter->type = TSDB_STT_FILE_DATA_ITER; - pIter->sIter.pReader = pReader; - pIter->sIter.iStt = iStt; - pIter->sIter.aSttBlk = taosArrayInit(0, sizeof(SSttBlk)); - if (pIter->sIter.aSttBlk == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _exit); - } - - code = tBlockDataCreate(&pIter->sIter.bData); - TSDB_CHECK_CODE(code, lino, _exit); - - pIter->sIter.iSttBlk = 0; - pIter->sIter.iRow = 0; - - // read data - code = tsdbReadSttBlk(pReader, iStt, pIter->sIter.aSttBlk); - TSDB_CHECK_CODE(code, lino, _exit); - - if (taosArrayGetSize(pIter->sIter.aSttBlk) == 0) goto _clear; - -_exit: - if (code) { - if (pIter) { - _clear: - taosArrayDestroy(pIter->sIter.aSttBlk); - tBlockDataDestroy(&pIter->sIter.bData); - taosMemoryFree(pIter); - pIter = NULL; - } - } - *ppIter = pIter; - return code; -} - -static int32_t tsdbOpenTombFileDataIter(SDelFReader* pReader, STsdbDataIter2** ppIter) { - int32_t code = 0; - int32_t lino = 0; - - STsdbDataIter2* pIter = (STsdbDataIter2*)taosMemoryCalloc(1, sizeof(*pIter)); - if (pIter == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _exit); - } - pIter->type = TSDB_TOMB_FILE_DATA_ITER; - - pIter->tIter.pReader = pReader; - if ((pIter->tIter.aDelIdx = taosArrayInit(0, sizeof(SDelIdx))) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _exit); - } - if ((pIter->tIter.aDelData = taosArrayInit(0, sizeof(SDelData))) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _exit); - } - - code = tsdbReadDelIdx(pReader, pIter->tIter.aDelIdx); - TSDB_CHECK_CODE(code, lino, _exit); - - if (taosArrayGetSize(pIter->tIter.aDelIdx) == 0) goto _clear; - - pIter->tIter.iDelIdx = 0; - pIter->tIter.iDelData = 0; - -_exit: - if (code) { - if (pIter) { - _clear: - taosArrayDestroy(pIter->tIter.aDelIdx); - taosArrayDestroy(pIter->tIter.aDelData); - taosMemoryFree(pIter); - pIter = NULL; - } - } - *ppIter = pIter; - return code; -} - -/* close */ -static void tsdbCloseDataFileDataIter(STsdbDataIter2* pIter) { - tBlockDataDestroy(&pIter->dIter.bData); - tMapDataClear(&pIter->dIter.mDataBlk); - taosArrayDestroy(pIter->dIter.aBlockIdx); - taosMemoryFree(pIter); -} - -static void tsdbCloseSttFileDataIter(STsdbDataIter2* pIter) { - tBlockDataDestroy(&pIter->sIter.bData); - taosArrayDestroy(pIter->sIter.aSttBlk); - taosMemoryFree(pIter); -} - -static void tsdbCloseTombFileDataIter(STsdbDataIter2* pIter) { - taosArrayDestroy(pIter->tIter.aDelData); - taosArrayDestroy(pIter->tIter.aDelIdx); - taosMemoryFree(pIter); -} - -static void tsdbCloseDataIter2(STsdbDataIter2* pIter) { - if (pIter->type == TSDB_MEM_TABLE_DATA_ITER) { - ASSERT(0); - } else if (pIter->type == TSDB_DATA_FILE_DATA_ITER) { - tsdbCloseDataFileDataIter(pIter); - } else if (pIter->type == TSDB_STT_FILE_DATA_ITER) { - tsdbCloseSttFileDataIter(pIter); - } else if (pIter->type == TSDB_TOMB_FILE_DATA_ITER) { - tsdbCloseTombFileDataIter(pIter); - } else { - ASSERT(0); - } -} - -/* cmpr */ -static int32_t tsdbDataIterCmprFn(const SRBTreeNode* pNode1, const SRBTreeNode* pNode2) { - STsdbDataIter2* pIter1 = TSDB_RBTN_TO_DATA_ITER(pNode1); - STsdbDataIter2* pIter2 = TSDB_RBTN_TO_DATA_ITER(pNode2); - return tRowInfoCmprFn(&pIter1->rowInfo, &pIter2->rowInfo); -} - -/* seek */ - -/* iter next */ -static int32_t tsdbDataFileDataIterNext(STsdbDataIter2* pIter, STsdbFilterInfo* pFilterInfo) { - int32_t code = 0; - int32_t lino = 0; - - for (;;) { - while (pIter->dIter.iRow < pIter->dIter.bData.nRow) { - if (pFilterInfo) { - if (pFilterInfo->flag & TSDB_FILTER_FLAG_BY_VERSION) { - if (pIter->dIter.bData.aVersion[pIter->dIter.iRow] < pFilterInfo->sver || - pIter->dIter.bData.aVersion[pIter->dIter.iRow] > pFilterInfo->ever) { - pIter->dIter.iRow++; - continue; - } - } - } - - pIter->rowInfo.suid = pIter->dIter.bData.suid; - pIter->rowInfo.uid = pIter->dIter.bData.uid; - pIter->rowInfo.row = tsdbRowFromBlockData(&pIter->dIter.bData, pIter->dIter.iRow); - pIter->dIter.iRow++; - goto _exit; - } - - for (;;) { - while (pIter->dIter.iDataBlk < pIter->dIter.mDataBlk.nItem) { - SDataBlk dataBlk; - tMapDataGetItemByIdx(&pIter->dIter.mDataBlk, pIter->dIter.iDataBlk, &dataBlk, tGetDataBlk); - - // filter - if (pFilterInfo) { - if (pFilterInfo->flag & TSDB_FILTER_FLAG_BY_VERSION) { - if (pFilterInfo->sver > dataBlk.maxVer || pFilterInfo->ever < dataBlk.minVer) { - pIter->dIter.iDataBlk++; - continue; - } - } - } - - code = tsdbReadDataBlockEx(pIter->dIter.pReader, &dataBlk, &pIter->dIter.bData); - TSDB_CHECK_CODE(code, lino, _exit); - - pIter->dIter.iDataBlk++; - pIter->dIter.iRow = 0; - - break; - } - - if (pIter->dIter.iRow < pIter->dIter.bData.nRow) break; - - for (;;) { - if (pIter->dIter.iBlockIdx < taosArrayGetSize(pIter->dIter.aBlockIdx)) { - SBlockIdx* pBlockIdx = taosArrayGet(pIter->dIter.aBlockIdx, pIter->dIter.iBlockIdx); - - code = tsdbReadDataBlk(pIter->dIter.pReader, pBlockIdx, &pIter->dIter.mDataBlk); - TSDB_CHECK_CODE(code, lino, _exit); - - pIter->dIter.iBlockIdx++; - pIter->dIter.iDataBlk = 0; - - break; - } else { - pIter->rowInfo = (SRowInfo){0}; - goto _exit; - } - } - } - } - -_exit: - if (code) { - tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); - } - return code; -} - -static int32_t tsdbSttFileDataIterNext(STsdbDataIter2* pIter, STsdbFilterInfo* pFilterInfo) { - int32_t code = 0; - int32_t lino = 0; - - for (;;) { - while (pIter->sIter.iRow < pIter->sIter.bData.nRow) { - if (pFilterInfo) { - if (pFilterInfo->flag & TSDB_FILTER_FLAG_BY_VERSION) { - if (pFilterInfo->sver > pIter->sIter.bData.aVersion[pIter->sIter.iRow] || - pFilterInfo->ever < pIter->sIter.bData.aVersion[pIter->sIter.iRow]) { - pIter->sIter.iRow++; - continue; - } - } - } - - pIter->rowInfo.suid = pIter->sIter.bData.suid; - pIter->rowInfo.uid = pIter->sIter.bData.uid ? pIter->sIter.bData.uid : pIter->sIter.bData.aUid[pIter->sIter.iRow]; - pIter->rowInfo.row = tsdbRowFromBlockData(&pIter->sIter.bData, pIter->sIter.iRow); - pIter->sIter.iRow++; - goto _exit; - } - - for (;;) { - if (pIter->sIter.iSttBlk < taosArrayGetSize(pIter->sIter.aSttBlk)) { - SSttBlk* pSttBlk = taosArrayGet(pIter->sIter.aSttBlk, pIter->sIter.iSttBlk); - - if (pFilterInfo) { - if (pFilterInfo->flag & TSDB_FILTER_FLAG_BY_VERSION) { - if (pFilterInfo->sver > pSttBlk->maxVer || pFilterInfo->ever < pSttBlk->minVer) { - pIter->sIter.iSttBlk++; - continue; - } - } - } - - code = tsdbReadSttBlockEx(pIter->sIter.pReader, pIter->sIter.iStt, pSttBlk, &pIter->sIter.bData); - TSDB_CHECK_CODE(code, lino, _exit); - - pIter->sIter.iRow = 0; - pIter->sIter.iSttBlk++; - break; - } else { - pIter->rowInfo = (SRowInfo){0}; - goto _exit; - } - } - } - -_exit: - if (code) { - tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); - } - return code; -} - -static int32_t tsdbTombFileDataIterNext(STsdbDataIter2* pIter, STsdbFilterInfo* pFilterInfo) { - int32_t code = 0; - int32_t lino = 0; - - for (;;) { - while (pIter->tIter.iDelData < taosArrayGetSize(pIter->tIter.aDelData)) { - SDelData* pDelData = taosArrayGet(pIter->tIter.aDelData, pIter->tIter.iDelData); - - if (pFilterInfo) { - if (pFilterInfo->flag & TSDB_FILTER_FLAG_BY_VERSION) { - if (pFilterInfo->sver > pDelData->version || pFilterInfo->ever < pDelData->version) { - pIter->tIter.iDelData++; - continue; - } - } - } - - pIter->delInfo.delData = *pDelData; - pIter->tIter.iDelData++; - goto _exit; - } - - for (;;) { - if (pIter->tIter.iDelIdx < taosArrayGetSize(pIter->tIter.aDelIdx)) { - SDelIdx* pDelIdx = taosArrayGet(pIter->tIter.aDelIdx, pIter->tIter.iDelIdx); - - code = tsdbReadDelData(pIter->tIter.pReader, pDelIdx, pIter->tIter.aDelData); - TSDB_CHECK_CODE(code, lino, _exit); - - pIter->delInfo.suid = pDelIdx->suid; - pIter->delInfo.uid = pDelIdx->uid; - pIter->tIter.iDelData = 0; - pIter->tIter.iDelIdx++; - break; - } else { - pIter->delInfo = (SDelInfo){0}; - goto _exit; - } - } - } - -_exit: - if (code) { - tsdbError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); - } - return code; -} - -static int32_t tsdbDataIterNext2(STsdbDataIter2* pIter, STsdbFilterInfo* pFilterInfo) { - int32_t code = 0; - - if (pIter->type == TSDB_MEM_TABLE_DATA_ITER) { - ASSERT(0); - return code; - } else if (pIter->type == TSDB_DATA_FILE_DATA_ITER) { - return tsdbDataFileDataIterNext(pIter, pFilterInfo); - } else if (pIter->type == TSDB_STT_FILE_DATA_ITER) { - return tsdbSttFileDataIterNext(pIter, pFilterInfo); - } else if (pIter->type == TSDB_TOMB_FILE_DATA_ITER) { - return tsdbTombFileDataIterNext(pIter, pFilterInfo); - } else { - ASSERT(0); - return code; - } -} - -/* get */ - // STsdbSnapReader ======================================== struct STsdbSnapReader { STsdb* pTsdb; @@ -1318,7 +871,7 @@ static int32_t tsdbSnapWriteFileDataStart(STsdbSnapWriter* pWriter, int32_t fid) TSDB_CHECK_CODE(code, lino, _exit); if (pWriter->pSIter) { - code = tsdbSttFileDataIterNext(pWriter->pSIter, NULL); + code = tsdbDataIterNext2(pWriter->pSIter, NULL); TSDB_CHECK_CODE(code, lino, _exit); // add to tree diff --git a/source/dnode/vnode/src/tsdb/tsdbUtil.c b/source/dnode/vnode/src/tsdb/tsdbUtil.c index 5249a8396e..391891da28 100644 --- a/source/dnode/vnode/src/tsdb/tsdbUtil.c +++ b/source/dnode/vnode/src/tsdb/tsdbUtil.c @@ -1281,7 +1281,12 @@ void tBlockDataClear(SBlockData *pBlockData) { } } -static int32_t tBlockDataAppendBlockRow(SBlockData *pBlockData, SBlockData *pBlockDataFrom, int32_t iRow) { +/* flag > 0: forward update + * flag == 0: insert + * flag < 0: backward update + */ +static int32_t tBlockDataUpsertBlockRow(SBlockData *pBlockData, SBlockData *pBlockDataFrom, int32_t iRow, + int32_t flag) { int32_t code = 0; SColVal cv = {0}; @@ -1296,12 +1301,16 @@ static int32_t tBlockDataAppendBlockRow(SBlockData *pBlockData, SBlockData *pBlo } if (pColDataFrom == NULL || pColDataFrom->cid > pColDataTo->cid) { - code = tColDataAppendValue(pColDataTo, &COL_VAL_NONE(pColDataTo->cid, pColDataTo->type)); - if (code) goto _exit; + cv = COL_VAL_NONE(pColDataTo->cid, pColDataTo->type); + if (flag == 0 && (code = tColDataAppendValue(pColDataTo, &cv))) goto _exit; } else { tColDataGetValue(pColDataFrom, iRow, &cv); - code = tColDataAppendValue(pColDataTo, &cv); + if (flag) { + code = tColDataUpdateValue(pColDataTo, &cv, flag > 0); + } else { + code = tColDataAppendValue(pColDataTo, &cv); + } if (code) goto _exit; pColDataFrom = (++iColDataFrom < pBlockDataFrom->nColData) ? &pBlockDataFrom->aColData[iColDataFrom] : NULL; @@ -1321,36 +1330,77 @@ int32_t tBlockDataAppendRow(SBlockData *pBlockData, TSDBROW *pRow, STSchema *pTS if (pBlockData->uid == 0) { ASSERT(uid); code = tRealloc((uint8_t **)&pBlockData->aUid, sizeof(int64_t) * (pBlockData->nRow + 1)); - if (code) goto _err; + if (code) goto _exit; pBlockData->aUid[pBlockData->nRow] = uid; } // version code = tRealloc((uint8_t **)&pBlockData->aVersion, sizeof(int64_t) * (pBlockData->nRow + 1)); - if (code) goto _err; + if (code) goto _exit; pBlockData->aVersion[pBlockData->nRow] = TSDBROW_VERSION(pRow); // timestamp code = tRealloc((uint8_t **)&pBlockData->aTSKEY, sizeof(TSKEY) * (pBlockData->nRow + 1)); - if (code) goto _err; + if (code) goto _exit; pBlockData->aTSKEY[pBlockData->nRow] = TSDBROW_TS(pRow); - SColVal cv = {0}; if (pRow->type == TSDBROW_ROW_FMT) { - code = tRowAppendToColData(pRow->pTSRow, pTSchema, pBlockData->aColData, pBlockData->nColData); - if (code) goto _err; + code = tRowUpsertColData(pRow->pTSRow, pTSchema, pBlockData->aColData, pBlockData->nColData, 0 /* append */); + if (code) goto _exit; } else if (pRow->type == TSDBROW_COL_FMT) { - code = tBlockDataAppendBlockRow(pBlockData, pRow->pBlockData, pRow->iRow); - if (code) goto _err; + code = tBlockDataUpsertBlockRow(pBlockData, pRow->pBlockData, pRow->iRow, 0 /* append */); + if (code) goto _exit; } else { ASSERT(0); } pBlockData->nRow++; +_exit: return code; +} +static int32_t tBlockDataUpdateRow(SBlockData *pBlockData, TSDBROW *pRow, STSchema *pTSchema) { + int32_t code = 0; -_err: + // version + int64_t lversion = pBlockData->aVersion[pBlockData->nRow - 1]; + int64_t rversion = TSDBROW_VERSION(pRow); + ASSERT(lversion != rversion); + if (rversion > lversion) { + pBlockData->aVersion[pBlockData->nRow - 1] = rversion; + } + + // update other rows + if (pRow->type == TSDBROW_ROW_FMT) { + code = tRowUpsertColData(pRow->pTSRow, pTSchema, pBlockData->aColData, pBlockData->nColData, + (rversion > lversion) ? 1 : -1 /* update */); + if (code) goto _exit; + } else if (pRow->type == TSDBROW_COL_FMT) { + code = tBlockDataUpsertBlockRow(pBlockData, pRow->pBlockData, pRow->iRow, (rversion > lversion) ? 1 : -1); + if (code) goto _exit; + } else { + ASSERT(0); + } + +_exit: return code; } +int32_t tBlockDataTryUpsertRow(SBlockData *pBlockData, TSDBROW *pRow, int64_t uid) { + if (pBlockData->nRow == 0) { + return 1; + } else if (pBlockData->aTSKEY[pBlockData->nRow - 1] == TSDBROW_TS(pRow)) { + return pBlockData->nRow; + } else { + return pBlockData->nRow + 1; + } +} + +int32_t tBlockDataUpsertRow(SBlockData *pBlockData, TSDBROW *pRow, STSchema *pTSchema, int64_t uid) { + if (pBlockData->aTSKEY[pBlockData->nRow - 1] == TSDBROW_TS(pRow)) { + return tBlockDataUpdateRow(pBlockData, pRow, pTSchema); + } else { + return tBlockDataAppendRow(pBlockData, pRow, pTSchema, uid); + } +} + void tBlockDataGetColData(SBlockData *pBlockData, int16_t cid, SColData **ppColData) { ASSERT(cid != PRIMARYKEY_TIMESTAMP_COL_ID); int32_t lidx = 0; diff --git a/source/dnode/vnode/src/vnd/vnodeCommit.c b/source/dnode/vnode/src/vnd/vnodeCommit.c index b8448747a4..f0cd08f8fa 100644 --- a/source/dnode/vnode/src/vnd/vnodeCommit.c +++ b/source/dnode/vnode/src/vnd/vnodeCommit.c @@ -289,7 +289,7 @@ _err: return -1; } -static int32_t vnodePrepareCommit(SVnode *pVnode, SCommitInfo *pInfo) { +int32_t vnodePrepareCommit(SVnode *pVnode, SCommitInfo *pInfo) { int32_t code = 0; int32_t lino = 0; char dir[TSDB_FILENAME_LEN] = {0}; diff --git a/source/dnode/vnode/src/vnd/vnodeCompact.c b/source/dnode/vnode/src/vnd/vnodeCompact.c new file mode 100644 index 0000000000..d74993e80a --- /dev/null +++ b/source/dnode/vnode/src/vnd/vnodeCompact.c @@ -0,0 +1,81 @@ +/* + * 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 . + */ + +#include "vnd.h" + +extern int32_t tsdbCompact(STsdb *pTsdb, int32_t flag); + +int32_t vnodePrepareCommit(SVnode *pVnode, SCommitInfo *pInfo); + +static int32_t vnodeCompactImpl(SCommitInfo *pInfo) { + int32_t code = 0; + int32_t lino = 0; + + // TODO + SVnode *pVnode = pInfo->pVnode; + + code = tsdbCompact(pVnode->pTsdb, 0); + TSDB_CHECK_CODE(code, lino, _exit); + +_exit: + if (code) { + vError("vgId:%d %s failed since %s", TD_VID(pInfo->pVnode), __func__, tstrerror(code)); + } else { + vDebug("vgId:%d %s done", TD_VID(pInfo->pVnode), __func__); + } + return code; +} + +static int32_t vnodeCompactTask(void *param) { + int32_t code = 0; + + SCommitInfo *pInfo = (SCommitInfo *)param; + + // compact + vnodeCompactImpl(pInfo); + + // end compact + tsem_post(&pInfo->pVnode->canCommit); + +_exit: + taosMemoryFree(pInfo); + return code; +} +int32_t vnodeAsyncCompact(SVnode *pVnode) { + int32_t code = 0; + + // schedule compact task + SCommitInfo *pInfo = taosMemoryCalloc(1, sizeof(*pInfo)); + if (NULL == pInfo) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _exit; + } + + vnodePrepareCommit(pVnode, pInfo); + vnodeScheduleTask(vnodeCompactTask, pInfo); + +_exit: + if (code) { + vError("vgId:%d %s failed since %s", TD_VID(pInfo->pVnode), __func__, tstrerror(code)); + } + return code; +} + +int32_t vnodeSyncCompact(SVnode *pVnode) { + vnodeAsyncCompact(pVnode); + tsem_wait(&pVnode->canCommit); + tsem_post(&pVnode->canCommit); + return 0; +} \ No newline at end of file diff --git a/source/dnode/vnode/src/vnd/vnodeSvr.c b/source/dnode/vnode/src/vnd/vnodeSvr.c index a384defa91..05d29656ef 100644 --- a/source/dnode/vnode/src/vnd/vnodeSvr.c +++ b/source/dnode/vnode/src/vnd/vnodeSvr.c @@ -29,6 +29,7 @@ static int32_t vnodeProcessDropTtlTbReq(SVnode *pVnode, int64_t version, void *p static int32_t vnodeProcessTrimReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp); static int32_t vnodeProcessDeleteReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp); static int32_t vnodeProcessBatchDeleteReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp); +static int32_t vnodeProcessCompactVnodeReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp); int32_t vnodePreProcessWriteMsg(SVnode *pVnode, SRpcMsg *pMsg) { int32_t code = 0; @@ -318,6 +319,9 @@ int32_t vnodeProcessWriteMsg(SVnode *pVnode, SRpcMsg *pMsg, int64_t version, SRp case TDMT_VND_COMMIT: needCommit = true; break; + case TDMT_VND_COMPACT: + vnodeProcessCompactVnodeReq(pVnode, version, pReq, len, pRsp); + goto _exit; default: vError("vgId:%d, unprocessed msg, %d", TD_VID(pVnode), pMsg->msgType); return -1; @@ -1404,3 +1408,18 @@ static int32_t vnodeProcessDeleteReq(SVnode *pVnode, int64_t version, void *pReq _err: return code; } + +static int32_t vnodeProcessCompactVnodeReq(SVnode *pVnode, int64_t version, void *pReq, int32_t len, SRpcMsg *pRsp) { + SCompactVnodeReq req = {0}; + if (tDeserializeSCompactVnodeReq(pReq, len, &req) != 0) { + terrno = TSDB_CODE_INVALID_MSG; + return TSDB_CODE_INVALID_MSG; + } + vInfo("vgId:%d, compact msg will be processed, db:%s dbUid:%" PRId64 " compactStartTime:%" PRId64, TD_VID(pVnode), + req.db, req.dbUid, req.compactStartTime); + + vnodeAsyncCompact(pVnode); + vnodeBegin(pVnode); + + return 0; +} \ No newline at end of file diff --git a/source/libs/nodes/src/nodesCodeFuncs.c b/source/libs/nodes/src/nodesCodeFuncs.c index 348cd702c3..4f197ea464 100644 --- a/source/libs/nodes/src/nodesCodeFuncs.c +++ b/source/libs/nodes/src/nodesCodeFuncs.c @@ -165,6 +165,8 @@ const char* nodesNodeName(ENodeType type) { return "ExplainStmt"; case QUERY_NODE_DESCRIBE_STMT: return "DescribeStmt"; + case QUERY_NODE_COMPACT_DATABASE_STMT: + return "CompactDatabaseStmt"; case QUERY_NODE_CREATE_STREAM_STMT: return "CreateStreamStmt"; case QUERY_NODE_DROP_STREAM_STMT: @@ -5693,6 +5695,18 @@ static int32_t jsonToDescribeStmt(const SJson* pJson, void* pObj) { return code; } +static const char* jkCompactDatabaseStmtDbName = "DbName"; + +static int32_t compactDatabaseStmtToJson(const void* pObj, SJson* pJson) { + const SCompactDatabaseStmt* pNode = (const SCompactDatabaseStmt*)pObj; + return tjsonAddStringToObject(pJson, jkCompactDatabaseStmtDbName, pNode->dbName); +} + +static int32_t jsonToCompactDatabaseStmt(const SJson* pJson, void* pObj) { + SCompactDatabaseStmt* pNode = (SCompactDatabaseStmt*)pObj; + return tjsonGetStringValue(pJson, jkCompactDatabaseStmtDbName, pNode->dbName); +} + static const char* jkCreateStreamStmtStreamName = "StreamName"; static const char* jkCreateStreamStmtTargetDbName = "TargetDbName"; static const char* jkCreateStreamStmtTargetTabName = "TargetTabName"; @@ -6404,6 +6418,8 @@ static int32_t specificNodeToJson(const void* pObj, SJson* pJson) { return explainStmtToJson(pObj, pJson); case QUERY_NODE_DESCRIBE_STMT: return describeStmtToJson(pObj, pJson); + case QUERY_NODE_COMPACT_DATABASE_STMT: + return compactDatabaseStmtToJson(pObj, pJson); case QUERY_NODE_CREATE_STREAM_STMT: return createStreamStmtToJson(pObj, pJson); case QUERY_NODE_DROP_STREAM_STMT: @@ -6710,6 +6726,8 @@ static int32_t jsonToSpecificNode(const SJson* pJson, void* pObj) { return jsonToExplainStmt(pJson, pObj); case QUERY_NODE_DESCRIBE_STMT: return jsonToDescribeStmt(pJson, pObj); + case QUERY_NODE_COMPACT_DATABASE_STMT: + return jsonToCompactDatabaseStmt(pJson, pObj); case QUERY_NODE_CREATE_STREAM_STMT: return jsonToCreateStreamStmt(pJson, pObj); case QUERY_NODE_DROP_STREAM_STMT: diff --git a/source/libs/nodes/src/nodesUtilFuncs.c b/source/libs/nodes/src/nodesUtilFuncs.c index 816842ff4c..0419c883e6 100644 --- a/source/libs/nodes/src/nodesUtilFuncs.c +++ b/source/libs/nodes/src/nodesUtilFuncs.c @@ -374,8 +374,8 @@ SNode* nodesMakeNode(ENodeType type) { return makeNode(type, sizeof(SDescribeStmt)); case QUERY_NODE_RESET_QUERY_CACHE_STMT: return makeNode(type, sizeof(SNode)); - case QUERY_NODE_COMPACT_STMT: - break; + case QUERY_NODE_COMPACT_DATABASE_STMT: + return makeNode(type, sizeof(SCompactDatabaseStmt)); case QUERY_NODE_CREATE_FUNCTION_STMT: return makeNode(type, sizeof(SCreateFunctionStmt)); case QUERY_NODE_DROP_FUNCTION_STMT: @@ -923,7 +923,7 @@ void nodesDestroyNode(SNode* pNode) { taosMemoryFree(((SDescribeStmt*)pNode)->pMeta); break; case QUERY_NODE_RESET_QUERY_CACHE_STMT: // no pointer field - case QUERY_NODE_COMPACT_STMT: // no pointer field + case QUERY_NODE_COMPACT_DATABASE_STMT: // no pointer field case QUERY_NODE_CREATE_FUNCTION_STMT: // no pointer field case QUERY_NODE_DROP_FUNCTION_STMT: // no pointer field break; diff --git a/source/libs/parser/inc/parAst.h b/source/libs/parser/inc/parAst.h index d202e60a45..3b309db1db 100644 --- a/source/libs/parser/inc/parAst.h +++ b/source/libs/parser/inc/parAst.h @@ -151,6 +151,7 @@ SNode* createDropDatabaseStmt(SAstCreateContext* pCxt, bool ignoreNotExists, STo SNode* createAlterDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName, SNode* pOptions); SNode* createFlushDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName); SNode* createTrimDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName, int32_t maxSpeed); +SNode* createCompactStmt(SAstCreateContext* pCxt, SToken* pDbName); SNode* createDefaultTableOptions(SAstCreateContext* pCxt); SNode* createAlterTableOptions(SAstCreateContext* pCxt); SNode* setTableOption(SAstCreateContext* pCxt, SNode* pOptions, ETableOptionType type, void* pVal); @@ -210,7 +211,6 @@ SNode* setExplainRatio(SAstCreateContext* pCxt, SNode* pOptions, const SToken* p SNode* createExplainStmt(SAstCreateContext* pCxt, bool analyze, SNode* pOptions, SNode* pQuery); SNode* createDescribeStmt(SAstCreateContext* pCxt, SNode* pRealTable); SNode* createResetQueryCacheStmt(SAstCreateContext* pCxt); -SNode* createCompactStmt(SAstCreateContext* pCxt, SNodeList* pVgroups); SNode* createCreateFunctionStmt(SAstCreateContext* pCxt, bool ignoreExists, bool aggFunc, const SToken* pFuncName, const SToken* pLibPath, SDataType dataType, int32_t bufSize); SNode* createDropFunctionStmt(SAstCreateContext* pCxt, bool ignoreNotExists, const SToken* pFuncName); diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y index ab30ecaa40..c87911c9bc 100644 --- a/source/libs/parser/inc/sql.y +++ b/source/libs/parser/inc/sql.y @@ -167,6 +167,7 @@ cmd ::= USE db_name(A). cmd ::= ALTER DATABASE db_name(A) alter_db_options(B). { pCxt->pRootNode = createAlterDatabaseStmt(pCxt, &A, B); } cmd ::= FLUSH DATABASE db_name(A). { pCxt->pRootNode = createFlushDatabaseStmt(pCxt, &A); } cmd ::= TRIM DATABASE db_name(A) speed_opt(B). { pCxt->pRootNode = createTrimDatabaseStmt(pCxt, &A, B); } +cmd ::= COMPACT DATABASE db_name(A). { pCxt->pRootNode = createCompactStmt(pCxt, &A); } %type not_exists_opt { bool } %destructor not_exists_opt { } @@ -528,9 +529,6 @@ explain_options(A) ::= . explain_options(A) ::= explain_options(B) VERBOSE NK_BOOL(C). { A = setExplainVerbose(pCxt, B, &C); } explain_options(A) ::= explain_options(B) RATIO NK_FLOAT(C). { A = setExplainRatio(pCxt, B, &C); } -/************************************************ compact *************************************************************/ -//cmd ::= COMPACT VNODES IN NK_LP integer_list NK_RP. { pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); } - /************************************************ create/drop function ************************************************/ cmd ::= CREATE agg_func_opt(A) FUNCTION not_exists_opt(F) function_name(B) AS NK_STRING(C) OUTPUTTYPE type_name(D) bufsize_opt(E). { pCxt->pRootNode = createCreateFunctionStmt(pCxt, F, A, &B, &C, D, E); } @@ -1106,6 +1104,6 @@ null_ordering_opt(A) ::= . null_ordering_opt(A) ::= NULLS FIRST. { A = NULL_ORDER_FIRST; } null_ordering_opt(A) ::= NULLS LAST. { A = NULL_ORDER_LAST; } -%fallback ABORT AFTER ATTACH BEFORE BEGIN BITAND BITNOT BITOR BLOCKS CHANGE COMMA COMPACT CONCAT CONFLICT COPY DEFERRED DELIMITERS DETACH DIVIDE DOT EACH END FAIL +%fallback ABORT AFTER ATTACH BEFORE BEGIN BITAND BITNOT BITOR BLOCKS CHANGE COMMA CONCAT CONFLICT COPY DEFERRED DELIMITERS DETACH DIVIDE DOT EACH END FAIL FILE FOR GLOB ID IMMEDIATE IMPORT INITIALLY INSTEAD ISNULL KEY MODULES NK_BITNOT NK_SEMI NOTNULL OF PLUS PRIVILEGE RAISE REPLACE RESTRICT ROW SEMI STAR STATEMENT STRICT STRING TIMES UPDATE VALUES VARIABLE VIEW WAL. diff --git a/source/libs/parser/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c index f582adb0c6..b3adcc817b 100644 --- a/source/libs/parser/src/parAstCreater.c +++ b/source/libs/parser/src/parAstCreater.c @@ -1105,6 +1105,17 @@ SNode* createTrimDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName, int32_t return (SNode*)pStmt; } +SNode* createCompactStmt(SAstCreateContext* pCxt, SToken* pDbName) { + CHECK_PARSER_STATUS(pCxt); + if (!checkDbName(pCxt, pDbName, false)) { + return NULL; + } + SCompactDatabaseStmt* pStmt = (SCompactDatabaseStmt*)nodesMakeNode(QUERY_NODE_COMPACT_DATABASE_STMT); + CHECK_OUT_OF_MEM(pStmt); + COPY_STRING_FORM_ID_TOKEN(pStmt->dbName, pDbName); + return (SNode*)pStmt; +} + SNode* createDefaultTableOptions(SAstCreateContext* pCxt) { CHECK_PARSER_STATUS(pCxt); STableOptions* pOptions = (STableOptions*)nodesMakeNode(QUERY_NODE_TABLE_OPTIONS); @@ -1768,13 +1779,6 @@ SNode* createResetQueryCacheStmt(SAstCreateContext* pCxt) { return pStmt; } -SNode* createCompactStmt(SAstCreateContext* pCxt, SNodeList* pVgroups) { - CHECK_PARSER_STATUS(pCxt); - SNode* pStmt = nodesMakeNode(QUERY_NODE_COMPACT_STMT); - CHECK_OUT_OF_MEM(pStmt); - return pStmt; -} - SNode* createCreateFunctionStmt(SAstCreateContext* pCxt, bool ignoreExists, bool aggFunc, const SToken* pFuncName, const SToken* pLibPath, SDataType dataType, int32_t bufSize) { CHECK_PARSER_STATUS(pCxt); diff --git a/source/libs/parser/src/parTokenizer.c b/source/libs/parser/src/parTokenizer.c index feb2992875..3e16b5c80f 100644 --- a/source/libs/parser/src/parTokenizer.c +++ b/source/libs/parser/src/parTokenizer.c @@ -61,6 +61,7 @@ static SKeyword keywordTable[] = { {"COLUMN", TK_COLUMN}, {"COMMENT", TK_COMMENT}, {"COMP", TK_COMP}, + {"COMPACT", TK_COMPACT}, {"CONNECTION", TK_CONNECTION}, {"CONNECTIONS", TK_CONNECTIONS}, {"CONNS", TK_CONNS}, diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index 9d6f0a5e8a..58857881d8 100644 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -5530,7 +5530,7 @@ static int32_t translateDropCGroup(STranslateContext* pCxt, SDropCGroupStmt* pSt } static int32_t translateAlterLocal(STranslateContext* pCxt, SAlterLocalStmt* pStmt) { - // todo + // The statement is executed directly on the client without constructing a message. return TSDB_CODE_SUCCESS; } @@ -5545,6 +5545,14 @@ static int32_t translateDescribe(STranslateContext* pCxt, SDescribeStmt* pStmt) return refreshGetTableMeta(pCxt, pStmt->dbName, pStmt->tableName, &pStmt->pMeta); } +static int32_t translateCompact(STranslateContext* pCxt, SCompactDatabaseStmt* pStmt) { + SCompactDbReq compactReq = {0}; + SName name; + tNameSetDbName(&name, pCxt->pParseCxt->acctId, pStmt->dbName, strlen(pStmt->dbName)); + tNameGetFullDbName(&name, compactReq.db); + return buildCmdMsg(pCxt, TDMT_MND_COMPACT_DB, (FSerializeFunc)tSerializeSCompactDbReq, &compactReq); +} + static int32_t translateKillConnection(STranslateContext* pCxt, SKillStmt* pStmt) { SKillConnReq killReq = {0}; killReq.connId = pStmt->targetId; @@ -6478,6 +6486,9 @@ static int32_t translateQuery(STranslateContext* pCxt, SNode* pNode) { case QUERY_NODE_DESCRIBE_STMT: code = translateDescribe(pCxt, (SDescribeStmt*)pNode); break; + case QUERY_NODE_COMPACT_DATABASE_STMT: + code = translateCompact(pCxt, (SCompactDatabaseStmt*)pNode); + break; case QUERY_NODE_KILL_CONNECTION_STMT: code = translateKillConnection(pCxt, (SKillStmt*)pNode); break; diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c index 5f0bf43f2b..1faf34a528 100644 --- a/source/libs/parser/src/sql.c +++ b/source/libs/parser/src/sql.c @@ -139,17 +139,17 @@ typedef union { #define ParseCTX_FETCH #define ParseCTX_STORE #define YYFALLBACK 1 -#define YYNSTATE 737 -#define YYNRULE 560 +#define YYNSTATE 740 +#define YYNRULE 561 #define YYNTOKEN 328 -#define YY_MAX_SHIFT 736 -#define YY_MIN_SHIFTREDUCE 1094 -#define YY_MAX_SHIFTREDUCE 1653 -#define YY_ERROR_ACTION 1654 -#define YY_ACCEPT_ACTION 1655 -#define YY_NO_ACTION 1656 -#define YY_MIN_REDUCE 1657 -#define YY_MAX_REDUCE 2216 +#define YY_MAX_SHIFT 739 +#define YY_MIN_SHIFTREDUCE 1097 +#define YY_MAX_SHIFTREDUCE 1657 +#define YY_ERROR_ACTION 1658 +#define YY_ACCEPT_ACTION 1659 +#define YY_NO_ACTION 1660 +#define YY_MIN_REDUCE 1661 +#define YY_MAX_REDUCE 2221 /************* End control #defines *******************************************/ #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) @@ -216,769 +216,769 @@ typedef union { ** yy_default[] Default action for each state. ** *********** Begin parsing tables **********************************************/ -#define YY_ACTTAB_COUNT (2837) +#define YY_ACTTAB_COUNT (2835) static const YYACTIONTYPE yy_action[] = { - /* 0 */ 476, 1680, 477, 1693, 1893, 589, 1799, 607, 2014, 2187, - /* 10 */ 1795, 1863, 45, 43, 1581, 482, 1929, 176, 343, 2010, - /* 20 */ 376, 478, 1430, 1801, 588, 182, 421, 1861, 367, 2188, - /* 30 */ 590, 1926, 613, 1511, 2010, 1428, 2028, 2192, 345, 1912, - /* 40 */ 2014, 2187, 38, 37, 1929, 1996, 44, 42, 41, 40, - /* 50 */ 39, 2010, 564, 2006, 2012, 357, 2187, 2191, 1506, 1927, - /* 60 */ 613, 2188, 2190, 18, 636, 178, 328, 2046, 2006, 2012, - /* 70 */ 1436, 2193, 182, 368, 601, 640, 2188, 590, 1850, 636, - /* 80 */ 1996, 164, 642, 45, 43, 2006, 2012, 358, 589, 1455, - /* 90 */ 1812, 376, 2187, 1430, 164, 14, 636, 338, 44, 42, - /* 100 */ 41, 40, 39, 1813, 1511, 140, 1428, 588, 182, 35, - /* 110 */ 286, 2027, 2188, 590, 166, 2063, 1669, 733, 322, 2029, - /* 120 */ 646, 2031, 2032, 641, 639, 636, 627, 2081, 268, 1506, - /* 130 */ 8, 2015, 1513, 1514, 18, 1788, 381, 1989, 1540, 1856, - /* 140 */ 1858, 1436, 2010, 625, 1253, 668, 667, 666, 1257, 665, - /* 150 */ 1259, 1260, 664, 1262, 661, 439, 1268, 658, 1270, 1271, - /* 160 */ 655, 652, 1486, 1496, 438, 61, 14, 92, 1512, 1515, - /* 170 */ 265, 2124, 600, 1585, 133, 599, 2006, 2012, 2187, 1455, - /* 180 */ 1857, 1858, 564, 1431, 1863, 1429, 2187, 636, 733, 349, - /* 190 */ 1127, 354, 1456, 588, 182, 1541, 61, 494, 2188, 590, - /* 200 */ 1861, 2193, 182, 1513, 1514, 167, 2188, 590, 1434, 1435, - /* 210 */ 1764, 1485, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, - /* 220 */ 638, 634, 1504, 1505, 1507, 1508, 1509, 1510, 2, 1129, - /* 230 */ 611, 1132, 1133, 1486, 1496, 494, 49, 86, 122, 1512, - /* 240 */ 1515, 121, 120, 119, 118, 117, 116, 115, 114, 113, - /* 250 */ 350, 136, 348, 347, 1431, 517, 1429, 38, 37, 519, - /* 260 */ 1805, 44, 42, 41, 40, 39, 584, 34, 374, 1535, - /* 270 */ 1536, 1537, 1538, 1539, 1543, 1544, 1545, 1546, 1456, 1434, - /* 280 */ 1435, 518, 1485, 1488, 1489, 1490, 1491, 1492, 1493, 1494, - /* 290 */ 1495, 638, 634, 1504, 1505, 1507, 1508, 1509, 1510, 2, - /* 300 */ 379, 11, 45, 43, 1296, 1297, 2046, 220, 161, 612, - /* 310 */ 376, 1863, 1430, 1658, 583, 355, 185, 1812, 364, 680, - /* 320 */ 601, 1487, 171, 1511, 1861, 1428, 2028, 1861, 511, 507, - /* 330 */ 503, 499, 217, 1990, 122, 535, 1574, 121, 120, 119, - /* 340 */ 118, 117, 116, 115, 114, 113, 1454, 185, 1506, 61, - /* 350 */ 545, 140, 485, 18, 477, 1693, 492, 2046, 1922, 582, - /* 360 */ 1436, 1146, 1679, 1145, 233, 643, 234, 2131, 87, 379, - /* 370 */ 1996, 215, 642, 45, 43, 1516, 219, 164, 564, 538, - /* 380 */ 579, 376, 2187, 1430, 532, 14, 1812, 185, 1863, 232, - /* 390 */ 1368, 1369, 1147, 2128, 1511, 369, 1428, 2193, 182, 65, - /* 400 */ 1455, 2027, 2188, 590, 1861, 2063, 1996, 733, 168, 2029, - /* 410 */ 646, 2031, 2032, 641, 553, 636, 181, 2124, 2125, 1506, - /* 420 */ 138, 2129, 1513, 1514, 1650, 69, 1367, 1370, 68, 89, - /* 430 */ 333, 1436, 100, 548, 382, 546, 413, 601, 412, 214, - /* 440 */ 208, 626, 164, 1982, 213, 2131, 626, 490, 612, 565, - /* 450 */ 2153, 1812, 1486, 1496, 1803, 132, 46, 1657, 1512, 1515, - /* 460 */ 132, 411, 515, 206, 585, 580, 573, 520, 140, 86, - /* 470 */ 625, 2127, 1810, 1431, 1726, 1429, 475, 1810, 733, 480, - /* 480 */ 1699, 131, 130, 129, 128, 127, 126, 125, 124, 123, - /* 490 */ 61, 396, 1806, 1513, 1514, 610, 601, 1922, 1434, 1435, - /* 500 */ 185, 1485, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, - /* 510 */ 638, 634, 1504, 1505, 1507, 1508, 1509, 1510, 2, 2192, - /* 520 */ 2028, 1649, 1521, 1486, 1496, 1787, 625, 140, 1455, 1512, - /* 530 */ 1515, 176, 603, 180, 2124, 2125, 1457, 138, 2129, 530, - /* 540 */ 529, 528, 1351, 1352, 1431, 48, 1429, 137, 524, 1863, - /* 550 */ 1455, 2046, 523, 1913, 13, 12, 380, 522, 527, 604, - /* 560 */ 11, 612, 9, 521, 1996, 1861, 642, 526, 525, 1434, - /* 570 */ 1435, 1678, 1485, 1488, 1489, 1490, 1491, 1492, 1493, 1494, - /* 580 */ 1495, 638, 634, 1504, 1505, 1507, 1508, 1509, 1510, 2, - /* 590 */ 45, 43, 183, 2124, 2125, 2027, 138, 2129, 376, 2063, - /* 600 */ 1430, 48, 109, 2029, 646, 2031, 2032, 641, 621, 636, - /* 610 */ 1922, 1511, 1643, 1428, 179, 1996, 2116, 1863, 459, 2028, - /* 620 */ 370, 2112, 1213, 38, 37, 61, 11, 44, 42, 41, - /* 630 */ 40, 39, 678, 1862, 184, 1458, 1506, 1677, 408, 38, - /* 640 */ 37, 185, 2142, 44, 42, 41, 40, 39, 1436, 1554, - /* 650 */ 2046, 154, 153, 675, 674, 673, 151, 1215, 643, 410, - /* 660 */ 406, 45, 43, 1996, 1457, 642, 1542, 2014, 2192, 376, - /* 670 */ 1487, 1430, 2187, 46, 2131, 1786, 198, 197, 2010, 194, - /* 680 */ 267, 1996, 1511, 235, 1428, 2028, 484, 415, 2191, 480, - /* 690 */ 1699, 414, 2188, 2189, 2027, 733, 185, 2017, 2063, 458, - /* 700 */ 2126, 169, 2029, 646, 2031, 2032, 641, 1506, 636, 1785, - /* 710 */ 1513, 1514, 2006, 2012, 371, 83, 2046, 519, 82, 1436, - /* 720 */ 628, 106, 2088, 636, 643, 277, 278, 1620, 626, 1996, - /* 730 */ 276, 642, 564, 671, 1676, 141, 2187, 680, 32, 518, - /* 740 */ 1486, 1496, 287, 1802, 14, 2019, 1512, 1515, 1547, 1406, - /* 750 */ 1407, 2193, 182, 591, 2208, 142, 2188, 590, 2087, 1810, - /* 760 */ 2027, 1431, 544, 1429, 2063, 1436, 733, 168, 2029, 646, - /* 770 */ 2031, 2032, 641, 52, 636, 542, 185, 540, 1996, 245, - /* 780 */ 563, 1513, 1514, 41, 40, 39, 1434, 1435, 633, 1485, - /* 790 */ 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 638, 634, - /* 800 */ 1504, 1505, 1507, 1508, 1509, 1510, 2, 422, 267, 2154, - /* 810 */ 626, 1486, 1496, 331, 1175, 1453, 678, 1512, 1515, 1908, - /* 820 */ 423, 630, 452, 2088, 187, 466, 704, 702, 465, 693, - /* 830 */ 190, 1780, 1431, 1908, 1429, 154, 153, 675, 674, 673, - /* 840 */ 151, 1810, 1675, 435, 192, 467, 38, 37, 437, 1176, - /* 850 */ 44, 42, 41, 40, 39, 1578, 1458, 1434, 1435, 1966, - /* 860 */ 1485, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 638, - /* 870 */ 634, 1504, 1505, 1507, 1508, 1509, 1510, 2, 73, 1674, - /* 880 */ 626, 626, 626, 165, 1132, 1133, 1996, 1908, 306, 346, - /* 890 */ 1723, 530, 529, 528, 54, 419, 420, 692, 196, 137, - /* 900 */ 524, 425, 304, 72, 523, 236, 71, 1652, 1653, 522, - /* 910 */ 527, 1810, 1810, 1810, 1797, 521, 672, 1655, 676, 1854, - /* 920 */ 1146, 1854, 1145, 1996, 202, 472, 470, 677, 81, 300, - /* 930 */ 1854, 463, 1840, 1532, 457, 456, 455, 454, 451, 450, - /* 940 */ 449, 448, 447, 443, 442, 441, 440, 330, 432, 431, - /* 950 */ 430, 1147, 427, 426, 344, 710, 709, 708, 707, 386, - /* 960 */ 61, 706, 705, 144, 700, 699, 698, 697, 696, 695, - /* 970 */ 694, 156, 690, 689, 688, 385, 384, 685, 684, 683, - /* 980 */ 682, 681, 1673, 389, 38, 37, 1672, 388, 44, 42, - /* 990 */ 41, 40, 39, 1671, 1668, 1667, 626, 1458, 225, 108, - /* 1000 */ 191, 223, 1666, 2136, 1574, 2028, 1609, 1455, 38, 37, - /* 1010 */ 429, 31, 44, 42, 41, 40, 39, 38, 37, 1793, - /* 1020 */ 27, 44, 42, 41, 40, 39, 1996, 1810, 564, 2191, - /* 1030 */ 1996, 1665, 2187, 1664, 1663, 1662, 2046, 1996, 1996, 1996, - /* 1040 */ 80, 79, 418, 152, 643, 189, 1996, 2193, 182, 1996, - /* 1050 */ 626, 642, 2188, 590, 596, 576, 575, 1607, 1608, 1610, - /* 1060 */ 1611, 1612, 152, 329, 444, 51, 404, 3, 402, 398, - /* 1070 */ 394, 391, 411, 2028, 1661, 1996, 1660, 1996, 1996, 1996, - /* 1080 */ 2027, 1810, 152, 146, 2063, 134, 1713, 109, 2029, 646, - /* 1090 */ 2031, 2032, 641, 2028, 636, 1401, 1597, 143, 1577, 149, - /* 1100 */ 2087, 2116, 593, 670, 2046, 370, 2112, 227, 531, 1706, - /* 1110 */ 226, 185, 604, 229, 53, 33, 228, 1996, 1996, 642, - /* 1120 */ 1996, 38, 37, 678, 2046, 44, 42, 41, 40, 39, - /* 1130 */ 231, 533, 643, 230, 1404, 13, 12, 1996, 559, 642, - /* 1140 */ 626, 244, 154, 153, 675, 674, 673, 151, 2027, 1487, - /* 1150 */ 626, 243, 2063, 1439, 445, 109, 2029, 646, 2031, 2032, - /* 1160 */ 641, 1704, 636, 240, 493, 63, 2028, 179, 2027, 2116, - /* 1170 */ 637, 1810, 2063, 370, 2112, 109, 2029, 646, 2031, 2032, - /* 1180 */ 641, 1810, 636, 536, 63, 626, 249, 2207, 626, 2116, - /* 1190 */ 90, 1670, 626, 370, 2112, 2143, 1765, 2046, 2156, 1807, - /* 1200 */ 2028, 626, 237, 105, 2150, 643, 560, 152, 1438, 47, - /* 1210 */ 1996, 274, 642, 102, 262, 605, 1810, 1606, 70, 1810, - /* 1220 */ 150, 38, 37, 1810, 152, 44, 42, 41, 40, 39, - /* 1230 */ 577, 2046, 1810, 626, 2028, 2047, 1605, 218, 251, 643, - /* 1240 */ 626, 2027, 256, 626, 1996, 2063, 642, 609, 109, 2029, - /* 1250 */ 646, 2031, 2032, 641, 281, 636, 387, 623, 1694, 608, - /* 1260 */ 2207, 1365, 2116, 279, 1810, 2046, 370, 2112, 2028, 686, - /* 1270 */ 618, 1810, 283, 643, 1810, 2027, 1246, 2163, 1996, 2063, - /* 1280 */ 642, 597, 109, 2029, 646, 2031, 2032, 641, 63, 636, - /* 1290 */ 47, 1194, 47, 592, 2207, 1917, 2116, 650, 1851, 2046, - /* 1300 */ 370, 2112, 2146, 1442, 150, 602, 390, 643, 626, 2027, - /* 1310 */ 626, 571, 1996, 2063, 642, 152, 109, 2029, 646, 2031, - /* 1320 */ 2032, 641, 624, 636, 383, 261, 687, 594, 2207, 551, - /* 1330 */ 2116, 1700, 135, 150, 370, 2112, 264, 1, 4, 1810, - /* 1340 */ 1548, 1810, 1497, 2027, 299, 2181, 395, 2063, 1192, 1274, - /* 1350 */ 109, 2029, 646, 2031, 2032, 641, 1278, 636, 1441, 342, - /* 1360 */ 373, 372, 2207, 1388, 2116, 195, 294, 1285, 370, 2112, - /* 1370 */ 1444, 424, 1458, 2028, 564, 1430, 1918, 163, 2187, 2135, - /* 1380 */ 728, 1511, 461, 1437, 1283, 155, 428, 433, 1428, 1453, - /* 1390 */ 446, 1910, 460, 2193, 182, 453, 468, 462, 2188, 590, - /* 1400 */ 2028, 469, 199, 471, 2046, 473, 1506, 1459, 474, 483, - /* 1410 */ 1461, 1456, 643, 205, 487, 207, 486, 1996, 1436, 642, - /* 1420 */ 1460, 488, 1462, 1436, 489, 210, 550, 491, 212, 84, - /* 1430 */ 85, 2046, 2028, 495, 216, 1149, 514, 512, 513, 643, - /* 1440 */ 516, 1800, 1972, 238, 1996, 552, 642, 332, 2027, 1971, - /* 1450 */ 222, 112, 2063, 1796, 224, 109, 2029, 646, 2031, 2032, - /* 1460 */ 641, 157, 636, 2046, 2028, 632, 158, 2091, 1798, 2116, - /* 1470 */ 733, 643, 1794, 370, 2112, 2027, 1996, 159, 642, 2063, - /* 1480 */ 88, 160, 109, 2029, 646, 2031, 2032, 641, 554, 636, - /* 1490 */ 241, 561, 2147, 558, 2089, 2046, 2116, 568, 295, 578, - /* 1500 */ 370, 2112, 2157, 643, 2162, 148, 616, 2027, 1996, 2161, - /* 1510 */ 642, 2063, 574, 247, 169, 2029, 646, 2031, 2032, 641, - /* 1520 */ 555, 636, 250, 359, 581, 7, 566, 567, 587, 2138, - /* 1530 */ 569, 1445, 260, 1440, 2186, 598, 1431, 2028, 1429, 2027, - /* 1540 */ 360, 2210, 595, 2063, 1574, 258, 109, 2029, 646, 2031, - /* 1550 */ 2032, 641, 363, 636, 172, 139, 1448, 1450, 629, 257, - /* 1560 */ 2116, 1434, 1435, 1457, 370, 2112, 2132, 2209, 2046, 634, - /* 1570 */ 1504, 1505, 1507, 1508, 1509, 1510, 643, 255, 606, 269, - /* 1580 */ 95, 1996, 259, 642, 1463, 1923, 263, 619, 296, 614, - /* 1590 */ 615, 1937, 1936, 1935, 297, 366, 620, 2028, 97, 298, - /* 1600 */ 99, 1811, 60, 101, 648, 2097, 1781, 1855, 301, 729, - /* 1610 */ 730, 290, 2027, 732, 334, 335, 2063, 2028, 1988, 110, - /* 1620 */ 2029, 646, 2031, 2032, 641, 50, 636, 325, 2046, 310, - /* 1630 */ 305, 324, 1987, 2116, 314, 303, 643, 2115, 2112, 1986, - /* 1640 */ 77, 1996, 1983, 642, 392, 393, 1421, 1422, 2046, 188, - /* 1650 */ 397, 1981, 399, 401, 400, 1980, 643, 403, 1979, 405, - /* 1660 */ 1978, 1996, 407, 642, 1977, 409, 78, 1391, 1390, 1949, - /* 1670 */ 1948, 1947, 2027, 416, 417, 1946, 2063, 2028, 1342, 110, - /* 1680 */ 2029, 646, 2031, 2032, 641, 1945, 636, 1901, 1900, 1898, - /* 1690 */ 145, 1897, 644, 2116, 434, 193, 2063, 631, 2112, 110, - /* 1700 */ 2029, 646, 2031, 2032, 641, 2028, 636, 1896, 2046, 1899, - /* 1710 */ 1895, 1894, 1892, 2116, 1891, 1890, 643, 337, 2112, 1889, - /* 1720 */ 436, 1996, 1903, 642, 1888, 1887, 1886, 1885, 1884, 1883, - /* 1730 */ 1882, 1881, 1880, 1879, 1878, 1877, 2046, 1876, 1875, 1874, - /* 1740 */ 147, 1873, 1872, 1871, 643, 1902, 1870, 1869, 1868, 1996, - /* 1750 */ 1867, 642, 2027, 1866, 1865, 464, 2063, 1864, 1344, 110, - /* 1760 */ 2029, 646, 2031, 2032, 641, 1728, 636, 1727, 1725, 1689, - /* 1770 */ 2016, 2028, 1168, 2116, 200, 1221, 201, 1135, 2113, 1688, - /* 1780 */ 2027, 1962, 1956, 1944, 2063, 1134, 203, 316, 2029, 646, - /* 1790 */ 2031, 2032, 641, 177, 636, 2028, 204, 75, 479, 481, - /* 1800 */ 76, 209, 2046, 1943, 1921, 1789, 1724, 365, 211, 1722, - /* 1810 */ 643, 496, 497, 498, 1720, 1996, 502, 642, 501, 500, - /* 1820 */ 1718, 504, 1716, 505, 506, 508, 2046, 1703, 509, 1702, - /* 1830 */ 736, 586, 510, 1685, 640, 1791, 1290, 1289, 1790, 1996, - /* 1840 */ 701, 642, 1212, 1211, 293, 1210, 2027, 1209, 1206, 1714, - /* 1850 */ 2063, 1205, 1204, 323, 2029, 646, 2031, 2032, 641, 175, - /* 1860 */ 636, 221, 703, 2028, 62, 726, 722, 718, 714, 291, - /* 1870 */ 2027, 1203, 351, 1707, 2063, 352, 534, 322, 2029, 646, - /* 1880 */ 2031, 2032, 641, 2028, 636, 1705, 2082, 353, 1684, 537, - /* 1890 */ 539, 1683, 541, 1682, 2046, 111, 543, 1411, 1410, 375, - /* 1900 */ 547, 1961, 643, 1397, 1955, 107, 162, 1996, 284, 642, - /* 1910 */ 1942, 556, 1940, 1413, 2046, 19, 26, 2192, 66, 377, - /* 1920 */ 28, 242, 643, 16, 1622, 570, 246, 1996, 572, 642, - /* 1930 */ 55, 58, 20, 248, 59, 1604, 170, 557, 2027, 252, - /* 1940 */ 253, 622, 2063, 29, 2028, 323, 2029, 646, 2031, 2032, - /* 1950 */ 641, 356, 636, 254, 1596, 2017, 91, 30, 2027, 64, - /* 1960 */ 2028, 562, 2063, 5, 21, 323, 2029, 646, 2031, 2032, - /* 1970 */ 641, 6, 636, 1642, 1643, 2046, 271, 1571, 1637, 1636, - /* 1980 */ 361, 270, 1641, 643, 1640, 362, 266, 173, 1996, 1941, - /* 1990 */ 642, 2046, 57, 1570, 1939, 1938, 1920, 93, 1395, 643, - /* 2000 */ 239, 94, 272, 273, 1996, 1602, 642, 617, 1919, 2028, - /* 2010 */ 22, 275, 280, 67, 96, 285, 282, 98, 23, 549, - /* 2020 */ 12, 1446, 56, 2063, 102, 2028, 318, 2029, 646, 2031, - /* 2030 */ 2032, 641, 1533, 636, 1501, 2027, 2066, 174, 1478, 2063, - /* 2040 */ 2046, 17, 307, 2029, 646, 2031, 2032, 641, 643, 636, - /* 2050 */ 10, 186, 635, 1996, 1499, 642, 2046, 1498, 36, 15, - /* 2060 */ 24, 1523, 1470, 1522, 643, 25, 645, 1275, 649, 1996, - /* 2070 */ 378, 642, 651, 647, 1272, 654, 653, 1269, 656, 657, - /* 2080 */ 659, 1263, 660, 662, 2027, 1252, 669, 663, 2063, 1261, - /* 2090 */ 288, 308, 2029, 646, 2031, 2032, 641, 103, 636, 1284, - /* 2100 */ 2027, 1267, 1266, 2028, 2063, 1265, 104, 309, 2029, 646, - /* 2110 */ 2031, 2032, 641, 1280, 636, 74, 1264, 1166, 679, 2028, - /* 2120 */ 1200, 1199, 1198, 1197, 1196, 1195, 691, 1193, 1191, 1190, - /* 2130 */ 1189, 1219, 1187, 1186, 2046, 1185, 1184, 1183, 1182, 1181, - /* 2140 */ 289, 1216, 643, 1214, 1178, 1177, 1174, 1996, 1173, 642, - /* 2150 */ 2046, 1172, 1171, 1721, 711, 712, 1719, 713, 643, 715, - /* 2160 */ 716, 717, 1717, 1996, 720, 642, 719, 721, 1715, 723, - /* 2170 */ 1701, 724, 725, 727, 1124, 1681, 2028, 292, 2027, 731, - /* 2180 */ 735, 1432, 2063, 302, 734, 315, 2029, 646, 2031, 2032, - /* 2190 */ 641, 1656, 636, 1656, 2027, 2028, 1656, 1656, 2063, 1656, - /* 2200 */ 1656, 319, 2029, 646, 2031, 2032, 641, 2046, 636, 1656, - /* 2210 */ 1656, 1656, 1656, 1656, 1656, 643, 1656, 1656, 1656, 1656, - /* 2220 */ 1996, 1656, 642, 1656, 1656, 1656, 2046, 1656, 1656, 1656, - /* 2230 */ 1656, 1656, 1656, 1656, 643, 1656, 1656, 1656, 1656, 1996, - /* 2240 */ 1656, 642, 1656, 1656, 1656, 1656, 1656, 1656, 1656, 1656, - /* 2250 */ 1656, 2027, 1656, 1656, 2028, 2063, 1656, 1656, 311, 2029, - /* 2260 */ 646, 2031, 2032, 641, 1656, 636, 1656, 1656, 1656, 1656, - /* 2270 */ 2027, 1656, 1656, 2028, 2063, 1656, 1656, 320, 2029, 646, - /* 2280 */ 2031, 2032, 641, 1656, 636, 2046, 1656, 1656, 1656, 1656, - /* 2290 */ 1656, 1656, 1656, 643, 1656, 1656, 1656, 1656, 1996, 1656, - /* 2300 */ 642, 1656, 1656, 1656, 2046, 1656, 1656, 1656, 1656, 1656, - /* 2310 */ 1656, 1656, 643, 1656, 1656, 1656, 1656, 1996, 1656, 642, - /* 2320 */ 1656, 1656, 2028, 1656, 1656, 1656, 1656, 1656, 1656, 2027, - /* 2330 */ 1656, 1656, 1656, 2063, 1656, 1656, 312, 2029, 646, 2031, - /* 2340 */ 2032, 641, 1656, 636, 1656, 1656, 1656, 1656, 2027, 1656, - /* 2350 */ 1656, 1656, 2063, 2046, 1656, 321, 2029, 646, 2031, 2032, - /* 2360 */ 641, 643, 636, 1656, 1656, 1656, 1996, 1656, 642, 1656, - /* 2370 */ 1656, 2028, 1656, 1656, 1656, 1656, 1656, 1656, 1656, 1656, - /* 2380 */ 1656, 1656, 1656, 1656, 1656, 1656, 1656, 2028, 1656, 1656, - /* 2390 */ 1656, 1656, 1656, 1656, 1656, 1656, 1656, 2027, 1656, 1656, - /* 2400 */ 1656, 2063, 2046, 2028, 313, 2029, 646, 2031, 2032, 641, - /* 2410 */ 643, 636, 1656, 1656, 1656, 1996, 1656, 642, 2046, 1656, - /* 2420 */ 1656, 1656, 1656, 1656, 1656, 1656, 643, 1656, 1656, 1656, - /* 2430 */ 1656, 1996, 1656, 642, 2046, 1656, 1656, 1656, 1656, 1656, - /* 2440 */ 1656, 1656, 643, 1656, 1656, 1656, 2027, 1996, 1656, 642, - /* 2450 */ 2063, 1656, 1656, 326, 2029, 646, 2031, 2032, 641, 1656, - /* 2460 */ 636, 1656, 2027, 1656, 1656, 1656, 2063, 1656, 1656, 327, - /* 2470 */ 2029, 646, 2031, 2032, 641, 1656, 636, 1656, 2027, 2028, - /* 2480 */ 1656, 1656, 2063, 1656, 1656, 2040, 2029, 646, 2031, 2032, - /* 2490 */ 641, 1656, 636, 1656, 1656, 2028, 1656, 1656, 1656, 1656, - /* 2500 */ 1656, 1656, 1656, 1656, 1656, 1656, 1656, 1656, 1656, 1656, - /* 2510 */ 2046, 1656, 1656, 1656, 1656, 1656, 1656, 1656, 643, 1656, - /* 2520 */ 1656, 1656, 1656, 1996, 1656, 642, 2046, 1656, 1656, 1656, - /* 2530 */ 1656, 1656, 1656, 1656, 643, 1656, 1656, 1656, 1656, 1996, - /* 2540 */ 1656, 642, 1656, 1656, 1656, 1656, 1656, 1656, 1656, 1656, - /* 2550 */ 1656, 1656, 2028, 1656, 2027, 1656, 1656, 1656, 2063, 1656, - /* 2560 */ 1656, 2039, 2029, 646, 2031, 2032, 641, 1656, 636, 1656, - /* 2570 */ 2027, 2028, 1656, 1656, 2063, 1656, 1656, 2038, 2029, 646, - /* 2580 */ 2031, 2032, 641, 2046, 636, 1656, 1656, 1656, 1656, 1656, - /* 2590 */ 1656, 643, 1656, 1656, 1656, 1656, 1996, 1656, 642, 1656, - /* 2600 */ 1656, 1656, 2046, 1656, 1656, 1656, 1656, 1656, 1656, 1656, - /* 2610 */ 643, 1656, 1656, 1656, 1656, 1996, 1656, 642, 1656, 1656, - /* 2620 */ 1656, 1656, 1656, 1656, 1656, 1656, 1656, 2027, 1656, 1656, - /* 2630 */ 2028, 2063, 1656, 1656, 339, 2029, 646, 2031, 2032, 641, - /* 2640 */ 1656, 636, 1656, 1656, 1656, 1656, 2027, 1656, 1656, 2028, - /* 2650 */ 2063, 1656, 1656, 340, 2029, 646, 2031, 2032, 641, 1656, - /* 2660 */ 636, 2046, 1656, 1656, 1656, 1656, 1656, 1656, 1656, 643, - /* 2670 */ 1656, 1656, 1656, 1656, 1996, 1656, 642, 1656, 1656, 1656, - /* 2680 */ 2046, 1656, 1656, 1656, 1656, 1656, 1656, 1656, 643, 1656, - /* 2690 */ 1656, 1656, 1656, 1996, 1656, 642, 1656, 1656, 2028, 1656, - /* 2700 */ 1656, 1656, 1656, 1656, 1656, 2027, 1656, 1656, 1656, 2063, - /* 2710 */ 1656, 1656, 336, 2029, 646, 2031, 2032, 641, 1656, 636, - /* 2720 */ 1656, 1656, 1656, 1656, 2027, 1656, 1656, 1656, 2063, 2046, - /* 2730 */ 1656, 341, 2029, 646, 2031, 2032, 641, 643, 636, 1656, - /* 2740 */ 1656, 1656, 1996, 1656, 642, 1656, 1656, 2028, 1656, 1656, - /* 2750 */ 1656, 1656, 1656, 1656, 1656, 1656, 1656, 1656, 1656, 1656, - /* 2760 */ 1656, 1656, 1656, 1656, 1656, 1656, 1656, 1656, 1656, 1656, - /* 2770 */ 1656, 1656, 1656, 644, 1656, 1656, 1656, 2063, 2046, 1656, - /* 2780 */ 318, 2029, 646, 2031, 2032, 641, 643, 636, 1656, 1656, - /* 2790 */ 1656, 1996, 1656, 642, 1656, 1656, 1656, 1656, 1656, 1656, - /* 2800 */ 1656, 1656, 1656, 1656, 1656, 1656, 1656, 1656, 1656, 1656, - /* 2810 */ 1656, 1656, 1656, 1656, 1656, 1656, 1656, 1656, 1656, 1656, - /* 2820 */ 1656, 1656, 2027, 1656, 1656, 1656, 2063, 1656, 1656, 317, - /* 2830 */ 2029, 646, 2031, 2032, 641, 1656, 636, + /* 0 */ 166, 380, 1673, 604, 479, 629, 480, 1697, 142, 161, + /* 10 */ 65, 2092, 45, 43, 1585, 1804, 356, 31, 1817, 132, + /* 20 */ 377, 1806, 1434, 38, 37, 1866, 518, 44, 42, 41, + /* 30 */ 40, 39, 2015, 1515, 140, 1432, 1815, 2033, 1149, 1589, + /* 40 */ 1148, 2019, 38, 37, 610, 1459, 44, 42, 41, 40, + /* 50 */ 39, 629, 2015, 220, 2136, 38, 37, 176, 1510, 44, + /* 60 */ 42, 41, 40, 39, 18, 187, 2011, 2017, 2051, 1150, + /* 70 */ 382, 1440, 1659, 1861, 1863, 604, 643, 639, 346, 1917, + /* 80 */ 2133, 2001, 1815, 645, 45, 43, 2011, 2017, 358, 567, + /* 90 */ 1459, 269, 377, 2192, 1434, 1934, 14, 639, 339, 181, + /* 100 */ 2129, 2130, 61, 138, 2134, 1515, 140, 1432, 2198, 182, + /* 110 */ 1932, 616, 2032, 2193, 593, 1459, 2068, 1460, 736, 323, + /* 120 */ 2034, 649, 2036, 2037, 644, 642, 639, 630, 2086, 61, + /* 130 */ 1510, 92, 628, 1517, 1518, 628, 18, 478, 390, 1544, + /* 140 */ 483, 1703, 389, 1440, 1624, 1257, 671, 670, 669, 1261, + /* 150 */ 668, 1263, 1264, 667, 1266, 664, 1459, 1272, 661, 1274, + /* 160 */ 1275, 658, 655, 1490, 1500, 1934, 604, 61, 14, 1516, + /* 170 */ 1519, 266, 2129, 603, 614, 133, 602, 368, 86, 2192, + /* 180 */ 1931, 616, 176, 567, 1435, 2051, 1433, 2192, 1491, 488, + /* 190 */ 736, 480, 1697, 586, 591, 182, 1545, 140, 497, 2193, + /* 200 */ 593, 1811, 2198, 182, 1918, 1517, 1518, 2193, 593, 1438, + /* 210 */ 1439, 48, 1489, 1492, 1493, 1494, 1495, 1496, 1497, 1498, + /* 220 */ 1499, 641, 637, 1508, 1509, 1511, 1512, 1513, 1514, 2, + /* 230 */ 1300, 1301, 61, 1491, 604, 1490, 1500, 1459, 585, 1546, + /* 240 */ 122, 1516, 1519, 121, 120, 119, 118, 117, 116, 115, + /* 250 */ 114, 113, 1149, 185, 1148, 350, 1435, 100, 1433, 35, + /* 260 */ 287, 606, 180, 2129, 2130, 140, 138, 2134, 34, 375, + /* 270 */ 1539, 1540, 1541, 1542, 1543, 1547, 1548, 1549, 1550, 1808, + /* 280 */ 185, 1438, 1439, 1150, 1489, 1492, 1493, 1494, 1495, 1496, + /* 290 */ 1497, 1498, 1499, 641, 637, 1508, 1509, 1511, 1512, 1513, + /* 300 */ 1514, 2, 615, 11, 45, 43, 44, 42, 41, 40, + /* 310 */ 39, 32, 377, 1971, 1434, 1662, 587, 351, 185, 349, + /* 320 */ 348, 1551, 520, 167, 629, 1515, 522, 1432, 1769, 2033, + /* 330 */ 183, 2129, 2130, 592, 138, 2134, 122, 2192, 54, 121, + /* 340 */ 120, 119, 118, 117, 116, 115, 114, 113, 521, 495, + /* 350 */ 1510, 1927, 591, 182, 2033, 1815, 18, 2193, 593, 237, + /* 360 */ 2051, 2020, 185, 1440, 278, 279, 1217, 2197, 646, 277, + /* 370 */ 2197, 2192, 2015, 2001, 2192, 645, 45, 43, 1520, 582, + /* 380 */ 1355, 1356, 1130, 185, 377, 2051, 1434, 2196, 14, 629, + /* 390 */ 2196, 2193, 2195, 646, 2193, 2194, 1613, 1515, 2001, 1432, + /* 400 */ 645, 152, 1219, 420, 2032, 106, 2011, 2017, 2068, 683, + /* 410 */ 736, 168, 2034, 649, 2036, 2037, 644, 639, 639, 141, + /* 420 */ 1815, 1132, 1510, 1135, 1136, 1517, 1518, 1807, 487, 2032, + /* 430 */ 1458, 483, 1703, 2068, 105, 1440, 169, 2034, 649, 2036, + /* 440 */ 2037, 644, 1661, 639, 102, 579, 578, 1611, 1612, 1614, + /* 450 */ 1615, 1616, 568, 2158, 53, 1490, 1500, 1730, 1460, 628, + /* 460 */ 46, 1516, 1519, 588, 583, 576, 131, 130, 129, 128, + /* 470 */ 127, 126, 125, 124, 123, 1525, 1435, 547, 1433, 38, + /* 480 */ 37, 1459, 736, 44, 42, 41, 40, 39, 594, 2213, + /* 490 */ 545, 1462, 543, 41, 40, 39, 675, 1517, 1518, 1859, + /* 500 */ 1994, 1438, 1439, 1792, 1489, 1492, 1493, 1494, 1495, 1496, + /* 510 */ 1497, 1498, 1499, 641, 637, 1508, 1509, 1511, 1512, 1513, + /* 520 */ 1514, 2, 2197, 533, 532, 531, 556, 1490, 1500, 164, + /* 530 */ 629, 137, 527, 1516, 1519, 48, 526, 485, 1818, 1461, + /* 540 */ 86, 525, 530, 481, 132, 567, 1868, 524, 1435, 2192, + /* 550 */ 1433, 523, 1868, 344, 136, 1684, 416, 11, 369, 355, + /* 560 */ 415, 1815, 1866, 1810, 2198, 182, 164, 1440, 1866, 2193, + /* 570 */ 593, 1372, 1373, 1438, 1439, 1817, 1489, 1492, 1493, 1494, + /* 580 */ 1495, 1496, 1497, 1498, 1499, 641, 637, 1508, 1509, 1511, + /* 590 */ 1512, 1513, 1514, 2, 45, 43, 460, 1434, 629, 2001, + /* 600 */ 679, 567, 377, 1859, 1434, 2192, 73, 1371, 1374, 422, + /* 610 */ 1432, 681, 421, 615, 629, 1515, 1647, 1432, 1461, 2033, + /* 620 */ 2198, 182, 61, 592, 1491, 2193, 593, 2192, 430, 1815, + /* 630 */ 154, 153, 678, 677, 676, 151, 246, 629, 629, 674, + /* 640 */ 1510, 1683, 591, 182, 2033, 1815, 1440, 2193, 593, 329, + /* 650 */ 2051, 445, 446, 1440, 198, 197, 81, 1868, 646, 409, + /* 660 */ 613, 49, 1927, 2001, 365, 645, 45, 43, 1815, 1815, + /* 670 */ 1868, 615, 1995, 1866, 377, 2051, 1434, 459, 46, 178, + /* 680 */ 411, 407, 629, 646, 268, 2001, 1867, 1515, 2001, 1432, + /* 690 */ 645, 695, 1855, 736, 2032, 538, 496, 11, 2068, 9, + /* 700 */ 736, 168, 2034, 649, 2036, 2037, 644, 1987, 639, 414, + /* 710 */ 548, 413, 1510, 1815, 235, 1517, 1518, 567, 624, 2032, + /* 720 */ 1927, 2192, 1800, 2068, 234, 1440, 317, 2034, 649, 2036, + /* 730 */ 2037, 644, 680, 639, 412, 1859, 2198, 182, 1682, 541, + /* 740 */ 629, 2193, 593, 2159, 535, 1490, 1500, 1802, 629, 233, + /* 750 */ 14, 1516, 1519, 194, 1812, 397, 533, 532, 531, 1435, + /* 760 */ 1868, 1433, 238, 268, 137, 527, 1435, 370, 1433, 526, + /* 770 */ 589, 1815, 736, 185, 525, 530, 1866, 89, 334, 1815, + /* 780 */ 524, 551, 2001, 549, 1438, 1439, 69, 1517, 1518, 68, + /* 790 */ 83, 1438, 1439, 82, 1489, 1492, 1493, 1494, 1495, 1496, + /* 800 */ 1497, 1498, 1499, 641, 637, 1508, 1509, 1511, 1512, 1513, + /* 810 */ 1514, 2, 185, 332, 1462, 1457, 2136, 1490, 1500, 1862, + /* 820 */ 1863, 1681, 453, 1516, 1519, 467, 38, 37, 466, 221, + /* 830 */ 44, 42, 41, 40, 39, 2136, 681, 1798, 1435, 1727, + /* 840 */ 1433, 1680, 2132, 436, 171, 468, 529, 528, 438, 673, + /* 850 */ 514, 510, 506, 502, 218, 154, 153, 678, 677, 676, + /* 860 */ 151, 2131, 27, 1438, 1439, 2001, 1489, 1492, 1493, 1494, + /* 870 */ 1495, 1496, 1497, 1498, 1499, 641, 637, 1508, 1509, 1511, + /* 880 */ 1512, 1513, 1514, 2, 1462, 2001, 33, 380, 707, 705, + /* 890 */ 347, 87, 38, 37, 216, 164, 44, 42, 41, 40, + /* 900 */ 39, 1793, 426, 52, 1817, 713, 712, 711, 710, 387, + /* 910 */ 566, 709, 708, 144, 703, 702, 701, 700, 699, 698, + /* 920 */ 697, 156, 693, 692, 691, 386, 385, 688, 687, 686, + /* 930 */ 685, 684, 464, 241, 2033, 458, 457, 456, 455, 452, + /* 940 */ 451, 450, 449, 448, 444, 443, 442, 441, 331, 433, + /* 950 */ 432, 431, 739, 428, 427, 345, 165, 301, 2019, 191, + /* 960 */ 1845, 307, 215, 209, 497, 2051, 294, 214, 1679, 2015, + /* 970 */ 493, 629, 631, 646, 2093, 305, 72, 554, 2001, 71, + /* 980 */ 645, 175, 1913, 1678, 383, 563, 207, 729, 725, 721, + /* 990 */ 717, 292, 164, 190, 629, 1898, 2196, 203, 475, 473, + /* 1000 */ 470, 1817, 1815, 2011, 2017, 359, 2033, 1677, 608, 2032, + /* 1010 */ 236, 8, 2001, 2068, 639, 1582, 110, 2034, 649, 2036, + /* 1020 */ 2037, 644, 567, 639, 629, 1815, 2192, 2001, 107, 245, + /* 1030 */ 2121, 285, 1868, 1791, 61, 2118, 596, 2051, 612, 381, + /* 1040 */ 629, 2198, 182, 629, 629, 607, 2193, 593, 1866, 629, + /* 1050 */ 2001, 2001, 645, 1676, 282, 1815, 629, 626, 627, 13, + /* 1060 */ 12, 38, 37, 288, 625, 44, 42, 41, 40, 39, + /* 1070 */ 384, 1815, 522, 108, 1815, 1815, 1410, 1411, 2033, 640, + /* 1080 */ 1815, 2032, 633, 1675, 2093, 2068, 599, 1815, 109, 2034, + /* 1090 */ 649, 2036, 2037, 644, 521, 639, 683, 2001, 562, 272, + /* 1100 */ 179, 1913, 2121, 1674, 271, 1672, 371, 2117, 1671, 2051, + /* 1110 */ 1670, 696, 192, 1785, 80, 79, 419, 646, 152, 189, + /* 1120 */ 184, 1399, 2001, 240, 645, 38, 37, 2001, 2147, 44, + /* 1130 */ 42, 41, 40, 39, 1135, 1136, 1669, 330, 2033, 1668, + /* 1140 */ 405, 244, 403, 399, 395, 392, 412, 440, 226, 2001, + /* 1150 */ 1601, 224, 2001, 2032, 2001, 1558, 439, 2068, 1667, 1666, + /* 1160 */ 109, 2034, 649, 2036, 2037, 644, 1665, 639, 1664, 2051, + /* 1170 */ 143, 1405, 149, 2092, 2121, 2141, 1578, 607, 371, 2117, + /* 1180 */ 2001, 90, 2001, 2001, 645, 185, 1913, 38, 37, 1790, + /* 1190 */ 152, 44, 42, 41, 40, 39, 423, 196, 2033, 51, + /* 1200 */ 636, 3, 2001, 2001, 146, 228, 134, 1770, 227, 424, + /* 1210 */ 2001, 230, 2001, 2032, 229, 63, 63, 2068, 1578, 2019, + /* 1220 */ 109, 2034, 649, 2036, 2037, 644, 250, 639, 232, 2051, + /* 1230 */ 2015, 231, 179, 1443, 2121, 1717, 1710, 646, 371, 2117, + /* 1240 */ 1656, 1657, 2001, 1408, 645, 1708, 2022, 2033, 38, 37, + /* 1250 */ 152, 47, 44, 42, 41, 40, 39, 534, 536, 1581, + /* 1260 */ 2148, 595, 597, 2161, 2011, 2017, 372, 539, 1610, 1609, + /* 1270 */ 275, 70, 150, 2032, 152, 639, 1442, 2068, 2051, 252, + /* 1280 */ 109, 2034, 649, 2036, 2037, 644, 646, 639, 13, 12, + /* 1290 */ 1704, 2001, 2212, 645, 2121, 2024, 63, 681, 371, 2117, + /* 1300 */ 263, 47, 47, 611, 1369, 580, 653, 2033, 219, 2155, + /* 1310 */ 150, 152, 135, 689, 600, 150, 154, 153, 678, 677, + /* 1320 */ 676, 151, 2032, 280, 621, 284, 2068, 1250, 690, 109, + /* 1330 */ 2034, 649, 2036, 2037, 644, 1198, 639, 1179, 2051, 731, + /* 1340 */ 257, 2212, 2052, 2121, 163, 1536, 646, 371, 2117, 1552, + /* 1350 */ 1196, 2001, 1698, 645, 1501, 300, 388, 1856, 2168, 1278, + /* 1360 */ 1922, 605, 2151, 1282, 1289, 1287, 2033, 265, 155, 262, + /* 1370 */ 1, 4, 396, 1180, 391, 343, 1392, 295, 195, 425, + /* 1380 */ 1462, 1923, 2032, 429, 1446, 462, 2068, 434, 1457, 109, + /* 1390 */ 2034, 649, 2036, 2037, 644, 447, 639, 2051, 1915, 454, + /* 1400 */ 461, 2212, 463, 2121, 469, 646, 471, 371, 2117, 472, + /* 1410 */ 2001, 200, 645, 477, 474, 476, 1654, 1463, 574, 486, + /* 1420 */ 1465, 1460, 489, 206, 490, 2033, 208, 1445, 1464, 1466, + /* 1430 */ 491, 492, 211, 494, 1152, 498, 213, 84, 1977, 517, + /* 1440 */ 85, 2032, 217, 515, 516, 2068, 519, 1805, 109, 2034, + /* 1450 */ 649, 2036, 2037, 644, 112, 639, 2051, 333, 553, 555, + /* 1460 */ 2212, 223, 2121, 1976, 646, 1801, 371, 2117, 88, 2001, + /* 1470 */ 225, 645, 157, 148, 158, 1803, 1799, 2186, 159, 558, + /* 1480 */ 160, 239, 374, 373, 242, 2033, 557, 564, 581, 2152, + /* 1490 */ 2167, 2143, 1448, 619, 2162, 571, 561, 7, 577, 296, + /* 1500 */ 2032, 2166, 360, 1515, 2068, 1441, 584, 109, 2034, 649, + /* 1510 */ 2036, 2037, 644, 1653, 639, 248, 2051, 2033, 590, 2212, + /* 1520 */ 251, 2121, 256, 572, 646, 371, 2117, 570, 1510, 2001, + /* 1530 */ 258, 645, 569, 361, 2215, 601, 2140, 1578, 598, 2191, + /* 1540 */ 261, 1440, 1461, 139, 609, 2033, 2137, 270, 2051, 172, + /* 1550 */ 364, 95, 1467, 1928, 297, 617, 646, 298, 618, 1942, + /* 1560 */ 2032, 2001, 1941, 645, 2068, 1940, 367, 109, 2034, 649, + /* 1570 */ 2036, 2037, 644, 259, 639, 260, 2051, 622, 299, 2096, + /* 1580 */ 623, 2121, 264, 1816, 646, 371, 2117, 97, 635, 2001, + /* 1590 */ 99, 645, 2032, 60, 101, 651, 2068, 1860, 2102, 109, + /* 1600 */ 2034, 649, 2036, 2037, 644, 1786, 639, 732, 291, 302, + /* 1610 */ 733, 2094, 735, 2121, 50, 335, 336, 371, 2117, 311, + /* 1620 */ 2032, 326, 304, 306, 2068, 1993, 2033, 109, 2034, 649, + /* 1630 */ 2036, 2037, 644, 325, 639, 1992, 315, 1991, 77, 632, + /* 1640 */ 1988, 2121, 393, 394, 1425, 371, 2117, 1426, 188, 398, + /* 1650 */ 1986, 400, 401, 402, 1449, 1985, 1444, 2051, 404, 1984, + /* 1660 */ 1983, 406, 1982, 408, 410, 646, 78, 1395, 1394, 1954, + /* 1670 */ 2001, 1953, 645, 1952, 417, 2033, 1951, 1950, 418, 1452, + /* 1680 */ 1454, 1346, 1906, 1905, 1903, 145, 1902, 1901, 1904, 1900, + /* 1690 */ 1899, 1897, 637, 1508, 1509, 1511, 1512, 1513, 1514, 1896, + /* 1700 */ 1895, 2032, 193, 435, 1894, 2068, 2051, 437, 110, 2034, + /* 1710 */ 649, 2036, 2037, 644, 646, 639, 1908, 1893, 1892, 2001, + /* 1720 */ 1891, 645, 2121, 1890, 2033, 1889, 2120, 2117, 1888, 1887, + /* 1730 */ 1886, 1885, 1884, 1883, 1882, 1881, 1880, 1879, 147, 1878, + /* 1740 */ 1877, 1876, 1907, 1875, 1874, 1873, 1348, 1872, 1871, 1870, + /* 1750 */ 2032, 465, 1869, 1733, 2068, 2051, 199, 110, 2034, 649, + /* 1760 */ 2036, 2037, 644, 646, 639, 1732, 201, 1731, 2001, 202, + /* 1770 */ 645, 2121, 1729, 2033, 1693, 634, 2117, 1138, 1137, 1692, + /* 1780 */ 204, 1225, 1967, 1961, 1949, 212, 1948, 1926, 1794, 75, + /* 1790 */ 1728, 1172, 2033, 1726, 1724, 177, 205, 499, 76, 647, + /* 1800 */ 210, 2021, 482, 2068, 2051, 484, 110, 2034, 649, 2036, + /* 1810 */ 2037, 644, 646, 639, 500, 501, 503, 2001, 504, 645, + /* 1820 */ 2121, 1722, 1720, 2051, 338, 2117, 508, 507, 366, 1707, + /* 1830 */ 505, 646, 511, 512, 509, 513, 2001, 1706, 645, 1689, + /* 1840 */ 1796, 2033, 1294, 1795, 1216, 1293, 1215, 1214, 2032, 1213, + /* 1850 */ 704, 1210, 2068, 1209, 706, 169, 2034, 649, 2036, 2037, + /* 1860 */ 644, 2033, 639, 1208, 1718, 62, 1207, 2032, 352, 1711, + /* 1870 */ 353, 2068, 2051, 1709, 324, 2034, 649, 2036, 2037, 644, + /* 1880 */ 643, 639, 354, 222, 537, 2001, 540, 645, 1688, 542, + /* 1890 */ 1687, 544, 2051, 1686, 546, 111, 1415, 376, 1414, 550, + /* 1900 */ 646, 1417, 1966, 1401, 26, 2001, 1960, 645, 2214, 66, + /* 1910 */ 1947, 559, 1945, 28, 162, 19, 2032, 16, 2033, 575, + /* 1920 */ 2068, 1626, 55, 323, 2034, 649, 2036, 2037, 644, 2197, + /* 1930 */ 639, 247, 2087, 560, 2033, 573, 2032, 64, 357, 249, + /* 1940 */ 2068, 5, 243, 324, 2034, 649, 2036, 2037, 644, 2051, + /* 1950 */ 639, 58, 2033, 59, 378, 1608, 1600, 646, 254, 30, + /* 1960 */ 255, 6, 2001, 170, 645, 2051, 253, 2022, 21, 267, + /* 1970 */ 29, 565, 91, 646, 1646, 1647, 1641, 1640, 2001, 362, + /* 1980 */ 645, 1645, 1644, 2051, 363, 173, 1946, 57, 1575, 1574, + /* 1990 */ 1944, 646, 1943, 2032, 1925, 93, 2001, 2068, 645, 94, + /* 2000 */ 324, 2034, 649, 2036, 2037, 644, 273, 639, 274, 552, + /* 2010 */ 1924, 2033, 22, 2068, 1606, 276, 319, 2034, 649, 2036, + /* 2020 */ 2037, 644, 56, 639, 281, 620, 67, 2032, 2033, 98, + /* 2030 */ 96, 2068, 283, 102, 308, 2034, 649, 2036, 2037, 644, + /* 2040 */ 286, 639, 2051, 12, 23, 2033, 1450, 10, 2071, 1527, + /* 2050 */ 646, 20, 17, 1537, 1505, 2001, 1526, 645, 638, 2051, + /* 2060 */ 1503, 36, 174, 1502, 15, 24, 186, 646, 1474, 1482, + /* 2070 */ 1279, 25, 2001, 652, 645, 379, 2051, 650, 654, 656, + /* 2080 */ 1276, 657, 1256, 659, 646, 1273, 2032, 662, 665, 2001, + /* 2090 */ 2068, 645, 660, 309, 2034, 649, 2036, 2037, 644, 1267, + /* 2100 */ 639, 663, 2033, 2032, 1265, 648, 289, 2068, 666, 1271, + /* 2110 */ 310, 2034, 649, 2036, 2037, 644, 672, 639, 1270, 103, + /* 2120 */ 2032, 1269, 104, 1268, 2068, 1288, 74, 316, 2034, 649, + /* 2130 */ 2036, 2037, 644, 2051, 639, 1284, 2033, 1170, 682, 1204, + /* 2140 */ 1203, 646, 1202, 1201, 1200, 1199, 2001, 1197, 645, 1195, + /* 2150 */ 1194, 1193, 1223, 1191, 694, 290, 1190, 1189, 1188, 1187, + /* 2160 */ 1186, 1185, 1220, 2033, 1218, 1182, 1181, 2051, 1178, 1177, + /* 2170 */ 1176, 1725, 1175, 714, 716, 646, 715, 2032, 1723, 718, + /* 2180 */ 2001, 2068, 645, 1721, 320, 2034, 649, 2036, 2037, 644, + /* 2190 */ 719, 639, 720, 2033, 2051, 722, 724, 1719, 723, 726, + /* 2200 */ 727, 728, 646, 1705, 730, 1127, 1685, 2001, 293, 645, + /* 2210 */ 734, 2032, 2033, 1436, 303, 2068, 737, 1660, 312, 2034, + /* 2220 */ 649, 2036, 2037, 644, 2051, 639, 1660, 738, 1660, 1660, + /* 2230 */ 1660, 1660, 646, 1660, 1660, 1660, 1660, 2001, 2032, 645, + /* 2240 */ 1660, 1660, 2068, 2051, 1660, 321, 2034, 649, 2036, 2037, + /* 2250 */ 644, 646, 639, 1660, 1660, 1660, 2001, 1660, 645, 1660, + /* 2260 */ 1660, 1660, 1660, 1660, 1660, 1660, 1660, 1660, 2032, 1660, + /* 2270 */ 1660, 1660, 2068, 1660, 1660, 313, 2034, 649, 2036, 2037, + /* 2280 */ 644, 2033, 639, 1660, 1660, 1660, 1660, 2032, 1660, 1660, + /* 2290 */ 1660, 2068, 1660, 1660, 322, 2034, 649, 2036, 2037, 644, + /* 2300 */ 1660, 639, 1660, 1660, 1660, 2033, 1660, 1660, 1660, 1660, + /* 2310 */ 1660, 1660, 2051, 1660, 1660, 1660, 1660, 1660, 1660, 1660, + /* 2320 */ 646, 1660, 1660, 1660, 1660, 2001, 1660, 645, 1660, 1660, + /* 2330 */ 2033, 1660, 1660, 1660, 1660, 1660, 2051, 1660, 1660, 1660, + /* 2340 */ 1660, 1660, 1660, 1660, 646, 1660, 1660, 1660, 1660, 2001, + /* 2350 */ 1660, 645, 1660, 1660, 1660, 1660, 2032, 1660, 1660, 1660, + /* 2360 */ 2068, 2051, 1660, 314, 2034, 649, 2036, 2037, 644, 646, + /* 2370 */ 639, 1660, 1660, 1660, 2001, 1660, 645, 1660, 1660, 1660, + /* 2380 */ 2032, 1660, 1660, 1660, 2068, 1660, 1660, 327, 2034, 649, + /* 2390 */ 2036, 2037, 644, 1660, 639, 1660, 1660, 1660, 1660, 2033, + /* 2400 */ 1660, 1660, 1660, 1660, 1660, 2032, 1660, 1660, 1660, 2068, + /* 2410 */ 1660, 1660, 328, 2034, 649, 2036, 2037, 644, 2033, 639, + /* 2420 */ 1660, 1660, 1660, 1660, 1660, 1660, 1660, 1660, 1660, 1660, + /* 2430 */ 2051, 1660, 1660, 1660, 1660, 1660, 1660, 1660, 646, 1660, + /* 2440 */ 1660, 1660, 1660, 2001, 1660, 645, 1660, 1660, 1660, 2051, + /* 2450 */ 1660, 1660, 1660, 1660, 1660, 1660, 1660, 646, 1660, 1660, + /* 2460 */ 1660, 1660, 2001, 1660, 645, 1660, 1660, 1660, 1660, 1660, + /* 2470 */ 1660, 1660, 1660, 1660, 2032, 1660, 1660, 1660, 2068, 1660, + /* 2480 */ 2033, 2045, 2034, 649, 2036, 2037, 644, 1660, 639, 1660, + /* 2490 */ 1660, 1660, 1660, 2032, 1660, 1660, 1660, 2068, 1660, 2033, + /* 2500 */ 2044, 2034, 649, 2036, 2037, 644, 1660, 639, 1660, 1660, + /* 2510 */ 1660, 2051, 1660, 1660, 1660, 1660, 1660, 1660, 1660, 646, + /* 2520 */ 1660, 1660, 1660, 1660, 2001, 1660, 645, 1660, 1660, 1660, + /* 2530 */ 2051, 1660, 1660, 1660, 1660, 1660, 1660, 1660, 646, 1660, + /* 2540 */ 1660, 1660, 1660, 2001, 1660, 645, 1660, 1660, 1660, 1660, + /* 2550 */ 1660, 1660, 1660, 1660, 1660, 2032, 2033, 1660, 1660, 2068, + /* 2560 */ 1660, 1660, 2043, 2034, 649, 2036, 2037, 644, 1660, 639, + /* 2570 */ 1660, 1660, 1660, 1660, 2032, 2033, 1660, 1660, 2068, 1660, + /* 2580 */ 1660, 340, 2034, 649, 2036, 2037, 644, 2051, 639, 1660, + /* 2590 */ 1660, 1660, 1660, 1660, 1660, 646, 1660, 1660, 1660, 1660, + /* 2600 */ 2001, 1660, 645, 1660, 1660, 1660, 2051, 1660, 1660, 1660, + /* 2610 */ 1660, 1660, 1660, 1660, 646, 1660, 1660, 1660, 1660, 2001, + /* 2620 */ 1660, 645, 1660, 1660, 1660, 1660, 1660, 1660, 1660, 1660, + /* 2630 */ 1660, 2032, 1660, 1660, 1660, 2068, 1660, 2033, 341, 2034, + /* 2640 */ 649, 2036, 2037, 644, 1660, 639, 1660, 1660, 1660, 1660, + /* 2650 */ 2032, 1660, 1660, 1660, 2068, 1660, 1660, 337, 2034, 649, + /* 2660 */ 2036, 2037, 644, 1660, 639, 1660, 1660, 1660, 2051, 1660, + /* 2670 */ 1660, 1660, 1660, 1660, 1660, 1660, 646, 1660, 1660, 1660, + /* 2680 */ 1660, 2001, 1660, 645, 1660, 1660, 1660, 1660, 1660, 1660, + /* 2690 */ 1660, 1660, 1660, 1660, 1660, 1660, 2033, 1660, 1660, 1660, + /* 2700 */ 1660, 1660, 1660, 1660, 1660, 1660, 1660, 1660, 1660, 1660, + /* 2710 */ 1660, 1660, 2032, 1660, 1660, 1660, 2068, 1660, 1660, 342, + /* 2720 */ 2034, 649, 2036, 2037, 644, 1660, 639, 2051, 1660, 1660, + /* 2730 */ 1660, 1660, 1660, 1660, 1660, 646, 1660, 1660, 1660, 1660, + /* 2740 */ 2001, 1660, 645, 1660, 1660, 2033, 1660, 1660, 1660, 1660, + /* 2750 */ 1660, 1660, 1660, 1660, 1660, 1660, 1660, 1660, 1660, 1660, + /* 2760 */ 1660, 1660, 1660, 1660, 1660, 1660, 1660, 1660, 1660, 1660, + /* 2770 */ 1660, 647, 1660, 1660, 1660, 2068, 2051, 1660, 319, 2034, + /* 2780 */ 649, 2036, 2037, 644, 646, 639, 1660, 1660, 1660, 2001, + /* 2790 */ 1660, 645, 1660, 1660, 1660, 1660, 1660, 1660, 1660, 1660, + /* 2800 */ 1660, 1660, 1660, 1660, 1660, 1660, 1660, 1660, 1660, 1660, + /* 2810 */ 1660, 1660, 1660, 1660, 1660, 1660, 1660, 1660, 1660, 1660, + /* 2820 */ 2032, 1660, 1660, 1660, 2068, 1660, 1660, 318, 2034, 649, + /* 2830 */ 2036, 2037, 644, 1660, 639, }; static const YYCODETYPE yy_lookahead[] = { - /* 0 */ 335, 331, 337, 338, 0, 439, 363, 394, 364, 443, - /* 10 */ 363, 362, 12, 13, 14, 14, 377, 362, 369, 375, - /* 20 */ 20, 20, 22, 364, 458, 459, 339, 378, 389, 463, - /* 30 */ 464, 392, 393, 33, 375, 35, 331, 439, 383, 384, - /* 40 */ 364, 443, 8, 9, 377, 375, 12, 13, 14, 15, - /* 50 */ 16, 375, 439, 409, 410, 411, 443, 459, 58, 392, - /* 60 */ 393, 463, 464, 63, 420, 361, 379, 362, 409, 410, - /* 70 */ 70, 458, 459, 354, 339, 370, 463, 464, 374, 420, - /* 80 */ 375, 362, 377, 12, 13, 409, 410, 411, 439, 20, - /* 90 */ 371, 20, 443, 22, 362, 95, 420, 63, 12, 13, - /* 100 */ 14, 15, 16, 371, 33, 370, 35, 458, 459, 428, - /* 110 */ 429, 406, 463, 464, 330, 410, 332, 117, 413, 414, - /* 120 */ 415, 416, 417, 418, 419, 420, 421, 422, 58, 58, - /* 130 */ 39, 364, 132, 133, 63, 0, 373, 394, 104, 376, - /* 140 */ 377, 70, 375, 20, 108, 109, 110, 111, 112, 113, - /* 150 */ 114, 115, 116, 117, 118, 151, 120, 121, 122, 123, - /* 160 */ 124, 125, 162, 163, 160, 95, 95, 97, 168, 169, - /* 170 */ 435, 436, 437, 14, 439, 440, 409, 410, 443, 20, - /* 180 */ 376, 377, 439, 183, 362, 185, 443, 420, 117, 37, - /* 190 */ 4, 369, 20, 458, 459, 161, 95, 62, 463, 464, - /* 200 */ 378, 458, 459, 132, 133, 346, 463, 464, 208, 209, - /* 210 */ 351, 211, 212, 213, 214, 215, 216, 217, 218, 219, - /* 220 */ 220, 221, 222, 223, 224, 225, 226, 227, 228, 43, - /* 230 */ 20, 45, 46, 162, 163, 62, 95, 345, 21, 168, - /* 240 */ 169, 24, 25, 26, 27, 28, 29, 30, 31, 32, - /* 250 */ 98, 359, 100, 101, 183, 103, 185, 8, 9, 107, - /* 260 */ 368, 12, 13, 14, 15, 16, 20, 233, 234, 235, - /* 270 */ 236, 237, 238, 239, 240, 241, 242, 243, 20, 208, - /* 280 */ 209, 129, 211, 212, 213, 214, 215, 216, 217, 218, - /* 290 */ 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, - /* 300 */ 354, 230, 12, 13, 132, 133, 362, 33, 362, 339, - /* 310 */ 20, 362, 22, 0, 370, 369, 246, 371, 369, 62, - /* 320 */ 339, 162, 48, 33, 378, 35, 331, 378, 54, 55, - /* 330 */ 56, 57, 58, 394, 21, 4, 245, 24, 25, 26, - /* 340 */ 27, 28, 29, 30, 31, 32, 20, 246, 58, 95, - /* 350 */ 19, 370, 335, 63, 337, 338, 386, 362, 388, 415, - /* 360 */ 70, 20, 331, 22, 33, 370, 127, 412, 94, 354, - /* 370 */ 375, 97, 377, 12, 13, 14, 35, 362, 439, 48, - /* 380 */ 167, 20, 443, 22, 53, 95, 371, 246, 362, 58, - /* 390 */ 132, 133, 51, 438, 33, 369, 35, 458, 459, 4, - /* 400 */ 20, 406, 463, 464, 378, 410, 375, 117, 413, 414, - /* 410 */ 415, 416, 417, 418, 106, 420, 435, 436, 437, 58, - /* 420 */ 439, 440, 132, 133, 175, 94, 168, 169, 97, 190, - /* 430 */ 191, 70, 343, 194, 354, 196, 182, 339, 184, 165, - /* 440 */ 166, 339, 362, 0, 170, 412, 339, 173, 339, 454, - /* 450 */ 455, 371, 162, 163, 365, 353, 95, 0, 168, 169, - /* 460 */ 353, 207, 360, 189, 251, 252, 253, 360, 370, 345, - /* 470 */ 20, 438, 370, 183, 0, 185, 336, 370, 117, 339, - /* 480 */ 340, 24, 25, 26, 27, 28, 29, 30, 31, 32, - /* 490 */ 95, 48, 368, 132, 133, 386, 339, 388, 208, 209, - /* 500 */ 246, 211, 212, 213, 214, 215, 216, 217, 218, 219, - /* 510 */ 220, 221, 222, 223, 224, 225, 226, 227, 228, 3, - /* 520 */ 331, 272, 14, 162, 163, 0, 20, 370, 20, 168, - /* 530 */ 169, 362, 434, 435, 436, 437, 20, 439, 440, 65, - /* 540 */ 66, 67, 162, 163, 183, 95, 185, 73, 74, 362, - /* 550 */ 20, 362, 78, 384, 1, 2, 369, 83, 84, 370, - /* 560 */ 230, 339, 232, 89, 375, 378, 377, 348, 349, 208, - /* 570 */ 209, 331, 211, 212, 213, 214, 215, 216, 217, 218, - /* 580 */ 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, - /* 590 */ 12, 13, 435, 436, 437, 406, 439, 440, 20, 410, - /* 600 */ 22, 95, 413, 414, 415, 416, 417, 418, 386, 420, - /* 610 */ 388, 33, 96, 35, 425, 375, 427, 362, 79, 331, - /* 620 */ 431, 432, 35, 8, 9, 95, 230, 12, 13, 14, - /* 630 */ 15, 16, 107, 378, 445, 20, 58, 331, 178, 8, - /* 640 */ 9, 246, 453, 12, 13, 14, 15, 16, 70, 96, - /* 650 */ 362, 126, 127, 128, 129, 130, 131, 70, 370, 199, - /* 660 */ 200, 12, 13, 375, 20, 377, 161, 364, 439, 20, - /* 670 */ 162, 22, 443, 95, 412, 0, 137, 138, 375, 58, - /* 680 */ 164, 375, 33, 126, 35, 331, 336, 394, 459, 339, - /* 690 */ 340, 398, 463, 464, 406, 117, 246, 47, 410, 160, - /* 700 */ 438, 413, 414, 415, 416, 417, 418, 58, 420, 0, - /* 710 */ 132, 133, 409, 410, 411, 94, 362, 107, 97, 70, - /* 720 */ 424, 343, 426, 420, 370, 126, 127, 96, 339, 375, - /* 730 */ 131, 377, 439, 106, 331, 357, 443, 62, 233, 129, - /* 740 */ 162, 163, 353, 365, 95, 95, 168, 169, 243, 192, - /* 750 */ 193, 458, 459, 465, 466, 423, 463, 464, 426, 370, - /* 760 */ 406, 183, 21, 185, 410, 70, 117, 413, 414, 415, - /* 770 */ 416, 417, 418, 164, 420, 34, 246, 36, 375, 164, - /* 780 */ 171, 132, 133, 14, 15, 16, 208, 209, 63, 211, - /* 790 */ 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, - /* 800 */ 222, 223, 224, 225, 226, 227, 228, 22, 164, 455, - /* 810 */ 339, 162, 163, 18, 35, 20, 107, 168, 169, 370, - /* 820 */ 35, 424, 27, 426, 353, 30, 348, 349, 33, 350, - /* 830 */ 381, 352, 183, 370, 185, 126, 127, 128, 129, 130, - /* 840 */ 131, 370, 331, 48, 381, 50, 8, 9, 53, 70, - /* 850 */ 12, 13, 14, 15, 16, 4, 20, 208, 209, 358, - /* 860 */ 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, - /* 870 */ 221, 222, 223, 224, 225, 226, 227, 228, 106, 331, - /* 880 */ 339, 339, 339, 18, 45, 46, 375, 370, 23, 94, - /* 890 */ 0, 65, 66, 67, 353, 353, 353, 70, 381, 73, - /* 900 */ 74, 106, 37, 38, 78, 404, 41, 132, 133, 83, - /* 910 */ 84, 370, 370, 370, 363, 89, 372, 328, 372, 375, - /* 920 */ 20, 375, 22, 375, 59, 60, 61, 372, 156, 355, - /* 930 */ 375, 136, 358, 208, 139, 140, 141, 142, 143, 144, + /* 0 */ 330, 354, 332, 339, 335, 339, 337, 338, 423, 362, + /* 10 */ 4, 426, 12, 13, 14, 363, 369, 2, 371, 353, + /* 20 */ 20, 364, 22, 8, 9, 378, 360, 12, 13, 14, + /* 30 */ 15, 16, 375, 33, 370, 35, 370, 331, 20, 14, + /* 40 */ 22, 364, 8, 9, 394, 20, 12, 13, 14, 15, + /* 50 */ 16, 339, 375, 35, 412, 8, 9, 362, 58, 12, + /* 60 */ 13, 14, 15, 16, 64, 353, 409, 410, 362, 51, + /* 70 */ 373, 71, 328, 376, 377, 339, 370, 420, 383, 384, + /* 80 */ 438, 375, 370, 377, 12, 13, 409, 410, 411, 439, + /* 90 */ 20, 58, 20, 443, 22, 377, 96, 420, 64, 435, + /* 100 */ 436, 437, 96, 439, 440, 33, 370, 35, 458, 459, + /* 110 */ 392, 393, 406, 463, 464, 20, 410, 20, 118, 413, + /* 120 */ 414, 415, 416, 417, 418, 419, 420, 421, 422, 96, + /* 130 */ 58, 98, 20, 133, 134, 20, 64, 336, 394, 105, + /* 140 */ 339, 340, 398, 71, 97, 109, 110, 111, 112, 113, + /* 150 */ 114, 115, 116, 117, 118, 119, 20, 121, 122, 123, + /* 160 */ 124, 125, 126, 163, 164, 377, 339, 96, 96, 169, + /* 170 */ 170, 435, 436, 437, 20, 439, 440, 389, 345, 443, + /* 180 */ 392, 393, 362, 439, 184, 362, 186, 443, 163, 335, + /* 190 */ 118, 337, 338, 370, 458, 459, 162, 370, 63, 463, + /* 200 */ 464, 368, 458, 459, 384, 133, 134, 463, 464, 209, + /* 210 */ 210, 96, 212, 213, 214, 215, 216, 217, 218, 219, + /* 220 */ 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + /* 230 */ 133, 134, 96, 163, 339, 163, 164, 20, 415, 162, + /* 240 */ 21, 169, 170, 24, 25, 26, 27, 28, 29, 30, + /* 250 */ 31, 32, 20, 247, 22, 37, 184, 343, 186, 428, + /* 260 */ 429, 434, 435, 436, 437, 370, 439, 440, 234, 235, + /* 270 */ 236, 237, 238, 239, 240, 241, 242, 243, 244, 365, + /* 280 */ 247, 209, 210, 51, 212, 213, 214, 215, 216, 217, + /* 290 */ 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + /* 300 */ 228, 229, 339, 231, 12, 13, 12, 13, 14, 15, + /* 310 */ 16, 234, 20, 358, 22, 0, 20, 99, 247, 101, + /* 320 */ 102, 244, 104, 346, 339, 33, 108, 35, 351, 331, + /* 330 */ 435, 436, 437, 439, 439, 440, 21, 443, 353, 24, + /* 340 */ 25, 26, 27, 28, 29, 30, 31, 32, 130, 386, + /* 350 */ 58, 388, 458, 459, 331, 370, 64, 463, 464, 404, + /* 360 */ 362, 364, 247, 71, 127, 128, 35, 439, 370, 132, + /* 370 */ 439, 443, 375, 375, 443, 377, 12, 13, 14, 168, + /* 380 */ 163, 164, 4, 247, 20, 362, 22, 459, 96, 339, + /* 390 */ 459, 463, 464, 370, 463, 464, 209, 33, 375, 35, + /* 400 */ 377, 44, 71, 353, 406, 343, 409, 410, 410, 63, + /* 410 */ 118, 413, 414, 415, 416, 417, 418, 420, 420, 357, + /* 420 */ 370, 43, 58, 45, 46, 133, 134, 365, 336, 406, + /* 430 */ 20, 339, 340, 410, 96, 71, 413, 414, 415, 416, + /* 440 */ 417, 418, 0, 420, 106, 258, 259, 260, 261, 262, + /* 450 */ 263, 264, 454, 455, 97, 163, 164, 0, 20, 20, + /* 460 */ 96, 169, 170, 252, 253, 254, 24, 25, 26, 27, + /* 470 */ 28, 29, 30, 31, 32, 14, 184, 21, 186, 8, + /* 480 */ 9, 20, 118, 12, 13, 14, 15, 16, 465, 466, + /* 490 */ 34, 20, 36, 14, 15, 16, 372, 133, 134, 375, + /* 500 */ 394, 209, 210, 0, 212, 213, 214, 215, 216, 217, + /* 510 */ 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + /* 520 */ 228, 229, 3, 66, 67, 68, 107, 163, 164, 362, + /* 530 */ 339, 74, 75, 169, 170, 96, 79, 14, 371, 20, + /* 540 */ 345, 84, 85, 20, 353, 439, 362, 90, 184, 443, + /* 550 */ 186, 360, 362, 369, 359, 331, 394, 231, 354, 369, + /* 560 */ 398, 370, 378, 368, 458, 459, 362, 71, 378, 463, + /* 570 */ 464, 133, 134, 209, 210, 371, 212, 213, 214, 215, + /* 580 */ 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + /* 590 */ 226, 227, 228, 229, 12, 13, 80, 22, 339, 375, + /* 600 */ 372, 439, 20, 375, 22, 443, 107, 169, 170, 339, + /* 610 */ 35, 108, 353, 339, 339, 33, 97, 35, 20, 331, + /* 620 */ 458, 459, 96, 439, 163, 463, 464, 443, 353, 370, + /* 630 */ 127, 128, 129, 130, 131, 132, 165, 339, 339, 107, + /* 640 */ 58, 331, 458, 459, 331, 370, 71, 463, 464, 379, + /* 650 */ 362, 353, 353, 71, 138, 139, 157, 362, 370, 179, + /* 660 */ 386, 96, 388, 375, 369, 377, 12, 13, 370, 370, + /* 670 */ 362, 339, 394, 378, 20, 362, 22, 161, 96, 361, + /* 680 */ 200, 201, 339, 370, 165, 375, 378, 33, 375, 35, + /* 690 */ 377, 71, 374, 118, 406, 4, 353, 231, 410, 233, + /* 700 */ 118, 413, 414, 415, 416, 417, 418, 0, 420, 183, + /* 710 */ 19, 185, 58, 370, 128, 133, 134, 439, 386, 406, + /* 720 */ 388, 443, 363, 410, 33, 71, 413, 414, 415, 416, + /* 730 */ 417, 418, 372, 420, 208, 375, 458, 459, 331, 48, + /* 740 */ 339, 463, 464, 455, 53, 163, 164, 363, 339, 58, + /* 750 */ 96, 169, 170, 58, 353, 48, 66, 67, 68, 184, + /* 760 */ 362, 186, 353, 165, 74, 75, 184, 369, 186, 79, + /* 770 */ 457, 370, 118, 247, 84, 85, 378, 191, 192, 370, + /* 780 */ 90, 195, 375, 197, 209, 210, 95, 133, 134, 98, + /* 790 */ 95, 209, 210, 98, 212, 213, 214, 215, 216, 217, + /* 800 */ 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + /* 810 */ 228, 229, 247, 18, 20, 20, 412, 163, 164, 376, + /* 820 */ 377, 331, 27, 169, 170, 30, 8, 9, 33, 33, + /* 830 */ 12, 13, 14, 15, 16, 412, 108, 363, 184, 0, + /* 840 */ 186, 331, 438, 48, 48, 50, 348, 349, 53, 363, + /* 850 */ 54, 55, 56, 57, 58, 127, 128, 129, 130, 131, + /* 860 */ 132, 438, 44, 209, 210, 375, 212, 213, 214, 215, + /* 870 */ 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + /* 880 */ 226, 227, 228, 229, 20, 375, 2, 354, 348, 349, + /* 890 */ 95, 95, 8, 9, 98, 362, 12, 13, 14, 15, + /* 900 */ 16, 0, 107, 165, 371, 66, 67, 68, 69, 70, + /* 910 */ 172, 72, 73, 74, 75, 76, 77, 78, 79, 80, + /* 920 */ 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + /* 930 */ 91, 92, 137, 363, 331, 140, 141, 142, 143, 144, /* 940 */ 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - /* 950 */ 155, 51, 157, 158, 159, 65, 66, 67, 68, 69, - /* 960 */ 95, 71, 72, 73, 74, 75, 76, 77, 78, 79, - /* 970 */ 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - /* 980 */ 90, 91, 331, 394, 8, 9, 331, 398, 12, 13, - /* 990 */ 14, 15, 16, 331, 331, 331, 339, 20, 99, 134, - /* 1000 */ 164, 102, 331, 244, 245, 331, 208, 20, 8, 9, - /* 1010 */ 353, 2, 12, 13, 14, 15, 16, 8, 9, 363, - /* 1020 */ 44, 12, 13, 14, 15, 16, 375, 370, 439, 3, - /* 1030 */ 375, 331, 443, 331, 331, 331, 362, 375, 375, 375, - /* 1040 */ 175, 176, 177, 44, 370, 180, 375, 458, 459, 375, - /* 1050 */ 339, 377, 463, 464, 44, 257, 258, 259, 260, 261, - /* 1060 */ 262, 263, 44, 198, 353, 42, 201, 44, 203, 204, - /* 1070 */ 205, 206, 207, 331, 331, 375, 331, 375, 375, 375, - /* 1080 */ 406, 370, 44, 42, 410, 44, 0, 413, 414, 415, - /* 1090 */ 416, 417, 418, 331, 420, 96, 96, 423, 247, 425, - /* 1100 */ 426, 427, 44, 363, 362, 431, 432, 99, 22, 0, - /* 1110 */ 102, 246, 370, 99, 96, 2, 102, 375, 375, 377, - /* 1120 */ 375, 8, 9, 107, 362, 12, 13, 14, 15, 16, - /* 1130 */ 99, 22, 370, 102, 96, 1, 2, 375, 399, 377, - /* 1140 */ 339, 164, 126, 127, 128, 129, 130, 131, 406, 162, - /* 1150 */ 339, 58, 410, 35, 353, 413, 414, 415, 416, 417, - /* 1160 */ 418, 0, 420, 363, 353, 44, 331, 425, 406, 427, - /* 1170 */ 363, 370, 410, 431, 432, 413, 414, 415, 416, 417, - /* 1180 */ 418, 370, 420, 22, 44, 339, 44, 425, 339, 427, - /* 1190 */ 97, 332, 339, 431, 432, 453, 351, 362, 385, 353, - /* 1200 */ 331, 339, 353, 95, 442, 370, 353, 44, 35, 44, - /* 1210 */ 375, 44, 377, 105, 467, 353, 370, 96, 44, 370, - /* 1220 */ 44, 8, 9, 370, 44, 12, 13, 14, 15, 16, - /* 1230 */ 456, 362, 370, 339, 331, 362, 96, 341, 96, 370, - /* 1240 */ 339, 406, 450, 339, 375, 410, 377, 353, 413, 414, - /* 1250 */ 415, 416, 417, 418, 353, 420, 341, 353, 338, 96, - /* 1260 */ 425, 96, 427, 96, 370, 362, 431, 432, 331, 13, - /* 1270 */ 96, 370, 96, 370, 370, 406, 96, 442, 375, 410, - /* 1280 */ 377, 271, 413, 414, 415, 416, 417, 418, 44, 420, - /* 1290 */ 44, 35, 44, 267, 425, 385, 427, 44, 374, 362, - /* 1300 */ 431, 432, 385, 185, 44, 441, 408, 370, 339, 406, - /* 1310 */ 339, 442, 375, 410, 377, 44, 413, 414, 415, 416, - /* 1320 */ 417, 418, 353, 420, 353, 433, 13, 269, 425, 394, - /* 1330 */ 427, 0, 44, 44, 431, 432, 460, 444, 248, 370, - /* 1340 */ 96, 370, 96, 406, 96, 442, 48, 410, 35, 96, - /* 1350 */ 413, 414, 415, 416, 417, 418, 96, 420, 185, 407, - /* 1360 */ 12, 13, 425, 181, 427, 42, 396, 96, 431, 432, - /* 1370 */ 22, 382, 20, 331, 439, 22, 385, 164, 443, 442, - /* 1380 */ 49, 33, 161, 35, 96, 96, 382, 380, 35, 20, - /* 1390 */ 339, 339, 380, 458, 459, 382, 93, 380, 463, 464, - /* 1400 */ 331, 347, 339, 339, 362, 339, 58, 20, 333, 333, - /* 1410 */ 20, 20, 370, 345, 377, 345, 401, 375, 70, 377, - /* 1420 */ 20, 340, 20, 70, 395, 345, 197, 340, 345, 345, - /* 1430 */ 345, 362, 331, 339, 345, 52, 333, 342, 342, 370, - /* 1440 */ 362, 362, 375, 343, 375, 405, 377, 333, 406, 375, - /* 1450 */ 362, 339, 410, 362, 362, 413, 414, 415, 416, 417, - /* 1460 */ 418, 362, 420, 362, 331, 117, 362, 425, 362, 427, - /* 1470 */ 117, 370, 362, 431, 432, 406, 375, 362, 377, 410, - /* 1480 */ 95, 362, 413, 414, 415, 416, 417, 418, 188, 420, - /* 1490 */ 343, 339, 385, 377, 425, 362, 427, 375, 401, 256, - /* 1500 */ 431, 432, 385, 370, 449, 403, 255, 406, 375, 449, - /* 1510 */ 377, 410, 375, 390, 413, 414, 415, 416, 417, 418, - /* 1520 */ 400, 420, 390, 375, 375, 264, 249, 265, 174, 452, - /* 1530 */ 266, 183, 408, 185, 462, 270, 183, 331, 185, 406, - /* 1540 */ 273, 468, 268, 410, 245, 447, 413, 414, 415, 416, - /* 1550 */ 417, 418, 340, 420, 449, 370, 208, 209, 425, 448, - /* 1560 */ 427, 208, 209, 20, 431, 432, 412, 466, 362, 221, - /* 1570 */ 222, 223, 224, 225, 226, 227, 370, 451, 339, 343, - /* 1580 */ 343, 375, 446, 377, 20, 388, 461, 166, 390, 375, - /* 1590 */ 375, 375, 375, 375, 390, 375, 387, 331, 343, 358, - /* 1600 */ 343, 370, 95, 95, 366, 430, 352, 375, 339, 36, - /* 1610 */ 334, 343, 406, 333, 391, 391, 410, 331, 0, 413, - /* 1620 */ 414, 415, 416, 417, 418, 397, 420, 402, 362, 356, - /* 1630 */ 329, 356, 0, 427, 356, 344, 370, 431, 432, 0, - /* 1640 */ 42, 375, 0, 377, 35, 202, 35, 35, 362, 35, - /* 1650 */ 202, 0, 35, 202, 35, 0, 370, 202, 0, 35, - /* 1660 */ 0, 375, 22, 377, 0, 35, 190, 185, 183, 0, - /* 1670 */ 0, 0, 406, 179, 178, 0, 410, 331, 47, 413, - /* 1680 */ 414, 415, 416, 417, 418, 0, 420, 0, 0, 0, - /* 1690 */ 42, 0, 406, 427, 35, 151, 410, 431, 432, 413, - /* 1700 */ 414, 415, 416, 417, 418, 331, 420, 0, 362, 0, - /* 1710 */ 0, 0, 0, 427, 0, 0, 370, 431, 432, 0, - /* 1720 */ 151, 375, 0, 377, 0, 0, 0, 0, 0, 0, - /* 1730 */ 0, 0, 0, 0, 0, 0, 362, 0, 0, 0, - /* 1740 */ 42, 0, 0, 0, 370, 0, 0, 0, 0, 375, - /* 1750 */ 0, 377, 406, 0, 0, 135, 410, 0, 22, 413, - /* 1760 */ 414, 415, 416, 417, 418, 0, 420, 0, 0, 0, - /* 1770 */ 47, 331, 64, 427, 58, 35, 58, 14, 432, 0, - /* 1780 */ 406, 0, 0, 0, 410, 14, 42, 413, 414, 415, - /* 1790 */ 416, 417, 418, 44, 420, 331, 40, 39, 47, 47, - /* 1800 */ 39, 39, 362, 0, 0, 0, 0, 367, 174, 0, - /* 1810 */ 370, 35, 48, 39, 0, 375, 39, 377, 48, 35, - /* 1820 */ 0, 35, 0, 48, 39, 35, 362, 0, 48, 0, - /* 1830 */ 19, 457, 39, 0, 370, 0, 35, 22, 0, 375, - /* 1840 */ 44, 377, 35, 35, 33, 35, 406, 35, 35, 0, - /* 1850 */ 410, 35, 22, 413, 414, 415, 416, 417, 418, 48, - /* 1860 */ 420, 102, 44, 331, 104, 54, 55, 56, 57, 58, - /* 1870 */ 406, 35, 22, 0, 410, 22, 50, 413, 414, 415, - /* 1880 */ 416, 417, 418, 331, 420, 0, 422, 22, 0, 35, - /* 1890 */ 35, 0, 35, 0, 362, 20, 22, 35, 35, 367, - /* 1900 */ 195, 0, 370, 35, 0, 94, 186, 375, 97, 377, - /* 1910 */ 0, 22, 0, 96, 362, 44, 95, 3, 95, 367, - /* 1920 */ 95, 166, 370, 250, 96, 229, 95, 375, 254, 377, - /* 1930 */ 164, 44, 250, 96, 44, 96, 95, 164, 406, 95, - /* 1940 */ 44, 130, 410, 95, 331, 413, 414, 415, 416, 417, - /* 1950 */ 418, 164, 420, 47, 96, 47, 95, 44, 406, 3, - /* 1960 */ 331, 172, 410, 171, 44, 413, 414, 415, 416, 417, - /* 1970 */ 418, 171, 420, 96, 96, 362, 165, 96, 35, 35, - /* 1980 */ 35, 170, 35, 370, 35, 35, 47, 47, 375, 0, - /* 1990 */ 377, 362, 44, 96, 0, 0, 0, 95, 187, 370, - /* 2000 */ 189, 39, 47, 96, 375, 96, 377, 167, 0, 331, - /* 2010 */ 95, 95, 95, 95, 39, 47, 165, 95, 44, 406, - /* 2020 */ 2, 22, 244, 410, 105, 331, 413, 414, 415, 416, - /* 2030 */ 417, 418, 208, 420, 96, 406, 95, 47, 22, 410, - /* 2040 */ 362, 250, 413, 414, 415, 416, 417, 418, 370, 420, - /* 2050 */ 231, 47, 95, 375, 96, 377, 362, 96, 95, 95, - /* 2060 */ 95, 229, 96, 229, 370, 95, 210, 96, 35, 375, - /* 2070 */ 35, 377, 95, 106, 96, 95, 35, 96, 35, 95, - /* 2080 */ 35, 96, 95, 35, 406, 22, 107, 95, 410, 96, - /* 2090 */ 44, 413, 414, 415, 416, 417, 418, 95, 420, 35, - /* 2100 */ 406, 119, 119, 331, 410, 119, 95, 413, 414, 415, - /* 2110 */ 416, 417, 418, 22, 420, 95, 119, 64, 63, 331, - /* 2120 */ 35, 35, 35, 35, 35, 35, 92, 35, 35, 35, - /* 2130 */ 35, 70, 35, 35, 362, 35, 22, 35, 35, 35, - /* 2140 */ 44, 70, 370, 35, 35, 35, 35, 375, 35, 377, - /* 2150 */ 362, 22, 35, 0, 35, 48, 0, 39, 370, 35, - /* 2160 */ 48, 39, 0, 375, 48, 377, 35, 39, 0, 35, - /* 2170 */ 0, 48, 39, 35, 35, 0, 331, 22, 406, 21, - /* 2180 */ 20, 22, 410, 22, 21, 413, 414, 415, 416, 417, - /* 2190 */ 418, 469, 420, 469, 406, 331, 469, 469, 410, 469, - /* 2200 */ 469, 413, 414, 415, 416, 417, 418, 362, 420, 469, - /* 2210 */ 469, 469, 469, 469, 469, 370, 469, 469, 469, 469, - /* 2220 */ 375, 469, 377, 469, 469, 469, 362, 469, 469, 469, - /* 2230 */ 469, 469, 469, 469, 370, 469, 469, 469, 469, 375, - /* 2240 */ 469, 377, 469, 469, 469, 469, 469, 469, 469, 469, - /* 2250 */ 469, 406, 469, 469, 331, 410, 469, 469, 413, 414, - /* 2260 */ 415, 416, 417, 418, 469, 420, 469, 469, 469, 469, - /* 2270 */ 406, 469, 469, 331, 410, 469, 469, 413, 414, 415, - /* 2280 */ 416, 417, 418, 469, 420, 362, 469, 469, 469, 469, - /* 2290 */ 469, 469, 469, 370, 469, 469, 469, 469, 375, 469, - /* 2300 */ 377, 469, 469, 469, 362, 469, 469, 469, 469, 469, - /* 2310 */ 469, 469, 370, 469, 469, 469, 469, 375, 469, 377, - /* 2320 */ 469, 469, 331, 469, 469, 469, 469, 469, 469, 406, - /* 2330 */ 469, 469, 469, 410, 469, 469, 413, 414, 415, 416, - /* 2340 */ 417, 418, 469, 420, 469, 469, 469, 469, 406, 469, - /* 2350 */ 469, 469, 410, 362, 469, 413, 414, 415, 416, 417, - /* 2360 */ 418, 370, 420, 469, 469, 469, 375, 469, 377, 469, - /* 2370 */ 469, 331, 469, 469, 469, 469, 469, 469, 469, 469, - /* 2380 */ 469, 469, 469, 469, 469, 469, 469, 331, 469, 469, - /* 2390 */ 469, 469, 469, 469, 469, 469, 469, 406, 469, 469, - /* 2400 */ 469, 410, 362, 331, 413, 414, 415, 416, 417, 418, - /* 2410 */ 370, 420, 469, 469, 469, 375, 469, 377, 362, 469, - /* 2420 */ 469, 469, 469, 469, 469, 469, 370, 469, 469, 469, - /* 2430 */ 469, 375, 469, 377, 362, 469, 469, 469, 469, 469, - /* 2440 */ 469, 469, 370, 469, 469, 469, 406, 375, 469, 377, - /* 2450 */ 410, 469, 469, 413, 414, 415, 416, 417, 418, 469, - /* 2460 */ 420, 469, 406, 469, 469, 469, 410, 469, 469, 413, - /* 2470 */ 414, 415, 416, 417, 418, 469, 420, 469, 406, 331, - /* 2480 */ 469, 469, 410, 469, 469, 413, 414, 415, 416, 417, - /* 2490 */ 418, 469, 420, 469, 469, 331, 469, 469, 469, 469, - /* 2500 */ 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, - /* 2510 */ 362, 469, 469, 469, 469, 469, 469, 469, 370, 469, - /* 2520 */ 469, 469, 469, 375, 469, 377, 362, 469, 469, 469, - /* 2530 */ 469, 469, 469, 469, 370, 469, 469, 469, 469, 375, - /* 2540 */ 469, 377, 469, 469, 469, 469, 469, 469, 469, 469, - /* 2550 */ 469, 469, 331, 469, 406, 469, 469, 469, 410, 469, - /* 2560 */ 469, 413, 414, 415, 416, 417, 418, 469, 420, 469, - /* 2570 */ 406, 331, 469, 469, 410, 469, 469, 413, 414, 415, - /* 2580 */ 416, 417, 418, 362, 420, 469, 469, 469, 469, 469, - /* 2590 */ 469, 370, 469, 469, 469, 469, 375, 469, 377, 469, - /* 2600 */ 469, 469, 362, 469, 469, 469, 469, 469, 469, 469, - /* 2610 */ 370, 469, 469, 469, 469, 375, 469, 377, 469, 469, - /* 2620 */ 469, 469, 469, 469, 469, 469, 469, 406, 469, 469, - /* 2630 */ 331, 410, 469, 469, 413, 414, 415, 416, 417, 418, - /* 2640 */ 469, 420, 469, 469, 469, 469, 406, 469, 469, 331, - /* 2650 */ 410, 469, 469, 413, 414, 415, 416, 417, 418, 469, - /* 2660 */ 420, 362, 469, 469, 469, 469, 469, 469, 469, 370, - /* 2670 */ 469, 469, 469, 469, 375, 469, 377, 469, 469, 469, - /* 2680 */ 362, 469, 469, 469, 469, 469, 469, 469, 370, 469, - /* 2690 */ 469, 469, 469, 375, 469, 377, 469, 469, 331, 469, - /* 2700 */ 469, 469, 469, 469, 469, 406, 469, 469, 469, 410, - /* 2710 */ 469, 469, 413, 414, 415, 416, 417, 418, 469, 420, - /* 2720 */ 469, 469, 469, 469, 406, 469, 469, 469, 410, 362, - /* 2730 */ 469, 413, 414, 415, 416, 417, 418, 370, 420, 469, - /* 2740 */ 469, 469, 375, 469, 377, 469, 469, 331, 469, 469, + /* 950 */ 155, 156, 19, 158, 159, 160, 18, 355, 364, 165, + /* 960 */ 358, 23, 166, 167, 63, 362, 33, 171, 331, 375, + /* 970 */ 174, 339, 424, 370, 426, 37, 38, 394, 375, 41, + /* 980 */ 377, 48, 370, 331, 354, 353, 190, 54, 55, 56, + /* 990 */ 57, 58, 362, 381, 339, 0, 3, 59, 60, 61, + /* 1000 */ 62, 371, 370, 409, 410, 411, 331, 331, 353, 406, + /* 1010 */ 127, 39, 375, 410, 420, 4, 413, 414, 415, 416, + /* 1020 */ 417, 418, 439, 420, 339, 370, 443, 375, 95, 165, + /* 1030 */ 427, 98, 362, 0, 96, 432, 44, 362, 353, 369, + /* 1040 */ 339, 458, 459, 339, 339, 370, 463, 464, 378, 339, + /* 1050 */ 375, 375, 377, 331, 353, 370, 339, 353, 353, 1, + /* 1060 */ 2, 8, 9, 353, 131, 12, 13, 14, 15, 16, + /* 1070 */ 353, 370, 108, 135, 370, 370, 193, 194, 331, 363, + /* 1080 */ 370, 406, 424, 331, 426, 410, 44, 370, 413, 414, + /* 1090 */ 415, 416, 417, 418, 130, 420, 63, 375, 399, 166, + /* 1100 */ 425, 370, 427, 332, 171, 331, 431, 432, 331, 362, + /* 1110 */ 331, 350, 381, 352, 176, 177, 178, 370, 44, 181, + /* 1120 */ 445, 188, 375, 190, 377, 8, 9, 375, 453, 12, + /* 1130 */ 13, 14, 15, 16, 45, 46, 331, 199, 331, 331, + /* 1140 */ 202, 58, 204, 205, 206, 207, 208, 152, 100, 375, + /* 1150 */ 97, 103, 375, 406, 375, 97, 161, 410, 331, 331, + /* 1160 */ 413, 414, 415, 416, 417, 418, 331, 420, 331, 362, + /* 1170 */ 423, 97, 425, 426, 427, 245, 246, 370, 431, 432, + /* 1180 */ 375, 98, 375, 375, 377, 247, 370, 8, 9, 0, + /* 1190 */ 44, 12, 13, 14, 15, 16, 22, 381, 331, 42, + /* 1200 */ 64, 44, 375, 375, 42, 100, 44, 351, 103, 35, + /* 1210 */ 375, 100, 375, 406, 103, 44, 44, 410, 246, 364, + /* 1220 */ 413, 414, 415, 416, 417, 418, 44, 420, 100, 362, + /* 1230 */ 375, 103, 425, 35, 427, 0, 0, 370, 431, 432, + /* 1240 */ 133, 134, 375, 97, 377, 0, 47, 331, 8, 9, + /* 1250 */ 44, 44, 12, 13, 14, 15, 16, 22, 22, 248, + /* 1260 */ 453, 268, 270, 385, 409, 410, 411, 22, 97, 97, + /* 1270 */ 44, 44, 44, 406, 44, 420, 35, 410, 362, 97, + /* 1280 */ 413, 414, 415, 416, 417, 418, 370, 420, 1, 2, + /* 1290 */ 0, 375, 425, 377, 427, 96, 44, 108, 431, 432, + /* 1300 */ 467, 44, 44, 97, 97, 456, 44, 331, 341, 442, + /* 1310 */ 44, 44, 44, 13, 272, 44, 127, 128, 129, 130, + /* 1320 */ 131, 132, 406, 97, 97, 97, 410, 97, 13, 413, + /* 1330 */ 414, 415, 416, 417, 418, 35, 420, 35, 362, 49, + /* 1340 */ 450, 425, 362, 427, 165, 209, 370, 431, 432, 97, + /* 1350 */ 35, 375, 338, 377, 97, 97, 341, 374, 442, 97, + /* 1360 */ 385, 441, 385, 97, 97, 97, 331, 460, 97, 433, + /* 1370 */ 444, 249, 48, 71, 408, 407, 182, 396, 42, 382, + /* 1380 */ 20, 385, 406, 382, 186, 162, 410, 380, 20, 413, + /* 1390 */ 414, 415, 416, 417, 418, 339, 420, 362, 339, 382, + /* 1400 */ 380, 425, 380, 427, 339, 370, 94, 431, 432, 347, + /* 1410 */ 375, 339, 377, 333, 339, 339, 176, 20, 442, 333, + /* 1420 */ 20, 20, 401, 345, 377, 331, 345, 186, 20, 20, + /* 1430 */ 340, 395, 345, 340, 52, 339, 345, 345, 375, 333, + /* 1440 */ 345, 406, 345, 342, 342, 410, 362, 362, 413, 414, + /* 1450 */ 415, 416, 417, 418, 339, 420, 362, 333, 198, 405, + /* 1460 */ 425, 362, 427, 375, 370, 362, 431, 432, 96, 375, + /* 1470 */ 362, 377, 362, 403, 362, 362, 362, 442, 362, 400, + /* 1480 */ 362, 343, 12, 13, 343, 331, 189, 339, 257, 385, + /* 1490 */ 449, 452, 22, 256, 385, 375, 377, 265, 375, 401, + /* 1500 */ 406, 449, 375, 33, 410, 35, 375, 413, 414, 415, + /* 1510 */ 416, 417, 418, 273, 420, 390, 362, 331, 175, 425, + /* 1520 */ 390, 427, 451, 267, 370, 431, 432, 266, 58, 375, + /* 1530 */ 448, 377, 250, 274, 468, 271, 442, 246, 269, 462, + /* 1540 */ 408, 71, 20, 370, 339, 331, 412, 343, 362, 449, + /* 1550 */ 340, 343, 20, 388, 390, 375, 370, 390, 375, 375, + /* 1560 */ 406, 375, 375, 377, 410, 375, 375, 413, 414, 415, + /* 1570 */ 416, 417, 418, 447, 420, 446, 362, 167, 358, 425, + /* 1580 */ 387, 427, 461, 370, 370, 431, 432, 343, 118, 375, + /* 1590 */ 343, 377, 406, 96, 96, 366, 410, 375, 430, 413, + /* 1600 */ 414, 415, 416, 417, 418, 352, 420, 36, 343, 339, + /* 1610 */ 334, 425, 333, 427, 397, 391, 391, 431, 432, 356, + /* 1620 */ 406, 402, 344, 329, 410, 0, 331, 413, 414, 415, + /* 1630 */ 416, 417, 418, 356, 420, 0, 356, 0, 42, 425, + /* 1640 */ 0, 427, 35, 203, 35, 431, 432, 35, 35, 203, + /* 1650 */ 0, 35, 35, 203, 184, 0, 186, 362, 203, 0, + /* 1660 */ 0, 35, 0, 22, 35, 370, 191, 186, 184, 0, + /* 1670 */ 375, 0, 377, 0, 180, 331, 0, 0, 179, 209, + /* 1680 */ 210, 47, 0, 0, 0, 42, 0, 0, 0, 0, + /* 1690 */ 0, 0, 222, 223, 224, 225, 226, 227, 228, 0, + /* 1700 */ 0, 406, 152, 35, 0, 410, 362, 152, 413, 414, + /* 1710 */ 415, 416, 417, 418, 370, 420, 0, 0, 0, 375, + /* 1720 */ 0, 377, 427, 0, 331, 0, 431, 432, 0, 0, + /* 1730 */ 0, 0, 0, 0, 0, 0, 0, 0, 42, 0, + /* 1740 */ 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, + /* 1750 */ 406, 136, 0, 0, 410, 362, 58, 413, 414, 415, + /* 1760 */ 416, 417, 418, 370, 420, 0, 58, 0, 375, 58, + /* 1770 */ 377, 427, 0, 331, 0, 431, 432, 14, 14, 0, + /* 1780 */ 42, 35, 0, 0, 0, 175, 0, 0, 0, 39, + /* 1790 */ 0, 65, 331, 0, 0, 44, 40, 35, 39, 406, + /* 1800 */ 39, 47, 47, 410, 362, 47, 413, 414, 415, 416, + /* 1810 */ 417, 418, 370, 420, 48, 39, 35, 375, 48, 377, + /* 1820 */ 427, 0, 0, 362, 431, 432, 48, 35, 367, 0, + /* 1830 */ 39, 370, 35, 48, 39, 39, 375, 0, 377, 0, + /* 1840 */ 0, 331, 35, 0, 35, 22, 35, 35, 406, 35, + /* 1850 */ 44, 35, 410, 35, 44, 413, 414, 415, 416, 417, + /* 1860 */ 418, 331, 420, 22, 0, 105, 35, 406, 22, 0, + /* 1870 */ 22, 410, 362, 0, 413, 414, 415, 416, 417, 418, + /* 1880 */ 370, 420, 22, 103, 50, 375, 35, 377, 0, 35, + /* 1890 */ 0, 35, 362, 0, 22, 20, 35, 367, 35, 196, + /* 1900 */ 370, 97, 0, 35, 96, 375, 0, 377, 466, 96, + /* 1910 */ 0, 22, 0, 96, 187, 44, 406, 251, 331, 255, + /* 1920 */ 410, 97, 165, 413, 414, 415, 416, 417, 418, 3, + /* 1930 */ 420, 96, 422, 165, 331, 230, 406, 3, 165, 97, + /* 1940 */ 410, 172, 167, 413, 414, 415, 416, 417, 418, 362, + /* 1950 */ 420, 44, 331, 44, 367, 97, 97, 370, 44, 44, + /* 1960 */ 47, 172, 375, 96, 377, 362, 96, 47, 44, 47, + /* 1970 */ 96, 173, 96, 370, 97, 97, 35, 35, 375, 35, + /* 1980 */ 377, 35, 35, 362, 35, 47, 0, 44, 97, 97, + /* 1990 */ 0, 370, 0, 406, 0, 96, 375, 410, 377, 39, + /* 2000 */ 413, 414, 415, 416, 417, 418, 47, 420, 97, 406, + /* 2010 */ 0, 331, 96, 410, 97, 96, 413, 414, 415, 416, + /* 2020 */ 417, 418, 245, 420, 96, 168, 96, 406, 331, 96, + /* 2030 */ 39, 410, 166, 106, 413, 414, 415, 416, 417, 418, + /* 2040 */ 47, 420, 362, 2, 44, 331, 22, 232, 96, 230, + /* 2050 */ 370, 251, 251, 209, 97, 375, 230, 377, 96, 362, + /* 2060 */ 97, 96, 47, 97, 96, 96, 47, 370, 97, 22, + /* 2070 */ 97, 96, 375, 35, 377, 35, 362, 107, 96, 35, + /* 2080 */ 97, 96, 22, 35, 370, 97, 406, 35, 35, 375, + /* 2090 */ 410, 377, 96, 413, 414, 415, 416, 417, 418, 97, + /* 2100 */ 420, 96, 331, 406, 97, 211, 44, 410, 96, 120, + /* 2110 */ 413, 414, 415, 416, 417, 418, 108, 420, 120, 96, + /* 2120 */ 406, 120, 96, 120, 410, 35, 96, 413, 414, 415, + /* 2130 */ 416, 417, 418, 362, 420, 22, 331, 65, 64, 35, + /* 2140 */ 35, 370, 35, 35, 35, 35, 375, 35, 377, 35, + /* 2150 */ 35, 35, 71, 35, 93, 44, 35, 35, 22, 35, + /* 2160 */ 35, 35, 71, 331, 35, 35, 35, 362, 35, 35, + /* 2170 */ 22, 0, 35, 35, 39, 370, 48, 406, 0, 35, + /* 2180 */ 375, 410, 377, 0, 413, 414, 415, 416, 417, 418, + /* 2190 */ 48, 420, 39, 331, 362, 35, 39, 0, 48, 35, + /* 2200 */ 48, 39, 370, 0, 35, 35, 0, 375, 22, 377, + /* 2210 */ 21, 406, 331, 22, 22, 410, 21, 469, 413, 414, + /* 2220 */ 415, 416, 417, 418, 362, 420, 469, 20, 469, 469, + /* 2230 */ 469, 469, 370, 469, 469, 469, 469, 375, 406, 377, + /* 2240 */ 469, 469, 410, 362, 469, 413, 414, 415, 416, 417, + /* 2250 */ 418, 370, 420, 469, 469, 469, 375, 469, 377, 469, + /* 2260 */ 469, 469, 469, 469, 469, 469, 469, 469, 406, 469, + /* 2270 */ 469, 469, 410, 469, 469, 413, 414, 415, 416, 417, + /* 2280 */ 418, 331, 420, 469, 469, 469, 469, 406, 469, 469, + /* 2290 */ 469, 410, 469, 469, 413, 414, 415, 416, 417, 418, + /* 2300 */ 469, 420, 469, 469, 469, 331, 469, 469, 469, 469, + /* 2310 */ 469, 469, 362, 469, 469, 469, 469, 469, 469, 469, + /* 2320 */ 370, 469, 469, 469, 469, 375, 469, 377, 469, 469, + /* 2330 */ 331, 469, 469, 469, 469, 469, 362, 469, 469, 469, + /* 2340 */ 469, 469, 469, 469, 370, 469, 469, 469, 469, 375, + /* 2350 */ 469, 377, 469, 469, 469, 469, 406, 469, 469, 469, + /* 2360 */ 410, 362, 469, 413, 414, 415, 416, 417, 418, 370, + /* 2370 */ 420, 469, 469, 469, 375, 469, 377, 469, 469, 469, + /* 2380 */ 406, 469, 469, 469, 410, 469, 469, 413, 414, 415, + /* 2390 */ 416, 417, 418, 469, 420, 469, 469, 469, 469, 331, + /* 2400 */ 469, 469, 469, 469, 469, 406, 469, 469, 469, 410, + /* 2410 */ 469, 469, 413, 414, 415, 416, 417, 418, 331, 420, + /* 2420 */ 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + /* 2430 */ 362, 469, 469, 469, 469, 469, 469, 469, 370, 469, + /* 2440 */ 469, 469, 469, 375, 469, 377, 469, 469, 469, 362, + /* 2450 */ 469, 469, 469, 469, 469, 469, 469, 370, 469, 469, + /* 2460 */ 469, 469, 375, 469, 377, 469, 469, 469, 469, 469, + /* 2470 */ 469, 469, 469, 469, 406, 469, 469, 469, 410, 469, + /* 2480 */ 331, 413, 414, 415, 416, 417, 418, 469, 420, 469, + /* 2490 */ 469, 469, 469, 406, 469, 469, 469, 410, 469, 331, + /* 2500 */ 413, 414, 415, 416, 417, 418, 469, 420, 469, 469, + /* 2510 */ 469, 362, 469, 469, 469, 469, 469, 469, 469, 370, + /* 2520 */ 469, 469, 469, 469, 375, 469, 377, 469, 469, 469, + /* 2530 */ 362, 469, 469, 469, 469, 469, 469, 469, 370, 469, + /* 2540 */ 469, 469, 469, 375, 469, 377, 469, 469, 469, 469, + /* 2550 */ 469, 469, 469, 469, 469, 406, 331, 469, 469, 410, + /* 2560 */ 469, 469, 413, 414, 415, 416, 417, 418, 469, 420, + /* 2570 */ 469, 469, 469, 469, 406, 331, 469, 469, 410, 469, + /* 2580 */ 469, 413, 414, 415, 416, 417, 418, 362, 420, 469, + /* 2590 */ 469, 469, 469, 469, 469, 370, 469, 469, 469, 469, + /* 2600 */ 375, 469, 377, 469, 469, 469, 362, 469, 469, 469, + /* 2610 */ 469, 469, 469, 469, 370, 469, 469, 469, 469, 375, + /* 2620 */ 469, 377, 469, 469, 469, 469, 469, 469, 469, 469, + /* 2630 */ 469, 406, 469, 469, 469, 410, 469, 331, 413, 414, + /* 2640 */ 415, 416, 417, 418, 469, 420, 469, 469, 469, 469, + /* 2650 */ 406, 469, 469, 469, 410, 469, 469, 413, 414, 415, + /* 2660 */ 416, 417, 418, 469, 420, 469, 469, 469, 362, 469, + /* 2670 */ 469, 469, 469, 469, 469, 469, 370, 469, 469, 469, + /* 2680 */ 469, 375, 469, 377, 469, 469, 469, 469, 469, 469, + /* 2690 */ 469, 469, 469, 469, 469, 469, 331, 469, 469, 469, + /* 2700 */ 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, + /* 2710 */ 469, 469, 406, 469, 469, 469, 410, 469, 469, 413, + /* 2720 */ 414, 415, 416, 417, 418, 469, 420, 362, 469, 469, + /* 2730 */ 469, 469, 469, 469, 469, 370, 469, 469, 469, 469, + /* 2740 */ 375, 469, 377, 469, 469, 331, 469, 469, 469, 469, /* 2750 */ 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, /* 2760 */ 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, - /* 2770 */ 469, 469, 469, 406, 469, 469, 469, 410, 362, 469, - /* 2780 */ 413, 414, 415, 416, 417, 418, 370, 420, 469, 469, - /* 2790 */ 469, 375, 469, 377, 469, 469, 469, 469, 469, 469, + /* 2770 */ 469, 406, 469, 469, 469, 410, 362, 469, 413, 414, + /* 2780 */ 415, 416, 417, 418, 370, 420, 469, 469, 469, 375, + /* 2790 */ 469, 377, 469, 469, 469, 469, 469, 469, 469, 469, /* 2800 */ 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, /* 2810 */ 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, - /* 2820 */ 469, 469, 406, 469, 469, 469, 410, 469, 469, 413, - /* 2830 */ 414, 415, 416, 417, 418, 469, 420, + /* 2820 */ 406, 469, 469, 469, 410, 469, 469, 413, 414, 415, + /* 2830 */ 416, 417, 418, 469, 420, }; -#define YY_SHIFT_COUNT (736) +#define YY_SHIFT_COUNT (739) #define YY_SHIFT_MIN (0) -#define YY_SHIFT_MAX (2175) +#define YY_SHIFT_MAX (2207) static const unsigned short int yy_shift_ofst[] = { - /* 0 */ 865, 0, 71, 0, 290, 290, 290, 290, 290, 290, - /* 10 */ 290, 290, 290, 290, 290, 361, 578, 578, 649, 578, - /* 20 */ 578, 578, 578, 578, 578, 578, 578, 578, 578, 578, - /* 30 */ 578, 578, 578, 578, 578, 578, 578, 578, 578, 578, - /* 40 */ 578, 578, 578, 578, 578, 578, 578, 578, 450, 530, - /* 50 */ 254, 506, 70, 101, 141, 101, 506, 506, 1348, 1348, - /* 60 */ 1348, 101, 1348, 1348, 395, 101, 69, 258, 123, 123, - /* 70 */ 258, 186, 186, 380, 172, 1, 1, 123, 123, 123, - /* 80 */ 123, 123, 123, 123, 210, 123, 123, 173, 69, 123, - /* 90 */ 123, 246, 123, 69, 123, 210, 123, 210, 69, 123, - /* 100 */ 123, 69, 123, 69, 69, 69, 123, 257, 795, 34, - /* 110 */ 34, 217, 826, 1353, 1353, 1353, 1353, 1353, 1353, 1353, - /* 120 */ 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, 1353, - /* 130 */ 1353, 1353, 152, 516, 380, 172, 135, 587, 644, 644, - /* 140 */ 644, 675, 330, 330, 587, 326, 326, 326, 308, 396, - /* 150 */ 69, 695, 69, 695, 695, 627, 827, 36, 36, 36, - /* 160 */ 36, 36, 36, 36, 36, 1811, 313, 474, 615, 249, - /* 170 */ 798, 341, 213, 159, 508, 900, 836, 839, 610, 977, - /* 180 */ 759, 91, 1026, 759, 1023, 851, 987, 1090, 1298, 1182, - /* 190 */ 1323, 1352, 1323, 1221, 1369, 1369, 1323, 1221, 1221, 1303, - /* 200 */ 1369, 1369, 1369, 1387, 1387, 1390, 173, 1391, 173, 1400, - /* 210 */ 1402, 173, 1400, 173, 173, 173, 1369, 173, 1383, 1383, - /* 220 */ 1387, 69, 69, 69, 69, 69, 69, 69, 69, 69, - /* 230 */ 69, 69, 1369, 1387, 695, 695, 1229, 1385, 1390, 257, - /* 240 */ 1300, 1391, 257, 1369, 1352, 1352, 695, 1243, 1251, 695, - /* 250 */ 1243, 1251, 695, 695, 69, 1261, 1354, 1243, 1264, 1262, - /* 260 */ 1277, 1090, 1267, 1265, 1274, 1299, 326, 1543, 1369, 1400, - /* 270 */ 257, 257, 1564, 1251, 695, 695, 695, 695, 695, 1251, - /* 280 */ 695, 1421, 257, 627, 257, 326, 1507, 1508, 695, 827, - /* 290 */ 1369, 257, 1573, 1387, 2837, 2837, 2837, 2837, 2837, 2837, - /* 300 */ 2837, 2837, 2837, 890, 274, 457, 331, 631, 976, 1000, - /* 310 */ 525, 1009, 1113, 1213, 709, 838, 838, 838, 838, 838, - /* 320 */ 838, 838, 838, 838, 1016, 239, 86, 86, 539, 460, - /* 330 */ 4, 621, 741, 557, 599, 599, 769, 553, 505, 769, - /* 340 */ 769, 769, 443, 1018, 785, 1041, 772, 899, 1008, 1014, - /* 350 */ 1031, 1086, 1109, 1161, 999, 1038, 1093, 1121, 1140, 1142, - /* 360 */ 775, 1058, 1010, 609, 1163, 1165, 1167, 1174, 1176, 1180, - /* 370 */ 1134, 1244, 1118, 1173, 725, 1246, 650, 1248, 1253, 1260, - /* 380 */ 1271, 1288, 1289, 1108, 1256, 1313, 779, 1331, 1618, 1632, - /* 390 */ 1639, 1598, 1642, 1609, 1443, 1611, 1612, 1614, 1448, 1651, - /* 400 */ 1617, 1619, 1451, 1655, 1455, 1658, 1624, 1660, 1640, 1664, - /* 410 */ 1630, 1476, 1482, 1485, 1669, 1670, 1671, 1494, 1496, 1675, - /* 420 */ 1685, 1631, 1687, 1688, 1689, 1648, 1691, 1707, 1709, 1710, - /* 430 */ 1711, 1712, 1714, 1715, 1544, 1659, 1719, 1569, 1722, 1724, - /* 440 */ 1725, 1726, 1727, 1728, 1729, 1730, 1731, 1732, 1733, 1734, - /* 450 */ 1735, 1737, 1738, 1739, 1698, 1741, 1742, 1743, 1745, 1746, - /* 460 */ 1747, 1736, 1748, 1750, 1753, 1620, 1754, 1757, 1740, 1765, - /* 470 */ 1716, 1767, 1718, 1768, 1769, 1744, 1758, 1749, 1723, 1763, - /* 480 */ 1751, 1771, 1752, 1779, 1756, 1761, 1781, 1782, 1783, 1762, - /* 490 */ 1634, 1803, 1804, 1805, 1708, 1806, 1809, 1776, 1764, 1774, - /* 500 */ 1814, 1784, 1770, 1777, 1820, 1786, 1775, 1785, 1822, 1790, - /* 510 */ 1780, 1793, 1827, 1829, 1833, 1835, 1760, 1759, 1801, 1815, - /* 520 */ 1838, 1807, 1808, 1810, 1812, 1796, 1818, 1813, 1816, 1830, - /* 530 */ 1836, 1849, 1850, 1873, 1853, 1826, 1885, 1865, 1854, 1888, - /* 540 */ 1855, 1891, 1857, 1893, 1874, 1875, 1862, 1863, 1705, 1817, - /* 550 */ 1821, 1901, 1766, 1823, 1868, 1904, 1720, 1889, 1773, 1755, - /* 560 */ 1910, 1912, 1787, 1789, 1914, 1871, 1673, 1825, 1828, 1831, - /* 570 */ 1792, 1696, 1800, 1674, 1837, 1887, 1890, 1839, 1841, 1844, - /* 580 */ 1848, 1858, 1896, 1906, 1908, 1861, 1913, 1682, 1877, 1878, - /* 590 */ 1956, 1920, 1791, 1943, 1944, 1945, 1947, 1949, 1950, 1881, - /* 600 */ 1897, 1939, 1778, 1948, 1940, 1989, 1994, 1995, 1996, 1902, - /* 610 */ 1962, 1723, 1955, 1915, 1907, 1909, 1916, 1917, 1840, 1918, - /* 620 */ 2008, 1975, 1851, 1922, 1919, 1723, 1968, 1974, 1832, 1819, - /* 630 */ 1834, 2018, 1999, 1824, 1941, 1938, 1957, 1958, 1963, 1961, - /* 640 */ 1990, 1964, 1965, 2004, 1966, 2016, 1856, 1970, 1967, 1971, - /* 650 */ 2033, 2035, 1977, 1978, 2041, 1980, 1981, 2043, 1984, 1985, - /* 660 */ 2045, 1987, 1993, 2048, 1992, 1982, 1983, 1986, 1997, 2063, - /* 670 */ 1979, 2002, 2046, 2011, 2064, 2020, 2046, 2046, 2091, 2053, - /* 680 */ 2055, 2085, 2086, 2087, 2088, 2089, 2090, 2092, 2093, 2094, - /* 690 */ 2095, 2061, 2034, 2096, 2097, 2098, 2100, 2114, 2102, 2103, - /* 700 */ 2104, 2071, 1796, 2108, 1818, 2109, 2110, 2111, 2113, 2129, - /* 710 */ 2117, 2153, 2119, 2107, 2118, 2156, 2124, 2112, 2122, 2162, - /* 720 */ 2131, 2116, 2128, 2168, 2134, 2123, 2133, 2170, 2138, 2139, - /* 730 */ 2175, 2155, 2158, 2159, 2161, 2163, 2160, + /* 0 */ 938, 0, 72, 0, 292, 292, 292, 292, 292, 292, + /* 10 */ 292, 292, 292, 292, 292, 364, 582, 582, 654, 582, + /* 20 */ 582, 582, 582, 582, 582, 582, 582, 582, 582, 582, + /* 30 */ 582, 582, 582, 582, 582, 582, 582, 582, 582, 582, + /* 40 */ 582, 582, 582, 582, 582, 582, 582, 582, 115, 136, + /* 50 */ 526, 439, 33, 71, 565, 71, 439, 439, 1470, 1470, + /* 60 */ 1470, 71, 1470, 1470, 6, 71, 95, 438, 112, 112, + /* 70 */ 438, 378, 378, 217, 97, 523, 523, 112, 112, 112, + /* 80 */ 112, 112, 112, 112, 154, 112, 112, 135, 95, 112, + /* 90 */ 112, 296, 112, 95, 112, 154, 112, 154, 95, 112, + /* 100 */ 112, 95, 112, 95, 95, 95, 112, 346, 795, 34, + /* 110 */ 34, 219, 690, 575, 575, 575, 575, 575, 575, 575, + /* 120 */ 575, 575, 575, 575, 575, 575, 575, 575, 575, 575, + /* 130 */ 575, 575, 218, 519, 217, 97, 901, 331, 598, 598, + /* 140 */ 598, 1033, 466, 466, 331, 410, 410, 410, 419, 326, + /* 150 */ 95, 496, 95, 496, 496, 532, 620, 36, 36, 36, + /* 160 */ 36, 36, 36, 36, 36, 933, 315, 457, 471, 1240, + /* 170 */ 187, 18, 211, 25, 461, 232, 794, 1089, 964, 864, + /* 180 */ 930, 972, 993, 930, 1157, 1011, 70, 1122, 1324, 1194, + /* 190 */ 1336, 1360, 1336, 1223, 1368, 1368, 1336, 1223, 1223, 1368, + /* 200 */ 1312, 1368, 1368, 1368, 1397, 1397, 1400, 135, 1401, 135, + /* 210 */ 1408, 1409, 135, 1408, 135, 135, 135, 1368, 135, 1382, + /* 220 */ 1382, 1397, 95, 95, 95, 95, 95, 95, 95, 95, + /* 230 */ 95, 95, 95, 1368, 1397, 496, 496, 1260, 1372, 1400, + /* 240 */ 346, 1297, 1401, 346, 1368, 1360, 1360, 496, 1231, 1237, + /* 250 */ 496, 1231, 1237, 496, 496, 95, 1232, 1343, 1231, 1256, + /* 260 */ 1261, 1282, 1122, 1259, 1264, 1269, 1291, 410, 1522, 1368, + /* 270 */ 1408, 346, 346, 1532, 1237, 496, 496, 496, 496, 496, + /* 280 */ 1237, 496, 1410, 346, 532, 346, 410, 1497, 1498, 496, + /* 290 */ 620, 1368, 346, 1571, 1397, 2835, 2835, 2835, 2835, 2835, + /* 300 */ 2835, 2835, 2835, 2835, 839, 796, 442, 691, 47, 818, + /* 310 */ 1053, 503, 15, 884, 1179, 1189, 1117, 1117, 1117, 1117, + /* 320 */ 1117, 1117, 1117, 1117, 1117, 728, 586, 294, 294, 516, + /* 330 */ 480, 995, 695, 456, 883, 237, 237, 479, 1058, 77, + /* 340 */ 479, 479, 479, 707, 357, 1174, 1162, 499, 1048, 1105, + /* 350 */ 1111, 1128, 1235, 1236, 1245, 1074, 1146, 1083, 1171, 1172, + /* 360 */ 1182, 1107, 992, 1042, 738, 1206, 1207, 1226, 1227, 1228, + /* 370 */ 1230, 1287, 1252, 1198, 1241, 1136, 1257, 1199, 1258, 1262, + /* 380 */ 1266, 1267, 1268, 1271, 338, 1300, 1315, 1302, 1290, 1625, + /* 390 */ 1635, 1637, 1596, 1640, 1607, 1440, 1609, 1612, 1613, 1446, + /* 400 */ 1650, 1616, 1617, 1450, 1655, 1455, 1659, 1626, 1660, 1641, + /* 410 */ 1662, 1629, 1475, 1481, 1484, 1669, 1671, 1673, 1494, 1499, + /* 420 */ 1676, 1677, 1634, 1682, 1683, 1684, 1643, 1686, 1687, 1688, + /* 430 */ 1689, 1690, 1691, 1699, 1700, 1550, 1668, 1704, 1555, 1716, + /* 440 */ 1717, 1718, 1720, 1723, 1725, 1728, 1729, 1730, 1731, 1732, + /* 450 */ 1733, 1734, 1735, 1736, 1737, 1696, 1739, 1740, 1741, 1742, + /* 460 */ 1743, 1744, 1724, 1745, 1747, 1748, 1615, 1749, 1752, 1753, + /* 470 */ 1698, 1746, 1765, 1708, 1767, 1711, 1772, 1774, 1738, 1750, + /* 480 */ 1751, 1754, 1763, 1755, 1764, 1758, 1779, 1756, 1759, 1782, + /* 490 */ 1783, 1784, 1761, 1610, 1786, 1787, 1788, 1726, 1790, 1793, + /* 500 */ 1762, 1766, 1776, 1794, 1781, 1770, 1791, 1821, 1792, 1778, + /* 510 */ 1795, 1822, 1797, 1785, 1796, 1829, 1837, 1839, 1840, 1760, + /* 520 */ 1780, 1807, 1823, 1843, 1809, 1811, 1812, 1814, 1806, 1810, + /* 530 */ 1816, 1818, 1841, 1831, 1864, 1846, 1869, 1848, 1834, 1873, + /* 540 */ 1860, 1851, 1888, 1854, 1890, 1856, 1893, 1872, 1875, 1861, + /* 550 */ 1863, 1703, 1804, 1808, 1902, 1757, 1813, 1868, 1906, 1727, + /* 560 */ 1889, 1768, 1775, 1910, 1912, 1773, 1798, 1926, 1871, 1666, + /* 570 */ 1817, 1824, 1835, 1769, 1705, 1789, 1664, 1842, 1907, 1909, + /* 580 */ 1858, 1867, 1870, 1874, 1859, 1914, 1913, 1920, 1876, 1915, + /* 590 */ 1800, 1877, 1878, 1934, 1924, 1801, 1941, 1942, 1944, 1946, + /* 600 */ 1947, 1949, 1891, 1892, 1922, 1777, 1943, 1938, 1986, 1990, + /* 610 */ 1992, 1994, 1899, 1960, 1754, 1959, 1916, 1911, 1917, 1919, + /* 620 */ 1928, 1857, 1930, 2010, 1991, 1866, 1933, 1927, 1754, 1993, + /* 630 */ 2000, 1819, 1815, 1826, 2041, 2024, 1844, 1952, 1957, 1962, + /* 640 */ 1963, 1965, 1966, 2015, 1968, 1969, 2019, 1971, 2047, 1894, + /* 650 */ 1975, 1970, 1973, 2038, 2040, 1982, 1983, 2044, 1985, 1988, + /* 660 */ 2048, 1996, 2002, 2052, 2005, 2007, 2053, 2012, 1989, 1998, + /* 670 */ 2001, 2003, 2060, 2008, 2023, 2062, 2026, 2090, 2030, 2062, + /* 680 */ 2062, 2113, 2072, 2074, 2104, 2105, 2107, 2108, 2109, 2110, + /* 690 */ 2112, 2114, 2115, 2116, 2081, 2061, 2111, 2118, 2121, 2122, + /* 700 */ 2136, 2124, 2125, 2126, 2091, 1806, 2129, 1810, 2130, 2131, + /* 710 */ 2133, 2134, 2148, 2137, 2171, 2138, 2128, 2135, 2178, 2144, + /* 720 */ 2142, 2153, 2183, 2160, 2150, 2157, 2197, 2164, 2152, 2162, + /* 730 */ 2203, 2169, 2170, 2206, 2186, 2189, 2191, 2192, 2195, 2207, }; -#define YY_REDUCE_COUNT (302) -#define YY_REDUCE_MIN (-434) -#define YY_REDUCE_MAX (2416) +#define YY_REDUCE_COUNT (303) +#define YY_REDUCE_MIN (-415) +#define YY_REDUCE_MAX (2414) static const short yy_reduce_ofst[] = { - /* 0 */ 589, 189, 674, 742, 762, 835, 869, 903, 937, 1042, - /* 10 */ 1069, 1133, 1206, 1266, 1286, -295, -5, 288, 1346, 354, - /* 20 */ 1374, 1101, 1440, 1464, 1532, 1552, 1613, 1629, 1678, 1694, - /* 30 */ 1772, 1788, 1845, 1864, 1923, 1942, 1991, 2040, 2056, 2072, - /* 40 */ 2148, 2164, 2221, 2240, 2299, 2318, 2367, 2416, -265, -351, - /* 50 */ 293, 98, -387, -257, -61, 935, -19, 157, -356, -324, - /* 60 */ 303, -434, -341, -233, -402, 229, -54, -361, 102, 107, - /* 70 */ -333, -335, 17, -345, -237, 140, 350, 471, 541, 542, - /* 80 */ 543, 657, 711, 801, -30, 811, 846, -108, -178, 849, - /* 90 */ 853, -56, 862, -51, 894, 109, 901, 222, -281, 904, - /* 100 */ 969, 26, 389, 15, 187, 80, 971, 378, -313, -319, - /* 110 */ -319, -216, -141, -330, 31, 240, 306, 403, 511, 548, - /* 120 */ 651, 655, 662, 663, 664, 671, 700, 702, 703, 704, - /* 130 */ 743, 745, -296, -45, 169, -196, 124, 219, -45, 33, - /* 140 */ 262, 89, 296, 397, 478, 449, 463, 517, 501, 332, - /* 150 */ -268, 544, 255, 546, 555, 574, 479, -357, -353, 551, - /* 160 */ 656, 740, 800, 807, 740, 739, 859, 845, 813, 747, - /* 170 */ 774, 896, 792, 873, 873, 915, 910, 920, 924, 917, - /* 180 */ 864, 864, 876, 864, 892, 893, 873, 898, 952, 970, - /* 190 */ 989, 991, 1004, 1007, 1051, 1052, 1013, 1012, 1017, 1054, - /* 200 */ 1063, 1064, 1066, 1075, 1076, 1015, 1068, 1037, 1070, 1081, - /* 210 */ 1029, 1080, 1087, 1083, 1084, 1085, 1094, 1089, 1095, 1096, - /* 220 */ 1103, 1078, 1079, 1088, 1091, 1092, 1099, 1104, 1106, 1110, - /* 230 */ 1115, 1119, 1112, 1114, 1067, 1074, 1040, 1102, 1097, 1100, - /* 240 */ 1120, 1116, 1147, 1152, 1107, 1117, 1122, 1055, 1123, 1137, - /* 250 */ 1060, 1132, 1148, 1149, 873, 1077, 1126, 1105, 1111, 1098, - /* 260 */ 1136, 1124, 1073, 1072, 1125, 864, 1185, 1154, 1239, 1212, - /* 270 */ 1236, 1237, 1197, 1198, 1214, 1215, 1216, 1217, 1218, 1204, - /* 280 */ 1220, 1209, 1255, 1241, 1257, 1231, 1175, 1238, 1232, 1254, - /* 290 */ 1269, 1268, 1276, 1280, 1228, 1225, 1223, 1224, 1273, 1275, - /* 300 */ 1278, 1291, 1301, + /* 0 */ -256, 675, 747, 807, 867, 916, 976, 1035, 1094, 1154, + /* 10 */ 1186, 1214, 1295, 1344, 1393, -294, -2, 23, 603, 288, + /* 20 */ 313, 1442, 1461, 1510, 1530, 1587, 1603, 1621, 1680, 1697, + /* 30 */ 1714, 1771, 1805, 1832, 1862, 1881, 1950, 1974, 1999, 2068, + /* 40 */ 2087, 2149, 2168, 2225, 2244, 2306, 2365, 2414, -264, 184, + /* 50 */ 162, -173, -350, 106, 278, 583, -336, -105, -323, 594, + /* 60 */ 855, -106, -343, -3, -72, -69, -353, -212, -334, 191, + /* 70 */ -282, -331, -146, -305, -303, -199, 92, -288, -15, 50, + /* 80 */ 259, 275, 298, 299, -37, 343, 401, 195, 190, 409, + /* 90 */ 632, -177, 655, 295, 685, 274, 701, 332, 204, 704, + /* 100 */ 705, 398, 710, 533, 670, 630, 717, 62, 270, -169, + /* 110 */ -169, -330, -23, 224, 310, 407, 490, 510, 637, 652, + /* 120 */ 676, 722, 752, 774, 777, 779, 805, 808, 827, 828, + /* 130 */ 835, 837, 318, -358, -180, 443, -167, 498, -358, 404, + /* 140 */ 423, -86, 548, 658, 540, 612, 731, 816, -45, -415, + /* 150 */ 167, 124, 308, 228, 360, 602, 761, -348, 359, 384, + /* 160 */ 474, 486, 570, 716, 486, 699, 771, 856, 878, 833, + /* 170 */ 849, 967, 890, 980, 980, 1015, 975, 1014, 983, 977, + /* 180 */ 920, 920, 907, 920, 936, 926, 980, 966, 968, 981, + /* 190 */ 997, 996, 1001, 1007, 1056, 1059, 1017, 1020, 1022, 1065, + /* 200 */ 1062, 1072, 1075, 1076, 1080, 1086, 1021, 1078, 1047, 1081, + /* 210 */ 1090, 1036, 1087, 1093, 1091, 1092, 1095, 1096, 1097, 1101, + /* 220 */ 1102, 1106, 1084, 1085, 1099, 1103, 1108, 1110, 1112, 1113, + /* 230 */ 1114, 1116, 1118, 1115, 1124, 1063, 1088, 1054, 1070, 1098, + /* 240 */ 1138, 1079, 1119, 1141, 1148, 1104, 1109, 1120, 1041, 1125, + /* 250 */ 1123, 1052, 1130, 1127, 1131, 980, 1039, 1071, 1100, 1082, + /* 260 */ 1126, 1129, 1132, 1066, 1077, 1121, 920, 1173, 1134, 1205, + /* 270 */ 1210, 1204, 1208, 1165, 1164, 1180, 1183, 1184, 1187, 1190, + /* 280 */ 1167, 1191, 1193, 1244, 1220, 1247, 1213, 1168, 1229, 1222, + /* 290 */ 1253, 1270, 1265, 1276, 1279, 1217, 1219, 1224, 1225, 1263, + /* 300 */ 1277, 1280, 1278, 1294, }; static const YYACTIONTYPE yy_default[] = { - /* 0 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 10 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 20 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 30 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 40 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 50 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 60 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 70 */ 1654, 1654, 1654, 1911, 1654, 1654, 1654, 1654, 1654, 1654, - /* 80 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1732, 1654, 1654, - /* 90 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 100 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1730, 1904, 2118, - /* 110 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 120 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 130 */ 1654, 1654, 1654, 2130, 1654, 1654, 1732, 1654, 2130, 2130, - /* 140 */ 2130, 1730, 2090, 2090, 1654, 1654, 1654, 1654, 1965, 1654, - /* 150 */ 1654, 1654, 1654, 1654, 1654, 1839, 1654, 1654, 1654, 1654, - /* 160 */ 1654, 1863, 1654, 1654, 1654, 1957, 1654, 1654, 2155, 2211, - /* 170 */ 1654, 1654, 2158, 1654, 1654, 1654, 1916, 1654, 1792, 2145, - /* 180 */ 2122, 2136, 2195, 2123, 2120, 2139, 1654, 2149, 1654, 1950, - /* 190 */ 1909, 1654, 1909, 1906, 1654, 1654, 1909, 1906, 1906, 1783, - /* 200 */ 1654, 1654, 1654, 1654, 1654, 1654, 1732, 1654, 1732, 1654, - /* 210 */ 1654, 1732, 1654, 1732, 1732, 1732, 1654, 1732, 1711, 1711, - /* 220 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 230 */ 1654, 1654, 1654, 1654, 1654, 1654, 1975, 1963, 1654, 1730, - /* 240 */ 1959, 1654, 1730, 1654, 1654, 1654, 1654, 2166, 2164, 1654, - /* 250 */ 2166, 2164, 1654, 1654, 1654, 2180, 2176, 2166, 2184, 2182, - /* 260 */ 2151, 2149, 2214, 2201, 2197, 2136, 1654, 1654, 1654, 1654, - /* 270 */ 1730, 1730, 1654, 2164, 1654, 1654, 1654, 1654, 1654, 2164, - /* 280 */ 1654, 1654, 1730, 1654, 1730, 1654, 1654, 1808, 1654, 1654, - /* 290 */ 1654, 1730, 1686, 1654, 1952, 1968, 1934, 1934, 1842, 1842, - /* 300 */ 1842, 1733, 1659, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 310 */ 1654, 1654, 1654, 1654, 1654, 2179, 2178, 2045, 1654, 2094, - /* 320 */ 2093, 2092, 2083, 2044, 1804, 1654, 2043, 2042, 1654, 1654, - /* 330 */ 1654, 1654, 1654, 1654, 1925, 1924, 2036, 1654, 1654, 2037, - /* 340 */ 2035, 2034, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 350 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 360 */ 1654, 2198, 2202, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 370 */ 2119, 1654, 1654, 1654, 1654, 1654, 2018, 1654, 1654, 1654, - /* 380 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 390 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 400 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 410 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 420 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 430 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 440 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 450 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 460 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 470 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1691, 2023, 1654, - /* 480 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 490 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 500 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 510 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 520 */ 1654, 1654, 1654, 1654, 1654, 1771, 1770, 1654, 1654, 1654, - /* 530 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 540 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 2027, - /* 550 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 560 */ 1654, 1654, 1654, 1654, 2194, 2152, 1654, 1654, 1654, 1654, - /* 570 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 580 */ 1654, 1654, 1654, 1654, 2018, 1654, 2177, 1654, 1654, 2192, - /* 590 */ 1654, 2196, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 2129, - /* 600 */ 2125, 1654, 1654, 2121, 1654, 1654, 1654, 1654, 1654, 1654, - /* 610 */ 1654, 2026, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 620 */ 1654, 1654, 1654, 1654, 1654, 2017, 1654, 2080, 1654, 1654, - /* 630 */ 1654, 2114, 1654, 1654, 2065, 1654, 1654, 1654, 1654, 1654, - /* 640 */ 1654, 1654, 1654, 1654, 2027, 1654, 2030, 1654, 1654, 1654, - /* 650 */ 1654, 1654, 1836, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 660 */ 1654, 1654, 1654, 1654, 1654, 1821, 1819, 1818, 1817, 1654, - /* 670 */ 1814, 1654, 1849, 1654, 1654, 1654, 1845, 1844, 1654, 1654, - /* 680 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 690 */ 1654, 1654, 1654, 1751, 1654, 1654, 1654, 1654, 1654, 1654, - /* 700 */ 1654, 1654, 1743, 1654, 1742, 1654, 1654, 1654, 1654, 1654, - /* 710 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 720 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, 1654, - /* 730 */ 1654, 1654, 1654, 1654, 1654, 1654, 1654, + /* 0 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 10 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 20 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 30 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 40 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 50 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 60 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 70 */ 1658, 1658, 1658, 1916, 1658, 1658, 1658, 1658, 1658, 1658, + /* 80 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1737, 1658, 1658, + /* 90 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 100 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1735, 1909, 2123, + /* 110 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 120 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 130 */ 1658, 1658, 1658, 2135, 1658, 1658, 1737, 1658, 2135, 2135, + /* 140 */ 2135, 1735, 2095, 2095, 1658, 1658, 1658, 1658, 1970, 1658, + /* 150 */ 1658, 1658, 1658, 1658, 1658, 1844, 1658, 1658, 1658, 1658, + /* 160 */ 1658, 1868, 1658, 1658, 1658, 1962, 1658, 1658, 2160, 2216, + /* 170 */ 1658, 1658, 2163, 1658, 1658, 1658, 1921, 1658, 1797, 2150, + /* 180 */ 2127, 2141, 2200, 2128, 2125, 2144, 1658, 2154, 1658, 1955, + /* 190 */ 1914, 1658, 1914, 1911, 1658, 1658, 1914, 1911, 1911, 1658, + /* 200 */ 1788, 1658, 1658, 1658, 1658, 1658, 1658, 1737, 1658, 1737, + /* 210 */ 1658, 1658, 1737, 1658, 1737, 1737, 1737, 1658, 1737, 1715, + /* 220 */ 1715, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 230 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1980, 1968, 1658, + /* 240 */ 1735, 1964, 1658, 1735, 1658, 1658, 1658, 1658, 2171, 2169, + /* 250 */ 1658, 2171, 2169, 1658, 1658, 1658, 2185, 2181, 2171, 2189, + /* 260 */ 2187, 2156, 2154, 2219, 2206, 2202, 2141, 1658, 1658, 1658, + /* 270 */ 1658, 1735, 1735, 1658, 2169, 1658, 1658, 1658, 1658, 1658, + /* 280 */ 2169, 1658, 1658, 1735, 1658, 1735, 1658, 1658, 1813, 1658, + /* 290 */ 1658, 1658, 1735, 1690, 1658, 1957, 1973, 1939, 1939, 1847, + /* 300 */ 1847, 1847, 1738, 1663, 1658, 1658, 1658, 1658, 1658, 1658, + /* 310 */ 1658, 1658, 1658, 1658, 1658, 1658, 2184, 2183, 2050, 1658, + /* 320 */ 2099, 2098, 2097, 2088, 2049, 1809, 1658, 2048, 2047, 1658, + /* 330 */ 1658, 1658, 1658, 1658, 1658, 1930, 1929, 2041, 1658, 1658, + /* 340 */ 2042, 2040, 2039, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 350 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 360 */ 1658, 1658, 2203, 2207, 1658, 1658, 1658, 1658, 1658, 1658, + /* 370 */ 1658, 2124, 1658, 1658, 1658, 1658, 1658, 2023, 1658, 1658, + /* 380 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 390 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 400 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 410 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 420 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 430 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 440 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 450 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 460 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 470 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 480 */ 1695, 2028, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 490 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 500 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 510 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 520 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1776, 1775, + /* 530 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 540 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 550 */ 1658, 1658, 2032, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 560 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 2199, 2157, 1658, + /* 570 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 580 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 2023, 1658, 2182, + /* 590 */ 1658, 1658, 2197, 1658, 2201, 1658, 1658, 1658, 1658, 1658, + /* 600 */ 1658, 1658, 2134, 2130, 1658, 1658, 2126, 1658, 1658, 1658, + /* 610 */ 1658, 1658, 1658, 1658, 2031, 1658, 1658, 1658, 1658, 1658, + /* 620 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 2022, 1658, + /* 630 */ 2085, 1658, 1658, 1658, 2119, 1658, 1658, 2070, 1658, 1658, + /* 640 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 2032, 1658, 2035, + /* 650 */ 1658, 1658, 1658, 1658, 1658, 1841, 1658, 1658, 1658, 1658, + /* 660 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1826, 1824, + /* 670 */ 1823, 1822, 1658, 1819, 1658, 1854, 1658, 1658, 1658, 1850, + /* 680 */ 1849, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 690 */ 1658, 1658, 1658, 1658, 1658, 1658, 1756, 1658, 1658, 1658, + /* 700 */ 1658, 1658, 1658, 1658, 1658, 1748, 1658, 1747, 1658, 1658, + /* 710 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 720 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, + /* 730 */ 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, 1658, }; /********** End of lemon-generated parsing tables *****************************/ @@ -1060,6 +1060,7 @@ static const YYCODETYPE yyFallback[] = { 0, /* USE => nothing */ 0, /* FLUSH => nothing */ 0, /* TRIM => nothing */ + 0, /* COMPACT => nothing */ 0, /* IF => nothing */ 0, /* NOT => nothing */ 0, /* EXISTS => nothing */ @@ -1227,7 +1228,7 @@ static const YYCODETYPE yyFallback[] = { 0, /* SERVER_STATUS => nothing */ 0, /* CURRENT_USER => nothing */ 0, /* CASE => nothing */ - 274, /* END => ABORT */ + 275, /* END => ABORT */ 0, /* WHEN => nothing */ 0, /* THEN => nothing */ 0, /* ELSE => nothing */ @@ -1273,59 +1274,58 @@ static const YYCODETYPE yyFallback[] = { 0, /* ASC => nothing */ 0, /* NULLS => nothing */ 0, /* ABORT => nothing */ - 274, /* AFTER => ABORT */ - 274, /* ATTACH => ABORT */ - 274, /* BEFORE => ABORT */ - 274, /* BEGIN => ABORT */ - 274, /* BITAND => ABORT */ - 274, /* BITNOT => ABORT */ - 274, /* BITOR => ABORT */ - 274, /* BLOCKS => ABORT */ - 274, /* CHANGE => ABORT */ - 274, /* COMMA => ABORT */ - 274, /* COMPACT => ABORT */ - 274, /* CONCAT => ABORT */ - 274, /* CONFLICT => ABORT */ - 274, /* COPY => ABORT */ - 274, /* DEFERRED => ABORT */ - 274, /* DELIMITERS => ABORT */ - 274, /* DETACH => ABORT */ - 274, /* DIVIDE => ABORT */ - 274, /* DOT => ABORT */ - 274, /* EACH => ABORT */ - 274, /* FAIL => ABORT */ - 274, /* FILE => ABORT */ - 274, /* FOR => ABORT */ - 274, /* GLOB => ABORT */ - 274, /* ID => ABORT */ - 274, /* IMMEDIATE => ABORT */ - 274, /* IMPORT => ABORT */ - 274, /* INITIALLY => ABORT */ - 274, /* INSTEAD => ABORT */ - 274, /* ISNULL => ABORT */ - 274, /* KEY => ABORT */ - 274, /* MODULES => ABORT */ - 274, /* NK_BITNOT => ABORT */ - 274, /* NK_SEMI => ABORT */ - 274, /* NOTNULL => ABORT */ - 274, /* OF => ABORT */ - 274, /* PLUS => ABORT */ - 274, /* PRIVILEGE => ABORT */ - 274, /* RAISE => ABORT */ - 274, /* REPLACE => ABORT */ - 274, /* RESTRICT => ABORT */ - 274, /* ROW => ABORT */ - 274, /* SEMI => ABORT */ - 274, /* STAR => ABORT */ - 274, /* STATEMENT => ABORT */ - 274, /* STRICT => ABORT */ - 274, /* STRING => ABORT */ - 274, /* TIMES => ABORT */ - 274, /* UPDATE => ABORT */ - 274, /* VALUES => ABORT */ - 274, /* VARIABLE => ABORT */ - 274, /* VIEW => ABORT */ - 274, /* WAL => ABORT */ + 275, /* AFTER => ABORT */ + 275, /* ATTACH => ABORT */ + 275, /* BEFORE => ABORT */ + 275, /* BEGIN => ABORT */ + 275, /* BITAND => ABORT */ + 275, /* BITNOT => ABORT */ + 275, /* BITOR => ABORT */ + 275, /* BLOCKS => ABORT */ + 275, /* CHANGE => ABORT */ + 275, /* COMMA => ABORT */ + 275, /* CONCAT => ABORT */ + 275, /* CONFLICT => ABORT */ + 275, /* COPY => ABORT */ + 275, /* DEFERRED => ABORT */ + 275, /* DELIMITERS => ABORT */ + 275, /* DETACH => ABORT */ + 275, /* DIVIDE => ABORT */ + 275, /* DOT => ABORT */ + 275, /* EACH => ABORT */ + 275, /* FAIL => ABORT */ + 275, /* FILE => ABORT */ + 275, /* FOR => ABORT */ + 275, /* GLOB => ABORT */ + 275, /* ID => ABORT */ + 275, /* IMMEDIATE => ABORT */ + 275, /* IMPORT => ABORT */ + 275, /* INITIALLY => ABORT */ + 275, /* INSTEAD => ABORT */ + 275, /* ISNULL => ABORT */ + 275, /* KEY => ABORT */ + 275, /* MODULES => ABORT */ + 275, /* NK_BITNOT => ABORT */ + 275, /* NK_SEMI => ABORT */ + 275, /* NOTNULL => ABORT */ + 275, /* OF => ABORT */ + 275, /* PLUS => ABORT */ + 275, /* PRIVILEGE => ABORT */ + 275, /* RAISE => ABORT */ + 275, /* REPLACE => ABORT */ + 275, /* RESTRICT => ABORT */ + 275, /* ROW => ABORT */ + 275, /* SEMI => ABORT */ + 275, /* STAR => ABORT */ + 275, /* STATEMENT => ABORT */ + 275, /* STRICT => ABORT */ + 275, /* STRING => ABORT */ + 275, /* TIMES => ABORT */ + 275, /* UPDATE => ABORT */ + 275, /* VALUES => ABORT */ + 275, /* VARIABLE => ABORT */ + 275, /* VIEW => ABORT */ + 275, /* WAL => ABORT */ }; #endif /* YYFALLBACK */ @@ -1475,230 +1475,230 @@ static const char *const yyTokenName[] = { /* 59 */ "USE", /* 60 */ "FLUSH", /* 61 */ "TRIM", - /* 62 */ "IF", - /* 63 */ "NOT", - /* 64 */ "EXISTS", - /* 65 */ "BUFFER", - /* 66 */ "CACHEMODEL", - /* 67 */ "CACHESIZE", - /* 68 */ "COMP", - /* 69 */ "DURATION", - /* 70 */ "NK_VARIABLE", - /* 71 */ "MAXROWS", - /* 72 */ "MINROWS", - /* 73 */ "KEEP", - /* 74 */ "PAGES", - /* 75 */ "PAGESIZE", - /* 76 */ "TSDB_PAGESIZE", - /* 77 */ "PRECISION", - /* 78 */ "REPLICA", - /* 79 */ "VGROUPS", - /* 80 */ "SINGLE_STABLE", - /* 81 */ "RETENTIONS", - /* 82 */ "SCHEMALESS", - /* 83 */ "WAL_LEVEL", - /* 84 */ "WAL_FSYNC_PERIOD", - /* 85 */ "WAL_RETENTION_PERIOD", - /* 86 */ "WAL_RETENTION_SIZE", - /* 87 */ "WAL_ROLL_PERIOD", - /* 88 */ "WAL_SEGMENT_SIZE", - /* 89 */ "STT_TRIGGER", - /* 90 */ "TABLE_PREFIX", - /* 91 */ "TABLE_SUFFIX", - /* 92 */ "NK_COLON", - /* 93 */ "MAX_SPEED", - /* 94 */ "TABLE", - /* 95 */ "NK_LP", - /* 96 */ "NK_RP", - /* 97 */ "STABLE", - /* 98 */ "ADD", - /* 99 */ "COLUMN", - /* 100 */ "MODIFY", - /* 101 */ "RENAME", - /* 102 */ "TAG", - /* 103 */ "SET", - /* 104 */ "NK_EQ", - /* 105 */ "USING", - /* 106 */ "TAGS", - /* 107 */ "COMMENT", - /* 108 */ "BOOL", - /* 109 */ "TINYINT", - /* 110 */ "SMALLINT", - /* 111 */ "INT", - /* 112 */ "INTEGER", - /* 113 */ "BIGINT", - /* 114 */ "FLOAT", - /* 115 */ "DOUBLE", - /* 116 */ "BINARY", - /* 117 */ "TIMESTAMP", - /* 118 */ "NCHAR", - /* 119 */ "UNSIGNED", - /* 120 */ "JSON", - /* 121 */ "VARCHAR", - /* 122 */ "MEDIUMBLOB", - /* 123 */ "BLOB", - /* 124 */ "VARBINARY", - /* 125 */ "DECIMAL", - /* 126 */ "MAX_DELAY", - /* 127 */ "WATERMARK", - /* 128 */ "ROLLUP", - /* 129 */ "TTL", - /* 130 */ "SMA", - /* 131 */ "DELETE_MARK", - /* 132 */ "FIRST", - /* 133 */ "LAST", - /* 134 */ "SHOW", - /* 135 */ "PRIVILEGES", - /* 136 */ "DATABASES", - /* 137 */ "TABLES", - /* 138 */ "STABLES", - /* 139 */ "MNODES", - /* 140 */ "QNODES", - /* 141 */ "FUNCTIONS", - /* 142 */ "INDEXES", - /* 143 */ "ACCOUNTS", - /* 144 */ "APPS", - /* 145 */ "CONNECTIONS", - /* 146 */ "LICENCES", - /* 147 */ "GRANTS", - /* 148 */ "QUERIES", - /* 149 */ "SCORES", - /* 150 */ "TOPICS", - /* 151 */ "VARIABLES", - /* 152 */ "CLUSTER", - /* 153 */ "BNODES", - /* 154 */ "SNODES", - /* 155 */ "TRANSACTIONS", - /* 156 */ "DISTRIBUTED", - /* 157 */ "CONSUMERS", - /* 158 */ "SUBSCRIPTIONS", - /* 159 */ "VNODES", - /* 160 */ "ALIVE", - /* 161 */ "LIKE", - /* 162 */ "TBNAME", - /* 163 */ "QTAGS", - /* 164 */ "AS", - /* 165 */ "INDEX", - /* 166 */ "FUNCTION", - /* 167 */ "INTERVAL", - /* 168 */ "COUNT", - /* 169 */ "LAST_ROW", - /* 170 */ "TOPIC", - /* 171 */ "WITH", - /* 172 */ "META", - /* 173 */ "CONSUMER", - /* 174 */ "GROUP", - /* 175 */ "DESC", - /* 176 */ "DESCRIBE", - /* 177 */ "RESET", - /* 178 */ "QUERY", - /* 179 */ "CACHE", - /* 180 */ "EXPLAIN", - /* 181 */ "ANALYZE", - /* 182 */ "VERBOSE", - /* 183 */ "NK_BOOL", - /* 184 */ "RATIO", - /* 185 */ "NK_FLOAT", - /* 186 */ "OUTPUTTYPE", - /* 187 */ "AGGREGATE", - /* 188 */ "BUFSIZE", - /* 189 */ "STREAM", - /* 190 */ "INTO", - /* 191 */ "TRIGGER", - /* 192 */ "AT_ONCE", - /* 193 */ "WINDOW_CLOSE", - /* 194 */ "IGNORE", - /* 195 */ "EXPIRED", - /* 196 */ "FILL_HISTORY", - /* 197 */ "SUBTABLE", - /* 198 */ "KILL", - /* 199 */ "CONNECTION", - /* 200 */ "TRANSACTION", - /* 201 */ "BALANCE", - /* 202 */ "VGROUP", - /* 203 */ "MERGE", - /* 204 */ "REDISTRIBUTE", - /* 205 */ "SPLIT", - /* 206 */ "DELETE", - /* 207 */ "INSERT", - /* 208 */ "NULL", - /* 209 */ "NK_QUESTION", - /* 210 */ "NK_ARROW", - /* 211 */ "ROWTS", - /* 212 */ "QSTART", - /* 213 */ "QEND", - /* 214 */ "QDURATION", - /* 215 */ "WSTART", - /* 216 */ "WEND", - /* 217 */ "WDURATION", - /* 218 */ "IROWTS", - /* 219 */ "ISFILLED", - /* 220 */ "CAST", - /* 221 */ "NOW", - /* 222 */ "TODAY", - /* 223 */ "TIMEZONE", - /* 224 */ "CLIENT_VERSION", - /* 225 */ "SERVER_VERSION", - /* 226 */ "SERVER_STATUS", - /* 227 */ "CURRENT_USER", - /* 228 */ "CASE", - /* 229 */ "END", - /* 230 */ "WHEN", - /* 231 */ "THEN", - /* 232 */ "ELSE", - /* 233 */ "BETWEEN", - /* 234 */ "IS", - /* 235 */ "NK_LT", - /* 236 */ "NK_GT", - /* 237 */ "NK_LE", - /* 238 */ "NK_GE", - /* 239 */ "NK_NE", - /* 240 */ "MATCH", - /* 241 */ "NMATCH", - /* 242 */ "CONTAINS", - /* 243 */ "IN", - /* 244 */ "JOIN", - /* 245 */ "INNER", - /* 246 */ "SELECT", - /* 247 */ "DISTINCT", - /* 248 */ "WHERE", - /* 249 */ "PARTITION", - /* 250 */ "BY", - /* 251 */ "SESSION", - /* 252 */ "STATE_WINDOW", - /* 253 */ "EVENT_WINDOW", - /* 254 */ "START", - /* 255 */ "SLIDING", - /* 256 */ "FILL", - /* 257 */ "VALUE", - /* 258 */ "VALUE_F", - /* 259 */ "NONE", - /* 260 */ "PREV", - /* 261 */ "NULL_F", - /* 262 */ "LINEAR", - /* 263 */ "NEXT", - /* 264 */ "HAVING", - /* 265 */ "RANGE", - /* 266 */ "EVERY", - /* 267 */ "ORDER", - /* 268 */ "SLIMIT", - /* 269 */ "SOFFSET", - /* 270 */ "LIMIT", - /* 271 */ "OFFSET", - /* 272 */ "ASC", - /* 273 */ "NULLS", - /* 274 */ "ABORT", - /* 275 */ "AFTER", - /* 276 */ "ATTACH", - /* 277 */ "BEFORE", - /* 278 */ "BEGIN", - /* 279 */ "BITAND", - /* 280 */ "BITNOT", - /* 281 */ "BITOR", - /* 282 */ "BLOCKS", - /* 283 */ "CHANGE", - /* 284 */ "COMMA", - /* 285 */ "COMPACT", + /* 62 */ "COMPACT", + /* 63 */ "IF", + /* 64 */ "NOT", + /* 65 */ "EXISTS", + /* 66 */ "BUFFER", + /* 67 */ "CACHEMODEL", + /* 68 */ "CACHESIZE", + /* 69 */ "COMP", + /* 70 */ "DURATION", + /* 71 */ "NK_VARIABLE", + /* 72 */ "MAXROWS", + /* 73 */ "MINROWS", + /* 74 */ "KEEP", + /* 75 */ "PAGES", + /* 76 */ "PAGESIZE", + /* 77 */ "TSDB_PAGESIZE", + /* 78 */ "PRECISION", + /* 79 */ "REPLICA", + /* 80 */ "VGROUPS", + /* 81 */ "SINGLE_STABLE", + /* 82 */ "RETENTIONS", + /* 83 */ "SCHEMALESS", + /* 84 */ "WAL_LEVEL", + /* 85 */ "WAL_FSYNC_PERIOD", + /* 86 */ "WAL_RETENTION_PERIOD", + /* 87 */ "WAL_RETENTION_SIZE", + /* 88 */ "WAL_ROLL_PERIOD", + /* 89 */ "WAL_SEGMENT_SIZE", + /* 90 */ "STT_TRIGGER", + /* 91 */ "TABLE_PREFIX", + /* 92 */ "TABLE_SUFFIX", + /* 93 */ "NK_COLON", + /* 94 */ "MAX_SPEED", + /* 95 */ "TABLE", + /* 96 */ "NK_LP", + /* 97 */ "NK_RP", + /* 98 */ "STABLE", + /* 99 */ "ADD", + /* 100 */ "COLUMN", + /* 101 */ "MODIFY", + /* 102 */ "RENAME", + /* 103 */ "TAG", + /* 104 */ "SET", + /* 105 */ "NK_EQ", + /* 106 */ "USING", + /* 107 */ "TAGS", + /* 108 */ "COMMENT", + /* 109 */ "BOOL", + /* 110 */ "TINYINT", + /* 111 */ "SMALLINT", + /* 112 */ "INT", + /* 113 */ "INTEGER", + /* 114 */ "BIGINT", + /* 115 */ "FLOAT", + /* 116 */ "DOUBLE", + /* 117 */ "BINARY", + /* 118 */ "TIMESTAMP", + /* 119 */ "NCHAR", + /* 120 */ "UNSIGNED", + /* 121 */ "JSON", + /* 122 */ "VARCHAR", + /* 123 */ "MEDIUMBLOB", + /* 124 */ "BLOB", + /* 125 */ "VARBINARY", + /* 126 */ "DECIMAL", + /* 127 */ "MAX_DELAY", + /* 128 */ "WATERMARK", + /* 129 */ "ROLLUP", + /* 130 */ "TTL", + /* 131 */ "SMA", + /* 132 */ "DELETE_MARK", + /* 133 */ "FIRST", + /* 134 */ "LAST", + /* 135 */ "SHOW", + /* 136 */ "PRIVILEGES", + /* 137 */ "DATABASES", + /* 138 */ "TABLES", + /* 139 */ "STABLES", + /* 140 */ "MNODES", + /* 141 */ "QNODES", + /* 142 */ "FUNCTIONS", + /* 143 */ "INDEXES", + /* 144 */ "ACCOUNTS", + /* 145 */ "APPS", + /* 146 */ "CONNECTIONS", + /* 147 */ "LICENCES", + /* 148 */ "GRANTS", + /* 149 */ "QUERIES", + /* 150 */ "SCORES", + /* 151 */ "TOPICS", + /* 152 */ "VARIABLES", + /* 153 */ "CLUSTER", + /* 154 */ "BNODES", + /* 155 */ "SNODES", + /* 156 */ "TRANSACTIONS", + /* 157 */ "DISTRIBUTED", + /* 158 */ "CONSUMERS", + /* 159 */ "SUBSCRIPTIONS", + /* 160 */ "VNODES", + /* 161 */ "ALIVE", + /* 162 */ "LIKE", + /* 163 */ "TBNAME", + /* 164 */ "QTAGS", + /* 165 */ "AS", + /* 166 */ "INDEX", + /* 167 */ "FUNCTION", + /* 168 */ "INTERVAL", + /* 169 */ "COUNT", + /* 170 */ "LAST_ROW", + /* 171 */ "TOPIC", + /* 172 */ "WITH", + /* 173 */ "META", + /* 174 */ "CONSUMER", + /* 175 */ "GROUP", + /* 176 */ "DESC", + /* 177 */ "DESCRIBE", + /* 178 */ "RESET", + /* 179 */ "QUERY", + /* 180 */ "CACHE", + /* 181 */ "EXPLAIN", + /* 182 */ "ANALYZE", + /* 183 */ "VERBOSE", + /* 184 */ "NK_BOOL", + /* 185 */ "RATIO", + /* 186 */ "NK_FLOAT", + /* 187 */ "OUTPUTTYPE", + /* 188 */ "AGGREGATE", + /* 189 */ "BUFSIZE", + /* 190 */ "STREAM", + /* 191 */ "INTO", + /* 192 */ "TRIGGER", + /* 193 */ "AT_ONCE", + /* 194 */ "WINDOW_CLOSE", + /* 195 */ "IGNORE", + /* 196 */ "EXPIRED", + /* 197 */ "FILL_HISTORY", + /* 198 */ "SUBTABLE", + /* 199 */ "KILL", + /* 200 */ "CONNECTION", + /* 201 */ "TRANSACTION", + /* 202 */ "BALANCE", + /* 203 */ "VGROUP", + /* 204 */ "MERGE", + /* 205 */ "REDISTRIBUTE", + /* 206 */ "SPLIT", + /* 207 */ "DELETE", + /* 208 */ "INSERT", + /* 209 */ "NULL", + /* 210 */ "NK_QUESTION", + /* 211 */ "NK_ARROW", + /* 212 */ "ROWTS", + /* 213 */ "QSTART", + /* 214 */ "QEND", + /* 215 */ "QDURATION", + /* 216 */ "WSTART", + /* 217 */ "WEND", + /* 218 */ "WDURATION", + /* 219 */ "IROWTS", + /* 220 */ "ISFILLED", + /* 221 */ "CAST", + /* 222 */ "NOW", + /* 223 */ "TODAY", + /* 224 */ "TIMEZONE", + /* 225 */ "CLIENT_VERSION", + /* 226 */ "SERVER_VERSION", + /* 227 */ "SERVER_STATUS", + /* 228 */ "CURRENT_USER", + /* 229 */ "CASE", + /* 230 */ "END", + /* 231 */ "WHEN", + /* 232 */ "THEN", + /* 233 */ "ELSE", + /* 234 */ "BETWEEN", + /* 235 */ "IS", + /* 236 */ "NK_LT", + /* 237 */ "NK_GT", + /* 238 */ "NK_LE", + /* 239 */ "NK_GE", + /* 240 */ "NK_NE", + /* 241 */ "MATCH", + /* 242 */ "NMATCH", + /* 243 */ "CONTAINS", + /* 244 */ "IN", + /* 245 */ "JOIN", + /* 246 */ "INNER", + /* 247 */ "SELECT", + /* 248 */ "DISTINCT", + /* 249 */ "WHERE", + /* 250 */ "PARTITION", + /* 251 */ "BY", + /* 252 */ "SESSION", + /* 253 */ "STATE_WINDOW", + /* 254 */ "EVENT_WINDOW", + /* 255 */ "START", + /* 256 */ "SLIDING", + /* 257 */ "FILL", + /* 258 */ "VALUE", + /* 259 */ "VALUE_F", + /* 260 */ "NONE", + /* 261 */ "PREV", + /* 262 */ "NULL_F", + /* 263 */ "LINEAR", + /* 264 */ "NEXT", + /* 265 */ "HAVING", + /* 266 */ "RANGE", + /* 267 */ "EVERY", + /* 268 */ "ORDER", + /* 269 */ "SLIMIT", + /* 270 */ "SOFFSET", + /* 271 */ "LIMIT", + /* 272 */ "OFFSET", + /* 273 */ "ASC", + /* 274 */ "NULLS", + /* 275 */ "ABORT", + /* 276 */ "AFTER", + /* 277 */ "ATTACH", + /* 278 */ "BEFORE", + /* 279 */ "BEGIN", + /* 280 */ "BITAND", + /* 281 */ "BITNOT", + /* 282 */ "BITOR", + /* 283 */ "BLOCKS", + /* 284 */ "CHANGE", + /* 285 */ "COMMA", /* 286 */ "CONCAT", /* 287 */ "CONFLICT", /* 288 */ "COPY", @@ -1961,494 +1961,495 @@ static const char *const yyRuleName[] = { /* 69 */ "cmd ::= ALTER DATABASE db_name alter_db_options", /* 70 */ "cmd ::= FLUSH DATABASE db_name", /* 71 */ "cmd ::= TRIM DATABASE db_name speed_opt", - /* 72 */ "not_exists_opt ::= IF NOT EXISTS", - /* 73 */ "not_exists_opt ::=", - /* 74 */ "exists_opt ::= IF EXISTS", - /* 75 */ "exists_opt ::=", - /* 76 */ "db_options ::=", - /* 77 */ "db_options ::= db_options BUFFER NK_INTEGER", - /* 78 */ "db_options ::= db_options CACHEMODEL NK_STRING", - /* 79 */ "db_options ::= db_options CACHESIZE NK_INTEGER", - /* 80 */ "db_options ::= db_options COMP NK_INTEGER", - /* 81 */ "db_options ::= db_options DURATION NK_INTEGER", - /* 82 */ "db_options ::= db_options DURATION NK_VARIABLE", - /* 83 */ "db_options ::= db_options MAXROWS NK_INTEGER", - /* 84 */ "db_options ::= db_options MINROWS NK_INTEGER", - /* 85 */ "db_options ::= db_options KEEP integer_list", - /* 86 */ "db_options ::= db_options KEEP variable_list", - /* 87 */ "db_options ::= db_options PAGES NK_INTEGER", - /* 88 */ "db_options ::= db_options PAGESIZE NK_INTEGER", - /* 89 */ "db_options ::= db_options TSDB_PAGESIZE NK_INTEGER", - /* 90 */ "db_options ::= db_options PRECISION NK_STRING", - /* 91 */ "db_options ::= db_options REPLICA NK_INTEGER", - /* 92 */ "db_options ::= db_options VGROUPS NK_INTEGER", - /* 93 */ "db_options ::= db_options SINGLE_STABLE NK_INTEGER", - /* 94 */ "db_options ::= db_options RETENTIONS retention_list", - /* 95 */ "db_options ::= db_options SCHEMALESS NK_INTEGER", - /* 96 */ "db_options ::= db_options WAL_LEVEL NK_INTEGER", - /* 97 */ "db_options ::= db_options WAL_FSYNC_PERIOD NK_INTEGER", - /* 98 */ "db_options ::= db_options WAL_RETENTION_PERIOD NK_INTEGER", - /* 99 */ "db_options ::= db_options WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER", - /* 100 */ "db_options ::= db_options WAL_RETENTION_SIZE NK_INTEGER", - /* 101 */ "db_options ::= db_options WAL_RETENTION_SIZE NK_MINUS NK_INTEGER", - /* 102 */ "db_options ::= db_options WAL_ROLL_PERIOD NK_INTEGER", - /* 103 */ "db_options ::= db_options WAL_SEGMENT_SIZE NK_INTEGER", - /* 104 */ "db_options ::= db_options STT_TRIGGER NK_INTEGER", - /* 105 */ "db_options ::= db_options TABLE_PREFIX NK_INTEGER", - /* 106 */ "db_options ::= db_options TABLE_SUFFIX NK_INTEGER", - /* 107 */ "alter_db_options ::= alter_db_option", - /* 108 */ "alter_db_options ::= alter_db_options alter_db_option", - /* 109 */ "alter_db_option ::= BUFFER NK_INTEGER", - /* 110 */ "alter_db_option ::= CACHEMODEL NK_STRING", - /* 111 */ "alter_db_option ::= CACHESIZE NK_INTEGER", - /* 112 */ "alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER", - /* 113 */ "alter_db_option ::= KEEP integer_list", - /* 114 */ "alter_db_option ::= KEEP variable_list", - /* 115 */ "alter_db_option ::= PAGES NK_INTEGER", - /* 116 */ "alter_db_option ::= REPLICA NK_INTEGER", - /* 117 */ "alter_db_option ::= WAL_LEVEL NK_INTEGER", - /* 118 */ "alter_db_option ::= STT_TRIGGER NK_INTEGER", - /* 119 */ "integer_list ::= NK_INTEGER", - /* 120 */ "integer_list ::= integer_list NK_COMMA NK_INTEGER", - /* 121 */ "variable_list ::= NK_VARIABLE", - /* 122 */ "variable_list ::= variable_list NK_COMMA NK_VARIABLE", - /* 123 */ "retention_list ::= retention", - /* 124 */ "retention_list ::= retention_list NK_COMMA retention", - /* 125 */ "retention ::= NK_VARIABLE NK_COLON NK_VARIABLE", - /* 126 */ "speed_opt ::=", - /* 127 */ "speed_opt ::= MAX_SPEED NK_INTEGER", - /* 128 */ "cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options", - /* 129 */ "cmd ::= CREATE TABLE multi_create_clause", - /* 130 */ "cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options", - /* 131 */ "cmd ::= DROP TABLE multi_drop_clause", - /* 132 */ "cmd ::= DROP STABLE exists_opt full_table_name", - /* 133 */ "cmd ::= ALTER TABLE alter_table_clause", - /* 134 */ "cmd ::= ALTER STABLE alter_table_clause", - /* 135 */ "alter_table_clause ::= full_table_name alter_table_options", - /* 136 */ "alter_table_clause ::= full_table_name ADD COLUMN column_name type_name", - /* 137 */ "alter_table_clause ::= full_table_name DROP COLUMN column_name", - /* 138 */ "alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name", - /* 139 */ "alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name", - /* 140 */ "alter_table_clause ::= full_table_name ADD TAG column_name type_name", - /* 141 */ "alter_table_clause ::= full_table_name DROP TAG column_name", - /* 142 */ "alter_table_clause ::= full_table_name MODIFY TAG column_name type_name", - /* 143 */ "alter_table_clause ::= full_table_name RENAME TAG column_name column_name", - /* 144 */ "alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal", - /* 145 */ "multi_create_clause ::= create_subtable_clause", - /* 146 */ "multi_create_clause ::= multi_create_clause create_subtable_clause", - /* 147 */ "create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP expression_list NK_RP table_options", - /* 148 */ "multi_drop_clause ::= drop_table_clause", - /* 149 */ "multi_drop_clause ::= multi_drop_clause drop_table_clause", - /* 150 */ "drop_table_clause ::= exists_opt full_table_name", - /* 151 */ "specific_cols_opt ::=", - /* 152 */ "specific_cols_opt ::= NK_LP col_name_list NK_RP", - /* 153 */ "full_table_name ::= table_name", - /* 154 */ "full_table_name ::= db_name NK_DOT table_name", - /* 155 */ "column_def_list ::= column_def", - /* 156 */ "column_def_list ::= column_def_list NK_COMMA column_def", - /* 157 */ "column_def ::= column_name type_name", - /* 158 */ "column_def ::= column_name type_name COMMENT NK_STRING", - /* 159 */ "type_name ::= BOOL", - /* 160 */ "type_name ::= TINYINT", - /* 161 */ "type_name ::= SMALLINT", - /* 162 */ "type_name ::= INT", - /* 163 */ "type_name ::= INTEGER", - /* 164 */ "type_name ::= BIGINT", - /* 165 */ "type_name ::= FLOAT", - /* 166 */ "type_name ::= DOUBLE", - /* 167 */ "type_name ::= BINARY NK_LP NK_INTEGER NK_RP", - /* 168 */ "type_name ::= TIMESTAMP", - /* 169 */ "type_name ::= NCHAR NK_LP NK_INTEGER NK_RP", - /* 170 */ "type_name ::= TINYINT UNSIGNED", - /* 171 */ "type_name ::= SMALLINT UNSIGNED", - /* 172 */ "type_name ::= INT UNSIGNED", - /* 173 */ "type_name ::= BIGINT UNSIGNED", - /* 174 */ "type_name ::= JSON", - /* 175 */ "type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP", - /* 176 */ "type_name ::= MEDIUMBLOB", - /* 177 */ "type_name ::= BLOB", - /* 178 */ "type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP", - /* 179 */ "type_name ::= DECIMAL", - /* 180 */ "type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP", - /* 181 */ "type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP", - /* 182 */ "tags_def_opt ::=", - /* 183 */ "tags_def_opt ::= tags_def", - /* 184 */ "tags_def ::= TAGS NK_LP column_def_list NK_RP", - /* 185 */ "table_options ::=", - /* 186 */ "table_options ::= table_options COMMENT NK_STRING", - /* 187 */ "table_options ::= table_options MAX_DELAY duration_list", - /* 188 */ "table_options ::= table_options WATERMARK duration_list", - /* 189 */ "table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP", - /* 190 */ "table_options ::= table_options TTL NK_INTEGER", - /* 191 */ "table_options ::= table_options SMA NK_LP col_name_list NK_RP", - /* 192 */ "table_options ::= table_options DELETE_MARK duration_list", - /* 193 */ "alter_table_options ::= alter_table_option", - /* 194 */ "alter_table_options ::= alter_table_options alter_table_option", - /* 195 */ "alter_table_option ::= COMMENT NK_STRING", - /* 196 */ "alter_table_option ::= TTL NK_INTEGER", - /* 197 */ "duration_list ::= duration_literal", - /* 198 */ "duration_list ::= duration_list NK_COMMA duration_literal", - /* 199 */ "rollup_func_list ::= rollup_func_name", - /* 200 */ "rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name", - /* 201 */ "rollup_func_name ::= function_name", - /* 202 */ "rollup_func_name ::= FIRST", - /* 203 */ "rollup_func_name ::= LAST", - /* 204 */ "col_name_list ::= col_name", - /* 205 */ "col_name_list ::= col_name_list NK_COMMA col_name", - /* 206 */ "col_name ::= column_name", - /* 207 */ "cmd ::= SHOW DNODES", - /* 208 */ "cmd ::= SHOW USERS", - /* 209 */ "cmd ::= SHOW USER PRIVILEGES", - /* 210 */ "cmd ::= SHOW DATABASES", - /* 211 */ "cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt", - /* 212 */ "cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt", - /* 213 */ "cmd ::= SHOW db_name_cond_opt VGROUPS", - /* 214 */ "cmd ::= SHOW MNODES", - /* 215 */ "cmd ::= SHOW QNODES", - /* 216 */ "cmd ::= SHOW FUNCTIONS", - /* 217 */ "cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt", - /* 218 */ "cmd ::= SHOW STREAMS", - /* 219 */ "cmd ::= SHOW ACCOUNTS", - /* 220 */ "cmd ::= SHOW APPS", - /* 221 */ "cmd ::= SHOW CONNECTIONS", - /* 222 */ "cmd ::= SHOW LICENCES", - /* 223 */ "cmd ::= SHOW GRANTS", - /* 224 */ "cmd ::= SHOW CREATE DATABASE db_name", - /* 225 */ "cmd ::= SHOW CREATE TABLE full_table_name", - /* 226 */ "cmd ::= SHOW CREATE STABLE full_table_name", - /* 227 */ "cmd ::= SHOW QUERIES", - /* 228 */ "cmd ::= SHOW SCORES", - /* 229 */ "cmd ::= SHOW TOPICS", - /* 230 */ "cmd ::= SHOW VARIABLES", - /* 231 */ "cmd ::= SHOW CLUSTER VARIABLES", - /* 232 */ "cmd ::= SHOW LOCAL VARIABLES", - /* 233 */ "cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt", - /* 234 */ "cmd ::= SHOW BNODES", - /* 235 */ "cmd ::= SHOW SNODES", - /* 236 */ "cmd ::= SHOW CLUSTER", - /* 237 */ "cmd ::= SHOW TRANSACTIONS", - /* 238 */ "cmd ::= SHOW TABLE DISTRIBUTED full_table_name", - /* 239 */ "cmd ::= SHOW CONSUMERS", - /* 240 */ "cmd ::= SHOW SUBSCRIPTIONS", - /* 241 */ "cmd ::= SHOW TAGS FROM table_name_cond from_db_opt", - /* 242 */ "cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt", - /* 243 */ "cmd ::= SHOW VNODES NK_INTEGER", - /* 244 */ "cmd ::= SHOW VNODES NK_STRING", - /* 245 */ "cmd ::= SHOW db_name_cond_opt ALIVE", - /* 246 */ "cmd ::= SHOW CLUSTER ALIVE", - /* 247 */ "db_name_cond_opt ::=", - /* 248 */ "db_name_cond_opt ::= db_name NK_DOT", - /* 249 */ "like_pattern_opt ::=", - /* 250 */ "like_pattern_opt ::= LIKE NK_STRING", - /* 251 */ "table_name_cond ::= table_name", - /* 252 */ "from_db_opt ::=", - /* 253 */ "from_db_opt ::= FROM db_name", - /* 254 */ "tag_list_opt ::=", - /* 255 */ "tag_list_opt ::= tag_item", - /* 256 */ "tag_list_opt ::= tag_list_opt NK_COMMA tag_item", - /* 257 */ "tag_item ::= TBNAME", - /* 258 */ "tag_item ::= QTAGS", - /* 259 */ "tag_item ::= column_name", - /* 260 */ "tag_item ::= column_name column_alias", - /* 261 */ "tag_item ::= column_name AS column_alias", - /* 262 */ "cmd ::= CREATE SMA INDEX not_exists_opt full_index_name ON full_table_name index_options", - /* 263 */ "cmd ::= CREATE INDEX not_exists_opt full_index_name ON full_table_name NK_LP col_name_list NK_RP", - /* 264 */ "cmd ::= DROP INDEX exists_opt full_index_name", - /* 265 */ "full_index_name ::= index_name", - /* 266 */ "full_index_name ::= db_name NK_DOT index_name", - /* 267 */ "index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt", - /* 268 */ "index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt", - /* 269 */ "func_list ::= func", - /* 270 */ "func_list ::= func_list NK_COMMA func", - /* 271 */ "func ::= sma_func_name NK_LP expression_list NK_RP", - /* 272 */ "sma_func_name ::= function_name", - /* 273 */ "sma_func_name ::= COUNT", - /* 274 */ "sma_func_name ::= FIRST", - /* 275 */ "sma_func_name ::= LAST", - /* 276 */ "sma_func_name ::= LAST_ROW", - /* 277 */ "sma_stream_opt ::=", - /* 278 */ "sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal", - /* 279 */ "sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal", - /* 280 */ "sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal", - /* 281 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery", - /* 282 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name", - /* 283 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS DATABASE db_name", - /* 284 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name", - /* 285 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS STABLE full_table_name", - /* 286 */ "cmd ::= DROP TOPIC exists_opt topic_name", - /* 287 */ "cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name", - /* 288 */ "cmd ::= DESC full_table_name", - /* 289 */ "cmd ::= DESCRIBE full_table_name", - /* 290 */ "cmd ::= RESET QUERY CACHE", - /* 291 */ "cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery", - /* 292 */ "cmd ::= EXPLAIN analyze_opt explain_options insert_query", - /* 293 */ "analyze_opt ::=", - /* 294 */ "analyze_opt ::= ANALYZE", - /* 295 */ "explain_options ::=", - /* 296 */ "explain_options ::= explain_options VERBOSE NK_BOOL", - /* 297 */ "explain_options ::= explain_options RATIO NK_FLOAT", - /* 298 */ "cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt", - /* 299 */ "cmd ::= DROP FUNCTION exists_opt function_name", - /* 300 */ "agg_func_opt ::=", - /* 301 */ "agg_func_opt ::= AGGREGATE", - /* 302 */ "bufsize_opt ::=", - /* 303 */ "bufsize_opt ::= BUFSIZE NK_INTEGER", - /* 304 */ "cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery", - /* 305 */ "cmd ::= DROP STREAM exists_opt stream_name", - /* 306 */ "col_list_opt ::=", - /* 307 */ "col_list_opt ::= NK_LP col_name_list NK_RP", - /* 308 */ "tag_def_or_ref_opt ::=", - /* 309 */ "tag_def_or_ref_opt ::= tags_def", - /* 310 */ "tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP", - /* 311 */ "stream_options ::=", - /* 312 */ "stream_options ::= stream_options TRIGGER AT_ONCE", - /* 313 */ "stream_options ::= stream_options TRIGGER WINDOW_CLOSE", - /* 314 */ "stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal", - /* 315 */ "stream_options ::= stream_options WATERMARK duration_literal", - /* 316 */ "stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER", - /* 317 */ "stream_options ::= stream_options FILL_HISTORY NK_INTEGER", - /* 318 */ "subtable_opt ::=", - /* 319 */ "subtable_opt ::= SUBTABLE NK_LP expression NK_RP", - /* 320 */ "cmd ::= KILL CONNECTION NK_INTEGER", - /* 321 */ "cmd ::= KILL QUERY NK_STRING", - /* 322 */ "cmd ::= KILL TRANSACTION NK_INTEGER", - /* 323 */ "cmd ::= BALANCE VGROUP", - /* 324 */ "cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER", - /* 325 */ "cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list", - /* 326 */ "cmd ::= SPLIT VGROUP NK_INTEGER", - /* 327 */ "dnode_list ::= DNODE NK_INTEGER", - /* 328 */ "dnode_list ::= dnode_list DNODE NK_INTEGER", - /* 329 */ "cmd ::= DELETE FROM full_table_name where_clause_opt", - /* 330 */ "cmd ::= query_or_subquery", - /* 331 */ "cmd ::= insert_query", - /* 332 */ "insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery", - /* 333 */ "insert_query ::= INSERT INTO full_table_name query_or_subquery", - /* 334 */ "literal ::= NK_INTEGER", - /* 335 */ "literal ::= NK_FLOAT", - /* 336 */ "literal ::= NK_STRING", - /* 337 */ "literal ::= NK_BOOL", - /* 338 */ "literal ::= TIMESTAMP NK_STRING", - /* 339 */ "literal ::= duration_literal", - /* 340 */ "literal ::= NULL", - /* 341 */ "literal ::= NK_QUESTION", - /* 342 */ "duration_literal ::= NK_VARIABLE", - /* 343 */ "signed ::= NK_INTEGER", - /* 344 */ "signed ::= NK_PLUS NK_INTEGER", - /* 345 */ "signed ::= NK_MINUS NK_INTEGER", - /* 346 */ "signed ::= NK_FLOAT", - /* 347 */ "signed ::= NK_PLUS NK_FLOAT", - /* 348 */ "signed ::= NK_MINUS NK_FLOAT", - /* 349 */ "signed_literal ::= signed", - /* 350 */ "signed_literal ::= NK_STRING", - /* 351 */ "signed_literal ::= NK_BOOL", - /* 352 */ "signed_literal ::= TIMESTAMP NK_STRING", - /* 353 */ "signed_literal ::= duration_literal", - /* 354 */ "signed_literal ::= NULL", - /* 355 */ "signed_literal ::= literal_func", - /* 356 */ "signed_literal ::= NK_QUESTION", - /* 357 */ "literal_list ::= signed_literal", - /* 358 */ "literal_list ::= literal_list NK_COMMA signed_literal", - /* 359 */ "db_name ::= NK_ID", - /* 360 */ "table_name ::= NK_ID", - /* 361 */ "column_name ::= NK_ID", - /* 362 */ "function_name ::= NK_ID", - /* 363 */ "table_alias ::= NK_ID", - /* 364 */ "column_alias ::= NK_ID", - /* 365 */ "user_name ::= NK_ID", - /* 366 */ "topic_name ::= NK_ID", - /* 367 */ "stream_name ::= NK_ID", - /* 368 */ "cgroup_name ::= NK_ID", - /* 369 */ "index_name ::= NK_ID", - /* 370 */ "expr_or_subquery ::= expression", - /* 371 */ "expression ::= literal", - /* 372 */ "expression ::= pseudo_column", - /* 373 */ "expression ::= column_reference", - /* 374 */ "expression ::= function_expression", - /* 375 */ "expression ::= case_when_expression", - /* 376 */ "expression ::= NK_LP expression NK_RP", - /* 377 */ "expression ::= NK_PLUS expr_or_subquery", - /* 378 */ "expression ::= NK_MINUS expr_or_subquery", - /* 379 */ "expression ::= expr_or_subquery NK_PLUS expr_or_subquery", - /* 380 */ "expression ::= expr_or_subquery NK_MINUS expr_or_subquery", - /* 381 */ "expression ::= expr_or_subquery NK_STAR expr_or_subquery", - /* 382 */ "expression ::= expr_or_subquery NK_SLASH expr_or_subquery", - /* 383 */ "expression ::= expr_or_subquery NK_REM expr_or_subquery", - /* 384 */ "expression ::= column_reference NK_ARROW NK_STRING", - /* 385 */ "expression ::= expr_or_subquery NK_BITAND expr_or_subquery", - /* 386 */ "expression ::= expr_or_subquery NK_BITOR expr_or_subquery", - /* 387 */ "expression_list ::= expr_or_subquery", - /* 388 */ "expression_list ::= expression_list NK_COMMA expr_or_subquery", - /* 389 */ "column_reference ::= column_name", - /* 390 */ "column_reference ::= table_name NK_DOT column_name", - /* 391 */ "pseudo_column ::= ROWTS", - /* 392 */ "pseudo_column ::= TBNAME", - /* 393 */ "pseudo_column ::= table_name NK_DOT TBNAME", - /* 394 */ "pseudo_column ::= QSTART", - /* 395 */ "pseudo_column ::= QEND", - /* 396 */ "pseudo_column ::= QDURATION", - /* 397 */ "pseudo_column ::= WSTART", - /* 398 */ "pseudo_column ::= WEND", - /* 399 */ "pseudo_column ::= WDURATION", - /* 400 */ "pseudo_column ::= IROWTS", - /* 401 */ "pseudo_column ::= ISFILLED", - /* 402 */ "pseudo_column ::= QTAGS", - /* 403 */ "function_expression ::= function_name NK_LP expression_list NK_RP", - /* 404 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP", - /* 405 */ "function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP", - /* 406 */ "function_expression ::= literal_func", - /* 407 */ "literal_func ::= noarg_func NK_LP NK_RP", - /* 408 */ "literal_func ::= NOW", - /* 409 */ "noarg_func ::= NOW", - /* 410 */ "noarg_func ::= TODAY", - /* 411 */ "noarg_func ::= TIMEZONE", - /* 412 */ "noarg_func ::= DATABASE", - /* 413 */ "noarg_func ::= CLIENT_VERSION", - /* 414 */ "noarg_func ::= SERVER_VERSION", - /* 415 */ "noarg_func ::= SERVER_STATUS", - /* 416 */ "noarg_func ::= CURRENT_USER", - /* 417 */ "noarg_func ::= USER", - /* 418 */ "star_func ::= COUNT", - /* 419 */ "star_func ::= FIRST", - /* 420 */ "star_func ::= LAST", - /* 421 */ "star_func ::= LAST_ROW", - /* 422 */ "star_func_para_list ::= NK_STAR", - /* 423 */ "star_func_para_list ::= other_para_list", - /* 424 */ "other_para_list ::= star_func_para", - /* 425 */ "other_para_list ::= other_para_list NK_COMMA star_func_para", - /* 426 */ "star_func_para ::= expr_or_subquery", - /* 427 */ "star_func_para ::= table_name NK_DOT NK_STAR", - /* 428 */ "case_when_expression ::= CASE when_then_list case_when_else_opt END", - /* 429 */ "case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END", - /* 430 */ "when_then_list ::= when_then_expr", - /* 431 */ "when_then_list ::= when_then_list when_then_expr", - /* 432 */ "when_then_expr ::= WHEN common_expression THEN common_expression", - /* 433 */ "case_when_else_opt ::=", - /* 434 */ "case_when_else_opt ::= ELSE common_expression", - /* 435 */ "predicate ::= expr_or_subquery compare_op expr_or_subquery", - /* 436 */ "predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery", - /* 437 */ "predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery", - /* 438 */ "predicate ::= expr_or_subquery IS NULL", - /* 439 */ "predicate ::= expr_or_subquery IS NOT NULL", - /* 440 */ "predicate ::= expr_or_subquery in_op in_predicate_value", - /* 441 */ "compare_op ::= NK_LT", - /* 442 */ "compare_op ::= NK_GT", - /* 443 */ "compare_op ::= NK_LE", - /* 444 */ "compare_op ::= NK_GE", - /* 445 */ "compare_op ::= NK_NE", - /* 446 */ "compare_op ::= NK_EQ", - /* 447 */ "compare_op ::= LIKE", - /* 448 */ "compare_op ::= NOT LIKE", - /* 449 */ "compare_op ::= MATCH", - /* 450 */ "compare_op ::= NMATCH", - /* 451 */ "compare_op ::= CONTAINS", - /* 452 */ "in_op ::= IN", - /* 453 */ "in_op ::= NOT IN", - /* 454 */ "in_predicate_value ::= NK_LP literal_list NK_RP", - /* 455 */ "boolean_value_expression ::= boolean_primary", - /* 456 */ "boolean_value_expression ::= NOT boolean_primary", - /* 457 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression", - /* 458 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression", - /* 459 */ "boolean_primary ::= predicate", - /* 460 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP", - /* 461 */ "common_expression ::= expr_or_subquery", - /* 462 */ "common_expression ::= boolean_value_expression", - /* 463 */ "from_clause_opt ::=", - /* 464 */ "from_clause_opt ::= FROM table_reference_list", - /* 465 */ "table_reference_list ::= table_reference", - /* 466 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference", - /* 467 */ "table_reference ::= table_primary", - /* 468 */ "table_reference ::= joined_table", - /* 469 */ "table_primary ::= table_name alias_opt", - /* 470 */ "table_primary ::= db_name NK_DOT table_name alias_opt", - /* 471 */ "table_primary ::= subquery alias_opt", - /* 472 */ "table_primary ::= parenthesized_joined_table", - /* 473 */ "alias_opt ::=", - /* 474 */ "alias_opt ::= table_alias", - /* 475 */ "alias_opt ::= AS table_alias", - /* 476 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP", - /* 477 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP", - /* 478 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition", - /* 479 */ "join_type ::=", - /* 480 */ "join_type ::= INNER", - /* 481 */ "query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt", - /* 482 */ "set_quantifier_opt ::=", - /* 483 */ "set_quantifier_opt ::= DISTINCT", - /* 484 */ "set_quantifier_opt ::= ALL", - /* 485 */ "select_list ::= select_item", - /* 486 */ "select_list ::= select_list NK_COMMA select_item", - /* 487 */ "select_item ::= NK_STAR", - /* 488 */ "select_item ::= common_expression", - /* 489 */ "select_item ::= common_expression column_alias", - /* 490 */ "select_item ::= common_expression AS column_alias", - /* 491 */ "select_item ::= table_name NK_DOT NK_STAR", - /* 492 */ "where_clause_opt ::=", - /* 493 */ "where_clause_opt ::= WHERE search_condition", - /* 494 */ "partition_by_clause_opt ::=", - /* 495 */ "partition_by_clause_opt ::= PARTITION BY partition_list", - /* 496 */ "partition_list ::= partition_item", - /* 497 */ "partition_list ::= partition_list NK_COMMA partition_item", - /* 498 */ "partition_item ::= expr_or_subquery", - /* 499 */ "partition_item ::= expr_or_subquery column_alias", - /* 500 */ "partition_item ::= expr_or_subquery AS column_alias", - /* 501 */ "twindow_clause_opt ::=", - /* 502 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP", - /* 503 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP", - /* 504 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt", - /* 505 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt", - /* 506 */ "twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition", - /* 507 */ "sliding_opt ::=", - /* 508 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP", - /* 509 */ "fill_opt ::=", - /* 510 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", - /* 511 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP", - /* 512 */ "fill_opt ::= FILL NK_LP VALUE_F NK_COMMA literal_list NK_RP", - /* 513 */ "fill_mode ::= NONE", - /* 514 */ "fill_mode ::= PREV", - /* 515 */ "fill_mode ::= NULL", - /* 516 */ "fill_mode ::= NULL_F", - /* 517 */ "fill_mode ::= LINEAR", - /* 518 */ "fill_mode ::= NEXT", - /* 519 */ "group_by_clause_opt ::=", - /* 520 */ "group_by_clause_opt ::= GROUP BY group_by_list", - /* 521 */ "group_by_list ::= expr_or_subquery", - /* 522 */ "group_by_list ::= group_by_list NK_COMMA expr_or_subquery", - /* 523 */ "having_clause_opt ::=", - /* 524 */ "having_clause_opt ::= HAVING search_condition", - /* 525 */ "range_opt ::=", - /* 526 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP", - /* 527 */ "every_opt ::=", - /* 528 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP", - /* 529 */ "query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt", - /* 530 */ "query_simple ::= query_specification", - /* 531 */ "query_simple ::= union_query_expression", - /* 532 */ "union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery", - /* 533 */ "union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery", - /* 534 */ "query_simple_or_subquery ::= query_simple", - /* 535 */ "query_simple_or_subquery ::= subquery", - /* 536 */ "query_or_subquery ::= query_expression", - /* 537 */ "query_or_subquery ::= subquery", - /* 538 */ "order_by_clause_opt ::=", - /* 539 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", - /* 540 */ "slimit_clause_opt ::=", - /* 541 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", - /* 542 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", - /* 543 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 544 */ "limit_clause_opt ::=", - /* 545 */ "limit_clause_opt ::= LIMIT NK_INTEGER", - /* 546 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", - /* 547 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 548 */ "subquery ::= NK_LP query_expression NK_RP", - /* 549 */ "subquery ::= NK_LP subquery NK_RP", - /* 550 */ "search_condition ::= common_expression", - /* 551 */ "sort_specification_list ::= sort_specification", - /* 552 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", - /* 553 */ "sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt", - /* 554 */ "ordering_specification_opt ::=", - /* 555 */ "ordering_specification_opt ::= ASC", - /* 556 */ "ordering_specification_opt ::= DESC", - /* 557 */ "null_ordering_opt ::=", - /* 558 */ "null_ordering_opt ::= NULLS FIRST", - /* 559 */ "null_ordering_opt ::= NULLS LAST", + /* 72 */ "cmd ::= COMPACT DATABASE db_name", + /* 73 */ "not_exists_opt ::= IF NOT EXISTS", + /* 74 */ "not_exists_opt ::=", + /* 75 */ "exists_opt ::= IF EXISTS", + /* 76 */ "exists_opt ::=", + /* 77 */ "db_options ::=", + /* 78 */ "db_options ::= db_options BUFFER NK_INTEGER", + /* 79 */ "db_options ::= db_options CACHEMODEL NK_STRING", + /* 80 */ "db_options ::= db_options CACHESIZE NK_INTEGER", + /* 81 */ "db_options ::= db_options COMP NK_INTEGER", + /* 82 */ "db_options ::= db_options DURATION NK_INTEGER", + /* 83 */ "db_options ::= db_options DURATION NK_VARIABLE", + /* 84 */ "db_options ::= db_options MAXROWS NK_INTEGER", + /* 85 */ "db_options ::= db_options MINROWS NK_INTEGER", + /* 86 */ "db_options ::= db_options KEEP integer_list", + /* 87 */ "db_options ::= db_options KEEP variable_list", + /* 88 */ "db_options ::= db_options PAGES NK_INTEGER", + /* 89 */ "db_options ::= db_options PAGESIZE NK_INTEGER", + /* 90 */ "db_options ::= db_options TSDB_PAGESIZE NK_INTEGER", + /* 91 */ "db_options ::= db_options PRECISION NK_STRING", + /* 92 */ "db_options ::= db_options REPLICA NK_INTEGER", + /* 93 */ "db_options ::= db_options VGROUPS NK_INTEGER", + /* 94 */ "db_options ::= db_options SINGLE_STABLE NK_INTEGER", + /* 95 */ "db_options ::= db_options RETENTIONS retention_list", + /* 96 */ "db_options ::= db_options SCHEMALESS NK_INTEGER", + /* 97 */ "db_options ::= db_options WAL_LEVEL NK_INTEGER", + /* 98 */ "db_options ::= db_options WAL_FSYNC_PERIOD NK_INTEGER", + /* 99 */ "db_options ::= db_options WAL_RETENTION_PERIOD NK_INTEGER", + /* 100 */ "db_options ::= db_options WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER", + /* 101 */ "db_options ::= db_options WAL_RETENTION_SIZE NK_INTEGER", + /* 102 */ "db_options ::= db_options WAL_RETENTION_SIZE NK_MINUS NK_INTEGER", + /* 103 */ "db_options ::= db_options WAL_ROLL_PERIOD NK_INTEGER", + /* 104 */ "db_options ::= db_options WAL_SEGMENT_SIZE NK_INTEGER", + /* 105 */ "db_options ::= db_options STT_TRIGGER NK_INTEGER", + /* 106 */ "db_options ::= db_options TABLE_PREFIX NK_INTEGER", + /* 107 */ "db_options ::= db_options TABLE_SUFFIX NK_INTEGER", + /* 108 */ "alter_db_options ::= alter_db_option", + /* 109 */ "alter_db_options ::= alter_db_options alter_db_option", + /* 110 */ "alter_db_option ::= BUFFER NK_INTEGER", + /* 111 */ "alter_db_option ::= CACHEMODEL NK_STRING", + /* 112 */ "alter_db_option ::= CACHESIZE NK_INTEGER", + /* 113 */ "alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER", + /* 114 */ "alter_db_option ::= KEEP integer_list", + /* 115 */ "alter_db_option ::= KEEP variable_list", + /* 116 */ "alter_db_option ::= PAGES NK_INTEGER", + /* 117 */ "alter_db_option ::= REPLICA NK_INTEGER", + /* 118 */ "alter_db_option ::= WAL_LEVEL NK_INTEGER", + /* 119 */ "alter_db_option ::= STT_TRIGGER NK_INTEGER", + /* 120 */ "integer_list ::= NK_INTEGER", + /* 121 */ "integer_list ::= integer_list NK_COMMA NK_INTEGER", + /* 122 */ "variable_list ::= NK_VARIABLE", + /* 123 */ "variable_list ::= variable_list NK_COMMA NK_VARIABLE", + /* 124 */ "retention_list ::= retention", + /* 125 */ "retention_list ::= retention_list NK_COMMA retention", + /* 126 */ "retention ::= NK_VARIABLE NK_COLON NK_VARIABLE", + /* 127 */ "speed_opt ::=", + /* 128 */ "speed_opt ::= MAX_SPEED NK_INTEGER", + /* 129 */ "cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options", + /* 130 */ "cmd ::= CREATE TABLE multi_create_clause", + /* 131 */ "cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options", + /* 132 */ "cmd ::= DROP TABLE multi_drop_clause", + /* 133 */ "cmd ::= DROP STABLE exists_opt full_table_name", + /* 134 */ "cmd ::= ALTER TABLE alter_table_clause", + /* 135 */ "cmd ::= ALTER STABLE alter_table_clause", + /* 136 */ "alter_table_clause ::= full_table_name alter_table_options", + /* 137 */ "alter_table_clause ::= full_table_name ADD COLUMN column_name type_name", + /* 138 */ "alter_table_clause ::= full_table_name DROP COLUMN column_name", + /* 139 */ "alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name", + /* 140 */ "alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name", + /* 141 */ "alter_table_clause ::= full_table_name ADD TAG column_name type_name", + /* 142 */ "alter_table_clause ::= full_table_name DROP TAG column_name", + /* 143 */ "alter_table_clause ::= full_table_name MODIFY TAG column_name type_name", + /* 144 */ "alter_table_clause ::= full_table_name RENAME TAG column_name column_name", + /* 145 */ "alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal", + /* 146 */ "multi_create_clause ::= create_subtable_clause", + /* 147 */ "multi_create_clause ::= multi_create_clause create_subtable_clause", + /* 148 */ "create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP expression_list NK_RP table_options", + /* 149 */ "multi_drop_clause ::= drop_table_clause", + /* 150 */ "multi_drop_clause ::= multi_drop_clause drop_table_clause", + /* 151 */ "drop_table_clause ::= exists_opt full_table_name", + /* 152 */ "specific_cols_opt ::=", + /* 153 */ "specific_cols_opt ::= NK_LP col_name_list NK_RP", + /* 154 */ "full_table_name ::= table_name", + /* 155 */ "full_table_name ::= db_name NK_DOT table_name", + /* 156 */ "column_def_list ::= column_def", + /* 157 */ "column_def_list ::= column_def_list NK_COMMA column_def", + /* 158 */ "column_def ::= column_name type_name", + /* 159 */ "column_def ::= column_name type_name COMMENT NK_STRING", + /* 160 */ "type_name ::= BOOL", + /* 161 */ "type_name ::= TINYINT", + /* 162 */ "type_name ::= SMALLINT", + /* 163 */ "type_name ::= INT", + /* 164 */ "type_name ::= INTEGER", + /* 165 */ "type_name ::= BIGINT", + /* 166 */ "type_name ::= FLOAT", + /* 167 */ "type_name ::= DOUBLE", + /* 168 */ "type_name ::= BINARY NK_LP NK_INTEGER NK_RP", + /* 169 */ "type_name ::= TIMESTAMP", + /* 170 */ "type_name ::= NCHAR NK_LP NK_INTEGER NK_RP", + /* 171 */ "type_name ::= TINYINT UNSIGNED", + /* 172 */ "type_name ::= SMALLINT UNSIGNED", + /* 173 */ "type_name ::= INT UNSIGNED", + /* 174 */ "type_name ::= BIGINT UNSIGNED", + /* 175 */ "type_name ::= JSON", + /* 176 */ "type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP", + /* 177 */ "type_name ::= MEDIUMBLOB", + /* 178 */ "type_name ::= BLOB", + /* 179 */ "type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP", + /* 180 */ "type_name ::= DECIMAL", + /* 181 */ "type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP", + /* 182 */ "type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP", + /* 183 */ "tags_def_opt ::=", + /* 184 */ "tags_def_opt ::= tags_def", + /* 185 */ "tags_def ::= TAGS NK_LP column_def_list NK_RP", + /* 186 */ "table_options ::=", + /* 187 */ "table_options ::= table_options COMMENT NK_STRING", + /* 188 */ "table_options ::= table_options MAX_DELAY duration_list", + /* 189 */ "table_options ::= table_options WATERMARK duration_list", + /* 190 */ "table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP", + /* 191 */ "table_options ::= table_options TTL NK_INTEGER", + /* 192 */ "table_options ::= table_options SMA NK_LP col_name_list NK_RP", + /* 193 */ "table_options ::= table_options DELETE_MARK duration_list", + /* 194 */ "alter_table_options ::= alter_table_option", + /* 195 */ "alter_table_options ::= alter_table_options alter_table_option", + /* 196 */ "alter_table_option ::= COMMENT NK_STRING", + /* 197 */ "alter_table_option ::= TTL NK_INTEGER", + /* 198 */ "duration_list ::= duration_literal", + /* 199 */ "duration_list ::= duration_list NK_COMMA duration_literal", + /* 200 */ "rollup_func_list ::= rollup_func_name", + /* 201 */ "rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name", + /* 202 */ "rollup_func_name ::= function_name", + /* 203 */ "rollup_func_name ::= FIRST", + /* 204 */ "rollup_func_name ::= LAST", + /* 205 */ "col_name_list ::= col_name", + /* 206 */ "col_name_list ::= col_name_list NK_COMMA col_name", + /* 207 */ "col_name ::= column_name", + /* 208 */ "cmd ::= SHOW DNODES", + /* 209 */ "cmd ::= SHOW USERS", + /* 210 */ "cmd ::= SHOW USER PRIVILEGES", + /* 211 */ "cmd ::= SHOW DATABASES", + /* 212 */ "cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt", + /* 213 */ "cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt", + /* 214 */ "cmd ::= SHOW db_name_cond_opt VGROUPS", + /* 215 */ "cmd ::= SHOW MNODES", + /* 216 */ "cmd ::= SHOW QNODES", + /* 217 */ "cmd ::= SHOW FUNCTIONS", + /* 218 */ "cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt", + /* 219 */ "cmd ::= SHOW STREAMS", + /* 220 */ "cmd ::= SHOW ACCOUNTS", + /* 221 */ "cmd ::= SHOW APPS", + /* 222 */ "cmd ::= SHOW CONNECTIONS", + /* 223 */ "cmd ::= SHOW LICENCES", + /* 224 */ "cmd ::= SHOW GRANTS", + /* 225 */ "cmd ::= SHOW CREATE DATABASE db_name", + /* 226 */ "cmd ::= SHOW CREATE TABLE full_table_name", + /* 227 */ "cmd ::= SHOW CREATE STABLE full_table_name", + /* 228 */ "cmd ::= SHOW QUERIES", + /* 229 */ "cmd ::= SHOW SCORES", + /* 230 */ "cmd ::= SHOW TOPICS", + /* 231 */ "cmd ::= SHOW VARIABLES", + /* 232 */ "cmd ::= SHOW CLUSTER VARIABLES", + /* 233 */ "cmd ::= SHOW LOCAL VARIABLES", + /* 234 */ "cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt", + /* 235 */ "cmd ::= SHOW BNODES", + /* 236 */ "cmd ::= SHOW SNODES", + /* 237 */ "cmd ::= SHOW CLUSTER", + /* 238 */ "cmd ::= SHOW TRANSACTIONS", + /* 239 */ "cmd ::= SHOW TABLE DISTRIBUTED full_table_name", + /* 240 */ "cmd ::= SHOW CONSUMERS", + /* 241 */ "cmd ::= SHOW SUBSCRIPTIONS", + /* 242 */ "cmd ::= SHOW TAGS FROM table_name_cond from_db_opt", + /* 243 */ "cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt", + /* 244 */ "cmd ::= SHOW VNODES NK_INTEGER", + /* 245 */ "cmd ::= SHOW VNODES NK_STRING", + /* 246 */ "cmd ::= SHOW db_name_cond_opt ALIVE", + /* 247 */ "cmd ::= SHOW CLUSTER ALIVE", + /* 248 */ "db_name_cond_opt ::=", + /* 249 */ "db_name_cond_opt ::= db_name NK_DOT", + /* 250 */ "like_pattern_opt ::=", + /* 251 */ "like_pattern_opt ::= LIKE NK_STRING", + /* 252 */ "table_name_cond ::= table_name", + /* 253 */ "from_db_opt ::=", + /* 254 */ "from_db_opt ::= FROM db_name", + /* 255 */ "tag_list_opt ::=", + /* 256 */ "tag_list_opt ::= tag_item", + /* 257 */ "tag_list_opt ::= tag_list_opt NK_COMMA tag_item", + /* 258 */ "tag_item ::= TBNAME", + /* 259 */ "tag_item ::= QTAGS", + /* 260 */ "tag_item ::= column_name", + /* 261 */ "tag_item ::= column_name column_alias", + /* 262 */ "tag_item ::= column_name AS column_alias", + /* 263 */ "cmd ::= CREATE SMA INDEX not_exists_opt full_index_name ON full_table_name index_options", + /* 264 */ "cmd ::= CREATE INDEX not_exists_opt full_index_name ON full_table_name NK_LP col_name_list NK_RP", + /* 265 */ "cmd ::= DROP INDEX exists_opt full_index_name", + /* 266 */ "full_index_name ::= index_name", + /* 267 */ "full_index_name ::= db_name NK_DOT index_name", + /* 268 */ "index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt", + /* 269 */ "index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt", + /* 270 */ "func_list ::= func", + /* 271 */ "func_list ::= func_list NK_COMMA func", + /* 272 */ "func ::= sma_func_name NK_LP expression_list NK_RP", + /* 273 */ "sma_func_name ::= function_name", + /* 274 */ "sma_func_name ::= COUNT", + /* 275 */ "sma_func_name ::= FIRST", + /* 276 */ "sma_func_name ::= LAST", + /* 277 */ "sma_func_name ::= LAST_ROW", + /* 278 */ "sma_stream_opt ::=", + /* 279 */ "sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal", + /* 280 */ "sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal", + /* 281 */ "sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal", + /* 282 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery", + /* 283 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name", + /* 284 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS DATABASE db_name", + /* 285 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name", + /* 286 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS STABLE full_table_name", + /* 287 */ "cmd ::= DROP TOPIC exists_opt topic_name", + /* 288 */ "cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name", + /* 289 */ "cmd ::= DESC full_table_name", + /* 290 */ "cmd ::= DESCRIBE full_table_name", + /* 291 */ "cmd ::= RESET QUERY CACHE", + /* 292 */ "cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery", + /* 293 */ "cmd ::= EXPLAIN analyze_opt explain_options insert_query", + /* 294 */ "analyze_opt ::=", + /* 295 */ "analyze_opt ::= ANALYZE", + /* 296 */ "explain_options ::=", + /* 297 */ "explain_options ::= explain_options VERBOSE NK_BOOL", + /* 298 */ "explain_options ::= explain_options RATIO NK_FLOAT", + /* 299 */ "cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt", + /* 300 */ "cmd ::= DROP FUNCTION exists_opt function_name", + /* 301 */ "agg_func_opt ::=", + /* 302 */ "agg_func_opt ::= AGGREGATE", + /* 303 */ "bufsize_opt ::=", + /* 304 */ "bufsize_opt ::= BUFSIZE NK_INTEGER", + /* 305 */ "cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery", + /* 306 */ "cmd ::= DROP STREAM exists_opt stream_name", + /* 307 */ "col_list_opt ::=", + /* 308 */ "col_list_opt ::= NK_LP col_name_list NK_RP", + /* 309 */ "tag_def_or_ref_opt ::=", + /* 310 */ "tag_def_or_ref_opt ::= tags_def", + /* 311 */ "tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP", + /* 312 */ "stream_options ::=", + /* 313 */ "stream_options ::= stream_options TRIGGER AT_ONCE", + /* 314 */ "stream_options ::= stream_options TRIGGER WINDOW_CLOSE", + /* 315 */ "stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal", + /* 316 */ "stream_options ::= stream_options WATERMARK duration_literal", + /* 317 */ "stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER", + /* 318 */ "stream_options ::= stream_options FILL_HISTORY NK_INTEGER", + /* 319 */ "subtable_opt ::=", + /* 320 */ "subtable_opt ::= SUBTABLE NK_LP expression NK_RP", + /* 321 */ "cmd ::= KILL CONNECTION NK_INTEGER", + /* 322 */ "cmd ::= KILL QUERY NK_STRING", + /* 323 */ "cmd ::= KILL TRANSACTION NK_INTEGER", + /* 324 */ "cmd ::= BALANCE VGROUP", + /* 325 */ "cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER", + /* 326 */ "cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list", + /* 327 */ "cmd ::= SPLIT VGROUP NK_INTEGER", + /* 328 */ "dnode_list ::= DNODE NK_INTEGER", + /* 329 */ "dnode_list ::= dnode_list DNODE NK_INTEGER", + /* 330 */ "cmd ::= DELETE FROM full_table_name where_clause_opt", + /* 331 */ "cmd ::= query_or_subquery", + /* 332 */ "cmd ::= insert_query", + /* 333 */ "insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery", + /* 334 */ "insert_query ::= INSERT INTO full_table_name query_or_subquery", + /* 335 */ "literal ::= NK_INTEGER", + /* 336 */ "literal ::= NK_FLOAT", + /* 337 */ "literal ::= NK_STRING", + /* 338 */ "literal ::= NK_BOOL", + /* 339 */ "literal ::= TIMESTAMP NK_STRING", + /* 340 */ "literal ::= duration_literal", + /* 341 */ "literal ::= NULL", + /* 342 */ "literal ::= NK_QUESTION", + /* 343 */ "duration_literal ::= NK_VARIABLE", + /* 344 */ "signed ::= NK_INTEGER", + /* 345 */ "signed ::= NK_PLUS NK_INTEGER", + /* 346 */ "signed ::= NK_MINUS NK_INTEGER", + /* 347 */ "signed ::= NK_FLOAT", + /* 348 */ "signed ::= NK_PLUS NK_FLOAT", + /* 349 */ "signed ::= NK_MINUS NK_FLOAT", + /* 350 */ "signed_literal ::= signed", + /* 351 */ "signed_literal ::= NK_STRING", + /* 352 */ "signed_literal ::= NK_BOOL", + /* 353 */ "signed_literal ::= TIMESTAMP NK_STRING", + /* 354 */ "signed_literal ::= duration_literal", + /* 355 */ "signed_literal ::= NULL", + /* 356 */ "signed_literal ::= literal_func", + /* 357 */ "signed_literal ::= NK_QUESTION", + /* 358 */ "literal_list ::= signed_literal", + /* 359 */ "literal_list ::= literal_list NK_COMMA signed_literal", + /* 360 */ "db_name ::= NK_ID", + /* 361 */ "table_name ::= NK_ID", + /* 362 */ "column_name ::= NK_ID", + /* 363 */ "function_name ::= NK_ID", + /* 364 */ "table_alias ::= NK_ID", + /* 365 */ "column_alias ::= NK_ID", + /* 366 */ "user_name ::= NK_ID", + /* 367 */ "topic_name ::= NK_ID", + /* 368 */ "stream_name ::= NK_ID", + /* 369 */ "cgroup_name ::= NK_ID", + /* 370 */ "index_name ::= NK_ID", + /* 371 */ "expr_or_subquery ::= expression", + /* 372 */ "expression ::= literal", + /* 373 */ "expression ::= pseudo_column", + /* 374 */ "expression ::= column_reference", + /* 375 */ "expression ::= function_expression", + /* 376 */ "expression ::= case_when_expression", + /* 377 */ "expression ::= NK_LP expression NK_RP", + /* 378 */ "expression ::= NK_PLUS expr_or_subquery", + /* 379 */ "expression ::= NK_MINUS expr_or_subquery", + /* 380 */ "expression ::= expr_or_subquery NK_PLUS expr_or_subquery", + /* 381 */ "expression ::= expr_or_subquery NK_MINUS expr_or_subquery", + /* 382 */ "expression ::= expr_or_subquery NK_STAR expr_or_subquery", + /* 383 */ "expression ::= expr_or_subquery NK_SLASH expr_or_subquery", + /* 384 */ "expression ::= expr_or_subquery NK_REM expr_or_subquery", + /* 385 */ "expression ::= column_reference NK_ARROW NK_STRING", + /* 386 */ "expression ::= expr_or_subquery NK_BITAND expr_or_subquery", + /* 387 */ "expression ::= expr_or_subquery NK_BITOR expr_or_subquery", + /* 388 */ "expression_list ::= expr_or_subquery", + /* 389 */ "expression_list ::= expression_list NK_COMMA expr_or_subquery", + /* 390 */ "column_reference ::= column_name", + /* 391 */ "column_reference ::= table_name NK_DOT column_name", + /* 392 */ "pseudo_column ::= ROWTS", + /* 393 */ "pseudo_column ::= TBNAME", + /* 394 */ "pseudo_column ::= table_name NK_DOT TBNAME", + /* 395 */ "pseudo_column ::= QSTART", + /* 396 */ "pseudo_column ::= QEND", + /* 397 */ "pseudo_column ::= QDURATION", + /* 398 */ "pseudo_column ::= WSTART", + /* 399 */ "pseudo_column ::= WEND", + /* 400 */ "pseudo_column ::= WDURATION", + /* 401 */ "pseudo_column ::= IROWTS", + /* 402 */ "pseudo_column ::= ISFILLED", + /* 403 */ "pseudo_column ::= QTAGS", + /* 404 */ "function_expression ::= function_name NK_LP expression_list NK_RP", + /* 405 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP", + /* 406 */ "function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP", + /* 407 */ "function_expression ::= literal_func", + /* 408 */ "literal_func ::= noarg_func NK_LP NK_RP", + /* 409 */ "literal_func ::= NOW", + /* 410 */ "noarg_func ::= NOW", + /* 411 */ "noarg_func ::= TODAY", + /* 412 */ "noarg_func ::= TIMEZONE", + /* 413 */ "noarg_func ::= DATABASE", + /* 414 */ "noarg_func ::= CLIENT_VERSION", + /* 415 */ "noarg_func ::= SERVER_VERSION", + /* 416 */ "noarg_func ::= SERVER_STATUS", + /* 417 */ "noarg_func ::= CURRENT_USER", + /* 418 */ "noarg_func ::= USER", + /* 419 */ "star_func ::= COUNT", + /* 420 */ "star_func ::= FIRST", + /* 421 */ "star_func ::= LAST", + /* 422 */ "star_func ::= LAST_ROW", + /* 423 */ "star_func_para_list ::= NK_STAR", + /* 424 */ "star_func_para_list ::= other_para_list", + /* 425 */ "other_para_list ::= star_func_para", + /* 426 */ "other_para_list ::= other_para_list NK_COMMA star_func_para", + /* 427 */ "star_func_para ::= expr_or_subquery", + /* 428 */ "star_func_para ::= table_name NK_DOT NK_STAR", + /* 429 */ "case_when_expression ::= CASE when_then_list case_when_else_opt END", + /* 430 */ "case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END", + /* 431 */ "when_then_list ::= when_then_expr", + /* 432 */ "when_then_list ::= when_then_list when_then_expr", + /* 433 */ "when_then_expr ::= WHEN common_expression THEN common_expression", + /* 434 */ "case_when_else_opt ::=", + /* 435 */ "case_when_else_opt ::= ELSE common_expression", + /* 436 */ "predicate ::= expr_or_subquery compare_op expr_or_subquery", + /* 437 */ "predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery", + /* 438 */ "predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery", + /* 439 */ "predicate ::= expr_or_subquery IS NULL", + /* 440 */ "predicate ::= expr_or_subquery IS NOT NULL", + /* 441 */ "predicate ::= expr_or_subquery in_op in_predicate_value", + /* 442 */ "compare_op ::= NK_LT", + /* 443 */ "compare_op ::= NK_GT", + /* 444 */ "compare_op ::= NK_LE", + /* 445 */ "compare_op ::= NK_GE", + /* 446 */ "compare_op ::= NK_NE", + /* 447 */ "compare_op ::= NK_EQ", + /* 448 */ "compare_op ::= LIKE", + /* 449 */ "compare_op ::= NOT LIKE", + /* 450 */ "compare_op ::= MATCH", + /* 451 */ "compare_op ::= NMATCH", + /* 452 */ "compare_op ::= CONTAINS", + /* 453 */ "in_op ::= IN", + /* 454 */ "in_op ::= NOT IN", + /* 455 */ "in_predicate_value ::= NK_LP literal_list NK_RP", + /* 456 */ "boolean_value_expression ::= boolean_primary", + /* 457 */ "boolean_value_expression ::= NOT boolean_primary", + /* 458 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression", + /* 459 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression", + /* 460 */ "boolean_primary ::= predicate", + /* 461 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP", + /* 462 */ "common_expression ::= expr_or_subquery", + /* 463 */ "common_expression ::= boolean_value_expression", + /* 464 */ "from_clause_opt ::=", + /* 465 */ "from_clause_opt ::= FROM table_reference_list", + /* 466 */ "table_reference_list ::= table_reference", + /* 467 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference", + /* 468 */ "table_reference ::= table_primary", + /* 469 */ "table_reference ::= joined_table", + /* 470 */ "table_primary ::= table_name alias_opt", + /* 471 */ "table_primary ::= db_name NK_DOT table_name alias_opt", + /* 472 */ "table_primary ::= subquery alias_opt", + /* 473 */ "table_primary ::= parenthesized_joined_table", + /* 474 */ "alias_opt ::=", + /* 475 */ "alias_opt ::= table_alias", + /* 476 */ "alias_opt ::= AS table_alias", + /* 477 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP", + /* 478 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP", + /* 479 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition", + /* 480 */ "join_type ::=", + /* 481 */ "join_type ::= INNER", + /* 482 */ "query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt", + /* 483 */ "set_quantifier_opt ::=", + /* 484 */ "set_quantifier_opt ::= DISTINCT", + /* 485 */ "set_quantifier_opt ::= ALL", + /* 486 */ "select_list ::= select_item", + /* 487 */ "select_list ::= select_list NK_COMMA select_item", + /* 488 */ "select_item ::= NK_STAR", + /* 489 */ "select_item ::= common_expression", + /* 490 */ "select_item ::= common_expression column_alias", + /* 491 */ "select_item ::= common_expression AS column_alias", + /* 492 */ "select_item ::= table_name NK_DOT NK_STAR", + /* 493 */ "where_clause_opt ::=", + /* 494 */ "where_clause_opt ::= WHERE search_condition", + /* 495 */ "partition_by_clause_opt ::=", + /* 496 */ "partition_by_clause_opt ::= PARTITION BY partition_list", + /* 497 */ "partition_list ::= partition_item", + /* 498 */ "partition_list ::= partition_list NK_COMMA partition_item", + /* 499 */ "partition_item ::= expr_or_subquery", + /* 500 */ "partition_item ::= expr_or_subquery column_alias", + /* 501 */ "partition_item ::= expr_or_subquery AS column_alias", + /* 502 */ "twindow_clause_opt ::=", + /* 503 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP", + /* 504 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP", + /* 505 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt", + /* 506 */ "twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt", + /* 507 */ "twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition", + /* 508 */ "sliding_opt ::=", + /* 509 */ "sliding_opt ::= SLIDING NK_LP duration_literal NK_RP", + /* 510 */ "fill_opt ::=", + /* 511 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", + /* 512 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP", + /* 513 */ "fill_opt ::= FILL NK_LP VALUE_F NK_COMMA literal_list NK_RP", + /* 514 */ "fill_mode ::= NONE", + /* 515 */ "fill_mode ::= PREV", + /* 516 */ "fill_mode ::= NULL", + /* 517 */ "fill_mode ::= NULL_F", + /* 518 */ "fill_mode ::= LINEAR", + /* 519 */ "fill_mode ::= NEXT", + /* 520 */ "group_by_clause_opt ::=", + /* 521 */ "group_by_clause_opt ::= GROUP BY group_by_list", + /* 522 */ "group_by_list ::= expr_or_subquery", + /* 523 */ "group_by_list ::= group_by_list NK_COMMA expr_or_subquery", + /* 524 */ "having_clause_opt ::=", + /* 525 */ "having_clause_opt ::= HAVING search_condition", + /* 526 */ "range_opt ::=", + /* 527 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP", + /* 528 */ "every_opt ::=", + /* 529 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP", + /* 530 */ "query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt", + /* 531 */ "query_simple ::= query_specification", + /* 532 */ "query_simple ::= union_query_expression", + /* 533 */ "union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery", + /* 534 */ "union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery", + /* 535 */ "query_simple_or_subquery ::= query_simple", + /* 536 */ "query_simple_or_subquery ::= subquery", + /* 537 */ "query_or_subquery ::= query_expression", + /* 538 */ "query_or_subquery ::= subquery", + /* 539 */ "order_by_clause_opt ::=", + /* 540 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", + /* 541 */ "slimit_clause_opt ::=", + /* 542 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", + /* 543 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", + /* 544 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 545 */ "limit_clause_opt ::=", + /* 546 */ "limit_clause_opt ::= LIMIT NK_INTEGER", + /* 547 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", + /* 548 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 549 */ "subquery ::= NK_LP query_expression NK_RP", + /* 550 */ "subquery ::= NK_LP subquery NK_RP", + /* 551 */ "search_condition ::= common_expression", + /* 552 */ "sort_specification_list ::= sort_specification", + /* 553 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", + /* 554 */ "sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt", + /* 555 */ "ordering_specification_opt ::=", + /* 556 */ "ordering_specification_opt ::= ASC", + /* 557 */ "ordering_specification_opt ::= DESC", + /* 558 */ "null_ordering_opt ::=", + /* 559 */ "null_ordering_opt ::= NULLS FIRST", + /* 560 */ "null_ordering_opt ::= NULLS LAST", }; #endif /* NDEBUG */ @@ -3138,494 +3139,495 @@ static const struct { { 328, -4 }, /* (69) cmd ::= ALTER DATABASE db_name alter_db_options */ { 328, -3 }, /* (70) cmd ::= FLUSH DATABASE db_name */ { 328, -4 }, /* (71) cmd ::= TRIM DATABASE db_name speed_opt */ - { 343, -3 }, /* (72) not_exists_opt ::= IF NOT EXISTS */ - { 343, 0 }, /* (73) not_exists_opt ::= */ - { 345, -2 }, /* (74) exists_opt ::= IF EXISTS */ - { 345, 0 }, /* (75) exists_opt ::= */ - { 344, 0 }, /* (76) db_options ::= */ - { 344, -3 }, /* (77) db_options ::= db_options BUFFER NK_INTEGER */ - { 344, -3 }, /* (78) db_options ::= db_options CACHEMODEL NK_STRING */ - { 344, -3 }, /* (79) db_options ::= db_options CACHESIZE NK_INTEGER */ - { 344, -3 }, /* (80) db_options ::= db_options COMP NK_INTEGER */ - { 344, -3 }, /* (81) db_options ::= db_options DURATION NK_INTEGER */ - { 344, -3 }, /* (82) db_options ::= db_options DURATION NK_VARIABLE */ - { 344, -3 }, /* (83) db_options ::= db_options MAXROWS NK_INTEGER */ - { 344, -3 }, /* (84) db_options ::= db_options MINROWS NK_INTEGER */ - { 344, -3 }, /* (85) db_options ::= db_options KEEP integer_list */ - { 344, -3 }, /* (86) db_options ::= db_options KEEP variable_list */ - { 344, -3 }, /* (87) db_options ::= db_options PAGES NK_INTEGER */ - { 344, -3 }, /* (88) db_options ::= db_options PAGESIZE NK_INTEGER */ - { 344, -3 }, /* (89) db_options ::= db_options TSDB_PAGESIZE NK_INTEGER */ - { 344, -3 }, /* (90) db_options ::= db_options PRECISION NK_STRING */ - { 344, -3 }, /* (91) db_options ::= db_options REPLICA NK_INTEGER */ - { 344, -3 }, /* (92) db_options ::= db_options VGROUPS NK_INTEGER */ - { 344, -3 }, /* (93) db_options ::= db_options SINGLE_STABLE NK_INTEGER */ - { 344, -3 }, /* (94) db_options ::= db_options RETENTIONS retention_list */ - { 344, -3 }, /* (95) db_options ::= db_options SCHEMALESS NK_INTEGER */ - { 344, -3 }, /* (96) db_options ::= db_options WAL_LEVEL NK_INTEGER */ - { 344, -3 }, /* (97) db_options ::= db_options WAL_FSYNC_PERIOD NK_INTEGER */ - { 344, -3 }, /* (98) db_options ::= db_options WAL_RETENTION_PERIOD NK_INTEGER */ - { 344, -4 }, /* (99) db_options ::= db_options WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ - { 344, -3 }, /* (100) db_options ::= db_options WAL_RETENTION_SIZE NK_INTEGER */ - { 344, -4 }, /* (101) db_options ::= db_options WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ - { 344, -3 }, /* (102) db_options ::= db_options WAL_ROLL_PERIOD NK_INTEGER */ - { 344, -3 }, /* (103) db_options ::= db_options WAL_SEGMENT_SIZE NK_INTEGER */ - { 344, -3 }, /* (104) db_options ::= db_options STT_TRIGGER NK_INTEGER */ - { 344, -3 }, /* (105) db_options ::= db_options TABLE_PREFIX NK_INTEGER */ - { 344, -3 }, /* (106) db_options ::= db_options TABLE_SUFFIX NK_INTEGER */ - { 346, -1 }, /* (107) alter_db_options ::= alter_db_option */ - { 346, -2 }, /* (108) alter_db_options ::= alter_db_options alter_db_option */ - { 351, -2 }, /* (109) alter_db_option ::= BUFFER NK_INTEGER */ - { 351, -2 }, /* (110) alter_db_option ::= CACHEMODEL NK_STRING */ - { 351, -2 }, /* (111) alter_db_option ::= CACHESIZE NK_INTEGER */ - { 351, -2 }, /* (112) alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */ - { 351, -2 }, /* (113) alter_db_option ::= KEEP integer_list */ - { 351, -2 }, /* (114) alter_db_option ::= KEEP variable_list */ - { 351, -2 }, /* (115) alter_db_option ::= PAGES NK_INTEGER */ - { 351, -2 }, /* (116) alter_db_option ::= REPLICA NK_INTEGER */ - { 351, -2 }, /* (117) alter_db_option ::= WAL_LEVEL NK_INTEGER */ - { 351, -2 }, /* (118) alter_db_option ::= STT_TRIGGER NK_INTEGER */ - { 348, -1 }, /* (119) integer_list ::= NK_INTEGER */ - { 348, -3 }, /* (120) integer_list ::= integer_list NK_COMMA NK_INTEGER */ - { 349, -1 }, /* (121) variable_list ::= NK_VARIABLE */ - { 349, -3 }, /* (122) variable_list ::= variable_list NK_COMMA NK_VARIABLE */ - { 350, -1 }, /* (123) retention_list ::= retention */ - { 350, -3 }, /* (124) retention_list ::= retention_list NK_COMMA retention */ - { 352, -3 }, /* (125) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ - { 347, 0 }, /* (126) speed_opt ::= */ - { 347, -2 }, /* (127) speed_opt ::= MAX_SPEED NK_INTEGER */ - { 328, -9 }, /* (128) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ - { 328, -3 }, /* (129) cmd ::= CREATE TABLE multi_create_clause */ - { 328, -9 }, /* (130) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ - { 328, -3 }, /* (131) cmd ::= DROP TABLE multi_drop_clause */ - { 328, -4 }, /* (132) cmd ::= DROP STABLE exists_opt full_table_name */ - { 328, -3 }, /* (133) cmd ::= ALTER TABLE alter_table_clause */ - { 328, -3 }, /* (134) cmd ::= ALTER STABLE alter_table_clause */ - { 360, -2 }, /* (135) alter_table_clause ::= full_table_name alter_table_options */ - { 360, -5 }, /* (136) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ - { 360, -4 }, /* (137) alter_table_clause ::= full_table_name DROP COLUMN column_name */ - { 360, -5 }, /* (138) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ - { 360, -5 }, /* (139) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ - { 360, -5 }, /* (140) alter_table_clause ::= full_table_name ADD TAG column_name type_name */ - { 360, -4 }, /* (141) alter_table_clause ::= full_table_name DROP TAG column_name */ - { 360, -5 }, /* (142) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ - { 360, -5 }, /* (143) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ - { 360, -6 }, /* (144) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ - { 357, -1 }, /* (145) multi_create_clause ::= create_subtable_clause */ - { 357, -2 }, /* (146) multi_create_clause ::= multi_create_clause create_subtable_clause */ - { 365, -10 }, /* (147) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP expression_list NK_RP table_options */ - { 359, -1 }, /* (148) multi_drop_clause ::= drop_table_clause */ - { 359, -2 }, /* (149) multi_drop_clause ::= multi_drop_clause drop_table_clause */ - { 368, -2 }, /* (150) drop_table_clause ::= exists_opt full_table_name */ - { 366, 0 }, /* (151) specific_cols_opt ::= */ - { 366, -3 }, /* (152) specific_cols_opt ::= NK_LP col_name_list NK_RP */ - { 353, -1 }, /* (153) full_table_name ::= table_name */ - { 353, -3 }, /* (154) full_table_name ::= db_name NK_DOT table_name */ - { 354, -1 }, /* (155) column_def_list ::= column_def */ - { 354, -3 }, /* (156) column_def_list ::= column_def_list NK_COMMA column_def */ - { 371, -2 }, /* (157) column_def ::= column_name type_name */ - { 371, -4 }, /* (158) column_def ::= column_name type_name COMMENT NK_STRING */ - { 363, -1 }, /* (159) type_name ::= BOOL */ - { 363, -1 }, /* (160) type_name ::= TINYINT */ - { 363, -1 }, /* (161) type_name ::= SMALLINT */ - { 363, -1 }, /* (162) type_name ::= INT */ - { 363, -1 }, /* (163) type_name ::= INTEGER */ - { 363, -1 }, /* (164) type_name ::= BIGINT */ - { 363, -1 }, /* (165) type_name ::= FLOAT */ - { 363, -1 }, /* (166) type_name ::= DOUBLE */ - { 363, -4 }, /* (167) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ - { 363, -1 }, /* (168) type_name ::= TIMESTAMP */ - { 363, -4 }, /* (169) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ - { 363, -2 }, /* (170) type_name ::= TINYINT UNSIGNED */ - { 363, -2 }, /* (171) type_name ::= SMALLINT UNSIGNED */ - { 363, -2 }, /* (172) type_name ::= INT UNSIGNED */ - { 363, -2 }, /* (173) type_name ::= BIGINT UNSIGNED */ - { 363, -1 }, /* (174) type_name ::= JSON */ - { 363, -4 }, /* (175) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ - { 363, -1 }, /* (176) type_name ::= MEDIUMBLOB */ - { 363, -1 }, /* (177) type_name ::= BLOB */ - { 363, -4 }, /* (178) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ - { 363, -1 }, /* (179) type_name ::= DECIMAL */ - { 363, -4 }, /* (180) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ - { 363, -6 }, /* (181) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ - { 355, 0 }, /* (182) tags_def_opt ::= */ - { 355, -1 }, /* (183) tags_def_opt ::= tags_def */ - { 358, -4 }, /* (184) tags_def ::= TAGS NK_LP column_def_list NK_RP */ - { 356, 0 }, /* (185) table_options ::= */ - { 356, -3 }, /* (186) table_options ::= table_options COMMENT NK_STRING */ - { 356, -3 }, /* (187) table_options ::= table_options MAX_DELAY duration_list */ - { 356, -3 }, /* (188) table_options ::= table_options WATERMARK duration_list */ - { 356, -5 }, /* (189) table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ - { 356, -3 }, /* (190) table_options ::= table_options TTL NK_INTEGER */ - { 356, -5 }, /* (191) table_options ::= table_options SMA NK_LP col_name_list NK_RP */ - { 356, -3 }, /* (192) table_options ::= table_options DELETE_MARK duration_list */ - { 361, -1 }, /* (193) alter_table_options ::= alter_table_option */ - { 361, -2 }, /* (194) alter_table_options ::= alter_table_options alter_table_option */ - { 374, -2 }, /* (195) alter_table_option ::= COMMENT NK_STRING */ - { 374, -2 }, /* (196) alter_table_option ::= TTL NK_INTEGER */ - { 372, -1 }, /* (197) duration_list ::= duration_literal */ - { 372, -3 }, /* (198) duration_list ::= duration_list NK_COMMA duration_literal */ - { 373, -1 }, /* (199) rollup_func_list ::= rollup_func_name */ - { 373, -3 }, /* (200) rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ - { 376, -1 }, /* (201) rollup_func_name ::= function_name */ - { 376, -1 }, /* (202) rollup_func_name ::= FIRST */ - { 376, -1 }, /* (203) rollup_func_name ::= LAST */ - { 369, -1 }, /* (204) col_name_list ::= col_name */ - { 369, -3 }, /* (205) col_name_list ::= col_name_list NK_COMMA col_name */ - { 378, -1 }, /* (206) col_name ::= column_name */ - { 328, -2 }, /* (207) cmd ::= SHOW DNODES */ - { 328, -2 }, /* (208) cmd ::= SHOW USERS */ - { 328, -3 }, /* (209) cmd ::= SHOW USER PRIVILEGES */ - { 328, -2 }, /* (210) cmd ::= SHOW DATABASES */ - { 328, -4 }, /* (211) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */ - { 328, -4 }, /* (212) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ - { 328, -3 }, /* (213) cmd ::= SHOW db_name_cond_opt VGROUPS */ - { 328, -2 }, /* (214) cmd ::= SHOW MNODES */ - { 328, -2 }, /* (215) cmd ::= SHOW QNODES */ - { 328, -2 }, /* (216) cmd ::= SHOW FUNCTIONS */ - { 328, -5 }, /* (217) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ - { 328, -2 }, /* (218) cmd ::= SHOW STREAMS */ - { 328, -2 }, /* (219) cmd ::= SHOW ACCOUNTS */ - { 328, -2 }, /* (220) cmd ::= SHOW APPS */ - { 328, -2 }, /* (221) cmd ::= SHOW CONNECTIONS */ - { 328, -2 }, /* (222) cmd ::= SHOW LICENCES */ - { 328, -2 }, /* (223) cmd ::= SHOW GRANTS */ - { 328, -4 }, /* (224) cmd ::= SHOW CREATE DATABASE db_name */ - { 328, -4 }, /* (225) cmd ::= SHOW CREATE TABLE full_table_name */ - { 328, -4 }, /* (226) cmd ::= SHOW CREATE STABLE full_table_name */ - { 328, -2 }, /* (227) cmd ::= SHOW QUERIES */ - { 328, -2 }, /* (228) cmd ::= SHOW SCORES */ - { 328, -2 }, /* (229) cmd ::= SHOW TOPICS */ - { 328, -2 }, /* (230) cmd ::= SHOW VARIABLES */ - { 328, -3 }, /* (231) cmd ::= SHOW CLUSTER VARIABLES */ - { 328, -3 }, /* (232) cmd ::= SHOW LOCAL VARIABLES */ - { 328, -5 }, /* (233) cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */ - { 328, -2 }, /* (234) cmd ::= SHOW BNODES */ - { 328, -2 }, /* (235) cmd ::= SHOW SNODES */ - { 328, -2 }, /* (236) cmd ::= SHOW CLUSTER */ - { 328, -2 }, /* (237) cmd ::= SHOW TRANSACTIONS */ - { 328, -4 }, /* (238) cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ - { 328, -2 }, /* (239) cmd ::= SHOW CONSUMERS */ - { 328, -2 }, /* (240) cmd ::= SHOW SUBSCRIPTIONS */ - { 328, -5 }, /* (241) cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ - { 328, -7 }, /* (242) cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */ - { 328, -3 }, /* (243) cmd ::= SHOW VNODES NK_INTEGER */ - { 328, -3 }, /* (244) cmd ::= SHOW VNODES NK_STRING */ - { 328, -3 }, /* (245) cmd ::= SHOW db_name_cond_opt ALIVE */ - { 328, -3 }, /* (246) cmd ::= SHOW CLUSTER ALIVE */ - { 379, 0 }, /* (247) db_name_cond_opt ::= */ - { 379, -2 }, /* (248) db_name_cond_opt ::= db_name NK_DOT */ - { 380, 0 }, /* (249) like_pattern_opt ::= */ - { 380, -2 }, /* (250) like_pattern_opt ::= LIKE NK_STRING */ - { 381, -1 }, /* (251) table_name_cond ::= table_name */ - { 382, 0 }, /* (252) from_db_opt ::= */ - { 382, -2 }, /* (253) from_db_opt ::= FROM db_name */ - { 383, 0 }, /* (254) tag_list_opt ::= */ - { 383, -1 }, /* (255) tag_list_opt ::= tag_item */ - { 383, -3 }, /* (256) tag_list_opt ::= tag_list_opt NK_COMMA tag_item */ - { 384, -1 }, /* (257) tag_item ::= TBNAME */ - { 384, -1 }, /* (258) tag_item ::= QTAGS */ - { 384, -1 }, /* (259) tag_item ::= column_name */ - { 384, -2 }, /* (260) tag_item ::= column_name column_alias */ - { 384, -3 }, /* (261) tag_item ::= column_name AS column_alias */ - { 328, -8 }, /* (262) cmd ::= CREATE SMA INDEX not_exists_opt full_index_name ON full_table_name index_options */ - { 328, -9 }, /* (263) cmd ::= CREATE INDEX not_exists_opt full_index_name ON full_table_name NK_LP col_name_list NK_RP */ - { 328, -4 }, /* (264) cmd ::= DROP INDEX exists_opt full_index_name */ - { 386, -1 }, /* (265) full_index_name ::= index_name */ - { 386, -3 }, /* (266) full_index_name ::= db_name NK_DOT index_name */ - { 387, -10 }, /* (267) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ - { 387, -12 }, /* (268) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt */ - { 389, -1 }, /* (269) func_list ::= func */ - { 389, -3 }, /* (270) func_list ::= func_list NK_COMMA func */ - { 392, -4 }, /* (271) func ::= sma_func_name NK_LP expression_list NK_RP */ - { 393, -1 }, /* (272) sma_func_name ::= function_name */ - { 393, -1 }, /* (273) sma_func_name ::= COUNT */ - { 393, -1 }, /* (274) sma_func_name ::= FIRST */ - { 393, -1 }, /* (275) sma_func_name ::= LAST */ - { 393, -1 }, /* (276) sma_func_name ::= LAST_ROW */ - { 391, 0 }, /* (277) sma_stream_opt ::= */ - { 391, -3 }, /* (278) sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */ - { 391, -3 }, /* (279) sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */ - { 391, -3 }, /* (280) sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */ - { 328, -6 }, /* (281) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */ - { 328, -7 }, /* (282) cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name */ - { 328, -9 }, /* (283) cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS DATABASE db_name */ - { 328, -7 }, /* (284) cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name */ - { 328, -9 }, /* (285) cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS STABLE full_table_name */ - { 328, -4 }, /* (286) cmd ::= DROP TOPIC exists_opt topic_name */ - { 328, -7 }, /* (287) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ - { 328, -2 }, /* (288) cmd ::= DESC full_table_name */ - { 328, -2 }, /* (289) cmd ::= DESCRIBE full_table_name */ - { 328, -3 }, /* (290) cmd ::= RESET QUERY CACHE */ - { 328, -4 }, /* (291) cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */ - { 328, -4 }, /* (292) cmd ::= EXPLAIN analyze_opt explain_options insert_query */ - { 396, 0 }, /* (293) analyze_opt ::= */ - { 396, -1 }, /* (294) analyze_opt ::= ANALYZE */ - { 397, 0 }, /* (295) explain_options ::= */ - { 397, -3 }, /* (296) explain_options ::= explain_options VERBOSE NK_BOOL */ - { 397, -3 }, /* (297) explain_options ::= explain_options RATIO NK_FLOAT */ - { 328, -10 }, /* (298) cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */ - { 328, -4 }, /* (299) cmd ::= DROP FUNCTION exists_opt function_name */ - { 399, 0 }, /* (300) agg_func_opt ::= */ - { 399, -1 }, /* (301) agg_func_opt ::= AGGREGATE */ - { 400, 0 }, /* (302) bufsize_opt ::= */ - { 400, -2 }, /* (303) bufsize_opt ::= BUFSIZE NK_INTEGER */ - { 328, -12 }, /* (304) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery */ - { 328, -4 }, /* (305) cmd ::= DROP STREAM exists_opt stream_name */ - { 403, 0 }, /* (306) col_list_opt ::= */ - { 403, -3 }, /* (307) col_list_opt ::= NK_LP col_name_list NK_RP */ - { 404, 0 }, /* (308) tag_def_or_ref_opt ::= */ - { 404, -1 }, /* (309) tag_def_or_ref_opt ::= tags_def */ - { 404, -4 }, /* (310) tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP */ - { 402, 0 }, /* (311) stream_options ::= */ - { 402, -3 }, /* (312) stream_options ::= stream_options TRIGGER AT_ONCE */ - { 402, -3 }, /* (313) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ - { 402, -4 }, /* (314) stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ - { 402, -3 }, /* (315) stream_options ::= stream_options WATERMARK duration_literal */ - { 402, -4 }, /* (316) stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ - { 402, -3 }, /* (317) stream_options ::= stream_options FILL_HISTORY NK_INTEGER */ - { 405, 0 }, /* (318) subtable_opt ::= */ - { 405, -4 }, /* (319) subtable_opt ::= SUBTABLE NK_LP expression NK_RP */ - { 328, -3 }, /* (320) cmd ::= KILL CONNECTION NK_INTEGER */ - { 328, -3 }, /* (321) cmd ::= KILL QUERY NK_STRING */ - { 328, -3 }, /* (322) cmd ::= KILL TRANSACTION NK_INTEGER */ - { 328, -2 }, /* (323) cmd ::= BALANCE VGROUP */ - { 328, -4 }, /* (324) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ - { 328, -4 }, /* (325) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ - { 328, -3 }, /* (326) cmd ::= SPLIT VGROUP NK_INTEGER */ - { 407, -2 }, /* (327) dnode_list ::= DNODE NK_INTEGER */ - { 407, -3 }, /* (328) dnode_list ::= dnode_list DNODE NK_INTEGER */ - { 328, -4 }, /* (329) cmd ::= DELETE FROM full_table_name where_clause_opt */ - { 328, -1 }, /* (330) cmd ::= query_or_subquery */ - { 328, -1 }, /* (331) cmd ::= insert_query */ - { 398, -7 }, /* (332) insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */ - { 398, -4 }, /* (333) insert_query ::= INSERT INTO full_table_name query_or_subquery */ - { 331, -1 }, /* (334) literal ::= NK_INTEGER */ - { 331, -1 }, /* (335) literal ::= NK_FLOAT */ - { 331, -1 }, /* (336) literal ::= NK_STRING */ - { 331, -1 }, /* (337) literal ::= NK_BOOL */ - { 331, -2 }, /* (338) literal ::= TIMESTAMP NK_STRING */ - { 331, -1 }, /* (339) literal ::= duration_literal */ - { 331, -1 }, /* (340) literal ::= NULL */ - { 331, -1 }, /* (341) literal ::= NK_QUESTION */ - { 375, -1 }, /* (342) duration_literal ::= NK_VARIABLE */ - { 409, -1 }, /* (343) signed ::= NK_INTEGER */ - { 409, -2 }, /* (344) signed ::= NK_PLUS NK_INTEGER */ - { 409, -2 }, /* (345) signed ::= NK_MINUS NK_INTEGER */ - { 409, -1 }, /* (346) signed ::= NK_FLOAT */ - { 409, -2 }, /* (347) signed ::= NK_PLUS NK_FLOAT */ - { 409, -2 }, /* (348) signed ::= NK_MINUS NK_FLOAT */ - { 364, -1 }, /* (349) signed_literal ::= signed */ - { 364, -1 }, /* (350) signed_literal ::= NK_STRING */ - { 364, -1 }, /* (351) signed_literal ::= NK_BOOL */ - { 364, -2 }, /* (352) signed_literal ::= TIMESTAMP NK_STRING */ - { 364, -1 }, /* (353) signed_literal ::= duration_literal */ - { 364, -1 }, /* (354) signed_literal ::= NULL */ - { 364, -1 }, /* (355) signed_literal ::= literal_func */ - { 364, -1 }, /* (356) signed_literal ::= NK_QUESTION */ - { 411, -1 }, /* (357) literal_list ::= signed_literal */ - { 411, -3 }, /* (358) literal_list ::= literal_list NK_COMMA signed_literal */ - { 339, -1 }, /* (359) db_name ::= NK_ID */ - { 370, -1 }, /* (360) table_name ::= NK_ID */ - { 362, -1 }, /* (361) column_name ::= NK_ID */ - { 377, -1 }, /* (362) function_name ::= NK_ID */ - { 412, -1 }, /* (363) table_alias ::= NK_ID */ - { 385, -1 }, /* (364) column_alias ::= NK_ID */ - { 333, -1 }, /* (365) user_name ::= NK_ID */ - { 340, -1 }, /* (366) topic_name ::= NK_ID */ - { 401, -1 }, /* (367) stream_name ::= NK_ID */ - { 395, -1 }, /* (368) cgroup_name ::= NK_ID */ - { 388, -1 }, /* (369) index_name ::= NK_ID */ - { 413, -1 }, /* (370) expr_or_subquery ::= expression */ - { 406, -1 }, /* (371) expression ::= literal */ - { 406, -1 }, /* (372) expression ::= pseudo_column */ - { 406, -1 }, /* (373) expression ::= column_reference */ - { 406, -1 }, /* (374) expression ::= function_expression */ - { 406, -1 }, /* (375) expression ::= case_when_expression */ - { 406, -3 }, /* (376) expression ::= NK_LP expression NK_RP */ - { 406, -2 }, /* (377) expression ::= NK_PLUS expr_or_subquery */ - { 406, -2 }, /* (378) expression ::= NK_MINUS expr_or_subquery */ - { 406, -3 }, /* (379) expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ - { 406, -3 }, /* (380) expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ - { 406, -3 }, /* (381) expression ::= expr_or_subquery NK_STAR expr_or_subquery */ - { 406, -3 }, /* (382) expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ - { 406, -3 }, /* (383) expression ::= expr_or_subquery NK_REM expr_or_subquery */ - { 406, -3 }, /* (384) expression ::= column_reference NK_ARROW NK_STRING */ - { 406, -3 }, /* (385) expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ - { 406, -3 }, /* (386) expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ - { 367, -1 }, /* (387) expression_list ::= expr_or_subquery */ - { 367, -3 }, /* (388) expression_list ::= expression_list NK_COMMA expr_or_subquery */ - { 415, -1 }, /* (389) column_reference ::= column_name */ - { 415, -3 }, /* (390) column_reference ::= table_name NK_DOT column_name */ - { 414, -1 }, /* (391) pseudo_column ::= ROWTS */ - { 414, -1 }, /* (392) pseudo_column ::= TBNAME */ - { 414, -3 }, /* (393) pseudo_column ::= table_name NK_DOT TBNAME */ - { 414, -1 }, /* (394) pseudo_column ::= QSTART */ - { 414, -1 }, /* (395) pseudo_column ::= QEND */ - { 414, -1 }, /* (396) pseudo_column ::= QDURATION */ - { 414, -1 }, /* (397) pseudo_column ::= WSTART */ - { 414, -1 }, /* (398) pseudo_column ::= WEND */ - { 414, -1 }, /* (399) pseudo_column ::= WDURATION */ - { 414, -1 }, /* (400) pseudo_column ::= IROWTS */ - { 414, -1 }, /* (401) pseudo_column ::= ISFILLED */ - { 414, -1 }, /* (402) pseudo_column ::= QTAGS */ - { 416, -4 }, /* (403) function_expression ::= function_name NK_LP expression_list NK_RP */ - { 416, -4 }, /* (404) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ - { 416, -6 }, /* (405) function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ - { 416, -1 }, /* (406) function_expression ::= literal_func */ - { 410, -3 }, /* (407) literal_func ::= noarg_func NK_LP NK_RP */ - { 410, -1 }, /* (408) literal_func ::= NOW */ - { 420, -1 }, /* (409) noarg_func ::= NOW */ - { 420, -1 }, /* (410) noarg_func ::= TODAY */ - { 420, -1 }, /* (411) noarg_func ::= TIMEZONE */ - { 420, -1 }, /* (412) noarg_func ::= DATABASE */ - { 420, -1 }, /* (413) noarg_func ::= CLIENT_VERSION */ - { 420, -1 }, /* (414) noarg_func ::= SERVER_VERSION */ - { 420, -1 }, /* (415) noarg_func ::= SERVER_STATUS */ - { 420, -1 }, /* (416) noarg_func ::= CURRENT_USER */ - { 420, -1 }, /* (417) noarg_func ::= USER */ - { 418, -1 }, /* (418) star_func ::= COUNT */ - { 418, -1 }, /* (419) star_func ::= FIRST */ - { 418, -1 }, /* (420) star_func ::= LAST */ - { 418, -1 }, /* (421) star_func ::= LAST_ROW */ - { 419, -1 }, /* (422) star_func_para_list ::= NK_STAR */ - { 419, -1 }, /* (423) star_func_para_list ::= other_para_list */ - { 421, -1 }, /* (424) other_para_list ::= star_func_para */ - { 421, -3 }, /* (425) other_para_list ::= other_para_list NK_COMMA star_func_para */ - { 422, -1 }, /* (426) star_func_para ::= expr_or_subquery */ - { 422, -3 }, /* (427) star_func_para ::= table_name NK_DOT NK_STAR */ - { 417, -4 }, /* (428) case_when_expression ::= CASE when_then_list case_when_else_opt END */ - { 417, -5 }, /* (429) case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ - { 423, -1 }, /* (430) when_then_list ::= when_then_expr */ - { 423, -2 }, /* (431) when_then_list ::= when_then_list when_then_expr */ - { 426, -4 }, /* (432) when_then_expr ::= WHEN common_expression THEN common_expression */ - { 424, 0 }, /* (433) case_when_else_opt ::= */ - { 424, -2 }, /* (434) case_when_else_opt ::= ELSE common_expression */ - { 427, -3 }, /* (435) predicate ::= expr_or_subquery compare_op expr_or_subquery */ - { 427, -5 }, /* (436) predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ - { 427, -6 }, /* (437) predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ - { 427, -3 }, /* (438) predicate ::= expr_or_subquery IS NULL */ - { 427, -4 }, /* (439) predicate ::= expr_or_subquery IS NOT NULL */ - { 427, -3 }, /* (440) predicate ::= expr_or_subquery in_op in_predicate_value */ - { 428, -1 }, /* (441) compare_op ::= NK_LT */ - { 428, -1 }, /* (442) compare_op ::= NK_GT */ - { 428, -1 }, /* (443) compare_op ::= NK_LE */ - { 428, -1 }, /* (444) compare_op ::= NK_GE */ - { 428, -1 }, /* (445) compare_op ::= NK_NE */ - { 428, -1 }, /* (446) compare_op ::= NK_EQ */ - { 428, -1 }, /* (447) compare_op ::= LIKE */ - { 428, -2 }, /* (448) compare_op ::= NOT LIKE */ - { 428, -1 }, /* (449) compare_op ::= MATCH */ - { 428, -1 }, /* (450) compare_op ::= NMATCH */ - { 428, -1 }, /* (451) compare_op ::= CONTAINS */ - { 429, -1 }, /* (452) in_op ::= IN */ - { 429, -2 }, /* (453) in_op ::= NOT IN */ - { 430, -3 }, /* (454) in_predicate_value ::= NK_LP literal_list NK_RP */ - { 431, -1 }, /* (455) boolean_value_expression ::= boolean_primary */ - { 431, -2 }, /* (456) boolean_value_expression ::= NOT boolean_primary */ - { 431, -3 }, /* (457) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ - { 431, -3 }, /* (458) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ - { 432, -1 }, /* (459) boolean_primary ::= predicate */ - { 432, -3 }, /* (460) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ - { 425, -1 }, /* (461) common_expression ::= expr_or_subquery */ - { 425, -1 }, /* (462) common_expression ::= boolean_value_expression */ - { 433, 0 }, /* (463) from_clause_opt ::= */ - { 433, -2 }, /* (464) from_clause_opt ::= FROM table_reference_list */ - { 434, -1 }, /* (465) table_reference_list ::= table_reference */ - { 434, -3 }, /* (466) table_reference_list ::= table_reference_list NK_COMMA table_reference */ - { 435, -1 }, /* (467) table_reference ::= table_primary */ - { 435, -1 }, /* (468) table_reference ::= joined_table */ - { 436, -2 }, /* (469) table_primary ::= table_name alias_opt */ - { 436, -4 }, /* (470) table_primary ::= db_name NK_DOT table_name alias_opt */ - { 436, -2 }, /* (471) table_primary ::= subquery alias_opt */ - { 436, -1 }, /* (472) table_primary ::= parenthesized_joined_table */ - { 438, 0 }, /* (473) alias_opt ::= */ - { 438, -1 }, /* (474) alias_opt ::= table_alias */ - { 438, -2 }, /* (475) alias_opt ::= AS table_alias */ - { 440, -3 }, /* (476) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - { 440, -3 }, /* (477) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ - { 437, -6 }, /* (478) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ - { 441, 0 }, /* (479) join_type ::= */ - { 441, -1 }, /* (480) join_type ::= INNER */ - { 443, -12 }, /* (481) query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ - { 444, 0 }, /* (482) set_quantifier_opt ::= */ - { 444, -1 }, /* (483) set_quantifier_opt ::= DISTINCT */ - { 444, -1 }, /* (484) set_quantifier_opt ::= ALL */ - { 445, -1 }, /* (485) select_list ::= select_item */ - { 445, -3 }, /* (486) select_list ::= select_list NK_COMMA select_item */ - { 453, -1 }, /* (487) select_item ::= NK_STAR */ - { 453, -1 }, /* (488) select_item ::= common_expression */ - { 453, -2 }, /* (489) select_item ::= common_expression column_alias */ - { 453, -3 }, /* (490) select_item ::= common_expression AS column_alias */ - { 453, -3 }, /* (491) select_item ::= table_name NK_DOT NK_STAR */ - { 408, 0 }, /* (492) where_clause_opt ::= */ - { 408, -2 }, /* (493) where_clause_opt ::= WHERE search_condition */ - { 446, 0 }, /* (494) partition_by_clause_opt ::= */ - { 446, -3 }, /* (495) partition_by_clause_opt ::= PARTITION BY partition_list */ - { 454, -1 }, /* (496) partition_list ::= partition_item */ - { 454, -3 }, /* (497) partition_list ::= partition_list NK_COMMA partition_item */ - { 455, -1 }, /* (498) partition_item ::= expr_or_subquery */ - { 455, -2 }, /* (499) partition_item ::= expr_or_subquery column_alias */ - { 455, -3 }, /* (500) partition_item ::= expr_or_subquery AS column_alias */ - { 450, 0 }, /* (501) twindow_clause_opt ::= */ - { 450, -6 }, /* (502) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ - { 450, -4 }, /* (503) twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ - { 450, -6 }, /* (504) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ - { 450, -8 }, /* (505) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ - { 450, -7 }, /* (506) twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ - { 390, 0 }, /* (507) sliding_opt ::= */ - { 390, -4 }, /* (508) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ - { 449, 0 }, /* (509) fill_opt ::= */ - { 449, -4 }, /* (510) fill_opt ::= FILL NK_LP fill_mode NK_RP */ - { 449, -6 }, /* (511) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ - { 449, -6 }, /* (512) fill_opt ::= FILL NK_LP VALUE_F NK_COMMA literal_list NK_RP */ - { 456, -1 }, /* (513) fill_mode ::= NONE */ - { 456, -1 }, /* (514) fill_mode ::= PREV */ - { 456, -1 }, /* (515) fill_mode ::= NULL */ - { 456, -1 }, /* (516) fill_mode ::= NULL_F */ - { 456, -1 }, /* (517) fill_mode ::= LINEAR */ - { 456, -1 }, /* (518) fill_mode ::= NEXT */ - { 451, 0 }, /* (519) group_by_clause_opt ::= */ - { 451, -3 }, /* (520) group_by_clause_opt ::= GROUP BY group_by_list */ - { 457, -1 }, /* (521) group_by_list ::= expr_or_subquery */ - { 457, -3 }, /* (522) group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ - { 452, 0 }, /* (523) having_clause_opt ::= */ - { 452, -2 }, /* (524) having_clause_opt ::= HAVING search_condition */ - { 447, 0 }, /* (525) range_opt ::= */ - { 447, -6 }, /* (526) range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ - { 448, 0 }, /* (527) every_opt ::= */ - { 448, -4 }, /* (528) every_opt ::= EVERY NK_LP duration_literal NK_RP */ - { 458, -4 }, /* (529) query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ - { 459, -1 }, /* (530) query_simple ::= query_specification */ - { 459, -1 }, /* (531) query_simple ::= union_query_expression */ - { 463, -4 }, /* (532) union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ - { 463, -3 }, /* (533) union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ - { 464, -1 }, /* (534) query_simple_or_subquery ::= query_simple */ - { 464, -1 }, /* (535) query_simple_or_subquery ::= subquery */ - { 394, -1 }, /* (536) query_or_subquery ::= query_expression */ - { 394, -1 }, /* (537) query_or_subquery ::= subquery */ - { 460, 0 }, /* (538) order_by_clause_opt ::= */ - { 460, -3 }, /* (539) order_by_clause_opt ::= ORDER BY sort_specification_list */ - { 461, 0 }, /* (540) slimit_clause_opt ::= */ - { 461, -2 }, /* (541) slimit_clause_opt ::= SLIMIT NK_INTEGER */ - { 461, -4 }, /* (542) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - { 461, -4 }, /* (543) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - { 462, 0 }, /* (544) limit_clause_opt ::= */ - { 462, -2 }, /* (545) limit_clause_opt ::= LIMIT NK_INTEGER */ - { 462, -4 }, /* (546) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ - { 462, -4 }, /* (547) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - { 439, -3 }, /* (548) subquery ::= NK_LP query_expression NK_RP */ - { 439, -3 }, /* (549) subquery ::= NK_LP subquery NK_RP */ - { 442, -1 }, /* (550) search_condition ::= common_expression */ - { 465, -1 }, /* (551) sort_specification_list ::= sort_specification */ - { 465, -3 }, /* (552) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ - { 466, -3 }, /* (553) sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ - { 467, 0 }, /* (554) ordering_specification_opt ::= */ - { 467, -1 }, /* (555) ordering_specification_opt ::= ASC */ - { 467, -1 }, /* (556) ordering_specification_opt ::= DESC */ - { 468, 0 }, /* (557) null_ordering_opt ::= */ - { 468, -2 }, /* (558) null_ordering_opt ::= NULLS FIRST */ - { 468, -2 }, /* (559) null_ordering_opt ::= NULLS LAST */ + { 328, -3 }, /* (72) cmd ::= COMPACT DATABASE db_name */ + { 343, -3 }, /* (73) not_exists_opt ::= IF NOT EXISTS */ + { 343, 0 }, /* (74) not_exists_opt ::= */ + { 345, -2 }, /* (75) exists_opt ::= IF EXISTS */ + { 345, 0 }, /* (76) exists_opt ::= */ + { 344, 0 }, /* (77) db_options ::= */ + { 344, -3 }, /* (78) db_options ::= db_options BUFFER NK_INTEGER */ + { 344, -3 }, /* (79) db_options ::= db_options CACHEMODEL NK_STRING */ + { 344, -3 }, /* (80) db_options ::= db_options CACHESIZE NK_INTEGER */ + { 344, -3 }, /* (81) db_options ::= db_options COMP NK_INTEGER */ + { 344, -3 }, /* (82) db_options ::= db_options DURATION NK_INTEGER */ + { 344, -3 }, /* (83) db_options ::= db_options DURATION NK_VARIABLE */ + { 344, -3 }, /* (84) db_options ::= db_options MAXROWS NK_INTEGER */ + { 344, -3 }, /* (85) db_options ::= db_options MINROWS NK_INTEGER */ + { 344, -3 }, /* (86) db_options ::= db_options KEEP integer_list */ + { 344, -3 }, /* (87) db_options ::= db_options KEEP variable_list */ + { 344, -3 }, /* (88) db_options ::= db_options PAGES NK_INTEGER */ + { 344, -3 }, /* (89) db_options ::= db_options PAGESIZE NK_INTEGER */ + { 344, -3 }, /* (90) db_options ::= db_options TSDB_PAGESIZE NK_INTEGER */ + { 344, -3 }, /* (91) db_options ::= db_options PRECISION NK_STRING */ + { 344, -3 }, /* (92) db_options ::= db_options REPLICA NK_INTEGER */ + { 344, -3 }, /* (93) db_options ::= db_options VGROUPS NK_INTEGER */ + { 344, -3 }, /* (94) db_options ::= db_options SINGLE_STABLE NK_INTEGER */ + { 344, -3 }, /* (95) db_options ::= db_options RETENTIONS retention_list */ + { 344, -3 }, /* (96) db_options ::= db_options SCHEMALESS NK_INTEGER */ + { 344, -3 }, /* (97) db_options ::= db_options WAL_LEVEL NK_INTEGER */ + { 344, -3 }, /* (98) db_options ::= db_options WAL_FSYNC_PERIOD NK_INTEGER */ + { 344, -3 }, /* (99) db_options ::= db_options WAL_RETENTION_PERIOD NK_INTEGER */ + { 344, -4 }, /* (100) db_options ::= db_options WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ + { 344, -3 }, /* (101) db_options ::= db_options WAL_RETENTION_SIZE NK_INTEGER */ + { 344, -4 }, /* (102) db_options ::= db_options WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ + { 344, -3 }, /* (103) db_options ::= db_options WAL_ROLL_PERIOD NK_INTEGER */ + { 344, -3 }, /* (104) db_options ::= db_options WAL_SEGMENT_SIZE NK_INTEGER */ + { 344, -3 }, /* (105) db_options ::= db_options STT_TRIGGER NK_INTEGER */ + { 344, -3 }, /* (106) db_options ::= db_options TABLE_PREFIX NK_INTEGER */ + { 344, -3 }, /* (107) db_options ::= db_options TABLE_SUFFIX NK_INTEGER */ + { 346, -1 }, /* (108) alter_db_options ::= alter_db_option */ + { 346, -2 }, /* (109) alter_db_options ::= alter_db_options alter_db_option */ + { 351, -2 }, /* (110) alter_db_option ::= BUFFER NK_INTEGER */ + { 351, -2 }, /* (111) alter_db_option ::= CACHEMODEL NK_STRING */ + { 351, -2 }, /* (112) alter_db_option ::= CACHESIZE NK_INTEGER */ + { 351, -2 }, /* (113) alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */ + { 351, -2 }, /* (114) alter_db_option ::= KEEP integer_list */ + { 351, -2 }, /* (115) alter_db_option ::= KEEP variable_list */ + { 351, -2 }, /* (116) alter_db_option ::= PAGES NK_INTEGER */ + { 351, -2 }, /* (117) alter_db_option ::= REPLICA NK_INTEGER */ + { 351, -2 }, /* (118) alter_db_option ::= WAL_LEVEL NK_INTEGER */ + { 351, -2 }, /* (119) alter_db_option ::= STT_TRIGGER NK_INTEGER */ + { 348, -1 }, /* (120) integer_list ::= NK_INTEGER */ + { 348, -3 }, /* (121) integer_list ::= integer_list NK_COMMA NK_INTEGER */ + { 349, -1 }, /* (122) variable_list ::= NK_VARIABLE */ + { 349, -3 }, /* (123) variable_list ::= variable_list NK_COMMA NK_VARIABLE */ + { 350, -1 }, /* (124) retention_list ::= retention */ + { 350, -3 }, /* (125) retention_list ::= retention_list NK_COMMA retention */ + { 352, -3 }, /* (126) retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ + { 347, 0 }, /* (127) speed_opt ::= */ + { 347, -2 }, /* (128) speed_opt ::= MAX_SPEED NK_INTEGER */ + { 328, -9 }, /* (129) cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ + { 328, -3 }, /* (130) cmd ::= CREATE TABLE multi_create_clause */ + { 328, -9 }, /* (131) cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ + { 328, -3 }, /* (132) cmd ::= DROP TABLE multi_drop_clause */ + { 328, -4 }, /* (133) cmd ::= DROP STABLE exists_opt full_table_name */ + { 328, -3 }, /* (134) cmd ::= ALTER TABLE alter_table_clause */ + { 328, -3 }, /* (135) cmd ::= ALTER STABLE alter_table_clause */ + { 360, -2 }, /* (136) alter_table_clause ::= full_table_name alter_table_options */ + { 360, -5 }, /* (137) alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ + { 360, -4 }, /* (138) alter_table_clause ::= full_table_name DROP COLUMN column_name */ + { 360, -5 }, /* (139) alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ + { 360, -5 }, /* (140) alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ + { 360, -5 }, /* (141) alter_table_clause ::= full_table_name ADD TAG column_name type_name */ + { 360, -4 }, /* (142) alter_table_clause ::= full_table_name DROP TAG column_name */ + { 360, -5 }, /* (143) alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ + { 360, -5 }, /* (144) alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ + { 360, -6 }, /* (145) alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ + { 357, -1 }, /* (146) multi_create_clause ::= create_subtable_clause */ + { 357, -2 }, /* (147) multi_create_clause ::= multi_create_clause create_subtable_clause */ + { 365, -10 }, /* (148) create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP expression_list NK_RP table_options */ + { 359, -1 }, /* (149) multi_drop_clause ::= drop_table_clause */ + { 359, -2 }, /* (150) multi_drop_clause ::= multi_drop_clause drop_table_clause */ + { 368, -2 }, /* (151) drop_table_clause ::= exists_opt full_table_name */ + { 366, 0 }, /* (152) specific_cols_opt ::= */ + { 366, -3 }, /* (153) specific_cols_opt ::= NK_LP col_name_list NK_RP */ + { 353, -1 }, /* (154) full_table_name ::= table_name */ + { 353, -3 }, /* (155) full_table_name ::= db_name NK_DOT table_name */ + { 354, -1 }, /* (156) column_def_list ::= column_def */ + { 354, -3 }, /* (157) column_def_list ::= column_def_list NK_COMMA column_def */ + { 371, -2 }, /* (158) column_def ::= column_name type_name */ + { 371, -4 }, /* (159) column_def ::= column_name type_name COMMENT NK_STRING */ + { 363, -1 }, /* (160) type_name ::= BOOL */ + { 363, -1 }, /* (161) type_name ::= TINYINT */ + { 363, -1 }, /* (162) type_name ::= SMALLINT */ + { 363, -1 }, /* (163) type_name ::= INT */ + { 363, -1 }, /* (164) type_name ::= INTEGER */ + { 363, -1 }, /* (165) type_name ::= BIGINT */ + { 363, -1 }, /* (166) type_name ::= FLOAT */ + { 363, -1 }, /* (167) type_name ::= DOUBLE */ + { 363, -4 }, /* (168) type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ + { 363, -1 }, /* (169) type_name ::= TIMESTAMP */ + { 363, -4 }, /* (170) type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ + { 363, -2 }, /* (171) type_name ::= TINYINT UNSIGNED */ + { 363, -2 }, /* (172) type_name ::= SMALLINT UNSIGNED */ + { 363, -2 }, /* (173) type_name ::= INT UNSIGNED */ + { 363, -2 }, /* (174) type_name ::= BIGINT UNSIGNED */ + { 363, -1 }, /* (175) type_name ::= JSON */ + { 363, -4 }, /* (176) type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ + { 363, -1 }, /* (177) type_name ::= MEDIUMBLOB */ + { 363, -1 }, /* (178) type_name ::= BLOB */ + { 363, -4 }, /* (179) type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ + { 363, -1 }, /* (180) type_name ::= DECIMAL */ + { 363, -4 }, /* (181) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ + { 363, -6 }, /* (182) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ + { 355, 0 }, /* (183) tags_def_opt ::= */ + { 355, -1 }, /* (184) tags_def_opt ::= tags_def */ + { 358, -4 }, /* (185) tags_def ::= TAGS NK_LP column_def_list NK_RP */ + { 356, 0 }, /* (186) table_options ::= */ + { 356, -3 }, /* (187) table_options ::= table_options COMMENT NK_STRING */ + { 356, -3 }, /* (188) table_options ::= table_options MAX_DELAY duration_list */ + { 356, -3 }, /* (189) table_options ::= table_options WATERMARK duration_list */ + { 356, -5 }, /* (190) table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ + { 356, -3 }, /* (191) table_options ::= table_options TTL NK_INTEGER */ + { 356, -5 }, /* (192) table_options ::= table_options SMA NK_LP col_name_list NK_RP */ + { 356, -3 }, /* (193) table_options ::= table_options DELETE_MARK duration_list */ + { 361, -1 }, /* (194) alter_table_options ::= alter_table_option */ + { 361, -2 }, /* (195) alter_table_options ::= alter_table_options alter_table_option */ + { 374, -2 }, /* (196) alter_table_option ::= COMMENT NK_STRING */ + { 374, -2 }, /* (197) alter_table_option ::= TTL NK_INTEGER */ + { 372, -1 }, /* (198) duration_list ::= duration_literal */ + { 372, -3 }, /* (199) duration_list ::= duration_list NK_COMMA duration_literal */ + { 373, -1 }, /* (200) rollup_func_list ::= rollup_func_name */ + { 373, -3 }, /* (201) rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ + { 376, -1 }, /* (202) rollup_func_name ::= function_name */ + { 376, -1 }, /* (203) rollup_func_name ::= FIRST */ + { 376, -1 }, /* (204) rollup_func_name ::= LAST */ + { 369, -1 }, /* (205) col_name_list ::= col_name */ + { 369, -3 }, /* (206) col_name_list ::= col_name_list NK_COMMA col_name */ + { 378, -1 }, /* (207) col_name ::= column_name */ + { 328, -2 }, /* (208) cmd ::= SHOW DNODES */ + { 328, -2 }, /* (209) cmd ::= SHOW USERS */ + { 328, -3 }, /* (210) cmd ::= SHOW USER PRIVILEGES */ + { 328, -2 }, /* (211) cmd ::= SHOW DATABASES */ + { 328, -4 }, /* (212) cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */ + { 328, -4 }, /* (213) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ + { 328, -3 }, /* (214) cmd ::= SHOW db_name_cond_opt VGROUPS */ + { 328, -2 }, /* (215) cmd ::= SHOW MNODES */ + { 328, -2 }, /* (216) cmd ::= SHOW QNODES */ + { 328, -2 }, /* (217) cmd ::= SHOW FUNCTIONS */ + { 328, -5 }, /* (218) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ + { 328, -2 }, /* (219) cmd ::= SHOW STREAMS */ + { 328, -2 }, /* (220) cmd ::= SHOW ACCOUNTS */ + { 328, -2 }, /* (221) cmd ::= SHOW APPS */ + { 328, -2 }, /* (222) cmd ::= SHOW CONNECTIONS */ + { 328, -2 }, /* (223) cmd ::= SHOW LICENCES */ + { 328, -2 }, /* (224) cmd ::= SHOW GRANTS */ + { 328, -4 }, /* (225) cmd ::= SHOW CREATE DATABASE db_name */ + { 328, -4 }, /* (226) cmd ::= SHOW CREATE TABLE full_table_name */ + { 328, -4 }, /* (227) cmd ::= SHOW CREATE STABLE full_table_name */ + { 328, -2 }, /* (228) cmd ::= SHOW QUERIES */ + { 328, -2 }, /* (229) cmd ::= SHOW SCORES */ + { 328, -2 }, /* (230) cmd ::= SHOW TOPICS */ + { 328, -2 }, /* (231) cmd ::= SHOW VARIABLES */ + { 328, -3 }, /* (232) cmd ::= SHOW CLUSTER VARIABLES */ + { 328, -3 }, /* (233) cmd ::= SHOW LOCAL VARIABLES */ + { 328, -5 }, /* (234) cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */ + { 328, -2 }, /* (235) cmd ::= SHOW BNODES */ + { 328, -2 }, /* (236) cmd ::= SHOW SNODES */ + { 328, -2 }, /* (237) cmd ::= SHOW CLUSTER */ + { 328, -2 }, /* (238) cmd ::= SHOW TRANSACTIONS */ + { 328, -4 }, /* (239) cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ + { 328, -2 }, /* (240) cmd ::= SHOW CONSUMERS */ + { 328, -2 }, /* (241) cmd ::= SHOW SUBSCRIPTIONS */ + { 328, -5 }, /* (242) cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ + { 328, -7 }, /* (243) cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */ + { 328, -3 }, /* (244) cmd ::= SHOW VNODES NK_INTEGER */ + { 328, -3 }, /* (245) cmd ::= SHOW VNODES NK_STRING */ + { 328, -3 }, /* (246) cmd ::= SHOW db_name_cond_opt ALIVE */ + { 328, -3 }, /* (247) cmd ::= SHOW CLUSTER ALIVE */ + { 379, 0 }, /* (248) db_name_cond_opt ::= */ + { 379, -2 }, /* (249) db_name_cond_opt ::= db_name NK_DOT */ + { 380, 0 }, /* (250) like_pattern_opt ::= */ + { 380, -2 }, /* (251) like_pattern_opt ::= LIKE NK_STRING */ + { 381, -1 }, /* (252) table_name_cond ::= table_name */ + { 382, 0 }, /* (253) from_db_opt ::= */ + { 382, -2 }, /* (254) from_db_opt ::= FROM db_name */ + { 383, 0 }, /* (255) tag_list_opt ::= */ + { 383, -1 }, /* (256) tag_list_opt ::= tag_item */ + { 383, -3 }, /* (257) tag_list_opt ::= tag_list_opt NK_COMMA tag_item */ + { 384, -1 }, /* (258) tag_item ::= TBNAME */ + { 384, -1 }, /* (259) tag_item ::= QTAGS */ + { 384, -1 }, /* (260) tag_item ::= column_name */ + { 384, -2 }, /* (261) tag_item ::= column_name column_alias */ + { 384, -3 }, /* (262) tag_item ::= column_name AS column_alias */ + { 328, -8 }, /* (263) cmd ::= CREATE SMA INDEX not_exists_opt full_index_name ON full_table_name index_options */ + { 328, -9 }, /* (264) cmd ::= CREATE INDEX not_exists_opt full_index_name ON full_table_name NK_LP col_name_list NK_RP */ + { 328, -4 }, /* (265) cmd ::= DROP INDEX exists_opt full_index_name */ + { 386, -1 }, /* (266) full_index_name ::= index_name */ + { 386, -3 }, /* (267) full_index_name ::= db_name NK_DOT index_name */ + { 387, -10 }, /* (268) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ + { 387, -12 }, /* (269) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt */ + { 389, -1 }, /* (270) func_list ::= func */ + { 389, -3 }, /* (271) func_list ::= func_list NK_COMMA func */ + { 392, -4 }, /* (272) func ::= sma_func_name NK_LP expression_list NK_RP */ + { 393, -1 }, /* (273) sma_func_name ::= function_name */ + { 393, -1 }, /* (274) sma_func_name ::= COUNT */ + { 393, -1 }, /* (275) sma_func_name ::= FIRST */ + { 393, -1 }, /* (276) sma_func_name ::= LAST */ + { 393, -1 }, /* (277) sma_func_name ::= LAST_ROW */ + { 391, 0 }, /* (278) sma_stream_opt ::= */ + { 391, -3 }, /* (279) sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */ + { 391, -3 }, /* (280) sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */ + { 391, -3 }, /* (281) sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */ + { 328, -6 }, /* (282) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */ + { 328, -7 }, /* (283) cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name */ + { 328, -9 }, /* (284) cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS DATABASE db_name */ + { 328, -7 }, /* (285) cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name */ + { 328, -9 }, /* (286) cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS STABLE full_table_name */ + { 328, -4 }, /* (287) cmd ::= DROP TOPIC exists_opt topic_name */ + { 328, -7 }, /* (288) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ + { 328, -2 }, /* (289) cmd ::= DESC full_table_name */ + { 328, -2 }, /* (290) cmd ::= DESCRIBE full_table_name */ + { 328, -3 }, /* (291) cmd ::= RESET QUERY CACHE */ + { 328, -4 }, /* (292) cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */ + { 328, -4 }, /* (293) cmd ::= EXPLAIN analyze_opt explain_options insert_query */ + { 396, 0 }, /* (294) analyze_opt ::= */ + { 396, -1 }, /* (295) analyze_opt ::= ANALYZE */ + { 397, 0 }, /* (296) explain_options ::= */ + { 397, -3 }, /* (297) explain_options ::= explain_options VERBOSE NK_BOOL */ + { 397, -3 }, /* (298) explain_options ::= explain_options RATIO NK_FLOAT */ + { 328, -10 }, /* (299) cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */ + { 328, -4 }, /* (300) cmd ::= DROP FUNCTION exists_opt function_name */ + { 399, 0 }, /* (301) agg_func_opt ::= */ + { 399, -1 }, /* (302) agg_func_opt ::= AGGREGATE */ + { 400, 0 }, /* (303) bufsize_opt ::= */ + { 400, -2 }, /* (304) bufsize_opt ::= BUFSIZE NK_INTEGER */ + { 328, -12 }, /* (305) cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery */ + { 328, -4 }, /* (306) cmd ::= DROP STREAM exists_opt stream_name */ + { 403, 0 }, /* (307) col_list_opt ::= */ + { 403, -3 }, /* (308) col_list_opt ::= NK_LP col_name_list NK_RP */ + { 404, 0 }, /* (309) tag_def_or_ref_opt ::= */ + { 404, -1 }, /* (310) tag_def_or_ref_opt ::= tags_def */ + { 404, -4 }, /* (311) tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP */ + { 402, 0 }, /* (312) stream_options ::= */ + { 402, -3 }, /* (313) stream_options ::= stream_options TRIGGER AT_ONCE */ + { 402, -3 }, /* (314) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ + { 402, -4 }, /* (315) stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ + { 402, -3 }, /* (316) stream_options ::= stream_options WATERMARK duration_literal */ + { 402, -4 }, /* (317) stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ + { 402, -3 }, /* (318) stream_options ::= stream_options FILL_HISTORY NK_INTEGER */ + { 405, 0 }, /* (319) subtable_opt ::= */ + { 405, -4 }, /* (320) subtable_opt ::= SUBTABLE NK_LP expression NK_RP */ + { 328, -3 }, /* (321) cmd ::= KILL CONNECTION NK_INTEGER */ + { 328, -3 }, /* (322) cmd ::= KILL QUERY NK_STRING */ + { 328, -3 }, /* (323) cmd ::= KILL TRANSACTION NK_INTEGER */ + { 328, -2 }, /* (324) cmd ::= BALANCE VGROUP */ + { 328, -4 }, /* (325) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ + { 328, -4 }, /* (326) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ + { 328, -3 }, /* (327) cmd ::= SPLIT VGROUP NK_INTEGER */ + { 407, -2 }, /* (328) dnode_list ::= DNODE NK_INTEGER */ + { 407, -3 }, /* (329) dnode_list ::= dnode_list DNODE NK_INTEGER */ + { 328, -4 }, /* (330) cmd ::= DELETE FROM full_table_name where_clause_opt */ + { 328, -1 }, /* (331) cmd ::= query_or_subquery */ + { 328, -1 }, /* (332) cmd ::= insert_query */ + { 398, -7 }, /* (333) insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */ + { 398, -4 }, /* (334) insert_query ::= INSERT INTO full_table_name query_or_subquery */ + { 331, -1 }, /* (335) literal ::= NK_INTEGER */ + { 331, -1 }, /* (336) literal ::= NK_FLOAT */ + { 331, -1 }, /* (337) literal ::= NK_STRING */ + { 331, -1 }, /* (338) literal ::= NK_BOOL */ + { 331, -2 }, /* (339) literal ::= TIMESTAMP NK_STRING */ + { 331, -1 }, /* (340) literal ::= duration_literal */ + { 331, -1 }, /* (341) literal ::= NULL */ + { 331, -1 }, /* (342) literal ::= NK_QUESTION */ + { 375, -1 }, /* (343) duration_literal ::= NK_VARIABLE */ + { 409, -1 }, /* (344) signed ::= NK_INTEGER */ + { 409, -2 }, /* (345) signed ::= NK_PLUS NK_INTEGER */ + { 409, -2 }, /* (346) signed ::= NK_MINUS NK_INTEGER */ + { 409, -1 }, /* (347) signed ::= NK_FLOAT */ + { 409, -2 }, /* (348) signed ::= NK_PLUS NK_FLOAT */ + { 409, -2 }, /* (349) signed ::= NK_MINUS NK_FLOAT */ + { 364, -1 }, /* (350) signed_literal ::= signed */ + { 364, -1 }, /* (351) signed_literal ::= NK_STRING */ + { 364, -1 }, /* (352) signed_literal ::= NK_BOOL */ + { 364, -2 }, /* (353) signed_literal ::= TIMESTAMP NK_STRING */ + { 364, -1 }, /* (354) signed_literal ::= duration_literal */ + { 364, -1 }, /* (355) signed_literal ::= NULL */ + { 364, -1 }, /* (356) signed_literal ::= literal_func */ + { 364, -1 }, /* (357) signed_literal ::= NK_QUESTION */ + { 411, -1 }, /* (358) literal_list ::= signed_literal */ + { 411, -3 }, /* (359) literal_list ::= literal_list NK_COMMA signed_literal */ + { 339, -1 }, /* (360) db_name ::= NK_ID */ + { 370, -1 }, /* (361) table_name ::= NK_ID */ + { 362, -1 }, /* (362) column_name ::= NK_ID */ + { 377, -1 }, /* (363) function_name ::= NK_ID */ + { 412, -1 }, /* (364) table_alias ::= NK_ID */ + { 385, -1 }, /* (365) column_alias ::= NK_ID */ + { 333, -1 }, /* (366) user_name ::= NK_ID */ + { 340, -1 }, /* (367) topic_name ::= NK_ID */ + { 401, -1 }, /* (368) stream_name ::= NK_ID */ + { 395, -1 }, /* (369) cgroup_name ::= NK_ID */ + { 388, -1 }, /* (370) index_name ::= NK_ID */ + { 413, -1 }, /* (371) expr_or_subquery ::= expression */ + { 406, -1 }, /* (372) expression ::= literal */ + { 406, -1 }, /* (373) expression ::= pseudo_column */ + { 406, -1 }, /* (374) expression ::= column_reference */ + { 406, -1 }, /* (375) expression ::= function_expression */ + { 406, -1 }, /* (376) expression ::= case_when_expression */ + { 406, -3 }, /* (377) expression ::= NK_LP expression NK_RP */ + { 406, -2 }, /* (378) expression ::= NK_PLUS expr_or_subquery */ + { 406, -2 }, /* (379) expression ::= NK_MINUS expr_or_subquery */ + { 406, -3 }, /* (380) expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ + { 406, -3 }, /* (381) expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ + { 406, -3 }, /* (382) expression ::= expr_or_subquery NK_STAR expr_or_subquery */ + { 406, -3 }, /* (383) expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ + { 406, -3 }, /* (384) expression ::= expr_or_subquery NK_REM expr_or_subquery */ + { 406, -3 }, /* (385) expression ::= column_reference NK_ARROW NK_STRING */ + { 406, -3 }, /* (386) expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ + { 406, -3 }, /* (387) expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ + { 367, -1 }, /* (388) expression_list ::= expr_or_subquery */ + { 367, -3 }, /* (389) expression_list ::= expression_list NK_COMMA expr_or_subquery */ + { 415, -1 }, /* (390) column_reference ::= column_name */ + { 415, -3 }, /* (391) column_reference ::= table_name NK_DOT column_name */ + { 414, -1 }, /* (392) pseudo_column ::= ROWTS */ + { 414, -1 }, /* (393) pseudo_column ::= TBNAME */ + { 414, -3 }, /* (394) pseudo_column ::= table_name NK_DOT TBNAME */ + { 414, -1 }, /* (395) pseudo_column ::= QSTART */ + { 414, -1 }, /* (396) pseudo_column ::= QEND */ + { 414, -1 }, /* (397) pseudo_column ::= QDURATION */ + { 414, -1 }, /* (398) pseudo_column ::= WSTART */ + { 414, -1 }, /* (399) pseudo_column ::= WEND */ + { 414, -1 }, /* (400) pseudo_column ::= WDURATION */ + { 414, -1 }, /* (401) pseudo_column ::= IROWTS */ + { 414, -1 }, /* (402) pseudo_column ::= ISFILLED */ + { 414, -1 }, /* (403) pseudo_column ::= QTAGS */ + { 416, -4 }, /* (404) function_expression ::= function_name NK_LP expression_list NK_RP */ + { 416, -4 }, /* (405) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ + { 416, -6 }, /* (406) function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ + { 416, -1 }, /* (407) function_expression ::= literal_func */ + { 410, -3 }, /* (408) literal_func ::= noarg_func NK_LP NK_RP */ + { 410, -1 }, /* (409) literal_func ::= NOW */ + { 420, -1 }, /* (410) noarg_func ::= NOW */ + { 420, -1 }, /* (411) noarg_func ::= TODAY */ + { 420, -1 }, /* (412) noarg_func ::= TIMEZONE */ + { 420, -1 }, /* (413) noarg_func ::= DATABASE */ + { 420, -1 }, /* (414) noarg_func ::= CLIENT_VERSION */ + { 420, -1 }, /* (415) noarg_func ::= SERVER_VERSION */ + { 420, -1 }, /* (416) noarg_func ::= SERVER_STATUS */ + { 420, -1 }, /* (417) noarg_func ::= CURRENT_USER */ + { 420, -1 }, /* (418) noarg_func ::= USER */ + { 418, -1 }, /* (419) star_func ::= COUNT */ + { 418, -1 }, /* (420) star_func ::= FIRST */ + { 418, -1 }, /* (421) star_func ::= LAST */ + { 418, -1 }, /* (422) star_func ::= LAST_ROW */ + { 419, -1 }, /* (423) star_func_para_list ::= NK_STAR */ + { 419, -1 }, /* (424) star_func_para_list ::= other_para_list */ + { 421, -1 }, /* (425) other_para_list ::= star_func_para */ + { 421, -3 }, /* (426) other_para_list ::= other_para_list NK_COMMA star_func_para */ + { 422, -1 }, /* (427) star_func_para ::= expr_or_subquery */ + { 422, -3 }, /* (428) star_func_para ::= table_name NK_DOT NK_STAR */ + { 417, -4 }, /* (429) case_when_expression ::= CASE when_then_list case_when_else_opt END */ + { 417, -5 }, /* (430) case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ + { 423, -1 }, /* (431) when_then_list ::= when_then_expr */ + { 423, -2 }, /* (432) when_then_list ::= when_then_list when_then_expr */ + { 426, -4 }, /* (433) when_then_expr ::= WHEN common_expression THEN common_expression */ + { 424, 0 }, /* (434) case_when_else_opt ::= */ + { 424, -2 }, /* (435) case_when_else_opt ::= ELSE common_expression */ + { 427, -3 }, /* (436) predicate ::= expr_or_subquery compare_op expr_or_subquery */ + { 427, -5 }, /* (437) predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ + { 427, -6 }, /* (438) predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ + { 427, -3 }, /* (439) predicate ::= expr_or_subquery IS NULL */ + { 427, -4 }, /* (440) predicate ::= expr_or_subquery IS NOT NULL */ + { 427, -3 }, /* (441) predicate ::= expr_or_subquery in_op in_predicate_value */ + { 428, -1 }, /* (442) compare_op ::= NK_LT */ + { 428, -1 }, /* (443) compare_op ::= NK_GT */ + { 428, -1 }, /* (444) compare_op ::= NK_LE */ + { 428, -1 }, /* (445) compare_op ::= NK_GE */ + { 428, -1 }, /* (446) compare_op ::= NK_NE */ + { 428, -1 }, /* (447) compare_op ::= NK_EQ */ + { 428, -1 }, /* (448) compare_op ::= LIKE */ + { 428, -2 }, /* (449) compare_op ::= NOT LIKE */ + { 428, -1 }, /* (450) compare_op ::= MATCH */ + { 428, -1 }, /* (451) compare_op ::= NMATCH */ + { 428, -1 }, /* (452) compare_op ::= CONTAINS */ + { 429, -1 }, /* (453) in_op ::= IN */ + { 429, -2 }, /* (454) in_op ::= NOT IN */ + { 430, -3 }, /* (455) in_predicate_value ::= NK_LP literal_list NK_RP */ + { 431, -1 }, /* (456) boolean_value_expression ::= boolean_primary */ + { 431, -2 }, /* (457) boolean_value_expression ::= NOT boolean_primary */ + { 431, -3 }, /* (458) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ + { 431, -3 }, /* (459) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ + { 432, -1 }, /* (460) boolean_primary ::= predicate */ + { 432, -3 }, /* (461) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ + { 425, -1 }, /* (462) common_expression ::= expr_or_subquery */ + { 425, -1 }, /* (463) common_expression ::= boolean_value_expression */ + { 433, 0 }, /* (464) from_clause_opt ::= */ + { 433, -2 }, /* (465) from_clause_opt ::= FROM table_reference_list */ + { 434, -1 }, /* (466) table_reference_list ::= table_reference */ + { 434, -3 }, /* (467) table_reference_list ::= table_reference_list NK_COMMA table_reference */ + { 435, -1 }, /* (468) table_reference ::= table_primary */ + { 435, -1 }, /* (469) table_reference ::= joined_table */ + { 436, -2 }, /* (470) table_primary ::= table_name alias_opt */ + { 436, -4 }, /* (471) table_primary ::= db_name NK_DOT table_name alias_opt */ + { 436, -2 }, /* (472) table_primary ::= subquery alias_opt */ + { 436, -1 }, /* (473) table_primary ::= parenthesized_joined_table */ + { 438, 0 }, /* (474) alias_opt ::= */ + { 438, -1 }, /* (475) alias_opt ::= table_alias */ + { 438, -2 }, /* (476) alias_opt ::= AS table_alias */ + { 440, -3 }, /* (477) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ + { 440, -3 }, /* (478) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ + { 437, -6 }, /* (479) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ + { 441, 0 }, /* (480) join_type ::= */ + { 441, -1 }, /* (481) join_type ::= INNER */ + { 443, -12 }, /* (482) query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ + { 444, 0 }, /* (483) set_quantifier_opt ::= */ + { 444, -1 }, /* (484) set_quantifier_opt ::= DISTINCT */ + { 444, -1 }, /* (485) set_quantifier_opt ::= ALL */ + { 445, -1 }, /* (486) select_list ::= select_item */ + { 445, -3 }, /* (487) select_list ::= select_list NK_COMMA select_item */ + { 453, -1 }, /* (488) select_item ::= NK_STAR */ + { 453, -1 }, /* (489) select_item ::= common_expression */ + { 453, -2 }, /* (490) select_item ::= common_expression column_alias */ + { 453, -3 }, /* (491) select_item ::= common_expression AS column_alias */ + { 453, -3 }, /* (492) select_item ::= table_name NK_DOT NK_STAR */ + { 408, 0 }, /* (493) where_clause_opt ::= */ + { 408, -2 }, /* (494) where_clause_opt ::= WHERE search_condition */ + { 446, 0 }, /* (495) partition_by_clause_opt ::= */ + { 446, -3 }, /* (496) partition_by_clause_opt ::= PARTITION BY partition_list */ + { 454, -1 }, /* (497) partition_list ::= partition_item */ + { 454, -3 }, /* (498) partition_list ::= partition_list NK_COMMA partition_item */ + { 455, -1 }, /* (499) partition_item ::= expr_or_subquery */ + { 455, -2 }, /* (500) partition_item ::= expr_or_subquery column_alias */ + { 455, -3 }, /* (501) partition_item ::= expr_or_subquery AS column_alias */ + { 450, 0 }, /* (502) twindow_clause_opt ::= */ + { 450, -6 }, /* (503) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ + { 450, -4 }, /* (504) twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ + { 450, -6 }, /* (505) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ + { 450, -8 }, /* (506) twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ + { 450, -7 }, /* (507) twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ + { 390, 0 }, /* (508) sliding_opt ::= */ + { 390, -4 }, /* (509) sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ + { 449, 0 }, /* (510) fill_opt ::= */ + { 449, -4 }, /* (511) fill_opt ::= FILL NK_LP fill_mode NK_RP */ + { 449, -6 }, /* (512) fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ + { 449, -6 }, /* (513) fill_opt ::= FILL NK_LP VALUE_F NK_COMMA literal_list NK_RP */ + { 456, -1 }, /* (514) fill_mode ::= NONE */ + { 456, -1 }, /* (515) fill_mode ::= PREV */ + { 456, -1 }, /* (516) fill_mode ::= NULL */ + { 456, -1 }, /* (517) fill_mode ::= NULL_F */ + { 456, -1 }, /* (518) fill_mode ::= LINEAR */ + { 456, -1 }, /* (519) fill_mode ::= NEXT */ + { 451, 0 }, /* (520) group_by_clause_opt ::= */ + { 451, -3 }, /* (521) group_by_clause_opt ::= GROUP BY group_by_list */ + { 457, -1 }, /* (522) group_by_list ::= expr_or_subquery */ + { 457, -3 }, /* (523) group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ + { 452, 0 }, /* (524) having_clause_opt ::= */ + { 452, -2 }, /* (525) having_clause_opt ::= HAVING search_condition */ + { 447, 0 }, /* (526) range_opt ::= */ + { 447, -6 }, /* (527) range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ + { 448, 0 }, /* (528) every_opt ::= */ + { 448, -4 }, /* (529) every_opt ::= EVERY NK_LP duration_literal NK_RP */ + { 458, -4 }, /* (530) query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ + { 459, -1 }, /* (531) query_simple ::= query_specification */ + { 459, -1 }, /* (532) query_simple ::= union_query_expression */ + { 463, -4 }, /* (533) union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ + { 463, -3 }, /* (534) union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ + { 464, -1 }, /* (535) query_simple_or_subquery ::= query_simple */ + { 464, -1 }, /* (536) query_simple_or_subquery ::= subquery */ + { 394, -1 }, /* (537) query_or_subquery ::= query_expression */ + { 394, -1 }, /* (538) query_or_subquery ::= subquery */ + { 460, 0 }, /* (539) order_by_clause_opt ::= */ + { 460, -3 }, /* (540) order_by_clause_opt ::= ORDER BY sort_specification_list */ + { 461, 0 }, /* (541) slimit_clause_opt ::= */ + { 461, -2 }, /* (542) slimit_clause_opt ::= SLIMIT NK_INTEGER */ + { 461, -4 }, /* (543) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + { 461, -4 }, /* (544) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + { 462, 0 }, /* (545) limit_clause_opt ::= */ + { 462, -2 }, /* (546) limit_clause_opt ::= LIMIT NK_INTEGER */ + { 462, -4 }, /* (547) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ + { 462, -4 }, /* (548) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + { 439, -3 }, /* (549) subquery ::= NK_LP query_expression NK_RP */ + { 439, -3 }, /* (550) subquery ::= NK_LP subquery NK_RP */ + { 442, -1 }, /* (551) search_condition ::= common_expression */ + { 465, -1 }, /* (552) sort_specification_list ::= sort_specification */ + { 465, -3 }, /* (553) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ + { 466, -3 }, /* (554) sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ + { 467, 0 }, /* (555) ordering_specification_opt ::= */ + { 467, -1 }, /* (556) ordering_specification_opt ::= ASC */ + { 467, -1 }, /* (557) ordering_specification_opt ::= DESC */ + { 468, 0 }, /* (558) null_ordering_opt ::= */ + { 468, -2 }, /* (559) null_ordering_opt ::= NULLS FIRST */ + { 468, -2 }, /* (560) null_ordering_opt ::= NULLS LAST */ }; static void yy_accept(yyParser*); /* Forward Declaration */ @@ -3818,8 +3820,8 @@ static YYACTIONTYPE yy_reduce( yymsp[-2].minor.yy225 = yylhsminor.yy225; break; case 42: /* priv_level ::= topic_name */ - case 272: /* sma_func_name ::= function_name */ yytestcase(yyruleno==272); - case 474: /* alias_opt ::= table_alias */ yytestcase(yyruleno==474); + case 273: /* sma_func_name ::= function_name */ yytestcase(yyruleno==273); + case 475: /* alias_opt ::= table_alias */ yytestcase(yyruleno==475); { yylhsminor.yy225 = yymsp[0].minor.yy225; } yymsp[0].minor.yy225 = yylhsminor.yy225; break; @@ -3850,49 +3852,49 @@ static YYACTIONTYPE yy_reduce( case 51: /* dnode_endpoint ::= NK_STRING */ case 52: /* dnode_endpoint ::= NK_ID */ yytestcase(yyruleno==52); case 53: /* dnode_endpoint ::= NK_IPTOKEN */ yytestcase(yyruleno==53); - case 273: /* sma_func_name ::= COUNT */ yytestcase(yyruleno==273); - case 274: /* sma_func_name ::= FIRST */ yytestcase(yyruleno==274); - case 275: /* sma_func_name ::= LAST */ yytestcase(yyruleno==275); - case 276: /* sma_func_name ::= LAST_ROW */ yytestcase(yyruleno==276); - case 359: /* db_name ::= NK_ID */ yytestcase(yyruleno==359); - case 360: /* table_name ::= NK_ID */ yytestcase(yyruleno==360); - case 361: /* column_name ::= NK_ID */ yytestcase(yyruleno==361); - case 362: /* function_name ::= NK_ID */ yytestcase(yyruleno==362); - case 363: /* table_alias ::= NK_ID */ yytestcase(yyruleno==363); - case 364: /* column_alias ::= NK_ID */ yytestcase(yyruleno==364); - case 365: /* user_name ::= NK_ID */ yytestcase(yyruleno==365); - case 366: /* topic_name ::= NK_ID */ yytestcase(yyruleno==366); - case 367: /* stream_name ::= NK_ID */ yytestcase(yyruleno==367); - case 368: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==368); - case 369: /* index_name ::= NK_ID */ yytestcase(yyruleno==369); - case 409: /* noarg_func ::= NOW */ yytestcase(yyruleno==409); - case 410: /* noarg_func ::= TODAY */ yytestcase(yyruleno==410); - case 411: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==411); - case 412: /* noarg_func ::= DATABASE */ yytestcase(yyruleno==412); - case 413: /* noarg_func ::= CLIENT_VERSION */ yytestcase(yyruleno==413); - case 414: /* noarg_func ::= SERVER_VERSION */ yytestcase(yyruleno==414); - case 415: /* noarg_func ::= SERVER_STATUS */ yytestcase(yyruleno==415); - case 416: /* noarg_func ::= CURRENT_USER */ yytestcase(yyruleno==416); - case 417: /* noarg_func ::= USER */ yytestcase(yyruleno==417); - case 418: /* star_func ::= COUNT */ yytestcase(yyruleno==418); - case 419: /* star_func ::= FIRST */ yytestcase(yyruleno==419); - case 420: /* star_func ::= LAST */ yytestcase(yyruleno==420); - case 421: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==421); + case 274: /* sma_func_name ::= COUNT */ yytestcase(yyruleno==274); + case 275: /* sma_func_name ::= FIRST */ yytestcase(yyruleno==275); + case 276: /* sma_func_name ::= LAST */ yytestcase(yyruleno==276); + case 277: /* sma_func_name ::= LAST_ROW */ yytestcase(yyruleno==277); + case 360: /* db_name ::= NK_ID */ yytestcase(yyruleno==360); + case 361: /* table_name ::= NK_ID */ yytestcase(yyruleno==361); + case 362: /* column_name ::= NK_ID */ yytestcase(yyruleno==362); + case 363: /* function_name ::= NK_ID */ yytestcase(yyruleno==363); + case 364: /* table_alias ::= NK_ID */ yytestcase(yyruleno==364); + case 365: /* column_alias ::= NK_ID */ yytestcase(yyruleno==365); + case 366: /* user_name ::= NK_ID */ yytestcase(yyruleno==366); + case 367: /* topic_name ::= NK_ID */ yytestcase(yyruleno==367); + case 368: /* stream_name ::= NK_ID */ yytestcase(yyruleno==368); + case 369: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==369); + case 370: /* index_name ::= NK_ID */ yytestcase(yyruleno==370); + case 410: /* noarg_func ::= NOW */ yytestcase(yyruleno==410); + case 411: /* noarg_func ::= TODAY */ yytestcase(yyruleno==411); + case 412: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==412); + case 413: /* noarg_func ::= DATABASE */ yytestcase(yyruleno==413); + case 414: /* noarg_func ::= CLIENT_VERSION */ yytestcase(yyruleno==414); + case 415: /* noarg_func ::= SERVER_VERSION */ yytestcase(yyruleno==415); + case 416: /* noarg_func ::= SERVER_STATUS */ yytestcase(yyruleno==416); + case 417: /* noarg_func ::= CURRENT_USER */ yytestcase(yyruleno==417); + case 418: /* noarg_func ::= USER */ yytestcase(yyruleno==418); + case 419: /* star_func ::= COUNT */ yytestcase(yyruleno==419); + case 420: /* star_func ::= FIRST */ yytestcase(yyruleno==420); + case 421: /* star_func ::= LAST */ yytestcase(yyruleno==421); + case 422: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==422); { yylhsminor.yy225 = yymsp[0].minor.yy0; } yymsp[0].minor.yy225 = yylhsminor.yy225; break; case 54: /* force_opt ::= */ - case 73: /* not_exists_opt ::= */ yytestcase(yyruleno==73); - case 75: /* exists_opt ::= */ yytestcase(yyruleno==75); - case 293: /* analyze_opt ::= */ yytestcase(yyruleno==293); - case 300: /* agg_func_opt ::= */ yytestcase(yyruleno==300); - case 482: /* set_quantifier_opt ::= */ yytestcase(yyruleno==482); + case 74: /* not_exists_opt ::= */ yytestcase(yyruleno==74); + case 76: /* exists_opt ::= */ yytestcase(yyruleno==76); + case 294: /* analyze_opt ::= */ yytestcase(yyruleno==294); + case 301: /* agg_func_opt ::= */ yytestcase(yyruleno==301); + case 483: /* set_quantifier_opt ::= */ yytestcase(yyruleno==483); { yymsp[1].minor.yy103 = false; } break; case 55: /* force_opt ::= FORCE */ - case 294: /* analyze_opt ::= ANALYZE */ yytestcase(yyruleno==294); - case 301: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==301); - case 483: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==483); + case 295: /* analyze_opt ::= ANALYZE */ yytestcase(yyruleno==295); + case 302: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==302); + case 484: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==484); { yymsp[0].minor.yy103 = true; } break; case 56: /* cmd ::= ALTER LOCAL NK_STRING */ @@ -3943,98 +3945,101 @@ static YYACTIONTYPE yy_reduce( case 71: /* cmd ::= TRIM DATABASE db_name speed_opt */ { pCxt->pRootNode = createTrimDatabaseStmt(pCxt, &yymsp[-1].minor.yy225, yymsp[0].minor.yy508); } break; - case 72: /* not_exists_opt ::= IF NOT EXISTS */ + case 72: /* cmd ::= COMPACT DATABASE db_name */ +{ pCxt->pRootNode = createCompactStmt(pCxt, &yymsp[0].minor.yy225); } + break; + case 73: /* not_exists_opt ::= IF NOT EXISTS */ { yymsp[-2].minor.yy103 = true; } break; - case 74: /* exists_opt ::= IF EXISTS */ + case 75: /* exists_opt ::= IF EXISTS */ { yymsp[-1].minor.yy103 = true; } break; - case 76: /* db_options ::= */ + case 77: /* db_options ::= */ { yymsp[1].minor.yy42 = createDefaultDatabaseOptions(pCxt); } break; - case 77: /* db_options ::= db_options BUFFER NK_INTEGER */ + case 78: /* db_options ::= db_options BUFFER NK_INTEGER */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_BUFFER, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 78: /* db_options ::= db_options CACHEMODEL NK_STRING */ + case 79: /* db_options ::= db_options CACHEMODEL NK_STRING */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_CACHEMODEL, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 79: /* db_options ::= db_options CACHESIZE NK_INTEGER */ + case 80: /* db_options ::= db_options CACHESIZE NK_INTEGER */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_CACHESIZE, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 80: /* db_options ::= db_options COMP NK_INTEGER */ + case 81: /* db_options ::= db_options COMP NK_INTEGER */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_COMP, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 81: /* db_options ::= db_options DURATION NK_INTEGER */ - case 82: /* db_options ::= db_options DURATION NK_VARIABLE */ yytestcase(yyruleno==82); + case 82: /* db_options ::= db_options DURATION NK_INTEGER */ + case 83: /* db_options ::= db_options DURATION NK_VARIABLE */ yytestcase(yyruleno==83); { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_DAYS, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 83: /* db_options ::= db_options MAXROWS NK_INTEGER */ + case 84: /* db_options ::= db_options MAXROWS NK_INTEGER */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_MAXROWS, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 84: /* db_options ::= db_options MINROWS NK_INTEGER */ + case 85: /* db_options ::= db_options MINROWS NK_INTEGER */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_MINROWS, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 85: /* db_options ::= db_options KEEP integer_list */ - case 86: /* db_options ::= db_options KEEP variable_list */ yytestcase(yyruleno==86); + case 86: /* db_options ::= db_options KEEP integer_list */ + case 87: /* db_options ::= db_options KEEP variable_list */ yytestcase(yyruleno==87); { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_KEEP, yymsp[0].minor.yy110); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 87: /* db_options ::= db_options PAGES NK_INTEGER */ + case 88: /* db_options ::= db_options PAGES NK_INTEGER */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_PAGES, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 88: /* db_options ::= db_options PAGESIZE NK_INTEGER */ + case 89: /* db_options ::= db_options PAGESIZE NK_INTEGER */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_PAGESIZE, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 89: /* db_options ::= db_options TSDB_PAGESIZE NK_INTEGER */ + case 90: /* db_options ::= db_options TSDB_PAGESIZE NK_INTEGER */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_TSDB_PAGESIZE, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 90: /* db_options ::= db_options PRECISION NK_STRING */ + case 91: /* db_options ::= db_options PRECISION NK_STRING */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_PRECISION, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 91: /* db_options ::= db_options REPLICA NK_INTEGER */ + case 92: /* db_options ::= db_options REPLICA NK_INTEGER */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_REPLICA, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 92: /* db_options ::= db_options VGROUPS NK_INTEGER */ + case 93: /* db_options ::= db_options VGROUPS NK_INTEGER */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_VGROUPS, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 93: /* db_options ::= db_options SINGLE_STABLE NK_INTEGER */ + case 94: /* db_options ::= db_options SINGLE_STABLE NK_INTEGER */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_SINGLE_STABLE, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 94: /* db_options ::= db_options RETENTIONS retention_list */ + case 95: /* db_options ::= db_options RETENTIONS retention_list */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_RETENTIONS, yymsp[0].minor.yy110); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 95: /* db_options ::= db_options SCHEMALESS NK_INTEGER */ + case 96: /* db_options ::= db_options SCHEMALESS NK_INTEGER */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_SCHEMALESS, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 96: /* db_options ::= db_options WAL_LEVEL NK_INTEGER */ + case 97: /* db_options ::= db_options WAL_LEVEL NK_INTEGER */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_WAL, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 97: /* db_options ::= db_options WAL_FSYNC_PERIOD NK_INTEGER */ + case 98: /* db_options ::= db_options WAL_FSYNC_PERIOD NK_INTEGER */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_FSYNC, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 98: /* db_options ::= db_options WAL_RETENTION_PERIOD NK_INTEGER */ + case 99: /* db_options ::= db_options WAL_RETENTION_PERIOD NK_INTEGER */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_WAL_RETENTION_PERIOD, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 99: /* db_options ::= db_options WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ + case 100: /* db_options ::= db_options WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; @@ -4042,11 +4047,11 @@ static YYACTIONTYPE yy_reduce( } yymsp[-3].minor.yy42 = yylhsminor.yy42; break; - case 100: /* db_options ::= db_options WAL_RETENTION_SIZE NK_INTEGER */ + case 101: /* db_options ::= db_options WAL_RETENTION_SIZE NK_INTEGER */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_WAL_RETENTION_SIZE, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 101: /* db_options ::= db_options WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ + case 102: /* db_options ::= db_options WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; @@ -4054,756 +4059,756 @@ static YYACTIONTYPE yy_reduce( } yymsp[-3].minor.yy42 = yylhsminor.yy42; break; - case 102: /* db_options ::= db_options WAL_ROLL_PERIOD NK_INTEGER */ + case 103: /* db_options ::= db_options WAL_ROLL_PERIOD NK_INTEGER */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_WAL_ROLL_PERIOD, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 103: /* db_options ::= db_options WAL_SEGMENT_SIZE NK_INTEGER */ + case 104: /* db_options ::= db_options WAL_SEGMENT_SIZE NK_INTEGER */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_WAL_SEGMENT_SIZE, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 104: /* db_options ::= db_options STT_TRIGGER NK_INTEGER */ + case 105: /* db_options ::= db_options STT_TRIGGER NK_INTEGER */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_STT_TRIGGER, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 105: /* db_options ::= db_options TABLE_PREFIX NK_INTEGER */ + case 106: /* db_options ::= db_options TABLE_PREFIX NK_INTEGER */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_TABLE_PREFIX, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 106: /* db_options ::= db_options TABLE_SUFFIX NK_INTEGER */ + case 107: /* db_options ::= db_options TABLE_SUFFIX NK_INTEGER */ { yylhsminor.yy42 = setDatabaseOption(pCxt, yymsp[-2].minor.yy42, DB_OPTION_TABLE_SUFFIX, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 107: /* alter_db_options ::= alter_db_option */ + case 108: /* alter_db_options ::= alter_db_option */ { yylhsminor.yy42 = createAlterDatabaseOptions(pCxt); yylhsminor.yy42 = setAlterDatabaseOption(pCxt, yylhsminor.yy42, &yymsp[0].minor.yy459); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 108: /* alter_db_options ::= alter_db_options alter_db_option */ + case 109: /* alter_db_options ::= alter_db_options alter_db_option */ { yylhsminor.yy42 = setAlterDatabaseOption(pCxt, yymsp[-1].minor.yy42, &yymsp[0].minor.yy459); } yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 109: /* alter_db_option ::= BUFFER NK_INTEGER */ + case 110: /* alter_db_option ::= BUFFER NK_INTEGER */ { yymsp[-1].minor.yy459.type = DB_OPTION_BUFFER; yymsp[-1].minor.yy459.val = yymsp[0].minor.yy0; } break; - case 110: /* alter_db_option ::= CACHEMODEL NK_STRING */ + case 111: /* alter_db_option ::= CACHEMODEL NK_STRING */ { yymsp[-1].minor.yy459.type = DB_OPTION_CACHEMODEL; yymsp[-1].minor.yy459.val = yymsp[0].minor.yy0; } break; - case 111: /* alter_db_option ::= CACHESIZE NK_INTEGER */ + case 112: /* alter_db_option ::= CACHESIZE NK_INTEGER */ { yymsp[-1].minor.yy459.type = DB_OPTION_CACHESIZE; yymsp[-1].minor.yy459.val = yymsp[0].minor.yy0; } break; - case 112: /* alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */ + case 113: /* alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */ { yymsp[-1].minor.yy459.type = DB_OPTION_FSYNC; yymsp[-1].minor.yy459.val = yymsp[0].minor.yy0; } break; - case 113: /* alter_db_option ::= KEEP integer_list */ - case 114: /* alter_db_option ::= KEEP variable_list */ yytestcase(yyruleno==114); + case 114: /* alter_db_option ::= KEEP integer_list */ + case 115: /* alter_db_option ::= KEEP variable_list */ yytestcase(yyruleno==115); { yymsp[-1].minor.yy459.type = DB_OPTION_KEEP; yymsp[-1].minor.yy459.pList = yymsp[0].minor.yy110; } break; - case 115: /* alter_db_option ::= PAGES NK_INTEGER */ + case 116: /* alter_db_option ::= PAGES NK_INTEGER */ { yymsp[-1].minor.yy459.type = DB_OPTION_PAGES; yymsp[-1].minor.yy459.val = yymsp[0].minor.yy0; } break; - case 116: /* alter_db_option ::= REPLICA NK_INTEGER */ + case 117: /* alter_db_option ::= REPLICA NK_INTEGER */ { yymsp[-1].minor.yy459.type = DB_OPTION_REPLICA; yymsp[-1].minor.yy459.val = yymsp[0].minor.yy0; } break; - case 117: /* alter_db_option ::= WAL_LEVEL NK_INTEGER */ + case 118: /* alter_db_option ::= WAL_LEVEL NK_INTEGER */ { yymsp[-1].minor.yy459.type = DB_OPTION_WAL; yymsp[-1].minor.yy459.val = yymsp[0].minor.yy0; } break; - case 118: /* alter_db_option ::= STT_TRIGGER NK_INTEGER */ + case 119: /* alter_db_option ::= STT_TRIGGER NK_INTEGER */ { yymsp[-1].minor.yy459.type = DB_OPTION_STT_TRIGGER; yymsp[-1].minor.yy459.val = yymsp[0].minor.yy0; } break; - case 119: /* integer_list ::= NK_INTEGER */ + case 120: /* integer_list ::= NK_INTEGER */ { yylhsminor.yy110 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy110 = yylhsminor.yy110; break; - case 120: /* integer_list ::= integer_list NK_COMMA NK_INTEGER */ - case 328: /* dnode_list ::= dnode_list DNODE NK_INTEGER */ yytestcase(yyruleno==328); + case 121: /* integer_list ::= integer_list NK_COMMA NK_INTEGER */ + case 329: /* dnode_list ::= dnode_list DNODE NK_INTEGER */ yytestcase(yyruleno==329); { yylhsminor.yy110 = addNodeToList(pCxt, yymsp[-2].minor.yy110, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } yymsp[-2].minor.yy110 = yylhsminor.yy110; break; - case 121: /* variable_list ::= NK_VARIABLE */ + case 122: /* variable_list ::= NK_VARIABLE */ { yylhsminor.yy110 = createNodeList(pCxt, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy110 = yylhsminor.yy110; break; - case 122: /* variable_list ::= variable_list NK_COMMA NK_VARIABLE */ + case 123: /* variable_list ::= variable_list NK_COMMA NK_VARIABLE */ { yylhsminor.yy110 = addNodeToList(pCxt, yymsp[-2].minor.yy110, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } yymsp[-2].minor.yy110 = yylhsminor.yy110; break; - case 123: /* retention_list ::= retention */ - case 145: /* multi_create_clause ::= create_subtable_clause */ yytestcase(yyruleno==145); - case 148: /* multi_drop_clause ::= drop_table_clause */ yytestcase(yyruleno==148); - case 155: /* column_def_list ::= column_def */ yytestcase(yyruleno==155); - case 199: /* rollup_func_list ::= rollup_func_name */ yytestcase(yyruleno==199); - case 204: /* col_name_list ::= col_name */ yytestcase(yyruleno==204); - case 255: /* tag_list_opt ::= tag_item */ yytestcase(yyruleno==255); - case 269: /* func_list ::= func */ yytestcase(yyruleno==269); - case 357: /* literal_list ::= signed_literal */ yytestcase(yyruleno==357); - case 424: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==424); - case 430: /* when_then_list ::= when_then_expr */ yytestcase(yyruleno==430); - case 485: /* select_list ::= select_item */ yytestcase(yyruleno==485); - case 496: /* partition_list ::= partition_item */ yytestcase(yyruleno==496); - case 551: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==551); + case 124: /* retention_list ::= retention */ + case 146: /* multi_create_clause ::= create_subtable_clause */ yytestcase(yyruleno==146); + case 149: /* multi_drop_clause ::= drop_table_clause */ yytestcase(yyruleno==149); + case 156: /* column_def_list ::= column_def */ yytestcase(yyruleno==156); + case 200: /* rollup_func_list ::= rollup_func_name */ yytestcase(yyruleno==200); + case 205: /* col_name_list ::= col_name */ yytestcase(yyruleno==205); + case 256: /* tag_list_opt ::= tag_item */ yytestcase(yyruleno==256); + case 270: /* func_list ::= func */ yytestcase(yyruleno==270); + case 358: /* literal_list ::= signed_literal */ yytestcase(yyruleno==358); + case 425: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==425); + case 431: /* when_then_list ::= when_then_expr */ yytestcase(yyruleno==431); + case 486: /* select_list ::= select_item */ yytestcase(yyruleno==486); + case 497: /* partition_list ::= partition_item */ yytestcase(yyruleno==497); + case 552: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==552); { yylhsminor.yy110 = createNodeList(pCxt, yymsp[0].minor.yy42); } yymsp[0].minor.yy110 = yylhsminor.yy110; break; - case 124: /* retention_list ::= retention_list NK_COMMA retention */ - case 156: /* column_def_list ::= column_def_list NK_COMMA column_def */ yytestcase(yyruleno==156); - case 200: /* rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ yytestcase(yyruleno==200); - case 205: /* col_name_list ::= col_name_list NK_COMMA col_name */ yytestcase(yyruleno==205); - case 256: /* tag_list_opt ::= tag_list_opt NK_COMMA tag_item */ yytestcase(yyruleno==256); - case 270: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==270); - case 358: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==358); - case 425: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==425); - case 486: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==486); - case 497: /* partition_list ::= partition_list NK_COMMA partition_item */ yytestcase(yyruleno==497); - case 552: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==552); + case 125: /* retention_list ::= retention_list NK_COMMA retention */ + case 157: /* column_def_list ::= column_def_list NK_COMMA column_def */ yytestcase(yyruleno==157); + case 201: /* rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ yytestcase(yyruleno==201); + case 206: /* col_name_list ::= col_name_list NK_COMMA col_name */ yytestcase(yyruleno==206); + case 257: /* tag_list_opt ::= tag_list_opt NK_COMMA tag_item */ yytestcase(yyruleno==257); + case 271: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==271); + case 359: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==359); + case 426: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==426); + case 487: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==487); + case 498: /* partition_list ::= partition_list NK_COMMA partition_item */ yytestcase(yyruleno==498); + case 553: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==553); { yylhsminor.yy110 = addNodeToList(pCxt, yymsp[-2].minor.yy110, yymsp[0].minor.yy42); } yymsp[-2].minor.yy110 = yylhsminor.yy110; break; - case 125: /* retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ + case 126: /* retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ { yylhsminor.yy42 = createNodeListNodeEx(pCxt, createDurationValueNode(pCxt, &yymsp[-2].minor.yy0), createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 126: /* speed_opt ::= */ - case 302: /* bufsize_opt ::= */ yytestcase(yyruleno==302); + case 127: /* speed_opt ::= */ + case 303: /* bufsize_opt ::= */ yytestcase(yyruleno==303); { yymsp[1].minor.yy508 = 0; } break; - case 127: /* speed_opt ::= MAX_SPEED NK_INTEGER */ - case 303: /* bufsize_opt ::= BUFSIZE NK_INTEGER */ yytestcase(yyruleno==303); + case 128: /* speed_opt ::= MAX_SPEED NK_INTEGER */ + case 304: /* bufsize_opt ::= BUFSIZE NK_INTEGER */ yytestcase(yyruleno==304); { yymsp[-1].minor.yy508 = taosStr2Int32(yymsp[0].minor.yy0.z, NULL, 10); } break; - case 128: /* cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ - case 130: /* cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ yytestcase(yyruleno==130); + case 129: /* cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ + case 131: /* cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ yytestcase(yyruleno==131); { pCxt->pRootNode = createCreateTableStmt(pCxt, yymsp[-6].minor.yy103, yymsp[-5].minor.yy42, yymsp[-3].minor.yy110, yymsp[-1].minor.yy110, yymsp[0].minor.yy42); } break; - case 129: /* cmd ::= CREATE TABLE multi_create_clause */ + case 130: /* cmd ::= CREATE TABLE multi_create_clause */ { pCxt->pRootNode = createCreateMultiTableStmt(pCxt, yymsp[0].minor.yy110); } break; - case 131: /* cmd ::= DROP TABLE multi_drop_clause */ + case 132: /* cmd ::= DROP TABLE multi_drop_clause */ { pCxt->pRootNode = createDropTableStmt(pCxt, yymsp[0].minor.yy110); } break; - case 132: /* cmd ::= DROP STABLE exists_opt full_table_name */ + case 133: /* cmd ::= DROP STABLE exists_opt full_table_name */ { pCxt->pRootNode = createDropSuperTableStmt(pCxt, yymsp[-1].minor.yy103, yymsp[0].minor.yy42); } break; - case 133: /* cmd ::= ALTER TABLE alter_table_clause */ - case 330: /* cmd ::= query_or_subquery */ yytestcase(yyruleno==330); - case 331: /* cmd ::= insert_query */ yytestcase(yyruleno==331); + case 134: /* cmd ::= ALTER TABLE alter_table_clause */ + case 331: /* cmd ::= query_or_subquery */ yytestcase(yyruleno==331); + case 332: /* cmd ::= insert_query */ yytestcase(yyruleno==332); { pCxt->pRootNode = yymsp[0].minor.yy42; } break; - case 134: /* cmd ::= ALTER STABLE alter_table_clause */ + case 135: /* cmd ::= ALTER STABLE alter_table_clause */ { pCxt->pRootNode = setAlterSuperTableType(yymsp[0].minor.yy42); } break; - case 135: /* alter_table_clause ::= full_table_name alter_table_options */ + case 136: /* alter_table_clause ::= full_table_name alter_table_options */ { yylhsminor.yy42 = createAlterTableModifyOptions(pCxt, yymsp[-1].minor.yy42, yymsp[0].minor.yy42); } yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 136: /* alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ + case 137: /* alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ { yylhsminor.yy42 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy42, TSDB_ALTER_TABLE_ADD_COLUMN, &yymsp[-1].minor.yy225, yymsp[0].minor.yy448); } yymsp[-4].minor.yy42 = yylhsminor.yy42; break; - case 137: /* alter_table_clause ::= full_table_name DROP COLUMN column_name */ + case 138: /* alter_table_clause ::= full_table_name DROP COLUMN column_name */ { yylhsminor.yy42 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy42, TSDB_ALTER_TABLE_DROP_COLUMN, &yymsp[0].minor.yy225); } yymsp[-3].minor.yy42 = yylhsminor.yy42; break; - case 138: /* alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ + case 139: /* alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ { yylhsminor.yy42 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy42, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, &yymsp[-1].minor.yy225, yymsp[0].minor.yy448); } yymsp[-4].minor.yy42 = yylhsminor.yy42; break; - case 139: /* alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ + case 140: /* alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ { yylhsminor.yy42 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy42, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &yymsp[-1].minor.yy225, &yymsp[0].minor.yy225); } yymsp[-4].minor.yy42 = yylhsminor.yy42; break; - case 140: /* alter_table_clause ::= full_table_name ADD TAG column_name type_name */ + case 141: /* alter_table_clause ::= full_table_name ADD TAG column_name type_name */ { yylhsminor.yy42 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy42, TSDB_ALTER_TABLE_ADD_TAG, &yymsp[-1].minor.yy225, yymsp[0].minor.yy448); } yymsp[-4].minor.yy42 = yylhsminor.yy42; break; - case 141: /* alter_table_clause ::= full_table_name DROP TAG column_name */ + case 142: /* alter_table_clause ::= full_table_name DROP TAG column_name */ { yylhsminor.yy42 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy42, TSDB_ALTER_TABLE_DROP_TAG, &yymsp[0].minor.yy225); } yymsp[-3].minor.yy42 = yylhsminor.yy42; break; - case 142: /* alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ + case 143: /* alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ { yylhsminor.yy42 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy42, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &yymsp[-1].minor.yy225, yymsp[0].minor.yy448); } yymsp[-4].minor.yy42 = yylhsminor.yy42; break; - case 143: /* alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ + case 144: /* alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ { yylhsminor.yy42 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy42, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &yymsp[-1].minor.yy225, &yymsp[0].minor.yy225); } yymsp[-4].minor.yy42 = yylhsminor.yy42; break; - case 144: /* alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ + case 145: /* alter_table_clause ::= full_table_name SET TAG column_name NK_EQ signed_literal */ { yylhsminor.yy42 = createAlterTableSetTag(pCxt, yymsp[-5].minor.yy42, &yymsp[-2].minor.yy225, yymsp[0].minor.yy42); } yymsp[-5].minor.yy42 = yylhsminor.yy42; break; - case 146: /* multi_create_clause ::= multi_create_clause create_subtable_clause */ - case 149: /* multi_drop_clause ::= multi_drop_clause drop_table_clause */ yytestcase(yyruleno==149); - case 431: /* when_then_list ::= when_then_list when_then_expr */ yytestcase(yyruleno==431); + case 147: /* multi_create_clause ::= multi_create_clause create_subtable_clause */ + case 150: /* multi_drop_clause ::= multi_drop_clause drop_table_clause */ yytestcase(yyruleno==150); + case 432: /* when_then_list ::= when_then_list when_then_expr */ yytestcase(yyruleno==432); { yylhsminor.yy110 = addNodeToList(pCxt, yymsp[-1].minor.yy110, yymsp[0].minor.yy42); } yymsp[-1].minor.yy110 = yylhsminor.yy110; break; - case 147: /* create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP expression_list NK_RP table_options */ + case 148: /* create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP expression_list NK_RP table_options */ { yylhsminor.yy42 = createCreateSubTableClause(pCxt, yymsp[-9].minor.yy103, yymsp[-8].minor.yy42, yymsp[-6].minor.yy42, yymsp[-5].minor.yy110, yymsp[-2].minor.yy110, yymsp[0].minor.yy42); } yymsp[-9].minor.yy42 = yylhsminor.yy42; break; - case 150: /* drop_table_clause ::= exists_opt full_table_name */ + case 151: /* drop_table_clause ::= exists_opt full_table_name */ { yylhsminor.yy42 = createDropTableClause(pCxt, yymsp[-1].minor.yy103, yymsp[0].minor.yy42); } yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 151: /* specific_cols_opt ::= */ - case 182: /* tags_def_opt ::= */ yytestcase(yyruleno==182); - case 254: /* tag_list_opt ::= */ yytestcase(yyruleno==254); - case 306: /* col_list_opt ::= */ yytestcase(yyruleno==306); - case 308: /* tag_def_or_ref_opt ::= */ yytestcase(yyruleno==308); - case 494: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==494); - case 519: /* group_by_clause_opt ::= */ yytestcase(yyruleno==519); - case 538: /* order_by_clause_opt ::= */ yytestcase(yyruleno==538); + case 152: /* specific_cols_opt ::= */ + case 183: /* tags_def_opt ::= */ yytestcase(yyruleno==183); + case 255: /* tag_list_opt ::= */ yytestcase(yyruleno==255); + case 307: /* col_list_opt ::= */ yytestcase(yyruleno==307); + case 309: /* tag_def_or_ref_opt ::= */ yytestcase(yyruleno==309); + case 495: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==495); + case 520: /* group_by_clause_opt ::= */ yytestcase(yyruleno==520); + case 539: /* order_by_clause_opt ::= */ yytestcase(yyruleno==539); { yymsp[1].minor.yy110 = NULL; } break; - case 152: /* specific_cols_opt ::= NK_LP col_name_list NK_RP */ - case 307: /* col_list_opt ::= NK_LP col_name_list NK_RP */ yytestcase(yyruleno==307); + case 153: /* specific_cols_opt ::= NK_LP col_name_list NK_RP */ + case 308: /* col_list_opt ::= NK_LP col_name_list NK_RP */ yytestcase(yyruleno==308); { yymsp[-2].minor.yy110 = yymsp[-1].minor.yy110; } break; - case 153: /* full_table_name ::= table_name */ + case 154: /* full_table_name ::= table_name */ { yylhsminor.yy42 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy225, NULL); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 154: /* full_table_name ::= db_name NK_DOT table_name */ + case 155: /* full_table_name ::= db_name NK_DOT table_name */ { yylhsminor.yy42 = createRealTableNode(pCxt, &yymsp[-2].minor.yy225, &yymsp[0].minor.yy225, NULL); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 157: /* column_def ::= column_name type_name */ + case 158: /* column_def ::= column_name type_name */ { yylhsminor.yy42 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy225, yymsp[0].minor.yy448, NULL); } yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 158: /* column_def ::= column_name type_name COMMENT NK_STRING */ + case 159: /* column_def ::= column_name type_name COMMENT NK_STRING */ { yylhsminor.yy42 = createColumnDefNode(pCxt, &yymsp[-3].minor.yy225, yymsp[-2].minor.yy448, &yymsp[0].minor.yy0); } yymsp[-3].minor.yy42 = yylhsminor.yy42; break; - case 159: /* type_name ::= BOOL */ + case 160: /* type_name ::= BOOL */ { yymsp[0].minor.yy448 = createDataType(TSDB_DATA_TYPE_BOOL); } break; - case 160: /* type_name ::= TINYINT */ + case 161: /* type_name ::= TINYINT */ { yymsp[0].minor.yy448 = createDataType(TSDB_DATA_TYPE_TINYINT); } break; - case 161: /* type_name ::= SMALLINT */ + case 162: /* type_name ::= SMALLINT */ { yymsp[0].minor.yy448 = createDataType(TSDB_DATA_TYPE_SMALLINT); } break; - case 162: /* type_name ::= INT */ - case 163: /* type_name ::= INTEGER */ yytestcase(yyruleno==163); + case 163: /* type_name ::= INT */ + case 164: /* type_name ::= INTEGER */ yytestcase(yyruleno==164); { yymsp[0].minor.yy448 = createDataType(TSDB_DATA_TYPE_INT); } break; - case 164: /* type_name ::= BIGINT */ + case 165: /* type_name ::= BIGINT */ { yymsp[0].minor.yy448 = createDataType(TSDB_DATA_TYPE_BIGINT); } break; - case 165: /* type_name ::= FLOAT */ + case 166: /* type_name ::= FLOAT */ { yymsp[0].minor.yy448 = createDataType(TSDB_DATA_TYPE_FLOAT); } break; - case 166: /* type_name ::= DOUBLE */ + case 167: /* type_name ::= DOUBLE */ { yymsp[0].minor.yy448 = createDataType(TSDB_DATA_TYPE_DOUBLE); } break; - case 167: /* type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ + case 168: /* type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ { yymsp[-3].minor.yy448 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy0); } break; - case 168: /* type_name ::= TIMESTAMP */ + case 169: /* type_name ::= TIMESTAMP */ { yymsp[0].minor.yy448 = createDataType(TSDB_DATA_TYPE_TIMESTAMP); } break; - case 169: /* type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ + case 170: /* type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ { yymsp[-3].minor.yy448 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, &yymsp[-1].minor.yy0); } break; - case 170: /* type_name ::= TINYINT UNSIGNED */ + case 171: /* type_name ::= TINYINT UNSIGNED */ { yymsp[-1].minor.yy448 = createDataType(TSDB_DATA_TYPE_UTINYINT); } break; - case 171: /* type_name ::= SMALLINT UNSIGNED */ + case 172: /* type_name ::= SMALLINT UNSIGNED */ { yymsp[-1].minor.yy448 = createDataType(TSDB_DATA_TYPE_USMALLINT); } break; - case 172: /* type_name ::= INT UNSIGNED */ + case 173: /* type_name ::= INT UNSIGNED */ { yymsp[-1].minor.yy448 = createDataType(TSDB_DATA_TYPE_UINT); } break; - case 173: /* type_name ::= BIGINT UNSIGNED */ + case 174: /* type_name ::= BIGINT UNSIGNED */ { yymsp[-1].minor.yy448 = createDataType(TSDB_DATA_TYPE_UBIGINT); } break; - case 174: /* type_name ::= JSON */ + case 175: /* type_name ::= JSON */ { yymsp[0].minor.yy448 = createDataType(TSDB_DATA_TYPE_JSON); } break; - case 175: /* type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ + case 176: /* type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ { yymsp[-3].minor.yy448 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, &yymsp[-1].minor.yy0); } break; - case 176: /* type_name ::= MEDIUMBLOB */ + case 177: /* type_name ::= MEDIUMBLOB */ { yymsp[0].minor.yy448 = createDataType(TSDB_DATA_TYPE_MEDIUMBLOB); } break; - case 177: /* type_name ::= BLOB */ + case 178: /* type_name ::= BLOB */ { yymsp[0].minor.yy448 = createDataType(TSDB_DATA_TYPE_BLOB); } break; - case 178: /* type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ + case 179: /* type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ { yymsp[-3].minor.yy448 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, &yymsp[-1].minor.yy0); } break; - case 179: /* type_name ::= DECIMAL */ + case 180: /* type_name ::= DECIMAL */ { yymsp[0].minor.yy448 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; - case 180: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ + case 181: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ { yymsp[-3].minor.yy448 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; - case 181: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ + case 182: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ { yymsp[-5].minor.yy448 = createDataType(TSDB_DATA_TYPE_DECIMAL); } break; - case 183: /* tags_def_opt ::= tags_def */ - case 309: /* tag_def_or_ref_opt ::= tags_def */ yytestcase(yyruleno==309); - case 423: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==423); + case 184: /* tags_def_opt ::= tags_def */ + case 310: /* tag_def_or_ref_opt ::= tags_def */ yytestcase(yyruleno==310); + case 424: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==424); { yylhsminor.yy110 = yymsp[0].minor.yy110; } yymsp[0].minor.yy110 = yylhsminor.yy110; break; - case 184: /* tags_def ::= TAGS NK_LP column_def_list NK_RP */ - case 310: /* tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP */ yytestcase(yyruleno==310); + case 185: /* tags_def ::= TAGS NK_LP column_def_list NK_RP */ + case 311: /* tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP */ yytestcase(yyruleno==311); { yymsp[-3].minor.yy110 = yymsp[-1].minor.yy110; } break; - case 185: /* table_options ::= */ + case 186: /* table_options ::= */ { yymsp[1].minor.yy42 = createDefaultTableOptions(pCxt); } break; - case 186: /* table_options ::= table_options COMMENT NK_STRING */ + case 187: /* table_options ::= table_options COMMENT NK_STRING */ { yylhsminor.yy42 = setTableOption(pCxt, yymsp[-2].minor.yy42, TABLE_OPTION_COMMENT, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 187: /* table_options ::= table_options MAX_DELAY duration_list */ + case 188: /* table_options ::= table_options MAX_DELAY duration_list */ { yylhsminor.yy42 = setTableOption(pCxt, yymsp[-2].minor.yy42, TABLE_OPTION_MAXDELAY, yymsp[0].minor.yy110); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 188: /* table_options ::= table_options WATERMARK duration_list */ + case 189: /* table_options ::= table_options WATERMARK duration_list */ { yylhsminor.yy42 = setTableOption(pCxt, yymsp[-2].minor.yy42, TABLE_OPTION_WATERMARK, yymsp[0].minor.yy110); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 189: /* table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ + case 190: /* table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ { yylhsminor.yy42 = setTableOption(pCxt, yymsp[-4].minor.yy42, TABLE_OPTION_ROLLUP, yymsp[-1].minor.yy110); } yymsp[-4].minor.yy42 = yylhsminor.yy42; break; - case 190: /* table_options ::= table_options TTL NK_INTEGER */ + case 191: /* table_options ::= table_options TTL NK_INTEGER */ { yylhsminor.yy42 = setTableOption(pCxt, yymsp[-2].minor.yy42, TABLE_OPTION_TTL, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 191: /* table_options ::= table_options SMA NK_LP col_name_list NK_RP */ + case 192: /* table_options ::= table_options SMA NK_LP col_name_list NK_RP */ { yylhsminor.yy42 = setTableOption(pCxt, yymsp[-4].minor.yy42, TABLE_OPTION_SMA, yymsp[-1].minor.yy110); } yymsp[-4].minor.yy42 = yylhsminor.yy42; break; - case 192: /* table_options ::= table_options DELETE_MARK duration_list */ + case 193: /* table_options ::= table_options DELETE_MARK duration_list */ { yylhsminor.yy42 = setTableOption(pCxt, yymsp[-2].minor.yy42, TABLE_OPTION_DELETE_MARK, yymsp[0].minor.yy110); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 193: /* alter_table_options ::= alter_table_option */ + case 194: /* alter_table_options ::= alter_table_option */ { yylhsminor.yy42 = createAlterTableOptions(pCxt); yylhsminor.yy42 = setTableOption(pCxt, yylhsminor.yy42, yymsp[0].minor.yy459.type, &yymsp[0].minor.yy459.val); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 194: /* alter_table_options ::= alter_table_options alter_table_option */ + case 195: /* alter_table_options ::= alter_table_options alter_table_option */ { yylhsminor.yy42 = setTableOption(pCxt, yymsp[-1].minor.yy42, yymsp[0].minor.yy459.type, &yymsp[0].minor.yy459.val); } yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 195: /* alter_table_option ::= COMMENT NK_STRING */ + case 196: /* alter_table_option ::= COMMENT NK_STRING */ { yymsp[-1].minor.yy459.type = TABLE_OPTION_COMMENT; yymsp[-1].minor.yy459.val = yymsp[0].minor.yy0; } break; - case 196: /* alter_table_option ::= TTL NK_INTEGER */ + case 197: /* alter_table_option ::= TTL NK_INTEGER */ { yymsp[-1].minor.yy459.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy459.val = yymsp[0].minor.yy0; } break; - case 197: /* duration_list ::= duration_literal */ - case 387: /* expression_list ::= expr_or_subquery */ yytestcase(yyruleno==387); + case 198: /* duration_list ::= duration_literal */ + case 388: /* expression_list ::= expr_or_subquery */ yytestcase(yyruleno==388); { yylhsminor.yy110 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy42)); } yymsp[0].minor.yy110 = yylhsminor.yy110; break; - case 198: /* duration_list ::= duration_list NK_COMMA duration_literal */ - case 388: /* expression_list ::= expression_list NK_COMMA expr_or_subquery */ yytestcase(yyruleno==388); + case 199: /* duration_list ::= duration_list NK_COMMA duration_literal */ + case 389: /* expression_list ::= expression_list NK_COMMA expr_or_subquery */ yytestcase(yyruleno==389); { yylhsminor.yy110 = addNodeToList(pCxt, yymsp[-2].minor.yy110, releaseRawExprNode(pCxt, yymsp[0].minor.yy42)); } yymsp[-2].minor.yy110 = yylhsminor.yy110; break; - case 201: /* rollup_func_name ::= function_name */ + case 202: /* rollup_func_name ::= function_name */ { yylhsminor.yy42 = createFunctionNode(pCxt, &yymsp[0].minor.yy225, NULL); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 202: /* rollup_func_name ::= FIRST */ - case 203: /* rollup_func_name ::= LAST */ yytestcase(yyruleno==203); - case 258: /* tag_item ::= QTAGS */ yytestcase(yyruleno==258); + case 203: /* rollup_func_name ::= FIRST */ + case 204: /* rollup_func_name ::= LAST */ yytestcase(yyruleno==204); + case 259: /* tag_item ::= QTAGS */ yytestcase(yyruleno==259); { yylhsminor.yy42 = createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 206: /* col_name ::= column_name */ - case 259: /* tag_item ::= column_name */ yytestcase(yyruleno==259); + case 207: /* col_name ::= column_name */ + case 260: /* tag_item ::= column_name */ yytestcase(yyruleno==260); { yylhsminor.yy42 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy225); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 207: /* cmd ::= SHOW DNODES */ + case 208: /* cmd ::= SHOW DNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DNODES_STMT); } break; - case 208: /* cmd ::= SHOW USERS */ + case 209: /* cmd ::= SHOW USERS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_USERS_STMT); } break; - case 209: /* cmd ::= SHOW USER PRIVILEGES */ + case 210: /* cmd ::= SHOW USER PRIVILEGES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_USER_PRIVILEGES_STMT); } break; - case 210: /* cmd ::= SHOW DATABASES */ + case 211: /* cmd ::= SHOW DATABASES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DATABASES_STMT); } break; - case 211: /* cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */ + case 212: /* cmd ::= SHOW db_name_cond_opt TABLES like_pattern_opt */ { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TABLES_STMT, yymsp[-2].minor.yy42, yymsp[0].minor.yy42, OP_TYPE_LIKE); } break; - case 212: /* cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ + case 213: /* cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_STABLES_STMT, yymsp[-2].minor.yy42, yymsp[0].minor.yy42, OP_TYPE_LIKE); } break; - case 213: /* cmd ::= SHOW db_name_cond_opt VGROUPS */ + case 214: /* cmd ::= SHOW db_name_cond_opt VGROUPS */ { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, yymsp[-1].minor.yy42, NULL, OP_TYPE_LIKE); } break; - case 214: /* cmd ::= SHOW MNODES */ + case 215: /* cmd ::= SHOW MNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_MNODES_STMT); } break; - case 215: /* cmd ::= SHOW QNODES */ + case 216: /* cmd ::= SHOW QNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QNODES_STMT); } break; - case 216: /* cmd ::= SHOW FUNCTIONS */ + case 217: /* cmd ::= SHOW FUNCTIONS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_FUNCTIONS_STMT); } break; - case 217: /* cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ + case 218: /* cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, yymsp[0].minor.yy42, yymsp[-1].minor.yy42, OP_TYPE_EQUAL); } break; - case 218: /* cmd ::= SHOW STREAMS */ + case 219: /* cmd ::= SHOW STREAMS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_STREAMS_STMT); } break; - case 219: /* cmd ::= SHOW ACCOUNTS */ + case 220: /* cmd ::= SHOW ACCOUNTS */ { pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); } break; - case 220: /* cmd ::= SHOW APPS */ + case 221: /* cmd ::= SHOW APPS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_APPS_STMT); } break; - case 221: /* cmd ::= SHOW CONNECTIONS */ + case 222: /* cmd ::= SHOW CONNECTIONS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CONNECTIONS_STMT); } break; - case 222: /* cmd ::= SHOW LICENCES */ - case 223: /* cmd ::= SHOW GRANTS */ yytestcase(yyruleno==223); + case 223: /* cmd ::= SHOW LICENCES */ + case 224: /* cmd ::= SHOW GRANTS */ yytestcase(yyruleno==224); { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_LICENCES_STMT); } break; - case 224: /* cmd ::= SHOW CREATE DATABASE db_name */ + case 225: /* cmd ::= SHOW CREATE DATABASE db_name */ { pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &yymsp[0].minor.yy225); } break; - case 225: /* cmd ::= SHOW CREATE TABLE full_table_name */ + case 226: /* cmd ::= SHOW CREATE TABLE full_table_name */ { pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, yymsp[0].minor.yy42); } break; - case 226: /* cmd ::= SHOW CREATE STABLE full_table_name */ + case 227: /* cmd ::= SHOW CREATE STABLE full_table_name */ { pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, yymsp[0].minor.yy42); } break; - case 227: /* cmd ::= SHOW QUERIES */ + case 228: /* cmd ::= SHOW QUERIES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QUERIES_STMT); } break; - case 228: /* cmd ::= SHOW SCORES */ + case 229: /* cmd ::= SHOW SCORES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SCORES_STMT); } break; - case 229: /* cmd ::= SHOW TOPICS */ + case 230: /* cmd ::= SHOW TOPICS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TOPICS_STMT); } break; - case 230: /* cmd ::= SHOW VARIABLES */ - case 231: /* cmd ::= SHOW CLUSTER VARIABLES */ yytestcase(yyruleno==231); + case 231: /* cmd ::= SHOW VARIABLES */ + case 232: /* cmd ::= SHOW CLUSTER VARIABLES */ yytestcase(yyruleno==232); { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_VARIABLES_STMT); } break; - case 232: /* cmd ::= SHOW LOCAL VARIABLES */ + case 233: /* cmd ::= SHOW LOCAL VARIABLES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT); } break; - case 233: /* cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */ + case 234: /* cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */ { pCxt->pRootNode = createShowDnodeVariablesStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[-2].minor.yy0), yymsp[0].minor.yy42); } break; - case 234: /* cmd ::= SHOW BNODES */ + case 235: /* cmd ::= SHOW BNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_BNODES_STMT); } break; - case 235: /* cmd ::= SHOW SNODES */ + case 236: /* cmd ::= SHOW SNODES */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SNODES_STMT); } break; - case 236: /* cmd ::= SHOW CLUSTER */ + case 237: /* cmd ::= SHOW CLUSTER */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CLUSTER_STMT); } break; - case 237: /* cmd ::= SHOW TRANSACTIONS */ + case 238: /* cmd ::= SHOW TRANSACTIONS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TRANSACTIONS_STMT); } break; - case 238: /* cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ + case 239: /* cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ { pCxt->pRootNode = createShowTableDistributedStmt(pCxt, yymsp[0].minor.yy42); } break; - case 239: /* cmd ::= SHOW CONSUMERS */ + case 240: /* cmd ::= SHOW CONSUMERS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CONSUMERS_STMT); } break; - case 240: /* cmd ::= SHOW SUBSCRIPTIONS */ + case 241: /* cmd ::= SHOW SUBSCRIPTIONS */ { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT); } break; - case 241: /* cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ + case 242: /* cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, yymsp[0].minor.yy42, yymsp[-1].minor.yy42, OP_TYPE_EQUAL); } break; - case 242: /* cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */ + case 243: /* cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */ { pCxt->pRootNode = createShowTableTagsStmt(pCxt, yymsp[-1].minor.yy42, yymsp[0].minor.yy42, yymsp[-3].minor.yy110); } break; - case 243: /* cmd ::= SHOW VNODES NK_INTEGER */ + case 244: /* cmd ::= SHOW VNODES NK_INTEGER */ { pCxt->pRootNode = createShowVnodesStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0), NULL); } break; - case 244: /* cmd ::= SHOW VNODES NK_STRING */ + case 245: /* cmd ::= SHOW VNODES NK_STRING */ { pCxt->pRootNode = createShowVnodesStmt(pCxt, NULL, createValueNode(pCxt, TSDB_DATA_TYPE_VARCHAR, &yymsp[0].minor.yy0)); } break; - case 245: /* cmd ::= SHOW db_name_cond_opt ALIVE */ + case 246: /* cmd ::= SHOW db_name_cond_opt ALIVE */ { pCxt->pRootNode = createShowAliveStmt(pCxt, yymsp[-1].minor.yy42, QUERY_NODE_SHOW_DB_ALIVE_STMT); } break; - case 246: /* cmd ::= SHOW CLUSTER ALIVE */ + case 247: /* cmd ::= SHOW CLUSTER ALIVE */ { pCxt->pRootNode = createShowAliveStmt(pCxt, NULL, QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT); } break; - case 247: /* db_name_cond_opt ::= */ - case 252: /* from_db_opt ::= */ yytestcase(yyruleno==252); + case 248: /* db_name_cond_opt ::= */ + case 253: /* from_db_opt ::= */ yytestcase(yyruleno==253); { yymsp[1].minor.yy42 = createDefaultDatabaseCondValue(pCxt); } break; - case 248: /* db_name_cond_opt ::= db_name NK_DOT */ + case 249: /* db_name_cond_opt ::= db_name NK_DOT */ { yylhsminor.yy42 = createIdentifierValueNode(pCxt, &yymsp[-1].minor.yy225); } yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 249: /* like_pattern_opt ::= */ - case 318: /* subtable_opt ::= */ yytestcase(yyruleno==318); - case 433: /* case_when_else_opt ::= */ yytestcase(yyruleno==433); - case 463: /* from_clause_opt ::= */ yytestcase(yyruleno==463); - case 492: /* where_clause_opt ::= */ yytestcase(yyruleno==492); - case 501: /* twindow_clause_opt ::= */ yytestcase(yyruleno==501); - case 507: /* sliding_opt ::= */ yytestcase(yyruleno==507); - case 509: /* fill_opt ::= */ yytestcase(yyruleno==509); - case 523: /* having_clause_opt ::= */ yytestcase(yyruleno==523); - case 525: /* range_opt ::= */ yytestcase(yyruleno==525); - case 527: /* every_opt ::= */ yytestcase(yyruleno==527); - case 540: /* slimit_clause_opt ::= */ yytestcase(yyruleno==540); - case 544: /* limit_clause_opt ::= */ yytestcase(yyruleno==544); + case 250: /* like_pattern_opt ::= */ + case 319: /* subtable_opt ::= */ yytestcase(yyruleno==319); + case 434: /* case_when_else_opt ::= */ yytestcase(yyruleno==434); + case 464: /* from_clause_opt ::= */ yytestcase(yyruleno==464); + case 493: /* where_clause_opt ::= */ yytestcase(yyruleno==493); + case 502: /* twindow_clause_opt ::= */ yytestcase(yyruleno==502); + case 508: /* sliding_opt ::= */ yytestcase(yyruleno==508); + case 510: /* fill_opt ::= */ yytestcase(yyruleno==510); + case 524: /* having_clause_opt ::= */ yytestcase(yyruleno==524); + case 526: /* range_opt ::= */ yytestcase(yyruleno==526); + case 528: /* every_opt ::= */ yytestcase(yyruleno==528); + case 541: /* slimit_clause_opt ::= */ yytestcase(yyruleno==541); + case 545: /* limit_clause_opt ::= */ yytestcase(yyruleno==545); { yymsp[1].minor.yy42 = NULL; } break; - case 250: /* like_pattern_opt ::= LIKE NK_STRING */ + case 251: /* like_pattern_opt ::= LIKE NK_STRING */ { yymsp[-1].minor.yy42 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } break; - case 251: /* table_name_cond ::= table_name */ + case 252: /* table_name_cond ::= table_name */ { yylhsminor.yy42 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy225); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 253: /* from_db_opt ::= FROM db_name */ + case 254: /* from_db_opt ::= FROM db_name */ { yymsp[-1].minor.yy42 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy225); } break; - case 257: /* tag_item ::= TBNAME */ + case 258: /* tag_item ::= TBNAME */ { yylhsminor.yy42 = setProjectionAlias(pCxt, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL), &yymsp[0].minor.yy0); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 260: /* tag_item ::= column_name column_alias */ + case 261: /* tag_item ::= column_name column_alias */ { yylhsminor.yy42 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-1].minor.yy225), &yymsp[0].minor.yy225); } yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 261: /* tag_item ::= column_name AS column_alias */ + case 262: /* tag_item ::= column_name AS column_alias */ { yylhsminor.yy42 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-2].minor.yy225), &yymsp[0].minor.yy225); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 262: /* cmd ::= CREATE SMA INDEX not_exists_opt full_index_name ON full_table_name index_options */ + case 263: /* cmd ::= CREATE SMA INDEX not_exists_opt full_index_name ON full_table_name index_options */ { pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_SMA, yymsp[-4].minor.yy103, yymsp[-3].minor.yy42, yymsp[-1].minor.yy42, NULL, yymsp[0].minor.yy42); } break; - case 263: /* cmd ::= CREATE INDEX not_exists_opt full_index_name ON full_table_name NK_LP col_name_list NK_RP */ + case 264: /* cmd ::= CREATE INDEX not_exists_opt full_index_name ON full_table_name NK_LP col_name_list NK_RP */ { pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_NORMAL, yymsp[-6].minor.yy103, yymsp[-5].minor.yy42, yymsp[-3].minor.yy42, yymsp[-1].minor.yy110, NULL); } break; - case 264: /* cmd ::= DROP INDEX exists_opt full_index_name */ + case 265: /* cmd ::= DROP INDEX exists_opt full_index_name */ { pCxt->pRootNode = createDropIndexStmt(pCxt, yymsp[-1].minor.yy103, yymsp[0].minor.yy42); } break; - case 265: /* full_index_name ::= index_name */ + case 266: /* full_index_name ::= index_name */ { yylhsminor.yy42 = createRealTableNodeForIndexName(pCxt, NULL, &yymsp[0].minor.yy225); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 266: /* full_index_name ::= db_name NK_DOT index_name */ + case 267: /* full_index_name ::= db_name NK_DOT index_name */ { yylhsminor.yy42 = createRealTableNodeForIndexName(pCxt, &yymsp[-2].minor.yy225, &yymsp[0].minor.yy225); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 267: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ + case 268: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ { yymsp[-9].minor.yy42 = createIndexOption(pCxt, yymsp[-7].minor.yy110, releaseRawExprNode(pCxt, yymsp[-3].minor.yy42), NULL, yymsp[-1].minor.yy42, yymsp[0].minor.yy42); } break; - case 268: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt */ + case 269: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt sma_stream_opt */ { yymsp[-11].minor.yy42 = createIndexOption(pCxt, yymsp[-9].minor.yy110, releaseRawExprNode(pCxt, yymsp[-5].minor.yy42), releaseRawExprNode(pCxt, yymsp[-3].minor.yy42), yymsp[-1].minor.yy42, yymsp[0].minor.yy42); } break; - case 271: /* func ::= sma_func_name NK_LP expression_list NK_RP */ + case 272: /* func ::= sma_func_name NK_LP expression_list NK_RP */ { yylhsminor.yy42 = createFunctionNode(pCxt, &yymsp[-3].minor.yy225, yymsp[-1].minor.yy110); } yymsp[-3].minor.yy42 = yylhsminor.yy42; break; - case 277: /* sma_stream_opt ::= */ - case 311: /* stream_options ::= */ yytestcase(yyruleno==311); + case 278: /* sma_stream_opt ::= */ + case 312: /* stream_options ::= */ yytestcase(yyruleno==312); { yymsp[1].minor.yy42 = createStreamOptions(pCxt); } break; - case 278: /* sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */ - case 315: /* stream_options ::= stream_options WATERMARK duration_literal */ yytestcase(yyruleno==315); + case 279: /* sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */ + case 316: /* stream_options ::= stream_options WATERMARK duration_literal */ yytestcase(yyruleno==316); { ((SStreamOptions*)yymsp[-2].minor.yy42)->pWatermark = releaseRawExprNode(pCxt, yymsp[0].minor.yy42); yylhsminor.yy42 = yymsp[-2].minor.yy42; } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 279: /* sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */ + case 280: /* sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */ { ((SStreamOptions*)yymsp[-2].minor.yy42)->pDelay = releaseRawExprNode(pCxt, yymsp[0].minor.yy42); yylhsminor.yy42 = yymsp[-2].minor.yy42; } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 280: /* sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */ + case 281: /* sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */ { ((SStreamOptions*)yymsp[-2].minor.yy42)->pDeleteMark = releaseRawExprNode(pCxt, yymsp[0].minor.yy42); yylhsminor.yy42 = yymsp[-2].minor.yy42; } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 281: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */ + case 282: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */ { pCxt->pRootNode = createCreateTopicStmtUseQuery(pCxt, yymsp[-3].minor.yy103, &yymsp[-2].minor.yy225, yymsp[0].minor.yy42); } break; - case 282: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name */ + case 283: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS DATABASE db_name */ { pCxt->pRootNode = createCreateTopicStmtUseDb(pCxt, yymsp[-4].minor.yy103, &yymsp[-3].minor.yy225, &yymsp[0].minor.yy225, false); } break; - case 283: /* cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS DATABASE db_name */ + case 284: /* cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS DATABASE db_name */ { pCxt->pRootNode = createCreateTopicStmtUseDb(pCxt, yymsp[-6].minor.yy103, &yymsp[-5].minor.yy225, &yymsp[0].minor.yy225, true); } break; - case 284: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name */ + case 285: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS STABLE full_table_name */ { pCxt->pRootNode = createCreateTopicStmtUseTable(pCxt, yymsp[-4].minor.yy103, &yymsp[-3].minor.yy225, yymsp[0].minor.yy42, false); } break; - case 285: /* cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS STABLE full_table_name */ + case 286: /* cmd ::= CREATE TOPIC not_exists_opt topic_name WITH META AS STABLE full_table_name */ { pCxt->pRootNode = createCreateTopicStmtUseTable(pCxt, yymsp[-6].minor.yy103, &yymsp[-5].minor.yy225, yymsp[0].minor.yy42, true); } break; - case 286: /* cmd ::= DROP TOPIC exists_opt topic_name */ + case 287: /* cmd ::= DROP TOPIC exists_opt topic_name */ { pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy103, &yymsp[0].minor.yy225); } break; - case 287: /* cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ + case 288: /* cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ { pCxt->pRootNode = createDropCGroupStmt(pCxt, yymsp[-3].minor.yy103, &yymsp[-2].minor.yy225, &yymsp[0].minor.yy225); } break; - case 288: /* cmd ::= DESC full_table_name */ - case 289: /* cmd ::= DESCRIBE full_table_name */ yytestcase(yyruleno==289); + case 289: /* cmd ::= DESC full_table_name */ + case 290: /* cmd ::= DESCRIBE full_table_name */ yytestcase(yyruleno==290); { pCxt->pRootNode = createDescribeStmt(pCxt, yymsp[0].minor.yy42); } break; - case 290: /* cmd ::= RESET QUERY CACHE */ + case 291: /* cmd ::= RESET QUERY CACHE */ { pCxt->pRootNode = createResetQueryCacheStmt(pCxt); } break; - case 291: /* cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */ - case 292: /* cmd ::= EXPLAIN analyze_opt explain_options insert_query */ yytestcase(yyruleno==292); + case 292: /* cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */ + case 293: /* cmd ::= EXPLAIN analyze_opt explain_options insert_query */ yytestcase(yyruleno==293); { pCxt->pRootNode = createExplainStmt(pCxt, yymsp[-2].minor.yy103, yymsp[-1].minor.yy42, yymsp[0].minor.yy42); } break; - case 295: /* explain_options ::= */ + case 296: /* explain_options ::= */ { yymsp[1].minor.yy42 = createDefaultExplainOptions(pCxt); } break; - case 296: /* explain_options ::= explain_options VERBOSE NK_BOOL */ + case 297: /* explain_options ::= explain_options VERBOSE NK_BOOL */ { yylhsminor.yy42 = setExplainVerbose(pCxt, yymsp[-2].minor.yy42, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 297: /* explain_options ::= explain_options RATIO NK_FLOAT */ + case 298: /* explain_options ::= explain_options RATIO NK_FLOAT */ { yylhsminor.yy42 = setExplainRatio(pCxt, yymsp[-2].minor.yy42, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 298: /* cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */ + case 299: /* cmd ::= CREATE agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt */ { pCxt->pRootNode = createCreateFunctionStmt(pCxt, yymsp[-6].minor.yy103, yymsp[-8].minor.yy103, &yymsp[-5].minor.yy225, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy448, yymsp[0].minor.yy508); } break; - case 299: /* cmd ::= DROP FUNCTION exists_opt function_name */ + case 300: /* cmd ::= DROP FUNCTION exists_opt function_name */ { pCxt->pRootNode = createDropFunctionStmt(pCxt, yymsp[-1].minor.yy103, &yymsp[0].minor.yy225); } break; - case 304: /* cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery */ + case 305: /* cmd ::= CREATE STREAM not_exists_opt stream_name stream_options INTO full_table_name col_list_opt tag_def_or_ref_opt subtable_opt AS query_or_subquery */ { pCxt->pRootNode = createCreateStreamStmt(pCxt, yymsp[-9].minor.yy103, &yymsp[-8].minor.yy225, yymsp[-5].minor.yy42, yymsp[-7].minor.yy42, yymsp[-3].minor.yy110, yymsp[-2].minor.yy42, yymsp[0].minor.yy42, yymsp[-4].minor.yy110); } break; - case 305: /* cmd ::= DROP STREAM exists_opt stream_name */ + case 306: /* cmd ::= DROP STREAM exists_opt stream_name */ { pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy103, &yymsp[0].minor.yy225); } break; - case 312: /* stream_options ::= stream_options TRIGGER AT_ONCE */ + case 313: /* stream_options ::= stream_options TRIGGER AT_ONCE */ { ((SStreamOptions*)yymsp[-2].minor.yy42)->triggerType = STREAM_TRIGGER_AT_ONCE; yylhsminor.yy42 = yymsp[-2].minor.yy42; } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 313: /* stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ + case 314: /* stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ { ((SStreamOptions*)yymsp[-2].minor.yy42)->triggerType = STREAM_TRIGGER_WINDOW_CLOSE; yylhsminor.yy42 = yymsp[-2].minor.yy42; } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 314: /* stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ + case 315: /* stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ { ((SStreamOptions*)yymsp[-3].minor.yy42)->triggerType = STREAM_TRIGGER_MAX_DELAY; ((SStreamOptions*)yymsp[-3].minor.yy42)->pDelay = releaseRawExprNode(pCxt, yymsp[0].minor.yy42); yylhsminor.yy42 = yymsp[-3].minor.yy42; } yymsp[-3].minor.yy42 = yylhsminor.yy42; break; - case 316: /* stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ + case 317: /* stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ { ((SStreamOptions*)yymsp[-3].minor.yy42)->ignoreExpired = taosStr2Int8(yymsp[0].minor.yy0.z, NULL, 10); yylhsminor.yy42 = yymsp[-3].minor.yy42; } yymsp[-3].minor.yy42 = yylhsminor.yy42; break; - case 317: /* stream_options ::= stream_options FILL_HISTORY NK_INTEGER */ + case 318: /* stream_options ::= stream_options FILL_HISTORY NK_INTEGER */ { ((SStreamOptions*)yymsp[-2].minor.yy42)->fillHistory = taosStr2Int8(yymsp[0].minor.yy0.z, NULL, 10); yylhsminor.yy42 = yymsp[-2].minor.yy42; } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 319: /* subtable_opt ::= SUBTABLE NK_LP expression NK_RP */ - case 508: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ yytestcase(yyruleno==508); - case 528: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==528); + case 320: /* subtable_opt ::= SUBTABLE NK_LP expression NK_RP */ + case 509: /* sliding_opt ::= SLIDING NK_LP duration_literal NK_RP */ yytestcase(yyruleno==509); + case 529: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==529); { yymsp[-3].minor.yy42 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy42); } break; - case 320: /* cmd ::= KILL CONNECTION NK_INTEGER */ + case 321: /* cmd ::= KILL CONNECTION NK_INTEGER */ { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_CONNECTION_STMT, &yymsp[0].minor.yy0); } break; - case 321: /* cmd ::= KILL QUERY NK_STRING */ + case 322: /* cmd ::= KILL QUERY NK_STRING */ { pCxt->pRootNode = createKillQueryStmt(pCxt, &yymsp[0].minor.yy0); } break; - case 322: /* cmd ::= KILL TRANSACTION NK_INTEGER */ + case 323: /* cmd ::= KILL TRANSACTION NK_INTEGER */ { pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_TRANSACTION_STMT, &yymsp[0].minor.yy0); } break; - case 323: /* cmd ::= BALANCE VGROUP */ + case 324: /* cmd ::= BALANCE VGROUP */ { pCxt->pRootNode = createBalanceVgroupStmt(pCxt); } break; - case 324: /* cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ + case 325: /* cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ { pCxt->pRootNode = createMergeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } break; - case 325: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ + case 326: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ { pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy110); } break; - case 326: /* cmd ::= SPLIT VGROUP NK_INTEGER */ + case 327: /* cmd ::= SPLIT VGROUP NK_INTEGER */ { pCxt->pRootNode = createSplitVgroupStmt(pCxt, &yymsp[0].minor.yy0); } break; - case 327: /* dnode_list ::= DNODE NK_INTEGER */ + case 328: /* dnode_list ::= DNODE NK_INTEGER */ { yymsp[-1].minor.yy110 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } break; - case 329: /* cmd ::= DELETE FROM full_table_name where_clause_opt */ + case 330: /* cmd ::= DELETE FROM full_table_name where_clause_opt */ { pCxt->pRootNode = createDeleteStmt(pCxt, yymsp[-1].minor.yy42, yymsp[0].minor.yy42); } break; - case 332: /* insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */ + case 333: /* insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */ { yymsp[-6].minor.yy42 = createInsertStmt(pCxt, yymsp[-4].minor.yy42, yymsp[-2].minor.yy110, yymsp[0].minor.yy42); } break; - case 333: /* insert_query ::= INSERT INTO full_table_name query_or_subquery */ + case 334: /* insert_query ::= INSERT INTO full_table_name query_or_subquery */ { yymsp[-3].minor.yy42 = createInsertStmt(pCxt, yymsp[-1].minor.yy42, NULL, yymsp[0].minor.yy42); } break; - case 334: /* literal ::= NK_INTEGER */ + case 335: /* literal ::= NK_INTEGER */ { yylhsminor.yy42 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 335: /* literal ::= NK_FLOAT */ + case 336: /* literal ::= NK_FLOAT */ { yylhsminor.yy42 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 336: /* literal ::= NK_STRING */ + case 337: /* literal ::= NK_STRING */ { yylhsminor.yy42 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 337: /* literal ::= NK_BOOL */ + case 338: /* literal ::= NK_BOOL */ { yylhsminor.yy42 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 338: /* literal ::= TIMESTAMP NK_STRING */ + case 339: /* literal ::= TIMESTAMP NK_STRING */ { yylhsminor.yy42 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); } yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 339: /* literal ::= duration_literal */ - case 349: /* signed_literal ::= signed */ yytestcase(yyruleno==349); - case 370: /* expr_or_subquery ::= expression */ yytestcase(yyruleno==370); - case 371: /* expression ::= literal */ yytestcase(yyruleno==371); - case 372: /* expression ::= pseudo_column */ yytestcase(yyruleno==372); - case 373: /* expression ::= column_reference */ yytestcase(yyruleno==373); - case 374: /* expression ::= function_expression */ yytestcase(yyruleno==374); - case 375: /* expression ::= case_when_expression */ yytestcase(yyruleno==375); - case 406: /* function_expression ::= literal_func */ yytestcase(yyruleno==406); - case 455: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==455); - case 459: /* boolean_primary ::= predicate */ yytestcase(yyruleno==459); - case 461: /* common_expression ::= expr_or_subquery */ yytestcase(yyruleno==461); - case 462: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==462); - case 465: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==465); - case 467: /* table_reference ::= table_primary */ yytestcase(yyruleno==467); - case 468: /* table_reference ::= joined_table */ yytestcase(yyruleno==468); - case 472: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==472); - case 530: /* query_simple ::= query_specification */ yytestcase(yyruleno==530); - case 531: /* query_simple ::= union_query_expression */ yytestcase(yyruleno==531); - case 534: /* query_simple_or_subquery ::= query_simple */ yytestcase(yyruleno==534); - case 536: /* query_or_subquery ::= query_expression */ yytestcase(yyruleno==536); + case 340: /* literal ::= duration_literal */ + case 350: /* signed_literal ::= signed */ yytestcase(yyruleno==350); + case 371: /* expr_or_subquery ::= expression */ yytestcase(yyruleno==371); + case 372: /* expression ::= literal */ yytestcase(yyruleno==372); + case 373: /* expression ::= pseudo_column */ yytestcase(yyruleno==373); + case 374: /* expression ::= column_reference */ yytestcase(yyruleno==374); + case 375: /* expression ::= function_expression */ yytestcase(yyruleno==375); + case 376: /* expression ::= case_when_expression */ yytestcase(yyruleno==376); + case 407: /* function_expression ::= literal_func */ yytestcase(yyruleno==407); + case 456: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==456); + case 460: /* boolean_primary ::= predicate */ yytestcase(yyruleno==460); + case 462: /* common_expression ::= expr_or_subquery */ yytestcase(yyruleno==462); + case 463: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==463); + case 466: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==466); + case 468: /* table_reference ::= table_primary */ yytestcase(yyruleno==468); + case 469: /* table_reference ::= joined_table */ yytestcase(yyruleno==469); + case 473: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==473); + case 531: /* query_simple ::= query_specification */ yytestcase(yyruleno==531); + case 532: /* query_simple ::= union_query_expression */ yytestcase(yyruleno==532); + case 535: /* query_simple_or_subquery ::= query_simple */ yytestcase(yyruleno==535); + case 537: /* query_or_subquery ::= query_expression */ yytestcase(yyruleno==537); { yylhsminor.yy42 = yymsp[0].minor.yy42; } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 340: /* literal ::= NULL */ + case 341: /* literal ::= NULL */ { yylhsminor.yy42 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 341: /* literal ::= NK_QUESTION */ + case 342: /* literal ::= NK_QUESTION */ { yylhsminor.yy42 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 342: /* duration_literal ::= NK_VARIABLE */ + case 343: /* duration_literal ::= NK_VARIABLE */ { yylhsminor.yy42 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 343: /* signed ::= NK_INTEGER */ + case 344: /* signed ::= NK_INTEGER */ { yylhsminor.yy42 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 344: /* signed ::= NK_PLUS NK_INTEGER */ + case 345: /* signed ::= NK_PLUS NK_INTEGER */ { yymsp[-1].minor.yy42 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } break; - case 345: /* signed ::= NK_MINUS NK_INTEGER */ + case 346: /* signed ::= NK_MINUS NK_INTEGER */ { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; @@ -4811,14 +4816,14 @@ static YYACTIONTYPE yy_reduce( } yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 346: /* signed ::= NK_FLOAT */ + case 347: /* signed ::= NK_FLOAT */ { yylhsminor.yy42 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 347: /* signed ::= NK_PLUS NK_FLOAT */ + case 348: /* signed ::= NK_PLUS NK_FLOAT */ { yymsp[-1].minor.yy42 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } break; - case 348: /* signed ::= NK_MINUS NK_FLOAT */ + case 349: /* signed ::= NK_MINUS NK_FLOAT */ { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; @@ -4826,57 +4831,57 @@ static YYACTIONTYPE yy_reduce( } yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 350: /* signed_literal ::= NK_STRING */ + case 351: /* signed_literal ::= NK_STRING */ { yylhsminor.yy42 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 351: /* signed_literal ::= NK_BOOL */ + case 352: /* signed_literal ::= NK_BOOL */ { yylhsminor.yy42 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 352: /* signed_literal ::= TIMESTAMP NK_STRING */ + case 353: /* signed_literal ::= TIMESTAMP NK_STRING */ { yymsp[-1].minor.yy42 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } break; - case 353: /* signed_literal ::= duration_literal */ - case 355: /* signed_literal ::= literal_func */ yytestcase(yyruleno==355); - case 426: /* star_func_para ::= expr_or_subquery */ yytestcase(yyruleno==426); - case 488: /* select_item ::= common_expression */ yytestcase(yyruleno==488); - case 498: /* partition_item ::= expr_or_subquery */ yytestcase(yyruleno==498); - case 535: /* query_simple_or_subquery ::= subquery */ yytestcase(yyruleno==535); - case 537: /* query_or_subquery ::= subquery */ yytestcase(yyruleno==537); - case 550: /* search_condition ::= common_expression */ yytestcase(yyruleno==550); + case 354: /* signed_literal ::= duration_literal */ + case 356: /* signed_literal ::= literal_func */ yytestcase(yyruleno==356); + case 427: /* star_func_para ::= expr_or_subquery */ yytestcase(yyruleno==427); + case 489: /* select_item ::= common_expression */ yytestcase(yyruleno==489); + case 499: /* partition_item ::= expr_or_subquery */ yytestcase(yyruleno==499); + case 536: /* query_simple_or_subquery ::= subquery */ yytestcase(yyruleno==536); + case 538: /* query_or_subquery ::= subquery */ yytestcase(yyruleno==538); + case 551: /* search_condition ::= common_expression */ yytestcase(yyruleno==551); { yylhsminor.yy42 = releaseRawExprNode(pCxt, yymsp[0].minor.yy42); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 354: /* signed_literal ::= NULL */ + case 355: /* signed_literal ::= NULL */ { yylhsminor.yy42 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 356: /* signed_literal ::= NK_QUESTION */ + case 357: /* signed_literal ::= NK_QUESTION */ { yylhsminor.yy42 = createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 376: /* expression ::= NK_LP expression NK_RP */ - case 460: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==460); - case 549: /* subquery ::= NK_LP subquery NK_RP */ yytestcase(yyruleno==549); + case 377: /* expression ::= NK_LP expression NK_RP */ + case 461: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==461); + case 550: /* subquery ::= NK_LP subquery NK_RP */ yytestcase(yyruleno==550); { yylhsminor.yy42 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy42)); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 377: /* expression ::= NK_PLUS expr_or_subquery */ + case 378: /* expression ::= NK_PLUS expr_or_subquery */ { SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy42); yylhsminor.yy42 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy42)); } yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 378: /* expression ::= NK_MINUS expr_or_subquery */ + case 379: /* expression ::= NK_MINUS expr_or_subquery */ { SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy42); yylhsminor.yy42 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy42), NULL)); } yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 379: /* expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ + case 380: /* expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy42); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy42); @@ -4884,7 +4889,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 380: /* expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ + case 381: /* expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy42); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy42); @@ -4892,7 +4897,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 381: /* expression ::= expr_or_subquery NK_STAR expr_or_subquery */ + case 382: /* expression ::= expr_or_subquery NK_STAR expr_or_subquery */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy42); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy42); @@ -4900,7 +4905,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 382: /* expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ + case 383: /* expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy42); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy42); @@ -4908,7 +4913,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 383: /* expression ::= expr_or_subquery NK_REM expr_or_subquery */ + case 384: /* expression ::= expr_or_subquery NK_REM expr_or_subquery */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy42); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy42); @@ -4916,14 +4921,14 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 384: /* expression ::= column_reference NK_ARROW NK_STRING */ + case 385: /* expression ::= column_reference NK_ARROW NK_STRING */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy42); yylhsminor.yy42 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy42), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0))); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 385: /* expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ + case 386: /* expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy42); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy42); @@ -4931,7 +4936,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 386: /* expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ + case 387: /* expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy42); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy42); @@ -4939,71 +4944,71 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 389: /* column_reference ::= column_name */ + case 390: /* column_reference ::= column_name */ { yylhsminor.yy42 = createRawExprNode(pCxt, &yymsp[0].minor.yy225, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy225)); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 390: /* column_reference ::= table_name NK_DOT column_name */ + case 391: /* column_reference ::= table_name NK_DOT column_name */ { yylhsminor.yy42 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy225, &yymsp[0].minor.yy225, createColumnNode(pCxt, &yymsp[-2].minor.yy225, &yymsp[0].minor.yy225)); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 391: /* pseudo_column ::= ROWTS */ - case 392: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==392); - case 394: /* pseudo_column ::= QSTART */ yytestcase(yyruleno==394); - case 395: /* pseudo_column ::= QEND */ yytestcase(yyruleno==395); - case 396: /* pseudo_column ::= QDURATION */ yytestcase(yyruleno==396); - case 397: /* pseudo_column ::= WSTART */ yytestcase(yyruleno==397); - case 398: /* pseudo_column ::= WEND */ yytestcase(yyruleno==398); - case 399: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==399); - case 400: /* pseudo_column ::= IROWTS */ yytestcase(yyruleno==400); - case 401: /* pseudo_column ::= ISFILLED */ yytestcase(yyruleno==401); - case 402: /* pseudo_column ::= QTAGS */ yytestcase(yyruleno==402); - case 408: /* literal_func ::= NOW */ yytestcase(yyruleno==408); + case 392: /* pseudo_column ::= ROWTS */ + case 393: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==393); + case 395: /* pseudo_column ::= QSTART */ yytestcase(yyruleno==395); + case 396: /* pseudo_column ::= QEND */ yytestcase(yyruleno==396); + case 397: /* pseudo_column ::= QDURATION */ yytestcase(yyruleno==397); + case 398: /* pseudo_column ::= WSTART */ yytestcase(yyruleno==398); + case 399: /* pseudo_column ::= WEND */ yytestcase(yyruleno==399); + case 400: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==400); + case 401: /* pseudo_column ::= IROWTS */ yytestcase(yyruleno==401); + case 402: /* pseudo_column ::= ISFILLED */ yytestcase(yyruleno==402); + case 403: /* pseudo_column ::= QTAGS */ yytestcase(yyruleno==403); + case 409: /* literal_func ::= NOW */ yytestcase(yyruleno==409); { yylhsminor.yy42 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 393: /* pseudo_column ::= table_name NK_DOT TBNAME */ + case 394: /* pseudo_column ::= table_name NK_DOT TBNAME */ { yylhsminor.yy42 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy225, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy225)))); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 403: /* function_expression ::= function_name NK_LP expression_list NK_RP */ - case 404: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==404); + case 404: /* function_expression ::= function_name NK_LP expression_list NK_RP */ + case 405: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==405); { yylhsminor.yy42 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy225, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy225, yymsp[-1].minor.yy110)); } yymsp[-3].minor.yy42 = yylhsminor.yy42; break; - case 405: /* function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ + case 406: /* function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ { yylhsminor.yy42 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy42), yymsp[-1].minor.yy448)); } yymsp[-5].minor.yy42 = yylhsminor.yy42; break; - case 407: /* literal_func ::= noarg_func NK_LP NK_RP */ + case 408: /* literal_func ::= noarg_func NK_LP NK_RP */ { yylhsminor.yy42 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy225, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy225, NULL)); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 422: /* star_func_para_list ::= NK_STAR */ + case 423: /* star_func_para_list ::= NK_STAR */ { yylhsminor.yy110 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } yymsp[0].minor.yy110 = yylhsminor.yy110; break; - case 427: /* star_func_para ::= table_name NK_DOT NK_STAR */ - case 491: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==491); + case 428: /* star_func_para ::= table_name NK_DOT NK_STAR */ + case 492: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==492); { yylhsminor.yy42 = createColumnNode(pCxt, &yymsp[-2].minor.yy225, &yymsp[0].minor.yy0); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 428: /* case_when_expression ::= CASE when_then_list case_when_else_opt END */ + case 429: /* case_when_expression ::= CASE when_then_list case_when_else_opt END */ { yylhsminor.yy42 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, NULL, yymsp[-2].minor.yy110, yymsp[-1].minor.yy42)); } yymsp[-3].minor.yy42 = yylhsminor.yy42; break; - case 429: /* case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ + case 430: /* case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ { yylhsminor.yy42 = createRawExprNodeExt(pCxt, &yymsp[-4].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy42), yymsp[-2].minor.yy110, yymsp[-1].minor.yy42)); } yymsp[-4].minor.yy42 = yylhsminor.yy42; break; - case 432: /* when_then_expr ::= WHEN common_expression THEN common_expression */ + case 433: /* when_then_expr ::= WHEN common_expression THEN common_expression */ { yymsp[-3].minor.yy42 = createWhenThenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy42), releaseRawExprNode(pCxt, yymsp[0].minor.yy42)); } break; - case 434: /* case_when_else_opt ::= ELSE common_expression */ + case 435: /* case_when_else_opt ::= ELSE common_expression */ { yymsp[-1].minor.yy42 = releaseRawExprNode(pCxt, yymsp[0].minor.yy42); } break; - case 435: /* predicate ::= expr_or_subquery compare_op expr_or_subquery */ - case 440: /* predicate ::= expr_or_subquery in_op in_predicate_value */ yytestcase(yyruleno==440); + case 436: /* predicate ::= expr_or_subquery compare_op expr_or_subquery */ + case 441: /* predicate ::= expr_or_subquery in_op in_predicate_value */ yytestcase(yyruleno==441); { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy42); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy42); @@ -5011,7 +5016,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 436: /* predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ + case 437: /* predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy42); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy42); @@ -5019,7 +5024,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-4].minor.yy42 = yylhsminor.yy42; break; - case 437: /* predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ + case 438: /* predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy42); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy42); @@ -5027,71 +5032,71 @@ static YYACTIONTYPE yy_reduce( } yymsp[-5].minor.yy42 = yylhsminor.yy42; break; - case 438: /* predicate ::= expr_or_subquery IS NULL */ + case 439: /* predicate ::= expr_or_subquery IS NULL */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy42); yylhsminor.yy42 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy42), NULL)); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 439: /* predicate ::= expr_or_subquery IS NOT NULL */ + case 440: /* predicate ::= expr_or_subquery IS NOT NULL */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy42); yylhsminor.yy42 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy42), NULL)); } yymsp[-3].minor.yy42 = yylhsminor.yy42; break; - case 441: /* compare_op ::= NK_LT */ + case 442: /* compare_op ::= NK_LT */ { yymsp[0].minor.yy2 = OP_TYPE_LOWER_THAN; } break; - case 442: /* compare_op ::= NK_GT */ + case 443: /* compare_op ::= NK_GT */ { yymsp[0].minor.yy2 = OP_TYPE_GREATER_THAN; } break; - case 443: /* compare_op ::= NK_LE */ + case 444: /* compare_op ::= NK_LE */ { yymsp[0].minor.yy2 = OP_TYPE_LOWER_EQUAL; } break; - case 444: /* compare_op ::= NK_GE */ + case 445: /* compare_op ::= NK_GE */ { yymsp[0].minor.yy2 = OP_TYPE_GREATER_EQUAL; } break; - case 445: /* compare_op ::= NK_NE */ + case 446: /* compare_op ::= NK_NE */ { yymsp[0].minor.yy2 = OP_TYPE_NOT_EQUAL; } break; - case 446: /* compare_op ::= NK_EQ */ + case 447: /* compare_op ::= NK_EQ */ { yymsp[0].minor.yy2 = OP_TYPE_EQUAL; } break; - case 447: /* compare_op ::= LIKE */ + case 448: /* compare_op ::= LIKE */ { yymsp[0].minor.yy2 = OP_TYPE_LIKE; } break; - case 448: /* compare_op ::= NOT LIKE */ + case 449: /* compare_op ::= NOT LIKE */ { yymsp[-1].minor.yy2 = OP_TYPE_NOT_LIKE; } break; - case 449: /* compare_op ::= MATCH */ + case 450: /* compare_op ::= MATCH */ { yymsp[0].minor.yy2 = OP_TYPE_MATCH; } break; - case 450: /* compare_op ::= NMATCH */ + case 451: /* compare_op ::= NMATCH */ { yymsp[0].minor.yy2 = OP_TYPE_NMATCH; } break; - case 451: /* compare_op ::= CONTAINS */ + case 452: /* compare_op ::= CONTAINS */ { yymsp[0].minor.yy2 = OP_TYPE_JSON_CONTAINS; } break; - case 452: /* in_op ::= IN */ + case 453: /* in_op ::= IN */ { yymsp[0].minor.yy2 = OP_TYPE_IN; } break; - case 453: /* in_op ::= NOT IN */ + case 454: /* in_op ::= NOT IN */ { yymsp[-1].minor.yy2 = OP_TYPE_NOT_IN; } break; - case 454: /* in_predicate_value ::= NK_LP literal_list NK_RP */ + case 455: /* in_predicate_value ::= NK_LP literal_list NK_RP */ { yylhsminor.yy42 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy110)); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 456: /* boolean_value_expression ::= NOT boolean_primary */ + case 457: /* boolean_value_expression ::= NOT boolean_primary */ { SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy42); yylhsminor.yy42 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy42), NULL)); } yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 457: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ + case 458: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy42); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy42); @@ -5099,7 +5104,7 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 458: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ + case 459: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ { SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy42); SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy42); @@ -5107,48 +5112,48 @@ static YYACTIONTYPE yy_reduce( } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 464: /* from_clause_opt ::= FROM table_reference_list */ - case 493: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==493); - case 524: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==524); + case 465: /* from_clause_opt ::= FROM table_reference_list */ + case 494: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==494); + case 525: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==525); { yymsp[-1].minor.yy42 = yymsp[0].minor.yy42; } break; - case 466: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */ + case 467: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */ { yylhsminor.yy42 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy42, yymsp[0].minor.yy42, NULL); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 469: /* table_primary ::= table_name alias_opt */ + case 470: /* table_primary ::= table_name alias_opt */ { yylhsminor.yy42 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy225, &yymsp[0].minor.yy225); } yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 470: /* table_primary ::= db_name NK_DOT table_name alias_opt */ + case 471: /* table_primary ::= db_name NK_DOT table_name alias_opt */ { yylhsminor.yy42 = createRealTableNode(pCxt, &yymsp[-3].minor.yy225, &yymsp[-1].minor.yy225, &yymsp[0].minor.yy225); } yymsp[-3].minor.yy42 = yylhsminor.yy42; break; - case 471: /* table_primary ::= subquery alias_opt */ + case 472: /* table_primary ::= subquery alias_opt */ { yylhsminor.yy42 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy42), &yymsp[0].minor.yy225); } yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 473: /* alias_opt ::= */ + case 474: /* alias_opt ::= */ { yymsp[1].minor.yy225 = nil_token; } break; - case 475: /* alias_opt ::= AS table_alias */ + case 476: /* alias_opt ::= AS table_alias */ { yymsp[-1].minor.yy225 = yymsp[0].minor.yy225; } break; - case 476: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - case 477: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==477); + case 477: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */ + case 478: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==478); { yymsp[-2].minor.yy42 = yymsp[-1].minor.yy42; } break; - case 478: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ + case 479: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ { yylhsminor.yy42 = createJoinTableNode(pCxt, yymsp[-4].minor.yy638, yymsp[-5].minor.yy42, yymsp[-2].minor.yy42, yymsp[0].minor.yy42); } yymsp[-5].minor.yy42 = yylhsminor.yy42; break; - case 479: /* join_type ::= */ + case 480: /* join_type ::= */ { yymsp[1].minor.yy638 = JOIN_TYPE_INNER; } break; - case 480: /* join_type ::= INNER */ + case 481: /* join_type ::= INNER */ { yymsp[0].minor.yy638 = JOIN_TYPE_INNER; } break; - case 481: /* query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ + case 482: /* query_specification ::= SELECT set_quantifier_opt select_list from_clause_opt where_clause_opt partition_by_clause_opt range_opt every_opt fill_opt twindow_clause_opt group_by_clause_opt having_clause_opt */ { yymsp[-11].minor.yy42 = createSelectStmt(pCxt, yymsp[-10].minor.yy103, yymsp[-9].minor.yy110, yymsp[-8].minor.yy42); yymsp[-11].minor.yy42 = addWhereClause(pCxt, yymsp[-11].minor.yy42, yymsp[-7].minor.yy42); @@ -5161,82 +5166,82 @@ static YYACTIONTYPE yy_reduce( yymsp[-11].minor.yy42 = addFillClause(pCxt, yymsp[-11].minor.yy42, yymsp[-3].minor.yy42); } break; - case 484: /* set_quantifier_opt ::= ALL */ + case 485: /* set_quantifier_opt ::= ALL */ { yymsp[0].minor.yy103 = false; } break; - case 487: /* select_item ::= NK_STAR */ + case 488: /* select_item ::= NK_STAR */ { yylhsminor.yy42 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0); } yymsp[0].minor.yy42 = yylhsminor.yy42; break; - case 489: /* select_item ::= common_expression column_alias */ - case 499: /* partition_item ::= expr_or_subquery column_alias */ yytestcase(yyruleno==499); + case 490: /* select_item ::= common_expression column_alias */ + case 500: /* partition_item ::= expr_or_subquery column_alias */ yytestcase(yyruleno==500); { yylhsminor.yy42 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy42), &yymsp[0].minor.yy225); } yymsp[-1].minor.yy42 = yylhsminor.yy42; break; - case 490: /* select_item ::= common_expression AS column_alias */ - case 500: /* partition_item ::= expr_or_subquery AS column_alias */ yytestcase(yyruleno==500); + case 491: /* select_item ::= common_expression AS column_alias */ + case 501: /* partition_item ::= expr_or_subquery AS column_alias */ yytestcase(yyruleno==501); { yylhsminor.yy42 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy42), &yymsp[0].minor.yy225); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 495: /* partition_by_clause_opt ::= PARTITION BY partition_list */ - case 520: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==520); - case 539: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==539); + case 496: /* partition_by_clause_opt ::= PARTITION BY partition_list */ + case 521: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==521); + case 540: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==540); { yymsp[-2].minor.yy110 = yymsp[0].minor.yy110; } break; - case 502: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ + case 503: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA duration_literal NK_RP */ { yymsp[-5].minor.yy42 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy42), releaseRawExprNode(pCxt, yymsp[-1].minor.yy42)); } break; - case 503: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ + case 504: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ { yymsp[-3].minor.yy42 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy42)); } break; - case 504: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ + case 505: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_RP sliding_opt fill_opt */ { yymsp[-5].minor.yy42 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy42), NULL, yymsp[-1].minor.yy42, yymsp[0].minor.yy42); } break; - case 505: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ + case 506: /* twindow_clause_opt ::= INTERVAL NK_LP duration_literal NK_COMMA duration_literal NK_RP sliding_opt fill_opt */ { yymsp[-7].minor.yy42 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy42), releaseRawExprNode(pCxt, yymsp[-3].minor.yy42), yymsp[-1].minor.yy42, yymsp[0].minor.yy42); } break; - case 506: /* twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ + case 507: /* twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ { yymsp[-6].minor.yy42 = createEventWindowNode(pCxt, yymsp[-3].minor.yy42, yymsp[0].minor.yy42); } break; - case 510: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ + case 511: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ { yymsp[-3].minor.yy42 = createFillNode(pCxt, yymsp[-1].minor.yy410, NULL); } break; - case 511: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ + case 512: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA literal_list NK_RP */ { yymsp[-5].minor.yy42 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy110)); } break; - case 512: /* fill_opt ::= FILL NK_LP VALUE_F NK_COMMA literal_list NK_RP */ + case 513: /* fill_opt ::= FILL NK_LP VALUE_F NK_COMMA literal_list NK_RP */ { yymsp[-5].minor.yy42 = createFillNode(pCxt, FILL_MODE_VALUE_F, createNodeListNode(pCxt, yymsp[-1].minor.yy110)); } break; - case 513: /* fill_mode ::= NONE */ + case 514: /* fill_mode ::= NONE */ { yymsp[0].minor.yy410 = FILL_MODE_NONE; } break; - case 514: /* fill_mode ::= PREV */ + case 515: /* fill_mode ::= PREV */ { yymsp[0].minor.yy410 = FILL_MODE_PREV; } break; - case 515: /* fill_mode ::= NULL */ + case 516: /* fill_mode ::= NULL */ { yymsp[0].minor.yy410 = FILL_MODE_NULL; } break; - case 516: /* fill_mode ::= NULL_F */ + case 517: /* fill_mode ::= NULL_F */ { yymsp[0].minor.yy410 = FILL_MODE_NULL_F; } break; - case 517: /* fill_mode ::= LINEAR */ + case 518: /* fill_mode ::= LINEAR */ { yymsp[0].minor.yy410 = FILL_MODE_LINEAR; } break; - case 518: /* fill_mode ::= NEXT */ + case 519: /* fill_mode ::= NEXT */ { yymsp[0].minor.yy410 = FILL_MODE_NEXT; } break; - case 521: /* group_by_list ::= expr_or_subquery */ + case 522: /* group_by_list ::= expr_or_subquery */ { yylhsminor.yy110 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy42))); } yymsp[0].minor.yy110 = yylhsminor.yy110; break; - case 522: /* group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ + case 523: /* group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ { yylhsminor.yy110 = addNodeToList(pCxt, yymsp[-2].minor.yy110, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy42))); } yymsp[-2].minor.yy110 = yylhsminor.yy110; break; - case 526: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ + case 527: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ { yymsp[-5].minor.yy42 = createInterpTimeRange(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy42), releaseRawExprNode(pCxt, yymsp[-1].minor.yy42)); } break; - case 529: /* query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ + case 530: /* query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ { yylhsminor.yy42 = addOrderByClause(pCxt, yymsp[-3].minor.yy42, yymsp[-2].minor.yy110); yylhsminor.yy42 = addSlimitClause(pCxt, yylhsminor.yy42, yymsp[-1].minor.yy42); @@ -5244,50 +5249,50 @@ static YYACTIONTYPE yy_reduce( } yymsp[-3].minor.yy42 = yylhsminor.yy42; break; - case 532: /* union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ + case 533: /* union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ { yylhsminor.yy42 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy42, yymsp[0].minor.yy42); } yymsp[-3].minor.yy42 = yylhsminor.yy42; break; - case 533: /* union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ + case 534: /* union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ { yylhsminor.yy42 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy42, yymsp[0].minor.yy42); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 541: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ - case 545: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==545); + case 542: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ + case 546: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==546); { yymsp[-1].minor.yy42 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); } break; - case 542: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - case 546: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==546); + case 543: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + case 547: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==547); { yymsp[-3].minor.yy42 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } break; - case 543: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - case 547: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==547); + case 544: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + case 548: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==548); { yymsp[-3].minor.yy42 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); } break; - case 548: /* subquery ::= NK_LP query_expression NK_RP */ + case 549: /* subquery ::= NK_LP query_expression NK_RP */ { yylhsminor.yy42 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy42); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 553: /* sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ + case 554: /* sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ { yylhsminor.yy42 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy42), yymsp[-1].minor.yy106, yymsp[0].minor.yy599); } yymsp[-2].minor.yy42 = yylhsminor.yy42; break; - case 554: /* ordering_specification_opt ::= */ + case 555: /* ordering_specification_opt ::= */ { yymsp[1].minor.yy106 = ORDER_ASC; } break; - case 555: /* ordering_specification_opt ::= ASC */ + case 556: /* ordering_specification_opt ::= ASC */ { yymsp[0].minor.yy106 = ORDER_ASC; } break; - case 556: /* ordering_specification_opt ::= DESC */ + case 557: /* ordering_specification_opt ::= DESC */ { yymsp[0].minor.yy106 = ORDER_DESC; } break; - case 557: /* null_ordering_opt ::= */ + case 558: /* null_ordering_opt ::= */ { yymsp[1].minor.yy599 = NULL_ORDER_DEFAULT; } break; - case 558: /* null_ordering_opt ::= NULLS FIRST */ + case 559: /* null_ordering_opt ::= NULLS FIRST */ { yymsp[-1].minor.yy599 = NULL_ORDER_FIRST; } break; - case 559: /* null_ordering_opt ::= NULLS LAST */ + case 560: /* null_ordering_opt ::= NULLS LAST */ { yymsp[-1].minor.yy599 = NULL_ORDER_LAST; } break; default: diff --git a/source/libs/parser/test/parInitialCTest.cpp b/source/libs/parser/test/parInitialCTest.cpp index a7a11d8edf..51de121d1e 100644 --- a/source/libs/parser/test/parInitialCTest.cpp +++ b/source/libs/parser/test/parInitialCTest.cpp @@ -21,6 +21,26 @@ namespace ParserTest { class ParserInitialCTest : public ParserDdlTest {}; +/* + * COMPACT DATABASE db_name + */ +TEST_F(ParserInitialCTest, compact) { + SCompactDbReq expect = {0}; + + auto setCompactDbReq = [&](const char* pDb) { snprintf(expect.db, sizeof(expect.db), "0.%s", pDb); }; + + setCheckDdlFunc([&](const SQuery* pQuery, ParserStage stage) { + ASSERT_EQ(nodeType(pQuery->pRoot), QUERY_NODE_COMPACT_DATABASE_STMT); + ASSERT_EQ(pQuery->pCmdMsg->msgType, TDMT_MND_COMPACT_DB); + SCompactDbReq req = {0}; + ASSERT_EQ(tDeserializeSCompactDbReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req), TSDB_CODE_SUCCESS); + ASSERT_EQ(std::string(req.db), std::string(expect.db)); + }); + + setCompactDbReq("wxy_db"); + run("COMPACT DATABASE wxy_db"); +} + /* * CREATE ACCOUNT account_name PASS value [create_account_options] * diff --git a/source/util/src/trbtree.c b/source/util/src/trbtree.c index ffae5441aa..e7386d5912 100644 --- a/source/util/src/trbtree.c +++ b/source/util/src/trbtree.c @@ -147,6 +147,10 @@ static SRBTreeNode *tRBTreePredecessor(SRBTree *pTree, SRBTreeNode *pNode) { void tRBTreeCreate(SRBTree *pTree, tRBTreeCmprFn cmprFn) { pTree->cmprFn = cmprFn; + tRBTreeClear(pTree); +} + +void tRBTreeClear(SRBTree *pTree) { pTree->n = 0; pTree->NIL = &pTree->NILNODE; pTree->NIL->color = BLACK; @@ -423,6 +427,22 @@ SRBTreeNode *tRBTreeDropByKey(SRBTree *pTree, void *pKey) { return pNode; } +SRBTreeNode *tRBTreeDropMin(SRBTree *pTree) { + SRBTreeNode *pNode = tRBTreeMin(pTree); + if (pNode) { + tRBTreeDrop(pTree, pNode); + } + return pNode; +} + +SRBTreeNode *tRBTreeDropMax(SRBTree *pTree) { + SRBTreeNode *pNode = tRBTreeMax(pTree); + if (pNode) { + tRBTreeDrop(pTree, pNode); + } + return pNode; +} + SRBTreeNode *tRBTreeGet(SRBTree *pTree, const SRBTreeNode *pKeyNode) { SRBTreeNode *pNode = pTree->root;