[TSDB/物联网/本体/车辆] 基于 TD-Engine 的时序方案-行业分析

0 序

1 CASE 智能网联汽车:车企的车联网云平台-车辆信号的时序数据存储与查询

本节仅讨论思路,未项目实测。

需求描述

  • 需求描述
如果做车企的车联网云平台-车辆信号的时序数据存储与查询,可以如何设计?
1、多品牌-多车系-多车型-多车辆[5-100W级]-多域控制器/零部件-多传感器信号[单车型合计:500-5000个];
即:每个车型有相对固定的数百、数千个传感器信号时序数据。
2、采集频率:每秒采集。
3、数据的消费上,需支持:
1)单车多个信号的时序数据查询
2)单车的降采样的时序数据查询
3)单车的信号聚合分析;
3)单车的多个信号最新值的查询;

此时,如何进行表模型的选择、设计?集群与服务器的资源规划?有哪些利弊?

方案总览 : 一车一表 × 按【车型-域】拆分为【超级表】(官方推荐"一车一表")

1、先算账(关键约束)

规模 每秒写入 日增(3副本) 年增
5万车×500信号×1Hz 2500万 点/s ~2 TB ~700 TB
20万车×1000信号×1Hz 2亿 点/s ~150 TB PB级
100万车×2000信号×1Hz 20亿 点/s 物理不可行 —

结论:全信号 1Hz 采集频次在 20万车以上就不可行,必须先做【信号分级采集】(核心信号 1Hz、扩展信号低频/事件触发、高频信号独立分表)+ 降采样预聚合。

2、表模型:一车一表 × 按域拆分(官方推荐"一车一表")

  • 硬限制:单表 ≤ 4096 列、单 vnode ≤ 100 万表 → 500~5000 信号必须按【域控制器】拆分成多张【超级表】(动力/底盘/车身/三电/座舱/智驾)。

补充:非虚拟超级表列 + 标签合计 ≤ 4096;虚拟超级表数据列可到 32767。关键还有2点新信息很重要 ——虚拟表(Virtual Table)机制让 "【单列模型写入 + 按需建模】" 也成为可能。

  • 【超级表】按"【车型族 × 域】"建:【同一车型族】共享列集,避免【信号并集表】过宽稀疏;每车在每个【域】建一张子表。

  • 【标签】:brand/series/model/region/版本/VIN,支撑跨车、按车型维度的【聚合分析】。

  • 四类查询映射:

    • 单车多信号:SELECT ts, motor_speed, soc FROM ... WHERE tbname='VIN_pt' AND ts BETWEEN...(单表扫描)
    • 降采样:INTERVAL(1m) 窗口聚合
    • 聚合分析:超级表 + 标签过滤 + 窗口函数
    • 最新值:SELECT LAST(*)——TDengine 每表缓存最后一条,O(1) 级,直接支撑整车实时大屏

3、集群规划(写入按单节点 ~100万点/秒,留30%余量)

  • 小(5万车):3~5 台 16核/64GB/SSD
  • 中(20万车):15~25 台 32核/128GB + 冷热分层
  • 大(100万车):Kafka 削峰 + 批量写入(≥200条/请求)+ 预聚合表,50+ 台起步
  • 生产 3 副本;分区分 1~10 天;KEEP 按合规 ≥1 年;万兆内网;3.0 多级存储降 TCO

4、方案利弊对比(结论)

方案 结论
一车一表×按域拆(本设计) 推荐:单车查询最快、最新值缓存天然按车、写并发分散
一信号一超级表 子表数=车×信号(1亿~50亿),远超上限,不可行
一车一宽表全信号 5000列>4096上限,稀疏浪费,不可行
信号并集共用超级表 过宽稀疏,不推荐

一、需求与规模测算(先算账)

1.0 设计约束

设计日期:2026-10-13 | 面向:多品牌-多车系-多车型-多车辆(5万~100万级)、单车型 500~5000 信号、1Hz 采集、四类查询场景
关键官方限制(已查证):单表最多 4096 列;单 vnode 最多 100 万张表;副本仅支持 1 或 3;【单节点】写入约 100 万点/秒(批量写入,官方容量规划口径);TDengine 官方车联网推荐"一车一表"模型。

1.1 场景参数

参数 值
车辆数 V 5 万 ~ 100 万
单车型信号数 S 500 ~ 5000
采集频率 1Hz(每秒 1 点/信号)
单点大小 ts(8B) + 值(4~8B) ≈ 12~16B,压缩后约 2~3B
留存 按合规与业务(建议 ≥1 年,冷数据可再压缩/迁移)

1.2 写入与存储量级(全信号 1Hz 的理论值)

规模档位 每秒写入点 每日写入点 每日新增(压缩后 ~3B) 年度新增(1 副本)
5 万车 × 500 信号 2500 万点/s 2160 亿点 ~648 GB ~237 TB
20 万车 × 1000 信号 2 亿点/s 17.28 万亿点 ~52 TB ~19 PB
100 万车 × 2000 信号 20 亿点/s 172.8 万亿点 ~518 TB ~189 PB

结论(重要):全信号 1Hz 在 20 万车以上即进入 PB/年 级,100 万车全信号 1Hz 在物理上不可行。

