dolphindb 2.0.603 → 2.0.800

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (12) hide show
  1. package/browser.d.ts +98 -17
  2. package/browser.js +333 -154
  3. package/browser.js.map +1 -1
  4. package/docs.en.json +2096 -646
  5. package/docs.zh.json +1290 -729
  6. package/index.d.ts +103 -18
  7. package/index.js +350 -166
  8. package/index.js.map +1 -1
  9. package/language.d.ts +2 -2
  10. package/language.js +5 -3
  11. package/language.js.map +1 -1
  12. package/package.json +7 -7
package/docs.zh.json CHANGED
@@ -117,7 +117,14 @@
117
117
  " $ }",
118
118
  "",
119
119
  " $ acf = acf(x, 20)",
120
- " $ plot(acf,chartType=BAR)"
120
+ " $ plot(acf,chartType=BAR)",
121
+ ""
122
+ ]
123
+ },
124
+ {
125
+ "type": "text",
126
+ "value": [
127
+ "相关函数： :doc:`../a/autocorr`"
121
128
  ]
122
129
  }
123
130
  ]
@@ -2352,9 +2359,7 @@
2352
2359
  " $ appendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.009))",
2353
2360
  " $ appendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.010))",
2354
2361
  "",
2355
- " $ sleep(5000)",
2356
- " $ leftTable.append!(tmp1)",
2357
- " $ rightTable.append!(tmp2)"
2362
+ " $ sleep(5000)"
2358
2363
  ]
2359
2364
  }
2360
2365
  ]
@@ -3506,7 +3511,7 @@
3506
3511
  {
3507
3512
  "type": "text",
3508
3513
  "value": [
3509
- "`location` 是一个向量。",
3514
+ "`X` 是一个向量。",
3510
3515
  "",
3511
3516
  "`lag` 是一个正整数。"
3512
3517
  ]
@@ -3520,7 +3525,7 @@
3520
3525
  {
3521
3526
  "type": "text",
3522
3527
  "value": [
3523
- "计算 X 的 lag 阶自相关系数。请注意，计算时两个时间序列所用的均值均为X的均值，而非两个时间序列各自的均值。"
3528
+ "计算 X 的 lag 阶自相关系数。请注意，计算时两个时间序列所用的均值均为 X 的均值，而非两个时间序列各自的均值。"
3524
3529
  ]
3525
3530
  }
3526
3531
  ]
@@ -3547,8 +3552,13 @@
3547
3552
  "",
3548
3553
  " $ autocorr(x, 2)",
3549
3554
  " 0.661018",
3550
- "",
3551
- "",
3555
+ ""
3556
+ ]
3557
+ },
3558
+ {
3559
+ "type": "text",
3560
+ "value": [
3561
+ "相关函数： :doc:`../a/acf`",
3552
3562
  "",
3553
3563
  "",
3554
3564
  ""
@@ -4168,8 +4178,8 @@
4168
4178
  "| aac | 2.3 |",
4169
4179
  "+-----+-------+",
4170
4180
  "",
4171
- "下例说明数据对 a:b 中出现空值的处理方式。若配置 *nullAsMinValueForComparison*=true，则 NULL 值当同数据类型的而最小值处理，",
4172
- "若配置 *nullAsMinValueForComparison*=false，则 NULL 值仍保留为 NULL。也可以使用 :doc:`/Functionalprogramming/TemplateFunctions/nullCompare` 函数，无论 *nullAsMinValueForComparison* 设置为何值都保留 NULL 值。",
4181
+ "下例说明数据对 a:b 中出现空值的处理方式。若配置 *nullAsMinValueForComparison* =true，则 NULL 值当同数据类型的而最小值处理，",
4182
+ "若配置 *nullAsMinValueForComparison* =false，则 NULL 值仍保留为 NULL。也可以使用 :doc:`/Functionalprogramming/TemplateFunctions/nullCompare` 函数，无论 *nullAsMinValueForComparison* 设置为何值都保留 NULL 值。",
4173
4183
  ""
4174
4184
  ]
4175
4185
  },
@@ -6822,7 +6832,7 @@
6822
6832
  {
6823
6833
  "type": "text",
6824
6834
  "value": [
6825
- "形状参数 `alpha` 和 `beeta` 都是正数。",
6835
+ "形状参数 `alpha` 和 `beta` 都是正数。",
6826
6836
  "",
6827
6837
  "`X` 是数值型标量或向量。"
6828
6838
  ]
@@ -11523,7 +11533,62 @@
11523
11533
  {
11524
11534
  "type": "text",
11525
11535
  "value": [
11526
- "createAnomalyDetectionEngine(name, metrics, dummyTable, outputTable, timeColumn, [keyColumn], [windowSize], [step], [garbageSize], [roundTime=true], [snapshotDir], [snapshotIntervalInMsgCount], [raftGroup])"
11536
+ "createAnomalyDetectionEngine(name, metrics, dummyTable, outputTable, timeColumn, [keyColumn], [windowSize], [step], [garbageSize], [roundTime=true], [snapshotDir], [snapshotIntervalInMsgCount], [raftGroup])",
11537
+ ""
11538
+ ]
11539
+ }
11540
+ ]
11541
+ },
11542
+ {
11543
+ "title": "详情",
11544
+ "type": "detail",
11545
+ "children": [
11546
+ {
11547
+ "type": "text",
11548
+ "value": [
11549
+ "创建异常检测引擎，返回一个表对象，向该表写入数据意味着将数据注入异常检测引擎进行计算。异常检测引擎会根据异常指标，对每条记录进行检测。",
11550
+ "",
11551
+ "异常检测引擎不支持在 *metrics* 中使用以下函数：next, talibNull, linearTimeTrend, iterate；亦不支持在序列相关函数内部嵌套聚合函数，如：tmsum(sum())。",
11552
+ "",
11553
+ "为了便于观察和对比计算结果，系统会对第一个数据窗口的起始时间进行调整。调整规则与 :doc:`createTimeSeriesEngine` 相同。",
11554
+ "",
11555
+ "更多流数据引擎的应用场景说明可以参考 :doc:`../../SeriesOfFunctions/streamingEngine`。",
11556
+ ""
11557
+ ]
11558
+ }
11559
+ ]
11560
+ },
11561
+ {
11562
+ "title": "计算规则",
11563
+ "children": [
11564
+ {
11565
+ "type": "text",
11566
+ "value": [
11567
+ "异常检测引擎会根据不同类型的异常指标采用不同的计算规则。异常指标一般有以下三种类型：",
11568
+ "",
11569
+ "* 某个列与常量对比、列与列之间对比或非聚合函数中没有嵌套聚合函数，例如 qty < 4, qty > price, lt(qty, prev(qty)), isNull(qty) == false 等。对于这类指标，异常检测引擎会对每一条数据进行计算，判断是否符合条件并决定输出。",
11570
+ "",
11571
+ "* 聚合函数的结果与某个常量值对比、聚合函数结果之间的对比、非聚合函数中仅嵌套聚合函数和常量，例如 avg(qty - price) > 10, percentile(qty, 90) < 100, sum(qty) > prev(sum(qty)), le(sum(qty), 5) 等。对于这类指标，异常检测引擎会在每个窗口计算时判断计算结果是否符合条件并决定输出。",
11572
+ "",
11573
+ "* 聚合函数的结果与列对比、非聚合函数中同时嵌套聚合函数和列，例如 avg(qty) > qty, le(med(qty), price) 等。对于这类指标，每当数据到达时，异常检测引擎会将数据与上一个计算窗口的聚合结果对比，判断计算结果是否符合条件并决定输出，直到触发下一次聚合计算。",
11574
+ "",
11575
+ "注意，当指标中包含聚合函数，则必须指定窗口长度（由参数 :ref:`windowSize <windowSize_ad>` 设置）和计算的时间间隔（由参数 :ref:`step <step_ad>` 设置）。每隔一段时间，在固定长度的移动窗口中计算指标。为了便于观察和对比计算结果，系统会对第一个数据窗口的起始时间进行调整，起始窗口的规整规则同时间序列引擎。",
11576
+ "",
11577
+ "注意：若指定了 :ref:`keyColumn <keyColumn_ad>`，则按照分组分别进行计算。"
11578
+ ]
11579
+ }
11580
+ ]
11581
+ },
11582
+ {
11583
+ "title": "引擎的其它功能",
11584
+ "children": [
11585
+ {
11586
+ "type": "text",
11587
+ "value": [
11588
+ "* 支持数据/状态清理：若 :ref:`metrics <metrics_ad>` 参数指定的指标中使用了聚合函数或序列相关函数，异常检测引擎会保留历史数据，可通过配置 :ref:`garbageSize <garbageSize_ad>` 参数，使系统清理本次计算不需要的历史数据。若指定了 :ref:`keyColumn <keyColumn_ad>` ，则各分组独立进行数据清理。",
11589
+ "* 快照机制：启用快照机制之后，系统若出现异常，可及时将流数据引擎恢复到最新的快照状态。（详情请参考 :ref:`snapshotDir <snapshotDir_ad>` 和 :ref:`snapshotIntervalInMsgCount <snapshotIntervalInMsgCount_ad>` 的参数说明）",
11590
+ "* 流数据引擎高可用：若要启用引擎高可用，需在订阅端 raft 组的 leader 节点创建引擎并通过 *raftGroup* 参数开启高可用。开启高可用后，当 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。（详情请参考 :ref:`raftGroup <raftGroup_rs>` 的参数说明）",
11591
+ ""
11527
11592
  ]
11528
11593
  }
11529
11594
  ]
@@ -11535,18 +11600,21 @@
11535
11600
  {
11536
11601
  "type": "text",
11537
11602
  "value": [
11538
- "`name` 是一个字符串，表示异常检测引擎的名称，是异常检测的唯一标识。它可以包含字母，数字和下划线，但必须以字母开头。",
11603
+ ".. _name_ad:",
11604
+ "",
11605
+ "`name` 字符串标量，表示异常检测引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
11539
11606
  "",
11540
- "`metrics` 是元代码或元组，表示异常指标，每个异常指标的返回值必须是 BOOL 类型，如<[sum(qty) > 5, avg(qty) > qty, qty < 4]>。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
11607
+ ".. _metrics_ad:",
11541
11608
  "",
11542
- "异常检测引擎不支持在 *metrics* 中使用以下函数：",
11609
+ "`metrics` 以元代码或元组的格式表示异常指标，每个异常指标必须是布尔表达式，如<[sum(qty) > 5, avg(qty) > qty, qty < 4]>。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
11543
11610
  "",
11544
- "* 序列相关函数：next, talibNull, linearTimeTrend, iterate",
11545
- "* 内部嵌套聚合函数，如：tmsum(sum())",
11611
+ ".. _dummyTable_ad:",
11546
11612
  "",
11547
- "`dummyTable` 是一个表对象，该表的唯一作用是为引擎提供订阅的流数据表的 schema，可以含有数据，亦可为空表。",
11613
+ "`dummyTable` 一个表对象，该表的唯一作用是为引擎提供订阅的流数据表的 schema，可以含有数据，亦可为空表。",
11548
11614
  "",
11549
- "`outputTable` 是表对象，用于保存计算结果，可以是内存表或者分布式表。",
11615
+ ".. _outputTable_ad:",
11616
+ "",
11617
+ "`outputTable` 计算结果的输出表，可以是内存表或分布式表。在调用 ``createAnomalyDetectionEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。异常检测引擎会将计算结果注入该表。",
11550
11618
  "",
11551
11619
  "输出表的各列的顺序为：时间列，分组列，异常类型列 type，异常条件列 metric。",
11552
11620
  "",
@@ -11558,21 +11626,33 @@
11558
11626
  "",
11559
11627
  "\\(3) 之后两列分别为 INT 类型和 STRING / SYMBOL 类型，用于记录异常的类型（在 *metrics* 中的下标）和异常条件的内容。",
11560
11628
  "",
11561
- "`timeColumn` 是字符串标量，表示输入流数据表的时间列名称。",
11629
+ ".. _timeColumn_ad:",
11562
11630
  "",
11563
- "`keyColumn` 是字符串标量，表示分组列。异常检测引擎会按照 *keyColumn* 对输入的数据分组，并在每组中进行运算。它是可选参数。",
11631
+ "`timeColumn` 字符串标量，该参数用于指定订阅的流数据表中时间列的名称。",
11564
11632
  "",
11565
- "`windowSize` 是正整数。如果 *metrics* 中包含聚合函数，必须指定 *windowSize*，它表示计算的数据窗口的长度，数据窗口只包含上边界不包含下边界。如果 *metrics* 中不包含聚合函数，该参数无效。",
11633
+ ".. _keyColumn_ad:",
11566
11634
  "",
11567
- "`step` 是正整数。如果 *metrics* 中包含聚合函数，必须指定 *step*，并且必须能够被 *windowSize* 整除，它表示计算的时间间隔。如果 *metrics* 中不包含聚合函数，该参数无效。",
11635
+ "`keyColumn` 可选参数，字符串标量，表示分组列名。异常检测引擎会按照 *keyColumn* 对输入的数据分组，并计算将在各分组分别进行。",
11568
11636
  "",
11569
- "为了便于观察和对比计算结果，系统会对第一个数据窗口的起始时间进行调整。调整规则与 :doc:`createTimeSeriesEngine` 相同。",
11637
+ ".. _windowSize_ad:",
11638
+ "",
11639
+ "`windowSize` 可选参数，正整数。如果 *metrics* 中包含聚合函数，必须指定 *windowSize*，它表示计算的数据窗口的长度，数据窗口只包含上边界不包含下边界。如果 *metrics* 中不包含聚合函数，该参数无效。",
11640
+ "",
11641
+ ".. _step_ad:",
11642
+ "",
11643
+ "`step` 可选参数，正整数。如果 *metrics* 中包含聚合函数，必须指定 *step*，并且必须能够被 *windowSize* 整除，它表示计算的时间间隔。如果 *metrics* 中不包含聚合函数，该参数无效。",
11644
+ "",
11645
+ ".. _garbageSize_ad:",
11570
11646
  "",
11571
- "`garbageSize` 是正整数。它是可选参数，默认值是2,000（单位为行）。如果没有指定 *keyColumn*，当内存中历史数据的数量超过 *garbageSize* 时，系统会清理本次计算不需要的历史数据。如果指定了 *keyColumn*，意味着需要分组计算时，内存清理是各分组独立进行的。当一个组的历史数据记录数超出 *garbageSize* 时，会清理该组不再需要的历史数据。若一个组的历史数据记录数未超出 *garbageSize*，则该组数据不会被清理。如果 *metrics* 中没有聚合函数，这个参数不起作用。",
11647
+ "`garbageSize` 可选参数，正整数。它是可选参数，默认值是 2,000（单位为行）。如果没有指定 *keyColumn*，当内存中历史数据的数量超过 *garbageSize* 时，系统会清理本次计算不需要的历史数据。如果指定了 *keyColumn*，意味着需要分组计算时，内存清理是各分组独立进行的。当一个组的历史数据记录数超出 *garbageSize* 时，会清理该组不再需要的历史数据。若一个组的历史数据记录数未超出 *garbageSize*，则该组数据不会被清理。如果 *metrics* 中没有聚合函数，这个参数不起作用。",
11648
+ "",
11649
+ ".. _roundTime_ad:",
11650
+ "",
11651
+ "`roundTime` 可选参数，布尔值，表示若数据时间精度为毫秒或者秒且 *step* > 一分钟，如何对窗口边界值进行规整处理。默认值为 true，表示按照既定的多分钟规则（见以上表格）进行规整。若为 false，则按一分钟规则（见以上表格）进行窗口规整（详情参考 :ref:`规整规则表 <alignment_ts>`）。",
11572
11652
  "",
11573
11653
  "若要开启快照机制 (snapshot)，必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。",
11574
11654
  "",
11575
- "启用快照机制之后，系统若出现异常，可及时将流数据引擎恢复到最新的快照状态。",
11655
+ ".. _snapshotDir_ad:",
11576
11656
  "",
11577
11657
  "`snapshotDir` 可选参数，字符串，表示保存引擎快照的文件目录。",
11578
11658
  "",
@@ -11585,29 +11665,13 @@
11585
11665
  " * 快照生成并刷到磁盘：文件保存为 <engineName>.snapshot；",
11586
11666
  " * 存在同名快照：旧快照自动重命名为 <engineName>.old。",
11587
11667
  "",
11588
- "`snapshotIntervalInMsgCount` 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。",
11589
- "",
11590
- "`raftGroup` 是流数据高可用订阅端 raft 组的 ID (大于1的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。"
11591
- ]
11592
- }
11593
- ]
11594
- },
11595
- {
11596
- "title": "详情",
11597
- "type": "detail",
11598
- "children": [
11599
- {
11600
- "type": "text",
11601
- "value": [
11602
- "创建异常检测引擎。返回一个表对象，向该表写入数据意味着这些数据进入异常检测引擎进行计算。",
11603
- "",
11604
- "异常检测引擎会根据不同类型的异常指标采用不同的计算规则。异常指标一般有以下三种类型：",
11668
+ ".. _snapshotIntervalInMsgCount_ad:",
11605
11669
  "",
11606
- "* 某个列与常量对比、列与列之间对比或非聚合函数中不包含聚合函数，例如 qty < 4, qty > price, lt(qty, prev(qty)), isNull(qty) == false 等。对于这类指标，异常检测引擎会对每一条数据进行计算，判断是否符合条件并决定输出。",
11670
+ "`snapshotIntervalInMsgCount` 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。",
11607
11671
  "",
11608
- "* 聚合函数的结果与某个常量值对比、聚合函数结果之间的对比、非聚合函数中仅包含聚合函数和常量，例如 avg(qty - price) > 10, percentile(qty, 90) < 100, sum(qty) > prev(sum(qty)), le(sum(qty), 5) 等。对于这类指标，异常检测引擎会在每个窗口计算时判断计算结果是否符合条件并决定输出。",
11672
+ ".. _raftGroup_ad:",
11609
11673
  "",
11610
- "* 聚合函数的结果与列对比、非聚合函数中同时包含聚合函数和列，例如 avg(qty) > qty, le(med(qty), price) 等。对于这类指标，每当数据到达时，异常检测引擎会将数据与上一个计算窗口的聚合结果对比，判断计算结果是否符合条件并决定输出，直到触发下一次聚合计算。"
11674
+ "`raftGroup` 是流数据高可用订阅端 raft 组的 ID (大于1的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。"
11611
11675
  ]
11612
11676
  }
11613
11677
  ]
@@ -11717,6 +11781,25 @@
11717
11781
  }
11718
11782
  ]
11719
11783
  },
11784
+ {
11785
+ "title": "详情",
11786
+ "type": "detail",
11787
+ "children": [
11788
+ {
11789
+ "type": "text",
11790
+ "value": [
11791
+ "创建流数据 asof join 引擎。返回一个左、右两表 as join 后的表对象。注入 asof join 引擎的左、右两表将以 :ref:`matchingColumn <mc_aj>` + :ref:`timeColumn <tc_aj>` (或系统时间) 作为连接列，在右表中选取与连接列匹配的，在给定的左表时间戳前且最接近的记录。该引擎适用于两个数据源没有完全匹配的记录，需要按时间段作连接，以获取最新信息的场景。",
11792
+ "",
11793
+ "注意：asof join 假定左右表是有序的。",
11794
+ "",
11795
+ "* 如果没有指定 :ref:`delayedTime <delayedTime_aj>`，则当右表数据的最新时间大于左表数据的最新时间，才会触发 join, 计算输出。",
11796
+ "* 如果指定了 :ref:`delayedTime <delayedTime_aj>`，则当左表中数据最新时间与上一条未计算的时间差大于 *delayedTime* 设置值，或者左表中数据在经过 2 \\* *delayedTime* （小于2秒按2秒计算）后还没有 join 输出，就直接触发左右两表 join。",
11797
+ "",
11798
+ "更多流数据引擎的应用场景说明可以参考 :doc:`../../SeriesOfFunctions/streamingEngine`。"
11799
+ ]
11800
+ }
11801
+ ]
11802
+ },
11720
11803
  {
11721
11804
  "title": "参数",
11722
11805
  "type": "parameters",
@@ -11724,11 +11807,17 @@
11724
11807
  {
11725
11808
  "type": "text",
11726
11809
  "value": [
11727
- "`name` 必选参数，是一个字符串，表示流数据 asof join 引擎的名称。",
11810
+ ".. _name_aj:",
11811
+ "",
11812
+ "`name` 字符串标量，表示 asof join 引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
11728
11813
  "",
11729
- "`leftTable` 和 `rightTable` 是表对象。可以不包含数据，但结构必须与订阅的流数据表相同。",
11814
+ ".. _table_aj:",
11730
11815
  "",
11731
- "`outputTable` 必选参数，为计算结果的输出表。在使用 ``createAsofJoinEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。asof join 引擎会将计算结果插入该表。",
11816
+ "`leftTable` 和 `rightTable` 表对象。结构必须与订阅的流数据表相同。",
11817
+ "",
11818
+ ".. _outputTable_aj:",
11819
+ "",
11820
+ "`outputTable` 计算结果的输出表，可以是内存表或分布式表。在使用 ``createAsofJoinEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。asof join 引擎会将计算结果注入该表。",
11732
11821
  "",
11733
11822
  "输出表的各列的顺序为：时间列，连接列，计算结果列。",
11734
11823
  "",
@@ -11743,14 +11832,18 @@
11743
11832
  "",
11744
11833
  "\\(3) 最后为计算结果列，可为多列。",
11745
11834
  "",
11835
+ ".. _metrics_aj:",
11836
+ "",
11746
11837
  "`metrics` 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
11747
11838
  "",
11748
11839
  "* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数，但不能是聚合函数。",
11749
11840
  "* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 <func(price) as \\`col1\\`col2>。",
11750
11841
  "",
11751
- "请注意，若 *metrics* 中指定了左右表列名相同的时间列或者连接列，默认取左表中的列。如果需要取右表中的列，在列前加上右表名。例如：*matchingColumn* = \\`sym, *timeColumn* = \\`timestamp，则 *metrics* = <[rightTable.sym, rightTable.timestamp, price, val, price*val]> 指定 *metrics* 中输出右表的 sym 列和 timestamp 列。",
11842
+ "若 *metrics* 中指定了 *leftTable* 和 *rightTable* 中具有相同名称的列，可以通过 \"tableName.colName\" 指定该列来自哪个表。",
11752
11843
  "",
11753
- "`matchingColumn` 表示连接列的字符串标量/向量/tuple，支持 Integral, Temproal 或 Literal（UUID 除外）类型。",
11844
+ ".. _mc_aj:",
11845
+ "",
11846
+ "`matchingColumn` 表示连接列的字符串标量/向量/字符串组成的 tuple，支持 Integral, Temproal 或 Literal（UUID 除外）类型。",
11754
11847
  "",
11755
11848
  "*matchingColumn* 指定规则：",
11756
11849
  "",
@@ -11758,36 +11851,28 @@
11758
11851
  "",
11759
11852
  "\\2. 有多个连接列：当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串向量，否则是一个长度为 2 的 tuple，例如：左表连接列名为 orderNo, sym，右表连接列名为 orderNo, sym1，则 *matchingColumn* = [[\\`orderNo, \\`sym], [\\`orderNo,\\`sym1]]。",
11760
11853
  "",
11761
- "`timeColumn` 可选参数，当 *useSystemTime* = false 时，指定要连接的两个表中时间列的名称。 `leftTable` 和 `rightTable` 时间列名称可以不同，但数据类型需保持一致。当 `leftTable` 和 `rightTable` 时间列名称不同时，`timeColumn` 为一个长度为2的字符串向量。",
11854
+ ".. _tc_aj:",
11762
11855
  "",
11763
- "`useSystemTime` 可选参数，表示 *outputTable* 中第一列（时间列）为系统当前时间（*useSystemTime* = true）或左表的时间列（*useSystemTime* = false）。",
11856
+ "`timeColumn` 可选参数，字符串标量或向量。当 *useSystemTime* = false 时，指定要连接的两个表中时间列的名称。 `leftTable` 和 `rightTable` 时间列名称可以不同，但数据类型需保持一致。当 `leftTable` 和 `rightTable` 时间列名称不同时，`timeColumn` 为一个长度为2的字符串向量。",
11857
+ "",
11858
+ ".. _useSystemTime_aj:",
11859
+ "",
11860
+ "`useSystemTime` 可选参数，布尔值。表示是否使用数据注入引擎时的系统时间作为时间列进行计算。",
11764
11861
  "",
11765
11862
  "* 当 *useSystemTime* = true 时，按照数据进入引擎的时刻（毫秒精度的本地系统时间，与数据中的时间列无关）进行计算。",
11766
11863
  "",
11767
11864
  "* 当 *useSystemTime* = false（缺省值）时，按照数据中的时间列进行计算。请注意，触发计算的数据并不会参与该次计算。",
11768
11865
  "",
11769
- "`delayedTime` 可选参数，是正整数。要设置 *delayedTime*， *useSystemTime* 必须设为 false。",
11866
+ ".. _delayedTime_aj:",
11770
11867
  "",
11771
- "如果指定了 *delayedTime*，若左表中最新时间 t2 与上一条未计算的时间差大于 *delayedTime* 设置值，则 t2 这条记录可以直接触发左表和右表 join，或者左表中的数据在经过 2 * *delayedTime* （小于2秒按2秒计算）后还没有 join 输出，则直接触发 join。",
11868
+ "`delayedTime` 可选参数，正整数，单位同 timeColumn 精度一致。要设置 *delayedTime*， 必须指定 *timeColumn*。",
11772
11869
  "",
11773
- "`garbageSize` 可选参数，是正整数，默认值是5,000（单位为行）。随着订阅的流数据不断注入 asof join 引擎，存放在内存中的数据会越来越多，行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。"
11774
- ]
11775
- }
11776
- ]
11777
- },
11778
- {
11779
- "title": "详情",
11780
- "type": "detail",
11781
- "children": [
11782
- {
11783
- "type": "text",
11784
- "value": [
11785
- "创建流数据 asof join 引擎。返回一个左、右两表 :doc:`/SQLStatements/TableJoiners/asofjoin` 后的表对象。通常与 :doc:`../s/subscribeTable` 函数一起使用。",
11870
+ "如果指定了 *delayedTime*，若左表中最新到来的数据时间与左表之前未计算的数据时间差大于 *delayedTime* 设置值，则这条数据可以直接触发左表和右表 join，或左表中的数据在经过 2 \\* *delayedTime* （小于2秒按2秒计算）后还没有 join 输出，则直接触发 join。",
11786
11871
  "",
11787
- "* 如果没有指定 *delayedTime*，则当右表数据的最新时间大于左表数据的最新时间，才会触发 join, 计算输出。",
11788
- "* 如果指定了 *delayedTime*，则当左表中数据最新时间与上一条未计算的时间差大于 *delayedTime* 设置值，或者左表中数据在经过 2 \\* *delayedTime* （小于2秒按2秒计算）后还没有 join 输出，就直接触发左右两表 join。",
11872
+ ".. _garbageSize_aj:",
11789
11873
  "",
11790
- "从 1.30.17, 2.00.5 版本开始，DolphinDB 支持其他流数据引擎通过 :doc:`/FunctionsandCommands/FunctionReferences/g/getLeftStream` 及 :doc:`/FunctionsandCommands/FunctionReferences/g/getRightStream`，为流数据 join 引擎注入数据，以实现引擎间的级联。"
11874
+ "`garbageSize` 可选参数，正整数，默认值是 5,000（单位为行）。随着订阅的流数据不断注入 asof join 引擎，存放在内存中的数据会越来越多，当左/右两表根据 *matchingCol* 分组后的各个分组内的数据行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。",
11875
+ ""
11791
11876
  ]
11792
11877
  }
11793
11878
  ]
@@ -11820,7 +11905,7 @@
11820
11905
  "",
11821
11906
  " $ sleep(1000)",
11822
11907
  "",
11823
- " $ select time, sym, price from prevailingQuotes order by time, sym",
11908
+ " $ select time, sym, bid from prevailingQuotes order by time, sym",
11824
11909
  ""
11825
11910
  ]
11826
11911
  },
@@ -11828,12 +11913,12 @@
11828
11913
  "type": "text",
11829
11914
  "value": [
11830
11915
  "======================= ======== ========",
11831
- "time sym price",
11916
+ "time sym bid",
11832
11917
  "======================= ======== ========",
11833
- "2020.08.27T09:30:00.002 A 20.01",
11834
- "2020.08.27T09:30:00.008 A 20.04",
11835
- "2020.08.27T09:30:00.020 A 20.07",
11836
- "2020.08.27T09:30:00.022 A 20.08",
11918
+ "2020.08.27T09:30:00.002 A ",
11919
+ "2020.08.27T09:30:00.008 A ",
11920
+ "2020.08.27T09:30:00.020 A ",
11921
+ "2020.08.27T09:30:00.022 A 20.06",
11837
11922
  "======================= ======== ========"
11838
11923
  ]
11839
11924
  }
@@ -11857,13 +11942,58 @@
11857
11942
  {
11858
11943
  "type": "text",
11859
11944
  "value": [
11860
- "createCrossSectionalEngine(name, [metrics], dummyTable, [outputTable], keyColumn, [triggeringPattern='perBatch'], [triggeringInterval=1000], [useSystemTime=true], [timeColumn], [lastBatchOnly=false], [contextByColumn], [snapshotDir], [snapshotIntervalInMsgCount], [raftGroup=-1])",
11945
+ "createCrossSectionalEngine(name, [metrics], dummyTable, [outputTable], keyColumn, [triggeringPattern='perBatch'], [triggeringInterval=1000], [useSystemTime=true], [timeColumn], [lastBatchOnly=false], [contextByColumn], [snapshotDir], [snapshotIntervalInMsgCount], [raftGroup])",
11861
11946
  "",
11862
11947
  "别名：createCrossSectionalAggregator"
11863
11948
  ]
11864
11949
  }
