本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 流式处理 SQL 语言元素
<a name="sql-reference-basic-building-blocks"></a>

以下主题讨论了 Kinesis Data Analytics 中构成其语法和操作基础的语言元素：

**Topics**
+ [标识符](sql-reference-identifiers.md)
+ [数据类型](sql-reference-data-types.md)
+ [流式 SQL 运算符](sql-reference-streaming-operators.md)
+ [表达式和文字](sql-reference-expressions.md)
+ [单调表达式和运算符](sql-reference-monotonic-expressions-operators.md)
+ [条件子句](sql-reference-conditions.md)
+ [时间谓词](sql-reference-temporal-predicate.md)
+ [保留字和关键字](sql-reference-reserved-words-keywords.md)

# 标识符
<a name="sql-reference-identifiers"></a>

所有标识符最多可以有 128 个字符。标识符可以通过用双引号 (") 括起来进行引用（区分大小写），也可以不加引号（在存储和查找之前都使用隐式大写）。

未加引号的标识符必须以字母或下划线开头，后跟字母、数字或下划线；字母全部转换为大写。

带引号的标识符也可以包含其他标点符号（实际上，除控制字符之外的任何 Unicode 字符都接受：代码 0x0000 到 0x001F）。您可以在标识符中加入双引号，方法是用另一个双引号对其进行转义。

在以下示例中，使用未加引号的标识符创建了一个流，该标识符在流定义存储到目录中之前会转换为大写。可以使用其大写名称来引用它，也可以使用隐式转换为大写的未加引号的标识符来引用它。

```
–- Create a stream. Stream name specified without quotes, 
–- which defaults to uppercase.
CREATE OR REPLACE STREAM ExampleStream (col1 VARCHAR(4));

– example 1: OK, stream name interpreted as uppercase.
CREATE OR REPLACE PUMP "STREAM_PUMP" AS INSERT INTO ExampleStream 
    SELECT * FROM SOURCE_SQL_STREAM_001;

– example 2: OK, stream name interpreted as uppercase.
CREATE OR REPLACE PUMP "STREAM_PUMP" AS INSERT INTO examplestream 
    SELECT * FROM   customerdata;

– example 3: Ok. 
CREATE OR REPLACE PUMP "STREAM_PUMP" AS INSERT INTO EXAMPLESTREAM 
    SELECT * FROM   customerdata;

– example 2: Not found. Quoted names are case-sensitive.
CREATE OR REPLACE PUMP "STREAM_PUMP" AS INSERT INTO "examplestream"
    SELECT * FROM   customerdata;
```

在 Amazon Kinesis Data Analytics 中创建对象时，其名称会隐式引用，因此可以轻松创建包含小写字符、空格、短划线或其他标点符号的标识符。如果您在 SQL 语句中引用这些对象，则需要引用其名称。
<a name="TOC3"></a>
**保留字和关键字**  
对于某些标识符（称为关键字），如果出现在流式 SQL 语句中的特定位置，则具有特殊含义。这些关键字的子集称为保留字，除非被引用，否则不能用作对象的名称。有关更多信息，请参阅 [保留字和关键字](sql-reference-reserved-words-keywords.md)。

# 数据类型
<a name="sql-reference-data-types"></a>

下表汇总了 Amazon Kinesis Data Analytics 支持的数据类型。


| SQL 数据类型 | JSON 数据类型 | 说明 | 注意 | 
| --- | --- | --- | --- | 
|  BIGINT  | 数字 |  64 位有符号整数  | 
|  BINARY  | BASE64-编码后的字符串 |  二进制（非字符）数据  |  子字符串适用于 BINARY。联接对 BINARY 不起作用。  | 
|  BOOLEAN  | 布尔值 |  TRUE、FALSE 或 NULL  |  计算结果为 TRUE、FALSE 和 UNKNOWN。  | 
|  CHAR (n)  | 字符串 |  固定长度 n 的字符串。也可指定为 CHARACTER  |  n 必须大于 0 且小于 65535。  | 
|  DATE  | 字符串 |  日期是日历日 (year/month/day)。  |  精度是日。范围介于最大值 [大约 \$1229（以年为单位）] 到最小值 -229 之间。  | 
|  DECIMAL DEC NUMERIC  | 数字 |  一个固定点，最多包含 19 位有效数字。  |  可以用 DECIMAL、DEC 或 NUMERIC 指定。  | 
|  DOUBLE DOUBLE PRECISION  | 数字 |  64 位浮点数  |  64 位近似值；-1.79E\$1308 至 1.79E\$1308。采用 ISO DOUBLE PRECISION 数据类型，53 位用于科学计数法中的数字尾数，表示 15 位数的精度和 8 字节的存储空间。  | 
|  INTEGER INT  | 数字 |   |  32 位带符号的整数。范围介于 -2147483648 到 2147483647 [ 2\$1\$1(31) to 2\$1\$1(31)- 1] 之间  | 
|  INTERVAL <timeunit> [TO <timeunit>]  | 字符串 |  支持日-时间间隔，不支持年-月间隔  |  在采用日期算法的表达式中允许，但不可用作表或流中列的数据类型。  | 
|  <timeUnit>  | 字符串 |  INTERVAL 值的单位  |  支持的单位为 YEAR、MONTH、DAY、HOUR、MINUTE 和 SECOND  | 
|  SMALLINT  | 数字 |  16 位有符号整数  |  范围介于 -32768 到 32767 之间  [2\$1\$1(15) to 2\$1\$1(15)-1]  | 
|  REAL  | 数字 |  32 位浮点数  |  采用 ISO REAL 数据类型，24 位用于科学计数法中的数字尾数，表示 7 位数的精度和 4 字节的存储空间。最小值为 -3.40E\$138；最大值为 3.40E\$138。  | 
|  TIME  | 字符串 |  TIME 是一天中的时间 (hour:minute:second)。  |  其精度是毫秒；其范围是 00:00:00.000 到 23:59:59.999。由于系统时钟采用 UTC，因此不考虑用于 TIME 或 TIMESTAMP 列中存储的值的时区。 用于 TIME 或 TIMESTAMP 列中存储的值。  | 
|  TIMESTAMP  | 字符串 |  TIMESTAMP 是 DATE 和 TIME 的组合。  |  TIMESTAMP 值的精度始终为 1 毫秒。没有特定的时区。由于系统时钟采用 UTC，因此不考虑用于 TIME 或 TIMESTAMP 列中存储的值的时区。范围介于最大值 [大约 \$1229（以年为单位）] 到最小值 -229 之间。每个时间戳都存储为带符号的 64 位整数，其中 0 表示 Unix 时代 (1970 年 1 月 1 日零点)。这意味着最大的 TIMESTAMP 值代表 1970 年之后的大约 3 亿年，最小的值代表 1970 年之前的大约 3 亿年。根据 SQL 标准，TIMESTAMP 值的时区未定义。  | 
|  TINYINT  | 数字 |  8 位有符号整数  |  范围介于 -128 到 127 之间  | 
|  VARBINARY (n)  | BASE64-编码后的字符串 |  也可指定为 BINARY VARYING  |  n 必须大于 0 且小于 65535。  | 
|  VARCHAR (n)  | 字符串 |  也可指定为 CHARACTER VARYING  |  n 必须大于 0 且小于 65535。  | 
<a name="NOTE1"></a>
**注意**  
关于字符：
+ 亚马逊 Kinesis Data Analytics 仅支持 Java 单字节字符 SETs。
+ 不支持隐式类型转换。也就是说，当且仅当字符取自相同的字符库并且是数据类型为 CHARACTER 或 CHARACTER VARYING 的值时，字符才可以相互分配。

关于数字：
+ 如果数字是数据类型为 NUMERIC、DECIMAL、INTEGER、BIGINT、SMALLINT、TINYINT、REAL 和 DOUBLE PRECISION 的值，则可以相互比较和相互分配。

以下数据类型集是同义词：
+ DEC 和 DECIMAL
+ DOUBLE PRECISION 和 DOUBLE
+ CHARACTER 和 CHAR
+ CHAR VARYING 或 CHARACTER VARYING 和 VARCHAR
+ BINARY VARYING 和 VARBINARY
+ INT 和 INTEGER
+ 二进制值（数据类型为 BINARY 和 BINARY VARYING）始终可以相互比较，并且可以相互分配。

关于日期、时间和时间戳：
+ 不支持隐式类型转换（也就是说，只有当分配的源和目标都是 DATE、TIME 或 TIMESTAMP 类型时，日期时间值才可以相互分配）。
+ Amazon Kinesis Data Analytics 时区始终采用 UTC。时间函数，包括 Amazon Kinesis Data Analytics 扩展 CURRENT\$1ROW\$1TIMESTAMP，以 UTC 返回时间。

# 数字类型和精度
<a name="sql-reference-numeric-types-precision"></a>

对于 DECIMAL，我们最多支持 18 位数的精度和小数位数。

精度指定列中可存储的最大小数位数，包括小数点右侧和左侧的小数位数。您可以指定从 1 位到 18 位的精度，也可以使用 18 位的默认精度。

小数位数指定小数点右侧可存储的最大位数。小数位数必须小于或等于精度。您可以指定介于 0 到 18 位之间的小数位数，也可以使用 0 位的默认小数位数。

**除法规则**  
假设 p1、s1 是第一个运算对象的精度和小数位数，例如 DECIMAL (10,1)。

假设 p2、s2 是第二个运算对象的精度和小数位数，例如 DECIMAL (10,3)。

假设 p、s 是结果的精度和小数位数。

假设 d 为结果中的整数位数。然后，结果类型为小数，如下所示：


|  |  | 
| --- |--- |
|  d = p1 - s1 \$1 s2  |  D = 10 - 1 \$1 3 结果中的整数位数 = 6  | 
|  s <= MAX (6, s1 \$1 p2 \$11)  |  S <= MAX (6, 1 \$1 10 \$1 1) 结果的小数位数 = 14  | 
|  p = d \$1 s  |  结果的精度 = 18  | 

精度和小数位数上限为其最大值（18，其中小数位数不能大于精度）。

优先级是首先给出至少第一个参数的小数位数 (s >= s1)，然后再加上足够的整数来表示结果而不会溢出

**乘法规则**  
假设 p1、s1 是第一个运算对象 DECIMAL (10,1) 的精度和小数位数。

假设 p2、s2 是第二个运算对象 DECIMAL (10,3) 的精度和小数位数。

假设 p、s 是结果的精度和小数位数。

然后，结果类型为小数，如下所示：


|  |  | 
| --- |--- |
|  p = p1 \$1 p2  |  p = 10 \$1 10 结果的精度 = 18  | 
|  s = s1 \$1 s2  |  s = 1 \$1 3 结果的小数位数 = 4  | 

**求和或减法规则**  
类型推断策略，调用的结果类型是两个精确数字运算对象的小数之和，其中至少有一个运算对象是小数。

假设 p1、s1 是第一个运算对象 DECIMAL (10,1) 的精度和小数位数。

假设 p2、s2 是第二个运算对象 DECIMAL (10,3) 的精度和小数位数。

假设 p、s 是结果的精度和小数位数，如下所示：


|  |  | 
| --- |--- |
|  s = max(s1, s2)  |  s = max (1,3) 结果的小数位数 = 3  | 
|  p = max(p1 - s1, p2 - s2) \$1 s \$1 1  |  p = max(10-1,10-3) \$1 3 \$1 1 结果的精度 = 11  | 

s 和 p 的上限为其最大值

# 流式 SQL 运算符
<a name="sql-reference-streaming-operators"></a>
<a name="TOC1"></a>
**子查询运算符**  
在查询和子查询中使用运算符来组合或测试各种属性或关系的数据。

以下主题将介绍可用的运算符，分为以下几类：
+ [标量运算符](#scalaroprs)
  + [运算符类型](#OPRTYPES)
  + [优先级](#PRECEDENCE)
+ [算术运算符](#ARITHMOPRS)
+ [字符串运算符](sql-reference-string-operators.md)
  +  （联接）
  + LIKE 模式
  + SIMILAR TO 模式
+ [日期、时间戳和间隔运算符](sql-reference-date-timestamp-interval.md)
+ [逻辑运算符](sql-reference-logical-operators.md)
  + 三态布尔逻辑
  + 示例

## IN 运算符
<a name="INOPERATOR"></a>

作为条件测试中的运算符，IN 测试标量或行值在值列表、关系表达式或子查询中的成员资格。

```
Examples:
1. --- IF column IN ('A','B','C')
2. --- IF (col1, col2) IN (
    select a, b from my_table
    )
```

如果在列表、关系表达式的计算结果或子查询返回的行中找到要测试的值，则返回 TRUE；否则返回 FALSE。

**注意**  
IN 具有不同的含义且用在 [CREATE FUNCTION](sql-reference-create-function.md) 中。

## EXISTS 运算符
<a name="EXISTSOPERATOR"></a>

测试关系表达式是否返回任何行；如果返回任何行，则返回 TRUE，否则返回 FALSE。

## 标量运算符
<a name="scalaroprs"></a>
<a name="OPRTYPES"></a>
**运算符类型**  
标量运算符的两大类是：
+ 一元：一元运算符只能对一个运算对象进行运算。一元运算符通常以下列格式对其运算对象进行运算：

  ```
  operator operand
  ```
+ 二进制：二进制运算符对两个运算对象进行运算。二进制运算符以下列格式对其运算对象进行运算：

  ```
  operand1 operator operand2
  ```

下面的运算对象描述中特别注明了一些使用不同格式的运算符。

如果指定给运算符的运算对象是 null，则结果几乎总是 null（有关异常，请参阅关于逻辑运算符的主题）。
<a name="PRECEDENCE"></a>
**优先级**  
流式 SQL 遵循通常的运算符优先级：

1. 计算带括号的子表达式。

1. 计算一元运算符（例如，\$1 或 -，逻辑 NOT）。

1. 计算乘法和除法（\$1 和 /）。

1. 计算加法和减法（\$1 和 -）以及逻辑组合（AND 和 OR）。

如果运算对象之一为 NULL，则结果也为 NULL。如果运算对象的类型不同但可比较，则结果的类型将是精度最高的。如果运算对象的类型相同，则结果将与运算对象的类型相同。例如，5/2 = 2，而不是 2.5，因为 5 和 2 都是整数。

## 算术运算符
<a name="ARITHMOPRS"></a>


| 运算符 | 一元/二进制 | 说明 | 
| --- | --- | --- | 
|  \$1  |  U  |  身份  | 
|  -  |  U  |  求反  | 
|  \$1  |  B  |  加  | 
|  -  |  B  |  减  | 
|  \$1  |  B  |  乘  | 
|  /  |  B  |  除  | 



这些运算符中的每一个都根据正常的算术行为运作，但需要注意以下几点：

1. 如果运算对象之一为 NULL，则结果也为 NULL。

1. 如果运算对象的类型不同但可比较，则结果的类型将是精度最高的。

1. 如果运算对象的类型相同，则结果将与运算对象的类型相同。例如，5/2 = 2，而不是 2.5，因为 5 和 2 都是整数。

### 示例
<a name="operators_examples"></a>


| 操作 | 结果 | 
| --- | --- | 
|  1 \$1 1  |  2  | 
|  2.0 \$1 2.0  |  4.0  | 
|  3.0 \$1 2  |  5.0  | 
|  5/2  |  2  | 
|  5.0/ 2  |  2.50000000000000  | 
|  5\$12\$12  |  12  | 

# 字符串运算符
<a name="sql-reference-string-operators"></a>

您可以使用流式 SQL 的字符串运算符（包括联接和字符串模式比较）来合并和比较字符串。


| 运算符 | 一元/二进制 | 说明 | 注意 | 
| --- | --- | --- | --- | 
|  \$1\$1  |  B  |  联接  |  也适用于二进制类型  | 
|  LIKE  |  B  |  字符串模式比较  |  <string> LIKE <like pattern> [ESCAPE <escape character>]  | 
|  SIMILAR TO  |  B  |  字符串模式比较  |  <string> SIMILAR TO <similar to pattern> [ESCAPE <escape character>]  | 

## 联接
<a name="CONCAT"></a>

此运算符用于联接一个或多个字符串，如下表所示。


| 操作 | 结果 | 
| --- | --- | 
|  'SQL'\$1\$1'stream'  |  SQLstream  | 
|  'SQL'\$1\$1''\$1\$1'stream'  |  SQLstream  | 
|  'SQL'\$1\$1'stream'\$1\$1' Incorporated'  |  SQLstream 注册成立  | 
|  <col1>\$1\$1<col2>\$1\$1<col3>\$1\$1<col4>  |  <col1><col2><col3><col4>  | 

## LIKE 模式
<a name="w2aac10c19c21b9"></a>

LIKE 将字符串与字符串模式进行比较。在模式中，字符“\$1”（下划线）和“%”（百分比）具有特殊含义。


| 模式中的字符 | 效果 | 
| --- | --- | 
|  \$1  |  匹配任何单个字符。  | 
|  %  |  匹配任何子字符串，包括空字符串  | 
|  <any other character>  |  只匹配完全相同的字符  | 

如果任一运算对象为 NULL，则 LIKE 运算的结果为 UNKNOWN。

要显式匹配字符串中的特殊字符，必须使用 ESCAPE 子句指定转义字符。然后，转义字符必须位于模式中的特殊字符之前。下表列出了示例。


| 操作 | 结果 | 
| --- | --- | 
|  'a' LIKE 'a'  |  TRUE  | 
|  'a' LIKE 'A'  |  FALSE  | 
|  'a' LIKE 'b'  |  FALSE  | 
|  'ab' LIKE 'a\$1'  |  TRUE  | 
|  'ab' LIKE 'a%'  |  TRUE  | 
|  'ab' LIKE 'a\$1\$1' ESCAPE '\$1'  |  FALSE  | 
|  'ab' LIKE 'a\$1%' ESCAPE '\$1'  |  FALSE  | 
|  'a\$1' LIKE 'a\$1\$1' ESCAPE '\$1'  |  TRUE  | 
|  'a%' LIKE 'a\$1%' ESCAPE '\$1'  |  TRUE  | 
|  'a' LIKE 'a\$1'  |  FALSE  | 
|  'a' LIKE 'a%'  |  TRUE  | 
|  'abcd' LIKE 'a\$1'  |  FALSE  | 
|  'abcd' LIKE 'a%'  |  TRUE  | 
|  '' LIKE ''  |  TRUE  | 
|  '1a' LIKE '\$1a'  |  TRUE  | 
|  '123aXYZ' LIKE '%a%'  |  TRUE  | 
|  '123aXYZ' LIKE '\$1%\$1a%\$1'  |  TRUE  | 

## SIMILAR TO 模式
<a name="SIMILARPATTERNS"></a>

SIMILAR TO 将字符串与模式进行比较。很像 LIKE 运算符，但功能更强大，因为模式是正则表达式。

在下面的 SIMILAR TO 表中，*seq* 表示显式指定的字符的任何序列（如 '13aq'）。用于匹配的非字母数字字符前面必须有一个在 SIMILAR TO 语句中明确声明的转义字符，例如 '13aq\$1\$1' SIMILAR TO '13aq\$1\$124br\$1\$1% ESCAPE '\$1'（此语句为 TRUE）。

当指定范围时，例如在模式中使用短划线时，将使用当前的排序序列。典型范围为 0-9 和 a-z。[PostgreSQL](https://www.postgresql.org/docs/7.3/static/functions-matching.html) 提供了模式匹配的典型讨论（包括范围）。

当一行需要多次比较时，将首先匹配可以匹配的最里面的模式，然后匹配“下一个最里面的模式”，依此类推。

在应用周围运算之前计算括在圆括号内的表达式和匹配运算，同样优先计算最里面的项目。


| 分隔符 | 模式中的字符 | 效果 | 规则 ID | 
| --- | --- | --- | --- | 
|  圆括号 (  )  |    (  seq  )  |   为 *seq* 分组（用于定义模式表达式的优先级）  |  1  | 
|   方括号 [  ]  |   [  seq  ]  |  匹配 seq 中的任何单个字符  |  2  | 
|   脱字符或音调符号  |   [^seq]  |   匹配不在 seq 中的任何单个字符  |  3  | 
|   |    [ seq ^ seq]  |  匹配 seq 中和不在 seq 中的任何单个字符  |  4  | 
|  短划线  |   <character1>-<character2>  |  指定字符 1 和字符 2 之间的字符范围 （使用一些已知序列，例如 1-9 或 a-z）  |  5  | 
|   条形图  |    [ seq  seq]  |  匹配任一 seq  |  6  | 
|   星号  |    seq\$1  |  匹配 seq 的零个或多个重复项  |  7  | 
|   加号  |   seq\$1  |  匹配 seq 的一个或多个重复项  |  8  | 
|   大括号  |    seq\$1<number>\$1  |  精确匹配 seq 的重复次数   |  9  | 
|    |    seq\$1<low number>,<high number>\$1  |  匹配 seq 的低重复次数或更多重复次数，最多匹配高重复次数  |  10  | 
|   问号  |    seq?  |  匹配 seq 的零个或一个实例  |  11  | 
|   下划线  |   \$1  |   匹配任何单个字符  |  12  | 
|   百分比  |   %  |   匹配任何子字符串，包括空字符串  |  13  | 
|   字符  |   <any other character>  |   只匹配完全相同的字符  |  14  | 
|    NULL  |    NULL  |     如果任一操作数为 NULL，则 SIMILAR TO 运算的结果为 UNKNOWN。  |  15  | 
|    非字母数字  |   特殊字符  |   要显式匹配字符串中的特殊字符， 该特殊字符前面必须有一个使用 在模式末尾指定的 ESCAPE 子句定义的转义字符。  |  16  | 

下表列出了示例。


| 操作 | 结果 | 规则 | 
| --- | --- | --- | 
|  'a' SIMILAR TO 'a'  |  TRUE  |  14  | 
|  'a' SIMILAR TO 'A'  |  FALSE  |  14  | 
|  'a' SIMILAR TO 'b'  |  FALSE  |  14  | 
|  'ab' SIMILAR TO 'a\$1'  |  TRUE  |  12  | 
|  'ab' SIMILAR TO 'a%'  |  TRUE  |  13  | 
|  'a' SIMILAR TO 'a\$1'  |  FALSE  |  12 和 14  | 
|  'a' SIMILAR TO 'a%'  |  TRUE  |  13  | 
|  'abcd' SIMILAR TO 'a\$1'  |  FALSE  |  12  | 
|  'abcd' SIMILAR TO 'a%'  |  TRUE  |  13  | 
|  '' SIMILAR TO ''  |  TRUE  |  14  | 
|  '1a' SIMILAR TO '\$1a'  |  TRUE  |  12  | 
|  '123aXYZ' SIMILAR TO ''  |  TRUE  |  14  | 
|  '123aXYZ' SIMILAR TO '\$1%\$1a%\$1'  |  TRUE  |  13 和 12  | 
|  'xy' SIMILAR TO '(xy)'  |  TRUE  |  1  | 
|  'abd' SIMILAR TO '[ab][bcde]d'  |  TRUE  |  2  | 
|  'bdd' SIMILAR TO '[ab][bcde]d'  |  TRUE  |  2  | 
|  'abd' SIMILAR TO '[ab]d'  |  FALSE  |  2  | 
|  'cd' SIMILAR TO '[a-e]d'  |  TRUE  |  2  | 
|  'cd' SIMILAR TO '[a-e^c]d'  |  FALSE  |  4  | 
|  'cd' SIMILAR TO '[^(a-e)]d'  |  INVALID  | 
|  'yd' SIMILAR TO '[^(a-e)]d'  |  INVALID  | 
|  'amy' SIMILAR TO 'amyfred'  |  TRUE  |  6  | 
|  'fred' SIMILAR TO 'amyfred'  |  TRUE  |  6  | 
|  'mike' SIMILAR TO 'amyfred'  |  FALSE  |  6  | 
|  'acd' SIMILAR TO 'ab\$1c\$1d'  |  TRUE  |  7 和 8  | 
|  'accccd' SIMILAR TO 'ab\$1c\$1d'  |  TRUE  |  7 和 8  | 
|  'abd' SIMILAR TO 'ab\$1c\$1d'  |  FALSE  |  7 和 8  | 
|  'aabc' SIMILAR TO 'ab\$1c\$1d'  |  FALSE  |   | 
|  'abb' SIMILAR TO 'a(b\$13\$1)'  |  FALSE  |  9  | 
|  'abbb' SIMILAR TO 'a(b\$13\$1)'  |  TRUE  |  9  | 
|  'abbbbb' SIMILAR TO 'a(b\$13\$1)'  |  FALSE  |  9  | 
|  'abbbbb' SIMILAR TO 'ab\$13,6\$1'  |  TRUE  |  10  | 
|  'abbbbbbbb' SIMILAR TO 'ab\$13,6\$1'  |  FALSE  |  10  | 
|  '' SIMILAR TO 'ab?'  |  FALSE  |  11  | 
|  '' SIMILAR TO '(ab)?'  |  TRUE  |  11  | 
|  'a' SIMILAR TO 'ab?'  |  TRUE  |  11  | 
|  'a' SIMILAR TO '(ab)?'  |  FALSE  |  11  | 
|  'a' SIMILAR TO 'a(b?)'  |  TRUE  |  11  | 
|  'ab' SIMILAR TO 'ab?'  |  TRUE  |  11  | 
|  'ab' SIMILAR TO 'a(b?)'  |  TRUE  |  11  | 
|  'abb' SIMILAR TO 'ab?'  |  FALSE  |  11  | 
|  'ab' SIMILAR TO 'a\$1\$1' ESCAPE '\$1'  |  FALSE  |  16  | 
|  'ab' SIMILAR TO 'a\$1%' ESCAPE '\$1'  |  FALSE  |  16  | 
|  'a\$1' SIMILAR TO 'a\$1\$1' ESCAPE '\$1'  |  TRUE  |  16  | 
|  'a%' SIMILAR TO 'a\$1%' ESCAPE '\$1'  |  TRUE  |  16  | 
|  'a(b\$13\$1)' SIMILAR TO 'a(b\$13\$1)'  |  FALSE  |  16  | 
|  'a(b\$13\$1)' SIMILAR TO 'a\$1(b\$1\$13\$1\$1\$1)' ESCAPE '\$1'  |  TRUE  |  16  | 

# 逻辑运算符
<a name="sql-reference-logical-operators"></a>

逻辑运算符允许您创建条件并测试其结果。


| 运算符 | 一元/二进制 | 说明 | 运算对象 | 
| --- | --- | --- | --- | 
|  NOT  |  U  |  逻辑求反  |  布尔值  | 
|  AND  |  B  |  连词  |  布尔值  | 
|  或  |  B  |  析取  |  布尔值  | 
|  IS  |  B  |  逻辑断言  |  布尔值  | 
|  IS NOT UNKNOWN  |  U  |  否定未知比较： <expr> IS NOT UNKNOWN  |  布尔值  | 
|  IS NULL  |  U  |  Null 比较： <expr> IS NULL  |  任何  | 
|  IS NOT NULL  |  U  |  否定 null 比较： <expr> IS NOT NULL  |  任何  | 
|  =  |  B  |  等于  |  任何  | 
|  \$1=  |  B  |  不等于  |  任何  | 
|  <>  |  B  |  不等于  |  任何  | 
|  >  |  B  |  Greater than  |  有序类型（数字、字符串、日期、时间）  | 
|  >=  |  B  |  大于或等于（不小于）  |  有序类型  | 
|  <  |  B  |  Less than  |  有序类型  | 
|  <=  |  B  |  小于或等于（不大于）  |  有序类型  | 
|  BETWEEN  |  三元  |  范围比较： col1 BETWEEN expr1 AND expr2  |  有序类型  | 
|  IS DISTINCT FROM  |  B  |  区别  |  任何  | 
|  IS NOT DISTINCT FROM  |  B  |  否定区别  |  任何  | 

## 三态布尔逻辑
<a name="three_state_boolean_logic"></a>

SQL 布尔值有三种可能的状态，而不是通常的两种状态：TRUE、FALSE 和 UNKNOWN，其中最后一种等同于布尔值 NULL。TRUE 和 FALSE 运算对象通常根据普通的双态布尔逻辑起作用，但是在将它们与 UNKNOWN 运算对象配对时会适用其他规则，如下表所示。

**注意**  
UNKOWN 表示“可能是 TRUE，也可能是 FALSE”，或者换句话说，“不绝对是 TRUE，也不绝对是 FALSE”。这种理解可以帮助您弄清为什么表中的某些表达式会这样计算。


**求反 (NOT)**  

| 操作 | 结果 | 
| --- | --- | 
|  NOT TRUE  |  FALSE  | 
|  NOT FALSE  |  TRUE  | 
|  NOT UNKNOWN  |  UNKNOWN  | 


**连词 (AND)**  

| 操作 | 结果 | 
| --- | --- | 
|  TRUE AND TRUE  |  TRUE  | 
|  TRUE AND FALSE  |  FALSE  | 
|  TRUE AND UNKNOWN  |  UNKNOWN  | 
|  FALSE AND TRUE  |  FALSE  | 
|  FALSE AND FALSE  |  FALSE  | 
|  FALSE AND UNKNOWN  |  FALSE  | 
|  UNKNOWN AND TRUE  |  UNKNOWN  | 
|  UNKNOWN AND FALSE  |  FALSE  | 
|  UNKNOWN AND UNKNOWN  |  UNKNOWN  | 


**析取 (OR)**  

| 操作 | 结果 | 
| --- | --- | 
|  TRUE OR TRUE  |  TRUE  | 
|  TRUE OR FALSE  |  TRUE  | 
|  TRUE OR UNKNOWN  |  TRUE  | 
|  FALSE OR TRUE  |  TRUE  | 
|  FALSE OR FALSE  |  FALSE  | 
|  FALSE OR UNKNOWN  |  UNKNOWN  | 
|  UNKNOWN OR TRUE  |  TRUE  | 
|  UNKNOWN OR FALSE  |  UNKNOWN  | 
|  UNKNOWN OR UNKNOWN  |  UNKNOWN  | 


**断言 (IS)**  

| 操作 | 结果 | 
| --- | --- | 
|  TRUE IS TRUE  |  TRUE  | 
|  TRUE IS FALSE  |  FALSE  | 
|  TRUE IS UNKNOWN  |  FALSE  | 
|  FALSE IS TRUE  |  FALSE  | 
|  FALSE IS FALSE  |  TRUE  | 
|  FALSE IS UNKNOWN  |  FALSE  | 
|  UNKNOWN IS TRUE  |  FALSE  | 
|  UNKNOWN IS FALSE  |  FALSE  | 
|  UNKNOWN IS UNKNOWN  |  TRUE  | 


**IS NOT UNKNOWN**  

| 操作 | 结果 | 
| --- | --- | 
|  TRUE IS NOT UNKNOWN  |  TRUE  | 
|  FALSE IS NOT UNKNOWN  |  TRUE  | 
|  UNKNOWN IS NOT UNKNOWN  |  FALSE  | 

IS NOT UNKNOWN 本身就是一个特殊的运算符。表达式“x IS NOT UNKNOWN”等同于“(x IS TRUE) OR (x IS FALSE)”，而不是“x IS (NOT UNKNOWN)”。因此，在上表中替换：


| x | 操作 | 结果 |   | 在“(x IS TRUE) OR (x IS FALSE)”中替换 x 的结果 | 
| --- | --- | --- | --- | --- | 
|  TRUE  |  TRUE IS NOT UNKNOWN  |  TRUE  |  变为  |  “(TRUE IS TRUE) OR (TRUE IS FALSE)”，即 TRUE  | 
|  FALSE  |  FALSE IS NOT UNKNOWN  |  TRUE  |  变为  |  “(FALSE IS TRUE) OR (FALSE IS FALSE)”，即 TRUE  | 
|  UNKNOWN  |  UNKNOWN IS NOT UNKNOWN  |  FALSE  |  变为  |  “(UNKNOWN IS TRUE) OR (UNKNOWN IS FALSE)”，即 FALSE， 因为 UNKNOWN 既不是 TRUE 也不是 FALSE  | 

由于 IS NOT UNKNOWN 是一个特殊的运算符，因此上述运算在 IS 这个词周围是不可传递的：


| 操作 | 结果 | 
| --- | --- | 
|  NOT UNKNOWN IS TRUE  |  FALSE  | 
|  NOT UNKNOWN IS FALSE  |  FALSE  | 
|  NOT UNKNOWN IS UNKNOWN  |  TRUE  | 


**IS NULL 和 IS NOT NULL**  

| 操作 | 结果 | 
| --- | --- | 
|  UNKNOWN IS NULL  |  TRUE  | 
|  UNKNOWN IS NOT NULL  |  FALSE  | 
|  NULL IS NULL  |  TRUE  | 
|  NULL IS NOT NULL  |  FALSE  | 


**IS DISTINCT FROM 和 IS NOT DISTINCT FROM**  

| 操作 | 结果 | 
| --- | --- | 
|  UNKNOWN IS DISTINCT FROM TRUE  |  TRUE  | 
|  UNKNOWN IS DISTINCT FROM FALSE  |  TRUE  | 
|  UNKNOWN IS DISTINCT FROM UNKNOWN  |  FALSE  | 
|  UNKNOWN IS NOT DISTINCT FROM TRUE  |  FALSE  | 
|  UNKNOWN IS NOT DISTINCT FROM FALSE  |  FALSE  | 
|  UNKNOWN IS NOT DISTINCT FROM UNKNOWN  |  TRUE  | 



通常，“x IS DISTINCT FROM y”类似于“x <> y”，在 x 或 y（而非二者）为 NULL 时也为 true 的情况除外。DISTINCT FROM 与“相同”相反，后者的通常含义是值（true、false 或 unknown）与其自身相同，并且与其他所有值不同。IS 和 IS NOT 运算符以一种特殊的方式处理 UNKOWN，因为它表示“可能是 TRUE，也许是 FALSE”。

## 其他逻辑运算符
<a name="w2aac10c19c25b9"></a>

对于所有其他运算符，传递 NULL 或 UNKNOWN 运算对象将导致结果为 UNKNOWN（与 NULL 相同）。


**示例**  

| 操作 | 结果 | 
| --- | --- | 
|  TRUE AND CAST( NULL AS BOOLEAN)  |  UNKNOWN  | 
|  FALSE AND CAST( NULL AS BOOLEAN)  |  FALSE  | 
|  1 > 2  |  FALSE  | 
|  1 < 2  |  TRUE  | 
|  'foo' = 'bar'  |  FALSE  | 
|  'foo' <> 'bar'  |  TRUE  | 
|  'foo' <= 'bar'  |  FALSE  | 
|  'foo' <= 'bar'  |  TRUE  | 
|  3 BETWEEN 1 AND 5  |  TRUE  | 
|  1 BETWEEN 3 AND 5  |  FALSE  | 
|  3 BETWEEN 3 AND 5  |  TRUE  | 
|  5 BETWEEN 3 AND 5  |  TRUE  | 
|  1 IS DISTINCT FROM 1.0  |  FALSE  | 
|  CAST( NULL AS INTEGER ) IS NOT DISTINCT FROM CAST (NULL AS INTEGER)  |  TRUE  | 

# 表达式和文字
<a name="sql-reference-expressions"></a>
<a name="value-expression"></a>
**值表达式**  
值表达式由以下语法定义：

```
value-expression := <character-expression > | <number-expression> | <datetime-expression> | <interval-expression> | <boolean-expression>
```
<a name="character-expression"></a>
**字符（字符串）表达式**  
字符表达式由以下语法定义：

```
character-expression := <character-literal>
                  | <character-expression> || <character-expression>
                  | <character-function> ( <parameters> )

 character-literal  := <quote> { <character> }* <quote>
 string-literal     := <quote> { <character> }* <quote>
 character-function   :=   CAST | COALESCE | CURRENT_PATH
                  | FIRST_VALUE  | INITCAP | LAST_VALUE
                  | LOWER | MAX | MIN | NULLIF
                  | OVERLAY | SUBSTRING| SYSTEM_USER
                  | TRIM | UPPER 
                  | <user-defined-function>
```

请注意，Amazon Kinesis Data Analytics 流式 SQL 支持 Unicode 字符文字，例如 u&'foo'。与使用常规文字一样，您可以对这些文字中的单引号进行转义，例如 u&'can''t'。与常规文字不同，您可以使用 Unicode 转义符：例如，u&'\$10009' 是一个仅由制表符组成的字符串。您可以用另一个 \$1 来转义 \$1，例如 u&'back\$1\$1slash'。Amazon Kinesis Data Analytics 还支持备用转义字符，例如 u&'\$10009\$1\$1' uescape '\$1' 是一个制表符。
<a name="numeric-expression"></a>
**数字表达式**  
数字表达式由以下语法定义：

```
number-expression := <number-literal>
                  | <number-unary-oper> <number-expression>
                  | <number-expression> <number-operator> <number-expression>
                  | <number-function> [ ( <parameters> ) ]
 number-literal :=   <UNSIGNED_INTEGER_LITERAL> | <DECIMAL_NUMERIC_LITERAL>
                           | <APPROX_NUMERIC_LITERAL>
```



```
--Note: An <APPROX_NUMERIC_LITERAL> is a number in scientific notation, such as with an 
--exponent, such as 1e2 or -1.5E-6.
number-unary-oper := + | -
 number-operator      :=   + | - | / | *

 number-function      :=   ABS | AVG | CAST | CEIL
                          | CEILING | CHAR_LENGTH
                          | CHARACTER_LENGTH | COALESCE
                          | COUNT | EXP | EXTRACT
                          | FIRST_VALUE
                          | FLOOR | LAST_VALUE
                          | LN | LOG10
                          | MAX | MIN  | MOD
                          | NULLIF
                          | POSITION | POWER
                          | SUM| <user-defined-function>
```
<a name="datetime-expression"></a>
**日期/时间表达式**  
日期/时间表达式由以下语法定义：

```
datetime-expression := <datetime-literal>
                          | <datetime-expression> [ + | - ] <number-expression>
                          | <datetime-function> [ ( <parameters> ) ]
 datetime-literal    :=  <left_brace> { <character-literal> } *  <right_brace>
                          |  <DATE> { <character-literal> } *
                          |  <TIME> { <character-literal> } *
                          |  <TIMESTAMP> { <character-literal> } *
 datetime-function   :=    CAST | CEIL | CEILING
                          | CURRENT_DATE | CURRENT_ROW_TIMESTAMP
                          | CURRENT_ROW_TIMESTAMP
                          | FIRST_VALUE| FLOOR
                          | LAST_VALUE | LOCALTIME
                          | LOCALTIMESTAMP | MAX | MIN
                          | NULLIF | ROWTIME
                          | <user-defined-function>
 <time unit>         :=  YEAR | MONTH | DAY | HOUR | MINUTE | SECOND
```
<a name="INTERVAL-EXPRESSION"></a>
**间隔表达式**  
间隔表达式由以下语法定义：

```
interval-expression := <interval-literal>
                          | <interval-function>
 interval-literal    :=    <INTERVAL> ( <MINUS> | <PLUS> ) <QUOTED_STRING> <IntervalQualifier>
 IntervalQualifier  :=  <YEAR> ( <UNSIGNED_INTEGER_LITERAL> )
                          | <YEAR> ( <UNSIGNED_INTEGER_LITERAL> ) <TO> <MONTH>
                          |  <MONTH> [ ( <UNSIGNED_INTEGER_LITERAL> ) ]
                          |  <DAY> [ (  <UNSIGNED_INTEGER_LITERAL> )  ]
                          |  <DAY> [ (  <UNSIGNED_INTEGER_LITERAL> )  ] <TO>
                                    { <HOUR> | <MINUTE> | <SECOND> [ ( <UNSIGNED_INTEGER_LITERAL> ) ] }
                          |  <HOUR> [ (  <UNSIGNED_INTEGER_LITERAL> ) ]
                          |  <HOUR> [ (  <UNSIGNED_INTEGER_LITERAL> ) ] <TO>
                                    { <MINUTE> | <SECOND> [ <UNSIGNED_INTEGER_LITERAL> ] }
                          |  <MINUTE> [ ( <UNSIGNED_INTEGER_LITERAL> )  ]
                          |  <MINUTE> [ ( <UNSIGNED_INTEGER_LITERAL> )  ] <TO>
                                     <SECOND> [ ( <UNSIGNED_INTEGER_LITERAL> ) ]
                          |  <SECOND> [ ( <UNSIGNED_INTEGER_LITERAL> )  ]
 interval-function   :=    ABS  | CAST | FIRST_VALUE
                          | LAST_VALUE | MAX | MIN
                          | NULLIF| <user-defined-function>
```
<a name="BOOLEAN_EXPRESSION"></a>
**布尔表达式**  
布尔表达式由以下语法定义：

```
boolean-expression := <boolean-literal>
                  | <boolean-expression> <boolean-operator> <boolean-expression>
                  | <boolean-unary-oper> <boolean-expression>
                         | <boolean-function> ( <parameters> )
                         | ( <boolean-expression> )
 boolean-literal    :=  TRUE | FALSE
 boolean-operator   :=  AND | OR
 boolean-unary-oper :=  NOT
 boolean-function   :=    CAST | FIRST_VALUE | LAST_VALUE
                         | NULLIF | <user-defined-function>
```

# 单调表达式和运算符
<a name="sql-reference-monotonic-expressions-operators"></a>

由于 Amazon Kinesis Data Analytics 查询对无限行流进行操作，因此只有在对这些流有所了解的情况下，才能进行某些操作。

例如，对于给定订单流，要求提供按日期和产品汇总订单的流是合理的（因为天数在增加），但要求提供按产品和发货状态汇总订单的流则不合理。我们永远无法完成通过小组件 X 发往俄勒冈州的汇总，因为我们永远看不到通过小组件发往俄勒冈州的“最后一个”订单。

这种按特定列或表达式排序的流的属性称为单调性。

一些与时间相关的定义：
+ **单调**。如果表达式是升序或降序的，则是单调的。等效的措辞是“不减少或不增加”。
+ **升序**。如果给定行的 e 值始终大于或等于前一行中的值，则表达式 e 在流中是升序的。
+ **降序**。如果给定行的 e 值始终小于或等于前一行中的值，则表达式 e 在流中是降序的。
+ **严格升序**。如果给定行的 e 值始终大于前一行中的值，则表达式 e 在流中是严格升序的。
+ **严格降序**。如果给定行的 e 值始终小于前一行中的值，则表达式 e 在流中是严格降序的。
+ **常量**。如果给定行的 e 值始终等于前一行中的值，则表达式 e 在流中是常量的。

请注意，根据这个定义，常量表达式被认为是单调的。

## 单调列
<a name="sql-reference-monotonic-expressions-columns"></a>

ROWTIME 系统列是升序的。ROWTIME 列不是严格升序的：连续行具有相同的时间戳是可以接受的。

Amazon Kinesis Data Analytics 可防止客户端在时间戳小于其写入流中的前一行的流中插入一行。Amazon Kinesis Data Analytics 还可确保，如果多个客户端在同一个流中插入行，则合并这些行，使得 ROWTIME 列是升序的。

例如，断言 orderId 列是升序的；或者排序顺序中没有 orderId 超过 100 行，显然是非常有用的。但是，当前版本不支持声明的排序键。

## 单调表达式
<a name="sql-reference-monotonic-expressions-expressions"></a>

如果 Amazon Kinesis Data Analytics 知道表达式的参数是单调的，就能推断出该表达式是单调的。（另请参阅[单调函数](sql-reference-monotonic.md)。）

另一个定义：

单调的函数或运算符

如果将函数或运算符应用于严格增加的值序列时，生成的结果序列是单调的，则该函数或运算符就是单调的。

例如，将 FLOOR 函数应用于升序的输入 \$11.5、3、5、5.8、6.3\$1 时，会生成 \$11、3、5、5、6\$1。请注意，输入是严格升序的，但输出只是升序的（包括重复值）。

## 推断单调性的规则
<a name="sql-reference-monotonic-rules"></a>

Amazon Kinesis Data Analytics 要求一个或多个分组表达式有效才能使流式 GROUP BY 语句有效。在其他情况下，如果 Amazon Kinesis Data Analytics 知道单调性，就能更高效地运行；例如，如果它知道某个特定键再也不会出现在流中，就能从窗口式聚合总数表中删除条目。

为了以这种方式利用单调性，Amazon Kinesis Data Analytics 使用了一套规则来推断表达式的单调性。下面是推断单调性的规则：


| Expression | 单调性 | 
| --- | --- | 
|  c  |  常量  | 
|  [FLOOR](sql-reference-floor.md)(m)  |  与 m 相同，但不严格  | 
|  [CEIL/CEILING](sql-reference-ceil.md)(m)  |  与 m 相同，但不严格  | 
|  [CEIL/CEILING](sql-reference-ceil.md)(m TO timeUnit)  |  与 m 相同，但不严格  | 
|  [FLOOR](sql-reference-floor.md)(m TO timeUnit)  |  与 m 相同，但不严格  | 
|  [SUBSTRING](sql-reference-substring.md)(m FROM 0 FOR c)  |  与 m 相同，但不严格  | 
|  \$1 m  |  与 m 相同  | 
|  -m  |  与 m 相反  | 
|  m \$1 c c \$1 m  |  与 m 相同  | 
|  m1 \$1 m2  |  如果 m1 和 m2 的方向相同，则与 m1 相同； 否则不是单调的  | 
|  c - m  |  与 m 相反  | 
|  m \$1 c c \$1 m  |  如果 c 为正数，则与 m 相同； 如果 c 为负数，则与 m 相反；如果 c 为 0，则是常数 (0)  | 
|  c / m  |  如果 m 始终是正数或始终是负数，并且 c 和 m 的符号相同，则与 m 相同； 如果 m 始终是正数或始终是负数，并且 c 和 m 的符号不同，则与 m 相反； 否则不是单调的  | 
|   |  常量  | 
|  [LOCALTIME](sql-reference-localtime.md) [LOCALTIMESTAMP](sql-reference-local-timestamp.md) [CURRENT\$1ROW\$1TIMESTAMP](sql-reference-current-row-timestamp.md) [CURRENT\$1DATE](sql-reference-current-date.md)  |   升序  | 

在整个表中，c 是一个常数，m（以及 m1 和 m2）是一个单调表达式。

# 条件子句
<a name="sql-reference-conditions"></a>

引用者：
+ SELECT 子句：[HAVING 子句](sql-reference-having-clause.md)、[WHERE 子句](sql-reference-where-clause.md) 和 [JOIN 子句](sql-reference-join-clause.md)。（另请参阅 SELECT 图表及其 [SELECT 子句](sql-reference-select-clause.md)。）
+ DELETE

条件是任何类型为 BOOLEAN 的值表达式，如下例所示：
+ 2<4
+ TRUE
+ FALSE
+ expr\$117 IS NULL
+ NOT expr\$119 IS NULL AND expr\$123 < expr>29
+ expr\$117 IS NULL OR ( NOT expr\$119 IS NULL AND expr\$123 < expr>29 )

# 时间谓词
<a name="sql-reference-temporal-predicate"></a>

下表以图形方式显示了标准 SQL 支持的时间谓词以及对 Amazon Kinesis Data Analytics 支持的 SQL 标准的扩展。它显示了每个谓词所涵盖的关系。每个关系均表示为时间间隔上限和下限，并具有组合意义 *upperInterval predicate lowerInterval evaluates to TRUE*。前 7 个谓词是标准 SQL。最后 10 个谓词（以粗体显示）是 Amazon Kinesis Data Analytics 对 SQL 标准的扩展。


| 谓词 | 涵盖的关系 | 
| --- | --- | 
|  CONTAINS  |  ![\[Blue rectangular shapes arranged in horizontal rows, resembling a simplified layout or structure.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sqlrf_contains.png)  | 
|  OVERLAPS  |  ![\[Blue rectangular boxes arranged in rows, representing a structured layout or diagram.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sqlrf_overlaps.png)  | 
|  EQUALS  |  ![\[Two horizontal blue rectangles with orange borders, stacked vertically.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sqlrf_equals.png)  | 
|  PRECEDES  |  ![\[Four blue rectangular shapes representing placeholder text or content blocks.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sqlrf_precedes.png)  | 
|  SUCCEEDS  |  ![\[Four blue rectangular shapes arranged horizontally with gaps between them.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sqlrf_succeeds.png)  | 
|  IMMEDIATELY PRECEDES  |  ![\[Blue rectangular shapes representing text or content placeholders.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sqlrf_immediately_precedes.png)  | 
|  IMMEDIATELY SUCCEEDS  |  ![\[Two horizontal blue rectangular shapes against a white background.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sqlrf_immediately_succeeds.png)  | 
|  **LEADS**  |  ![\[Four blue rectangular buttons with orange outlines, arranged horizontally.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sqlrf_leads.png)  | 
|  **LAGS**  |  ![\[Four blue rectangular bars of varying lengths arranged horizontally.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sqlrf_lags.png)  | 
|  **STRICTLY CONTAINS**  |  ![\[Two blue rectangular shapes with orange outlines, one larger above a smaller one.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sqlrf_strictly_contains.png)  | 
|  **STRICTLY OVERLAPS**  |  ![\[Two blue rectangular shapes, one longer than the other, stacked vertically.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sqlrf_strictly_overlaps.png)  | 
|  **STRICTLY PRECEDES**  |  ![\[Two horizontal blue bars representing placeholder elements in a user interface.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sqlrf_strictly_precedes.png)  | 
|  **STRICTLY SUCCEEDS**  |  ![\[Two blue rectangular shapes representing UI elements or buttons.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sqlrf_strictly_succeeds.png)  | 
|  **STRICTLY LEADS**  |  ![\[Two blue rectangular shapes representing text or content blocks.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sqlrf_strictly_leads.png)  | 
|  **STRICTLY LAGS**  |  ![\[Two horizontal blue rectangular shapes, one above the other, against a white background.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sqlrf_strictly_lags.png)  | 
|  **IMMEDIATELY LEADS**  |  ![\[Two blue rectangular shapes, one longer than the other, stacked vertically.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sqlrf_immediately_leads.png)  | 
|  **IMMEDIATELY LAGS**  |  ![\[Two blue rectangular shapes, one longer than the other, stacked vertically.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sqlrf_immediately_lags.png)  | 

为了实现简洁的表达式，Amazon Kinesis Data Analytics 还支持以下扩展：
+ 可选 PERIOD 关键字 – 可忽略 PERIOD 关键字。
+ 紧凑链接 – 如果这些谓词中有两个背靠背出现并由 AND 分隔，则可以忽略 AND，前提是第一个谓词的右间隔与第二个谓词的左间隔相同。
+ TSDIFF – 此函数将选取两个 TIMESTAMP 参数并返回两者之差（以毫秒为单位）。

例如，您可以编写以下表达式：

```
  PERIOD (s1,e1) PRECEDES PERIOD(s2,e2)
  AND PERIOD(s2, e2) PRECEDES PERIOD(s3,e3)
```

更简洁的版本如下所示：

```
(s1,e1) PRECEDES (s2,e2) PRECEDES PERIOD(s3,e3)
```

以下简洁的表达方式：

```
TSDIFF(s,e) 
```

即以下表达式：

 

```
CAST((e - s) SECOND(10, 3) * 1000 AS BIGINT)
```

最后，标准 SQL 允许 CONTAINS 谓词将单个 TIMESTAMP 作为其右侧参数。例如，以下表达式：

```
PERIOD(s, e) CONTAINS t
```

等效于以下表达式：

```
s <= t AND t < e
```

## 语法
<a name="sql-reference-temporal-predicate-syntax"></a>

时间谓词被集成到一个值为 BOOLEAN 的新表达式中：

```
<period-expression> :=
  <left-period> <half-period-predicate> <right-period>

<half-period-predicate> := 
  <period-predicate> [ <left-period> <half-period-predicate> ]

<period-predicate> :=
   EQUALS
 | [ STRICTLY ] CONTAINS
 | [ STRICTLY ] OVERLAPS
 | [ STRICTLY | IMMEDIATELY ] PRECEDES
 | [ STRICTLY | IMMEDIATELY ] SUCCEEDS
 | [ STRICTLY | IMMEDIATELY ] LEADS
 | [ STRICTLY | IMMEDIATELY ] LAGS

<left-period> := <bounded-period>

<right-period> := <bounded-period> | <timestamp-expression>

<bounded-period> := [ PERIOD ] ( <start-time>, <end-time> )

<start-time> := <timestamp-expression>

<end-time> := <timestamp-expression>

<timestamp-expression> :=
  an expression which evaluates to a TIMESTAMP value

where <right-period> may evaluate to a <timestamp-expression> only if
the immediately preceding <period-predicate> is [ STRICTLY ] CONTAINS
```

以下内置函数支持此布尔表达式：

```
BIGINT tsdiff( startTime TIMESTAMP, endTime TIMESTAMP )
```

以毫秒为单位返回 (endTime - startTime) 的值。

```
```

## 示例
<a name="sql-reference-temporal-predicate-example"></a>

以下示例代码会记录因窗户在空调开启时处于打开状态而发出的警报：

```
create or replace pump alarmPump stopped as
  insert into alarmStream( houseID, roomID, alarmTime, alarmMessage )
    select stream w.houseID, w.roomID, current_timestamp,
                   'Window open while air conditioner is on.'
    from
        windowIsOpenEvents over (range interval '1' minute preceding) w
    join
        acIsOnEvents over (range interval '1' minute preceding) h
    on w.houseID = h.houseID
    where (h.startTime, h.endTime) overlaps (w.startTime, w.endTime);
```

## 示例使用案例
<a name="sql-reference-temporal-predicate-sample-use-case"></a>

当两个人尝试在两个不同的地点同时使用同一张信用卡时，以下查询将使用时间谓词发出欺诈警报：

```
create pump creditCardFraudPump stopped as
 insert into alarmStream
  select stream
    current_timestamp, creditCardNumber, registerID1, registerID2
  from transactionsPerCreditCard
  where registerID1 <> registerID2
  and (startTime1, endTime1) overlaps (startTime2, endTime2)
;
```

前面的代码示例使用具有以下数据集的输入流：

```
(current_timestamp  TIMESTAMP,
  creditCardNumber  VARCHAR(16),
  registerID1       VARCHAR(16),
  registerID2       VARCHAR(16),
  startTime1        TIMESTAMP,
  endTime1          TIMESTAMP,
  startTime2        TIMESTAMP,
  endTime2          TIMESTAMP)
```

# 保留字和关键字
<a name="sql-reference-reserved-words-keywords"></a>

**保留字**  
以下是自版本 5.0.1 起 Amazon Kinesis Data Analytics 应用程序中的保留关键字的列表。


|  | 
| --- |
| A | 
| ABS | ALL | ALLOCATE | 
| 允许 | ALTER | ANALYZE | 
| AND | ANY | APPROXIMATE\$1ARRIVAL\$1TIME | 
| ARE | ARRAY | AS | 
| ASENSITIVE | ASYMMETRIC | AT | 
| ATOMIC | AUTHORIZATION | AVG | 
| B | 
| BEGIN | BETWEEN | BIGINT | 
| BINARY | BIT | BLOB | 
| BOOLEAN | BOTH | BY | 
| C | 
| CALL | CALLED | CARDINALITY | 
| CASCADED | CASE | CAST | 
| CEIL | CEILING | CHAR | 
| CHARACTER | CHARACTER\$1LENGTH | CHAR\$1LENGTH | 
| CHECK | CHECKPOINT | CLOB | 
| CLOSE | CLUSTERED | COALESCE | 
| COLLATE | COLLECT | COLUMN | 
| COMMIT | CONDITION | CONNECT | 
| CONSTRAINT | CONVERT | CORR | 
| CORRESPONDING | COUNT | COVAR\$1POP | 
| COVAR\$1SAMP | CREATE | CROSS | 
| CUBE | CUME\$1DIST | CURRENT | 
| CURRENT\$1CATALOG | CURRENT\$1DATE | CURRENT\$1DEFAULT\$1TRANSFORM\$1GROUP | 
| CURRENT\$1PATH | CURRENT\$1ROLE | CURRENT\$1SCHEMA | 
| CURRENT\$1TIME | CURRENT\$1TIMESTAMP | CURRENT\$1TRANSFORM\$1GROUP\$1FOR\$1TYPE | 
| CURRENT\$1USER | CURSOR | CYCLE | 
| D | 
| DATE | DAY | DEALLOCATE | 
| DEC | DECIMAL | DECLARE | 
| DEFAULT | DELETE | DENSE\$1RANK | 
| DEREF | DESCRIBE | DETERMINISTIC | 
| DISALLOW | DISCONNECT | DISTINCT | 
| DOUBLE | DROP | DYNAMIC | 
| E | 
| EACH | ELEMENT | ELSE | 
| END | END-EXEC | ESCAPE | 
| EVERY | EXCEPT | EXEC | 
| EXECUTE | EXISTS | EXP | 
| EXPLAIN | EXP\$1AVG | EXTERNAL | 
| EXTRACT | 
| F | 
| FALSE | FETCH | FILTER | 
| FIRST\$1VALUE | FLOAT | FLOOR | 
| FOR | FOREIGN | FREE | 
| FROM | FULL | FUNCTION | 
| FUSION | 
| G | 
| GET | GLOBAL | GRANT | 
| GROUP | GROUPING | 
| H | 
| HAVING | HOLD | HOUR | 
| I | 
| IDENTITY | 忽略 | IMPORT | 
| IN | INDICATOR | INITCAP | 
| INNER | INOUT | INSENSITIVE | 
| INSERT | INT | INTEGER | 
| INTERSECT | INTERSECTION | INTERVAL | 
| INTO | IS | 
| J | 
| JOIN | 
| L | 
| LANGUAGE | LARGE | LAST\$1VALUE | 
| LATERAL | LEADING | LEFT | 
| LIKE | LIMIT | LN | 
| LOCAL | LOCALTIME | LOCALTIMESTAMP | 
| LOWER | 
| M | 
| MATCH | MAX | MEMBER | 
| MERGE | METHOD | MIN | 
| MINUTE | MOD | MODIFIES | 
| MODULE | MONTH | MULTISET | 
| 否 | 
| NATIONAL | NATURAL | NCHAR | 
| NCLOB | 新 | 否 | 
| NODE | NONE | NORMALIZE | 
| NOT | NTH\$1VALUE | NULL | 
| NULLIF | NUMERIC | 
| O | 
| OCTET\$1LENGTH | OF | OLD | 
| ON | ONLY | OPEN | 
| 或 | ORDER | OUT | 
| OUTER | OVER | OVERLAPS | 
| OVERLAY | 
| P | 
| PARAMETER | PARTITION | PARTITION\$1ID | 
| PARTITION\$1KEY | PERCENTILE\$1CONT | PERCENTILE\$1DISC | 
| PERCENT\$1RANK | POSITION | POWER | 
| PRECISION | PREPARE | PRIMARY | 
| PROCEDURE | 
| R | 
| RANGE | RANK | READS | 
| REAL | RECURSIVE | REF | 
| 参考 | REFERENCING | REGR\$1AVGX | 
| REGR\$1AVGY | REGR\$1COUNT | REGR\$1INTERCEPT | 
| REGR\$1R2 | REGR\$1SLOPE | REGR\$1SXX | 
| REGR\$1SXY | RELEASE | RESPECT | 
| RESULT | RETURN | RETURNS | 
| REVOKE | RIGHT | ROLLBACK | 
| ROLLUP | ROW | ROWS | 
| ROWTIME | ROW\$1NUMBER | 
| S | 
| SAVEPOINT | SCOPE | SCROLL | 
| SEARCH | SECOND | SELECT | 
| SENSITIVE | SEQUENCE\$1NUMBER | SESSION\$1USER | 
| SET | SHARD\$1ID | SIMILAR | 
| SMALLINT | SOME | SORT | 
| SPECIFIC | SQL | SQLEXCEPTION | 
| SQLSTATE | SQLWARNING | SQRT | 
| START | STATIC | STDDEV | 
| STDDEV\$1POP | STDDEV\$1SAMP | STOP | 
| STREAM | SUBMULTISET | SUBSTRING | 
| SUM | SYMMETRIC | SYSTEM | 
| SYSTEM\$1USER | 
| T | 
| TABLE | TABLESAMPLE | THEN | 
| TIME | TIMESTAMP | TIMEZONE\$1HOUR | 
| TIMEZONE\$1MINUTE | TINYINT | TO | 
| TRAILING | TRANSLATE | TRANSLATION | 
| TREAT | TRIGGER | TRIM | 
| TRUE | TRUNCATE | 
| U | 
| UESCAPE | 联合 | UNIQUE | 
| UNKNOWN | UNNEST | UPDATE | 
| UPPER | USER | USING | 
| V | 
| 值 | VALUES | VARBINARY | 
| VARCHAR | VARYING | VAR\$1POP | 
| VAR\$1SAMP | 
| W | 
| WHEN | WHENEVER | WHERE | 
| WIDTH\$1BUCKET | WINDOW | WITH | 
| WITHIN | WITHOUT |  | 
| Y | 
| YEAR |