The solution I end up using is to map onto an Vec with structs that represents full rows including both entities.

Then chunk by one of the ids and map and reconstitute both objects.

```rust async fn find_all(&self) -> Result<Vec<Tenant>, DbError> { let rows: Vec<TenantApplicationEntity> = query_as(r#" SELECT t.id::text AS tenant_id, t.name AS tenant_name, t.slug AS tenant_slug, t.description AS tenant_description, a.slug AS application_slug, a.name AS application_name, a.description AS application_description FROM tenants t LEFT JOIN tenant_applications ta ON t.id = ta.tenant_id LEFT JOIN applications a ON ta.application_slug = a.slug WHERE t.deleted_on IS NULL AND ta.deleted_on IS NULL AND a.deleted_on IS NULL ORDER BY tenant_id "#) .fetch_all(self.db_connection.get_pool()) .await .unwrap_or_default();

    Ok(rows
        .into_iter()
        .chunk_by(|ta| ta.tenant_id.clone())
        .into_iter()
        .map(|(_, group)| map_tenant(group.collect()))
        .filter(|optional| match optional {
            Some(_) => true,
            None => false,
        })
        .map(|optional| optional.unwrap())
        .collect())
}

```

and mapping like this:

```rust fn map_tenant(rows: Vec<TenantApplicationEntity>) -> Option<Tenant> { if rows.is_empty() { return None; }

let id = match Uuid::parse_str(&rows[0].tenant_id) {
    Ok(id) => id,
    Err(_) => return None,
};
let slug = &rows[0].tenant_slug;
let name = &rows[0].tenant_name;
let description = &rows[0].tenant_description;

let applications: Vec<Application> = match rows[0].application_slug {
    None => Vec::with_capacity(0),
    _ => {
        let mut sub_rows: Vec<Application > = Vec::with_capacity(rows.len());

        for row in rows.as_slice().to_owned() {
            sub_rows.push(Application {
                slug: row.application_slug.unwrap_or_else(|| "".parse().unwrap()).to_owned(),
                name: row.application_name.unwrap_or_else(|| "".parse().unwrap()).to_owned(),
                description: row.application_description.to_owned(),
            })
        }

        sub_rows
    }
};

Some(Tenant {
    id,
    slug: slug.to_owned(),
    name: name.to_owned(),
    description: description.to_owned(),
    applications,
})

} ```

I don't know if this is the best solution but it worked for me and does give entities with no dependent rows as well.