Examples

33 statements. 19 in Postgres, 14 in Databricks. Every entry parses, resolves, round-trips, and projects to the product IR. A test enforces that.

The same list drives the example picker in the report helper. Open the app with make dev and pick an entry. The filter panel fills itself from the statement.

The hard shapes

Correlated EXISTS: the outer table appears in the inner predicate. — Correlated `EXISTS`. The inner predicate reads `sales.customers.id` from the outer scope.

A CTE that feeds a join, with the CTE name in the filter heading. — A CTE feeding a join. The filter heading names the scope, `where · paid`.

A Databricks QUALIFY statement with the rank predicate as an editable row. — Databricks `QUALIFY`. The rank predicate is editable on Databricks and refused on Postgres.

A named parameter marker coloured as a parameter in the tree and the SQL. — A named parameter marker. The marker keeps its own colour and stays printable.

One panel for any query

The filter panel is not a fixed form. It walks the product IR and builds one row per predicate. A literal value gets a typed control. A comparison between two columns becomes a read-only row, because a value patch would change the meaning.

Join filters with a read-only key row and an editable boolean row. — Join predicates: one read-only key, one editable boolean.

A range control, a read-only LIKE row, and a parameter field. — A range, a read-only `LIKE`, and a parameter field in one clause.

Postgres (19)

Simple filter

postgreswhere

SELECT cust_id, status, amount
FROM sales.orders
WHERE status = 'paid'

Inner join with two predicates

postgresjoin

SELECT c.region, SUM(o.amount) AS total
FROM sales.orders o
JOIN sales.customers c ON c.id = o.cust_id AND c.active = TRUE
WHERE o.status = 'paid'
GROUP BY c.region

Three filter kinds in one WHERE

postgreswhereinbetween

SELECT id, cust_id, amount, region
FROM sales.orders
WHERE status = 'paid'
  AND amount BETWEEN 100 AND 500
  AND region IN ('EU', 'US')

Left join used as an anti join

postgresjoinnull

SELECT c.id, c.email
FROM sales.customers c
LEFT JOIN sales.orders o ON o.cust_id = c.id
WHERE o.id IS NULL

Three way join

postgresjoin

SELECT o.id, c.email, p.method, p.amount
FROM sales.orders o
JOIN sales.customers c ON c.id = o.cust_id
JOIN sales.payments p ON p.order_id = o.id AND p.amount > 0
WHERE c.region IN ('EU', 'US')

Self join for the previous order

postgresjoinwindow

SELECT curr.id, prev.id AS previous_id
FROM sales.orders curr
LEFT JOIN sales.orders prev
  ON prev.cust_id = curr.cust_id AND prev.created_at < curr.created_at
WHERE curr.status = 'open'

Correlated EXISTS

postgressubqueryexists

SELECT c.id, c.email
FROM sales.customers c
WHERE EXISTS (
  SELECT 1 FROM sales.orders o
  WHERE o.cust_id = c.id AND o.status = 'paid'
)

Correlated NOT EXISTS

postgressubqueryexists

SELECT c.id
FROM sales.customers c
WHERE NOT EXISTS (
  SELECT 1 FROM sales.orders o
  WHERE o.cust_id = c.id AND o.amount > 500
)

Scalar subquery in the projection

postgressubqueryaggregate

SELECT o.id, o.amount,
  (SELECT MAX(p.amount) FROM sales.payments p WHERE p.order_id = o.id) AS largest_payment
FROM sales.orders o
WHERE o.amount > 50

IN against a subquery

postgressubqueryin

SELECT c.id
FROM sales.customers c
WHERE c.region IN (
  SELECT r.code FROM sales.regions r WHERE r.active
)

Derived table with a filter

postgressubquery

SELECT t.cust_id, t.total
FROM (
  SELECT o.cust_id, SUM(o.amount) AS total
  FROM sales.orders o
  GROUP BY o.cust_id
) t
WHERE t.total > 1000

