> ## Documentation Index
> Fetch the complete documentation index at: https://docs.omni.co/llms.txt
> Use this file to discover all available pages before exploring further.
# Join to the same table twice
> Use aliases to build tables named with language already familiar to your users.
export const categoryIcons = {
'administration': 'lock',
'api': 'terminal',
'connections': 'database',
'dashboards': 'table-columns',
'embed': 'code',
'errors': 'exclamation',
'modeling': 'wrench',
'patterns': 'plus',
'schedules & alerts': 'envelope',
'visualizations': 'chart-column',
'workbooks': 'book'
};
export const GuideSidebar = ({category, relatedLinks, updatedDate}) => {
const [progress, setProgress] = React.useState(0);
React.useEffect(() => {
const sidebar = document.querySelector('.guide-sidebar');
if (!sidebar) return;
let container = sidebar.parentElement;
while (container && !container.querySelector('.guide-header')) {
container = container.parentElement;
}
if (container && !container.classList.contains('guide-page-layout')) {
container.classList.add('guide-page-layout');
}
}, []);
React.useEffect(() => {
const handleScroll = () => {
const scrollTop = window.scrollY;
const docHeight = document.documentElement.scrollHeight - window.innerHeight;
const scrollPercent = docHeight > 0 ? scrollTop / docHeight * 100 : 0;
setProgress(Math.min(100, Math.max(0, scrollPercent)));
};
window.addEventListener('scroll', handleScroll, {
passive: true
});
handleScroll();
return () => window.removeEventListener('scroll', handleScroll);
}, []);
const icon = category ? categoryIcons[category.toLowerCase()] || 'book' : 'book';
return ;
};
export const GuideTitle = ({title}) => {
return
{title}
;
};
When modeling topics, simplicity in naming conventions is key. Aliasing table joins allows you to build out tables based on logical concepts, using language your users will recognize.
## The scenario: Buyers and sellers
In this example, we'll focus on **buyers** and **sellers**.
Our model has an `orders` table containing fields like `seller_id` and `buyer_id` and a `users` table where individual users are identified by a unique `id`:
```mermaid theme={null}
erDiagram
orders {
int buyer_id
int seller_id
}
users {
int id
}
```
To segment the `users` table into buyers and sellers, we need to join either the `buyer_id` or `seller_id` field with the `id` field in the `users` table. Essentially, our goal is to join the same tables **twice** but in **different ways** each time:
```mermaid theme={null}
erDiagram
order_items {
int buyer_id FK
int seller_id FK
}
buyers["users (as buyers)"] {
int id PK
}
sellers["users (as sellers)"] {
int id PK
}
order_items }o--|| buyers : "buyer_id = id"
order_items }o--|| sellers : "seller_id = id"
```
This is where aliasing becomes necessary. If we attempt to make both joins without aliasing, Omni will surface the following validation error in the model IDE:
```markdown wrap theme={null}
Relationship duplication: there are multiple relationships between "order_items" and "users". This may lead to surprising results. Use a different alias for one of the relationships.
```
## Implementing aliases in the relationships file
In the model's [relationships file](/modeling/relationships), we'll define two joins: one for buyers and the other for sellers.
There are three parts to defining aliased joins:
* The [`join_to_view_as` parameter](/modeling/relationships/parameters/join-to-view-as), which creates the alias for referencing the join in the modeling layer.
* The [`join_to_view_as_label` parameter](/modeling/relationships/parameters/join-to-view-as-label), which creates the label for the view in the workbook layer.
* The [`on_sql` parameter](/modeling/relationships/parameters/on-sql), which creates the join condition. **Use the alias when defining the condition** or you'll encounter errors. For example, the `buyers` alias is used as the prefix in `${order_items.buyer_id} = ${buyers.id}`.
```yaml title="buyers join" highlight={3,4,6} theme={null}
- join_from_view: order_items
join_to_view: users
join_to_view_as: buyers
join_to_view_as_label: Buyers
join_type: always_left
on_sql: ${order_items.buyer_id} = ${buyers.id}
relationship_type: assumed_many_to_one
```
```yaml title="sellers join" highlight={3,4,6} theme={null}
- join_from_view: order_items
join_to_view: users
join_to_view_as: sellers
join_to_view_as_label: Sellers
join_type: always_left
on_sql: ${order_items.seller_id} = ${sellers.id}
relationship_type: assumed_many_to_one
```