// data lakes and query engines · 20 November 2026 · 5 min read
Trino vs StarRocks vs Doris on an Azure Iceberg lake
Same tables, same machine, same six questions. One engine was fastest, one was most familiar, and one couldn’t read the files at all.
On an Iceberg lake in Azure, the engine that reads your data is a choice you can test in an afternoon. I ran Trino, StarRocks and Apache Doris against the same tables and the same questions. StarRocks was the fastest without any tuning. Trino got close only after I built two fixes around it. Doris connected, listed every table, and then failed on the first read, for a reason worth knowing before you pick an engine on Azure.
The setup
The data is CRM and accounting records in Iceberg tables on Azure storage (ADLS), written by an ingestion service I don’t control. Iceberg keeps each table as data files plus a small metadata file saying which files are current. A hosted Polaris catalog, reached over a REST API with OAuth, keeps the pointer to each table’s current metadata file. Every engine had to go through that catalog for the pointers and then read the files with the virtual machine’s managed identity (the VM’s own Azure login, no passwords or keys in config files).
Each engine ran alone on the same small VM, 2 CPUs and 3.8 GB of RAM, with the others stopped. The questions came from an AI agent that answers business questions. Three are small, each joining 4 CRM tables: top billing city by won revenue, win rate by year, and accounts that won in one year but not the next. Three are big, over an accounting ledger built from 25 tables: P&L by month, balance by account, and income in one month.

Same lake, same login, same questions: two engines read it, one stopped at the files.
Trino: the standard, once you fix the lookups
Trino read everything on the first try, and it’s the engine most people reach for on a lake. Out of the box it was slow here: about 1.2 to 3.3 seconds for a small question and 22 to 28 seconds for a big one.
Most of that wasn’t reading data. Trino asks the REST catalog about every table in every query and keeps no memory of the answer between queries. Moving those pointers into a local Postgres catalog took the small questions to 0.35 to 0.6 seconds and the big ones to 15 to 17. Building the ledger in advance as one ready table took the big questions to about 0.2 seconds. I wrote up the whole Trino story separately.
So Trino can be fast. It just needs you to build and run those two extras.
StarRocks: fastest with nothing extra
StarRocks connected to the same catalog with the same managed identity on the first try. The catalog definition was ordinary: REST type, OAuth credential and scope, plus three Azure settings for the identity (azure.adls2.oauth2_use_managed_identity, the tenant ID and the identity's client ID), all covered in StarRocks' Azure authentication docs. If you don't have the tenant ID handy, the storage account's own "please sign in" reply to an anonymous request contains it.
With none of the Trino fixes, small questions took 0.4 to 0.7 seconds (one outlier at 1.5) and the big ones 6.8 to 10.4. That’s about as fast as Trino with its local catalog on small questions, and about twice as fast on big ones. Every answer matched Trino’s, the accounting totals to the cent.
I didn’t profile why, so treat these as likely reasons rather than findings. StarRocks keeps table metadata between queries instead of asking the catalog each time. Its planner can reuse a repeated block of a query instead of planning every copy, and the ledger query repeats its building blocks a lot. Its execution engine is C++ and works on data in batches, where Trino runs on Java.
The cost is the SQL. The agent writes Trino SQL, and StarRocks speaks a MySQL-style dialect. For six queries the conversion was mechanical, five kinds of change:
- backticks instead of double quotes around names,
- date_add(d, INTERVAL 1 MONTH) instead of date_add('month', 1, d),
- datediff(end, start) instead of date_diff('day', start, end), with the arguments swapped,
- last_day(d) instead of last_day_of_month(d) and a CAST instead of DATE '…' literals,
- utc_timestamp() instead of current_timestamp AT TIME ZONE 'UTC'.
One setting also needed raising: the big queries hit StarRocks’ default 3-second limit on planning time, so I set new_planner_optimize_timeout higher for the session. StarRocks also returned some totals as floating point numbers (1650620.4199999978), right to the cent but needing rounding before display.
StarRocks has its own version of precomputed tables, asynchronous materialized views. For tables in an external catalog like this one, its docs say they refresh on a schedule or on demand, not automatically when the data changes (feature support page). I haven’t tested them yet.
Doris: blocked on Azure authentication
Doris needed two adjustments before it would even start on this VM. Its frontend defaults to 8 GB of Java memory reserved up front, more than the machine had, so I gave it 1.5 GB through its config file. Its backend also requires the Linux setting vm.max_map_count of at least 2,000,000.
Then it connected to the catalog with the same OAuth settings (the iceberg.rest.* properties, available from Doris 3.1 per its REST catalog docs) and listed every schema and table. The first query that read data failed, asking for an Azure storage account key.
Doris’ Azure storage docs list only account name and key for access, with no managed identity. I also tried letting the catalog hand out temporary storage credentials, which Doris supports in general. It didn’t change anything for Azure.
An account key opens the whole storage account, including data the engine has no business writing to. After enough security audits of payment flows, a key that opens everything is the first thing I remove from a design, not something I add to get a test working. I stopped the test there. If your Azure setup avoids account keys, check this first.
Which one I’d pick
On numbers alone, StarRocks wins this test. But each engine comes with a different kind of work, and that’s what actually decides it:
- Trino is the most common choice, with the most people who know it. To make it fast here, you build a local catalog and keep its pointers fresh after every data refresh, and you precompute the heavy models.
- StarRocks is fast with no extra pieces, and its materialized views could replace a homemade refresh job. In exchange, every query your application writes needs porting to its dialect, and the community is smaller, at least in the circles I work in.
- Doris is out on Azure until it supports managed identities for storage.
If an application already speaks Trino SQL, as mine did, Trino with the two fixes gets you most of the speed without a second port. If you’re starting fresh, StarRocks deserves a real trial before you default to Trino.
Test the engine against your own catalog and your own login method first. Speed is the easy part to measure; whether it can read your files at all is the part that surprises you.
Muhammad Mairaj is a Senior Backend Engineer with 8 years building payment and data systems. He writes about data engineering, measured. More about him.