必须做信号分级采集(见第五节),实际规划按"核心信号 1Hz + 扩展信号低频/事件触发 + 高频信号独立分表"测算。


二、表模型设计(核心)

2.1 总原则:官方"一车一表" —— 可按车型拆分(推荐)

  • TDengine 官方车联网模型为 "一车一表":每辆车一张子表,写互不争抢;超级表承载"同类数据"。
  • 拆分维度有两个:按"域"拆 或 按"车型"拆。 车型非常稳定(你判断正确),因此按车型拆分是更贴合业务的粒度:一个车型 = 一套固定的信号集合 = 一张(或多张)超级表,同一车型下所有车辆共享同一列定义。
  • 硬约束:非虚拟超级表列数 + 标签数 ≤ 4096(标签最多 128 个)。因此:
    • 单车型信号 ≤ 约 3900 列 → 一个车型一张超级表(一车一表,最优);
    • 单车型信号 > 约 3900 列(如 5000 信号)→ 该车型内部再按域/频率拆成 2~3 张表(仍按车型命名,如 veh_<model>_a/b/c)。
  • 虚拟表(Virtual Table,VTable)补充:TDengine 虚拟表数据列上限 32767,可跨表/跨库按时间戳对齐拼接。若希望"物理上一车多表、逻辑上一车一张视图",可用虚拟超级表把同一辆车的多张域表合成一张逻辑宽表(先写入后建模),兼顾写入效率与查询易用。

2.2 表模型结构(按车型拆分)

flowchart TB subgraph DB["数据库 vehicle_iot"] subgraph ST1["超级表: veh_ev620(车型 EV620,信号集固定)"] T1["子表: <VIN> 车辆A"] T2["子表: <VIN> 车辆B"] TN["...同一车型所有车辆"] end subgraph ST2["超级表: veh_ev750(车型 EV750)"] C1["子表: <VIN>"] C2["子表: <VIN>"] end subgraph ST3["超级表: veh_hs5(车型 HS5,若信号>3900列<br/>再拆 veh_hs5_a / veh_hs5_b)"] B1["子表: <VIN>"] end end VIN["标签: brand / series / model / region<br/>hw_ver / sw_ver / vin / 下线日期"] ST1 --> VIN ST2 --> VIN ST3 --> VIN

2.2b 按车型拆 vs 按域拆(决策表)

维度 按车型拆(一车型一表)【推荐】 按域拆(一域一表)
建模粒度 车型稳定,列定义长期不变 域信号跨车型差异大,需按车型族再细分
单车查询 最优:一张子表取全部信号 需跨多张域表多次查询/应用侧合并
最新值 每车一条缓存,整车实时一次取全 每域各一条缓存,需合并
跨车聚合 同车型直接聚合;跨车型因列集不同需按列名分别处理 域结构跨车型较统一,跨车聚合略易
写入并发 一车一表无锁追加 一车多表,同为无锁追加
适用 推荐:车型数适中、单车型信号≤3900 单车型信号>4096 时的补充拆分手段
虚拟表 可再合成整车逻辑宽表 同左

2.3 DDL 示例

CREATE DATABASE vehicle_iot KEEP 3650 DURATION 1 BUFFER 256 WAL_LEVEL 2;

USE vehicle_iot;

-- 按“车型族 + 域”建超级表(列 = 该域信号,控制每表列数)
CREATE STABLE veh_ev620_powertrain (
  ts TIMESTAMP,
  motor_speed   FLOAT,   -- 电机转速
  motor_torque  FLOAT,   -- 电机扭矩
  accelerator   FLOAT,   -- 加速踏板开度
  soc           FLOAT,   -- 电池 SOC
  dc_voltage    FLOAT,
  dc_current    FLOAT
  -- ... 该域 200~800 列
) TAGS (
  brand      BINARY(32),
  series     BINARY(32),
  model      BINARY(32),
  region     BINARY(16),
  hw_version BINARY(32),
  sw_version BINARY(32),
  vin        BINARY(32)
);

CREATE STABLE veh_ev620_chassis (
  ts TIMESTAMP,
  wheel_speed_fl FLOAT,
  wheel_speed_fr FLOAT,
  brake_pressure FLOAT
  -- ... 该域 100~500 列
) TAGS (
  brand BINARY(32), series BINARY(32), model BINARY(32),
  region BINARY(16), hw_version BINARY(32), sw_version BINARY(32), vin BINARY(32)
);

-- 每辆车在每个域建一张子表
CREATE TABLE LFV3A123456_pow USING veh_ev620_powertrain
  TAGS ('BYD','Han','EV620','Chengdu','HW1.0','SW1.2.3','LFV3A123456');
CREATE TABLE LFV3A123456_ch  USING veh_ev620_chassis
  TAGS ('BYD','Han','EV620','Chengdu','HW1.0','SW1.2.3','LFV3A123456');

2.4 为什么这样设计

设计点 理由
一车一表(每域一张) 写并发天然分散、互不争锁;单车查询 = 单表范围扫描,最快
按域拆超级表 突破 4096 列上限;列式存储下同域信号聚簇,压缩与扫描最优
按车型族定列集 避免全车型信号并集导致列稀疏、表过宽;标签存品牌/车型便于跨车聚合
标签设计 支撑"品牌/车系/车型/区域维度"的跨车聚合分析,且标签独立于时序数据存储
高频信号独立分表 10~100Hz 信号(IMU、雷达点云特征等)写入量大,独立表避免拖慢低频表

