diff --git a/docs/en/12-taos-sql/05-insert.md b/docs/en/12-taos-sql/05-insert.md index 462e7fc0ae..32227a2214 100644 --- a/docs/en/12-taos-sql/05-insert.md +++ b/docs/en/12-taos-sql/05-insert.md @@ -1,7 +1,7 @@ --- title: Insert sidebar_label: Insert -description: This document describes how to insert data into TDengine. +description: This document describes the SQL commands and syntax for inserting data into TDengine. --- ## Syntax diff --git a/docs/en/12-taos-sql/13-tmq.md b/docs/en/12-taos-sql/13-tmq.md index d14b6da2d3..16dc9efd62 100644 --- a/docs/en/12-taos-sql/13-tmq.md +++ b/docs/en/12-taos-sql/13-tmq.md @@ -1,5 +1,5 @@ --- -title: Data Subscription +title: Data Subscription SQL Reference sidebar_label: Data Subscription description: This document describes the SQL statements related to the data subscription component of TDengine. --- diff --git a/docs/en/12-taos-sql/14-stream.md b/docs/en/12-taos-sql/14-stream.md index e1bf18c854..337660a36c 100644 --- a/docs/en/12-taos-sql/14-stream.md +++ b/docs/en/12-taos-sql/14-stream.md @@ -1,5 +1,5 @@ --- -title: Stream Processing +title: Stream Processing SQL Reference sidebar_label: Stream Processing description: This document describes the SQL statements related to the stream processing component of TDengine. --- @@ -148,7 +148,7 @@ T = latest event time - watermark The window closing time for each batch of data that arrives at the system is updated using the preceding formula, and all windows are closed whose closing time is less than T. If the triggering method is WINDOW_CLOSE or MAX_DELAY, the aggregate result for the window is pushed. -Stream processing strategy for expired data +## Stream processing strategy for expired data The data in expired windows is tagged as expired. TDengine stream processing provides two methods for handling such data: 1. Drop the data. This is the default and often only handling method for most stream processing engines. @@ -157,6 +157,14 @@ The data in expired windows is tagged as expired. TDengine stream processing pro In both of these methods, configuring the watermark is essential for obtaining accurate results (if expired data is dropped) and avoiding repeated triggers that affect system performance (if expired data is recalculated). +## Stream processing strategy for modifying data + +TDengine provides two ways to handle modified data, which are specified by the IGNORE UPDATE option: + +1. Check whether the data has been modified, i.e. IGNORE UPDATE 0, and recalculate the corresponding window if the data has been modified. + +2. Do not check whether the data has been modified, and calculate all the data as incremental data, i.e. IGNORE UPDATE 1, the default configuration. + ## Supported functions All [scalar functions](../function/#scalar-functions) are available in stream processing. All [Aggregate functions](../function/#aggregate-functions) and [Selection functions](../function/#selection-functions) are available in stream processing, except the followings: diff --git a/docs/en/12-taos-sql/26-udf.md b/docs/en/12-taos-sql/26-udf.md index f86b535927..dec9ca217d 100644 --- a/docs/en/12-taos-sql/26-udf.md +++ b/docs/en/12-taos-sql/26-udf.md @@ -1,5 +1,5 @@ --- -title: User-Defined Functions (UDF) +title: User-Defined Functions (UDF) SQL Reference sidebar_label: User-Defined Functions description: This document describes the SQL statements related to user-defined functions (UDF) in TDengine. --- diff --git a/docs/en/14-reference/07-tdinsight/index.md b/docs/en/14-reference/07-tdinsight/index.md index cada05d738..1bc983262e 100644 --- a/docs/en/14-reference/07-tdinsight/index.md +++ b/docs/en/14-reference/07-tdinsight/index.md @@ -1,5 +1,5 @@ --- -title: TDinsight - Grafana-based Zero-Dependency Monitoring Solution for TDengine +title: TDinsight sidebar_label: TDinsight description: This document describes TDinsight, a monitoring solution for TDengine. --- diff --git a/docs/en/25-application/01-telegraf.md b/docs/en/25-application/01-telegraf.md index a6db826fa3..f8784e9ab9 100644 --- a/docs/en/25-application/01-telegraf.md +++ b/docs/en/25-application/01-telegraf.md @@ -1,5 +1,5 @@ --- -title: Quickly Build IT DevOps Visualization System with TDengine + Telegraf + Grafana +title: IT Visualization with TDengine + Telegraf + Grafana sidebar_label: TDengine + Telegraf + Grafana description: This document describes how to create an IT visualization system by integrating TDengine with Telegraf and Grafana. --- diff --git a/docs/examples/rust/nativeexample/examples/query.rs b/docs/examples/rust/nativeexample/examples/query.rs new file mode 100644 index 0000000000..dfe55e8749 --- /dev/null +++ b/docs/examples/rust/nativeexample/examples/query.rs @@ -0,0 +1,66 @@ +use taos::*; + +#[tokio::main] +async fn main() -> anyhow::Result<()> { + let dsn = "taos://localhost:6030"; + let builder = TaosBuilder::from_dsn(dsn)?; + + let taos = builder.build()?; + + // ANCHOR: create_db_and_table + let db = "power"; + // create database + taos.exec_many([ + format!("DROP DATABASE IF EXISTS `{db}`"), + format!("CREATE DATABASE `{db}`"), + format!("USE `{db}`"), + ]) + .await?; + + // create table + taos.exec_many([ + // create super table + "CREATE TABLE `meters` (`ts` TIMESTAMP, `current` FLOAT, `voltage` INT, `phase` FLOAT) \ + TAGS (`groupid` INT, `location` BINARY(24))", + ]).await?; + // ANCHOR_END: create_db_and_table + + // ANCHOR: insert_data + let inserted = taos.exec("INSERT INTO " + + "power.d1001 USING power.meters TAGS(2,'California.SanFrancisco') " + + "VALUES " + + "(NOW + 1a, 10.30000, 219, 0.31000) " + + "(NOW + 2a, 12.60000, 218, 0.33000) " + + "(NOW + 3a, 12.30000, 221, 0.31000) " + + "power.d1002 USING power.meters TAGS(3, 'California.SanFrancisco') " + + "VALUES " + + "(NOW + 1a, 10.30000, 218, 0.25000) ").await?; + + println!("inserted: {} rows", inserted); + // ANCHOR_END: insert_data + + // ANCHOR: query_data + let mut result = taos.query("SELECT * FROM power.meters").await?; + + for field in result.fields() { + println!("got field: {}", field.name()); + } + + let mut rows = result.rows(); + let mut nrows = 0; + while let Some(row) = rows.try_next().await? { + for (col, (name, value)) in row.enumerate() { + println!( + "[{}] got value in col {} (named `{:>8}`): {}", + nrows, col, name, value + ); + } + nrows += 1; + } + // ANCHOR_END: query_data + + // ANCHOR: query_with_req_id + let result = taos.query_with_req_id("SELECT * FROM power.meters", 0).await?; + // ANCHOR_END: query_with_req_id + +} diff --git a/docs/examples/rust/nativeexample/examples/schemaless.rs b/docs/examples/rust/nativeexample/examples/schemaless.rs new file mode 100644 index 0000000000..44ce0fe694 --- /dev/null +++ b/docs/examples/rust/nativeexample/examples/schemaless.rs @@ -0,0 +1,80 @@ +use taos_query::common::SchemalessPrecision; +use taos_query::common::SchemalessProtocol; +use taos_query::common::SmlDataBuilder; + +use crate::AsyncQueryable; +use crate::AsyncTBuilder; +use crate::TaosBuilder; + +async fn put() -> anyhow::Result<()> { + std::env::set_var("RUST_LOG", "taos=debug"); + pretty_env_logger::init(); + let dsn = + std::env::var("TDENGINE_ClOUD_DSN").unwrap_or("http://localhost:6041".to_string()); + log::debug!("dsn: {:?}", &dsn); + + let client = TaosBuilder::from_dsn(dsn)?.build().await?; + + let db = "power"; + + client.exec(format!("drop database if exists {db}")).await?; + + client + .exec(format!("create database if not exists {db}")) + .await?; + + // should specify database before insert + client.exec(format!("use {db}")).await?; + + // SchemalessProtocol::Line + let data = [ + "meters,groupid=2,location=California.SanFrancisco current=10.3000002f64,voltage=219i32,phase=0.31f64 1626006833639000000", + ] + .map(String::from) + .to_vec(); + + let sml_data = SmlDataBuilder::default() + .protocol(SchemalessProtocol::Line) + .precision(SchemalessPrecision::Millisecond) + .data(data.clone()) + .ttl(1000) + .req_id(100u64) + .build()?; + assert_eq!(client.put(&sml_data).await?, ()); + + // SchemalessProtocol::Telnet + let data = [ + "meters.current 1648432611249 10.3 location=California.SanFrancisco group=2", + ] + .map(String::from) + .to_vec(); + + let sml_data = SmlDataBuilder::default() + .protocol(SchemalessProtocol::Telnet) + .precision(SchemalessPrecision::Millisecond) + .data(data.clone()) + .ttl(1000) + .req_id(200u64) + .build()?; + assert_eq!(client.put(&sml_data).await?, ()); + + // SchemalessProtocol::Json + let data = [ + r#"[{"metric": "meters.current", "timestamp": 1681345954000, "value": 10.3, "tags": {"location": "California.SanFrancisco", "groupid": 2}}, {"metric": "meters.voltage", "timestamp": 1648432611249, "value": 219, "tags": {"location": "California.LosAngeles", "groupid": 1}}, {"metric": "meters.current", "timestamp": 1648432611250, "value": 12.6, "tags": {"location": "California.SanFrancisco", "groupid": 2}}, {"metric": "meters.voltage", "timestamp": 1648432611250, "value": 221, "tags": {"location": "California.LosAngeles", "groupid": 1}}]"# + ] + .map(String::from) + .to_vec(); + + let sml_data = SmlDataBuilder::default() + .protocol(SchemalessProtocol::Json) + .precision(SchemalessPrecision::Millisecond) + .data(data.clone()) + .ttl(1000) + .req_id(300u64) + .build()?; + assert_eq!(client.put(&sml_data).await?, ()); + + client.exec(format!("drop database if exists {db}")).await?; + + Ok(()) +} diff --git a/docs/examples/rust/nativeexample/examples/stmt.rs b/docs/examples/rust/nativeexample/examples/stmt.rs new file mode 100644 index 0000000000..0194eccdf1 --- /dev/null +++ b/docs/examples/rust/nativeexample/examples/stmt.rs @@ -0,0 +1,37 @@ +use taos::*; + +#[tokio::main] +async fn main() -> anyhow::Result<()> { + let taos = TaosBuilder::from_dsn("taos://")?.build().await?; + + taos.exec("DROP DATABASE IF EXISTS power").await?; + taos.create_database("power").await?; + taos.use_database("power").await?; + taos.exec("CREATE STABLE IF NOT EXISTS meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)").await?; + + let mut stmt = Stmt::init(&taos).await?; + stmt.prepare("INSERT INTO ? USING meters TAGS(?, ?) VALUES(?, ?, ?, ?)").await?; + + const NUM_TABLES: usize = 10; + const NUM_ROWS: usize = 10; + for i in 0..NUM_TABLES { + let table_name = format!("d{}", i); + let tags = vec![Value::VarChar("California.SanFransico".into()), Value::Int(2)]; + stmt.set_tbname_tags(&table_name, &tags).await?; + for j in 0..NUM_ROWS { + let values = vec![ + ColumnView::from_millis_timestamp(vec![1648432611249 + j as i64]), + ColumnView::from_floats(vec![10.3 + j as f32]), + ColumnView::from_ints(vec![219 + j as i32]), + ColumnView::from_floats(vec![0.31 + j as f32]), + ]; + stmt.bind(&values).await?; + } + stmt.add_batch().await?; + } + + // execute. + let rows = stmt.execute().await?; + assert_eq!(rows, NUM_TABLES * NUM_ROWS); + Ok(()) +} diff --git a/docs/examples/rust/nativeexample/examples/tmq.rs b/docs/examples/rust/nativeexample/examples/tmq.rs new file mode 100644 index 0000000000..764c0c1fc8 --- /dev/null +++ b/docs/examples/rust/nativeexample/examples/tmq.rs @@ -0,0 +1,166 @@ +use std::time::Duration; +use std::str::FromStr; + +use taos::*; + +#[tokio::main] +async fn main() -> anyhow::Result<()> { + pretty_env_logger::formatted_timed_builder() + .filter_level(log::LevelFilter::Info) + .init(); + use taos_query::prelude::*; + let dsn = "taos://localhost:6030".to_string(); + log::info!("dsn: {}", dsn); + let mut dsn = Dsn::from_str(&dsn)?; + + let taos = TaosBuilder::from_dsn(&dsn)?.build().await?; + + // prepare database and table + taos.exec_many([ + "drop topic if exists topic_meters", + "drop database if exists power", + "create database if not exists power WAL_RETENTION_PERIOD 86400", + "use power", + + "CREATE STABLE IF NOT EXISTS power.meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (groupId INT, location BINARY(24))", + + "create table if not exists power.d001 using power.meters tags(1,'location')", + + ]) + .await?; + + taos.exec_many([ + "drop database if exists db2", + "create database if not exists db2 wal_retention_period 3600", + "use db2", + ]) + .await?; + + // ANCHOR: create_topic + taos.exec_many([ + "CREATE TOPIC IF NOT EXISTS topic_meters AS SELECT ts, current, voltage, phase, groupid, location FROM power.meters", + ]) + .await?; + // ANCHOR_END: create_topic + + // ANCHOR: create_consumer + dsn.params.insert("group.id".to_string(), "abc".to_string()); + dsn.params.insert("auto.offset.reset".to_string(), "earliest".to_string()); + + let builder = TmqBuilder::from_dsn(&dsn)?; + let mut consumer = builder.build().await?; + // ANCHOR_END: create_consumer + + // ANCHOR: subscribe + consumer.subscribe(["topic_meters"]).await?; + // ANCHOR_END: subscribe + + // ANCHOR: consume + { + let mut stream = consumer.stream_with_timeout(Timeout::from_secs(1)); + + while let Some((offset, message)) = stream.try_next().await? { + + let topic: &str = offset.topic(); + let database = offset.database(); + let vgroup_id = offset.vgroup_id(); + log::debug!( + "topic: {}, database: {}, vgroup_id: {}", + topic, + database, + vgroup_id + ); + + match message { + MessageSet::Meta(meta) => { + log::info!("Meta"); + let raw = meta.as_raw_meta().await?; + taos.write_raw_meta(&raw).await?; + + let json = meta.as_json_meta().await?; + let sql = json.to_string(); + if let Err(err) = taos.exec(sql).await { + println!("maybe error: {}", err); + } + } + MessageSet::Data(data) => { + log::info!("Data"); + while let Some(data) = data.fetch_raw_block().await? { + log::debug!("data: {:?}", data); + } + } + MessageSet::MetaData(meta, data) => { + log::info!("MetaData"); + let raw = meta.as_raw_meta().await?; + taos.write_raw_meta(&raw).await?; + + let json = meta.as_json_meta().await?; + let sql = json.to_string(); + if let Err(err) = taos.exec(sql).await { + println!("maybe error: {}", err); + } + + while let Some(data) = data.fetch_raw_block().await? { + log::debug!("data: {:?}", data); + } + } + } + consumer.commit(offset).await?; + } + } + // ANCHOR_END: consume + + // ANCHOR: assignments + let assignments = consumer.assignments().await.unwrap(); + log::info!("assignments: {:?}", assignments); + // ANCHOR_END: assignments + + // seek offset + for topic_vec_assignment in assignments { + let topic = &topic_vec_assignment.0; + let vec_assignment = topic_vec_assignment.1; + for assignment in vec_assignment { + let vgroup_id = assignment.vgroup_id(); + let current = assignment.current_offset(); + let begin = assignment.begin(); + let end = assignment.end(); + log::debug!( + "topic: {}, vgroup_id: {}, current offset: {} begin {}, end: {}", + topic, + vgroup_id, + current, + begin, + end + ); + // ANCHOR: seek_offset + let res = consumer.offset_seek(topic, vgroup_id, end).await; + if res.is_err() { + log::error!("seek offset error: {:?}", res); + let a = consumer.assignments().await.unwrap(); + log::error!("assignments: {:?}", a); + } + // ANCHOR_END: seek_offset + } + + let topic_assignment = consumer.topic_assignment(topic).await; + log::debug!("topic assignment: {:?}", topic_assignment); + } + + // after seek offset + let assignments = consumer.assignments().await.unwrap(); + log::info!("after seek offset assignments: {:?}", assignments); + + // ANCHOR: unsubscribe + consumer.unsubscribe().await; + // ANCHOR_END: unsubscribe + + tokio::time::sleep(Duration::from_secs(1)).await; + + taos.exec_many([ + "drop database db2", + "drop topic topic_meters", + "drop database power", + ]) + .await?; + Ok(()) +} diff --git a/docs/zh/12-taos-sql/14-stream.md b/docs/zh/12-taos-sql/14-stream.md index 2ed3c9afae..125f868758 100644 --- a/docs/zh/12-taos-sql/14-stream.md +++ b/docs/zh/12-taos-sql/14-stream.md @@ -201,9 +201,9 @@ TDengine 对于过期数据提供两种处理方式，由 IGNORE EXPIRED 选项 TDengine 对于修改数据提供两种处理方式，由 IGNORE UPDATE 选项指定： -1. 检查数据是否被修改，即 IGNORE UPDATE 0：默认配置，如果被修改，则重新计算对应窗口。 +1. 检查数据是否被修改，即 IGNORE UPDATE 0，如果数据被修改，则重新计算对应窗口。 -2. 不检查数据是否被修改，全部按增量数据计算，即 IGNORE UPDATE 1。 +2. 不检查数据是否被修改，全部按增量数据计算，即 IGNORE UPDATE 1，默认配置。 ## 写入已存在的超级表 diff --git a/include/libs/stream/tstream.h b/include/libs/stream/tstream.h index e7c6491b9d..138fad0ddb 100644 --- a/include/libs/stream/tstream.h +++ b/include/libs/stream/tstream.h @@ -355,6 +355,8 @@ typedef struct SMetaHbInfo SMetaHbInfo; typedef struct SDispatchMsgInfo { SStreamDispatchReq* pData; // current dispatch data int8_t dispatchMsgType; + int64_t checkpointId;// checkpoint id msg + int32_t transId; // transId for current checkpoint int16_t msgType; // dispatch msg type int32_t retryCount; // retry send data count int64_t startTs; // dispatch start time, record total elapsed time for dispatch diff --git a/source/client/src/clientHb.c b/source/client/src/clientHb.c index a146712cab..b1f0ea55d8 100644 --- a/source/client/src/clientHb.c +++ b/source/client/src/clientHb.c @@ -496,6 +496,11 @@ static int32_t hbAsyncCallBack(void *param, SDataBuf *pMsg, int32_t code) { if (code != 0) { pInst->onlineDnodes = pInst->totalDnodes ? 0 : -1; tscDebug("hb rsp error %s, update server status %d/%d", tstrerror(code), pInst->onlineDnodes, pInst->totalDnodes); + taosThreadMutexUnlock(&clientHbMgr.lock); + taosMemoryFree(pMsg->pData); + taosMemoryFree(pMsg->pEpSet); + tFreeClientHbBatchRsp(&pRsp); + return -1; } if (rspNum) { diff --git a/source/client/src/clientTmq.c b/source/client/src/clientTmq.c index c8fc556150..ce149921e3 100644 --- a/source/client/src/clientTmq.c +++ b/source/client/src/clientTmq.c @@ -1626,6 +1626,22 @@ void changeByteEndian(char* pData){ } } +static void tmqGetRawDataRowsPrecisionFromRes(void *pRetrieve, void** rawData, int64_t *rows, int32_t *precision){ + if(*(int64_t*)pRetrieve == 0){ + *rawData = ((SRetrieveTableRsp*)pRetrieve)->data; + *rows = htobe64(((SRetrieveTableRsp*)pRetrieve)->numOfRows); + if(precision != NULL){ + *precision = ((SRetrieveTableRsp*)pRetrieve)->precision; + } + }else if(*(int64_t*)pRetrieve == 1){ + *rawData = ((SRetrieveTableRspForTmq*)pRetrieve)->data; + *rows = htobe64(((SRetrieveTableRspForTmq*)pRetrieve)->numOfRows); + if(precision != NULL){ + *precision = ((SRetrieveTableRspForTmq*)pRetrieve)->precision; + } + } +} + static void tmqBuildRspFromWrapperInner(SMqPollRspWrapper* pWrapper, SMqClientVg* pVg, int64_t* numOfRows, SMqRspObj* pRspObj) { (*numOfRows) = 0; tstrncpy(pRspObj->topic, pWrapper->topicHandle->topicName, TSDB_TOPIC_FNAME_LEN); @@ -1648,13 +1664,7 @@ static void tmqBuildRspFromWrapperInner(SMqPollRspWrapper* pWrapper, SMqClientVg void* rawData = NULL; int64_t rows = 0; // deal with compatibility - if(*(int64_t*)pRetrieve == 0){ - rawData = ((SRetrieveTableRsp*)pRetrieve)->data; - rows = htobe64(((SRetrieveTableRsp*)pRetrieve)->numOfRows); - }else if(*(int64_t*)pRetrieve == 1){ - rawData = ((SRetrieveTableRspForTmq*)pRetrieve)->data; - rows = htobe64(((SRetrieveTableRspForTmq*)pRetrieve)->numOfRows); - } + tmqGetRawDataRowsPrecisionFromRes(pRetrieve, &rawData, &rows, NULL); pVg->numOfRows += rows; (*numOfRows) += rows; @@ -2625,18 +2635,22 @@ SReqResultInfo* tmqGetNextResInfo(TAOS_RES* res, bool convertUcs4) { pRspObj->resIter++; if (pRspObj->resIter < pRspObj->rsp.blockNum) { - SRetrieveTableRspForTmq* pRetrieveTmq = - (SRetrieveTableRspForTmq*)taosArrayGetP(pRspObj->rsp.blockData, pRspObj->resIter); if (pRspObj->rsp.withSchema) { doFreeReqResultInfo(&pRspObj->resInfo); SSchemaWrapper* pSW = (SSchemaWrapper*)taosArrayGetP(pRspObj->rsp.blockSchema, pRspObj->resIter); setResSchemaInfo(&pRspObj->resInfo, pSW->pSchema, pSW->nCols); } - pRspObj->resInfo.pData = (void*)pRetrieveTmq->data; - pRspObj->resInfo.numOfRows = htobe64(pRetrieveTmq->numOfRows); + void* pRetrieve = taosArrayGetP(pRspObj->rsp.blockData, pRspObj->resIter); + void* rawData = NULL; + int64_t rows = 0; + int32_t precision = 0; + tmqGetRawDataRowsPrecisionFromRes(pRetrieve, &rawData, &rows, &precision); + + pRspObj->resInfo.pData = rawData; + pRspObj->resInfo.numOfRows = rows; pRspObj->resInfo.current = 0; - pRspObj->resInfo.precision = pRetrieveTmq->precision; + pRspObj->resInfo.precision = precision; // TODO handle the compressed case pRspObj->resInfo.totalRows += pRspObj->resInfo.numOfRows; diff --git a/source/dnode/mnode/impl/inc/mndDef.h b/source/dnode/mnode/impl/inc/mndDef.h index ce6f0e2af7..c6d5b63c44 100644 --- a/source/dnode/mnode/impl/inc/mndDef.h +++ b/source/dnode/mnode/impl/inc/mndDef.h @@ -160,6 +160,7 @@ typedef struct { ETrnConflct conflict; ETrnExec exec; EOperType oper; + bool changeless; int32_t code; int32_t failedTimes; void* rpcRsp; diff --git a/source/dnode/mnode/impl/inc/mndTrans.h b/source/dnode/mnode/impl/inc/mndTrans.h index 8689df98af..8c9ca87fb1 100644 --- a/source/dnode/mnode/impl/inc/mndTrans.h +++ b/source/dnode/mnode/impl/inc/mndTrans.h @@ -81,6 +81,7 @@ void mndTransSetDbName(STrans *pTrans, const char *dbname, const char *stbnam void mndTransSetArbGroupId(STrans *pTrans, int32_t groupId); void mndTransSetSerial(STrans *pTrans); void mndTransSetParallel(STrans *pTrans); +void mndTransSetChangeless(STrans *pTrans); void mndTransSetOper(STrans *pTrans, EOperType oper); int32_t mndTransCheckConflict(SMnode *pMnode, STrans *pTrans); #ifndef BUILD_NO_CALL diff --git a/source/dnode/mnode/impl/src/mndConsumer.c b/source/dnode/mnode/impl/src/mndConsumer.c index 52671f6b66..ed9333f480 100644 --- a/source/dnode/mnode/impl/src/mndConsumer.c +++ b/source/dnode/mnode/impl/src/mndConsumer.c @@ -292,16 +292,16 @@ static void storeOffsetRows(SMnode *pMnode, SMqHbReq *req, SMqConsumerObj *pCons static int32_t buildMqHbRsp(SRpcMsg *pMsg, SMqHbRsp *rsp){ int32_t tlen = tSerializeSMqHbRsp(NULL, 0, rsp); if (tlen <= 0){ - return TSDB_CODE_OUT_OF_MEMORY; + return TSDB_CODE_TMQ_INVALID_MSG; } void *buf = rpcMallocCont(tlen); if (buf == NULL) { return TSDB_CODE_OUT_OF_MEMORY; } - if(tSerializeSMqHbRsp(buf, tlen, rsp) != 0){ + if(tSerializeSMqHbRsp(buf, tlen, rsp) <= 0){ rpcFreeCont(buf); - return TSDB_CODE_OUT_OF_MEMORY; + return TSDB_CODE_TMQ_INVALID_MSG; } pMsg->info.rsp = buf; pMsg->info.rspLen = tlen; @@ -316,7 +316,7 @@ static int32_t mndProcessMqHbReq(SRpcMsg *pMsg) { SMqConsumerObj *pConsumer = NULL; if (tDeserializeSMqHbReq(pMsg->pCont, pMsg->contLen, &req) < 0) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_TMQ_INVALID_MSG; goto end; } diff --git a/source/dnode/mnode/impl/src/mndMain.c b/source/dnode/mnode/impl/src/mndMain.c index ee7cd83a8c..76a9d804e6 100644 --- a/source/dnode/mnode/impl/src/mndMain.c +++ b/source/dnode/mnode/impl/src/mndMain.c @@ -822,7 +822,7 @@ _OVER: "msg:%p, type:%s failed to process since %s, mnode restored:%d stopped:%d, sync restored:%d " "role:%s, redirect numOfEps:%d inUse:%d, type:%s", pMsg, TMSG_INFO(pMsg->msgType), terrstr(), pMnode->restored, pMnode->stopped, state.restored, - syncStr(state.restored), epSet.numOfEps, epSet.inUse, TMSG_INFO(pMsg->msgType)); + syncStr(state.state), epSet.numOfEps, epSet.inUse, TMSG_INFO(pMsg->msgType)); if (epSet.numOfEps <= 0) return -1; diff --git a/source/dnode/mnode/impl/src/mndTrans.c b/source/dnode/mnode/impl/src/mndTrans.c index 3af372a432..41ff45038f 100644 --- a/source/dnode/mnode/impl/src/mndTrans.c +++ b/source/dnode/mnode/impl/src/mndTrans.c @@ -739,6 +739,8 @@ void mndTransSetSerial(STrans *pTrans) { pTrans->exec = TRN_EXEC_SERIAL; } void mndTransSetParallel(STrans *pTrans) { pTrans->exec = TRN_EXEC_PARALLEL; } +void mndTransSetChangeless(STrans *pTrans) { pTrans->changeless = true; } + void mndTransSetOper(STrans *pTrans, EOperType oper) { pTrans->oper = oper; } static int32_t mndTransSync(SMnode *pMnode, STrans *pTrans) { @@ -855,6 +857,58 @@ int32_t mndTransCheckConflict(SMnode *pMnode, STrans *pTrans) { return 0; } +static bool mndTransActionsOfSameType(SArray *pActions) { + int32_t size = taosArrayGetSize(pActions); + ETrnAct lastActType = TRANS_ACTION_NULL; + bool same = true; + for (int32_t i = 0; i < size; ++i) { + STransAction *pAction = taosArrayGet(pActions, i); + if (i > 0) { + if (lastActType != pAction->actionType) { + same = false; + break; + } + } + lastActType = pAction->actionType; + } + return same; +} + +static int32_t mndTransCheckParallelActions(SMnode *pMnode, STrans *pTrans) { + if (pTrans->exec == TRN_EXEC_PARALLEL) { + if (mndTransActionsOfSameType(pTrans->redoActions) == false) { + terrno = TSDB_CODE_MND_TRANS_INVALID_STAGE; + mError("trans:%d, types of parallel redo actions are not the same", pTrans->id); + return -1; + } + + if (pTrans->policy == TRN_POLICY_ROLLBACK) { + if (mndTransActionsOfSameType(pTrans->undoActions) == false) { + terrno = TSDB_CODE_MND_TRANS_INVALID_STAGE; + mError("trans:%d, types of parallel undo actions are not the same", pTrans->id); + return -1; + } + } + } + + return 0; +} + +static int32_t mndTransCheckCommitActions(SMnode *pMnode, STrans *pTrans) { + if (!pTrans->changeless && taosArrayGetSize(pTrans->commitActions) <= 0) { + terrno = TSDB_CODE_MND_TRANS_CLOG_IS_NULL; + mError("trans:%d, commit actions of non-changeless trans are empty", pTrans->id); + return -1; + } + if (mndTransActionsOfSameType(pTrans->commitActions) == false) { + terrno = TSDB_CODE_MND_TRANS_INVALID_STAGE; + mError("trans:%d, types of commit actions are not the same", pTrans->id); + return -1; + } + + return 0; +} + int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans) { if (pTrans == NULL) return -1; @@ -862,9 +916,11 @@ int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans) { return -1; } - if (taosArrayGetSize(pTrans->commitActions) <= 0) { - terrno = TSDB_CODE_MND_TRANS_CLOG_IS_NULL; - mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr()); + if (mndTransCheckParallelActions(pMnode, pTrans) != 0) { + return -1; + } + + if (mndTransCheckCommitActions(pMnode, pTrans) != 0) { return -1; } @@ -1281,24 +1337,25 @@ static int32_t mndTransExecuteActions(SMnode *pMnode, STrans *pTrans, SArray *pA static int32_t mndTransExecuteRedoActions(SMnode *pMnode, STrans *pTrans, bool topHalf) { int32_t code = mndTransExecuteActions(pMnode, pTrans, pTrans->redoActions, topHalf); - if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) { - mError("failed to execute redoActions since:%s, code:0x%x", terrstr(), terrno); + if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS && code != TSDB_CODE_MND_TRANS_CTX_SWITCH) { + mError("trans:%d, failed to execute redoActions since:%s, code:0x%x, topHalf:%d", pTrans->id, terrstr(), terrno, + topHalf); } return code; } static int32_t mndTransExecuteUndoActions(SMnode *pMnode, STrans *pTrans, bool topHalf) { int32_t code = mndTransExecuteActions(pMnode, pTrans, pTrans->undoActions, topHalf); - if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) { - mError("failed to execute undoActions since %s", terrstr()); + if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS && code != TSDB_CODE_MND_TRANS_CTX_SWITCH) { + mError("trans:%d, failed to execute undoActions since %s. topHalf:%d", pTrans->id, terrstr(), topHalf); } return code; } static int32_t mndTransExecuteCommitActions(SMnode *pMnode, STrans *pTrans, bool topHalf) { int32_t code = mndTransExecuteActions(pMnode, pTrans, pTrans->commitActions, topHalf); - if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) { - mError("failed to execute commitActions since %s", terrstr()); + if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS && code != TSDB_CODE_MND_TRANS_CTX_SWITCH) { + mError("trans:%d, failed to execute commitActions since %s. topHalf:%d", pTrans->id, terrstr(), topHalf); } return code; } diff --git a/source/dnode/mnode/impl/src/mndVgroup.c b/source/dnode/mnode/impl/src/mndVgroup.c index 571f17fab6..2ee9af0486 100644 --- a/source/dnode/mnode/impl/src/mndVgroup.c +++ b/source/dnode/mnode/impl/src/mndVgroup.c @@ -2342,24 +2342,7 @@ int32_t mndAddVgroupBalanceToTrans(SMnode *pMnode, SVgObj *pVgroup, STrans *pTra return -1; } - if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, pVgroup) != 0) { - mError("trans:%d, vgid:%d failed to be balanced to dnode:%d", pTrans->id, vgid, dnodeId); - return -1; - } - mndReleaseDb(pMnode, pDb); - - SSdbRaw *pRaw = mndVgroupActionEncode(pVgroup); - if (pRaw == NULL) { - mError("trans:%d, vgid:%d failed to encode action to dnode:%d", pTrans->id, vgid, dnodeId); - return -1; - } - if (mndTransAppendCommitlog(pTrans, pRaw) != 0) { - sdbFreeRaw(pRaw); - mError("trans:%d, vgid:%d failed to append commit log dnode:%d", pTrans->id, vgid, dnodeId); - return -1; - } - (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY); } else { mInfo("trans:%d, vgid:%d cant be balanced to dnode:%d, exist:%d, online:%d", pTrans->id, vgid, dnodeId, exist, online); diff --git a/source/dnode/vnode/src/meta/metaSnapshot.c b/source/dnode/vnode/src/meta/metaSnapshot.c index c07bb8f5f0..7db8142762 100644 --- a/source/dnode/vnode/src/meta/metaSnapshot.c +++ b/source/dnode/vnode/src/meta/metaSnapshot.c @@ -79,6 +79,7 @@ int32_t metaSnapRead(SMetaSnapReader* pReader, uint8_t** ppData) { int32_t nKey = 0; int32_t nData = 0; STbDbKey key; + SMetaInfo info; *ppData = NULL; for (;;) { @@ -91,7 +92,8 @@ int32_t metaSnapRead(SMetaSnapReader* pReader, uint8_t** ppData) { goto _exit; } - if (key.version < pReader->sver) { + if (key.version < pReader->sver // + || metaGetInfo(pReader->pMeta, key.uid, &info, NULL) == TSDB_CODE_NOT_FOUND) { tdbTbcMoveToNext(pReader->pTbc); continue; } diff --git a/source/dnode/vnode/src/tq/tq.c b/source/dnode/vnode/src/tq/tq.c index 3a321fef79..b7882b547c 100644 --- a/source/dnode/vnode/src/tq/tq.c +++ b/source/dnode/vnode/src/tq/tq.c @@ -923,13 +923,14 @@ int32_t handleStep2Async(SStreamTask* pStreamTask, void* param) { STaskId hId = pStreamTask->hTaskInfo.id; SStreamTask* pTask = streamMetaAcquireTask(pStreamTask->pMeta, hId.streamId, hId.taskId); if (pTask == NULL) { - // todo handle error + tqWarn("s-task:0x%x failed to acquired it to exec step 2, scan wal quit", (int32_t) hId.taskId); + return TSDB_CODE_SUCCESS; } doStartFillhistoryStep2(pTask, pStreamTask, pTq); streamMetaReleaseTask(pMeta, pTask); - return 0; + return TSDB_CODE_SUCCESS; } // this function should be executed by only one thread, so we set an sentinel to protect this function diff --git a/source/dnode/vnode/src/tq/tqScan.c b/source/dnode/vnode/src/tq/tqScan.c index 9940164ee2..cc9e8c0136 100644 --- a/source/dnode/vnode/src/tq/tqScan.c +++ b/source/dnode/vnode/src/tq/tqScan.c @@ -311,7 +311,7 @@ int32_t tqTaosxScanLog(STQ* pTq, STqHandle* pHandle, SPackedData submit, STaosxR SSDataBlock* pBlock = taosArrayGet(pBlocks, i); tqAddBlockDataToRsp(pBlock, (SMqDataRsp*)pRsp, taosArrayGetSize(pBlock->pDataBlock), pTq->pVnode->config.tsdbCfg.precision); - totalRows += pBlock->info.rows; + *totalRows += pBlock->info.rows; blockDataFreeRes(pBlock); SSchemaWrapper* pSW = taosArrayGetP(pSchemas, i); taosArrayPush(pRsp->blockSchema, &pSW); diff --git a/source/dnode/vnode/src/tqCommon/tqCommon.c b/source/dnode/vnode/src/tqCommon/tqCommon.c index 1b67dce9b0..0f7f74f78b 100644 --- a/source/dnode/vnode/src/tqCommon/tqCommon.c +++ b/source/dnode/vnode/src/tqCommon/tqCommon.c @@ -850,12 +850,18 @@ int32_t tqStreamTaskProcessTaskResetReq(SStreamMeta* pMeta, SRpcMsg* pMsg) { tqDebug("s-task:%s receive task-reset msg from mnode, reset status and ready for data processing", pTask->id.idStr); + taosThreadMutexLock(&pTask->lock); + // clear flag set during do checkpoint, and open inputQ for all upstream tasks if (streamTaskGetStatus(pTask)->state == TASK_STATUS__CK) { + tqDebug("s-task:%s reset task status from checkpoint, current checkpointingId:%" PRId64 ", transId:%d", + pTask->id.idStr, pTask->chkInfo.checkpointingId, pTask->chkInfo.transId); streamTaskClearCheckInfo(pTask, true); streamTaskSetStatusReady(pTask); } + taosThreadMutexUnlock(&pTask->lock); + streamMetaReleaseTask(pMeta, pTask); return TSDB_CODE_SUCCESS; } diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c index 13edc6ebcb..76bb7b4b42 100644 --- a/source/libs/executor/src/executil.c +++ b/source/libs/executor/src/executil.c @@ -2140,6 +2140,9 @@ int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle* } pTableListInfo->oneTableForEachGroup = groupByTbname; + if (numOfTables == 1 && pTableListInfo->idInfo.tableType == TSDB_CHILD_TABLE) { + pTableListInfo->oneTableForEachGroup = true; + } if (groupSort && groupByTbname) { taosArraySort(pTableListInfo->pTableList, orderbyGroupIdComparFn); diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c index a51e627272..18e3d23608 100644 --- a/source/libs/executor/src/scanoperator.c +++ b/source/libs/executor/src/scanoperator.c @@ -889,14 +889,15 @@ static SSDataBlock* doGroupedTableScan(SOperatorInfo* pOperator) { if (pTableScanInfo->countState < TABLE_COUNT_STATE_END) { STableListInfo* pTableListInfo = pTableScanInfo->base.pTableListInfo; - if (pTableListInfo->oneTableForEachGroup || pTableListInfo->groupOffset) { // group by tbname, group by tag + sort + if (pTableListInfo->oneTableForEachGroup || pTableListInfo->groupOffset) { // group by tbname, group by tag + sort if (pTableScanInfo->countState < TABLE_COUNT_STATE_PROCESSED) { pTableScanInfo->countState = TABLE_COUNT_STATE_PROCESSED; STableKeyInfo* pStart = (STableKeyInfo*)tableListGetInfo(pTableScanInfo->base.pTableListInfo, pTableScanInfo->tableStartIndex); + if (NULL == pStart) return NULL; return getBlockForEmptyTable(pOperator, pStart); } - } else { // group by tag + no sort + } else { // group by tag + no sort int32_t numOfTables = tableListGetSize(pTableListInfo); if (pTableScanInfo->tableEndIndex + 1 >= numOfTables) { // get empty group, mark processed & rm from hash diff --git a/source/libs/executor/src/sysscanoperator.c b/source/libs/executor/src/sysscanoperator.c index a5e27e1910..25b8dcfe6e 100644 --- a/source/libs/executor/src/sysscanoperator.c +++ b/source/libs/executor/src/sysscanoperator.c @@ -983,7 +983,10 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo, : (3 + DBL_MANT_DIG - DBL_MIN_EXP + VARSTR_HEADER_SIZE); tagVarChar = taosMemoryCalloc(1, bufSize + 1); int32_t len = -1; - convertTagDataToStr(varDataVal(tagVarChar), tagType, tagData, tagLen, &len); + if (tagLen > 0) + convertTagDataToStr(varDataVal(tagVarChar), tagType, tagData, tagLen, &len); + else + len = 0; varDataSetLen(tagVarChar, len); } } diff --git a/source/libs/function/src/builtins.c b/source/libs/function/src/builtins.c index 2476449383..df992d1b55 100644 --- a/source/libs/function/src/builtins.c +++ b/source/libs/function/src/builtins.c @@ -2018,9 +2018,17 @@ static int32_t translateCast(SFunctionNode* pFunc, char* pErrBuf, int32_t len) { if (IS_STR_DATA_TYPE(para2Type)) { para2Bytes -= VARSTR_HEADER_SIZE; } - if (para2Bytes <= 0 || para2Bytes > 4096) { // cast dst var type length limits to 4096 bytes - return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR, - "CAST function converted length should be in range (0, 4096] bytes"); + if (para2Bytes <= 0 || + para2Bytes > TSDB_MAX_BINARY_LEN - VARSTR_HEADER_SIZE) { // cast dst var type length limits to 4096 bytes + if (TSDB_DATA_TYPE_NCHAR == para2Type) { + return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR, + "CAST function converted length should be in range (0, %d] NCHARS", + (TSDB_MAX_BINARY_LEN - VARSTR_HEADER_SIZE)/TSDB_NCHAR_SIZE); + } else { + return buildFuncErrMsg(pErrBuf, len, TSDB_CODE_FUNC_FUNTION_ERROR, + "CAST function converted length should be in range (0, %d] bytes", + TSDB_MAX_BINARY_LEN - VARSTR_HEADER_SIZE); + } } // add database precision as param diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c index fafc313afc..265ba04902 100644 --- a/source/libs/function/src/builtinsimpl.c +++ b/source/libs/function/src/builtinsimpl.c @@ -3598,15 +3598,15 @@ static int32_t doSaveTupleData(SSerializeDataHandle* pHandle, const void* pBuf, int32_t saveTupleData(SqlFunctionCtx* pCtx, int32_t rowIndex, const SSDataBlock* pSrcBlock, STuplePos* pPos) { prepareBuf(pCtx); - SWinKey key; + SWinKey key = {0}; if (pCtx->saveHandle.pBuf == NULL) { - SColumnInfoData* pColInfo = taosArrayGet(pSrcBlock->pDataBlock, 0); - if (pColInfo->info.type == TSDB_DATA_TYPE_TIMESTAMP) { - int64_t skey = *(int64_t*)colDataGetData(pColInfo, rowIndex); - - key.groupId = pSrcBlock->info.id.groupId; - key.ts = skey; + SColumnInfoData* pColInfo = pCtx->input.pPTS; + if (!pColInfo || pColInfo->info.type != TSDB_DATA_TYPE_TIMESTAMP) { + pColInfo = taosArrayGet(pSrcBlock->pDataBlock, 0); } + ASSERT(pColInfo->info.type == TSDB_DATA_TYPE_TIMESTAMP); + key.groupId = pSrcBlock->info.id.groupId; + key.ts = *(int64_t*)colDataGetData(pColInfo, rowIndex);; } char* buf = serializeTupleData(pSrcBlock, rowIndex, &pCtx->subsidiaries, pCtx->subsidiaries.buf); diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y index 817586c3aa..4f8e576e3f 100755 --- a/source/libs/parser/inc/sql.y +++ b/source/libs/parser/inc/sql.y @@ -423,6 +423,13 @@ type_name(A) ::= DECIMAL. type_name(A) ::= DECIMAL NK_LP NK_INTEGER NK_RP. { A = createDataType(TSDB_DATA_TYPE_DECIMAL); } type_name(A) ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP. { A = createDataType(TSDB_DATA_TYPE_DECIMAL); } +%type type_name_default_len { SDataType } +%destructor type_name_default_len { } +type_name_default_len(A) ::= BINARY. { A = createVarLenDataType(TSDB_DATA_TYPE_BINARY, NULL); } +type_name_default_len(A) ::= NCHAR. { A = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, NULL); } +type_name_default_len(A) ::= VARCHAR. { A = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, NULL); } +type_name_default_len(A) ::= VARBINARY. { A = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, NULL); } + %type tags_def_opt { SNodeList* } %destructor tags_def_opt { nodesDestroyList($$); } tags_def_opt(A) ::= . { A = NULL; } @@ -1119,6 +1126,9 @@ function_expression(A) ::= function_name(B) NK_LP expression_list(C) NK_RP(D). function_expression(A) ::= star_func(B) NK_LP star_func_para_list(C) NK_RP(D). { A = createRawExprNodeExt(pCxt, &B, &D, createFunctionNode(pCxt, &B, C)); } function_expression(A) ::= CAST(B) NK_LP expr_or_subquery(C) AS type_name(D) NK_RP(E). { A = createRawExprNodeExt(pCxt, &B, &E, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, C), D)); } +function_expression(A) ::= + CAST(B) NK_LP expr_or_subquery(C) AS type_name_default_len(D) NK_RP(E). { A = createRawExprNodeExt(pCxt, &B, &E, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, C), D)); } + function_expression(A) ::= literal_func(B). { A = B; } literal_func(A) ::= noarg_func(B) NK_LP NK_RP(C). { A = createRawExprNodeExt(pCxt, &B, &C, createFunctionNode(pCxt, &B, NULL)); } diff --git a/source/libs/parser/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c index 538d100367..f423edfdcf 100644 --- a/source/libs/parser/src/parAstCreater.c +++ b/source/libs/parser/src/parAstCreater.c @@ -1641,7 +1641,10 @@ SDataType createDataType(uint8_t type) { } SDataType createVarLenDataType(uint8_t type, const SToken* pLen) { - SDataType dt = {.type = type, .precision = 0, .scale = 0, .bytes = taosStr2Int32(pLen->z, NULL, 10)}; + int32_t len = TSDB_MAX_BINARY_LEN - VARSTR_HEADER_SIZE; + if (type == TSDB_DATA_TYPE_NCHAR) len /= TSDB_NCHAR_SIZE; + if(pLen) len = taosStr2Int32(pLen->z, NULL, 10); + SDataType dt = {.type = type, .precision = 0, .scale = 0, .bytes = len}; return dt; } diff --git a/source/libs/parser/src/parInsertSql.c b/source/libs/parser/src/parInsertSql.c index 1a41ba5fb9..687e7eea25 100644 --- a/source/libs/parser/src/parInsertSql.c +++ b/source/libs/parser/src/parInsertSql.c @@ -1566,11 +1566,13 @@ static int32_t parseValueTokenImpl(SInsertParseContext* pCxt, const char** pSql, case TSDB_DATA_TYPE_NCHAR: { // if the converted output len is over than pColumnModel->bytes, return error: 'Argument list too long' int32_t len = 0; - char* pUcs4 = taosMemoryCalloc(1, pSchema->bytes - VARSTR_HEADER_SIZE); + int64_t realLen = pToken->n << 2; + if (realLen > pSchema->bytes - VARSTR_HEADER_SIZE) realLen = pSchema->bytes - VARSTR_HEADER_SIZE; + char* pUcs4 = taosMemoryMalloc(realLen); if (NULL == pUcs4) { return TSDB_CODE_OUT_OF_MEMORY; } - if (!taosMbsToUcs4(pToken->z, pToken->n, (TdUcs4*)pUcs4, pSchema->bytes - VARSTR_HEADER_SIZE, &len)) { + if (!taosMbsToUcs4(pToken->z, pToken->n, (TdUcs4*)pUcs4, realLen, &len)) { taosMemoryFree(pUcs4); if (errno == E2BIG) { return generateSyntaxErrMsg(&pCxt->msg, TSDB_CODE_PAR_VALUE_TOO_LONG, pSchema->name); diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index a56a8bc5d5..301b60727a 100644 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -2121,7 +2121,6 @@ static int32_t translateMultiResFunc(STranslateContext* pCxt, SFunctionNode* pFu } if (tsKeepColumnName && 1 == LIST_LENGTH(pFunc->pParameterList) && !pFunc->node.asAlias && !pFunc->node.asParam) { strcpy(pFunc->node.userAlias, ((SExprNode*)nodesListGetNode(pFunc->pParameterList, 0))->userAlias); - strcpy(pFunc->node.aliasName, pFunc->node.userAlias); } return TSDB_CODE_SUCCESS; } @@ -2713,6 +2712,29 @@ static EDealRes rewriteExprToGroupKeyFunc(STranslateContext* pCxt, SNode** pNode return (TSDB_CODE_SUCCESS == pCxt->errCode ? DEAL_RES_IGNORE_CHILD : DEAL_RES_ERROR); } +static bool isTbnameFuction(SNode* pNode) { + return QUERY_NODE_FUNCTION == nodeType(pNode) && FUNCTION_TYPE_TBNAME == ((SFunctionNode*)pNode)->funcType; +} + +static bool hasTbnameFunction(SNodeList* pPartitionByList) { + SNode* pPartKey = NULL; + FOREACH(pPartKey, pPartitionByList) { + if (isTbnameFuction(pPartKey)) { + return true; + } + } + return false; +} + +static bool fromSubtable(SNode* table) { + if (NULL == table) return false; + if (table->type == QUERY_NODE_REAL_TABLE && ((SRealTableNode*)table)->pMeta && + ((SRealTableNode*)table)->pMeta->tableType == TSDB_CHILD_TABLE) { + return true; + } + return false; +} + static EDealRes doCheckExprForGroupBy(SNode** pNode, void* pContext) { STranslateContext* pCxt = (STranslateContext*)pContext; SSelectStmt* pSelect = (SSelectStmt*)pCxt->pCurrStmt; @@ -2724,15 +2746,25 @@ static EDealRes doCheckExprForGroupBy(SNode** pNode, void* pContext) { } SNode* pGroupNode = NULL; FOREACH(pGroupNode, getGroupByList(pCxt)) { - if (nodesEqualNode(getGroupByNode(pGroupNode), *pNode)) { + SNode* pActualNode = getGroupByNode(pGroupNode); + if (nodesEqualNode(pActualNode, *pNode)) { return DEAL_RES_IGNORE_CHILD; } + if (isTbnameFuction(pActualNode) && QUERY_NODE_COLUMN == nodeType(*pNode) && + ((SColumnNode*)*pNode)->colType == COLUMN_TYPE_TAG) { + return rewriteExprToGroupKeyFunc(pCxt, pNode); + } } SNode* pPartKey = NULL; + bool partionByTbname = hasTbnameFunction(pSelect->pPartitionByList); FOREACH(pPartKey, pSelect->pPartitionByList) { if (nodesEqualNode(pPartKey, *pNode)) { return rewriteExprToGroupKeyFunc(pCxt, pNode); } + if ((partionByTbname) && QUERY_NODE_COLUMN == nodeType(*pNode) && + ((SColumnNode*)*pNode)->colType == COLUMN_TYPE_TAG) { + return rewriteExprToGroupKeyFunc(pCxt, pNode); + } } if (NULL != pSelect->pWindow && QUERY_NODE_STATE_WINDOW == nodeType(pSelect->pWindow)) { if (nodesEqualNode(((SStateWindowNode*)pSelect->pWindow)->pExpr, *pNode)) { @@ -2796,11 +2828,19 @@ static EDealRes doCheckAggColCoexist(SNode** pNode, void* pContext) { return DEAL_RES_IGNORE_CHILD; } SNode* pPartKey = NULL; + bool partionByTbname = false; + if (fromSubtable(((SSelectStmt*)pCxt->pTranslateCxt->pCurrStmt)->pFromTable) || + hasTbnameFunction(((SSelectStmt*)pCxt->pTranslateCxt->pCurrStmt)->pPartitionByList)) { + partionByTbname = true; + } FOREACH(pPartKey, ((SSelectStmt*)pCxt->pTranslateCxt->pCurrStmt)->pPartitionByList) { if (nodesEqualNode(pPartKey, *pNode)) { return rewriteExprToGroupKeyFunc(pCxt->pTranslateCxt, pNode); } } + if (partionByTbname && QUERY_NODE_COLUMN == nodeType(*pNode) && ((SColumnNode*)*pNode)->colType == COLUMN_TYPE_TAG) { + return rewriteExprToGroupKeyFunc(pCxt->pTranslateCxt, pNode); + } if (isScanPseudoColumnFunc(*pNode) || QUERY_NODE_COLUMN == nodeType(*pNode)) { pCxt->existCol = true; } @@ -3970,22 +4010,12 @@ static int32_t checkStateExpr(STranslateContext* pCxt, SNode* pNode) { return TSDB_CODE_SUCCESS; } -static bool hasPartitionByTbname(SNodeList* pPartitionByList) { - SNode* pPartKey = NULL; - FOREACH(pPartKey, pPartitionByList) { - if (QUERY_NODE_FUNCTION == nodeType(pPartKey) && FUNCTION_TYPE_TBNAME == ((SFunctionNode*)pPartKey)->funcType) { - return true; - } - } - return false; -} - static int32_t checkStateWindowForStream(STranslateContext* pCxt, SSelectStmt* pSelect) { if (!pCxt->createStream) { return TSDB_CODE_SUCCESS; } if (TSDB_SUPER_TABLE == ((SRealTableNode*)pSelect->pFromTable)->pMeta->tableType && - !hasPartitionByTbname(pSelect->pPartitionByList)) { + !hasTbnameFunction(pSelect->pPartitionByList)) { return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_STREAM_QUERY, "Unsupported stream query"); } return TSDB_CODE_SUCCESS; @@ -7706,12 +7736,12 @@ static int32_t translateKillTransaction(STranslateContext* pCxt, SKillStmt* pStm static bool crossTableWithoutAggOper(SSelectStmt* pSelect) { return NULL == pSelect->pWindow && !pSelect->hasAggFuncs && !pSelect->hasIndefiniteRowsFunc && !pSelect->hasInterpFunc && TSDB_SUPER_TABLE == ((SRealTableNode*)pSelect->pFromTable)->pMeta->tableType && - !hasPartitionByTbname(pSelect->pPartitionByList); + !hasTbnameFunction(pSelect->pPartitionByList); } static bool crossTableWithUdaf(SSelectStmt* pSelect) { return pSelect->hasUdaf && TSDB_SUPER_TABLE == ((SRealTableNode*)pSelect->pFromTable)->pMeta->tableType && - !hasPartitionByTbname(pSelect->pPartitionByList); + !hasTbnameFunction(pSelect->pPartitionByList); } static int32_t checkCreateStream(STranslateContext* pCxt, SCreateStreamStmt* pStmt) { @@ -7967,10 +7997,10 @@ static int32_t subtableExprHasColumnOrPseudoColumn(SNode* pNode) { static int32_t checkStreamQuery(STranslateContext* pCxt, SCreateStreamStmt* pStmt) { SSelectStmt* pSelect = (SSelectStmt*)pStmt->pQuery; - if ((SRealTableNode*)pSelect->pFromTable && ((SRealTableNode*)pSelect->pFromTable)->pMeta && - TSDB_SUPER_TABLE == ((SRealTableNode*)pSelect->pFromTable)->pMeta->tableType && - !hasPartitionByTbname(pSelect->pPartitionByList) && pSelect->pWindow != NULL && - pSelect->pWindow->type == QUERY_NODE_EVENT_WINDOW) { + if ( (SRealTableNode*)pSelect->pFromTable && ((SRealTableNode*)pSelect->pFromTable)->pMeta + && TSDB_SUPER_TABLE == ((SRealTableNode*)pSelect->pFromTable)->pMeta->tableType + && !hasTbnameFunction(pSelect->pPartitionByList) + && pSelect->pWindow != NULL && pSelect->pWindow->type == QUERY_NODE_EVENT_WINDOW) { return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_STREAM_QUERY, "Event window for stream on super table must patitioned by table name"); } @@ -7995,9 +8025,9 @@ static int32_t checkStreamQuery(STranslateContext* pCxt, SCreateStreamStmt* pStm } if (pSelect->pWindow != NULL && pSelect->pWindow->type == QUERY_NODE_COUNT_WINDOW) { - if ((SRealTableNode*)pSelect->pFromTable && ((SRealTableNode*)pSelect->pFromTable)->pMeta && - TSDB_SUPER_TABLE == ((SRealTableNode*)pSelect->pFromTable)->pMeta->tableType && - !hasPartitionByTbname(pSelect->pPartitionByList)) { + if ( (SRealTableNode*)pSelect->pFromTable && ((SRealTableNode*)pSelect->pFromTable)->pMeta + && TSDB_SUPER_TABLE == ((SRealTableNode*)pSelect->pFromTable)->pMeta->tableType + && !hasTbnameFunction(pSelect->pPartitionByList) ) { return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_STREAM_QUERY, "Count window for stream on super table must patitioned by table name"); } diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c index c572b31790..0c1a055495 100644 --- a/source/libs/parser/src/sql.c +++ b/source/libs/parser/src/sql.c @@ -463,29 +463,29 @@ #endif /************* Begin control #defines *****************************************/ #define YYCODETYPE unsigned short int -#define YYNOCODE 524 +#define YYNOCODE 525 #define YYACTIONTYPE unsigned short int #define ParseTOKENTYPE SToken typedef union { int yyinit; ParseTOKENTYPE yy0; - SDataType yy56; - SNodeList* yy72; - EOrder yy130; - SToken yy305; - EOperatorType yy324; - int8_t yy359; - STokenPair yy361; - int32_t yy444; - SShowTablesOption yy517; - ENullOrder yy681; - EShowKind yy761; - EJoinType yy828; - EFillMode yy926; - SAlterOption yy941; - bool yy985; - SNode* yy1000; - int64_t yy1005; + SToken yy29; + SAlterOption yy95; + SNodeList* yy124; + EFillMode yy144; + STokenPair yy147; + EJoinType yy162; + int64_t yy459; + EOperatorType yy590; + EOrder yy638; + SShowTablesOption yy667; + int32_t yy760; + SDataType yy784; + EShowKind yy789; + int8_t yy803; + SNode* yy812; + bool yy887; + ENullOrder yy907; } YYMINORTYPE; #ifndef YYSTACKDEPTH #define YYSTACKDEPTH 100 @@ -501,18 +501,18 @@ typedef union { #define ParseCTX_FETCH #define ParseCTX_STORE #define YYFALLBACK 1 -#define YYNSTATE 899 -#define YYNRULE 700 -#define YYNRULE_WITH_ACTION 700 +#define YYNSTATE 904 +#define YYNRULE 705 +#define YYNRULE_WITH_ACTION 705 #define YYNTOKEN 358 -#define YY_MAX_SHIFT 898 -#define YY_MIN_SHIFTREDUCE 1337 -#define YY_MAX_SHIFTREDUCE 2036 -#define YY_ERROR_ACTION 2037 -#define YY_ACCEPT_ACTION 2038 -#define YY_NO_ACTION 2039 -#define YY_MIN_REDUCE 2040 -#define YY_MAX_REDUCE 2739 +#define YY_MAX_SHIFT 903 +#define YY_MIN_SHIFTREDUCE 1343 +#define YY_MAX_SHIFTREDUCE 2047 +#define YY_ERROR_ACTION 2048 +#define YY_ACCEPT_ACTION 2049 +#define YY_NO_ACTION 2050 +#define YY_MIN_REDUCE 2051 +#define YY_MAX_REDUCE 2755 /************* End control #defines *******************************************/ #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) @@ -579,651 +579,664 @@ typedef union { ** yy_default[] Default action for each state. ** *********** Begin parsing tables **********************************************/ -#define YY_ACTTAB_COUNT (3132) +#define YY_ACTTAB_COUNT (3265) static const YYACTIONTYPE yy_action[] = { - /* 0 */ 609, 2287, 465, 610, 2083, 2280, 2282, 516, 170, 429, - /* 10 */ 509, 174, 47, 45, 1953, 508, 430, 463, 2233, 2285, - /* 20 */ 444, 2234, 1793, 40, 39, 1818, 2285, 46, 44, 43, - /* 30 */ 42, 41, 33, 37, 312, 1879, 2126, 1791, 40, 39, - /* 40 */ 2533, 795, 46, 44, 43, 42, 41, 796, 2231, 1377, - /* 50 */ 758, 148, 795, 761, 199, 576, 574, 2443, 393, 796, - /* 60 */ 2231, 717, 220, 746, 2705, 1874, 2705, 139, 1384, 2274, - /* 70 */ 2038, 19, 1802, 2710, 652, 177, 2705, 2052, 1799, 139, - /* 80 */ 700, 2551, 2711, 206, 745, 206, 657, 2706, 747, 2706, - /* 90 */ 747, 1379, 1382, 1383, 2492, 2709, 2499, 461, 778, 2706, - /* 100 */ 2708, 421, 420, 2222, 895, 2215, 395, 15, 482, 870, - /* 110 */ 869, 868, 867, 472, 1818, 866, 865, 153, 860, 859, - /* 120 */ 858, 857, 856, 855, 854, 152, 848, 847, 846, 471, - /* 130 */ 470, 843, 842, 841, 186, 185, 840, 2373, 2532, 50, - /* 140 */ 767, 2570, 2596, 1881, 1882, 115, 2534, 782, 2536, 2537, - /* 150 */ 777, 450, 800, 475, 62, 2371, 783, 189, 474, 2624, - /* 160 */ 450, 2639, 800, 440, 2620, 304, 2632, 757, 66, 140, - /* 170 */ 756, 800, 2705, 419, 418, 2287, 654, 853, 208, 493, - /* 180 */ 2191, 1853, 1863, 413, 525, 2349, 2654, 2636, 1880, 1883, - /* 190 */ 745, 206, 448, 2285, 625, 2706, 747, 1403, 656, 1402, - /* 200 */ 173, 62, 655, 1794, 717, 1792, 1793, 2705, 629, 2373, - /* 210 */ 2028, 2236, 40, 39, 144, 2493, 46, 44, 43, 42, - /* 220 */ 41, 1791, 2533, 2452, 447, 2711, 206, 2370, 783, 276, - /* 230 */ 2706, 747, 1404, 275, 277, 779, 222, 1797, 1798, 1850, - /* 240 */ 1805, 1852, 1855, 1856, 1857, 1858, 1859, 1860, 1861, 1862, - /* 250 */ 774, 798, 797, 1873, 1875, 1876, 1877, 1878, 2, 47, - /* 260 */ 45, 839, 1799, 2551, 391, 746, 1816, 444, 2705, 1793, - /* 270 */ 2453, 62, 450, 559, 717, 405, 579, 2705, 2499, 850, - /* 280 */ 778, 578, 1879, 800, 1791, 2129, 745, 206, 895, 2509, - /* 290 */ 617, 2706, 747, 610, 2083, 2711, 206, 539, 740, 580, - /* 300 */ 2706, 747, 1818, 99, 392, 541, 402, 308, 497, 428, - /* 310 */ 1819, 691, 1874, 1721, 1722, 519, 2513, 2027, 19, 1908, - /* 320 */ 2532, 717, 308, 2570, 2705, 1799, 2551, 115, 2534, 782, - /* 330 */ 2536, 2537, 777, 2710, 800, 499, 495, 150, 689, 157, - /* 340 */ 2595, 2624, 2711, 206, 852, 440, 2620, 2706, 747, 1822, - /* 350 */ 1821, 895, 416, 687, 15, 685, 273, 272, 671, 670, - /* 360 */ 669, 2515, 2518, 527, 241, 661, 145, 665, 612, 308, - /* 370 */ 2091, 664, 800, 698, 531, 2349, 663, 668, 423, 422, - /* 380 */ 14, 13, 662, 2206, 1909, 658, 769, 1794, 2596, 1792, - /* 390 */ 1881, 1882, 739, 2360, 2339, 173, 567, 566, 565, 564, - /* 400 */ 563, 558, 557, 556, 555, 399, 2237, 469, 468, 545, - /* 410 */ 544, 543, 542, 536, 535, 534, 2041, 529, 528, 414, - /* 420 */ 2709, 1797, 1798, 520, 1640, 1641, 224, 1986, 1853, 1863, - /* 430 */ 1659, 736, 1800, 1580, 1581, 1880, 1883, 129, 2021, 308, - /* 440 */ 128, 127, 126, 125, 124, 123, 122, 121, 120, 1799, - /* 450 */ 1794, 129, 1792, 839, 128, 127, 126, 125, 124, 123, - /* 460 */ 122, 121, 120, 1652, 1653, 701, 36, 442, 1903, 1904, - /* 470 */ 1905, 1906, 1907, 1911, 1912, 1913, 1914, 733, 732, 1984, - /* 480 */ 1985, 1987, 1988, 1989, 1797, 1798, 1850, 1922, 1852, 1855, - /* 490 */ 1856, 1857, 1858, 1859, 1860, 1861, 1862, 774, 798, 797, - /* 500 */ 1873, 1875, 1876, 1877, 1878, 2, 12, 47, 45, 561, - /* 510 */ 2349, 2533, 197, 306, 175, 444, 243, 1793, 12, 367, - /* 520 */ 612, 699, 2091, 830, 761, 742, 737, 730, 726, 187, - /* 530 */ 1879, 2710, 1791, 2421, 2705, 35, 365, 75, 351, 898, - /* 540 */ 74, 40, 39, 619, 2412, 46, 44, 43, 42, 41, - /* 550 */ 394, 2322, 2551, 2709, 415, 353, 2353, 2706, 2707, 696, - /* 560 */ 1874, 229, 239, 591, 589, 586, 19, 2499, 1823, 778, - /* 570 */ 2094, 196, 1403, 1799, 1402, 46, 44, 43, 42, 41, - /* 580 */ 886, 882, 878, 874, 2220, 350, 2063, 758, 148, 40, - /* 590 */ 39, 278, 606, 46, 44, 43, 42, 41, 176, 895, - /* 600 */ 1803, 604, 15, 62, 600, 596, 2169, 1404, 702, 2532, - /* 610 */ 717, 2062, 2570, 2705, 29, 1821, 115, 2534, 782, 2536, - /* 620 */ 2537, 777, 888, 800, 796, 2231, 114, 614, 189, 323, - /* 630 */ 2624, 2711, 206, 611, 440, 2620, 2706, 747, 1881, 1882, - /* 640 */ 1822, 63, 2499, 701, 211, 671, 670, 669, 796, 2231, - /* 650 */ 758, 148, 661, 145, 665, 316, 317, 2655, 664, 717, - /* 660 */ 315, 792, 2705, 663, 668, 423, 422, 2499, 55, 662, - /* 670 */ 796, 2231, 658, 570, 226, 51, 1853, 1863, 174, 2170, - /* 680 */ 2711, 206, 1819, 1880, 1883, 2706, 747, 463, 2233, 1998, - /* 690 */ 513, 85, 84, 512, 758, 148, 219, 795, 1794, 716, - /* 700 */ 1792, 760, 204, 2632, 2633, 311, 146, 2637, 149, 504, - /* 710 */ 502, 2595, 310, 552, 749, 91, 626, 551, 90, 2218, - /* 720 */ 390, 703, 2412, 491, 288, 550, 488, 484, 480, 477, - /* 730 */ 505, 281, 1797, 1798, 1850, 231, 1852, 1855, 1856, 1857, - /* 740 */ 1858, 1859, 1860, 1861, 1862, 774, 798, 797, 1873, 1875, - /* 750 */ 1876, 1877, 1878, 2, 47, 45, 1884, 2281, 2282, 2533, - /* 760 */ 569, 230, 444, 2040, 1793, 205, 2632, 2633, 101, 146, - /* 770 */ 2637, 308, 779, 2213, 2093, 627, 2366, 1879, 306, 1791, - /* 780 */ 806, 805, 804, 803, 50, 89, 2533, 138, 137, 136, - /* 790 */ 135, 134, 133, 132, 131, 130, 796, 2231, 1818, 779, - /* 800 */ 2551, 2662, 762, 201, 96, 1672, 1673, 1874, 2306, 207, - /* 810 */ 2632, 2633, 2235, 146, 2637, 2499, 514, 778, 40, 39, - /* 820 */ 1799, 417, 46, 44, 43, 42, 41, 2551, 200, 40, - /* 830 */ 39, 2226, 60, 46, 44, 43, 42, 41, 741, 1957, - /* 840 */ 714, 1822, 2499, 308, 778, 1818, 895, 62, 2533, 48, - /* 850 */ 1671, 1674, 1889, 717, 2287, 2639, 2705, 2532, 1818, 1823, - /* 860 */ 2570, 779, 439, 2675, 115, 2534, 782, 2536, 2537, 777, - /* 870 */ 831, 800, 2285, 2278, 2711, 206, 2725, 1384, 2624, 2706, - /* 880 */ 747, 2635, 440, 2620, 2532, 1881, 1882, 2570, 12, 2551, - /* 890 */ 10, 115, 2534, 782, 2536, 2537, 777, 2207, 800, 796, - /* 900 */ 2231, 1382, 1383, 2725, 2499, 2624, 778, 40, 39, 440, - /* 910 */ 2620, 46, 44, 43, 42, 41, 284, 113, 456, 533, - /* 920 */ 1978, 40, 39, 1853, 1863, 46, 44, 43, 42, 41, - /* 930 */ 1880, 1883, 40, 39, 151, 1979, 46, 44, 43, 42, - /* 940 */ 41, 112, 507, 2223, 506, 1794, 2532, 1792, 1910, 2570, - /* 950 */ 109, 459, 2061, 115, 2534, 782, 2536, 2537, 777, 1854, - /* 960 */ 800, 773, 796, 2231, 2533, 2725, 656, 2624, 554, 553, - /* 970 */ 655, 440, 2620, 1484, 505, 835, 1977, 779, 2278, 1797, - /* 980 */ 1798, 1850, 546, 1852, 1855, 1856, 1857, 1858, 1859, 1860, - /* 990 */ 1861, 1862, 774, 798, 797, 1873, 1875, 1876, 1877, 1878, - /* 1000 */ 2, 47, 45, 2533, 202, 2551, 1854, 1997, 2499, 444, - /* 1010 */ 1496, 1793, 796, 2231, 1486, 308, 779, 1851, 728, 1854, - /* 1020 */ 2499, 1969, 778, 2287, 1879, 1495, 1791, 43, 42, 41, - /* 1030 */ 34, 449, 547, 837, 164, 163, 834, 833, 832, 161, - /* 1040 */ 1915, 2285, 2053, 1500, 2551, 2205, 837, 164, 163, 834, - /* 1050 */ 833, 832, 161, 187, 1874, 796, 2231, 1850, 1499, 2499, - /* 1060 */ 1823, 778, 2532, 2639, 1851, 2570, 100, 1799, 2509, 115, - /* 1070 */ 2534, 782, 2536, 2537, 777, 548, 800, 1851, 796, 2231, - /* 1080 */ 2354, 2599, 659, 2624, 1406, 1407, 1762, 440, 2620, 2634, - /* 1090 */ 2533, 361, 581, 895, 2264, 2513, 48, 1700, 628, 2060, - /* 1100 */ 2287, 2532, 360, 779, 2570, 2698, 1481, 172, 115, 2534, - /* 1110 */ 782, 2536, 2537, 777, 678, 800, 455, 454, 765, 1761, - /* 1120 */ 2725, 2668, 2624, 796, 2231, 583, 440, 2620, 466, 690, - /* 1130 */ 1950, 2551, 1881, 1882, 796, 2231, 173, 259, 796, 2231, - /* 1140 */ 2515, 2517, 441, 2228, 750, 274, 2499, 2236, 778, 458, - /* 1150 */ 457, 800, 2440, 182, 279, 2499, 796, 2231, 287, 796, - /* 1160 */ 2231, 681, 646, 642, 638, 634, 2059, 258, 675, 673, - /* 1170 */ 1853, 1863, 2287, 796, 2231, 271, 764, 1880, 1883, 320, - /* 1180 */ 464, 837, 164, 163, 834, 833, 832, 161, 2532, 107, - /* 1190 */ 2285, 2570, 1794, 793, 1792, 115, 2534, 782, 2536, 2537, - /* 1200 */ 777, 2058, 800, 2057, 796, 2231, 9, 2725, 97, 2624, - /* 1210 */ 2533, 256, 1822, 440, 2620, 2224, 71, 1818, 2056, 70, - /* 1220 */ 2055, 2054, 2499, 779, 794, 2643, 1797, 1798, 1850, 2051, - /* 1230 */ 1852, 1855, 1856, 1857, 1858, 1859, 1860, 1861, 1862, 774, - /* 1240 */ 798, 797, 1873, 1875, 1876, 1877, 1878, 2, 47, 45, - /* 1250 */ 1439, 2551, 796, 2231, 2050, 772, 444, 2499, 1793, 2499, - /* 1260 */ 660, 796, 2231, 648, 647, 2049, 2499, 2048, 778, 2047, - /* 1270 */ 2046, 1879, 347, 1791, 2499, 753, 2499, 2499, 246, 469, - /* 1280 */ 468, 467, 2045, 2044, 1479, 2499, 2332, 255, 248, 1807, - /* 1290 */ 2043, 1440, 667, 666, 253, 623, 650, 649, 864, 862, - /* 1300 */ 836, 1874, 1879, 2278, 1800, 2068, 890, 77, 2532, 96, - /* 1310 */ 2499, 2570, 3, 245, 1799, 115, 2534, 782, 2536, 2537, - /* 1320 */ 777, 2499, 800, 2499, 53, 2499, 2499, 2725, 523, 2624, - /* 1330 */ 2287, 1386, 1874, 440, 2620, 2287, 2227, 1817, 2499, 2499, - /* 1340 */ 895, 162, 2533, 15, 162, 1799, 2499, 1545, 791, 2644, - /* 1350 */ 1942, 264, 734, 2286, 262, 779, 2208, 693, 162, 692, - /* 1360 */ 88, 1536, 829, 828, 827, 1540, 826, 1542, 1543, 825, - /* 1370 */ 822, 771, 1551, 819, 1553, 1554, 816, 813, 810, 1881, - /* 1380 */ 1882, 213, 2113, 2551, 397, 396, 2111, 141, 266, 154, - /* 1390 */ 268, 265, 270, 267, 451, 269, 724, 301, 2499, 87, - /* 1400 */ 778, 2102, 1801, 1949, 672, 2100, 2520, 1879, 674, 460, - /* 1410 */ 751, 2030, 2031, 14, 13, 143, 1716, 1853, 1863, 54, - /* 1420 */ 49, 1900, 49, 676, 1880, 1883, 190, 679, 162, 326, - /* 1430 */ 325, 1823, 64, 1719, 295, 49, 1851, 1874, 1942, 1794, - /* 1440 */ 2532, 1792, 49, 2570, 328, 327, 2552, 115, 2534, 782, - /* 1450 */ 2536, 2537, 777, 314, 800, 2533, 76, 2167, 159, 2597, - /* 1460 */ 162, 2624, 330, 329, 2522, 440, 2620, 2166, 779, 73, - /* 1470 */ 1808, 1973, 1803, 1797, 1798, 1850, 808, 1852, 1855, 1856, - /* 1480 */ 1857, 1858, 1859, 1860, 1861, 1862, 774, 798, 797, 1873, - /* 1490 */ 1875, 1876, 1877, 1878, 2, 1983, 2551, 1982, 332, 331, - /* 1500 */ 2358, 293, 2084, 763, 1811, 1813, 160, 1916, 334, 333, - /* 1510 */ 1864, 2499, 2658, 778, 336, 335, 162, 1669, 798, 797, - /* 1520 */ 1873, 1875, 1876, 1877, 1878, 142, 338, 337, 318, 731, - /* 1530 */ 844, 788, 2533, 322, 845, 1527, 340, 339, 159, 342, - /* 1540 */ 341, 344, 343, 754, 359, 779, 346, 345, 431, 435, - /* 1550 */ 738, 1558, 785, 2532, 1458, 473, 2570, 2359, 1456, 2090, - /* 1560 */ 115, 2534, 782, 2536, 2537, 777, 2275, 800, 710, 2659, - /* 1570 */ 1804, 2669, 768, 2551, 2624, 1784, 2533, 1760, 440, 2620, - /* 1580 */ 759, 1562, 300, 303, 307, 2192, 476, 5, 2499, 779, - /* 1590 */ 778, 1569, 481, 411, 489, 490, 1826, 500, 501, 215, - /* 1600 */ 1567, 214, 503, 217, 1693, 2533, 354, 453, 452, 1785, - /* 1610 */ 1816, 517, 1817, 165, 524, 228, 584, 2551, 779, 530, - /* 1620 */ 526, 532, 572, 798, 797, 1873, 1875, 1876, 1877, 1878, - /* 1630 */ 2532, 537, 2499, 2570, 778, 2533, 549, 116, 2534, 782, - /* 1640 */ 2536, 2537, 777, 560, 800, 2351, 2551, 568, 776, 562, - /* 1650 */ 571, 2624, 573, 582, 234, 2623, 2620, 585, 233, 587, - /* 1660 */ 588, 2499, 236, 778, 590, 592, 1824, 607, 4, 608, - /* 1670 */ 615, 618, 616, 1819, 2532, 244, 2551, 2570, 93, 2533, - /* 1680 */ 620, 116, 2534, 782, 2536, 2537, 777, 247, 800, 1825, - /* 1690 */ 621, 2499, 779, 778, 1827, 2624, 622, 624, 250, 770, - /* 1700 */ 2620, 252, 1828, 780, 630, 94, 2570, 651, 2367, 2533, - /* 1710 */ 116, 2534, 782, 2536, 2537, 777, 95, 800, 257, 118, - /* 1720 */ 2551, 387, 779, 653, 2624, 682, 2221, 2430, 404, 2620, - /* 1730 */ 261, 2217, 263, 2532, 167, 2499, 2570, 778, 2533, 117, - /* 1740 */ 383, 2534, 782, 2536, 2537, 777, 775, 800, 766, 2589, - /* 1750 */ 2551, 779, 2219, 2214, 168, 169, 683, 2427, 695, 2426, - /* 1760 */ 697, 98, 155, 280, 1820, 2499, 355, 778, 705, 704, - /* 1770 */ 285, 712, 2413, 735, 786, 721, 706, 2532, 709, 2551, - /* 1780 */ 2570, 711, 283, 2646, 178, 2534, 782, 2536, 2537, 777, - /* 1790 */ 2674, 800, 8, 2673, 2499, 290, 778, 292, 744, 294, - /* 1800 */ 181, 297, 722, 720, 719, 752, 299, 2532, 296, 755, - /* 1810 */ 2570, 2728, 298, 436, 179, 2534, 782, 2536, 2537, 777, - /* 1820 */ 1942, 800, 147, 1821, 1947, 1, 718, 2665, 193, 1945, - /* 1830 */ 61, 2704, 2640, 784, 209, 309, 2532, 156, 2381, 2570, - /* 1840 */ 2533, 356, 357, 116, 2534, 782, 2536, 2537, 777, 2605, - /* 1850 */ 800, 302, 2380, 779, 2379, 446, 789, 2624, 2533, 790, - /* 1860 */ 158, 358, 2621, 2491, 106, 2232, 2490, 108, 748, 2726, - /* 1870 */ 1361, 779, 362, 2486, 802, 2485, 2477, 2476, 2468, 2467, - /* 1880 */ 349, 2551, 2483, 2482, 2533, 2474, 2473, 2462, 2461, 2480, - /* 1890 */ 889, 2479, 2471, 2470, 2459, 2458, 2499, 779, 778, 2551, - /* 1900 */ 892, 894, 2456, 364, 366, 2455, 166, 2279, 386, 52, - /* 1910 */ 2451, 374, 385, 2450, 2499, 375, 778, 409, 410, 2449, - /* 1920 */ 82, 2444, 398, 478, 479, 2551, 1744, 1745, 212, 2442, - /* 1930 */ 483, 485, 486, 487, 1743, 2441, 433, 412, 2532, 2439, - /* 1940 */ 2499, 2570, 778, 492, 2438, 178, 2534, 782, 2536, 2537, - /* 1950 */ 777, 494, 800, 496, 2436, 498, 2532, 2437, 1732, 2570, - /* 1960 */ 2417, 216, 434, 384, 2534, 782, 2536, 2537, 777, 2416, - /* 1970 */ 800, 2533, 218, 1696, 83, 1695, 2394, 2393, 2392, 510, - /* 1980 */ 511, 2391, 2532, 2390, 779, 2570, 2341, 2533, 2666, 384, - /* 1990 */ 2534, 782, 2536, 2537, 777, 515, 800, 1639, 2338, 518, - /* 2000 */ 779, 2337, 2331, 2533, 521, 2328, 522, 221, 2327, 86, - /* 2010 */ 2326, 2325, 2551, 2330, 223, 2329, 776, 2324, 2323, 2321, - /* 2020 */ 2320, 2319, 225, 538, 2318, 540, 2316, 2499, 2551, 778, - /* 2030 */ 2315, 2314, 2313, 2336, 2312, 2311, 2310, 2334, 2317, 2309, - /* 2040 */ 2308, 2307, 2305, 2499, 2551, 778, 2304, 2303, 2302, 2301, - /* 2050 */ 2300, 2299, 227, 2298, 92, 2297, 2296, 2295, 2335, 2499, - /* 2060 */ 2333, 778, 2533, 2294, 2293, 1645, 2292, 2291, 232, 2532, - /* 2070 */ 575, 2290, 2570, 577, 2289, 779, 377, 2534, 782, 2536, - /* 2080 */ 2537, 777, 2288, 800, 1497, 2532, 2132, 1501, 2570, 240, - /* 2090 */ 235, 1493, 179, 2534, 782, 2536, 2537, 777, 2131, 800, - /* 2100 */ 2130, 2532, 400, 2551, 2570, 593, 2124, 2117, 383, 2534, - /* 2110 */ 782, 2536, 2537, 777, 2128, 800, 2125, 2590, 2499, 401, - /* 2120 */ 778, 594, 743, 595, 237, 597, 238, 598, 601, 599, - /* 2130 */ 602, 2104, 605, 2079, 603, 79, 188, 1385, 2078, 2533, - /* 2140 */ 443, 2415, 242, 2519, 80, 198, 613, 2727, 2411, 2401, - /* 2150 */ 2389, 249, 779, 251, 2388, 2365, 2209, 254, 2127, 2123, - /* 2160 */ 2532, 631, 1432, 2570, 632, 2121, 635, 384, 2534, 782, - /* 2170 */ 2536, 2537, 777, 636, 800, 2119, 633, 2533, 637, 639, - /* 2180 */ 2551, 640, 641, 2116, 643, 645, 644, 2099, 2097, 2098, - /* 2190 */ 779, 260, 72, 1573, 1574, 2499, 2096, 778, 2533, 2075, - /* 2200 */ 2211, 2210, 1469, 1483, 1482, 1480, 1478, 1477, 2114, 1476, - /* 2210 */ 1475, 779, 861, 1474, 863, 1471, 424, 445, 2551, 1470, - /* 2220 */ 2112, 1468, 2103, 2101, 425, 426, 427, 677, 2074, 680, - /* 2230 */ 2073, 2072, 684, 2499, 2071, 778, 2070, 2532, 688, 2551, - /* 2240 */ 2570, 119, 686, 1726, 384, 2534, 782, 2536, 2537, 777, - /* 2250 */ 1728, 800, 1725, 1730, 2499, 2414, 778, 2410, 28, 2533, - /* 2260 */ 67, 282, 1702, 56, 1704, 2400, 707, 57, 708, 2387, - /* 2270 */ 2386, 2710, 779, 20, 17, 694, 723, 6, 2570, 7, - /* 2280 */ 432, 171, 379, 2534, 782, 2536, 2537, 777, 65, 800, - /* 2290 */ 286, 713, 30, 1706, 1681, 1680, 2532, 289, 2533, 2570, - /* 2300 */ 2551, 2000, 727, 369, 2534, 782, 2536, 2537, 777, 715, - /* 2310 */ 800, 779, 21, 22, 2533, 2499, 725, 778, 1974, 291, - /* 2320 */ 729, 192, 1981, 203, 2520, 180, 191, 779, 32, 24, - /* 2330 */ 2015, 31, 2533, 305, 1968, 2014, 437, 2019, 2018, 2551, - /* 2340 */ 81, 438, 59, 2020, 2385, 779, 2021, 2364, 103, 1939, - /* 2350 */ 25, 183, 23, 1938, 2499, 2551, 778, 2532, 102, 1891, - /* 2360 */ 2570, 1890, 13, 1809, 368, 2534, 782, 2536, 2537, 777, - /* 2370 */ 2499, 800, 778, 2551, 1901, 1866, 184, 11, 38, 194, - /* 2380 */ 1865, 1835, 2363, 58, 16, 26, 1843, 104, 2499, 27, - /* 2390 */ 778, 313, 781, 801, 1976, 18, 2532, 195, 319, 2570, - /* 2400 */ 324, 69, 2036, 370, 2534, 782, 2536, 2537, 777, 2035, - /* 2410 */ 800, 1868, 2532, 109, 105, 2570, 2034, 321, 2575, 376, - /* 2420 */ 2534, 782, 2536, 2537, 777, 2574, 800, 799, 68, 807, - /* 2430 */ 2532, 1559, 462, 2570, 2533, 787, 809, 380, 2534, 782, - /* 2440 */ 2536, 2537, 777, 1556, 800, 811, 812, 779, 1555, 814, - /* 2450 */ 2533, 1552, 2033, 815, 817, 818, 820, 1546, 1544, 821, - /* 2460 */ 823, 824, 1550, 779, 1549, 1548, 2533, 348, 110, 111, - /* 2470 */ 1547, 1564, 1568, 1430, 78, 2551, 1465, 838, 1462, 779, - /* 2480 */ 1461, 1460, 1459, 1457, 1455, 1454, 849, 1453, 1491, 1490, - /* 2490 */ 2499, 2551, 778, 210, 851, 1451, 1450, 1448, 1449, 1447, - /* 2500 */ 1446, 1445, 1487, 1485, 1442, 1441, 2499, 2551, 778, 1438, - /* 2510 */ 1437, 1436, 2122, 1435, 871, 2120, 872, 2118, 875, 879, - /* 2520 */ 873, 876, 2499, 2115, 778, 2533, 877, 881, 883, 885, - /* 2530 */ 880, 2095, 2532, 887, 884, 2570, 1374, 2069, 779, 371, - /* 2540 */ 2534, 782, 2536, 2537, 777, 893, 800, 1362, 2532, 891, - /* 2550 */ 352, 2570, 2533, 897, 1795, 381, 2534, 782, 2536, 2537, - /* 2560 */ 777, 363, 800, 2039, 2532, 779, 2551, 2570, 896, 2039, - /* 2570 */ 2039, 372, 2534, 782, 2536, 2537, 777, 2039, 800, 2039, - /* 2580 */ 2039, 2499, 2039, 778, 2039, 2039, 2039, 2039, 2039, 2039, - /* 2590 */ 2039, 2039, 2039, 2551, 2039, 2039, 2039, 2039, 2039, 2039, - /* 2600 */ 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2533, 2499, 2039, - /* 2610 */ 778, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, - /* 2620 */ 779, 2039, 2039, 2532, 2039, 2039, 2570, 2039, 2039, 2039, - /* 2630 */ 382, 2534, 782, 2536, 2537, 777, 2039, 800, 2039, 2039, - /* 2640 */ 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2551, 2039, - /* 2650 */ 2532, 2039, 2039, 2570, 2039, 2039, 2039, 373, 2534, 782, - /* 2660 */ 2536, 2537, 777, 2499, 800, 778, 2533, 2039, 2039, 2039, - /* 2670 */ 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 779, - /* 2680 */ 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2533, - /* 2690 */ 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, - /* 2700 */ 2039, 2039, 779, 2039, 2039, 2532, 2039, 2551, 2570, 2039, - /* 2710 */ 2039, 2039, 388, 2534, 782, 2536, 2537, 777, 2039, 800, - /* 2720 */ 2039, 2039, 2499, 2039, 778, 2039, 2039, 2533, 2039, 2039, - /* 2730 */ 2551, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, - /* 2740 */ 779, 2039, 2039, 2039, 2039, 2499, 2039, 778, 2039, 2039, - /* 2750 */ 2533, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, - /* 2760 */ 2039, 2039, 2039, 779, 2532, 2039, 2533, 2570, 2551, 2039, - /* 2770 */ 2039, 389, 2534, 782, 2536, 2537, 777, 2039, 800, 779, - /* 2780 */ 2039, 2039, 2039, 2499, 2039, 778, 2039, 2532, 2039, 2039, - /* 2790 */ 2570, 2551, 2039, 2039, 2545, 2534, 782, 2536, 2537, 777, - /* 2800 */ 2039, 800, 2039, 2039, 2039, 2039, 2499, 2551, 778, 2039, - /* 2810 */ 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, - /* 2820 */ 2039, 2039, 2499, 2039, 778, 2532, 2039, 2039, 2570, 2039, - /* 2830 */ 2039, 2039, 2544, 2534, 782, 2536, 2537, 777, 2039, 800, - /* 2840 */ 2039, 2533, 2039, 2039, 2039, 2039, 2039, 2039, 2532, 2039, - /* 2850 */ 2039, 2570, 2039, 2039, 779, 2543, 2534, 782, 2536, 2537, - /* 2860 */ 777, 2039, 800, 2039, 2532, 2039, 2039, 2570, 2533, 2039, - /* 2870 */ 2039, 406, 2534, 782, 2536, 2537, 777, 2039, 800, 2039, - /* 2880 */ 2039, 779, 2551, 2039, 2039, 2039, 2039, 2533, 2039, 2039, - /* 2890 */ 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2499, 2039, 778, - /* 2900 */ 779, 2039, 2039, 2533, 2039, 2039, 2039, 2039, 2039, 2551, - /* 2910 */ 2039, 2039, 2039, 2039, 2039, 2039, 779, 2039, 2039, 2039, - /* 2920 */ 2039, 2039, 2039, 2039, 2499, 2039, 778, 2039, 2551, 2039, - /* 2930 */ 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2532, - /* 2940 */ 2039, 2039, 2570, 2499, 2551, 778, 407, 2534, 782, 2536, - /* 2950 */ 2537, 777, 2039, 800, 2039, 2039, 2039, 2039, 2039, 2499, - /* 2960 */ 2039, 778, 2039, 2039, 2039, 2039, 2532, 2039, 2039, 2570, - /* 2970 */ 2039, 2039, 2039, 403, 2534, 782, 2536, 2537, 777, 2039, - /* 2980 */ 800, 2039, 2039, 2039, 2039, 2532, 2039, 2039, 2570, 2039, - /* 2990 */ 2039, 2039, 408, 2534, 782, 2536, 2537, 777, 2039, 800, - /* 3000 */ 2039, 780, 2039, 2039, 2570, 2039, 2039, 2039, 379, 2534, - /* 3010 */ 782, 2536, 2537, 777, 2039, 800, 2039, 2039, 2039, 2533, - /* 3020 */ 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, - /* 3030 */ 2039, 2039, 779, 2039, 2039, 2039, 2039, 2039, 2039, 2039, - /* 3040 */ 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, - /* 3050 */ 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, - /* 3060 */ 2551, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, - /* 3070 */ 2039, 2039, 2039, 2039, 2039, 2499, 2039, 778, 2039, 2039, - /* 3080 */ 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, - /* 3090 */ 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, - /* 3100 */ 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2039, - /* 3110 */ 2039, 2039, 2039, 2039, 2039, 2039, 2039, 2532, 2039, 2039, - /* 3120 */ 2570, 2039, 2039, 2039, 378, 2534, 782, 2536, 2537, 777, - /* 3130 */ 2039, 800, + /* 0 */ 448, 801, 2242, 2507, 509, 2231, 461, 171, 173, 508, + /* 10 */ 2524, 2229, 47, 45, 1964, 430, 463, 2244, 516, 2247, + /* 20 */ 444, 211, 1803, 40, 39, 1828, 2300, 46, 44, 43, + /* 30 */ 42, 41, 37, 312, 2726, 1890, 2137, 1801, 2528, 2548, + /* 40 */ 40, 39, 525, 2364, 46, 44, 43, 42, 41, 758, + /* 50 */ 149, 1831, 761, 609, 2455, 717, 610, 2094, 2721, 758, + /* 60 */ 149, 450, 1409, 858, 1408, 1885, 2202, 576, 574, 2049, + /* 70 */ 393, 19, 805, 767, 220, 2612, 2727, 206, 1809, 145, + /* 80 */ 2566, 2722, 747, 2530, 2533, 40, 39, 2388, 800, 46, + /* 90 */ 44, 43, 42, 41, 805, 222, 2514, 1410, 783, 46, + /* 100 */ 44, 43, 42, 41, 900, 2386, 788, 15, 614, 875, + /* 110 */ 874, 873, 872, 472, 611, 871, 870, 154, 865, 864, + /* 120 */ 863, 862, 861, 860, 859, 153, 853, 852, 851, 471, + /* 130 */ 470, 848, 847, 846, 186, 185, 845, 629, 2547, 2032, + /* 140 */ 2008, 2586, 700, 1892, 1893, 115, 2549, 787, 2551, 2552, + /* 150 */ 782, 2074, 805, 475, 2302, 2467, 241, 189, 474, 2640, + /* 160 */ 612, 2655, 2102, 440, 2636, 304, 2648, 757, 62, 141, + /* 170 */ 756, 2233, 2721, 765, 760, 204, 2648, 2649, 208, 147, + /* 180 */ 2653, 1863, 1873, 531, 2364, 1980, 2670, 2652, 1891, 1894, + /* 190 */ 745, 206, 177, 493, 2063, 2722, 747, 276, 1390, 469, + /* 200 */ 468, 275, 741, 1804, 717, 1802, 717, 2721, 2514, 2721, + /* 210 */ 2039, 66, 40, 39, 306, 2725, 46, 44, 43, 42, + /* 220 */ 41, 2548, 1388, 1389, 1810, 2727, 206, 2727, 206, 450, + /* 230 */ 2722, 747, 2722, 747, 784, 2655, 224, 1807, 1808, 1860, + /* 240 */ 805, 1862, 1865, 1866, 1867, 1868, 1869, 1870, 1871, 1872, + /* 250 */ 779, 803, 802, 1884, 1886, 1887, 1888, 1889, 2, 47, + /* 260 */ 45, 2651, 2566, 2051, 391, 1829, 1826, 444, 1832, 1803, + /* 270 */ 2468, 99, 187, 559, 402, 405, 579, 428, 2514, 691, + /* 280 */ 783, 578, 1890, 213, 1801, 2140, 1831, 139, 138, 137, + /* 290 */ 136, 135, 134, 133, 132, 131, 33, 539, 415, 580, + /* 300 */ 2368, 625, 40, 39, 392, 541, 46, 44, 43, 42, + /* 310 */ 41, 2508, 1885, 698, 62, 519, 2436, 2038, 19, 1919, + /* 320 */ 2547, 717, 497, 2586, 2721, 1809, 844, 115, 2549, 787, + /* 330 */ 2551, 2552, 782, 800, 805, 746, 308, 151, 2721, 158, + /* 340 */ 2611, 2640, 2727, 206, 740, 440, 2636, 2722, 747, 499, + /* 350 */ 495, 900, 416, 187, 15, 2388, 745, 206, 671, 670, + /* 360 */ 669, 2722, 747, 527, 1383, 661, 146, 665, 736, 450, + /* 370 */ 447, 664, 2566, 2385, 788, 278, 663, 668, 423, 422, + /* 380 */ 805, 2369, 662, 1390, 1920, 658, 62, 12, 1682, 1683, + /* 390 */ 1892, 1893, 1813, 2375, 2354, 1828, 567, 566, 565, 564, + /* 400 */ 563, 558, 557, 556, 555, 399, 1385, 1388, 1389, 545, + /* 410 */ 544, 543, 542, 536, 535, 534, 2052, 529, 528, 414, + /* 420 */ 50, 1860, 174, 520, 1650, 1651, 561, 2364, 1863, 1873, + /* 430 */ 1669, 463, 2244, 1681, 1684, 1891, 1894, 130, 51, 739, + /* 440 */ 129, 128, 127, 126, 125, 124, 123, 122, 121, 306, + /* 450 */ 1804, 800, 1802, 40, 39, 1809, 570, 46, 44, 43, + /* 460 */ 42, 41, 742, 737, 730, 726, 36, 442, 1914, 1915, + /* 470 */ 1916, 1917, 1918, 1922, 1923, 1924, 1925, 2073, 29, 229, + /* 480 */ 835, 507, 308, 506, 1807, 1808, 1860, 1833, 1862, 1865, + /* 490 */ 1866, 1867, 1868, 1869, 1870, 1871, 1872, 779, 803, 802, + /* 500 */ 1884, 1886, 1887, 1888, 1889, 2, 12, 47, 45, 749, + /* 510 */ 2548, 774, 1989, 505, 175, 444, 606, 1803, 231, 367, + /* 520 */ 1828, 699, 773, 761, 2458, 604, 2655, 1990, 600, 596, + /* 530 */ 1890, 1490, 1801, 226, 2514, 35, 365, 75, 50, 903, + /* 540 */ 74, 40, 39, 569, 230, 46, 44, 43, 42, 41, + /* 550 */ 394, 2566, 2650, 2009, 308, 353, 1662, 1663, 9, 696, + /* 560 */ 1885, 2321, 239, 591, 589, 586, 19, 2514, 1988, 783, + /* 570 */ 2072, 196, 1492, 1809, 91, 482, 2524, 90, 801, 2242, + /* 580 */ 891, 887, 883, 879, 130, 350, 1803, 129, 128, 127, + /* 590 */ 126, 125, 124, 123, 122, 121, 2296, 2297, 140, 900, + /* 600 */ 176, 1801, 15, 62, 2528, 652, 308, 62, 2180, 2547, + /* 610 */ 717, 617, 2586, 2721, 610, 2094, 115, 2549, 787, 2551, + /* 620 */ 2552, 782, 150, 805, 716, 2611, 114, 2514, 189, 323, + /* 630 */ 2640, 2727, 206, 2071, 440, 2636, 2722, 747, 1892, 1893, + /* 640 */ 2302, 63, 1809, 2337, 89, 671, 670, 669, 429, 2530, + /* 650 */ 2532, 441, 661, 146, 665, 3, 689, 2671, 664, 2300, + /* 660 */ 805, 797, 351, 663, 668, 423, 422, 53, 900, 662, + /* 670 */ 174, 687, 658, 685, 273, 272, 1863, 1873, 758, 149, + /* 680 */ 2245, 40, 39, 1891, 1894, 46, 44, 43, 42, 41, + /* 690 */ 2514, 85, 84, 512, 758, 149, 219, 2218, 1804, 2302, + /* 700 */ 1802, 811, 810, 809, 808, 311, 308, 439, 2217, 504, + /* 710 */ 502, 465, 310, 243, 2295, 2297, 2347, 612, 2300, 2102, + /* 720 */ 390, 554, 553, 491, 14, 13, 488, 484, 480, 477, + /* 730 */ 505, 281, 1807, 1808, 1860, 456, 1862, 1865, 1866, 1867, + /* 740 */ 1868, 1869, 1870, 1871, 1872, 779, 803, 802, 1884, 1886, + /* 750 */ 1887, 1888, 1889, 2, 47, 45, 1895, 60, 523, 2548, + /* 760 */ 801, 2242, 444, 626, 1803, 714, 113, 1804, 199, 1802, + /* 770 */ 200, 308, 784, 701, 2104, 308, 459, 1890, 844, 1801, + /* 780 */ 55, 40, 39, 152, 2289, 46, 44, 43, 42, 41, + /* 790 */ 1953, 2548, 2234, 1832, 205, 2648, 2649, 1829, 147, 2653, + /* 800 */ 2566, 1807, 1808, 702, 784, 552, 2678, 1885, 173, 551, + /* 810 */ 207, 2648, 2649, 855, 147, 2653, 2514, 550, 783, 2248, + /* 820 */ 1809, 40, 39, 627, 2381, 46, 44, 43, 42, 41, + /* 830 */ 2548, 1933, 2566, 842, 165, 164, 839, 838, 837, 162, + /* 840 */ 12, 762, 10, 784, 1961, 2691, 900, 701, 2514, 48, + /* 850 */ 783, 772, 619, 2427, 717, 2302, 118, 2721, 2547, 836, + /* 860 */ 2070, 2586, 2293, 413, 1828, 115, 2549, 787, 2551, 2552, + /* 870 */ 782, 2566, 805, 1828, 2300, 2727, 206, 2741, 857, 2640, + /* 880 */ 2722, 747, 1968, 440, 2636, 1892, 1893, 2514, 1828, 783, + /* 890 */ 2547, 2216, 717, 2586, 2224, 2721, 2069, 115, 2549, 787, + /* 900 */ 2551, 2552, 782, 1772, 805, 2226, 395, 1997, 96, 2741, + /* 910 */ 2246, 2640, 2068, 2727, 206, 440, 2636, 2514, 2722, 747, + /* 920 */ 1590, 1591, 1392, 1863, 1873, 417, 703, 2427, 1827, 2547, + /* 930 */ 1891, 1894, 2586, 455, 454, 2237, 115, 2549, 787, 2551, + /* 940 */ 2552, 782, 284, 805, 1771, 1804, 746, 1802, 2741, 2721, + /* 950 */ 2640, 801, 2242, 2514, 440, 2636, 202, 733, 732, 1995, + /* 960 */ 1996, 1998, 1999, 2000, 2548, 316, 317, 745, 206, 2514, + /* 970 */ 315, 513, 2722, 747, 458, 457, 1900, 784, 107, 1807, + /* 980 */ 1808, 1860, 1828, 1862, 1865, 1866, 1867, 1868, 1869, 1870, + /* 990 */ 1871, 1872, 779, 803, 802, 1884, 1886, 1887, 1888, 1889, + /* 1000 */ 2, 47, 45, 2548, 2235, 2566, 1412, 1413, 1409, 444, + /* 1010 */ 1408, 1803, 1833, 96, 801, 2242, 784, 1911, 728, 801, + /* 1020 */ 2242, 2514, 1502, 783, 1890, 1864, 1801, 842, 165, 164, + /* 1030 */ 839, 838, 837, 162, 279, 801, 2242, 1501, 2548, 140, + /* 1040 */ 2238, 1832, 2726, 1410, 2566, 2721, 657, 1921, 769, 1864, + /* 1050 */ 2612, 784, 360, 2714, 1885, 514, 801, 2242, 801, 2242, + /* 1060 */ 2514, 2067, 783, 2547, 2725, 2066, 2586, 1809, 2722, 2724, + /* 1070 */ 115, 2549, 787, 2551, 2552, 782, 533, 805, 546, 2566, + /* 1080 */ 801, 2242, 2615, 1861, 2640, 277, 801, 2242, 440, 2636, + /* 1090 */ 656, 1832, 1861, 900, 655, 2514, 48, 783, 2726, 112, + /* 1100 */ 547, 2721, 2547, 2181, 581, 2586, 548, 1861, 109, 115, + /* 1110 */ 2549, 787, 2551, 2552, 782, 2065, 805, 1960, 2514, 678, + /* 1120 */ 2725, 2741, 2514, 2640, 2722, 2723, 2064, 440, 2636, 34, + /* 1130 */ 648, 647, 1892, 1893, 690, 801, 2242, 2547, 2302, 1926, + /* 1140 */ 2586, 801, 2242, 1864, 115, 2549, 787, 2551, 2552, 782, + /* 1150 */ 274, 805, 43, 42, 41, 628, 2741, 796, 2640, 801, + /* 1160 */ 2242, 2239, 440, 2636, 1731, 1732, 681, 77, 801, 2242, + /* 1170 */ 1863, 1873, 2514, 675, 673, 801, 2242, 1891, 1894, 287, + /* 1180 */ 271, 842, 165, 164, 839, 838, 837, 162, 764, 801, + /* 1190 */ 2242, 750, 1804, 2062, 1802, 320, 801, 2242, 2302, 801, + /* 1200 */ 2242, 1861, 840, 2302, 197, 2293, 449, 2061, 2060, 798, + /* 1210 */ 2548, 464, 650, 649, 2684, 2059, 799, 2300, 301, 347, + /* 1220 */ 88, 71, 2300, 784, 70, 2659, 1807, 1808, 1860, 734, + /* 1230 */ 1862, 1865, 1866, 1867, 1868, 1869, 1870, 1871, 1872, 779, + /* 1240 */ 803, 802, 1884, 1886, 1887, 1888, 1889, 2, 47, 45, + /* 1250 */ 2514, 2566, 667, 666, 201, 1506, 444, 693, 1803, 692, + /* 1260 */ 1833, 1551, 869, 867, 2514, 2514, 466, 2514, 2058, 783, + /* 1270 */ 1505, 1890, 2514, 1801, 173, 1542, 834, 833, 832, 1546, + /* 1280 */ 831, 1548, 1549, 830, 827, 2247, 1557, 824, 1559, 1560, + /* 1290 */ 821, 818, 815, 801, 2242, 2057, 2056, 753, 2055, 841, + /* 1300 */ 2054, 1885, 2293, 2302, 361, 2079, 895, 2279, 100, 2547, + /* 1310 */ 1833, 2219, 2586, 467, 1809, 163, 115, 2549, 787, 2551, + /* 1320 */ 2552, 782, 2301, 805, 142, 2514, 264, 659, 2741, 262, + /* 1330 */ 2640, 469, 468, 163, 440, 2636, 87, 583, 163, 1710, + /* 1340 */ 900, 1817, 295, 15, 155, 2548, 1551, 2660, 1953, 2041, + /* 1350 */ 2042, 1487, 2514, 2514, 1890, 2514, 1810, 2514, 784, 660, + /* 1360 */ 1542, 834, 833, 832, 1546, 831, 1548, 1549, 778, 777, + /* 1370 */ 2124, 1557, 776, 1559, 1560, 775, 818, 815, 266, 1892, + /* 1380 */ 1893, 265, 268, 1485, 1885, 267, 2566, 288, 270, 2122, + /* 1390 */ 54, 269, 672, 2113, 2111, 849, 724, 1809, 2567, 14, + /* 1400 */ 13, 49, 2514, 2535, 783, 850, 144, 2178, 1726, 1812, + /* 1410 */ 1811, 674, 2177, 1729, 2373, 676, 679, 1863, 1873, 1464, + /* 1420 */ 2105, 326, 325, 771, 1891, 1894, 421, 420, 49, 1462, + /* 1430 */ 190, 101, 2095, 2674, 64, 163, 49, 49, 314, 1804, + /* 1440 */ 731, 1802, 435, 738, 2547, 76, 431, 2586, 328, 327, + /* 1450 */ 473, 115, 2549, 787, 2551, 2552, 782, 751, 805, 160, + /* 1460 */ 163, 2537, 73, 2613, 813, 2640, 330, 329, 790, 440, + /* 1470 */ 2636, 1984, 893, 1807, 1808, 1860, 1994, 1862, 1865, 1866, + /* 1480 */ 1867, 1868, 1869, 1870, 1871, 1872, 779, 803, 802, 1884, + /* 1490 */ 1886, 1887, 1888, 1889, 2, 2548, 397, 396, 419, 418, + /* 1500 */ 2374, 654, 2101, 1993, 161, 293, 451, 2290, 784, 1927, + /* 1510 */ 763, 1874, 1679, 318, 332, 331, 710, 259, 163, 1890, + /* 1520 */ 793, 460, 1818, 656, 1813, 2548, 2675, 655, 334, 333, + /* 1530 */ 336, 335, 143, 182, 322, 1533, 2566, 359, 784, 1564, + /* 1540 */ 338, 337, 646, 642, 638, 634, 160, 258, 1445, 1885, + /* 1550 */ 2685, 759, 2514, 303, 783, 300, 1821, 1823, 340, 339, + /* 1560 */ 342, 341, 344, 343, 307, 754, 2566, 346, 345, 2203, + /* 1570 */ 803, 802, 1884, 1886, 1887, 1888, 1889, 1815, 1814, 1572, + /* 1580 */ 5, 481, 2514, 476, 783, 411, 489, 490, 97, 1446, + /* 1590 */ 1836, 256, 500, 1579, 2547, 501, 214, 2586, 2548, 215, + /* 1600 */ 503, 115, 2549, 787, 2551, 2552, 782, 1577, 805, 217, + /* 1610 */ 354, 784, 1703, 768, 1826, 2640, 517, 1827, 524, 440, + /* 1620 */ 2636, 166, 228, 526, 2547, 530, 532, 2586, 572, 537, + /* 1630 */ 549, 116, 2549, 787, 2551, 2552, 782, 560, 805, 2566, + /* 1640 */ 2366, 562, 568, 571, 573, 2640, 584, 585, 582, 2639, + /* 1650 */ 2636, 233, 234, 2548, 587, 2514, 236, 783, 246, 588, + /* 1660 */ 590, 592, 1834, 607, 4, 608, 784, 255, 248, 615, + /* 1670 */ 1829, 616, 244, 620, 253, 623, 618, 1835, 93, 621, + /* 1680 */ 247, 1837, 622, 624, 1838, 2548, 2382, 1794, 250, 1770, + /* 1690 */ 630, 252, 94, 245, 2566, 95, 651, 2547, 781, 682, + /* 1700 */ 2586, 653, 257, 683, 116, 2549, 787, 2551, 2552, 782, + /* 1710 */ 2514, 805, 783, 119, 2232, 387, 695, 261, 2640, 453, + /* 1720 */ 452, 1795, 770, 2636, 98, 2228, 2566, 263, 168, 117, + /* 1730 */ 2230, 2225, 697, 169, 170, 803, 802, 1884, 1886, 1887, + /* 1740 */ 1888, 1889, 2514, 1830, 783, 156, 280, 355, 705, 285, + /* 1750 */ 704, 2445, 785, 712, 2442, 2586, 2441, 709, 706, 116, + /* 1760 */ 2549, 787, 2551, 2552, 782, 721, 805, 735, 283, 2428, + /* 1770 */ 290, 791, 8, 2640, 2690, 2689, 2662, 404, 2636, 292, + /* 1780 */ 744, 181, 294, 722, 2547, 711, 720, 2586, 296, 719, + /* 1790 */ 755, 383, 2549, 787, 2551, 2552, 782, 780, 805, 766, + /* 1800 */ 2605, 2548, 299, 436, 2744, 752, 1953, 148, 1831, 1958, + /* 1810 */ 1956, 61, 2720, 193, 784, 309, 2548, 2656, 789, 157, + /* 1820 */ 356, 357, 794, 297, 2396, 2395, 2394, 159, 446, 784, + /* 1830 */ 358, 2548, 2621, 106, 2243, 2506, 2505, 2501, 108, 2500, + /* 1840 */ 1, 2492, 2566, 2491, 784, 298, 795, 209, 2483, 807, + /* 1850 */ 362, 1367, 2482, 349, 894, 2498, 897, 2566, 2514, 2497, + /* 1860 */ 783, 2489, 302, 2488, 2477, 167, 2466, 2476, 2495, 2494, + /* 1870 */ 2486, 899, 2566, 2514, 2485, 783, 2474, 2473, 398, 2471, + /* 1880 */ 2470, 2294, 364, 386, 374, 385, 366, 2465, 2514, 2464, + /* 1890 */ 783, 375, 82, 2459, 409, 478, 479, 1754, 1755, 212, + /* 1900 */ 2547, 410, 483, 2586, 2457, 485, 486, 178, 2549, 787, + /* 1910 */ 2551, 2552, 782, 52, 805, 2547, 487, 1753, 2586, 2456, + /* 1920 */ 2454, 412, 179, 2549, 787, 2551, 2552, 782, 492, 805, + /* 1930 */ 2547, 2453, 2548, 2586, 494, 2452, 496, 116, 2549, 787, + /* 1940 */ 2551, 2552, 782, 2451, 805, 784, 498, 1742, 2432, 718, + /* 1950 */ 2681, 2640, 2431, 216, 218, 1706, 2637, 83, 1705, 2409, + /* 1960 */ 2408, 2407, 510, 511, 2406, 2548, 2405, 2356, 2353, 518, + /* 1970 */ 515, 1649, 2352, 2566, 2346, 521, 748, 2742, 784, 522, + /* 1980 */ 2343, 2342, 221, 2341, 86, 2340, 2345, 2344, 2339, 2514, + /* 1990 */ 223, 783, 2338, 2336, 2335, 2334, 225, 2333, 540, 538, + /* 2000 */ 2331, 2330, 2329, 2328, 2351, 2327, 2566, 2326, 2325, 2349, + /* 2010 */ 2332, 2324, 2323, 2322, 2320, 2319, 2318, 2317, 2316, 2315, + /* 2020 */ 227, 2314, 2514, 92, 783, 2313, 2312, 2311, 2310, 2350, + /* 2030 */ 2348, 2547, 2309, 2308, 2586, 2307, 232, 2306, 178, 2549, + /* 2040 */ 787, 2551, 2552, 782, 433, 805, 1655, 2548, 575, 2305, + /* 2050 */ 2304, 577, 2303, 1503, 2143, 235, 400, 2142, 1507, 1499, + /* 2060 */ 784, 237, 2141, 238, 2547, 2139, 2548, 2586, 2136, 2135, + /* 2070 */ 401, 384, 2549, 787, 2551, 2552, 782, 593, 805, 784, + /* 2080 */ 595, 2682, 597, 2548, 599, 594, 2128, 2115, 2566, 603, + /* 2090 */ 601, 2090, 598, 605, 602, 2534, 784, 188, 1391, 2089, + /* 2100 */ 240, 79, 2548, 2430, 2514, 2426, 783, 2566, 80, 198, + /* 2110 */ 242, 2416, 613, 2404, 249, 781, 1438, 251, 2403, 254, + /* 2120 */ 2380, 2548, 2220, 2514, 2566, 783, 434, 2138, 2134, 631, + /* 2130 */ 632, 633, 2132, 635, 784, 637, 636, 2130, 639, 640, + /* 2140 */ 2514, 2127, 783, 2566, 641, 643, 2547, 2110, 644, 2586, + /* 2150 */ 2108, 645, 2109, 384, 2549, 787, 2551, 2552, 782, 2514, + /* 2160 */ 805, 783, 2566, 2107, 2086, 2547, 2222, 1584, 2586, 2221, + /* 2170 */ 1583, 260, 377, 2549, 787, 2551, 2552, 782, 2514, 805, + /* 2180 */ 783, 1489, 2547, 1488, 677, 2586, 72, 866, 1486, 179, + /* 2190 */ 2549, 787, 2551, 2552, 782, 1484, 805, 1483, 1482, 1481, + /* 2200 */ 443, 2547, 1480, 868, 2586, 1477, 2548, 427, 383, 2549, + /* 2210 */ 787, 2551, 2552, 782, 1476, 805, 1475, 2606, 743, 784, + /* 2220 */ 2547, 1474, 2125, 2586, 424, 2123, 425, 384, 2549, 787, + /* 2230 */ 2551, 2552, 782, 2114, 805, 2548, 426, 2112, 680, 2085, + /* 2240 */ 2084, 2083, 684, 2082, 2743, 686, 2081, 2566, 784, 688, + /* 2250 */ 120, 2429, 1736, 1738, 1735, 282, 56, 1740, 1716, 2425, + /* 2260 */ 28, 57, 67, 2514, 1714, 783, 1712, 2415, 286, 2548, + /* 2270 */ 707, 2402, 2401, 708, 30, 723, 2566, 1691, 1690, 17, + /* 2280 */ 172, 2726, 784, 20, 432, 445, 2011, 289, 713, 1985, + /* 2290 */ 715, 729, 2514, 725, 783, 6, 727, 291, 21, 7, + /* 2300 */ 1992, 22, 180, 191, 31, 2547, 1979, 192, 2586, 203, + /* 2310 */ 2566, 2535, 384, 2549, 787, 2551, 2552, 782, 81, 805, + /* 2320 */ 32, 2031, 65, 24, 305, 2026, 2514, 2032, 783, 2025, + /* 2330 */ 437, 23, 1950, 2030, 694, 2029, 438, 2586, 59, 2400, + /* 2340 */ 2548, 379, 2549, 787, 2551, 2552, 782, 2379, 805, 58, + /* 2350 */ 183, 103, 1949, 784, 25, 18, 13, 1819, 1902, 102, + /* 2360 */ 1901, 1912, 1877, 820, 11, 1876, 1875, 184, 2547, 194, + /* 2370 */ 823, 2586, 1845, 826, 1853, 369, 2549, 787, 2551, 2552, + /* 2380 */ 782, 2566, 805, 829, 38, 786, 16, 26, 27, 2378, + /* 2390 */ 313, 1987, 195, 319, 324, 104, 792, 2514, 69, 783, + /* 2400 */ 2548, 105, 2047, 321, 2591, 109, 2046, 2590, 2045, 812, + /* 2410 */ 1879, 804, 462, 784, 68, 2044, 1565, 814, 816, 1562, + /* 2420 */ 806, 817, 2548, 1561, 819, 1558, 348, 822, 825, 828, + /* 2430 */ 1552, 1550, 110, 111, 1556, 784, 1578, 78, 1574, 2547, + /* 2440 */ 1555, 2566, 2586, 1436, 1554, 843, 368, 2549, 787, 2551, + /* 2450 */ 2552, 782, 1553, 805, 1471, 1468, 1467, 2514, 1466, 783, + /* 2460 */ 1465, 1463, 1461, 2566, 1460, 1459, 1497, 854, 856, 210, + /* 2470 */ 1457, 1456, 1496, 1454, 1455, 1453, 1452, 2548, 1451, 2514, + /* 2480 */ 1493, 783, 1491, 1448, 1447, 1444, 1443, 1442, 2133, 1441, + /* 2490 */ 784, 876, 878, 877, 2131, 880, 2129, 882, 886, 2547, + /* 2500 */ 884, 2126, 2586, 888, 2548, 2106, 370, 2549, 787, 2551, + /* 2510 */ 2552, 782, 881, 805, 890, 885, 892, 784, 2566, 889, + /* 2520 */ 1380, 2547, 1368, 896, 2586, 2080, 352, 898, 376, 2549, + /* 2530 */ 787, 2551, 2552, 782, 2514, 805, 783, 2548, 1805, 363, + /* 2540 */ 901, 902, 2050, 2050, 2050, 2566, 2050, 2050, 2050, 2050, + /* 2550 */ 784, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, + /* 2560 */ 2050, 2514, 2050, 783, 2050, 2050, 2050, 2050, 2548, 2050, + /* 2570 */ 2050, 2050, 2050, 2050, 2050, 2050, 2547, 2050, 2566, 2586, + /* 2580 */ 2050, 784, 2050, 380, 2549, 787, 2551, 2552, 782, 2050, + /* 2590 */ 805, 2050, 2548, 2050, 2514, 2050, 783, 2050, 2050, 2050, + /* 2600 */ 2050, 2050, 2050, 2547, 2050, 784, 2586, 2050, 2050, 2566, + /* 2610 */ 371, 2549, 787, 2551, 2552, 782, 2050, 805, 2050, 2050, + /* 2620 */ 2050, 2050, 2050, 2050, 2050, 2514, 2050, 783, 2050, 2050, + /* 2630 */ 2050, 2050, 2050, 2566, 2050, 2050, 2547, 2050, 2050, 2586, + /* 2640 */ 2050, 2050, 2050, 381, 2549, 787, 2551, 2552, 782, 2514, + /* 2650 */ 805, 783, 2050, 2050, 2050, 2050, 2548, 2050, 2050, 2050, + /* 2660 */ 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2547, 2050, 784, + /* 2670 */ 2586, 2050, 2050, 2050, 372, 2549, 787, 2551, 2552, 782, + /* 2680 */ 2050, 805, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, + /* 2690 */ 2050, 2547, 2050, 2050, 2586, 2050, 2050, 2566, 382, 2549, + /* 2700 */ 787, 2551, 2552, 782, 2050, 805, 2050, 2050, 2050, 2050, + /* 2710 */ 2050, 2050, 2050, 2514, 2050, 783, 2050, 2050, 2050, 2050, + /* 2720 */ 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, + /* 2730 */ 2548, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, + /* 2740 */ 2050, 2050, 2050, 784, 2050, 2050, 2050, 2050, 2050, 2050, + /* 2750 */ 2050, 2050, 2050, 2050, 2050, 2547, 2050, 2050, 2586, 2548, + /* 2760 */ 2050, 2050, 373, 2549, 787, 2551, 2552, 782, 2050, 805, + /* 2770 */ 2050, 2566, 784, 2050, 2050, 2050, 2050, 2050, 2050, 2050, + /* 2780 */ 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2514, 2050, 783, + /* 2790 */ 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, + /* 2800 */ 2566, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, + /* 2810 */ 2050, 2050, 2050, 2050, 2050, 2050, 2514, 2050, 783, 2050, + /* 2820 */ 2050, 2548, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2547, + /* 2830 */ 2050, 2050, 2586, 2050, 784, 2050, 388, 2549, 787, 2551, + /* 2840 */ 2552, 782, 2050, 805, 2050, 2050, 2050, 2050, 2050, 2050, + /* 2850 */ 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2547, 2050, + /* 2860 */ 2050, 2586, 2566, 2050, 2050, 389, 2549, 787, 2551, 2552, + /* 2870 */ 782, 2050, 805, 2050, 2050, 2050, 2050, 2050, 2514, 2050, + /* 2880 */ 783, 2050, 2050, 2548, 2050, 2050, 2050, 2050, 2050, 2050, + /* 2890 */ 2050, 2050, 2050, 2050, 2050, 2050, 784, 2050, 2548, 2050, + /* 2900 */ 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, + /* 2910 */ 2050, 784, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, + /* 2920 */ 2547, 2050, 2050, 2586, 2566, 2050, 2050, 2560, 2549, 787, + /* 2930 */ 2551, 2552, 782, 2050, 805, 2050, 2050, 2050, 2050, 2566, + /* 2940 */ 2514, 2050, 783, 2050, 2050, 2050, 2050, 2050, 2050, 2050, + /* 2950 */ 2050, 2050, 2050, 2050, 2050, 2514, 2050, 783, 2548, 2050, + /* 2960 */ 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, + /* 2970 */ 2050, 784, 2050, 2548, 2050, 2050, 2050, 2050, 2050, 2050, + /* 2980 */ 2050, 2050, 2547, 2050, 2050, 2586, 784, 2050, 2050, 2559, + /* 2990 */ 2549, 787, 2551, 2552, 782, 2050, 805, 2547, 2050, 2566, + /* 3000 */ 2586, 2050, 2050, 2050, 2558, 2549, 787, 2551, 2552, 782, + /* 3010 */ 2050, 805, 2050, 2050, 2566, 2514, 2050, 783, 2050, 2050, + /* 3020 */ 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, + /* 3030 */ 2514, 2050, 783, 2050, 2050, 2050, 2548, 2050, 2050, 2050, + /* 3040 */ 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 784, + /* 3050 */ 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2547, 2050, 2050, + /* 3060 */ 2586, 2548, 2050, 2050, 406, 2549, 787, 2551, 2552, 782, + /* 3070 */ 2050, 805, 2547, 2050, 784, 2586, 2050, 2566, 2050, 407, + /* 3080 */ 2549, 787, 2551, 2552, 782, 2050, 805, 2050, 2050, 2050, + /* 3090 */ 2050, 2050, 2050, 2514, 2050, 783, 2050, 2050, 2050, 2050, + /* 3100 */ 2050, 2050, 2566, 2050, 2050, 2050, 2050, 2050, 2050, 2050, + /* 3110 */ 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2514, 2050, + /* 3120 */ 783, 2548, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, + /* 3130 */ 2050, 2050, 2050, 2050, 784, 2547, 2050, 2050, 2586, 2050, + /* 3140 */ 2050, 2050, 403, 2549, 787, 2551, 2552, 782, 2050, 805, + /* 3150 */ 2050, 2548, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, + /* 3160 */ 2547, 2050, 2566, 2586, 784, 2050, 2050, 408, 2549, 787, + /* 3170 */ 2551, 2552, 782, 2050, 805, 2050, 2050, 2050, 2514, 2050, + /* 3180 */ 783, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, + /* 3190 */ 2050, 2050, 2566, 2050, 2050, 2050, 2050, 2050, 2050, 2050, + /* 3200 */ 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2514, 2050, + /* 3210 */ 783, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, + /* 3220 */ 785, 2050, 2050, 2586, 2050, 2050, 2050, 379, 2549, 787, + /* 3230 */ 2551, 2552, 782, 2050, 805, 2050, 2050, 2050, 2050, 2050, + /* 3240 */ 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, 2050, + /* 3250 */ 2547, 2050, 2050, 2586, 2050, 2050, 2050, 378, 2549, 787, + /* 3260 */ 2551, 2552, 782, 2050, 805, }; static const YYCODETYPE yy_lookahead[] = { - /* 0 */ 368, 402, 415, 371, 372, 418, 419, 373, 402, 410, - /* 10 */ 441, 402, 12, 13, 14, 446, 410, 411, 412, 420, - /* 20 */ 20, 412, 22, 8, 9, 20, 420, 12, 13, 14, - /* 30 */ 15, 16, 2, 481, 482, 35, 0, 37, 8, 9, - /* 40 */ 361, 20, 12, 13, 14, 15, 16, 373, 374, 4, - /* 50 */ 373, 374, 20, 374, 401, 421, 422, 0, 424, 373, - /* 60 */ 374, 492, 428, 492, 495, 65, 495, 393, 23, 416, - /* 70 */ 358, 71, 37, 492, 400, 360, 495, 362, 78, 393, - /* 80 */ 20, 402, 513, 514, 513, 514, 400, 518, 519, 518, - /* 90 */ 519, 46, 47, 48, 405, 514, 417, 408, 419, 518, - /* 100 */ 519, 39, 40, 405, 104, 403, 404, 107, 51, 73, + /* 0 */ 394, 373, 374, 405, 442, 403, 408, 402, 402, 447, + /* 10 */ 390, 403, 12, 13, 14, 410, 411, 412, 373, 413, + /* 20 */ 20, 393, 22, 8, 9, 20, 421, 12, 13, 14, + /* 30 */ 15, 16, 482, 483, 3, 35, 0, 37, 418, 361, + /* 40 */ 8, 9, 373, 374, 12, 13, 14, 15, 16, 373, + /* 50 */ 374, 20, 374, 368, 0, 493, 371, 372, 496, 373, + /* 60 */ 374, 463, 20, 389, 22, 65, 392, 422, 423, 358, + /* 70 */ 425, 71, 474, 478, 429, 480, 514, 515, 78, 37, + /* 80 */ 402, 519, 520, 463, 464, 8, 9, 420, 20, 12, + /* 90 */ 13, 14, 15, 16, 474, 426, 418, 55, 420, 12, + /* 100 */ 13, 14, 15, 16, 104, 438, 439, 107, 14, 73, /* 110 */ 74, 75, 76, 77, 20, 79, 80, 81, 82, 83, /* 120 */ 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - /* 130 */ 94, 95, 96, 97, 98, 99, 100, 419, 459, 107, - /* 140 */ 477, 462, 479, 143, 144, 466, 467, 468, 469, 470, - /* 150 */ 471, 462, 473, 441, 107, 437, 438, 478, 446, 480, - /* 160 */ 462, 465, 473, 484, 485, 488, 489, 490, 4, 492, - /* 170 */ 493, 473, 495, 111, 112, 402, 114, 389, 499, 69, - /* 180 */ 392, 181, 182, 410, 373, 374, 507, 491, 188, 189, - /* 190 */ 513, 514, 394, 420, 20, 518, 519, 20, 136, 22, - /* 200 */ 402, 107, 140, 203, 492, 205, 22, 495, 70, 419, - /* 210 */ 195, 413, 8, 9, 37, 405, 12, 13, 14, 15, - /* 220 */ 16, 37, 361, 441, 434, 513, 514, 437, 438, 138, - /* 230 */ 518, 519, 55, 142, 137, 374, 425, 237, 238, 239, - /* 240 */ 205, 241, 242, 243, 244, 245, 246, 247, 248, 249, + /* 130 */ 94, 95, 96, 97, 98, 99, 100, 70, 460, 108, + /* 140 */ 108, 463, 20, 143, 144, 467, 468, 469, 470, 471, + /* 150 */ 472, 361, 474, 442, 402, 442, 369, 479, 447, 481, + /* 160 */ 373, 466, 375, 485, 486, 489, 490, 491, 107, 493, + /* 170 */ 494, 405, 496, 421, 488, 489, 490, 491, 500, 493, + /* 180 */ 494, 181, 182, 373, 374, 108, 508, 492, 188, 189, + /* 190 */ 514, 515, 360, 69, 362, 519, 520, 138, 23, 12, + /* 200 */ 13, 142, 20, 203, 493, 205, 493, 496, 418, 496, + /* 210 */ 195, 4, 8, 9, 183, 3, 12, 13, 14, 15, + /* 220 */ 16, 361, 47, 48, 37, 514, 515, 514, 515, 463, + /* 230 */ 519, 520, 519, 520, 374, 466, 426, 237, 238, 239, + /* 240 */ 474, 241, 242, 243, 244, 245, 246, 247, 248, 249, /* 250 */ 250, 251, 252, 253, 254, 255, 256, 257, 258, 12, - /* 260 */ 13, 70, 78, 402, 18, 492, 20, 20, 495, 22, - /* 270 */ 441, 107, 462, 27, 492, 71, 30, 495, 417, 13, - /* 280 */ 419, 35, 35, 473, 37, 0, 513, 514, 104, 390, - /* 290 */ 368, 518, 519, 371, 372, 513, 514, 51, 374, 53, - /* 300 */ 518, 519, 20, 212, 58, 59, 215, 275, 198, 218, - /* 310 */ 20, 220, 65, 216, 217, 69, 417, 302, 71, 115, - /* 320 */ 459, 492, 275, 462, 495, 78, 402, 466, 467, 468, - /* 330 */ 469, 470, 471, 3, 473, 225, 226, 476, 21, 478, - /* 340 */ 479, 480, 513, 514, 78, 484, 485, 518, 519, 20, - /* 350 */ 20, 104, 106, 36, 107, 38, 39, 40, 73, 74, - /* 360 */ 75, 462, 463, 117, 369, 80, 81, 82, 373, 275, - /* 370 */ 375, 86, 473, 117, 373, 374, 91, 92, 93, 94, - /* 380 */ 1, 2, 97, 0, 180, 100, 477, 203, 479, 205, - /* 390 */ 143, 144, 468, 147, 148, 402, 150, 151, 152, 153, - /* 400 */ 154, 155, 156, 157, 158, 159, 413, 12, 13, 163, + /* 260 */ 13, 492, 402, 0, 18, 20, 20, 20, 20, 22, + /* 270 */ 442, 212, 402, 27, 215, 71, 30, 218, 418, 220, + /* 280 */ 420, 35, 35, 229, 37, 0, 20, 24, 25, 26, + /* 290 */ 27, 28, 29, 30, 31, 32, 2, 51, 428, 53, + /* 300 */ 430, 20, 8, 9, 58, 59, 12, 13, 14, 15, + /* 310 */ 16, 405, 65, 117, 107, 69, 398, 302, 71, 115, + /* 320 */ 460, 493, 198, 463, 496, 78, 70, 467, 468, 469, + /* 330 */ 470, 471, 472, 20, 474, 493, 275, 477, 496, 479, + /* 340 */ 480, 481, 514, 515, 374, 485, 486, 519, 520, 225, + /* 350 */ 226, 104, 106, 402, 107, 420, 514, 515, 73, 74, + /* 360 */ 75, 519, 520, 117, 4, 80, 81, 82, 187, 463, + /* 370 */ 435, 86, 402, 438, 439, 457, 91, 92, 93, 94, + /* 380 */ 474, 430, 97, 23, 180, 100, 107, 259, 143, 144, + /* 390 */ 143, 144, 205, 147, 148, 20, 150, 151, 152, 153, + /* 400 */ 154, 155, 156, 157, 158, 159, 46, 47, 48, 163, /* 410 */ 164, 165, 166, 167, 168, 169, 0, 171, 172, 173, - /* 420 */ 3, 237, 238, 177, 178, 179, 425, 237, 181, 182, - /* 430 */ 184, 187, 37, 143, 144, 188, 189, 21, 108, 275, - /* 440 */ 24, 25, 26, 27, 28, 29, 30, 31, 32, 78, - /* 450 */ 203, 21, 205, 70, 24, 25, 26, 27, 28, 29, - /* 460 */ 30, 31, 32, 181, 182, 373, 262, 263, 264, 265, - /* 470 */ 266, 267, 268, 269, 270, 271, 272, 287, 288, 289, - /* 480 */ 290, 291, 292, 293, 237, 238, 239, 108, 241, 242, + /* 420 */ 107, 239, 402, 177, 178, 179, 373, 374, 181, 182, + /* 430 */ 184, 411, 412, 188, 189, 188, 189, 21, 107, 469, + /* 440 */ 24, 25, 26, 27, 28, 29, 30, 31, 32, 183, + /* 450 */ 203, 20, 205, 8, 9, 78, 87, 12, 13, 14, + /* 460 */ 15, 16, 281, 282, 283, 284, 262, 263, 264, 265, + /* 470 */ 266, 267, 268, 269, 270, 271, 272, 361, 33, 426, + /* 480 */ 117, 202, 275, 204, 237, 238, 239, 239, 241, 242, /* 490 */ 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - /* 500 */ 253, 254, 255, 256, 257, 258, 259, 12, 13, 373, - /* 510 */ 374, 361, 183, 183, 18, 20, 369, 22, 259, 23, - /* 520 */ 373, 1, 375, 117, 374, 281, 282, 283, 284, 402, - /* 530 */ 35, 492, 37, 398, 495, 2, 40, 41, 34, 19, - /* 540 */ 44, 8, 9, 451, 452, 12, 13, 14, 15, 16, - /* 550 */ 54, 0, 402, 514, 427, 35, 429, 518, 519, 441, - /* 560 */ 65, 425, 66, 67, 68, 69, 71, 417, 239, 419, - /* 570 */ 0, 51, 20, 78, 22, 12, 13, 14, 15, 16, - /* 580 */ 60, 61, 62, 63, 403, 65, 361, 373, 374, 8, - /* 590 */ 9, 456, 51, 12, 13, 14, 15, 16, 383, 104, - /* 600 */ 205, 60, 107, 107, 63, 64, 391, 55, 441, 459, - /* 610 */ 492, 361, 462, 495, 33, 20, 466, 467, 468, 469, - /* 620 */ 470, 471, 52, 473, 373, 374, 106, 14, 478, 109, - /* 630 */ 480, 513, 514, 20, 484, 485, 518, 519, 143, 144, - /* 640 */ 20, 145, 417, 373, 393, 73, 74, 75, 373, 374, - /* 650 */ 373, 374, 80, 81, 82, 137, 138, 507, 86, 492, - /* 660 */ 142, 141, 495, 91, 92, 93, 94, 417, 393, 97, - /* 670 */ 373, 374, 100, 87, 65, 107, 181, 182, 402, 391, - /* 680 */ 513, 514, 20, 188, 189, 518, 519, 411, 412, 108, - /* 690 */ 393, 195, 196, 197, 373, 374, 200, 20, 203, 50, - /* 700 */ 205, 487, 488, 489, 490, 185, 492, 493, 476, 213, - /* 710 */ 214, 479, 192, 162, 297, 106, 373, 166, 109, 403, - /* 720 */ 224, 451, 452, 227, 65, 174, 230, 231, 232, 233, - /* 730 */ 234, 211, 237, 238, 239, 149, 241, 242, 243, 244, + /* 500 */ 253, 254, 255, 256, 257, 258, 259, 12, 13, 297, + /* 510 */ 361, 403, 22, 234, 18, 20, 51, 22, 149, 23, + /* 520 */ 20, 1, 414, 374, 0, 60, 466, 37, 63, 64, + /* 530 */ 35, 37, 37, 65, 418, 2, 40, 41, 107, 19, + /* 540 */ 44, 8, 9, 174, 175, 12, 13, 14, 15, 16, + /* 550 */ 54, 402, 492, 108, 275, 35, 181, 182, 42, 442, + /* 560 */ 65, 0, 66, 67, 68, 69, 71, 418, 78, 420, + /* 570 */ 361, 51, 78, 78, 106, 51, 390, 109, 373, 374, + /* 580 */ 60, 61, 62, 63, 21, 65, 22, 24, 25, 26, + /* 590 */ 27, 28, 29, 30, 31, 32, 419, 420, 393, 104, + /* 600 */ 383, 37, 107, 107, 418, 400, 275, 107, 391, 460, + /* 610 */ 493, 368, 463, 496, 371, 372, 467, 468, 469, 470, + /* 620 */ 471, 472, 477, 474, 50, 480, 106, 418, 479, 109, + /* 630 */ 481, 514, 515, 361, 485, 486, 519, 520, 143, 144, + /* 640 */ 402, 145, 78, 0, 176, 73, 74, 75, 410, 463, + /* 650 */ 464, 465, 80, 81, 82, 33, 21, 508, 86, 421, + /* 660 */ 474, 141, 34, 91, 92, 93, 94, 45, 104, 97, + /* 670 */ 402, 36, 100, 38, 39, 40, 181, 182, 373, 374, + /* 680 */ 412, 8, 9, 188, 189, 12, 13, 14, 15, 16, + /* 690 */ 418, 195, 196, 197, 373, 374, 200, 0, 203, 402, + /* 700 */ 205, 354, 355, 356, 357, 185, 275, 410, 0, 213, + /* 710 */ 214, 416, 192, 369, 419, 420, 0, 373, 421, 375, + /* 720 */ 224, 160, 161, 227, 1, 2, 230, 231, 232, 233, + /* 730 */ 234, 211, 237, 238, 239, 37, 241, 242, 243, 244, /* 740 */ 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - /* 750 */ 255, 256, 257, 258, 12, 13, 14, 418, 419, 361, - /* 760 */ 174, 175, 20, 0, 22, 488, 489, 490, 109, 492, - /* 770 */ 493, 275, 374, 403, 376, 432, 433, 35, 183, 37, - /* 780 */ 354, 355, 356, 357, 107, 176, 361, 24, 25, 26, - /* 790 */ 27, 28, 29, 30, 31, 32, 373, 374, 20, 374, - /* 800 */ 402, 376, 441, 183, 382, 143, 144, 65, 0, 488, - /* 810 */ 489, 490, 403, 492, 493, 417, 393, 419, 8, 9, - /* 820 */ 78, 399, 12, 13, 14, 15, 16, 402, 447, 8, - /* 830 */ 9, 409, 183, 12, 13, 14, 15, 16, 20, 14, - /* 840 */ 191, 20, 417, 275, 419, 20, 104, 107, 361, 107, - /* 850 */ 188, 189, 14, 492, 402, 465, 495, 459, 20, 239, - /* 860 */ 462, 374, 410, 376, 466, 467, 468, 469, 470, 471, - /* 870 */ 414, 473, 420, 417, 513, 514, 478, 23, 480, 518, - /* 880 */ 519, 491, 484, 485, 459, 143, 144, 462, 259, 402, - /* 890 */ 261, 466, 467, 468, 469, 470, 471, 0, 473, 373, - /* 900 */ 374, 47, 48, 478, 417, 480, 419, 8, 9, 484, - /* 910 */ 485, 12, 13, 14, 15, 16, 403, 380, 37, 393, - /* 920 */ 22, 8, 9, 181, 182, 12, 13, 14, 15, 16, - /* 930 */ 188, 189, 8, 9, 397, 37, 12, 13, 14, 15, - /* 940 */ 16, 107, 202, 406, 204, 203, 459, 205, 180, 462, - /* 950 */ 116, 37, 361, 466, 467, 468, 469, 470, 471, 181, - /* 960 */ 473, 403, 373, 374, 361, 478, 136, 480, 160, 161, - /* 970 */ 140, 484, 485, 37, 234, 414, 78, 374, 417, 237, - /* 980 */ 238, 239, 393, 241, 242, 243, 244, 245, 246, 247, + /* 750 */ 255, 256, 257, 258, 12, 13, 14, 183, 42, 361, + /* 760 */ 373, 374, 20, 373, 22, 191, 380, 203, 401, 205, + /* 770 */ 448, 275, 374, 373, 376, 275, 37, 35, 70, 37, + /* 780 */ 393, 8, 9, 397, 417, 12, 13, 14, 15, 16, + /* 790 */ 274, 361, 406, 20, 489, 490, 491, 20, 493, 494, + /* 800 */ 402, 237, 238, 442, 374, 162, 376, 65, 402, 166, + /* 810 */ 489, 490, 491, 13, 493, 494, 418, 174, 420, 413, + /* 820 */ 78, 8, 9, 433, 434, 12, 13, 14, 15, 16, + /* 830 */ 361, 108, 402, 136, 137, 138, 139, 140, 141, 142, + /* 840 */ 259, 442, 261, 374, 4, 376, 104, 373, 418, 107, + /* 850 */ 420, 71, 452, 453, 493, 402, 183, 496, 460, 415, + /* 860 */ 361, 463, 418, 410, 20, 467, 468, 469, 470, 471, + /* 870 */ 472, 402, 474, 20, 421, 514, 515, 479, 78, 481, + /* 880 */ 519, 520, 14, 485, 486, 143, 144, 418, 20, 420, + /* 890 */ 460, 0, 493, 463, 403, 496, 361, 467, 468, 469, + /* 900 */ 470, 471, 472, 205, 474, 403, 404, 237, 382, 479, + /* 910 */ 403, 481, 361, 514, 515, 485, 486, 418, 519, 520, + /* 920 */ 143, 144, 14, 181, 182, 399, 452, 453, 20, 460, + /* 930 */ 188, 189, 463, 235, 236, 409, 467, 468, 469, 470, + /* 940 */ 471, 472, 403, 474, 205, 203, 493, 205, 479, 496, + /* 950 */ 481, 373, 374, 418, 485, 486, 183, 287, 288, 289, + /* 960 */ 290, 291, 292, 293, 361, 137, 138, 514, 515, 418, + /* 970 */ 142, 393, 519, 520, 235, 236, 14, 374, 380, 237, + /* 980 */ 238, 239, 20, 241, 242, 243, 244, 245, 246, 247, /* 990 */ 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - /* 1000 */ 258, 12, 13, 361, 183, 402, 181, 108, 417, 20, - /* 1010 */ 22, 22, 373, 374, 78, 275, 374, 239, 376, 181, - /* 1020 */ 417, 108, 419, 402, 35, 37, 37, 14, 15, 16, - /* 1030 */ 262, 410, 393, 136, 137, 138, 139, 140, 141, 142, - /* 1040 */ 272, 420, 362, 22, 402, 0, 136, 137, 138, 139, - /* 1050 */ 140, 141, 142, 402, 65, 373, 374, 239, 37, 417, - /* 1060 */ 239, 419, 459, 465, 239, 462, 176, 78, 390, 466, - /* 1070 */ 467, 468, 469, 470, 471, 393, 473, 239, 373, 374, - /* 1080 */ 429, 478, 13, 480, 56, 57, 205, 484, 485, 491, - /* 1090 */ 361, 395, 104, 104, 398, 417, 107, 207, 393, 361, - /* 1100 */ 402, 459, 403, 374, 462, 376, 37, 183, 466, 467, - /* 1110 */ 468, 469, 470, 471, 4, 473, 235, 236, 420, 205, - /* 1120 */ 478, 430, 480, 373, 374, 104, 484, 485, 394, 19, - /* 1130 */ 4, 402, 143, 144, 373, 374, 402, 35, 373, 374, - /* 1140 */ 462, 463, 464, 393, 33, 35, 417, 413, 419, 235, - /* 1150 */ 236, 473, 0, 51, 393, 417, 373, 374, 393, 373, - /* 1160 */ 374, 51, 60, 61, 62, 63, 361, 65, 58, 59, - /* 1170 */ 181, 182, 402, 373, 374, 65, 393, 188, 189, 393, - /* 1180 */ 410, 136, 137, 138, 139, 140, 141, 142, 459, 380, - /* 1190 */ 420, 462, 203, 393, 205, 466, 467, 468, 469, 470, - /* 1200 */ 471, 361, 473, 361, 373, 374, 42, 478, 106, 480, - /* 1210 */ 361, 109, 20, 484, 485, 406, 106, 20, 361, 109, - /* 1220 */ 361, 361, 417, 374, 393, 376, 237, 238, 239, 361, + /* 1000 */ 258, 12, 13, 361, 406, 402, 56, 57, 20, 20, + /* 1010 */ 22, 22, 239, 382, 373, 374, 374, 237, 376, 373, + /* 1020 */ 374, 418, 22, 420, 35, 181, 37, 136, 137, 138, + /* 1030 */ 139, 140, 141, 142, 393, 373, 374, 37, 361, 393, + /* 1040 */ 409, 20, 493, 55, 402, 496, 400, 180, 478, 181, + /* 1050 */ 480, 374, 403, 376, 65, 393, 373, 374, 373, 374, + /* 1060 */ 418, 361, 420, 460, 515, 361, 463, 78, 519, 520, + /* 1070 */ 467, 468, 469, 470, 471, 472, 393, 474, 393, 402, + /* 1080 */ 373, 374, 479, 239, 481, 137, 373, 374, 485, 486, + /* 1090 */ 136, 20, 239, 104, 140, 418, 107, 420, 493, 107, + /* 1100 */ 393, 496, 460, 391, 104, 463, 393, 239, 116, 467, + /* 1110 */ 468, 469, 470, 471, 472, 361, 474, 277, 418, 4, + /* 1120 */ 515, 479, 418, 481, 519, 520, 362, 485, 486, 262, + /* 1130 */ 378, 379, 143, 144, 19, 373, 374, 460, 402, 272, + /* 1140 */ 463, 373, 374, 181, 467, 468, 469, 470, 471, 472, + /* 1150 */ 35, 474, 14, 15, 16, 393, 479, 421, 481, 373, + /* 1160 */ 374, 393, 485, 486, 216, 217, 51, 117, 373, 374, + /* 1170 */ 181, 182, 418, 58, 59, 373, 374, 188, 189, 393, + /* 1180 */ 65, 136, 137, 138, 139, 140, 141, 142, 393, 373, + /* 1190 */ 374, 33, 203, 361, 205, 393, 373, 374, 402, 373, + /* 1200 */ 374, 239, 415, 402, 183, 418, 410, 361, 361, 393, + /* 1210 */ 361, 410, 378, 379, 431, 361, 393, 421, 523, 393, + /* 1220 */ 170, 106, 421, 374, 109, 376, 237, 238, 239, 512, /* 1230 */ 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, /* 1240 */ 251, 252, 253, 254, 255, 256, 257, 258, 12, 13, - /* 1250 */ 37, 402, 373, 374, 361, 71, 20, 417, 22, 417, - /* 1260 */ 13, 373, 374, 378, 379, 361, 417, 361, 419, 361, - /* 1270 */ 361, 35, 393, 37, 417, 33, 417, 417, 176, 12, - /* 1280 */ 13, 393, 361, 361, 37, 417, 0, 185, 186, 22, - /* 1290 */ 361, 78, 387, 388, 192, 193, 378, 379, 387, 388, - /* 1300 */ 414, 65, 35, 417, 37, 364, 365, 117, 459, 382, - /* 1310 */ 417, 462, 33, 211, 78, 466, 467, 468, 469, 470, - /* 1320 */ 471, 417, 473, 417, 45, 417, 417, 478, 42, 480, - /* 1330 */ 402, 14, 65, 484, 485, 402, 409, 20, 417, 417, - /* 1340 */ 104, 33, 361, 107, 33, 78, 417, 104, 420, 273, - /* 1350 */ 274, 110, 511, 420, 113, 374, 0, 219, 33, 221, - /* 1360 */ 170, 118, 119, 120, 121, 122, 123, 124, 125, 126, - /* 1370 */ 127, 104, 129, 130, 131, 132, 133, 134, 135, 143, - /* 1380 */ 144, 229, 0, 402, 12, 13, 0, 33, 110, 33, - /* 1390 */ 110, 113, 110, 113, 22, 113, 33, 522, 417, 45, - /* 1400 */ 419, 0, 37, 277, 22, 0, 49, 35, 22, 37, - /* 1410 */ 299, 143, 144, 1, 2, 377, 108, 181, 182, 108, - /* 1420 */ 33, 237, 33, 22, 188, 189, 33, 22, 33, 12, - /* 1430 */ 13, 239, 33, 108, 504, 33, 239, 65, 274, 203, - /* 1440 */ 459, 205, 33, 462, 12, 13, 402, 466, 467, 468, - /* 1450 */ 469, 470, 471, 33, 473, 361, 33, 390, 33, 478, - /* 1460 */ 33, 480, 12, 13, 107, 484, 485, 390, 374, 33, - /* 1470 */ 203, 108, 205, 237, 238, 239, 33, 241, 242, 243, + /* 1250 */ 418, 402, 387, 388, 183, 22, 20, 219, 22, 221, + /* 1260 */ 239, 104, 387, 388, 418, 418, 394, 418, 361, 420, + /* 1270 */ 37, 35, 418, 37, 402, 118, 119, 120, 121, 122, + /* 1280 */ 123, 124, 125, 126, 127, 413, 129, 130, 131, 132, + /* 1290 */ 133, 134, 135, 373, 374, 361, 361, 33, 361, 415, + /* 1300 */ 361, 65, 418, 402, 395, 364, 365, 398, 176, 460, + /* 1310 */ 239, 0, 463, 393, 78, 33, 467, 468, 469, 470, + /* 1320 */ 471, 472, 421, 474, 33, 418, 110, 13, 479, 113, + /* 1330 */ 481, 12, 13, 33, 485, 486, 45, 104, 33, 207, + /* 1340 */ 104, 22, 505, 107, 33, 361, 104, 273, 274, 143, + /* 1350 */ 144, 37, 418, 418, 35, 418, 37, 418, 374, 13, + /* 1360 */ 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + /* 1370 */ 0, 129, 130, 131, 132, 133, 134, 135, 110, 143, + /* 1380 */ 144, 113, 110, 37, 65, 113, 402, 65, 110, 0, + /* 1390 */ 108, 113, 22, 0, 0, 13, 33, 78, 402, 1, + /* 1400 */ 2, 33, 418, 49, 420, 13, 377, 390, 108, 37, + /* 1410 */ 37, 22, 390, 108, 431, 22, 22, 181, 182, 37, + /* 1420 */ 0, 12, 13, 104, 188, 189, 39, 40, 33, 37, + /* 1430 */ 33, 109, 372, 431, 33, 33, 33, 33, 33, 203, + /* 1440 */ 511, 205, 511, 511, 460, 33, 441, 463, 12, 13, + /* 1450 */ 377, 467, 468, 469, 470, 471, 472, 299, 474, 33, + /* 1460 */ 33, 107, 33, 479, 33, 481, 12, 13, 511, 485, + /* 1470 */ 486, 108, 52, 237, 238, 239, 108, 241, 242, 243, /* 1480 */ 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - /* 1490 */ 254, 255, 256, 257, 258, 108, 402, 108, 12, 13, - /* 1500 */ 430, 108, 372, 108, 237, 238, 33, 108, 12, 13, - /* 1510 */ 108, 417, 430, 419, 12, 13, 33, 108, 251, 252, - /* 1520 */ 253, 254, 255, 256, 257, 33, 12, 13, 108, 510, - /* 1530 */ 13, 108, 361, 108, 13, 108, 12, 13, 33, 12, - /* 1540 */ 13, 12, 13, 301, 108, 374, 12, 13, 440, 510, - /* 1550 */ 510, 108, 510, 459, 37, 377, 462, 430, 37, 374, - /* 1560 */ 466, 467, 468, 469, 470, 471, 416, 473, 448, 430, - /* 1570 */ 205, 430, 478, 402, 480, 203, 361, 205, 484, 485, - /* 1580 */ 494, 108, 486, 515, 497, 392, 442, 278, 417, 374, - /* 1590 */ 419, 108, 51, 461, 42, 460, 20, 218, 453, 382, - /* 1600 */ 108, 458, 453, 382, 201, 361, 444, 235, 236, 237, - /* 1610 */ 20, 373, 20, 108, 374, 45, 105, 402, 374, 374, - /* 1620 */ 426, 426, 180, 251, 252, 253, 254, 255, 256, 257, - /* 1630 */ 459, 423, 417, 462, 419, 361, 373, 466, 467, 468, - /* 1640 */ 469, 470, 471, 374, 473, 373, 402, 423, 374, 426, - /* 1650 */ 423, 480, 423, 103, 373, 484, 485, 386, 385, 102, - /* 1660 */ 384, 417, 373, 419, 373, 373, 20, 366, 50, 370, - /* 1670 */ 366, 453, 370, 20, 459, 382, 402, 462, 382, 361, - /* 1680 */ 419, 466, 467, 468, 469, 470, 471, 382, 473, 20, - /* 1690 */ 375, 417, 374, 419, 20, 480, 443, 375, 382, 484, - /* 1700 */ 485, 382, 20, 459, 373, 382, 462, 366, 433, 361, - /* 1710 */ 466, 467, 468, 469, 470, 471, 382, 473, 382, 373, - /* 1720 */ 402, 366, 374, 402, 480, 364, 402, 417, 484, 485, - /* 1730 */ 402, 402, 402, 459, 402, 417, 462, 419, 361, 402, - /* 1740 */ 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, - /* 1750 */ 402, 374, 402, 402, 402, 402, 364, 417, 222, 417, - /* 1760 */ 457, 107, 455, 380, 20, 417, 453, 419, 209, 208, - /* 1770 */ 380, 373, 452, 286, 285, 417, 450, 459, 419, 402, - /* 1780 */ 462, 442, 449, 506, 466, 467, 468, 469, 470, 471, - /* 1790 */ 503, 473, 294, 503, 417, 435, 419, 435, 194, 505, - /* 1800 */ 503, 501, 296, 295, 279, 298, 442, 459, 502, 300, - /* 1810 */ 462, 523, 500, 303, 466, 467, 468, 469, 470, 471, - /* 1820 */ 274, 473, 374, 20, 117, 498, 508, 509, 375, 276, - /* 1830 */ 107, 517, 465, 417, 496, 380, 459, 380, 417, 462, - /* 1840 */ 361, 435, 435, 466, 467, 468, 469, 470, 471, 483, - /* 1850 */ 473, 516, 417, 374, 417, 417, 186, 480, 361, 431, - /* 1860 */ 380, 398, 485, 417, 380, 374, 417, 107, 520, 521, - /* 1870 */ 22, 374, 373, 417, 407, 417, 417, 417, 417, 417, - /* 1880 */ 380, 402, 417, 417, 361, 417, 417, 417, 417, 417, - /* 1890 */ 38, 417, 417, 417, 417, 417, 417, 374, 419, 402, - /* 1900 */ 363, 366, 417, 381, 359, 417, 367, 417, 454, 445, - /* 1910 */ 0, 396, 396, 0, 417, 396, 419, 436, 436, 0, - /* 1920 */ 45, 0, 404, 37, 228, 402, 37, 37, 37, 0, - /* 1930 */ 228, 37, 37, 228, 37, 0, 439, 228, 459, 0, - /* 1940 */ 417, 462, 419, 37, 0, 466, 467, 468, 469, 470, - /* 1950 */ 471, 37, 473, 22, 0, 37, 459, 0, 223, 462, - /* 1960 */ 0, 211, 439, 466, 467, 468, 469, 470, 471, 0, - /* 1970 */ 473, 361, 211, 205, 212, 203, 0, 0, 0, 199, - /* 1980 */ 198, 0, 459, 0, 374, 462, 148, 361, 509, 466, - /* 1990 */ 467, 468, 469, 470, 471, 49, 473, 49, 0, 37, - /* 2000 */ 374, 0, 0, 361, 37, 0, 51, 49, 0, 45, - /* 2010 */ 0, 0, 402, 0, 49, 0, 374, 0, 0, 0, - /* 2020 */ 0, 0, 166, 37, 0, 166, 0, 417, 402, 419, - /* 2030 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - /* 2040 */ 0, 0, 0, 417, 402, 419, 0, 0, 0, 0, - /* 2050 */ 0, 0, 49, 0, 45, 0, 0, 0, 0, 417, - /* 2060 */ 0, 419, 361, 0, 0, 22, 0, 0, 148, 459, - /* 2070 */ 147, 0, 462, 146, 0, 374, 466, 467, 468, 469, - /* 2080 */ 470, 471, 0, 473, 22, 459, 0, 22, 462, 45, - /* 2090 */ 65, 37, 466, 467, 468, 469, 470, 471, 0, 473, - /* 2100 */ 0, 459, 50, 402, 462, 37, 0, 0, 466, 467, - /* 2110 */ 468, 469, 470, 471, 0, 473, 0, 475, 417, 50, - /* 2120 */ 419, 51, 512, 42, 65, 37, 65, 51, 37, 42, - /* 2130 */ 51, 0, 37, 0, 42, 42, 33, 14, 0, 361, - /* 2140 */ 439, 0, 43, 49, 42, 49, 49, 521, 0, 0, - /* 2150 */ 0, 42, 374, 194, 0, 0, 0, 49, 0, 0, - /* 2160 */ 459, 37, 72, 462, 51, 0, 37, 466, 467, 468, - /* 2170 */ 469, 470, 471, 51, 473, 0, 42, 361, 42, 37, - /* 2180 */ 402, 51, 42, 0, 37, 42, 51, 0, 0, 0, - /* 2190 */ 374, 113, 115, 22, 37, 417, 0, 419, 361, 0, - /* 2200 */ 0, 0, 22, 37, 37, 37, 37, 37, 0, 37, - /* 2210 */ 37, 374, 33, 37, 33, 37, 22, 439, 402, 37, - /* 2220 */ 0, 37, 0, 0, 22, 22, 22, 53, 0, 37, - /* 2230 */ 0, 0, 37, 417, 0, 419, 0, 459, 22, 402, - /* 2240 */ 462, 20, 37, 37, 466, 467, 468, 469, 470, 471, - /* 2250 */ 37, 473, 37, 108, 417, 0, 419, 0, 107, 361, - /* 2260 */ 107, 49, 37, 183, 22, 0, 22, 183, 183, 0, - /* 2270 */ 0, 3, 374, 33, 280, 459, 37, 50, 462, 50, - /* 2280 */ 37, 206, 466, 467, 468, 469, 470, 471, 3, 473, - /* 2290 */ 186, 190, 107, 210, 183, 183, 459, 107, 361, 462, - /* 2300 */ 402, 108, 105, 466, 467, 468, 469, 470, 471, 190, - /* 2310 */ 473, 374, 33, 33, 361, 417, 107, 419, 108, 108, - /* 2320 */ 103, 33, 108, 49, 49, 107, 107, 374, 33, 33, - /* 2330 */ 37, 107, 361, 49, 108, 37, 37, 37, 37, 402, - /* 2340 */ 107, 37, 33, 108, 0, 374, 108, 0, 42, 108, - /* 2350 */ 33, 49, 280, 108, 417, 402, 419, 459, 107, 105, - /* 2360 */ 462, 105, 2, 22, 466, 467, 468, 469, 470, 471, - /* 2370 */ 417, 473, 419, 402, 237, 108, 49, 260, 107, 49, - /* 2380 */ 108, 108, 0, 273, 107, 107, 22, 42, 417, 107, - /* 2390 */ 419, 108, 240, 117, 108, 280, 459, 107, 107, 462, - /* 2400 */ 49, 107, 22, 466, 467, 468, 469, 470, 471, 22, - /* 2410 */ 473, 108, 459, 116, 107, 462, 22, 185, 107, 466, - /* 2420 */ 467, 468, 469, 470, 471, 107, 473, 107, 107, 37, - /* 2430 */ 459, 108, 37, 462, 361, 187, 107, 466, 467, 468, - /* 2440 */ 469, 470, 471, 108, 473, 37, 107, 374, 108, 37, - /* 2450 */ 361, 108, 334, 107, 37, 107, 37, 108, 108, 107, - /* 2460 */ 37, 107, 128, 374, 128, 128, 361, 33, 107, 107, - /* 2470 */ 128, 22, 37, 72, 107, 402, 37, 71, 37, 374, - /* 2480 */ 37, 37, 37, 37, 37, 37, 101, 37, 78, 78, - /* 2490 */ 417, 402, 419, 33, 101, 37, 37, 22, 37, 37, - /* 2500 */ 37, 37, 78, 37, 37, 37, 417, 402, 419, 37, - /* 2510 */ 37, 22, 0, 37, 37, 0, 51, 0, 37, 37, - /* 2520 */ 42, 51, 417, 0, 419, 361, 42, 42, 37, 42, - /* 2530 */ 51, 0, 459, 37, 51, 462, 37, 0, 374, 466, - /* 2540 */ 467, 468, 469, 470, 471, 21, 473, 22, 459, 33, - /* 2550 */ 22, 462, 361, 20, 22, 466, 467, 468, 469, 470, - /* 2560 */ 471, 22, 473, 524, 459, 374, 402, 462, 21, 524, - /* 2570 */ 524, 466, 467, 468, 469, 470, 471, 524, 473, 524, - /* 2580 */ 524, 417, 524, 419, 524, 524, 524, 524, 524, 524, - /* 2590 */ 524, 524, 524, 402, 524, 524, 524, 524, 524, 524, - /* 2600 */ 524, 524, 524, 524, 524, 524, 524, 361, 417, 524, - /* 2610 */ 419, 524, 524, 524, 524, 524, 524, 524, 524, 524, - /* 2620 */ 374, 524, 524, 459, 524, 524, 462, 524, 524, 524, - /* 2630 */ 466, 467, 468, 469, 470, 471, 524, 473, 524, 524, - /* 2640 */ 524, 524, 524, 524, 524, 524, 524, 524, 402, 524, - /* 2650 */ 459, 524, 524, 462, 524, 524, 524, 466, 467, 468, - /* 2660 */ 469, 470, 471, 417, 473, 419, 361, 524, 524, 524, - /* 2670 */ 524, 524, 524, 524, 524, 524, 524, 524, 524, 374, - /* 2680 */ 524, 524, 524, 524, 524, 524, 524, 524, 524, 361, - /* 2690 */ 524, 524, 524, 524, 524, 524, 524, 524, 524, 524, - /* 2700 */ 524, 524, 374, 524, 524, 459, 524, 402, 462, 524, - /* 2710 */ 524, 524, 466, 467, 468, 469, 470, 471, 524, 473, - /* 2720 */ 524, 524, 417, 524, 419, 524, 524, 361, 524, 524, - /* 2730 */ 402, 524, 524, 524, 524, 524, 524, 524, 524, 524, - /* 2740 */ 374, 524, 524, 524, 524, 417, 524, 419, 524, 524, - /* 2750 */ 361, 524, 524, 524, 524, 524, 524, 524, 524, 524, - /* 2760 */ 524, 524, 524, 374, 459, 524, 361, 462, 402, 524, - /* 2770 */ 524, 466, 467, 468, 469, 470, 471, 524, 473, 374, - /* 2780 */ 524, 524, 524, 417, 524, 419, 524, 459, 524, 524, - /* 2790 */ 462, 402, 524, 524, 466, 467, 468, 469, 470, 471, - /* 2800 */ 524, 473, 524, 524, 524, 524, 417, 402, 419, 524, - /* 2810 */ 524, 524, 524, 524, 524, 524, 524, 524, 524, 524, - /* 2820 */ 524, 524, 417, 524, 419, 459, 524, 524, 462, 524, - /* 2830 */ 524, 524, 466, 467, 468, 469, 470, 471, 524, 473, - /* 2840 */ 524, 361, 524, 524, 524, 524, 524, 524, 459, 524, - /* 2850 */ 524, 462, 524, 524, 374, 466, 467, 468, 469, 470, - /* 2860 */ 471, 524, 473, 524, 459, 524, 524, 462, 361, 524, - /* 2870 */ 524, 466, 467, 468, 469, 470, 471, 524, 473, 524, - /* 2880 */ 524, 374, 402, 524, 524, 524, 524, 361, 524, 524, - /* 2890 */ 524, 524, 524, 524, 524, 524, 524, 417, 524, 419, - /* 2900 */ 374, 524, 524, 361, 524, 524, 524, 524, 524, 402, - /* 2910 */ 524, 524, 524, 524, 524, 524, 374, 524, 524, 524, - /* 2920 */ 524, 524, 524, 524, 417, 524, 419, 524, 402, 524, - /* 2930 */ 524, 524, 524, 524, 524, 524, 524, 524, 524, 459, - /* 2940 */ 524, 524, 462, 417, 402, 419, 466, 467, 468, 469, - /* 2950 */ 470, 471, 524, 473, 524, 524, 524, 524, 524, 417, - /* 2960 */ 524, 419, 524, 524, 524, 524, 459, 524, 524, 462, - /* 2970 */ 524, 524, 524, 466, 467, 468, 469, 470, 471, 524, - /* 2980 */ 473, 524, 524, 524, 524, 459, 524, 524, 462, 524, - /* 2990 */ 524, 524, 466, 467, 468, 469, 470, 471, 524, 473, - /* 3000 */ 524, 459, 524, 524, 462, 524, 524, 524, 466, 467, - /* 3010 */ 468, 469, 470, 471, 524, 473, 524, 524, 524, 361, - /* 3020 */ 524, 524, 524, 524, 524, 524, 524, 524, 524, 524, - /* 3030 */ 524, 524, 374, 524, 524, 524, 524, 524, 524, 524, - /* 3040 */ 524, 524, 524, 524, 524, 524, 524, 524, 524, 524, - /* 3050 */ 524, 524, 524, 524, 524, 524, 524, 524, 524, 524, - /* 3060 */ 402, 524, 524, 524, 524, 524, 524, 524, 524, 524, - /* 3070 */ 524, 524, 524, 524, 524, 417, 524, 419, 524, 524, - /* 3080 */ 524, 524, 524, 524, 524, 524, 524, 524, 524, 524, - /* 3090 */ 524, 524, 524, 524, 524, 524, 524, 524, 524, 524, - /* 3100 */ 524, 524, 524, 524, 524, 524, 524, 524, 524, 524, - /* 3110 */ 524, 524, 524, 524, 524, 524, 524, 459, 524, 524, - /* 3120 */ 462, 524, 524, 524, 466, 467, 468, 469, 470, 471, - /* 3130 */ 524, 473, 358, 358, 358, 358, 358, 358, 358, 358, - /* 3140 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, - /* 3150 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, - /* 3160 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, - /* 3170 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, - /* 3180 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, - /* 3190 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, - /* 3200 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, - /* 3210 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, - /* 3220 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, - /* 3230 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, - /* 3240 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, - /* 3250 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, - /* 3260 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, + /* 1490 */ 254, 255, 256, 257, 258, 361, 12, 13, 111, 112, + /* 1500 */ 431, 114, 374, 108, 33, 108, 22, 417, 374, 108, + /* 1510 */ 108, 108, 108, 108, 12, 13, 449, 35, 33, 35, + /* 1520 */ 108, 37, 203, 136, 205, 361, 431, 140, 12, 13, + /* 1530 */ 12, 13, 33, 51, 108, 108, 402, 108, 374, 108, + /* 1540 */ 12, 13, 60, 61, 62, 63, 33, 65, 37, 65, + /* 1550 */ 431, 495, 418, 516, 420, 487, 237, 238, 12, 13, + /* 1560 */ 12, 13, 12, 13, 498, 301, 402, 12, 13, 392, + /* 1570 */ 251, 252, 253, 254, 255, 256, 257, 205, 205, 108, + /* 1580 */ 278, 51, 418, 443, 420, 462, 42, 461, 106, 78, + /* 1590 */ 20, 109, 218, 108, 460, 454, 459, 463, 361, 382, + /* 1600 */ 454, 467, 468, 469, 470, 471, 472, 108, 474, 382, + /* 1610 */ 445, 374, 201, 479, 20, 481, 373, 20, 374, 485, + /* 1620 */ 486, 108, 45, 427, 460, 374, 427, 463, 180, 424, + /* 1630 */ 373, 467, 468, 469, 470, 471, 472, 374, 474, 402, + /* 1640 */ 373, 427, 424, 424, 424, 481, 105, 386, 103, 485, + /* 1650 */ 486, 385, 373, 361, 102, 418, 373, 420, 176, 384, + /* 1660 */ 373, 373, 20, 366, 50, 370, 374, 185, 186, 366, + /* 1670 */ 20, 370, 382, 420, 192, 193, 454, 20, 382, 375, + /* 1680 */ 382, 20, 444, 375, 20, 361, 434, 203, 382, 205, + /* 1690 */ 373, 382, 382, 211, 402, 382, 366, 460, 374, 364, + /* 1700 */ 463, 402, 382, 364, 467, 468, 469, 470, 471, 472, + /* 1710 */ 418, 474, 420, 373, 402, 366, 222, 402, 481, 235, + /* 1720 */ 236, 237, 485, 486, 107, 402, 402, 402, 402, 402, + /* 1730 */ 402, 402, 458, 402, 402, 251, 252, 253, 254, 255, + /* 1740 */ 256, 257, 418, 20, 420, 456, 380, 454, 209, 380, + /* 1750 */ 208, 418, 460, 373, 418, 463, 418, 420, 451, 467, + /* 1760 */ 468, 469, 470, 471, 472, 418, 474, 286, 450, 453, + /* 1770 */ 436, 285, 294, 481, 504, 504, 507, 485, 486, 436, + /* 1780 */ 194, 504, 506, 296, 460, 443, 295, 463, 503, 279, + /* 1790 */ 300, 467, 468, 469, 470, 471, 472, 473, 474, 475, + /* 1800 */ 476, 361, 443, 303, 524, 298, 274, 374, 20, 117, + /* 1810 */ 276, 107, 518, 375, 374, 380, 361, 466, 418, 380, + /* 1820 */ 436, 436, 186, 502, 418, 418, 418, 380, 418, 374, + /* 1830 */ 398, 361, 484, 380, 374, 418, 418, 418, 107, 418, + /* 1840 */ 499, 418, 402, 418, 374, 501, 432, 497, 418, 407, + /* 1850 */ 373, 22, 418, 380, 38, 418, 363, 402, 418, 418, + /* 1860 */ 420, 418, 517, 418, 418, 367, 0, 418, 418, 418, + /* 1870 */ 418, 366, 402, 418, 418, 420, 418, 418, 404, 418, + /* 1880 */ 418, 418, 381, 455, 396, 396, 359, 0, 418, 0, + /* 1890 */ 420, 396, 45, 0, 437, 37, 228, 37, 37, 37, + /* 1900 */ 460, 437, 228, 463, 0, 37, 37, 467, 468, 469, + /* 1910 */ 470, 471, 472, 446, 474, 460, 228, 37, 463, 0, + /* 1920 */ 0, 228, 467, 468, 469, 470, 471, 472, 37, 474, + /* 1930 */ 460, 0, 361, 463, 37, 0, 22, 467, 468, 469, + /* 1940 */ 470, 471, 472, 0, 474, 374, 37, 223, 0, 509, + /* 1950 */ 510, 481, 0, 211, 211, 205, 486, 212, 203, 0, + /* 1960 */ 0, 0, 199, 198, 0, 361, 0, 148, 0, 37, + /* 1970 */ 49, 49, 0, 402, 0, 37, 521, 522, 374, 51, + /* 1980 */ 0, 0, 49, 0, 45, 0, 0, 0, 0, 418, + /* 1990 */ 49, 420, 0, 0, 0, 0, 166, 0, 166, 37, + /* 2000 */ 0, 0, 0, 0, 0, 0, 402, 0, 0, 0, + /* 2010 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 2020 */ 49, 0, 418, 45, 420, 0, 0, 0, 0, 0, + /* 2030 */ 0, 460, 0, 0, 463, 0, 148, 0, 467, 468, + /* 2040 */ 469, 470, 471, 472, 440, 474, 22, 361, 147, 0, + /* 2050 */ 0, 146, 0, 22, 0, 65, 50, 0, 22, 37, + /* 2060 */ 374, 65, 0, 65, 460, 0, 361, 463, 0, 0, + /* 2070 */ 50, 467, 468, 469, 470, 471, 472, 37, 474, 374, + /* 2080 */ 42, 510, 37, 361, 42, 51, 0, 0, 402, 42, + /* 2090 */ 37, 0, 51, 37, 51, 49, 374, 33, 14, 0, + /* 2100 */ 45, 42, 361, 0, 418, 0, 420, 402, 42, 49, + /* 2110 */ 43, 0, 49, 0, 42, 374, 72, 194, 0, 49, + /* 2120 */ 0, 361, 0, 418, 402, 420, 440, 0, 0, 37, + /* 2130 */ 51, 42, 0, 37, 374, 42, 51, 0, 37, 51, + /* 2140 */ 418, 0, 420, 402, 42, 37, 460, 0, 51, 463, + /* 2150 */ 0, 42, 0, 467, 468, 469, 470, 471, 472, 418, + /* 2160 */ 474, 420, 402, 0, 0, 460, 0, 37, 463, 0, + /* 2170 */ 22, 113, 467, 468, 469, 470, 471, 472, 418, 474, + /* 2180 */ 420, 37, 460, 37, 53, 463, 115, 33, 37, 467, + /* 2190 */ 468, 469, 470, 471, 472, 37, 474, 37, 37, 37, + /* 2200 */ 440, 460, 37, 33, 463, 37, 361, 22, 467, 468, + /* 2210 */ 469, 470, 471, 472, 37, 474, 22, 476, 513, 374, + /* 2220 */ 460, 37, 0, 463, 22, 0, 22, 467, 468, 469, + /* 2230 */ 470, 471, 472, 0, 474, 361, 22, 0, 37, 0, + /* 2240 */ 0, 0, 37, 0, 522, 37, 0, 402, 374, 22, + /* 2250 */ 20, 0, 37, 37, 37, 49, 183, 108, 210, 0, + /* 2260 */ 107, 183, 107, 418, 22, 420, 37, 0, 186, 361, + /* 2270 */ 22, 0, 0, 183, 107, 37, 402, 183, 183, 280, + /* 2280 */ 206, 3, 374, 33, 37, 440, 108, 107, 190, 108, + /* 2290 */ 190, 103, 418, 107, 420, 50, 105, 108, 33, 50, + /* 2300 */ 108, 33, 107, 107, 107, 460, 108, 33, 463, 49, + /* 2310 */ 402, 49, 467, 468, 469, 470, 471, 472, 107, 474, + /* 2320 */ 33, 108, 3, 33, 49, 37, 418, 108, 420, 37, + /* 2330 */ 37, 280, 108, 37, 460, 37, 37, 463, 33, 0, + /* 2340 */ 361, 467, 468, 469, 470, 471, 472, 0, 474, 273, + /* 2350 */ 49, 42, 108, 374, 33, 280, 2, 22, 105, 107, + /* 2360 */ 105, 237, 108, 107, 260, 108, 108, 49, 460, 49, + /* 2370 */ 107, 463, 108, 107, 22, 467, 468, 469, 470, 471, + /* 2380 */ 472, 402, 474, 107, 107, 240, 107, 107, 107, 0, + /* 2390 */ 108, 108, 107, 107, 49, 42, 187, 418, 107, 420, + /* 2400 */ 361, 107, 22, 185, 107, 116, 22, 107, 22, 37, + /* 2410 */ 108, 107, 37, 374, 107, 334, 108, 107, 37, 108, + /* 2420 */ 117, 107, 361, 108, 37, 108, 33, 37, 37, 37, + /* 2430 */ 108, 108, 107, 107, 128, 374, 37, 107, 22, 460, + /* 2440 */ 128, 402, 463, 72, 128, 71, 467, 468, 469, 470, + /* 2450 */ 471, 472, 128, 474, 37, 37, 37, 418, 37, 420, + /* 2460 */ 37, 37, 37, 402, 37, 37, 78, 101, 101, 33, + /* 2470 */ 37, 37, 78, 22, 37, 37, 37, 361, 37, 418, + /* 2480 */ 78, 420, 37, 37, 37, 37, 37, 22, 0, 37, + /* 2490 */ 374, 37, 42, 51, 0, 37, 0, 42, 42, 460, + /* 2500 */ 37, 0, 463, 37, 361, 0, 467, 468, 469, 470, + /* 2510 */ 471, 472, 51, 474, 42, 51, 37, 374, 402, 51, + /* 2520 */ 37, 460, 22, 33, 463, 0, 22, 21, 467, 468, + /* 2530 */ 469, 470, 471, 472, 418, 474, 420, 361, 22, 22, + /* 2540 */ 21, 20, 525, 525, 525, 402, 525, 525, 525, 525, + /* 2550 */ 374, 525, 525, 525, 525, 525, 525, 525, 525, 525, + /* 2560 */ 525, 418, 525, 420, 525, 525, 525, 525, 361, 525, + /* 2570 */ 525, 525, 525, 525, 525, 525, 460, 525, 402, 463, + /* 2580 */ 525, 374, 525, 467, 468, 469, 470, 471, 472, 525, + /* 2590 */ 474, 525, 361, 525, 418, 525, 420, 525, 525, 525, + /* 2600 */ 525, 525, 525, 460, 525, 374, 463, 525, 525, 402, + /* 2610 */ 467, 468, 469, 470, 471, 472, 525, 474, 525, 525, + /* 2620 */ 525, 525, 525, 525, 525, 418, 525, 420, 525, 525, + /* 2630 */ 525, 525, 525, 402, 525, 525, 460, 525, 525, 463, + /* 2640 */ 525, 525, 525, 467, 468, 469, 470, 471, 472, 418, + /* 2650 */ 474, 420, 525, 525, 525, 525, 361, 525, 525, 525, + /* 2660 */ 525, 525, 525, 525, 525, 525, 525, 460, 525, 374, + /* 2670 */ 463, 525, 525, 525, 467, 468, 469, 470, 471, 472, + /* 2680 */ 525, 474, 525, 525, 525, 525, 525, 525, 525, 525, + /* 2690 */ 525, 460, 525, 525, 463, 525, 525, 402, 467, 468, + /* 2700 */ 469, 470, 471, 472, 525, 474, 525, 525, 525, 525, + /* 2710 */ 525, 525, 525, 418, 525, 420, 525, 525, 525, 525, + /* 2720 */ 525, 525, 525, 525, 525, 525, 525, 525, 525, 525, + /* 2730 */ 361, 525, 525, 525, 525, 525, 525, 525, 525, 525, + /* 2740 */ 525, 525, 525, 374, 525, 525, 525, 525, 525, 525, + /* 2750 */ 525, 525, 525, 525, 525, 460, 525, 525, 463, 361, + /* 2760 */ 525, 525, 467, 468, 469, 470, 471, 472, 525, 474, + /* 2770 */ 525, 402, 374, 525, 525, 525, 525, 525, 525, 525, + /* 2780 */ 525, 525, 525, 525, 525, 525, 525, 418, 525, 420, + /* 2790 */ 525, 525, 525, 525, 525, 525, 525, 525, 525, 525, + /* 2800 */ 402, 525, 525, 525, 525, 525, 525, 525, 525, 525, + /* 2810 */ 525, 525, 525, 525, 525, 525, 418, 525, 420, 525, + /* 2820 */ 525, 361, 525, 525, 525, 525, 525, 525, 525, 460, + /* 2830 */ 525, 525, 463, 525, 374, 525, 467, 468, 469, 470, + /* 2840 */ 471, 472, 525, 474, 525, 525, 525, 525, 525, 525, + /* 2850 */ 525, 525, 525, 525, 525, 525, 525, 525, 460, 525, + /* 2860 */ 525, 463, 402, 525, 525, 467, 468, 469, 470, 471, + /* 2870 */ 472, 525, 474, 525, 525, 525, 525, 525, 418, 525, + /* 2880 */ 420, 525, 525, 361, 525, 525, 525, 525, 525, 525, + /* 2890 */ 525, 525, 525, 525, 525, 525, 374, 525, 361, 525, + /* 2900 */ 525, 525, 525, 525, 525, 525, 525, 525, 525, 525, + /* 2910 */ 525, 374, 525, 525, 525, 525, 525, 525, 525, 525, + /* 2920 */ 460, 525, 525, 463, 402, 525, 525, 467, 468, 469, + /* 2930 */ 470, 471, 472, 525, 474, 525, 525, 525, 525, 402, + /* 2940 */ 418, 525, 420, 525, 525, 525, 525, 525, 525, 525, + /* 2950 */ 525, 525, 525, 525, 525, 418, 525, 420, 361, 525, + /* 2960 */ 525, 525, 525, 525, 525, 525, 525, 525, 525, 525, + /* 2970 */ 525, 374, 525, 361, 525, 525, 525, 525, 525, 525, + /* 2980 */ 525, 525, 460, 525, 525, 463, 374, 525, 525, 467, + /* 2990 */ 468, 469, 470, 471, 472, 525, 474, 460, 525, 402, + /* 3000 */ 463, 525, 525, 525, 467, 468, 469, 470, 471, 472, + /* 3010 */ 525, 474, 525, 525, 402, 418, 525, 420, 525, 525, + /* 3020 */ 525, 525, 525, 525, 525, 525, 525, 525, 525, 525, + /* 3030 */ 418, 525, 420, 525, 525, 525, 361, 525, 525, 525, + /* 3040 */ 525, 525, 525, 525, 525, 525, 525, 525, 525, 374, + /* 3050 */ 525, 525, 525, 525, 525, 525, 525, 460, 525, 525, + /* 3060 */ 463, 361, 525, 525, 467, 468, 469, 470, 471, 472, + /* 3070 */ 525, 474, 460, 525, 374, 463, 525, 402, 525, 467, + /* 3080 */ 468, 469, 470, 471, 472, 525, 474, 525, 525, 525, + /* 3090 */ 525, 525, 525, 418, 525, 420, 525, 525, 525, 525, + /* 3100 */ 525, 525, 402, 525, 525, 525, 525, 525, 525, 525, + /* 3110 */ 525, 525, 525, 525, 525, 525, 525, 525, 418, 525, + /* 3120 */ 420, 361, 525, 525, 525, 525, 525, 525, 525, 525, + /* 3130 */ 525, 525, 525, 525, 374, 460, 525, 525, 463, 525, + /* 3140 */ 525, 525, 467, 468, 469, 470, 471, 472, 525, 474, + /* 3150 */ 525, 361, 525, 525, 525, 525, 525, 525, 525, 525, + /* 3160 */ 460, 525, 402, 463, 374, 525, 525, 467, 468, 469, + /* 3170 */ 470, 471, 472, 525, 474, 525, 525, 525, 418, 525, + /* 3180 */ 420, 525, 525, 525, 525, 525, 525, 525, 525, 525, + /* 3190 */ 525, 525, 402, 525, 525, 525, 525, 525, 525, 525, + /* 3200 */ 525, 525, 525, 525, 525, 525, 525, 525, 418, 525, + /* 3210 */ 420, 525, 525, 525, 525, 525, 525, 525, 525, 525, + /* 3220 */ 460, 525, 525, 463, 525, 525, 525, 467, 468, 469, + /* 3230 */ 470, 471, 472, 525, 474, 525, 525, 525, 525, 525, + /* 3240 */ 525, 525, 525, 525, 525, 525, 525, 525, 525, 525, + /* 3250 */ 460, 525, 525, 463, 525, 525, 525, 467, 468, 469, + /* 3260 */ 470, 471, 472, 525, 474, 358, 358, 358, 358, 358, /* 3270 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, /* 3280 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, /* 3290 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, @@ -1246,235 +1259,251 @@ static const YYCODETYPE yy_lookahead[] = { /* 3460 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, /* 3470 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, /* 3480 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, + /* 3490 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, + /* 3500 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, + /* 3510 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, + /* 3520 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, + /* 3530 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, + /* 3540 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, + /* 3550 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, + /* 3560 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, + /* 3570 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, + /* 3580 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, + /* 3590 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, + /* 3600 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, + /* 3610 */ 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, + /* 3620 */ 358, 358, 358, }; -#define YY_SHIFT_COUNT (898) +#define YY_SHIFT_COUNT (903) #define YY_SHIFT_MIN (0) -#define YY_SHIFT_MAX (2547) +#define YY_SHIFT_MAX (2525) static const unsigned short int yy_shift_ofst[] = { /* 0 */ 496, 0, 247, 0, 495, 495, 495, 495, 495, 495, /* 10 */ 495, 495, 495, 495, 495, 495, 742, 989, 989, 1236, /* 20 */ 989, 989, 989, 989, 989, 989, 989, 989, 989, 989, /* 30 */ 989, 989, 989, 989, 989, 989, 989, 989, 989, 989, /* 40 */ 989, 989, 989, 989, 989, 989, 989, 989, 989, 989, - /* 50 */ 32, 94, 740, 677, 47, 568, 47, 47, 677, 677, - /* 60 */ 47, 1267, 47, 246, 1267, 164, 47, 5, 1372, 662, - /* 70 */ 21, 21, 1372, 1372, 45, 45, 662, 282, 290, 613, - /* 80 */ 613, 818, 21, 21, 21, 21, 21, 21, 21, 21, - /* 90 */ 21, 21, 21, 60, 174, 21, 21, 138, 5, 21, - /* 100 */ 60, 21, 5, 21, 21, 5, 21, 21, 5, 21, - /* 110 */ 5, 5, 5, 21, 191, 204, 204, 1243, 572, 430, - /* 120 */ 184, 184, 184, 184, 184, 184, 184, 184, 184, 184, - /* 130 */ 184, 184, 184, 184, 184, 184, 184, 184, 184, 62, - /* 140 */ 330, 282, 290, 1028, 1028, 936, 595, 595, 595, 629, - /* 150 */ 629, 383, 266, 936, 138, 256, 5, 259, 5, 5, - /* 160 */ 5, 371, 5, 371, 371, 406, 504, 1243, 1243, 1243, - /* 170 */ 1243, 1243, 1243, 1243, 1243, 520, 285, 416, 821, 15, - /* 180 */ 190, 244, 177, 825, 838, 395, 395, 329, 854, 620, - /* 190 */ 898, 898, 898, 649, 778, 898, 552, 1192, 1317, 830, - /* 200 */ 890, 1192, 1192, 1197, 1076, 1164, 417, 1076, 1279, 1126, - /* 210 */ 266, 1309, 1541, 1552, 1576, 1379, 138, 1576, 138, 1403, - /* 220 */ 1590, 1592, 1570, 1592, 1570, 1442, 1590, 1592, 1590, 1570, - /* 230 */ 1442, 1442, 1442, 1511, 1550, 1590, 1557, 1590, 1590, 1590, - /* 240 */ 1646, 1618, 1646, 1618, 1576, 138, 138, 1653, 138, 1669, - /* 250 */ 1674, 138, 1669, 138, 1682, 138, 138, 1590, 138, 1646, + /* 50 */ 431, 500, 279, 313, 61, 331, 61, 61, 313, 313, + /* 60 */ 61, 1319, 61, 246, 1319, 207, 61, 5, 1484, 245, + /* 70 */ 68, 68, 1484, 1484, 360, 360, 245, 375, 777, 94, + /* 80 */ 94, 182, 68, 68, 68, 68, 68, 68, 68, 68, + /* 90 */ 68, 68, 68, 122, 281, 68, 68, 67, 5, 68, + /* 100 */ 122, 68, 5, 68, 68, 5, 68, 68, 5, 68, + /* 110 */ 5, 5, 5, 68, 256, 204, 204, 1157, 1242, 572, + /* 120 */ 563, 564, 564, 564, 564, 564, 564, 564, 564, 564, + /* 130 */ 564, 564, 564, 564, 564, 564, 564, 564, 564, 564, + /* 140 */ 1387, 31, 375, 777, 950, 950, 494, 266, 266, 266, + /* 150 */ 581, 581, 708, 800, 494, 67, 196, 5, 128, 5, + /* 160 */ 5, 5, 377, 5, 377, 377, 363, 628, 1157, 1157, + /* 170 */ 1157, 1157, 1157, 1157, 1157, 520, 285, 416, 773, 15, + /* 180 */ 670, 181, 42, 868, 962, 187, 187, 1021, 175, 1071, + /* 190 */ 490, 490, 490, 574, 844, 490, 988, 248, 908, 954, + /* 200 */ 1132, 248, 248, 853, 1074, 516, 212, 1074, 622, 840, + /* 210 */ 800, 1302, 1530, 1544, 1570, 1374, 67, 1570, 67, 1411, + /* 220 */ 1594, 1597, 1577, 1597, 1577, 1448, 1594, 1597, 1594, 1577, + /* 230 */ 1448, 1448, 1448, 1541, 1545, 1594, 1552, 1594, 1594, 1594, + /* 240 */ 1642, 1614, 1642, 1614, 1570, 67, 67, 1650, 67, 1657, + /* 250 */ 1661, 67, 1657, 67, 1664, 67, 67, 1594, 67, 1642, /* 260 */ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, - /* 270 */ 5, 1590, 504, 504, 1646, 371, 371, 371, 1536, 1654, - /* 280 */ 1576, 191, 1744, 1559, 1561, 1653, 191, 1309, 1590, 371, - /* 290 */ 1487, 1489, 1487, 1489, 1498, 1604, 1487, 1506, 1508, 1525, - /* 300 */ 1309, 1510, 1509, 1507, 1546, 1592, 1803, 1707, 1553, 1669, - /* 310 */ 191, 191, 1723, 1489, 371, 371, 371, 371, 1489, 371, - /* 320 */ 1670, 191, 406, 191, 1592, 371, 371, 371, 371, 371, - /* 330 */ 371, 371, 371, 371, 371, 371, 371, 371, 371, 371, - /* 340 */ 371, 371, 371, 371, 371, 371, 371, 1760, 371, 1590, - /* 350 */ 191, 1848, 1852, 1646, 3132, 3132, 3132, 3132, 3132, 3132, - /* 360 */ 3132, 3132, 3132, 3132, 36, 1102, 763, 1110, 581, 899, - /* 370 */ 913, 30, 533, 924, 897, 1045, 810, 810, 810, 810, - /* 380 */ 810, 810, 810, 810, 810, 910, 91, 317, 563, 563, - /* 390 */ 110, 609, 551, 586, 541, 426, 881, 914, 426, 808, - /* 400 */ 988, 1021, 97, 1013, 379, 768, 1013, 1013, 1013, 518, - /* 410 */ 518, 57, 1152, 1311, 1286, 1354, 1190, 1356, 1241, 1278, - /* 420 */ 1280, 1282, 1069, 1247, 1382, 1386, 1401, 1405, 1138, 1308, - /* 430 */ 1325, 659, 1363, 1387, 1389, 1393, 1268, 1111, 1242, 1395, - /* 440 */ 1412, 1399, 1184, 1402, 1357, 1409, 1420, 1423, 1425, 1427, - /* 450 */ 1417, 1432, 1450, 1486, 1496, 1502, 1514, 1524, 1527, 1529, - /* 460 */ 1534, 1436, 1443, 1473, 1483, 1492, 1505, 834, 35, 1365, - /* 470 */ 1517, 1521, 1213, 570, 1910, 1913, 1919, 1875, 1921, 1886, - /* 480 */ 1696, 1889, 1890, 1891, 1702, 1929, 1894, 1895, 1705, 1897, - /* 490 */ 1935, 1709, 1939, 1906, 1944, 1914, 1957, 1931, 1954, 1918, - /* 500 */ 1735, 1960, 1750, 1969, 1761, 1762, 1768, 1772, 1976, 1977, - /* 510 */ 1978, 1780, 1782, 1981, 1983, 1838, 1946, 1948, 1998, 1962, - /* 520 */ 2001, 2002, 1967, 1955, 2005, 1958, 2008, 1964, 2010, 2011, - /* 530 */ 2013, 1965, 2015, 2017, 2018, 2019, 2020, 2021, 1856, 1986, - /* 540 */ 2024, 1859, 2026, 2030, 2031, 2032, 2033, 2034, 2035, 2036, - /* 550 */ 2037, 2038, 2039, 2040, 2041, 2042, 2046, 2047, 2048, 2049, - /* 560 */ 2050, 2003, 2051, 2009, 2053, 2055, 2056, 2057, 2058, 2060, - /* 570 */ 2063, 2064, 2043, 2066, 1920, 2067, 1923, 2071, 1927, 2074, - /* 580 */ 2082, 2062, 2052, 2065, 2069, 2086, 2025, 2054, 2098, 2059, - /* 590 */ 2100, 2061, 2114, 2116, 2068, 2070, 2081, 2106, 2088, 2076, - /* 600 */ 2087, 2107, 2091, 2079, 2092, 2131, 2095, 2133, 2044, 2093, - /* 610 */ 2103, 2094, 2096, 2123, 2097, 2138, 2099, 2102, 2141, 2148, - /* 620 */ 2149, 2150, 2109, 1959, 2154, 2094, 2108, 2155, 2156, 2090, - /* 630 */ 2158, 2159, 2124, 2113, 2134, 2165, 2129, 2122, 2136, 2175, - /* 640 */ 2142, 2130, 2140, 2183, 2147, 2135, 2143, 2187, 2188, 2189, - /* 650 */ 2196, 2199, 2200, 2077, 2078, 2157, 2171, 2201, 2166, 2167, - /* 660 */ 2168, 2169, 2170, 2172, 2173, 2176, 2179, 2181, 2178, 2182, - /* 670 */ 2180, 2184, 2208, 2194, 2220, 2202, 2222, 2203, 2174, 2223, - /* 680 */ 2204, 2192, 2228, 2230, 2231, 2195, 2234, 2205, 2236, 2216, - /* 690 */ 2221, 2206, 2213, 2215, 2145, 2151, 2255, 2080, 2153, 2083, - /* 700 */ 2094, 2212, 2257, 2084, 2225, 2242, 2265, 2075, 2244, 2085, - /* 710 */ 2104, 2269, 2270, 2111, 2101, 2112, 2119, 2268, 2240, 1994, - /* 720 */ 2185, 2193, 2190, 2210, 2239, 2243, 2209, 2227, 2197, 2229, - /* 730 */ 2217, 2211, 2279, 2280, 2214, 2218, 2219, 2224, 2226, 2288, - /* 740 */ 2274, 2275, 2233, 2295, 2072, 2235, 2238, 2285, 2296, 2115, - /* 750 */ 2293, 2298, 2299, 2300, 2301, 2304, 2241, 2245, 2284, 2110, - /* 760 */ 2309, 2302, 2344, 2347, 2251, 2306, 2317, 2254, 2117, 2256, - /* 770 */ 2360, 2341, 2137, 2267, 2271, 2272, 2327, 2277, 2278, 2330, - /* 780 */ 2273, 2364, 2152, 2282, 2283, 2286, 2290, 2291, 2248, 2294, - /* 790 */ 2382, 2345, 2232, 2307, 2297, 2094, 2351, 2311, 2318, 2303, - /* 800 */ 2320, 2321, 2276, 2380, 2387, 2394, 2118, 2323, 2392, 2395, - /* 810 */ 2329, 2335, 2408, 2339, 2340, 2412, 2346, 2343, 2417, 2348, - /* 820 */ 2349, 2419, 2352, 2350, 2423, 2354, 2334, 2336, 2337, 2342, - /* 830 */ 2361, 2434, 2362, 2435, 2367, 2434, 2434, 2449, 2401, 2406, - /* 840 */ 2439, 2441, 2443, 2444, 2445, 2446, 2447, 2448, 2450, 2410, - /* 850 */ 2385, 2411, 2393, 2460, 2458, 2459, 2461, 2475, 2462, 2463, - /* 860 */ 2464, 2424, 2179, 2466, 2181, 2467, 2468, 2472, 2473, 2489, - /* 870 */ 2476, 2512, 2477, 2465, 2478, 2515, 2481, 2470, 2484, 2517, - /* 880 */ 2482, 2479, 2485, 2523, 2491, 2483, 2487, 2531, 2496, 2499, - /* 890 */ 2537, 2525, 2516, 2528, 2524, 2532, 2539, 2547, 2533, + /* 270 */ 5, 1594, 628, 628, 1642, 377, 377, 377, 1494, 1617, + /* 280 */ 1570, 256, 1723, 1539, 1542, 1650, 256, 1302, 1594, 377, + /* 290 */ 1481, 1486, 1481, 1486, 1478, 1586, 1481, 1487, 1491, 1510, + /* 300 */ 1302, 1500, 1490, 1507, 1532, 1597, 1788, 1692, 1534, 1657, + /* 310 */ 256, 256, 1704, 1486, 377, 377, 377, 377, 1486, 377, + /* 320 */ 1636, 256, 363, 256, 1597, 377, 377, 377, 377, 377, + /* 330 */ 377, 377, 377, 377, 377, 377, 377, 377, 377, 377, + /* 340 */ 377, 377, 377, 377, 377, 377, 377, 1731, 377, 1594, + /* 350 */ 256, 1829, 1816, 1642, 3265, 3265, 3265, 3265, 3265, 3265, + /* 360 */ 3265, 3265, 3265, 3265, 36, 1482, 263, 1115, 445, 32, + /* 370 */ 77, 294, 533, 673, 697, 891, 813, 813, 813, 813, + /* 380 */ 813, 813, 813, 813, 813, 1045, 59, 635, 87, 87, + /* 390 */ 124, 468, 643, 369, 465, 347, 698, 739, 347, 561, + /* 400 */ 1000, 1233, 948, 1138, 723, 867, 1138, 1138, 1138, 828, + /* 410 */ 828, 524, 54, 1282, 716, 1291, 1050, 1311, 1216, 1268, + /* 420 */ 1272, 1278, 1314, 1346, 1370, 1389, 1393, 1394, 1038, 1300, + /* 430 */ 1305, 1322, 1363, 1368, 1395, 1397, 1206, 1158, 1264, 1402, + /* 440 */ 1398, 1401, 780, 1403, 1354, 1404, 1405, 1412, 1426, 1427, + /* 450 */ 1409, 1436, 1454, 1502, 1516, 1518, 1528, 1546, 1548, 1550, + /* 460 */ 1555, 1429, 1431, 1471, 1485, 1499, 1513, 992, 1372, 1373, + /* 470 */ 1382, 1392, 1511, 1420, 1866, 1887, 1889, 1847, 1893, 1858, + /* 480 */ 1668, 1860, 1861, 1862, 1674, 1904, 1868, 1869, 1688, 1880, + /* 490 */ 1919, 1693, 1920, 1891, 1931, 1897, 1935, 1914, 1943, 1909, + /* 500 */ 1724, 1948, 1742, 1952, 1743, 1745, 1750, 1755, 1959, 1960, + /* 510 */ 1961, 1763, 1765, 1964, 1966, 1819, 1921, 1922, 1968, 1932, + /* 520 */ 1972, 1974, 1938, 1928, 1980, 1933, 1981, 1939, 1983, 1985, + /* 530 */ 1986, 1941, 1987, 1988, 1992, 1993, 1994, 1995, 1830, 1962, + /* 540 */ 1997, 1832, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, + /* 550 */ 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, + /* 560 */ 2019, 1971, 2021, 1978, 2025, 2026, 2027, 2028, 2029, 2030, + /* 570 */ 2032, 2033, 2024, 2035, 1888, 2037, 1901, 2049, 1905, 2050, + /* 580 */ 2052, 2031, 2006, 2036, 2020, 2054, 1990, 2022, 2057, 1996, + /* 590 */ 2062, 1998, 2065, 2068, 2040, 2034, 2038, 2069, 2045, 2041, + /* 600 */ 2042, 2086, 2053, 2043, 2047, 2087, 2056, 2091, 2055, 2059, + /* 610 */ 2064, 2046, 2060, 2084, 2063, 2099, 2067, 2066, 2103, 2105, + /* 620 */ 2111, 2113, 2072, 1923, 2118, 2046, 2070, 2120, 2122, 2044, + /* 630 */ 2127, 2128, 2092, 2079, 2089, 2132, 2096, 2085, 2093, 2137, + /* 640 */ 2101, 2088, 2102, 2141, 2108, 2097, 2109, 2147, 2150, 2152, + /* 650 */ 2163, 2164, 2166, 2071, 2058, 2130, 2148, 2169, 2144, 2146, + /* 660 */ 2151, 2158, 2160, 2161, 2162, 2165, 2154, 2170, 2168, 2177, + /* 670 */ 2194, 2184, 2222, 2202, 2225, 2204, 2233, 2214, 2131, 2237, + /* 680 */ 2185, 2201, 2239, 2240, 2241, 2205, 2243, 2208, 2246, 2227, + /* 690 */ 2230, 2215, 2216, 2217, 2149, 2153, 2251, 2073, 2155, 2048, + /* 700 */ 2046, 2206, 2259, 2078, 2229, 2242, 2267, 2074, 2248, 2090, + /* 710 */ 2082, 2271, 2272, 2094, 2098, 2095, 2100, 2278, 2250, 1999, + /* 720 */ 2167, 2178, 2180, 2181, 2238, 2247, 2186, 2245, 2191, 2249, + /* 730 */ 2188, 2189, 2265, 2268, 2192, 2195, 2196, 2197, 2198, 2274, + /* 740 */ 2260, 2262, 2211, 2287, 2051, 2213, 2219, 2319, 2290, 2075, + /* 750 */ 2288, 2292, 2293, 2296, 2298, 2299, 2224, 2244, 2275, 2076, + /* 760 */ 2305, 2301, 2339, 2347, 2252, 2309, 2321, 2253, 2104, 2255, + /* 770 */ 2354, 2335, 2124, 2254, 2257, 2256, 2263, 2266, 2276, 2277, + /* 780 */ 2258, 2318, 2279, 2280, 2320, 2264, 2352, 2145, 2281, 2282, + /* 790 */ 2283, 2285, 2286, 2209, 2291, 2389, 2353, 2218, 2294, 2289, + /* 800 */ 2046, 2345, 2297, 2300, 2302, 2304, 2307, 2303, 2380, 2384, + /* 810 */ 2386, 2081, 2308, 2372, 2375, 2310, 2311, 2381, 2314, 2315, + /* 820 */ 2387, 2256, 2317, 2390, 2263, 2322, 2391, 2266, 2323, 2392, + /* 830 */ 2276, 2306, 2312, 2316, 2324, 2325, 2393, 2326, 2399, 2330, + /* 840 */ 2393, 2393, 2416, 2371, 2374, 2417, 2418, 2419, 2421, 2423, + /* 850 */ 2424, 2425, 2427, 2428, 2388, 2366, 2394, 2367, 2436, 2433, + /* 860 */ 2434, 2437, 2451, 2438, 2439, 2441, 2402, 2154, 2445, 2170, + /* 870 */ 2446, 2447, 2448, 2449, 2465, 2452, 2488, 2454, 2442, 2450, + /* 880 */ 2494, 2458, 2461, 2455, 2496, 2463, 2464, 2456, 2501, 2466, + /* 890 */ 2468, 2472, 2505, 2479, 2483, 2525, 2500, 2490, 2504, 2506, + /* 900 */ 2516, 2517, 2519, 2521, }; #define YY_REDUCE_COUNT (363) -#define YY_REDUCE_MIN (-448) -#define YY_REDUCE_MAX (2658) +#define YY_REDUCE_MIN (-450) +#define YY_REDUCE_MAX (2790) static const short yy_reduce_ofst[] = { - /* 0 */ -288, -321, -139, 150, 398, 425, 487, 642, 729, 849, - /* 10 */ 603, 981, 1094, 1171, 1215, 1244, 1274, 1318, 1348, 1377, - /* 20 */ 1479, 1497, 1523, 1610, 1626, 1642, 1701, 1778, 1816, 1837, - /* 30 */ 1898, 1937, 1953, 1971, 2073, 2089, 2105, 2164, 2191, 2246, - /* 40 */ 2305, 2328, 2366, 2389, 2405, 2480, 2507, 2526, 2542, 2658, - /* 50 */ -323, -227, -431, 214, -218, -171, 118, 167, 277, 321, - /* 60 */ 361, 678, -429, -366, -101, -419, 39, -394, -311, -210, - /* 70 */ -326, -314, -302, -190, -368, -78, -282, 127, -413, -5, - /* 80 */ 147, -76, 251, 275, 297, 423, -189, 1, 526, 589, - /* 90 */ 639, 682, 136, 92, 343, 705, 750, 422, -401, 761, - /* 100 */ 270, 765, 452, 783, 786, -202, 800, 831, 621, 879, - /* 110 */ 276, 770, 734, 888, 537, -448, -448, -298, 215, -285, - /* 120 */ 225, 250, 591, 738, 805, 840, 842, 857, 859, 860, - /* 130 */ 868, 893, 904, 906, 908, 909, 921, 922, 929, -347, - /* 140 */ -304, 651, 339, 885, 918, 905, -304, 390, 598, -337, - /* 150 */ -91, 809, -212, 911, 927, 135, 698, 232, 928, -7, - /* 160 */ -391, 456, 933, 561, 886, 696, 941, 181, 316, 370, - /* 170 */ 409, 513, 558, 699, 409, 381, 288, 680, 691, 875, - /* 180 */ 841, 930, 1038, 1044, 1044, 1067, 1077, 1070, 1130, 1082, - /* 190 */ 1019, 1039, 1040, 1108, 1044, 1042, 1178, 1127, 1185, 1150, - /* 200 */ 1120, 1139, 1141, 1044, 1086, 1086, 1068, 1086, 1096, 1087, - /* 210 */ 1193, 1144, 1132, 1135, 1145, 1143, 1217, 1149, 1221, 1162, - /* 220 */ 1238, 1240, 1194, 1245, 1195, 1208, 1263, 1269, 1272, 1223, - /* 230 */ 1224, 1227, 1229, 1271, 1273, 1281, 1276, 1289, 1291, 1292, - /* 240 */ 1301, 1299, 1304, 1302, 1218, 1293, 1296, 1261, 1305, 1315, - /* 250 */ 1253, 1316, 1322, 1319, 1275, 1323, 1334, 1331, 1336, 1341, - /* 260 */ 1321, 1324, 1328, 1329, 1330, 1332, 1337, 1350, 1351, 1352, - /* 270 */ 1353, 1346, 1361, 1392, 1355, 1310, 1340, 1342, 1303, 1307, - /* 280 */ 1313, 1383, 1320, 1326, 1333, 1359, 1390, 1339, 1398, 1358, - /* 290 */ 1287, 1360, 1290, 1362, 1277, 1294, 1297, 1306, 1300, 1312, - /* 300 */ 1364, 1288, 1314, 1335, 1086, 1448, 1367, 1327, 1338, 1453, - /* 310 */ 1455, 1457, 1366, 1406, 1416, 1421, 1435, 1437, 1407, 1438, - /* 320 */ 1428, 1480, 1463, 1484, 1491, 1446, 1449, 1456, 1458, 1459, - /* 330 */ 1460, 1461, 1462, 1465, 1466, 1468, 1469, 1470, 1471, 1472, - /* 340 */ 1474, 1475, 1476, 1477, 1478, 1485, 1488, 1467, 1490, 1499, - /* 350 */ 1500, 1537, 1539, 1535, 1464, 1454, 1481, 1482, 1515, 1516, - /* 360 */ 1518, 1519, 1522, 1545, + /* 0 */ -289, -322, -140, 149, 398, 430, 469, 642, 677, 849, + /* 10 */ 603, 984, 1134, 1164, 1237, 1292, 1324, 1440, 1455, 1470, + /* 20 */ 1571, 1604, 1686, 1705, 1722, 1741, 1760, 1845, 1874, 1908, + /* 30 */ 1979, 2039, 2061, 2116, 2143, 2176, 2207, 2231, 2295, 2369, + /* 40 */ 2398, 2460, 2522, 2537, 2597, 2612, 2675, 2700, 2760, 2790, + /* 50 */ -324, 453, -438, -314, -287, -172, 117, 361, 305, 321, + /* 60 */ 399, 186, -158, -355, -380, 549, 605, -395, -402, -65, + /* 70 */ 205, 646, -234, -94, -315, 243, -333, -130, 295, -213, + /* 80 */ 344, -30, -372, 387, 578, 662, -331, -190, 683, 685, + /* 90 */ 707, 713, 53, 400, 390, 762, 768, 526, 238, 641, + /* 100 */ 474, 786, 297, 795, 802, -394, 816, 823, 796, 826, + /* 110 */ 20, 801, 872, 920, 386, -450, -450, 502, 108, 217, + /* 120 */ -168, -210, 116, 209, 272, 499, 535, 551, 700, 704, + /* 130 */ 754, 832, 846, 847, 854, 907, 934, 935, 937, 939, + /* 140 */ 367, -305, -49, 177, 752, 834, 865, -305, -231, 60, + /* 150 */ -405, 570, 598, -326, 875, 631, -82, -248, 145, 736, + /* 160 */ 406, 268, 444, 901, 787, 884, 909, 941, -398, -392, + /* 170 */ 491, 507, 539, 649, 507, 322, 712, 764, 783, 695, + /* 180 */ 717, 837, 1029, 996, 996, 1017, 1022, 983, 1060, 1002, + /* 190 */ 929, 931, 932, 1005, 996, 957, 1073, 1069, 1128, 1090, + /* 200 */ 1067, 1095, 1119, 996, 1056, 1056, 1037, 1056, 1068, 1066, + /* 210 */ 1177, 1140, 1123, 1126, 1141, 1137, 1217, 1146, 1227, 1165, + /* 220 */ 1243, 1244, 1196, 1251, 1199, 1205, 1257, 1263, 1267, 1214, + /* 230 */ 1218, 1219, 1220, 1261, 1266, 1279, 1275, 1283, 1287, 1288, + /* 240 */ 1297, 1295, 1303, 1301, 1222, 1290, 1296, 1253, 1298, 1304, + /* 250 */ 1238, 1306, 1308, 1309, 1252, 1310, 1313, 1317, 1320, 1330, + /* 260 */ 1299, 1312, 1315, 1323, 1325, 1326, 1327, 1328, 1329, 1331, + /* 270 */ 1332, 1340, 1335, 1339, 1349, 1333, 1336, 1338, 1274, 1289, + /* 280 */ 1293, 1366, 1316, 1307, 1318, 1337, 1369, 1342, 1380, 1347, + /* 290 */ 1270, 1334, 1271, 1343, 1269, 1276, 1277, 1285, 1321, 1344, + /* 300 */ 1359, 1280, 1294, 1345, 1056, 1433, 1351, 1341, 1350, 1438, + /* 310 */ 1435, 1439, 1348, 1384, 1400, 1406, 1407, 1408, 1385, 1410, + /* 320 */ 1414, 1447, 1432, 1453, 1460, 1417, 1418, 1419, 1421, 1423, + /* 330 */ 1425, 1430, 1434, 1437, 1441, 1443, 1445, 1446, 1449, 1450, + /* 340 */ 1451, 1452, 1456, 1458, 1459, 1461, 1462, 1442, 1463, 1477, + /* 350 */ 1473, 1493, 1498, 1505, 1467, 1428, 1457, 1464, 1488, 1489, + /* 360 */ 1474, 1495, 1501, 1527, }; static const YYACTIONTYPE yy_default[] = { - /* 0 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 10 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 20 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 30 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 40 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 50 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 60 */ 2382, 2037, 2037, 2345, 2037, 2037, 2037, 2037, 2037, 2037, - /* 70 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2352, 2037, 2037, - /* 80 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 90 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2136, 2037, 2037, - /* 100 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 110 */ 2037, 2037, 2037, 2037, 2134, 2626, 2037, 2735, 2037, 2037, - /* 120 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 130 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 140 */ 2638, 2037, 2037, 2108, 2108, 2037, 2638, 2638, 2638, 2598, - /* 150 */ 2598, 2134, 2037, 2037, 2136, 2420, 2037, 2037, 2037, 2037, - /* 160 */ 2037, 2037, 2037, 2037, 2037, 2263, 2067, 2037, 2037, 2037, - /* 170 */ 2287, 2037, 2037, 2037, 2037, 2408, 2037, 2037, 2667, 2729, - /* 180 */ 2037, 2670, 2037, 2037, 2037, 2037, 2037, 2357, 2037, 2657, - /* 190 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2212, - /* 200 */ 2402, 2037, 2037, 2037, 2630, 2644, 2713, 2631, 2628, 2651, - /* 210 */ 2037, 2661, 2037, 2445, 2037, 2434, 2136, 2037, 2136, 2395, - /* 220 */ 2340, 2037, 2350, 2037, 2350, 2347, 2037, 2037, 2037, 2350, - /* 230 */ 2347, 2347, 2347, 2201, 2197, 2037, 2195, 2037, 2037, 2037, - /* 240 */ 2037, 2092, 2037, 2092, 2037, 2136, 2136, 2037, 2136, 2037, - /* 250 */ 2037, 2136, 2037, 2136, 2037, 2136, 2136, 2037, 2136, 2037, - /* 260 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 270 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2432, 2418, - /* 280 */ 2037, 2134, 2037, 2406, 2404, 2037, 2134, 2661, 2037, 2037, - /* 290 */ 2683, 2678, 2683, 2678, 2697, 2693, 2683, 2702, 2699, 2663, - /* 300 */ 2661, 2732, 2719, 2715, 2644, 2037, 2037, 2649, 2647, 2037, - /* 310 */ 2134, 2134, 2037, 2678, 2037, 2037, 2037, 2037, 2678, 2037, - /* 320 */ 2037, 2134, 2037, 2134, 2037, 2037, 2037, 2037, 2037, 2037, - /* 330 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 340 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2229, 2037, 2037, - /* 350 */ 2134, 2037, 2076, 2037, 2397, 2423, 2378, 2378, 2266, 2266, - /* 360 */ 2735, 2266, 2137, 2042, 2037, 2037, 2037, 2037, 2037, 2037, - /* 370 */ 2037, 2037, 2037, 2037, 2037, 2037, 2696, 2695, 2550, 2037, - /* 380 */ 2602, 2601, 2600, 2591, 2549, 2225, 2037, 2037, 2548, 2547, - /* 390 */ 2037, 2037, 2037, 2037, 2037, 2216, 2037, 2037, 2238, 2037, - /* 400 */ 2037, 2037, 2037, 2541, 2037, 2037, 2542, 2540, 2539, 2369, - /* 410 */ 2368, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 420 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 430 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2716, 2720, 2037, - /* 440 */ 2627, 2037, 2037, 2037, 2521, 2037, 2037, 2037, 2037, 2037, - /* 450 */ 2489, 2484, 2475, 2466, 2481, 2472, 2460, 2478, 2469, 2457, - /* 460 */ 2454, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 470 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 480 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 490 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 500 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 510 */ 2037, 2037, 2037, 2037, 2037, 2346, 2037, 2037, 2037, 2037, - /* 520 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 530 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 540 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 550 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 560 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 570 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2361, 2037, - /* 580 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 590 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 600 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 610 */ 2081, 2528, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 620 */ 2037, 2037, 2037, 2037, 2037, 2531, 2037, 2037, 2037, 2037, - /* 630 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 640 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 650 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 660 */ 2037, 2037, 2037, 2037, 2037, 2037, 2176, 2175, 2037, 2037, - /* 670 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 680 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 690 */ 2037, 2037, 2037, 2037, 2532, 2037, 2037, 2037, 2037, 2037, - /* 700 */ 2523, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 710 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2712, 2664, 2037, - /* 720 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 730 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 740 */ 2037, 2521, 2037, 2694, 2037, 2037, 2710, 2037, 2714, 2037, - /* 750 */ 2037, 2037, 2037, 2037, 2037, 2037, 2637, 2633, 2037, 2037, - /* 760 */ 2629, 2037, 2037, 2037, 2037, 2037, 2588, 2037, 2037, 2037, - /* 770 */ 2622, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 780 */ 2532, 2037, 2535, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 790 */ 2037, 2037, 2037, 2037, 2037, 2520, 2037, 2573, 2572, 2037, - /* 800 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 810 */ 2260, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 820 */ 2037, 2037, 2037, 2037, 2037, 2037, 2244, 2242, 2241, 2240, - /* 830 */ 2037, 2273, 2037, 2037, 2037, 2269, 2268, 2037, 2037, 2037, - /* 840 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 850 */ 2037, 2037, 2037, 2155, 2037, 2037, 2037, 2037, 2037, 2037, - /* 860 */ 2037, 2037, 2147, 2037, 2146, 2037, 2037, 2037, 2037, 2037, - /* 870 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 880 */ 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, 2037, - /* 890 */ 2037, 2037, 2066, 2037, 2037, 2037, 2037, 2037, 2037, + /* 0 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 10 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 20 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 30 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 40 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 50 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 60 */ 2397, 2048, 2048, 2360, 2048, 2048, 2048, 2048, 2048, 2048, + /* 70 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2367, 2048, 2048, + /* 80 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 90 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2147, 2048, 2048, + /* 100 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 110 */ 2048, 2048, 2048, 2048, 2145, 2642, 2048, 2751, 2048, 2048, + /* 120 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 130 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 140 */ 2048, 2654, 2048, 2048, 2119, 2119, 2048, 2654, 2654, 2654, + /* 150 */ 2614, 2614, 2145, 2048, 2048, 2147, 2435, 2048, 2048, 2048, + /* 160 */ 2048, 2048, 2048, 2048, 2048, 2048, 2278, 2078, 2048, 2048, + /* 170 */ 2048, 2302, 2048, 2048, 2048, 2423, 2048, 2048, 2683, 2745, + /* 180 */ 2048, 2686, 2048, 2048, 2048, 2048, 2048, 2372, 2048, 2673, + /* 190 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2223, + /* 200 */ 2417, 2048, 2048, 2048, 2646, 2660, 2729, 2647, 2644, 2667, + /* 210 */ 2048, 2677, 2048, 2460, 2048, 2449, 2147, 2048, 2147, 2410, + /* 220 */ 2355, 2048, 2365, 2048, 2365, 2362, 2048, 2048, 2048, 2365, + /* 230 */ 2362, 2362, 2362, 2212, 2208, 2048, 2206, 2048, 2048, 2048, + /* 240 */ 2048, 2103, 2048, 2103, 2048, 2147, 2147, 2048, 2147, 2048, + /* 250 */ 2048, 2147, 2048, 2147, 2048, 2147, 2147, 2048, 2147, 2048, + /* 260 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 270 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2447, 2433, + /* 280 */ 2048, 2145, 2048, 2421, 2419, 2048, 2145, 2677, 2048, 2048, + /* 290 */ 2699, 2694, 2699, 2694, 2713, 2709, 2699, 2718, 2715, 2679, + /* 300 */ 2677, 2748, 2735, 2731, 2660, 2048, 2048, 2665, 2663, 2048, + /* 310 */ 2145, 2145, 2048, 2694, 2048, 2048, 2048, 2048, 2694, 2048, + /* 320 */ 2048, 2145, 2048, 2145, 2048, 2048, 2048, 2048, 2048, 2048, + /* 330 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 340 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2240, 2048, 2048, + /* 350 */ 2145, 2048, 2087, 2048, 2412, 2438, 2393, 2393, 2281, 2281, + /* 360 */ 2751, 2281, 2148, 2053, 2048, 2048, 2048, 2048, 2048, 2048, + /* 370 */ 2048, 2048, 2048, 2048, 2048, 2048, 2712, 2711, 2565, 2048, + /* 380 */ 2618, 2617, 2616, 2607, 2564, 2236, 2048, 2048, 2563, 2562, + /* 390 */ 2048, 2048, 2048, 2048, 2048, 2227, 2048, 2048, 2249, 2048, + /* 400 */ 2048, 2048, 2048, 2556, 2048, 2048, 2557, 2555, 2554, 2384, + /* 410 */ 2383, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 420 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 430 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2732, 2736, 2048, + /* 440 */ 2643, 2048, 2048, 2048, 2536, 2048, 2048, 2048, 2048, 2048, + /* 450 */ 2504, 2499, 2490, 2481, 2496, 2487, 2475, 2493, 2484, 2472, + /* 460 */ 2469, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 470 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 480 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 490 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 500 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 510 */ 2048, 2048, 2048, 2048, 2048, 2361, 2048, 2048, 2048, 2048, + /* 520 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 530 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 540 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 550 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 560 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 570 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2376, 2048, + /* 580 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 590 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 600 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 610 */ 2092, 2543, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 620 */ 2048, 2048, 2048, 2048, 2048, 2546, 2048, 2048, 2048, 2048, + /* 630 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 640 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 650 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 660 */ 2048, 2048, 2048, 2048, 2048, 2048, 2187, 2186, 2048, 2048, + /* 670 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 680 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 690 */ 2048, 2048, 2048, 2048, 2547, 2048, 2048, 2048, 2048, 2048, + /* 700 */ 2538, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 710 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2728, 2680, 2048, + /* 720 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 730 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 740 */ 2048, 2536, 2048, 2710, 2048, 2048, 2726, 2048, 2730, 2048, + /* 750 */ 2048, 2048, 2048, 2048, 2048, 2048, 2653, 2649, 2048, 2048, + /* 760 */ 2645, 2048, 2048, 2048, 2048, 2048, 2604, 2048, 2048, 2048, + /* 770 */ 2638, 2048, 2048, 2048, 2048, 2277, 2276, 2275, 2274, 2048, + /* 780 */ 2048, 2048, 2048, 2048, 2048, 2547, 2048, 2550, 2048, 2048, + /* 790 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 800 */ 2535, 2048, 2589, 2588, 2048, 2048, 2048, 2048, 2048, 2048, + /* 810 */ 2048, 2048, 2048, 2048, 2048, 2271, 2048, 2048, 2048, 2048, + /* 820 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 830 */ 2048, 2255, 2253, 2252, 2251, 2048, 2288, 2048, 2048, 2048, + /* 840 */ 2284, 2283, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 850 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2166, 2048, + /* 860 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2158, 2048, 2157, + /* 870 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 880 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, + /* 890 */ 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2077, 2048, 2048, + /* 900 */ 2048, 2048, 2048, 2048, }; /********** End of lemon-generated parsing tables *****************************/ @@ -2354,116 +2383,117 @@ static const char *const yyTokenName[] = { /* 411 */ "tag_def_list", /* 412 */ "tag_def", /* 413 */ "column_def", - /* 414 */ "duration_list", - /* 415 */ "rollup_func_list", - /* 416 */ "alter_table_option", - /* 417 */ "duration_literal", - /* 418 */ "rollup_func_name", - /* 419 */ "function_name", - /* 420 */ "col_name", - /* 421 */ "db_kind_opt", - /* 422 */ "table_kind_db_name_cond_opt", - /* 423 */ "like_pattern_opt", - /* 424 */ "db_name_cond_opt", - /* 425 */ "table_name_cond", - /* 426 */ "from_db_opt", - /* 427 */ "tag_list_opt", - /* 428 */ "table_kind", - /* 429 */ "tag_item", - /* 430 */ "column_alias", - /* 431 */ "index_options", - /* 432 */ "full_index_name", - /* 433 */ "index_name", - /* 434 */ "func_list", - /* 435 */ "sliding_opt", - /* 436 */ "sma_stream_opt", - /* 437 */ "func", - /* 438 */ "sma_func_name", - /* 439 */ "expression_list", - /* 440 */ "with_meta", - /* 441 */ "query_or_subquery", - /* 442 */ "where_clause_opt", - /* 443 */ "cgroup_name", - /* 444 */ "analyze_opt", - /* 445 */ "explain_options", - /* 446 */ "insert_query", - /* 447 */ "or_replace_opt", - /* 448 */ "agg_func_opt", - /* 449 */ "bufsize_opt", - /* 450 */ "language_opt", - /* 451 */ "full_view_name", - /* 452 */ "view_name", - /* 453 */ "stream_name", - /* 454 */ "stream_options", - /* 455 */ "col_list_opt", - /* 456 */ "tag_def_or_ref_opt", - /* 457 */ "subtable_opt", - /* 458 */ "ignore_opt", - /* 459 */ "expression", - /* 460 */ "on_vgroup_id", - /* 461 */ "dnode_list", - /* 462 */ "literal_func", - /* 463 */ "signed_literal", - /* 464 */ "literal_list", - /* 465 */ "table_alias", - /* 466 */ "expr_or_subquery", - /* 467 */ "pseudo_column", - /* 468 */ "column_reference", - /* 469 */ "function_expression", - /* 470 */ "case_when_expression", - /* 471 */ "star_func", - /* 472 */ "star_func_para_list", - /* 473 */ "noarg_func", - /* 474 */ "other_para_list", - /* 475 */ "star_func_para", - /* 476 */ "when_then_list", - /* 477 */ "case_when_else_opt", - /* 478 */ "common_expression", - /* 479 */ "when_then_expr", - /* 480 */ "predicate", - /* 481 */ "compare_op", - /* 482 */ "in_op", - /* 483 */ "in_predicate_value", - /* 484 */ "boolean_value_expression", - /* 485 */ "boolean_primary", - /* 486 */ "from_clause_opt", - /* 487 */ "table_reference_list", - /* 488 */ "table_reference", - /* 489 */ "table_primary", - /* 490 */ "joined_table", - /* 491 */ "alias_opt", - /* 492 */ "subquery", - /* 493 */ "parenthesized_joined_table", - /* 494 */ "join_type", - /* 495 */ "query_specification", - /* 496 */ "hint_list", - /* 497 */ "set_quantifier_opt", - /* 498 */ "tag_mode_opt", - /* 499 */ "select_list", - /* 500 */ "partition_by_clause_opt", - /* 501 */ "range_opt", - /* 502 */ "every_opt", - /* 503 */ "fill_opt", - /* 504 */ "twindow_clause_opt", - /* 505 */ "group_by_clause_opt", - /* 506 */ "having_clause_opt", - /* 507 */ "select_item", - /* 508 */ "partition_list", - /* 509 */ "partition_item", - /* 510 */ "interval_sliding_duration_literal", - /* 511 */ "fill_mode", - /* 512 */ "group_by_list", - /* 513 */ "query_expression", - /* 514 */ "query_simple", - /* 515 */ "order_by_clause_opt", - /* 516 */ "slimit_clause_opt", - /* 517 */ "limit_clause_opt", - /* 518 */ "union_query_expression", - /* 519 */ "query_simple_or_subquery", - /* 520 */ "sort_specification_list", - /* 521 */ "sort_specification", - /* 522 */ "ordering_specification_opt", - /* 523 */ "null_ordering_opt", + /* 414 */ "type_name_default_len", + /* 415 */ "duration_list", + /* 416 */ "rollup_func_list", + /* 417 */ "alter_table_option", + /* 418 */ "duration_literal", + /* 419 */ "rollup_func_name", + /* 420 */ "function_name", + /* 421 */ "col_name", + /* 422 */ "db_kind_opt", + /* 423 */ "table_kind_db_name_cond_opt", + /* 424 */ "like_pattern_opt", + /* 425 */ "db_name_cond_opt", + /* 426 */ "table_name_cond", + /* 427 */ "from_db_opt", + /* 428 */ "tag_list_opt", + /* 429 */ "table_kind", + /* 430 */ "tag_item", + /* 431 */ "column_alias", + /* 432 */ "index_options", + /* 433 */ "full_index_name", + /* 434 */ "index_name", + /* 435 */ "func_list", + /* 436 */ "sliding_opt", + /* 437 */ "sma_stream_opt", + /* 438 */ "func", + /* 439 */ "sma_func_name", + /* 440 */ "expression_list", + /* 441 */ "with_meta", + /* 442 */ "query_or_subquery", + /* 443 */ "where_clause_opt", + /* 444 */ "cgroup_name", + /* 445 */ "analyze_opt", + /* 446 */ "explain_options", + /* 447 */ "insert_query", + /* 448 */ "or_replace_opt", + /* 449 */ "agg_func_opt", + /* 450 */ "bufsize_opt", + /* 451 */ "language_opt", + /* 452 */ "full_view_name", + /* 453 */ "view_name", + /* 454 */ "stream_name", + /* 455 */ "stream_options", + /* 456 */ "col_list_opt", + /* 457 */ "tag_def_or_ref_opt", + /* 458 */ "subtable_opt", + /* 459 */ "ignore_opt", + /* 460 */ "expression", + /* 461 */ "on_vgroup_id", + /* 462 */ "dnode_list", + /* 463 */ "literal_func", + /* 464 */ "signed_literal", + /* 465 */ "literal_list", + /* 466 */ "table_alias", + /* 467 */ "expr_or_subquery", + /* 468 */ "pseudo_column", + /* 469 */ "column_reference", + /* 470 */ "function_expression", + /* 471 */ "case_when_expression", + /* 472 */ "star_func", + /* 473 */ "star_func_para_list", + /* 474 */ "noarg_func", + /* 475 */ "other_para_list", + /* 476 */ "star_func_para", + /* 477 */ "when_then_list", + /* 478 */ "case_when_else_opt", + /* 479 */ "common_expression", + /* 480 */ "when_then_expr", + /* 481 */ "predicate", + /* 482 */ "compare_op", + /* 483 */ "in_op", + /* 484 */ "in_predicate_value", + /* 485 */ "boolean_value_expression", + /* 486 */ "boolean_primary", + /* 487 */ "from_clause_opt", + /* 488 */ "table_reference_list", + /* 489 */ "table_reference", + /* 490 */ "table_primary", + /* 491 */ "joined_table", + /* 492 */ "alias_opt", + /* 493 */ "subquery", + /* 494 */ "parenthesized_joined_table", + /* 495 */ "join_type", + /* 496 */ "query_specification", + /* 497 */ "hint_list", + /* 498 */ "set_quantifier_opt", + /* 499 */ "tag_mode_opt", + /* 500 */ "select_list", + /* 501 */ "partition_by_clause_opt", + /* 502 */ "range_opt", + /* 503 */ "every_opt", + /* 504 */ "fill_opt", + /* 505 */ "twindow_clause_opt", + /* 506 */ "group_by_clause_opt", + /* 507 */ "having_clause_opt", + /* 508 */ "select_item", + /* 509 */ "partition_list", + /* 510 */ "partition_item", + /* 511 */ "interval_sliding_duration_literal", + /* 512 */ "fill_mode", + /* 513 */ "group_by_list", + /* 514 */ "query_expression", + /* 515 */ "query_simple", + /* 516 */ "order_by_clause_opt", + /* 517 */ "slimit_clause_opt", + /* 518 */ "limit_clause_opt", + /* 519 */ "union_query_expression", + /* 520 */ "query_simple_or_subquery", + /* 521 */ "sort_specification_list", + /* 522 */ "sort_specification", + /* 523 */ "ordering_specification_opt", + /* 524 */ "null_ordering_opt", }; #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */ @@ -2694,483 +2724,488 @@ static const char *const yyRuleName[] = { /* 220 */ "type_name ::= DECIMAL", /* 221 */ "type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP", /* 222 */ "type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP", - /* 223 */ "tags_def_opt ::=", - /* 224 */ "tags_def_opt ::= tags_def", - /* 225 */ "tags_def ::= TAGS NK_LP tag_def_list NK_RP", - /* 226 */ "table_options ::=", - /* 227 */ "table_options ::= table_options COMMENT NK_STRING", - /* 228 */ "table_options ::= table_options MAX_DELAY duration_list", - /* 229 */ "table_options ::= table_options WATERMARK duration_list", - /* 230 */ "table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP", - /* 231 */ "table_options ::= table_options TTL NK_INTEGER", - /* 232 */ "table_options ::= table_options SMA NK_LP col_name_list NK_RP", - /* 233 */ "table_options ::= table_options DELETE_MARK duration_list", - /* 234 */ "alter_table_options ::= alter_table_option", - /* 235 */ "alter_table_options ::= alter_table_options alter_table_option", - /* 236 */ "alter_table_option ::= COMMENT NK_STRING", - /* 237 */ "alter_table_option ::= TTL NK_INTEGER", - /* 238 */ "duration_list ::= duration_literal", - /* 239 */ "duration_list ::= duration_list NK_COMMA duration_literal", - /* 240 */ "rollup_func_list ::= rollup_func_name", - /* 241 */ "rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name", - /* 242 */ "rollup_func_name ::= function_name", - /* 243 */ "rollup_func_name ::= FIRST", - /* 244 */ "rollup_func_name ::= LAST", - /* 245 */ "col_name_list ::= col_name", - /* 246 */ "col_name_list ::= col_name_list NK_COMMA col_name", - /* 247 */ "col_name ::= column_name", - /* 248 */ "cmd ::= SHOW DNODES", - /* 249 */ "cmd ::= SHOW USERS", - /* 250 */ "cmd ::= SHOW USER PRIVILEGES", - /* 251 */ "cmd ::= SHOW db_kind_opt DATABASES", - /* 252 */ "cmd ::= SHOW table_kind_db_name_cond_opt TABLES like_pattern_opt", - /* 253 */ "cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt", - /* 254 */ "cmd ::= SHOW db_name_cond_opt VGROUPS", - /* 255 */ "cmd ::= SHOW MNODES", - /* 256 */ "cmd ::= SHOW QNODES", - /* 257 */ "cmd ::= SHOW ARBGROUPS", - /* 258 */ "cmd ::= SHOW FUNCTIONS", - /* 259 */ "cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt", - /* 260 */ "cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name", - /* 261 */ "cmd ::= SHOW STREAMS", - /* 262 */ "cmd ::= SHOW ACCOUNTS", - /* 263 */ "cmd ::= SHOW APPS", - /* 264 */ "cmd ::= SHOW CONNECTIONS", - /* 265 */ "cmd ::= SHOW LICENCES", - /* 266 */ "cmd ::= SHOW GRANTS", - /* 267 */ "cmd ::= SHOW GRANTS FULL", - /* 268 */ "cmd ::= SHOW GRANTS LOGS", - /* 269 */ "cmd ::= SHOW CLUSTER MACHINES", - /* 270 */ "cmd ::= SHOW CREATE DATABASE db_name", - /* 271 */ "cmd ::= SHOW CREATE TABLE full_table_name", - /* 272 */ "cmd ::= SHOW CREATE STABLE full_table_name", - /* 273 */ "cmd ::= SHOW QUERIES", - /* 274 */ "cmd ::= SHOW SCORES", - /* 275 */ "cmd ::= SHOW TOPICS", - /* 276 */ "cmd ::= SHOW VARIABLES", - /* 277 */ "cmd ::= SHOW CLUSTER VARIABLES", - /* 278 */ "cmd ::= SHOW LOCAL VARIABLES", - /* 279 */ "cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt", - /* 280 */ "cmd ::= SHOW BNODES", - /* 281 */ "cmd ::= SHOW SNODES", - /* 282 */ "cmd ::= SHOW CLUSTER", - /* 283 */ "cmd ::= SHOW TRANSACTIONS", - /* 284 */ "cmd ::= SHOW TABLE DISTRIBUTED full_table_name", - /* 285 */ "cmd ::= SHOW CONSUMERS", - /* 286 */ "cmd ::= SHOW SUBSCRIPTIONS", - /* 287 */ "cmd ::= SHOW TAGS FROM table_name_cond from_db_opt", - /* 288 */ "cmd ::= SHOW TAGS FROM db_name NK_DOT table_name", - /* 289 */ "cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt", - /* 290 */ "cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name", - /* 291 */ "cmd ::= SHOW VNODES ON DNODE NK_INTEGER", - /* 292 */ "cmd ::= SHOW VNODES", - /* 293 */ "cmd ::= SHOW db_name_cond_opt ALIVE", - /* 294 */ "cmd ::= SHOW CLUSTER ALIVE", - /* 295 */ "cmd ::= SHOW db_name_cond_opt VIEWS like_pattern_opt", - /* 296 */ "cmd ::= SHOW CREATE VIEW full_table_name", - /* 297 */ "cmd ::= SHOW COMPACTS", - /* 298 */ "cmd ::= SHOW COMPACT NK_INTEGER", - /* 299 */ "table_kind_db_name_cond_opt ::=", - /* 300 */ "table_kind_db_name_cond_opt ::= table_kind", - /* 301 */ "table_kind_db_name_cond_opt ::= db_name NK_DOT", - /* 302 */ "table_kind_db_name_cond_opt ::= table_kind db_name NK_DOT", - /* 303 */ "table_kind ::= NORMAL", - /* 304 */ "table_kind ::= CHILD", - /* 305 */ "db_name_cond_opt ::=", - /* 306 */ "db_name_cond_opt ::= db_name NK_DOT", - /* 307 */ "like_pattern_opt ::=", - /* 308 */ "like_pattern_opt ::= LIKE NK_STRING", - /* 309 */ "table_name_cond ::= table_name", - /* 310 */ "from_db_opt ::=", - /* 311 */ "from_db_opt ::= FROM db_name", - /* 312 */ "tag_list_opt ::=", - /* 313 */ "tag_list_opt ::= tag_item", - /* 314 */ "tag_list_opt ::= tag_list_opt NK_COMMA tag_item", - /* 315 */ "tag_item ::= TBNAME", - /* 316 */ "tag_item ::= QTAGS", - /* 317 */ "tag_item ::= column_name", - /* 318 */ "tag_item ::= column_name column_alias", - /* 319 */ "tag_item ::= column_name AS column_alias", - /* 320 */ "db_kind_opt ::=", - /* 321 */ "db_kind_opt ::= USER", - /* 322 */ "db_kind_opt ::= SYSTEM", - /* 323 */ "cmd ::= CREATE SMA INDEX not_exists_opt col_name ON full_table_name index_options", - /* 324 */ "cmd ::= CREATE INDEX not_exists_opt col_name ON full_table_name NK_LP col_name_list NK_RP", - /* 325 */ "cmd ::= DROP INDEX exists_opt full_index_name", - /* 326 */ "full_index_name ::= index_name", - /* 327 */ "full_index_name ::= db_name NK_DOT index_name", - /* 328 */ "index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt", - /* 329 */ "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", - /* 330 */ "func_list ::= func", - /* 331 */ "func_list ::= func_list NK_COMMA func", - /* 332 */ "func ::= sma_func_name NK_LP expression_list NK_RP", - /* 333 */ "sma_func_name ::= function_name", - /* 334 */ "sma_func_name ::= COUNT", - /* 335 */ "sma_func_name ::= FIRST", - /* 336 */ "sma_func_name ::= LAST", - /* 337 */ "sma_func_name ::= LAST_ROW", - /* 338 */ "sma_stream_opt ::=", - /* 339 */ "sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal", - /* 340 */ "sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal", - /* 341 */ "sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal", - /* 342 */ "with_meta ::= AS", - /* 343 */ "with_meta ::= WITH META AS", - /* 344 */ "with_meta ::= ONLY META AS", - /* 345 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery", - /* 346 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name", - /* 347 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt", - /* 348 */ "cmd ::= DROP TOPIC exists_opt topic_name", - /* 349 */ "cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name", - /* 350 */ "cmd ::= DESC full_table_name", - /* 351 */ "cmd ::= DESCRIBE full_table_name", - /* 352 */ "cmd ::= RESET QUERY CACHE", - /* 353 */ "cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery", - /* 354 */ "cmd ::= EXPLAIN analyze_opt explain_options insert_query", - /* 355 */ "analyze_opt ::=", - /* 356 */ "analyze_opt ::= ANALYZE", - /* 357 */ "explain_options ::=", - /* 358 */ "explain_options ::= explain_options VERBOSE NK_BOOL", - /* 359 */ "explain_options ::= explain_options RATIO NK_FLOAT", - /* 360 */ "cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt", - /* 361 */ "cmd ::= DROP FUNCTION exists_opt function_name", - /* 362 */ "agg_func_opt ::=", - /* 363 */ "agg_func_opt ::= AGGREGATE", - /* 364 */ "bufsize_opt ::=", - /* 365 */ "bufsize_opt ::= BUFSIZE NK_INTEGER", - /* 366 */ "language_opt ::=", - /* 367 */ "language_opt ::= LANGUAGE NK_STRING", - /* 368 */ "or_replace_opt ::=", - /* 369 */ "or_replace_opt ::= OR REPLACE", - /* 370 */ "cmd ::= CREATE or_replace_opt VIEW full_view_name AS query_or_subquery", - /* 371 */ "cmd ::= DROP VIEW exists_opt full_view_name", - /* 372 */ "full_view_name ::= view_name", - /* 373 */ "full_view_name ::= db_name NK_DOT view_name", - /* 374 */ "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", - /* 375 */ "cmd ::= DROP STREAM exists_opt stream_name", - /* 376 */ "cmd ::= PAUSE STREAM exists_opt stream_name", - /* 377 */ "cmd ::= RESUME STREAM exists_opt ignore_opt stream_name", - /* 378 */ "col_list_opt ::=", - /* 379 */ "col_list_opt ::= NK_LP col_name_list NK_RP", - /* 380 */ "tag_def_or_ref_opt ::=", - /* 381 */ "tag_def_or_ref_opt ::= tags_def", - /* 382 */ "tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP", - /* 383 */ "stream_options ::=", - /* 384 */ "stream_options ::= stream_options TRIGGER AT_ONCE", - /* 385 */ "stream_options ::= stream_options TRIGGER WINDOW_CLOSE", - /* 386 */ "stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal", - /* 387 */ "stream_options ::= stream_options WATERMARK duration_literal", - /* 388 */ "stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER", - /* 389 */ "stream_options ::= stream_options FILL_HISTORY NK_INTEGER", - /* 390 */ "stream_options ::= stream_options DELETE_MARK duration_literal", - /* 391 */ "stream_options ::= stream_options IGNORE UPDATE NK_INTEGER", - /* 392 */ "subtable_opt ::=", - /* 393 */ "subtable_opt ::= SUBTABLE NK_LP expression NK_RP", - /* 394 */ "ignore_opt ::=", - /* 395 */ "ignore_opt ::= IGNORE UNTREATED", - /* 396 */ "cmd ::= KILL CONNECTION NK_INTEGER", - /* 397 */ "cmd ::= KILL QUERY NK_STRING", - /* 398 */ "cmd ::= KILL TRANSACTION NK_INTEGER", - /* 399 */ "cmd ::= KILL COMPACT NK_INTEGER", - /* 400 */ "cmd ::= BALANCE VGROUP", - /* 401 */ "cmd ::= BALANCE VGROUP LEADER on_vgroup_id", - /* 402 */ "cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER", - /* 403 */ "cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list", - /* 404 */ "cmd ::= SPLIT VGROUP NK_INTEGER", - /* 405 */ "on_vgroup_id ::=", - /* 406 */ "on_vgroup_id ::= ON NK_INTEGER", - /* 407 */ "dnode_list ::= DNODE NK_INTEGER", - /* 408 */ "dnode_list ::= dnode_list DNODE NK_INTEGER", - /* 409 */ "cmd ::= DELETE FROM full_table_name where_clause_opt", - /* 410 */ "cmd ::= query_or_subquery", - /* 411 */ "cmd ::= insert_query", - /* 412 */ "insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery", - /* 413 */ "insert_query ::= INSERT INTO full_table_name query_or_subquery", - /* 414 */ "tags_literal ::= NK_INTEGER", - /* 415 */ "tags_literal ::= NK_INTEGER NK_PLUS duration_literal", - /* 416 */ "tags_literal ::= NK_INTEGER NK_MINUS duration_literal", - /* 417 */ "tags_literal ::= NK_PLUS NK_INTEGER", - /* 418 */ "tags_literal ::= NK_PLUS NK_INTEGER NK_PLUS duration_literal", - /* 419 */ "tags_literal ::= NK_PLUS NK_INTEGER NK_MINUS duration_literal", - /* 420 */ "tags_literal ::= NK_MINUS NK_INTEGER", - /* 421 */ "tags_literal ::= NK_MINUS NK_INTEGER NK_PLUS duration_literal", - /* 422 */ "tags_literal ::= NK_MINUS NK_INTEGER NK_MINUS duration_literal", - /* 423 */ "tags_literal ::= NK_FLOAT", - /* 424 */ "tags_literal ::= NK_PLUS NK_FLOAT", - /* 425 */ "tags_literal ::= NK_MINUS NK_FLOAT", - /* 426 */ "tags_literal ::= NK_BIN", - /* 427 */ "tags_literal ::= NK_BIN NK_PLUS duration_literal", - /* 428 */ "tags_literal ::= NK_BIN NK_MINUS duration_literal", - /* 429 */ "tags_literal ::= NK_PLUS NK_BIN", - /* 430 */ "tags_literal ::= NK_PLUS NK_BIN NK_PLUS duration_literal", - /* 431 */ "tags_literal ::= NK_PLUS NK_BIN NK_MINUS duration_literal", - /* 432 */ "tags_literal ::= NK_MINUS NK_BIN", - /* 433 */ "tags_literal ::= NK_MINUS NK_BIN NK_PLUS duration_literal", - /* 434 */ "tags_literal ::= NK_MINUS NK_BIN NK_MINUS duration_literal", - /* 435 */ "tags_literal ::= NK_HEX", - /* 436 */ "tags_literal ::= NK_HEX NK_PLUS duration_literal", - /* 437 */ "tags_literal ::= NK_HEX NK_MINUS duration_literal", - /* 438 */ "tags_literal ::= NK_PLUS NK_HEX", - /* 439 */ "tags_literal ::= NK_PLUS NK_HEX NK_PLUS duration_literal", - /* 440 */ "tags_literal ::= NK_PLUS NK_HEX NK_MINUS duration_literal", - /* 441 */ "tags_literal ::= NK_MINUS NK_HEX", - /* 442 */ "tags_literal ::= NK_MINUS NK_HEX NK_PLUS duration_literal", - /* 443 */ "tags_literal ::= NK_MINUS NK_HEX NK_MINUS duration_literal", - /* 444 */ "tags_literal ::= NK_STRING", - /* 445 */ "tags_literal ::= NK_STRING NK_PLUS duration_literal", - /* 446 */ "tags_literal ::= NK_STRING NK_MINUS duration_literal", - /* 447 */ "tags_literal ::= NK_BOOL", - /* 448 */ "tags_literal ::= NULL", - /* 449 */ "tags_literal ::= literal_func", - /* 450 */ "tags_literal ::= literal_func NK_PLUS duration_literal", - /* 451 */ "tags_literal ::= literal_func NK_MINUS duration_literal", - /* 452 */ "tags_literal_list ::= tags_literal", - /* 453 */ "tags_literal_list ::= tags_literal_list NK_COMMA tags_literal", - /* 454 */ "literal ::= NK_INTEGER", - /* 455 */ "literal ::= NK_FLOAT", - /* 456 */ "literal ::= NK_STRING", - /* 457 */ "literal ::= NK_BOOL", - /* 458 */ "literal ::= TIMESTAMP NK_STRING", - /* 459 */ "literal ::= duration_literal", - /* 460 */ "literal ::= NULL", - /* 461 */ "literal ::= NK_QUESTION", - /* 462 */ "duration_literal ::= NK_VARIABLE", - /* 463 */ "signed ::= NK_INTEGER", - /* 464 */ "signed ::= NK_PLUS NK_INTEGER", - /* 465 */ "signed ::= NK_MINUS NK_INTEGER", - /* 466 */ "signed ::= NK_FLOAT", - /* 467 */ "signed ::= NK_PLUS NK_FLOAT", - /* 468 */ "signed ::= NK_MINUS NK_FLOAT", - /* 469 */ "signed_literal ::= signed", - /* 470 */ "signed_literal ::= NK_STRING", - /* 471 */ "signed_literal ::= NK_BOOL", - /* 472 */ "signed_literal ::= TIMESTAMP NK_STRING", - /* 473 */ "signed_literal ::= duration_literal", - /* 474 */ "signed_literal ::= NULL", - /* 475 */ "signed_literal ::= literal_func", - /* 476 */ "signed_literal ::= NK_QUESTION", - /* 477 */ "literal_list ::= signed_literal", - /* 478 */ "literal_list ::= literal_list NK_COMMA signed_literal", - /* 479 */ "db_name ::= NK_ID", - /* 480 */ "table_name ::= NK_ID", - /* 481 */ "column_name ::= NK_ID", - /* 482 */ "function_name ::= NK_ID", - /* 483 */ "view_name ::= NK_ID", - /* 484 */ "table_alias ::= NK_ID", - /* 485 */ "column_alias ::= NK_ID", - /* 486 */ "column_alias ::= NK_ALIAS", - /* 487 */ "user_name ::= NK_ID", - /* 488 */ "topic_name ::= NK_ID", - /* 489 */ "stream_name ::= NK_ID", - /* 490 */ "cgroup_name ::= NK_ID", - /* 491 */ "index_name ::= NK_ID", - /* 492 */ "expr_or_subquery ::= expression", - /* 493 */ "expression ::= literal", - /* 494 */ "expression ::= pseudo_column", - /* 495 */ "expression ::= column_reference", - /* 496 */ "expression ::= function_expression", - /* 497 */ "expression ::= case_when_expression", - /* 498 */ "expression ::= NK_LP expression NK_RP", - /* 499 */ "expression ::= NK_PLUS expr_or_subquery", - /* 500 */ "expression ::= NK_MINUS expr_or_subquery", - /* 501 */ "expression ::= expr_or_subquery NK_PLUS expr_or_subquery", - /* 502 */ "expression ::= expr_or_subquery NK_MINUS expr_or_subquery", - /* 503 */ "expression ::= expr_or_subquery NK_STAR expr_or_subquery", - /* 504 */ "expression ::= expr_or_subquery NK_SLASH expr_or_subquery", - /* 505 */ "expression ::= expr_or_subquery NK_REM expr_or_subquery", - /* 506 */ "expression ::= column_reference NK_ARROW NK_STRING", - /* 507 */ "expression ::= expr_or_subquery NK_BITAND expr_or_subquery", - /* 508 */ "expression ::= expr_or_subquery NK_BITOR expr_or_subquery", - /* 509 */ "expression_list ::= expr_or_subquery", - /* 510 */ "expression_list ::= expression_list NK_COMMA expr_or_subquery", - /* 511 */ "column_reference ::= column_name", - /* 512 */ "column_reference ::= table_name NK_DOT column_name", - /* 513 */ "column_reference ::= NK_ALIAS", - /* 514 */ "column_reference ::= table_name NK_DOT NK_ALIAS", - /* 515 */ "pseudo_column ::= ROWTS", - /* 516 */ "pseudo_column ::= TBNAME", - /* 517 */ "pseudo_column ::= table_name NK_DOT TBNAME", - /* 518 */ "pseudo_column ::= QSTART", - /* 519 */ "pseudo_column ::= QEND", - /* 520 */ "pseudo_column ::= QDURATION", - /* 521 */ "pseudo_column ::= WSTART", - /* 522 */ "pseudo_column ::= WEND", - /* 523 */ "pseudo_column ::= WDURATION", - /* 524 */ "pseudo_column ::= IROWTS", - /* 525 */ "pseudo_column ::= ISFILLED", - /* 526 */ "pseudo_column ::= QTAGS", - /* 527 */ "function_expression ::= function_name NK_LP expression_list NK_RP", - /* 528 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP", - /* 529 */ "function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP", - /* 530 */ "function_expression ::= literal_func", - /* 531 */ "literal_func ::= noarg_func NK_LP NK_RP", - /* 532 */ "literal_func ::= NOW", - /* 533 */ "literal_func ::= TODAY", - /* 534 */ "noarg_func ::= NOW", - /* 535 */ "noarg_func ::= TODAY", - /* 536 */ "noarg_func ::= TIMEZONE", - /* 537 */ "noarg_func ::= DATABASE", - /* 538 */ "noarg_func ::= CLIENT_VERSION", - /* 539 */ "noarg_func ::= SERVER_VERSION", - /* 540 */ "noarg_func ::= SERVER_STATUS", - /* 541 */ "noarg_func ::= CURRENT_USER", - /* 542 */ "noarg_func ::= USER", - /* 543 */ "star_func ::= COUNT", - /* 544 */ "star_func ::= FIRST", - /* 545 */ "star_func ::= LAST", - /* 546 */ "star_func ::= LAST_ROW", - /* 547 */ "star_func_para_list ::= NK_STAR", - /* 548 */ "star_func_para_list ::= other_para_list", - /* 549 */ "other_para_list ::= star_func_para", - /* 550 */ "other_para_list ::= other_para_list NK_COMMA star_func_para", - /* 551 */ "star_func_para ::= expr_or_subquery", - /* 552 */ "star_func_para ::= table_name NK_DOT NK_STAR", - /* 553 */ "case_when_expression ::= CASE when_then_list case_when_else_opt END", - /* 554 */ "case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END", - /* 555 */ "when_then_list ::= when_then_expr", - /* 556 */ "when_then_list ::= when_then_list when_then_expr", - /* 557 */ "when_then_expr ::= WHEN common_expression THEN common_expression", - /* 558 */ "case_when_else_opt ::=", - /* 559 */ "case_when_else_opt ::= ELSE common_expression", - /* 560 */ "predicate ::= expr_or_subquery compare_op expr_or_subquery", - /* 561 */ "predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery", - /* 562 */ "predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery", - /* 563 */ "predicate ::= expr_or_subquery IS NULL", - /* 564 */ "predicate ::= expr_or_subquery IS NOT NULL", - /* 565 */ "predicate ::= expr_or_subquery in_op in_predicate_value", - /* 566 */ "compare_op ::= NK_LT", - /* 567 */ "compare_op ::= NK_GT", - /* 568 */ "compare_op ::= NK_LE", - /* 569 */ "compare_op ::= NK_GE", - /* 570 */ "compare_op ::= NK_NE", - /* 571 */ "compare_op ::= NK_EQ", - /* 572 */ "compare_op ::= LIKE", - /* 573 */ "compare_op ::= NOT LIKE", - /* 574 */ "compare_op ::= MATCH", - /* 575 */ "compare_op ::= NMATCH", - /* 576 */ "compare_op ::= CONTAINS", - /* 577 */ "in_op ::= IN", - /* 578 */ "in_op ::= NOT IN", - /* 579 */ "in_predicate_value ::= NK_LP literal_list NK_RP", - /* 580 */ "boolean_value_expression ::= boolean_primary", - /* 581 */ "boolean_value_expression ::= NOT boolean_primary", - /* 582 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression", - /* 583 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression", - /* 584 */ "boolean_primary ::= predicate", - /* 585 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP", - /* 586 */ "common_expression ::= expr_or_subquery", - /* 587 */ "common_expression ::= boolean_value_expression", - /* 588 */ "from_clause_opt ::=", - /* 589 */ "from_clause_opt ::= FROM table_reference_list", - /* 590 */ "table_reference_list ::= table_reference", - /* 591 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference", - /* 592 */ "table_reference ::= table_primary", - /* 593 */ "table_reference ::= joined_table", - /* 594 */ "table_primary ::= table_name alias_opt", - /* 595 */ "table_primary ::= db_name NK_DOT table_name alias_opt", - /* 596 */ "table_primary ::= subquery alias_opt", - /* 597 */ "table_primary ::= parenthesized_joined_table", - /* 598 */ "alias_opt ::=", - /* 599 */ "alias_opt ::= table_alias", - /* 600 */ "alias_opt ::= AS table_alias", - /* 601 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP", - /* 602 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP", - /* 603 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition", - /* 604 */ "join_type ::=", - /* 605 */ "join_type ::= INNER", - /* 606 */ "query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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", - /* 607 */ "hint_list ::=", - /* 608 */ "hint_list ::= NK_HINT", - /* 609 */ "tag_mode_opt ::=", - /* 610 */ "tag_mode_opt ::= TAGS", - /* 611 */ "set_quantifier_opt ::=", - /* 612 */ "set_quantifier_opt ::= DISTINCT", - /* 613 */ "set_quantifier_opt ::= ALL", - /* 614 */ "select_list ::= select_item", - /* 615 */ "select_list ::= select_list NK_COMMA select_item", - /* 616 */ "select_item ::= NK_STAR", - /* 617 */ "select_item ::= common_expression", - /* 618 */ "select_item ::= common_expression column_alias", - /* 619 */ "select_item ::= common_expression AS column_alias", - /* 620 */ "select_item ::= table_name NK_DOT NK_STAR", - /* 621 */ "where_clause_opt ::=", - /* 622 */ "where_clause_opt ::= WHERE search_condition", - /* 623 */ "partition_by_clause_opt ::=", - /* 624 */ "partition_by_clause_opt ::= PARTITION BY partition_list", - /* 625 */ "partition_list ::= partition_item", - /* 626 */ "partition_list ::= partition_list NK_COMMA partition_item", - /* 627 */ "partition_item ::= expr_or_subquery", - /* 628 */ "partition_item ::= expr_or_subquery column_alias", - /* 629 */ "partition_item ::= expr_or_subquery AS column_alias", - /* 630 */ "twindow_clause_opt ::=", - /* 631 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP", - /* 632 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP", - /* 633 */ "twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt", - /* 634 */ "twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt", - /* 635 */ "twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition", - /* 636 */ "twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_RP", - /* 637 */ "twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP", - /* 638 */ "sliding_opt ::=", - /* 639 */ "sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP", - /* 640 */ "interval_sliding_duration_literal ::= NK_VARIABLE", - /* 641 */ "interval_sliding_duration_literal ::= NK_STRING", - /* 642 */ "interval_sliding_duration_literal ::= NK_INTEGER", - /* 643 */ "fill_opt ::=", - /* 644 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", - /* 645 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP", - /* 646 */ "fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP", - /* 647 */ "fill_mode ::= NONE", - /* 648 */ "fill_mode ::= PREV", - /* 649 */ "fill_mode ::= NULL", - /* 650 */ "fill_mode ::= NULL_F", - /* 651 */ "fill_mode ::= LINEAR", - /* 652 */ "fill_mode ::= NEXT", - /* 653 */ "group_by_clause_opt ::=", - /* 654 */ "group_by_clause_opt ::= GROUP BY group_by_list", - /* 655 */ "group_by_list ::= expr_or_subquery", - /* 656 */ "group_by_list ::= group_by_list NK_COMMA expr_or_subquery", - /* 657 */ "having_clause_opt ::=", - /* 658 */ "having_clause_opt ::= HAVING search_condition", - /* 659 */ "range_opt ::=", - /* 660 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP", - /* 661 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_RP", - /* 662 */ "every_opt ::=", - /* 663 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP", - /* 664 */ "query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt", - /* 665 */ "query_simple ::= query_specification", - /* 666 */ "query_simple ::= union_query_expression", - /* 667 */ "union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery", - /* 668 */ "union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery", - /* 669 */ "query_simple_or_subquery ::= query_simple", - /* 670 */ "query_simple_or_subquery ::= subquery", - /* 671 */ "query_or_subquery ::= query_expression", - /* 672 */ "query_or_subquery ::= subquery", - /* 673 */ "order_by_clause_opt ::=", - /* 674 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", - /* 675 */ "slimit_clause_opt ::=", - /* 676 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", - /* 677 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", - /* 678 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 679 */ "limit_clause_opt ::=", - /* 680 */ "limit_clause_opt ::= LIMIT NK_INTEGER", - /* 681 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", - /* 682 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", - /* 683 */ "subquery ::= NK_LP query_expression NK_RP", - /* 684 */ "subquery ::= NK_LP subquery NK_RP", - /* 685 */ "search_condition ::= common_expression", - /* 686 */ "sort_specification_list ::= sort_specification", - /* 687 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", - /* 688 */ "sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt", - /* 689 */ "ordering_specification_opt ::=", - /* 690 */ "ordering_specification_opt ::= ASC", - /* 691 */ "ordering_specification_opt ::= DESC", - /* 692 */ "null_ordering_opt ::=", - /* 693 */ "null_ordering_opt ::= NULLS FIRST", - /* 694 */ "null_ordering_opt ::= NULLS LAST", - /* 695 */ "column_options ::=", - /* 696 */ "column_options ::= column_options PRIMARY KEY", - /* 697 */ "column_options ::= column_options ENCODE NK_STRING", - /* 698 */ "column_options ::= column_options COMPRESS NK_STRING", - /* 699 */ "column_options ::= column_options LEVEL NK_STRING", + /* 223 */ "type_name_default_len ::= BINARY", + /* 224 */ "type_name_default_len ::= NCHAR", + /* 225 */ "type_name_default_len ::= VARCHAR", + /* 226 */ "type_name_default_len ::= VARBINARY", + /* 227 */ "tags_def_opt ::=", + /* 228 */ "tags_def_opt ::= tags_def", + /* 229 */ "tags_def ::= TAGS NK_LP tag_def_list NK_RP", + /* 230 */ "table_options ::=", + /* 231 */ "table_options ::= table_options COMMENT NK_STRING", + /* 232 */ "table_options ::= table_options MAX_DELAY duration_list", + /* 233 */ "table_options ::= table_options WATERMARK duration_list", + /* 234 */ "table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP", + /* 235 */ "table_options ::= table_options TTL NK_INTEGER", + /* 236 */ "table_options ::= table_options SMA NK_LP col_name_list NK_RP", + /* 237 */ "table_options ::= table_options DELETE_MARK duration_list", + /* 238 */ "alter_table_options ::= alter_table_option", + /* 239 */ "alter_table_options ::= alter_table_options alter_table_option", + /* 240 */ "alter_table_option ::= COMMENT NK_STRING", + /* 241 */ "alter_table_option ::= TTL NK_INTEGER", + /* 242 */ "duration_list ::= duration_literal", + /* 243 */ "duration_list ::= duration_list NK_COMMA duration_literal", + /* 244 */ "rollup_func_list ::= rollup_func_name", + /* 245 */ "rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name", + /* 246 */ "rollup_func_name ::= function_name", + /* 247 */ "rollup_func_name ::= FIRST", + /* 248 */ "rollup_func_name ::= LAST", + /* 249 */ "col_name_list ::= col_name", + /* 250 */ "col_name_list ::= col_name_list NK_COMMA col_name", + /* 251 */ "col_name ::= column_name", + /* 252 */ "cmd ::= SHOW DNODES", + /* 253 */ "cmd ::= SHOW USERS", + /* 254 */ "cmd ::= SHOW USER PRIVILEGES", + /* 255 */ "cmd ::= SHOW db_kind_opt DATABASES", + /* 256 */ "cmd ::= SHOW table_kind_db_name_cond_opt TABLES like_pattern_opt", + /* 257 */ "cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt", + /* 258 */ "cmd ::= SHOW db_name_cond_opt VGROUPS", + /* 259 */ "cmd ::= SHOW MNODES", + /* 260 */ "cmd ::= SHOW QNODES", + /* 261 */ "cmd ::= SHOW ARBGROUPS", + /* 262 */ "cmd ::= SHOW FUNCTIONS", + /* 263 */ "cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt", + /* 264 */ "cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name", + /* 265 */ "cmd ::= SHOW STREAMS", + /* 266 */ "cmd ::= SHOW ACCOUNTS", + /* 267 */ "cmd ::= SHOW APPS", + /* 268 */ "cmd ::= SHOW CONNECTIONS", + /* 269 */ "cmd ::= SHOW LICENCES", + /* 270 */ "cmd ::= SHOW GRANTS", + /* 271 */ "cmd ::= SHOW GRANTS FULL", + /* 272 */ "cmd ::= SHOW GRANTS LOGS", + /* 273 */ "cmd ::= SHOW CLUSTER MACHINES", + /* 274 */ "cmd ::= SHOW CREATE DATABASE db_name", + /* 275 */ "cmd ::= SHOW CREATE TABLE full_table_name", + /* 276 */ "cmd ::= SHOW CREATE STABLE full_table_name", + /* 277 */ "cmd ::= SHOW QUERIES", + /* 278 */ "cmd ::= SHOW SCORES", + /* 279 */ "cmd ::= SHOW TOPICS", + /* 280 */ "cmd ::= SHOW VARIABLES", + /* 281 */ "cmd ::= SHOW CLUSTER VARIABLES", + /* 282 */ "cmd ::= SHOW LOCAL VARIABLES", + /* 283 */ "cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt", + /* 284 */ "cmd ::= SHOW BNODES", + /* 285 */ "cmd ::= SHOW SNODES", + /* 286 */ "cmd ::= SHOW CLUSTER", + /* 287 */ "cmd ::= SHOW TRANSACTIONS", + /* 288 */ "cmd ::= SHOW TABLE DISTRIBUTED full_table_name", + /* 289 */ "cmd ::= SHOW CONSUMERS", + /* 290 */ "cmd ::= SHOW SUBSCRIPTIONS", + /* 291 */ "cmd ::= SHOW TAGS FROM table_name_cond from_db_opt", + /* 292 */ "cmd ::= SHOW TAGS FROM db_name NK_DOT table_name", + /* 293 */ "cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt", + /* 294 */ "cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name", + /* 295 */ "cmd ::= SHOW VNODES ON DNODE NK_INTEGER", + /* 296 */ "cmd ::= SHOW VNODES", + /* 297 */ "cmd ::= SHOW db_name_cond_opt ALIVE", + /* 298 */ "cmd ::= SHOW CLUSTER ALIVE", + /* 299 */ "cmd ::= SHOW db_name_cond_opt VIEWS like_pattern_opt", + /* 300 */ "cmd ::= SHOW CREATE VIEW full_table_name", + /* 301 */ "cmd ::= SHOW COMPACTS", + /* 302 */ "cmd ::= SHOW COMPACT NK_INTEGER", + /* 303 */ "table_kind_db_name_cond_opt ::=", + /* 304 */ "table_kind_db_name_cond_opt ::= table_kind", + /* 305 */ "table_kind_db_name_cond_opt ::= db_name NK_DOT", + /* 306 */ "table_kind_db_name_cond_opt ::= table_kind db_name NK_DOT", + /* 307 */ "table_kind ::= NORMAL", + /* 308 */ "table_kind ::= CHILD", + /* 309 */ "db_name_cond_opt ::=", + /* 310 */ "db_name_cond_opt ::= db_name NK_DOT", + /* 311 */ "like_pattern_opt ::=", + /* 312 */ "like_pattern_opt ::= LIKE NK_STRING", + /* 313 */ "table_name_cond ::= table_name", + /* 314 */ "from_db_opt ::=", + /* 315 */ "from_db_opt ::= FROM db_name", + /* 316 */ "tag_list_opt ::=", + /* 317 */ "tag_list_opt ::= tag_item", + /* 318 */ "tag_list_opt ::= tag_list_opt NK_COMMA tag_item", + /* 319 */ "tag_item ::= TBNAME", + /* 320 */ "tag_item ::= QTAGS", + /* 321 */ "tag_item ::= column_name", + /* 322 */ "tag_item ::= column_name column_alias", + /* 323 */ "tag_item ::= column_name AS column_alias", + /* 324 */ "db_kind_opt ::=", + /* 325 */ "db_kind_opt ::= USER", + /* 326 */ "db_kind_opt ::= SYSTEM", + /* 327 */ "cmd ::= CREATE SMA INDEX not_exists_opt col_name ON full_table_name index_options", + /* 328 */ "cmd ::= CREATE INDEX not_exists_opt col_name ON full_table_name NK_LP col_name_list NK_RP", + /* 329 */ "cmd ::= DROP INDEX exists_opt full_index_name", + /* 330 */ "full_index_name ::= index_name", + /* 331 */ "full_index_name ::= db_name NK_DOT index_name", + /* 332 */ "index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt", + /* 333 */ "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", + /* 334 */ "func_list ::= func", + /* 335 */ "func_list ::= func_list NK_COMMA func", + /* 336 */ "func ::= sma_func_name NK_LP expression_list NK_RP", + /* 337 */ "sma_func_name ::= function_name", + /* 338 */ "sma_func_name ::= COUNT", + /* 339 */ "sma_func_name ::= FIRST", + /* 340 */ "sma_func_name ::= LAST", + /* 341 */ "sma_func_name ::= LAST_ROW", + /* 342 */ "sma_stream_opt ::=", + /* 343 */ "sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal", + /* 344 */ "sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal", + /* 345 */ "sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal", + /* 346 */ "with_meta ::= AS", + /* 347 */ "with_meta ::= WITH META AS", + /* 348 */ "with_meta ::= ONLY META AS", + /* 349 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery", + /* 350 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name", + /* 351 */ "cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt", + /* 352 */ "cmd ::= DROP TOPIC exists_opt topic_name", + /* 353 */ "cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name", + /* 354 */ "cmd ::= DESC full_table_name", + /* 355 */ "cmd ::= DESCRIBE full_table_name", + /* 356 */ "cmd ::= RESET QUERY CACHE", + /* 357 */ "cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery", + /* 358 */ "cmd ::= EXPLAIN analyze_opt explain_options insert_query", + /* 359 */ "analyze_opt ::=", + /* 360 */ "analyze_opt ::= ANALYZE", + /* 361 */ "explain_options ::=", + /* 362 */ "explain_options ::= explain_options VERBOSE NK_BOOL", + /* 363 */ "explain_options ::= explain_options RATIO NK_FLOAT", + /* 364 */ "cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt", + /* 365 */ "cmd ::= DROP FUNCTION exists_opt function_name", + /* 366 */ "agg_func_opt ::=", + /* 367 */ "agg_func_opt ::= AGGREGATE", + /* 368 */ "bufsize_opt ::=", + /* 369 */ "bufsize_opt ::= BUFSIZE NK_INTEGER", + /* 370 */ "language_opt ::=", + /* 371 */ "language_opt ::= LANGUAGE NK_STRING", + /* 372 */ "or_replace_opt ::=", + /* 373 */ "or_replace_opt ::= OR REPLACE", + /* 374 */ "cmd ::= CREATE or_replace_opt VIEW full_view_name AS query_or_subquery", + /* 375 */ "cmd ::= DROP VIEW exists_opt full_view_name", + /* 376 */ "full_view_name ::= view_name", + /* 377 */ "full_view_name ::= db_name NK_DOT view_name", + /* 378 */ "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", + /* 379 */ "cmd ::= DROP STREAM exists_opt stream_name", + /* 380 */ "cmd ::= PAUSE STREAM exists_opt stream_name", + /* 381 */ "cmd ::= RESUME STREAM exists_opt ignore_opt stream_name", + /* 382 */ "col_list_opt ::=", + /* 383 */ "col_list_opt ::= NK_LP col_name_list NK_RP", + /* 384 */ "tag_def_or_ref_opt ::=", + /* 385 */ "tag_def_or_ref_opt ::= tags_def", + /* 386 */ "tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP", + /* 387 */ "stream_options ::=", + /* 388 */ "stream_options ::= stream_options TRIGGER AT_ONCE", + /* 389 */ "stream_options ::= stream_options TRIGGER WINDOW_CLOSE", + /* 390 */ "stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal", + /* 391 */ "stream_options ::= stream_options WATERMARK duration_literal", + /* 392 */ "stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER", + /* 393 */ "stream_options ::= stream_options FILL_HISTORY NK_INTEGER", + /* 394 */ "stream_options ::= stream_options DELETE_MARK duration_literal", + /* 395 */ "stream_options ::= stream_options IGNORE UPDATE NK_INTEGER", + /* 396 */ "subtable_opt ::=", + /* 397 */ "subtable_opt ::= SUBTABLE NK_LP expression NK_RP", + /* 398 */ "ignore_opt ::=", + /* 399 */ "ignore_opt ::= IGNORE UNTREATED", + /* 400 */ "cmd ::= KILL CONNECTION NK_INTEGER", + /* 401 */ "cmd ::= KILL QUERY NK_STRING", + /* 402 */ "cmd ::= KILL TRANSACTION NK_INTEGER", + /* 403 */ "cmd ::= KILL COMPACT NK_INTEGER", + /* 404 */ "cmd ::= BALANCE VGROUP", + /* 405 */ "cmd ::= BALANCE VGROUP LEADER on_vgroup_id", + /* 406 */ "cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER", + /* 407 */ "cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list", + /* 408 */ "cmd ::= SPLIT VGROUP NK_INTEGER", + /* 409 */ "on_vgroup_id ::=", + /* 410 */ "on_vgroup_id ::= ON NK_INTEGER", + /* 411 */ "dnode_list ::= DNODE NK_INTEGER", + /* 412 */ "dnode_list ::= dnode_list DNODE NK_INTEGER", + /* 413 */ "cmd ::= DELETE FROM full_table_name where_clause_opt", + /* 414 */ "cmd ::= query_or_subquery", + /* 415 */ "cmd ::= insert_query", + /* 416 */ "insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery", + /* 417 */ "insert_query ::= INSERT INTO full_table_name query_or_subquery", + /* 418 */ "tags_literal ::= NK_INTEGER", + /* 419 */ "tags_literal ::= NK_INTEGER NK_PLUS duration_literal", + /* 420 */ "tags_literal ::= NK_INTEGER NK_MINUS duration_literal", + /* 421 */ "tags_literal ::= NK_PLUS NK_INTEGER", + /* 422 */ "tags_literal ::= NK_PLUS NK_INTEGER NK_PLUS duration_literal", + /* 423 */ "tags_literal ::= NK_PLUS NK_INTEGER NK_MINUS duration_literal", + /* 424 */ "tags_literal ::= NK_MINUS NK_INTEGER", + /* 425 */ "tags_literal ::= NK_MINUS NK_INTEGER NK_PLUS duration_literal", + /* 426 */ "tags_literal ::= NK_MINUS NK_INTEGER NK_MINUS duration_literal", + /* 427 */ "tags_literal ::= NK_FLOAT", + /* 428 */ "tags_literal ::= NK_PLUS NK_FLOAT", + /* 429 */ "tags_literal ::= NK_MINUS NK_FLOAT", + /* 430 */ "tags_literal ::= NK_BIN", + /* 431 */ "tags_literal ::= NK_BIN NK_PLUS duration_literal", + /* 432 */ "tags_literal ::= NK_BIN NK_MINUS duration_literal", + /* 433 */ "tags_literal ::= NK_PLUS NK_BIN", + /* 434 */ "tags_literal ::= NK_PLUS NK_BIN NK_PLUS duration_literal", + /* 435 */ "tags_literal ::= NK_PLUS NK_BIN NK_MINUS duration_literal", + /* 436 */ "tags_literal ::= NK_MINUS NK_BIN", + /* 437 */ "tags_literal ::= NK_MINUS NK_BIN NK_PLUS duration_literal", + /* 438 */ "tags_literal ::= NK_MINUS NK_BIN NK_MINUS duration_literal", + /* 439 */ "tags_literal ::= NK_HEX", + /* 440 */ "tags_literal ::= NK_HEX NK_PLUS duration_literal", + /* 441 */ "tags_literal ::= NK_HEX NK_MINUS duration_literal", + /* 442 */ "tags_literal ::= NK_PLUS NK_HEX", + /* 443 */ "tags_literal ::= NK_PLUS NK_HEX NK_PLUS duration_literal", + /* 444 */ "tags_literal ::= NK_PLUS NK_HEX NK_MINUS duration_literal", + /* 445 */ "tags_literal ::= NK_MINUS NK_HEX", + /* 446 */ "tags_literal ::= NK_MINUS NK_HEX NK_PLUS duration_literal", + /* 447 */ "tags_literal ::= NK_MINUS NK_HEX NK_MINUS duration_literal", + /* 448 */ "tags_literal ::= NK_STRING", + /* 449 */ "tags_literal ::= NK_STRING NK_PLUS duration_literal", + /* 450 */ "tags_literal ::= NK_STRING NK_MINUS duration_literal", + /* 451 */ "tags_literal ::= NK_BOOL", + /* 452 */ "tags_literal ::= NULL", + /* 453 */ "tags_literal ::= literal_func", + /* 454 */ "tags_literal ::= literal_func NK_PLUS duration_literal", + /* 455 */ "tags_literal ::= literal_func NK_MINUS duration_literal", + /* 456 */ "tags_literal_list ::= tags_literal", + /* 457 */ "tags_literal_list ::= tags_literal_list NK_COMMA tags_literal", + /* 458 */ "literal ::= NK_INTEGER", + /* 459 */ "literal ::= NK_FLOAT", + /* 460 */ "literal ::= NK_STRING", + /* 461 */ "literal ::= NK_BOOL", + /* 462 */ "literal ::= TIMESTAMP NK_STRING", + /* 463 */ "literal ::= duration_literal", + /* 464 */ "literal ::= NULL", + /* 465 */ "literal ::= NK_QUESTION", + /* 466 */ "duration_literal ::= NK_VARIABLE", + /* 467 */ "signed ::= NK_INTEGER", + /* 468 */ "signed ::= NK_PLUS NK_INTEGER", + /* 469 */ "signed ::= NK_MINUS NK_INTEGER", + /* 470 */ "signed ::= NK_FLOAT", + /* 471 */ "signed ::= NK_PLUS NK_FLOAT", + /* 472 */ "signed ::= NK_MINUS NK_FLOAT", + /* 473 */ "signed_literal ::= signed", + /* 474 */ "signed_literal ::= NK_STRING", + /* 475 */ "signed_literal ::= NK_BOOL", + /* 476 */ "signed_literal ::= TIMESTAMP NK_STRING", + /* 477 */ "signed_literal ::= duration_literal", + /* 478 */ "signed_literal ::= NULL", + /* 479 */ "signed_literal ::= literal_func", + /* 480 */ "signed_literal ::= NK_QUESTION", + /* 481 */ "literal_list ::= signed_literal", + /* 482 */ "literal_list ::= literal_list NK_COMMA signed_literal", + /* 483 */ "db_name ::= NK_ID", + /* 484 */ "table_name ::= NK_ID", + /* 485 */ "column_name ::= NK_ID", + /* 486 */ "function_name ::= NK_ID", + /* 487 */ "view_name ::= NK_ID", + /* 488 */ "table_alias ::= NK_ID", + /* 489 */ "column_alias ::= NK_ID", + /* 490 */ "column_alias ::= NK_ALIAS", + /* 491 */ "user_name ::= NK_ID", + /* 492 */ "topic_name ::= NK_ID", + /* 493 */ "stream_name ::= NK_ID", + /* 494 */ "cgroup_name ::= NK_ID", + /* 495 */ "index_name ::= NK_ID", + /* 496 */ "expr_or_subquery ::= expression", + /* 497 */ "expression ::= literal", + /* 498 */ "expression ::= pseudo_column", + /* 499 */ "expression ::= column_reference", + /* 500 */ "expression ::= function_expression", + /* 501 */ "expression ::= case_when_expression", + /* 502 */ "expression ::= NK_LP expression NK_RP", + /* 503 */ "expression ::= NK_PLUS expr_or_subquery", + /* 504 */ "expression ::= NK_MINUS expr_or_subquery", + /* 505 */ "expression ::= expr_or_subquery NK_PLUS expr_or_subquery", + /* 506 */ "expression ::= expr_or_subquery NK_MINUS expr_or_subquery", + /* 507 */ "expression ::= expr_or_subquery NK_STAR expr_or_subquery", + /* 508 */ "expression ::= expr_or_subquery NK_SLASH expr_or_subquery", + /* 509 */ "expression ::= expr_or_subquery NK_REM expr_or_subquery", + /* 510 */ "expression ::= column_reference NK_ARROW NK_STRING", + /* 511 */ "expression ::= expr_or_subquery NK_BITAND expr_or_subquery", + /* 512 */ "expression ::= expr_or_subquery NK_BITOR expr_or_subquery", + /* 513 */ "expression_list ::= expr_or_subquery", + /* 514 */ "expression_list ::= expression_list NK_COMMA expr_or_subquery", + /* 515 */ "column_reference ::= column_name", + /* 516 */ "column_reference ::= table_name NK_DOT column_name", + /* 517 */ "column_reference ::= NK_ALIAS", + /* 518 */ "column_reference ::= table_name NK_DOT NK_ALIAS", + /* 519 */ "pseudo_column ::= ROWTS", + /* 520 */ "pseudo_column ::= TBNAME", + /* 521 */ "pseudo_column ::= table_name NK_DOT TBNAME", + /* 522 */ "pseudo_column ::= QSTART", + /* 523 */ "pseudo_column ::= QEND", + /* 524 */ "pseudo_column ::= QDURATION", + /* 525 */ "pseudo_column ::= WSTART", + /* 526 */ "pseudo_column ::= WEND", + /* 527 */ "pseudo_column ::= WDURATION", + /* 528 */ "pseudo_column ::= IROWTS", + /* 529 */ "pseudo_column ::= ISFILLED", + /* 530 */ "pseudo_column ::= QTAGS", + /* 531 */ "function_expression ::= function_name NK_LP expression_list NK_RP", + /* 532 */ "function_expression ::= star_func NK_LP star_func_para_list NK_RP", + /* 533 */ "function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP", + /* 534 */ "function_expression ::= CAST NK_LP expr_or_subquery AS type_name_default_len NK_RP", + /* 535 */ "function_expression ::= literal_func", + /* 536 */ "literal_func ::= noarg_func NK_LP NK_RP", + /* 537 */ "literal_func ::= NOW", + /* 538 */ "literal_func ::= TODAY", + /* 539 */ "noarg_func ::= NOW", + /* 540 */ "noarg_func ::= TODAY", + /* 541 */ "noarg_func ::= TIMEZONE", + /* 542 */ "noarg_func ::= DATABASE", + /* 543 */ "noarg_func ::= CLIENT_VERSION", + /* 544 */ "noarg_func ::= SERVER_VERSION", + /* 545 */ "noarg_func ::= SERVER_STATUS", + /* 546 */ "noarg_func ::= CURRENT_USER", + /* 547 */ "noarg_func ::= USER", + /* 548 */ "star_func ::= COUNT", + /* 549 */ "star_func ::= FIRST", + /* 550 */ "star_func ::= LAST", + /* 551 */ "star_func ::= LAST_ROW", + /* 552 */ "star_func_para_list ::= NK_STAR", + /* 553 */ "star_func_para_list ::= other_para_list", + /* 554 */ "other_para_list ::= star_func_para", + /* 555 */ "other_para_list ::= other_para_list NK_COMMA star_func_para", + /* 556 */ "star_func_para ::= expr_or_subquery", + /* 557 */ "star_func_para ::= table_name NK_DOT NK_STAR", + /* 558 */ "case_when_expression ::= CASE when_then_list case_when_else_opt END", + /* 559 */ "case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END", + /* 560 */ "when_then_list ::= when_then_expr", + /* 561 */ "when_then_list ::= when_then_list when_then_expr", + /* 562 */ "when_then_expr ::= WHEN common_expression THEN common_expression", + /* 563 */ "case_when_else_opt ::=", + /* 564 */ "case_when_else_opt ::= ELSE common_expression", + /* 565 */ "predicate ::= expr_or_subquery compare_op expr_or_subquery", + /* 566 */ "predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery", + /* 567 */ "predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery", + /* 568 */ "predicate ::= expr_or_subquery IS NULL", + /* 569 */ "predicate ::= expr_or_subquery IS NOT NULL", + /* 570 */ "predicate ::= expr_or_subquery in_op in_predicate_value", + /* 571 */ "compare_op ::= NK_LT", + /* 572 */ "compare_op ::= NK_GT", + /* 573 */ "compare_op ::= NK_LE", + /* 574 */ "compare_op ::= NK_GE", + /* 575 */ "compare_op ::= NK_NE", + /* 576 */ "compare_op ::= NK_EQ", + /* 577 */ "compare_op ::= LIKE", + /* 578 */ "compare_op ::= NOT LIKE", + /* 579 */ "compare_op ::= MATCH", + /* 580 */ "compare_op ::= NMATCH", + /* 581 */ "compare_op ::= CONTAINS", + /* 582 */ "in_op ::= IN", + /* 583 */ "in_op ::= NOT IN", + /* 584 */ "in_predicate_value ::= NK_LP literal_list NK_RP", + /* 585 */ "boolean_value_expression ::= boolean_primary", + /* 586 */ "boolean_value_expression ::= NOT boolean_primary", + /* 587 */ "boolean_value_expression ::= boolean_value_expression OR boolean_value_expression", + /* 588 */ "boolean_value_expression ::= boolean_value_expression AND boolean_value_expression", + /* 589 */ "boolean_primary ::= predicate", + /* 590 */ "boolean_primary ::= NK_LP boolean_value_expression NK_RP", + /* 591 */ "common_expression ::= expr_or_subquery", + /* 592 */ "common_expression ::= boolean_value_expression", + /* 593 */ "from_clause_opt ::=", + /* 594 */ "from_clause_opt ::= FROM table_reference_list", + /* 595 */ "table_reference_list ::= table_reference", + /* 596 */ "table_reference_list ::= table_reference_list NK_COMMA table_reference", + /* 597 */ "table_reference ::= table_primary", + /* 598 */ "table_reference ::= joined_table", + /* 599 */ "table_primary ::= table_name alias_opt", + /* 600 */ "table_primary ::= db_name NK_DOT table_name alias_opt", + /* 601 */ "table_primary ::= subquery alias_opt", + /* 602 */ "table_primary ::= parenthesized_joined_table", + /* 603 */ "alias_opt ::=", + /* 604 */ "alias_opt ::= table_alias", + /* 605 */ "alias_opt ::= AS table_alias", + /* 606 */ "parenthesized_joined_table ::= NK_LP joined_table NK_RP", + /* 607 */ "parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP", + /* 608 */ "joined_table ::= table_reference join_type JOIN table_reference ON search_condition", + /* 609 */ "join_type ::=", + /* 610 */ "join_type ::= INNER", + /* 611 */ "query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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", + /* 612 */ "hint_list ::=", + /* 613 */ "hint_list ::= NK_HINT", + /* 614 */ "tag_mode_opt ::=", + /* 615 */ "tag_mode_opt ::= TAGS", + /* 616 */ "set_quantifier_opt ::=", + /* 617 */ "set_quantifier_opt ::= DISTINCT", + /* 618 */ "set_quantifier_opt ::= ALL", + /* 619 */ "select_list ::= select_item", + /* 620 */ "select_list ::= select_list NK_COMMA select_item", + /* 621 */ "select_item ::= NK_STAR", + /* 622 */ "select_item ::= common_expression", + /* 623 */ "select_item ::= common_expression column_alias", + /* 624 */ "select_item ::= common_expression AS column_alias", + /* 625 */ "select_item ::= table_name NK_DOT NK_STAR", + /* 626 */ "where_clause_opt ::=", + /* 627 */ "where_clause_opt ::= WHERE search_condition", + /* 628 */ "partition_by_clause_opt ::=", + /* 629 */ "partition_by_clause_opt ::= PARTITION BY partition_list", + /* 630 */ "partition_list ::= partition_item", + /* 631 */ "partition_list ::= partition_list NK_COMMA partition_item", + /* 632 */ "partition_item ::= expr_or_subquery", + /* 633 */ "partition_item ::= expr_or_subquery column_alias", + /* 634 */ "partition_item ::= expr_or_subquery AS column_alias", + /* 635 */ "twindow_clause_opt ::=", + /* 636 */ "twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP", + /* 637 */ "twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP", + /* 638 */ "twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt", + /* 639 */ "twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt", + /* 640 */ "twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition", + /* 641 */ "twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_RP", + /* 642 */ "twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP", + /* 643 */ "sliding_opt ::=", + /* 644 */ "sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP", + /* 645 */ "interval_sliding_duration_literal ::= NK_VARIABLE", + /* 646 */ "interval_sliding_duration_literal ::= NK_STRING", + /* 647 */ "interval_sliding_duration_literal ::= NK_INTEGER", + /* 648 */ "fill_opt ::=", + /* 649 */ "fill_opt ::= FILL NK_LP fill_mode NK_RP", + /* 650 */ "fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP", + /* 651 */ "fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP", + /* 652 */ "fill_mode ::= NONE", + /* 653 */ "fill_mode ::= PREV", + /* 654 */ "fill_mode ::= NULL", + /* 655 */ "fill_mode ::= NULL_F", + /* 656 */ "fill_mode ::= LINEAR", + /* 657 */ "fill_mode ::= NEXT", + /* 658 */ "group_by_clause_opt ::=", + /* 659 */ "group_by_clause_opt ::= GROUP BY group_by_list", + /* 660 */ "group_by_list ::= expr_or_subquery", + /* 661 */ "group_by_list ::= group_by_list NK_COMMA expr_or_subquery", + /* 662 */ "having_clause_opt ::=", + /* 663 */ "having_clause_opt ::= HAVING search_condition", + /* 664 */ "range_opt ::=", + /* 665 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP", + /* 666 */ "range_opt ::= RANGE NK_LP expr_or_subquery NK_RP", + /* 667 */ "every_opt ::=", + /* 668 */ "every_opt ::= EVERY NK_LP duration_literal NK_RP", + /* 669 */ "query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt", + /* 670 */ "query_simple ::= query_specification", + /* 671 */ "query_simple ::= union_query_expression", + /* 672 */ "union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery", + /* 673 */ "union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery", + /* 674 */ "query_simple_or_subquery ::= query_simple", + /* 675 */ "query_simple_or_subquery ::= subquery", + /* 676 */ "query_or_subquery ::= query_expression", + /* 677 */ "query_or_subquery ::= subquery", + /* 678 */ "order_by_clause_opt ::=", + /* 679 */ "order_by_clause_opt ::= ORDER BY sort_specification_list", + /* 680 */ "slimit_clause_opt ::=", + /* 681 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER", + /* 682 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER", + /* 683 */ "slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 684 */ "limit_clause_opt ::=", + /* 685 */ "limit_clause_opt ::= LIMIT NK_INTEGER", + /* 686 */ "limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER", + /* 687 */ "limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER", + /* 688 */ "subquery ::= NK_LP query_expression NK_RP", + /* 689 */ "subquery ::= NK_LP subquery NK_RP", + /* 690 */ "search_condition ::= common_expression", + /* 691 */ "sort_specification_list ::= sort_specification", + /* 692 */ "sort_specification_list ::= sort_specification_list NK_COMMA sort_specification", + /* 693 */ "sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt", + /* 694 */ "ordering_specification_opt ::=", + /* 695 */ "ordering_specification_opt ::= ASC", + /* 696 */ "ordering_specification_opt ::= DESC", + /* 697 */ "null_ordering_opt ::=", + /* 698 */ "null_ordering_opt ::= NULLS FIRST", + /* 699 */ "null_ordering_opt ::= NULLS LAST", + /* 700 */ "column_options ::=", + /* 701 */ "column_options ::= column_options PRIMARY KEY", + /* 702 */ "column_options ::= column_options ENCODE NK_STRING", + /* 703 */ "column_options ::= column_options COMPRESS NK_STRING", + /* 704 */ "column_options ::= column_options LEVEL NK_STRING", }; #endif /* NDEBUG */ @@ -3317,81 +3352,81 @@ static void yy_destructor( case 409: /* drop_table_clause */ case 412: /* tag_def */ case 413: /* column_def */ - case 417: /* duration_literal */ - case 418: /* rollup_func_name */ - case 420: /* col_name */ - case 423: /* like_pattern_opt */ - case 424: /* db_name_cond_opt */ - case 425: /* table_name_cond */ - case 426: /* from_db_opt */ - case 429: /* tag_item */ - case 431: /* index_options */ - case 432: /* full_index_name */ - case 435: /* sliding_opt */ - case 436: /* sma_stream_opt */ - case 437: /* func */ - case 441: /* query_or_subquery */ - case 442: /* where_clause_opt */ - case 445: /* explain_options */ - case 446: /* insert_query */ - case 451: /* full_view_name */ - case 454: /* stream_options */ - case 457: /* subtable_opt */ - case 459: /* expression */ - case 462: /* literal_func */ - case 463: /* signed_literal */ - case 466: /* expr_or_subquery */ - case 467: /* pseudo_column */ - case 468: /* column_reference */ - case 469: /* function_expression */ - case 470: /* case_when_expression */ - case 475: /* star_func_para */ - case 477: /* case_when_else_opt */ - case 478: /* common_expression */ - case 479: /* when_then_expr */ - case 480: /* predicate */ - case 483: /* in_predicate_value */ - case 484: /* boolean_value_expression */ - case 485: /* boolean_primary */ - case 486: /* from_clause_opt */ - case 487: /* table_reference_list */ - case 488: /* table_reference */ - case 489: /* table_primary */ - case 490: /* joined_table */ - case 492: /* subquery */ - case 493: /* parenthesized_joined_table */ - case 495: /* query_specification */ - case 501: /* range_opt */ - case 502: /* every_opt */ - case 503: /* fill_opt */ - case 504: /* twindow_clause_opt */ - case 506: /* having_clause_opt */ - case 507: /* select_item */ - case 509: /* partition_item */ - case 510: /* interval_sliding_duration_literal */ - case 513: /* query_expression */ - case 514: /* query_simple */ - case 516: /* slimit_clause_opt */ - case 517: /* limit_clause_opt */ - case 518: /* union_query_expression */ - case 519: /* query_simple_or_subquery */ - case 521: /* sort_specification */ + case 418: /* duration_literal */ + case 419: /* rollup_func_name */ + case 421: /* col_name */ + case 424: /* like_pattern_opt */ + case 425: /* db_name_cond_opt */ + case 426: /* table_name_cond */ + case 427: /* from_db_opt */ + case 430: /* tag_item */ + case 432: /* index_options */ + case 433: /* full_index_name */ + case 436: /* sliding_opt */ + case 437: /* sma_stream_opt */ + case 438: /* func */ + case 442: /* query_or_subquery */ + case 443: /* where_clause_opt */ + case 446: /* explain_options */ + case 447: /* insert_query */ + case 452: /* full_view_name */ + case 455: /* stream_options */ + case 458: /* subtable_opt */ + case 460: /* expression */ + case 463: /* literal_func */ + case 464: /* signed_literal */ + case 467: /* expr_or_subquery */ + case 468: /* pseudo_column */ + case 469: /* column_reference */ + case 470: /* function_expression */ + case 471: /* case_when_expression */ + case 476: /* star_func_para */ + case 478: /* case_when_else_opt */ + case 479: /* common_expression */ + case 480: /* when_then_expr */ + case 481: /* predicate */ + case 484: /* in_predicate_value */ + case 485: /* boolean_value_expression */ + case 486: /* boolean_primary */ + case 487: /* from_clause_opt */ + case 488: /* table_reference_list */ + case 489: /* table_reference */ + case 490: /* table_primary */ + case 491: /* joined_table */ + case 493: /* subquery */ + case 494: /* parenthesized_joined_table */ + case 496: /* query_specification */ + case 502: /* range_opt */ + case 503: /* every_opt */ + case 504: /* fill_opt */ + case 505: /* twindow_clause_opt */ + case 507: /* having_clause_opt */ + case 508: /* select_item */ + case 510: /* partition_item */ + case 511: /* interval_sliding_duration_literal */ + case 514: /* query_expression */ + case 515: /* query_simple */ + case 517: /* slimit_clause_opt */ + case 518: /* limit_clause_opt */ + case 519: /* union_query_expression */ + case 520: /* query_simple_or_subquery */ + case 522: /* sort_specification */ { #line 7 "sql.y" - nodesDestroyNode((yypminor->yy1000)); -#line 3382 "sql.c" + nodesDestroyNode((yypminor->yy812)); +#line 3417 "sql.c" } break; case 359: /* account_options */ case 360: /* alter_account_options */ case 362: /* alter_account_option */ case 384: /* speed_opt */ - case 440: /* with_meta */ - case 449: /* bufsize_opt */ + case 441: /* with_meta */ + case 450: /* bufsize_opt */ { #line 54 "sql.y" -#line 3394 "sql.c" +#line 3429 "sql.c" } break; case 363: /* ip_range_list */ @@ -3409,30 +3444,30 @@ static void yy_destructor( case 408: /* tags_literal_list */ case 410: /* col_name_list */ case 411: /* tag_def_list */ - case 414: /* duration_list */ - case 415: /* rollup_func_list */ - case 427: /* tag_list_opt */ - case 434: /* func_list */ - case 439: /* expression_list */ - case 455: /* col_list_opt */ - case 456: /* tag_def_or_ref_opt */ - case 461: /* dnode_list */ - case 464: /* literal_list */ - case 472: /* star_func_para_list */ - case 474: /* other_para_list */ - case 476: /* when_then_list */ - case 496: /* hint_list */ - case 499: /* select_list */ - case 500: /* partition_by_clause_opt */ - case 505: /* group_by_clause_opt */ - case 508: /* partition_list */ - case 512: /* group_by_list */ - case 515: /* order_by_clause_opt */ - case 520: /* sort_specification_list */ + case 415: /* duration_list */ + case 416: /* rollup_func_list */ + case 428: /* tag_list_opt */ + case 435: /* func_list */ + case 440: /* expression_list */ + case 456: /* col_list_opt */ + case 457: /* tag_def_or_ref_opt */ + case 462: /* dnode_list */ + case 465: /* literal_list */ + case 473: /* star_func_para_list */ + case 475: /* other_para_list */ + case 477: /* when_then_list */ + case 497: /* hint_list */ + case 500: /* select_list */ + case 501: /* partition_by_clause_opt */ + case 506: /* group_by_clause_opt */ + case 509: /* partition_list */ + case 513: /* group_by_list */ + case 516: /* order_by_clause_opt */ + case 521: /* sort_specification_list */ { #line 85 "sql.y" - nodesDestroyList((yypminor->yy72)); -#line 3435 "sql.c" + nodesDestroyList((yypminor->yy124)); +#line 3470 "sql.c" } break; case 366: /* user_name */ @@ -3441,30 +3476,30 @@ static void yy_destructor( case 375: /* topic_name */ case 377: /* dnode_endpoint */ case 402: /* column_name */ - case 419: /* function_name */ - case 430: /* column_alias */ - case 433: /* index_name */ - case 438: /* sma_func_name */ - case 443: /* cgroup_name */ - case 450: /* language_opt */ - case 452: /* view_name */ - case 453: /* stream_name */ - case 460: /* on_vgroup_id */ - case 465: /* table_alias */ - case 471: /* star_func */ - case 473: /* noarg_func */ - case 491: /* alias_opt */ + case 420: /* function_name */ + case 431: /* column_alias */ + case 434: /* index_name */ + case 439: /* sma_func_name */ + case 444: /* cgroup_name */ + case 451: /* language_opt */ + case 453: /* view_name */ + case 454: /* stream_name */ + case 461: /* on_vgroup_id */ + case 466: /* table_alias */ + case 472: /* star_func */ + case 474: /* noarg_func */ + case 492: /* alias_opt */ { -#line 1018 "sql.y" +#line 1025 "sql.y" -#line 3460 "sql.c" +#line 3495 "sql.c" } break; case 367: /* sysinfo_opt */ { #line 112 "sql.y" -#line 3467 "sql.c" +#line 3502 "sql.c" } break; case 368: /* privileges */ @@ -3473,96 +3508,97 @@ static void yy_destructor( { #line 121 "sql.y" -#line 3476 "sql.c" +#line 3511 "sql.c" } break; case 369: /* priv_level */ { #line 138 "sql.y" -#line 3483 "sql.c" +#line 3518 "sql.c" } break; case 378: /* force_opt */ case 379: /* unsafe_opt */ case 380: /* not_exists_opt */ case 382: /* exists_opt */ - case 444: /* analyze_opt */ - case 447: /* or_replace_opt */ - case 448: /* agg_func_opt */ - case 458: /* ignore_opt */ - case 497: /* set_quantifier_opt */ - case 498: /* tag_mode_opt */ + case 445: /* analyze_opt */ + case 448: /* or_replace_opt */ + case 449: /* agg_func_opt */ + case 459: /* ignore_opt */ + case 498: /* set_quantifier_opt */ + case 499: /* tag_mode_opt */ { #line 167 "sql.y" -#line 3499 "sql.c" +#line 3534 "sql.c" } break; case 391: /* alter_db_option */ - case 416: /* alter_table_option */ + case 417: /* alter_table_option */ { #line 269 "sql.y" -#line 3507 "sql.c" +#line 3542 "sql.c" } break; case 403: /* type_name */ + case 414: /* type_name_default_len */ { #line 400 "sql.y" -#line 3514 "sql.c" +#line 3550 "sql.c" } break; - case 421: /* db_kind_opt */ - case 428: /* table_kind */ + case 422: /* db_kind_opt */ + case 429: /* table_kind */ { -#line 569 "sql.y" - -#line 3522 "sql.c" -} - break; - case 422: /* table_kind_db_name_cond_opt */ -{ -#line 534 "sql.y" - -#line 3529 "sql.c" -} - break; - case 481: /* compare_op */ - case 482: /* in_op */ -{ -#line 1209 "sql.y" - -#line 3537 "sql.c" -} - break; - case 494: /* join_type */ -{ -#line 1285 "sql.y" - -#line 3544 "sql.c" -} - break; - case 511: /* fill_mode */ -{ -#line 1380 "sql.y" - -#line 3551 "sql.c" -} - break; - case 522: /* ordering_specification_opt */ -{ -#line 1465 "sql.y" +#line 576 "sql.y" #line 3558 "sql.c" } break; - case 523: /* null_ordering_opt */ + case 423: /* table_kind_db_name_cond_opt */ { -#line 1471 "sql.y" +#line 541 "sql.y" #line 3565 "sql.c" +} + break; + case 482: /* compare_op */ + case 483: /* in_op */ +{ +#line 1219 "sql.y" + +#line 3573 "sql.c" +} + break; + case 495: /* join_type */ +{ +#line 1295 "sql.y" + +#line 3580 "sql.c" +} + break; + case 512: /* fill_mode */ +{ +#line 1390 "sql.y" + +#line 3587 "sql.c" +} + break; + case 523: /* ordering_specification_opt */ +{ +#line 1475 "sql.y" + +#line 3594 "sql.c" +} + break; + case 524: /* null_ordering_opt */ +{ +#line 1481 "sql.y" + +#line 3601 "sql.c" } break; /********* End destructor definitions *****************************************/ @@ -4074,483 +4110,488 @@ static const YYCODETYPE yyRuleInfoLhs[] = { 403, /* (220) type_name ::= DECIMAL */ 403, /* (221) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ 403, /* (222) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ - 395, /* (223) tags_def_opt ::= */ - 395, /* (224) tags_def_opt ::= tags_def */ - 398, /* (225) tags_def ::= TAGS NK_LP tag_def_list NK_RP */ - 396, /* (226) table_options ::= */ - 396, /* (227) table_options ::= table_options COMMENT NK_STRING */ - 396, /* (228) table_options ::= table_options MAX_DELAY duration_list */ - 396, /* (229) table_options ::= table_options WATERMARK duration_list */ - 396, /* (230) table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ - 396, /* (231) table_options ::= table_options TTL NK_INTEGER */ - 396, /* (232) table_options ::= table_options SMA NK_LP col_name_list NK_RP */ - 396, /* (233) table_options ::= table_options DELETE_MARK duration_list */ - 401, /* (234) alter_table_options ::= alter_table_option */ - 401, /* (235) alter_table_options ::= alter_table_options alter_table_option */ - 416, /* (236) alter_table_option ::= COMMENT NK_STRING */ - 416, /* (237) alter_table_option ::= TTL NK_INTEGER */ - 414, /* (238) duration_list ::= duration_literal */ - 414, /* (239) duration_list ::= duration_list NK_COMMA duration_literal */ - 415, /* (240) rollup_func_list ::= rollup_func_name */ - 415, /* (241) rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ - 418, /* (242) rollup_func_name ::= function_name */ - 418, /* (243) rollup_func_name ::= FIRST */ - 418, /* (244) rollup_func_name ::= LAST */ - 410, /* (245) col_name_list ::= col_name */ - 410, /* (246) col_name_list ::= col_name_list NK_COMMA col_name */ - 420, /* (247) col_name ::= column_name */ - 358, /* (248) cmd ::= SHOW DNODES */ - 358, /* (249) cmd ::= SHOW USERS */ - 358, /* (250) cmd ::= SHOW USER PRIVILEGES */ - 358, /* (251) cmd ::= SHOW db_kind_opt DATABASES */ - 358, /* (252) cmd ::= SHOW table_kind_db_name_cond_opt TABLES like_pattern_opt */ - 358, /* (253) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ - 358, /* (254) cmd ::= SHOW db_name_cond_opt VGROUPS */ - 358, /* (255) cmd ::= SHOW MNODES */ - 358, /* (256) cmd ::= SHOW QNODES */ - 358, /* (257) cmd ::= SHOW ARBGROUPS */ - 358, /* (258) cmd ::= SHOW FUNCTIONS */ - 358, /* (259) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ - 358, /* (260) cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */ - 358, /* (261) cmd ::= SHOW STREAMS */ - 358, /* (262) cmd ::= SHOW ACCOUNTS */ - 358, /* (263) cmd ::= SHOW APPS */ - 358, /* (264) cmd ::= SHOW CONNECTIONS */ - 358, /* (265) cmd ::= SHOW LICENCES */ - 358, /* (266) cmd ::= SHOW GRANTS */ - 358, /* (267) cmd ::= SHOW GRANTS FULL */ - 358, /* (268) cmd ::= SHOW GRANTS LOGS */ - 358, /* (269) cmd ::= SHOW CLUSTER MACHINES */ - 358, /* (270) cmd ::= SHOW CREATE DATABASE db_name */ - 358, /* (271) cmd ::= SHOW CREATE TABLE full_table_name */ - 358, /* (272) cmd ::= SHOW CREATE STABLE full_table_name */ - 358, /* (273) cmd ::= SHOW QUERIES */ - 358, /* (274) cmd ::= SHOW SCORES */ - 358, /* (275) cmd ::= SHOW TOPICS */ - 358, /* (276) cmd ::= SHOW VARIABLES */ - 358, /* (277) cmd ::= SHOW CLUSTER VARIABLES */ - 358, /* (278) cmd ::= SHOW LOCAL VARIABLES */ - 358, /* (279) cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */ - 358, /* (280) cmd ::= SHOW BNODES */ - 358, /* (281) cmd ::= SHOW SNODES */ - 358, /* (282) cmd ::= SHOW CLUSTER */ - 358, /* (283) cmd ::= SHOW TRANSACTIONS */ - 358, /* (284) cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ - 358, /* (285) cmd ::= SHOW CONSUMERS */ - 358, /* (286) cmd ::= SHOW SUBSCRIPTIONS */ - 358, /* (287) cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ - 358, /* (288) cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */ - 358, /* (289) cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */ - 358, /* (290) cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */ - 358, /* (291) cmd ::= SHOW VNODES ON DNODE NK_INTEGER */ - 358, /* (292) cmd ::= SHOW VNODES */ - 358, /* (293) cmd ::= SHOW db_name_cond_opt ALIVE */ - 358, /* (294) cmd ::= SHOW CLUSTER ALIVE */ - 358, /* (295) cmd ::= SHOW db_name_cond_opt VIEWS like_pattern_opt */ - 358, /* (296) cmd ::= SHOW CREATE VIEW full_table_name */ - 358, /* (297) cmd ::= SHOW COMPACTS */ - 358, /* (298) cmd ::= SHOW COMPACT NK_INTEGER */ - 422, /* (299) table_kind_db_name_cond_opt ::= */ - 422, /* (300) table_kind_db_name_cond_opt ::= table_kind */ - 422, /* (301) table_kind_db_name_cond_opt ::= db_name NK_DOT */ - 422, /* (302) table_kind_db_name_cond_opt ::= table_kind db_name NK_DOT */ - 428, /* (303) table_kind ::= NORMAL */ - 428, /* (304) table_kind ::= CHILD */ - 424, /* (305) db_name_cond_opt ::= */ - 424, /* (306) db_name_cond_opt ::= db_name NK_DOT */ - 423, /* (307) like_pattern_opt ::= */ - 423, /* (308) like_pattern_opt ::= LIKE NK_STRING */ - 425, /* (309) table_name_cond ::= table_name */ - 426, /* (310) from_db_opt ::= */ - 426, /* (311) from_db_opt ::= FROM db_name */ - 427, /* (312) tag_list_opt ::= */ - 427, /* (313) tag_list_opt ::= tag_item */ - 427, /* (314) tag_list_opt ::= tag_list_opt NK_COMMA tag_item */ - 429, /* (315) tag_item ::= TBNAME */ - 429, /* (316) tag_item ::= QTAGS */ - 429, /* (317) tag_item ::= column_name */ - 429, /* (318) tag_item ::= column_name column_alias */ - 429, /* (319) tag_item ::= column_name AS column_alias */ - 421, /* (320) db_kind_opt ::= */ - 421, /* (321) db_kind_opt ::= USER */ - 421, /* (322) db_kind_opt ::= SYSTEM */ - 358, /* (323) cmd ::= CREATE SMA INDEX not_exists_opt col_name ON full_table_name index_options */ - 358, /* (324) cmd ::= CREATE INDEX not_exists_opt col_name ON full_table_name NK_LP col_name_list NK_RP */ - 358, /* (325) cmd ::= DROP INDEX exists_opt full_index_name */ - 432, /* (326) full_index_name ::= index_name */ - 432, /* (327) full_index_name ::= db_name NK_DOT index_name */ - 431, /* (328) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ - 431, /* (329) 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 */ - 434, /* (330) func_list ::= func */ - 434, /* (331) func_list ::= func_list NK_COMMA func */ - 437, /* (332) func ::= sma_func_name NK_LP expression_list NK_RP */ - 438, /* (333) sma_func_name ::= function_name */ - 438, /* (334) sma_func_name ::= COUNT */ - 438, /* (335) sma_func_name ::= FIRST */ - 438, /* (336) sma_func_name ::= LAST */ - 438, /* (337) sma_func_name ::= LAST_ROW */ - 436, /* (338) sma_stream_opt ::= */ - 436, /* (339) sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */ - 436, /* (340) sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */ - 436, /* (341) sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */ - 440, /* (342) with_meta ::= AS */ - 440, /* (343) with_meta ::= WITH META AS */ - 440, /* (344) with_meta ::= ONLY META AS */ - 358, /* (345) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */ - 358, /* (346) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */ - 358, /* (347) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */ - 358, /* (348) cmd ::= DROP TOPIC exists_opt topic_name */ - 358, /* (349) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ - 358, /* (350) cmd ::= DESC full_table_name */ - 358, /* (351) cmd ::= DESCRIBE full_table_name */ - 358, /* (352) cmd ::= RESET QUERY CACHE */ - 358, /* (353) cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */ - 358, /* (354) cmd ::= EXPLAIN analyze_opt explain_options insert_query */ - 444, /* (355) analyze_opt ::= */ - 444, /* (356) analyze_opt ::= ANALYZE */ - 445, /* (357) explain_options ::= */ - 445, /* (358) explain_options ::= explain_options VERBOSE NK_BOOL */ - 445, /* (359) explain_options ::= explain_options RATIO NK_FLOAT */ - 358, /* (360) cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */ - 358, /* (361) cmd ::= DROP FUNCTION exists_opt function_name */ - 448, /* (362) agg_func_opt ::= */ - 448, /* (363) agg_func_opt ::= AGGREGATE */ - 449, /* (364) bufsize_opt ::= */ - 449, /* (365) bufsize_opt ::= BUFSIZE NK_INTEGER */ - 450, /* (366) language_opt ::= */ - 450, /* (367) language_opt ::= LANGUAGE NK_STRING */ - 447, /* (368) or_replace_opt ::= */ - 447, /* (369) or_replace_opt ::= OR REPLACE */ - 358, /* (370) cmd ::= CREATE or_replace_opt VIEW full_view_name AS query_or_subquery */ - 358, /* (371) cmd ::= DROP VIEW exists_opt full_view_name */ - 451, /* (372) full_view_name ::= view_name */ - 451, /* (373) full_view_name ::= db_name NK_DOT view_name */ - 358, /* (374) 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 */ - 358, /* (375) cmd ::= DROP STREAM exists_opt stream_name */ - 358, /* (376) cmd ::= PAUSE STREAM exists_opt stream_name */ - 358, /* (377) cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */ - 455, /* (378) col_list_opt ::= */ - 455, /* (379) col_list_opt ::= NK_LP col_name_list NK_RP */ - 456, /* (380) tag_def_or_ref_opt ::= */ - 456, /* (381) tag_def_or_ref_opt ::= tags_def */ - 456, /* (382) tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP */ - 454, /* (383) stream_options ::= */ - 454, /* (384) stream_options ::= stream_options TRIGGER AT_ONCE */ - 454, /* (385) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ - 454, /* (386) stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ - 454, /* (387) stream_options ::= stream_options WATERMARK duration_literal */ - 454, /* (388) stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ - 454, /* (389) stream_options ::= stream_options FILL_HISTORY NK_INTEGER */ - 454, /* (390) stream_options ::= stream_options DELETE_MARK duration_literal */ - 454, /* (391) stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */ - 457, /* (392) subtable_opt ::= */ - 457, /* (393) subtable_opt ::= SUBTABLE NK_LP expression NK_RP */ - 458, /* (394) ignore_opt ::= */ - 458, /* (395) ignore_opt ::= IGNORE UNTREATED */ - 358, /* (396) cmd ::= KILL CONNECTION NK_INTEGER */ - 358, /* (397) cmd ::= KILL QUERY NK_STRING */ - 358, /* (398) cmd ::= KILL TRANSACTION NK_INTEGER */ - 358, /* (399) cmd ::= KILL COMPACT NK_INTEGER */ - 358, /* (400) cmd ::= BALANCE VGROUP */ - 358, /* (401) cmd ::= BALANCE VGROUP LEADER on_vgroup_id */ - 358, /* (402) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ - 358, /* (403) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ - 358, /* (404) cmd ::= SPLIT VGROUP NK_INTEGER */ - 460, /* (405) on_vgroup_id ::= */ - 460, /* (406) on_vgroup_id ::= ON NK_INTEGER */ - 461, /* (407) dnode_list ::= DNODE NK_INTEGER */ - 461, /* (408) dnode_list ::= dnode_list DNODE NK_INTEGER */ - 358, /* (409) cmd ::= DELETE FROM full_table_name where_clause_opt */ - 358, /* (410) cmd ::= query_or_subquery */ - 358, /* (411) cmd ::= insert_query */ - 446, /* (412) insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */ - 446, /* (413) insert_query ::= INSERT INTO full_table_name query_or_subquery */ - 405, /* (414) tags_literal ::= NK_INTEGER */ - 405, /* (415) tags_literal ::= NK_INTEGER NK_PLUS duration_literal */ - 405, /* (416) tags_literal ::= NK_INTEGER NK_MINUS duration_literal */ - 405, /* (417) tags_literal ::= NK_PLUS NK_INTEGER */ - 405, /* (418) tags_literal ::= NK_PLUS NK_INTEGER NK_PLUS duration_literal */ - 405, /* (419) tags_literal ::= NK_PLUS NK_INTEGER NK_MINUS duration_literal */ - 405, /* (420) tags_literal ::= NK_MINUS NK_INTEGER */ - 405, /* (421) tags_literal ::= NK_MINUS NK_INTEGER NK_PLUS duration_literal */ - 405, /* (422) tags_literal ::= NK_MINUS NK_INTEGER NK_MINUS duration_literal */ - 405, /* (423) tags_literal ::= NK_FLOAT */ - 405, /* (424) tags_literal ::= NK_PLUS NK_FLOAT */ - 405, /* (425) tags_literal ::= NK_MINUS NK_FLOAT */ - 405, /* (426) tags_literal ::= NK_BIN */ - 405, /* (427) tags_literal ::= NK_BIN NK_PLUS duration_literal */ - 405, /* (428) tags_literal ::= NK_BIN NK_MINUS duration_literal */ - 405, /* (429) tags_literal ::= NK_PLUS NK_BIN */ - 405, /* (430) tags_literal ::= NK_PLUS NK_BIN NK_PLUS duration_literal */ - 405, /* (431) tags_literal ::= NK_PLUS NK_BIN NK_MINUS duration_literal */ - 405, /* (432) tags_literal ::= NK_MINUS NK_BIN */ - 405, /* (433) tags_literal ::= NK_MINUS NK_BIN NK_PLUS duration_literal */ - 405, /* (434) tags_literal ::= NK_MINUS NK_BIN NK_MINUS duration_literal */ - 405, /* (435) tags_literal ::= NK_HEX */ - 405, /* (436) tags_literal ::= NK_HEX NK_PLUS duration_literal */ - 405, /* (437) tags_literal ::= NK_HEX NK_MINUS duration_literal */ - 405, /* (438) tags_literal ::= NK_PLUS NK_HEX */ - 405, /* (439) tags_literal ::= NK_PLUS NK_HEX NK_PLUS duration_literal */ - 405, /* (440) tags_literal ::= NK_PLUS NK_HEX NK_MINUS duration_literal */ - 405, /* (441) tags_literal ::= NK_MINUS NK_HEX */ - 405, /* (442) tags_literal ::= NK_MINUS NK_HEX NK_PLUS duration_literal */ - 405, /* (443) tags_literal ::= NK_MINUS NK_HEX NK_MINUS duration_literal */ - 405, /* (444) tags_literal ::= NK_STRING */ - 405, /* (445) tags_literal ::= NK_STRING NK_PLUS duration_literal */ - 405, /* (446) tags_literal ::= NK_STRING NK_MINUS duration_literal */ - 405, /* (447) tags_literal ::= NK_BOOL */ - 405, /* (448) tags_literal ::= NULL */ - 405, /* (449) tags_literal ::= literal_func */ - 405, /* (450) tags_literal ::= literal_func NK_PLUS duration_literal */ - 405, /* (451) tags_literal ::= literal_func NK_MINUS duration_literal */ - 408, /* (452) tags_literal_list ::= tags_literal */ - 408, /* (453) tags_literal_list ::= tags_literal_list NK_COMMA tags_literal */ - 361, /* (454) literal ::= NK_INTEGER */ - 361, /* (455) literal ::= NK_FLOAT */ - 361, /* (456) literal ::= NK_STRING */ - 361, /* (457) literal ::= NK_BOOL */ - 361, /* (458) literal ::= TIMESTAMP NK_STRING */ - 361, /* (459) literal ::= duration_literal */ - 361, /* (460) literal ::= NULL */ - 361, /* (461) literal ::= NK_QUESTION */ - 417, /* (462) duration_literal ::= NK_VARIABLE */ - 390, /* (463) signed ::= NK_INTEGER */ - 390, /* (464) signed ::= NK_PLUS NK_INTEGER */ - 390, /* (465) signed ::= NK_MINUS NK_INTEGER */ - 390, /* (466) signed ::= NK_FLOAT */ - 390, /* (467) signed ::= NK_PLUS NK_FLOAT */ - 390, /* (468) signed ::= NK_MINUS NK_FLOAT */ - 463, /* (469) signed_literal ::= signed */ - 463, /* (470) signed_literal ::= NK_STRING */ - 463, /* (471) signed_literal ::= NK_BOOL */ - 463, /* (472) signed_literal ::= TIMESTAMP NK_STRING */ - 463, /* (473) signed_literal ::= duration_literal */ - 463, /* (474) signed_literal ::= NULL */ - 463, /* (475) signed_literal ::= literal_func */ - 463, /* (476) signed_literal ::= NK_QUESTION */ - 464, /* (477) literal_list ::= signed_literal */ - 464, /* (478) literal_list ::= literal_list NK_COMMA signed_literal */ - 373, /* (479) db_name ::= NK_ID */ - 374, /* (480) table_name ::= NK_ID */ - 402, /* (481) column_name ::= NK_ID */ - 419, /* (482) function_name ::= NK_ID */ - 452, /* (483) view_name ::= NK_ID */ - 465, /* (484) table_alias ::= NK_ID */ - 430, /* (485) column_alias ::= NK_ID */ - 430, /* (486) column_alias ::= NK_ALIAS */ - 366, /* (487) user_name ::= NK_ID */ - 375, /* (488) topic_name ::= NK_ID */ - 453, /* (489) stream_name ::= NK_ID */ - 443, /* (490) cgroup_name ::= NK_ID */ - 433, /* (491) index_name ::= NK_ID */ - 466, /* (492) expr_or_subquery ::= expression */ - 459, /* (493) expression ::= literal */ - 459, /* (494) expression ::= pseudo_column */ - 459, /* (495) expression ::= column_reference */ - 459, /* (496) expression ::= function_expression */ - 459, /* (497) expression ::= case_when_expression */ - 459, /* (498) expression ::= NK_LP expression NK_RP */ - 459, /* (499) expression ::= NK_PLUS expr_or_subquery */ - 459, /* (500) expression ::= NK_MINUS expr_or_subquery */ - 459, /* (501) expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ - 459, /* (502) expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ - 459, /* (503) expression ::= expr_or_subquery NK_STAR expr_or_subquery */ - 459, /* (504) expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ - 459, /* (505) expression ::= expr_or_subquery NK_REM expr_or_subquery */ - 459, /* (506) expression ::= column_reference NK_ARROW NK_STRING */ - 459, /* (507) expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ - 459, /* (508) expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ - 439, /* (509) expression_list ::= expr_or_subquery */ - 439, /* (510) expression_list ::= expression_list NK_COMMA expr_or_subquery */ - 468, /* (511) column_reference ::= column_name */ - 468, /* (512) column_reference ::= table_name NK_DOT column_name */ - 468, /* (513) column_reference ::= NK_ALIAS */ - 468, /* (514) column_reference ::= table_name NK_DOT NK_ALIAS */ - 467, /* (515) pseudo_column ::= ROWTS */ - 467, /* (516) pseudo_column ::= TBNAME */ - 467, /* (517) pseudo_column ::= table_name NK_DOT TBNAME */ - 467, /* (518) pseudo_column ::= QSTART */ - 467, /* (519) pseudo_column ::= QEND */ - 467, /* (520) pseudo_column ::= QDURATION */ - 467, /* (521) pseudo_column ::= WSTART */ - 467, /* (522) pseudo_column ::= WEND */ - 467, /* (523) pseudo_column ::= WDURATION */ - 467, /* (524) pseudo_column ::= IROWTS */ - 467, /* (525) pseudo_column ::= ISFILLED */ - 467, /* (526) pseudo_column ::= QTAGS */ - 469, /* (527) function_expression ::= function_name NK_LP expression_list NK_RP */ - 469, /* (528) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ - 469, /* (529) function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ - 469, /* (530) function_expression ::= literal_func */ - 462, /* (531) literal_func ::= noarg_func NK_LP NK_RP */ - 462, /* (532) literal_func ::= NOW */ - 462, /* (533) literal_func ::= TODAY */ - 473, /* (534) noarg_func ::= NOW */ - 473, /* (535) noarg_func ::= TODAY */ - 473, /* (536) noarg_func ::= TIMEZONE */ - 473, /* (537) noarg_func ::= DATABASE */ - 473, /* (538) noarg_func ::= CLIENT_VERSION */ - 473, /* (539) noarg_func ::= SERVER_VERSION */ - 473, /* (540) noarg_func ::= SERVER_STATUS */ - 473, /* (541) noarg_func ::= CURRENT_USER */ - 473, /* (542) noarg_func ::= USER */ - 471, /* (543) star_func ::= COUNT */ - 471, /* (544) star_func ::= FIRST */ - 471, /* (545) star_func ::= LAST */ - 471, /* (546) star_func ::= LAST_ROW */ - 472, /* (547) star_func_para_list ::= NK_STAR */ - 472, /* (548) star_func_para_list ::= other_para_list */ - 474, /* (549) other_para_list ::= star_func_para */ - 474, /* (550) other_para_list ::= other_para_list NK_COMMA star_func_para */ - 475, /* (551) star_func_para ::= expr_or_subquery */ - 475, /* (552) star_func_para ::= table_name NK_DOT NK_STAR */ - 470, /* (553) case_when_expression ::= CASE when_then_list case_when_else_opt END */ - 470, /* (554) case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ - 476, /* (555) when_then_list ::= when_then_expr */ - 476, /* (556) when_then_list ::= when_then_list when_then_expr */ - 479, /* (557) when_then_expr ::= WHEN common_expression THEN common_expression */ - 477, /* (558) case_when_else_opt ::= */ - 477, /* (559) case_when_else_opt ::= ELSE common_expression */ - 480, /* (560) predicate ::= expr_or_subquery compare_op expr_or_subquery */ - 480, /* (561) predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ - 480, /* (562) predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ - 480, /* (563) predicate ::= expr_or_subquery IS NULL */ - 480, /* (564) predicate ::= expr_or_subquery IS NOT NULL */ - 480, /* (565) predicate ::= expr_or_subquery in_op in_predicate_value */ - 481, /* (566) compare_op ::= NK_LT */ - 481, /* (567) compare_op ::= NK_GT */ - 481, /* (568) compare_op ::= NK_LE */ - 481, /* (569) compare_op ::= NK_GE */ - 481, /* (570) compare_op ::= NK_NE */ - 481, /* (571) compare_op ::= NK_EQ */ - 481, /* (572) compare_op ::= LIKE */ - 481, /* (573) compare_op ::= NOT LIKE */ - 481, /* (574) compare_op ::= MATCH */ - 481, /* (575) compare_op ::= NMATCH */ - 481, /* (576) compare_op ::= CONTAINS */ - 482, /* (577) in_op ::= IN */ - 482, /* (578) in_op ::= NOT IN */ - 483, /* (579) in_predicate_value ::= NK_LP literal_list NK_RP */ - 484, /* (580) boolean_value_expression ::= boolean_primary */ - 484, /* (581) boolean_value_expression ::= NOT boolean_primary */ - 484, /* (582) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ - 484, /* (583) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ - 485, /* (584) boolean_primary ::= predicate */ - 485, /* (585) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ - 478, /* (586) common_expression ::= expr_or_subquery */ - 478, /* (587) common_expression ::= boolean_value_expression */ - 486, /* (588) from_clause_opt ::= */ - 486, /* (589) from_clause_opt ::= FROM table_reference_list */ - 487, /* (590) table_reference_list ::= table_reference */ - 487, /* (591) table_reference_list ::= table_reference_list NK_COMMA table_reference */ - 488, /* (592) table_reference ::= table_primary */ - 488, /* (593) table_reference ::= joined_table */ - 489, /* (594) table_primary ::= table_name alias_opt */ - 489, /* (595) table_primary ::= db_name NK_DOT table_name alias_opt */ - 489, /* (596) table_primary ::= subquery alias_opt */ - 489, /* (597) table_primary ::= parenthesized_joined_table */ - 491, /* (598) alias_opt ::= */ - 491, /* (599) alias_opt ::= table_alias */ - 491, /* (600) alias_opt ::= AS table_alias */ - 493, /* (601) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - 493, /* (602) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ - 490, /* (603) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ - 494, /* (604) join_type ::= */ - 494, /* (605) join_type ::= INNER */ - 495, /* (606) query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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 */ - 496, /* (607) hint_list ::= */ - 496, /* (608) hint_list ::= NK_HINT */ - 498, /* (609) tag_mode_opt ::= */ - 498, /* (610) tag_mode_opt ::= TAGS */ - 497, /* (611) set_quantifier_opt ::= */ - 497, /* (612) set_quantifier_opt ::= DISTINCT */ - 497, /* (613) set_quantifier_opt ::= ALL */ - 499, /* (614) select_list ::= select_item */ - 499, /* (615) select_list ::= select_list NK_COMMA select_item */ - 507, /* (616) select_item ::= NK_STAR */ - 507, /* (617) select_item ::= common_expression */ - 507, /* (618) select_item ::= common_expression column_alias */ - 507, /* (619) select_item ::= common_expression AS column_alias */ - 507, /* (620) select_item ::= table_name NK_DOT NK_STAR */ - 442, /* (621) where_clause_opt ::= */ - 442, /* (622) where_clause_opt ::= WHERE search_condition */ - 500, /* (623) partition_by_clause_opt ::= */ - 500, /* (624) partition_by_clause_opt ::= PARTITION BY partition_list */ - 508, /* (625) partition_list ::= partition_item */ - 508, /* (626) partition_list ::= partition_list NK_COMMA partition_item */ - 509, /* (627) partition_item ::= expr_or_subquery */ - 509, /* (628) partition_item ::= expr_or_subquery column_alias */ - 509, /* (629) partition_item ::= expr_or_subquery AS column_alias */ - 504, /* (630) twindow_clause_opt ::= */ - 504, /* (631) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP */ - 504, /* (632) twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ - 504, /* (633) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ - 504, /* (634) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ - 504, /* (635) twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ - 504, /* (636) twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_RP */ - 504, /* (637) twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ - 435, /* (638) sliding_opt ::= */ - 435, /* (639) sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP */ - 510, /* (640) interval_sliding_duration_literal ::= NK_VARIABLE */ - 510, /* (641) interval_sliding_duration_literal ::= NK_STRING */ - 510, /* (642) interval_sliding_duration_literal ::= NK_INTEGER */ - 503, /* (643) fill_opt ::= */ - 503, /* (644) fill_opt ::= FILL NK_LP fill_mode NK_RP */ - 503, /* (645) fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ - 503, /* (646) fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ - 511, /* (647) fill_mode ::= NONE */ - 511, /* (648) fill_mode ::= PREV */ - 511, /* (649) fill_mode ::= NULL */ - 511, /* (650) fill_mode ::= NULL_F */ - 511, /* (651) fill_mode ::= LINEAR */ - 511, /* (652) fill_mode ::= NEXT */ - 505, /* (653) group_by_clause_opt ::= */ - 505, /* (654) group_by_clause_opt ::= GROUP BY group_by_list */ - 512, /* (655) group_by_list ::= expr_or_subquery */ - 512, /* (656) group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ - 506, /* (657) having_clause_opt ::= */ - 506, /* (658) having_clause_opt ::= HAVING search_condition */ - 501, /* (659) range_opt ::= */ - 501, /* (660) range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ - 501, /* (661) range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ - 502, /* (662) every_opt ::= */ - 502, /* (663) every_opt ::= EVERY NK_LP duration_literal NK_RP */ - 513, /* (664) query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ - 514, /* (665) query_simple ::= query_specification */ - 514, /* (666) query_simple ::= union_query_expression */ - 518, /* (667) union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ - 518, /* (668) union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ - 519, /* (669) query_simple_or_subquery ::= query_simple */ - 519, /* (670) query_simple_or_subquery ::= subquery */ - 441, /* (671) query_or_subquery ::= query_expression */ - 441, /* (672) query_or_subquery ::= subquery */ - 515, /* (673) order_by_clause_opt ::= */ - 515, /* (674) order_by_clause_opt ::= ORDER BY sort_specification_list */ - 516, /* (675) slimit_clause_opt ::= */ - 516, /* (676) slimit_clause_opt ::= SLIMIT NK_INTEGER */ - 516, /* (677) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - 516, /* (678) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - 517, /* (679) limit_clause_opt ::= */ - 517, /* (680) limit_clause_opt ::= LIMIT NK_INTEGER */ - 517, /* (681) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ - 517, /* (682) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - 492, /* (683) subquery ::= NK_LP query_expression NK_RP */ - 492, /* (684) subquery ::= NK_LP subquery NK_RP */ - 376, /* (685) search_condition ::= common_expression */ - 520, /* (686) sort_specification_list ::= sort_specification */ - 520, /* (687) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ - 521, /* (688) sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ - 522, /* (689) ordering_specification_opt ::= */ - 522, /* (690) ordering_specification_opt ::= ASC */ - 522, /* (691) ordering_specification_opt ::= DESC */ - 523, /* (692) null_ordering_opt ::= */ - 523, /* (693) null_ordering_opt ::= NULLS FIRST */ - 523, /* (694) null_ordering_opt ::= NULLS LAST */ - 404, /* (695) column_options ::= */ - 404, /* (696) column_options ::= column_options PRIMARY KEY */ - 404, /* (697) column_options ::= column_options ENCODE NK_STRING */ - 404, /* (698) column_options ::= column_options COMPRESS NK_STRING */ - 404, /* (699) column_options ::= column_options LEVEL NK_STRING */ + 414, /* (223) type_name_default_len ::= BINARY */ + 414, /* (224) type_name_default_len ::= NCHAR */ + 414, /* (225) type_name_default_len ::= VARCHAR */ + 414, /* (226) type_name_default_len ::= VARBINARY */ + 395, /* (227) tags_def_opt ::= */ + 395, /* (228) tags_def_opt ::= tags_def */ + 398, /* (229) tags_def ::= TAGS NK_LP tag_def_list NK_RP */ + 396, /* (230) table_options ::= */ + 396, /* (231) table_options ::= table_options COMMENT NK_STRING */ + 396, /* (232) table_options ::= table_options MAX_DELAY duration_list */ + 396, /* (233) table_options ::= table_options WATERMARK duration_list */ + 396, /* (234) table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ + 396, /* (235) table_options ::= table_options TTL NK_INTEGER */ + 396, /* (236) table_options ::= table_options SMA NK_LP col_name_list NK_RP */ + 396, /* (237) table_options ::= table_options DELETE_MARK duration_list */ + 401, /* (238) alter_table_options ::= alter_table_option */ + 401, /* (239) alter_table_options ::= alter_table_options alter_table_option */ + 417, /* (240) alter_table_option ::= COMMENT NK_STRING */ + 417, /* (241) alter_table_option ::= TTL NK_INTEGER */ + 415, /* (242) duration_list ::= duration_literal */ + 415, /* (243) duration_list ::= duration_list NK_COMMA duration_literal */ + 416, /* (244) rollup_func_list ::= rollup_func_name */ + 416, /* (245) rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ + 419, /* (246) rollup_func_name ::= function_name */ + 419, /* (247) rollup_func_name ::= FIRST */ + 419, /* (248) rollup_func_name ::= LAST */ + 410, /* (249) col_name_list ::= col_name */ + 410, /* (250) col_name_list ::= col_name_list NK_COMMA col_name */ + 421, /* (251) col_name ::= column_name */ + 358, /* (252) cmd ::= SHOW DNODES */ + 358, /* (253) cmd ::= SHOW USERS */ + 358, /* (254) cmd ::= SHOW USER PRIVILEGES */ + 358, /* (255) cmd ::= SHOW db_kind_opt DATABASES */ + 358, /* (256) cmd ::= SHOW table_kind_db_name_cond_opt TABLES like_pattern_opt */ + 358, /* (257) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ + 358, /* (258) cmd ::= SHOW db_name_cond_opt VGROUPS */ + 358, /* (259) cmd ::= SHOW MNODES */ + 358, /* (260) cmd ::= SHOW QNODES */ + 358, /* (261) cmd ::= SHOW ARBGROUPS */ + 358, /* (262) cmd ::= SHOW FUNCTIONS */ + 358, /* (263) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ + 358, /* (264) cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */ + 358, /* (265) cmd ::= SHOW STREAMS */ + 358, /* (266) cmd ::= SHOW ACCOUNTS */ + 358, /* (267) cmd ::= SHOW APPS */ + 358, /* (268) cmd ::= SHOW CONNECTIONS */ + 358, /* (269) cmd ::= SHOW LICENCES */ + 358, /* (270) cmd ::= SHOW GRANTS */ + 358, /* (271) cmd ::= SHOW GRANTS FULL */ + 358, /* (272) cmd ::= SHOW GRANTS LOGS */ + 358, /* (273) cmd ::= SHOW CLUSTER MACHINES */ + 358, /* (274) cmd ::= SHOW CREATE DATABASE db_name */ + 358, /* (275) cmd ::= SHOW CREATE TABLE full_table_name */ + 358, /* (276) cmd ::= SHOW CREATE STABLE full_table_name */ + 358, /* (277) cmd ::= SHOW QUERIES */ + 358, /* (278) cmd ::= SHOW SCORES */ + 358, /* (279) cmd ::= SHOW TOPICS */ + 358, /* (280) cmd ::= SHOW VARIABLES */ + 358, /* (281) cmd ::= SHOW CLUSTER VARIABLES */ + 358, /* (282) cmd ::= SHOW LOCAL VARIABLES */ + 358, /* (283) cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */ + 358, /* (284) cmd ::= SHOW BNODES */ + 358, /* (285) cmd ::= SHOW SNODES */ + 358, /* (286) cmd ::= SHOW CLUSTER */ + 358, /* (287) cmd ::= SHOW TRANSACTIONS */ + 358, /* (288) cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ + 358, /* (289) cmd ::= SHOW CONSUMERS */ + 358, /* (290) cmd ::= SHOW SUBSCRIPTIONS */ + 358, /* (291) cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ + 358, /* (292) cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */ + 358, /* (293) cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */ + 358, /* (294) cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */ + 358, /* (295) cmd ::= SHOW VNODES ON DNODE NK_INTEGER */ + 358, /* (296) cmd ::= SHOW VNODES */ + 358, /* (297) cmd ::= SHOW db_name_cond_opt ALIVE */ + 358, /* (298) cmd ::= SHOW CLUSTER ALIVE */ + 358, /* (299) cmd ::= SHOW db_name_cond_opt VIEWS like_pattern_opt */ + 358, /* (300) cmd ::= SHOW CREATE VIEW full_table_name */ + 358, /* (301) cmd ::= SHOW COMPACTS */ + 358, /* (302) cmd ::= SHOW COMPACT NK_INTEGER */ + 423, /* (303) table_kind_db_name_cond_opt ::= */ + 423, /* (304) table_kind_db_name_cond_opt ::= table_kind */ + 423, /* (305) table_kind_db_name_cond_opt ::= db_name NK_DOT */ + 423, /* (306) table_kind_db_name_cond_opt ::= table_kind db_name NK_DOT */ + 429, /* (307) table_kind ::= NORMAL */ + 429, /* (308) table_kind ::= CHILD */ + 425, /* (309) db_name_cond_opt ::= */ + 425, /* (310) db_name_cond_opt ::= db_name NK_DOT */ + 424, /* (311) like_pattern_opt ::= */ + 424, /* (312) like_pattern_opt ::= LIKE NK_STRING */ + 426, /* (313) table_name_cond ::= table_name */ + 427, /* (314) from_db_opt ::= */ + 427, /* (315) from_db_opt ::= FROM db_name */ + 428, /* (316) tag_list_opt ::= */ + 428, /* (317) tag_list_opt ::= tag_item */ + 428, /* (318) tag_list_opt ::= tag_list_opt NK_COMMA tag_item */ + 430, /* (319) tag_item ::= TBNAME */ + 430, /* (320) tag_item ::= QTAGS */ + 430, /* (321) tag_item ::= column_name */ + 430, /* (322) tag_item ::= column_name column_alias */ + 430, /* (323) tag_item ::= column_name AS column_alias */ + 422, /* (324) db_kind_opt ::= */ + 422, /* (325) db_kind_opt ::= USER */ + 422, /* (326) db_kind_opt ::= SYSTEM */ + 358, /* (327) cmd ::= CREATE SMA INDEX not_exists_opt col_name ON full_table_name index_options */ + 358, /* (328) cmd ::= CREATE INDEX not_exists_opt col_name ON full_table_name NK_LP col_name_list NK_RP */ + 358, /* (329) cmd ::= DROP INDEX exists_opt full_index_name */ + 433, /* (330) full_index_name ::= index_name */ + 433, /* (331) full_index_name ::= db_name NK_DOT index_name */ + 432, /* (332) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ + 432, /* (333) 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 */ + 435, /* (334) func_list ::= func */ + 435, /* (335) func_list ::= func_list NK_COMMA func */ + 438, /* (336) func ::= sma_func_name NK_LP expression_list NK_RP */ + 439, /* (337) sma_func_name ::= function_name */ + 439, /* (338) sma_func_name ::= COUNT */ + 439, /* (339) sma_func_name ::= FIRST */ + 439, /* (340) sma_func_name ::= LAST */ + 439, /* (341) sma_func_name ::= LAST_ROW */ + 437, /* (342) sma_stream_opt ::= */ + 437, /* (343) sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */ + 437, /* (344) sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */ + 437, /* (345) sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */ + 441, /* (346) with_meta ::= AS */ + 441, /* (347) with_meta ::= WITH META AS */ + 441, /* (348) with_meta ::= ONLY META AS */ + 358, /* (349) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */ + 358, /* (350) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */ + 358, /* (351) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */ + 358, /* (352) cmd ::= DROP TOPIC exists_opt topic_name */ + 358, /* (353) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ + 358, /* (354) cmd ::= DESC full_table_name */ + 358, /* (355) cmd ::= DESCRIBE full_table_name */ + 358, /* (356) cmd ::= RESET QUERY CACHE */ + 358, /* (357) cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */ + 358, /* (358) cmd ::= EXPLAIN analyze_opt explain_options insert_query */ + 445, /* (359) analyze_opt ::= */ + 445, /* (360) analyze_opt ::= ANALYZE */ + 446, /* (361) explain_options ::= */ + 446, /* (362) explain_options ::= explain_options VERBOSE NK_BOOL */ + 446, /* (363) explain_options ::= explain_options RATIO NK_FLOAT */ + 358, /* (364) cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */ + 358, /* (365) cmd ::= DROP FUNCTION exists_opt function_name */ + 449, /* (366) agg_func_opt ::= */ + 449, /* (367) agg_func_opt ::= AGGREGATE */ + 450, /* (368) bufsize_opt ::= */ + 450, /* (369) bufsize_opt ::= BUFSIZE NK_INTEGER */ + 451, /* (370) language_opt ::= */ + 451, /* (371) language_opt ::= LANGUAGE NK_STRING */ + 448, /* (372) or_replace_opt ::= */ + 448, /* (373) or_replace_opt ::= OR REPLACE */ + 358, /* (374) cmd ::= CREATE or_replace_opt VIEW full_view_name AS query_or_subquery */ + 358, /* (375) cmd ::= DROP VIEW exists_opt full_view_name */ + 452, /* (376) full_view_name ::= view_name */ + 452, /* (377) full_view_name ::= db_name NK_DOT view_name */ + 358, /* (378) 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 */ + 358, /* (379) cmd ::= DROP STREAM exists_opt stream_name */ + 358, /* (380) cmd ::= PAUSE STREAM exists_opt stream_name */ + 358, /* (381) cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */ + 456, /* (382) col_list_opt ::= */ + 456, /* (383) col_list_opt ::= NK_LP col_name_list NK_RP */ + 457, /* (384) tag_def_or_ref_opt ::= */ + 457, /* (385) tag_def_or_ref_opt ::= tags_def */ + 457, /* (386) tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP */ + 455, /* (387) stream_options ::= */ + 455, /* (388) stream_options ::= stream_options TRIGGER AT_ONCE */ + 455, /* (389) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ + 455, /* (390) stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ + 455, /* (391) stream_options ::= stream_options WATERMARK duration_literal */ + 455, /* (392) stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ + 455, /* (393) stream_options ::= stream_options FILL_HISTORY NK_INTEGER */ + 455, /* (394) stream_options ::= stream_options DELETE_MARK duration_literal */ + 455, /* (395) stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */ + 458, /* (396) subtable_opt ::= */ + 458, /* (397) subtable_opt ::= SUBTABLE NK_LP expression NK_RP */ + 459, /* (398) ignore_opt ::= */ + 459, /* (399) ignore_opt ::= IGNORE UNTREATED */ + 358, /* (400) cmd ::= KILL CONNECTION NK_INTEGER */ + 358, /* (401) cmd ::= KILL QUERY NK_STRING */ + 358, /* (402) cmd ::= KILL TRANSACTION NK_INTEGER */ + 358, /* (403) cmd ::= KILL COMPACT NK_INTEGER */ + 358, /* (404) cmd ::= BALANCE VGROUP */ + 358, /* (405) cmd ::= BALANCE VGROUP LEADER on_vgroup_id */ + 358, /* (406) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ + 358, /* (407) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ + 358, /* (408) cmd ::= SPLIT VGROUP NK_INTEGER */ + 461, /* (409) on_vgroup_id ::= */ + 461, /* (410) on_vgroup_id ::= ON NK_INTEGER */ + 462, /* (411) dnode_list ::= DNODE NK_INTEGER */ + 462, /* (412) dnode_list ::= dnode_list DNODE NK_INTEGER */ + 358, /* (413) cmd ::= DELETE FROM full_table_name where_clause_opt */ + 358, /* (414) cmd ::= query_or_subquery */ + 358, /* (415) cmd ::= insert_query */ + 447, /* (416) insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */ + 447, /* (417) insert_query ::= INSERT INTO full_table_name query_or_subquery */ + 405, /* (418) tags_literal ::= NK_INTEGER */ + 405, /* (419) tags_literal ::= NK_INTEGER NK_PLUS duration_literal */ + 405, /* (420) tags_literal ::= NK_INTEGER NK_MINUS duration_literal */ + 405, /* (421) tags_literal ::= NK_PLUS NK_INTEGER */ + 405, /* (422) tags_literal ::= NK_PLUS NK_INTEGER NK_PLUS duration_literal */ + 405, /* (423) tags_literal ::= NK_PLUS NK_INTEGER NK_MINUS duration_literal */ + 405, /* (424) tags_literal ::= NK_MINUS NK_INTEGER */ + 405, /* (425) tags_literal ::= NK_MINUS NK_INTEGER NK_PLUS duration_literal */ + 405, /* (426) tags_literal ::= NK_MINUS NK_INTEGER NK_MINUS duration_literal */ + 405, /* (427) tags_literal ::= NK_FLOAT */ + 405, /* (428) tags_literal ::= NK_PLUS NK_FLOAT */ + 405, /* (429) tags_literal ::= NK_MINUS NK_FLOAT */ + 405, /* (430) tags_literal ::= NK_BIN */ + 405, /* (431) tags_literal ::= NK_BIN NK_PLUS duration_literal */ + 405, /* (432) tags_literal ::= NK_BIN NK_MINUS duration_literal */ + 405, /* (433) tags_literal ::= NK_PLUS NK_BIN */ + 405, /* (434) tags_literal ::= NK_PLUS NK_BIN NK_PLUS duration_literal */ + 405, /* (435) tags_literal ::= NK_PLUS NK_BIN NK_MINUS duration_literal */ + 405, /* (436) tags_literal ::= NK_MINUS NK_BIN */ + 405, /* (437) tags_literal ::= NK_MINUS NK_BIN NK_PLUS duration_literal */ + 405, /* (438) tags_literal ::= NK_MINUS NK_BIN NK_MINUS duration_literal */ + 405, /* (439) tags_literal ::= NK_HEX */ + 405, /* (440) tags_literal ::= NK_HEX NK_PLUS duration_literal */ + 405, /* (441) tags_literal ::= NK_HEX NK_MINUS duration_literal */ + 405, /* (442) tags_literal ::= NK_PLUS NK_HEX */ + 405, /* (443) tags_literal ::= NK_PLUS NK_HEX NK_PLUS duration_literal */ + 405, /* (444) tags_literal ::= NK_PLUS NK_HEX NK_MINUS duration_literal */ + 405, /* (445) tags_literal ::= NK_MINUS NK_HEX */ + 405, /* (446) tags_literal ::= NK_MINUS NK_HEX NK_PLUS duration_literal */ + 405, /* (447) tags_literal ::= NK_MINUS NK_HEX NK_MINUS duration_literal */ + 405, /* (448) tags_literal ::= NK_STRING */ + 405, /* (449) tags_literal ::= NK_STRING NK_PLUS duration_literal */ + 405, /* (450) tags_literal ::= NK_STRING NK_MINUS duration_literal */ + 405, /* (451) tags_literal ::= NK_BOOL */ + 405, /* (452) tags_literal ::= NULL */ + 405, /* (453) tags_literal ::= literal_func */ + 405, /* (454) tags_literal ::= literal_func NK_PLUS duration_literal */ + 405, /* (455) tags_literal ::= literal_func NK_MINUS duration_literal */ + 408, /* (456) tags_literal_list ::= tags_literal */ + 408, /* (457) tags_literal_list ::= tags_literal_list NK_COMMA tags_literal */ + 361, /* (458) literal ::= NK_INTEGER */ + 361, /* (459) literal ::= NK_FLOAT */ + 361, /* (460) literal ::= NK_STRING */ + 361, /* (461) literal ::= NK_BOOL */ + 361, /* (462) literal ::= TIMESTAMP NK_STRING */ + 361, /* (463) literal ::= duration_literal */ + 361, /* (464) literal ::= NULL */ + 361, /* (465) literal ::= NK_QUESTION */ + 418, /* (466) duration_literal ::= NK_VARIABLE */ + 390, /* (467) signed ::= NK_INTEGER */ + 390, /* (468) signed ::= NK_PLUS NK_INTEGER */ + 390, /* (469) signed ::= NK_MINUS NK_INTEGER */ + 390, /* (470) signed ::= NK_FLOAT */ + 390, /* (471) signed ::= NK_PLUS NK_FLOAT */ + 390, /* (472) signed ::= NK_MINUS NK_FLOAT */ + 464, /* (473) signed_literal ::= signed */ + 464, /* (474) signed_literal ::= NK_STRING */ + 464, /* (475) signed_literal ::= NK_BOOL */ + 464, /* (476) signed_literal ::= TIMESTAMP NK_STRING */ + 464, /* (477) signed_literal ::= duration_literal */ + 464, /* (478) signed_literal ::= NULL */ + 464, /* (479) signed_literal ::= literal_func */ + 464, /* (480) signed_literal ::= NK_QUESTION */ + 465, /* (481) literal_list ::= signed_literal */ + 465, /* (482) literal_list ::= literal_list NK_COMMA signed_literal */ + 373, /* (483) db_name ::= NK_ID */ + 374, /* (484) table_name ::= NK_ID */ + 402, /* (485) column_name ::= NK_ID */ + 420, /* (486) function_name ::= NK_ID */ + 453, /* (487) view_name ::= NK_ID */ + 466, /* (488) table_alias ::= NK_ID */ + 431, /* (489) column_alias ::= NK_ID */ + 431, /* (490) column_alias ::= NK_ALIAS */ + 366, /* (491) user_name ::= NK_ID */ + 375, /* (492) topic_name ::= NK_ID */ + 454, /* (493) stream_name ::= NK_ID */ + 444, /* (494) cgroup_name ::= NK_ID */ + 434, /* (495) index_name ::= NK_ID */ + 467, /* (496) expr_or_subquery ::= expression */ + 460, /* (497) expression ::= literal */ + 460, /* (498) expression ::= pseudo_column */ + 460, /* (499) expression ::= column_reference */ + 460, /* (500) expression ::= function_expression */ + 460, /* (501) expression ::= case_when_expression */ + 460, /* (502) expression ::= NK_LP expression NK_RP */ + 460, /* (503) expression ::= NK_PLUS expr_or_subquery */ + 460, /* (504) expression ::= NK_MINUS expr_or_subquery */ + 460, /* (505) expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ + 460, /* (506) expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ + 460, /* (507) expression ::= expr_or_subquery NK_STAR expr_or_subquery */ + 460, /* (508) expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ + 460, /* (509) expression ::= expr_or_subquery NK_REM expr_or_subquery */ + 460, /* (510) expression ::= column_reference NK_ARROW NK_STRING */ + 460, /* (511) expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ + 460, /* (512) expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ + 440, /* (513) expression_list ::= expr_or_subquery */ + 440, /* (514) expression_list ::= expression_list NK_COMMA expr_or_subquery */ + 469, /* (515) column_reference ::= column_name */ + 469, /* (516) column_reference ::= table_name NK_DOT column_name */ + 469, /* (517) column_reference ::= NK_ALIAS */ + 469, /* (518) column_reference ::= table_name NK_DOT NK_ALIAS */ + 468, /* (519) pseudo_column ::= ROWTS */ + 468, /* (520) pseudo_column ::= TBNAME */ + 468, /* (521) pseudo_column ::= table_name NK_DOT TBNAME */ + 468, /* (522) pseudo_column ::= QSTART */ + 468, /* (523) pseudo_column ::= QEND */ + 468, /* (524) pseudo_column ::= QDURATION */ + 468, /* (525) pseudo_column ::= WSTART */ + 468, /* (526) pseudo_column ::= WEND */ + 468, /* (527) pseudo_column ::= WDURATION */ + 468, /* (528) pseudo_column ::= IROWTS */ + 468, /* (529) pseudo_column ::= ISFILLED */ + 468, /* (530) pseudo_column ::= QTAGS */ + 470, /* (531) function_expression ::= function_name NK_LP expression_list NK_RP */ + 470, /* (532) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ + 470, /* (533) function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ + 470, /* (534) function_expression ::= CAST NK_LP expr_or_subquery AS type_name_default_len NK_RP */ + 470, /* (535) function_expression ::= literal_func */ + 463, /* (536) literal_func ::= noarg_func NK_LP NK_RP */ + 463, /* (537) literal_func ::= NOW */ + 463, /* (538) literal_func ::= TODAY */ + 474, /* (539) noarg_func ::= NOW */ + 474, /* (540) noarg_func ::= TODAY */ + 474, /* (541) noarg_func ::= TIMEZONE */ + 474, /* (542) noarg_func ::= DATABASE */ + 474, /* (543) noarg_func ::= CLIENT_VERSION */ + 474, /* (544) noarg_func ::= SERVER_VERSION */ + 474, /* (545) noarg_func ::= SERVER_STATUS */ + 474, /* (546) noarg_func ::= CURRENT_USER */ + 474, /* (547) noarg_func ::= USER */ + 472, /* (548) star_func ::= COUNT */ + 472, /* (549) star_func ::= FIRST */ + 472, /* (550) star_func ::= LAST */ + 472, /* (551) star_func ::= LAST_ROW */ + 473, /* (552) star_func_para_list ::= NK_STAR */ + 473, /* (553) star_func_para_list ::= other_para_list */ + 475, /* (554) other_para_list ::= star_func_para */ + 475, /* (555) other_para_list ::= other_para_list NK_COMMA star_func_para */ + 476, /* (556) star_func_para ::= expr_or_subquery */ + 476, /* (557) star_func_para ::= table_name NK_DOT NK_STAR */ + 471, /* (558) case_when_expression ::= CASE when_then_list case_when_else_opt END */ + 471, /* (559) case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ + 477, /* (560) when_then_list ::= when_then_expr */ + 477, /* (561) when_then_list ::= when_then_list when_then_expr */ + 480, /* (562) when_then_expr ::= WHEN common_expression THEN common_expression */ + 478, /* (563) case_when_else_opt ::= */ + 478, /* (564) case_when_else_opt ::= ELSE common_expression */ + 481, /* (565) predicate ::= expr_or_subquery compare_op expr_or_subquery */ + 481, /* (566) predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ + 481, /* (567) predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ + 481, /* (568) predicate ::= expr_or_subquery IS NULL */ + 481, /* (569) predicate ::= expr_or_subquery IS NOT NULL */ + 481, /* (570) predicate ::= expr_or_subquery in_op in_predicate_value */ + 482, /* (571) compare_op ::= NK_LT */ + 482, /* (572) compare_op ::= NK_GT */ + 482, /* (573) compare_op ::= NK_LE */ + 482, /* (574) compare_op ::= NK_GE */ + 482, /* (575) compare_op ::= NK_NE */ + 482, /* (576) compare_op ::= NK_EQ */ + 482, /* (577) compare_op ::= LIKE */ + 482, /* (578) compare_op ::= NOT LIKE */ + 482, /* (579) compare_op ::= MATCH */ + 482, /* (580) compare_op ::= NMATCH */ + 482, /* (581) compare_op ::= CONTAINS */ + 483, /* (582) in_op ::= IN */ + 483, /* (583) in_op ::= NOT IN */ + 484, /* (584) in_predicate_value ::= NK_LP literal_list NK_RP */ + 485, /* (585) boolean_value_expression ::= boolean_primary */ + 485, /* (586) boolean_value_expression ::= NOT boolean_primary */ + 485, /* (587) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ + 485, /* (588) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ + 486, /* (589) boolean_primary ::= predicate */ + 486, /* (590) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ + 479, /* (591) common_expression ::= expr_or_subquery */ + 479, /* (592) common_expression ::= boolean_value_expression */ + 487, /* (593) from_clause_opt ::= */ + 487, /* (594) from_clause_opt ::= FROM table_reference_list */ + 488, /* (595) table_reference_list ::= table_reference */ + 488, /* (596) table_reference_list ::= table_reference_list NK_COMMA table_reference */ + 489, /* (597) table_reference ::= table_primary */ + 489, /* (598) table_reference ::= joined_table */ + 490, /* (599) table_primary ::= table_name alias_opt */ + 490, /* (600) table_primary ::= db_name NK_DOT table_name alias_opt */ + 490, /* (601) table_primary ::= subquery alias_opt */ + 490, /* (602) table_primary ::= parenthesized_joined_table */ + 492, /* (603) alias_opt ::= */ + 492, /* (604) alias_opt ::= table_alias */ + 492, /* (605) alias_opt ::= AS table_alias */ + 494, /* (606) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ + 494, /* (607) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ + 491, /* (608) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ + 495, /* (609) join_type ::= */ + 495, /* (610) join_type ::= INNER */ + 496, /* (611) query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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 */ + 497, /* (612) hint_list ::= */ + 497, /* (613) hint_list ::= NK_HINT */ + 499, /* (614) tag_mode_opt ::= */ + 499, /* (615) tag_mode_opt ::= TAGS */ + 498, /* (616) set_quantifier_opt ::= */ + 498, /* (617) set_quantifier_opt ::= DISTINCT */ + 498, /* (618) set_quantifier_opt ::= ALL */ + 500, /* (619) select_list ::= select_item */ + 500, /* (620) select_list ::= select_list NK_COMMA select_item */ + 508, /* (621) select_item ::= NK_STAR */ + 508, /* (622) select_item ::= common_expression */ + 508, /* (623) select_item ::= common_expression column_alias */ + 508, /* (624) select_item ::= common_expression AS column_alias */ + 508, /* (625) select_item ::= table_name NK_DOT NK_STAR */ + 443, /* (626) where_clause_opt ::= */ + 443, /* (627) where_clause_opt ::= WHERE search_condition */ + 501, /* (628) partition_by_clause_opt ::= */ + 501, /* (629) partition_by_clause_opt ::= PARTITION BY partition_list */ + 509, /* (630) partition_list ::= partition_item */ + 509, /* (631) partition_list ::= partition_list NK_COMMA partition_item */ + 510, /* (632) partition_item ::= expr_or_subquery */ + 510, /* (633) partition_item ::= expr_or_subquery column_alias */ + 510, /* (634) partition_item ::= expr_or_subquery AS column_alias */ + 505, /* (635) twindow_clause_opt ::= */ + 505, /* (636) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP */ + 505, /* (637) twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ + 505, /* (638) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ + 505, /* (639) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ + 505, /* (640) twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ + 505, /* (641) twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_RP */ + 505, /* (642) twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ + 436, /* (643) sliding_opt ::= */ + 436, /* (644) sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP */ + 511, /* (645) interval_sliding_duration_literal ::= NK_VARIABLE */ + 511, /* (646) interval_sliding_duration_literal ::= NK_STRING */ + 511, /* (647) interval_sliding_duration_literal ::= NK_INTEGER */ + 504, /* (648) fill_opt ::= */ + 504, /* (649) fill_opt ::= FILL NK_LP fill_mode NK_RP */ + 504, /* (650) fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ + 504, /* (651) fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ + 512, /* (652) fill_mode ::= NONE */ + 512, /* (653) fill_mode ::= PREV */ + 512, /* (654) fill_mode ::= NULL */ + 512, /* (655) fill_mode ::= NULL_F */ + 512, /* (656) fill_mode ::= LINEAR */ + 512, /* (657) fill_mode ::= NEXT */ + 506, /* (658) group_by_clause_opt ::= */ + 506, /* (659) group_by_clause_opt ::= GROUP BY group_by_list */ + 513, /* (660) group_by_list ::= expr_or_subquery */ + 513, /* (661) group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ + 507, /* (662) having_clause_opt ::= */ + 507, /* (663) having_clause_opt ::= HAVING search_condition */ + 502, /* (664) range_opt ::= */ + 502, /* (665) range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ + 502, /* (666) range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ + 503, /* (667) every_opt ::= */ + 503, /* (668) every_opt ::= EVERY NK_LP duration_literal NK_RP */ + 514, /* (669) query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ + 515, /* (670) query_simple ::= query_specification */ + 515, /* (671) query_simple ::= union_query_expression */ + 519, /* (672) union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ + 519, /* (673) union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ + 520, /* (674) query_simple_or_subquery ::= query_simple */ + 520, /* (675) query_simple_or_subquery ::= subquery */ + 442, /* (676) query_or_subquery ::= query_expression */ + 442, /* (677) query_or_subquery ::= subquery */ + 516, /* (678) order_by_clause_opt ::= */ + 516, /* (679) order_by_clause_opt ::= ORDER BY sort_specification_list */ + 517, /* (680) slimit_clause_opt ::= */ + 517, /* (681) slimit_clause_opt ::= SLIMIT NK_INTEGER */ + 517, /* (682) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + 517, /* (683) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + 518, /* (684) limit_clause_opt ::= */ + 518, /* (685) limit_clause_opt ::= LIMIT NK_INTEGER */ + 518, /* (686) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ + 518, /* (687) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + 493, /* (688) subquery ::= NK_LP query_expression NK_RP */ + 493, /* (689) subquery ::= NK_LP subquery NK_RP */ + 376, /* (690) search_condition ::= common_expression */ + 521, /* (691) sort_specification_list ::= sort_specification */ + 521, /* (692) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ + 522, /* (693) sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ + 523, /* (694) ordering_specification_opt ::= */ + 523, /* (695) ordering_specification_opt ::= ASC */ + 523, /* (696) ordering_specification_opt ::= DESC */ + 524, /* (697) null_ordering_opt ::= */ + 524, /* (698) null_ordering_opt ::= NULLS FIRST */ + 524, /* (699) null_ordering_opt ::= NULLS LAST */ + 404, /* (700) column_options ::= */ + 404, /* (701) column_options ::= column_options PRIMARY KEY */ + 404, /* (702) column_options ::= column_options ENCODE NK_STRING */ + 404, /* (703) column_options ::= column_options COMPRESS NK_STRING */ + 404, /* (704) column_options ::= column_options LEVEL NK_STRING */ }; /* For rule J, yyRuleInfoNRhs[J] contains the negative of the number @@ -4779,483 +4820,488 @@ static const signed char yyRuleInfoNRhs[] = { -1, /* (220) type_name ::= DECIMAL */ -4, /* (221) type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ -6, /* (222) type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ - 0, /* (223) tags_def_opt ::= */ - -1, /* (224) tags_def_opt ::= tags_def */ - -4, /* (225) tags_def ::= TAGS NK_LP tag_def_list NK_RP */ - 0, /* (226) table_options ::= */ - -3, /* (227) table_options ::= table_options COMMENT NK_STRING */ - -3, /* (228) table_options ::= table_options MAX_DELAY duration_list */ - -3, /* (229) table_options ::= table_options WATERMARK duration_list */ - -5, /* (230) table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ - -3, /* (231) table_options ::= table_options TTL NK_INTEGER */ - -5, /* (232) table_options ::= table_options SMA NK_LP col_name_list NK_RP */ - -3, /* (233) table_options ::= table_options DELETE_MARK duration_list */ - -1, /* (234) alter_table_options ::= alter_table_option */ - -2, /* (235) alter_table_options ::= alter_table_options alter_table_option */ - -2, /* (236) alter_table_option ::= COMMENT NK_STRING */ - -2, /* (237) alter_table_option ::= TTL NK_INTEGER */ - -1, /* (238) duration_list ::= duration_literal */ - -3, /* (239) duration_list ::= duration_list NK_COMMA duration_literal */ - -1, /* (240) rollup_func_list ::= rollup_func_name */ - -3, /* (241) rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ - -1, /* (242) rollup_func_name ::= function_name */ - -1, /* (243) rollup_func_name ::= FIRST */ - -1, /* (244) rollup_func_name ::= LAST */ - -1, /* (245) col_name_list ::= col_name */ - -3, /* (246) col_name_list ::= col_name_list NK_COMMA col_name */ - -1, /* (247) col_name ::= column_name */ - -2, /* (248) cmd ::= SHOW DNODES */ - -2, /* (249) cmd ::= SHOW USERS */ - -3, /* (250) cmd ::= SHOW USER PRIVILEGES */ - -3, /* (251) cmd ::= SHOW db_kind_opt DATABASES */ - -4, /* (252) cmd ::= SHOW table_kind_db_name_cond_opt TABLES like_pattern_opt */ - -4, /* (253) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ - -3, /* (254) cmd ::= SHOW db_name_cond_opt VGROUPS */ - -2, /* (255) cmd ::= SHOW MNODES */ - -2, /* (256) cmd ::= SHOW QNODES */ - -2, /* (257) cmd ::= SHOW ARBGROUPS */ - -2, /* (258) cmd ::= SHOW FUNCTIONS */ - -5, /* (259) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ - -6, /* (260) cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */ - -2, /* (261) cmd ::= SHOW STREAMS */ - -2, /* (262) cmd ::= SHOW ACCOUNTS */ - -2, /* (263) cmd ::= SHOW APPS */ - -2, /* (264) cmd ::= SHOW CONNECTIONS */ - -2, /* (265) cmd ::= SHOW LICENCES */ - -2, /* (266) cmd ::= SHOW GRANTS */ - -3, /* (267) cmd ::= SHOW GRANTS FULL */ - -3, /* (268) cmd ::= SHOW GRANTS LOGS */ - -3, /* (269) cmd ::= SHOW CLUSTER MACHINES */ - -4, /* (270) cmd ::= SHOW CREATE DATABASE db_name */ - -4, /* (271) cmd ::= SHOW CREATE TABLE full_table_name */ - -4, /* (272) cmd ::= SHOW CREATE STABLE full_table_name */ - -2, /* (273) cmd ::= SHOW QUERIES */ - -2, /* (274) cmd ::= SHOW SCORES */ - -2, /* (275) cmd ::= SHOW TOPICS */ - -2, /* (276) cmd ::= SHOW VARIABLES */ - -3, /* (277) cmd ::= SHOW CLUSTER VARIABLES */ - -3, /* (278) cmd ::= SHOW LOCAL VARIABLES */ - -5, /* (279) cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */ - -2, /* (280) cmd ::= SHOW BNODES */ - -2, /* (281) cmd ::= SHOW SNODES */ - -2, /* (282) cmd ::= SHOW CLUSTER */ - -2, /* (283) cmd ::= SHOW TRANSACTIONS */ - -4, /* (284) cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ - -2, /* (285) cmd ::= SHOW CONSUMERS */ - -2, /* (286) cmd ::= SHOW SUBSCRIPTIONS */ - -5, /* (287) cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ - -6, /* (288) cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */ - -7, /* (289) cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */ - -8, /* (290) cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */ - -5, /* (291) cmd ::= SHOW VNODES ON DNODE NK_INTEGER */ - -2, /* (292) cmd ::= SHOW VNODES */ - -3, /* (293) cmd ::= SHOW db_name_cond_opt ALIVE */ - -3, /* (294) cmd ::= SHOW CLUSTER ALIVE */ - -4, /* (295) cmd ::= SHOW db_name_cond_opt VIEWS like_pattern_opt */ - -4, /* (296) cmd ::= SHOW CREATE VIEW full_table_name */ - -2, /* (297) cmd ::= SHOW COMPACTS */ - -3, /* (298) cmd ::= SHOW COMPACT NK_INTEGER */ - 0, /* (299) table_kind_db_name_cond_opt ::= */ - -1, /* (300) table_kind_db_name_cond_opt ::= table_kind */ - -2, /* (301) table_kind_db_name_cond_opt ::= db_name NK_DOT */ - -3, /* (302) table_kind_db_name_cond_opt ::= table_kind db_name NK_DOT */ - -1, /* (303) table_kind ::= NORMAL */ - -1, /* (304) table_kind ::= CHILD */ - 0, /* (305) db_name_cond_opt ::= */ - -2, /* (306) db_name_cond_opt ::= db_name NK_DOT */ - 0, /* (307) like_pattern_opt ::= */ - -2, /* (308) like_pattern_opt ::= LIKE NK_STRING */ - -1, /* (309) table_name_cond ::= table_name */ - 0, /* (310) from_db_opt ::= */ - -2, /* (311) from_db_opt ::= FROM db_name */ - 0, /* (312) tag_list_opt ::= */ - -1, /* (313) tag_list_opt ::= tag_item */ - -3, /* (314) tag_list_opt ::= tag_list_opt NK_COMMA tag_item */ - -1, /* (315) tag_item ::= TBNAME */ - -1, /* (316) tag_item ::= QTAGS */ - -1, /* (317) tag_item ::= column_name */ - -2, /* (318) tag_item ::= column_name column_alias */ - -3, /* (319) tag_item ::= column_name AS column_alias */ - 0, /* (320) db_kind_opt ::= */ - -1, /* (321) db_kind_opt ::= USER */ - -1, /* (322) db_kind_opt ::= SYSTEM */ - -8, /* (323) cmd ::= CREATE SMA INDEX not_exists_opt col_name ON full_table_name index_options */ - -9, /* (324) cmd ::= CREATE INDEX not_exists_opt col_name ON full_table_name NK_LP col_name_list NK_RP */ - -4, /* (325) cmd ::= DROP INDEX exists_opt full_index_name */ - -1, /* (326) full_index_name ::= index_name */ - -3, /* (327) full_index_name ::= db_name NK_DOT index_name */ - -10, /* (328) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ - -12, /* (329) 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 */ - -1, /* (330) func_list ::= func */ - -3, /* (331) func_list ::= func_list NK_COMMA func */ - -4, /* (332) func ::= sma_func_name NK_LP expression_list NK_RP */ - -1, /* (333) sma_func_name ::= function_name */ - -1, /* (334) sma_func_name ::= COUNT */ - -1, /* (335) sma_func_name ::= FIRST */ - -1, /* (336) sma_func_name ::= LAST */ - -1, /* (337) sma_func_name ::= LAST_ROW */ - 0, /* (338) sma_stream_opt ::= */ - -3, /* (339) sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */ - -3, /* (340) sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */ - -3, /* (341) sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */ - -1, /* (342) with_meta ::= AS */ - -3, /* (343) with_meta ::= WITH META AS */ - -3, /* (344) with_meta ::= ONLY META AS */ - -6, /* (345) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */ - -7, /* (346) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */ - -8, /* (347) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */ - -4, /* (348) cmd ::= DROP TOPIC exists_opt topic_name */ - -7, /* (349) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ - -2, /* (350) cmd ::= DESC full_table_name */ - -2, /* (351) cmd ::= DESCRIBE full_table_name */ - -3, /* (352) cmd ::= RESET QUERY CACHE */ - -4, /* (353) cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */ - -4, /* (354) cmd ::= EXPLAIN analyze_opt explain_options insert_query */ - 0, /* (355) analyze_opt ::= */ - -1, /* (356) analyze_opt ::= ANALYZE */ - 0, /* (357) explain_options ::= */ - -3, /* (358) explain_options ::= explain_options VERBOSE NK_BOOL */ - -3, /* (359) explain_options ::= explain_options RATIO NK_FLOAT */ - -12, /* (360) cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */ - -4, /* (361) cmd ::= DROP FUNCTION exists_opt function_name */ - 0, /* (362) agg_func_opt ::= */ - -1, /* (363) agg_func_opt ::= AGGREGATE */ - 0, /* (364) bufsize_opt ::= */ - -2, /* (365) bufsize_opt ::= BUFSIZE NK_INTEGER */ - 0, /* (366) language_opt ::= */ - -2, /* (367) language_opt ::= LANGUAGE NK_STRING */ - 0, /* (368) or_replace_opt ::= */ - -2, /* (369) or_replace_opt ::= OR REPLACE */ - -6, /* (370) cmd ::= CREATE or_replace_opt VIEW full_view_name AS query_or_subquery */ - -4, /* (371) cmd ::= DROP VIEW exists_opt full_view_name */ - -1, /* (372) full_view_name ::= view_name */ - -3, /* (373) full_view_name ::= db_name NK_DOT view_name */ - -12, /* (374) 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 */ - -4, /* (375) cmd ::= DROP STREAM exists_opt stream_name */ - -4, /* (376) cmd ::= PAUSE STREAM exists_opt stream_name */ - -5, /* (377) cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */ - 0, /* (378) col_list_opt ::= */ - -3, /* (379) col_list_opt ::= NK_LP col_name_list NK_RP */ - 0, /* (380) tag_def_or_ref_opt ::= */ - -1, /* (381) tag_def_or_ref_opt ::= tags_def */ - -4, /* (382) tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP */ - 0, /* (383) stream_options ::= */ - -3, /* (384) stream_options ::= stream_options TRIGGER AT_ONCE */ - -3, /* (385) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ - -4, /* (386) stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ - -3, /* (387) stream_options ::= stream_options WATERMARK duration_literal */ - -4, /* (388) stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ - -3, /* (389) stream_options ::= stream_options FILL_HISTORY NK_INTEGER */ - -3, /* (390) stream_options ::= stream_options DELETE_MARK duration_literal */ - -4, /* (391) stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */ - 0, /* (392) subtable_opt ::= */ - -4, /* (393) subtable_opt ::= SUBTABLE NK_LP expression NK_RP */ - 0, /* (394) ignore_opt ::= */ - -2, /* (395) ignore_opt ::= IGNORE UNTREATED */ - -3, /* (396) cmd ::= KILL CONNECTION NK_INTEGER */ - -3, /* (397) cmd ::= KILL QUERY NK_STRING */ - -3, /* (398) cmd ::= KILL TRANSACTION NK_INTEGER */ - -3, /* (399) cmd ::= KILL COMPACT NK_INTEGER */ - -2, /* (400) cmd ::= BALANCE VGROUP */ - -4, /* (401) cmd ::= BALANCE VGROUP LEADER on_vgroup_id */ - -4, /* (402) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ - -4, /* (403) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ - -3, /* (404) cmd ::= SPLIT VGROUP NK_INTEGER */ - 0, /* (405) on_vgroup_id ::= */ - -2, /* (406) on_vgroup_id ::= ON NK_INTEGER */ - -2, /* (407) dnode_list ::= DNODE NK_INTEGER */ - -3, /* (408) dnode_list ::= dnode_list DNODE NK_INTEGER */ - -4, /* (409) cmd ::= DELETE FROM full_table_name where_clause_opt */ - -1, /* (410) cmd ::= query_or_subquery */ - -1, /* (411) cmd ::= insert_query */ - -7, /* (412) insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */ - -4, /* (413) insert_query ::= INSERT INTO full_table_name query_or_subquery */ - -1, /* (414) tags_literal ::= NK_INTEGER */ - -3, /* (415) tags_literal ::= NK_INTEGER NK_PLUS duration_literal */ - -3, /* (416) tags_literal ::= NK_INTEGER NK_MINUS duration_literal */ - -2, /* (417) tags_literal ::= NK_PLUS NK_INTEGER */ - -4, /* (418) tags_literal ::= NK_PLUS NK_INTEGER NK_PLUS duration_literal */ - -4, /* (419) tags_literal ::= NK_PLUS NK_INTEGER NK_MINUS duration_literal */ - -2, /* (420) tags_literal ::= NK_MINUS NK_INTEGER */ - -4, /* (421) tags_literal ::= NK_MINUS NK_INTEGER NK_PLUS duration_literal */ - -4, /* (422) tags_literal ::= NK_MINUS NK_INTEGER NK_MINUS duration_literal */ - -1, /* (423) tags_literal ::= NK_FLOAT */ - -2, /* (424) tags_literal ::= NK_PLUS NK_FLOAT */ - -2, /* (425) tags_literal ::= NK_MINUS NK_FLOAT */ - -1, /* (426) tags_literal ::= NK_BIN */ - -3, /* (427) tags_literal ::= NK_BIN NK_PLUS duration_literal */ - -3, /* (428) tags_literal ::= NK_BIN NK_MINUS duration_literal */ - -2, /* (429) tags_literal ::= NK_PLUS NK_BIN */ - -4, /* (430) tags_literal ::= NK_PLUS NK_BIN NK_PLUS duration_literal */ - -4, /* (431) tags_literal ::= NK_PLUS NK_BIN NK_MINUS duration_literal */ - -2, /* (432) tags_literal ::= NK_MINUS NK_BIN */ - -4, /* (433) tags_literal ::= NK_MINUS NK_BIN NK_PLUS duration_literal */ - -4, /* (434) tags_literal ::= NK_MINUS NK_BIN NK_MINUS duration_literal */ - -1, /* (435) tags_literal ::= NK_HEX */ - -3, /* (436) tags_literal ::= NK_HEX NK_PLUS duration_literal */ - -3, /* (437) tags_literal ::= NK_HEX NK_MINUS duration_literal */ - -2, /* (438) tags_literal ::= NK_PLUS NK_HEX */ - -4, /* (439) tags_literal ::= NK_PLUS NK_HEX NK_PLUS duration_literal */ - -4, /* (440) tags_literal ::= NK_PLUS NK_HEX NK_MINUS duration_literal */ - -2, /* (441) tags_literal ::= NK_MINUS NK_HEX */ - -4, /* (442) tags_literal ::= NK_MINUS NK_HEX NK_PLUS duration_literal */ - -4, /* (443) tags_literal ::= NK_MINUS NK_HEX NK_MINUS duration_literal */ - -1, /* (444) tags_literal ::= NK_STRING */ - -3, /* (445) tags_literal ::= NK_STRING NK_PLUS duration_literal */ - -3, /* (446) tags_literal ::= NK_STRING NK_MINUS duration_literal */ - -1, /* (447) tags_literal ::= NK_BOOL */ - -1, /* (448) tags_literal ::= NULL */ - -1, /* (449) tags_literal ::= literal_func */ - -3, /* (450) tags_literal ::= literal_func NK_PLUS duration_literal */ - -3, /* (451) tags_literal ::= literal_func NK_MINUS duration_literal */ - -1, /* (452) tags_literal_list ::= tags_literal */ - -3, /* (453) tags_literal_list ::= tags_literal_list NK_COMMA tags_literal */ - -1, /* (454) literal ::= NK_INTEGER */ - -1, /* (455) literal ::= NK_FLOAT */ - -1, /* (456) literal ::= NK_STRING */ - -1, /* (457) literal ::= NK_BOOL */ - -2, /* (458) literal ::= TIMESTAMP NK_STRING */ - -1, /* (459) literal ::= duration_literal */ - -1, /* (460) literal ::= NULL */ - -1, /* (461) literal ::= NK_QUESTION */ - -1, /* (462) duration_literal ::= NK_VARIABLE */ - -1, /* (463) signed ::= NK_INTEGER */ - -2, /* (464) signed ::= NK_PLUS NK_INTEGER */ - -2, /* (465) signed ::= NK_MINUS NK_INTEGER */ - -1, /* (466) signed ::= NK_FLOAT */ - -2, /* (467) signed ::= NK_PLUS NK_FLOAT */ - -2, /* (468) signed ::= NK_MINUS NK_FLOAT */ - -1, /* (469) signed_literal ::= signed */ - -1, /* (470) signed_literal ::= NK_STRING */ - -1, /* (471) signed_literal ::= NK_BOOL */ - -2, /* (472) signed_literal ::= TIMESTAMP NK_STRING */ - -1, /* (473) signed_literal ::= duration_literal */ - -1, /* (474) signed_literal ::= NULL */ - -1, /* (475) signed_literal ::= literal_func */ - -1, /* (476) signed_literal ::= NK_QUESTION */ - -1, /* (477) literal_list ::= signed_literal */ - -3, /* (478) literal_list ::= literal_list NK_COMMA signed_literal */ - -1, /* (479) db_name ::= NK_ID */ - -1, /* (480) table_name ::= NK_ID */ - -1, /* (481) column_name ::= NK_ID */ - -1, /* (482) function_name ::= NK_ID */ - -1, /* (483) view_name ::= NK_ID */ - -1, /* (484) table_alias ::= NK_ID */ - -1, /* (485) column_alias ::= NK_ID */ - -1, /* (486) column_alias ::= NK_ALIAS */ - -1, /* (487) user_name ::= NK_ID */ - -1, /* (488) topic_name ::= NK_ID */ - -1, /* (489) stream_name ::= NK_ID */ - -1, /* (490) cgroup_name ::= NK_ID */ - -1, /* (491) index_name ::= NK_ID */ - -1, /* (492) expr_or_subquery ::= expression */ - -1, /* (493) expression ::= literal */ - -1, /* (494) expression ::= pseudo_column */ - -1, /* (495) expression ::= column_reference */ - -1, /* (496) expression ::= function_expression */ - -1, /* (497) expression ::= case_when_expression */ - -3, /* (498) expression ::= NK_LP expression NK_RP */ - -2, /* (499) expression ::= NK_PLUS expr_or_subquery */ - -2, /* (500) expression ::= NK_MINUS expr_or_subquery */ - -3, /* (501) expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ - -3, /* (502) expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ - -3, /* (503) expression ::= expr_or_subquery NK_STAR expr_or_subquery */ - -3, /* (504) expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ - -3, /* (505) expression ::= expr_or_subquery NK_REM expr_or_subquery */ - -3, /* (506) expression ::= column_reference NK_ARROW NK_STRING */ - -3, /* (507) expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ - -3, /* (508) expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ - -1, /* (509) expression_list ::= expr_or_subquery */ - -3, /* (510) expression_list ::= expression_list NK_COMMA expr_or_subquery */ - -1, /* (511) column_reference ::= column_name */ - -3, /* (512) column_reference ::= table_name NK_DOT column_name */ - -1, /* (513) column_reference ::= NK_ALIAS */ - -3, /* (514) column_reference ::= table_name NK_DOT NK_ALIAS */ - -1, /* (515) pseudo_column ::= ROWTS */ - -1, /* (516) pseudo_column ::= TBNAME */ - -3, /* (517) pseudo_column ::= table_name NK_DOT TBNAME */ - -1, /* (518) pseudo_column ::= QSTART */ - -1, /* (519) pseudo_column ::= QEND */ - -1, /* (520) pseudo_column ::= QDURATION */ - -1, /* (521) pseudo_column ::= WSTART */ - -1, /* (522) pseudo_column ::= WEND */ - -1, /* (523) pseudo_column ::= WDURATION */ - -1, /* (524) pseudo_column ::= IROWTS */ - -1, /* (525) pseudo_column ::= ISFILLED */ - -1, /* (526) pseudo_column ::= QTAGS */ - -4, /* (527) function_expression ::= function_name NK_LP expression_list NK_RP */ - -4, /* (528) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ - -6, /* (529) function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ - -1, /* (530) function_expression ::= literal_func */ - -3, /* (531) literal_func ::= noarg_func NK_LP NK_RP */ - -1, /* (532) literal_func ::= NOW */ - -1, /* (533) literal_func ::= TODAY */ - -1, /* (534) noarg_func ::= NOW */ - -1, /* (535) noarg_func ::= TODAY */ - -1, /* (536) noarg_func ::= TIMEZONE */ - -1, /* (537) noarg_func ::= DATABASE */ - -1, /* (538) noarg_func ::= CLIENT_VERSION */ - -1, /* (539) noarg_func ::= SERVER_VERSION */ - -1, /* (540) noarg_func ::= SERVER_STATUS */ - -1, /* (541) noarg_func ::= CURRENT_USER */ - -1, /* (542) noarg_func ::= USER */ - -1, /* (543) star_func ::= COUNT */ - -1, /* (544) star_func ::= FIRST */ - -1, /* (545) star_func ::= LAST */ - -1, /* (546) star_func ::= LAST_ROW */ - -1, /* (547) star_func_para_list ::= NK_STAR */ - -1, /* (548) star_func_para_list ::= other_para_list */ - -1, /* (549) other_para_list ::= star_func_para */ - -3, /* (550) other_para_list ::= other_para_list NK_COMMA star_func_para */ - -1, /* (551) star_func_para ::= expr_or_subquery */ - -3, /* (552) star_func_para ::= table_name NK_DOT NK_STAR */ - -4, /* (553) case_when_expression ::= CASE when_then_list case_when_else_opt END */ - -5, /* (554) case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ - -1, /* (555) when_then_list ::= when_then_expr */ - -2, /* (556) when_then_list ::= when_then_list when_then_expr */ - -4, /* (557) when_then_expr ::= WHEN common_expression THEN common_expression */ - 0, /* (558) case_when_else_opt ::= */ - -2, /* (559) case_when_else_opt ::= ELSE common_expression */ - -3, /* (560) predicate ::= expr_or_subquery compare_op expr_or_subquery */ - -5, /* (561) predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ - -6, /* (562) predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ - -3, /* (563) predicate ::= expr_or_subquery IS NULL */ - -4, /* (564) predicate ::= expr_or_subquery IS NOT NULL */ - -3, /* (565) predicate ::= expr_or_subquery in_op in_predicate_value */ - -1, /* (566) compare_op ::= NK_LT */ - -1, /* (567) compare_op ::= NK_GT */ - -1, /* (568) compare_op ::= NK_LE */ - -1, /* (569) compare_op ::= NK_GE */ - -1, /* (570) compare_op ::= NK_NE */ - -1, /* (571) compare_op ::= NK_EQ */ - -1, /* (572) compare_op ::= LIKE */ - -2, /* (573) compare_op ::= NOT LIKE */ - -1, /* (574) compare_op ::= MATCH */ - -1, /* (575) compare_op ::= NMATCH */ - -1, /* (576) compare_op ::= CONTAINS */ - -1, /* (577) in_op ::= IN */ - -2, /* (578) in_op ::= NOT IN */ - -3, /* (579) in_predicate_value ::= NK_LP literal_list NK_RP */ - -1, /* (580) boolean_value_expression ::= boolean_primary */ - -2, /* (581) boolean_value_expression ::= NOT boolean_primary */ - -3, /* (582) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ - -3, /* (583) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ - -1, /* (584) boolean_primary ::= predicate */ - -3, /* (585) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ - -1, /* (586) common_expression ::= expr_or_subquery */ - -1, /* (587) common_expression ::= boolean_value_expression */ - 0, /* (588) from_clause_opt ::= */ - -2, /* (589) from_clause_opt ::= FROM table_reference_list */ - -1, /* (590) table_reference_list ::= table_reference */ - -3, /* (591) table_reference_list ::= table_reference_list NK_COMMA table_reference */ - -1, /* (592) table_reference ::= table_primary */ - -1, /* (593) table_reference ::= joined_table */ - -2, /* (594) table_primary ::= table_name alias_opt */ - -4, /* (595) table_primary ::= db_name NK_DOT table_name alias_opt */ - -2, /* (596) table_primary ::= subquery alias_opt */ - -1, /* (597) table_primary ::= parenthesized_joined_table */ - 0, /* (598) alias_opt ::= */ - -1, /* (599) alias_opt ::= table_alias */ - -2, /* (600) alias_opt ::= AS table_alias */ - -3, /* (601) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - -3, /* (602) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ - -6, /* (603) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ - 0, /* (604) join_type ::= */ - -1, /* (605) join_type ::= INNER */ - -14, /* (606) query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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 */ - 0, /* (607) hint_list ::= */ - -1, /* (608) hint_list ::= NK_HINT */ - 0, /* (609) tag_mode_opt ::= */ - -1, /* (610) tag_mode_opt ::= TAGS */ - 0, /* (611) set_quantifier_opt ::= */ - -1, /* (612) set_quantifier_opt ::= DISTINCT */ - -1, /* (613) set_quantifier_opt ::= ALL */ - -1, /* (614) select_list ::= select_item */ - -3, /* (615) select_list ::= select_list NK_COMMA select_item */ - -1, /* (616) select_item ::= NK_STAR */ - -1, /* (617) select_item ::= common_expression */ - -2, /* (618) select_item ::= common_expression column_alias */ - -3, /* (619) select_item ::= common_expression AS column_alias */ - -3, /* (620) select_item ::= table_name NK_DOT NK_STAR */ - 0, /* (621) where_clause_opt ::= */ - -2, /* (622) where_clause_opt ::= WHERE search_condition */ - 0, /* (623) partition_by_clause_opt ::= */ - -3, /* (624) partition_by_clause_opt ::= PARTITION BY partition_list */ - -1, /* (625) partition_list ::= partition_item */ - -3, /* (626) partition_list ::= partition_list NK_COMMA partition_item */ - -1, /* (627) partition_item ::= expr_or_subquery */ - -2, /* (628) partition_item ::= expr_or_subquery column_alias */ - -3, /* (629) partition_item ::= expr_or_subquery AS column_alias */ - 0, /* (630) twindow_clause_opt ::= */ - -6, /* (631) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP */ - -4, /* (632) twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ - -6, /* (633) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ - -8, /* (634) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ - -7, /* (635) twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ - -4, /* (636) twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_RP */ - -6, /* (637) twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ - 0, /* (638) sliding_opt ::= */ - -4, /* (639) sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP */ - -1, /* (640) interval_sliding_duration_literal ::= NK_VARIABLE */ - -1, /* (641) interval_sliding_duration_literal ::= NK_STRING */ - -1, /* (642) interval_sliding_duration_literal ::= NK_INTEGER */ - 0, /* (643) fill_opt ::= */ - -4, /* (644) fill_opt ::= FILL NK_LP fill_mode NK_RP */ - -6, /* (645) fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ - -6, /* (646) fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ - -1, /* (647) fill_mode ::= NONE */ - -1, /* (648) fill_mode ::= PREV */ - -1, /* (649) fill_mode ::= NULL */ - -1, /* (650) fill_mode ::= NULL_F */ - -1, /* (651) fill_mode ::= LINEAR */ - -1, /* (652) fill_mode ::= NEXT */ - 0, /* (653) group_by_clause_opt ::= */ - -3, /* (654) group_by_clause_opt ::= GROUP BY group_by_list */ - -1, /* (655) group_by_list ::= expr_or_subquery */ - -3, /* (656) group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ - 0, /* (657) having_clause_opt ::= */ - -2, /* (658) having_clause_opt ::= HAVING search_condition */ - 0, /* (659) range_opt ::= */ - -6, /* (660) range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ - -4, /* (661) range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ - 0, /* (662) every_opt ::= */ - -4, /* (663) every_opt ::= EVERY NK_LP duration_literal NK_RP */ - -4, /* (664) query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ - -1, /* (665) query_simple ::= query_specification */ - -1, /* (666) query_simple ::= union_query_expression */ - -4, /* (667) union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ - -3, /* (668) union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ - -1, /* (669) query_simple_or_subquery ::= query_simple */ - -1, /* (670) query_simple_or_subquery ::= subquery */ - -1, /* (671) query_or_subquery ::= query_expression */ - -1, /* (672) query_or_subquery ::= subquery */ - 0, /* (673) order_by_clause_opt ::= */ - -3, /* (674) order_by_clause_opt ::= ORDER BY sort_specification_list */ - 0, /* (675) slimit_clause_opt ::= */ - -2, /* (676) slimit_clause_opt ::= SLIMIT NK_INTEGER */ - -4, /* (677) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - -4, /* (678) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - 0, /* (679) limit_clause_opt ::= */ - -2, /* (680) limit_clause_opt ::= LIMIT NK_INTEGER */ - -4, /* (681) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ - -4, /* (682) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - -3, /* (683) subquery ::= NK_LP query_expression NK_RP */ - -3, /* (684) subquery ::= NK_LP subquery NK_RP */ - -1, /* (685) search_condition ::= common_expression */ - -1, /* (686) sort_specification_list ::= sort_specification */ - -3, /* (687) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ - -3, /* (688) sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ - 0, /* (689) ordering_specification_opt ::= */ - -1, /* (690) ordering_specification_opt ::= ASC */ - -1, /* (691) ordering_specification_opt ::= DESC */ - 0, /* (692) null_ordering_opt ::= */ - -2, /* (693) null_ordering_opt ::= NULLS FIRST */ - -2, /* (694) null_ordering_opt ::= NULLS LAST */ - 0, /* (695) column_options ::= */ - -3, /* (696) column_options ::= column_options PRIMARY KEY */ - -3, /* (697) column_options ::= column_options ENCODE NK_STRING */ - -3, /* (698) column_options ::= column_options COMPRESS NK_STRING */ - -3, /* (699) column_options ::= column_options LEVEL NK_STRING */ + -1, /* (223) type_name_default_len ::= BINARY */ + -1, /* (224) type_name_default_len ::= NCHAR */ + -1, /* (225) type_name_default_len ::= VARCHAR */ + -1, /* (226) type_name_default_len ::= VARBINARY */ + 0, /* (227) tags_def_opt ::= */ + -1, /* (228) tags_def_opt ::= tags_def */ + -4, /* (229) tags_def ::= TAGS NK_LP tag_def_list NK_RP */ + 0, /* (230) table_options ::= */ + -3, /* (231) table_options ::= table_options COMMENT NK_STRING */ + -3, /* (232) table_options ::= table_options MAX_DELAY duration_list */ + -3, /* (233) table_options ::= table_options WATERMARK duration_list */ + -5, /* (234) table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ + -3, /* (235) table_options ::= table_options TTL NK_INTEGER */ + -5, /* (236) table_options ::= table_options SMA NK_LP col_name_list NK_RP */ + -3, /* (237) table_options ::= table_options DELETE_MARK duration_list */ + -1, /* (238) alter_table_options ::= alter_table_option */ + -2, /* (239) alter_table_options ::= alter_table_options alter_table_option */ + -2, /* (240) alter_table_option ::= COMMENT NK_STRING */ + -2, /* (241) alter_table_option ::= TTL NK_INTEGER */ + -1, /* (242) duration_list ::= duration_literal */ + -3, /* (243) duration_list ::= duration_list NK_COMMA duration_literal */ + -1, /* (244) rollup_func_list ::= rollup_func_name */ + -3, /* (245) rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ + -1, /* (246) rollup_func_name ::= function_name */ + -1, /* (247) rollup_func_name ::= FIRST */ + -1, /* (248) rollup_func_name ::= LAST */ + -1, /* (249) col_name_list ::= col_name */ + -3, /* (250) col_name_list ::= col_name_list NK_COMMA col_name */ + -1, /* (251) col_name ::= column_name */ + -2, /* (252) cmd ::= SHOW DNODES */ + -2, /* (253) cmd ::= SHOW USERS */ + -3, /* (254) cmd ::= SHOW USER PRIVILEGES */ + -3, /* (255) cmd ::= SHOW db_kind_opt DATABASES */ + -4, /* (256) cmd ::= SHOW table_kind_db_name_cond_opt TABLES like_pattern_opt */ + -4, /* (257) cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ + -3, /* (258) cmd ::= SHOW db_name_cond_opt VGROUPS */ + -2, /* (259) cmd ::= SHOW MNODES */ + -2, /* (260) cmd ::= SHOW QNODES */ + -2, /* (261) cmd ::= SHOW ARBGROUPS */ + -2, /* (262) cmd ::= SHOW FUNCTIONS */ + -5, /* (263) cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ + -6, /* (264) cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */ + -2, /* (265) cmd ::= SHOW STREAMS */ + -2, /* (266) cmd ::= SHOW ACCOUNTS */ + -2, /* (267) cmd ::= SHOW APPS */ + -2, /* (268) cmd ::= SHOW CONNECTIONS */ + -2, /* (269) cmd ::= SHOW LICENCES */ + -2, /* (270) cmd ::= SHOW GRANTS */ + -3, /* (271) cmd ::= SHOW GRANTS FULL */ + -3, /* (272) cmd ::= SHOW GRANTS LOGS */ + -3, /* (273) cmd ::= SHOW CLUSTER MACHINES */ + -4, /* (274) cmd ::= SHOW CREATE DATABASE db_name */ + -4, /* (275) cmd ::= SHOW CREATE TABLE full_table_name */ + -4, /* (276) cmd ::= SHOW CREATE STABLE full_table_name */ + -2, /* (277) cmd ::= SHOW QUERIES */ + -2, /* (278) cmd ::= SHOW SCORES */ + -2, /* (279) cmd ::= SHOW TOPICS */ + -2, /* (280) cmd ::= SHOW VARIABLES */ + -3, /* (281) cmd ::= SHOW CLUSTER VARIABLES */ + -3, /* (282) cmd ::= SHOW LOCAL VARIABLES */ + -5, /* (283) cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */ + -2, /* (284) cmd ::= SHOW BNODES */ + -2, /* (285) cmd ::= SHOW SNODES */ + -2, /* (286) cmd ::= SHOW CLUSTER */ + -2, /* (287) cmd ::= SHOW TRANSACTIONS */ + -4, /* (288) cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ + -2, /* (289) cmd ::= SHOW CONSUMERS */ + -2, /* (290) cmd ::= SHOW SUBSCRIPTIONS */ + -5, /* (291) cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ + -6, /* (292) cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */ + -7, /* (293) cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */ + -8, /* (294) cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */ + -5, /* (295) cmd ::= SHOW VNODES ON DNODE NK_INTEGER */ + -2, /* (296) cmd ::= SHOW VNODES */ + -3, /* (297) cmd ::= SHOW db_name_cond_opt ALIVE */ + -3, /* (298) cmd ::= SHOW CLUSTER ALIVE */ + -4, /* (299) cmd ::= SHOW db_name_cond_opt VIEWS like_pattern_opt */ + -4, /* (300) cmd ::= SHOW CREATE VIEW full_table_name */ + -2, /* (301) cmd ::= SHOW COMPACTS */ + -3, /* (302) cmd ::= SHOW COMPACT NK_INTEGER */ + 0, /* (303) table_kind_db_name_cond_opt ::= */ + -1, /* (304) table_kind_db_name_cond_opt ::= table_kind */ + -2, /* (305) table_kind_db_name_cond_opt ::= db_name NK_DOT */ + -3, /* (306) table_kind_db_name_cond_opt ::= table_kind db_name NK_DOT */ + -1, /* (307) table_kind ::= NORMAL */ + -1, /* (308) table_kind ::= CHILD */ + 0, /* (309) db_name_cond_opt ::= */ + -2, /* (310) db_name_cond_opt ::= db_name NK_DOT */ + 0, /* (311) like_pattern_opt ::= */ + -2, /* (312) like_pattern_opt ::= LIKE NK_STRING */ + -1, /* (313) table_name_cond ::= table_name */ + 0, /* (314) from_db_opt ::= */ + -2, /* (315) from_db_opt ::= FROM db_name */ + 0, /* (316) tag_list_opt ::= */ + -1, /* (317) tag_list_opt ::= tag_item */ + -3, /* (318) tag_list_opt ::= tag_list_opt NK_COMMA tag_item */ + -1, /* (319) tag_item ::= TBNAME */ + -1, /* (320) tag_item ::= QTAGS */ + -1, /* (321) tag_item ::= column_name */ + -2, /* (322) tag_item ::= column_name column_alias */ + -3, /* (323) tag_item ::= column_name AS column_alias */ + 0, /* (324) db_kind_opt ::= */ + -1, /* (325) db_kind_opt ::= USER */ + -1, /* (326) db_kind_opt ::= SYSTEM */ + -8, /* (327) cmd ::= CREATE SMA INDEX not_exists_opt col_name ON full_table_name index_options */ + -9, /* (328) cmd ::= CREATE INDEX not_exists_opt col_name ON full_table_name NK_LP col_name_list NK_RP */ + -4, /* (329) cmd ::= DROP INDEX exists_opt full_index_name */ + -1, /* (330) full_index_name ::= index_name */ + -3, /* (331) full_index_name ::= db_name NK_DOT index_name */ + -10, /* (332) index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ + -12, /* (333) 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 */ + -1, /* (334) func_list ::= func */ + -3, /* (335) func_list ::= func_list NK_COMMA func */ + -4, /* (336) func ::= sma_func_name NK_LP expression_list NK_RP */ + -1, /* (337) sma_func_name ::= function_name */ + -1, /* (338) sma_func_name ::= COUNT */ + -1, /* (339) sma_func_name ::= FIRST */ + -1, /* (340) sma_func_name ::= LAST */ + -1, /* (341) sma_func_name ::= LAST_ROW */ + 0, /* (342) sma_stream_opt ::= */ + -3, /* (343) sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */ + -3, /* (344) sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */ + -3, /* (345) sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */ + -1, /* (346) with_meta ::= AS */ + -3, /* (347) with_meta ::= WITH META AS */ + -3, /* (348) with_meta ::= ONLY META AS */ + -6, /* (349) cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */ + -7, /* (350) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */ + -8, /* (351) cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */ + -4, /* (352) cmd ::= DROP TOPIC exists_opt topic_name */ + -7, /* (353) cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ + -2, /* (354) cmd ::= DESC full_table_name */ + -2, /* (355) cmd ::= DESCRIBE full_table_name */ + -3, /* (356) cmd ::= RESET QUERY CACHE */ + -4, /* (357) cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */ + -4, /* (358) cmd ::= EXPLAIN analyze_opt explain_options insert_query */ + 0, /* (359) analyze_opt ::= */ + -1, /* (360) analyze_opt ::= ANALYZE */ + 0, /* (361) explain_options ::= */ + -3, /* (362) explain_options ::= explain_options VERBOSE NK_BOOL */ + -3, /* (363) explain_options ::= explain_options RATIO NK_FLOAT */ + -12, /* (364) cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */ + -4, /* (365) cmd ::= DROP FUNCTION exists_opt function_name */ + 0, /* (366) agg_func_opt ::= */ + -1, /* (367) agg_func_opt ::= AGGREGATE */ + 0, /* (368) bufsize_opt ::= */ + -2, /* (369) bufsize_opt ::= BUFSIZE NK_INTEGER */ + 0, /* (370) language_opt ::= */ + -2, /* (371) language_opt ::= LANGUAGE NK_STRING */ + 0, /* (372) or_replace_opt ::= */ + -2, /* (373) or_replace_opt ::= OR REPLACE */ + -6, /* (374) cmd ::= CREATE or_replace_opt VIEW full_view_name AS query_or_subquery */ + -4, /* (375) cmd ::= DROP VIEW exists_opt full_view_name */ + -1, /* (376) full_view_name ::= view_name */ + -3, /* (377) full_view_name ::= db_name NK_DOT view_name */ + -12, /* (378) 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 */ + -4, /* (379) cmd ::= DROP STREAM exists_opt stream_name */ + -4, /* (380) cmd ::= PAUSE STREAM exists_opt stream_name */ + -5, /* (381) cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */ + 0, /* (382) col_list_opt ::= */ + -3, /* (383) col_list_opt ::= NK_LP col_name_list NK_RP */ + 0, /* (384) tag_def_or_ref_opt ::= */ + -1, /* (385) tag_def_or_ref_opt ::= tags_def */ + -4, /* (386) tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP */ + 0, /* (387) stream_options ::= */ + -3, /* (388) stream_options ::= stream_options TRIGGER AT_ONCE */ + -3, /* (389) stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ + -4, /* (390) stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ + -3, /* (391) stream_options ::= stream_options WATERMARK duration_literal */ + -4, /* (392) stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ + -3, /* (393) stream_options ::= stream_options FILL_HISTORY NK_INTEGER */ + -3, /* (394) stream_options ::= stream_options DELETE_MARK duration_literal */ + -4, /* (395) stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */ + 0, /* (396) subtable_opt ::= */ + -4, /* (397) subtable_opt ::= SUBTABLE NK_LP expression NK_RP */ + 0, /* (398) ignore_opt ::= */ + -2, /* (399) ignore_opt ::= IGNORE UNTREATED */ + -3, /* (400) cmd ::= KILL CONNECTION NK_INTEGER */ + -3, /* (401) cmd ::= KILL QUERY NK_STRING */ + -3, /* (402) cmd ::= KILL TRANSACTION NK_INTEGER */ + -3, /* (403) cmd ::= KILL COMPACT NK_INTEGER */ + -2, /* (404) cmd ::= BALANCE VGROUP */ + -4, /* (405) cmd ::= BALANCE VGROUP LEADER on_vgroup_id */ + -4, /* (406) cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ + -4, /* (407) cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ + -3, /* (408) cmd ::= SPLIT VGROUP NK_INTEGER */ + 0, /* (409) on_vgroup_id ::= */ + -2, /* (410) on_vgroup_id ::= ON NK_INTEGER */ + -2, /* (411) dnode_list ::= DNODE NK_INTEGER */ + -3, /* (412) dnode_list ::= dnode_list DNODE NK_INTEGER */ + -4, /* (413) cmd ::= DELETE FROM full_table_name where_clause_opt */ + -1, /* (414) cmd ::= query_or_subquery */ + -1, /* (415) cmd ::= insert_query */ + -7, /* (416) insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */ + -4, /* (417) insert_query ::= INSERT INTO full_table_name query_or_subquery */ + -1, /* (418) tags_literal ::= NK_INTEGER */ + -3, /* (419) tags_literal ::= NK_INTEGER NK_PLUS duration_literal */ + -3, /* (420) tags_literal ::= NK_INTEGER NK_MINUS duration_literal */ + -2, /* (421) tags_literal ::= NK_PLUS NK_INTEGER */ + -4, /* (422) tags_literal ::= NK_PLUS NK_INTEGER NK_PLUS duration_literal */ + -4, /* (423) tags_literal ::= NK_PLUS NK_INTEGER NK_MINUS duration_literal */ + -2, /* (424) tags_literal ::= NK_MINUS NK_INTEGER */ + -4, /* (425) tags_literal ::= NK_MINUS NK_INTEGER NK_PLUS duration_literal */ + -4, /* (426) tags_literal ::= NK_MINUS NK_INTEGER NK_MINUS duration_literal */ + -1, /* (427) tags_literal ::= NK_FLOAT */ + -2, /* (428) tags_literal ::= NK_PLUS NK_FLOAT */ + -2, /* (429) tags_literal ::= NK_MINUS NK_FLOAT */ + -1, /* (430) tags_literal ::= NK_BIN */ + -3, /* (431) tags_literal ::= NK_BIN NK_PLUS duration_literal */ + -3, /* (432) tags_literal ::= NK_BIN NK_MINUS duration_literal */ + -2, /* (433) tags_literal ::= NK_PLUS NK_BIN */ + -4, /* (434) tags_literal ::= NK_PLUS NK_BIN NK_PLUS duration_literal */ + -4, /* (435) tags_literal ::= NK_PLUS NK_BIN NK_MINUS duration_literal */ + -2, /* (436) tags_literal ::= NK_MINUS NK_BIN */ + -4, /* (437) tags_literal ::= NK_MINUS NK_BIN NK_PLUS duration_literal */ + -4, /* (438) tags_literal ::= NK_MINUS NK_BIN NK_MINUS duration_literal */ + -1, /* (439) tags_literal ::= NK_HEX */ + -3, /* (440) tags_literal ::= NK_HEX NK_PLUS duration_literal */ + -3, /* (441) tags_literal ::= NK_HEX NK_MINUS duration_literal */ + -2, /* (442) tags_literal ::= NK_PLUS NK_HEX */ + -4, /* (443) tags_literal ::= NK_PLUS NK_HEX NK_PLUS duration_literal */ + -4, /* (444) tags_literal ::= NK_PLUS NK_HEX NK_MINUS duration_literal */ + -2, /* (445) tags_literal ::= NK_MINUS NK_HEX */ + -4, /* (446) tags_literal ::= NK_MINUS NK_HEX NK_PLUS duration_literal */ + -4, /* (447) tags_literal ::= NK_MINUS NK_HEX NK_MINUS duration_literal */ + -1, /* (448) tags_literal ::= NK_STRING */ + -3, /* (449) tags_literal ::= NK_STRING NK_PLUS duration_literal */ + -3, /* (450) tags_literal ::= NK_STRING NK_MINUS duration_literal */ + -1, /* (451) tags_literal ::= NK_BOOL */ + -1, /* (452) tags_literal ::= NULL */ + -1, /* (453) tags_literal ::= literal_func */ + -3, /* (454) tags_literal ::= literal_func NK_PLUS duration_literal */ + -3, /* (455) tags_literal ::= literal_func NK_MINUS duration_literal */ + -1, /* (456) tags_literal_list ::= tags_literal */ + -3, /* (457) tags_literal_list ::= tags_literal_list NK_COMMA tags_literal */ + -1, /* (458) literal ::= NK_INTEGER */ + -1, /* (459) literal ::= NK_FLOAT */ + -1, /* (460) literal ::= NK_STRING */ + -1, /* (461) literal ::= NK_BOOL */ + -2, /* (462) literal ::= TIMESTAMP NK_STRING */ + -1, /* (463) literal ::= duration_literal */ + -1, /* (464) literal ::= NULL */ + -1, /* (465) literal ::= NK_QUESTION */ + -1, /* (466) duration_literal ::= NK_VARIABLE */ + -1, /* (467) signed ::= NK_INTEGER */ + -2, /* (468) signed ::= NK_PLUS NK_INTEGER */ + -2, /* (469) signed ::= NK_MINUS NK_INTEGER */ + -1, /* (470) signed ::= NK_FLOAT */ + -2, /* (471) signed ::= NK_PLUS NK_FLOAT */ + -2, /* (472) signed ::= NK_MINUS NK_FLOAT */ + -1, /* (473) signed_literal ::= signed */ + -1, /* (474) signed_literal ::= NK_STRING */ + -1, /* (475) signed_literal ::= NK_BOOL */ + -2, /* (476) signed_literal ::= TIMESTAMP NK_STRING */ + -1, /* (477) signed_literal ::= duration_literal */ + -1, /* (478) signed_literal ::= NULL */ + -1, /* (479) signed_literal ::= literal_func */ + -1, /* (480) signed_literal ::= NK_QUESTION */ + -1, /* (481) literal_list ::= signed_literal */ + -3, /* (482) literal_list ::= literal_list NK_COMMA signed_literal */ + -1, /* (483) db_name ::= NK_ID */ + -1, /* (484) table_name ::= NK_ID */ + -1, /* (485) column_name ::= NK_ID */ + -1, /* (486) function_name ::= NK_ID */ + -1, /* (487) view_name ::= NK_ID */ + -1, /* (488) table_alias ::= NK_ID */ + -1, /* (489) column_alias ::= NK_ID */ + -1, /* (490) column_alias ::= NK_ALIAS */ + -1, /* (491) user_name ::= NK_ID */ + -1, /* (492) topic_name ::= NK_ID */ + -1, /* (493) stream_name ::= NK_ID */ + -1, /* (494) cgroup_name ::= NK_ID */ + -1, /* (495) index_name ::= NK_ID */ + -1, /* (496) expr_or_subquery ::= expression */ + -1, /* (497) expression ::= literal */ + -1, /* (498) expression ::= pseudo_column */ + -1, /* (499) expression ::= column_reference */ + -1, /* (500) expression ::= function_expression */ + -1, /* (501) expression ::= case_when_expression */ + -3, /* (502) expression ::= NK_LP expression NK_RP */ + -2, /* (503) expression ::= NK_PLUS expr_or_subquery */ + -2, /* (504) expression ::= NK_MINUS expr_or_subquery */ + -3, /* (505) expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ + -3, /* (506) expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ + -3, /* (507) expression ::= expr_or_subquery NK_STAR expr_or_subquery */ + -3, /* (508) expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ + -3, /* (509) expression ::= expr_or_subquery NK_REM expr_or_subquery */ + -3, /* (510) expression ::= column_reference NK_ARROW NK_STRING */ + -3, /* (511) expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ + -3, /* (512) expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ + -1, /* (513) expression_list ::= expr_or_subquery */ + -3, /* (514) expression_list ::= expression_list NK_COMMA expr_or_subquery */ + -1, /* (515) column_reference ::= column_name */ + -3, /* (516) column_reference ::= table_name NK_DOT column_name */ + -1, /* (517) column_reference ::= NK_ALIAS */ + -3, /* (518) column_reference ::= table_name NK_DOT NK_ALIAS */ + -1, /* (519) pseudo_column ::= ROWTS */ + -1, /* (520) pseudo_column ::= TBNAME */ + -3, /* (521) pseudo_column ::= table_name NK_DOT TBNAME */ + -1, /* (522) pseudo_column ::= QSTART */ + -1, /* (523) pseudo_column ::= QEND */ + -1, /* (524) pseudo_column ::= QDURATION */ + -1, /* (525) pseudo_column ::= WSTART */ + -1, /* (526) pseudo_column ::= WEND */ + -1, /* (527) pseudo_column ::= WDURATION */ + -1, /* (528) pseudo_column ::= IROWTS */ + -1, /* (529) pseudo_column ::= ISFILLED */ + -1, /* (530) pseudo_column ::= QTAGS */ + -4, /* (531) function_expression ::= function_name NK_LP expression_list NK_RP */ + -4, /* (532) function_expression ::= star_func NK_LP star_func_para_list NK_RP */ + -6, /* (533) function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ + -6, /* (534) function_expression ::= CAST NK_LP expr_or_subquery AS type_name_default_len NK_RP */ + -1, /* (535) function_expression ::= literal_func */ + -3, /* (536) literal_func ::= noarg_func NK_LP NK_RP */ + -1, /* (537) literal_func ::= NOW */ + -1, /* (538) literal_func ::= TODAY */ + -1, /* (539) noarg_func ::= NOW */ + -1, /* (540) noarg_func ::= TODAY */ + -1, /* (541) noarg_func ::= TIMEZONE */ + -1, /* (542) noarg_func ::= DATABASE */ + -1, /* (543) noarg_func ::= CLIENT_VERSION */ + -1, /* (544) noarg_func ::= SERVER_VERSION */ + -1, /* (545) noarg_func ::= SERVER_STATUS */ + -1, /* (546) noarg_func ::= CURRENT_USER */ + -1, /* (547) noarg_func ::= USER */ + -1, /* (548) star_func ::= COUNT */ + -1, /* (549) star_func ::= FIRST */ + -1, /* (550) star_func ::= LAST */ + -1, /* (551) star_func ::= LAST_ROW */ + -1, /* (552) star_func_para_list ::= NK_STAR */ + -1, /* (553) star_func_para_list ::= other_para_list */ + -1, /* (554) other_para_list ::= star_func_para */ + -3, /* (555) other_para_list ::= other_para_list NK_COMMA star_func_para */ + -1, /* (556) star_func_para ::= expr_or_subquery */ + -3, /* (557) star_func_para ::= table_name NK_DOT NK_STAR */ + -4, /* (558) case_when_expression ::= CASE when_then_list case_when_else_opt END */ + -5, /* (559) case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ + -1, /* (560) when_then_list ::= when_then_expr */ + -2, /* (561) when_then_list ::= when_then_list when_then_expr */ + -4, /* (562) when_then_expr ::= WHEN common_expression THEN common_expression */ + 0, /* (563) case_when_else_opt ::= */ + -2, /* (564) case_when_else_opt ::= ELSE common_expression */ + -3, /* (565) predicate ::= expr_or_subquery compare_op expr_or_subquery */ + -5, /* (566) predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ + -6, /* (567) predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ + -3, /* (568) predicate ::= expr_or_subquery IS NULL */ + -4, /* (569) predicate ::= expr_or_subquery IS NOT NULL */ + -3, /* (570) predicate ::= expr_or_subquery in_op in_predicate_value */ + -1, /* (571) compare_op ::= NK_LT */ + -1, /* (572) compare_op ::= NK_GT */ + -1, /* (573) compare_op ::= NK_LE */ + -1, /* (574) compare_op ::= NK_GE */ + -1, /* (575) compare_op ::= NK_NE */ + -1, /* (576) compare_op ::= NK_EQ */ + -1, /* (577) compare_op ::= LIKE */ + -2, /* (578) compare_op ::= NOT LIKE */ + -1, /* (579) compare_op ::= MATCH */ + -1, /* (580) compare_op ::= NMATCH */ + -1, /* (581) compare_op ::= CONTAINS */ + -1, /* (582) in_op ::= IN */ + -2, /* (583) in_op ::= NOT IN */ + -3, /* (584) in_predicate_value ::= NK_LP literal_list NK_RP */ + -1, /* (585) boolean_value_expression ::= boolean_primary */ + -2, /* (586) boolean_value_expression ::= NOT boolean_primary */ + -3, /* (587) boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ + -3, /* (588) boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ + -1, /* (589) boolean_primary ::= predicate */ + -3, /* (590) boolean_primary ::= NK_LP boolean_value_expression NK_RP */ + -1, /* (591) common_expression ::= expr_or_subquery */ + -1, /* (592) common_expression ::= boolean_value_expression */ + 0, /* (593) from_clause_opt ::= */ + -2, /* (594) from_clause_opt ::= FROM table_reference_list */ + -1, /* (595) table_reference_list ::= table_reference */ + -3, /* (596) table_reference_list ::= table_reference_list NK_COMMA table_reference */ + -1, /* (597) table_reference ::= table_primary */ + -1, /* (598) table_reference ::= joined_table */ + -2, /* (599) table_primary ::= table_name alias_opt */ + -4, /* (600) table_primary ::= db_name NK_DOT table_name alias_opt */ + -2, /* (601) table_primary ::= subquery alias_opt */ + -1, /* (602) table_primary ::= parenthesized_joined_table */ + 0, /* (603) alias_opt ::= */ + -1, /* (604) alias_opt ::= table_alias */ + -2, /* (605) alias_opt ::= AS table_alias */ + -3, /* (606) parenthesized_joined_table ::= NK_LP joined_table NK_RP */ + -3, /* (607) parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ + -6, /* (608) joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ + 0, /* (609) join_type ::= */ + -1, /* (610) join_type ::= INNER */ + -14, /* (611) query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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 */ + 0, /* (612) hint_list ::= */ + -1, /* (613) hint_list ::= NK_HINT */ + 0, /* (614) tag_mode_opt ::= */ + -1, /* (615) tag_mode_opt ::= TAGS */ + 0, /* (616) set_quantifier_opt ::= */ + -1, /* (617) set_quantifier_opt ::= DISTINCT */ + -1, /* (618) set_quantifier_opt ::= ALL */ + -1, /* (619) select_list ::= select_item */ + -3, /* (620) select_list ::= select_list NK_COMMA select_item */ + -1, /* (621) select_item ::= NK_STAR */ + -1, /* (622) select_item ::= common_expression */ + -2, /* (623) select_item ::= common_expression column_alias */ + -3, /* (624) select_item ::= common_expression AS column_alias */ + -3, /* (625) select_item ::= table_name NK_DOT NK_STAR */ + 0, /* (626) where_clause_opt ::= */ + -2, /* (627) where_clause_opt ::= WHERE search_condition */ + 0, /* (628) partition_by_clause_opt ::= */ + -3, /* (629) partition_by_clause_opt ::= PARTITION BY partition_list */ + -1, /* (630) partition_list ::= partition_item */ + -3, /* (631) partition_list ::= partition_list NK_COMMA partition_item */ + -1, /* (632) partition_item ::= expr_or_subquery */ + -2, /* (633) partition_item ::= expr_or_subquery column_alias */ + -3, /* (634) partition_item ::= expr_or_subquery AS column_alias */ + 0, /* (635) twindow_clause_opt ::= */ + -6, /* (636) twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP */ + -4, /* (637) twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ + -6, /* (638) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ + -8, /* (639) twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ + -7, /* (640) twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ + -4, /* (641) twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_RP */ + -6, /* (642) twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ + 0, /* (643) sliding_opt ::= */ + -4, /* (644) sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP */ + -1, /* (645) interval_sliding_duration_literal ::= NK_VARIABLE */ + -1, /* (646) interval_sliding_duration_literal ::= NK_STRING */ + -1, /* (647) interval_sliding_duration_literal ::= NK_INTEGER */ + 0, /* (648) fill_opt ::= */ + -4, /* (649) fill_opt ::= FILL NK_LP fill_mode NK_RP */ + -6, /* (650) fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ + -6, /* (651) fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ + -1, /* (652) fill_mode ::= NONE */ + -1, /* (653) fill_mode ::= PREV */ + -1, /* (654) fill_mode ::= NULL */ + -1, /* (655) fill_mode ::= NULL_F */ + -1, /* (656) fill_mode ::= LINEAR */ + -1, /* (657) fill_mode ::= NEXT */ + 0, /* (658) group_by_clause_opt ::= */ + -3, /* (659) group_by_clause_opt ::= GROUP BY group_by_list */ + -1, /* (660) group_by_list ::= expr_or_subquery */ + -3, /* (661) group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ + 0, /* (662) having_clause_opt ::= */ + -2, /* (663) having_clause_opt ::= HAVING search_condition */ + 0, /* (664) range_opt ::= */ + -6, /* (665) range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ + -4, /* (666) range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ + 0, /* (667) every_opt ::= */ + -4, /* (668) every_opt ::= EVERY NK_LP duration_literal NK_RP */ + -4, /* (669) query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ + -1, /* (670) query_simple ::= query_specification */ + -1, /* (671) query_simple ::= union_query_expression */ + -4, /* (672) union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ + -3, /* (673) union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ + -1, /* (674) query_simple_or_subquery ::= query_simple */ + -1, /* (675) query_simple_or_subquery ::= subquery */ + -1, /* (676) query_or_subquery ::= query_expression */ + -1, /* (677) query_or_subquery ::= subquery */ + 0, /* (678) order_by_clause_opt ::= */ + -3, /* (679) order_by_clause_opt ::= ORDER BY sort_specification_list */ + 0, /* (680) slimit_clause_opt ::= */ + -2, /* (681) slimit_clause_opt ::= SLIMIT NK_INTEGER */ + -4, /* (682) slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + -4, /* (683) slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + 0, /* (684) limit_clause_opt ::= */ + -2, /* (685) limit_clause_opt ::= LIMIT NK_INTEGER */ + -4, /* (686) limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ + -4, /* (687) limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + -3, /* (688) subquery ::= NK_LP query_expression NK_RP */ + -3, /* (689) subquery ::= NK_LP subquery NK_RP */ + -1, /* (690) search_condition ::= common_expression */ + -1, /* (691) sort_specification_list ::= sort_specification */ + -3, /* (692) sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ + -3, /* (693) sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ + 0, /* (694) ordering_specification_opt ::= */ + -1, /* (695) ordering_specification_opt ::= ASC */ + -1, /* (696) ordering_specification_opt ::= DESC */ + 0, /* (697) null_ordering_opt ::= */ + -2, /* (698) null_ordering_opt ::= NULLS FIRST */ + -2, /* (699) null_ordering_opt ::= NULLS LAST */ + 0, /* (700) column_options ::= */ + -3, /* (701) column_options ::= column_options PRIMARY KEY */ + -3, /* (702) column_options ::= column_options ENCODE NK_STRING */ + -3, /* (703) column_options ::= column_options COMPRESS NK_STRING */ + -3, /* (704) column_options ::= column_options LEVEL NK_STRING */ }; static void yy_accept(yyParser*); /* Forward Declaration */ @@ -5300,19 +5346,19 @@ static YYACTIONTYPE yy_reduce( case 0: /* cmd ::= CREATE ACCOUNT NK_ID PASS NK_STRING account_options */ #line 50 "sql.y" { pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); } -#line 5303 "sql.c" +#line 5349 "sql.c" yy_destructor(yypParser,359,&yymsp[0].minor); break; case 1: /* cmd ::= ALTER ACCOUNT NK_ID alter_account_options */ #line 51 "sql.y" { pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); } -#line 5309 "sql.c" +#line 5355 "sql.c" yy_destructor(yypParser,360,&yymsp[0].minor); break; case 2: /* account_options ::= */ #line 55 "sql.y" { } -#line 5315 "sql.c" +#line 5361 "sql.c" break; case 3: /* account_options ::= account_options PPS literal */ case 4: /* account_options ::= account_options TSERIES literal */ yytestcase(yyruleno==4); @@ -5326,7 +5372,7 @@ static YYACTIONTYPE yy_reduce( { yy_destructor(yypParser,359,&yymsp[-2].minor); #line 56 "sql.y" { } -#line 5329 "sql.c" +#line 5375 "sql.c" yy_destructor(yypParser,361,&yymsp[0].minor); } break; @@ -5334,14 +5380,14 @@ static YYACTIONTYPE yy_reduce( { yy_destructor(yypParser,362,&yymsp[0].minor); #line 68 "sql.y" { } -#line 5337 "sql.c" +#line 5383 "sql.c" } break; case 13: /* alter_account_options ::= alter_account_options alter_account_option */ { yy_destructor(yypParser,360,&yymsp[-1].minor); #line 69 "sql.y" { } -#line 5344 "sql.c" +#line 5390 "sql.c" yy_destructor(yypParser,362,&yymsp[0].minor); } break; @@ -5357,2833 +5403,2854 @@ static YYACTIONTYPE yy_reduce( case 23: /* alter_account_option ::= STATE literal */ yytestcase(yyruleno==23); #line 73 "sql.y" { } -#line 5360 "sql.c" +#line 5406 "sql.c" yy_destructor(yypParser,361,&yymsp[0].minor); break; case 24: /* ip_range_list ::= NK_STRING */ #line 86 "sql.y" -{ yylhsminor.yy72 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } -#line 5366 "sql.c" - yymsp[0].minor.yy72 = yylhsminor.yy72; +{ yylhsminor.yy124 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } +#line 5412 "sql.c" + yymsp[0].minor.yy124 = yylhsminor.yy124; break; case 25: /* ip_range_list ::= ip_range_list NK_COMMA NK_STRING */ #line 87 "sql.y" -{ yylhsminor.yy72 = addNodeToList(pCxt, yymsp[-2].minor.yy72, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } -#line 5372 "sql.c" - yymsp[-2].minor.yy72 = yylhsminor.yy72; +{ yylhsminor.yy124 = addNodeToList(pCxt, yymsp[-2].minor.yy124, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } +#line 5418 "sql.c" + yymsp[-2].minor.yy124 = yylhsminor.yy124; break; case 26: /* white_list ::= HOST ip_range_list */ #line 91 "sql.y" -{ yymsp[-1].minor.yy72 = yymsp[0].minor.yy72; } -#line 5378 "sql.c" +{ yymsp[-1].minor.yy124 = yymsp[0].minor.yy124; } +#line 5424 "sql.c" break; case 27: /* white_list_opt ::= */ case 189: /* specific_cols_opt ::= */ yytestcase(yyruleno==189); - case 223: /* tags_def_opt ::= */ yytestcase(yyruleno==223); - case 312: /* tag_list_opt ::= */ yytestcase(yyruleno==312); - case 378: /* col_list_opt ::= */ yytestcase(yyruleno==378); - case 380: /* tag_def_or_ref_opt ::= */ yytestcase(yyruleno==380); - case 623: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==623); - case 653: /* group_by_clause_opt ::= */ yytestcase(yyruleno==653); - case 673: /* order_by_clause_opt ::= */ yytestcase(yyruleno==673); + case 227: /* tags_def_opt ::= */ yytestcase(yyruleno==227); + case 316: /* tag_list_opt ::= */ yytestcase(yyruleno==316); + case 382: /* col_list_opt ::= */ yytestcase(yyruleno==382); + case 384: /* tag_def_or_ref_opt ::= */ yytestcase(yyruleno==384); + case 628: /* partition_by_clause_opt ::= */ yytestcase(yyruleno==628); + case 658: /* group_by_clause_opt ::= */ yytestcase(yyruleno==658); + case 678: /* order_by_clause_opt ::= */ yytestcase(yyruleno==678); #line 95 "sql.y" -{ yymsp[1].minor.yy72 = NULL; } -#line 5391 "sql.c" +{ yymsp[1].minor.yy124 = NULL; } +#line 5437 "sql.c" break; case 28: /* white_list_opt ::= white_list */ - case 224: /* tags_def_opt ::= tags_def */ yytestcase(yyruleno==224); - case 381: /* tag_def_or_ref_opt ::= tags_def */ yytestcase(yyruleno==381); - case 548: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==548); + case 228: /* tags_def_opt ::= tags_def */ yytestcase(yyruleno==228); + case 385: /* tag_def_or_ref_opt ::= tags_def */ yytestcase(yyruleno==385); + case 553: /* star_func_para_list ::= other_para_list */ yytestcase(yyruleno==553); #line 96 "sql.y" -{ yylhsminor.yy72 = yymsp[0].minor.yy72; } -#line 5399 "sql.c" - yymsp[0].minor.yy72 = yylhsminor.yy72; +{ yylhsminor.yy124 = yymsp[0].minor.yy124; } +#line 5445 "sql.c" + yymsp[0].minor.yy124 = yylhsminor.yy124; break; case 29: /* cmd ::= CREATE USER user_name PASS NK_STRING sysinfo_opt white_list_opt */ #line 100 "sql.y" { - pCxt->pRootNode = createCreateUserStmt(pCxt, &yymsp[-4].minor.yy305, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy359); - pCxt->pRootNode = addCreateUserStmtWhiteList(pCxt, pCxt->pRootNode, yymsp[0].minor.yy72); + pCxt->pRootNode = createCreateUserStmt(pCxt, &yymsp[-4].minor.yy29, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy803); + pCxt->pRootNode = addCreateUserStmtWhiteList(pCxt, pCxt->pRootNode, yymsp[0].minor.yy124); } -#line 5408 "sql.c" +#line 5454 "sql.c" break; case 30: /* cmd ::= ALTER USER user_name PASS NK_STRING */ #line 104 "sql.y" -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy305, TSDB_ALTER_USER_PASSWD, &yymsp[0].minor.yy0); } -#line 5413 "sql.c" +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy29, TSDB_ALTER_USER_PASSWD, &yymsp[0].minor.yy0); } +#line 5459 "sql.c" break; case 31: /* cmd ::= ALTER USER user_name ENABLE NK_INTEGER */ #line 105 "sql.y" -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy305, TSDB_ALTER_USER_ENABLE, &yymsp[0].minor.yy0); } -#line 5418 "sql.c" +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy29, TSDB_ALTER_USER_ENABLE, &yymsp[0].minor.yy0); } +#line 5464 "sql.c" break; case 32: /* cmd ::= ALTER USER user_name SYSINFO NK_INTEGER */ #line 106 "sql.y" -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy305, TSDB_ALTER_USER_SYSINFO, &yymsp[0].minor.yy0); } -#line 5423 "sql.c" +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy29, TSDB_ALTER_USER_SYSINFO, &yymsp[0].minor.yy0); } +#line 5469 "sql.c" break; case 33: /* cmd ::= ALTER USER user_name ADD white_list */ #line 107 "sql.y" -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy305, TSDB_ALTER_USER_ADD_WHITE_LIST, yymsp[0].minor.yy72); } -#line 5428 "sql.c" +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy29, TSDB_ALTER_USER_ADD_WHITE_LIST, yymsp[0].minor.yy124); } +#line 5474 "sql.c" break; case 34: /* cmd ::= ALTER USER user_name DROP white_list */ #line 108 "sql.y" -{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy305, TSDB_ALTER_USER_DROP_WHITE_LIST, yymsp[0].minor.yy72); } -#line 5433 "sql.c" +{ pCxt->pRootNode = createAlterUserStmt(pCxt, &yymsp[-2].minor.yy29, TSDB_ALTER_USER_DROP_WHITE_LIST, yymsp[0].minor.yy124); } +#line 5479 "sql.c" break; case 35: /* cmd ::= DROP USER user_name */ #line 109 "sql.y" -{ pCxt->pRootNode = createDropUserStmt(pCxt, &yymsp[0].minor.yy305); } -#line 5438 "sql.c" +{ pCxt->pRootNode = createDropUserStmt(pCxt, &yymsp[0].minor.yy29); } +#line 5484 "sql.c" break; case 36: /* sysinfo_opt ::= */ #line 113 "sql.y" -{ yymsp[1].minor.yy359 = 1; } -#line 5443 "sql.c" +{ yymsp[1].minor.yy803 = 1; } +#line 5489 "sql.c" break; case 37: /* sysinfo_opt ::= SYSINFO NK_INTEGER */ #line 114 "sql.y" -{ yymsp[-1].minor.yy359 = taosStr2Int8(yymsp[0].minor.yy0.z, NULL, 10); } -#line 5448 "sql.c" +{ yymsp[-1].minor.yy803 = taosStr2Int8(yymsp[0].minor.yy0.z, NULL, 10); } +#line 5494 "sql.c" break; case 38: /* cmd ::= GRANT privileges ON priv_level with_opt TO user_name */ #line 117 "sql.y" -{ pCxt->pRootNode = createGrantStmt(pCxt, yymsp[-5].minor.yy1005, &yymsp[-3].minor.yy361, &yymsp[0].minor.yy305, yymsp[-2].minor.yy1000); } -#line 5453 "sql.c" +{ pCxt->pRootNode = createGrantStmt(pCxt, yymsp[-5].minor.yy459, &yymsp[-3].minor.yy147, &yymsp[0].minor.yy29, yymsp[-2].minor.yy812); } +#line 5499 "sql.c" break; case 39: /* cmd ::= REVOKE privileges ON priv_level with_opt FROM user_name */ #line 118 "sql.y" -{ pCxt->pRootNode = createRevokeStmt(pCxt, yymsp[-5].minor.yy1005, &yymsp[-3].minor.yy361, &yymsp[0].minor.yy305, yymsp[-2].minor.yy1000); } -#line 5458 "sql.c" +{ pCxt->pRootNode = createRevokeStmt(pCxt, yymsp[-5].minor.yy459, &yymsp[-3].minor.yy147, &yymsp[0].minor.yy29, yymsp[-2].minor.yy812); } +#line 5504 "sql.c" break; case 40: /* privileges ::= ALL */ #line 122 "sql.y" -{ yymsp[0].minor.yy1005 = PRIVILEGE_TYPE_ALL; } -#line 5463 "sql.c" +{ yymsp[0].minor.yy459 = PRIVILEGE_TYPE_ALL; } +#line 5509 "sql.c" break; case 41: /* privileges ::= priv_type_list */ case 43: /* priv_type_list ::= priv_type */ yytestcase(yyruleno==43); #line 123 "sql.y" -{ yylhsminor.yy1005 = yymsp[0].minor.yy1005; } -#line 5469 "sql.c" - yymsp[0].minor.yy1005 = yylhsminor.yy1005; +{ yylhsminor.yy459 = yymsp[0].minor.yy459; } +#line 5515 "sql.c" + yymsp[0].minor.yy459 = yylhsminor.yy459; break; case 42: /* privileges ::= SUBSCRIBE */ #line 124 "sql.y" -{ yymsp[0].minor.yy1005 = PRIVILEGE_TYPE_SUBSCRIBE; } -#line 5475 "sql.c" +{ yymsp[0].minor.yy459 = PRIVILEGE_TYPE_SUBSCRIBE; } +#line 5521 "sql.c" break; case 44: /* priv_type_list ::= priv_type_list NK_COMMA priv_type */ #line 129 "sql.y" -{ yylhsminor.yy1005 = yymsp[-2].minor.yy1005 | yymsp[0].minor.yy1005; } -#line 5480 "sql.c" - yymsp[-2].minor.yy1005 = yylhsminor.yy1005; +{ yylhsminor.yy459 = yymsp[-2].minor.yy459 | yymsp[0].minor.yy459; } +#line 5526 "sql.c" + yymsp[-2].minor.yy459 = yylhsminor.yy459; break; case 45: /* priv_type ::= READ */ #line 133 "sql.y" -{ yymsp[0].minor.yy1005 = PRIVILEGE_TYPE_READ; } -#line 5486 "sql.c" +{ yymsp[0].minor.yy459 = PRIVILEGE_TYPE_READ; } +#line 5532 "sql.c" break; case 46: /* priv_type ::= WRITE */ #line 134 "sql.y" -{ yymsp[0].minor.yy1005 = PRIVILEGE_TYPE_WRITE; } -#line 5491 "sql.c" +{ yymsp[0].minor.yy459 = PRIVILEGE_TYPE_WRITE; } +#line 5537 "sql.c" break; case 47: /* priv_type ::= ALTER */ #line 135 "sql.y" -{ yymsp[0].minor.yy1005 = PRIVILEGE_TYPE_ALTER; } -#line 5496 "sql.c" +{ yymsp[0].minor.yy459 = PRIVILEGE_TYPE_ALTER; } +#line 5542 "sql.c" break; case 48: /* priv_level ::= NK_STAR NK_DOT NK_STAR */ #line 139 "sql.y" -{ yylhsminor.yy361.first = yymsp[-2].minor.yy0; yylhsminor.yy361.second = yymsp[0].minor.yy0; } -#line 5501 "sql.c" - yymsp[-2].minor.yy361 = yylhsminor.yy361; +{ yylhsminor.yy147.first = yymsp[-2].minor.yy0; yylhsminor.yy147.second = yymsp[0].minor.yy0; } +#line 5547 "sql.c" + yymsp[-2].minor.yy147 = yylhsminor.yy147; break; case 49: /* priv_level ::= db_name NK_DOT NK_STAR */ #line 140 "sql.y" -{ yylhsminor.yy361.first = yymsp[-2].minor.yy305; yylhsminor.yy361.second = yymsp[0].minor.yy0; } -#line 5507 "sql.c" - yymsp[-2].minor.yy361 = yylhsminor.yy361; +{ yylhsminor.yy147.first = yymsp[-2].minor.yy29; yylhsminor.yy147.second = yymsp[0].minor.yy0; } +#line 5553 "sql.c" + yymsp[-2].minor.yy147 = yylhsminor.yy147; break; case 50: /* priv_level ::= db_name NK_DOT table_name */ #line 141 "sql.y" -{ yylhsminor.yy361.first = yymsp[-2].minor.yy305; yylhsminor.yy361.second = yymsp[0].minor.yy305; } -#line 5513 "sql.c" - yymsp[-2].minor.yy361 = yylhsminor.yy361; +{ yylhsminor.yy147.first = yymsp[-2].minor.yy29; yylhsminor.yy147.second = yymsp[0].minor.yy29; } +#line 5559 "sql.c" + yymsp[-2].minor.yy147 = yylhsminor.yy147; break; case 51: /* priv_level ::= topic_name */ #line 142 "sql.y" -{ yylhsminor.yy361.first = yymsp[0].minor.yy305; yylhsminor.yy361.second = nil_token; } -#line 5519 "sql.c" - yymsp[0].minor.yy361 = yylhsminor.yy361; +{ yylhsminor.yy147.first = yymsp[0].minor.yy29; yylhsminor.yy147.second = nil_token; } +#line 5565 "sql.c" + yymsp[0].minor.yy147 = yylhsminor.yy147; break; case 52: /* with_opt ::= */ case 157: /* start_opt ::= */ yytestcase(yyruleno==157); case 161: /* end_opt ::= */ yytestcase(yyruleno==161); - case 307: /* like_pattern_opt ::= */ yytestcase(yyruleno==307); - case 392: /* subtable_opt ::= */ yytestcase(yyruleno==392); - case 558: /* case_when_else_opt ::= */ yytestcase(yyruleno==558); - case 588: /* from_clause_opt ::= */ yytestcase(yyruleno==588); - case 621: /* where_clause_opt ::= */ yytestcase(yyruleno==621); - case 630: /* twindow_clause_opt ::= */ yytestcase(yyruleno==630); - case 638: /* sliding_opt ::= */ yytestcase(yyruleno==638); - case 643: /* fill_opt ::= */ yytestcase(yyruleno==643); - case 657: /* having_clause_opt ::= */ yytestcase(yyruleno==657); - case 659: /* range_opt ::= */ yytestcase(yyruleno==659); - case 662: /* every_opt ::= */ yytestcase(yyruleno==662); - case 675: /* slimit_clause_opt ::= */ yytestcase(yyruleno==675); - case 679: /* limit_clause_opt ::= */ yytestcase(yyruleno==679); + case 311: /* like_pattern_opt ::= */ yytestcase(yyruleno==311); + case 396: /* subtable_opt ::= */ yytestcase(yyruleno==396); + case 563: /* case_when_else_opt ::= */ yytestcase(yyruleno==563); + case 593: /* from_clause_opt ::= */ yytestcase(yyruleno==593); + case 626: /* where_clause_opt ::= */ yytestcase(yyruleno==626); + case 635: /* twindow_clause_opt ::= */ yytestcase(yyruleno==635); + case 643: /* sliding_opt ::= */ yytestcase(yyruleno==643); + case 648: /* fill_opt ::= */ yytestcase(yyruleno==648); + case 662: /* having_clause_opt ::= */ yytestcase(yyruleno==662); + case 664: /* range_opt ::= */ yytestcase(yyruleno==664); + case 667: /* every_opt ::= */ yytestcase(yyruleno==667); + case 680: /* slimit_clause_opt ::= */ yytestcase(yyruleno==680); + case 684: /* limit_clause_opt ::= */ yytestcase(yyruleno==684); #line 144 "sql.y" -{ yymsp[1].minor.yy1000 = NULL; } -#line 5540 "sql.c" +{ yymsp[1].minor.yy812 = NULL; } +#line 5586 "sql.c" break; case 53: /* with_opt ::= WITH search_condition */ - case 589: /* from_clause_opt ::= FROM table_reference_list */ yytestcase(yyruleno==589); - case 622: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==622); - case 658: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==658); + case 594: /* from_clause_opt ::= FROM table_reference_list */ yytestcase(yyruleno==594); + case 627: /* where_clause_opt ::= WHERE search_condition */ yytestcase(yyruleno==627); + case 663: /* having_clause_opt ::= HAVING search_condition */ yytestcase(yyruleno==663); #line 145 "sql.y" -{ yymsp[-1].minor.yy1000 = yymsp[0].minor.yy1000; } -#line 5548 "sql.c" +{ yymsp[-1].minor.yy812 = yymsp[0].minor.yy812; } +#line 5594 "sql.c" break; case 54: /* cmd ::= CREATE DNODE dnode_endpoint */ #line 148 "sql.y" -{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[0].minor.yy305, NULL); } -#line 5553 "sql.c" +{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[0].minor.yy29, NULL); } +#line 5599 "sql.c" break; case 55: /* cmd ::= CREATE DNODE dnode_endpoint PORT NK_INTEGER */ #line 149 "sql.y" -{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[-2].minor.yy305, &yymsp[0].minor.yy0); } -#line 5558 "sql.c" +{ pCxt->pRootNode = createCreateDnodeStmt(pCxt, &yymsp[-2].minor.yy29, &yymsp[0].minor.yy0); } +#line 5604 "sql.c" break; case 56: /* cmd ::= DROP DNODE NK_INTEGER force_opt */ #line 150 "sql.y" -{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy985, false); } -#line 5563 "sql.c" +{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy887, false); } +#line 5609 "sql.c" break; case 57: /* cmd ::= DROP DNODE dnode_endpoint force_opt */ #line 151 "sql.y" -{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy305, yymsp[0].minor.yy985, false); } -#line 5568 "sql.c" +{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy29, yymsp[0].minor.yy887, false); } +#line 5614 "sql.c" break; case 58: /* cmd ::= DROP DNODE NK_INTEGER unsafe_opt */ #line 152 "sql.y" -{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy0, false, yymsp[0].minor.yy985); } -#line 5573 "sql.c" +{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy0, false, yymsp[0].minor.yy887); } +#line 5619 "sql.c" break; case 59: /* cmd ::= DROP DNODE dnode_endpoint unsafe_opt */ #line 153 "sql.y" -{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy305, false, yymsp[0].minor.yy985); } -#line 5578 "sql.c" +{ pCxt->pRootNode = createDropDnodeStmt(pCxt, &yymsp[-1].minor.yy29, false, yymsp[0].minor.yy887); } +#line 5624 "sql.c" break; case 60: /* cmd ::= ALTER DNODE NK_INTEGER NK_STRING */ #line 154 "sql.y" { pCxt->pRootNode = createAlterDnodeStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, NULL); } -#line 5583 "sql.c" +#line 5629 "sql.c" break; case 61: /* cmd ::= ALTER DNODE NK_INTEGER NK_STRING NK_STRING */ #line 155 "sql.y" { pCxt->pRootNode = createAlterDnodeStmt(pCxt, &yymsp[-2].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } -#line 5588 "sql.c" +#line 5634 "sql.c" break; case 62: /* cmd ::= ALTER ALL DNODES NK_STRING */ #line 156 "sql.y" { pCxt->pRootNode = createAlterDnodeStmt(pCxt, NULL, &yymsp[0].minor.yy0, NULL); } -#line 5593 "sql.c" +#line 5639 "sql.c" break; case 63: /* cmd ::= ALTER ALL DNODES NK_STRING NK_STRING */ #line 157 "sql.y" { pCxt->pRootNode = createAlterDnodeStmt(pCxt, NULL, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } -#line 5598 "sql.c" +#line 5644 "sql.c" break; case 64: /* cmd ::= RESTORE DNODE NK_INTEGER */ #line 158 "sql.y" { pCxt->pRootNode = createRestoreComponentNodeStmt(pCxt, QUERY_NODE_RESTORE_DNODE_STMT, &yymsp[0].minor.yy0); } -#line 5603 "sql.c" +#line 5649 "sql.c" break; case 65: /* dnode_endpoint ::= NK_STRING */ case 66: /* dnode_endpoint ::= NK_ID */ yytestcase(yyruleno==66); case 67: /* dnode_endpoint ::= NK_IPTOKEN */ yytestcase(yyruleno==67); - case 334: /* sma_func_name ::= COUNT */ yytestcase(yyruleno==334); - case 335: /* sma_func_name ::= FIRST */ yytestcase(yyruleno==335); - case 336: /* sma_func_name ::= LAST */ yytestcase(yyruleno==336); - case 337: /* sma_func_name ::= LAST_ROW */ yytestcase(yyruleno==337); - case 479: /* db_name ::= NK_ID */ yytestcase(yyruleno==479); - case 480: /* table_name ::= NK_ID */ yytestcase(yyruleno==480); - case 481: /* column_name ::= NK_ID */ yytestcase(yyruleno==481); - case 482: /* function_name ::= NK_ID */ yytestcase(yyruleno==482); - case 483: /* view_name ::= NK_ID */ yytestcase(yyruleno==483); - case 484: /* table_alias ::= NK_ID */ yytestcase(yyruleno==484); - case 485: /* column_alias ::= NK_ID */ yytestcase(yyruleno==485); - case 486: /* column_alias ::= NK_ALIAS */ yytestcase(yyruleno==486); - case 487: /* user_name ::= NK_ID */ yytestcase(yyruleno==487); - case 488: /* topic_name ::= NK_ID */ yytestcase(yyruleno==488); - case 489: /* stream_name ::= NK_ID */ yytestcase(yyruleno==489); - case 490: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==490); - case 491: /* index_name ::= NK_ID */ yytestcase(yyruleno==491); - case 534: /* noarg_func ::= NOW */ yytestcase(yyruleno==534); - case 535: /* noarg_func ::= TODAY */ yytestcase(yyruleno==535); - case 536: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==536); - case 537: /* noarg_func ::= DATABASE */ yytestcase(yyruleno==537); - case 538: /* noarg_func ::= CLIENT_VERSION */ yytestcase(yyruleno==538); - case 539: /* noarg_func ::= SERVER_VERSION */ yytestcase(yyruleno==539); - case 540: /* noarg_func ::= SERVER_STATUS */ yytestcase(yyruleno==540); - case 541: /* noarg_func ::= CURRENT_USER */ yytestcase(yyruleno==541); - case 542: /* noarg_func ::= USER */ yytestcase(yyruleno==542); - case 543: /* star_func ::= COUNT */ yytestcase(yyruleno==543); - case 544: /* star_func ::= FIRST */ yytestcase(yyruleno==544); - case 545: /* star_func ::= LAST */ yytestcase(yyruleno==545); - case 546: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==546); + case 338: /* sma_func_name ::= COUNT */ yytestcase(yyruleno==338); + case 339: /* sma_func_name ::= FIRST */ yytestcase(yyruleno==339); + case 340: /* sma_func_name ::= LAST */ yytestcase(yyruleno==340); + case 341: /* sma_func_name ::= LAST_ROW */ yytestcase(yyruleno==341); + case 483: /* db_name ::= NK_ID */ yytestcase(yyruleno==483); + case 484: /* table_name ::= NK_ID */ yytestcase(yyruleno==484); + case 485: /* column_name ::= NK_ID */ yytestcase(yyruleno==485); + case 486: /* function_name ::= NK_ID */ yytestcase(yyruleno==486); + case 487: /* view_name ::= NK_ID */ yytestcase(yyruleno==487); + case 488: /* table_alias ::= NK_ID */ yytestcase(yyruleno==488); + case 489: /* column_alias ::= NK_ID */ yytestcase(yyruleno==489); + case 490: /* column_alias ::= NK_ALIAS */ yytestcase(yyruleno==490); + case 491: /* user_name ::= NK_ID */ yytestcase(yyruleno==491); + case 492: /* topic_name ::= NK_ID */ yytestcase(yyruleno==492); + case 493: /* stream_name ::= NK_ID */ yytestcase(yyruleno==493); + case 494: /* cgroup_name ::= NK_ID */ yytestcase(yyruleno==494); + case 495: /* index_name ::= NK_ID */ yytestcase(yyruleno==495); + case 539: /* noarg_func ::= NOW */ yytestcase(yyruleno==539); + case 540: /* noarg_func ::= TODAY */ yytestcase(yyruleno==540); + case 541: /* noarg_func ::= TIMEZONE */ yytestcase(yyruleno==541); + case 542: /* noarg_func ::= DATABASE */ yytestcase(yyruleno==542); + case 543: /* noarg_func ::= CLIENT_VERSION */ yytestcase(yyruleno==543); + case 544: /* noarg_func ::= SERVER_VERSION */ yytestcase(yyruleno==544); + case 545: /* noarg_func ::= SERVER_STATUS */ yytestcase(yyruleno==545); + case 546: /* noarg_func ::= CURRENT_USER */ yytestcase(yyruleno==546); + case 547: /* noarg_func ::= USER */ yytestcase(yyruleno==547); + case 548: /* star_func ::= COUNT */ yytestcase(yyruleno==548); + case 549: /* star_func ::= FIRST */ yytestcase(yyruleno==549); + case 550: /* star_func ::= LAST */ yytestcase(yyruleno==550); + case 551: /* star_func ::= LAST_ROW */ yytestcase(yyruleno==551); #line 162 "sql.y" -{ yylhsminor.yy305 = yymsp[0].minor.yy0; } -#line 5640 "sql.c" - yymsp[0].minor.yy305 = yylhsminor.yy305; +{ yylhsminor.yy29 = yymsp[0].minor.yy0; } +#line 5686 "sql.c" + yymsp[0].minor.yy29 = yylhsminor.yy29; break; case 68: /* force_opt ::= */ case 94: /* not_exists_opt ::= */ yytestcase(yyruleno==94); case 96: /* exists_opt ::= */ yytestcase(yyruleno==96); - case 355: /* analyze_opt ::= */ yytestcase(yyruleno==355); - case 362: /* agg_func_opt ::= */ yytestcase(yyruleno==362); - case 368: /* or_replace_opt ::= */ yytestcase(yyruleno==368); - case 394: /* ignore_opt ::= */ yytestcase(yyruleno==394); - case 609: /* tag_mode_opt ::= */ yytestcase(yyruleno==609); - case 611: /* set_quantifier_opt ::= */ yytestcase(yyruleno==611); + case 359: /* analyze_opt ::= */ yytestcase(yyruleno==359); + case 366: /* agg_func_opt ::= */ yytestcase(yyruleno==366); + case 372: /* or_replace_opt ::= */ yytestcase(yyruleno==372); + case 398: /* ignore_opt ::= */ yytestcase(yyruleno==398); + case 614: /* tag_mode_opt ::= */ yytestcase(yyruleno==614); + case 616: /* set_quantifier_opt ::= */ yytestcase(yyruleno==616); #line 168 "sql.y" -{ yymsp[1].minor.yy985 = false; } -#line 5654 "sql.c" +{ yymsp[1].minor.yy887 = false; } +#line 5700 "sql.c" break; case 69: /* force_opt ::= FORCE */ case 70: /* unsafe_opt ::= UNSAFE */ yytestcase(yyruleno==70); - case 356: /* analyze_opt ::= ANALYZE */ yytestcase(yyruleno==356); - case 363: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==363); - case 610: /* tag_mode_opt ::= TAGS */ yytestcase(yyruleno==610); - case 612: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==612); + case 360: /* analyze_opt ::= ANALYZE */ yytestcase(yyruleno==360); + case 367: /* agg_func_opt ::= AGGREGATE */ yytestcase(yyruleno==367); + case 615: /* tag_mode_opt ::= TAGS */ yytestcase(yyruleno==615); + case 617: /* set_quantifier_opt ::= DISTINCT */ yytestcase(yyruleno==617); #line 169 "sql.y" -{ yymsp[0].minor.yy985 = true; } -#line 5664 "sql.c" +{ yymsp[0].minor.yy887 = true; } +#line 5710 "sql.c" break; case 71: /* cmd ::= ALTER CLUSTER NK_STRING */ #line 176 "sql.y" { pCxt->pRootNode = createAlterClusterStmt(pCxt, &yymsp[0].minor.yy0, NULL); } -#line 5669 "sql.c" +#line 5715 "sql.c" break; case 72: /* cmd ::= ALTER CLUSTER NK_STRING NK_STRING */ #line 177 "sql.y" { pCxt->pRootNode = createAlterClusterStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } -#line 5674 "sql.c" +#line 5720 "sql.c" break; case 73: /* cmd ::= ALTER LOCAL NK_STRING */ #line 180 "sql.y" { pCxt->pRootNode = createAlterLocalStmt(pCxt, &yymsp[0].minor.yy0, NULL); } -#line 5679 "sql.c" +#line 5725 "sql.c" break; case 74: /* cmd ::= ALTER LOCAL NK_STRING NK_STRING */ #line 181 "sql.y" { pCxt->pRootNode = createAlterLocalStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } -#line 5684 "sql.c" +#line 5730 "sql.c" break; case 75: /* cmd ::= CREATE QNODE ON DNODE NK_INTEGER */ #line 184 "sql.y" { pCxt->pRootNode = createCreateComponentNodeStmt(pCxt, QUERY_NODE_CREATE_QNODE_STMT, &yymsp[0].minor.yy0); } -#line 5689 "sql.c" +#line 5735 "sql.c" break; case 76: /* cmd ::= DROP QNODE ON DNODE NK_INTEGER */ #line 185 "sql.y" { pCxt->pRootNode = createDropComponentNodeStmt(pCxt, QUERY_NODE_DROP_QNODE_STMT, &yymsp[0].minor.yy0); } -#line 5694 "sql.c" +#line 5740 "sql.c" break; case 77: /* cmd ::= RESTORE QNODE ON DNODE NK_INTEGER */ #line 186 "sql.y" { pCxt->pRootNode = createRestoreComponentNodeStmt(pCxt, QUERY_NODE_RESTORE_QNODE_STMT, &yymsp[0].minor.yy0); } -#line 5699 "sql.c" +#line 5745 "sql.c" break; case 78: /* cmd ::= CREATE BNODE ON DNODE NK_INTEGER */ #line 189 "sql.y" { pCxt->pRootNode = createCreateComponentNodeStmt(pCxt, QUERY_NODE_CREATE_BNODE_STMT, &yymsp[0].minor.yy0); } -#line 5704 "sql.c" +#line 5750 "sql.c" break; case 79: /* cmd ::= DROP BNODE ON DNODE NK_INTEGER */ #line 190 "sql.y" { pCxt->pRootNode = createDropComponentNodeStmt(pCxt, QUERY_NODE_DROP_BNODE_STMT, &yymsp[0].minor.yy0); } -#line 5709 "sql.c" +#line 5755 "sql.c" break; case 80: /* cmd ::= CREATE SNODE ON DNODE NK_INTEGER */ #line 193 "sql.y" { pCxt->pRootNode = createCreateComponentNodeStmt(pCxt, QUERY_NODE_CREATE_SNODE_STMT, &yymsp[0].minor.yy0); } -#line 5714 "sql.c" +#line 5760 "sql.c" break; case 81: /* cmd ::= DROP SNODE ON DNODE NK_INTEGER */ #line 194 "sql.y" { pCxt->pRootNode = createDropComponentNodeStmt(pCxt, QUERY_NODE_DROP_SNODE_STMT, &yymsp[0].minor.yy0); } -#line 5719 "sql.c" +#line 5765 "sql.c" break; case 82: /* cmd ::= CREATE MNODE ON DNODE NK_INTEGER */ #line 197 "sql.y" { pCxt->pRootNode = createCreateComponentNodeStmt(pCxt, QUERY_NODE_CREATE_MNODE_STMT, &yymsp[0].minor.yy0); } -#line 5724 "sql.c" +#line 5770 "sql.c" break; case 83: /* cmd ::= DROP MNODE ON DNODE NK_INTEGER */ #line 198 "sql.y" { pCxt->pRootNode = createDropComponentNodeStmt(pCxt, QUERY_NODE_DROP_MNODE_STMT, &yymsp[0].minor.yy0); } -#line 5729 "sql.c" +#line 5775 "sql.c" break; case 84: /* cmd ::= RESTORE MNODE ON DNODE NK_INTEGER */ #line 199 "sql.y" { pCxt->pRootNode = createRestoreComponentNodeStmt(pCxt, QUERY_NODE_RESTORE_MNODE_STMT, &yymsp[0].minor.yy0); } -#line 5734 "sql.c" +#line 5780 "sql.c" break; case 85: /* cmd ::= RESTORE VNODE ON DNODE NK_INTEGER */ #line 202 "sql.y" { pCxt->pRootNode = createRestoreComponentNodeStmt(pCxt, QUERY_NODE_RESTORE_VNODE_STMT, &yymsp[0].minor.yy0); } -#line 5739 "sql.c" +#line 5785 "sql.c" break; case 86: /* cmd ::= CREATE DATABASE not_exists_opt db_name db_options */ #line 205 "sql.y" -{ pCxt->pRootNode = createCreateDatabaseStmt(pCxt, yymsp[-2].minor.yy985, &yymsp[-1].minor.yy305, yymsp[0].minor.yy1000); } -#line 5744 "sql.c" +{ pCxt->pRootNode = createCreateDatabaseStmt(pCxt, yymsp[-2].minor.yy887, &yymsp[-1].minor.yy29, yymsp[0].minor.yy812); } +#line 5790 "sql.c" break; case 87: /* cmd ::= DROP DATABASE exists_opt db_name */ #line 206 "sql.y" -{ pCxt->pRootNode = createDropDatabaseStmt(pCxt, yymsp[-1].minor.yy985, &yymsp[0].minor.yy305); } -#line 5749 "sql.c" +{ pCxt->pRootNode = createDropDatabaseStmt(pCxt, yymsp[-1].minor.yy887, &yymsp[0].minor.yy29); } +#line 5795 "sql.c" break; case 88: /* cmd ::= USE db_name */ #line 207 "sql.y" -{ pCxt->pRootNode = createUseDatabaseStmt(pCxt, &yymsp[0].minor.yy305); } -#line 5754 "sql.c" +{ pCxt->pRootNode = createUseDatabaseStmt(pCxt, &yymsp[0].minor.yy29); } +#line 5800 "sql.c" break; case 89: /* cmd ::= ALTER DATABASE db_name alter_db_options */ #line 208 "sql.y" -{ pCxt->pRootNode = createAlterDatabaseStmt(pCxt, &yymsp[-1].minor.yy305, yymsp[0].minor.yy1000); } -#line 5759 "sql.c" +{ pCxt->pRootNode = createAlterDatabaseStmt(pCxt, &yymsp[-1].minor.yy29, yymsp[0].minor.yy812); } +#line 5805 "sql.c" break; case 90: /* cmd ::= FLUSH DATABASE db_name */ #line 209 "sql.y" -{ pCxt->pRootNode = createFlushDatabaseStmt(pCxt, &yymsp[0].minor.yy305); } -#line 5764 "sql.c" +{ pCxt->pRootNode = createFlushDatabaseStmt(pCxt, &yymsp[0].minor.yy29); } +#line 5810 "sql.c" break; case 91: /* cmd ::= TRIM DATABASE db_name speed_opt */ #line 210 "sql.y" -{ pCxt->pRootNode = createTrimDatabaseStmt(pCxt, &yymsp[-1].minor.yy305, yymsp[0].minor.yy444); } -#line 5769 "sql.c" +{ pCxt->pRootNode = createTrimDatabaseStmt(pCxt, &yymsp[-1].minor.yy29, yymsp[0].minor.yy760); } +#line 5815 "sql.c" break; case 92: /* cmd ::= COMPACT DATABASE db_name start_opt end_opt */ #line 211 "sql.y" -{ pCxt->pRootNode = createCompactStmt(pCxt, &yymsp[-2].minor.yy305, yymsp[-1].minor.yy1000, yymsp[0].minor.yy1000); } -#line 5774 "sql.c" +{ pCxt->pRootNode = createCompactStmt(pCxt, &yymsp[-2].minor.yy29, yymsp[-1].minor.yy812, yymsp[0].minor.yy812); } +#line 5820 "sql.c" break; case 93: /* not_exists_opt ::= IF NOT EXISTS */ #line 215 "sql.y" -{ yymsp[-2].minor.yy985 = true; } -#line 5779 "sql.c" +{ yymsp[-2].minor.yy887 = true; } +#line 5825 "sql.c" break; case 95: /* exists_opt ::= IF EXISTS */ - case 369: /* or_replace_opt ::= OR REPLACE */ yytestcase(yyruleno==369); - case 395: /* ignore_opt ::= IGNORE UNTREATED */ yytestcase(yyruleno==395); + case 373: /* or_replace_opt ::= OR REPLACE */ yytestcase(yyruleno==373); + case 399: /* ignore_opt ::= IGNORE UNTREATED */ yytestcase(yyruleno==399); #line 220 "sql.y" -{ yymsp[-1].minor.yy985 = true; } -#line 5786 "sql.c" +{ yymsp[-1].minor.yy887 = true; } +#line 5832 "sql.c" break; case 97: /* db_options ::= */ #line 223 "sql.y" -{ yymsp[1].minor.yy1000 = createDefaultDatabaseOptions(pCxt); } -#line 5791 "sql.c" +{ yymsp[1].minor.yy812 = createDefaultDatabaseOptions(pCxt); } +#line 5837 "sql.c" break; case 98: /* db_options ::= db_options BUFFER NK_INTEGER */ #line 224 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_BUFFER, &yymsp[0].minor.yy0); } -#line 5796 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_BUFFER, &yymsp[0].minor.yy0); } +#line 5842 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 99: /* db_options ::= db_options CACHEMODEL NK_STRING */ #line 225 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_CACHEMODEL, &yymsp[0].minor.yy0); } -#line 5802 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_CACHEMODEL, &yymsp[0].minor.yy0); } +#line 5848 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 100: /* db_options ::= db_options CACHESIZE NK_INTEGER */ #line 226 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_CACHESIZE, &yymsp[0].minor.yy0); } -#line 5808 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_CACHESIZE, &yymsp[0].minor.yy0); } +#line 5854 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 101: /* db_options ::= db_options COMP NK_INTEGER */ #line 227 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_COMP, &yymsp[0].minor.yy0); } -#line 5814 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_COMP, &yymsp[0].minor.yy0); } +#line 5860 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 102: /* db_options ::= db_options DURATION NK_INTEGER */ case 103: /* db_options ::= db_options DURATION NK_VARIABLE */ yytestcase(yyruleno==103); #line 228 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_DAYS, &yymsp[0].minor.yy0); } -#line 5821 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_DAYS, &yymsp[0].minor.yy0); } +#line 5867 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 104: /* db_options ::= db_options MAXROWS NK_INTEGER */ #line 230 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_MAXROWS, &yymsp[0].minor.yy0); } -#line 5827 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_MAXROWS, &yymsp[0].minor.yy0); } +#line 5873 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 105: /* db_options ::= db_options MINROWS NK_INTEGER */ #line 231 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_MINROWS, &yymsp[0].minor.yy0); } -#line 5833 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_MINROWS, &yymsp[0].minor.yy0); } +#line 5879 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 106: /* db_options ::= db_options KEEP integer_list */ case 107: /* db_options ::= db_options KEEP variable_list */ yytestcase(yyruleno==107); #line 232 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_KEEP, yymsp[0].minor.yy72); } -#line 5840 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_KEEP, yymsp[0].minor.yy124); } +#line 5886 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 108: /* db_options ::= db_options PAGES NK_INTEGER */ #line 234 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_PAGES, &yymsp[0].minor.yy0); } -#line 5846 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_PAGES, &yymsp[0].minor.yy0); } +#line 5892 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 109: /* db_options ::= db_options PAGESIZE NK_INTEGER */ #line 235 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_PAGESIZE, &yymsp[0].minor.yy0); } -#line 5852 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_PAGESIZE, &yymsp[0].minor.yy0); } +#line 5898 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 110: /* db_options ::= db_options TSDB_PAGESIZE NK_INTEGER */ #line 236 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_TSDB_PAGESIZE, &yymsp[0].minor.yy0); } -#line 5858 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_TSDB_PAGESIZE, &yymsp[0].minor.yy0); } +#line 5904 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 111: /* db_options ::= db_options PRECISION NK_STRING */ #line 237 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_PRECISION, &yymsp[0].minor.yy0); } -#line 5864 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_PRECISION, &yymsp[0].minor.yy0); } +#line 5910 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 112: /* db_options ::= db_options REPLICA NK_INTEGER */ #line 238 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_REPLICA, &yymsp[0].minor.yy0); } -#line 5870 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_REPLICA, &yymsp[0].minor.yy0); } +#line 5916 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 113: /* db_options ::= db_options VGROUPS NK_INTEGER */ #line 240 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_VGROUPS, &yymsp[0].minor.yy0); } -#line 5876 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_VGROUPS, &yymsp[0].minor.yy0); } +#line 5922 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 114: /* db_options ::= db_options SINGLE_STABLE NK_INTEGER */ #line 241 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_SINGLE_STABLE, &yymsp[0].minor.yy0); } -#line 5882 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_SINGLE_STABLE, &yymsp[0].minor.yy0); } +#line 5928 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 115: /* db_options ::= db_options RETENTIONS retention_list */ #line 242 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_RETENTIONS, yymsp[0].minor.yy72); } -#line 5888 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_RETENTIONS, yymsp[0].minor.yy124); } +#line 5934 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 116: /* db_options ::= db_options SCHEMALESS NK_INTEGER */ #line 243 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_SCHEMALESS, &yymsp[0].minor.yy0); } -#line 5894 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_SCHEMALESS, &yymsp[0].minor.yy0); } +#line 5940 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 117: /* db_options ::= db_options WAL_LEVEL NK_INTEGER */ #line 244 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_WAL, &yymsp[0].minor.yy0); } -#line 5900 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_WAL, &yymsp[0].minor.yy0); } +#line 5946 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 118: /* db_options ::= db_options WAL_FSYNC_PERIOD NK_INTEGER */ #line 245 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_FSYNC, &yymsp[0].minor.yy0); } -#line 5906 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_FSYNC, &yymsp[0].minor.yy0); } +#line 5952 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 119: /* db_options ::= db_options WAL_RETENTION_PERIOD NK_INTEGER */ #line 246 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_WAL_RETENTION_PERIOD, &yymsp[0].minor.yy0); } -#line 5912 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_WAL_RETENTION_PERIOD, &yymsp[0].minor.yy0); } +#line 5958 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 120: /* db_options ::= db_options WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ #line 247 "sql.y" { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-3].minor.yy1000, DB_OPTION_WAL_RETENTION_PERIOD, &t); + yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-3].minor.yy812, DB_OPTION_WAL_RETENTION_PERIOD, &t); } -#line 5922 "sql.c" - yymsp[-3].minor.yy1000 = yylhsminor.yy1000; +#line 5968 "sql.c" + yymsp[-3].minor.yy812 = yylhsminor.yy812; break; case 121: /* db_options ::= db_options WAL_RETENTION_SIZE NK_INTEGER */ #line 252 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_WAL_RETENTION_SIZE, &yymsp[0].minor.yy0); } -#line 5928 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_WAL_RETENTION_SIZE, &yymsp[0].minor.yy0); } +#line 5974 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 122: /* db_options ::= db_options WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ #line 253 "sql.y" { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-3].minor.yy1000, DB_OPTION_WAL_RETENTION_SIZE, &t); + yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-3].minor.yy812, DB_OPTION_WAL_RETENTION_SIZE, &t); } -#line 5938 "sql.c" - yymsp[-3].minor.yy1000 = yylhsminor.yy1000; +#line 5984 "sql.c" + yymsp[-3].minor.yy812 = yylhsminor.yy812; break; case 123: /* db_options ::= db_options WAL_ROLL_PERIOD NK_INTEGER */ #line 258 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_WAL_ROLL_PERIOD, &yymsp[0].minor.yy0); } -#line 5944 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_WAL_ROLL_PERIOD, &yymsp[0].minor.yy0); } +#line 5990 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 124: /* db_options ::= db_options WAL_SEGMENT_SIZE NK_INTEGER */ #line 259 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_WAL_SEGMENT_SIZE, &yymsp[0].minor.yy0); } -#line 5950 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_WAL_SEGMENT_SIZE, &yymsp[0].minor.yy0); } +#line 5996 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 125: /* db_options ::= db_options STT_TRIGGER NK_INTEGER */ #line 260 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_STT_TRIGGER, &yymsp[0].minor.yy0); } -#line 5956 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_STT_TRIGGER, &yymsp[0].minor.yy0); } +#line 6002 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 126: /* db_options ::= db_options TABLE_PREFIX signed */ #line 261 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_TABLE_PREFIX, yymsp[0].minor.yy1000); } -#line 5962 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_TABLE_PREFIX, yymsp[0].minor.yy812); } +#line 6008 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 127: /* db_options ::= db_options TABLE_SUFFIX signed */ #line 262 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_TABLE_SUFFIX, yymsp[0].minor.yy1000); } -#line 5968 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_TABLE_SUFFIX, yymsp[0].minor.yy812); } +#line 6014 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 128: /* db_options ::= db_options KEEP_TIME_OFFSET NK_INTEGER */ #line 263 "sql.y" -{ yylhsminor.yy1000 = setDatabaseOption(pCxt, yymsp[-2].minor.yy1000, DB_OPTION_KEEP_TIME_OFFSET, &yymsp[0].minor.yy0); } -#line 5974 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setDatabaseOption(pCxt, yymsp[-2].minor.yy812, DB_OPTION_KEEP_TIME_OFFSET, &yymsp[0].minor.yy0); } +#line 6020 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 129: /* alter_db_options ::= alter_db_option */ #line 265 "sql.y" -{ yylhsminor.yy1000 = createAlterDatabaseOptions(pCxt); yylhsminor.yy1000 = setAlterDatabaseOption(pCxt, yylhsminor.yy1000, &yymsp[0].minor.yy941); } -#line 5980 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = createAlterDatabaseOptions(pCxt); yylhsminor.yy812 = setAlterDatabaseOption(pCxt, yylhsminor.yy812, &yymsp[0].minor.yy95); } +#line 6026 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; break; case 130: /* alter_db_options ::= alter_db_options alter_db_option */ #line 266 "sql.y" -{ yylhsminor.yy1000 = setAlterDatabaseOption(pCxt, yymsp[-1].minor.yy1000, &yymsp[0].minor.yy941); } -#line 5986 "sql.c" - yymsp[-1].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setAlterDatabaseOption(pCxt, yymsp[-1].minor.yy812, &yymsp[0].minor.yy95); } +#line 6032 "sql.c" + yymsp[-1].minor.yy812 = yylhsminor.yy812; break; case 131: /* alter_db_option ::= BUFFER NK_INTEGER */ #line 270 "sql.y" -{ yymsp[-1].minor.yy941.type = DB_OPTION_BUFFER; yymsp[-1].minor.yy941.val = yymsp[0].minor.yy0; } -#line 5992 "sql.c" +{ yymsp[-1].minor.yy95.type = DB_OPTION_BUFFER; yymsp[-1].minor.yy95.val = yymsp[0].minor.yy0; } +#line 6038 "sql.c" break; case 132: /* alter_db_option ::= CACHEMODEL NK_STRING */ #line 271 "sql.y" -{ yymsp[-1].minor.yy941.type = DB_OPTION_CACHEMODEL; yymsp[-1].minor.yy941.val = yymsp[0].minor.yy0; } -#line 5997 "sql.c" +{ yymsp[-1].minor.yy95.type = DB_OPTION_CACHEMODEL; yymsp[-1].minor.yy95.val = yymsp[0].minor.yy0; } +#line 6043 "sql.c" break; case 133: /* alter_db_option ::= CACHESIZE NK_INTEGER */ #line 272 "sql.y" -{ yymsp[-1].minor.yy941.type = DB_OPTION_CACHESIZE; yymsp[-1].minor.yy941.val = yymsp[0].minor.yy0; } -#line 6002 "sql.c" +{ yymsp[-1].minor.yy95.type = DB_OPTION_CACHESIZE; yymsp[-1].minor.yy95.val = yymsp[0].minor.yy0; } +#line 6048 "sql.c" break; case 134: /* alter_db_option ::= WAL_FSYNC_PERIOD NK_INTEGER */ #line 273 "sql.y" -{ yymsp[-1].minor.yy941.type = DB_OPTION_FSYNC; yymsp[-1].minor.yy941.val = yymsp[0].minor.yy0; } -#line 6007 "sql.c" +{ yymsp[-1].minor.yy95.type = DB_OPTION_FSYNC; yymsp[-1].minor.yy95.val = yymsp[0].minor.yy0; } +#line 6053 "sql.c" break; case 135: /* alter_db_option ::= KEEP integer_list */ case 136: /* alter_db_option ::= KEEP variable_list */ yytestcase(yyruleno==136); #line 274 "sql.y" -{ yymsp[-1].minor.yy941.type = DB_OPTION_KEEP; yymsp[-1].minor.yy941.pList = yymsp[0].minor.yy72; } -#line 6013 "sql.c" +{ yymsp[-1].minor.yy95.type = DB_OPTION_KEEP; yymsp[-1].minor.yy95.pList = yymsp[0].minor.yy124; } +#line 6059 "sql.c" break; case 137: /* alter_db_option ::= PAGES NK_INTEGER */ #line 276 "sql.y" -{ yymsp[-1].minor.yy941.type = DB_OPTION_PAGES; yymsp[-1].minor.yy941.val = yymsp[0].minor.yy0; } -#line 6018 "sql.c" +{ yymsp[-1].minor.yy95.type = DB_OPTION_PAGES; yymsp[-1].minor.yy95.val = yymsp[0].minor.yy0; } +#line 6064 "sql.c" break; case 138: /* alter_db_option ::= REPLICA NK_INTEGER */ #line 277 "sql.y" -{ yymsp[-1].minor.yy941.type = DB_OPTION_REPLICA; yymsp[-1].minor.yy941.val = yymsp[0].minor.yy0; } -#line 6023 "sql.c" +{ yymsp[-1].minor.yy95.type = DB_OPTION_REPLICA; yymsp[-1].minor.yy95.val = yymsp[0].minor.yy0; } +#line 6069 "sql.c" break; case 139: /* alter_db_option ::= WAL_LEVEL NK_INTEGER */ #line 279 "sql.y" -{ yymsp[-1].minor.yy941.type = DB_OPTION_WAL; yymsp[-1].minor.yy941.val = yymsp[0].minor.yy0; } -#line 6028 "sql.c" +{ yymsp[-1].minor.yy95.type = DB_OPTION_WAL; yymsp[-1].minor.yy95.val = yymsp[0].minor.yy0; } +#line 6074 "sql.c" break; case 140: /* alter_db_option ::= STT_TRIGGER NK_INTEGER */ #line 280 "sql.y" -{ yymsp[-1].minor.yy941.type = DB_OPTION_STT_TRIGGER; yymsp[-1].minor.yy941.val = yymsp[0].minor.yy0; } -#line 6033 "sql.c" +{ yymsp[-1].minor.yy95.type = DB_OPTION_STT_TRIGGER; yymsp[-1].minor.yy95.val = yymsp[0].minor.yy0; } +#line 6079 "sql.c" break; case 141: /* alter_db_option ::= MINROWS NK_INTEGER */ #line 281 "sql.y" -{ yymsp[-1].minor.yy941.type = DB_OPTION_MINROWS; yymsp[-1].minor.yy941.val = yymsp[0].minor.yy0; } -#line 6038 "sql.c" +{ yymsp[-1].minor.yy95.type = DB_OPTION_MINROWS; yymsp[-1].minor.yy95.val = yymsp[0].minor.yy0; } +#line 6084 "sql.c" break; case 142: /* alter_db_option ::= WAL_RETENTION_PERIOD NK_INTEGER */ #line 282 "sql.y" -{ yymsp[-1].minor.yy941.type = DB_OPTION_WAL_RETENTION_PERIOD; yymsp[-1].minor.yy941.val = yymsp[0].minor.yy0; } -#line 6043 "sql.c" +{ yymsp[-1].minor.yy95.type = DB_OPTION_WAL_RETENTION_PERIOD; yymsp[-1].minor.yy95.val = yymsp[0].minor.yy0; } +#line 6089 "sql.c" break; case 143: /* alter_db_option ::= WAL_RETENTION_PERIOD NK_MINUS NK_INTEGER */ #line 283 "sql.y" { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yymsp[-2].minor.yy941.type = DB_OPTION_WAL_RETENTION_PERIOD; yymsp[-2].minor.yy941.val = t; + yymsp[-2].minor.yy95.type = DB_OPTION_WAL_RETENTION_PERIOD; yymsp[-2].minor.yy95.val = t; } -#line 6052 "sql.c" +#line 6098 "sql.c" break; case 144: /* alter_db_option ::= WAL_RETENTION_SIZE NK_INTEGER */ #line 288 "sql.y" -{ yymsp[-1].minor.yy941.type = DB_OPTION_WAL_RETENTION_SIZE; yymsp[-1].minor.yy941.val = yymsp[0].minor.yy0; } -#line 6057 "sql.c" +{ yymsp[-1].minor.yy95.type = DB_OPTION_WAL_RETENTION_SIZE; yymsp[-1].minor.yy95.val = yymsp[0].minor.yy0; } +#line 6103 "sql.c" break; case 145: /* alter_db_option ::= WAL_RETENTION_SIZE NK_MINUS NK_INTEGER */ #line 289 "sql.y" { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yymsp[-2].minor.yy941.type = DB_OPTION_WAL_RETENTION_SIZE; yymsp[-2].minor.yy941.val = t; + yymsp[-2].minor.yy95.type = DB_OPTION_WAL_RETENTION_SIZE; yymsp[-2].minor.yy95.val = t; } -#line 6066 "sql.c" +#line 6112 "sql.c" break; case 146: /* alter_db_option ::= KEEP_TIME_OFFSET NK_INTEGER */ #line 294 "sql.y" -{ yymsp[-1].minor.yy941.type = DB_OPTION_KEEP_TIME_OFFSET; yymsp[-1].minor.yy941.val = yymsp[0].minor.yy0; } -#line 6071 "sql.c" +{ yymsp[-1].minor.yy95.type = DB_OPTION_KEEP_TIME_OFFSET; yymsp[-1].minor.yy95.val = yymsp[0].minor.yy0; } +#line 6117 "sql.c" break; case 147: /* integer_list ::= NK_INTEGER */ #line 298 "sql.y" -{ yylhsminor.yy72 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } -#line 6076 "sql.c" - yymsp[0].minor.yy72 = yylhsminor.yy72; +{ yylhsminor.yy124 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } +#line 6122 "sql.c" + yymsp[0].minor.yy124 = yylhsminor.yy124; break; case 148: /* integer_list ::= integer_list NK_COMMA NK_INTEGER */ - case 408: /* dnode_list ::= dnode_list DNODE NK_INTEGER */ yytestcase(yyruleno==408); + case 412: /* dnode_list ::= dnode_list DNODE NK_INTEGER */ yytestcase(yyruleno==412); #line 299 "sql.y" -{ yylhsminor.yy72 = addNodeToList(pCxt, yymsp[-2].minor.yy72, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } -#line 6083 "sql.c" - yymsp[-2].minor.yy72 = yylhsminor.yy72; +{ yylhsminor.yy124 = addNodeToList(pCxt, yymsp[-2].minor.yy124, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } +#line 6129 "sql.c" + yymsp[-2].minor.yy124 = yylhsminor.yy124; break; case 149: /* variable_list ::= NK_VARIABLE */ #line 303 "sql.y" -{ yylhsminor.yy72 = createNodeList(pCxt, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } -#line 6089 "sql.c" - yymsp[0].minor.yy72 = yylhsminor.yy72; +{ yylhsminor.yy124 = createNodeList(pCxt, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } +#line 6135 "sql.c" + yymsp[0].minor.yy124 = yylhsminor.yy124; break; case 150: /* variable_list ::= variable_list NK_COMMA NK_VARIABLE */ #line 304 "sql.y" -{ yylhsminor.yy72 = addNodeToList(pCxt, yymsp[-2].minor.yy72, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } -#line 6095 "sql.c" - yymsp[-2].minor.yy72 = yylhsminor.yy72; +{ yylhsminor.yy124 = addNodeToList(pCxt, yymsp[-2].minor.yy124, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } +#line 6141 "sql.c" + yymsp[-2].minor.yy124 = yylhsminor.yy124; break; case 151: /* retention_list ::= retention */ case 183: /* multi_create_clause ::= create_subtable_clause */ yytestcase(yyruleno==183); case 186: /* multi_drop_clause ::= drop_table_clause */ yytestcase(yyruleno==186); case 193: /* tag_def_list ::= tag_def */ yytestcase(yyruleno==193); case 196: /* column_def_list ::= column_def */ yytestcase(yyruleno==196); - case 240: /* rollup_func_list ::= rollup_func_name */ yytestcase(yyruleno==240); - case 245: /* col_name_list ::= col_name */ yytestcase(yyruleno==245); - case 313: /* tag_list_opt ::= tag_item */ yytestcase(yyruleno==313); - case 330: /* func_list ::= func */ yytestcase(yyruleno==330); - case 452: /* tags_literal_list ::= tags_literal */ yytestcase(yyruleno==452); - case 477: /* literal_list ::= signed_literal */ yytestcase(yyruleno==477); - case 549: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==549); - case 555: /* when_then_list ::= when_then_expr */ yytestcase(yyruleno==555); - case 614: /* select_list ::= select_item */ yytestcase(yyruleno==614); - case 625: /* partition_list ::= partition_item */ yytestcase(yyruleno==625); - case 686: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==686); + case 244: /* rollup_func_list ::= rollup_func_name */ yytestcase(yyruleno==244); + case 249: /* col_name_list ::= col_name */ yytestcase(yyruleno==249); + case 317: /* tag_list_opt ::= tag_item */ yytestcase(yyruleno==317); + case 334: /* func_list ::= func */ yytestcase(yyruleno==334); + case 456: /* tags_literal_list ::= tags_literal */ yytestcase(yyruleno==456); + case 481: /* literal_list ::= signed_literal */ yytestcase(yyruleno==481); + case 554: /* other_para_list ::= star_func_para */ yytestcase(yyruleno==554); + case 560: /* when_then_list ::= when_then_expr */ yytestcase(yyruleno==560); + case 619: /* select_list ::= select_item */ yytestcase(yyruleno==619); + case 630: /* partition_list ::= partition_item */ yytestcase(yyruleno==630); + case 691: /* sort_specification_list ::= sort_specification */ yytestcase(yyruleno==691); #line 308 "sql.y" -{ yylhsminor.yy72 = createNodeList(pCxt, yymsp[0].minor.yy1000); } -#line 6116 "sql.c" - yymsp[0].minor.yy72 = yylhsminor.yy72; +{ yylhsminor.yy124 = createNodeList(pCxt, yymsp[0].minor.yy812); } +#line 6162 "sql.c" + yymsp[0].minor.yy124 = yylhsminor.yy124; break; case 152: /* retention_list ::= retention_list NK_COMMA retention */ case 187: /* multi_drop_clause ::= multi_drop_clause NK_COMMA drop_table_clause */ yytestcase(yyruleno==187); case 194: /* tag_def_list ::= tag_def_list NK_COMMA tag_def */ yytestcase(yyruleno==194); case 197: /* column_def_list ::= column_def_list NK_COMMA column_def */ yytestcase(yyruleno==197); - case 241: /* rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ yytestcase(yyruleno==241); - case 246: /* col_name_list ::= col_name_list NK_COMMA col_name */ yytestcase(yyruleno==246); - case 314: /* tag_list_opt ::= tag_list_opt NK_COMMA tag_item */ yytestcase(yyruleno==314); - case 331: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==331); - case 453: /* tags_literal_list ::= tags_literal_list NK_COMMA tags_literal */ yytestcase(yyruleno==453); - case 478: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==478); - case 550: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==550); - case 615: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==615); - case 626: /* partition_list ::= partition_list NK_COMMA partition_item */ yytestcase(yyruleno==626); - case 687: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==687); + case 245: /* rollup_func_list ::= rollup_func_list NK_COMMA rollup_func_name */ yytestcase(yyruleno==245); + case 250: /* col_name_list ::= col_name_list NK_COMMA col_name */ yytestcase(yyruleno==250); + case 318: /* tag_list_opt ::= tag_list_opt NK_COMMA tag_item */ yytestcase(yyruleno==318); + case 335: /* func_list ::= func_list NK_COMMA func */ yytestcase(yyruleno==335); + case 457: /* tags_literal_list ::= tags_literal_list NK_COMMA tags_literal */ yytestcase(yyruleno==457); + case 482: /* literal_list ::= literal_list NK_COMMA signed_literal */ yytestcase(yyruleno==482); + case 555: /* other_para_list ::= other_para_list NK_COMMA star_func_para */ yytestcase(yyruleno==555); + case 620: /* select_list ::= select_list NK_COMMA select_item */ yytestcase(yyruleno==620); + case 631: /* partition_list ::= partition_list NK_COMMA partition_item */ yytestcase(yyruleno==631); + case 692: /* sort_specification_list ::= sort_specification_list NK_COMMA sort_specification */ yytestcase(yyruleno==692); #line 309 "sql.y" -{ yylhsminor.yy72 = addNodeToList(pCxt, yymsp[-2].minor.yy72, yymsp[0].minor.yy1000); } -#line 6135 "sql.c" - yymsp[-2].minor.yy72 = yylhsminor.yy72; +{ yylhsminor.yy124 = addNodeToList(pCxt, yymsp[-2].minor.yy124, yymsp[0].minor.yy812); } +#line 6181 "sql.c" + yymsp[-2].minor.yy124 = yylhsminor.yy124; break; case 153: /* retention ::= NK_VARIABLE NK_COLON NK_VARIABLE */ case 154: /* retention ::= NK_MINUS NK_COLON NK_VARIABLE */ yytestcase(yyruleno==154); #line 311 "sql.y" -{ yylhsminor.yy1000 = createNodeListNodeEx(pCxt, createDurationValueNode(pCxt, &yymsp[-2].minor.yy0), createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } -#line 6142 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = createNodeListNodeEx(pCxt, createDurationValueNode(pCxt, &yymsp[-2].minor.yy0), createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } +#line 6188 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 155: /* speed_opt ::= */ - case 364: /* bufsize_opt ::= */ yytestcase(yyruleno==364); + case 368: /* bufsize_opt ::= */ yytestcase(yyruleno==368); #line 316 "sql.y" -{ yymsp[1].minor.yy444 = 0; } -#line 6149 "sql.c" +{ yymsp[1].minor.yy760 = 0; } +#line 6195 "sql.c" break; case 156: /* speed_opt ::= BWLIMIT NK_INTEGER */ - case 365: /* bufsize_opt ::= BUFSIZE NK_INTEGER */ yytestcase(yyruleno==365); + case 369: /* bufsize_opt ::= BUFSIZE NK_INTEGER */ yytestcase(yyruleno==369); #line 317 "sql.y" -{ yymsp[-1].minor.yy444 = taosStr2Int32(yymsp[0].minor.yy0.z, NULL, 10); } -#line 6155 "sql.c" +{ yymsp[-1].minor.yy760 = taosStr2Int32(yymsp[0].minor.yy0.z, NULL, 10); } +#line 6201 "sql.c" break; case 158: /* start_opt ::= START WITH NK_INTEGER */ case 162: /* end_opt ::= END WITH NK_INTEGER */ yytestcase(yyruleno==162); #line 320 "sql.y" -{ yymsp[-2].minor.yy1000 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); } -#line 6161 "sql.c" +{ yymsp[-2].minor.yy812 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0); } +#line 6207 "sql.c" break; case 159: /* start_opt ::= START WITH NK_STRING */ case 163: /* end_opt ::= END WITH NK_STRING */ yytestcase(yyruleno==163); #line 321 "sql.y" -{ yymsp[-2].minor.yy1000 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } -#line 6167 "sql.c" +{ yymsp[-2].minor.yy812 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } +#line 6213 "sql.c" break; case 160: /* start_opt ::= START WITH TIMESTAMP NK_STRING */ case 164: /* end_opt ::= END WITH TIMESTAMP NK_STRING */ yytestcase(yyruleno==164); #line 322 "sql.y" -{ yymsp[-3].minor.yy1000 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } -#line 6173 "sql.c" +{ yymsp[-3].minor.yy812 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } +#line 6219 "sql.c" break; case 165: /* cmd ::= CREATE TABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def_opt table_options */ case 167: /* cmd ::= CREATE STABLE not_exists_opt full_table_name NK_LP column_def_list NK_RP tags_def table_options */ yytestcase(yyruleno==167); #line 331 "sql.y" -{ pCxt->pRootNode = createCreateTableStmt(pCxt, yymsp[-6].minor.yy985, yymsp[-5].minor.yy1000, yymsp[-3].minor.yy72, yymsp[-1].minor.yy72, yymsp[0].minor.yy1000); } -#line 6179 "sql.c" +{ pCxt->pRootNode = createCreateTableStmt(pCxt, yymsp[-6].minor.yy887, yymsp[-5].minor.yy812, yymsp[-3].minor.yy124, yymsp[-1].minor.yy124, yymsp[0].minor.yy812); } +#line 6225 "sql.c" break; case 166: /* cmd ::= CREATE TABLE multi_create_clause */ #line 332 "sql.y" -{ pCxt->pRootNode = createCreateMultiTableStmt(pCxt, yymsp[0].minor.yy72); } -#line 6184 "sql.c" +{ pCxt->pRootNode = createCreateMultiTableStmt(pCxt, yymsp[0].minor.yy124); } +#line 6230 "sql.c" break; case 168: /* cmd ::= DROP TABLE multi_drop_clause */ #line 335 "sql.y" -{ pCxt->pRootNode = createDropTableStmt(pCxt, yymsp[0].minor.yy72); } -#line 6189 "sql.c" +{ pCxt->pRootNode = createDropTableStmt(pCxt, yymsp[0].minor.yy124); } +#line 6235 "sql.c" break; case 169: /* cmd ::= DROP STABLE exists_opt full_table_name */ #line 336 "sql.y" -{ pCxt->pRootNode = createDropSuperTableStmt(pCxt, yymsp[-1].minor.yy985, yymsp[0].minor.yy1000); } -#line 6194 "sql.c" +{ pCxt->pRootNode = createDropSuperTableStmt(pCxt, yymsp[-1].minor.yy887, yymsp[0].minor.yy812); } +#line 6240 "sql.c" break; case 170: /* cmd ::= ALTER TABLE alter_table_clause */ - case 410: /* cmd ::= query_or_subquery */ yytestcase(yyruleno==410); - case 411: /* cmd ::= insert_query */ yytestcase(yyruleno==411); + case 414: /* cmd ::= query_or_subquery */ yytestcase(yyruleno==414); + case 415: /* cmd ::= insert_query */ yytestcase(yyruleno==415); #line 338 "sql.y" -{ pCxt->pRootNode = yymsp[0].minor.yy1000; } -#line 6201 "sql.c" +{ pCxt->pRootNode = yymsp[0].minor.yy812; } +#line 6247 "sql.c" break; case 171: /* cmd ::= ALTER STABLE alter_table_clause */ #line 339 "sql.y" -{ pCxt->pRootNode = setAlterSuperTableType(yymsp[0].minor.yy1000); } -#line 6206 "sql.c" +{ pCxt->pRootNode = setAlterSuperTableType(yymsp[0].minor.yy812); } +#line 6252 "sql.c" break; case 172: /* alter_table_clause ::= full_table_name alter_table_options */ #line 341 "sql.y" -{ yylhsminor.yy1000 = createAlterTableModifyOptions(pCxt, yymsp[-1].minor.yy1000, yymsp[0].minor.yy1000); } -#line 6211 "sql.c" - yymsp[-1].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = createAlterTableModifyOptions(pCxt, yymsp[-1].minor.yy812, yymsp[0].minor.yy812); } +#line 6257 "sql.c" + yymsp[-1].minor.yy812 = yylhsminor.yy812; break; case 173: /* alter_table_clause ::= full_table_name ADD COLUMN column_name type_name */ #line 343 "sql.y" -{ yylhsminor.yy1000 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy1000, TSDB_ALTER_TABLE_ADD_COLUMN, &yymsp[-1].minor.yy305, yymsp[0].minor.yy56); } -#line 6217 "sql.c" - yymsp[-4].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy812, TSDB_ALTER_TABLE_ADD_COLUMN, &yymsp[-1].minor.yy29, yymsp[0].minor.yy784); } +#line 6263 "sql.c" + yymsp[-4].minor.yy812 = yylhsminor.yy812; break; case 174: /* alter_table_clause ::= full_table_name DROP COLUMN column_name */ #line 344 "sql.y" -{ yylhsminor.yy1000 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy1000, TSDB_ALTER_TABLE_DROP_COLUMN, &yymsp[0].minor.yy305); } -#line 6223 "sql.c" - yymsp[-3].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy812, TSDB_ALTER_TABLE_DROP_COLUMN, &yymsp[0].minor.yy29); } +#line 6269 "sql.c" + yymsp[-3].minor.yy812 = yylhsminor.yy812; break; case 175: /* alter_table_clause ::= full_table_name MODIFY COLUMN column_name type_name */ #line 346 "sql.y" -{ yylhsminor.yy1000 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy1000, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, &yymsp[-1].minor.yy305, yymsp[0].minor.yy56); } -#line 6229 "sql.c" - yymsp[-4].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy812, TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES, &yymsp[-1].minor.yy29, yymsp[0].minor.yy784); } +#line 6275 "sql.c" + yymsp[-4].minor.yy812 = yylhsminor.yy812; break; case 176: /* alter_table_clause ::= full_table_name MODIFY COLUMN column_name column_options */ #line 348 "sql.y" -{ yylhsminor.yy1000 = createAlterTableAddModifyColOptions(pCxt, yymsp[-4].minor.yy1000, TSDB_ALTER_TABLE_UPDATE_COLUMN_COMPRESS, &yymsp[-1].minor.yy305, yymsp[0].minor.yy1000); } -#line 6235 "sql.c" - yymsp[-4].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = createAlterTableAddModifyColOptions(pCxt, yymsp[-4].minor.yy812, TSDB_ALTER_TABLE_UPDATE_COLUMN_COMPRESS, &yymsp[-1].minor.yy29, yymsp[0].minor.yy812); } +#line 6281 "sql.c" + yymsp[-4].minor.yy812 = yylhsminor.yy812; break; case 177: /* alter_table_clause ::= full_table_name RENAME COLUMN column_name column_name */ #line 350 "sql.y" -{ yylhsminor.yy1000 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy1000, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &yymsp[-1].minor.yy305, &yymsp[0].minor.yy305); } -#line 6241 "sql.c" - yymsp[-4].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy812, TSDB_ALTER_TABLE_UPDATE_COLUMN_NAME, &yymsp[-1].minor.yy29, &yymsp[0].minor.yy29); } +#line 6287 "sql.c" + yymsp[-4].minor.yy812 = yylhsminor.yy812; break; case 178: /* alter_table_clause ::= full_table_name ADD TAG column_name type_name */ #line 352 "sql.y" -{ yylhsminor.yy1000 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy1000, TSDB_ALTER_TABLE_ADD_TAG, &yymsp[-1].minor.yy305, yymsp[0].minor.yy56); } -#line 6247 "sql.c" - yymsp[-4].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy812, TSDB_ALTER_TABLE_ADD_TAG, &yymsp[-1].minor.yy29, yymsp[0].minor.yy784); } +#line 6293 "sql.c" + yymsp[-4].minor.yy812 = yylhsminor.yy812; break; case 179: /* alter_table_clause ::= full_table_name DROP TAG column_name */ #line 353 "sql.y" -{ yylhsminor.yy1000 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy1000, TSDB_ALTER_TABLE_DROP_TAG, &yymsp[0].minor.yy305); } -#line 6253 "sql.c" - yymsp[-3].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = createAlterTableDropCol(pCxt, yymsp[-3].minor.yy812, TSDB_ALTER_TABLE_DROP_TAG, &yymsp[0].minor.yy29); } +#line 6299 "sql.c" + yymsp[-3].minor.yy812 = yylhsminor.yy812; break; case 180: /* alter_table_clause ::= full_table_name MODIFY TAG column_name type_name */ #line 355 "sql.y" -{ yylhsminor.yy1000 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy1000, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &yymsp[-1].minor.yy305, yymsp[0].minor.yy56); } -#line 6259 "sql.c" - yymsp[-4].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = createAlterTableAddModifyCol(pCxt, yymsp[-4].minor.yy812, TSDB_ALTER_TABLE_UPDATE_TAG_BYTES, &yymsp[-1].minor.yy29, yymsp[0].minor.yy784); } +#line 6305 "sql.c" + yymsp[-4].minor.yy812 = yylhsminor.yy812; break; case 181: /* alter_table_clause ::= full_table_name RENAME TAG column_name column_name */ #line 357 "sql.y" -{ yylhsminor.yy1000 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy1000, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &yymsp[-1].minor.yy305, &yymsp[0].minor.yy305); } -#line 6265 "sql.c" - yymsp[-4].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = createAlterTableRenameCol(pCxt, yymsp[-4].minor.yy812, TSDB_ALTER_TABLE_UPDATE_TAG_NAME, &yymsp[-1].minor.yy29, &yymsp[0].minor.yy29); } +#line 6311 "sql.c" + yymsp[-4].minor.yy812 = yylhsminor.yy812; break; case 182: /* alter_table_clause ::= full_table_name SET TAG column_name NK_EQ tags_literal */ #line 359 "sql.y" -{ yylhsminor.yy1000 = createAlterTableSetTag(pCxt, yymsp[-5].minor.yy1000, &yymsp[-2].minor.yy305, yymsp[0].minor.yy1000); } -#line 6271 "sql.c" - yymsp[-5].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = createAlterTableSetTag(pCxt, yymsp[-5].minor.yy812, &yymsp[-2].minor.yy29, yymsp[0].minor.yy812); } +#line 6317 "sql.c" + yymsp[-5].minor.yy812 = yylhsminor.yy812; break; case 184: /* multi_create_clause ::= multi_create_clause create_subtable_clause */ - case 556: /* when_then_list ::= when_then_list when_then_expr */ yytestcase(yyruleno==556); + case 561: /* when_then_list ::= when_then_list when_then_expr */ yytestcase(yyruleno==561); #line 364 "sql.y" -{ yylhsminor.yy72 = addNodeToList(pCxt, yymsp[-1].minor.yy72, yymsp[0].minor.yy1000); } -#line 6278 "sql.c" - yymsp[-1].minor.yy72 = yylhsminor.yy72; +{ yylhsminor.yy124 = addNodeToList(pCxt, yymsp[-1].minor.yy124, yymsp[0].minor.yy812); } +#line 6324 "sql.c" + yymsp[-1].minor.yy124 = yylhsminor.yy124; break; case 185: /* create_subtable_clause ::= not_exists_opt full_table_name USING full_table_name specific_cols_opt TAGS NK_LP tags_literal_list NK_RP table_options */ #line 368 "sql.y" -{ yylhsminor.yy1000 = createCreateSubTableClause(pCxt, yymsp[-9].minor.yy985, yymsp[-8].minor.yy1000, yymsp[-6].minor.yy1000, yymsp[-5].minor.yy72, yymsp[-2].minor.yy72, yymsp[0].minor.yy1000); } -#line 6284 "sql.c" - yymsp[-9].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = createCreateSubTableClause(pCxt, yymsp[-9].minor.yy887, yymsp[-8].minor.yy812, yymsp[-6].minor.yy812, yymsp[-5].minor.yy124, yymsp[-2].minor.yy124, yymsp[0].minor.yy812); } +#line 6330 "sql.c" + yymsp[-9].minor.yy812 = yylhsminor.yy812; break; case 188: /* drop_table_clause ::= exists_opt full_table_name */ #line 375 "sql.y" -{ yylhsminor.yy1000 = createDropTableClause(pCxt, yymsp[-1].minor.yy985, yymsp[0].minor.yy1000); } -#line 6290 "sql.c" - yymsp[-1].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = createDropTableClause(pCxt, yymsp[-1].minor.yy887, yymsp[0].minor.yy812); } +#line 6336 "sql.c" + yymsp[-1].minor.yy812 = yylhsminor.yy812; break; case 190: /* specific_cols_opt ::= NK_LP col_name_list NK_RP */ - case 379: /* col_list_opt ::= NK_LP col_name_list NK_RP */ yytestcase(yyruleno==379); + case 383: /* col_list_opt ::= NK_LP col_name_list NK_RP */ yytestcase(yyruleno==383); #line 380 "sql.y" -{ yymsp[-2].minor.yy72 = yymsp[-1].minor.yy72; } -#line 6297 "sql.c" +{ yymsp[-2].minor.yy124 = yymsp[-1].minor.yy124; } +#line 6343 "sql.c" break; case 191: /* full_table_name ::= table_name */ #line 382 "sql.y" -{ yylhsminor.yy1000 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy305, NULL); } -#line 6302 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = createRealTableNode(pCxt, NULL, &yymsp[0].minor.yy29, NULL); } +#line 6348 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; break; case 192: /* full_table_name ::= db_name NK_DOT table_name */ #line 383 "sql.y" -{ yylhsminor.yy1000 = createRealTableNode(pCxt, &yymsp[-2].minor.yy305, &yymsp[0].minor.yy305, NULL); } -#line 6308 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = createRealTableNode(pCxt, &yymsp[-2].minor.yy29, &yymsp[0].minor.yy29, NULL); } +#line 6354 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 195: /* tag_def ::= column_name type_name */ #line 389 "sql.y" -{ yylhsminor.yy1000 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy305, yymsp[0].minor.yy56, NULL); } -#line 6314 "sql.c" - yymsp[-1].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = createColumnDefNode(pCxt, &yymsp[-1].minor.yy29, yymsp[0].minor.yy784, NULL); } +#line 6360 "sql.c" + yymsp[-1].minor.yy812 = yylhsminor.yy812; break; case 198: /* column_def ::= column_name type_name column_options */ #line 397 "sql.y" -{ yylhsminor.yy1000 = createColumnDefNode(pCxt, &yymsp[-2].minor.yy305, yymsp[-1].minor.yy56, yymsp[0].minor.yy1000); } -#line 6320 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = createColumnDefNode(pCxt, &yymsp[-2].minor.yy29, yymsp[-1].minor.yy784, yymsp[0].minor.yy812); } +#line 6366 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; case 199: /* type_name ::= BOOL */ #line 401 "sql.y" -{ yymsp[0].minor.yy56 = createDataType(TSDB_DATA_TYPE_BOOL); } -#line 6326 "sql.c" +{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_BOOL); } +#line 6372 "sql.c" break; case 200: /* type_name ::= TINYINT */ #line 402 "sql.y" -{ yymsp[0].minor.yy56 = createDataType(TSDB_DATA_TYPE_TINYINT); } -#line 6331 "sql.c" +{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_TINYINT); } +#line 6377 "sql.c" break; case 201: /* type_name ::= SMALLINT */ #line 403 "sql.y" -{ yymsp[0].minor.yy56 = createDataType(TSDB_DATA_TYPE_SMALLINT); } -#line 6336 "sql.c" +{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_SMALLINT); } +#line 6382 "sql.c" break; case 202: /* type_name ::= INT */ case 203: /* type_name ::= INTEGER */ yytestcase(yyruleno==203); #line 404 "sql.y" -{ yymsp[0].minor.yy56 = createDataType(TSDB_DATA_TYPE_INT); } -#line 6342 "sql.c" +{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_INT); } +#line 6388 "sql.c" break; case 204: /* type_name ::= BIGINT */ #line 406 "sql.y" -{ yymsp[0].minor.yy56 = createDataType(TSDB_DATA_TYPE_BIGINT); } -#line 6347 "sql.c" +{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_BIGINT); } +#line 6393 "sql.c" break; case 205: /* type_name ::= FLOAT */ #line 407 "sql.y" -{ yymsp[0].minor.yy56 = createDataType(TSDB_DATA_TYPE_FLOAT); } -#line 6352 "sql.c" +{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_FLOAT); } +#line 6398 "sql.c" break; case 206: /* type_name ::= DOUBLE */ #line 408 "sql.y" -{ yymsp[0].minor.yy56 = createDataType(TSDB_DATA_TYPE_DOUBLE); } -#line 6357 "sql.c" +{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_DOUBLE); } +#line 6403 "sql.c" break; case 207: /* type_name ::= BINARY NK_LP NK_INTEGER NK_RP */ #line 409 "sql.y" -{ yymsp[-3].minor.yy56 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy0); } -#line 6362 "sql.c" +{ yymsp[-3].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, &yymsp[-1].minor.yy0); } +#line 6408 "sql.c" break; case 208: /* type_name ::= TIMESTAMP */ #line 410 "sql.y" -{ yymsp[0].minor.yy56 = createDataType(TSDB_DATA_TYPE_TIMESTAMP); } -#line 6367 "sql.c" +{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_TIMESTAMP); } +#line 6413 "sql.c" break; case 209: /* type_name ::= NCHAR NK_LP NK_INTEGER NK_RP */ #line 411 "sql.y" -{ yymsp[-3].minor.yy56 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, &yymsp[-1].minor.yy0); } -#line 6372 "sql.c" +{ yymsp[-3].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, &yymsp[-1].minor.yy0); } +#line 6418 "sql.c" break; case 210: /* type_name ::= TINYINT UNSIGNED */ #line 412 "sql.y" -{ yymsp[-1].minor.yy56 = createDataType(TSDB_DATA_TYPE_UTINYINT); } -#line 6377 "sql.c" +{ yymsp[-1].minor.yy784 = createDataType(TSDB_DATA_TYPE_UTINYINT); } +#line 6423 "sql.c" break; case 211: /* type_name ::= SMALLINT UNSIGNED */ #line 413 "sql.y" -{ yymsp[-1].minor.yy56 = createDataType(TSDB_DATA_TYPE_USMALLINT); } -#line 6382 "sql.c" +{ yymsp[-1].minor.yy784 = createDataType(TSDB_DATA_TYPE_USMALLINT); } +#line 6428 "sql.c" break; case 212: /* type_name ::= INT UNSIGNED */ #line 414 "sql.y" -{ yymsp[-1].minor.yy56 = createDataType(TSDB_DATA_TYPE_UINT); } -#line 6387 "sql.c" +{ yymsp[-1].minor.yy784 = createDataType(TSDB_DATA_TYPE_UINT); } +#line 6433 "sql.c" break; case 213: /* type_name ::= BIGINT UNSIGNED */ #line 415 "sql.y" -{ yymsp[-1].minor.yy56 = createDataType(TSDB_DATA_TYPE_UBIGINT); } -#line 6392 "sql.c" +{ yymsp[-1].minor.yy784 = createDataType(TSDB_DATA_TYPE_UBIGINT); } +#line 6438 "sql.c" break; case 214: /* type_name ::= JSON */ #line 416 "sql.y" -{ yymsp[0].minor.yy56 = createDataType(TSDB_DATA_TYPE_JSON); } -#line 6397 "sql.c" +{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_JSON); } +#line 6443 "sql.c" break; case 215: /* type_name ::= VARCHAR NK_LP NK_INTEGER NK_RP */ #line 417 "sql.y" -{ yymsp[-3].minor.yy56 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, &yymsp[-1].minor.yy0); } -#line 6402 "sql.c" +{ yymsp[-3].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, &yymsp[-1].minor.yy0); } +#line 6448 "sql.c" break; case 216: /* type_name ::= MEDIUMBLOB */ #line 418 "sql.y" -{ yymsp[0].minor.yy56 = createDataType(TSDB_DATA_TYPE_MEDIUMBLOB); } -#line 6407 "sql.c" +{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_MEDIUMBLOB); } +#line 6453 "sql.c" break; case 217: /* type_name ::= BLOB */ #line 419 "sql.y" -{ yymsp[0].minor.yy56 = createDataType(TSDB_DATA_TYPE_BLOB); } -#line 6412 "sql.c" +{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_BLOB); } +#line 6458 "sql.c" break; case 218: /* type_name ::= VARBINARY NK_LP NK_INTEGER NK_RP */ #line 420 "sql.y" -{ yymsp[-3].minor.yy56 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, &yymsp[-1].minor.yy0); } -#line 6417 "sql.c" +{ yymsp[-3].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, &yymsp[-1].minor.yy0); } +#line 6463 "sql.c" break; case 219: /* type_name ::= GEOMETRY NK_LP NK_INTEGER NK_RP */ #line 421 "sql.y" -{ yymsp[-3].minor.yy56 = createVarLenDataType(TSDB_DATA_TYPE_GEOMETRY, &yymsp[-1].minor.yy0); } -#line 6422 "sql.c" +{ yymsp[-3].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_GEOMETRY, &yymsp[-1].minor.yy0); } +#line 6468 "sql.c" break; case 220: /* type_name ::= DECIMAL */ #line 422 "sql.y" -{ yymsp[0].minor.yy56 = createDataType(TSDB_DATA_TYPE_DECIMAL); } -#line 6427 "sql.c" +{ yymsp[0].minor.yy784 = createDataType(TSDB_DATA_TYPE_DECIMAL); } +#line 6473 "sql.c" break; case 221: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_RP */ #line 423 "sql.y" -{ yymsp[-3].minor.yy56 = createDataType(TSDB_DATA_TYPE_DECIMAL); } -#line 6432 "sql.c" +{ yymsp[-3].minor.yy784 = createDataType(TSDB_DATA_TYPE_DECIMAL); } +#line 6478 "sql.c" break; case 222: /* type_name ::= DECIMAL NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ #line 424 "sql.y" -{ yymsp[-5].minor.yy56 = createDataType(TSDB_DATA_TYPE_DECIMAL); } -#line 6437 "sql.c" - break; - case 225: /* tags_def ::= TAGS NK_LP tag_def_list NK_RP */ - case 382: /* tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP */ yytestcase(yyruleno==382); -#line 433 "sql.y" -{ yymsp[-3].minor.yy72 = yymsp[-1].minor.yy72; } -#line 6443 "sql.c" - break; - case 226: /* table_options ::= */ -#line 435 "sql.y" -{ yymsp[1].minor.yy1000 = createDefaultTableOptions(pCxt); } -#line 6448 "sql.c" - break; - case 227: /* table_options ::= table_options COMMENT NK_STRING */ -#line 436 "sql.y" -{ yylhsminor.yy1000 = setTableOption(pCxt, yymsp[-2].minor.yy1000, TABLE_OPTION_COMMENT, &yymsp[0].minor.yy0); } -#line 6453 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; - break; - case 228: /* table_options ::= table_options MAX_DELAY duration_list */ -#line 437 "sql.y" -{ yylhsminor.yy1000 = setTableOption(pCxt, yymsp[-2].minor.yy1000, TABLE_OPTION_MAXDELAY, yymsp[0].minor.yy72); } -#line 6459 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; - break; - case 229: /* table_options ::= table_options WATERMARK duration_list */ -#line 438 "sql.y" -{ yylhsminor.yy1000 = setTableOption(pCxt, yymsp[-2].minor.yy1000, TABLE_OPTION_WATERMARK, yymsp[0].minor.yy72); } -#line 6465 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; - break; - case 230: /* table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ -#line 439 "sql.y" -{ yylhsminor.yy1000 = setTableOption(pCxt, yymsp[-4].minor.yy1000, TABLE_OPTION_ROLLUP, yymsp[-1].minor.yy72); } -#line 6471 "sql.c" - yymsp[-4].minor.yy1000 = yylhsminor.yy1000; - break; - case 231: /* table_options ::= table_options TTL NK_INTEGER */ -#line 440 "sql.y" -{ yylhsminor.yy1000 = setTableOption(pCxt, yymsp[-2].minor.yy1000, TABLE_OPTION_TTL, &yymsp[0].minor.yy0); } -#line 6477 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; - break; - case 232: /* table_options ::= table_options SMA NK_LP col_name_list NK_RP */ -#line 441 "sql.y" -{ yylhsminor.yy1000 = setTableOption(pCxt, yymsp[-4].minor.yy1000, TABLE_OPTION_SMA, yymsp[-1].minor.yy72); } +{ yymsp[-5].minor.yy784 = createDataType(TSDB_DATA_TYPE_DECIMAL); } #line 6483 "sql.c" - yymsp[-4].minor.yy1000 = yylhsminor.yy1000; break; - case 233: /* table_options ::= table_options DELETE_MARK duration_list */ + case 223: /* type_name_default_len ::= BINARY */ +#line 428 "sql.y" +{ yymsp[0].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_BINARY, NULL); } +#line 6488 "sql.c" + break; + case 224: /* type_name_default_len ::= NCHAR */ +#line 429 "sql.y" +{ yymsp[0].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_NCHAR, NULL); } +#line 6493 "sql.c" + break; + case 225: /* type_name_default_len ::= VARCHAR */ +#line 430 "sql.y" +{ yymsp[0].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_VARCHAR, NULL); } +#line 6498 "sql.c" + break; + case 226: /* type_name_default_len ::= VARBINARY */ +#line 431 "sql.y" +{ yymsp[0].minor.yy784 = createVarLenDataType(TSDB_DATA_TYPE_VARBINARY, NULL); } +#line 6503 "sql.c" + break; + case 229: /* tags_def ::= TAGS NK_LP tag_def_list NK_RP */ + case 386: /* tag_def_or_ref_opt ::= TAGS NK_LP col_name_list NK_RP */ yytestcase(yyruleno==386); +#line 440 "sql.y" +{ yymsp[-3].minor.yy124 = yymsp[-1].minor.yy124; } +#line 6509 "sql.c" + break; + case 230: /* table_options ::= */ #line 442 "sql.y" -{ yylhsminor.yy1000 = setTableOption(pCxt, yymsp[-2].minor.yy1000, TABLE_OPTION_DELETE_MARK, yymsp[0].minor.yy72); } -#line 6489 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yymsp[1].minor.yy812 = createDefaultTableOptions(pCxt); } +#line 6514 "sql.c" break; - case 234: /* alter_table_options ::= alter_table_option */ + case 231: /* table_options ::= table_options COMMENT NK_STRING */ +#line 443 "sql.y" +{ yylhsminor.yy812 = setTableOption(pCxt, yymsp[-2].minor.yy812, TABLE_OPTION_COMMENT, &yymsp[0].minor.yy0); } +#line 6519 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; + break; + case 232: /* table_options ::= table_options MAX_DELAY duration_list */ #line 444 "sql.y" -{ yylhsminor.yy1000 = createAlterTableOptions(pCxt); yylhsminor.yy1000 = setTableOption(pCxt, yylhsminor.yy1000, yymsp[0].minor.yy941.type, &yymsp[0].minor.yy941.val); } -#line 6495 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; - break; - case 235: /* alter_table_options ::= alter_table_options alter_table_option */ -#line 445 "sql.y" -{ yylhsminor.yy1000 = setTableOption(pCxt, yymsp[-1].minor.yy1000, yymsp[0].minor.yy941.type, &yymsp[0].minor.yy941.val); } -#line 6501 "sql.c" - yymsp[-1].minor.yy1000 = yylhsminor.yy1000; - break; - case 236: /* alter_table_option ::= COMMENT NK_STRING */ -#line 449 "sql.y" -{ yymsp[-1].minor.yy941.type = TABLE_OPTION_COMMENT; yymsp[-1].minor.yy941.val = yymsp[0].minor.yy0; } -#line 6507 "sql.c" - break; - case 237: /* alter_table_option ::= TTL NK_INTEGER */ -#line 450 "sql.y" -{ yymsp[-1].minor.yy941.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy941.val = yymsp[0].minor.yy0; } -#line 6512 "sql.c" - break; - case 238: /* duration_list ::= duration_literal */ - case 509: /* expression_list ::= expr_or_subquery */ yytestcase(yyruleno==509); -#line 454 "sql.y" -{ yylhsminor.yy72 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy1000)); } -#line 6518 "sql.c" - yymsp[0].minor.yy72 = yylhsminor.yy72; - break; - case 239: /* duration_list ::= duration_list NK_COMMA duration_literal */ - case 510: /* expression_list ::= expression_list NK_COMMA expr_or_subquery */ yytestcase(yyruleno==510); -#line 455 "sql.y" -{ yylhsminor.yy72 = addNodeToList(pCxt, yymsp[-2].minor.yy72, releaseRawExprNode(pCxt, yymsp[0].minor.yy1000)); } +{ yylhsminor.yy812 = setTableOption(pCxt, yymsp[-2].minor.yy812, TABLE_OPTION_MAXDELAY, yymsp[0].minor.yy124); } #line 6525 "sql.c" - yymsp[-2].minor.yy72 = yylhsminor.yy72; + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 242: /* rollup_func_name ::= function_name */ -#line 462 "sql.y" -{ yylhsminor.yy1000 = createFunctionNode(pCxt, &yymsp[0].minor.yy305, NULL); } + case 233: /* table_options ::= table_options WATERMARK duration_list */ +#line 445 "sql.y" +{ yylhsminor.yy812 = setTableOption(pCxt, yymsp[-2].minor.yy812, TABLE_OPTION_WATERMARK, yymsp[0].minor.yy124); } #line 6531 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 243: /* rollup_func_name ::= FIRST */ - case 244: /* rollup_func_name ::= LAST */ yytestcase(yyruleno==244); - case 316: /* tag_item ::= QTAGS */ yytestcase(yyruleno==316); -#line 463 "sql.y" -{ yylhsminor.yy1000 = createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL); } -#line 6539 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; + case 234: /* table_options ::= table_options ROLLUP NK_LP rollup_func_list NK_RP */ +#line 446 "sql.y" +{ yylhsminor.yy812 = setTableOption(pCxt, yymsp[-4].minor.yy812, TABLE_OPTION_ROLLUP, yymsp[-1].minor.yy124); } +#line 6537 "sql.c" + yymsp[-4].minor.yy812 = yylhsminor.yy812; break; - case 247: /* col_name ::= column_name */ - case 317: /* tag_item ::= column_name */ yytestcase(yyruleno==317); -#line 471 "sql.y" -{ yylhsminor.yy1000 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy305); } -#line 6546 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; + case 235: /* table_options ::= table_options TTL NK_INTEGER */ +#line 447 "sql.y" +{ yylhsminor.yy812 = setTableOption(pCxt, yymsp[-2].minor.yy812, TABLE_OPTION_TTL, &yymsp[0].minor.yy0); } +#line 6543 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 248: /* cmd ::= SHOW DNODES */ -#line 474 "sql.y" + case 236: /* table_options ::= table_options SMA NK_LP col_name_list NK_RP */ +#line 448 "sql.y" +{ yylhsminor.yy812 = setTableOption(pCxt, yymsp[-4].minor.yy812, TABLE_OPTION_SMA, yymsp[-1].minor.yy124); } +#line 6549 "sql.c" + yymsp[-4].minor.yy812 = yylhsminor.yy812; + break; + case 237: /* table_options ::= table_options DELETE_MARK duration_list */ +#line 449 "sql.y" +{ yylhsminor.yy812 = setTableOption(pCxt, yymsp[-2].minor.yy812, TABLE_OPTION_DELETE_MARK, yymsp[0].minor.yy124); } +#line 6555 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; + break; + case 238: /* alter_table_options ::= alter_table_option */ +#line 451 "sql.y" +{ yylhsminor.yy812 = createAlterTableOptions(pCxt); yylhsminor.yy812 = setTableOption(pCxt, yylhsminor.yy812, yymsp[0].minor.yy95.type, &yymsp[0].minor.yy95.val); } +#line 6561 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; + break; + case 239: /* alter_table_options ::= alter_table_options alter_table_option */ +#line 452 "sql.y" +{ yylhsminor.yy812 = setTableOption(pCxt, yymsp[-1].minor.yy812, yymsp[0].minor.yy95.type, &yymsp[0].minor.yy95.val); } +#line 6567 "sql.c" + yymsp[-1].minor.yy812 = yylhsminor.yy812; + break; + case 240: /* alter_table_option ::= COMMENT NK_STRING */ +#line 456 "sql.y" +{ yymsp[-1].minor.yy95.type = TABLE_OPTION_COMMENT; yymsp[-1].minor.yy95.val = yymsp[0].minor.yy0; } +#line 6573 "sql.c" + break; + case 241: /* alter_table_option ::= TTL NK_INTEGER */ +#line 457 "sql.y" +{ yymsp[-1].minor.yy95.type = TABLE_OPTION_TTL; yymsp[-1].minor.yy95.val = yymsp[0].minor.yy0; } +#line 6578 "sql.c" + break; + case 242: /* duration_list ::= duration_literal */ + case 513: /* expression_list ::= expr_or_subquery */ yytestcase(yyruleno==513); +#line 461 "sql.y" +{ yylhsminor.yy124 = createNodeList(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy812)); } +#line 6584 "sql.c" + yymsp[0].minor.yy124 = yylhsminor.yy124; + break; + case 243: /* duration_list ::= duration_list NK_COMMA duration_literal */ + case 514: /* expression_list ::= expression_list NK_COMMA expr_or_subquery */ yytestcase(yyruleno==514); +#line 462 "sql.y" +{ yylhsminor.yy124 = addNodeToList(pCxt, yymsp[-2].minor.yy124, releaseRawExprNode(pCxt, yymsp[0].minor.yy812)); } +#line 6591 "sql.c" + yymsp[-2].minor.yy124 = yylhsminor.yy124; + break; + case 246: /* rollup_func_name ::= function_name */ +#line 469 "sql.y" +{ yylhsminor.yy812 = createFunctionNode(pCxt, &yymsp[0].minor.yy29, NULL); } +#line 6597 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; + break; + case 247: /* rollup_func_name ::= FIRST */ + case 248: /* rollup_func_name ::= LAST */ yytestcase(yyruleno==248); + case 320: /* tag_item ::= QTAGS */ yytestcase(yyruleno==320); +#line 470 "sql.y" +{ yylhsminor.yy812 = createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL); } +#line 6605 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; + break; + case 251: /* col_name ::= column_name */ + case 321: /* tag_item ::= column_name */ yytestcase(yyruleno==321); +#line 478 "sql.y" +{ yylhsminor.yy812 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy29); } +#line 6612 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; + break; + case 252: /* cmd ::= SHOW DNODES */ +#line 481 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DNODES_STMT); } -#line 6552 "sql.c" +#line 6618 "sql.c" break; - case 249: /* cmd ::= SHOW USERS */ -#line 475 "sql.y" + case 253: /* cmd ::= SHOW USERS */ +#line 482 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_USERS_STMT); } -#line 6557 "sql.c" +#line 6623 "sql.c" break; - case 250: /* cmd ::= SHOW USER PRIVILEGES */ -#line 476 "sql.y" + case 254: /* cmd ::= SHOW USER PRIVILEGES */ +#line 483 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_USER_PRIVILEGES_STMT); } -#line 6562 "sql.c" +#line 6628 "sql.c" break; - case 251: /* cmd ::= SHOW db_kind_opt DATABASES */ -#line 477 "sql.y" + case 255: /* cmd ::= SHOW db_kind_opt DATABASES */ +#line 484 "sql.y" { pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_DATABASES_STMT); - setShowKind(pCxt, pCxt->pRootNode, yymsp[-1].minor.yy761); + setShowKind(pCxt, pCxt->pRootNode, yymsp[-1].minor.yy789); } -#line 6570 "sql.c" +#line 6636 "sql.c" break; - case 252: /* cmd ::= SHOW table_kind_db_name_cond_opt TABLES like_pattern_opt */ -#line 481 "sql.y" -{ - pCxt->pRootNode = createShowTablesStmt(pCxt, yymsp[-2].minor.yy517, yymsp[0].minor.yy1000, OP_TYPE_LIKE); - } -#line 6577 "sql.c" - break; - case 253: /* cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ -#line 484 "sql.y" -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_STABLES_STMT, yymsp[-2].minor.yy1000, yymsp[0].minor.yy1000, OP_TYPE_LIKE); } -#line 6582 "sql.c" - break; - case 254: /* cmd ::= SHOW db_name_cond_opt VGROUPS */ -#line 485 "sql.y" -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, yymsp[-1].minor.yy1000, NULL, OP_TYPE_LIKE); } -#line 6587 "sql.c" - break; - case 255: /* cmd ::= SHOW MNODES */ -#line 486 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_MNODES_STMT); } -#line 6592 "sql.c" - break; - case 256: /* cmd ::= SHOW QNODES */ + case 256: /* cmd ::= SHOW table_kind_db_name_cond_opt TABLES like_pattern_opt */ #line 488 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QNODES_STMT); } -#line 6597 "sql.c" - break; - case 257: /* cmd ::= SHOW ARBGROUPS */ -#line 489 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_ARBGROUPS_STMT); } -#line 6602 "sql.c" - break; - case 258: /* cmd ::= SHOW FUNCTIONS */ -#line 490 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_FUNCTIONS_STMT); } -#line 6607 "sql.c" - break; - case 259: /* cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ -#line 491 "sql.y" -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, yymsp[0].minor.yy1000, yymsp[-1].minor.yy1000, OP_TYPE_EQUAL); } -#line 6612 "sql.c" - break; - case 260: /* cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */ -#line 492 "sql.y" -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy305), createIdentifierValueNode(pCxt, &yymsp[0].minor.yy305), OP_TYPE_EQUAL); } -#line 6617 "sql.c" - break; - case 261: /* cmd ::= SHOW STREAMS */ -#line 493 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_STREAMS_STMT); } -#line 6622 "sql.c" - break; - case 262: /* cmd ::= SHOW ACCOUNTS */ -#line 494 "sql.y" -{ pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); } -#line 6627 "sql.c" - break; - case 263: /* cmd ::= SHOW APPS */ -#line 495 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_APPS_STMT); } -#line 6632 "sql.c" - break; - case 264: /* cmd ::= SHOW CONNECTIONS */ -#line 496 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CONNECTIONS_STMT); } -#line 6637 "sql.c" - break; - case 265: /* cmd ::= SHOW LICENCES */ - case 266: /* cmd ::= SHOW GRANTS */ yytestcase(yyruleno==266); -#line 497 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_LICENCES_STMT); } +{ + pCxt->pRootNode = createShowTablesStmt(pCxt, yymsp[-2].minor.yy667, yymsp[0].minor.yy812, OP_TYPE_LIKE); + } #line 6643 "sql.c" break; - case 267: /* cmd ::= SHOW GRANTS FULL */ -#line 499 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_GRANTS_FULL_STMT); } + case 257: /* cmd ::= SHOW db_name_cond_opt STABLES like_pattern_opt */ +#line 491 "sql.y" +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_STABLES_STMT, yymsp[-2].minor.yy812, yymsp[0].minor.yy812, OP_TYPE_LIKE); } #line 6648 "sql.c" break; - case 268: /* cmd ::= SHOW GRANTS LOGS */ -#line 500 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_GRANTS_LOGS_STMT); } + case 258: /* cmd ::= SHOW db_name_cond_opt VGROUPS */ +#line 492 "sql.y" +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VGROUPS_STMT, yymsp[-1].minor.yy812, NULL, OP_TYPE_LIKE); } #line 6653 "sql.c" break; - case 269: /* cmd ::= SHOW CLUSTER MACHINES */ -#line 501 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CLUSTER_MACHINES_STMT); } + case 259: /* cmd ::= SHOW MNODES */ +#line 493 "sql.y" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_MNODES_STMT); } #line 6658 "sql.c" break; - case 270: /* cmd ::= SHOW CREATE DATABASE db_name */ -#line 502 "sql.y" -{ pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &yymsp[0].minor.yy305); } + case 260: /* cmd ::= SHOW QNODES */ +#line 495 "sql.y" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QNODES_STMT); } #line 6663 "sql.c" break; - case 271: /* cmd ::= SHOW CREATE TABLE full_table_name */ -#line 503 "sql.y" -{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, yymsp[0].minor.yy1000); } + case 261: /* cmd ::= SHOW ARBGROUPS */ +#line 496 "sql.y" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_ARBGROUPS_STMT); } #line 6668 "sql.c" break; - case 272: /* cmd ::= SHOW CREATE STABLE full_table_name */ -#line 504 "sql.y" -{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, yymsp[0].minor.yy1000); } + case 262: /* cmd ::= SHOW FUNCTIONS */ +#line 497 "sql.y" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_FUNCTIONS_STMT); } #line 6673 "sql.c" break; - case 273: /* cmd ::= SHOW QUERIES */ -#line 505 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QUERIES_STMT); } + case 263: /* cmd ::= SHOW INDEXES FROM table_name_cond from_db_opt */ +#line 498 "sql.y" +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, yymsp[0].minor.yy812, yymsp[-1].minor.yy812, OP_TYPE_EQUAL); } #line 6678 "sql.c" break; - case 274: /* cmd ::= SHOW SCORES */ -#line 506 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SCORES_STMT); } + case 264: /* cmd ::= SHOW INDEXES FROM db_name NK_DOT table_name */ +#line 499 "sql.y" +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_INDEXES_STMT, createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy29), createIdentifierValueNode(pCxt, &yymsp[0].minor.yy29), OP_TYPE_EQUAL); } #line 6683 "sql.c" break; - case 275: /* cmd ::= SHOW TOPICS */ -#line 507 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TOPICS_STMT); } + case 265: /* cmd ::= SHOW STREAMS */ +#line 500 "sql.y" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_STREAMS_STMT); } #line 6688 "sql.c" break; - case 276: /* cmd ::= SHOW VARIABLES */ - case 277: /* cmd ::= SHOW CLUSTER VARIABLES */ yytestcase(yyruleno==277); -#line 508 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_VARIABLES_STMT); } -#line 6694 "sql.c" + case 266: /* cmd ::= SHOW ACCOUNTS */ +#line 501 "sql.y" +{ pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_EXPRIE_STATEMENT); } +#line 6693 "sql.c" break; - case 278: /* cmd ::= SHOW LOCAL VARIABLES */ -#line 510 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT); } -#line 6699 "sql.c" + case 267: /* cmd ::= SHOW APPS */ +#line 502 "sql.y" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_APPS_STMT); } +#line 6698 "sql.c" break; - case 279: /* cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */ -#line 511 "sql.y" -{ pCxt->pRootNode = createShowDnodeVariablesStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[-2].minor.yy0), yymsp[0].minor.yy1000); } -#line 6704 "sql.c" + case 268: /* cmd ::= SHOW CONNECTIONS */ +#line 503 "sql.y" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CONNECTIONS_STMT); } +#line 6703 "sql.c" break; - case 280: /* cmd ::= SHOW BNODES */ -#line 512 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_BNODES_STMT); } + case 269: /* cmd ::= SHOW LICENCES */ + case 270: /* cmd ::= SHOW GRANTS */ yytestcase(yyruleno==270); +#line 504 "sql.y" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_LICENCES_STMT); } #line 6709 "sql.c" break; - case 281: /* cmd ::= SHOW SNODES */ -#line 513 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SNODES_STMT); } + case 271: /* cmd ::= SHOW GRANTS FULL */ +#line 506 "sql.y" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_GRANTS_FULL_STMT); } #line 6714 "sql.c" break; - case 282: /* cmd ::= SHOW CLUSTER */ -#line 514 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CLUSTER_STMT); } + case 272: /* cmd ::= SHOW GRANTS LOGS */ +#line 507 "sql.y" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_GRANTS_LOGS_STMT); } #line 6719 "sql.c" break; - case 283: /* cmd ::= SHOW TRANSACTIONS */ -#line 515 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TRANSACTIONS_STMT); } + case 273: /* cmd ::= SHOW CLUSTER MACHINES */ +#line 508 "sql.y" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CLUSTER_MACHINES_STMT); } #line 6724 "sql.c" break; - case 284: /* cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ -#line 516 "sql.y" -{ pCxt->pRootNode = createShowTableDistributedStmt(pCxt, yymsp[0].minor.yy1000); } + case 274: /* cmd ::= SHOW CREATE DATABASE db_name */ +#line 509 "sql.y" +{ pCxt->pRootNode = createShowCreateDatabaseStmt(pCxt, &yymsp[0].minor.yy29); } #line 6729 "sql.c" break; - case 285: /* cmd ::= SHOW CONSUMERS */ -#line 517 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CONSUMERS_STMT); } + case 275: /* cmd ::= SHOW CREATE TABLE full_table_name */ +#line 510 "sql.y" +{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_TABLE_STMT, yymsp[0].minor.yy812); } #line 6734 "sql.c" break; - case 286: /* cmd ::= SHOW SUBSCRIPTIONS */ -#line 518 "sql.y" -{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT); } + case 276: /* cmd ::= SHOW CREATE STABLE full_table_name */ +#line 511 "sql.y" +{ pCxt->pRootNode = createShowCreateTableStmt(pCxt, QUERY_NODE_SHOW_CREATE_STABLE_STMT, yymsp[0].minor.yy812); } #line 6739 "sql.c" break; - case 287: /* cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ -#line 519 "sql.y" -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, yymsp[0].minor.yy1000, yymsp[-1].minor.yy1000, OP_TYPE_EQUAL); } + case 277: /* cmd ::= SHOW QUERIES */ +#line 512 "sql.y" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_QUERIES_STMT); } #line 6744 "sql.c" break; - case 288: /* cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */ -#line 520 "sql.y" -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy305), createIdentifierValueNode(pCxt, &yymsp[0].minor.yy305), OP_TYPE_EQUAL); } + case 278: /* cmd ::= SHOW SCORES */ +#line 513 "sql.y" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SCORES_STMT); } #line 6749 "sql.c" break; - case 289: /* cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */ -#line 521 "sql.y" -{ pCxt->pRootNode = createShowTableTagsStmt(pCxt, yymsp[-1].minor.yy1000, yymsp[0].minor.yy1000, yymsp[-3].minor.yy72); } + case 279: /* cmd ::= SHOW TOPICS */ +#line 514 "sql.y" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TOPICS_STMT); } #line 6754 "sql.c" break; - case 290: /* cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */ + case 280: /* cmd ::= SHOW VARIABLES */ + case 281: /* cmd ::= SHOW CLUSTER VARIABLES */ yytestcase(yyruleno==281); +#line 515 "sql.y" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_VARIABLES_STMT); } +#line 6760 "sql.c" + break; + case 282: /* cmd ::= SHOW LOCAL VARIABLES */ +#line 517 "sql.y" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_LOCAL_VARIABLES_STMT); } +#line 6765 "sql.c" + break; + case 283: /* cmd ::= SHOW DNODE NK_INTEGER VARIABLES like_pattern_opt */ +#line 518 "sql.y" +{ pCxt->pRootNode = createShowDnodeVariablesStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[-2].minor.yy0), yymsp[0].minor.yy812); } +#line 6770 "sql.c" + break; + case 284: /* cmd ::= SHOW BNODES */ +#line 519 "sql.y" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_BNODES_STMT); } +#line 6775 "sql.c" + break; + case 285: /* cmd ::= SHOW SNODES */ +#line 520 "sql.y" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SNODES_STMT); } +#line 6780 "sql.c" + break; + case 286: /* cmd ::= SHOW CLUSTER */ +#line 521 "sql.y" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CLUSTER_STMT); } +#line 6785 "sql.c" + break; + case 287: /* cmd ::= SHOW TRANSACTIONS */ #line 522 "sql.y" -{ pCxt->pRootNode = createShowTableTagsStmt(pCxt, createIdentifierValueNode(pCxt, &yymsp[0].minor.yy305), createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy305), yymsp[-4].minor.yy72); } -#line 6759 "sql.c" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_TRANSACTIONS_STMT); } +#line 6790 "sql.c" break; - case 291: /* cmd ::= SHOW VNODES ON DNODE NK_INTEGER */ + case 288: /* cmd ::= SHOW TABLE DISTRIBUTED full_table_name */ #line 523 "sql.y" -{ pCxt->pRootNode = createShowVnodesStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0), NULL); } -#line 6764 "sql.c" +{ pCxt->pRootNode = createShowTableDistributedStmt(pCxt, yymsp[0].minor.yy812); } +#line 6795 "sql.c" break; - case 292: /* cmd ::= SHOW VNODES */ + case 289: /* cmd ::= SHOW CONSUMERS */ #line 524 "sql.y" -{ pCxt->pRootNode = createShowVnodesStmt(pCxt, NULL, NULL); } -#line 6769 "sql.c" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_CONSUMERS_STMT); } +#line 6800 "sql.c" break; - case 293: /* cmd ::= SHOW db_name_cond_opt ALIVE */ + case 290: /* cmd ::= SHOW SUBSCRIPTIONS */ +#line 525 "sql.y" +{ pCxt->pRootNode = createShowStmt(pCxt, QUERY_NODE_SHOW_SUBSCRIPTIONS_STMT); } +#line 6805 "sql.c" + break; + case 291: /* cmd ::= SHOW TAGS FROM table_name_cond from_db_opt */ #line 526 "sql.y" -{ pCxt->pRootNode = createShowAliveStmt(pCxt, yymsp[-1].minor.yy1000, QUERY_NODE_SHOW_DB_ALIVE_STMT); } -#line 6774 "sql.c" +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, yymsp[0].minor.yy812, yymsp[-1].minor.yy812, OP_TYPE_EQUAL); } +#line 6810 "sql.c" break; - case 294: /* cmd ::= SHOW CLUSTER ALIVE */ + case 292: /* cmd ::= SHOW TAGS FROM db_name NK_DOT table_name */ #line 527 "sql.y" -{ pCxt->pRootNode = createShowAliveStmt(pCxt, NULL, QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT); } -#line 6779 "sql.c" - break; - case 295: /* cmd ::= SHOW db_name_cond_opt VIEWS like_pattern_opt */ -#line 528 "sql.y" -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VIEWS_STMT, yymsp[-2].minor.yy1000, yymsp[0].minor.yy1000, OP_TYPE_LIKE); } -#line 6784 "sql.c" - break; - case 296: /* cmd ::= SHOW CREATE VIEW full_table_name */ -#line 529 "sql.y" -{ pCxt->pRootNode = createShowCreateViewStmt(pCxt, QUERY_NODE_SHOW_CREATE_VIEW_STMT, yymsp[0].minor.yy1000); } -#line 6789 "sql.c" - break; - case 297: /* cmd ::= SHOW COMPACTS */ -#line 530 "sql.y" -{ pCxt->pRootNode = createShowCompactsStmt(pCxt, QUERY_NODE_SHOW_COMPACTS_STMT); } -#line 6794 "sql.c" - break; - case 298: /* cmd ::= SHOW COMPACT NK_INTEGER */ -#line 531 "sql.y" -{ pCxt->pRootNode = createShowCompactDetailsStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } -#line 6799 "sql.c" - break; - case 299: /* table_kind_db_name_cond_opt ::= */ -#line 535 "sql.y" -{ yymsp[1].minor.yy517.kind = SHOW_KIND_ALL; yymsp[1].minor.yy517.dbName = nil_token; } -#line 6804 "sql.c" - break; - case 300: /* table_kind_db_name_cond_opt ::= table_kind */ -#line 536 "sql.y" -{ yylhsminor.yy517.kind = yymsp[0].minor.yy761; yylhsminor.yy517.dbName = nil_token; } -#line 6809 "sql.c" - yymsp[0].minor.yy517 = yylhsminor.yy517; - break; - case 301: /* table_kind_db_name_cond_opt ::= db_name NK_DOT */ -#line 537 "sql.y" -{ yylhsminor.yy517.kind = SHOW_KIND_ALL; yylhsminor.yy517.dbName = yymsp[-1].minor.yy305; } +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_TAGS_STMT, createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy29), createIdentifierValueNode(pCxt, &yymsp[0].minor.yy29), OP_TYPE_EQUAL); } #line 6815 "sql.c" - yymsp[-1].minor.yy517 = yylhsminor.yy517; break; - case 302: /* table_kind_db_name_cond_opt ::= table_kind db_name NK_DOT */ -#line 538 "sql.y" -{ yylhsminor.yy517.kind = yymsp[-2].minor.yy761; yylhsminor.yy517.dbName = yymsp[-1].minor.yy305; } -#line 6821 "sql.c" - yymsp[-2].minor.yy517 = yylhsminor.yy517; + case 293: /* cmd ::= SHOW TABLE TAGS tag_list_opt FROM table_name_cond from_db_opt */ +#line 528 "sql.y" +{ pCxt->pRootNode = createShowTableTagsStmt(pCxt, yymsp[-1].minor.yy812, yymsp[0].minor.yy812, yymsp[-3].minor.yy124); } +#line 6820 "sql.c" break; - case 303: /* table_kind ::= NORMAL */ -#line 542 "sql.y" -{ yymsp[0].minor.yy761 = SHOW_KIND_TABLES_NORMAL; } -#line 6827 "sql.c" + case 294: /* cmd ::= SHOW TABLE TAGS tag_list_opt FROM db_name NK_DOT table_name */ +#line 529 "sql.y" +{ pCxt->pRootNode = createShowTableTagsStmt(pCxt, createIdentifierValueNode(pCxt, &yymsp[0].minor.yy29), createIdentifierValueNode(pCxt, &yymsp[-2].minor.yy29), yymsp[-4].minor.yy124); } +#line 6825 "sql.c" break; - case 304: /* table_kind ::= CHILD */ -#line 543 "sql.y" -{ yymsp[0].minor.yy761 = SHOW_KIND_TABLES_CHILD; } -#line 6832 "sql.c" + case 295: /* cmd ::= SHOW VNODES ON DNODE NK_INTEGER */ +#line 530 "sql.y" +{ pCxt->pRootNode = createShowVnodesStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0), NULL); } +#line 6830 "sql.c" break; - case 305: /* db_name_cond_opt ::= */ - case 310: /* from_db_opt ::= */ yytestcase(yyruleno==310); -#line 545 "sql.y" -{ yymsp[1].minor.yy1000 = createDefaultDatabaseCondValue(pCxt); } -#line 6838 "sql.c" + case 296: /* cmd ::= SHOW VNODES */ +#line 531 "sql.y" +{ pCxt->pRootNode = createShowVnodesStmt(pCxt, NULL, NULL); } +#line 6835 "sql.c" break; - case 306: /* db_name_cond_opt ::= db_name NK_DOT */ -#line 546 "sql.y" -{ yylhsminor.yy1000 = createIdentifierValueNode(pCxt, &yymsp[-1].minor.yy305); } -#line 6843 "sql.c" - yymsp[-1].minor.yy1000 = yylhsminor.yy1000; + case 297: /* cmd ::= SHOW db_name_cond_opt ALIVE */ +#line 533 "sql.y" +{ pCxt->pRootNode = createShowAliveStmt(pCxt, yymsp[-1].minor.yy812, QUERY_NODE_SHOW_DB_ALIVE_STMT); } +#line 6840 "sql.c" break; - case 308: /* like_pattern_opt ::= LIKE NK_STRING */ -#line 549 "sql.y" -{ yymsp[-1].minor.yy1000 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } -#line 6849 "sql.c" + case 298: /* cmd ::= SHOW CLUSTER ALIVE */ +#line 534 "sql.y" +{ pCxt->pRootNode = createShowAliveStmt(pCxt, NULL, QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT); } +#line 6845 "sql.c" break; - case 309: /* table_name_cond ::= table_name */ -#line 551 "sql.y" -{ yylhsminor.yy1000 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy305); } -#line 6854 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; + case 299: /* cmd ::= SHOW db_name_cond_opt VIEWS like_pattern_opt */ +#line 535 "sql.y" +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VIEWS_STMT, yymsp[-2].minor.yy812, yymsp[0].minor.yy812, OP_TYPE_LIKE); } +#line 6850 "sql.c" break; - case 311: /* from_db_opt ::= FROM db_name */ -#line 554 "sql.y" -{ yymsp[-1].minor.yy1000 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy305); } + case 300: /* cmd ::= SHOW CREATE VIEW full_table_name */ +#line 536 "sql.y" +{ pCxt->pRootNode = createShowCreateViewStmt(pCxt, QUERY_NODE_SHOW_CREATE_VIEW_STMT, yymsp[0].minor.yy812); } +#line 6855 "sql.c" + break; + case 301: /* cmd ::= SHOW COMPACTS */ +#line 537 "sql.y" +{ pCxt->pRootNode = createShowCompactsStmt(pCxt, QUERY_NODE_SHOW_COMPACTS_STMT); } #line 6860 "sql.c" break; - case 315: /* tag_item ::= TBNAME */ -#line 562 "sql.y" -{ yylhsminor.yy1000 = setProjectionAlias(pCxt, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL), &yymsp[0].minor.yy0); } + case 302: /* cmd ::= SHOW COMPACT NK_INTEGER */ +#line 538 "sql.y" +{ pCxt->pRootNode = createShowCompactDetailsStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } #line 6865 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; break; - case 318: /* tag_item ::= column_name column_alias */ -#line 565 "sql.y" -{ yylhsminor.yy1000 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-1].minor.yy305), &yymsp[0].minor.yy305); } -#line 6871 "sql.c" - yymsp[-1].minor.yy1000 = yylhsminor.yy1000; + case 303: /* table_kind_db_name_cond_opt ::= */ +#line 542 "sql.y" +{ yymsp[1].minor.yy667.kind = SHOW_KIND_ALL; yymsp[1].minor.yy667.dbName = nil_token; } +#line 6870 "sql.c" break; - case 319: /* tag_item ::= column_name AS column_alias */ -#line 566 "sql.y" -{ yylhsminor.yy1000 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-2].minor.yy305), &yymsp[0].minor.yy305); } -#line 6877 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; + case 304: /* table_kind_db_name_cond_opt ::= table_kind */ +#line 543 "sql.y" +{ yylhsminor.yy667.kind = yymsp[0].minor.yy789; yylhsminor.yy667.dbName = nil_token; } +#line 6875 "sql.c" + yymsp[0].minor.yy667 = yylhsminor.yy667; break; - case 320: /* db_kind_opt ::= */ -#line 570 "sql.y" -{ yymsp[1].minor.yy761 = SHOW_KIND_ALL; } -#line 6883 "sql.c" + case 305: /* table_kind_db_name_cond_opt ::= db_name NK_DOT */ +#line 544 "sql.y" +{ yylhsminor.yy667.kind = SHOW_KIND_ALL; yylhsminor.yy667.dbName = yymsp[-1].minor.yy29; } +#line 6881 "sql.c" + yymsp[-1].minor.yy667 = yylhsminor.yy667; break; - case 321: /* db_kind_opt ::= USER */ -#line 571 "sql.y" -{ yymsp[0].minor.yy761 = SHOW_KIND_DATABASES_USER; } -#line 6888 "sql.c" + case 306: /* table_kind_db_name_cond_opt ::= table_kind db_name NK_DOT */ +#line 545 "sql.y" +{ yylhsminor.yy667.kind = yymsp[-2].minor.yy789; yylhsminor.yy667.dbName = yymsp[-1].minor.yy29; } +#line 6887 "sql.c" + yymsp[-2].minor.yy667 = yylhsminor.yy667; break; - case 322: /* db_kind_opt ::= SYSTEM */ -#line 572 "sql.y" -{ yymsp[0].minor.yy761 = SHOW_KIND_DATABASES_SYSTEM; } + case 307: /* table_kind ::= NORMAL */ +#line 549 "sql.y" +{ yymsp[0].minor.yy789 = SHOW_KIND_TABLES_NORMAL; } #line 6893 "sql.c" break; - case 323: /* cmd ::= CREATE SMA INDEX not_exists_opt col_name ON full_table_name index_options */ -#line 576 "sql.y" -{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_SMA, yymsp[-4].minor.yy985, yymsp[-3].minor.yy1000, yymsp[-1].minor.yy1000, NULL, yymsp[0].minor.yy1000); } + case 308: /* table_kind ::= CHILD */ +#line 550 "sql.y" +{ yymsp[0].minor.yy789 = SHOW_KIND_TABLES_CHILD; } #line 6898 "sql.c" break; - case 324: /* cmd ::= CREATE INDEX not_exists_opt col_name ON full_table_name NK_LP col_name_list NK_RP */ -#line 578 "sql.y" -{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_NORMAL, yymsp[-6].minor.yy985, yymsp[-5].minor.yy1000, yymsp[-3].minor.yy1000, yymsp[-1].minor.yy72, NULL); } -#line 6903 "sql.c" + case 309: /* db_name_cond_opt ::= */ + case 314: /* from_db_opt ::= */ yytestcase(yyruleno==314); +#line 552 "sql.y" +{ yymsp[1].minor.yy812 = createDefaultDatabaseCondValue(pCxt); } +#line 6904 "sql.c" break; - case 325: /* cmd ::= DROP INDEX exists_opt full_index_name */ -#line 579 "sql.y" -{ pCxt->pRootNode = createDropIndexStmt(pCxt, yymsp[-1].minor.yy985, yymsp[0].minor.yy1000); } -#line 6908 "sql.c" + case 310: /* db_name_cond_opt ::= db_name NK_DOT */ +#line 553 "sql.y" +{ yylhsminor.yy812 = createIdentifierValueNode(pCxt, &yymsp[-1].minor.yy29); } +#line 6909 "sql.c" + yymsp[-1].minor.yy812 = yylhsminor.yy812; break; - case 326: /* full_index_name ::= index_name */ -#line 581 "sql.y" -{ yylhsminor.yy1000 = createRealTableNodeForIndexName(pCxt, NULL, &yymsp[0].minor.yy305); } -#line 6913 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; + case 312: /* like_pattern_opt ::= LIKE NK_STRING */ +#line 556 "sql.y" +{ yymsp[-1].minor.yy812 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } +#line 6915 "sql.c" break; - case 327: /* full_index_name ::= db_name NK_DOT index_name */ -#line 582 "sql.y" -{ yylhsminor.yy1000 = createRealTableNodeForIndexName(pCxt, &yymsp[-2].minor.yy305, &yymsp[0].minor.yy305); } -#line 6919 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; + case 313: /* table_name_cond ::= table_name */ +#line 558 "sql.y" +{ yylhsminor.yy812 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy29); } +#line 6920 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; break; - case 328: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ -#line 585 "sql.y" -{ yymsp[-9].minor.yy1000 = createIndexOption(pCxt, yymsp[-7].minor.yy72, releaseRawExprNode(pCxt, yymsp[-3].minor.yy1000), NULL, yymsp[-1].minor.yy1000, yymsp[0].minor.yy1000); } -#line 6925 "sql.c" + case 315: /* from_db_opt ::= FROM db_name */ +#line 561 "sql.y" +{ yymsp[-1].minor.yy812 = createIdentifierValueNode(pCxt, &yymsp[0].minor.yy29); } +#line 6926 "sql.c" break; - case 329: /* 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 */ -#line 588 "sql.y" -{ yymsp[-11].minor.yy1000 = createIndexOption(pCxt, yymsp[-9].minor.yy72, releaseRawExprNode(pCxt, yymsp[-5].minor.yy1000), releaseRawExprNode(pCxt, yymsp[-3].minor.yy1000), yymsp[-1].minor.yy1000, yymsp[0].minor.yy1000); } -#line 6930 "sql.c" + case 319: /* tag_item ::= TBNAME */ +#line 569 "sql.y" +{ yylhsminor.yy812 = setProjectionAlias(pCxt, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL), &yymsp[0].minor.yy0); } +#line 6931 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; break; - case 332: /* func ::= sma_func_name NK_LP expression_list NK_RP */ -#line 595 "sql.y" -{ yylhsminor.yy1000 = createFunctionNode(pCxt, &yymsp[-3].minor.yy305, yymsp[-1].minor.yy72); } -#line 6935 "sql.c" - yymsp[-3].minor.yy1000 = yylhsminor.yy1000; + case 322: /* tag_item ::= column_name column_alias */ +#line 572 "sql.y" +{ yylhsminor.yy812 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-1].minor.yy29), &yymsp[0].minor.yy29); } +#line 6937 "sql.c" + yymsp[-1].minor.yy812 = yylhsminor.yy812; break; - case 333: /* sma_func_name ::= function_name */ - case 599: /* alias_opt ::= table_alias */ yytestcase(yyruleno==599); -#line 599 "sql.y" -{ yylhsminor.yy305 = yymsp[0].minor.yy305; } -#line 6942 "sql.c" - yymsp[0].minor.yy305 = yylhsminor.yy305; + case 323: /* tag_item ::= column_name AS column_alias */ +#line 573 "sql.y" +{ yylhsminor.yy812 = setProjectionAlias(pCxt, createColumnNode(pCxt, NULL, &yymsp[-2].minor.yy29), &yymsp[0].minor.yy29); } +#line 6943 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 338: /* sma_stream_opt ::= */ - case 383: /* stream_options ::= */ yytestcase(yyruleno==383); -#line 605 "sql.y" -{ yymsp[1].minor.yy1000 = createStreamOptions(pCxt); } + case 324: /* db_kind_opt ::= */ +#line 577 "sql.y" +{ yymsp[1].minor.yy789 = SHOW_KIND_ALL; } #line 6949 "sql.c" break; - case 339: /* sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */ -#line 606 "sql.y" -{ ((SStreamOptions*)yymsp[-2].minor.yy1000)->pWatermark = releaseRawExprNode(pCxt, yymsp[0].minor.yy1000); yylhsminor.yy1000 = yymsp[-2].minor.yy1000; } + case 325: /* db_kind_opt ::= USER */ +#line 578 "sql.y" +{ yymsp[0].minor.yy789 = SHOW_KIND_DATABASES_USER; } #line 6954 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; break; - case 340: /* sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */ -#line 607 "sql.y" -{ ((SStreamOptions*)yymsp[-2].minor.yy1000)->pDelay = releaseRawExprNode(pCxt, yymsp[0].minor.yy1000); yylhsminor.yy1000 = yymsp[-2].minor.yy1000; } -#line 6960 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; + case 326: /* db_kind_opt ::= SYSTEM */ +#line 579 "sql.y" +{ yymsp[0].minor.yy789 = SHOW_KIND_DATABASES_SYSTEM; } +#line 6959 "sql.c" break; - case 341: /* sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */ -#line 608 "sql.y" -{ ((SStreamOptions*)yymsp[-2].minor.yy1000)->pDeleteMark = releaseRawExprNode(pCxt, yymsp[0].minor.yy1000); yylhsminor.yy1000 = yymsp[-2].minor.yy1000; } -#line 6966 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; + case 327: /* cmd ::= CREATE SMA INDEX not_exists_opt col_name ON full_table_name index_options */ +#line 583 "sql.y" +{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_SMA, yymsp[-4].minor.yy887, yymsp[-3].minor.yy812, yymsp[-1].minor.yy812, NULL, yymsp[0].minor.yy812); } +#line 6964 "sql.c" break; - case 342: /* with_meta ::= AS */ + case 328: /* cmd ::= CREATE INDEX not_exists_opt col_name ON full_table_name NK_LP col_name_list NK_RP */ +#line 585 "sql.y" +{ pCxt->pRootNode = createCreateIndexStmt(pCxt, INDEX_TYPE_NORMAL, yymsp[-6].minor.yy887, yymsp[-5].minor.yy812, yymsp[-3].minor.yy812, yymsp[-1].minor.yy124, NULL); } +#line 6969 "sql.c" + break; + case 329: /* cmd ::= DROP INDEX exists_opt full_index_name */ +#line 586 "sql.y" +{ pCxt->pRootNode = createDropIndexStmt(pCxt, yymsp[-1].minor.yy887, yymsp[0].minor.yy812); } +#line 6974 "sql.c" + break; + case 330: /* full_index_name ::= index_name */ +#line 588 "sql.y" +{ yylhsminor.yy812 = createRealTableNodeForIndexName(pCxt, NULL, &yymsp[0].minor.yy29); } +#line 6979 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; + break; + case 331: /* full_index_name ::= db_name NK_DOT index_name */ +#line 589 "sql.y" +{ yylhsminor.yy812 = createRealTableNodeForIndexName(pCxt, &yymsp[-2].minor.yy29, &yymsp[0].minor.yy29); } +#line 6985 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; + break; + case 332: /* index_options ::= FUNCTION NK_LP func_list NK_RP INTERVAL NK_LP duration_literal NK_RP sliding_opt sma_stream_opt */ +#line 592 "sql.y" +{ yymsp[-9].minor.yy812 = createIndexOption(pCxt, yymsp[-7].minor.yy124, releaseRawExprNode(pCxt, yymsp[-3].minor.yy812), NULL, yymsp[-1].minor.yy812, yymsp[0].minor.yy812); } +#line 6991 "sql.c" + break; + case 333: /* 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 */ +#line 595 "sql.y" +{ yymsp[-11].minor.yy812 = createIndexOption(pCxt, yymsp[-9].minor.yy124, releaseRawExprNode(pCxt, yymsp[-5].minor.yy812), releaseRawExprNode(pCxt, yymsp[-3].minor.yy812), yymsp[-1].minor.yy812, yymsp[0].minor.yy812); } +#line 6996 "sql.c" + break; + case 336: /* func ::= sma_func_name NK_LP expression_list NK_RP */ +#line 602 "sql.y" +{ yylhsminor.yy812 = createFunctionNode(pCxt, &yymsp[-3].minor.yy29, yymsp[-1].minor.yy124); } +#line 7001 "sql.c" + yymsp[-3].minor.yy812 = yylhsminor.yy812; + break; + case 337: /* sma_func_name ::= function_name */ + case 604: /* alias_opt ::= table_alias */ yytestcase(yyruleno==604); +#line 606 "sql.y" +{ yylhsminor.yy29 = yymsp[0].minor.yy29; } +#line 7008 "sql.c" + yymsp[0].minor.yy29 = yylhsminor.yy29; + break; + case 342: /* sma_stream_opt ::= */ + case 387: /* stream_options ::= */ yytestcase(yyruleno==387); +#line 612 "sql.y" +{ yymsp[1].minor.yy812 = createStreamOptions(pCxt); } +#line 7015 "sql.c" + break; + case 343: /* sma_stream_opt ::= sma_stream_opt WATERMARK duration_literal */ #line 613 "sql.y" -{ yymsp[0].minor.yy444 = 0; } -#line 6972 "sql.c" +{ ((SStreamOptions*)yymsp[-2].minor.yy812)->pWatermark = releaseRawExprNode(pCxt, yymsp[0].minor.yy812); yylhsminor.yy812 = yymsp[-2].minor.yy812; } +#line 7020 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 343: /* with_meta ::= WITH META AS */ + case 344: /* sma_stream_opt ::= sma_stream_opt MAX_DELAY duration_literal */ #line 614 "sql.y" -{ yymsp[-2].minor.yy444 = 1; } -#line 6977 "sql.c" +{ ((SStreamOptions*)yymsp[-2].minor.yy812)->pDelay = releaseRawExprNode(pCxt, yymsp[0].minor.yy812); yylhsminor.yy812 = yymsp[-2].minor.yy812; } +#line 7026 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 344: /* with_meta ::= ONLY META AS */ + case 345: /* sma_stream_opt ::= sma_stream_opt DELETE_MARK duration_literal */ #line 615 "sql.y" -{ yymsp[-2].minor.yy444 = 2; } -#line 6982 "sql.c" +{ ((SStreamOptions*)yymsp[-2].minor.yy812)->pDeleteMark = releaseRawExprNode(pCxt, yymsp[0].minor.yy812); yylhsminor.yy812 = yymsp[-2].minor.yy812; } +#line 7032 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 345: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */ -#line 617 "sql.y" -{ pCxt->pRootNode = createCreateTopicStmtUseQuery(pCxt, yymsp[-3].minor.yy985, &yymsp[-2].minor.yy305, yymsp[0].minor.yy1000); } -#line 6987 "sql.c" + case 346: /* with_meta ::= AS */ +#line 620 "sql.y" +{ yymsp[0].minor.yy760 = 0; } +#line 7038 "sql.c" break; - case 346: /* cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */ -#line 619 "sql.y" -{ pCxt->pRootNode = createCreateTopicStmtUseDb(pCxt, yymsp[-4].minor.yy985, &yymsp[-3].minor.yy305, &yymsp[0].minor.yy305, yymsp[-2].minor.yy444); } -#line 6992 "sql.c" - break; - case 347: /* cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */ + case 347: /* with_meta ::= WITH META AS */ #line 621 "sql.y" -{ pCxt->pRootNode = createCreateTopicStmtUseTable(pCxt, yymsp[-5].minor.yy985, &yymsp[-4].minor.yy305, yymsp[-1].minor.yy1000, yymsp[-3].minor.yy444, yymsp[0].minor.yy1000); } -#line 6997 "sql.c" +{ yymsp[-2].minor.yy760 = 1; } +#line 7043 "sql.c" break; - case 348: /* cmd ::= DROP TOPIC exists_opt topic_name */ -#line 623 "sql.y" -{ pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy985, &yymsp[0].minor.yy305); } -#line 7002 "sql.c" + case 348: /* with_meta ::= ONLY META AS */ +#line 622 "sql.y" +{ yymsp[-2].minor.yy760 = 2; } +#line 7048 "sql.c" break; - case 349: /* cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ + case 349: /* cmd ::= CREATE TOPIC not_exists_opt topic_name AS query_or_subquery */ #line 624 "sql.y" -{ pCxt->pRootNode = createDropCGroupStmt(pCxt, yymsp[-3].minor.yy985, &yymsp[-2].minor.yy305, &yymsp[0].minor.yy305); } -#line 7007 "sql.c" +{ pCxt->pRootNode = createCreateTopicStmtUseQuery(pCxt, yymsp[-3].minor.yy887, &yymsp[-2].minor.yy29, yymsp[0].minor.yy812); } +#line 7053 "sql.c" break; - case 350: /* cmd ::= DESC full_table_name */ - case 351: /* cmd ::= DESCRIBE full_table_name */ yytestcase(yyruleno==351); -#line 627 "sql.y" -{ pCxt->pRootNode = createDescribeStmt(pCxt, yymsp[0].minor.yy1000); } -#line 7013 "sql.c" + case 350: /* cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta DATABASE db_name */ +#line 626 "sql.y" +{ pCxt->pRootNode = createCreateTopicStmtUseDb(pCxt, yymsp[-4].minor.yy887, &yymsp[-3].minor.yy29, &yymsp[0].minor.yy29, yymsp[-2].minor.yy760); } +#line 7058 "sql.c" break; - case 352: /* cmd ::= RESET QUERY CACHE */ -#line 631 "sql.y" -{ pCxt->pRootNode = createResetQueryCacheStmt(pCxt); } -#line 7018 "sql.c" - break; - case 353: /* cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */ - case 354: /* cmd ::= EXPLAIN analyze_opt explain_options insert_query */ yytestcase(yyruleno==354); -#line 634 "sql.y" -{ pCxt->pRootNode = createExplainStmt(pCxt, yymsp[-2].minor.yy985, yymsp[-1].minor.yy1000, yymsp[0].minor.yy1000); } -#line 7024 "sql.c" - break; - case 357: /* explain_options ::= */ -#line 642 "sql.y" -{ yymsp[1].minor.yy1000 = createDefaultExplainOptions(pCxt); } -#line 7029 "sql.c" - break; - case 358: /* explain_options ::= explain_options VERBOSE NK_BOOL */ -#line 643 "sql.y" -{ yylhsminor.yy1000 = setExplainVerbose(pCxt, yymsp[-2].minor.yy1000, &yymsp[0].minor.yy0); } -#line 7034 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; - break; - case 359: /* explain_options ::= explain_options RATIO NK_FLOAT */ -#line 644 "sql.y" -{ yylhsminor.yy1000 = setExplainRatio(pCxt, yymsp[-2].minor.yy1000, &yymsp[0].minor.yy0); } -#line 7040 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; - break; - case 360: /* cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */ -#line 649 "sql.y" -{ pCxt->pRootNode = createCreateFunctionStmt(pCxt, yymsp[-7].minor.yy985, yymsp[-9].minor.yy985, &yymsp[-6].minor.yy305, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy56, yymsp[-1].minor.yy444, &yymsp[0].minor.yy305, yymsp[-10].minor.yy985); } -#line 7046 "sql.c" - break; - case 361: /* cmd ::= DROP FUNCTION exists_opt function_name */ -#line 650 "sql.y" -{ pCxt->pRootNode = createDropFunctionStmt(pCxt, yymsp[-1].minor.yy985, &yymsp[0].minor.yy305); } -#line 7051 "sql.c" - break; - case 366: /* language_opt ::= */ - case 405: /* on_vgroup_id ::= */ yytestcase(yyruleno==405); -#line 664 "sql.y" -{ yymsp[1].minor.yy305 = nil_token; } -#line 7057 "sql.c" - break; - case 367: /* language_opt ::= LANGUAGE NK_STRING */ - case 406: /* on_vgroup_id ::= ON NK_INTEGER */ yytestcase(yyruleno==406); -#line 665 "sql.y" -{ yymsp[-1].minor.yy305 = yymsp[0].minor.yy0; } + case 351: /* cmd ::= CREATE TOPIC not_exists_opt topic_name with_meta STABLE full_table_name where_clause_opt */ +#line 628 "sql.y" +{ pCxt->pRootNode = createCreateTopicStmtUseTable(pCxt, yymsp[-5].minor.yy887, &yymsp[-4].minor.yy29, yymsp[-1].minor.yy812, yymsp[-3].minor.yy760, yymsp[0].minor.yy812); } #line 7063 "sql.c" break; - case 370: /* cmd ::= CREATE or_replace_opt VIEW full_view_name AS query_or_subquery */ -#line 674 "sql.y" -{ pCxt->pRootNode = createCreateViewStmt(pCxt, yymsp[-4].minor.yy985, yymsp[-2].minor.yy1000, &yymsp[-1].minor.yy0, yymsp[0].minor.yy1000); } + case 352: /* cmd ::= DROP TOPIC exists_opt topic_name */ +#line 630 "sql.y" +{ pCxt->pRootNode = createDropTopicStmt(pCxt, yymsp[-1].minor.yy887, &yymsp[0].minor.yy29); } #line 7068 "sql.c" break; - case 371: /* cmd ::= DROP VIEW exists_opt full_view_name */ -#line 675 "sql.y" -{ pCxt->pRootNode = createDropViewStmt(pCxt, yymsp[-1].minor.yy985, yymsp[0].minor.yy1000); } + case 353: /* cmd ::= DROP CONSUMER GROUP exists_opt cgroup_name ON topic_name */ +#line 631 "sql.y" +{ pCxt->pRootNode = createDropCGroupStmt(pCxt, yymsp[-3].minor.yy887, &yymsp[-2].minor.yy29, &yymsp[0].minor.yy29); } #line 7073 "sql.c" break; - case 372: /* full_view_name ::= view_name */ -#line 677 "sql.y" -{ yylhsminor.yy1000 = createViewNode(pCxt, NULL, &yymsp[0].minor.yy305); } -#line 7078 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; + case 354: /* cmd ::= DESC full_table_name */ + case 355: /* cmd ::= DESCRIBE full_table_name */ yytestcase(yyruleno==355); +#line 634 "sql.y" +{ pCxt->pRootNode = createDescribeStmt(pCxt, yymsp[0].minor.yy812); } +#line 7079 "sql.c" break; - case 373: /* full_view_name ::= db_name NK_DOT view_name */ -#line 678 "sql.y" -{ yylhsminor.yy1000 = createViewNode(pCxt, &yymsp[-2].minor.yy305, &yymsp[0].minor.yy305); } + case 356: /* cmd ::= RESET QUERY CACHE */ +#line 638 "sql.y" +{ pCxt->pRootNode = createResetQueryCacheStmt(pCxt); } #line 7084 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; break; - case 374: /* 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 */ -#line 683 "sql.y" -{ pCxt->pRootNode = createCreateStreamStmt(pCxt, yymsp[-9].minor.yy985, &yymsp[-8].minor.yy305, yymsp[-5].minor.yy1000, yymsp[-7].minor.yy1000, yymsp[-3].minor.yy72, yymsp[-2].minor.yy1000, yymsp[0].minor.yy1000, yymsp[-4].minor.yy72); } + case 357: /* cmd ::= EXPLAIN analyze_opt explain_options query_or_subquery */ + case 358: /* cmd ::= EXPLAIN analyze_opt explain_options insert_query */ yytestcase(yyruleno==358); +#line 641 "sql.y" +{ pCxt->pRootNode = createExplainStmt(pCxt, yymsp[-2].minor.yy887, yymsp[-1].minor.yy812, yymsp[0].minor.yy812); } #line 7090 "sql.c" break; - case 375: /* cmd ::= DROP STREAM exists_opt stream_name */ -#line 684 "sql.y" -{ pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy985, &yymsp[0].minor.yy305); } + case 361: /* explain_options ::= */ +#line 649 "sql.y" +{ yymsp[1].minor.yy812 = createDefaultExplainOptions(pCxt); } #line 7095 "sql.c" break; - case 376: /* cmd ::= PAUSE STREAM exists_opt stream_name */ -#line 685 "sql.y" -{ pCxt->pRootNode = createPauseStreamStmt(pCxt, yymsp[-1].minor.yy985, &yymsp[0].minor.yy305); } + case 362: /* explain_options ::= explain_options VERBOSE NK_BOOL */ +#line 650 "sql.y" +{ yylhsminor.yy812 = setExplainVerbose(pCxt, yymsp[-2].minor.yy812, &yymsp[0].minor.yy0); } #line 7100 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 377: /* cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */ -#line 686 "sql.y" -{ pCxt->pRootNode = createResumeStreamStmt(pCxt, yymsp[-2].minor.yy985, yymsp[-1].minor.yy985, &yymsp[0].minor.yy305); } -#line 7105 "sql.c" + case 363: /* explain_options ::= explain_options RATIO NK_FLOAT */ +#line 651 "sql.y" +{ yylhsminor.yy812 = setExplainRatio(pCxt, yymsp[-2].minor.yy812, &yymsp[0].minor.yy0); } +#line 7106 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 384: /* stream_options ::= stream_options TRIGGER AT_ONCE */ - case 385: /* stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ yytestcase(yyruleno==385); -#line 700 "sql.y" -{ yylhsminor.yy1000 = setStreamOptions(pCxt, yymsp[-2].minor.yy1000, SOPT_TRIGGER_TYPE_SET, &yymsp[0].minor.yy0, NULL); } -#line 7111 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; + case 364: /* cmd ::= CREATE or_replace_opt agg_func_opt FUNCTION not_exists_opt function_name AS NK_STRING OUTPUTTYPE type_name bufsize_opt language_opt */ +#line 656 "sql.y" +{ pCxt->pRootNode = createCreateFunctionStmt(pCxt, yymsp[-7].minor.yy887, yymsp[-9].minor.yy887, &yymsp[-6].minor.yy29, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy784, yymsp[-1].minor.yy760, &yymsp[0].minor.yy29, yymsp[-10].minor.yy887); } +#line 7112 "sql.c" break; - case 386: /* stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ -#line 702 "sql.y" -{ yylhsminor.yy1000 = setStreamOptions(pCxt, yymsp[-3].minor.yy1000, SOPT_TRIGGER_TYPE_SET, &yymsp[-1].minor.yy0, releaseRawExprNode(pCxt, yymsp[0].minor.yy1000)); } + case 365: /* cmd ::= DROP FUNCTION exists_opt function_name */ +#line 657 "sql.y" +{ pCxt->pRootNode = createDropFunctionStmt(pCxt, yymsp[-1].minor.yy887, &yymsp[0].minor.yy29); } #line 7117 "sql.c" - yymsp[-3].minor.yy1000 = yylhsminor.yy1000; break; - case 387: /* stream_options ::= stream_options WATERMARK duration_literal */ -#line 703 "sql.y" -{ yylhsminor.yy1000 = setStreamOptions(pCxt, yymsp[-2].minor.yy1000, SOPT_WATERMARK_SET, NULL, releaseRawExprNode(pCxt, yymsp[0].minor.yy1000)); } + case 370: /* language_opt ::= */ + case 409: /* on_vgroup_id ::= */ yytestcase(yyruleno==409); +#line 671 "sql.y" +{ yymsp[1].minor.yy29 = nil_token; } #line 7123 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; break; - case 388: /* stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ -#line 704 "sql.y" -{ yylhsminor.yy1000 = setStreamOptions(pCxt, yymsp[-3].minor.yy1000, SOPT_IGNORE_EXPIRED_SET, &yymsp[0].minor.yy0, NULL); } + case 371: /* language_opt ::= LANGUAGE NK_STRING */ + case 410: /* on_vgroup_id ::= ON NK_INTEGER */ yytestcase(yyruleno==410); +#line 672 "sql.y" +{ yymsp[-1].minor.yy29 = yymsp[0].minor.yy0; } #line 7129 "sql.c" - yymsp[-3].minor.yy1000 = yylhsminor.yy1000; break; - case 389: /* stream_options ::= stream_options FILL_HISTORY NK_INTEGER */ -#line 705 "sql.y" -{ yylhsminor.yy1000 = setStreamOptions(pCxt, yymsp[-2].minor.yy1000, SOPT_FILL_HISTORY_SET, &yymsp[0].minor.yy0, NULL); } -#line 7135 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; + case 374: /* cmd ::= CREATE or_replace_opt VIEW full_view_name AS query_or_subquery */ +#line 681 "sql.y" +{ pCxt->pRootNode = createCreateViewStmt(pCxt, yymsp[-4].minor.yy887, yymsp[-2].minor.yy812, &yymsp[-1].minor.yy0, yymsp[0].minor.yy812); } +#line 7134 "sql.c" break; - case 390: /* stream_options ::= stream_options DELETE_MARK duration_literal */ -#line 706 "sql.y" -{ yylhsminor.yy1000 = setStreamOptions(pCxt, yymsp[-2].minor.yy1000, SOPT_DELETE_MARK_SET, NULL, releaseRawExprNode(pCxt, yymsp[0].minor.yy1000)); } -#line 7141 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; + case 375: /* cmd ::= DROP VIEW exists_opt full_view_name */ +#line 682 "sql.y" +{ pCxt->pRootNode = createDropViewStmt(pCxt, yymsp[-1].minor.yy887, yymsp[0].minor.yy812); } +#line 7139 "sql.c" break; - case 391: /* stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */ + case 376: /* full_view_name ::= view_name */ +#line 684 "sql.y" +{ yylhsminor.yy812 = createViewNode(pCxt, NULL, &yymsp[0].minor.yy29); } +#line 7144 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; + break; + case 377: /* full_view_name ::= db_name NK_DOT view_name */ +#line 685 "sql.y" +{ yylhsminor.yy812 = createViewNode(pCxt, &yymsp[-2].minor.yy29, &yymsp[0].minor.yy29); } +#line 7150 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; + break; + case 378: /* 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 */ +#line 690 "sql.y" +{ pCxt->pRootNode = createCreateStreamStmt(pCxt, yymsp[-9].minor.yy887, &yymsp[-8].minor.yy29, yymsp[-5].minor.yy812, yymsp[-7].minor.yy812, yymsp[-3].minor.yy124, yymsp[-2].minor.yy812, yymsp[0].minor.yy812, yymsp[-4].minor.yy124); } +#line 7156 "sql.c" + break; + case 379: /* cmd ::= DROP STREAM exists_opt stream_name */ +#line 691 "sql.y" +{ pCxt->pRootNode = createDropStreamStmt(pCxt, yymsp[-1].minor.yy887, &yymsp[0].minor.yy29); } +#line 7161 "sql.c" + break; + case 380: /* cmd ::= PAUSE STREAM exists_opt stream_name */ +#line 692 "sql.y" +{ pCxt->pRootNode = createPauseStreamStmt(pCxt, yymsp[-1].minor.yy887, &yymsp[0].minor.yy29); } +#line 7166 "sql.c" + break; + case 381: /* cmd ::= RESUME STREAM exists_opt ignore_opt stream_name */ +#line 693 "sql.y" +{ pCxt->pRootNode = createResumeStreamStmt(pCxt, yymsp[-2].minor.yy887, yymsp[-1].minor.yy887, &yymsp[0].minor.yy29); } +#line 7171 "sql.c" + break; + case 388: /* stream_options ::= stream_options TRIGGER AT_ONCE */ + case 389: /* stream_options ::= stream_options TRIGGER WINDOW_CLOSE */ yytestcase(yyruleno==389); #line 707 "sql.y" -{ yylhsminor.yy1000 = setStreamOptions(pCxt, yymsp[-3].minor.yy1000, SOPT_IGNORE_UPDATE_SET, &yymsp[0].minor.yy0, NULL); } -#line 7147 "sql.c" - yymsp[-3].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = setStreamOptions(pCxt, yymsp[-2].minor.yy812, SOPT_TRIGGER_TYPE_SET, &yymsp[0].minor.yy0, NULL); } +#line 7177 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 393: /* subtable_opt ::= SUBTABLE NK_LP expression NK_RP */ - case 639: /* sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP */ yytestcase(yyruleno==639); - case 663: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==663); + case 390: /* stream_options ::= stream_options TRIGGER MAX_DELAY duration_literal */ +#line 709 "sql.y" +{ yylhsminor.yy812 = setStreamOptions(pCxt, yymsp[-3].minor.yy812, SOPT_TRIGGER_TYPE_SET, &yymsp[-1].minor.yy0, releaseRawExprNode(pCxt, yymsp[0].minor.yy812)); } +#line 7183 "sql.c" + yymsp[-3].minor.yy812 = yylhsminor.yy812; + break; + case 391: /* stream_options ::= stream_options WATERMARK duration_literal */ #line 710 "sql.y" -{ yymsp[-3].minor.yy1000 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy1000); } -#line 7155 "sql.c" +{ yylhsminor.yy812 = setStreamOptions(pCxt, yymsp[-2].minor.yy812, SOPT_WATERMARK_SET, NULL, releaseRawExprNode(pCxt, yymsp[0].minor.yy812)); } +#line 7189 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 396: /* cmd ::= KILL CONNECTION NK_INTEGER */ -#line 718 "sql.y" -{ pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_CONNECTION_STMT, &yymsp[0].minor.yy0); } -#line 7160 "sql.c" - break; - case 397: /* cmd ::= KILL QUERY NK_STRING */ -#line 719 "sql.y" -{ pCxt->pRootNode = createKillQueryStmt(pCxt, &yymsp[0].minor.yy0); } -#line 7165 "sql.c" - break; - case 398: /* cmd ::= KILL TRANSACTION NK_INTEGER */ -#line 720 "sql.y" -{ pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_TRANSACTION_STMT, &yymsp[0].minor.yy0); } -#line 7170 "sql.c" - break; - case 399: /* cmd ::= KILL COMPACT NK_INTEGER */ -#line 721 "sql.y" -{ pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_COMPACT_STMT, &yymsp[0].minor.yy0); } -#line 7175 "sql.c" - break; - case 400: /* cmd ::= BALANCE VGROUP */ -#line 724 "sql.y" -{ pCxt->pRootNode = createBalanceVgroupStmt(pCxt); } -#line 7180 "sql.c" - break; - case 401: /* cmd ::= BALANCE VGROUP LEADER on_vgroup_id */ -#line 725 "sql.y" -{ pCxt->pRootNode = createBalanceVgroupLeaderStmt(pCxt, &yymsp[0].minor.yy305); } -#line 7185 "sql.c" - break; - case 402: /* cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ -#line 726 "sql.y" -{ pCxt->pRootNode = createMergeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } -#line 7190 "sql.c" - break; - case 403: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ -#line 727 "sql.y" -{ pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy72); } + case 392: /* stream_options ::= stream_options IGNORE EXPIRED NK_INTEGER */ +#line 711 "sql.y" +{ yylhsminor.yy812 = setStreamOptions(pCxt, yymsp[-3].minor.yy812, SOPT_IGNORE_EXPIRED_SET, &yymsp[0].minor.yy0, NULL); } #line 7195 "sql.c" + yymsp[-3].minor.yy812 = yylhsminor.yy812; break; - case 404: /* cmd ::= SPLIT VGROUP NK_INTEGER */ + case 393: /* stream_options ::= stream_options FILL_HISTORY NK_INTEGER */ +#line 712 "sql.y" +{ yylhsminor.yy812 = setStreamOptions(pCxt, yymsp[-2].minor.yy812, SOPT_FILL_HISTORY_SET, &yymsp[0].minor.yy0, NULL); } +#line 7201 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; + break; + case 394: /* stream_options ::= stream_options DELETE_MARK duration_literal */ +#line 713 "sql.y" +{ yylhsminor.yy812 = setStreamOptions(pCxt, yymsp[-2].minor.yy812, SOPT_DELETE_MARK_SET, NULL, releaseRawExprNode(pCxt, yymsp[0].minor.yy812)); } +#line 7207 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; + break; + case 395: /* stream_options ::= stream_options IGNORE UPDATE NK_INTEGER */ +#line 714 "sql.y" +{ yylhsminor.yy812 = setStreamOptions(pCxt, yymsp[-3].minor.yy812, SOPT_IGNORE_UPDATE_SET, &yymsp[0].minor.yy0, NULL); } +#line 7213 "sql.c" + yymsp[-3].minor.yy812 = yylhsminor.yy812; + break; + case 397: /* subtable_opt ::= SUBTABLE NK_LP expression NK_RP */ + case 644: /* sliding_opt ::= SLIDING NK_LP interval_sliding_duration_literal NK_RP */ yytestcase(yyruleno==644); + case 668: /* every_opt ::= EVERY NK_LP duration_literal NK_RP */ yytestcase(yyruleno==668); +#line 717 "sql.y" +{ yymsp[-3].minor.yy812 = releaseRawExprNode(pCxt, yymsp[-1].minor.yy812); } +#line 7221 "sql.c" + break; + case 400: /* cmd ::= KILL CONNECTION NK_INTEGER */ +#line 725 "sql.y" +{ pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_CONNECTION_STMT, &yymsp[0].minor.yy0); } +#line 7226 "sql.c" + break; + case 401: /* cmd ::= KILL QUERY NK_STRING */ +#line 726 "sql.y" +{ pCxt->pRootNode = createKillQueryStmt(pCxt, &yymsp[0].minor.yy0); } +#line 7231 "sql.c" + break; + case 402: /* cmd ::= KILL TRANSACTION NK_INTEGER */ +#line 727 "sql.y" +{ pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_TRANSACTION_STMT, &yymsp[0].minor.yy0); } +#line 7236 "sql.c" + break; + case 403: /* cmd ::= KILL COMPACT NK_INTEGER */ #line 728 "sql.y" +{ pCxt->pRootNode = createKillStmt(pCxt, QUERY_NODE_KILL_COMPACT_STMT, &yymsp[0].minor.yy0); } +#line 7241 "sql.c" + break; + case 404: /* cmd ::= BALANCE VGROUP */ +#line 731 "sql.y" +{ pCxt->pRootNode = createBalanceVgroupStmt(pCxt); } +#line 7246 "sql.c" + break; + case 405: /* cmd ::= BALANCE VGROUP LEADER on_vgroup_id */ +#line 732 "sql.y" +{ pCxt->pRootNode = createBalanceVgroupLeaderStmt(pCxt, &yymsp[0].minor.yy29); } +#line 7251 "sql.c" + break; + case 406: /* cmd ::= MERGE VGROUP NK_INTEGER NK_INTEGER */ +#line 733 "sql.y" +{ pCxt->pRootNode = createMergeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } +#line 7256 "sql.c" + break; + case 407: /* cmd ::= REDISTRIBUTE VGROUP NK_INTEGER dnode_list */ +#line 734 "sql.y" +{ pCxt->pRootNode = createRedistributeVgroupStmt(pCxt, &yymsp[-1].minor.yy0, yymsp[0].minor.yy124); } +#line 7261 "sql.c" + break; + case 408: /* cmd ::= SPLIT VGROUP NK_INTEGER */ +#line 735 "sql.y" { pCxt->pRootNode = createSplitVgroupStmt(pCxt, &yymsp[0].minor.yy0); } -#line 7200 "sql.c" +#line 7266 "sql.c" break; - case 407: /* dnode_list ::= DNODE NK_INTEGER */ -#line 737 "sql.y" -{ yymsp[-1].minor.yy72 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } -#line 7205 "sql.c" - break; - case 409: /* cmd ::= DELETE FROM full_table_name where_clause_opt */ + case 411: /* dnode_list ::= DNODE NK_INTEGER */ #line 744 "sql.y" -{ pCxt->pRootNode = createDeleteStmt(pCxt, yymsp[-1].minor.yy1000, yymsp[0].minor.yy1000); } -#line 7210 "sql.c" +{ yymsp[-1].minor.yy124 = createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &yymsp[0].minor.yy0)); } +#line 7271 "sql.c" break; - case 412: /* insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */ -#line 753 "sql.y" -{ yymsp[-6].minor.yy1000 = createInsertStmt(pCxt, yymsp[-4].minor.yy1000, yymsp[-2].minor.yy72, yymsp[0].minor.yy1000); } -#line 7215 "sql.c" + case 413: /* cmd ::= DELETE FROM full_table_name where_clause_opt */ +#line 751 "sql.y" +{ pCxt->pRootNode = createDeleteStmt(pCxt, yymsp[-1].minor.yy812, yymsp[0].minor.yy812); } +#line 7276 "sql.c" break; - case 413: /* insert_query ::= INSERT INTO full_table_name query_or_subquery */ -#line 754 "sql.y" -{ yymsp[-3].minor.yy1000 = createInsertStmt(pCxt, yymsp[-1].minor.yy1000, NULL, yymsp[0].minor.yy1000); } -#line 7220 "sql.c" + case 416: /* insert_query ::= INSERT INTO full_table_name NK_LP col_name_list NK_RP query_or_subquery */ +#line 760 "sql.y" +{ yymsp[-6].minor.yy812 = createInsertStmt(pCxt, yymsp[-4].minor.yy812, yymsp[-2].minor.yy124, yymsp[0].minor.yy812); } +#line 7281 "sql.c" break; - case 414: /* tags_literal ::= NK_INTEGER */ - case 426: /* tags_literal ::= NK_BIN */ yytestcase(yyruleno==426); - case 435: /* tags_literal ::= NK_HEX */ yytestcase(yyruleno==435); -#line 757 "sql.y" -{ yylhsminor.yy1000 = createRawValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0, NULL); } -#line 7227 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; + case 417: /* insert_query ::= INSERT INTO full_table_name query_or_subquery */ +#line 761 "sql.y" +{ yymsp[-3].minor.yy812 = createInsertStmt(pCxt, yymsp[-1].minor.yy812, NULL, yymsp[0].minor.yy812); } +#line 7286 "sql.c" break; - case 415: /* tags_literal ::= NK_INTEGER NK_PLUS duration_literal */ - case 416: /* tags_literal ::= NK_INTEGER NK_MINUS duration_literal */ yytestcase(yyruleno==416); - case 427: /* tags_literal ::= NK_BIN NK_PLUS duration_literal */ yytestcase(yyruleno==427); - case 428: /* tags_literal ::= NK_BIN NK_MINUS duration_literal */ yytestcase(yyruleno==428); - case 436: /* tags_literal ::= NK_HEX NK_PLUS duration_literal */ yytestcase(yyruleno==436); - case 437: /* tags_literal ::= NK_HEX NK_MINUS duration_literal */ yytestcase(yyruleno==437); - case 445: /* tags_literal ::= NK_STRING NK_PLUS duration_literal */ yytestcase(yyruleno==445); - case 446: /* tags_literal ::= NK_STRING NK_MINUS duration_literal */ yytestcase(yyruleno==446); -#line 758 "sql.y" + case 418: /* tags_literal ::= NK_INTEGER */ + case 430: /* tags_literal ::= NK_BIN */ yytestcase(yyruleno==430); + case 439: /* tags_literal ::= NK_HEX */ yytestcase(yyruleno==439); +#line 764 "sql.y" +{ yylhsminor.yy812 = createRawValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0, NULL); } +#line 7293 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; + break; + case 419: /* tags_literal ::= NK_INTEGER NK_PLUS duration_literal */ + case 420: /* tags_literal ::= NK_INTEGER NK_MINUS duration_literal */ yytestcase(yyruleno==420); + case 431: /* tags_literal ::= NK_BIN NK_PLUS duration_literal */ yytestcase(yyruleno==431); + case 432: /* tags_literal ::= NK_BIN NK_MINUS duration_literal */ yytestcase(yyruleno==432); + case 440: /* tags_literal ::= NK_HEX NK_PLUS duration_literal */ yytestcase(yyruleno==440); + case 441: /* tags_literal ::= NK_HEX NK_MINUS duration_literal */ yytestcase(yyruleno==441); + case 449: /* tags_literal ::= NK_STRING NK_PLUS duration_literal */ yytestcase(yyruleno==449); + case 450: /* tags_literal ::= NK_STRING NK_MINUS duration_literal */ yytestcase(yyruleno==450); +#line 765 "sql.y" { SToken l = yymsp[-2].minor.yy0; - SToken r = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy1000); + SToken r = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy812); l.n = (r.z + r.n) - l.z; - yylhsminor.yy1000 = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, yymsp[0].minor.yy1000); + yylhsminor.yy812 = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, yymsp[0].minor.yy812); } -#line 7245 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +#line 7311 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 417: /* tags_literal ::= NK_PLUS NK_INTEGER */ - case 420: /* tags_literal ::= NK_MINUS NK_INTEGER */ yytestcase(yyruleno==420); - case 429: /* tags_literal ::= NK_PLUS NK_BIN */ yytestcase(yyruleno==429); - case 432: /* tags_literal ::= NK_MINUS NK_BIN */ yytestcase(yyruleno==432); - case 438: /* tags_literal ::= NK_PLUS NK_HEX */ yytestcase(yyruleno==438); - case 441: /* tags_literal ::= NK_MINUS NK_HEX */ yytestcase(yyruleno==441); -#line 770 "sql.y" + case 421: /* tags_literal ::= NK_PLUS NK_INTEGER */ + case 424: /* tags_literal ::= NK_MINUS NK_INTEGER */ yytestcase(yyruleno==424); + case 433: /* tags_literal ::= NK_PLUS NK_BIN */ yytestcase(yyruleno==433); + case 436: /* tags_literal ::= NK_MINUS NK_BIN */ yytestcase(yyruleno==436); + case 442: /* tags_literal ::= NK_PLUS NK_HEX */ yytestcase(yyruleno==442); + case 445: /* tags_literal ::= NK_MINUS NK_HEX */ yytestcase(yyruleno==445); +#line 777 "sql.y" { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy1000 = createRawValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &t, NULL); + yylhsminor.yy812 = createRawValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &t, NULL); } -#line 7260 "sql.c" - yymsp[-1].minor.yy1000 = yylhsminor.yy1000; +#line 7326 "sql.c" + yymsp[-1].minor.yy812 = yylhsminor.yy812; break; - case 418: /* tags_literal ::= NK_PLUS NK_INTEGER NK_PLUS duration_literal */ - case 419: /* tags_literal ::= NK_PLUS NK_INTEGER NK_MINUS duration_literal */ yytestcase(yyruleno==419); - case 421: /* tags_literal ::= NK_MINUS NK_INTEGER NK_PLUS duration_literal */ yytestcase(yyruleno==421); - case 422: /* tags_literal ::= NK_MINUS NK_INTEGER NK_MINUS duration_literal */ yytestcase(yyruleno==422); - case 430: /* tags_literal ::= NK_PLUS NK_BIN NK_PLUS duration_literal */ yytestcase(yyruleno==430); - case 431: /* tags_literal ::= NK_PLUS NK_BIN NK_MINUS duration_literal */ yytestcase(yyruleno==431); - case 433: /* tags_literal ::= NK_MINUS NK_BIN NK_PLUS duration_literal */ yytestcase(yyruleno==433); - case 434: /* tags_literal ::= NK_MINUS NK_BIN NK_MINUS duration_literal */ yytestcase(yyruleno==434); - case 439: /* tags_literal ::= NK_PLUS NK_HEX NK_PLUS duration_literal */ yytestcase(yyruleno==439); - case 440: /* tags_literal ::= NK_PLUS NK_HEX NK_MINUS duration_literal */ yytestcase(yyruleno==440); - case 442: /* tags_literal ::= NK_MINUS NK_HEX NK_PLUS duration_literal */ yytestcase(yyruleno==442); - case 443: /* tags_literal ::= NK_MINUS NK_HEX NK_MINUS duration_literal */ yytestcase(yyruleno==443); -#line 775 "sql.y" + case 422: /* tags_literal ::= NK_PLUS NK_INTEGER NK_PLUS duration_literal */ + case 423: /* tags_literal ::= NK_PLUS NK_INTEGER NK_MINUS duration_literal */ yytestcase(yyruleno==423); + case 425: /* tags_literal ::= NK_MINUS NK_INTEGER NK_PLUS duration_literal */ yytestcase(yyruleno==425); + case 426: /* tags_literal ::= NK_MINUS NK_INTEGER NK_MINUS duration_literal */ yytestcase(yyruleno==426); + case 434: /* tags_literal ::= NK_PLUS NK_BIN NK_PLUS duration_literal */ yytestcase(yyruleno==434); + case 435: /* tags_literal ::= NK_PLUS NK_BIN NK_MINUS duration_literal */ yytestcase(yyruleno==435); + case 437: /* tags_literal ::= NK_MINUS NK_BIN NK_PLUS duration_literal */ yytestcase(yyruleno==437); + case 438: /* tags_literal ::= NK_MINUS NK_BIN NK_MINUS duration_literal */ yytestcase(yyruleno==438); + case 443: /* tags_literal ::= NK_PLUS NK_HEX NK_PLUS duration_literal */ yytestcase(yyruleno==443); + case 444: /* tags_literal ::= NK_PLUS NK_HEX NK_MINUS duration_literal */ yytestcase(yyruleno==444); + case 446: /* tags_literal ::= NK_MINUS NK_HEX NK_PLUS duration_literal */ yytestcase(yyruleno==446); + case 447: /* tags_literal ::= NK_MINUS NK_HEX NK_MINUS duration_literal */ yytestcase(yyruleno==447); +#line 782 "sql.y" { SToken l = yymsp[-3].minor.yy0; - SToken r = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy1000); + SToken r = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy812); l.n = (r.z + r.n) - l.z; - yylhsminor.yy1000 = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, yymsp[0].minor.yy1000); + yylhsminor.yy812 = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, NULL, yymsp[0].minor.yy812); } -#line 7282 "sql.c" - yymsp[-3].minor.yy1000 = yylhsminor.yy1000; +#line 7348 "sql.c" + yymsp[-3].minor.yy812 = yylhsminor.yy812; break; - case 423: /* tags_literal ::= NK_FLOAT */ -#line 804 "sql.y" -{ yylhsminor.yy1000 = createRawValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0, NULL); } -#line 7288 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; + case 427: /* tags_literal ::= NK_FLOAT */ +#line 811 "sql.y" +{ yylhsminor.yy812 = createRawValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0, NULL); } +#line 7354 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; break; - case 424: /* tags_literal ::= NK_PLUS NK_FLOAT */ - case 425: /* tags_literal ::= NK_MINUS NK_FLOAT */ yytestcase(yyruleno==425); -#line 805 "sql.y" + case 428: /* tags_literal ::= NK_PLUS NK_FLOAT */ + case 429: /* tags_literal ::= NK_MINUS NK_FLOAT */ yytestcase(yyruleno==429); +#line 812 "sql.y" { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy1000 = createRawValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t, NULL); + yylhsminor.yy812 = createRawValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t, NULL); } -#line 7299 "sql.c" - yymsp[-1].minor.yy1000 = yylhsminor.yy1000; - break; - case 444: /* tags_literal ::= NK_STRING */ -#line 911 "sql.y" -{ yylhsminor.yy1000 = createRawValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0, NULL); } -#line 7305 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; - break; - case 447: /* tags_literal ::= NK_BOOL */ -#line 924 "sql.y" -{ yylhsminor.yy1000 = createRawValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0, NULL); } -#line 7311 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; - break; - case 448: /* tags_literal ::= NULL */ -#line 925 "sql.y" -{ yylhsminor.yy1000 = createRawValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0, NULL); } -#line 7317 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; - break; - case 449: /* tags_literal ::= literal_func */ -#line 927 "sql.y" -{ yylhsminor.yy1000 = createRawValueNode(pCxt, TSDB_DATA_TYPE_BINARY, NULL, yymsp[0].minor.yy1000); } -#line 7323 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; - break; - case 450: /* tags_literal ::= literal_func NK_PLUS duration_literal */ - case 451: /* tags_literal ::= literal_func NK_MINUS duration_literal */ yytestcase(yyruleno==451); -#line 928 "sql.y" -{ - SToken l = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy1000); - SToken r = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy1000); - l.n = (r.z + r.n) - l.z; - yylhsminor.yy1000 = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, yymsp[-2].minor.yy1000, yymsp[0].minor.yy1000); - } -#line 7335 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; - break; - case 454: /* literal ::= NK_INTEGER */ -#line 947 "sql.y" -{ yylhsminor.yy1000 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0)); } -#line 7341 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; - break; - case 455: /* literal ::= NK_FLOAT */ -#line 948 "sql.y" -{ yylhsminor.yy1000 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); } -#line 7347 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; - break; - case 456: /* literal ::= NK_STRING */ -#line 949 "sql.y" -{ yylhsminor.yy1000 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } -#line 7353 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; - break; - case 457: /* literal ::= NK_BOOL */ -#line 950 "sql.y" -{ yylhsminor.yy1000 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); } -#line 7359 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; - break; - case 458: /* literal ::= TIMESTAMP NK_STRING */ -#line 951 "sql.y" -{ yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); } #line 7365 "sql.c" - yymsp[-1].minor.yy1000 = yylhsminor.yy1000; + yymsp[-1].minor.yy812 = yylhsminor.yy812; break; - case 459: /* literal ::= duration_literal */ - case 469: /* signed_literal ::= signed */ yytestcase(yyruleno==469); - case 492: /* expr_or_subquery ::= expression */ yytestcase(yyruleno==492); - case 493: /* expression ::= literal */ yytestcase(yyruleno==493); - case 495: /* expression ::= column_reference */ yytestcase(yyruleno==495); - case 496: /* expression ::= function_expression */ yytestcase(yyruleno==496); - case 497: /* expression ::= case_when_expression */ yytestcase(yyruleno==497); - case 530: /* function_expression ::= literal_func */ yytestcase(yyruleno==530); - case 580: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==580); - case 584: /* boolean_primary ::= predicate */ yytestcase(yyruleno==584); - case 586: /* common_expression ::= expr_or_subquery */ yytestcase(yyruleno==586); - case 587: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==587); - case 590: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==590); - case 592: /* table_reference ::= table_primary */ yytestcase(yyruleno==592); - case 593: /* table_reference ::= joined_table */ yytestcase(yyruleno==593); - case 597: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==597); - case 665: /* query_simple ::= query_specification */ yytestcase(yyruleno==665); - case 666: /* query_simple ::= union_query_expression */ yytestcase(yyruleno==666); - case 669: /* query_simple_or_subquery ::= query_simple */ yytestcase(yyruleno==669); - case 671: /* query_or_subquery ::= query_expression */ yytestcase(yyruleno==671); -#line 952 "sql.y" -{ yylhsminor.yy1000 = yymsp[0].minor.yy1000; } -#line 7390 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; + case 448: /* tags_literal ::= NK_STRING */ +#line 918 "sql.y" +{ yylhsminor.yy812 = createRawValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0, NULL); } +#line 7371 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; break; - case 460: /* literal ::= NULL */ -#line 953 "sql.y" -{ yylhsminor.yy1000 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0)); } -#line 7396 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; + case 451: /* tags_literal ::= NK_BOOL */ +#line 931 "sql.y" +{ yylhsminor.yy812 = createRawValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0, NULL); } +#line 7377 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; break; - case 461: /* literal ::= NK_QUESTION */ -#line 954 "sql.y" -{ yylhsminor.yy1000 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0)); } -#line 7402 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; + case 452: /* tags_literal ::= NULL */ +#line 932 "sql.y" +{ yylhsminor.yy812 = createRawValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0, NULL); } +#line 7383 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; break; - case 462: /* duration_literal ::= NK_VARIABLE */ - case 640: /* interval_sliding_duration_literal ::= NK_VARIABLE */ yytestcase(yyruleno==640); - case 641: /* interval_sliding_duration_literal ::= NK_STRING */ yytestcase(yyruleno==641); - case 642: /* interval_sliding_duration_literal ::= NK_INTEGER */ yytestcase(yyruleno==642); -#line 956 "sql.y" -{ yylhsminor.yy1000 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } -#line 7411 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; + case 453: /* tags_literal ::= literal_func */ +#line 934 "sql.y" +{ yylhsminor.yy812 = createRawValueNode(pCxt, TSDB_DATA_TYPE_BINARY, NULL, yymsp[0].minor.yy812); } +#line 7389 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; break; - case 463: /* signed ::= NK_INTEGER */ -#line 958 "sql.y" -{ yylhsminor.yy1000 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } -#line 7417 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; - break; - case 464: /* signed ::= NK_PLUS NK_INTEGER */ -#line 959 "sql.y" -{ yymsp[-1].minor.yy1000 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } -#line 7423 "sql.c" - break; - case 465: /* signed ::= NK_MINUS NK_INTEGER */ -#line 960 "sql.y" + case 454: /* tags_literal ::= literal_func NK_PLUS duration_literal */ + case 455: /* tags_literal ::= literal_func NK_MINUS duration_literal */ yytestcase(yyruleno==455); +#line 935 "sql.y" { - SToken t = yymsp[-1].minor.yy0; - t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy1000 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &t); + SToken l = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy812); + SToken r = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy812); + l.n = (r.z + r.n) - l.z; + yylhsminor.yy812 = createRawValueNodeExt(pCxt, TSDB_DATA_TYPE_BINARY, &l, yymsp[-2].minor.yy812, yymsp[0].minor.yy812); } -#line 7432 "sql.c" - yymsp[-1].minor.yy1000 = yylhsminor.yy1000; +#line 7401 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 466: /* signed ::= NK_FLOAT */ + case 458: /* literal ::= NK_INTEGER */ +#line 954 "sql.y" +{ yylhsminor.yy812 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0)); } +#line 7407 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; + break; + case 459: /* literal ::= NK_FLOAT */ +#line 955 "sql.y" +{ yylhsminor.yy812 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0)); } +#line 7413 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; + break; + case 460: /* literal ::= NK_STRING */ +#line 956 "sql.y" +{ yylhsminor.yy812 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0)); } +#line 7419 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; + break; + case 461: /* literal ::= NK_BOOL */ +#line 957 "sql.y" +{ yylhsminor.yy812 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0)); } +#line 7425 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; + break; + case 462: /* literal ::= TIMESTAMP NK_STRING */ +#line 958 "sql.y" +{ yylhsminor.yy812 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0)); } +#line 7431 "sql.c" + yymsp[-1].minor.yy812 = yylhsminor.yy812; + break; + case 463: /* literal ::= duration_literal */ + case 473: /* signed_literal ::= signed */ yytestcase(yyruleno==473); + case 496: /* expr_or_subquery ::= expression */ yytestcase(yyruleno==496); + case 497: /* expression ::= literal */ yytestcase(yyruleno==497); + case 499: /* expression ::= column_reference */ yytestcase(yyruleno==499); + case 500: /* expression ::= function_expression */ yytestcase(yyruleno==500); + case 501: /* expression ::= case_when_expression */ yytestcase(yyruleno==501); + case 535: /* function_expression ::= literal_func */ yytestcase(yyruleno==535); + case 585: /* boolean_value_expression ::= boolean_primary */ yytestcase(yyruleno==585); + case 589: /* boolean_primary ::= predicate */ yytestcase(yyruleno==589); + case 591: /* common_expression ::= expr_or_subquery */ yytestcase(yyruleno==591); + case 592: /* common_expression ::= boolean_value_expression */ yytestcase(yyruleno==592); + case 595: /* table_reference_list ::= table_reference */ yytestcase(yyruleno==595); + case 597: /* table_reference ::= table_primary */ yytestcase(yyruleno==597); + case 598: /* table_reference ::= joined_table */ yytestcase(yyruleno==598); + case 602: /* table_primary ::= parenthesized_joined_table */ yytestcase(yyruleno==602); + case 670: /* query_simple ::= query_specification */ yytestcase(yyruleno==670); + case 671: /* query_simple ::= union_query_expression */ yytestcase(yyruleno==671); + case 674: /* query_simple_or_subquery ::= query_simple */ yytestcase(yyruleno==674); + case 676: /* query_or_subquery ::= query_expression */ yytestcase(yyruleno==676); +#line 959 "sql.y" +{ yylhsminor.yy812 = yymsp[0].minor.yy812; } +#line 7456 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; + break; + case 464: /* literal ::= NULL */ +#line 960 "sql.y" +{ yylhsminor.yy812 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0)); } +#line 7462 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; + break; + case 465: /* literal ::= NK_QUESTION */ +#line 961 "sql.y" +{ yylhsminor.yy812 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0)); } +#line 7468 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; + break; + case 466: /* duration_literal ::= NK_VARIABLE */ + case 645: /* interval_sliding_duration_literal ::= NK_VARIABLE */ yytestcase(yyruleno==645); + case 646: /* interval_sliding_duration_literal ::= NK_STRING */ yytestcase(yyruleno==646); + case 647: /* interval_sliding_duration_literal ::= NK_INTEGER */ yytestcase(yyruleno==647); +#line 963 "sql.y" +{ yylhsminor.yy812 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createDurationValueNode(pCxt, &yymsp[0].minor.yy0)); } +#line 7477 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; + break; + case 467: /* signed ::= NK_INTEGER */ #line 965 "sql.y" -{ yylhsminor.yy1000 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } -#line 7438 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } +#line 7483 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; break; - case 467: /* signed ::= NK_PLUS NK_FLOAT */ + case 468: /* signed ::= NK_PLUS NK_INTEGER */ #line 966 "sql.y" -{ yymsp[-1].minor.yy1000 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } -#line 7444 "sql.c" +{ yymsp[-1].minor.yy812 = createValueNode(pCxt, TSDB_DATA_TYPE_UBIGINT, &yymsp[0].minor.yy0); } +#line 7489 "sql.c" break; - case 468: /* signed ::= NK_MINUS NK_FLOAT */ + case 469: /* signed ::= NK_MINUS NK_INTEGER */ #line 967 "sql.y" { SToken t = yymsp[-1].minor.yy0; t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; - yylhsminor.yy1000 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t); + yylhsminor.yy812 = createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &t); } -#line 7453 "sql.c" - yymsp[-1].minor.yy1000 = yylhsminor.yy1000; +#line 7498 "sql.c" + yymsp[-1].minor.yy812 = yylhsminor.yy812; break; - case 470: /* signed_literal ::= NK_STRING */ + case 470: /* signed ::= NK_FLOAT */ +#line 972 "sql.y" +{ yylhsminor.yy812 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } +#line 7504 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; + break; + case 471: /* signed ::= NK_PLUS NK_FLOAT */ +#line 973 "sql.y" +{ yymsp[-1].minor.yy812 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &yymsp[0].minor.yy0); } +#line 7510 "sql.c" + break; + case 472: /* signed ::= NK_MINUS NK_FLOAT */ #line 974 "sql.y" -{ yylhsminor.yy1000 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } -#line 7459 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; - break; - case 471: /* signed_literal ::= NK_BOOL */ -#line 975 "sql.y" -{ yylhsminor.yy1000 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); } -#line 7465 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; - break; - case 472: /* signed_literal ::= TIMESTAMP NK_STRING */ -#line 976 "sql.y" -{ yymsp[-1].minor.yy1000 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } -#line 7471 "sql.c" - break; - case 473: /* signed_literal ::= duration_literal */ - case 475: /* signed_literal ::= literal_func */ yytestcase(yyruleno==475); - case 551: /* star_func_para ::= expr_or_subquery */ yytestcase(yyruleno==551); - case 617: /* select_item ::= common_expression */ yytestcase(yyruleno==617); - case 627: /* partition_item ::= expr_or_subquery */ yytestcase(yyruleno==627); - case 670: /* query_simple_or_subquery ::= subquery */ yytestcase(yyruleno==670); - case 672: /* query_or_subquery ::= subquery */ yytestcase(yyruleno==672); - case 685: /* search_condition ::= common_expression */ yytestcase(yyruleno==685); -#line 977 "sql.y" -{ yylhsminor.yy1000 = releaseRawExprNode(pCxt, yymsp[0].minor.yy1000); } -#line 7483 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; - break; - case 474: /* signed_literal ::= NULL */ -#line 978 "sql.y" -{ yylhsminor.yy1000 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); } -#line 7489 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; - break; - case 476: /* signed_literal ::= NK_QUESTION */ -#line 980 "sql.y" -{ yylhsminor.yy1000 = createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0); } -#line 7495 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; - break; - case 494: /* expression ::= pseudo_column */ -#line 1042 "sql.y" -{ yylhsminor.yy1000 = yymsp[0].minor.yy1000; setRawExprNodeIsPseudoColumn(pCxt, yylhsminor.yy1000, true); } -#line 7501 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; - break; - case 498: /* expression ::= NK_LP expression NK_RP */ - case 585: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==585); - case 684: /* subquery ::= NK_LP subquery NK_RP */ yytestcase(yyruleno==684); -#line 1046 "sql.y" -{ yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy1000)); } -#line 7509 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; - break; - case 499: /* expression ::= NK_PLUS expr_or_subquery */ -#line 1047 "sql.y" { - SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy1000); - yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy1000)); + SToken t = yymsp[-1].minor.yy0; + t.n = (yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z; + yylhsminor.yy812 = createValueNode(pCxt, TSDB_DATA_TYPE_DOUBLE, &t); } -#line 7518 "sql.c" - yymsp[-1].minor.yy1000 = yylhsminor.yy1000; +#line 7519 "sql.c" + yymsp[-1].minor.yy812 = yylhsminor.yy812; break; - case 500: /* expression ::= NK_MINUS expr_or_subquery */ -#line 1051 "sql.y" -{ - SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy1000); - yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy1000), NULL)); - } -#line 7527 "sql.c" - yymsp[-1].minor.yy1000 = yylhsminor.yy1000; + case 474: /* signed_literal ::= NK_STRING */ +#line 981 "sql.y" +{ yylhsminor.yy812 = createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0); } +#line 7525 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; break; - case 501: /* expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ -#line 1055 "sql.y" -{ - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy1000); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy1000); - yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_ADD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy1000), releaseRawExprNode(pCxt, yymsp[0].minor.yy1000))); - } + case 475: /* signed_literal ::= NK_BOOL */ +#line 982 "sql.y" +{ yylhsminor.yy812 = createValueNode(pCxt, TSDB_DATA_TYPE_BOOL, &yymsp[0].minor.yy0); } +#line 7531 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; + break; + case 476: /* signed_literal ::= TIMESTAMP NK_STRING */ +#line 983 "sql.y" +{ yymsp[-1].minor.yy812 = createValueNode(pCxt, TSDB_DATA_TYPE_TIMESTAMP, &yymsp[0].minor.yy0); } #line 7537 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; break; - case 502: /* expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ -#line 1060 "sql.y" -{ - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy1000); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy1000); - yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_SUB, releaseRawExprNode(pCxt, yymsp[-2].minor.yy1000), releaseRawExprNode(pCxt, yymsp[0].minor.yy1000))); - } -#line 7547 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; + case 477: /* signed_literal ::= duration_literal */ + case 479: /* signed_literal ::= literal_func */ yytestcase(yyruleno==479); + case 556: /* star_func_para ::= expr_or_subquery */ yytestcase(yyruleno==556); + case 622: /* select_item ::= common_expression */ yytestcase(yyruleno==622); + case 632: /* partition_item ::= expr_or_subquery */ yytestcase(yyruleno==632); + case 675: /* query_simple_or_subquery ::= subquery */ yytestcase(yyruleno==675); + case 677: /* query_or_subquery ::= subquery */ yytestcase(yyruleno==677); + case 690: /* search_condition ::= common_expression */ yytestcase(yyruleno==690); +#line 984 "sql.y" +{ yylhsminor.yy812 = releaseRawExprNode(pCxt, yymsp[0].minor.yy812); } +#line 7549 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; break; - case 503: /* expression ::= expr_or_subquery NK_STAR expr_or_subquery */ -#line 1065 "sql.y" -{ - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy1000); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy1000); - yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MULTI, releaseRawExprNode(pCxt, yymsp[-2].minor.yy1000), releaseRawExprNode(pCxt, yymsp[0].minor.yy1000))); - } -#line 7557 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; + case 478: /* signed_literal ::= NULL */ +#line 985 "sql.y" +{ yylhsminor.yy812 = createValueNode(pCxt, TSDB_DATA_TYPE_NULL, &yymsp[0].minor.yy0); } +#line 7555 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; break; - case 504: /* expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ -#line 1070 "sql.y" -{ - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy1000); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy1000); - yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_DIV, releaseRawExprNode(pCxt, yymsp[-2].minor.yy1000), releaseRawExprNode(pCxt, yymsp[0].minor.yy1000))); - } + case 480: /* signed_literal ::= NK_QUESTION */ +#line 987 "sql.y" +{ yylhsminor.yy812 = createPlaceholderValueNode(pCxt, &yymsp[0].minor.yy0); } +#line 7561 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; + break; + case 498: /* expression ::= pseudo_column */ +#line 1049 "sql.y" +{ yylhsminor.yy812 = yymsp[0].minor.yy812; setRawExprNodeIsPseudoColumn(pCxt, yylhsminor.yy812, true); } #line 7567 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; + yymsp[0].minor.yy812 = yylhsminor.yy812; break; - case 505: /* expression ::= expr_or_subquery NK_REM expr_or_subquery */ -#line 1075 "sql.y" + case 502: /* expression ::= NK_LP expression NK_RP */ + case 590: /* boolean_primary ::= NK_LP boolean_value_expression NK_RP */ yytestcase(yyruleno==590); + case 689: /* subquery ::= NK_LP subquery NK_RP */ yytestcase(yyruleno==689); +#line 1053 "sql.y" +{ yylhsminor.yy812 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, releaseRawExprNode(pCxt, yymsp[-1].minor.yy812)); } +#line 7575 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; + break; + case 503: /* expression ::= NK_PLUS expr_or_subquery */ +#line 1054 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy1000); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy1000); - yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_REM, releaseRawExprNode(pCxt, yymsp[-2].minor.yy1000), releaseRawExprNode(pCxt, yymsp[0].minor.yy1000))); + SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy812); + yylhsminor.yy812 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, releaseRawExprNode(pCxt, yymsp[0].minor.yy812)); } -#line 7577 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +#line 7584 "sql.c" + yymsp[-1].minor.yy812 = yylhsminor.yy812; break; - case 506: /* expression ::= column_reference NK_ARROW NK_STRING */ -#line 1080 "sql.y" + case 504: /* expression ::= NK_MINUS expr_or_subquery */ +#line 1058 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy1000); - yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy1000), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0))); + SToken t = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy812); + yylhsminor.yy812 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &t, createOperatorNode(pCxt, OP_TYPE_MINUS, releaseRawExprNode(pCxt, yymsp[0].minor.yy812), NULL)); } -#line 7586 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +#line 7593 "sql.c" + yymsp[-1].minor.yy812 = yylhsminor.yy812; break; - case 507: /* expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ -#line 1084 "sql.y" + case 505: /* expression ::= expr_or_subquery NK_PLUS expr_or_subquery */ +#line 1062 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy1000); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy1000); - yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy1000), releaseRawExprNode(pCxt, yymsp[0].minor.yy1000))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy812); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy812); + yylhsminor.yy812 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_ADD, releaseRawExprNode(pCxt, yymsp[-2].minor.yy812), releaseRawExprNode(pCxt, yymsp[0].minor.yy812))); } -#line 7596 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +#line 7603 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 508: /* expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ -#line 1089 "sql.y" + case 506: /* expression ::= expr_or_subquery NK_MINUS expr_or_subquery */ +#line 1067 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy1000); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy1000); - yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy1000), releaseRawExprNode(pCxt, yymsp[0].minor.yy1000))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy812); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy812); + yylhsminor.yy812 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_SUB, releaseRawExprNode(pCxt, yymsp[-2].minor.yy812), releaseRawExprNode(pCxt, yymsp[0].minor.yy812))); } -#line 7606 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +#line 7613 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 511: /* column_reference ::= column_name */ -#line 1100 "sql.y" -{ yylhsminor.yy1000 = createRawExprNode(pCxt, &yymsp[0].minor.yy305, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy305)); } -#line 7612 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; + case 507: /* expression ::= expr_or_subquery NK_STAR expr_or_subquery */ +#line 1072 "sql.y" +{ + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy812); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy812); + yylhsminor.yy812 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_MULTI, releaseRawExprNode(pCxt, yymsp[-2].minor.yy812), releaseRawExprNode(pCxt, yymsp[0].minor.yy812))); + } +#line 7623 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 512: /* column_reference ::= table_name NK_DOT column_name */ -#line 1101 "sql.y" -{ yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy305, &yymsp[0].minor.yy305, createColumnNode(pCxt, &yymsp[-2].minor.yy305, &yymsp[0].minor.yy305)); } -#line 7618 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; + case 508: /* expression ::= expr_or_subquery NK_SLASH expr_or_subquery */ +#line 1077 "sql.y" +{ + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy812); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy812); + yylhsminor.yy812 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_DIV, releaseRawExprNode(pCxt, yymsp[-2].minor.yy812), releaseRawExprNode(pCxt, yymsp[0].minor.yy812))); + } +#line 7633 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 513: /* column_reference ::= NK_ALIAS */ -#line 1102 "sql.y" -{ yylhsminor.yy1000 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } -#line 7624 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; + case 509: /* expression ::= expr_or_subquery NK_REM expr_or_subquery */ +#line 1082 "sql.y" +{ + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy812); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy812); + yylhsminor.yy812 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_REM, releaseRawExprNode(pCxt, yymsp[-2].minor.yy812), releaseRawExprNode(pCxt, yymsp[0].minor.yy812))); + } +#line 7643 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 514: /* column_reference ::= table_name NK_DOT NK_ALIAS */ -#line 1103 "sql.y" -{ yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy305, &yymsp[0].minor.yy0, createColumnNode(pCxt, &yymsp[-2].minor.yy305, &yymsp[0].minor.yy0)); } -#line 7630 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; + case 510: /* expression ::= column_reference NK_ARROW NK_STRING */ +#line 1087 "sql.y" +{ + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy812); + yylhsminor.yy812 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_JSON_GET_VALUE, releaseRawExprNode(pCxt, yymsp[-2].minor.yy812), createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[0].minor.yy0))); + } +#line 7652 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 515: /* pseudo_column ::= ROWTS */ - case 516: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==516); - case 518: /* pseudo_column ::= QSTART */ yytestcase(yyruleno==518); - case 519: /* pseudo_column ::= QEND */ yytestcase(yyruleno==519); - case 520: /* pseudo_column ::= QDURATION */ yytestcase(yyruleno==520); - case 521: /* pseudo_column ::= WSTART */ yytestcase(yyruleno==521); - case 522: /* pseudo_column ::= WEND */ yytestcase(yyruleno==522); - case 523: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==523); - case 524: /* pseudo_column ::= IROWTS */ yytestcase(yyruleno==524); - case 525: /* pseudo_column ::= ISFILLED */ yytestcase(yyruleno==525); - case 526: /* pseudo_column ::= QTAGS */ yytestcase(yyruleno==526); - case 532: /* literal_func ::= NOW */ yytestcase(yyruleno==532); - case 533: /* literal_func ::= TODAY */ yytestcase(yyruleno==533); -#line 1105 "sql.y" -{ yylhsminor.yy1000 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); } -#line 7648 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; + case 511: /* expression ::= expr_or_subquery NK_BITAND expr_or_subquery */ +#line 1091 "sql.y" +{ + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy812); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy812); + yylhsminor.yy812 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy812), releaseRawExprNode(pCxt, yymsp[0].minor.yy812))); + } +#line 7662 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 517: /* pseudo_column ::= table_name NK_DOT TBNAME */ + case 512: /* expression ::= expr_or_subquery NK_BITOR expr_or_subquery */ +#line 1096 "sql.y" +{ + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy812); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy812); + yylhsminor.yy812 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, OP_TYPE_BIT_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy812), releaseRawExprNode(pCxt, yymsp[0].minor.yy812))); + } +#line 7672 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; + break; + case 515: /* column_reference ::= column_name */ #line 1107 "sql.y" -{ yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy305, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy305)))); } -#line 7654 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yylhsminor.yy812 = createRawExprNode(pCxt, &yymsp[0].minor.yy29, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy29)); } +#line 7678 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; break; - case 527: /* function_expression ::= function_name NK_LP expression_list NK_RP */ - case 528: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==528); -#line 1118 "sql.y" -{ yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy305, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy305, yymsp[-1].minor.yy72)); } -#line 7661 "sql.c" - yymsp[-3].minor.yy1000 = yylhsminor.yy1000; + case 516: /* column_reference ::= table_name NK_DOT column_name */ +#line 1108 "sql.y" +{ yylhsminor.yy812 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy29, &yymsp[0].minor.yy29, createColumnNode(pCxt, &yymsp[-2].minor.yy29, &yymsp[0].minor.yy29)); } +#line 7684 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 529: /* function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ -#line 1121 "sql.y" -{ yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy1000), yymsp[-1].minor.yy56)); } -#line 7667 "sql.c" - yymsp[-5].minor.yy1000 = yylhsminor.yy1000; + case 517: /* column_reference ::= NK_ALIAS */ +#line 1109 "sql.y" +{ yylhsminor.yy812 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } +#line 7690 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; break; - case 531: /* literal_func ::= noarg_func NK_LP NK_RP */ -#line 1124 "sql.y" -{ yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy305, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy305, NULL)); } -#line 7673 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; + case 518: /* column_reference ::= table_name NK_DOT NK_ALIAS */ +#line 1110 "sql.y" +{ yylhsminor.yy812 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy29, &yymsp[0].minor.yy0, createColumnNode(pCxt, &yymsp[-2].minor.yy29, &yymsp[0].minor.yy0)); } +#line 7696 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 547: /* star_func_para_list ::= NK_STAR */ -#line 1149 "sql.y" -{ yylhsminor.yy72 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } -#line 7679 "sql.c" - yymsp[0].minor.yy72 = yylhsminor.yy72; + case 519: /* pseudo_column ::= ROWTS */ + case 520: /* pseudo_column ::= TBNAME */ yytestcase(yyruleno==520); + case 522: /* pseudo_column ::= QSTART */ yytestcase(yyruleno==522); + case 523: /* pseudo_column ::= QEND */ yytestcase(yyruleno==523); + case 524: /* pseudo_column ::= QDURATION */ yytestcase(yyruleno==524); + case 525: /* pseudo_column ::= WSTART */ yytestcase(yyruleno==525); + case 526: /* pseudo_column ::= WEND */ yytestcase(yyruleno==526); + case 527: /* pseudo_column ::= WDURATION */ yytestcase(yyruleno==527); + case 528: /* pseudo_column ::= IROWTS */ yytestcase(yyruleno==528); + case 529: /* pseudo_column ::= ISFILLED */ yytestcase(yyruleno==529); + case 530: /* pseudo_column ::= QTAGS */ yytestcase(yyruleno==530); + case 537: /* literal_func ::= NOW */ yytestcase(yyruleno==537); + case 538: /* literal_func ::= TODAY */ yytestcase(yyruleno==538); +#line 1112 "sql.y" +{ yylhsminor.yy812 = createRawExprNode(pCxt, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, NULL)); } +#line 7714 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; break; - case 552: /* star_func_para ::= table_name NK_DOT NK_STAR */ - case 620: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==620); -#line 1158 "sql.y" -{ yylhsminor.yy1000 = createColumnNode(pCxt, &yymsp[-2].minor.yy305, &yymsp[0].minor.yy0); } -#line 7686 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; + case 521: /* pseudo_column ::= table_name NK_DOT TBNAME */ +#line 1114 "sql.y" +{ yylhsminor.yy812 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy29, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[0].minor.yy0, createNodeList(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BINARY, &yymsp[-2].minor.yy29)))); } +#line 7720 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 553: /* case_when_expression ::= CASE when_then_list case_when_else_opt END */ -#line 1161 "sql.y" -{ yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, NULL, yymsp[-2].minor.yy72, yymsp[-1].minor.yy1000)); } -#line 7692 "sql.c" - yymsp[-3].minor.yy1000 = yylhsminor.yy1000; + case 531: /* function_expression ::= function_name NK_LP expression_list NK_RP */ + case 532: /* function_expression ::= star_func NK_LP star_func_para_list NK_RP */ yytestcase(yyruleno==532); +#line 1125 "sql.y" +{ yylhsminor.yy812 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy29, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-3].minor.yy29, yymsp[-1].minor.yy124)); } +#line 7727 "sql.c" + yymsp[-3].minor.yy812 = yylhsminor.yy812; break; - case 554: /* case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ -#line 1163 "sql.y" -{ yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &yymsp[-4].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy1000), yymsp[-2].minor.yy72, yymsp[-1].minor.yy1000)); } -#line 7698 "sql.c" - yymsp[-4].minor.yy1000 = yylhsminor.yy1000; + case 533: /* function_expression ::= CAST NK_LP expr_or_subquery AS type_name NK_RP */ + case 534: /* function_expression ::= CAST NK_LP expr_or_subquery AS type_name_default_len NK_RP */ yytestcase(yyruleno==534); +#line 1128 "sql.y" +{ yylhsminor.yy812 = createRawExprNodeExt(pCxt, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, createCastFunctionNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy812), yymsp[-1].minor.yy784)); } +#line 7734 "sql.c" + yymsp[-5].minor.yy812 = yylhsminor.yy812; break; - case 557: /* when_then_expr ::= WHEN common_expression THEN common_expression */ -#line 1170 "sql.y" -{ yymsp[-3].minor.yy1000 = createWhenThenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy1000), releaseRawExprNode(pCxt, yymsp[0].minor.yy1000)); } -#line 7704 "sql.c" + case 536: /* literal_func ::= noarg_func NK_LP NK_RP */ +#line 1134 "sql.y" +{ yylhsminor.yy812 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy29, &yymsp[0].minor.yy0, createFunctionNode(pCxt, &yymsp[-2].minor.yy29, NULL)); } +#line 7740 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 559: /* case_when_else_opt ::= ELSE common_expression */ + case 552: /* star_func_para_list ::= NK_STAR */ +#line 1159 "sql.y" +{ yylhsminor.yy124 = createNodeList(pCxt, createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0)); } +#line 7746 "sql.c" + yymsp[0].minor.yy124 = yylhsminor.yy124; + break; + case 557: /* star_func_para ::= table_name NK_DOT NK_STAR */ + case 625: /* select_item ::= table_name NK_DOT NK_STAR */ yytestcase(yyruleno==625); +#line 1168 "sql.y" +{ yylhsminor.yy812 = createColumnNode(pCxt, &yymsp[-2].minor.yy29, &yymsp[0].minor.yy0); } +#line 7753 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; + break; + case 558: /* case_when_expression ::= CASE when_then_list case_when_else_opt END */ +#line 1171 "sql.y" +{ yylhsminor.yy812 = createRawExprNodeExt(pCxt, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, NULL, yymsp[-2].minor.yy124, yymsp[-1].minor.yy812)); } +#line 7759 "sql.c" + yymsp[-3].minor.yy812 = yylhsminor.yy812; + break; + case 559: /* case_when_expression ::= CASE common_expression when_then_list case_when_else_opt END */ #line 1173 "sql.y" -{ yymsp[-1].minor.yy1000 = releaseRawExprNode(pCxt, yymsp[0].minor.yy1000); } -#line 7709 "sql.c" +{ yylhsminor.yy812 = createRawExprNodeExt(pCxt, &yymsp[-4].minor.yy0, &yymsp[0].minor.yy0, createCaseWhenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy812), yymsp[-2].minor.yy124, yymsp[-1].minor.yy812)); } +#line 7765 "sql.c" + yymsp[-4].minor.yy812 = yylhsminor.yy812; break; - case 560: /* predicate ::= expr_or_subquery compare_op expr_or_subquery */ - case 565: /* predicate ::= expr_or_subquery in_op in_predicate_value */ yytestcase(yyruleno==565); -#line 1176 "sql.y" -{ - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy1000); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy1000); - yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, yymsp[-1].minor.yy324, releaseRawExprNode(pCxt, yymsp[-2].minor.yy1000), releaseRawExprNode(pCxt, yymsp[0].minor.yy1000))); - } -#line 7719 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; + case 562: /* when_then_expr ::= WHEN common_expression THEN common_expression */ +#line 1180 "sql.y" +{ yymsp[-3].minor.yy812 = createWhenThenNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy812), releaseRawExprNode(pCxt, yymsp[0].minor.yy812)); } +#line 7771 "sql.c" break; - case 561: /* predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ + case 564: /* case_when_else_opt ::= ELSE common_expression */ #line 1183 "sql.y" +{ yymsp[-1].minor.yy812 = releaseRawExprNode(pCxt, yymsp[0].minor.yy812); } +#line 7776 "sql.c" + break; + case 565: /* predicate ::= expr_or_subquery compare_op expr_or_subquery */ + case 570: /* predicate ::= expr_or_subquery in_op in_predicate_value */ yytestcase(yyruleno==570); +#line 1186 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy1000); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy1000); - yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &s, &e, createBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-4].minor.yy1000), releaseRawExprNode(pCxt, yymsp[-2].minor.yy1000), releaseRawExprNode(pCxt, yymsp[0].minor.yy1000))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy812); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy812); + yylhsminor.yy812 = createRawExprNodeExt(pCxt, &s, &e, createOperatorNode(pCxt, yymsp[-1].minor.yy590, releaseRawExprNode(pCxt, yymsp[-2].minor.yy812), releaseRawExprNode(pCxt, yymsp[0].minor.yy812))); } -#line 7729 "sql.c" - yymsp[-4].minor.yy1000 = yylhsminor.yy1000; +#line 7786 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 562: /* predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ -#line 1189 "sql.y" + case 566: /* predicate ::= expr_or_subquery BETWEEN expr_or_subquery AND expr_or_subquery */ +#line 1193 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy1000); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy1000); - yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &s, &e, createNotBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy1000), releaseRawExprNode(pCxt, yymsp[-2].minor.yy1000), releaseRawExprNode(pCxt, yymsp[0].minor.yy1000))); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-4].minor.yy812); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy812); + yylhsminor.yy812 = createRawExprNodeExt(pCxt, &s, &e, createBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-4].minor.yy812), releaseRawExprNode(pCxt, yymsp[-2].minor.yy812), releaseRawExprNode(pCxt, yymsp[0].minor.yy812))); } -#line 7739 "sql.c" - yymsp[-5].minor.yy1000 = yylhsminor.yy1000; +#line 7796 "sql.c" + yymsp[-4].minor.yy812 = yylhsminor.yy812; break; - case 563: /* predicate ::= expr_or_subquery IS NULL */ -#line 1194 "sql.y" + case 567: /* predicate ::= expr_or_subquery NOT BETWEEN expr_or_subquery AND expr_or_subquery */ +#line 1199 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy1000); - yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy1000), NULL)); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-5].minor.yy812); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy812); + yylhsminor.yy812 = createRawExprNodeExt(pCxt, &s, &e, createNotBetweenAnd(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy812), releaseRawExprNode(pCxt, yymsp[-2].minor.yy812), releaseRawExprNode(pCxt, yymsp[0].minor.yy812))); } -#line 7748 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +#line 7806 "sql.c" + yymsp[-5].minor.yy812 = yylhsminor.yy812; break; - case 564: /* predicate ::= expr_or_subquery IS NOT NULL */ -#line 1198 "sql.y" + case 568: /* predicate ::= expr_or_subquery IS NULL */ +#line 1204 "sql.y" { - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy1000); - yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy1000), NULL)); + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy812); + yylhsminor.yy812 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NULL, releaseRawExprNode(pCxt, yymsp[-2].minor.yy812), NULL)); } -#line 7757 "sql.c" - yymsp[-3].minor.yy1000 = yylhsminor.yy1000; +#line 7815 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 566: /* compare_op ::= NK_LT */ -#line 1210 "sql.y" -{ yymsp[0].minor.yy324 = OP_TYPE_LOWER_THAN; } -#line 7763 "sql.c" + case 569: /* predicate ::= expr_or_subquery IS NOT NULL */ +#line 1208 "sql.y" +{ + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-3].minor.yy812); + yylhsminor.yy812 = createRawExprNodeExt(pCxt, &s, &yymsp[0].minor.yy0, createOperatorNode(pCxt, OP_TYPE_IS_NOT_NULL, releaseRawExprNode(pCxt, yymsp[-3].minor.yy812), NULL)); + } +#line 7824 "sql.c" + yymsp[-3].minor.yy812 = yylhsminor.yy812; break; - case 567: /* compare_op ::= NK_GT */ -#line 1211 "sql.y" -{ yymsp[0].minor.yy324 = OP_TYPE_GREATER_THAN; } -#line 7768 "sql.c" - break; - case 568: /* compare_op ::= NK_LE */ -#line 1212 "sql.y" -{ yymsp[0].minor.yy324 = OP_TYPE_LOWER_EQUAL; } -#line 7773 "sql.c" - break; - case 569: /* compare_op ::= NK_GE */ -#line 1213 "sql.y" -{ yymsp[0].minor.yy324 = OP_TYPE_GREATER_EQUAL; } -#line 7778 "sql.c" - break; - case 570: /* compare_op ::= NK_NE */ -#line 1214 "sql.y" -{ yymsp[0].minor.yy324 = OP_TYPE_NOT_EQUAL; } -#line 7783 "sql.c" - break; - case 571: /* compare_op ::= NK_EQ */ -#line 1215 "sql.y" -{ yymsp[0].minor.yy324 = OP_TYPE_EQUAL; } -#line 7788 "sql.c" - break; - case 572: /* compare_op ::= LIKE */ -#line 1216 "sql.y" -{ yymsp[0].minor.yy324 = OP_TYPE_LIKE; } -#line 7793 "sql.c" - break; - case 573: /* compare_op ::= NOT LIKE */ -#line 1217 "sql.y" -{ yymsp[-1].minor.yy324 = OP_TYPE_NOT_LIKE; } -#line 7798 "sql.c" - break; - case 574: /* compare_op ::= MATCH */ -#line 1218 "sql.y" -{ yymsp[0].minor.yy324 = OP_TYPE_MATCH; } -#line 7803 "sql.c" - break; - case 575: /* compare_op ::= NMATCH */ -#line 1219 "sql.y" -{ yymsp[0].minor.yy324 = OP_TYPE_NMATCH; } -#line 7808 "sql.c" - break; - case 576: /* compare_op ::= CONTAINS */ + case 571: /* compare_op ::= NK_LT */ #line 1220 "sql.y" -{ yymsp[0].minor.yy324 = OP_TYPE_JSON_CONTAINS; } -#line 7813 "sql.c" +{ yymsp[0].minor.yy590 = OP_TYPE_LOWER_THAN; } +#line 7830 "sql.c" break; - case 577: /* in_op ::= IN */ + case 572: /* compare_op ::= NK_GT */ +#line 1221 "sql.y" +{ yymsp[0].minor.yy590 = OP_TYPE_GREATER_THAN; } +#line 7835 "sql.c" + break; + case 573: /* compare_op ::= NK_LE */ +#line 1222 "sql.y" +{ yymsp[0].minor.yy590 = OP_TYPE_LOWER_EQUAL; } +#line 7840 "sql.c" + break; + case 574: /* compare_op ::= NK_GE */ +#line 1223 "sql.y" +{ yymsp[0].minor.yy590 = OP_TYPE_GREATER_EQUAL; } +#line 7845 "sql.c" + break; + case 575: /* compare_op ::= NK_NE */ #line 1224 "sql.y" -{ yymsp[0].minor.yy324 = OP_TYPE_IN; } -#line 7818 "sql.c" +{ yymsp[0].minor.yy590 = OP_TYPE_NOT_EQUAL; } +#line 7850 "sql.c" break; - case 578: /* in_op ::= NOT IN */ + case 576: /* compare_op ::= NK_EQ */ #line 1225 "sql.y" -{ yymsp[-1].minor.yy324 = OP_TYPE_NOT_IN; } -#line 7823 "sql.c" +{ yymsp[0].minor.yy590 = OP_TYPE_EQUAL; } +#line 7855 "sql.c" break; - case 579: /* in_predicate_value ::= NK_LP literal_list NK_RP */ + case 577: /* compare_op ::= LIKE */ +#line 1226 "sql.y" +{ yymsp[0].minor.yy590 = OP_TYPE_LIKE; } +#line 7860 "sql.c" + break; + case 578: /* compare_op ::= NOT LIKE */ #line 1227 "sql.y" -{ yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy72)); } -#line 7828 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yymsp[-1].minor.yy590 = OP_TYPE_NOT_LIKE; } +#line 7865 "sql.c" break; - case 581: /* boolean_value_expression ::= NOT boolean_primary */ -#line 1231 "sql.y" -{ - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy1000); - yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy1000), NULL)); - } -#line 7837 "sql.c" - yymsp[-1].minor.yy1000 = yylhsminor.yy1000; + case 579: /* compare_op ::= MATCH */ +#line 1228 "sql.y" +{ yymsp[0].minor.yy590 = OP_TYPE_MATCH; } +#line 7870 "sql.c" break; - case 582: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ -#line 1236 "sql.y" -{ - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy1000); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy1000); - yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy1000), releaseRawExprNode(pCxt, yymsp[0].minor.yy1000))); - } -#line 7847 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; - break; - case 583: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ -#line 1242 "sql.y" -{ - SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy1000); - SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy1000); - yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy1000), releaseRawExprNode(pCxt, yymsp[0].minor.yy1000))); - } -#line 7857 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; - break; - case 591: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */ -#line 1260 "sql.y" -{ yylhsminor.yy1000 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy1000, yymsp[0].minor.yy1000, NULL); } -#line 7863 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; - break; - case 594: /* table_primary ::= table_name alias_opt */ -#line 1266 "sql.y" -{ yylhsminor.yy1000 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy305, &yymsp[0].minor.yy305); } -#line 7869 "sql.c" - yymsp[-1].minor.yy1000 = yylhsminor.yy1000; - break; - case 595: /* table_primary ::= db_name NK_DOT table_name alias_opt */ -#line 1267 "sql.y" -{ yylhsminor.yy1000 = createRealTableNode(pCxt, &yymsp[-3].minor.yy305, &yymsp[-1].minor.yy305, &yymsp[0].minor.yy305); } + case 580: /* compare_op ::= NMATCH */ +#line 1229 "sql.y" +{ yymsp[0].minor.yy590 = OP_TYPE_NMATCH; } #line 7875 "sql.c" - yymsp[-3].minor.yy1000 = yylhsminor.yy1000; break; - case 596: /* table_primary ::= subquery alias_opt */ -#line 1268 "sql.y" -{ yylhsminor.yy1000 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy1000), &yymsp[0].minor.yy305); } -#line 7881 "sql.c" - yymsp[-1].minor.yy1000 = yylhsminor.yy1000; + case 581: /* compare_op ::= CONTAINS */ +#line 1230 "sql.y" +{ yymsp[0].minor.yy590 = OP_TYPE_JSON_CONTAINS; } +#line 7880 "sql.c" break; - case 598: /* alias_opt ::= */ -#line 1273 "sql.y" -{ yymsp[1].minor.yy305 = nil_token; } -#line 7887 "sql.c" + case 582: /* in_op ::= IN */ +#line 1234 "sql.y" +{ yymsp[0].minor.yy590 = OP_TYPE_IN; } +#line 7885 "sql.c" break; - case 600: /* alias_opt ::= AS table_alias */ -#line 1275 "sql.y" -{ yymsp[-1].minor.yy305 = yymsp[0].minor.yy305; } -#line 7892 "sql.c" + case 583: /* in_op ::= NOT IN */ +#line 1235 "sql.y" +{ yymsp[-1].minor.yy590 = OP_TYPE_NOT_IN; } +#line 7890 "sql.c" break; - case 601: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */ - case 602: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==602); -#line 1277 "sql.y" -{ yymsp[-2].minor.yy1000 = yymsp[-1].minor.yy1000; } -#line 7898 "sql.c" + case 584: /* in_predicate_value ::= NK_LP literal_list NK_RP */ +#line 1237 "sql.y" +{ yylhsminor.yy812 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, createNodeListNode(pCxt, yymsp[-1].minor.yy124)); } +#line 7895 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 603: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ -#line 1282 "sql.y" -{ yylhsminor.yy1000 = createJoinTableNode(pCxt, yymsp[-4].minor.yy828, yymsp[-5].minor.yy1000, yymsp[-2].minor.yy1000, yymsp[0].minor.yy1000); } -#line 7903 "sql.c" - yymsp[-5].minor.yy1000 = yylhsminor.yy1000; - break; - case 604: /* join_type ::= */ -#line 1286 "sql.y" -{ yymsp[1].minor.yy828 = JOIN_TYPE_INNER; } -#line 7909 "sql.c" - break; - case 605: /* join_type ::= INNER */ -#line 1287 "sql.y" -{ yymsp[0].minor.yy828 = JOIN_TYPE_INNER; } -#line 7914 "sql.c" - break; - case 606: /* query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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 */ -#line 1293 "sql.y" + case 586: /* boolean_value_expression ::= NOT boolean_primary */ +#line 1241 "sql.y" { - yymsp[-13].minor.yy1000 = createSelectStmt(pCxt, yymsp[-11].minor.yy985, yymsp[-9].minor.yy72, yymsp[-8].minor.yy1000, yymsp[-12].minor.yy72); - yymsp[-13].minor.yy1000 = setSelectStmtTagMode(pCxt, yymsp[-13].minor.yy1000, yymsp[-10].minor.yy985); - yymsp[-13].minor.yy1000 = addWhereClause(pCxt, yymsp[-13].minor.yy1000, yymsp[-7].minor.yy1000); - yymsp[-13].minor.yy1000 = addPartitionByClause(pCxt, yymsp[-13].minor.yy1000, yymsp[-6].minor.yy72); - yymsp[-13].minor.yy1000 = addWindowClauseClause(pCxt, yymsp[-13].minor.yy1000, yymsp[-2].minor.yy1000); - yymsp[-13].minor.yy1000 = addGroupByClause(pCxt, yymsp[-13].minor.yy1000, yymsp[-1].minor.yy72); - yymsp[-13].minor.yy1000 = addHavingClause(pCxt, yymsp[-13].minor.yy1000, yymsp[0].minor.yy1000); - yymsp[-13].minor.yy1000 = addRangeClause(pCxt, yymsp[-13].minor.yy1000, yymsp[-5].minor.yy1000); - yymsp[-13].minor.yy1000 = addEveryClause(pCxt, yymsp[-13].minor.yy1000, yymsp[-4].minor.yy1000); - yymsp[-13].minor.yy1000 = addFillClause(pCxt, yymsp[-13].minor.yy1000, yymsp[-3].minor.yy1000); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy812); + yylhsminor.yy812 = createRawExprNodeExt(pCxt, &yymsp[-1].minor.yy0, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_NOT, releaseRawExprNode(pCxt, yymsp[0].minor.yy812), NULL)); } +#line 7904 "sql.c" + yymsp[-1].minor.yy812 = yylhsminor.yy812; + break; + case 587: /* boolean_value_expression ::= boolean_value_expression OR boolean_value_expression */ +#line 1246 "sql.y" +{ + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy812); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy812); + yylhsminor.yy812 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, releaseRawExprNode(pCxt, yymsp[-2].minor.yy812), releaseRawExprNode(pCxt, yymsp[0].minor.yy812))); + } +#line 7914 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; + break; + case 588: /* boolean_value_expression ::= boolean_value_expression AND boolean_value_expression */ +#line 1252 "sql.y" +{ + SToken s = getTokenFromRawExprNode(pCxt, yymsp[-2].minor.yy812); + SToken e = getTokenFromRawExprNode(pCxt, yymsp[0].minor.yy812); + yylhsminor.yy812 = createRawExprNodeExt(pCxt, &s, &e, createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND, releaseRawExprNode(pCxt, yymsp[-2].minor.yy812), releaseRawExprNode(pCxt, yymsp[0].minor.yy812))); + } +#line 7924 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; + break; + case 596: /* table_reference_list ::= table_reference_list NK_COMMA table_reference */ +#line 1270 "sql.y" +{ yylhsminor.yy812 = createJoinTableNode(pCxt, JOIN_TYPE_INNER, yymsp[-2].minor.yy812, yymsp[0].minor.yy812, NULL); } #line 7930 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 607: /* hint_list ::= */ -#line 1308 "sql.y" -{ yymsp[1].minor.yy72 = createHintNodeList(pCxt, NULL); } -#line 7935 "sql.c" + case 599: /* table_primary ::= table_name alias_opt */ +#line 1276 "sql.y" +{ yylhsminor.yy812 = createRealTableNode(pCxt, NULL, &yymsp[-1].minor.yy29, &yymsp[0].minor.yy29); } +#line 7936 "sql.c" + yymsp[-1].minor.yy812 = yylhsminor.yy812; break; - case 608: /* hint_list ::= NK_HINT */ -#line 1309 "sql.y" -{ yylhsminor.yy72 = createHintNodeList(pCxt, &yymsp[0].minor.yy0); } -#line 7940 "sql.c" - yymsp[0].minor.yy72 = yylhsminor.yy72; + case 600: /* table_primary ::= db_name NK_DOT table_name alias_opt */ +#line 1277 "sql.y" +{ yylhsminor.yy812 = createRealTableNode(pCxt, &yymsp[-3].minor.yy29, &yymsp[-1].minor.yy29, &yymsp[0].minor.yy29); } +#line 7942 "sql.c" + yymsp[-3].minor.yy812 = yylhsminor.yy812; break; - case 613: /* set_quantifier_opt ::= ALL */ -#line 1320 "sql.y" -{ yymsp[0].minor.yy985 = false; } -#line 7946 "sql.c" + case 601: /* table_primary ::= subquery alias_opt */ +#line 1278 "sql.y" +{ yylhsminor.yy812 = createTempTableNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy812), &yymsp[0].minor.yy29); } +#line 7948 "sql.c" + yymsp[-1].minor.yy812 = yylhsminor.yy812; break; - case 616: /* select_item ::= NK_STAR */ -#line 1327 "sql.y" -{ yylhsminor.yy1000 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0); } -#line 7951 "sql.c" - yymsp[0].minor.yy1000 = yylhsminor.yy1000; + case 603: /* alias_opt ::= */ +#line 1283 "sql.y" +{ yymsp[1].minor.yy29 = nil_token; } +#line 7954 "sql.c" break; - case 618: /* select_item ::= common_expression column_alias */ - case 628: /* partition_item ::= expr_or_subquery column_alias */ yytestcase(yyruleno==628); -#line 1329 "sql.y" -{ yylhsminor.yy1000 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy1000), &yymsp[0].minor.yy305); } -#line 7958 "sql.c" - yymsp[-1].minor.yy1000 = yylhsminor.yy1000; + case 605: /* alias_opt ::= AS table_alias */ +#line 1285 "sql.y" +{ yymsp[-1].minor.yy29 = yymsp[0].minor.yy29; } +#line 7959 "sql.c" break; - case 619: /* select_item ::= common_expression AS column_alias */ - case 629: /* partition_item ::= expr_or_subquery AS column_alias */ yytestcase(yyruleno==629); -#line 1330 "sql.y" -{ yylhsminor.yy1000 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy1000), &yymsp[0].minor.yy305); } + case 606: /* parenthesized_joined_table ::= NK_LP joined_table NK_RP */ + case 607: /* parenthesized_joined_table ::= NK_LP parenthesized_joined_table NK_RP */ yytestcase(yyruleno==607); +#line 1287 "sql.y" +{ yymsp[-2].minor.yy812 = yymsp[-1].minor.yy812; } #line 7965 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; break; - case 624: /* partition_by_clause_opt ::= PARTITION BY partition_list */ - case 654: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==654); - case 674: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==674); -#line 1339 "sql.y" -{ yymsp[-2].minor.yy72 = yymsp[0].minor.yy72; } -#line 7973 "sql.c" + case 608: /* joined_table ::= table_reference join_type JOIN table_reference ON search_condition */ +#line 1292 "sql.y" +{ yylhsminor.yy812 = createJoinTableNode(pCxt, yymsp[-4].minor.yy162, yymsp[-5].minor.yy812, yymsp[-2].minor.yy812, yymsp[0].minor.yy812); } +#line 7970 "sql.c" + yymsp[-5].minor.yy812 = yylhsminor.yy812; break; - case 631: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP */ -#line 1352 "sql.y" -{ yymsp[-5].minor.yy1000 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy1000), releaseRawExprNode(pCxt, yymsp[-1].minor.yy1000)); } -#line 7978 "sql.c" + case 609: /* join_type ::= */ +#line 1296 "sql.y" +{ yymsp[1].minor.yy162 = JOIN_TYPE_INNER; } +#line 7976 "sql.c" break; - case 632: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ -#line 1353 "sql.y" -{ yymsp[-3].minor.yy1000 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy1000)); } -#line 7983 "sql.c" + case 610: /* join_type ::= INNER */ +#line 1297 "sql.y" +{ yymsp[0].minor.yy162 = JOIN_TYPE_INNER; } +#line 7981 "sql.c" break; - case 633: /* twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ -#line 1355 "sql.y" -{ yymsp[-5].minor.yy1000 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy1000), NULL, yymsp[-1].minor.yy1000, yymsp[0].minor.yy1000); } -#line 7988 "sql.c" + case 611: /* query_specification ::= SELECT hint_list set_quantifier_opt tag_mode_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 */ +#line 1303 "sql.y" +{ + yymsp[-13].minor.yy812 = createSelectStmt(pCxt, yymsp[-11].minor.yy887, yymsp[-9].minor.yy124, yymsp[-8].minor.yy812, yymsp[-12].minor.yy124); + yymsp[-13].minor.yy812 = setSelectStmtTagMode(pCxt, yymsp[-13].minor.yy812, yymsp[-10].minor.yy887); + yymsp[-13].minor.yy812 = addWhereClause(pCxt, yymsp[-13].minor.yy812, yymsp[-7].minor.yy812); + yymsp[-13].minor.yy812 = addPartitionByClause(pCxt, yymsp[-13].minor.yy812, yymsp[-6].minor.yy124); + yymsp[-13].minor.yy812 = addWindowClauseClause(pCxt, yymsp[-13].minor.yy812, yymsp[-2].minor.yy812); + yymsp[-13].minor.yy812 = addGroupByClause(pCxt, yymsp[-13].minor.yy812, yymsp[-1].minor.yy124); + yymsp[-13].minor.yy812 = addHavingClause(pCxt, yymsp[-13].minor.yy812, yymsp[0].minor.yy812); + yymsp[-13].minor.yy812 = addRangeClause(pCxt, yymsp[-13].minor.yy812, yymsp[-5].minor.yy812); + yymsp[-13].minor.yy812 = addEveryClause(pCxt, yymsp[-13].minor.yy812, yymsp[-4].minor.yy812); + yymsp[-13].minor.yy812 = addFillClause(pCxt, yymsp[-13].minor.yy812, yymsp[-3].minor.yy812); + } +#line 7997 "sql.c" break; - case 634: /* twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ -#line 1359 "sql.y" -{ yymsp[-7].minor.yy1000 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy1000), releaseRawExprNode(pCxt, yymsp[-3].minor.yy1000), yymsp[-1].minor.yy1000, yymsp[0].minor.yy1000); } -#line 7993 "sql.c" + case 612: /* hint_list ::= */ +#line 1318 "sql.y" +{ yymsp[1].minor.yy124 = createHintNodeList(pCxt, NULL); } +#line 8002 "sql.c" break; - case 635: /* twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ -#line 1361 "sql.y" -{ yymsp[-6].minor.yy1000 = createEventWindowNode(pCxt, yymsp[-3].minor.yy1000, yymsp[0].minor.yy1000); } -#line 7998 "sql.c" + case 613: /* hint_list ::= NK_HINT */ +#line 1319 "sql.y" +{ yylhsminor.yy124 = createHintNodeList(pCxt, &yymsp[0].minor.yy0); } +#line 8007 "sql.c" + yymsp[0].minor.yy124 = yylhsminor.yy124; break; - case 636: /* twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_RP */ -#line 1363 "sql.y" -{ yymsp[-3].minor.yy1000 = createCountWindowNode(pCxt, &yymsp[-1].minor.yy0, &yymsp[-1].minor.yy0); } -#line 8003 "sql.c" - break; - case 637: /* twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ -#line 1365 "sql.y" -{ yymsp[-5].minor.yy1000 = createCountWindowNode(pCxt, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0); } -#line 8008 "sql.c" - break; - case 644: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ -#line 1375 "sql.y" -{ yymsp[-3].minor.yy1000 = createFillNode(pCxt, yymsp[-1].minor.yy926, NULL); } + case 618: /* set_quantifier_opt ::= ALL */ +#line 1330 "sql.y" +{ yymsp[0].minor.yy887 = false; } #line 8013 "sql.c" break; - case 645: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ -#line 1376 "sql.y" -{ yymsp[-5].minor.yy1000 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy72)); } + case 621: /* select_item ::= NK_STAR */ +#line 1337 "sql.y" +{ yylhsminor.yy812 = createColumnNode(pCxt, NULL, &yymsp[0].minor.yy0); } #line 8018 "sql.c" + yymsp[0].minor.yy812 = yylhsminor.yy812; break; - case 646: /* fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ -#line 1377 "sql.y" -{ yymsp[-5].minor.yy1000 = createFillNode(pCxt, FILL_MODE_VALUE_F, createNodeListNode(pCxt, yymsp[-1].minor.yy72)); } -#line 8023 "sql.c" + case 623: /* select_item ::= common_expression column_alias */ + case 633: /* partition_item ::= expr_or_subquery column_alias */ yytestcase(yyruleno==633); +#line 1339 "sql.y" +{ yylhsminor.yy812 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy812), &yymsp[0].minor.yy29); } +#line 8025 "sql.c" + yymsp[-1].minor.yy812 = yylhsminor.yy812; break; - case 647: /* fill_mode ::= NONE */ -#line 1381 "sql.y" -{ yymsp[0].minor.yy926 = FILL_MODE_NONE; } -#line 8028 "sql.c" + case 624: /* select_item ::= common_expression AS column_alias */ + case 634: /* partition_item ::= expr_or_subquery AS column_alias */ yytestcase(yyruleno==634); +#line 1340 "sql.y" +{ yylhsminor.yy812 = setProjectionAlias(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy812), &yymsp[0].minor.yy29); } +#line 8032 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 648: /* fill_mode ::= PREV */ -#line 1382 "sql.y" -{ yymsp[0].minor.yy926 = FILL_MODE_PREV; } -#line 8033 "sql.c" + case 629: /* partition_by_clause_opt ::= PARTITION BY partition_list */ + case 659: /* group_by_clause_opt ::= GROUP BY group_by_list */ yytestcase(yyruleno==659); + case 679: /* order_by_clause_opt ::= ORDER BY sort_specification_list */ yytestcase(yyruleno==679); +#line 1349 "sql.y" +{ yymsp[-2].minor.yy124 = yymsp[0].minor.yy124; } +#line 8040 "sql.c" break; - case 649: /* fill_mode ::= NULL */ -#line 1383 "sql.y" -{ yymsp[0].minor.yy926 = FILL_MODE_NULL; } -#line 8038 "sql.c" + case 636: /* twindow_clause_opt ::= SESSION NK_LP column_reference NK_COMMA interval_sliding_duration_literal NK_RP */ +#line 1362 "sql.y" +{ yymsp[-5].minor.yy812 = createSessionWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy812), releaseRawExprNode(pCxt, yymsp[-1].minor.yy812)); } +#line 8045 "sql.c" break; - case 650: /* fill_mode ::= NULL_F */ -#line 1384 "sql.y" -{ yymsp[0].minor.yy926 = FILL_MODE_NULL_F; } -#line 8043 "sql.c" + case 637: /* twindow_clause_opt ::= STATE_WINDOW NK_LP expr_or_subquery NK_RP */ +#line 1363 "sql.y" +{ yymsp[-3].minor.yy812 = createStateWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy812)); } +#line 8050 "sql.c" break; - case 651: /* fill_mode ::= LINEAR */ -#line 1385 "sql.y" -{ yymsp[0].minor.yy926 = FILL_MODE_LINEAR; } -#line 8048 "sql.c" + case 638: /* twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ +#line 1365 "sql.y" +{ yymsp[-5].minor.yy812 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy812), NULL, yymsp[-1].minor.yy812, yymsp[0].minor.yy812); } +#line 8055 "sql.c" break; - case 652: /* fill_mode ::= NEXT */ -#line 1386 "sql.y" -{ yymsp[0].minor.yy926 = FILL_MODE_NEXT; } -#line 8053 "sql.c" + case 639: /* twindow_clause_opt ::= INTERVAL NK_LP interval_sliding_duration_literal NK_COMMA interval_sliding_duration_literal NK_RP sliding_opt fill_opt */ +#line 1369 "sql.y" +{ yymsp[-7].minor.yy812 = createIntervalWindowNode(pCxt, releaseRawExprNode(pCxt, yymsp[-5].minor.yy812), releaseRawExprNode(pCxt, yymsp[-3].minor.yy812), yymsp[-1].minor.yy812, yymsp[0].minor.yy812); } +#line 8060 "sql.c" break; - case 655: /* group_by_list ::= expr_or_subquery */ -#line 1395 "sql.y" -{ yylhsminor.yy72 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy1000))); } -#line 8058 "sql.c" - yymsp[0].minor.yy72 = yylhsminor.yy72; + case 640: /* twindow_clause_opt ::= EVENT_WINDOW START WITH search_condition END WITH search_condition */ +#line 1371 "sql.y" +{ yymsp[-6].minor.yy812 = createEventWindowNode(pCxt, yymsp[-3].minor.yy812, yymsp[0].minor.yy812); } +#line 8065 "sql.c" break; - case 656: /* group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ -#line 1396 "sql.y" -{ yylhsminor.yy72 = addNodeToList(pCxt, yymsp[-2].minor.yy72, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy1000))); } -#line 8064 "sql.c" - yymsp[-2].minor.yy72 = yylhsminor.yy72; - break; - case 660: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ -#line 1403 "sql.y" -{ yymsp[-5].minor.yy1000 = createInterpTimeRange(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy1000), releaseRawExprNode(pCxt, yymsp[-1].minor.yy1000)); } + case 641: /* twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_RP */ +#line 1373 "sql.y" +{ yymsp[-3].minor.yy812 = createCountWindowNode(pCxt, &yymsp[-1].minor.yy0, &yymsp[-1].minor.yy0); } #line 8070 "sql.c" break; - case 661: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ -#line 1405 "sql.y" -{ yymsp[-3].minor.yy1000 = createInterpTimePoint(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy1000)); } + case 642: /* twindow_clause_opt ::= COUNT_WINDOW NK_LP NK_INTEGER NK_COMMA NK_INTEGER NK_RP */ +#line 1375 "sql.y" +{ yymsp[-5].minor.yy812 = createCountWindowNode(pCxt, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0); } #line 8075 "sql.c" break; - case 664: /* query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ -#line 1412 "sql.y" -{ - yylhsminor.yy1000 = addOrderByClause(pCxt, yymsp[-3].minor.yy1000, yymsp[-2].minor.yy72); - yylhsminor.yy1000 = addSlimitClause(pCxt, yylhsminor.yy1000, yymsp[-1].minor.yy1000); - yylhsminor.yy1000 = addLimitClause(pCxt, yylhsminor.yy1000, yymsp[0].minor.yy1000); - } -#line 8084 "sql.c" - yymsp[-3].minor.yy1000 = yylhsminor.yy1000; + case 649: /* fill_opt ::= FILL NK_LP fill_mode NK_RP */ +#line 1385 "sql.y" +{ yymsp[-3].minor.yy812 = createFillNode(pCxt, yymsp[-1].minor.yy144, NULL); } +#line 8080 "sql.c" break; - case 667: /* union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ -#line 1422 "sql.y" -{ yylhsminor.yy1000 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy1000, yymsp[0].minor.yy1000); } + case 650: /* fill_opt ::= FILL NK_LP VALUE NK_COMMA expression_list NK_RP */ +#line 1386 "sql.y" +{ yymsp[-5].minor.yy812 = createFillNode(pCxt, FILL_MODE_VALUE, createNodeListNode(pCxt, yymsp[-1].minor.yy124)); } +#line 8085 "sql.c" + break; + case 651: /* fill_opt ::= FILL NK_LP VALUE_F NK_COMMA expression_list NK_RP */ +#line 1387 "sql.y" +{ yymsp[-5].minor.yy812 = createFillNode(pCxt, FILL_MODE_VALUE_F, createNodeListNode(pCxt, yymsp[-1].minor.yy124)); } #line 8090 "sql.c" - yymsp[-3].minor.yy1000 = yylhsminor.yy1000; break; - case 668: /* union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ -#line 1424 "sql.y" -{ yylhsminor.yy1000 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy1000, yymsp[0].minor.yy1000); } -#line 8096 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; + case 652: /* fill_mode ::= NONE */ +#line 1391 "sql.y" +{ yymsp[0].minor.yy144 = FILL_MODE_NONE; } +#line 8095 "sql.c" break; - case 676: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ - case 680: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==680); -#line 1438 "sql.y" -{ yymsp[-1].minor.yy1000 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); } -#line 8103 "sql.c" + case 653: /* fill_mode ::= PREV */ +#line 1392 "sql.y" +{ yymsp[0].minor.yy144 = FILL_MODE_PREV; } +#line 8100 "sql.c" break; - case 677: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ - case 681: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==681); -#line 1439 "sql.y" -{ yymsp[-3].minor.yy1000 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } -#line 8109 "sql.c" + case 654: /* fill_mode ::= NULL */ +#line 1393 "sql.y" +{ yymsp[0].minor.yy144 = FILL_MODE_NULL; } +#line 8105 "sql.c" break; - case 678: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ - case 682: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==682); -#line 1440 "sql.y" -{ yymsp[-3].minor.yy1000 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); } + case 655: /* fill_mode ::= NULL_F */ +#line 1394 "sql.y" +{ yymsp[0].minor.yy144 = FILL_MODE_NULL_F; } +#line 8110 "sql.c" + break; + case 656: /* fill_mode ::= LINEAR */ +#line 1395 "sql.y" +{ yymsp[0].minor.yy144 = FILL_MODE_LINEAR; } #line 8115 "sql.c" break; - case 683: /* subquery ::= NK_LP query_expression NK_RP */ -#line 1448 "sql.y" -{ yylhsminor.yy1000 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy1000); } + case 657: /* fill_mode ::= NEXT */ +#line 1396 "sql.y" +{ yymsp[0].minor.yy144 = FILL_MODE_NEXT; } #line 8120 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; break; - case 688: /* sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ -#line 1462 "sql.y" -{ yylhsminor.yy1000 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy1000), yymsp[-1].minor.yy130, yymsp[0].minor.yy681); } -#line 8126 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; + case 660: /* group_by_list ::= expr_or_subquery */ +#line 1405 "sql.y" +{ yylhsminor.yy124 = createNodeList(pCxt, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy812))); } +#line 8125 "sql.c" + yymsp[0].minor.yy124 = yylhsminor.yy124; break; - case 689: /* ordering_specification_opt ::= */ -#line 1466 "sql.y" -{ yymsp[1].minor.yy130 = ORDER_ASC; } -#line 8132 "sql.c" + case 661: /* group_by_list ::= group_by_list NK_COMMA expr_or_subquery */ +#line 1406 "sql.y" +{ yylhsminor.yy124 = addNodeToList(pCxt, yymsp[-2].minor.yy124, createGroupingSetNode(pCxt, releaseRawExprNode(pCxt, yymsp[0].minor.yy812))); } +#line 8131 "sql.c" + yymsp[-2].minor.yy124 = yylhsminor.yy124; break; - case 690: /* ordering_specification_opt ::= ASC */ -#line 1467 "sql.y" -{ yymsp[0].minor.yy130 = ORDER_ASC; } + case 665: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_COMMA expr_or_subquery NK_RP */ +#line 1413 "sql.y" +{ yymsp[-5].minor.yy812 = createInterpTimeRange(pCxt, releaseRawExprNode(pCxt, yymsp[-3].minor.yy812), releaseRawExprNode(pCxt, yymsp[-1].minor.yy812)); } #line 8137 "sql.c" break; - case 691: /* ordering_specification_opt ::= DESC */ -#line 1468 "sql.y" -{ yymsp[0].minor.yy130 = ORDER_DESC; } + case 666: /* range_opt ::= RANGE NK_LP expr_or_subquery NK_RP */ +#line 1415 "sql.y" +{ yymsp[-3].minor.yy812 = createInterpTimePoint(pCxt, releaseRawExprNode(pCxt, yymsp[-1].minor.yy812)); } #line 8142 "sql.c" break; - case 692: /* null_ordering_opt ::= */ -#line 1472 "sql.y" -{ yymsp[1].minor.yy681 = NULL_ORDER_DEFAULT; } -#line 8147 "sql.c" + case 669: /* query_expression ::= query_simple order_by_clause_opt slimit_clause_opt limit_clause_opt */ +#line 1422 "sql.y" +{ + yylhsminor.yy812 = addOrderByClause(pCxt, yymsp[-3].minor.yy812, yymsp[-2].minor.yy124); + yylhsminor.yy812 = addSlimitClause(pCxt, yylhsminor.yy812, yymsp[-1].minor.yy812); + yylhsminor.yy812 = addLimitClause(pCxt, yylhsminor.yy812, yymsp[0].minor.yy812); + } +#line 8151 "sql.c" + yymsp[-3].minor.yy812 = yylhsminor.yy812; break; - case 693: /* null_ordering_opt ::= NULLS FIRST */ -#line 1473 "sql.y" -{ yymsp[-1].minor.yy681 = NULL_ORDER_FIRST; } -#line 8152 "sql.c" - break; - case 694: /* null_ordering_opt ::= NULLS LAST */ -#line 1474 "sql.y" -{ yymsp[-1].minor.yy681 = NULL_ORDER_LAST; } + case 672: /* union_query_expression ::= query_simple_or_subquery UNION ALL query_simple_or_subquery */ +#line 1432 "sql.y" +{ yylhsminor.yy812 = createSetOperator(pCxt, SET_OP_TYPE_UNION_ALL, yymsp[-3].minor.yy812, yymsp[0].minor.yy812); } #line 8157 "sql.c" + yymsp[-3].minor.yy812 = yylhsminor.yy812; break; - case 695: /* column_options ::= */ -#line 1480 "sql.y" -{ yymsp[1].minor.yy1000 = createDefaultColumnOptions(pCxt); } -#line 8162 "sql.c" + case 673: /* union_query_expression ::= query_simple_or_subquery UNION query_simple_or_subquery */ +#line 1434 "sql.y" +{ yylhsminor.yy812 = createSetOperator(pCxt, SET_OP_TYPE_UNION, yymsp[-2].minor.yy812, yymsp[0].minor.yy812); } +#line 8163 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; - case 696: /* column_options ::= column_options PRIMARY KEY */ -#line 1481 "sql.y" -{ yylhsminor.yy1000 = setColumnOptions(pCxt, yymsp[-2].minor.yy1000, COLUMN_OPTION_PRIMARYKEY, NULL); } -#line 8167 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; + case 681: /* slimit_clause_opt ::= SLIMIT NK_INTEGER */ + case 685: /* limit_clause_opt ::= LIMIT NK_INTEGER */ yytestcase(yyruleno==685); +#line 1448 "sql.y" +{ yymsp[-1].minor.yy812 = createLimitNode(pCxt, &yymsp[0].minor.yy0, NULL); } +#line 8170 "sql.c" break; - case 697: /* column_options ::= column_options ENCODE NK_STRING */ + case 682: /* slimit_clause_opt ::= SLIMIT NK_INTEGER SOFFSET NK_INTEGER */ + case 686: /* limit_clause_opt ::= LIMIT NK_INTEGER OFFSET NK_INTEGER */ yytestcase(yyruleno==686); +#line 1449 "sql.y" +{ yymsp[-3].minor.yy812 = createLimitNode(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); } +#line 8176 "sql.c" + break; + case 683: /* slimit_clause_opt ::= SLIMIT NK_INTEGER NK_COMMA NK_INTEGER */ + case 687: /* limit_clause_opt ::= LIMIT NK_INTEGER NK_COMMA NK_INTEGER */ yytestcase(yyruleno==687); +#line 1450 "sql.y" +{ yymsp[-3].minor.yy812 = createLimitNode(pCxt, &yymsp[0].minor.yy0, &yymsp[-2].minor.yy0); } +#line 8182 "sql.c" + break; + case 688: /* subquery ::= NK_LP query_expression NK_RP */ +#line 1458 "sql.y" +{ yylhsminor.yy812 = createRawExprNodeExt(pCxt, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-1].minor.yy812); } +#line 8187 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; + break; + case 693: /* sort_specification ::= expr_or_subquery ordering_specification_opt null_ordering_opt */ +#line 1472 "sql.y" +{ yylhsminor.yy812 = createOrderByExprNode(pCxt, releaseRawExprNode(pCxt, yymsp[-2].minor.yy812), yymsp[-1].minor.yy638, yymsp[0].minor.yy907); } +#line 8193 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; + break; + case 694: /* ordering_specification_opt ::= */ +#line 1476 "sql.y" +{ yymsp[1].minor.yy638 = ORDER_ASC; } +#line 8199 "sql.c" + break; + case 695: /* ordering_specification_opt ::= ASC */ +#line 1477 "sql.y" +{ yymsp[0].minor.yy638 = ORDER_ASC; } +#line 8204 "sql.c" + break; + case 696: /* ordering_specification_opt ::= DESC */ +#line 1478 "sql.y" +{ yymsp[0].minor.yy638 = ORDER_DESC; } +#line 8209 "sql.c" + break; + case 697: /* null_ordering_opt ::= */ #line 1482 "sql.y" -{ yylhsminor.yy1000 = setColumnOptions(pCxt, yymsp[-2].minor.yy1000, COLUMN_OPTION_ENCODE, &yymsp[0].minor.yy0); } -#line 8173 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yymsp[1].minor.yy907 = NULL_ORDER_DEFAULT; } +#line 8214 "sql.c" break; - case 698: /* column_options ::= column_options COMPRESS NK_STRING */ + case 698: /* null_ordering_opt ::= NULLS FIRST */ #line 1483 "sql.y" -{ yylhsminor.yy1000 = setColumnOptions(pCxt, yymsp[-2].minor.yy1000, COLUMN_OPTION_COMPRESS, &yymsp[0].minor.yy0); } -#line 8179 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yymsp[-1].minor.yy907 = NULL_ORDER_FIRST; } +#line 8219 "sql.c" break; - case 699: /* column_options ::= column_options LEVEL NK_STRING */ + case 699: /* null_ordering_opt ::= NULLS LAST */ #line 1484 "sql.y" -{ yylhsminor.yy1000 = setColumnOptions(pCxt, yymsp[-2].minor.yy1000, COLUMN_OPTION_LEVEL, &yymsp[0].minor.yy0); } -#line 8185 "sql.c" - yymsp[-2].minor.yy1000 = yylhsminor.yy1000; +{ yymsp[-1].minor.yy907 = NULL_ORDER_LAST; } +#line 8224 "sql.c" + break; + case 700: /* column_options ::= */ +#line 1490 "sql.y" +{ yymsp[1].minor.yy812 = createDefaultColumnOptions(pCxt); } +#line 8229 "sql.c" + break; + case 701: /* column_options ::= column_options PRIMARY KEY */ +#line 1491 "sql.y" +{ yylhsminor.yy812 = setColumnOptions(pCxt, yymsp[-2].minor.yy812, COLUMN_OPTION_PRIMARYKEY, NULL); } +#line 8234 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; + break; + case 702: /* column_options ::= column_options ENCODE NK_STRING */ +#line 1492 "sql.y" +{ yylhsminor.yy812 = setColumnOptions(pCxt, yymsp[-2].minor.yy812, COLUMN_OPTION_ENCODE, &yymsp[0].minor.yy0); } +#line 8240 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; + break; + case 703: /* column_options ::= column_options COMPRESS NK_STRING */ +#line 1493 "sql.y" +{ yylhsminor.yy812 = setColumnOptions(pCxt, yymsp[-2].minor.yy812, COLUMN_OPTION_COMPRESS, &yymsp[0].minor.yy0); } +#line 8246 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; + break; + case 704: /* column_options ::= column_options LEVEL NK_STRING */ +#line 1494 "sql.y" +{ yylhsminor.yy812 = setColumnOptions(pCxt, yymsp[-2].minor.yy812, COLUMN_OPTION_LEVEL, &yymsp[0].minor.yy0); } +#line 8252 "sql.c" + yymsp[-2].minor.yy812 = yylhsminor.yy812; break; default: break; @@ -8256,7 +8323,7 @@ static void yy_syntax_error( } else if (TSDB_CODE_PAR_DB_NOT_SPECIFIED == pCxt->errCode && TK_NK_FLOAT == TOKEN.type) { pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_SYNTAX_ERROR, TOKEN.z); } -#line 8259 "sql.c" +#line 8326 "sql.c" /************ End %syntax_error code ******************************************/ ParseARG_STORE /* Suppress warning about unused %extra_argument variable */ ParseCTX_STORE diff --git a/source/libs/planner/src/planLogicCreater.c b/source/libs/planner/src/planLogicCreater.c index b5236fee9e..ef2f360a4e 100644 --- a/source/libs/planner/src/planLogicCreater.c +++ b/source/libs/planner/src/planLogicCreater.c @@ -521,6 +521,9 @@ static int32_t createScanLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect } else if (pSelect->pPartitionByList) { isCountByTag = !keysHasCol(pSelect->pPartitionByList); } + if (pScan->tableType == TSDB_CHILD_TABLE) { + isCountByTag = true; + } } pScan->isCountByTag = isCountByTag; diff --git a/source/libs/scheduler/src/schRemote.c b/source/libs/scheduler/src/schRemote.c index aa33d6f2fc..079fd7d29d 100644 --- a/source/libs/scheduler/src/schRemote.c +++ b/source/libs/scheduler/src/schRemote.c @@ -486,6 +486,7 @@ int32_t schHandleNotifyCallback(void *param, SDataBuf *pMsg, int32_t code) { SSchTaskCallbackParam *pParam = (SSchTaskCallbackParam *)param; qDebug("QID:0x%" PRIx64 ",TID:0x%" PRIx64 " task notify rsp received, code:0x%x", pParam->queryId, pParam->taskId, code); + rpcReleaseHandle(pMsg->handle, TAOS_CONN_CLIENT); if (pMsg) { taosMemoryFree(pMsg->pData); taosMemoryFree(pMsg->pEpSet); @@ -526,6 +527,7 @@ int32_t schHandleHbCallback(void *param, SDataBuf *pMsg, int32_t code) { if (code) { qError("hb rsp error:%s", tstrerror(code)); + rpcReleaseHandle(pMsg->handle, TAOS_CONN_CLIENT); SCH_ERR_JRET(code); } @@ -1181,7 +1183,7 @@ int32_t schBuildAndSendMsg(SSchJob *pJob, SSchTask *pTask, SQueryNodeAddr *addr, qMsg.queryId = pJob->queryId; qMsg.taskId = pTask->taskId; qMsg.refId = pJob->refId; - qMsg.execId = pTask->execId; + qMsg.execId = *(int32_t*)param; msgSize = tSerializeSTaskDropReq(NULL, 0, &qMsg); if (msgSize < 0) { diff --git a/source/libs/scheduler/src/schTask.c b/source/libs/scheduler/src/schTask.c index d96c01fc76..97c3c7d276 100644 --- a/source/libs/scheduler/src/schTask.c +++ b/source/libs/scheduler/src/schTask.c @@ -371,14 +371,13 @@ int32_t schChkUpdateRedirectCtx(SSchJob *pJob, SSchTask *pTask, SEpSet *pEpSet, pCtx->roundTotal = pEpSet->numOfEps; } - if (pCtx->roundTimes >= pCtx->roundTotal) { int64_t nowTs = taosGetTimestampMs(); int64_t lastTime = nowTs - pCtx->startTs; if (lastTime > tsMaxRetryWaitTime) { SCH_TASK_DLOG("task no more redirect retry since timeout, now:%" PRId64 ", start:%" PRId64 ", max:%d, total:%d", nowTs, pCtx->startTs, tsMaxRetryWaitTime, pCtx->totalTimes); - pJob->noMoreRetry = true; + pJob->noMoreRetry = true; SCH_ERR_RET(SCH_GET_REDIRECT_CODE(pJob, rspCode)); } @@ -418,7 +417,7 @@ void schResetTaskForRetry(SSchJob *pJob, SSchTask *pTask) { taosMemoryFreeClear(pTask->msg); pTask->msgLen = 0; pTask->lastMsgType = 0; - pTask->childReady = 0; + pTask->childReady = 0; memset(&pTask->succeedAddr, 0, sizeof(pTask->succeedAddr)); } @@ -505,11 +504,11 @@ int32_t schHandleTaskSetRetry(SSchJob *pJob, SSchTask *pTask, SDataBuf *pData, i pLevel->taskExecDoneNum = 0; pLevel->taskLaunchedNum = 0; } - + SCH_RESET_JOB_LEVEL_IDX(pJob); - + code = schDoTaskRedirect(pJob, pTask, pData, rspCode); - + taosMemoryFreeClear(pData->pData); taosMemoryFreeClear(pData->pEpSet); @@ -627,7 +626,7 @@ int32_t schTaskCheckSetRetry(SSchJob *pJob, SSchTask *pTask, int32_t errCode, bo pTask->maxRetryTimes); return TSDB_CODE_SUCCESS; } - + if (TSDB_CODE_SCH_TIMEOUT_ERROR == errCode) { pTask->maxExecTimes++; pTask->maxRetryTimes++; @@ -862,7 +861,9 @@ void schDropTaskOnExecNode(SSchJob *pJob, SSchTask *pTask) { while (nodeInfo) { if (nodeInfo->handle) { SCH_SET_TASK_HANDLE(pTask, nodeInfo->handle); - schBuildAndSendMsg(pJob, pTask, &nodeInfo->addr, TDMT_SCH_DROP_TASK, NULL); + void *pExecId = taosHashGetKey(nodeInfo, NULL); + schBuildAndSendMsg(pJob, pTask, &nodeInfo->addr, TDMT_SCH_DROP_TASK, pExecId); + SCH_TASK_DLOG("start to drop task's %dth execNode", i); } else { SCH_TASK_DLOG("no need to drop task %dth execNode", i); @@ -901,7 +902,6 @@ int32_t schNotifyTaskOnExecNode(SSchJob *pJob, SSchTask *pTask, ETaskNotifyType return TSDB_CODE_SUCCESS; } - int32_t schProcessOnTaskStatusRsp(SQueryNodeEpId *pEpId, SArray *pStatusList) { int32_t taskNum = (int32_t)taosArrayGetSize(pStatusList); SSchTask *pTask = NULL; @@ -1269,7 +1269,7 @@ int32_t schNotifyTaskInHashList(SSchJob *pJob, SHashObj *list, ETaskNotifyType t int32_t code = TSDB_CODE_SUCCESS; SCH_ERR_RET(schNotifyTaskOnExecNode(pJob, pCurrTask, type)); - + void *pIter = taosHashIterate(list, NULL); while (pIter) { SSchTask *pTask = *(SSchTask **)pIter; @@ -1277,7 +1277,7 @@ int32_t schNotifyTaskInHashList(SSchJob *pJob, SHashObj *list, ETaskNotifyType t SCH_LOCK_TASK(pTask); code = schNotifyTaskOnExecNode(pJob, pTask, type); SCH_UNLOCK_TASK(pTask); - + if (TSDB_CODE_SUCCESS != code) { break; } @@ -1289,7 +1289,6 @@ int32_t schNotifyTaskInHashList(SSchJob *pJob, SHashObj *list, ETaskNotifyType t SCH_RET(code); } - int32_t schExecRemoteFetch(SSchJob *pJob, SSchTask *pTask) { SCH_RET(schBuildAndSendMsg(pJob, pJob->fetchTask, &pJob->resNode, SCH_FETCH_TYPE(pJob->fetchTask), NULL)); } diff --git a/source/libs/stream/src/streamCheckpoint.c b/source/libs/stream/src/streamCheckpoint.c index f58c72eded..7f52c5d2f0 100644 --- a/source/libs/stream/src/streamCheckpoint.c +++ b/source/libs/stream/src/streamCheckpoint.c @@ -278,6 +278,7 @@ void streamTaskClearCheckInfo(SStreamTask* pTask, bool clearChkpReadyMsg) { pTask->chkInfo.numOfNotReady = 0; pTask->chkInfo.transId = 0; pTask->chkInfo.dispatchCheckpointTrigger = false; + pTask->chkInfo.downstreamAlignNum = 0; streamTaskOpenAllUpstreamInput(pTask); // open inputQ for all upstream tasks if (clearChkpReadyMsg) { diff --git a/source/libs/stream/src/streamDispatch.c b/source/libs/stream/src/streamDispatch.c index 9542009d72..baf5ebf8cb 100644 --- a/source/libs/stream/src/streamDispatch.c +++ b/source/libs/stream/src/streamDispatch.c @@ -321,6 +321,8 @@ void clearBufferedDispatchMsg(SStreamTask* pTask) { destroyDispatchMsg(pMsgInfo->pData, getNumOfDispatchBranch(pTask)); } + pMsgInfo->checkpointId = -1; + pMsgInfo->transId = -1; pMsgInfo->pData = NULL; pMsgInfo->dispatchMsgType = 0; } @@ -332,6 +334,12 @@ static int32_t doBuildDispatchMsg(SStreamTask* pTask, const SStreamDataBlock* pD pTask->msgInfo.dispatchMsgType = pData->type; + if (pData->type == STREAM_INPUT__CHECKPOINT_TRIGGER) { + SSDataBlock* p = taosArrayGet(pData->blocks, 0); + pTask->msgInfo.checkpointId = p->info.version; + pTask->msgInfo.transId = p->info.window.ekey; + } + if (pTask->outputInfo.type == TASK_OUTPUT__FIXED_DISPATCH) { SStreamDispatchReq* pReq = taosMemoryCalloc(1, sizeof(SStreamDispatchReq)); @@ -950,9 +958,21 @@ void streamClearChkptReadyMsg(SStreamTask* pTask) { // this message has been sent successfully, let's try next one. static int32_t handleDispatchSuccessRsp(SStreamTask* pTask, int32_t downstreamId) { stDebug("s-task:%s destroy dispatch msg:%p", pTask->id.idStr, pTask->msgInfo.pData); + bool delayDispatch = (pTask->msgInfo.dispatchMsgType == STREAM_INPUT__CHECKPOINT_TRIGGER); if (delayDispatch) { - pTask->chkInfo.dispatchCheckpointTrigger = true; + taosThreadMutexLock(&pTask->lock); + // we only set the dispatch msg info for current checkpoint trans + if (streamTaskGetStatus(pTask)->state == TASK_STATUS__CK && pTask->chkInfo.checkpointingId == pTask->msgInfo.checkpointId) { + ASSERT(pTask->chkInfo.transId == pTask->msgInfo.transId); + pTask->chkInfo.dispatchCheckpointTrigger = true; + stDebug("s-task:%s checkpoint-trigger msg rsp for checkpointId:%" PRId64 " transId:%d confirmed", + pTask->id.idStr, pTask->msgInfo.checkpointId, pTask->msgInfo.transId); + } else { + stWarn("s-task:%s checkpoint-trigger msg rsp for checkpointId:%" PRId64 " transId:%d discard, since expired", + pTask->id.idStr, pTask->msgInfo.checkpointId, pTask->msgInfo.transId); + } + taosThreadMutexUnlock(&pTask->lock); } clearBufferedDispatchMsg(pTask); diff --git a/source/libs/stream/src/streamStart.c b/source/libs/stream/src/streamStart.c index cb340ade32..0161f382ba 100644 --- a/source/libs/stream/src/streamStart.c +++ b/source/libs/stream/src/streamStart.c @@ -119,7 +119,11 @@ int32_t streamReExecScanHistoryFuture(SStreamTask* pTask, int32_t idleDuration) // add ref for task SStreamTask* p = streamMetaAcquireTask(pTask->pMeta, pTask->id.streamId, pTask->id.taskId); - ASSERT(p != NULL); + if (p == NULL) { + stError("s-task:0x%x failed to acquire task, status:%s, not exec scan-history data", pTask->id.taskId, + streamTaskGetStatus(pTask)->name); + return TSDB_CODE_SUCCESS; + } pTask->schedHistoryInfo.numOfTicks = numOfTicks; diff --git a/source/libs/stream/src/streamTask.c b/source/libs/stream/src/streamTask.c index c7a1a00a46..44f70f8b19 100644 --- a/source/libs/stream/src/streamTask.c +++ b/source/libs/stream/src/streamTask.c @@ -380,12 +380,12 @@ void tFreeStreamTask(SStreamTask* pTask) { } if (pTask->hTaskInfo.pTimer != NULL) { - taosTmrStop(pTask->hTaskInfo.pTimer); + /*bool ret = */taosTmrStop(pTask->hTaskInfo.pTimer); pTask->hTaskInfo.pTimer = NULL; } if (pTask->msgInfo.pTimer != NULL) { - taosTmrStop(pTask->msgInfo.pTimer); + /*bool ret = */taosTmrStop(pTask->msgInfo.pTimer); pTask->msgInfo.pTimer = NULL; } diff --git a/source/libs/stream/src/streamTaskSm.c b/source/libs/stream/src/streamTaskSm.c index 6aa215586a..cfa94209f6 100644 --- a/source/libs/stream/src/streamTaskSm.c +++ b/source/libs/stream/src/streamTaskSm.c @@ -543,8 +543,6 @@ void streamTaskSetStatusReady(SStreamTask* pTask) { return; } - taosThreadMutexLock(&pTask->lock); - pSM->prev.state = pSM->current; pSM->prev.evt = 0; @@ -552,8 +550,6 @@ void streamTaskSetStatusReady(SStreamTask* pTask) { pSM->startTs = taosGetTimestampMs(); pSM->pActiveTrans = NULL; taosArrayClear(pSM->pWaitingEventList); - - taosThreadMutexUnlock(&pTask->lock); } STaskStateTrans createStateTransform(ETaskStatus current, ETaskStatus next, EStreamTaskEvent event, __state_trans_fn fn, diff --git a/source/libs/sync/src/syncMain.c b/source/libs/sync/src/syncMain.c index da18bbdea2..85aa3a2796 100644 --- a/source/libs/sync/src/syncMain.c +++ b/source/libs/sync/src/syncMain.c @@ -276,16 +276,18 @@ int32_t syncForceBecomeFollower(SSyncNode* ths, const SRpcMsg* pRpcMsg) { int32_t syncBecomeAssignedLeader(SSyncNode* ths, SRpcMsg* pRpcMsg) { int32_t ret = -1; + int32_t errcode = TSDB_CODE_MND_ARB_TOKEN_MISMATCH; + void* pHead = NULL; + int32_t contLen = 0; SVArbSetAssignedLeaderReq req = {0}; if (tDeserializeSVArbSetAssignedLeaderReq((char*)pRpcMsg->pCont + sizeof(SMsgHead), pRpcMsg->contLen, &req) != 0) { sError("vgId:%d, failed to deserialize SVArbSetAssignedLeaderReq", ths->vgId); terrno = TSDB_CODE_INVALID_MSG; - return -1; + errcode = terrno; + goto _OVER; } - int32_t errcode = TSDB_CODE_MND_ARB_TOKEN_MISMATCH; - if (ths->arbTerm > req.arbTerm) { sInfo("vgId:%d, skip to set assigned leader, msg with lower term, local:%" PRId64 "msg:%" PRId64, ths->vgId, ths->arbTerm, req.arbTerm); @@ -294,50 +296,58 @@ int32_t syncBecomeAssignedLeader(SSyncNode* ths, SRpcMsg* pRpcMsg) { ths->arbTerm = TMAX(req.arbTerm, ths->arbTerm); - if (strncmp(req.memberToken, ths->arbToken, TSDB_ARB_TOKEN_SIZE) == 0) { - if (ths->state != TAOS_SYNC_STATE_ASSIGNED_LEADER) { - raftStoreNextTerm(ths); - if (terrno != TSDB_CODE_SUCCESS) { - sError("vgId:%d, failed to set next term since:%s", ths->vgId, terrstr()); - goto _OVER; - } - syncNodeBecomeAssignedLeader(ths); - - if (syncNodeAppendNoop(ths) < 0) { - sError("vgId:%d, assigned leader failed to append noop entry since %s", ths->vgId, terrstr()); - } - } - errcode = TSDB_CODE_SUCCESS; - } else { + if (strncmp(req.memberToken, ths->arbToken, TSDB_ARB_TOKEN_SIZE) != 0) { sInfo("vgId:%d, skip to set assigned leader, token mismatch, local:%s, msg:%s", ths->vgId, ths->arbToken, req.memberToken); goto _OVER; } + if (ths->state != TAOS_SYNC_STATE_ASSIGNED_LEADER) { + terrno = TSDB_CODE_SUCCESS; + raftStoreNextTerm(ths); + if (terrno != TSDB_CODE_SUCCESS) { + sError("vgId:%d, failed to set next term since:%s", ths->vgId, terrstr()); + errcode = terrno; + goto _OVER; + } + syncNodeBecomeAssignedLeader(ths); + + if (syncNodeAppendNoop(ths) < 0) { + sError("vgId:%d, assigned leader failed to append noop entry since %s", ths->vgId, terrstr()); + } + } + SVArbSetAssignedLeaderRsp rsp = {0}; rsp.arbToken = req.arbToken; rsp.memberToken = req.memberToken; rsp.vgId = ths->vgId; - int32_t contLen = tSerializeSVArbSetAssignedLeaderRsp(NULL, 0, &rsp); + contLen = tSerializeSVArbSetAssignedLeaderRsp(NULL, 0, &rsp); if (contLen <= 0) { sError("vgId:%d, failed to serialize SVArbSetAssignedLeaderRsp", ths->vgId); terrno = TSDB_CODE_OUT_OF_MEMORY; + errcode = terrno; goto _OVER; } - void* pHead = rpcMallocCont(contLen); + pHead = rpcMallocCont(contLen); if (!pHead) { sError("vgId:%d, failed to malloc memory for SVArbSetAssignedLeaderRsp", ths->vgId); terrno = TSDB_CODE_OUT_OF_MEMORY; + errcode = terrno; goto _OVER; } if (tSerializeSVArbSetAssignedLeaderRsp(pHead, contLen, &rsp) <= 0) { sError("vgId:%d, failed to serialize SVArbSetAssignedLeaderRsp", ths->vgId); terrno = TSDB_CODE_OUT_OF_MEMORY; + errcode = terrno; rpcFreeCont(pHead); goto _OVER; } + errcode = TSDB_CODE_SUCCESS; + ret = 0; + +_OVER:; SRpcMsg rspMsg = { .code = errcode, .pCont = pHead, @@ -347,9 +357,6 @@ int32_t syncBecomeAssignedLeader(SSyncNode* ths, SRpcMsg* pRpcMsg) { tmsgSendRsp(&rspMsg); - ret = 0; - -_OVER: tFreeSVArbSetAssignedLeaderReq(&req); return ret; } diff --git a/source/libs/transport/inc/transComm.h b/source/libs/transport/inc/transComm.h index c010e31320..da6d71e07b 100644 --- a/source/libs/transport/inc/transComm.h +++ b/source/libs/transport/inc/transComm.h @@ -19,16 +19,12 @@ extern "C" { #endif #include -#include "os.h" -#include "taoserror.h" #include "theap.h" -#include "tmisce.h" #include "tmsg.h" #include "transLog.h" #include "transportInt.h" #include "trpc.h" #include "ttrace.h" -#include "tutil.h" typedef bool (*FilteFunc)(void* arg); @@ -115,9 +111,12 @@ typedef SRpcConnInfo STransHandleInfo; // ref mgt handle typedef struct SExHandle { - void* handle; - int64_t refId; - void* pThrd; + void* handle; + int64_t refId; + void* pThrd; + queue q; + int8_t inited; + SRWLatch latch; } SExHandle; typedef struct { diff --git a/source/libs/transport/src/transCli.c b/source/libs/transport/src/transCli.c index 99af5e520e..c371535dae 100644 --- a/source/libs/transport/src/transCli.c +++ b/source/libs/transport/src/transCli.c @@ -92,6 +92,7 @@ typedef struct SCliMsg { int64_t refId; uint64_t st; int sent; //(0: no send, 1: alread sent) + queue seqq; } SCliMsg; typedef struct SCliThrd { @@ -121,11 +122,7 @@ typedef struct SCliThrd { SHashObj* batchCache; SCliMsg* stopMsg; - - bool quit; - - int newConnCount; - SHashObj* msgCount; + bool quit; } SCliThrd; typedef struct SCliObj { @@ -262,10 +259,8 @@ static void cliWalkCb(uv_handle_t* handle, void* arg); } \ if (i == sz) { \ pMsg = NULL; \ - tDebug("msg not found, %" PRIu64 "", ahandle); \ } else { \ pMsg = transQueueRm(&conn->cliMsgs, i); \ - tDebug("msg found, %" PRIu64 "", ahandle); \ } \ } while (0) @@ -343,6 +338,34 @@ bool cliMaySendCachedMsg(SCliConn* conn) { _RETURN: return false; } +bool cliConnSendSeqMsg(int64_t refId, SCliConn* conn) { + if (refId == 0) return false; + SExHandle* exh = transAcquireExHandle(transGetRefMgt(), refId); + if (exh == NULL) { + tDebug("release conn %p, refId: %" PRId64 "", conn, refId); + return false; + } + taosWLockLatch(&exh->latch); + if (exh->handle == NULL) exh->handle = conn; + exh->inited = 1; + if (!QUEUE_IS_EMPTY(&exh->q)) { + queue* h = QUEUE_HEAD(&exh->q); + QUEUE_REMOVE(h); + taosWUnLockLatch(&exh->latch); + SCliMsg* t = QUEUE_DATA(h, SCliMsg, seqq); + transCtxMerge(&conn->ctx, &t->ctx->appCtx); + transQueuePush(&conn->cliMsgs, t); + tDebug("pop from conn %p, refId: %" PRId64 "", conn, refId); + transReleaseExHandle(transGetRefMgt(), refId); + cliSend(conn); + return true; + } + taosWUnLockLatch(&exh->latch); + tDebug("empty conn %p, refId: %" PRId64 "", conn, refId); + transReleaseExHandle(transGetRefMgt(), refId); + return false; +} + void cliHandleResp(SCliConn* conn) { SCliThrd* pThrd = conn->hostThrd; STrans* pTransInst = pThrd->pTransInst; @@ -439,8 +462,14 @@ void cliHandleResp(SCliConn* conn) { return; } } + int64_t refId = (pMsg == NULL ? 0 : (int64_t)(pMsg->msg.info.handle)); + tDebug("conn %p msg refId: %" PRId64 "", conn, refId); destroyCmsg(pMsg); + if (cliConnSendSeqMsg(refId, conn)) { + return; + } + if (cliMaySendCachedMsg(conn) == true) { return; } @@ -451,6 +480,21 @@ void cliHandleResp(SCliConn* conn) { uv_read_start((uv_stream_t*)conn->stream, cliAllocRecvBufferCb, cliRecvCb); } +static void cliDestroyMsgInExhandle(int64_t refId) { + if (refId == 0) return; + SExHandle* exh = transAcquireExHandle(transGetRefMgt(), refId); + if (exh) { + taosWLockLatch(&exh->latch); + while (!QUEUE_IS_EMPTY(&exh->q)) { + queue* h = QUEUE_HEAD(&exh->q); + QUEUE_REMOVE(h); + SCliMsg* t = QUEUE_DATA(h, SCliMsg, seqq); + destroyCmsg(t); + } + taosWUnLockLatch(&exh->latch); + transReleaseExHandle(transGetRefMgt(), refId); + } +} void cliHandleExceptImpl(SCliConn* pConn, int32_t code) { if (transQueueEmpty(&pConn->cliMsgs)) { @@ -510,6 +554,8 @@ void cliHandleExceptImpl(SCliConn* pConn, int32_t code) { } if (pMsg == NULL || (pMsg && pMsg->type != Release)) { + int64_t refId = (pMsg == NULL ? 0 : (int64_t)(pMsg->msg.info.handle)); + cliDestroyMsgInExhandle(refId); if (cliAppCb(pConn, &transMsg, pMsg) != 0) { return; } @@ -678,7 +724,7 @@ static SCliConn* getConnFromPool2(SCliThrd* pThrd, char* key, SCliMsg** pMsg) { } list->numOfConn++; } - tTrace("%s numOfConn: %d, limit: %d", pTransInst->label, list->numOfConn, pTransInst->connLimitNum); + tDebug("%s numOfConn: %d, limit: %d, dst:%s", pTransInst->label, list->numOfConn, pTransInst->connLimitNum, key); return NULL; } @@ -742,13 +788,13 @@ static void addConnToPool(void* pool, SCliConn* conn) { QUEUE_PUSH(&conn->list->conns, &conn->q); conn->list->size += 1; - if (conn->list->size >= 20) { + if (conn->list->size >= 10) { STaskArg* arg = taosMemoryCalloc(1, sizeof(STaskArg)); arg->param1 = conn; arg->param2 = thrd; STrans* pTransInst = thrd->pTransInst; - conn->task = transDQSched(thrd->timeoutQueue, doCloseIdleConn, arg, CONN_PERSIST_TIME(pTransInst->idleTime)); + conn->task = transDQSched(thrd->timeoutQueue, doCloseIdleConn, arg, 10 * CONN_PERSIST_TIME(pTransInst->idleTime)); } } static int32_t allocConnRef(SCliConn* conn, bool update) { @@ -761,8 +807,10 @@ static int32_t allocConnRef(SCliConn* conn, bool update) { exh->handle = conn; exh->pThrd = conn->hostThrd; exh->refId = transAddExHandle(transGetRefMgt(), exh); - conn->refId = exh->refId; + QUEUE_INIT(&exh->q); + taosInitRWLatch(&exh->latch); + conn->refId = exh->refId; if (conn->refId == -1) { taosMemoryFree(exh); } @@ -779,9 +827,11 @@ static int32_t specifyConnRef(SCliConn* conn, bool update, int64_t handle) { if (exh == NULL) { return -1; } + taosWLockLatch(&exh->latch); exh->handle = conn; exh->pThrd = conn->hostThrd; conn->refId = exh->refId; + taosWUnLockLatch(&exh->latch); transReleaseExHandle(transGetRefMgt(), handle); return 0; @@ -882,7 +932,6 @@ static void cliDestroyConn(SCliConn* conn, bool clear) { } conn->list = NULL; - pThrd->newConnCount--; transReleaseExHandle(transGetRefMgt(), conn->refId); transRemoveExHandle(transGetRefMgt(), conn->refId); @@ -1190,7 +1239,6 @@ static void cliHandleBatchReq(SCliBatch* pBatch, SCliThrd* pThrd) { addr.sin_port = (uint16_t)htons(pList->port); tTrace("%s conn %p try to connect to %s", pTransInst->label, conn, pList->dst); - pThrd->newConnCount++; int32_t fd = taosCreateSocketWithTimeout(TRANS_CONN_TIMEOUT * 10); if (fd == -1) { tError("%s conn %p failed to create socket, reason:%s", transLabel(pTransInst), conn, @@ -1392,7 +1440,10 @@ static void cliHandleRelease(SCliMsg* pMsg, SCliThrd* pThrd) { return; } + taosRLockLatch(&exh->latch); SCliConn* conn = exh->handle; + taosRUnLockLatch(&exh->latch); + transReleaseExHandle(transGetRefMgt(), refId); tDebug("%s conn %p start to release to inst", CONN_GET_INST_LABEL(conn), conn); @@ -1425,7 +1476,9 @@ SCliConn* cliGetConn(SCliMsg** pMsg, SCliThrd* pThrd, bool* ignore, char* addr) *ignore = true; return NULL; } else { + taosRLockLatch(&exh->latch); conn = exh->handle; + taosRUnLockLatch(&exh->latch); if (conn == NULL) { conn = getConnFromPool2(pThrd, addr, pMsg); if (conn != NULL) specifyConnRef(conn, true, refId); @@ -1439,7 +1492,7 @@ SCliConn* cliGetConn(SCliMsg** pMsg, SCliThrd* pThrd, bool* ignore, char* addr) if (conn != NULL) { tTrace("%s conn %p get from conn pool:%p", CONN_GET_INST_LABEL(conn), conn, pThrd->pool); } else { - tTrace("%s not found conn in conn pool:%p", ((STrans*)pThrd->pTransInst)->label, pThrd->pool); + tTrace("%s not found conn in conn pool:%p, dst:%s", ((STrans*)pThrd->pTransInst)->label, pThrd->pool, addr); } return conn; } @@ -1598,7 +1651,6 @@ void cliHandleReq(SCliMsg* pMsg, SCliThrd* pThrd) { addr.sin_port = (uint16_t)htons(port); tGTrace("%s conn %p try to connect to %s", pTransInst->label, conn, conn->dstAddr); - pThrd->newConnCount++; int32_t fd = taosCreateSocketWithTimeout(TRANS_CONN_TIMEOUT * 10); if (fd == -1) { tGError("%s conn %p failed to create socket, reason:%s", transLabel(pTransInst), conn, @@ -1858,9 +1910,10 @@ void cliIteraConnMsgs(SCliConn* conn) { bool cliRecvReleaseReq(SCliConn* conn, STransMsgHead* pHead) { if (pHead->release == 1 && (pHead->msgLen) == sizeof(*pHead)) { uint64_t ahandle = pHead->ahandle; - tDebug("ahandle = %" PRIu64 "", ahandle); SCliMsg* pMsg = NULL; CONN_GET_MSGCTX_BY_AHANDLE(conn, ahandle); + tDebug("%s conn %p receive release request, refId:%" PRId64 ", may ignore", CONN_GET_INST_LABEL(conn), conn, + conn->refId); transClearBuffer(&conn->readBuf); transFreeMsg(transContFromHead((char*)pHead)); @@ -1869,6 +1922,9 @@ bool cliRecvReleaseReq(SCliConn* conn, STransMsgHead* pHead) { SCliMsg* cliMsg = transQueueGet(&conn->cliMsgs, i); if (cliMsg->type == Release) { ASSERTS(pMsg == NULL, "trans-cli recv invaid release-req"); + tDebug("%s conn %p receive release request, refId:%" PRId64 ", ignore msg", CONN_GET_INST_LABEL(conn), conn, + conn->refId); + cliDestroyConn(conn, true); return true; } } @@ -1984,11 +2040,9 @@ static SCliThrd* createThrdObj(void* trans) { taosMemoryFree(pThrd); return NULL; } - if (pTransInst->supportBatch) { - pThrd->asyncPool = transAsyncPoolCreate(pThrd->loop, 4, pThrd, cliAsyncCb); - } else { - pThrd->asyncPool = transAsyncPoolCreate(pThrd->loop, 8, pThrd, cliAsyncCb); - } + int32_t nSync = pTransInst->supportBatch ? 4 : 8; + pThrd->asyncPool = transAsyncPoolCreate(pThrd->loop, nSync, pThrd, cliAsyncCb); + if (pThrd->asyncPool == NULL) { tError("failed to init async pool"); uv_loop_close(pThrd->loop); @@ -2029,8 +2083,6 @@ static SCliThrd* createThrdObj(void* trans) { pThrd->quit = false; - pThrd->newConnCount = 0; - pThrd->msgCount = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK); return pThrd; } static void destroyThrdObj(SCliThrd* pThrd) { @@ -2076,7 +2128,6 @@ static void destroyThrdObj(SCliThrd* pThrd) { pIter = (void**)taosHashIterate(pThrd->batchCache, pIter); } taosHashCleanup(pThrd->batchCache); - taosHashCleanup(pThrd->msgCount); taosMemoryFree(pThrd); } @@ -2095,14 +2146,7 @@ void cliSendQuit(SCliThrd* thrd) { void cliWalkCb(uv_handle_t* handle, void* arg) { if (!uv_is_closing(handle)) { if (uv_handle_get_type(handle) == UV_TIMER) { - // SCliConn* pConn = handle->data; - // if (pConn != NULL && pConn->timer != NULL) { - // SCliThrd* pThrd = pConn->hostThrd; - // uv_timer_stop((uv_timer_t*)handle); - // handle->data = NULL; - // taosArrayPush(pThrd->timerList, &pConn->timer); - // pConn->timer = NULL; - // } + // do nothing } else { uv_read_stop((uv_stream_t*)handle); } @@ -2137,18 +2181,23 @@ static void doCloseIdleConn(void* param) { cliDestroyConn(conn, true); taosMemoryFree(arg); } +static void cliSchedMsgToDebug(SCliMsg* pMsg, char* label) { + if (!(rpcDebugFlag & DEBUG_DEBUG)) { + return; + } + STransConnCtx* pCtx = pMsg->ctx; + STraceId* trace = &pMsg->msg.info.traceId; + char tbuf[512] = {0}; + EPSET_TO_STR(&pCtx->epSet, tbuf); + tGDebug("%s retry on next node,use:%s, step: %d,timeout:%" PRId64 "", label, tbuf, pCtx->retryStep, + pCtx->retryNextInterval); + return; +} static void cliSchedMsgToNextNode(SCliMsg* pMsg, SCliThrd* pThrd) { STrans* pTransInst = pThrd->pTransInst; STransConnCtx* pCtx = pMsg->ctx; - - if (rpcDebugFlag & DEBUG_DEBUG) { - STraceId* trace = &pMsg->msg.info.traceId; - char tbuf[512] = {0}; - EPSET_TO_STR(&pCtx->epSet, tbuf); - tGDebug("%s retry on next node,use:%s, step: %d,timeout:%" PRId64 "", transLabel(pThrd->pTransInst), tbuf, - pCtx->retryStep, pCtx->retryNextInterval); - } + cliSchedMsgToDebug(pMsg, transLabel(pThrd->pTransInst)); STaskArg* arg = taosMemoryMalloc(sizeof(STaskArg)); arg->param1 = pMsg; @@ -2157,12 +2206,6 @@ static void cliSchedMsgToNextNode(SCliMsg* pMsg, SCliThrd* pThrd) { transDQSched(pThrd->delayQueue, doDelayTask, arg, pCtx->retryNextInterval); } -FORCE_INLINE void cliCompareAndSwap(int8_t* val, int8_t exp, int8_t newVal) { - if (*val != exp) { - *val = newVal; - } -} - FORCE_INLINE bool cliTryExtractEpSet(STransMsg* pResp, SEpSet* dst) { if ((pResp == NULL || pResp->info.hasEpSet == 0)) { return false; @@ -2504,21 +2547,7 @@ int transReleaseCliHandle(void* handle) { } return 0; } - -int transSendRequest(void* shandle, const SEpSet* pEpSet, STransMsg* pReq, STransCtx* ctx) { - STrans* pTransInst = (STrans*)transAcquireExHandle(transGetInstMgt(), (int64_t)shandle); - if (pTransInst == NULL) { - transFreeMsg(pReq->pCont); - return TSDB_CODE_RPC_BROKEN_LINK; - } - - SCliThrd* pThrd = transGetWorkThrd(pTransInst, (int64_t)pReq->info.handle); - if (pThrd == NULL) { - transFreeMsg(pReq->pCont); - transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); - return TSDB_CODE_RPC_BROKEN_LINK; - } - +static SCliMsg* transInitMsg(void* shandle, const SEpSet* pEpSet, STransMsg* pReq, STransCtx* ctx) { TRACE_SET_MSGID(&pReq->info.traceId, tGenIdPI64()); STransConnCtx* pCtx = taosMemoryCalloc(1, sizeof(STransConnCtx)); epsetAssign(&pCtx->epSet, pEpSet); @@ -2535,12 +2564,48 @@ int transSendRequest(void* shandle, const SEpSet* pEpSet, STransMsg* pReq, STran cliMsg->st = taosGetTimestampUs(); cliMsg->type = Normal; cliMsg->refId = (int64_t)shandle; + QUEUE_INIT(&cliMsg->seqq); + return cliMsg; +} + +int transSendRequest(void* shandle, const SEpSet* pEpSet, STransMsg* pReq, STransCtx* ctx) { + STrans* pTransInst = (STrans*)transAcquireExHandle(transGetInstMgt(), (int64_t)shandle); + if (pTransInst == NULL) { + transFreeMsg(pReq->pCont); + return TSDB_CODE_RPC_BROKEN_LINK; + } + + int64_t handle = (int64_t)pReq->info.handle; + SCliThrd* pThrd = transGetWorkThrd(pTransInst, handle); + if (pThrd == NULL) { + transFreeMsg(pReq->pCont); + transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); + return TSDB_CODE_RPC_BROKEN_LINK; + } + if (handle != 0) { + SExHandle* exh = transAcquireExHandle(transGetRefMgt(), handle); + if (exh != NULL) { + taosWLockLatch(&exh->latch); + if (exh->handle == NULL && exh->inited != 0) { + SCliMsg* pCliMsg = transInitMsg(shandle, pEpSet, pReq, ctx); + QUEUE_PUSH(&exh->q, &pCliMsg->seqq); + taosWUnLockLatch(&exh->latch); + tDebug("msg refId: %" PRId64 "", handle); + transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); + return 0; + } + exh->inited = 1; + taosWUnLockLatch(&exh->latch); + transReleaseExHandle(transGetRefMgt(), handle); + } + } + SCliMsg* pCliMsg = transInitMsg(shandle, pEpSet, pReq, ctx); STraceId* trace = &pReq->info.traceId; tGDebug("%s send request at thread:%08" PRId64 ", dst:%s:%d, app:%p", transLabel(pTransInst), pThrd->pid, - EPSET_GET_INUSE_IP(&pCtx->epSet), EPSET_GET_INUSE_PORT(&pCtx->epSet), pReq->info.ahandle); - if (0 != transAsyncSend(pThrd->asyncPool, &(cliMsg->q))) { - destroyCmsg(cliMsg); + EPSET_GET_INUSE_IP(pEpSet), EPSET_GET_INUSE_PORT(pEpSet), pReq->info.ahandle); + if (0 != transAsyncSend(pThrd->asyncPool, &(pCliMsg->q))) { + destroyCmsg(pCliMsg); transReleaseExHandle(transGetInstMgt(), (int64_t)shandle); return TSDB_CODE_RPC_BROKEN_LINK; } @@ -2726,6 +2791,8 @@ int transSetDefaultAddr(void* shandle, const char* ip, const char* fqdn) { int64_t transAllocHandle() { SExHandle* exh = taosMemoryCalloc(1, sizeof(SExHandle)); exh->refId = transAddExHandle(transGetRefMgt(), exh); + QUEUE_INIT(&exh->q); + taosInitRWLatch(&exh->latch); tDebug("pre alloc refId %" PRId64 "", exh->refId); return exh->refId; diff --git a/source/libs/transport/src/transComm.c b/source/libs/transport/src/transComm.c index 27099c76fc..fff13e7ebb 100644 --- a/source/libs/transport/src/transComm.c +++ b/source/libs/transport/src/transComm.c @@ -70,7 +70,7 @@ int32_t transDecompressMsg(char** msg, int32_t len) { char* buf = taosMemoryCalloc(1, oriLen + sizeof(STransMsgHead)); STransMsgHead* pNewHead = (STransMsgHead*)buf; int32_t decompLen = LZ4_decompress_safe(pCont + sizeof(STransCompMsg), (char*)pNewHead->content, - len - sizeof(STransMsgHead) - sizeof(STransCompMsg), oriLen); + len - sizeof(STransMsgHead) - sizeof(STransCompMsg), oriLen); memcpy((char*)pNewHead, (char*)pHead, sizeof(STransMsgHead)); pNewHead->msgLen = htonl(oriLen + sizeof(STransMsgHead)); @@ -158,6 +158,10 @@ int transResetBuffer(SConnBuffer* connBuf) { p->left = -1; p->total = 0; p->len = 0; + if (p->cap > BUFFER_CAP) { + p->cap = BUFFER_CAP; + p->buf = taosMemoryRealloc(p->buf, p->cap); + } } else { ASSERTS(0, "invalid read from sock buf"); return -1; diff --git a/source/libs/transport/src/transSvr.c b/source/libs/transport/src/transSvr.c index f47a688e6f..21ad5be869 100644 --- a/source/libs/transport/src/transSvr.c +++ b/source/libs/transport/src/transSvr.c @@ -761,9 +761,12 @@ static bool uvRecvReleaseReq(SSvrConn* pConn, STransMsgHead* pHead) { tTrace("conn %p received release request", pConn); STraceId traceId = pHead->traceId; - pConn->status = ConnRelease; transClearBuffer(&pConn->readBuf); transFreeMsg(transContFromHead((char*)pHead)); + if (pConn->status != ConnAcquire) { + return true; + } + pConn->status = ConnRelease; STransMsg tmsg = {.code = 0, .info.handle = (void*)pConn, .info.traceId = traceId, .info.ahandle = (void*)0x9527}; SSvrMsg* srvMsg = taosMemoryCalloc(1, sizeof(SSvrMsg)); @@ -1090,6 +1093,7 @@ static FORCE_INLINE SSvrConn* createConn(void* hThrd) { STrans* pTransInst = pThrd->pTransInst; pConn->refId = exh->refId; + QUEUE_INIT(&exh->q); transRefSrvHandle(pConn); tTrace("%s handle %p, conn %p created, refId:%" PRId64, transLabel(pTransInst), exh, pConn, pConn->refId); return pConn; @@ -1121,6 +1125,7 @@ static int reallocConnRef(SSvrConn* conn) { exh->handle = conn; exh->pThrd = conn->hostThrd; exh->refId = transAddExHandle(transGetRefMgt(), exh); + QUEUE_INIT(&exh->q); transAcquireExHandle(transGetRefMgt(), exh->refId); conn->refId = exh->refId; diff --git a/source/util/src/terror.c b/source/util/src/terror.c index b70c1aacda..748087fe61 100644 --- a/source/util/src/terror.c +++ b/source/util/src/terror.c @@ -289,7 +289,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_DNODE_IN_DROPPING, "Dnode in dropping sta // mnode-trans TAOS_DEFINE_ERROR(TSDB_CODE_MND_TRANS_ALREADY_EXIST, "Transaction already exists") TAOS_DEFINE_ERROR(TSDB_CODE_MND_TRANS_NOT_EXIST, "Transaction not exists") -TAOS_DEFINE_ERROR(TSDB_CODE_MND_TRANS_INVALID_STAGE, "Invalid stage to kill") +TAOS_DEFINE_ERROR(TSDB_CODE_MND_TRANS_INVALID_STAGE, "Invalid transaction stage") TAOS_DEFINE_ERROR(TSDB_CODE_MND_TRANS_CONFLICT, "Conflict transaction not completed") TAOS_DEFINE_ERROR(TSDB_CODE_MND_TRANS_CLOG_IS_NULL, "Transaction commitlog is null") TAOS_DEFINE_ERROR(TSDB_CODE_MND_TRANS_NETWORK_UNAVAILL, "Unable to establish connection While execute transaction and will continue in the background") diff --git a/source/util/src/tlog.c b/source/util/src/tlog.c index 16ca1b64c3..0c09174970 100644 --- a/source/util/src/tlog.c +++ b/source/util/src/tlog.c @@ -242,6 +242,7 @@ void taosCloseLog() { taosMemoryFreeClear(tsLogObj.logHandle->buffer); taosThreadMutexDestroy(&tsLogObj.logMutex); taosMemoryFreeClear(tsLogObj.logHandle); + tsLogObj.logHandle = NULL; } } @@ -285,8 +286,11 @@ static void taosKeepOldLog(char *oldName) { taosRemoveOldFiles(tsLogDir, tsLogKeepDays); } } - -static void *taosThreadToOpenNewFile(void *param) { +typedef struct { + TdFilePtr pOldFile; + char keepName[LOG_FILE_NAME_LEN + 20]; +} OldFileKeeper; +static OldFileKeeper *taosOpenNewFile() { char keepName[LOG_FILE_NAME_LEN + 20]; sprintf(keepName, "%s.%d", tsLogObj.logName, tsLogObj.flag); @@ -312,13 +316,26 @@ static void *taosThreadToOpenNewFile(void *param) { tsLogObj.logHandle->pFile = pFile; tsLogObj.lines = 0; tsLogObj.openInProgress = 0; - taosSsleep(20); - taosCloseLogByFd(pOldFile); + OldFileKeeper* oldFileKeeper = taosMemoryMalloc(sizeof(OldFileKeeper)); + if (oldFileKeeper == NULL) { + uError("create old log keep info faild! mem is not enough."); + return NULL; + } + oldFileKeeper->pOldFile = pOldFile; + memcpy(oldFileKeeper->keepName, keepName, LOG_FILE_NAME_LEN + 20); uInfo(" new log file:%d is opened", tsLogObj.flag); uInfo("=================================="); - taosKeepOldLog(keepName); + return oldFileKeeper; +} +static void *taosThreadToCloseOldFile(void* param) { + if(!param) return NULL; + OldFileKeeper* oldFileKeeper = (OldFileKeeper*)param; + taosSsleep(20); + taosCloseLogByFd(oldFileKeeper->pOldFile); + taosKeepOldLog(oldFileKeeper->keepName); + taosMemoryFree(oldFileKeeper); return NULL; } @@ -334,7 +351,8 @@ static int32_t taosOpenNewLogFile() { taosThreadAttrInit(&attr); taosThreadAttrSetDetachState(&attr, PTHREAD_CREATE_DETACHED); - taosThreadCreate(&thread, &attr, taosThreadToOpenNewFile, NULL); + OldFileKeeper* oldFileKeeper = taosOpenNewFile(); + taosThreadCreate(&thread, &attr, taosThreadToCloseOldFile, oldFileKeeper); taosThreadAttrDestroy(&attr); } @@ -347,10 +365,11 @@ void taosResetLog() { // force create a new log file tsLogObj.lines = tsNumOfLogLines + 10; - taosOpenNewLogFile(); - - uInfo("=================================="); - uInfo(" reset log file "); + if (tsLogObj.logHandle) { + taosOpenNewLogFile(); + uInfo("=================================="); + uInfo(" reset log file "); + } } static bool taosCheckFileIsOpen(char *logFileName) { diff --git a/tests/develop-test/2-query/pseudo_column.py b/tests/develop-test/2-query/pseudo_column.py index 1d94df4cff..61ea53433f 100644 --- a/tests/develop-test/2-query/pseudo_column.py +++ b/tests/develop-test/2-query/pseudo_column.py @@ -66,10 +66,10 @@ class TDTestCase: tdSql.query('select * from (select tbname, avg(f) from st partition by tbname) a partition by a.tbname order by a.tbname'); tdSql.checkRows(2) tdSql.checkCols(2) - tdSql.checkData(0, 0, 'ct1'); - tdSql.checkData(0, 1, 6.0); - tdSql.checkData(1, 0, 'ct2'); - tdSql.checkData(1, 1, 12.0); + tdSql.checkData(0, 0, 'ct1') + tdSql.checkData(0, 1, 6.0) + tdSql.checkData(1, 0, 'ct2') + tdSql.checkData(1, 1, 12.0) tdSql.error('select tbname from (select * from st)') tdSql.error('select st.tbname from (select st.tbname from st)') diff --git a/tests/script/tsim/parser/select_with_tags.sim b/tests/script/tsim/parser/select_with_tags.sim index 0e777de7e8..0cc8a7db8a 100644 --- a/tests/script/tsim/parser/select_with_tags.sim +++ b/tests/script/tsim/parser/select_with_tags.sim @@ -870,7 +870,7 @@ sql_error select stddev(c2), tbname from select_tags_mt0; sql_error select twa(c2), tbname from select_tags_mt0; sql_error select interp(c2), tbname from select_tags_mt0 where ts=100001; -sql_error select t1,t2,tbname from select_tags_mt0 group by tbname; + sql select count(tbname) from select_tags_mt0 interval(1d); sql select count(tbname) from select_tags_mt0 group by t1; sql select count(tbname),SUM(T1) from select_tags_mt0 interval(1d); @@ -888,16 +888,16 @@ sql_error select tbname, t1 from select_tags_mt0 interval(1y); print ==================================>TD-4231 sql select t1,tbname from select_tags_mt0 where c1<0 sql select t1,tbname from select_tags_mt0 where c1<0 and tbname in ('select_tags_tb12') - sql select tbname from select_tags_mt0 where tbname in ('select_tags_tb12'); -sql_error select first(c1), last(c2), t1 from select_tags_mt0 group by tbname; -sql_error select first(c1), last(c2), tbname, t2 from select_tags_mt0 group by tbname; -sql_error select first(c1), count(*), t2, t1, tbname from select_tags_mt0 group by tbname; -#valid sql: select first(c1), t2 from select_tags_mt0 group by tbname; +sql select first(ts), tbname from select_tags_mt0 group by tbname; +sql select count(c1) from select_tags_mt0 where c1=99 group by tbname; +sql select count(*),tbname from select_tags_mt0 group by tbname -#sql select first(ts), tbname from select_tags_mt0 group by tbname; -#sql select count(c1) from select_tags_mt0 where c1=99 group by tbname; -#sql select count(*),tbname from select_tags_mt0 group by tbname +print ==================================> tag supported in group +sql select t1,t2,tbname from select_tags_mt0 group by tbname; +sql select first(c1), last(c2), t1 from select_tags_mt0 group by tbname; +sql select first(c1), last(c2), tbname, t2 from select_tags_mt0 group by tbname; +sql select first(c1), count(*), t2, t1, tbname from select_tags_mt0 group by tbname; system sh/exec.sh -n dnode1 -s stop -x SIGINT diff --git a/tests/script/tsim/query/count_spread.sim b/tests/script/tsim/query/count_spread.sim index c03783b7fe..082b32d1fb 100644 --- a/tests/script/tsim/query/count_spread.sim +++ b/tests/script/tsim/query/count_spread.sim @@ -3,15 +3,24 @@ system sh/deploy.sh -n dnode1 -i 1 system sh/exec.sh -n dnode1 -s start sql connect -sql create database test; +sql create database test KEEP 36500; sql use test; sql create table st(ts timestamp, f int) tags(t int); -sql insert into ct1 using st tags(1) values(now, 0)(now+1s, 1)(now+2s, 10)(now+3s, 11) -sql insert into ct2 using st tags(2) values(now+2s, 2)(now+3s, 3) -sql insert into ct3 using st tags(3) values(now+4s, 4)(now+5s, 5) -sql insert into ct4 using st tags(4) values(now+6s, 6)(now+7s, 7) -sql select count(*), spread(ts) from st where tbname='ct1' +$ms = 1712135244502 +$ms1 = $ms + 1000 +$ms2 = $ms + 2000 +$ms3 = $ms + 3000 +$ms4 = $ms + 4000 +$ms5 = $ms + 5000 +$ms6 = $ms + 6000 +$ms7 = $ms + 7000 +sql insert into ct1 using st tags(1) values($ms , 0)($ms1 , 1)($ms2 , 10)($ms3 , 11) +sql insert into ct2 using st tags(2) values($ms2 , 2)($ms3 , 3) +sql insert into ct3 using st tags(3) values($ms4 , 4)($ms5 , 5) +sql insert into ct4 using st tags(4) values($ms6 , 6)($ms7 , 7) + +sql select count(*), spread(ts) from st where tbname='ct1' print $data00, $data01 if $data00 != @4@ then return -1 diff --git a/tests/script/tsim/stream/basic5.sim b/tests/script/tsim/stream/basic5.sim index 583c803e4e..f507ab7d3b 100644 --- a/tests/script/tsim/stream/basic5.sim +++ b/tests/script/tsim/stream/basic5.sim @@ -15,6 +15,8 @@ sql use test3; sql create table t1(ts timestamp, a int, b int , c int, d double); sql create stream streams3 trigger at_once ignore expired 0 ignore update 0 into streamt3 as select _wstart, count(*) c1 from t1 state_window(a); +sleep 1000 + sql insert into t1 values(1648791211000,1,2,3,1.0); sql insert into t1 values(1648791213000,2,2,3,1.1); sql insert into t1 values(1648791215000,3,2,3,1.1); @@ -214,4 +216,232 @@ if $data[29][1] != 2 then goto loop11 endi +print step2============= + +sql create database test4 vgroups 4; +sql use test4; +sql create stable st(ts timestamp,a int,b int,c int,d double) tags(ta int,tb int,tc int); +sql create table t1 using st tags(1,1,1); +sql create table t2 using st tags(2,2,2); +sql create stream streams4 trigger at_once ignore expired 0 ignore update 0 into streamt4 as select _wstart, first(a), b, c, ta, tb from st interval(1s); + +sleep 1000 + +sql insert into t1 values(1648791211000,1,2,3,1.0); +sql insert into t1 values(1648791213000,2,3,4,1.1); +sql insert into t2 values(1648791215000,3,4,5,1.1); +sql insert into t2 values(1648791217000,4,5,6,1.1); + +$loop_count = 0 + +loop12: + +sleep 200 + +$loop_count = $loop_count + 1 +if $loop_count == 10 then + return -1 +endi + +print 1 select * from streamt4 order by 1; +sql select * from streamt4 order by 1; + +if $rows != 4 then + print ======rows=$rows + goto loop12 +endi + +if $data02 != 2 then + print ======data02=$data02 + goto loop12 +endi + +if $data03 != 3 then + print ======data03=$data03 + goto loop12 +endi + +if $data04 != 1 then + print ======data04=$data04 + goto loop12 +endi + +if $data05 != 1 then + print ======data05=$data05 + goto loop12 +endi + + +if $data22 != 4 then + print ======data22=$data22 + goto loop12 +endi + +if $data23 != 5 then + print ======data23=$data23 + goto loop12 +endi + +if $data24 != 2 then + print ======data24=$data24 + goto loop12 +endi + +if $data25 != 2 then + print ======data25=$data25 + goto loop12 +endi + +print step3============= + +sql create database test5 vgroups 4; +sql use test5; +sql create stable st(ts timestamp,a int,b int,c int,d double) tags(ta int,tb int,tc int); +sql create table t1 using st tags(1,1,1); +sql create table t2 using st tags(2,2,2); +sql create stream streams5 trigger at_once ignore expired 0 ignore update 0 into streamt5 as select _wstart, b, c, ta, tb, max(b) from t1 interval(1s); + +sleep 1000 + +sql insert into t1 values(1648791211000,1,2,3,1.0); +sql insert into t1 values(1648791213000,2,3,4,1.1); +sql insert into t1 values(1648791215000,3,4,5,1.1); +sql insert into t1 values(1648791217000,4,5,6,1.1); + +$loop_count = 0 + +loop13: + +sleep 200 + +$loop_count = $loop_count + 1 +if $loop_count == 10 then + return -1 +endi + +print 1 select * from streamt5 order by 1; +sql select * from streamt5 order by 1; + +if $rows != 4 then + print ======rows=$rows + goto loop13 +endi + +if $data01 != 2 then + print ======data02=$data02 + goto loop13 +endi + +if $data02 != 3 then + print ======data03=$data03 + goto loop13 +endi + +if $data03 != 1 then + print ======data04=$data04 + goto loop13 +endi + +if $data04 != 1 then + print ======data05=$data05 + goto loop13 +endi + + +if $data21 != 4 then + print ======data22=$data22 + goto loop13 +endi + +if $data22 != 5 then + print ======data23=$data23 + goto loop13 +endi + +if $data23 != 1 then + print ======data24=$data24 + goto loop13 +endi + +if $data24 != 1 then + print ======data25=$data25 + goto loop13 +endi + +print step4============= + +sql create database test6 vgroups 4; +sql use test6; +sql create stable st(ts timestamp,a int,b int,c int,d double) tags(ta int,tb int,tc int); +sql create table t1 using st tags(1,1,1); +sql create table t2 using st tags(2,2,2); +sql create stream streams6 trigger at_once ignore expired 0 ignore update 0 into streamt6 as select _wstart, b, c,min(c), ta, tb from st interval(1s); + +sleep 1000 + +sql insert into t1 values(1648791211000,1,2,3,1.0); +sql insert into t1 values(1648791213000,2,3,4,1.1); +sql insert into t2 values(1648791215000,3,4,5,1.1); +sql insert into t2 values(1648791217000,4,5,6,1.1); + +$loop_count = 0 + +loop14: + +sleep 200 + +$loop_count = $loop_count + 1 +if $loop_count == 10 then + return -1 +endi + +print 1 select * from streamt6 order by 1; +sql select * from streamt6 order by 1; + +if $rows != 4 then + print ======rows=$rows + goto loop14 +endi + +if $data01 != 2 then + print ======data02=$data02 + goto loop14 +endi + +if $data02 != 3 then + print ======data03=$data03 + goto loop14 +endi + +if $data04 != 1 then + print ======data04=$data04 + goto loop14 +endi + +if $data05 != 1 then + print ======data05=$data05 + goto loop14 +endi + + +if $data21 != 4 then + print ======data22=$data22 + goto loop14 +endi + +if $data22 != 5 then + print ======data23=$data23 + goto loop14 +endi + +if $data24 != 2 then + print ======data24=$data24 + goto loop14 +endi + +if $data25 != 2 then + print ======data25=$data25 + goto loop14 +endi + system sh/exec.sh -n dnode1 -s stop -x SIGINT \ No newline at end of file diff --git a/tests/system-test/0-others/information_schema.py b/tests/system-test/0-others/information_schema.py index 63718417b4..c3d65482fc 100644 --- a/tests/system-test/0-others/information_schema.py +++ b/tests/system-test/0-others/information_schema.py @@ -50,10 +50,11 @@ class TDTestCase: self.tbnum = 20 self.rowNum = 10 self.tag_dict = { - 't0':'int' + 't0':'int', + 't1':f'nchar({self.nchar_length})' } self.tag_values = [ - f'1' + f'1', '""' ] self.binary_str = 'taosdata' self.nchar_str = '涛思数据' @@ -72,7 +73,7 @@ class TDTestCase: tdSql.execute(f'use {self.dbname}') tdSql.execute(self.setsql.set_create_stable_sql(self.stbname,self.column_dict,self.tag_dict)) for i in range(self.tbnum): - tdSql.execute(f"create table {self.stbname}_{i} using {self.stbname} tags({self.tag_values[0]})") + tdSql.execute(f"create table {self.stbname}_{i} using {self.stbname} tags({self.tag_values[0]}, {self.tag_values[1]})") self.insert_data(self.column_dict,f'{self.stbname}_{i}',self.rowNum) def count_check(self): tdSql.query('select count(*) from information_schema.ins_tables') @@ -313,6 +314,11 @@ class TDTestCase: tdSql.error('alter cluster "activeCode" ""') tdSql.execute('alter cluster "activeCode" "revoked"') + def test_query_ins_tags(self): + sql = f'select tag_name, tag_value from information_schema.ins_tags where table_name = "{self.stbname}_0"' + tdSql.query(sql) + tdSql.checkRows(2) + def run(self): self.prepare_data() self.count_check() @@ -322,6 +328,7 @@ class TDTestCase: self.ins_stable_check2() self.ins_dnodes_check() self.ins_grants_check() + self.test_query_ins_tags() def stop(self): diff --git a/tests/system-test/2-query/cast.py b/tests/system-test/2-query/cast.py index ede1f28324..352395b830 100644 --- a/tests/system-test/2-query/cast.py +++ b/tests/system-test/2-query/cast.py @@ -79,6 +79,10 @@ class TDTestCase: tdSql.query(f"select cast(c1 as binary(32)) as b from {self.dbname}.t1") for i in range(len(data_t1_c1)): tdSql.checkData( i, 0, str(data_t1_c1[i]) ) + + tdSql.query(f"select cast(c1 as binary) as b from {self.dbname}.t1") + for i in range(len(data_t1_c1)): + tdSql.checkData( i, 0, str(data_t1_c1[i]) ) tdLog.printNoPrefix("==========step6: cast int to nchar, expect changes to str(int) ") @@ -130,6 +134,13 @@ class TDTestCase: tdSql.query(f"select cast(c2 as binary(32)) as b from {self.dbname}.t1") for i in range(len(data_t1_c2)): tdSql.checkData( i, 0, str(data_t1_c2[i]) ) + + tdSql.query(f"select cast(c2 as binary) as b from {self.dbname}.ct4") + for i in range(len(data_ct4_c2)): + tdSql.checkData( i, 0, str(data_ct4_c2[i]) ) + tdSql.query(f"select cast(c2 as binary) as b from {self.dbname}.t1") + for i in range(len(data_t1_c2)): + tdSql.checkData( i, 0, str(data_t1_c2[i]) ) tdLog.printNoPrefix("==========step10: cast bigint to nchar, expect changes to str(int) ") @@ -184,6 +195,13 @@ class TDTestCase: tdSql.query(f"select cast(c3 as binary(32)) as b from {self.dbname}.t1") for i in range(len(data_t1_c3)): tdSql.checkData( i, 0, str(data_t1_c3[i]) ) + + tdSql.query(f"select cast(c3 as binary) as b from {self.dbname}.ct4") + for i in range(len(data_ct4_c3)): + tdSql.checkData( i, 0, str(data_ct4_c3[i]) ) + tdSql.query(f"select cast(c3 as binary) as b from {self.dbname}.t1") + for i in range(len(data_t1_c3)): + tdSql.checkData( i, 0, str(data_t1_c3[i]) ) tdLog.printNoPrefix("==========step14: cast smallint to nchar, expect changes to str(int) ") @@ -235,6 +253,13 @@ class TDTestCase: tdSql.query(f"select cast(c4 as binary(32)) as b from {self.dbname}.t1") for i in range(len(data_t1_c4)): tdSql.checkData( i, 0, str(data_t1_c4[i]) ) + + tdSql.query(f"select cast(c4 as binary) as b from {self.dbname}.ct4") + for i in range(len(data_ct4_c4)): + tdSql.checkData( i, 0, str(data_ct4_c4[i]) ) + tdSql.query(f"select cast(c4 as binary) as b from {self.dbname}.t1") + for i in range(len(data_t1_c4)): + tdSql.checkData( i, 0, str(data_t1_c4[i]) ) tdLog.printNoPrefix("==========step18: cast tinyint to nchar, expect changes to str(int) ") @@ -282,6 +307,12 @@ class TDTestCase: for i in range(len(data_ct4_c5)): tdSql.checkData( i, 0, str(data_ct4_c5[i]) ) if data_ct4_c5[i] is None else tdSql.checkData( i, 0, f'{data_ct4_c5[i]:.6f}' ) tdSql.query(f"select cast(c5 as binary(32)) as b from {self.dbname}.t1") + for i in range(len(data_t1_c5)): + tdSql.checkData( i, 0, str(data_t1_c5[i]) ) if data_t1_c5[i] is None else tdSql.checkData( i, 0, f'{data_t1_c5[i]:.6f}' ) + tdSql.query(f"select cast(c5 as binary) as b from {self.dbname}.ct4") + for i in range(len(data_ct4_c5)): + tdSql.checkData( i, 0, str(data_ct4_c5[i]) ) if data_ct4_c5[i] is None else tdSql.checkData( i, 0, f'{data_ct4_c5[i]:.6f}' ) + tdSql.query(f"select cast(c5 as binary) as b from {self.dbname}.t1") for i in range(len(data_t1_c5)): tdSql.checkData( i, 0, str(data_t1_c5[i]) ) if data_t1_c5[i] is None else tdSql.checkData( i, 0, f'{data_t1_c5[i]:.6f}' ) @@ -290,6 +321,12 @@ class TDTestCase: for i in range(len(data_ct4_c5)): tdSql.checkData( i, 0, None ) if data_ct4_c5[i] is None else tdSql.checkData( i, 0, f'{data_ct4_c5[i]:.6f}' ) tdSql.query(f"select cast(c5 as nchar(32)) as b from {self.dbname}.t1") + for i in range(len(data_t1_c5)): + tdSql.checkData( i, 0, None ) if data_t1_c5[i] is None else tdSql.checkData( i, 0, f'{data_t1_c5[i]:.6f}' ) + tdSql.query(f"select cast(c5 as nchar) as b from {self.dbname}.t1") + for i in range(len(data_t1_c5)): + tdSql.checkData( i, 0, None ) if data_t1_c5[i] is None else tdSql.checkData( i, 0, f'{data_t1_c5[i]:.6f}' ) + tdSql.query(f"select cast(c5 as varchar) as b from {self.dbname}.t1") for i in range(len(data_t1_c5)): tdSql.checkData( i, 0, None ) if data_t1_c5[i] is None else tdSql.checkData( i, 0, f'{data_t1_c5[i]:.6f}' ) @@ -580,6 +617,10 @@ class TDTestCase: ( tdSql.checkData(i, 0, '12121.233231') for i in range(tdSql.queryRows) ) tdSql.query(f"select cast(12121.23323131 + 'test~!@`#$%^&*(){'}'}{'{'}][;><.,' as binary(2)) as b from {self.dbname}.ct4") ( tdSql.checkData(i, 0, '12') for i in range(tdSql.queryRows) ) + tdSql.query(f"select cast(12121.23323131 + 'test~!@`#$%^&*(){'}'}{'{'}][;><.,' as binary) as b from {self.dbname}.ct4") + ( tdSql.checkData(i, 0, '12121.233231') for i in range(tdSql.queryRows) ) + tdSql.query(f"select cast(12121.23323131 + 'test~!@`#$%^&*(){'}'}{'{'}][;><.,' as binary) as b from {self.dbname}.ct4") + ( tdSql.checkData(i, 0, '12') for i in range(tdSql.queryRows) ) tdSql.query(f"select cast(12121.23323131 + 'test~!@`#$%^&*(){'}'}{'{'}][;><.,' as nchar(16)) as b from {self.dbname}.ct4") ( tdSql.checkData(i, 0, '12121.233231') for i in range(tdSql.queryRows) ) tdSql.query(f"select cast(12121.23323131 + 'test~!@`#$%^&*(){'}'}{'{'}][;><.,' as nchar(2)) as b from {self.dbname}.ct4") diff --git a/tests/system-test/2-query/count.py b/tests/system-test/2-query/count.py index c06ee28d02..6d34dde791 100644 --- a/tests/system-test/2-query/count.py +++ b/tests/system-test/2-query/count.py @@ -103,6 +103,10 @@ class TDTestCase: tdSql.checkRows(row) tdSql.query(f'select {function_name}(c1),sum(c1) from {self.stbname} partition by tbname') tdSql.checkRows(row) + tdSql.query(f'select t0, {function_name}(c1),sum(c1) from {self.stbname} partition by tbname') + tdSql.checkRows(row) + tdSql.query(f'select cast(t0 as binary(12)), {function_name}(c1),sum(c1) from {self.stbname} partition by tbname') + tdSql.checkRows(row) tdSql.query(f'select {function_name}(c1),sum(c1) from {self.stbname} partition by c1') tdSql.checkRows(0) tdSql.query(f'select {function_name}(c1),sum(c1) from {self.stbname} partition by t0') diff --git a/tests/system-test/2-query/csum.py b/tests/system-test/2-query/csum.py index b16f511491..e3ac529d5e 100644 --- a/tests/system-test/2-query/csum.py +++ b/tests/system-test/2-query/csum.py @@ -470,7 +470,9 @@ class TDTestCase: tdSql.checkRows(40) # bug need fix - tdSql.query("select tbname , csum(c1), csum(c12) from db.stb1 partition by tbname") + tdSql.query("select tbname , st1, csum(c1), csum(c12) from db.stb1 partition by tbname") + tdSql.checkRows(40) + tdSql.query("select tbname , cast(st1 as binary(24)), csum(c1), csum(c12) from db.stb1 partition by tbname") tdSql.checkRows(40) tdSql.query("select tbname , csum(st1) from db.stb1 partition by tbname") tdSql.checkRows(70) diff --git a/tests/system-test/2-query/group_partition.py b/tests/system-test/2-query/group_partition.py index 36e3afd3ca..4b236c1bce 100644 --- a/tests/system-test/2-query/group_partition.py +++ b/tests/system-test/2-query/group_partition.py @@ -91,15 +91,71 @@ class TDTestCase: tdSql.query(f"select t2, t3, c1, count(*) from {self.dbname}.{self.stable} {keyword} by t2, t3, c1 ") tdSql.checkRows(nonempty_tb_num * self.row_nums) + def test_groupby_sub_table(self): + for i in range(self.tb_nums): + tbname = f"{self.dbname}.sub_{self.stable}_{i}" + ts = self.ts + i*10000 + tdSql.query(f"select t1, t2, t3,count(*) from {tbname}") + tdSql.checkRows(1) + tdSql.checkData(0, 1, i) + tdSql.checkData(0, 2, i*10) + + tdSql.query(f"select cast(t2 as binary(12)),count(*) from {tbname}") + tdSql.checkRows(1) + tdSql.checkData(0, 0, i) + + tdSql.query(f"select t2 + 1, count(*) from {tbname}") + tdSql.checkRows(1) + tdSql.checkData(0, 0, i + 1) + + tdSql.query(f"select t1, t2, t3, count(*) from {tbname} group by tbname") + tdSql.checkRows(1) + tdSql.checkData(0, 1, i) + tdSql.checkData(0, 2, i*10) + + tdSql.query(f"select t1, t2, t3, count(*) from {tbname} group by tbname, c1, t4") + tdSql.checkData(0, 1, i) + tdSql.checkData(0, 2, i*10) + + tdSql.query(f"select t1, t2, t3, count(*) from {tbname} partition by tbname") + tdSql.checkRows(1) + tdSql.checkData(0, 1, i) + tdSql.checkData(0, 2, i*10) + + tdSql.query(f"select t1, t2, t3, count(*) from {tbname} partition by c1, tbname") + tdSql.checkData(0, 1, i) + tdSql.checkData(0, 2, i*10) + + tdSql.query(f"select t1, t2, t3, count(*) from {self.dbname}.{self.stable} partition by c1, tbname order by tbname desc") + tdSql.checkRows(50) + tdSql.checkData(0, 1, 4) + tdSql.checkData(0, 2, 40) + def test_multi_group_key(self, check_num, nonempty_tb_num): # multi tag/tbname tdSql.query(f"select t2, t3, tbname, count(*) from {self.dbname}.{self.stable} group by t2, t3, tbname") tdSql.checkRows(check_num) + tdSql.query(f"select cast(t2 as binary(12)), count(*) from {self.dbname}.{self.stable} group by t2, t3, tbname") + tdSql.checkRows(check_num) + tdSql.query(f"select t2, t3, tbname, count(*) from {self.dbname}.{self.stable} partition by t2, t3, tbname") tdSql.checkRows(check_num) + tdSql.query(f"select t2, t3, tbname, count(*) from {self.dbname}.{self.stable} group by tbname order by tbname asc") + tdSql.checkRows(check_num) + tdSql.checkData(0, 0, 0) + tdSql.checkData(1, 0, 1) + tdSql.checkData(2, 1, 20) + tdSql.checkData(3, 1, 30) + + tdSql.query(f"select t2, t3, tbname, count(*) from {self.dbname}.{self.stable} partition by tbname order by tbname asc") + tdSql.checkRows(check_num) + tdSql.checkData(0, 0, 0) + tdSql.checkData(2, 1, 20) + tdSql.checkData(3, 1, 30) + # multi tag + col tdSql.query(f"select t1, t2, c1, count(*) from {self.dbname}.{self.stable} partition by t1, t2, c1 ") tdSql.checkRows(nonempty_tb_num * self.row_nums) @@ -222,12 +278,14 @@ class TDTestCase: self.test_groupby('group', self.tb_nums, nonempty_tb_num) self.test_groupby('partition', self.tb_nums, nonempty_tb_num) + self.test_groupby_sub_table() self.test_innerSelect(self.tb_nums) self.test_multi_group_key(self.tb_nums, nonempty_tb_num) self.test_multi_agg(self.tb_nums, nonempty_tb_num) self.test_window(nonempty_tb_num) self.test_event_window(nonempty_tb_num) + ## test old version before changed # self.test_groupby('group', 0, 0) # self.insert_db(5, self.row_nums) diff --git a/tests/system-test/2-query/multi_res_function.py b/tests/system-test/2-query/multi_res_function.py new file mode 100644 index 0000000000..89038e5c08 --- /dev/null +++ b/tests/system-test/2-query/multi_res_function.py @@ -0,0 +1,130 @@ +################################################################### +# Copyright (c) 2016 by TAOS Technologies, Inc. +# All rights reserved. +# +# This file is proprietary and confidential to TAOS Technologies. +# No part of this file may be reproduced, stored, transmitted, +# disclosed or used in any form or by any means other than as +# expressly provided by the written permission from Jianhui Tao +# +################################################################### + +# -*- coding: utf-8 -*- + +import random +import string +import sys +import taos +from util.common import * +from util.log import * +from util.cases import * +from util.sql import * +import numpy as np + + +class TDTestCase: + def init(self, conn, logSql, replicaVar=1): + self.replicaVar = int(replicaVar) + tdLog.debug("start to execute %s" % __file__) + tdSql.init(conn.cursor()) + + self.rowNum = 10 + self.tbnum = 20 + self.ts = 1537146000000 + self.binary_str = 'taosdata' + self.nchar_str = '涛思数据' + + def first_check_base(self): + dbname = "db" + tdSql.prepare(dbname) + column_dict = { + 'col1': 'tinyint', + 'col2': 'smallint', + 'col3': 'int', + 'col4': 'bigint', + 'col5': 'tinyint unsigned', + 'col6': 'smallint unsigned', + 'col7': 'int unsigned', + 'col8': 'bigint unsigned', + 'col9': 'float', + 'col10': 'double', + 'col11': 'bool', + 'col12': 'binary(20)', + 'col13': 'nchar(20)' + } + tdSql.execute(f"alter local \'keepColumnName\' \'1\'") + tdSql.execute(f'''create table {dbname}.stb(ts timestamp, col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 tinyint unsigned, col6 smallint unsigned, + col7 int unsigned, col8 bigint unsigned, col9 float, col10 double, col11 bool, col12 binary(20), col13 nchar(20)) tags(loc nchar(20))''') + tdSql.execute(f"create table {dbname}.stb_1 using {dbname}.stb tags('beijing')") + tdSql.execute(f"create table {dbname}.stb_2 using {dbname}.stb tags('beijing')") + + column_list = ['col1','col2','col3','col4','col5','col6','col7','col8','col9','col10','col11','col12','col13'] + for i in column_list: + for j in ['stb_1']: + tdSql.query(f"select first({i}) from {dbname}.{j}") + tdSql.checkRows(0) + for n in range(self.rowNum): + i = n + tdSql.execute(f"insert into {dbname}.stb_1 values(%d, %d, %d, %d, %d, %d, %d, %d, %d, %f, %f, %d, '{self.binary_str}%d', '{self.nchar_str}%d')" + % (self.ts + i, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1)) + + for n in range(self.rowNum): + i = n + 10 + tdSql.execute(f"insert into {dbname}.stb_1 values(%d, %d, %d, %d, %d, %d, %d, %d, %d, %f, %f, %d, '{self.binary_str}%d', '{self.nchar_str}%d')" + % (self.ts + i, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1)) + + for n in range(self.rowNum): + i = n + 100 + tdSql.execute(f"insert into {dbname}.stb_2 values(%d, %d, %d, %d, %d, %d, %d, %d, %d, %f, %f, %d, '{self.binary_str}%d', '{self.nchar_str}%d')" + % (self.ts + i, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1, i + 1, i + 0.1, i + 0.1, i % 2, i + 1, i + 1)) + + for k, v in column_dict.items(): + + if v == 'tinyint' or v == 'smallint' or v == 'int' or v == 'bigint' or v == 'tinyint unsigned' or v == 'smallint unsigned'\ + or v == 'int unsigned' or v == 'bigint unsigned': + tdSql.query(f"select last({k})-first({k}) from {dbname}.stb") + tdSql.checkData(0, 0, 109) + tdSql.query(f"select first({k})+last({k}) from {dbname}.stb") + tdSql.checkData(0, 0, 111) + tdSql.query(f"select max({k})-first({k}) from {dbname}.stb") + tdSql.checkData(0, 0, 109) + tdSql.query(f"select max({k})-min({k}) from {dbname}.stb") + tdSql.checkData(0, 0, 109) + + tdSql.query(f"select last({k})-first({k}) from {dbname}.stb_1") + tdSql.checkData(0, 0, 19) + tdSql.query(f"select first({k})+last({k}) from {dbname}.stb_1") + tdSql.checkData(0, 0, 21) + tdSql.query(f"select max({k})-first({k}) from {dbname}.stb_1") + tdSql.checkData(0, 0, 19) + tdSql.query(f"select max({k})-min({k}) from {dbname}.stb_1") + tdSql.checkData(0, 0, 19) + + # float,double + elif v == 'float' or v == 'double': + tdSql.query(f"select first({k})+last({k}) from {dbname}.stb") + tdSql.checkData(0, 0, 109.2) + tdSql.query(f"select first({k})+last({k}) from {dbname}.stb_1") + tdSql.checkData(0, 0, 19.2) + # bool + elif v == 'bool': + continue + # binary + elif 'binary' in v: + continue + # nchar + elif 'nchar' in v: + continue + + #tdSql.execute(f'drop database {dbname}') + + def run(self): + self.first_check_base() + + + def stop(self): + tdSql.close() + tdLog.success("%s successfully executed" % __file__) + +tdCases.addWindows(__file__, TDTestCase()) +tdCases.addLinux(__file__, TDTestCase()) diff --git a/tests/system-test/7-tmq/tmq_ts4563.py b/tests/system-test/7-tmq/tmq_ts4563.py index fc1cc259ce..13f510ffe6 100644 --- a/tests/system-test/7-tmq/tmq_ts4563.py +++ b/tests/system-test/7-tmq/tmq_ts4563.py @@ -29,9 +29,11 @@ class TDTestCase: tdSql.execute(f'use db_stmt') tdSql.query("select ts,k from st") - tdSql.checkRows(2) + tdSql.checkRows(self.expected_affected_rows) tdSql.execute(f'create topic t_unorder_data as select ts,k from st') + tdSql.execute(f'create topic t_unorder_data_none as select i,k from st') + consumer_dict = { "group.id": "g1", "td.connect.user": "root", @@ -41,7 +43,7 @@ class TDTestCase: consumer = Consumer(consumer_dict) try: - consumer.subscribe(["t_unorder_data"]) + consumer.subscribe(["t_unorder_data", "t_unorder_data_none"]) except TmqError: tdLog.exit(f"subscribe error") @@ -51,18 +53,15 @@ class TDTestCase: res = consumer.poll(1) print(res) if not res: - if cnt == 0: + if cnt == 0 or cnt != 2*self.expected_affected_rows: tdLog.exit("consume error") break val = res.value() if val is None: continue for block in val: + print(block.fetchall(),len(block.fetchall())) cnt += len(block.fetchall()) - - if cnt != 2: - tdLog.exit("consume error") - finally: consumer.close() @@ -110,20 +109,32 @@ class TDTestCase: params = new_multi_binds(2) params[0].timestamp((1626861392589, 1626861392590)) params[1].int([3, None]) - + # print(type(stmt)) tdLog.debug("bind_param_batch start") stmt.bind_param_batch(params) + tdLog.debug("bind_param_batch end") stmt.execute() tdLog.debug("execute end") + conn.execute("flush database %s" % dbname) + + params1 = new_multi_binds(2) + params1[0].timestamp((1626861392587,1626861392586)) + params1[1].int([None,3]) + stmt.bind_param_batch(params1) + stmt.execute() + end = datetime.now() print("elapsed time: ", end - start) - assert stmt.affected_rows == 2 + print(stmt.affected_rows) + self.expected_affected_rows = 4 + if stmt.affected_rows != self.expected_affected_rows : + tdLog.exit("affected_rows error") tdLog.debug("close start") stmt.close() - + # conn.execute("drop database if exists %s" % dbname) conn.close() diff --git a/tests/system-test/8-stream/stream_basic.py b/tests/system-test/8-stream/stream_basic.py index 5167423ea3..ff16bee787 100644 --- a/tests/system-test/8-stream/stream_basic.py +++ b/tests/system-test/8-stream/stream_basic.py @@ -96,9 +96,28 @@ class TDTestCase: time.sleep(2) tdSql.query("select * from sta") tdSql.checkRows(3) + tdSql.query("select tbname from sta order by tbname") + if not tdSql.getData(0, 0).startswith('new-t1_1.d1.sta_'): + tdLog.exit("error1") + + if not tdSql.getData(1, 0).startswith('new-t2_1.d1.sta_'): + tdLog.exit("error2") + + if not tdSql.getData(2, 0).startswith('new-t3_1.d1.sta_'): + tdLog.exit("error3") tdSql.query("select * from stb") tdSql.checkRows(3) + tdSql.query("select tbname from stb order by tbname") + if not tdSql.getData(0, 0).startswith('new-t1_1.d1.stb_'): + tdLog.exit("error4") + + if not tdSql.getData(1, 0).startswith('new-t2_1.d1.stb_'): + tdLog.exit("error5") + + if not tdSql.getData(2, 0).startswith('new-t3_1.d1.stb_'): + tdLog.exit("error6") + # run def run(self): self.case1() diff --git a/tests/system-test/buildJson.py b/tests/system-test/buildJson.py deleted file mode 100644 index 6e9e9f83e1..0000000000 --- a/tests/system-test/buildJson.py +++ /dev/null @@ -1,243 +0,0 @@ -# 写一段python代码，生成一个JSON串，json 串为数组，数组长度为10000，每个元素为包含4000个key-value对的JSON字符串，json 数组里每个元素里的4000个key不相同，元素之间使用相同的key，key值为英文单词，value 为int值，且value 的范围是[0, 256]。把json串紧凑形式写入文件，把json串存入parquet文件中，把json串写入avro文件中,把json串写入到postgre sql表中，表有两列第一列主int类型主键，第二列为json类型，数组的每个元素写入json类型里 -import csv -import json -import os -import random -import string -import time - -from faker import Faker -import pandas as pd -import pyarrow as pa -import pyarrow.parquet as pq -import fastavro -import psycopg2 -from psycopg2.extras import Json - - -def get_dir_size(start_path='.'): - total = 0 - for dirpath, dirs, files in os.walk(start_path): - for f in files: - fp = os.path.join(dirpath, f) - # 获取文件大小并累加到total上 - total += os.path.getsize(fp) - return total - - -def to_avro_record(obj): - return {key: value for key, value in obj.items()} - - -def generate_random_string(length): - return ''.join(random.choices(string.ascii_letters + string.digits, k=length)) - - -def generate_random_values(t): - if t == 0: - return random.randint(-255, 256) - elif t == 1: - return random.randint(-2100000000, 2100000000) - elif t == 2: - return random.uniform(-10000.0, 10000.0) - elif t == 3: - return generate_random_string(10) - elif t == 4: - return random.choice([True, False]) - - -def generate_json_object(key_set, value_set): - values = [generate_random_values(t) for t in value_set] - return dict(zip(key_set, values)) - - -def generate_json_array(keys, values, array_length): - return [generate_json_object(keys, values) for _ in range(array_length)] - - -def write_parquet_file(parquet_file, json_array): - df = pd.DataFrame(json_array) - table = pa.Table.from_pandas(df) - pq.write_table(table, parquet_file + ".parquet") - - -def write_json_file(json_file, json_array): - with open(json_file + ".json", 'w') as f: - json.dump(json_array, f, separators=(',', ':')) - - -def generate_avro_schema(k, t): - if t == 0: - return {"name": k, "type": "int", "logicalType": "int"} - elif t == 1: - return {"name": k, "type": "int", "logicalType": "int"} - elif t == 2: - return {"name": k, "type": "float"} - elif t == 3: - return {"name": k, "type": "string"} - elif t == 4: - return {"name": k, "type": "boolean"} - - -def write_avro_file(avro_file, json_array, keys, values): - k = list(json_array[0].keys()) - - if keys != k: - raise ValueError("keys and values should have the same length") - - avro_schema = { - "type": "record", - "name": "MyRecord", - "fields": [generate_avro_schema(k, v) for k, v in dict(zip(keys, values)).items()] - } - - avro_records = [to_avro_record(obj) for obj in json_array] - with open(avro_file + ".avro", 'wb') as f: - fastavro.writer(f, avro_schema, avro_records) - - -def write_pg_file(json_array): - conn_str = "dbname=mydatabase user=myuser host=localhost" - conn = psycopg2.connect(conn_str) - cur = conn.cursor() - - cur.execute("drop table if exists my_table") - conn.commit() - - # 创建表（如果不存在） - cur.execute(""" - CREATE TABLE IF NOT EXISTS my_table ( - id SERIAL PRIMARY KEY, - json_data JSONB - ); - """) - conn.commit() - - # 执行SQL查询 - cur.execute("SELECT count(*) FROM my_table") - # 获取查询结果 - rows = cur.fetchall() - # 打印查询结果 - for row in rows: - print("rows before:", row[0]) - - # 插入数据 - for idx, json_obj in enumerate(json_array): - # print(json.dumps(json_obj)) - cur.execute("INSERT INTO my_table (json_data) VALUES (%s)", (json.dumps(json_obj),)) - - conn.commit() # 提交事务 - - # 执行SQL查询 - cur.execute("SELECT count(*) FROM my_table") - # 获取查询结果 - rows = cur.fetchall() - # 打印查询结果 - for row in rows: - print("rows after:", row[0]) - - # # 执行SQL查询 - # cur.execute("SELECT pg_relation_size('my_table')") - # # 获取查询结果 - # rows = cur.fetchall() - # # 打印查询结果 - # size = 0 - # for row in rows: - # size = row[0] - # print("table size:", row[0]) - - # 关闭游标和连接 - cur.close() - conn.close() - -def read_parquet_file(parquet_file): - table = pq.read_table(parquet_file + ".parquet") - df = table.to_pandas() - print(df) - - -def read_avro_file(avg_file): - with open(avg_file + ".avro", 'rb') as f: - reader = fastavro.reader(f) - - for record in reader: - print(record) - - -def read_json_file(csv_file): - with open(csv_file + ".json", 'r') as f: - data = json.load(f) - print(data) - - -def main(): - key_length = 7 - key_sizes = 4000 - row_sizes = 10000 - file_name = "output" - - # cases = [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (0, 4)] - cases = [(2, 2), (3, 3), (0, 4)] - - for data in cases: - begin, end = data - print(f"执行类型：{begin}-{end}") - - N = 2 - for _ in range(N): - - t0 = time.time() - - keys = [generate_random_string(key_length) for _ in range(key_sizes)] - values = [random.randint(begin, end) for _ in range(key_sizes)] - # 生成JSON数组 - json_array = generate_json_array(keys, values, row_sizes) - - t1 = time.time() - - write_json_file(file_name, json_array) - - t2 = time.time() - - write_parquet_file(file_name, json_array) - - t3 = time.time() - - write_avro_file(file_name, json_array, keys, values) - - t4 = time.time() - - size = write_pg_file(json_array) - - t5 = time.time() - - print("生成json 速度：", t2 - t0, "文件大小：", os.path.getsize(file_name + ".json")) - print("parquet 速度：", t3 - t2, "文件大小：", os.path.getsize(file_name + ".parquet")) - print("avro 速度：", t4 - t3, "文件大小：", os.path.getsize(file_name + ".avro")) - print("pg json 速度：", t5 - t4, "文件大小：", get_dir_size("/opt/homebrew/var/postgresql@14/base/16385") - 8 * 1024 * 1024) - - # read_json_file(file_name) - # read_parquet_file(file_name) - # read_avro_file(file_name) - print(f"\n---------------\n") - -if __name__ == "__main__": - main() - -# 压缩文件 -# import os -# -# import lz4.frame -# -# -# files =["output.json", "output.parquet", "output.avro"] -# def compress_file(input_path, output_path): -# with open(input_path, 'rb') as f_in: -# compressed_data = lz4.frame.compress(f_in.read()) -# -# with open(output_path, 'wb') as f_out: -# f_out.write(compressed_data) -# -# for file in files: -# compress_file(file, file + ".lz4") -# print(file, "origin size:", os.path.getsize(file), " after lsz size:", os.path.getsize(file + ".lz4")) diff --git a/tools/CMakeLists.txt b/tools/CMakeLists.txt index a1c5405253..188abb4b58 100644 --- a/tools/CMakeLists.txt +++ b/tools/CMakeLists.txt @@ -18,7 +18,7 @@ IF (TD_WEBSOCKET) COMMAND git clean -f -d BUILD_COMMAND COMMAND cargo update - COMMAND RUSTFLAGS=-Ctarget-feature=-crt-static cargo build --release -p taos-ws-sys --features native-tls + COMMAND RUSTFLAGS=-Ctarget-feature=-crt-static cargo build --release -p taos-ws-sys --features rustls INSTALL_COMMAND COMMAND cp target/release/${websocket_lib_file} ${CMAKE_BINARY_DIR}/build/lib COMMAND cmake -E make_directory ${CMAKE_BINARY_DIR}/build/include @@ -37,7 +37,7 @@ IF (TD_WEBSOCKET) COMMAND git clean -f -d BUILD_COMMAND COMMAND cargo update - COMMAND cargo build --release -p taos-ws-sys --features native-tls-vendored + COMMAND cargo build --release -p taos-ws-sys --features rustls INSTALL_COMMAND COMMAND cp target/release/taosws.dll ${CMAKE_BINARY_DIR}/build/lib COMMAND cp target/release/taosws.dll.lib ${CMAKE_BINARY_DIR}/build/lib/taosws.lib @@ -57,7 +57,7 @@ IF (TD_WEBSOCKET) COMMAND git clean -f -d BUILD_COMMAND COMMAND cargo update - COMMAND cargo build --release -p taos-ws-sys --features native-tls-vendored + COMMAND cargo build --release -p taos-ws-sys --features rustls INSTALL_COMMAND COMMAND cp target/release/${websocket_lib_file} ${CMAKE_BINARY_DIR}/build/lib COMMAND cmake -E make_directory ${CMAKE_BINARY_DIR}/build/include