create-dwy 0.12.1 → 0.13.0

package/templates/claude-global/skills//346/225/260/346/215/256/345/272/223/dwy-dolphindb/references/official/funcs/d/DStream_timeSeriesEngine.md

@@ -0,0 +1,201 @@
+---
+source_url: https://docs.dolphindb.cn/zh/funcs/d/DStream_timeSeriesEngine.html
+fetched_at: 2026-05-19T09:20:24Z
+category: funcs
+title: DStream::timeSeriesEngine
+sha1: 78589556a2ee919c2fecb0776b5b5c620db4d521
+---
+
+# DStream::timeSeriesEngine
+
+首发版本：3.00.3
+
+## 语法
+
+`DStream::timeSeriesEngine(windowSize, step, metrics, [timeColumn],
+[useSystemTime=false], [keyColumn], [updateTime], [useWindowStartTime],
+[roundTime=true], [fill='none'], [forceTriggerTime], [keyPurgeFreqInSecond=-1],
+[closed='left'], [subWindow], [parallelism=1], [acceptedDelay=0])`
+
+## 详情
+
+创建流计算时间序列聚合引擎。参考：[createTimeSeriesEngine](../c/createTimeSeriesEngine.html)。
+
+## 参数
+
+**windowSize** 正整数标量或向量，表示滑动窗口的长度。
+
+**step** 正整数标量，表示滑动窗口移动的步长。 *windowSize* 必须是 *step*
+的整数倍，否则会抛出异常。*windowSize* 和 *step* 的单位与 *useSystemTime* 有关：
+
+- 若 *useSystemTime* 为 true，则 *windowSize* 和
+  *step* 的单位为毫秒。
+- 若 *useSystemTime* 为 false，则 *windowSize* 和
+  *step* 的单位与 *timeColumn* 的时间精度一致。
+
+**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [元编程](../c/../../progr/objs/meta_progr.html)。
+
+- 计算指标可以是一个或多个系统内置或用户自定义的聚合函数（使用 defg 关键字定义），如
+  <[sum(volume), avg(price)]>；可以对聚合结果使用表达式，如
+  <[avg(price1)-avg(price2)]>；也可对列与列的计算结果进行聚合计算，如
+  <[std(price1-price2)]>。
+- *metrics* 内支持调用具有多个返回值的函数，例如 <func(price) as
+  `col1`col2>（可不指定列名）。
+- 支持指定为一个常量标量或向量，例如 <1>，<[1, 2, 3]> 。当指定为常量向量时，对应的输出列必须设置为数组向量类型。
+- 若 *windowSize* 为向量， *windowSize* 每个值可对应
+  *metrics* 中多个计算指标。例如，*windowSize* 为[10,20]时，metrics可为
+  (<[min(volume), max(volume)]>, <sum(volume)>)。
+  *metrics* 也可以嵌套输入元组向量。例如：[[<[min(volume), max(volume)]>,
+  <sum(volume)>], [<avg(volume)>]]
+
+  注：
+
+  - *metrics* 中使用的列名大小写不敏感，不需要与输入表的列名大小写保持一致。
+  - *metrics* 中不可使用嵌套聚合函数。
+
+**timeColumn** 可选参数，字符串标量或向量。当 *useSystemTime* = false
+时，必须指定该参数。 该参数用于指定订阅的流数据表中时间列的名称。
+
+注：
+
+字符串向量必须是 date 和 time
+组成的向量，date 类型为 DATE，time 类型为 TIME, SECOND 或 NANOTIME。此时，输出表第一列的时间类型必须与 [concatDateTime(date, time)](../c/concatDateTime.html)
+的类型一致。
+
+**useSystemTime** 可选参数，布尔值，表示是否使用数据注入引擎时的系统时间作为时间列进行计算。
+
+- 当 *useSystemTime* =
+  true时，时间序列引擎会按照数据注入时间序列引擎的时刻（毫秒精度的本地系统时间，与数据中的时间列无关），每隔固定时间截取固定长度窗口的流数据进行计算。只要一个数据窗口中含有数据，数据窗口结束后就会自动进行计算。结果中的第一列为计算发生的时间戳，与数据中的时间无关。
+- 当 *useSystemTime* = false（缺省值）时，时间序列引擎根据流数据中的 *timeColumn*
+  列来截取数据窗口。一个数据窗口结束后的第一条新数据才会触发该数据窗口的计算。请注意，触发计算的数据并不会参与该次计算。
+
+  例如，一个数据窗口从 10:10:10 到 10:10:19。若 *useSystemTime*
+  = true，则只要该窗口中至少有一条数据，该窗口的计算会在窗口结束后的 10:10:20 触发。若 *useSystemTime*
+  = false，且 10:10:19 后的第一条数据为 10:10:25，则该窗口的计算会在 10:10:25 触发。
+
+**keyColumn**
+可选参数，字符串标量或向量，表示分组列名。若设置，则分组进行聚合计算，例如以每支股票为一组进行聚合计算。
+
+**updateTime** 可选参数，非负整数，单位与 timeColumn 的时间精度一致。用于指定比
+*step* 更短的计算时间间隔。*step* 必须是 *updateTime* 的整数倍。要设置
+*updateTime*， *useSystemTime* 必须设为 false。
+
+- updateTime 指定为正整数值时：
+
+  - 从当前窗口的左边界开始，每隔 *updateTime*
+    时间，若有新的数据到来，则对当前窗口内该数据之前的所有数据进行计算。
+  - 如果系统经过 2 \* *updateTime* （至少2秒）后仍有未被处理的数据，则触发对当前窗口内所有数据的计算。
+  - 若分组计算，则每组内进行上述操作。
+- updateTime 指定为 0 时：在新的数据到来后，立即对当前窗口的最新数据计算并输出。
+
+**useWindowStartTime** 可选参数，布尔值，表示输出表中的时间是否为数据窗口起始时间。默认值为
+false，表示输出表中的时间为数据窗口起始时间 + *windowSize* 。若 *windowSize* 是向量，
+*useWindowStartTime* 必须为 false。
+
+**roundTime** 可选参数，布尔值，表示若数据时间精度为毫秒或者秒且 *step* >
+一分钟，如何对窗口边界值进行规整处理。默认值为 true，表示按照既定的多分钟规则进行规整。若为 false，则按一分钟规则进行窗口规整。
+
+**fill** 可选参数，一个标量或向量，指定某个分组的某个窗口无数据时的处理方法。可取以下值：
+
+- 'none': 不输出结果。
+- 'null': 输出结果为 NULL。
+- 'ffill': 输出上一个有数据的窗口的结果。
+- '具体数值'：该值的数据类型需要和对应的 *metrics* 计算结果的类型保持一致。
+
+*fill* 可以输入向量，长度与 *metrics* 元素个数保持一致，表示为每个 *metrics* 指定不同的 *fill*
+方式。若为向量，向量中各项只能是 'null', 'ffill' 或一个数值，不能是 'none'。
+
+**forceTriggerTime** 可选参数，是非负整数，单位与 *timeColumn*
+的时间精度一致。用于强制触发各个分组未计算的窗口进行计算。要设置 *forceTriggerTime*， *useSystemTime* 必须设置为
+false，且不能指定 *updateTime*。强制触发计算及输出规则如下：
+
+1. 未被触发计算的窗口结束后（窗口结束时刻为 t），若收到了其他分组的数据（时间戳为 t1），且满足 t1-t
+   ≥ *forceTriggerTime*，则该窗口将被触发计算。
+2. 如果某个分组在最后一个窗口被强制触发计算后，没有再收到新的数据，但其他分组仍然收到了新的数据，那么通过 *fill*
+   来填充该分组的所有缺失窗口，可以确保在最新时间截面上仍然输出该分组的窗口。如果不指定
+   *fill*，则最后一个窗口被触发计算后，该分组不会产生新的窗口。
+
+设置 *forceTriggerTime* 或 *updateTime* 时需注意以下几点：
+
+- 设置 *updateTime*，计算发生后仍有属于当前窗口的数据到达时，当前窗口计算结果会再次更新；
+- 设置 *forceTriggerTime*，则触发计算之后收到的数据会被丢弃，建议不要设置太小的
+  *forceTriggerTime*。
+- 如果 *timeColumn* 指定的时间为 TIME
+  类型，数据跨天后无法仅凭时间判断数据的先后顺序，因此会出现跨天无法强制触发的情况。*timeColumn*
+  的时间需要加上日期。
+
+**keyPurgeFreqInSec** 正整数，单位为秒。用于控制定期清理“窗口数据已为空”的分组对应的
+key，从而避免 key 持续增长带来的内存占用。指定该参数后，如果当前数据注入时间与上一次清理时间的间隔 ≥
+*keyPurgeFreqInSec*，则会删除当前窗口数据为空的分组及其对应的 key。
+
+注：
+
+- 若需指定该参数，必须指定 *forceTriggerTime*，且不能指定 *fill*。
+- 可以通过调用 [getStreamEngineStat](../c/../g/getStreamEngineStat.html) 函数查看 TimeSeriesEngine 引擎状态的
+  numGroups 列，来对比响应式状态引擎清理前后分组数的变化。
+
+**closed** 字符串，用于确定滑动窗口边界的开闭情况。可选值为 'left' 或 'right'，默认值为
+'left'。
+
+- closed = 'left'： 窗口左闭右开。
+- closed = 'right'： 窗口左开右闭。
+
+**subWindow** 整型或者 DURATION
+数据对。在滑动窗口内指定子窗口，仅计算子窗口内的数据。子窗口边界的开闭情况由参数 *closed*
+决定。子窗口结束后收到第一条数据触发对子窗口内数据的计算（参考例4）。当 *subWindow* 为整型数据对时，其单位与 *timeColumn*
+的时间精度一致。若指定 *subWindow*，则：
+
+- *windowSize* 和 *step* 必须相等。
+- 不可设置 *updateTime*>0和 *useSystemTime*=true。
+
+**parallelism** 为不超过 63 的正整数，可选参数，表示并行计算的工作线程数，默认值为
+1。在计算量较大时，合理地调整该参数能够有效利用计算资源，降低计算耗时。建议小于机器核数，推荐值为 4 到 8 。
+
+**acceptedDelay** 正整数，可选参数。指定每个窗口接收数据的最大延迟，默认值为 0。若设置该参数，则不能设置
+*forceTriggerTime* 或 *updateTime*。
+
+- 当 useSystemTime= true 时，*acceptedDelay* 必须小于等于
+  *windowSize*。在窗口结束后的 *acceptedDelay*
+  时间内接收到的数据，仍然属于此窗口并参与计算，而不会参与下一个窗口的计算。
+- 当 useSystemTime= false 时，该参数用于处理乱序数据。假设当前窗口结束的时间戳为 t ，若收到一条时间戳大于等于
+  t+*acceptedDelay*的数据，则触发在此之前收到的所有属于当前窗口的数据进行计算输出，并关闭该窗口。
+
+## 返回值
+
+返回一个 DStream 对象。
+
+## 例子
+
+```dolphindb
+if (!existsCatalog("orca")) {
+	createCatalog("orca")
+}
+go
+use catalog orca
+
+// 如已存在流图，则先销毁该流图
+// dropStreamGraph('engine')
+g = createStreamGraph('engine')
+
+g.source("trades", ["time","sym","volume"], [TIMESTAMP, SYMBOL, INT])
+.timeSeriesEngine(windowSize=60000, step=60000, metrics=<[sum(volume)]>, timeColumn="time", useSystemTime=false, keyColumn="sym", useWindowStartTime=false)
+.sink("output")
+g.submit()
+go
+
+times = [2018.10.08T01:01:01.785, 2018.10.08T01:01:02.125, 2018.10.08T01:01:10.263, 2018.10.08T01:01:12.457, 2018.10.08T01:02:10.789, 2018.10.08T01:02:12.005, 2018.10.08T01:02:30.021, 2018.10.08T01:04:02.236, 2018.10.08T01:04:04.412, 2018.10.08T01:04:05.152]
+syms = [`A, `B, `B, `A, `A, `B, `A, `A, `B, `B]
+volumes = [10, 26, 14, 28, 15, 9, 10, 29, 32, 23]
+
+tmp = table(times as time, syms as sym, volumes as volume)
+appendOrcaStreamTable("trades", tmp)
+
+select * from orca_table.output
+```
+
+| time | sym | sum\_volume |
+| --- | --- | --- |
+| 2018.10.08 01:02:00.000 | A | 38 |
+| 2018.10.08 01:02:00.000 | B | 40 |
+| 2018.10.08 01:03:00.000 | A | 25 |
+| 2018.10.08 01:03:00.000 | B | 9 |

