OceanBase源码解读:物化视图MDS操作登记与重放 ob_mview_mds

物化视图刷新是 OceanBase 4.3 的重头特性。刷新的主战场在存储层的 storage/mview,但有一类信息光靠存储层自己知道没用——「这张 MV 正在刷、刷到哪个快照、目标要同步到哪个 GTS 位点」。这些元信息必须让 RootService 也看得见,否则 RS 无法判断嵌套 MV 的下层是否就位,也就无法决定上层能不能开始刷。OceanBase 选的做法是把这类状态做成事务的一等多数据源(Multi Data Source,简称 MDS),跟着 redo 一起落盘。本文解析这条通道的实现——三个类、两百来行代码,把「写入、注册、回放、清理」四个环节串了起来。

一、为什么不用 RPC,而用 MDS

最直觉的方案是刷新侧刷完调一次 RPC 告诉 RS。但 MV 刷新是长事务,中途可能切主、可能崩溃。RPC 是「尽力而为」语义:发出了不代表对方处理了,对方处理了也不代表落盘了。切主之后,新的 RS 完全不知道自己错过了什么。

MDS 的思路是把这条消息「变成事务的一部分」。它随事务 redo 写 SYS_LS,因此天然继承事务的两个性质:原子(要不就在、要不就没有)和可回放(新主机重放 redo 就能重建状态)。代价是必须定义序列化协议、生命周期回调,并处理「回放时该重建什么、不该重建什么」——后面会看到,这个「不该重建什么」恰恰是最精妙的一处设计。

二、核心数据结构

ObMViewOpArg:一次刷新操作的全部参数

这是跨机、跨版本传输的载体,所以必须可序列化。它用 OB_UNIS_VERSION(1) 声明协议版本,字段顺序即协议顺序——新增字段只能追加到尾部并同步升级版本号。

struct ObMViewOpArg
{
  OB_UNIS_VERSION(1);
public:
  bool is_valid() const { return table_id_ > 0 && mview_op_type_ > UNDEFINE_OP; }
  int64_t table_id_;                        // 哪张 MV
  MVIEW_OP_TYPE mview_op_type_;             // 操作类型
  int64_t read_snapshot_;                   // 读快照(刷新读的是哪个版本)
  int64_t parallel_;                        // 并行度
  uint64_t session_id_;                     // 发起刷新的会话
  int64_t start_ts_;                        // 开始时间戳
  uint64_t refresh_id_;                     // 第几次刷新
  ObSEArray<uint64_t, 4> nested_mview_lists_;
  share::SCN target_data_sync_scn_;         // 目标同步位点(GTS)
};

OB_SERIALIZE_MEMBER(ObMViewOpArg,
                    table_id_, mview_op_type_, read_snapshot_,
                    parallel_, session_id_, start_ts_,
                    refresh_id_, nested_mview_lists_, target_data_sync_scn_);

九个字段分四类:定位类(table_id_、refresh_id_)回答「哪张 MV 的第几次刷新」;能力类(mview_op_type_、parallel_、session_id_)回答「怎么刷、并发多少、谁发起」;约束类(read_snapshot_、start_ts_、target_data_sync_scn_)回答「读哪个版本、要同步到哪」;依赖类(nested_mview_lists_)回答「由哪些嵌套成员组成」。

操作类型是四个枚举值:COMPLETE_REFRESH、FAST_REFRESH、PURGE_MLOG、NESTED_SYNC_REFRESH。注意 is_valid() 判断很宽松,只要求 table_id 有效且类型不是 UNDEFINE_OP——不同操作类型用到的字段并不相同,做不了统一强校验。

ObMViewMdsOpCtx:生命周期钩子的载体

它继承 mds::BufferCtx,是 MDS 框架要求的上下文形态,只有三个成员:

class ObMViewMdsOpCtx : public mds::BufferCtx
{
public:
  virtual const mds::MdsWriter get_writer() const override;
  virtual void on_redo(const share::SCN &redo_scn) override;
  virtual void on_commit(const share::SCN &commit_version, const share::SCN &commit_scn) override;
  virtual void on_abort(const share::SCN &abort_scn) override;
private:
  mds::MdsWriter writer_;   // 两元组:writer_type_ + writer_id_(这里 id 就是 tx_id)
  share::SCN op_scn_;       // 这条操作被重做到哪个 SCN
  ObMViewOpArg arg_;
};

