docs.md 79.4 KB
Newer Older
X
Xiaxin Li 已提交
1 2
# TAOS SQL

3
本文档说明 TAOS SQL 支持的语法规则、主要查询功能、支持的 SQL 查询函数,以及常用技巧等内容。阅读本文档需要读者具有基本的 SQL 语言的基础。
X
Xiaxin Li 已提交
4

5
TAOS SQL 是用户对 TDengine 进行数据写入和查询的主要工具。TAOS SQL 为了便于用户快速上手,在一定程度上提供类似于标准 SQL 类似的风格和模式。严格意义上,TAOS SQL 并不是也不试图提供 SQL 标准的语法。此外,由于 TDengine 针对的时序性结构化数据不提供删除功能,因此在 TAO SQL 中不提供数据删除的相关功能。
X
Xiaxin Li 已提交
6

7
TAOS SQL 不支持关键字的缩写,例如 DESCRIBE 不能缩写为 DESC。 
X
Xiaxin Li 已提交
8

9 10 11
本章节 SQL 语法遵循如下约定:

- < > 里的内容是用户需要输入的,但不要输入 <> 本身
12
- \[ \] 表示内容为可选项,但不能输入 [] 本身
13
- | 表示多选一,选择其中一个即可,但不能输入 | 本身
X
Xiaxin Li 已提交
14 15
- … 表示前面的项可重复多个

16
为更好地说明 SQL 语法的规则及其特点,本文假设存在一个数据集。以智能电表(meters)为例,假设每个智能电表采集电流、电压、相位三个量。其建模如下:
X
Xiaxin Li 已提交
17 18 19 20 21 22 23 24 25 26 27
```mysql
taos> DESCRIBE meters;
             Field              |        Type        |   Length    |    Note    |
=================================================================================
 ts                             | TIMESTAMP          |           8 |            |
 current                        | FLOAT              |           4 |            |
 voltage                        | INT                |           4 |            |
 phase                          | FLOAT              |           4 |            |
 location                       | BINARY             |          64 | TAG        |
 groupid                        | INT                |           4 | TAG        |
```
28
数据集包含 4 个智能电表的数据,按照 TDengine 的建模规则,对应 4 个子表,其名称分别是 d1001, d1002, d1003, d1004。
X
Xiaxin Li 已提交
29

30
## <a class="anchor" id="data-type"></a>支持的数据类型
X
Xiaxin Li 已提交
31

32
使用 TDengine,最重要的是时间戳。创建并插入记录、查询历史记录的时候,均需要指定时间戳。时间戳有如下规则:
X
Xiaxin Li 已提交
33

34 35 36
- 时间格式为 ```YYYY-MM-DD HH:mm:ss.MS```,默认时间分辨率为毫秒。比如:```2017-08-12 18:25:58.128```
- 内部函数 now 是客户端的当前时间
- 插入记录时,如果时间戳为 now,插入数据时使用提交这条记录的客户端的当前时间
37
- Epoch Time:时间戳也可以是一个长整数,表示从格林威治时间 1970-01-01 00:00:00.000 (UTC/GMT) 开始的毫秒数(相应地,如果所在 Database 的时间精度设置为“微秒”,则长整型格式的时间戳含义也就对应于从格林威治时间 1970-01-01 00:00:00.000 (UTC/GMT) 开始的微秒数;纳秒精度的逻辑也是类似的。)
K
kartist 已提交
38
- 时间可以加减,比如 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(自然年)。
X
Xiaxin Li 已提交
39

40
TDengine 缺省的时间戳是毫秒精度,但通过在 CREATE DATABASE 时传递的 PRECISION 参数就可以支持微秒和纳秒。(从 2.1.5.0 版本开始支持纳秒精度)
X
Xiaxin Li 已提交
41

42
在TDengine中,普通表的数据模型中可使用以下 10 种数据类型。 
X
Xiaxin Li 已提交
43

44
| #    | **类型**          | **Bytes** | **说明**                                                     |
X
Xiaxin Li 已提交
45
| ---- | :-------: | ------ | ------------------------------------------------------------ |
46
| 1    | TIMESTAMP | 8      | 时间戳。缺省精度毫秒,可支持微秒和纳秒。从格林威治时间 1970-01-01 00:00:00.000 (UTC/GMT) 开始,计时不能早于该时间。(从 2.0.18.0 版本开始,已经去除了这一时间范围限制)(从 2.1.5.0 版本开始支持纳秒精度) |
47 48 49 50
| 2    |    INT    | 4      | 整型,范围 [-2^31+1,   2^31-1], -2^31 用作 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]      |
51
| 6    |  BINARY   | 自定义 | 记录单字节字符串,建议只用于处理 ASCII 可见字符,中文等多字节字符需使用 nchar。理论上,最长可以有 16374 字节,但由于每行数据最多 16K 字节,实际上限一般小于理论值。binary 仅支持字符串输入,字符串两端需使用单引号引用。使用时须指定大小,如 binary(20) 定义了最长为 20 个单字节字符的字符串,每个字符占 1 byte 的存储空间,总共固定占用 20 bytes 的空间,此时如果用户字符串超出 20 字节将会报错。对于字符串内的单引号,可以用转义字符反斜线加单引号来表示,即 `\’`。 |
52 53 54
| 7    | SMALLINT  | 2      | 短整型, 范围 [-32767, 32767], -32768 用于 NULL                                |
| 8    |  TINYINT  | 1      | 单字节整型,范围 [-127, 127], -128 用于 NULL                                |
| 9    |   BOOL    | 1      | 布尔型,{true, false}                                      |
55
| 10   |   NCHAR   | 自定义 | 记录包含多字节字符在内的字符串,如中文字符。每个 nchar 字符占用 4 bytes 的存储空间。字符串两端使用单引号引用,字符串内的单引号需用转义字符 `\’`。nchar 使用时须指定字符串大小,类型为 nchar(10) 的列表示此列的字符串最多存储 10 个 nchar 字符,会固定占用 40 bytes 的空间。如果用户字符串长度超出声明长度,将会报错。 |
56
<!-- REPLACE_OPEN_TO_ENTERPRISE__COLUMN_TYPE_ADDONS -->
57 58 59

**Tips**:
1. TDengine 对 SQL 语句中的英文字符不区分大小写,自动转化为小写执行。因此用户大小写敏感的字符串及密码,需要使用单引号将字符串引起来。
60
2. **注意**,虽然 Binary 类型在底层存储上支持字节型的二进制字符,但不同编程语言对二进制数据的处理方式并不保证一致,因此建议在 Binary 类型中只存储 ASCII 可见字符,而避免存储不可见字符。多字节的数据,例如中文字符,则需要使用 nchar 类型进行保存。如果强行使用 Binary 类型保存中文字符,虽然有时也能正常读写,但并不带有字符集信息,很容易出现数据乱码甚至数据损坏等情况。
X
Xiaxin Li 已提交
61

62
## <a class="anchor" id="management"></a>数据库管理
X
Xiaxin Li 已提交
63 64

- **创建数据库**  
65

66
    ```mysql
67
    CREATE DATABASE [IF NOT EXISTS] db_name [KEEP keep] [DAYS days] [UPDATE 1];
68
    ```
69
    说明:<!-- 注意:上一行中的 SQL 语句在企业版文档中会被替换,因此修改此语句的话,需要修改企业版文档的替换字典键值!! -->
70

71
    1) KEEP是该数据库的数据保留多长天数,缺省是3650天(10年),数据库会自动删除超过时限的数据;<!-- REPLACE_OPEN_TO_ENTERPRISE__KEEP_PARAM_DESCRIPTION -->
72

73
    2) UPDATE 标志数据库支持更新相同时间戳数据;(从 2.1.7.0 版本开始此参数支持设为 2,表示允许部分列更新,也即更新数据行时未被设置的列会保留原值。)(从 2.0.8.0 版本开始支持此参数。注意此参数不能通过 `ALTER DATABASE` 指令进行修改。)
74 75 76 77 78

        1) UPDATE设为0时,表示不允许更新数据,后发送的相同时间戳的数据会被直接丢弃;
        
        2) UPDATE设为1时,表示更新全部列数据,即如果更新一个数据行,其中某些列没有提供取值,那么这些列会被设为 NULL;
        
涛思数据(TDengine)'s avatar
涛思数据(TDengine) 已提交
79 80 81
        3) UPDATE设为2时,表示支持更新部分列数据,即如果更新一个数据行,其中某些列没有提供取值,那么这些列会保持原有数据行中的对应值;
        
        4) 更多关于UPDATE参数的用法,请参考[FAQ](https://www.taosdata.com/cn/documentation/faq)。
82

83
    3) 数据库名最大长度为33;
84

85
    4) 一条SQL 语句的最大长度为65480个字符;
86

87
    5) 数据库还有更多与存储相关的配置参数,请参见 [服务端配置](https://www.taosdata.com/cn/documentation/administrator#config) 章节。
88 89 90

- **显示系统当前参数**

91 92 93
    ```mysql
    SHOW VARIABLES;
    ```
X
Xiaxin Li 已提交
94 95

- **使用数据库**
96

X
Xiaxin Li 已提交
97
    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
98
    USE db_name;
X
Xiaxin Li 已提交
99
    ```
100
    使用/切换数据库(在 RESTful 连接方式下无效)。
X
Xiaxin Li 已提交
101 102 103

- **删除数据库**
    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
104
    DROP DATABASE [IF EXISTS] db_name;
X
Xiaxin Li 已提交
105
    ```
106
    删除数据库。指定 Database 所包含的全部数据表将被删除,谨慎使用!
X
Xiaxin Li 已提交
107

108 109 110 111
- **修改数据库参数**
    ```mysql
    ALTER DATABASE db_name COMP 2;
    ```
112
    COMP 参数是指修改数据库文件压缩标志位,缺省值为 2,取值范围为 [0, 2]。0 表示不压缩,1 表示一阶段压缩,2 表示两阶段压缩。
113 114 115 116

    ```mysql
    ALTER DATABASE db_name REPLICA 2;
    ```
117
    REPLICA 参数是指修改数据库副本数,取值范围 [1, 3]。在集群中使用,副本数必须小于或等于 DNODE 的数目。
118

119 120 121
    ```mysql
    ALTER DATABASE db_name KEEP 365;
    ```
122
    KEEP 参数是指修改数据文件保存的天数,缺省值为 3650,取值范围 [days, 365000],必须大于或等于 days 参数值。
123 124

    ```mysql
125
    ALTER DATABASE db_name QUORUM 2;
126
    ```
L
liuyq-617 已提交
127
    QUORUM 参数是指数据写入成功所需要的确认数,取值范围 [1, 2]。对于异步复制,quorum 设为 1,具有 master 角色的虚拟节点自己确认即可。对于同步复制,quorum 设为 2。原则上,Quorum >= 1 并且 Quorum <= replica(副本数),这个参数在启动一个同步模块实例时需要提供。
128 129

    ```mysql
130
    ALTER DATABASE db_name BLOCKS 100;
131
    ```
132 133 134 135 136
    BLOCKS 参数是每个 VNODE (TSDB) 中有多少 cache 大小的内存块,因此一个 VNODE 的用的内存大小粗略为(cache * blocks)。取值范围 [3, 1000]。

    ```mysql
    ALTER DATABASE db_name CACHELAST 0;
    ```
137
    CACHELAST 参数控制是否在内存中缓存子表的最近数据。缺省值为 0,取值范围 [0, 1, 2, 3]。其中 0 表示不缓存,1 表示缓存子表最近一行数据,2 表示缓存子表每一列的最近的非 NULL 值,3 表示同时打开缓存最近行和列功能。(从 2.0.11.0 版本开始支持参数值 [0, 1],从 2.1.2.0 版本开始支持参数值 [0, 1, 2, 3]。)  
138
    说明:缓存最近行,将显著改善 LAST_ROW 函数的性能表现;缓存每列的最近非 NULL 值,将显著改善无特殊影响(WHERE、ORDER BY、GROUP BY、INTERVAL)下的 LAST 函数的性能表现。
139

140
    **Tips**: 以上所有参数修改后都可以用show databases来确认是否修改成功。另外,从 2.1.3.0 版本开始,修改这些参数后无需重启服务器即可生效。
X
Xiaxin Li 已提交
141 142

- **显示系统所有数据库**
143

X
Xiaxin Li 已提交
144
    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
145
    SHOW DATABASES;
X
Xiaxin Li 已提交
146 147
    ```

148 149 150 151 152 153 154 155
- **显示一个数据库的创建语句**

    ```mysql
    SHOW CREATE DATABASE db_name;
    ```
    常用于数据库迁移。对一个已经存在的数据库,返回其创建语句;在另一个集群中执行该语句,就能得到一个设置完全相同的 Database。


156 157
## <a class="anchor" id="table"></a>表管理

X
Xiaxin Li 已提交
158
- **创建数据表**
159

X
Xiaxin Li 已提交
160
    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
161
    CREATE TABLE [IF NOT EXISTS] tb_name (timestamp_field_name TIMESTAMP, field1_name data_type1 [, field2_name data_type2 ...]);
X
Xiaxin Li 已提交
162 163
    ```
    说明:
164

165
    1) 表的第一个字段必须是 TIMESTAMP,并且系统自动将其设为主键;
