Temporal graph neural networks (TGNNs) model structural dynamics in evolving graphs by integrating temporal information. However, jointly modeling evolving topology and long-range temporal dependencies remains challenging. Moreover, dynamic graph operations (e.g., temporal neighbor sampling) incur substantial overhead, forcing existing TGNNs to rely on customized training frameworks for scalability. We propose TF-TGN, a decoder-only Transformer-based TGNN that reformulates temporal graph learning as sequence modeling, enabling expressive modeling of temporally ordered structural dynamics with efficient and scalable training. First, TF-TGN casts graph substructures into temporal node sequences via suffix infilling and introduces a spatio-temporal fusion encoding that jointly captures relative temporal intervals and structural positions. Then, building on masked self-attention, TF-TGN enables efficient temporal information aggregation. Furthermore, TF-TGN incorporates a temporal-aware distributed training system that parallelizes temporal CSR (T-CSR) construction, neighbor sampling, and data preparation, while integrating optimized attention kernels (e.g., FlashAttention) to improve efficiency and scalability on large-scale graphs. Extensive experiments show that TF-TGN achieves state-of-the-art results on dynamic link prediction and node classification, delivering a 6.69 ×  training speedup over the strongest baseline, a 242.48 ×  speedup in T-CSR construction, and a 10.55 ×  speedup in inference.

Existing database knob tuning methods evaluate the actual performance of each configuration by fully executing the entire workload. However, our experimental analysis reveals that this exhaustive execution approach significantly limits tuning efficiency, particularly when dealing with underperforming configurations. To address this issue, we propose ESTune, which is designed to early-stop the execution of poorly performing configurations. ESTune approximates the actual performance of these configurations using high-confidence predicted values generated from partially executed workload data and configuration knob settings. This strategy significantly reduces the evaluation time for underperforming configurations while maintaining the overall tuning effectiveness. The high-confidence predicted values are produced by a Hybrid Bayesian Neural Network (HBNN), which models the performance distribution with respect to different knob configurations. To address the challenge of limited training data commonly encountered in database knob tuning, ESTune integrates a Model-Agnostic Meta-Learning (MAML), thereby enhancing the few-shot learning capability of the HBNN. Extensive evaluations on a wide range of workloads consistently demonstrate that ESTune improves the tuning efficiency of existing methods.

As storage costs continue to rise, reducing redundancy has become increasingly important. In relational databases, classical normalization addresses redundancy through exact functional dependencies (FDs), but this rule-based design paradigm is not inherently cost-aware and does not necessarily minimize storage in practice. Moreover, much real-world redundancy follows FD+Δ patterns, where FDs hold for most tuples but are violated by a small fraction. To address this, we propose RelaxRD, a storage-centric relaxed schema design that leverages approximate functional dependencies (AFDs) to reduce redundancy in FD+Δ. Rather than treating all AFDs as equally useful signals, we quantify the storage value of AFD subsets via duplicate gain and select a high-quality subset for decomposition. It decomposes tuples satisfying the selected AFDs while retaining violating tuples. The key issue is that selecting a high-quality subset is difficult due to conflicts and the exponential search space. To tackle this, we develop a family of efficient filtering techniques to eliminate low-value and unpromising candidates without exhaustive enumeration. Extensive experiments on real-world datasets demonstrate that RelaxRD consistently achieves substantial storage savings.

Cardinality estimation is a cornerstone of query optimization. However, learned estimators still face a practical bottleneck. Many SPN-based methods rely on a fixed global correlation threshold to partition attributes at product nodes, even though dependence patterns vary widely across datasets and across recursive subproblems. This paper proposes AdapCard, a learned cardinality estimation framework that improves both robustness and efficiency by making thresholding and factorization adaptive. AdapCard introduces (i) TC-SPN, a tri-correlation SPN construction scheme that explicitly isolates moderately dependent attributes to enable earlier factorization without sacrificing fidelity; and (ii) MetaATPM, a meta-learned threshold predictor that maps local dependence structure to node-specific splitting thresholds and transfers across datasets with only a small amount of supervision. We further extend these techniques to multi-table estimation via a decoupled local-model design that reduces training overhead while preserving accuracy. Experiments on standard single-table and multi-table benchmarks demonstrate that AdapCard achieves state-of-the-art accuracy with substantially reduced training and inference cost compared with prior SPN-based estimators.

