How do you approach SQL: Customers Who Placed Orders (INNER JOIN)?

INNER JOIN on customer_id, then SELECT DISTINCT name.

What are common mistakes on SQL: Customers Who Placed Orders (INNER JOIN)?

Filtering on an aggregate in WHERE rather than HAVING. An inner join where a left join is meant, which silently drops the rows the question was about - the customers with zero orders. COUNT(*) versus COUNT(column). The second skips nulls, and that difference is often the entire question.

gitGood.dev

← Back to problems

SQL: Customers Who Placed Orders (INNER JOIN)

EasyDatabases

Description

> This problem is paper-only - see explanation for the canonical SQL solution. The auto-grader validates an in-memory simulation that produces the same result an INNER JOIN would. Given two tables: ``` Customers(id, name) Orders(id, customer_id, total) ``` Return the **distinct names of customers who have placed at least one order**, sorted alphabetically. **For the auto-grader:** implement `customersWithOrders(customers, orders)` where each list contains plain objects matching the schema. Return a sorted array of customer names.

Example 1

Input: customers = [{id:1,name:"Alice"},{id:2,name:"Bob"},{id:3,name:"Cleo"}], orders = [{id:10,customer_id:1,total:50},{id:11,customer_id:1,total:25},{id:12,customer_id:3,total:99}]

Output: ["Alice","Cleo"]

Explanation: Bob has no orders so he is excluded. Alice has two orders but appears only once.

Constraints

- 0 <= customers.length <= 10^4 - 0 <= orders.length <= 10^4 - Customer ids are unique. Some orders may reference missing customers (treat as no-match). - Names are unique per customer id.

SQL: Customers Who Placed Orders (INNER JOIN): approach, complexity and pitfalls

An easy sql problem, graded against 4 test cases (2 of them hidden).

The pattern: SQL

Query-writing problems - joins, aggregation, window functions, and query tuning.

Reach for it when you see: A schema and a question about the data rather than a function signature.

More SQLproblems →

If you are stuck

Show the 2-step hint ladder

INNER JOIN on customer_id, then SELECT DISTINCT name.
In the simulation: build a Set of customer_ids that have at least one order, then filter customers and dedupe names.

The optimal approach

Show the approach: Canonical SQL (ANSI):

```sql

SELECT DISTINCT c.name

FROM Customers c

INNER JOIN Orders o ON o.customer_id = c.id

ORDER BY c.name;

```

`INNER JOIN` keeps only rows where a match exists in both tables. `DISTINCT` drops duplicates from customers with multiple orders.

Why paper-only: the gitGood sandbox does not run a SQL engine. The simulation produces the same result so you can verify your filter + dedupe + sort logic. In an interview, write the SQL.

Edge cases: customers with no orders are dropped. Orders pointing at missing customer ids contribute nothing. Empty input on either side returns `[]`.

The full reference solution in every supported language stays in the editor above - reveal it there once you have had a real attempt.

What the tests check

Read off this problem's own test suite, so these are the cases a submission actually has to survive.

Empty input. At least one case passes an empty collection. Make sure your loop bounds and any "first element" read survive a length of zero.
Single element. A one-element case is included. Two-pointer and window solutions frequently return the wrong thing when the two indices start out equal.

Common SQL mistakes

These apply to the pattern as a whole, not just this problem.

Filtering on an aggregate in `WHERE` rather than `HAVING`.
An inner join where a left join is meant, which silently drops the rows the question was about - the customers with zero orders.
`COUNT(*)` versus `COUNT(column)`. The second skips nulls, and that difference is often the entire question.