166

167
    2) 表名最大长度为 192;
168

169
    3) 表的每行长度不能超过 16k 个字符;(注意:每个 BINARY/NCHAR 类型的列还会额外占用 2 个字节的存储位置)
170

H
Hui Li 已提交
171
    4) 子表名只能由字母、数字和下划线组成,且不能以数字开头,不区分大小写
172

173
    5) 使用数据类型 binary 或 nchar,需指定其最长的字节数,如 binary(20),表示 20 字节;
X
xiangyang guo 已提交
174
    
H
Hui Li 已提交
175 176
    6) 为了兼容支持更多形式的表名,TDengine 引入新的转义符 "\`",可以让表名与关键词不冲突,同时不受限于上述表名称合法性约束检查。但是同样具有长度限制要求。使用转义字符以后,不再对转义字符中的内容进行大小写统一。
    例如:\`aBc\` 和 \`abc\` 是不同的表名,但是 abc 和 aBc 是相同的表名。
H
Hui Li 已提交
177 178 179
    需要注意的是转义字符中的内容必须是可打印字符。
    上述的操作逻辑和约束要求与MySQL数据的操作一致。
    从 2.3.0.0 版本开始支持这种方式。
180

181
- **以超级表为模板创建数据表**
X
Xiaxin Li 已提交
182 183

    ```mysql
184
    CREATE TABLE [IF NOT EXISTS] tb_name USING stb_name TAGS (tag_value1, ...);
X
Xiaxin Li 已提交
185
    ```
186
    以指定的超级表为模板,指定 TAGS 的值来创建数据表。
X
Xiaxin Li 已提交
187

188
- **以超级表为模板创建数据表,并指定具体的 TAGS 列**
189 190 191 192

    ```mysql
    CREATE TABLE [IF NOT EXISTS] tb_name USING stb_name (tag_name1, ...) TAGS (tag_value1, ...);
    ```
193 194
    以指定的超级表为模板,指定一部分 TAGS 列的值来创建数据表(没被指定的 TAGS 列会设为空值)。  
    说明:从 2.0.17.0 版本开始支持这种方式。在之前的版本中,不允许指定 TAGS 列,而必须显式给出所有 TAGS 列的取值。
195

196
- **批量创建数据表**
X
Xiaxin Li 已提交
197 198

    ```mysql
199
    CREATE TABLE [IF NOT EXISTS] tb_name1 USING stb_name TAGS (tag_value1, ...) [IF NOT EXISTS] tb_name2 USING stb_name TAGS (tag_value2, ...) ...;
X
Xiaxin Li 已提交
200
    ```
201
    以更快的速度批量创建大量数据表(服务器端 2.0.14 及以上版本)。
202 203 204 205 206 207
    
    说明:

    1)批量建表方式要求数据表必须以超级表为模板。

    2)在不超出 SQL 语句长度限制的前提下,单条语句中的建表数量建议控制在 1000~3000 之间,将会获得比较理想的建表速度。
X
Xiaxin Li 已提交
208 209 210 211

- **删除数据表**

    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
212
    DROP TABLE [IF EXISTS] tb_name;
X
Xiaxin Li 已提交
213
    ```
214

X
Xiaxin Li 已提交
215 216 217
- **显示当前数据库下的所有数据表信息**

    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
218
    SHOW TABLES [LIKE tb_name_wildcar];
X
Xiaxin Li 已提交
219 220
    ```

221
    显示当前数据库下的所有数据表信息。
222

223 224 225 226 227 228 229
- **显示一个数据表的创建语句**

    ```mysql
    SHOW CREATE TABLE tb_name;
    ```
    常用于数据库迁移。对一个已经存在的数据表,返回其创建语句;在另一个集群中执行该语句,就能得到一个结构完全相同的数据表。

230
- **在线修改显示字符宽度**
X
Xiaxin Li 已提交
231 232

    ```mysql
233
    SET MAX_BINARY_DISPLAY_WIDTH <nn>;
X
Xiaxin Li 已提交
234
    ```
235
    如显示的内容后面以...结尾时,表示该内容已被截断,可通过本命令修改显示字符宽度以显示完整的内容。
X
Xiaxin Li 已提交
236 237

- **获取表的结构信息**
238

X
Xiaxin Li 已提交
239
    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
240
    DESCRIBE tb_name;
X
Xiaxin Li 已提交
241 242 243 244 245
    ```

- **表增加列**

    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
246
    ALTER TABLE tb_name ADD COLUMN field_name data_type;
X
Xiaxin Li 已提交
247 248
    ```
    说明:
249

250
    1) 列的最大个数为1024,最小个数为2;(从 2.1.7.0 版本开始,改为最多允许 4096 列)
251

252
    2) 列名最大长度为64。
X
Xiaxin Li 已提交
253 254 255 256

- **表删除列**

    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
257
    ALTER TABLE tb_name DROP COLUMN field_name; 
X
Xiaxin Li 已提交
258
    ```
259
    如果表是通过超级表创建,更改表结构的操作只能对超级表进行。同时针对超级表的结构更改对所有通过该结构创建的表生效。对于不是通过超级表创建的表,可以直接修改表结构。
X
Xiaxin Li 已提交
260

261 262 263 264 265 266 267 268
- **表修改列宽**

    ```mysql
    ALTER TABLE tb_name MODIFY COLUMN field_name data_type(length); 
    ```
    如果数据列的类型是可变长格式(BINARY 或 NCHAR),那么可以使用此指令修改其宽度(只能改大,不能改小)。(2.1.3.0 版本新增)  
    如果表是通过超级表创建,更改表结构的操作只能对超级表进行。同时针对超级表的结构更改对所有通过该结构创建的表生效。对于不是通过超级表创建的表,可以直接修改表结构。

269
## <a class="anchor" id="super-table"></a>超级表STable管理
270

271
注意:在 2.0.15.0 及以后的版本中,开始支持 STABLE 保留字。也即,在本节后文的指令说明中,CREATE、DROP、ALTER 三个指令在老版本中保留字需写作 TABLE 而不是 STABLE。
272

X
Xiaxin Li 已提交
273 274 275
- **创建超级表**

    ```mysql
276
    CREATE STABLE [IF NOT EXISTS] stb_name (timestamp_field_name TIMESTAMP, field1_name data_type1 [, field2_name data_type2 ...]) TAGS (tag1_name tag_type1, tag2_name tag_type2 [, tag3_name tag_type3]);
X
Xiaxin Li 已提交
277
    ```
278
    创建 STable,与创建表的 SQL 语法相似,但需要指定 TAGS 字段的名称和类型。
X
Xiaxin Li 已提交
279 280

    说明:
281

282
    1) TAGS 列的数据类型不能是 timestamp 类型;(从 2.1.3.0 版本开始,TAGS 列中支持使用 timestamp 类型,但需注意在 TAGS 中的 timestamp 列写入数据时需要提供给定值,而暂不支持四则运算,例如 `NOW + 10s` 这类表达式)
283

X
Xiaxin Li 已提交
284
    2) TAGS 列名不能与其他列名相同;
285