三、四类查询需求 → SQL 映射

需求 SQL 思路 说明
① 单车多信号时序查询 SELECT ts, motor_speed, motor_torque, soc FROM veh_ev620_powertrain WHERE tbname='LFV3A123456_pow' AND ts BETWEEN '...' AND '...' 单子表内取多列,走时间主键索引,毫秒级
② 单车降采样查询 SELECT _wstart, AVG(motor_speed), MAX(motor_torque) FROM veh_ev620_powertrain WHERE tbname='LFV3A123456_pow' AND ts BETWEEN ... INTERVAL(1m) 窗口聚合;长期分析可配合流式计算写预聚合表
③ 单车信号聚合分析 SELECT AVG(motor_speed), MAX(motor_torque), COUNT(*) FROM veh_ev620_powertrain WHERE tbname='LFV3A123456_pow' AND ts ...;跨车维度:... WHERE brand='BYD' AND region='Chengdu' ... INTERVAL(1m) 单表聚合快;跨车聚合走超级表+标签过滤
④ 单车多信号最新值 SELECT LAST(*) FROM veh_ev620_powertrain WHERE tbname='LFV3A123456_pow' TDengine 每表缓存最后一条记录(last row cache),最新值 O(1) 级,可支撑整车实时状态大屏

四、集群与服务器资源规划

4.1 规模换算公式(供按实际参数代入)

  • 每秒写入点 = V × S × 采集频率
  • 存储日增 ≈ 每秒写入点 × 86400 × 单点压缩后字节(≈2~3B) × 副本数
  • 写入节点需求 ≈ 每秒写入点 ÷ (单节点 100 万点/秒,批量写入、留 30% 余量)

4.2 三档规划建议(按"核心信号 1Hz"口径)

档位 规模 每日新增(3 副本) 建议集群
小(PoC/5万车) ~2500 万点/s ~2 TB 3~5 台 dnode:16 核/64GB/2×SSD 1TB,万兆网
中(20万车) ~2 亿点/s ~150 TB 15~25 台 dnode:32 核/128GB/SSD 2~4TB,万兆网;冷热分层
大(100万车) ≥20 亿点/s PB 级/日 必须先信号分级+降采样预聚合,写入层加 Kafka/批量写入缓冲,50+ 台起步

4.3 关键配置项

项 建议 依据
副本数 3(生产高可用) 官方仅支持 1/3
分片(vgroup) 按子表量自动分;600 万子表至少 6+ vgroup 单 vnode 上限 100 万表
分区 DURATION 1~10 天 分区内时间索引、过期删除按文件组
KEEP 按合规留存(≥1 年) 过期数据按分区自动清理
内存 单节点 64~256GB;600 万表元数据约数 GB 级 表元数据常驻内存
网络 万兆内网 高写入吞吐
冷热分层 3.0 支持多级存储:热数据 SSD、历史数据冷介质 降 TCO
写入链路 T-Box → 网关 → Kafka → 批量写入器(JDBC/REST,每次 ≥200 条/请求) 官方:批量越大写入效率越高

五、落地建议与利弊分析

5.1 必做的三项配套(否则规模不可行)

  1. 信号分级采集:核心信号(车速/扭矩/SOC/档位等 200500 个)1Hz;扩展信号 0.1~0.2Hz 或事件触发;高频信号(≥10Hz)单独分表。
  2. 降采样预聚合:用 TDengine 流式计算(或定时任务)把 1Hz 明细聚合为 1m/1h 聚合表,长期趋势查询走聚合表,明细按合规留存。
  3. 保留策略 + 冷热分层:热数据 SSD(近期),历史数据迁冷介质/对象存储,控制 TCO。

5.2 表模型方案对比(利弊)

方案 优点 缺点 结论
A. 一车一表 × 按域拆多超级表(本设计) 单车查询最快;最新值缓存天然按车;写并发分散;列数可控 跨域查询需多次查/应用侧关联;子表量 = 车×域(600 万级),元数据占内存 推荐
B. 一信号一超级表(每信号一张) 单信号跨车聚合直接 子表数 = 车×信号(1 亿~50 亿),远超 100 万/vnode 上限,不可行 不采用
C. 一车一宽表(全部信号一列集) 单车全信号一次查 5000 列 > 4096 上限;信号稀疏浪费;列式压缩率下降 不可行
D. 按"信号并集"全车型共用超级表 超级表数量少 列 = 全部车型信号并集,过宽且稀疏;车型差异大时查询效率差 不推荐

5.3 集群与部署的利弊

决策 利 弊
3 副本 高可用、故障自动切换 存储 ×3、写入放大;小规模可先 1 副本
多级存储/冷热分层 大幅降 TCO 冷数据查询延迟升高;需设计归档策略
存算分离(3.0 云原生) 计算/存储独立扩缩容、K8s 部署 运维复杂度上升
写入经 Kafka 缓冲 削峰填谷、解耦车端突发 增加链路与端到端延迟;需保障 Kafka 高可用
单节点大规格 vs 多节点小规格 大规格:表元数据集中、运维简单 小规格集群:弹性好、故障域小但节点多、运维重

