I don’t think there is a performance difference between map and tuple. But tuple, especially long tuple, is hard to remember the position of each element. So I rarely use tuples for database results.

For better maintainability, why not create relationship and use preload like this:

query = from(Child, where: [is_active: true], preload: [:parent])
children = Repo.all(query)

Enum.each(children, fn child ->
  child.name
  child.parent.logo
end)

If you have to use inner join (i.e. some child has no parent), then:

from(
  c in Child,
  join: p in assoc(c, :parent),
  where: [is_active: true]
  preload: [parent: p]
)

You can also use select to reduce the fields needed. The key point is that using struct/map is much clear than tuple.

Ecto supports selecting into a map directly. Not sure if it has any measurable performance impact vs tuples, but it is certainly more convenient than remembering the order of elements in a tuple

For the pattern matching, since you have a fixed tuple coming back why not just pattern match the tuple?

{
  parent_logo,
  parent_name,
  parent_desc,
  child_name,
  child_image,
  child_type,
  child_slug,
  child_id
} = object

Alternately, if you can modify the database, you could create a view for that query and create an Ecto schema over the view.