286
    3) TAGS 列名不能为预留关键字(参见:[参数限制与保留关键字](https://www.taosdata.com/cn/documentation/administrator#keywords) 章节);
287

288
    4) TAGS 最多允许 128 个,至少 1 个,总长度不超过 16 KB。
289

X
Xiaxin Li 已提交
290
- **删除超级表**
291 292

    ```mysql
293
    DROP STABLE [IF EXISTS] stb_name;
294
    ```
295
    删除 STable 会自动删除通过 STable 创建的子表。
296

X
Xiaxin Li 已提交
297
- **显示当前数据库下的所有超级表信息**
298 299

    ```mysql
300
    SHOW STABLES [LIKE tb_name_wildcard];
301
    ```
302
    查看数据库内全部 STable,及其相关信息,包括 STable 的名称、创建时间、列数量、标签(TAG)数量、通过该 STable 建表的数量。
303

304 305 306 307 308 309 310
- **显示一个超级表的创建语句**

    ```mysql
    SHOW CREATE STABLE stb_name;
    ```
    常用于数据库迁移。对一个已经存在的超级表,返回其创建语句;在另一个集群中执行该语句,就能得到一个结构完全相同的超级表。

X
Xiaxin Li 已提交
311
- **获取超级表的结构信息**
312 313

    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
314
    DESCRIBE stb_name;
315 316
    ```

X
Xiaxin Li 已提交
317
- **超级表增加列**
318 319

    ```mysql
320
    ALTER STABLE stb_name ADD COLUMN field_name data_type;
321 322
    ```

X
Xiaxin Li 已提交
323
- **超级表删除列**
324 325

    ```mysql
326
    ALTER STABLE stb_name DROP COLUMN field_name; 
327 328
    ```

329 330 331 332 333 334 335
- **超级表修改列宽**

    ```mysql
    ALTER STABLE stb_name MODIFY COLUMN field_name data_type(length); 
    ```
    如果数据列的类型是可变长格式(BINARY 或 NCHAR),那么可以使用此指令修改其宽度(只能改大,不能改小)。(2.1.3.0 版本新增)

336
## <a class="anchor" id="tags"></a>超级表 STable 中 TAG 管理
337

X
Xiaxin Li 已提交
338
- **添加标签**
339 340

    ```mysql
341
    ALTER STABLE stb_name ADD TAG new_tag_name tag_type;
342
    ```
343
    为 STable 增加一个新的标签,并指定新标签的类型。标签总数不能超过 128 个,总长度不超过 16k 个字符。
344

X
Xiaxin Li 已提交
345
- **删除标签**
346 347

    ```mysql
348
    ALTER STABLE stb_name DROP TAG tag_name;
349
    ```
X
Xiaxin Li 已提交
350
    删除超级表的一个标签,从超级表删除某个标签后,该超级表下的所有子表也会自动删除该标签。
351

X
Xiaxin Li 已提交
352
- **修改标签名**
353 354

    ```mysql
355
    ALTER STABLE stb_name CHANGE TAG old_tag_name new_tag_name;
356
    ```
X
Xiaxin Li 已提交
357
    修改超级表的标签名,从超级表修改某个标签名后,该超级表下的所有子表也会自动更新该标签名。
358

359 360 361 362 363 364 365
- **修改标签列宽度**

    ```mysql
    ALTER STABLE stb_name MODIFY TAG tag_name data_type(length); 
    ```
    如果标签的类型是可变长格式(BINARY 或 NCHAR),那么可以使用此指令修改其宽度(只能改大,不能改小)。(2.1.3.0 版本新增)

P
Ping Xiao 已提交
366
- **修改子表标签值**
367 368

    ```mysql
369
    ALTER TABLE tb_name SET TAG tag_name=new_tag_value;
370
    ```
371
    说明:除了更新标签的值的操作是针对子表进行,其他所有的标签操作(添加标签、删除标签等)均只能作用于 STable,不能对单个子表操作。对 STable 添加标签以后,依托于该 STable 建立的所有表将自动增加了一个标签,所有新增标签的默认值都是 NULL。
372

373
## <a class="anchor" id="insert"></a>数据写入
X
Xiaxin Li 已提交
374

375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390
### 写入语法:

```mysql
INSERT INTO
    tb_name
        [USING stb_name [(tag1_name, ...)] TAGS (tag1_value, ...)]
        [(field1_name, ...)]
        VALUES (field1_value, ...) [(field1_value2, ...) ...] | FILE csv_file_path
    [tb2_name
        [USING stb_name [(tag1_name, ...)] TAGS (tag1_value, ...)]
        [(field1_name, ...)]
        VALUES (field1_value, ...) [(field1_value2, ...) ...] | FILE csv_file_path
    ...];
```

### 详细描述及示例:
X
Xiaxin Li 已提交
391

392 393
- **插入一条或多条记录**  
    指定已经创建好的数据子表的表名,并通过 VALUES 关键字提供一行或多行数据,即可向数据库写入这些数据。例如,执行如下语句可以写入一行记录:
X
Xiaxin Li 已提交
394
    ```mysql
395
    INSERT INTO d1001 VALUES (NOW, 10.2, 219, 0.32);
X
Xiaxin Li 已提交
396
    ```
397
    或者,可以通过如下语句写入两行记录:  
X
Xiaxin Li 已提交
398
    ```mysql
399
    INSERT INTO d1001 VALUES ('2021-07-13 14:06:32.272', 10.2, 219, 0.32) (1626164208000, 10.15, 217, 0.33);
X
Xiaxin Li 已提交
400
    ```
401
    **注意:**  
402
    1)在第二个例子中,两行记录的首列时间戳使用了不同格式的写法。其中字符串格式的时间戳写法不受所在 DATABASE 的时间精度设置影响;而长整形格式的时间戳写法会受到所在 DATABASE 的时间精度设置影响——例子中的时间戳在毫秒精度下可以写作 1626164208000,而如果是在微秒精度设置下就需要写为 1626164208000000,纳秒精度设置下需要写为 1626164208000000000。  
403 404
    2)在使用“插入多条记录”方式写入数据时,不能把第一列的时间戳取值都设为 NOW,否则会导致语句中的多条记录使用相同的时间戳,于是就可能出现相互覆盖以致这些数据行无法全部被正确保存。其原因在于,NOW 函数在执行中会被解析为所在 SQL 语句的实际执行时间,出现在同一语句中的多个 NOW 标记也就会被替换为完全相同的时间戳取值。  
    3)允许插入的最老记录的时间戳,是相对于当前服务器时间,减去配置的 keep 值(数据保留的天数);允许插入的最新记录的时间戳,是相对于当前服务器时间,加上配置的 days 值(数据文件存储数据的时间跨度,单位为天)。keep 和 days 都是可以在创建数据库时指定的,缺省值分别是 3650 天和 10 天。
X
Xiaxin Li 已提交
405

406 407
- **插入记录,数据对应到指定的列**  
    向数据子表中插入记录时,无论插入一行还是多行,都可以让数据对应到指定的列。对于 SQL 语句中没有出现的列,数据库将自动填充为 NULL。主键(时间戳)不能为 NULL。例如:
X
Xiaxin Li 已提交
408
    ```mysql
409
    INSERT INTO d1001 (ts, current, phase) VALUES ('2021-07-13 14:06:33.196', 10.27, 0.31);
X
Xiaxin Li 已提交
410
    ```
411
    **说明:**如果不指定列,也即使用全列模式——那么在 VALUES 部分提供的数据,必须为数据表的每个列都显式地提供数据。全列模式写入速度会远快于指定列,因此建议尽可能采用全列写入方式,此时空列可以填入 NULL。
X
Xiaxin Li 已提交
412

413 414
- **向多个表插入记录**  
    可以在一条语句中,分别向多个表插入一条或多条记录,并且也可以在插入过程中指定列。例如:
X
Xiaxin Li 已提交
415
    ```mysql
416 417
    INSERT INTO d1001 VALUES ('2021-07-13 14:06:34.630', 10.2, 219, 0.32) ('2021-07-13 14:06:35.779', 10.15, 217, 0.33)
                d1002 (ts, current, phase) VALUES ('2021-07-13 14:06:34.255', 10.27, 0.31);
X
Xiaxin Li 已提交
418 419
    ```

420 421
- <a class="anchor" id="auto_create_table"></a>**插入记录时自动建表**  
    如果用户在写数据时并不确定某个表是否存在,此时可以在写入数据时使用自动建表语法来创建不存在的表,若该表已存在则不会建立新表。自动建表时,要求必须以超级表为模板,并写明数据表的 TAGS 取值。例如:  
X
Xiaxin Li 已提交
422
    ```mysql
423
    INSERT INTO d21001 USING meters TAGS ('Beijing.Chaoyang', 2) VALUES ('2021-07-13 14:06:32.272', 10.2, 219, 0.32);
X
Xiaxin Li 已提交
424
    ```
425
    也可以在自动建表时,只是指定部分 TAGS 列的取值,未被指定的 TAGS 列将置为 NULL。例如:  
426
    ```mysql
427
    INSERT INTO d21001 USING meters (groupId) TAGS (2) VALUES ('2021-07-13 14:06:33.196', 10.15, 217, 0.33);
428
    ```
429
    自动建表语法也支持在一条语句中向多个表插入记录。例如:  
430
    ```mysql
431
    INSERT INTO d21001 USING meters TAGS ('Beijing.Chaoyang', 2) VALUES ('2021-07-13 14:06:34.630', 10.2, 219, 0.32) ('2021-07-13 14:06:35.779', 10.15, 217, 0.33)
432 433
                d21002 USING meters (groupId) TAGS (2) VALUES ('2021-07-13 14:06:34.255', 10.15, 217, 0.33)
                d21003 USING meters (groupId) TAGS (2) (ts, current, phase) VALUES ('2021-07-13 14:06:34.255', 10.27, 0.31);
434
    ```
435
    **说明:**在 2.0.20.5 版本之前,在使用自动建表语法并指定列时,子表的列名必须紧跟在子表名称后面,而不能如例子里那样放在 TAGS 和 VALUES 之间。从 2.0.20.5 版本开始,两种写法都可以,但不能在一条 SQL 语句中混用,否则会报语法错误。
436

437 438 439 440 441
- **插入来自文件的数据记录**  
    除了使用 VALUES 关键字插入一行或多行数据外,也可以把要写入的数据放在 CSV 文件中(英文逗号分隔、英文单引号括住每个值)供 SQL 指令读取。其中 CSV 文件无需表头。例如,如果 /tmp/csvfile.csv 文件的内容为:  
    ```
    '2021-07-13 14:07:34.630', '10.2', '219', '0.32'
    '2021-07-13 14:07:35.779', '10.15', '217', '0.33'
442
    ```
443
    那么通过如下指令可以把这个文件中的数据写入子表中:  
444
    ```mysql
445
    INSERT INTO d1001 FILE '/tmp/csvfile.csv';
446
    ```
447

448 449 450 451 452 453 454 455 456 457 458
- **插入来自文件的数据记录,并自动建表**  
    从 2.1.5.0 版本开始,支持在插入来自 CSV 文件的数据时,以超级表为模板来自动创建不存在的数据表。例如:  
    ```mysql
    INSERT INTO d21001 USING meters TAGS ('Beijing.Chaoyang', 2) FILE '/tmp/csvfile.csv';
    ```
    也可以在一条语句中向多个表以自动建表的方式插入记录。例如:  
    ```mysql
    INSERT INTO d21001 USING meters TAGS ('Beijing.Chaoyang', 2) FILE '/tmp/csvfile_21001.csv'
                d21002 USING meters (groupId) TAGS (2) FILE '/tmp/csvfile_21002.csv';
    ```

X
Xiaxin Li 已提交
459 460
**历史记录写入**:可使用IMPORT或者INSERT命令,IMPORT的语法,功能与INSERT完全一样。

461
**说明:**针对 insert 类型的 SQL 语句,我们采用的流式解析策略,在发现后面的错误之前,前面正确的部分 SQL 仍会执行。下面的 SQL 中,INSERT 语句是无效的,但是 d1001 仍会被创建。
462

P
Ping Xiao 已提交
463
```mysql
464
taos> CREATE TABLE meters(ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS(location BINARY(30), groupId INT);
P
Ping Xiao 已提交
465 466
Query OK, 0 row(s) affected (0.008245s)

467
taos> SHOW STABLES;
P
Ping Xiao 已提交
468 469 470 471 472
              name              |      created_time       | columns |  tags  |   tables    |
============================================================================================
 meters                         | 2020-08-06 17:50:27.831 |       4 |      2 |           0 |
Query OK, 1 row(s) in set (0.001029s)

473
taos> SHOW TABLES;
P
Ping Xiao 已提交
474 475
Query OK, 0 row(s) in set (0.000946s)

476
taos> INSERT INTO d1001 USING meters TAGS('Beijing.Chaoyang', 2) VALUES('a');
P
Ping Xiao 已提交
477

478
DB error: invalid SQL: 'a' (invalid timestamp) (0.039494s)
P
Ping Xiao 已提交
479

480
taos> SHOW TABLES;
P
Ping Xiao 已提交
481 482 483 484 485
           table_name           |      created_time       | columns |          stable_name           |
======================================================================================================
 d1001                          | 2020-08-06 17:52:02.097 |       4 | meters                         |
Query OK, 1 row(s) in set (0.001091s)
```
X
Xiaxin Li 已提交
486

487 488 489 490 491 492 493 494
## <a class="anchor" id="select"></a>数据查询

### 查询语法:

```mysql
SELECT select_expr [, select_expr ...]
    FROM {tb_name_list}
    [WHERE where_condition]
495 496 497 498
    [SESSION(ts_col, tol_val)]
    [STATE_WINDOW(col)]
    [INTERVAL(interval_val [, interval_offset]) [SLIDING sliding_val]]
    [FILL(fill_mod_and_val)]
499
    [GROUP BY col_list]
500
    [ORDER BY col_list { DESC | ASC }]
501 502
    [SLIMIT limit_val [SOFFSET offset_val]]
    [LIMIT limit_val [OFFSET offset_val]]
503
    [>> export_file];
504 505
```

506
#### 通配符
507

X
Xiaxin Li 已提交
508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540
通配符 * 可以用于代指全部列。对于普通表,结果中只有普通列。
```mysql
taos> SELECT * FROM d1001;
           ts            |       current        |   voltage   |        phase         |
======================================================================================
 2018-10-03 14:38:05.000 |             10.30000 |         219 |              0.31000 |
 2018-10-03 14:38:15.000 |             12.60000 |         218 |              0.33000 |
 2018-10-03 14:38:16.800 |             12.30000 |         221 |              0.31000 |
Query OK, 3 row(s) in set (0.001165s)
```

在针对超级表,通配符包含 _标签列_ 。
```mysql
taos> SELECT * FROM meters;
           ts            |       current        |   voltage   |        phase         |            location            |   groupid   |
=====================================================================================================================================
 2018-10-03 14:38:05.500 |             11.80000 |         221 |              0.28000 | Beijing.Haidian                |           2 |
 2018-10-03 14:38:16.600 |             13.40000 |         223 |              0.29000 | Beijing.Haidian                |           2 |
 2018-10-03 14:38:05.000 |             10.80000 |         223 |              0.29000 | Beijing.Haidian                |           3 |
 2018-10-03 14:38:06.500 |             11.50000 |         221 |              0.35000 | Beijing.Haidian                |           3 |
 2018-10-03 14:38:04.000 |             10.20000 |         220 |              0.23000 | Beijing.Chaoyang               |           3 |
 2018-10-03 14:38:16.650 |             10.30000 |         218 |              0.25000 | Beijing.Chaoyang               |           3 |
 2018-10-03 14:38:05.000 |             10.30000 |         219 |              0.31000 | Beijing.Chaoyang               |           2 |
 2018-10-03 14:38:15.000 |             12.60000 |         218 |              0.33000 | Beijing.Chaoyang               |           2 |
 2018-10-03 14:38:16.800 |             12.30000 |         221 |              0.31000 | Beijing.Chaoyang               |           2 |
Query OK, 9 row(s) in set (0.002022s)
```

通配符支持表名前缀,以下两个SQL语句均为返回全部的列:
```mysql
SELECT * FROM d1001;
SELECT d1001.* FROM d1001;
```
541
在JOIN查询中,带前缀的\*和不带前缀\*返回的结果有差别, \*返回全部表的所有列数据(不包含标签),带前缀的通配符,则只返回该表的列数据。
X
Xiaxin Li 已提交
542 543 544 545 546 547 548 549 550 551 552 553 554 555 556
```mysql
taos> SELECT * FROM d1001, d1003 WHERE d1001.ts=d1003.ts;
           ts            | current |   voltage   |    phase     |           ts            | current |   voltage   |    phase     |
==================================================================================================================================
 2018-10-03 14:38:05.000 | 10.30000|         219 |      0.31000 | 2018-10-03 14:38:05.000 | 10.80000|         223 |      0.29000 |
Query OK, 1 row(s) in set (0.017385s)
```
```mysql
taos> SELECT d1001.* FROM d1001,d1003 WHERE d1001.ts = d1003.ts;
           ts            |       current        |   voltage   |        phase         |
======================================================================================
 2018-10-03 14:38:05.000 |             10.30000 |         219 |              0.31000 |
Query OK, 1 row(s) in set (0.020443s)
```

557
在使用SQL函数来进行查询的过程中,部分SQL函数支持通配符操作。其中的区别在于:
558
```count(*)```函数只返回一列。```first```、```last```、```last_row```函数则是返回全部列。
X
Xiaxin Li 已提交
559

560 561
```mysql
taos> SELECT COUNT(*) FROM d1001;
X
Xiaxin Li 已提交
562 563 564 565 566 567
       count(*)        |
========================
                     3 |
Query OK, 1 row(s) in set (0.001035s)
```

568 569
```mysql
taos> SELECT FIRST(*) FROM d1001;
X
Xiaxin Li 已提交
570 571 572 573 574 575
        first(ts)        |    first(current)    | first(voltage) |     first(phase)     |
=========================================================================================
 2018-10-03 14:38:05.000 |             10.30000 |            219 |              0.31000 |
Query OK, 1 row(s) in set (0.000849s)
```

576
#### 标签列
577 578 579 580 581 582 583 584 585 586 587 588 589

从 2.0.14 版本开始,支持在普通表的查询中指定 _标签列_,且标签列的值会与普通列的数据一起返回。
```mysql
taos> SELECT location, groupid, current FROM d1001 LIMIT 2;
            location            |   groupid   |       current        |
======================================================================
 Beijing.Chaoyang               |           2 |             10.30000 |
 Beijing.Chaoyang               |           2 |             12.60000 |
Query OK, 2 row(s) in set (0.003112s)
```

注意:普通表的通配符 * 中并不包含 _标签列_。

590
#### 获取标签列或普通列的去重取值
591

592 593 594
从 2.0.15.0 版本开始,支持在超级表查询标签列时,指定 DISTINCT 关键字,这样将返回指定标签列的所有不重复取值。注意,在 2.1.6.0 版本之前,DISTINCT 只支持处理单个标签列,而从 2.1.6.0 版本开始,DISTINCT 可以对多个标签列进行处理,输出这些标签列取值不重复的组合。
```sql
SELECT DISTINCT tag_name [, tag_name ...] FROM stb_name;
595 596
```

597 598 599 600
从 2.1.7.0 版本开始,DISTINCT 也支持对数据子表或普通表进行处理,也即支持获取单个普通列的不重复取值,或多个普通列取值的不重复组合。
```sql
SELECT DISTINCT col_name [, col_name ...] FROM tb_name;
```
601

602
需要注意的是,DISTINCT 目前不支持对超级表中的普通列进行处理。如果需要进行此类操作,那么需要把超级表放在子查询中,再对子查询的计算结果执行 DISTINCT。
603

604 605 606 607
说明:
1. cfg 文件中的配置参数 maxNumOfDistinctRes 将对 DISTINCT 能够输出的数据行数进行限制。其最小值是 100000,最大值是 100000000,默认值是 10000000。如果实际计算结果超出了这个限制,那么会仅输出这个数量范围内的部分。
2. 由于浮点数天然的精度机制原因,在特定情况下,对 FLOAT 和 DOUBLE 列使用 DISTINCT 并不能保证输出值的完全唯一性。
3. 在当前版本下,DISTINCT 不能在嵌套查询的子查询中使用,也不能与聚合函数、GROUP BY、或 JOIN 在同一条语句中混用。
608

X
Xiaxin Li 已提交
609 610 611
#### 结果集列名

```SELECT```子句中,如果不指定返回结果集合的列名,结果集列名称默认使用```SELECT```子句中的表达式名称作为列名称。此外,用户可使用```AS```来重命名返回结果集合中列的名称。例如:
612 613
```mysql
taos> SELECT ts, ts AS primary_key_ts FROM d1001;
X
Xiaxin Li 已提交
614 615 616 617 618 619 620 621 622 623
           ts            |     primary_key_ts      |
====================================================
 2018-10-03 14:38:05.000 | 2018-10-03 14:38:05.000 |
 2018-10-03 14:38:15.000 | 2018-10-03 14:38:15.000 |
 2018-10-03 14:38:16.800 | 2018-10-03 14:38:16.800 |
Query OK, 3 row(s) in set (0.001191s)
```
但是针对```first(*)```、```last(*)```、```last_row(*)```不支持针对单列的重命名。

#### 隐式结果列
624

X
Xiaxin Li 已提交
625 626 627 628 629 630
```Select_exprs```可以是表所属列的列名,也可以是基于列的函数表达式或计算式,数量的上限256个。当用户使用了```interval```或```group by tags```的子句以后,在最后返回结果中会强制返回时间戳列(第一列)和group by子句中的标签列。后续的版本中可以支持关闭group by子句中隐式列的输出,列输出完全由select子句控制。

#### 表(超级表)列表

FROM关键字后面可以是若干个表(超级表)列表,也可以是子查询的结果。
如果没有指定用户的当前数据库,可以在表名称之前使用数据库的名称来指定表所属的数据库。例如:```power.d1001``` 方式来跨库使用表。
631
```mysql
X
Xiaxin Li 已提交
632 633
SELECT * FROM power.d1001;
------------------------------
634
USE power;
X
Xiaxin Li 已提交
635 636 637 638
SELECT * FROM d1001;
```

#### 特殊功能
639

640
部分特殊的查询功能可以不使用FROM子句执行。获取当前所在的数据库 database(): 
641 642
```mysql
taos> SELECT DATABASE();
X
Xiaxin Li 已提交
643 644 645 646 647
           database()           |
=================================
 power                          |
Query OK, 1 row(s) in set (0.000079s)
```
648
如果登录的时候没有指定默认数据库,且没有使用```USE```命令切换数据,则返回NULL。
649 650
```mysql
taos> SELECT DATABASE();
X
Xiaxin Li 已提交
651 652 653 654 655
           database()           |
=================================
 NULL                           |
Query OK, 1 row(s) in set (0.000184s)
```
656
获取服务器和客户端版本号:
657 658
```mysql
taos> SELECT CLIENT_VERSION();
X
Xiaxin Li 已提交
659 660 661 662 663
 client_version() |
===================
 2.0.0.0          |
Query OK, 1 row(s) in set (0.000070s)

664
taos> SELECT SERVER_VERSION();
X
Xiaxin Li 已提交
665 666 667 668 669 670
 server_version() |
===================
 2.0.0.0          |
Query OK, 1 row(s) in set (0.000077s)
```
服务器状态检测语句。如果服务器正常,返回一个数字(例如 1)。如果服务器异常,返回error code。该SQL语法能兼容连接池对于TDengine状态的检查及第三方工具对于数据库服务器状态的检查。并可以避免出现使用了错误的心跳检测SQL语句导致的连接池连接丢失的问题。
671 672
```mysql
taos> SELECT SERVER_STATUS();
X
Xiaxin Li 已提交
673 674 675 676 677
 server_status() |
==================
               1 |
Query OK, 1 row(s) in set (0.000074s)

678
taos> SELECT SERVER_STATUS() AS status;
X
Xiaxin Li 已提交
679 680 681 682 683
   status    |
==============
           1 |
Query OK, 1 row(s) in set (0.000081s)
```
684

X
Xiaxin Li 已提交
685 686 687 688 689 690
#### TAOS SQL中特殊关键词

 >   TBNAME: 在超级表查询中可视为一个特殊的标签,代表查询涉及的子表名<br>
    \_c0: 表示表(超级表)的第一列

#### 小技巧
691

X
Xiaxin Li 已提交
692
获取一个超级表所有的子表名及相关的标签信息:
693
```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
694
SELECT TBNAME, location FROM meters;
X
Xiaxin Li 已提交
695 696
```
统计超级表下辖子表数量:
697
```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
698
SELECT COUNT(TBNAME) FROM meters;
X
Xiaxin Li 已提交
699
```
700
以上两个查询均只支持在WHERE条件子句中添加针对标签(TAGS)的过滤条件。例如:
701
```mysql
X
Xiaxin Li 已提交
702 703 704 705 706 707 708 709 710
taos> SELECT TBNAME, location FROM meters;
             tbname             |            location            |
==================================================================
 d1004                          | Beijing.Haidian                |
 d1003                          | Beijing.Haidian                |
 d1002                          | Beijing.Chaoyang               |
 d1001                          | Beijing.Chaoyang               |
Query OK, 4 row(s) in set (0.000881s)

711
taos> SELECT COUNT(tbname) FROM meters WHERE groupId > 2;
X
Xiaxin Li 已提交
712 713 714 715 716 717
     count(tbname)     |
========================
                     2 |
Query OK, 1 row(s) in set (0.001091s)
```

718
- 可以使用 * 返回所有列,或指定列名。可以对数字列进行四则运算,可以给输出的列取列名。
719 720
  * 暂不支持含列名的四则运算表达式用于条件过滤算子(例如,不支持 `where a*2>6;`,但可以写 `where a>6/2;`)。
  * 暂不支持含列名的四则运算表达式作为 SQL 函数的应用对象(例如,不支持 `select min(2*a) from t;`,但可以写 `select 2*min(a) from t;`)。
721
- WHERE 语句可以使用各种逻辑判断来过滤数字值,或使用通配符来过滤字符串。
722
- 输出结果缺省按首列时间戳升序排序,但可以指定按降序排序( _c0 指首列时间戳)。使用 ORDER BY 对其他字段进行排序,排序结果顺序不确定。
723
- 参数 LIMIT 控制输出条数,OFFSET 指定从第几条开始输出。LIMIT/OFFSET 对结果集的执行顺序在 ORDER BY 之后。且 `LIMIT 5 OFFSET 2` 可以简写为 `LIMIT 2, 5`。
724
  * 在有 GROUP BY 子句的情况下,LIMIT 参数控制的是每个分组中至多允许输出的条数。
E
Elias Soong 已提交
725
- 参数 SLIMIT 控制由 GROUP BY 指令划分的分组中,至多允许输出几个分组的数据。且 `SLIMIT 5 SOFFSET 2` 可以简写为 `SLIMIT 2, 5`。
726
- 通过 “>>” 输出结果可以导出到指定文件。
X
Xiaxin Li 已提交
727 728 729

### 支持的条件过滤操作

730 731
| **Operation** | **Note**                 | **Applicable Data Types**                 |
| ------------- | ------------------------ | ----------------------------------------- |
D
dapan1121 已提交
732 733 734 735
| >             | larger than              | all types except bool                     |
| <             | smaller than             | all types except bool                     |
| >=            | larger than or equal to  | all types except bool                     |
| <=            | smaller than or equal to | all types except bool                     |
736 737 738
| =             | equal to                 | all types                                 |
| <>            | not equal to             | all types                                 |
| is [not] null | is null or is not null   | all types                                 |
D
dapan1121 已提交
739
| between and   | within a certain range   | all types except bool                     |
740 741
| in            | match any value in a set | all types except first column `timestamp` |
| like          | match a wildcard string  | **`binary`** **`nchar`**                  |
D
dapan1121 已提交
742
| match/nmatch  | filter regex             | **`binary`** **`nchar`**                  |
X
Xiaxin Li 已提交
743

744
1. <> 算子也可以写为 != ,请注意,这个算子不能用于数据表第一列的 timestamp 字段。
745
2. like 算子使用通配符字符串进行匹配检查。
L
liuyq-617 已提交
746
  * 在通配符字符串中:'%'(百分号)匹配 0 到任意个字符;'\_'(下划线)匹配单个任意ASCII字符。
747
    * 如果希望匹配字符串中原本就带有的 \_(下划线)字符,那么可以在通配符字符串中写作 `\_`,也即加一个反斜线来进行转义。(从 2.2.0.0 版本开始支持)
748 749
  * 通配符字符串最长不能超过 20 字节。(从 2.1.6.1 版本开始,通配符字符串的长度放宽到了 100 字节,并可以通过 taos.cfg 中的 maxWildCardsLength 参数来配置这一长度限制。但不建议使用太长的通配符字符串,将有可能严重影响 LIKE 操作的执行性能。)
3. 同时进行多个字段的范围过滤,需要使用关键词 AND 来连接不同的查询条件,暂不支持 OR 连接的不同列之间的查询过滤条件。
750
  * 从 2.3.0.0 版本开始,已支持完整的同一列和/或不同列间的 AND/OR 运算。
751
4. 针对单一字段的过滤,如果是时间过滤条件,则一条语句中只支持设定一个;但针对其他的(普通)列或标签列,则可以使用 `OR` 关键字进行组合条件的查询过滤。例如: `((value > 20 AND value < 30) OR (value < 12))`。
752
  * 从 2.3.0.0 版本开始,允许使用多个时间过滤条件,但首列时间戳的过滤运算结果只能包含一个区间。
753
5. 从 2.0.17.0 版本开始,条件过滤开始支持 BETWEEN AND 语法,例如 `WHERE col2 BETWEEN 1.5 AND 3.25` 表示查询条件为“1.5 ≤ col2 ≤ 3.25”。
754 755 756 757 758 759 760 761 762 763 764

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,不区分大小写。

   **语法**

   WHERE (column|tbname) **match/MATCH/nmatch/NMATCH** *regex*

   **正则表达式规范**

H
Hui Li 已提交
765
   确保使用的正则表达式符合POSIX的规范,具体规范内容可参见[Regular Expressions](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html)
766 767 768

   **使用限制**

D
dapan1121 已提交
769
   只能针对表名(即 tbname 筛选)、binary/nchar类型标签值进行正则表达式过滤,不支持普通列的过滤。
770 771 772

   正则匹配字符串长度不能超过 128 字节。可以通过参数 *maxRegexStringLen* 设置和调整最大允许的正则匹配字符串,该参数是客户端配置参数,需要重启才能生效。

X
Xiaxin Li 已提交
773

774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801
<a class="anchor" id="join"></a>
### JOIN 子句

从 2.2.0.0 版本开始,TDengine 对内连接(INNER JOIN)中的自然连接(Natural join)操作实现了完整的支持。也即支持“普通表与普通表之间”、“超级表与超级表之间”、“子查询与子查询之间”进行自然连接。自然连接与内连接的主要区别是,自然连接要求参与连接的字段在不同的表/超级表中必须是同名字段。也即,TDengine 在连接关系的表达中,要求必须使用同名数据列/标签列的相等关系。

在普通表与普通表之间的 JOIN 操作中,只能使用主键时间戳之间的相等关系。例如:
```sql
SELECT *
FROM temp_tb_1 t1, pressure_tb_1 t2
WHERE t1.ts = t2.ts
```

在超级表与超级表之间的 JOIN 操作中,除了主键时间戳一致的条件外,还要求引入能实现一一对应的标签列的相等关系。例如:
```sql
SELECT *
FROM temp_stable t1, temp_stable t2
WHERE t1.ts = t2.ts AND t1.deviceid = t2.deviceid AND t1.status=0;
```

类似地,也可以对多个子查询的查询结果进行 JOIN 操作。

注意,JOIN 操作存在如下限制要求:
1. 参与一条语句中 JOIN 操作的表/超级表最多可以有 10 个。
2. 在包含 JOIN 操作的查询语句中不支持 FILL。
3. 暂不支持参与 JOIN 操作的表之间聚合后的四则运算。
4. 不支持只对其中一部分表做 GROUP BY。
5. JOIN 查询的不同表的过滤条件之间不能为 OR。

802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827
<a class="anchor" id="nested"></a>
### 嵌套查询

“嵌套查询”又称为“子查询”,也即在一条 SQL 语句中,“内层查询”的计算结果可以作为“外层查询”的计算对象来使用。

从 2.2.0.0 版本开始,TDengine 的查询引擎开始支持在 FROM 子句中使用非关联子查询(“非关联”的意思是,子查询不会用到父查询中的参数)。也即在普通 SELECT 语句的 tb_name_list 位置,用一个独立的 SELECT 语句来代替(这一 SELECT 语句被包含在英文圆括号内),于是完整的嵌套查询 SQL 语句形如:

```mysql
SELECT ... FROM (SELECT ... FROM ...) ...;
```

说明:
1. 目前仅支持一层嵌套,也即不能在子查询中再嵌入子查询。
2. 内层查询的返回结果将作为“虚拟表”供外层查询使用,此虚拟表可以使用 AS 语法做重命名,以便于外层查询中方便引用。
3. 目前不能在“连续查询”功能中使用子查询。
4. 在内层和外层查询中,都支持普通的表间/超级表间 JOIN。内层查询的计算结果也可以再参与数据子表的 JOIN 操作。
5. 目前内层查询、外层查询均不支持 UNION 操作。
6. 内层查询支持的功能特性与非嵌套的查询语句能力是一致的。
  * 内层查询的 ORDER BY 子句一般没有意义,建议避免这样的写法以免无谓的资源消耗。
7. 与非嵌套的查询语句相比,外层查询所能支持的功能特性存在如下限制:
  * 计算函数部分:
    1. 如果内层查询的结果数据未提供时间戳,那么计算过程依赖时间戳的函数在外层会无法正常工作。例如:TOP, BOTTOM, FIRST, LAST, DIFF。
    2. 计算过程需要两遍扫描的函数,在外层查询中无法正常工作。例如:此类函数包括:STDDEV, PERCENTILE。
  * 外层查询中不支持 IN 算子,但在内层中可以使用。
  * 外层查询不支持 GROUP BY。

828
<a class="anchor" id="union"></a>
829
### UNION ALL 子句
830 831 832 833 834 835 836 837 838

```mysql
SELECT ...
UNION ALL SELECT ...
[UNION ALL SELECT ...]
```

TDengine 支持 UNION ALL 操作符。也就是说,如果多个 SELECT 子句返回结果集的结构完全相同(列名、列类型、列数、顺序),那么可以通过 UNION ALL 把这些结果集合并到一起。目前只支持 UNION ALL 模式,也即在结果集的合并过程中是不去重的。

H
haojun Liao 已提交
839
### SQL 示例 
X
Xiaxin Li 已提交
840

841
- 对于下面的例子,表tb1用以下语句创建:
X
Xiaxin Li 已提交
842 843

    ```mysql
844
    CREATE TABLE tb1 (ts TIMESTAMP, col1 INT, col2 FLOAT, col3 BINARY(50));
X
Xiaxin Li 已提交
845 846
    ```

847
- 查询tb1刚过去的一个小时的所有记录:
X
Xiaxin Li 已提交
848 849

    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
850
    SELECT * FROM tb1 WHERE ts >= NOW - 1h;
X
Xiaxin Li 已提交
851 852
    ```

853
- 查询表tb1从2018-06-01 08:00:00.000 到2018-06-02 08:00:00.000时间范围,并且col3的字符串是'nny'结尾的记录,结果按照时间戳降序:
X
Xiaxin Li 已提交
854 855

    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
856
    SELECT * FROM tb1 WHERE ts > '2018-06-01 08:00:00.000' AND ts <= '2018-06-02 08:00:00.000' AND col3 LIKE '%nny' ORDER BY ts DESC;
X
Xiaxin Li 已提交
857 858
    ```

859
- 查询col1与col2的和,并取名complex, 时间大于2018-06-01 08:00:00.000, col2大于1.2,结果输出仅仅10条记录,从第5条开始:
X
Xiaxin Li 已提交
860 861

    ```mysql
862
    SELECT (col1 + col2) AS 'complex' FROM tb1 WHERE ts > '2018-06-01 08:00:00.000' AND col2 > 1.2 LIMIT 10 OFFSET 5;
X
Xiaxin Li 已提交
863 864
    ```

865
- 查询过去10分钟的记录,col2的值大于3.14,并且将结果输出到文件 `/home/testoutpu.csv`:
X
Xiaxin Li 已提交
866 867

    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
868
    SELECT COUNT(*) FROM tb1 WHERE ts >= NOW - 10m AND col2 > 3.14 >> /home/testoutpu.csv;
X
Xiaxin Li 已提交
869 870
    ```

871 872
<a class="anchor" id="functions"></a>
## SQL 函数
X
Xiaxin Li 已提交
873 874 875 876 877 878 879

### 聚合函数

TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数如下:

- **COUNT**
    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
880
    SELECT COUNT([*|field_name]) FROM tb_name [WHERE clause];
X
Xiaxin Li 已提交
881
    ```
882
    功能说明:统计表/超级表中记录行数或某列的非空值个数。
883

884
    返回结果数据类型:长整型INT64。
885

886
    应用字段:应用全部字段。
887

888
    适用于:**表、超级表**。
889 890 891

    说明:

892
    1)可以使用星号(\*)来替代具体的字段,使用星号(\*)返回全部记录数量。
893 894 895 896

    2)针对同一表的(不包含NULL值)字段查询结果均相同。

    3)如果统计对象是具体的列,则返回该列中非NULL值的记录数量。
X
Xiaxin Li 已提交
897 898 899

    示例:
    ```mysql
900
    taos> SELECT COUNT(*), COUNT(voltage) FROM meters;
X
Xiaxin Li 已提交
901 902 903 904 905
        count(*)        |    count(voltage)     |
    ================================================
                        9 |                     9 |
    Query OK, 1 row(s) in set (0.004475s)

906
    taos> SELECT COUNT(*), COUNT(voltage) FROM d1001;
X
Xiaxin Li 已提交
907 908 909 910 911 912 913 914
        count(*)        |    count(voltage)     |
    ================================================
                        3 |                     3 |
    Query OK, 1 row(s) in set (0.001075s)
    ```

- **AVG**
    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
915
    SELECT AVG(field_name) FROM tb_name [WHERE clause];
X
Xiaxin Li 已提交
916
    ```
917
    功能说明:统计表/超级表中某列的平均值。
918

919
    返回结果数据类型:双精度浮点数Double。
920

921
    应用字段:不能应用在timestamp、binary、nchar、bool字段。
922

923
    适用于:**表、超级表**。
924

X
Xiaxin Li 已提交
925 926 927 928 929 930 931 932
    示例:
    ```mysql
    taos> SELECT AVG(current), AVG(voltage), AVG(phase) FROM meters;
        avg(current)        |       avg(voltage)        |        avg(phase)         |
    ====================================================================================
                11.466666751 |             220.444444444 |               0.293333333 |
    Query OK, 1 row(s) in set (0.004135s)

933
    taos> SELECT AVG(current), AVG(voltage), AVG(phase) FROM d1001;
X
Xiaxin Li 已提交
934 935 936 937 938 939 940 941
        avg(current)        |       avg(voltage)        |        avg(phase)         |
    ====================================================================================
                11.733333588 |             219.333333333 |               0.316666673 |
    Query OK, 1 row(s) in set (0.000943s)
    ```

- **TWA**
    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
942
    SELECT TWA(field_name) FROM tb_name WHERE clause;
X
Xiaxin Li 已提交
943
    ```
944
    功能说明:时间加权平均函数。统计表中某列在一段时间内的时间加权平均。
945

946
    返回结果数据类型:双精度浮点数Double。
947

X
Xiaxin Li 已提交
948
    应用字段:不能应用在timestamp、binary、nchar、bool类型字段。
949

950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965
    适用于:**表、(超级表)**。

    说明:从 2.1.3.0 版本开始,TWA 函数可以在由 GROUP BY 划分出单独时间线的情况下用于超级表(也即 GROUP BY tbname)。

- **IRATE**
    ```mysql
    SELECT IRATE(field_name) FROM tb_name WHERE clause;
    ```
    功能说明:计算瞬时增长率。使用时间区间中最后两个样本数据来计算瞬时增长速率;如果这两个值呈递减关系,那么只取最后一个数用于计算,而不是使用二者差值。

    返回结果数据类型:双精度浮点数Double。

    应用字段:不能应用在timestamp、binary、nchar、bool类型字段。

    适用于:**表、(超级表)**。

966
    说明:(从 2.1.3.0 版本开始新增此函数)IRATE 可以在由 GROUP BY 划分出单独时间线的情况下用于超级表(也即 GROUP BY tbname)。
X
Xiaxin Li 已提交
967 968 969

- **SUM**
    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
970
    SELECT SUM(field_name) FROM tb_name [WHERE clause];
X
Xiaxin Li 已提交
971
    ```
972
    功能说明:统计表/超级表中某列的和。
973

974
    返回结果数据类型:双精度浮点数Double和长整型INT64。
975

976
    应用字段:不能应用在timestamp、binary、nchar、bool类型字段。
977

978
    适用于:**表、超级表**。
X
Xiaxin Li 已提交
979 980 981

    示例:
    ```mysql
982
    taos> SELECT SUM(current), SUM(voltage), SUM(phase) FROM meters;
X
Xiaxin Li 已提交
983 984 985 986 987
        sum(current)        |     sum(voltage)      |        sum(phase)         |
    ================================================================================
                103.200000763 |                  1984 |               2.640000001 |
    Query OK, 1 row(s) in set (0.001702s)

988
    taos> SELECT SUM(current), SUM(voltage), SUM(phase) FROM d1001;
X
Xiaxin Li 已提交
989 990 991 992 993 994 995 996
        sum(current)        |     sum(voltage)      |        sum(phase)         |
    ================================================================================
                35.200000763 |                   658 |               0.950000018 |
    Query OK, 1 row(s) in set (0.000980s)
    ```

- **STDDEV**
    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
997
    SELECT STDDEV(field_name) FROM tb_name [WHERE clause];
X
Xiaxin Li 已提交
998
    ```
999
    功能说明:统计表中某列的均方差。
1000

1001
    返回结果数据类型:双精度浮点数Double。
1002

1003
    应用字段:不能应用在timestamp、binary、nchar、bool类型字段。
1004

1005
    适用于:**表**。(从 2.0.15.1 版本开始,本函数也支持**超级表**)
X
Xiaxin Li 已提交
1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017

    示例:
    ```mysql
    taos> SELECT STDDEV(current) FROM d1001;
        stddev(current)      |
    ============================
                1.020892909 |
    Query OK, 1 row(s) in set (0.000915s)
    ```

- **LEASTSQUARES**
    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
1018
    SELECT LEASTSQUARES(field_name, start_val, step_val) FROM tb_name [WHERE clause];
X
Xiaxin Li 已提交
1019
    ```
1020
    功能说明:统计表中某列的值是主键(时间戳)的拟合直线方程。start_val是自变量初始值,step_val是自变量的步长值。
1021

1022
    返回结果数据类型:字符串表达式(斜率, 截距)。
1023

1024
    应用字段:不能应用在timestamp、binary、nchar、bool类型字段。
1025

1026
    说明:自变量是时间戳,因变量是该列的值。
1027

1028
    适用于:**表**。
X
Xiaxin Li 已提交
1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040

    示例:
    ```mysql
    taos> SELECT LEASTSQUARES(current, 1, 1) FROM d1001;
                leastsquares(current, 1, 1)             |
    =====================================================
    {slop:1.000000, intercept:9.733334}                 |
    Query OK, 1 row(s) in set (0.000921s)
    ```

### 选择函数

1041 1042
在使用所有的选择函数的时候,可以同时指定输出 ts 列或标签列(包括 tbname),这样就可以方便地知道被选出的值是源于哪个数据行的。

X
Xiaxin Li 已提交
1043 1044
- **MIN**
    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
1045
    SELECT MIN(field_name) FROM {tb_name | stb_name} [WHERE clause];
X
Xiaxin Li 已提交
1046
    ```
1047
    功能说明:统计表/超级表中某列的值最小值。
1048

1049
    返回结果数据类型:同应用的字段。
1050

X
Xiaxin Li 已提交
1051 1052
    应用字段:不能应用在timestamp、binary、nchar、bool类型字段。

1053 1054
    适用于:**表、超级表**。

X
Xiaxin Li 已提交
1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071
    示例:
    ```mysql
    taos> SELECT MIN(current), MIN(voltage) FROM meters;
        min(current)     | min(voltage) |
    ======================================
                10.20000 |          218 |
    Query OK, 1 row(s) in set (0.001765s)

    taos> SELECT MIN(current), MIN(voltage) FROM d1001;
        min(current)     | min(voltage) |
    ======================================
                10.30000 |          218 |
    Query OK, 1 row(s) in set (0.000950s)
    ```

- **MAX**
    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
1072
    SELECT MAX(field_name) FROM { tb_name | stb_name } [WHERE clause];
X
Xiaxin Li 已提交
1073
    ```
1074
    功能说明:统计表/超级表中某列的值最大值。
1075

1076
    返回结果数据类型:同应用的字段。
1077

X
Xiaxin Li 已提交
1078 1079
    应用字段:不能应用在timestamp、binary、nchar、bool类型字段。

1080 1081
    适用于:**表、超级表**。

X
Xiaxin Li 已提交
1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098
    示例:
    ```mysql
    taos> SELECT MAX(current), MAX(voltage) FROM meters;
        max(current)     | max(voltage) |
    ======================================
                13.40000 |          223 |
    Query OK, 1 row(s) in set (0.001123s)

    taos> SELECT MAX(current), MAX(voltage) FROM d1001;
        max(current)     | max(voltage) |
    ======================================
                12.60000 |          221 |
    Query OK, 1 row(s) in set (0.000987s)
    ```

- **FIRST**
    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
1099
    SELECT FIRST(field_name) FROM { tb_name | stb_name } [WHERE clause];
X
Xiaxin Li 已提交
1100
    ```
1101
    功能说明:统计表/超级表中某列的值最先写入的非NULL值。
1102

1103
    返回结果数据类型:同应用的字段。
1104

1105
    应用字段:所有字段。
1106

1107 1108
    适用于:**表、超级表**。

1109 1110 1111 1112
    说明:

    1)如果要返回各个列的首个(时间戳最小)非NULL值,可以使用FIRST(\*);

1113
    2)如果结果集中的某列全部为NULL值,则该列的返回结果也是NULL;
1114

1115
    3)如果结果集中所有列全部为NULL值,则不返回结果。
X
Xiaxin Li 已提交
1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133

    示例:
    ```mysql
    taos> SELECT FIRST(*) FROM meters;
            first(ts)        |    first(current)    | first(voltage) |     first(phase)     |
    =========================================================================================
    2018-10-03 14:38:04.000 |             10.20000 |            220 |              0.23000 |
    Query OK, 1 row(s) in set (0.004767s)

    taos> SELECT FIRST(current) FROM d1002;
        first(current)    |
    =======================
                10.20000 |
    Query OK, 1 row(s) in set (0.001023s)
    ```

- **LAST**
    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
1134
    SELECT LAST(field_name) FROM { tb_name | stb_name } [WHERE clause];
X
Xiaxin Li 已提交
1135
    ```
1136
    功能说明:统计表/超级表中某列的值最后写入的非 NULL 值。
1137

1138
    返回结果数据类型:同应用的字段。
1139

1140
    应用字段:所有字段。
1141

1142 1143
    适用于:**表、超级表**。

1144 1145
    说明:

1146
    1)如果要返回各个列的最后(时间戳最大)一个非 NULL 值,可以使用 LAST(\*);
1147

1148 1149 1150
    2)如果结果集中的某列全部为 NULL 值,则该列的返回结果也是 NULL;如果结果集中所有列全部为 NULL 值,则不返回结果。

    3)在用于超级表时,时间戳完全一样且同为最大的数据行可能有多个,那么会从中随机返回一条,而并不保证多次运行所挑选的数据行必然一致。