Federated learning of foundation models faces a fundamental resource-asymmetry challenge: the institutions holding the most valuable domain-specific data cannot host billion-parameter models. Existing heterogeneous federated approaches attempt to bridge this gap through parameter-efficient tuning, model pruning, or knowledge distillation, yet each trades away a critical property, whether full-model memory reduction, architectural self-containedness, or representational fidelity, leaving the core tension unresolved. We propose FedSLM, a parameter-centric framework for federated fine-tuning with heterogeneous compressed clients. FedSLM uses SVD-based decomposition to produce self-contained client models, whose low-rank subspaces form nested manifolds that are structurally compatible for aggregation. It then applies a two-stage protocol that synchronizes lightweight adapters within compression groups and fuses full-rank reconstructions across groups via structural alignment. Finally, a weak-to-strong elicitation step with auxiliary confidence loss transfers the aggregated knowledge to the full-scale server, while an explicit bias–variance trade-off mitigates compression artifacts. We provide theoretical guarantees for adapter-level aggregation, subspace-alignment bounds for cross-group fusion, and a characterization of how the confidence loss mitigates weak-supervision noise. Experiments on natural language and vision–language benchmarks show that FedSLM outperforms existing federated baselines under both IID and non-IID partitions, while client models operate at roughly 50

LSM-tree has been widely adopted as a key data structure in modern key-value stores, leveraging sequential append-only writes to achieve high write throughput in writeintensive applications. However, the unpredictability of LSMtree compaction introduces several critical challenges, including performance instability under peak loads or resource-constrained environments, write amplification due to repeated data rewriting, read amplification from multi-level queries, the non-trivial tradeoff between read and write performance, and inefficient space utilization leading to space amplification. While prior research has extensively investigated optimizations to mitigate these limitations, the field of LSM-tree optimization continues to evolve, with numerous notable contributions emerging in recent years. This tutorial provides a timely review of state-of-the-art LSM-tree optimizations, with a particular focus on representative studies published within the last five years.

Database parameter automatic tuning is a significant challenge for database administrators (DBAs) in artificial intelligence (AI) enabled database (DB) systems. Optimizing key parameters is crucial for identifying critical interactions among them. Aiming to overcome the disadvantages of existing methods, we propose a collaborative multi-agents model called CMA+DB to automatically tune DB parameters in an effective and efficient fashion. CMA+DB integrates three components including SAPM (Single-Agent Pre-trained Model), MATM (Multi-Agent Joint Training Model), and PJTM (Probability-based Joint Training Model). SAPM applies the deep deterministic policy gradient to explore the impact of one single agent on DB performance, MATM uses multi-agent deep deterministic policy gradients to find agents that collaboratively work to improve DB performance, and PJTM can enhance parameter tuning by important agents based on a probabilistic selection factor. In the CMA+DB model, each agent is responsible for tuning a portion of the parameters, and multiple agents collaborate to recommend the optimal parameter configuration. This hybrid model can expand the number of tunable parameters in order to perform parameter tuning from the aspects of functions and parameter levels (i.e., global, DB, and session level). Experimental results reveal that CMA+DB obtains the fastest convergence performance (when reaching the largest throughput) of 14.83% faster than the state-of-the-art (SOTA) algorithms in the TPC-C benchmark on average. Essentially, after the phase of SAPM model training, CMA+DB outperforms the performance of the SOTA models in throughput. Furthermore, DB performance of CMA+DB can be improved by 1.758% through the phases of MATM and PJTM model training.

Log-structured merge trees (LSM-trees) serve as the backbone of modern storage engines, yet their compaction process frequently becomes the primary performance bottleneck in production environments, compromising quality of service (QoS) in latency-sensitive applications. While LSM-tree based database systems expose numerous tunable parameters, existing tuning approaches focus exclusively on optimizing average-case throughput and latency, leaving compaction-induced performance bottlenecks unaddressed. In this work, we formulate robustness to compaction-induced performance variability as a novel constrained optimization problem, aiming to reduce performance variance without violating the throughput and latency service level agreements (SLAs). We propose MerTune, a knowledge-driven and constraint-aware Bayesian optimization framework designed for LSM-tree compaction tuning. MerTune models both the optimization objective and SLA constraints via Gaussian processes, while leveraging large language models (LLMs) to extract and group parameter knowledge from the database's official documentation. By integrating workload characterization, LLM-guided parameter selection, and knowledge-driven Bayesian exploration, MerTune improves robustness against compaction-induced performance fluctuations. MerTune has been applied to OceanBase database, and extensive evaluations under representative workloads demonstrate that it reduces throughput fluctuation by over 66.4%, latency fluctuation by over 45.5%, and CPU utilization fluctuation by over 17.1%, achieving superior optimization effectiveness and faster convergence compared to state-of-the-art tuning methods.