5.4 风险与提示

  • 元数据内存:600 万子表量级,表元数据常驻内存,需给足内存并关注扩容。
  • 写入突发:车端定时批量上报会产生秒级尖峰,Kafka + 批量写入(≥200 条/请求)是关键。
  • 多车型扩展:新车型 = 新超级表(或新车型族表),需规范化命名与建表自动化(按车型配置生成 DDL)。
  • 先 PoC 后扩容:用 taosBenchmark 按目标规模压测(表数、信号列数、批量大小),验证后再定节点数。

六、补充思路:以 "车型" 作为超级表拆分维度(每车型一张超级表、每车一张子表,不再按域拆)

  • 以"车型"作为超级表拆分维度(每车型一张超级表、每车一张子表,不再按域拆)。

判断依据: "车型稳定 → 信号集稳定 → 表结构稳定"是对的,这正好命中 TDengine schema 维护的关键痛点。

结论先行: 也可行,且在这种场景下多数情况可能优于"按域拆"。

flowchart TB subgraph DB["数据库 vehicle_iot(按车型建超级表)"] subgraph M1["超级表: veh_ev620(车型A)列=该车型全部信号 500~4000列"] V1["子表: <VIN>"] V2["子表: <VIN>"] V3["...每车一张"] end subgraph M2["超级表: veh_han_dmi(车型B)列=该车型全部信号"] V4["子表: <VIN>"] V5["子表: <VIN>"] end subgraph M3["超级表: veh_xxx(车型C)"] V6["子表: <VIN>"] end end M1 -->|tags: brand/series/region/版本/vin| VIN["新车型=新建超级表<br/>存量表零改动"]
  • DDL 示意:
CREATE STABLE veh_ev620 (
  ts TIMESTAMP,
  motor_speed FLOAT, motor_torque FLOAT, soc FLOAT, ... -- 该车型全部信号(≤4096列)
) TAGS (brand BINARY(32), series BINARY(32), model BINARY(32), region BINARY(16), sw_version BINARY(32), vin BINARY(32));


CREATE TABLE LFV3A123456 USING veh_ev620 TAGS ('BYD','Han','EV620','Chengdu','SW1.2.3','LFV3A123456');

为什么这个方案也更贴合这种场景

考量点 按车型拆(你提的方案) 按域拆(原文档方案)
schema 稳定性 极好:车型稳定→信号集固定→建表后几乎不 ALTER;新车型=新建超级表,存量零改动 中:域内信号仍可能随软硬件版本增减
单车多信号查询 最优:一张表一次查询取全部信号,无跨表 需跨多张域表查询/应用侧合并
单车最新值 最优:LAST(*) 一次取全车最新信号 需查多张域表
同车型跨车聚合 最优:单超级表直接聚合全车型车辆 需多次聚合后合并
跨车型对比分析 较弱:跨超级表聚合需应用层合并 若域定义跨车型统一,可直接跨车型聚合
子表数量 = 车辆数(5万~100万张),更少、更省元数据 = 车辆×域(30万~600万张)
高频信号隔离 弱:高频列与低频列同表(列式存储下影响可控) 强:高频信号独立域表
写入 一次写入覆盖整车信号 一车多域需多条写入

须注意的边界x2

① 单表 4096 列上限:单车型 500~5000 信号,其中 信号 ≤4096 的车型可直接一车一表;超 4096 的车型才需要二次兜底拆分(按域或按"高频/低频信号组"拆成 2 张表)。

量程上限 5000 仅少数豪华车型会触及,可作特例处理。

② 100 万车 = 100 万子表:接近单 vnode 上限(100 万表),需分散到多个 vgroup/dnode(TDengine 3.x 表数仅受节点资源限制,可水平扩展),元数据内存按数 GB 级预留。5万~50万车规模完全无压力。

建议的最终形态(混合策略)

以"按车型"为主,信号超 4096 的车型退回"车型×信号分组"。即:

  • 常规车型(≤4096 信号):一车型一超级表、一车一表 —— 覆盖 90%+ 车型
  • 超宽车型(>4096 信号):按信号分组拆 2~3 张超级表
  • 跨车型对比需求单独建"通用信号超级表"(车速/里程/SOC 等全车型共有信号)承载

这样既吃到"车型稳定"的最大红利,又规避列数与超宽表的边界风险。之前的文档我不改动,如需我可以基于此方案另出一份修订版设计文档。

扩展问题: 按 ①某车型的完整 DDL + 写入/查询示例脚本;②基于 taosBenchmark 的目标规模压测配置;③与 Kafka 接入的批量写入方案设计。

参考文献

场景下的横向对比: InfluxDB / OpenGemini / Apache lotDB

场景基线:多品牌/多车系/多车型,一车一表、按车型建立超级表,单车型信号5005000个、1Hz采集;查询需求:单车多信号时序、单车降采样、单车聚合、单车最新值查询;规模5万100w车辆。
推荐系数:满分5分

