symbol resolution

This paper investigates the expressive power of SQL/PGQ for modeling property graphs over relational databases. We analyze three fragments—its read-only core, read-write extensions, and variants supporting rich view definitions—using formal language theory and computational complexity analysis. We identify graph construction operations as the key mechanism differentiating expressiveness. Our results establish a strict hierarchy: the read-only fragment is strictly weaker than NL; the read-write extension remains below NL; and with arbitrary-arity identifiers, the fragment becomes NL-complete. Moreover, under ordered structures, binary identifiers suffice for expressiveness saturation. The primary contribution is the first precise characterization of each SQL/PGQ fragment’s expressive power relative to the complexity class NL, together with a rigorous demonstration that view definition mechanisms are decisive in elevating expressive capacity.

This paper addresses the low execution efficiency of acyclic recursive graph queries in graph databases. We propose a schema-based, semantics-preserving optimization technique. Our core innovation lies in the first systematic integration of structural information inherent in the graph schema into recursive query optimization: leveraging type inference and schema analysis, we automatically derive type constraints on nodes and edges to enable schema-augmented rewriting of recursive queries. Within a formal semantic framework, we prove the soundness and completeness of our approach, thereby rigorously guaranteeing query equivalence. Experimental evaluation demonstrates significant performance improvements for acyclic recursive queries across real-world domains—including social networks and life sciences—while preserving correctness. The method achieves both substantial speedups and strict semantic fidelity, bridging a critical gap between optimization and formal correctness in recursive graph querying.

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.

Relational databases, graph databases, and deductive systems exhibit paradigmatic fragmentation in supporting recursive queries, hindering interoperability and standardization. Method: This paper proposes a source-to-source compilation framework based on a multi-layer intermediate representation (PGIR, DLIR, SQIR), employing formal semantic modeling and syntax-directed translation to enable bidirectional, semantics-preserving translation among Cypher, SQL/PGQ, and Datalog for recursive queries. Contribution/Results: The framework establishes a cross-paradigm semantic bridge that supports static analysis, optimization transformations, and execution engine adaptation. It provides a formally verifiable reference implementation for recursive queries, significantly improving query portability and execution consistency across heterogeneous systems. By unifying recursive query semantics across database paradigms, the work advances standardization efforts and fosters interoperability in graph and relational data processing.

Existing systems require manual implementation of pruning logic for each query predicate and data structure, hindering support for complex set queries. Method: This paper proposes a metadata-driven tree-structured query optimization framework. It employs symbolic interval analysis to automatically derive subtree pruning and containment conditions, integrates filtering and aggregation into a single traversal for the first time, and extends geometric predicate inference rules (e.g., intersection, containment) to support generic single-index and dual-index tree joins—overcoming traditional limitations of equality and range joins. Contribution/Results: The generated code is behaviorally equivalent to expert hand-optimized implementations. In absence of domain-specific optimizations, it significantly outperforms linear scans and nested-loop joins, achieving asymptotically optimal time complexity.

Existing Datalog engines struggle to simultaneously achieve efficiency, scalability, and extensible semantics in static analysis, while also lacking robust support for rule debugging and incremental updates. This work proposes a novel approach that compiles Soufflé-style Datalog programs into executable Differential Dataflow programs, yielding a high-performance, memory-efficient static analysis framework capable of millisecond-scale incremental recomputation. The framework natively supports non-standard semantics—such as k-core analysis—and integrates in-browser performance profiling and rule-tuning capabilities. Evaluated on 24 real-world static analysis benchmarks, the system outperforms state-of-the-art engines in both runtime performance and scalability.

Natural language log querying remains challenging due to the absence of structured schemas, hindering accurate SQL generation. This work proposes a novel approach that first parses raw logs into templated relational tables and then enriches both templates and parameter columns with interpretable semantics through dual-granularity semantic grounding. By integrating semantic search with constrained decoding in large language models, the method generates context-aware, executable SQL queries. The study introduces the first semantically grounded log schema and releases LogNLQ-Bench, the inaugural benchmark for natural language log querying featuring execution-based validation. Experimental results demonstrate that the proposed method significantly outperforms existing techniques on LogNLQ-Bench, particularly excelling in complex analytical queries.

This work addresses the significant runtime overhead commonly incurred by assertion checking in dynamically typed languages. It proposes a novel approach that, for the first time, systematically incorporates multi-calling-context information into a goal-directed, multi-variant abstract interpretation framework. By performing top-down inference of program properties under distinct calling contexts and selectively integrating the runtime semantics of assertions, the method substantially reduces redundant checks while preserving the ability to provide hints about unverified properties. An implementation in the Ciao system demonstrates that this technique markedly decreases the number of runtime checks and improves execution performance compared to existing approaches.

This work addresses the challenge of integrating and retrieving multi-source heterogeneous data arising from schema inconsistencies by proposing an “executable schema contract” mechanism. This approach enables structure-aware automatic knowledge graph construction through a combination of closed-world field catalogs, deterministic structural analysis (e.g., primary/foreign key detection and source hierarchy identification), and monotonic extension protocols. It integrates large language model–constrained schema discovery, schema-guided information extraction and deduplication, and a multi-tool agent routing strategy that supports structured queries, graph traversal, and vector search. Evaluated on four question-answering benchmarks, the method achieves significantly superior zero-shot performance compared to pure retrieval and decomposition-based baselines. Ablation studies confirm that schema-conditioned routing, structural reasoning, and schema-guided construction are critical to its performance gains.

This work addresses the challenge of identifying structural and semantic similarities across imperative programs written in different languages by proposing a unified graph representation that integrates abstract syntax trees with neural semantic embeddings. The approach transforms annotated programs into typed, attributed graphs and leverages CodeBERT and SentenceTransformer to generate rich semantic embeddings. By constructing consistent graph representations across multilingual verification datasets—including C/ACSL, Java/JML, and Dafny—it achieves, for the first time, joint modeling of syntactic structure and formal semantics. This unified framework offers a viable pathway for cross-language reuse of verification artifacts and demonstrates strong generality and effectiveness across diverse programming languages and specification frameworks.