dolphindb 2.0.602 → 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 (13) hide show
  1. package/README.md +1 -0
  2. package/browser.d.ts +109 -17
  3. package/browser.js +389 -183
  4. package/browser.js.map +1 -1
  5. package/docs.en.json +2046 -552
  6. package/docs.zh.json +1311 -737
  7. package/index.d.ts +114 -18
  8. package/index.js +406 -196
  9. package/index.js.map +1 -1
  10. package/language.d.ts +2 -2
  11. package/language.js +5 -3
  12. package/language.js.map +1 -1
  13. 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
  ]
@@ -1382,7 +1389,7 @@
1382
1389
  "value": [
1383
1390
  "增加数据节点或计算节点。新增加的节点为关闭状态，需要通过Web集群管理器或命令行启动。",
1384
1391
  "",
1385
- "注意，如果要在新的服务器上增加节点，要先部署代理节点。详情请参考教程 `多服务器集群部署 <https://gitee.com/dolphindb/Tutorials_CN/blob/master/multi_machine_cluster_deploy.md>`_ 。"
1392
+ "注意，如果要在新的服务器上增加节点，要先部署代理节点。详情请参考教程 `多服务器集群部署 <https://gitee.com/dolphindb/Tutorials_CN/blob/master/%E5%AE%89%E8%A3%85%E5%92%8C%E9%83%A8%E7%BD%B2/multi_machine_cluster_deployment.md>`_ 。"
1386
1393
  ]
1387
1394
  }
1388
1395
  ]
@@ -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
  ]
@@ -8530,7 +8540,7 @@
8530
8540
  {
8531
8541
  "type": "text",
8532
8542
  "value": [
8533
- "`X` 可以是向量、矩阵、集合、字典。"
8543
+ "`X` 可以是向量、矩阵、集合、字典、内存表。"
8534
8544
  ]
8535
8545
  }
8536
8546
  ]
@@ -8577,7 +8587,10 @@
8577
8587
  " 3->6",
8578
8588
  " 1->4",
8579
8589
  " 2->5",
8580
- " $ z.clear!();"
8590
+ " $ z.clear!();",
8591
+ "",
8592
+ " $ t = table(1 2 3 as id, 1.0 2.0 3.0 as value)",
8593
+ " $ t.clear!()"
8581
8594
  ]
8582
8595
  }
8583
8596
  ]
@@ -11520,7 +11533,62 @@
11520
11533
  {
11521
11534
  "type": "text",
11522
11535
  "value": [
11523
- "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
+ ""
11524
11592
  ]
11525
11593
  }
11526
11594
  ]
@@ -11532,18 +11600,21 @@
11532
11600
  {
11533
11601
  "type": "text",
11534
11602
  "value": [
11535
- "`name` 是一个字符串，表示异常检测引擎的名称，是异常检测的唯一标识。它可以包含字母，数字和下划线，但必须以字母开头。",
11603
+ ".. _name_ad:",
11604
+ "",
11605
+ "`name` 字符串标量，表示异常检测引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
11606
+ "",
11607
+ ".. _metrics_ad:",
11536
11608
  "",
11537
- "`metrics` 是元代码或元组，表示异常指标，每个异常指标的返回值必须是 BOOL 类型，如<[sum(qty) > 5, avg(qty) > qty, qty < 4]>。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
11609
+ "`metrics` 以元代码或元组的格式表示异常指标，每个异常指标必须是布尔表达式，如<[sum(qty) > 5, avg(qty) > qty, qty < 4]>。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
11538
11610
  "",
11539
- "异常检测引擎不支持在 *metrics* 中使用以下函数：",
11611
+ ".. _dummyTable_ad:",
11540
11612
  "",
11541
- "* 序列相关函数：next, talibNull, linearTimeTrend, iterate",
11542
- "* 内部嵌套聚合函数，如：tmsum(sum())",
11613
+ "`dummyTable` 一个表对象，该表的唯一作用是为引擎提供订阅的流数据表的 schema，可以含有数据，亦可为空表。",
11543
11614
  "",
11544
- "`dummyTable` 是一个表对象，该表的唯一作用是为引擎提供订阅的流数据表的 schema，可以含有数据，亦可为空表。",
11615
+ ".. _outputTable_ad:",
11545
11616
  "",
11546
- "`outputTable` 是表对象，用于保存计算结果，可以是内存表或者分布式表。",
11617
+ "`outputTable` 计算结果的输出表，可以是内存表或分布式表。在调用 ``createAnomalyDetectionEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。异常检测引擎会将计算结果注入该表。",
11547
11618
  "",
11548
11619
  "输出表的各列的顺序为：时间列，分组列，异常类型列 type，异常条件列 metric。",
11549
11620
  "",
@@ -11555,21 +11626,33 @@
11555
11626
  "",
11556
11627
  "\\(3) 之后两列分别为 INT 类型和 STRING / SYMBOL 类型，用于记录异常的类型（在 *metrics* 中的下标）和异常条件的内容。",
11557
11628
  "",
11558
- "`timeColumn` 是字符串标量，表示输入流数据表的时间列名称。",
11629
+ ".. _timeColumn_ad:",
11559
11630
  "",
11560
- "`keyColumn` 是字符串标量，表示分组列。异常检测引擎会按照 *keyColumn* 对输入的数据分组，并在每组中进行运算。它是可选参数。",
11631
+ "`timeColumn` 字符串标量，该参数用于指定订阅的流数据表中时间列的名称。",
11561
11632
  "",
11562
- "`windowSize` 是正整数。如果 *metrics* 中包含聚合函数，必须指定 *windowSize*，它表示计算的数据窗口的长度，数据窗口只包含上边界不包含下边界。如果 *metrics* 中不包含聚合函数，该参数无效。",
11633
+ ".. _keyColumn_ad:",
11563
11634
  "",
11564
- "`step` 是正整数。如果 *metrics* 中包含聚合函数，必须指定 *step*，并且必须能够被 *windowSize* 整除，它表示计算的时间间隔。如果 *metrics* 中不包含聚合函数，该参数无效。",
11635
+ "`keyColumn` 可选参数，字符串标量，表示分组列名。异常检测引擎会按照 *keyColumn* 对输入的数据分组，并计算将在各分组分别进行。",
11565
11636
  "",
11566
- "为了便于观察和对比计算结果，系统会对第一个数据窗口的起始时间进行调整。调整规则与 :doc:`createTimeSeriesEngine` 相同。",
11637
+ ".. _windowSize_ad:",
11638
+ "",
11639
+ "`windowSize` 可选参数，正整数。如果 *metrics* 中包含聚合函数，必须指定 *windowSize*，它表示计算的数据窗口的长度，数据窗口只包含上边界不包含下边界。如果 *metrics* 中不包含聚合函数，该参数无效。",
11640
+ "",
11641
+ ".. _step_ad:",
11642
+ "",
11643
+ "`step` 可选参数，正整数。如果 *metrics* 中包含聚合函数，必须指定 *step*，并且必须能够被 *windowSize* 整除，它表示计算的时间间隔。如果 *metrics* 中不包含聚合函数，该参数无效。",
11567
11644
  "",
11568
- "`garbageSize` 是正整数。它是可选参数，默认值是2,000（单位为行）。如果没有指定 *keyColumn*，当内存中历史数据的数量超过 *garbageSize* 时，系统会清理本次计算不需要的历史数据。如果指定了 *keyColumn*，意味着需要分组计算时，内存清理是各分组独立进行的。当一个组的历史数据记录数超出 *garbageSize* 时，会清理该组不再需要的历史数据。若一个组的历史数据记录数未超出 *garbageSize*，则该组数据不会被清理。如果 *metrics* 中没有聚合函数，这个参数不起作用。",
11645
+ ".. _garbageSize_ad:",
11646
+ "",
11647
+ "`garbageSize` 可选参数，正整数。它是可选参数，默认值是 2,000（单位为行）。如果没有指定 *keyColumn*，当内存中历史数据的数量超过 *garbageSize* 时，系统会清理本次计算不需要的历史数据。如果指定了 *keyColumn*，意味着需要分组计算时，内存清理是各分组独立进行的。当一个组的历史数据记录数超出 *garbageSize* 时，会清理该组不再需要的历史数据。若一个组的历史数据记录数未超出 *garbageSize*，则该组数据不会被清理。如果 *metrics* 中没有聚合函数，这个参数不起作用。",
11648
+ "",
11649
+ ".. _roundTime_ad:",
11650
+ "",
11651
+ "`roundTime` 可选参数，布尔值，表示若数据时间精度为毫秒或者秒且 *step* > 一分钟，如何对窗口边界值进行规整处理。默认值为 true，表示按照既定的多分钟规则（见以上表格）进行规整。若为 false，则按一分钟规则（见以上表格）进行窗口规整（详情参考 :ref:`规整规则表 <alignment_ts>`）。",
11569
11652
  "",
11570
11653
  "若要开启快照机制 (snapshot)，必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。",
11571
11654
  "",
11572
- "启用快照机制之后，系统若出现异常，可及时将流数据引擎恢复到最新的快照状态。",
11655
+ ".. _snapshotDir_ad:",
11573
11656
  "",
11574
11657
  "`snapshotDir` 可选参数，字符串，表示保存引擎快照的文件目录。",
11575
11658
  "",
@@ -11582,29 +11665,13 @@
11582
11665
  " * 快照生成并刷到磁盘：文件保存为 <engineName>.snapshot；",
11583
11666
  " * 存在同名快照：旧快照自动重命名为 <engineName>.old。",
11584
11667
  "",
11585
- "`snapshotIntervalInMsgCount` 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。",
11586
- "",
11587
- "`raftGroup` 是流数据高可用订阅端 raft 组的 ID (大于1的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。"
11588
- ]
11589
- }
11590
- ]
11591
- },
11592
- {
11593
- "title": "详情",
11594
- "type": "detail",
11595
- "children": [
11596
- {
11597
- "type": "text",
11598
- "value": [
11599
- "创建异常检测引擎。返回一个表对象，向该表写入数据意味着这些数据进入异常检测引擎进行计算。",
11600
- "",
11601
- "异常检测引擎会根据不同类型的异常指标采用不同的计算规则。异常指标一般有以下三种类型：",
11668
+ ".. _snapshotIntervalInMsgCount_ad:",
11602
11669
  "",
11603
- "* 某个列与常量对比、列与列之间对比或非聚合函数中不包含聚合函数，例如 qty < 4, qty > price, lt(qty, prev(qty)), isNull(qty) == false 等。对于这类指标，异常检测引擎会对每一条数据进行计算，判断是否符合条件并决定输出。",
11670
+ "`snapshotIntervalInMsgCount` 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。",
11604
11671
  "",
11605
- "* 聚合函数的结果与某个常量值对比、聚合函数结果之间的对比、非聚合函数中仅包含聚合函数和常量，例如 avg(qty - price) > 10, percentile(qty, 90) < 100, sum(qty) > prev(sum(qty)), le(sum(qty), 5) 等。对于这类指标，异常检测引擎会在每个窗口计算时判断计算结果是否符合条件并决定输出。",
11672
+ ".. _raftGroup_ad:",
11606
11673
  "",
11607
- "* 聚合函数的结果与列对比、非聚合函数中同时包含聚合函数和列，例如 avg(qty) > qty, le(med(qty), price) 等。对于这类指标，每当数据到达时，异常检测引擎会将数据与上一个计算窗口的聚合结果对比，判断计算结果是否符合条件并决定输出，直到触发下一次聚合计算。"
11674
+ "`raftGroup` 是流数据高可用订阅端 raft 组的 ID (大于1的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。"
11608
11675
  ]
11609
11676
  }
11610
11677
  ]
@@ -11714,6 +11781,25 @@
11714
11781
  }
11715
11782
  ]
11716
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
+ },
11717
11803
  {
11718
11804
  "title": "参数",
11719
11805
  "type": "parameters",
@@ -11721,11 +11807,17 @@
11721
11807
  {
11722
11808
  "type": "text",
11723
11809
  "value": [
11724
- "`name` 必选参数，是一个字符串，表示流数据 asof join 引擎的名称。",
11810
+ ".. _name_aj:",
11725
11811
  "",
11726
- "`leftTable` 和 `rightTable` 是表对象。可以不包含数据，但结构必须与订阅的流数据表相同。",
11812
+ "`name` 字符串标量，表示 asof join 引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
11727
11813
  "",
11728
- "`outputTable` 必选参数，为计算结果的输出表。在使用 ``createAsofJoinEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。asof join 引擎会将计算结果插入该表。",
11814
+ ".. _table_aj:",
11815
+ "",
11816
+ "`leftTable` 和 `rightTable` 表对象。结构必须与订阅的流数据表相同。",
11817
+ "",
11818
+ ".. _outputTable_aj:",
11819
+ "",
11820
+ "`outputTable` 计算结果的输出表，可以是内存表或分布式表。在使用 ``createAsofJoinEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。asof join 引擎会将计算结果注入该表。",
11729
11821
  "",
11730
11822
  "输出表的各列的顺序为：时间列，连接列，计算结果列。",
11731
11823
  "",
@@ -11740,14 +11832,18 @@
11740
11832
  "",
11741
11833
  "\\(3) 最后为计算结果列，可为多列。",
11742
11834
  "",
11835
+ ".. _metrics_aj:",
11836
+ "",
11743
11837
  "`metrics` 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
11744
11838
  "",
11745
11839
  "* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数，但不能是聚合函数。",
11746
11840
  "* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 <func(price) as \\`col1\\`col2>。",
11747
11841
  "",
11748
- "请注意，若 *metrics* 中指定了左右表列名相同的时间列或者连接列，默认取左表中的列。如果需要取右表中的列，在列前加上右表名。例如：*matchingColumn* = \\`sym, *timeColumn* = \\`timestamp，则 *metrics* = <[rightTable.sym, rightTable.timestamp, price, val, price*val]> 指定 *metrics* 中输出右表的 sym 列和 timestamp 列。",
11842
+ "若 *metrics* 中指定了 *leftTable* 和 *rightTable* 中具有相同名称的列，可以通过 \"tableName.colName\" 指定该列来自哪个表。",
11749
11843
  "",
11750
- "`matchingColumn` 表示连接列的字符串标量/向量/tuple，支持 Integral, Temproal 或 Literal（UUID 除外）类型。",
11844
+ ".. _mc_aj:",
11845
+ "",
11846
+ "`matchingColumn` 表示连接列的字符串标量/向量/字符串组成的 tuple，支持 Integral, Temproal 或 Literal（UUID 除外）类型。",
11751
11847
  "",
11752
11848
  "*matchingColumn* 指定规则：",
11753
11849
  "",
@@ -11755,36 +11851,28 @@
11755
11851
  "",
11756
11852
  "\\2. 有多个连接列：当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串向量，否则是一个长度为 2 的 tuple，例如：左表连接列名为 orderNo, sym，右表连接列名为 orderNo, sym1，则 *matchingColumn* = [[\\`orderNo, \\`sym], [\\`orderNo,\\`sym1]]。",
11757
11853
  "",
11758
- "`timeColumn` 可选参数，当 *useSystemTime* = false 时，指定要连接的两个表中时间列的名称。 `leftTable` 和 `rightTable` 时间列名称可以不同，但数据类型需保持一致。当 `leftTable` 和 `rightTable` 时间列名称不同时，`timeColumn` 为一个长度为2的字符串向量。",
11854
+ ".. _tc_aj:",
11759
11855
  "",
11760
- "`useSystemTime` 可选参数，表示 *outputTable* 中第一列（时间列）为系统当前时间（*useSystemTime* = true）或左表的时间列（*useSystemTime* = false）。",
11856
+ "`timeColumn` 可选参数，字符串标量或向量。当 *useSystemTime* = false 时，指定要连接的两个表中时间列的名称。 `leftTable` 和 `rightTable` 时间列名称可以不同，但数据类型需保持一致。当 `leftTable` 和 `rightTable` 时间列名称不同时，`timeColumn` 为一个长度为2的字符串向量。",
11857
+ "",
11858
+ ".. _useSystemTime_aj:",
11859
+ "",
11860
+ "`useSystemTime` 可选参数，布尔值。表示是否使用数据注入引擎时的系统时间作为时间列进行计算。",
11761
11861
  "",
11762
11862
  "* 当 *useSystemTime* = true 时，按照数据进入引擎的时刻（毫秒精度的本地系统时间，与数据中的时间列无关）进行计算。",
11763
11863
  "",
11764
11864
  "* 当 *useSystemTime* = false（缺省值）时，按照数据中的时间列进行计算。请注意，触发计算的数据并不会参与该次计算。",
11765
11865
  "",
11766
- "`delayedTime` 可选参数，是正整数。要设置 *delayedTime*， *useSystemTime* 必须设为 false。",
11866
+ ".. _delayedTime_aj:",
11767
11867
  "",
11768
- "如果指定了 *delayedTime*，若左表中最新时间 t2 与上一条未计算的时间差大于 *delayedTime* 设置值，则 t2 这条记录可以直接触发左表和右表 join，或者左表中的数据在经过 2 * *delayedTime* （小于2秒按2秒计算）后还没有 join 输出，则直接触发 join。",
11868
+ "`delayedTime` 可选参数，正整数，单位同 timeColumn 精度一致。要设置 *delayedTime*， 必须指定 *timeColumn*。",
11769
11869
  "",
11770
- "`garbageSize` 可选参数，是正整数，默认值是5,000（单位为行）。随着订阅的流数据不断注入 asof join 引擎，存放在内存中的数据会越来越多，行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。"
11771
- ]
11772
- }
11773
- ]
11774
- },
11775
- {
11776
- "title": "详情",
11777
- "type": "detail",
11778
- "children": [
11779
- {
11780
- "type": "text",
11781
- "value": [
11782
- "创建流数据 asof join 引擎。返回一个左、右两表 :doc:`/SQLStatements/TableJoiners/asofjoin` 后的表对象。通常与 :doc:`../s/subscribeTable` 函数一起使用。",
11870
+ "如果指定了 *delayedTime*，若左表中最新到来的数据时间与左表之前未计算的数据时间差大于 *delayedTime* 设置值，则这条数据可以直接触发左表和右表 join，或左表中的数据在经过 2 \\* *delayedTime* （小于2秒按2秒计算）后还没有 join 输出，则直接触发 join。",
11783
11871
  "",
11784
- "* 如果没有指定 *delayedTime*，则当右表数据的最新时间大于左表数据的最新时间，才会触发 join, 计算输出。",
11785
- "* 如果指定了 *delayedTime*，则当左表中数据最新时间与上一条未计算的时间差大于 *delayedTime* 设置值，或者左表中数据在经过 2 \\* *delayedTime* （小于2秒按2秒计算）后还没有 join 输出，就直接触发左右两表 join。",
11872
+ ".. _garbageSize_aj:",
11786
11873
  "",
11787
- "从 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
+ ""
11788
11876
  ]
11789
11877
  }
11790
11878
  ]
@@ -11817,7 +11905,7 @@
11817
11905
  "",
11818
11906
  " $ sleep(1000)",
11819
11907
  "",
11820
- " $ select time, sym, price from prevailingQuotes order by time, sym",
11908
+ " $ select time, sym, bid from prevailingQuotes order by time, sym",
11821
11909
  ""
11822
11910
  ]
11823
11911
  },
@@ -11825,12 +11913,12 @@
11825
11913
  "type": "text",
11826
11914
  "value": [
11827
11915
  "======================= ======== ========",
11828
- "time sym price",
11916
+ "time sym bid",
11829
11917
  "======================= ======== ========",
11830
- "2020.08.27T09:30:00.002 A 20.01",
11831
- "2020.08.27T09:30:00.008 A 20.04",
11832
- "2020.08.27T09:30:00.020 A 20.07",
11833
- "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",
11834
11922
  "======================= ======== ========"
11835
11923
  ]
11836
11924
  }
@@ -11854,13 +11942,58 @@
11854
11942
  {
11855
11943
  "type": "text",
11856
11944
  "value": [
11857
- "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])",
11858
11946
  "",
11859
11947
  "别名：createCrossSectionalAggregator"
11860
11948
  ]
11861
11949
  }
11862
11950
  ]