X
Xiaxin Li 已提交
1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168

    示例:
    ```mysql
    taos> SELECT LAST(*) FROM meters;
            last(ts)         |    last(current)     | last(voltage) |     last(phase)      |
    ========================================================================================
    2018-10-03 14:38:16.800 |             12.30000 |           221 |              0.31000 |
    Query OK, 1 row(s) in set (0.001452s)

    taos> SELECT LAST(current) FROM d1002;
        last(current)     |
    =======================
                10.30000 |
    Query OK, 1 row(s) in set (0.000843s)
    ```

- **TOP**
    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
1169
    SELECT TOP(field_name, K) FROM { tb_name | stb_name } [WHERE clause];
X
Xiaxin Li 已提交
1170
    ```
1171
    功能说明: 统计表/超级表中某列的值最大 *k* 个非 NULL 值。如果多条数据取值一样,全部取用又会超出 k 条限制时,系统会从相同值中随机选取符合要求的数量返回。
1172

1173
    返回结果数据类型:同应用的字段。
1174

1175
    应用字段:不能应用在timestamp、binary、nchar、bool类型字段。
1176

1177 1178
    适用于:**表、超级表**。

1179 1180 1181 1182
    说明:

    1)*k*值取值范围1≤*k*≤100;

1183 1184 1185
    2)系统同时返回该记录关联的时间戳列;

    3)限制:TOP函数不支持FILL子句。
X
Xiaxin Li 已提交
1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206

    示例:
    ```mysql
    taos> SELECT TOP(current, 3) FROM meters;
            ts            |   top(current, 3)    |
    =================================================
    2018-10-03 14:38:15.000 |             12.60000 |
    2018-10-03 14:38:16.600 |             13.40000 |
    2018-10-03 14:38:16.800 |             12.30000 |
    Query OK, 3 row(s) in set (0.001548s)

    taos> SELECT TOP(current, 2) FROM d1001;
            ts            |   top(current, 2)    |
    =================================================
    2018-10-03 14:38:15.000 |             12.60000 |
    2018-10-03 14:38:16.800 |             12.30000 |
    Query OK, 2 row(s) in set (0.000810s)
    ```

- **BOTTOM**
    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
1207
    SELECT BOTTOM(field_name, K) FROM { tb_name | stb_name } [WHERE clause];
X
Xiaxin Li 已提交
1208
    ```
