2019-02-23 23:22:20

docs/1.7-SNAPSHOT/61.md

@@ -185,10 +185,13 @@ Flink SQL对类似于Java标识符（表，属性，函数名）使用词法策
 
 ### Scan，Projection和过滤
 
-| Operation | 描述 |
-| --- | --- |
-| **Scan/Select/As**
-批量 流 | 
+
+
+---
+
+操作：**Scan/Select/As** 批量 流
+
+描述：
 
 
 ```
@@ -198,9 +201,12 @@ SELECT a, c AS d FROM Orders
 ```
 
 
- |
-| **Where / Filter**
-Batch Streaming | 
+
+---
+
+操作：**Where / Filter** Batch Streaming
+
+描述：
 
 
 ```
@@ -210,9 +216,12 @@ SELECT * FROM Orders WHERE a % 2 = 0
 ```
 
 
- |
-| **User-defined Scalar Functions (Scalar UDF)**
-批量 流 | UDF必须在TableEnvironment中注册。有关如何指定和注册标量UDF的详细信息，请参阅[UDF文档](udfs.html)。
+
+---
+
+操作：**User-defined Scalar Functions (Scalar UDF)** 批量 流
+
+描述：UDF必须在TableEnvironment中注册。有关如何指定和注册标量UDF的详细信息，请参阅[UDF文档](udfs.html)。
 
 
 ```
@@ -220,12 +229,12 @@ SELECT PRETTY_PRINT(user) FROM Orders
 ```
 
 
- |
+
 
 ### 聚合
 
-| Operation | 描述 |
-| --- | --- |
+
+
 | **GroupBy聚合**
 批处理 流
 结果更新 | **注意：**流表上的GroupBy会生成更新结果。有关详细信息，请参阅[Streaming Concepts](streaming.html)页面。
@@ -238,9 +247,12 @@ GROUP BY a
 ```
 
 
- |
-| **GroupBy窗口聚合**
-批量 流 | 使用组窗口计算每个组的单个结果行。有关详细信息，请参阅[GroupWindows](#group-windows)部分。
+
+---
+
+操作：**GroupBy窗口聚合** 批量 流
+
+描述：使用组窗口计算每个组的单个结果行。有关详细信息，请参阅[GroupWindows](#group-windows)部分。
 
 
 ```
@@ -250,9 +262,12 @@ GROUP BY TUMBLE(rowtime, INTERVAL '1' DAY), user
 ```
 
 
- |
-| **Over Window聚合**
-流 | **注意：**必须在同一窗口中定义所有聚合，即相同的分区，排序和范围。目前，仅支持具有PRREDING（UNBOUNDED和有界）到CURRENT ROW范围的窗口。尚不支持使用FOLLOWING的范围。必须在单个[时间属性](streaming.html#time-attributes)上指定ORDER BY[](streaming.html#time-attributes)
+
+---
+
+操作：**Over Window聚合** 流
+
+描述：**注意：**必须在同一窗口中定义所有聚合，即相同的分区，排序和范围。目前，仅支持具有PRREDING（UNBOUNDED和有界）到CURRENT ROW范围的窗口。尚不支持使用FOLLOWING的范围。必须在单个[时间属性](streaming.html#time-attributes)上指定ORDER BY[](streaming.html#time-attributes)
 
 
 ```
