Rust中Option<T>与自定义Avro Schema的序列化兼容问题

我用apache-avro库做Rust程序的序列化/反序列化，目标Avro Schema是这样的：

{
    "type": "record",
    "name": "Topic",
    "namespace": "some.namespace",
    "fields": [
        {
            "name": "double0",
            "type": ["double", "null"],
            "default": 0.0
        }
    ]
}

这个字段允许double或null值，默认0.0，用来处理客户端传的NaN或无效值。

核心问题 #

我一开始用Rust的Option<f64>对应这个字段：

struct Topic {
    double0: Option<f64>,
}

但serde自动把Option<f64>映射成"type": ["null", "double"]的Schema，导致数据不兼容：

• 目标Schema要求Union索引0对应double（比如Record([("double0", Union(0, Double(1234.5)))])）
• 但serde生成的是索引1对应double，完全反过来了。

踩过的坑 #

我试过自定义类似Option<T>的结构体，让Some<T>优先级高于None，还设了默认值Some(T::default())，但序列化出来的是嵌套Record，完全不对：

Ok(Record([("double0", Record([("type", Enum(0, "Some")), ("value", Union(0, Double(1234.5)))]))]))

目前的进展（初步可行但不优雅） #

我写了模仿Option的MyDouble和MyFloat枚举，手动实现了Serialize：

impl Serialize for MyFloat {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match self {
            MyFloat::Some(value) => serializer.serialize_f32(*value),
            MyFloat::None => serializer.serialize_unit(),
        }
    }
}

序列化结果：

• Some(value)时：Ok(Record([("double0", Double(1234.5)), ("float0", Float(5.4321))]))
• None时：Ok(Record([("double0", Null), ("float0", Null)]))
  现在序列化反序列化能跑，但没有显式的Union标记，总觉得不够规范，想找个更标准的实现方式。

解决方案：严格匹配Avro Union顺序的自定义类型 #

要完全贴合目标Schema的[double, null]顺序，需要同时实现Serialize和Deserialize，让serde识别这是Union类型而非普通枚举。

1. 定义自定义枚举并实现默认值 #

use serde::{Serialize, Deserialize, Serializer, Deserializer};

#[derive(Debug, Clone, PartialEq)]
enum MyDouble {
    Some(f64),
    None,
}

// 匹配Schema的default值0.0
impl Default for MyDouble {
    fn default() -> Self {
        MyDouble::Some(0.0)
    }
}

2. 实现Serialize trait（指定Union索引） #

要让MyDouble::Some对应Union的第0项（double），MyDouble::None对应第1项（null），需要针对Avro序列化器的特性处理：

impl Serialize for MyDouble {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        // 针对Avro的Union序列化，明确指定索引
        match self {
            MyDouble::Some(v) => {
                // 构造Union值，索引0对应double
                serializer.serialize_newtype_variant("MyDouble", 0, "Some", v)
            }
            MyDouble::None => {
                // 索引1对应null
                serializer.serialize_newtype_variant("MyDouble", 1, "None", &())
            }
        }
    }
}

3. 实现Deserialize trait（处理Union索引） #

反序列化时要识别Avro Union的两个索引对应的类型：

impl<'de> Deserialize<'de> for MyDouble {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        use serde::de::Visitor;
        use std::fmt;

        struct MyDoubleVisitor;

        impl<'de> Visitor<'de> for MyDoubleVisitor {
            type Value = MyDouble;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("Avro Union类型：[double, null]")
            }

            // 直接读取double值
            fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                Ok(MyDouble::Some(value))
            }

            // 读取null值
            fn visit_unit<E>(self) -> Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                Ok(MyDouble::None)
            }

            // 处理带索引的Union类型
            fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
            where
                A: serde::de::EnumAccess<'de>,
            {
                let (index, variant) = data.variant::<u32>()?;
                match index {
                    0 => Ok(MyDouble::Some(variant.newtype_variant()?)),
                    1 => {
                        variant.unit_variant()?;
                        Ok(MyDouble::None)
                    }
                    idx => Err(serde::de::Error::custom(format!("无效的Union索引：{}", idx))),
                }
            }
        }

        deserializer.deserialize_any(MyDoubleVisitor)
    }
}

4. 在结构体中使用自定义枚举 #

#[derive(Debug, Serialize, Deserialize)]
struct Topic {
    double0: MyDouble,
}

这样实现后，序列化出来的Union索引完全匹配目标Schema：double对应索引0，null对应索引1，同时默认值为0.0，完美满足需求。

内容的提问来源于stack exchange，提问作者tribeiro