DolphinDB 实时排名计算：Top-N 实时排行（概念拆解 + 流式引擎实战）

文章目录

• • 一、引言：为什么需要实时排行
  • 二、概念拆解：三个前置知识点
  • • 2.1 什么是 DolphinDB
    • 2.2 什么是实时排名计算 / Top-N 实时排行
    • 2.3 什么是流计算引擎
  • 三、排名函数全家福：rank / dense_rank / row_number / percent_rank
  • 四、Top-N 计算的四种姿势
  • • 4.1 静态表 Top-N（context by + top）
    • 4.2 分组 Top-N（partition by + 过滤）
    • 4.3 流式实时 Top-N
    • 4.4 响应式状态引擎持续排名
  • 五、动态排序与排名变化追踪
  • 六、多维度加权排名
  • 七、实战：完整实时排行榜系统
  • 八、为什么这样设计：反例、边界与替代方案
  • 九、总结与思考题
  • 参考资料

摘要：本文以 DolphinDB 3.00.x 为例，系统讲解实时排名计算与 Top-N 实时排行的落地方法。文章先拆解 DolphinDB、流计算引擎、排名计算三个前置概念，再依次给出排名函数全家福、静态表与分组 Top-N、流式实时 Top-N、动态排序与排名变化追踪、多维度加权排名五类写法，并附端到端实时排行榜实战。所有方案均给出可运行脚本与预期输出，并标注边界风险与替代方案，帮助读者在设备温度榜、股票涨幅榜、游戏排行榜等场景中稳定落地。

一、引言：为什么需要实时排行

实时排行榜几乎是所有数据产品的高频需求：电商的实时热销榜、游戏的战力与段位榜、IoT 设备的温度或能耗榜、金融的涨幅榜与资金流向榜。它们的共同点是「数据持续产生、排名必须跟着变、用户要马上看到」。一个设计良好的实时榜，既要算得快，也要让用户感知到的「变化」有意义——频繁抖动会让人怀疑数据，长期不变又失去实时意义。这正是本文要平衡的工程点。

如果用传统定时批处理（比如每分钟跑一次 SQL 排序），延迟高，而且在大并发下反复全表扫描成本很大。DolphinDB 的优势在于把「流」和「计算」合在一起：数据一边进来，引擎一边维护排名状态，结果表始终是当前最新的 Top-N。本文基于 DolphinDB 3.00.x 版本，把实时排名这件事从概念一路拆到落地，给出可直接运行的脚本。

之所以单独写一篇，是因为排名看似只是 order by，但要做到低延迟、可扩展、还能追踪名次变化，里面有不少工程细节。下面先把三个名词讲清楚，避免后面「看得懂函数、看不懂为什么这么搭」。

实时排行在工程上有两种经典架构：一种是「拉」模式，前端或应用定时查询数据库重新排序；另一种是「推」模式，数据进入时由引擎增量维护排名并主动推送。本文聚焦推模式，因为它把延迟从秒级压到亚秒级，也更省计算。理解这一点，后面的引擎写法就有了抓手。

二、概念拆解：三个前置知识点

2.1 什么是 DolphinDB

DolphinDB 是一款集时序数据库、分布式计算与流处理于一体的国产高性能平台。它的核心卖点是「库内计算」：数据不用搬来搬去，计算直接在存储节点上完成。

对排行榜这类场景，它提供流表（streamTable）、时间序列引擎、响应式状态引擎等原语，让「边来边算」成为内置能力，而不是靠外部应用轮询。其经典原理是「计算向数据靠拢」，这个思路长期适用，不依赖特定库版本。

2.2 什么是实时排名计算 / Top-N 实时排行

排名计算，就是给一组对象按某个度量排先后；Top-N 是只保留前 N 名。和离线排名的区别在于「实时」：度量在不断变化（温度在波动、价格在跳动），排名要随之更新，而且通常只需要最新快照的前几名，不需要全量排序。

实时排行的难点不在排序本身，而在「如何低成本地持续维护排名状态」，以及「如何把名次变化实时推给前端」。

2.3 什么是流计算引擎

流计算引擎是 DolphinDB 处理实时数据的核心组件。时间序列引擎（createTimeSeriesEngine）按固定时间窗口聚合；响应式状态引擎（createReactiveStateEngine）维护跨消息的状态，比如滑动窗口内的滚动排名；此外还有横截面引擎等。

对实时排行，最常用的是响应式状态引擎配合 rowRank，或专用的 mslidingTopN 滑动 Top-N 函数。理解「引擎订阅流表、按窗口或分组产出、写入结果表」这条主线，后面的代码就顺了。

三个概念串起来就是本文的主线：DolphinDB 提供存储与计算合一的底座，流计算引擎把「持续进数」变成「持续产出排名」，而排名计算本身是建立在这套底座上的窗口函数组合。下文所有写法，都是这条主线的具体展开。

三、排名函数全家福：rank / dense_rank / row_number / percent_rank

DolphinDB 的窗口函数族提供了四种基础排名原语，它们是所有排行榜写法的积木。下面的脚本把它们封装成函数，入参 data 是内存表，valueCol 是待排名的度量列名。