1209
    功能说明:统计表/超级表中某列的值最小 *k* 个非 NULL 值。如果多条数据取值一样,全部取用又会超出 k 条限制时,系统会从相同值中随机选取符合要求的数量返回。
1210

1211
    返回结果数据类型:同应用的字段。
1212

1213
    应用字段:不能应用在timestamp、binary、nchar、bool类型字段。
1214

1215 1216
    适用于:**表、超级表**。

1217 1218 1219 1220
    说明:

    1)*k*值取值范围1≤*k*≤100;

1221 1222 1223
    2)系统同时返回该记录关联的时间戳列;

    3)限制:BOTTOM函数不支持FILL子句。
X
Xiaxin Li 已提交
1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243

    示例:
    ```mysql
    taos> SELECT BOTTOM(voltage, 2) FROM meters;
            ts            | bottom(voltage, 2) |
    ===============================================
    2018-10-03 14:38:15.000 |                218 |
    2018-10-03 14:38:16.650 |                218 |
    Query OK, 2 row(s) in set (0.001332s)

    taos> SELECT BOTTOM(current, 2) FROM d1001;
            ts            |  bottom(current, 2)  |
    =================================================
    2018-10-03 14:38:05.000 |             10.30000 |
    2018-10-03 14:38:16.800 |             12.30000 |
    Query OK, 2 row(s) in set (0.000793s)
    ```

