create-dwy 0.9.1 → 0.11.0

package/templates/claude-global/skills/dwy-dolphindb/references/python-api.md

@@ -0,0 +1,306 @@
+# Python SDK 详解（dolphindb 3.0.4）
+
+## 安装与版本
+
+```bash
+pip install dolphindb==3.0.4
+python -c "import dolphindb as ddb; print(ddb.__version__)"
+```
+
+最低 Python 3.7+。底层 C++ via Pybind11，多线程不受 GIL。
+
+## session.run 全用法
+
+### 执行脚本
+
+```python
+# 单语句
+s.run("x = 1")
+
+# 多语句（用 ; 分隔，最后一句的值为返回值）
+result = s.run("x=1; y=2; x+y")   # 返回 3
+
+# 多行字符串
+s.run("""
+    t = table(1..10 as a, rand(100,10) as b)
+    select * from t where a > 5
+""")
+```
+
+### 调用 DDB 函数（参数传递）
+
+```python
+# 方式 1：所有参数在服务端
+s.run("x=[1,3,5]; y=[2,4,6]")
+s.run("add(x, y)")                          # array([3, 7, 11])
+
+# 方式 2：部分应用（curry）
+import numpy as np
+y = np.array([1, 2, 3])
+s.run("add{x,}", y)                         # 等价 add(x, y)，y 从客户端传
+
+# 方式 3：两参数都从客户端
+x = np.array([1.5, 2.5, 7])
+y = np.array([8.5, 7.5, 3])
+s.run("add", x, y)                          # array([10., 10., 10.])
+```
+
+### 高级参数
+
+```python
+s.run("expensiveQuery()",
+    clearMemory=True,        # 跑完清理中间变量，防内存堆积
+    priority=7,              # 0-9，越大越优先（默认 4）
+    parallelism=2,           # 限并发，社区版 4 worker 别超 4
+    fetchSize=8192,          # 大结果分段拉
+    disableDecimal=False,    # True 时 DECIMAL 转 str（精度优先）
+)
+```
+
+### 跑文件
+
+```python
+# test.dos 是 DDB 脚本文件
+s.runFile("./scripts/calc_factor.dos")
+```
+
+## upload：Python → DDB 变量
+
+```python
+import pandas as pd
+
+s.upload({
+    'a': 8,                                  # int
+    'b': "abc",                              # str
+    'c': {'k1': 1, 'k2': 2},                # dict → DDB dictionary
+    'arr': np.array([1, 2, 3]),             # ndarray → vector
+    'df': pd.DataFrame({'x': [1,2,3]}),     # DataFrame → table
+})
+
+s.run("typestr(a)")                          # 'INT'
+s.run("typestr(df)")                         # 'TABLE'
+```
+
+**注意**：upload 的变量在 session 关闭后丢失。要持久化得写进 DFS 表。
+
+## SDK v3 异步 API（**踩坑高发**）
+
+| 调用 | 是否 async | 用法 |
+|---|---|---|
+| `DBConnectionPool.run()` | ✅ **原生 async** | `await pool.run(script)` |
+| `Session.run()` | ❌ 同步 | `await asyncio.to_thread(s.run, script)` |
+
+```python
+# ❌ 错：pool.run 已经是协程，再包 to_thread 会产生 "coroutine never awaited" 警告
+await asyncio.to_thread(pool.run, script)
+
+# ✅ 对：pool.run 直接 await
+await pool.run(script)
+
+# ✅ 对：Session.run 是同步的，需要 to_thread
+await asyncio.to_thread(s.run, script)
+```
+
+## 数据类型映射
+
+### Python → DolphinDB
+
+| Python/Pandas | DolphinDB | 转换方式 |
+|---|---|---|
+| `int` (32 bit) | INT | — |
+| `int` (64 bit) | LONG | — |
+| `float` | DOUBLE | — |
+| `str` | STRING | — |
+| `datetime.date` | DATE | — |
+| `datetime.datetime` | DATETIME / TIMESTAMP（按精度） | — |
+| `numpy.ndarray` | VECTOR | — |
+| `pandas.DataFrame` | TABLE | — |
+| `dict` | DICTIONARY | — |
+| `list of mixed` | ANY VECTOR | — |
+| `uint8/16/32/64`（DDB 不接） | INT/LONG | `.astype('int64')` 显式转 |
+| `float64` 含 NaN → 整数 | INT/LONG | `.fillna(0).astype('int64')` |
+| `uint32`（日期如 20191205） | DATE | `pd.to_datetime(str(x), format='%Y%m%d')` |
+| `uint32`（时间如 91509000） | INT | `.astype('int64')` |
+| `object`（字符串） | SYMBOL | `.astype(str)` |
+
+**硬性约束**：
+- DDB **不接受 uint 类型**，所有 `uint8/16/32/64` 必须先 `.astype('int64')`，否则报错
+- `NaN` **不能直接转整数**，必须先 `fillna(0)` 否则报 cast error
+- `SYMBOL` 是字典编码字符串，**单值上限 255 字节**（详见 [[pitfalls-and-best-practices]] SYMBOL 长度）
+
+### 精度差异
+
+- pandas `datetime64[ns]` → DDB `NANOTIMESTAMP`
+- pandas `datetime64[ms]` → DDB `TIMESTAMP`
+- Python `Decimal` → 转 DECIMAL 时要明确 scale，否则用 `disableDecimal=True` 拿字符串
+
+## 拉数据：DDB → Python
+
+```python
+# Table → DataFrame
+table = s.loadTable(tableName='snapshot', dbPath='dfs://stock_lv2_snapshot')
+df = table.toDF()
+
+print(table.rows)            # 行数
+print(table.cols)            # 列数
+print(table.schema)          # schema（DataFrame 格式）
+
+# 直接 SQL → DataFrame
+df = s.run("select * from loadTable('dfs://x','t') where TradeDate=2024.01.03")
+```
+
+## 大结果分段拉取
+
+```python
+block = s.run(
+    "select * from loadTable('dfs://stock_lv2_snapshot','snapshot') where TradeDate=2024.01.03",
+    fetchSize=8192,
+)
+total = 0
+while block.hasNext():
+    chunk = block.read()         # pd.DataFrame
+    total += len(chunk)
+    process(chunk)
+# 提前结束要 skipAll，否则连接阻塞
+# block.skipAll()
+```
+
+## DBConnectionPool 并发
+
+```python
+import asyncio
+
+pool = ddb.DBConnectionPool(
+    "localhost", 8848,
+    threadNum=3,                 # 4 worker → pool size 3
+    userId="admin", password="123456",
+)
+
+async def query_one(sid):
+    return await pool.run(f"""
+        select avg(LastPrice) from loadTable('dfs://k','k_minute')
+        where SecurityID=`{sid} and TradeDate=2024.01.03
+    """)
+
+async def main():
+    sids = ['600000', '600036', '600519']
+    results = await asyncio.gather(*[query_one(s) for s in sids])
+    return results
+
+results = asyncio.run(main())
+pool.shutDown()
+```
+
+## 流数据订阅
+
+```python
+import dolphindb as ddb
+
+s = ddb.session()
+# 开本地接收端（必须先 enable）
+s.enableStreaming(local_port=8000)    # 端口要和服务端 publish 端口区分
+s.connect("localhost", 8848, "admin", "123456")
+
+# handler：每条/每批数据回调
+def on_data(msg):
+    # msg 是 list（msgAsTable=False）或 DataFrame（msgAsTable=True）
+    print(f"received {len(msg)} rows")
+    process(msg)
+
+# 订阅服务端流表
+s.subscribe(
+    host="localhost", port=8848,
+    handler=on_data,
+    tableName="trades_stream",       # 服务端 streamTable
+    actionName="myAction",           # 订阅 ID（同表多订阅必须不同）
+    offset=-1,                       # -1=最新, 0=从头, N=从第 N 条
+    resub=True,                      # 断线重连
+    filter=None,                     # 过滤向量
+    msgAsTable=True,                 # True=每批 DataFrame, False=每条 list
+    batchSize=1000,                  # 攒够 1000 条触发 handler
+    throttle=1,                      # 或最多攒 1 秒
+)
+
+# 看当前订阅
+print(s.getSubscriptionTopics())
+
+# 取消
+s.unsubscribe(host="localhost", port=8848,
+              tableName="trades_stream", actionName="myAction")
+```
+
+**坑**：
+- `enableStreaming` 的 `local_port` 不能和 DDB 服务端口冲突
+- handler 抛异常**默默吃掉**，必须自己 try/except + log
+- `batchSize + throttle` 是 OR 关系，先到先发
+
+## 异步提交（不阻塞客户端）
+
+```python
+# Session 异步模式（fire-and-forget）
+s.enableAsyncMode()
+s.run("tableInsert{loadTable('dfs://k','k_minute')}", df)
+# 立即返回，写入在服务端后台跑，**没有返回值，错误也不抛**
+s.disableAsyncMode()
+
+# 适用：高频写入，对回执不敏感
+# 不适用：要确认成功、要拿结果
+```
+
+## 错误处理与重连
+
+```python
+import dolphindb as ddb
+import dolphindb.settings as keys
+
+s = ddb.session()
+try:
+    s.connect("localhost", 8848, "admin", "123456",
+              reconnect=True, tryReconnectNums=5,
+              keepAliveTime=120)
+    result = s.run("select count(*) from loadTable('dfs://x','t')")
+except RuntimeError as e:
+    # DDB 服务端报错都是 RuntimeError
+    print(f"DDB error: {e}")
+    # 常见消息：
+    #   "Out of memory" → 见 performance-tuning
+    #   "Failed to read response" → 网络/服务端崩溃
+    #   "Couldn't send script" → keepAlive 超时
+finally:
+    s.close()
+```
+
+## 关闭与资源回收
+
+```python
+# Session：必须显式关
+s.close()
+
+# 连接池：必须 shutDown
+pool.shutDown()
+
+# 流订阅：unsubscribe 后销毁 session
+s.unsubscribe(...)
+s.close()
+```
+
+**长期运行的服务**：用 context manager 包一层（DDB SDK 没原生支持，自己写）：
+
+```python
+from contextlib import contextmanager
+
+@contextmanager
+def ddb_session(host="localhost", port=8848):
+    s = ddb.session()
+    s.connect(host, port, "admin", "123456",
+              keepAliveTime=120, reconnect=True)
+    try:
+        yield s
+    finally:
+        s.close()
+
+with ddb_session() as s:
+    df = s.run("select count(*) from loadTable('dfs://x','t')")
+```
+
+跨引用：写入对比 → [[data-import]]，性能调优 → [[performance-tuning]]，连接配置 → [[setup-and-connection]]。

package/templates/claude-global/skills/dwy-dolphindb/references/setup-and-connection.md

@@ -0,0 +1,143 @@
+# 连接与基础设置
+
+## 集群拓扑
+
+```
+controller (8848)  ←─ Web UI / DolphinDB GUI / Python SDK 入口
+    │
+    ├── datanode-1 (8849?)   ← 实际存储 + 计算
+    └── datanode-2 (8850?)   ← 实际存储 + 计算
+```
+
+社区版默认 1 控 2 节点。`localhost:8848` 是控制节点的 Web 端，**Python SDK 连这里**，由控制节点路由到数据节点。
+
+查实际端口和节点：
+
+```dolphindb
+getClusterPerf()                 // 列出所有节点 name/host/port/mode
+getControllerAlias()             // 控制节点别名
+getDataNodes()                   // 数据节点列表
+```
+
+## Python SDK 安装
+
+```bash
+pip install dolphindb==3.0.4
+# 验证
+python -c "import dolphindb as ddb; print(ddb.__version__)"
+```
+
+## 标准连接
+
+```python
+import dolphindb as ddb
+
+s = ddb.session()
+s.connect("localhost", 8848, "admin", "123456")
+
+# 验证
+print(s.run("getNodeAlias()"))
+```
+
+### 完整 connect 签名
+
+```python
+connect(host, port,
+        userid=None, password=None, startup=None,
+        highAvailability=False, highAvailabilitySites=None,
+        keepAliveTime=None, reconnect=False,
+        *,
+        tryReconnectNums=None, readTimeout=None, writeTimeout=None)
+```
+
+### 大查询场景（必须调）
+
+```python
+s.connect(
+    "localhost", 8848, "admin", "123456",
+    keepAliveTime=120,        # 默认 30s，大查询要拉到 ≥120s 否则断连
+    reconnect=True,
+    tryReconnectNums=5,
+    readTimeout=600,          # 单位秒，大结果集别用默认
+    writeTimeout=600,
+)
+```
+
+### 高可用（连节点池，自动选最低负载）
+
+```python
+s = ddb.session()
+sites = ["localhost:8848", "192.168.0.107:8848"]   # 控制节点列表
+s.connect(
+    host="localhost", port=8848,
+    userid="admin", password="123456",
+    highAvailability=True,
+    highAvailabilitySites=sites,
+)
+```
+
+### 启动脚本（每次连接自动跑）
+
+```python
+s.connect(host="localhost", port=8848,
+          startup="clearAllCache(); login('admin','123456')")
+```
+
+## 关闭连接
+
+```python
+s.close()
+```
+
+**重要**：连接不显式关，连接数会被快速吃满（社区版上限 512，当前已用 15）。脚本结束务必 `s.close()`，长服务用 `try/finally`。
+
+## DBConnectionPool（并发场景必备）
+
+```python
+pool = ddb.DBConnectionPool(
+    "localhost", 8848, threadNum=3,    # 4 worker → pool size 3
+    userId="admin", password="123456",
+)
+
+# 并发跑多个 SQL
+import asyncio
+loop = asyncio.get_event_loop()
+tasks = [pool.run(f"select * from loadTable('dfs://k','k_minute') where SecurityID=`{sid}`")
+         for sid in ['600000', '600036']]
+results = loop.run_until_complete(asyncio.gather(*tasks))
+
+pool.shutDown()
+```
+
+**社区版 worker = 4**：pool size 取 3（留 1 worker 给 Web/管理）。设到 4+ 会和 web/ops 抢线程。
+
+## 登录与权限
+
+```python
+# 方式 1：connect 时带凭证（推荐）
+s.connect("localhost", 8848, "admin", "123456")
+
+# 方式 2：先连后登录
+s.connect("localhost", 8848)
+s.login("admin", "123456")
+
+# 改密码
+s.run("changePwd('admin', '新密码')")
+```
+
+## 常见报错
+
+| 报错 | 原因 | 处理 |
+|---|---|---|
+| `Connection refused` | 节点没起 / 端口不对 | `lsof -i:8848` 看端口；查 `getClusterPerf()` 用控制节点端口 |
+| `Couldn't send script/function...` | `keepAliveTime` 太短，长查询被踢 | 提到 120+ |
+| `The user is not authorized to perform this operation` | 权限不够 | 用 admin 登录或 `grant(...)` |
+| `Out of memory` | 单查询超 2GB | 看 [[performance-tuning]] |
+| `Couldn't connect to the gateway` | 高可用模式所有 site 都挂 | 退回单节点模式排查 |
+| Python 端 hang 住 | 服务端作业卡了 | 另起 session 跑 `getConsoleJobs()` 找 → `cancelConsoleJob()` |
+
+## Web UI 入口
+
+- 控制台：http://localhost:8848
+- 看作业 / 节点状态 / 配置参数 / 用 Web 编辑器跑脚本
+- 局域网访问用机器 IP：`http://192.168.0.107:8848`

package/templates/claude-global/skills/dwy-dolphindb/references/sources.md

@@ -0,0 +1,46 @@
+# 数据源与参考资料
+
+本 skill 的所有内容溯源。需要查更新 / 深入细节时直接进官方。
+
+## 官方文档（中文）
+
+| 资源 | URL | 用途 |
+|---|---|---|
+| 金融用户入门 | https://docs.dolphindb.cn/zh/tutorials/new_users_finance.html | 建库 / 导入 / SQL 批计算完整范式 |
+| 使用须知 | https://docs.dolphindb.cn/zh/tutorials/usage_guidelines.html | 库表/SQL/语法/运维所有反模式 |
+| 作业管理教程 | https://docs.dolphindb.cn/zh/tutorials/job_management_tutorial.html | getConsoleJobs / cancelJob 等命令 |
+| 函数手册 | https://docs.dolphindb.cn/zh/funcs/ | 所有内置函数签名 |
+
+## Python SDK（dolphindb 3.0.4）
+
+主入口：https://docs.dolphindb.cn/zh/pydoc/
+
+| 章节 | URL |
+|---|---|
+| Session 创建 | https://docs.dolphindb.cn/zh/pydoc/BasicOperations/Session/Constructor.html |
+| Session connect | https://docs.dolphindb.cn/zh/pydoc/BasicOperations/Session/Connect.html |
+| Session 常用方法 | https://docs.dolphindb.cn/zh/pydoc/BasicOperations/Session/OtherParams.html |
+| 异步任务提交 | https://docs.dolphindb.cn/zh/pydoc/BasicOperations/AsyncWrites/SessionAsyncMode.html |
+| 离线安装 | https://docs.dolphindb.cn/zh/tutorials/python_api_install_offline.html |
+| Release Notes | https://docs.dolphindb.cn/zh/ReleaseNotes/api/python_rn.html |
+
+## 英文版（部分中文还没翻译，英文更完整）
+
+主入口：https://docs.dolphindb.com/en/pydoc/
+
+## GitHub 仓库
+
+| 仓库 | URL | 用途 |
+|---|---|---|
+| Python SDK 源码 | https://github.com/dolphindb/python-sdk | 看源码确认行为 |
+| Python SDK README | https://github.com/dolphindb/api_python3/blob/master/README.md | 快速上手 |
+
+## 版本基线
+
+本 skill 验证于：
+- DolphinDB Server：**3.0 社区版**
+- Python SDK：**dolphindb==3.0.4**
+- 集群拓扑：1 控制 + 2 数据节点
+- 资源：2 核 / 8GB / 33TB
+
+跨大版本（如 2.x → 3.x，或 3.x → 4.x）部分行为会变，遇到不符必须回官方文档核对。

package/templates/claude-global/skills/dwy-dolphindb/references/sql-batch-compute.md

@@ -0,0 +1,206 @@
+# SQL 批计算
+
+## 核心范式
+
+DDB 三种批计算范式，按数据量选：
+
+| 数据量 | 范式 | 说明 |
+|---|---|---|
+| 单分区 / 单股 / 单天 | 直接 SQL | 一句话搞定 |
+| 跨多分区 | `sqlDS` + `mr` 分布式 | 自动分片并行 |
+| 复杂多步骤管道 | 中间内存表 + 多步 SQL | 拆步骤调试 |
+
+## 范式 1：单步 SQL
+
+```dolphindb
+// 单天单股 SOIR
+select TradeDate, TradeTime, SecurityID,
+       (BidOrderQty - OfferOrderQty) \ (BidOrderQty + OfferOrderQty) as imbalance
+from loadTable("dfs://stock_lv2_snapshot", "snapshot")
+where TradeDate = 2024.01.03 and SecurityID = `600000`
+```
+
+## 范式 2：sqlDS + mr（**跨分区必用**）
+
+```dolphindb
+def calcSomething(snapshot){
+    return select SecurityID, TradeDate,
+        avg(LastPrice) as avgPx,
+        sum(TotalVolumeTrade) as vol
+    from snapshot
+    group by SecurityID, TradeDate
+}
+
+dbName = "dfs://stock_lv2_snapshot"
+tbName = "snapshot"
+beginDate = 2024.01.01
+endDate = 2024.01.31
+
+// sqlDS = 把一个 SQL 切成多个数据源（按分区）
+ds = sqlDS(<select * from loadTable(dbName, tbName)
+            where TradeDate between beginDate and endDate>)
+
+// mr = map-reduce
+// 参数：数据源, map 函数, reduce 函数（可省）, final 合并, parallel
+re = mr(ds, calcSomething, , unionAll, false)
+```
+
+**parallel=false 的意义**：写同一目标分区时必须 false。读分布式查询 + 写内存结果 → 可以 true。
+
+## 完整案例：K 线合成（snapshot → 1 分钟 K）
+
+```dolphindb
+defg highPx(deltasHigh, highPrice, lastPrice){
+    // 函数式聚合：如果有 deltas 就用 high，否则用 last
+    if(sum(deltasHigh) > 0.000001){
+        return max(highPrice)
+    } else {
+        return max(lastPrice)
+    }
+}
+
+def calcKLine(snapshot){
+    // 第一步：处理时间 + 计算 delta（按股票分组）
+    tempTB = select TradeDate,
+        iif(TradeTime <= 09:30:00.000, 09:30:00.000, TradeTime) as TradeTime,
+        SecurityID,
+        OpenPrice, HighPrice, LowPrice, LastPrice,
+        iif(deltas(HighPrice) > 0.000001, 1, 0) as deltasHigh,
+        iif(deltas(TotalVolumeTrade) == NULL,
+            TotalVolumeTrade,
+            deltas(TotalVolumeTrade)) as deltasVolume
+    from snapshot
+    where TradeTime >= 09:25:00.000
+    context by SecurityID                  // 注意：deltas 要分组
+
+    // 第二步：按 1 分钟桶聚合
+    return select firstNot(LastPrice, 0) as open,
+        highPx(deltasHigh, HighPrice, LastPrice) as high,
+        last(LastPrice) as close,
+        sum(deltasVolume) as volume
+    from tempTB
+    group by SecurityID, TradeDate,
+        interval(X=TradeTime, duration=60s, label='left', fill=0) as bar1min
+}
+
+// 跑全月
+dbName = "dfs://stock_lv2_snapshot"
+ds = sqlDS(<select * from loadTable(dbName, "snapshot")
+            where TradeDate between 2024.01.01 and 2024.01.31>)
+result = mr(ds, calcKLine, , unionAll, false)
+```
+
+## 完整案例：SOIR（订单失衡率）
+
+```dolphindb
+def wavgSOIR(bidQty, askQty, lag=20){
+    // rowWavg：按 10 档权重加权 (10,9,8,...,1)
+    imbalance = rowWavg(
+        (bidQty - askQty) \ (bidQty + askQty),
+        10 9 8 7 6 5 4 3 2 1
+    ).ffill().nullFill(0)
+
+    // 滚动均值 + 标准差，做 z-score
+    mean = mavg(prev(imbalance), (lag - 1), 2)
+    std = mstdp(prev(imbalance) * 1000000, (lag - 1), 2) \ 1000000
+
+    return iif(std >= 0.0000001,
+               (imbalance - mean) \ std,
+               NULL).ffill().nullFill(0)
+}
+
+re = select SecurityID, TradeDate, TradeTime,
+            wavgSOIR(BidOrderQty, OfferOrderQty, lag=20) as soir
+     from loadTable("dfs://stock_lv2_snapshot", "snapshot")
+     where TradeDate between 2024.01.01 and 2024.01.31
+     context by SecurityID csort TradeTime
+```
+
+**关键点**：
+- `context by SecurityID csort TradeTime`：按股票分组、组内按时间排序
+- `prev()`：取上一行，避免使用当前行未来信息
+- `ffill().nullFill(0)`：先用前值补，前值也没有时填 0
+
+## 完整案例：截面排名（行业内 z-score）
+
+```dolphindb
+// 输入：因子表 t(date, sid, industry, factor)
+// 输出：每天每个行业内 z-score 排名
+
+// 方式 1：context by 多键
+select date, sid, industry, factor,
+       (factor - avg(factor)) \ stdp(factor) as zscore
+from t
+context by date, industry
+
+// 方式 2：pivot 后矩阵化
+m = exec factor from t pivot by date, sid
+// 转置：行=date, 列=sid -> 每行内 rank
+rankM = rowRank(m, true) \ count(m[0])    // 转 percentile
+```
+
+## 时序窗口函数（DDB 强项）
+
+| 函数 | 说明 |
+|---|---|
+| `prev(x, n=1)` | 取前 n 行 |
+| `next(x, n=1)` | 取后 n 行 |
+| `deltas(x)` | 一阶差分 |
+| `ratios(x)` | 比率 |
+| `cumsum/cumavg/cummax/cummin(x)` | 累计 |
+| `mavg/msum/mmax/mmin(x, window)` | 滚动 |
+| `mvar/mstdp(x, window)` | 滚动方差/标准差 |
+| `ema(x, alpha)` | 指数移动平均 |
+| `rolling(func, x, window, step)` | 通用滚动 |
+
+## 截面函数
+
+| 函数 | 说明 |
+|---|---|
+| `rowSum/rowAvg/rowMin/rowMax(m)` | 矩阵每行聚合 |
+| `rowRank(m, asc=true)` | 行内排名 |
+| `rowWavg(m, weights)` | 行加权平均 |
+| `corrMatrix(m)` | 相关性矩阵 |
+| `pivot by` | 长表 → 矩阵 |
+| `unpivot` | 矩阵 → 长表 |
+
+## Python 触发批计算
+
+```python
+# 方式 1：把 DDB 函数注册到服务端，Python 调用
+ddb_func = """
+def calcKLine(snapshot){ ... }
+"""
+s.run(ddb_func)
+
+# 然后跑 mr
+result = s.run("""
+    ds = sqlDS(<select * from loadTable('dfs://k','snapshot')
+                where TradeDate between 2024.01.01 and 2024.01.31>);
+    mr(ds, calcKLine, , unionAll, false)
+""")  # 返回 DataFrame
+
+# 方式 2：用 submitJob 异步跑，避免 keepAlive 超时
+jobId = s.run("""
+    submitJob('calcK', 'calc kline for jan',
+              {def(){
+                ds = sqlDS(<select * from loadTable('dfs://k','snapshot')
+                            where TradeDate between 2024.01.01 and 2024.01.31>);
+                re = mr(ds, calcKLine, , unionAll, false);
+                loadTable('dfs://k','k_minute').tableInsert(re)
+              }})
+""")
+# 查进度
+s.run(f"getJobStatus(`{jobId})")
+```
+
+## 性能技巧
+
+1. **能 group by 就别 context by**：context by 保留所有行，内存翻倍。
+2. **数组向量比拆列快**：10 档行情用 `DOUBLE[]` 一列，而不是 20 列。
+3. **mr 的 final 函数选择**：返回小表用 `unionAll`，返回标量用 `+` 或 `add`。
+4. **defg vs def**：`defg`（aggregate function）用于聚合上下文，性能比普通 `def` 在 group by 中快 10x+。
+5. **避免 join 大表**：DDB 的 `equal join` 在大分布式表上很慢，能 pivot 解决就 pivot。
+6. **chunkSize 调优**：mr 太多小任务调度开销大，太少不并行。社区版 4 worker → 控制在 8-16 个 chunk。
+
+跨引用：建表 → [[create-database-table]]，调优 → [[performance-tuning]]。