CATune: Structural Constraint-Aware Bayesian Optimization for DBMS Configuration Tuning

arXiv:2610.09276 · cs.DB, cs.LG · Submitted 2026-10-07 · Read on arXiv

Listen

Transcript

Introduction to the show: ident: AI Radio. Generated commentary on the latest Artificial Intelligence papers.

Tom: Today's paper: "CATune: Structural Constraint-Aware Bayesian Optimization for DBMS Configuration Tuning".

Jane: The gist The CATune framework is a constraint-aware Bayesian optimization (BO) system that models deterministic inter-knob ordering constraints as structural components of the search domain to substantially improve sample efficiency…

Tom: First, who's behind it and why it matters.

Paper summary: Jane: So, what is this system actually doing in terms of how it works? It seems they have a two-part approach starting with how they extract that constraint information.

Tom: Right. They have a precision-first extraction pipeline first, which uses schema-constrained LLM parsing combined with symbolic normalization and high-precision rule templates to pull out those documentation rules safely.

Lu: This extraction process involves candidate retrieval where the LLM parses the documentation into knobcentric entries and identifies dependency-relevant paragraphs by looking at knob co-mentions and trigger expressions (<ref:2610.09276#pg1>).

Meng: So, if the LLM pulls out a relationship, how does it make sure that output is actually correct and structured for the optimization engine? That’s where the schema-constrained extraction comes in, requiring structured JSON records and providing supporting evidence spans for every extracted relation.

Lalam: And then they move into constraint-aware Bayesian optimization, where they modify the standard BO to enforce these structural dependencies during both exploration and exploitation (<ref:2610.09276#pg1>).

Tom: In the exploration phase, they construct a topology graph that encodes all those knob dependency relationships, harmonize different units across knobs for consistent comparison, and then perform topology-aware sampling in the normalized space to make sure every generated configuration satisfies active constraints without any rejection (<ref:2610.09276#pg1>).

Jane: And during exploitation, they restrict what the optimizer can even look at by limiting acquisition maximization only to the feasible configuration space defined by those dependency constraints, discarding any candidate configurations that violate a constraint when maximizing within a local neighborhood N (theta t) (<ref:2610.09276#pg2>).

Lu: The specific mechanism they use to avoid rejection-based constrained sampling is the topology-aware sampler, which generates configurations directly in the dependency-consistent order defined by the topology graph G = (V, E), where an edge b to a indicates that b must be assigned before a if the constraint is theta i less than or equal to theta j (<ref:2610.09276#pg2>).

Meng: So they compute this topological order pi by running TopoSort on G, and then they sample root knobs, which are nodes with no incoming edges, using Latin Hypercube Sampling (LHS) to start the process (<ref:2610.09276#pg2>).

Tom: The overall result of this is that by filtering structurally invalid regions before evaluation, CATune substantially improves sample efficiency and robustness for tuning PostgreSQL and MySQL configurations on TPC-C and TPC-H workloads (<ref:2610.09276#pg3>).

Conclusion: Jane: So we've seen how this paper, "CATune: Structural Constraint-Aware Bayesian Optimization for DBMS Configuration Tuning," works—it’s about explicitly modeling those deterministic ordering constraints as structure within the optimization domain.

Tom: Exactly. The authors show that instead of letting the ML model implicitly learn feasibility by seeing violations, CATune performs optimization within a constraint-consistent subspace (<ref:2610.09276#pg1>).

Lu: The key finding is that this approach substantially improves sample efficiency and robustness because it filters structurally invalid regions prior to evaluation, which reduces unnecessary trials (<ref:2610.09276#pg3>).

Meng: When we look at the numbers, they reach the baseline optimum up to twelve point five times faster and improve throughput by up to sixty-three point three seven percent under default ranges (<ref:2610.09276#pg3>). That’s a significant jump for our tuning pipeline.

Jane: It also shows consistency across different surrogate models, like random forest versus Gaussian process, and different BO frameworks, meaning this method isn't just a fluke on one setup (<ref:2610.09276#pg3>).

Tom: The paper suggests that structural constraint injection is more sample-efficient and effective than penalty-based handling because it proactively filters out infeasible regions, rather than passively exploring the full space while penalizing violations (<ref:2610.09276#pg3>).

Lu: They also found that CATune reaches the baseline optimum approximately three point nine three times and three point five seven times faster on TPC-C and TPC-H respectively compared to the baseline method (<ref:2610.09276#pg3>).

Jane: So, what does this mean for us in practice? It means that instead of training a model on thousands of bad configurations, we can use documented knowledge about how knobs relate to each other to guide the search much more intelligently from the very start (<ref:2610.09276#pg1>).

Tom: It shifts the focus from learning complex feasibility boundaries through expensive feedback to leveraging existing system documentation directly in the optimization process (<ref:2610.09276#pg3>).

Meng: For deployment at scale, this means we can expect faster convergence times and better stability when tuning these complex database systems because we are only testing configurations that are structurally valid from the beginning (<ref:2610.09276#pg1>).

Lu: The limitation they mention is that they aren't necessarily capturing every single undocumented dependency in the system; it relies heavily on what is explicitly documented (<ref:2610.09276#pg3>).

Jane: So, the idea is to use those known dependencies to make the tuning process inherently more structured and less reliant on expensive trial and error across a vast, messy search space (<ref:2610.09276#pg1>).

Fangping Lan, Qi Zhang, Eduard Dragut

Temple University

cs.DB, cs.LG

Submitted: 2026-10-07

Updated: 2026-10-07

Comments: 14 pages including references, 10 figure, 2 tables. Accpeted by PVLDB, Volume 19, 2026

DOI: 10.14778/3849398.3849421

Code: https://github.com/lanfangping/CATune

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 80/100

The gist: The gist The CATune framework is a constraint-aware Bayesian optimization (BO) system that models deterministic inter-knob ordering constraints as structural components of the search domain to

Key concepts

Constraint-Aware Bayesian Optimization (BO): This is a method of searching for the best database settings by using a probabilistic model. CATune modifies this standard search by treating known rules about which knobs must be set before others as hard boundaries. This prevents the system from wasting time testing invalid or impossible configurations, making the search much more focused and efficient.
Precision-First Extraction: This is the initial step where the system reads documentation to find knob dependencies. It uses a large language model (LLM) guided by schema rules to safely extract relationships between knobs. The goal is to turn natural language descriptions of constraints into structured, machine-readable data that the optimization algorithm can understand and use.
Topology-Aware Sampling: This is a smart way to generate new configuration suggestions during the search process. Instead of randomly picking settings, this technique uses a graph representing all knob dependencies to create a specific order for testing. It ensures that when new configurations are generated, they follow the required dependency structure, avoiding invalid tests altogether.

Terminology

Bayesian Optimization — 1× in this paper · explained in 3 episodes

Summary

The gist The CATune framework is a constraint-aware Bayesian optimization (BO) system that models deterministic inter-knob ordering constraints as structural components of the search domain to substantially improve sample efficiency and final tuning quality for DBMS configuration tuning.

Problem Motivation

Existing ML-based tuning systems typically treat the configuration domain as box-constrained and rely on workload feedback to implicitly capture inter-knob relationships, leading to wasted evaluations of invalid configurations. The paper hypothesizes that explicitly encoding deterministic knob dependency constraints into the optimization process can substantially improve sample efficiency and robustness. This motivation stems from the fact that many sampled configurations are either invalid or uninformative, which increases operational cost and slows model convergence.

CATune Design Components

CATune is a system that systematically incorporates documented structural knob dependencies into the optimization process. It consists of two major components: (1) precision-first extraction and (2) constraint-aware Bayesian optimization.

The precision-first extraction pipeline is designed to safely inject documentation-driven dependencies into tuning by coupling schema-constrained LLM parsing with symbolic normalization and high-precision rule templates. This pipeline involves several steps:

Candidate retrieval, which parses the documentation into knobcentric entries and identifies dependency-relevant paragraphs using knob co-mentions and trigger expressions.
Schema-constrained extraction, where the LLM must return structured JSON records and provide a supporting evidence span for every extracted relation.

Constraint-Aware Bayesian Optimization

CATune modifies standard BO to enforce structural dependencies during both exploration and exploitation. The core idea is to restrict the optimizer to valid configurations by construction, thereby eliminating infeasible evaluations and improving sample efficiency.

The exploration phase involves a five-step procedure:

Constructing a topology graph encoding knob dependency relationships.
Harmonizing heterogeneous units across knobs to enable consistent comparisons.
Performing topology-aware sampling in the normalized space, ensuring all generated configurations satisfy active constraints without rejection.

The exploitation phase restricts acquisition maximization to the feasible configuration space defined by the dependency constraints. Specifically, when maximizing within a local neighborhood N (θt), candidate configurations that violate any dependency constraint are discarded.

Topology-Aware Sampling Strategy

To avoid rejection-based constrained sampling, CATune proposes a topology-aware sampler that generates configurations directly in a dependency-consistent order defined by the topology graph.

The topology graph G = (V, E) represents the structure, where an edge b → a indicates that b must be assigned before a if the constraint is thetai ≤ thetaj. The process involves:

Computing the topological order π ← TopoSort(G).
Sampling root knobs (nodes with no incoming edges) using Latin Hypercube Sampling (LHS).

Evaluation and Results

Experiments on PostgreSQL and MySQL using TPC-C and TPC-H workloads show that CATune substantially improves both sample efficiency and final tuning quality across surrogate models and BO frameworks. Under default ranges, CATune reaches the baseline optimum up to 12.5× faster and improves throughput by up to 63.37%. These results demonstrate that explicitly modeling system-defined deterministic ordering constraints enhances optimization robustness and system stability.

The ablation study confirms the effectiveness of topology-aware sampling, showing that it achieves 18.8% higher throughput and reaches the same performance level 2.19× faster compared to SMAC + Rules. Furthermore, CATune consistently improves both sample efficiency and final performance across different surrogate models (random forest vs. Gaussian process) and BO frameworks (standard GP-BO vs. coarse-to-fine GPTuner).

Discussion on Constraint Employment

CATune demonstrates that proactive filtering yields faster convergence by eliminating infeasible regions prior to optimization. This contrasts with passive penalization, which explores infeasible configurations within the full search space while penalizing violations. The results show that CATune reaches the baseline optimum approximately ∼ 3.93× and 3.57× faster than the baseline on TPC-C and TPC-H, respectively.

The paper concludes that structural constraint injection is more sample-efficient and effective than penalty-based handling.

Improvements for AI systems

Bold header: Topology-Aware Sampling for Feasibility

This strategy generates feasible configurations directly by traversing a topology graph defined by knob dependencies, which eliminates rejection entire[ly] and avoids the inefficiency of post-hoc constraint handling.

Bold header: Precision-First LLM Extraction Pipeline

The system utilizes a pipeline combining schema-constrained LLM parsing with symbolic normalization and high-precision rule templates followed by an agentic guardrail that applies self-reflection and LLM-as-judge verification to mitigate hallucinated dependencies.

Bold header: Constraint-Aware Search Space Restriction

CATune modifies standard Bayesian optimization by restricting acquisition maximization to the feasible configuration space defined by the dependency constraints, ensuring that the optimizer no longer wastes trials on structurally invalid settings.

Abstract

Modern DBMSs expose hundreds of configuration knobs, resulting in a high-dimensional and heterogeneous search space that makes automated tuning costly. Existing ML-based tuning systems typically treat the configuration domain as box-constrained and rely on workload feedback to implicitly capture inter-knob relationships. However, DBMS documentation specifies deterministic knob dependency constraints, particularly ordering constraints, that characterize structurally valid regions of the configuration space. We present CATune, a constraint-aware Bayesian optimization (BO) framework that models deterministic inter-knob ordering constraints as structural components of the search domain. Instead of learning feasibility boundaries through sampled violations, CATune performs optimization within a constraint-consistent subspace. We develop a topology-aware sampling strategy that respects dependency structure during exploration and avoids the inefficiencies of post-hoc constraint handling. To enable automated constraint discovery, we further design a precision-first extraction pipeline that combines LLM-based parsing with reliability safeguards to mitigate hallucinated dependencies. Experiments on PostgreSQL and MySQL using TPC-C and TPC-H workloads show that CATune substantially improves both sample efficiency and final tuning quality across surrogate models and BO frameworks. Under default ranges, CATune reaches the baseline optimum up to 12.5x faster and improves throughput by up to 63.37%. The improvements persist under knowledge-guided reduced ranges and alternative optimization implementations. These results demonstrate that explicitly modeling system-defined deterministic ordering constraints enhances optimization robustness and system stability.