Modern distributed databases face challenges in achieving transactional consistency across distributed partitions. Traditional two-phase commit (2PC) protocols incur high coordination overhead and latency, and require complex recovery for dynamic partition transfers. This paper introduces a novel tree-shaped 2PC framework for OceanBase that leverages single-machine log streams to address these challenges through three innovations. First, we propose log streams as atomic participants, replacing partition-level coordination. By treating each log stream as the commit unit, a transaction spanning $N$ co-located partitions interacts with one participant, reducing coordination overhead by orders of magnitude (e.g., 99 percent reduction for $N=100$). Second, we design a tree-shaped 2PC protocol with coordinator-rooted DAG topology that dynamically handles partition transfers by recursively constructing commit trees. When a partition migrates during a transaction, the protocol embeds migration contexts as leaf nodes, eliminating explicit participant list updates, resolving circular dependencies, and ensuring linearizable commits under topology changes. Third, we introduce prepare-unknown and trans-unknown states to prevent consistency violations when participants lose context. These states signal uncertainty during retries, avoiding erroneous aborts from so-called lying participants while isolating users from ambiguity. Experimental evaluation demonstrates performance approaching that of single-machine transactions, with reduced latency and bandwidth consumption, validating the framework's effectiveness for modern distributed databases.

Locality-sensitive hashing (LSH) is a well-known solution for approximate nearest neighbor (ANN) search with theoretical guarantees. Traditional LSH-based methods mainly focus on improving the efficiency and accuracy of query phase by designing different query strategies, but pay little attention to improving the efficiency of the indexing phase. They typically fine tune existing data-oriented partitioning trees to index data points and support their query strategies. However, their strategy to directly partition the multidimensional space is time-consuming, and performance degrades as the space dimensionality increases. In this paper, we design an encoding-based tree called Dynamic Encoding Tree (DE-Tree) to improve the indexing efficiency and support efficient range queries. Based on DE-Tree, we propose a novel LSH scheme called DET-LSH. DET-LSH adopts a novel query strategy, which performs range queries in multiple independent index DE-Trees to reduce the probability of missing exact NN points. Extensive experiments demonstrate that while achieving best query accuracy, DET-LSH achieves up to 6x speedup in indexing time and 2x speedup in query time over the state-of-the-art LSH-based methods. In addition, to further improve the performance of DET-LSH, we propose PDET-LSH, an in-memory method adopting the parallelization opportunities provided by multicore CPUs. PDET-LSH exhibits considerable advantages in indexing and query efficiency, especially on large scale datasets. Extensive experiments show that, while achieving the same query accuracy as DET-LSH, PDET-LSH offers up to 40x speedup in indexing time and 62x speedup in query answering time over the state-of-the-art LSH-based methods. Our theoretical analysis demonstrates that DET-LSH and PDET-LSH offer probabilistic guarantees on query answering accuracy.

Multi-view attributed graphs (MVAG) are well-known for their ability to model complex networks and relationships, which can provide diverse yet complementary information for finding a consensus partition suitable for all views. There have been abundant methods for clustering over multi-view attributed graphs. However, most of them are not suitable for large-scale graphs due to high complexity. Moreover, while existing anchor-based methods can effectively accelerate clustering, they mainly focus on either attribute information or graph structure during anchor selection, and some suffer from stability issues. Inspired by this, in this paper, we propose the adaptive virtual anchor clustering method (AVAC) to boost clustering performance and keep stable results. In particular, we first introduce adaptive virtual anchors for multi-view attributed graphs, which are learned and generated from graphs adaptively. After that, we connect anchor learning and anchor graph construction closely and cyclically to learn virtual anchors dynamically and make them capture real data distribution and topology information more accurately. Last but not least, we design a five-block coordinate descent method with proven convergence to further optimize our virtual anchors more representative of existing nodes. Extensive experiments over both real and synthetic datasets demonstrate the effectiveness, efficiency, and stability of our method. Compared to state-of-the-art approaches, the AVAC algorithm always gains stable results with a significant improvement in accuracy, and achieves a speedup of 1.8 times on public large-scale datasets. The source code is available at https://github.com/lmyfree/AVAC.