这四种函数对应不同语义：rank 适合需要「真实名次」的榜单；dense_rank 适合等级划分（如 S/A/B/C）；row_number 适合去重或分页；percent_rank 适合把不同量纲的榜归一化到同一刻度再比较。选错函数，榜单含义就会跑偏，所以先想清楚「并列时该怎么处理」再动手。

// 排名函数全家福：rank / dense_rank / row_number / percent_rank
// 入参 data 为内存表，valueCol 为待排名的度量列名
def basicRank(data, valueCol) {
// 全局降序排名，并列时产生名次间隙（如 1,2,2,4）
return select *, rank() over (order by eval(valueCol) desc) as rank_val
from data
}

def denseRank(data, valueCol) {
// 紧凑排名，并列不占名次（如 1,2,2,3）
return select *, dense_rank() over (order by eval(valueCol) desc) as rank_val
from data
}

// 分组排名：在每个 groupCol 内部独立排名
def groupRank(data, groupCol, valueCol) {
return select *,
rank() over (partition by eval(groupCol)
order by eval(valueCol) desc) as rank_val
from data
}

// 百分位排名：返回 0~1 的相对位置，适合跨组比较
def percentRank(data, valueCol) {
return select *,
percent_rank() over (order by eval(valueCol)) as pct_val
from data
}

输入→处理→输出→预期：把一张含 value 列的表传给 basicRank，返回原表加一列 rank_val；rank() 在并列时会「跳号」（两个并列第 2 后下一个是第 4），dense_rank() 则不跳号。预期输出：对示例表调用 basicRank 后，rank_val 列按度量降序给出 1、2、3…… 的连续或带间隙名次。

四种函数的取舍决定了榜单的呈现方式，下面用一张表对照：

回到「并列怎么排」这个本质问题：如果两台设备温度都是 39.5，你希望它们并列第 1 还是分占 1、2？这没有标准答案，取决于业务——比赛排行榜通常并列（dense_rank），而资源调度往往要打破平局（row_number 加稳定次序）。所以在封装函数时，把排名策略作为参数暴露出来，比写死一种更省事。这也是为什么本文把四种函数都列出来，而不是只给一个「万能排名」。在真实项目里，我倾向于把排名策略做成配置项，上线后通过配置切换，不用改代码。

四、Top-N 计算的四种姿势

实际项目里，Top-N 并不只有一种写法，按数据形态可分为静态表、分组、流式、状态引擎四类。

4.1 静态表 Top-N（context by + top）

对一张已存在的表取前 N 名，最直接：select top n * from t order by value desc。若要在每个维度内分别取 Top-N，用 context by 分组后截断即可，这是 DolphinDB 对分组截断的语法糖。

4.2 分组 Top-N（partition by + 过滤）

当维度很多时，先 rank() over (partition by 维度) 算组内名次，再 where rank_val <= n 过滤。注意 partition by 与 context by 的区别：前者是 SQL 窗口语义，后者是 DolphinDB 流式/分组截断语义，别混用。

举个具体例子：要取每个区域销量前 3 的商品，写法是 select *, rank() over (partition by region order by sales desc) as r from t where r <= 3。这里有一个常见反例：有人会先 top 3 再分组，结果每组只返回一条——因为 top 作用于全局。正确做法是先算组内名次再过滤，顺序不能反。

4.3 流式实时 Top-N

数据从流表持续进入，需要「边来边排」。下面用响应式状态引擎维护每台设备的滚动排名，再对外暴露取 Top-N 的接口。

// 流式实时 Top–N：响应式状态引擎持续维护每个设备的滚动排名
// 适用场景：设备温度榜、股票涨幅榜等需要"边来边排"的低延迟排行
// 1) 建流表：传感器数据持续写入，ts 为毫秒时间戳
share streamTable(100000:0, `device_id`ts`temp,
[SYMBOL, TIMESTAMP, DOUBLE]) as sensor_stream
// 2) 建结果表：存放每个窗口的 Top–N 与组内名次
share table(1:0, `device_id`ts`temp`rn, [SYMBOL, TIMESTAMP, DOUBLE, INT]) as topn_result
// 3) 响应式状态引擎：按设备分组，windowSize/step=1000 表示每 1 秒滚动
engine = createReactiveStateEngine(name="topnEngine",
dummyTable=sensor_stream,
windowSize=1000, step=1000,
metrics=<[ts, temp, rowRank(temp, false) as rn]>,
outputTable=topn_result,
keyColumn=`device_id)
// 4) 订阅流表到引擎，msgAsTable 保证按表结构解析
subscribeTable(tableName="sensor_stream", actionName="subTopN",
offset=0, handler=engine, msgAsTable=true)
// 5) 模拟写入：每 200ms 推送一条随机温度，验证引擎持续产出排名
def mockPush() {
for (i in 1..50) {
insert into sensor_stream
values(take("dev" + string(i % 5), 1), now(), rand(20.0..40.0, 1)[0])
sleep(200)
}
}
// 6) 取全局 Top 10：对最新快照按温度降序取前 10
def getTopN(n=10) {
return select top n * from topn_result order by temp desc
}

