Struct Model 

pub struct Model {
    pub id: ModelId,
    pub table: TableId,
    pub columns: Vec<ColumnId>,
    pub fields: Vec<Field>,
    pub model_to_table: ExprRecord,
    pub table_to_model: TableToModel,
}

Defines the bidirectional mapping between a single model and its backing table.

This struct contains the expression templates used during lowering to translate between model-level field references and table-level column references. The mapping supports scenarios where field names differ from column names, where type conversions are required (e.g., Id<T> to String), and where multiple models share a single table.

Fields

id: ModelId

The model this mapping applies to.

table: TableId

The database table that stores this model’s data.

columns: Vec<ColumnId>

Ordered list of columns that comprise this model’s storage representation.

The order corresponds to the model_to_table expression record: the i-th expression in model_to_table produces the value for the i-th column here.

fields: Vec<Field>

Per-field mappings.

Indexed by field index within the model. Primitive fields and embedded fields have their respective mappings, while relation fields use Field::Relation since they don’t map directly to columns.

model_to_table: ExprRecord

Expression template for converting model field values to table column values.

Used during INSERT and UPDATE lowering. Each expression in the record references model fields (via Expr::Reference) and produces a column value. May include type casts (e.g., Id<T> to String) or concatenations for discriminated storage formats.

table_to_model: TableToModel

Expression template for converting table column values to model field values.

Used during SELECT lowering to construct the RETURNING clause. Each expression references table columns (via Expr::Reference) and produces a model field value. Relation fields are initialized to Null and replaced with subqueries when include() is used.

Implementations

impl Model

pub fn resolve_field_mapping(&self, projection: &Projection) -> Option<&Field>

Resolves a projection to the corresponding field mapping.

Handles both single-step projections (primitive/embedded fields) and multi-step projections (nested embedded struct fields). Supports arbitrary nesting depth.

Examples

• [2] → field at index 2 (primitive or embedded)
• [2, 1] → embedded field at index 2, subfield at index 1
• [2, 1, 0] → nested embedded field at index 2, subfield 1, sub-subfield 0

Returns

Returns Some(&Field) if the projection is valid. The field can be:

• Field::Primitive for partial updates to a specific primitive
• Field::Struct for full replacement of an embedded struct

Returns None if the projection is invalid or points to a relation field.

Trait Implementations

impl Clone for Model

fn clone(&self) -> Model

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Model

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

Formats the value using the given formatter.