11865
11950
  ]
11866
11951
  },
11952
+ {
11953
+ "title": "详情",
11954
+ "type": "detail",
11955
+ "children": [
11956
+ {
11957
+ "type": "text",
11958
+ "value": [
11959
+ "创建横截面引擎，返回一个以 *keyColumn* 作为键值的键值表。",
11960
+ "",
11961
+ "该表记录了每组最新记录的时间戳（可以是数据自身的时间戳或者系统时间，由参数 :ref:`timeColumn <timeColumn_cs>` 和 :ref:`useSystemTime <useSystemTime_cs>` 指定）。每次新数据的到来都会更新该表。若指定了 :ref:`lastBatchOnly <lastBatchOnly_cs>` = true，此时引擎维护的键值表只会保留最新时间戳上不同组的数据。",
11962
+ "",
11963
+ "* 如果没有指定 :ref:`metrics <metrics_cs>` 或 :ref:`outputTable <outputTable_cs>`，横截面引擎不会利用表中的数据进行任何运算和输出，仅更新表中记录。",
11964
+ "",
11965
+ "* 如果指定了 :ref:`metrics <metrics_cs>` 和 :ref:`outputTable <outputTable_cs>`，横截面引擎会首先更新表中记录，然后对表中的最新记录进行运算，并把结果输出到 *outputTable* 中。",
11966
+ "",
11967
+ "更多流数据引擎的应用场景说明可以参考 :doc:`../../SeriesOfFunctions/streamingEngine`。"
11968
+ ]
11969
+ }
11970
+ ]
11971
+ },
11972
+ {
11973
+ "title": "计算规则",
11974
+ "children": [
11975
+ {
11976
+ "type": "text",
11977
+ "value": [
11978
+ "可选按数据量或时间触发计算，详情请参考 :ref:`triggeringPattern <triggeringPattern_cs>` 和 :ref:`triggeringInterval <triggeringInterval_cs>` 的参数说明。",
11979
+ "",
11980
+ "注意：若指定了 :ref:`contextByColumn <contextByColumn_cs>`，则数据将按照指定字段分组后在组内进行计算。"
11981
+ ]
11982
+ }
11983
+ ]
11984
+ },
11985
+ {
11986
+ "title": "引擎的其他功能",
11987
+ "children": [
11988
+ {
11989
+ "type": "text",
11990
+ "value": [
11991
+ "* 快照机制：启用快照机制之后，系统若出现异常，可及时将流数据引擎恢复到最新的快照状态。（详情请参考 :ref:`snapshotDir <snapshotDir_cs>` 和 :ref:`snapshotIntervalInMsgCount <snapshotIntervalInMsgCount_cs>` 的参数说明）",
11992
+ "* 流数据引擎高可用：若要启用引擎高可用，需在订阅端 raft 组的 leader 节点创建引擎并通过 *raftGroup* 参数开启高可用。开启高可用后，当 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。（详情请参考 :ref:`raftGroup <raftGroup_cs>` 的参数说明）"
11993
+ ]
11994
+ }
11995
+ ]
11996
+ },
11867
11997
  {
11868
11998
  "title": "参数",
11869
11999
  "type": "parameters",
@@ -11871,52 +12001,91 @@
11871
12001
  {
11872
12002
  "type": "text",
11873
12003
  "value": [
11874
- "`name` 是一个字符串，表示横截面引擎的名称，是横截面引擎的唯一标识。它可以包含字母，数字和下划线，但必须以字母开头。",
12004
+ ".. _name_cs:",
12005
+ "",
12006
+ "`name` 字符串标量，表示横截面引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
12007
+ "",
12008
+ ".. _metrics_cs:",
12009
+ "",
12010
+ "`metrics` 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
12011
+ "",
12012
+ "* 计算指标可以是系统内置或用户自定义的函数，如 <[sum(qty), avg(price)]>；可以对计算结果使用表达式，如 <[avg(price1)-avg(price2)]>；也可以对多列进行运算，如 <[std(price1-price2)]>。",
12013
+ "* *metrics* 内支持调用具有多个返回值的函数，例如 <func(price) as \\`col1\\`col2>（可不指定列名）。",
12014
+ "",
12015
+ ".. _dummyTable_cs:",
11875
12016
  "",
11876
- "`metrics` 是元代码或元组。它可以是系统内置或用户自定义的函数，如 <[sum(qty), avg(price)]>，可以对计算结果使用表达式，如 <[avg(price1)-avg(price2)]>，也可以对多列进行运算，如 <[std(price1-price2)]>。*metrics* 内支持调用具有多个返回值的函数，例如 <func(price) as \\`col1\\`col2>（可不指定列名）。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
12017
+ "`dummyTable` 一个表对象，该表的唯一作用是为引擎提供订阅的流数据表的 schema，可以含有数据，亦可为空表。",
12018
+ "",
12019
+ ".. _outputTable_cs:",
12020
+ "",
12021
+ "`outputTable` 计算结果的输出表，可以是内存表或分布式表。使用 ``createCrossSectionalEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。",
12022
+ "",
12023
+ "* 如果没有指定 *contextByColumn*， 输出表的列数为 *metrics* 数量 + 1，其中：",
11877
12024
  "",
11878
- "`dummyTable` 是一个表对象，该表的唯一作用是为引擎提供订阅的流数据表的 schema，可以含有数据，亦可为空表。",
12025
+ " * 第一列为 TIMESTAMP 类型，用于存放发生计算的时间戳（如果指定了 *timeColumn* 则是对应记录的时间戳）；",
12026
+ " * 其他列为 *metrics* 计算结果对应的列，其数据类型必须与 *metrics* 返回结果的数据类型一致。",
12027
+ " ",
12028
+ "* 如果指定 *contextByColumn*， 输出表的列数为 *metrics* 数量 + 2，其中：",
12029
+ " ",
12030
+ " * 第一列为 TIMESTAMP 类型，用于存放发生计算的时间戳（如果指定了 *timeColumn* 则是对应记录的时间戳）；",
12031
+ " * 第二列为 *contextByColumn* 指定的 列；",
12032
+ " * 其他列为 *metrics* 计算结果对应的列，其数据类型必须与 *metrics* 返回结果的数据类型一致。",
11879
12033
  "",
11880
- "`outputTable` 是表对象，用于保存计算结果，可以是内存表或者分布式表。",
12034
+ ".. _keyColumn_cs:",
11881
12035
  "",
11882
- "* 如果没有指定 *contextByColumn*， 输出表的列数为 *metrics* 数量 + 1，第一列为 TIMESTAMP 类型，用于存放发生计算的时间戳（如果指定了 *timeColumn* 则是对应记录的时间戳），其他列为 *metrics* 计算结果对应的列，其数据类型必须与 *metrics* 返回结果的数据类型一致。",
11883
- "* 如果指定 *contextByColumn*， 输出表的列数为 *metrics* 数量 + 2，第一列为 TIMESTAMP 类型，用于存放发生计算的时间戳（如果指定了 *timeColumn* 则是对应记录的时间戳），第二列为 *contextByColumn* 指定的 列，其他列为 *metrics* 计算结果对应的列，其数据类型必须与 *metrics* 返回结果的数据类型一致。",
12036
+ "`keyColumn` 字符串标量或向量，指定流数据表中某列的值为横截面引擎的键值。横截面引擎的计算时，仅使用每个键值对应的最新一行记录。",
11884
12037
  "",
11885
- "`keyColumn` 是一个字符串标量或向量，指定流数据表中某列的值为横截面引擎的 key。横截面引擎的每次计算，仅使用每个 key 对应的最新一行记录。",
12038
+ ".. _triggeringPattern_cs:",
11886
12039
  "",
11887
- "`triggeringPattern` 是一个字符串，表示触发计算的方式，每触发一次计算，输出一条结果到输出表。它可以是以下取值：",
12040
+ "`triggeringPattern` 字符串标量，表示触发计算的方式，每触发一次计算，输出一条结果到输出表。该字符串可选值如下：",
11888
12041
  "",
11889
12042
  "* 'perBatch': *triggeringPattern* 的默认值。每插入一次数据触发一次计算。",
11890
12043
  "* 'perRow': 插入的每一行数据都会触发一次计算。",
11891
- "* 'interval': 根据时间间隔触发计算。每经过 *triggeringInterval* 指定的时间间隔（根据系统时间）检查引擎中的数据是否被计算，若未被计算，则触发一次计算。",
11892
- "* 'keyCount': 若相同时间戳的数据分批次到达，当最新时间戳的 key 的数量达到 *triggeringInterval* 时，或尚未触发计算时有更新的时间戳数据到达，则触发计算。使用该参数值时，必须指定 *timeColumn*，且 *useSystemTime* = false。",
12044
+ "* 'interval': 根据时间间隔触发计算。每经过 *triggeringInterval* 指定的时间间隔（根据系统时间）检查引擎中的数据是否被计算。若存在未被计算的数据，则触发一次计算。",
12045
+ "* 'keyCount': 若相同时间戳的数据分批次到达，则只有在当前时间戳的记录数达到 *triggeringInterval*，或有更新时间戳的数据到达时，才会触发计算。使用该参数值时，必须指定 *timeColumn*，且 *useSystemTime* = false。",
11893
12046
  "",
11894
12047
  "注意：若设置 *triggeringPattern* = 'keyCount'，收到的数据中出现的乱序数据会被丢弃，不参与计算。",
11895
12048
  "",
11896
- "`triggeringInterval` 是一个整数或 tuple，触发计算规则如下：",
12049
+ ".. _triggeringInterval_cs:",
12050
+ "",
12051
+ "`triggeringInterval` 整数或元组，触发计算规则如下：",
11897
12052
  "",
11898
12053
  "* *triggeringPattern* 取值为'interval'时，*triggeringInterval* 是一个整数，表示触发计算的时间间隔，单位为毫秒，默认值为 1000。",
11899
- "* *triggeringPattern* 取值为'keyCount'时，*triggeringInterval* 可以是一个整数，表示触发计算的最新时间戳的 key 的数量。也可以是一个长度为 2 的 tuple。tuple 的第一个元素是整数，表示触发计算的最新时间戳的 key 的数量。tuple 的第二个值可以是整数或者 duration 类型数据。",
12054
+ "* *triggeringPattern* 取值为'keyCount'时：",
12055
+ "",
12056
+ " * *triggeringInterval* 可以是一个整数。设置后，在更新的时间戳的数据到来前，当前时间戳的记录数需要累积到 *triggeringInterval* 才会触发计算。",
12057
+ " * *triggeringInterval* 也可以是一个长度为 2 的 元组。元组的第一个元素是整数，表示触发计算的最新时间戳的记录数量。元组的第二个值可以是整数或者 duration 类型数据。",
11900
12058
  "",
11901
12059
  " 假设设置 *triggeringInterval* = (c1, c2):",
11902
12060
  "",
11903
12061
  " * 当 c2 为整数时，若收到的最新时间戳 t1 的数据数量小于 c1，这批数据不会触发计算，系统可以继续缓存更新时间戳 t2(t2>t1) 的数据，当 t2 的数据量达到 c2 或者收到更新的时间戳 t3(t3>t2) 的数据时，会触发时间戳 t1 对应数据的计算。注意必须满足 c2 < c1。",
11904
12062
  " * 当 c2 为 duration 时，若收到的最新时间戳 t1 的数据数量小于 c1，这批数据不会触发计算，系统收到更新的时间戳 t2(t2>t1) 的数据后，会等待 duration 指定的时间，若在此期间继续收到了 t1 的数据且满足 t1 时间戳的数据总量达到 c1，或者在此期间又收到了更新的时间戳 t3(t3>t2) 的数据，则直接触发 t1 对应数据的计算，等待时间结束后不再触发计算。否则，等待 duration 设置的时间后才会触发 t1 数据的计算。",
11905
12063
  "",
11906
- "`useSystemTime` 可选参数。表示 *outputTable* 中第一列（时间列）为系统当前时间（*useSystemTime* = true）或数据中时间列（*useSystemTime* = false）。",
12064
+ ".. _useSystemTime_cs:",
12065
+ "",
12066
+ "`useSystemTime` 可选参数，布尔值，表示是否使用数据注入引擎时的系统时间作为计算参照的时间列。",
12067
+ "",
12068
+ "* 若 *useSystemTime* = true，*outputTable* 中第一列（时间列）为系统时间；",
12069
+ "* 若 *useSystemTime* = false，必须指定 *timeColumn*，*outputTable* 中第一列（时间列）为数据的时间戳。",
12070
+ "",
12071
+ ".. _timeColumn_cs:",
11907
12072
  "",
11908
12073
  "`timeColumn` 是一个字符串。当 *useSystemTime* = false 时，指定订阅的流数据表中时间列的名称。仅支持 TIMESTAMP 类型。",
11909
12074
  "",
11910
- "`lastBatchOnly` 可选参数。横截面引擎是否只保留最新时间戳上的数据。当 *lastBatchOnly* = true 时，只能指定 *triggeringPattern* = 'keyCount'，此时横截面引擎表只保存最新时间戳上 key 的数据；否则，横截面引擎表更新并保留所有 key 的数据。",
12075
+ ".. _lastBatchOnly_cs:",
12076
+ "",
12077
+ "`lastBatchOnly` 可选参数。横截面引擎是否只保留最新时间戳上的数据。当 *lastBatchOnly* = true 时，只能指定 *triggeringPattern* = 'keyCount'，此时横截面引擎维护的键值表只保存最新时间戳的键值数据；否则，更新并保留所有时间戳上的键值数据。",
11911
12078
  "",
11912
- "`contextByColumn` 可选参数，是一个字符串标量。设置后，将对横截面引擎中数据按照指定的字段分组，并在组内进行指定计算。",
12079
+ ".. _contextByColumn_cs:",
12080
+ "",
12081
+ "`contextByColumn` 可选参数，字符串标量。设置后，将对横截面引擎中数据按照指定的字段分组，并在组内进行指定计算。",
11913
12082
  "",
11914
12083
  "* 设置该参数，必须指定 *metrics* 和 *outputTable*.",
11915
12084
  "* 如果 *metrics* 全为聚合函数，则分组计算结果和 groupby 分组计算结果一致，否则和 contextby 分组计算结果一致。",
11916
12085
  "",
11917
12086
  "若要开启快照机制 (snapshot)，必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。",
11918
12087
  "",
11919
- "启用快照机制之后，系统若出现异常，可及时将流数据引擎恢复到最新的快照状态。",
12088
+ ".. _snapshotDir_cs:",
11920
12089
  "",
11921
12090
  "`snapshotDir` 可选参数，字符串，表示保存引擎快照的文件目录。",
11922
12091
  "",
@@ -11929,27 +12098,14 @@
11929
12098
  " * 快照生成并刷到磁盘：文件保存为 <engineName>.snapshot；",
11930
12099
  " * 存在同名快照：旧快照自动重命名为 <engineName>.old。",
11931
12100
  "",
11932
- "`snapshotIntervalInMsgCount` 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。",
11933
- "",
11934
- "`raftGroup` 是流数据高可用订阅端 raft 组的 ID (大于 1 的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。"
11935
- ]
11936
- }
11937
- ]
11938
- },
11939
- {
11940
- "title": "详情",
11941
- "type": "detail",
11942
- "children": [
11943
- {
11944
- "type": "text",
11945
- "value": [
11946
- "创建横截面引擎。返回一个以 *keyColumn* 作为键值的键值表。",
12101
+ ".. _snapshotIntervalInMsgCount_cs:",
11947
12102
  "",
11948
- ".. *metrics* 根据该表进行计算。*keyColumn* 中的值对应表中唯一一行，如果新插入数据中 *keyColumn* 的值已经存在，那么将更新记录，反之将在表的末尾插入一行新的记录。",
12103
+ "`snapshotIntervalInMsgCount` 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。",
11949
12104
  "",
11950
- "* 如果没有指定 *metrics* 或 *outputTable*，横截面引擎不会利用表中的数据进行任何运算和输出，仅更新表中记录。",
12105
+ ".. _raftGroup_cs:",
11951
12106
  "",
11952
- "* 如果指定了 *metrics* 和 *outputTable*，横截面引擎会首先更新表中记录，然后对表中的最新记录进行运算，并把结果输出到 *outputTable* 中。"
12107
+ "`raftGroup` 是流数据高可用订阅端 raft 组的 ID (大于 1 的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。",
12108
+ ""
11953
12109
  ]
11954
12110
  }
11955
12111
  ]
@@ -12186,39 +12342,46 @@
12186
12342
  ]
12187
12343
  },
12188
12344
  {
12189
- "title": "参数",
12190
- "type": "parameters",
12345
+ "title": "详情",
12346
+ "type": "detail",
12191
12347
  "children": [
12192
12348
  {
12193
12349
  "type": "text",
12194
12350
  "value": [
12195
- "该引擎是基于时间序列引擎进行的扩展，继承了 ``createTimeSeriesEngine`` 所有的参数，请参照 :doc:`createTimeSeriesEngine` 中参数介绍。这里仅介绍与时间序列引擎不同的参数：",
12196
- "",
12197
- "`sessionBegin` 为可选参数，可以是与时间列的数据类型对应的 SECOND、TIME 或 NANOTIME 类型的标量或向量，表示每个时间段的起始时刻。如果 *sessionBegin* 是一个向量，它必须是递增的。",
12198
- "",
12199
- "`sessionEnd` 为可选参数，可以是与时间列的数据类型对应的 SECOND、TIME 或 NANOTIME 类型的标量或向量，表示每个时间段的结束时刻。",
12351
+ "创建流数据日级时间序列引擎。日级时间序列引擎和时间序列引擎窗口划分和计算规则基本一致，但在此基础上做了如下拓展：",
12200
12352
  "",
12201
- "`mergeSessionEnd` 为可选参数，是一个布尔值，表示每一个区间的计算是否包括其结束时刻（规整后的时刻）的数据。默认值为 false。",
12353
+ "* 该引擎只能在一个自然日的指定时间段内（以下统称为 session）进行窗口的聚合计算。一个自然日内，可以指定多个 session， 如 9:00-12:00，13:00-15:00 等。",
12354
+ "* 出现在一个 session 开始之前的数据，日级时序引擎规定将该部分数据合入该 session 的第一个窗口进行计算。",
12355
+ "* 当日最后一个 session 后到来的数据将被丢弃，不会计入第二天的第一个窗口中。",
12202
12356
  "",
12203
- "`forceTriggerSessionEndTime` 可选参数，是正整数，单位与 *timeColumn* 的时间精度一致。若 *sessionEnd* 时刻对应的窗口数据未计算输出，通过该参数设置系统经过多少时间后触发计算并输出。若不指定 *fill* ，未包含在该窗口内的分组不会输出结果；若指定了 *fill* ，未包含在该窗口内的分组会按照 *fill* 指定的方式输出结果。",
12357
+ "若指定了 *keyColumn* 进行分组，则上述计算将在各分组内独立进行。",
12204
12358
  "",
12205
- "注：",
12206
- "",
12207
- "* 系统会对数据窗口的起始时间（*sessionBegin* 和 *sessionEnd*）进行规整。"
12359
+ "更多流数据引擎的应用场景说明可以参考 :doc:`../../SeriesOfFunctions/streamingEngine`。"
12208
12360
  ]
12209
12361
  }
12210
12362
  ]
12211
12363
  },
12212
12364
  {
12213
- "title": "详情",
12214
- "type": "detail",
12365
+ "title": "参数",
12366
+ "type": "parameters",
12215
12367
  "children": [
12216
12368
  {
12217
12369
  "type": "text",
12218
12370
  "value": [
12219
- "创建流数据日级时间序列引擎。",
12371
+ "该引擎是基于时间序列引擎进行的扩展，继承了 ``createTimeSeriesEngine`` 所有的参数，请参照 ``createTimeSeriesEngine`` 中参数介绍。这里仅介绍与时间序列引擎不同的参数：",
12372
+ "",
12373
+ "`sessionBegin` 为可选参数，可以是与时间列的数据类型对应的 SECOND、TIME 或 NANOTIME 类型的标量或向量，表示每个时间段的起始时刻。如果 *sessionBegin* 是一个向量，它必须是递增的。",
12374
+ "",
12375
+ "`sessionEnd` 为可选参数，可以是与时间列的数据类型对应的 SECOND、TIME 或 NANOTIME 类型的标量或向量，表示每个时间段的结束时刻。可在 *sessionEnd* 中指定 00:00:00 表示的次日的零点（即当日的 24:00:00）。",
12376
+ "",
12377
+ "`mergeSessionEnd` 为可选参数，是一个布尔值。当 close = 'left' 时，表示每个 session 结束时刻（规整后）的数据是否合入最后一个窗口。默认值为 false，此时该条数据不会合入当前 session 的最后一个窗口，但可以触发最后一个窗口的计算；如果当前 session 不是该自然日内最后一个 session，则该数据会合入下个 session 的第一个窗口。",
12378
+ "",
12379
+ "`forceTriggerSessionEndTime` 可选参数，正整数，单位与 *timeColumn* 的时间精度一致。若 *sessionEnd* 时刻对应的窗口数据长时间未发生计算，通过该参数可以设置系统经过多少时间后触发计算并输出。若不指定 *fill* ，未包含在该窗口内的分组不会输出结果；若指定了 *fill* ，未包含在该窗口内的分组会按照 *fill* 指定的方式输出结果。",
12380
+ "",
12381
+ "注：",
12220
12382
  "",
12221
- "对一个自然日内的数据指定时间段（由 *sessionBegin* 和 *sessionEnd* 指定）进行聚合计算。*sessionBegin* 设置的第一个时刻之前的所有数据并入第一个窗口进行计算。*sessionEnd* 设置的最后一个时刻及之后的数据是否参与计算，由参数 *mergeSessionEnd* 的设置决定。当 *mergeSessionEnd* = true 时，*sessionEnd* 设置的最后一个时刻上的数据会参与计算，但大于此时刻的数据被忽略，不参与计算；当 *mergeSessionEnd* = false 时，*sessionEnd* 设置的最后一个时刻及之后的数据都被忽略，不参与计算。"
12383
+ "* 系统会对数据窗口的起始时间（*sessionBegin* 和 *sessionEnd*）进行规整。",
12384
+ ""
12222
12385
  ]
12223
12386
  }
12224
12387
  ]
@@ -12548,11 +12711,11 @@
12548
12711
  "",
12549
12712
  "`outputTable` 结果的输出表，可以是内存表或者分布式表。使用 ``createDualOwnershipReactiveStateEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。",
12550
12713
  "",
12551
- "输出表的各列的顺序为：分组列，计算结果列。",
12714
+ "输出表各列的顺序为：分组列，计算结果列。",
12552
12715
  "",
12553
12716
  "其中：",
12554
12717
  "",
12555
- "(1) 输出表的前几列为 keyColumn1 和 keyColumn2 的公共列，然后依次为 keyColumn1 的非公共列和 keyColumn2 的非公共列。",
12718
+ "(1) 输出表的前几列为 keyColumn1 和 keyColumn2 的公共列，然后依次为 keyColumn1 的非公共列和 keyColumn2 的非公共列。",
12556
12719
  "",
12557
12720
  "(2) 其后为 metrics1 的计算结果列，metrics2 的计算结果列。"
12558
12721
  ]
@@ -12566,7 +12729,7 @@
12566
12729
  {
12567
12730
  "type": "text",
12568
12731
  "value": [
12569
- "Dual Ownership Reactive State Engine 是对响应式状态引擎的扩展，支持对同一张流数据表指定两种不同的分组方式分别应用不同的指标进行并行计算。与响应式状态级联实现相比，调用该函数进行计算极大地提升了计算性能。",
12732
+ "Dual Ownership Reactive State Engine 是对响应式状态引擎的扩展，支持对同一张流数据表指定两种不同的分组方式分别应用不同的指标进行并行计算。与响应式状态级联实现相比，该函数能极大地提升计算性能。",
12570
12733
  "",
12571
12734
  "注意：该引擎输出和输入顺序保持一致，即内部强制使 keepOrder = True。"
12572
12735
  ]
@@ -12661,41 +12824,61 @@
12661
12824
  ]
12662
12825
  },
12663
12826
  {
12664
- "title": "参数",
12665
- "type": "parameters",
12827
+ "title": "详情",
12828
+ "type": "detail",
12666
12829
  "children": [
12667
12830
  {
12668
12831
  "type": "text",
12669
12832
  "value": [
12670
- "equal join引擎的部分参数和 asof join 引擎相同，请参照 :doc:`createAsofJoinEngine` 中参数介绍。下面介绍不同的参数：",
12671
- "",
12672
- "`name` 必选参数，是一个字符串，表示流数据 equal join 引擎的名称。",
12833
+ "创建流数据等值连接引擎。返回一个左、右两表 equal join 后的表对象。注入等值连接引擎的左、右两表将以 :ref:`matchingColumn <mc_aj>` + :ref:`timeColumn <tc_ej>` 作为连接列，返回两表中连接字段相等的行。",
12673
12834
  "",
12674
- "`garbageSize` 可选参数，是正整数，默认值是5,000（单位为行）。当内存中历史数据行数超过 *garbageSize* 时，会清理本次计算不需要的历史数据。",
12675
- "",
12676
- "`maxDelayedTime` 可选参数，为正整数，默认值为3s，equal join 引擎接收到的能够参与计算的数据的最大延时时间。超过 *maxDelayedTime* 延迟时间的数据会被丢弃。不建议 *maxDelayedTime* 值设置过小。",
12677
- "",
12678
- "当内存中历史数据行数超过 *garbageSize* 时，会根据以下规则清理数据：",
12679
- "",
12680
- "\\1. 历史数据中已经 join 过的数据；",
12681
- "",
12682
- "\\2. 内存中历史数据的时间戳与 *leftTable* 或 *rightTable* 新收到的数据的时间戳的差值大于 *maxDelayedTime* 的数据。"
12835
+ "更多流数据引擎的应用场景说明可以参考 :doc:`../../SeriesOfFunctions/streamingEngine`。"
12683
12836
  ]
12684
12837
  }
12685
12838
  ]
12686
12839
  },