LSM-trees have been widely adopted in modern database systems owing to their log-structured design and sequential write efficiency. This design makes them particularly suitable for write-intensive, large-scale scenarios. However, a critical challenge lies in the flush and compaction processes in the LSM-tree, which often lead to performance fluctuation. Existing tuning strategies, including manual configurations and machine learning or LLM-based methods, struggle to adapt to dynamic workload patterns (e.g., sequential vs. random writes, Zipfian vs. uniform distributions). These methods also incur high tuning overhead and fail to mitigate severe I/O contention and performance spikes. In this paper, we propose Tetris, a lightweight hyperparameter auto-tuning framework designed to mitigate performance spikes in LSM-based key-value stores. Tetris dynamically adjusts LSM-tree configurable parameters by monitoring performance spikes, workload patterns, and realtime resource utilization during runtime. It contains three key components: a performance-driven tuning trigger, which determines when to initiate parameter adjustments; a workload-aware parameter selector, which identifies what parameters to tune based on workload characteristics; and a resource-efficient autotuner, which optimizes resource utilization while adapting to the current LSM-tree status. We evaluate Tetris on RocksDB using db_bench benchmarks and real-world YCSB workloads. Experimental results show that Tetris mitigates performance spikes across various workloads with minimal overhead. Compared to ADOC, it reduces average latency by 18% (up to 62%) and improves throughput by 38% (up to 1.64×). For tail latency, Tetris cuts P99 and P99.9 read latency by 54% and 53%, respectively, while maintaining comparable write tail latency with a 66% lower standard deviation in write latency.

Differential Privacy (DP) has become the gold standard for protecting individual privacy in data analytics, and the shuffle-DP model has attracted significant attention from both academia and industry due to its favorable balance between privacy and utility. However, existing shuffle-DP protocols rely on a strong assumption: all users behave honestly. In real-world scenarios, adversarial users can exploit this vulnerability through poisoning attacks, compromising both privacy guarantees and the utility of analytical results. While defending against poisoning attacks in the shuffle-DP model has recently gained interest, existing solutions are limited to frequency estimation tasks. To address this issue, we propose the first general defense framework for all union-preserving queries, capable of transforming any shuffle-DP protocol into a version resilient to poisoning attacks. Beyond robust defense against poisoning attacks, our framework achieves high utility of analytical results. Compared to the original shuffle-DP protocol, it retains asymptotically equivalent error in attack-free settings and incurs only a polylogarithmic increase in error when a constant number of attackers are present. We demonstrate the generality of our framework on several common queries, including summation, frequency estimation, and range counting. Experimental results confirm that our approach effectively defends against poisoning attacks while maintaining strong utility and communication efficiency.

Column Type Annotation (CTA), which assigns a semantic type to a table column, underpins data integration, cleaning, and search over data lakes. State-of-the-art annotators are pre-trained language models (PLMs) fine-tuned on one particular corpus of tables, i.e., a source data lake, and they degrade sharply once deployed on a new (i.e., target) lake, whose tables and semantic type set both differ. Retraining per lake is prohibitive because it demands large volumes of expert annotations. We recast cross-lake adaptation as a knowledge management problem and make the resulting decomposition explicit: relative to a target annotator, a source annotator holds knowledge that must be discarded (source-specific), realigned and reused (shared), or acquired (target-specific). This decomposition exposes which part of the gap a general-purpose LLM can close and which part only target supervision can. Guided by it, we present LakeHopper, which adapts a source annotator under a fixed annotation budget through three coupled mechanisms: label-set realignment that transplants the output layer for shared types, LLM-verified gap discovery that localizes columns the annotator handles unreliably, and cluster-based propagation plus rehearsal fine-tuning that generalizes each flagged column into a labeling batch without erasing shared knowledge. Casting the LLM as a verifier of the annotator's own predictions rather than an annotator keeps every output inside the target type set, so LakeHopper structurally emits no out-of-domain labels, whereas prompted LLMs hallucinate types on 2.7-47.6

Leveraging large language models (LLMs) to analyze complex documents – such as academic papers, technical manuals, and financial reports – has emerged as a mainstream and critical task in both research and industry. In practice, users must first filter relevant documents from large collections and then conduct in-depth analysis (e.g. question answering) over the selected subset, yet existing systems flatten documents into plain-text chunks, discarding the rich hierarchical structures (sections, tables, figures, equations) and degrading downstream performance. We present DocMaster, a hierarchical structure-aware document analysis system. DocMaster parses documents into hierarchical document trees preserving original layouts and constructs a structure-aware semantic index that enables accurate document filtering and in-depth analysis. We demonstrate DocMaster through an interactive web interface that enables users to upload document collections, construct tree-based and multi-view semantic indices, filter relevant documents via natural-language conditions, and perform follow-up question answering over the filtered results. The source code, data, and demo are available at https://doc-master.github.io/.