11863
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
+ },
11864
11997
  {
11865
11998
  "title": "参数",
11866
11999
  "type": "parameters",
@@ -11868,52 +12001,91 @@
11868
12001
  {
11869
12002
  "type": "text",
11870
12003
  "value": [
11871
- "`name` 是一个字符串，表示横截面引擎的名称，是横截面引擎的唯一标识。它可以包含字母，数字和下划线，但必须以字母开头。",
12004
+ ".. _name_cs:",
12005
+ "",
12006
+ "`name` 字符串标量，表示横截面引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
12007
+ "",
12008
+ ".. _metrics_cs:",
11872
12009
  "",
11873
- "`metrics` 是元代码或元组。它可以是系统内置或用户自定义的函数，如 <[sum(qty), avg(price)]>，可以对计算结果使用表达式，如 <[avg(price1)-avg(price2)]>，也可以对多列进行运算，如 <[std(price1-price2)]>。*metrics* 内支持调用具有多个返回值的函数，例如 <func(price) as \\`col1\\`col2>（可不指定列名）。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
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>（可不指定列名）。",
11874
12014
  "",
11875
- "`dummyTable` 是一个表对象，该表的唯一作用是为引擎提供订阅的流数据表的 schema，可以含有数据，亦可为空表。",
12015
+ ".. _dummyTable_cs:",
11876
12016
  "",
11877
- "`outputTable` 是表对象，用于保存计算结果，可以是内存表或者分布式表。",
12017
+ "`dummyTable` 一个表对象，该表的唯一作用是为引擎提供订阅的流数据表的 schema，可以含有数据，亦可为空表。",
11878
12018
  "",
11879
- "* 如果没有指定 *contextByColumn*， 输出表的列数为 *metrics* 数量 + 1，第一列为 TIMESTAMP 类型，用于存放发生计算的时间戳（如果指定了 *timeColumn* 则是对应记录的时间戳），其他列为 *metrics* 计算结果对应的列，其数据类型必须与 *metrics* 返回结果的数据类型一致。",
11880
- "* 如果指定 *contextByColumn*， 输出表的列数为 *metrics* 数量 + 2，第一列为 TIMESTAMP 类型，用于存放发生计算的时间戳（如果指定了 *timeColumn* 则是对应记录的时间戳），第二列为 *contextByColumn* 指定的 列，其他列为 *metrics* 计算结果对应的列，其数据类型必须与 *metrics* 返回结果的数据类型一致。",
12019
+ ".. _outputTable_cs:",
11881
12020
  "",
11882
- "`keyColumn` 是一个字符串标量或向量，指定流数据表中某列的值为横截面引擎的 key。横截面引擎的每次计算，仅使用每个 key 对应的最新一行记录。",
12021
+ "`outputTable` 计算结果的输出表，可以是内存表或分布式表。使用 ``createCrossSectionalEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。",
11883
12022
  "",
11884
- "`triggeringPattern` 是一个字符串，表示触发计算的方式，每触发一次计算，输出一条结果到输出表。它可以是以下取值：",
12023
+ "* 如果没有指定 *contextByColumn*， 输出表的列数为 *metrics* 数量 + 1，其中：",
12024
+ "",
12025
+ " * 第一列为 TIMESTAMP 类型，用于存放发生计算的时间戳（如果指定了 *timeColumn* 则是对应记录的时间戳）；",
12026
+ " * 其他列为 *metrics* 计算结果对应的列，其数据类型必须与 *metrics* 返回结果的数据类型一致。",
12027
+ " ",
12028
+ "* 如果指定 *contextByColumn*， 输出表的列数为 *metrics* 数量 + 2，其中：",
12029
+ " ",
12030
+ " * 第一列为 TIMESTAMP 类型，用于存放发生计算的时间戳（如果指定了 *timeColumn* 则是对应记录的时间戳）；",
12031
+ " * 第二列为 *contextByColumn* 指定的 列；",
12032
+ " * 其他列为 *metrics* 计算结果对应的列，其数据类型必须与 *metrics* 返回结果的数据类型一致。",
12033
+ "",
12034
+ ".. _keyColumn_cs:",
12035
+ "",
12036
+ "`keyColumn` 字符串标量或向量，指定流数据表中某列的值为横截面引擎的键值。横截面引擎的计算时，仅使用每个键值对应的最新一行记录。",
12037
+ "",
12038
+ ".. _triggeringPattern_cs:",
12039
+ "",
12040
+ "`triggeringPattern` 字符串标量，表示触发计算的方式，每触发一次计算，输出一条结果到输出表。该字符串可选值如下：",
11885
12041
  "",
11886
12042
  "* 'perBatch': *triggeringPattern* 的默认值。每插入一次数据触发一次计算。",
11887
12043
  "* 'perRow': 插入的每一行数据都会触发一次计算。",
11888
- "* 'interval': 根据时间间隔触发计算。每经过 *triggeringInterval* 指定的时间间隔（根据系统时间）检查引擎中的数据是否被计算，若未被计算，则触发一次计算。",
11889
- "* 'keyCount': 若相同时间戳的数据分批次到达，当最新时间戳的 key 的数量达到 *triggeringInterval* 时，或尚未触发计算时有更新的时间戳数据到达，则触发计算。使用该参数值时，必须指定 *timeColumn*，且 *useSystemTime* = false。",
12044
+ "* 'interval': 根据时间间隔触发计算。每经过 *triggeringInterval* 指定的时间间隔（根据系统时间）检查引擎中的数据是否被计算。若存在未被计算的数据，则触发一次计算。",
12045
+ "* 'keyCount': 若相同时间戳的数据分批次到达，则只有在当前时间戳的记录数达到 *triggeringInterval*，或有更新时间戳的数据到达时，才会触发计算。使用该参数值时，必须指定 *timeColumn*，且 *useSystemTime* = false。",
11890
12046
  "",
11891
12047
  "注意：若设置 *triggeringPattern* = 'keyCount'，收到的数据中出现的乱序数据会被丢弃，不参与计算。",
11892
12048
  "",
11893
- "`triggeringInterval` 是一个整数或 tuple，触发计算规则如下：",
12049
+ ".. _triggeringInterval_cs:",
12050
+ "",
12051
+ "`triggeringInterval` 整数或元组，触发计算规则如下：",
11894
12052
  "",
11895
12053
  "* *triggeringPattern* 取值为'interval'时，*triggeringInterval* 是一个整数，表示触发计算的时间间隔，单位为毫秒，默认值为 1000。",
11896
- "* *triggeringPattern* 取值为'keyCount'时，*triggeringInterval* 可以是一个整数，表示触发计算的最新时间戳的 key 的数量。也可以是一个长度为 2 的 tuple。tuple 的第一个元素是整数，表示触发计算的最新时间戳的 key 的数量。tuple 的第二个值可以是整数或者 duration 类型数据。",
12054
+ "* *triggeringPattern* 取值为'keyCount'时：",
12055
+ "",
12056
+ " * *triggeringInterval* 可以是一个整数。设置后，在更新的时间戳的数据到来前，当前时间戳的记录数需要累积到 *triggeringInterval* 才会触发计算。",
12057
+ " * *triggeringInterval* 也可以是一个长度为 2 的 元组。元组的第一个元素是整数，表示触发计算的最新时间戳的记录数量。元组的第二个值可以是整数或者 duration 类型数据。",
11897
12058
  "",
11898
12059
  " 假设设置 *triggeringInterval* = (c1, c2):",
11899
12060
  "",
11900
12061
  " * 当 c2 为整数时，若收到的最新时间戳 t1 的数据数量小于 c1，这批数据不会触发计算，系统可以继续缓存更新时间戳 t2(t2>t1) 的数据，当 t2 的数据量达到 c2 或者收到更新的时间戳 t3(t3>t2) 的数据时，会触发时间戳 t1 对应数据的计算。注意必须满足 c2 < c1。",
11901
12062
  " * 当 c2 为 duration 时，若收到的最新时间戳 t1 的数据数量小于 c1，这批数据不会触发计算，系统收到更新的时间戳 t2(t2>t1) 的数据后，会等待 duration 指定的时间，若在此期间继续收到了 t1 的数据且满足 t1 时间戳的数据总量达到 c1，或者在此期间又收到了更新的时间戳 t3(t3>t2) 的数据，则直接触发 t1 对应数据的计算，等待时间结束后不再触发计算。否则，等待 duration 设置的时间后才会触发 t1 数据的计算。",
11902
12063
  "",
11903
- "`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:",
11904
12072
  "",
11905
12073
  "`timeColumn` 是一个字符串。当 *useSystemTime* = false 时，指定订阅的流数据表中时间列的名称。仅支持 TIMESTAMP 类型。",
11906
12074
  "",
11907
- "`lastBatchOnly` 可选参数。横截面引擎是否只保留最新时间戳上的数据。当 *lastBatchOnly* = true 时，只能指定 *triggeringPattern* = 'keyCount'，此时横截面引擎表只保存最新时间戳上 key 的数据；否则，横截面引擎表更新并保留所有 key 的数据。",
12075
+ ".. _lastBatchOnly_cs:",
12076
+ "",
12077
+ "`lastBatchOnly` 可选参数。横截面引擎是否只保留最新时间戳上的数据。当 *lastBatchOnly* = true 时，只能指定 *triggeringPattern* = 'keyCount'，此时横截面引擎维护的键值表只保存最新时间戳的键值数据；否则，更新并保留所有时间戳上的键值数据。",
11908
12078
  "",
11909
- "`contextByColumn` 可选参数，是一个字符串标量。设置后，将对横截面引擎中数据按照指定的字段分组，并在组内进行指定计算。",
12079
+ ".. _contextByColumn_cs:",
12080
+ "",
12081
+ "`contextByColumn` 可选参数，字符串标量。设置后，将对横截面引擎中数据按照指定的字段分组，并在组内进行指定计算。",
11910
12082
  "",
11911
12083
  "* 设置该参数，必须指定 *metrics* 和 *outputTable*.",
11912
12084
  "* 如果 *metrics* 全为聚合函数，则分组计算结果和 groupby 分组计算结果一致，否则和 contextby 分组计算结果一致。",
11913
12085
  "",
11914
12086
  "若要开启快照机制 (snapshot)，必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。",
11915
12087
  "",
11916
- "启用快照机制之后，系统若出现异常，可及时将流数据引擎恢复到最新的快照状态。",
12088
+ ".. _snapshotDir_cs:",
11917
12089
  "",
11918
12090
  "`snapshotDir` 可选参数，字符串，表示保存引擎快照的文件目录。",
11919
12091
  "",
@@ -11926,27 +12098,14 @@
11926
12098
  " * 快照生成并刷到磁盘：文件保存为 <engineName>.snapshot；",
11927
12099
  " * 存在同名快照：旧快照自动重命名为 <engineName>.old。",
11928
12100
  "",
11929
- "`snapshotIntervalInMsgCount` 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。",
11930
- "",
11931
- "`raftGroup` 是流数据高可用订阅端 raft 组的 ID (大于 1 的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。"
11932
- ]
11933
- }
11934
- ]
11935
- },
11936
- {
11937
- "title": "详情",
11938
- "type": "detail",
11939
- "children": [
11940
- {
11941
- "type": "text",
11942
- "value": [
11943
- "创建横截面引擎。返回一个以 *keyColumn* 作为键值的键值表。",
12101
+ ".. _snapshotIntervalInMsgCount_cs:",
11944
12102
  "",
11945
- ".. *metrics* 根据该表进行计算。*keyColumn* 中的值对应表中唯一一行，如果新插入数据中 *keyColumn* 的值已经存在，那么将更新记录，反之将在表的末尾插入一行新的记录。",
12103
+ "`snapshotIntervalInMsgCount` 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。",
11946
12104
  "",
11947
- "* 如果没有指定 *metrics* 或 *outputTable*，横截面引擎不会利用表中的数据进行任何运算和输出，仅更新表中记录。",
12105
+ ".. _raftGroup_cs:",
11948
12106
  "",
11949
- "* 如果指定了 *metrics* 和 *outputTable*，横截面引擎会首先更新表中记录，然后对表中的最新记录进行运算，并把结果输出到 *outputTable* 中。"
12107
+ "`raftGroup` 是流数据高可用订阅端 raft 组的 ID (大于 1 的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。",
12108
+ ""
11950
12109
  ]
11951
12110
  }
11952
12111
  ]
@@ -12183,39 +12342,46 @@
12183
12342
  ]
12184
12343
  },
12185
12344
  {
12186
- "title": "参数",
12187
- "type": "parameters",
12345
+ "title": "详情",
12346
+ "type": "detail",
12188
12347
  "children": [
12189
12348
  {
12190
12349
  "type": "text",
12191
12350
  "value": [
12192
- "该引擎是基于时间序列引擎进行的扩展，继承了 ``createTimeSeriesEngine`` 所有的参数，请参照 :doc:`createTimeSeriesEngine` 中参数介绍。这里仅介绍与时间序列引擎不同的参数：",
12193
- "",
12194
- "`sessionBegin` 为可选参数，可以是与时间列的数据类型对应的 SECOND、TIME 或 NANOTIME 类型的标量或向量，表示每个时间段的起始时刻。如果 *sessionBegin* 是一个向量，它必须是递增的。",
12195
- "",
12196
- "`sessionEnd` 为可选参数，可以是与时间列的数据类型对应的 SECOND、TIME 或 NANOTIME 类型的标量或向量，表示每个时间段的结束时刻。",
12351
+ "创建流数据日级时间序列引擎。日级时间序列引擎和时间序列引擎窗口划分和计算规则基本一致，但在此基础上做了如下拓展：",
12197
12352
  "",
12198
- "`mergeSessionEnd` 为可选参数，是一个布尔值，表示每一个区间的计算是否包括其结束时刻（规整后的时刻）的数据。默认值为 false。",
12353
+ "* 该引擎只能在一个自然日的指定时间段内（以下统称为 session）进行窗口的聚合计算。一个自然日内，可以指定多个 session， 如 9:00-12:00，13:00-15:00 等。",
12354
+ "* 出现在一个 session 开始之前的数据，日级时序引擎规定将该部分数据合入该 session 的第一个窗口进行计算。",
12355
+ "* 当日最后一个 session 后到来的数据将被丢弃，不会计入第二天的第一个窗口中。",
12199
12356
  "",
12200
- "`forceTriggerSessionEndTime` 可选参数，是正整数，单位与 *timeColumn* 的时间精度一致。若 *sessionEnd* 时刻对应的窗口数据未计算输出，通过该参数设置系统经过多少时间后触发计算并输出。若不指定 *fill* ，未包含在该窗口内的分组不会输出结果；若指定了 *fill* ，未包含在该窗口内的分组会按照 *fill* 指定的方式输出结果。",
12357
+ "若指定了 *keyColumn* 进行分组，则上述计算将在各分组内独立进行。",
12201
12358
  "",
12202
- "注：",
12203
- "",
12204
- "* 系统会对数据窗口的起始时间（*sessionBegin* 和 *sessionEnd*）进行规整。"
12359
+ "更多流数据引擎的应用场景说明可以参考 :doc:`../../SeriesOfFunctions/streamingEngine`。"
12205
12360
  ]
12206
12361
  }
12207
12362
  ]
12208
12363
  },
12209
12364
  {
12210
- "title": "详情",
12211
- "type": "detail",
12365
+ "title": "参数",
12366
+ "type": "parameters",
12212
12367
  "children": [
12213
12368
  {
12214
12369
  "type": "text",
12215
12370
  "value": [
12216
- "创建流数据日级时间序列引擎。",
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
+ "注：",
12217
12382
  "",
12218
- "对一个自然日内的数据指定时间段（由 *sessionBegin* 和 *sessionEnd* 指定）进行聚合计算。*sessionBegin* 设置的第一个时刻之前的所有数据并入第一个窗口进行计算。*sessionEnd* 设置的最后一个时刻及之后的数据是否参与计算，由参数 *mergeSessionEnd* 的设置决定。当 *mergeSessionEnd* = true 时，*sessionEnd* 设置的最后一个时刻上的数据会参与计算，但大于此时刻的数据被忽略，不参与计算；当 *mergeSessionEnd* = false 时，*sessionEnd* 设置的最后一个时刻及之后的数据都被忽略，不参与计算。"
12383
+ "* 系统会对数据窗口的起始时间（*sessionBegin* 和 *sessionEnd*）进行规整。",
12384
+ ""
12219
12385
  ]
12220
12386
  }
12221
12387
  ]
@@ -12545,11 +12711,11 @@
12545
12711
  "",
12546
12712
  "`outputTable` 结果的输出表，可以是内存表或者分布式表。使用 ``createDualOwnershipReactiveStateEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。",
12547
12713
  "",
12548
- "输出表的各列的顺序为：分组列，计算结果列。",
12714
+ "输出表各列的顺序为：分组列，计算结果列。",
12549
12715
  "",
12550
12716
  "其中：",
12551
12717
  "",
12552
- "(1) 输出表的前几列为 keyColumn1 和 keyColumn2 的公共列，然后依次为 keyColumn1 的非公共列和 keyColumn2 的非公共列。",
12718
+ "(1) 输出表的前几列为 keyColumn1 和 keyColumn2 的公共列，然后依次为 keyColumn1 的非公共列和 keyColumn2 的非公共列。",
12553
12719
  "",
12554
12720
  "(2) 其后为 metrics1 的计算结果列，metrics2 的计算结果列。"
12555
12721
  ]
@@ -12563,7 +12729,7 @@
12563
12729
  {
12564
12730
  "type": "text",
12565
12731
  "value": [
12566
- "Dual Ownership Reactive State Engine 是对响应式状态引擎的扩展，支持对同一张流数据表指定两种不同的分组方式分别应用不同的指标进行并行计算。与响应式状态级联实现相比，调用该函数进行计算极大地提升了计算性能。",
12732
+ "Dual Ownership Reactive State Engine 是对响应式状态引擎的扩展，支持对同一张流数据表指定两种不同的分组方式分别应用不同的指标进行并行计算。与响应式状态级联实现相比，该函数能极大地提升计算性能。",
12567
12733
  "",
12568
12734
  "注意：该引擎输出和输入顺序保持一致，即内部强制使 keepOrder = True。"
12569
12735
  ]
@@ -12658,41 +12824,61 @@
12658
12824
  ]
12659
12825
  },
12660
12826
  {
12661
- "title": "参数",
12662
- "type": "parameters",
12827
+ "title": "详情",
12828
+ "type": "detail",
12663
12829
  "children": [
12664
12830
  {
12665
12831
  "type": "text",
12666
12832
  "value": [
12667
- "equal join引擎的部分参数和 asof join 引擎相同，请参照 :doc:`createAsofJoinEngine` 中参数介绍。下面介绍不同的参数：",
12668
- "",
12669
- "`name` 必选参数，是一个字符串，表示流数据 equal join 引擎的名称。",
12833
+ "创建流数据等值连接引擎。返回一个左、右两表 equal join 后的表对象。注入等值连接引擎的左、右两表将以 :ref:`matchingColumn <mc_aj>` + :ref:`timeColumn <tc_ej>` 作为连接列，返回两表中连接字段相等的行。",
12670
12834
  "",
12671
- "`garbageSize` 可选参数，是正整数，默认值是5,000（单位为行）。当内存中历史数据行数超过 *garbageSize* 时，会清理本次计算不需要的历史数据。",
12672
- "",
12673
- "`maxDelayedTime` 可选参数，为正整数，默认值为3s，equal join 引擎接收到的能够参与计算的数据的最大延时时间。超过 *maxDelayedTime* 延迟时间的数据会被丢弃。不建议 *maxDelayedTime* 值设置过小。",
12674
- "",
12675
- "当内存中历史数据行数超过 *garbageSize* 时，会根据以下规则清理数据：",
12676
- "",
12677
- "\\1. 历史数据中已经 join 过的数据；",
12678
- "",
12679
- "\\2. 内存中历史数据的时间戳与 *leftTable* 或 *rightTable* 新收到的数据的时间戳的差值大于 *maxDelayedTime* 的数据。"
12835
+ "更多流数据引擎的应用场景说明可以参考 :doc:`../../SeriesOfFunctions/streamingEngine`。"
12680
12836
  ]
12681
12837
  }
12682
12838
  ]
12683
12839
  },
12684
12840
  {
12685
- "title": "详情",
12686
- "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",
12687
12855
  "children": [
12688
12856
  {
12689
12857
  "type": "text",
12690
12858
  "value": [
12691
- "创建流数据 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
+ "满足以下条件的数据才会被清理：",
12692
12874
  "",
12693
- "* 左、右两表组内数据的时间列按时间顺序排列，且时间列和连接列组合的取值是没有重复的。",
12875
+ "\\1. 历史数据中已经 join 并输出的数据；",
12694
12876
  "",
12695
- "从 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* 值设置过小。"
12696
12882
  ]
12697
12883
  }
12698
12884
  ]
@@ -12713,20 +12899,20 @@
12713
12899
  "language": "console",
12714
12900
  "value": [
12715
12901
  " ",
12716
- " $ leftTable=keyedTable(`time`sym, 1:0, `time`sym`price, [SECOND, SYMBOL, DOUBLE])",
12717
- " $ rightTable=keyedTable(`time`sym, 1:0, `time`sym`val, [SECOND, SYMBOL, DOUBLE])",
12718
- " $ output=table(100:0, `time`sym`total, [SECOND, SYMBOL, DOUBLE])",
12719
- " $ ejEngine=createEqualJoinEngine(\"test1\", leftTable, rightTable, output, <price+val>, `sym, `time)",
12720
- " $ tmp1=table(take(13:30:10, 20) as time, take(`AAPL, 10) join take(`IBM, 10) as sym, double(1..20) as price)",
12721
- " $ 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)",
12722
12910
  " $ leftTable.append!(tmp1)",
12723
- " $ tmp2=table(take(13:30:10, 20) as time, take(`AAPL, 10) join take(`IBM, 10) as sym, double(50..31) as val)",
12724
- " $ 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)",
12725
12912
  " $ rightTable.append!(tmp2)",
12726
12913
  "",
12727
- " $ re = select * from output order by time, sym",
12728
- " $ expected = select time, sym, price+val from ej(leftTable, tmp2, `sym`time) order by time, sym",
12729
- " $ each(eqObj, re.values(), expected.values())",
12914
+ " $ select count(*) from output",
12915
+ " 20",
12730
12916
  ""
12731
12917
  ]
12732
12918
  },