12687
12840
  {
12688
- "title": "详情",
12689
- "type": "detail",
12841
+ "title": "计算规则",
12842
+ "children": [
12843
+ {
12844
+ "type": "text",
12845
+ "value": [
12846
+ "* 每次数据注入引擎左表时，会在右表中查找与连接列字段相匹配的记录，若找到，则将两表匹配的记录 join 后，根据 :ref:`metrics <metrics_aj>` 给出的因子进行计算并输出。",
12847
+ "* 每次数据注入引擎右表时，亦会做同样操作。"
12848
+ ]
12849
+ }
12850
+ ]
12851
+ },
12852
+ {
12853
+ "title": "参数",
12854
+ "type": "parameters",
12690
12855
  "children": [
12691
12856
  {
12692
12857
  "type": "text",
12693
12858
  "value": [
12694
- "创建流数据 equal join 引擎。返回一个左、右两表 :doc:`/SQLStatements/TableJoiners/equaljoin` 后的表对象。通常与 :doc:`../s/subscribeTable` 函数一起使用。",
12859
+ "equal join 引擎的部分参数和 asof join 引擎相同，请参照 :doc:`createAsofJoinEngine` 中参数介绍。下面介绍不同的参数：",
12860
+ "",
12861
+ ".. _name_ej:",
12862
+ "",
12863
+ "`name` 字符串标量，表示 equal join 引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
12864
+ "",
12865
+ ".. _tc_ej:",
12866
+ "",
12867
+ "`timeColumn` 字符串标量或向量。用于指定 *leftTable* 和 *rightTable* 中时间列的名称。两表的时间列名称可以不同，但数据类型需保持一致。当 *leftTable* 和 *rightTable* 时间列名称相同时，*timeColumn* 是字符串标量，否则，*timeColumn* 是长度为2的字符串向量。",
12868
+ "",
12869
+ ".. _garbageSize_ej:",
12870
+ "",
12871
+ "`garbageSize` 可选参数，正整数，默认值是 5,000（单位为行）。当内存中历史数据行数超过 *garbageSize* 时，会清理本次计算不需要的历史数据。",
12872
+ "",
12873
+ "满足以下条件的数据才会被清理：",
12695
12874
  "",
12696
- "* 左、右两表组内数据的时间列按时间顺序排列，且时间列和连接列组合的取值是没有重复的。",
12875
+ "\\1. 历史数据中已经 join 并输出的数据；",
12697
12876
  "",
12698
- "从 1.30.17, 2.00.5 版本开始，DolphinDB 支持其他流数据引擎通过 :doc:`/FunctionsandCommands/FunctionReferences/g/getLeftStream` 及 :doc:`/FunctionsandCommands/FunctionReferences/g/getRightStream`，为流数据 join 引擎注入数据，以实现引擎间的级联。"
12877
+ "\\2. 历史数据未发生 join 的数据，但其时间戳与 *leftTable* 或 *rightTable* 收到的最新数据的时间戳的差值大于 *maxDelayedTime*。",
12878
+ "",
12879
+ ".. _maxDelayedTime_ej:",
12880
+ "",
12881
+ "`maxDelayedTime` 可选参数，正整数，单位同 timeColumn 精度一致，默认值为 3 秒。该参数仅在达到 *garbageSize* 清理条件时才会起效，表示引擎内能够保留最新多长时间的数据。详情参考上述清理条件 2。不建议设置 *maxDelayedTime* 值设置过小。"
12699
12882
  ]
12700
12883
  }
12701
12884
  ]
@@ -12716,20 +12899,20 @@
12716
12899
  "language": "console",
12717
12900
  "value": [
12718
12901
  " ",
12719
- " $ leftTable=keyedTable(`time`sym, 1:0, `time`sym`price, [SECOND, SYMBOL, DOUBLE])",
12720
- " $ rightTable=keyedTable(`time`sym, 1:0, `time`sym`val, [SECOND, SYMBOL, DOUBLE])",
12721
- " $ output=table(100:0, `time`sym`total, [SECOND, SYMBOL, DOUBLE])",
12722
- " $ ejEngine=createEqualJoinEngine(\"test1\", leftTable, rightTable, output, <price+val>, `sym, `time)",
12723
- " $ tmp1=table(take(13:30:10, 20) as time, take(`AAPL, 10) join take(`IBM, 10) as sym, double(1..20) as price)",
12724
- " $ appendForJoin(ejEngine, true, tmp1)",
12902
+ " $ share streamTable(1:0, `time`sym`price, [SECOND, SYMBOL, DOUBLE]) as leftTable",
12903
+ " $ share streamTable(1:0, `time`sym`val, [SECOND, SYMBOL, DOUBLE]) as rightTable",
12904
+ " $ output=table(100:0, `time`sym`price`val`total, [SECOND, SYMBOL, DOUBLE, DOUBLE, DOUBLE])",
12905
+ " $ ejEngine=createEqualJoinEngine(\"test1\", leftTable, rightTable, output, [<price>, <val>, <price*val>], `sym, `time)",
12906
+ " $ subscribeTable(tableName=\"leftTable\", actionName=\"joinLeft\", offset=0, handler=appendForJoin{ejEngine, true}, msgAsTable=true)",
12907
+ " $ subscribeTable(tableName=\"rightTable\", actionName=\"joinRight\", offset=0, handler=appendForJoin{ejEngine, false}, msgAsTable=true)",
12908
+ "",
12909
+ " $ tmp1=table(13:30:10+1..20 as time, take(`AAPL, 10) join take(`IBM, 10) as sym, double(1..20) as price)",
12725
12910
  " $ leftTable.append!(tmp1)",
12726
- " $ tmp2=table(take(13:30:10, 20) as time, take(`AAPL, 10) join take(`IBM, 10) as sym, double(50..31) as val)",
12727
- " $ appendForJoin(ejEngine, false, tmp2)",
12911
+ " $ tmp2=table(13:30:10+1..20 as time, take(`AAPL, 10) join take(`IBM, 10) as sym, double(50..31) as val)",
12728
12912
  " $ rightTable.append!(tmp2)",
12729
12913
  "",
12730
- " $ re = select * from output order by time, sym",
12731
- " $ expected = select time, sym, price+val from ej(leftTable, tmp2, `sym`time) order by time, sym",
12732
- " $ each(eqObj, re.values(), expected.values())",
12914
+ " $ select count(*) from output",
12915
+ " 20",
12733
12916
  ""
12734
12917
  ]
12735
12918
  },
@@ -12892,23 +13075,19 @@
12892
13075
  {
12893
13076
  "type": "text",
12894
13077
  "value": [
12895
- "创建一个跨进程共享内存表的句柄。",
13078
+ "创建一个跨进程共享内存表的句柄。跨进程共享内存表通常作为流计算的输出表。在对时延要求极高的场景下，用户进程通过插件直接访问共享内存获取数据，极大减小了 TCP 等网络传输的时延。",
13079
+ "",
13080
+ "跨进程共享内存表通过共享内存（由操作系统管理）进行跨进程通信。共享内存表仅支持在同一物理机内共享，不支持在集群不同物理节点间进行共享。",
13081
+ "",
13082
+ "跨进程共享内存表支持读写，但不支持对跨进程共享内存表的表结构进行修改。向跨进程共享内存表写数据的方法，与普通内存表一致。若一次性插入的数据量大于共享内存，系统会抛出异常。",
12896
13083
  "",
12897
- "跨进程共享内存表通过共享内存（由操作系统管理）进行跨进程通信。系统允许不同进程对该内存并发写入（暂不支持并发读），或者不同进程对该内存同时读写。注意：共享内存表仅支持在同一物理机内共享，不支持在集群不同物理节点间进行共享。",
13084
+ "* 读写机制：将写入共享内存的进程作为生产者，从共享内存中读取数据的进程作为消费者。一次写入的数据将作为一个整体，供一次读取消费，且读进程依次按顺序对写入的数据进行消费。例如：第一写入 100 条数据，第二次写入 200 条数据，则第一次会读到 100 条数据，第二次会读到第二批写入的 200 条数据，以此类推。读取数据时，共享内存表中的所有数据均已被消费，则读进程会被阻塞，直到有新写入的可消费数据时，才能将数据读出。",
12898
13085
  "",
12899
- "跨进程共享内存表支持读写，但不支持对跨进程共享内存表的表结构进行修改。向跨进程共享内存表写数据的方法，与普通内存表一致。但对于跨进程共享内存表，既可以通过表的句柄插入数据，亦可通过与表名同名的表对象插入数据。若一次性插入的数据量大于共享内存，系统会抛出异常。"
13086
+ "DolphinDB 支持多进程并发写入共享内存表，以及在写入的同时进行读操作。但注意，只能同时存在一个读进程。参考上述读写机制，读取是一次性的，若不同进程并发读取，将会得到不同阶段写入的数据。"
12900
13087
  ]
12901
13088
  }
12902
13089
  ]
12903
13090
  },
12904
- {
12905
- "title": "读写机制：",
12906
- "children": []
12907
- },
12908
- {
12909
- "title": "场景：",
12910
- "children": []
12911
- },
12912
13091
  {
12913
13092
  "title": "例子",
12914
13093
  "type": "example",
@@ -12938,7 +13117,14 @@
12938
13117
  " $ temp = 30 + rand(5.0,n)",
12939
13118
  " $ tableInsert(shm_test,timestamp,temp)",
12940
13119
  "",
12941
- " $ tableInsert(pubTable,timestamp,temp)"
13120
+ " $ tableInsert(pubTable,timestamp,temp)",
13121
+ ""
13122
+ ]
13123
+ },
13124
+ {
13125
+ "type": "text",
13126
+ "value": [
13127
+ "相关函数：:doc:`../d/dropIPCInMemoryTable`, :doc:`../l/loadIPCInMemoryTable`"
12942
13128
  ]
12943
13129
  }
12944
13130
  ]
@@ -12968,15 +13154,23 @@
12968
13154
  {
12969
13155
  "type": "text",
12970
13156
  "value": [
12971
- "创建流数据表的 lookup join 引擎，该引擎可以对两个流数据表进行实时 left join，或者对流数据表和非流数据表进行 left join（此时需要定时刷新非流表）。",
13157
+ "创建流数据表的 lookup join 引擎，该引擎以 :ref:`matchingColumn <matchingColumnLJ>` 作为连接列将两个流数据表进行实时 :doc:`/SQLStatements/TableJoiners/leftjoin`，",
13158
+ "或者将流数据表和非流数据表进行 left join（此时需要定时刷新非流表）。lookup join 引擎常用于右表更新不频繁的场景。",
12972
13159
  "",
12973
- "请注意：",
13160
+ "工作机制：",
13161
+ "",
13162
+ "\\1. 仅当左表有新数据流入时才会触发左、右表的 left join 输出。",
13163
+ "",
13164
+ "\\2. 引擎仅保留右表根据 *matchingColumn* 分组后各分组内的最新一条数据。当右表是订阅的流表时，数据流入右表的同时会更新数据；",
13165
+ "若右表为内存表或分布式表（目前仅支持维度表），系统会根据 *checkTimes* 定时刷新右表数据。",
12974
13166
  "",
12975
- "\\1. 仅当左表有新数据流入时才会触发左、右表的 left join。",
13167
+ "lookup join 引擎实际采用 left join 的连接方式，但与 left join 不完全等价，区别在于：如果右表中有多条匹配记录，left join 会返回右表所有匹配的记录，但 lookup join 引擎只返回右表最新一条匹配的记录。",
12976
13168
  "",
12977
- "\\2. 右表仅保留根据 *matchingColumn* 分组的各分组内的最新一条数据。当右表是订阅的流表时，数据流入右表的同时会更新数据；若右表为内存表或分布式表（目前仅支持维度表），系统会根据 *checkTimes* 定时刷新右表数据。",
13169
+ "lookup join 引擎与 asof jion 引擎很相似，它们之间的区别与联系如下：",
12978
13170
  "",
12979
- "从 1.30.17, 2.00.5 版本开始，DolphinDB 支持其他流数据引擎通过 :doc:`/FunctionsandCommands/FunctionReferences/g/getLeftStream` 及 :doc:`/FunctionsandCommands/FunctionReferences/g/getRightStream`，为流数据 join 引擎注入数据，以实现引擎间的级联。"
13171
+ "lookup join 引擎输出表的第一列可以不是时间列，而 asof join 引擎输出表第一列必须是时间列。",
13172
+ "",
13173
+ "lookup join 引擎当左表有新数据流入便会触发 jion 输出，因此无需考虑数据延迟，也无需缓存数据。而 asof join 引擎，当指定 timeColumn 时，需要考虑左右表的数据延时，因此需要缓存数据。"
12980
13174
  ]
12981
13175
  }
12982
13176
  ]
@@ -12988,11 +13182,11 @@
12988
13182
  {
12989
13183
  "type": "text",
12990
13184
  "value": [
12991
- "`name` 必选参数，是一个字符串，表示流数据 lookup join 引擎的名称。",
13185
+ "`name` 必选参数，表示流数据 lookup join 引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
12992
13186
  "",
12993
- "`leftTable` 是一个表对象。可以不包含数据，但结构必须与订阅的流数据表相同。",
13187
+ "`leftTable` 表对象。结构必须与订阅的流数据表相同。",
12994
13188
  "",
12995
- "`rightTable` 是一个表对象，是不包含数据的内存表、流数据表或维度表。请注意，如果 *rightTable* 没有被订阅，必须设置 *checkTimes* 定时刷新数据。",
13189
+ "`rightTable` 表对象，可以是内存表、流数据表或维度表。请注意，如果 *rightTable* 没有被订阅，必须设置 *checkTimes* 定时刷新数据。",
12996
13190
  "",
12997
13191
  "`outputTable` 必选参数，为计算结果的输出表。在使用 ``createLookupJoinEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。",
12998
13192
  "",
@@ -13011,6 +13205,7 @@
13011
13205
  "",
13012
13206
  "请注意，若 *metrics* 中指定了时间列或者连接列，需要在连接列或时间列前加上表名来指定该列所属的表，若不加表名，则默认取左表的列。例如：*matchingColumn* = \\`sym, *timeColumn* = \\`timestamp，则 *metrics* = <[rightTable.sym, rightTable.timestamp, price, val, price*val]> 指定 *metrics* 中输出右表的 sym 列和 timestamp 列。",
13013
13207
  "",
13208
+ ".. _matchingColumnLJ:",
13014
13209
  "",
13015
13210
  "`matchingColumn` 表示连接列的字符串标量/向量或字符串向量组成的 tuple，支持 Integral, Temproal 或 Literal(UUID 除外)类型。",
13016
13211
  "",
@@ -13269,7 +13464,7 @@
13269
13464
  {
13270
13465
  "type": "text",
13271
13466
  "value": [
13272
- "`dbHandle` :doc:`../d/database` 函数返回的数据库句柄。它可以是本地磁盘数据库，也可以是分布式数据库。*dbHandle* 为空字符串或没有指定时，表示内存数据库的句柄。",
13467
+ "`dbHandle` :doc:`../d/database` 函数返回的数据库句柄。它可以是本地磁盘数据库，也可以是分布式数据库。*dbHandle* 为空字符串或没有指定时，表示内存数据库的句柄。",
13273
13468
  "",
13274
13469
  "`table` 一个表或包含多个表的元组。系统将会根据该表的结构创建新的分区表。",
13275
13470
  "",
@@ -13365,27 +13560,17 @@
13365
13560
  "value": [
13366
13561
  "在分布式数据库中，初次创建表后，可以跳过 :doc:`../l/loadTable` 把表载入内存的步骤，因为分布式文件系统会动态刷新表的内容。系统重启后，需要再次执行 loadTable 函数加载表。",
13367
13562
  "",
13368
- "例 2. 在本地数据库中创建分区表",
13563
+ ".. 例 2. 在本地数据库中创建分区表",
13369
13564
  "",
13370
- "我们只需要将数据库的路径修改为本地文件系统的路径。需要注意的是，在本地文件系统中，系统不能自动刷新表的内容。在进行交互工作之前，我们需要使用 :doc:`../l/loadTable` 函数把表加载到内存中。",
13371
- ""
13372
- ]
13373
- },
13374
- {
13375
- "type": "code",
13376
- "language": "console",
13377
- "value": [
13565
+ ".. 我们只需要将数据库的路径修改为本地文件系统的路径。需要注意的是，在本地文件系统中，系统不能自动刷新表的内容。在进行交互工作之前，我们需要使用 :doc:`../l/loadTable` 函数把表加载到内存中。",
13566
+ "",
13567
+ ".. .. code:: console",
13378
13568
  "",
13379
13569
  " $ db=database(\"C:/DolphinDB/Data/rangedb_tradedata\",RANGE,`A`F`M`S`ZZZZ)",
13380
- ""
13381
- ]
13382
- },
13383
- {
13384
- "type": "text",
13385
- "value": [
13386
- "例 3. 在内存数据库中创建一个分区表",
13387
13570
  "",
13388
- "例 3.1 创建分区常规内存表",
13571
+ "例 2. 在内存数据库中创建一个分区表",
13572
+ "",
13573
+ "例 2.1 创建分区常规内存表",
13389
13574
  ""
13390
13575
  ]
13391
13576
  },
@@ -13409,7 +13594,7 @@
13409
13594
  {
13410
13595
  "type": "text",
13411
13596
  "value": [
13412
- "例 3.2 创建分区键值内存表",
13597
+ "例 2.2 创建分区键值内存表",
13413
13598
  ""
13414
13599
  ]
13415
13600
  },
@@ -13433,7 +13618,7 @@
13433
13618
  {
13434
13619
  "type": "text",
13435
13620
  "value": [
13436
- "例 3.3 创建分区流数据表",
13621
+ "例 2.3 创建分区流数据表",
13437
13622
  "",
13438
13623
  "注意，创建分区流数据表时 createPartitionedTable 的第二个参数必须是元组，并且其长度必须与分区数量相等，每个表对应一个分区。下例中，trades_stream1 和 trades_stream2 组成一个分区流数据表 trades。写入数据时，只能分别往 trades_stream1 和 trades_stream2 写入，不能直接写入到 trades。查询 trades 可以获取到两个表的数据。",
13439
13624
  ""
@@ -13469,7 +13654,7 @@
13469
13654
  "09:30:01.001 DELL 100 15.5",
13470
13655
  "============= ===== ===== ======",
13471
13656
  "",
13472
- "例 3.4 创建分区 MVCC 内存表",
13657
+ "例 2.4 创建分区 MVCC 内存表",
13473
13658
  "",
13474
13659
  "创建分区 MVCC 内存表的方式与创建分区流数据表的方式相同。",
13475
13660
  ""
@@ -13505,7 +13690,7 @@
13505
13690
  "09:30:01.001 DELL 100 15.5",
13506
13691
  "============= ===== ===== ======",
13507
13692
  "",
13508
- "例 4. 指定压缩算法",
13693
+ "例 3. 指定压缩算法",
13509
13694
  ""
13510
13695
  ]
13511
13696
  },
@@ -13548,6 +13733,60 @@
13548
13733
  }
13549
13734
  ]
13550
13735
  },
13736
+ {
13737
+ "title": "详情",
13738
+ "type": "detail",
13739
+ "children": [
13740
+ {
13741
+ "type": "text",
13742
+ "value": [
13743
+ "创建响应式状态引擎。返回一个表对象，向该表写入数据意味着这些数据进入响应式状态引擎进行计算。",
13744
+ "",
13745
+ "下列状态函数在 DolphinDB 的响应式状态引擎中的实现均得到了优化。目前，状态引擎不允许使用未经优化的状态函数，且需避免使用聚合函数。",
13746
+ "",
13747
+ "* 累计窗口函数：cumavg, cumsum, cumprod, cumcount, cummin, cummax, cumvar, cumvarp, cumstd, cumstdp, cumcorr, cumcovar, cumbeta, cumwsum, cumwavg, cumfirstNot, cumlastNot, cummed, cumpercentile, cumPositiveStreak",
13748
+ "* 滑动窗口函数：ema, mavg, msum, mcount, mprod, mvar, mvarp, mstd, mstdp, mskew, mkurtosis, mmin, mmax, mimin, mimax, mmed, mpercentile, mrank, mcorr, mcovar, mbeta, mwsum, mwavg, mmad, mfirst, mlast, mmaxPositiveStreak, mslr, tmove, tmfirst, tmlast, tmsum, tmavg, tmcount, tmvar, tmvarp, tmstd, tmstdp, tmprod, tmskew, tmkurtosis, tmmin, tmmax, tmmed, tmpercentile, tmrank, tmcovar, tmbeta, tmcorr, tmwavg, tmwsum, tmoving, moving, sma,wma, dema, tema, trima, linearTimeTrend, talib, t3, ma, mmaxPostiveStreak",
13749
+ "* 序列相关函数：deltas, ratios, ffill, move, prev, iterate, ewmMean, ewmVar, ewmStd, ewmCov, ewmCorr, prevState",
13750
+ "* topN相关函数：msumTopN, mavgTopN, mstdpTopN, mstdTopN, mvarpTopN, mvarTopN, mcorrTopN, mbetaTopN, mcovarTopN, mwsumTopN",
13751
+ "* 高阶函数：segmentby(参数 *func* 暂支持 cumsum, cummax, cummin, cumcount, cumavg, cumstd, cumvar, cumstdp, cumvarp)",
13752
+ "* 其他函数：talibNull, dynamicGroupCumsum, dynamicGroupCumcount, topRange, lowRange, trueRange",
13753
+ "",
13754
+ "注意，:doc:`/Functionalprogramming/TemplateFunctions/talib` 作为状态函数时，第一个参数 `func` 只能是响应式状态引擎支持的状态函数。",
13755
+ "",
13756
+ ".. 响应式状态引擎不支持多线程并发写入，必须配置 *subExecutorPooling* = false，使引擎读写任务串行执行。",
13757
+ "",
13758
+ "更多流数据引擎的应用场景说明可以参考 :doc:`../../SeriesOfFunctions/streamingEngine`。",
13759
+ ""
13760
+ ]
13761
+ }
13762
+ ]
13763
+ },
13764
+ {
13765
+ "title": "计算规则",
13766
+ "children": [
13767
+ {
13768
+ "type": "text",
13769
+ "value": [
13770
+ "每注入一条数据都会触发一次计算，产生一条结果。用户可以通过设置参数 :ref:`filter <filter_rs>` 过滤计算结果后输出。 若指定了 :ref:`keyColumn <keyColumn_rs>` 进行分组，则计算将在组内进行。",
13771
+ "",
13772
+ "注意：状态引擎的输出结果可能和输入顺序不一致，建议配置参数 :ref:`keepOrder <keepOrder_rs>` = true，保持输出结果的有序性。"
13773
+ ]
13774
+ }
13775
+ ]
13776
+ },
13777
+ {
13778
+ "title": "引擎的其它功能",
13779
+ "children": [
13780
+ {
13781
+ "type": "text",
13782
+ "value": [
13783
+ "* 支持数据/状态清理：状态引擎内部的状态数据是按分组保存的，为避免分组过多，导致引擎内部内存开销过大，可以将历史分组数据进行清理。用户可以通过配置参数 *keyPurgeFilter* 设置清理条件，配置 *keyPurgeFreqInSecond* 设置清理时间间隔。（详情请参考 :ref:`keyPurgeFilter <keyPurgeFilter_rs>` 和 :ref:`keyPurgeFreqInSecond <keyPurgeFreqInSecond_rs>` 的参数说明）",
13784
+ "* 快照机制：启用快照机制之后，系统若出现异常，可及时将流数据引擎恢复到最新的快照状态。（详情请参考 :ref:`snapshotDir <snapshotDir_rs>` 和 :ref:`snapshotIntervalInMsgCount <snapshotIntervalInMsgCount_rs>` 的参数说明）",
13785
+ "* 流数据引擎高可用：若要启用引擎高可用，需在订阅端 raft 组的 leader 节点创建引擎并通过 *raftGroup* 参数开启高可用。开启高可用后，当 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。（详情请参考 :ref:`raftGroup <raftGroup_rs>` 的参数说明）"
13786
+ ]
13787
+ }
13788
+ ]
13789
+ },
13551
13790
  {
13552
13791
  "title": "参数",
13553
13792
  "type": "parameters",
@@ -13555,7 +13794,11 @@
13555
13794
  {
13556
13795
  "type": "text",
13557
13796
  "value": [
13558
- "`name` 一个字符串，表示响应式状态引擎的名称，是其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
13797
+ ".. _name_rs:",
13798
+ "",
13799
+ "`name` 字符串标量，表示响应式状态引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
13800
+ "",
13801
+ ".. _metrics_rs:",
13559
13802
  "",
13560
13803
  "`metrics` 以元代码的形式表示计算公式。有关元代码的详情可参考 :doc:`/Objects/Metaprogramming`。若需使用用户自定义函数，请注意以下两点：",
13561
13804
  "",
@@ -13571,20 +13814,13 @@
13571
13814
  " $ return (N - 1) * linearregSlope + linearregIntercept",
13572
13815
  " $ }",
13573
13816
  "",
13574
- "下列状态函数在 DolphinDB 的响应式状态引擎中的实现均得到了优化。目前，状态引擎不允许使用未经优化的状态函数。应避免使用聚合函数。",
13575
- "",
13576
- "* 累计窗口函数：cumavg, cumsum, cumprod, cumcount, cummin, cummax, cumvar, cumvarp, cumstd, cumstdp, cumcorr, cumcovar, cumbeta, cumwsum, cumwavg, cumfirstNot, cumlastNot, cummed, cumpercentile, cumPositiveStreak",
13577
- "* 滑动窗口函数：ema, mavg, msum, mcount, mprod, mvar, mvarp, mstd, mstdp, mskew, mkurtosis, mmin, mmax, mimin, mimax, mmed, mpercentile, mrank, mcorr, mcovar, mbeta, mwsum, mwavg, mmad, mfirst, mlast, mslr, tmove, tmfirst, tmlast, tmsum, tmavg, tmcount, tmvar, tmvarp, tmstd, tmstdp, tmprod, tmskew, tmkurtosis, tmmin, tmmax, tmmed, tmpercentile, tmrank, tmcovar, tmbeta, tmcorr, tmwavg, tmwsum, tmoving, moving, sma,wma, dema, tema, trima, linearTimeTrend, talib, t3, ma",
13578
- "* 序列相关函数：deltas, ratios, ffill, move, prev, iterate, ewmMean, ewmVar, ewmStd, ewmCov, ewmCorr, prevState",
13579
- "* topN相关函数：msumTopN, mavgTopN, mstdpTopN, mstdTopN, mvarpTopN, mvarTopN, mcorrTopN, mbetaTopN, mcovarTopN, mwsumTopN",
13580
- "* 高阶函数：segmentBy(参数 func 暂支持 cumsum, cummax, cummin, cumcount, cumavg, cumstd, cumvar, cumstdp, cumvarp)",
13581
- "* 其他函数：talibNull, dynamicGroupCumsum, dynamicGroupCumcount, topRange, lowRange",
13817
+ ".. _dummyTable_rs:",
13582
13818
  "",
13583
- "注意，:doc:`/Functionalprogramming/TemplateFunctions/talib` 作为状态函数时，第一个参数 `func` 只能是响应式状态引擎支持的状态函数。",
13819
+ "`dummyTable` 一个表对象，该表的唯一作用是为引擎提供订阅的流数据表的 schema，可以含有数据，亦可为空表。",
13584
13820
  "",
13585
- "`dummyTable` 是一个表对象，该表的唯一作用是为引擎提供订阅的流数据表的 schema，可以含有数据，亦可为空表。",
13821
+ ".. _outputTable_rs:",
13586
13822
  "",
13587
- "`outputTable` 结果的输出表，可以是内存表或者分布式表。使用 ``createReactiveStateEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。",
13823
+ "`outputTable` 计算结果的输出表，可以是内存表或分布式表。使用 ``createReactiveStateEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。响应式状态引擎会将计算结果注入该表。",
13588
13824
  "",
13589
13825
  "输出表的各列的顺序为：分组列，计算结果列。",
13590
13826
  "",
@@ -13594,13 +13830,17 @@
13594
13830
  "",
13595
13831
  "\\(2) 其后为计算结果列，可为多列。",
13596
13832
  "",
13597
- "`keyColumn` 一个字符串标量或向量，表示分组列名，例如以每只股票为一组进行计算。",
13833
+ ".. _keyColumn_rs:",
13834
+ "",
13835
+ "`keyColumn` 字符串标量或向量表示分组列名。计算将在各分组进行。",
13836
+ "",
13837
+ ".. _filter_rs:",
13598
13838
  "",
13599
13839
  "`filter` 可选参数。以元代码的形式表示过滤条件。只有符合过滤条件的结果才被输出。它只能是一个表达式。设置多个条件时，用逻辑运算符（and, or）连接。",
13600
13840
  "",
13601
13841
  "若要开启快照机制 (snapshot)，必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。",
13602
13842
  "",
13603
- "启用快照机制之后，系统若出现异常，可及时将流数据引擎恢复到最新的快照状态。",
13843
+ ".. _snapshotDir_rs:",
13604
13844
  "",
13605
13845
  "`snapshotDir` 可选参数，字符串，表示保存引擎快照的文件目录。",
13606
13846
  "",
@@ -13613,47 +13853,38 @@
13613
13853
  " * 快照生成并刷到磁盘：文件保存为 <engineName>.snapshot；",
13614
13854
  " * 存在同名快照：旧快照自动重命名为 <engineName>.old。",
13615
13855
  "",
13856
+ ".. _snapshotIntervalInMsgCount_rs:",
13857
+ "",
13616
13858
  "`snapshotIntervalInMsgCount` 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。",
13617
13859
  "",
13860
+ ".. _keepOrder_rs:",
13861
+ "",
13618
13862
  "`keepOrder` 可选参数，表示输出表数据是否按照输入时的顺序排序。设置 *keyOrder* = true，表示输出表按照输入时的顺序排序。当 *keyColumn* 包含有时间列时，*keyOrder* 默认值为 true，否则默认值为 false。",
13619
13863
  "",
13620
- "若要对历史分组的数据进行清理，可以配置 *keyPurgeFilter* 和 *keyPurgeFreqInSecond* 参数。",
13864
+ ".. _keyPurgeFilter_rs:",
13621
13865
  "",
13622
13866
  "`keyPurgeFilter` 可选参数，是一个由条件表达式组成的元代码，表示清理条件。各表达式只能引用 *outputTable* 中的字段。",
13623
13867
  "",
13868
+ ".. _keyPurgeFreqInSecond_rs:",
13869
+ "",
13624
13870
  "`keyPurgeFreqInSecond` 正整数，表示触发数据清理需要满足的时间间隔（以秒为单位）。",
13625
13871
  "",
13626
13872
  "响应式状态引擎提供了 *keyPurgeFilter*, *keyPurgeFreqInSecond* 两个参数，用来清理不再需要的分组数据。",
13627
13873
  "",
13628
13874
  "每次数据注入时，系统会依次根据以下条件决定是否触发数据清理：",
13629
13875
  "",
13630
- "\\(1) 检测本次数据注入与上一次数据注入的时间间隔是否大于等于 keyPurgeFreqInSecond（第一次数据注入时，检测注入时间和引擎创建时间的间隔）；",
13876
+ "\\(1) 检测本次数据注入与上一次数据注入的时间间隔是否大于等于 *keyPurgeFreqInSecond* （第一次数据注入时，检测注入时间和引擎创建时间的间隔）；",
13631
13877
  "",
13632
- "\\(2) 若满足上述条件，系统将根据 keyPurgeFilter 指定的条件，过滤出待清理的数据；",
13878
+ "\\(2) 若满足上述条件，系统将根据 *keyPurgeFilter* 指定的条件，过滤出待清理的数据；",
13633
13879
  "",
13634
13880
  "\\(3) 若待清理的数据所属的分组数大于等于所有分组数的 10%，则触发清理。",
13635
13881
  " ",
13636
13882
  "若需要查看清理前后的状态，可以通过调用 :doc:`../g/getStreamEngineStat` 函数查看 ReactiveStreamEngine 引擎状态的 numGroups 列，来对比响应式状态引擎清理前后分组数的变化。",
13637
13883
  "",
13638
- "`raftGroup` 是流数据高可用订阅端 raft 组的 ID (大于1的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。"
13639
- ]
13640
- }
13641
- ]
13642
- },
13643
- {
13644
- "title": "详情",
13645
- "type": "detail",
13646
- "children": [
13647
- {
13648
- "type": "text",
13649
- "value": [
13650
- "创建响应式状态引擎。",
13651
- "",
13652
- "返回一个表对象，向该表写入数据意味着这些数据进入响应式状态引擎进行计算。",
13884
+ ".. _raftGroup_rs:",
13653
13885
  "",
13654
- "通常与 :doc:`../s/subscribeTable` 函数一起使用。更多详情请参考教程 `DolphinDB 流聚合引擎 <https://gitee.com/dolphindb/Tutorials_CN/blob/master/%E6%B5%81%E8%AE%A1%E7%AE%97/stream_aggregator.md>`_。创建的响应式状态引擎可以跨会话调用。",
13655
- "",
13656
- "请注意：响应式状态引擎不支持多线程并发写入，必须配置 *subExecutorPooling* = false，使引擎读写任务串行执行。"
13886
+ "`raftGroup` 是流数据高可用订阅端 raft 组的 ID (大于1的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。",
13887
+ ""
13657
13888
  ]
13658
13889
  }
13659
13890
  ]
@@ -13754,33 +13985,55 @@
13754
13985
  ]
