Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
Yes—you can analyze tabular and graph-shaped data from the same modern lakehouse, but a lakehouse table format alone does not provide graph traversal. SQL and Spark can handle many bounded relationship questions. Deeper, branching, repeated traversals usually need a graph-aware execution layer, which may read tables at query time, build an index or cache, or materialize a separate graph. So “directly on the lake” can mean less pipeline duplication—not necessarily no data movement, no derived storage, or fast queries.
What “directly on the data lake” means
A data lake stores files—often Parquet, JSON, Avro, or CSV—in object storage. A lakehouse adds table management, transactions, catalogs, governance, and query-engine support. Apache Iceberg, Delta Lake, and Hudi are open table formats: they manage table metadata and changes, but they are not graph databases or graph engines.
Tabular analytics covers filters, aggregations, joins, reporting, time-series analysis, and feature engineering. Graph analytics focuses on entities and their relationships: multi-hop traversal, path finding, connected components, centrality, communities, or link prediction. A graph database stores and serves graph data; a graph compute engine may instead read tables and process them as a graph.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Repair Windows errors before they cause bigger problems3Scan for outdated or missing drivers - takes under a minuteIn practice, “direct” can describe several different architectures:
#1 Best Overall
- SQL or Spark over tables: Nodes and relationships remain relational rows, and queries use joins or iterative jobs.
- Query-time graph virtualization: A graph layer maps existing tables to vertices and edges and queries them without a conventional ETL load. PuppyGraph, for example, advertises access to Iceberg, Delta Lake, and Hudi among other sources; its documentation also describes optional local caching (product overview, data sources).
- Graph materialization or indexing: A service reads lakehouse tables and constructs a traversal-ready graph or index. Microsoft Fabric Graph takes this approach: OneLake tables are the source, but saving a model builds a queryable graph (how Fabric Graph works).
- A separate graph database: Data is ingested or synchronized into a system designed for graph querying and serving, creating another storage, security, and operations boundary.
“Directly on the lake” is an architectural claim, not a performance guarantee. Zero-ETL may mean you do not operate a separate extract-transform-load pipeline; it does not necessarily mean no schema mapping, preprocessing, cache, index, temporary state, or persistent graph representation. Zero-copy is narrower: no second persistent copy of the source data is created. It still may not rule out derived indexes or caches.
Why lakehouses handle tabular analytics well
Modern table formats make lake data more dependable and usable across engines. Iceberg’s documentation describes schema evolution, hidden partitioning, time travel, rollback, atomic table changes, optimistic concurrency, and metadata-based pruning. It lists engines including Spark, Trino, PrestoDB, Flink, Hive, and Impala (Iceberg documentation).
Columnar files, predicate pushdown, partition and file pruning, statistics, distributed SQL, and Spark execution can make scans and aggregations efficient. Table metadata can help an engine avoid reading irrelevant files, while separation of storage and compute lets different engines use the same tables. Time travel can support reproducible analysis against a historical table state.
Those capabilities are a strong foundation for analytics. They do not, by themselves, provide adjacency indexes, graph partitioning, recursive-query optimization, or a graph algorithm library. The graph execution layer remains a separate architectural choice.
Representing a graph in tables
A property graph can be represented with entity tables (nodes) and relationship tables (edges). For example:
CREATE TABLE customer (
customer_id BIGINT,
name STRING,
country STRING,
signup_date DATE
);
CREATE TABLE product (
product_id BIGINT,
category STRING,
brand STRING
);
CREATE TABLE purchase (
customer_id BIGINT,
product_id BIGINT,
order_id BIGINT,
purchased_at TIMESTAMP,
amount DECIMAL(18,2)
);Here, a customer and a product are nodes; each purchase row is an edge carrying properties such as its time and amount. In other domains, edges might represent account transfers, supplier dependencies, device use, or document references.
Before choosing a graph engine, define the model deliberately:
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Rank #2
- Identity: Use stable endpoint IDs. Natural keys such as email addresses can change; changing identifiers can split or merge an entity’s apparent connections.
- Direction: Decide whether an edge is directed, interpreted as undirected, or represented in both directions. Reciprocal rows may be distinct events—or accidental duplicates.
- Labels and properties: Specify node and edge types, properties, and which fields are queryable.
- Time: Store event timestamps or validity intervals when relationships change over time. A relationship that was once true may not be valid now.
- Data quality: Define how to handle duplicate edges, missing endpoint records, deletes, late-arriving data, and corrected relationships.
Slowly changing dimensions deserve special attention: a current entity attribute may not describe what that entity meant when a historical edge was created. Microsoft Fabric Graph, for example, uses node types, edge types, and table mappings to construct a labeled property graph from OneLake tables (architecture documentation).
Start with SQL when the question is bounded
A one-hop question—such as finding a customer’s purchases—is ordinary SQL:
SELECT
p.customer_id,
p.product_id,
p.amount
FROM purchase AS p
WHERE p.customer_id = 12345;A two-hop question can use a self-join. For example, find other customers who bought a product purchased by customer 12345:
SELECT DISTINCT
p1.customer_id AS source_customer,
p2.customer_id AS related_customer
FROM purchase AS p1
JOIN purchase AS p2
ON p1.product_id = p2.product_id
WHERE p1.customer_id = 12345
AND p2.customer_id <> 12345;This is a useful pattern for bounded relationship analysis and batch feature generation. It would be a mistake to say that SQL cannot do graph analysis: many graph questions reduce naturally to relational operations.
The practical limitation appears as patterns become deeper, variable-length, branching, or repeated. Each additional join may scan or shuffle substantial data; intermediate results can grow quickly; high-degree entities can cause fan-out; and join order and cardinality estimates matter. Recursive SQL support and behavior differ by engine. Iterative algorithms may require repeated jobs, state management, and checkpointing. A relational optimizer is not automatically a graph optimizer.
Use SQL or Spark first for stable, bounded patterns and set-based graph features. Consider graph-specific execution when analysts need repeated path exploration, variable-depth traversal, large connected-component work, or interactive queries that are awkward or costly as repeated joins.
Four architecture choices
| Approach | Where graph work happens | Often a good fit for | Key trade-off |
|---|---|---|---|
| SQL or Spark | Against relational tables | One- or two-hop questions, batch features, existing SQL/Spark workflows | Deep and iterative work can become cumbersome or expensive |
| Query-time graph virtualization | A graph engine maps and queries source tables | Exploratory multi-hop analysis and federated sources | Source reads, object-store latency, mapping, caching, and security behavior matter |
| Lakehouse-integrated graph | A platform builds a graph model or read-optimized representation from lakehouse data | Analytics within an existing lakehouse platform, BI or data-agent workflows | Refresh, derived storage, capacity use, and model-evolution limits matter |
| Separate graph database | A graph-native system stores or serves a graph | Operational applications, frequent relationship changes, predictable interactive serving | Ingestion or synchronization, extra storage, governance, and operations |
1. SQL and Spark
This is usually the simplest starting point when the question is bounded and the team already operates a lakehouse. It avoids adopting a new graph service and keeps the analysis in familiar tooling. It is less attractive for deep traversals, interactive path exploration, or high-concurrency applications.
Rank #3
2. Query-time graph virtualization
A virtualization layer defines how source tables map to nodes and edges, then executes graph queries against those sources. PuppyGraph advertises ETL-free access to several relational and lakehouse sources and supports Cypher and Gremlin in its published product materials (features and pricing). Its documentation distinguishes direct source-table querying from an optional local-data-source caching mode (data-source options).
This can avoid maintaining a conventional load pipeline and retain the lakehouse as the authoritative data source. But every query still needs compute and I/O. Depending on source layout and engine behavior, remote reads may add latency; caches or other derived state may change freshness and storage requirements. Verify how the product handles permissions, updates, and table-format features rather than assuming the source system’s behavior is inherited automatically.
3. A lakehouse-integrated graph service
Microsoft Fabric Graph maps OneLake tables to node and edge types, then constructs a read-optimized queryable graph when a model is saved. Its documented interfaces include a visual Query Builder, GQL, REST, and preview natural-language-to-GQL functionality; results can be visual, tabular, or returned programmatically (overview, how it works).
This is an integrated graph layer, not simply every traversal running against raw Delta files at query time. The documentation says structural schema changes currently require a new model and reingestion because graph schema evolution is not supported. The overview describes graph operations as using Fabric capacity and graph storage as having a minimum provisioned amount of 100 GB; confirm current regional pricing and capacity details before planning costs (Fabric Graph overview).
4. A separate graph database
Systems such as Neo4j and TigerGraph provide graph-oriented storage, query languages, indexes, algorithms, and application interfaces. They may be the right choice for low-latency serving, frequent graph mutations, or high-concurrency interactive traversal. They also introduce a separate system to secure, monitor, synchronize, pay for, and recover. Neo4j documents Fabric integration and exporting graph-analysis results to OneLake (Fabric integration), but integration does not make a separate graph database equivalent to querying lakehouse tables in place.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Graph queries are not the same as graph algorithms
A pattern query asks for relationships that match a shape: accounts sharing a device, suppliers connected to a product within three hops, or a path between two entities. An algorithm computes a property over a graph: PageRank, centrality, connected components, community membership, similarity, embeddings, or link prediction.
A product may support pattern matching without offering a broad algorithm library, or may run algorithms through a separate batch runtime. Check supported languages and semantics, traversal limits, directed and weighted-edge support, whether algorithms are incremental or full-recompute, and how outputs can be exported. Do not assume that support for Cypher, Gremlin, or GQL means identical behavior or portability across products.
Rank #4
Graph work should often end in a table, not just a diagram. Examples include a risk score per account, a connected-component ID per customer, supplier dependency counts per product, or a centrality score per entity. A common workflow is:
lakehouse tables
→ graph traversal or algorithm
→ tabular features or results
→ BI, ML, alerting, or an applicationFabric Graph explicitly documents visual graph results, tabular results, and programmatic JSON responses (results and interfaces). This matters because graph output is often input to ordinary analytics or operational workflows.
Freshness, consistency, and schema changes
Architecture choice determines how quickly a relationship change becomes visible:
- SQL over source tables: Reads the committed table state visible to the chosen engine, subject to its snapshot and caching behavior.
- Query-time virtualization: Can read source data at query time, but caching and source snapshot semantics affect what is visible.
- Materialized graph or index: Traversal may be quicker, but results represent a built or refreshed graph state.
- Separate graph database: Freshness depends on its ingestion, batch load, or change-data-capture path.
Ask whether the graph query is tied to a specific Iceberg or Delta snapshot and whether updates, deletes, tombstones, and merges appear immediately. Confirm how late edges, corrected relationships, table compaction, and source rewrites affect an index. A platform’s table-format guarantees do not automatically mean a graph index updates transactionally with every table commit.
Iceberg’s time travel and atomic table changes can help make source-table analysis reproducible, but verify whether the graph layer can query or record the same snapshot identifier (Iceberg documentation). If graph output must be auditable, record its source snapshot, model version, and refresh time.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Performance and cost: measure the graph, not just the table
Table tuning still matters: file sizes, small-file compaction, partitioning or clustering, statistics, predicate pushdown, data skipping, metadata performance, and object-store request overhead affect source reads. For graph workloads, also measure the graph’s shape and traversal:
Recommended Free Tools
- Vertices, edges, and degree distribution—not just total row count.
- High-degree hubs and skew; a single popular device or account may connect to millions of records.
- Traversal depth, branching factor, starting-vertex selectivity, and edge filters.
- Whether edges are directed, weighted, time-bounded, or duplicated.
- Algorithm iteration count, shuffle volume, result size, and graph partitioning.
- Index construction, cache warm-up, refresh time, and cold-start latency.
A rough way to understand fan-out is:
candidate paths ≈ starting_vertices × average_degree^hopsThis is a conceptual illustration, not a runtime prediction: real graphs have skew, filters, cycles, and implementation details. It shows why increasing traversal depth can rapidly enlarge the search space. Apply time windows, edge-type filters, degree limits, sampling, top-k expansion, or explicit query limits where appropriate. Treat hub nodes deliberately rather than letting a broad traversal expand without bound.
Best Value
“No copy” is not automatically the lowest-cost design. Query-time scans can consume compute and object-store requests; persistent graph indexes consume storage and need refresh; a separate database adds ingestion and operating costs. Compare total cost for the workload, including refreshes and peak concurrency—not just the price of storing source files.
A practical benchmark protocol
Benchmark representative production-shaped data and queries. Include regular-degree and heavy-tailed graphs, skewed hubs, duplicate edges, high-cardinality IDs, historical and current relationships, and updates or deletes. Measure:
- Cold-start and warm-cache latency.
- P50, P95, and P99 latency at realistic concurrency.
- Cost per query or batch, including source scans and capacity.
- Graph index build and refresh time, plus freshness lag.
- Source-table scan volume, shuffle, and result size.
- Recovery and rebuild time after a failed refresh, rewrite, or schema change.
- Equivalence of results against a trusted reference implementation.
Vendor statements such as “sub-second,” “billions of relationships,” or “petabyte scale” should be treated as claims tied to specific workload shapes and configurations, not as general performance guarantees. Request the query depth, graph topology, hardware, cache state, concurrency, and whether preprocessing time was included.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Governance is more than catalog connectivity
Connecting to a lakehouse catalog does not prove that a graph layer enforces every source-table policy. Test row-level and column-level permissions, object-store credentials, service principals, network boundaries, audit logs, lineage, and exported-result controls. Check access to cached data as well as direct reads.
Graph results can expose sensitive information by inference: a user who cannot see a source row may still learn a relationship from a path, aggregate, or risk score. Test authorization on derived paths and features, not only on individual columns. Also verify whether access is enforced at graph query time, during cache construction, and when results are returned through an API.
For example, PuppyGraph’s OneLake setup documentation describes a service principal with read access to the lakehouse and access through Microsoft’s Iceberg REST interface (OneLake setup). That connection detail is not, by itself, proof that every row- and column-level policy behaves identically across both systems.
Worked example: fraud-ring analysis
Suppose a team has customer, device, and transaction tables in a lakehouse. A first pass can use SQL to find accounts sharing a device within a defined time window. That is often an efficient bounded feature. If investigators need to follow variable-length paths through accounts, devices, addresses, and transactions, a graph model can make multi-hop exploration more natural.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →The production workflow might be:
- Keep the source entities and events in governed lakehouse tables with stable identifiers and event timestamps.
- Define which relationships are valid, how duplicates are interpreted, and how late or deleted records are handled.
- Start with SQL/Spark for bounded features; use a graph layer if path exploration or algorithms justify it.
- Specify whether queries read current table state or a refreshed graph snapshot, and expose that timestamp or version.
- Return risk indicators as tabular results for BI, ML, alerts, or an investigation application.
- Test access controls on relationships and derived scores, not just on the original tables.
The key question is not whether the data can remain in one authoritative lakehouse. It often can. The question is whether the chosen execution and derived-state model meets the required latency, freshness, governance, and cost.
Choosing an architecture
| Requirement | Good starting point |
|---|---|
| BI, reporting, aggregations | Lakehouse SQL engine |
| Bounded one- or two-hop analysis | SQL or Spark |
| Batch graph features for machine learning | Spark/SQL graph processing or a lakehouse graph engine |
| Exploratory multi-hop analysis over existing tables | Query-time graph virtualization, subject to source-read and cache behavior |
| Fabric-first governance and data-agent workflows | Fabric Graph, accounting for graph materialization and capacity |
| Low-latency, high-concurrency application serving | Native graph database, with its synchronization and governance costs |
| Frequently changing operational graph | Native graph database with an appropriate update or CDC design |
| Historical graph analysis | Snapshot-aware lakehouse and graph processing |
| Strict requirement against a persistent source-data copy | Evaluate query-time execution, but verify caches, indexes, temporary data, and derived storage |
Before committing, answer these questions:
- Must a query see the latest committed table state, or is a refreshed snapshot acceptable?
- Are traversals bounded, deep, or variable-length? How large and skewed is the graph?
- Is the workload batch analytics, analyst exploration, agent retrieval, or online serving?
- Which algorithms and query languages are actually required?
- Can permissions and audit behavior be demonstrated across direct reads, caches, paths, and exports?
- Where do indexes and other derived assets live, who refreshes them, and how are they rebuilt?
- What are the total compute, storage, refresh, and concurrency costs?
- Can results be traced to source-table snapshots and model versions?
Iceberg, Delta Lake, and similar formats make lakehouse tables reliable and interoperable; they do not make the storage layer a graph engine. Many organizations can keep one authoritative data estate and add graph capability above it. Whether that means SQL joins, virtualized reads, a materialized graph index, or a separate database should follow from the workload—not from the phrase “zero ETL.”
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
