mongodb

Document-oriented NoSQL databases, which typically adopt eventual consistency models, struggle to support highly reliable transaction processing. This work proposes a four-phase transaction management framework that achieves conflict-serializable consistency while preserving system scalability. By integrating transaction lifecycle management, operation classification, pre-execution conflict detection, and an adaptive locking strategy, the approach effectively eliminates deadlocks and significantly reduces both transaction abort rates and latency variance. Experimental results demonstrate that the abort rate decreases from 8.3% to 4.7%, and latency variance is reduced by 34.2%. Under high concurrency, throughput improves by 6.3%–18.4%, with a 15.2% increase observed in a 9-node cluster, accompanied by a 53% reduction in abort rate.

This paper addresses the lack of a unified query standard for JSON document databases by proposing, for the first time, a formally defined standardized fragment grounded in MongoDB’s aggregation framework. Methodologically, it employs formal semantics to precisely specify the fragment’s syntax and operational semantics, systematically establishes its correspondence with relational algebra, and derives sound algebraic transformation rules for equivalence-based optimization. The key contributions are: (1) establishing the first verifiable formal foundation for JSON document querying; (2) rigorously characterizing the theoretical correspondence between aggregation pipelines and relational operations, thereby enabling semantic interoperability between NoSQL and relational models; and (3) providing an extensible standard framework accompanied by practical, implementable optimization rules that support query rewriting, cost estimation, and cross-engine interoperability. The work bridges theoretical rigor and engineering utility.

To address the challenge of jointly optimizing efficient storage, historical preservation, and global query performance for dynamically evolving graph data in NoSQL systems, this paper proposes a space-efficient, enhanced vertex-centric storage model implemented atop MongoDB. The model innovatively integrates dual-mode historical representation—combining snapshots with time intervals—and leverages MongoDB’s native query capabilities to eliminate storage redundancy. It is the first approach to jointly optimize memory footprint, client-side query load, and server-side computational overhead in NoSQL-based graph storage. Extensive experiments, conducted on LDBC Social Network Benchmark (SNB) synthetic datasets under both single-node and distributed deployments, demonstrate that our method reduces average global query latency by 32.7% and storage overhead by 28.4% compared to baseline approaches, significantly improving the efficiency of resource-intensive, history-aware graph queries.

To address replication latency, race conditions, and high network overhead induced by pointer-based designs in cross-region, high-throughput NoSQL database storage, this paper proposes the “Chunked Object” pattern. It decomposes oversized objects into ordered data chunks and stores them directly within a multi-region replicated key-value store (e.g., DynamoDB Global Tables), collocating data and metadata within a single consistency domain. This eliminates asynchronous replication between the database and external object storage, thereby significantly reducing cross-region p99 consistency attainment time. Evaluated in production under heavy load (>200K TPH, 1 MB/transaction), the approach demonstrates robust effectiveness and generalizability. It is applicable to any key-value store supporting per-item size limits and cross-region strong synchronization, offering a practical, system-agnostic solution for scalable, low-latency global data management.

Contemporary relational database management systems (RDBMSs) suffer from insufficient logical data independence, reducing them to passive storage layers incapable of supporting modern architectural innovation. This paper argues that the Entity-Relationship (ER) model must serve as the native abstraction layer of RDBMSs to overcome this limitation, and it provides the first systematic theoretical justification and empirical validation of the ER model’s necessity and feasibility for ensuring logical independence. Based on this insight, we design and implement ErbiumDB—a prototype system integrating metadata-driven schema management, declarative relational semantic modeling, and runtime relationship evolution. Experimental evaluation demonstrates that ER-based abstraction significantly enhances decoupling between application and storage layers, enabling flexible, semantics-aware data management. ErbiumDB establishes a novel paradigm for intelligent database architectures and delivers a rigorously validated, extensible prototype foundation for future research and development.

Databases continuously evolve through operations such as schema changes, version updates, and data transformations; however, existing approaches typically address these functionalities in isolation, lacking a unified abstraction. This work proposes the first integrated model that unifies continuous schema evolution, version management, and data transformation within a single framework. Built upon general-purpose computational primitives, the model supports operation provenance, conditional update propagation, and change alerts, while employing a declarative mechanism to manage the co-evolution of dependent artifacts—including views and machine learning models. A prototype system implements this framework using an enhanced, parameterized Prolly Tree—a Merkle tree–inspired data structure—to construct a relational-like engine. Experimental evaluation demonstrates that the proposed approach is both feasible and offers tunable performance across diverse evolution scenarios.

This work addresses the longstanding challenge of reconciling correctness guarantees with high performance in database storage systems by proposing a compositional construction methodology grounded in formal specifications. The approach leverages formal specifications to guide a Java implementation and employs storage equivalence proofs to rigorously ensure correctness. Crucially, it decouples performance optimizations from functional logic, enabling flexible composition of components. Using this methodology, the authors reimplement RocksDB’s tiered storage architecture and develop CobbleDB, a prototype system that demonstrates strong real-world performance and practical applicability while maintaining strict correctness guarantees.

Existing relational databases lack the persistent isolation and concurrent branching capabilities required by agent workloads, hindering support for speculative modifications and nonlinear state exploration. This work presents the first systematic definition and quantitative evaluation of database branching for intelligent agents, introducing BranchBench—a benchmark combining parameterized macrobenchmarks (modeling branch-mutate-evaluate cycles) and microbenchmarks (measuring branch lifecycle overhead). We evaluate systems including Neon, DoltgreSQL, TigerBeetle, Xata, and PostgreSQL, revealing that fast-branching systems suffer 5–4000× read performance degradation as branch depth increases, while fast data operating systems exhibit 25–1500× higher latency in branch creation and switching. Our experiments demonstrate that none of the current systems can effectively scale to support representative agent workloads such as software engineering tasks, fault reproduction, or Monte Carlo Tree Search (MCTS).

This work addresses the limitations of traditional database migration approaches, which are often constrained to specific source-target model pairs and struggle to support general-purpose migration in heterogeneous, multi-model environments. To overcome this, the authors propose a model-driven migration framework based on a unified data model called U-Schema. By mapping diverse data models into a common intermediate representation, the framework drastically reduces the number of required transformation pathways and enables cross-paradigm migrations. It employs traceable metadata to decouple schema transformation from data migration, thereby preserving semantic consistency while enhancing structural fidelity and query behavior equivalence. Empirical evaluation—conducted in a relational-to-document database migration scenario using both synthetic datasets and the Northwind benchmark—demonstrates the approach’s effectiveness and scalability across varying data sizes.

Existing learned indexes struggle to simultaneously achieve high concurrency, durability, and low intrusiveness under write-intensive workloads. This work proposes a hierarchical learned indexing architecture that leverages the separation between Memtables and SST files in RocksDB to enable targeted optimizations at both memory and disk layers. By reusing structural knowledge across Memtables, the approach mitigates the overhead of frequent index reconstruction, while a block-aware, read-only learned index ensures that lookups complete within a single I/O in the worst case—without requiring modifications to the storage layer or read path. Experimental results demonstrate that, across diverse large-scale workloads, the proposed method improves write throughput by up to 1.5× and read throughput by up to 2.1× compared to state-of-the-art systems.