13755
13986
  },
13756
13987
  {
13757
- "title": "参数",
13758
- "type": "parameters",
13988
+ "title": "详情",
13989
+ "type": "detail",
13759
13990
  "children": [
13760
13991
  {
13761
13992
  "type": "text",
13762
13993
  "value": [
13763
- "由于会话窗口引擎的绝大多数参数与时间序列引擎重合，请参照 :doc:`createTimeSeriesEngine` 中参数介绍。这里仅介绍与时间序列引擎不同的以下参数：",
13994
+ "创建流数据会话窗口引擎。",
13764
13995
  "",
13765
- "`sessionGap` 必选参数，是一个正整数，表示会话窗口之间的时间间隔。此参数的时间单位由 *useSystemTime* 参数决定。",
13996
+ "``createSessionWindowEngine`` 的参数绝大多数与 ``createTimeSeriesEngine`` 一样，只有 :ref:`sessionGap <sessionGap_sw>` 和 :ref:`useSessionStartTime <useSessionStartTime_sw>` 是它独有的参数。*sessionGap* 决定了一个会话窗口何时结束，*useSessionStartTime* 决定了输出表时间列的时间为各个窗口的起始时刻还是结束时刻。",
13766
13997
  "",
13767
- "`useSessionStartTime`: 可选参数，是一个布尔值，默认值为 true，表示输出表中的时刻是否为数据窗口起始时刻，即每个窗口中第一条数据的时刻。若设置为 false，则表示输出表中的时刻为数据窗口结束时刻，即每个窗口中最后一条数据的时刻+ *sessionGap*。如果指定 *updateTime*，*useSessionStartTime* 必须为 true。",
13998
+ "更多流数据引擎的应用场景说明可以参考 :doc:`../../SeriesOfFunctions/streamingEngine`。"
13999
+ ]
14000
+ }
14001
+ ]
14002
+ },
14003
+ {
14004
+ "title": "计算规则",
14005
+ "children": [
14006
+ {
14007
+ "type": "text",
14008
+ "value": [
14009
+ "若某条数据之后，经过 :ref:`sessionGap <sessionGap_sw>` 指定的时间长度内，没有新数据到来，就进行一次窗口截断（以截断前最后一条数据的时间戳 + sessionGap 作为窗口的结束时刻）。窗口结束后新到来的一条数据将触发该窗口的计算。",
13768
14010
  "",
13769
- "`forceTriggerTime` 可选参数，非负整数，单位与 *timeColumn* 的时间精度一致。该参数仅在设置 *useSystemTime* = false 时起效。当系统收到最后一条数据后，经过 *forceTriggerTime* 时间，将强制触发未计算的窗口进行计算。请注意，若设置了 *keyColumn*，则各分组内进行上述操作。"
14011
+ "注意：若指定了 :ref:`keyColumn <keyColumn_ts>`，则按照分组分别进行窗口计算。"
13770
14012
  ]
13771
14013
  }
13772
14014
  ]
13773
14015
  },
13774
14016
  {
13775
- "title": "详情",
13776
- "type": "detail",
14017
+ "title": "参数",
14018
+ "type": "parameters",
13777
14019
  "children": [
13778
14020
  {
13779
14021
  "type": "text",
13780
14022
  "value": [
13781
- "创建流数据会话窗口引擎。",
14023
+ "由于会话窗口引擎的绝大多数参数与时间序列引擎重合，请参照 :doc:`createTimeSeriesEngine` 中参数介绍。这里仅介绍与时间序列引擎不同的参数：",
14024
+ "",
14025
+ ".. _sessionGap_sw:",
13782
14026
  "",
13783
- "该引擎与时间序列引擎极为相似。唯一的不同之处在于如何决定计算窗口。在时间序列引擎中，窗口以固定长度，按照固定频率产生。在会话窗口引擎中，若某条数据之后指定时间长度（*sessionGap*）内无数据进入，则该条数据为一个窗口的终点。之后第一条新数据为新窗口的起点。"
14027
+ "`sessionGap` 必选参数，正整数标量，是判断窗口结束的时间指标，表示某条数据到来后若等待该时间仍无更新的数据到来，就终止当前窗口。此参数的时间精度取决于 :ref:`useSystemTime <useSystemTime_ts>` 参数。",
14028
+ "",
14029
+ ".. _useSessionStartTime_sw:",
14030
+ "",
14031
+ "`useSessionStartTime`: 可选参数，布尔值，默认值为 true，表示输出表中的时刻是否为数据窗口起始时刻，即每个窗口中第一条数据的时间戳。若设置为 false，则表示输出表中的时刻为数据窗口结束时刻，即每个窗口中最后一条数据的时刻+ *sessionGap*。如果指定 :ref:`updateTime <updateTime_ts>`，*useSessionStartTime* 必须为 true。",
14032
+ "",
14033
+ ".. _forceTriggerTime_sw:",
14034
+ "",
14035
+ "`forceTriggerTime` 可选参数，非负整数，单位与 *timeColumn* 的时间精度一致。该参数仅在设置 *useSystemTime* = false 时起效。当系统收到最后一条数据后，经过 *forceTriggerTime* 时间，将强制触发未计算的窗口进行计算。请注意，若设置了 *keyColumn*，则各分组内进行上述操作。",
14036
+ ""
13784
14037
  ]
13785
14038
  }
13786
14039
  ]
@@ -14032,17 +14285,64 @@
14032
14285
  {
14033
14286
  "type": "text",
14034
14287
  "value": [
14035
- "创建流数据时间序列引擎。返回一个表对象，向该表写入数据意味着这些数据进入时间序列引擎，并在滑动窗口内进行聚合计算，窗口区间左闭右开。若指定了 *keyColumn*，则按照分组分别进行滑动窗口计算。",
14288
+ "创建流数据时间序列引擎，以实现基于时间的滑动窗口或滚动窗口进行实时计算。返回一个表对象，通过向该表对象写入，将数据注入时间序列引擎进行计算。 ",
14036
14289
  "",
14037
- "计算中，若指定了 *timeColumn*：",
14290
+ "时序引擎的聚合计算的算子分为增量计算和全量计算两种。增量计算算子不会保留历史数据，每次有数据进来就会进行增量计算；而全量计算算子（例如自定义的聚合函数，或未经优化的内置聚合函数，亦或是嵌套了状态函数的函数）会保留窗口内完整的数据，待触发输出时进行全量计算。",
14038
14291
  "",
14039
- "\\1. *keyColumn* 未指定，则 *timeColumn* 的时间必须递增；",
14292
+ "时序引擎对以下聚合计算算子进行了优化，实现了增量计算，显著提升了性能：corr, covar, first, last, max, med, min, percentile, quantile, std, var, sum, sum2, sum3, sum4, wavg, wsum, count, firstNot, ifirstNot, lastNot, ilastNot, imax, imin, nunique, prod, sem, mode, searchK。",
14040
14293
  "",
14041
- "\\2. *keyColumn* 指定，则 *timeColumn* 在每组内的时间必须递增。",
14294
+ "更多流数据引擎的应用场景说明可以参考 :doc:`../../SeriesOfFunctions/streamingEngine`。"
14295
+ ]
14296
+ }
14297
+ ]
14298
+ },
14299
+ {
14300
+ "title": "窗口划分",
14301
+ "children": [
14302
+ {
14303
+ "type": "text",
14304
+ "value": [
14305
+ "* 窗口边界规整：对起始窗口左边界进行规整。（详情请参考 :ref:`step <step_ts>` 和 :ref:`roundTime <roundTime_ts>` 的参数说明以及 :ref:`规整规则表 <alignment_ts>`）",
14306
+ "* 确定窗口：",
14307
+ "",
14308
+ " * :ref:`windowSize <windowSize_ts>` 确定窗口长度。",
14309
+ " * :ref:`closed <closed_ts>` 确定窗口左闭右开或左开右闭。",
14310
+ " * :ref:`step <step_ts>` 确定滑动的步长。",
14311
+ "",
14312
+ "其中，*windowSize* 与 *step* 的单位取决于 *useSystemTime* 参数。若 *useSystemTime* 为 true， *windowSize* 与 *step* 的单位是毫秒。若 *useSystemTime* = false，*windowSize* 与 *step* 的单位同 *timeColumn* 列的精度一致。",
14313
+ "",
14314
+ "* 窗口截取：:ref:`useSystemTime <useSystemTime_ts>` 参数决定了如何截取窗口，可以基于数据的时间列，亦可以基于数据注入系统的时间进行截取。"
14315
+ ]
14316
+ }
14317
+ ]
14318
+ },
14319
+ {
14320
+ "title": "计算规则",
14321
+ "children": [
14322
+ {
14323
+ "type": "text",
14324
+ "value": [
14325
+ "* 计算前提：若指定了 :ref:`timeColumn <timeColumn_ts>`，则 *timeColumn* 的时间必须递增；若同时指定了 :ref:`keyColumn <keyColumn_ts>`，则按照分组分别进行滑动窗口计算，*timeColumn* 在每组内的时间必须递增。否则，时间乱序的数据在计算中会被直接丢弃。",
14326
+ "* 触发规则：若指定了 *timeColumn*，当前窗口的计算将由该窗口结束后收到的第一条数据触发；若设置 *useSystemTime* = true，窗口结束后会自动触发计算。",
14327
+ "* 强制触发规则：对长时间未触发计算的窗口数据，可以通过设置 :ref:`updateTime <updateTime_ts>` 和 :ref:`forceTriggerTime <forceTriggerTime_ts>` 强制触发计算。具体规则请参考参数说明。",
14328
+ "* 窗口填充规则：未指定 :ref:`fill <fill_ts>` 或指定 *fill* = \"none\" 时，只会输出计算结果不为空的窗口；若指定了 *fill*，则会输出所有窗口，且根据 *fill* 规则对结果为空的窗口进行填充。输出表的时间列由参数 :ref:`useWindowStartTime <useWindowStartTime_ts>` 决定。",
14042
14329
  "",
14043
- "否则，时间乱序的数据在计算中会被直接丢弃。",
14330
+ "可以为不同因子指定不同长度的窗口：若 *metrics* 指定了多个元代码，则将 *windowSize* 指定为一个长度与元代码个数相同的向量。"
14331
+ ]
14332
+ }
14333
+ ]
14334
+ },
14335
+ {
14336
+ "title": "引擎的其它功能",
14337
+ "children": [
14338
+ {
14339
+ "type": "text",
14340
+ "value": [
14341
+ "* 支持数据/状态清理：清理引擎中堆积的数据和不再需要的状态信息。（详情请参考 :ref:`garbageSize <garbageSize_ts>` 和 :ref:`keyPurgeFreqInSec <keyPurgeFreqInSec_ts>` 的参数说明）",
14342
+ "* 快照机制：启用快照机制之后，系统若出现异常，可及时将流数据引擎恢复到最新的快照状态。（详情请参考 :ref:`snapshotDir <snapshotDir_ts>` 和 :ref:`snapshotIntervalInMsgCount <snapshotIntervalInMsgCount_ts>` 的参数说明）",
14343
+ "* 流数据引擎高可用：若要启用引擎高可用，需在订阅端 raft 组的 leader 节点创建引擎并通过 raftGroup 参数开启高可用。开启高可用后，当 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。（详情请参考 :ref:`raftGroup <raftGroup_ts>` 的参数说明）",
14044
14344
  "",
14045
- "该函数通常与 :doc:`../s/subscribeTable` 函数一起使用。更多详情请参考教程 `DolphinDB 流数据引擎 <https://gitee.com/dolphindb/Tutorials_CN/blob/master/%E6%B5%81%E8%AE%A1%E7%AE%97/stream_aggregator.md>`_。创建时间序列引擎可以跨会话调用。"
14345
+ ""
14046
14346
  ]
14047
14347
  }
14048
14348
  ]
@@ -14054,19 +14354,17 @@
14054
14354
  {
14055
14355
  "type": "text",
14056
14356
  "value": [
14057
- "`name` 必选参数，是一个字符串，表示时间序列引擎的名称，是其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
14058
- "",
14059
- "`useSystemTime` 可选参数，表示是否使用数据进入引擎时的系统时间作为时间列进行计算。",
14357
+ ".. _name_ts:",
14060
14358
  "",
14061
- "* 当 *useSystemTime* = true时，时间序列引擎会按照数据进入时间序列引擎的时刻（毫秒精度的本地系统时间，与数据中的时间列无关），每隔固定时间截取固定长度窗口的流数据进行计算。只要一个数据窗口中含有数据，数据窗口结束后就会自动进行计算。结果中的第一列为计算发生的时间戳，与数据中的时间无关。",
14359
+ "`name` 字符串标量，表示时间序列引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
14062
14360
  "",
14063
- "* 当 *useSystemTime* = false（缺省值）时，时间序列引擎根据流数据中的 *timeColumn* 列来截取数据窗口。一个数据窗口结束后的第一条新数据才会触发该数据窗口的计算。请注意，触发计算的数据并不会参与该次计算。",
14361
+ ".. _windowSize_ts:",
14064
14362
  "",
14065
- "例如，一个数据窗口从10:10:10到10:10:19。若 *useSystemTime* = true，则只要该窗口中至少有一条数据，该窗口的计算会在窗口结束后的10:10:20触发。若 *useSystemTime* = false，且10:10:19后的第一条数据为10:10:25，则该窗口的计算会在10:10:25触发。",
14363
+ "`windowSize` 正整数标量或向量，表示滑动窗口的长度。",
14066
14364
  "",
14067
- "`windowSize` 必选参数，是一个正整数标量或向量，指定数据窗口的长度。若为向量，其长度必须与 *metrics* 中元素个数一致。",
14365
+ ".. _step_ts:",
14068
14366
  "",
14069
- "`step` 必选参数，是一个正整数，表示计算窗口右边界的位移量。 *windowSize* 必须是 *step* 的整数倍，否则会抛出异常。",
14367
+ "`step` 正整数标量，表示滑动窗口移动的步长。 *windowSize* 必须是 *step* 的整数倍，否则会抛出异常。",
14070
14368
  "",
14071
14369
  "*windowSize* 和 *step* 的单位与 *useSystemTime* 有关：",
14072
14370
  "",
@@ -14074,7 +14372,170 @@
14074
14372
  "",
14075
14373
  "* 若 *useSystemTime* 为 false，则 *windowSize* 和 *step* 的单位与 *timeColumn* 的时间精度一致。",
14076
14374
  "",
14077
- "为了便于观察和对比计算结果，系统会对第一个数据窗口的起始时间进行规整，根据 *step* 参数、数据的时间精度，以及 *roundTime* 参数来确定整数类型的规整尺度 alignmentSize。当时间序列引擎使用分组计算时，所有分组的窗口均进行统一的规整。相同时刻的数据窗口在各组均有相同的边界。",
14375
+ ".. _metrics_ts:",
14376
+ "",
14377
+ "`metrics` 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。支持输入元组。",
14378
+ "",
14379
+ "* 计算指标可以是一个或多个系统内置或用户自定义的聚合函数（使用 defg 关键字定义），如 <[sum(volume), avg(price)]>；可以对聚合结果使用表达式，如 <[avg(price1)-avg(price2)]>；也可对列与列的计算结果进行聚合计算，如 <[std(price1-price2)]>。",
14380
+ "* *metrics* 内支持调用具有多个返回值的函数，例如 <func(price) as \\`col1\\`col2>（可不指定列名）。",
14381
+ "* 若 *windowSize* 为向量， *windowSize* 每个值可对应 *metrics* 中多个计算指标。例如，*windowSize* 为[10,20]时，metrics可为 (<[min(volume), max(volume)]>, <sum(volume)>)。 *metrics* 也可以嵌套输入元组向量。例如：[[<[min(volume), max(volume)]>, <sum(volume)>], [<avg(volume)>]]",
14382
+ "",
14383
+ ".. _dummyTable_ts:",
14384
+ "",
14385
+ "`dummyTable` 一个表对象，该表的唯一作用是为引擎提供订阅的流数据表的 schema，可以含有数据，亦可为空表。",
14386
+ "",
14387
+ ".. _outputTable_ts:",
14388
+ "",
14389
+ "`outputTable` 计算结果的输出表，可以是内存表或者分布式表。在使用 ``createTimeSeriesEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。时间序列引擎会将计算结果插入该表。",
14390
+ "",
14391
+ "输出表的各列的顺序为：时间列，分组列，计算结果列。",
14392
+ "",
14393
+ "其中：",
14394
+ "",
14395
+ "\\(1) 第一列必须是时间类型。",
14396
+ "",
14397
+ "* 若 *useSystemTime* = true，为 TIMESTAMP 类型；",
14398
+ "* 若 *useSystemTime* = false，数据类型与 *timeColumn* 列一致。",
14399
+ "* 若 *useWindowStartTime* = true，显示时间为数据窗口起始时间。",
14400
+ "* 若 *useWindowStartTime* = false，显示时间为数据窗口终止时间。",
14401
+ "",
14402
+ "\\(2) 如果 *keyColumn* 不为空，则其后几列和 *keyColumn* 设置的列及其顺序保持一致。",
14403
+ "",
14404
+ "\\(3) 最后为计算结果列，可为多列。",
14405
+ "",
14406
+ ".. _timeColumn_ts:",
14407
+ "",
14408
+ "`timeColumn` 可选参数，字符串标量或向量。当 *useSystemTime* = false 时，必须指定该参数。 该参数用于指定订阅的流数据表中时间列的名称。",
14409
+ "",
14410
+ "请注意，字符串向量，必须是 date 和 time 组成的向量，date 类型为 DATE，time 类型为 TIME, SECOND 或 NANOTIME。此时，输出表第一列的时间类型必须与 :doc:`concatDateTime(date, time) <../c/concatDateTime>` 的类型一致。",
14411
+ "",
14412
+ ".. _useSystemTime_ts:",
14413
+ "",
14414
+ "`useSystemTime` 可选参数，布尔值，表示是否使用数据注入引擎时的系统时间作为时间列进行计算。",
14415
+ "",
14416
+ "* 当 *useSystemTime* = true时，时间序列引擎会按照数据注入时间序列引擎的时刻（毫秒精度的本地系统时间，与数据中的时间列无关），每隔固定时间截取固定长度窗口的流数据进行计算。只要一个数据窗口中含有数据，数据窗口结束后就会自动进行计算。结果中的第一列为计算发生的时间戳，与数据中的时间无关。",
14417
+ "",
14418
+ "* 当 *useSystemTime* = false（缺省值）时，时间序列引擎根据流数据中的 *timeColumn* 列来截取数据窗口。一个数据窗口结束后的第一条新数据才会触发该数据窗口的计算。请注意，触发计算的数据并不会参与该次计算。",
14419
+ "",
14420
+ "例如，一个数据窗口从 10:10:10 到 10:10:19。若 *useSystemTime* = true，则只要该窗口中至少有一条数据，该窗口的计算会在窗口结束后的 10:10:20 触发。若 *useSystemTime* = false，且 10:10:19 后的第一条数据为 10:10:25，则该窗口的计算会在 10:10:25 触发。",
14421
+ "",
14422
+ ".. _keyColumn_ts:",
14423
+ "",
14424
+ "`keyColumn` 可选参数，字符串标量或向量，表示分组列名。若设置，则分组进行聚合计算，例如以每支股票为一组进行聚合计算。",
14425
+ "",
14426
+ ".. _garbageSize_ts:",
14427
+ "",
14428
+ "`garbageSize` 可选参数，正整数，默认值是 50,000（单位为行）。随着订阅的流数据不断积累，注入时间序列引擎，存放在内存中的数据会越来越多，这时需要清理不再需要的历史数据。当内存中历史数据行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。如果指定了 *keyColumn*，内存清理是各组内独立进行的。当一个组在内存中的历史数据记录数超出 *garbageSize* 时，会清理该组中本次计算中不需要的历史数据。",
14429
+ "",
14430
+ "注意：对于增量计算算子，系统会自动清理不再需要的历史数据。而对于全量计算算子，需要指定该参数来触发清理历史数据。",
14431
+ "",
14432
+ ".. _updateTime_ts:",
14433
+ "",
14434
+ "`updateTime` 可选参数，正整数，用于指定比 *step* 更短的计算的时间间隔。*step* 必须是 *updateTime* 的整数倍。要设置 *updateTime*， *useSystemTime* 必须设为 false。",
14435
+ "",
14436
+ "如果没有指定 *updateTime*，一个数据窗口结束前，不会发生对该数据窗口数据的计算。若一个窗口长时间未触发计算，可以指定 updateTime，分多次触发当前窗口数据的计算。",
14437
+ "",
14438
+ "计算触发的规则为：",
14439
+ " ",
14440
+ "\\(1) 将窗口划分为多个长度为 *updateTime* 的小窗口，各个小窗口之间没有重叠。每个小窗口的计算将由窗口结束后的第一条数据触发。该次计算包括当前窗口内所有未参与计算的数据。注意：触发计算的数据不参与本次计算。",
14441
+ "",
14442
+ "\\(2) 系统每经过 2 \\* *updateTime*（若 2 \\* *updateTime* 不足 2 秒，则设置为 2 秒）会检查是否有数据未参与计算，若仍有数据未参与计算，则会触发计算。本次计算包括触发计算时当前窗口内的所有数据。",
14443
+ "",
14444
+ "若分组计算，则每组内进行上述操作。",
14445
+ "",
14446
+ "请注意，小窗口内每次触发的计算结果的时间戳均为其所属滑动窗口的开始时间或结束时间 （由参数 *useWindowStartTime* 决定），而非小窗口内的时刻。",
14447
+ "",
14448
+ "指定 *updateTime* 后，建议使用键值内存表作为输出表。因为每次计算均会增加一条记录，输出表若使用普通内存表或流数据表，则会产生大量带有相同时间戳的结果。因为键值流数据表不可更新记录，输出表亦不推荐使用键值流数据表。",
14449
+ "",
14450
+ ".. _useWindowStartTime_ts:",
14451
+ "",
14452
+ "`useWindowStartTime` 可选参数，布尔值，表示输出表中的时间是否为数据窗口起始时间。默认值为 false，表示输出表中的时间为数据窗口起始时间 + *windowSize* 。若 *windowSize* 是向量， *useWindowStartTime* 必须为 false。",
14453
+ "",
14454
+ "",
14455
+ ".. _roundTime_ts:",
14456
+ "",
14457
+ "`roundTime` 可选参数，布尔值，表示若数据时间精度为毫秒或者秒且 *step* > 一分钟，如何对窗口边界值进行规整处理。默认值为 true，表示按照既定的多分钟规则（见以上表格）进行规整。若为 false，则按一分钟规则（见以上表格）进行窗口规整。",
14458
+ "",
14459
+ "若要开启快照机制 (snapshot)，必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。",
14460
+ "",
14461
+ ".. _snapshotDir_ts:",
14462
+ "",
14463
+ "`snapshotDir` 可选参数，字符串，表示保存引擎快照的文件目录。",
14464
+ "",
14465
+ "* 指定的目录必须存在，否则系统会提示异常。",
14466
+ "* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。",
14467
+ "* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。",
14468
+ "* 一个引擎的快照可能会使用三个文件名：",
14469
+ "",
14470
+ " * 临时存储快照信息：文件名为 <engineName>.tmp；",
14471
+ " * 快照生成并刷到磁盘：文件保存为 <engineName>.snapshot；",
14472
+ " * 存在同名快照：旧快照自动重命名为 <engineName>.old。",
14473
+ "",
14474
+ ".. _snapshotIntervalInMsgCount_ts:",
14475
+ "",
14476
+ "`snapshotIntervalInMsgCount` 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。",
14477
+ "",
14478
+ ".. _fill_ts:",
14479
+ "",
14480
+ "`fill` 可选参数，一个标量或向量，表示若（某个分组的）某个窗口无数据时，如何处理。可取以下值：",
14481
+ "",
14482
+ "* 'none': 不输出结果。",
14483
+ "* 'null': 输出结果为 NULL。",
14484
+ "* 'ffill': 输出上一个有数据的窗口的结果。",
14485
+ "* '具体数值'：该值的数据类型需要和对应的 *metrics* 计算结果的类型保持一致。",
14486
+ "",
14487
+ "*fill* 可以输入向量，长度与 *metrics* 元素个数保持一致，表示为每个 *metrics* 指定不同的 *fill* 方式。若为向量，向量中各项只能是 'null', 'ffill' 或一个数值，不能是 'none'。",
14488
+ "",
14489
+ ".. _forceTriggerTime_ts:",
14490
+ "",
14491
+ "`forceTriggerTime` 可选参数，是非负整数，单位与 *timeColumn* 的时间精度一致。用于强制触发各个分组未计算的窗口进行计算。强制触发计算及输出规则如下：",
14492
+ "",
14493
+ "\\1. 未被触发计算的窗口结束后（窗口结束时刻为 t），若收到了其他分组的数据（时间戳为 t1），且满足 t1-t ≥ *forceTriggerTime*，则该窗口将被触发计算。",
14494
+ "",
14495
+ "\\2. 窗口内不包含数据时，若未指定 *fill*，则不会输出结果；若指定了 *fill*，则会以 *fill* 指定的方式输出结果。",
14496
+ "",
14497
+ "注：要设置 *forceTriggerTime*， *useSystemTime* 必须设置为 false，且不能指定 *updateTime*。若强制触发计算后，仍有属于当前窗口的数据到达，则这些数据会被丢弃，建议不要设置太小的 *forceTriggerTime*。",
14498
+ "",
14499
+ "设置 *forceTriggerTime* 或 *updateTime* 时需注意以下几点：",
14500
+ "",
14501
+ "* 只设置 *updateTime*，计算发生后仍有属于当前窗口的数据到达时，当前窗口计算结果会再次更新；",
14502
+ "* 只设置 *forceTriggerTime*，则触发计算之后收到的数据会被丢弃。",
14503
+ "",
14504
+ ".. _raftGroup_ts:",
14505
+ "",
14506
+ "`raftGroup` 可选参数，表示流数据高可用订阅端 raft 组的 ID (大于1的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。",
14507
+ "",
14508
+ ".. _keyPurgeFreqInSec_ts:",
14509
+ "",
14510
+ "`keyPurgeFreqInSec` 正整数，表示清理窗口数据为空的分组的时间间隔，单位为秒。指定该参数后，若当前数据注入时间与上一次清理时间的间隔大于等于 *keyPurgeFreqInSec*，则触发对当前窗口数据为空的分组信息的清理。",
14511
+ "",
14512
+ ".. 若不指定该参数，则表示不对分组数据进行清理。",
14513
+ "",
14514
+ "注意：若需指定该参数，必须指定 *forceTriggerTime*，且不能指定 *fill*。",
14515
+ "",
14516
+ "若需要查看清理前后的状态，可以通过调用 :doc:`../g/getStreamEngineStat` 函数查看 TimeSeriesEngine 引擎状态的 numGroups 列，来对比响应式状态引擎清理前后分组数的变化。",
14517
+ "",
14518
+ ".. _closed_ts:",
14519
+ "",
14520
+ "`closed` 字符串，用于确定滑动窗口边界的开闭情况。可选值为 'left' 或 'right'，默认值为 'left'。",
14521
+ "",
14522
+ "* closed = 'left'： 窗口左闭右开。",
14523
+ "* closed = 'right'： 窗口左开右闭。",
14524
+ ""
14525
+ ]
14526
+ }
14527
+ ]
14528
+ },
14529
+ {
14530
+ "title": "规整规则",
14531
+ "children": [
14532
+ {
14533
+ "type": "text",
14534
+ "value": [
14535
+ ".. _alignment_ts:",
14536
+ "",
14537
+ "",
14538
+ "为了便于观察和对比计算结果，系统会对第一个数据窗口的起始时间进行规整，根据 :ref:`step <step_ts>` 参数、数据的时间精度，以及 :ref:`roundTime <roundTime_ts>` 参数来确定整数类型的规整尺度 alignmentSize。当时间序列引擎使用分组计算时，所有分组的窗口均进行统一的规整。相同时刻的数据窗口在各组均有相同的边界。",
14078
14539
  "",
14079
14540
  "* 若数据的时间精度为秒，如 DATETIME(yyyy-MM-dd HH:mm:ss) 与 SECOND(HH:mm:ss) 类型，alignmentSize 的 取值如下：",
14080
14541
  "",
@@ -14194,120 +14655,7 @@
14194
14655
  " >30s 1min",
14195
14656
  " ============== =================",
14196
14657
  "",
14197
- "假设第一条数据的时间为 x, 那么根据其类型，第一个数据窗口的左边界的计算规则为：timeType_cast(x/alignmentSize \\* alignmentSize + step - windowSize)。其中，timeType_cast 表示依据时间精度，需要强制转换的时间类型；'/' 表示整除。例如，第一条数据的时间为 2018.10.08T01:01:01.365，windowSize 为 120000，step 为 60000，那么 alignmentSize 为 60000，第一个数据窗口的左边界为 timestamp(2018.10.08T01:01:01.365/60000*60000+ 60000-120000)，即 2018.10.08T01:00:00.000。 ",
14198
- "",
14199
- "`metrics` 必选参数，以元代码的格式表示计算指标。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。支持输入元组。",
14200
- "",
14201
- "* 计算指标可以是一个或多个系统内置或用户自定义的聚合函数（使用 defg 关键字定义），如 <[sum(volume), avg(price)]>；可以对聚合结果使用表达式，如 <[avg(price1)-avg(price2)]>；也可对列与列的计算结果进行聚合计算，如 <[std(price1-price2)]>。",
14202
- "* *metrics* 内支持调用具有多个返回值的函数，例如 <func(price) as \\`col1\\`col2>（可不指定列名）。",
14203
- "* 若 *windowSize* 为向量， *windowSize* 每个值可对应 *metrics* 中多个计算指标。例如，*windowSize* 为[10,20]时，metrics可为 (<[min(volume), max(volume)]>, <sum(volume)>)。 *metrics* 也可以嵌套输入元组向量。例如：[[<[min(volume), max(volume)]>, <sum(volume)>], [<avg(volume)>]]",
14204
- "",
14205
- "DolphinDB 对在时间序列引擎中某些聚合函数的实现进行了优化，实现增量计算，显著提升性能。已优化的聚合函数包括：corr, covar, first, last, max, med, min, percentile, quantile, std, var, sum, sum2, sum3, sum4, wavg, wsum, count, firstNot, ifirstNot, lastNot, ilastNot, imax, imin, nunique, prod, sem, mode, searchK。",
14206
- "",
14207
- "`dummyTable` 是一个表对象，该表的唯一作用是为引擎提供订阅的流数据表的 schema，可以含有数据，亦可为空表。",
14208
- "",
14209
- "`outputTable` 必选参数，为计算结果的输出表，可以是内存表或者分布式表。在使用 ``createTimeSeriesEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。时间序列引擎会将计算结果插入该表。",
14210
- "",
14211
- "输出表的各列的顺序为：时间列，分组列，计算结果列。",
14212
- "",
14213
- "其中：",
14214
- "",
14215
- "\\(1) 第一列必须是时间类型。",
14216
- "",
14217
- "* 若 *useSystemTime* = true，为 TIMESTAMP 类型；",
14218
- "* 若 *useSystemTime* = false，数据类型与 *timeColumn* 列一致。",
14219
- "* 若 *useWindowStartTime* = true，显示时间为数据窗口起始时间。",
14220
- "* 若 *useWindowStartTime* = false，显示时间为数据窗口终止时间。",
14221
- "",
14222
- "\\(2) 如果 *keyColumn* 不为空，则其后几列和 *keyColumn* 设置的列及其顺序保持一致。",
14223
- "",
14224
- "\\(3) 最后为计算结果列，可为多列。",
14225
- "",
14226
- "`timeColumn` 可选参数，是字符串标量或向量，当 *useSystemTime* = false 时，必须指定该参数。 该参数用于指定订阅的流数据表中时间列的名称。",
14227
- "",
14228
- "请注意，字符串向量，必须是 date 和 time 组成的向量，date 类型为 DATE，time 类型为 TIME, SECOND 或 NANOTIME。此时，输出表第一列的时间类型必须与 :doc:`concatDateTime(date, time) <../c/concatDateTime>` 的类型一致。",
14229
- "",
14230
- "`keyColumn` 可选参数，是字符串标量或向量，表示分组列名。若设置，则分组进行聚合计算，例如以每支股票为一组进行聚合计算。",
14231
- "",
14232
- "`garbageSize` 可选参数，是正整数，默认值是50,000（单位为行）。当 *metrics* 中使用了自定义聚合函数，时间序列引擎会保留历史数据。随着订阅的流数据不断积累，进入时间序列引擎，存放在内存中的数据会越来越多，这时需要清理不再需要的历史数据。当内存中历史数据行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。如果指定了 *keyColumn*，内存清理是各组内独立进行的。当一个组在内存中的历史数据记录数超出 *garbageSize* 时，会清理该组中本次计算中不需要的历史数据。",
14233
- "",
14234
- "`updateTime` 可选参数，是正整数，可定义比 *step* 更短的计算的时间间隔。*step* 必须是 *updateTime* 的整数倍。要设置 *updateTime*， *useSystemTime* 必须设为 false。",
14235
- "",
14236
- "如果没有指定 *updateTime*，一个数据窗口结束前，不会发生对该数据窗口数据的计算。若要求在当前窗口结束前对当前窗口数据进行计算，可指定 *updateTime*。",
14237
- "",
14238
- "如果指定了 *updateTime*，当前窗口内可能会发生多次计算。计算触发的规则为：",
14239
- "",
14240
- "\\(1) 将当前窗口分为 *windowSize* / *updateTime* 个小窗口，每个小窗口长度为 *updateTime*。一个小窗口结束后，若有一条新数据到达，且在此之前当前窗口内有未参加计算的的数据，会触发一次计算。请注意，该次计算不包括这条新数据。",
14241
- "",
14242
- "\\(2) 一条数据到达时间序列引擎之后经过 2 \\* updateTime（若 2 \\* updateTime不足 2 秒，则设置为 2 秒），若其仍未参与计算，会触发一次计算。该次计算包括当时当前窗口内的所有数据。 ",
14243
- "",
14244
- "若分组计算，则每组内进行上述操作。",
14245
- "",
14246
- "请注意，当前窗口内每次计算结果的时间戳均为当前数据窗口开始时间或开始时间 + *windowSize* （由参数 *useWindowStartTime* 决定），而非当前窗口内的时刻。",
14247
- "",
14248
- "指定 *updateTime* 后，建议使用键值内存表作为输出表。因为每次计算均会增加一条记录，输出表若使用普通内存表或流数据表，则会产生大量带有相同时间戳的结果。因为键值流数据表不可更新记录，输出表亦不推荐使用键值流数据表。",
14249
- "",
14250
- "`useWindowStartTime` 可选参数，是一个布尔值，表示输出表中的时间是否为数据窗口起始时间。默认值为 false，表示输出表中的时间为数据窗口起始时间 + *windowSize* 。若 *windowSize* 是向量， *useWindowStartTime* 必须为 false。",
14251
- "",
14252
- "`roundTime` 可选参数，是一个布尔值，表示若数据时间精度为毫秒或者秒且 *step* > 一分钟，如何对窗口边界值进行规整处理。默认值为 true，表示按照既定的多分钟规则（见以上表格）进行规整。若为 false，则按一分钟规则（见以上表格）进行窗口规整。",
14253
- "",
14254
- "若要开启快照机制 (snapshot)，必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。",
14255
- "",
14256
- "启用快照机制之后，系统若出现异常，可及时将流数据引擎恢复到最新的快照状态。",
14257
- "",
14258
- "`snapshotDir` 可选参数，字符串，表示保存引擎快照的文件目录。",
14259
- "",
14260
- "* 指定的目录必须存在，否则系统会提示异常。",
14261
- "* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。",
14262
- "* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。",
14263
- "* 一个引擎的快照可能会使用三个文件名：",
14264
- "",
14265
- " * 临时存储快照信息：文件名为 <engineName>.tmp；",
14266
- " * 快照生成并刷到磁盘：文件保存为 <engineName>.snapshot；",
14267
- " * 存在同名快照：旧快照自动重命名为 <engineName>.old。",
14268
- "",
14269
- "`snapshotIntervalInMsgCount` 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。",
14270
- "",
14271
- "`fill` 可选参数，是一个标量或向量，表示若（某个分组的）某个窗口无数据时，如何处理。可取以下值：",
14272
- "",
14273
- "* 'none': 不输出结果。",
14274
- "* 'null': 输出结果为 NULL。",
14275
- "* 'ffill': 输出上一个有数据的窗口的结果。",
14276
- "* '具体数值'：该值的数据类型需要和对应的 *metrics* 计算结果的类型保持一致。",
14277
- "",
14278
- "*fill* 可以输入向量，为每个 *metrics* 指定不同的 *fill* 方式。其中，向量中各项只能是 'null', 'ffill' 或一个数值，不能是 'none'。",
14279
- "",
14280
- "`forceTriggerTime` 可选参数，是非负整数，单位与 *timeColumn* 的时间精度一致。用于强制触发各个分组未计算的窗口进行计算。强制触发计算及输出规则如下：",
14281
- "",
14282
- "\\1. 未被触发计算的窗口结束后（窗口结束时刻为 t），若收到了其他分组的数据（时间戳为 t1），且满足 t1-t ≥ *forceTriggerTime*，则该窗口将被触发计算。",
14283
- "",
14284
- "\\2. 窗口内不包含数据时，若未指定 *fill*，则不会输出结果；若指定了 *fill*，则会以 *fill* 指定的方式输出结果。",
14285
- "",
14286
- "注：要设置 *forceTriggerTime*， *useSystemTime* 必须设置为 false，且不能指定 *updateTime*。若强制触发计算后，仍有属于当前窗口的数据到达，则这些数据会被丢弃，建议不要设置太小的 *forceTriggerTime*。",
14287
- "",
14288
- "设置 *forceTriggerTime* 或 *updateTime* 时需注意以下几点：",
14289
- "",
14290
- "* 只设置 *updateTime*，计算发生后仍有属于当前窗口的数据到达时，当前窗口计算结果会再次更新；只设置 *forceTriggerTime*，则触发计算之后收到的数据会被丢弃。",
14291
- "",
14292
- "`raftGroup` 是流数据高可用订阅端 raft 组的 ID (大于1的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。",
14293
- "",
14294
- "`keyPurgeFreqInSec` 正整数，表示清理窗口数据为空的分组的时间间隔，单位为秒。指定该参数后，若当前数据注入时间与上一次清理时间的间隔大于等于 *keyPurgeFreqInSec*，便会对当前窗口数据为空的分组进行清理。",
14295
- "",
14296
- ".. 若不指定该参数，则表示不对分组数据进行清理。",
14297
- "",
14298
- "注意：若需指定该参数，必须指定 *forceTriggerTime*，且不能指定 *fill*。",
14299
- "",
14300
- "若需要查看清理前后的状态，可以通过调用 :doc:`../g/getStreamEngineStat` 函数查看 TimeSeriesEngine 引擎状态的 numGroups 列，来对比响应式状态引擎清理前后分组数的变化。",
14301
- "",
14302
- "`closed` 字符串，用于确定滑动窗口边界的开闭情况。可选值为 'left' 或 'right'，默认值为 'left'。",
14303
- "",
14304
- "* closed = 'left'： 窗口左闭右开",
14305
- "* closed = 'right'： 窗口左开右闭",
14306
- "",
14307
- ".. `closed` 字符串，表示对滑动窗口进行计算时需要排除的点，可选值为 'left' 或 'right'，默认值为 'left'。",
14308
- "",
14309
- ".. * closed = 'left'： 计算中将排除滑动窗口中的最后一个点",
14310
- ".. * closed = 'right'： 计算中将排除滑动窗口中的第一个点",
14658
+ "假设第一条数据的时间为 x, 那么根据其类型，第一个数据窗口的左边界的计算规则为：``timeType_cast(x/alignmentSize \\* alignmentSize + step - windowSize)``。其中，timeType_cast 表示依据时间精度，需要强制转换的时间类型；'/' 表示整除。例如，第一条数据的时间为 2018.10.08T01:01:01.365，windowSize 为 120000，step 为 60000，那么 alignmentSize 为 60000，第一个数据窗口的左边界为 ``timestamp(2018.10.08T01:01:01.365/60000*60000+ 60000-120000)``，即 2018.10.08T01:00:00.000。 ",
14311
14659
  ""
14312
14660
  ]
14313
14661
  }
@@ -14653,6 +15001,26 @@
14653
15001
  }
14654
15002
  ]
