Struct TypeSchema 

pub struct TypeSchema {
    pub id: SchemaId,
    pub name: String,
    pub fields: Vec<FieldDef>,
    pub data_size: usize,
    pub component_types: Option<Vec<String>>,
    pub enum_info: Option<EnumInfo>,
    pub content_hash: Option<[u8; 32]>,
    /* private fields */
}

Schema describing the memory layout of a declared type

Fields

id: SchemaId

Unique schema identifier

name: String

Type name (e.g., “Candle”, “Trade”)

fields: Vec<FieldDef>

Field definitions with computed offsets

data_size: usize

Total size of the object data in bytes (excluding header)

component_types: Option<Vec<String>>

Component types (for intersection types, tracks which types were merged) Maps field name to the source type name for decomposition

enum_info: Option<EnumInfo>

Enum-specific information (if this is an enum type)

content_hash: Option<[u8; 32]>

Content hash (SHA-256) derived from structural definition. Computed lazily and cached. Skipped during serialization since it is derived.

Implementations

impl TypeSchema

pub fn from_intersection( name: impl Into<String>, schemas: &[&TypeSchema], ) -> Result<Self, SchemaError>

Create an intersection type schema by merging multiple schemas. Returns an error if any field names collide.

pub fn is_intersection(&self) -> bool

Check if this schema is an intersection type

pub fn get_component_types(&self) -> Option<&[String]>

Get the component types if this is an intersection

pub fn field_source(&self, field_name: &str) -> Option<&str>

Get the source type for a field (for decomposition)

pub fn fields_for_component(&self, component_name: &str) -> Vec<&FieldDef>

Get fields belonging to a specific component type (for decomposition)

impl TypeSchema

pub fn new( name: impl Into<String>, field_defs: Vec<(String, FieldType)>, ) -> Self

Create a new type schema with the given fields

pub fn get_field(&self, name: &str) -> Option<&FieldDef>

Get field definition by name

pub fn field_offset(&self, name: &str) -> Option<usize>

Get field offset by name (returns None if field doesn’t exist)

pub fn field_index(&self, name: &str) -> Option<u16>

Get field index by name

pub fn field_by_index(&self, index: u16) -> Option<&FieldDef>

Get field by index

pub fn field_count(&self) -> usize

Number of fields in this schema

pub fn has_field(&self, name: &str) -> bool

Check if schema has a field with the given name

pub fn field_names(&self) -> impl Iterator<Item = &str>

Iterator over field names

pub fn is_enum(&self) -> bool

Check if this schema is for an enum type

pub fn get_enum_info(&self) -> Option<&EnumInfo>

Get enum info if this is an enum type

pub fn variant_id(&self, variant_name: &str) -> Option<u16>

Get variant ID by name (for enum types)

pub fn new_enum(name: impl Into<String>, variants: Vec<EnumVariantInfo>) -> Self

Create an enum schema with variant information

Layout:

• Field 0: __variant (I64) - variant discriminator at offset 0
• Field 1+: __payload_N (Any) - payload fields at offset 8, 16, etc.

pub fn compute_content_hash(&self) -> [u8; 32]

Compute the content hash (SHA-256) from the structural definition.

The hash is derived deterministically from:

• The type name
• Fields sorted by name, each contributing field name + field type string
• Enum variant info (if present), sorted by variant name

For recursive type references (Object("Foo")), only the type name is hashed to avoid infinite recursion.

pub fn content_hash(&mut self) -> [u8; 32]

Return the cached content hash, computing and caching it if needed.

pub fn bind_to_arrow_schema( &self, arrow_schema: &ArrowSchema, ) -> Result<TypeBinding, TypeBindingError>

Bind this TypeSchema to an Arrow schema, producing a TypeBinding.

Validates that every field in the TypeSchema has a compatible column in the Arrow schema. Returns a mapping from TypeSchema field index → Arrow column index.

pub fn from_canonical(canonical: &CanonicalType) -> Self

Create a type schema from a canonical type (for evolved types)

This converts the semantic CanonicalType representation into a JIT-ready TypeSchema with proper field offsets and types.

Trait Implementations

impl Clone for TypeSchema

fn clone(&self) -> TypeSchema

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypeSchema

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TypeSchema

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TypeSchema

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

where __S: Serializer,

Serialize this value into the given Serde serializer.