diff --git a/docs/zh/07-develop/07-tmq.mdx b/docs/zh/07-develop/07-tmq.mdx index df651eab96..a852e71ff4 100644 --- a/docs/zh/07-develop/07-tmq.mdx +++ b/docs/zh/07-develop/07-tmq.mdx @@ -91,6 +91,7 @@ TDengine 会为 WAL 文件自动创建索引以支持快速随机访问，并提 不同语言下， TMQ 订阅相关的 API 及数据结构如下（详细的接口说明可以参考连接器章节，注意consumer结构不是线程安全的，在一个线程使用consumer时，不要在另一个线程close这个consumer）： + ```c @@ -101,17 +102,17 @@ TDengine 会为 WAL 文件自动创建索引以支持快速随机访问，并提 typedef void(tmq_commit_cb(tmq_t *tmq, int32_t code, void *param)); typedef enum tmq_conf_res_t { - TMQ_CONF_UNKNOWN = -2, - TMQ_CONF_INVALID = -1, - TMQ_CONF_OK = 0, - } tmq_conf_res_t; + TMQ_CONF_UNKNOWN = -2, + TMQ_CONF_INVALID = -1, + TMQ_CONF_OK = 0, + } tmq_conf_res_t; typedef struct tmq_topic_assignment { - int32_t vgId; - int64_t currentOffset; - int64_t begin; - int64_t end; - } tmq_topic_assignment; + int32_t vgId; + int64_t currentOffset; + int64_t begin; + int64_t end; + } tmq_topic_assignment; DLL_EXPORT tmq_conf_t *tmq_conf_new(); DLL_EXPORT tmq_conf_res_t tmq_conf_set(tmq_conf_t *conf, const char *key, const char *value); @@ -146,7 +147,6 @@ TDengine 会为 WAL 文件自动创建索引以支持快速随机访问，并提 DLL_EXPORT int64_t tmq_get_vgroup_offset(TAOS_RES* res); DLL_EXPORT const char *tmq_err2str(int32_t code); ``` - @@ -250,281 +250,280 @@ TDengine 会为 WAL 文件自动创建索引以支持快速随机访问，并提 + futures::Stream< Item = Result<(Self::Offset, MessageSet), Self::Error>, >, - >, - >; - async fn commit(&self, offset: Self::Offset) -> Result<(), Self::Error>; + >, + >; + async fn commit(&self, offset: Self::Offset) -> Result<(), Self::Error>; - async fn unsubscribe(self); - ``` + async fn unsubscribe(self); + ``` - 可在 上查看详细 API 说明。 + 可在 上查看详细 API 说明。 - + - + - ```js - function TMQConsumer(config) + ```js + function TMQConsumer(config) + + function subscribe(topic) + + function consume(timeout) + + function subscription() + + function unsubscribe() + + function commit(msg) + + function close() + ``` - function subscribe(topic) + - function consume(timeout) + - function subscription() + ```csharp + class ConsumerBuilder + + ConsumerBuilder(IEnumerable> config) + + public IConsumer Build() + + void Subscribe(IEnumerable topics) + + void Subscribe(string topic) + + ConsumeResult Consume(int millisecondsTimeout) + + List Subscription() + + void Unsubscribe() + + List Commit() + + void Close() + ``` + + - function unsubscribe() +# 数据订阅示例 +## 写入数据 - function commit(msg) +首先完成建库、建一张超级表和多张子表操作，然后就可以写入数据了，比如： - function close() - ``` - - - - - - ```csharp - class ConsumerBuilder - - ConsumerBuilder(IEnumerable> config) - - public IConsumer Build() - - void Subscribe(IEnumerable topics) - - void Subscribe(string topic) - - ConsumeResult Consume(int millisecondsTimeout) - - List Subscription() - - void Unsubscribe() - - List Commit() - - void Close() - ``` - - - - - # 数据订阅示例 - ## 写入数据 - - 首先完成建库、建一张超级表和多张子表操作，然后就可以写入数据了，比如： - - ```sql - DROP DATABASE IF EXISTS tmqdb; - CREATE DATABASE tmqdb WAL_RETENTION_PERIOD 3600; - CREATE TABLE tmqdb.stb (ts TIMESTAMP, c1 INT, c2 FLOAT, c3 VARCHAR(16)) TAGS(t1 INT, t3 VARCHAR(16)); - CREATE TABLE tmqdb.ctb0 USING tmqdb.stb TAGS(0, "subtable0"); - CREATE TABLE tmqdb.ctb1 USING tmqdb.stb TAGS(1, "subtable1"); - INSERT INTO tmqdb.ctb0 VALUES(now, 0, 0, 'a0')(now+1s, 0, 0, 'a00'); +```sql +DROP DATABASE IF EXISTS tmqdb; +CREATE DATABASE tmqdb WAL_RETENTION_PERIOD 3600; +CREATE TABLE tmqdb.stb (ts TIMESTAMP, c1 INT, c2 FLOAT, c3 VARCHAR(16)) TAGS(t1 INT, t3 VARCHAR(16)); +CREATE TABLE tmqdb.ctb0 USING tmqdb.stb TAGS(0, "subtable0"); +CREATE TABLE tmqdb.ctb1 USING tmqdb.stb TAGS(1, "subtable1"); +INSERT INTO tmqdb.ctb0 VALUES(now, 0, 0, 'a0')(now+1s, 0, 0, 'a00'); INSERT INTO tmqdb.ctb1 VALUES(now, 1, 1, 'a1')(now+1s, 11, 11, 'a11'); ``` ## 创建 topic - 使用 SQL 创建一个 topic： +使用 SQL 创建一个 topic： - ```sql - CREATE TOPIC topic_name AS SELECT ts, c1, c2, c3 FROM tmqdb.stb WHERE c1 > 1; - ``` +```sql +CREATE TOPIC topic_name AS SELECT ts, c1, c2, c3 FROM tmqdb.stb WHERE c1 > 1; +``` - ## 创建消费者 *consumer* +## 创建消费者 *consumer* - 对于不同编程语言，其设置方式如下： +对于不同编程语言，其设置方式如下： - - + - ```c - /* 根据需要，设置消费组 (group.id)、自动提交 (enable.auto.commit)、 - 自动提交时间间隔 (auto.commit.interval.ms)、用户名 (td.connect.user)、密码 (td.connect.pass) 等参数 */ - tmq_conf_t* conf = tmq_conf_new(); - tmq_conf_set(conf, "enable.auto.commit", "true"); - tmq_conf_set(conf, "auto.commit.interval.ms", "1000"); - tmq_conf_set(conf, "group.id", "cgrpName"); - tmq_conf_set(conf, "td.connect.user", "root"); - tmq_conf_set(conf, "td.connect.pass", "taosdata"); - tmq_conf_set(conf, "auto.offset.reset", "latest"); - tmq_conf_set(conf, "msg.with.table.name", "true"); - tmq_conf_set_auto_commit_cb(conf, tmq_commit_cb_print, NULL); + + ```c + /* 根据需要，设置消费组 (group.id)、自动提交 (enable.auto.commit)、 + 自动提交时间间隔 (auto.commit.interval.ms)、用户名 (td.connect.user)、密码 (td.connect.pass) 等参数 */ + tmq_conf_t* conf = tmq_conf_new(); + tmq_conf_set(conf, "enable.auto.commit", "true"); + tmq_conf_set(conf, "auto.commit.interval.ms", "1000"); + tmq_conf_set(conf, "group.id", "cgrpName"); + tmq_conf_set(conf, "td.connect.user", "root"); + tmq_conf_set(conf, "td.connect.pass", "taosdata"); + tmq_conf_set(conf, "auto.offset.reset", "latest"); + tmq_conf_set(conf, "msg.with.table.name", "true"); + tmq_conf_set_auto_commit_cb(conf, tmq_commit_cb_print, NULL); - tmq_t* tmq = tmq_consumer_new(conf, NULL, 0); - tmq_conf_destroy(conf); - ``` - - - - - 对于 Java 程序，还可以使用如下配置项： - - | 参数名称 | 类型 | 参数说明 | - | ----------------------------- | ------ | ----------------------------------------------------------------------------------------------------------------------------- | - | `td.connect.type` | string | 连接类型，"jni" 指原生连接，"ws" 指 websocket 连接，默认值为 "jni" | - | `bootstrap.servers` | string | 连接地址，如 `localhost:6030` | - | `value.deserializer` | string | 值解析方法，使用此方法应实现 `com.taosdata.jdbc.tmq.Deserializer` 接口或继承 `com.taosdata.jdbc.tmq.ReferenceDeserializer` 类 | - | `value.deserializer.encoding` | string | 指定字符串解析的字符集 | | - - 需要注意：此处使用 `bootstrap.servers` 替代 `td.connect.ip` 和 `td.connect.port`，以提供与 Kafka 一致的接口。 - - ```java - Properties properties = new Properties(); - properties.setProperty("enable.auto.commit", "true"); - properties.setProperty("auto.commit.interval.ms", "1000"); - properties.setProperty("group.id", "cgrpName"); - properties.setProperty("bootstrap.servers", "127.0.0.1:6030"); - properties.setProperty("td.connect.user", "root"); - properties.setProperty("td.connect.pass", "taosdata"); - properties.setProperty("auto.offset.reset", "latest"); - properties.setProperty("msg.with.table.name", "true"); - properties.setProperty("value.deserializer", "com.taos.example.MetersDeserializer"); - - TaosConsumer consumer = new TaosConsumer<>(properties); - - /* value deserializer definition. */ - import com.taosdata.jdbc.tmq.ReferenceDeserializer; - - public class MetersDeserializer extends ReferenceDeserializer { - } - ``` - - - - - - ```go - conf := &tmq.ConfigMap{ - "group.id": "test", - "auto.offset.reset": "latest", - "td.connect.ip": "127.0.0.1", - "td.connect.user": "root", - "td.connect.pass": "taosdata", - "td.connect.port": "6030", - "client.id": "test_tmq_c", - "enable.auto.commit": "false", - "msg.with.table.name": "true", - } - consumer, err := NewConsumer(conf) - ``` - - - - - - ```rust - let mut dsn: Dsn = "taos://".parse()?; - dsn.set("group.id", "group1"); - dsn.set("client.id", "test"); - dsn.set("auto.offset.reset", "latest"); - - let tmq = TmqBuilder::from_dsn(dsn)?; - - let mut consumer = tmq.build()?; - ``` - - - - - - Python 语言下引入 `taos` 库的 `Consumer` 类，创建一个 Consumer 示例： - - ```python - from taos.tmq import Consumer - - # Syntax: `consumer = Consumer(configs)` - # - # Example: - consumer = Consumer( - { - "group.id": "local", - "client.id": "1", - "enable.auto.commit": "true", - "auto.commit.interval.ms": "1000", - "td.connect.ip": "127.0.0.1", - "td.connect.user": "root", - "td.connect.pass": "taosdata", - "auto.offset.reset": "latest", - "msg.with.table.name": "true", - } - ) - ``` - - - - - - ```js - // 根据需要，设置消费组 (group.id)、自动提交 (enable.auto.commit)、 - // 自动提交时间间隔 (auto.commit.interval.ms)、用户名 (td.connect.user)、密码 (td.connect.pass) 等参数 - - let consumer = taos.consumer({ -'enable.auto.commit': 'true', - 'auto.commit.interval.ms','1000', - 'group.id': 'tg2', - 'td.connect.user': 'root', - 'td.connect.pass': 'taosdata', - 'auto.offset.reset','latest', - 'msg.with.table.name': 'true', - 'td.connect.ip','127.0.0.1', - 'td.connect.port','6030' - }); + tmq_t* tmq = tmq_consumer_new(conf, NULL, 0); + tmq_conf_destroy(conf); ``` + - + - - - ```csharp - var cfg = new Dictionary() - { - { "group.id", "group1" }, - { "auto.offset.reset", "latest" }, - { "td.connect.ip", "127.0.0.1" }, - { "td.connect.user", "root" }, - { "td.connect.pass", "taosdata" }, - { "td.connect.port", "6030" }, - { "client.id", "tmq_example" }, - { "enable.auto.commit", "true" }, - { "msg.with.table.name", "false" }, - }; - var consumer = new ConsumerBuilder>(cfg).Build(); + 对于 Java 程序，还可以使用如下配置项： + + | 参数名称 | 类型 | 参数说明 | + | ----------------------------- | ------ | ----------------------------------------------------------------------------------------------------------------------------- | + | `td.connect.type` | string | 连接类型，"jni" 指原生连接，"ws" 指 websocket 连接，默认值为 "jni" | + | `bootstrap.servers` | string | 连接地址，如 `localhost:6030` | + | `value.deserializer` | string | 值解析方法，使用此方法应实现 `com.taosdata.jdbc.tmq.Deserializer` 接口或继承 `com.taosdata.jdbc.tmq.ReferenceDeserializer` 类 | + | `value.deserializer.encoding` | string | 指定字符串解析的字符集 | | + + 需要注意：此处使用 `bootstrap.servers` 替代 `td.connect.ip` 和 `td.connect.port`，以提供与 Kafka 一致的接口。 + + ```java + Properties properties = new Properties(); + properties.setProperty("enable.auto.commit", "true"); + properties.setProperty("auto.commit.interval.ms", "1000"); + properties.setProperty("group.id", "cgrpName"); + properties.setProperty("bootstrap.servers", "127.0.0.1:6030"); + properties.setProperty("td.connect.user", "root"); + properties.setProperty("td.connect.pass", "taosdata"); + properties.setProperty("auto.offset.reset", "latest"); + properties.setProperty("msg.with.table.name", "true"); + properties.setProperty("value.deserializer", "com.taos.example.MetersDeserializer"); + + TaosConsumer consumer = new TaosConsumer<>(properties); + + /* value deserializer definition. */ + import com.taosdata.jdbc.tmq.ReferenceDeserializer; + + public class MetersDeserializer extends ReferenceDeserializer { + } ``` + - + + + ```go + conf := &tmq.ConfigMap{ + "group.id": "test", + "auto.offset.reset": "latest", + "td.connect.ip": "127.0.0.1", + "td.connect.user": "root", + "td.connect.pass": "taosdata", + "td.connect.port": "6030", + "client.id": "test_tmq_c", + "enable.auto.commit": "false", + "msg.with.table.name": "true", + } + consumer, err := NewConsumer(conf) + ``` + + - + + + ```rust + let mut dsn: Dsn = "taos://".parse()?; + dsn.set("group.id", "group1"); + dsn.set("client.id", "test"); + dsn.set("auto.offset.reset", "latest"); + + let tmq = TmqBuilder::from_dsn(dsn)?; + + let mut consumer = tmq.build()?; + ``` + + - 上述配置中包括 consumer group ID，如果多个 consumer 指定的 consumer group ID 一样，则自动形成一个 consumer group，共享消费进度。 + + + Python 语言下引入 `taos` 库的 `Consumer` 类，创建一个 Consumer 示例： + + ```python + from taos.tmq import Consumer + + # Syntax: `consumer = Consumer(configs)` + # + # Example: + consumer = Consumer( + { + "group.id": "local", + "client.id": "1", + "enable.auto.commit": "true", + "auto.commit.interval.ms": "1000", + "td.connect.ip": "127.0.0.1", + "td.connect.user": "root", + "td.connect.pass": "taosdata", + "auto.offset.reset": "latest", + "msg.with.table.name": "true", + } + ) + ``` + + - ## 订阅 *topics* + + + ```js + // 根据需要，设置消费组 (group.id)、自动提交 (enable.auto.commit)、 + // 自动提交时间间隔 (auto.commit.interval.ms)、用户名 (td.connect.user)、密码 (td.connect.pass) 等参数 + + let consumer = taos.consumer({ + 'enable.auto.commit': 'true', + 'auto.commit.interval.ms','1000', + 'group.id': 'tg2', + 'td.connect.user': 'root', + 'td.connect.pass': 'taosdata', + 'auto.offset.reset','latest', + 'msg.with.table.name': 'true', + 'td.connect.ip','127.0.0.1', + 'td.connect.port','6030' + }); + ``` + + - 一个 consumer 支持同时订阅多个 topic。 + + + ```csharp + var cfg = new Dictionary() + { + { "group.id", "group1" }, + { "auto.offset.reset", "latest" }, + { "td.connect.ip", "127.0.0.1" }, + { "td.connect.user", "root" }, + { "td.connect.pass", "taosdata" }, + { "td.connect.port", "6030" }, + { "client.id", "tmq_example" }, + { "enable.auto.commit", "true" }, + { "msg.with.table.name", "false" }, + }; + var consumer = new ConsumerBuilder>(cfg).Build(); + ``` + + + + + +上述配置中包括 consumer group ID，如果多个 consumer 指定的 consumer group ID 一样，则自动形成一个 consumer group，共享消费进度。 + +## 订阅 *topics* - - +一个 consumer 支持同时订阅多个 topic。 + + -```c + + + ```c // 创建订阅 topics 列表 tmq_list_t* topicList = tmq_list_new(); tmq_list_append(topicList, "topicName"); // 启动订阅 tmq_subscribe(tmq, topicList); tmq_list_destroy(topicList); - + ``` - - - - + + + + ```java List topics = new ArrayList<>(); topics.add("tmq_topic"); consumer.subscribe(topics); ``` - - - + + + ```go err = consumer.Subscribe("example_tmq_topic", nil) @@ -533,26 +532,26 @@ INSERT INTO tmqdb.ctb1 VALUES(now, 1, 1, 'a1')(now+1s, 11, 11, 'a11'); } ``` - - + + -```rust + ```rust consumer.subscribe(["tmq_meters"]).await?; ``` - + - + -```python + ```python consumer.subscribe(['topic1', 'topic2']) ``` - + - + -```js + ```js // 创建订阅 topics 列表 let topics = ['topic_test'] @@ -560,11 +559,11 @@ INSERT INTO tmqdb.ctb1 VALUES(now, 1, 1, 'a1')(now+1s, 11, 11, 'a11'); consumer.subscribe(topics); ``` - + - + -```csharp + ```csharp // 创建订阅 topics 列表 List topics = new List(); topics.add("tmq_topic"); @@ -572,18 +571,19 @@ INSERT INTO tmqdb.ctb1 VALUES(now, 1, 1, 'a1')(now+1s, 11, 11, 'a11'); consumer.Subscribe(topics); ``` - + - + - ## 消费 +## 消费 - 以下代码展示了不同语言下如何对 TMQ 消息进行消费。 +以下代码展示了不同语言下如何对 TMQ 消息进行消费。 - - + -```c + + + ```c // 消费数据 while (running) { TAOS_RES* msg = tmq_consumer_poll(tmq, timeOut); @@ -591,11 +591,11 @@ INSERT INTO tmqdb.ctb1 VALUES(now, 1, 1, 'a1')(now+1s, 11, 11, 'a11'); } ``` -这里是一个 **while** 循环，每调用一次 tmq_consumer_poll()，获取一个消息，该消息与普通查询返回的结果集完全相同，可以使用相同的解析 API 完成消息内容的解析。 - - - + 这里是一个 **while** 循环，每调用一次 tmq_consumer_poll()，获取一个消息，该消息与普通查询返回的结果集完全相同，可以使用相同的解析 API 完成消息内容的解析。 + + + ```java while(running){ ConsumerRecords meters = consumer.poll(Duration.ofMillis(100)); @@ -604,10 +604,10 @@ INSERT INTO tmqdb.ctb1 VALUES(now, 1, 1, 'a1')(now+1s, 11, 11, 'a11'); } } ``` + + - - - + ```go for { @@ -625,9 +625,9 @@ INSERT INTO tmqdb.ctb1 VALUES(now, 1, 1, 'a1')(now+1s, 11, 11, 'a11'); } ``` - + - + ```rust { @@ -660,8 +660,8 @@ INSERT INTO tmqdb.ctb1 VALUES(now, 1, 1, 'a1')(now+1s, 11, 11, 'a11'); } ``` - - + + ```python while True: @@ -677,9 +677,9 @@ INSERT INTO tmqdb.ctb1 VALUES(now, 1, 1, 'a1')(now+1s, 11, 11, 'a11'); print(block.fetchall()) ``` - + - + ```js while(true){ @@ -691,11 +691,11 @@ INSERT INTO tmqdb.ctb1 VALUES(now, 1, 1, 'a1')(now+1s, 11, 11, 'a11'); } ``` - + - + -```csharp + ```csharp // 消费数据 while (true) { @@ -708,18 +708,19 @@ INSERT INTO tmqdb.ctb1 VALUES(now, 1, 1, 'a1')(now+1s, 11, 11, 'a11'); } ``` - + - + - ## 结束消费 +## 结束消费 - 消费结束后，应当取消订阅。 +消费结束后，应当取消订阅。 - - + + + -```c + ```c /* 取消订阅 */ tmq_unsubscribe(tmq); @@ -727,10 +728,10 @@ INSERT INTO tmqdb.ctb1 VALUES(now, 1, 1, 'a1')(now+1s, 11, 11, 'a11'); tmq_consumer_close(tmq); ``` - - + + -```java + ```java /* 取消订阅 */ consumer.unsubscribe(); @@ -738,11 +739,11 @@ INSERT INTO tmqdb.ctb1 VALUES(now, 1, 1, 'a1')(now+1s, 11, 11, 'a11'); consumer.close(); ``` - + + + - - -```go + ```go /* Unsubscribe */ _ = consumer.Unsubscribe() @@ -750,38 +751,38 @@ INSERT INTO tmqdb.ctb1 VALUES(now, 1, 1, 'a1')(now+1s, 11, 11, 'a11'); _ = consumer.Close() ``` - + + + - - -```rust + ```rust consumer.unsubscribe().await; ``` - + - + -```py + ```py # 取消订阅 consumer.unsubscribe() # 关闭消费 consumer.close() ``` - - + + -```js + ```js consumer.unsubscribe(); consumer.close(); ``` - + - + -```csharp + ```csharp // 取消订阅 consumer.Unsubscribe(); @@ -789,7 +790,7 @@ INSERT INTO tmqdb.ctb1 VALUES(now, 1, 1, 'a1')(now+1s, 11, 11, 'a11'); consumer.Close(); ``` - + @@ -799,41 +800,41 @@ INSERT INTO tmqdb.ctb1 VALUES(now, 1, 1, 'a1')(now+1s, 11, 11, 'a11'); - - - + + + - - - - - - - - - - + + + + + + + + + + - - - + + + - - - + + + - - - + + + - - - - - - - + + + + + + + #订阅高级功能 diff --git a/include/common/tmsg.h b/include/common/tmsg.h index 5793825e39..1b438ba026 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -1403,7 +1403,7 @@ void tFreeSCompactDbReq(SCompactDbReq* pReq); typedef struct { int32_t compactId; - int8_t bAccepted; + int8_t bAccepted; } SCompactDbRsp; int32_t tSerializeSCompactDbRsp(void* buf, int32_t bufLen, SCompactDbRsp* pRsp); @@ -1417,7 +1417,7 @@ typedef struct { int32_t tSerializeSKillCompactReq(void* buf, int32_t bufLen, SKillCompactReq* pReq); int32_t tDeserializeSKillCompactReq(void* buf, int32_t bufLen, SKillCompactReq* pReq); -void tFreeSKillCompactReq(SKillCompactReq *pReq); +void tFreeSKillCompactReq(SKillCompactReq* pReq); typedef struct { char name[TSDB_FUNC_NAME_LEN]; @@ -1754,9 +1754,9 @@ int32_t tSerializeSCompactVnodeReq(void* buf, int32_t bufLen, SCompactVnodeReq* int32_t tDeserializeSCompactVnodeReq(void* buf, int32_t bufLen, SCompactVnodeReq* pReq); typedef struct { - int32_t compactId; - int32_t vgId; - int32_t dnodeId; + int32_t compactId; + int32_t vgId; + int32_t dnodeId; } SVKillCompactReq; int32_t tSerializeSVKillCompactReq(void* buf, int32_t bufLen, SVKillCompactReq* pReq); @@ -1957,9 +1957,9 @@ typedef struct { char db[TSDB_DB_FNAME_LEN]; char tb[TSDB_TABLE_NAME_LEN]; char user[TSDB_USER_LEN]; - char filterTb[TSDB_TABLE_NAME_LEN]; // for ins_columns + char filterTb[TSDB_TABLE_NAME_LEN]; // for ins_columns int64_t showId; - int64_t compactId; // for compact + int64_t compactId; // for compact } SRetrieveTableReq; typedef struct SSysTableSchema { @@ -3780,12 +3780,12 @@ typedef struct { } SMqHbReq; typedef struct { - char topic[TSDB_TOPIC_FNAME_LEN]; - int8_t noPrivilege; + char topic[TSDB_TOPIC_FNAME_LEN]; + int8_t noPrivilege; } STopicPrivilege; typedef struct { - SArray* topicPrivileges; // SArray + SArray* topicPrivileges; // SArray } SMqHbRsp; typedef struct { @@ -3923,8 +3923,8 @@ int32_t tDeserializeSMqSeekReq(void* buf, int32_t bufLen, SMqSeekReq* pReq); #define SUBMIT_REQ_COLUMN_DATA_FORMAT 0x2 #define SUBMIT_REQ_FROM_FILE 0x4 -#define SOURCE_NULL 0 -#define SOURCE_TAOSX 1 +#define SOURCE_NULL 0 +#define SOURCE_TAOSX 1 typedef struct { int32_t flags; @@ -3936,8 +3936,8 @@ typedef struct { SArray* aRowP; SArray* aCol; }; - int64_t ctimeMs; - int8_t source; + int64_t ctimeMs; + int8_t source; } SSubmitTbData; typedef struct { diff --git a/include/libs/stream/tstream.h b/include/libs/stream/tstream.h index 19b1924397..13a3b68155 100644 --- a/include/libs/stream/tstream.h +++ b/include/libs/stream/tstream.h @@ -50,21 +50,21 @@ extern "C" { (_t)->hTaskInfo.id.streamId = 0; \ } while (0) -#define STREAM_EXEC_T_EXTRACT_WAL_DATA (-1) -#define STREAM_EXEC_T_START_ALL_TASKS (-2) -#define STREAM_EXEC_T_START_ONE_TASK (-3) -#define STREAM_EXEC_T_RESTART_ALL_TASKS (-4) -#define STREAM_EXEC_T_STOP_ALL_TASKS (-5) -#define STREAM_EXEC_T_RESUME_TASK (-6) -#define STREAM_EXEC_T_UPDATE_TASK_EPSET (-7) +#define STREAM_EXEC_T_EXTRACT_WAL_DATA (-1) +#define STREAM_EXEC_T_START_ALL_TASKS (-2) +#define STREAM_EXEC_T_START_ONE_TASK (-3) +#define STREAM_EXEC_T_RESTART_ALL_TASKS (-4) +#define STREAM_EXEC_T_STOP_ALL_TASKS (-5) +#define STREAM_EXEC_T_RESUME_TASK (-6) +#define STREAM_EXEC_T_UPDATE_TASK_EPSET (-7) typedef struct SStreamTask SStreamTask; typedef struct SStreamQueue SStreamQueue; typedef struct SStreamTaskSM SStreamTaskSM; -#define SSTREAM_TASK_VER 3 -#define SSTREAM_TASK_INCOMPATIBLE_VER 1 -#define SSTREAM_TASK_NEED_CONVERT_VER 2 +#define SSTREAM_TASK_VER 3 +#define SSTREAM_TASK_INCOMPATIBLE_VER 1 +#define SSTREAM_TASK_NEED_CONVERT_VER 2 #define SSTREAM_TASK_SUBTABLE_CHANGED_VER 3 enum { @@ -405,8 +405,8 @@ typedef struct SHistoryTaskInfo { int32_t tickCount; int32_t retryTimes; int32_t waitInterval; - int64_t haltVer; // offset in wal when halt the stream task - bool operatorOpen; // false by default + int64_t haltVer; // offset in wal when halt the stream task + bool operatorOpen; // false by default } SHistoryTaskInfo; typedef struct STaskOutputInfo { @@ -463,21 +463,22 @@ struct SStreamTask { struct SStreamMeta* pMeta; SSHashObj* pNameMap; void* pBackend; - char reserve[256]; + int8_t subtableWithoutMd5; + char reserve[255]; }; typedef int32_t (*startComplete_fn_t)(struct SStreamMeta*); typedef struct STaskStartInfo { - int64_t startTs; - int64_t readyTs; - int32_t tasksWillRestart; - int32_t taskStarting; // restart flag, sentinel to guard the restart procedure. - SHashObj* pReadyTaskSet; // tasks that are all ready for running stream processing - SHashObj* pFailedTaskSet; // tasks that are done the check downstream process, may be successful or failed - int64_t elapsedTime; - int32_t restartCount; // restart task counter - startComplete_fn_t completeFn; // complete callback function + int64_t startTs; + int64_t readyTs; + int32_t tasksWillRestart; + int32_t taskStarting; // restart flag, sentinel to guard the restart procedure. + SHashObj* pReadyTaskSet; // tasks that are all ready for running stream processing + SHashObj* pFailedTaskSet; // tasks that are done the check downstream process, may be successful or failed + int64_t elapsedTime; + int32_t restartCount; // restart task counter + startComplete_fn_t completeFn; // complete callback function } STaskStartInfo; typedef struct STaskUpdateInfo { @@ -504,7 +505,7 @@ typedef struct SStreamMeta { int32_t vgId; int64_t stage; int32_t role; - bool sendMsgBeforeClosing; // send hb to mnode before close all tasks when switch to follower. + bool sendMsgBeforeClosing; // send hb to mnode before close all tasks when switch to follower. STaskStartInfo startInfo; TdThreadRwlock lock; SScanWalInfo scanInfo; @@ -532,7 +533,7 @@ int32_t tEncodeStreamEpInfo(SEncoder* pEncoder, const SStreamChildEpInfo* pInfo) int32_t tDecodeStreamEpInfo(SDecoder* pDecoder, SStreamChildEpInfo* pInfo); SStreamTask* tNewStreamTask(int64_t streamId, int8_t taskLevel, SEpSet* pEpset, bool fillHistory, int64_t triggerParam, - SArray* pTaskList, bool hasFillhistory); + SArray* pTaskList, bool hasFillhistory, int8_t subtableWithoutMd5); int32_t tEncodeStreamTask(SEncoder* pEncoder, const SStreamTask* pTask); int32_t tDecodeStreamTask(SDecoder* pDecoder, SStreamTask* pTask); void tFreeStreamTask(SStreamTask* pTask); @@ -678,18 +679,18 @@ typedef struct STaskStatusEntry { int32_t statusLastDuration; // to record the last duration of current status int64_t stage; int32_t nodeId; - int64_t verStart; // start version in WAL, only valid for source task - int64_t verEnd; // end version in WAL, only valid for source task - int64_t processedVer; // only valid for source task - int64_t checkpointId; // current active checkpoint id - int32_t chkpointTransId; // checkpoint trans id - int8_t checkpointFailed; // denote if the checkpoint is failed or not - bool inputQChanging; // inputQ is changing or not + int64_t verStart; // start version in WAL, only valid for source task + int64_t verEnd; // end version in WAL, only valid for source task + int64_t processedVer; // only valid for source task + int64_t checkpointId; // current active checkpoint id + int32_t chkpointTransId; // checkpoint trans id + int8_t checkpointFailed; // denote if the checkpoint is failed or not + bool inputQChanging; // inputQ is changing or not int64_t inputQUnchangeCounter; - double inputQUsed; // in MiB + double inputQUsed; // in MiB double inputRate; - double sinkQuota; // existed quota size for sink task - double sinkDataSize; // sink to dst data size + double sinkQuota; // existed quota size for sink task + double sinkDataSize; // sink to dst data size } STaskStatusEntry; typedef struct SStreamHbMsg { @@ -720,8 +721,8 @@ int32_t tEncodeStreamTaskUpdateMsg(SEncoder* pEncoder, const SStreamTaskNodeUpda int32_t tDecodeStreamTaskUpdateMsg(SDecoder* pDecoder, SStreamTaskNodeUpdateMsg* pMsg); typedef struct SStreamTaskState { - ETaskStatus state; - char* name; + ETaskStatus state; + char* name; } SStreamTaskState; typedef struct { @@ -839,7 +840,8 @@ SScanhistoryDataInfo streamScanHistoryData(SStreamTask* pTask, int64_t st); // stream task meta void streamMetaInit(); void streamMetaCleanup(); -SStreamMeta* streamMetaOpen(const char* path, void* ahandle, FTaskExpand expandFunc, int32_t vgId, int64_t stage, startComplete_fn_t fn); +SStreamMeta* streamMetaOpen(const char* path, void* ahandle, FTaskExpand expandFunc, int32_t vgId, int64_t stage, + startComplete_fn_t fn); void streamMetaClose(SStreamMeta* streamMeta); int32_t streamMetaSaveTask(SStreamMeta* pMeta, SStreamTask* pTask); // save to stream meta store int32_t streamMetaRemoveTask(SStreamMeta* pMeta, STaskId* pKey); @@ -858,22 +860,22 @@ void streamMetaNotifyClose(SStreamMeta* pMeta); void streamMetaStartHb(SStreamMeta* pMeta); bool streamMetaTaskInTimer(SStreamMeta* pMeta); int32_t streamMetaAddTaskLaunchResult(SStreamMeta* pMeta, int64_t streamId, int32_t taskId, int64_t startTs, - int64_t endTs, bool ready); + int64_t endTs, bool ready); int32_t streamMetaResetTaskStatus(SStreamMeta* pMeta); -void streamMetaRLock(SStreamMeta* pMeta); -void streamMetaRUnLock(SStreamMeta* pMeta); -void streamMetaWLock(SStreamMeta* pMeta); -void streamMetaWUnLock(SStreamMeta* pMeta); -void streamMetaResetStartInfo(STaskStartInfo* pMeta); -SArray* streamMetaSendMsgBeforeCloseTasks(SStreamMeta* pMeta); -void streamMetaUpdateStageRole(SStreamMeta* pMeta, int64_t stage, bool isLeader); -int32_t streamMetaLoadAllTasks(SStreamMeta* pMeta); -int32_t streamMetaStartAllTasks(SStreamMeta* pMeta); -int32_t streamMetaStopAllTasks(SStreamMeta* pMeta); -int32_t streamMetaStartOneTask(SStreamMeta* pMeta, int64_t streamId, int32_t taskId); -bool streamMetaAllTasksReady(const SStreamMeta* pMeta); -tmr_h streamTimerGetInstance(); +void streamMetaRLock(SStreamMeta* pMeta); +void streamMetaRUnLock(SStreamMeta* pMeta); +void streamMetaWLock(SStreamMeta* pMeta); +void streamMetaWUnLock(SStreamMeta* pMeta); +void streamMetaResetStartInfo(STaskStartInfo* pMeta); +SArray* streamMetaSendMsgBeforeCloseTasks(SStreamMeta* pMeta); +void streamMetaUpdateStageRole(SStreamMeta* pMeta, int64_t stage, bool isLeader); +int32_t streamMetaLoadAllTasks(SStreamMeta* pMeta); +int32_t streamMetaStartAllTasks(SStreamMeta* pMeta); +int32_t streamMetaStopAllTasks(SStreamMeta* pMeta); +int32_t streamMetaStartOneTask(SStreamMeta* pMeta, int64_t streamId, int32_t taskId); +bool streamMetaAllTasksReady(const SStreamMeta* pMeta); +tmr_h streamTimerGetInstance(); // checkpoint int32_t streamProcessCheckpointSourceReq(SStreamTask* pTask, SStreamCheckpointSourceReq* pReq); @@ -890,8 +892,8 @@ int32_t buildCheckpointSourceRsp(SStreamCheckpointSourceReq* pReq, SRpcHandleInf SStreamTaskSM* streamCreateStateMachine(SStreamTask* pTask); void* streamDestroyStateMachine(SStreamTaskSM* pSM); -int32_t broadcastRetrieveMsg(SStreamTask* pTask, SStreamRetrieveReq *req); -void sendRetrieveRsp(SStreamRetrieveReq *pReq, SRpcMsg* pRsp); +int32_t broadcastRetrieveMsg(SStreamTask* pTask, SStreamRetrieveReq* req); +void sendRetrieveRsp(SStreamRetrieveReq* pReq, SRpcMsg* pRsp); #ifdef __cplusplus } #endif diff --git a/source/dnode/mnode/impl/inc/mndDef.h b/source/dnode/mnode/impl/inc/mndDef.h index 19de4561d6..fc58fabad5 100644 --- a/source/dnode/mnode/impl/inc/mndDef.h +++ b/source/dnode/mnode/impl/inc/mndDef.h @@ -699,6 +699,7 @@ typedef struct { int64_t checkpointId; int32_t indexForMultiAggBalance; + int8_t subTableWithoutMd5; char reserve[256]; } SStreamObj; @@ -776,8 +777,8 @@ typedef enum { GRANT_STATE_REASON_MAX, } EGrantStateReason; -#define GRANT_STATE_NUM 30 -#define GRANT_ACTIVE_NUM 10 +#define GRANT_STATE_NUM 30 +#define GRANT_ACTIVE_NUM 10 #define GRANT_ACTIVE_HEAD_LEN 30 typedef struct { @@ -812,7 +813,7 @@ typedef struct { int64_t id : 24; }; }; - char machine[TSDB_MACHINE_ID_LEN + 1]; + char machine[TSDB_MACHINE_ID_LEN + 1]; } SGrantMachine; typedef struct { diff --git a/source/dnode/mnode/impl/inc/mndStream.h b/source/dnode/mnode/impl/inc/mndStream.h index 4d1125a340..1084340dc2 100644 --- a/source/dnode/mnode/impl/inc/mndStream.h +++ b/source/dnode/mnode/impl/inc/mndStream.h @@ -24,7 +24,7 @@ extern "C" { #endif #define MND_STREAM_RESERVE_SIZE 64 -#define MND_STREAM_VER_NUMBER 4 +#define MND_STREAM_VER_NUMBER 5 #define MND_STREAM_CREATE_NAME "stream-create" #define MND_STREAM_CHECKPOINT_NAME "stream-checkpoint" diff --git a/source/dnode/mnode/impl/src/mndDef.c b/source/dnode/mnode/impl/src/mndDef.c index d59354286d..5be641d1c2 100644 --- a/source/dnode/mnode/impl/src/mndDef.c +++ b/source/dnode/mnode/impl/src/mndDef.c @@ -85,6 +85,7 @@ int32_t tEncodeSStreamObj(SEncoder *pEncoder, const SStreamObj *pObj) { // 3.0.50 ver = 3 if (tEncodeI64(pEncoder, pObj->checkpointId) < 0) return -1; + if (tEncodeI8(pEncoder, pObj->subTableWithoutMd5) < 0) return -1; if (tEncodeCStrWithLen(pEncoder, pObj->reserve, sizeof(pObj->reserve) - 1) < 0) return -1; @@ -168,6 +169,10 @@ int32_t tDecodeSStreamObj(SDecoder *pDecoder, SStreamObj *pObj, int32_t sver) { if (sver >= 3) { if (tDecodeI64(pDecoder, &pObj->checkpointId) < 0) return -1; } + + if (sver >= 5) { + if (tDecodeI8(pDecoder, &pObj->subTableWithoutMd5) < 0) return -1; + } if (tDecodeCStrTo(pDecoder, pObj->reserve) < 0) return -1; tEndDecode(pDecoder); diff --git a/source/dnode/mnode/impl/src/mndScheduler.c b/source/dnode/mnode/impl/src/mndScheduler.c index 9d134d97bb..cbc0ace75d 100644 --- a/source/dnode/mnode/impl/src/mndScheduler.c +++ b/source/dnode/mnode/impl/src/mndScheduler.c @@ -14,13 +14,13 @@ */ #include "mndScheduler.h" -#include "tmisce.h" -#include "mndMnode.h" #include "mndDb.h" +#include "mndMnode.h" #include "mndSnode.h" #include "mndVgroup.h" #include "parser.h" #include "tcompare.h" +#include "tmisce.h" #include "tname.h" #include "tuuid.h" @@ -211,7 +211,7 @@ SVgObj* mndSchedFetchOneVg(SMnode* pMnode, SStreamObj* pStream) { return NULL; } - if(pStream->indexForMultiAggBalance == -1){ + if (pStream->indexForMultiAggBalance == -1) { taosSeedRand(taosSafeRand()); pStream->indexForMultiAggBalance = taosRand() % pDbObj->cfg.numOfVgroups; } @@ -226,7 +226,7 @@ SVgObj* mndSchedFetchOneVg(SMnode* pMnode, SStreamObj* pStream) { sdbRelease(pMnode->pSdb, pVgroup); continue; } - if (index++ == pStream->indexForMultiAggBalance){ + if (index++ == pStream->indexForMultiAggBalance) { pStream->indexForMultiAggBalance++; pStream->indexForMultiAggBalance %= pDbObj->cfg.numOfVgroups; sdbCancelFetch(pMnode->pSdb, pIter); @@ -239,12 +239,12 @@ SVgObj* mndSchedFetchOneVg(SMnode* pMnode, SStreamObj* pStream) { return pVgroup; } -static int32_t doAddSinkTask(SStreamObj* pStream, SMnode* pMnode, SVgObj* pVgroup, - SEpSet* pEpset, bool isFillhistory) { - int64_t uid = (isFillhistory) ? pStream->hTaskUid : pStream->uid; +static int32_t doAddSinkTask(SStreamObj* pStream, SMnode* pMnode, SVgObj* pVgroup, SEpSet* pEpset, bool isFillhistory) { + int64_t uid = (isFillhistory) ? pStream->hTaskUid : pStream->uid; SArray** pTaskList = (isFillhistory) ? taosArrayGetLast(pStream->pHTasksList) : taosArrayGetLast(pStream->tasks); - SStreamTask* pTask = tNewStreamTask(uid, TASK_LEVEL__SINK, pEpset, isFillhistory, 0, *pTaskList, pStream->conf.fillHistory); + SStreamTask* pTask = tNewStreamTask(uid, TASK_LEVEL__SINK, pEpset, isFillhistory, 0, *pTaskList, + pStream->conf.fillHistory, pStream->subTableWithoutMd5); if (pTask == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; return terrno; @@ -257,12 +257,12 @@ static int32_t doAddSinkTask(SStreamObj* pStream, SMnode* pMnode, SVgObj* pVgrou return mndSetSinkTaskInfo(pStream, pTask); } -static int32_t doAddSinkTaskToVg(SMnode* pMnode, SStreamObj* pStream, SEpSet* pEpset, SVgObj* vgObj){ +static int32_t doAddSinkTaskToVg(SMnode* pMnode, SStreamObj* pStream, SEpSet* pEpset, SVgObj* vgObj) { int32_t code = doAddSinkTask(pStream, pMnode, vgObj, pEpset, false); if (code != 0) { return code; } - if(pStream->conf.fillHistory){ + if (pStream->conf.fillHistory) { code = doAddSinkTask(pStream, pMnode, vgObj, pEpset, true); if (code != 0) { return code; @@ -289,7 +289,7 @@ static int32_t doAddShuffleSinkTask(SMnode* pMnode, SStreamObj* pStream, SEpSet* } int32_t code = doAddSinkTaskToVg(pMnode, pStream, pEpset, pVgroup); - if(code != 0){ + if (code != 0) { sdbRelease(pSdb, pVgroup); return code; } @@ -301,7 +301,7 @@ static int32_t doAddShuffleSinkTask(SMnode* pMnode, SStreamObj* pStream, SEpSet* } static int64_t getVgroupLastVer(const SArray* pList, int32_t vgId) { - for(int32_t i = 0; i < taosArrayGetSize(pList); ++i) { + for (int32_t i = 0; i < taosArrayGetSize(pList); ++i) { SVgroupVer* pVer = taosArrayGet(pList, i); if (pVer->vgId == vgId) { return pVer->ver; @@ -337,8 +337,8 @@ static void streamTaskSetDataRange(SStreamTask* pTask, int64_t skey, SArray* pVe pRange->range.minVer = latestVer + 1; pRange->range.maxVer = INT64_MAX; - mDebug("add source task 0x%x timeWindow:%" PRId64 "-%" PRId64 " verRange:%" PRId64 "-%" PRId64, - pTask->id.taskId, pWindow->skey, pWindow->ekey, pRange->range.minVer, pRange->range.maxVer); + mDebug("add source task 0x%x timeWindow:%" PRId64 "-%" PRId64 " verRange:%" PRId64 "-%" PRId64, pTask->id.taskId, + pWindow->skey, pWindow->ekey, pRange->range.minVer, pRange->range.maxVer); } } @@ -353,14 +353,13 @@ static void haltInitialTaskStatus(SStreamTask* pTask, SSubplan* pPlan) { } } -static SStreamTask* buildSourceTask(SStreamObj* pStream, SEpSet* pEpset, - bool isFillhistory, bool useTriggerParam) { +static SStreamTask* buildSourceTask(SStreamObj* pStream, SEpSet* pEpset, bool isFillhistory, bool useTriggerParam) { uint64_t uid = (isFillhistory) ? pStream->hTaskUid : pStream->uid; SArray** pTaskList = (isFillhistory) ? taosArrayGetLast(pStream->pHTasksList) : taosArrayGetLast(pStream->tasks); - SStreamTask* pTask = tNewStreamTask(uid, TASK_LEVEL__SOURCE, pEpset, - isFillhistory, useTriggerParam ? pStream->conf.triggerParam : 0, - *pTaskList, pStream->conf.fillHistory); + SStreamTask* pTask = + tNewStreamTask(uid, TASK_LEVEL__SOURCE, pEpset, isFillhistory, useTriggerParam ? pStream->conf.triggerParam : 0, + *pTaskList, pStream->conf.fillHistory, pStream->subTableWithoutMd5); if (pTask == NULL) { return NULL; } @@ -368,7 +367,7 @@ static SStreamTask* buildSourceTask(SStreamObj* pStream, SEpSet* pEpset, return pTask; } -static void addNewTaskList(SStreamObj* pStream){ +static void addNewTaskList(SStreamObj* pStream) { SArray* pTaskList = taosArrayInit(0, POINTER_BYTES); taosArrayPush(pStream->tasks, &pTaskList); if (pStream->conf.fillHistory) { @@ -397,11 +396,11 @@ static void setHTasksId(SStreamObj* pStream) { } } -static int32_t doAddSourceTask(SMnode* pMnode, SSubplan* plan, SStreamObj* pStream, SEpSet* pEpset, - int64_t skey, SArray* pVerList, SVgObj* pVgroup, bool isFillhistory, bool useTriggerParam ){ +static int32_t doAddSourceTask(SMnode* pMnode, SSubplan* plan, SStreamObj* pStream, SEpSet* pEpset, int64_t skey, + SArray* pVerList, SVgObj* pVgroup, bool isFillhistory, bool useTriggerParam) { // new stream task SStreamTask* pTask = buildSourceTask(pStream, pEpset, isFillhistory, useTriggerParam); - if(pTask == NULL){ + if (pTask == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; return terrno; } @@ -412,15 +411,15 @@ static int32_t doAddSourceTask(SMnode* pMnode, SSubplan* plan, SStreamObj* pStre streamTaskSetDataRange(pTask, skey, pVerList, pVgroup->vgId); int32_t code = mndAssignStreamTaskToVgroup(pMnode, pTask, plan, pVgroup); - if(code != 0){ + if (code != 0) { terrno = code; return terrno; } return TDB_CODE_SUCCESS; } -static SSubplan* getScanSubPlan(const SQueryPlan* pPlan){ - int32_t numOfPlanLevel = LIST_LENGTH(pPlan->pSubplans); +static SSubplan* getScanSubPlan(const SQueryPlan* pPlan) { + int32_t numOfPlanLevel = LIST_LENGTH(pPlan->pSubplans); SNodeListNode* inner = (SNodeListNode*)nodesListGetNode(pPlan->pSubplans, numOfPlanLevel - 1); if (LIST_LENGTH(inner->pNodeList) != 1) { terrno = TSDB_CODE_QRY_INVALID_INPUT; @@ -435,7 +434,7 @@ static SSubplan* getScanSubPlan(const SQueryPlan* pPlan){ return plan; } -static SSubplan* getAggSubPlan(const SQueryPlan* pPlan, int index){ +static SSubplan* getAggSubPlan(const SQueryPlan* pPlan, int index) { SNodeListNode* inner = (SNodeListNode*)nodesListGetNode(pPlan->pSubplans, index); if (LIST_LENGTH(inner->pNodeList) != 1) { terrno = TSDB_CODE_QRY_INVALID_INPUT; @@ -450,8 +449,8 @@ static SSubplan* getAggSubPlan(const SQueryPlan* pPlan, int index){ return plan; } -static int32_t addSourceTask(SMnode* pMnode, SSubplan* plan, SStreamObj* pStream, - SEpSet* pEpset, int64_t nextWindowSkey, SArray* pVerList, bool useTriggerParam) { +static int32_t addSourceTask(SMnode* pMnode, SSubplan* plan, SStreamObj* pStream, SEpSet* pEpset, + int64_t nextWindowSkey, SArray* pVerList, bool useTriggerParam) { addNewTaskList(pStream); void* pIter = NULL; @@ -468,15 +467,16 @@ static int32_t addSourceTask(SMnode* pMnode, SSubplan* plan, SStreamObj* pStream continue; } - int code = doAddSourceTask(pMnode, plan, pStream, pEpset, nextWindowSkey, pVerList, pVgroup, false, useTriggerParam); - if(code != 0){ + int code = + doAddSourceTask(pMnode, plan, pStream, pEpset, nextWindowSkey, pVerList, pVgroup, false, useTriggerParam); + if (code != 0) { sdbRelease(pSdb, pVgroup); return code; } if (pStream->conf.fillHistory) { code = doAddSourceTask(pMnode, plan, pStream, pEpset, nextWindowSkey, pVerList, pVgroup, true, useTriggerParam); - if(code != 0){ + if (code != 0) { sdbRelease(pSdb, pVgroup); return code; } @@ -496,9 +496,9 @@ static SStreamTask* buildAggTask(SStreamObj* pStream, SEpSet* pEpset, bool isFil uint64_t uid = (isFillhistory) ? pStream->hTaskUid : pStream->uid; SArray** pTaskList = (isFillhistory) ? taosArrayGetLast(pStream->pHTasksList) : taosArrayGetLast(pStream->tasks); - SStreamTask* pAggTask = tNewStreamTask(uid, TASK_LEVEL__AGG, pEpset, isFillhistory, - useTriggerParam ? pStream->conf.triggerParam : 0, - *pTaskList, pStream->conf.fillHistory); + SStreamTask* pAggTask = + tNewStreamTask(uid, TASK_LEVEL__AGG, pEpset, isFillhistory, useTriggerParam ? pStream->conf.triggerParam : 0, + *pTaskList, pStream->conf.fillHistory, pStream->subTableWithoutMd5); if (pAggTask == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; return NULL; @@ -507,8 +507,8 @@ static SStreamTask* buildAggTask(SStreamObj* pStream, SEpSet* pEpset, bool isFil return pAggTask; } -static int32_t doAddAggTask(SStreamObj* pStream, SMnode* pMnode, SSubplan* plan, SEpSet* pEpset, - SVgObj* pVgroup, SSnodeObj* pSnode, bool isFillhistory, bool useTriggerParam){ +static int32_t doAddAggTask(SStreamObj* pStream, SMnode* pMnode, SSubplan* plan, SEpSet* pEpset, SVgObj* pVgroup, + SSnodeObj* pSnode, bool isFillhistory, bool useTriggerParam) { int32_t code = 0; SStreamTask* pTask = buildAggTask(pStream, pEpset, isFillhistory, useTriggerParam); if (pTask == NULL) { @@ -525,7 +525,7 @@ static int32_t doAddAggTask(SStreamObj* pStream, SMnode* pMnode, SSubplan* plan, return code; } -static int32_t addAggTask(SStreamObj* pStream, SMnode* pMnode, SSubplan* plan, SEpSet* pEpset, bool useTriggerParam){ +static int32_t addAggTask(SStreamObj* pStream, SMnode* pMnode, SSubplan* plan, SEpSet* pEpset, bool useTriggerParam) { SVgObj* pVgroup = NULL; SSnodeObj* pSnode = NULL; int32_t code = 0; @@ -539,20 +539,20 @@ static int32_t addAggTask(SStreamObj* pStream, SMnode* pMnode, SSubplan* plan, S } code = doAddAggTask(pStream, pMnode, plan, pEpset, pVgroup, pSnode, false, useTriggerParam); - if(code != 0){ + if (code != 0) { goto END; } if (pStream->conf.fillHistory) { code = doAddAggTask(pStream, pMnode, plan, pEpset, pVgroup, pSnode, true, useTriggerParam); - if(code != 0){ + if (code != 0) { goto END; } setHTasksId(pStream); } - END: +END: if (pSnode != NULL) { sdbRelease(pMnode->pSdb, pSnode); } else { @@ -561,7 +561,7 @@ static int32_t addAggTask(SStreamObj* pStream, SMnode* pMnode, SSubplan* plan, S return code; } -static int32_t addSinkTask(SMnode* pMnode, SStreamObj* pStream, SEpSet* pEpset){ +static int32_t addSinkTask(SMnode* pMnode, SStreamObj* pStream, SEpSet* pEpset) { int32_t code = 0; addNewTaskList(pStream); @@ -583,9 +583,9 @@ static int32_t addSinkTask(SMnode* pMnode, SStreamObj* pStream, SEpSet* pEpset){ return TDB_CODE_SUCCESS; } -static void bindTaskToSinkTask(SStreamObj* pStream, SMnode* pMnode, SArray* pSinkTaskList, SStreamTask* task){ +static void bindTaskToSinkTask(SStreamObj* pStream, SMnode* pMnode, SArray* pSinkTaskList, SStreamTask* task) { mndAddDispatcherForInternalTask(pMnode, pStream, pSinkTaskList, task); - for(int32_t k = 0; k < taosArrayGetSize(pSinkTaskList); k++) { + for (int32_t k = 0; k < taosArrayGetSize(pSinkTaskList); k++) { SStreamTask* pSinkTask = taosArrayGetP(pSinkTaskList, k); streamTaskSetUpstreamInfo(pSinkTask, task); } @@ -593,10 +593,10 @@ static void bindTaskToSinkTask(SStreamObj* pStream, SMnode* pMnode, SArray* pSin } static void bindAggSink(SStreamObj* pStream, SMnode* pMnode, SArray* tasks) { - SArray* pSinkTaskList = taosArrayGetP(tasks, SINK_NODE_LEVEL); + SArray* pSinkTaskList = taosArrayGetP(tasks, SINK_NODE_LEVEL); SArray** pAggTaskList = taosArrayGetLast(tasks); - for(int i = 0; i < taosArrayGetSize(*pAggTaskList); i++){ + for (int i = 0; i < taosArrayGetSize(*pAggTaskList); i++) { SStreamTask* pAggTask = taosArrayGetP(*pAggTaskList, i); bindTaskToSinkTask(pStream, pMnode, pSinkTaskList, pAggTask); mDebug("bindAggSink taskId:%s to sink task list", pAggTask->id.idStr); @@ -607,7 +607,7 @@ static void bindSourceSink(SStreamObj* pStream, SMnode* pMnode, SArray* tasks, b SArray* pSinkTaskList = taosArrayGetP(tasks, SINK_NODE_LEVEL); SArray* pSourceTaskList = taosArrayGetP(tasks, hasExtraSink ? SINK_NODE_LEVEL + 1 : SINK_NODE_LEVEL); - for(int i = 0; i < taosArrayGetSize(pSourceTaskList); i++){ + for (int i = 0; i < taosArrayGetSize(pSourceTaskList); i++) { SStreamTask* pSourceTask = taosArrayGetP(pSourceTaskList, i); mDebug("bindSourceSink taskId:%s to sink task list", pSourceTask->id.idStr); @@ -626,8 +626,8 @@ static void bindTwoLevel(SArray* tasks, int32_t begin, int32_t end) { SArray* pUpTaskList = taosArrayGetP(tasks, size - 2); SStreamTask** pDownTask = taosArrayGetLast(pDownTaskList); - end = end > taosArrayGetSize(pUpTaskList) ? taosArrayGetSize(pUpTaskList): end; - for(int i = begin; i < end; i++){ + end = end > taosArrayGetSize(pUpTaskList) ? taosArrayGetSize(pUpTaskList) : end; + for (int i = begin; i < end; i++) { SStreamTask* pUpTask = taosArrayGetP(pUpTaskList, i); pUpTask->info.selfChildId = i - begin; streamTaskSetFixedDownstreamInfo(pUpTask, *pDownTask); @@ -651,8 +651,8 @@ static int32_t doScheduleStream(SStreamObj* pStream, SMnode* pMnode, SQueryPlan* bool multiTarget = (pDbObj->cfg.numOfVgroups > 1); sdbRelease(pSdb, pDbObj); - mDebug("doScheduleStream numOfPlanLevel:%d, exDb:%d, multiTarget:%d, fix vgId:%d, physicalPlan:%s", - numOfPlanLevel, externalTargetDB, multiTarget, pStream->fixedSinkVgId, pStream->physicalPlan); + mDebug("doScheduleStream numOfPlanLevel:%d, exDb:%d, multiTarget:%d, fix vgId:%d, physicalPlan:%s", numOfPlanLevel, + externalTargetDB, multiTarget, pStream->fixedSinkVgId, pStream->physicalPlan); pStream->tasks = taosArrayInit(numOfPlanLevel + 1, POINTER_BYTES); pStream->pHTasksList = taosArrayInit(numOfPlanLevel + 1, POINTER_BYTES); @@ -667,7 +667,7 @@ static int32_t doScheduleStream(SStreamObj* pStream, SMnode* pMnode, SQueryPlan* pStream->totalLevel = numOfPlanLevel + hasExtraSink; - SSubplan* plan = getScanSubPlan(pPlan); // source plan + SSubplan* plan = getScanSubPlan(pPlan); // source plan if (plan == NULL) { return terrno; } @@ -684,32 +684,32 @@ static int32_t doScheduleStream(SStreamObj* pStream, SMnode* pMnode, SQueryPlan* return TDB_CODE_SUCCESS; } - if(numOfPlanLevel == 3){ + if (numOfPlanLevel == 3) { plan = getAggSubPlan(pPlan, 1); // middle agg plan if (plan == NULL) { return terrno; } - do{ + do { SArray** list = taosArrayGetLast(pStream->tasks); - float size = (float)taosArrayGetSize(*list); - size_t cnt = (size_t)ceil(size/tsStreamAggCnt); - if(cnt <= 1) break; + float size = (float)taosArrayGetSize(*list); + size_t cnt = (size_t)ceil(size / tsStreamAggCnt); + if (cnt <= 1) break; mDebug("doScheduleStream add middle agg, size:%d, cnt:%d", (int)size, (int)cnt); addNewTaskList(pStream); - for(int j = 0; j < cnt; j++){ + for (int j = 0; j < cnt; j++) { code = addAggTask(pStream, pMnode, plan, pEpset, false); if (code != TSDB_CODE_SUCCESS) { return code; } - bindTwoLevel(pStream->tasks, j*tsStreamAggCnt, (j+1)*tsStreamAggCnt); + bindTwoLevel(pStream->tasks, j * tsStreamAggCnt, (j + 1) * tsStreamAggCnt); if (pStream->conf.fillHistory) { - bindTwoLevel(pStream->pHTasksList, j*tsStreamAggCnt, (j+1)*tsStreamAggCnt); + bindTwoLevel(pStream->pHTasksList, j * tsStreamAggCnt, (j + 1) * tsStreamAggCnt); } } - }while(1); + } while (1); } plan = getAggSubPlan(pPlan, 0); @@ -719,7 +719,7 @@ static int32_t doScheduleStream(SStreamObj* pStream, SMnode* pMnode, SQueryPlan* mDebug("doScheduleStream add final agg"); SArray** list = taosArrayGetLast(pStream->tasks); - size_t size = taosArrayGetSize(*list); + size_t size = taosArrayGetSize(*list); addNewTaskList(pStream); code = addAggTask(pStream, pMnode, plan, pEpset, true); if (code != TSDB_CODE_SUCCESS) { diff --git a/source/dnode/mnode/impl/src/mndSma.c b/source/dnode/mnode/impl/src/mndSma.c index 1e92b1a181..05189d5a53 100644 --- a/source/dnode/mnode/impl/src/mndSma.c +++ b/source/dnode/mnode/impl/src/mndSma.c @@ -567,6 +567,7 @@ static int32_t mndCreateSma(SMnode *pMnode, SRpcMsg *pReq, SMCreateSmaReq *pCrea streamObj.conf.triggerParam = pCreate->maxDelay; streamObj.ast = taosStrdup(smaObj.ast); streamObj.indexForMultiAggBalance = -1; + streamObj.subTableWithoutMd5 = 1; // check the maxDelay if (streamObj.conf.triggerParam < TSDB_MIN_ROLLUP_MAX_DELAY) { @@ -898,11 +899,11 @@ _OVER: } int32_t mndDropSmasByStb(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb) { - SSdb *pSdb = pMnode->pSdb; - SSmaObj *pSma = NULL; - void *pIter = NULL; - SVgObj *pVgroup = NULL; - int32_t code = -1; + SSdb *pSdb = pMnode->pSdb; + SSmaObj *pSma = NULL; + void *pIter = NULL; + SVgObj *pVgroup = NULL; + int32_t code = -1; while (1) { pIter = sdbFetch(pSdb, SDB_SMA, pIter, (void **)&pSma); diff --git a/source/dnode/mnode/impl/src/mndStream.c b/source/dnode/mnode/impl/src/mndStream.c index 190b4f28ce..e4767d72d7 100644 --- a/source/dnode/mnode/impl/src/mndStream.c +++ b/source/dnode/mnode/impl/src/mndStream.c @@ -27,7 +27,7 @@ #include "tmisce.h" #include "tname.h" -#define MND_STREAM_MAX_NUM 60 +#define MND_STREAM_MAX_NUM 60 typedef struct SMStreamNodeCheckMsg { int8_t placeHolder; // // to fix windows compile error, define place holder @@ -192,7 +192,7 @@ SSdbRow *mndStreamActionDecode(SSdbRaw *pRaw) { STREAM_DECODE_OVER: taosMemoryFreeClear(buf); if (terrno != TSDB_CODE_SUCCESS) { - char* p = (pStream == NULL) ? "null" : pStream->name; + char *p = (pStream == NULL) ? "null" : pStream->name; mError("stream:%s, failed to decode from raw:%p since %s", p, pRaw, terrstr()); taosMemoryFreeClear(pRow); return NULL; @@ -802,8 +802,7 @@ static int32_t mndProcessStreamCheckpointTmr(SRpcMsg *pReq) { } static int32_t mndBuildStreamCheckpointSourceReq(void **pBuf, int32_t *pLen, int32_t nodeId, int64_t checkpointId, - int64_t streamId, int32_t taskId, int32_t transId, - int8_t mndTrigger) { + int64_t streamId, int32_t taskId, int32_t transId, int8_t mndTrigger) { SStreamCheckpointSourceReq req = {0}; req.checkpointId = checkpointId; req.nodeId = nodeId; @@ -878,11 +877,10 @@ static int32_t mndProcessStreamCheckpointTrans(SMnode *pMnode, SStreamObj *pStre int32_t code = -1; int64_t ts = taosGetTimestampMs(); if (mndTrigger == 1 && (ts - pStream->checkpointFreq < tsStreamCheckpointInterval * 1000)) { -// mWarn("checkpoint interval less than the threshold, ignore it"); + // mWarn("checkpoint interval less than the threshold, ignore it"); return -1; } - bool conflict = mndStreamTransConflictCheck(pMnode, pStream->uid, MND_STREAM_CHECKPOINT_NAME, lock); if (conflict) { mndAddtoCheckpointWaitingList(pStream, checkpointId); @@ -1144,7 +1142,7 @@ static int32_t mndProcessDropStreamReq(SRpcMsg *pReq) { return -1; } - STrans* pTrans = doCreateTrans(pMnode, pStream, pReq, MND_STREAM_DROP_NAME, "drop stream"); + STrans *pTrans = doCreateTrans(pMnode, pStream, pReq, MND_STREAM_DROP_NAME, "drop stream"); if (pTrans == NULL) { mError("stream:%s, failed to drop since %s", dropReq.name, terrstr()); sdbRelease(pMnode->pSdb, pStream); @@ -1570,7 +1568,7 @@ static int32_t mndProcessPauseStreamReq(SRpcMsg *pReq) { return -1; } - STrans* pTrans = doCreateTrans(pMnode, pStream, pReq, MND_STREAM_PAUSE_NAME, "pause the stream"); + STrans *pTrans = doCreateTrans(pMnode, pStream, pReq, MND_STREAM_PAUSE_NAME, "pause the stream"); if (pTrans == NULL) { mError("stream:%s failed to pause stream since %s", pauseReq.name, terrstr()); sdbRelease(pMnode->pSdb, pStream); @@ -1590,7 +1588,7 @@ static int32_t mndProcessPauseStreamReq(SRpcMsg *pReq) { // pause stream taosWLockLatch(&pStream->lock); pStream->status = STREAM_STATUS__PAUSE; - if (mndPersistTransLog(pStream, pTrans,SDB_STATUS_READY) < 0) { + if (mndPersistTransLog(pStream, pTrans, SDB_STATUS_READY) < 0) { taosWUnLockLatch(&pStream->lock); sdbRelease(pMnode->pSdb, pStream); @@ -1617,7 +1615,7 @@ static int32_t mndProcessResumeStreamReq(SRpcMsg *pReq) { SMnode *pMnode = pReq->info.node; SStreamObj *pStream = NULL; - if(grantCheckExpire(TSDB_GRANT_STREAMS) < 0){ + if (grantCheckExpire(TSDB_GRANT_STREAMS) < 0) { terrno = TSDB_CODE_GRANT_EXPIRED; return -1; } @@ -1659,7 +1657,7 @@ static int32_t mndProcessResumeStreamReq(SRpcMsg *pReq) { return -1; } - STrans* pTrans = doCreateTrans(pMnode, pStream, pReq, MND_STREAM_RESUME_NAME, "resume the stream"); + STrans *pTrans = doCreateTrans(pMnode, pStream, pReq, MND_STREAM_RESUME_NAME, "resume the stream"); if (pTrans == NULL) { mError("stream:%s, failed to resume stream since %s", resumeReq.name, terrstr()); sdbRelease(pMnode->pSdb, pStream); @@ -2106,10 +2104,10 @@ void removeStreamTasksInBuf(SStreamObj *pStream, SStreamExecInfo *pExecNode) { ASSERT(taosHashGetSize(pExecNode->pTaskMap) == taosArrayGetSize(pExecNode->pTaskList)); } -static void doAddTaskId(SArray* pList, int32_t taskId, int64_t uid, int32_t numOfTotal) { +static void doAddTaskId(SArray *pList, int32_t taskId, int64_t uid, int32_t numOfTotal) { int32_t num = taosArrayGetSize(pList); - for(int32_t i = 0; i < num; ++i) { - int32_t* pId = taosArrayGet(pList, i); + for (int32_t i = 0; i < num; ++i) { + int32_t *pId = taosArrayGet(pList, i); if (taskId == *pId) { return; } @@ -2122,7 +2120,7 @@ static void doAddTaskId(SArray* pList, int32_t taskId, int64_t uid, int32_t numO } int32_t mndProcessStreamReqCheckpoint(SRpcMsg *pReq) { - SMnode *pMnode = pReq->info.node; + SMnode *pMnode = pReq->info.node; SStreamTaskCheckpointReq req = {0}; SDecoder decoder = {0}; @@ -2143,7 +2141,7 @@ int32_t mndProcessStreamReqCheckpoint(SRpcMsg *pReq) { SStreamObj *pStream = mndGetStreamObj(pMnode, req.streamId); if (pStream == NULL) { - mError("failed to find the stream:0x%"PRIx64" not handle the checkpoint req", req.streamId); + mError("failed to find the stream:0x%" PRIx64 " not handle the checkpoint req", req.streamId); terrno = TSDB_CODE_MND_STREAM_NOT_EXIST; taosThreadMutexUnlock(&execInfo.lock); @@ -2151,13 +2149,13 @@ int32_t mndProcessStreamReqCheckpoint(SRpcMsg *pReq) { } int32_t numOfTasks = mndGetNumOfStreamTasks(pStream); - SArray **pReqTaskList = (SArray**)taosHashGet(execInfo.pTransferStateStreams, &req.streamId, sizeof(req.streamId)); + SArray **pReqTaskList = (SArray **)taosHashGet(execInfo.pTransferStateStreams, &req.streamId, sizeof(req.streamId)); if (pReqTaskList == NULL) { SArray *pList = taosArrayInit(4, sizeof(int32_t)); doAddTaskId(pList, req.taskId, pStream->uid, numOfTasks); taosHashPut(execInfo.pTransferStateStreams, &req.streamId, sizeof(int64_t), &pList, sizeof(void *)); - pReqTaskList = (SArray**)taosHashGet(execInfo.pTransferStateStreams, &req.streamId, sizeof(req.streamId)); + pReqTaskList = (SArray **)taosHashGet(execInfo.pTransferStateStreams, &req.streamId, sizeof(req.streamId)); } else { doAddTaskId(*pReqTaskList, req.taskId, pStream->uid, numOfTasks); } diff --git a/source/dnode/vnode/src/tq/tqSink.c b/source/dnode/vnode/src/tq/tqSink.c index b438b2dc0a..b56bf3e0fe 100644 --- a/source/dnode/vnode/src/tq/tqSink.c +++ b/source/dnode/vnode/src/tq/tqSink.c @@ -33,15 +33,18 @@ static int32_t doBuildAndSendDeleteMsg(SVnode* pVnode, char* stbFullName, SSData int64_t suid); static int32_t doBuildAndSendSubmitMsg(SVnode* pVnode, SStreamTask* pTask, SSubmitReq2* pReq, int32_t numOfBlocks); static int32_t buildSubmitMsgImpl(SSubmitReq2* pSubmitReq, int32_t vgId, void** pMsg, int32_t* msgLen); -static int32_t doConvertRows(SSubmitTbData* pTableData, const STSchema* pTSchema, SSDataBlock* pDataBlock, const char* id); +static int32_t doConvertRows(SSubmitTbData* pTableData, const STSchema* pTSchema, SSDataBlock* pDataBlock, + const char* id); static int32_t doWaitForDstTableCreated(SVnode* pVnode, SStreamTask* pTask, STableSinkInfo* pTableSinkInfo, const char* dstTableName, int64_t* uid); -static int32_t doPutIntoCache(SSHashObj* pSinkTableMap, STableSinkInfo* pTableSinkInfo, uint64_t groupId, const char* id); +static int32_t doPutIntoCache(SSHashObj* pSinkTableMap, STableSinkInfo* pTableSinkInfo, uint64_t groupId, + const char* id); static bool isValidDstChildTable(SMetaReader* pReader, int32_t vgId, const char* ctbName, int64_t suid); -static int32_t initCreateTableMsg(SVCreateTbReq* pCreateTableReq, uint64_t suid, const char* stbFullName, int32_t numOfTags); +static int32_t initCreateTableMsg(SVCreateTbReq* pCreateTableReq, uint64_t suid, const char* stbFullName, + int32_t numOfTags); static SArray* createDefaultTagColName(); -static void setCreateTableMsgTableName(SVCreateTbReq* pCreateTableReq, SSDataBlock* pDataBlock, const char* stbFullName, - int64_t gid, bool newSubTableRule); +static void setCreateTableMsgTableName(SVCreateTbReq* pCreateTableReq, SSDataBlock* pDataBlock, const char* stbFullName, + int64_t gid, bool newSubTableRule); int32_t tqBuildDeleteReq(STQ* pTq, const char* stbFullName, const SSDataBlock* pDataBlock, SBatchDeleteReq* deleteReq, const char* pIdStr, bool newSubTableRule) { @@ -68,10 +71,7 @@ int32_t tqBuildDeleteReq(STQ* pTq, const char* stbFullName, const SSDataBlock* p if (varTbName != NULL && varTbName != (void*)-1) { name = taosMemoryCalloc(1, TSDB_TABLE_NAME_LEN); memcpy(name, varDataVal(varTbName), varDataLen(varTbName)); - if(newSubTableRule && - !isAutoTableName(name) && - !alreadyAddGroupId(name) && - groupId != 0) { + if (newSubTableRule && !isAutoTableName(name) && !alreadyAddGroupId(name) && groupId != 0) { buildCtbNameAddGruopId(name, groupId); } } else if (stbFullName) { @@ -134,7 +134,7 @@ end: return ret; } -static bool tqGetTableInfo(SSHashObj* pTableInfoMap,uint64_t groupId, STableSinkInfo** pInfo) { +static bool tqGetTableInfo(SSHashObj* pTableInfoMap, uint64_t groupId, STableSinkInfo** pInfo) { void* pVal = tSimpleHashGet(pTableInfoMap, &groupId, sizeof(uint64_t)); if (pVal) { *pInfo = *(STableSinkInfo**)pVal; @@ -149,7 +149,7 @@ static int32_t tqPutReqToQueue(SVnode* pVnode, SVCreateTbBatchReq* pReqs) { int32_t tlen = 0; encodeCreateChildTableForRPC(pReqs, TD_VID(pVnode), &buf, &tlen); - SRpcMsg msg = { .msgType = TDMT_VND_CREATE_TABLE, .pCont = buf, .contLen = tlen }; + SRpcMsg msg = {.msgType = TDMT_VND_CREATE_TABLE, .pCont = buf, .contLen = tlen}; if (tmsgPutToQueue(&pVnode->msgCb, WRITE_QUEUE, &msg) != 0) { tqError("failed to put into write-queue since %s", terrstr()); } @@ -181,14 +181,12 @@ SArray* createDefaultTagColName() { void setCreateTableMsgTableName(SVCreateTbReq* pCreateTableReq, SSDataBlock* pDataBlock, const char* stbFullName, int64_t gid, bool newSubTableRule) { if (pDataBlock->info.parTbName[0]) { - if(newSubTableRule && - !isAutoTableName(pDataBlock->info.parTbName) && - !alreadyAddGroupId(pDataBlock->info.parTbName) && - gid != 0) { + if (newSubTableRule && !isAutoTableName(pDataBlock->info.parTbName) && + !alreadyAddGroupId(pDataBlock->info.parTbName) && gid != 0) { pCreateTableReq->name = taosMemoryCalloc(1, TSDB_TABLE_NAME_LEN); strcpy(pCreateTableReq->name, pDataBlock->info.parTbName); buildCtbNameAddGruopId(pCreateTableReq->name, gid); - }else{ + } else { pCreateTableReq->name = taosStrdup(pDataBlock->info.parTbName); } } else { @@ -196,17 +194,18 @@ void setCreateTableMsgTableName(SVCreateTbReq* pCreateTableReq, SSDataBlock* pDa } } -static int32_t doBuildAndSendCreateTableMsg(SVnode* pVnode, char* stbFullName, SSDataBlock* pDataBlock, SStreamTask* pTask, - int64_t suid) { +static int32_t doBuildAndSendCreateTableMsg(SVnode* pVnode, char* stbFullName, SSDataBlock* pDataBlock, + SStreamTask* pTask, int64_t suid) { tqDebug("s-task:%s build create table msg", pTask->id.idStr); STSchema* pTSchema = pTask->outputInfo.tbSink.pTSchema; int32_t rows = pDataBlock->info.rows; - SArray* tagArray = taosArrayInit(4, sizeof(STagVal));; - int32_t code = 0; + SArray* tagArray = taosArrayInit(4, sizeof(STagVal)); + ; + int32_t code = 0; SVCreateTbBatchReq reqs = {0}; - SArray* crTblArray = reqs.pArray = taosArrayInit(1, sizeof(SVCreateTbReq)); + SArray* crTblArray = reqs.pArray = taosArrayInit(1, sizeof(SVCreateTbReq)); if (NULL == reqs.pArray) { tqError("s-task:%s failed to init create table msg, code:%s", pTask->id.idStr, tstrerror(terrno)); goto _end; @@ -262,7 +261,8 @@ static int32_t doBuildAndSendCreateTableMsg(SVnode* pVnode, char* stbFullName, S ASSERT(gid == *(int64_t*)pGpIdData); } - setCreateTableMsgTableName(pCreateTbReq, pDataBlock, stbFullName, gid, pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER); + setCreateTableMsgTableName(pCreateTbReq, pDataBlock, stbFullName, gid, + pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER && pTask->subtableWithoutMd5 != 1); taosArrayPush(reqs.pArray, pCreateTbReq); tqDebug("s-task:%s build create table:%s msg complete", pTask->id.idStr, pCreateTbReq->name); @@ -274,7 +274,7 @@ static int32_t doBuildAndSendCreateTableMsg(SVnode* pVnode, char* stbFullName, S tqError("s-task:%s failed to send create table msg", pTask->id.idStr); } - _end: +_end: taosArrayDestroy(tagArray); taosArrayDestroyEx(crTblArray, (FDelete)tdDestroySVCreateTbReq); return code; @@ -361,7 +361,8 @@ int32_t doMergeExistedRows(SSubmitTbData* pExisted, const SSubmitTbData* pNew, c pExisted->aRowP = pFinal; tqTrace("s-task:%s rows merged, final rows:%d, uid:%" PRId64 ", existed auto-create table:%d, new-block:%d", id, - (int32_t)taosArrayGetSize(pFinal), pExisted->uid, (pExisted->pCreateTbReq != NULL), (pNew->pCreateTbReq != NULL)); + (int32_t)taosArrayGetSize(pFinal), pExisted->uid, (pExisted->pCreateTbReq != NULL), + (pNew->pCreateTbReq != NULL)); tdDestroySVCreateTbReq(pNew->pCreateTbReq); taosMemoryFree(pNew->pCreateTbReq); @@ -373,7 +374,7 @@ int32_t doBuildAndSendDeleteMsg(SVnode* pVnode, char* stbFullName, SSDataBlock* SBatchDeleteReq deleteReq = {.suid = suid, .deleteReqs = taosArrayInit(0, sizeof(SSingleDeleteReq))}; int32_t code = tqBuildDeleteReq(pVnode->pTq, stbFullName, pDataBlock, &deleteReq, pTask->id.idStr, - pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER); + pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER && pTask->subtableWithoutMd5 != 1); if (code != TSDB_CODE_SUCCESS) { return code; } @@ -416,8 +417,8 @@ bool isValidDstChildTable(SMetaReader* pReader, int32_t vgId, const char* ctbNam } if (pReader->me.ctbEntry.suid != suid) { - tqError("vgId:%d, failed to write into %s, since suid mismatch, expect suid:%" PRId64 ", actual:%" PRId64, - vgId, ctbName, suid, pReader->me.ctbEntry.suid); + tqError("vgId:%d, failed to write into %s, since suid mismatch, expect suid:%" PRId64 ", actual:%" PRId64, vgId, + ctbName, suid, pReader->me.ctbEntry.suid); terrno = TSDB_CODE_TDB_TABLE_IN_OTHER_STABLE; return false; } @@ -437,10 +438,10 @@ SVCreateTbReq* buildAutoCreateTableReq(const char* stbFullName, int64_t suid, in taosArrayClear(pTagArray); initCreateTableMsg(pCreateTbReq, suid, stbFullName, 1); - STagVal tagVal = { .cid = numOfCols, .type = TSDB_DATA_TYPE_UBIGINT, .i64 = pDataBlock->info.id.groupId}; + STagVal tagVal = {.cid = numOfCols, .type = TSDB_DATA_TYPE_UBIGINT, .i64 = pDataBlock->info.id.groupId}; taosArrayPush(pTagArray, &tagVal); - tTagNew(pTagArray, 1, false, (STag**) &pCreateTbReq->ctb.pTag); + tTagNew(pTagArray, 1, false, (STag**)&pCreateTbReq->ctb.pTag); if (pCreateTbReq->ctb.pTag == NULL) { tdDestroySVCreateTbReq(pCreateTbReq); @@ -513,13 +514,13 @@ int32_t buildSubmitMsgImpl(SSubmitReq2* pSubmitReq, int32_t vgId, void** pMsg, i } int32_t tsAscendingSortFn(const void* p1, const void* p2) { - SRow* pRow1 = *(SRow**) p1; - SRow* pRow2 = *(SRow**) p2; + SRow* pRow1 = *(SRow**)p1; + SRow* pRow2 = *(SRow**)p2; if (pRow1->ts == pRow2->ts) { return 0; } else { - return pRow1->ts > pRow2->ts? 1:-1; + return pRow1->ts > pRow2->ts ? 1 : -1; } } @@ -563,7 +564,7 @@ int32_t doConvertRows(SSubmitTbData* pTableData, const STSchema* pTSchema, SSDat void* colData = colDataGetData(pColData, j); if (IS_STR_DATA_TYPE(pCol->type)) { // address copy, no value - SValue sv = (SValue){.nData = varDataLen(colData), .pData = (uint8_t*) varDataVal(colData)}; + SValue sv = (SValue){.nData = varDataLen(colData), .pData = (uint8_t*)varDataVal(colData)}; SColVal cv = COL_VAL_VALUE(pCol->colId, pCol->type, sv); taosArrayPush(pVals, &cv); } else { @@ -666,11 +667,9 @@ int32_t setDstTableDataUid(SVnode* pVnode, SStreamTask* pTask, SSDataBlock* pDat if (dstTableName[0] == 0) { memset(dstTableName, 0, TSDB_TABLE_NAME_LEN); buildCtbNameByGroupIdImpl(stbFullName, groupId, dstTableName); - }else{ - if(pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER && - !isAutoTableName(dstTableName) && - !alreadyAddGroupId(dstTableName) && - groupId != 0) { + } else { + if (pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER && pTask->subtableWithoutMd5 != 1 && + !isAutoTableName(dstTableName) && !alreadyAddGroupId(dstTableName) && groupId != 0) { buildCtbNameAddGruopId(dstTableName, groupId); } } @@ -693,7 +692,7 @@ int32_t setDstTableDataUid(SVnode* pVnode, SStreamTask* pTask, SSDataBlock* pDat tqTrace("s-task:%s cached tableInfo uid is invalid, acquire it from meta", id); return doWaitForDstTableCreated(pVnode, pTask, pTableSinkInfo, dstTableName, &pTableData->uid); } else { - tqTrace("s-task:%s set the dstTable uid from cache:%"PRId64, id, pTableData->uid); + tqTrace("s-task:%s set the dstTable uid from cache:%" PRId64, id, pTableData->uid); } } else { // The auto-create option will always set to be open for those submit messages, which arrive during the period @@ -714,7 +713,8 @@ int32_t setDstTableDataUid(SVnode* pVnode, SStreamTask* pTask, SSDataBlock* pDat pTableData->flags = SUBMIT_REQ_AUTO_CREATE_TABLE; pTableData->pCreateTbReq = - buildAutoCreateTableReq(stbFullName, suid, pTSchema->numOfCols + 1, pDataBlock, pTagArray, pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER); + buildAutoCreateTableReq(stbFullName, suid, pTSchema->numOfCols + 1, pDataBlock, pTagArray, + pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER && pTask->subtableWithoutMd5 != 1); taosArrayDestroy(pTagArray); if (pTableData->pCreateTbReq == NULL) { @@ -746,12 +746,12 @@ int32_t setDstTableDataUid(SVnode* pVnode, SStreamTask* pTask, SSDataBlock* pDat return TDB_CODE_SUCCESS; } -int32_t tqSetDstTableDataPayload(uint64_t suid, const STSchema *pTSchema, int32_t blockIndex, SSDataBlock* pDataBlock, - SSubmitTbData* pTableData, const char* id) { +int32_t tqSetDstTableDataPayload(uint64_t suid, const STSchema* pTSchema, int32_t blockIndex, SSDataBlock* pDataBlock, + SSubmitTbData* pTableData, const char* id) { int32_t numOfRows = pDataBlock->info.rows; - tqDebug("s-task:%s sink data pipeline, build submit msg from %dth resBlock, including %d rows, dst suid:%" PRId64, - id, blockIndex + 1, numOfRows, suid); + tqDebug("s-task:%s sink data pipeline, build submit msg from %dth resBlock, including %d rows, dst suid:%" PRId64, id, + blockIndex + 1, numOfRows, suid); char* dstTableName = pDataBlock->info.parTbName; // convert all rows @@ -767,14 +767,14 @@ int32_t tqSetDstTableDataPayload(uint64_t suid, const STSchema *pTSchema, int32_ } bool hasOnlySubmitData(const SArray* pBlocks, int32_t numOfBlocks) { - for(int32_t i = 0; i < numOfBlocks; ++i) { + for (int32_t i = 0; i < numOfBlocks; ++i) { SSDataBlock* p = taosArrayGet(pBlocks, i); if (p->info.type == STREAM_DELETE_RESULT || p->info.type == STREAM_CREATE_CHILD_TABLE) { return false; } } - return true; + return true; } void tqSinkDataIntoDstTable(SStreamTask* pTask, void* vnode, void* data) { @@ -793,7 +793,7 @@ void tqSinkDataIntoDstTable(SStreamTask* pTask, void* vnode, void* data) { tqDebug("vgId:%d, s-task:%s write %d stream resBlock(s) into table, has delete block, submit one-by-one", vgId, id, numOfBlocks); - for(int32_t i = 0; i < numOfBlocks; ++i) { + for (int32_t i = 0; i < numOfBlocks; ++i) { if (streamTaskShouldStop(pTask)) { return; } @@ -832,7 +832,8 @@ void tqSinkDataIntoDstTable(SStreamTask* pTask, void* vnode, void* data) { } } else { tqDebug("vgId:%d, s-task:%s write %d stream resBlock(s) into table, merge submit msg", vgId, id, numOfBlocks); - SHashObj* pTableIndexMap = taosHashInit(numOfBlocks, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK); + SHashObj* pTableIndexMap = + taosHashInit(numOfBlocks, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK); SSubmitReq2 submitReq = {.aSubmitTbData = taosArrayInit(1, sizeof(SSubmitTbData))}; if (submitReq.aSubmitTbData == NULL) { diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y index ba1517a212..4c59f3abd7 100755 --- a/source/libs/parser/inc/sql.y +++ b/source/libs/parser/inc/sql.y @@ -516,7 +516,7 @@ cmd ::= SHOW VNODES. // show alive cmd ::= SHOW db_name_cond_opt(A) ALIVE. { pCxt->pRootNode = createShowAliveStmt(pCxt, A, QUERY_NODE_SHOW_DB_ALIVE_STMT); } cmd ::= SHOW CLUSTER ALIVE. { pCxt->pRootNode = createShowAliveStmt(pCxt, NULL, QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT); } -cmd ::= SHOW db_name_cond_opt(A) VIEWS. { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VIEWS_STMT, A, NULL, OP_TYPE_LIKE); } +cmd ::= SHOW db_name_cond_opt(A) VIEWS like_pattern_opt(B). { pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VIEWS_STMT, A, B, OP_TYPE_LIKE); } cmd ::= SHOW CREATE VIEW full_table_name(A). { pCxt->pRootNode = createShowCreateViewStmt(pCxt, QUERY_NODE_SHOW_CREATE_VIEW_STMT, A); } cmd ::= SHOW COMPACTS. { pCxt->pRootNode = createShowCompactsStmt(pCxt, QUERY_NODE_SHOW_COMPACTS_STMT); } cmd ::= SHOW COMPACT NK_INTEGER(A). { pCxt->pRootNode = createShowCompactDetailsStmt(pCxt, createValueNode(pCxt, TSDB_DATA_TYPE_BIGINT, &A)); } diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index 0caea44fef..abe50a27da 100644 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -9457,7 +9457,20 @@ static int32_t createOperatorNode(EOperatorType opType, const char* pColName, SN } static const char* getTbNameColName(ENodeType type) { - return (QUERY_NODE_SHOW_STABLES_STMT == type ? "stable_name" : "table_name"); + const char* colName; + switch (type) + { + case QUERY_NODE_SHOW_VIEWS_STMT: + colName = "view_name"; + break; + case QUERY_NODE_SHOW_STABLES_STMT: + colName = "stable_name"; + break; + default: + colName = "table_name"; + break; + } + return colName; } static int32_t createLogicCondNode(SNode* pCond1, SNode* pCond2, SNode** pCond, ELogicConditionType logicCondType) { diff --git a/source/libs/parser/src/sql.c b/source/libs/parser/src/sql.c index d7295823c3..9833c8151b 100644 --- a/source/libs/parser/src/sql.c +++ b/source/libs/parser/src/sql.c @@ -491,18 +491,18 @@ typedef union { #define ParseCTX_FETCH #define ParseCTX_STORE #define YYFALLBACK 1 -#define YYNSTATE 851 +#define YYNSTATE 852 #define YYNRULE 649 #define YYNRULE_WITH_ACTION 649 #define YYNTOKEN 351 -#define YY_MAX_SHIFT 850 -#define YY_MIN_SHIFTREDUCE 1255 -#define YY_MAX_SHIFTREDUCE 1903 -#define YY_ERROR_ACTION 1904 -#define YY_ACCEPT_ACTION 1905 -#define YY_NO_ACTION 1906 -#define YY_MIN_REDUCE 1907 -#define YY_MAX_REDUCE 2555 +#define YY_MAX_SHIFT 851 +#define YY_MIN_SHIFTREDUCE 1256 +#define YY_MAX_SHIFTREDUCE 1904 +#define YY_ERROR_ACTION 1905 +#define YY_ACCEPT_ACTION 1906 +#define YY_NO_ACTION 1907 +#define YY_MIN_REDUCE 1908 +#define YY_MAX_REDUCE 2556 /************* End control #defines *******************************************/ #define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) @@ -571,301 +571,301 @@ typedef union { *********** Begin parsing tables **********************************************/ #define YY_ACTTAB_COUNT (2941) static const YYACTIONTYPE yy_action[] = { - /* 0 */ 95, 2331, 566, 2150, 467, 567, 1950, 14, 13, 466, - /* 10 */ 2184, 2314, 48, 46, 1825, 2339, 2531, 386, 722, 2526, - /* 20 */ 418, 698, 1666, 41, 40, 2335, 2092, 47, 45, 44, - /* 30 */ 43, 42, 174, 646, 1919, 1751, 1993, 1664, 2530, 736, - /* 40 */ 2097, 703, 2527, 2529, 2526, 2355, 38, 320, 644, 583, - /* 50 */ 642, 269, 268, 1695, 674, 715, 146, 2526, 718, 137, - /* 60 */ 112, 674, 702, 203, 2526, 1746, 609, 2527, 704, 2337, - /* 70 */ 415, 19, 738, 2235, 2417, 2532, 203, 147, 1672, 746, - /* 80 */ 2527, 704, 2532, 203, 2235, 2089, 2373, 2527, 704, 41, - /* 90 */ 40, 2233, 723, 47, 45, 44, 43, 42, 2321, 411, - /* 100 */ 752, 586, 2232, 723, 847, 584, 2228, 15, 474, 822, - /* 110 */ 821, 820, 819, 430, 1794, 818, 817, 151, 812, 811, - /* 120 */ 810, 809, 808, 807, 806, 150, 800, 799, 798, 429, - /* 130 */ 428, 795, 794, 793, 183, 182, 792, 2073, 1321, 2354, - /* 140 */ 1320, 63, 2392, 1753, 1754, 114, 2356, 756, 2358, 2359, - /* 150 */ 751, 1691, 746, 533, 531, 142, 366, 186, 574, 2445, - /* 160 */ 217, 567, 1950, 414, 2441, 300, 2453, 714, 571, 138, - /* 170 */ 713, 510, 2526, 1322, 568, 509, 184, 2150, 205, 2531, - /* 180 */ 1726, 1736, 2526, 508, 382, 735, 2475, 1752, 1755, 1869, - /* 190 */ 702, 203, 2148, 715, 146, 2527, 704, 1907, 384, 52, - /* 200 */ 2215, 2530, 1667, 63, 1665, 2527, 2528, 791, 196, 1900, - /* 210 */ 1691, 41, 40, 2144, 2145, 47, 45, 44, 43, 42, - /* 220 */ 2137, 136, 135, 134, 133, 132, 131, 130, 129, 128, - /* 230 */ 735, 483, 2211, 527, 1670, 1671, 1723, 1723, 1725, 1728, - /* 240 */ 1729, 1730, 1731, 1732, 1733, 1734, 1735, 748, 744, 1744, - /* 250 */ 1745, 1747, 1748, 1749, 1750, 2, 48, 46, 1324, 1325, - /* 260 */ 1692, 364, 703, 1689, 418, 2526, 1666, 427, 426, 1696, - /* 270 */ 517, 237, 2355, 536, 376, 569, 657, 1958, 535, 1751, - /* 280 */ 219, 1664, 223, 702, 203, 750, 272, 239, 2527, 704, - /* 290 */ 271, 569, 1673, 1958, 497, 227, 537, 465, 1695, 464, - /* 300 */ 697, 365, 499, 202, 2453, 2454, 304, 144, 2458, 1746, - /* 310 */ 1930, 658, 477, 2373, 1899, 19, 1459, 51, 1780, 526, - /* 320 */ 525, 451, 1672, 90, 273, 2321, 89, 752, 2373, 463, - /* 330 */ 1450, 781, 780, 779, 1454, 778, 1456, 1457, 777, 774, - /* 340 */ 582, 1465, 771, 1467, 1468, 768, 765, 762, 847, 385, - /* 350 */ 1692, 15, 789, 161, 160, 786, 785, 784, 158, 98, - /* 360 */ 485, 1996, 371, 2321, 304, 397, 2354, 648, 304, 2392, - /* 370 */ 1565, 1566, 356, 2356, 756, 2358, 2359, 751, 749, 746, - /* 380 */ 737, 2410, 1781, 1585, 1586, 576, 2274, 1753, 1754, 696, - /* 390 */ 2222, 2201, 88, 524, 523, 522, 521, 516, 515, 514, - /* 400 */ 513, 368, 1634, 1635, 1929, 503, 502, 501, 500, 494, - /* 410 */ 493, 492, 2531, 487, 486, 383, 184, 736, 2097, 478, - /* 420 */ 1553, 1554, 715, 146, 1726, 1736, 1572, 1584, 1587, 1694, - /* 430 */ 2460, 1752, 1755, 1694, 628, 627, 626, 137, 715, 146, - /* 440 */ 2216, 618, 143, 622, 614, 1304, 1667, 621, 1665, 455, - /* 450 */ 1695, 1690, 620, 625, 392, 391, 2457, 2321, 619, 1676, - /* 460 */ 194, 615, 37, 416, 1775, 1776, 1777, 1778, 1779, 1783, - /* 470 */ 1784, 1785, 1786, 1494, 1495, 791, 457, 453, 1670, 1671, - /* 480 */ 1723, 743, 1725, 1728, 1729, 1730, 1731, 1732, 1733, 1734, - /* 490 */ 1735, 748, 744, 1744, 1745, 1747, 1748, 1749, 1750, 2, - /* 500 */ 12, 48, 46, 2355, 1321, 2331, 1320, 735, 2530, 418, - /* 510 */ 2074, 1666, 421, 1822, 1696, 255, 753, 1893, 423, 2088, - /* 520 */ 168, 2143, 2145, 2150, 1751, 1928, 1664, 399, 2099, 2335, - /* 530 */ 398, 179, 204, 2453, 2454, 2148, 144, 2458, 2148, 1322, - /* 540 */ 603, 599, 595, 591, 2373, 254, 106, 717, 201, 2453, - /* 550 */ 2454, 1302, 144, 2458, 1746, 12, 2321, 2150, 752, 655, - /* 560 */ 19, 628, 627, 626, 408, 3, 693, 1672, 618, 143, - /* 570 */ 622, 2090, 2148, 2337, 621, 1300, 1301, 54, 2321, 620, - /* 580 */ 625, 392, 391, 746, 1858, 619, 96, 1691, 615, 252, - /* 590 */ 12, 302, 10, 847, 51, 302, 15, 2354, 736, 2097, - /* 600 */ 2392, 2355, 95, 114, 2356, 756, 2358, 2359, 751, 740, - /* 610 */ 746, 2417, 198, 149, 753, 156, 2416, 2445, 491, 41, - /* 620 */ 40, 414, 2441, 47, 45, 44, 43, 42, 2093, 2331, - /* 630 */ 1414, 1695, 1753, 1754, 690, 689, 1856, 1857, 1859, 1860, - /* 640 */ 1861, 1927, 2373, 2340, 1772, 1413, 789, 161, 160, 786, - /* 650 */ 785, 784, 158, 2335, 2321, 242, 752, 1908, 699, 694, - /* 660 */ 687, 683, 489, 2211, 251, 244, 1696, 519, 2211, 1726, - /* 670 */ 1736, 249, 580, 1926, 63, 658, 1752, 1755, 127, 68, - /* 680 */ 2302, 126, 125, 124, 123, 122, 121, 120, 119, 118, - /* 690 */ 241, 1667, 173, 1665, 2321, 2354, 805, 2337, 2392, 2058, - /* 700 */ 2036, 114, 2356, 756, 2358, 2359, 751, 746, 746, 563, - /* 710 */ 1925, 221, 538, 2420, 2315, 2445, 226, 1672, 561, 414, - /* 720 */ 2441, 557, 553, 1670, 1671, 1723, 2321, 1725, 1728, 1729, - /* 730 */ 1730, 1731, 1732, 1733, 1734, 1735, 748, 744, 1744, 1745, - /* 740 */ 1747, 1748, 1749, 1750, 2, 48, 46, 1756, 2355, 660, - /* 750 */ 2274, 736, 2097, 418, 2283, 1666, 653, 311, 312, 304, - /* 760 */ 159, 718, 310, 2321, 674, 1935, 842, 2526, 1751, 127, - /* 770 */ 1664, 208, 126, 125, 124, 123, 122, 121, 120, 119, - /* 780 */ 118, 2355, 63, 1821, 412, 2532, 203, 736, 2097, 2373, - /* 790 */ 2527, 704, 171, 199, 753, 2150, 1960, 325, 1746, 706, - /* 800 */ 2099, 2321, 413, 752, 736, 2097, 674, 56, 274, 2526, - /* 810 */ 2148, 1672, 41, 40, 2150, 421, 47, 45, 44, 43, - /* 820 */ 42, 422, 2373, 171, 471, 605, 604, 2532, 203, 2148, - /* 830 */ 424, 2099, 2527, 704, 2321, 55, 752, 847, 171, 304, - /* 840 */ 49, 9, 2354, 736, 2097, 2392, 2099, 1696, 114, 2356, - /* 850 */ 756, 2358, 2359, 751, 1924, 746, 2355, 1923, 782, 1666, - /* 860 */ 186, 1295, 2445, 472, 171, 1922, 414, 2441, 2460, 753, - /* 870 */ 736, 2097, 2100, 1921, 1664, 2354, 1753, 1754, 2392, 2072, - /* 880 */ 1302, 114, 2356, 756, 2358, 2359, 751, 1918, 746, 2476, - /* 890 */ 504, 635, 1829, 2546, 2456, 2445, 1761, 2373, 1691, 414, - /* 900 */ 2441, 197, 1691, 1297, 1300, 1301, 647, 2321, 210, 2321, - /* 910 */ 2321, 752, 1841, 1726, 1736, 1672, 736, 2097, 2321, 2305, - /* 920 */ 1752, 1755, 270, 41, 40, 1691, 2321, 47, 45, 44, - /* 930 */ 43, 42, 44, 43, 42, 1667, 505, 1665, 638, 1850, - /* 940 */ 2321, 847, 673, 624, 623, 632, 630, 304, 30, 2150, - /* 950 */ 2354, 1402, 267, 2392, 1851, 659, 176, 2356, 756, 2358, - /* 960 */ 2359, 751, 2086, 746, 731, 607, 606, 1670, 1671, 1723, - /* 970 */ 440, 1725, 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, - /* 980 */ 748, 744, 1744, 1745, 1747, 1748, 1749, 1750, 2, 48, - /* 990 */ 46, 2082, 1404, 72, 1917, 1849, 71, 418, 1916, 1666, - /* 1000 */ 47, 45, 44, 43, 42, 674, 1915, 1914, 2526, 2084, - /* 1010 */ 705, 2547, 1751, 2150, 1664, 789, 161, 160, 786, 785, - /* 1020 */ 784, 158, 1913, 1870, 1912, 2355, 2532, 203, 2149, 41, - /* 1030 */ 40, 2527, 704, 47, 45, 44, 43, 42, 753, 1667, - /* 1040 */ 2483, 1665, 1746, 1782, 736, 2097, 1691, 2321, 2355, 736, - /* 1050 */ 2097, 2321, 1418, 736, 2097, 1672, 736, 2097, 1727, 2321, - /* 1060 */ 2321, 753, 1727, 2496, 506, 148, 2373, 1417, 2416, 585, - /* 1070 */ 1814, 1670, 1671, 2094, 61, 2321, 275, 2321, 2321, 76, - /* 1080 */ 752, 847, 671, 2355, 49, 1727, 613, 41, 40, 2373, - /* 1090 */ 612, 47, 45, 44, 43, 42, 753, 707, 685, 34, - /* 1100 */ 2168, 2321, 2080, 752, 783, 41, 40, 2141, 1911, 47, - /* 1110 */ 45, 44, 43, 42, 1724, 736, 2097, 802, 1724, 2354, - /* 1120 */ 1753, 1754, 2392, 35, 2373, 114, 2356, 756, 2358, 2359, - /* 1130 */ 751, 87, 746, 1787, 540, 283, 2321, 2546, 752, 2445, - /* 1140 */ 710, 1724, 2354, 414, 2441, 2392, 1980, 99, 114, 2356, - /* 1150 */ 756, 2358, 2359, 751, 2194, 746, 1910, 1726, 1736, 1675, - /* 1160 */ 2546, 2321, 2445, 1674, 1752, 1755, 414, 2441, 629, 736, - /* 1170 */ 2097, 736, 2097, 787, 736, 2097, 2141, 2354, 1613, 1667, - /* 1180 */ 2392, 1665, 804, 114, 2356, 756, 2358, 2359, 751, 321, - /* 1190 */ 746, 721, 719, 36, 315, 2546, 481, 2445, 139, 41, - /* 1200 */ 40, 414, 2441, 47, 45, 44, 43, 42, 2101, 2321, - /* 1210 */ 86, 1670, 1671, 1723, 280, 1725, 1728, 1729, 1730, 1731, - /* 1220 */ 1732, 1733, 1734, 1735, 748, 744, 1744, 1745, 1747, 1748, - /* 1230 */ 1749, 1750, 2, 48, 46, 390, 389, 736, 2097, 2460, - /* 1240 */ 2075, 418, 674, 1666, 159, 2526, 736, 2097, 816, 814, - /* 1250 */ 736, 2097, 788, 2465, 1814, 2141, 1751, 733, 1664, 512, - /* 1260 */ 511, 170, 1724, 2532, 203, 2455, 734, 159, 2527, 704, - /* 1270 */ 425, 334, 260, 152, 2127, 258, 2355, 262, 264, 616, - /* 1280 */ 261, 263, 266, 1978, 1969, 265, 1746, 617, 681, 753, - /* 1290 */ 1967, 2519, 650, 284, 649, 2342, 50, 50, 1920, 1672, - /* 1300 */ 1902, 1903, 747, 1399, 1357, 631, 633, 388, 387, 187, - /* 1310 */ 611, 1397, 636, 14, 13, 2037, 2489, 2373, 172, 1629, - /* 1320 */ 297, 159, 50, 340, 309, 847, 1678, 796, 15, 2321, - /* 1330 */ 1677, 752, 613, 691, 2355, 75, 612, 100, 291, 157, - /* 1340 */ 338, 74, 1632, 159, 73, 1358, 66, 753, 141, 2464, - /* 1350 */ 111, 1376, 50, 2344, 367, 50, 2374, 760, 157, 108, - /* 1360 */ 708, 797, 2034, 1845, 1753, 1754, 235, 548, 546, 543, - /* 1370 */ 2354, 1855, 1854, 2392, 159, 2373, 114, 2356, 756, 2358, - /* 1380 */ 2359, 751, 2033, 746, 289, 1374, 2220, 2321, 2546, 752, - /* 1390 */ 2445, 1961, 1951, 2479, 414, 2441, 720, 1582, 688, 313, - /* 1400 */ 404, 1726, 1736, 140, 157, 711, 695, 63, 1752, 1755, - /* 1410 */ 728, 400, 431, 2221, 317, 1957, 2138, 2480, 1444, 725, - /* 1420 */ 2490, 1788, 667, 1667, 716, 1665, 299, 1737, 2354, 296, - /* 1430 */ 333, 2392, 1472, 1476, 114, 2356, 756, 2358, 2359, 751, - /* 1440 */ 2059, 746, 303, 840, 5, 64, 2546, 434, 2445, 1483, - /* 1450 */ 439, 380, 414, 2441, 447, 1670, 1671, 1723, 448, 1725, - /* 1460 */ 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 748, 744, - /* 1470 */ 1744, 1745, 1747, 1748, 1749, 1750, 2, 1699, 1481, 162, - /* 1480 */ 459, 427, 426, 211, 2355, 458, 212, 461, 214, 328, - /* 1490 */ 1689, 1680, 1606, 475, 84, 83, 470, 753, 1690, 216, - /* 1500 */ 482, 225, 484, 488, 1751, 490, 1673, 2355, 529, 495, - /* 1510 */ 507, 2213, 462, 460, 518, 520, 528, 542, 530, 541, - /* 1520 */ 753, 539, 230, 363, 544, 2373, 449, 229, 545, 446, - /* 1530 */ 442, 438, 435, 463, 1746, 1697, 1905, 2321, 564, 752, - /* 1540 */ 232, 547, 2355, 549, 4, 565, 572, 1672, 2373, 573, - /* 1550 */ 575, 240, 1692, 92, 1698, 753, 243, 577, 578, 1700, - /* 1560 */ 2321, 579, 752, 581, 246, 1701, 2229, 248, 93, 94, - /* 1570 */ 587, 608, 304, 742, 253, 610, 639, 640, 2354, 2087, - /* 1580 */ 116, 2392, 652, 2373, 114, 2356, 756, 2358, 2359, 751, - /* 1590 */ 360, 746, 257, 2083, 97, 2321, 2418, 752, 2445, 153, - /* 1600 */ 259, 2354, 414, 2441, 2392, 164, 654, 114, 2356, 756, - /* 1610 */ 2358, 2359, 751, 165, 746, 433, 2292, 2085, 2081, 739, - /* 1620 */ 432, 2445, 166, 2289, 167, 414, 2441, 276, 1693, 662, - /* 1630 */ 661, 2288, 281, 668, 666, 669, 2354, 678, 279, 2392, - /* 1640 */ 663, 2355, 115, 2356, 756, 2358, 2359, 751, 329, 746, - /* 1650 */ 692, 726, 2495, 8, 753, 2494, 2445, 286, 2275, 701, - /* 1660 */ 2444, 2441, 288, 676, 2467, 674, 290, 679, 2526, 677, - /* 1670 */ 295, 1681, 2355, 1676, 178, 405, 712, 2549, 709, 1814, - /* 1680 */ 1694, 1819, 2373, 145, 1817, 753, 2532, 203, 2461, 190, - /* 1690 */ 305, 2527, 704, 292, 2321, 294, 752, 293, 330, 2355, - /* 1700 */ 154, 1, 724, 1684, 1686, 2243, 2242, 331, 2241, 729, - /* 1710 */ 410, 155, 753, 2373, 730, 105, 2098, 744, 1744, 1745, - /* 1720 */ 1747, 1748, 1749, 1750, 332, 2321, 206, 752, 62, 2426, - /* 1730 */ 107, 2525, 335, 758, 1279, 2354, 323, 298, 2392, 2142, - /* 1740 */ 2373, 115, 2356, 756, 2358, 2359, 751, 841, 746, 844, - /* 1750 */ 163, 846, 2321, 344, 752, 2445, 372, 2355, 359, 741, - /* 1760 */ 2441, 373, 53, 337, 2313, 358, 754, 348, 339, 2392, - /* 1770 */ 753, 2312, 115, 2356, 756, 2358, 2359, 751, 2311, 746, - /* 1780 */ 81, 2306, 436, 437, 1657, 1658, 2445, 209, 441, 2304, - /* 1790 */ 375, 2441, 2355, 2354, 443, 444, 2392, 445, 2373, 175, - /* 1800 */ 2356, 756, 2358, 2359, 751, 753, 746, 1656, 2303, 381, - /* 1810 */ 2321, 2301, 752, 450, 2300, 2299, 452, 454, 2298, 456, - /* 1820 */ 1645, 2279, 2355, 213, 2278, 215, 1609, 82, 1608, 2256, - /* 1830 */ 2255, 2254, 468, 2373, 469, 753, 2253, 2252, 2203, 473, - /* 1840 */ 1552, 675, 2486, 2200, 476, 2321, 2199, 752, 2193, 479, - /* 1850 */ 480, 2354, 2190, 218, 2392, 2189, 2188, 115, 2356, 756, - /* 1860 */ 2358, 2359, 751, 2373, 746, 85, 2187, 2192, 402, 2191, - /* 1870 */ 2186, 2445, 2185, 2183, 220, 2321, 2442, 752, 2182, 2181, - /* 1880 */ 222, 496, 2180, 498, 2178, 2177, 2354, 2355, 2176, 2392, - /* 1890 */ 2175, 2198, 175, 2356, 756, 2358, 2359, 751, 224, 746, - /* 1900 */ 753, 2174, 2355, 2173, 2172, 2196, 2179, 2171, 2170, 2169, - /* 1910 */ 2167, 2166, 2165, 2164, 2163, 753, 2354, 2355, 1558, 2392, - /* 1920 */ 2162, 2161, 357, 2356, 756, 2358, 2359, 751, 2373, 746, - /* 1930 */ 753, 91, 2160, 403, 228, 2487, 2159, 2158, 2197, 2195, - /* 1940 */ 2321, 2157, 752, 2373, 2156, 2155, 2154, 532, 2153, 534, - /* 1950 */ 2152, 2151, 1415, 1419, 1999, 2321, 1411, 752, 2373, 231, - /* 1960 */ 1998, 1997, 233, 1995, 234, 369, 370, 1992, 551, 552, - /* 1970 */ 2321, 1991, 752, 555, 1984, 556, 559, 550, 1971, 554, - /* 1980 */ 558, 2354, 1946, 1303, 2392, 185, 562, 357, 2356, 756, - /* 1990 */ 2358, 2359, 751, 1945, 746, 560, 2354, 2355, 78, 2392, - /* 2000 */ 236, 238, 350, 2356, 756, 2358, 2359, 751, 2341, 746, - /* 2010 */ 753, 2354, 79, 195, 2392, 2355, 2277, 176, 2356, 756, - /* 2020 */ 2358, 2359, 751, 2273, 746, 570, 2263, 2251, 750, 245, - /* 2030 */ 2250, 247, 250, 2227, 2076, 1994, 1990, 1350, 2373, 588, - /* 2040 */ 2355, 589, 590, 409, 1988, 592, 593, 594, 700, 596, - /* 2050 */ 2321, 1986, 752, 753, 597, 598, 2373, 1983, 600, 602, - /* 2060 */ 601, 1966, 1964, 1965, 1963, 1942, 2078, 1487, 2321, 1488, - /* 2070 */ 752, 2077, 2548, 813, 1401, 1400, 1398, 65, 1396, 256, - /* 2080 */ 1395, 2373, 1387, 1394, 1393, 1392, 417, 815, 1981, 1389, - /* 2090 */ 1388, 2354, 1386, 2321, 2392, 752, 393, 357, 2356, 756, - /* 2100 */ 2358, 2359, 751, 1979, 746, 394, 1970, 395, 1968, 2354, - /* 2110 */ 2355, 634, 2392, 396, 656, 356, 2356, 756, 2358, 2359, - /* 2120 */ 751, 637, 746, 753, 2411, 1941, 1940, 1939, 1938, 641, - /* 2130 */ 643, 1937, 850, 645, 2354, 117, 1639, 2392, 1641, 1638, - /* 2140 */ 357, 2356, 756, 2358, 2359, 751, 2355, 746, 327, 2276, - /* 2150 */ 1643, 2373, 2272, 278, 57, 1615, 419, 29, 1617, 753, - /* 2160 */ 664, 58, 2262, 2321, 193, 752, 69, 665, 2249, 282, - /* 2170 */ 2248, 1594, 2531, 838, 834, 830, 826, 2355, 324, 1593, - /* 2180 */ 169, 670, 1619, 672, 20, 31, 285, 2373, 1872, 1846, - /* 2190 */ 753, 680, 401, 682, 684, 6, 7, 686, 287, 2321, - /* 2200 */ 17, 752, 200, 1853, 2354, 21, 22, 2392, 1840, 189, - /* 2210 */ 357, 2356, 756, 2358, 2359, 751, 177, 746, 2373, 113, - /* 2220 */ 2342, 188, 318, 32, 80, 33, 67, 1892, 1893, 24, - /* 2230 */ 2321, 1887, 752, 301, 23, 1886, 406, 1891, 1890, 407, - /* 2240 */ 651, 1811, 1810, 2392, 60, 18, 352, 2356, 756, 2358, - /* 2250 */ 2359, 751, 2355, 746, 732, 180, 59, 2247, 2226, 102, - /* 2260 */ 2225, 727, 103, 101, 25, 753, 308, 1848, 191, 26, - /* 2270 */ 314, 2354, 2355, 70, 2392, 319, 11, 342, 2356, 756, - /* 2280 */ 2358, 2359, 751, 108, 746, 753, 104, 1763, 2355, 316, - /* 2290 */ 1762, 1682, 13, 2373, 2395, 181, 1741, 307, 745, 192, - /* 2300 */ 39, 753, 1773, 1739, 306, 2321, 1716, 752, 759, 755, - /* 2310 */ 420, 1738, 16, 2373, 27, 763, 1708, 28, 766, 769, - /* 2320 */ 1473, 757, 761, 277, 1470, 2321, 764, 752, 767, 2373, - /* 2330 */ 1469, 772, 1466, 1460, 770, 773, 775, 1458, 776, 322, - /* 2340 */ 1482, 2321, 1464, 752, 109, 2355, 2354, 110, 77, 2392, - /* 2350 */ 1478, 1348, 341, 2356, 756, 2358, 2359, 751, 753, 746, - /* 2360 */ 1463, 1462, 1461, 790, 1383, 2355, 2354, 1380, 1379, 2392, - /* 2370 */ 1378, 1377, 343, 2356, 756, 2358, 2359, 751, 753, 746, - /* 2380 */ 1375, 1373, 2354, 2355, 1372, 2392, 2373, 1371, 349, 2356, - /* 2390 */ 756, 2358, 2359, 751, 1409, 746, 753, 801, 2321, 1408, - /* 2400 */ 752, 803, 207, 2355, 1366, 1369, 2373, 1368, 1367, 1365, - /* 2410 */ 1364, 1363, 1403, 1405, 1360, 1359, 753, 1356, 2321, 1354, - /* 2420 */ 752, 1989, 1355, 1353, 2373, 823, 1987, 824, 827, 825, - /* 2430 */ 828, 829, 1985, 831, 832, 833, 2321, 1982, 752, 2354, - /* 2440 */ 835, 2355, 2392, 836, 2373, 353, 2356, 756, 2358, 2359, - /* 2450 */ 751, 837, 746, 1962, 753, 839, 2321, 1292, 752, 2354, - /* 2460 */ 1936, 1280, 2392, 843, 845, 345, 2356, 756, 2358, 2359, - /* 2470 */ 751, 326, 746, 1668, 336, 848, 849, 2354, 2355, 1906, - /* 2480 */ 2392, 1906, 2373, 354, 2356, 756, 2358, 2359, 751, 1906, - /* 2490 */ 746, 753, 1906, 1906, 2321, 1906, 752, 2354, 2355, 1906, - /* 2500 */ 2392, 1906, 1906, 346, 2356, 756, 2358, 2359, 751, 1906, - /* 2510 */ 746, 753, 1906, 1906, 2355, 1906, 1906, 1906, 1906, 2373, - /* 2520 */ 1906, 1906, 1906, 1906, 1906, 1906, 1906, 753, 1906, 1906, - /* 2530 */ 1906, 2321, 1906, 752, 1906, 2354, 1906, 1906, 2392, 2373, - /* 2540 */ 1906, 355, 2356, 756, 2358, 2359, 751, 1906, 746, 1906, - /* 2550 */ 1906, 2321, 1906, 752, 1906, 2373, 1906, 1906, 1906, 1906, - /* 2560 */ 1906, 1906, 1906, 1906, 1906, 1906, 1906, 2321, 1906, 752, - /* 2570 */ 1906, 1906, 2354, 1906, 1906, 2392, 1906, 1906, 347, 2356, - /* 2580 */ 756, 2358, 2359, 751, 1906, 746, 1906, 1906, 1906, 1906, - /* 2590 */ 1906, 1906, 2354, 1906, 1906, 2392, 1906, 1906, 361, 2356, - /* 2600 */ 756, 2358, 2359, 751, 1906, 746, 1906, 2355, 2354, 1906, - /* 2610 */ 1906, 2392, 1906, 1906, 362, 2356, 756, 2358, 2359, 751, - /* 2620 */ 753, 746, 1906, 1906, 1906, 1906, 2355, 1906, 1906, 1906, - /* 2630 */ 1906, 1906, 1906, 1906, 1906, 1906, 1906, 1906, 1906, 753, - /* 2640 */ 1906, 1906, 1906, 2355, 1906, 1906, 1906, 1906, 2373, 1906, - /* 2650 */ 1906, 1906, 1906, 1906, 1906, 1906, 753, 1906, 1906, 1906, - /* 2660 */ 2321, 1906, 752, 1906, 1906, 1906, 1906, 2373, 1906, 1906, - /* 2670 */ 1906, 1906, 1906, 1906, 1906, 1906, 1906, 1906, 1906, 2321, - /* 2680 */ 1906, 752, 1906, 1906, 2373, 1906, 1906, 1906, 1906, 1906, - /* 2690 */ 1906, 1906, 1906, 1906, 1906, 1906, 2321, 1906, 752, 1906, - /* 2700 */ 2355, 2354, 1906, 1906, 2392, 1906, 1906, 2367, 2356, 756, - /* 2710 */ 2358, 2359, 751, 753, 746, 1906, 1906, 1906, 1906, 1906, - /* 2720 */ 2354, 2355, 1906, 2392, 1906, 1906, 2366, 2356, 756, 2358, - /* 2730 */ 2359, 751, 1906, 746, 753, 1906, 1906, 2354, 2355, 1906, - /* 2740 */ 2392, 2373, 1906, 2365, 2356, 756, 2358, 2359, 751, 1906, - /* 2750 */ 746, 753, 1906, 2321, 1906, 752, 1906, 1906, 2355, 1906, - /* 2760 */ 1906, 1906, 2373, 1906, 1906, 1906, 1906, 1906, 1906, 1906, - /* 2770 */ 1906, 753, 1906, 1906, 2321, 1906, 752, 1906, 1906, 2373, - /* 2780 */ 1906, 1906, 1906, 1906, 1906, 1906, 1906, 1906, 1906, 1906, - /* 2790 */ 1906, 2321, 1906, 752, 2354, 1906, 2355, 2392, 1906, 2373, - /* 2800 */ 377, 2356, 756, 2358, 2359, 751, 1906, 746, 1906, 753, - /* 2810 */ 1906, 2321, 1906, 752, 1906, 2354, 1906, 1906, 2392, 1906, - /* 2820 */ 1906, 378, 2356, 756, 2358, 2359, 751, 1906, 746, 1906, - /* 2830 */ 1906, 1906, 2354, 2355, 1906, 2392, 1906, 2373, 374, 2356, - /* 2840 */ 756, 2358, 2359, 751, 1906, 746, 753, 1906, 1906, 2321, - /* 2850 */ 1906, 752, 2354, 1906, 1906, 2392, 1906, 1906, 379, 2356, - /* 2860 */ 756, 2358, 2359, 751, 1906, 746, 1906, 1906, 1906, 1906, - /* 2870 */ 1906, 1906, 1906, 1906, 2373, 1906, 1906, 1906, 1906, 1906, - /* 2880 */ 1906, 1906, 1906, 1906, 1906, 1906, 2321, 1906, 752, 1906, - /* 2890 */ 754, 1906, 1906, 2392, 1906, 1906, 352, 2356, 756, 2358, - /* 2900 */ 2359, 751, 1906, 746, 1906, 1906, 1906, 1906, 1906, 1906, - /* 2910 */ 1906, 1906, 1906, 1906, 1906, 1906, 1906, 1906, 1906, 1906, - /* 2920 */ 1906, 1906, 1906, 1906, 1906, 1906, 1906, 2354, 1906, 1906, - /* 2930 */ 2392, 1906, 1906, 351, 2356, 756, 2358, 2359, 751, 1906, - /* 2940 */ 746, + /* 0 */ 95, 2332, 567, 2151, 468, 568, 1951, 14, 13, 467, + /* 10 */ 2185, 2315, 48, 46, 1826, 2340, 2532, 387, 723, 2527, + /* 20 */ 419, 699, 1667, 41, 40, 2336, 2093, 47, 45, 44, + /* 30 */ 43, 42, 174, 647, 1920, 1752, 1994, 1665, 2531, 737, + /* 40 */ 2098, 704, 2528, 2530, 2527, 2356, 38, 321, 645, 584, + /* 50 */ 643, 270, 269, 1696, 675, 716, 146, 2527, 719, 137, + /* 60 */ 112, 675, 703, 203, 2527, 1747, 610, 2528, 705, 2338, + /* 70 */ 416, 19, 739, 2236, 2418, 2533, 203, 147, 1673, 747, + /* 80 */ 2528, 705, 2533, 203, 2236, 2090, 2374, 2528, 705, 41, + /* 90 */ 40, 2234, 724, 47, 45, 44, 43, 42, 2322, 412, + /* 100 */ 753, 587, 2233, 724, 848, 585, 2229, 15, 475, 823, + /* 110 */ 822, 821, 820, 431, 1795, 819, 818, 151, 813, 812, + /* 120 */ 811, 810, 809, 808, 807, 150, 801, 800, 799, 430, + /* 130 */ 429, 796, 795, 794, 183, 182, 793, 2074, 1322, 2355, + /* 140 */ 1321, 63, 2393, 1754, 1755, 114, 2357, 757, 2359, 2360, + /* 150 */ 752, 1692, 747, 534, 532, 142, 367, 186, 575, 2446, + /* 160 */ 217, 568, 1951, 415, 2442, 301, 2454, 715, 572, 138, + /* 170 */ 714, 511, 2527, 1323, 569, 510, 184, 2151, 205, 2532, + /* 180 */ 1727, 1737, 2527, 509, 383, 736, 2476, 1753, 1756, 1870, + /* 190 */ 703, 203, 2149, 716, 146, 2528, 705, 1908, 385, 52, + /* 200 */ 2216, 2531, 1668, 63, 1666, 2528, 2529, 792, 196, 1901, + /* 210 */ 1692, 41, 40, 2145, 2146, 47, 45, 44, 43, 42, + /* 220 */ 2138, 136, 135, 134, 133, 132, 131, 130, 129, 128, + /* 230 */ 736, 484, 2212, 528, 1671, 1672, 1724, 1724, 1726, 1729, + /* 240 */ 1730, 1731, 1732, 1733, 1734, 1735, 1736, 749, 745, 1745, + /* 250 */ 1746, 1748, 1749, 1750, 1751, 2, 48, 46, 1325, 1326, + /* 260 */ 1693, 365, 704, 1690, 419, 2527, 1667, 428, 427, 1697, + /* 270 */ 518, 238, 2356, 537, 377, 570, 658, 1959, 536, 1752, + /* 280 */ 219, 1665, 223, 703, 203, 751, 273, 240, 2528, 705, + /* 290 */ 272, 570, 1674, 1959, 498, 228, 538, 466, 1696, 465, + /* 300 */ 698, 366, 500, 202, 2454, 2455, 305, 144, 2459, 1747, + /* 310 */ 1931, 659, 478, 2374, 1900, 19, 1460, 51, 1781, 527, + /* 320 */ 227, 452, 1673, 90, 274, 2322, 89, 753, 2374, 464, + /* 330 */ 1451, 782, 781, 780, 1455, 779, 1457, 1458, 778, 775, + /* 340 */ 583, 1466, 772, 1468, 1469, 769, 766, 763, 848, 386, + /* 350 */ 1693, 15, 790, 161, 160, 787, 786, 785, 158, 98, + /* 360 */ 486, 1997, 372, 2322, 305, 398, 2355, 649, 305, 2393, + /* 370 */ 1566, 1567, 357, 2357, 757, 2359, 2360, 752, 750, 747, + /* 380 */ 738, 2411, 1782, 1586, 1587, 577, 2275, 1754, 1755, 697, + /* 390 */ 2223, 2202, 88, 525, 524, 523, 522, 517, 516, 515, + /* 400 */ 514, 369, 1635, 1636, 1930, 504, 503, 502, 501, 495, + /* 410 */ 494, 493, 2532, 488, 487, 384, 184, 737, 2098, 479, + /* 420 */ 1554, 1555, 716, 146, 1727, 1737, 1573, 1585, 1588, 1695, + /* 430 */ 2461, 1753, 1756, 1695, 629, 628, 627, 137, 716, 146, + /* 440 */ 2217, 619, 143, 623, 615, 1305, 1668, 622, 1666, 456, + /* 450 */ 1696, 1691, 621, 626, 393, 392, 2458, 2322, 620, 1677, + /* 460 */ 194, 616, 37, 417, 1776, 1777, 1778, 1779, 1780, 1784, + /* 470 */ 1785, 1786, 1787, 1495, 1496, 792, 458, 454, 1671, 1672, + /* 480 */ 1724, 744, 1726, 1729, 1730, 1731, 1732, 1733, 1734, 1735, + /* 490 */ 1736, 749, 745, 1745, 1746, 1748, 1749, 1750, 1751, 2, + /* 500 */ 12, 48, 46, 2356, 1322, 2332, 1321, 736, 2531, 419, + /* 510 */ 2075, 1667, 422, 1823, 1697, 256, 754, 1894, 424, 2089, + /* 520 */ 168, 2144, 2146, 2151, 1752, 1929, 1665, 400, 2100, 2336, + /* 530 */ 399, 179, 204, 2454, 2455, 2149, 144, 2459, 2149, 1323, + /* 540 */ 604, 600, 596, 592, 2374, 255, 106, 718, 201, 2454, + /* 550 */ 2455, 1303, 144, 2459, 1747, 12, 2322, 2151, 753, 656, + /* 560 */ 19, 629, 628, 627, 409, 3, 694, 1673, 619, 143, + /* 570 */ 623, 2091, 2149, 2338, 622, 1301, 1302, 54, 2322, 621, + /* 580 */ 626, 393, 392, 747, 1859, 620, 96, 1692, 616, 253, + /* 590 */ 12, 303, 10, 848, 51, 303, 15, 2355, 737, 2098, + /* 600 */ 2393, 2356, 95, 114, 2357, 757, 2359, 2360, 752, 741, + /* 610 */ 747, 2418, 198, 149, 754, 156, 2417, 2446, 492, 41, + /* 620 */ 40, 415, 2442, 47, 45, 44, 43, 42, 2094, 2332, + /* 630 */ 1415, 1696, 1754, 1755, 691, 690, 1857, 1858, 1860, 1861, + /* 640 */ 1862, 1928, 2374, 2341, 1773, 1414, 790, 161, 160, 787, + /* 650 */ 786, 785, 158, 2336, 2322, 243, 753, 1909, 700, 695, + /* 660 */ 688, 684, 490, 2212, 252, 245, 1697, 520, 2212, 1727, + /* 670 */ 1737, 250, 581, 1927, 63, 659, 1753, 1756, 127, 68, + /* 680 */ 2303, 126, 125, 124, 123, 122, 121, 120, 119, 118, + /* 690 */ 242, 1668, 173, 1666, 2322, 2355, 806, 2338, 2393, 2059, + /* 700 */ 2037, 114, 2357, 757, 2359, 2360, 752, 747, 747, 564, + /* 710 */ 1926, 221, 539, 2421, 2316, 2446, 226, 1673, 562, 415, + /* 720 */ 2442, 558, 554, 1671, 1672, 1724, 2322, 1726, 1729, 1730, + /* 730 */ 1731, 1732, 1733, 1734, 1735, 1736, 749, 745, 1745, 1746, + /* 740 */ 1748, 1749, 1750, 1751, 2, 48, 46, 1757, 2356, 661, + /* 750 */ 2275, 737, 2098, 419, 2284, 1667, 654, 312, 313, 305, + /* 760 */ 159, 719, 311, 2322, 675, 1936, 843, 2527, 1752, 127, + /* 770 */ 1665, 208, 126, 125, 124, 123, 122, 121, 120, 119, + /* 780 */ 118, 2356, 63, 1822, 413, 2533, 203, 737, 2098, 2374, + /* 790 */ 2528, 705, 171, 199, 754, 2151, 1961, 326, 1747, 707, + /* 800 */ 2100, 2322, 414, 753, 737, 2098, 675, 56, 275, 2527, + /* 810 */ 2149, 1673, 41, 40, 2151, 422, 47, 45, 44, 43, + /* 820 */ 42, 423, 2374, 171, 472, 606, 605, 2533, 203, 2149, + /* 830 */ 425, 2100, 2528, 705, 2322, 55, 753, 848, 171, 305, + /* 840 */ 49, 9, 2355, 737, 2098, 2393, 2100, 1697, 114, 2357, + /* 850 */ 757, 2359, 2360, 752, 1925, 747, 2356, 1924, 783, 1667, + /* 860 */ 186, 1296, 2446, 473, 171, 1923, 415, 2442, 2461, 754, + /* 870 */ 737, 2098, 2101, 1922, 1665, 2355, 1754, 1755, 2393, 2073, + /* 880 */ 1303, 114, 2357, 757, 2359, 2360, 752, 1919, 747, 2477, + /* 890 */ 505, 636, 1830, 2547, 2457, 2446, 1762, 2374, 1692, 415, + /* 900 */ 2442, 197, 1692, 1298, 1301, 1302, 648, 2322, 210, 2322, + /* 910 */ 2322, 753, 1842, 1727, 1737, 1673, 737, 2098, 2322, 2306, + /* 920 */ 1753, 1756, 271, 41, 40, 1692, 2322, 47, 45, 44, + /* 930 */ 43, 42, 44, 43, 42, 1668, 506, 1666, 639, 1851, + /* 940 */ 2322, 848, 674, 625, 624, 633, 631, 305, 30, 2151, + /* 950 */ 2355, 1403, 268, 2393, 1852, 660, 176, 2357, 757, 2359, + /* 960 */ 2360, 752, 2087, 747, 732, 608, 607, 1671, 1672, 1724, + /* 970 */ 441, 1726, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, + /* 980 */ 749, 745, 1745, 1746, 1748, 1749, 1750, 1751, 2, 48, + /* 990 */ 46, 2083, 1405, 72, 1918, 1850, 71, 419, 1917, 1667, + /* 1000 */ 47, 45, 44, 43, 42, 675, 1916, 1915, 2527, 2085, + /* 1010 */ 706, 2548, 1752, 2151, 1665, 790, 161, 160, 787, 786, + /* 1020 */ 785, 158, 1914, 1871, 1913, 2356, 2533, 203, 2150, 41, + /* 1030 */ 40, 2528, 705, 47, 45, 44, 43, 42, 754, 1668, + /* 1040 */ 2484, 1666, 1747, 1783, 737, 2098, 1692, 2322, 2356, 737, + /* 1050 */ 2098, 2322, 1419, 737, 2098, 1673, 737, 2098, 1728, 2322, + /* 1060 */ 2322, 754, 1728, 2497, 507, 148, 2374, 1418, 2417, 586, + /* 1070 */ 1815, 1671, 1672, 2095, 61, 2322, 276, 2322, 2322, 76, + /* 1080 */ 753, 848, 672, 2356, 49, 1728, 614, 41, 40, 2374, + /* 1090 */ 613, 47, 45, 44, 43, 42, 754, 708, 686, 34, + /* 1100 */ 2169, 2322, 2081, 753, 784, 41, 40, 2142, 1912, 47, + /* 1110 */ 45, 44, 43, 42, 1725, 737, 2098, 803, 1725, 2355, + /* 1120 */ 1754, 1755, 2393, 35, 2374, 114, 2357, 757, 2359, 2360, + /* 1130 */ 752, 87, 747, 1788, 541, 284, 2322, 2547, 753, 2446, + /* 1140 */ 711, 1725, 2355, 415, 2442, 2393, 1981, 99, 114, 2357, + /* 1150 */ 757, 2359, 2360, 752, 2195, 747, 1911, 1727, 1737, 1676, + /* 1160 */ 2547, 2322, 2446, 1675, 1753, 1756, 415, 2442, 630, 737, + /* 1170 */ 2098, 737, 2098, 788, 737, 2098, 2142, 2355, 1614, 1668, + /* 1180 */ 2393, 1666, 805, 114, 2357, 757, 2359, 2360, 752, 322, + /* 1190 */ 747, 722, 720, 36, 316, 2547, 482, 2446, 139, 41, + /* 1200 */ 40, 415, 2442, 47, 45, 44, 43, 42, 2102, 2322, + /* 1210 */ 86, 1671, 1672, 1724, 281, 1726, 1729, 1730, 1731, 1732, + /* 1220 */ 1733, 1734, 1735, 1736, 749, 745, 1745, 1746, 1748, 1749, + /* 1230 */ 1750, 1751, 2, 48, 46, 391, 390, 737, 2098, 2461, + /* 1240 */ 2076, 419, 675, 1667, 159, 2527, 737, 2098, 817, 815, + /* 1250 */ 737, 2098, 789, 2466, 1815, 2142, 1752, 734, 1665, 513, + /* 1260 */ 512, 170, 1725, 2533, 203, 2456, 735, 159, 2528, 705, + /* 1270 */ 426, 335, 261, 152, 2128, 259, 2356, 263, 265, 617, + /* 1280 */ 262, 264, 267, 1979, 1970, 266, 1747, 618, 682, 754, + /* 1290 */ 1968, 2520, 651, 285, 650, 2343, 50, 50, 1921, 1673, + /* 1300 */ 1903, 1904, 748, 1400, 1358, 632, 634, 389, 388, 187, + /* 1310 */ 612, 1398, 637, 14, 13, 2038, 2490, 2374, 172, 1630, + /* 1320 */ 298, 159, 50, 341, 310, 848, 1679, 797, 15, 2322, + /* 1330 */ 1678, 753, 614, 692, 2356, 75, 613, 100, 292, 157, + /* 1340 */ 339, 74, 1633, 159, 73, 1359, 66, 754, 141, 2465, + /* 1350 */ 111, 1377, 50, 2345, 368, 50, 2375, 761, 157, 108, + /* 1360 */ 709, 798, 2035, 1846, 1754, 1755, 236, 549, 547, 544, + /* 1370 */ 2355, 1856, 1855, 2393, 159, 2374, 114, 2357, 757, 2359, + /* 1380 */ 2360, 752, 2034, 747, 290, 1375, 2221, 2322, 2547, 753, + /* 1390 */ 2446, 1962, 1952, 2480, 415, 2442, 721, 1583, 689, 314, + /* 1400 */ 405, 1727, 1737, 140, 157, 712, 696, 63, 1753, 1756, + /* 1410 */ 729, 401, 432, 2222, 318, 1958, 2139, 2481, 1445, 726, + /* 1420 */ 2491, 1789, 668, 1668, 717, 1666, 300, 1738, 2355, 297, + /* 1430 */ 334, 2393, 1473, 1477, 114, 2357, 757, 2359, 2360, 752, + /* 1440 */ 2060, 747, 304, 841, 5, 64, 2547, 435, 2446, 1484, + /* 1450 */ 440, 381, 415, 2442, 448, 1671, 1672, 1724, 449, 1726, + /* 1460 */ 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 749, 745, + /* 1470 */ 1745, 1746, 1748, 1749, 1750, 1751, 2, 1700, 1482, 162, + /* 1480 */ 460, 428, 427, 211, 2356, 459, 212, 462, 214, 329, + /* 1490 */ 1690, 1681, 1607, 476, 84, 83, 471, 754, 1691, 216, + /* 1500 */ 483, 225, 485, 489, 1752, 491, 1674, 2356, 530, 496, + /* 1510 */ 508, 2214, 463, 461, 519, 521, 526, 543, 529, 531, + /* 1520 */ 754, 542, 540, 364, 231, 2374, 450, 230, 545, 447, + /* 1530 */ 443, 439, 436, 464, 1747, 1698, 1906, 2322, 546, 753, + /* 1540 */ 233, 548, 2356, 550, 4, 565, 566, 1673, 2374, 573, + /* 1550 */ 574, 576, 1693, 241, 92, 754, 244, 578, 1699, 1701, + /* 1560 */ 2322, 579, 753, 580, 247, 582, 1702, 249, 588, 93, + /* 1570 */ 94, 609, 305, 743, 2230, 254, 640, 611, 2355, 2088, + /* 1580 */ 116, 2393, 641, 2374, 114, 2357, 757, 2359, 2360, 752, + /* 1590 */ 361, 747, 97, 258, 2084, 2322, 2419, 753, 2446, 260, + /* 1600 */ 164, 2355, 415, 2442, 2393, 165, 653, 114, 2357, 757, + /* 1610 */ 2359, 2360, 752, 2086, 747, 434, 2293, 2082, 166, 740, + /* 1620 */ 433, 2446, 167, 2290, 2289, 415, 2442, 277, 1694, 663, + /* 1630 */ 662, 282, 693, 667, 669, 670, 2355, 679, 727, 2393, + /* 1640 */ 664, 2356, 115, 2357, 757, 2359, 2360, 752, 8, 747, + /* 1650 */ 330, 153, 655, 280, 754, 2496, 2446, 287, 289, 702, + /* 1660 */ 2445, 2442, 2495, 677, 2468, 675, 291, 2276, 2527, 680, + /* 1670 */ 293, 1682, 2356, 1677, 678, 296, 713, 406, 710, 1815, + /* 1680 */ 1695, 2526, 2374, 145, 1820, 754, 2533, 203, 2462, 190, + /* 1690 */ 1818, 2528, 705, 306, 2322, 331, 753, 332, 730, 2356, + /* 1700 */ 154, 725, 294, 1685, 1687, 2244, 2243, 731, 2242, 155, + /* 1710 */ 411, 178, 754, 2374, 333, 105, 62, 745, 1745, 1746, + /* 1720 */ 1748, 1749, 1750, 1751, 295, 2322, 2099, 753, 1, 206, + /* 1730 */ 2427, 107, 759, 299, 336, 2355, 324, 2143, 2393, 1280, + /* 1740 */ 2374, 115, 2357, 757, 2359, 2360, 752, 842, 747, 2550, + /* 1750 */ 845, 847, 2322, 163, 753, 2446, 345, 2356, 360, 742, + /* 1760 */ 2442, 373, 53, 374, 359, 340, 755, 349, 2314, 2393, + /* 1770 */ 754, 338, 115, 2357, 757, 2359, 2360, 752, 2313, 747, + /* 1780 */ 2312, 81, 2307, 437, 438, 1658, 2446, 1659, 209, 442, + /* 1790 */ 376, 2442, 2356, 2355, 2305, 444, 2393, 445, 2374, 175, + /* 1800 */ 2357, 757, 2359, 2360, 752, 754, 747, 446, 1657, 2304, + /* 1810 */ 2322, 382, 753, 2302, 451, 2301, 453, 2300, 455, 2299, + /* 1820 */ 457, 1646, 2356, 213, 2279, 215, 1610, 82, 1609, 2257, + /* 1830 */ 2256, 2255, 469, 2374, 2280, 754, 470, 2254, 2253, 2204, + /* 1840 */ 474, 676, 2487, 2201, 1553, 2322, 2200, 753, 477, 2194, + /* 1850 */ 481, 2355, 2191, 480, 2393, 218, 2190, 115, 2357, 757, + /* 1860 */ 2359, 2360, 752, 2374, 747, 85, 2189, 2188, 403, 2193, + /* 1870 */ 220, 2446, 2192, 2187, 2186, 2322, 2443, 753, 2184, 2183, + /* 1880 */ 2182, 222, 497, 2181, 499, 2179, 2355, 2356, 2178, 2393, + /* 1890 */ 2177, 2176, 175, 2357, 757, 2359, 2360, 752, 91, 747, + /* 1900 */ 754, 2199, 2356, 2175, 2174, 2173, 2197, 2180, 2172, 2171, + /* 1910 */ 2170, 2168, 2167, 2166, 2165, 754, 2355, 2356, 1559, 2393, + /* 1920 */ 2164, 2163, 358, 2357, 757, 2359, 2360, 752, 2374, 747, + /* 1930 */ 754, 224, 2162, 404, 229, 2488, 2161, 2160, 2159, 2198, + /* 1940 */ 2322, 2196, 753, 2374, 2158, 2157, 2156, 2155, 533, 2154, + /* 1950 */ 535, 2153, 2152, 1416, 2000, 2322, 1412, 753, 2374, 232, + /* 1960 */ 1999, 1998, 1420, 1996, 234, 370, 371, 235, 1993, 553, + /* 1970 */ 2322, 1992, 753, 552, 556, 557, 1985, 560, 1972, 551, + /* 1980 */ 555, 2355, 1947, 185, 2393, 559, 1304, 358, 2357, 757, + /* 1990 */ 2359, 2360, 752, 563, 747, 561, 2355, 2356, 1946, 2393, + /* 2000 */ 237, 78, 351, 2357, 757, 2359, 2360, 752, 239, 747, + /* 2010 */ 754, 2355, 79, 2342, 2393, 2356, 195, 176, 2357, 757, + /* 2020 */ 2359, 2360, 752, 571, 747, 2278, 2274, 2264, 751, 246, + /* 2030 */ 2251, 2228, 248, 251, 2077, 1995, 1991, 589, 2374, 2252, + /* 2040 */ 2356, 1351, 1989, 410, 590, 591, 593, 594, 701, 595, + /* 2050 */ 2322, 1987, 753, 754, 597, 598, 2374, 599, 1984, 601, + /* 2060 */ 603, 602, 1967, 1965, 1966, 1964, 1943, 2079, 2322, 1489, + /* 2070 */ 753, 2078, 2549, 65, 1488, 257, 1388, 1402, 1401, 1982, + /* 2080 */ 1399, 2374, 1397, 1396, 1395, 1394, 418, 1393, 814, 816, + /* 2090 */ 1390, 2355, 394, 2322, 2393, 753, 1389, 358, 2357, 757, + /* 2100 */ 2359, 2360, 752, 1980, 747, 1387, 395, 1971, 396, 2355, + /* 2110 */ 2356, 1969, 2393, 635, 657, 357, 2357, 757, 2359, 2360, + /* 2120 */ 752, 397, 747, 754, 2412, 638, 1942, 1941, 1940, 642, + /* 2130 */ 1939, 644, 851, 1938, 2355, 117, 646, 2393, 1640, 1642, + /* 2140 */ 358, 2357, 757, 2359, 2360, 752, 2356, 747, 328, 1639, + /* 2150 */ 2277, 2374, 1644, 279, 2273, 57, 420, 58, 1616, 754, + /* 2160 */ 1618, 2263, 665, 2322, 193, 753, 1620, 666, 29, 2250, + /* 2170 */ 2249, 169, 1595, 839, 835, 831, 827, 2356, 325, 69, + /* 2180 */ 283, 671, 2532, 1594, 20, 31, 673, 2374, 1873, 286, + /* 2190 */ 754, 1847, 681, 402, 17, 6, 683, 7, 685, 2322, + /* 2200 */ 687, 753, 200, 288, 2355, 21, 22, 2393, 1854, 189, + /* 2210 */ 358, 2357, 757, 2359, 2360, 752, 177, 747, 2374, 113, + /* 2220 */ 2343, 33, 319, 188, 32, 67, 1841, 80, 24, 1888, + /* 2230 */ 2322, 1893, 753, 1894, 1887, 407, 1892, 1891, 408, 1812, + /* 2240 */ 652, 60, 1811, 2393, 2248, 302, 353, 2357, 757, 2359, + /* 2250 */ 2360, 752, 2356, 747, 733, 180, 23, 18, 59, 2227, + /* 2260 */ 102, 728, 2226, 103, 101, 754, 25, 26, 108, 317, + /* 2270 */ 309, 2355, 2356, 1849, 2393, 191, 320, 343, 2357, 757, + /* 2280 */ 2359, 2360, 752, 1764, 747, 754, 1763, 315, 2356, 70, + /* 2290 */ 104, 1683, 13, 2374, 11, 1742, 2396, 308, 746, 181, + /* 2300 */ 39, 754, 1740, 1774, 307, 2322, 192, 753, 1717, 323, + /* 2310 */ 1739, 16, 27, 2374, 756, 1709, 28, 760, 1474, 421, + /* 2320 */ 758, 762, 764, 278, 1471, 2322, 765, 753, 1470, 2374, + /* 2330 */ 767, 768, 770, 1467, 1461, 771, 773, 774, 776, 1459, + /* 2340 */ 777, 2322, 1483, 753, 109, 2356, 2355, 110, 77, 2393, + /* 2350 */ 1479, 1465, 342, 2357, 757, 2359, 2360, 752, 754, 747, + /* 2360 */ 1464, 1384, 791, 1463, 1462, 2356, 2355, 1381, 1349, 2393, + /* 2370 */ 1380, 1379, 344, 2357, 757, 2359, 2360, 752, 754, 747, + /* 2380 */ 1378, 1376, 2355, 2356, 1374, 2393, 2374, 1373, 350, 2357, + /* 2390 */ 757, 2359, 2360, 752, 1372, 747, 754, 1410, 2322, 802, + /* 2400 */ 753, 1409, 207, 2356, 804, 1370, 2374, 1369, 1368, 1367, + /* 2410 */ 1366, 1365, 1364, 1406, 1404, 1361, 754, 1360, 2322, 1357, + /* 2420 */ 753, 1355, 1356, 1354, 2374, 1990, 824, 825, 1988, 828, + /* 2430 */ 826, 1986, 829, 830, 832, 834, 2322, 1983, 753, 2355, + /* 2440 */ 836, 2356, 2393, 838, 2374, 354, 2357, 757, 2359, 2360, + /* 2450 */ 752, 833, 747, 837, 754, 1963, 2322, 840, 753, 2355, + /* 2460 */ 1293, 1937, 2393, 1281, 846, 346, 2357, 757, 2359, 2360, + /* 2470 */ 752, 844, 747, 327, 1669, 337, 850, 2355, 2356, 849, + /* 2480 */ 2393, 1907, 2374, 355, 2357, 757, 2359, 2360, 752, 1907, + /* 2490 */ 747, 754, 1907, 1907, 2322, 1907, 753, 2355, 2356, 1907, + /* 2500 */ 2393, 1907, 1907, 347, 2357, 757, 2359, 2360, 752, 1907, + /* 2510 */ 747, 754, 1907, 1907, 2356, 1907, 1907, 1907, 1907, 2374, + /* 2520 */ 1907, 1907, 1907, 1907, 1907, 1907, 1907, 754, 1907, 1907, + /* 2530 */ 1907, 2322, 1907, 753, 1907, 2355, 1907, 1907, 2393, 2374, + /* 2540 */ 1907, 356, 2357, 757, 2359, 2360, 752, 1907, 747, 1907, + /* 2550 */ 1907, 2322, 1907, 753, 1907, 2374, 1907, 1907, 1907, 1907, + /* 2560 */ 1907, 1907, 1907, 1907, 1907, 1907, 1907, 2322, 1907, 753, + /* 2570 */ 1907, 1907, 2355, 1907, 1907, 2393, 1907, 1907, 348, 2357, + /* 2580 */ 757, 2359, 2360, 752, 1907, 747, 1907, 1907, 1907, 1907, + /* 2590 */ 1907, 1907, 2355, 1907, 1907, 2393, 1907, 1907, 362, 2357, + /* 2600 */ 757, 2359, 2360, 752, 1907, 747, 1907, 2356, 2355, 1907, + /* 2610 */ 1907, 2393, 1907, 1907, 363, 2357, 757, 2359, 2360, 752, + /* 2620 */ 754, 747, 1907, 1907, 1907, 1907, 2356, 1907, 1907, 1907, + /* 2630 */ 1907, 1907, 1907, 1907, 1907, 1907, 1907, 1907, 1907, 754, + /* 2640 */ 1907, 1907, 1907, 2356, 1907, 1907, 1907, 1907, 2374, 1907, + /* 2650 */ 1907, 1907, 1907, 1907, 1907, 1907, 754, 1907, 1907, 1907, + /* 2660 */ 2322, 1907, 753, 1907, 1907, 1907, 1907, 2374, 1907, 1907, + /* 2670 */ 1907, 1907, 1907, 1907, 1907, 1907, 1907, 1907, 1907, 2322, + /* 2680 */ 1907, 753, 1907, 1907, 2374, 1907, 1907, 1907, 1907, 1907, + /* 2690 */ 1907, 1907, 1907, 1907, 1907, 1907, 2322, 1907, 753, 1907, + /* 2700 */ 2356, 2355, 1907, 1907, 2393, 1907, 1907, 2368, 2357, 757, + /* 2710 */ 2359, 2360, 752, 754, 747, 1907, 1907, 1907, 1907, 1907, + /* 2720 */ 2355, 2356, 1907, 2393, 1907, 1907, 2367, 2357, 757, 2359, + /* 2730 */ 2360, 752, 1907, 747, 754, 1907, 1907, 2355, 2356, 1907, + /* 2740 */ 2393, 2374, 1907, 2366, 2357, 757, 2359, 2360, 752, 1907, + /* 2750 */ 747, 754, 1907, 2322, 1907, 753, 1907, 1907, 2356, 1907, + /* 2760 */ 1907, 1907, 2374, 1907, 1907, 1907, 1907, 1907, 1907, 1907, + /* 2770 */ 1907, 754, 1907, 1907, 2322, 1907, 753, 1907, 1907, 2374, + /* 2780 */ 1907, 1907, 1907, 1907, 1907, 1907, 1907, 1907, 1907, 1907, + /* 2790 */ 1907, 2322, 1907, 753, 2355, 1907, 2356, 2393, 1907, 2374, + /* 2800 */ 378, 2357, 757, 2359, 2360, 752, 1907, 747, 1907, 754, + /* 2810 */ 1907, 2322, 1907, 753, 1907, 2355, 1907, 1907, 2393, 1907, + /* 2820 */ 1907, 379, 2357, 757, 2359, 2360, 752, 1907, 747, 1907, + /* 2830 */ 1907, 1907, 2355, 2356, 1907, 2393, 1907, 2374, 375, 2357, + /* 2840 */ 757, 2359, 2360, 752, 1907, 747, 754, 1907, 1907, 2322, + /* 2850 */ 1907, 753, 2355, 1907, 1907, 2393, 1907, 1907, 380, 2357, + /* 2860 */ 757, 2359, 2360, 752, 1907, 747, 1907, 1907, 1907, 1907, + /* 2870 */ 1907, 1907, 1907, 1907, 2374, 1907, 1907, 1907, 1907, 1907, + /* 2880 */ 1907, 1907, 1907, 1907, 1907, 1907, 2322, 1907, 753, 1907, + /* 2890 */ 755, 1907, 1907, 2393, 1907, 1907, 353, 2357, 757, 2359, + /* 2900 */ 2360, 752, 1907, 747, 1907, 1907, 1907, 1907, 1907, 1907, + /* 2910 */ 1907, 1907, 1907, 1907, 1907, 1907, 1907, 1907, 1907, 1907, + /* 2920 */ 1907, 1907, 1907, 1907, 1907, 1907, 1907, 2355, 1907, 1907, + /* 2930 */ 2393, 1907, 1907, 352, 2357, 757, 2359, 2360, 752, 1907, + /* 2940 */ 747, }; static const YYCODETYPE yy_lookahead[] = { /* 0 */ 375, 383, 361, 395, 430, 364, 365, 1, 2, 435, @@ -1019,103 +1019,103 @@ static const YYCODETYPE yy_lookahead[] = { /* 1480 */ 442, 12, 13, 447, 354, 217, 375, 442, 375, 433, /* 1490 */ 20, 22, 200, 366, 194, 195, 196, 367, 20, 199, /* 1500 */ 367, 45, 416, 367, 35, 416, 37, 354, 179, 413, - /* 1510 */ 366, 366, 212, 213, 367, 416, 413, 379, 413, 105, - /* 1520 */ 367, 103, 366, 223, 102, 395, 226, 378, 377, 229, - /* 1530 */ 230, 231, 232, 233, 65, 20, 351, 407, 359, 409, - /* 1540 */ 366, 366, 354, 366, 50, 363, 359, 78, 395, 363, - /* 1550 */ 442, 375, 20, 375, 20, 367, 375, 409, 368, 20, - /* 1560 */ 407, 432, 409, 368, 375, 20, 423, 375, 375, 375, - /* 1570 */ 366, 359, 272, 104, 375, 395, 357, 357, 448, 395, - /* 1580 */ 366, 451, 221, 395, 454, 455, 456, 457, 458, 459, - /* 1590 */ 359, 461, 395, 395, 107, 407, 466, 409, 468, 444, - /* 1600 */ 395, 448, 472, 473, 451, 395, 446, 454, 455, 456, + /* 1510 */ 366, 366, 212, 213, 367, 416, 413, 379, 413, 413, + /* 1520 */ 367, 105, 103, 223, 366, 395, 226, 378, 102, 229, + /* 1530 */ 230, 231, 232, 233, 65, 20, 351, 407, 377, 409, + /* 1540 */ 366, 366, 354, 366, 50, 359, 363, 78, 395, 359, + /* 1550 */ 363, 442, 20, 375, 375, 367, 375, 409, 20, 20, + /* 1560 */ 407, 368, 409, 432, 375, 368, 20, 375, 366, 375, + /* 1570 */ 375, 359, 272, 104, 423, 375, 357, 395, 448, 395, + /* 1580 */ 366, 451, 357, 395, 454, 455, 456, 457, 458, 459, + /* 1590 */ 359, 461, 107, 395, 395, 407, 466, 409, 468, 395, + /* 1600 */ 395, 448, 472, 473, 451, 395, 221, 454, 455, 456, /* 1610 */ 457, 458, 459, 395, 461, 430, 407, 395, 395, 466, - /* 1620 */ 435, 468, 395, 407, 395, 472, 473, 373, 20, 208, - /* 1630 */ 207, 407, 373, 431, 409, 366, 448, 407, 438, 451, - /* 1640 */ 439, 354, 454, 455, 456, 457, 458, 459, 442, 461, - /* 1650 */ 283, 282, 491, 291, 367, 491, 468, 425, 441, 193, - /* 1660 */ 472, 473, 425, 276, 494, 480, 493, 293, 483, 292, - /* 1670 */ 431, 202, 354, 204, 491, 300, 297, 511, 295, 271, - /* 1680 */ 20, 117, 395, 367, 273, 367, 501, 502, 453, 368, - /* 1690 */ 373, 506, 507, 490, 407, 488, 409, 489, 425, 354, - /* 1700 */ 373, 486, 407, 234, 235, 407, 407, 425, 407, 185, - /* 1710 */ 407, 373, 367, 395, 421, 373, 367, 248, 249, 250, - /* 1720 */ 251, 252, 253, 254, 391, 407, 484, 409, 107, 471, - /* 1730 */ 107, 505, 366, 399, 22, 448, 373, 504, 451, 407, - /* 1740 */ 395, 454, 455, 456, 457, 458, 459, 38, 461, 356, - /* 1750 */ 360, 359, 407, 389, 409, 468, 426, 354, 443, 472, - /* 1760 */ 473, 426, 434, 374, 0, 389, 448, 389, 352, 451, - /* 1770 */ 367, 0, 454, 455, 456, 457, 458, 459, 0, 461, - /* 1780 */ 45, 0, 37, 227, 37, 37, 468, 37, 227, 0, - /* 1790 */ 472, 473, 354, 448, 37, 37, 451, 227, 395, 454, - /* 1800 */ 455, 456, 457, 458, 459, 367, 461, 37, 0, 227, - /* 1810 */ 407, 0, 409, 37, 0, 0, 37, 22, 0, 37, - /* 1820 */ 222, 0, 354, 210, 0, 210, 204, 211, 202, 0, - /* 1830 */ 0, 0, 198, 395, 197, 367, 0, 0, 148, 49, - /* 1840 */ 49, 496, 497, 0, 37, 407, 0, 409, 0, 37, - /* 1850 */ 51, 448, 0, 49, 451, 0, 0, 454, 455, 456, + /* 1620 */ 435, 468, 395, 407, 407, 472, 473, 373, 20, 208, + /* 1630 */ 207, 373, 283, 409, 431, 366, 448, 407, 282, 451, + /* 1640 */ 439, 354, 454, 455, 456, 457, 458, 459, 291, 461, + /* 1650 */ 442, 444, 446, 438, 367, 491, 468, 425, 425, 193, + /* 1660 */ 472, 473, 491, 276, 494, 480, 493, 441, 483, 293, + /* 1670 */ 490, 202, 354, 204, 292, 431, 297, 300, 295, 271, + /* 1680 */ 20, 505, 395, 367, 117, 367, 501, 502, 453, 368, + /* 1690 */ 273, 506, 507, 373, 407, 425, 409, 425, 185, 354, + /* 1700 */ 373, 407, 489, 234, 235, 407, 407, 421, 407, 373, + /* 1710 */ 407, 491, 367, 395, 391, 373, 107, 248, 249, 250, + /* 1720 */ 251, 252, 253, 254, 488, 407, 367, 409, 486, 484, + /* 1730 */ 471, 107, 399, 504, 366, 448, 373, 407, 451, 22, + /* 1740 */ 395, 454, 455, 456, 457, 458, 459, 38, 461, 511, + /* 1750 */ 356, 359, 407, 360, 409, 468, 389, 354, 443, 472, + /* 1760 */ 473, 426, 434, 426, 389, 352, 448, 389, 0, 451, + /* 1770 */ 367, 374, 454, 455, 456, 457, 458, 459, 0, 461, + /* 1780 */ 0, 45, 0, 37, 227, 37, 468, 37, 37, 227, + /* 1790 */ 472, 473, 354, 448, 0, 37, 451, 37, 395, 454, + /* 1800 */ 455, 456, 457, 458, 459, 367, 461, 227, 37, 0, + /* 1810 */ 407, 227, 409, 0, 37, 0, 37, 0, 22, 0, + /* 1820 */ 37, 222, 354, 210, 0, 210, 204, 211, 202, 0, + /* 1830 */ 0, 0, 198, 395, 0, 367, 197, 0, 0, 148, + /* 1840 */ 49, 496, 497, 0, 49, 407, 0, 409, 37, 0, + /* 1850 */ 51, 448, 0, 37, 451, 49, 0, 454, 455, 456, /* 1860 */ 457, 458, 459, 395, 461, 45, 0, 0, 400, 0, - /* 1870 */ 0, 468, 0, 0, 49, 407, 473, 409, 0, 0, - /* 1880 */ 165, 37, 0, 165, 0, 0, 448, 354, 0, 451, - /* 1890 */ 0, 0, 454, 455, 456, 457, 458, 459, 49, 461, + /* 1870 */ 49, 468, 0, 0, 0, 407, 473, 409, 0, 0, + /* 1880 */ 0, 165, 37, 0, 165, 0, 448, 354, 0, 451, + /* 1890 */ 0, 0, 454, 455, 456, 457, 458, 459, 45, 461, /* 1900 */ 367, 0, 354, 0, 0, 0, 0, 0, 0, 0, /* 1910 */ 0, 0, 0, 0, 0, 367, 448, 354, 22, 451, /* 1920 */ 0, 0, 454, 455, 456, 457, 458, 459, 395, 461, - /* 1930 */ 367, 45, 0, 400, 148, 497, 0, 0, 0, 0, - /* 1940 */ 407, 0, 409, 395, 0, 0, 0, 147, 0, 146, - /* 1950 */ 0, 0, 22, 22, 0, 407, 37, 409, 395, 65, - /* 1960 */ 0, 0, 65, 0, 65, 50, 50, 0, 51, 42, - /* 1970 */ 407, 0, 409, 51, 0, 42, 51, 37, 0, 37, - /* 1980 */ 37, 448, 0, 14, 451, 33, 37, 454, 455, 456, - /* 1990 */ 457, 458, 459, 0, 461, 42, 448, 354, 42, 451, - /* 2000 */ 45, 43, 454, 455, 456, 457, 458, 459, 49, 461, - /* 2010 */ 367, 448, 42, 49, 451, 354, 0, 454, 455, 456, - /* 2020 */ 457, 458, 459, 0, 461, 49, 0, 0, 367, 42, - /* 2030 */ 0, 193, 49, 0, 0, 0, 0, 72, 395, 37, - /* 2040 */ 354, 51, 42, 400, 0, 37, 51, 42, 500, 37, - /* 2050 */ 407, 0, 409, 367, 51, 42, 395, 0, 37, 42, - /* 2060 */ 51, 0, 0, 0, 0, 0, 0, 22, 407, 37, - /* 2070 */ 409, 0, 509, 33, 37, 37, 37, 115, 37, 113, - /* 2080 */ 37, 395, 22, 37, 37, 37, 400, 33, 0, 37, - /* 2090 */ 37, 448, 37, 407, 451, 409, 22, 454, 455, 456, - /* 2100 */ 457, 458, 459, 0, 461, 22, 0, 22, 0, 448, - /* 2110 */ 354, 53, 451, 22, 1, 454, 455, 456, 457, 458, - /* 2120 */ 459, 37, 461, 367, 463, 0, 0, 0, 0, 37, - /* 2130 */ 37, 0, 19, 22, 448, 20, 37, 451, 37, 37, - /* 2140 */ 454, 455, 456, 457, 458, 459, 354, 461, 35, 0, - /* 2150 */ 108, 395, 0, 49, 182, 37, 400, 107, 22, 367, - /* 2160 */ 22, 182, 0, 407, 51, 409, 107, 182, 0, 185, - /* 2170 */ 0, 182, 3, 60, 61, 62, 63, 354, 65, 182, - /* 2180 */ 205, 189, 209, 189, 33, 107, 107, 395, 108, 108, - /* 2190 */ 367, 37, 37, 107, 105, 50, 50, 103, 108, 407, - /* 2200 */ 277, 409, 49, 108, 448, 33, 33, 451, 108, 33, + /* 1930 */ 367, 49, 0, 400, 148, 497, 0, 0, 0, 0, + /* 1940 */ 407, 0, 409, 395, 0, 0, 0, 0, 147, 0, + /* 1950 */ 146, 0, 0, 22, 0, 407, 37, 409, 395, 65, + /* 1960 */ 0, 0, 22, 0, 65, 50, 50, 65, 0, 42, + /* 1970 */ 407, 0, 409, 51, 51, 42, 0, 51, 0, 37, + /* 1980 */ 37, 448, 0, 33, 451, 37, 14, 454, 455, 456, + /* 1990 */ 457, 458, 459, 37, 461, 42, 448, 354, 0, 451, + /* 2000 */ 45, 42, 454, 455, 456, 457, 458, 459, 43, 461, + /* 2010 */ 367, 448, 42, 49, 451, 354, 49, 454, 455, 456, + /* 2020 */ 457, 458, 459, 49, 461, 0, 0, 0, 367, 42, + /* 2030 */ 0, 0, 193, 49, 0, 0, 0, 37, 395, 0, + /* 2040 */ 354, 72, 0, 400, 51, 42, 37, 51, 500, 42, + /* 2050 */ 407, 0, 409, 367, 37, 51, 395, 42, 0, 37, + /* 2060 */ 42, 51, 0, 0, 0, 0, 0, 0, 407, 37, + /* 2070 */ 409, 0, 509, 115, 22, 113, 22, 37, 37, 0, + /* 2080 */ 37, 395, 37, 37, 37, 37, 400, 37, 33, 33, + /* 2090 */ 37, 448, 22, 407, 451, 409, 37, 454, 455, 456, + /* 2100 */ 457, 458, 459, 0, 461, 37, 22, 0, 22, 448, + /* 2110 */ 354, 0, 451, 53, 1, 454, 455, 456, 457, 458, + /* 2120 */ 459, 22, 461, 367, 463, 37, 0, 0, 0, 37, + /* 2130 */ 0, 37, 19, 0, 448, 20, 22, 451, 37, 37, + /* 2140 */ 454, 455, 456, 457, 458, 459, 354, 461, 35, 37, + /* 2150 */ 0, 395, 108, 49, 0, 182, 400, 182, 37, 367, + /* 2160 */ 22, 0, 22, 407, 51, 409, 209, 182, 107, 0, + /* 2170 */ 0, 205, 182, 60, 61, 62, 63, 354, 65, 107, + /* 2180 */ 185, 189, 3, 182, 33, 107, 189, 395, 108, 107, + /* 2190 */ 367, 108, 37, 37, 277, 50, 107, 50, 105, 407, + /* 2200 */ 103, 409, 49, 108, 448, 33, 33, 451, 108, 33, /* 2210 */ 454, 455, 456, 457, 458, 459, 107, 461, 395, 106, - /* 2220 */ 49, 107, 109, 107, 107, 33, 3, 108, 108, 33, - /* 2230 */ 407, 37, 409, 49, 277, 37, 37, 37, 37, 37, - /* 2240 */ 448, 108, 108, 451, 33, 277, 454, 455, 456, 457, - /* 2250 */ 458, 459, 354, 461, 141, 49, 270, 0, 0, 42, - /* 2260 */ 0, 186, 42, 107, 107, 367, 108, 108, 107, 33, - /* 2270 */ 107, 448, 354, 107, 451, 49, 257, 454, 455, 456, - /* 2280 */ 457, 458, 459, 116, 461, 367, 107, 105, 354, 184, - /* 2290 */ 105, 22, 2, 395, 107, 49, 108, 184, 107, 49, - /* 2300 */ 107, 367, 234, 108, 191, 407, 22, 409, 37, 237, - /* 2310 */ 37, 108, 107, 395, 107, 37, 108, 107, 37, 37, - /* 2320 */ 108, 117, 107, 210, 108, 407, 107, 409, 107, 395, - /* 2330 */ 108, 37, 108, 108, 107, 107, 37, 108, 107, 33, - /* 2340 */ 37, 407, 128, 409, 107, 354, 448, 107, 107, 451, - /* 2350 */ 22, 72, 454, 455, 456, 457, 458, 459, 367, 461, - /* 2360 */ 128, 128, 128, 71, 37, 354, 448, 37, 37, 451, + /* 2220 */ 49, 33, 109, 107, 107, 3, 108, 107, 33, 37, + /* 2230 */ 407, 108, 409, 108, 37, 37, 37, 37, 37, 108, + /* 2240 */ 448, 33, 108, 451, 0, 49, 454, 455, 456, 457, + /* 2250 */ 458, 459, 354, 461, 141, 49, 277, 277, 270, 0, + /* 2260 */ 42, 186, 0, 42, 107, 367, 107, 33, 116, 184, + /* 2270 */ 108, 448, 354, 108, 451, 107, 49, 454, 455, 456, + /* 2280 */ 457, 458, 459, 105, 461, 367, 105, 107, 354, 107, + /* 2290 */ 107, 22, 2, 395, 257, 108, 107, 184, 107, 49, + /* 2300 */ 107, 367, 108, 234, 191, 407, 49, 409, 22, 33, + /* 2310 */ 108, 107, 107, 395, 237, 108, 107, 37, 108, 37, + /* 2320 */ 117, 107, 37, 210, 108, 407, 107, 409, 108, 395, + /* 2330 */ 37, 107, 37, 108, 108, 107, 37, 107, 37, 108, + /* 2340 */ 107, 407, 37, 409, 107, 354, 448, 107, 107, 451, + /* 2350 */ 22, 128, 454, 455, 456, 457, 458, 459, 367, 461, + /* 2360 */ 128, 37, 71, 128, 128, 354, 448, 37, 72, 451, /* 2370 */ 37, 37, 454, 455, 456, 457, 458, 459, 367, 461, /* 2380 */ 37, 37, 448, 354, 37, 451, 395, 37, 454, 455, - /* 2390 */ 456, 457, 458, 459, 78, 461, 367, 101, 407, 78, - /* 2400 */ 409, 101, 33, 354, 22, 37, 395, 37, 37, 37, - /* 2410 */ 37, 37, 37, 78, 37, 37, 367, 37, 407, 22, - /* 2420 */ 409, 0, 37, 37, 395, 37, 0, 51, 37, 42, - /* 2430 */ 51, 42, 0, 37, 51, 42, 407, 0, 409, 448, - /* 2440 */ 37, 354, 451, 51, 395, 454, 455, 456, 457, 458, - /* 2450 */ 459, 42, 461, 0, 367, 37, 407, 37, 409, 448, - /* 2460 */ 0, 22, 451, 33, 21, 454, 455, 456, 457, 458, - /* 2470 */ 459, 22, 461, 22, 22, 21, 20, 448, 354, 512, + /* 2390 */ 456, 457, 458, 459, 37, 461, 367, 78, 407, 101, + /* 2400 */ 409, 78, 33, 354, 101, 37, 395, 37, 37, 22, + /* 2410 */ 37, 37, 37, 78, 37, 37, 367, 37, 407, 37, + /* 2420 */ 409, 22, 37, 37, 395, 0, 37, 51, 0, 37, + /* 2430 */ 42, 0, 51, 42, 37, 42, 407, 0, 409, 448, + /* 2440 */ 37, 354, 451, 42, 395, 454, 455, 456, 457, 458, + /* 2450 */ 459, 51, 461, 51, 367, 0, 407, 37, 409, 448, + /* 2460 */ 37, 0, 451, 22, 21, 454, 455, 456, 457, 458, + /* 2470 */ 459, 33, 461, 22, 22, 22, 20, 448, 354, 21, /* 2480 */ 451, 512, 395, 454, 455, 456, 457, 458, 459, 512, /* 2490 */ 461, 367, 512, 512, 407, 512, 409, 448, 354, 512, /* 2500 */ 451, 512, 512, 454, 455, 456, 457, 458, 459, 512, @@ -1199,9 +1199,9 @@ static const YYCODETYPE yy_lookahead[] = { /* 3280 */ 351, 351, 351, 351, 351, 351, 351, 351, 351, 351, /* 3290 */ 351, 351, }; -#define YY_SHIFT_COUNT (850) +#define YY_SHIFT_COUNT (851) #define YY_SHIFT_MIN (0) -#define YY_SHIFT_MAX (2460) +#define YY_SHIFT_MAX (2461) static const unsigned short int yy_shift_ofst[] = { /* 0 */ 1300, 0, 244, 0, 489, 489, 489, 489, 489, 489, /* 10 */ 489, 489, 489, 489, 489, 489, 733, 977, 977, 1221, @@ -1225,72 +1225,72 @@ static const unsigned short int yy_shift_ofst[] = { /* 190 */ 892, 917, 905, 484, 33, 431, 950, 972, 33, 33, /* 200 */ 1026, 983, 799, 505, 983, 532, 509, 1104, 1169, 1399, /* 210 */ 1412, 1457, 1268, 31, 1457, 31, 1292, 1470, 1478, 1456, - /* 220 */ 1478, 1456, 1329, 1470, 1478, 1470, 1456, 1329, 1329, 1414, - /* 230 */ 1418, 1470, 1422, 1470, 1470, 1470, 1515, 1494, 1515, 1494, - /* 240 */ 1457, 31, 31, 1532, 31, 1534, 1539, 31, 1534, 31, - /* 250 */ 1545, 31, 31, 1470, 31, 1515, 131, 131, 131, 131, - /* 260 */ 131, 131, 131, 131, 131, 131, 131, 1470, 763, 763, - /* 270 */ 1515, 639, 639, 639, 1361, 1487, 1457, 405, 1608, 1421, - /* 280 */ 1423, 1532, 405, 1169, 1470, 639, 1367, 1369, 1367, 1369, - /* 290 */ 1362, 1466, 1367, 1374, 1377, 1387, 1169, 1375, 1379, 1383, - /* 300 */ 1408, 1478, 1660, 1564, 1411, 1534, 405, 405, 1369, 639, - /* 310 */ 639, 639, 639, 1369, 639, 1524, 405, 741, 405, 1478, - /* 320 */ 1621, 1623, 639, 1470, 405, 1712, 1709, 1515, 2941, 2941, - /* 330 */ 2941, 2941, 2941, 2941, 2941, 2941, 2941, 36, 480, 197, - /* 340 */ 887, 915, 81, 804, 510, 1097, 1191, 1079, 879, 1021, - /* 350 */ 1021, 1021, 1021, 1021, 1021, 1021, 1021, 1021, 216, 148, - /* 360 */ 12, 988, 988, 252, 217, 10, 146, 658, 1100, 608, - /* 370 */ 1030, 187, 620, 620, 918, 6, 864, 918, 918, 918, - /* 380 */ 919, 680, 727, 1154, 1165, 962, 1240, 1162, 1167, 1168, - /* 390 */ 1172, 1266, 1274, 1146, 1283, 1284, 1290, 1074, 1211, 1234, - /* 400 */ 1228, 1255, 1263, 1264, 1276, 1157, 1064, 1107, 1288, 1289, - /* 410 */ 1291, 1302, 1306, 1310, 1312, 1313, 410, 1319, 1246, 1322, - /* 420 */ 1324, 1325, 1341, 1370, 1371, 1243, 1122, 1126, 1314, 1348, - /* 430 */ 1267, 1391, 1764, 1771, 1778, 1735, 1781, 1745, 1556, 1747, - /* 440 */ 1748, 1750, 1561, 1789, 1757, 1758, 1570, 1770, 1808, 1582, - /* 450 */ 1811, 1776, 1814, 1779, 1815, 1795, 1818, 1782, 1598, 1821, - /* 460 */ 1613, 1824, 1615, 1616, 1622, 1626, 1829, 1830, 1831, 1634, - /* 470 */ 1637, 1836, 1837, 1690, 1790, 1791, 1843, 1807, 1846, 1848, - /* 480 */ 1812, 1799, 1852, 1804, 1855, 1820, 1856, 1866, 1867, 1825, - /* 490 */ 1869, 1870, 1872, 1873, 1878, 1879, 1715, 1844, 1882, 1718, - /* 500 */ 1884, 1885, 1888, 1890, 1891, 1901, 1903, 1904, 1905, 1906, - /* 510 */ 1907, 1908, 1909, 1910, 1911, 1912, 1913, 1914, 1920, 1849, - /* 520 */ 1921, 1886, 1932, 1936, 1937, 1938, 1939, 1941, 1944, 1896, - /* 530 */ 1945, 1786, 1946, 1800, 1948, 1803, 1950, 1951, 1930, 1915, - /* 540 */ 1931, 1916, 1954, 1894, 1919, 1960, 1897, 1961, 1899, 1963, - /* 550 */ 1967, 1940, 1917, 1927, 1971, 1942, 1922, 1933, 1974, 1943, - /* 560 */ 1925, 1953, 1978, 1949, 1982, 1955, 1956, 1952, 1959, 1964, - /* 570 */ 1969, 1976, 1993, 1958, 1970, 2016, 2023, 2026, 2027, 1987, - /* 580 */ 1838, 2030, 1959, 1983, 2033, 2034, 1965, 2035, 2036, 2002, - /* 590 */ 1990, 2000, 2044, 2008, 1995, 2005, 2051, 2012, 2003, 2013, - /* 600 */ 2057, 2021, 2009, 2017, 2061, 2062, 2063, 2064, 2065, 2066, - /* 610 */ 1962, 1966, 2032, 2045, 2071, 2037, 2038, 2039, 2041, 2043, - /* 620 */ 2046, 2047, 2048, 2040, 2054, 2052, 2053, 2060, 2055, 2088, - /* 630 */ 2074, 2103, 2083, 2106, 2085, 2058, 2108, 2091, 2084, 2125, - /* 640 */ 2126, 2127, 2092, 2128, 2093, 2131, 2111, 2115, 2099, 2101, - /* 650 */ 2102, 2042, 2050, 2149, 1972, 2059, 1973, 1959, 2104, 2152, - /* 660 */ 1979, 2118, 2136, 2162, 1975, 2138, 1985, 1984, 2168, 2170, - /* 670 */ 1989, 1992, 1997, 1994, 2169, 2151, 1923, 2078, 2080, 2079, - /* 680 */ 2081, 2154, 2155, 2086, 2145, 2089, 2146, 2094, 2090, 2172, - /* 690 */ 2173, 2095, 2109, 2114, 2116, 2100, 2176, 2153, 2171, 2117, - /* 700 */ 2192, 1957, 2119, 2120, 2223, 2196, 1968, 2194, 2198, 2199, - /* 710 */ 2200, 2201, 2202, 2133, 2134, 2184, 1986, 2211, 2206, 2257, - /* 720 */ 2258, 2156, 2217, 2157, 2158, 2159, 2161, 2163, 2075, 2166, - /* 730 */ 2260, 2220, 2105, 2179, 2167, 1959, 2226, 2236, 2182, 2019, - /* 740 */ 2185, 2290, 2269, 2068, 2187, 2188, 2191, 2195, 2193, 2203, - /* 750 */ 2246, 2205, 2207, 2250, 2208, 2284, 2072, 2210, 2204, 2212, - /* 760 */ 2271, 2273, 2215, 2216, 2278, 2219, 2222, 2281, 2221, 2224, - /* 770 */ 2282, 2227, 2225, 2294, 2228, 2229, 2299, 2231, 2214, 2232, - /* 780 */ 2233, 2234, 2237, 2306, 2240, 2303, 2241, 2306, 2306, 2328, - /* 790 */ 2279, 2292, 2327, 2330, 2331, 2333, 2334, 2343, 2344, 2347, - /* 800 */ 2350, 2316, 2296, 2321, 2300, 2369, 2368, 2370, 2371, 2382, - /* 810 */ 2372, 2373, 2374, 2335, 2040, 2375, 2054, 2377, 2378, 2380, - /* 820 */ 2385, 2397, 2386, 2421, 2388, 2376, 2387, 2426, 2391, 2379, - /* 830 */ 2389, 2432, 2396, 2383, 2393, 2437, 2403, 2392, 2409, 2453, - /* 840 */ 2418, 2420, 2460, 2439, 2430, 2449, 2443, 2451, 2452, 2454, - /* 850 */ 2456, + /* 220 */ 1478, 1456, 1329, 1470, 1478, 1470, 1456, 1329, 1329, 1329, + /* 230 */ 1416, 1419, 1470, 1426, 1470, 1470, 1470, 1515, 1494, 1515, + /* 240 */ 1494, 1457, 31, 31, 1532, 31, 1538, 1539, 31, 1538, + /* 250 */ 31, 1546, 31, 31, 1470, 31, 1515, 131, 131, 131, + /* 260 */ 131, 131, 131, 131, 131, 131, 131, 131, 1470, 763, + /* 270 */ 763, 1515, 639, 639, 639, 1385, 1485, 1457, 405, 1608, + /* 280 */ 1421, 1423, 1532, 405, 1169, 1470, 639, 1349, 1356, 1349, + /* 290 */ 1356, 1357, 1466, 1349, 1376, 1382, 1387, 1169, 1377, 1379, + /* 300 */ 1383, 1408, 1478, 1660, 1567, 1417, 1538, 405, 405, 1356, + /* 310 */ 639, 639, 639, 639, 1356, 639, 1513, 405, 741, 405, + /* 320 */ 1478, 1609, 1624, 639, 1470, 405, 1717, 1709, 1515, 2941, + /* 330 */ 2941, 2941, 2941, 2941, 2941, 2941, 2941, 2941, 36, 480, + /* 340 */ 197, 887, 915, 81, 804, 510, 1097, 1191, 1079, 879, + /* 350 */ 1021, 1021, 1021, 1021, 1021, 1021, 1021, 1021, 1021, 216, + /* 360 */ 148, 12, 988, 988, 252, 217, 10, 146, 658, 1100, + /* 370 */ 608, 1030, 187, 620, 620, 918, 6, 864, 918, 918, + /* 380 */ 918, 919, 680, 727, 1154, 1165, 962, 1240, 1162, 1167, + /* 390 */ 1168, 1172, 1266, 1274, 1146, 1283, 1284, 1290, 1074, 1211, + /* 400 */ 1234, 1228, 1255, 1263, 1264, 1276, 1157, 1064, 1107, 1288, + /* 410 */ 1289, 1291, 1302, 1306, 1310, 1312, 1313, 410, 1319, 1246, + /* 420 */ 1322, 1324, 1325, 1341, 1370, 1371, 1243, 1122, 1126, 1314, + /* 430 */ 1348, 1267, 1391, 1768, 1778, 1780, 1736, 1782, 1746, 1557, + /* 440 */ 1748, 1750, 1751, 1562, 1794, 1758, 1760, 1580, 1771, 1809, + /* 450 */ 1584, 1813, 1777, 1815, 1779, 1817, 1796, 1819, 1783, 1599, + /* 460 */ 1834, 1613, 1824, 1615, 1616, 1622, 1626, 1829, 1830, 1831, + /* 470 */ 1634, 1639, 1837, 1838, 1691, 1791, 1795, 1843, 1811, 1846, + /* 480 */ 1849, 1816, 1799, 1852, 1806, 1856, 1820, 1866, 1867, 1869, + /* 490 */ 1821, 1872, 1873, 1874, 1878, 1879, 1880, 1716, 1845, 1883, + /* 500 */ 1719, 1885, 1888, 1890, 1891, 1901, 1903, 1904, 1905, 1906, + /* 510 */ 1907, 1908, 1909, 1910, 1911, 1912, 1913, 1914, 1920, 1921, + /* 520 */ 1882, 1932, 1853, 1936, 1937, 1938, 1939, 1941, 1944, 1945, + /* 530 */ 1896, 1946, 1786, 1947, 1801, 1949, 1804, 1951, 1952, 1931, + /* 540 */ 1915, 1940, 1916, 1954, 1894, 1919, 1960, 1899, 1961, 1902, + /* 550 */ 1963, 1968, 1942, 1922, 1927, 1971, 1943, 1923, 1933, 1976, + /* 560 */ 1948, 1926, 1953, 1978, 1956, 1982, 1955, 1959, 1950, 1964, + /* 570 */ 1967, 1972, 1974, 1998, 1965, 1970, 2025, 2026, 2027, 2039, + /* 580 */ 1987, 1839, 2030, 1964, 1984, 2031, 2034, 1969, 2035, 2036, + /* 590 */ 2000, 1993, 2003, 2042, 2009, 1996, 2007, 2051, 2017, 2004, + /* 600 */ 2015, 2058, 2022, 2010, 2018, 2062, 2063, 2064, 2065, 2066, + /* 610 */ 2067, 1958, 1962, 2032, 2052, 2071, 2040, 2041, 2043, 2045, + /* 620 */ 2046, 2047, 2048, 2050, 2055, 2056, 2053, 2059, 2054, 2068, + /* 630 */ 2079, 2070, 2103, 2084, 2107, 2086, 2060, 2111, 2099, 2088, + /* 640 */ 2126, 2127, 2128, 2092, 2130, 2094, 2133, 2114, 2115, 2101, + /* 650 */ 2102, 2112, 2044, 2061, 2150, 1973, 2072, 1957, 1964, 2104, + /* 660 */ 2154, 1975, 2121, 2138, 2161, 1966, 2140, 1985, 1995, 2169, + /* 670 */ 2170, 1990, 1992, 2001, 1997, 2179, 2151, 1917, 2078, 2080, + /* 680 */ 2082, 2083, 2155, 2156, 2089, 2145, 2093, 2147, 2097, 2095, + /* 690 */ 2172, 2173, 2100, 2109, 2116, 2117, 2118, 2176, 2153, 2171, + /* 700 */ 2120, 2188, 1979, 2123, 2125, 2222, 2195, 1980, 2192, 2197, + /* 710 */ 2198, 2199, 2200, 2201, 2131, 2134, 2196, 1988, 2208, 2206, + /* 720 */ 2244, 2259, 2157, 2218, 2159, 2162, 2165, 2168, 2180, 2075, + /* 730 */ 2182, 2262, 2221, 2085, 2183, 2152, 1964, 2227, 2234, 2178, + /* 740 */ 2037, 2181, 2290, 2269, 2069, 2189, 2187, 2191, 2194, 2193, + /* 750 */ 2202, 2250, 2204, 2205, 2257, 2207, 2286, 2077, 2209, 2203, + /* 760 */ 2210, 2280, 2282, 2214, 2216, 2285, 2219, 2220, 2293, 2224, + /* 770 */ 2225, 2295, 2228, 2226, 2299, 2230, 2231, 2301, 2233, 2223, + /* 780 */ 2232, 2235, 2236, 2237, 2276, 2240, 2305, 2241, 2276, 2276, + /* 790 */ 2328, 2296, 2291, 2324, 2330, 2333, 2334, 2343, 2344, 2347, + /* 800 */ 2350, 2357, 2319, 2298, 2323, 2303, 2369, 2368, 2370, 2371, + /* 810 */ 2387, 2373, 2374, 2375, 2335, 2055, 2377, 2056, 2378, 2380, + /* 820 */ 2382, 2385, 2399, 2386, 2425, 2389, 2376, 2388, 2428, 2392, + /* 830 */ 2381, 2391, 2431, 2397, 2400, 2393, 2437, 2403, 2402, 2401, + /* 840 */ 2455, 2420, 2423, 2461, 2441, 2438, 2451, 2443, 2452, 2453, + /* 850 */ 2458, 2456, }; -#define YY_REDUCE_COUNT (336) +#define YY_REDUCE_COUNT (337) #define YY_REDUCE_MIN (-464) #define YY_REDUCE_MAX (2479) static const short yy_reduce_ofst[] = { @@ -1316,106 +1316,106 @@ static const short yy_reduce_ofst[] = { /* 190 */ 982, 921, 961, 1042, 993, 1048, 1010, 985, 997, 1000, /* 200 */ 961, 942, 942, 923, 942, 955, 957, 1055, 1016, 1001, /* 210 */ 1009, 1038, 1036, 1111, 1045, 1113, 1056, 1127, 1133, 1086, - /* 220 */ 1136, 1089, 1096, 1144, 1147, 1145, 1099, 1103, 1105, 1138, - /* 230 */ 1149, 1156, 1151, 1174, 1175, 1177, 1179, 1182, 1187, 1186, - /* 240 */ 1108, 1176, 1178, 1148, 1181, 1190, 1129, 1189, 1195, 1192, - /* 250 */ 1143, 1193, 1194, 1204, 1199, 1212, 1180, 1184, 1197, 1198, - /* 260 */ 1205, 1210, 1218, 1222, 1223, 1227, 1229, 1214, 1219, 1220, - /* 270 */ 1231, 1209, 1216, 1224, 1160, 1155, 1206, 1254, 1217, 1201, - /* 280 */ 1200, 1225, 1259, 1202, 1269, 1230, 1161, 1232, 1164, 1237, - /* 290 */ 1170, 1173, 1183, 1203, 1208, 1207, 1239, 1166, 1226, 1233, - /* 300 */ 942, 1316, 1235, 1215, 1242, 1321, 1317, 1327, 1273, 1295, - /* 310 */ 1298, 1299, 1301, 1282, 1303, 1293, 1338, 1333, 1342, 1349, - /* 320 */ 1258, 1334, 1332, 1366, 1363, 1393, 1390, 1392, 1328, 1315, - /* 330 */ 1330, 1335, 1364, 1376, 1378, 1389, 1416, + /* 220 */ 1136, 1089, 1096, 1144, 1147, 1145, 1099, 1103, 1105, 1106, + /* 230 */ 1138, 1149, 1158, 1161, 1174, 1175, 1177, 1186, 1183, 1190, + /* 240 */ 1187, 1109, 1178, 1179, 1148, 1181, 1193, 1131, 1189, 1197, + /* 250 */ 1192, 1151, 1194, 1195, 1202, 1200, 1212, 1182, 1184, 1198, + /* 260 */ 1199, 1204, 1205, 1210, 1218, 1222, 1223, 1227, 1214, 1219, + /* 270 */ 1225, 1231, 1209, 1216, 1217, 1206, 1207, 1208, 1254, 1226, + /* 280 */ 1201, 1215, 1224, 1258, 1203, 1269, 1230, 1164, 1232, 1171, + /* 290 */ 1233, 1170, 1173, 1220, 1180, 1213, 1236, 1244, 1238, 1176, + /* 300 */ 1229, 942, 1316, 1235, 1242, 1245, 1321, 1320, 1327, 1270, + /* 310 */ 1294, 1298, 1299, 1301, 1272, 1303, 1286, 1336, 1323, 1342, + /* 320 */ 1359, 1259, 1333, 1330, 1368, 1363, 1394, 1393, 1392, 1328, + /* 330 */ 1315, 1335, 1337, 1367, 1375, 1378, 1397, 1413, }; static const YYACTIONTYPE yy_default[] = { - /* 0 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 10 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 20 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 30 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 40 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 50 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 60 */ 1904, 2244, 1904, 1904, 2207, 1904, 1904, 1904, 1904, 1904, - /* 70 */ 1904, 1904, 1904, 1904, 1904, 1904, 2214, 1904, 1904, 1904, - /* 80 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 90 */ 1904, 1904, 1904, 1904, 1904, 1904, 2003, 1904, 1904, 1904, - /* 100 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 110 */ 1904, 1904, 1904, 2001, 2447, 1904, 1904, 1904, 1904, 1904, - /* 120 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 130 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 2459, 1904, - /* 140 */ 1904, 1975, 1975, 1904, 2459, 2459, 2459, 2001, 2419, 2419, - /* 150 */ 1904, 1904, 2003, 2282, 1904, 1904, 1904, 1904, 1904, 1904, - /* 160 */ 1904, 1904, 2126, 1934, 1904, 1904, 1904, 1904, 2150, 1904, - /* 170 */ 1904, 1904, 2270, 1904, 1904, 2488, 2550, 1904, 2491, 1904, - /* 180 */ 1904, 1904, 1904, 1904, 2219, 1904, 2478, 1904, 1904, 1904, - /* 190 */ 1904, 1904, 1904, 1904, 1904, 1904, 2079, 2264, 1904, 1904, - /* 200 */ 1904, 2451, 2465, 2534, 2452, 2449, 2472, 1904, 2482, 1904, - /* 210 */ 2307, 1904, 2296, 2003, 1904, 2003, 2257, 2202, 1904, 2212, - /* 220 */ 1904, 2212, 2209, 1904, 1904, 1904, 2212, 2209, 2209, 2068, - /* 230 */ 2064, 1904, 2062, 1904, 1904, 1904, 1904, 1959, 1904, 1959, - /* 240 */ 1904, 2003, 2003, 1904, 2003, 1904, 1904, 2003, 1904, 2003, - /* 250 */ 1904, 2003, 2003, 1904, 2003, 1904, 1904, 1904, 1904, 1904, - /* 260 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 270 */ 1904, 1904, 1904, 1904, 2294, 2280, 1904, 2001, 1904, 2268, - /* 280 */ 2266, 1904, 2001, 2482, 1904, 1904, 2504, 2499, 2504, 2499, - /* 290 */ 2518, 2514, 2504, 2523, 2520, 2484, 2482, 2553, 2540, 2536, - /* 300 */ 2465, 1904, 1904, 2470, 2468, 1904, 2001, 2001, 2499, 1904, - /* 310 */ 1904, 1904, 1904, 2499, 1904, 1904, 2001, 1904, 2001, 1904, - /* 320 */ 1904, 2095, 1904, 1904, 2001, 1904, 1943, 1904, 2259, 2285, - /* 330 */ 2240, 2240, 2129, 2129, 2129, 2004, 1909, 1904, 1904, 1904, - /* 340 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 2517, - /* 350 */ 2516, 2372, 1904, 2423, 2422, 2421, 2412, 2371, 2091, 1904, - /* 360 */ 1904, 2370, 2369, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 370 */ 1904, 1904, 2231, 2230, 2363, 1904, 1904, 2364, 2362, 2361, - /* 380 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 390 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 400 */ 1904, 1904, 1904, 1904, 1904, 1904, 2537, 2541, 1904, 1904, - /* 410 */ 1904, 1904, 1904, 1904, 2448, 1904, 1904, 1904, 2343, 1904, - /* 420 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 430 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 440 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 450 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 460 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 470 */ 1904, 1904, 1904, 2208, 1904, 1904, 1904, 1904, 1904, 1904, - /* 480 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 490 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 500 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 510 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 520 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 530 */ 1904, 1904, 1904, 1904, 1904, 2223, 1904, 1904, 1904, 1904, - /* 540 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 550 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 560 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1948, 2350, 1904, - /* 570 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 580 */ 1904, 1904, 2353, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 590 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 600 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 610 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 620 */ 1904, 1904, 1904, 2043, 2042, 1904, 1904, 1904, 1904, 1904, - /* 630 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 640 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 650 */ 1904, 2354, 1904, 1904, 1904, 1904, 1904, 2345, 1904, 1904, - /* 660 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 670 */ 1904, 1904, 1904, 1904, 2533, 2485, 1904, 1904, 1904, 1904, - /* 680 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 690 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 2343, 1904, - /* 700 */ 2515, 1904, 1904, 2531, 1904, 2535, 1904, 1904, 1904, 1904, - /* 710 */ 1904, 1904, 1904, 2458, 2454, 1904, 1904, 2450, 1904, 1904, - /* 720 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 730 */ 1904, 1904, 1904, 1904, 1904, 2342, 1904, 2409, 1904, 1904, - /* 740 */ 1904, 2443, 1904, 1904, 2394, 1904, 1904, 1904, 1904, 1904, - /* 750 */ 1904, 1904, 1904, 1904, 2354, 1904, 2357, 1904, 1904, 1904, - /* 760 */ 1904, 1904, 2123, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 770 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 2107, 2105, - /* 780 */ 2104, 2103, 1904, 2136, 1904, 1904, 1904, 2132, 2131, 1904, - /* 790 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 800 */ 1904, 1904, 1904, 1904, 1904, 2022, 1904, 1904, 1904, 1904, - /* 810 */ 1904, 1904, 1904, 1904, 2014, 1904, 2013, 1904, 1904, 1904, - /* 820 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 830 */ 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, 1904, - /* 840 */ 1904, 1904, 1904, 1904, 1933, 1904, 1904, 1904, 1904, 1904, - /* 850 */ 1904, + /* 0 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 10 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 20 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 30 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 40 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 50 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 60 */ 1905, 2245, 1905, 1905, 2208, 1905, 1905, 1905, 1905, 1905, + /* 70 */ 1905, 1905, 1905, 1905, 1905, 1905, 2215, 1905, 1905, 1905, + /* 80 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 90 */ 1905, 1905, 1905, 1905, 1905, 1905, 2004, 1905, 1905, 1905, + /* 100 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 110 */ 1905, 1905, 1905, 2002, 2448, 1905, 1905, 1905, 1905, 1905, + /* 120 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 130 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 2460, 1905, + /* 140 */ 1905, 1976, 1976, 1905, 2460, 2460, 2460, 2002, 2420, 2420, + /* 150 */ 1905, 1905, 2004, 2283, 1905, 1905, 1905, 1905, 1905, 1905, + /* 160 */ 1905, 1905, 2127, 1935, 1905, 1905, 1905, 1905, 2151, 1905, + /* 170 */ 1905, 1905, 2271, 1905, 1905, 2489, 2551, 1905, 2492, 1905, + /* 180 */ 1905, 1905, 1905, 1905, 2220, 1905, 2479, 1905, 1905, 1905, + /* 190 */ 1905, 1905, 1905, 1905, 1905, 1905, 2080, 2265, 1905, 1905, + /* 200 */ 1905, 2452, 2466, 2535, 2453, 2450, 2473, 1905, 2483, 1905, + /* 210 */ 2308, 1905, 2297, 2004, 1905, 2004, 2258, 2203, 1905, 2213, + /* 220 */ 1905, 2213, 2210, 1905, 1905, 1905, 2213, 2210, 2210, 2210, + /* 230 */ 2069, 2065, 1905, 2063, 1905, 1905, 1905, 1905, 1960, 1905, + /* 240 */ 1960, 1905, 2004, 2004, 1905, 2004, 1905, 1905, 2004, 1905, + /* 250 */ 2004, 1905, 2004, 2004, 1905, 2004, 1905, 1905, 1905, 1905, + /* 260 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 270 */ 1905, 1905, 1905, 1905, 1905, 2295, 2281, 1905, 2002, 1905, + /* 280 */ 2269, 2267, 1905, 2002, 2483, 1905, 1905, 2505, 2500, 2505, + /* 290 */ 2500, 2519, 2515, 2505, 2524, 2521, 2485, 2483, 2554, 2541, + /* 300 */ 2537, 2466, 1905, 1905, 2471, 2469, 1905, 2002, 2002, 2500, + /* 310 */ 1905, 1905, 1905, 1905, 2500, 1905, 1905, 2002, 1905, 2002, + /* 320 */ 1905, 1905, 2096, 1905, 1905, 2002, 1905, 1944, 1905, 2260, + /* 330 */ 2286, 2241, 2241, 2130, 2130, 2130, 2005, 1910, 1905, 1905, + /* 340 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 350 */ 2518, 2517, 2373, 1905, 2424, 2423, 2422, 2413, 2372, 2092, + /* 360 */ 1905, 1905, 2371, 2370, 1905, 1905, 1905, 1905, 1905, 1905, + /* 370 */ 1905, 1905, 1905, 2232, 2231, 2364, 1905, 1905, 2365, 2363, + /* 380 */ 2362, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 390 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 400 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 2538, 2542, 1905, + /* 410 */ 1905, 1905, 1905, 1905, 1905, 2449, 1905, 1905, 1905, 2344, + /* 420 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 430 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 440 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 450 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 460 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 470 */ 1905, 1905, 1905, 1905, 2209, 1905, 1905, 1905, 1905, 1905, + /* 480 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 490 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 500 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 510 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 520 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 530 */ 1905, 1905, 1905, 1905, 1905, 1905, 2224, 1905, 1905, 1905, + /* 540 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 550 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 560 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1949, 2351, + /* 570 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 580 */ 1905, 1905, 1905, 2354, 1905, 1905, 1905, 1905, 1905, 1905, + /* 590 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 600 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 610 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 620 */ 1905, 1905, 1905, 1905, 2044, 2043, 1905, 1905, 1905, 1905, + /* 630 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 640 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 650 */ 1905, 1905, 2355, 1905, 1905, 1905, 1905, 1905, 2346, 1905, + /* 660 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 670 */ 1905, 1905, 1905, 1905, 1905, 2534, 2486, 1905, 1905, 1905, + /* 680 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 690 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 2344, + /* 700 */ 1905, 2516, 1905, 1905, 2532, 1905, 2536, 1905, 1905, 1905, + /* 710 */ 1905, 1905, 1905, 1905, 2459, 2455, 1905, 1905, 2451, 1905, + /* 720 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 730 */ 1905, 1905, 1905, 1905, 1905, 1905, 2343, 1905, 2410, 1905, + /* 740 */ 1905, 1905, 2444, 1905, 1905, 2395, 1905, 1905, 1905, 1905, + /* 750 */ 1905, 1905, 1905, 1905, 1905, 2355, 1905, 2358, 1905, 1905, + /* 760 */ 1905, 1905, 1905, 2124, 1905, 1905, 1905, 1905, 1905, 1905, + /* 770 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 2108, + /* 780 */ 2106, 2105, 2104, 1905, 2137, 1905, 1905, 1905, 2133, 2132, + /* 790 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 800 */ 1905, 1905, 1905, 1905, 1905, 1905, 2023, 1905, 1905, 1905, + /* 810 */ 1905, 1905, 1905, 1905, 1905, 2015, 1905, 2014, 1905, 1905, + /* 820 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 830 */ 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, 1905, + /* 840 */ 1905, 1905, 1905, 1905, 1905, 1934, 1905, 1905, 1905, 1905, + /* 850 */ 1905, 1905, }; /********** End of lemon-generated parsing tables *****************************/ @@ -2683,7 +2683,7 @@ static const char *const yyRuleName[] = { /* 287 */ "cmd ::= SHOW VNODES", /* 288 */ "cmd ::= SHOW db_name_cond_opt ALIVE", /* 289 */ "cmd ::= SHOW CLUSTER ALIVE", - /* 290 */ "cmd ::= SHOW db_name_cond_opt VIEWS", + /* 290 */ "cmd ::= SHOW db_name_cond_opt VIEWS like_pattern_opt", /* 291 */ "cmd ::= SHOW CREATE VIEW full_table_name", /* 292 */ "cmd ::= SHOW COMPACTS", /* 293 */ "cmd ::= SHOW COMPACT NK_INTEGER", @@ -3973,7 +3973,7 @@ static const YYCODETYPE yyRuleInfoLhs[] = { 351, /* (287) cmd ::= SHOW VNODES */ 351, /* (288) cmd ::= SHOW db_name_cond_opt ALIVE */ 351, /* (289) cmd ::= SHOW CLUSTER ALIVE */ - 351, /* (290) cmd ::= SHOW db_name_cond_opt VIEWS */ + 351, /* (290) cmd ::= SHOW db_name_cond_opt VIEWS like_pattern_opt */ 351, /* (291) cmd ::= SHOW CREATE VIEW full_table_name */ 351, /* (292) cmd ::= SHOW COMPACTS */ 351, /* (293) cmd ::= SHOW COMPACT NK_INTEGER */ @@ -4627,7 +4627,7 @@ static const signed char yyRuleInfoNRhs[] = { -2, /* (287) cmd ::= SHOW VNODES */ -3, /* (288) cmd ::= SHOW db_name_cond_opt ALIVE */ -3, /* (289) cmd ::= SHOW CLUSTER ALIVE */ - -3, /* (290) cmd ::= SHOW db_name_cond_opt VIEWS */ + -4, /* (290) cmd ::= SHOW db_name_cond_opt VIEWS like_pattern_opt */ -4, /* (291) cmd ::= SHOW CREATE VIEW full_table_name */ -2, /* (292) cmd ::= SHOW COMPACTS */ -3, /* (293) cmd ::= SHOW COMPACT NK_INTEGER */ @@ -6005,8 +6005,8 @@ static YYACTIONTYPE yy_reduce( case 289: /* cmd ::= SHOW CLUSTER ALIVE */ { pCxt->pRootNode = createShowAliveStmt(pCxt, NULL, QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT); } break; - case 290: /* cmd ::= SHOW db_name_cond_opt VIEWS */ -{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VIEWS_STMT, yymsp[-1].minor.yy360, NULL, OP_TYPE_LIKE); } + case 290: /* cmd ::= SHOW db_name_cond_opt VIEWS like_pattern_opt */ +{ pCxt->pRootNode = createShowStmtWithCond(pCxt, QUERY_NODE_SHOW_VIEWS_STMT, yymsp[-2].minor.yy360, yymsp[0].minor.yy360, OP_TYPE_LIKE); } break; case 291: /* cmd ::= SHOW CREATE VIEW full_table_name */ { pCxt->pRootNode = createShowCreateViewStmt(pCxt, QUERY_NODE_SHOW_CREATE_VIEW_STMT, yymsp[0].minor.yy360); } diff --git a/source/libs/scheduler/src/schJob.c b/source/libs/scheduler/src/schJob.c index 6e312f0e6f..e50ec64d54 100644 --- a/source/libs/scheduler/src/schJob.c +++ b/source/libs/scheduler/src/schJob.c @@ -66,7 +66,7 @@ FORCE_INLINE bool schJobNeedToStop(SSchJob *pJob, int8_t *pStatus) { return true; } - if ((*pJob->chkKillFp)(pJob->chkKillParam)) { + if (pJob->chkKillFp && (*pJob->chkKillFp)(pJob->chkKillParam)) { schUpdateJobErrCode(pJob, TSDB_CODE_TSC_QUERY_KILLED); return true; } diff --git a/source/libs/scheduler/test/schedulerTests.cpp b/source/libs/scheduler/test/schedulerTests.cpp index 5605a4b842..fbb1f657b0 100644 --- a/source/libs/scheduler/test/schedulerTests.cpp +++ b/source/libs/scheduler/test/schedulerTests.cpp @@ -54,9 +54,8 @@ namespace { -extern "C" int32_t schHandleResponseMsg(SSchJob *job, SSchTask *task, int32_t msgType, char *msg, int32_t msgSize, - int32_t rspCode); -extern "C" int32_t schHandleCallback(void *param, const SDataBuf *pMsg, int32_t msgType, int32_t rspCode); +extern "C" int32_t schHandleResponseMsg(SSchJob *pJob, SSchTask *pTask, int32_t execId, SDataBuf *pMsg, int32_t rspCode); +extern "C" int32_t schHandleCallback(void *param, const SDataBuf *pMsg, int32_t rspCode); int64_t insertJobRefId = 0; int64_t queryJobRefId = 0; @@ -67,7 +66,7 @@ uint64_t schtQueryId = 1; bool schtTestStop = false; bool schtTestDeadLoop = false; -int32_t schtTestMTRunSec = 10; +int32_t schtTestMTRunSec = 1; int32_t schtTestPrintNum = 1000; int32_t schtStartFetch = 0; @@ -85,10 +84,69 @@ void schtInitLogFile() { } void schtQueryCb(SExecResult *pResult, void *param, int32_t code) { - assert(TSDB_CODE_SUCCESS == code); *(int32_t *)param = 1; } +int32_t schtBuildQueryRspMsg(uint32_t *msize, void** rspMsg) { + SQueryTableRsp rsp = {0}; + rsp.code = 0; + rsp.affectedRows = 0; + rsp.tbVerInfo = NULL; + + int32_t msgSize = tSerializeSQueryTableRsp(NULL, 0, &rsp); + if (msgSize < 0) { + qError("tSerializeSQueryTableRsp failed"); + return TSDB_CODE_OUT_OF_MEMORY; + } + + void *pRsp = taosMemoryCalloc(msgSize, 1); + if (NULL == pRsp) { + qError("rpcMallocCont %d failed", msgSize); + return TSDB_CODE_OUT_OF_MEMORY; + } + + if (tSerializeSQueryTableRsp(pRsp, msgSize, &rsp) < 0) { + qError("tSerializeSQueryTableRsp %d failed", msgSize); + return TSDB_CODE_OUT_OF_MEMORY; + } + + *rspMsg = pRsp; + *msize = msgSize; + + return TSDB_CODE_SUCCESS; +} + + +int32_t schtBuildFetchRspMsg(uint32_t *msize, void** rspMsg) { + SRetrieveTableRsp* rsp = (SRetrieveTableRsp*)taosMemoryCalloc(sizeof(SRetrieveTableRsp), 1); + rsp->completed = 1; + rsp->numOfRows = 10; + rsp->compLen = 0; + + *rspMsg = rsp; + *msize = sizeof(SRetrieveTableRsp); + + return TSDB_CODE_SUCCESS; +} + +int32_t schtBuildSubmitRspMsg(uint32_t *msize, void** rspMsg) { + SSubmitRsp2 submitRsp = {0}; + int32_t msgSize = 0, ret = 0; + SEncoder ec = {0}; + + tEncodeSize(tEncodeSSubmitRsp2, &submitRsp, msgSize, ret); + void* msg = taosMemoryCalloc(1, msgSize); + tEncoderInit(&ec, (uint8_t*)msg, msgSize); + tEncodeSSubmitRsp2(&ec, &submitRsp); + tEncoderClear(&ec); + + *rspMsg = msg; + *msize = msgSize; + + return TSDB_CODE_SUCCESS; +} + + void schtBuildQueryDag(SQueryPlan *dag) { uint64_t qId = schtQueryId; @@ -98,8 +156,8 @@ void schtBuildQueryDag(SQueryPlan *dag) { SNodeListNode *scan = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST); SNodeListNode *merge = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST); - SSubplan *scanPlan = (SSubplan *)taosMemoryCalloc(1, sizeof(SSubplan)); - SSubplan *mergePlan = (SSubplan *)taosMemoryCalloc(1, sizeof(SSubplan)); + SSubplan *scanPlan = (SSubplan*)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN); + SSubplan *mergePlan = (SSubplan*)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN); scanPlan->id.queryId = qId; scanPlan->id.groupId = 0x0000000000000002; @@ -113,7 +171,7 @@ void schtBuildQueryDag(SQueryPlan *dag) { scanPlan->pChildren = NULL; scanPlan->level = 1; scanPlan->pParents = nodesMakeList(); - scanPlan->pNode = (SPhysiNode *)taosMemoryCalloc(1, sizeof(SPhysiNode)); + scanPlan->pNode = (SPhysiNode *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN); scanPlan->msgType = TDMT_SCH_QUERY; mergePlan->id.queryId = qId; @@ -125,7 +183,7 @@ void schtBuildQueryDag(SQueryPlan *dag) { mergePlan->pChildren = nodesMakeList(); mergePlan->pParents = NULL; - mergePlan->pNode = (SPhysiNode *)taosMemoryCalloc(1, sizeof(SPhysiNode)); + mergePlan->pNode = (SPhysiNode *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_MERGE); mergePlan->msgType = TDMT_SCH_QUERY; merge->pNodeList = nodesMakeList(); @@ -151,8 +209,7 @@ void schtBuildQueryFlowCtrlDag(SQueryPlan *dag) { SNodeListNode *scan = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST); SNodeListNode *merge = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST); - SSubplan *scanPlan = (SSubplan *)taosMemoryCalloc(scanPlanNum, sizeof(SSubplan)); - SSubplan *mergePlan = (SSubplan *)taosMemoryCalloc(1, sizeof(SSubplan)); + SSubplan *mergePlan = (SSubplan*)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN); merge->pNodeList = nodesMakeList(); scan->pNodeList = nodesMakeList(); @@ -160,29 +217,30 @@ void schtBuildQueryFlowCtrlDag(SQueryPlan *dag) { mergePlan->pChildren = nodesMakeList(); for (int32_t i = 0; i < scanPlanNum; ++i) { - scanPlan[i].id.queryId = qId; - scanPlan[i].id.groupId = 0x0000000000000002; - scanPlan[i].id.subplanId = 0x0000000000000003 + i; - scanPlan[i].subplanType = SUBPLAN_TYPE_SCAN; + SSubplan *scanPlan = (SSubplan*)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN); + scanPlan->id.queryId = qId; + scanPlan->id.groupId = 0x0000000000000002; + scanPlan->id.subplanId = 0x0000000000000003 + i; + scanPlan->subplanType = SUBPLAN_TYPE_SCAN; - scanPlan[i].execNode.nodeId = 1 + i; - scanPlan[i].execNode.epSet.inUse = 0; - scanPlan[i].execNodeStat.tableNum = taosRand() % 30; - addEpIntoEpSet(&scanPlan[i].execNode.epSet, "ep0", 6030); - addEpIntoEpSet(&scanPlan[i].execNode.epSet, "ep1", 6030); - addEpIntoEpSet(&scanPlan[i].execNode.epSet, "ep2", 6030); - scanPlan[i].execNode.epSet.inUse = taosRand() % 3; + scanPlan->execNode.nodeId = 1 + i; + scanPlan->execNode.epSet.inUse = 0; + scanPlan->execNodeStat.tableNum = taosRand() % 30; + addEpIntoEpSet(&scanPlan->execNode.epSet, "ep0", 6030); + addEpIntoEpSet(&scanPlan->execNode.epSet, "ep1", 6030); + addEpIntoEpSet(&scanPlan->execNode.epSet, "ep2", 6030); + scanPlan->execNode.epSet.inUse = taosRand() % 3; - scanPlan[i].pChildren = NULL; - scanPlan[i].level = 1; - scanPlan[i].pParents = nodesMakeList(); - scanPlan[i].pNode = (SPhysiNode *)taosMemoryCalloc(1, sizeof(SPhysiNode)); - scanPlan[i].msgType = TDMT_SCH_QUERY; + scanPlan->pChildren = NULL; + scanPlan->level = 1; + scanPlan->pParents = nodesMakeList(); + scanPlan->pNode = (SPhysiNode *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN); + scanPlan->msgType = TDMT_SCH_QUERY; - nodesListAppend(scanPlan[i].pParents, (SNode *)mergePlan); - nodesListAppend(mergePlan->pChildren, (SNode *)(scanPlan + i)); + nodesListAppend(scanPlan->pParents, (SNode *)mergePlan); + nodesListAppend(mergePlan->pChildren, (SNode *)scanPlan); - nodesListAppend(scan->pNodeList, (SNode *)(scanPlan + i)); + nodesListAppend(scan->pNodeList, (SNode *)scanPlan); } mergePlan->id.queryId = qId; @@ -193,7 +251,7 @@ void schtBuildQueryFlowCtrlDag(SQueryPlan *dag) { mergePlan->execNode.epSet.numOfEps = 0; mergePlan->pParents = NULL; - mergePlan->pNode = (SPhysiNode *)taosMemoryCalloc(1, sizeof(SPhysiNode)); + mergePlan->pNode = (SPhysiNode *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_MERGE); mergePlan->msgType = TDMT_SCH_QUERY; nodesListAppend(merge->pNodeList, (SNode *)mergePlan); @@ -211,45 +269,50 @@ void schtBuildInsertDag(SQueryPlan *dag) { dag->numOfSubplans = 2; dag->pSubplans = nodesMakeList(); SNodeListNode *inserta = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST); - - SSubplan *insertPlan = (SSubplan *)taosMemoryCalloc(2, sizeof(SSubplan)); - - insertPlan[0].id.queryId = qId; - insertPlan[0].id.groupId = 0x0000000000000003; - insertPlan[0].id.subplanId = 0x0000000000000004; - insertPlan[0].subplanType = SUBPLAN_TYPE_MODIFY; - insertPlan[0].level = 0; - - insertPlan[0].execNode.nodeId = 1; - insertPlan[0].execNode.epSet.inUse = 0; - addEpIntoEpSet(&insertPlan[0].execNode.epSet, "ep0", 6030); - - insertPlan[0].pChildren = NULL; - insertPlan[0].pParents = NULL; - insertPlan[0].pNode = NULL; - insertPlan[0].pDataSink = (SDataSinkNode *)taosMemoryCalloc(1, sizeof(SDataSinkNode)); - insertPlan[0].msgType = TDMT_VND_SUBMIT; - - insertPlan[1].id.queryId = qId; - insertPlan[1].id.groupId = 0x0000000000000003; - insertPlan[1].id.subplanId = 0x0000000000000005; - insertPlan[1].subplanType = SUBPLAN_TYPE_MODIFY; - insertPlan[1].level = 0; - - insertPlan[1].execNode.nodeId = 1; - insertPlan[1].execNode.epSet.inUse = 0; - addEpIntoEpSet(&insertPlan[1].execNode.epSet, "ep0", 6030); - - insertPlan[1].pChildren = NULL; - insertPlan[1].pParents = NULL; - insertPlan[1].pNode = NULL; - insertPlan[1].pDataSink = (SDataSinkNode *)taosMemoryCalloc(1, sizeof(SDataSinkNode)); - insertPlan[1].msgType = TDMT_VND_SUBMIT; - inserta->pNodeList = nodesMakeList(); + SSubplan *insertPlan = (SSubplan*)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN); + + insertPlan->id.queryId = qId; + insertPlan->id.groupId = 0x0000000000000003; + insertPlan->id.subplanId = 0x0000000000000004; + insertPlan->subplanType = SUBPLAN_TYPE_MODIFY; + insertPlan->level = 0; + + insertPlan->execNode.nodeId = 1; + insertPlan->execNode.epSet.inUse = 0; + addEpIntoEpSet(&insertPlan->execNode.epSet, "ep0", 6030); + + insertPlan->pChildren = NULL; + insertPlan->pParents = NULL; + insertPlan->pNode = NULL; + insertPlan->pDataSink = (SDataSinkNode*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_INSERT); + ((SDataInserterNode*)insertPlan->pDataSink)->size = 1; + ((SDataInserterNode*)insertPlan->pDataSink)->pData = taosMemoryCalloc(1, 1); + insertPlan->msgType = TDMT_VND_SUBMIT; + nodesListAppend(inserta->pNodeList, (SNode *)insertPlan); - insertPlan += 1; + + insertPlan = (SSubplan*)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN); + + insertPlan->id.queryId = qId; + insertPlan->id.groupId = 0x0000000000000003; + insertPlan->id.subplanId = 0x0000000000000005; + insertPlan->subplanType = SUBPLAN_TYPE_MODIFY; + insertPlan->level = 0; + + insertPlan->execNode.nodeId = 1; + insertPlan->execNode.epSet.inUse = 0; + addEpIntoEpSet(&insertPlan->execNode.epSet, "ep0", 6030); + + insertPlan->pChildren = NULL; + insertPlan->pParents = NULL; + insertPlan->pNode = NULL; + insertPlan->pDataSink = (SDataSinkNode*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_INSERT); + ((SDataInserterNode*)insertPlan->pDataSink)->size = 1; + ((SDataInserterNode*)insertPlan->pDataSink)->pData = taosMemoryCalloc(1, 1); + insertPlan->msgType = TDMT_VND_SUBMIT; + nodesListAppend(inserta->pNodeList, (SNode *)insertPlan); nodesListAppend(dag->pSubplans, (SNode *)inserta); @@ -325,7 +388,7 @@ void schtSetRpcSendRequest() { } } -int32_t schtAsyncSendMsgToServer(void *pTransporter, SEpSet *epSet, int64_t *pTransporterId, SMsgSendInfo *pInfo) { +int32_t schtAsyncSendMsgToServer(void *pTransporter, SEpSet *epSet, int64_t *pTransporterId, SMsgSendInfo *pInfo, bool persistHandle, void* rpcCtx) { if (pInfo) { taosMemoryFreeClear(pInfo->param); taosMemoryFreeClear(pInfo->msgInfo.pData); @@ -336,17 +399,17 @@ int32_t schtAsyncSendMsgToServer(void *pTransporter, SEpSet *epSet, int64_t *pTr void schtSetAsyncSendMsgToServer() { static Stub stub; - stub.set(asyncSendMsgToServer, schtAsyncSendMsgToServer); + stub.set(asyncSendMsgToServerExt, schtAsyncSendMsgToServer); { #ifdef WINDOWS AddrAny any; std::map result; - any.get_func_addr("asyncSendMsgToServer", result); + any.get_func_addr("asyncSendMsgToServerExt", result); #endif #ifdef LINUX AddrAny any("libtransport.so"); std::map result; - any.get_global_func_addr_dynsym("^asyncSendMsgToServer$", result); + any.get_global_func_addr_dynsym("^asyncSendMsgToServerExt$", result); #endif for (const auto &f : result) { stub.set(f.second, schtAsyncSendMsgToServer); @@ -374,9 +437,13 @@ void *schtSendRsp(void *param) { while (pIter) { SSchTask *task = *(SSchTask **)pIter; - SSubmitRsp rsp = {0}; - rsp.affectedRows = 10; - schHandleResponseMsg(pJob, task, TDMT_VND_SUBMIT_RSP, (char *)&rsp, sizeof(rsp), 0); + SDataBuf msg = {0}; + void* rmsg = NULL; + schtBuildSubmitRspMsg(&msg.len, &rmsg); + msg.msgType = TDMT_VND_SUBMIT_RSP; + msg.pData = rmsg; + + schHandleResponseMsg(pJob, task, task->execId, &msg, 0); pIter = taosHashIterate(pJob->execTasks, pIter); } @@ -393,11 +460,13 @@ void *schtCreateFetchRspThread(void *param) { taosSsleep(1); int32_t code = 0; - SRetrieveTableRsp *rsp = (SRetrieveTableRsp *)taosMemoryCalloc(1, sizeof(SRetrieveTableRsp)); - rsp->completed = 1; - rsp->numOfRows = 10; - - code = schHandleResponseMsg(pJob, pJob->fetchTask, TDMT_SCH_FETCH_RSP, (char *)rsp, sizeof(*rsp), 0); + SDataBuf msg = {0}; + void* rmsg = NULL; + schtBuildFetchRspMsg(&msg.len, &rmsg); + msg.msgType = TDMT_SCH_MERGE_FETCH_RSP; + msg.pData = rmsg; + + code = schHandleResponseMsg(pJob, pJob->fetchTask, pJob->fetchTask->execId, &msg, 0); schReleaseJob(job); @@ -414,7 +483,7 @@ void *schtFetchRspThread(void *aa) { continue; } - taosUsleep(1); + taosUsleep(100); param = (SSchTaskCallbackParam *)taosMemoryCalloc(1, sizeof(*param)); @@ -426,10 +495,11 @@ void *schtFetchRspThread(void *aa) { rsp->completed = 1; rsp->numOfRows = 10; + dataBuf.msgType = TDMT_SCH_FETCH_RSP; dataBuf.pData = rsp; dataBuf.len = sizeof(*rsp); - code = schHandleCallback(param, &dataBuf, TDMT_SCH_FETCH_RSP, 0); + code = schHandleCallback(param, &dataBuf, 0); assert(code == 0 || code); } @@ -456,7 +526,7 @@ void *schtRunJobThread(void *aa) { char *dbname = "1.db1"; char *tablename = "table1"; SVgroupInfo vgInfo = {0}; - SQueryPlan dag; + SQueryPlan* dag = (SQueryPlan*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN); schtInitLogFile(); @@ -470,19 +540,19 @@ void *schtRunJobThread(void *aa) { SSchJob *pJob = NULL; SSchTaskCallbackParam *param = NULL; SHashObj *execTasks = NULL; - SDataBuf dataBuf = {0}; uint32_t jobFinished = 0; int32_t queryDone = 0; while (!schtTestStop) { - schtBuildQueryDag(&dag); + schtBuildQueryDag(dag); - SArray *qnodeList = taosArrayInit(1, sizeof(SEp)); + SArray *qnodeList = taosArrayInit(1, sizeof(SQueryNodeLoad)); - SEp qnodeAddr = {0}; - strcpy(qnodeAddr.fqdn, "qnode0.ep"); - qnodeAddr.port = 6031; - taosArrayPush(qnodeList, &qnodeAddr); + SQueryNodeLoad load = {0}; + load.addr.epSet.numOfEps = 1; + strcpy(load.addr.epSet.eps[0].fqdn, "qnode0.ep"); + load.addr.epSet.eps[0].port = 6031; + taosArrayPush(qnodeList, &load); queryDone = 0; @@ -492,7 +562,7 @@ void *schtRunJobThread(void *aa) { req.syncReq = false; req.pConn = &conn; req.pNodeList = qnodeList; - req.pDag = &dag; + req.pDag = dag; req.sql = "select * from tb"; req.execFp = schtQueryCb; req.cbParam = &queryDone; @@ -503,7 +573,7 @@ void *schtRunJobThread(void *aa) { pJob = schAcquireJob(queryJobRefId); if (NULL == pJob) { taosArrayDestroy(qnodeList); - schtFreeQueryDag(&dag); + schtFreeQueryDag(dag); continue; } @@ -526,11 +596,14 @@ void *schtRunJobThread(void *aa) { SSchTask *task = (SSchTask *)pIter; param->taskId = task->taskId; - SQueryTableRsp rsp = {0}; - dataBuf.pData = &rsp; - dataBuf.len = sizeof(rsp); - code = schHandleCallback(param, &dataBuf, TDMT_SCH_QUERY_RSP, 0); + SDataBuf msg = {0}; + void* rmsg = NULL; + schtBuildQueryRspMsg(&msg.len, &rmsg); + msg.msgType = TDMT_SCH_QUERY_RSP; + msg.pData = rmsg; + + code = schHandleCallback(param, &msg, 0); assert(code == 0 || code); pIter = taosHashIterate(execTasks, pIter); @@ -545,11 +618,13 @@ void *schtRunJobThread(void *aa) { SSchTask *task = (SSchTask *)pIter; param->taskId = task->taskId - 1; - SQueryTableRsp rsp = {0}; - dataBuf.pData = &rsp; - dataBuf.len = sizeof(rsp); + SDataBuf msg = {0}; + void* rmsg = NULL; + schtBuildQueryRspMsg(&msg.len, &rmsg); + msg.msgType = TDMT_SCH_QUERY_RSP; + msg.pData = rmsg; - code = schHandleCallback(param, &dataBuf, TDMT_SCH_QUERY_RSP, 0); + code = schHandleCallback(param, &msg, 0); assert(code == 0 || code); pIter = taosHashIterate(execTasks, pIter); @@ -575,7 +650,6 @@ void *schtRunJobThread(void *aa) { if (0 == code) { SRetrieveTableRsp *pRsp = (SRetrieveTableRsp *)data; assert(pRsp->completed == 1); - assert(pRsp->numOfRows == 10); } data = NULL; @@ -587,7 +661,7 @@ void *schtRunJobThread(void *aa) { taosHashCleanup(execTasks); taosArrayDestroy(qnodeList); - schtFreeQueryDag(&dag); + schtFreeQueryDag(dag); if (++jobFinished % schtTestPrintNum == 0) { printf("jobFinished:%d\n", jobFinished); @@ -609,6 +683,7 @@ void *schtFreeJobThread(void *aa) { return NULL; } + } // namespace TEST(queryTest, normalCase) { @@ -618,21 +693,20 @@ TEST(queryTest, normalCase) { char *tablename = "table1"; SVgroupInfo vgInfo = {0}; int64_t job = 0; - SQueryPlan dag; + SQueryPlan* dag = (SQueryPlan*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN); - memset(&dag, 0, sizeof(dag)); + SArray *qnodeList = taosArrayInit(1, sizeof(SQueryNodeLoad)); - SArray *qnodeList = taosArrayInit(1, sizeof(SEp)); - - SEp qnodeAddr = {0}; - strcpy(qnodeAddr.fqdn, "qnode0.ep"); - qnodeAddr.port = 6031; - taosArrayPush(qnodeList, &qnodeAddr); + SQueryNodeLoad load = {0}; + load.addr.epSet.numOfEps = 1; + strcpy(load.addr.epSet.eps[0].fqdn, "qnode0.ep"); + load.addr.epSet.eps[0].port = 6031; + taosArrayPush(qnodeList, &load); int32_t code = schedulerInit(); ASSERT_EQ(code, 0); - schtBuildQueryDag(&dag); + schtBuildQueryDag(dag); schtSetPlanToString(); schtSetExecNode(); @@ -645,7 +719,7 @@ TEST(queryTest, normalCase) { SSchedulerReq req = {0}; req.pConn = &conn; req.pNodeList = qnodeList; - req.pDag = &dag; + req.pDag = dag; req.sql = "select * from tb"; req.execFp = schtQueryCb; req.cbParam = &queryDone; @@ -659,9 +733,14 @@ TEST(queryTest, normalCase) { while (pIter) { SSchTask *task = *(SSchTask **)pIter; - SQueryTableRsp rsp = {0}; - code = schHandleResponseMsg(pJob, task, TDMT_SCH_QUERY_RSP, (char *)&rsp, sizeof(rsp), 0); - + SDataBuf msg = {0}; + void* rmsg = NULL; + schtBuildQueryRspMsg(&msg.len, &rmsg); + msg.msgType = TDMT_SCH_QUERY_RSP; + msg.pData = rmsg; + + code = schHandleResponseMsg(pJob, task, task->execId, &msg, 0); + ASSERT_EQ(code, 0); pIter = taosHashIterate(pJob->execTasks, pIter); } @@ -669,11 +748,18 @@ TEST(queryTest, normalCase) { pIter = taosHashIterate(pJob->execTasks, NULL); while (pIter) { SSchTask *task = *(SSchTask **)pIter; + if (JOB_TASK_STATUS_EXEC == task->status) { + SDataBuf msg = {0}; + void* rmsg = NULL; + schtBuildQueryRspMsg(&msg.len, &rmsg); + msg.msgType = TDMT_SCH_QUERY_RSP; + msg.pData = rmsg; + + code = schHandleResponseMsg(pJob, task, task->execId, &msg, 0); + + ASSERT_EQ(code, 0); + } - SQueryTableRsp rsp = {0}; - code = schHandleResponseMsg(pJob, task, TDMT_SCH_QUERY_RSP, (char *)&rsp, sizeof(rsp), 0); - - ASSERT_EQ(code, 0); pIter = taosHashIterate(pJob->execTasks, pIter); } @@ -703,18 +789,12 @@ TEST(queryTest, normalCase) { ASSERT_EQ(pRsp->numOfRows, 10); taosMemoryFreeClear(data); - data = NULL; - code = schedulerFetchRows(job, &req); - ASSERT_EQ(code, 0); - ASSERT_TRUE(data == NULL); - schReleaseJob(job); + + schedulerDestroy(); schedulerFreeJob(&job, 0); - schtFreeQueryDag(&dag); - - schedulerDestroy(); } TEST(queryTest, readyFirstCase) { @@ -724,21 +804,20 @@ TEST(queryTest, readyFirstCase) { char *tablename = "table1"; SVgroupInfo vgInfo = {0}; int64_t job = 0; - SQueryPlan dag; + SQueryPlan* dag = (SQueryPlan*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN); - memset(&dag, 0, sizeof(dag)); + SArray *qnodeList = taosArrayInit(1, sizeof(SQueryNodeLoad)); - SArray *qnodeList = taosArrayInit(1, sizeof(SEp)); - - SEp qnodeAddr = {0}; - strcpy(qnodeAddr.fqdn, "qnode0.ep"); - qnodeAddr.port = 6031; - taosArrayPush(qnodeList, &qnodeAddr); + SQueryNodeLoad load = {0}; + load.addr.epSet.numOfEps = 1; + strcpy(load.addr.epSet.eps[0].fqdn, "qnode0.ep"); + load.addr.epSet.eps[0].port = 6031; + taosArrayPush(qnodeList, &load); int32_t code = schedulerInit(); ASSERT_EQ(code, 0); - schtBuildQueryDag(&dag); + schtBuildQueryDag(dag); schtSetPlanToString(); schtSetExecNode(); @@ -751,7 +830,7 @@ TEST(queryTest, readyFirstCase) { SSchedulerReq req = {0}; req.pConn = &conn; req.pNodeList = qnodeList; - req.pDag = &dag; + req.pDag = dag; req.sql = "select * from tb"; req.execFp = schtQueryCb; req.cbParam = &queryDone; @@ -764,8 +843,13 @@ TEST(queryTest, readyFirstCase) { while (pIter) { SSchTask *task = *(SSchTask **)pIter; - SQueryTableRsp rsp = {0}; - code = schHandleResponseMsg(pJob, task, TDMT_SCH_QUERY_RSP, (char *)&rsp, sizeof(rsp), 0); + SDataBuf msg = {0}; + void* rmsg = NULL; + schtBuildQueryRspMsg(&msg.len, &rmsg); + msg.msgType = TDMT_SCH_QUERY_RSP; + msg.pData = rmsg; + + code = schHandleResponseMsg(pJob, task, task->execId, &msg, 0); ASSERT_EQ(code, 0); pIter = taosHashIterate(pJob->execTasks, pIter); @@ -775,10 +859,18 @@ TEST(queryTest, readyFirstCase) { while (pIter) { SSchTask *task = *(SSchTask **)pIter; - SQueryTableRsp rsp = {0}; - code = schHandleResponseMsg(pJob, task, TDMT_SCH_QUERY_RSP, (char *)&rsp, sizeof(rsp), 0); + if (JOB_TASK_STATUS_EXEC == task->status) { + SDataBuf msg = {0}; + void* rmsg = NULL; + schtBuildQueryRspMsg(&msg.len, &rmsg); + msg.msgType = TDMT_SCH_QUERY_RSP; + msg.pData = rmsg; + + code = schHandleResponseMsg(pJob, task, task->execId, &msg, 0); + + ASSERT_EQ(code, 0); + } - ASSERT_EQ(code, 0); pIter = taosHashIterate(pJob->execTasks, pIter); } @@ -807,18 +899,11 @@ TEST(queryTest, readyFirstCase) { ASSERT_EQ(pRsp->numOfRows, 10); taosMemoryFreeClear(data); - data = NULL; - code = schedulerFetchRows(job, &req); - ASSERT_EQ(code, 0); - ASSERT_TRUE(data == NULL); - schReleaseJob(job); - schedulerFreeJob(&job, 0); - - schtFreeQueryDag(&dag); - schedulerDestroy(); + + schedulerFreeJob(&job, 0); } TEST(queryTest, flowCtrlCase) { @@ -828,35 +913,39 @@ TEST(queryTest, flowCtrlCase) { char *tablename = "table1"; SVgroupInfo vgInfo = {0}; int64_t job = 0; - SQueryPlan dag; + SQueryPlan* dag = (SQueryPlan*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN); schtInitLogFile(); taosSeedRand(taosGetTimestampSec()); - SArray *qnodeList = taosArrayInit(1, sizeof(SEp)); + SArray *qnodeList = taosArrayInit(1, sizeof(SQueryNodeLoad)); + + SQueryNodeLoad load = {0}; + load.addr.epSet.numOfEps = 1; + strcpy(load.addr.epSet.eps[0].fqdn, "qnode0.ep"); + load.addr.epSet.eps[0].port = 6031; + taosArrayPush(qnodeList, &load); - SEp qnodeAddr = {0}; - strcpy(qnodeAddr.fqdn, "qnode0.ep"); - qnodeAddr.port = 6031; - taosArrayPush(qnodeList, &qnodeAddr); int32_t code = schedulerInit(); ASSERT_EQ(code, 0); - schtBuildQueryFlowCtrlDag(&dag); + schtBuildQueryFlowCtrlDag(dag); schtSetPlanToString(); schtSetExecNode(); schtSetAsyncSendMsgToServer(); + initTaskQueue(); + int32_t queryDone = 0; SRequestConnInfo conn = {0}; conn.pTrans = mockPointer; SSchedulerReq req = {0}; req.pConn = &conn; req.pNodeList = qnodeList; - req.pDag = &dag; + req.pDag = dag; req.sql = "select * from tb"; req.execFp = schtQueryCb; req.cbParam = &queryDone; @@ -866,41 +955,27 @@ TEST(queryTest, flowCtrlCase) { SSchJob *pJob = schAcquireJob(job); - bool qDone = false; - - while (!qDone) { + while (!queryDone) { void *pIter = taosHashIterate(pJob->execTasks, NULL); - if (NULL == pIter) { - break; - } - while (pIter) { SSchTask *task = *(SSchTask **)pIter; - taosHashCancelIterate(pJob->execTasks, pIter); - - if (task->lastMsgType == TDMT_SCH_QUERY) { - SQueryTableRsp rsp = {0}; - code = schHandleResponseMsg(pJob, task, TDMT_SCH_QUERY_RSP, (char *)&rsp, sizeof(rsp), 0); - + if (JOB_TASK_STATUS_EXEC == task->status && 0 != task->lastMsgType) { + SDataBuf msg = {0}; + void* rmsg = NULL; + schtBuildQueryRspMsg(&msg.len, &rmsg); + msg.msgType = TDMT_SCH_QUERY_RSP; + msg.pData = rmsg; + + code = schHandleResponseMsg(pJob, task, task->execId, &msg, 0); + ASSERT_EQ(code, 0); - } else { - qDone = true; - break; } - pIter = NULL; + pIter = taosHashIterate(pJob->execTasks, pIter); } } - while (true) { - if (queryDone) { - break; - } - - taosUsleep(10000); - } - TdThreadAttr thattr; taosThreadAttrInit(&thattr); @@ -918,18 +993,11 @@ TEST(queryTest, flowCtrlCase) { ASSERT_EQ(pRsp->numOfRows, 10); taosMemoryFreeClear(data); - data = NULL; - code = schedulerFetchRows(job, &req); - ASSERT_EQ(code, 0); - ASSERT_TRUE(data == NULL); - schReleaseJob(job); - schedulerFreeJob(&job, 0); - - schtFreeQueryDag(&dag); - schedulerDestroy(); + + schedulerFreeJob(&job, 0); } TEST(insertTest, normalCase) { @@ -938,20 +1006,21 @@ TEST(insertTest, normalCase) { char *dbname = "1.db1"; char *tablename = "table1"; SVgroupInfo vgInfo = {0}; - SQueryPlan dag; + SQueryPlan* dag = (SQueryPlan*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN); uint64_t numOfRows = 0; - SArray *qnodeList = taosArrayInit(1, sizeof(SEp)); + SArray *qnodeList = taosArrayInit(1, sizeof(SQueryNodeLoad)); - SEp qnodeAddr = {0}; - strcpy(qnodeAddr.fqdn, "qnode0.ep"); - qnodeAddr.port = 6031; - taosArrayPush(qnodeList, &qnodeAddr); + SQueryNodeLoad load = {0}; + load.addr.epSet.numOfEps = 1; + strcpy(load.addr.epSet.eps[0].fqdn, "qnode0.ep"); + load.addr.epSet.eps[0].port = 6031; + taosArrayPush(qnodeList, &load); int32_t code = schedulerInit(); ASSERT_EQ(code, 0); - schtBuildInsertDag(&dag); + schtBuildInsertDag(dag); schtSetPlanToString(); schtSetAsyncSendMsgToServer(); @@ -962,21 +1031,19 @@ TEST(insertTest, normalCase) { TdThread thread1; taosThreadCreate(&(thread1), &thattr, schtSendRsp, &insertJobRefId); - SExecResult res = {0}; - + int32_t queryDone = 0; SRequestConnInfo conn = {0}; conn.pTrans = mockPointer; SSchedulerReq req = {0}; req.pConn = &conn; req.pNodeList = qnodeList; - req.pDag = &dag; + req.pDag = dag; req.sql = "insert into tb values(now,1)"; req.execFp = schtQueryCb; - req.cbParam = NULL; + req.cbParam = &queryDone; code = schedulerExecJob(&req, &insertJobRefId); ASSERT_EQ(code, 0); - ASSERT_EQ(res.numOfRows, 20); schedulerFreeJob(&insertJobRefId, 0); @@ -989,7 +1056,7 @@ TEST(multiThread, forceFree) { TdThread thread1, thread2, thread3; taosThreadCreate(&(thread1), &thattr, schtRunJobThread, NULL); - taosThreadCreate(&(thread2), &thattr, schtFreeJobThread, NULL); +// taosThreadCreate(&(thread2), &thattr, schtFreeJobThread, NULL); taosThreadCreate(&(thread3), &thattr, schtFetchRspThread, NULL); while (true) { @@ -1002,7 +1069,7 @@ TEST(multiThread, forceFree) { } schtTestStop = true; - taosSsleep(3); + //taosSsleep(3); } int main(int argc, char **argv) { diff --git a/source/libs/stream/src/streamDispatch.c b/source/libs/stream/src/streamDispatch.c index 98d9a29c87..626f7fc161 100644 --- a/source/libs/stream/src/streamDispatch.c +++ b/source/libs/stream/src/streamDispatch.c @@ -569,6 +569,7 @@ int32_t streamSearchAndAddBlock(SStreamTask* pTask, SStreamDispatchReq* pReqs, S char ctbName[TSDB_TABLE_FNAME_LEN] = {0}; if (pDataBlock->info.parTbName[0]) { if(pTask->ver >= SSTREAM_TASK_SUBTABLE_CHANGED_VER && + pTask->subtableWithoutMd5 != 1 && !isAutoTableName(pDataBlock->info.parTbName) && !alreadyAddGroupId(pDataBlock->info.parTbName) && groupId != 0){ diff --git a/source/libs/stream/src/streamTask.c b/source/libs/stream/src/streamTask.c index b74a45b5cf..281e2ed550 100644 --- a/source/libs/stream/src/streamTask.c +++ b/source/libs/stream/src/streamTask.c @@ -80,7 +80,7 @@ static SStreamChildEpInfo* createStreamTaskEpInfo(const SStreamTask* pTask) { } SStreamTask* tNewStreamTask(int64_t streamId, int8_t taskLevel, SEpSet* pEpset, bool fillHistory, int64_t triggerParam, - SArray* pTaskList, bool hasFillhistory) { + SArray* pTaskList, bool hasFillhistory, int8_t subtableWithoutMd5) { SStreamTask* pTask = (SStreamTask*)taosMemoryCalloc(1, sizeof(SStreamTask)); if (pTask == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; @@ -96,6 +96,7 @@ SStreamTask* tNewStreamTask(int64_t streamId, int8_t taskLevel, SEpSet* pEpset, pTask->info.taskLevel = taskLevel; pTask->info.fillHistory = fillHistory; pTask->info.triggerParam = triggerParam; + pTask->subtableWithoutMd5 = subtableWithoutMd5; pTask->status.pSM = streamCreateStateMachine(pTask); if (pTask->status.pSM == NULL) { @@ -203,6 +204,7 @@ int32_t tEncodeStreamTask(SEncoder* pEncoder, const SStreamTask* pTask) { if (tEncodeCStr(pEncoder, pTask->outputInfo.shuffleDispatcher.stbFullName) < 0) return -1; } if (tEncodeI64(pEncoder, pTask->info.triggerParam) < 0) return -1; + if (tEncodeI8(pEncoder, pTask->subtableWithoutMd5) < 0) return -1; if (tEncodeCStrWithLen(pEncoder, pTask->reserve, sizeof(pTask->reserve) - 1) < 0) return -1; tEndEncode(pEncoder); @@ -285,6 +287,7 @@ int32_t tDecodeStreamTask(SDecoder* pDecoder, SStreamTask* pTask) { if (tDecodeCStrTo(pDecoder, pTask->outputInfo.shuffleDispatcher.stbFullName) < 0) return -1; } if (tDecodeI64(pDecoder, &pTask->info.triggerParam) < 0) return -1; + if (tDecodeI8(pDecoder, &pTask->subtableWithoutMd5) < 0) return -1; if (tDecodeCStrTo(pDecoder, pTask->reserve) < 0) return -1; tEndDecode(pDecoder); @@ -479,7 +482,7 @@ int32_t streamTaskInit(SStreamTask* pTask, SStreamMeta* pMeta, SMsgCb* pMsgCb, i pTask->execInfo.created = taosGetTimestampMs(); SCheckpointInfo* pChkInfo = &pTask->chkInfo; - SDataRange* pRange = &pTask->dataRange; + SDataRange* pRange = &pTask->dataRange; // only set the version info for stream tasks without fill-history task if (pTask->info.taskLevel == TASK_LEVEL__SOURCE) { @@ -753,8 +756,8 @@ int8_t streamTaskSetSchedStatusInactive(SStreamTask* pTask) { } int32_t streamTaskClearHTaskAttr(SStreamTask* pTask, int32_t resetRelHalt, bool metaLock) { - SStreamMeta* pMeta = pTask->pMeta; - STaskId sTaskId = {.streamId = pTask->streamTaskId.streamId, .taskId = pTask->streamTaskId.taskId}; + SStreamMeta* pMeta = pTask->pMeta; + STaskId sTaskId = {.streamId = pTask->streamTaskId.streamId, .taskId = pTask->streamTaskId.taskId}; if (pTask->info.fillHistory == 0) { return 0; } @@ -868,7 +871,7 @@ void streamTaskPause(SStreamMeta* pMeta, SStreamTask* pTask) { void streamTaskResume(SStreamTask* pTask) { SStreamTaskState prevState = *streamTaskGetStatus(pTask); - SStreamMeta* pMeta = pTask->pMeta; + SStreamMeta* pMeta = pTask->pMeta; if (prevState.state == TASK_STATUS__PAUSE || prevState.state == TASK_STATUS__HALT) { streamTaskRestoreStatus(pTask); @@ -885,9 +888,7 @@ void streamTaskResume(SStreamTask* pTask) { } } -bool streamTaskIsSinkTask(const SStreamTask* pTask) { - return pTask->info.taskLevel == TASK_LEVEL__SINK; -} +bool streamTaskIsSinkTask(const SStreamTask* pTask) { return pTask->info.taskLevel == TASK_LEVEL__SINK; } int32_t streamTaskSendCheckpointReq(SStreamTask* pTask) { int32_t code; diff --git a/source/libs/stream/src/streamUpdate.c b/source/libs/stream/src/streamUpdate.c index d607f26de3..454ed4297c 100644 --- a/source/libs/stream/src/streamUpdate.c +++ b/source/libs/stream/src/streamUpdate.c @@ -261,6 +261,7 @@ void updateInfoDestroy(SUpdateInfo *pInfo) { taosArrayDestroy(pInfo->pTsSBFs); taosHashCleanup(pInfo->pMap); + updateInfoDestoryColseWinSBF(pInfo); taosMemoryFree(pInfo); } diff --git a/source/libs/transport/src/trans.c b/source/libs/transport/src/trans.c index 64302a78fc..f658947144 100644 --- a/source/libs/transport/src/trans.c +++ b/source/libs/transport/src/trans.c @@ -140,11 +140,7 @@ void* rpcMallocCont(int64_t contLen) { return start + sizeof(STransMsgHead); } -void rpcFreeCont(void* cont) { - if (cont == NULL) return; - taosMemoryFree((char*)cont - TRANS_MSG_OVERHEAD); - tTrace("rpc free cont:%p", (char*)cont - TRANS_MSG_OVERHEAD); -} +void rpcFreeCont(void* cont) { transFreeMsg(cont); } void* rpcReallocCont(void* ptr, int64_t contLen) { if (ptr == NULL) return rpcMallocCont(contLen); diff --git a/source/libs/transport/src/transCli.c b/source/libs/transport/src/transCli.c index b6942655a9..798a5bf54f 100644 --- a/source/libs/transport/src/transCli.c +++ b/source/libs/transport/src/transCli.c @@ -218,7 +218,6 @@ static void (*cliAsyncHandle[])(SCliMsg* pMsg, SCliThrd* pThrd) = {cliHandleReq, /// static void (*cliAsyncHandle[])(SCliMsg* pMsg, SCliThrd* pThrd) = {cliHandleReq, cliHandleQuit, cliHandleRelease, /// NULL,cliHandleUpdate}; -static FORCE_INLINE void destroyUserdata(STransMsg* userdata); static FORCE_INLINE void destroyCmsg(void* cmsg); static FORCE_INLINE void destroyCmsgAndAhandle(void* cmsg); static FORCE_INLINE int cliRBChoseIdx(STrans* pTransInst); @@ -1950,14 +1949,6 @@ _err: return NULL; } -static FORCE_INLINE void destroyUserdata(STransMsg* userdata) { - if (userdata->pCont == NULL) { - return; - } - transFreeMsg(userdata->pCont); - userdata->pCont = NULL; -} - static FORCE_INLINE void destroyCmsg(void* arg) { SCliMsg* pMsg = arg; if (pMsg == NULL) { @@ -1965,7 +1956,7 @@ static FORCE_INLINE void destroyCmsg(void* arg) { } transDestroyConnCtx(pMsg->ctx); - destroyUserdata(&pMsg->msg); + transFreeMsg(pMsg->msg.pCont); taosMemoryFree(pMsg); } @@ -1984,7 +1975,7 @@ static FORCE_INLINE void destroyCmsgAndAhandle(void* param) { tDebug("destroy Ahandle C"); transDestroyConnCtx(pMsg->ctx); - destroyUserdata(&pMsg->msg); + transFreeMsg(pMsg->msg.pCont); taosMemoryFree(pMsg); } diff --git a/source/libs/transport/src/transComm.c b/source/libs/transport/src/transComm.c index b1fb9a2450..4619722743 100644 --- a/source/libs/transport/src/transComm.c +++ b/source/libs/transport/src/transComm.c @@ -87,6 +87,7 @@ void transFreeMsg(void* msg) { if (msg == NULL) { return; } + tTrace("rpc free cont:%p", (char*)msg - TRANS_MSG_OVERHEAD); taosMemoryFree((char*)msg - sizeof(STransMsgHead)); } int transSockInfo2Str(struct sockaddr* sockname, char* dst) { diff --git a/tests/parallel_test/cases.task b/tests/parallel_test/cases.task index 539e9e4c7b..d12a1e5837 100644 --- a/tests/parallel_test/cases.task +++ b/tests/parallel_test/cases.task @@ -575,6 +575,7 @@ ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/ts_3405_3398_3423.py -N 3 -n 3 ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/ts-4348-td-27939.py ,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/backslash_g.py +,,y,system-test,./pytest.sh python3 ./test.py -f 2-query/test_ts4467.py ,,n,system-test,python3 ./test.py -f 2-query/queryQnode.py ,,y,system-test,./pytest.sh python3 ./test.py -f 6-cluster/5dnode1mnode.py diff --git a/tests/script/tsim/parser/like.sim b/tests/script/tsim/parser/like.sim index 5cac026b57..298dbce0e5 100644 --- a/tests/script/tsim/parser/like.sim +++ b/tests/script/tsim/parser/like.sim @@ -51,6 +51,22 @@ if $rows != 1 then return -1 endi +$view1 = view1_name +$view2 = view2_name + +sql CREATE VIEW $view1 as select * from $table1 +sql CREATE VIEW $view2 AS select * from $table2 + +sql show views like 'view%' +if $rows != 2 then + return -1 +endi + +sql show views like 'view1%' +if $rows != 1 then + return -1 +endi + system sh/exec.sh -n dnode1 -s stop -x SIGINT diff --git a/tests/script/tsim/query/query_count1.sim b/tests/script/tsim/query/query_count1.sim new file mode 100644 index 0000000000..0694ab062a --- /dev/null +++ b/tests/script/tsim/query/query_count1.sim @@ -0,0 +1,83 @@ +system sh/stop_dnodes.sh +system sh/deploy.sh -n dnode1 -i 1 +system sh/exec.sh -n dnode1 -s start +sleep 50 +sql connect + +print step1 +print =============== create database +sql create database test vgroups 4; +sql use test; + +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 insert into t1 values(1648791213000,0,1,1,1.0); +sql insert into t1 values(1648791213001,9,1,2,1.1); +sql insert into t1 values(1648791213009,0,1,3,1.0); + +sql insert into t2 values(1648791213000,0,1,4,1.0); +sql insert into t2 values(1648791213001,9,1,5,1.1); +sql insert into t2 values(1648791213009,0,1,6,1.0); + +sql insert into t1 values(1648791223000,0,1,7,1.0); +sql insert into t1 values(1648791223001,9,1,8,1.1); +sql insert into t1 values(1648791223009,0,1,9,1.0); + +sql insert into t2 values(1648791223000,0,1,10,1.0); +sql insert into t2 values(1648791223001,9,1,11,1.1); +sql insert into t2 values(1648791223009,0,1,12,1.0); + +$loop_count = 0 +loop3: + +sleep 300 +print 1 sql select _wstart as s, count(*) c1, sum(b), max(c) from st count_window(4); +sql select _wstart as s, count(*) c1, sum(b), max(c) from st count_window(4); + +print $data00 $data01 $data02 $data03 +print $data10 $data11 $data12 $data13 +print $data20 $data21 $data22 $data23 +print $data30 $data31 $data32 $data33 + +$loop_count = $loop_count + 1 +if $loop_count == 10 then + return -1 +endi + +# row 0 +if $data01 != 4 then + print ======data01=$data01 + goto loop3 +endi + +if $data02 != 4 then + print ======data02=$data02 + goto loop3 +endi + +# row 1 +if $data11 != 4 then + print ======data11=$data11 + goto loop3 +endi + +if $data12 != 4 then + print ======data12=$data12 + goto loop3 +endi + +# row 2 +if $data21 != 4 then + print ======data21=$data21 + goto loop3 +endi + +if $data22 != 4 then + print ======data22=$data22 + goto loop3 +endi + +print query_count0 end +system sh/exec.sh -n dnode1 -s stop -x SIGINT diff --git a/tests/script/tsim/query/query_count_sliding0.sim b/tests/script/tsim/query/query_count_sliding0.sim index 2363259194..464aec6b97 100644 --- a/tests/script/tsim/query/query_count_sliding0.sim +++ b/tests/script/tsim/query/query_count_sliding0.sim @@ -540,5 +540,131 @@ if $rows != 9 then print ======rows=$rows goto loop12 endi + + + +print step3 +print =============== create database +sql create database test3 vgroups 4; +sql use test3; + +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 insert into t1 values(1648791213000,0,1,1,1.0); +sql insert into t1 values(1648791213001,9,1,2,1.1); +sql insert into t1 values(1648791213009,0,1,3,1.0); + +sql insert into t2 values(1648791213000,0,1,4,1.0); +sql insert into t2 values(1648791213001,9,1,5,1.1); +sql insert into t2 values(1648791213009,0,1,6,1.0); + +sql insert into t1 values(1648791223000,0,1,7,1.0); +sql insert into t1 values(1648791223001,9,1,8,1.1); +sql insert into t1 values(1648791223009,0,1,9,1.0); + +sql insert into t2 values(1648791223000,0,1,10,1.0); +sql insert into t2 values(1648791223001,9,1,11,1.1); +sql insert into t2 values(1648791223009,0,1,12,1.0); + +$loop_count = 0 +loop13: + +sleep 300 +print 1 sql select _wstart as s, count(*) c1, sum(b), max(c) from st count_window(4, 1); +sql select _wstart as s, count(*) c1, sum(b), max(c) from st count_window(4,1); + +print $data00 $data01 $data02 $data03 +print $data10 $data11 $data12 $data13 +print $data20 $data21 $data22 $data23 +print $data30 $data31 $data32 $data33 +print $data40 $data41 $data42 $data43 +print $data50 $data51 $data52 $data53 +print $data60 $data61 $data62 $data63 +print $data70 $data71 $data72 $data73 +print $data80 $data81 $data82 $data83 +print $data90 $data91 $data92 $data93 +print $data[10][0] $data[10][1] $data[10][2] $data[10][3] +print $data[11][0] $data[11][1] $data[11][2] $data[11][3] +print $data[12][0] $data[12][1] $data[12][2] $data[12][3] + +$loop_count = $loop_count + 1 +if $loop_count == 10 then + return -1 +endi + +# rows +if $rows != 12 then + print ======rows=$rows + goto loop13 +endi + +# row 0 +if $data01 != 4 then + print ======data01=$data01 + goto loop13 +endi + +if $data02 != 4 then + print ======data02=$data02 + goto loop13 +endi + +# row 1 +if $data11 != 4 then + print ======data11=$data11 + goto loop13 +endi + +if $data12 != 4 then + print ======data12=$data12 + goto loop13 +endi + +# row 2 +if $data21 != 4 then + print ======data21=$data21 + goto loop13 +endi + +if $data22 != 4 then + print ======data22=$data22 + goto loop13 +endi + +# row 9 +if $data91 != 3 then + print ======data91=$data91 + goto loop13 +endi + +if $data92 != 3 then + print ======data92=$data92 + goto loop13 +endi + +# row 10 +if $data[10][1] != 2 then + print ======data[10][1]=$data[10][1] + goto loop13 +endi + +if $data[10][2] != 2 then + print ======data[10][2]=$data[10][2] + goto loop13 +endi + +# row 11 +if $data[11][1] != 1 then + print ======data[11][1]=$data[11][1] + goto loop13 +endi + +if $data[11][2] != 1 then + print ======data[11][2]=$data[11][2] + goto loop13 +endi + print count sliding 0 end system sh/exec.sh -n dnode1 -s stop -x SIGINT diff --git a/tests/system-test/2-query/test_ts4467.py b/tests/system-test/2-query/test_ts4467.py new file mode 100644 index 0000000000..4e09a9fbbe --- /dev/null +++ b/tests/system-test/2-query/test_ts4467.py @@ -0,0 +1,63 @@ +import random +import itertools +from util.log import * +from util.cases import * +from util.sql import * +from util.sqlset import * +from util import constant +from util.common import * + + +class TDTestCase: + """Verify the jira TS-4467 + """ + def init(self, conn, logSql, replicaVar=1): + self.replicaVar = int(replicaVar) + tdLog.debug("start to execute %s" % __file__) + tdSql.init(conn.cursor()) + + def prepareData(self): + # db + tdSql.execute("create database if not exists db") + tdSql.execute("use db") + + # table + tdSql.execute("create table t (ts timestamp, c1 varchar(16));") + + # insert data + sql = "insert into t values" + for i in range(6): + sql += f"(now+{str(i+1)}s, '{'name' + str(i+1)}')" + sql += ";" + tdSql.execute(sql) + tdLog.debug("insert data successfully") + + def run(self): + self.prepareData() + + # join query with order by + sql = "select * from t t1, (select * from t order by ts limit 5) t2 where t1.ts = t2.ts;" + tdSql.query(sql) + tdSql.checkRows(5) + + sql = "select * from t t1, (select * from t order by ts desc limit 5) t2 where t1.ts = t2.ts;" + tdSql.query(sql) + tdSql.checkRows(5) + + sql = "select * from t t1, (select * from t order by ts limit 5) t2 where t1.ts = t2.ts order by t1.ts;" + tdSql.query(sql) + res1 = tdSql.queryResult + tdLog.debug("res1: %s" % str(res1)) + + sql = "select * from t t1, (select * from t order by ts limit 5) t2 where t1.ts = t2.ts order by t1.ts desc;" + tdSql.query(sql) + res2 = tdSql.queryResult + tdLog.debug("res2: %s" % str(res2)) + assert(len(res1) == len(res2) and res1[0][0] == res2[4][0]) + + def stop(self): + tdSql.close() + tdLog.success("%s successfully executed" % __file__) + +tdCases.addWindows(__file__, TDTestCase()) +tdCases.addLinux(__file__, TDTestCase())