CTE feeding a join

postgresctejoin

WITH paid AS (
  SELECT o.cust_id, SUM(o.amount) AS total
  FROM sales.orders o
  WHERE o.status = 'paid'
  GROUP BY o.cust_id
)
SELECT c.region, COUNT(*) AS customers
FROM paid p
JOIN sales.customers c ON c.id = p.cust_id
GROUP BY c.region

Two CTEs, one joined to the other

postgresctejoin

WITH paid AS (
  SELECT cust_id, SUM(amount) AS total FROM sales.orders
  WHERE status = 'paid' GROUP BY cust_id
),
big AS (
  SELECT cust_id FROM paid WHERE total > 1000
)
SELECT c.id, c.email
FROM sales.customers c
JOIN big b ON b.cust_id = c.id
WHERE c.active

Recursive CTE over an org tree

postgrescterecursive

WITH RECURSIVE tree AS (
  SELECT id, manager_id, 1 AS depth
  FROM hr.employees
  WHERE manager_id IS NULL
  UNION ALL
  SELECT e.id, e.manager_id, t.depth + 1
  FROM hr.employees e
  JOIN tree t ON e.manager_id = t.id
)
SELECT id, depth FROM tree WHERE depth < 5

Window function with QUALIFY-free ranking

postgreswindowsubquery

SELECT id, cust_id, amount
FROM (
  SELECT id, cust_id, amount,
    ROW_NUMBER() OVER (PARTITION BY cust_id ORDER BY amount DESC) AS rn
  FROM sales.orders
) ranked
WHERE rn = 1

UNION of two branches

postgresset

SELECT cust_id FROM sales.orders WHERE status = 'paid'
UNION
SELECT cust_id FROM sales.refunds WHERE settled

BETWEEN, LIKE, and a parameter

postgreswhereparam

SELECT id, amount
FROM sales.orders
WHERE amount BETWEEN 10 AND 500
  AND email LIKE '%@example.com'
  AND status = $1

DISTINCT ON keeps the first row

postgres

SELECT DISTINCT ON (cust_id) cust_id, id, created_at
FROM sales.orders
ORDER BY cust_id, created_at DESC

LATERAL join to a top-three subquery

postgresjoinsubquery

SELECT c.id, top.id AS order_id, top.amount
FROM sales.customers c
JOIN LATERAL (
  SELECT o.id, o.amount FROM sales.orders o
  WHERE o.cust_id = c.id
  ORDER BY o.amount DESC
  LIMIT 3
) top ON TRUE
WHERE c.region = 'EU'

Databricks (14)

Simple filter

databrickswhere

SELECT cust_id, status, amount
FROM sales.orders
WHERE status = 'paid'

QUALIFY on a window function

databricksqualifywindow

SELECT city, car_model, quantity
FROM dealer
QUALIFY RANK() OVER (PARTITION BY car_model ORDER BY quantity) = 1

QUALIFY references an output alias

databricksqualify

SELECT city, car_model,
  RANK() OVER (PARTITION BY car_model ORDER BY quantity) AS rank
FROM dealer
QUALIFY rank = 1

SEMI join

databricksjoin

SELECT o.id, o.amount
FROM sales.orders o
LEFT SEMI JOIN sales.customers c ON c.id = o.cust_id
WHERE o.status = 'paid'

ANTI join

databricksjoin

SELECT c.id
FROM sales.customers c
LEFT ANTI JOIN sales.orders o ON o.cust_id = c.id

CTE with a QUALIFY step

databricksctequalify

WITH recent AS (
  SELECT cust_id, id, amount, created_at
  FROM sales.orders
  WHERE created_at >= '2026-01-01'
)
SELECT cust_id, id, amount
FROM recent
QUALIFY ROW_NUMBER() OVER (PARTITION BY cust_id ORDER BY created_at DESC) = 1

Recursive CTE with MAX RECURSION

databrickscterecursive

