MotherDuck Integrates with PlanetScale Postgres

PlanetScale PS-50

At $5 per month, the single-node PS-5 instance is an incredible value. On the 1 million row hits dataset in Clickbench, it ran in 261 seconds using the Postgres engine. Pg_duckdb was actually a tad slower, at 273 seconds (~4% slower). In MotherDuck, the benchmark queries took 11 seconds (96% faster).

While pg_duckdb alone is slower, this isn’t too surprising. DuckDB was designed to run in parallel across many CPUs, and the PS-5 instance includes 1/16th of a vCPU - economical for lightweight OLTP use cases, but not sufficient for speedups with DuckDB.

PlanetScale PS-80

Stepping up to the 10 million row hits dataset, the PS-80 instance clocked 1738 seconds via the Postgres engine and 1787 seconds on pg_duckdb (3% slower). Again, not too surprising for pg_duckdb as the PS-80 instance has only 1 vCPU.

MotherDuck completes the benchmark queries in 16 seconds, 99% faster than the Postgres engine.

PlanetScale M-320

This is where things got interesting, as we could finally run TPC-H at scale factor 10 (10 GB dataset). With 4 vCPU cores on hand, pg_duckdb was significantly faster than Postgres (70% faster), running in 858 seconds.

MotherDuck took only 13 seconds, 99.5% faster than Postgres.

So, pg_duckdb offers some real performance improvements starting with the 4 core M-320. Why not use pg_duckdb on Postgres, add DuckDB’s Iceberg extension, and bootstrap a data warehouse?

There are several major drawbacks here. Concurrency and cost stand out. DuckDB is a multi-threaded analytical engine and will quickly max out CPU when given the chance, functionally restricting you to a single query at a time and introducing replication lag during long-running queries. During testing, our Postgres replica utilization regularly looked like this:

The other concern here is cost. Our testing assumed a fixed cluster size, with benchmark datasets chosen to fit the allocated resources. This isn’t quite how application workloads operate–analytical queries are bursty and larger in scale than their transactional counterparts. PlanetScale Postgres is cost-efficient for transactional performance (you can get a Metal instance for 50 bucks!), but scaling a cluster–accounting for multiple identical replicas– to meet peak analytical load is another tier of cost.

Is this HTAP?

Well, no. But maybe yes? Consider the following query - TPC-H Query 3.

Copy code
SELECT
    l.l_orderkey,
    SUM(l.l_extendedprice * (1 - l.l_discount)) AS revenue,
    o.o_orderdate,
    o.o_shippriority
FROM top_tests.customer c -- pg table
JOIN public.tpch_orders_100m o ON c.c_custkey = o.o_custkey -- md table
JOIN public.tpch_lineitem_100m l ON l.l_orderkey = o.o_orderkey -- md table
WHERE
    c.c_mktsegment = 'BUILDING'
    AND o.o_orderdate < '1995-03-15'
    AND l.l_shipdate > '1995-03-15'
GROUP BY l.l_orderkey, o.o_orderdate, o.o_shippriority
ORDER BY revenue DESC, o.o_orderdate
LIMIT 10;

This query finds orders placed before March 15, 1995, that still have line items that hadn't shipped by that date, calculates the total revenue for each order, and ranks them. This is a classic fulfillment prioritization report: if you can only ship 10 orders today, these are the ones that matter most to your bottom line.

Now, let’s look at a simplified query plan. The query planner is smart enough to get the 300k rows it needs from Postgres, load the data into MotherDuck, and then do the rest of the heavy lifting outside your Postgres server before returning the results. Mind. Blown.

DuckScale? PlanetDuck?

Integrating MotherDuck with PlanetScale Postgres feels inevitable, in a way. Developers shouldn't have to accept tradeoffs when building for OLTP and OLAP workloads. With pg_duckdb connecting the fastest Postgres to serverless analytics on MotherDuck, you get the best of both: millisecond transactional performance where it matters, and sub-second analytical queries without maxing out your cluster or your budget.

We’re incredibly excited to let this feature fly, and we’re hard at work cooking up the next round of performance and usability improvements. Read the MotherDuck feature docs and PlanetScale documentation to get started and join our pond in MotherDuck Slack–we’d love to help get you quacking.