14655
15003
  },
15004
+ {
15005
+ "title": "详情",
15006
+ "type": "detail",
15007
+ "children": [
15008
+ {
15009
+ "type": "text",
15010
+ "value": [
15011
+ "创建流数据 window join 引擎。返回一个左、右两表实时 :doc:`/SQLStatements/TableJoiners/windowjoin` 后的表对象。与 window join 仅支持聚合计算不同，window join 引擎亦支持非聚合计算。",
15012
+ "",
15013
+ "注入 window join 引擎左、右两表的数据，根据 :ref:`matchingColumn <matchingColumnWJ>` 分组。在各分组内，左表的每条记录，都会同右表中一个时间区间（即窗口）内的数据进行连接，并根据指定的 :ref:`metrics <metricsWJ>` 计算窗口内的数据并输出。例如，左表某条记录的时间戳为 t，则右表时间戳属于[t+window 左边界, t+window 右边界]的数据将与左表连接并计算输出。",
15014
+ "",
15015
+ "matchingColumnWJ：",
15016
+ "",
15017
+ "\\1. 当前窗口数据的计算将由该窗口结束后的第一条数据触发。触发计算的数据不参与该窗口的计算。",
15018
+ "",
15019
+ "\\2. 指定 :ref:`maxDelayedTime <maxDelayedTimeWJ>` 后，对于某个未发生计算的窗口右，若其窗口边界 + *maxDelayedTime* < 右表最新收到的任意一个分组数据的时间戳，则该窗口的计算将被新收到的这条数据触发。"
15020
+ ]
15021
+ }
15022
+ ]
15023
+ },
14656
15024
  {
14657
15025
  "title": "参数",
14658
15026
  "type": "parameters",
@@ -14660,11 +15028,11 @@
14660
15028
  {
14661
15029
  "type": "text",
14662
15030
  "value": [
14663
- "`name` 必选参数，是一个字符串，表示流数据 window join 引擎的名称。",
15031
+ "`name` 必选参数，表示 window join 引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
14664
15032
  "",
14665
- "`leftTable` 和 `rightTable` 是表对象。可以不包含数据，但结构必须与订阅的流数据表相同。",
15033
+ "`leftTable` 和 `rightTable` 表对象。可以不包含数据，但结构必须与订阅的流数据表相同。",
14666
15034
  "",
14667
- "`outputTable` 必选参数，为计算结果的输出表。在使用 ``createWindowJoinEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。window join 引擎会将计算结果插入该表。",
15035
+ "`outputTable` 必选参数，为计算结果的输出表。window join 引擎会将计算结果插入该表。",
14668
15036
  "",
14669
15037
  "输出表各列的顺序为：时间列，连接列，计算结果列：",
14670
15038
  "",
@@ -14679,15 +15047,19 @@
14679
15047
  "",
14680
15048
  "`window` 必选参数，表示滑动窗口区间的整型或 DURATION 数据对，其中左右边界都包含在内。",
14681
15049
  "",
15050
+ ".. _metricsWJ:",
15051
+ "",
14682
15052
  "`metrics` 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
14683
15053
  "",
14684
15054
  "* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数，但不能是聚合函数。",
14685
15055
  "* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 <func(price) as \\`col1\\`col2>。",
14686
15056
  "",
14687
- "请注意，若 *metrics* 中指定了时间列或者连接列，需要在连接列或时间列前加上表名来指定该列所属的表，若不加表名，则默认取左表的列。例如：*matchingColumn* = \\`sym, *timeColumn* = \\`timestamp，则 *metrics* = <[rightTable.sym, rightTable.timestamp, price, val, price*val]> 指定 *metrics* 中输出右表的 sym 列和 timestamp 列。",
15057
+ "若在 *metrics* 指定了 *leftTable* 和 *rightTable* 中具有相同名称的列，默认取左表的列，可以通过 \"tableName.colName\" 指定该列来自哪个表。",
14688
15058
  "",
14689
15059
  "当以下函数只计算 *rightTable* 中的数据列时，window join 引擎对它们进行了优化：sum, sum2, avg, std, var, corr, covar, wavg, wsum, beta, max, min, last, first, med, percentile。",
14690
15060
  "",
15061
+ ".. _matchingColumnWJ:",
15062
+ "",
14691
15063
  "`matchingColumn` 表示连接列的字符串标量/向量/tuple，支持 Integral, Temproal 或 Literal（UUID 除外）类型。",
14692
15064
  "",
14693
15065
  "*matchingColumn* 指定规则：",
@@ -14700,33 +15072,13 @@
14700
15072
  "",
14701
15073
  "`useSystemTime` 可选参数，表示 *outputTable* 中第一列（时间列）为系统当前时间（*useSystemTime* = true）或左表的时间列（*useSystemTime* = false）。",
14702
15074
  "",
14703
- "`garbageSize` 可选参数，是正整数，默认值是5,000（单位为行）。随着订阅的流数据不断积累进入 window join 引擎，存放在内存中的数据会越来越多，这时需要清理不再需要的历史数据。当内存中历史数据行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。",
14704
- "",
14705
- "`maxDelayedTime` 可选参数，是正整数,默认值为3，单位为秒。通过设置该参数，帮助触发引擎中长时间未输出的分组数据进行计算。"
14706
- ]
14707
- }
14708
- ]
14709
- },
14710
- {
14711
- "title": "详情",
14712
- "type": "detail",
14713
- "children": [
14714
- {
14715
- "type": "text",
14716
- "value": [
14717
- "创建流数据 window join 引擎。返回一个左、右两表 :doc:`/SQLStatements/TableJoiners/windowjoin` 后的表对象。通常与 :doc:`../s/subscribeTable` 函数一起使用。",
14718
- "",
14719
- "请注意，向该引擎注入数据，仅可使用 :doc:`../a/appendForJoin`、:doc:`/FunctionsandCommands/FunctionReferences/g/getLeftStream` 或 :doc:`/FunctionsandCommands/FunctionReferences/g/getRightStream` 函数。",
14720
- "",
14721
- "该引擎的计算规则如下：",
14722
- "",
14723
- "\\1. 在 *matchingColumn* 对应的分组数据中，根据左表的某一行的时间戳，确定右表的一个时间窗口。当前窗口数据的计算将由该窗口结束后的第一条数据触发。",
14724
- "",
14725
- "\\2. 指定 *maxDelayedTime* 后，若当前窗口为该分组的最后一个窗口，当右表存在最新的时间戳 t1，使得 t1 > t + *window* 右边界 + *maxDelayedTime* 时，会触发计算当前窗口数据的计算。",
15075
+ "`garbageSize` 可选参数，是正整数，默认值是5,000（单位为行）。随着订阅的流数据不断积累进入 window join 引擎，存放在内存中的数据会越来越多，这时需要清理不再需要的历史数据。当左/右两表各个分组内的数据行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。",
14726
15076
  "",
14727
- "请注意，向该引擎注入数据时，仅可使用 :doc:`../a/appendForJoin` 函数。",
15077
+ ".. _maxDelayedTimeWJ:",
14728
15078
  "",
14729
- "从 1.30.17, 2.00.5 版本开始，DolphinDB 支持其他流数据引擎通过 :doc:`/FunctionsandCommands/FunctionReferences/g/getLeftStream` 及 :doc:`/FunctionsandCommands/FunctionReferences/g/getRightStream`，为流数据 join 引擎注入数据，以实现引擎间的级联。"
15079
+ "`maxDelayedTime` 可选参数，是正整数,默认值为3，单位为秒。通过设置该参数，帮助触发引擎中长时间未输出的分组数据进行计算。",
15080
+ "即若右表中最新到来的数据时间戳 - 未计算的分组数据窗口的右边界 > maxDelayedTime，则这条数据会触发满足条件的分组数据窗口计算输出。",
15081
+ "请注意，指定该参数时，必须同时指定 timeColumn，且单位需和 timeColumn 精度一致。"
14730
15082
  ]
14731
15083
  }
14732
15084
  ]
@@ -17650,7 +18002,9 @@
17650
18002
  "value": [
17651
18003
  "创建一个数据库句柄。",
17652
18004
  "",
17653
- "我们需要指定 *partitionType* 和 *partitionScheme* 创建新的分布式数据库。当我们重新打开已有的分布式数据库，只需要指定 *directory*。我们不能用不同的 *partitionType* 或 *partitionScheme* 覆盖已有的分布式数据库。"
18005
+ "我们需要指定 *partitionType* 和 *partitionScheme* 创建新的分布式数据库。当我们重新打开已有的分布式数据库，只需要指定 *directory*。我们不能用不同的 *partitionType* 或 *partitionScheme* 覆盖已有的分布式数据库。",
18006
+ "",
18007
+ "请注意：当 *directory* 为本地磁盘路径时，将创建本地磁盘数据库。磁盘数据库仅应用于备份数据和本地计算的场景，其相较于分布式表，在使用上具有一定局限，例如不能进行权限控制等。"
17654
18008
  ]
17655
18009
  }
17656
18010
  ]
@@ -17662,7 +18016,7 @@
17662
18016
  {
17663
18017
  "type": "text",
17664
18018
  "value": [
17665
- "\\1.创建没有分区的数据库",
18019
+ "\\1.创建没有分区的磁盘数据库。",
17666
18020
  ""
17667
18021
  ]
17668
18022
  },
@@ -21726,7 +22080,7 @@
21726
22080
  {
21727
22081
  "type": "text",
21728
22082
  "value": [
21729
- "删除本地磁盘数据库：",
22083
+ "删除分布式数据库：",
21730
22084
  ""
21731
22085
  ]
21732
22086
  },
@@ -21740,20 +22094,20 @@
21740
22094
  " $ dates=2017.08.07..2017.08.11",
21741
22095
  " $ date=rand(dates, n)",
21742
22096
  " $ x=rand(10.0, n)",
21743
- " $ t=table(ID, date, x)",
22097
+ " $ t=table(ID, date, x);",
21744
22098
  " $ saveText(t, \"C:/DolphinDB/Data/t.txt\");",
21745
22099
  "",
21746
- " $ db = database(\"C:/DolphinDB/Data/rangedb\", RANGE, 0 5 10)",
21747
- " $ pt = loadTextEx(db, `pt, `ID, \"C:/DolphinDB/Data/t.txt\");",
22100
+ " $ db = database(\"dfs://valueDB\", VALUE, 2017.08.07..2017.08.11)",
22101
+ " $ pt = loadTextEx(db, `pt1, `date, \"C:/DolphinDB/Data/t.txt\");",
21748
22102
  "",
21749
- " $ dropDatabase(\"C:/DolphinDB/Data/rangedb\");",
22103
+ " $ dropDatabase(\"dfs://valueDB\")",
21750
22104
  ""
21751
22105
  ]
21752
22106
  },
21753
22107
  {
21754
22108
  "type": "text",
21755
22109
  "value": [
21756
- "删除分布式数据库：",
22110
+ "删除本地磁盘数据库：",
21757
22111
  ""
21758
22112
  ]
21759
22113
  },
@@ -21767,13 +22121,13 @@
21767
22121
  " $ dates=2017.08.07..2017.08.11",
21768
22122
  " $ date=rand(dates, n)",
21769
22123
  " $ x=rand(10.0, n)",
21770
- " $ t=table(ID, date, x);",
22124
+ " $ t=table(ID, date, x)",
21771
22125
  " $ saveText(t, \"C:/DolphinDB/Data/t.txt\");",
21772
22126
  "",
21773
- " $ db = database(\"dfs://valueDB\", VALUE, 2017.08.07..2017.08.11)",
21774
- " $ pt = loadTextEx(db, `pt1, `date, \"C:/DolphinDB/Data/t.txt\");",
22127
+ " $ db = database(\"C:/DolphinDB/Data/rangedb\", RANGE, 0 5 10)",
22128
+ " $ pt = loadTextEx(db, `pt, `ID, \"C:/DolphinDB/Data/t.txt\");",
21775
22129
  "",
21776
- " $ dropDatabase(\"dfs://valueDB\")",
22130
+ " $ dropDatabase(\"C:/DolphinDB/Data/rangedb\");",
21777
22131
  ""
21778
22132
  ]
21779
22133
  },