对比维度 TDengine InfluxDB 3.0 OpenGemini Apache IoTDB
推荐系数 ★★★★★(4.8/5) ★★★☆☆(3.0/5) ★★★★☆(4.0/5) ★★★★☆(4.1/5)
核心数据模型 超级表+子表,原生支持一车一表;超级表按车型定义,子表=单VIN车辆;单表上限4096列;标签独立存储,天然适配静态资产维度(品牌/车系/车型) Measurement+Tag/Field扁平模型;不支持一车一表原生语义,主流建模是:measurement=车型,tag=VIN;单measurement字段上限1000列;高时间线基数(VIN×信号)会膨胀元数据 兼容InfluxLine协议,Measurement+Tag模型;支持shardkey指定VIN做分区;同样是tag=VIN的扁平模型;无原生“一车一表”语义 树形分层模型(设备/传感器路径),root.品牌.车系.车型.VIN.信号;天然资产树;无超级表,不支持一车一宽表,一个信号一条时间序列
单车多信号时序查询 极佳。单车全部信号在一张子表,一次SQL读取多列;LAST(*)内置缓存,单车最新值O(1);原生INTERVAL降采样窗口函数 一般。同一VIN下多个信号是独立field,读取多field尚可;无原生按设备缓存最新值;复杂降采样依赖Flux/SQL,查询fanout大 良好。VIN作为shardkey,同车数据落在同一分片;多field读取性能优于InfluxDB;内置降采样、连续查询;无单表缓存最新值 良好。单车多个信号是多条独立时间序列,查询需要读取多条series并应用层合并;内置last_value函数,无单设备全局缓存
写入性能&压缩 极高,C内核;列式时序专用压缩;写入吞吐高、磁盘占用低;支持批量写入、WAL;车联网大量落地案例 中等,Go/Rust;压缩一般;高基数VIN场景元数据压力大;集群版非完全开源 高,云原生MPP架构;列式压缩;千万级写入能力;华为云背景,国内运维友好 高,Java+TsFile;面向IoT优化压缩;乱序数据处理能力强;支持预聚合
许可协议 社区版AGPLv3;5000tags以内IDMP+TDgpt永久免费,超出需商业授权 InfluxDB3 Core:MIT宽松;企业集群版商业付费 Apache2.0完全开源 Apache2.0完全开源
车联网资产/本体建模能力 强。IDMP工业本体模块,资产层级(品牌/车系/车型/VIN)、关系建模;支持标签+超级表绑定;可绑定时序测点;自带TDgpt时序AI(预测/异常) 弱。仅标签扁平维度,无原生资产树、本体语义,本体需要外部系统维护 中。tag+shardkey支持资产维度分区;无原生本体模块,本体需外部构建 中强。原生树形路径天然匹配资产层级;适合OPC-UA;但缺少本体三元组关系能力,本体需要外部工具(Protege等)集成
生态集成 标准SQL;内置流计算、数据订阅;IDMP打通资产语义;大数据生态偏弱 生态最成熟,Grafana、Prometheus;Flux分析;海外云原生生态强;大数据批处理弱 兼容Influx生态;国内云原生友好;流计算、异常检测内置;第三方生态少于InfluxDB Hadoop/Spark/Flink深度原生集成;TsFile文件可离线分析;大数据数仓链路最强;工业OPC-UA生态好
核心短板 AGPL协议商用有传染风险;单表最大4096列,>4096信号车型需要额外拆分;大数据批处理生态弱 不适合一车一宽表建模,字段上限1000;高基数VIN场景元数据压力大;集群企业版闭源;单车最新值查询性能弱 没有原生一车一表模型,需要基于tag+shardkey做业务层模拟;社区相对TDengine/IoTDB更小;车联网大规模生产案例偏少 不能采用“一车一张宽表”方案;单车多信号查询必须多series合并;Java栈资源开销高于C;不适合本次选定的【一车一表按车型拆分】建模方案
推荐原因 最贴合你当前选定的【一车一表,按车型建超级表】设计。标准SQL、单车查询、单车LAST(*)最新值、时间窗口降采样全部原生支持;自带IDMP工业本体模块,刚好匹配车企资产语义建模;国内大量头部车联网落地;压缩/写入性能优异;5000测点内IDMP+TDgpt免费试用评估 适合中小规模监控类指标;不推荐在本车联网方案主力存储,模型和字段上限限制,无法高效落地“一车一宽表”,VIN高基数场景成本偏高 国内开源云原生TSDB;兼容Influx生态,写入性能优秀;适合如果团队熟悉Influx体系、希望Apache2.0协议;但无法原生支持一车一表超级表,模型需要业务层封装 适合需要深度对接大数据Hadoop/Spark、OPC-UA、资产树场景;但不适合你选定的一车一宽表模型,信号必须拆成独立时间序列,单车多信号查询成本上升
  • 选型小结
  1. 如果确定采用 一车一表、按车型超级表 的模型,首选 TDengine,模型原生匹配,4类查询(单车时序/降采样/聚合/最新值)全部最优;IDMP本体能力是加分项;唯一风险AGPL许可与>4096信号车型的列上限。
  2. Apache IoTDB:大数据离线分析、OPC-UA、资产树场景首选,但不适合本次“一车一宽表”的建模思路,会改变表模型设计。
  3. OpenGemini:备选,适合团队熟悉Influx协议、需要Apache2.0许可;但一车一表需要业务层模拟,缺少原生超级表语义。
  4. InfluxDB 3.0:不推荐作为主力存储,扁平tag模型+字段上限约束,高基数VIN场景TCO高。

2 CASE 本体建模: 图数据库TypeDB(知识图谱) + 时序数据库TD-Engine 与 本体论时序建模的融合方案