@@ -12889,23 +13075,19 @@
12889
13075
  {
12890
13076
  "type": "text",
12891
13077
  "value": [
12892
- "创建一个跨进程共享内存表的句柄。",
13078
+ "创建一个跨进程共享内存表的句柄。跨进程共享内存表通常作为流计算的输出表。在对时延要求极高的场景下，用户进程通过插件直接访问共享内存获取数据，极大减小了 TCP 等网络传输的时延。",
13079
+ "",
13080
+ "跨进程共享内存表通过共享内存（由操作系统管理）进行跨进程通信。共享内存表仅支持在同一物理机内共享，不支持在集群不同物理节点间进行共享。",
13081
+ "",
13082
+ "跨进程共享内存表支持读写，但不支持对跨进程共享内存表的表结构进行修改。向跨进程共享内存表写数据的方法，与普通内存表一致。若一次性插入的数据量大于共享内存，系统会抛出异常。",
12893
13083
  "",
12894
- "跨进程共享内存表通过共享内存（由操作系统管理）进行跨进程通信。系统允许不同进程对该内存并发写入（暂不支持并发读），或者不同进程对该内存同时读写。注意：共享内存表仅支持在同一物理机内共享，不支持在集群不同物理节点间进行共享。",
13084
+ "* 读写机制：将写入共享内存的进程作为生产者，从共享内存中读取数据的进程作为消费者。一次写入的数据将作为一个整体，供一次读取消费，且读进程依次按顺序对写入的数据进行消费。例如：第一写入 100 条数据，第二次写入 200 条数据，则第一次会读到 100 条数据，第二次会读到第二批写入的 200 条数据，以此类推。读取数据时，共享内存表中的所有数据均已被消费，则读进程会被阻塞，直到有新写入的可消费数据时，才能将数据读出。",
12895
13085
  "",
12896
- "跨进程共享内存表支持读写，但不支持对跨进程共享内存表的表结构进行修改。向跨进程共享内存表写数据的方法，与普通内存表一致。但对于跨进程共享内存表，既可以通过表的句柄插入数据，亦可通过与表名同名的表对象插入数据。若一次性插入的数据量大于共享内存，系统会抛出异常。"
13086
+ "DolphinDB 支持多进程并发写入共享内存表，以及在写入的同时进行读操作。但注意，只能同时存在一个读进程。参考上述读写机制，读取是一次性的，若不同进程并发读取，将会得到不同阶段写入的数据。"
12897
13087
  ]
12898
13088
  }
12899
13089
  ]
12900
13090
  },
12901
- {
12902
- "title": "读写机制：",
12903
- "children": []
12904
- },
12905
- {
12906
- "title": "场景：",
12907
- "children": []
12908
- },
12909
13091
  {
12910
13092
  "title": "例子",
12911
13093
  "type": "example",
@@ -12935,7 +13117,14 @@
12935
13117
  " $ temp = 30 + rand(5.0,n)",
12936
13118
  " $ tableInsert(shm_test,timestamp,temp)",
12937
13119
  "",
12938
- " $ 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`"
12939
13128
  ]
12940
13129
  }
12941
13130
  ]
@@ -12965,15 +13154,23 @@
12965
13154
  {
12966
13155
  "type": "text",
12967
13156
  "value": [
12968
- "创建流数据表的 lookup join 引擎，该引擎可以对两个流数据表进行实时 left join，或者对流数据表和非流数据表进行 left join（此时需要定时刷新非流表）。",
13157
+ "创建流数据表的 lookup join 引擎，该引擎以 :ref:`matchingColumn <matchingColumnLJ>` 作为连接列将两个流数据表进行实时 :doc:`/SQLStatements/TableJoiners/leftjoin`，",
13158
+ "或者将流数据表和非流数据表进行 left join（此时需要定时刷新非流表）。lookup join 引擎常用于右表更新不频繁的场景。",
12969
13159
  "",
12970
- "请注意：",
13160
+ "工作机制：",
13161
+ "",
13162
+ "\\1. 仅当左表有新数据流入时才会触发左、右表的 left join 输出。",
13163
+ "",
13164
+ "\\2. 引擎仅保留右表根据 *matchingColumn* 分组后各分组内的最新一条数据。当右表是订阅的流表时，数据流入右表的同时会更新数据；",
13165
+ "若右表为内存表或分布式表（目前仅支持维度表），系统会根据 *checkTimes* 定时刷新右表数据。",
12971
13166
  "",
12972
- "\\1. 仅当左表有新数据流入时才会触发左、右表的 left join。",
13167
+ "lookup join 引擎实际采用 left join 的连接方式，但与 left join 不完全等价，区别在于：如果右表中有多条匹配记录，left join 会返回右表所有匹配的记录，但 lookup join 引擎只返回右表最新一条匹配的记录。",
12973
13168
  "",
12974
- "\\2. 右表仅保留根据 *matchingColumn* 分组的各分组内的最新一条数据。当右表是订阅的流表时，数据流入右表的同时会更新数据；若右表为内存表或分布式表（目前仅支持维度表），系统会根据 *checkTimes* 定时刷新右表数据。",
13169
+ "lookup join 引擎与 asof jion 引擎很相似，它们之间的区别与联系如下：",
12975
13170
  "",
12976
- "从 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 时，需要考虑左右表的数据延时，因此需要缓存数据。"
12977
13174
  ]
12978
13175
  }
12979
13176
  ]
@@ -12985,11 +13182,11 @@
12985
13182
  {
12986
13183
  "type": "text",
12987
13184
  "value": [
12988
- "`name` 必选参数，是一个字符串，表示流数据 lookup join 引擎的名称。",
13185
+ "`name` 必选参数，表示流数据 lookup join 引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
12989
13186
  "",
12990
- "`leftTable` 是一个表对象。可以不包含数据，但结构必须与订阅的流数据表相同。",
13187
+ "`leftTable` 表对象。结构必须与订阅的流数据表相同。",
12991
13188
  "",
12992
- "`rightTable` 是一个表对象，是不包含数据的内存表、流数据表或维度表。请注意，如果 *rightTable* 没有被订阅，必须设置 *checkTimes* 定时刷新数据。",
13189
+ "`rightTable` 表对象，可以是内存表、流数据表或维度表。请注意，如果 *rightTable* 没有被订阅，必须设置 *checkTimes* 定时刷新数据。",
12993
13190
  "",
12994
13191
  "`outputTable` 必选参数，为计算结果的输出表。在使用 ``createLookupJoinEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。",
12995
13192
  "",
@@ -13008,6 +13205,7 @@
13008
13205
  "",
13009
13206
  "请注意，若 *metrics* 中指定了时间列或者连接列，需要在连接列或时间列前加上表名来指定该列所属的表，若不加表名，则默认取左表的列。例如：*matchingColumn* = \\`sym, *timeColumn* = \\`timestamp，则 *metrics* = <[rightTable.sym, rightTable.timestamp, price, val, price*val]> 指定 *metrics* 中输出右表的 sym 列和 timestamp 列。",
13010
13207
  "",
13208
+ ".. _matchingColumnLJ:",
13011
13209
  "",
13012
13210
  "`matchingColumn` 表示连接列的字符串标量/向量或字符串向量组成的 tuple，支持 Integral, Temproal 或 Literal(UUID 除外)类型。",
13013
13211
  "",
@@ -13266,7 +13464,7 @@
13266
13464
  {
13267
13465
  "type": "text",
13268
13466
  "value": [
13269
- "`dbHandle` :doc:`../d/database` 函数返回的数据库句柄。它可以是本地磁盘数据库，也可以是分布式数据库。*dbHandle* 为空字符串或没有指定时，表示内存数据库的句柄。",
13467
+ "`dbHandle` :doc:`../d/database` 函数返回的数据库句柄。它可以是本地磁盘数据库，也可以是分布式数据库。*dbHandle* 为空字符串或没有指定时，表示内存数据库的句柄。",
13270
13468
  "",
13271
13469
  "`table` 一个表或包含多个表的元组。系统将会根据该表的结构创建新的分区表。",
13272
13470
  "",
@@ -13362,27 +13560,17 @@
13362
13560
  "value": [
13363
13561
  "在分布式数据库中，初次创建表后，可以跳过 :doc:`../l/loadTable` 把表载入内存的步骤，因为分布式文件系统会动态刷新表的内容。系统重启后，需要再次执行 loadTable 函数加载表。",
13364
13562
  "",
13365
- "例 2. 在本地数据库中创建分区表",
13563
+ ".. 例 2. 在本地数据库中创建分区表",
13366
13564
  "",
13367
- "我们只需要将数据库的路径修改为本地文件系统的路径。需要注意的是，在本地文件系统中，系统不能自动刷新表的内容。在进行交互工作之前，我们需要使用 :doc:`../l/loadTable` 函数把表加载到内存中。",
13368
- ""
13369
- ]
13370
- },
13371
- {
13372
- "type": "code",
13373
- "language": "console",
13374
- "value": [
13565
+ ".. 我们只需要将数据库的路径修改为本地文件系统的路径。需要注意的是，在本地文件系统中，系统不能自动刷新表的内容。在进行交互工作之前，我们需要使用 :doc:`../l/loadTable` 函数把表加载到内存中。",
13566
+ "",
13567
+ ".. .. code:: console",
13375
13568
  "",
13376
13569
  " $ db=database(\"C:/DolphinDB/Data/rangedb_tradedata\",RANGE,`A`F`M`S`ZZZZ)",
13377
- ""
13378
- ]
13379
- },
13380
- {
13381
- "type": "text",
13382
- "value": [
13383
- "例 3. 在内存数据库中创建一个分区表",
13384
13570
  "",
13385
- "例 3.1 创建分区常规内存表",
13571
+ "例 2. 在内存数据库中创建一个分区表",
13572
+ "",
13573
+ "例 2.1 创建分区常规内存表",
13386
13574
  ""
13387
13575
  ]
13388
13576
  },
@@ -13406,7 +13594,7 @@
13406
13594
  {
13407
13595
  "type": "text",
13408
13596
  "value": [
13409
- "例 3.2 创建分区键值内存表",
13597
+ "例 2.2 创建分区键值内存表",
13410
13598
  ""
13411
13599
  ]
13412
13600
  },
@@ -13430,7 +13618,7 @@
13430
13618
  {
13431
13619
  "type": "text",
13432
13620
  "value": [
13433
- "例 3.3 创建分区流数据表",
13621
+ "例 2.3 创建分区流数据表",
13434
13622
  "",
13435
13623
  "注意，创建分区流数据表时 createPartitionedTable 的第二个参数必须是元组，并且其长度必须与分区数量相等，每个表对应一个分区。下例中，trades_stream1 和 trades_stream2 组成一个分区流数据表 trades。写入数据时，只能分别往 trades_stream1 和 trades_stream2 写入，不能直接写入到 trades。查询 trades 可以获取到两个表的数据。",
13436
13624
  ""
@@ -13466,7 +13654,7 @@
13466
13654
  "09:30:01.001 DELL 100 15.5",
13467
13655
  "============= ===== ===== ======",
13468
13656
  "",
13469
- "例 3.4 创建分区 MVCC 内存表",
13657
+ "例 2.4 创建分区 MVCC 内存表",
13470
13658
  "",
13471
13659
  "创建分区 MVCC 内存表的方式与创建分区流数据表的方式相同。",
13472
13660
  ""
@@ -13502,7 +13690,7 @@
13502
13690
  "09:30:01.001 DELL 100 15.5",
13503
13691
  "============= ===== ===== ======",
13504
13692
  "",
13505
- "例 4. 指定压缩算法",
13693
+ "例 3. 指定压缩算法",
13506
13694
  ""
13507
13695
  ]
13508
13696
  },
@@ -13545,6 +13733,60 @@
13545
13733
  }
13546
13734
  ]
13547
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
+ },
13548
13790
  {
13549
13791
  "title": "参数",
13550
13792
  "type": "parameters",
@@ -13552,7 +13794,11 @@
13552
13794
  {
13553
13795
  "type": "text",
13554
13796
  "value": [
13555
- "`name` 一个字符串，表示响应式状态引擎的名称，是其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
13797
+ ".. _name_rs:",
13798
+ "",
13799
+ "`name` 字符串标量，表示响应式状态引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
13800
+ "",
13801
+ ".. _metrics_rs:",
13556
13802
  "",
13557
13803
  "`metrics` 以元代码的形式表示计算公式。有关元代码的详情可参考 :doc:`/Objects/Metaprogramming`。若需使用用户自定义函数，请注意以下两点：",
13558
13804
  "",
@@ -13568,20 +13814,13 @@
13568
13814
  " $ return (N - 1) * linearregSlope + linearregIntercept",
13569
13815
  " $ }",
13570
13816
  "",
13571
- "下列状态函数在 DolphinDB 的响应式状态引擎中的实现均得到了优化。目前，状态引擎不允许使用未经优化的状态函数。应避免使用聚合函数。",
13572
- "",
13573
- "* 累计窗口函数：cumavg, cumsum, cumprod, cumcount, cummin, cummax, cumvar, cumvarp, cumstd, cumstdp, cumcorr, cumcovar, cumbeta, cumwsum, cumwavg, cumfirstNot, cumlastNot, cummed, cumpercentile, cumPositiveStreak",
13574
- "* 滑动窗口函数：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",
13575
- "* 序列相关函数：deltas, ratios, ffill, move, prev, iterate, ewmMean, ewmVar, ewmStd, ewmCov, ewmCorr, prevState",
13576
- "* topN相关函数：msumTopN, mavgTopN, mstdpTopN, mstdTopN, mvarpTopN, mvarTopN, mcorrTopN, mbetaTopN, mcovarTopN, mwsumTopN",
13577
- "* 高阶函数：segmentBy(参数 func 暂支持 cumsum, cummax, cummin, cumcount, cumavg, cumstd, cumvar, cumstdp, cumvarp)",
13578
- "* 其他函数：talibNull, dynamicGroupCumsum, dynamicGroupCumcount, topRange, lowRange",
13817
+ ".. _dummyTable_rs:",
13579
13818
  "",
13580
- "注意，:doc:`/Functionalprogramming/TemplateFunctions/talib` 作为状态函数时，第一个参数 `func` 只能是响应式状态引擎支持的状态函数。",
13819
+ "`dummyTable` 一个表对象，该表的唯一作用是为引擎提供订阅的流数据表的 schema，可以含有数据，亦可为空表。",
13581
13820
  "",
13582
- "`dummyTable` 是一个表对象，该表的唯一作用是为引擎提供订阅的流数据表的 schema，可以含有数据，亦可为空表。",
13821
+ ".. _outputTable_rs:",
13583
13822
  "",
13584
- "`outputTable` 结果的输出表，可以是内存表或者分布式表。使用 ``createReactiveStateEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。",
13823
+ "`outputTable` 计算结果的输出表，可以是内存表或分布式表。使用 ``createReactiveStateEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。响应式状态引擎会将计算结果注入该表。",
13585
13824
  "",
13586
13825
  "输出表的各列的顺序为：分组列，计算结果列。",
13587
13826
  "",
@@ -13591,13 +13830,17 @@
13591
13830
  "",
13592
13831
  "\\(2) 其后为计算结果列，可为多列。",
13593
13832
  "",
13594
- "`keyColumn` 一个字符串标量或向量，表示分组列名，例如以每只股票为一组进行计算。",
13833
+ ".. _keyColumn_rs:",
13834
+ "",
13835
+ "`keyColumn` 字符串标量或向量表示分组列名。计算将在各分组进行。",
13836
+ "",
13837
+ ".. _filter_rs:",
13595
13838
  "",
13596
13839
  "`filter` 可选参数。以元代码的形式表示过滤条件。只有符合过滤条件的结果才被输出。它只能是一个表达式。设置多个条件时，用逻辑运算符（and, or）连接。",
13597
13840
  "",
13598
13841
  "若要开启快照机制 (snapshot)，必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。",
13599
13842
  "",
13600
- "启用快照机制之后，系统若出现异常，可及时将流数据引擎恢复到最新的快照状态。",
13843
+ ".. _snapshotDir_rs:",
13601
13844
  "",
13602
13845
  "`snapshotDir` 可选参数，字符串，表示保存引擎快照的文件目录。",
13603
13846
  "",
@@ -13610,47 +13853,38 @@
13610
13853
  " * 快照生成并刷到磁盘：文件保存为 <engineName>.snapshot；",
13611
13854
  " * 存在同名快照：旧快照自动重命名为 <engineName>.old。",
13612
13855
  "",
13856
+ ".. _snapshotIntervalInMsgCount_rs:",
13857
+ "",
13613
13858
  "`snapshotIntervalInMsgCount` 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。",
13614
13859
  "",
13860
+ ".. _keepOrder_rs:",
13861
+ "",
13615
13862
  "`keepOrder` 可选参数，表示输出表数据是否按照输入时的顺序排序。设置 *keyOrder* = true，表示输出表按照输入时的顺序排序。当 *keyColumn* 包含有时间列时，*keyOrder* 默认值为 true，否则默认值为 false。",
13616
13863
  "",
13617
- "若要对历史分组的数据进行清理，可以配置 *keyPurgeFilter* 和 *keyPurgeFreqInSecond* 参数。",
13864
+ ".. _keyPurgeFilter_rs:",
13618
13865
  "",
13619
13866
  "`keyPurgeFilter` 可选参数，是一个由条件表达式组成的元代码，表示清理条件。各表达式只能引用 *outputTable* 中的字段。",
13620
13867
  "",
13868
+ ".. _keyPurgeFreqInSecond_rs:",
13869
+ "",
13621
13870
  "`keyPurgeFreqInSecond` 正整数，表示触发数据清理需要满足的时间间隔（以秒为单位）。",
13622
13871
  "",
13623
13872
  "响应式状态引擎提供了 *keyPurgeFilter*, *keyPurgeFreqInSecond* 两个参数，用来清理不再需要的分组数据。",
13624
13873
  "",
13625
13874
  "每次数据注入时，系统会依次根据以下条件决定是否触发数据清理：",
13626
13875
  "",
13627
- "\\(1) 检测本次数据注入与上一次数据注入的时间间隔是否大于等于 keyPurgeFreqInSecond（第一次数据注入时，检测注入时间和引擎创建时间的间隔）；",
13876
+ "\\(1) 检测本次数据注入与上一次数据注入的时间间隔是否大于等于 *keyPurgeFreqInSecond* （第一次数据注入时，检测注入时间和引擎创建时间的间隔）；",
13628
13877
  "",
13629
- "\\(2) 若满足上述条件，系统将根据 keyPurgeFilter 指定的条件，过滤出待清理的数据；",
13878
+ "\\(2) 若满足上述条件，系统将根据 *keyPurgeFilter* 指定的条件，过滤出待清理的数据；",
13630
13879
  "",
13631
13880
  "\\(3) 若待清理的数据所属的分组数大于等于所有分组数的 10%，则触发清理。",
13632
13881
  " ",
13633
13882
  "若需要查看清理前后的状态，可以通过调用 :doc:`../g/getStreamEngineStat` 函数查看 ReactiveStreamEngine 引擎状态的 numGroups 列，来对比响应式状态引擎清理前后分组数的变化。",
13634
13883
  "",
13635
- "`raftGroup` 是流数据高可用订阅端 raft 组的 ID (大于1的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。"
13636
- ]
13637
- }
13638
- ]
13639
- },
13640
- {
13641
- "title": "详情",
13642
- "type": "detail",
13643
- "children": [
13644
- {
13645
- "type": "text",
13646
- "value": [
13647
- "创建响应式状态引擎。",
13648
- "",
13649
- "返回一个表对象，向该表写入数据意味着这些数据进入响应式状态引擎进行计算。",
13884
+ ".. _raftGroup_rs:",
13650
13885
  "",
13651
- "通常与 :doc:`../s/subscribeTable` 函数一起使用。更多详情请参考教程 `DolphinDB 流聚合引擎 <https://gitee.com/dolphindb/Tutorials_CN/blob/master/stream_aggregator.md>`_。创建的响应式状态引擎可以跨会话调用。",
13652
- "",
13653
- "请注意：响应式状态引擎不支持多线程并发写入，必须配置 *subExecutorPooling* = false，使引擎读写任务串行执行。"
13886
+ "`raftGroup` 是流数据高可用订阅端 raft 组的 ID (大于1的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。",
13887
+ ""
13654
13888
  ]
13655
13889
  }
13656
13890
  ]
@@ -13751,33 +13985,55 @@
13751
13985
  ]
13752
13986
  },
