N.B. It is possible to create a Haskell value (of Schema type) that is not a valid Avro schema by violating one of the above or one of the conditions called out in validateSchema.

A named type in Avro has a name and, optionally, a namespace.

A name is a string that starts with an ASCII letter or underscore followed by letters, underscores and digits:

name ::= [A-Za-z_][A-Za-z0-9_]*

Examples include "_foo7", Bar_ and "x".

A namespace is a sequence of names with the same lexical structure. When written as a string, the components of a namespace are separated with dots ("com.example").

TypeName represents a fullname—a name combined with a namespace. These are written and parsed as dot-separated strings. The TypeName TN Foo ["com", "example"] is rendered as "com.example.Foo".

Fullnames have to be globally unique inside an Avro schema.

A namespace of [] or [""] is the "null namespace". In avro an explicitly null-namespaced identifier is written as ".Foo"

The decimal logical type represents arbitrary-precision decimal numbers. Numbers are represented as unscaled * (10 ** -scale) where scale is part of the logical type and unscaled is an integer represented by the underlying primitive type.

Instances of the decimal logical type need to specify a scale and precision.

decimal can be encoded as one of several different primitive types:

• bytes

• fixed

• long

• int

For long and int, unscaled is the underlying number.

For bytes and fixed, unscaled is represented as a two's-complement signed integer in big-endian byte order.

Note: int and long representations for decimal are not part of the current Avro specification, but they are supported by some language implementations including the official Java library. Implementations that do not support this should ignore the logical type and use the underlying primitive type instead.

This type represents a deconflicted version of a Schema. Schema resolution is described in Avro specification: https://avro.apache.org/docs/current/spec.html#Schema+Resolution

This library represents "normal" schema and "deconflicted" schema as different types to avoid confusion between these two usecases (we shouldn't serialise values with such schema) and to be able to accomodate some extra information that links between how data is supposed transformed between what reader wants and what writer has.

deconflict writer reader will produce a schema that can decode with the writer's schema into the form specified by the reader's schema.

Schema resolution rules are described by the specification: https://avro.apache.org/docs/current/spec.html#Schema+Resolution

Converts Schema into ReadSchema. This function may be useful when it is known that the writer and the reader schemas are the same.

Serialises an individual value into Avro using the schema from its coresponding HasAvroSchema instance.

Serialises an individual value into Avro with the schema provided.

Deserialises an individual value from Avro using the schema from its coresponding HasAvroSchema.

NOTE: This function is only to be used when reader and writes schemas are known to be the same. Because only one schema is known at this point, and it is the reader schema, no decondlicting can be performed.

Deserialises an individual value from Avro.

Decodes the container using a schema from HasAvroSchema as a reader schema.

Errors are reported as a part of the list and the list will stop at first error. This means that the consumer will get all the "good" content from the container until the error is detected, then this error and then the list is finished.

Decodes the container as a list of values of the requested type.

Errors are reported as a part of the list and the list will stop at first error. This means that the consumer will get all the "good" content from the container until the error is detected, then this error and then the list is finished.

Decodes the container as a list of values of the requested type.

The provided reader schema will be de-conflicted with the schema embedded with the container.

Errors are reported as a part of the list and the list will stop at first error. This means that the consumer will get all the "good" content from the container until the error is detected, then this error and then the list is finished.

Encode chunks of values into a container, using 16 random bytes for the synchronization markers and a corresponding HasAvroSchema schema. Blocks are compressed (or not) according to the given Codec (nullCodec or deflateCodec).

Encode chunks of values into a container, using 16 random bytes for the synchronization markers. Blocks are compressed (or not) according to the given Codec (nullCodec or deflateCodec).

Encode chunks of objects into a container, using the provided ByteString as the synchronization markers.

Generates a new synchronization marker for encoding Avro containers

Splits container into a list of individual avro-encoded values.

This is particularly useful when slicing up containers into one or more smaller files. By extracting the original bytestring it is possible to avoid re-encoding data.

Splits container into a list of individual avro-encoded values. This version provides both encoded and decoded values.

This is particularly useful when slicing up containers into one or more smaller files. By extracting the original bytestring it is possible to avoid re-encoding data.

Describes how to encode Haskell data types into Avro bytes

Descrives how to convert a given intermediate Value into a Haskell data type.

A Codec allows for compression/decompression of a block in an Avro container according to the Avro spec.

nullCodec specifies null required by Avro spec. (see https://avro.apache.org/docs/1.8.1/spec.html#null)

deflateCodec specifies deflate codec required by Avro spec. (see https://avro.apache.org/docs/1.8.1/spec.html#deflate)