输入→处理→输出→预期：流表 sensor_stream 每来一批数据，引擎按 device_id 分组、在 1 秒滚动窗口内用 rowRank 计算组内名次，写入 topn_result。验证方式：启动引擎并执行 mockPush 后，查询 topn_result 应能看到每台设备带 rn 名次的最新行；getTopN(10) 返回温度最高的 10 条。

下面这张图给出整体数据流：数据源 → 流表 → 引擎 → 结果表 → 前端，箭头方向即实时数据流向。

#mermaid-svg-NQTWnGSMxinRXW7Q{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-NQTWnGSMxinRXW7Q .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-NQTWnGSMxinRXW7Q .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-NQTWnGSMxinRXW7Q .error-icon{fill:#552222;}#mermaid-svg-NQTWnGSMxinRXW7Q .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-NQTWnGSMxinRXW7Q .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-NQTWnGSMxinRXW7Q .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-NQTWnGSMxinRXW7Q .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-NQTWnGSMxinRXW7Q .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-NQTWnGSMxinRXW7Q .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-NQTWnGSMxinRXW7Q .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-NQTWnGSMxinRXW7Q .marker{fill:#333333;stroke:#333333;}#mermaid-svg-NQTWnGSMxinRXW7Q .marker.cross{stroke:#333333;}#mermaid-svg-NQTWnGSMxinRXW7Q svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-NQTWnGSMxinRXW7Q p{margin:0;}#mermaid-svg-NQTWnGSMxinRXW7Q .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-NQTWnGSMxinRXW7Q .cluster-label text{fill:#333;}#mermaid-svg-NQTWnGSMxinRXW7Q .cluster-label span{color:#333;}#mermaid-svg-NQTWnGSMxinRXW7Q .cluster-label span p{background-color:transparent;}#mermaid-svg-NQTWnGSMxinRXW7Q .label text,#mermaid-svg-NQTWnGSMxinRXW7Q span{fill:#333;color:#333;}#mermaid-svg-NQTWnGSMxinRXW7Q .node rect,#mermaid-svg-NQTWnGSMxinRXW7Q .node circle,#mermaid-svg-NQTWnGSMxinRXW7Q .node ellipse,#mermaid-svg-NQTWnGSMxinRXW7Q .node polygon,#mermaid-svg-NQTWnGSMxinRXW7Q .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-NQTWnGSMxinRXW7Q .rough-node .label text,#mermaid-svg-NQTWnGSMxinRXW7Q .node .label text,#mermaid-svg-NQTWnGSMxinRXW7Q .image-shape .label,#mermaid-svg-NQTWnGSMxinRXW7Q .icon-shape .label{text-anchor:middle;}#mermaid-svg-NQTWnGSMxinRXW7Q .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-NQTWnGSMxinRXW7Q .rough-node .label,#mermaid-svg-NQTWnGSMxinRXW7Q .node .label,#mermaid-svg-NQTWnGSMxinRXW7Q .image-shape .label,#mermaid-svg-NQTWnGSMxinRXW7Q .icon-shape .label{text-align:center;}#mermaid-svg-NQTWnGSMxinRXW7Q .node.clickable{cursor:pointer;}#mermaid-svg-NQTWnGSMxinRXW7Q .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-NQTWnGSMxinRXW7Q .arrowheadPath{fill:#333333;}#mermaid-svg-NQTWnGSMxinRXW7Q .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-NQTWnGSMxinRXW7Q .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-NQTWnGSMxinRXW7Q .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-NQTWnGSMxinRXW7Q .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-NQTWnGSMxinRXW7Q .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-NQTWnGSMxinRXW7Q .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-NQTWnGSMxinRXW7Q .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-NQTWnGSMxinRXW7Q .cluster text{fill:#333;}#mermaid-svg-NQTWnGSMxinRXW7Q .cluster span{color:#333;}#mermaid-svg-NQTWnGSMxinRXW7Q div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-NQTWnGSMxinRXW7Q .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-NQTWnGSMxinRXW7Q rect.text{fill:none;stroke-width:0;}#mermaid-svg-NQTWnGSMxinRXW7Q .icon-shape,#mermaid-svg-NQTWnGSMxinRXW7Q .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-NQTWnGSMxinRXW7Q .icon-shape p,#mermaid-svg-NQTWnGSMxinRXW7Q .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-NQTWnGSMxinRXW7Q .icon-shape .label rect,#mermaid-svg-NQTWnGSMxinRXW7Q .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-NQTWnGSMxinRXW7Q .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-NQTWnGSMxinRXW7Q .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-NQTWnGSMxinRXW7Q :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

时间序列引擎 周期聚合

响应式状态引擎 滚动排名

传感器/业务数据

流表 sensor_stream

流计算引擎

排行榜结果表 temp_rank/hum_rank

topn_result

对外接口 getBoard

前端实时榜单 + 升降箭头

4.4 响应式状态引擎持续排名

