
Query federation is the mechanism that runs one SQL query across several independent data systems and returns a single result. A federated engine parses the statement, plans access source by source, pushes supported work down to those sources, moves the intermediate data it needs, and combines the outputs for whoever asked.
Plenty of teams need current data from several operational systems and don't want to copy everything into one store first. Know what the engine actually does with your federated SQL and you can predict performance and network traffic, and spot where the expensive joins are going to land.
What happens when a federated SQL query runs?
Hypothetically, an analyst writes one statement that touches an orders database and a customer system. Nobody has copied either into a warehouse. What now?
The engine turns that statement into a distributed execution plan. First it validates the SQL and resolves the tables, columns, functions and source systems the statement mentions. Then the planner splits it into source-specific subqueries and works out dependencies and execution order, deciding for each operation whether it runs at a source or in the central engine. Each source runs what it supports and sends rows or partial results back. Whatever joins, filtering or aggregation are left over happen in the federated engine, which presents one unified result.
The exact plan depends on source capabilities, data distribution, query shape and the optimizer's estimates. That's why two logically equivalent SQL statements can end up with different execution plans and very different network costs.

How does predicate pushdown improve query federation?
If we had to name the single biggest lever in query federation, it'd be pushdown.
Predicate pushdown sends as much compatible work as possible to each source, so less data travels to the federated engine and less processing happens centrally. Skip it and the engine may haul back broad datasets, then filter, join and aggregate them itself. Use it and the engine rewrites the source subqueries to include the supported WHERE clauses, aggregations, projections and sometimes join conditions. Each source processes its own data first and returns something smaller.
Rarely all-or-nothing, though. A source may handle filters but not a particular function, data type conversion or join, and the planner has to split the work according to what each connector and source can execute correctly.

Why are cross-source joins expensive?
Records from separate systems have to meet somewhere. The federated engine retrieves both inputs and performs the join, which often eats memory and can mean moving a lot of data over the network.
There is a friendly case: one side is small enough to broadcast to the nodes working on the larger side. When both sides are large tables, neither moves cheaply and the join gets costly. Filtering and aggregating before transfer helps, but it can't remove the basic need to bring matching records together.
Before you trust a cross-system join in production, check join cardinality, filter selectivity, source latency and expected result size. For large joins that run again and again, replication or materialization may still beat redoing the same distributed work on every query.
What is query federation, and how is it different from data federation?
Two terms that get blurred. Data federation is the architectural idea: present distributed data through one unified access layer. Query federation is the technical process that carries one individual query through that layer.
The split matters because the promise and the behavior aren't the same thing. An architecture can promise federated access, yet how it behaves depends on how the query engine discovers sources, translates SQL, optimizes operations and handles intermediate results. Query federation is one implementation mechanism inside a broader federated data architecture.
A close cousin is data virtualization as an interface layer. Virtualization can also bring broader abstraction, catalog, security and semantic capabilities beyond SQL execution.
How does query federation support enterprise AI?
AI applications and agents get current operational data through one query interface, with no new replication pipeline for every use case. The engine combines approved information while the underlying systems stay separate.
Picture an agent that joins customer status from a CRM, order history from an ERP and pricing from a product catalog in one federated statement. The result gives it current context for a response or workflow, subject to the identity, access and policy controls around each source.
Access isn't meaning, though. Federation gets the agent to the data; governed schemas, reviewed semantics, data quality controls and sound agent grounding practices are what make the context approved and interpretable.
How Hyperlake helps
Hyperlake can assemble governed data foundations from engines that suit the workload, including Iceberg and Trino for lakehouse analytics alongside operational, vector, graph, search and streaming services. It provides shared identity, policy, observability and lifecycle controls in infrastructure controlled by the organization or its client. To discuss a federated data and AI deployment, talk to our team.
Frequently asked questions
Does query federation copy data into a central warehouse?
No permanent central copy is required before you can query. Query federation sends subqueries to the source systems and transfers only the rows or intermediate results the current request needs. Teams may still materialize or replicate heavily used datasets when repeated cross-source processing gets too slow or too expensive.
Can a federated SQL engine push every operation to its sources?
No. Pushdown depends on the SQL operation, connector, source engine, data types and supported functions. A source might run filters and aggregations but fail on a cross-system join or a specialized function. Whatever it can't do stays in the federated engine, which means more data movement and central processing.
When should a team avoid a large cross-system join?
Think twice when both inputs are large, filters remove little data, source latency is high, or the query runs over and over. Moving and joining that data on every request can be wasteful. A materialized view, a replicated data product or a scheduled transformation may be the better operational trade.
How current are the results of a federated query?
They reflect what each source exposes when its part of the query runs, subject to transaction isolation, caching and connector behavior. That can be fresher than a scheduled replication pipeline. But it isn't a guaranteed synchronized snapshot across unrelated systems, so applications should allow for timing differences between sources.