Vertical federated learning (VFL) considers model training when the features of data samples are partitioned over a set of clients. As the standard practice of VFL, SplitNN decomposes a model into a bottom part on the clients and a top part on a server, and requires the clients and server to exchange activations/gradients in every mini-batch. We observe that SplitNN is inefficient due to frequent client-server communication and propose random projection (i.e., RAP) to improve efficiency. RAP is radically simple, i.e., the clients transform their local features and transfer the transformed data to the server, and the server trains on the transformed data without communicating with the clients. As only one round of client-server communication is required, RAP is much more efficient than SplitNN. RAP uses Gaussian projection matrix as the data transformation. Data privacy is preserved because the projection matrix of each client is private and resembles the bottom model of SplitNN. Model accuracy is not affected because the Gaussian projection matrix is invertible and preserves the geometry of the original space. To evaluate RAP, we experimented with both regression and classification tasks on six datasets. The results show that RAP matches SplitNN in model accuracy and accelerates training by over 630 × .

Although an increasing number of databases now embrace shared-storage architectures, current storage-disaggregated systems have yet to strike an optimal balance between cost and performance. In high-concurrency read/write scenarios, B+-tree-based shared storage struggles to efficiently absorb frequent in-place updates. Existing LSM-tree-backed disaggregated storage designs are hindered by the intricate implementation of cross-node shared-log mechanisms, where no satisfactory solution yet exists. This paper presents OceanBase Bacchus, an LSM-tree architecture tailored for object storage provided by cloud vendors. The system sustains high-performance reads and writes while rendering compute nodes stateless through shared service-oriented PALF (Paxos-backed Append-only Log File system) logging and asynchronous background services. We employ a Shared Block Cache Service to flexibly utilize cache resources. Our design places log synchronization into a shared service, providing a novel solution for log sharing in storage-compute-separated databases. The architecture decouples functionality across modules, enabling elastic scaling where compute, cache, and storage resources can be resized rapidly and independently. Through experimental evaluation using multiple benchmark tests, including SysBench and TPC-H, we confirm that OceanBase Bacchus achieves performance comparable to or superior to that of HBase in OLTP scenarios and significantly outperforms StarRocks in OLAP workloads. Leveraging Bacchus's support for multi-cloud deployment and consistent performance, we not only retain high availability and competitive performance but also achieve substantial reductions in storage costs by 59

With the rapid evolution of Large Language Models (LLMs), multi-round workflows, such as autonomous agents and iterative retrieval, have become increasingly prevalent. However, this raises hurdles for serving LLMs under prefill-decode (PD) disaggregation, a widely adopted paradigm that separates the compute-bound prefill phase and memory-bound decode phase onto individual resources. Specifically, existing systems overlook the interleaved prefill-decode workload pattern in multi-round inference, leading to sub-optimal handling of the incremental prefill workloads and model deployment for the two phases. In this work, we present AMPD, a brand new disaggregated serving framework for multi-round LLM inference. The core of AMPD is to coordinate the prefill workloads based on real-time workloads by adaptively determining to carry out these workloads and they are scheduled, in order to maximize service level objective (SLO) attainment. In addition, we tailor a planning algorithm for our scenario, facilitating the deduction of optimal resource allocation and parallel strategies for the two phases. Empirical results demonstrate that AMPD substantially improves SLO attainment compared to state-of-the-art baselines.

Vertical multimodal federated learning (VMFL) enables multiple clients holding data from different modalities to conduct collaboratively model training. Existing methods typically assume that multimodal data samples (i.e., text and image) from the same entity (i.e., person) are paired across the clients (i.e., aligned). However, this assumption rarely holds in practice, as data is often collected independently with no shared identifiers. To address this challenge, we propose hashing-based alignment (HAL), a new VMFL framework that works without pre-aligned samples. HAL consists of two key components. The first component is an efficient and privacy-preserving method to identify similar samples from different modalities as aligned pairs. It adopts locality sensitive hashing (LSH) for the efficient retrieval of similar samples, introduces a shift-orthogonal hashing scheme to tackle the gaps between different modalities, and uses a bloom-style method for secure Hamming distance estimation. We prove that the shift-orthogonal hashing reduces distance estimation errors and secure Hamming distance estimation satisfies differential privacy. The second component is a neighbor-aware fusion strategy, which applies cross-attention to aggregate informative signals from the aligned samples without relying on explicit similarity scores. Experimental results on two real-world datasets show that compared with five state-of-the-art (SOTA) baselines, HAL improves the cross-modal retrieval accuracy by over 63%, while also achieving up to 154x speedup.