Enum Schema

pub enum Schema {
    Null,
    Boolean,
    Int(Option<IntLogical>),
    Long(Option<LongLogical>),
    Float,
    Double,
    Bytes(Option<BytesLogical>),
    String(Option<StringLogical>),
    Record(Record),
    Enum(Enum),
    Array(Box<Schema>),
    Map(Box<Schema>),
    Union(Vec<Schema>),
    Fixed(Fixed),
}

An Avro Schema. It describes all physical and logical types. See the spec for details.

Variants

Null

A null type

Boolean

Boolean (physically represented as a single byte)

Int(Option<IntLogical>)

32 bit signed integer (physically represented as a zigzag encoded variable number of bytes)

Long(Option<LongLogical>)

64 bit signed integer (physically represented as a zigzag encoded variable number of bytes)

Float

32 bit float (physically represented as 4 bytes in little endian)

Double

64 bit float (physically represented as 8 bytes in little endian)

Bytes(Option<BytesLogical>)

variable length bytes (physically represented by a zigzag encoded positive integer followed by its number of bytes)

String(Option<StringLogical>)

variable length utf8 (physically represented by a zigzag encoded positive integer followed by its number of bytes)

Record(Record)

Record

Enum(Enum)

Enum with a known number of variants

Array(Box<Schema>)

Array of a uniform type with N entries

Map(Box<Schema>)

A map String -> type

Union(Vec<Schema>)

A union of a heterogeneous number of types

Fixed(Fixed)

todo

Trait Implementations

impl Clone for Schema

fn clone(&self) -> Schema

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Schema

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Schema

fn deserialize<D>(deserializer: D) -> Result<Schema, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Enum> for Schema

fn from(enum_: Enum) -> Self

Converts to this type from the input type.

impl From<Fixed> for Schema

fn from(fixed: Fixed) -> Self

Converts to this type from the input type.

impl From<Record> for Schema

fn from(record: Record) -> Self

Converts to this type from the input type.

impl Hash for Schema

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Schema

fn eq(&self, other: &Schema) -> 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 Serialize for Schema

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 Schema