Struct SchemaStore 

pub struct SchemaStore {
    fingerprint_algorithm: FingerprintAlgorithm,
    schemas: HashMap<Fingerprint, AvroSchema>,
}

An in-memory cache of Avro schemas, indexed by their fingerprint.

SchemaStore provides a mechanism to store and retrieve Avro schemas efficiently. Each schema is associated with a unique Fingerprint, which is generated based on the schema’s canonical form and a specific hashing algorithm.

A SchemaStore instance is configured to use a single FingerprintAlgorithm such as Rabin, MD5 (not yet supported), or SHA256 (not yet supported) for all its operations. This ensures consistency when generating fingerprints and looking up schemas. All schemas registered will have their fingerprint computed with this algorithm, and lookups must use a matching fingerprint.

Examples

// Create a new store with the default Rabin fingerprinting.
use arrow_avro::schema::{AvroSchema, SchemaStore};

let mut store = SchemaStore::new();
let schema = AvroSchema::new("\"string\"".to_string());
// Register the schema to get its fingerprint.
let fingerprint = store.register(schema.clone()).unwrap();
// Use the fingerprint to look up the schema.
let retrieved_schema = store.lookup(&fingerprint).cloned();
assert_eq!(retrieved_schema, Some(schema));

Fields

fingerprint_algorithm: FingerprintAlgorithm

The hashing algorithm used for generating fingerprints.

schemas: HashMap<Fingerprint, AvroSchema>

A map from a schema’s fingerprint to the schema itself.

Implementations

impl SchemaStore

pub fn new() -> Self

Creates an empty SchemaStore using the default fingerprinting algorithm (64-bit Rabin).

pub fn new_with_type(fingerprint_algorithm: FingerprintAlgorithm) -> Self

Creates an empty SchemaStore using the default fingerprinting algorithm (64-bit Rabin).

pub fn set( &mut self, fingerprint: Fingerprint, schema: AvroSchema, ) -> Result<Fingerprint, ArrowError>

Registers a schema with the store and the provided fingerprint. Note: Confluent wire format implementations should leverage this method.

A schema is set in the store, using the provided fingerprint. If a schema with the same fingerprint does not already exist in the store, the new schema is inserted. If the fingerprint already exists, the existing schema is not overwritten.

Arguments

• fingerprint - A reference to the Fingerprint of the schema to register.
• schema - The AvroSchema to register.

Returns

A Result returning the provided Fingerprint of the schema if successful, or an ArrowError on failure.

pub fn register( &mut self, schema: AvroSchema, ) -> Result<Fingerprint, ArrowError>

Registers a schema with the store and returns its fingerprint.

A fingerprint is calculated for the given schema using the store’s configured hash type. If a schema with the same fingerprint does not already exist in the store, the new schema is inserted. If the fingerprint already exists, the existing schema is not overwritten. If FingerprintAlgorithm is set to None, this method will return an error. Confluent wire format implementations should leverage the set method instead.

Arguments

• schema - The AvroSchema to register.

Returns

A Result containing the Fingerprint of the schema if successful, or an ArrowError on failure.

pub fn lookup(&self, fingerprint: &Fingerprint) -> Option<&AvroSchema>

Looks up a schema by its Fingerprint.

Arguments

• fingerprint - A reference to the Fingerprint of the schema to look up.

Returns

An Option containing a clone of the AvroSchema if found, otherwise None.

pub fn fingerprints(&self) -> Vec<Fingerprint>

Returns a Vec containing all unique Fingerprints currently held by this SchemaStore.

The order of the returned fingerprints is unspecified and should not be relied upon.

pub(crate) fn fingerprint_algorithm(&self) -> FingerprintAlgorithm

Returns the FingerprintAlgorithm used by the SchemaStore for fingerprinting.

Trait Implementations

impl Clone for SchemaStore

fn clone(&self) -> SchemaStore

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SchemaStore

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

Formats the value using the given formatter.

impl Default for SchemaStore

fn default() -> SchemaStore

Returns the “default value” for a type.

impl TryFrom<HashMap<Fingerprint, AvroSchema>> for SchemaStore

fn try_from( schemas: HashMap<Fingerprint, AvroSchema>, ) -> Result<Self, Self::Error>

Creates a SchemaStore from a HashMap of schemas. Each schema in the HashMap is registered with the new store.

type Error = ArrowError

The type returned in the event of a conversion error.