package/templates/claude-global/skills//346/225/260/346/215/256/345/272/223/dwy-dolphindb/references/official/funcs/d/DStream_timerEngine.md

@@ -0,0 +1,73 @@
+---
+source_url: https://docs.dolphindb.cn/zh/funcs/d/DStream_timerEngine.html
+fetched_at: 2026-05-19T09:20:22Z
+category: funcs
+title: DStream::timerEngine
+sha1: 29821c749fdcc60fd3dcb33c5865c1cf3ccadde6
+---
+
+# DStream::timerEngine
+
+## 语法
+
+`DStream::timerEngine(interval, func, args...)`
+
+## 详情
+
+定义一个时间触发引擎，以间隔 *interval* 周期性地执行 *func*。执行该任务不会阻塞或修改流图的数据流。
+
+## 参数
+
+**interval** 整型标量，表示任务执行的时间间隔，单位为秒。
+
+**func** FUNCTIONDEF 标量，表示定时执行的任务。
+
+**args…** 传递给 *func* 的参数，使用方式类似于远程过程调用函数 [rpc](../r/rpc.html) 的 *args…* 参数。当 *func* 为无参函数时可省略。
+
+## 返回值
+
+返回一个 DStream 对象。
+
+## 例子
+
+提交任务
+
+```dolphindb
+if (!existsCatalog("test")) {
+	createCatalog("test")	
+}
+go
+use catalog test
+
+// 定义任务
+def myFunc(x,y,z){
+    writeLog(x,y,z)
+}
+
+// 定义参数
+a = "aaa"
+b = "bbb"
+c = "ccc"
+
+// 提交流图
+g = createStreamGraph("timerEngineDemo")
+g.source("trade", `id`price, [INT, DOUBLE])
+ .timerEngine(3, myFunc, a, b, c)
+ .setEngineName("myJob")
+ .sink("result")
+g.submit()
+```
+
+暂停任务执行
+
+```dolphindb
+useOrcaStreamEngine("myJob", stopTimerEngine)
+```
+
+继续执行任务
+
+```dolphindb
+useOrcaStreamEngine("myJob", resumeTimerEngine)
+```
+
+**相关函数：**[resumeTimerEngine](../r/resumeTimerEngine.html), [stopTimerEngine](../s/stopTimerEngine.html)

