Struct RelationBuilder 

pub struct RelationBuilder<E>
where
    E: Entity + Clone + Send + Sync,
{ /* private fields */ }

Builder for loading relationships on entities

This builder provides a fluent API for loading relationships with automatic batching to prevent N+1 queries.

Example

use ormkit::relations::{RelationBuilder, BelongsTo, Loaded};

// Load users for posts
let posts_with_users = RelationBuilder::for_entities(posts)
    .load::<User>(&pool)
    .await?;

for post_with_user in posts_with_users {
    let post = post_with_user.entity();
    let user = post_with_user.relation();
    println!("Post: {:?}, User: {:?}", post, user);
}

Implementations

impl<E> RelationBuilder<E>

where E: Entity + Clone + Send + Sync,

pub fn for_entities(entities: Vec<E>) -> Self

Create a new RelationBuilder for the given entities

Arguments

• entities - The entities to load relationships for

pub fn with_strategy(self, strategy: LoadStrategy) -> Self

Set the loading strategy

Arguments

• strategy - The loading strategy to use

pub async fn load_belongs_to<P>( self, pool: &PgPool, ) -> Result<Vec<Loaded<E, Option<P>>>, LoadError>

where E: BelongsTo<P>, P: Entity + Debug + Clone + for<'r> FromRow<'r, PgRow> + Send + Unpin,

Load a BelongsTo relationship

Type Parameters

• P - The parent entity type

Arguments

• pool - The database connection pool

Returns

A vector of entities with loaded parent relationships

pub async fn load_has_many<C>( self, pool: &PgPool, ) -> Result<Vec<Loaded<E, HasManyLoaded<C>>>, LoadError>

where E: HasMany<C>, C: Entity + Debug + Clone + for<'r> FromRow<'r, PgRow> + Send + Unpin,

Load a HasMany relationship

Type Parameters

• C - The child entity type

Arguments

• pool - The database connection pool

Returns

A vector of entities with loaded children relationships

pub async fn load<P>( self, pool: &PgPool, ) -> Result<Vec<Loaded<E, Option<P>>>, LoadError>

where E: BelongsTo<P>, P: Entity + Debug + Clone + for<'r> FromRow<'r, PgRow> + Send + Unpin,

Generic load method that infers the relationship type

This is a convenience method that attempts to infer the relationship type based on the trait bounds