@@ -22510,7 +22864,7 @@
22510
22864
  {
22511
22865
  "type": "text",
22512
22866
  "value": [
22513
- "`dnHandle` 是数据库句柄。",
22867
+ "`dbHandle` 是数据库句柄。",
22514
22868
  "",
22515
22869
  "`tableName` 是一个字符串，表示表名。"
22516
22870
  ]
@@ -25303,9 +25657,9 @@
25303
25657
  "type": "example",
25304
25658
  "children": [
25305
25659
  {
25306
- "type": "code",
25307
- "language": "console",
25660
+ "type": "text",
25308
25661
  "value": [
25662
+ ".. .. code:: console",
25309
25663
  "",
25310
25664
  " $ n=1000000",
25311
25665
  " $ ID=rand(10, n)",
@@ -25314,7 +25668,7 @@
25314
25668
  " $ x=rand(10.0, n)",
25315
25669
  " $ t=table(ID, date, x)",
25316
25670
  "",
25317
- " $ db = database(\"dfs://valueDB\", VALUE, 2017.08.07..2017.08.11)",
25671
+ " $ db = database(\"C:/DolphinDB/Data/valueDB\", VALUE, 2017.08.07..2017.08.11)",
25318
25672
  " $ pt = db.createPartitionedTable(t, `pt, `date);",
25319
25673
  " $ pt.append!(t);",
25320
25674
  "",
@@ -25323,12 +25677,7 @@
25323
25677
  "",
25324
25678
  " $ existsDatabase(\"C:/DolphinDB/Data/valueDB/20170807\");",
25325
25679
  " 0",
25326
- ""
25327
- ]
25328
- },
25329
- {
25330
- "type": "text",
25331
- "value": [
25680
+ "",
25332
25681
  "检查分布式数据库是否存在：",
25333
25682
  ""
25334
25683
  ]
@@ -25398,7 +25747,7 @@
25398
25747
  "* 若分区粒度为数据库级（ :doc:`../d/database` : *chunkGranularity* = 'DATABASE'），可以不指定该参数。",
25399
25748
  "* 若分区粒度为表级（ :doc:`../d/database` : *chunkGranularity* = 'TABLE'）",
25400
25749
  "",
25401
- " * *path* 指定的路径包含了物理索引（通过函数 :doc:`../l/listTables` 获取），可以不指定该参数。",
25750
+ " * 若 *path* 指定的路径包含了物理索引（通过函数 :doc:`../l/listTables` 获取），可以不指定该参数。",
25402
25751
  " * 否则，必须指定该参数。"
25403
25752
  ]
25404
25753
  }
@@ -25618,9 +25967,9 @@
25618
25967
  "type": "example",
25619
25968
  "children": [
25620
25969
  {
25621
- "type": "code",
25622
- "language": "console",
25970
+ "type": "text",
25623
25971
  "value": [
25972
+ ".. .. code:: console",
25624
25973
  "",
25625
25974
  " $ n=1000000",
25626
25975
  " $ ID=rand(10, n)",
@@ -25629,7 +25978,7 @@
25629
25978
  " $ x=rand(10.0, n)",
25630
25979
  " $ t=table(ID, date, x)",
25631
25980
  "",
25632
- " $ db = database(\"dfs://valueDB\", VALUE, 2017.08.07..2017.08.11)",
25981
+ " $ db = database(\"C:/DolphinDB/Data/valueDB\", VALUE, 2017.08.07..2017.08.11)",
25633
25982
  " $ pt = db.createPartitionedTable(t, `pt, `date);",
25634
25983
  " $ pt.append!(t);",
25635
25984
  "",
@@ -25641,12 +25990,7 @@
25641
25990
  "",
25642
25991
  " $ existsTable(\"C:/DolphinDB/Data\", `pt);",
25643
25992
  " 0",
25644
- ""
25645
- ]
25646
- },
25647
- {
25648
- "type": "text",
25649
- "value": [
25993
+ "",
25650
25994
  "检查分区是否在分布式文件系统中（以下脚本需要在集群的数据节点/计算节点中执行）：",
25651
25995
  ""
25652
25996
  ]
@@ -26007,7 +26351,7 @@
26007
26351
  {
26008
26352
  "type": "text",
26009
26353
  "value": [
26010
- "`filename` 是使用绝对路径的输入数据文件名z。",
26354
+ "`filename` 是使用绝对路径的输入数据文件名。",
26011
26355
  "",
26012
26356
  "`delimiter` 是表中列的分隔符。默认为逗号。",
26013
26357
  "",
@@ -28936,6 +29280,64 @@
28936
29280
  }
28937
29281
  ]
28938
29282
  },
29283
+ "getAuthenticatedUsers": {
29284
+ "title": "getAuthenticatedUsers",
29285
+ "type": "function",
29286
+ "children": [
29287
+ {
29288
+ "title": "语法",
29289
+ "type": "grammer",
29290
+ "children": [
29291
+ {
29292
+ "type": "text",
29293
+ "value": [
29294
+ "getAuthenticatedUsers()"
29295
+ ]
29296
+ }
29297
+ ]
29298
+ },
29299
+ {
29300
+ "title": "参数",
29301
+ "type": "parameters",
29302
+ "children": [
29303
+ {
29304
+ "type": "text",
29305
+ "value": [
29306
+ "无",
29307
+ ""
29308
+ ]
29309
+ }
29310
+ ]
29311
+ },
29312
+ {
29313
+ "title": "详情",
29314
+ "type": "detail",
29315
+ "children": [
29316
+ {
29317
+ "type": "text",
29318
+ "value": [
29319
+ "获取所有节点已经登录的用户信息。返回一个向量，包含所有已登录用户的名称。"
29320
+ ]
29321
+ }
29322
+ ]
29323
+ },
29324
+ {
29325
+ "title": "例子",
29326
+ "type": "example",
29327
+ "children": [
29328
+ {
29329
+ "type": "code",
29330
+ "language": "console",
29331
+ "value": [
29332
+ "",
29333
+ " $ getAuthenticatedUsers()",
29334
+ " [\"admin\",\"a1\",\"a3\",\"a2\",\"a4\"] "
29335
+ ]
29336
+ }
29337
+ ]
29338
+ }
29339
+ ]
29340
+ },
28939
29341
  "getBackupList": {
28940
29342
  "title": "getBackupList",
28941
29343
  "type": "function",
@@ -29091,7 +29493,7 @@
29091
29493
  "language": "console",
29092
29494
  "value": [
29093
29495
  " ",
29094
- " $ getBackupMeta(\"/home/DolphinDB/backup\",\"dfs://valuedb\", \"/200001M/2\",\"pt\")",
29496
+ " $ getBackupMeta(\"/home/DolphinDB/backup\",\"dfs://valuedb\", \"/200001M\",\"pt\")",
29095
29497
  "",
29096
29498
  " schema->",
29097
29499
  " name typeString typeInt comment",
@@ -29491,13 +29893,13 @@
29491
29893
  " ",
29492
29894
  "* versionChain: 版本链",
29493
29895
  "",
29494
- "* state: chunk 状态。CONSTRUCTING：正在事务中； RECOVERING：正在 recovery 中；COMPLETE：已经处于事务终止状态；",
29896
+ "* state: chunk 状态。CONSTRUCTING：正在事务中； RECOVERING：正在 recovery 中；COMPLETE：已经处于事务终止状态",
29495
29897
  "",
29496
29898
  "* replicas: 副本的分布信息",
29497
29899
  "",
29498
29900
  "* replicaCount: 副本数",
29499
29901
  "",
29500
- "* permission: CHUNK 的权限。CHUNK 的权限分为 READ_ONLY 以及 READ_WRITE（默认权限）两类。正在进行迁移的分区，或存储在 s3 的分区权限均为 READ_ONLY。",
29902
+ "* permission: CHUNK 的权限。CHUNK 的权限分为 READ_ONLY 以及 READ_WRITE（默认权限）两类。正在进行迁移的分区，或存储在 s3 的分区权限均为 READ_ONLY",
29501
29903
  "",
29502
29904
  "对于 READ_ONLY 权限的分区：",
29503
29905
  "",
@@ -29715,11 +30117,11 @@
29715
30117
  "* memoryAlloc：系统已分配给当前节点的内存（单位：字节）。",
29716
30118
  "* cpuUsage：CPU 使用率。",
29717
30119
  "* avgLoad：CPU 平均负载。",
29718
- "* medLast10QueryTime：前 10 个完成的查询执行所耗费时间的中间值（单位：毫秒）。",
29719
- "* maxLast10QueryTime：前 10 个完成的查询执行所耗费时间的最大值（单位：毫秒）。",
29720
- "* medLast100QueryTime：前 100 个完成的查询执行所耗费时间的中间值（单位：毫秒）。",
29721
- "* maxLast100QueryTime：前100个完成的查询执行所耗费时间的最大值（单位：毫秒）。",
29722
- "* maxRunningQueryTime：当前正在执行的查询的耗费时间的最大值（单位：毫秒）。",
30120
+ "* medLast10QueryTime：前 10 个完成的查询执行所耗费时间的中间值（单位：纳秒）。",
30121
+ "* maxLast10QueryTime：前 10 个完成的查询执行所耗费时间的最大值（单位：纳秒）。",
30122
+ "* medLast100QueryTime：前 100 个完成的查询执行所耗费时间的中间值（单位：纳秒）。",
30123
+ "* maxLast100QueryTime：前100个完成的查询执行所耗费时间的最大值（单位：纳秒）。",
30124
+ "* maxRunningQueryTime：当前正在执行的查询的耗费时间的最大值（单位：纳秒）。",
29723
30125
  "* runningJobs：正在执行中的 Job 个数。",
29724
30126
  "* queuedJobs：队列中的 Job 个数。",
29725
30127
  "* runningTasks：正在执行中的 Task 个数。",
@@ -29737,8 +30139,8 @@
29737
30139
  "* lastMinuteNetworkSend：前一分钟网络发送字节数（单位：字节）。",
29738
30140
  "* lastMinuteNetworkRecv：前一分钟网络接收字节数 （单位：字节）。",
29739
30141
  "* publicName：若为控制节点，且配置了 publicName，则显示 publicName；否则显示控制节点所在服务器的 网卡地址。若为数据节点或代理节点，则显示数据节点或代理节点所在服务器的网卡地址。",
29740
- "* lastMsgLatency：前一批消息的延时（单位：毫秒）。",
29741
- "* cumMsgLatency：所有消息的平均延时（单位：毫秒）。",
30142
+ "* lastMsgLatency：流数据订阅节点最后收到的消息的延时（单位：毫秒）。",
30143
+ "* cumMsgLatency：流数据订阅节点所有已接收的消息的平均延时（单位：毫秒）。",
29742
30144
  "* isLeader：是否是 raft 组的 leader，该字段仅在配置了控制节点高可用时才生效。请注意，若 raft 组存在宕机的节点，则该节点的 isLeader 将返回空值。",
29743
30145
  ""
29744
30146
  ]
@@ -30499,7 +30901,15 @@
30499
30901
  "language": "console",
30500
30902
  "value": [
30501
30903
  " ",
30502
- " $ getDFSTablesByDatabase()"
30904
+ " $ getDFSTablesByDatabase(\"dfs://db\")",
30905
+ " [\"dfs://db1/dt\", \"dfs://db1/dt1\"]",
30906
+ ""
30907
+ ]
30908
+ },
30909
+ {
30910
+ "type": "text",
30911
+ "value": [
30912
+ ".. 相关函数：:doc:`getTables`"
30503
30913
  ]
30504
30914
  }
30505
30915
  ]
@@ -32109,7 +32519,36 @@
32109
32519
  {
32110
32520
  "type": "text",
32111
32521
  "value": [
32112
- "以字典的形式返回本地节点上的多个性能监控度量值。"
32522
+ "以字典的形式返回本地节点上的多个性能监控度量值。",
32523
+ "",
32524
+ "返回一个表对象，包含以下几列：",
32525
+ "",
32526
+ "* runningJobs：正在执行中的 Job 个数。",
32527
+ "* jobLoad：作业负载。",
32528
+ "* avgLoad：CPU 平均负载。",
32529
+ "* queuedJobs：队列中的 Job 个数。",
32530
+ "* lastMinuteNetworkSend：前一分钟网络发送字节数（单位：字节）。",
32531
+ "* lastMinuteNetworkRecv：前一分钟网络接收字节数 （单位：字节）。",
32532
+ "* lastMinuteReadVolume：前一分钟读磁盘容量（单位：字节）。",
32533
+ "* lastMinuteWriteVolume：前一分钟写磁盘容量（单位：字节）。",
32534
+ "* lastMsgLatency：前一批消息的延时（单位：毫秒）。",
32535
+ "* cumMsgLatency：所有消息的平均延时（单位：毫秒）。",
32536
+ "* maxLast10QueryTime：前 10 个完成的查询执行所耗费时间的最大值（单位：毫秒）。",
32537
+ "* maxLast100QueryTime：前100个完成的查询执行所耗费时间的最大值（单位：毫秒）。",
32538
+ "* medLast10QueryTime：前 10 个完成的查询执行所耗费时间的中间值（单位：毫秒）。",
32539
+ "* medLast100QueryTime：前 100 个完成的查询执行所耗费时间的中间值（单位：毫秒）。",
32540
+ "* maxRunningQueryTime：当前正在执行的查询的耗费时间的最大值（单位：毫秒）。",
32541
+ "* diskFreeSpaceRatio：磁盘可用空间占比。",
32542
+ "* diskReadRate：磁盘读速率（单位：字节/秒）。",
32543
+ "* diskWriteRate：磁盘写速率 （单位：字节/秒）。",
32544
+ "* diskFreeSpace：磁盘剩余空间（单位：字节）。",
32545
+ "* diskCapacity：磁盘容量（单位：字节）。",
32546
+ "* cpuUsage：CPU 使用率。",
32547
+ "* memoryAlloc：系统已分配给当前节点的内存（单位：字节）。",
32548
+ "* memoryUsed：节点的内存占用量（单位：字节）。",
32549
+ "* networkSendRate：网络发送速率（单位：字节/秒）。",
32550
+ "* networkRecvRate：网络接收速率（单位：字节/秒）。",
32551
+ ""
32113
32552
  ]
32114
32553
  }
32115
32554
  ]
@@ -32506,23 +32945,23 @@
32506
32945
  "",
32507
32946
  "返回一个表，包含以下列：",
32508
32947
  "",
32509
- "* TaskId: 表示恢复副本任务的 ID。",
32510
- "* TaskType: 恢复任务的类型，包括 LoadRebalance 和 ChunkRecovery 。",
32511
- "* ChunkId: 分区的 ID。",
32512
- "* ChunkPath: 分区的 DFS 路径。",
32513
- "* Source: 恢复数据的源节点，即正常的数据节点。",
32514
- "* Dest: 需要进行数据恢复的节点(目的节点)。",
32515
- "* Status: 数据恢复的状态，包括 “Waiting”, “In-Progress”, “Finish”。",
32516
- "* AttemptCount: 恢复任务尝试的次数。",
32517
- "* DeleteSource: 是否删除源节点的数据。当 TaskType 是 ChunkRecovery 时，只能返回 false；当 TaskType 是 LoadRebalance 时，可以返回 true 或 false。",
32518
- "* StartTime: 创建恢复任务的时间。",
32519
- "* LastDequeueTime: 任务最后一次从任务队列出队的时间。",
32520
- "* LastStartTime: 最后一次开始执行任务的时间。",
32521
- "* FinishTime: 任务结束的时间。",
32522
- "* IsIncrementalRecovery: 是否启用增量复制。",
32523
- "* IsAsyncRecovery: 是否启用异步复制。",
32524
- "* ChangeFromIncrementalToFull: 是否从增量恢复转为全量恢复。系统多次尝试增量恢复失败会自动转换成全量恢复。",
32525
- "* ChangeToSyncTime: 节点在线恢复时，从异步恢复阶段转为同步恢复阶段的时刻。",
32948
+ "* TaskId：表示恢复副本任务的 ID。",
32949
+ "* TaskType：恢复任务的类型，包括 LoadRebalance 和 ChunkRecovery 。",
32950
+ "* ChunkId：分区的 ID。",
32951
+ "* ChunkPath：分区的 DFS 路径。",
32952
+ "* Source：恢复数据的源节点，即正常的数据节点。",
32953
+ "* Dest：需要进行数据恢复的节点(目的节点)。",
32954
+ "* Status：数据恢复的状态，包括 “Waiting”, “In-Progress”, “Finish”。",
32955
+ "* AttemptCount：恢复任务尝试的次数。",
32956
+ "* DeleteSource：是否删除源节点的数据。当 TaskType 是 ChunkRecovery 时，只能返回 false；当 TaskType 是 LoadRebalance 时，可以返回 true 或 false。",
32957
+ "* StartTime：创建恢复任务的时间。",
32958
+ "* LastDequeueTime：任务最后一次从任务队列出队的时间。",
32959
+ "* LastStartTime：最后一次开始执行任务的时间。",
32960
+ "* FinishTime：任务结束的时间。",
32961
+ "* IsIncrementalRecovery：是否启用增量复制。",
32962
+ "* IsAsyncRecovery：是否启用异步复制。",
32963
+ "* ChangeFromIncrementalToFull：是否从增量恢复转为全量恢复。系统多次尝试增量恢复失败会自动转换成全量恢复。",
32964
+ "* ChangeToSyncTime：节点在线恢复时，从异步恢复阶段转为同步恢复阶段的时刻。",
32526
32965
  "* FailureReason：recovery 任务失败的原因。"
32527
32966
  ]
32528
32967
  }
@@ -32647,11 +33086,11 @@
32647
33086
  "获取 redo log 垃圾回收的状态。返回一个表对象，包含以下几列：",
32648
33087
  "",
32649
33088
  "* physicalName：物理表名，格式为 \"/数据库名/物理表名\"",
32650
- "* txnCount：redo log 尚未回收的事务数。",
32651
- "* numOfTxnPendingGC：等待回收的事务数。",
32652
- "* minTidPendingGC：等待回收的事务的最小 tid。",
32653
- "* numOfTxnPendingFlush：等待刷盘的事务数。",
32654
- "* minTidPendingFlush：等待刷盘的事务的最小 tid。"
33089
+ "* txnCount：redo log 尚未回收的事务数",
33090
+ "* numOfTxnPendingGC：等待回收的事务数",
33091
+ "* minTidPendingGC：等待回收的事务的最小 tid",
33092
+ "* numOfTxnPendingFlush：等待刷盘的事务数",
33093
+ "* minTidPendingFlush：等待刷盘的事务的最小 tid"
32655
33094
  ]
32656
33095
  }
32657
33096
  ]
@@ -33135,7 +33574,7 @@
33135
33574
  "numRows 时间序列引擎中的记录行数",
33136
33575
  "numMetrics 时间序列引擎使用的聚合指标的数量",
33137
33576
  "metrics 时间序列引擎使用的聚合指标的元代码",
33138
- "memoryUsed 时间序列引擎所占用内存量",
33577
+ "memoryUsed 时间序列引擎所占用内存量，单位为字节",
33139
33578
  "snapshotDir 保存引擎快照的文件目录",
33140
33579
  "snapshotInterval 每隔多少条数据保存一次引擎快照",
33141
33580
  "snapshotMsgId 最后一个 snapshot 的 msgId",
@@ -33156,7 +33595,7 @@
33156
33595
  "metrics\t\t\t 横截面引擎使用的聚合指标的元代码",
33157
33596
  "triggeringPattern\t横截面引擎触发计算的方式",
33158
33597
  "triggeringInterval\t横截面引擎触发计算的时间间隔",
33159
- "memoryUsed 横截面引擎所占用内存量",
33598
+ "memoryUsed 横截面引擎所占用内存量，单位为字节",
33160
33599
  "================== =================================================",
33161
33600
  "",
33162
33601
  "* 表 AnomalyDetectionEngine 返回异常检测引擎的状态。它包含以下列：",
@@ -33177,7 +33616,7 @@
33177
33616
  "snapshotMsgId 最后一个 snapshot 的 msgId",
33178
33617
  "snapshotTimestam 引擎快照的时间戳",
33179
33618
  "garbageSize 触发内存清理的阈值",
33180
- "memoryUsed 异常检测引擎所占用内存量",
33619
+ "memoryUsed 异常检测引擎所占用内存量，单位为字节",
33181
33620
  "===================== ====================================================",
33182
33621
  "",
33183
33622
  "",
@@ -33193,7 +33632,7 @@
33193
33632
  "numGroups 响应式状态引擎中的分组数",
33194
33633
  "numRows 响应式状态引擎中的记录行数",
33195
33634
  "numMetrics 指标的数量",
33196
- "memoryUsed 响应式状态引擎所占用内存量",
33635
+ "memoryUsed 响应式状态引擎所占用内存量，单位为字节",
33197
33636
  "snapshotDir 保存引擎快照的文件目录",
33198
33637
  "snapshotInterval 每隔多少条数据保存一次引擎快照",
33199
33638
  "snapshotMsgId 最后一个 snapshot 的 msgId",
@@ -33215,7 +33654,7 @@
33215
33654
  "numRows 会话窗口引擎中的记录行数",
33216
33655
  "numMetrics 指标的数量",
33217
33656
  "Metrics 会话窗口聚合引擎使用的聚合指标的元代码",
33218
- "memoryUsed 会话窗口引擎所占用内存量",
33657
+ "memoryUsed 会话窗口引擎所占用内存量，单位为字节",
33219
33658
  "snapshotDir 会话窗口引擎快照保存的文件目录",
33220
33659
  "snapshotInterval 每隔多少条数据保存一次引擎快照",
33221
33660
  "snapshotMsgId 最后一个 snapshot 的 msgId",
@@ -33239,7 +33678,7 @@
33239
33678
  "numRows 日级时间序列引擎中的记录行数",
33240
33679
  "numMetrics 日级时间序列引擎使用的聚合指标的数量",
33241
33680
  "metrics 日级时间序列引擎使用的聚合指标的元代码",
33242
- "memoryUsed 日级时间序列引擎所占用内存量",
33681
+ "memoryUsed 日级时间序列引擎所占用内存量，单位为字节",
33243
33682
  "snapshotDir 日级时间序列聚合引擎快照保存的文件目录",
33244
33683
  "snapshotInterval 每隔多少条数据保存一次引擎快照",
33245
33684
  "snapshotMsgId 最后一个 snapshot 的 msgId",
@@ -33262,7 +33701,7 @@
33262
33701
  "rightTableNumRows asof join 引擎右表中的记录行数",
33263
33702
  "numMetrics asof join 引擎使用的聚合指标的数量",
33264
33703
  "metrics asof join 引擎使用的聚合指标的元代码",
33265
- "memoryUsed asof join 引擎所占用内存量",
33704
+ "memoryUsed asof join 引擎所占用内存量，单位为字节",
33266
33705
  "================== =================================================",
33267
33706
  "",
33268
33707
  "* 表 EqualJoinEngine 返回 equal join 引擎的状态。它包含以下列：",
@@ -33279,7 +33718,7 @@
33279
33718
  "rightTableNumRows equal join 引擎右表中的记录行数",
33280
33719
  "numMetrics equal join 引擎使用的聚合指标的数量",
33281
33720
  "metrics equal join 引擎使用的聚合指标的元代码",
33282
- "memoryUsed equal join 引擎所占用内存量",
33721
+ "memoryUsed equal join 引擎所占用内存量，单位为字节",
33283
33722
  "================== =================================================",
33284
33723
  "",
33285
33724
  "* 表 StreamFilter 返回流数据过滤引擎的状态。它包含以下列：",
@@ -33836,15 +34275,13 @@
33836
34275
  "| OLAP CACHE ENGINE | OLAP 引擎 cache Engine 的状态信息，包含各节点的内存信息以及当前节点的状态表。 | ``pnodeRun(getCacheEngineMemSize)`` |",
33837
34276
  "| STATUS | | ``pnodeRun(getCacheEngineStat)`` |",
33838
34277
  "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
33839
- "| TSDB META | 获取 TSDB 引擎下所有 chunk 的元数据。 | ``pnodeRun(getTSDBMetaData)`` |",
33840
- "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
33841
34278
  "| REDO LOG GC STATUS | 获取事务 redo log 回收的状态。 | ``pnodeRun(getRedoLogGCStat)`` |",
33842
34279
  "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
33843
34280
  "| TRANSACTION STATUS | 获取事务的状态。 | ``pnodeRun(getTransactionStatus)`` |",
33844
34281
  "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
33845
- "| TABLETS META | 返回集群中行数最多的前100个 chunk 的元数据信息。 | select top 100 \\* from pnodeRun(getTable|",
33846
- "| | | tsMeta{\"%\",\"%\",false,-1}) order by |",
33847
- "| | | rowNum desc |",
34282
+ "| TABLETS META | 返回集群中行数最多的前100个 chunk 的元数据信息。 |select top 100 \\* from pnodeRun(getTable |",
34283
+ "| | |tsMeta{\"%\",\"%\",false,-1}) order by |",
34284
+ "| | |rowNum desc |",
33848
34285
  "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
33849
34286
  "|ANOMALOUS CHUNK STATUS| 获取处于异常状态的 chunk 信息。异常状态包含处于 recovery 状态，版本号不一致， | ``getClusterChunksStatus()`` |",
33850
34287
  "|(only in cluster mode)| 副本数不一致等。 | |",
@@ -34038,14 +34475,21 @@
34038
34475
  " $ y=rand(10, n)",
34039
34476
  " $ t1=table(ID, date, x)",
34040
34477
  " $ t2=table(ID, date, y)",
34041
- " $ db = database(\"C:/DolphinDB/Data/valueDB\", VALUE, 2017.08.07..2017.08.11)",
34478
+ " $ db = database(\"dfs://valueDB\", VALUE, 2017.08.07..2017.08.11)",
34042
34479
  " $ pt1 = db.createPartitionedTable(t1, `pt1, `date)",
34043
34480
  " $ pt1.append!(t1)",
34044
34481
  " $ pt2 = db.createPartitionedTable(t2, `pt2, `date)",
34045
34482
  " $ pt2.append!(t2);",
34046
34483
  " $ getTables(db);",
34047
34484
  "",
34048
- " [\"pt1\",\"pt2\"]"
34485
+ " [\"pt1\",\"pt2\"]",
34486
+ ""
34487
+ ]
34488
+ },
34489
+ {
34490
+ "type": "text",
34491
+ "value": [
34492
+ ".. 相关函数：:doc:`getDFSTablesByDatabase`"
34049
34493
  ]
34050
34494
  }
34051
34495
  ]
@@ -34854,7 +35298,7 @@
34854
35298
  "",
34855
35299
  "`mean` 可选参数，向量/矩阵。表示模型初始化的均值。若 *X* 为一元数据，则 *mean* 是元素个数为 *k* 的向量；若 *X* 为多元数据，则 *mean* 是列数为 *k*，行数与 *X* 的元数相同的矩阵。若不指定，系统随机从 *X* 中选择 *k* 个值作为模型的初始化均值。",
34856
35300
  "",
34857
- "`sigma` 可选参数，向量/元组，元素个数为 *k*。若 *X* 为一元数据，表示每个子模型初始化的方差；若 *X* 为多元数据，表示每个子模型初始化的协方差矩阵。若不指定，系统使用元素值为 1 的向量或单位矩阵。",
35301
+ "`sigma` 可选参数，向量/元组，元素个数为 *k*。若 *X* 为一元数据，表示每个子模型初始化的方差；若 *X* 为多元数据，表示每个子模型初始化的协方差矩阵。若不指定，系统使用 1 作为方差，或单位矩阵作为协方差矩阵。",
34858
35302
  ""
34859
35303
  ]
34860
35304
  }
@@ -34869,7 +35313,7 @@
34869
35313
  "value": [
34870
35314
  "通过数据集训练 GMM（高斯混合模型）。返回一个字典，包含以下键值：",
34871
35315
  "",
34872
- "* modelName：字符串 \"Gaussian Mixture Model\"",
35316
+ "* modelName：字符串 \"Gaussian Mixture Model\"。",
34873
35317
  "* prior：观测数据属于各子模型的先验概率。",
34874
35318
  "* mean：训练获得的每个子模型的期望。",
34875
35319
  "* sigma：若 *X* 为 一元数据，表示训练获得的每个子模型的方差；若 *X* 为多元数据，表示训练获得的每个子模型的协方差矩阵。"
@@ -37603,7 +38047,7 @@
37603
38047
  "",
37604
38048
  "`colTypes` 是向量，表示各列的数据类型。",
37605
38049
  "",
37606
- "第三种用法中，table是一个表。注意，`table` 中的 `keyColumns` 不能包含重复值。"
38050
+ "第三种用法中，*table* 是一个表。注意，`table` 中的 `keyColumns` 不能包含重复值。"
37607
38051
  ]
37608
38052
  }
37609
38053
  ]
@@ -37623,10 +38067,12 @@
37623
38067
  "",
37624
38068
  "对于索引内存表，满足以下条件，SQL查询性能会优于普通内存表：",
37625
38069
  "",
37626
- "* 查询语句必须包含keyColumns的第1列，且该列使用的过滤条件只能使用=或in，且该条件后面不能跟or语句；",
37627
- "* 所有过滤条件使用的in谓词次数小于等于两次。",
38070
+ "* 查询语句必须包含 *keyColumns* 的第 1 列，且该列使用的过滤条件只能使用 = 或 in，且该条件后面不能跟 or 语句；",
38071
+ "* 所有过滤条件使用的 in 谓词次数小于等于两次。",
37628
38072
  "",
37629
- "请对比 :doc:`键值内存表 <../k/keyedTable>` 优化SQL查询条件。"
38073
+ "查询 ``indexedTable`` 时，建议调用 :doc:`../s/sliceByKey` 以提高性能。",
38074
+ "",
38075
+ "请对比 :doc:`键值内存表 <../k/keyedTable>` 优化 SQL 查询条件。"
37630
38076
  ]
37631
38077
  }
37632
38078
  ]
@@ -37825,16 +38271,19 @@
37825
38271
  "value": [
37826
38272
  "",
37827
38273
  " $ timer(100) select * from t where id=500000;",
37828
- " Time elapsed: 66.855 ms",
38274
+ " Time elapsed: 177.286 ms",
37829
38275
  "",
37830
38276
  " $ timer(100) select * from t1 where id=500000;",
37831
- " Time elapsed: 1.001 ms",
38277
+ " Time elapsed: 1.245 ms",
38278
+ "",
38279
+ " $ timer(100) sliceByKey(t1, 500000)",
38280
+ " Time elapsed: 0.742 ms",
37832
38281
  "",
37833
38282
  " $ timer(100) select * from t where id in [500000, 600000, 700000];",
37834
- " Time elapsed: 576.49 ms",
38283
+ " Time elapsed: 1134.429 ms",
37835
38284
  "",
37836
38285
  " $ timer(100) select * from t1 where id in [500000, 600000, 700000];",
37837
- " Time elapsed: 1 ms",
38286
+ " Time elapsed: 1.377 ms",
37838
38287
  ""
37839
38288
  ]
37840
38289
  },
@@ -37851,10 +38300,10 @@
37851
38300
  "value": [
37852
38301
  "",
37853
38302
  " $ timer(100) select * from t where id between 500000:500010;",
37854
- " Time elapsed: 64.862 ms",
38303
+ " Time elapsed: 641.544 ms",
37855
38304
  "",
37856
38305
  " $ timer(100) select * from t1 where id between 500000:500010;",
37857
- " Time elapsed: 64.858 ms",
38306
+ " Time elapsed: 599.752 ms",
37858
38307
  ""
37859
38308
  ]
37860
38309
  },
@@ -37871,10 +38320,10 @@
37871
38320
  "value": [
37872
38321
  "",
37873
38322
  " $ timer(100) select * from t where id=500000, type in [3,6];",
37874
- " Time elapsed: 65.861 ms",
38323
+ " Time elapsed: 172.808 ms",
37875
38324
  "",
37876
38325
  " $ timer(100) select * from t1 where id=500000, type in [3,6];",
37877
- " Time elapsed: 0.995 ms",
38326
+ " Time elapsed: 1.664 ms",
37878
38327
  ""
37879
38328
  ]
37880
38329
  },
@@ -37891,16 +38340,16 @@
37891
38340
  "value": [
37892
38341
  "",
37893
38342
  " $ timer(100) select * from t where date in [2012.06.03, 2012.06.06];",
37894
- " Time elapsed: 285.24 ms",
38343
+ " Time elapsed: 490.182 ms",
37895
38344
  "",
37896
38345
  " $ timer(100) select * from t1 where date in [2012.06.03, 2012.06.06];",
37897
- " Time elapsed: 271.325 ms",
38346
+ " Time elapsed: 544.015 ms",
37898
38347
  "",
37899
38348
  " $ timer(100) select * from t where date=2012.06.03, type=8;",
37900
- " Time elapsed: 74.835 ms",
38349
+ " Time elapsed: 205.443 ms",
37901
38350
  "",
37902
38351
  " $ timer(100) select * from t1 where date=2012.06.03, type=8;",
37903
- " Time elapsed: 77.828 ms",
38352
+ " Time elapsed: 204.532 ms",
37904
38353
  ""
37905
38354
  ]
37906
38355
  },
@@ -37917,10 +38366,10 @@
37917
38366
  "value": [
37918
38367
  "",
37919
38368
  " $ timer(100) select * from t where id in [100,200], date in [2012.06.03, 2012.06.06], type in [3,6];",
37920
- " Time elapsed: 98.767 ms",
38369
+ " Time elapsed: 208.714 ms",
37921
38370
  "",
37922
38371
  " $ timer(100) select * from t1 where id in [100,200], date in [2012.06.03, 2012.06.06], type in [3,6];",
37923
- " Time elapsed: 99.736 ms",
38372
+ " Time elapsed: 198.674 ms",
37924
38373
  ""
37925
38374
  ]
37926
38375
  },
@@ -40667,7 +41116,10 @@
40667
41116
  "value": [
40668
41117
  "`X` 数值型向量/矩阵/表。",
40669
41118
  "",
40670
- "`strict` 布尔值，表示是否取严格的峰值点。默认值为 true。"
41119
+ "`strict` 布尔值，默认值为 true。",
41120
+ "",
41121
+ " * 若 *strict* = true，相邻元素不为空且严格小于该元素；",
41122
+ " * 若 *strict* = false，相邻元素不为空且小于等于该元素；"
40671
41123
  ]
40672
41124
  }
40673
41125
  ]
