You know the feeling. You’ve spent weeks perfecting a complex analytical query in DuckDB — window functions, recursive CTEs, all the good stuff. Then your boss says, ‘We need to run this on Snowflake.’ Suddenly your weekend is gone, rewriting LIST_AGG into LISTAGG, debugging predicate pushdown, and praying you didn’t miss a semicolon.
It’s a nightmare. And it’s entirely unnecessary.
A team just shipped a tool that lets you write DuckDB SQL once and run it against any database — with full predicate pushdown, joins, and all the optimizations you’d expect from a native query. No data movement. No ETL. No dialect translation hell.
Here’s the twist: this isn’t about making DuckDB a better local database. It’s about turning DuckDB from an execution engine into a universal query planner. Your DuckDB syntax becomes the source of truth. The actual compute happens entirely on the remote database — PostgreSQL, MySQL, BigQuery, whatever. DuckDB just figures out how to speak their language.
Think about what that means. You can standardize your entire data infrastructure on one SQL dialect without migrating a single table. No more context-switching between Snowflake’s quirks and Redshift’s legacy. No more hiring specialists for each database. Just one language, everywhere.
This is the kind of thing that sounds too good to be true. And you should be skeptical. But the key insight is predicate pushdown: the transpiler doesn’t just translate syntax — it pushes filters, joins, and aggregations down to the target database so you’re not pulling all the data into DuckDB. The performance stays native.
I’ve seen this firsthand. A data engineer at a fintech company used it to unify queries across 12 different databases. He said it was the first time in years he could write a query and trust it would work the same way everywhere. No more ‘it works on my machine’ — or more accurately, ‘it works on my DuckDB but not on the warehouse.’
Now, the obvious question: why not just use a query federation tool like Presto or Trino? Those are great, but they introduce a new execution layer. This transpiler keeps the execution where it belongs — on the database that already has the data and the indexes. It’s a thinner layer, less to break, less to tune.
Of course, there are limits. Not every DuckDB function has a direct equivalent in every database. But the team is building a fallback system that handles the edge cases. And the open-source community is already contributing patches.
Here’s the bottom line: the era of being locked into a single database vendor’s SQL dialect is over. You can keep your existing infrastructure, keep your data in place, and still get the expressive power of DuckDB’s SQL. The only thing that changes is how you write your queries — and that’s the best kind of change.
So go ahead. Write that PIVOT query. Use QUALIFY. Stop worrying about which database you’re hitting. DuckDB just became the universal language of data. And nobody noticed.
FAQ
Q: Does this transpiler really handle all DuckDB features, or are there gaps?
A: It handles the vast majority of common analytical queries, including window functions, CTEs, joins, and aggregations. Some exotic functions may not have direct equivalents, but the team provides fallback mechanisms and the community is actively filling gaps.
Q: What's the practical benefit for a data team already using a single warehouse?
A: If you're standardized on one warehouse, the benefit is less obvious. But for teams with multiple databases (e.g., legacy, cloud, on-prem), it eliminates the need to rewrite queries for each dialect. It also allows you to gradually adopt DuckDB's advanced features without migrating.
Q: Isn't it better to just learn the native SQL dialect of each database and avoid an extra layer?
A: In theory, yes. In practice, native dialects are inconsistent, quirky, and often missing modern features. DuckDB's SQL is cleaner and more powerful. The transpiler is a thin layer that removes the friction without adding overhead. You gain productivity without sacrificing performance.