- **PERCENTILE**
    ```mysql
P
Ping Xiao 已提交
1244
    SELECT PERCENTILE(field_name, P) FROM { tb_name } [WHERE clause];
X
Xiaxin Li 已提交
1245
    ```
1246
    功能说明:统计表中某列的值百分比分位数。
1247

1248
    返回结果数据类型: 双精度浮点数Double。
1249

1250
    应用字段:不能应用在timestamp、binary、nchar、bool类型字段。
1251

1252 1253
    适用于:**表**。

X
Xiaxin Li 已提交
1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265
    说明:*P*值取值范围0≤*P*≤100,为0的时候等同于MIN,为100的时候等同于MAX。

    示例:
    ```mysql
    taos> SELECT PERCENTILE(current, 20) FROM d1001;
    percentile(current, 20)  |
    ============================
                11.100000191 |
    Query OK, 1 row(s) in set (0.000787s)
    ```

- **APERCENTILE**
1266
    
X
Xiaxin Li 已提交
1267
    ```mysql
1268 1269
    SELECT APERCENTILE(field_name, P[, algo_type]) 
    FROM { tb_name | stb_name } [WHERE clause]
H
Hui Li 已提交
1270
    ```
1271 1272 1273 1274 1275 1276 1277 1278
    功能说明:统计表/超级表中指定列的值百分比分位数,与PERCENTILE函数相似,但是返回近似结果。

    返回结果数据类型: 双精度浮点数Double。

    应用字段:不能应用在timestamp、binary、nchar、bool类型字段。

    适用于:**表、超级表**。

