Ilmu Komputer & AI editorial
Relational-Core Graph Analytics: Querying graphs at SQL scale, and why the node/edge model is a performance tax, not a truer picture of connected data
The core problem
A durable assumption holds that graph analytics requires a purpose-built graph engine, and that relational systems are ill-suited to connected data. This paper argues the opposite for the workloads enterprises actually run. The central claim is twofold: first, that a columnar relational engine fronted by a graph query language matches or exceeds native graph engines on analytical graph queries, and — decisively — scales past the point where in-memory graph engines fail. Second, that the node/edge property graph is not a more faithful model of connected data but a re-encoding of relationships that already exist explicitly in relational tables; reconstructing them at query time is pure overhead.
The authors present ClickGraph and its Databricks-dialect sibling DeltaGraph, systems that translate Cypher directly onto the native relational schema — the tables, columns, and foreign keys as they already exist — and execute in place on ClickHouse, Databricks, or in-process on lakehouse files, with no import and no separate cluster. Because the output is ordinary SQL, an underperforming query is an open optimization surface: it can be rewritten, and the engine itself extended. The argument
Innovation
The results are presented at two levels: comparative performance and scalability. The peer system's published benchmark shows a columnar engine outrunning Neo4j by two-to-four orders of magnitude. This is a striking margin, and it directly challenges the assumption that native graph engines are necessary for analytical graph queries. The authors also report reproducible measurements across the LDBC Social Network Benchmark suite, which corroborate the claim that a columnar relational engine fronted by a graph query language matches or exceeds native graph engines.
Crucially, the results emphasize scalability: the relational approach scales past the point where in-memory graph engines fail. In-memory graph engines are bounded by the memory of a single machine or cluster, and as graph size grows, they either spill to disk (with severe performance penalties) or fail outright. Columnar relational engines, by contrast, are designed for out-of-core execution and distributed processing, allowing them to handle graphs that exceed memory.
The performance advantage can be expressed in terms of the overhead of the node/edge model. If the relational schema already stores relationships explic
Why it matters
The analysis challenges a foundational assumption in the graph analytics community. The authors argue that the node/edge property graph is not a truer picture of connected data; rather, it is a re-encoding of relationships that already exist explicitly in relational tables. In a relational schema, foreign keys and join tables already capture relationships. Converting these into a node/edge model duplicates information and forces the engine to reconstruct relationships at query time. This reconstruction is pure overhead.
The implication is that enterprises can leverage their existing relational infrastructure for graph analytics without importing data into a specialized graph database. By translating Cypher directly onto the native relational schema, ClickGraph and DeltaGraph avoid the cost of data duplication and the operational complexity of a separate cluster. Moreover, because the output is ordinary SQL, the query is an open optimization surface: it can be rewritten by a skilled SQL developer, and the engine itself can be extended. This is in contrast to closed graph engines, where optimization opportunities are limited to what the vendor provides.
The discussion also touches on the taxonomy of the approach. It sits at the intersection of Architecture, Network, and Cryptography? Not exactly — the taxonomy candidates provided are Architecture, Cybersecurity, Network, Cryptography. The work is primarily architectural, with implications for network analysis and potentially for security analytics where graph queries are common. However, the core contribution is a systems architecture that rethinks the execution layer for graph queries.
One might object that graph query languages offer expressive power beyond SQL, such as variable-length path queries. The authors counter that such queries can be compiled to recursive SQL, which modern relational engines support. The key is that the graph query language is a front end, and the relational engine is the execution engine. This separation of concerns allows each to excel.
In summary, the paper argues for a paradigm shift: instead of treating graphs as a special case requiring special engines, treat them as a query language over relational data. The performance and scalability benefits are substantial, and the approach is practical because it builds on existing, mature technology.
Who should read this
Opening member content…