graph databases

Existing graph databases lack effective support for the tree-shaped substructures commonly found in property graphs. This work addresses this limitation by treating such tree substructures as first-class citizens and proposes a systematic management framework encompassing modeling, indexing, and query optimization. Drawing inspiration from XML structural indexing techniques, the approach enables efficient path queries within a relational graph database backend. Experimental evaluation demonstrates that the proposed method significantly improves path query performance, thereby validating the potential of structural indexing to enhance graph data management.

Relational databases’ flat data model exhibits impedance mismatch with the nested data structures required by modern applications. This paper introduces the graph-relational database model, which unifies the formal rigor of the relational model with the expressive power of graph-structured nesting to support composable, type-safe complex queries. Our approach comprises three core contributions: (1) EdgeQL—a statically typed, SQL-like query language designed for expressive, safe navigation and transformation of nested, graph-shaped data; (2) the Gel compiler system, which jointly compiles EdgeQL schemas and queries—incorporating both static and dynamic semantics—into highly optimized, native PostgreSQL SQL; and (3) end-to-end type safety without runtime overhead, achieving execution performance comparable to hand-written SQL. Experimental evaluation demonstrates that our system substantially outperforms conventional ORMs, delivering superior balance among query expressivity, developer productivity, and runtime efficiency.

To address result explosion and ambiguous path semantics in navigational graph database queries, this paper proposes a formal framework for path attributes: quantitative constraints—such as path length and accumulated cost—are natively embedded into the operational semantics of the query language, enabling the first seamless integration of path properties with query processing. Unlike register automata, our framework offers strictly greater expressive power; its completeness and consistency are rigorously established via co-modeling of operational and logical semantics. We implement a prototype system based on this framework. Experiments demonstrate that incorporating path-attribute filtering significantly reduces result set size (by 72% on average), improves query throughput (up to 4.3× speedup), and effectively identifies and eliminates malformed paths.

SQL/PGQ standards enable hybrid relational and graph query processing, yet experiments reveal substantial performance disparities—even for semantically equivalent SQL and PGQ queries—due to syntax-driven, model-isolated optimization in existing systems, lacking cross-model synergy. This paper proposes the first holistic unified optimization framework that transcends syntactic boundaries between SQL and PGQ, instead leveraging query semantics and data characteristics to automatically select optimal execution strategies. Key technical innovations include: (i) cross-model query normalization via equivalence-aware analysis; (ii) cost-aware operator fusion; and (iii) adaptive execution plan generation. Experimental evaluation demonstrates that the framework significantly narrows performance gaps among functionally identical queries, achieving an average 3.2× speedup. It thus provides critical enabling technology for efficient, standardized SQL/PGQ deployment.

The data complexity of GQL—the standardized query language for graph databases—has long lacked a rigorous theoretical characterization. Method: We establish a unified relational-logic framework for graph queries, embedding full GQL (including arithmetic extensions) into FO[TC] + ESO. We introduce the *Restricted Quantifier Collapse* (RQC), a general technique grounded in finite model theory, and employ register automata modeling coupled with schema validation to analyze query evaluation. Contribution/Results: Our approach yields tight data complexity bounds for GQL and regular path queries (e.g., NL-completeness), and precisely captures regular path queries within FO[TC] while preserving NL complexity. This work provides the first systematic logical foundation for analyzing graph database query complexity, delivering both a unified formal framework and asymptotically optimal, tight complexity characterizations.

This work addresses the limited expressiveness of existing graph query languages—such as GQL and SQL/PGQ—which lack full compositionality and cannot capture complex path queries within the NLOGSPACE complexity class. To overcome this limitation, the paper introduces a novel query language that unifies graph pattern matching with relational querying through two key innovations: regular path queries enriched with variables and data-value comparisons, and a #Datalog-based graph transformation mechanism capable of constructing nodes, edges, and paths. This combination enables, for the first time, a systematically compositional approach to graph querying that precisely captures the full expressive power of NLOGSPACE. The proposed language not only resolves fundamental expressiveness gaps in current standards but also offers a practical and theoretically grounded extension pathway for both GQL and SQL/PGQ.

This work addresses the limitation of existing Text2Cypher systems, which are confined to a single graph database and thus unable to support natural language queries across multiple heterogeneous graph databases in real-world scenarios. For the first time, we extend Text2Cypher to a multi-database setting by formally defining the cross-database query reasoning task and its core challenges. We propose a structured three-stage reasoning framework that first routes the query to the relevant target database, then decomposes the original question into sub-queries, and finally performs heterogeneous query reasoning tailored to diverse graph database types and their respective query languages. This framework effectively enables the understanding and execution of cross-database natural language queries, laying a foundation for scalable and practical natural language interfaces to graph databases.

This work presents the first systematic approach to instance-free schema inference under property graph query transformations. Given a ProGS input schema and a G-CORE query, the authors propose a multi-layer mapping technique that translates property graphs, schemas, and queries into RDF, SHACL, and SPARQL CONSTRUCT representations, respectively, enabling automatic derivation of structural constraints on the output graph via description logic reasoning. By leveraging RDF reification and cross-language semantic bridging, the method establishes a sound and semantically equivalent metatheoretical foundation. This enables generic output schema inference applicable to any input graph conforming to the given schema, while formally verifying both the correctness of the derived constraints and the semantic fidelity of the mappings.

GQL (the ISO standard for graph querying) lacks native support for expressing monotonic edge-value constraints along paths, representing a fundamental expressiveness gap in its pattern-matching capabilities. To address this, we propose a constructive graph compilation technique that encodes ordering constraints directly into the graph structure—enabling existing GQL engines to evaluate such queries without syntactic extensions. Our approach integrates structural graph transformation, logical expressibility analysis, and Cypher-specific optimization, and is deeply embedded within the Neo4j runtime. Theoretically, this work closes a long-standing expressiveness gap in GQL concerning path-ordered constraints. Practically, it delivers substantial query performance improvements on real-world workloads, eliminating timeout failures observed with naïve implementations. By bridging formal database theory with industrial graph query engine design, our method advances both the theoretical foundations and practical applicability of standardized graph querying.

Existing graph and relational database systems struggle to efficiently evaluate path queries that combine regular expressions with complex attribute constraints, primarily due to their inability to perform early pruning of intermediate results. This work proposes ReCAP, an abstraction mechanism that explicitly models nondeterministic finite automaton (NFA) state transitions and integrates a minimal set of user-defined functions to deeply push arbitrary attribute constraints down into the lowest layers of the query execution plan. By embedding this approach within optimization frameworks of relational databases such as DuckDB, ReCAP enables highly effective early filtering of intermediate results. Empirical evaluation across diverse graph datasets and query workloads demonstrates performance improvements of up to 400,000× over state-of-the-art systems.