@@ -40681,11 +41133,6 @@
40681
41133
  "value": [
40682
41134
  "若 *X* 为向量，计算 *X* 中的每个元素是否为峰值点，若是则返回 true，否则返回 false。",
40683
41135
  "",
40684
- "判断规则为：",
40685
- "",
40686
- "* 若 *strict* = true，相邻元素不为空且严格小于该元素；",
40687
- "* 若 *strict* = false，相邻元素不为空且小于等于该元素；",
40688
- "",
40689
41136
  "若 *X* 为矩阵，在每列进行上述计算，返回值一个同 X 维度相同的矩阵。若 *X* 为表，则只对数值型的列进行上述计算。"
40690
41137
  ]
40691
41138
  }
@@ -41212,7 +41659,7 @@
41212
41659
  {
41213
41660
  "type": "text",
41214
41661
  "value": [
41215
- "检查每个元素是否是 NULL。如果它不是 NULL，返回 1，否则返回 0。"
41662
+ "检查每个元素是否为有效数（非 NULL 值）。如果是，返回 1，否则返回 0。"
41216
41663
  ]
41217
41664
  }
41218
41665
  ]
@@ -41265,7 +41712,10 @@
41265
41712
  "value": [
41266
41713
  "`X` 数值型向量/矩阵/表。",
41267
41714
  "",
41268
- "`strict` 布尔值，表示是否取严格的谷值点。默认值为 true。"
41715
+ "`strict` 布尔值，表示是否取严格的谷值点。默认值为 true。",
41716
+ "",
41717
+ " * 若 *strict* = true，相邻元素不为空且严格大于该元素；",
41718
+ " * 若 *strict* = false，相邻元素不为空且大于等于该元素；"
41269
41719
  ]
41270
41720
  }
41271
41721
  ]
@@ -41279,11 +41729,6 @@
41279
41729
  "value": [
41280
41730
  "若 *X* 为向量，计算 *X* 中的每个元素是否为谷值点，若是则返回 true，否则返回 false。",
41281
41731
  "",
41282
- "判断规则为：",
41283
- "",
41284
- "* 若 *strict* = true，相邻元素不为空且严格大于该元素；",
41285
- "* 若 *strict* = false，相邻元素不为空且大于等于该元素；",
41286
- "",
41287
41732
  "若 *X* 为矩阵，在每列进行上述计算，返回值一个同 X 维度相同的矩阵。若 *X* 为表，则只对数值型的列进行上述计算。"
41288
41733
  ]
41289
41734
  }
@@ -42818,12 +43263,14 @@
42818
43263
  "",
42819
43264
  "注意：",
42820
43265
  "",
42821
- "对于键值内存表，满足以下条件，SQL查询性能会优于普通内存表：",
43266
+ "对于键值内存表，满足以下条件，SQL 查询性能会优于普通内存表：",
43267
+ "",
43268
+ "* SQL语句中只能使用 =, in 或 and, 且 in 谓词使用小于等于两次；",
43269
+ "* 查询语句必须包含 *keyColumns* 所有列。",
42822
43270
  "",
42823
- "* SQL语句中只能使用=, in或and, 且in谓词使用小于等于两次；",
42824
- "* 查询语句必须包含keyColumns所有列。",
43271
+ "查询 ``keyedTable`` 时，建议调用 :doc:`../s/sliceByKey` 以提高性能。",
42825
43272
  "",
42826
- "请对比 :doc:`索引内存表 <../i/indexedTable>` 优化SQL查询条件。",
43273
+ "请对比 :doc:`索引内存表 <../i/indexedTable>` 优化 SQL 查询条件。",
42827
43274
  "",
42828
43275
  "具体请参考例3。"
42829
43276
  ]
@@ -43053,10 +43500,13 @@
43053
43500
  "value": [
43054
43501
  "",
43055
43502
  " $ timer(100) select * from t where id=500000, date=2012.06.01, type=0;",
43056
- " Time elapsed: 63.864 ms",
43503
+ " Time elapsed: 161.574 ms",
43057
43504
  "",
43058
43505
  " $ timer(100) select * from kt where id=500000, date=2012.06.01, type=0;",
43059
- " Time elapsed: 0.998 ms",
43506
+ " Time elapsed: 1.483 ms",
43507
+ "",
43508
+ " $ timer(100) sliceByKey(t1, (500000, 2012.06.01, 0))",
43509
+ " Time elapsed: 0.705 ms",
43060
43510
  ""
43061
43511
  ]
43062
43512
  },
@@ -43073,17 +43523,17 @@
43073
43523
  "value": [
43074
43524
  "",
43075
43525
  " $ timer(100) select * from t where id in [1, 500000], date in 2012.06.01..2012.06.05, type=5;",
43076
- " Time elapsed: 507.676 ms",
43526
+ " Time elapsed: 894.241 ms",
43077
43527
  "",
43078
43528
  " $ timer(100) select * from kt where id in [1, 500000], date in 2012.06.01..2012.06.05, type=5;",
43079
- " Time elapsed: 1.002 ms",
43529
+ " Time elapsed: 2.322 ms",
43080
43530
  ""
43081
43531
  ]
43082
43532
  },
43083
43533
  {
43084
43534
  "type": "text",
43085
43535
  "value": [
43086
- "in谓词数量超过两个时，键值内存表不会进行查询优化：",
43536
+ "in 谓词数量超过两个时，键值内存表不会进行查询优化：",
43087
43537
  "",
43088
43538
  "例3.3",
43089
43539
  ""
@@ -43095,10 +43545,10 @@
43095
43545
  "value": [
43096
43546
  "",
43097
43547
  " $ timer(100) select * from t where id in [1, 500000], date in 2012.06.01..2012.06.05, type in 1..5;",
43098
- " Time elapsed: 504.65 ms",
43099
- "",
43548
+ " Time elapsed: 801.347 ms",
43549
+ " ",
43100
43550
  " $ timer(100) select * from kt where id in [1, 500000], date in 2012.06.01..2012.06.05, type in 1..5;",
43101
- " Time elapsed: 511.665 ms",
43551
+ " Time elapsed: 834.184 ms",
43102
43552
  ""
43103
43553
  ]
43104
43554
  },
@@ -43117,10 +43567,10 @@
43117
43567
  "value": [
43118
43568
  "",
43119
43569
  " $ timer(100) select * from t where id=500000, date in 2012.06.01..2012.06.05;",
43120
- " Time elapsed: 64.861 ms",
43570
+ " Time elapsed: 177.113 ms",
43121
43571
  "",
43122
43572
  " $ timer(100) select * from kt where id=500000, date in 2012.06.01..2012.06.05;",
43123
- " Time elapsed: 64.863 ms",
43573
+ " Time elapsed: 163.265 ms",
43124
43574
  " "
43125
43575
  ]
43126
43576
  },
@@ -44961,7 +45411,7 @@
44961
45411
  "language": "console",
44962
45412
  "value": [
44963
45413
  "",
44964
- " $ loadBackup(\"/home/DolphinDB/backup\",\"dfs://valuedb\", \"/200001M/2\",\"pt\");",
45414
+ " $ loadBackup(\"/home/DolphinDB/backup\",\"dfs://valuedb\", \"/200001M\",\"pt\");",
44965
45415
  ""
44966
45416
  ]
44967
45417
  },
@@ -45845,13 +46295,14 @@
45845
46295
  {
45846
46296
  "type": "text",
45847
46297
  "value": [
45848
- "`database` 可以是字符串，表示数据库的路径，也可以是数据库句柄。",
46298
+ "`database` 字符串，表示数据库的路径，也可以是数据库句柄。可以是分布式数据库或本地磁盘数据库。",
45849
46299
  "",
45850
- "`tableName` 是字符串，表示表的名称，它需要使用反引号(`)或双引号。",
46300
+ "`tableName` 字符串，表示表的名称，它需要使用反引号(`)或双引号。",
45851
46301
  "",
45852
- "`partitions` 是标量或向量，表示要加载的分区。注意，只有本地磁盘数据库支持该参数，分布式数据库不支持该参数。",
46302
+ "`partitions` 标量或向量，表示要加载的分区。注意，只有本地磁盘数据库支持该参数，分布式数据库不支持该参数。",
45853
46303
  "",
45854
- "`memoryMode` 是布尔值，表示是否把数据加载到内存。如果 *memoryMode* =false，表示只加载元数据到内存；如果 *memoryMode* =true，表示将实际数据加载到内存。注意，只有本地磁盘数据库支持该参数，分布式数据库不支持该参数。对于分布式数据库，只将元数据加载到内存中。"
46304
+ "`memoryMode` 布尔值，表示是否把数据加载到内存。如果 *memoryMode* =false，表示只加载元数据到内存；如果 *memoryMode* =true，",
46305
+ "表示将实际数据加载到内存。注意，只有本地磁盘数据库支持该参数，分布式数据库不支持该参数。对于分布式数据库，只将元数据加载到内存中。"
45855
46306
  ]
45856
46307
  }
45857
46308
  ]
@@ -45972,14 +46423,9 @@
45972
46423
  {
45973
46424
  "type": "text",
45974
46425
  "value": [
45975
- "* 加载本地磁盘未分区表：",
45976
- ""
45977
- ]
45978
- },
45979
- {
45980
- "type": "code",
45981
- "language": "console",
45982
- "value": [
46426
+ ".. * 加载本地磁盘未分区表：",
46427
+ "",
46428
+ ".. .. code:: console",
45983
46429
  "",
45984
46430
  " $ n=2000000",
45985
46431
  " $ syms=`IBM`C`MS`MSFT`JPM`ORCL`FB`GE",
@@ -45996,20 +46442,10 @@
45996
46442
  "",
45997
46443
  " $ // alternatively, we can specify the folder path to load a table:",
45998
46444
  " $ tt=loadTable(\"C:/DolphinDB/Data/db01\",`t1);",
45999
- ""
46000
- ]
46001
- },
46002
- {
46003
- "type": "text",
46004
- "value": [
46005
- "* 加载本地磁盘分区表的某些分区：",
46006
- ""
46007
- ]
46008
- },
46009
- {
46010
- "type": "code",
46011
- "language": "console",
46012
- "value": [
46445
+ "",
46446
+ ".. * 加载本地磁盘分区表的某些分区：",
46447
+ "",
46448
+ ".. .. code:: console",
46013
46449
  "",
46014
46450
  " $ n = 2000000",
46015
46451
  " $ workDir = \"C:/DolphinDB/Data\"",
@@ -46020,56 +46456,26 @@
46020
46456
  " $ db = database(workDir + \"/trade1\",VALUE,`IBM`MSFT`GM`C`YHOO`GOOG)",
46021
46457
  " $ db.loadTextEx(\"trades\",\"sym\", workDir + \"/trades.txt\")",
46022
46458
  " $ trades = db.loadTable(\"trades\",`IBM`GM`YHOO,1)",
46023
- ""
46024
- ]
46025
- },
46026
- {
46027
- "type": "text",
46028
- "value": [
46029
- "对于范围分区，我们可以使用范围中的某个值表示整个分区。",
46030
- ""
46031
- ]
46032
- },
46033
- {
46034
- "type": "code",
46035
- "language": "console",
46036
- "value": [
46459
+ "",
46460
+ ".. 对于范围分区，我们可以使用范围中的某个值表示整个分区。",
46461
+ "",
46462
+ ".. .. code:: console",
46037
46463
  "",
46038
46464
  " $ db = database(workDir + \"/trade2\",RANGE,[2000.01.01, 2000.04.01, 2000.07.01, 2000.10.01, 2001.01.01])",
46039
46465
  " $ db.loadTextEx(\"trades\",\"date\", workDir + \"/trades.txt\")",
46040
- ""
46041
- ]
46042
- },
46043
- {
46044
- "type": "text",
46045
- "value": [
46046
- "下面两个命令类似：",
46047
- ""
46048
- ]
46049
- },
46050
- {
46051
- "type": "code",
46052
- "language": "console",
46053
- "value": [
46466
+ "",
46467
+ ".. 下面两个命令类似：",
46468
+ "",
46469
+ ".. .. code:: console",
46054
46470
  "",
46055
46471
  " $ trades = db.loadTable(\"trades\",[2000.01.01, 2000.07.01],true)",
46056
46472
  " $ trades = db.loadTable(\"trades\",[2000.03.06, 2000.09.15],true)",
46057
- ""
46058
- ]
46059
- },
46060
- {
46061
- "type": "text",
46062
- "value": [
46063
- "注意，对于组合分区的数据库，目前仅加载第一层分区的子集。",
46064
46473
  "",
46065
- "* 将本地磁盘分区表加载为内存分区表：",
46066
- ""
46067
- ]
46068
- },
46069
- {
46070
- "type": "code",
46071
- "language": "console",
46072
- "value": [
46474
+ ".. 注意，对于组合分区的数据库，目前仅加载第一层分区的子集。",
46475
+ "",
46476
+ ".. * 将本地磁盘分区表加载为内存分区表：",
46477
+ "",
46478
+ ".. .. code:: console",
46073
46479
  "",
46074
46480
  " $ n = 2000000",
46075
46481
  " $ workDir = \"C:/DolphinDB/Data\"",
@@ -46084,13 +46490,8 @@
46084
46490
  " $ db = database(workDir + \"/trade3\",RANGE, 0 5 10 15 20)",
46085
46491
  " $ db.loadTextEx(\"trades\",\"price\", workDir + \"/trades.txt\")",
46086
46492
  " $ trades = db.loadTable(\"trades\", ,1)",
46087
- ""
46088
- ]
46089
- },
46090
- {
46091
- "type": "text",
46092
- "value": [
46093
- "对于内存的分区表，我们可以执行一些函数，如 :doc:`../u/update!`, :doc:`drop! <../d/dropColumns!>`, :doc:`../r/rename!`, :doc:`../s/sortBy!`.",
46493
+ "",
46494
+ "对于内存的分区表，我们可以执行一些函数，如 :doc:`../u/update!`, :doc:`drop! <../d/dropColumns!>`, :doc:`../r/rename!`, :doc:`../s/sortBy!`。",
46094
46495
  "",
46095
46496
  ".. meta:: ",
46096
46497
  " :keywords: 维度表"
@@ -46198,7 +46599,7 @@
46198
46599
  "",
46199
46600
  "`delimiter` 是数据文件中各列的分隔符。默认是逗号。",
46200
46601
  "",
46201
- "`schema` 是一个表，用于指定各字段的数据类型。它可以包含以下四列（其中，name 和 type 这两列是必需的）：",
46602
+ "`schema` 是一个表，用于指定各字段的数据类型。它可以包含以下四列（其中，name 和 type 这两列是必需的）",
46202
46603
  "",
46203
46604
  "======== ================================================================",
46204
46605
  "列名 含义",
@@ -46347,11 +46748,14 @@
46347
46748
  },
46348
46749
  {
46349
46750
  "title": "例 2",
46350
- "children": []
46351
- },
46352
- {
46353
- "title": "loadText",
46354
46751
  "children": [
46752
+ {
46753
+ "type": "text",
46754
+ "value": [
46755
+ "例如，我们想要把 permno 列的数据类型转换成 SYMBOL，可以用 :doc:`../e/extractTextSchema` 函数获取输入文件的结构，在导入数据前修改该列的数据类型，并指定 `loadText` 函数的 schema 参数。",
46756
+ ""
46757
+ ]
46758
+ },
46355
46759
  {
46356
46760
  "type": "code",
46357
46761
  "language": "console",
@@ -46603,7 +47007,7 @@
46603
47007
  {
46604
47008
  "type": "text",
46605
47009
  "value": [
46606
- "`dbHandle` 是数据库的句柄，可以是内存数据库、本地磁盘数据库或分布式数据库。",
47010
+ "`dbHandle` 是数据库的句柄，可以是内存数据库或分布式数据库。",
46607
47011
  "",
46608
47012
  "`tableName` 是一个字符串，表示表的名称。",
46609
47013
  "",
@@ -46630,8 +47034,8 @@
46630
47034
  "value": [
46631
47035
  "将数据文件加载到数据库中。",
46632
47036
  "",
46633
- "* 如果要将数据文件加载到分布式数据库或本地磁盘数据库中，必须指定 *dbHandle*，并且不能为空字符串。",
46634
- "* 如果要将数据文件加载到内存数据库中，那么 *dbHandle* 为空字符串或者不指定 *dbHandle*。",
47037
+ "* 如果要将数据文件加载到分布式数据库中，必须指定 *tableName*，并且不能为空字符串。",
47038
+ "* 如果要将数据文件加载到内存数据库中，那么 *tableName* 为空字符串或者不指定 *tableName*。",
46635
47039
  "",
46636
47040
  "如果指定了 *transform* 参数，需要先创建分区表，再加载数据。系统会对数据文件中的数据执行 *transform* 参数指定的函数，再将得到的结果保存到数据库中。",
46637
47041
  "",
@@ -47592,7 +47996,7 @@
47592
47996
  "language": "console",
47593
47997
  "value": [
47594
47998
  "",
47595
- " //模拟股票 A 8天的股价,使用 topRange 计算股票 A 每日股价创几日新高",
47999
+ " //模拟股票 A 8天的股价,使用 lowRange 计算股票 A 当日股价创几日新低",
47596
48000
  " $ trades = table(take(`A, 8) as sym, 2022.01.01 + 1..8 as date, 39.70 39.72 39.80 39.78 39.83 39.92 40.00 40.03 as price)",
47597
48001
  " $ select *, lowRange(price) from trades",
47598
48002
  ""
@@ -51737,9 +52141,9 @@
51737
52141
  "",
51738
52142
  "`backupTableName` 是字符串，表示已备份的表的名称。",
51739
52143
  "",
51740
- "`newDBPath` 是字符串，表示新数据库的名称。如果没有指定，默认值为 *backupDBPath*.",
52144
+ "`newDBPath` 是字符串，表示新数据库的名称。如果没有指定，默认值为 *backupDBPath*。",
51741
52145
  "",
51742
- "`newTableName` 是字符串，表示新表的名称。如果没有指定，默认值为 *backupTableName*."
52146
+ "`newTableName` 是字符串，表示新表的名称。如果没有指定，默认值为 *backupTableName*。"
51743
52147
  ]
51744
52148
  }
51745
52149
  ]
@@ -52045,7 +52449,7 @@
52045
52449
  {
52046
52450
  "type": "text",
52047
52451
  "value": [
52048
- "在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 元素的最大元素的位置。"
52452
+ "在给定长度（以元素个数衡量）的滑动窗口内计算 *X* 元素的最大元素的位置。"
52049
52453
  ]
52050
52454
  }
52051
52455
  ]
@@ -52150,7 +52554,7 @@
52150
52554
  {
52151
52555
  "type": "text",
52152
52556
  "value": [
52153
- "在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 元素的最小元素的位置。"
52557
+ "在给定长度（以元素个数衡量）的滑动窗口内计算 *X* 元素的最小元素的位置。"
52154
52558
  ]
52155
52559
  }
52156
52560
  ]
@@ -53006,7 +53410,7 @@
53006
53410
  {
53007
53411
  "type": "text",
53008
53412
  "value": [
53009
- "在给定长度（以元素个数或时间长度衡量）的滑动窗口内，计算 *X* 的平均绝对离差或绝对中位差。"
53413
+ "在给定长度（以元素个数衡量）的滑动窗口内，计算 *X* 的平均绝对离差或绝对中位差。"
53010
53414
  ]
53011
53415
  }
53012
53416
  ]
@@ -53198,6 +53602,64 @@
53198
53602
  }
53199
53603
  ]
53200
53604
  },
53605
+ "mmaxPositiveStreak": {
53606
+ "title": "mmaxPositiveStreak",
53607
+ "type": "function",
53608
+ "children": [
53609
+ {
53610
+ "title": "语法",
53611
+ "type": "grammer",
53612
+ "children": [
53613
+ {
53614
+ "type": "text",
53615
+ "value": [
53616
+ "mmaxPositiveStreak(X, window)",
53617
+ "",
53618
+ "参数说明和窗口计算规则请参考：:doc:`/FunctionsandCommands/SeriesOfFunctions/mFunctions`"
53619
+ ]
53620
+ }
53621
+ ]
53622
+ },
53623
+ {
53624
+ "title": "详情",
53625
+ "type": "detail",
53626
+ "children": [
53627
+ {
53628
+ "type": "text",
53629
+ "value": [
53630
+ "在给定长度（以元素个数衡量）的滑动窗口内统计 *X* 中连续正数之和的最大值。"
53631
+ ]
53632
+ }
53633
+ ]
53634
+ },
53635
+ {
53636
+ "title": "例子",
53637
+ "type": "example",
53638
+ "children": [
53639
+ {
53640
+ "type": "code",
53641
+ "language": "console",
53642
+ "value": [
53643
+ "",
53644
+ " $ x = 1 -1 1 -2 10 3 3 9 0 6 5",
53645
+ " $ w = 5",
53646
+ " $ mmaxPositiveStreak(x, w)",
53647
+ " [,,,,10,13,16,25,25,15,12]",
53648
+ "",
53649
+ " $ x = 5 NULL 3 2 1 5 10 9 NULL 9 10 -1 NULL ",
53650
+ " $ w = 5",
53651
+ " $ mmaxPositiveStreak(x, w)",
53652
+ " [,,,,6,11,21,27,25,24,19,19,19]",
53653
+ "",
53654
+ " // 搭配 signum 函数用于统计向量中出现的连续正数的最大个数",
53655
+ " $ mmaxPositiveStreak(signum(x), w)",
53656
+ " [,,,,3,4,5,5,4,3,2,2,2]"
53657
+ ]
53658
+ }
53659
+ ]
53660
+ }
53661
+ ]
53662
+ },
53201
53663
  "mmed": {
53202
53664
  "title": "mmed",
53203
53665
  "type": "function",
@@ -55859,7 +56321,7 @@
55859
56321
  "value": [
55860
56322
  "msum2(X, window, [minPeriods])",
55861
56323
  "",
55862
- "参数说明和窗口计算规则请参考: :doc:`/FunctionsandCommands/SeriesOfFunctions/mFunctions`"
56324
+ "参数说明和窗口计算规则请参考：:doc:`/FunctionsandCommands/SeriesOfFunctions/mFunctions`"
55863
56325
  ]
55864
56326
  }
55865
56327
  ]
@@ -58275,17 +58737,7 @@
58275
58737
  {
58276
58738
  "type": "text",
58277
58739
  "value": [
58278
- "*X* 中连续且值相同的元素具有相同的状态，该函数返回与当前元素状态不同的后一个临近元素值。",
58279
- "",
58280
- "*X* 是向量时：",
58281
- "",
58282
- "* 若当前元素为空值，返回后项最邻近的一个非空值。",
58283
- "* 若当前元素为非空值，寻找后项最邻近且状态不同的元素 N：",
58284
- " ",
58285
- " * 若 N 为非空值，则返回 N。",
58286
- " * 若 N 为空值，则返回 N 之后最邻近的一个非空值。",
58287
- " ",
58288
- "* 若找不到符合上述条件的值，则返回空值。",
58740
+ "*X* 中连续且相同的元素标记为同一状态，空值无状态。每个元素的状态等于其元素值。对于 *X* 中的每一个元素，返回当前状态的下一个状态。若当前元素为空，则返回下一个邻近状态。",
58289
58741
  "",
58290
58742
  "*X* 是矩阵时，则在矩阵每一列进行上述计算。"
58291
58743
  ]
@@ -59614,9 +60066,9 @@
59614
60066
  "type": "example",
59615
60067
  "children": [
59616
60068
  {
59617
- "type": "code",
59618
- "language": "console",
60069
+ "type": "text",
59619
60070
  "value": [
60071
+ ".. .. code:: console",
59620
60072
  "",
59621
60073
  " $ db=database(\"C:/DolphinDB/Data/DBSeq\",SEQ,3)",
59622
60074
  " $ USPrices=loadTextEx(db, \"USPrices\", \"c:/DolphinDB/Data/USPrices.csv\")",
@@ -59648,6 +60100,52 @@
59648
60100
  ""
59649
60101
  ]
59650
60102
  },
60103
+ {
60104
+ "type": "code",
60105
+ "language": "console",
60106
+ "value": [
60107
+ "",
60108
+ " $ n=10000",
60109
+ " $ ID=rand(100, n)",
60110
+ " $ dates=2017.08.07..2017.08.11",
60111
+ " $ date=rand(dates, n)",
60112
+ " $ vol=rand(1..10 join int(), n)",
60113
+ " $ price=rand(100,n)",
60114
+ " $ t=table(ID, date, vol,price)",
60115
+ " $ saveText(t, \"D:/DolphinDB/Data/t.txt\");",
60116
+ " $ if(existsDatabase(\"dfs://rangedb\")){",
60117
+ " $ \tdropDatabase(\"dfs://rangedb\")",
60118
+ " $ }",
60119
+ " $ db = database(directory=\"dfs://rangedb\", partitionType=RANGE, partitionScheme=0 51 101)",
60120
+ " $ USPrices=loadTextEx(dbHandle=db,tableName=`USPrices, partitionColumns=`ID, filename=\"D:/DolphinDB/Data/t.txt\");",
60121
+ "",
60122
+ " $ ds=sqlDS(<select vol as VS, price as SBA from USPrices where vol>5>)",
60123
+ " $ rs=olsEx(ds, `VS, `SBA, true, 2)",
60124
+ " $ rs;",
60125
+ " ",
60126
+ " RegressionStat->",
60127
+ " item statistics",
60128
+ " ------------ ----------",
60129
+ " R2 0.000848 ",
60130
+ " AdjustedR2 0.000628 ",
60131
+ " StdError 1.404645 ",
60132
+ " Observations 4535 ",
60133
+ "",
60134
+ " ANOVA->",
60135
+ " Breakdown DF SS MS F Significance",
60136
+ " ---------- ---- ----------- -------- -------- ------------",
60137
+ " Regression 1 7.592565 7.592565 3.848178 0.049861 ",
60138
+ " Residual 4533 8943.739298 1.973029 ",
60139
+ " Total 4534 8951.331863 ",
60140
+ "",
60141
+ " Coefficient->",
60142
+ " factor beta stdError tstat pvalue ",
60143
+ " --------- -------- -------- ---------- --------",
60144
+ " intercept 7.953084 0.04185 190.039423 0 ",
60145
+ " SBA 0.001422 0.000725 1.961677 0.049861",
60146
+ ""
60147
+ ]
60148
+ },
59651
60149
  {
59652
60150
  "type": "text",
59653
60151
  "value": [
@@ -59963,7 +60461,7 @@
59963
60461
  "",
59964
60462
  "panel 函数同 :doc:`/SQLStatements/pivotBy` 语句类似，将数据表中的数据按照两个维度重新排列。两者的不同之处在于，SQL 中，exec... pivot by... 只能指定一个指标列，",
59965
60463
  "生成一个矩阵，而 panel 函数可以指定一个或多个指标列，生成一个或多个矩阵。",
59966
- "更多面板数据的处理，请参考 `DolphinDB教程：面板数据的处理 <https://gitee.com/dolphindb/Tutorials_CN/blob/master/%E5%BA%94%E7%94%A8%E5%9C%BA%E6%99%AF%E7%A4%BA%E4%BE%8B/panel_data.md>`_。"
60464
+ "更多面板数据的处理，请参考 `DolphinDB教程：面板数据的处理 <https://gitee.com/dolphindb/Tutorials_CN/blob/master/panel_data.md>`_。"
59967
60465
  ]
59968
60466
  }
59969
60467
  ]
@@ -60766,9 +61264,9 @@
60766
61264
  "其中，:math:`X_i` 和 :math:`X_{i+1}` 为数据集X中的紧邻score的前、后两个数值，:math:`P_i` 和 :math:`P_{i+1}` 分别为 :math:`X_i` 和 :math:`X_{i+1}` 的百分位。",
60767
61265
  "",
60768
61266
  "* \"rank\": 小于等于 *score* 的元素个数占元素总数的百分比。当有多个值相等的 *score* 时，取它们百分位的平均值；",
60769
- "* \"script\": 严格小于 *score* 的元素个数占元素总数的百分比；",
61267
+ "* \"strict\": 严格小于 *score* 的元素个数占元素总数的百分比；",
60770
61268
  "* \"weak\": 小于等于 *score* 的元素个数占元素总数的百分比；",
60771
- "* \"mean\": \"script\" 和 \"weak\" 的平均值。"
61269
+ "* \"mean\": \"strict\" 和 \"weak\" 的平均值。"
60772
61270
  ]
60773
61271
  }
60774
61272
  ]
@@ -62038,17 +62536,7 @@
62038
62536
  {
62039
62537
  "type": "text",
62040
62538
  "value": [
62041
- "*X* 中连续且值相同的元素具有相同的状态，该函数返回与当前元素状态不同的前一个临近元素值。",
62042
- "",
62043
- "*X* 是向量时：",
62044
- "",
62045
- "* 若当前元素为空值，返回前项最邻近的一个非空值。",
62046
- "* 若当前元素为非空值，寻找前项最邻近且状态不同的元素 P：",
62047
- " ",
62048
- " * 若 P 为非空值，则返回 P。",
62049
- " * 若 P 为空值，则返回 P 之前最邻近的一个非空值。",
62050
- " ",
62051
- "* 若找不到符合上述条件的值，则返回空值。",
62539
+ "*X* 中连续且相同的元素标记为同一状态，空值无状态。每个元素的状态等于其元素值。对于 *X* 中的每一个元素，返回当前状态的上一个状态。若当前元素为空，则返回上一个邻近状态。",
62052
62540
  "",
62053
62541
  "*X* 是矩阵时，则在矩阵每一列进行上述计算。"
62054
62542
  ]
@@ -67840,6 +68328,27 @@
67840
68328
  }
67841
68329
  ]
67842
68330
  },