一处容易看漏的细节:reset() 只清 op_scn_ 和 arg_,不清 writer_。因为 writer_ 是框架通过 set_writer() 从外部注入的「身份」,而 reset 的语义是「清业务状态」。职责分离,混在一起清会把身份也抹掉。

三、写入侧:register_mview_mds 的阶梯瀑布

机制的入口在存储侧。该校验顺序是刻意设计的,从便宜到昂贵一条线排下来:

int ObMViewMdsOpHelper::register_mview_mds(const uint64_t tenant_id,
                                           const ObMViewOpArg &arg,
                                           ObISQLClient &sql_client)
{
  ObInnerSQLConnection *conn = nullptr;
  ObArenaAllocator allocator("MVIEW_MDS");
  int64_t size = arg.get_serialize_size();
  ObRegisterMdsFlag flag;
  flag.need_flush_redo_instantly_ = true;          // 立刻刷 redo,不组提交
  flag.mds_base_scn_.reset();
  share::ObLSID ls_id(share::ObLSID::SYS_LS_ID);   // 固定写 SYS_LS

  if (OB_FAIL(GET_MIN_DATA_VERSION(tenant_id, data_version))) {
    // ...
  } else if (data_version < DATA_VERSION_4_3_5_1) {
    // do nothing —— 老集群无此能力,静默跳过
  } else if (OB_ISNULL(conn = static_cast<ObInnerSQLConnection *>(sql_client.get_connection()))) {
    ret = OB_INNER_STAT_ERROR;
  } else if (!arg.is_valid()) {
    ret = OB_INVALID_ARGUMENT;
  } else if (OB_ISNULL(buf = static_cast<char *>(allocator.alloc(size)))) {
    ret = OB_ALLOCATE_MEMORY_FAILED;
  } else if (OB_FAIL(arg.serialize(buf, size, pos))) {
    // ...
  } else if (OB_FAIL(conn->register_multi_data_source(tenant_id, ls_id,
                                                     ObTxDataSourceType::MVIEW_MDS_OP,
                                                     buf, size, flag))) {
    // ...
  }
  return ret;
}

版本门禁放第一步。4.3.5.1 之前的集群没有这套能力。这里选「静默返回成功」而非报错,是因为调用方(刷新主流程)不该因「集群版本老」而感知差异——功能降级要无感,这是灰度兼容的常规做法。

必须是内联连接。强制要求 ObInnerSQLConnection,因为 register_multi_data_source 是内联连接独有的能力。拿不到就是 OB_INNER_STAT_ERROR,属于「不该发生」的情况。业务校验 arg.is_valid() 排在 alloc 之前,避免为非法参数白分配内存——「先判断后分配」在 OceanBase 里是硬性习惯。

两个 flag 决定可靠性等级。need_flush_redo_instantly_ = true 意味着不等组提交、立刻刷盘。为什么多付一次 fsync?因为 MV 刷新是长事务,若 MDS 只留在内存,崩溃就会让 RS 丢失「有刷新在跑」这个事实,切主后可能重复调度同一张 MV。一次刷盘换状态不丢,划算。

固定写 SYS_LS。MDS 元信息必须由 RS 所在的主副本维护,写到用户 LS 上 RS 就看不见了。这和刷新工具箱里「先定位 SYS_LS leader 再发 RPC」是同一个前提。

四、读取侧:on_register 与 on_replay 的不对称

RS 侧收这条 MDS 时有两个回调:正常注册路径 on_register,和重启/切主后的回放路径 on_replay。两者代码看起来几乎一样,但有关键的不对称。

int ObMViewMdsOpHelper::on_register(const char* buf, const int64_t len, mds::BufferCtx &ctx)
{
  ObMViewMdsOpCtx &user_ctx = static_cast<ObMViewMdsOpCtx&>(ctx);
  ObMViewOpArg &arg = user_ctx.get_arg();
  transaction::ObTransID tx_id = user_ctx.get_writer().writer_id_;

  if (OB_FAIL(arg.deserialize(buf, len, pos))) {
    // ...
  } else if (!arg.is_valid()) {
    ret = OB_INVALID_ARGUMENT;
  } else {
    int64_t ts = ObTimeUtil::current_time();
    MTL(ObMViewMaintenanceService*)->update_mview_mds_ts(ts);   // 心跳水位
    if (arg.mview_op_type_ == MVIEW_OP_TYPE::NESTED_SYNC_REFRESH) {
      // 只有嵌套同步刷新才落 map
      if (OB_TMP_FAIL(MTL(ObMViewMaintenanceService*)->get_mview_mds_op()
                        .set_refactored(tx_id, arg, 1))) {
        LOG_WARN("fail to set refactored mview mds op map", K(ret), K(tx_id), K(arg));
      }
    }
  }
  return ret;
}

