提交 fc3d921b 编写于 作者: A Alex Duan

Merge branch 'develop' into feature/TS-238-D

......@@ -32,7 +32,7 @@ TDengine 是一款高性能、分布式、支持 SQL 的时序数据库。而且
## TDengine 总体适用场景
作为一个 IoT 大数据平台,TDengine 的典型适用场景是在 IoT 范畴,而且用户有一定的数据量。本文后续的介绍主要针对这个范畴里面的系统。范畴之外的系统,比如 CRM,ERP 等,不在本文讨论范围内
作为一个高性能、分布式、支持 SQL 的时序数据库,TDengine 的典型适用场景包括但不限于 IoT 和 DevOps,尤其是在大数据量的情况下。本文后续的介绍主要针对这些应用场景
### 数据源特点和需求
......
......@@ -9,7 +9,7 @@ TDengine 采用关系型数据模型,需要建库、建表。因此对于一
## 创建库
不同类型的数据采集点往往具有不同的数据特征,包括数据采集频率的高低,数据保留时间的长短,副本的数目,数据块的大小,是否允许更新数据等等。为了在各种场景下 TDengine 都能最大效率的工作,TDengine 建议将不同数据特征的表创建在不同的库里,因为每个库可以配置不同的存储策略。创建一个库时,除 SQL 标准的选项外,应用还可以指定保留时长、副本数、内存块个数、时间精度、文件块里最大最小记录条数、是否压缩、一个数据文件覆盖的天数等多种参数。比如:
不同类型的数据采集点往往具有不同的数据特征,包括数据采集频率的高低,数据保留时间的长短,副本的数目,数据块的大小,是否允许更新数据等等。为了在各种场景下 TDengine 都能最大效率的工作,TDengine 建议将不同数据特征的表创建在不同的库里,因为每个库可以配置不同的存储策略。创建一个库时,除 SQL 标准的选项外,还可以指定保留时长、副本数、内存块个数、时间精度、文件块里最大最小记录条数、是否压缩、一个数据文件覆盖的天数等多种参数。比如:
```sql
CREATE DATABASE power KEEP 365 DAYS 10 BLOCKS 6 UPDATE 1;
......@@ -27,7 +27,7 @@ USE power;
:::note
- 任何一张表或超级表是属于一个库的,在创建表之前,必须先创建库。
- 任何一张表或超级表必须属于某个库,在创建表之前,必须先创建库。
- 处于两个不同库的表是不能进行 JOIN 操作的。
- 创建并插入记录、查询历史记录的时候,均需要指定时间戳。
......@@ -45,9 +45,9 @@ CREATE STABLE meters (ts timestamp, current float, voltage int, phase float) TAG
这一指令中的 STABLE 关键字,在 2.0.15 之前的版本中需写作 TABLE 。
:::
与创建普通表一样,创建表时,需要提供表名(示例中为 meters),表结构 Schema,即数据列的定义。第一列必须为时间戳(示例中为 ts),其他列为采集的物理量(示例中为 current, voltage, phase),数据类型可以为整型、浮点型、字符串等。除此之外,还需要提供标签的 schema (示例中为 location, groupId),标签的数据类型可以为整型、浮点型、字符串等。采集点的静态属性往往可以作为标签,比如采集点的地理位置、设备型号、设备组 ID、管理员 ID 等等。标签的 schema 可以事后增加、删除、修改。具体定义以及细节请见 [TAOS SQL 的超级表管理](/reference/taos-sql/stable) 章节。
与创建普通表一样,创建超级表时,需要提供表名(示例中为 meters),表结构 Schema,即数据列的定义。第一列必须为时间戳(示例中为 ts),其他列为采集的物理量(示例中为 current, voltage, phase),数据类型可以为整型、浮点型、字符串等。除此之外,还需要提供标签的 schema (示例中为 location, groupId),标签的数据类型可以为整型、浮点型、字符串等。采集点的静态属性往往可以作为标签,比如采集点的地理位置、设备型号、设备组 ID、管理员 ID 等等。标签的 schema 可以事后增加、删除、修改。具体定义以及细节请见 [TAOS SQL 的超级表管理](/reference/taos-sql/stable) 章节。
每一种类型的数据采集点需要建立一个超级表,因此一个物联网系统,往往会有多个超级表。对于电网,我们就需要对智能电表、变压器、母线、开关等都建立一个超级表。在物联网中,一个设备就可能有多个数据采集点(比如一台风力发电的风机,有的采集点采集电流、电压等电参数,有的采集点采集温度、湿度、风向等环境参数),这个时候,对这一类型的设备,需要建立多张超级表。一张超级表里包含的采集物理量必须是同时采集的(时间戳是一致的)。
每一种类型的数据采集点需要建立一个超级表,因此一个物联网系统,往往会有多个超级表。对于电网,我们就需要对智能电表、变压器、母线、开关等都建立一个超级表。在物联网中,一个设备就可能有多个数据采集点(比如一台风力发电的风机,有的采集点采集电流、电压等电参数,有的采集点采集温度、湿度、风向等环境参数),这个时候,对这一类型的设备,需要建立多张超级表。
一张超级表最多容许 1024 列,如果一个采集点采集的物理量个数超过 1024,需要建多张超级表来处理。一个系统可以有多个 DB,一个 DB 里可以有一到多个超级表。(从 2.1.7.0 版本开始,列数限制由 1024 列放宽到了 4096 列。)
......
......@@ -85,7 +85,7 @@ INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6,
:::note
1. 无论 RESTFful 方式建立连接还是本地驱动方式建立连接,以上示例代码都能正常工作。
1. 无论 RESTful 方式建立连接还是本地驱动方式建立连接,以上示例代码都能正常工作。
2. 唯一需要注意的是:由于 RESTful 接口无状态, 不能使用 `use db` 语句来切换数据库, 所以在上面示例中使用了`dbName.tbName`指定表名。
:::
......
......@@ -13,6 +13,8 @@ import NodeLine from "./_js_line.mdx";
import CsLine from "./_cs_line.mdx";
import CLine from "./_c_line.mdx";
## InfluxDB Line 协议介绍
## 示例代码
<Tabs defaultValue="java" groupId="lang">
......
......@@ -147,7 +147,7 @@ Query OK, 5 row(s) in set (0.001521s)
:::note
1. 无论 RESTFful 方式建立连接还是本地驱动方式建立连接,以上示例代码都能正常工作。
1. 无论 RESTful 方式建立连接还是本地驱动方式建立连接,以上示例代码都能正常工作。
2. 唯一需要注意的是:由于 RESTful 接口无状态, 不能使用 `use db` 语句来切换数据库。
:::
......
......@@ -11,20 +11,20 @@ TDengine 能够与开源数据可视化系统 [Grafana](https://www.grafana.com/
## 配置 Grafana
TDengine 的 Grafana 插件托管在 GitHub,可从 <https://github.com/taosdata/grafanaplugin/releases/latest> 下载,当前最新版本为 3.1.3
TDengine 的 Grafana 插件托管在 GitHub,可从 <https://github.com/taosdata/grafanaplugin/releases/latest> 下载,当前最新版本为 3.1.4
推荐使用 [`grafana-cli` 命令行工具](https://grafana.com/docs/grafana/latest/administration/cli/) 进行插件安装。
```bash
sudo -u grafana grafana-cli \
--pluginUrl https://github.com/taosdata/grafanaplugin/releases/download/v3.1.3/tdengine-datasource-3.1.3.zip \
--pluginUrl https://github.com/taosdata/grafanaplugin/releases/download/v3.1.4/tdengine-datasource-3.1.4.zip \
plugins install tdengine-datasource
```
或者下载到本地并解压到 Grafana 插件目录。
```bash
GF_VERSION=3.1.3
GF_VERSION=3.1.4
wget https://github.com/taosdata/grafanaplugin/releases/download/v$GF_VERSION/tdengine-datasource-$GF_VERSION.zip
```
......@@ -44,7 +44,7 @@ allow_loading_unsigned_plugins = tdengine-datasource
在 Docker 环境下,可以使用如下的环境变量设置自动安装并设置 TDengine 插件:
```bash
GF_INSTALL_PLUGINS=https://github.com/taosdata/grafanaplugin/releases/download/v3.1.3/tdengine-datasource-3.1.3.zip;tdengine-datasource
GF_INSTALL_PLUGINS=https://github.com/taosdata/grafanaplugin/releases/download/v3.1.4/tdengine-datasource-3.1.4.zip;tdengine-datasource
GF_PLUGINS_ALLOW_LOADING_UNSIGNED_PLUGINS=tdengine-datasource
```
......
......@@ -7,7 +7,7 @@ title: collectd 写入
TDengine 新版本(2.3.0.0+)包含一个 taosAdapter 独立程序,负责接收包括 collectd 的多种应用的数据写入。
/etc/collectd/collectd.conf 文件中增加如下内容,其中 host 和 port 请填写 TDengine 和 taosAdapter 配置的实际值:
`/etc/collectd/collectd.conf` 文件中增加如下内容,其中 host 和 port 请填写 TDengine 和 taosAdapter 配置的实际值:
```
LoadPlugin network
......@@ -22,4 +22,4 @@ LoadPlugin network
sudo systemctl start collectd
```
taosAdapter 相关配置参数请参考 taosadapter --help 命令输出以及相关文档。
taosAdapter 相关配置参数请参考 `taosadapter --help` 命令输出以及相关文档。
......@@ -8,7 +8,7 @@ title: StatsD 直接写入
TDengine 新版本(2.3.0.0+)包含一个 taosAdapter 独立程序,负责接收包括 StatsD 的多种应用的数据写入。
config.js 文件中增加如下内容后启动 StatsD,其中 host 和 port 请填写 TDengine 和 taosAdapter 配置的实际值:
`config.js` 文件中增加如下内容后启动 StatsD,其中 host 和 port 请填写 TDengine 和 taosAdapter 配置的实际值:
```
backends 部分添加 "./backends/repeater"
......@@ -25,6 +25,5 @@ port: 8125
}
```
taosAdapter 相关配置参数请参考 taosadapter --help 命令输出以及相关文档。
taosAdapter 相关配置参数请参考 `taosadapter --help` 命令输出以及相关文档。
icinga2 可以收集监控和性能数据并写入 OpenTSDB,taosAdapter 可以支持接收 icinga2 的数据并写入到 TDengine 中。
......@@ -3,6 +3,13 @@ sidebar_label: icinga2
title: icinga2 写入
---
安装 icinga2
请参考[官方文档](https://icinga.com/docs/icinga-2/latest/doc/02-installation/)
TDengine 新版本(2.3.0.0+)包含一个 taosAdapter 独立程序,负责接收包括 icinga2 的多种应用的数据写入。
icinga2 可以收集监控和性能数据并写入 OpenTSDB,taosAdapter 可以支持接收 icinga2 的数据并写入到 TDengine 中。
- 参考链接 `https://icinga.com/docs/icinga-2/latest/doc/14-features/#opentsdb-writer` 使能 opentsdb-writer
- 使能 taosAdapter 配置项 opentsdb_telnet.enable
- 修改配置文件 /etc/icinga2/features-enabled/opentsdb.conf
......@@ -14,4 +21,4 @@ object OpenTsdbWriter "opentsdb" {
}
```
taosAdapter 相关配置参数请参考 taosadapter --help 命令输出以及相关文档。
\ No newline at end of file
taosAdapter 相关配置参数请参考 `taosadapter --help` 命令输出以及相关文档。
......@@ -3,9 +3,14 @@ sidebar_label: TCollector
title: TCollector 写入
---
TCollector 是一个在客户侧收集本地收集器并发送数据到 OpenTSDB 的进程,taosAdaapter 可以支持接收 TCollector 的数据并写入到 TDengine 中。
安装 TCollector
请参考[官方文档](http://opentsdb.net/docs/build/html/user_guide/utilities/tcollector.html#installation-of-tcollector)
使能 taosAdapter 配置项 opentsdb_telnet.enable
TDengine 新版本(2.3.0.0+)包含一个 taosAdapter 独立程序,负责接收包括 TCollector 的多种应用的数据写入。
TCollector 是一个在客户侧收集本地收集器并发送数据到 OpenTSDB 的进程,taosAdapter 可以支持接收 TCollector 的数据并写入到 TDengine 中。
使能 taosAdapter 配置项 `opentsdb_telnet.enable`
修改 TCollector 配置文件,修改 OpenTSDB 宿主机地址为 taosAdapter 被部署的地址,并修改端口号为 taosAdapter 使用的端口(默认 6049)。
taosAdapter 相关配置参数请参考 taosadapter --help 命令输出以及相关文档。
taosAdapter 相关配置参数请参考 `taosadapter --help` 命令输出以及相关文档。
......@@ -6,11 +6,11 @@ title: 集群部署
### 第零步
规划集群所有物理节点的 FQDN,将规划好的 FQDN 分别添加到每个物理节点的/etc/hostname;修改每个物理节点的/etc/hosts,将所有集群物理节点的 IP 与 FQDN 的对应添加好。【如部署了 DNS,请联系网络管理员在 DNS 上做好相关配置】
规划集群所有物理节点的 FQDN,将规划好的 FQDN 分别添加到每个物理节点的 /etc/hostname;修改每个物理节点的 /etc/hosts,将所有集群物理节点的 IP 与 FQDN 的对应添加好。【如部署了 DNS,请联系网络管理员在 DNS 上做好相关配置】
### 第一步
如果搭建集群的物理节点中,存有之前的测试数据、装过 1.X 的版本,或者装过其他版本的 TDengine,请先将其删除,并清空所有数据(如果需要保留原有数据,请联系涛思交付团队进行旧版本升级、数据迁移),具体步骤请参考博客《TDengine 多种安装包的安装和卸载》
如果搭建集群的物理节点中,存有之前的测试数据、装过 1.X 的版本,或者装过其他版本的 TDengine,请先将其删除,并清空所有数据(如果需要保留原有数据,请联系涛思交付团队进行旧版本升级、数据迁移),具体步骤请参考博客[《TDengine 多种安装包的安装和卸载》](https://www.taosdata.com/blog/2019/08/09/566.html)
:::note
因为 FQDN 的信息会写进文件,如果之前没有配置或者更改 FQDN,且启动了 TDengine。请一定在确保数据无用或者备份的前提下,清理一下之前的数据(rm -rf /var/lib/taos/\*);
......@@ -26,15 +26,15 @@ title: 集群部署
### 第三步
在所有物理节点安装 TDengine,且版本必须是一致的,但不要启动 taosd。安装时,提示输入是否要加入一个已经存在的 TDengine 集群时,第一个物理节点直接回车创建新集群,后续物理节点则输入该集群任何一个在线的物理节点的 FQDN:端口号(默认 6030)
在所有物理节点安装 TDengine,且版本必须是一致的,但不要启动 taosd。安装时,提示输入是否要加入一个已经存在的 TDengine 集群时,第一个物理节点直接回车创建新集群,后续物理节点则输入该集群任何一个在线的物理节点的 FQDN:端口号(默认 6030)
### 第四步
检查所有数据节点,以及应用程序所在物理节点的网络设置:
每个物理节点上执行命令 `hostname -f`,查看和确认所有节点的 hostname 是不相同的(应用驱动所在节点无需做此项检查)
每个物理节点上执行命令 `hostname -f`,查看和确认所有节点的 hostname 是不相同的(应用驱动所在节点无需做此项检查)
每个物理节点上执行 ping host,其中 host 是其他物理节点的 hostname,看能否 ping 通其它物理节点;如果不能 ping 通,需要检查网络设置,或/etc/hosts 文件(Windows 系统默认路径为 C:\Windows\system32\drivers\etc\hosts),或 DNS 的配置。如果无法 ping 通,是无法组成集群的;
每个物理节点上执行 ping host,其中 host 是其他物理节点的 hostname,看能否 ping 通其它物理节点;如果不能 ping 通,需要检查网络设置,或 /etc/hosts 文件(Windows 系统默认路径为 C:\Windows\system32\drivers\etc\hosts),或 DNS 的配置。如果无法 ping 通,是无法组成集群的;
从应用运行的物理节点,ping taosd 运行的数据节点,如果无法 ping 通,应用是无法连接 taosd 的,请检查应用所在物理节点的 DNS 设置或 hosts 文件;
......@@ -42,19 +42,19 @@ title: 集群部署
### 第五步
修改 TDengine 的配置文件(所有节点的文件/etc/taos/taos.cfg 都需要修改)。假设准备启动的第一个数据节点 End Point 为 h1.taosdata.com:6030,其与集群配置相关参数如下:
修改 TDengine 的配置文件(所有节点的文件 /etc/taos/taos.cfg 都需要修改)。假设准备启动的第一个数据节点 End Point 为 h1.taosdata.com:6030,其与集群配置相关参数如下:
```c
// firstEp 是每个数据节点首次启动后连接的第一个数据节点
firstEp h1.taosdata.com:6030
// 必须配置为本数据节点的FQDN,如果本机只有一个hostname, 可注释掉本项
// 必须配置为本数据节点的 FQDN,如果本机只有一个 hostname,可注释掉本项
fqdn h1.taosdata.com
// 配置本数据节点的端口号,缺省是6030
// 配置本数据节点的端口号,缺省是 6030
serverPort 6030
// 副本数为偶数的时候,需要配置,请参考《Arbitrator的使用》的部分
// 副本数为偶数的时候,需要配置,请参考《Arbitrator 的使用》的部分
arbitrator ha.taosdata.com:6042
```
......@@ -83,7 +83,7 @@ arbitrator ha.taosdata.com:6042
### 启动第一个数据节点
按照《立即开始》里的步骤,启动第一个数据节点,例如 h1.taosdata.com,然后执行 taos, 启动 taos shell,从 shell 里执行命令"SHOW dnodes;",如下所示:
按照《立即开始》里的步骤,启动第一个数据节点,例如 h1.taosdata.com,然后执行 taos,启动 taos shell,从 shell 里执行命令“SHOW DNODES”,如下所示:
```
Welcome to the TDengine shell from Linux, Client Version:2.0.0.0
......@@ -100,7 +100,7 @@ Query OK, 1 row(s) in set (0.006385s)
taos>
```
上述命令里,可以看到这个刚启动的这个数据节点的 End Point 是:h1.taos.com:6030,就是这个新集群的 firstEp。
上述命令里,可以看到刚启动的数据节点的 End Point 是:h1.taos.com:6030,就是这个新集群的 firstEp。
### 启动后续数据节点
......@@ -114,7 +114,7 @@ taos>
CREATE DNODE "h2.taos.com:6030";
```
将新数据节点的 End Point (准备工作中第四步获知的) 添加进集群的 EP 列表。"fqdn:port"需要用双引号引起来,否则出错。请注意将示例的“h2.taos.com:6030" 替换为这个新数据节点的 End Point。
将新数据节点的 End Point(准备工作中第四步获知的)添加进集群的 EP 列表。“fqdn:port”需要用双引号引起来,否则出错。请注意将示例的“h2.taos.com:6030” 替换为这个新数据节点的 End Point。
然后执行命令
......@@ -124,8 +124,8 @@ SHOW DNODES;
查看新节点是否被成功加入。如果该被加入的数据节点处于离线状态,请做两个检查:
查看该数据节点的 taosd 是否正常工作,如果没有正常运行,需要先检查为什么
查看该数据节点 taosd 日志文件 taosdlog.0 里前面几行日志(一般在/var/log/taos 目录),看日志里输出的该数据节点 fqdn 以及端口号是否为刚添加的 End Point。如果不一致,需要将正确的 End Point 添加进去。
查看该数据节点的 taosd 是否正常工作,如果没有正常运行,需要先检查为什么?
查看该数据节点 taosd 日志文件 taosdlog.0 里前面几行日志(一般在 /var/log/taos 目录),看日志里输出的该数据节点 fqdn 以及端口号是否为刚添加的 End Point。如果不一致,需要将正确的 End Point 添加进去。
按照上述步骤可以源源不断的将新的数据节点加入到集群。
:::tip
......
......@@ -6,17 +6,21 @@ title: 集群管理
上面已经介绍如何从零开始搭建集群。集群组建完后,还可以随时添加新的数据节点进行扩容,或删除数据节点,并检查集群当前状态。
提示:
:::note
以下所有执行命令的操作需要先登陆进 TDengine 系统,必要时请使用 root 权限。
添加数据节点
:::
## 添加数据节点
执行 CLI 程序 taos,执行:
```sql
CREATE DNODE "fqdn:port";
```
将新数据节点的 End Point 添加进集群的 EP 列表。"fqdn:port"需要用双引号引起来,否则出错。一个数据节点对外服务的 fqdn 和 port 可以通过配置文件 taos.cfg 进行配置,缺省是自动获取。【强烈不建议用自动获取方式来配置 FQDN,可能导致生成的数据节点的 End Point 不是所期望的】
将新数据节点的 End Point 添加进集群的 EP 列表。“fqdn:port“需要用双引号引起来,否则出错。一个数据节点对外服务的 fqdn 和 port 可以通过配置文件 taos.cfg 进行配置,缺省是自动获取。【强烈不建议用自动获取方式来配置 FQDN,可能导致生成的数据节点的 End Point 不是所期望的】
## 删除数据节点
......@@ -26,11 +30,11 @@ CREATE DNODE "fqdn:port";
DROP DNODE "fqdn:port | dnodeID";
```
通过"fqdn:port"或"dnodeID"来指定一个具体的节点都是可以的。其中 fqdn 是被删除的节点的 FQDN,port 是其对外服务器的端口号;dnodeID 可以通过 SHOW DNODES 获得。
通过“fqdn:port”或“dnodeID”来指定一个具体的节点都是可以的。其中 fqdn 是被删除的节点的 FQDN,port 是其对外服务器的端口号;dnodeID 可以通过 SHOW DNODES 获得。
:::warning
一个数据节点一旦被 drop 之后,不能重新加入集群。需要将此节点重新部署(清空数据文件夹)。集群在完成 drop dnode 操作之前,会将该 dnode 的数据迁移走。
数据节点一旦被 drop 之后,不能重新加入集群。需要将此节点重新部署(清空数据文件夹)。集群在完成 drop dnode 操作之前,会将该 dnode 的数据迁移走。
请注意 drop dnode 和 停止 taosd 进程是两个不同的概念,不要混淆:因为删除 dnode 之前要执行迁移数据的操作,因此被删除的 dnode 必须保持在线状态。待删除操作结束之后,才能停止 taosd 进程。
一个数据节点被 drop 之后,其他节点都会感知到这个 dnodeID 的删除操作,任何集群中的节点都不会再接收此 dnodeID 的请求。
dnodeID 是集群自动分配的,不得人工指定。它在生成时是递增的,不会重复。
......@@ -51,8 +55,8 @@ ALTER DNODE <source-dnodeId> BALANCE "VNODE:<vgId>-DNODE:<dest-dnodeId>";
:::warning
只有在集群的自动负载均衡选项关闭时(balance 设置为 0),才允许手动迁移。
只有处于正常工作状态的 vnode 才能被迁移:master/slave当处于 offline/unsynced/syncing 状态时,是不能迁移的。
只有在集群的自动负载均衡选项关闭时(balance 设置为 0),才允许手动迁移。
只有处于正常工作状态的 vnode 才能被迁移:master/slave当处于 offline/unsynced/syncing 状态时,是不能迁移的。
迁移前,务必核实目标 dnode 的资源足够:CPU、内存、硬盘。
:::
......@@ -65,11 +69,11 @@ ALTER DNODE <source-dnodeId> BALANCE "VNODE:<vgId>-DNODE:<dest-dnodeId>";
SHOW DNODES;
```
它将列出集群中所有的 dnode,每个 dnode 的 ID,end_point(fqdn:port),状态(ready, offline 等),vnode 数目,还未使用的 vnode 数目等信息。在添加或删除一个数据节点后,可以使用该命令查看。
它将列出集群中所有的 dnode,每个 dnode 的 ID,end_point(fqdn:port),状态(ready,offline 等),vnode 数目,还未使用的 vnode 数目等信息。在添加或删除一个数据节点后,可以使用该命令查看。
## 查看虚拟节点组
为充分利用多核技术,并提供 scalability,数据需要分片处理。因此 TDengine 会将一个 DB 的数据切分成多份,存放在多个 vnode 里。这些 vnode 可能分布在多个数据节点 dnode 里,这样就实现了水平扩展。一个 vnode 仅仅属于一个 DB,但一个 DB 可以有多个 vnode。vnode 是 mnode 根据当前系统资源的情况,自动进行分配的,无需任何人工干预。
为充分利用多核技术,并提供 scalability,数据需要分片处理。因此 TDengine 会将一个 DB 的数据切分成多份,存放在多个 vnode 里。这些 vnode 可能分布在多个数据节点 dnode 里,这样就实现了水平扩展。一个 vnode 仅仅属于一个 DB,但一个 DB 可以有多个 vnode。vnode 所在的数据节点是 mnode 根据当前系统资源的情况,自动进行分配的,无需任何人工干预。
执行 CLI 程序 taos,执行:
......
......@@ -2,17 +2,17 @@
title: 高可用与负载均衡
---
## vnode 的高可用性
## Vnode 的高可用性
TDengine 通过多副本的机制来提供系统的高可用性,包括 vnode 和 mnode 的高可用性。
vnode 的副本数是与 DB 关联的,一个集群里可以有多个 DB,根据运营的需求,每个 DB 可以配置不同的副本数。创建数据库时,通过参数 replica 指定副本数(缺省为 1)。如果副本数为 1,系统的可靠性无法保证,只要数据所在的节点宕机,就将无法提供服务。集群的节点数必须大于等于副本数,否则创建表时将返回错误"more dnodes are needed"。比如下面的命令将创建副本数为 3 的数据库 demo:
vnode 的副本数是与 DB 关联的,一个集群里可以有多个 DB,根据运营的需求,每个 DB 可以配置不同的副本数。创建数据库时,通过参数 replica 指定副本数(缺省为 1)。如果副本数为 1,系统的可靠性无法保证,只要数据所在的节点宕机,就将无法提供服务。集群的节点数必须大于等于副本数,否则创建表时将返回错误“more dnodes are needed”。比如下面的命令将创建副本数为 3 的数据库 demo:
```sql
CREATE DATABASE demo replica 3;
```
一个 DB 里的数据会被切片分到多个 vnode group,vnode group 里的 vnode 数目就是 DB 的副本数,同一个 vnode group 里各 vnode 的数据是完全一致的。为保证高可用性,vnode group 里的 vnode 一定要分布在不同的数据节点 dnode 里(实际部署时,需要在不同的物理机上),只要一个 vgroup 里超过半数的 vnode 处于工作状态,这个 vgroup 就能正常的对外服务。
一个 DB 里的数据会被切片分到多个 vnode group,vnode group 里的 vnode 数目就是 DB 的副本数,同一个 vnode group 里各 vnode 的数据是完全一致的。为保证高可用性,vnode group 里的 vnode 一定要分布在不同的数据节点 dnode 里(实际部署时,需要在不同的物理机上),只要一个 vnode group 里超过半数的 vnode 处于工作状态,这个 vnode group 就能正常的对外服务。
一个数据节点 dnode 里可能有多个 DB 的数据,因此一个 dnode 离线时,可能会影响到多个 DB。如果一个 vnode group 里的一半或一半以上的 vnode 不工作,那么该 vnode group 就无法对外服务,无法插入或读取数据,这样会影响到它所属的 DB 的一部分表的读写操作。
......@@ -20,7 +20,7 @@ CREATE DATABASE demo replica 3;
## Mnode 的高可用性
TDengine 集群是由 mnode (taosd 的一个模块,管理节点) 负责管理的,为保证 mnode 的高可用,可以配置多个 mnode 副本,副本数由系统配置参数 numOfMnodes 决定,有效范围为 1-3。为保证元数据的强一致性,mnode 副本之间是通过同步的方式进行数据复制的。
TDengine 集群是由 mnode(taosd 的一个模块,管理节点)负责管理的,为保证 mnode 的高可用,可以配置多个 mnode 副本,副本数由系统配置参数 numOfMnodes 决定,有效范围为 1-3。为保证元数据的强一致性,mnode 副本之间是通过同步的方式进行数据复制的。
一个集群有多个数据节点 dnode,但一个 dnode 至多运行一个 mnode 实例。多个 dnode 情况下,哪个 dnode 可以作为 mnode 呢?这是完全由系统根据整个系统资源情况,自动指定的。用户可通过 CLI 程序 taos,在 TDengine 的 console 里,执行如下命令:
......@@ -28,12 +28,12 @@ TDengine 集群是由 mnode (taosd 的一个模块,管理节点) 负责管理
SHOW MNODES;
```
来查看 mnode 列表,该列表将列出 mnode 所处的 dnode 的 End Point 和角色(master, slave, unsynced 或 offline)。当集群中第一个数据节点启动时,该数据节点一定会运行一个 mnode 实例,否则该数据节点 dnode 无法正常工作,因为一个系统是必须有至少一个 mnode 的。如果 numOfMnodes 配置为 2,启动第二个 dnode 时,该 dnode 也将运行一个 mnode 实例。
来查看 mnode 列表,该列表将列出 mnode 所处的 dnode 的 End Point 和角色(master,slave,unsynced 或 offline)。当集群中第一个数据节点启动时,该数据节点一定会运行一个 mnode 实例,否则该数据节点 dnode 无法正常工作,因为一个系统是必须有至少一个 mnode 的。如果 numOfMnodes 配置为 2,启动第二个 dnode 时,该 dnode 也将运行一个 mnode 实例。
为保证 mnode 服务的高可用性,numOfMnodes 必须设置为 2 或更大。因为 mnode 保存的元数据必须是强一致的,如果 numOfMnodes 大于 2,复制参数 quorum 自动设为 2,也就是说,至少要保证有两个副本写入数据成功,才通知客户端应用写入成功。
:::note
一个 TDengine 高可用系统,无论是 vnode 还是 mnode, 都必须配置多个副本。
一个 TDengine 高可用系统,无论是 vnode 还是 mnode都必须配置多个副本。
:::
......@@ -47,7 +47,7 @@ SHOW MNODES;
当上述三种情况发生时,系统将启动各个数据节点的负载计算,从而决定如何挪动。
:::tip
负载均衡由参数 balance 控制,它决定是否启动自动负载均衡, 0 表示禁用, 1 表示启用自动负载均衡。\*\*
负载均衡由参数 balance 控制,它决定是否启动自动负载均衡,0 表示禁用,1 表示启用自动负载均衡。
:::
......@@ -55,7 +55,7 @@ SHOW MNODES;
如果一个数据节点离线,TDengine 集群将自动检测到。有如下两种情况:
该数据节点离线超过一定时间(taos.cfg 里配置参数 offlineThreshold 控制时长),系统将自动把该数据节点删除,产生系统报警信息,触发负载均衡流程。如果该被删除的数据节点重新上线时,它将无法加入集群,需要系统管理员重新将其添加进集群才会开始工作。
该数据节点离线超过一定时间(taos.cfg 里配置参数 offlineThreshold 控制时长,系统将自动把该数据节点删除,产生系统报警信息,触发负载均衡流程。如果该被删除的数据节点重新上线时,它将无法加入集群,需要系统管理员重新将其添加进集群才会开始工作。
离线后,在 offlineThreshold 的时长内重新上线,系统将自动启动数据恢复流程,等数据完全恢复后,该节点将开始正常工作。
......@@ -79,7 +79,7 @@ Arbitrator 的执行程序名为 tarbitrator。该程序对系统资源几乎没
修改每个 taosd 实例的配置文件,在 taos.cfg 里将参数 arbitrator 设置为 tarbitrator 程序所对应的 End Point。(如果该参数配置了,当副本数为偶数时,系统将自动连接配置的 Arbitrator。如果副本数为奇数,即使配置了 Arbitrator,系统也不会去建立连接。)
在配置文件中配置了的 Arbitrator,会出现在 SHOW DNODES; 指令的返回结果中,对应的 role 列的值会是“arb”。
在配置文件中配置了的 Arbitrator,会出现在 SHOW DNODES 指令的返回结果中,对应的 role 列的值会是“arb”。
查看集群 Arbitrator 的状态【2.0.14.0 以后支持】
```sql
......
......@@ -2,14 +2,14 @@
title: 安装、卸载、启动和停止
---
TDengine 开源版本提供 deb 和 rpm 格式安装包,用户可以根据自己的运行环境选择合适的安装包。其中 deb 支持 Debian/Ubuntu 等系统,rpm 支持 CentOS/RHEL/SUSE 等系统。同时我们也为企业用户提供 tar.gz 格式安装包。
TDengine 开源版本提供 deb 和 rpm 格式安装包,用户可以根据自己的运行环境选择合适的安装包。其中 deb 支持 Debian/Ubuntu 及衍生系统,rpm 支持 CentOS/RHEL/SUSE 及衍生系统。同时我们也为企业用户提供 tar.gz 格式安装包。
## deb 包的安装和卸载
### 安装 deb
1、从官网下载获得 deb 安装包,比如 TDengine-server-2.0.0.0-Linux-x64.deb;
2、进入到 TDengine-server-2.0.0.0-Linux-x64.deb 安装包所在目录,执行如下的安装命令:
1、从官网下载获得 deb 安装包,例如 TDengine-server-2.4.0.7-Linux-x64.deb;
2、进入到 TDengine-server-2.4.0.7-Linux-x64.deb 安装包所在目录,执行如下的安装命令:
```
$ sudo dpkg -i TDengine-server-2.4.0.7-Linux-x64.deb
......@@ -20,7 +20,7 @@ Unpacking tdengine (2.4.0.7) over (2.4.0.7) ...
Setting up tdengine (2.4.0.7) ...
Start to install TDengine...
System hostname is: shuduo-1804
System hostname is: ubuntu-1804
Enter FQDN:port (like h1.taosdata.com:6030) of an existing TDengine cluster node to join
OR leave it blank to build one:
......@@ -30,7 +30,7 @@ Created symlink /etc/systemd/system/multi-user.target.wants/taosd.service → /e
To configure TDengine : edit /etc/taos/taos.cfg
To start TDengine : sudo systemctl start taosd
To access TDengine : taos -h shuduo-1804 to login into TDengine server
To access TDengine : taos -h ubuntu-1804 to login into TDengine server
TDengine is installed successfully!
......@@ -55,8 +55,8 @@ TDengine is removed successfully!
### 安装 rpm
1、从官网下载获得 rpm 安装包,比如 TDengine-server-2.0.0.0-Linux-x64.rpm;
2、进入到 TDengine-server-2.0.0.0-Linux-x64.rpm 安装包所在目录,执行如下的安装命令:
1、从官网下载获得 rpm 安装包,例如 TDengine-server-2.4.0.7-Linux-x64.rpm;
2、进入到 TDengine-server-2.4.0.7-Linux-x64.rpm 安装包所在目录,执行如下的安装命令:
```
$ sudo rpm -ivh TDengine-server-2.4.0.7-Linux-x64.rpm
......@@ -95,7 +95,7 @@ TDengine is removed successfully!
### 安装 tar.gz 安装包
1、从官网下载获得 tar.gz 安装包,如 TDengine-server-2.4.0.7-Linux-x64.tar.gz;
1、从官网下载获得 tar.gz 安装包,如 TDengine-server-2.4.0.7-Linux-x64.tar.gz;
2、进入到 TDengine-server-2.4.0.7-Linux-x64.tar.gz 安装包所在目录,先解压文件后,进入子目录,执行其中的 install.sh 安装脚本:
```
......@@ -135,7 +135,7 @@ Nginx for TDengine is updated successfully!
To configure TDengine : edit /etc/taos/taos.cfg
To configure Taos Adapter (if has) : edit /etc/taos/taosadapter.toml
To start TDengine : sudo systemctl start taosd
To access TDengine : use taos -h shuduo-1804 in shell OR from http://127.0.0.1:6060
To access TDengine : use taos -h ubuntu-1804 in shell OR from http://127.0.0.1:6060
TDengine is updated successfully!
Install taoskeeper as a standalone service
......
......@@ -11,8 +11,11 @@ title: 诊断及其他
诊断步骤:
1. 如拟诊断的端口范围与服务器 taosd 实例的端口范围相同,须先停掉 taosd 实例
2. 服务端命令行输入:`taos -n server -P <port>` 以服务端身份启动对端口 port 为基准端口的监听
3. 客户端命令行输入:`taos -n client -h <fqdn of server> -P <port>` 以客户端身份启动对指定的服务器、指定的端口发送测试包
2. 服务端命令行输入:`taos -n server -P <port> -l <pktlen>` 以服务端身份启动对端口 port 为基准端口的监听
3. 客户端命令行输入:`taos -n client -h <fqdn of server> -P <port> -l <pktlen>` 以客户端身份启动对指定的服务器、指定的端口发送测试包
-l <pktlen\>: 测试网络包的大小(单位:字节)。最小值是 11、最大值是 64000,默认值为 1000。
注:两端命令行中指定的测试包长度必须一致,否则测试显示失败。
服务端运行正常的话会输出以下信息:
......@@ -96,7 +99,7 @@ taos -n sync -P 6042 -h <fqdn of server>
-h:所要连接的服务端的 FQDN 或 ip 地址。如果不设置这一项,会使用本机 taos.cfg 文件中 FQDN 参数的设置作为默认值。
-P:所连接服务端的网络端口。默认值为 6030。
-N:诊断过程中使用的网络包总数。最小值是 1、最大值是 10000,默认值为 100。
-l:单个网络包的大小(单位:字节)。最小值是 1024、最大值是 1024 _ 1024 _ 1024,默认值为 1000
-l:单个网络包的大小(单位:字节)。最小值是 1024、最大值是 1024 `*` 1024 `*` 1024,默认值为 1024
-S:网络封包的类型。可以是 TCP 或 UDP,默认值为 TCP。
## FQDN 解析速度诊断
......
......@@ -104,7 +104,7 @@ title: 数据模型和整体架构
<center> <a href="#model_table1">表 1:智能电表数据示例</a></center>
每一条记录都有设备 ID,时间戳,采集的物理量(如上图中的电流、电压、相位),还有与每个设备相关的静态标签(如上述表 1 中的位置 Location 和分组 groupId)。每个设备是受外界的触发,或按照设定的周期采集数据。采集的数据点是时序的,是一个数据流。
每一条记录都有设备 ID,时间戳,采集的物理量(如上图中的电流、电压、相位),还有与每个设备相关的静态标签(如上述表 1 中的位置 location 和分组 groupId)。每个设备是受外界的触发,或按照设定的周期采集数据。采集的数据点是时序的,是一个数据流。
### 数据特征
......@@ -125,11 +125,11 @@ title: 数据模型和整体架构
### 关系型数据库模型
因为采集的数据一般是结构化数据,同时为降低学习门槛,TDengine 采用传统的关系型数据库模型管理数据。因此用户需要先创建库,然后创建表,之后才能插入或查询数据。TDengine 采用的是结构化存储,而不是 NoSQL 的 key-value 存储。
因为采集的数据一般是结构化数据,同时为降低学习门槛,TDengine 采用传统的关系型数据库模型管理数据。用户需要先创建库,然后创建表,之后才能插入或查询数据。TDengine 采用的是结构化存储,而不是 NoSQL 的 key-value 存储。
### 一个数据采集点一张表
为充分利用其数据的时序性和其他数据特点,TDengine 要求**对每个数据采集点单独建表**(比如有一千万个智能电表,就需创建一千万张表,上述表格中的 d1001, d1002, d1003, d1004 都需单独建表),用来存储这个采集点所采集的时序数据。这种设计有几大优点:
为充分利用其数据的时序性和其他数据特点,TDengine 要求**对每个数据采集点单独建表**(比如有一千万个智能电表,就需创建一千万张表,上述表格中的 d1001,d1002,d1003,d1004 都需单独建表),用来存储这个采集点所采集的时序数据。这种设计有几大优点:
1. 能保证一个采集点的数据在存储介质上是以块为单位连续存储的。如果读取一个时间段的数据,它能大幅减少随机读取操作,成数量级的提升读取和查询速度。
2. 由于不同采集设备产生数据的过程完全独立,每个设备的数据源是唯一的,一张表也就只有一个写入者,这样就可采用无锁方式来写,写入速度就能大幅提升。
......@@ -137,11 +137,11 @@ title: 数据模型和整体架构
如果采用传统的方式,将多个设备的数据写入一张表,由于网络延时不可控,不同设备的数据到达服务器的时序是无法保证的,写入操作是要有锁保护的,而且一个设备的数据是难以保证连续存储在一起的。**采用一个数据采集点一张表的方式,能最大程度的保证单个数据采集点的插入和查询的性能是最优的。**
TDengine 建议用数据采集点的名字(如上表中的 D1001)来做表名。每个数据采集点可能同时采集多个物理量(如上表中的 curent, voltage, phase),每个物理量对应一张表中的一列,数据类型可以是整型、浮点型、字符串等。除此之外,表的第一列必须是时间戳,即数据类型为 timestamp。对采集的数据,TDengine 将自动按照时间戳建立索引,但对采集的物理量不建任何索引。数据用列式存储方式保存。
TDengine 建议用数据采集点的名字(如上表中的 D1001)来做表名。每个数据采集点可能同时采集多个物理量(如上表中的 curent,voltage,phase),每个物理量对应一张表中的一列,数据类型可以是整型、浮点型、字符串等。除此之外,表的第一列必须是时间戳,即数据类型为 timestamp。对采集的数据,TDengine 将自动按照时间戳建立索引,但对采集的物理量不建任何索引。数据用列式存储方式保存。
### 超级表:同一类型数据采集点的集合
由于一个数据采集点一张表,导致表的数量巨增,难以管理,而且应用经常需要做采集点之间的聚合操作,聚合的操作也变得复杂起来。为解决这个问题,TDengine 引入超级表(Super Table,简称为 STable)的概念。
由于一个数据采集点一张表,导致表的数量巨增,难以管理,而且应用经常需要做采集点之间的聚合操作,聚合的操作也变得复杂起来。为解决这个问题,TDengine 引入超级表(Super Table,简称为 STable)的概念。
超级表是指某一特定类型的数据采集点的集合。同一类型的数据采集点,其表的结构是完全一样的,但每个表(数据采集点)的静态属性(标签)是不一样的。描述一个超级表(某一特定类型的数据采集点的集合),除需要定义采集量的表结构之外,还需要定义其标签的 schema,标签的数据类型可以是整数、浮点数、字符串,标签可以有多个,可以事后增加、删除或修改。如果整个系统有 N 个不同类型的数据采集点,就需要建立 N 个超级表。
......@@ -161,25 +161,25 @@ TDengine 分布式架构的逻辑结构图如下:
<center> 图 1 TDengine架构示意图 </center>
一个完整的 TDengine 系统是运行在一到多个物理节点上的,逻辑上,它包含数据节点(dnode)、TDengine 应用驱动(taosc)以及应用(app)。系统中存在一到多个数据节点,这些数据节点组成一个集群(cluster)。应用通过 taosc 的 API 与 TDengine 集群进行互动。下面对每个逻辑单元进行简要介绍。
一个完整的 TDengine 系统是运行在一到多个物理节点上的,逻辑上,它包含数据节点(dnode)、TDengine 应用驱动(taosc)以及应用(app)。系统中存在一到多个数据节点,这些数据节点组成一个集群(cluster)。应用通过 taosc 的 API 与 TDengine 集群进行互动。下面对每个逻辑单元进行简要介绍。
**物理节点(pnode):** pnode 是一独立运行、拥有自己的计算、存储和网络能力的计算机,可以是安装有 OS 的物理机、虚拟机或 Docker 容器。物理节点由其配置的 FQDN (Fully Qualified Domain Name)来标识。TDengine 完全依赖 FQDN 来进行网络通讯,如果不了解 FQDN,请看博文[《一篇文章说清楚 TDengine 的 FQDN》](https://www.taosdata.com/blog/2020/09/11/1824.html)
**物理节点(pnode):** pnode 是一独立运行、拥有自己的计算、存储和网络能力的计算机,可以是安装有 OS 的物理机、虚拟机或 Docker 容器。物理节点由其配置的 FQDN(Fully Qualified Domain Name)来标识。TDengine 完全依赖 FQDN 来进行网络通讯,如果不了解 FQDN,请看博文[《一篇文章说清楚 TDengine 的 FQDN》](https://www.taosdata.com/blog/2020/09/11/1824.html)
**数据节点(dnode):** dnode 是 TDengine 服务器侧执行代码 taosd 在物理节点上的一个运行实例,一个工作的系统必须有至少一个数据节点。dnode 包含零到多个逻辑的虚拟节点(vnode),零或者至多一个逻辑的管理节点(mnode)。dnode 在系统中的唯一标识由实例的 End Point (EP)决定。EP 是 dnode 所在物理节点的 FQDN (Fully Qualified Domain Name)和系统所配置的网络端口号(Port)的组合。通过配置不同的端口,一个物理节点(一台物理机、虚拟机或容器)可以运行多个实例,或有多个数据节点。
**数据节点(dnode):** dnode 是 TDengine 服务器侧执行代码 taosd 在物理节点上的一个运行实例,一个工作的系统必须有至少一个数据节点。dnode 包含零到多个逻辑的虚拟节点(vnode),零或者至多一个逻辑的管理节点(mnode)。dnode 在系统中的唯一标识由实例的 End Point(EP)决定。EP 是 dnode 所在物理节点的 FQDN(Fully Qualified Domain Name)和系统所配置的网络端口号(Port)的组合。通过配置不同的端口,一个物理节点(一台物理机、虚拟机或容器)可以运行多个实例,或有多个数据节点。
**虚拟节点(vnode):** 为更好的支持数据分片、负载均衡,防止数据过热或倾斜,数据节点被虚拟化成多个虚拟节点(vnode,图中 V2, V3, V4 等)。每个 vnode 都是一个相对独立的工作单元,是时序数据存储的基本单元,具有独立的运行线程、内存空间与持久化存储的路径。一个 vnode 包含一定数量的表(数据采集点)。当创建一张新表时,系统会检查是否需要创建新的 vnode。一个数据节点上能创建的 vnode 的数量取决于该数据节点所在物理节点的硬件资源。一个 vnode 只属于一个 DB,但一个 DB 可以有多个 vnode。一个 vnode 除存储的时序数据外,也保存有所包含的表的 schema、标签值等。一个虚拟节点由所属的数据节点的 EP,以及所属的 VGroup ID 在系统内唯一标识,由管理节点创建并管理。
**虚拟节点(vnode):** 为更好的支持数据分片、负载均衡,防止数据过热或倾斜,数据节点被虚拟化成多个虚拟节点(vnode,图中 V2,V3,V4 等)。每个 vnode 都是一个相对独立的工作单元,是时序数据存储的基本单元,具有独立的运行线程、内存空间与持久化存储的路径。一个 vnode 包含一定数量的表(数据采集点)。当创建一张新表时,系统会检查是否需要创建新的 vnode。一个数据节点上能创建的 vnode 的数量取决于该数据节点所在物理节点的硬件资源。一个 vnode 只属于一个 DB,但一个 DB 可以有多个 vnode。一个 vnode 除存储的时序数据外,也保存有所包含的表的 schema、标签值等。一个虚拟节点由所属的数据节点的 EP,以及所属的 VGroup ID 在系统内唯一标识,由管理节点创建并管理。
**管理节点(mnode):** 一个虚拟的逻辑单元,负责所有数据节点运行状态的监控和维护,以及节点之间的负载均衡(图中 M)。同时,管理节点也负责元数据(包括用户、数据库、表、静态标签等)的存储和管理,因此也称为 Meta Node。TDengine 集群中可配置多个(开源版最多不超过 3 个) mnode,它们自动构建成为一个虚拟管理节点组(图中 M0, M1, M2)。mnode 间采用 master/slave 的机制进行管理,而且采取强一致方式进行数据同步, 任何数据更新操作只能在 Master 上进行。mnode 集群的创建由系统自动完成,无需人工干预。每个 dnode 上至多有一个 mnode,由所属的数据节点的 EP 来唯一标识。每个 dnode 通过内部消息交互自动获取整个集群中所有 mnode 所在的 dnode 的 EP。
**管理节点(mnode):** 一个虚拟的逻辑单元,负责所有数据节点运行状态的监控和维护,以及节点之间的负载均衡(图中 M)。同时,管理节点也负责元数据(包括用户、数据库、表、静态标签等)的存储和管理,因此也称为 Meta Node。TDengine 集群中可配置多个(开源版最多不超过 3 个)mnode,它们自动构建成为一个虚拟管理节点组(图中 M0,M1,M2)。mnode 间采用 master/slave 的机制进行管理,而且采取强一致方式进行数据同步,任何数据更新操作只能在 Master 上进行。mnode 集群的创建由系统自动完成,无需人工干预。每个 dnode 上至多有一个 mnode,由所属的数据节点的 EP 来唯一标识。每个 dnode 通过内部消息交互自动获取整个集群中所有 mnode 所在的 dnode 的 EP。
**虚拟节点组(VGroup):** 不同数据节点上的 vnode 可以组成一个虚拟节点组(vnode group)来保证系统的高可靠。虚拟节点组内采取 master/slave 的方式进行管理。写操作只能在 master vnode 上进行,系统采用异步复制的方式将数据同步到 slave vnode,这样确保了一份数据在多个物理节点上有拷贝。一个 vgroup 里虚拟节点个数就是数据的副本数。如果一个 DB 的副本数为 N,系统必须有至少 N 数据节点。副本数在创建 DB 时通过参数 replica 可以指定,缺省为 1。使用 TDengine 的多副本特性,可以不再需要昂贵的磁盘阵列等存储设备,就可以获得同样的数据高可靠性。虚拟节点组由管理节点创建、管理,并且由管理节点分配一个系统唯一的 ID,VGroup ID。如果两个虚拟节点的 vnode group ID 相同,说明他们属于同一个组,数据互为备份。虚拟节点组里虚拟节点的个数是可以动态改变的,容许只有一个,也就是没有数据复制。VGroup ID 是永远不变的,即使一个虚拟节点组被删除,它的 ID 也不会被收回重复利用。
**虚拟节点组(VGroup):** 不同数据节点上的 vnode 可以组成一个虚拟节点组(vgroup)来保证系统的高可靠。虚拟节点组内采取 master/slave 的方式进行管理。写操作只能在 master vnode 上进行,系统采用异步复制的方式将数据同步到 slave vnode,这样确保了一份数据在多个物理节点上有拷贝。一个 vgroup 里虚拟节点个数就是数据的副本数。如果一个 DB 的副本数为 N,系统必须有至少 N 数据节点。副本数在创建 DB 时通过参数 replica 可以指定,缺省为 1。使用 TDengine 的多副本特性,可以不再需要昂贵的磁盘阵列等存储设备,就可以获得同样的数据高可靠性。虚拟节点组由管理节点创建、管理,并且由管理节点分配一个系统唯一的 ID,VGroup ID。如果两个虚拟节点的 VGroup ID 相同,说明他们属于同一个组,数据互为备份。虚拟节点组里虚拟节点的个数是可以动态改变的,容许只有一个,也就是没有数据复制。VGroup ID 是永远不变的,即使一个虚拟节点组被删除,它的 ID 也不会被收回重复利用。
**TAOSC:** taosc 是 TDengine 给应用提供的驱动程序(driver),负责处理应用与集群的接口交互,提供 C/C++ 语言原生接口,内嵌于 JDBC、C#、Python、Go、Node.js 语言连接库里。应用都是通过 taosc 而不是直接连接集群中的数据节点与整个集群进行交互的。这个模块负责获取并缓存元数据;将插入、查询等请求转发到正确的数据节点;在把结果返回给应用时,还需要负责最后一级的聚合、排序、过滤等操作。对于 JDBC、C/C++、C#、Python、Go、Node.js 接口而言,这个模块是在应用所处的物理节点上运行。同时,为支持全分布式的 RESTful 接口,taosc 在 TDengine 集群的每个 dnode 上都有一运行实例。
**Taosc** taosc 是 TDengine 给应用提供的驱动程序(driver),负责处理应用与集群的接口交互,提供 C/C++ 语言原生接口,内嵌于 JDBC、C#、Python、Go、Node.js 语言连接库里。应用都是通过 taosc 而不是直接连接集群中的数据节点与整个集群进行交互的。这个模块负责获取并缓存元数据;将插入、查询等请求转发到正确的数据节点;在把结果返回给应用时,还需要负责最后一级的聚合、排序、过滤等操作。对于 JDBC、C/C++、C#、Python、Go、Node.js 接口而言,这个模块是在应用所处的物理节点上运行。同时,为支持全分布式的 RESTful 接口,taosc 在 TDengine 集群的每个 dnode 上都有一运行实例。
### 节点之间的通讯
**通讯方式:**TDengine 系统的各个数据节点之间,以及应用驱动与各数据节点之间的通讯是通过 TCP/UDP 进行的。因为考虑到物联网场景,数据写入的包一般不大,因此 TDengine 除采用 TCP 做传输之外,还采用 UDP 方式,因为 UDP 更加高效,而且不受连接数的限制。TDengine 实现了自己的超时、重传、确认等机制,以确保 UDP 的可靠传输。对于数据量不到 15K 的数据包,采取 UDP 的方式进行传输,超过 15K 的,或者是查询类的操作,自动采取 TCP 的方式进行传输。同时,TDengine 根据配置和数据包,会自动对数据进行压缩/解压缩,数字签名/认证等处理。对于数据节点之间的数据复制,只采用 TCP 方式进行数据传输。
**FQDN 配置:**一个数据节点有一个或多个 FQDN,可以在系统配置文件 taos.cfg 通过参数"fqdn"进行指定,如果没有指定,系统将自动获取计算机的 hostname 作为其 FQDN。如果节点没有配置 FQDN,可以直接将该节点的配置参数 fqdn 设置为它的 IP 地址。但不建议使用 IP,因为 IP 地址可变,一旦变化,将让集群无法正常工作。一个数据节点的 EP(End Point) 由 FQDN + Port 组成。采用 FQDN,需要保证 DNS 服务正常工作,或者在节点以及应用所在的节点配置好 hosts 文件。另外,这个参数值的长度需要控制在 96 个字符以内。
**FQDN 配置:**一个数据节点有一个或多个 FQDN,可以在系统配置文件 taos.cfg 通过参数“fqdn”进行指定,如果没有指定,系统将自动获取计算机的 hostname 作为其 FQDN。如果节点没有配置 FQDN,可以直接将该节点的配置参数 fqdn 设置为它的 IP 地址。但不建议使用 IP,因为 IP 地址可变,一旦变化,将让集群无法正常工作。一个数据节点的 EP(End Point)由 FQDN + Port 组成。采用 FQDN,需要保证 DNS 服务正常工作,或者在节点以及应用所在的节点配置好 hosts 文件。另外,这个参数值的长度需要控制在 96 个字符以内。
**端口配置:**一个数据节点对外的端口由 TDengine 的系统配置参数 serverPort 决定,对集群内部通讯的端口是 serverPort+5。为支持多线程高效的处理 UDP 数据,每个对内和对外的 UDP 连接,都需要占用 5 个连续的端口。
......@@ -187,9 +187,9 @@ TDengine 分布式架构的逻辑结构图如下:
- 集群数据节点对外提供 RESTful 服务占用一个 TCP 端口,是 serverPort+11。
- 集群内数据节点与 Arbitrator 节点之间通讯占用一个 TCP 端口,是 serverPort+12。
因此一个数据节点总的端口范围为 serverPort 到 serverPort+12,总共 13 个 TCP/UDP 端口。使用时,需要确保防火墙将这些端口打开。每个数据节点可以配置不同的 serverPort。(详细的端口情况请参见 [TDengine 2.0 端口说明](https://www.taosdata.com/cn/documentation/faq#port)
因此一个数据节点总的端口范围为 serverPort 到 serverPort+12,总共 13 个 TCP/UDP 端口。使用时,需要确保防火墙将这些端口打开。每个数据节点可以配置不同的 serverPort。(详细的端口情况请参见 [TDengine 2.0 端口说明](https://www.taosdata.com/cn/documentation/faq#port)
**集群对外连接:**TDengine 集群可以容纳单个、多个甚至几千个数据节点。应用只需要向集群中任何一个数据节点发起连接即可,连接需要提供的网络参数是一数据节点的 End Point(FQDN 加配置的端口号)。通过命令行 CLI 启动应用 taos 时,可以通过选项-h 来指定数据节点的 FQDN, -P 来指定其配置的端口号,如果端口不配置,将采用 TDengine 的系统配置参数 serverPort。
**集群对外连接:**TDengine 集群可以容纳单个、多个甚至几千个数据节点。应用只需要向集群中任何一个数据节点发起连接即可,连接需要提供的网络参数是一数据节点的 End Point(FQDN 加配置的端口号)。通过命令行 CLI 启动应用 taos 时,可以通过选项-h 来指定数据节点的 FQDN,-P 来指定其配置的端口号,如果端口不配置,将采用 TDengine 的系统配置参数 serverPort。
**集群内部通讯:**各个数据节点之间通过 TCP/UDP 进行连接。一个数据节点启动时,将获取 mnode 所在的 dnode 的 EP 信息,然后与系统中的 mnode 建立起连接,交换信息。获取 mnode 的 EP 信息有三步:
......@@ -199,11 +199,11 @@ TDengine 分布式架构的逻辑结构图如下:
获取 mnode EP 列表后,数据节点发起连接,如果连接成功,则成功加入进工作的集群,如果不成功,则尝试 mnode EP 列表中的下一个。如果都尝试了,但连接都仍然失败,则休眠几秒后,再进行尝试。
**MNODE 的选择:**TDengine 逻辑上有管理节点,但没有单独的执行代码,服务器侧只有一套执行代码 taosd。那么哪个数据节点会是管理节点呢?这是系统自动决定的,无需任何人工干预。原则如下:一个数据节点启动时,会检查自己的 End Point, 并与获取的 mnode EP List 进行比对,如果在其中,该数据节点认为自己应该启动 mnode 模块,成为 mnode。如果自己的 EP 不在 mnode EP List 里,则不启动 mnode 模块。在系统的运行过程中,由于负载均衡、宕机等原因,mnode 有可能迁移至新的 dnode,但一切都是透明的,无需人工干预,配置参数的修改,是 mnode 自己根据资源做出的决定。
**Mnode 的选择:**TDengine 逻辑上有管理节点,但没有单独的执行代码,服务器侧只有一套执行代码 taosd。那么哪个数据节点会是管理节点呢?这是系统自动决定的,无需任何人工干预。原则如下:一个数据节点启动时,会检查自己的 End Point,并与获取的 mnode EP List 进行比对,如果在其中,该数据节点认为自己应该启动 mnode 模块,成为 mnode。如果自己的 EP 不在 mnode EP List 里,则不启动 mnode 模块。在系统的运行过程中,由于负载均衡、宕机等原因,mnode 有可能迁移至新的 dnode,但一切都是透明的,无需人工干预,配置参数的修改,是 mnode 自己根据资源做出的决定。
**新数据节点的加入:**系统有了一个数据节点后,就已经成为一个工作的系统。添加新的节点进集群时,有两个步骤,第一步:使用 TDengine CLI 连接到现有工作的数据节点,然后用命令"create dnode"将新的数据节点的 End Point 添加进去; 第二步:在新的数据节点的系统配置参数文件 taos.cfg 里,将 firstEp, secondEp 参数设置为现有集群中任意两个数据节点的 EP 即可。具体添加的详细步骤请见详细的用户手册。这样就把集群一步一步的建立起来。
**新数据节点的加入:**系统有了一个数据节点后,就已经成为一个工作的系统。添加新的节点进集群时,有两个步骤,第一步:使用 TDengine CLI 连接到现有工作的数据节点,然后用命令“CREATE DNODE”将新的数据节点的 End Point 添加进去;第二步:在新的数据节点的系统配置参数文件 taos.cfg 里,将 firstEp,secondEp 参数设置为现有集群中任意两个数据节点的 EP 即可。具体添加的详细步骤请见详细的用户手册。这样就把集群一步一步的建立起来。
**重定向:**无论是 dnode 还是 taosc,最先都是要发起与 mnode 的连接,但 mnode 是系统自动创建并维护的,因此对于用户来说,并不知道哪个 dnode 在运行 mnode。TDengine 只要求向系统中任何一个工作的 dnode 发起连接即可。因为任何一个正在运行的 dnode,都维护有目前运行的 mnode EP List。当收到一个来自新启动的 dnode 或 taosc 的连接请求,如果自己不是 mnode,则将 mnode EP List 回复给对方,taosc 或新启动的 dnode 收到这个 list, 就重新尝试建立连接。当 mnode EP List 发生改变,通过节点之间的消息交互,各个数据节点就很快获取最新列表,并通知 taosc。
**重定向:**无论是 dnode 还是 taosc,最先都是要发起与 mnode 的连接,但 mnode 是系统自动创建并维护的,因此对于用户来说,并不知道哪个 dnode 在运行 mnode。TDengine 只要求向系统中任何一个工作的 dnode 发起连接即可。因为任何一个正在运行的 dnode,都维护有目前运行的 mnode EP List。当收到一个来自新启动的 dnode 或 taosc 的连接请求,如果自己不是 mnode,则将 mnode EP List 回复给对方,taosc 或新启动的 dnode 收到这个 list就重新尝试建立连接。当 mnode EP List 发生改变,通过节点之间的消息交互,各个数据节点就很快获取最新列表,并通知 taosc。
### 一个典型的消息流程
......@@ -215,14 +215,14 @@ TDengine 分布式架构的逻辑结构图如下:
1. 应用通过 JDBC 或其他 API 接口发起插入数据的请求。
2. taosc 会检查缓存,看是否保存有该表的 meta data。如果有,直接到第 4 步。如果没有,taosc 将向 mnode 发出 get meta-data 请求。
3. mnode 将该表的 meta-data 返回给 taosc。Meta-data 包含有该表的 schema, 而且还有该表所属的 vgroup 信息(vnode ID 以及所在的 dnode 的 End Point,如果副本数为 N,就有 N 组 End Point)。如果 taosc 迟迟得不到 mnode 回应,而且存在多个 mnode, taosc 将向下一个 mnode 发出请求。
3. mnode 将该表的 meta-data 返回给 taosc。Meta-data 包含有该表的 schema,而且还有该表所属的 vgroup 信息(vnode ID 以及所在的 dnode 的 End Point,如果副本数为 N,就有 N 组 End Point)。如果 taosc 迟迟得不到 mnode 回应,而且存在多个 mnode,taosc 将向下一个 mnode 发出请求。
4. taosc 向 master vnode 发起插入请求。
5. vnode 插入数据后,给 taosc 一个应答,表示插入成功。如果 taosc 迟迟得不到 vnode 的回应,taosc 会认为该节点已经离线。这种情况下,如果被插入的数据库有多个副本,taosc 将向 vgroup 里下一个 vnode 发出插入请求。
6. taosc 通知 APP,写入成功。
对于第二和第三步,taosc 启动时,并不知道 mnode 的 End Point,因此会直接向配置的集群对外服务的 End Point 发起请求。如果接收到该请求的 dnode 并没有配置 mnode,该 dnode 会在回复的消息中告知 mnode EP 列表,这样 taosc 会重新向新的 mnode 的 EP 发出获取 meta-data 的请求。
对于第四和第五步,没有缓存的情况下,taosc 无法知道虚拟节点组里谁是 master,就假设第一个 vnodeID 就是 master,向它发出请求。如果接收到请求的 vnode 并不是 master,它会在回复中告知谁是 master,这样 taosc 就向建议的 master vnode 发出请求。一旦得到插入成功的回复,taosc 会缓存 master 节点的信息。
对于第四和第五步,没有缓存的情况下,taosc 无法知道虚拟节点组里谁是 master,就假设第一个 vnodeID 就是 master,向它发出请求。如果接收到请求的 vnode 并不是 master,它会在回复中告知谁是 master,这样 taosc 就向建议的 master vnode 发出请求。一旦得到插入成功的回复,taosc 会缓存 master 节点的信息。
上述是插入数据的流程,查询、计算的流程也完全一致。taosc 把这些复杂的流程全部封装屏蔽了,对于应用来说无感知也无需任何特别处理。
......@@ -245,27 +245,27 @@ TDengine 存储的数据包括采集的时序数据以及库、表相关的元
### 数据分片
对于海量的数据管理,为实现水平扩展,一般都需要采取分片(Sharding)分区(Partitioning)策略。TDengine 是通过 vnode 来实现数据分片的,通过一个时间段一个数据文件来实现时序数据分区的。
对于海量的数据管理,为实现水平扩展,一般都需要采取分片(Sharding)分区(Partitioning)策略。TDengine 是通过 vnode 来实现数据分片的,通过一个时间段一个数据文件来实现时序数据分区的。
vnode(虚拟数据节点)负责为采集的时序数据提供写入、查询和计算功能。为便于负载均衡、数据恢复、支持异构环境,TDengine 将一个数据节点根据其计算和存储资源切分为多个 vnode。这些 vnode 的管理是 TDengine 自动完成的,对应用完全透明。
vnode(虚拟数据节点)负责为采集的时序数据提供写入、查询和计算功能。为便于负载均衡、数据恢复、支持异构环境,TDengine 将一个数据节点根据其计算和存储资源切分为多个 vnode。这些 vnode 的管理是 TDengine 自动完成的,对应用完全透明。
对于单独一个数据采集点,无论其数据量多大,一个 vnode(或 vnode group, 如果副本数大于 1)有足够的计算资源和存储资源来处理(如果每秒生成一条 16 字节的记录,一年产生的原始数据不到 0.5G),因此 TDengine 将一张表(一个数据采集点)的所有数据都存放在一个 vnode 里,而不会让同一个采集点的数据分布到两个或多个 dnode 上。而且一个 vnode 可存储多个数据采集点(表)的数据,一个 vnode 可容纳的表的数目的上限为一百万。设计上,一个 vnode 里所有的表都属于同一个 DB。一个数据节点上,除非特殊配置,一个 DB 拥有的 vnode 数目不会超过系统核的数目。
对于单独一个数据采集点,无论其数据量多大,一个 vnode(或 vgroup,如果副本数大于 1)有足够的计算资源和存储资源来处理(如果每秒生成一条 16 字节的记录,一年产生的原始数据不到 0.5G),因此 TDengine 将一张表(一个数据采集点)的所有数据都存放在一个 vnode 里,而不会让同一个采集点的数据分布到两个或多个 dnode 上。而且一个 vnode 可存储多个数据采集点(表)的数据,一个 vnode 可容纳的表的数目的上限为一百万。设计上,一个 vnode 里所有的表都属于同一个 DB。一个数据节点上,除非特殊配置,一个 DB 拥有的 vnode 数目不会超过系统核的数目。
创建 DB 时,系统并不会马上分配资源。但当创建一张表时,系统将看是否有已经分配的 vnode, 且该 vnode 是否有空余的表空间,如果有,立即在该有空位的 vnode 创建表。如果没有,系统将从集群中,根据当前的负载情况,在一个 dnode 上创建一新的 vnode, 然后创建表。如果 DB 有多个副本,系统不是只创建一个 vnode,而是一个 vgroup (虚拟数据节点组)。系统对 vnode 的数目没有任何限制,仅仅受限于物理节点本身的计算和存储资源。
创建 DB 时,系统并不会马上分配资源。但当创建一张表时,系统将看是否有已经分配的 vnode,且该 vnode 是否有空余的表空间,如果有,立即在该有空位的 vnode 创建表。如果没有,系统将从集群中,根据当前的负载情况,在一个 dnode 上创建一新的 vnode,然后创建表。如果 DB 有多个副本,系统不是只创建一个 vnode,而是一个 vgroup(虚拟数据节点组)。系统对 vnode 的数目没有任何限制,仅仅受限于物理节点本身的计算和存储资源。
每张表的 meta data(包含 schema, 标签等)也存放于 vnode 里,而不是集中存放于 mnode,实际上这是对 Meta 数据的分片,这样便于高效并行的进行标签过滤操作。
每张表的 meta data(包含 schema标签等)也存放于 vnode 里,而不是集中存放于 mnode,实际上这是对 Meta 数据的分片,这样便于高效并行的进行标签过滤操作。
### 数据分区
TDengine 除 vnode 分片之外,还对时序数据按照时间段进行分区。每个数据文件只包含一个时间段的时序数据,时间段的长度由 DB 的配置参数 days 决定。这种按时间段分区的方法还便于高效实现数据的保留策略,只要数据文件超过规定的天数(系统配置参数 keep),将被自动删除。而且不同的时间段可以存放于不同的路径和存储介质,以便于大数据的冷热管理,实现多级存储。
TDengine 除 vnode 分片之外,还对时序数据按照时间段进行分区。每个数据文件只包含一个时间段的时序数据,时间段的长度由 DB 的配置参数 days 决定。这种按时间段分区的方法还便于高效实现数据的保留策略,只要数据文件超过规定的天数(系统配置参数 keep,将被自动删除。而且不同的时间段可以存放于不同的路径和存储介质,以便于大数据的冷热管理,实现多级存储。
总的来说,**TDengine 是通过 vnode 以及时间两个维度,对大数据进行切分**,便于并行高效的管理,实现水平扩展。
### 负载均衡
每个 dnode 都定时向 mnode(虚拟管理节点)报告其状态(包括硬盘空间、内存大小、CPU、网络、虚拟节点个数等),因此 mnode 了解整个集群的状态。基于整体状态,当 mnode 发现某个 dnode 负载过重,它会将 dnode 上的一个或多个 vnode 挪到其他 dnode。在挪动过程中,对外服务继续进行,数据插入、查询和计算操作都不受影响。
每个 dnode 都定时向 mnode(虚拟管理节点)报告其状态(包括硬盘空间、内存大小、CPU、网络、虚拟节点个数等),因此 mnode 了解整个集群的状态。基于整体状态,当 mnode 发现某个 dnode 负载过重,它会将 dnode 上的一个或多个 vnode 挪到其他 dnode。在挪动过程中,对外服务继续进行,数据插入、查询和计算操作都不受影响。
如果 mnode 一段时间没有收到 dnode 的状态报告,mnode 会认为这个 dnode 已经离线。如果离线时间超过一定时长(时长由配置参数 offlineThreshold 决定),该 dnode 将被 mnode 强制剔除出集群。该 dnode 上的 vnodes 如果副本数大于 1,系统将自动在其他 dnode 上创建新的副本,以保证数据的副本数。如果该 dnode 上还有 mnode, 而且 mnode 的副本数大于 1,系统也将自动在其他 dnode 上创建新的 mnode, 以保证 mnode 的副本数。
如果 mnode 一段时间没有收到 dnode 的状态报告,mnode 会认为这个 dnode 已经离线。如果离线时间超过一定时长(时长由配置参数 offlineThreshold 决定),该 dnode 将被 mnode 强制剔除出集群。该 dnode 上的 vnodes 如果副本数大于 1,系统将自动在其他 dnode 上创建新的副本,以保证数据的副本数。如果该 dnode 上还有 mnode,而且 mnode 的副本数大于 1,系统也将自动在其他 dnode 上创建新的 mnode,以保证 mnode 的副本数。
当新的数据节点被添加进集群,因为新的计算和存储被添加进来,系统也将自动启动负载均衡流程。
......@@ -287,9 +287,9 @@ Master Vnode 遵循下面的写入流程:
1. master vnode 收到应用的数据插入请求,验证 OK,进入下一步;
2. 如果系统配置参数 walLevel 大于 0,vnode 将把该请求的原始数据包写入数据库日志文件 WAL。如果 walLevel 设置为 2,而且 fsync 设置为 0,TDengine 还将 WAL 数据立即落盘,以保证即使宕机,也能从数据库日志文件中恢复数据,避免数据的丢失;
3. 如果有多个副本,vnode 将把数据包转发给同一虚拟节点组内的 slave vnodes, 该转发包带有数据的版本号(version)
3. 如果有多个副本,vnode 将把数据包转发给同一虚拟节点组内的 slave vnodes,该转发包带有数据的版本号(version)
4. 写入内存,并将记录加入到 skip list;
5. master vnode 返回确认信息给应用,表示写入成功
5. master vnode 返回确认信息给应用,表示写入成功
6. 如果第 2、3、4 步中任何一步失败,将直接返回错误给应用。
### Slave Vnode 写入流程
......@@ -308,16 +308,16 @@ Master Vnode 遵循下面的写入流程:
### 主从选择
Vnode 会保持一个数据版本号(version),对内存数据进行持久化存储时,对该版本号也进行持久化存储。每个数据更新操作,无论是采集的时序数据还是元数据,这个版本号将增加 1。
Vnode 会保持一个数据版本号(version),对内存数据进行持久化存储时,对该版本号也进行持久化存储。每个数据更新操作,无论是采集的时序数据还是元数据,这个版本号将增加 1。
一个 vnode 启动时,角色(master、slave) 是不定的,数据是处于未同步状态,它需要与虚拟节点组内其他节点建立 TCP 连接,并互相交换 status,其中包括 version 和自己的角色。通过 status 的交换,系统进入选主流程,规则如下:
一个 vnode 启动时,角色(master、slave)是不定的,数据是处于未同步状态,它需要与虚拟节点组内其他节点建立 TCP 连接,并互相交换 status,其中包括 version 和自己的角色。通过 status 的交换,系统进入选主流程,规则如下:
1. 如果只有一个副本,该副本永远就是 master
2. 所有副本都在线时,版本最高的被选为 master
3. 在线的虚拟节点数过半,而且有虚拟节点是 slave 的话,该虚拟节点自动成为 master
4. 对于 2 和 3,如果多个虚拟节点满足成为 master 的要求,那么虚拟节点组的节点列表里,最前面的选为 master
更多的关于数据复制的流程,请见[TDengine 2.0 数据复制模块设计](https://www.taosdata.com/cn/documentation/architecture/replica/)
更多的关于数据复制的流程,请见[《TDengine 2.0 数据复制模块设计》](https://www.taosdata.com/cn/documentation/architecture/replica/)
### 同步复制
......@@ -343,11 +343,11 @@ TDengine 采用数据驱动的方式让缓存中的数据写入硬盘进行持
对于采集的数据,一般有保留时长,这个时长由系统配置参数 keep 决定。超过这个设置天数的数据文件,将被系统自动删除,释放存储空间。
给定 days 与 keep 两个参数,一个典型工作状态的 vnode 中总的数据文件数为:`向上取整(keep/days)+1`个。总的数据文件个数不宜过大,也不宜过小。10 到 100 以内合适。基于这个原则,可以设置合理的 days。目前的版本,参数 keep 可以修改,但对于参数 days,一旦设置后,不可修改。
给定 days 与 keep 两个参数,一个典型工作状态的 vnode 中总的数据文件数为:向上取整 `(keep/days)+1` 个。总的数据文件个数不宜过大,也不宜过小。10 到 100 以内合适。基于这个原则,可以设置合理的 days。目前的版本,参数 keep 可以修改,但对于参数 days,一旦设置后,不可修改。
在每个数据文件里,一张表的数据是一块一块存储的。一张表可以有一到多个数据文件块。在一个文件块里,数据是列式存储的,占用的是一片连续的存储空间,这样大大提高读取速度。文件块的大小由系统参数 maxRows (每块最大记录条数)决定,缺省值为 4096。这个值不宜过大,也不宜过小。过大,定位具体时间段的数据的搜索时间会变长,影响读取速度;过小,数据块的索引太大,压缩效率偏低,也影响读取速度。
每个数据文件(.data 结尾)都有一个对应的索引文件(.head 结尾),该索引文件对每张表都有一数据块的摘要信息,记录了每个数据块在数据文件中的偏移量,数据的起止时间等信息,以帮助系统迅速定位需要查找的数据。每个数据文件还有一对应的 last 文件(.last 结尾),该文件是为防止落盘时数据块碎片化而设计的。如果一张表落盘的记录条数没有达到系统配置参数 minRows(每块最小记录条数),将被先存储到 last 文件,等下次落盘时,新落盘的记录将与 last 文件的记录进行合并,再写入数据文件。
每个数据文件(.data 结尾)都有一个对应的索引文件(.head 结尾),该索引文件对每张表都有一数据块的摘要信息,记录了每个数据块在数据文件中的偏移量,数据的起止时间等信息,以帮助系统迅速定位需要查找的数据。每个数据文件还有一对应的 last 文件(.last 结尾),该文件是为防止落盘时数据块碎片化而设计的。如果一张表落盘的记录条数没有达到系统配置参数 minRows(每块最小记录条数),将被先存储到 last 文件,等下次落盘时,新落盘的记录将与 last 文件的记录进行合并,再写入数据文件。
数据写入磁盘时,根据系统配置参数 comp 决定是否压缩数据。TDengine 提供了三种压缩选项:无压缩、一阶段压缩和两阶段压缩,分别对应 comp 值为 0、1 和 2 的情况。一阶段压缩根据数据的类型进行了相应的压缩,压缩算法包括 delta-delta 编码、simple 8B 方法、zig-zag 编码、LZ4 等算法。二阶段压缩在一阶段压缩的基础上又用通用压缩算法进行了压缩,压缩率更高。
......@@ -375,7 +375,7 @@ dataDir [path] <level> <primary>
需要说明的是,数据在不同级别的存储介质上的移动,是由系统自动完成的,用户无需干预。
- primary: 是否为主挂载点,0(否)或 1(是),省略默认为 1。
在配置中,只允许一个主挂载点的存在(level=0, primary=1),例如采用如下的配置方式:
在配置中,只允许一个主挂载点的存在(level=0primary=1),例如采用如下的配置方式:
```
dataDir /mnt/data1 0 1
......@@ -386,19 +386,21 @@ dataDir /mnt/data5 2 0
dataDir /mnt/data6 2 0
```
注意:
:::note
1. 多级存储不允许跨级配置,合法的配置方案有:仅 0 级,仅 0 级+ 1 级,以及 0 级+ 1 级+ 2 级。而不允许只配置 level=0 和 level=2,而不配置 level=1。
2. 禁止手动移除使用中的挂载盘,挂载盘目前不支持非本地的网络盘。
3. 多级存储目前不支持删除已经挂载的硬盘的功能。
:::
## 数据查询
TDengine 提供了多种多样针对表和超级表的查询处理功能,除了常规的聚合查询之外,还提供针对时序数据的窗口查询、统计聚合等功能。TDengine 的查询处理需要客户端、vnode、mnode 节点协同完成。
### 单表查询
SQL 语句的解析和校验工作在客户端完成。解析 SQL 语句并生成抽象语法树(Abstract Syntax Tree, AST),然后对其进行校验和检查。以及向管理节点(mnode)请求查询中指定表的元数据信息(table metadata)
SQL 语句的解析和校验工作在客户端完成。解析 SQL 语句并生成抽象语法树(Abstract Syntax Tree,AST),然后对其进行校验和检查。以及向管理节点(mnode)请求查询中指定表的元数据信息(table metadata)
根据元数据信息中的 End Point 信息,将查询请求序列化后发送到该表所在的数据节点(dnode)。dnode 接收到查询请求后,识别出该查询请求指向的虚拟节点(vnode),将消息转发到 vnode 的查询执行队列。vnode 的查询执行线程建立基础的查询执行环境,并立即返回该查询请求,同时开始执行该查询。
......@@ -422,7 +424,7 @@ SELECT COUNT(*) FROM d1001 INTERVAL(1h);
SELECT COUNT(*) FROM d1001 WHERE ts >= '2017-7-14 00:00:00' AND ts < '2017-7-14 23:59:59' INTERVAL(1h) FILL(PREV);
```
针对 d1001 设备采集数据统计每小时记录数,如果某一个小时不存在数据,则返回之前一个小时的统计数据。TDengine 提供前向插值(prev)、线性插值(linear)、NULL 值填充(NULL)、特定值填充(value)
针对 d1001 设备采集数据统计每小时记录数,如果某一个小时不存在数据,则返回之前一个小时的统计数据。TDengine 提供前向插值(prev)、线性插值(linear)、空值填充(NULL)、特定值填充(value)
### 多表聚合查询
......@@ -433,7 +435,7 @@ TDengine 对每个数据采集点单独建表,但在实际应用中经常需
<center> 图 5 多表聚合查询原理图 </center>
1. 应用将一个查询条件发往系统;
2. taosc 将超级表的名字发往 meta node(管理节点)
2. taosc 将超级表的名字发往 meta node(管理节点
3. 管理节点将超级表所拥有的 vnode 列表发回 taosc;
4. taosc 将计算的请求连同标签过滤条件发往这些 vnode 对应的多个数据节点;
5. 每个 vnode 先在内存里查找出自己节点里符合标签过滤条件的表的集合,然后扫描存储的时序数据,完成相应的聚合计算,将结果返回给 taosc;
......
......@@ -4,92 +4,92 @@ title: taosd的设计
---
逻辑上,TDengine系统包含dnode, taosc和App,dnode是服务器侧执行代码taosd的一个运行实例,因此taosd是TDengine的核心,本文对taosd的设计做一简单的介绍,模块内的实现细节请见其他文档。
逻辑上,TDengine 系统包含 dnode,taosc 和 App,dnode 是服务器侧执行代码 taosd 的一个运行实例,因此 taosd 是 TDengine 的核心,本文对 taosd 的设计做一简单的介绍,模块内的实现细节请见其他文档。
## 系统模块图
taosd包含rpc, dnode, vnode, tsdb, query, cq, sync, wal, mnode, http, monitor等模块,具体如下图:
taosd 包含 rpc,dnode,vnode,tsdb,query,cq,sync,wal,mnode,http,monitor 等模块,具体如下图:
![modules.png](/img/architecture/modules.png)
taosd的启动入口是dnode模块,dnode然后启动其他模块,包括可选配置的http, monitor模块。taosc或dnode之间交互的消息都是通过rpc模块进行,dnode模块根据接收到的消息类型,将消息分发到vnode或mnode的消息队列,或由dnode模块自己消费。dnode的工作线程(worker)消费消息队列里的消息,交给mnode或vnode进行处理。下面对各个模块做简要说明。
taosd 的启动入口是 dnode 模块,dnode 然后启动其他模块,包括可选配置的 http,monitor 模块。taosc 或 dnode 之间交互的消息都是通过 rpc 模块进行,dnode 模块根据接收到的消息类型,将消息分发到 vnode 或 mnode 的消息队列,或由 dnode 模块自己消费。dnode 的工作线程(worker)消费消息队列里的消息,交给 mnode 或 vnode 进行处理。下面对各个模块做简要说明。
## RPC模块
该模块负责taosd与taosc, 以及其他数据节点之间的通讯。TDengine没有采取标准的HTTP或gRPC等第三方工具,而是实现了自己的通讯模块RPC。
该模块负责 taosd 与 taosc,以及其他数据节点之间的通讯。TDengine 没有采取标准的 HTTP 或 gRPC 等第三方工具,而是实现了自己的通讯模块 RPC。
考虑到物联网场景下,数据写入的包一般不大,因此除支持TCP连接之外,RPC还支持UDP连接。当数据包小于15K时,RPC将采用UDP方式进行连接,否则将采用TCP连接。对于查询类的消息,RPC不管包的大小,总是采取TCP连接。对于UDP连接,RPC实现了自己的超时、重传、顺序检查等机制,以保证数据可靠传输。
考虑到物联网场景下,数据写入的包一般不大,因此除支持 TCP 连接之外,RPC 还支持 UDP 连接。当数据包小于 15K 时,RPC 将采用 UDP 方式进行连接,否则将采用 TCP 连接。对于查询类的消息,RPC 不管包的大小,总是采取 TCP 连接。对于 UDP 连接,RPC 实现了自己的超时、重传、顺序检查等机制,以保证数据可靠传输。
RPC模块还提供数据压缩功能,如果数据包的字节数超过系统配置参数compressMsgSize, RPC在传输中将自动压缩数据,以节省带宽。
RPC 模块还提供数据压缩功能,如果数据包的字节数超过系统配置参数 compressMsgSize,RPC 在传输中将自动压缩数据,以节省带宽。
为保证数据的安全和数据的integrity, RPC模块采用MD5做数字签名,对数据的真实性和完整性进行认证。
为保证数据的安全和数据的 integrity,RPC 模块采用 MD5 做数字签名,对数据的真实性和完整性进行认证。
## DNODE模块
该模块是整个taosd的入口,它具体负责如下任务:
该模块是整个 taosd 的入口,它具体负责如下任务:
- 系统的初始化,包括
- 从文件taos.cfg读取系统配置参数,从文件dnodeCfg.json读取数据节点的配置参数;
- 启动RPC模块,并建立起与taosc通讯的server连接,与其他数据节点通讯的server连接;
- 启动并初始化dnode的内部管理, 该模块将扫描该数据节点已有的vnode,并打开它们;
- 初始化可配置的模块,如mnode, http, monitor等。
- 从文件 taos.cfg 读取系统配置参数,从文件 dnodeCfg.json 读取数据节点的配置参数;
- 启动 RPC 模块,并建立起与 taosc 通讯的 server 连接,与其他数据节点通讯的 server 连接;
- 启动并初始化 dnode 的内部管理,该模块将扫描该数据节点已有的 vnode ,并打开它们;
- 初始化可配置的模块,如 mnode,http,monitor 等。
- 数据节点的管理,包括
- 定时的向mnode发送status消息,报告自己的状态;
- 根据mnode的指示,创建、改变、删除vnode;
- 根据mnode的指示,修改自己的配置参数;
- 定时的向 mnode 发送 status 消息,报告自己的状态;
- 根据 mnode 的指示,创建、改变、删除 vnode;
- 根据 mnode 的指示,修改自己的配置参数;
- 消息的分发、消费,包括
- 为每一个vnode和mnode的创建并维护一个读队列、一个写队列;
- 将从taosc或其他数据节点来的消息,根据消息类型,将其直接分发到不同的消息队列,或由自己的管理模块直接消费;
- 维护一个读的线程池,消费读队列的消息,交给vnode或mnode处理。为支持高并发,一个读线程(Worker)可以消费多个队列的消息,一个读队列可以由多个worker消费;
- 维护一个写的线程池,消费写队列的消息,交给vnode或mnode处理。为保证写操作的序列化,一个写队列只能由一个写线程负责,但一个写线程可以负责多个写队列。
- 为每一个 vnode 和 mnode 的创建并维护一个读队列、一个写队列;
- 将从 taosc 或其他数据节点来的消息,根据消息类型,将其直接分发到不同的消息队列,或由自己的管理模块直接消费;
- 维护一个读的线程池,消费读队列的消息,交给 vnode 或 mnode 处理。为支持高并发,一个读线程(worker)可以消费多个队列的消息,一个读队列可以由多个 worker 消费;
- 维护一个写的线程池,消费写队列的消息,交给 vnode 或 mnode 处理。为保证写操作的序列化,一个写队列只能由一个写线程负责,但一个写线程可以负责多个写队列。
taosd的消息消费由dnode通过读写线程池进行控制,是系统的中枢。该模块内的结构体图如下:
taosd 的消息消费由 dnode 通过读写线程池进行控制,是系统的中枢。该模块内的结构体图如下:
![dnode.png](/img/architecture/dnode.png)
## VNODE模块
vnode是一独立的数据存储查询逻辑单元,但因为一个vnode只能容许一个DB,因此vnode内部没有account, DB, user等概念。为实现更好的模块化、封装以及未来的扩展,它有很多子模块,包括负责存储的TSDB,负责查询的Query, 负责数据复制的sync,负责数据库日志的的wal, 负责连续查询的cq(continuous query), 负责事件触发的流计算的event等模块,这些子模块只与vnode模块发生关系,与其他模块没有任何调用关系。模块图如下:
vnode 是一独立的数据存储查询逻辑单元,但因为一个 vnode 只能容许一个 DB ,因此 vnode 内部没有 account,DB,user 等概念。为实现更好的模块化、封装以及未来的扩展,它有很多子模块,包括负责存储的 TSDB,负责查询的 query,负责数据复制的 sync,负责数据库日志的的 wal,负责连续查询的 cq(continuous query),负责事件触发的流计算的 event 等模块,这些子模块只与 vnode 模块发生关系,与其他模块没有任何调用关系。模块图如下:
![vnode.png](/img/architecture/vnode.png)
vnode模块向下,与dnodeVRead,dnodeVWrite发生互动,向上,与子模块发生互动。它主要的功能有:
vnode 模块向下,与 dnodeVRead,dnodeVWrite 发生互动,向上,与子模块发生互动。它主要的功能有:
- 协调各个子模块的互动。各个子模块之间都不直接调用,都需要通过vnode模块进行;
- 对于来自taosc或mnode的写操作,vnode模块将其分解为写日志(wal), 转发(sync), 本地存储(tsdb)子模块的操作;
- 对于查询操作,分发到query模块进行。
- 协调各个子模块的互动。各个子模块之间都不直接调用,都需要通过 vnode 模块进行;
- 对于来自 taosc 或 mnode 的写操作,vnode 模块将其分解为写日志(wal),转发(sync),本地存储(TSDB)子模块的操作;
- 对于查询操作,分发到 query 模块进行。
一个数据节点里有多个vnode, 因此vnode模块是有多个运行实例的。每个运行实例是完全独立的。
一个数据节点里有多个 vnode,因此 vnode 模块是有多个运行实例的。每个运行实例是完全独立的。
vnode与其子模块是通过API直接调用,而不是通过消息队列传递。而且各个子模块只与vnode模块有交互,不与dnode, rpc等模块发生任何直接关联。
vnode 与其子模块是通过 API 直接调用,而不是通过消息队列传递。而且各个子模块只与 vnode 模块有交互,不与 dnode,rpc 等模块发生任何直接关联。
## MNODE模块
mnode是整个系统的大脑,负责整个系统的资源调度,负责meta data的管理与存储。
mnode 是整个系统的大脑,负责整个系统的资源调度,负责 meta data 的管理与存储。
一个运行的系统里,只有一个mnode,但它有多个副本(由系统配置参数numOfMnodes控制)。这些副本分布在不同的dnode里,目的是保证系统的高可靠运行。副本之间的数据复制是采用同步而非异步的方式,以确保数据的一致性,确保数据不会丢失。这些副本会自动选举一个Master,其他副本是slave。所有数据更新类的操作,都只能在master上进行,而查询类的可以在slave节点上进行。代码实现上,同步模块与vnode共享,但mnode被分配一个特殊的vgroup ID: 1,而且quorum大于1。整个集群系统是由多个dnode组成的,运行的mnode的副本数不可能超过dnode的个数,但不会超过配置的副本数。如果某个mnode副本宕机一段时间,只要超过半数的mnode副本仍在运行,运行的mnode会自动根据整个系统的资源情况,在其他dnode里再启动一个mnode, 以保证运行的副本数。
一个运行的系统里,只有一个 mnode,但它有多个副本(由系统配置参数 numOfMnodes 控制)。这些副本分布在不同的 dnode 里,目的是保证系统的高可靠运行。副本之间的数据复制是采用同步而非异步的方式,以确保数据的一致性,确保数据不会丢失。这些副本会自动选举一个 Master,其他副本是 slave。所有数据更新类的操作,都只能在 master 上进行,而查询类的可以在 slave 节点上进行。代码实现上,同步模块与 vnode 共享,但 mnode 被分配一个特殊的 vgroup ID: 1,而且 quorum 大于1。整个集群系统是由多个 dnode 组成的,运行的 mnode 的副本数不可能超过 dnode 的个数,但不会超过配置的副本数。如果某个 mnode 副本宕机一段时间,只要超过半数的 mnode 副本仍在运行,运行的 mnode 会自动根据整个系统的资源情况,在其他 dnode 里再启动一个 mnode,以保证运行的副本数。
各个dnode通过信息交换,保存有mnode各个副本的End Point列表,并向其中的master节点定时(间隔由系统配置参数statusInterval控制)发送status消息,消息体里包含该dnode的CPU、内存、剩余存储空间、vnode个数,以及各个vnode的状态(存储空间、原始数据大小、记录条数、角色等)。这样mnode就了解整个系统的资源情况,如果用户创建新的表,就可以决定需要在哪个dnode创建;如果增加或删除dnode, 或者监测到某dnode数据过热、或离线太长,就可以决定需要挪动那些vnode,以实现负载均衡。
各个 dnode 通过信息交换,保存有 mnode 各个副本的 End Point 列表,并向其中的 master 节点定时(间隔由系统配置参数 statusInterval 控制)发送 status 消息,消息体里包含该 dnode 的 CPU、内存、剩余存储空间、vnode 个数,以及各个 vnode 的状态(存储空间、原始数据大小、记录条数、角色等)。这样 mnode 就了解整个系统的资源情况,如果用户创建新的表,就可以决定需要在哪个 dnode 创建;如果增加或删除 dnode,或者监测到某 dnode 数据过热、或离线太长,就可以决定需要挪动那些 vnode,以实现负载均衡。
mnode里还负责account, user, DB, stable, table, vgroup, dnode的创建、删除与更新。mnode不仅把这些entity的meta data保存在内存,还做持久化存储。但为节省内存,各个表的标签值不保存在mnode(保存在vnode),而且子表不维护自己的schema, 而是与stable共享。为减小mnode的查询压力,taosc会缓存table、stable的schema。对于查询类的操作,各个slave mnode也可以提供,以减轻master压力。
mnode 里还负责 account,user,DB,stable,table,vgroup,dnode 的创建、删除与更新。mnode 不仅把这些 entity 的 meta data 保存在内存,还做持久化存储。但为节省内存,各个表的标签值不保存在 mnode(保存在 vnode),而且子表不维护自己的 schema,而是与 stable 共享。为减小 mnode 的查询压力,taosc 会缓存 table、stable 的 schema。对于查询类的操作,各个 slave mnode 也可以提供,以减轻 master 压力。
## TSDB模块
TSDB模块是VNODE中的负责快速高并发地存储和读取属于该VNODE的表的元数据及采集的时序数据的引擎。除此之外,TSDB还提供了表结构的修改、表标签值的修改等功能。TSDB提供API供VNODE和Query等模块调用。TSDB中存储了两类数据,1:元数据信息;2:时序数据
TSDB 模块是 vnode 中的负责快速高并发地存储和读取属于该 vnode 的表的元数据及采集的时序数据的引擎。除此之外,TSDB 还提供了表结构的修改、表标签值的修改等功能。TSDB 提供 API 供 vnode 和 query 等模块调用。TSDB 中存储了两类数据,1:元数据信息;2:时序数据
### 元数据信息
TSDB中存储的元数据包含属于其所在的VNODE中表的类型,schema的定义等。对于超级表和超级表下的子表而言,又包含了tag的schema定义以及子表的tag值等。对于元数据信息而言,TSDB就相当于一个全内存的KV型数据库,属于该VNODE的表对象全部在内存中,方便快速查询表的信息。除此之外,TSDB还对其中的子表,按照tag的第一列取值做了全内存的索引,大大加快了对于标签的过滤查询。TSDB中的元数据的最新状态在落盘时,会以追加(append-only)的形式,写入到meta文件中。meta文件只进行追加操作,即便是元数据的删除,也会以一条记录的形式写入到文件末尾。TSDB也提供了对于元数据的修改操作,如表schema的修改,tag schema的修改以及tag值的修改等。
TSDB 中存储的元数据包含属于其所在的 vnode 中表的类型,schema 的定义等。对于超级表和超级表下的子表而言,又包含了 tag 的 schema 定义以及子表的 tag 值等。对于元数据信息而言,TSDB 就相当于一个全内存的KV型数据库,属于该 vnode 的表对象全部在内存中,方便快速查询表的信息。除此之外,TSDB 还对其中的子表,按照 tag 的第一列取值做了全内存的索引,大大加快了对于标签的过滤查询。TSDB 中的元数据的最新状态在落盘时,会以追加(append-only)的形式,写入到 meta 文件中。meta 文件只进行追加操作,即便是元数据的删除,也会以一条记录的形式写入到文件末尾。TSDB 也提供了对于元数据的修改操作,如表 schema 的修改,tag schema 的修改以及 tag 值的修改等。
### 时序数据
每个TSDB在创建时,都会事先分配一定量的内存缓冲区,且内存缓冲区的大小可配可修改。表采集的时序数据,在写入TSDB时,首先以追加的方式写入到分配的内存缓冲区中,同时建立基于时间戳的内存索引,方便快速查询。当内存缓冲区的数据积累到一定的程度时(达到内存缓冲区总大小的1/3),则会触发落盘操作,将缓冲区中的数据持久化到硬盘文件上。时序数据在内存缓冲区中是以行(row)的形式存储的。
每个 TSDB 在创建时,都会事先分配一定量的内存缓冲区,且内存缓冲区的大小可配可修改。表采集的时序数据,在写入 TSDB 时,首先以追加的方式写入到分配的内存缓冲区中,同时建立基于时间戳的内存索引,方便快速查询。当内存缓冲区的数据积累到一定的程度时(达到内存缓冲区总大小的 1/3),则会触发落盘操作,将缓冲区中的数据持久化到硬盘文件上。时序数据在内存缓冲区中是以行(row)的形式存储的。
而时序数据在写入到TSDB的数据文件时,是以列(column)的形式存储的。TSDB中的数据文件包含多个数据文件组,每个数据文件组中又包含.head、.data和.last三个文件,如(v2f1801.head、v2f1801.data、v2f1801.last)数据文件组。TSDB中的数据文件组是按照时间跨度进行分片的,默认是10天一个文件组,且可通过配置文件及建库选项进行配置。分片的数据文件组又按照编号递增排列,方便快速定位某一时间段的时序数据,高效定位数据文件组。时序数据在TSDB的数据文件中是以块的形式进行列式存储的,每个块中只包含一张表的数据,且数据在一个块中是按照时间顺序递增排列的。在一个数据文件组中,.head文件负责存储数据块的索引及统计信息,如每个块的位置,压缩算法,时间戳范围等。存储在.head文件中一张表的索引信息是按照数据块中存储的数据的时间递增排列的,方便进行折半查找等工作。.head和.last文件是存储真实数据块的文件,若数据块中的数据累计到一定程度,则会写入.data文件中,否则,会写入.last文件中,等待下次落盘时合并数据写入.data文件中,从而大大减少文件中块的个数,避免数据的过度碎片化。
而时序数据在写入到 TSDB 的数据文件时,是以列(column)的形式存储的。TSDB 中的数据文件包含多个数据文件组,每个数据文件组中又包含 .head、.data 和 .last 三个文件,如(v2f1801.head、v2f1801.data、v2f1801.last)数据文件组。TSDB 中的数据文件组是按照时间跨度进行分片的,默认是 10 天一个文件组,且可通过配置文件及建库选项进行配置。分片的数据文件组又按照编号递增排列,方便快速定位某一时间段的时序数据,高效定位数据文件组。时序数据在 TSDB 的数据文件中是以块的形式进行列式存储的,每个块中只包含一张表的数据,且数据在一个块中是按照时间顺序递增排列的。在一个数据文件组中,.head 文件负责存储数据块的索引及统计信息,如每个块的位置,压缩算法,时间戳范围等。存储在 .head 文件中一张表的索引信息是按照数据块中存储的数据的时间递增排列的,方便进行折半查找等工作。.head 和 .last文件是存储真实数据块的文件,若数据块中的数据累计到一定程度,则会写入 .data 文件中,否则,会写入 .last 文件中,等待下次落盘时合并数据写入 .data 文件中,从而大大减少文件中块的个数,避免数据的过度碎片化。
## Query模块
该模块负责整体系统的查询处理。客户端调用该该模块进行SQL语法解析,并将查询或写入请求发送到vnode,同时负责针对超级表的查询进行二阶段的聚合操作。在Vnode端,该模块调用TSDB模块读取系统中存储的数据进行查询处理。Query模块还定义了系统能够支持的全部查询函数,查询函数的实现机制与查询框架无耦合,可以在不修改查询流程的情况下动态增加查询函数。详细的设计请参见《TDengine 2.0查询模块设计》。
该模块负责整体系统的查询处理。客户端调用该该模块进行 SQL 语法解析,并将查询或写入请求发送到 vnode ,同时负责针对超级表的查询进行二阶段的聚合操作。在 vnode 端,该模块调用 TSDB 模块读取系统中存储的数据进行查询处理。query 模块还定义了系统能够支持的全部查询函数,查询函数的实现机制与查询框架无耦合,可以在不修改查询流程的情况下动态增加查询函数。详细的设计请参见《TDengine 2.0 查询模块设计》。
## SYNC模块
......@@ -99,23 +99,23 @@ TSDB中存储的元数据包含属于其所在的VNODE中表的类型,schema
## WAL模块
该模块负责将新插入的数据写入write ahead log(WAL), 为vnode, mnode共享。以保证服务器crash或其他故障,能从WAL中恢复数据。
该模块负责将新插入的数据写入 write ahead log(WAL),为vnode,mnode共享。以保证服务器 crash 或其他故障,能从 WAL 中恢复数据。
每个vnode/mnode模块实例会有一对应的wal模块实例,是完全一一对应的。WAL的落盘操作由两个参数walLevel, fsync控制。看具体场景,如果要100%保证数据不会丢失,需要将walLevel配置为2,fsync设置为0,每条数据插入请求,都会实时落盘后,才会给应用确认
每个 vnode/mnode 模块实例会有一对应的 wal 模块实例,是完全一一对应的。WAL 的落盘操作由两个参数 walLevel,fsync 控制。看具体场景,如果要 100% 保证数据不会丢失,需要将 walLevel 配置为 2,fsync 设置为 0,每条数据插入请求,都会实时落盘后,才会给应用确认
## HTTP模块
该模块负责处理系统对外的RESTful接口,可以通过配置,由dnode启动或停止。
该模块负责处理系统对外的 RESTful 接口,可以通过配置,由 dnode 启动或停止 。(仅 2.2 及之前的版本中存在)
该模块将接收到的RESTful请求,做了各种合法性检查后,将其变成标准的SQL语句,通过taosc的异步接口,将请求发往整个系统中的任一dnode。收到处理后的结果后,再翻译成HTTP协议,返回给应用。
该模块将接收到的 RESTful 请求,做了各种合法性检查后,将其变成标准的 SQL 语句,通过 taosc 的异步接口,将请求发往整个系统中的任一 dnode 。收到处理后的结果后,再翻译成 HTTP 协议,返回给应用。
如果HTTP模块启动,就意味着启动了一个taosc的实例。任一一个dnode都可以启动该模块,以实现对RESTful请求的分布式处理。
## Monitor模块
该模块负责检测一个dnode的运行状态,可以通过配置,由dnode启动或停止。原则上,每个dnode都应该启动一个monitor实例。
该模块负责检测一个 dnode 的运行状态,可以通过配置,由 dnode 启动或停止。原则上,每个 dnode 都应该启动一个 monitor 实例。
Monitor采集TDengine里的关键操作,比如创建、删除、更新账号、表、库等,而且周期性的收集CPU、内存、网络等资源的使用情况(采集周期由系统配置参数monitorInterval控制)。获得这些数据后,monitor模块将采集的数据写入系统的日志库(DB名字由系统配置参数monitorDbName控制)。
Monitor 采集 TDengine 里的关键操作,比如创建、删除、更新账号、表、库等,而且周期性的收集 CPU、内存、网络等资源的使用情况(采集周期由系统配置参数 monitorInterval 控制)。获得这些数据后,monitor 模块将采集的数据写入系统的日志库(DB 名字由系统配置参数 monitorDbName 控制)。
Monitor模块使用taosc来将采集的数据写入系统,因此每个monitor实例,都有一个taosc运行实例。
Monitor 模块使用 taosc 来将采集的数据写入系统,因此每个 monitor 实例,都有一个 taosc 运行实例。
......@@ -8,10 +8,10 @@ title: 支持的数据类型
- 时间格式为 `YYYY-MM-DD HH:mm:ss.MS`,默认时间分辨率为毫秒。比如:`2017-08-12 18:25:58.128`
- 内部函数 now 是客户端的当前时间
- 插入记录时,如果时间戳为 now,插入数据时使用提交这条记录的客户端的当前时间
- Epoch Time:时间戳也可以是一个长整数,表示从格林威治时间 1970-01-01 00:00:00.000 (UTC/GMT) 开始的毫秒数(相应地,如果所在 Database 的时间精度设置为“微秒”,则长整型格式的时间戳含义也就对应于从格林威治时间 1970-01-01 00:00:00.000 (UTC/GMT) 开始的微秒数;纳秒精度的逻辑也是类似的。)
- 时间可以加减,比如 now-2h,表明查询时刻向前推 2 个小时(最近 2 小时)。数字后面的时间单位可以是 b(纳秒)、u(微秒)、a(毫秒)、s(秒)、m(分)、h(小时)、d(天)、w(周)。 比如 `select * from t1 where ts > now-2w and ts <= now-1w`,表示查询两周前整整一周的数据。在指定降采样操作(down sampling)的时间窗口(interval)时,时间单位还可以使用 n(自然月) 和 y(自然年)。
- Epoch Time:时间戳也可以是一个长整数,表示从格林威治时间 1970-01-01 00:00:00.000 (UTC/GMT) 开始的毫秒数(相应地,如果所在 Database 的时间精度设置为“微秒”,则长整型格式的时间戳含义也就对应于从格林威治时间 1970-01-01 00:00:00.000 (UTC/GMT) 开始的微秒数;纳秒精度逻辑类似。)
- 时间可以加减,比如 now-2h,表明查询时刻向前推 2 个小时(最近 2 小时)。数字后面的时间单位可以是 b(纳秒)、u(微秒)、a(毫秒)、s(秒)、m(分)、h(小时)、d(天)、w(周)。 比如 `select * from t1 where ts > now-2w and ts <= now-1w`,表示查询两周前整整一周的数据。在指定降采样操作(down sampling)的时间窗口(interval)时,时间单位还可以使用 n (自然月) 和 y (自然年)。
TDengine 缺省的时间戳是毫秒精度,但通过在 `CREATE DATABASE` 时传递的 PRECISION 参数就可以支持微秒和纳秒。(从 2.1.5.0 版本开始支持纳秒精度)
TDengine 缺省的时间戳精度是毫秒,但通过在 `CREATE DATABASE` 时传递的 PRECISION 参数也可以支持微秒和纳秒。(从 2.1.5.0 版本开始支持纳秒精度)
```
CREATE DATABASE db_name PRECISION 'ns';
......@@ -23,15 +23,15 @@ CREATE DATABASE db_name PRECISION 'ns';
| --- | :-------: | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 1 | TIMESTAMP | 8 | 时间戳。缺省精度毫秒,可支持微秒和纳秒。从格林威治时间 1970-01-01 00:00:00.000 (UTC/GMT) 开始,计时不能早于该时间。(从 2.0.18.0 版本开始,已经去除了这一时间范围限制)(从 2.1.5.0 版本开始支持纳秒精度) |
| 2 | INT | 4 | 整型,范围 [-2^31+1, 2^31-1], -2^31 用作 NULL |
| 3 | BIGINT | 8 | 长整型,范围 [-2^63+1, 2^63-1], -2^63 用 NULL |
| 3 | BIGINT | 8 | 长整型,范围 [-2^63+1, 2^63-1], -2^63 用 NULL |
| 4 | FLOAT | 4 | 浮点型,有效位数 6-7,范围 [-3.4E38, 3.4E38] |
| 5 | DOUBLE | 8 | 双精度浮点型,有效位数 15-16,范围 [-1.7E308, 1.7E308] |
| 6 | BINARY | 自定义 | 记录单字节字符串,建议只用于处理 ASCII 可见字符,中文等多字节字符需使用 nchar。理论上,最长可以有 16374 字节。binary 仅支持字符串输入,字符串两端需使用单引号引用。使用时须指定大小,如 binary(20) 定义了最长为 20 个单字节字符的字符串,每个字符占 1 byte 的存储空间,总共固定占用 20 bytes 的空间,此时如果用户字符串超出 20 字节将会报错。对于字符串内的单引号,可以用转义字符反斜线加单引号来表示,即 `\’`。 |
| 7 | SMALLINT | 2 | 短整型, 范围 [-32767, 32767], -32768 用 NULL |
| 8 | TINYINT | 1 | 单字节整型,范围 [-127, 127], -128 用 NULL |
| 7 | SMALLINT | 2 | 短整型, 范围 [-32767, 32767], -32768 用 NULL |
| 8 | TINYINT | 1 | 单字节整型,范围 [-127, 127], -128 用 NULL |
| 9 | BOOL | 1 | 布尔型,{true, false} |
| 10 | NCHAR | 自定义 | 记录包含多字节字符在内的字符串,如中文字符。每个 nchar 字符占用 4 bytes 的存储空间。字符串两端使用单引号引用,字符串内的单引号需用转义字符 `\’`。nchar 使用时须指定字符串大小,类型为 nchar(10) 的列表示此列的字符串最多存储 10 个 nchar 字符,会固定占用 40 bytes 的空间。如果用户字符串长度超出声明长度,将会报错。 |
| 11 | JSON | | json 数据类型, 只有 tag 类型可以是 json 格式 |
| 11 | JSON | | json 数据类型, 只有 tag 可以是 json 格式 |
<!-- REPLACE_OPEN_TO_ENTERPRISE__COLUMN_TYPE_ADDONS -->
......@@ -41,7 +41,7 @@ TDengine 对 SQL 语句中的英文字符不区分大小写,自动转化为小
:::
:::note
虽然 Binary 类型在底层存储上支持字节型的二进制字符,但不同编程语言对二进制数据的处理方式并不保证一致,因此建议在 Binary 类型中只存储 ASCII 可见字符,而避免存储不可见字符。多字节的数据,例如中文字符,则需要使用 nchar 类型进行保存。如果强行使用 Binary 类型保存中文字符,虽然有时也能正常读写,但并不带有字符集信息,很容易出现数据乱码甚至数据损坏等情况。
虽然 BINARY 类型在底层存储上支持字节型的二进制字符,但不同编程语言对二进制数据的处理方式并不保证一致,因此建议在 BINARY 类型中只存储 ASCII 可见字符,而避免存储不可见字符。多字节的数据,例如中文字符,则需要使用 NCHAR 类型进行保存。如果强行使用 BINARY 类型保存中文字符,虽然有时也能正常读写,但并不带有字符集信息,很容易出现数据乱码甚至数据损坏等情况。
:::
......
......@@ -3,8 +3,11 @@ sidebar_label: 超级表管理
title: 超级表 STable 管理
---
:::note
注意:在 2.0.15.0 及以后的版本中,开始支持 STABLE 保留字。也即,在本节后文的指令说明中,CREATE、DROP、ALTER 三个指令在老版本中保留字需写作 TABLE 而不是 STABLE。
在 2.0.15.0 及以后的版本中开始支持 STABLE 保留字。也即,在本节后文的指令说明中,CREATE、DROP、ALTER 三个指令在 2.0.15.0 之前的版本中 STABLE 保留字需写作 TABLE。
:::
## 创建超级表
......
......@@ -221,42 +221,43 @@ Query OK, 1 row(s) in set (0.000081s)
## \_block_dist 函数
用于获得指定的(超级)表的数据块分布信息
**功能说明**: 用于获得指定的(超级)表的数据块分布信息
```txt title="语法"
SELECT _block_dist() FROM { tb_name | stb_name }
```
返回结果类型:字符串。
**返回结果类型**:字符串。
适用数据类型:不能输入任何参数。
**适用数据类型**:不能输入任何参数。
嵌套子查询支持:不支持子查询或嵌套查询。
**嵌套子查询支持**:不支持子查询或嵌套查询。
返回 FROM 子句中输入的表或超级表的数据块分布情况。不支持查询条件。
**返回结果**:
返回的结果是该表或超级表的数据块所包含的行数的数据分布直方图。
- 返回 FROM 子句中输入的表或超级表的数据块分布情况。不支持查询条件。
- 返回的结果是该表或超级表的数据块所包含的行数的数据分布直方图。
```txt title="返回结果"
summary:
5th=[392], 10th=[392], 20th=[392], 30th=[392], 40th=[792], 50th=[792] 60th=[792], 70th=[792], 80th=[792], 90th=[792], 95th=[792], 99th=[792] Min=[392(Rows)] Max=[800(Rows)] Avg=[666(Rows)] Stddev=[2.17] Rows=[2000], Blocks=[3], Size=[5.440(Kb)] Comp=[0.23] RowsInMem=[0] SeekHeaderTime=[1(us)]
```
上述信息的说明如下:
**上述信息的说明如下**:
1. 查询的(超级)表所包含的存储在文件中的数据块(data block)中所包含的数据行的数量分布直方图信息:5%, 10%, 20%, 30%, 40%, 50%, 60%, 70%, 80%, 90%, 95%, 99% 的数值;
2. 所有数据块中,包含行数最少的数据块所包含的行数量, 其中的 Min 指标 392 行。
3. 所有数据块中,包含行数最多的数据块所包含的行数量, 其中的 Max 指标 800 行。
4. 所有数据块行数的算数平均值 666 行(其中的 Avg 项)。
5. 所有数据块中行数分布的均方差为 2.17 ( stddev )。
6. 数据块包含的行的总数为 2000 行(Rows)。
7. 数据块总数是 3 个数据块 (Blocks)。
8. 数据块占用磁盘空间大小 5.44 Kb (size)。
9. 压缩后的数据块的大小除以原始数据的所获得的压缩比例: 23%(Comp),及压缩后的数据规模是原始数据规模的 23%。
10. 内存中存在的数据行数是 0,表示内存中没有数据缓存。
11. 获取数据块信息的过程中读取头文件的时间开销 1 微秒(SeekHeaderTime)。
- 查询的(超级)表所包含的存储在文件中的数据块(data block)中所包含的数据行的数量分布直方图信息:5%, 10%, 20%, 30%, 40%, 50%, 60%, 70%, 80%, 90%, 95%, 99% 的数值;
- 所有数据块中,包含行数最少的数据块所包含的行数量, 其中的 Min 指标 392 行。
- 所有数据块中,包含行数最多的数据块所包含的行数量, 其中的 Max 指标 800 行。
- 所有数据块行数的算数平均值 666 行(其中的 Avg 项)。
- 所有数据块中行数分布的均方差为 2.17 ( stddev )。
- 数据块包含的行的总数为 2000 行(Rows)。
- 数据块总数是 3 个数据块 (Blocks)。
- 数据块占用磁盘空间大小 5.44 Kb (size)。
- 压缩后的数据块的大小除以原始数据的所获得的压缩比例: 23%(Comp),及压缩后的数据规模是原始数据规模的 23%。
- 内存中存在的数据行数是 0,表示内存中没有数据缓存。
- 获取数据块信息的过程中读取头文件的时间开销 1 微秒(SeekHeaderTime)。
支持版本:指定计算算法的功能从 2.1.0.x 版本开始,2.1.0.0 之前的版本不支持指定使用算法的功能。
**支持版本**:指定计算算法的功能从 2.1.0.x 版本开始,2.1.0.0 之前的版本不支持指定使用算法的功能。
## TAOS SQL 中特殊关键词
......@@ -322,18 +323,20 @@ Query OK, 1 row(s) in set (0.001091s)
| like | match a wildcard string | **`binary`** **`nchar`** |
| match/nmatch | filter regex | **`binary`** **`nchar`** |
1. <\> 算子也可以写为 != ,请注意,这个算子不能用于数据表第一列的 timestamp 字段。
2. like 算子使用通配符字符串进行匹配检查。
**使用说明**:
- <\> 算子也可以写为 != ,请注意,这个算子不能用于数据表第一列的 timestamp 字段。
- like 算子使用通配符字符串进行匹配检查。
- 在通配符字符串中:'%'(百分号)匹配 0 到任意个字符;'\_'(下划线)匹配单个任意 ASCII 字符。
- 如果希望匹配字符串中原本就带有的 \_(下划线)字符,那么可以在通配符字符串中写作 `\_`,也即加一个反斜线来进行转义。(从 2.2.0.0 版本开始支持)
- 通配符字符串最长不能超过 20 字节。(从 2.1.6.1 版本开始,通配符字符串的长度放宽到了 100 字节,并可以通过 taos.cfg 中的 maxWildCardsLength 参数来配置这一长度限制。但不建议使用太长的通配符字符串,将有可能严重影响 LIKE 操作的执行性能。)
3. 同时进行多个字段的范围过滤,需要使用关键词 AND 来连接不同的查询条件,暂不支持 OR 连接的不同列之间的查询过滤条件。
- 同时进行多个字段的范围过滤,需要使用关键词 AND 来连接不同的查询条件,暂不支持 OR 连接的不同列之间的查询过滤条件。
- 从 2.3.0.0 版本开始,已支持完整的同一列和/或不同列间的 AND/OR 运算。
4. 针对单一字段的过滤,如果是时间过滤条件,则一条语句中只支持设定一个;但针对其他的(普通)列或标签列,则可以使用 `OR` 关键字进行组合条件的查询过滤。例如: `((value > 20 AND value < 30) OR (value < 12))`
- 针对单一字段的过滤,如果是时间过滤条件,则一条语句中只支持设定一个;但针对其他的(普通)列或标签列,则可以使用 `OR` 关键字进行组合条件的查询过滤。例如: `((value > 20 AND value < 30) OR (value < 12))`
- 从 2.3.0.0 版本开始,允许使用多个时间过滤条件,但首列时间戳的过滤运算结果只能包含一个区间。
5. 从 2.0.17.0 版本开始,条件过滤开始支持 BETWEEN AND 语法,例如 `WHERE col2 BETWEEN 1.5 AND 3.25` 表示查询条件为“1.5 ≤ col2 ≤ 3.25”。
6. 从 2.1.4.0 版本开始,条件过滤开始支持 IN 算子,例如 `WHERE city IN ('Beijing', 'Shanghai')`。说明:BOOL 类型写作 `{true, false}``{0, 1}` 均可,但不能写作 0、1 之外的整数;FLOAT 和 DOUBLE 类型会受到浮点数精度影响,集合内的值在精度范围内认为和数据行的值完全相等才能匹配成功;TIMESTAMP 类型支持非主键的列。
7. 从 2.3.0.0 版本开始,条件过滤开始支持正则表达式,关键字 match/nmatch,不区分大小写。
- 从 2.0.17.0 版本开始,条件过滤开始支持 BETWEEN AND 语法,例如 `WHERE col2 BETWEEN 1.5 AND 3.25` 表示查询条件为“1.5 ≤ col2 ≤ 3.25”。
- 从 2.1.4.0 版本开始,条件过滤开始支持 IN 算子,例如 `WHERE city IN ('Beijing', 'Shanghai')`。说明:BOOL 类型写作 `{true, false}``{0, 1}` 均可,但不能写作 0、1 之外的整数;FLOAT 和 DOUBLE 类型会受到浮点数精度影响,集合内的值在精度范围内认为和数据行的值完全相等才能匹配成功;TIMESTAMP 类型支持非主键的列。
- 从 2.3.0.0 版本开始,条件过滤开始支持正则表达式,关键字 match/nmatch,不区分大小写。
## 正则表达式过滤
......@@ -375,14 +378,18 @@ WHERE t1.ts = t2.ts AND t1.deviceid = t2.deviceid AND t1.status=0;
类似地,也可以对多个子查询的查询结果进行 JOIN 操作。
注意,JOIN 操作存在如下限制要求:
:::note
JOIN语句存在如下限制要求:
1. 参与一条语句中 JOIN 操作的表/超级表最多可以有 10 个。
2. 在包含 JOIN 操作的查询语句中不支持 FILL。
3. 暂不支持参与 JOIN 操作的表之间聚合后的四则运算。
4. 不支持只对其中一部分表做 GROUP BY。
5. JOIN 查询的不同表的过滤条件之间不能为 OR。
6. JOIN 查询要求连接条件不能是普通列,只能针对标签和主时间字段列(第一列)。
- 参与一条语句中 JOIN 操作的表/超级表最多可以有 10 个。
- 在包含 JOIN 操作的查询语句中不支持 FILL。
- 暂不支持参与 JOIN 操作的表之间聚合后的四则运算。
- 不支持只对其中一部分表做 GROUP BY。
- JOIN 查询的不同表的过滤条件之间不能为 OR。
- JOIN 查询要求连接条件不能是普通列,只能针对标签和主时间字段列(第一列)。
:::
## 嵌套查询
......@@ -396,17 +403,17 @@ SELECT ... FROM (SELECT ... FROM ...) ...;
:::info
1. 目前仅支持一层嵌套,也即不能在子查询中再嵌入子查询。
2. 内层查询的返回结果将作为“虚拟表”供外层查询使用,此虚拟表可以使用 AS 语法做重命名,以便于外层查询中方便引用。
3. 目前不能在“连续查询”功能中使用子查询。
4. 在内层和外层查询中,都支持普通的表间/超级表间 JOIN。内层查询的计算结果也可以再参与数据子表的 JOIN 操作。
5. 目前内层查询、外层查询均不支持 UNION 操作。
6. 内层查询支持的功能特性与非嵌套的查询语句能力是一致的。
- 目前仅支持一层嵌套,也即不能在子查询中再嵌入子查询。
- 内层查询的返回结果将作为“虚拟表”供外层查询使用,此虚拟表可以使用 AS 语法做重命名,以便于外层查询中方便引用。
- 目前不能在“连续查询”功能中使用子查询。
- 在内层和外层查询中,都支持普通的表间/超级表间 JOIN。内层查询的计算结果也可以再参与数据子表的 JOIN 操作。
- 目前内层查询、外层查询均不支持 UNION 操作。
- 内层查询支持的功能特性与非嵌套的查询语句能力是一致的。
- 内层查询的 ORDER BY 子句一般没有意义,建议避免这样的写法以免无谓的资源消耗。
7. 与非嵌套的查询语句相比,外层查询所能支持的功能特性存在如下限制:
- 与非嵌套的查询语句相比,外层查询所能支持的功能特性存在如下限制:
- 计算函数部分:
_. 如果内层查询的结果数据未提供时间戳,那么计算过程依赖时间戳的函数在外层会无法正常工作。例如:TOP, BOTTOM, FIRST, LAST, DIFF。
_. 计算过程需要两遍扫描的函数,在外层查询中无法正常工作。例如:此类函数包括:STDDEV, PERCENTILE。
- 如果内层查询的结果数据未提供时间戳,那么计算过程依赖时间戳的函数在外层会无法正常工作。例如:TOP, BOTTOM, FIRST, LAST, DIFF。
- 计算过程需要两遍扫描的函数,在外层查询中无法正常工作。例如:此类函数包括:STDDEV, PERCENTILE。
- 外层查询中不支持 IN 算子,但在内层中可以使用。
- 外层查询不支持 GROUP BY。
......
......@@ -13,20 +13,21 @@ TDengine 支持针对数据的聚合查询。提供支持的聚合和选择函
SELECT COUNT([*|field_name]) FROM tb_name [WHERE clause];
```
- **功能说明**:统计表/超级表中记录行数或某列的非空值个数。
- **返回数据类型**:长整型 INT64。
- **应用字段**:应用全部字段。
- **适用于**:表、超级表。
**功能说明**:统计表/超级表中记录行数或某列的非空值个数。
:::info
**返回数据类型**:长整型 INT64。
**应用字段**:应用全部字段。
**适用于**:表、超级表。
**使用说明**:
- 可以使用星号(\*)来替代具体的字段,使用星号(\*)返回全部记录数量。
- 针对同一表的(不包含 NULL 值)字段查询结果均相同。
- 如果统计对象是具体的列,则返回该列中非 NULL 值的记录数量。
:::
示例:
**示例**
```
taos> SELECT COUNT(*), COUNT(voltage) FROM meters;
......@@ -48,12 +49,15 @@ Query OK, 1 row(s) in set (0.001075s)
SELECT AVG(field_name) FROM tb_name [WHERE clause];
```
- **功能说明**:统计表/超级表中某列的平均值。
- **返回数据类型**:双精度浮点数 Double。
- **应用字段**:不能应用在 timestamp、binary、nchar、bool 字段。
- **适用于**:表、超级表。
**功能说明**:统计表/超级表中某列的平均值。
**返回数据类型**:双精度浮点数 Double。
示例:
**应用字段**:不能应用在 timestamp、binary、nchar、bool 字段。
**适用于**:表、超级表。
**示例**
```
taos> SELECT AVG(current), AVG(voltage), AVG(phase) FROM meters;
......@@ -75,12 +79,17 @@ Query OK, 1 row(s) in set (0.000943s)
SELECT TWA(field_name) FROM tb_name WHERE clause;
```
- **功能说明**:时间加权平均函数。统计表中某列在一段时间内的时间加权平均。
- **返回数据类型**:双精度浮点数 Double。
- **应用字段**:不能应用在 timestamp、binary、nchar、bool 类型字段。
- **适用于**:表、(超级表。
**功能说明**:时间加权平均函数。统计表中某列在一段时间内的时间加权平均。
**返回数据类型**:双精度浮点数 Double。
**应用字段**:不能应用在 timestamp、binary、nchar、bool 类型字段。
说明:从 2.1.3.0 版本开始,TWA 函数可以在由 GROUP BY 划分出单独时间线的情况下用于超级表(也即 GROUP BY tbname)。
**适用于**:表、超级表。
**使用说明**
- 从 2.1.3.0 版本开始,TWA 函数可以在由 GROUP BY 划分出单独时间线的情况下用于超级表(也即 GROUP BY tbname)。
### IRATE
......@@ -94,9 +103,11 @@ SELECT IRATE(field_name) FROM tb_name WHERE clause;
**应用字段**:不能应用在 timestamp、binary、nchar、bool 类型字段。
适用于:**表、(超级表)**
**适用于**:表、超级表。
**使用说明**
说明:(从 2.1.3.0 版本开始新增此函数)IRATE 可以在由 GROUP BY 划分出单独时间线的情况下用于超级表(也即 GROUP BY tbname)。
- 从 2.1.3.0 版本开始此函数可用,IRATE 可以在由 GROUP BY 划分出单独时间线的情况下用于超级表(也即 GROUP BY tbname)。
### SUM
......@@ -112,7 +123,7 @@ SELECT SUM(field_name) FROM tb_name [WHERE clause];
**适用于**:表、超级表。
示例
**示例**
```
taos> SELECT SUM(current), SUM(voltage), SUM(phase) FROM meters;
......@@ -140,9 +151,9 @@ SELECT STDDEV(field_name) FROM tb_name [WHERE clause];
**应用字段**:不能应用在 timestamp、binary、nchar、bool 类型字段。
**适用于**:表。(从 2.0.15.1 版本开始,本函数也支持**超级表**
**适用于**:表、超级表(从 2.0.15.1 版本开始
示例
**示例**
```
taos> SELECT STDDEV(current) FROM d1001;
......@@ -158,12 +169,15 @@ Query OK, 1 row(s) in set (0.000915s)
SELECT LEASTSQUARES(field_name, start_val, step_val) FROM tb_name [WHERE clause];
```
- **功能说明**:统计表中某列的值是主键(时间戳)的拟合直线方程。start_val 是自变量初始值,step_val 是自变量的步长值。
- **返回数据类型**:字符串表达式(斜率, 截距)。
- **应用字段**:不能应用在 timestamp、binary、nchar、bool 类型字段。
- **适用于**:表。
**功能说明**:统计表中某列的值是主键(时间戳)的拟合直线方程。start_val 是自变量初始值,step_val 是自变量的步长值。
示例:
**返回数据类型**:字符串表达式(斜率, 截距)。
**应用字段**:不能应用在 timestamp、binary、nchar、bool 类型字段。
**适用于**:表。
**示例**
```
taos> SELECT LEASTSQUARES(current, 1, 1) FROM d1001;
......@@ -179,13 +193,17 @@ Query OK, 1 row(s) in set (0.000921s)
SELECT MODE(field_name) FROM tb_name [WHERE clause];
```
- **功能说明**:返回出现频率最高的值,若存在多个频率相同的最高值,输出空。不能匹配标签、时间戳输出。
- **返回数据类型**:同应用的字段。
- **应用字段**:适合于除时间主列外的任何类型字段。
- **说明**:由于返回数据量未知,考虑到内存因素,为了函数可以正常返回结果,建议不重复的数据量在 10 万级别,否则会报错。
- **支持的版本**:2.6 开始的版本。
**功能说明**:返回出现频率最高的值,若存在多个频率相同的最高值,输出空。不能匹配标签、时间戳输出。
示例:
**返回数据类型**:同应用的字段。
**应用字段**:适合于除时间主列外的任何类型字段。
**使用说明**:由于返回数据量未知,考虑到内存因素,为了函数可以正常返回结果,建议不重复的数据量在 10 万级别,否则会报错。
**支持的版本**:2.6.0.0 及以后的版本。
**示例**
```
taos> select voltage from d002;
......@@ -210,14 +228,17 @@ Query OK, 1 row(s) in set (0.019393s)
SELECT HYPERLOGLOG(field_name) FROM { tb_name | stb_name } [WHERE clause];
```
- **功能说明**
**功能说明**
- 采用 hyperloglog 算法,返回某列的基数。该算法在数据量很大的情况下,可以明显降低内存的占用,但是求出来的基数是个估算值,标准误差(标准误差是多次实验,每次的平均数的标准差,不是与真实结果的误差)为 0.81%。
- 在数据量较少的时候该算法不是很准确,可以使用 select count(data) from (select unique(col) as data from table) 的方法。
- **返回结果类型**:整形。
- **应用字段**:适合于任何类型字段。
- **支持的版本**:2.6 开始的版本。
示例:
**返回结果类型**:整形。
**应用字段**:适合于任何类型字段。
**支持的版本**:2.6.0.0 及以后的版本。
**示例**
```
taos> select dbig from shll;
......@@ -258,7 +279,7 @@ SELECT MIN(field_name) FROM {tb_name | stb_name} [WHERE clause];
**适用于**:表、超级表。
示例
**示例**
```
taos> SELECT MIN(current), MIN(voltage) FROM meters;
......@@ -288,7 +309,7 @@ SELECT MAX(field_name) FROM { tb_name | stb_name } [WHERE clause];
**适用于**:表、超级表。
示例
**示例**
```
taos> SELECT MAX(current), MAX(voltage) FROM meters;
......@@ -318,15 +339,13 @@ SELECT FIRST(field_name) FROM { tb_name | stb_name } [WHERE clause];
**适用于**:表、超级表。
说明:
**使用说明**:
1)如果要返回各个列的首个(时间戳最小)非 NULL 值,可以使用 FIRST(\*);
- 如果要返回各个列的首个(时间戳最小)非 NULL 值,可以使用 FIRST(\*);
- 如果结果集中的某列全部为 NULL 值,则该列的返回结果也是 NULL;
- 如果结果集中所有列全部为 NULL 值,则不返回结果。
2)如果结果集中的某列全部为 NULL 值,则该列的返回结果也是 NULL;
3)如果结果集中所有列全部为 NULL 值,则不返回结果。
示例:
**示例**
```
taos> SELECT FIRST(*) FROM meters;
......@@ -356,15 +375,14 @@ SELECT LAST(field_name) FROM { tb_name | stb_name } [WHERE clause];
**适用于**:表、超级表。
说明:
1)如果要返回各个列的最后(时间戳最大)一个非 NULL 值,可以使用 LAST(\*);
**使用说明**:
2)如果结果集中的某列全部为 NULL 值,则该列的返回结果也是 NULL;如果结果集中所有列全部为 NULL 值,则不返回结果。
- 如果要返回各个列的最后(时间戳最大)一个非 NULL 值,可以使用 LAST(\*);
- 如果结果集中的某列全部为 NULL 值,则该列的返回结果也是 NULL;如果结果集中所有列全部为 NULL 值,则不返回结果。
- 在用于超级表时,时间戳完全一样且同为最大的数据行可能有多个,那么会从中随机返回一条,而并不保证多次运行所挑选的数据行必然一致。
3)在用于超级表时,时间戳完全一样且同为最大的数据行可能有多个,那么会从中随机返回一条,而并不保证多次运行所挑选的数据行必然一致。
示例
**示例**
```
taos> SELECT LAST(*) FROM meters;
......@@ -394,15 +412,13 @@ SELECT TOP(field_name, K) FROM { tb_name | stb_name } [WHERE clause];
**适用于**:表、超级表。
说明:
1)*k*值取值范围 1≤*k*≤100;
**使用说明**:
2)系统同时返回该记录关联的时间戳列;
- *k*值取值范围 1≤*k*≤100;
- 系统同时返回该记录关联的时间戳列;
- 限制:TOP 函数不支持 FILL 子句。
3)限制:TOP 函数不支持 FILL 子句。
示例:
**示例**
```
taos> SELECT TOP(current, 3) FROM meters;
......@@ -435,15 +451,13 @@ SELECT BOTTOM(field_name, K) FROM { tb_name | stb_name } [WHERE clause];
**适用于**:表、超级表。
说明:
**使用说明**:
1)*k*值取值范围 1≤*k*≤100;
- *k*值取值范围 1≤*k*≤100;
- 系统同时返回该记录关联的时间戳列;
- 限制:BOTTOM 函数不支持 FILL 子句。
2)系统同时返回该记录关联的时间戳列;
3)限制:BOTTOM 函数不支持 FILL 子句。
示例:
**示例**
```
taos> SELECT BOTTOM(voltage, 2) FROM meters;
......@@ -475,9 +489,9 @@ SELECT PERCENTILE(field_name, P) FROM { tb_name } [WHERE clause];
**适用于**:表。
说明*P*值取值范围 0≤*P*≤100,为 0 的时候等同于 MIN,为 100 的时候等同于 MAX。
**使用说明***P*值取值范围 0≤*P*≤100,为 0 的时候等同于 MIN,为 100 的时候等同于 MAX。
示例
**示例**
```
taos> SELECT PERCENTILE(current, 20) FROM d1001;
......@@ -502,9 +516,14 @@ FROM { tb_name | stb_name } [WHERE clause]
**适用于**:表、超级表。
说明:<br/>**P**值有效取值范围 0≤P≤100,为 0 的时候等同于 MIN,为 100 的时候等同于 MAX;<br/>**algo_type**的有效输入:**default****t-digest**。 用于指定计算近似分位数的算法。可不提供第三个参数的输入,此时将使用 default 的算法进行计算,即 apercentile(column_name, 50, "default") 与 apercentile(column_name, 50) 等价。当使用“t-digest”参数的时候,将使用 t-digest 方式采样计算近似分位数。但该参数指定计算算法的功能从 2.2.0.x 版本开始支持,2.2.0.0 之前的版本不支持指定使用算法的功能。<br/>
**使用说明**
嵌套子查询支持:适用于内层查询和外层查询。
- **P**值有效取值范围 0≤P≤100,为 0 的时候等同于 MIN,为 100 的时候等同于 MAX;
- **algo_type**的有效输入:**default****t-digest**
- 用于指定计算近似分位数的算法。可不提供第三个参数的输入,此时将使用 default 的算法进行计算,即 apercentile(column_name, 50, "default") 与 apercentile(column_name, 50) 等价。
- 当使用“t-digest”参数的时候,将使用 t-digest 方式采样计算近似分位数。但该参数指定计算算法的功能从 2.2.0.x 版本开始支持,2.2.0.0 之前的版本不支持指定使用算法的功能。
**嵌套子查询支持**:适用于内层查询和外层查询。
```
taos> SELECT APERCENTILE(current, 20) FROM d1001;
......@@ -540,16 +559,12 @@ SELECT LAST_ROW(field_name) FROM { tb_name | stb_name };
**适用于**:表、超级表。
限制:LAST_ROW() 不能与 INTERVAL 一起使用。
说明:在用于超级表时,时间戳完全一样且同为最大的数据行可能有多个,那么会从中随机返回一条,而并不保证多次运行所挑选的数据行必然一致。<br/>
{" "}
**使用说明**
{" "}
- 在用于超级表时,时间戳完全一样且同为最大的数据行可能有多个,那么会从中随机返回一条,而并不保证多次运行所挑选的数据行必然一致。
- 不能与 INTERVAL 一起使用。
<br />
示例:
**示例**
```
taos> SELECT LAST_ROW(current) FROM meters;
......@@ -577,50 +592,46 @@ SELECT INTERP(field_name) FROM { tb_name | stb_name } [WHERE where_condition] [
**应用字段**:数值型字段。
适用于:**表、超级表、嵌套查询**
说明:
1)INTERP 用于在指定时间断面获取指定列的记录值,如果该时间断面不存在符合条件的行数据,那么会根据 FILL 参数的设定进行插值。
2)INTERP 的输入数据为指定列的数据,可以通过条件语句(where 子句)来对原始列数据进行过滤,如果没有指定过滤条件则输入为全部数据。
**适用于**:表、超级表、嵌套查询。
3)INTERP 的输出时间范围根据 RANGE(timestamp1,timestamp2)字段来指定,需满足 timestamp1<=timestamp2。其中 timestamp1(必选值)为输出时间范围的起始值,即如果 timestamp1 时刻符合插值条件则 timestamp1 为输出的第一条记录,timestamp2(必选值)为输出时间范围的结束值,即输出的最后一条记录的 timestamp 不能大于 timestamp2。如果没有指定 RANGE,那么满足过滤条件的输入数据中第一条记录的 timestamp 即为 timestamp1,最后一条记录的 timestamp 即为 timestamp2,同样也满足 timestamp1 <= timestamp2。
4)INTERP 根据 EVERY 字段来确定输出时间范围内的结果条数,即从 timestamp1 开始每隔固定长度的时间(EVERY 值)进行插值。如果没有指定 EVERY,则默认窗口大小为无穷大,即从 timestamp1 开始只有一个窗口。
**使用说明**
5)INTERP 根据 FILL 字段来决定在每个符合输出条件的时刻如何进行插值,如果没有 FILL 字段则默认不插值,即输出为原始记录值或不输出(原始记录不存在)。
- INTERP 用于在指定时间断面获取指定列的记录值,如果该时间断面不存在符合条件的行数据,那么会根据 FILL 参数的设定进行插值。
- INTERP 的输入数据为指定列的数据,可以通过条件语句(where 子句)来对原始列数据进行过滤,如果没有指定过滤条件则输入为全部数据。
- INTERP 的输出时间范围根据 RANGE(timestamp1,timestamp2)字段来指定,需满足 timestamp1<=timestamp2。其中 timestamp1(必选值)为输出时间范围的起始值,即如果 timestamp1 时刻符合插值条件则 timestamp1 为输出的第一条记录,timestamp2(必选值)为输出时间范围的结束值,即输出的最后一条记录的 timestamp 不能大于 timestamp2。如果没有指定 RANGE,那么满足过滤条件的输入数据中第一条记录的 timestamp 即为 timestamp1,最后一条记录的 timestamp 即为 timestamp2,同样也满足 timestamp1 <= timestamp2。
- INTERP 根据 EVERY 字段来确定输出时间范围内的结果条数,即从 timestamp1 开始每隔固定长度的时间(EVERY 值)进行插值。如果没有指定 EVERY,则默认窗口大小为无穷大,即从 timestamp1 开始只有一个窗口。
- INTERP 根据 FILL 字段来决定在每个符合输出条件的时刻如何进行插值,如果没有 FILL 字段则默认不插值,即输出为原始记录值或不输出(原始记录不存在)。
- INTERP 只能在一个时间序列内进行插值,因此当作用于超级表时必须跟 group by tbname 一起使用,当作用嵌套查询外层时内层子查询不能含 GROUP BY 信息。
- INTERP 的插值结果不受 ORDER BY timestamp 的影响,ORDER BY timestamp 只影响输出结果的排序。
6)INTERP 只能在一个时间序列内进行插值,因此当作用于超级表时必须跟 group by tbname 一起使用,当作用嵌套查询外层时内层子查询不能含 GROUP BY 信息。
**SQL示例**
7)INTERP 的插值结果不受 ORDER BY timestamp 的影响,ORDER BY timestamp 只影响输出结果的排序。
SQL 示例:
1) 单点线性插值
- 单点线性插值
```
taos> SELECT INTERP(*) FROM t1 RANGE('2017-7-14 18:40:00','2017-7-14 18:40:00') FILL(LINEAR);
```
2) 在2017-07-14 18:00:00到2017-07-14 19:00:00间每隔5秒钟进行取值(不插值)
- 在2017-07-14 18:00:00到2017-07-14 19:00:00间每隔5秒钟进行取值(不插值)
```
taos> SELECT INTERP(*) FROM t1 RANGE('2017-7-14 18:00:00','2017-7-14 19:00:00') EVERY(5s);
```
3) 在2017-07-14 18:00:00到2017-07-14 19:00:00间每隔5秒钟进行线性插值
- 在2017-07-14 18:00:00到2017-07-14 19:00:00间每隔5秒钟进行线性插值
```
taos> SELECT INTERP(*) FROM t1 RANGE('2017-7-14 18:00:00','2017-7-14 19:00:00') EVERY(5s) FILL(LINEAR);
```
4.在所有时间范围内每隔 5 秒钟进行向后插值
- 在所有时间范围内每隔 5 秒钟进行向后插值
```
taos> SELECT INTERP(*) FROM t1 EVERY(5s) FILL(NEXT);
```
5.根据 2017-07-14 17:00:00 到 2017-07-14 20:00:00 间的数据进行从 2017-07-14 18:00:00 到 2017-07-14 19:00:00 间每隔 5 秒钟进行线性插值
- 根据 2017-07-14 17:00:00 到 2017-07-14 20:00:00 间的数据进行从 2017-07-14 18:00:00 到 2017-07-14 19:00:00 间每隔 5 秒钟进行线性插值
```
taos> SELECT INTERP(*) FROM t1 where ts >= '2017-07-14 17:00:00' and ts <= '2017-07-14 20:00:00' RANGE('2017-7-14 18:00:00','2017-7-14 19:00:00') EVERY(5s) FILL(LINEAR);
......@@ -640,8 +651,14 @@ SELECT INTERP(field_name) FROM { tb_name | stb_name } WHERE ts='timestamp' [FILL
**适用于**:表、超级表。
说明:(从 2.0.15.0 版本开始新增此函数) <br/>1)INTERP 必须指定时间断面,如果该时间断面不存在直接对应的数据,那么会根据 FILL 参数的设定进行插值。此外,条件语句里面可附带筛选条件,例如标签、tbname。<br/>2)INTERP 查询要求查询的时间区间必须位于数据集合(表)的所有记录的时间范围之内。如果给定的时间戳位于时间范围之外,即使有插值指令,仍然不返回结果。<br/>3)单个 INTERP 函数查询只能够针对一个时间点进行查询,如果需要返回等时间间隔的断面数据,可以通过 INTERP 配合 EVERY 的方式来进行查询处理(而不是使用 INTERVAL),其含义是每隔固定长度的时间进行插值。<br/>
示例:
**使用说明**:
- 从 2.0.15.0 及以后版本可用
- INTERP 必须指定时间断面,如果该时间断面不存在直接对应的数据,那么会根据 FILL 参数的设定进行插值。此外,条件语句里面可附带筛选条件,例如标签、tbname。
- INTERP 查询要求查询的时间区间必须位于数据集合(表)的所有记录的时间范围之内。如果给定的时间戳位于时间范围之外,即使有插值指令,仍然不返回结果。
- 单个 INTERP 函数查询只能够针对一个时间点进行查询,如果需要返回等时间间隔的断面数据,可以通过 INTERP 配合 EVERY 的方式来进行查询处理(而不是使用 INTERVAL),其含义是每隔固定长度的时间进行插值
**示例**
```
taos> SELECT INTERP(*) FROM meters WHERE ts='2017-7-14 18:40:00.004';
......@@ -689,9 +706,9 @@ SELECT TAIL(field_name, k, offset_val) FROM {tb_name | stb_name} [WHERE clause];
**应用字段**:适合于除时间主列外的任何类型字段。
**支持版本**:2.6 开始的版本。
**支持版本**:2.6.0.0 及之后的版本。
示例
**示例**
```
taos> select ts,dbig from tail2;
......@@ -725,14 +742,14 @@ SELECT UNIQUE(field_name) FROM {tb_name | stb_name} [WHERE clause];
**应用字段**:适合于除时间类型以外的字段。
**支持版本**:2.6 开始的版本。
**支持版本**:2.6.0.0 及之后的版本。
**说明**
**使用说明**:
- 该函数可以应用在普通表和超级表上。不能和窗口操作一起使用,例如 interval/state_window/session_window 。
- 由于返回数据量未知,考虑到内存因素,为了函数可以正常返回结果,建议不重复的数据量在 10 万级别,否则会报错。
示例
**示例**
```
taos> select ts,voltage from unique1;
......@@ -761,23 +778,27 @@ Query OK, 5 row(s) in set (0.108458s)
## 计算函数
- **DIFF**
### DIFF
```sql
SELECT {DIFF(field_name, ignore_negative) | DIFF(field_name)} FROM tb_name [WHERE clause];
```
功能说明:统计表中某列的值与前一行对应值的差。 ignore_negative 取值为 0|1 , 可以不填,默认值为 0. 不忽略负值。ignore_negative 为 1 时表示忽略负数。
**功能说明**:统计表中某列的值与前一行对应值的差。 ignore_negative 取值为 0|1 , 可以不填,默认值为 0. 不忽略负值。ignore_negative 为 1 时表示忽略负数。
返回结果数据类型:同应用字段。
**返回结果数据类型**:同应用字段。
应用字段:不能应用在 timestamp、binary、nchar、bool 类型字段。
**应用字段**:不能应用在 timestamp、binary、nchar、bool 类型字段。
适用于:**表、(超级表)**
**适用于**:表、超级表
说明:输出结果行数是范围内总行数减一,第一行没有结果输出。从 2.1.3.0 版本开始,DIFF 函数可以在由 GROUP BY 划分出单独时间线的情况下用于超级表(也即 GROUP BY tbname)。从 2.6.0 开始,DIFF 函数支持 ignore_negative 参数
**使用说明**:
示例:
- 输出结果行数是范围内总行数减一,第一行没有结果输出。
- 从 2.1.3.0 版本开始,DIFF 函数可以在由 GROUP BY 划分出单独时间线的情况下用于超级表(也即 GROUP BY tbname)。
- 从 2.6.0 开始,DIFF 函数支持 ignore_negative 参数
**示例**
```sql
taos> SELECT DIFF(current) FROM d1001;
......@@ -800,11 +821,14 @@ SELECT DERIVATIVE(field_name, time_interval, ignore_negative) FROM tb_name [WHER
**应用字段**:不能应用在 timestamp、binary、nchar、bool 类型字段。
适用于:**表、(超级表)**
**适用于**:表、超级表
说明:(从 2.1.3.0 版本开始新增此函数)输出结果行数是范围内总行数减一,第一行没有结果输出。DERIVATIVE 函数可以在由 GROUP BY 划分出单独时间线的情况下用于超级表(也即 GROUP BY tbname)。
**使用说明**:
示例:
- 从 2.1.3.0 及以后版本可用;输出结果行数是范围内总行数减一,第一行没有结果输出。
- DERIVATIVE 函数可以在由 GROUP BY 划分出单独时间线的情况下用于超级表(也即 GROUP BY tbname)。
**示例**
```
taos> select derivative(current, 10m, 0) from t1;
......@@ -832,9 +856,9 @@ SELECT SPREAD(field_name) FROM { tb_name | stb_name } [WHERE clause];
**适用于**:表、超级表。
说明:可用于 TIMESTAMP 字段,此时表示记录的时间覆盖范围。
**使用说明**:可用于 TIMESTAMP 字段,此时表示记录的时间覆盖范围。
示例
**示例**
```
taos> SELECT SPREAD(voltage) FROM meters;
......@@ -858,16 +882,18 @@ SELECT CEIL(field_name) FROM { tb_name | stb_name } [WHERE clause];
**功能说明**:获得指定列的向上取整数的结果。
返回结果类型:与指定列的原始数据类型一致。例如,如果指定列的原始数据类型为 Float,那么返回的数据类型也为 Float;如果指定列的原始数据类型为 Double,那么返回的数据类型也为 Double。
**返回结果类型**:与指定列的原始数据类型一致。例如,如果指定列的原始数据类型为 Float,那么返回的数据类型也为 Float;如果指定列的原始数据类型为 Double,那么返回的数据类型也为 Double。
**适用数据类型**:不能应用在 timestamp、binary、nchar、bool 类型字段上;在超级表查询中使用时,不能应用在 tag 列,无论 tag 列的类型是什么类型。
适用数据类型:不能应用在 timestamp、binary、nchar、bool 类型字段上;在超级表查询中使用时,不能应用在 tag 列,无论 tag 列的类型是什么类型。
**适用于**: 普通表、超级表。
**嵌套子查询支持**:适用于内层查询和外层查询。
嵌套子查询支持:适用于内层查询和外层查询。
**使用说明**:
说明:
支持 +、-、\*、/ 运算,如 ceil(col1) + ceil(col2)。
只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
该函数可以应用在普通表和超级表上。
- 支持 +、-、\*、/ 运算,如 ceil(col1) + ceil(col2)。
- 只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
### FLOOR
......@@ -901,9 +927,13 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**嵌套子查询支持**: 适用于内层查询和外层查询。
**补充说明**: 不支持 +、-、*、/ 运算,如 csum(col1) + csum(col2)。只能与聚合(Aggregation)函数一起使用。 该函数可以应用在普通表和超级表上。 使用在超级表上的时候,需要搭配 Group by tbname使用,将结果强制规约到单个时间线。
**使用说明**
**支持版本**: 从2.3.0.x开始支持
- 不支持 +、-、*、/ 运算,如 csum(col1) + csum(col2)。
- 只能与聚合(Aggregation)函数一起使用。 该函数可以应用在普通表和超级表上。
- 使用在超级表上的时候,需要搭配 Group by tbname使用,将结果强制规约到单个时间线。
**支持版本**: 从2.3.0.x开始支持
### MAVG
......@@ -919,9 +949,13 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**嵌套子查询支持**: 适用于内层查询和外层查询。
**补充说明**: 不支持 +、-、*、/ 运算,如 mavg(col1, k1) + mavg(col2, k1); 只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用;该函数可以应用在普通表和超级表上;使用在超级表上的时候,需要搭配 Group by tbname使用,将结果强制规约到单个时间线。
**使用说明**
- 不支持 +、-、*、/ 运算,如 mavg(col1, k1) + mavg(col2, k1);
- 只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用;
- 该函数可以应用在普通表和超级表上;使用在超级表上的时候,需要搭配 Group by tbname使用,将结果强制规约到单个时间线。
**支持版本**: 从2.3.0.x开始支持
**支持版本**: 从2.3.0.x开始支持
### SAMPLE
......@@ -937,9 +971,12 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**嵌套子查询支持**: 适用于内层查询和外层查询。
**补充说明**: 不能参与表达式计算;该函数可以应用在普通表和超级表上;使用在超级表上的时候,需要搭配 Group by tbname 使用,将结果强制规约到单个时间线。
**使用说明**
**支持版本**: 从2.3.0.x开始支持
- 不能参与表达式计算;该函数可以应用在普通表和超级表上;
- 使用在超级表上的时候,需要搭配 Group by tbname 使用,将结果强制规约到单个时间线。
**支持版本**: 从2.3.0.x开始支持
### ASIN
......@@ -957,11 +994,9 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**使用说明**
只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
该函数可以应用在普通表和超级表上。
版本2.6.0.x后支持
- 只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
- 该函数可以应用在普通表和超级表上。
- 版本2.6.0.x后支持
### ACOS
......@@ -979,11 +1014,9 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**使用说明**
只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
该函数可以应用在普通表和超级表上。
版本2.6.0.x后支持
- 只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
- 该函数可以应用在普通表和超级表上。
- 版本2.6.0.x后支持
### ATAN
......@@ -1001,11 +1034,9 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**使用说明**
只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
该函数可以应用在普通表和超级表上。
版本2.6.0.x后支持
- 只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
- 该函数可以应用在普通表和超级表上。
- 版本2.6.0.x后支持
### SIN
......@@ -1023,11 +1054,9 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**使用说明**
只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
该函数可以应用在普通表和超级表上。
版本2.6.0.x后支持
- 只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
- 该函数可以应用在普通表和超级表上。
- 版本2.6.0.x后支持
### COS
......@@ -1045,11 +1074,9 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**使用说明**
只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
该函数可以应用在普通表和超级表上。
版本2.6.0.x后支持
- 只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
- 该函数可以应用在普通表和超级表上。
- 版本2.6.0.x后支持
### TAN
......@@ -1067,11 +1094,9 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**使用说明**
只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
该函数可以应用在普通表和超级表上。
版本2.6.0.x后支持
- 只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
- 该函数可以应用在普通表和超级表上。
- 版本2.6.0.x后支持
### POW
......@@ -1089,11 +1114,9 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**使用说明**
只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
该函数可以应用在普通表和超级表上。
版本2.6.0.x后支持
- 只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
- 该函数可以应用在普通表和超级表上。
- 版本2.6.0.x后支持
### LOG
......@@ -1111,11 +1134,9 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**使用说明**
只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
该函数可以应用在普通表和超级表上。
版本2.6.0.x后支持
- 只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
- 该函数可以应用在普通表和超级表上。
- 版本2.6.0.x后支持
### ABS
......@@ -1133,11 +1154,9 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**使用说明**
只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
该函数可以应用在普通表和超级表上。
版本2.6.0.x后支持
- 只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
- 该函数可以应用在普通表和超级表上。
- 版本2.6.0.x后支持
### SQRT
......@@ -1155,11 +1174,9 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**使用说明**
只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
该函数可以应用在普通表和超级表上。
版本2.6.0.x后支持
- 只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
- 该函数可以应用在普通表和超级表上。
- 版本2.6.0.x后支持
### CAST
......@@ -1171,20 +1188,21 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**返回结果类型**:CAST 中指定的类型(type_name)。
**适用数据类型**:输入参数 expression 的类型可以是除 JSON 外目前所有类型字段(BOOL/TINYINT/SMALLINT/INT/BIGINT/FLOAT/DOUBLE/BINARY(M)/TIMESTAMP/NCHAR(M)/TINYINT UNSIGNED/SMALLINT UNSIGNED/INT UNSIGNED/BIGINT UNSIGNED); 输出目标类型只支持 BIGINT/BINARY(N)/TIMESTAMP/NCHAR(N)/BIGINT UNSIGNED。
说明:
**适用数据类型**
对于不能支持的类型转换会直接报错。
- 输入参数 expression 的类型可以是除 JSON 外目前所有类型字段(BOOL/TINYINT/SMALLINT/INT/BIGINT/FLOAT/DOUBLE/BINARY(M)/TIMESTAMP/NCHAR(M)/TINYINT UNSIGNED/SMALLINT UNSIGNED/INT UNSIGNED/BIGINT UNSIGNED);
- 输出目标类型只支持 BIGINT/BINARY(N)/TIMESTAMP/NCHAR(N)/BIGINT UNSIGNED。
如果输入值为NULL则输出值也为NULL。
**使用说明**
对于类型支持但某些值无法正确转换的情况对应的转换后的值以转换函数输出为准。目前可能遇到的几种情况:
- 对于不能支持的类型转换会直接报错。
- 如果输入值为NULL则输出值也为NULL。
- 对于类型支持但某些值无法正确转换的情况对应的转换后的值以转换函数输出为准。目前可能遇到的几种情况:
1)BINARY/NCHAR转BIGINT/BIGINT UNSIGNED时可能出现的无效字符情况,例如"a"可能转为0。
2)有符号数或TIMESTAMP转BIGINT UNSIGNED可能遇到的溢出问题。
3)BIGINT UNSIGNED转BIGINT可能遇到的溢出问题。
4)FLOAT/DOUBLE转BIGINT/BIGINT UNSIGNED可能遇到的溢出问题。
版本2.6.0.x后支持
- 版本2.6.0.x后支持
### CONCAT
......@@ -1198,13 +1216,13 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**适用数据类型**:输入参数或者全部是 BINARY 格式的字符串或者列,或者全部是 NCHAR 格式的字符串或者列。不能应用在 TAG 列。
**说明**
**使用说明**
如果输入值为NULL,输出值为NULL。
该函数最小参数个数为2个,最大参数个数为8个。
该函数可以应用在普通表和超级表上。
该函数适用于内层查询和外层查询。
版本2.6.0.x后支持
- 如果输入值为NULL,输出值为NULL。
- 该函数最小参数个数为2个,最大参数个数为8个。
- 该函数可以应用在普通表和超级表上。
- 该函数适用于内层查询和外层查询。
- 版本2.6.0.x后支持
### CONCAT_WS
......@@ -1218,13 +1236,13 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**适用数据类型**:输入参数或者全部是 BINARY 格式的字符串或者列,或者全部是 NCHAR 格式的字符串或者列。不能应用在 TAG 列。
**说明**
**使用说明**
如果separator值为NULL,输出值为NULL。如果separator值不为NULL,其他输入为NULL,输出为空串
该函数最小参数个数为3个,最大参数个数为9个。
该函数可以应用在普通表和超级表上。
该函数适用于内层查询和外层查询。
版本2.6.0.x后支持
- 如果separator值为NULL,输出值为NULL。如果separator值不为NULL,其他输入为NULL,输出为空串
- 该函数最小参数个数为3个,最大参数个数为9个。
- 该函数可以应用在普通表和超级表上。
- 该函数适用于内层查询和外层查询。
- 版本2.6.0.x后支持
### LENGTH
......@@ -1238,12 +1256,12 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**适用数据类型**:输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。
**说明**
**使用说明**
如果输入值为NULL,输出值为NULL。
该函数可以应用在普通表和超级表上。
函数适用于内层查询和外层查询。
版本2.6.0.x后支持
- 如果输入值为NULL,输出值为NULL。
- 该函数可以应用在普通表和超级表上。
- 函数适用于内层查询和外层查询。
- 版本2.6.0.x后支持
### CHAR_LENGTH
......@@ -1257,12 +1275,12 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**适用数据类型**:输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。
**说明**
**使用说明**
如果输入值为NULL,输出值为NULL。
该函数可以应用在普通表和超级表上。
该函数适用于内层查询和外层查询。
版本2.6.0.x后支持
- 如果输入值为NULL,输出值为NULL。
- 该函数可以应用在普通表和超级表上。
- 该函数适用于内层查询和外层查询。
- 版本2.6.0.x后支持
### LOWER
......@@ -1276,12 +1294,12 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**适用数据类型**:输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。
**说明**
**使用说明**
如果输入值为NULL,输出值为NULL。
该函数可以应用在普通表和超级表上。
该函数适用于内层查询和外层查询。
版本2.6.0.x后支持
- 如果输入值为NULL,输出值为NULL。
- 该函数可以应用在普通表和超级表上。
- 该函数适用于内层查询和外层查询。
- 版本2.6.0.x后支持
### UPPER
......@@ -1295,12 +1313,12 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**适用数据类型**:输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。
**说明**
**使用说明**
如果输入值为NULL,输出值为NULL。
该函数可以应用在普通表和超级表上。
该函数适用于内层查询和外层查询。
版本2.6.0.x后支持
- 如果输入值为NULL,输出值为NULL。
- 该函数可以应用在普通表和超级表上。
- 该函数适用于内层查询和外层查询。
- 版本2.6.0.x后支持
### LTRIM
......@@ -1314,12 +1332,12 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**适用数据类型**:输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。
**说明**
**使用说明**
如果输入值为NULL,输出值为NULL。
该函数可以应用在普通表和超级表上。
该函数适用于内层查询和外层查询。
版本2.6.0.x后支持
- 如果输入值为NULL,输出值为NULL。
- 该函数可以应用在普通表和超级表上。
- 该函数适用于内层查询和外层查询。
- 版本2.6.0.x后支持
### RTRIM
......@@ -1333,12 +1351,12 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**适用数据类型**:输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。
**说明**
**使用说明**
如果输入值为NULL,输出值为NULL。
该函数可以应用在普通表和超级表上。
该函数适用于内层查询和外层查询。
版本2.6.0.x后支持
- 如果输入值为NULL,输出值为NULL。
- 该函数可以应用在普通表和超级表上。
- 该函数适用于内层查询和外层查询。
- 版本2.6.0.x后支持
### SUBSTR
......@@ -1352,13 +1370,13 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
**适用数据类型**:输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。
**说明**
**使用说明**
如果输入值为NULL,输出值为NULL。
输入参数pos可以为正数,也可以为负数。如果pos是正数,表示开始位置从字符串开头正数计算。如果pos为负数,表示开始位置从字符串结尾倒数计算。如果输入参数len被忽略,返回的子串包含从pos开始的整个字串。
该函数可以应用在普通表和超级表上。
该函数适用于内层查询和外层查询。
版本2.6.0.x后支持
- 如果输入值为NULL,输出值为NULL。
- 输入参数pos可以为正数,也可以为负数。如果pos是正数,表示开始位置从字符串开头正数计算。如果pos为负数,表示开始位置从字符串结尾倒数计算。如果输入参数len被忽略,返回的子串包含从pos开始的整个字串。
- 该函数可以应用在普通表和超级表上。
- 该函数适用于内层查询和外层查询。
- 版本2.6.0.x后支持
### 四则运算
......@@ -1374,11 +1392,10 @@ SELECT field_name [+|-|*|/|%][Value|field_name] FROM { tb_name | stb_name } [WH
**适用于**:表、超级表。
**说明**
1)支持两列或多列之间进行计算,可使用括号控制计算优先级;
**使用说明**
2)NULL 字段不参与计算,如果参与计算的某行中包含 NULL,该行的计算结果为 NULL。
- 支持两列或多列之间进行计算,可使用括号控制计算优先级;
- NULL 字段不参与计算,如果参与计算的某行中包含 NULL,该行的计算结果为 NULL。
```
taos> SELECT current + voltage * phase FROM d1001;
......@@ -1411,10 +1428,9 @@ SELECT STATECOUNT(field_name, oper, val) FROM { tb_name | stb_name } [WHERE clau
**支持的版本**:2.6 开始的版本。
**说明**
**使用说明**
- 该函数可以应用在普通表上,在由 GROUP BY 划分出单独时间线的情况下用于超级表(也即 GROUP BY tbname)
- 不能和窗口操作一起使用,例如 interval/state_window/session_window。
**示例**
......@@ -1465,10 +1481,9 @@ SELECT stateDuration(field_name, oper, val, unit) FROM { tb_name | stb_name } [W
**支持的版本**:2.6 开始的版本。
**说明**
**使用说明**
- 该函数可以应用在普通表上,在由 GROUP BY 划分出单独时间线的情况下用于超级表(也即 GROUP BY tbname)
- 不能和窗口操作一起使用,例如 interval/state_window/session_window。
**示例**
......@@ -1517,10 +1532,11 @@ INSERT INTO tb_name VALUES (NOW(), ...);
**适用于**:表、超级表。
**说明**
1)支持时间加减操作,如 NOW() + 1s, 支持的时间单位如下:
b(纳秒)、u(微秒)、a(毫秒)、s(秒)、m(分)、h(小时)、d(天)、w(周)。
2)返回的时间戳精度与当前 DATABASE 设置的时间精度一致。
**使用说明**
- 支持时间加减操作,如 NOW() + 1s, 支持的时间单位如下:
b(纳秒)、u(微秒)、a(毫秒)、s(秒)、m(分)、h(小时)、d(天)、w(周)。
- 返回的时间戳精度与当前 DATABASE 设置的时间精度一致。
**示例**
......@@ -1563,10 +1579,11 @@ INSERT INTO tb_name VALUES (TODAY(), ...);
**适用于**:表、超级表。
**说明**
1)支持时间加减操作,如 TODAY() + 1s, 支持的时间单位如下:
b(纳秒),u(微秒),a(毫秒),s(秒),m(分),h(小时),d(天),w(周)。
2)返回的时间戳精度与当前 DATABASE 设置的时间精度一致。
**使用说明**
- 支持时间加减操作,如 TODAY() + 1s, 支持的时间单位如下:
b(纳秒),u(微秒),a(毫秒),s(秒),m(分),h(小时),d(天),w(周)。
- 返回的时间戳精度与当前 DATABASE 设置的时间精度一致。
**示例**
......@@ -1631,7 +1648,10 @@ SELECT TO_ISO8601(ts_val | ts_col) FROM { tb_name | stb_name } [WHERE clause];
**适用于**:表、超级表。
**说明**:如果输入是 UNIX 时间戳常量,返回格式精度由时间戳的位数决定,如果输入是 TIMSTAMP 类型的列,返回格式的时间戳精度与当前 DATABASE 设置的时间精度一致。
**使用说明**
- 如果输入是 UNIX 时间戳常量,返回格式精度由时间戳的位数决定;
- 如果输入是 TIMSTAMP 类型的列,返回格式的时间戳精度与当前 DATABASE 设置的时间精度一致。
**示例**
......@@ -1663,9 +1683,10 @@ SELECT TO_UNIXTIMESTAMP(datetime_string | ts_col) FROM { tb_name | stb_name } [W
**适用于**:表、超级表。
**说明**
1)输入的日期时间字符串须符合 ISO8601/RFC3339 标准,无法转换的字符串格式将返回 0。
2)返回的时间戳精度与当前 DATABASE 设置的时间精度一致。
**使用说明**
- 输入的日期时间字符串须符合 ISO8601/RFC3339 标准,无法转换的字符串格式将返回 0。
- 返回的时间戳精度与当前 DATABASE 设置的时间精度一致。
**示例**
......@@ -1697,10 +1718,10 @@ SELECT TIMETRUNCATE(ts_val | datetime_string | ts_col, time_unit) FROM { tb_name
**适用于**:表、超级表。
**说明**
1)支持的时间单位 time_unit 如下:
1u(微秒),1a(毫秒),1s(秒),1m(分),1h(小时),1d(天)。
2)返回的时间戳精度与当前 DATABASE 设置的时间精度一致。
**使用说明**
- 支持的时间单位 time_unit 如下:
1u(微秒),1a(毫秒),1s(秒),1m(分),1h(小时),1d(天)。
- 返回的时间戳精度与当前 DATABASE 设置的时间精度一致。
**示例**
......@@ -1740,10 +1761,10 @@ SELECT TIMEDIFF(ts_val1 | datetime_string1 | ts_col1, ts_val2 | datetime_string2
**适用于**:表、超级表。
**说明**
1)支持的时间单位 time_unit 如下:
1u(微秒),1a(毫秒),1s(秒),1m(分),1h(小时),1d(天)。
2)如果时间单位 time_unit 未指定, 返回的时间差值精度与当前 DATABASE 设置的时间精度一致。
**使用说明**
- 支持的时间单位 time_unit 如下:
1u(微秒),1a(毫秒),1s(秒),1m(分),1h(小时),1d(天)。
- 如果时间单位 time_unit 未指定, 返回的时间差值精度与当前 DATABASE 设置的时间精度一致。
**示例**
......
......@@ -27,4 +27,4 @@ title: 转义字符说明
2. 反引号``标识符: 保持原样,不转义
2. 数据里有转义字符
1. 遇到上面定义的转义字符会转义(%和\_见下面说明),如果没有匹配的转义字符会忽略掉转义符\。
2. 对于%和*,因为在 like 里这两个字符是通配符,所以在模式匹配 like 里用`\%`%和`\_`表示字符里本身的%和*,如果在 like 模式匹配上下文之外使用`\%`或`\_`,则它们的计算结果为字符串`\%`和`\_`,而不是%和\_
2. 对于%和\_,因为在 like 里这两个字符是通配符,所以在模式匹配 like 里用`\%`%和`\_`表示字符里本身的%和\_,如果在 like 模式匹配上下文之外使用`\%`或`\_`,则它们的计算结果为字符串`\%`和`\_`,而不是%和\_
......@@ -4,7 +4,7 @@ title: TAOS SQL
本文档说明 TAOS SQL 支持的语法规则、主要查询功能、支持的 SQL 查询函数,以及常用技巧等内容。阅读本文档需要读者具有基本的 SQL 语言的基础。
TAOS SQL 是用户对 TDengine 进行数据写入和查询的主要工具。TAOS SQL 为了便于用户快速上手,在一定程度上提供类似于标准 SQL 类似的风格和模式。严格意义上,TAOS SQL 并不是也不试图提供 SQL 标准的语法。此外,由于 TDengine 针对的时序性结构化数据不提供删除功能,因此在 TAO SQL 中不提供数据删除的相关功能。
TAOS SQL 是用户对 TDengine 进行数据写入和查询的主要工具。TAOS SQL 为了便于用户快速上手,在一定程度上提供与标准 SQL 类似的风格和模式。严格意义上,TAOS SQL 并不是也不试图提供标准的 SQL 语法。此外,由于 TDengine 针对的时序性结构化数据不提供删除功能,因此在 TAO SQL 中不提供数据删除的相关功能。
TAOS SQL 不支持关键字的缩写,例如 DESCRIBE 不能缩写为 DESC。
......
......@@ -2,9 +2,9 @@
title: 连接器
---
TDengine 提供了丰富的应用程序开发接口,其中包括 C/C++、Java、Python、Go、Node.js、C# 、RESTful 等,便于用户快速开发应用。
TDengine 提供了丰富的应用程序开发接口,其中包括支持使用 C/C++、Java、Python、Go、Node.js、C# 等多种语言的连接器,包括使用 taos 客户端驱动接口和 RESTful 接口,便于用户快速开发自己的应用。
![image-connecotr](/img/connector.png)
![image-connector](/img/connector.png)
## 支持的系统
......@@ -60,13 +60,13 @@ import Tabs from "@theme/Tabs";
import TabItem from "@theme/TabItem";
import InstallOnWindows from "./_linux_install.mdx";
import InstallOnLinux from "./_windows_install.mdx";
import VarifyWindows from "./_varify_linux.mdx";
import VarifyLinux from "./_varify_windows.mdx";
import VerifyWindows from "./_verify_linux.mdx";
import VerifyLinux from "./_verify_windows.mdx";
## 安装客户端驱动
:::info
只有在没有安装 TDengine 服务端软件的系统上使用非 RESTFful 连接器才需要安装客户端驱动。
只有在没有安装 TDengine 服务端软件的系统上使用非 RESTful 连接器才需要安装客户端驱动。
:::
......@@ -87,9 +87,10 @@ import VarifyLinux from "./_varify_windows.mdx";
<Tabs defaultValue="linux" groupId="os">
<TabItem value="linux" label="Linux">
<VarifyLinux />
<VerifyLinux />
</TabItem>
<TabItem value="windows" label="Windows">
<VarifyWindows />
<VerifyWindows />
</TabItem>
</Tabs>
---
sidebar_position: 1
sidebar_label: C/C++
title: C/C++ Connector
---
......
---
sidebar_position: 4
sidebar_label: Go
title: Go Connector
---
......
---
sidebar_position: 2
sidebar_label: Java
title: Java Connector
---
......@@ -67,11 +68,11 @@ INSERT INTO test.t1 USING test.weather (ts, temperature) TAGS('beijing') VALUES(
| taos-jdbcdriver 版本 | TDengine 2.0.x.x 版本 | TDengine 2.2.x.x 版本 | TDengine 2.4.x.x 版本 | JDK 版本 |
| -------------------- | --------------------- | --------------------- | --------------------- | -------- |
| 2.0.38 | X | X | 2.4.0.12 以上 | 1.8.x |
| 2.0.37 | X | X | 2.4.0.6 以上 | 1.8.x |
| 2.0.36 | X | 2.2.2.11 以上 | 2.4.0.0 - 2.4.0.5 | 1.8.x |
| 2.0.35 | X | 2.2.2.11 以上 | 2.3.0.0 - 2.4.0.5 | 1.8.x |
| 2.0.33 - 2.0.34 | 2.0.3.0 以上 | 2.2.0.0 以上 | 2.4.0.0 - 2.4.0.5 | 1.8.x |
| 2.0.38 | X | X | 2.4.0.14 及以上 | 1.8.x |
| 2.0.37 | X | X | 2.4.0.6 及以上 | 1.8.x |
| 2.0.36 | X | 2.2.2.11 及以上 | 2.4.0.0 - 2.4.0.5 | 1.8.x |
| 2.0.35 | X | 2.2.2.11 及以上 | 2.3.0.0 - 2.4.0.5 | 1.8.x |
| 2.0.33 - 2.0.34 | 2.0.3.0 及以上 | 2.2.0.0 及以上 | 2.4.0.0 - 2.4.0.5 | 1.8.x |
| 2.0.31 - 2.0.32 | 2.1.3.0 - 2.1.7.7 | X | X | 1.8.x |
| 2.0.22 - 2.0.30 | 2.0.18.0 - 2.1.2.1 | X | X | 1.8.x |
| 2.0.12 - 2.0.21 | 2.0.8.0 - 2.0.17.4 | X | X | 1.8.x |
......@@ -170,7 +171,7 @@ Connection conn = DriverManager.getConnection(jdbcUrl);
连接开启批量拉取方式:
```
```java
String url = "jdbc:TAOS-RS://taosdemo.com:6041/?user=root&password=taosdata";Properties properties = new Properties();
properties.setProperty(TSDBDriver.PROPERTY_KEY_BATCH_LOAD, "true");
Connection connection = DriverManager.getConnection(url, properties);
......
---
sidebar_position: 5
sidebar_position: 6
sidebar_label: Node.js
title: Node.js Connector
---
......
---
sidebar_position: 3
sidebar_label: Python
title: Python Connector
---
......
---
sidebar_position: 5
sidebar_label: Rust
title: Rust Connector
---
......
......@@ -7,7 +7,6 @@ title: 文件目录结构
| 目录/文件 | 说明 |
| ------------------------- | -------------------------------------------------------------------- |
| /usr/local/taos/bin | TDengine 可执行文件目录。其中的执行文件都会软链接到/usr/bin 目录下。 |
| /usr/local/taos/connector | TDengine 各种连接器目录。 |
| /usr/local/taos/driver | TDengine 动态链接库目录。会软链接到/usr/lib 目录下。 |
| /usr/local/taos/examples | TDengine 各种语言应用示例目录。 |
| /usr/local/taos/include | TDengine 对外提供的 C 语言接口的头文件。 |
......@@ -23,7 +22,13 @@ TDengine 的所有可执行文件默认存放在 _/usr/local/taos/bin_ 目录下
- _taos_:TDengine Shell 可执行文件
- _taosdump_:数据导入导出工具
- _taosBenchmark_:TDengine 测试工具
- remove.sh:卸载 TDengine 的脚本,请谨慎执行,链接到/usr/bin 目录下的**rmtaos**命令。会删除 TDengine 的安装目录/usr/local/taos,但会保留/etc/taos、/var/lib/taos、/var/log/taos。
- _remove.sh_:卸载 TDengine 的脚本,请谨慎执行,链接到/usr/bin 目录下的**rmtaos**命令。会删除 TDengine 的安装目录/usr/local/taos,但会保留/etc/taos、/var/lib/taos、/var/log/taos。
- _taosadapter_: 提供 RESTful 服务和接受其他多种软件写入请求的服务端可执行文件
- _tarbitrator_: 提供双节点集群部署的仲裁功能
- _run_taosd_and_taosadapter.sh_:同时启动 taosd 和 taosAdapter 的脚本
- _TDinsight.sh_:用于下载 TDinsight 并安装的脚本
- _set_core.sh_:用于方便调试设置系统生成 core dump 文件的脚本
- _taosd-dump-cfg.gdb_:用于方便调试 taosd 的 gdb 执行脚本
:::note
2.4.0.0 版本之后的 taosBenchmark 和 taosdump 需要安装独立安装包 taosTools。
......
......@@ -36,7 +36,7 @@ IT 运维监测数据通常都是对时间特性比较敏感的数据,例如
### 安装 TDengine
从涛思数据官网[下载](http://taosdata.com/cn/all-downloads/页面下载最新 TDengine-server 2.3.0.0 或以上版本安装。
从涛思数据官网[下载](http://taosdata.com/cn/all-downloads/)页面下载最新 TDengine-server 2.3.0.0 或以上版本安装。
## 数据链路设置
......@@ -52,7 +52,7 @@ IT 运维监测数据通常都是对时间特性比较敏感的数据,例如
### 配置 collectd
/etc/collectd/collectd.conf 文件中增加如下内容,其中 host 和 port 请填写 TDengine 和 taosAdapter 配置的实际值:
`/etc/collectd/collectd.conf` 文件中增加如下内容,其中 host 和 port 请填写 TDengine 和 taosAdapter 配置的实际值:
```
LoadPlugin network
......@@ -65,7 +65,7 @@ sudo systemctl start collectd
### 配置 StatsD
config.js 文件中增加如下内容后启动 StatsD,其中 host 和 port 请填写 TDengine 和 taosAdapter 配置的实际值:
`config.js` 文件中增加如下内容后启动 StatsD,其中 host 和 port 请填写 TDengine 和 taosAdapter 配置的实际值:
```
backends 部分添加 "./backends/repeater"
......
......@@ -57,11 +57,11 @@ INSERT INTO test.t1 USING test.weather (ts, temperature) TAGS('beijing') VALUES(
| taos-jdbcdriver 版本 | TDengine 2.0.x.x 版本 | TDengine 2.2.x.x 版本 | TDengine 2.4.x.x 版本 | JDK 版本 |
| -------------------- | --------------------- | --------------------- | --------------------- | -------- |
| 2.0.38 | X | X | 2.4.0.12 以上 | 1.8.x |
| 2.0.37 | X | X | 2.4.0.6 以上 | 1.8.x |
| 2.0.36 | X | 2.2.2.11 以上 | 2.4.0.0 - 2.4.0.5 | 1.8.x |
| 2.0.35 | X | 2.2.2.11 以上 | 2.3.0.0 - 2.4.0.5 | 1.8.x |
| 2.0.33 - 2.0.34 | 2.0.3.0 以上 | 2.2.0.0 以上 | 2.4.0.0 - 2.4.0.5 | 1.8.x |
| 2.0.38 | X | X | 2.4.0.14 及以上 | 1.8.x |
| 2.0.37 | X | X | 2.4.0.6 及以上 | 1.8.x |
| 2.0.36 | X | 2.2.2.11 及以上 | 2.4.0.0 - 2.4.0.5 | 1.8.x |
| 2.0.35 | X | 2.2.2.11 及以上 | 2.3.0.0 - 2.4.0.5 | 1.8.x |
| 2.0.33 - 2.0.34 | 2.0.3.0 及以上 | 2.2.0.0 及以上 | 2.4.0.0 - 2.4.0.5 | 1.8.x |
| 2.0.31 - 2.0.32 | 2.1.3.0 - 2.1.7.7 | X | X | 1.8.x |
| 2.0.22 - 2.0.30 | 2.0.18.0 - 2.1.2.1 | X | X | 1.8.x |
| 2.0.12 - 2.0.21 | 2.0.8.0 - 2.0.17.4 | X | X | 1.8.x |
......
......@@ -1129,6 +1129,8 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
应用字段:适合于除时间主列外的任何类型字段。
支持的版本:2.6.0.x 之后的版本。
说明:由于返回数据量未知,考虑到内存因素,为了函数可以正常返回结果,建议不重复的数据量在10万级别,否则会报错。
示例:
......
......@@ -33,7 +33,7 @@ IT 运维监测数据通常都是对时间特性比较敏感的数据,例如
### 安装 TDengine
从涛思数据官网[下载](http://taosdata.com/cn/all-downloads/页面下载最新 TDengine-server 2.3.0.0 或以上版本安装。
从涛思数据官网[下载](http://taosdata.com/cn/all-downloads/)页面下载最新 TDengine-server 2.3.0.0 或以上版本安装。
## 数据链路设置
......
......@@ -56,7 +56,7 @@ INSERT INTO test.t1 USING test.weather (ts, temperature) TAGS('beijing') VALUES(
| taos-jdbcdriver version | TDengine 2.0.x.x version | TDengine 2.2.x.x version | TDengine 2.4.x.x version | JDK version |
| ----------------------- | ------------------------ | ------------------------ | ------------------------ | ----------- |
| 2.0.38 | X | X | 2.4.0.12 or later | 1.8.x |
| 2.0.38 | X | X | 2.4.0.14 or later | 1.8.x |
| 2.0.37 | X | X | 2.4.0.6 or later | 1.8.x |
| 2.0.36 | X | 2.2.2.11 or later | 2.4.0.0 - 2.4.0.5 | 1.8.x |
| 2.0.35 | X | 2.2.2.11 or later | 2.3.0.0 - 2.4.0.5 | 1.8.x |
......
......@@ -282,6 +282,8 @@ static uint8_t convertRelationalOperator(SStrToken *pToken) {
return TSDB_BINARY_OP_DIVIDE;
case TK_REM:
return TSDB_BINARY_OP_REMAINDER;
case TK_BITAND:
return TSDB_BINARY_OP_BITAND;
case TK_LIKE:
return TSDB_RELATION_LIKE;
case TK_MATCH:
......@@ -10720,6 +10722,23 @@ int32_t exprTreeFromSqlExpr(SSqlCmd* pCmd, tExprNode **pExpr, const tSqlExpr* pS
}
}
if (pSqlExpr->tokenId == TK_BITAND && pSqlExpr->pLeft != NULL && pSqlExpr->pRight != NULL) {
// for example: col type is "bool" but expr "col & 1" received
uint8_t colType = pLeft->pSchema->type;
SStrToken *exprToken = &pSqlExpr->pRight->exprToken;
if (pSqlExpr->pLeft->type == SQL_NODE_TABLE_COLUMN && pSqlExpr->pRight->type == SQL_NODE_VALUE) {
if (colType == TSDB_DATA_TYPE_BOOL) {
if ((exprToken->n != 4 || strncasecmp(exprToken->z, "true", 4)) && (exprToken->n != 5 || strncasecmp(exprToken->z, "false", 5))) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
} else if (IS_SIGNED_NUMERIC_TYPE(colType) || IS_UNSIGNED_NUMERIC_TYPE(colType)) {
if ((exprToken->n == 4 && strncasecmp(exprToken->z, "true", 4) == 0) || (exprToken->n == 5 || strncasecmp(exprToken->z, "false", 5) == 0)) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
}
}
}
if (pSqlExpr->pRight != NULL) {
int32_t ret = exprTreeFromSqlExpr(pCmd, &pRight, pSqlExpr->pRight, pQueryInfo, pCols, uid);
if (ret != TSDB_CODE_SUCCESS) {
......@@ -10757,12 +10776,14 @@ int32_t exprTreeFromSqlExpr(SSqlCmd* pCmd, tExprNode **pExpr, const tSqlExpr* pS
if (pLeft->_node.optr == TSDB_RELATION_ARROW){
pLeft = pLeft->_node.pLeft;
}
if (pRight->pVal->nType == TSDB_DATA_TYPE_BOOL && pLeft->nodeType == TSQL_NODE_COL &&
(pLeft->pSchema->type == TSDB_DATA_TYPE_BOOL || pLeft->pSchema->type == TSDB_DATA_TYPE_JSON)) {
if (pRight->pVal->nType == TSDB_DATA_TYPE_BOOL && pLeft->nodeType == TSQL_NODE_COL) {
if (((*pExpr)->_node.optr != TSDB_BINARY_OP_BITAND && pLeft->pSchema->type == TSDB_DATA_TYPE_BOOL) ||
pLeft->pSchema->type == TSDB_DATA_TYPE_JSON) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
}
}
}
} else if (pSqlExpr->type == SQL_NODE_SQLFUNCTION) {
if (TSDB_FUNC_IS_SCALAR(pSqlExpr->functionId)) {
......
......@@ -126,6 +126,9 @@ _arithmetic_getVectorDoubleValue_fn_t getVectorDoubleValueFn(int32_t srcType) {
typedef void* (*_arithmetic_getVectorValueAddr_fn_t)(void *src, int32_t index);
void* getVectorValueAddr_BOOL(void *src, int32_t index) {
return (void*)((bool *)src + index);
}
void* getVectorValueAddr_TINYINT(void *src, int32_t index) {
return (void*)((int8_t *)src + index);
}
......@@ -159,7 +162,9 @@ void* getVectorValueAddr_DOUBLE(void *src, int32_t index) {
_arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFn(int32_t srcType) {
_arithmetic_getVectorValueAddr_fn_t p = NULL;
if(srcType==TSDB_DATA_TYPE_TINYINT) {
if (srcType == TSDB_DATA_TYPE_BOOL) {
p = getVectorValueAddr_BOOL;
}else if(srcType == TSDB_DATA_TYPE_TINYINT) {
p = getVectorValueAddr_TINYINT;
}else if(srcType==TSDB_DATA_TYPE_UTINYINT) {
p = getVectorValueAddr_UTINYINT;
......@@ -469,6 +474,271 @@ void vectorRemainder(void *left, int32_t len1, int32_t _left_type, void *right,
}
}
void vectorBitand(void *left, int32_t len1, int32_t _left_type, void *right, int32_t len2, int32_t _right_type, void *out, int32_t _ord) {
int32_t i = (_ord == TSDB_ORDER_ASC) ? 0 : MAX(len1, len2) - 1;
int32_t step = (_ord == TSDB_ORDER_ASC) ? 1 : -1;
char *output = out;
_arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFnLeft = getVectorValueAddrFn(_left_type);
_arithmetic_getVectorValueAddr_fn_t getVectorValueAddrFnRight = getVectorValueAddrFn(_right_type);
if (len1 == (len2)) {
for (; i >= 0 && i < (len2); i += step) {
if (isNull(getVectorValueAddrFnLeft(left, i), _left_type) || isNull(getVectorValueAddrFnRight(right, i), _right_type)) {
switch (_left_type) {
case TSDB_DATA_TYPE_BOOL:
*(bool *) output = TSDB_DATA_BOOL_NULL;
output += sizeof(bool);
break;
case TSDB_DATA_TYPE_TINYINT:
*(int8_t *) output = TSDB_DATA_TINYINT_NULL;
output += sizeof(int8_t);
break;
case TSDB_DATA_TYPE_SMALLINT:
*(int16_t *) output = TSDB_DATA_SMALLINT_NULL;
output += sizeof(int16_t);
break;
case TSDB_DATA_TYPE_INT:
*(int32_t *) output = TSDB_DATA_INT_NULL;
output += sizeof(int32_t);
break;
case TSDB_DATA_TYPE_BIGINT:
*(int64_t *) output = TSDB_DATA_BIGINT_NULL;
output += sizeof(int64_t);
break;
case TSDB_DATA_TYPE_UTINYINT:
*(uint8_t *) output = TSDB_DATA_UTINYINT_NULL;
output += sizeof(int8_t);
break;
case TSDB_DATA_TYPE_USMALLINT:
*(uint16_t *) output = TSDB_DATA_USMALLINT_NULL;
output += sizeof(int16_t);
break;
case TSDB_DATA_TYPE_UINT:
*(uint32_t *) output = TSDB_DATA_UINT_NULL;
output += sizeof(int32_t);
break;
case TSDB_DATA_TYPE_UBIGINT:
*(uint64_t *) output = TSDB_DATA_UBIGINT_NULL;
output += sizeof(int64_t);
break;
}
continue;
}
switch (_left_type) {
case TSDB_DATA_TYPE_BOOL:
*(bool *) output = (*((bool *) left + i)) & (*((bool *) right + i));
output += sizeof(bool);
break;
case TSDB_DATA_TYPE_TINYINT:
*(int8_t *) output = (*((int8_t *) left + i)) & (*((int8_t *) right + i));
output += sizeof(int8_t);
break;
case TSDB_DATA_TYPE_SMALLINT:
*(int16_t *) output = (*((int16_t *) left + i)) & (*((int16_t *) right + i));
output += sizeof(int16_t);
break;
case TSDB_DATA_TYPE_INT:
*(int32_t *) output = (*((int32_t *) left + i)) & (*((int32_t *) right + i));
output += sizeof(int32_t);
break;
case TSDB_DATA_TYPE_BIGINT:
*(int64_t *) output = (*((int64_t *) left + i)) & (*((int64_t *) right + i));
output += sizeof(int64_t);
break;
case TSDB_DATA_TYPE_UTINYINT:
*(uint8_t *) output = (*((uint8_t *) left + i)) & (*((uint8_t *) right + i));
output += sizeof(int8_t);
break;
case TSDB_DATA_TYPE_USMALLINT:
*(uint16_t *) output = (*((uint16_t *) left + i)) & (*((uint16_t *) right + i));
output += sizeof(int16_t);
break;
case TSDB_DATA_TYPE_UINT:
*(uint32_t *) output = (*((uint32_t *) left + i)) & (*((uint32_t *) right + i));
output += sizeof(int32_t);
break;
case TSDB_DATA_TYPE_UBIGINT:
*(uint64_t *) output = (*((uint64_t *) left + i)) & (*((uint64_t *) right + i));
output += sizeof(int64_t);
break;
}
}
} else if (len1 == 1) {
for (; i >= 0 && i < (len2); i += step) {
if (isNull(getVectorValueAddrFnLeft(left, 0), _left_type) || isNull(getVectorValueAddrFnRight(right, i), _right_type)) {
switch (_left_type) {
case TSDB_DATA_TYPE_BOOL:
*(bool *) output = TSDB_DATA_BOOL_NULL;
output += sizeof(bool);
break;
case TSDB_DATA_TYPE_TINYINT:
*(int8_t *) output = TSDB_DATA_TINYINT_NULL;
output += sizeof(int8_t);
break;
case TSDB_DATA_TYPE_SMALLINT:
*(int16_t *) output = TSDB_DATA_SMALLINT_NULL;
output += sizeof(int16_t);
break;
case TSDB_DATA_TYPE_INT:
*(int32_t *) output = TSDB_DATA_INT_NULL;
output += sizeof(int32_t);
break;
case TSDB_DATA_TYPE_BIGINT:
*(int64_t *) output = TSDB_DATA_BIGINT_NULL;
output += sizeof(int64_t);
break;
case TSDB_DATA_TYPE_UTINYINT:
*(uint8_t *) output = TSDB_DATA_UTINYINT_NULL;
output += sizeof(int8_t);
break;
case TSDB_DATA_TYPE_USMALLINT:
*(uint16_t *) output = TSDB_DATA_USMALLINT_NULL;
output += sizeof(int16_t);
break;
case TSDB_DATA_TYPE_UINT:
*(uint32_t *) output = TSDB_DATA_UINT_NULL;
output += sizeof(int32_t);
break;
case TSDB_DATA_TYPE_UBIGINT:
*(uint64_t *) output = TSDB_DATA_UBIGINT_NULL;
output += sizeof(int64_t);
break;
}
continue;
}
switch (_left_type) {
case TSDB_DATA_TYPE_BOOL:
*(bool *) output = (*(bool *) left) & (*((bool *) right + i));
output += sizeof(bool);
break;
case TSDB_DATA_TYPE_TINYINT:
*(int8_t *) output = (*(int8_t *) left) & (*((int8_t *) right + i));
output += sizeof(int8_t);
break;
case TSDB_DATA_TYPE_SMALLINT:
*(int16_t *) output = (*(int16_t *) left) & (*((int16_t *) right + i));
output += sizeof(int16_t);
break;
case TSDB_DATA_TYPE_INT:
*(int32_t *) output = (*(int32_t *) left) & (*((int32_t *) right + i));
output += sizeof(int32_t);
break;
case TSDB_DATA_TYPE_BIGINT:
*(int64_t *) output = (*(int64_t *) left) & (*((int64_t *) right + i));
output += sizeof(int64_t);
break;
case TSDB_DATA_TYPE_UTINYINT:
*(uint8_t *) output = (*(uint8_t *) left) & (*((uint8_t *) right + i));
output += sizeof(int8_t);
break;
case TSDB_DATA_TYPE_USMALLINT:
*(uint16_t *) output = (*(uint16_t *) left) & (*((uint16_t *) right + i));
output += sizeof(int16_t);
break;
case TSDB_DATA_TYPE_UINT:
*(uint32_t *) output = (*(uint32_t *) left) & (*((uint32_t *) right + i));
output += sizeof(int32_t);
break;
case TSDB_DATA_TYPE_UBIGINT:
*(uint64_t *) output = (*(uint64_t *) left) & (*((uint64_t *) right + i));
output += sizeof(int64_t);
break;
}
}
} else if ((len2) == 1) {
for (; i >= 0 && i < len1; i += step) {
if (isNull(getVectorValueAddrFnLeft(left, i), _left_type) || isNull(getVectorValueAddrFnRight(right, 0), _right_type)) {
switch (_left_type) {
case TSDB_DATA_TYPE_BOOL:
*(bool *) output = TSDB_DATA_BOOL_NULL;
output += sizeof(bool);
break;
case TSDB_DATA_TYPE_TINYINT:
*(int8_t *) output = TSDB_DATA_TINYINT_NULL;
output += sizeof(int8_t);
break;
case TSDB_DATA_TYPE_SMALLINT:
*(int16_t *) output = TSDB_DATA_SMALLINT_NULL;
output += sizeof(int16_t);
break;
case TSDB_DATA_TYPE_INT:
*(int32_t *) output = TSDB_DATA_INT_NULL;
output += sizeof(int32_t);
break;
case TSDB_DATA_TYPE_BIGINT:
*(int64_t *) output = TSDB_DATA_BIGINT_NULL;
output += sizeof(int64_t);
break;
case TSDB_DATA_TYPE_UTINYINT:
*(uint8_t *) output = TSDB_DATA_UTINYINT_NULL;
output += sizeof(int8_t);
break;
case TSDB_DATA_TYPE_USMALLINT:
*(uint16_t *) output = TSDB_DATA_USMALLINT_NULL;
output += sizeof(int16_t);
break;
case TSDB_DATA_TYPE_UINT:
*(uint32_t *) output = TSDB_DATA_UINT_NULL;
output += sizeof(int32_t);
break;
case TSDB_DATA_TYPE_UBIGINT:
*(uint64_t *) output = TSDB_DATA_UBIGINT_NULL;
output += sizeof(int64_t);
break;
}
continue;
}
switch (_left_type) {
case TSDB_DATA_TYPE_BOOL:
*(bool *) output = (*((bool *) left + i)) & (*(bool *) right);
output += sizeof(bool);
break;
case TSDB_DATA_TYPE_TINYINT:
*(int8_t *) output = (*((int8_t *) left + i)) & (*(int8_t *) right);
output += sizeof(int8_t);
break;
case TSDB_DATA_TYPE_SMALLINT:
*(int16_t *) output = (*((int16_t *) left + i)) & (*(int16_t *) right);
output += sizeof(int16_t);
break;
case TSDB_DATA_TYPE_INT:
*(int32_t *) output = (*((int32_t *) left + i)) & (*(int32_t *) right);
output += sizeof(int32_t);
break;
case TSDB_DATA_TYPE_BIGINT:
*(int64_t *) output = (*((int64_t *) left + i)) & (*(int64_t *) right);
output += sizeof(int64_t);
break;
case TSDB_DATA_TYPE_UTINYINT:
*(uint8_t *) output = (*((uint8_t *) left + i)) & (*(uint8_t *) right);
output += sizeof(int8_t);
break;
case TSDB_DATA_TYPE_USMALLINT:
*(uint16_t *) output = (*((uint16_t *) left + i)) & (*(uint16_t *) right);
output += sizeof(int16_t);
break;
case TSDB_DATA_TYPE_UINT:
*(uint32_t *) output = (*((uint32_t *) left + i)) & (*(uint32_t *) right);
output += sizeof(int32_t);
break;
case TSDB_DATA_TYPE_UBIGINT:
*(uint64_t *) output = (*((uint64_t *) left + i)) & (*(uint64_t *) right);
output += sizeof(int64_t);
break;
}
}
}
}
_arithmetic_operator_fn_t getArithmeticOperatorFn(int32_t arithmeticOptr) {
switch (arithmeticOptr) {
case TSDB_BINARY_OP_ADD:
......@@ -481,6 +751,8 @@ _arithmetic_operator_fn_t getArithmeticOperatorFn(int32_t arithmeticOptr) {
return vectorDivide;
case TSDB_BINARY_OP_REMAINDER:
return vectorRemainder;
case TSDB_BINARY_OP_BITAND:
return vectorBitand;
default:
assert(0);
return NULL;
......
......@@ -107,11 +107,13 @@ int32_t exprTreeValidateFunctionNode(char* msgbuf, tExprNode *pExpr) {
}
int32_t exprTreeValidateExprNode(tExprNode *pExpr) {
int16_t leftType = pExpr->_node.pLeft->resultType;
int16_t rightType = pExpr->_node.pRight->resultType;
int16_t resultType = leftType;
if (pExpr->_node.optr == TSDB_BINARY_OP_ADD || pExpr->_node.optr == TSDB_BINARY_OP_SUBTRACT ||
pExpr->_node.optr == TSDB_BINARY_OP_MULTIPLY || pExpr->_node.optr == TSDB_BINARY_OP_DIVIDE ||
pExpr->_node.optr == TSDB_BINARY_OP_REMAINDER) {
int16_t leftType = pExpr->_node.pLeft->resultType;
int16_t rightType = pExpr->_node.pRight->resultType;
if ((!IS_NUMERIC_TYPE(leftType) && !IS_TIMESTAMP_TYPE(leftType)) ||
(!IS_NUMERIC_TYPE(rightType) && !IS_TIMESTAMP_TYPE(rightType))) {
return TSDB_CODE_TSC_INVALID_OPERATION;
......@@ -133,6 +135,171 @@ int32_t exprTreeValidateExprNode(tExprNode *pExpr) {
pExpr->resultBytes = tDataTypes[TSDB_DATA_TYPE_DOUBLE].bytes;
}
return TSDB_CODE_SUCCESS;
} else if (pExpr->_node.optr == TSDB_BINARY_OP_BITAND) {
if ((leftType != TSDB_DATA_TYPE_BOOL && !IS_SIGNED_NUMERIC_TYPE(leftType) && !IS_UNSIGNED_NUMERIC_TYPE(leftType)) ||
(rightType != TSDB_DATA_TYPE_BOOL && !IS_SIGNED_NUMERIC_TYPE(rightType) && !IS_UNSIGNED_NUMERIC_TYPE(rightType)))
{
return TSDB_CODE_TSC_INVALID_OPERATION;
}
uint8_t schemaType;
// now leftType and rightType are both numeric
if (pExpr->_node.pLeft->nodeType == TSQL_NODE_COL && pExpr->_node.pRight->nodeType == TSQL_NODE_COL) {
if (leftType != rightType) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
} else if (pExpr->_node.pLeft->nodeType == TSQL_NODE_COL) {
if (pExpr->_node.pRight->nodeType != TSQL_NODE_VALUE) {
return TSDB_CODE_TSC_INVALID_OPERATION;
} else {
schemaType = pExpr->_node.pLeft->pSchema->type;
int64_t sVal = pExpr->_node.pRight->pVal->i64;
uint64_t uVal = pExpr->_node.pRight->pVal->u64;
switch (schemaType) {
case TSDB_DATA_TYPE_BOOL:
if ((pExpr->_node.pRight->pVal->nType != TSDB_DATA_TYPE_BOOL) ||
(pExpr->_node.pRight->pVal->i64 != 0 &&
pExpr->_node.pRight->pVal->i64 != 1 &&
pExpr->_node.pRight->pVal->i64 != TSDB_DATA_BOOL_NULL))
{
return TSDB_CODE_TSC_INVALID_OPERATION;
}
break;
case TSDB_DATA_TYPE_TINYINT:
if (sVal < -128 || sVal > 127) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
break;
case TSDB_DATA_TYPE_SMALLINT:
if (sVal < -32768 || sVal > 32767) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
break;
case TSDB_DATA_TYPE_INT:
if (sVal < INT32_MIN || sVal > INT32_MAX) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
break;
case TSDB_DATA_TYPE_BIGINT:
if (sVal < INT64_MIN || sVal > INT64_MAX) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
break;
case TSDB_DATA_TYPE_UTINYINT:
if (uVal > 255) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
break;
case TSDB_DATA_TYPE_USMALLINT:
if (uVal > 65535) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
break;
case TSDB_DATA_TYPE_UINT:
if (uVal > UINT32_MAX) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
break;
case TSDB_DATA_TYPE_UBIGINT:
if (uVal > UINT64_MAX) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
break;
}
pExpr->_node.pRight->pSchema->type = schemaType;
pExpr->_node.pRight->pVal->nType = schemaType;
pExpr->_node.pRight->resultType = schemaType;
pExpr->_node.pRight->resultBytes = tDataTypes[schemaType].bytes;
}
} else {
if (pExpr->_node.pLeft->nodeType != TSQL_NODE_VALUE) {
return TSDB_CODE_TSC_INVALID_OPERATION;
} else {
schemaType = pExpr->_node.pRight->pSchema->type;
int64_t sVal = pExpr->_node.pLeft->pVal->i64;
uint64_t uVal = pExpr->_node.pLeft->pVal->u64;
switch (schemaType) {
case TSDB_DATA_TYPE_BOOL:
if ((pExpr->_node.pLeft->pVal->nType != TSDB_DATA_TYPE_BOOL) ||
(pExpr->_node.pLeft->pVal->i64 != 0 &&
pExpr->_node.pLeft->pVal->i64 != 1 &&
pExpr->_node.pLeft->pVal->i64 != TSDB_DATA_BOOL_NULL))
{
return TSDB_CODE_TSC_INVALID_OPERATION;
}
pExpr->_node.pLeft->pVal->nLen = 1;
break;
case TSDB_DATA_TYPE_TINYINT:
if (sVal < -128 || sVal > 127) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
pExpr->_node.pLeft->pVal->nLen = 1;
break;
case TSDB_DATA_TYPE_SMALLINT:
if (sVal < -32768 || sVal > 32767) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
pExpr->_node.pLeft->pVal->nLen = 2;
break;
case TSDB_DATA_TYPE_INT:
if (sVal < INT32_MIN || sVal > INT32_MAX) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
pExpr->_node.pLeft->pVal->nLen = 4;
break;
case TSDB_DATA_TYPE_BIGINT:
if (sVal < INT64_MIN || sVal > INT64_MAX) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
pExpr->_node.pLeft->pVal->nLen = 8;
break;
case TSDB_DATA_TYPE_UTINYINT:
if (uVal > 255) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
pExpr->_node.pLeft->pVal->nLen = 1;
break;
case TSDB_DATA_TYPE_USMALLINT:
if (uVal > 65535) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
pExpr->_node.pLeft->pVal->nLen = 2;
break;
case TSDB_DATA_TYPE_UINT:
if (uVal > UINT32_MAX) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
pExpr->_node.pLeft->pVal->nLen = 4;
break;
case TSDB_DATA_TYPE_UBIGINT:
if (uVal > UINT64_MAX) {
return TSDB_CODE_TSC_INVALID_OPERATION;
}
pExpr->_node.pLeft->pVal->nLen = 8;
break;
}
pExpr->_node.pLeft->pSchema->type = schemaType;
pExpr->_node.pLeft->pVal->nType = schemaType;
pExpr->_node.pLeft->resultType = schemaType;
pExpr->_node.pLeft->resultBytes = tDataTypes[schemaType].bytes;
}
resultType = schemaType;
}
if (resultType == TSDB_DATA_TYPE_BOOL) {
pExpr->resultType = TSDB_DATA_TYPE_BOOL;
pExpr->resultBytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes;
} else {
pExpr->resultType = resultType;
pExpr->resultBytes = tDataTypes[resultType].bytes;
}
return TSDB_CODE_SUCCESS;
} else {
return TSDB_CODE_SUCCESS;
}
......@@ -535,9 +702,13 @@ void exprTreeExprNodeTraverse(tExprNode *pExpr, int32_t numOfRows, tExprOperandI
output->numOfRows = MAX(leftNum, rightNum);
if(leftType == TSDB_DATA_TYPE_TIMESTAMP || rightType == TSDB_DATA_TYPE_TIMESTAMP) {
output->type = TSDB_DATA_TYPE_BIGINT;
} else {
if (pExpr->_node.optr == TSDB_BINARY_OP_BITAND) {
output->type = leftType; // rightType must be the same as leftType
} else {
output->type = TSDB_DATA_TYPE_DOUBLE;
}
}
output->bytes = tDataTypes[output->type].bytes;
tfree(ltmp);
......
......@@ -183,10 +183,11 @@ do { \
#define TSDB_BINARY_OP_MULTIPLY 32
#define TSDB_BINARY_OP_DIVIDE 33
#define TSDB_BINARY_OP_REMAINDER 34
#define TSDB_BINARY_OP_BITAND 35
#define IS_RELATION_OPTR(op) (((op) >= TSDB_RELATION_LESS) && ((op) < TSDB_RELATION_IN))
#define IS_ARITHMETIC_OPTR(op) (((op) >= TSDB_BINARY_OP_ADD) && ((op) <= TSDB_BINARY_OP_REMAINDER))
#define IS_ARITHMETIC_OPTR(op) (((op) >= TSDB_BINARY_OP_ADD) && ((op) <= TSDB_BINARY_OP_BITAND))
#define TS_PATH_DELIMITER_LEN 1
......
......@@ -87,6 +87,7 @@ TAOS *shellInit(SShellArguments *_args) {
}
if (con == NULL) {
printf("\033[31mfailed to connect to db, reason:%s\033[0m\n", taos_errstr(con));
fflush(stdout);
return con;
}
......
Subproject commit bae99633455cde5a4fd6435efe65cf24f13b805e
Subproject commit bf6c766986c61ff4fc80421fdea682a8fd4b5b32
......@@ -801,6 +801,7 @@ expr(A) ::= expr(X) MINUS expr(Y). {A = tSqlExprCreate(X, Y, TK_MINUS); }
expr(A) ::= expr(X) STAR expr(Y). {A = tSqlExprCreate(X, Y, TK_STAR); }
expr(A) ::= expr(X) SLASH expr(Y). {A = tSqlExprCreate(X, Y, TK_DIVIDE);}
expr(A) ::= expr(X) REM expr(Y). {A = tSqlExprCreate(X, Y, TK_REM); }
expr(A) ::= expr(X) BITAND expr(Y). {A = tSqlExprCreate(X, Y, TK_BITAND);}
// like expression
expr(A) ::= expr(X) LIKE expr(Y). {A = tSqlExprCreate(X, Y, TK_LIKE); }
......
......@@ -23,7 +23,6 @@
** input grammar file:
*/
#include <stdio.h>
#include <assert.h>
/************ Begin %include sections from the grammar ************************/
#include <stdio.h>
......@@ -77,10 +76,8 @@
** zero the stack is dynamically sized using realloc()
** ParseARG_SDECL A static variable declaration for the %extra_argument
** ParseARG_PDECL A parameter declaration for the %extra_argument
** ParseARG_PARAM Code to pass %extra_argument as a subroutine parameter
** ParseARG_STORE Code to store %extra_argument into yypParser
** ParseARG_FETCH Code to extract %extra_argument from yypParser
** ParseCTX_* As ParseARG_ except for %extra_context
** YYERRORSYMBOL is the code number of the error symbol. If not
** defined, then do no error processing.
** YYNSTATE the combined number of states.
......@@ -100,58 +97,51 @@
#endif
/************* Begin control #defines *****************************************/
#define YYCODETYPE unsigned short int
#define YYNOCODE 291
#define YYNOCODE 293
#define YYACTIONTYPE unsigned short int
#define ParseTOKENTYPE SStrToken
typedef union {
int yyinit;
ParseTOKENTYPE yy0;
SLimitVal yy6;
SSqlNode* yy86;
tVariant yy110;
TAOS_FIELD yy115;
tSqlExpr* yy142;
SIntervalVal yy238;
SSessionWindowVal yy319;
SRelationInfo* yy328;
SRangeVal yy330;
SCreateDbInfo yy436;
SCreatedTableInfo yy480;
int32_t yy508;
SCreateAcctInfo yy517;
SArray* yy525;
int64_t yy543;
SWindowStateVal yy546;
SCreateTableSql* yy572;
int yy580;
tVariant yy42;
int32_t yy44;
SCreateTableSql* yy78;
SRangeVal yy132;
int yy133;
SSqlNode* yy144;
SLimitVal yy190;
tSqlExpr* yy194;
SIntervalVal yy200;
SSessionWindowVal yy235;
SWindowStateVal yy248;
TAOS_FIELD yy263;
int64_t yy277;
SCreateAcctInfo yy299;
SArray* yy333;
SCreateDbInfo yy342;
SCreatedTableInfo yy400;
SRelationInfo* yy516;
} YYMINORTYPE;
#ifndef YYSTACKDEPTH
#define YYSTACKDEPTH 100
#endif
#define ParseARG_SDECL SSqlInfo* pInfo;
#define ParseARG_PDECL ,SSqlInfo* pInfo
#define ParseARG_PARAM ,pInfo
#define ParseARG_FETCH SSqlInfo* pInfo=yypParser->pInfo;
#define ParseARG_STORE yypParser->pInfo=pInfo;
#define ParseCTX_SDECL
#define ParseCTX_PDECL
#define ParseCTX_PARAM
#define ParseCTX_FETCH
#define ParseCTX_STORE
#define ParseARG_FETCH SSqlInfo* pInfo = yypParser->pInfo
#define ParseARG_STORE yypParser->pInfo = pInfo
#define YYFALLBACK 1
#define YYNSTATE 403
#define YYNRULE 321
#define YYNSTATE 405
#define YYNRULE 322
#define YYNTOKEN 205
#define YY_MAX_SHIFT 402
#define YY_MIN_SHIFTREDUCE 631
#define YY_MAX_SHIFTREDUCE 951
#define YY_ERROR_ACTION 952
#define YY_ACCEPT_ACTION 953
#define YY_NO_ACTION 954
#define YY_MIN_REDUCE 955
#define YY_MAX_REDUCE 1275
#define YY_MAX_SHIFT 404
#define YY_MIN_SHIFTREDUCE 633
#define YY_MAX_SHIFTREDUCE 954
#define YY_ERROR_ACTION 955
#define YY_ACCEPT_ACTION 956
#define YY_NO_ACTION 957
#define YY_MIN_REDUCE 958
#define YY_MAX_REDUCE 1279
/************* End control #defines *******************************************/
#define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))
/* Define the yytestcase() macro to be a no-op if is not already defined
** otherwise.
......@@ -216,322 +206,325 @@ typedef union {
** yy_default[] Default action for each state.
**
*********** Begin parsing tables **********************************************/
#define YY_ACTTAB_COUNT (872)
#define YY_ACTTAB_COUNT (889)
static const YYACTIONTYPE yy_action[] = {
/* 0 */ 106, 682, 401, 247, 953, 402, 266, 1129, 682, 683,
/* 10 */ 1190, 718, 1191, 319, 37, 38, 683, 41, 42, 395,
/* 20 */ 1041, 269, 31, 30, 29, 250, 167, 40, 352, 45,
/* 30 */ 43, 46, 44, 1093, 1094, 55, 1097, 36, 35, 24,
/* 40 */ 220, 34, 33, 32, 37, 38, 256, 41, 42, 1248,
/* 50 */ 1248, 269, 31, 30, 29, 221, 1129, 40, 352, 45,
/* 60 */ 43, 46, 44, 323, 101, 1248, 100, 36, 35, 222,
/* 70 */ 218, 34, 33, 32, 293, 766, 132, 126, 137, 1248,
/* 80 */ 1248, 1250, 1251, 136, 1113, 142, 145, 135, 37, 38,
/* 90 */ 89, 41, 42, 51, 139, 269, 31, 30, 29, 300,
/* 100 */ 299, 40, 352, 45, 43, 46, 44, 377, 376, 348,
/* 110 */ 182, 36, 35, 1138, 227, 34, 33, 32, 37, 38,
/* 120 */ 58, 41, 42, 59, 1248, 269, 31, 30, 29, 309,
/* 130 */ 228, 40, 352, 45, 43, 46, 44, 34, 33, 32,
/* 140 */ 1248, 36, 35, 682, 229, 34, 33, 32, 13, 37,
/* 150 */ 39, 683, 41, 42, 1248, 809, 269, 31, 30, 29,
/* 160 */ 1270, 880, 40, 352, 45, 43, 46, 44, 249, 400,
/* 170 */ 398, 659, 36, 35, 59, 1111, 34, 33, 32, 213,
/* 180 */ 211, 209, 108, 87, 10, 1135, 208, 152, 151, 150,
/* 190 */ 149, 632, 633, 634, 635, 636, 637, 638, 639, 640,
/* 200 */ 641, 642, 643, 644, 645, 161, 254, 248, 38, 59,
/* 210 */ 41, 42, 387, 1114, 269, 31, 30, 29, 285, 259,
/* 220 */ 40, 352, 45, 43, 46, 44, 1111, 289, 288, 682,
/* 230 */ 36, 35, 1262, 261, 34, 33, 32, 683, 41, 42,
/* 240 */ 1114, 294, 269, 31, 30, 29, 1240, 1239, 40, 352,
/* 250 */ 45, 43, 46, 44, 260, 60, 1248, 1248, 36, 35,
/* 260 */ 59, 1111, 34, 33, 32, 67, 346, 394, 393, 345,
/* 270 */ 344, 343, 392, 342, 341, 340, 391, 339, 390, 389,
/* 280 */ 1072, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068,
/* 290 */ 1069, 1070, 1071, 1073, 1074, 241, 896, 25, 1096, 884,
/* 300 */ 1238, 887, 95, 890, 794, 364, 134, 791, 301, 792,
/* 310 */ 1248, 793, 1111, 243, 226, 244, 241, 896, 387, 263,
/* 320 */ 884, 234, 887, 1248, 890, 1248, 1114, 148, 147, 146,
/* 330 */ 233, 245, 246, 104, 360, 95, 5, 62, 193, 274,
/* 340 */ 275, 224, 68, 192, 115, 120, 111, 119, 90, 837,
/* 350 */ 828, 1248, 245, 246, 831, 1129, 354, 45, 43, 46,
/* 360 */ 44, 272, 335, 169, 59, 36, 35, 278, 225, 34,
/* 370 */ 33, 32, 302, 251, 67, 68, 394, 393, 1248, 230,
/* 380 */ 47, 392, 305, 306, 59, 391, 348, 390, 389, 1248,
/* 390 */ 36, 35, 265, 351, 34, 33, 32, 886, 292, 889,
/* 400 */ 85, 47, 885, 59, 888, 59, 270, 242, 59, 365,
/* 410 */ 1188, 282, 1189, 59, 223, 350, 1111, 897, 891, 893,
/* 420 */ 1080, 1003, 1078, 1079, 1248, 795, 276, 1081, 203, 366,
/* 430 */ 812, 1082, 268, 1083, 1084, 1201, 1111, 1104, 897, 891,
/* 440 */ 893, 273, 892, 271, 59, 363, 362, 280, 367, 277,
/* 450 */ 373, 372, 371, 374, 6, 1111, 222, 1111, 375, 109,
/* 460 */ 1111, 840, 841, 892, 231, 1111, 1248, 59, 1251, 252,
/* 470 */ 222, 160, 158, 157, 1248, 232, 86, 236, 237, 860,
/* 480 */ 1248, 238, 1251, 235, 262, 1248, 279, 1248, 1248, 379,
/* 490 */ 219, 1248, 279, 1248, 279, 1098, 1111, 189, 279, 76,
/* 500 */ 1248, 1013, 92, 190, 103, 353, 102, 93, 203, 1112,
/* 510 */ 1095, 304, 303, 1004, 847, 1, 191, 894, 816, 1110,
/* 520 */ 203, 848, 895, 3, 204, 79, 350, 776, 71, 54,
/* 530 */ 267, 327, 778, 356, 329, 48, 777, 925, 898, 859,
/* 540 */ 357, 60, 296, 322, 77, 60, 71, 296, 107, 681,
/* 550 */ 71, 9, 9, 83, 15, 355, 14, 125, 801, 124,
/* 560 */ 802, 1200, 330, 9, 17, 799, 16, 800, 80, 257,
/* 570 */ 883, 369, 368, 1197, 19, 131, 18, 130, 21, 1196,
/* 580 */ 20, 144, 143, 258, 378, 765, 185, 163, 290, 165,
/* 590 */ 166, 1109, 1137, 26, 1148, 1145, 1130, 1146, 297, 1105,
/* 600 */ 1150, 168, 173, 315, 1180, 1179, 1178, 1177, 184, 186,
/* 610 */ 1103, 1275, 159, 187, 188, 1018, 332, 333, 396, 334,
/* 620 */ 337, 338, 827, 69, 216, 65, 349, 81, 27, 308,
/* 630 */ 1012, 253, 310, 361, 312, 1269, 122, 1268, 1265, 194,
/* 640 */ 370, 1127, 1261, 128, 1260, 1257, 195, 901, 1038, 66,
/* 650 */ 78, 174, 324, 61, 28, 70, 320, 318, 175, 217,
/* 660 */ 1000, 138, 998, 140, 141, 996, 995, 281, 206, 178,
/* 670 */ 207, 992, 991, 990, 316, 989, 988, 987, 986, 210,
/* 680 */ 212, 314, 978, 214, 975, 215, 311, 971, 307, 88,
/* 690 */ 336, 162, 388, 84, 295, 1107, 91, 96, 313, 133,
/* 700 */ 380, 381, 382, 383, 384, 82, 385, 386, 164, 950,
/* 710 */ 264, 331, 283, 284, 949, 286, 239, 287, 948, 931,
/* 720 */ 240, 930, 1017, 1016, 116, 117, 291, 296, 11, 326,
/* 730 */ 94, 804, 298, 52, 97, 836, 994, 993, 74, 198,
/* 740 */ 985, 1039, 200, 196, 197, 199, 201, 202, 153, 2,
/* 750 */ 154, 325, 1076, 155, 984, 1040, 156, 834, 53, 179,
/* 760 */ 180, 176, 177, 183, 181, 977, 4, 976, 833, 1086,
/* 770 */ 830, 829, 75, 172, 838, 170, 255, 849, 171, 63,
/* 780 */ 843, 98, 355, 845, 99, 317, 321, 105, 22, 64,
/* 790 */ 23, 12, 49, 328, 56, 108, 50, 110, 113, 696,
/* 800 */ 731, 112, 729, 728, 727, 57, 114, 725, 724, 723,
/* 810 */ 720, 686, 347, 118, 7, 922, 920, 900, 923, 899,
/* 820 */ 921, 358, 8, 902, 359, 72, 121, 60, 123, 73,
/* 830 */ 768, 127, 798, 767, 129, 764, 712, 710, 702, 708,
/* 840 */ 704, 706, 797, 700, 698, 734, 733, 732, 730, 726,
/* 850 */ 722, 721, 205, 684, 649, 955, 658, 656, 954, 397,
/* 860 */ 954, 954, 954, 954, 954, 954, 954, 954, 954, 954,
/* 870 */ 954, 399,
/* 0 */ 223, 684, 1107, 168, 956, 404, 24, 768, 1141, 685,
/* 10 */ 1252, 684, 1254, 256, 38, 39, 1252, 42, 43, 685,
/* 20 */ 1117, 271, 31, 30, 29, 403, 249, 41, 354, 46,
/* 30 */ 44, 47, 45, 32, 110, 258, 221, 37, 36, 379,
/* 40 */ 378, 35, 34, 33, 38, 39, 1252, 42, 43, 264,
/* 50 */ 183, 271, 31, 30, 29, 303, 1132, 41, 354, 46,
/* 60 */ 44, 47, 45, 32, 35, 34, 33, 37, 36, 311,
/* 70 */ 1101, 35, 34, 33, 295, 684, 302, 301, 38, 39,
/* 80 */ 1138, 42, 43, 685, 720, 271, 31, 30, 29, 60,
/* 90 */ 90, 41, 354, 46, 44, 47, 45, 32, 402, 400,
/* 100 */ 661, 37, 36, 222, 227, 35, 34, 33, 38, 39,
/* 110 */ 13, 42, 43, 1252, 1252, 271, 31, 30, 29, 296,
/* 120 */ 59, 41, 354, 46, 44, 47, 45, 32, 161, 159,
/* 130 */ 158, 37, 36, 61, 251, 35, 34, 33, 350, 38,
/* 140 */ 40, 1114, 42, 43, 109, 88, 271, 31, 30, 29,
/* 150 */ 281, 882, 41, 354, 46, 44, 47, 45, 32, 389,
/* 160 */ 52, 190, 37, 36, 228, 684, 35, 34, 33, 39,
/* 170 */ 229, 42, 43, 685, 1252, 271, 31, 30, 29, 240,
/* 180 */ 1252, 41, 354, 46, 44, 47, 45, 32, 60, 1252,
/* 190 */ 96, 37, 36, 842, 843, 35, 34, 33, 68, 348,
/* 200 */ 396, 395, 347, 346, 345, 394, 344, 343, 342, 393,
/* 210 */ 341, 392, 391, 634, 635, 636, 637, 638, 639, 640,
/* 220 */ 641, 642, 643, 644, 645, 646, 647, 162, 60, 250,
/* 230 */ 69, 42, 43, 261, 1116, 271, 31, 30, 29, 287,
/* 240 */ 1114, 41, 354, 46, 44, 47, 45, 32, 291, 290,
/* 250 */ 811, 37, 36, 60, 1274, 35, 34, 33, 25, 352,
/* 260 */ 1075, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071,
/* 270 */ 1072, 1073, 1074, 1076, 1077, 233, 324, 243, 898, 10,
/* 280 */ 1113, 886, 235, 889, 1193, 892, 1194, 321, 149, 148,
/* 290 */ 147, 234, 1243, 243, 898, 362, 96, 886, 262, 889,
/* 300 */ 304, 892, 1252, 359, 1191, 1114, 1192, 46, 44, 47,
/* 310 */ 45, 32, 1242, 247, 248, 37, 36, 356, 1241, 35,
/* 320 */ 34, 33, 1252, 1204, 5, 63, 194, 245, 1252, 247,
/* 330 */ 248, 193, 116, 121, 112, 120, 69, 1252, 796, 325,
/* 340 */ 102, 793, 101, 794, 32, 795, 1266, 830, 37, 36,
/* 350 */ 337, 833, 35, 34, 33, 1099, 214, 212, 210, 294,
/* 360 */ 60, 86, 48, 209, 153, 152, 151, 150, 244, 274,
/* 370 */ 268, 267, 284, 276, 277, 133, 127, 138, 48, 307,
/* 380 */ 308, 888, 137, 891, 143, 146, 136, 280, 272, 887,
/* 390 */ 104, 890, 103, 140, 246, 1083, 1203, 1081, 1082, 899,
/* 400 */ 893, 895, 1084, 107, 1252, 366, 1085, 263, 1086, 1087,
/* 410 */ 903, 60, 1114, 259, 1117, 899, 893, 895, 68, 353,
/* 420 */ 396, 395, 37, 36, 894, 394, 35, 34, 33, 393,
/* 430 */ 60, 392, 391, 60, 219, 223, 1096, 1097, 56, 1100,
/* 440 */ 894, 352, 60, 350, 1252, 1252, 1255, 1255, 186, 275,
/* 450 */ 60, 273, 223, 365, 364, 60, 367, 281, 270, 797,
/* 460 */ 278, 60, 1252, 1114, 1255, 814, 254, 282, 191, 279,
/* 470 */ 265, 374, 373, 281, 164, 368, 225, 1117, 369, 226,
/* 480 */ 6, 230, 1114, 224, 355, 1114, 1252, 375, 231, 1252,
/* 490 */ 87, 1252, 281, 1252, 1114, 376, 862, 1006, 1252, 93,
/* 500 */ 377, 896, 1114, 1115, 204, 232, 381, 1114, 135, 897,
/* 510 */ 105, 237, 238, 1114, 1132, 1252, 239, 236, 220, 1132,
/* 520 */ 389, 1252, 1252, 94, 1098, 91, 1252, 1252, 1252, 397,
/* 530 */ 1044, 1016, 252, 1007, 839, 1, 192, 253, 204, 298,
/* 540 */ 204, 3, 205, 306, 305, 849, 850, 77, 170, 269,
/* 550 */ 778, 80, 329, 818, 780, 331, 861, 779, 55, 72,
/* 560 */ 49, 928, 358, 298, 61, 900, 61, 683, 72, 108,
/* 570 */ 15, 72, 14, 84, 126, 9, 125, 292, 17, 9,
/* 580 */ 16, 9, 371, 370, 357, 803, 801, 804, 802, 885,
/* 590 */ 166, 332, 78, 19, 81, 18, 132, 21, 131, 20,
/* 600 */ 145, 144, 1200, 167, 1199, 767, 260, 380, 1112, 1140,
/* 610 */ 26, 1151, 1148, 1149, 1153, 1133, 169, 174, 299, 317,
/* 620 */ 1108, 1183, 1182, 1181, 185, 1180, 187, 1106, 188, 1279,
/* 630 */ 189, 1021, 160, 829, 398, 334, 335, 336, 339, 340,
/* 640 */ 70, 217, 66, 351, 27, 1015, 363, 1273, 1130, 123,
/* 650 */ 1272, 310, 82, 1269, 255, 312, 195, 372, 314, 1265,
/* 660 */ 129, 1264, 1261, 196, 1041, 67, 79, 175, 62, 71,
/* 670 */ 218, 326, 1003, 28, 139, 176, 322, 1001, 178, 141,
/* 680 */ 320, 142, 177, 999, 998, 283, 318, 207, 316, 208,
/* 690 */ 995, 994, 993, 992, 991, 313, 990, 989, 211, 213,
/* 700 */ 981, 215, 978, 216, 974, 309, 89, 338, 163, 390,
/* 710 */ 85, 297, 1110, 92, 97, 315, 134, 382, 383, 384,
/* 720 */ 385, 386, 387, 83, 388, 165, 266, 333, 953, 286,
/* 730 */ 285, 952, 288, 241, 242, 289, 951, 934, 933, 1020,
/* 740 */ 1019, 117, 118, 293, 298, 328, 11, 95, 806, 300,
/* 750 */ 997, 53, 996, 199, 154, 198, 1042, 197, 200, 202,
/* 760 */ 201, 203, 838, 155, 156, 988, 987, 2, 157, 1079,
/* 770 */ 179, 327, 1043, 980, 979, 184, 180, 4, 181, 182,
/* 780 */ 54, 98, 75, 836, 835, 1089, 832, 831, 76, 173,
/* 790 */ 840, 171, 257, 851, 172, 64, 845, 99, 357, 847,
/* 800 */ 100, 319, 323, 22, 12, 65, 23, 106, 50, 330,
/* 810 */ 111, 51, 109, 114, 698, 733, 731, 730, 57, 113,
/* 820 */ 729, 727, 726, 58, 115, 725, 722, 688, 119, 349,
/* 830 */ 7, 925, 923, 926, 902, 901, 924, 361, 8, 904,
/* 840 */ 122, 124, 360, 73, 61, 800, 799, 74, 128, 770,
/* 850 */ 130, 769, 766, 714, 712, 704, 710, 706, 708, 702,
/* 860 */ 700, 736, 735, 734, 732, 728, 724, 723, 206, 686,
/* 870 */ 958, 651, 660, 957, 658, 957, 957, 957, 957, 957,
/* 880 */ 957, 957, 957, 957, 957, 957, 399, 957, 401,
};
static const YYCODETYPE yy_lookahead[] = {
/* 0 */ 215, 1, 207, 208, 205, 206, 214, 257, 1, 9,
/* 10 */ 286, 5, 288, 289, 14, 15, 9, 17, 18, 229,
/* 20 */ 230, 21, 22, 23, 24, 275, 207, 27, 28, 29,
/* 30 */ 30, 31, 32, 248, 249, 250, 251, 37, 38, 278,
/* 40 */ 278, 41, 42, 43, 14, 15, 1, 17, 18, 288,
/* 50 */ 288, 21, 22, 23, 24, 278, 257, 27, 28, 29,
/* 60 */ 30, 31, 32, 285, 286, 288, 288, 37, 38, 278,
/* 70 */ 278, 41, 42, 43, 275, 5, 66, 67, 68, 288,
/* 80 */ 288, 290, 290, 73, 260, 75, 76, 77, 14, 15,
/* 90 */ 90, 17, 18, 86, 84, 21, 22, 23, 24, 280,
/* 100 */ 281, 27, 28, 29, 30, 31, 32, 37, 38, 88,
/* 110 */ 265, 37, 38, 207, 278, 41, 42, 43, 14, 15,
/* 120 */ 90, 17, 18, 207, 288, 21, 22, 23, 24, 284,
/* 130 */ 278, 27, 28, 29, 30, 31, 32, 41, 42, 43,
/* 140 */ 288, 37, 38, 1, 278, 41, 42, 43, 86, 14,
/* 150 */ 15, 9, 17, 18, 288, 101, 21, 22, 23, 24,
/* 160 */ 260, 87, 27, 28, 29, 30, 31, 32, 252, 69,
/* 170 */ 70, 71, 37, 38, 207, 259, 41, 42, 43, 66,
/* 180 */ 67, 68, 120, 121, 130, 279, 73, 74, 75, 76,
/* 190 */ 77, 49, 50, 51, 52, 53, 54, 55, 56, 57,
/* 200 */ 58, 59, 60, 61, 62, 63, 253, 65, 15, 207,
/* 210 */ 17, 18, 94, 260, 21, 22, 23, 24, 150, 252,
/* 220 */ 27, 28, 29, 30, 31, 32, 259, 159, 160, 1,
/* 230 */ 37, 38, 260, 253, 41, 42, 43, 9, 17, 18,
/* 240 */ 260, 87, 21, 22, 23, 24, 278, 278, 27, 28,
/* 250 */ 29, 30, 31, 32, 252, 101, 288, 288, 37, 38,
/* 260 */ 207, 259, 41, 42, 43, 102, 103, 104, 105, 106,
/* 270 */ 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
/* 280 */ 231, 232, 233, 234, 235, 236, 237, 238, 239, 240,
/* 290 */ 241, 242, 243, 244, 245, 1, 2, 48, 0, 5,
/* 300 */ 278, 7, 86, 9, 2, 252, 82, 5, 283, 7,
/* 310 */ 288, 9, 259, 278, 65, 278, 1, 2, 94, 253,
/* 320 */ 5, 72, 7, 288, 9, 288, 260, 78, 79, 80,
/* 330 */ 81, 37, 38, 261, 85, 86, 66, 67, 68, 37,
/* 340 */ 38, 278, 126, 73, 74, 75, 76, 77, 276, 87,
/* 350 */ 5, 288, 37, 38, 9, 257, 41, 29, 30, 31,
/* 360 */ 32, 72, 92, 101, 207, 37, 38, 72, 278, 41,
/* 370 */ 42, 43, 283, 275, 102, 126, 104, 105, 288, 278,
/* 380 */ 86, 109, 37, 38, 207, 113, 88, 115, 116, 288,
/* 390 */ 37, 38, 214, 25, 41, 42, 43, 5, 149, 7,
/* 400 */ 151, 86, 5, 207, 7, 207, 214, 158, 207, 252,
/* 410 */ 286, 162, 288, 207, 278, 47, 259, 123, 124, 125,
/* 420 */ 231, 213, 233, 234, 288, 123, 124, 238, 220, 252,
/* 430 */ 41, 242, 64, 244, 245, 247, 259, 207, 123, 124,
/* 440 */ 125, 152, 148, 154, 207, 156, 157, 152, 252, 154,
/* 450 */ 252, 156, 157, 252, 86, 259, 278, 259, 252, 215,
/* 460 */ 259, 132, 133, 148, 278, 259, 288, 207, 290, 124,
/* 470 */ 278, 66, 67, 68, 288, 278, 215, 278, 278, 80,
/* 480 */ 288, 278, 290, 278, 254, 288, 207, 288, 288, 252,
/* 490 */ 278, 288, 207, 288, 207, 251, 259, 218, 207, 101,
/* 500 */ 288, 213, 87, 218, 286, 218, 288, 87, 220, 218,
/* 510 */ 249, 37, 38, 213, 87, 216, 217, 125, 129, 259,
/* 520 */ 220, 87, 125, 211, 212, 101, 47, 87, 101, 86,
/* 530 */ 1, 87, 87, 25, 87, 101, 87, 87, 87, 140,
/* 540 */ 16, 101, 127, 64, 146, 101, 101, 127, 101, 87,
/* 550 */ 101, 101, 101, 86, 153, 47, 155, 153, 5, 155,
/* 560 */ 7, 247, 119, 101, 153, 5, 155, 7, 144, 247,
/* 570 */ 41, 37, 38, 247, 153, 153, 155, 155, 153, 247,
/* 580 */ 155, 82, 83, 247, 247, 118, 255, 207, 207, 207,
/* 590 */ 207, 207, 207, 277, 207, 207, 257, 207, 257, 257,
/* 600 */ 207, 207, 207, 207, 287, 287, 287, 287, 262, 207,
/* 610 */ 207, 263, 64, 207, 207, 207, 207, 207, 88, 207,
/* 620 */ 207, 207, 125, 207, 207, 207, 207, 143, 147, 282,
/* 630 */ 207, 282, 282, 207, 282, 207, 207, 207, 207, 207,
/* 640 */ 207, 274, 207, 207, 207, 207, 207, 123, 207, 207,
/* 650 */ 145, 273, 138, 207, 142, 207, 141, 136, 272, 207,
/* 660 */ 207, 207, 207, 207, 207, 207, 207, 207, 207, 269,
/* 670 */ 207, 207, 207, 207, 135, 207, 207, 207, 207, 207,
/* 680 */ 207, 134, 207, 207, 207, 207, 137, 207, 131, 122,
/* 690 */ 93, 209, 117, 210, 209, 209, 209, 209, 209, 100,
/* 700 */ 99, 55, 96, 98, 59, 209, 97, 95, 130, 5,
/* 710 */ 209, 209, 161, 5, 5, 161, 209, 5, 5, 104,
/* 720 */ 209, 103, 219, 219, 215, 215, 150, 127, 86, 119,
/* 730 */ 128, 87, 101, 86, 101, 87, 209, 209, 101, 222,
/* 740 */ 209, 228, 223, 227, 226, 225, 224, 221, 210, 216,
/* 750 */ 210, 256, 246, 210, 209, 230, 210, 125, 264, 268,
/* 760 */ 267, 271, 270, 263, 266, 209, 211, 209, 125, 246,
/* 770 */ 5, 5, 86, 101, 87, 86, 1, 87, 86, 101,
/* 780 */ 87, 86, 47, 87, 86, 86, 1, 90, 139, 101,
/* 790 */ 139, 86, 86, 119, 91, 120, 86, 82, 74, 5,
/* 800 */ 9, 90, 5, 5, 5, 91, 90, 5, 5, 5,
/* 810 */ 5, 89, 16, 82, 86, 9, 9, 87, 9, 87,
/* 820 */ 9, 28, 86, 123, 63, 17, 155, 101, 155, 17,
/* 830 */ 5, 155, 125, 5, 155, 87, 5, 5, 5, 5,
/* 840 */ 5, 5, 125, 5, 5, 5, 5, 5, 5, 5,
/* 850 */ 5, 5, 101, 89, 64, 0, 9, 9, 291, 22,
/* 860 */ 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
/* 870 */ 291, 22, 291, 291, 291, 291, 291, 291, 291, 291,
/* 880 */ 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
/* 890 */ 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
/* 900 */ 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
/* 910 */ 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
/* 920 */ 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
/* 930 */ 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
/* 940 */ 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
/* 950 */ 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
/* 960 */ 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
/* 970 */ 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
/* 980 */ 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
/* 990 */ 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
/* 1000 */ 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
/* 1010 */ 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
/* 1020 */ 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
/* 1030 */ 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
/* 1040 */ 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
/* 1050 */ 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
/* 1060 */ 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
/* 1070 */ 291, 291, 291, 291, 291, 291, 291,
/* 0 */ 279, 1, 208, 208, 206, 207, 279, 5, 208, 9,
/* 10 */ 289, 1, 291, 254, 14, 15, 289, 17, 18, 9,
/* 20 */ 261, 21, 22, 23, 24, 208, 209, 27, 28, 29,
/* 30 */ 30, 31, 32, 33, 216, 1, 279, 37, 38, 37,
/* 40 */ 38, 41, 42, 43, 14, 15, 289, 17, 18, 255,
/* 50 */ 266, 21, 22, 23, 24, 284, 258, 27, 28, 29,
/* 60 */ 30, 31, 32, 33, 41, 42, 43, 37, 38, 285,
/* 70 */ 252, 41, 42, 43, 276, 1, 281, 282, 14, 15,
/* 80 */ 280, 17, 18, 9, 5, 21, 22, 23, 24, 208,
/* 90 */ 90, 27, 28, 29, 30, 31, 32, 33, 69, 70,
/* 100 */ 71, 37, 38, 279, 279, 41, 42, 43, 14, 15,
/* 110 */ 86, 17, 18, 289, 289, 21, 22, 23, 24, 87,
/* 120 */ 90, 27, 28, 29, 30, 31, 32, 33, 66, 67,
/* 130 */ 68, 37, 38, 101, 253, 41, 42, 43, 88, 14,
/* 140 */ 15, 260, 17, 18, 120, 121, 21, 22, 23, 24,
/* 150 */ 208, 87, 27, 28, 29, 30, 31, 32, 33, 94,
/* 160 */ 86, 219, 37, 38, 279, 1, 41, 42, 43, 15,
/* 170 */ 279, 17, 18, 9, 289, 21, 22, 23, 24, 279,
/* 180 */ 289, 27, 28, 29, 30, 31, 32, 33, 208, 289,
/* 190 */ 86, 37, 38, 132, 133, 41, 42, 43, 102, 103,
/* 200 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
/* 210 */ 114, 115, 116, 49, 50, 51, 52, 53, 54, 55,
/* 220 */ 56, 57, 58, 59, 60, 61, 62, 63, 208, 65,
/* 230 */ 126, 17, 18, 253, 261, 21, 22, 23, 24, 150,
/* 240 */ 260, 27, 28, 29, 30, 31, 32, 33, 159, 160,
/* 250 */ 101, 37, 38, 208, 261, 41, 42, 43, 48, 47,
/* 260 */ 232, 233, 234, 235, 236, 237, 238, 239, 240, 241,
/* 270 */ 242, 243, 244, 245, 246, 65, 64, 1, 2, 130,
/* 280 */ 260, 5, 72, 7, 287, 9, 289, 290, 78, 79,
/* 290 */ 80, 81, 279, 1, 2, 85, 86, 5, 253, 7,
/* 300 */ 284, 9, 289, 16, 287, 260, 289, 29, 30, 31,
/* 310 */ 32, 33, 279, 37, 38, 37, 38, 41, 279, 41,
/* 320 */ 42, 43, 289, 248, 66, 67, 68, 279, 289, 37,
/* 330 */ 38, 73, 74, 75, 76, 77, 126, 289, 2, 286,
/* 340 */ 287, 5, 289, 7, 33, 9, 261, 5, 37, 38,
/* 350 */ 92, 9, 41, 42, 43, 0, 66, 67, 68, 149,
/* 360 */ 208, 151, 86, 73, 74, 75, 76, 77, 158, 72,
/* 370 */ 215, 215, 162, 37, 38, 66, 67, 68, 86, 37,
/* 380 */ 38, 5, 73, 7, 75, 76, 77, 72, 215, 5,
/* 390 */ 287, 7, 289, 84, 279, 232, 248, 234, 235, 123,
/* 400 */ 124, 125, 239, 216, 289, 253, 243, 254, 245, 246,
/* 410 */ 123, 208, 260, 248, 261, 123, 124, 125, 102, 25,
/* 420 */ 104, 105, 37, 38, 148, 109, 41, 42, 43, 113,
/* 430 */ 208, 115, 116, 208, 279, 279, 249, 250, 251, 252,
/* 440 */ 148, 47, 208, 88, 289, 289, 291, 291, 256, 152,
/* 450 */ 208, 154, 279, 156, 157, 208, 253, 208, 64, 123,
/* 460 */ 124, 208, 289, 260, 291, 41, 124, 152, 219, 154,
/* 470 */ 254, 156, 157, 208, 208, 253, 279, 261, 253, 279,
/* 480 */ 86, 279, 260, 279, 219, 260, 289, 253, 279, 289,
/* 490 */ 216, 289, 208, 289, 260, 253, 80, 214, 289, 87,
/* 500 */ 253, 125, 260, 219, 221, 279, 253, 260, 82, 125,
/* 510 */ 262, 279, 279, 260, 258, 289, 279, 279, 279, 258,
/* 520 */ 94, 289, 289, 87, 250, 277, 289, 289, 289, 230,
/* 530 */ 231, 214, 276, 214, 87, 217, 218, 276, 221, 127,
/* 540 */ 221, 212, 213, 37, 38, 87, 87, 101, 101, 1,
/* 550 */ 87, 101, 87, 129, 87, 87, 140, 87, 86, 101,
/* 560 */ 101, 87, 25, 127, 101, 87, 101, 87, 101, 101,
/* 570 */ 153, 101, 155, 86, 153, 101, 155, 208, 153, 101,
/* 580 */ 155, 101, 37, 38, 47, 5, 5, 7, 7, 41,
/* 590 */ 208, 119, 146, 153, 144, 155, 153, 153, 155, 155,
/* 600 */ 82, 83, 248, 208, 248, 118, 248, 248, 208, 208,
/* 610 */ 278, 208, 208, 208, 208, 258, 208, 208, 258, 208,
/* 620 */ 258, 288, 288, 288, 263, 288, 208, 208, 208, 264,
/* 630 */ 208, 208, 64, 125, 88, 208, 208, 208, 208, 208,
/* 640 */ 208, 208, 208, 208, 147, 208, 208, 208, 275, 208,
/* 650 */ 208, 283, 143, 208, 283, 283, 208, 208, 283, 208,
/* 660 */ 208, 208, 208, 208, 208, 208, 145, 274, 208, 208,
/* 670 */ 208, 138, 208, 142, 208, 273, 141, 208, 271, 208,
/* 680 */ 136, 208, 272, 208, 208, 208, 135, 208, 134, 208,
/* 690 */ 208, 208, 208, 208, 208, 137, 208, 208, 208, 208,
/* 700 */ 208, 208, 208, 208, 208, 131, 122, 93, 210, 117,
/* 710 */ 211, 210, 210, 210, 210, 210, 100, 99, 55, 96,
/* 720 */ 98, 59, 97, 210, 95, 130, 210, 210, 5, 5,
/* 730 */ 161, 5, 161, 210, 210, 5, 5, 104, 103, 220,
/* 740 */ 220, 216, 216, 150, 127, 119, 86, 128, 87, 101,
/* 750 */ 210, 86, 210, 223, 211, 227, 229, 228, 226, 225,
/* 760 */ 224, 222, 87, 211, 211, 210, 210, 217, 211, 247,
/* 770 */ 270, 257, 231, 210, 210, 264, 269, 212, 268, 267,
/* 780 */ 265, 101, 101, 125, 125, 247, 5, 5, 86, 101,
/* 790 */ 87, 86, 1, 87, 86, 101, 87, 86, 47, 87,
/* 800 */ 86, 86, 1, 139, 86, 101, 139, 90, 86, 119,
/* 810 */ 82, 86, 120, 74, 5, 9, 5, 5, 91, 90,
/* 820 */ 5, 5, 5, 91, 90, 5, 5, 89, 82, 16,
/* 830 */ 86, 9, 9, 9, 87, 87, 9, 63, 86, 123,
/* 840 */ 155, 155, 28, 17, 101, 125, 125, 17, 155, 5,
/* 850 */ 155, 5, 87, 5, 5, 5, 5, 5, 5, 5,
/* 860 */ 5, 5, 5, 5, 5, 5, 5, 5, 101, 89,
/* 870 */ 0, 64, 9, 292, 9, 292, 292, 292, 292, 292,
/* 880 */ 292, 292, 292, 292, 292, 292, 22, 292, 22, 292,
/* 890 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292,
/* 900 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292,
/* 910 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292,
/* 920 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292,
/* 930 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292,
/* 940 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292,
/* 950 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292,
/* 960 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292,
/* 970 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292,
/* 980 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292,
/* 990 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292,
/* 1000 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292,
/* 1010 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292,
/* 1020 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292,
/* 1030 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292,
/* 1040 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292,
/* 1050 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292,
/* 1060 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292,
/* 1070 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292,
/* 1080 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292,
/* 1090 */ 292, 292, 292, 292,
};
#define YY_SHIFT_COUNT (402)
#define YY_SHIFT_COUNT (404)
#define YY_SHIFT_MIN (0)
#define YY_SHIFT_MAX (855)
#define YY_SHIFT_MAX (870)
static const unsigned short int yy_shift_ofst[] = {
/* 0 */ 249, 163, 163, 272, 272, 21, 315, 294, 294, 294,
/* 10 */ 7, 228, 228, 228, 228, 228, 228, 228, 228, 228,
/* 20 */ 228, 228, 45, 45, 0, 142, 294, 294, 294, 294,
/* 30 */ 294, 294, 294, 294, 294, 294, 294, 294, 294, 294,
/* 40 */ 294, 294, 294, 294, 294, 294, 294, 294, 302, 302,
/* 50 */ 302, 216, 216, 329, 228, 298, 228, 228, 228, 228,
/* 60 */ 228, 224, 21, 45, 45, 118, 118, 6, 872, 872,
/* 70 */ 872, 302, 302, 302, 345, 345, 70, 70, 70, 70,
/* 80 */ 70, 70, 62, 70, 228, 228, 228, 228, 228, 228,
/* 90 */ 389, 228, 228, 228, 216, 216, 228, 228, 228, 228,
/* 100 */ 399, 399, 399, 399, 54, 216, 228, 228, 228, 228,
/* 110 */ 228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
/* 120 */ 228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
/* 130 */ 228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
/* 140 */ 228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
/* 150 */ 228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
/* 160 */ 228, 228, 481, 548, 530, 548, 548, 548, 548, 497,
/* 170 */ 497, 497, 497, 548, 484, 505, 514, 512, 515, 521,
/* 180 */ 539, 547, 549, 557, 481, 567, 548, 548, 548, 597,
/* 190 */ 597, 575, 21, 21, 548, 548, 599, 601, 646, 606,
/* 200 */ 605, 645, 609, 612, 575, 6, 548, 548, 530, 530,
/* 210 */ 548, 530, 548, 530, 548, 548, 872, 872, 30, 74,
/* 220 */ 104, 104, 104, 135, 193, 221, 270, 328, 328, 328,
/* 230 */ 328, 328, 328, 10, 113, 353, 353, 353, 353, 289,
/* 240 */ 295, 368, 68, 96, 96, 392, 397, 100, 405, 154,
/* 250 */ 415, 420, 474, 262, 427, 434, 479, 398, 424, 440,
/* 260 */ 444, 445, 447, 449, 443, 450, 451, 508, 529, 524,
/* 270 */ 462, 401, 404, 411, 553, 560, 534, 421, 422, 467,
/* 280 */ 425, 499, 578, 704, 551, 708, 709, 554, 712, 713,
/* 290 */ 615, 618, 576, 600, 610, 642, 602, 644, 647, 631,
/* 300 */ 633, 648, 637, 632, 643, 765, 766, 686, 687, 689,
/* 310 */ 690, 692, 693, 672, 695, 696, 698, 775, 699, 678,
/* 320 */ 649, 735, 785, 688, 651, 697, 705, 610, 706, 674,
/* 330 */ 710, 675, 715, 703, 711, 724, 794, 714, 716, 791,
/* 340 */ 797, 798, 799, 802, 803, 804, 805, 722, 796, 731,
/* 350 */ 806, 807, 728, 730, 732, 809, 811, 700, 736, 793,
/* 360 */ 761, 808, 671, 673, 726, 726, 726, 726, 707, 717,
/* 370 */ 812, 676, 679, 726, 726, 726, 825, 828, 748, 726,
/* 380 */ 831, 832, 833, 834, 835, 836, 838, 839, 840, 841,
/* 390 */ 842, 843, 844, 845, 846, 751, 764, 847, 837, 848,
/* 400 */ 849, 790, 855,
/* 0 */ 210, 96, 96, 316, 316, 50, 276, 292, 292, 292,
/* 10 */ 74, 10, 10, 10, 10, 10, 10, 10, 10, 10,
/* 20 */ 10, 10, 34, 34, 0, 164, 292, 292, 292, 292,
/* 30 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292,
/* 40 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 336,
/* 50 */ 336, 336, 104, 104, 61, 10, 355, 10, 10, 10,
/* 60 */ 10, 10, 426, 50, 34, 34, 65, 65, 79, 889,
/* 70 */ 889, 889, 336, 336, 336, 342, 342, 2, 2, 2,
/* 80 */ 2, 2, 2, 24, 2, 10, 10, 10, 10, 10,
/* 90 */ 10, 424, 10, 10, 10, 104, 104, 10, 10, 10,
/* 100 */ 10, 416, 416, 416, 416, 149, 104, 10, 10, 10,
/* 110 */ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
/* 120 */ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
/* 130 */ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
/* 140 */ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
/* 150 */ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
/* 160 */ 10, 10, 10, 497, 568, 546, 568, 568, 568, 568,
/* 170 */ 508, 508, 508, 508, 568, 509, 521, 533, 531, 535,
/* 180 */ 544, 551, 554, 558, 574, 497, 584, 568, 568, 568,
/* 190 */ 614, 614, 592, 50, 50, 568, 568, 616, 618, 663,
/* 200 */ 623, 622, 662, 625, 629, 592, 79, 568, 568, 546,
/* 210 */ 546, 568, 546, 568, 546, 568, 568, 889, 889, 30,
/* 220 */ 64, 94, 94, 94, 125, 154, 214, 278, 278, 278,
/* 230 */ 278, 278, 278, 258, 309, 290, 311, 311, 311, 311,
/* 240 */ 385, 297, 315, 394, 89, 23, 23, 376, 384, 29,
/* 250 */ 62, 32, 412, 436, 506, 447, 458, 459, 212, 446,
/* 260 */ 450, 463, 465, 467, 468, 470, 472, 474, 478, 537,
/* 270 */ 548, 287, 480, 417, 421, 425, 580, 581, 545, 440,
/* 280 */ 443, 487, 444, 518, 595, 723, 569, 724, 726, 571,
/* 290 */ 730, 731, 633, 635, 593, 617, 626, 660, 619, 661,
/* 300 */ 665, 648, 680, 675, 681, 658, 659, 781, 782, 702,
/* 310 */ 703, 705, 706, 708, 709, 688, 711, 712, 714, 791,
/* 320 */ 715, 694, 664, 751, 801, 704, 667, 717, 718, 626,
/* 330 */ 722, 690, 725, 692, 728, 727, 729, 739, 809, 732,
/* 340 */ 734, 806, 811, 812, 815, 816, 817, 820, 821, 738,
/* 350 */ 813, 746, 822, 823, 744, 747, 748, 824, 827, 716,
/* 360 */ 752, 814, 774, 826, 685, 686, 743, 743, 743, 743,
/* 370 */ 720, 721, 830, 693, 695, 743, 743, 743, 844, 846,
/* 380 */ 765, 743, 848, 849, 850, 851, 852, 853, 854, 855,
/* 390 */ 856, 857, 858, 859, 860, 861, 862, 767, 780, 863,
/* 400 */ 864, 865, 866, 807, 870,
};
#define YY_REDUCE_COUNT (217)
#define YY_REDUCE_MIN (-276)
#define YY_REDUCE_MAX (558)
#define YY_REDUCE_COUNT (218)
#define YY_REDUCE_MIN (-279)
#define YY_REDUCE_MAX (565)
static const short yy_reduce_ofst[] = {
/* 0 */ -201, 49, 49, 189, 189, -215, -208, 178, 192, -209,
/* 10 */ -181, -84, -33, 2, 53, 157, 177, 196, 198, 201,
/* 20 */ 206, 237, -276, -222, -94, -205, -239, -238, -223, -164,
/* 30 */ -148, -134, -32, -31, 22, 35, 37, 63, 90, 101,
/* 40 */ 136, 186, 197, 199, 200, 203, 205, 212, -47, -20,
/* 50 */ 66, -250, 98, -155, 230, 244, 279, 285, 287, 291,
/* 60 */ 260, 208, 261, 124, 218, 288, 300, -210, 72, 299,
/* 70 */ 312, -176, -100, -28, 25, 89, 188, 314, 322, 326,
/* 80 */ 332, 336, 331, 337, 380, 381, 382, 383, 384, 385,
/* 90 */ 316, 387, 388, 390, 339, 341, 393, 394, 395, 396,
/* 100 */ 317, 318, 319, 320, 346, 342, 402, 403, 406, 407,
/* 110 */ 408, 409, 410, 412, 413, 414, 416, 417, 418, 419,
/* 120 */ 423, 426, 428, 429, 430, 431, 432, 433, 435, 436,
/* 130 */ 437, 438, 439, 441, 442, 446, 448, 452, 453, 454,
/* 140 */ 455, 456, 457, 458, 459, 460, 461, 463, 464, 465,
/* 150 */ 466, 468, 469, 470, 471, 472, 473, 475, 476, 477,
/* 160 */ 478, 480, 348, 482, 483, 485, 486, 487, 488, 347,
/* 170 */ 349, 350, 352, 489, 367, 378, 386, 490, 492, 400,
/* 180 */ 491, 493, 498, 494, 500, 495, 496, 501, 502, 503,
/* 190 */ 504, 506, 509, 510, 507, 511, 513, 516, 518, 517,
/* 200 */ 520, 519, 522, 526, 523, 525, 527, 528, 538, 540,
/* 210 */ 531, 543, 545, 546, 556, 558, 533, 555,
/* 0 */ -202, 28, 28, 163, 163, 187, 155, 156, 173, -279,
/* 10 */ -205, -119, -20, 45, 152, 203, 222, 225, 234, 242,
/* 20 */ 247, 253, -3, 53, -200, -183, -273, -243, -176, -175,
/* 30 */ -115, -109, -100, 13, 33, 39, 48, 115, 197, 200,
/* 40 */ 202, 204, 209, 226, 232, 233, 237, 238, 239, -241,
/* 50 */ 153, 216, 256, 261, -216, -206, -182, -58, 249, 265,
/* 60 */ 284, 20, 283, 274, 17, 103, 317, 319, 299, 248,
/* 70 */ 318, 329, -27, -7, 85, -229, 16, 75, 148, 165,
/* 80 */ 354, 356, 358, 192, 359, 266, 369, 382, 395, 400,
/* 90 */ 401, 332, 403, 404, 405, 357, 360, 406, 408, 409,
/* 100 */ 411, 333, 334, 335, 337, 361, 362, 418, 419, 420,
/* 110 */ 422, 423, 427, 428, 429, 430, 431, 432, 433, 434,
/* 120 */ 435, 437, 438, 439, 441, 442, 445, 448, 449, 451,
/* 130 */ 452, 453, 454, 455, 456, 457, 460, 461, 462, 464,
/* 140 */ 466, 469, 471, 473, 475, 476, 477, 479, 481, 482,
/* 150 */ 483, 484, 485, 486, 488, 489, 490, 491, 492, 493,
/* 160 */ 494, 495, 496, 365, 498, 499, 501, 502, 503, 504,
/* 170 */ 368, 371, 372, 375, 505, 373, 393, 402, 410, 407,
/* 180 */ 500, 507, 510, 512, 515, 511, 514, 513, 516, 517,
/* 190 */ 519, 520, 522, 525, 526, 523, 524, 527, 529, 528,
/* 200 */ 530, 532, 536, 534, 539, 538, 541, 540, 542, 543,
/* 210 */ 552, 555, 553, 556, 557, 563, 564, 550, 565,
};
static const YYACTIONTYPE yy_default[] = {
/* 0 */ 952, 1075, 1014, 1085, 1001, 1011, 1253, 1253, 1253, 1253,
/* 10 */ 952, 952, 952, 952, 952, 952, 952, 952, 952, 952,
/* 20 */ 952, 952, 952, 952, 1139, 972, 952, 952, 952, 952,
/* 30 */ 952, 952, 952, 952, 952, 952, 952, 952, 952, 952,
/* 40 */ 952, 952, 952, 952, 952, 952, 952, 952, 952, 952,
/* 50 */ 952, 952, 952, 1163, 952, 1011, 952, 952, 952, 952,
/* 60 */ 952, 1021, 1011, 952, 952, 1021, 1021, 952, 1134, 1059,
/* 70 */ 1077, 952, 952, 952, 952, 952, 952, 952, 952, 952,
/* 80 */ 952, 952, 1106, 952, 952, 952, 952, 952, 952, 952,
/* 90 */ 1141, 1147, 1144, 952, 952, 952, 1149, 952, 952, 952,
/* 100 */ 1185, 1185, 1185, 1185, 1132, 952, 952, 952, 952, 952,
/* 110 */ 952, 952, 952, 952, 952, 952, 952, 952, 952, 952,
/* 120 */ 952, 952, 952, 952, 952, 952, 952, 952, 952, 952,
/* 130 */ 952, 952, 952, 952, 952, 952, 952, 952, 999, 952,
/* 140 */ 997, 952, 952, 952, 952, 952, 952, 952, 952, 952,
/* 150 */ 952, 952, 952, 952, 952, 952, 952, 952, 952, 952,
/* 160 */ 952, 970, 1202, 974, 1009, 974, 974, 974, 974, 952,
/* 170 */ 952, 952, 952, 974, 1194, 1198, 1175, 1192, 1186, 1170,
/* 180 */ 1168, 1166, 1174, 1159, 1202, 1108, 974, 974, 974, 1019,
/* 190 */ 1019, 1015, 1011, 1011, 974, 974, 1037, 1035, 1033, 1025,
/* 200 */ 1031, 1027, 1029, 1023, 1002, 952, 974, 974, 1009, 1009,
/* 210 */ 974, 1009, 974, 1009, 974, 974, 1059, 1077, 1252, 952,
/* 220 */ 1203, 1193, 1252, 952, 1235, 1234, 952, 1243, 1242, 1241,
/* 230 */ 1233, 1232, 1231, 952, 952, 1227, 1230, 1229, 1228, 952,
/* 240 */ 952, 1205, 952, 1237, 1236, 952, 952, 952, 952, 952,
/* 250 */ 952, 952, 1156, 952, 952, 952, 1181, 1199, 1195, 952,
/* 260 */ 952, 952, 952, 952, 952, 952, 952, 1206, 952, 952,
/* 270 */ 952, 952, 952, 952, 952, 952, 1120, 952, 952, 1087,
/* 280 */ 952, 952, 952, 952, 952, 952, 952, 952, 952, 952,
/* 290 */ 952, 952, 952, 1131, 952, 952, 952, 952, 952, 1143,
/* 300 */ 1142, 952, 952, 952, 952, 952, 952, 952, 952, 952,
/* 310 */ 952, 952, 952, 952, 952, 952, 952, 952, 952, 1187,
/* 320 */ 952, 1182, 952, 1176, 952, 952, 952, 1099, 952, 952,
/* 330 */ 952, 952, 952, 952, 952, 952, 952, 952, 952, 952,
/* 340 */ 952, 952, 952, 952, 952, 952, 952, 952, 952, 952,
/* 350 */ 952, 952, 952, 952, 952, 952, 952, 952, 952, 952,
/* 360 */ 952, 952, 952, 952, 1271, 1266, 1267, 1264, 952, 952,
/* 370 */ 952, 952, 952, 1263, 1258, 1259, 952, 952, 952, 1256,
/* 380 */ 952, 952, 952, 952, 952, 952, 952, 952, 952, 952,
/* 390 */ 952, 952, 952, 952, 952, 1043, 952, 952, 981, 952,
/* 400 */ 979, 952, 952,
/* 0 */ 955, 1078, 1017, 1088, 1004, 1014, 1257, 1257, 1257, 1257,
/* 10 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 955,
/* 20 */ 955, 955, 955, 955, 1142, 975, 955, 955, 955, 955,
/* 30 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 955,
/* 40 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 955,
/* 50 */ 955, 955, 955, 955, 1166, 955, 1014, 955, 955, 955,
/* 60 */ 955, 955, 1024, 1014, 955, 955, 1024, 1024, 955, 1137,
/* 70 */ 1062, 1080, 955, 955, 955, 955, 955, 955, 955, 955,
/* 80 */ 955, 955, 955, 1109, 955, 955, 955, 955, 955, 955,
/* 90 */ 955, 1144, 1150, 1147, 955, 955, 955, 1152, 955, 955,
/* 100 */ 955, 1188, 1188, 1188, 1188, 1135, 955, 955, 955, 955,
/* 110 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 955,
/* 120 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 955,
/* 130 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 1002,
/* 140 */ 955, 1000, 955, 955, 955, 955, 955, 955, 955, 955,
/* 150 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 955,
/* 160 */ 955, 955, 973, 1205, 977, 1012, 977, 977, 977, 977,
/* 170 */ 955, 955, 955, 955, 977, 1197, 1201, 1178, 1195, 1189,
/* 180 */ 1173, 1171, 1169, 1177, 1162, 1205, 1111, 977, 977, 977,
/* 190 */ 1022, 1022, 1018, 1014, 1014, 977, 977, 1040, 1038, 1036,
/* 200 */ 1028, 1034, 1030, 1032, 1026, 1005, 955, 977, 977, 1012,
/* 210 */ 1012, 977, 1012, 977, 1012, 977, 977, 1062, 1080, 1256,
/* 220 */ 955, 1206, 1196, 1256, 955, 1238, 1237, 1247, 1246, 1245,
/* 230 */ 1236, 1235, 1234, 955, 955, 955, 1230, 1233, 1232, 1231,
/* 240 */ 1244, 955, 955, 1208, 955, 1240, 1239, 955, 955, 955,
/* 250 */ 955, 955, 955, 955, 1159, 955, 955, 955, 1184, 1202,
/* 260 */ 1198, 955, 955, 955, 955, 955, 955, 955, 955, 1209,
/* 270 */ 955, 955, 955, 955, 955, 955, 955, 955, 1123, 955,
/* 280 */ 955, 1090, 955, 955, 955, 955, 955, 955, 955, 955,
/* 290 */ 955, 955, 955, 955, 955, 1134, 955, 955, 955, 955,
/* 300 */ 955, 1146, 1145, 955, 955, 955, 955, 955, 955, 955,
/* 310 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 955,
/* 320 */ 955, 1190, 955, 1185, 955, 1179, 955, 955, 955, 1102,
/* 330 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 955,
/* 340 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 955,
/* 350 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 955,
/* 360 */ 955, 955, 955, 955, 955, 955, 1275, 1270, 1271, 1268,
/* 370 */ 955, 955, 955, 955, 955, 1267, 1262, 1263, 955, 955,
/* 380 */ 955, 1260, 955, 955, 955, 955, 955, 955, 955, 955,
/* 390 */ 955, 955, 955, 955, 955, 955, 955, 1046, 955, 955,
/* 400 */ 984, 955, 982, 955, 955,
};
/********** End of lemon-generated parsing tables *****************************/
......@@ -795,7 +788,6 @@ struct yyParser {
int yyerrcnt; /* Shifts left before out of the error */
#endif
ParseARG_SDECL /* A place to hold %extra_argument */
ParseCTX_SDECL /* A place to hold %extra_context */
#if YYSTACKDEPTH<=0
int yystksz; /* Current side of the stack */
yyStackEntry *yystack; /* The parser's stack */
......@@ -1048,92 +1040,93 @@ static const char *const yyTokenName[] = {
/* 202 */ "INTO",
/* 203 */ "VALUES",
/* 204 */ "FILE",
/* 205 */ "program",
/* 206 */ "cmd",
/* 207 */ "ids",
/* 208 */ "dbPrefix",
/* 209 */ "cpxName",
/* 210 */ "ifexists",
/* 211 */ "alter_db_optr",
/* 212 */ "alter_topic_optr",
/* 213 */ "acct_optr",
/* 214 */ "exprlist",
/* 215 */ "ifnotexists",
/* 216 */ "db_optr",
/* 217 */ "topic_optr",
/* 218 */ "typename",
/* 219 */ "bufsize",
/* 220 */ "pps",
/* 221 */ "tseries",
/* 222 */ "dbs",
/* 223 */ "streams",
/* 224 */ "storage",
/* 225 */ "qtime",
/* 226 */ "users",
/* 227 */ "conns",
/* 228 */ "state",
/* 229 */ "intitemlist",
/* 230 */ "intitem",
/* 231 */ "keep",
/* 232 */ "cache",
/* 233 */ "replica",
/* 234 */ "quorum",
/* 235 */ "days",
/* 236 */ "minrows",
/* 237 */ "maxrows",
/* 238 */ "blocks",
/* 239 */ "ctime",
/* 240 */ "wal",
/* 241 */ "fsync",
/* 242 */ "comp",
/* 243 */ "prec",
/* 244 */ "update",
/* 245 */ "cachelast",
/* 246 */ "partitions",
/* 247 */ "signed",
/* 248 */ "create_table_args",
/* 249 */ "create_stable_args",
/* 250 */ "create_table_list",
/* 251 */ "create_from_stable",
/* 252 */ "columnlist",
/* 253 */ "tagitemlist",
/* 254 */ "tagNamelist",
/* 255 */ "to_opt",
/* 256 */ "split_opt",
/* 257 */ "select",
/* 258 */ "to_split",
/* 259 */ "column",
/* 260 */ "tagitem",
/* 261 */ "selcollist",
/* 262 */ "from",
/* 263 */ "where_opt",
/* 264 */ "range_option",
/* 265 */ "interval_option",
/* 266 */ "sliding_opt",
/* 267 */ "session_option",
/* 268 */ "windowstate_option",
/* 269 */ "fill_opt",
/* 270 */ "groupby_opt",
/* 271 */ "having_opt",
/* 272 */ "orderby_opt",
/* 273 */ "slimit_opt",
/* 274 */ "limit_opt",
/* 275 */ "union",
/* 276 */ "sclp",
/* 277 */ "distinct",
/* 278 */ "expr",
/* 279 */ "as",
/* 280 */ "tablelist",
/* 281 */ "sub",
/* 282 */ "tmvar",
/* 283 */ "timestamp",
/* 284 */ "intervalKey",
/* 285 */ "sortlist",
/* 286 */ "item",
/* 287 */ "sortorder",
/* 288 */ "arrow",
/* 289 */ "grouplist",
/* 290 */ "expritem",
/* 205 */ "error",
/* 206 */ "program",
/* 207 */ "cmd",
/* 208 */ "ids",
/* 209 */ "dbPrefix",
/* 210 */ "cpxName",
/* 211 */ "ifexists",
/* 212 */ "alter_db_optr",
/* 213 */ "alter_topic_optr",
/* 214 */ "acct_optr",
/* 215 */ "exprlist",
/* 216 */ "ifnotexists",
/* 217 */ "db_optr",
/* 218 */ "topic_optr",
/* 219 */ "typename",
/* 220 */ "bufsize",
/* 221 */ "pps",
/* 222 */ "tseries",
/* 223 */ "dbs",
/* 224 */ "streams",
/* 225 */ "storage",
/* 226 */ "qtime",
/* 227 */ "users",
/* 228 */ "conns",
/* 229 */ "state",
/* 230 */ "intitemlist",
/* 231 */ "intitem",
/* 232 */ "keep",
/* 233 */ "cache",
/* 234 */ "replica",
/* 235 */ "quorum",
/* 236 */ "days",
/* 237 */ "minrows",
/* 238 */ "maxrows",
/* 239 */ "blocks",
/* 240 */ "ctime",
/* 241 */ "wal",
/* 242 */ "fsync",
/* 243 */ "comp",
/* 244 */ "prec",
/* 245 */ "update",
/* 246 */ "cachelast",
/* 247 */ "partitions",
/* 248 */ "signed",
/* 249 */ "create_table_args",
/* 250 */ "create_stable_args",
/* 251 */ "create_table_list",
/* 252 */ "create_from_stable",
/* 253 */ "columnlist",
/* 254 */ "tagitemlist",
/* 255 */ "tagNamelist",
/* 256 */ "to_opt",
/* 257 */ "split_opt",
/* 258 */ "select",
/* 259 */ "to_split",
/* 260 */ "column",
/* 261 */ "tagitem",
/* 262 */ "selcollist",
/* 263 */ "from",
/* 264 */ "where_opt",
/* 265 */ "range_option",
/* 266 */ "interval_option",
/* 267 */ "sliding_opt",
/* 268 */ "session_option",
/* 269 */ "windowstate_option",
/* 270 */ "fill_opt",
/* 271 */ "groupby_opt",
/* 272 */ "having_opt",
/* 273 */ "orderby_opt",
/* 274 */ "slimit_opt",
/* 275 */ "limit_opt",
/* 276 */ "union",
/* 277 */ "sclp",
/* 278 */ "distinct",
/* 279 */ "expr",
/* 280 */ "as",
/* 281 */ "tablelist",
/* 282 */ "sub",
/* 283 */ "tmvar",
/* 284 */ "timestamp",
/* 285 */ "intervalKey",
/* 286 */ "sortlist",
/* 287 */ "item",
/* 288 */ "sortorder",
/* 289 */ "arrow",
/* 290 */ "grouplist",
/* 291 */ "expritem",
};
#endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
......@@ -1427,41 +1420,42 @@ static const char *const yyRuleName[] = {
/* 283 */ "expr ::= expr STAR expr",
/* 284 */ "expr ::= expr SLASH expr",
/* 285 */ "expr ::= expr REM expr",
/* 286 */ "expr ::= expr LIKE expr",
/* 287 */ "expr ::= expr MATCH expr",
/* 288 */ "expr ::= expr NMATCH expr",
/* 289 */ "expr ::= ID CONTAINS STRING",
/* 290 */ "expr ::= ID DOT ID CONTAINS STRING",
/* 291 */ "arrow ::= ID ARROW STRING",
/* 292 */ "arrow ::= ID DOT ID ARROW STRING",
/* 293 */ "expr ::= arrow",
/* 294 */ "expr ::= expr IN LP exprlist RP",
/* 295 */ "exprlist ::= exprlist COMMA expritem",
/* 296 */ "exprlist ::= expritem",
/* 297 */ "expritem ::= expr",
/* 298 */ "expritem ::=",
/* 299 */ "cmd ::= RESET QUERY CACHE",
/* 300 */ "cmd ::= SYNCDB ids REPLICA",
/* 301 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
/* 302 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
/* 303 */ "cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist",
/* 304 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
/* 305 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
/* 306 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
/* 307 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
/* 308 */ "cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist",
/* 309 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist",
/* 310 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids",
/* 311 */ "cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist",
/* 312 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist",
/* 313 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids",
/* 314 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids",
/* 315 */ "cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem",
/* 316 */ "cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist",
/* 317 */ "cmd ::= KILL CONNECTION INTEGER",
/* 318 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
/* 319 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
/* 320 */ "cmd ::= DELETE FROM ifexists ids cpxName where_opt",
/* 286 */ "expr ::= expr BITAND expr",
/* 287 */ "expr ::= expr LIKE expr",
/* 288 */ "expr ::= expr MATCH expr",
/* 289 */ "expr ::= expr NMATCH expr",
/* 290 */ "expr ::= ID CONTAINS STRING",
/* 291 */ "expr ::= ID DOT ID CONTAINS STRING",
/* 292 */ "arrow ::= ID ARROW STRING",
/* 293 */ "arrow ::= ID DOT ID ARROW STRING",
/* 294 */ "expr ::= arrow",
/* 295 */ "expr ::= expr IN LP exprlist RP",
/* 296 */ "exprlist ::= exprlist COMMA expritem",
/* 297 */ "exprlist ::= expritem",
/* 298 */ "expritem ::= expr",
/* 299 */ "expritem ::=",
/* 300 */ "cmd ::= RESET QUERY CACHE",
/* 301 */ "cmd ::= SYNCDB ids REPLICA",
/* 302 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
/* 303 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
/* 304 */ "cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist",
/* 305 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
/* 306 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
/* 307 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
/* 308 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
/* 309 */ "cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist",
/* 310 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist",
/* 311 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids",
/* 312 */ "cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist",
/* 313 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist",
/* 314 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids",
/* 315 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids",
/* 316 */ "cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem",
/* 317 */ "cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist",
/* 318 */ "cmd ::= KILL CONNECTION INTEGER",
/* 319 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
/* 320 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
/* 321 */ "cmd ::= DELETE FROM ifexists ids cpxName where_opt",
};
#endif /* NDEBUG */
......@@ -1510,29 +1504,28 @@ static int yyGrowStack(yyParser *p){
/* Initialize a new parser that has already been allocated.
*/
void ParseInit(void *yypRawParser ParseCTX_PDECL){
yyParser *yypParser = (yyParser*)yypRawParser;
ParseCTX_STORE
void ParseInit(void *yypParser){
yyParser *pParser = (yyParser*)yypParser;
#ifdef YYTRACKMAXSTACKDEPTH
yypParser->yyhwm = 0;
pParser->yyhwm = 0;
#endif
#if YYSTACKDEPTH<=0
yypParser->yytos = NULL;
yypParser->yystack = NULL;
yypParser->yystksz = 0;
if( yyGrowStack(yypParser) ){
yypParser->yystack = &yypParser->yystk0;
yypParser->yystksz = 1;
pParser->yytos = NULL;
pParser->yystack = NULL;
pParser->yystksz = 0;
if( yyGrowStack(pParser) ){
pParser->yystack = &pParser->yystk0;
pParser->yystksz = 1;
}
#endif
#ifndef YYNOERRORRECOVERY
yypParser->yyerrcnt = -1;
pParser->yyerrcnt = -1;
#endif
yypParser->yytos = yypParser->yystack;
yypParser->yystack[0].stateno = 0;
yypParser->yystack[0].major = 0;
pParser->yytos = pParser->yystack;
pParser->yystack[0].stateno = 0;
pParser->yystack[0].major = 0;
#if YYSTACKDEPTH>0
yypParser->yystackEnd = &yypParser->yystack[YYSTACKDEPTH-1];
pParser->yystackEnd = &pParser->yystack[YYSTACKDEPTH-1];
#endif
}
......@@ -1549,14 +1542,11 @@ void ParseInit(void *yypRawParser ParseCTX_PDECL){
** A pointer to a parser. This pointer is used in subsequent calls
** to Parse and ParseFree.
*/
void *ParseAlloc(void *(*mallocProc)(YYMALLOCARGTYPE) ParseCTX_PDECL){
yyParser *yypParser;
yypParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) );
if( yypParser ){
ParseCTX_STORE
ParseInit(yypParser ParseCTX_PARAM);
}
return (void*)yypParser;
void *ParseAlloc(void *(*mallocProc)(YYMALLOCARGTYPE)){
yyParser *pParser;
pParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) );
if( pParser ) ParseInit(pParser);
return pParser;
}
#endif /* Parse_ENGINEALWAYSONSTACK */
......@@ -1573,8 +1563,7 @@ static void yy_destructor(
YYCODETYPE yymajor, /* Type code for object to destroy */
YYMINORTYPE *yypminor /* The object to be destroyed */
){
ParseARG_FETCH
ParseCTX_FETCH
ParseARG_FETCH;
switch( yymajor ){
/* Here is inserted the actions which take place when a
** terminal or non-terminal is destroyed. This can happen
......@@ -1587,57 +1576,57 @@ static void yy_destructor(
** inside the C code.
*/
/********* Begin destructor definitions ***************************************/
case 214: /* exprlist */
case 261: /* selcollist */
case 276: /* sclp */
case 215: /* exprlist */
case 262: /* selcollist */
case 277: /* sclp */
{
tSqlExprListDestroy((yypminor->yy525));
tSqlExprListDestroy((yypminor->yy333));
}
break;
case 229: /* intitemlist */
case 231: /* keep */
case 252: /* columnlist */
case 253: /* tagitemlist */
case 254: /* tagNamelist */
case 269: /* fill_opt */
case 270: /* groupby_opt */
case 272: /* orderby_opt */
case 285: /* sortlist */
case 289: /* grouplist */
case 230: /* intitemlist */
case 232: /* keep */
case 253: /* columnlist */
case 254: /* tagitemlist */
case 255: /* tagNamelist */
case 270: /* fill_opt */
case 271: /* groupby_opt */
case 273: /* orderby_opt */
case 286: /* sortlist */
case 290: /* grouplist */
{
taosArrayDestroy(&(yypminor->yy525));
taosArrayDestroy(&(yypminor->yy333));
}
break;
case 250: /* create_table_list */
case 251: /* create_table_list */
{
destroyCreateTableSql((yypminor->yy572));
destroyCreateTableSql((yypminor->yy78));
}
break;
case 257: /* select */
case 258: /* select */
{
destroySqlNode((yypminor->yy86));
destroySqlNode((yypminor->yy144));
}
break;
case 262: /* from */
case 280: /* tablelist */
case 281: /* sub */
case 263: /* from */
case 281: /* tablelist */
case 282: /* sub */
{
destroyRelationInfo((yypminor->yy328));
destroyRelationInfo((yypminor->yy516));
}
break;
case 263: /* where_opt */
case 271: /* having_opt */
case 278: /* expr */
case 283: /* timestamp */
case 288: /* arrow */
case 290: /* expritem */
case 264: /* where_opt */
case 272: /* having_opt */
case 279: /* expr */
case 284: /* timestamp */
case 289: /* arrow */
case 291: /* expritem */
{
tSqlExprDestroy((yypminor->yy142));
tSqlExprDestroy((yypminor->yy194));
}
break;
case 275: /* union */
case 276: /* union */
{
destroyAllSqlNode((yypminor->yy525));
destroyAllSqlNode((yypminor->yy333));
}
break;
/********* End destructor definitions *****************************************/
......@@ -1749,11 +1738,12 @@ int ParseCoverage(FILE *out){
** Find the appropriate action for a parser given the terminal
** look-ahead token iLookAhead.
*/
static YYACTIONTYPE yy_find_shift_action(
YYCODETYPE iLookAhead, /* The look-ahead token */
YYACTIONTYPE stateno /* Current state number */
static unsigned int yy_find_shift_action(
yyParser *pParser, /* The parser */
YYCODETYPE iLookAhead /* The look-ahead token */
){
int i;
int stateno = pParser->yytos->stateno;
if( stateno>YY_MAX_SHIFT ) return stateno;
assert( stateno <= YY_SHIFT_COUNT );
......@@ -1762,12 +1752,11 @@ static YYACTIONTYPE yy_find_shift_action(
#endif
do{
i = yy_shift_ofst[stateno];
assert( i>=0 );
/* assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD ); */
assert( i>=0 && i+YYNTOKEN<=sizeof(yy_lookahead)/sizeof(yy_lookahead[0]) );
assert( iLookAhead!=YYNOCODE );
assert( iLookAhead < YYNTOKEN );
i += iLookAhead;
if( i>=YY_NLOOKAHEAD || yy_lookahead[i]!=iLookAhead ){
if( yy_lookahead[i]!=iLookAhead ){
#ifdef YYFALLBACK
YYCODETYPE iFallback; /* Fallback token */
if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
......@@ -1793,7 +1782,6 @@ static YYACTIONTYPE yy_find_shift_action(
#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
j<YY_ACTTAB_COUNT &&
#endif
j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) &&
yy_lookahead[j]==YYWILDCARD && iLookAhead>0
){
#ifndef NDEBUG
......@@ -1818,8 +1806,8 @@ static YYACTIONTYPE yy_find_shift_action(
** Find the appropriate action for a parser given the non-terminal
** look-ahead token iLookAhead.
*/
static YYACTIONTYPE yy_find_reduce_action(
YYACTIONTYPE stateno, /* Current state number */
static int yy_find_reduce_action(
int stateno, /* Current state number */
YYCODETYPE iLookAhead /* The look-ahead token */
){
int i;
......@@ -1848,8 +1836,7 @@ static YYACTIONTYPE yy_find_reduce_action(
** The following routine is called if the stack overflows.
*/
static void yyStackOverflow(yyParser *yypParser){
ParseARG_FETCH
ParseCTX_FETCH
ParseARG_FETCH;
#ifndef NDEBUG
if( yyTraceFILE ){
fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
......@@ -1860,8 +1847,7 @@ static void yyStackOverflow(yyParser *yypParser){
** stack every overflows */
/******** Begin %stack_overflow code ******************************************/
/******** End %stack_overflow code ********************************************/
ParseARG_STORE /* Suppress warning about unused %extra_argument var */
ParseCTX_STORE
ParseARG_STORE; /* Suppress warning about unused %extra_argument var */
}
/*
......@@ -1890,8 +1876,8 @@ static void yyTraceShift(yyParser *yypParser, int yyNewState, const char *zTag){
*/
static void yy_shift(
yyParser *yypParser, /* The parser to be shifted */
YYACTIONTYPE yyNewState, /* The new state to shift in */
YYCODETYPE yyMajor, /* The major token to shift in */
int yyNewState, /* The new state to shift in */
int yyMajor, /* The major token to shift in */
ParseTOKENTYPE yyMinor /* The minor token to shift in */
){
yyStackEntry *yytos;
......@@ -1921,8 +1907,8 @@ static void yy_shift(
yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
}
yytos = yypParser->yytos;
yytos->stateno = yyNewState;
yytos->major = yyMajor;
yytos->stateno = (YYACTIONTYPE)yyNewState;
yytos->major = (YYCODETYPE)yyMajor;
yytos->minor.yy0 = yyMinor;
yyTraceShift(yypParser, yyNewState, "Shift");
}
......@@ -1934,327 +1920,328 @@ static const struct {
YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */
signed char nrhs; /* Negative of the number of RHS symbols in the rule */
} yyRuleInfo[] = {
{ 205, -1 }, /* (0) program ::= cmd */
{ 206, -2 }, /* (1) cmd ::= SHOW DATABASES */
{ 206, -2 }, /* (2) cmd ::= SHOW TOPICS */
{ 206, -2 }, /* (3) cmd ::= SHOW FUNCTIONS */
{ 206, -2 }, /* (4) cmd ::= SHOW MNODES */
{ 206, -2 }, /* (5) cmd ::= SHOW DNODES */
{ 206, -2 }, /* (6) cmd ::= SHOW ACCOUNTS */
{ 206, -2 }, /* (7) cmd ::= SHOW USERS */
{ 206, -2 }, /* (8) cmd ::= SHOW MODULES */
{ 206, -2 }, /* (9) cmd ::= SHOW QUERIES */
{ 206, -2 }, /* (10) cmd ::= SHOW CONNECTIONS */
{ 206, -2 }, /* (11) cmd ::= SHOW STREAMS */
{ 206, -2 }, /* (12) cmd ::= SHOW VARIABLES */
{ 206, -2 }, /* (13) cmd ::= SHOW SCORES */
{ 206, -2 }, /* (14) cmd ::= SHOW GRANTS */
{ 206, -2 }, /* (15) cmd ::= SHOW VNODES */
{ 206, -3 }, /* (16) cmd ::= SHOW VNODES ids */
{ 208, 0 }, /* (17) dbPrefix ::= */
{ 208, -2 }, /* (18) dbPrefix ::= ids DOT */
{ 209, 0 }, /* (19) cpxName ::= */
{ 209, -2 }, /* (20) cpxName ::= DOT ids */
{ 206, -5 }, /* (21) cmd ::= SHOW CREATE TABLE ids cpxName */
{ 206, -5 }, /* (22) cmd ::= SHOW CREATE STABLE ids cpxName */
{ 206, -4 }, /* (23) cmd ::= SHOW CREATE DATABASE ids */
{ 206, -3 }, /* (24) cmd ::= SHOW dbPrefix TABLES */
{ 206, -5 }, /* (25) cmd ::= SHOW dbPrefix TABLES LIKE STRING */
{ 206, -3 }, /* (26) cmd ::= SHOW dbPrefix STABLES */
{ 206, -5 }, /* (27) cmd ::= SHOW dbPrefix STABLES LIKE STRING */
{ 206, -3 }, /* (28) cmd ::= SHOW dbPrefix VGROUPS */
{ 206, -5 }, /* (29) cmd ::= DROP TABLE ifexists ids cpxName */
{ 206, -5 }, /* (30) cmd ::= DROP STABLE ifexists ids cpxName */
{ 206, -4 }, /* (31) cmd ::= DROP DATABASE ifexists ids */
{ 206, -4 }, /* (32) cmd ::= DROP TOPIC ifexists ids */
{ 206, -3 }, /* (33) cmd ::= DROP FUNCTION ids */
{ 206, -3 }, /* (34) cmd ::= DROP DNODE ids */
{ 206, -3 }, /* (35) cmd ::= DROP USER ids */
{ 206, -3 }, /* (36) cmd ::= DROP ACCOUNT ids */
{ 206, -2 }, /* (37) cmd ::= USE ids */
{ 206, -3 }, /* (38) cmd ::= DESCRIBE ids cpxName */
{ 206, -3 }, /* (39) cmd ::= DESC ids cpxName */
{ 206, -5 }, /* (40) cmd ::= ALTER USER ids PASS ids */
{ 206, -5 }, /* (41) cmd ::= ALTER USER ids PRIVILEGE ids */
{ 206, -4 }, /* (42) cmd ::= ALTER DNODE ids ids */
{ 206, -5 }, /* (43) cmd ::= ALTER DNODE ids ids ids */
{ 206, -3 }, /* (44) cmd ::= ALTER LOCAL ids */
{ 206, -4 }, /* (45) cmd ::= ALTER LOCAL ids ids */
{ 206, -4 }, /* (46) cmd ::= ALTER DATABASE ids alter_db_optr */
{ 206, -4 }, /* (47) cmd ::= ALTER TOPIC ids alter_topic_optr */
{ 206, -4 }, /* (48) cmd ::= ALTER ACCOUNT ids acct_optr */
{ 206, -6 }, /* (49) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
{ 206, -6 }, /* (50) cmd ::= COMPACT VNODES IN LP exprlist RP */
{ 207, -1 }, /* (51) ids ::= ID */
{ 207, -1 }, /* (52) ids ::= STRING */
{ 210, -2 }, /* (53) ifexists ::= IF EXISTS */
{ 210, 0 }, /* (54) ifexists ::= */
{ 215, -3 }, /* (55) ifnotexists ::= IF NOT EXISTS */
{ 215, 0 }, /* (56) ifnotexists ::= */
{ 206, -3 }, /* (57) cmd ::= CREATE DNODE ids */
{ 206, -6 }, /* (58) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
{ 206, -5 }, /* (59) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
{ 206, -5 }, /* (60) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */
{ 206, -8 }, /* (61) cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
{ 206, -9 }, /* (62) cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
{ 206, -5 }, /* (63) cmd ::= CREATE USER ids PASS ids */
{ 219, 0 }, /* (64) bufsize ::= */
{ 219, -2 }, /* (65) bufsize ::= BUFSIZE INTEGER */
{ 220, 0 }, /* (66) pps ::= */
{ 220, -2 }, /* (67) pps ::= PPS INTEGER */
{ 221, 0 }, /* (68) tseries ::= */
{ 221, -2 }, /* (69) tseries ::= TSERIES INTEGER */
{ 222, 0 }, /* (70) dbs ::= */
{ 222, -2 }, /* (71) dbs ::= DBS INTEGER */
{ 223, 0 }, /* (72) streams ::= */
{ 223, -2 }, /* (73) streams ::= STREAMS INTEGER */
{ 224, 0 }, /* (74) storage ::= */
{ 224, -2 }, /* (75) storage ::= STORAGE INTEGER */
{ 225, 0 }, /* (76) qtime ::= */
{ 225, -2 }, /* (77) qtime ::= QTIME INTEGER */
{ 226, 0 }, /* (78) users ::= */
{ 226, -2 }, /* (79) users ::= USERS INTEGER */
{ 227, 0 }, /* (80) conns ::= */
{ 227, -2 }, /* (81) conns ::= CONNS INTEGER */
{ 228, 0 }, /* (82) state ::= */
{ 228, -2 }, /* (83) state ::= STATE ids */
{ 213, -9 }, /* (84) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
{ 229, -3 }, /* (85) intitemlist ::= intitemlist COMMA intitem */
{ 229, -1 }, /* (86) intitemlist ::= intitem */
{ 230, -1 }, /* (87) intitem ::= INTEGER */
{ 231, -2 }, /* (88) keep ::= KEEP intitemlist */
{ 232, -2 }, /* (89) cache ::= CACHE INTEGER */
{ 233, -2 }, /* (90) replica ::= REPLICA INTEGER */
{ 234, -2 }, /* (91) quorum ::= QUORUM INTEGER */
{ 235, -2 }, /* (92) days ::= DAYS INTEGER */
{ 236, -2 }, /* (93) minrows ::= MINROWS INTEGER */
{ 237, -2 }, /* (94) maxrows ::= MAXROWS INTEGER */
{ 238, -2 }, /* (95) blocks ::= BLOCKS INTEGER */
{ 239, -2 }, /* (96) ctime ::= CTIME INTEGER */
{ 240, -2 }, /* (97) wal ::= WAL INTEGER */
{ 241, -2 }, /* (98) fsync ::= FSYNC INTEGER */
{ 242, -2 }, /* (99) comp ::= COMP INTEGER */
{ 243, -2 }, /* (100) prec ::= PRECISION STRING */
{ 244, -2 }, /* (101) update ::= UPDATE INTEGER */
{ 245, -2 }, /* (102) cachelast ::= CACHELAST INTEGER */
{ 246, -2 }, /* (103) partitions ::= PARTITIONS INTEGER */
{ 216, 0 }, /* (104) db_optr ::= */
{ 216, -2 }, /* (105) db_optr ::= db_optr cache */
{ 216, -2 }, /* (106) db_optr ::= db_optr replica */
{ 216, -2 }, /* (107) db_optr ::= db_optr quorum */
{ 216, -2 }, /* (108) db_optr ::= db_optr days */
{ 216, -2 }, /* (109) db_optr ::= db_optr minrows */
{ 216, -2 }, /* (110) db_optr ::= db_optr maxrows */
{ 216, -2 }, /* (111) db_optr ::= db_optr blocks */
{ 216, -2 }, /* (112) db_optr ::= db_optr ctime */
{ 216, -2 }, /* (113) db_optr ::= db_optr wal */
{ 216, -2 }, /* (114) db_optr ::= db_optr fsync */
{ 216, -2 }, /* (115) db_optr ::= db_optr comp */
{ 216, -2 }, /* (116) db_optr ::= db_optr prec */
{ 216, -2 }, /* (117) db_optr ::= db_optr keep */
{ 216, -2 }, /* (118) db_optr ::= db_optr update */
{ 216, -2 }, /* (119) db_optr ::= db_optr cachelast */
{ 217, -1 }, /* (120) topic_optr ::= db_optr */
{ 217, -2 }, /* (121) topic_optr ::= topic_optr partitions */
{ 211, 0 }, /* (122) alter_db_optr ::= */
{ 211, -2 }, /* (123) alter_db_optr ::= alter_db_optr replica */
{ 211, -2 }, /* (124) alter_db_optr ::= alter_db_optr quorum */
{ 211, -2 }, /* (125) alter_db_optr ::= alter_db_optr keep */
{ 211, -2 }, /* (126) alter_db_optr ::= alter_db_optr blocks */
{ 211, -2 }, /* (127) alter_db_optr ::= alter_db_optr comp */
{ 211, -2 }, /* (128) alter_db_optr ::= alter_db_optr update */
{ 211, -2 }, /* (129) alter_db_optr ::= alter_db_optr cachelast */
{ 212, -1 }, /* (130) alter_topic_optr ::= alter_db_optr */
{ 212, -2 }, /* (131) alter_topic_optr ::= alter_topic_optr partitions */
{ 218, -1 }, /* (132) typename ::= ids */
{ 218, -4 }, /* (133) typename ::= ids LP signed RP */
{ 218, -2 }, /* (134) typename ::= ids UNSIGNED */
{ 247, -1 }, /* (135) signed ::= INTEGER */
{ 247, -2 }, /* (136) signed ::= PLUS INTEGER */
{ 247, -2 }, /* (137) signed ::= MINUS INTEGER */
{ 206, -3 }, /* (138) cmd ::= CREATE TABLE create_table_args */
{ 206, -3 }, /* (139) cmd ::= CREATE TABLE create_stable_args */
{ 206, -3 }, /* (140) cmd ::= CREATE STABLE create_stable_args */
{ 206, -3 }, /* (141) cmd ::= CREATE TABLE create_table_list */
{ 250, -1 }, /* (142) create_table_list ::= create_from_stable */
{ 250, -2 }, /* (143) create_table_list ::= create_table_list create_from_stable */
{ 248, -6 }, /* (144) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
{ 249, -10 }, /* (145) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
{ 251, -10 }, /* (146) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
{ 251, -13 }, /* (147) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
{ 254, -3 }, /* (148) tagNamelist ::= tagNamelist COMMA ids */
{ 254, -1 }, /* (149) tagNamelist ::= ids */
{ 248, -7 }, /* (150) create_table_args ::= ifnotexists ids cpxName to_opt split_opt AS select */
{ 255, 0 }, /* (151) to_opt ::= */
{ 255, -3 }, /* (152) to_opt ::= TO ids cpxName */
{ 256, 0 }, /* (153) split_opt ::= */
{ 256, -2 }, /* (154) split_opt ::= SPLIT ids */
{ 252, -3 }, /* (155) columnlist ::= columnlist COMMA column */
{ 252, -1 }, /* (156) columnlist ::= column */
{ 259, -2 }, /* (157) column ::= ids typename */
{ 253, -3 }, /* (158) tagitemlist ::= tagitemlist COMMA tagitem */
{ 253, -1 }, /* (159) tagitemlist ::= tagitem */
{ 260, -1 }, /* (160) tagitem ::= INTEGER */
{ 260, -1 }, /* (161) tagitem ::= FLOAT */
{ 260, -1 }, /* (162) tagitem ::= STRING */
{ 260, -1 }, /* (163) tagitem ::= BOOL */
{ 260, -1 }, /* (164) tagitem ::= NULL */
{ 260, -1 }, /* (165) tagitem ::= NOW */
{ 260, -3 }, /* (166) tagitem ::= NOW PLUS VARIABLE */
{ 260, -3 }, /* (167) tagitem ::= NOW MINUS VARIABLE */
{ 260, -2 }, /* (168) tagitem ::= MINUS INTEGER */
{ 260, -2 }, /* (169) tagitem ::= MINUS FLOAT */
{ 260, -2 }, /* (170) tagitem ::= PLUS INTEGER */
{ 260, -2 }, /* (171) tagitem ::= PLUS FLOAT */
{ 257, -15 }, /* (172) select ::= SELECT selcollist from where_opt range_option interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
{ 257, -3 }, /* (173) select ::= LP select RP */
{ 275, -1 }, /* (174) union ::= select */
{ 275, -4 }, /* (175) union ::= union UNION ALL select */
{ 206, -1 }, /* (176) cmd ::= union */
{ 257, -2 }, /* (177) select ::= SELECT selcollist */
{ 276, -2 }, /* (178) sclp ::= selcollist COMMA */
{ 276, 0 }, /* (179) sclp ::= */
{ 261, -4 }, /* (180) selcollist ::= sclp distinct expr as */
{ 261, -2 }, /* (181) selcollist ::= sclp STAR */
{ 279, -2 }, /* (182) as ::= AS ids */
{ 279, -1 }, /* (183) as ::= ids */
{ 279, 0 }, /* (184) as ::= */
{ 277, -1 }, /* (185) distinct ::= DISTINCT */
{ 277, 0 }, /* (186) distinct ::= */
{ 262, -2 }, /* (187) from ::= FROM tablelist */
{ 262, -2 }, /* (188) from ::= FROM sub */
{ 281, -3 }, /* (189) sub ::= LP union RP */
{ 281, -4 }, /* (190) sub ::= LP union RP ids */
{ 281, -6 }, /* (191) sub ::= sub COMMA LP union RP ids */
{ 280, -2 }, /* (192) tablelist ::= ids cpxName */
{ 280, -3 }, /* (193) tablelist ::= ids cpxName ids */
{ 280, -4 }, /* (194) tablelist ::= tablelist COMMA ids cpxName */
{ 280, -5 }, /* (195) tablelist ::= tablelist COMMA ids cpxName ids */
{ 282, -1 }, /* (196) tmvar ::= VARIABLE */
{ 283, -1 }, /* (197) timestamp ::= INTEGER */
{ 283, -2 }, /* (198) timestamp ::= MINUS INTEGER */
{ 283, -2 }, /* (199) timestamp ::= PLUS INTEGER */
{ 283, -1 }, /* (200) timestamp ::= STRING */
{ 283, -1 }, /* (201) timestamp ::= NOW */
{ 283, -3 }, /* (202) timestamp ::= NOW PLUS VARIABLE */
{ 283, -3 }, /* (203) timestamp ::= NOW MINUS VARIABLE */
{ 264, 0 }, /* (204) range_option ::= */
{ 264, -6 }, /* (205) range_option ::= RANGE LP timestamp COMMA timestamp RP */
{ 265, -4 }, /* (206) interval_option ::= intervalKey LP tmvar RP */
{ 265, -6 }, /* (207) interval_option ::= intervalKey LP tmvar COMMA tmvar RP */
{ 265, 0 }, /* (208) interval_option ::= */
{ 284, -1 }, /* (209) intervalKey ::= INTERVAL */
{ 284, -1 }, /* (210) intervalKey ::= EVERY */
{ 267, 0 }, /* (211) session_option ::= */
{ 267, -7 }, /* (212) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
{ 268, 0 }, /* (213) windowstate_option ::= */
{ 268, -4 }, /* (214) windowstate_option ::= STATE_WINDOW LP ids RP */
{ 269, 0 }, /* (215) fill_opt ::= */
{ 269, -6 }, /* (216) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
{ 269, -4 }, /* (217) fill_opt ::= FILL LP ID RP */
{ 266, -4 }, /* (218) sliding_opt ::= SLIDING LP tmvar RP */
{ 266, 0 }, /* (219) sliding_opt ::= */
{ 272, 0 }, /* (220) orderby_opt ::= */
{ 272, -3 }, /* (221) orderby_opt ::= ORDER BY sortlist */
{ 285, -4 }, /* (222) sortlist ::= sortlist COMMA item sortorder */
{ 285, -4 }, /* (223) sortlist ::= sortlist COMMA arrow sortorder */
{ 285, -2 }, /* (224) sortlist ::= item sortorder */
{ 285, -2 }, /* (225) sortlist ::= arrow sortorder */
{ 286, -1 }, /* (226) item ::= ID */
{ 286, -3 }, /* (227) item ::= ID DOT ID */
{ 287, -1 }, /* (228) sortorder ::= ASC */
{ 287, -1 }, /* (229) sortorder ::= DESC */
{ 287, 0 }, /* (230) sortorder ::= */
{ 270, 0 }, /* (231) groupby_opt ::= */
{ 270, -3 }, /* (232) groupby_opt ::= GROUP BY grouplist */
{ 289, -3 }, /* (233) grouplist ::= grouplist COMMA item */
{ 289, -3 }, /* (234) grouplist ::= grouplist COMMA arrow */
{ 289, -1 }, /* (235) grouplist ::= item */
{ 289, -1 }, /* (236) grouplist ::= arrow */
{ 271, 0 }, /* (237) having_opt ::= */
{ 271, -2 }, /* (238) having_opt ::= HAVING expr */
{ 274, 0 }, /* (239) limit_opt ::= */
{ 274, -2 }, /* (240) limit_opt ::= LIMIT signed */
{ 274, -4 }, /* (241) limit_opt ::= LIMIT signed OFFSET signed */
{ 274, -4 }, /* (242) limit_opt ::= LIMIT signed COMMA signed */
{ 273, 0 }, /* (243) slimit_opt ::= */
{ 273, -2 }, /* (244) slimit_opt ::= SLIMIT signed */
{ 273, -4 }, /* (245) slimit_opt ::= SLIMIT signed SOFFSET signed */
{ 273, -4 }, /* (246) slimit_opt ::= SLIMIT signed COMMA signed */
{ 263, 0 }, /* (247) where_opt ::= */
{ 263, -2 }, /* (248) where_opt ::= WHERE expr */
{ 278, -3 }, /* (249) expr ::= LP expr RP */
{ 278, -1 }, /* (250) expr ::= ID */
{ 278, -3 }, /* (251) expr ::= ID DOT ID */
{ 278, -3 }, /* (252) expr ::= ID DOT STAR */
{ 278, -1 }, /* (253) expr ::= INTEGER */
{ 278, -2 }, /* (254) expr ::= MINUS INTEGER */
{ 278, -2 }, /* (255) expr ::= PLUS INTEGER */
{ 278, -1 }, /* (256) expr ::= FLOAT */
{ 278, -2 }, /* (257) expr ::= MINUS FLOAT */
{ 278, -2 }, /* (258) expr ::= PLUS FLOAT */
{ 278, -1 }, /* (259) expr ::= STRING */
{ 278, -1 }, /* (260) expr ::= NOW */
{ 278, -1 }, /* (261) expr ::= TODAY */
{ 278, -1 }, /* (262) expr ::= VARIABLE */
{ 278, -2 }, /* (263) expr ::= PLUS VARIABLE */
{ 278, -2 }, /* (264) expr ::= MINUS VARIABLE */
{ 278, -1 }, /* (265) expr ::= BOOL */
{ 278, -1 }, /* (266) expr ::= NULL */
{ 278, -4 }, /* (267) expr ::= ID LP exprlist RP */
{ 278, -4 }, /* (268) expr ::= ID LP STAR RP */
{ 278, -6 }, /* (269) expr ::= ID LP expr AS typename RP */
{ 278, -3 }, /* (270) expr ::= expr IS NULL */
{ 278, -4 }, /* (271) expr ::= expr IS NOT NULL */
{ 278, -3 }, /* (272) expr ::= expr LT expr */
{ 278, -3 }, /* (273) expr ::= expr GT expr */
{ 278, -3 }, /* (274) expr ::= expr LE expr */
{ 278, -3 }, /* (275) expr ::= expr GE expr */
{ 278, -3 }, /* (276) expr ::= expr NE expr */
{ 278, -3 }, /* (277) expr ::= expr EQ expr */
{ 278, -5 }, /* (278) expr ::= expr BETWEEN expr AND expr */
{ 278, -3 }, /* (279) expr ::= expr AND expr */
{ 278, -3 }, /* (280) expr ::= expr OR expr */
{ 278, -3 }, /* (281) expr ::= expr PLUS expr */
{ 278, -3 }, /* (282) expr ::= expr MINUS expr */
{ 278, -3 }, /* (283) expr ::= expr STAR expr */
{ 278, -3 }, /* (284) expr ::= expr SLASH expr */
{ 278, -3 }, /* (285) expr ::= expr REM expr */
{ 278, -3 }, /* (286) expr ::= expr LIKE expr */
{ 278, -3 }, /* (287) expr ::= expr MATCH expr */
{ 278, -3 }, /* (288) expr ::= expr NMATCH expr */
{ 278, -3 }, /* (289) expr ::= ID CONTAINS STRING */
{ 278, -5 }, /* (290) expr ::= ID DOT ID CONTAINS STRING */
{ 288, -3 }, /* (291) arrow ::= ID ARROW STRING */
{ 288, -5 }, /* (292) arrow ::= ID DOT ID ARROW STRING */
{ 278, -1 }, /* (293) expr ::= arrow */
{ 278, -5 }, /* (294) expr ::= expr IN LP exprlist RP */
{ 214, -3 }, /* (295) exprlist ::= exprlist COMMA expritem */
{ 214, -1 }, /* (296) exprlist ::= expritem */
{ 290, -1 }, /* (297) expritem ::= expr */
{ 290, 0 }, /* (298) expritem ::= */
{ 206, -3 }, /* (299) cmd ::= RESET QUERY CACHE */
{ 206, -3 }, /* (300) cmd ::= SYNCDB ids REPLICA */
{ 206, -7 }, /* (301) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
{ 206, -7 }, /* (302) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
{ 206, -7 }, /* (303) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
{ 206, -7 }, /* (304) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
{ 206, -7 }, /* (305) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
{ 206, -8 }, /* (306) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
{ 206, -9 }, /* (307) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
{ 206, -7 }, /* (308) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
{ 206, -7 }, /* (309) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
{ 206, -7 }, /* (310) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
{ 206, -7 }, /* (311) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
{ 206, -7 }, /* (312) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
{ 206, -7 }, /* (313) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
{ 206, -8 }, /* (314) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
{ 206, -9 }, /* (315) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
{ 206, -7 }, /* (316) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
{ 206, -3 }, /* (317) cmd ::= KILL CONNECTION INTEGER */
{ 206, -5 }, /* (318) cmd ::= KILL STREAM INTEGER COLON INTEGER */
{ 206, -5 }, /* (319) cmd ::= KILL QUERY INTEGER COLON INTEGER */
{ 206, -6 }, /* (320) cmd ::= DELETE FROM ifexists ids cpxName where_opt */
{ 206, -1 }, /* (0) program ::= cmd */
{ 207, -2 }, /* (1) cmd ::= SHOW DATABASES */
{ 207, -2 }, /* (2) cmd ::= SHOW TOPICS */
{ 207, -2 }, /* (3) cmd ::= SHOW FUNCTIONS */
{ 207, -2 }, /* (4) cmd ::= SHOW MNODES */
{ 207, -2 }, /* (5) cmd ::= SHOW DNODES */
{ 207, -2 }, /* (6) cmd ::= SHOW ACCOUNTS */
{ 207, -2 }, /* (7) cmd ::= SHOW USERS */
{ 207, -2 }, /* (8) cmd ::= SHOW MODULES */
{ 207, -2 }, /* (9) cmd ::= SHOW QUERIES */
{ 207, -2 }, /* (10) cmd ::= SHOW CONNECTIONS */
{ 207, -2 }, /* (11) cmd ::= SHOW STREAMS */
{ 207, -2 }, /* (12) cmd ::= SHOW VARIABLES */
{ 207, -2 }, /* (13) cmd ::= SHOW SCORES */
{ 207, -2 }, /* (14) cmd ::= SHOW GRANTS */
{ 207, -2 }, /* (15) cmd ::= SHOW VNODES */
{ 207, -3 }, /* (16) cmd ::= SHOW VNODES ids */
{ 209, 0 }, /* (17) dbPrefix ::= */
{ 209, -2 }, /* (18) dbPrefix ::= ids DOT */
{ 210, 0 }, /* (19) cpxName ::= */
{ 210, -2 }, /* (20) cpxName ::= DOT ids */
{ 207, -5 }, /* (21) cmd ::= SHOW CREATE TABLE ids cpxName */
{ 207, -5 }, /* (22) cmd ::= SHOW CREATE STABLE ids cpxName */
{ 207, -4 }, /* (23) cmd ::= SHOW CREATE DATABASE ids */
{ 207, -3 }, /* (24) cmd ::= SHOW dbPrefix TABLES */
{ 207, -5 }, /* (25) cmd ::= SHOW dbPrefix TABLES LIKE STRING */
{ 207, -3 }, /* (26) cmd ::= SHOW dbPrefix STABLES */
{ 207, -5 }, /* (27) cmd ::= SHOW dbPrefix STABLES LIKE STRING */
{ 207, -3 }, /* (28) cmd ::= SHOW dbPrefix VGROUPS */
{ 207, -5 }, /* (29) cmd ::= DROP TABLE ifexists ids cpxName */
{ 207, -5 }, /* (30) cmd ::= DROP STABLE ifexists ids cpxName */
{ 207, -4 }, /* (31) cmd ::= DROP DATABASE ifexists ids */
{ 207, -4 }, /* (32) cmd ::= DROP TOPIC ifexists ids */
{ 207, -3 }, /* (33) cmd ::= DROP FUNCTION ids */
{ 207, -3 }, /* (34) cmd ::= DROP DNODE ids */
{ 207, -3 }, /* (35) cmd ::= DROP USER ids */
{ 207, -3 }, /* (36) cmd ::= DROP ACCOUNT ids */
{ 207, -2 }, /* (37) cmd ::= USE ids */
{ 207, -3 }, /* (38) cmd ::= DESCRIBE ids cpxName */
{ 207, -3 }, /* (39) cmd ::= DESC ids cpxName */
{ 207, -5 }, /* (40) cmd ::= ALTER USER ids PASS ids */
{ 207, -5 }, /* (41) cmd ::= ALTER USER ids PRIVILEGE ids */
{ 207, -4 }, /* (42) cmd ::= ALTER DNODE ids ids */
{ 207, -5 }, /* (43) cmd ::= ALTER DNODE ids ids ids */
{ 207, -3 }, /* (44) cmd ::= ALTER LOCAL ids */
{ 207, -4 }, /* (45) cmd ::= ALTER LOCAL ids ids */
{ 207, -4 }, /* (46) cmd ::= ALTER DATABASE ids alter_db_optr */
{ 207, -4 }, /* (47) cmd ::= ALTER TOPIC ids alter_topic_optr */
{ 207, -4 }, /* (48) cmd ::= ALTER ACCOUNT ids acct_optr */
{ 207, -6 }, /* (49) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
{ 207, -6 }, /* (50) cmd ::= COMPACT VNODES IN LP exprlist RP */
{ 208, -1 }, /* (51) ids ::= ID */
{ 208, -1 }, /* (52) ids ::= STRING */
{ 211, -2 }, /* (53) ifexists ::= IF EXISTS */
{ 211, 0 }, /* (54) ifexists ::= */
{ 216, -3 }, /* (55) ifnotexists ::= IF NOT EXISTS */
{ 216, 0 }, /* (56) ifnotexists ::= */
{ 207, -3 }, /* (57) cmd ::= CREATE DNODE ids */
{ 207, -6 }, /* (58) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
{ 207, -5 }, /* (59) cmd ::= CREATE DATABASE ifnotexists ids db_optr */
{ 207, -5 }, /* (60) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */
{ 207, -8 }, /* (61) cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
{ 207, -9 }, /* (62) cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
{ 207, -5 }, /* (63) cmd ::= CREATE USER ids PASS ids */
{ 220, 0 }, /* (64) bufsize ::= */
{ 220, -2 }, /* (65) bufsize ::= BUFSIZE INTEGER */
{ 221, 0 }, /* (66) pps ::= */
{ 221, -2 }, /* (67) pps ::= PPS INTEGER */
{ 222, 0 }, /* (68) tseries ::= */
{ 222, -2 }, /* (69) tseries ::= TSERIES INTEGER */
{ 223, 0 }, /* (70) dbs ::= */
{ 223, -2 }, /* (71) dbs ::= DBS INTEGER */
{ 224, 0 }, /* (72) streams ::= */
{ 224, -2 }, /* (73) streams ::= STREAMS INTEGER */
{ 225, 0 }, /* (74) storage ::= */
{ 225, -2 }, /* (75) storage ::= STORAGE INTEGER */
{ 226, 0 }, /* (76) qtime ::= */
{ 226, -2 }, /* (77) qtime ::= QTIME INTEGER */
{ 227, 0 }, /* (78) users ::= */
{ 227, -2 }, /* (79) users ::= USERS INTEGER */
{ 228, 0 }, /* (80) conns ::= */
{ 228, -2 }, /* (81) conns ::= CONNS INTEGER */
{ 229, 0 }, /* (82) state ::= */
{ 229, -2 }, /* (83) state ::= STATE ids */
{ 214, -9 }, /* (84) acct_optr ::= pps tseries storage streams qtime dbs users conns state */
{ 230, -3 }, /* (85) intitemlist ::= intitemlist COMMA intitem */
{ 230, -1 }, /* (86) intitemlist ::= intitem */
{ 231, -1 }, /* (87) intitem ::= INTEGER */
{ 232, -2 }, /* (88) keep ::= KEEP intitemlist */
{ 233, -2 }, /* (89) cache ::= CACHE INTEGER */
{ 234, -2 }, /* (90) replica ::= REPLICA INTEGER */
{ 235, -2 }, /* (91) quorum ::= QUORUM INTEGER */
{ 236, -2 }, /* (92) days ::= DAYS INTEGER */
{ 237, -2 }, /* (93) minrows ::= MINROWS INTEGER */
{ 238, -2 }, /* (94) maxrows ::= MAXROWS INTEGER */
{ 239, -2 }, /* (95) blocks ::= BLOCKS INTEGER */
{ 240, -2 }, /* (96) ctime ::= CTIME INTEGER */
{ 241, -2 }, /* (97) wal ::= WAL INTEGER */
{ 242, -2 }, /* (98) fsync ::= FSYNC INTEGER */
{ 243, -2 }, /* (99) comp ::= COMP INTEGER */
{ 244, -2 }, /* (100) prec ::= PRECISION STRING */
{ 245, -2 }, /* (101) update ::= UPDATE INTEGER */
{ 246, -2 }, /* (102) cachelast ::= CACHELAST INTEGER */
{ 247, -2 }, /* (103) partitions ::= PARTITIONS INTEGER */
{ 217, 0 }, /* (104) db_optr ::= */
{ 217, -2 }, /* (105) db_optr ::= db_optr cache */
{ 217, -2 }, /* (106) db_optr ::= db_optr replica */
{ 217, -2 }, /* (107) db_optr ::= db_optr quorum */
{ 217, -2 }, /* (108) db_optr ::= db_optr days */
{ 217, -2 }, /* (109) db_optr ::= db_optr minrows */
{ 217, -2 }, /* (110) db_optr ::= db_optr maxrows */
{ 217, -2 }, /* (111) db_optr ::= db_optr blocks */
{ 217, -2 }, /* (112) db_optr ::= db_optr ctime */
{ 217, -2 }, /* (113) db_optr ::= db_optr wal */
{ 217, -2 }, /* (114) db_optr ::= db_optr fsync */
{ 217, -2 }, /* (115) db_optr ::= db_optr comp */
{ 217, -2 }, /* (116) db_optr ::= db_optr prec */
{ 217, -2 }, /* (117) db_optr ::= db_optr keep */
{ 217, -2 }, /* (118) db_optr ::= db_optr update */
{ 217, -2 }, /* (119) db_optr ::= db_optr cachelast */
{ 218, -1 }, /* (120) topic_optr ::= db_optr */
{ 218, -2 }, /* (121) topic_optr ::= topic_optr partitions */
{ 212, 0 }, /* (122) alter_db_optr ::= */
{ 212, -2 }, /* (123) alter_db_optr ::= alter_db_optr replica */
{ 212, -2 }, /* (124) alter_db_optr ::= alter_db_optr quorum */
{ 212, -2 }, /* (125) alter_db_optr ::= alter_db_optr keep */
{ 212, -2 }, /* (126) alter_db_optr ::= alter_db_optr blocks */
{ 212, -2 }, /* (127) alter_db_optr ::= alter_db_optr comp */
{ 212, -2 }, /* (128) alter_db_optr ::= alter_db_optr update */
{ 212, -2 }, /* (129) alter_db_optr ::= alter_db_optr cachelast */
{ 213, -1 }, /* (130) alter_topic_optr ::= alter_db_optr */
{ 213, -2 }, /* (131) alter_topic_optr ::= alter_topic_optr partitions */
{ 219, -1 }, /* (132) typename ::= ids */
{ 219, -4 }, /* (133) typename ::= ids LP signed RP */
{ 219, -2 }, /* (134) typename ::= ids UNSIGNED */
{ 248, -1 }, /* (135) signed ::= INTEGER */
{ 248, -2 }, /* (136) signed ::= PLUS INTEGER */
{ 248, -2 }, /* (137) signed ::= MINUS INTEGER */
{ 207, -3 }, /* (138) cmd ::= CREATE TABLE create_table_args */
{ 207, -3 }, /* (139) cmd ::= CREATE TABLE create_stable_args */
{ 207, -3 }, /* (140) cmd ::= CREATE STABLE create_stable_args */
{ 207, -3 }, /* (141) cmd ::= CREATE TABLE create_table_list */
{ 251, -1 }, /* (142) create_table_list ::= create_from_stable */
{ 251, -2 }, /* (143) create_table_list ::= create_table_list create_from_stable */
{ 249, -6 }, /* (144) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
{ 250, -10 }, /* (145) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
{ 252, -10 }, /* (146) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
{ 252, -13 }, /* (147) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
{ 255, -3 }, /* (148) tagNamelist ::= tagNamelist COMMA ids */
{ 255, -1 }, /* (149) tagNamelist ::= ids */
{ 249, -7 }, /* (150) create_table_args ::= ifnotexists ids cpxName to_opt split_opt AS select */
{ 256, 0 }, /* (151) to_opt ::= */
{ 256, -3 }, /* (152) to_opt ::= TO ids cpxName */
{ 257, 0 }, /* (153) split_opt ::= */
{ 257, -2 }, /* (154) split_opt ::= SPLIT ids */
{ 253, -3 }, /* (155) columnlist ::= columnlist COMMA column */
{ 253, -1 }, /* (156) columnlist ::= column */
{ 260, -2 }, /* (157) column ::= ids typename */
{ 254, -3 }, /* (158) tagitemlist ::= tagitemlist COMMA tagitem */
{ 254, -1 }, /* (159) tagitemlist ::= tagitem */
{ 261, -1 }, /* (160) tagitem ::= INTEGER */
{ 261, -1 }, /* (161) tagitem ::= FLOAT */
{ 261, -1 }, /* (162) tagitem ::= STRING */
{ 261, -1 }, /* (163) tagitem ::= BOOL */
{ 261, -1 }, /* (164) tagitem ::= NULL */
{ 261, -1 }, /* (165) tagitem ::= NOW */
{ 261, -3 }, /* (166) tagitem ::= NOW PLUS VARIABLE */
{ 261, -3 }, /* (167) tagitem ::= NOW MINUS VARIABLE */
{ 261, -2 }, /* (168) tagitem ::= MINUS INTEGER */
{ 261, -2 }, /* (169) tagitem ::= MINUS FLOAT */
{ 261, -2 }, /* (170) tagitem ::= PLUS INTEGER */
{ 261, -2 }, /* (171) tagitem ::= PLUS FLOAT */
{ 258, -15 }, /* (172) select ::= SELECT selcollist from where_opt range_option interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
{ 258, -3 }, /* (173) select ::= LP select RP */
{ 276, -1 }, /* (174) union ::= select */
{ 276, -4 }, /* (175) union ::= union UNION ALL select */
{ 207, -1 }, /* (176) cmd ::= union */
{ 258, -2 }, /* (177) select ::= SELECT selcollist */
{ 277, -2 }, /* (178) sclp ::= selcollist COMMA */
{ 277, 0 }, /* (179) sclp ::= */
{ 262, -4 }, /* (180) selcollist ::= sclp distinct expr as */
{ 262, -2 }, /* (181) selcollist ::= sclp STAR */
{ 280, -2 }, /* (182) as ::= AS ids */
{ 280, -1 }, /* (183) as ::= ids */
{ 280, 0 }, /* (184) as ::= */
{ 278, -1 }, /* (185) distinct ::= DISTINCT */
{ 278, 0 }, /* (186) distinct ::= */
{ 263, -2 }, /* (187) from ::= FROM tablelist */
{ 263, -2 }, /* (188) from ::= FROM sub */
{ 282, -3 }, /* (189) sub ::= LP union RP */
{ 282, -4 }, /* (190) sub ::= LP union RP ids */
{ 282, -6 }, /* (191) sub ::= sub COMMA LP union RP ids */
{ 281, -2 }, /* (192) tablelist ::= ids cpxName */
{ 281, -3 }, /* (193) tablelist ::= ids cpxName ids */
{ 281, -4 }, /* (194) tablelist ::= tablelist COMMA ids cpxName */
{ 281, -5 }, /* (195) tablelist ::= tablelist COMMA ids cpxName ids */
{ 283, -1 }, /* (196) tmvar ::= VARIABLE */
{ 284, -1 }, /* (197) timestamp ::= INTEGER */
{ 284, -2 }, /* (198) timestamp ::= MINUS INTEGER */
{ 284, -2 }, /* (199) timestamp ::= PLUS INTEGER */
{ 284, -1 }, /* (200) timestamp ::= STRING */
{ 284, -1 }, /* (201) timestamp ::= NOW */
{ 284, -3 }, /* (202) timestamp ::= NOW PLUS VARIABLE */
{ 284, -3 }, /* (203) timestamp ::= NOW MINUS VARIABLE */
{ 265, 0 }, /* (204) range_option ::= */
{ 265, -6 }, /* (205) range_option ::= RANGE LP timestamp COMMA timestamp RP */
{ 266, -4 }, /* (206) interval_option ::= intervalKey LP tmvar RP */
{ 266, -6 }, /* (207) interval_option ::= intervalKey LP tmvar COMMA tmvar RP */
{ 266, 0 }, /* (208) interval_option ::= */
{ 285, -1 }, /* (209) intervalKey ::= INTERVAL */
{ 285, -1 }, /* (210) intervalKey ::= EVERY */
{ 268, 0 }, /* (211) session_option ::= */
{ 268, -7 }, /* (212) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
{ 269, 0 }, /* (213) windowstate_option ::= */
{ 269, -4 }, /* (214) windowstate_option ::= STATE_WINDOW LP ids RP */
{ 270, 0 }, /* (215) fill_opt ::= */
{ 270, -6 }, /* (216) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
{ 270, -4 }, /* (217) fill_opt ::= FILL LP ID RP */
{ 267, -4 }, /* (218) sliding_opt ::= SLIDING LP tmvar RP */
{ 267, 0 }, /* (219) sliding_opt ::= */
{ 273, 0 }, /* (220) orderby_opt ::= */
{ 273, -3 }, /* (221) orderby_opt ::= ORDER BY sortlist */
{ 286, -4 }, /* (222) sortlist ::= sortlist COMMA item sortorder */
{ 286, -4 }, /* (223) sortlist ::= sortlist COMMA arrow sortorder */
{ 286, -2 }, /* (224) sortlist ::= item sortorder */
{ 286, -2 }, /* (225) sortlist ::= arrow sortorder */
{ 287, -1 }, /* (226) item ::= ID */
{ 287, -3 }, /* (227) item ::= ID DOT ID */
{ 288, -1 }, /* (228) sortorder ::= ASC */
{ 288, -1 }, /* (229) sortorder ::= DESC */
{ 288, 0 }, /* (230) sortorder ::= */
{ 271, 0 }, /* (231) groupby_opt ::= */
{ 271, -3 }, /* (232) groupby_opt ::= GROUP BY grouplist */
{ 290, -3 }, /* (233) grouplist ::= grouplist COMMA item */
{ 290, -3 }, /* (234) grouplist ::= grouplist COMMA arrow */
{ 290, -1 }, /* (235) grouplist ::= item */
{ 290, -1 }, /* (236) grouplist ::= arrow */
{ 272, 0 }, /* (237) having_opt ::= */
{ 272, -2 }, /* (238) having_opt ::= HAVING expr */
{ 275, 0 }, /* (239) limit_opt ::= */
{ 275, -2 }, /* (240) limit_opt ::= LIMIT signed */
{ 275, -4 }, /* (241) limit_opt ::= LIMIT signed OFFSET signed */
{ 275, -4 }, /* (242) limit_opt ::= LIMIT signed COMMA signed */
{ 274, 0 }, /* (243) slimit_opt ::= */
{ 274, -2 }, /* (244) slimit_opt ::= SLIMIT signed */
{ 274, -4 }, /* (245) slimit_opt ::= SLIMIT signed SOFFSET signed */
{ 274, -4 }, /* (246) slimit_opt ::= SLIMIT signed COMMA signed */
{ 264, 0 }, /* (247) where_opt ::= */
{ 264, -2 }, /* (248) where_opt ::= WHERE expr */
{ 279, -3 }, /* (249) expr ::= LP expr RP */
{ 279, -1 }, /* (250) expr ::= ID */
{ 279, -3 }, /* (251) expr ::= ID DOT ID */
{ 279, -3 }, /* (252) expr ::= ID DOT STAR */
{ 279, -1 }, /* (253) expr ::= INTEGER */
{ 279, -2 }, /* (254) expr ::= MINUS INTEGER */
{ 279, -2 }, /* (255) expr ::= PLUS INTEGER */
{ 279, -1 }, /* (256) expr ::= FLOAT */
{ 279, -2 }, /* (257) expr ::= MINUS FLOAT */
{ 279, -2 }, /* (258) expr ::= PLUS FLOAT */
{ 279, -1 }, /* (259) expr ::= STRING */
{ 279, -1 }, /* (260) expr ::= NOW */
{ 279, -1 }, /* (261) expr ::= TODAY */
{ 279, -1 }, /* (262) expr ::= VARIABLE */
{ 279, -2 }, /* (263) expr ::= PLUS VARIABLE */
{ 279, -2 }, /* (264) expr ::= MINUS VARIABLE */
{ 279, -1 }, /* (265) expr ::= BOOL */
{ 279, -1 }, /* (266) expr ::= NULL */
{ 279, -4 }, /* (267) expr ::= ID LP exprlist RP */
{ 279, -4 }, /* (268) expr ::= ID LP STAR RP */
{ 279, -6 }, /* (269) expr ::= ID LP expr AS typename RP */
{ 279, -3 }, /* (270) expr ::= expr IS NULL */
{ 279, -4 }, /* (271) expr ::= expr IS NOT NULL */
{ 279, -3 }, /* (272) expr ::= expr LT expr */
{ 279, -3 }, /* (273) expr ::= expr GT expr */
{ 279, -3 }, /* (274) expr ::= expr LE expr */
{ 279, -3 }, /* (275) expr ::= expr GE expr */
{ 279, -3 }, /* (276) expr ::= expr NE expr */
{ 279, -3 }, /* (277) expr ::= expr EQ expr */
{ 279, -5 }, /* (278) expr ::= expr BETWEEN expr AND expr */
{ 279, -3 }, /* (279) expr ::= expr AND expr */
{ 279, -3 }, /* (280) expr ::= expr OR expr */
{ 279, -3 }, /* (281) expr ::= expr PLUS expr */
{ 279, -3 }, /* (282) expr ::= expr MINUS expr */
{ 279, -3 }, /* (283) expr ::= expr STAR expr */
{ 279, -3 }, /* (284) expr ::= expr SLASH expr */
{ 279, -3 }, /* (285) expr ::= expr REM expr */
{ 279, -3 }, /* (286) expr ::= expr BITAND expr */
{ 279, -3 }, /* (287) expr ::= expr LIKE expr */
{ 279, -3 }, /* (288) expr ::= expr MATCH expr */
{ 279, -3 }, /* (289) expr ::= expr NMATCH expr */
{ 279, -3 }, /* (290) expr ::= ID CONTAINS STRING */
{ 279, -5 }, /* (291) expr ::= ID DOT ID CONTAINS STRING */
{ 289, -3 }, /* (292) arrow ::= ID ARROW STRING */
{ 289, -5 }, /* (293) arrow ::= ID DOT ID ARROW STRING */
{ 279, -1 }, /* (294) expr ::= arrow */
{ 279, -5 }, /* (295) expr ::= expr IN LP exprlist RP */
{ 215, -3 }, /* (296) exprlist ::= exprlist COMMA expritem */
{ 215, -1 }, /* (297) exprlist ::= expritem */
{ 291, -1 }, /* (298) expritem ::= expr */
{ 291, 0 }, /* (299) expritem ::= */
{ 207, -3 }, /* (300) cmd ::= RESET QUERY CACHE */
{ 207, -3 }, /* (301) cmd ::= SYNCDB ids REPLICA */
{ 207, -7 }, /* (302) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
{ 207, -7 }, /* (303) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
{ 207, -7 }, /* (304) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
{ 207, -7 }, /* (305) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
{ 207, -7 }, /* (306) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
{ 207, -8 }, /* (307) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
{ 207, -9 }, /* (308) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
{ 207, -7 }, /* (309) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
{ 207, -7 }, /* (310) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
{ 207, -7 }, /* (311) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
{ 207, -7 }, /* (312) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
{ 207, -7 }, /* (313) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
{ 207, -7 }, /* (314) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
{ 207, -8 }, /* (315) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
{ 207, -9 }, /* (316) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
{ 207, -7 }, /* (317) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
{ 207, -3 }, /* (318) cmd ::= KILL CONNECTION INTEGER */
{ 207, -5 }, /* (319) cmd ::= KILL STREAM INTEGER COLON INTEGER */
{ 207, -5 }, /* (320) cmd ::= KILL QUERY INTEGER COLON INTEGER */
{ 207, -6 }, /* (321) cmd ::= DELETE FROM ifexists ids cpxName where_opt */
};
static void yy_accept(yyParser*); /* Forward Declaration */
......@@ -2269,18 +2256,17 @@ static void yy_accept(yyParser*); /* Forward Declaration */
** only called from one place, optimizing compilers will in-line it, which
** means that the extra parameters have no performance impact.
*/
static YYACTIONTYPE yy_reduce(
static void yy_reduce(
yyParser *yypParser, /* The parser */
unsigned int yyruleno, /* Number of the rule by which to reduce */
int yyLookahead, /* Lookahead token, or YYNOCODE if none */
ParseTOKENTYPE yyLookaheadToken /* Value of the lookahead token */
ParseCTX_PDECL /* %extra_context */
){
int yygoto; /* The next state */
YYACTIONTYPE yyact; /* The next action */
int yyact; /* The next action */
yyStackEntry *yymsp; /* The top of the parser's stack */
int yysize; /* Amount to pop the stack */
ParseARG_FETCH
ParseARG_FETCH;
(void)yyLookahead;
(void)yyLookaheadToken;
yymsp = yypParser->yytos;
......@@ -2311,19 +2297,13 @@ static YYACTIONTYPE yy_reduce(
#if YYSTACKDEPTH>0
if( yypParser->yytos>=yypParser->yystackEnd ){
yyStackOverflow(yypParser);
/* The call to yyStackOverflow() above pops the stack until it is
** empty, causing the main parser loop to exit. So the return value
** is never used and does not matter. */
return 0;
return;
}
#else
if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){
if( yyGrowStack(yypParser) ){
yyStackOverflow(yypParser);
/* The call to yyStackOverflow() above pops the stack until it is
** empty, causing the main parser loop to exit. So the return value
** is never used and does not matter. */
return 0;
return;
}
yymsp = yypParser->yytos;
}
......@@ -2514,16 +2494,16 @@ static YYACTIONTYPE yy_reduce(
break;
case 46: /* cmd ::= ALTER DATABASE ids alter_db_optr */
case 47: /* cmd ::= ALTER TOPIC ids alter_topic_optr */ yytestcase(yyruleno==47);
{ SStrToken t = {0}; setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy436, &t);}
{ SStrToken t = {0}; setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy342, &t);}
break;
case 48: /* cmd ::= ALTER ACCOUNT ids acct_optr */
{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy517);}
{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy299);}
break;
case 49: /* cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy517);}
{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy299);}
break;
case 50: /* cmd ::= COMPACT VNODES IN LP exprlist RP */
{ setCompactVnodeSql(pInfo, TSDB_SQL_COMPACT_VNODE, yymsp[-1].minor.yy525);}
{ setCompactVnodeSql(pInfo, TSDB_SQL_COMPACT_VNODE, yymsp[-1].minor.yy333);}
break;
case 51: /* ids ::= ID */
case 52: /* ids ::= STRING */ yytestcase(yyruleno==52);
......@@ -2545,17 +2525,17 @@ static YYACTIONTYPE yy_reduce(
{ setDCLSqlElems(pInfo, TSDB_SQL_CREATE_DNODE, 1, &yymsp[0].minor.yy0);}
break;
case 58: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
{ setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy517);}
{ setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy299);}
break;
case 59: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */
case 60: /* cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ yytestcase(yyruleno==60);
{ setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy436, &yymsp[-2].minor.yy0);}
{ setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy342, &yymsp[-2].minor.yy0);}
break;
case 61: /* cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy115, &yymsp[0].minor.yy0, 1);}
{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy263, &yymsp[0].minor.yy0, 1);}
break;
case 62: /* cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */
{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy115, &yymsp[0].minor.yy0, 2);}
{ setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy263, &yymsp[0].minor.yy0, 2);}
break;
case 63: /* cmd ::= CREATE USER ids PASS ids */
{ setCreateUserSql(pInfo, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);}
......@@ -2586,38 +2566,38 @@ static YYACTIONTYPE yy_reduce(
break;
case 84: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */
{
yylhsminor.yy517.maxUsers = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
yylhsminor.yy517.maxDbs = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
yylhsminor.yy517.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
yylhsminor.yy517.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
yylhsminor.yy517.maxPointsPerSecond = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
yylhsminor.yy517.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
yylhsminor.yy517.maxQueryTime = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
yylhsminor.yy517.maxConnections = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
yylhsminor.yy517.stat = yymsp[0].minor.yy0;
yylhsminor.yy299.maxUsers = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
yylhsminor.yy299.maxDbs = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
yylhsminor.yy299.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
yylhsminor.yy299.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
yylhsminor.yy299.maxPointsPerSecond = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
yylhsminor.yy299.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
yylhsminor.yy299.maxQueryTime = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
yylhsminor.yy299.maxConnections = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
yylhsminor.yy299.stat = yymsp[0].minor.yy0;
}
yymsp[-8].minor.yy517 = yylhsminor.yy517;
yymsp[-8].minor.yy299 = yylhsminor.yy299;
break;
case 85: /* intitemlist ::= intitemlist COMMA intitem */
case 158: /* tagitemlist ::= tagitemlist COMMA tagitem */ yytestcase(yyruleno==158);
{ yylhsminor.yy525 = tVariantListAppend(yymsp[-2].minor.yy525, &yymsp[0].minor.yy110, -1); }
yymsp[-2].minor.yy525 = yylhsminor.yy525;
{ yylhsminor.yy333 = tVariantListAppend(yymsp[-2].minor.yy333, &yymsp[0].minor.yy42, -1); }
yymsp[-2].minor.yy333 = yylhsminor.yy333;
break;
case 86: /* intitemlist ::= intitem */
case 159: /* tagitemlist ::= tagitem */ yytestcase(yyruleno==159);
{ yylhsminor.yy525 = tVariantListAppend(NULL, &yymsp[0].minor.yy110, -1); }
yymsp[0].minor.yy525 = yylhsminor.yy525;
{ yylhsminor.yy333 = tVariantListAppend(NULL, &yymsp[0].minor.yy42, -1); }
yymsp[0].minor.yy333 = yylhsminor.yy333;
break;
case 87: /* intitem ::= INTEGER */
case 160: /* tagitem ::= INTEGER */ yytestcase(yyruleno==160);
case 161: /* tagitem ::= FLOAT */ yytestcase(yyruleno==161);
case 162: /* tagitem ::= STRING */ yytestcase(yyruleno==162);
case 163: /* tagitem ::= BOOL */ yytestcase(yyruleno==163);
{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy110, &yymsp[0].minor.yy0); }
yymsp[0].minor.yy110 = yylhsminor.yy110;
{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy42, &yymsp[0].minor.yy0); }
yymsp[0].minor.yy42 = yylhsminor.yy42;
break;
case 88: /* keep ::= KEEP intitemlist */
{ yymsp[-1].minor.yy525 = yymsp[0].minor.yy525; }
{ yymsp[-1].minor.yy333 = yymsp[0].minor.yy333; }
break;
case 89: /* cache ::= CACHE INTEGER */
case 90: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==90);
......@@ -2637,200 +2617,200 @@ static YYACTIONTYPE yy_reduce(
{ yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
break;
case 104: /* db_optr ::= */
{setDefaultCreateDbOption(&yymsp[1].minor.yy436); yymsp[1].minor.yy436.dbType = TSDB_DB_TYPE_DEFAULT;}
{setDefaultCreateDbOption(&yymsp[1].minor.yy342); yymsp[1].minor.yy342.dbType = TSDB_DB_TYPE_DEFAULT;}
break;
case 105: /* db_optr ::= db_optr cache */
{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy436 = yylhsminor.yy436;
{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy342 = yylhsminor.yy342;
break;
case 106: /* db_optr ::= db_optr replica */
case 123: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==123);
{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy436 = yylhsminor.yy436;
{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy342 = yylhsminor.yy342;
break;
case 107: /* db_optr ::= db_optr quorum */
case 124: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==124);
{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy436 = yylhsminor.yy436;
{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy342 = yylhsminor.yy342;
break;
case 108: /* db_optr ::= db_optr days */
{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy436 = yylhsminor.yy436;
{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy342 = yylhsminor.yy342;
break;
case 109: /* db_optr ::= db_optr minrows */
{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
yymsp[-1].minor.yy436 = yylhsminor.yy436;
{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
yymsp[-1].minor.yy342 = yylhsminor.yy342;
break;
case 110: /* db_optr ::= db_optr maxrows */
{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
yymsp[-1].minor.yy436 = yylhsminor.yy436;
{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
yymsp[-1].minor.yy342 = yylhsminor.yy342;
break;
case 111: /* db_optr ::= db_optr blocks */
case 126: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==126);
{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy436 = yylhsminor.yy436;
{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy342 = yylhsminor.yy342;
break;
case 112: /* db_optr ::= db_optr ctime */
{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy436 = yylhsminor.yy436;
{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy342 = yylhsminor.yy342;
break;
case 113: /* db_optr ::= db_optr wal */
{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy436 = yylhsminor.yy436;
{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy342 = yylhsminor.yy342;
break;
case 114: /* db_optr ::= db_optr fsync */
{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy436 = yylhsminor.yy436;
{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy342 = yylhsminor.yy342;
break;
case 115: /* db_optr ::= db_optr comp */
case 127: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==127);
{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy436 = yylhsminor.yy436;
{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy342 = yylhsminor.yy342;
break;
case 116: /* db_optr ::= db_optr prec */
{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.precision = yymsp[0].minor.yy0; }
yymsp[-1].minor.yy436 = yylhsminor.yy436;
{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.precision = yymsp[0].minor.yy0; }
yymsp[-1].minor.yy342 = yylhsminor.yy342;
break;
case 117: /* db_optr ::= db_optr keep */
case 125: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==125);
{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.keep = yymsp[0].minor.yy525; }
yymsp[-1].minor.yy436 = yylhsminor.yy436;
{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.keep = yymsp[0].minor.yy333; }
yymsp[-1].minor.yy342 = yylhsminor.yy342;
break;
case 118: /* db_optr ::= db_optr update */
case 128: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==128);
{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy436 = yylhsminor.yy436;
{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy342 = yylhsminor.yy342;
break;
case 119: /* db_optr ::= db_optr cachelast */
case 129: /* alter_db_optr ::= alter_db_optr cachelast */ yytestcase(yyruleno==129);
{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy436 = yylhsminor.yy436;
{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy342 = yylhsminor.yy342;
break;
case 120: /* topic_optr ::= db_optr */
case 130: /* alter_topic_optr ::= alter_db_optr */ yytestcase(yyruleno==130);
{ yylhsminor.yy436 = yymsp[0].minor.yy436; yylhsminor.yy436.dbType = TSDB_DB_TYPE_TOPIC; }
yymsp[0].minor.yy436 = yylhsminor.yy436;
{ yylhsminor.yy342 = yymsp[0].minor.yy342; yylhsminor.yy342.dbType = TSDB_DB_TYPE_TOPIC; }
yymsp[0].minor.yy342 = yylhsminor.yy342;
break;
case 121: /* topic_optr ::= topic_optr partitions */
case 131: /* alter_topic_optr ::= alter_topic_optr partitions */ yytestcase(yyruleno==131);
{ yylhsminor.yy436 = yymsp[-1].minor.yy436; yylhsminor.yy436.partitions = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy436 = yylhsminor.yy436;
{ yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.partitions = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[-1].minor.yy342 = yylhsminor.yy342;
break;
case 122: /* alter_db_optr ::= */
{ setDefaultCreateDbOption(&yymsp[1].minor.yy436); yymsp[1].minor.yy436.dbType = TSDB_DB_TYPE_DEFAULT;}
{ setDefaultCreateDbOption(&yymsp[1].minor.yy342); yymsp[1].minor.yy342.dbType = TSDB_DB_TYPE_DEFAULT;}
break;
case 132: /* typename ::= ids */
{
yymsp[0].minor.yy0.type = 0;
tSetColumnType (&yylhsminor.yy115, &yymsp[0].minor.yy0);
tSetColumnType (&yylhsminor.yy263, &yymsp[0].minor.yy0);
}
yymsp[0].minor.yy115 = yylhsminor.yy115;
yymsp[0].minor.yy263 = yylhsminor.yy263;
break;
case 133: /* typename ::= ids LP signed RP */
{
if (yymsp[-1].minor.yy543 <= 0) {
if (yymsp[-1].minor.yy277 <= 0) {
yymsp[-3].minor.yy0.type = 0;
tSetColumnType(&yylhsminor.yy115, &yymsp[-3].minor.yy0);
tSetColumnType(&yylhsminor.yy263, &yymsp[-3].minor.yy0);
} else {
yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy543; // negative value of name length
tSetColumnType(&yylhsminor.yy115, &yymsp[-3].minor.yy0);
yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy277; // negative value of name length
tSetColumnType(&yylhsminor.yy263, &yymsp[-3].minor.yy0);
}
}
yymsp[-3].minor.yy115 = yylhsminor.yy115;
yymsp[-3].minor.yy263 = yylhsminor.yy263;
break;
case 134: /* typename ::= ids UNSIGNED */
{
yymsp[-1].minor.yy0.type = 0;
yymsp[-1].minor.yy0.n = ((yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z);
tSetColumnType (&yylhsminor.yy115, &yymsp[-1].minor.yy0);
tSetColumnType (&yylhsminor.yy263, &yymsp[-1].minor.yy0);
}
yymsp[-1].minor.yy115 = yylhsminor.yy115;
yymsp[-1].minor.yy263 = yylhsminor.yy263;
break;
case 135: /* signed ::= INTEGER */
{ yylhsminor.yy543 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[0].minor.yy543 = yylhsminor.yy543;
{ yylhsminor.yy277 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
yymsp[0].minor.yy277 = yylhsminor.yy277;
break;
case 136: /* signed ::= PLUS INTEGER */
{ yymsp[-1].minor.yy543 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
{ yymsp[-1].minor.yy277 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
break;
case 137: /* signed ::= MINUS INTEGER */
{ yymsp[-1].minor.yy543 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
{ yymsp[-1].minor.yy277 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
break;
case 141: /* cmd ::= CREATE TABLE create_table_list */
{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy572;}
{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy78;}
break;
case 142: /* create_table_list ::= create_from_stable */
{
SCreateTableSql* pCreateTable = calloc(1, sizeof(SCreateTableSql));
pCreateTable->childTableInfo = taosArrayInit(4, sizeof(SCreatedTableInfo));
taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy480);
taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy400);
pCreateTable->type = TSQL_CREATE_TABLE_FROM_STABLE;
yylhsminor.yy572 = pCreateTable;
yylhsminor.yy78 = pCreateTable;
}
yymsp[0].minor.yy572 = yylhsminor.yy572;
yymsp[0].minor.yy78 = yylhsminor.yy78;
break;
case 143: /* create_table_list ::= create_table_list create_from_stable */
{
taosArrayPush(yymsp[-1].minor.yy572->childTableInfo, &yymsp[0].minor.yy480);
yylhsminor.yy572 = yymsp[-1].minor.yy572;
taosArrayPush(yymsp[-1].minor.yy78->childTableInfo, &yymsp[0].minor.yy400);
yylhsminor.yy78 = yymsp[-1].minor.yy78;
}
yymsp[-1].minor.yy572 = yylhsminor.yy572;
yymsp[-1].minor.yy78 = yylhsminor.yy78;
break;
case 144: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
{
yylhsminor.yy572 = tSetCreateTableInfo(yymsp[-1].minor.yy525, NULL, NULL, TSQL_CREATE_TABLE);
setSqlInfo(pInfo, yylhsminor.yy572, NULL, TSDB_SQL_CREATE_TABLE);
yylhsminor.yy78 = tSetCreateTableInfo(yymsp[-1].minor.yy333, NULL, NULL, TSQL_CREATE_TABLE);
setSqlInfo(pInfo, yylhsminor.yy78, NULL, TSDB_SQL_CREATE_TABLE);
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
setCreatedTableName(pInfo, &yymsp[-4].minor.yy0, &yymsp[-5].minor.yy0);
}
yymsp[-5].minor.yy572 = yylhsminor.yy572;
yymsp[-5].minor.yy78 = yylhsminor.yy78;
break;
case 145: /* create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
{
yylhsminor.yy572 = tSetCreateTableInfo(yymsp[-5].minor.yy525, yymsp[-1].minor.yy525, NULL, TSQL_CREATE_STABLE);
setSqlInfo(pInfo, yylhsminor.yy572, NULL, TSDB_SQL_CREATE_TABLE);
yylhsminor.yy78 = tSetCreateTableInfo(yymsp[-5].minor.yy333, yymsp[-1].minor.yy333, NULL, TSQL_CREATE_STABLE);
setSqlInfo(pInfo, yylhsminor.yy78, NULL, TSDB_SQL_CREATE_TABLE);
yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
setCreatedTableName(pInfo, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
}
yymsp[-9].minor.yy572 = yylhsminor.yy572;
yymsp[-9].minor.yy78 = yylhsminor.yy78;
break;
case 146: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
{
yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
yylhsminor.yy480 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy525, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
yylhsminor.yy400 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy333, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
}
yymsp[-9].minor.yy480 = yylhsminor.yy480;
yymsp[-9].minor.yy400 = yylhsminor.yy400;
break;
case 147: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
{
yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
yymsp[-11].minor.yy0.n += yymsp[-10].minor.yy0.n;
yylhsminor.yy480 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy525, yymsp[-1].minor.yy525, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0);
yylhsminor.yy400 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy333, yymsp[-1].minor.yy333, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0);
}
yymsp[-12].minor.yy480 = yylhsminor.yy480;
yymsp[-12].minor.yy400 = yylhsminor.yy400;
break;
case 148: /* tagNamelist ::= tagNamelist COMMA ids */
{taosArrayPush(yymsp[-2].minor.yy525, &yymsp[0].minor.yy0); yylhsminor.yy525 = yymsp[-2].minor.yy525; }
yymsp[-2].minor.yy525 = yylhsminor.yy525;
{taosArrayPush(yymsp[-2].minor.yy333, &yymsp[0].minor.yy0); yylhsminor.yy333 = yymsp[-2].minor.yy333; }
yymsp[-2].minor.yy333 = yylhsminor.yy333;
break;
case 149: /* tagNamelist ::= ids */
{yylhsminor.yy525 = taosArrayInit(4, sizeof(SStrToken)); taosArrayPush(yylhsminor.yy525, &yymsp[0].minor.yy0);}
yymsp[0].minor.yy525 = yylhsminor.yy525;
{yylhsminor.yy333 = taosArrayInit(4, sizeof(SStrToken)); taosArrayPush(yylhsminor.yy333, &yymsp[0].minor.yy0);}
yymsp[0].minor.yy333 = yylhsminor.yy333;
break;
case 150: /* create_table_args ::= ifnotexists ids cpxName to_opt split_opt AS select */
{
yylhsminor.yy572 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy86, TSQL_CREATE_STREAM);
setSqlInfo(pInfo, yylhsminor.yy572, NULL, TSDB_SQL_CREATE_TABLE);
yylhsminor.yy78 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy144, TSQL_CREATE_STREAM);
setSqlInfo(pInfo, yylhsminor.yy78, NULL, TSDB_SQL_CREATE_TABLE);
setCreatedStreamOpt(pInfo, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0);
yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
setCreatedTableName(pInfo, &yymsp[-5].minor.yy0, &yymsp[-6].minor.yy0);
}
yymsp[-6].minor.yy572 = yylhsminor.yy572;
yymsp[-6].minor.yy78 = yylhsminor.yy78;
break;
case 151: /* to_opt ::= */
case 153: /* split_opt ::= */ yytestcase(yyruleno==153);
......@@ -2846,37 +2826,37 @@ static YYACTIONTYPE yy_reduce(
{ yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;}
break;
case 155: /* columnlist ::= columnlist COMMA column */
{taosArrayPush(yymsp[-2].minor.yy525, &yymsp[0].minor.yy115); yylhsminor.yy525 = yymsp[-2].minor.yy525; }
yymsp[-2].minor.yy525 = yylhsminor.yy525;
{taosArrayPush(yymsp[-2].minor.yy333, &yymsp[0].minor.yy263); yylhsminor.yy333 = yymsp[-2].minor.yy333; }
yymsp[-2].minor.yy333 = yylhsminor.yy333;
break;
case 156: /* columnlist ::= column */
{yylhsminor.yy525 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy525, &yymsp[0].minor.yy115);}
yymsp[0].minor.yy525 = yylhsminor.yy525;
{yylhsminor.yy333 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy333, &yymsp[0].minor.yy263);}
yymsp[0].minor.yy333 = yylhsminor.yy333;
break;
case 157: /* column ::= ids typename */
{
tSetColumnInfo(&yylhsminor.yy115, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy115);
tSetColumnInfo(&yylhsminor.yy263, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy263);
}
yymsp[-1].minor.yy115 = yylhsminor.yy115;
yymsp[-1].minor.yy263 = yylhsminor.yy263;
break;
case 164: /* tagitem ::= NULL */
{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy110, &yymsp[0].minor.yy0); }
yymsp[0].minor.yy110 = yylhsminor.yy110;
{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy42, &yymsp[0].minor.yy0); }
yymsp[0].minor.yy42 = yylhsminor.yy42;
break;
case 165: /* tagitem ::= NOW */
{ yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP; tVariantCreateExt(&yylhsminor.yy110, &yymsp[0].minor.yy0, TK_NOW, true);}
yymsp[0].minor.yy110 = yylhsminor.yy110;
{ yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP; tVariantCreateExt(&yylhsminor.yy42, &yymsp[0].minor.yy0, TK_NOW, true);}
yymsp[0].minor.yy42 = yylhsminor.yy42;
break;
case 166: /* tagitem ::= NOW PLUS VARIABLE */
{
yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP;
tVariantCreateExt(&yymsp[-2].minor.yy110, &yymsp[0].minor.yy0, TK_PLUS, true);
tVariantCreateExt(&yymsp[-2].minor.yy42, &yymsp[0].minor.yy0, TK_PLUS, true);
}
break;
case 167: /* tagitem ::= NOW MINUS VARIABLE */
{
yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP;
tVariantCreateExt(&yymsp[-2].minor.yy110, &yymsp[0].minor.yy0, TK_MINUS, true);
tVariantCreateExt(&yymsp[-2].minor.yy42, &yymsp[0].minor.yy0, TK_MINUS, true);
}
break;
case 168: /* tagitem ::= MINUS INTEGER */
......@@ -2887,56 +2867,56 @@ static YYACTIONTYPE yy_reduce(
yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
yymsp[-1].minor.yy0.type = yymsp[0].minor.yy0.type;
toTSDBType(yymsp[-1].minor.yy0.type);
tVariantCreate(&yylhsminor.yy110, &yymsp[-1].minor.yy0);
tVariantCreate(&yylhsminor.yy42, &yymsp[-1].minor.yy0);
}
yymsp[-1].minor.yy110 = yylhsminor.yy110;
yymsp[-1].minor.yy42 = yylhsminor.yy42;
break;
case 172: /* select ::= SELECT selcollist from where_opt range_option interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */
{
yylhsminor.yy86 = tSetQuerySqlNode(&yymsp[-14].minor.yy0, yymsp[-13].minor.yy525, yymsp[-12].minor.yy328, yymsp[-11].minor.yy142, yymsp[-4].minor.yy525, yymsp[-2].minor.yy525, &yymsp[-9].minor.yy238, &yymsp[-7].minor.yy319, &yymsp[-6].minor.yy546, &yymsp[-8].minor.yy0, yymsp[-5].minor.yy525, &yymsp[0].minor.yy6, &yymsp[-1].minor.yy6, yymsp[-3].minor.yy142, &yymsp[-10].minor.yy330);
yylhsminor.yy144 = tSetQuerySqlNode(&yymsp[-14].minor.yy0, yymsp[-13].minor.yy333, yymsp[-12].minor.yy516, yymsp[-11].minor.yy194, yymsp[-4].minor.yy333, yymsp[-2].minor.yy333, &yymsp[-9].minor.yy200, &yymsp[-7].minor.yy235, &yymsp[-6].minor.yy248, &yymsp[-8].minor.yy0, yymsp[-5].minor.yy333, &yymsp[0].minor.yy190, &yymsp[-1].minor.yy190, yymsp[-3].minor.yy194, &yymsp[-10].minor.yy132);
}
yymsp[-14].minor.yy86 = yylhsminor.yy86;
yymsp[-14].minor.yy144 = yylhsminor.yy144;
break;
case 173: /* select ::= LP select RP */
{yymsp[-2].minor.yy86 = yymsp[-1].minor.yy86;}
{yymsp[-2].minor.yy144 = yymsp[-1].minor.yy144;}
break;
case 174: /* union ::= select */
{ yylhsminor.yy525 = setSubclause(NULL, yymsp[0].minor.yy86); }
yymsp[0].minor.yy525 = yylhsminor.yy525;
{ yylhsminor.yy333 = setSubclause(NULL, yymsp[0].minor.yy144); }
yymsp[0].minor.yy333 = yylhsminor.yy333;
break;
case 175: /* union ::= union UNION ALL select */
{ yylhsminor.yy525 = appendSelectClause(yymsp[-3].minor.yy525, yymsp[0].minor.yy86); }
yymsp[-3].minor.yy525 = yylhsminor.yy525;
{ yylhsminor.yy333 = appendSelectClause(yymsp[-3].minor.yy333, yymsp[0].minor.yy144); }
yymsp[-3].minor.yy333 = yylhsminor.yy333;
break;
case 176: /* cmd ::= union */
{ setSqlInfo(pInfo, yymsp[0].minor.yy525, NULL, TSDB_SQL_SELECT); }
{ setSqlInfo(pInfo, yymsp[0].minor.yy333, NULL, TSDB_SQL_SELECT); }
break;
case 177: /* select ::= SELECT selcollist */
{
yylhsminor.yy86 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy525, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
yylhsminor.yy144 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy333, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
}
yymsp[-1].minor.yy86 = yylhsminor.yy86;
yymsp[-1].minor.yy144 = yylhsminor.yy144;
break;
case 178: /* sclp ::= selcollist COMMA */
{yylhsminor.yy525 = yymsp[-1].minor.yy525;}
yymsp[-1].minor.yy525 = yylhsminor.yy525;
{yylhsminor.yy333 = yymsp[-1].minor.yy333;}
yymsp[-1].minor.yy333 = yylhsminor.yy333;
break;
case 179: /* sclp ::= */
case 220: /* orderby_opt ::= */ yytestcase(yyruleno==220);
{yymsp[1].minor.yy525 = 0;}
{yymsp[1].minor.yy333 = 0;}
break;
case 180: /* selcollist ::= sclp distinct expr as */
{
yylhsminor.yy525 = tSqlExprListAppend(yymsp[-3].minor.yy525, yymsp[-1].minor.yy142, yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
yylhsminor.yy333 = tSqlExprListAppend(yymsp[-3].minor.yy333, yymsp[-1].minor.yy194, yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
}
yymsp[-3].minor.yy525 = yylhsminor.yy525;
yymsp[-3].minor.yy333 = yylhsminor.yy333;
break;
case 181: /* selcollist ::= sclp STAR */
{
tSqlExpr *pNode = tSqlExprCreateIdValue(pInfo, NULL, TK_ALL);
yylhsminor.yy525 = tSqlExprListAppend(yymsp[-1].minor.yy525, pNode, 0, 0);
yylhsminor.yy333 = tSqlExprListAppend(yymsp[-1].minor.yy333, pNode, 0, 0);
}
yymsp[-1].minor.yy525 = yylhsminor.yy525;
yymsp[-1].minor.yy333 = yylhsminor.yy333;
break;
case 182: /* as ::= AS ids */
{ yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
......@@ -2954,114 +2934,114 @@ static YYACTIONTYPE yy_reduce(
break;
case 187: /* from ::= FROM tablelist */
case 188: /* from ::= FROM sub */ yytestcase(yyruleno==188);
{yymsp[-1].minor.yy328 = yymsp[0].minor.yy328;}
{yymsp[-1].minor.yy516 = yymsp[0].minor.yy516;}
break;
case 189: /* sub ::= LP union RP */
{yymsp[-2].minor.yy328 = addSubqueryElem(NULL, yymsp[-1].minor.yy525, NULL);}
{yymsp[-2].minor.yy516 = addSubqueryElem(NULL, yymsp[-1].minor.yy333, NULL);}
break;
case 190: /* sub ::= LP union RP ids */
{yymsp[-3].minor.yy328 = addSubqueryElem(NULL, yymsp[-2].minor.yy525, &yymsp[0].minor.yy0);}
{yymsp[-3].minor.yy516 = addSubqueryElem(NULL, yymsp[-2].minor.yy333, &yymsp[0].minor.yy0);}
break;
case 191: /* sub ::= sub COMMA LP union RP ids */
{yylhsminor.yy328 = addSubqueryElem(yymsp[-5].minor.yy328, yymsp[-2].minor.yy525, &yymsp[0].minor.yy0);}
yymsp[-5].minor.yy328 = yylhsminor.yy328;
{yylhsminor.yy516 = addSubqueryElem(yymsp[-5].minor.yy516, yymsp[-2].minor.yy333, &yymsp[0].minor.yy0);}
yymsp[-5].minor.yy516 = yylhsminor.yy516;
break;
case 192: /* tablelist ::= ids cpxName */
{
yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
yylhsminor.yy328 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL);
yylhsminor.yy516 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL);
}
yymsp[-1].minor.yy328 = yylhsminor.yy328;
yymsp[-1].minor.yy516 = yylhsminor.yy516;
break;
case 193: /* tablelist ::= ids cpxName ids */
{
yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
yylhsminor.yy328 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
yylhsminor.yy516 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
}
yymsp[-2].minor.yy328 = yylhsminor.yy328;
yymsp[-2].minor.yy516 = yylhsminor.yy516;
break;
case 194: /* tablelist ::= tablelist COMMA ids cpxName */
{
yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
yylhsminor.yy328 = setTableNameList(yymsp[-3].minor.yy328, &yymsp[-1].minor.yy0, NULL);
yylhsminor.yy516 = setTableNameList(yymsp[-3].minor.yy516, &yymsp[-1].minor.yy0, NULL);
}
yymsp[-3].minor.yy328 = yylhsminor.yy328;
yymsp[-3].minor.yy516 = yylhsminor.yy516;
break;
case 195: /* tablelist ::= tablelist COMMA ids cpxName ids */
{
yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
yylhsminor.yy328 = setTableNameList(yymsp[-4].minor.yy328, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
yylhsminor.yy516 = setTableNameList(yymsp[-4].minor.yy516, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
}
yymsp[-4].minor.yy328 = yylhsminor.yy328;
yymsp[-4].minor.yy516 = yylhsminor.yy516;
break;
case 196: /* tmvar ::= VARIABLE */
{yylhsminor.yy0 = yymsp[0].minor.yy0;}
yymsp[0].minor.yy0 = yylhsminor.yy0;
break;
case 197: /* timestamp ::= INTEGER */
{ yylhsminor.yy142 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_INTEGER);}
yymsp[0].minor.yy142 = yylhsminor.yy142;
{ yylhsminor.yy194 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_INTEGER);}
yymsp[0].minor.yy194 = yylhsminor.yy194;
break;
case 198: /* timestamp ::= MINUS INTEGER */
case 199: /* timestamp ::= PLUS INTEGER */ yytestcase(yyruleno==199);
{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy142 = tSqlExprCreateTimestamp(&yymsp[-1].minor.yy0, TK_INTEGER);}
yymsp[-1].minor.yy142 = yylhsminor.yy142;
{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy194 = tSqlExprCreateTimestamp(&yymsp[-1].minor.yy0, TK_INTEGER);}
yymsp[-1].minor.yy194 = yylhsminor.yy194;
break;
case 200: /* timestamp ::= STRING */
{ yylhsminor.yy142 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_STRING);}
yymsp[0].minor.yy142 = yylhsminor.yy142;
{ yylhsminor.yy194 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_STRING);}
yymsp[0].minor.yy194 = yylhsminor.yy194;
break;
case 201: /* timestamp ::= NOW */
{ yylhsminor.yy142 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_NOW); }
yymsp[0].minor.yy142 = yylhsminor.yy142;
{ yylhsminor.yy194 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_NOW); }
yymsp[0].minor.yy194 = yylhsminor.yy194;
break;
case 202: /* timestamp ::= NOW PLUS VARIABLE */
{yymsp[-2].minor.yy142 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_PLUS); }
{yymsp[-2].minor.yy194 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_PLUS); }
break;
case 203: /* timestamp ::= NOW MINUS VARIABLE */
{yymsp[-2].minor.yy142 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_MINUS); }
{yymsp[-2].minor.yy194 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_MINUS); }
break;
case 204: /* range_option ::= */
{yymsp[1].minor.yy330.start = 0; yymsp[1].minor.yy330.end = 0;}
{yymsp[1].minor.yy132.start = 0; yymsp[1].minor.yy132.end = 0;}
break;
case 205: /* range_option ::= RANGE LP timestamp COMMA timestamp RP */
{yymsp[-5].minor.yy330.start = yymsp[-3].minor.yy142; yymsp[-5].minor.yy330.end = yymsp[-1].minor.yy142;}
{yymsp[-5].minor.yy132.start = yymsp[-3].minor.yy194; yymsp[-5].minor.yy132.end = yymsp[-1].minor.yy194;}
break;
case 206: /* interval_option ::= intervalKey LP tmvar RP */
{yylhsminor.yy238.interval = yymsp[-1].minor.yy0; yylhsminor.yy238.offset.n = 0; yylhsminor.yy238.token = yymsp[-3].minor.yy508;}
yymsp[-3].minor.yy238 = yylhsminor.yy238;
{yylhsminor.yy200.interval = yymsp[-1].minor.yy0; yylhsminor.yy200.offset.n = 0; yylhsminor.yy200.token = yymsp[-3].minor.yy44;}
yymsp[-3].minor.yy200 = yylhsminor.yy200;
break;
case 207: /* interval_option ::= intervalKey LP tmvar COMMA tmvar RP */
{yylhsminor.yy238.interval = yymsp[-3].minor.yy0; yylhsminor.yy238.offset = yymsp[-1].minor.yy0; yylhsminor.yy238.token = yymsp[-5].minor.yy508;}
yymsp[-5].minor.yy238 = yylhsminor.yy238;
{yylhsminor.yy200.interval = yymsp[-3].minor.yy0; yylhsminor.yy200.offset = yymsp[-1].minor.yy0; yylhsminor.yy200.token = yymsp[-5].minor.yy44;}
yymsp[-5].minor.yy200 = yylhsminor.yy200;
break;
case 208: /* interval_option ::= */
{memset(&yymsp[1].minor.yy238, 0, sizeof(yymsp[1].minor.yy238));}
{memset(&yymsp[1].minor.yy200, 0, sizeof(yymsp[1].minor.yy200));}
break;
case 209: /* intervalKey ::= INTERVAL */
{yymsp[0].minor.yy508 = TK_INTERVAL;}
{yymsp[0].minor.yy44 = TK_INTERVAL;}
break;
case 210: /* intervalKey ::= EVERY */
{yymsp[0].minor.yy508 = TK_EVERY; }
{yymsp[0].minor.yy44 = TK_EVERY; }
break;
case 211: /* session_option ::= */
{yymsp[1].minor.yy319.col.n = 0; yymsp[1].minor.yy319.gap.n = 0;}
{yymsp[1].minor.yy235.col.n = 0; yymsp[1].minor.yy235.gap.n = 0;}
break;
case 212: /* session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
yymsp[-6].minor.yy319.col = yymsp[-4].minor.yy0;
yymsp[-6].minor.yy319.gap = yymsp[-1].minor.yy0;
yymsp[-6].minor.yy235.col = yymsp[-4].minor.yy0;
yymsp[-6].minor.yy235.gap = yymsp[-1].minor.yy0;
}
break;
case 213: /* windowstate_option ::= */
{ yymsp[1].minor.yy546.col.n = 0; yymsp[1].minor.yy546.col.z = NULL;}
{ yymsp[1].minor.yy248.col.n = 0; yymsp[1].minor.yy248.col.z = NULL;}
break;
case 214: /* windowstate_option ::= STATE_WINDOW LP ids RP */
{ yymsp[-3].minor.yy546.col = yymsp[-1].minor.yy0; }
{ yymsp[-3].minor.yy248.col = yymsp[-1].minor.yy0; }
break;
case 215: /* fill_opt ::= */
{ yymsp[1].minor.yy525 = 0; }
{ yymsp[1].minor.yy333 = 0; }
break;
case 216: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
{
......@@ -3069,14 +3049,14 @@ static YYACTIONTYPE yy_reduce(
toTSDBType(yymsp[-3].minor.yy0.type);
tVariantCreate(&A, &yymsp[-3].minor.yy0);
tVariantListInsert(yymsp[-1].minor.yy525, &A, -1, 0);
yymsp[-5].minor.yy525 = yymsp[-1].minor.yy525;
tVariantListInsert(yymsp[-1].minor.yy333, &A, -1, 0);
yymsp[-5].minor.yy333 = yymsp[-1].minor.yy333;
}
break;
case 217: /* fill_opt ::= FILL LP ID RP */
{
toTSDBType(yymsp[-1].minor.yy0.type);
yymsp[-3].minor.yy525 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1, true);
yymsp[-3].minor.yy333 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1, true);
}
break;
case 218: /* sliding_opt ::= SLIDING LP tmvar RP */
......@@ -3086,313 +3066,317 @@ static YYACTIONTYPE yy_reduce(
{yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0; }
break;
case 221: /* orderby_opt ::= ORDER BY sortlist */
{yymsp[-2].minor.yy525 = yymsp[0].minor.yy525;}
{yymsp[-2].minor.yy333 = yymsp[0].minor.yy333;}
break;
case 222: /* sortlist ::= sortlist COMMA item sortorder */
{
yylhsminor.yy525 = commonItemAppend(yymsp[-3].minor.yy525, &yymsp[-1].minor.yy110, NULL, false, yymsp[0].minor.yy580);
yylhsminor.yy333 = commonItemAppend(yymsp[-3].minor.yy333, &yymsp[-1].minor.yy42, NULL, false, yymsp[0].minor.yy133);
}
yymsp[-3].minor.yy525 = yylhsminor.yy525;
yymsp[-3].minor.yy333 = yylhsminor.yy333;
break;
case 223: /* sortlist ::= sortlist COMMA arrow sortorder */
{
yylhsminor.yy525 = commonItemAppend(yymsp[-3].minor.yy525, NULL, yymsp[-1].minor.yy142, true, yymsp[0].minor.yy580);
yylhsminor.yy333 = commonItemAppend(yymsp[-3].minor.yy333, NULL, yymsp[-1].minor.yy194, true, yymsp[0].minor.yy133);
}
yymsp[-3].minor.yy525 = yylhsminor.yy525;
yymsp[-3].minor.yy333 = yylhsminor.yy333;
break;
case 224: /* sortlist ::= item sortorder */
{
yylhsminor.yy525 = commonItemAppend(NULL, &yymsp[-1].minor.yy110, NULL, false, yymsp[0].minor.yy580);
yylhsminor.yy333 = commonItemAppend(NULL, &yymsp[-1].minor.yy42, NULL, false, yymsp[0].minor.yy133);
}
yymsp[-1].minor.yy525 = yylhsminor.yy525;
yymsp[-1].minor.yy333 = yylhsminor.yy333;
break;
case 225: /* sortlist ::= arrow sortorder */
{
yylhsminor.yy525 = commonItemAppend(NULL, NULL, yymsp[-1].minor.yy142, true, yymsp[0].minor.yy580);
yylhsminor.yy333 = commonItemAppend(NULL, NULL, yymsp[-1].minor.yy194, true, yymsp[0].minor.yy133);
}
yymsp[-1].minor.yy525 = yylhsminor.yy525;
yymsp[-1].minor.yy333 = yylhsminor.yy333;
break;
case 226: /* item ::= ID */
{
toTSDBType(yymsp[0].minor.yy0.type);
tVariantCreate(&yylhsminor.yy110, &yymsp[0].minor.yy0);
tVariantCreate(&yylhsminor.yy42, &yymsp[0].minor.yy0);
}
yymsp[0].minor.yy110 = yylhsminor.yy110;
yymsp[0].minor.yy42 = yylhsminor.yy42;
break;
case 227: /* item ::= ID DOT ID */
{
toTSDBType(yymsp[-2].minor.yy0.type);
yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n);
tVariantCreate(&yylhsminor.yy110, &yymsp[-2].minor.yy0);
tVariantCreate(&yylhsminor.yy42, &yymsp[-2].minor.yy0);
}
yymsp[-2].minor.yy110 = yylhsminor.yy110;
yymsp[-2].minor.yy42 = yylhsminor.yy42;
break;
case 228: /* sortorder ::= ASC */
{ yymsp[0].minor.yy580 = TSDB_ORDER_ASC; }
{ yymsp[0].minor.yy133 = TSDB_ORDER_ASC; }
break;
case 229: /* sortorder ::= DESC */
{ yymsp[0].minor.yy580 = TSDB_ORDER_DESC;}
{ yymsp[0].minor.yy133 = TSDB_ORDER_DESC;}
break;
case 230: /* sortorder ::= */
{ yymsp[1].minor.yy580 = TSDB_ORDER_ASC; }
{ yymsp[1].minor.yy133 = TSDB_ORDER_ASC; }
break;
case 231: /* groupby_opt ::= */
{ yymsp[1].minor.yy525 = 0;}
{ yymsp[1].minor.yy333 = 0;}
break;
case 232: /* groupby_opt ::= GROUP BY grouplist */
{ yymsp[-2].minor.yy525 = yymsp[0].minor.yy525;}
{ yymsp[-2].minor.yy333 = yymsp[0].minor.yy333;}
break;
case 233: /* grouplist ::= grouplist COMMA item */
{
yylhsminor.yy525 = commonItemAppend(yymsp[-2].minor.yy525, &yymsp[0].minor.yy110, NULL, false, -1);
yylhsminor.yy333 = commonItemAppend(yymsp[-2].minor.yy333, &yymsp[0].minor.yy42, NULL, false, -1);
}
yymsp[-2].minor.yy525 = yylhsminor.yy525;
yymsp[-2].minor.yy333 = yylhsminor.yy333;
break;
case 234: /* grouplist ::= grouplist COMMA arrow */
{
yylhsminor.yy525 = commonItemAppend(yymsp[-2].minor.yy525, NULL, yymsp[0].minor.yy142, true, -1);
yylhsminor.yy333 = commonItemAppend(yymsp[-2].minor.yy333, NULL, yymsp[0].minor.yy194, true, -1);
}
yymsp[-2].minor.yy525 = yylhsminor.yy525;
yymsp[-2].minor.yy333 = yylhsminor.yy333;
break;
case 235: /* grouplist ::= item */
{
yylhsminor.yy525 = commonItemAppend(NULL, &yymsp[0].minor.yy110, NULL, false, -1);
yylhsminor.yy333 = commonItemAppend(NULL, &yymsp[0].minor.yy42, NULL, false, -1);
}
yymsp[0].minor.yy525 = yylhsminor.yy525;
yymsp[0].minor.yy333 = yylhsminor.yy333;
break;
case 236: /* grouplist ::= arrow */
{
yylhsminor.yy525 = commonItemAppend(NULL, NULL, yymsp[0].minor.yy142, true, -1);
yylhsminor.yy333 = commonItemAppend(NULL, NULL, yymsp[0].minor.yy194, true, -1);
}
yymsp[0].minor.yy525 = yylhsminor.yy525;
yymsp[0].minor.yy333 = yylhsminor.yy333;
break;
case 237: /* having_opt ::= */
case 247: /* where_opt ::= */ yytestcase(yyruleno==247);
case 298: /* expritem ::= */ yytestcase(yyruleno==298);
{yymsp[1].minor.yy142 = 0;}
case 299: /* expritem ::= */ yytestcase(yyruleno==299);
{yymsp[1].minor.yy194 = 0;}
break;
case 238: /* having_opt ::= HAVING expr */
case 248: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==248);
{yymsp[-1].minor.yy142 = yymsp[0].minor.yy142;}
{yymsp[-1].minor.yy194 = yymsp[0].minor.yy194;}
break;
case 239: /* limit_opt ::= */
case 243: /* slimit_opt ::= */ yytestcase(yyruleno==243);
{yymsp[1].minor.yy6.limit = -1; yymsp[1].minor.yy6.offset = 0;}
{yymsp[1].minor.yy190.limit = -1; yymsp[1].minor.yy190.offset = 0;}
break;
case 240: /* limit_opt ::= LIMIT signed */
case 244: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==244);
{yymsp[-1].minor.yy6.limit = yymsp[0].minor.yy543; yymsp[-1].minor.yy6.offset = 0;}
{yymsp[-1].minor.yy190.limit = yymsp[0].minor.yy277; yymsp[-1].minor.yy190.offset = 0;}
break;
case 241: /* limit_opt ::= LIMIT signed OFFSET signed */
{ yymsp[-3].minor.yy6.limit = yymsp[-2].minor.yy543; yymsp[-3].minor.yy6.offset = yymsp[0].minor.yy543;}
{ yymsp[-3].minor.yy190.limit = yymsp[-2].minor.yy277; yymsp[-3].minor.yy190.offset = yymsp[0].minor.yy277;}
break;
case 242: /* limit_opt ::= LIMIT signed COMMA signed */
{ yymsp[-3].minor.yy6.limit = yymsp[0].minor.yy543; yymsp[-3].minor.yy6.offset = yymsp[-2].minor.yy543;}
{ yymsp[-3].minor.yy190.limit = yymsp[0].minor.yy277; yymsp[-3].minor.yy190.offset = yymsp[-2].minor.yy277;}
break;
case 245: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
{yymsp[-3].minor.yy6.limit = yymsp[-2].minor.yy543; yymsp[-3].minor.yy6.offset = yymsp[0].minor.yy543;}
{yymsp[-3].minor.yy190.limit = yymsp[-2].minor.yy277; yymsp[-3].minor.yy190.offset = yymsp[0].minor.yy277;}
break;
case 246: /* slimit_opt ::= SLIMIT signed COMMA signed */
{yymsp[-3].minor.yy6.limit = yymsp[0].minor.yy543; yymsp[-3].minor.yy6.offset = yymsp[-2].minor.yy543;}
{yymsp[-3].minor.yy190.limit = yymsp[0].minor.yy277; yymsp[-3].minor.yy190.offset = yymsp[-2].minor.yy277;}
break;
case 249: /* expr ::= LP expr RP */
{yylhsminor.yy142 = yymsp[-1].minor.yy142; yylhsminor.yy142->exprToken.z = yymsp[-2].minor.yy0.z; yylhsminor.yy142->exprToken.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
yymsp[-2].minor.yy142 = yylhsminor.yy142;
{yylhsminor.yy194 = yymsp[-1].minor.yy194; yylhsminor.yy194->exprToken.z = yymsp[-2].minor.yy0.z; yylhsminor.yy194->exprToken.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 250: /* expr ::= ID */
{ yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_ID);}
yymsp[0].minor.yy142 = yylhsminor.yy142;
{ yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_ID);}
yymsp[0].minor.yy194 = yylhsminor.yy194;
break;
case 251: /* expr ::= ID DOT ID */
{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID);}
yymsp[-2].minor.yy142 = yylhsminor.yy142;
{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID);}
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 252: /* expr ::= ID DOT STAR */
{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ALL);}
yymsp[-2].minor.yy142 = yylhsminor.yy142;
{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ALL);}
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 253: /* expr ::= INTEGER */
{ yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_INTEGER);}
yymsp[0].minor.yy142 = yylhsminor.yy142;
{ yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_INTEGER);}
yymsp[0].minor.yy194 = yylhsminor.yy194;
break;
case 254: /* expr ::= MINUS INTEGER */
case 255: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==255);
{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_INTEGER);}
yymsp[-1].minor.yy142 = yylhsminor.yy142;
{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_INTEGER);}
yymsp[-1].minor.yy194 = yylhsminor.yy194;
break;
case 256: /* expr ::= FLOAT */
{ yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_FLOAT);}
yymsp[0].minor.yy142 = yylhsminor.yy142;
{ yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_FLOAT);}
yymsp[0].minor.yy194 = yylhsminor.yy194;
break;
case 257: /* expr ::= MINUS FLOAT */
case 258: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==258);
{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_FLOAT);}
yymsp[-1].minor.yy142 = yylhsminor.yy142;
{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_FLOAT);}
yymsp[-1].minor.yy194 = yylhsminor.yy194;
break;
case 259: /* expr ::= STRING */
{ yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING);}
yymsp[0].minor.yy142 = yylhsminor.yy142;
{ yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING);}
yymsp[0].minor.yy194 = yylhsminor.yy194;
break;
case 260: /* expr ::= NOW */
{ yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_NOW); }
yymsp[0].minor.yy142 = yylhsminor.yy142;
{ yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_NOW); }
yymsp[0].minor.yy194 = yylhsminor.yy194;
break;
case 261: /* expr ::= TODAY */
{ yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_TODAY); }
yymsp[0].minor.yy142 = yylhsminor.yy142;
{ yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_TODAY); }
yymsp[0].minor.yy194 = yylhsminor.yy194;
break;
case 262: /* expr ::= VARIABLE */
{ yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_VARIABLE);}
yymsp[0].minor.yy142 = yylhsminor.yy142;
{ yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_VARIABLE);}
yymsp[0].minor.yy194 = yylhsminor.yy194;
break;
case 263: /* expr ::= PLUS VARIABLE */
case 264: /* expr ::= MINUS VARIABLE */ yytestcase(yyruleno==264);
{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_VARIABLE; yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_VARIABLE);}
yymsp[-1].minor.yy142 = yylhsminor.yy142;
{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_VARIABLE; yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_VARIABLE);}
yymsp[-1].minor.yy194 = yylhsminor.yy194;
break;
case 265: /* expr ::= BOOL */
{ yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_BOOL);}
yymsp[0].minor.yy142 = yylhsminor.yy142;
{ yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_BOOL);}
yymsp[0].minor.yy194 = yylhsminor.yy194;
break;
case 266: /* expr ::= NULL */
{ yylhsminor.yy142 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_NULL);}
yymsp[0].minor.yy142 = yylhsminor.yy142;
{ yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_NULL);}
yymsp[0].minor.yy194 = yylhsminor.yy194;
break;
case 267: /* expr ::= ID LP exprlist RP */
{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy142 = tSqlExprCreateFunction(yymsp[-1].minor.yy525, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
yymsp[-3].minor.yy142 = yylhsminor.yy142;
{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy194 = tSqlExprCreateFunction(yymsp[-1].minor.yy333, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
yymsp[-3].minor.yy194 = yylhsminor.yy194;
break;
case 268: /* expr ::= ID LP STAR RP */
{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy142 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
yymsp[-3].minor.yy142 = yylhsminor.yy142;
{ tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy194 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
yymsp[-3].minor.yy194 = yylhsminor.yy194;
break;
case 269: /* expr ::= ID LP expr AS typename RP */
{ tStrTokenAppend(pInfo->funcs, &yymsp[-5].minor.yy0); yylhsminor.yy142 = tSqlExprCreateFuncWithParams(pInfo, yymsp[-3].minor.yy142, &yymsp[-1].minor.yy115, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, yymsp[-5].minor.yy0.type); }
yymsp[-5].minor.yy142 = yylhsminor.yy142;
{ tStrTokenAppend(pInfo->funcs, &yymsp[-5].minor.yy0); yylhsminor.yy194 = tSqlExprCreateFuncWithParams(pInfo, yymsp[-3].minor.yy194, &yymsp[-1].minor.yy263, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, yymsp[-5].minor.yy0.type); }
yymsp[-5].minor.yy194 = yylhsminor.yy194;
break;
case 270: /* expr ::= expr IS NULL */
{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, NULL, TK_ISNULL);}
yymsp[-2].minor.yy142 = yylhsminor.yy142;
{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, NULL, TK_ISNULL);}
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 271: /* expr ::= expr IS NOT NULL */
{yylhsminor.yy142 = tSqlExprCreate(yymsp[-3].minor.yy142, NULL, TK_NOTNULL);}
yymsp[-3].minor.yy142 = yylhsminor.yy142;
{yylhsminor.yy194 = tSqlExprCreate(yymsp[-3].minor.yy194, NULL, TK_NOTNULL);}
yymsp[-3].minor.yy194 = yylhsminor.yy194;
break;
case 272: /* expr ::= expr LT expr */
{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_LT);}
yymsp[-2].minor.yy142 = yylhsminor.yy142;
{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_LT);}
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 273: /* expr ::= expr GT expr */
{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_GT);}
yymsp[-2].minor.yy142 = yylhsminor.yy142;
{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_GT);}
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 274: /* expr ::= expr LE expr */
{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_LE);}
yymsp[-2].minor.yy142 = yylhsminor.yy142;
{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_LE);}
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 275: /* expr ::= expr GE expr */
{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_GE);}
yymsp[-2].minor.yy142 = yylhsminor.yy142;
{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_GE);}
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 276: /* expr ::= expr NE expr */
{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_NE);}
yymsp[-2].minor.yy142 = yylhsminor.yy142;
{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_NE);}
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 277: /* expr ::= expr EQ expr */
{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_EQ);}
yymsp[-2].minor.yy142 = yylhsminor.yy142;
{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_EQ);}
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 278: /* expr ::= expr BETWEEN expr AND expr */
{ tSqlExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy142); yylhsminor.yy142 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy142, yymsp[-2].minor.yy142, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy142, TK_LE), TK_AND);}
yymsp[-4].minor.yy142 = yylhsminor.yy142;
{ tSqlExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy194); yylhsminor.yy194 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy194, yymsp[-2].minor.yy194, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy194, TK_LE), TK_AND);}
yymsp[-4].minor.yy194 = yylhsminor.yy194;
break;
case 279: /* expr ::= expr AND expr */
{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_AND);}
yymsp[-2].minor.yy142 = yylhsminor.yy142;
{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_AND);}
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 280: /* expr ::= expr OR expr */
{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_OR); }
yymsp[-2].minor.yy142 = yylhsminor.yy142;
{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_OR); }
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 281: /* expr ::= expr PLUS expr */
{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_PLUS); }
yymsp[-2].minor.yy142 = yylhsminor.yy142;
{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_PLUS); }
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 282: /* expr ::= expr MINUS expr */
{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_MINUS); }
yymsp[-2].minor.yy142 = yylhsminor.yy142;
{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_MINUS); }
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 283: /* expr ::= expr STAR expr */
{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_STAR); }
yymsp[-2].minor.yy142 = yylhsminor.yy142;
{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_STAR); }
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 284: /* expr ::= expr SLASH expr */
{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_DIVIDE);}
yymsp[-2].minor.yy142 = yylhsminor.yy142;
{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_DIVIDE);}
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 285: /* expr ::= expr REM expr */
{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_REM); }
yymsp[-2].minor.yy142 = yylhsminor.yy142;
{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_REM); }
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 286: /* expr ::= expr BITAND expr */
{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_BITAND);}
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 286: /* expr ::= expr LIKE expr */
{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_LIKE); }
yymsp[-2].minor.yy142 = yylhsminor.yy142;
case 287: /* expr ::= expr LIKE expr */
{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_LIKE); }
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 287: /* expr ::= expr MATCH expr */
{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_MATCH); }
yymsp[-2].minor.yy142 = yylhsminor.yy142;
case 288: /* expr ::= expr MATCH expr */
{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_MATCH); }
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 288: /* expr ::= expr NMATCH expr */
{yylhsminor.yy142 = tSqlExprCreate(yymsp[-2].minor.yy142, yymsp[0].minor.yy142, TK_NMATCH); }
yymsp[-2].minor.yy142 = yylhsminor.yy142;
case 289: /* expr ::= expr NMATCH expr */
{yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_NMATCH); }
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 289: /* expr ::= ID CONTAINS STRING */
{ tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy142 = tSqlExprCreate(S, M, TK_CONTAINS); }
yymsp[-2].minor.yy142 = yylhsminor.yy142;
case 290: /* expr ::= ID CONTAINS STRING */
{ tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy194 = tSqlExprCreate(S, M, TK_CONTAINS); }
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 290: /* expr ::= ID DOT ID CONTAINS STRING */
{ yymsp[-4].minor.yy0.n += (1+yymsp[-2].minor.yy0.n); tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-4].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy142 = tSqlExprCreate(S, M, TK_CONTAINS); }
yymsp[-4].minor.yy142 = yylhsminor.yy142;
case 291: /* expr ::= ID DOT ID CONTAINS STRING */
{ yymsp[-4].minor.yy0.n += (1+yymsp[-2].minor.yy0.n); tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-4].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy194 = tSqlExprCreate(S, M, TK_CONTAINS); }
yymsp[-4].minor.yy194 = yylhsminor.yy194;
break;
case 291: /* arrow ::= ID ARROW STRING */
{tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy142 = tSqlExprCreate(S, M, TK_ARROW); }
yymsp[-2].minor.yy142 = yylhsminor.yy142;
case 292: /* arrow ::= ID ARROW STRING */
{tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy194 = tSqlExprCreate(S, M, TK_ARROW); }
yymsp[-2].minor.yy194 = yylhsminor.yy194;
break;
case 292: /* arrow ::= ID DOT ID ARROW STRING */
{yymsp[-4].minor.yy0.n += (1+yymsp[-2].minor.yy0.n); tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-4].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy142 = tSqlExprCreate(S, M, TK_ARROW); }
yymsp[-4].minor.yy142 = yylhsminor.yy142;
case 293: /* arrow ::= ID DOT ID ARROW STRING */
{yymsp[-4].minor.yy0.n += (1+yymsp[-2].minor.yy0.n); tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-4].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy194 = tSqlExprCreate(S, M, TK_ARROW); }
yymsp[-4].minor.yy194 = yylhsminor.yy194;
break;
case 293: /* expr ::= arrow */
case 297: /* expritem ::= expr */ yytestcase(yyruleno==297);
{yylhsminor.yy142 = yymsp[0].minor.yy142;}
yymsp[0].minor.yy142 = yylhsminor.yy142;
case 294: /* expr ::= arrow */
case 298: /* expritem ::= expr */ yytestcase(yyruleno==298);
{yylhsminor.yy194 = yymsp[0].minor.yy194;}
yymsp[0].minor.yy194 = yylhsminor.yy194;
break;
case 294: /* expr ::= expr IN LP exprlist RP */
{yylhsminor.yy142 = tSqlExprCreate(yymsp[-4].minor.yy142, (tSqlExpr*)yymsp[-1].minor.yy525, TK_IN); }
yymsp[-4].minor.yy142 = yylhsminor.yy142;
case 295: /* expr ::= expr IN LP exprlist RP */
{yylhsminor.yy194 = tSqlExprCreate(yymsp[-4].minor.yy194, (tSqlExpr*)yymsp[-1].minor.yy333, TK_IN); }
yymsp[-4].minor.yy194 = yylhsminor.yy194;
break;
case 295: /* exprlist ::= exprlist COMMA expritem */
{yylhsminor.yy525 = tSqlExprListAppend(yymsp[-2].minor.yy525,yymsp[0].minor.yy142,0, 0);}
yymsp[-2].minor.yy525 = yylhsminor.yy525;
case 296: /* exprlist ::= exprlist COMMA expritem */
{yylhsminor.yy333 = tSqlExprListAppend(yymsp[-2].minor.yy333,yymsp[0].minor.yy194,0, 0);}
yymsp[-2].minor.yy333 = yylhsminor.yy333;
break;
case 296: /* exprlist ::= expritem */
{yylhsminor.yy525 = tSqlExprListAppend(0,yymsp[0].minor.yy142,0, 0);}
yymsp[0].minor.yy525 = yylhsminor.yy525;
case 297: /* exprlist ::= expritem */
{yylhsminor.yy333 = tSqlExprListAppend(0,yymsp[0].minor.yy194,0, 0);}
yymsp[0].minor.yy333 = yylhsminor.yy333;
break;
case 299: /* cmd ::= RESET QUERY CACHE */
case 300: /* cmd ::= RESET QUERY CACHE */
{ setDCLSqlElems(pInfo, TSDB_SQL_RESET_CACHE, 0);}
break;
case 300: /* cmd ::= SYNCDB ids REPLICA */
case 301: /* cmd ::= SYNCDB ids REPLICA */
{ setDCLSqlElems(pInfo, TSDB_SQL_SYNC_DB_REPLICA, 1, &yymsp[-1].minor.yy0);}
break;
case 301: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
case 302: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1);
SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1);
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 302: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
case 303: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
......@@ -3403,21 +3387,21 @@ static YYACTIONTYPE yy_reduce(
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 303: /* cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
case 304: /* cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1);
SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1);
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 304: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
case 305: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1);
SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1);
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 305: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
case 306: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
......@@ -3428,7 +3412,7 @@ static YYACTIONTYPE yy_reduce(
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 306: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
case 307: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
{
yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
......@@ -3442,33 +3426,33 @@ static YYACTIONTYPE yy_reduce(
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 307: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
case 308: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
{
yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n;
toTSDBType(yymsp[-2].minor.yy0.type);
SArray* A = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1, false);
A = tVariantListAppend(A, &yymsp[0].minor.yy110, -1);
A = tVariantListAppend(A, &yymsp[0].minor.yy42, -1);
SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, -1);
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 308: /* cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
case 309: /* cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, -1);
SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, -1);
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 309: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
case 310: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE);
SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE);
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 310: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
case 311: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
......@@ -3479,21 +3463,21 @@ static YYACTIONTYPE yy_reduce(
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 311: /* cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
case 312: /* cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE);
SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE);
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 312: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
case 313: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE);
SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE);
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 313: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
case 314: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
......@@ -3504,7 +3488,7 @@ static YYACTIONTYPE yy_reduce(
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 314: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
case 315: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
{
yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
......@@ -3518,38 +3502,38 @@ static YYACTIONTYPE yy_reduce(
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 315: /* cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
case 316: /* cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */
{
yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n;
toTSDBType(yymsp[-2].minor.yy0.type);
SArray* A = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1, false);
A = tVariantListAppend(A, &yymsp[0].minor.yy110, -1);
A = tVariantListAppend(A, &yymsp[0].minor.yy42, -1);
SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, TSDB_SUPER_TABLE);
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 316: /* cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
case 317: /* cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */
{
yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy525, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, TSDB_SUPER_TABLE);
SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, TSDB_SUPER_TABLE);
setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
}
break;
case 317: /* cmd ::= KILL CONNECTION INTEGER */
case 318: /* cmd ::= KILL CONNECTION INTEGER */
{setKillSql(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);}
break;
case 318: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
case 319: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
{yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_STREAM, &yymsp[-2].minor.yy0);}
break;
case 319: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
case 320: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
{yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_QUERY, &yymsp[-2].minor.yy0);}
break;
case 320: /* cmd ::= DELETE FROM ifexists ids cpxName where_opt */
case 321: /* cmd ::= DELETE FROM ifexists ids cpxName where_opt */
{
yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
SDelData * pDelData = tGetDelData(&yymsp[-2].minor.yy0, &yymsp[-3].minor.yy0, yymsp[0].minor.yy142);
SDelData * pDelData = tGetDelData(&yymsp[-2].minor.yy0, &yymsp[-3].minor.yy0, yymsp[0].minor.yy194);
setSqlInfo(pInfo, pDelData, NULL, TSDB_SQL_DELETE_DATA);
}
break;
......@@ -3574,7 +3558,6 @@ static YYACTIONTYPE yy_reduce(
yymsp->stateno = (YYACTIONTYPE)yyact;
yymsp->major = (YYCODETYPE)yygoto;
yyTraceShift(yypParser, yyact, "... then shift");
return yyact;
}
/*
......@@ -3584,8 +3567,7 @@ static YYACTIONTYPE yy_reduce(
static void yy_parse_failed(
yyParser *yypParser /* The parser */
){
ParseARG_FETCH
ParseCTX_FETCH
ParseARG_FETCH;
#ifndef NDEBUG
if( yyTraceFILE ){
fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);
......@@ -3596,8 +3578,7 @@ static void yy_parse_failed(
** parser fails */
/************ Begin %parse_failure code ***************************************/
/************ End %parse_failure code *****************************************/
ParseARG_STORE /* Suppress warning about unused %extra_argument variable */
ParseCTX_STORE
ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
}
#endif /* YYNOERRORRECOVERY */
......@@ -3609,8 +3590,7 @@ static void yy_syntax_error(
int yymajor, /* The major type of the error token */
ParseTOKENTYPE yyminor /* The minor type of the error token */
){
ParseARG_FETCH
ParseCTX_FETCH
ParseARG_FETCH;
#define TOKEN yyminor
/************ Begin %syntax_error code ****************************************/
......@@ -3636,8 +3616,7 @@ static void yy_syntax_error(
assert(len <= outputBufLen);
/************ End %syntax_error code ******************************************/
ParseARG_STORE /* Suppress warning about unused %extra_argument variable */
ParseCTX_STORE
ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
}
/*
......@@ -3646,8 +3625,7 @@ static void yy_syntax_error(
static void yy_accept(
yyParser *yypParser /* The parser */
){
ParseARG_FETCH
ParseCTX_FETCH
ParseARG_FETCH;
#ifndef NDEBUG
if( yyTraceFILE ){
fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
......@@ -3662,8 +3640,7 @@ static void yy_accept(
/*********** Begin %parse_accept code *****************************************/
/*********** End %parse_accept code *******************************************/
ParseARG_STORE /* Suppress warning about unused %extra_argument variable */
ParseCTX_STORE
ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */
}
/* The main parser program.
......@@ -3692,47 +3669,45 @@ void Parse(
ParseARG_PDECL /* Optional %extra_argument parameter */
){
YYMINORTYPE yyminorunion;
YYACTIONTYPE yyact; /* The parser action. */
unsigned int yyact; /* The parser action. */
#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
int yyendofinput; /* True if we are at the end of input */
#endif
#ifdef YYERRORSYMBOL
int yyerrorhit = 0; /* True if yymajor has invoked an error */
#endif
yyParser *yypParser = (yyParser*)yyp; /* The parser */
ParseCTX_FETCH
ParseARG_STORE
yyParser *yypParser; /* The parser */
yypParser = (yyParser*)yyp;
assert( yypParser->yytos!=0 );
#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
yyendofinput = (yymajor==0);
#endif
ParseARG_STORE;
yyact = yypParser->yytos->stateno;
#ifndef NDEBUG
if( yyTraceFILE ){
if( yyact < YY_MIN_REDUCE ){
int stateno = yypParser->yytos->stateno;
if( stateno < YY_MIN_REDUCE ){
fprintf(yyTraceFILE,"%sInput '%s' in state %d\n",
yyTracePrompt,yyTokenName[yymajor],yyact);
yyTracePrompt,yyTokenName[yymajor],stateno);
}else{
fprintf(yyTraceFILE,"%sInput '%s' with pending reduce %d\n",
yyTracePrompt,yyTokenName[yymajor],yyact-YY_MIN_REDUCE);
yyTracePrompt,yyTokenName[yymajor],stateno-YY_MIN_REDUCE);
}
}
#endif
do{
assert( yyact==yypParser->yytos->stateno );
yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact);
yyact = yy_find_shift_action(yypParser,(YYCODETYPE)yymajor);
if( yyact >= YY_MIN_REDUCE ){
yyact = yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor,
yyminor ParseCTX_PARAM);
yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor,yyminor);
}else if( yyact <= YY_MAX_SHIFTREDUCE ){
yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor);
yy_shift(yypParser,yyact,yymajor,yyminor);
#ifndef YYNOERRORRECOVERY
yypParser->yyerrcnt--;
#endif
break;
yymajor = YYNOCODE;
}else if( yyact==YY_ACCEPT_ACTION ){
yypParser->yytos--;
yy_accept(yypParser);
......@@ -3783,9 +3758,10 @@ void Parse(
yymajor = YYNOCODE;
}else{
while( yypParser->yytos >= yypParser->yystack
&& yymx != YYERRORSYMBOL
&& (yyact = yy_find_reduce_action(
yypParser->yytos->stateno,
YYERRORSYMBOL)) > YY_MAX_SHIFTREDUCE
YYERRORSYMBOL)) >= YY_MIN_REDUCE
){
yy_pop_parser_stack(yypParser);
}
......@@ -3802,8 +3778,6 @@ void Parse(
}
yypParser->yyerrcnt = 3;
yyerrorhit = 1;
if( yymajor==YYNOCODE ) break;
yyact = yypParser->yytos->stateno;
#elif defined(YYNOERRORRECOVERY)
/* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
** do any kind of error recovery. Instead, simply invoke the syntax
......@@ -3814,7 +3788,8 @@ void Parse(
*/
yy_syntax_error(yypParser,yymajor, yyminor);
yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
break;
yymajor = YYNOCODE;
#else /* YYERRORSYMBOL is not defined */
/* This is what we do if the grammar does not define ERROR:
**
......@@ -3836,10 +3811,10 @@ void Parse(
yypParser->yyerrcnt = -1;
#endif
}
break;
yymajor = YYNOCODE;
#endif
}
}while( yypParser->yytos>yypParser->yystack );
}while( yymajor!=YYNOCODE && yypParser->yytos>yypParser->yystack );
#ifndef NDEBUG
if( yyTraceFILE ){
yyStackEntry *i;
......@@ -3854,18 +3829,3 @@ void Parse(
#endif
return;
}
/*
** Return the fallback token corresponding to canonical token iToken, or
** 0 if iToken has no fallback.
*/
int ParseFallback(int iToken){
#ifdef YYFALLBACK
if( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) ){
return yyFallback[iToken];
}
#else
(void)iToken;
#endif
return 0;
}
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册