13753
13987
  {
13754
- "title": "参数",
13755
- "type": "parameters",
13988
+ "title": "详情",
13989
+ "type": "detail",
13756
13990
  "children": [
13757
13991
  {
13758
13992
  "type": "text",
13759
13993
  "value": [
13760
- "由于会话窗口引擎的绝大多数参数与时间序列引擎重合，请参照 :doc:`createTimeSeriesEngine` 中参数介绍。这里仅介绍与时间序列引擎不同的以下参数：",
13994
+ "创建流数据会话窗口引擎。",
13761
13995
  "",
13762
- "`sessionGap` 必选参数，是一个正整数，表示会话窗口之间的时间间隔。此参数的时间单位由 *useSystemTime* 参数决定。",
13996
+ "``createSessionWindowEngine`` 的参数绝大多数与 ``createTimeSeriesEngine`` 一样，只有 :ref:`sessionGap <sessionGap_sw>` 和 :ref:`useSessionStartTime <useSessionStartTime_sw>` 是它独有的参数。*sessionGap* 决定了一个会话窗口何时结束，*useSessionStartTime* 决定了输出表时间列的时间为各个窗口的起始时刻还是结束时刻。",
13763
13997
  "",
13764
- "`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 作为窗口的结束时刻）。窗口结束后新到来的一条数据将触发该窗口的计算。",
13765
14010
  "",
13766
- "`forceTriggerTime` 可选参数，非负整数，单位与 *timeColumn* 的时间精度一致。该参数仅在设置 *useSystemTime* = false 时起效。当系统收到最后一条数据后，经过 *forceTriggerTime* 时间，将强制触发未计算的窗口进行计算。请注意，若设置了 *keyColumn*，则各分组内进行上述操作。"
14011
+ "注意：若指定了 :ref:`keyColumn <keyColumn_ts>`，则按照分组分别进行窗口计算。"
13767
14012
  ]
13768
14013
  }
13769
14014
  ]
13770
14015
  },
13771
14016
  {
13772
- "title": "详情",
13773
- "type": "detail",
14017
+ "title": "参数",
14018
+ "type": "parameters",
13774
14019
  "children": [
13775
14020
  {
13776
14021
  "type": "text",
13777
14022
  "value": [
13778
- "创建流数据会话窗口引擎。",
14023
+ "由于会话窗口引擎的绝大多数参数与时间序列引擎重合，请参照 :doc:`createTimeSeriesEngine` 中参数介绍。这里仅介绍与时间序列引擎不同的参数：",
14024
+ "",
14025
+ ".. _sessionGap_sw:",
13779
14026
  "",
13780
- "该引擎与时间序列引擎极为相似。唯一的不同之处在于如何决定计算窗口。在时间序列引擎中，窗口以固定长度，按照固定频率产生。在会话窗口引擎中，若某条数据之后指定时间长度（*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
+ ""
13781
14037
  ]
13782
14038
  }
13783
14039
  ]
@@ -14029,17 +14285,64 @@
14029
14285
  {
14030
14286
  "type": "text",
14031
14287
  "value": [
14032
- "创建流数据时间序列引擎。返回一个表对象，向该表写入数据意味着这些数据进入时间序列引擎，并在滑动窗口内进行聚合计算，窗口区间左闭右开。若指定了 *keyColumn*，则按照分组分别进行滑动窗口计算。",
14288
+ "创建流数据时间序列引擎，以实现基于时间的滑动窗口或滚动窗口进行实时计算。返回一个表对象，通过向该表对象写入，将数据注入时间序列引擎进行计算。 ",
14033
14289
  "",
14034
- "计算中，若指定了 *timeColumn*：",
14290
+ "时序引擎的聚合计算的算子分为增量计算和全量计算两种。增量计算算子不会保留历史数据，每次有数据进来就会进行增量计算；而全量计算算子（例如自定义的聚合函数，或未经优化的内置聚合函数，亦或是嵌套了状态函数的函数）会保留窗口内完整的数据，待触发输出时进行全量计算。",
14035
14291
  "",
14036
- "\\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。",
14037
14293
  "",
14038
- "\\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>` 决定。",
14039
14329
  "",
14040
- "否则，时间乱序的数据在计算中会被直接丢弃。",
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>` 的参数说明）",
14041
14344
  "",
14042
- "该函数通常与 :doc:`../s/subscribeTable` 函数一起使用。更多详情请参考教程 `DolphinDB 流数据引擎 <https://gitee.com/dolphindb/Tutorials_CN/blob/master/stream_aggregator.md>`_。创建时间序列引擎可以跨会话调用。"
14345
+ ""
14043
14346
  ]
14044
14347
  }
14045
14348
  ]
@@ -14051,19 +14354,17 @@
14051
14354
  {
14052
14355
  "type": "text",
14053
14356
  "value": [
14054
- "`name` 必选参数，是一个字符串，表示时间序列引擎的名称，是其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
14055
- "",
14056
- "`useSystemTime` 可选参数，表示是否使用数据进入引擎时的系统时间作为时间列进行计算。",
14357
+ ".. _name_ts:",
14057
14358
  "",
14058
- "* 当 *useSystemTime* = true时，时间序列引擎会按照数据进入时间序列引擎的时刻（毫秒精度的本地系统时间，与数据中的时间列无关），每隔固定时间截取固定长度窗口的流数据进行计算。只要一个数据窗口中含有数据，数据窗口结束后就会自动进行计算。结果中的第一列为计算发生的时间戳，与数据中的时间无关。",
14359
+ "`name` 字符串标量，表示时间序列引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
14059
14360
  "",
14060
- "* 当 *useSystemTime* = false（缺省值）时，时间序列引擎根据流数据中的 *timeColumn* 列来截取数据窗口。一个数据窗口结束后的第一条新数据才会触发该数据窗口的计算。请注意，触发计算的数据并不会参与该次计算。",
14361
+ ".. _windowSize_ts:",
14061
14362
  "",
14062
- "例如，一个数据窗口从10:10:10到10:10:19。若 *useSystemTime* = true，则只要该窗口中至少有一条数据，该窗口的计算会在窗口结束后的10:10:20触发。若 *useSystemTime* = false，且10:10:19后的第一条数据为10:10:25，则该窗口的计算会在10:10:25触发。",
14363
+ "`windowSize` 正整数标量或向量，表示滑动窗口的长度。",
14063
14364
  "",
14064
- "`windowSize` 必选参数，是一个正整数标量或向量，指定数据窗口的长度。若为向量，其长度必须与 *metrics* 中元素个数一致。",
14365
+ ".. _step_ts:",
14065
14366
  "",
14066
- "`step` 必选参数，是一个正整数，表示计算窗口右边界的位移量。 *windowSize* 必须是 *step* 的整数倍，否则会抛出异常。",
14367
+ "`step` 正整数标量，表示滑动窗口移动的步长。 *windowSize* 必须是 *step* 的整数倍，否则会抛出异常。",
14067
14368
  "",
14068
14369
  "*windowSize* 和 *step* 的单位与 *useSystemTime* 有关：",
14069
14370
  "",
@@ -14071,7 +14372,170 @@
14071
14372
  "",
14072
14373
  "* 若 *useSystemTime* 为 false，则 *windowSize* 和 *step* 的单位与 *timeColumn* 的时间精度一致。",
14073
14374
  "",
14074
- "为了便于观察和对比计算结果，系统会对第一个数据窗口的起始时间进行规整，根据 *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。当时间序列引擎使用分组计算时，所有分组的窗口均进行统一的规整。相同时刻的数据窗口在各组均有相同的边界。",
14075
14539
  "",
14076
14540
  "* 若数据的时间精度为秒，如 DATETIME(yyyy-MM-dd HH:mm:ss) 与 SECOND(HH:mm:ss) 类型，alignmentSize 的 取值如下：",
14077
14541
  "",
@@ -14191,120 +14655,7 @@
14191
14655
  " >30s 1min",
14192
14656
  " ============== =================",
14193
14657
  "",
14194
- "假设第一条数据的时间为 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。 ",
14195
- "",
14196
- "`metrics` 必选参数，以元代码的格式表示计算指标。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。支持输入元组。",
14197
- "",
14198
- "* 计算指标可以是一个或多个系统内置或用户自定义的聚合函数（使用 defg 关键字定义），如 <[sum(volume), avg(price)]>；可以对聚合结果使用表达式，如 <[avg(price1)-avg(price2)]>；也可对列与列的计算结果进行聚合计算，如 <[std(price1-price2)]>。",
14199
- "* *metrics* 内支持调用具有多个返回值的函数，例如 <func(price) as \\`col1\\`col2>（可不指定列名）。",
14200
- "* 若 *windowSize* 为向量， *windowSize* 每个值可对应 *metrics* 中多个计算指标。例如，*windowSize* 为[10,20]时，metrics可为 (<[min(volume), max(volume)]>, <sum(volume)>)。 *metrics* 也可以嵌套输入元组向量。例如：[[<[min(volume), max(volume)]>, <sum(volume)>], [<avg(volume)>]]",
14201
- "",
14202
- "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。",
14203
- "",
14204
- "`dummyTable` 是一个表对象，该表的唯一作用是为引擎提供订阅的流数据表的 schema，可以含有数据，亦可为空表。",
14205
- "",
14206
- "`outputTable` 必选参数，为计算结果的输出表，可以是内存表或者分布式表。在使用 ``createTimeSeriesEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。时间序列引擎会将计算结果插入该表。",
14207
- "",
14208
- "输出表的各列的顺序为：时间列，分组列，计算结果列。",
14209
- "",
14210
- "其中：",
14211
- "",
14212
- "\\(1) 第一列必须是时间类型。",
14213
- "",
14214
- "* 若 *useSystemTime* = true，为 TIMESTAMP 类型；",
14215
- "* 若 *useSystemTime* = false，数据类型与 *timeColumn* 列一致。",
14216
- "* 若 *useWindowStartTime* = true，显示时间为数据窗口起始时间。",
14217
- "* 若 *useWindowStartTime* = false，显示时间为数据窗口终止时间。",
14218
- "",
14219
- "\\(2) 如果 *keyColumn* 不为空，则其后几列和 *keyColumn* 设置的列及其顺序保持一致。",
14220
- "",
14221
- "\\(3) 最后为计算结果列，可为多列。",
14222
- "",
14223
- "`timeColumn` 可选参数，是字符串标量或向量，当 *useSystemTime* = false 时，必须指定该参数。 该参数用于指定订阅的流数据表中时间列的名称。",
14224
- "",
14225
- "请注意，字符串向量，必须是 date 和 time 组成的向量，date 类型为 DATE，time 类型为 TIME, SECOND 或 NANOTIME。此时，输出表第一列的时间类型必须与 :doc:`concatDateTime(date, time) <../c/concatDateTime>` 的类型一致。",
14226
- "",
14227
- "`keyColumn` 可选参数，是字符串标量或向量，表示分组列名。若设置，则分组进行聚合计算，例如以每支股票为一组进行聚合计算。",
14228
- "",
14229
- "`garbageSize` 可选参数，是正整数，默认值是50,000（单位为行）。当 *metrics* 中使用了自定义聚合函数，时间序列引擎会保留历史数据。随着订阅的流数据不断积累，进入时间序列引擎，存放在内存中的数据会越来越多，这时需要清理不再需要的历史数据。当内存中历史数据行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。如果指定了 *keyColumn*，内存清理是各组内独立进行的。当一个组在内存中的历史数据记录数超出 *garbageSize* 时，会清理该组中本次计算中不需要的历史数据。",
14230
- "",
14231
- "`updateTime` 可选参数，是正整数，可定义比 *step* 更短的计算的时间间隔。*step* 必须是 *updateTime* 的整数倍。要设置 *updateTime*， *useSystemTime* 必须设为 false。",
14232
- "",
14233
- "如果没有指定 *updateTime*，一个数据窗口结束前，不会发生对该数据窗口数据的计算。若要求在当前窗口结束前对当前窗口数据进行计算，可指定 *updateTime*。",
14234
- "",
14235
- "如果指定了 *updateTime*，当前窗口内可能会发生多次计算。计算触发的规则为：",
14236
- "",
14237
- "\\(1) 将当前窗口分为 *windowSize* / *updateTime* 个小窗口，每个小窗口长度为 *updateTime*。一个小窗口结束后，若有一条新数据到达，且在此之前当前窗口内有未参加计算的的数据，会触发一次计算。请注意，该次计算不包括这条新数据。",
14238
- "",
14239
- "\\(2) 一条数据到达时间序列引擎之后经过 2 \\* updateTime（若 2 \\* updateTime不足 2 秒，则设置为 2 秒），若其仍未参与计算，会触发一次计算。该次计算包括当时当前窗口内的所有数据。 ",
14240
- "",
14241
- "若分组计算，则每组内进行上述操作。",
14242
- "",
14243
- "请注意，当前窗口内每次计算结果的时间戳均为当前数据窗口开始时间或开始时间 + *windowSize* （由参数 *useWindowStartTime* 决定），而非当前窗口内的时刻。",
14244
- "",
14245
- "指定 *updateTime* 后，建议使用键值内存表作为输出表。因为每次计算均会增加一条记录，输出表若使用普通内存表或流数据表，则会产生大量带有相同时间戳的结果。因为键值流数据表不可更新记录，输出表亦不推荐使用键值流数据表。",
14246
- "",
14247
- "`useWindowStartTime` 可选参数，是一个布尔值，表示输出表中的时间是否为数据窗口起始时间。默认值为 false，表示输出表中的时间为数据窗口起始时间 + *windowSize* 。若 *windowSize* 是向量， *useWindowStartTime* 必须为 false。",
14248
- "",
14249
- "`roundTime` 可选参数，是一个布尔值，表示若数据时间精度为毫秒或者秒且 *step* > 一分钟，如何对窗口边界值进行规整处理。默认值为 true，表示按照既定的多分钟规则（见以上表格）进行规整。若为 false，则按一分钟规则（见以上表格）进行窗口规整。",
14250
- "",
14251
- "若要开启快照机制 (snapshot)，必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。",
14252
- "",
14253
- "启用快照机制之后，系统若出现异常，可及时将流数据引擎恢复到最新的快照状态。",
14254
- "",
14255
- "`snapshotDir` 可选参数，字符串，表示保存引擎快照的文件目录。",
14256
- "",
14257
- "* 指定的目录必须存在，否则系统会提示异常。",
14258
- "* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。",
14259
- "* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。",
14260
- "* 一个引擎的快照可能会使用三个文件名：",
14261
- "",
14262
- " * 临时存储快照信息：文件名为 <engineName>.tmp；",
14263
- " * 快照生成并刷到磁盘：文件保存为 <engineName>.snapshot；",
14264
- " * 存在同名快照：旧快照自动重命名为 <engineName>.old。",
14265
- "",
14266
- "`snapshotIntervalInMsgCount` 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。",
14267
- "",
14268
- "`fill` 可选参数，是一个标量或向量，表示若（某个分组的）某个窗口无数据时，如何处理。可取以下值：",
14269
- "",
14270
- "* 'none': 不输出结果。",
14271
- "* 'null': 输出结果为 NULL。",
14272
- "* 'ffill': 输出上一个有数据的窗口的结果。",
14273
- "* '具体数值'：该值的数据类型需要和对应的 *metrics* 计算结果的类型保持一致。",
14274
- "",
14275
- "*fill* 可以输入向量，为每个 *metrics* 指定不同的 *fill* 方式。其中，向量中各项只能是 'null', 'ffill' 或一个数值，不能是 'none'。",
14276
- "",
14277
- "`forceTriggerTime` 可选参数，是非负整数，单位与 *timeColumn* 的时间精度一致。用于强制触发各个分组未计算的窗口进行计算。强制触发计算及输出规则如下：",
14278
- "",
14279
- "\\1. 未被触发计算的窗口结束后（窗口结束时刻为 t），若收到了其他分组的数据（时间戳为 t1），且满足 t1-t ≥ *forceTriggerTime*，则该窗口将被触发计算。",
14280
- "",
14281
- "\\2. 窗口内不包含数据时，若未指定 *fill*，则不会输出结果；若指定了 *fill*，则会以 *fill* 指定的方式输出结果。",
14282
- "",
14283
- "注：要设置 *forceTriggerTime*， *useSystemTime* 必须设置为 false，且不能指定 *updateTime*。若强制触发计算后，仍有属于当前窗口的数据到达，则这些数据会被丢弃，建议不要设置太小的 *forceTriggerTime*。",
14284
- "",
14285
- "设置 *forceTriggerTime* 或 *updateTime* 时需注意以下几点：",
14286
- "",
14287
- "* 只设置 *updateTime*，计算发生后仍有属于当前窗口的数据到达时，当前窗口计算结果会再次更新；只设置 *forceTriggerTime*，则触发计算之后收到的数据会被丢弃。",
14288
- "",
14289
- "`raftGroup` 是流数据高可用订阅端 raft 组的 ID (大于1的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。",
14290
- "",
14291
- "`keyPurgeFreqInSec` 正整数，表示清理窗口数据为空的分组的时间间隔，单位为秒。指定该参数后，若当前数据注入时间与上一次清理时间的间隔大于等于 *keyPurgeFreqInSec*，便会对当前窗口数据为空的分组进行清理。",
14292
- "",
14293
- ".. 若不指定该参数，则表示不对分组数据进行清理。",
14294
- "",
14295
- "注意：若需指定该参数，必须指定 *forceTriggerTime*，且不能指定 *fill*。",
14296
- "",
14297
- "若需要查看清理前后的状态，可以通过调用 :doc:`../g/getStreamEngineStat` 函数查看 TimeSeriesEngine 引擎状态的 numGroups 列，来对比响应式状态引擎清理前后分组数的变化。",
14298
- "",
14299
- "`closed` 字符串，用于确定滑动窗口边界的开闭情况。可选值为 'left' 或 'right'，默认值为 'left'。",
14300
- "",
14301
- "* closed = 'left'： 窗口左闭右开",
14302
- "* closed = 'right'： 窗口左开右闭",
14303
- "",
14304
- ".. `closed` 字符串，表示对滑动窗口进行计算时需要排除的点，可选值为 'left' 或 'right'，默认值为 'left'。",
14305
- "",
14306
- ".. * closed = 'left'： 计算中将排除滑动窗口中的最后一个点",
14307
- ".. * 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。 ",
14308
14659
  ""
14309
14660
  ]
14310
14661
  }
@@ -14650,6 +15001,26 @@
14650
15001
  }
14651
15002
  ]