WITH RECURSIVE t(n) AS (
  SELECT 1
  UNION ALL
  SELECT n + 1 FROM t WHERE n < 5
)
MAX RECURSION LEVEL 10
SELECT * FROM t

Named parameter marker

databricksparam

SELECT trip_distance, fare_amount
FROM samples.nyctaxi.trips
WHERE fare_amount < :fare_parameter

Three positional markers

databricksparam

SELECT current_timestamp() + ?, ? * ? AS square

Join to a grouped subquery

databricksjoinsubquery

SELECT c.id, t.total
FROM sales.customers c
JOIN (
  SELECT cust_id, SUM(amount) AS total
  FROM sales.orders
  GROUP BY cust_id
) t ON t.cust_id = c.id
WHERE t.total > 100

Correlated EXISTS

databrickssubqueryexists

SELECT c.id
FROM sales.customers c
WHERE EXISTS (
  SELECT 1 FROM sales.orders o WHERE o.cust_id = c.id
)

Three CTE layers

databrickscte

WITH base AS (
  SELECT cust_id, amount, status FROM sales.orders
),
paid AS (
  SELECT cust_id, SUM(amount) AS total FROM base WHERE status = 'paid' GROUP BY cust_id
),
top AS (
  SELECT cust_id, total FROM paid WHERE total > 500
)
SELECT c.id, top.total
FROM sales.customers c
JOIN top ON top.cust_id = c.id

Limit the newest rows

databrickslimit

SELECT id, created_at
FROM sales.orders
WHERE status = 'open'
ORDER BY created_at DESC
LIMIT 25

Range and row limit

databrickswherebetweenlimit

SELECT id, amount
FROM sales.orders
WHERE amount BETWEEN 10 AND 250
  AND status = 'paid'
LIMIT 10

Raphael Mansuy

Author of EdgeSQL

Raphael is a data engineering and AI strategist with more than 20 years of global technology leadership experience. He works on democratizing data management and AI, and helps organizations build scalable data platforms. His work covers resilient data infrastructure, machine learning models, and coaching teams on practice. He leads a startup studio in Hong Kong.

EdgeSQL started from one observation: changing SQL with string replacement breaks as soon as two edits touch the same name. A typed tree with a preview gate is the smallest honest fix, so he built it and tested it against the official Postgres and Databricks statements.

Connect on LinkedIn Repository PyPI

Recognition

Favikon ranks Raphael at 12 in Top 20 AI Experts in France in 2026, with a Favikon Authority Score of 7,012 points. The list covers the most visible AI practitioners in France. The entry cites his 20 years of data and AI leadership, his work on scalable data platforms, and the startup studio he leads in Hong Kong.

Source: Favikon, Top 20 AI Experts in France in 2026.

The Definitive Guide to Data Integration

Packt, 2024

Unlock the power of data integration to efficiently manage, transform, and analyze data. Raphael is a co-author with Pierre-Yves Bonnefoy, Emeric Chaize, Mehdi Tazi, and Stephane Heckel.

Read it on O'Reilly

Other projects by Raphael

EdgeQuake

Graph-RAG in Rust: one binary, one Postgres, any LLM. It reads PDFs and text, builds a knowledge graph in PostgreSQL, and answers questions with sources. Six retrieval modes: naive, local, global, hybrid, mix, and bypass. Apache 2.0.

EdgeCrab

A personal and coding SuperAgent in one native Rust binary, with a ratatui terminal UI and a ReAct tool loop. It supports 24 LLM providers and 17 messaging gateways. Install with npm install -g edgecrab-cli, pip install edgecrab-cli, or cargo install edgecrab-cli.

EdgeWhisper

Voice dictation for macOS, powered by Voxtral from Mistral AI. It runs fully on the device, with no cloud and no data collection. It supports 13 languages, an Apple Silicon Mac, and macOS 14 or later.

Building something with SQL? Tell Raphael about it.

Connect on LinkedIn