假定另有图数据库 TypeDB 存储图谱数据等,TD-Engine 与 本体建模的融合解决方案。

编写日期:2026-10-13
前提:本体/图谱由 TypeDB 承载(强类型图数据库:Entity/Attribute/Relation、n-ary 关系、子类型、推理),TDengine 承载时序数据。目标平台类似 Palantir Foundry:统一 Ontology(对象类型+属性+关联)+ 时间序列属性(TSP)+ 应用层。
本节将明确回答2种本体时序建模方式:①对象类型上直接加 TSP(时间序列属性)、②新增 Sensor 对象类型。


一、核心结论

  1. TDengine 与本体建模的"贴合度"要分两层看:

    • 作为时序物理层(本体语义归 TypeDB),贴合度高——超级表≈对象类型、子表≈对象实例、标签≈对象元数据,天然支撑"对象↔时序序列"映射;
    • 作为本体承载层(替代 TypeDB 做语义建模),贴合度低——官方工业本体(IDMP)是"树+网络"自有体系,无 OWL/RDF/推理,不适合通用 Ontology 平台。
    • 正确定位:TypeDB 管"是什么/有什么关系",TDengine 管"随时间怎么变",两者通过"序列标识(Series ID)桥"衔接,即 Foundry 的 TSP 模式。
  2. Foundry 官方文档明确给出2种 TSP 配置,与本问题完全对应:

    • 模式①(对象直挂 TSP):所有对象都有该 TSP 数据时用(如所有 Machine 设备都有 Temperature传感器);
    • 模式②(Sensor 对象类型):对象配置差异大、避免大量空 TSP 时用(如 Equipment 中 Pump 有 Pressure、Reactor 有 Temperature,用 Sensor 承载并链接根对象)。
  3. 2种模式在 TDengine 上的物理形态都可收敛为:

"一序列(Series)一子表(窄表)或一对象(Object)一子表多列(宽表)"(见下文映射)


二、总体架构(分工与衔接)

flowchart TB subgraph ONT["本体层 TypeDB(强类型图)"] OT["对象类型 ObjectType<br/>entity/attribute/relation/子类型/推理"] INST["对象实例(entity)"] TSPD["TSP 元数据:属性→序列ID映射"] end subgraph BRIDGE["元数据桥(自研同步器)"] B1["Schema 同步:对象类型↔超级表<br/>对象实例↔子表"] B2["Series ID 注册表<br/>(TypeDB 属性 ↔ TDengine 表/标签)"] B3["双向查询翻译:<br/>TypeQL 时序引用 → TDengine SQL"] end subgraph TS["时序层 TDengine(物理存储)"] ST["超级表(按对象类型/Sensor 类型)"] SUB["子表(每对象/每传感器一张)"] TAG["标签(对象ID/单位/插值/链接)"] end subgraph APP["应用层(Quiver/Workshop 类比)"] A1["统一对象视图(属性+TSP 曲线)"] A2["图谱+时序联合检索/推理"] end OT --> INST INST --> TSPD ONT --> BRIDGE --> TS BRIDGE --> APP TS --> APP

核心机制(仿 Foundry):

  • Time Series Sync(时序同步):将 TDengine 中的时序数据按 Series ID 索引;每个 TSP 关联一个或多个 sync;每个唯一 Series ID 必须完整落在单个 sync 内。
  • Series ID 命名规范(唯一、可反查):
    • 模式①:{ObjectType}.{ObjectId}.{PropertyName},如 Machine.M-001.Temperature
    • 模式②:{SensorId} 或 {RootType}.{RootId}.{SensorName},如 Equipment.E-100.Pump-P-01
  • 对象↔序列一致性:TypeDB 中对象增删 → 桥自动建/删 TDengine 子表;标签(单位、插值、链接根对象)同步到 TDengine 标签列。

三、两种本体时序建模方式的落地

模式①(对象直挂 TSP):对象自己就是 "采集点",一张表多个读数列 —— 像 "一个人的体检单",身高、体重、血压都写在同一张单子上。

模式②(Sensor 对象):传感器是独立的对象,每个传感器一张表、只存一个数值 —— 像 "每个员工有自己的工牌和考勤记录",工牌(sensor_id)标明身份,考勤记录(子表)只记一条流水。

模式①:直接在对象类型上加 TSP(时间序列属性)

适用:该对象类型的所有对象都有该 TSP 数据(Foundry 文档:这些对象类型构成分析/操作基础)。

TypeDB 建模(属性指向序列,本体只管映射与元数据):

define
machine sub entity,
  owns temperature_series_id,      -- TSP 的 series id
  owns pressure_series_id,
  owns machine_name,
  plays maintenance:target;

temperature_series_id sub attribute, value string;
pressure_series_id    sub attribute, value string;

TDengine 物理落表(推荐"一对象一子表、TSP 为列"的宽表——对象直挂多 TSP 时查询高效):

-- 超级表 = 对象类型;子表 = 对象实例;TSP 列 = 该对象类型所有时序属性
CREATE STABLE st_machine (
  ts TIMESTAMP,
  temperature FLOAT,   -- TSP: Temperature
  pressure    FLOAT    -- TSP: Pressure
) TAGS (
  object_id   BINARY(64),   -- TypeDB 对象主键(Machine.M-001)
  unit_temp   BINARY(16),   -- TSP 元数据:单位
  unit_press  BINARY(16),
  interpolation BINARY(16)  -- linear/step
);