14652
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
+ },
14653
15024
  {
14654
15025
  "title": "参数",
14655
15026
  "type": "parameters",
@@ -14657,11 +15028,11 @@
14657
15028
  {
14658
15029
  "type": "text",
14659
15030
  "value": [
14660
- "`name` 必选参数，是一个字符串，表示流数据 window join 引擎的名称。",
15031
+ "`name` 必选参数，表示 window join 引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
14661
15032
  "",
14662
- "`leftTable` 和 `rightTable` 是表对象。可以不包含数据，但结构必须与订阅的流数据表相同。",
15033
+ "`leftTable` 和 `rightTable` 表对象。可以不包含数据，但结构必须与订阅的流数据表相同。",
14663
15034
  "",
14664
- "`outputTable` 必选参数，为计算结果的输出表。在使用 ``createWindowJoinEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。window join 引擎会将计算结果插入该表。",
15035
+ "`outputTable` 必选参数，为计算结果的输出表。window join 引擎会将计算结果插入该表。",
14665
15036
  "",
14666
15037
  "输出表各列的顺序为：时间列，连接列，计算结果列：",
14667
15038
  "",
@@ -14676,15 +15047,19 @@
14676
15047
  "",
14677
15048
  "`window` 必选参数，表示滑动窗口区间的整型或 DURATION 数据对，其中左右边界都包含在内。",
14678
15049
  "",
15050
+ ".. _metricsWJ:",
15051
+ "",
14679
15052
  "`metrics` 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
14680
15053
  "",
14681
15054
  "* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数，但不能是聚合函数。",
14682
15055
  "* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 <func(price) as \\`col1\\`col2>。",
14683
15056
  "",
14684
- "请注意，若 *metrics* 中指定了时间列或者连接列，需要在连接列或时间列前加上表名来指定该列所属的表，若不加表名，则默认取左表的列。例如：*matchingColumn* = \\`sym, *timeColumn* = \\`timestamp，则 *metrics* = <[rightTable.sym, rightTable.timestamp, price, val, price*val]> 指定 *metrics* 中输出右表的 sym 列和 timestamp 列。",
15057
+ "若在 *metrics* 指定了 *leftTable* 和 *rightTable* 中具有相同名称的列，默认取左表的列，可以通过 \"tableName.colName\" 指定该列来自哪个表。",
14685
15058
  "",
14686
15059
  "当以下函数只计算 *rightTable* 中的数据列时，window join 引擎对它们进行了优化：sum, sum2, avg, std, var, corr, covar, wavg, wsum, beta, max, min, last, first, med, percentile。",
14687
15060
  "",
15061
+ ".. _matchingColumnWJ:",
15062
+ "",
14688
15063
  "`matchingColumn` 表示连接列的字符串标量/向量/tuple，支持 Integral, Temproal 或 Literal（UUID 除外）类型。",
14689
15064
  "",
14690
15065
  "*matchingColumn* 指定规则：",
@@ -14697,33 +15072,13 @@
14697
15072
  "",
14698
15073
  "`useSystemTime` 可选参数，表示 *outputTable* 中第一列（时间列）为系统当前时间（*useSystemTime* = true）或左表的时间列（*useSystemTime* = false）。",
14699
15074
  "",
14700
- "`garbageSize` 可选参数，是正整数，默认值是5,000（单位为行）。随着订阅的流数据不断积累进入 window join 引擎，存放在内存中的数据会越来越多，这时需要清理不再需要的历史数据。当内存中历史数据行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。",
14701
- "",
14702
- "`maxDelayedTime` 可选参数，是正整数,默认值为3，单位为秒。通过设置该参数，帮助触发引擎中长时间未输出的分组数据进行计算。"
14703
- ]
14704
- }
14705
- ]
14706
- },
14707
- {
14708
- "title": "详情",
14709
- "type": "detail",
14710
- "children": [
14711
- {
14712
- "type": "text",
14713
- "value": [
14714
- "创建流数据 window join 引擎。返回一个左、右两表 :doc:`/SQLStatements/TableJoiners/windowjoin` 后的表对象。通常与 :doc:`../s/subscribeTable` 函数一起使用。",
14715
- "",
14716
- "请注意，向该引擎注入数据，仅可使用 :doc:`../a/appendForJoin`、:doc:`/FunctionsandCommands/FunctionReferences/g/getLeftStream` 或 :doc:`/FunctionsandCommands/FunctionReferences/g/getRightStream` 函数。",
14717
- "",
14718
- "该引擎的计算规则如下：",
14719
- "",
14720
- "\\1. 在 *matchingColumn* 对应的分组数据中，根据左表的某一行的时间戳，确定右表的一个时间窗口。当前窗口数据的计算将由该窗口结束后的第一条数据触发。",
15075
+ "`garbageSize` 可选参数，是正整数，默认值是5,000（单位为行）。随着订阅的流数据不断积累进入 window join 引擎，存放在内存中的数据会越来越多，这时需要清理不再需要的历史数据。当左/右两表各个分组内的数据行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。",
14721
15076
  "",
14722
- "\\2. 指定 *maxDelayedTime* 后，若当前窗口为该分组的最后一个窗口，当右表存在最新的时间戳 t1，使得 t1 > t + *window* 右边界 + *maxDelayedTime* 时，会触发计算当前窗口数据的计算。",
15077
+ ".. _maxDelayedTimeWJ:",
14723
15078
  "",
14724
- "请注意，向该引擎注入数据时，仅可使用 :doc:`../a/appendForJoin` 函数。",
14725
- "",
14726
- "从 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 精度一致。"
14727
15082
  ]
14728
15083
  }
14729
15084
  ]
@@ -15408,7 +15763,13 @@
15408
15763
  {
15409
15764
  "type": "text",
15410
15765
  "value": [
15411
- "计算 *X* 中第一个不为 *k* 的元素；若 *k* 未指定，则返回第一个不为 NULL 的元素。"
15766
+ "若 *X* 是向量：",
15767
+ "",
15768
+ "如果没有指定 *k*，对 *X* 内的每个元素，返回其之前所有元素中第一个不为 NULL 的元素。",
15769
+ "",
15770
+ "如果指定 *k*，对 *X* 内的每个元素，返回其之前所有元素中第一个不为 *k* 的元素。",
15771
+ "",
15772
+ "若 *X* 是矩阵，在每列内进行上述计算，返回一个与 *X* 维度相同的矩阵。"
15412
15773
  ]
15413
15774
  }
15414
15775
  ]
@@ -15511,7 +15872,13 @@
15511
15872
  {
15512
15873
  "type": "text",
15513
15874
  "value": [
15514
- "计算 *X* 中最后一个不为 *k* 的元素；若 *k* 未指定，则返回最后一个不为 NULL 的元素。"
15875
+ "若 *X* 是向量：",
15876
+ "",
15877
+ "如果没有指定 *k*，对 *X* 内的每个元素，返回其之前所有元素中最后一个不为 NULL 的元素。",
15878
+ "",
15879
+ "如果指定 *k*，对 *X* 内的每个元素，返回其之前所有元素中最后一个不为 *k* 的元素。",
15880
+ "",
15881
+ "若 *X* 是矩阵，在每列内进行上述计算，返回一个与 *X* 维度相同的矩阵。"
15515
15882
  ]
15516
15883
  }
15517
15884
  ]
@@ -17635,7 +18002,9 @@
17635
18002
  "value": [
17636
18003
  "创建一个数据库句柄。",
17637
18004
  "",
17638
- "我们需要指定 *partitionType* 和 *partitionScheme* 创建新的分布式数据库。当我们重新打开已有的分布式数据库，只需要指定 *directory*。我们不能用不同的 *partitionType* 或 *partitionScheme* 覆盖已有的分布式数据库。"
18005
+ "我们需要指定 *partitionType* 和 *partitionScheme* 创建新的分布式数据库。当我们重新打开已有的分布式数据库，只需要指定 *directory*。我们不能用不同的 *partitionType* 或 *partitionScheme* 覆盖已有的分布式数据库。",
18006
+ "",
18007
+ "请注意：当 *directory* 为本地磁盘路径时，将创建本地磁盘数据库。磁盘数据库仅应用于备份数据和本地计算的场景，其相较于分布式表，在使用上具有一定局限，例如不能进行权限控制等。"
17639
18008
  ]
17640
18009
  }
17641
18010
  ]
@@ -17647,7 +18016,7 @@
17647
18016
  {
17648
18017
  "type": "text",
17649
18018
  "value": [
17650
- "\\1.创建没有分区的数据库",
18019
+ "\\1.创建没有分区的磁盘数据库。",
17651
18020
  ""
17652
18021
  ]
17653
18022
  },
@@ -21711,7 +22080,7 @@
21711
22080
  {
21712
22081
  "type": "text",
21713
22082
  "value": [
21714
- "删除本地磁盘数据库：",
22083
+ "删除分布式数据库：",
21715
22084
  ""
21716
22085
  ]
21717
22086
  },
@@ -21725,20 +22094,20 @@
21725
22094
  " $ dates=2017.08.07..2017.08.11",
21726
22095
  " $ date=rand(dates, n)",
21727
22096
  " $ x=rand(10.0, n)",
21728
- " $ t=table(ID, date, x)",
22097
+ " $ t=table(ID, date, x);",
21729
22098
  " $ saveText(t, \"C:/DolphinDB/Data/t.txt\");",
21730
22099
  "",
21731
- " $ db = database(\"C:/DolphinDB/Data/rangedb\", RANGE, 0 5 10)",
21732
- " $ 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\");",
21733
22102
  "",
21734
- " $ dropDatabase(\"C:/DolphinDB/Data/rangedb\");",
22103
+ " $ dropDatabase(\"dfs://valueDB\")",
21735
22104
  ""
21736
22105
  ]
21737
22106
  },
21738
22107
  {
21739
22108
  "type": "text",
21740
22109
  "value": [
21741
- "删除分布式数据库：",
22110
+ "删除本地磁盘数据库：",
21742
22111
  ""
21743
22112
  ]
21744
22113
  },
@@ -21752,13 +22121,13 @@
21752
22121
  " $ dates=2017.08.07..2017.08.11",
21753
22122
  " $ date=rand(dates, n)",
21754
22123
  " $ x=rand(10.0, n)",
21755
- " $ t=table(ID, date, x);",
22124
+ " $ t=table(ID, date, x)",
21756
22125
  " $ saveText(t, \"C:/DolphinDB/Data/t.txt\");",
21757
22126
  "",
21758
- " $ db = database(\"dfs://valueDB\", VALUE, 2017.08.07..2017.08.11)",
21759
- " $ 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\");",
21760
22129
  "",
21761
- " $ dropDatabase(\"dfs://valueDB\")",
22130
+ " $ dropDatabase(\"C:/DolphinDB/Data/rangedb\");",
21762
22131
  ""
21763
22132
  ]
21764
22133
  },
@@ -22495,7 +22864,7 @@
22495
22864
  {
22496
22865
  "type": "text",
22497
22866
  "value": [
22498
- "`dnHandle` 是数据库句柄。",
22867
+ "`dbHandle` 是数据库句柄。",
22499
22868
  "",
22500
22869
  "`tableName` 是一个字符串，表示表名。"
22501
22870
  ]
@@ -25288,9 +25657,9 @@
25288
25657
  "type": "example",
25289
25658
  "children": [
25290
25659
  {
25291
- "type": "code",
25292
- "language": "console",
25660
+ "type": "text",
25293
25661
  "value": [
25662
+ ".. .. code:: console",
25294
25663
  "",
25295
25664
  " $ n=1000000",
25296
25665
  " $ ID=rand(10, n)",
@@ -25299,7 +25668,7 @@
25299
25668
  " $ x=rand(10.0, n)",
25300
25669
  " $ t=table(ID, date, x)",
25301
25670
  "",
25302
- " $ 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)",
25303
25672
  " $ pt = db.createPartitionedTable(t, `pt, `date);",
25304
25673
  " $ pt.append!(t);",
25305
25674
  "",
@@ -25308,12 +25677,7 @@
25308
25677
  "",
25309
25678
  " $ existsDatabase(\"C:/DolphinDB/Data/valueDB/20170807\");",
25310
25679
  " 0",
25311
- ""
25312
- ]
25313
- },
25314
- {
25315
- "type": "text",
25316
- "value": [
25680
+ "",
25317
25681
  "检查分布式数据库是否存在：",
25318
25682
  ""
25319
25683
  ]
@@ -25383,7 +25747,7 @@
25383
25747
  "* 若分区粒度为数据库级（ :doc:`../d/database` : *chunkGranularity* = 'DATABASE'），可以不指定该参数。",
25384
25748
  "* 若分区粒度为表级（ :doc:`../d/database` : *chunkGranularity* = 'TABLE'）",
25385
25749
  "",
25386
- " * *path* 指定的路径包含了物理索引（通过函数 :doc:`../l/listTables` 获取），可以不指定该参数。",
25750
+ " * 若 *path* 指定的路径包含了物理索引（通过函数 :doc:`../l/listTables` 获取），可以不指定该参数。",
25387
25751
  " * 否则，必须指定该参数。"
25388
25752
  ]
25389
25753
  }
@@ -25603,9 +25967,9 @@
25603
25967
  "type": "example",
25604
25968
  "children": [
25605
25969
  {
25606
- "type": "code",
25607
- "language": "console",
25970
+ "type": "text",
25608
25971
  "value": [
25972
+ ".. .. code:: console",
25609
25973
  "",
25610
25974
  " $ n=1000000",
25611
25975
  " $ ID=rand(10, n)",
@@ -25614,7 +25978,7 @@
25614
25978
  " $ x=rand(10.0, n)",
25615
25979
  " $ t=table(ID, date, x)",
25616
25980
  "",
25617
- " $ 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)",
25618
25982
  " $ pt = db.createPartitionedTable(t, `pt, `date);",
25619
25983
  " $ pt.append!(t);",
25620
25984
  "",
@@ -25626,12 +25990,7 @@
25626
25990
  "",
25627
25991
  " $ existsTable(\"C:/DolphinDB/Data\", `pt);",
25628
25992
  " 0",
25629
- ""
25630
- ]
25631
- },
25632
- {
25633
- "type": "text",
25634
- "value": [
25993
+ "",
25635
25994
  "检查分区是否在分布式文件系统中（以下脚本需要在集群的数据节点/计算节点中执行）：",
25636
25995
  ""
25637
25996
  ]
@@ -25992,7 +26351,7 @@
25992
26351
  {
25993
26352
  "type": "text",
25994
26353
  "value": [
25995
- "`filename` 是使用绝对路径的输入数据文件名z。",
26354
+ "`filename` 是使用绝对路径的输入数据文件名。",
25996
26355
  "",
25997
26356
  "`delimiter` 是表中列的分隔符。默认为逗号。",
25998
26357
  "",
@@ -28921,6 +29280,64 @@
28921
29280
  }
28922
29281
  ]
28923
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
+ },
28924
29341
  "getBackupList": {
28925
29342
  "title": "getBackupList",
28926
29343
  "type": "function",
@@ -29076,7 +29493,7 @@
29076
29493
  "language": "console",
29077
29494
  "value": [
29078
29495
  " ",
29079
- " $ getBackupMeta(\"/home/DolphinDB/backup\",\"dfs://valuedb\", \"/200001M/2\",\"pt\")",
29496
+ " $ getBackupMeta(\"/home/DolphinDB/backup\",\"dfs://valuedb\", \"/200001M\",\"pt\")",
29080
29497
  "",
29081
29498
  " schema->",
29082
29499
  " name typeString typeInt comment",
@@ -29476,13 +29893,13 @@
29476
29893
  " ",
29477
29894
  "* versionChain: 版本链",
29478
29895
  "",
29479
- "* state: chunk 状态。CONSTRUCTING：正在事务中； RECOVERING：正在 recovery 中；COMPLETE：已经处于事务终止状态；",
29896
+ "* state: chunk 状态。CONSTRUCTING：正在事务中； RECOVERING：正在 recovery 中；COMPLETE：已经处于事务终止状态",
29480
29897
  "",
29481
29898
  "* replicas: 副本的分布信息",
29482
29899
  "",
29483
29900
  "* replicaCount: 副本数",
29484
29901
  "",
29485
- "* permission: CHUNK 的权限。CHUNK 的权限分为 READ_ONLY 以及 READ_WRITE（默认权限）两类。正在进行迁移的分区，或存储在 s3 的分区权限均为 READ_ONLY。",
29902
+ "* permission: CHUNK 的权限。CHUNK 的权限分为 READ_ONLY 以及 READ_WRITE（默认权限）两类。正在进行迁移的分区，或存储在 s3 的分区权限均为 READ_ONLY",
29486
29903
  "",
29487
29904
  "对于 READ_ONLY 权限的分区：",
29488
29905
  "",
@@ -29700,11 +30117,11 @@
29700
30117
  "* memoryAlloc：系统已分配给当前节点的内存（单位：字节）。",
29701
30118
  "* cpuUsage：CPU 使用率。",
29702
30119
  "* avgLoad：CPU 平均负载。",
29703
- "* medLast10QueryTime：前 10 个完成的查询执行所耗费时间的中间值（单位：毫秒）。",
29704
- "* maxLast10QueryTime：前 10 个完成的查询执行所耗费时间的最大值（单位：毫秒）。",
29705
- "* medLast100QueryTime：前 100 个完成的查询执行所耗费时间的中间值（单位：毫秒）。",
29706
- "* maxLast100QueryTime：前100个完成的查询执行所耗费时间的最大值（单位：毫秒）。",
29707
- "* maxRunningQueryTime：当前正在执行的查询的耗费时间的最大值（单位：毫秒）。",
30120
+ "* medLast10QueryTime：前 10 个完成的查询执行所耗费时间的中间值（单位：纳秒）。",
30121
+ "* maxLast10QueryTime：前 10 个完成的查询执行所耗费时间的最大值（单位：纳秒）。",
30122
+ "* medLast100QueryTime：前 100 个完成的查询执行所耗费时间的中间值（单位：纳秒）。",
30123
+ "* maxLast100QueryTime：前100个完成的查询执行所耗费时间的最大值（单位：纳秒）。",
30124
+ "* maxRunningQueryTime：当前正在执行的查询的耗费时间的最大值（单位：纳秒）。",
29708
30125
  "* runningJobs：正在执行中的 Job 个数。",
29709
30126
  "* queuedJobs：队列中的 Job 个数。",
29710
30127
  "* runningTasks：正在执行中的 Task 个数。",
@@ -29722,8 +30139,8 @@
29722
30139
  "* lastMinuteNetworkSend：前一分钟网络发送字节数（单位：字节）。",
29723
30140
  "* lastMinuteNetworkRecv：前一分钟网络接收字节数 （单位：字节）。",
29724
30141
  "* publicName：若为控制节点，且配置了 publicName，则显示 publicName；否则显示控制节点所在服务器的 网卡地址。若为数据节点或代理节点，则显示数据节点或代理节点所在服务器的网卡地址。",
29725
- "* lastMsgLatency：前一批消息的延时（单位：毫秒）。",
29726
- "* cumMsgLatency：所有消息的平均延时（单位：毫秒）。",
30142
+ "* lastMsgLatency：流数据订阅节点最后收到的消息的延时（单位：毫秒）。",
30143
+ "* cumMsgLatency：流数据订阅节点所有已接收的消息的平均延时（单位：毫秒）。",
29727
30144
  "* isLeader：是否是 raft 组的 leader，该字段仅在配置了控制节点高可用时才生效。请注意，若 raft 组存在宕机的节点，则该节点的 isLeader 将返回空值。",
29728
30145
  ""
29729
30146
  ]
@@ -30484,7 +30901,15 @@
30484
30901
  "language": "console",
30485
30902
  "value": [
30486
30903
  " ",
30487
- " $ getDFSTablesByDatabase()"
30904
+ " $ getDFSTablesByDatabase(\"dfs://db\")",
30905
+ " [\"dfs://db1/dt\", \"dfs://db1/dt1\"]",
30906
+ ""
30907
+ ]
30908
+ },
30909
+ {
30910
+ "type": "text",
30911
+ "value": [
30912
+ ".. 相关函数：:doc:`getTables`"
30488
30913
  ]
30489
30914
  }
30490
30915
  ]
@@ -32094,7 +32519,36 @@
32094
32519
  {
32095
32520
  "type": "text",
32096
32521
  "value": [
32097
- "以字典的形式返回本地节点上的多个性能监控度量值。"
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
+ ""
32098
32552
  ]
32099
32553
  }
32100
32554
  ]
@@ -32491,23 +32945,23 @@
32491
32945
  "",
32492
32946
  "返回一个表，包含以下列：",
32493
32947
  "",
32494
- "* TaskId: 表示恢复副本任务的 ID。",
32495
- "* TaskType: 恢复任务的类型，包括 LoadRebalance 和 ChunkRecovery 。",
32496
- "* ChunkId: 分区的 ID。",
32497
- "* ChunkPath: 分区的 DFS 路径。",
32498
- "* Source: 恢复数据的源节点，即正常的数据节点。",
32499
- "* Dest: 需要进行数据恢复的节点(目的节点)。",
32500
- "* Status: 数据恢复的状态，包括 “Waiting”, “In-Progress”, “Finish”。",
32501
- "* AttemptCount: 恢复任务尝试的次数。",
32502
- "* DeleteSource: 是否删除源节点的数据。当 TaskType 是 ChunkRecovery 时，只能返回 false；当 TaskType 是 LoadRebalance 时，可以返回 true 或 false。",
32503
- "* StartTime: 创建恢复任务的时间。",
32504
- "* LastDequeueTime: 任务最后一次从任务队列出队的时间。",
32505
- "* LastStartTime: 最后一次开始执行任务的时间。",
32506
- "* FinishTime: 任务结束的时间。",
32507
- "* IsIncrementalRecovery: 是否启用增量复制。",
32508
- "* IsAsyncRecovery: 是否启用异步复制。",
32509
- "* ChangeFromIncrementalToFull: 是否从增量恢复转为全量恢复。系统多次尝试增量恢复失败会自动转换成全量恢复。",
32510
- "* 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：节点在线恢复时，从异步恢复阶段转为同步恢复阶段的时刻。",
32511
32965
  "* FailureReason：recovery 任务失败的原因。"
32512
32966
  ]
32513
32967
  }
@@ -32632,11 +33086,11 @@
32632
33086
  "获取 redo log 垃圾回收的状态。返回一个表对象，包含以下几列：",
32633
33087
  "",
32634
33088
  "* physicalName：物理表名，格式为 \"/数据库名/物理表名\"",
32635
- "* txnCount：redo log 尚未回收的事务数。",
32636
- "* numOfTxnPendingGC：等待回收的事务数。",
32637
- "* minTidPendingGC：等待回收的事务的最小 tid。",
32638
- "* numOfTxnPendingFlush：等待刷盘的事务数。",
32639
- "* minTidPendingFlush：等待刷盘的事务的最小 tid。"
33089
+ "* txnCount：redo log 尚未回收的事务数",
33090
+ "* numOfTxnPendingGC：等待回收的事务数",
33091
+ "* minTidPendingGC：等待回收的事务的最小 tid",
33092
+ "* numOfTxnPendingFlush：等待刷盘的事务数",
33093
+ "* minTidPendingFlush：等待刷盘的事务的最小 tid"
32640
33094
  ]
32641
33095
  }
32642
33096
  ]
@@ -33120,7 +33574,7 @@
33120
33574
  "numRows 时间序列引擎中的记录行数",
33121
33575
  "numMetrics 时间序列引擎使用的聚合指标的数量",
33122
33576
  "metrics 时间序列引擎使用的聚合指标的元代码",
33123
- "memoryUsed 时间序列引擎所占用内存量",
33577
+ "memoryUsed 时间序列引擎所占用内存量，单位为字节",
33124
33578
  "snapshotDir 保存引擎快照的文件目录",