第一个不对称:只有 NESTED_SYNC_REFRESH 才落 map。嵌套 MV 的同步刷新是唯一需要 RS 在事务尚未提交时就「看见」的操作——RS 要提前规划多层 MV 的刷新顺序,下层没刷完上层不能动。其它类型(complete / fast / purge)走常规流程就够了,往 map 里塞只会白占内存,还给提交路径增加负担。

第二个不对称:on_replay 不重建 map。回放路径只做两件事——反序列化、刷心跳水位,绝不碰 map。原因是 map 的语义是「本机正在进行中的事务」的临时视图;回放发生在重启或切主之后,那些事务要么早已结束、要么需要重新发起。此时把 map 重建起来,反而会让 RS 误以为有刷新正在跑,卡住后续调度。所以 map 的正确性完全依赖「注册时写、提交/回滚时删」这一对动作,回放路径刻意保持零副作用。

顺带一处容错:set_refactored 外面套的是 OB_TMP_FAIL,写 map 失败只打 WARN 不阻断注册。这条通道终究是辅助信息,辅助信息写不进去,不该拖垮主流程。

五、生命周期:map 的写与删必须配对

MDS 框架会在三个时机回调 ctx:redo、commit、abort。

void ObMViewMdsOpCtx::on_commit(const share::SCN &commit_version, const share::SCN &commit_scn)
{
  transaction::ObTransID tx_id = writer_.writer_id_;
  int ret = OB_SUCCESS;
  if (OB_FAIL(MTL(ObMViewMaintenanceService*)->get_mview_mds_op().erase_refactored(tx_id))) {
    LOG_WARN("fail to erase mview mds op map", K(ret), K(tx_id), K(arg_));
  }
  MTL(ObMViewMaintenanceService*)->update_mview_mds_ts(ts);
  LOG_INFO("mview mds on_commit", K(tx_id), KPC(this), K(commit_scn), K(commit_version));
}

void ObMViewMdsOpCtx::on_abort(const share::SCN &abort_scn)
{
  // 清理动作与 on_commit 完全一致:无论如何都要摘掉 map 条目
  if (OB_FAIL(MTL(ObMViewMaintenanceService*)->get_mview_mds_op().erase_refactored(tx_id))) {
    LOG_WARN("fail to erase mview mds op map", K(ret), K(tx_id), K(arg_));
  }
}

on_commit 和 on_abort 的清理逻辑一字不差,都是 erase_refactored(tx_id)。这解释了一个设计疑问:为什么不能只在提交路径清理?因为回滚同样意味着「这次刷新不存在了」,条目留着就是幽灵状态,会让 RS 一直以为有刷新在跑。

另一处细节:这两个函数都是 void,erase 失败只能打 WARN,没法向上返回错误。因为此刻事务已提交/回滚、回滚点已过,能做的只剩记日志,其余靠心跳水位和超时兜底。这类「不可失败的回调里如何处理失败」是分布式系统的典型取舍——承认无解,然后设计外部兜底。

至于 on_redo,它只做一件事:把 op_scn_ 记成当前重放到的 SCN,供后续时序判断(比如某条操作是否早于某次基线)。和 on_replay 一致,redo 路径同样属于「重放」,不写 map。

六、小结

两百行代码实现了一条「存储侧 → RS 侧」的状态同步通道,取舍集中在三点:

用 MDS 而不是 RPC,换取原子性与可回放性。代价是要写序列化协议、处理三个生命周期回调,并仔细区分「注册」与「回放」的语义差异。

按需落 map。只有嵌套同步刷新需要 RS 提前感知,其余类型只推进心跳水位。功能上做减法,避免把辅助通道变成主流程的负担。

回放路径零副作用。这是全文最容易被误改的一处:若有人「顺手」让 on_replay 也写 map,功能上看似更完整,实际会让切主后的 RS 卡在假的「刷新进行中」状态上无法调度。读这类代码时,最该问的不是「这里少了什么」,而是「这里为什么故意少」。

放回整体视角:刷新工具箱负责「怎么刷」,MDS 负责「让该知道的人知道刷到哪了」,RS 侧的维护任务负责「根据信息安排下一次」。三者拼起来,才是 4.3 物化视图自动维护的完整闭环。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注