68331
+ {
68332
+ "title": "详情",
68333
+ "type": "detail",
68334
+ "children": [
68335
+ {
68336
+ "type": "text",
68337
+ "value": [
68338
+ "按时间顺序将一个或多个数据表或数据源回放到数据表，以模拟流数据实时注入。如需回放历史数据， 可通过 :doc:`replayDS` 函数生成数据源来输入 replay 。",
68339
+ "",
68340
+ "根据输入表和输出表的映射关系（map），``replay`` 支持一对一，N 对一，N 对 N 三种回放形式。注意 N 对 N 回放时，若多表时间段存在重合，不能保证该段时间完全按时间序回放。",
68341
+ "",
68342
+ "对于 N 对一回放，1.30.17 / 2.00.5 版本前，输入表结构必须相同，称为同构回放。该版本后，replay 支持以字典的形式输入结构不同的表，称为异构回放。异构回放时，replay 的输出结果可以通过 :doc:`../s/streamFilter` 进行反序列化，并进行数据过滤和分离，详情请参考 :doc:`../s/streamFilter`。 ",
68343
+ "",
68344
+ "注意：进行多对一回放时，若 *inputTables* 为数据源，各数据源 size 以及其 *dateColumn* 列对应的时间范围必须保持一致。",
68345
+ "",
68346
+ "如需终止回放，使用 :doc:`../../CommandsReferences/c/cancelJob` 和 :doc:`../../CommandsReferences/c/cancelConsoleJob` 命令可以终止回放。",
68347
+ ""
68348
+ ]
68349
+ }
68350
+ ]
68351
+ },
67843
68352
  {
67844
68353
  "title": "参数",
67845
68354
  "type": "parameters",
@@ -67847,60 +68356,42 @@
67847
68356
  {
67848
68357
  "type": "text",
67849
68358
  "value": [
67850
- "`inputTables` 是一个未分区的内存表或 :doc:`replayDS` 函数生成的数据源。",
68359
+ "`inputTables` 是未分区的内存表或 :doc:`replayDS` 函数生成的数据源。",
67851
68360
  "",
67852
- "* 如果 *inputTables* 是单个或多个结构相同的表对象或数据源， 则用标量或元组表示。",
67853
- "* 如果 *inputTables* 是多个结构不同的表对象或数据源，则用字典表示。字典的 key 是用户自定义的字符串，表示输入表的唯一标识，value 是表对象或数据源。",
68361
+ "* 如果 *inputTables* 是单个或多个结构相同的表对象或数据源， 用标量或元组表示。",
68362
+ "* 如果 *inputTables* 是多个结构不同的表对象或数据源，用字典表示。字典的 key 是用户自定义的字符串，表示输入表或数据源的唯一标识，value 是表对象或数据源。",
67854
68363
  "",
67855
- "`outputTables` 内存表或流数据表对象。若输出表是共享表，也可以指定为共享表的表名。根据回放形式的不同（参考详情部分的说明），*outputTables* 的取值有所区别：",
68364
+ "`outputTables` 是内存表或流数据表对象。若输出表是共享表，可以指定为共享表的表名。根据回放形式的不同，*outputTables* 的取值有所区别：",
67856
68365
  "",
67857
- "\\（1）一对一回放、同构回放时，outputTables 是一个标量 ；输出表的 schema 必须与输入表的 schema 相同。",
68366
+ "\\（1）一对一回放或 N 对一同构回放时，*outputTables* 是一个表对象或字符串标量，必须与输入表的 schema 相同。",
67858
68367
  "",
67859
- "\\（2）多对多回放，outputTables 是一个向量或元组，且它的长度必须与 inputTables 相同。输出表和输入表两两对应，对应的两表的 schema 必须相同。",
68368
+ "\\（2）N 对 N 回放，outputTables 是字符串向量或表单对象组成的元组，且它的长度必须与 inputTables 相同。输出表和输入表一一对应，且表的 schema 必须相同。",
67860
68369
  "",
67861
- "\\（3）异构回放时 outputTables 是一个标量，至少包含三列：",
68370
+ "\\（3）N 对一异构回放时 outputTables 是一个标量，至少包含三列：",
67862
68371
  "",
67863
- " * 第一列用于存储时间戳，为 dateColumn 和 timeColumn 指定的回放时间；",
67864
- " * 第二列为 SYMBOL 或 STRING 类型，对应 inputTables 字典的 key；",
67865
- " * 第三列必须指定为 BLOB 类型，用于存储被回放的每条记录序列化后的结果。",
68372
+ " * 第一列为 *dateColumn* 和 *timeColumn* 指定的回放时间的时间戳；",
68373
+ " * 第二列为 SYMBOL 或 STRING 类型，对应 *inputTables* 字典的 key；",
68374
+ " * 第三列为 BLOB 类型，用于存储被回放的每条记录序列化后的结果。",
67866
68375
  "",
67867
- "此外，还支持指定输出各输入表的公共列（列名和类型一致的列）。",
68376
+ "此外，可输出各输入表的公共列（列名和类型一致的列）。",
67868
68377
  "",
67869
- "`dateColumn` 和 `timeColumn` 表示时间列的列名。必须至少指定其中一列。根据回放形式的不同（参考详情部分的说明），dateColumn 和 timeColumn 的取值有所区别：",
68378
+ "`dateColumn` 和 `timeColumn` 为时间列的列名，至少指定其中一个参数。根据回放形式的不同，*dateColumn* 和 *timeColumn* 的取值有所区别：",
67870
68379
  "",
67871
- "* 一对一回放、同构回放时，由于输入输出表的所有时间列的列名必须相同，因此可以指定为字符串标量；",
67872
- "* 输入表时间列的列名不同：",
68380
+ "* 一对一回放或 N 对一同构回放: 输入表与输出表的时间列列名必须相同，指定为字符串标量；",
68381
+ "* N 对 N 回放：输入表时间列的列名不同，指定为字符串向量；",
68382
+ "* N 对一异构回放：输入表时间列的列名不同，指定为字典，其中 key 为输入表的唯一标识符，value 是对应表时间列的列名。",
67873
68383
  "",
67874
- " * 多对多回放：可以指定为字符串向量；",
67875
- " * 异构回放：可以指定为一个字典，其中 key 为输入表的标识符，value 是对应表时间列的列名。",
68384
+ "只指定 *dateColumn* 或 *timeColumn* 中的一个参数，或者 *dateColumn* 和 *timeColumn* 指定为同一列时，对指定的时间列的类型没有限制。",
67876
68385
  "",
67877
- "只指定 *dateColumn* 或 *timeColumn* 中的一个参数，或者 *dateColumn* 和 *timeColumn* 指定为同一列时，对指定的时间列的类型没有限制。若指定 *dateColumn* 和 *timeColumn* 为不同列，*dateColumn* 必须是 DATE 类型，*timeColumn* 只能是 SECOND, TIME 或 NANOTIME 类型。",
68386
+ "若指定 *dateColumn* 和 *timeColumn* 为不同列，*dateColumn* 必须是 DATE 类型，*timeColumn* 只能是 SECOND, TIME 或 NANOTIME 类型。",
67878
68387
  "",
67879
68388
  "`replayRate` 整数，和参数 *absoluteRate* 共同决定了回放的速率。 ",
67880
68389
  "",
67881
68390
  "`absoluteRate` 布尔值。默认值为 true，表示每秒按 *replayRate* 指定的记录数回放。若为 false，表示依照数据中的时间戳加速 *replayRate* 倍回放。",
67882
68391
  "",
67883
- "`parallelLevel` 正整数，表示将数据从数据源加载到内存的工作线程数量，默认值为1。如果 *inputTables* 不是数据源，无需指定该参数。"
67884
- ]
67885
- }
67886
- ]
67887
- },
67888
- {
67889
- "title": "详情",
67890
- "type": "detail",
67891
- "children": [
67892
- {
67893
- "type": "text",
67894
- "value": [
67895
- "按照给定的回放模式，按时间顺对数据进行回放。",
67896
- "",
67897
- "根据输入表和输出表的映射关系（map），``replay`` 支持一对一，多对一，多对多三种回放形式。",
67898
- "",
67899
- "对于多对一回放，1.30.17 / 2.00.5 版本前，输入表结构必须相同，称为同构回放。该版本后，replay 支持以字典的形式输入结构不同的表，称为异构回放。",
67900
- "",
67901
68392
  "根据不同的场景需求，replay 提供以下三种回放模式：",
67902
68393
  "",
67903
- "- 匀速回放：如果 *replayRate* 为正整数，且 *absoluteRate* 为 true，则回放的速率基于记录数计算，按照每秒 *replayRate* 条记录进行回放。假设输入表的总记录条数为 total（多表回放时以记录数最多的表为基准），那么回放该表所需的时间大致为 total/replayRate 秒。",
68394
+ "- 匀速回放：如果 *replayRate* 为正整数，且 *absoluteRate* 为 true，则回放的速率基于记录数计算，按照每秒 *replayRate* 条记录进行回放。假设输入表的总记录条数为 total（多表回放时为所有表的总记录数），那么回放该表所需的时间大致为 total/replayRate 秒。",
67904
68395
  "",
67905
68396
  "- 倍速回放：如果 *replayRate* 为正整数，并且 *absoluteRate* 为 false，则将输入表中的数据按照时间加速 *replayRate* 倍回放。假设输入表中 *dateColumn* 或 *timeColumn* 的最大时间戳和最小时间戳相差 n 秒，数据总数为 s，则系统每秒回放 replayRate*s/n 条记录（每秒至少回放 1 条），即回放时间大致为 n/replayRate 秒。",
67906
68397
  "",
@@ -67908,13 +68399,8 @@
67908
68399
  "",
67909
68400
  "上述回放耗时主要基于同构回放估算，异构回放的耗时开销会略高于上述估算的回放耗时。",
67910
68401
  "",
67911
- "如需回放历史数据， 可通过 :doc:`replayDS` 函数直接生成数据源来作为 ``replay`` 的输入。",
67912
- "",
67913
- "注意：进行多对一回放时，若 *inputTables* 为数据源，各数据源 size 以及其 *dateColumn* 列对应的时间范围必须保持一致。",
67914
- "",
67915
- "异构回放时，replay 的输出结果可以通过 :doc:`../s/streamFilter` 进行反序列化，并进行数据过滤和分离，详情请参考 :doc:`../s/streamFilter`。 ",
67916
- "",
67917
- "使用 :doc:`../../CommandsReferences/c/cancelJob` 和 :doc:`../../CommandsReferences/c/cancelConsoleJob` 命令可以终止回放。"
68402
+ "`parallelLevel` 正整数，表示从数据源加载数据到内存的工作线程数量，默认值为 1。如果 *inputTables* 不是数据源，无需指定该参数。",
68403
+ ""
67918
68404
  ]
67919
68405
  }
67920
68406
  ]
@@ -70909,7 +71395,7 @@
70909
71395
  "value": [
70910
71396
  "rowImax(args...)",
70911
71397
  "",
70912
- "row 系列函数通用参数说明和计算规则请参考: :doc:`/FunctionsandCommands/SeriesOfFunctions/rowFunctions`",
71398
+ "row 系列函数通用参数说明和计算规则请参考：:doc:`/FunctionsandCommands/SeriesOfFunctions/rowFunctions`",
70913
71399
  ""
70914
71400
  ]
70915
71401
  }
@@ -70947,7 +71433,7 @@
70947
71433
  " $ insert into trades values(2022.01.01T09:00:00, `A, 31.2, 32.6, 33.6, 35.3, 34.5, 220, 160, 130, 100, 110)",
70948
71434
  " $ insert into trades values(2022.01.01T09:00:00, `A, 30.2, 32.5, 33.6, 35.3, 34.1, 200, 180, 150, 140, 120)",
70949
71435
  " $ insert into trades values(2022.01.01T09:00:00, `A, 33.2, 33.8, 33.6, 33.3, 33.1, 180, 160, 160, 180, 200)",
70950
- " $ select rowAt(matrix(p1, p2, p3, p4, p5), rowImin(vol1, vol2, vol3, vol4, vol5)) as price from trades",
71436
+ " $ select rowAt(matrix(p1, p2, p3, p4, p5), rowImax(vol1, vol2, vol3, vol4, vol5)) as price from trades",
70951
71437
  ""
70952
71438
  ]
70953
71439
  },
@@ -70991,7 +71477,7 @@
70991
71477
  "value": [
70992
71478
  "rowImin(args...)",
70993
71479
  "",
70994
- "row 系列函数通用参数说明和计算规则请参考: :doc:`/FunctionsandCommands/SeriesOfFunctions/rowFunctions`",
71480
+ "row 系列函数通用参数说明和计算规则请参考：:doc:`/FunctionsandCommands/SeriesOfFunctions/rowFunctions`",
70995
71481
  ""
70996
71482
  ]
70997
71483
  }
@@ -73796,7 +74282,7 @@
73796
74282
  {
73797
74283
  "type": "text",
73798
74284
  "value": [
73799
- "把一张表保存为本地磁盘数据库中的分区表。在用 *savePartition* 保存之前，要用 :doc:`../../FunctionReferences/c/createPartitionedTable` 先创建空的分区表。"
74285
+ "把一张表保存为分布式数据库中的分区表。在用 *savePartition* 保存之前，要用 :doc:`../../FunctionReferences/c/createPartitionedTable` 先创建空的分区表。"
73800
74286
  ]
73801
74287
  }
73802
74288
  ]
@@ -73815,13 +74301,13 @@
73815
74301
  " $ value=rand(1.0, n)",
73816
74302
  " $ t=table(ID, value);",
73817
74303
  "",
73818
- " $ db=database(\"C:/DolphinDB/Data/rangedb_Trades\", RANGE, 0 5 10)",
74304
+ " $ db=database(\"dfs://rangedb_Trades\", RANGE, 0 5 10)",
73819
74305
  " $ Trades = db.createPartitionedTable(t, \"Trades\", \"ID\");",
73820
74306
  " $ savePartition(db, t, `Trades)",
73821
74307
  "",
73822
74308
  " $ Trades=loadTable(db, `Trades)",
73823
74309
  " $ select count(value) from Trades;",
73824
- " 1000000",
74310
+ " 1,000,000",
73825
74311
  ""
73826
74312
  ]
73827
74313
  },
@@ -73846,7 +74332,7 @@
73846
74332
  " $ savePartition(db, t1, `Trades)",
73847
74333
  " $ Trades=loadTable(db, `Trades)",
73848
74334
  " $ select count(value) from Trades;",
73849
- " 1500000"
74335
+ " 1,500,000"
73850
74336
  ]
73851
74337
  }
73852
74338
  ]
@@ -73896,7 +74382,10 @@
73896
74382
  {
73897
74383
  "type": "text",
73898
74384
  "value": [
73899
- "将一个表保存在未分区的本地磁盘表中。如果要把表保存至分区数据库中，需要先使用 :doc:`../../FunctionReferences/c/createPartitionedTable` 函数创建分区表，再使用 :doc:`../../FunctionReferences/a/append!` 函数或 :doc:`../../FunctionReferences/t/tableInsert` 函数把数据保存至分区表中。"
74385
+ "将一个表保存在未分区的本地磁盘表中。如果要把表保存至分区数据库中，需要先使用 :doc:`../../FunctionReferences/c/createPartitionedTable` ",
74386
+ "函数创建分区表，再使用 :doc:`../../FunctionReferences/a/append!` 函数或 :doc:`../../FunctionReferences/t/tableInsert` 函数把数据保存至分区表中。",
74387
+ "",
74388
+ "注意：磁盘表仅应用于备份数据和本地计算的场景，其相较于分布式表，在使用上具有一定局限，例如不能进行权限控制等。"
73900
74389
  ]
73901
74390
  }
73902
74391
  ]
@@ -74827,7 +75316,7 @@
74827
75316
  {
74828
75317
  "type": "text",
74829
75318
  "value": [
74830
- "`X` 可以是整数标量或向量、时间标量或向量。"
75319
+ "`X` 可以是整数/时间类型/字符串类型的标量或向量。"
74831
75320
  ]
74832
75321
  }
74833
75322
  ]
@@ -74858,6 +75347,10 @@
74858
75347
  "",
74859
75348
  " $ second(61);",
74860
75349
  " 00:01:01",
75350
+ "",
75351
+ " $ second(\"09:00:01\") ",
75352
+ " 09:00:01",
75353
+ " ",
74861
75354
  ""
74862
75355
  ]
74863
75356
  },
@@ -76373,7 +76866,7 @@
76373
76866
  "value": [
76374
76867
  "在线修改单次查询结果占用的最大内存上限。该命令只能由管理员在数据节点/计算节点执行。",
76375
76868
  "",
76376
- "相关函数： :doc:`/FunctionsandCommands/FunctionReferences/g/getMemLimitOfTaskGroupResult`"
76869
+ "相关函数： :doc:`/FunctionsandCommands/FunctionReferences/g/getMemLimitOfQueryResult`"
76377
76870
  ]
76378
76871
  }
76379
76872
  ]
@@ -76417,7 +76910,7 @@
76417
76910
  "value": [
76418
76911
  "在线修改当前节点发送的批量子查询占用的内存上限。该命令只能由管理员在数据节点/计算节点执行。",
76419
76912
  "",
76420
- "相关函数： :doc:`/FunctionsandCommands/FunctionReferences/g/getMemLimitOfQueryResult`"
76913
+ "相关函数： :doc:`/FunctionsandCommands/FunctionReferences/g/getMemLimitOfTaskGroupResult`"
76421
76914
  ]
76422
76915
  }
76423
76916
  ]
@@ -80451,7 +80944,7 @@
80451
80944
  {
80452
80945
  "type": "text",
80453
80946
  "value": [
80454
- "相关函数：:doc:`../c/cumstd`"
80947
+ "相关函数：:doc:`std`, :doc:`../c/cumstd`"
80455
80948
  ]
80456
80949
  }
80457
80950
  ]
@@ -80549,7 +81042,7 @@
80549
81042
  {
80550
81043
  "type": "text",
80551
81044
  "value": [
80552
- "相关函数：:doc:`../c/cumstdp`"
81045
+ "相关函数：:doc:`std`, :doc:`../c/cumstdp`"
80553
81046
  ]
80554
81047
  }
80555
81048
  ]
@@ -81263,7 +81756,7 @@
81263
81756
  "* 'condition'：表示过滤条件。",
81264
81757
  "",
81265
81758
  " * 若分发异构流表，则 'condition' 是一个字符串，且必须是 replay 参数 *inputTables* 的键值（表的标识）。用于过滤出异构表中具有 *condition* 标识的数据。",
81266
- " * 若分发普通流表，则 'condition' 可以是一个表示列名的字符串标量或/向量，或者是包含一个或多个布尔表达式的元代码，且表达式中不能调用函数。请注意，若 'condition' 指定为字符串标量/向量，必须为 *conditionColumn* 指定列的元素。",
81759
+ " * 若分发普通流表，则 'condition' 可以是一个表示列名的字符串标量/向量，或者是包含一个或多个布尔表达式的元代码，且表达式中不能调用函数。请注意，若 'condition' 指定为字符串标量/向量，必须为 *conditionColumn* 指定列的元素。",
81267
81760
  "",
81268
81761
  "* 'handler'：一元函数或表对象（包括流数据引擎返回的表对象）。",
81269
81762
  "",
@@ -82654,7 +83147,7 @@
82654
83147
  "value": [
82655
83148
  "从客户端节点订阅本地或远程服务器的流数据表。可在 *handler* 调用函数来处理订阅数据。",
82656
83149
  "",
82657
- "返回一个订阅主题(topic)，即一个订阅的名称。它是一个字符串，由订阅表所在节点的别名、流数据表名称和订阅任务名称（如果指定了 actionName）组合而成，使用下划线分隔。如果订阅主题已经存在，函数将会抛出异常。",
83150
+ "返回一个订阅主题(topic)，即一个订阅的名称。它是一个字符串，由订阅表所在节点的别名、流数据表名称和订阅任务名称（如果指定了 actionName）组合而成，使用 \"/\" 分隔。如果订阅主题已经存在，函数将会抛出异常。",
82658
83151
  "",
82659
83152
  "* 如果指定了 *batchSize*，当未处理消息数量达到 *batchSize* 或距离上次 *handler* 被触发已过去 *throttle* 秒，*handler* 将会被触发。",
82660
83153
  "",
@@ -82674,7 +83167,7 @@
82674
83167
  {
82675
83168
  "type": "text",
82676
83169
  "value": [
82677
- "subscribeTable([server],tableName,[actionName],[offset=-1],handler,[msgAsTable=false],[batchSize=0],[throttle=1],[hash=-1],[reconnect=false],[filter],[persistOffset=false],[timeTrigger=false],[handlerNeedMsgId=false],[raftGroup=-1],[userId=\"\"],[password=\"\"])",
83170
+ "subscribeTable([server],tableName,[actionName],[offset=-1],handler,[msgAsTable=false],[batchSize=0],[throttle=1],[hash=-1],[reconnect=false],[filter],[persistOffset=false],[timeTrigger=false],[handlerNeedMsgId=false],[raftGroup],[userId=\"\"],[password=\"\"])",
82678
83171
  ""
82679
83172
  ]
82680
83173
  }
@@ -88519,7 +89012,7 @@
88519
89012
  "value": [
88520
89013
  "tmsum2(T, X, window)",
88521
89014
  "",
88522
- "参数说明和窗口计算规则请参考: :doc:`/FunctionsandCommands/SeriesOfFunctions/tmFunctions`"
89015
+ "参数说明和窗口计算规则请参考：:doc:`/FunctionsandCommands/SeriesOfFunctions/tmFunctions`"
88523
89016
  ]
88524
89017
  }
88525
89018
  ]
@@ -89549,7 +90042,7 @@
89549
90042
  "language": "console",
89550
90043
  "value": [
89551
90044
  "",
89552
- " //模拟股票 A 8天的股价,使用 topRange 计算股票 A 每日股价创几日新高",
90045
+ " //模拟股票 A 8天的股价，使用 topRange 计算股票 A 当日股价创几日新高",
89553
90046
  " $ trades = table(take(`A, 8) as sym, 2022.01.01 + 1..8 as date, 39.70 39.72 39.80 39.78 39.83 39.92 40.00 40.03 as price)",
89554
90047
  " $ select *, topRange(price) from trades",
89555
90048
  ""
@@ -92402,10 +92895,10 @@
92402
92895
  "",
92403
92896
  "`mode` 字符串，可选值为：\"prev\", \"next\", \"any\" 和 \"all\"，默认值为 \"prev\"。",
92404
92897
  "",
92405
- "* \"prev\": 前一个元素。",
92406
- "* \"next\": 后一个元素。",
92407
- "* \"any\": 前一个元素或后一个元素。",
92408
- "* \"all\": 前一个元素和后一个元素值。"
92898
+ "* \"prev\"：前一个元素。",
92899
+ "* \"next\"：后一个元素。",
92900
+ "* \"any\"：前一个元素或后一个元素。",
92901
+ "* \"all\"：前一个元素和后一个元素值。"
92409
92902
  ]
92410
92903
  }
92411
92904
  ]
@@ -92417,7 +92910,7 @@
92417
92910
  {
92418
92911
  "type": "text",
92419
92912
  "value": [
92420
- "*X* 中每个元素较 *mode* 是否发生变化，若当前元素值发生变化，则返回 true，否则返回 false。若比较对象不存在，则返回 false。例如：valueChanged(X, [mode=”prev“]) 的第一个元素返回 false；valueChanged(X, [mode=”next“]) 的最后一个元素返回 false。",
92913
+ "*X* 中每个元素较 *mode* 是否发生变化，若当前元素值发生变化，则返回 true，否则返回 false。若比较对象不存在，则返回 false。例如：valueChanged(X, [mode=\"prev\"]) 的第一个元素返回 false；valueChanged(X, [mode=\"next\"]) 的最后一个元素返回 false。",
92421
92914
  "",
92422
92915
  "若 *X* 为矩阵/表，在每列内进行上述操作，返回一个矩阵/表。"
92423
92916
  ]
@@ -92904,7 +93397,7 @@
92904
93397
  " $ volume=rand(100, n)",
92905
93398
  " $ table1 = table(date, sym, price, volume)",
92906
93399
  " $ outputTable = table(n:0, `sym`factor1, [STRING,DOUBLE])",
92907
- " $ engine = createReactiveStateEngine(\"test\", <ema(qty, 40)>, table1, outputTable, \"sym\")",
93400
+ " $ engine = createReactiveStateEngine(\"test\", <ema(volume, 40)>, table1, outputTable, \"sym\")",
92908
93401
  " $ warmupStreamEngine(engine, table1)",
92909
93402
  " $ date=take(2021.03.09, n)",
92910
93403
  " $ sym=take(\"A\"+string(1..3000), n)",
@@ -92929,7 +93422,7 @@
92929
93422
  {
92930
93423
  "type": "text",
92931
93424
  "value": [
92932
- "wavg(value, weight)"
93425
+ "wavg(X, Y)"
92933
93426
  ]
92934
93427
  }
92935
93428
  ]
@@ -92941,7 +93434,7 @@
92941
93434
  {
92942
93435
  "type": "text",
92943
93436
  "value": [
92944
- "`value` 与 `weight` 是向量、矩阵或表。*weight* 表示权重。"
93437
+ "`X` 与 `Y` 是向量、矩阵或表。*Y* 表示权重。"
92945
93438
  ]
92946
93439
  }
92947
93440
  ]
@@ -92953,9 +93446,9 @@
92953
93446
  {
92954
93447
  "type": "text",
92955
93448
  "value": [
92956
- "对 *value*，以 *weight* 为权重，计算其加权平均数。",
93449
+ "对 *X*，以 *Y* 为权重，计算其加权平均数。",
92957
93450
  "",
92958
- "请注意，权重向量会自动调整，使得 *value* 向量中非 Null 之值对应的权重向量之和为1。"
93451
+ "请注意，权重向量会自动调整，使得 *X* 向量中非 NULL 之值对应的权重向量之和为1。"
92959
93452
  ]
92960
93453
  }
92961
93454
  ]
@@ -93062,7 +93555,7 @@
93062
93555
  {
93063
93556
  "type": "text",
93064
93557
  "value": [
93065
- "wcovar(X, Y, weights)"
93558
+ "wcovar(X, Y, W)"
93066
93559
  ]
93067
93560
  }
93068
93561
  ]
@@ -93074,9 +93567,9 @@
93074
93567
  {
93075
93568
  "type": "text",
93076
93569
  "value": [
93077
- "`X`, `Y` 和 `weights` 是相同长度的数值型向量。",
93570
+ "`X`, `Y` 和 `W` 是相同长度的数值型向量。",
93078
93571
  "",
93079
- "*weights* 表示权重。它不能包含NULL值。"
93572
+ "*W* 表示权重。它不能包含NULL值。"
93080
93573
  ]
93081
93574
  }
93082
93575
  ]
@@ -94801,6 +95294,74 @@
94801
95294
  }
94802
95295
  ]
94803
95296
  },
95297
+ "wsum2": {
95298
+ "title": "wsum2",
95299
+ "type": "function",
95300
+ "children": [
95301
+ {
95302
+ "title": "语法",
95303
+ "type": "grammer",
95304
+ "children": [
95305
+ {
95306
+ "type": "text",
95307
+ "value": [
95308
+ "wsum2(X, Y)"
95309
+ ]
95310
+ }
95311
+ ]
95312
+ },
95313
+ {
95314
+ "title": "参数",
95315
+ "type": "parameters",
95316
+ "children": [
95317
+ {
95318
+ "type": "text",
95319
+ "value": [
95320
+ "`X` 和 `Y` 可以是标量、向量、矩阵或表。"
95321
+ ]
95322
+ }
95323
+ ]
95324
+ },
95325
+ {
95326
+ "title": "详情",
95327
+ "type": "detail",
95328
+ "children": [
95329
+ {
95330
+ "type": "text",
95331
+ "value": [
95332
+ "返回 *X* 和 *Y* 的加权平方和。即使 *X* 和 *Y* 都是整型，返回结果仍为 DOUBLE 类型。"
95333
+ ]
95334
+ }
95335
+ ]
95336
+ },
95337
+ {
95338
+ "title": "例子",
95339
+ "type": "example",
95340
+ "children": [
95341
+ {
95342
+ "type": "code",
95343
+ "language": "console",
95344
+ "value": [
95345
+ "",
95346
+ " $ wsum2(3 4 1, 1 2 3);",
95347
+ " 44",
95348
+ " // 9*1 + 16*2 + 1*3 = 44",
95349
+ ""
95350
+ ]
95351
+ },
95352
+ {
95353
+ "type": "text",
95354
+ "value": [
95355
+ "相关函数：:doc:`wsum`",
95356
+ "",
95357
+ ".. meta:: ",
95358
+ " :keywords: sum2"
95359
+ ]
95360
+ }
95361
+ ]
95362
+ }
95363
+ ]
95364
+ },
94804
95365
  "xdb": {
94805
95366
  "title": "xdb",
94806
95367
  "type": "function",
@@ -95431,7 +95992,7 @@
95431
95992
  {
95432
95993
  "type": "text",
95433
95994
  "value": [
95434
- "`HL` 数值向量或者包含两列的数值矩阵。",
95995
+ "`HL` 数值向量或者矩阵。请注意，若 *HL* 为矩阵，则其行数不能少于2行，列数不能超过2列。",
95435
95996
  "",
95436
95997
  "`change` 极值波动的最小阈值。 ",
95437
95998
  "",