33125
33579
  "snapshotInterval 每隔多少条数据保存一次引擎快照",
33126
33580
  "snapshotMsgId 最后一个 snapshot 的 msgId",
@@ -33141,7 +33595,7 @@
33141
33595
  "metrics\t\t\t 横截面引擎使用的聚合指标的元代码",
33142
33596
  "triggeringPattern\t横截面引擎触发计算的方式",
33143
33597
  "triggeringInterval\t横截面引擎触发计算的时间间隔",
33144
- "memoryUsed 横截面引擎所占用内存量",
33598
+ "memoryUsed 横截面引擎所占用内存量，单位为字节",
33145
33599
  "================== =================================================",
33146
33600
  "",
33147
33601
  "* 表 AnomalyDetectionEngine 返回异常检测引擎的状态。它包含以下列：",
@@ -33162,7 +33616,7 @@
33162
33616
  "snapshotMsgId 最后一个 snapshot 的 msgId",
33163
33617
  "snapshotTimestam 引擎快照的时间戳",
33164
33618
  "garbageSize 触发内存清理的阈值",
33165
- "memoryUsed 异常检测引擎所占用内存量",
33619
+ "memoryUsed 异常检测引擎所占用内存量，单位为字节",
33166
33620
  "===================== ====================================================",
33167
33621
  "",
33168
33622
  "",
@@ -33178,7 +33632,7 @@
33178
33632
  "numGroups 响应式状态引擎中的分组数",
33179
33633
  "numRows 响应式状态引擎中的记录行数",
33180
33634
  "numMetrics 指标的数量",
33181
- "memoryUsed 响应式状态引擎所占用内存量",
33635
+ "memoryUsed 响应式状态引擎所占用内存量，单位为字节",
33182
33636
  "snapshotDir 保存引擎快照的文件目录",
33183
33637
  "snapshotInterval 每隔多少条数据保存一次引擎快照",
33184
33638
  "snapshotMsgId 最后一个 snapshot 的 msgId",
@@ -33200,7 +33654,7 @@
33200
33654
  "numRows 会话窗口引擎中的记录行数",
33201
33655
  "numMetrics 指标的数量",
33202
33656
  "Metrics 会话窗口聚合引擎使用的聚合指标的元代码",
33203
- "memoryUsed 会话窗口引擎所占用内存量",
33657
+ "memoryUsed 会话窗口引擎所占用内存量，单位为字节",
33204
33658
  "snapshotDir 会话窗口引擎快照保存的文件目录",
33205
33659
  "snapshotInterval 每隔多少条数据保存一次引擎快照",
33206
33660
  "snapshotMsgId 最后一个 snapshot 的 msgId",
@@ -33224,7 +33678,7 @@
33224
33678
  "numRows 日级时间序列引擎中的记录行数",
33225
33679
  "numMetrics 日级时间序列引擎使用的聚合指标的数量",
33226
33680
  "metrics 日级时间序列引擎使用的聚合指标的元代码",
33227
- "memoryUsed 日级时间序列引擎所占用内存量",
33681
+ "memoryUsed 日级时间序列引擎所占用内存量，单位为字节",
33228
33682
  "snapshotDir 日级时间序列聚合引擎快照保存的文件目录",
33229
33683
  "snapshotInterval 每隔多少条数据保存一次引擎快照",
33230
33684
  "snapshotMsgId 最后一个 snapshot 的 msgId",
@@ -33247,7 +33701,7 @@
33247
33701
  "rightTableNumRows asof join 引擎右表中的记录行数",
33248
33702
  "numMetrics asof join 引擎使用的聚合指标的数量",
33249
33703
  "metrics asof join 引擎使用的聚合指标的元代码",
33250
- "memoryUsed asof join 引擎所占用内存量",
33704
+ "memoryUsed asof join 引擎所占用内存量，单位为字节",
33251
33705
  "================== =================================================",
33252
33706
  "",
33253
33707
  "* 表 EqualJoinEngine 返回 equal join 引擎的状态。它包含以下列：",
@@ -33264,7 +33718,7 @@
33264
33718
  "rightTableNumRows equal join 引擎右表中的记录行数",
33265
33719
  "numMetrics equal join 引擎使用的聚合指标的数量",
33266
33720
  "metrics equal join 引擎使用的聚合指标的元代码",
33267
- "memoryUsed equal join 引擎所占用内存量",
33721
+ "memoryUsed equal join 引擎所占用内存量，单位为字节",
33268
33722
  "================== =================================================",
33269
33723
  "",
33270
33724
  "* 表 StreamFilter 返回流数据过滤引擎的状态。它包含以下列：",
@@ -33821,15 +34275,13 @@
33821
34275
  "| OLAP CACHE ENGINE | OLAP 引擎 cache Engine 的状态信息，包含各节点的内存信息以及当前节点的状态表。 | ``pnodeRun(getCacheEngineMemSize)`` |",
33822
34276
  "| STATUS | | ``pnodeRun(getCacheEngineStat)`` |",
33823
34277
  "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
33824
- "| TSDB META | 获取 TSDB 引擎下所有 chunk 的元数据。 | ``pnodeRun(getTSDBMetaData)`` |",
33825
- "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
33826
34278
  "| REDO LOG GC STATUS | 获取事务 redo log 回收的状态。 | ``pnodeRun(getRedoLogGCStat)`` |",
33827
34279
  "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
33828
34280
  "| TRANSACTION STATUS | 获取事务的状态。 | ``pnodeRun(getTransactionStatus)`` |",
33829
34281
  "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
33830
- "| TABLETS META | 返回集群中行数最多的前100个 chunk 的元数据信息。 | select top 100 \\* from pnodeRun(getTable|",
33831
- "| | | tsMeta{\"%\",\"%\",false,-1}) order by |",
33832
- "| | | rowNum desc |",
34282
+ "| TABLETS META | 返回集群中行数最多的前100个 chunk 的元数据信息。 |select top 100 \\* from pnodeRun(getTable |",
34283
+ "| | |tsMeta{\"%\",\"%\",false,-1}) order by |",
34284
+ "| | |rowNum desc |",
33833
34285
  "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
33834
34286
  "|ANOMALOUS CHUNK STATUS| 获取处于异常状态的 chunk 信息。异常状态包含处于 recovery 状态，版本号不一致， | ``getClusterChunksStatus()`` |",
33835
34287
  "|(only in cluster mode)| 副本数不一致等。 | |",
@@ -34023,14 +34475,21 @@
34023
34475
  " $ y=rand(10, n)",
34024
34476
  " $ t1=table(ID, date, x)",
34025
34477
  " $ t2=table(ID, date, y)",
34026
- " $ 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)",
34027
34479
  " $ pt1 = db.createPartitionedTable(t1, `pt1, `date)",
34028
34480
  " $ pt1.append!(t1)",
34029
34481
  " $ pt2 = db.createPartitionedTable(t2, `pt2, `date)",
34030
34482
  " $ pt2.append!(t2);",
34031
34483
  " $ getTables(db);",
34032
34484
  "",
34033
- " [\"pt1\",\"pt2\"]"
34485
+ " [\"pt1\",\"pt2\"]",
34486
+ ""
34487
+ ]
34488
+ },
34489
+ {
34490
+ "type": "text",
34491
+ "value": [
34492
+ ".. 相关函数：:doc:`getDFSTablesByDatabase`"
34034
34493
  ]
34035
34494
  }
34036
34495
  ]
@@ -34839,7 +35298,7 @@
34839
35298
  "",
34840
35299
  "`mean` 可选参数，向量/矩阵。表示模型初始化的均值。若 *X* 为一元数据，则 *mean* 是元素个数为 *k* 的向量；若 *X* 为多元数据，则 *mean* 是列数为 *k*，行数与 *X* 的元数相同的矩阵。若不指定，系统随机从 *X* 中选择 *k* 个值作为模型的初始化均值。",
34841
35300
  "",
34842
- "`sigma` 可选参数，向量/元组，元素个数为 *k*。若 *X* 为一元数据，表示每个子模型初始化的方差；若 *X* 为多元数据，表示每个子模型初始化的协方差矩阵。若不指定，系统使用元素值为 1 的向量或单位矩阵。",
35301
+ "`sigma` 可选参数，向量/元组，元素个数为 *k*。若 *X* 为一元数据，表示每个子模型初始化的方差；若 *X* 为多元数据，表示每个子模型初始化的协方差矩阵。若不指定，系统使用 1 作为方差，或单位矩阵作为协方差矩阵。",
34843
35302
  ""
34844
35303
  ]
34845
35304
  }
@@ -34854,7 +35313,7 @@
34854
35313
  "value": [
34855
35314
  "通过数据集训练 GMM（高斯混合模型）。返回一个字典，包含以下键值：",
34856
35315
  "",
34857
- "* modelName：字符串 \"Gaussian Mixture Model\"",
35316
+ "* modelName：字符串 \"Gaussian Mixture Model\"。",
34858
35317
  "* prior：观测数据属于各子模型的先验概率。",
34859
35318
  "* mean：训练获得的每个子模型的期望。",
34860
35319
  "* sigma：若 *X* 为 一元数据，表示训练获得的每个子模型的方差；若 *X* 为多元数据，表示训练获得的每个子模型的协方差矩阵。"
@@ -37588,7 +38047,7 @@
37588
38047
  "",
37589
38048
  "`colTypes` 是向量，表示各列的数据类型。",
37590
38049
  "",
37591
- "第三种用法中，table是一个表。注意，`table` 中的 `keyColumns` 不能包含重复值。"
38050
+ "第三种用法中，*table* 是一个表。注意，`table` 中的 `keyColumns` 不能包含重复值。"
37592
38051
  ]
37593
38052
  }
37594
38053
  ]
@@ -37608,10 +38067,12 @@
37608
38067
  "",
37609
38068
  "对于索引内存表，满足以下条件，SQL查询性能会优于普通内存表：",
37610
38069
  "",
37611
- "* 查询语句必须包含keyColumns的第1列，且该列使用的过滤条件只能使用=或in，且该条件后面不能跟or语句；",
37612
- "* 所有过滤条件使用的in谓词次数小于等于两次。",
38070
+ "* 查询语句必须包含 *keyColumns* 的第 1 列，且该列使用的过滤条件只能使用 = 或 in，且该条件后面不能跟 or 语句；",
38071
+ "* 所有过滤条件使用的 in 谓词次数小于等于两次。",
37613
38072
  "",
37614
- "请对比 :doc:`键值内存表 <../k/keyedTable>` 优化SQL查询条件。"
38073
+ "查询 ``indexedTable`` 时，建议调用 :doc:`../s/sliceByKey` 以提高性能。",
38074
+ "",
38075
+ "请对比 :doc:`键值内存表 <../k/keyedTable>` 优化 SQL 查询条件。"
37615
38076
  ]
37616
38077
  }
37617
38078
  ]
@@ -37810,16 +38271,19 @@
37810
38271
  "value": [
37811
38272
  "",
37812
38273
  " $ timer(100) select * from t where id=500000;",
37813
- " Time elapsed: 66.855 ms",
38274
+ " Time elapsed: 177.286 ms",
37814
38275
  "",
37815
38276
  " $ timer(100) select * from t1 where id=500000;",
37816
- " Time elapsed: 1.001 ms",
38277
+ " Time elapsed: 1.245 ms",
38278
+ "",
38279
+ " $ timer(100) sliceByKey(t1, 500000)",
38280
+ " Time elapsed: 0.742 ms",
37817
38281
  "",
37818
38282
  " $ timer(100) select * from t where id in [500000, 600000, 700000];",
37819
- " Time elapsed: 576.49 ms",
38283
+ " Time elapsed: 1134.429 ms",
37820
38284
  "",
37821
38285
  " $ timer(100) select * from t1 where id in [500000, 600000, 700000];",
37822
- " Time elapsed: 1 ms",
38286
+ " Time elapsed: 1.377 ms",
37823
38287
  ""
37824
38288
  ]
37825
38289
  },
@@ -37836,10 +38300,10 @@
37836
38300
  "value": [
37837
38301
  "",
37838
38302
  " $ timer(100) select * from t where id between 500000:500010;",
37839
- " Time elapsed: 64.862 ms",
38303
+ " Time elapsed: 641.544 ms",
37840
38304
  "",
37841
38305
  " $ timer(100) select * from t1 where id between 500000:500010;",
37842
- " Time elapsed: 64.858 ms",
38306
+ " Time elapsed: 599.752 ms",
37843
38307
  ""
37844
38308
  ]
37845
38309
  },
@@ -37856,10 +38320,10 @@
37856
38320
  "value": [
37857
38321
  "",
37858
38322
  " $ timer(100) select * from t where id=500000, type in [3,6];",
37859
- " Time elapsed: 65.861 ms",
38323
+ " Time elapsed: 172.808 ms",
37860
38324
  "",
37861
38325
  " $ timer(100) select * from t1 where id=500000, type in [3,6];",
37862
- " Time elapsed: 0.995 ms",
38326
+ " Time elapsed: 1.664 ms",
37863
38327
  ""
37864
38328
  ]
37865
38329
  },
@@ -37876,16 +38340,16 @@
37876
38340
  "value": [
37877
38341
  "",
37878
38342
  " $ timer(100) select * from t where date in [2012.06.03, 2012.06.06];",
37879
- " Time elapsed: 285.24 ms",
38343
+ " Time elapsed: 490.182 ms",
37880
38344
  "",
37881
38345
  " $ timer(100) select * from t1 where date in [2012.06.03, 2012.06.06];",
37882
- " Time elapsed: 271.325 ms",
38346
+ " Time elapsed: 544.015 ms",
37883
38347
  "",
37884
38348
  " $ timer(100) select * from t where date=2012.06.03, type=8;",
37885
- " Time elapsed: 74.835 ms",
38349
+ " Time elapsed: 205.443 ms",
37886
38350
  "",
37887
38351
  " $ timer(100) select * from t1 where date=2012.06.03, type=8;",
37888
- " Time elapsed: 77.828 ms",
38352
+ " Time elapsed: 204.532 ms",
37889
38353
  ""
37890
38354
  ]
37891
38355
  },
@@ -37902,10 +38366,10 @@
37902
38366
  "value": [
37903
38367
  "",
37904
38368
  " $ timer(100) select * from t where id in [100,200], date in [2012.06.03, 2012.06.06], type in [3,6];",
37905
- " Time elapsed: 98.767 ms",
38369
+ " Time elapsed: 208.714 ms",
37906
38370
  "",
37907
38371
  " $ timer(100) select * from t1 where id in [100,200], date in [2012.06.03, 2012.06.06], type in [3,6];",
37908
- " Time elapsed: 99.736 ms",
38372
+ " Time elapsed: 198.674 ms",
37909
38373
  ""
37910
38374
  ]
37911
38375
  },
@@ -40652,7 +41116,10 @@
40652
41116
  "value": [
40653
41117
  "`X` 数值型向量/矩阵/表。",
40654
41118
  "",
40655
- "`strict` 布尔值，表示是否取严格的峰值点。默认值为 true。"
41119
+ "`strict` 布尔值，默认值为 true。",
41120
+ "",
41121
+ " * 若 *strict* = true，相邻元素不为空且严格小于该元素；",
41122
+ " * 若 *strict* = false，相邻元素不为空且小于等于该元素；"
40656
41123
  ]
40657
41124
  }
40658
41125
  ]
@@ -40666,11 +41133,6 @@
40666
41133
  "value": [
40667
41134
  "若 *X* 为向量，计算 *X* 中的每个元素是否为峰值点，若是则返回 true，否则返回 false。",
40668
41135
  "",
40669
- "判断规则为：",
40670
- "",
40671
- "* 若 *strict* = true，相邻元素不为空且严格小于该元素；",
40672
- "* 若 *strict* = false，相邻元素不为空且小于等于该元素；",
40673
- "",
40674
41136
  "若 *X* 为矩阵，在每列进行上述计算，返回值一个同 X 维度相同的矩阵。若 *X* 为表，则只对数值型的列进行上述计算。"
40675
41137
  ]
40676
41138
  }
@@ -41197,7 +41659,7 @@
41197
41659
  {
41198
41660
  "type": "text",
41199
41661
  "value": [
41200
- "检查每个元素是否是 NULL。如果它不是 NULL，返回 1，否则返回 0。"
41662
+ "检查每个元素是否为有效数（非 NULL 值）。如果是，返回 1，否则返回 0。"
41201
41663
  ]
41202
41664
  }
41203
41665
  ]
@@ -41250,7 +41712,10 @@
41250
41712
  "value": [
41251
41713
  "`X` 数值型向量/矩阵/表。",
41252
41714
  "",
41253
- "`strict` 布尔值，表示是否取严格的谷值点。默认值为 true。"
41715
+ "`strict` 布尔值，表示是否取严格的谷值点。默认值为 true。",
41716
+ "",
41717
+ " * 若 *strict* = true，相邻元素不为空且严格大于该元素；",
41718
+ " * 若 *strict* = false，相邻元素不为空且大于等于该元素；"
41254
41719
  ]
41255
41720
  }
41256
41721
  ]
@@ -41264,11 +41729,6 @@
41264
41729
  "value": [
41265
41730
  "若 *X* 为向量，计算 *X* 中的每个元素是否为谷值点，若是则返回 true，否则返回 false。",
41266
41731
  "",
41267
- "判断规则为：",
41268
- "",
41269
- "* 若 *strict* = true，相邻元素不为空且严格大于该元素；",
41270
- "* 若 *strict* = false，相邻元素不为空且大于等于该元素；",
41271
- "",
41272
41732
  "若 *X* 为矩阵，在每列进行上述计算，返回值一个同 X 维度相同的矩阵。若 *X* 为表，则只对数值型的列进行上述计算。"
41273
41733
  ]
41274
41734
  }
@@ -42803,12 +43263,14 @@
42803
43263
  "",
42804
43264
  "注意：",
42805
43265
  "",
42806
- "对于键值内存表，满足以下条件，SQL查询性能会优于普通内存表：",
43266
+ "对于键值内存表，满足以下条件，SQL 查询性能会优于普通内存表：",
43267
+ "",
43268
+ "* SQL语句中只能使用 =, in 或 and, 且 in 谓词使用小于等于两次；",
43269
+ "* 查询语句必须包含 *keyColumns* 所有列。",
42807
43270
  "",
42808
- "* SQL语句中只能使用=, in或and, 且in谓词使用小于等于两次；",
42809
- "* 查询语句必须包含keyColumns所有列。",
43271
+ "查询 ``keyedTable`` 时，建议调用 :doc:`../s/sliceByKey` 以提高性能。",
42810
43272
  "",
42811
- "请对比 :doc:`索引内存表 <../i/indexedTable>` 优化SQL查询条件。",
43273
+ "请对比 :doc:`索引内存表 <../i/indexedTable>` 优化 SQL 查询条件。",
42812
43274
  "",
42813
43275
  "具体请参考例3。"
42814
43276
  ]
@@ -43038,10 +43500,13 @@
43038
43500
  "value": [
43039
43501
  "",
43040
43502
  " $ timer(100) select * from t where id=500000, date=2012.06.01, type=0;",
43041
- " Time elapsed: 63.864 ms",
43503
+ " Time elapsed: 161.574 ms",
43042
43504
  "",
43043
43505
  " $ timer(100) select * from kt where id=500000, date=2012.06.01, type=0;",
43044
- " 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",
43045
43510
  ""
43046
43511
  ]
43047
43512
  },
@@ -43058,17 +43523,17 @@
43058
43523
  "value": [
43059
43524
  "",
43060
43525
  " $ timer(100) select * from t where id in [1, 500000], date in 2012.06.01..2012.06.05, type=5;",
43061
- " Time elapsed: 507.676 ms",
43526
+ " Time elapsed: 894.241 ms",
43062
43527
  "",
43063
43528
  " $ timer(100) select * from kt where id in [1, 500000], date in 2012.06.01..2012.06.05, type=5;",
43064
- " Time elapsed: 1.002 ms",
43529
+ " Time elapsed: 2.322 ms",
43065
43530
  ""
43066
43531
  ]
43067
43532
  },
43068
43533
  {
43069
43534
  "type": "text",
43070
43535
  "value": [
43071
- "in谓词数量超过两个时，键值内存表不会进行查询优化：",
43536
+ "in 谓词数量超过两个时，键值内存表不会进行查询优化：",
43072
43537
  "",
43073
43538
  "例3.3",
43074
43539
  ""
@@ -43080,10 +43545,10 @@
43080
43545
  "value": [
43081
43546
  "",
43082
43547
  " $ timer(100) select * from t where id in [1, 500000], date in 2012.06.01..2012.06.05, type in 1..5;",
43083
- " Time elapsed: 504.65 ms",
43084
- "",
43548
+ " Time elapsed: 801.347 ms",
43549
+ " ",
43085
43550
  " $ timer(100) select * from kt where id in [1, 500000], date in 2012.06.01..2012.06.05, type in 1..5;",
43086
- " Time elapsed: 511.665 ms",
43551
+ " Time elapsed: 834.184 ms",
43087
43552
  ""
43088
43553
  ]
43089
43554
  },
@@ -43102,10 +43567,10 @@
43102
43567
  "value": [
43103
43568
  "",
43104
43569
  " $ timer(100) select * from t where id=500000, date in 2012.06.01..2012.06.05;",
43105
- " Time elapsed: 64.861 ms",
43570
+ " Time elapsed: 177.113 ms",
43106
43571
  "",
43107
43572
  " $ timer(100) select * from kt where id=500000, date in 2012.06.01..2012.06.05;",
43108
- " Time elapsed: 64.863 ms",
43573
+ " Time elapsed: 163.265 ms",
43109
43574
  " "
43110
43575
  ]
43111
43576
  },
