Concat

Concat merges the current dataset with one other table from any connected integration. Three modes: Vertical stacks rows (union), Horizontal joins columns on the names the two tables share, Diagonal stacks rows while keeping every column from both tables. Always exactly two tables -- to combine three or more, chain multiple Concat steps one after another, using the result of each as the input to the next. Duplicate handling is configurable before saving.

The source table can come from a different database or integration than the current pipeline source. No need to land both datasets in a shared warehouse first.

When to Use Concat

• Stack regional tables. Vertical concat orders_na and orders_eu into a single orders dataset for global reporting.
• Combine attribute tables. Horizontal concat a transaction table with a metadata table that shares a key column such as order_id, joining on that shared name.
• Append new data. Vertical concat last month's orders into the current dataset to extend the time range.
• Keep every column from two overlapping-but-different sources. Diagonal concat two tables with mostly the same schema but a few extra columns on each side, filling the gaps with null instead of dropping columns.

Sample Dataset

The examples in this doc use three sample datasets. Download all three to follow along in your own workspace.

Concat Types

How to Apply Concat

Schema Differences

Vertical and Diagonal

Vertical keeps only the columns the two tables share by name; any column present on just one side is dropped. A shared column with a different data type widens automatically (for example integer and float become float) -- this never blocks the concat unless you turn on Strict mode, which requires the two tables' schemas to match exactly and fails with a clear error on any mismatch instead.

Diagonal keeps every column from both tables. A column missing from one side is filled with null in that table's rows. A shared column with a different data type always widens automatically, Diagonal has no Strict option.

Horizontal

Horizontal joins the two tables on every column name they have in common, not by row position. At least one shared column is required. The Join Type you pick determines which rows survive:

Before and After

Vertical concat

Concat edilitics_sample_orders (500 rows, 13 columns) with edilitics_sample_orders_h2 (250 rows, 15 columns) on Vertical. H2 has two extra columns (return_flag, delivery_partner) not present in H1 -- these are dropped automatically since Vertical keeps only shared columns. Manage Duplicates: Keep All.

Input (current dataset): 500 rows, 13 columns (order_id, customer_name, email, sales_rep, region, product_id, order_date, delivery_date, revenue, units_sold, discount_pct, product_tier, metadata, notes)

Second table: 250 rows, 15 columns (same 13 + return_flag, delivery_partner)

Output: 750 rows, 13 columns (return_flag and delivery_partner dropped)

Horizontal concat

Concat edilitics_sample_orders (500 rows) with edilitics_sample_products (4 rows) on product_id, Join Type Left: every order row is kept, product columns are filled in where product_id matches, and left null where it doesn't.

Output: 500 rows, 13 + 6 columns (13 from orders, 6 new from products, product_id shared)

Code Equivalent

-- Vertical concat (PostgreSQL / BigQuery / Snowflake / DuckDB)
SELECT * FROM orders_q1
UNION ALL
SELECT * FROM orders_q2;

-- Vertical concat with deduplication (keep first)
SELECT DISTINCT ON (order_id) *
FROM (
  SELECT * FROM orders_q1
  UNION ALL
  SELECT * FROM orders_q2
) combined
ORDER BY order_id;

-- Horizontal concat (join on a shared column)
SELECT a.*, b.category, b.supplier
FROM orders a
LEFT JOIN products b ON a.product_id = b.product_id;

import polars as pl

# Vertical: keep only shared columns, widen dtype mismatches safely
df_combined = pl.concat([df_q1, df_q2], how="vertical_relaxed")

# Vertical, strict: exact schema match required, errors otherwise
df_combined = pl.concat([df_q1, df_q2], how="vertical")

# Deduplicate after concat
df_combined = df_combined.unique(keep="first")

# Horizontal: join on every shared column name, Left/Right/Inner/Full
df_wide = pl.concat([df_orders, df_products], how="align_left")

# Diagonal: stack rows, union columns, widen/null-fill mismatches
df_diag = pl.concat([df_a, df_b], how="diagonal_relaxed")

Operation Reference

Frequently Asked Questions

Next Steps

Need help? Email support@edilitics.com with your workspace, job ID, and context. We reply within one business day.