package/templates/claude-global/skills//346/225/260/346/215/256/345/272/223/dwy-dolphindb/references/official/funcs/d/DStream_udfEngine.md

@@ -0,0 +1,109 @@
+---
+source_url: https://docs.dolphindb.cn/zh/funcs/d/DStream_udfEngine.html
+fetched_at: 2026-05-19T09:20:25Z
+category: funcs
+title: DStream::udfEngine
+sha1: 9ecdeefc6a91d1ca96eb24e2cff8ed085f059aef
+---
+
+# DStream::udfEngine
+
+首发版本：3.00.4
+
+## 语法
+
+`DStream::udfEngine(func)`
+
+## 详情
+
+`DStream::udfEngine` 是 Orca
+流图中用于执行用户自定义处理逻辑的扩展引擎。当内置流计算引擎无法满足特定业务需求时，用户可通过 `DStream::udfEngine`
+设置自定义函数，对每条流消息进行映射处理。
+
+为支持有状态计算，自定义函数可访问由
+`DStream::sharedTable`、`DStream::sharedDict` 或
+`DStream::sharedKeyedTable` 声明的共享变量。这些变量可在同一流图内的多个 udfEngine 实例和
+task 之间共享，其状态由 Orca 通过 Checkpoint 机制自动持久化，并在故障恢复时重建。
+
+**注意：**自定义函数中禁止访问任何外部变量。仅允许使用局部变量，或通过 `orcaObj("name")`
+引用已声明的共享变量。
+
+**共享变量使用约束**：
+
+- 共享变量必须先通过
+  `DStream::sharedTable`、`DStream::sharedDict`
+  或 `DStream::sharedKeyedTable` 声明；在 `udfEngine`
+  的 自定义函数中，通过 `orcaObj("name")` 引用。注意：`orcaObj`
+  仅在自定义函数执行上下文中有效。
+- 每个共享变量仅支持单写多读：只能有一个 udfEngine 实例写入，但允许多个实例并发读取。
+- 访问同一共享变量的所有任务会被 Orca 调度到同一个物理节点，以保证本地访问和一致性。
+
+## 参数
+
+**func** 用户定义函数，只有一个参数，为流数据表。该参数不可被原地修改或作为可变对象操作。函数内部可读写由
+`DStream::sharedTable`、`DStream::sharedDict` 或
+`DStream::sharedKeyedTable` 定义的共享变量，实现状态更新。若函数有返回值，类型必须为字典或表。
+
+## 返回值
+
+返回一个 DStream 对象。
+
+## 例子
+
+下面通过 `DStream::sharedKeyedTable` 与 `DStream::udfEngine`
+的结合，实现计算历史差值的功能。
+
+在本示例中，使用 `DStream::sharedKeyedTable` 存储已处理数据的历史记录，对每个 id
+仅保留最新的一条记录。当新数据到达时，若该 id 已存在于表中，则输出新值与历史值之间的差值；否则，仅将新数据存入表中，不输出。
+
+```dolphindb
+if(existsCatalog("orcaCatalog")) dropCatalog("orcaCatalog")
+createCatalog("orcaCatalog")
+go
+use catalog orcaCatalog
+// 创建流图
+g = createStreamGraph("compare")
+g.sharedKeyedTable("history", "id", 1:0, `id`value, [INT, DOUBLE])
+g.source("data", `id`value`time, [INT, DOUBLE, TIMESTAMP])
+  .udfEngine(def(msg) {
+    history = orcaObj("history")
+    diffTable = table(100:0, `id`diff, [INT, DOUBLE])
+    for(i in 0:msg.size()) {
+        idVal = msg.id[i]
+        valueVal = msg.value[i]
+        // 读取历史值
+        old = select value from history where id = idVal
+        // 写入新值
+        newRow = table(idVal as id, valueVal as value)
+        history.append!(newRow)
+        // 计算差值
+        if(old.size() > 0) {
+            diffTable.append!(table(idVal as id, (valueVal - old.value[0]) as diff))
+        }
+    }
+    return diffTable
+  })
+  .sink("comparison")
+g.submit()
+// 生成模拟数据
+mockData = table(1..5 as id, rand(100.0, 5) as value, now() + 1..5 as time)
+// 插入数据
+appendOrcaStreamTable("orcaCatalog.orca_table.data", mockData)
+// 生成id重复的数据
+mockData = table(1..5 as id, rand(100.0, 5) as value, now() + 1..5 as time)
+// 插入数据
+appendOrcaStreamTable("orcaCatalog.orca_table.data", mockData)
+// 等待处理并查看结果
+sleep(1000)
+select * from orcaCatalog.orca_table.comparison
+```
+
+| id | diff |
+| --- | --- |
+| 1 | 35.55946895749296 |
+| 2 | -3.4362593906550387 |
+| 3 | 36.283468999034596 |
+| 4 | 68.97968558337999 |
+| 5 | -91.64246928217878 |
+
+**相关函数：**[DStream::map](DStream_map.html), [getUdfEngineVariable](../g/getUdfEngineVariable.html)

package/templates/claude-global/skills//346/225/260/346/215/256/345/272/223/dwy-dolphindb/references/official/funcs/d/DStream_windowJoinEngine.md

@@ -0,0 +1,130 @@
+---
+source_url: https://docs.dolphindb.cn/zh/funcs/d/DStream_windowJoinEngine.html
+fetched_at: 2026-05-19T09:20:26Z
+category: funcs
+title: DStream::windowJoinEngine
+sha1: 136554631df6004dc2a97830a84220ef6cdc99f8
+---
+
+# DStream::windowJoinEngine
+
+首发版本：3.00.3
+
+## 语法
+
+`DStream::windowJoinEngine(rightStream, window, metrics, matchingColumn,
+[timeColumn], [useSystemTime=false], [garbageSize], [maxDelayedTime],
+[nullFill], [sortByTime], [closed])`
+
+## 详情
+
+创建流计算窗口连接引擎。参考：[createWindowJoinEngine](../c/createWindowJoinEngine.html) 。
+
+**注意：**Orca 中的输出表会自动推断列类型：
+
+- window = 0:0（特殊窗口）：对于非聚合结果，默认推断为 array vector；若结果类型不支持 array
+  vector，则自动转换为列式元组（columnar tuple）。
+- window ≠ 0:0（普通窗口）：必须显式指定 `toArray`，结果才会输出为 array vector。
+
+## 参数
+
+**rightStream** DStream 对象，表示输入的右表数据源。
+
+**window** 必选参数，表示滑动窗口区间的整型或 DURATION 数据对，其中左右边界都包含在内。
+
+**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [元编程](../c/../../progr/objs/meta_progr.html)。
+
+- 计算指标可以是一个或多个表达式、系统内置或用户自定义函数。
+- *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 <func(price) as
+  `col1`col2>。
+
+  若在 *metrics* 指定了 *leftTable* 和
+  *rightTable* 中具有相同名称的列，默认取左表的列，可以通过 "tableName.colName"
+  指定该列来自哪个表。
+
+  注：
+
+  - *metrics* 中使用的列名大小写不敏感，不要求与输入表的列名大小写保持一致。
+  - 在需要输出 array vector 类型结果时，需要显式指定 `toArray`
+    函数转换类型。
+  - 支持使用 `toColumnarTuple`
+    函数，将非聚合计算结果转换为列式元组（columnar tuple）。
+  - 当以下函数只计算 *rightTable* 中的数据列时，window join 引擎对它们进行了优化：sum,
+    sum2, avg, std, var, corr, covar, wavg, wsum, beta, max, min,
+    last, first, med, percentile。
+
+**matchingColumn** 表示连接列的字符串标量/向量/tuple，支持 Integral, Temporal 或
+Literal（UUID 除外）类型。*matchingColumn* 指定规则为：
+
+1. 只有一个连接列：当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串标量，否则是一个长度为 2 的
+   tuple，例如：左表连接列名为 sym，右表连接列名为 sym1，则 *matchingColumn* =
+   [[`sym],[`sym1]]。
+2. 有多个连接列：当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串向量，否则是一个长度为 2 的
+   tuple，例如：左表连接列名为 timestamp, sym，右表连接列名为 timestamp, sym1，则
+   *matchingColumn* = [[`timestamp, `sym], [`timestamp,`sym1]]。
+
+**timeColumn** 可选参数，当 *useSystemTime* = false
+时，指定要连接的两个表中时间列的名称。*leftTable* 和 *rightTable* 时间列名称可以不同，但数据类型需保持一致。当
+*leftTable* 和 *rightTable* 时间列名称不同时，*timeColumn*
+为一个长度为2的字符串向量。
+
+**useSystemTime**
+可选参数，表示 *outputTable* 中第一列（时间列）为系统当前时间（*useSystemTime* =
+true）或左表的时间列（*useSystemTime* = false）。
+
+**garbageSize** 可选参数，是正整数，默认值是5,000（单位为行）。随着订阅的流数据不断积累进入 window
+join 引擎，存放在内存中的数据会越来越多，这时需要清理不再需要的历史数据。当左/右两表各个分组内的数据行数超过 *garbageSize*
+值时，系统会清理本次计算不需要的历史数据。
+
+**maxDelayedTime** 可选参数，是正整数，用于触发引擎中长时间未输出的分组数据进行计算。
+具体来说，若`(某个分组中未发生计算的窗口右边界) + (maxDelayedTime) <
+(右表最新收到的任意一个分组数据的时间戳)`，则这条数据会触发该窗口计算输出。
+
+**nullFill**
+和输出表列字段等长且类型一一对应的元组，用于填充以下列中的空值：输出表中包含的左表列、右表列、右表列被聚合计算后的计算结果列。
+
+**sortByTime** 布尔值，表示是否按全局时间顺序输出数据。默认值为
+false，表示不按全局时间输出数据，仅在组内按时间顺序输出数据。注意：当设置 sortByTime=true 时，必须保证输入的左表和右表的数据全局有序，且不可设置
+*maxDelayedTime*。
+
+**closed** 字符串，用于确定窗口边界的开闭情况，仅当 *window*为 0:0 时有效 。可选值为 ‘left’ 或 ‘right’，默认值为 ‘left’。
+
+- closed = ‘left’： 窗口左闭右开。
+- closed = ‘right’： 窗口左开右闭。此时必须设置 useSystemTime=false 。
+
+## 返回值
+
+返回一个 DStream 对象。
+
+## 例子
+
+```dolphindb
+if (!existsCatalog("orca")) {
+	createCatalog("orca")
+}
+go
+use catalog orca
+
+// 如已存在流图，则先销毁该流图
+// dropStreamGraph('joinEngine')
+g = createStreamGraph('joinEngine')
+
+r = g.source("right", `time`sym`val, [TIMESTAMP, SYMBOL, DOUBLE])
+g.source("left", `time`sym`price, [TIMESTAMP, SYMBOL, DOUBLE])
+    .windowJoinEngine(r, window=-2:2, metrics=<[price,val,sum(val)]>, matchingColumn=`sym, timeColumn=`time, useSystemTime=false,nullFill=[2012.01.01T00:00:00.000, `NONE, 0.0, 0.0, 0.0])
+    .sink("output")
+g.submit()
+
+go
+
+n=10
+tp1=table(take(2012.01.01T00:00:00.000+0..10, 2*n) as time, take(`A, n) join take(`B, n) as sym, take(NULL join rand(10.0, n-1),2*n) as price)
+tp1.sortBy!(`time)
+appendOrcaStreamTable("left", tp1)
+
+tp2=table(take(2012.01.01T00:00:00.000+0..10, 2*n) as time, take(`A, n) join take(`B, n) as sym, take(double(1..n),2*n) as val)
+tp2.sortBy!(`time)
+appendOrcaStreamTable("right", tp2)
+
+select * from orca_table.output
+```

package/templates/claude-global/skills//346/225/260/346/215/256/345/272/223/dwy-dolphindb/references/official/funcs/d/dailyAlignedBar.md

@@ -0,0 +1,115 @@
+---
+source_url: https://docs.dolphindb.cn/zh/funcs/d/dailyAlignedBar.html
+fetched_at: 2026-05-19T09:18:08Z
+category: funcs
+title: dailyAlignedBar
+sha1: ec28f05c70b0274c768e840f17ad29789fdfd6da
+---
+
+# dailyAlignedBar
+
+## 语法
+
+`dailyAlignedBar(X, timeOffset, n, [timeEnd],
+[mergeSessionEnd=false])`
+
+相关函数：[bar](../b/bar.html)
+
+## 详情
+
+按照给定的起始时刻 *timeOffset* （与结束时刻 *timeEnd* ）以及时间区间长度（由 *n* 指定），划分时间区间，返回
+*X* 中每个元素所属的时间区间起始时刻，结果为与 *X* 长度相同的向量。具体而言，对于 *X* 中的每个元素，计算
+X-((X-timeOffset)%n)。
+
+时间区间一般包括左边界，不包括右边界。但若指定 *mergeSessionEnd* =
+true，且某个时段的最后时刻为某个区间的起始时刻，则将其并入之前的区间。
+
+该函数支持隔夜时段。
+
+## 参数
+
+**X** 时间类型向量，支持以下的类型：SECOND, TIME, NANOTIME, DATETIME, TIMESTAMP 或
+NANOTIMESTAMP。
+
+**timeOffset** 标量或向量，表示每个时段的起始时刻。与 *X* 精度一致，可以是 SECOND、TIME 或 NANOTIME
+类型的标量或向量。如果 *timeOffset* 是一个向量，它必须是递增的。
+
+**n** 是一个正整数或 DURATION 类型数据，表示时间区间长度。 *n* 取正整数时，其单位为 *timeOffset* 的最小精度。
+*n* 取 DURATION 类型数据时，其单位不能是 y, M, w, d, B。
+
+**timeEnd** 可选参数，表示每个时段的结束时刻。和 timeOffset 的类型和长度必须一致。
+
+**mergeSessionEnd** 为可选参数，是一个布尔值，表示若某个时段的最后时刻为某个区间的起始时刻，是否将其并入之前的区间。默认值为
+false。
+
+## 返回值
+
+返回一个与 X 长度相同的时间类型向量，表示 X 中每个元素所属的时间区间起始时刻。
+
+## 例子
+
+以下例子中均使用了随机模拟数据。结果中的 price 列之值每次执行均会有所不同。
+
+例1. 中国股票市场每天有两个交易时段：上午9:30-11:30和下午1:00-3:00。计算每个交易时段中的60分钟均价。
+
+```dolphindb
+sessionsBegin = 09:30:00 13:00:00
+ts = 2019.11.01T09:30:00..2019.11.01T11:30:00 join 2019.11.01T13:00:00..2019.11.01T15:00:00
+t = table(ts, rand(10.0, size(ts)) as price);
+
+select avg(price) as price, count(*) as count from t group by dailyAlignedBar(X=ts, timeOffset=sessionsBegin, n=60*60) as k60;
+```
+
+| k60 | price | count |
+| --- | --- | --- |
+| 2019.11.01T09:30:00 | 5.031685383252463 | 3600 |
+| 2019.11.01T10:30:00 | 5.022667285786399 | 3600 |
+| 2019.11.01T11:30:00 | 4.930270051117987 | 1 |
+| 2019.11.01T13:00:00 | 4.931854071494632 | 3600 |
+| 2019.11.01T14:00:00 | 4.979529541734115 | 3600 |
+| 2019.11.01T15:00:00 | 0.961996954865754 | 1 |
+
+由于每个区间包括左边界，不包括右边界，若每个交易时段的结束时刻（上午11:30与下午3:00）恰好是区间边界，若不指定
+*timeEnd* 与
+*mergeSessionEnd*，则时段的结束时刻会单独作为一区间，如上例所示。多数情况下，会希望此类结束时刻归入前一区间。可参照以下脚本。
+
+```dolphindb
+sessionsEnd = 11:30:00 15:00:00;
+select avg(price) as price, count(*) as count from t group by dailyAlignedBar(X=ts, timeOffset=sessionsBegin, n=60*60, timeEnd=sessionsEnd, mergeSessionEnd=true) as k60;
+```
+
+| k60 | price | count |
+| --- | --- | --- |
+| 2019.11.01T09:30:00 | 5.031685383252463 | 3600 |
+| 2019.11.01T10:30:00 | 5.022641627015316 | 3601 |
+| 2019.11.01T13:00:00 | 4.931854071494632 | 3600 |
+| 2019.11.01T14:00:00 | 4.978413870368697 | 3601 |
+
+例2. 隔夜时段。期货市场每天有两个交易时段：下午1:30-4:30和晚上10:30-凌晨2:30。使用
+`dailyAlignedBar` 函数计算每个交易时段中的7分钟均价。
+
+```dolphindb
+sessions = 13:30:00 22:30:00
+ts = 2019.11.01T13:30:00..2019.11.01T16:30:00 join 2019.11.01T22:30:00..2019.11.02T02:30:00
+ts = ts join (ts+60*60*24)
+t = table(ts, rand(10.0, size(ts)) as price)
+select avg(price) as price, count(*) as count from t group by dailyAlignedBar(X=ts, timeOffset=sessions, n=7m) as k7;
+```
+
+例3. 计算分钟 k 线时，*n* 需要转换为
+NANOTIMESTAMP，此时若使用整型计算可能造成类型溢出，需要将数据类型转换成 LONG。
+
+```dolphindb
+n = 1000000
+nano=(09:30:00.000000000 + rand(long(6.5*60*60*1000000000), n)).sort!()
+sessionStartNano=09:30:00.000000000
+price = 100+cumsum(rand(0.02, n)-0.01)
+volume = rand(1000, n)
+symbol = rand(`600519`000001`600000`601766, n)
+tradeNano=table(symbol, nano, price, volume).sortBy!(`symbol`nano)
+undef(`nano`price`volume`symbol)
+barMinutes=7
+itv = barMinutes*60*long(1000000000)
+
+OHLC_nano=select first(price) as open, max(price) as high, min(price) as low, last(price) as close, sum(volume) as volume from tradeNano group by symbol, dailyAlignedBar(X=nano, timeOffset=sessionStartNano, n=itv) as barStart
+```