Struct EncodedSchemas

pub struct EncodedSchemas {
    pub key: Bytes,
    pub key_data_type: Bytes,
    pub val: Bytes,
    pub val_data_type: Bytes,
}

A key and val Codec::Schema encoded via Codec::encode_schema.

This strategy of directly serializing the schema objects requires that persist users do the right thing. Specifically, that an encoded schema doesn’t in some later version of mz decode to an in-mem object that acts differently. In a sense, the current system (before the introduction of the schema registry) where schemas are passed in unchecked to reader and writer registration calls also has the same defect, so seems fine.

An alternative is to write down here some persist-specific representation of the schema (e.g. the arrow DataType). This is a lot more work and also has the potential to lead down a similar failure mode to the mz_persist_types Data trait, where the boilerplate isn’t worth the safety. Given that we can always migrate later by rehydrating these, seems fine to start with the easy thing.

Fields

key: Bytes

A full in-mem K::Schema impl encoded via Codec::encode_schema.

key_data_type: Bytes

The arrow DataType produced by this K::Schema at the time it was registered, encoded as a ProtoDataType.

val: Bytes

A full in-mem V::Schema impl encoded via Codec::encode_schema.

val_data_type: Bytes

The arrow DataType produced by this V::Schema at the time it was registered, encoded as a ProtoDataType.

Implementations

impl EncodedSchemas

pub(crate) fn decode_data_type(buf: &[u8]) -> DataType

Trait Implementations

impl Clone for EncodedSchemas

fn clone(&self) -> EncodedSchemas

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EncodedSchemas

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for EncodedSchemas

fn eq(&self, other: &EncodedSchemas) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl RustType<ProtoEncodedSchemas> for EncodedSchemas

fn into_proto(&self) -> ProtoEncodedSchemas

Convert a Self into a Proto value.

fn from_proto(proto: ProtoEncodedSchemas) -> Result<Self, TryFromProtoError>

Consume and convert a Proto back into a Self value.

fn into_proto_owned(self) -> Proto

A zero clone version of Self::into_proto that types can optionally implement, otherwise, the default implementation delegates to Self::into_proto.

impl Serialize for EncodedSchemas

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for EncodedSchemas