H
Hui Li 已提交
1279
    说明:<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/>
1280
    
1281
    嵌套子查询支持:适用于内层查询和外层查询。
1282
    
X
Xiaxin Li 已提交
1283 1284 1285 1286 1287 1288
    ```mysql
    taos> SELECT APERCENTILE(current, 20) FROM d1001;
    apercentile(current, 20)  |
    ============================
                10.300000191 |
    Query OK, 1 row(s) in set (0.000645s)
1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300
    
    taos> select apercentile (count, 80, 'default') from stb1;
     apercentile (c0, 80, 'default') |
    ==================================
                 601920857.210056424 |
    Query OK, 1 row(s) in set (0.012363s)
    
    taos> select apercentile (count, 80, 't-digest') from stb1;
     apercentile (c0, 80, 't-digest') |
    ===================================
                  605869120.966666579 |
    Query OK, 1 row(s) in set (0.011639s)
X
Xiaxin Li 已提交
1301 1302 1303
    ```
    
- **LAST_ROW**
1304
    
X
Xiaxin Li 已提交
1305
    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
1306
    SELECT LAST_ROW(field_name) FROM { tb_name | stb_name };
X
Xiaxin Li 已提交
1307
    ```
1308 1309 1310 1311 1312 1313 1314 1315 1316 1317
功能说明:返回表/超级表的最后一条记录。
    
返回结果数据类型:同应用的字段。
    
应用字段:所有字段。
    
适用于:**表、超级表**。
    
限制:LAST_ROW() 不能与 INTERVAL 一起使用。
    
H
Hui Li 已提交
1318 1319 1320 1321
说明:在用于超级表时,时间戳完全一样且同为最大的数据行可能有多个,那么会从中随机返回一条,而并不保证多次运行所挑选的数据行必然一致。<br/>
   <br/>示例:

   ```mysql
X
Xiaxin Li 已提交
1322 1323 1324 1325
    taos> SELECT LAST_ROW(current) FROM meters;
    last_row(current)   |
    =======================
                12.30000 |
H
Hui Li 已提交
1326
    Query OK, 1 row(s) in set (0.001238s)
1327
    
X
Xiaxin Li 已提交
1328 1329 1330 1331 1332
    taos> SELECT LAST_ROW(current) FROM d1002;
    last_row(current)   |
    =======================
                10.30000 |
    Query OK, 1 row(s) in set (0.001042s)
H
Hui Li 已提交
1333
   ```
H
Hui Li 已提交
1334
    
H
Hui Li 已提交
1335

H
Hui Li 已提交
1336 1337
- **INTERP** 
    
1338
    ```mysql
1339
    SELECT INTERP(field_name) FROM { tb_name | stb_name } WHERE ts='timestamp' [FILL ({ VALUE | PREV | NULL | LINEAR | NEXT})];
1340
    ```
H
Hui Li 已提交
1341

H
Hui Li 已提交
1342
功能说明:返回表/超级表的指定时间截面、指定字段的记录。
1343

H
Hui Li 已提交
1344
返回结果数据类型:同字段类型。
1345

H
Hui Li 已提交
1346
应用字段:数值型字段。
1347

H
Hui Li 已提交
1348
适用于:**表、超级表**。
1349

H
Hui Li 已提交
1350
说明:(从 2.0.15.0 版本开始新增此函数) <br/>1)INTERP 必须指定时间断面,如果该时间断面不存在直接对应的数据,那么会根据 FILL 参数的设定进行插值。此外,条件语句里面可附带筛选条件,例如标签、tbname。<br/>2)INTERP 查询要求查询的时间区间必须位于数据集合(表)的所有记录的时间范围之内。如果给定的时间戳位于时间范围之外,即使有插值指令,仍然不返回结果。<br/>3)单个 INTERP 函数查询只能够针对一个时间点进行查询,如果需要返回等时间间隔的断面数据,可以通过 INTERP 配合 EVERY 的方式来进行查询处理(而不是使用 INTERVAL),其含义是每隔固定长度的时间进行插值。<br/>    
H
Hui Li 已提交
1351
    示例:
H
Hui Li 已提交
1352
    
H
Hui Li 已提交
1353
   ```mysql
1354 1355 1356 1357 1358
    taos> SELECT INTERP(*) FROM meters WHERE ts='2017-7-14 18:40:00.004';
           interp(ts)        |   interp(current)    | interp(voltage) |    interp(phase)     |
    ==========================================================================================
     2017-07-14 18:40:00.004 |              9.84020 |             216 |              0.32222 |
    Query OK, 1 row(s) in set (0.002652s)
H
Hui Li 已提交
1359
   ```
H
Hui Li 已提交
1360

H
Hui Li 已提交
1361
如果给定的时间戳无对应的数据,在不指定插值生成策略的情况下,不会返回结果,如果指定了插值策略,会根据插值策略返回结果。
H
Hui Li 已提交
1362

H
Hui Li 已提交
1363
   ```mysql
1364 1365
    taos> SELECT INTERP(*) FROM meters WHERE tbname IN ('d636') AND ts='2017-7-14 18:40:00.005';
    Query OK, 0 row(s) in set (0.004022s)
1366
    
H
Hui Li 已提交
1367
    taos> SELECT INTERP(*) FROM meters WHERE tbname IN ('d636') AND ts='2017-7-14 18:40:00.005' FILL(PREV);
1368 1369 1370 1371
           interp(ts)        |   interp(current)    | interp(voltage) |    interp(phase)     |
    ==========================================================================================
     2017-07-14 18:40:00.005 |              9.88150 |             217 |              0.32500 |
    Query OK, 1 row(s) in set (0.003056s)
H
Hui Li 已提交
1372
   ```
H
Hui Li 已提交
1373

H
Hui Li 已提交
1374
如下所示代码表示在时间区间 `['2017-7-14 18:40:00', '2017-7-14 18:40:00.014']` 中每隔 5 毫秒 进行一次断面计算。
H
Hui Li 已提交
1375

H
Hui Li 已提交
1376
   ```mysql
1377 1378 1379 1380 1381
    taos> SELECT INTERP(current) FROM d636 WHERE ts>='2017-7-14 18:40:00' AND ts<='2017-7-14 18:40:00.014' EVERY(5a);
               ts            |   interp(current)    |
    =================================================
     2017-07-14 18:40:00.000 |             10.04179 |
     2017-07-14 18:40:00.010 |             10.16123 |
H
Hui Li 已提交
1382
    Query OK, 2 row(s) in set (0.003487s)
H
Hui Li 已提交
1383
   ```
H
Hui Li 已提交
1384

X
Xiaxin Li 已提交
1385
### 计算函数
1386

X
Xiaxin Li 已提交
1387 1388
- **DIFF**
    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
1389
    SELECT DIFF(field_name) FROM tb_name [WHERE clause];
X
Xiaxin Li 已提交
1390
    ```
1391
    功能说明:统计表中某列的值与前一行对应值的差。
1392

1393
    返回结果数据类型:同应用字段。
1394

1395
    应用字段:不能应用在timestamp、binary、nchar、bool类型字段。
1396

1397
    适用于:**表、(超级表)**。
1398

1399
    说明:输出结果行数是范围内总行数减一,第一行没有结果输出。从 2.1.3.0 版本开始,DIFF 函数可以在由 GROUP BY 划分出单独时间线的情况下用于超级表(也即 GROUP BY tbname)。
1400

X
Xiaxin Li 已提交
1401 1402 1403 1404 1405 1406 1407 1408 1409 1410
    示例:
    ```mysql
    taos> SELECT DIFF(current) FROM d1001;
            ts            |    diff(current)     |
    =================================================
    2018-10-03 14:38:15.000 |              2.30000 |
    2018-10-03 14:38:16.800 |             -0.30000 |
    Query OK, 2 row(s) in set (0.001162s)
    ```

1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424
- **DERIVATIVE**
    ```mysql
    SELECT DERIVATIVE(field_name, time_interval, ignore_negative) FROM tb_name [WHERE clause];
    ```
    功能说明:统计表中某列数值的单位变化率。其中单位时间区间的长度可以通过 time_interval 参数指定,最小可以是 1 秒(1s);ignore_negative 参数的值可以是 0 或 1,为 1 时表示忽略负值。

    返回结果数据类型:双精度浮点数。

    应用字段:不能应用在 timestamp、binary、nchar、bool 类型字段。

    适用于:**表、(超级表)**。

    说明:(从 2.1.3.0 版本开始新增此函数)输出结果行数是范围内总行数减一,第一行没有结果输出。DERIVATIVE 函数可以在由 GROUP BY 划分出单独时间线的情况下用于超级表(也即 GROUP BY tbname)。

1425 1426
    示例:
    ```mysql
1427 1428 1429 1430 1431 1432 1433 1434 1435
    taos> select derivative(current, 10m, 0) from t1;
               ts            | derivative(current, 10m, 0) |
    ========================================================
     2021-08-20 10:11:22.790 |                 0.500000000 |
     2021-08-20 11:11:22.791 |                 0.166666620 |
     2021-08-20 12:11:22.791 |                 0.000000000 |
     2021-08-20 13:11:22.792 |                 0.166666620 |
     2021-08-20 14:11:22.792 |                -0.666666667 |
    Query OK, 5 row(s) in set (0.004883s)
1436 1437
    ```