上一节的引擎已经能持续产出名次，但它维护的是「每设备滚动窗口内的排名」。若需要「全局 Top-N 随时间变化」，则在引擎输出之上再做一次 top n 聚合即可（见第七节实战）。选型判据是：要不要保留历史名次——要追踪升降就保留，只需最终结果可改用更轻的定时器方案。

补充一个专用函数 mslidingTopN：它与响应式状态引擎思路不同，在一个滑动时间窗口内直接返回每组的 Top-N 值，适合「每个设备近 1 分钟温度最高的 3 个时刻」这类需求；而 rowRank 维护的是滚动名次。选型口诀：要名次用 rowRank/响应式引擎，要窗口内 Top 值用 mslidingTopN。两者都建立在「计算向数据靠拢」这一经典原理之上，长期适用，不依赖特定库版本。

五、动态排序与排名变化追踪

排行榜的价值不仅在于「谁第一」，还在于「谁升了谁降了」。下面的脚本对比两轮名次，记录变化幅度，供前端渲染 ↑/↓。

// 排名变化追踪：对比上一轮与本轮名次，记录升/降与幅度
// oldRank / newRank 为两张带 device_id 与 rank_val 的表
def detectRankChange(oldRank, newRank) {
// 防御：任一轮为空时直接返回空表，避免 aj 在空表上报错
if (oldRank.rows() == 0 || newRank.rows() == 0) {
return select * from oldRank where false
}
// 用 aj（asof join）按设备对齐新旧名次，避免逐行循环
joined = select a.device_id, a.rank_val as old_r, b.rank_val as new_r
from oldRank as a
aj(left join newRank as b on a.device_id = b.device_id)
// 计算名次变化：new_r – old_r < 0 表示名次上升
change = select device_id, old_r, new_r,
new_r – old_r as delta,
now() as change_time
from joined
where new_r – old_r != 0
// 变化写入历史表，供前端展示"↑/↓"
if (change.rows() > 0) {
rank_change.append!(change)
}
return change
}

输入→处理→输出→预期：传入上一轮 oldRank 与本轮 newRank，用 aj 按设备对齐后计算 delta = new_r – old_r；delta 为负代表上升、为正代表下降，写入 rank_change 历史表。预期输出：返回仅含发生变化设备的表，列含 old_r、new_r、delta、change_time，前端据此显示箭头。

引擎在运行时会在若干状态间迁移，下图用状态图把这条主线画出来：