@@ -271,7 +286,7 @@ WINDOW w AS (
 ```
 
 
- |
+
 | **Distinct**
 批量 流
 结果更新 | 
@@ -283,8 +298,11 @@ SELECT DISTINCT users FROM Orders
 
 
 **注意：**对于流式查询，计算查询结果所需的状态可能会无限增长，具体取决于不同字段的数量。请提供具有有效保存间隔的查询配置，以防止过大的状态。有关详细信息，请参阅[Streaming Concepts](streaming.html)。 |
-| **分组集，汇总，多维数据集**
-批量 | 
+---
+
+操作：**分组集，汇总，多维数据集** 批量
+
+描述：
 
 
 ```
@@ -294,9 +312,12 @@ GROUP BY GROUPING SETS ((user), (product))
 ```
 
 
- |
-| **Having**
-批量 流 | 
+
+---
+
+操作：**Having** 批量 流
+
+描述：
 
 
 ```
@@ -307,9 +328,12 @@ HAVING SUM(amount) > 50
 ```
 
 
- |
-| **用户定义的聚合函数（UDAGG）**
-批量 流 | UDAGG必须在TableEnvironment中注册。有关如何指定和注册UDAGG的详细信息，请参阅[UDF文档](udfs.html)。
+
+---
+
+操作：**用户定义的聚合函数（UDAGG）** 批量 流
+
+描述：UDAGG必须在TableEnvironment中注册。有关如何指定和注册UDAGG的详细信息，请参阅[UDF文档](udfs.html)。
 
 
 ```
@@ -319,14 +343,17 @@ GROUP BY users
 ```
 
 
- |
+
 
 ### Join
 
-| Operation | 描述 |
-| --- | --- |
-| **内部Equi-join**
-批量 流 | 目前，仅支持等连接，即具有至少一个带有等式谓词的连接条件的连接。不支持任意交叉或theta连接。**注意：**连接顺序未优化。表按照FROM子句中指定的顺序连接。确保以不产生交叉连接（笛卡尔积）的顺序指定表，这些表不受支持并且会导致查询失败。
+
+
+---
+
+操作：**内部Equi-join** 批量 流
+
+描述：目前，仅支持等连接，即具有至少一个带有等式谓词的连接条件的连接。不支持任意交叉或theta连接。**注意：**连接顺序未优化。表按照FROM子句中指定的顺序连接。确保以不产生交叉连接（笛卡尔积）的顺序指定表，这些表不受支持并且会导致查询失败。
 
 
 ```
@@ -336,8 +363,11 @@ FROM Orders INNER JOIN Product ON Orders.productId = Product.id
 
 
 **注意：**对于流式查询，计算查询结果所需的状态可能会无限增长，具体取决于不同输入行的数量。请提供具有有效保存间隔的查询配置，以防止过大的状态。有关详细信息，请参阅[Streaming Concepts](streaming.html)。 |
-| **外部Equi-join**
-批量 流 结果更新 | 目前，仅支持等连接，即具有至少一个带有等式谓词的连接条件的连接。不支持任意交叉或theta连接。**注意：**连接顺序未优化。表按照FROM子句中指定的顺序连接。确保以不产生交叉连接（笛卡尔积）的顺序指定表，这些表不受支持并且会导致查询失败。
+---
+
+操作：**外部Equi-join** 批量 流 结果更新
+
+描述：目前，仅支持等连接，即具有至少一个带有等式谓词的连接条件的连接。不支持任意交叉或theta连接。**注意：**连接顺序未优化。表按照FROM子句中指定的顺序连接。确保以不产生交叉连接（笛卡尔积）的顺序指定表，这些表不受支持并且会导致查询失败。
 
 
 ```
@@ -353,8 +383,11 @@ FROM Orders FULL OUTER JOIN Product ON Orders.productId = Product.id
 
 
 **注意：**对于流式查询，计算查询结果所需的状态可能会无限增长，具体取决于不同输入行的数量。请提供具有有效保存间隔的查询配置，以防止过大的状态。有关详细信息，请参阅[Streaming Concepts](streaming.html)。 |
-| **Time-windowed Join**
-批量 流 | **注意：**时间窗口连接是可以以流方式处理的常规连接的子集。时间窗口连接需要至少一个等连接谓词和一个限制双方时间的连接条件。这样的条件可以由两个适当的范围谓词（`<, <=, >=, >`），`BETWEEN`谓词或单个等式谓词来定义，其比较两个输入表的相同类型的[时间属性](streaming.html#time-attributes)（即，处理时间或事件时间）。例如，以下谓词是有效的窗口连接条件：
+---
+
+操作：**Time-windowed Join** 批量 流
+
+描述：**注意：**时间窗口连接是可以以流方式处理的常规连接的子集。时间窗口连接需要至少一个等连接谓词和一个限制双方时间的连接条件。这样的条件可以由两个适当的范围谓词（`<, <=, >=, >`），`BETWEEN`谓词或单个等式谓词来定义，其比较两个输入表的相同类型的[时间属性](streaming.html#time-attributes)（即，处理时间或事件时间）。例如，以下谓词是有效的窗口连接条件：
 
 *   `ltime = rtime`
 *   `ltime >= rtime AND ltime < rtime + INTERVAL '10' MINUTE`
@@ -370,8 +403,11 @@ WHERE o.id = s.orderId AND
 
 
 如果订单在收到订单后四小时发货，上面的示例将关联所有订单及其相应的货件。 |
-| **将数组扩展为关系**
-Batch Streaming | 尚未支持UnANDing WITH ORDINALITY。
+---
+
+操作：**将数组扩展为关系** Batch Streaming
+
+描述：尚未支持UnANDing WITH ORDINALITY。
 
 
 ```
@@ -380,9 +416,12 @@ FROM Orders CROSS JOIN UNNEST(tags) AS t (tag)
 ```
 
 
- |
-| **关联用户定义的表函数（UDTF）**
-批量 流 | UDTF必须在TableEnvironment中注册。有关如何指定和注册UDTF的详细信息，请参阅[UDF文档](udfs.html)。内部联接
+
+---
+
+操作：**关联用户定义的表函数（UDTF）** 批量 流
+
+描述：UDTF必须在TableEnvironment中注册。有关如何指定和注册UDTF的详细信息，请参阅[UDF文档](udfs.html)。内部联接
 
 
 ```
@@ -404,10 +443,13 @@ FROM Orders LEFT JOIN LATERAL TABLE(unnest_udtf(tags)) t AS tag ON TRUE
 
 ### 设置 算子操作
 
-| Operation | 描述 |
-| --- | --- |
-| **Union**
-批次 | 
+
+
+---
+
+操作：**Union** 批次
+
+描述：
 
 
 ```
@@ -420,9 +462,12 @@ FROM (
 ```
 
 
- |
-| **UnionAll**
-Batch Streaming | 
+
+---
+
+操作：**UnionAll** Batch Streaming
+
+描述：
 
 
 ```
@@ -435,7 +480,7 @@ FROM (
 ```
 
 
- |
+
 | **Intersect/ Except**批量
  | 
 
@@ -461,9 +506,12 @@ FROM (
 ```
 
 
- |
-| **IN**
-批量 流中 | 如果表达式存在于给定的表子查询中，则返回true。子查询表必须包含一列。此列必须与表达式具有相同的数据类型。
+
+---
+
+操作：**IN** 批量 流中
+
+描述：如果表达式存在于给定的表子查询中，则返回true。子查询表必须包含一列。此列必须与表达式具有相同的数据类型。
 
 
 ```
@@ -476,8 +524,11 @@ WHERE product IN (
 
 
 **注意：**对于流式查询， 算子操作将在连接和组 算子操作中重写。计算查询结果所需的状态可能会无限增长，具体取决于不同输入行的数量。请提供具有有效保存间隔的查询配置，以防止过大的状态。有关详细信息，请参阅[Streaming Concepts](streaming.html)。 |
-| **Exists**
-批量 流 | 如果子查询至少返回一行，则返回true。仅在可以在连接和组 算子操作中重写 算子操作时才支持。
+---
+
+操作：**Exists** 批量 流
+
+描述：如果子查询至少返回一行，则返回true。仅在可以在连接和组 算子操作中重写 算子操作时才支持。
 
 
 ```
@@ -493,10 +544,13 @@ WHERE product EXISTS (
 
 ### OrderBy＆Limit
 
-| Operation | 描述 |
-| --- | --- |
-| **Order By**
-批量 流 | **注意：**流式查询的结果必须主要按升序[时间属性](streaming.html#time-attributes)排序。支持其他排序属性。
+
+
+---
+
+操作：**Order By** 批量 流
+
+描述：**注意：**流式查询的结果必须主要按升序[时间属性](streaming.html#time-attributes)排序。支持其他排序属性。
 
 
 ```
@@ -506,9 +560,12 @@ ORDER BY orderTime
 ```
 
 
- |
-| **Limit**
-批次 | 
+
+---
+
+操作：**Limit** 批次
+
+描述：
 
 
 ```
@@ -518,14 +575,17 @@ LIMIT 3
 ```
 
 
- |
+
 
 ### Insert
 
-| Operation | 描述 |
-| --- | --- |
-| **Insert**
-批量 流处理 | 输出表必须在TableEnvironment中[注册](common.html#register-a-tablesink)（请参阅[注册TableSink](common.html#register-a-tablesink)）。此外，已注册表的模式必须与查询的模式匹配。
+
+
+---
+
+操作：**Insert** 批量 流处理
+
+描述：输出表必须在TableEnvironment中[注册](common.html#register-a-tablesink)（请参阅[注册TableSink](common.html#register-a-tablesink)）。此外，已注册表的模式必须与查询的模式匹配。
 
 
 ```
@@ -534,9 +594,6 @@ SELECT users, tag
 FROM Orders
 ```
 
-
- |
-
 ### GroupWindows
 
 组窗口在`GROUP BY`SQL查询的子句中定义。就像具有常规`GROUP BY`子句的查询一样，带有`GROUP BY`包含组窗口函数的子句的查询会为每个组计算单个结果行。批处理和流表上的SQL支持以下组窗口函数。

docs/1.7-SNAPSHOT/73.md

@@ -379,7 +379,7 @@ pattern.where(event => ... /* some condition */).or(event => ... /* or condition
 
 ---
 
-模式算子操作：`where(condition)`
+模式操作：`where(condition)`
 
 描述：定义当前模式的条件。要匹配模式，事件必须满足条件。多个连续的where（）子句导致其条件为AND：
 
@@ -397,7 +397,7 @@ pattern.where(new IterativeCondition<Event>() {
 
 ---
 
-模式算子操作：`or(condition)`
+模式操作：`or(condition)`
 
 描述：添加与现有条件进行OR运算的新条件。只有在至少通过其中一个条件时，事件才能匹配该模式：
 
@@ -420,7 +420,7 @@ pattern.where(new IterativeCondition<Event>() {
 
 ---
 
-模式算子操作：`until(condition)`
+模式操作：`until(condition)`
 
 描述：指定循环模式的停止条件。意味着如果匹配给定条件的事件发生，则不再接受该模式中的事件。仅适用于 `oneOrMore()`**注意：**它允许在基于事件的条件下清除相应模式的状态。
 
@@ -438,7 +438,7 @@ pattern.oneOrMore().until(new IterativeCondition<Event>() {
 
 ---
 
-模式算子操作：`subtype(subClass)`
+模式操作：`subtype(subClass)`
 
 描述：定义当前模式的子类型条件。如果事件属于此子类型，则事件只能匹配该模式：
 
@@ -451,7 +451,7 @@ pattern.subtype(SubEvent.class);
 
 ---
 
-模式算子操作：`oneOrMore()`
+模式操作：`oneOrMore()`
 
 描述：指定此模式至少发生一次匹配事件。默认情况下，使用宽松的内部连续性（在后续事件之间）。有关内部连续性的更多信息，请参阅[连续](#consecutive_java)。**注意：**建议使用`until()`或`within()`启用状态清除
 
@@ -464,7 +464,7 @@ pattern.oneOrMore();
 
 ---
 
-模式算子操作：`timesOrMore（#times）`
+模式操作：`timesOrMore（#times）`
 
 描述：指定此模式至少需要**#times**出现匹配事件。默认情况下，使用宽松的内部连续性（在后续事件之间）。有关内部连续性的更多信息，请参阅[连续](#consecutive_java)。
 
@@ -477,7 +477,7 @@ pattern.timesOrMore(2);
 
 ---
 
-模式算子操作：`次（#ofTimes）`
+模式操作：`次（#ofTimes）`
 
 描述：指定此模式需要匹配事件的确切出现次数。默认情况下，使用宽松的内部连续性（在后续事件之间）。有关内部连续性的更多信息，请参阅[连续](#consecutive_java)。
 
@@ -490,7 +490,7 @@ pattern.times(2);
 
 ---
 
-模式算子操作：`times（#fromTimes，#toTimes）`
+模式操作：`times（#fromTimes，#toTimes）`
 
 描述：指定此模式期望在匹配事件的**#fromTimes** 和**#toTimes**之间出现。默认情况下，使用宽松的内部连续性（在后续事件之间）。有关内部连续性的更多信息，请参阅[连续](#consecutive_java)。
 
@@ -503,7 +503,7 @@ pattern.times(2, 4);
 
 ---
 
-模式算子操作：`Optional()`
+模式操作：`Optional()`
 
 描述：指定此模式是可选的，即根本不会发生。这适用于所有上述量词。
 
@@ -516,7 +516,7 @@ pattern.oneOrMore().optional();
 
 ---
 
-模式算子操作：`greedy()`
+模式操作：`greedy()`
 
 描述：指定此模式是贪婪的，即它将尽可能多地重复。这仅适用于量词，目前不支持组模式。
 
@@ -798,9 +798,12 @@ val start: Pattern[Event, _] = Pattern.begin(
 *   [**Java**](#tab_java_13)
 *   [**Scala**](#tab_scala_13)
 
-| 模式 算子操作 | 描述 |
-| --- | --- |
-| **开始（＃NAME）** | 定义一个起始模式：
+
+---
+
+模式操作：`开始（#NAME）`
+
+描述：定义一个起始模式：
 
 
 ```
@@ -808,8 +811,12 @@ Pattern<Event, ?> start = Pattern.<Event>begin("start");
 ```
 
 
- |
-| **开始（#pattern_sequence）** | 定义一个起始模式：
+
+---
+
+模式操作：`开始（#pattern_sequence）`
+
+描述：定义一个起始模式：
 
 
 ```
@@ -819,8 +826,12 @@ Pattern<Event, ?> start = Pattern.<Event>begin(
 ```
 
 
- |
-| **下一个（＃NAME）** | 添加新模式。匹配事件必须直接接替先前的匹配事件（严格连续性）：
+
+---
+
+模式操作：`下一个（#NAME）`
+
+描述：添加新模式。匹配事件必须直接接替先前的匹配事件（严格连续性）：
 
 
 ```
@@ -828,8 +839,12 @@ Pattern<Event, ?> next = start.next("middle");
 ```
 
 
- |
-| **下一个（#pattern_sequence）** | 添加新模式。一系列匹配事件必须直接接替先前的匹配事件（严格连续性）：
+
+---
+
+模式操作：`下一个（#pattern_sequence）`
+
+描述：添加新模式。一系列匹配事件必须直接接替先前的匹配事件（严格连续性）：
 
 
 ```
@@ -839,8 +854,12 @@ Pattern<Event, ?> next = start.next(
 ```
 
 
- |
-| **followedBy（＃NAME）** | 添加新模式。匹配事件和先前匹配事件（轻松连续）之间可能发生其他事件：
+
+---
+
+模式操作：`followedBy（#NAME）`
+
+描述：添加新模式。匹配事件和先前匹配事件（轻松连续）之间可能发生其他事件：
 
 
 ```
@@ -848,8 +867,12 @@ Pattern<Event, ?> followedBy = start.followedBy("middle");
 ```
 
 
- |
-| **followedBy（#pattern_sequence）** | 添加新模式。在一系列匹配事件和先前匹配事件（轻松连续）之间可能发生其他事件：
+
+---
+
+模式操作：`followedBy（#pattern_sequence）`
+
+描述：添加新模式。在一系列匹配事件和先前匹配事件（轻松连续）之间可能发生其他事件：
 
 
 ```
@@ -859,8 +882,12 @@ Pattern<Event, ?> followedBy = start.followedBy(
 ```
 
 
- |
-| **followedByAny（＃NAME）** | 添加新模式。匹配事件和先前匹配事件之间可能发生其他事件，并且将针对每个备选匹配事件（非确定性放松连续性）呈现替代匹配：
+
+---
+
+模式操作：`followedByAny（#NAME）`
+
+描述：添加新模式。匹配事件和先前匹配事件之间可能发生其他事件，并且将针对每个备选匹配事件（非确定性放松连续性）呈现替代匹配：
 
 
 ```
@@ -868,8 +895,12 @@ Pattern<Event, ?> followedByAny = start.followedByAny("middle");
 ```
 
 
- |
-| **followedByAny（#pattern_sequence）** | 添加新模式。在一系列匹配事件和先前匹配事件之间可能发生其他事件，并且将针对匹配事件的每个替代序列（非确定性松弛邻接）呈现替代匹配：
+
+---
+
+模式操作：`followedByAny（#pattern_sequence）`
+
+描述：添加新模式。在一系列匹配事件和先前匹配事件之间可能发生其他事件，并且将针对匹配事件的每个替代序列（非确定性松弛邻接）呈现替代匹配：
 
 
 ```
@@ -879,8 +910,12 @@ Pattern<Event, ?> followedByAny = start.followedByAny(
 ```
 
 
- |
-| **notNext（）** | 添加新的负面模式。匹配（否定）事件必须直接成功执行先前的匹配事件（严格连续性）才能丢弃部分匹配：
+
+---
+
+模式操作：`notNext（）`
+
+描述：添加新的负面模式。匹配（否定）事件必须直接成功执行先前的匹配事件（严格连续性）才能丢弃部分匹配：
 
 
 ```
@@ -888,8 +923,12 @@ Pattern<Event, ?> notNext = start.notNext("not");
 ```
 
 
- |
-| **notFollowedBy（）** | 添加新的负面模式。即使在匹配（否定）事件和先前匹配事件（松弛连续性）之间发生其他事件，也将丢弃部分匹配事件序列：
+
+---
+
+模式操作：`notFollowedBy（）`
+
+描述：添加新的负面模式。即使在匹配（否定）事件和先前匹配事件（松弛连续性）之间发生其他事件，也将丢弃部分匹配事件序列：
 
 
 ```
@@ -897,8 +936,12 @@ Pattern<Event, ?> notFollowedBy = start.notFollowedBy("not");
 ```
 
 
- |
-| **内（时间）** | 定义事件序列与模式匹配的最大时间间隔。如果未完成的事件序列超过此时间，则将其丢弃：
+
+---
+
+模式操作：`内（时间）`
+
+描述：定义事件序列与模式匹配的最大时间间隔。如果未完成的事件序列超过此时间，则将其丢弃：
 
 
 ```
@@ -906,11 +949,20 @@ pattern.within(Time.seconds(10));
 ```
 
 
- |
 
-| Pattern Operation | Description |
-| --- | --- |
-| **begin(#name)** | Defines a starting pattern:
+
+---
+
+模式操作：Pattern Operation
+
+描述：Description |
+
+
+---
+
+模式操作：`begin(#name)`
+
+描述：Defines a starting pattern:
 
 
 ```
@@ -918,8 +970,12 @@ val start = Pattern.begin[Event]("start")
 ```
 
 
- |
-| **begin(#pattern_sequence)** | Defines a starting pattern:
+
+---
+
+模式操作：`begin(#pattern_sequence)`
+
+描述：Defines a starting pattern:
 
 
 ```
@@ -929,8 +985,12 @@ val start = Pattern.begin(
 ```
 
 
- |
-| **next(#name)** | Appends a new pattern. A matching event has to directly succeed the previous matching event (strict contiguity):
+
+---
+
+模式操作：`next(#name)`
+
+描述：Appends a new pattern. A matching event has to directly succeed the previous matching event (strict contiguity):
 
 
 ```
@@ -938,8 +998,12 @@ val next = start.next("middle")
 ```
 
 
- |
-| **next(#pattern_sequence)** | Appends a new pattern. A sequence of matching events have to directly succeed the previous matching event (strict contiguity):
+
+---
+
+模式操作：`next(#pattern_sequence)`
+
+描述：Appends a new pattern. A sequence of matching events have to directly succeed the previous matching event (strict contiguity):
 
 
 ```
@@ -949,8 +1013,12 @@ val next = start.next(
 ```
 
 
- |
-| **followedBy(#name)** | Appends a new pattern. Other events can occur between a matching event and the previous matching event (relaxed contiguity) :
+
+---
+
+模式操作：`followedBy(#name)`
+
+描述：Appends a new pattern. Other events can occur between a matching event and the previous matching event (relaxed contiguity) :
 
 
 ```
@@ -958,8 +1026,12 @@ val followedBy = start.followedBy("middle")
 ```
 
 
- |
-| **followedBy(#pattern_sequence)** | Appends a new pattern. Other events can occur between a sequence of matching events and the previous matching event (relaxed contiguity) :
+
+---
+
+模式操作：`followedBy(#pattern_sequence)`
+
+描述：Appends a new pattern. Other events can occur between a sequence of matching events and the previous matching event (relaxed contiguity) :
 
 
 ```
@@ -969,8 +1041,12 @@ val followedBy = start.followedBy(
 ```
 
 
- |
-| **followedByAny(#name)** | Appends a new pattern. Other events can occur between a matching event and the previous matching event, and alternative matches will be presented for every alternative matching event (non-deterministic relaxed contiguity):
+
+---
+
+模式操作：`followedByAny(#name)`
+
+描述：Appends a new pattern. Other events can occur between a matching event and the previous matching event, and alternative matches will be presented for every alternative matching event (non-deterministic relaxed contiguity):
 
 
 ```
@@ -978,8 +1054,12 @@ val followedByAny = start.followedByAny("middle")
 ```
 
 
- |
-| **followedByAny(#pattern_sequence)** | Appends a new pattern. Other events can occur between a sequence of matching events and the previous matching event, and alternative matches will be presented for every alternative sequence of matching events (non-deterministic relaxed contiguity):
+
+---
+
+模式操作：`followedByAny(#pattern_sequence)`
+
+描述：Appends a new pattern. Other events can occur between a sequence of matching events and the previous matching event, and alternative matches will be presented for every alternative sequence of matching events (non-deterministic relaxed contiguity):
 
 
 ```
@@ -989,8 +1069,12 @@ val followedByAny = start.followedByAny(
 ```
 
 
- |
-| **notNext()** | Appends a new negative pattern. A matching (negative) event has to directly succeed the previous matching event (strict contiguity) for the partial match to be discarded:
+
+---
+
+模式操作：`notNext()`
+
+描述：Appends a new negative pattern. A matching (negative) event has to directly succeed the previous matching event (strict contiguity) for the partial match to be discarded:
 
 
 ```
@@ -998,8 +1082,12 @@ val notNext = start.notNext("not")
 ```
 
 
- |
-| **notFollowedBy()** | Appends a new negative pattern. A partial matching event sequence will be discarded even if other events occur between the matching (negative) event and the previous matching event (relaxed contiguity):
+
+---
+
+模式操作：`notFollowedBy()`
+
+描述：Appends a new negative pattern. A partial matching event sequence will be discarded even if other events occur between the matching (negative) event and the previous matching event (relaxed contiguity):
 
 
 ```
@@ -1007,17 +1095,18 @@ val notFollowedBy = start.notFollowedBy("not")
 ```
 
 
- |
-| **within(time)** | Defines the maximum time interval for an event sequence to match the pattern. If a non-completed event sequence exceeds this time, it is discarded:
+
+---
+
+模式操作：`within(time)`
+
+描述：Defines the maximum time interval for an event sequence to match the pattern. If a non-completed event sequence exceeds this time, it is discarded:
 
 
 ```
 pattern.within(Time.seconds(10))
 ```
 
-
- |
-
 ### 比赛后跳过策略
 
 对于给定模式，可以将同一事件分配给多个成功匹配。要控制将分配事件的匹配数，您需要指定调用的跳过策略`AfterMatchSkipStrategy`。跳过策略有四种类型，如下所示：