X
Xiaxin Li 已提交
1438 1439
- **SPREAD**
    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
1440
    SELECT SPREAD(field_name) FROM { tb_name | stb_name } [WHERE clause];
X
Xiaxin Li 已提交
1441
    ```
1442
    功能说明:统计表/超级表中某列的最大值和最小值之差。
1443

1444
    返回结果数据类型:双精度浮点数。
1445

1446
    应用字段:不能应用在binary、nchar、bool类型字段。
1447

1448 1449
    适用于:**表、超级表**。

X
Xiaxin Li 已提交
1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466
    说明:可用于TIMESTAMP字段,此时表示记录的时间覆盖范围。

    示例:
    ```mysql
    taos> SELECT SPREAD(voltage) FROM meters;
        spread(voltage)      |
    ============================
                5.000000000 |
    Query OK, 1 row(s) in set (0.001792s)

    taos> SELECT SPREAD(voltage) FROM d1001;
        spread(voltage)      |
    ============================
                3.000000000 |
    Query OK, 1 row(s) in set (0.000836s)
    ```

H
Hui Li 已提交
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478
- **CEIL**
    ```mysql
    SELECT CEIL(field_name) FROM { tb_name | stb_name } [WHERE clause];
    ```
    功能说明:获得指定列的向上取整数的结果。
    
    返回结果类型:与指定列的原始数据类型一致。例如,如果指定列的原始数据类型为 Float,那么返回的数据类型也为 Float;如果指定列的原始数据类型为 Double,那么返回的数据类型也为 Double。

    适用数据类型:不能应用在 timestamp、binary、nchar、bool 类型字段上;在超级表查询中使用时,不能应用在 tag 列,无论 tag 列的类型是什么类型。

    嵌套子查询支持:适用于内层查询和外层查询。

H
Hui Li 已提交
1479 1480 1481 1482
    说明:
      支持 +、-、*、/ 运算,如 ceil(col1) + ceil(col2)。
      只能与普通列,选择(Selection)、投影(Projection)函数一起使用,不能与聚合(Aggregation)函数一起使用。
      该函数可以应用在普通表和超级表上。
H
Hui Li 已提交
1483

H
Hui Li 已提交
1484
    支持版本:指定计算算法的功能从 2.2.0.x 版本开始,2.2.0.0 之前的版本不支持指定使用算法的功能。
H
Hui Li 已提交
1485 1486 1487 1488 1489 1490
  
- **FLOOR**
    ```mysql
    SELECT FLOOR(field_name) FROM { tb_name | stb_name } [WHERE clause];
    ```
    功能说明:获得指定列的向下取整数的结果。  
H
Hui Li 已提交
1491
    其他使用说明参见CEIL函数描述。
H
Hui Li 已提交
1492 1493 1494 1495 1496 1497

- **ROUND**
    ```mysql
    SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
    ```
    功能说明:获得指定列的四舍五入的结果。  
H
Hui Li 已提交
1498
    其他使用说明参见CEIL函数描述。
H
Hui Li 已提交
1499

X
Xiaxin Li 已提交
1500 1501 1502
- **四则运算**

    ```mysql
陶建辉(Jeff)'s avatar
陶建辉(Jeff) 已提交
1503
    SELECT field_name [+|-|*|/|%][Value|field_name] FROM { tb_name | stb_name }  [WHERE clause];
X
Xiaxin Li 已提交
1504
    ```
1505
    功能说明:统计表/超级表中某列或多列间的值加、减、乘、除、取余计算结果。
1506

1507
    返回结果数据类型:双精度浮点数。
1508

1509
    应用字段:不能应用在timestamp、binary、nchar、bool类型字段。
1510

1511 1512
    适用于:**表、超级表**。

1513 1514 1515 1516 1517
    说明:

    1)支持两列或多列之间进行计算,可使用括号控制计算优先级;

    2)NULL字段不参与计算,如果参与计算的某行中包含NULL,该行的计算结果为NULL。
X
Xiaxin Li 已提交
1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528

    ```mysql
    taos> SELECT current + voltage * phase FROM d1001;
    (current+(voltage*phase)) |
    ============================
                78.190000713 |
                84.540003240 |
                80.810000718 |
    Query OK, 3 row(s) in set (0.001046s)
    ```

1529
## <a class="anchor" id="aggregation"></a>按窗口切分聚合
1530

1531
TDengine 支持按时间段等窗口切分方式进行聚合结果查询,比如温度传感器每秒采集一次数据,但需查询每隔 10 分钟的温度平均值。这类聚合适合于降维(down sample)操作,语法如下:
X
Xiaxin Li 已提交
1532 1533

```mysql
1534
SELECT function_list FROM tb_name
X
Xiaxin Li 已提交
1535
  [WHERE where_condition]
1536 1537 1538 1539
  [SESSION(ts_col, tol_val)]
  [STATE_WINDOW(col)]
  [INTERVAL(interval [, offset]) [SLIDING sliding]]
  [FILL({NONE | VALUE | PREV | NULL | LINEAR | NEXT})]
X
Xiaxin Li 已提交
1540

1541
SELECT function_list FROM stb_name
X
Xiaxin Li 已提交
1542
  [WHERE where_condition]
1543 1544
  [INTERVAL(interval [, offset]) [SLIDING sliding]]
  [FILL({NONE | VALUE | PREV | NULL | LINEAR | NEXT})]
X
Xiaxin Li 已提交
1545 1546 1547
  [GROUP BY tags]
```

1548 1549 1550
- 在聚合查询中,function_list 位置允许使用聚合和选择函数,并要求每个函数仅输出单个结果(例如:COUNT、AVG、SUM、STDDEV、LEASTSQUARES、PERCENTILE、MIN、MAX、FIRST、LAST),而不能使用具有多行输出结果的函数(例如:TOP、BOTTOM、DIFF 以及四则运算)。
- 查询过滤、聚合等操作按照每个切分窗口为独立的单位执行。聚合查询目前支持三种窗口的划分方式:
  1. 时间窗口:聚合时间段的窗口宽度由关键词 INTERVAL 指定,最短时间间隔 10 毫秒(10a);并且支持偏移 offset(偏移必须小于间隔),也即时间窗口划分与“UTC 时刻 0”相比的偏移量。SLIDING 语句用于指定聚合时间段的前向增量,也即每次窗口向前滑动的时长。当 SLIDING 与 INTERVAL 取值相等的时候,滑动窗口即为翻转窗口。
1551
    * 从 2.1.5.0 版本开始,INTERVAL 语句允许的最短时间间隔调整为 1 微秒(1u),当然如果所查询的 DATABASE 的时间精度设置为毫秒级,那么允许的最短时间间隔为 1 毫秒(1a)。
1552
    * **注意:**用到 INTERVAL 语句时,除非极特殊的情况,都要求把客户端和服务端的 taos.cfg 配置文件中的 timezone 参数配置为相同的取值,以避免时间处理函数频繁进行跨时区转换而导致的严重性能影响。
1553 1554
  2. 状态窗口:使用整数或布尔值来标识产生记录时设备的状态量,产生的记录如果具有相同的状态量取值则归属于同一个状态窗口,数值改变后该窗口关闭。状态量所对应的列作为 STATE_WINDOW 语句的参数来指定。(状态窗口暂不支持对超级表使用)
  3. 会话窗口:时间戳所在的列由 SESSION 语句的 ts_col 参数指定,会话窗口根据相邻两条记录的时间戳差值来确定是否属于同一个会话——如果时间戳差异在 tol_val 以内,则认为记录仍属于同一个窗口;如果时间变化超过 tol_val,则自动开启下一个窗口。(会话窗口暂不支持对超级表使用)
1555 1556 1557 1558 1559 1560 1561 1562
- WHERE 语句可以指定查询的起止时间和其他过滤条件。
- FILL 语句指定某一窗口区间数据缺失的情况下的填充模式。填充模式包括以下几种:
  1. 不进行填充:NONE(默认填充模式)。
  2. VALUE 填充:固定值填充,此时需要指定填充的数值。例如:FILL(VALUE, 1.23)。
  3. PREV 填充:使用前一个非 NULL 值填充数据。例如:FILL(PREV)。
  4. NULL 填充:使用 NULL 填充数据。例如:FILL(NULL)。
  5. LINEAR 填充:根据前后距离最近的非 NULL 值做线性插值填充。例如:FILL(LINEAR)。
  6. NEXT 填充:使用下一个非 NULL 值填充数据。例如:FILL(NEXT)。
1563 1564

说明:
1565
  1. 使用 FILL 语句的时候可能生成大量的填充输出,务必指定查询的时间区间。针对每次查询,系统可返回不超过 1 千万条具有插值的结果。
X
Xiaxin Li 已提交
1566
  2. 在时间维度聚合中,返回的结果中时间序列严格单调递增。
1567
  3. 如果查询对象是超级表,则聚合函数会作用于该超级表下满足值过滤条件的所有表的数据。如果查询中没有使用 GROUP BY 语句,则返回的结果按照时间序列严格单调递增;如果查询中使用了 GROUP BY 语句分组,则返回结果中每个 GROUP 内不按照时间序列严格单调递增。
X
Xiaxin Li 已提交
1568

1569 1570
时间聚合也常被用于连续查询场景,可以参考文档 [连续查询(Continuous Query)](https://www.taosdata.com/cn/documentation/advanced-features#continuous-query)。

1571
**示例**: 智能电表的建表语句如下:
X
Xiaxin Li 已提交
1572 1573

```mysql
1574
CREATE TABLE meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT);
X
Xiaxin Li 已提交
1575 1576
```

1577
针对智能电表采集的数据,以 10 分钟为一个阶段,计算过去 24 小时的电流数据的平均值、最大值、电流的中位数。如果没有计算值,用前一个非 NULL 值填充。使用的查询语句如下:
X
Xiaxin Li 已提交
1578 1579

```mysql
1580 1581
SELECT AVG(current), MAX(current), APERCENTILE(current, 50) FROM meters
  WHERE ts>=NOW-1d and ts<=now
X
Xiaxin Li 已提交
1582 1583 1584 1585
  INTERVAL(10m)
  FILL(PREV);
```

1586 1587
## <a class="anchor" id="limitation"></a>TAOS SQL 边界限制

1588
- 数据库名最大长度为 32。
1589
- 表名最大长度为 192,每行数据最大长度 16k 个字符, 从 2.1.7.0 版本开始,每行数据最大长度 48k 个字符(注意:数据行内每个 BINARY/NCHAR 类型的列还会额外占用 2 个字节的存储位置)。
1590
- 列名最大长度为 64,最多允许 1024 列,最少需要 2 列,第一列必须是时间戳。(从 2.1.7.0 版本开始,改为最多允许 4096 列)
1591 1592
- 标签名最大长度为 64,最多允许 128 个,可以 1 个,一个表中标签值的总长度不超过 16k 个字符。
- SQL 语句最大长度 65480 个字符,但可通过系统配置参数 maxSQLLength 修改,最长可配置为 1M。
1593
- SELECT 语句的查询结果,最多允许返回 1024 列(语句中的函数调用可能也会占用一些列空间),超限时需要显式指定较少的返回数据列,以避免语句执行报错。(从 2.1.7.0 版本开始,改为最多允许 4096 列)
1594
- 库的数目,超级表的数目、表的数目,系统不做限制,仅受系统资源限制。
1595

1596
## TAOS SQL 其他约定
1597

1598
**GROUP BY的限制**
1599

L
liuyq-617 已提交
1600
TAOS SQL 支持对标签、TBNAME 进行 GROUP BY 操作,也支持普通列进行 GROUP BY,前提是:仅限一列且该列的唯一值小于 10 万个。注意:group by 不支持float,double 类型。
1601

1602
**IS NOT NULL 与不为空的表达式适用范围**
1603

1604
IS NOT NULL 支持所有类型的列。不为空的表达式为 <>"",仅对非数值类型的列适用。
1605