-- 每对象一张子表(series id 即 object_id)
CREATE TABLE s_M001 USING st_machine TAGS ('Machine.M-001','C','kPa','linear');

查询映射:

需求 TypeDB(本体) TDengine(时序)
找对象+拉曲线 match $m isa machine, has machine_name "M-001"; get $m.temperature_series_id SELECT ts, temperature FROM st_machine WHERE object_id='Machine.M-001'
TSP 最新值 同左拿 series id SELECT LAST(*) FROM st_machine WHERE object_id=...(last row cache)
TSP 降采样/聚合 — SELECT _wstart, AVG(temperature) ... INTERVAL(1h)

模式②:添加传感器对象类型(Sensor)

适用:对象配置差异大、避免根对象大量空 TSP(Foundry:如 Equipment 中 Pump 有 Pressure、Reactor 有 Temperature;或同一对象挂多个同名传感器)。

模式②的关键是"传感器的数据形态都一样,差异全在标签里"。下面用通俗类比 + 完整样例讲透。

假设场景:设备 Equipment.E-100(一台泵组)挂了 3 个传感器:

  • Pump-P-01 出口压力(kPa,线性插值)
  • Pump-P-02 进口压力(kPa,线性插值)
  • Motor-V-01 电机振动(mm/s,阶梯插值)

TypeDB 建模(Sensor 为独立实体,通过 relation 链接根对象;每个 Sensor 有唯一名称):

define
equipment sub entity,
  plays measurement:target,
  owns equipment_name;

sensor sub entity,
  owns sensor_name,          -- 唯一,如 Pump-P-01
  owns series_id,            -- 指向 TDengine 序列
  owns unit, owns interpolation,
  plays measurement:source;

measurement sub relation,
  relates source, relates target;   -- Sensor ——测→ Equipment

TDengine 物理落表(一传感器一子表窄表;标签携带链接根对象与元数据):

-- 超级表 = Sensor 类型(一个通用 Sensor 对象类型 → 一张超级表)
CREATE STable st_sensor (
  ts TIMESTAMP,
  value FLOAT               -- 该传感器读数(单一 TSP)
) TAGS (
  sensor_id BINARY(64),     -- series id:Equipment.E-100.Pump-P-01
  root_id   BINARY(64),     -- 链接根对象:Equipment.E-100
  unit      BINARY(16),
  interpolation BINARY(16)
);

-- 每个传感器一张子表(实例化)
CREATE TABLE s_P01 USING st_sensor TAGS ('Equipment.E-100.Pump-P-01','Equipment.E-100','kPa','linear');
CREATE TABLE s_P02 USING st_sensor TAGS ('Equipment.E-100.Pump-P-02','Equipment.E-100','kPa','linear');
CREATE TABLE s_V01 USING st_sensor TAGS ('Equipment.E-100.Motor-V-01','Equipment.E-100','mm/s','step');

-- 传感器 Pump-P-01:出口压力,1Hz 采集
INSERT INTO s_P01 VALUES
  ('2026-10-13 08:00:00.000', 120.5),
  ('2026-10-13 08:00:01.000', 120.7),
  ('2026-10-13 08:00:02.000', 121.0),
  ('2026-10-13 08:00:03.000', 121.2),
  ('2026-10-13 08:00:04.000', 120.9);

-- 传感器 Pump-P-02:进口压力
INSERT INTO s_P02 VALUES
  ('2026-10-13 08:00:00.000', 88.1),
  ('2026-10-13 08:00:01.000', 88.0),
  ('2026-10-13 08:00:02.000', 88.3),
  ('2026-10-13 08:00:03.000', 88.2),
  ('2026-10-13 08:00:04.000', 88.0);

-- 传感器 Motor-V-01:电机振动,低频采集
INSERT INTO s_V01 VALUES
  ('2026-10-13 08:00:00.000', 2.4),
  ('2026-10-13 08:01:00.000', 2.6),
  ('2026-10-13 08:02:00.000', 2.5),
  ('2026-10-13 08:03:00.000', 2.9);
  • 为什么 "一个通用 Sensor 类型 → 一张超级表"?

所有传感器产生的数据,结构完全相同:时间戳 + 一个数值。区别只在于:

区别 放哪里 例子
这个传感器是谁 子表(每个传感器一张) Pump-P-01 一张表
它属于哪个根对象 标签 root_id Equipment.E-100
单位/插值方式 标签 unit / interpolation kPa / linear
读数本身 表内的列 ts + value

所以,一张超级表(模板)+ 每传感器一张子表(实例)就够了。子表名只是 TDengine 的物理名(s_P01),业务身份是标签 sensor_id。

查询映射(传感器模式):

需求 实现
根对象的所有传感器时序 TypeDB 沿 measurement 找全部 sensor → 桥按 root_id 标签批量取 TDengine 子表
按 sensor 取曲线 SELECT ts, value FROM st_sensor WHERE sensor_id='Equipment.E-100.Pump-P-01'
统一视图 应用层:根对象属性(TypeDB)+ 链接传感器的 TSP(TDengine)合并渲染