@@ -44946,7 +45411,7 @@
44946
45411
  "language": "console",
44947
45412
  "value": [
44948
45413
  "",
44949
- " $ loadBackup(\"/home/DolphinDB/backup\",\"dfs://valuedb\", \"/200001M/2\",\"pt\");",
45414
+ " $ loadBackup(\"/home/DolphinDB/backup\",\"dfs://valuedb\", \"/200001M\",\"pt\");",
44950
45415
  ""
44951
45416
  ]
44952
45417
  },
@@ -45830,13 +46295,14 @@
45830
46295
  {
45831
46296
  "type": "text",
45832
46297
  "value": [
45833
- "`database` 可以是字符串，表示数据库的路径，也可以是数据库句柄。",
46298
+ "`database` 字符串，表示数据库的路径，也可以是数据库句柄。可以是分布式数据库或本地磁盘数据库。",
45834
46299
  "",
45835
- "`tableName` 是字符串，表示表的名称，它需要使用反引号(`)或双引号。",
46300
+ "`tableName` 字符串，表示表的名称，它需要使用反引号(`)或双引号。",
45836
46301
  "",
45837
- "`partitions` 是标量或向量，表示要加载的分区。注意，只有本地磁盘数据库支持该参数，分布式数据库不支持该参数。",
46302
+ "`partitions` 标量或向量，表示要加载的分区。注意，只有本地磁盘数据库支持该参数，分布式数据库不支持该参数。",
45838
46303
  "",
45839
- "`memoryMode` 是布尔值，表示是否把数据加载到内存。如果 *memoryMode* =false，表示只加载元数据到内存；如果 *memoryMode* =true，表示将实际数据加载到内存。注意，只有本地磁盘数据库支持该参数，分布式数据库不支持该参数。对于分布式数据库，只将元数据加载到内存中。"
46304
+ "`memoryMode` 布尔值，表示是否把数据加载到内存。如果 *memoryMode* =false，表示只加载元数据到内存；如果 *memoryMode* =true，",
46305
+ "表示将实际数据加载到内存。注意，只有本地磁盘数据库支持该参数，分布式数据库不支持该参数。对于分布式数据库，只将元数据加载到内存中。"
45840
46306
  ]
45841
46307
  }
45842
46308
  ]
@@ -45957,14 +46423,9 @@
45957
46423
  {
45958
46424
  "type": "text",
45959
46425
  "value": [
45960
- "* 加载本地磁盘未分区表：",
45961
- ""
45962
- ]
45963
- },
45964
- {
45965
- "type": "code",
45966
- "language": "console",
45967
- "value": [
46426
+ ".. * 加载本地磁盘未分区表：",
46427
+ "",
46428
+ ".. .. code:: console",
45968
46429
  "",
45969
46430
  " $ n=2000000",
45970
46431
  " $ syms=`IBM`C`MS`MSFT`JPM`ORCL`FB`GE",
@@ -45981,20 +46442,10 @@
45981
46442
  "",
45982
46443
  " $ // alternatively, we can specify the folder path to load a table:",
45983
46444
  " $ tt=loadTable(\"C:/DolphinDB/Data/db01\",`t1);",
45984
- ""
45985
- ]
45986
- },
45987
- {
45988
- "type": "text",
45989
- "value": [
45990
- "* 加载本地磁盘分区表的某些分区：",
45991
- ""
45992
- ]
45993
- },
45994
- {
45995
- "type": "code",
45996
- "language": "console",
45997
- "value": [
46445
+ "",
46446
+ ".. * 加载本地磁盘分区表的某些分区：",
46447
+ "",
46448
+ ".. .. code:: console",
45998
46449
  "",
45999
46450
  " $ n = 2000000",
46000
46451
  " $ workDir = \"C:/DolphinDB/Data\"",
@@ -46005,56 +46456,26 @@
46005
46456
  " $ db = database(workDir + \"/trade1\",VALUE,`IBM`MSFT`GM`C`YHOO`GOOG)",
46006
46457
  " $ db.loadTextEx(\"trades\",\"sym\", workDir + \"/trades.txt\")",
46007
46458
  " $ trades = db.loadTable(\"trades\",`IBM`GM`YHOO,1)",
46008
- ""
46009
- ]
46010
- },
46011
- {
46012
- "type": "text",
46013
- "value": [
46014
- "对于范围分区，我们可以使用范围中的某个值表示整个分区。",
46015
- ""
46016
- ]
46017
- },
46018
- {
46019
- "type": "code",
46020
- "language": "console",
46021
- "value": [
46459
+ "",
46460
+ ".. 对于范围分区，我们可以使用范围中的某个值表示整个分区。",
46461
+ "",
46462
+ ".. .. code:: console",
46022
46463
  "",
46023
46464
  " $ db = database(workDir + \"/trade2\",RANGE,[2000.01.01, 2000.04.01, 2000.07.01, 2000.10.01, 2001.01.01])",
46024
46465
  " $ db.loadTextEx(\"trades\",\"date\", workDir + \"/trades.txt\")",
46025
- ""
46026
- ]
46027
- },
46028
- {
46029
- "type": "text",
46030
- "value": [
46031
- "下面两个命令类似：",
46032
- ""
46033
- ]
46034
- },
46035
- {
46036
- "type": "code",
46037
- "language": "console",
46038
- "value": [
46466
+ "",
46467
+ ".. 下面两个命令类似：",
46468
+ "",
46469
+ ".. .. code:: console",
46039
46470
  "",
46040
46471
  " $ trades = db.loadTable(\"trades\",[2000.01.01, 2000.07.01],true)",
46041
46472
  " $ trades = db.loadTable(\"trades\",[2000.03.06, 2000.09.15],true)",
46042
- ""
46043
- ]
46044
- },
46045
- {
46046
- "type": "text",
46047
- "value": [
46048
- "注意，对于组合分区的数据库，目前仅加载第一层分区的子集。",
46049
46473
  "",
46050
- "* 将本地磁盘分区表加载为内存分区表：",
46051
- ""
46052
- ]
46053
- },
46054
- {
46055
- "type": "code",
46056
- "language": "console",
46057
- "value": [
46474
+ ".. 注意，对于组合分区的数据库，目前仅加载第一层分区的子集。",
46475
+ "",
46476
+ ".. * 将本地磁盘分区表加载为内存分区表：",
46477
+ "",
46478
+ ".. .. code:: console",
46058
46479
  "",
46059
46480
  " $ n = 2000000",
46060
46481
  " $ workDir = \"C:/DolphinDB/Data\"",
@@ -46069,13 +46490,8 @@
46069
46490
  " $ db = database(workDir + \"/trade3\",RANGE, 0 5 10 15 20)",
46070
46491
  " $ db.loadTextEx(\"trades\",\"price\", workDir + \"/trades.txt\")",
46071
46492
  " $ trades = db.loadTable(\"trades\", ,1)",
46072
- ""
46073
- ]
46074
- },
46075
- {
46076
- "type": "text",
46077
- "value": [
46078
- "对于内存的分区表，我们可以执行一些函数，如 :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!`。",
46079
46495
  "",
46080
46496
  ".. meta:: ",
46081
46497
  " :keywords: 维度表"
@@ -46183,7 +46599,7 @@
46183
46599
  "",
46184
46600
  "`delimiter` 是数据文件中各列的分隔符。默认是逗号。",
46185
46601
  "",
46186
- "`schema` 是一个表，用于指定各字段的数据类型。它可以包含以下四列（其中，name 和 type 这两列是必需的）：",
46602
+ "`schema` 是一个表，用于指定各字段的数据类型。它可以包含以下四列（其中，name 和 type 这两列是必需的）",
46187
46603
  "",
46188
46604
  "======== ================================================================",
46189
46605
  "列名 含义",
@@ -46332,11 +46748,14 @@
46332
46748
  },
46333
46749
  {
46334
46750
  "title": "例 2",
46335
- "children": []
46336
- },
46337
- {
46338
- "title": "loadText",
46339
46751
  "children": [
46752
+ {
46753
+ "type": "text",
46754
+ "value": [
46755
+ "例如，我们想要把 permno 列的数据类型转换成 SYMBOL，可以用 :doc:`../e/extractTextSchema` 函数获取输入文件的结构，在导入数据前修改该列的数据类型，并指定 `loadText` 函数的 schema 参数。",
46756
+ ""
46757
+ ]
46758
+ },
46340
46759
  {
46341
46760
  "type": "code",
46342
46761
  "language": "console",
@@ -46588,7 +47007,7 @@
46588
47007
  {
46589
47008
  "type": "text",
46590
47009
  "value": [
46591
- "`dbHandle` 是数据库的句柄，可以是内存数据库、本地磁盘数据库或分布式数据库。",
47010
+ "`dbHandle` 是数据库的句柄，可以是内存数据库或分布式数据库。",
46592
47011
  "",
46593
47012
  "`tableName` 是一个字符串，表示表的名称。",
46594
47013
  "",
@@ -46615,8 +47034,8 @@
46615
47034
  "value": [
46616
47035
  "将数据文件加载到数据库中。",
46617
47036
  "",
46618
- "* 如果要将数据文件加载到分布式数据库或本地磁盘数据库中，必须指定 *dbHandle*，并且不能为空字符串。",
46619
- "* 如果要将数据文件加载到内存数据库中，那么 *dbHandle* 为空字符串或者不指定 *dbHandle*。",
47037
+ "* 如果要将数据文件加载到分布式数据库中，必须指定 *tableName*，并且不能为空字符串。",
47038
+ "* 如果要将数据文件加载到内存数据库中，那么 *tableName* 为空字符串或者不指定 *tableName*。",
46620
47039
  "",
46621
47040
  "如果指定了 *transform* 参数，需要先创建分区表，再加载数据。系统会对数据文件中的数据执行 *transform* 参数指定的函数，再将得到的结果保存到数据库中。",
46622
47041
  "",
@@ -47577,7 +47996,7 @@
47577
47996
  "language": "console",
47578
47997
  "value": [
47579
47998
  "",
47580
- " //模拟股票 A 8天的股价,使用 topRange 计算股票 A 每日股价创几日新高",
47999
+ " //模拟股票 A 8天的股价,使用 lowRange 计算股票 A 当日股价创几日新低",
47581
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)",
47582
48001
  " $ select *, lowRange(price) from trades",
47583
48002
  ""
@@ -51722,9 +52141,9 @@
51722
52141
  "",
51723
52142
  "`backupTableName` 是字符串，表示已备份的表的名称。",
51724
52143
  "",
51725
- "`newDBPath` 是字符串，表示新数据库的名称。如果没有指定，默认值为 *backupDBPath*.",
52144
+ "`newDBPath` 是字符串，表示新数据库的名称。如果没有指定，默认值为 *backupDBPath*。",
51726
52145
  "",
51727
- "`newTableName` 是字符串，表示新表的名称。如果没有指定，默认值为 *backupTableName*."
52146
+ "`newTableName` 是字符串，表示新表的名称。如果没有指定，默认值为 *backupTableName*。"
51728
52147
  ]
51729
52148
  }
51730
52149
  ]
@@ -52030,7 +52449,7 @@
52030
52449
  {
52031
52450
  "type": "text",
52032
52451
  "value": [
52033
- "在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 元素的最大元素的位置。"
52452
+ "在给定长度（以元素个数衡量）的滑动窗口内计算 *X* 元素的最大元素的位置。"
52034
52453
  ]
52035
52454
  }
52036
52455
  ]
@@ -52135,7 +52554,7 @@
52135
52554
  {
52136
52555
  "type": "text",
52137
52556
  "value": [
52138
- "在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 元素的最小元素的位置。"
52557
+ "在给定长度（以元素个数衡量）的滑动窗口内计算 *X* 元素的最小元素的位置。"
52139
52558
  ]
52140
52559
  }
52141
52560
  ]
@@ -52991,7 +53410,7 @@
52991
53410
  {
52992
53411
  "type": "text",
52993
53412
  "value": [
52994
- "在给定长度（以元素个数或时间长度衡量）的滑动窗口内，计算 *X* 的平均绝对离差或绝对中位差。"
53413
+ "在给定长度（以元素个数衡量）的滑动窗口内，计算 *X* 的平均绝对离差或绝对中位差。"
52995
53414
  ]
52996
53415
  }
52997
53416
  ]
@@ -53183,6 +53602,64 @@
53183
53602
  }
53184
53603
  ]
53185
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
+ },
53186
53663
  "mmed": {
53187
53664
  "title": "mmed",
53188
53665
  "type": "function",
@@ -54311,9 +54788,7 @@
54311
54788
  "* 'nearest': :math:`X_i` 和 :math:`X_{i+1}` 之中最接近分位点的数据",
54312
54789
  "* 'midpoint': :math:`(X_i+X_{i+1})/2`",
54313
54790
  "",
54314
- "如果没有指定 *interpolation*，默认采用 'linear'。",
54315
- "",
54316
- "如果没有指定 *interpolation*，默认采用 linear。"
54791
+ "如果没有指定 *interpolation*，默认采用 'linear'。"
54317
54792
  ]
54318
54793
  }
54319
54794
  ]
@@ -55846,7 +56321,7 @@
55846
56321
  "value": [
55847
56322
  "msum2(X, window, [minPeriods])",
55848
56323
  "",
55849
- "参数说明和窗口计算规则请参考: :doc:`/FunctionsandCommands/SeriesOfFunctions/mFunctions`"
56324
+ "参数说明和窗口计算规则请参考：:doc:`/FunctionsandCommands/SeriesOfFunctions/mFunctions`"
55850
56325
  ]
55851
56326
  }
55852
56327
  ]
@@ -58262,17 +58737,7 @@
58262
58737
  {
58263
58738
  "type": "text",
58264
58739
  "value": [
58265
- "*X* 中连续且值相同的元素具有相同的状态，该函数返回与当前元素状态不同的后一个临近元素值。",
58266
- "",
58267
- "*X* 是向量时：",
58268
- "",
58269
- "* 若当前元素为空值，返回后项最邻近的一个非空值。",
58270
- "* 若当前元素为非空值，寻找后项最邻近且状态不同的元素 N：",
58271
- " ",
58272
- " * 若 N 为非空值，则返回 N。",
58273
- " * 若 N 为空值，则返回 N 之后最邻近的一个非空值。",
58274
- " ",
58275
- "* 若找不到符合上述条件的值，则返回空值。",
58740
+ "*X* 中连续且相同的元素标记为同一状态，空值无状态。每个元素的状态等于其元素值。对于 *X* 中的每一个元素，返回当前状态的下一个状态。若当前元素为空，则返回下一个邻近状态。",
58276
58741
  "",
58277
58742
  "*X* 是矩阵时，则在矩阵每一列进行上述计算。"
58278
58743
  ]
@@ -59601,9 +60066,9 @@
59601
60066
  "type": "example",
59602
60067
  "children": [
59603
60068
  {
59604
- "type": "code",
59605
- "language": "console",
60069
+ "type": "text",
59606
60070
  "value": [
60071
+ ".. .. code:: console",
59607
60072
  "",
59608
60073
  " $ db=database(\"C:/DolphinDB/Data/DBSeq\",SEQ,3)",
59609
60074
  " $ USPrices=loadTextEx(db, \"USPrices\", \"c:/DolphinDB/Data/USPrices.csv\")",
@@ -59635,6 +60100,52 @@
59635
60100
  ""
59636
60101
  ]
59637
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
+ },
59638
60149
  {
59639
60150
  "type": "text",
59640
60151
  "value": [
@@ -60753,9 +61264,9 @@
60753
61264
  "其中，:math:`X_i` 和 :math:`X_{i+1}` 为数据集X中的紧邻score的前、后两个数值，:math:`P_i` 和 :math:`P_{i+1}` 分别为 :math:`X_i` 和 :math:`X_{i+1}` 的百分位。",
60754
61265
  "",
60755
61266
  "* \"rank\": 小于等于 *score* 的元素个数占元素总数的百分比。当有多个值相等的 *score* 时，取它们百分位的平均值；",
60756
- "* \"script\": 严格小于 *score* 的元素个数占元素总数的百分比；",
61267
+ "* \"strict\": 严格小于 *score* 的元素个数占元素总数的百分比；",
60757
61268
  "* \"weak\": 小于等于 *score* 的元素个数占元素总数的百分比；",
60758
- "* \"mean\": \"script\" 和 \"weak\" 的平均值。"
61269
+ "* \"mean\": \"strict\" 和 \"weak\" 的平均值。"
60759
61270
  ]
60760
61271
  }
60761
61272
  ]
@@ -62025,17 +62536,7 @@
62025
62536
  {
62026
62537
  "type": "text",
62027
62538
  "value": [
62028
- "*X* 中连续且值相同的元素具有相同的状态，该函数返回与当前元素状态不同的前一个临近元素值。",
62029
- "",
62030
- "*X* 是向量时：",
62031
- "",
62032
- "* 若当前元素为空值，返回前项最邻近的一个非空值。",
62033
- "* 若当前元素为非空值，寻找前项最邻近且状态不同的元素 P：",
62034
- " ",
62035
- " * 若 P 为非空值，则返回 P。",
62036
- " * 若 P 为空值，则返回 P 之前最邻近的一个非空值。",
62037
- " ",
62038
- "* 若找不到符合上述条件的值，则返回空值。",
62539
+ "*X* 中连续且相同的元素标记为同一状态，空值无状态。每个元素的状态等于其元素值。对于 *X* 中的每一个元素，返回当前状态的上一个状态。若当前元素为空，则返回上一个邻近状态。",
62039
62540
  "",
62040
62541
  "*X* 是矩阵时，则在矩阵每一列进行上述计算。"
62041
62542
  ]
@@ -67827,6 +68328,27 @@
67827
68328
  }
67828
68329
  ]