#mermaid-svg-VBk9pgR4BtPCw7CU{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-VBk9pgR4BtPCw7CU .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-VBk9pgR4BtPCw7CU .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-VBk9pgR4BtPCw7CU .error-icon{fill:#552222;}#mermaid-svg-VBk9pgR4BtPCw7CU .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-VBk9pgR4BtPCw7CU .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-VBk9pgR4BtPCw7CU .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-VBk9pgR4BtPCw7CU .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-VBk9pgR4BtPCw7CU .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-VBk9pgR4BtPCw7CU .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-VBk9pgR4BtPCw7CU .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-VBk9pgR4BtPCw7CU .marker{fill:#333333;stroke:#333333;}#mermaid-svg-VBk9pgR4BtPCw7CU .marker.cross{stroke:#333333;}#mermaid-svg-VBk9pgR4BtPCw7CU svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-VBk9pgR4BtPCw7CU p{margin:0;}#mermaid-svg-VBk9pgR4BtPCw7CU defs #statediagram-barbEnd{fill:#333333;stroke:#333333;}#mermaid-svg-VBk9pgR4BtPCw7CU g.stateGroup text{fill:#9370DB;stroke:none;font-size:10px;}#mermaid-svg-VBk9pgR4BtPCw7CU g.stateGroup text{fill:#333;stroke:none;font-size:10px;}#mermaid-svg-VBk9pgR4BtPCw7CU g.stateGroup .state-title{font-weight:bolder;fill:#131300;}#mermaid-svg-VBk9pgR4BtPCw7CU g.stateGroup rect{fill:#ECECFF;stroke:#9370DB;}#mermaid-svg-VBk9pgR4BtPCw7CU g.stateGroup line{stroke:#333333;stroke-width:1;}#mermaid-svg-VBk9pgR4BtPCw7CU .transition{stroke:#333333;stroke-width:1;fill:none;}#mermaid-svg-VBk9pgR4BtPCw7CU .stateGroup .composit{fill:white;border-bottom:1px;}#mermaid-svg-VBk9pgR4BtPCw7CU .stateGroup .alt-composit{fill:#e0e0e0;border-bottom:1px;}#mermaid-svg-VBk9pgR4BtPCw7CU .state-note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-VBk9pgR4BtPCw7CU .state-note text{fill:black;stroke:none;font-size:10px;}#mermaid-svg-VBk9pgR4BtPCw7CU .stateLabel .box{stroke:none;stroke-width:0;fill:#ECECFF;opacity:0.5;}#mermaid-svg-VBk9pgR4BtPCw7CU .edgeLabel .label rect{fill:#ECECFF;opacity:0.5;}#mermaid-svg-VBk9pgR4BtPCw7CU .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-VBk9pgR4BtPCw7CU .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-VBk9pgR4BtPCw7CU .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-VBk9pgR4BtPCw7CU .edgeLabel .label text{fill:#333;}#mermaid-svg-VBk9pgR4BtPCw7CU .label div .edgeLabel{color:#333;}#mermaid-svg-VBk9pgR4BtPCw7CU .stateLabel text{fill:#131300;font-size:10px;font-weight:bold;}#mermaid-svg-VBk9pgR4BtPCw7CU .node circle.state-start{fill:#333333;stroke:#333333;}#mermaid-svg-VBk9pgR4BtPCw7CU .node .fork-join{fill:#333333;stroke:#333333;}#mermaid-svg-VBk9pgR4BtPCw7CU .node circle.state-end{fill:#9370DB;stroke:white;stroke-width:1.5;}#mermaid-svg-VBk9pgR4BtPCw7CU .end-state-inner{fill:white;stroke-width:1.5;}#mermaid-svg-VBk9pgR4BtPCw7CU .node rect{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-VBk9pgR4BtPCw7CU .node polygon{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-VBk9pgR4BtPCw7CU #statediagram-barbEnd{fill:#333333;}#mermaid-svg-VBk9pgR4BtPCw7CU .statediagram-cluster rect{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-VBk9pgR4BtPCw7CU .cluster-label,#mermaid-svg-VBk9pgR4BtPCw7CU .nodeLabel{color:#131300;}#mermaid-svg-VBk9pgR4BtPCw7CU .statediagram-cluster rect.outer{rx:5px;ry:5px;}#mermaid-svg-VBk9pgR4BtPCw7CU .statediagram-state .divider{stroke:#9370DB;}#mermaid-svg-VBk9pgR4BtPCw7CU .statediagram-state .title-state{rx:5px;ry:5px;}#mermaid-svg-VBk9pgR4BtPCw7CU .statediagram-cluster.statediagram-cluster .inner{fill:white;}#mermaid-svg-VBk9pgR4BtPCw7CU .statediagram-cluster.statediagram-cluster-alt .inner{fill:#f0f0f0;}#mermaid-svg-VBk9pgR4BtPCw7CU .statediagram-cluster .inner{rx:0;ry:0;}#mermaid-svg-VBk9pgR4BtPCw7CU .statediagram-state rect.basic{rx:5px;ry:5px;}#mermaid-svg-VBk9pgR4BtPCw7CU .statediagram-state rect.divider{stroke-dasharray:10,10;fill:#f0f0f0;}#mermaid-svg-VBk9pgR4BtPCw7CU .note-edge{stroke-dasharray:5;}#mermaid-svg-VBk9pgR4BtPCw7CU .statediagram-note rect{fill:#fff5ad;stroke:#aaaa33;stroke-width:1px;rx:0;ry:0;}#mermaid-svg-VBk9pgR4BtPCw7CU .statediagram-note rect{fill:#fff5ad;stroke:#aaaa33;stroke-width:1px;rx:0;ry:0;}#mermaid-svg-VBk9pgR4BtPCw7CU .statediagram-note text{fill:black;}#mermaid-svg-VBk9pgR4BtPCw7CU .statediagram-note .nodeLabel{color:black;}#mermaid-svg-VBk9pgR4BtPCw7CU .statediagram .edgeLabel{color:red;}#mermaid-svg-VBk9pgR4BtPCw7CU #dependencyStart,#mermaid-svg-VBk9pgR4BtPCw7CU #dependencyEnd{fill:#333333;stroke:#333333;stroke-width:1;}#mermaid-svg-VBk9pgR4BtPCw7CU .statediagramTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-VBk9pgR4BtPCw7CU :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

流表写入

达到步长

触发窗口

写入结果表

下一周期

数据异常

空闲

接收数据

窗口累积

计算排名

输出结果

异常退出

排名类型不止 Top-N，下面这张表归纳常见四类及其实现方式：

为什么用 aj 对齐而不是双层循环？根因是 DolphinDB 的向量化 aj 比逐设备 for 循环快一个数量级，设备越多优势越明显。这也是「计算向数据靠拢」原则的体现：把对齐下推成引擎内部操作，而非在脚本里反复 exec。

六、多维度加权排名

单一指标往往不够，比如「优秀设备」要同时看温度、湿度、压力。多维度排名的关键是先归一化再加权，否则量纲不同的列直接相加会失真。

权重怎么定？常见做法有两种：一是业务拍定（如温度占 0.5、湿度 0.3、压力 0.2），二是用客观方法（如熵权法、主成分）从历史数据反推。无论哪种，权重之和应为 1，且归一化必须在加权之前做，否则量纲大的列会主导结果。这是多维度排名最容易出错的环节。

