---
title: "SQL Golf: Lessons from Quackmas 2025"
canonical: "https://motherduck.com/blog/its-a-sql-golf-quackmas/"
related:
  - title: "Can you crack the case? Solve SQL puzzles in the Christmas Heist challenge and compete for prizes. The clock is ticking."
    url: "https://motherduck.com/blog/quackmas2025/"
  - title: "Prompting? That’s so 2024. Welcome to Quack-to-SQL."
    url: "https://motherduck.com/blog/quacktosql/"
  - title: "Why you should learn SQL in 2024"
    url: "https://motherduck.com/blog/why-learn-sql-in-2024/"
gated_asset:
  title: "Postgres Is Full: A Field Guide to Analytics at Scale"
  url: "https://motherduck.com/lp/postgres-analytics-guide-full/"
---

# SQL Golf: Lessons from Quackmas 2025

Here's a question: *Just how short can you write a SQL query?*

How about the query "How many volunteers have 7 or more years of experience?"

You can do it in just 36 characters.

```sql
select sum(#6>6)from volunteer_ducks
```

If that looks cursed, you're not alone. And if you've seen worse, you're probably an excel user. Either way, it returns the correct answer. Last month, a bunch of people spent their holidays writing queries exactly like this.

![Screenshot 2026-01-13 at 3.04.38 PM.png](https://motherduck-com-web-prod.s3.us-east-1.amazonaws.com/assets/img/Screenshot_2026_01_13_at_3_04_38_PM_c3e68a4af8.png)

## How we got here

We launched the [Quackmas 2025 Christmas Heist Challenge](https://motherduck.com/blog/quackmas2025/) on DBQuacks—15 SQL puzzles where you solve a mystery involving missing presents, suspicious volunteers, and millions of GPS coordinates. Hundreds of people competed for prizes.

But a subset of players took on a different challenge: **SQL golf**. The goal? Solve each puzzle with the shortest possible query.

The results were... interesting. Winning solutions ranged from 36 characters (Challenge 2) to 187 characters (Challenge 4, which required spatial joins across three tables). Along the way, our golfers discovered techniques that are equal parts clever, cursed, and (rarely) actually useful.

Let me show you what they found.

## The basics: every character counts

### Column position references

Here's the single biggest trick in SQL golf. Instead of writing column names, DuckDB lets you reference columns by position using `#N`:

```sql
-- Normal SQL
select sum(missing_count) from missing_presents_report

-- Golf SQL
-- `missing_count` is the 5th column in the table `missing_presents_report`
select sum(#5)from missing_presents_report
```

That's 11 characters saved just on the column name (`missing_count` → `#5`). The winning Challenge 1 solution came in at 42 characters. Would I do this in production? Absolutely not. Does it work for golf? Unfortunately yes.

### Whitespace elimination

SQL doesn't actually require spaces in most places:

```sql
-- Readable
select sum(#5) from missing_presents_report

-- Golfed
select sum(#5)from missing_presents_report
```

The golfers stripped every optional space. `where#1=#10` instead of `where #1 = #10`. Your linter would hate this. But we are golfing!

### count() without arguments

DuckDB accepts `count()` as equivalent to `count(*)`. Two characters saved. In golf, that matters.

## Boolean math: the trick that makes you feel smart

Challenge 2 asked: *Count how many volunteers have an experience_level of 7 or higher.*

The normal approach (64 characters):

```sql
select count(*) from volunteer_ducks where experience_level >= 7
```

Partially golfed:

```sql
select count()from volunteer_ducks where #6>=7
```

The winning solution (36 characters):

```sql
select sum(#6>6)from volunteer_ducks
```

Wait, what?

Here's the trick: in DuckDB, `true` evaluates to `1` and `false` to `0`. So `sum(#6>6)` counts rows where the condition is true. No `WHERE` clause needed. This reminds me of my favorite Excel Formula, [SUMPRODUCT](https://support.microsoft.com/en-us/office/sumproduct-function-16753e75-9f68-4874-94ac-4d2145a2fd2e). 

And notice: `#6>6` instead of `#6>=7`. Both mean "7 or higher," but `>6` saves one character. This is the kind of thing you think about 3 red bulls in during a code golf competition.

## The mode() trick: replacing three clauses with one function

Challenge 3 asked: *Find the district with the most theft reports.* The traditional approach:

```sql
select district
from duck_households h
join missing_presents_report r on h.household_id = r.household_id
group by district
order by count(*) desc
limit 1
```

That's a lot of SQL for "give me the most common value."

The golf solution:

```sql
select mode(#3)from
duck_households,missing_presents_report
where#1=#10
```

71 characters. DuckDB's `mode()` aggregate returns the most frequent value, replacing `GROUP BY`, `ORDER BY`, and `LIMIT 1` in one function call.

This pattern showed up in Challenges 3, 10, 13, and 14. Anytime you need "the most common X," `mode()` is your answer. This one's actually useful in real life too.

## Join golf: comma syntax is back

Remember learning about comma joins in SQL-89 and then being told never to use them? Turns out they're great for golf.

Every multi-table query in the winning solutions used comma joins. Here's Challenge 7, which asked for the total weight of all missing presents (75 characters):

```sql
-- Standard JOIN
select sum(m.missing_count * p.weight_kg)
from missing_presents_report m
join present_inventory p on m.present_type = p.present_type

-- Winning solution
select sum(#5*#13)from
missing_presents_report,present_inventory where#3=#8
```

The comma syntax with a `WHERE` clause is semantically equivalent to `INNER JOIN ... ON`. Combined with column position references, join conditions shrink dramatically.

Again, is this readable? No. Does it produce the same query plan? Yes.

## DuckDB shortcuts you might not know about

### FROM-first syntax

DuckDB lets you start queries with `FROM` and skip `SELECT *`:

```sql
-- Standard
select * from deliveries_log where success = true

-- DuckDB
from deliveries_log where success
```

Challenge 9 asked: *Find all volunteers who rank #1 in at least one district, then count all their deliveries.* The winning solution (104 characters) used FROM-first inside a subquery:

```sql
select sum(1)from(from
deliveries_log,duck_households
where#2=#8 QUALIFY#3=mode(#3)over(partition by#10))
```

The `(from table,table where...)` pattern creates a derived table without writing `SELECT *`. I didn't know you could nest `from` like this until I saw it in the competition, and maybe I wish I hadn't at all.

### QUALIFY: filtering without subqueries

`QUALIFY` filters results after window functions run, so you don't need a wrapping subquery:

```sql
-- Without QUALIFY
select * from (
  select *, rank() over (partition by district order by deliveries desc) as rnk
  from summary
) where rnk = 1

-- With QUALIFY
from summary
qualify rank() over (partition by district order by deliveries desc) = 1
```

This one's legitimately useful in production. Window functions are great, but wrapping them in subqueries just to filter is annoying.

## The subtraction trick: my favorite solution

Challenge 6 asked: *Count how many 5-minute periods in December 2025 have no security checkpoint activity for Coach Waddles (duck_id = 1).*

The hint suggested using `GENERATE_SERIES` to create a date spine. The obvious approach: generate all 8,928 five-minute slots, then find the gaps.

```sql
with slots as (
  select generate_series as slot
  from generate_series(
    '2025-12-01'::timestamp,
    '2025-12-31 23:55'::timestamp,
    interval '5 minutes'
  )
)
select count(*)
from slots s
left join dbquacks_xmas.security_checkpoint_events e
  on date_trunc('5 minutes', e.timestamp) = s.slot and e.duck_id = 1
where e.timestamp is null
```

The golf solution (102 characters) flipped the problem entirely:

```sql
select 8928-count(distinct epoch(#2)::int//300)from
dbquacks_xmas.security_checkpoint_events where#3=1
```

Instead of generating all 8,928 slots (31 days × 24 hours × 12 per hour), the golfer:

1. Counted distinct 5-minute buckets that *have* activity using `epoch(timestamp)::int//300`
2. Subtracted from 8,928

The `//300` converts epoch seconds to 5-minute bucket IDs via integer division. No date spine needed.

This is legitimately elegant. I've used this pattern since to count gaps in time series data. Sometimes golf teaches you something.

## The final leaderboard

Here's every winning query. Yes, they're all cursed.

**Challenge 1: The Missing Presents Report (42 chars)**
```sql
select sum(#5)from missing_presents_report
```

**Challenge 2: The Suspect Pool (36 chars)**
```sql
select sum(#6>6)from volunteer_ducks
```

**Challenge 3: The Pattern Emerges (71 chars)**
```sql
select mode(#3)from
duck_households,missing_presents_report
where#1=#10
```

**Challenge 4: The GPS Surveillance Net (187 chars)**
```sql
select mode(#18)from
x:dbquacks_xmas.gps_tracking_events,deliveries_log,duck_households
where#3=#9and#10=#16and
ST_Distance(st_point(x.latitude,x.longitude),st_point(45.52,-122.68))<=3000
```

**Challenge 5: Searching the Evidence Logs (66 chars)**
```sql
select sum(#3ilike'%ano%'or#3ilike'%sec%')from delivery_activities
```

**Challenge 6: The Security System Deep Dive (102 chars)**
```sql
select 8928-count(distinct epoch(#2)::int//300)from
dbquacks_xmas.security_checkpoint_events where#3=1
```

**Challenge 7: The Weighted Evidence (75 chars)**
```sql
select sum(#5*#13)from
missing_presents_report,present_inventory where#3=#8
```

**Challenge 8: Weather Forensics at Scale (155 chars)**
```sql
select max(#30)from
dbquacks_xmas.gps_tracking_events,deliveries_log,duck_households,dbquacks_xmas.weather_reports
where#3=#9and#10=#16and#18=#26and#4<=#25
```

**Challenge 9: The Elite Performers (104 chars)**
```sql
select sum(1)from(from
deliveries_log,duck_households
where#2=#8QUALIFY#3=mode(#3)over(partition by#10))
```

**Challenge 10: Multi-Checkpoint Access Patterns (87 chars)**
```sql
select mode(#9)from
dbquacks_xmas.security_checkpoint_events,volunteer_ducks
where#3=#8
```

**Challenge 11: Package Chain of Custody (146 chars)**
```sql
with recursive p as(from dbquacks_xmas.package_tracking_events),t
as(select i:186union select#2from p,t
where#7=i)select count()from p,t where#2=i
```

**Challenge 12: GPS Breadcrumb Trail Analysis (107 chars)**
```sql
select max(#1)from(select
epoch(#4-lag(#4)over())from
dbquacks_xmas.gps_tracking_events
where month(#4)=12)
```

**Challenge 13: The Secret Route (69 chars)**
```sql
select mode(#10)from deliveries_log,duck_households where#2=#8and#3=1
```

**Challenge 14: Telemetry Data Mining at Scale (113 chars)**
```sql
select mode(#10)from
dbquacks_xmas.package_tracking_events,volunteer_ducks
where#6=#9and(#8::json).temperature>10
```

**Challenge 15: The Christmas Miracle Revealed (133 chars)**
```sql
select sum(#14='low'and(delivery_metadata::json->>'program')='secret_santa')from
deliveries_log,duck_households
where#2=#8and
success
```

---

**Total: 1,438 characters to solve all 15 challenges.**

## Should you golf in production?

No. Your future self (and probably your coworkers) will hate you.

Column position references break when schemas change. Whitespace removal makes queries unreadable. Boolean math obscures intent. This is all terrible for maintainability.

But SQL golf is a great way to:

- **Learn DuckDB features you didn't know existed**:`mode()`, `QUALIFY`, and `FROM`-first syntax are genuinely useful
- **Think about problems differently**: the subtraction trick in Challenge 6 is elegant regardless of character count
- **Appreciate readable SQL**: nothing makes you value linting like debugging `select sum(#5*#13)from a,b where#3=#8`

## Try it yourself

The Christmas Heist challenges are still available on [DBQuacks](https://dbquacks.com/challenges?series=christmas). Think you can beat these scores? Share your attempts in the [MotherDuck Community Slack](https://community.motherduck.com/).

Thanks to everyone who participated in Quackmas 2025. Your willingness to write gloriously unreadable SQL made this a blast.

See you next year.