Struct orma::JoinBuilder

pub struct JoinBuilder<'a, A, B> where
    A: DbData + Serialize + DeserializeOwned,
    B: DbData + Serialize + DeserializeOwned,  { /* fields omitted */ }

This is the builder for a DbJoin If you need to relate two different entities, DbJoin<DbData> is used to get entities related to the specified DbData.
You need to use JoinBuilder to create a DbJoin relation, and you can define both simple joins and table joins for M to N relations.

Simple join example:

async fn office_users(
    user: &DbEntity<Office>,
    db_conn: &Connection,
) -> Result<DbJoin<User>, DbError> {
    JoinBuilder::new(user)
        .with_source_fk("id_office")
        .with_target(User::table_name())
        .with_sorting(&["data->>'name'"])
        .build(db_conn)
        .await
}

M to N join example:

async fn user_groups(
    user: &DbEntity<User>,
    db_conn: &Connection,
) -> Result<DbJoin<Group>, DbError> {
    JoinBuilder::new(user)
        .with_join_table("intrared.r_user_group", "id_user", "id_group")
        .with_target(Group::table_name())
        .with_sorting(&["data->>'name'"])
        .build(db_conn)
        .await
}

Methods

impl<'a, A, B> JoinBuilder<'a, A, B> where
    A: DbData + Serialize + DeserializeOwned,
    B: DbData + Serialize + DeserializeOwned, 

pub fn new(source: &'a DbEntity<A>) -> Self

Defines the source DbEntity of the DbJoin

pub fn with_target(self, target_table: &'a str) -> Self

Provides the name of the table where DbJoin items are mapped to

pub fn with_source_fk(self, source_fk: &'a str) -> Self

The name of the source foreign key in the items table when you want to represents a simple join ( 1 to n )

pub fn with_join_table(
    self,
    join_table: &'a str,
    source_fk: &'a str,
    items_fk: &'a str
) -> Self

If you want to map a m2n join, you provide the name of the db table with name of the source foreign key and the foreign key of the items table

pub fn with_sorting(self, sorting: &'a [&'a str]) -> Self

DbJoin sorting attribute used to provide a sorting method on data fetching.

vec!["data->>'first_name'", "data->>'last_name' DESC"];

pub async fn build<'_>(
    &'_ self,
    conn: &'a Connection
) -> Result<DbJoin<B>, DbError>

Creates the DbJoin object and fetches the data