Enum AvroSchema 

pub enum AvroSchema {
    Null,
    Boolean,
    Int,
    Long,
    Float,
    Double,
    Bytes,
    String,
    Array(ArraySchema),
    Map(MapSchema),
    Union(UnionSchema),
    Record(RecordSchema),
    Enum(EnumSchema),
    Fixed(FixedSchema),
    Decimal(DecimalSchema),
    BigDecimal,
    Uuid,
    Date,
    TimeMillis,
    TimeMicros,
    TimestampMillis,
    TimestampMicros,
    TimestampNanos,
    LocalTimestampMillis,
    LocalTimestampMicros,
    LocalTimestampNanos,
    Duration,
    Ref {
        name: Name,
    },
}

Represents any valid Avro schema More information about Avro schemas can be found in the Avro Specification

Variants

Null

A null Avro schema.

Boolean

A boolean Avro schema.

Int

An int Avro schema.

Long

A long Avro schema.

Float

A float Avro schema.

Double

A double Avro schema.

Bytes

A bytes Avro schema. Bytes represents a sequence of 8-bit unsigned bytes.

String

A string Avro schema. String represents a unicode character sequence.

Array(ArraySchema)

A array Avro schema. Avro arrays are required to have the same type for each element. This variant holds the Schema for the array element type.

Map(MapSchema)

A map Avro schema. Map holds a pointer to the Schema of its values, which must all be the same schema. Map keys are assumed to be string.

Union(UnionSchema)

A union Avro schema.

Record(RecordSchema)

A record Avro schema.

Enum(EnumSchema)

An enum Avro schema.

Fixed(FixedSchema)

A fixed Avro schema.

Decimal(DecimalSchema)

Logical type which represents Decimal values. The underlying type is serialized and deserialized as Schema::Bytes or Schema::Fixed.

BigDecimal

Logical type which represents Decimal values without predefined scale. The underlying type is serialized and deserialized as Schema::Bytes

Uuid

A universally unique identifier, annotating a string.

Date

Logical type which represents the number of days since the unix epoch. Serialization format is Schema::Int.

TimeMillis

The time of day in number of milliseconds after midnight with no reference any calendar, time zone or date in particular.

TimeMicros

The time of day in number of microseconds after midnight with no reference any calendar, time zone or date in particular.

TimestampMillis

An instant in time represented as the number of milliseconds after the UNIX epoch.

TimestampMicros

An instant in time represented as the number of microseconds after the UNIX epoch.

TimestampNanos

An instant in time represented as the number of nanoseconds after the UNIX epoch.

LocalTimestampMillis

An instant in localtime represented as the number of milliseconds after the UNIX epoch.

LocalTimestampMicros

An instant in local time represented as the number of microseconds after the UNIX epoch.

LocalTimestampNanos

An instant in local time represented as the number of nanoseconds after the UNIX epoch.

Duration

An amount of time defined by a number of months, days and milliseconds.

Ref

A reference to another schema.

Fields

name: Name

Implementations

impl Schema

pub fn canonical_form(&self) -> String

Converts self into its Parsing Canonical Form.

pub fn independent_canonical_form( &self, schemata: &[Schema], ) -> Result<String, Error>

Returns the Parsing Canonical Form of self that is self contained (not dependent on any definitions in schemata)

pub fn fingerprint<D>(&self) -> SchemaFingerprint

where D: Digest,

Generate fingerprint of Schema’s Parsing Canonical Form.

pub fn parse_str(input: &str) -> Result<Schema, Error>

Create a Schema from a string representing a JSON Avro schema.

pub fn parse_list( input: impl IntoIterator<Item = impl AsRef<str>>, ) -> Result<Vec<Schema>, Error>

Create an array of Schema’s from a list of named JSON Avro schemas (Record, Enum, and Fixed).

It is allowed that the schemas have cross-dependencies; these will be resolved during parsing.

If two of the input schemas have the same fullname, an Error will be returned.

pub fn parse_str_with_list( schema: &str, schemata: impl IntoIterator<Item = impl AsRef<str>>, ) -> Result<(Schema, Vec<Schema>), Error>

Create a Schema from a string representing a JSON Avro schema, along with an array of Schema’s from a list of named JSON Avro schemas (Record, Enum, and Fixed).

It is allowed that the schemas have cross-dependencies; these will be resolved during parsing.

If two of the named input schemas have the same fullname, an Error will be returned.

Arguments

• schema - the JSON string of the schema to parse
• schemata - a slice of additional schemas that is used to resolve cross-references

pub fn parse_reader(reader: &mut (impl Read + ?Sized)) -> Result<Schema, Error>

Create a Schema from a reader which implements Read.

pub fn parse(value: &Value) -> Result<Schema, Error>

Parses an Avro schema from JSON.

pub fn custom_attributes(&self) -> Option<&BTreeMap<String, Value>>

Returns the custom attributes (metadata) if the schema supports them.

pub fn name(&self) -> Option<&Name>

Returns the name of the schema if it has one.

pub fn namespace(&self) -> Option<String>

Returns the namespace of the schema if it has one.

pub fn aliases(&self) -> Option<&Vec<Alias>>

Returns the aliases of the schema if it has ones.

pub fn doc(&self) -> Option<&String>

Returns the doc of the schema if it has one.

pub fn map(types: Schema) -> Schema

Returns a Schema::Map with the given types.

pub fn map_with_attributes( types: Schema, attributes: BTreeMap<String, Value>, ) -> Schema

Returns a Schema::Map with the given types and custom attributes.

pub fn array(items: Schema) -> Schema

Returns a Schema::Array with the given items.

pub fn array_with_attributes( items: Schema, attributes: BTreeMap<String, Value>, ) -> Schema

Returns a Schema::Array with the given items and custom attributes.

Trait Implementations

impl Clone for Schema

fn clone(&self) -> Schema

Returns a duplicate 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<(), Error>

Formats the value using the given formatter.

impl Display for Schema

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

Formats the value using the given formatter.

impl IntoDiscriminant for Schema

type Discriminant = SchemaKind

Enum listing the same variants as this enum but without any data fields

fn discriminant(&self) -> <Schema as IntoDiscriminant>::Discriminant

impl PartialEq for Schema

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

Assess equality of two Schema based on Parsing Canonical Form.

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 as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.