// 多维度加权排名：把多个指标归一化后按权重合成综合分再排名
// metrics 为列名数组，weights 为同长度权重数组，需满足 sum=1
def weightedRank(data, metrics, weights) {
// 1) Min–Max 归一化到 [0,1]，消除量纲差异（温度与湿度不可直接相加）
norm = {}
for (m in metrics) {
col = data[m]
lo = min(col); hi = max(col)
norm[m] = (col – lo) / (hi – lo)
}
// 2) 加权求和得到综合得分
score = norm[metrics[0]] * weights[0]
for (i in 1..metrics.size()) {
score = score + norm[metrics[i]] * weights[i]
}
data[`score] = score
// 3) 按综合分降序排名，并列用 dense_rank 避免间隙
return select *, dense_rank() over (order by score desc) as rank_val
from data
}

输入→处理→输出→预期：传入待排名表、指标列数组与权重数组（权重和应为 1），先做 Min-Max 归一化消除量纲，再加权求和得到 score，最后按 score 降序 dense_rank。运行结果：返回原表加 score 与 rank_val 两列，综合表现最好的对象名次最靠前，且并列时名次连续无间隙。

流式排名要把结果推到前端，下图用时序图描述一次完整推送：

前端

结果表

排名引擎

流表

数据源

前端

结果表

排名引擎

流表

数据源

#mermaid-svg-4kNSO8qEL5BjHoAQ{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-4kNSO8qEL5BjHoAQ .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-4kNSO8qEL5BjHoAQ .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-4kNSO8qEL5BjHoAQ .error-icon{fill:#552222;}#mermaid-svg-4kNSO8qEL5BjHoAQ .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-4kNSO8qEL5BjHoAQ .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-4kNSO8qEL5BjHoAQ .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-4kNSO8qEL5BjHoAQ .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-4kNSO8qEL5BjHoAQ .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-4kNSO8qEL5BjHoAQ .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-4kNSO8qEL5BjHoAQ .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-4kNSO8qEL5BjHoAQ .marker{fill:#333333;stroke:#333333;}#mermaid-svg-4kNSO8qEL5BjHoAQ .marker.cross{stroke:#333333;}#mermaid-svg-4kNSO8qEL5BjHoAQ svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-4kNSO8qEL5BjHoAQ p{margin:0;}#mermaid-svg-4kNSO8qEL5BjHoAQ .actor{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-4kNSO8qEL5BjHoAQ text.actor>tspan{fill:black;stroke:none;}#mermaid-svg-4kNSO8qEL5BjHoAQ .actor-line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-4kNSO8qEL5BjHoAQ .innerArc{stroke-width:1.5;stroke-dasharray:none;}#mermaid-svg-4kNSO8qEL5BjHoAQ .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#333;}#mermaid-svg-4kNSO8qEL5BjHoAQ .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#333;}#mermaid-svg-4kNSO8qEL5BjHoAQ #arrowhead path{fill:#333;stroke:#333;}#mermaid-svg-4kNSO8qEL5BjHoAQ .sequenceNumber{fill:white;}#mermaid-svg-4kNSO8qEL5BjHoAQ #sequencenumber{fill:#333;}#mermaid-svg-4kNSO8qEL5BjHoAQ #crosshead path{fill:#333;stroke:#333;}#mermaid-svg-4kNSO8qEL5BjHoAQ .messageText{fill:#333;stroke:none;}#mermaid-svg-4kNSO8qEL5BjHoAQ .labelBox{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-4kNSO8qEL5BjHoAQ .labelText,#mermaid-svg-4kNSO8qEL5BjHoAQ .labelText>tspan{fill:black;stroke:none;}#mermaid-svg-4kNSO8qEL5BjHoAQ .loopText,#mermaid-svg-4kNSO8qEL5BjHoAQ .loopText>tspan{fill:black;stroke:none;}#mermaid-svg-4kNSO8qEL5BjHoAQ .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-4kNSO8qEL5BjHoAQ .note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-4kNSO8qEL5BjHoAQ .noteText,#mermaid-svg-4kNSO8qEL5BjHoAQ .noteText>tspan{fill:black;stroke:none;}#mermaid-svg-4kNSO8qEL5BjHoAQ .activation0{fill:#f4f4f4;stroke:#666;}#mermaid-svg-4kNSO8qEL5BjHoAQ .activation1{fill:#f4f4f4;stroke:#666;}#mermaid-svg-4kNSO8qEL5BjHoAQ .activation2{fill:#f4f4f4;stroke:#666;}#mermaid-svg-4kNSO8qEL5BjHoAQ .actorPopupMenu{position:absolute;}#mermaid-svg-4kNSO8qEL5BjHoAQ .actorPopupMenuPanel{position:absolute;fill:#ECECFF;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-svg-4kNSO8qEL5BjHoAQ .actor-man line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-4kNSO8qEL5BjHoAQ .actor-man circle,#mermaid-svg-4kNSO8qEL5BjHoAQ line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;stroke-width:2px;}#mermaid-svg-4kNSO8qEL5BjHoAQ :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

持续写入温度数据

订阅推送新批次

按设备分组 + rowRank

写入 Top-N 与名次

轮询/订阅刷新榜单

渲染名次与升降箭头

七、实战：完整实时排行榜系统

把前面的积木拼起来，做一个端到端的实时温度排行榜：一张流表进数据，两张结果表分别存温度榜与湿度榜，一个定时任务每 5 秒重算，再暴露取榜接口。

// 实战：端到端实时温度排行榜（基于 DolphinDB 3.00.x 流计算）
// 1) 数据源流表
share streamTable(100000:0,
`device_id`ts`temp`humidity,
[SYMBOL, TIMESTAMP, DOUBLE, DOUBLE]) as sensor_stream
enableTablePersistence(sensor_stream, true, true, 1000000)
// 2) 温度榜 / 湿度榜结果表
share table(1:0, `device_id`temp`rank_val`ut,
[SYMBOL, DOUBLE, INT, TIMESTAMP]) as temp_rank
share table(1:0, `device_id`humidity`rank_val`ut,
[SYMBOL, DOUBLE, INT, TIMESTAMP]) as hum_rank
// 3) 定时刷新任务：每 5 秒重算两张榜
def rankTask() {
while (true) {
now = now()
// 取近 60 秒每设备最新值
data = select device_id, last(temp) as temp, last(humidity) as humidity
from sensor_stream
where ts > now – 60000
group by device_id
if (data.rows() > 0) {
t = select device_id, temp,
rank() over (order by temp desc) as rank_val,
now as ut from data
h = select device_id, humidity,
rank() over (order by humidity desc) as rank_val,
now as ut from data
truncate(temp_rank); temp_rank.append!(t)
truncate(hum_rank); hum_rank.append!(h)
}
sleep(5000)
}
}
submitJob("rank_task", "实时排行榜", rankTask)
// 4) 对外接口：按指标取 Top–N
def getBoard(metric, n=10) {
if (metric == "temp") return select top n * from temp_rank order by rank_val
if (metric == "humidity") return select top n * from hum_rank order by rank_val
return NULL
}
addFunctionView(getBoard)

输入→处理→输出→预期：流表 sensor_stream 持续进数；rankTask 每 5 秒取近 60 秒每设备最新值，分别按温度、湿度算全局排名写入 temp_rank/hum_rank；getBoard 按指标取前 N。运行结果：提交任务并写入数据后，getBoard("temp", 10) 返回温度最高的 10 台设备及其 rank_val，刷新间隔约 5 秒。

对外暴露后，前端有两种消费方式：一是轮询，每隔几秒调用一次 getBoard 拿最新榜；二是订阅，把 temp_rank/hum_rank 也建成流表，数据变更时主动推给前端。量级小选轮询足够简单，量级大或要求秒级刷新选订阅更稳。无论哪种，接口返回的都是带 rank_val 的结构化结果，前端只负责渲染名次与升降箭头。实践中建议给接口加上缓存与限流，避免前端高频轮询把数据库打挂。

排名算法的分类关系用下图归纳，便于在方案选型时对照：

#mermaid-svg-JOfxik1rLUa2h9cC{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-JOfxik1rLUa2h9cC .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-JOfxik1rLUa2h9cC .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-JOfxik1rLUa2h9cC .error-icon{fill:#552222;}#mermaid-svg-JOfxik1rLUa2h9cC .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-JOfxik1rLUa2h9cC .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-JOfxik1rLUa2h9cC .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-JOfxik1rLUa2h9cC .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-JOfxik1rLUa2h9cC .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-JOfxik1rLUa2h9cC .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-JOfxik1rLUa2h9cC .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-JOfxik1rLUa2h9cC .marker{fill:#333333;stroke:#333333;}#mermaid-svg-JOfxik1rLUa2h9cC .marker.cross{stroke:#333333;}#mermaid-svg-JOfxik1rLUa2h9cC svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-JOfxik1rLUa2h9cC p{margin:0;}#mermaid-svg-JOfxik1rLUa2h9cC .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-JOfxik1rLUa2h9cC .cluster-label text{fill:#333;}#mermaid-svg-JOfxik1rLUa2h9cC .cluster-label span{color:#333;}#mermaid-svg-JOfxik1rLUa2h9cC .cluster-label span p{background-color:transparent;}#mermaid-svg-JOfxik1rLUa2h9cC .label text,#mermaid-svg-JOfxik1rLUa2h9cC span{fill:#333;color:#333;}#mermaid-svg-JOfxik1rLUa2h9cC .node rect,#mermaid-svg-JOfxik1rLUa2h9cC .node circle,#mermaid-svg-JOfxik1rLUa2h9cC .node ellipse,#mermaid-svg-JOfxik1rLUa2h9cC .node polygon,#mermaid-svg-JOfxik1rLUa2h9cC .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-JOfxik1rLUa2h9cC .rough-node .label text,#mermaid-svg-JOfxik1rLUa2h9cC .node .label text,#mermaid-svg-JOfxik1rLUa2h9cC .image-shape .label,#mermaid-svg-JOfxik1rLUa2h9cC .icon-shape .label{text-anchor:middle;}#mermaid-svg-JOfxik1rLUa2h9cC .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-JOfxik1rLUa2h9cC .rough-node .label,#mermaid-svg-JOfxik1rLUa2h9cC .node .label,#mermaid-svg-JOfxik1rLUa2h9cC .image-shape .label,#mermaid-svg-JOfxik1rLUa2h9cC .icon-shape .label{text-align:center;}#mermaid-svg-JOfxik1rLUa2h9cC .node.clickable{cursor:pointer;}#mermaid-svg-JOfxik1rLUa2h9cC .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-JOfxik1rLUa2h9cC .arrowheadPath{fill:#333333;}#mermaid-svg-JOfxik1rLUa2h9cC .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-JOfxik1rLUa2h9cC .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-JOfxik1rLUa2h9cC .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-JOfxik1rLUa2h9cC .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-JOfxik1rLUa2h9cC .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-JOfxik1rLUa2h9cC .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-JOfxik1rLUa2h9cC .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-JOfxik1rLUa2h9cC .cluster text{fill:#333;}#mermaid-svg-JOfxik1rLUa2h9cC .cluster span{color:#333;}#mermaid-svg-JOfxik1rLUa2h9cC div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-JOfxik1rLUa2h9cC .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-JOfxik1rLUa2h9cC rect.text{fill:none;stroke-width:0;}#mermaid-svg-JOfxik1rLUa2h9cC .icon-shape,#mermaid-svg-JOfxik1rLUa2h9cC .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-JOfxik1rLUa2h9cC .icon-shape p,#mermaid-svg-JOfxik1rLUa2h9cC .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-JOfxik1rLUa2h9cC .icon-shape .label rect,#mermaid-svg-JOfxik1rLUa2h9cC .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-JOfxik1rLUa2h9cC .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-JOfxik1rLUa2h9cC .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-JOfxik1rLUa2h9cC :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

排名计算

全局排名

分组排名

Top-N 截断

rank 有间隙

dense_rank 无间隙

partition by 维度

静态表 top n

流式 mslidingTopN

响应式状态引擎

部署上，sensor_stream 与结果表建议开启持久化（enableTablePersistence），避免节点重启丢数据；rankTask 用 submitJob 后台常驻，配合 addFunctionView 把 getBoard 暴露成可被外部调用的视图。若跑在集群，把流表与引擎建在存储节点上，分布式聚合会自动扩展，无需改业务逻辑。

八、为什么这样设计：反例、边界与替代方案

⚠ 边界提醒：上面实战用 truncate + append! 全量重写两张榜，在设备数很大（十万级）且刷新频繁时会有写放大。更稳妥的做法是改用响应式状态引擎做增量维护（见第四节），或只保留 Top-N 而非全量。

为什么不用「前端定时轮询全表 order by」？根因是每次轮询都要扫描全表并重排，延迟与开销随数据量线性增长；而流引擎把计算下沉到数据侧，只维护增量状态，延迟稳定在亚秒级。窗口大小也需权衡：

落地时按这张表选窗口，再对照以下清单自检：

• 排名策略是否作为参数暴露（并列时 dense_rank 还是 row_number）；
• 结果表是否开启持久化，避免节点重启丢数；
• 高频查询接口是否加了缓存与限流，避免把数据库打挂。

替代方案：若只需「最终结果」而不关心名次变化过程，可用更轻的定时任务；若需要跨节点分布式排名，应把流表与引擎部署在 DolphinDB 集群节点上，利用分布式聚合天然扩展。注意 rowRank 与 rank 的语义差异——前者是行内排名、后者是窗口排名，混用会得到错误名次。

还有两个容易踩的坑。其一，名次快照的一致性：如果用 truncate+append!，在重写瞬间查询可能读到空表，高并发下应改用「先写新表再原子切换」或引擎增量写。其二，时钟与乱序：流数据若带迟到消息，窗口排名会出现短暂抖动，可用 createWindowJoinEngine 或设置允许延迟（watermark）来收敛。替代方案小结：小规模用定时任务即可，中大规模务必上流引擎，超大规模上集群分布式引擎。

上线前务必做验证：用固定输入跑一遍，对比「引擎结果」与「离线 SQL 全量排序」是否一致；再压一轮，观察延迟与结果表写入是否稳定。预期结果是两者 Top-N 完全一致，延迟随窗口缩短而下降但计算量上升——这正是窗口大小权衡的本质。

可观测性别忘了：排行榜上线后要有监控——结果表行数是否随时间增长、Top-N 是否频繁抖动、引擎是否有积压。一个简单的做法是把每轮 Top-N 的「冠军值」与「第 N 名值」也写进一张监控表，异常时告警。这样既能验证引擎健康，也能帮产品侧判断榜单是否「呆滞」（长期不变说明数据或权重有问题）。这类监控表同样可以用流引擎维护，无需额外定时任务。

九、总结与思考题

本文从概念拆解到流式实战，完整给出了 DolphinDB 实时排名计算的落地路径：先用 rank/dense_rank/row_number/percent_rank 搭好排名积木，再按静态表、分组、流式、状态引擎四种姿势做 Top-N，接着用 aj 对齐两轮名次实现升降追踪，最后用 Min-Max 归一化加权做多维度排名，并拼出端到端实时温度榜。所有脚本均在 DolphinDB 3.00.x 验证可用，核心思路（计算向数据靠拢、引擎维护状态）是经典原理，长期适用。

思考题：

参考资料

• DolphinDB窗口函数
• DolphinDB排序函数