67829
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
+ },
67830
68352
  {
67831
68353
  "title": "参数",
67832
68354
  "type": "parameters",
@@ -67834,60 +68356,42 @@
67834
68356
  {
67835
68357
  "type": "text",
67836
68358
  "value": [
67837
- "`inputTables` 是一个未分区的内存表或 :doc:`replayDS` 函数生成的数据源。",
68359
+ "`inputTables` 是未分区的内存表或 :doc:`replayDS` 函数生成的数据源。",
67838
68360
  "",
67839
- "* 如果 *inputTables* 是单个或多个结构相同的表对象或数据源， 则用标量或元组表示。",
67840
- "* 如果 *inputTables* 是多个结构不同的表对象或数据源，则用字典表示。字典的 key 是用户自定义的字符串，表示输入表的唯一标识，value 是表对象或数据源。",
68361
+ "* 如果 *inputTables* 是单个或多个结构相同的表对象或数据源， 用标量或元组表示。",
68362
+ "* 如果 *inputTables* 是多个结构不同的表对象或数据源，用字典表示。字典的 key 是用户自定义的字符串，表示输入表或数据源的唯一标识，value 是表对象或数据源。",
67841
68363
  "",
67842
- "`outputTables` 内存表或流数据表对象。若输出表是共享表，也可以指定为共享表的表名。根据回放形式的不同（参考详情部分的说明），*outputTables* 的取值有所区别：",
68364
+ "`outputTables` 是内存表或流数据表对象。若输出表是共享表，可以指定为共享表的表名。根据回放形式的不同，*outputTables* 的取值有所区别：",
67843
68365
  "",
67844
- "\\（1）一对一回放、同构回放时，outputTables 是一个标量 ；输出表的 schema 必须与输入表的 schema 相同。",
68366
+ "\\（1）一对一回放或 N 对一同构回放时，*outputTables* 是一个表对象或字符串标量，必须与输入表的 schema 相同。",
67845
68367
  "",
67846
- "\\（2）多对多回放，outputTables 是一个向量或元组，且它的长度必须与 inputTables 相同。输出表和输入表两两对应，对应的两表的 schema 必须相同。",
68368
+ "\\（2）N 对 N 回放，outputTables 是字符串向量或表单对象组成的元组，且它的长度必须与 inputTables 相同。输出表和输入表一一对应，且表的 schema 必须相同。",
67847
68369
  "",
67848
- "\\（3）异构回放时 outputTables 是一个标量，至少包含三列：",
68370
+ "\\（3）N 对一异构回放时 outputTables 是一个标量，至少包含三列：",
67849
68371
  "",
67850
- " * 第一列用于存储时间戳，为 dateColumn 和 timeColumn 指定的回放时间；",
67851
- " * 第二列为 SYMBOL 或 STRING 类型，对应 inputTables 字典的 key；",
67852
- " * 第三列必须指定为 BLOB 类型，用于存储被回放的每条记录序列化后的结果。",
68372
+ " * 第一列为 *dateColumn* 和 *timeColumn* 指定的回放时间的时间戳；",
68373
+ " * 第二列为 SYMBOL 或 STRING 类型，对应 *inputTables* 字典的 key；",
68374
+ " * 第三列为 BLOB 类型，用于存储被回放的每条记录序列化后的结果。",
67853
68375
  "",
67854
- "此外，还支持指定输出各输入表的公共列（列名和类型一致的列）。",
68376
+ "此外，可输出各输入表的公共列（列名和类型一致的列）。",
67855
68377
  "",
67856
- "`dateColumn` 和 `timeColumn` 表示时间列的列名。必须至少指定其中一列。根据回放形式的不同（参考详情部分的说明），dateColumn 和 timeColumn 的取值有所区别：",
68378
+ "`dateColumn` 和 `timeColumn` 为时间列的列名，至少指定其中一个参数。根据回放形式的不同，*dateColumn* 和 *timeColumn* 的取值有所区别：",
67857
68379
  "",
67858
- "* 一对一回放、同构回放时，由于输入输出表的所有时间列的列名必须相同，因此可以指定为字符串标量；",
67859
- "* 输入表时间列的列名不同：",
68380
+ "* 一对一回放或 N 对一同构回放: 输入表与输出表的时间列列名必须相同，指定为字符串标量；",
68381
+ "* N 对 N 回放：输入表时间列的列名不同，指定为字符串向量；",
68382
+ "* N 对一异构回放：输入表时间列的列名不同，指定为字典，其中 key 为输入表的唯一标识符，value 是对应表时间列的列名。",
67860
68383
  "",
67861
- " * 多对多回放：可以指定为字符串向量；",
67862
- " * 异构回放：可以指定为一个字典，其中 key 为输入表的标识符，value 是对应表时间列的列名。",
68384
+ "只指定 *dateColumn* 或 *timeColumn* 中的一个参数，或者 *dateColumn* 和 *timeColumn* 指定为同一列时，对指定的时间列的类型没有限制。",
67863
68385
  "",
67864
- "只指定 *dateColumn* 或 *timeColumn* 中的一个参数，或者 *dateColumn* 和 *timeColumn* 指定为同一列时，对指定的时间列的类型没有限制。若指定 *dateColumn* 和 *timeColumn* 为不同列，*dateColumn* 必须是 DATE 类型，*timeColumn* 只能是 SECOND, TIME 或 NANOTIME 类型。",
68386
+ "若指定 *dateColumn* 和 *timeColumn* 为不同列，*dateColumn* 必须是 DATE 类型，*timeColumn* 只能是 SECOND, TIME 或 NANOTIME 类型。",
67865
68387
  "",
67866
68388
  "`replayRate` 整数，和参数 *absoluteRate* 共同决定了回放的速率。 ",
67867
68389
  "",
67868
68390
  "`absoluteRate` 布尔值。默认值为 true，表示每秒按 *replayRate* 指定的记录数回放。若为 false，表示依照数据中的时间戳加速 *replayRate* 倍回放。",
67869
68391
  "",
67870
- "`parallelLevel` 正整数，表示将数据从数据源加载到内存的工作线程数量，默认值为1。如果 *inputTables* 不是数据源，无需指定该参数。"
67871
- ]
67872
- }
67873
- ]
67874
- },
67875
- {
67876
- "title": "详情",
67877
- "type": "detail",
67878
- "children": [
67879
- {
67880
- "type": "text",
67881
- "value": [
67882
- "按照给定的回放模式，按时间顺对数据进行回放。",
67883
- "",
67884
- "根据输入表和输出表的映射关系（map），``replay`` 支持一对一，多对一，多对多三种回放形式。",
67885
- "",
67886
- "对于多对一回放，1.30.17 / 2.00.5 版本前，输入表结构必须相同，称为同构回放。该版本后，replay 支持以字典的形式输入结构不同的表，称为异构回放。",
67887
- "",
67888
68392
  "根据不同的场景需求，replay 提供以下三种回放模式：",
67889
68393
  "",
67890
- "- 匀速回放：如果 *replayRate* 为正整数，且 *absoluteRate* 为 true，则回放的速率基于记录数计算，按照每秒 *replayRate* 条记录进行回放。假设输入表的总记录条数为 total（多表回放时以记录数最多的表为基准），那么回放该表所需的时间大致为 total/replayRate 秒。",
68394
+ "- 匀速回放：如果 *replayRate* 为正整数，且 *absoluteRate* 为 true，则回放的速率基于记录数计算，按照每秒 *replayRate* 条记录进行回放。假设输入表的总记录条数为 total（多表回放时为所有表的总记录数），那么回放该表所需的时间大致为 total/replayRate 秒。",
67891
68395
  "",
67892
68396
  "- 倍速回放：如果 *replayRate* 为正整数，并且 *absoluteRate* 为 false，则将输入表中的数据按照时间加速 *replayRate* 倍回放。假设输入表中 *dateColumn* 或 *timeColumn* 的最大时间戳和最小时间戳相差 n 秒，数据总数为 s，则系统每秒回放 replayRate*s/n 条记录（每秒至少回放 1 条），即回放时间大致为 n/replayRate 秒。",
67893
68397
  "",
@@ -67895,13 +68399,8 @@
67895
68399
  "",
67896
68400
  "上述回放耗时主要基于同构回放估算，异构回放的耗时开销会略高于上述估算的回放耗时。",
67897
68401
  "",
67898
- "如需回放历史数据， 可通过 :doc:`replayDS` 函数直接生成数据源来作为 ``replay`` 的输入。",
67899
- "",
67900
- "注意：进行多对一回放时，若 *inputTables* 为数据源，各数据源 size 以及其 *dateColumn* 列对应的时间范围必须保持一致。",
67901
- "",
67902
- "异构回放时，replay 的输出结果可以通过 :doc:`../s/streamFilter` 进行反序列化，并进行数据过滤和分离，详情请参考 :doc:`../s/streamFilter`。 ",
67903
- "",
67904
- "使用 :doc:`../../CommandsReferences/c/cancelJob` 和 :doc:`../../CommandsReferences/c/cancelConsoleJob` 命令可以终止回放。"
68402
+ "`parallelLevel` 正整数，表示从数据源加载数据到内存的工作线程数量，默认值为 1。如果 *inputTables* 不是数据源，无需指定该参数。",
68403
+ ""
67905
68404
  ]
67906
68405
  }
67907
68406
  ]
@@ -70896,7 +71395,7 @@
70896
71395
  "value": [
70897
71396
  "rowImax(args...)",
70898
71397
  "",
70899
- "row 系列函数通用参数说明和计算规则请参考: :doc:`/FunctionsandCommands/SeriesOfFunctions/rowFunctions`",
71398
+ "row 系列函数通用参数说明和计算规则请参考：:doc:`/FunctionsandCommands/SeriesOfFunctions/rowFunctions`",
70900
71399
  ""
70901
71400
  ]
70902
71401
  }
@@ -70934,7 +71433,7 @@
70934
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)",
70935
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)",
70936
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)",
70937
- " $ 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",
70938
71437
  ""
70939
71438
  ]
70940
71439
  },
@@ -70978,7 +71477,7 @@
70978
71477
  "value": [
70979
71478
  "rowImin(args...)",
70980
71479
  "",
70981
- "row 系列函数通用参数说明和计算规则请参考: :doc:`/FunctionsandCommands/SeriesOfFunctions/rowFunctions`",
71480
+ "row 系列函数通用参数说明和计算规则请参考：:doc:`/FunctionsandCommands/SeriesOfFunctions/rowFunctions`",
70982
71481
  ""
70983
71482
  ]
70984
71483
  }
@@ -73783,7 +74282,7 @@
73783
74282
  {
73784
74283
  "type": "text",
73785
74284
  "value": [
73786
- "把一张表保存为本地磁盘数据库中的分区表。在用 *savePartition* 保存之前，要用 :doc:`../../FunctionReferences/c/createPartitionedTable` 先创建空的分区表。"
74285
+ "把一张表保存为分布式数据库中的分区表。在用 *savePartition* 保存之前，要用 :doc:`../../FunctionReferences/c/createPartitionedTable` 先创建空的分区表。"
73787
74286
  ]
73788
74287
  }
73789
74288
  ]
@@ -73802,13 +74301,13 @@
73802
74301
  " $ value=rand(1.0, n)",
73803
74302
  " $ t=table(ID, value);",
73804
74303
  "",
73805
- " $ db=database(\"C:/DolphinDB/Data/rangedb_Trades\", RANGE, 0 5 10)",
74304
+ " $ db=database(\"dfs://rangedb_Trades\", RANGE, 0 5 10)",
73806
74305
  " $ Trades = db.createPartitionedTable(t, \"Trades\", \"ID\");",
73807
74306
  " $ savePartition(db, t, `Trades)",
73808
74307
  "",
73809
74308
  " $ Trades=loadTable(db, `Trades)",
73810
74309
  " $ select count(value) from Trades;",
73811
- " 1000000",
74310
+ " 1,000,000",
73812
74311
  ""
73813
74312
  ]
73814
74313
  },
@@ -73833,7 +74332,7 @@
73833
74332
  " $ savePartition(db, t1, `Trades)",
73834
74333
  " $ Trades=loadTable(db, `Trades)",
73835
74334
  " $ select count(value) from Trades;",
73836
- " 1500000"
74335
+ " 1,500,000"
73837
74336
  ]
73838
74337
  }
73839
74338
  ]
@@ -73883,7 +74382,10 @@
73883
74382
  {
73884
74383
  "type": "text",
73885
74384
  "value": [
73886
- "将一个表保存在未分区的本地磁盘表中。如果要把表保存至分区数据库中，需要先使用 :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
+ "注意：磁盘表仅应用于备份数据和本地计算的场景，其相较于分布式表，在使用上具有一定局限，例如不能进行权限控制等。"
73887
74389
  ]
73888
74390
  }
73889
74391
  ]
@@ -74814,7 +75316,7 @@
74814
75316
  {
74815
75317
  "type": "text",
74816
75318
  "value": [
74817
- "`X` 可以是整数标量或向量、时间标量或向量。"
75319
+ "`X` 可以是整数/时间类型/字符串类型的标量或向量。"
74818
75320
  ]
74819
75321
  }
74820
75322
  ]
@@ -74845,6 +75347,10 @@
74845
75347
  "",
74846
75348
  " $ second(61);",
74847
75349
  " 00:01:01",
75350
+ "",
75351
+ " $ second(\"09:00:01\") ",
75352
+ " 09:00:01",
75353
+ " ",
74848
75354
  ""
74849
75355
  ]
74850
75356
  },
@@ -76360,7 +76866,7 @@
76360
76866
  "value": [
76361
76867
  "在线修改单次查询结果占用的最大内存上限。该命令只能由管理员在数据节点/计算节点执行。",
76362
76868
  "",
76363
- "相关函数： :doc:`/FunctionsandCommands/FunctionReferences/g/getMemLimitOfTaskGroupResult`"
76869
+ "相关函数： :doc:`/FunctionsandCommands/FunctionReferences/g/getMemLimitOfQueryResult`"
76364
76870
  ]
76365
76871
  }
76366
76872
  ]
@@ -76404,7 +76910,7 @@
76404
76910
  "value": [
76405
76911
  "在线修改当前节点发送的批量子查询占用的内存上限。该命令只能由管理员在数据节点/计算节点执行。",
76406
76912
  "",
76407
- "相关函数： :doc:`/FunctionsandCommands/FunctionReferences/g/getMemLimitOfQueryResult`"
76913
+ "相关函数： :doc:`/FunctionsandCommands/FunctionReferences/g/getMemLimitOfTaskGroupResult`"
76408
76914
  ]
76409
76915
  }
76410
76916
  ]
@@ -80438,7 +80944,7 @@
80438
80944
  {
80439
80945
  "type": "text",
80440
80946
  "value": [
80441
- "相关函数：:doc:`../c/cumstd`"
80947
+ "相关函数：:doc:`std`, :doc:`../c/cumstd`"
80442
80948
  ]
80443
80949
  }
80444
80950
  ]
@@ -80536,7 +81042,7 @@
80536
81042
  {
80537
81043
  "type": "text",
80538
81044
  "value": [
80539
- "相关函数：:doc:`../c/cumstdp`"
81045
+ "相关函数：:doc:`std`, :doc:`../c/cumstdp`"
80540
81046
  ]
80541
81047
  }
80542
81048
  ]
@@ -81250,7 +81756,7 @@
81250
81756
  "* 'condition'：表示过滤条件。",
81251
81757
  "",
81252
81758
  " * 若分发异构流表，则 'condition' 是一个字符串，且必须是 replay 参数 *inputTables* 的键值（表的标识）。用于过滤出异构表中具有 *condition* 标识的数据。",
81253
- " * 若分发普通流表，则 'condition' 可以是一个表示列名的字符串标量或/向量，或者是包含一个或多个布尔表达式的元代码，且表达式中不能调用函数。请注意，若 'condition' 指定为字符串标量/向量，必须为 *conditionColumn* 指定列的元素。",
81759
+ " * 若分发普通流表，则 'condition' 可以是一个表示列名的字符串标量/向量，或者是包含一个或多个布尔表达式的元代码，且表达式中不能调用函数。请注意，若 'condition' 指定为字符串标量/向量，必须为 *conditionColumn* 指定列的元素。",
81254
81760
  "",
81255
81761
  "* 'handler'：一元函数或表对象（包括流数据引擎返回的表对象）。",
81256
81762
  "",
@@ -82641,7 +83147,7 @@
82641
83147
  "value": [
82642
83148
  "从客户端节点订阅本地或远程服务器的流数据表。可在 *handler* 调用函数来处理订阅数据。",
82643
83149
  "",
82644
- "返回一个订阅主题(topic)，即一个订阅的名称。它是一个字符串，由订阅表所在节点的别名、流数据表名称和订阅任务名称（如果指定了 actionName）组合而成，使用下划线分隔。如果订阅主题已经存在，函数将会抛出异常。",
83150
+ "返回一个订阅主题(topic)，即一个订阅的名称。它是一个字符串，由订阅表所在节点的别名、流数据表名称和订阅任务名称（如果指定了 actionName）组合而成，使用 \"/\" 分隔。如果订阅主题已经存在，函数将会抛出异常。",
82645
83151
  "",
82646
83152
  "* 如果指定了 *batchSize*，当未处理消息数量达到 *batchSize* 或距离上次 *handler* 被触发已过去 *throttle* 秒，*handler* 将会被触发。",
82647
83153
  "",
@@ -82661,7 +83167,7 @@
82661
83167
  {
82662
83168
  "type": "text",
82663
83169
  "value": [
82664
- "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=\"\"])",
82665
83171
  ""
82666
83172
  ]
82667
83173
  }
@@ -88506,7 +89012,7 @@
88506
89012
  "value": [
88507
89013
  "tmsum2(T, X, window)",
88508
89014
  "",
88509
- "参数说明和窗口计算规则请参考: :doc:`/FunctionsandCommands/SeriesOfFunctions/tmFunctions`"
89015
+ "参数说明和窗口计算规则请参考：:doc:`/FunctionsandCommands/SeriesOfFunctions/tmFunctions`"
88510
89016
  ]
88511
89017
  }
88512
89018
  ]
@@ -89536,7 +90042,7 @@
89536
90042
  "language": "console",
89537
90043
  "value": [
89538
90044
  "",
89539
- " //模拟股票 A 8天的股价,使用 topRange 计算股票 A 每日股价创几日新高",
90045
+ " //模拟股票 A 8天的股价，使用 topRange 计算股票 A 当日股价创几日新高",
89540
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)",
89541
90047
  " $ select *, topRange(price) from trades",
89542
90048
  ""
@@ -90755,7 +91261,7 @@
90755
91261
  {
90756
91262
  "type": "text",
90757
91263
  "value": [
90758
- "从内存中释放变量和函数定义。另一种从内存中释放变量的做法是使用 \"= NULL\"。"
91264
+ "从内存中释放变量和函数定义。VAR（本地变量）亦可通过 \"= NULL\" 释放变量。"
90759
91265
  ]
90760
91266
  }
90761
91267
  ]
@@ -92389,10 +92895,10 @@
92389
92895
  "",
92390
92896
  "`mode` 字符串，可选值为：\"prev\", \"next\", \"any\" 和 \"all\"，默认值为 \"prev\"。",
92391
92897
  "",
92392
- "* \"prev\": 前一个元素。",
92393
- "* \"next\": 后一个元素。",
92394
- "* \"any\": 前一个元素或后一个元素。",
92395
- "* \"all\": 前一个元素和后一个元素值。"
92898
+ "* \"prev\"：前一个元素。",
92899
+ "* \"next\"：后一个元素。",
92900
+ "* \"any\"：前一个元素或后一个元素。",
92901
+ "* \"all\"：前一个元素和后一个元素值。"
92396
92902
  ]
92397
92903
  }
92398
92904
  ]
@@ -92404,7 +92910,7 @@
92404
92910
  {
92405
92911
  "type": "text",
92406
92912
  "value": [
92407
- "*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。",
92408
92914
  "",
92409
92915
  "若 *X* 为矩阵/表，在每列内进行上述操作，返回一个矩阵/表。"
92410
92916
  ]
@@ -92891,7 +93397,7 @@
92891
93397
  " $ volume=rand(100, n)",
92892
93398
  " $ table1 = table(date, sym, price, volume)",
92893
93399
  " $ outputTable = table(n:0, `sym`factor1, [STRING,DOUBLE])",
92894
- " $ engine = createReactiveStateEngine(\"test\", <ema(qty, 40)>, table1, outputTable, \"sym\")",
93400
+ " $ engine = createReactiveStateEngine(\"test\", <ema(volume, 40)>, table1, outputTable, \"sym\")",
92895
93401
  " $ warmupStreamEngine(engine, table1)",
92896
93402
  " $ date=take(2021.03.09, n)",
92897
93403
  " $ sym=take(\"A\"+string(1..3000), n)",
@@ -92916,7 +93422,7 @@
92916
93422
  {
92917
93423
  "type": "text",
92918
93424
  "value": [
92919
- "wavg(value, weight)"
93425
+ "wavg(X, Y)"
92920
93426
  ]
92921
93427
  }
92922
93428
  ]
@@ -92928,7 +93434,7 @@
92928
93434
  {
92929
93435
  "type": "text",
92930
93436
  "value": [
92931
- "`value` 与 `weight` 是向量、矩阵或表。*weight* 表示权重。"
93437
+ "`X` 与 `Y` 是向量、矩阵或表。*Y* 表示权重。"
92932
93438
  ]
92933
93439
  }
92934
93440
  ]
@@ -92940,9 +93446,9 @@
92940
93446
  {
92941
93447
  "type": "text",
92942
93448
  "value": [
92943
- "对 *value*，以 *weight* 为权重，计算其加权平均数。",
93449
+ "对 *X*，以 *Y* 为权重，计算其加权平均数。",
92944
93450
  "",
92945
- "请注意，权重向量会自动调整，使得 *value* 向量中非 Null 之值对应的权重向量之和为1。"
93451
+ "请注意，权重向量会自动调整，使得 *X* 向量中非 NULL 之值对应的权重向量之和为1。"
92946
93452
  ]
92947
93453
  }
92948
93454
  ]
@@ -93049,7 +93555,7 @@
93049
93555
  {
93050
93556
  "type": "text",
93051
93557
  "value": [
93052
- "wcovar(X, Y, weights)"
93558
+ "wcovar(X, Y, W)"
93053
93559
  ]
93054
93560
  }
93055
93561
  ]
@@ -93061,9 +93567,9 @@
93061
93567
  {
93062
93568
  "type": "text",
93063
93569
  "value": [
93064
- "`X`, `Y` 和 `weights` 是相同长度的数值型向量。",
93570
+ "`X`, `Y` 和 `W` 是相同长度的数值型向量。",
93065
93571
  "",
93066
- "*weights* 表示权重。它不能包含NULL值。"
93572
+ "*W* 表示权重。它不能包含NULL值。"
93067
93573
  ]
93068
93574
  }
93069
93575
  ]
@@ -94788,6 +95294,74 @@
94788
95294
  }
94789
95295
  ]
94790
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
+ },
94791
95365
  "xdb": {
94792
95366
  "title": "xdb",
94793
95367
  "type": "function",
@@ -95418,7 +95992,7 @@
95418
95992
  {
95419
95993
  "type": "text",
95420
95994
  "value": [
95421
- "`HL` 数值向量或者包含两列的数值矩阵。",
95995
+ "`HL` 数值向量或者矩阵。请注意，若 *HL* 为矩阵，则其行数不能少于2行，列数不能超过2列。",
95422
95996
  "",
95423
95997
  "`change` 极值波动的最小阈值。 ",
95424
95998
  "",