① 查某个传感器的曲线(按 sensor_id 定位):

SELECT ts, value FROM st_sensor
WHERE sensor_id = 'Equipment.E-100.Pump-P-01'
  AND ts BETWEEN '2026-10-13 08:00:00' AND '2026-10-13 08:01:00';

② 查某根对象的"所有传感器"最近读数(一键拉全厂设备全景):

-- 最新值:每个传感器一行(TDengine 每表缓存最后一条)
SELECT sensor_id, unit, LAST(value) AS last_val
FROM st_sensor
WHERE root_id = 'Equipment.E-100'
GROUP BY sensor_id, unit;

结果示意:

sensor_id                            | unit | last_val
Equipment.E-100.Pump-P-01            | kPa  | 120.9
Equipment.E-100.Pump-P-02            | kPa  | 88.0
Equipment.E-100.Motor-V-01           | mm/s | 2.9

③ 降采样聚合(如每小时平均压力):

SELECT _wstart, AVG(value) AS avg_pressure
FROM st_sensor
WHERE sensor_id = 'Equipment.E-100.Pump-P-01'
  AND ts >= '2026-10-13 08:00:00' AND ts < '2026-10-13 09:00:00'
INTERVAL(1h);

④ 应用层统一视图流程(对应 Foundry):

  1. TypeDB:match $e isa equipment, has equipment_name "E-100"; $s isa sensor; (source:$s, target:$e) isa measurement; get $s.sensor_name; → 拿到 3 个 sensor_name
  2. 桥层:转成 root_id='Equipment.E-100' 批量查 TDengine(上面的查询②)
  3. 前端:设备属性(TypeDB)+ 3 条 TSP 曲线(TDengine)合并渲染

四、TDengine 与本体建模贴合度评估(分维度)

本体建模维度 TDengine 角色贴合度 说明
对象类型(类) 高 超级表 ≈ 对象类型的时序视图,Schema 稳定、可建多张
对象实例 高 子表 ≈ 对象实例;"一对象一表/一传感器一表"即 Foundry 语义
属性(静态) 中-高 静态属性入 TypeDB;TDengine 用标签冗余承载(单位/插值/链接),便于时序侧过滤
属性(动态=TSP) 高 时序属性正是 TDengine 本职:列(宽表)或序列(窄表)均可表达
关系/关联 低(不承担) 关系归 TypeDB(n-ary relation);TDengine 仅以 root_id 等标签冗余表达"链接"
子类型/继承/推理 低(不承担) 归 TypeDB type-theoretic 能力;TDengine 无推理
语义/上下文 中 标签可携带单位/工况等;深度语义靠 TypeDB + 应用层
AI 可遍历 中-高 TDgpt 提供预测/异常检测;本体遍历由 TypeDB + 桥完成
标准本体语言(OWL/RDF) 低 由 TypeDB 侧解决;TDengine 不需要

总评:作为时序物理底座贴合度高;作为本体引擎贴合度低。正确分工后,两者互补构成 Foundry 式"对象+时序"底座。


五、两种模式的利弊与选型

维度 模式① 对象直挂 TSP 模式② Sensor 对象类型
Foundry 官方适用 所有对象都有该 TSP 设备配置差异大、避免空 TSP
TDengine 表形态 一对象一子表、多 TSP 列(宽表) 一传感器一子表、单值列(窄表)
子表数量 = 对象数 = 传感器数(≥对象数)
宽表列数风险 对象 TSP 多时列数膨胀(<4096 限制内) 无(窄表)
单车/单对象全景查询 最优(一次取全部 TSP) 需合并多传感器
新增 TSP 加列(影响整类) 加传感器实例(不影响既有)
元数据(单位/插值) 每 TSP 一组标签 每传感器维护,更内聚
空值/稀疏 易出现大量空列 天然避免
推荐场景 TSP 集固定且普适(温度/计数) TSP 因对象而异(泵压力 vs 反应器温度)、多传感器同名

选型建议:通用平台中两者共存——根对象类型直挂"普适 TSP"(模式①),差异化的、可枚举的信号走 Sensor 对象(模式②),与 Foundry 官方"根对象也可同时直挂其他 TSP"的做法一致。


六、资源与实施要点

  • TDengine 规模:子表数 = 对象数 + 传感器数(通用平台通常远小于车联网量级);按"每秒写入点=序列数×采集频率"公式换算,单节点 100 万点/秒写入、单 vnode 100 万表上限规划;生产 3 副本。
  • 元数据桥(关键自研件):TypeQL schema 变更监听 → 自动建/改超级表与标签;对象生命周期(增删/改名)→ 子表同步;Series ID 注册表保证两侧一致。
  • 一致性策略:本体先写(TypeDB 为权威),时序异步同步(TDengine 最终一致);Series ID 不可变(防悬挂)。
  • 查询路径:应用先查 TypeDB 拿对象/传感器/Series ID → 再批量查 TDengine;跨系统聚合在应用层或桥层完成(无分布式 JOIN)。
  • PoC 验证:用 taosBenchmark 按目标对象数/传感器数/频率压测宽表与窄表两种形态。

参考文献

Y 推荐文献

X 参考文献

posted @ 2026-10-13 11:43  千千寰宇  阅读(31)  评论(0)    收藏  举报