Mixed-Type Relational Database Synthesis with Graph-Prompted Language Model

arXiv:2611.02373v1 [cs.DB] 2 Nov 2026

Mixed-Type Relational Database Synthesis with Graph-Prompted Language Model Yuxiang Sun

Mengshi Chen

Jianwei Wang

Shanghai Jiao Tong University Shanghai, China scscsc04@sjtu.edu.cn

Shanghai Jiao Tong University Shanghai, China chenmengshi@sjtu.edu.cn

University of New South Wales Sydney, Australia jianwei.wang1@unsw.edu.au

Wenjie Zhang

Kai Wang

University of New South Wales Sydney, Australia wenjie.zhang@unsw.edu.au

Shanghai Jiao Tong University Shanghai, China w.kai@sjtu.edu.cn

ABSTRACT Data access is often limited by privacy or proprietary restrictions, motivating relational database synthesis, which synthesizes realistic contents across related tables. Relational databases couple multitable structure with mixed-type attributes and intricate semantic dependencies among values, making realistic synthesis challenging. In this paper, we propose REMIX , a unified framework for realistic RElational database synthesis with MIXed-type attributes. REMIX integrates a small language model (SLM) and a large language model (LLM) through two key phases: Graph-to-Prompt Tuning and Collaborative SLM–LLM Decoding. To capture attribute dependencies within and across tables, Graph-to-Prompt Tuning represents the database as an attributed heterogeneous graph. We project mixed-type record embeddings and aggregated relational context into soft prompts that serve as continuous vectors for an SLM. We jointly optimize the graph-to-prompt mapping and SLM through autoregressive attribute reconstruction. Furthermore, to reduce semantic inconsistencies, Collaborative SLM–LLM Decoding combines SLM-based record generation with repair programs induced by an LLM. The LLM discovers semantic dependencies, iteratively refines them through independent validation with a statistical bound on the overall probability of false acceptance, and translates validated dependencies into tested programs that repair generated values. Extensive experiments on seven real-world relational databases demonstrate the effectiveness of REMIX in generating high-fidelity data with improved semantic consistency and downstream utility.

1

INTRODUCTION

Relational databases organize records and represent their relationships across tables [8]. They support efficient data management and retrieval, making them a cornerstone of large-scale information systems in e-commerce [1, 17], healthcare [35], and enterprise applications [39, 40]. However, access to real-world databases is often limited by privacy concerns, proprietary restrictions, and data collection costs [10, 11, 21]. Relational database synthesis addresses this problem by generating synthetic database content that preserves the statistical properties and relational dependencies of the source data [19, 30], thereby providing an alternative data source for downstream applications. Real-world relational databases contain numerical, categorical, and textual attributes whose dependencies can span multiple tables [4, 9, 32]. Textual descriptions provide contextual details that

Input: source relational database D Numerical Categorical orders order_id PK O1 order_items

channel web

subtotal 90

order_idFK item_idPK qty

O1 O1

I1 I2

note Home-office lighting and seating

price

amount

30 60

30 60

1 1

Textual

description Adjustable desk lamp Ergonomic office chair

Mixed-type record synthesis Output: synthetic database orders order_id PK O1 order_items

channel web

subtotal 110①

order_idFK item_idPK qty

O1 O1

I1 I2

2 1

note Office lighting and seating set

price

amount

20 60

45② 60

description Warm-white LED desk lamp Mesh office chair

Semantic dependencies and corrections

① subtotal = Σ linked amounts 40 + 60: 110 ✗ → 100 ✓

② amount = qty × price 2 × 20: 45 ✗ → 40 ✓

Figure 1: Mixed-type relational database synthesis. complement numerical and categorical values. Meanwhile, semantic dependencies express arithmetic relationships, domain constraints, and business rules at both record and database levels. Excluding attributes or failing to preserve their semantic dependencies can therefore affect analytical results and downstream predictions. Figure 1 illustrates this synthesis task using a shopping database, where an item’s amount equals its quantity times its unit price and an order’s subtotal equals the sum of its linked item amounts. Table 1 compares representative relational database synthesis methods. In early stages, SDV [30] synthesizes related tables using a hierarchical statistical framework, but its assumptions and aggregate summaries can limit the dependencies captured. Conventional neural methods model attribute distributions and relational dependencies through generative adversarial networks (GAN) in RC-TGAN [13], variational autoencoders (VAE) in GraphVAE [26], and autoregressive (AR) models in TabularARGN [37]. However, GANs can suffer from instability and mode collapse, VAEs balance regularization and reconstruction fidelity, and AR models can accumulate errors. Their native support is generally limited to numerical and categorical attributes.

TRAINING Input User u

u

···

···

Denoiser

r

Review

Noise

Input

Serialized records

Fine-tune

Records

···

u

u

Product p ···

p

Parent LMs

Graph context

p

Product p ··· r

Graph-to-Prompt Tuning

TRAINING Real records

GNN

User u

Review

+

Learn to denoise

Noisy records

INFERENCE

r

u

···

p

Parent prefix

r

Child LM

Target

INFERENCE

Row embeddings

User ···

u

Product p ··· r

u

p r

↻

User u ···

GNN

Product p ···

Joint denoising

Review r

u

Product p ···

User u ···

Parent LMs

Parent records

p

Review ···

Joint tuning

u

r

r

Tuned SLM

Encoding & prompt mixing

Semantic Repair

Noise-tolerant dependency discovery Schema, profiles & samples

(b) Parent-conditioned LM

Output

Soft prompts

p

Review

Child LM

Parent prefix

(a) Graph-conditioned diffusion

SLM

r

Relational graph

Denoiser

Attribute reconstruction Soft prompts

Collaborative SLM–LLM Decoding

Output

Initial noise

p

Discovery & validation

check(·) compute(·) repair(·)

u

User ···

p

Product ··· Review

r Tested repair programs

(c) REMIX (ours)

Figure 2: Framework comparison for relational database synthesis. (a) Graph-conditioned diffusion trains a GNN denoiser with relational context, then jointly denoises related records from noise. (b) Parent-conditioned LM trains on serialized records, then generates parents followed by parent-conditioned children. (c) REMIX jointly tunes its graph-to-prompt mapping and SLM via attribute reconstruction, while an LLM prepares tested programs from validated semantic dependencies. During decoding, the SLM generates mixed-type records from soft prompts, and the programs compute derived values and repair inconsistencies. Table 1: Comparison of relational database synthesis methods. ✓ denotes support; ✗ denotes no native support. Abbr: AR (autoregressive), GAN (generative adversarial network), GNN (graph neural network), LM (language model).

Method

Column Type Coverage Semantic Repair Num. Cat. Text

These limitations motivate joint modeling of mixed-type attributes across related tables. Moreover, a synthetic database can closely match individual attribute distributions while violating semantic dependencies [34]. For example, in a shopping database, an order’s subtotal should equal the sum of its linked item amounts. A synthesized order with item amounts of 40 and 60 but a subtotal of 110 violates this dependency despite valid foreign-key links. A naive approach is to check generated records directly, either manually or with an LLM, but such checks can overlook dependencies and yield inconsistent judgments across repeated evaluations. These limitations motivate incorporating semantic dependencies into synthesis to reduce inconsistencies among generated values. Challenges. Modeling mixed-type attributes across related tables while reducing semantic inconsistencies involves two challenges. Challenge I. Incorporating relational context into joint modeling of mixed-type attributes is difficult because relevant information spans heterogeneous records and multiple relationship paths. Parent conditioning can omit information from other connected records, while one-to-many joins repeat shared records and produce long serialized inputs. Compressing input while preserving the attribute semantics and relation types needed to capture cross-table dependencies is therefore difficult. Challenge II. The diverse forms and context-dependent applicability conditions of semantic dependencies complicate their reliable discovery from source data and safe application during synthesis. Inferred dependencies may reflect statistical associations or hold only under specific conditions. Applying them to all synthesized records can therefore lead to incorrect changes. Moreover, noise in the source databases can also cause occasional violations of otherwise valid dependencies, making it difficult to distinguish unreliable rules from valid ones affected by noise. Our approaches. To address these challenges, we propose REMIX , a unified framework for mixed-type relational database synthesis, as

Backbone

SDV [30] RC-TGAN [13] TabularARGN [37] GRDM [22] REaLTabFormer [33]

✓ ✓ ✓ ✓ ✓

✓ ✓ ✓ ✓ ✓

✗ ✗ ✗ ✗ ✗

✗ ✗ ✗ ✗ ✗

Statistical Model GAN AR GNN+Diffusion LM

REMIX

✓

✓

✓

✓

GNN+LM

Recent methods apply diffusion models and language models (LM) to relational database synthesis. As depicted in Figure 2(a), diffusion-based methods such as GRDM [22] and RelDiff [20] jointly denoise related records conditioned on relational context to capture cross-table dependencies. In parallel, LM-based synthesizers serialize records into token sequences and generate new records autoregressively. For example, REaLTabFormer [33] generates child records conditioned on previously generated parent records, as depicted in Figure 2(b). GReaTER [24] instead restructures and joins selected related records before serialization and generation. Motivations. LM-based synthesis can generate structured values and text through a common token representation [2]. Existing relational LM methods, however, typically obtain relational context from serialized parent records or selected table joins [24, 33], limiting the related information available for joint generation. Relational diffusion models incorporate cross-table context but primarily target numerical and categorical attributes [22]. Generating text independently of these attributes can overlook their dependencies.

2

Table 2: Symbols and Descriptions

illustrated in Figure 2(c). It first trains a small language model (SLM) for graph-conditioned generation through Graph-to-Prompt Tuning, then combines this generator with repair programs induced by a large language model (LLM) in Collaborative SLM–LLM Decoding. To address Challenge I, Graph-to-Prompt Tuning learns to supply mixed-type record information and relational context through soft prompts, continuous input vectors that condition the SLM. Specifically, we represent records and foreign-key links as an attributed heterogeneous graph. A type-aware row encoder maps each record’s mixed-type attributes to a row embedding, while a heterogeneous graph neural network (GNN) aggregates information from connected records. A projector maps the relational context together with a randomly masked row embedding into soft prompts. Masking encourages the SLM to use relational context during reconstruction. An autoregressive attribute reconstruction objective jointly trains the graph-to-prompt mapping and the SLM. This design supplies relational context without serializing joined tables or requiring a fixed table generation order. To address Challenge II, Collaborative SLM–LLM Decoding combines the tuned SLM generator with programs constructed by the LLM to repair violations of semantic dependencies. The LLM first proposes semantic dependencies from source data. Validation on independent samples accounts for source noise through a small violation tolerance and uses counterexamples to guide iterative refinement. A statistical acceptance criterion bounds the overall probability of accepting dependencies whose violation probabilities exceed the prescribed tolerance. The LLM then translates validated dependencies into executable programs, which are tested individually and together. The tested programs are reused across generated records. After the tuned SLM generates new records, the programs execute in dependency order to repair violations. REMIX checks interacting program updates together and rolls back changes that introduce new violations. Contributions. Our main contributions are summarized as follows.

Notation e D, D R, L G, V, E r𝑣 ,e r𝑣 h𝑣 P𝑣 𝑞𝜙 (𝑣) y𝑣 , e y𝑣 Θ C, C ∗ F

Description Source and synthesized relational databases Tables and foreign-key relationships Attributed graph, record nodes, and typed edges Row embedding and its randomly masked version GNN-derived context embedding Soft prompt used to condition the SLM decoder Table-specific generation instruction Serialized training label and generated sequence Trainable generator parameters Human-verified reference / LLM-discovered semantic dependency sets Semantic repair functions

Definition 1 (Relational Database Synthesis). Given a source relational database D, relational database synthesis aims to generate e by synthesizing numerical, categorical, and a synthetic database D textual non-key attribute values while preserving the source schema, table sizes, and primary- and foreign-key assignments. The goal is to reproduce attribute distributions and statistical relationships within and across tables as faithfully as possible. In this paper, we focus on synthesizing database contents while preserving the source schema, table sizes, and key assignments. Beyond matching statistical distributions, realistic synthesis requires preserving semantic dependencies among attribute values, which are introduced in Section 2.2. To jointly model and generate numerical, categorical, and textual attributes, language models provide a common autoregressive formulation. Section 2.3 presents this formulation and the adaptation techniques used in our approach.

2.2

• We study mixed-type relational database synthesis and propose REMIX , a unified framework for jointly generating structured values and text across related tables. • We design Graph-to-Prompt Tuning, which uses type-aware encoding and heterogeneous graph propagation to construct soft prompts for learning mixed-type attribute distributions. • We develop Collaborative SLM–LLM Decoding, combining SLM generation with independently validated semantic dependencies and tested programs built by an LLM for computation and repair. • Experiments on seven real-world databases show REMIX ’s gains in fidelity, semantic consistency, and downstream utility.

Semantic Dependencies

Database content reflects real-world knowledge and application semantics, which impose requirements on how attribute values relate within and across tables. These requirements often remain implicit in the data and extend beyond declared schema constraints. In this work, semantic dependencies encompass functional dependencies, arithmetic relationships, and domain-specific rules. These dependencies are defined in Definition 2 and illustrated in Example 1. Definition 2 (Semantic Dependency). A semantic dependency is a deterministic rule over attribute values, specified by (i) a scope identifying the records or record groups to be checked within or across tables, (ii) an applicability condition, and (iii) a checkable assertion that needs to hold whenever the condition is met. Records violate the dependency if the applicability condition holds but the assertion does not. We denote a set of semantic dependencies by C.

2 PRELIMINARIES 2.1 Problem Statement We represent a relational database as D = (R, L), where R = {𝑅 (1) , . . . , 𝑅 (𝑚) } is a collection of 𝑚 tables and L is the set of primary-key–foreign-key relationships. Each table 𝑅 (𝑎) contains 𝑛𝑎 records with numerical, categorical, or textual non-key attributes. Primary keys uniquely identify records within a table, while foreign keys link records across tables.

Example 1. In a shopping database, the functional dependency {quantity, unit_price} → amount requires items with the same quantity and unit price to have the same amount. The arithmetic rule amount = quantity × unit_price specifies how that amount is computed. Across tables, an order’s subtotal equals the sum of the amounts of all its linked items. A conditional rule may further require tax = 0 for tax-exempt orders. These semantic dependencies 3

3.2

express requirements over individual records, related record groups, and records satisfying specific conditions.

2.3

LM-based Data Generation

Autoregressive generation. LMs, including the GPT [27] and Qwen [36] families, acquire broad world knowledge and strong reasoning and generation capabilities through large-scale text pretraining. Given a conditioning input 𝑐 and a target sequence 𝑦 = (𝑦1, . . . , 𝑦𝑇 ), the conditional probability is factorized as

𝑝𝜗 (𝑦 | 𝑐) =

𝑇 Ö

Attributed Heterogeneous Graph Building

Motivation. An attributed heterogeneous graph provides a natural representation of relational databases, preserving individual records and their foreign-key connections in a unified structure. Record nodes retain attribute information, while typed edges distinguish different relationships and enable context aggregation across connected records. Within each record, mixed-type attributes carry different forms of information. We therefore use type-aware encoding to preserve these characteristics and incorporate column semantics to identify what each value represents. Graph construction. Given a relational database D = (R, L), we construct an attributed heterogeneous graph G = (V, E, 𝜙,𝜓, X) to preserve its native relational structure. Here, V and E denote the node and edge sets, 𝜙 : V → R maps each node to its table type, 𝜓 : E → L ∪ L −1 maps each edge to its relation type, and X contains the non-key attributes. The set L −1 contains the reverse of each foreign-key relationship. For each row 𝑟𝑖(𝑎) in table 𝑅 (𝑎) , we create a node 𝑣𝑖(𝑎) ∈ V with node type 𝜙 (𝑣𝑖(𝑎) ) = 𝑅 (𝑎) . For each relationship 𝜌 ∈ L from table 𝑅 (𝑎) to table 𝑅 (𝑏 ) , if row 𝑟𝑖(𝑎) references row 𝑟 𝑗(𝑏 ) through 𝜌, we add two directed edges:

𝑝𝜗 (𝑦𝑡 | 𝑐, 𝑦 <𝑡 ),

𝑡 =1

where 𝜗 denotes the model parameters and 𝑦 <𝑡 contains the preceding tokens. New sequences are generated by successively sampling tokens from these conditional distributions. Existing methods, including GReaT for single-table synthesis and REaLTabFormer for multi-table synthesis, apply this autoregressive formulation to database synthesis by serializing records as token sequences. Fine-tuning and soft prompts. In supervised fine-tuning (SFT) [28], the model maximizes 𝑝𝜗 (𝑦 | 𝑐) over conditioning–target pairs (𝑐, 𝑦). Target tokens are predicted given their observed predecessors, and the sequence loss is used to optimize all or a subset of model parameters. Soft prompts [25] condition an LM through continuous vectors in its token embedding space. A soft prompt P ∈ R𝑀 ×𝑑LLM contains 𝑀 such vectors, where 𝑑 LLM is the token embedding dimension. Together with an instruction 𝑞, it forms the conditioning prefix H0 = [P; Emb(𝑞)], where Emb(𝑞) denotes the instruction’s token embeddings and [·; ·] denotes concatenation along the sequence dimension. In conventional soft prompt tuning, the prompt vectors are optimized while the pretrained LM remains frozen. Building on these preliminaries, we present REMIX ’s two stages: Graph-to-Prompt Tuning (Section 3), which jointly optimizes the SLM and a graph-to-prompt mapping through autoregressive reconstruction of mixed-type record attributes, and Collaborative SLM–LLM Decoding (Section 4), which synthesizes records and reduces semantic inconsistencies.

𝑒𝑖 𝑗 = (𝑣𝑖(𝑎) , 𝑣 𝑗(𝑏 ) , 𝜌), 𝜌

𝜌 −1

𝑒 𝑗𝑖

= (𝑣 𝑗(𝑏 ) , 𝑣𝑖(𝑎) , 𝜌 −1 ).

Their edge types are defined as 𝜌

𝜓 (𝑒𝑖 𝑗 ) = 𝜌,

𝜌 −1

𝜓 (𝑒 𝑗𝑖 ) = 𝜌 −1 .

These edge types distinguish messages from parent to child records and from child to parent records. Type-aware row encoding. Each record node is initialized with a row embedding of its non-key attributes. For node 𝑣𝑖(𝑎) corresponding to row 𝑟𝑖(𝑎) in table 𝑅 (𝑎) , we denote these 𝑑𝑎 attributes as (𝑎) x𝑖(𝑎) = {𝑥𝑖1(𝑎) , · · · , 𝑥𝑖𝑑 }. Their column names are {𝑐 1(𝑎) , · · · , 𝑐𝑑(𝑎) }, 𝑎 𝑎 with types 𝜏 (𝑐 𝑗(𝑎) ) ∈ {num, cat, time, text}. We encode each attribute value according to its column type: (𝑎) u𝑖(𝑎) 𝑗 = Enc𝜏 (𝑐 (𝑎) ) (𝑥𝑖 𝑗 ). 𝑗

Numerical values are normalized and encoded with Fourier features, while categorical values use a vocabulary embedding table. Temporal values are decomposed into calendar and linear-time features. For textual values, a frozen text encoder encodes the column name and cell value together as “table.column: value”. For non-textual attributes, the value embedding alone is insufficient because the same value can have different meanings under different column names. Therefore, REMIX further encodes each column name using the frozen text encoder:

3 GRAPH-TO-PROMPT TUNING 3.1 Overview Given a source relational database, realistic synthesis of mixedtype records requires modeling both the contents of individual records and their dependencies through foreign-key links. To this end, REMIX jointly learns a soft-prompt representation space for relational records and tunes an SLM to model attribute distributions conditioned on the resulting prompts. As illustrated in Figure 3, REMIX first constructs an attributed heterogeneous graph and encodes each record’s mixed-type attributes into a row embedding. A heterogeneous GNN then aggregates relational context, which is combined with a masked row embedding and projected into soft prompts. The SLM reconstructs record attributes conditioned on these prompts, providing a shared reconstruction objective for learning the mapping and adapting the SLM.

s (𝑎) = TextEnc(“𝑅 (𝑎) .𝑐 𝑗(𝑎) ”). 𝑗 (𝑎) The value embedding u𝑖(𝑎) 𝑗 and the column-name embedding s 𝑗 are then projected into a shared embedding space and combined by a gated fusion module: (𝑎) (𝑎) (𝑎) (𝑎) e𝑖(𝑎) 𝑗 = g𝑖 𝑗 ⊙ ū𝑖 𝑗 + (1 − g𝑖 𝑗 ) ⊙ s̄ 𝑗 , 4

Graph-to-Prompt Tuning Row encoding rating

sentiment

comment

created

r2

4.5

positive

“Good color”

2024-03-15

Number Encoder

Reconstruction

Relational context

id

Category Encoder

Text Encoder

Time Encoder

r2

Projector Instructed Decoder

P4

Learned soft prompts

Tuned parameters

Preliminary Output

Soft prompt tokens

Generate a Review record. rating (num.), sentiment (cat.) comment (text), created (time).

Selected soft prompts P1 P3 P4

PREFIX Hv

CONCAT

Tokenize & embed

…

Noise-tolerant dependency discovery

Corrected record

rating: 5.6 × [1, 5] sentiment: positive comment: “Crisp audio” created: 03/16/24 × format

review_id

r2

restored

user_id

u1

restored

prod_id

p2

restored

rating

5.0

repaired

Semantic repair

sentiment

positive

comment

“Crisp audio”

created

2024-03-16

1. Validate 2. Compute & repair 3. Restore keys

Tuned SLM Refine

reformatted

Refine

Dependency proposal

Sample

Update Enc, HGNN, Proj, LoRA

Semantic repair & output

Table instruction P2

Ltoken(y2, ŷ2)

SLM

SLM decoding Weighted aggregation

Token CE Loss

Soft prompt P2 h2

Collaborative SLM–LLM Decoding Soft-prompt kNN

Generate a Review record. rating (num.), sentiment (cat.) comment (text), created (time).

Heterogeneous GNN HGNN(G, r2)

r2

Profile

Mismatch

Table instruction

r2 = RowPool(SelfAttn(enum, ecat, etext, etime))

Schema

Reconstructed sequence ŷ2

p2

r3

Self-attention + Row Pooling

P1

Ground-truth tokens y2

[h2 || Dropout(r2)]

Node embedding

u1 u2

P3

Token-level learning

Residual Conditioning

p1

r1

Validation & Refinement

Database Information

Code Generation & Testing

</> Tested repair programs

Figure 3: Overview of REMIX, consisting of Graph-to-Prompt Tuning and Collaborative SLM–LLM Decoding. (𝑎) where ū𝑖(𝑎) are the projected value and column-name em𝑗 and s̄ 𝑗

each layer updates node 𝑣 by message passing:

beddings, and g𝑖(𝑎) 𝑗 is a learnable gate. Each fused attribute embed(𝑔+1)

h𝑣

ding captures both the value and its column meaning. For textual attributes, we use the projected text embedding as e𝑖(𝑎) 𝑗 , since it already encodes the column name and cell value. To capture dependencies among attributes within the same row, we apply a lightweight multi-head self-attention block over their embeddings. The refined embeddings are mean-pooled and projected into a row embedding:

where N𝜌 (𝑣) denotes the neighbors of 𝑣 connected by relation type (𝑔) (𝑔) 𝜌. The matrices W𝜙 (𝑣) and W𝜌 transform messages according to node and relation types, while AGG and 𝜎 denote neighborhood aggregation and a nonlinear transformation. After 𝐿 layers, the context embedding h𝑣 = h𝑣(𝐿) contains information from parent records, child records, and multi-hop relational neighborhoods. Repeated message passing can make record-specific information less distinguishable in the context embedding. REMIX therefore retains a direct row residual and randomly masks it to vary the reconstruction condition: m𝑣 ⊙ r𝑣 e r𝑣 = , m𝑣 ∼ Bernoulli(1 − 𝑝), 1−𝑝

   (𝑎) (𝑎) r𝑣 (𝑎) = W𝑜 · MeanPool SelfAttn {e𝑖1 , · · · , e𝑖𝑑 } . 𝑎 𝑖

The resulting row embedding r𝑣 (𝑎) summarizes the mixed-type 𝑖

attributes of row 𝑟𝑖(𝑎) and initializes the node for message passing.

3.3

∑︁ © (𝑔) (𝑔) (𝑔) (𝑔) ª = 𝜎 ­W𝜙 (𝑣) h𝑣 + AGG𝑢 ∈ N𝜌 (𝑣) W𝜌 h𝑢 ® , −1 𝜌 ∈ ( L∪L ) « ¬

Graph-to-Prompt Mapping

Motivation. With the attributed heterogeneous graph in place, we need to translate its attribute and relational information into a form suitable for conditioning the SLM. We therefore adopt soft prompts as a learnable interface to the SLM’s token embedding space, incorporating both relational context aggregated from connected records and the target record’s own row embedding. Prompt information preparation. Given the graph G and row embeddings r𝑣 , a heterogeneous GNN aggregates information from related records into a context embedding. Starting from h𝑣(0) = r𝑣 ,

where 𝑝 is the dropout ratio and m𝑣 is a random mask. We concatenate the context embedding with this masked row embedding: z𝑣 = [h𝑣 ∥e r𝑣 ]. Soft prompt construction. A learnable projector maps the concatenated embedding z𝑣 into a soft prompt in the SLM’s token embedding space: P𝑣 = Projector(z𝑣 ) ∈ R𝑀 ×𝑑SLM , 5

Algorithm 1: Graph-to-Prompt Tuning of REMIX Input: Database D, seed 𝑠 1 , steps 𝑆 tr , target batch size 𝐵 tr , depth 𝐿 Output: Tuned parameters Θ 1: Build attributed graph G from D 2: Cache frozen text features and serialization mappings 3: Serialize non-key attributes as labels {y𝑣 } 4: Initialize Θ and set random seed 𝑠 1 5: for 𝑠 = 1, . . . , 𝑆 tr do 6: V𝑏 ← SampleTargets(G, 𝐵 tr ) 7: G𝑏 ← KHopSubgraph(G, V𝑏 , 𝐿) 8: Encode rows in G𝑏 to obtain {r𝑣 } 9: Propagate context on G𝑏 to obtain {h𝑣 } 10: for 𝑣 ∈ V𝑏 do 11: e r𝑣 ← Dropout(r𝑣 ) 12: P𝑣 ← ProjectorΘ ([h𝑣 ∥e r𝑣 ]) 13: end for 14: Compute normalized autoregressive loss J on V𝑏 15: Θ ← OptimizerStep(Θ, ∇Θ J ) 16: end for 17: return Θ

where 𝑀 is the number of soft prompt vectors and 𝑑 SLM is the token embedding dimension of the SLM decoder. For each target table 𝑅 (𝑎) , REMIX constructs a textual instruction 𝑞𝜙 (𝑣) specifying the table name, non-key columns, their types, and the output format. The instruction follows a canonical template: 𝑞𝜙 (𝑣) = Generate attributes for 𝜙 (𝑣). Columns: 𝑐 1(𝑎) (𝜏 (𝑐 1(𝑎) )), · · · . Format: 𝑐 1(𝑎) : value;; · · · . Column types use descriptors such as num, cat, time, or text. We concatenate the soft prompt with the instruction’s token embeddings to form the decoder input: H0𝑣 = [P𝑣 ; Emb(𝑞𝜙 (𝑣) )]. The instruction specifies which attributes to reconstruct, while the soft prompt supplies their row information and relational context.

3.4

Tuning Procedure

Motivation. To learn mixed-type attribute distributions conditioned on the soft prompts constructed above, we jointly tune the graph-to-prompt mapping and the SLM through autoregressive attribute reconstruction. The reconstruction task provides a shared learning signal, guiding the mapping to produce informative prompts and the SLM to generate attributes conditioned on them. Training objective. For supervision, we serialize each record’s non-key attributes into a target sequence y𝑣 = (𝑦 𝑣,1, · · · , 𝑦 𝑣,𝑇𝑣 ). Deterministically computable attributes are omitted from these targets and restored after decoding by the tested programs in Section 4.3. Specifically, for numerical columns that are difficult for token-based prediction, especially those with high-cardinality or continuous values, we use quantile-based textual representations. For categorical columns with long labels, we use short codes such as C1. For example, a serialized record may be “price(quantile): 0.7321;; room_type: C1;; review: near the metro;;”. Conditioned on the input embeddings H0𝑣 constructed in Section 3.3, the SLM reconstructs this sequence autoregressively under teacher forcing. The tuning objective is to minimize the normalized autoregressive loss:

J (Θ) = − Í

1

𝑇𝑣 ∑︁ ∑︁

𝑣 ∈ V𝑡𝑟 𝑇𝑣 𝑣 ∈ V

4 COLLABORATIVE SLM–LLM DECODING 4.1 Overview The graph-to-prompt mapping and tuned SLM from Section 3 provide the basis for generating mixed-type records conditioned on relational context. However, probabilistic decoding from learned attribute distributions does not guarantee that generated values satisfy semantic dependencies. To address this, REMIX combines SLM-based record generation with an LLM-driven semantic dependency engine. As illustrated in Figure 3, the tuned SLM generates mixed-type attributes from soft prompts, while an LLM discovers semantic dependencies and refines them using independent validation feedback. The validated dependencies are translated into tested repair programs, which are applied to the generated database to correct semantic inconsistencies.

4.2

log 𝑝 Θ 𝑦 𝑣,𝑡 | H0𝑣 , 𝑦 𝑣,<𝑡 .

SLM-Based Record Decoding

Motivation. While training reconstructs source records from their soft prompts, synthesis requires constructing new conditioning inputs rather than simply reusing those prompts. We therefore vary the row masks and aggregate nearby prompts from the same table in the learned soft-prompt space. The resulting soft prompts are designed to introduce variation while maintaining semantic similarity, guiding the tuned SLM to generate synthetic records from the learned conditional distributions. Prompt preparation. Given the attributed heterogeneous graph of D, REMIX uses the tuned row encoder and heterogeneous GNN to obtain row and context embeddings. For each record, we mask its row embedding using an inference seed 𝑠 2 distinct from the tuning seed 𝑠 1 , which varies the row information supplied for synthesis. The context embedding is concatenated with the masked row embedding and projected into a soft prompt, following Section 3.3.

𝑡𝑟 𝑡 =1

Here, V𝑡𝑟 is the set of training target nodes, and Θ contains the trainable parameters of the type-aware row encoder, heterogeneous GNN, soft-prompt projector, and adapted SLM. We adapt the SLM using LoRA [16] while keeping the separate text encoder frozen. Training pipeline. Algorithm 1 summarizes the tuning procedure. In each iteration, REMIX samples 𝐵 tr target record nodes with nonkey attributes and expands their 𝐿-hop neighborhoods to provide relational context. Only the target nodes contribute to the training objective, while the sampled neighbor nodes supply information for message passing. REMIX constructs soft prompts for the target nodes and updates Θ using their autoregressive loss. The tuned model, parameterized by Θ, is used for attribute generation in the subsequent decoding phase. 6

Prompt Design

We then select other records from the same table using 𝑘-nearestneighbor (kNN) search in soft-prompt space to draw on semantically similar records. Their prompts are combined with normalized inverse-distance weights to form the synthesis prompt P𝑣 . As in Section 3.3, we concatenate P𝑣 with the token embeddings of the table-specific instruction 𝑞𝜙 (𝑣) to form the decoder input H0𝑣 = [P𝑣 ; Emb(𝑞𝜙 (𝑣) )]. Attribute decoding. Conditioned on H0𝑣 , the tuned SLM generates the non-key attributes of a new synthetic record e 𝑟 𝑣 . The output sequence e y𝑣 has autoregressive likelihood: 𝑝 Θ (e y𝑣 | H0𝑣 ) =

|e y𝑣 | Ö

Input context. Schema, data profiles, and relational examples from the source database. Discovery guidance. Combine the supplied data evidence with your world knowledge to identify dependencies within and across tables: • Functional dependencies: identify attributes determined by one or more others, including semantic hierarchies. • Arithmetic relationships: formulate equations, comparisons. • Domain-specific rules: identify specific value domains, conditional implications, and event consistency requirements. Distinguish semantic requirements from frequent patterns; allow plausible rare exceptions. Output. Return at most 𝑄 candidates in JSON, each with an assertion, a scope, and an applicability condition.

𝑝 Θ 𝑦e𝑣,𝑡 | H0𝑣 , 𝑦e𝑣,<𝑡 .

𝑡 =1

Here, Θ denotes the tuned generator parameters. The output follows the column-value format specified by the instruction: column1 : value1 ;; column2 : value2 ;;

a candidate only if the upper confidence bound on its violation probability is at most 𝜖. Specifically, for a candidate 𝛾, let 𝑛𝛾 > 0 be the number of total evaluation units, 𝑏𝛾 the number of violated units, and 𝑝𝛾 the true violation probability. We model their violation indicators as i.i.d. Bernoulli variables, giving 𝑏𝛾 ∼ Binomial(𝑛𝛾 , 𝑝𝛾 ). The one-sided Clopper–Pearson upper confidence bound [7] 𝑈 CP at confidence level 1 − 𝛼 satisfies 𝑏𝛾   ∑︁ 𝑛𝛾 𝑖 𝑈 (1 − 𝑈 CP )𝑛𝛾 −𝑖 = 𝛼 . 𝑖 CP 𝑖=0

· · · column𝑑𝑎 : value𝑑𝑎 ;; We then parse each generated sequence into typed values using the serialization mappings introduced in Section 3.4. During parsing, generated quantile values are mapped back to the source numeric scale, and categorical codes are converted to their original labels. We place the resulting records in the synthetic database with the source schema, table sizes, and key assignments.

4.3

LLM-Driven Semantic Dependency Engine

Motivation. The probabilistic nature of SLM decoding can lead to violations of semantic dependencies among generated values. Repairing these violations requires identifying dependencies that are often implicit in the data and difficult to infer from the schema alone. A naive approach is to ask an LLM to enumerate all dependencies directly from the database, but the resulting dependency set can be incomplete and inaccurate. Noise in the source database further complicates discovery, as even valid dependencies can be violated occasionally. REMIX therefore combines LLM-guided proposals with iterative validation and refinement for noise-tolerant semantic dependency discovery. Discovery and refinement. To identify candidate semantic dependencies, REMIX provides the LLM with the schema, data profiles, and relational examples from the source database. We instruct the LLM to combine this context with its world knowledge to identify determining and dependent attributes for functional dependencies, formulate equations for arithmetic relationships, and infer semantically justified value domains, conditional implications, and event consistency requirements for domain-specific rules, both within and across tables. The LLM returns at most 𝑄 candidates, each specifying a checkable assertion, its scope, and an applicability condition. The discovery instructions are summarized in Box 1. The full prompt templates are provided in our source code. However, these candidates can be overly strict or based on incorrect semantic assumptions. To identify valid dependencies while accommodating source noise, REMIX therefore iteratively validates and refines them over at most 𝑅val rounds, allowing a small tolerance 𝜖 for the true violation probability of each dependency. In each round, REMIX validates candidates on fresh samples from the source database. To account for sampling uncertainty, we accept

The acceptance criterion 𝑈 CP ≤ 𝜖 limits the probability of accepting a dependency with 𝑝𝛾 > 𝜖 to at most 𝛼 in each test. To maintain this guarantee across iterative refinement, we allocate a total error budget 𝛿 over at most 𝑄 candidates and 𝑅val rounds, setting 𝛼 = 𝛿/(𝑄𝑅val ). A union bound then gives
Pr ∃𝛾 ∈ C ∗ : 𝑝𝛾 > 𝜖 ≤ 𝑄𝑅val 𝛼 = 𝛿, where C ∗ denotes the dependencies accepted by this criterion. Thus, with confidence at least 1 − 𝛿, all dependencies in C ∗ have violation probabilities at most 𝜖. Accepted dependencies then remain fixed. For the remaining candidates, the LLM uses validation statistics, counterexamples, and satisfying instances to revise their definitions, discard invalid ones, or retain those requiring more evidence. Revised candidates are retested, and the loop ends when no candidates remain pending or the round budget is exhausted. The LLM then implements the validated dependencies as repair programs, which are tested individually and jointly on source and perturbed records for violation correction and preservation of valid inputs. During synthesis, these tested programs repair semantic inconsistencies in the database generated by the SLM.

4.4

Collaborative Decoding Procedure

Algorithm 2 summarizes the collaborative decoding procedure of REMIX . Given the source database D, REMIX first obtains validated dependencies C ∗ and tested repair functions F through the semantic dependency engine and caches them for subsequent repair. With the tuned parameters Θ, the complete generation process is e (0) = GenerateΘ (D; 𝑠 2 ), D e = Execute F,C ∗ ( D e (0) ). D 7

Table 3: Profiles of the evaluation databases. |R|, 𝑁 , 𝑑, and |L| denote the numbers of tables, rows, columns, and relationships, respectively. MC denotes multiple children, and MC&P denotes multiple children and parents. N, C, and T denote numerical, categorical, and text attributes.

Algorithm 2: Collaborative SLM–LLM Decoding of REMIX Input: Database D, tuned parameters Θ, seed 𝑠 2 , neighborhood depth 𝐿 e Output: Synthetic relational database D 1: Load or construct (C ∗ , F ) ← DependencyEngine(D) 2: Reuse or build attributed graph G from D e (0) with source schema and keys 3: Initialize D 4: SetSeed(𝑠 2 ) 5: for V𝑏 ∈ BatchAttributeTargets(G) do 6: G𝑏 ← KHopSubgraph(G, V𝑏 , 𝐿) 7: Encode rows in G𝑏 to obtain {r𝑣 } 8: Propagate relational context on G𝑏 to obtain {h𝑣 } 9: for 𝑣 ∈ V𝑏 do 10: e r𝑣 ← Dropout(r𝑣 ) 11: P𝑣 ← ProjectorΘ ([h𝑣 ∥e r𝑣 ]) 12: end for 13: end for 14: {P𝑣 } ← PrepareInferenceInputs({P𝑣 }, G) 15: for V𝑏 ∈ BatchAttributeTargets(G) do 16: for 𝑣 ∈ V𝑏 do 17: e y𝑣 ← DecodeΘ (P𝑣 , 𝑞𝜙 (𝑣) ) 18: e 𝑟 𝑣 ← Parse𝜙 (𝑣) (e y𝑣 ) e (0) 19: Write non-key values of e 𝑟 𝑣 into D 20: end for 21: end for e ← Execute F,C ∗ ( D e (0) ) 22: D ∗ e 23: Audit D under C e 24: return D

Datasets Walmart Biodeg. F1 (w/o text) HM Chicago F1 (w/ text) ML-small

𝑵 12,075 21,895 97,606 97,917 50,335 97,606 102,806

𝒅 20 16 50 24 26 50 13

|L| 2 5 13 2 2 13 4

Hierarchy MC MC&P MC&P MC&P MC&P MC&P MC&P

Types N, C N, C N, C N, C N, C, T N, C, T N, T

Decoding and repair. During decoding, let 𝑁 Σ and 𝐸 Σ count accumulated node and edge visits across sampled subgraphs, including repeated neighborhoods. Let 𝑇DE cover semantic dependency discovery, validation, and repair-program preparation and testing. With source features cached, the first synthesis run costs
2 𝑇DE + 𝑂 𝑁 Σ𝑑 max + 𝐿(𝑁 Σ + 𝐸 Σ ) + 𝑁 ℓ 2 + 𝑇kNN + 𝑇repair . The neural terms cover row encoding, graph propagation, and autoregressive decoding with a key/value cache. Here, 𝑇kNN includes neighbor search and prompt combination, and 𝑇repair includes program execution and auditing. The current exact search compares Í prompts within each table, giving 𝑇kNN = 𝑂 (𝑀𝑑 SLM 𝑎 𝑛𝑎2 ) for fixed (𝑎) 𝑘, where 𝑛𝑎 is the size of table 𝑅 . Chunking the search reduces peak memory but does not remove this quadratic time term. The cost of semantic dependency validation and repair depends on the scopes of the retained dependencies. Bounded-size row checks and indexed key-link checks take 𝑂 (|C ∗ |𝑁 ), whereas ordered checks may require 𝑂 (|C ∗ |𝑁 log 𝑁 ). General joins, repeated checks, and joint repair solvers depend on intermediate sizes and execution plans and remain within 𝑇DE and 𝑇repair . Subsequent runs reuse validated dependencies and tested programs, avoiding 𝑇DE when these artifacts remain applicable. The prompt bank uses 𝑂 (𝑁 𝑀𝑑 SLM ) space; for decoding batches of 𝐵 records, the key/value cache uses 𝑂 (𝐵ℓ) additional space under the fixed-architecture assumption, besides graph storage, cached features, search buffers, and repair intermediates.

Here, 𝑠 2 is the inference seed, and GenerateΘ includes graph encoding, soft-prompt preparation, SLM decoding, and parsing the outputs into typed values. The decoded non-key attributes are ase (0) with the source schema, table sizes, and key sembled into D assignments. After all tables have been populated, Execute F,C ∗ applies the tested repair functions in the planned dependency order. Interacting updates are checked together against affected dependencies, and changes that introduce new violations are rolled back.

5

|R| 3 5 9 3 3 9 4

COMPLEXITY ANALYSIS

We analyze the tuning and decoding costs of REMIX in Sections 3 and 4, respectively. Let 𝑁 = |V | be the number of records, 𝑑 max the maximum number of non-key attributes per record, and ℓ the maximum decoder sequence length, including soft prompts, instructions, and attribute tokens. The analysis assumes fixed neural widths and decoder architecture. Preparation cost 𝑇feat covers graph construction and frozen text encoding, which are reused during decoding. Tuning. During tuning, let 𝑛𝑏 and 𝑒𝑏 bound the numbers of sampled nodes and edges per batch of 𝐵 tr target records. Row attention, 𝐿-layer graph propagation, and teacher-forced decoding cost 2 ), 𝑂 (𝐿(𝑛 + 𝑒 )), and 𝑂 (𝐵 ℓ 2 ), respectively. Backpropa𝑂 (𝑛𝑏 𝑑 max tr 𝑏 𝑏 gation preserves these asymptotic orders. The overall cost of 𝑆 tr tuning steps, including preparation, is given by  2 
𝑇feat + 𝑂 𝑆 tr 𝑛𝑏 𝑑 max + 𝐿(𝑛𝑏 + 𝑒𝑏 ) + 𝐵 tr ℓ 2 .

6 EXPERIMENTAL EVALUATION 6.1 Experiment Setup Dataset description. The evaluation uses seven real-world relational databases, whose profiles are summarized in Table 3. For comparison with existing relational database generators, we use four text-free databases: Biodegradability (Biodeg.), Walmart, and F1 (w/o text) following SyntheRela [19], and HM from RelBench [32]. To evaluate synthesis with textual attributes, we further include three text-rich databases: F1 (w/ text) built from RelBench [32], with driver and circuit names; ML-small from MovieLens [15], containing movie titles and user-generated tags; and Chicago from the Chicago Open Data [5, 6], including crime and location descriptions. 8

Baseline methods. We compare REMIX with seven representative baselines: 1) SDV [30], which uses statistical modeling and copulas for synthesis; 2) RC-TGAN [13], which extends GAN-based generation to relational databases; 3) TabularARGN (TabARGN) [37], which uses autoregressive modeling to synthesize relational databases; 4) GRDM [22], a graph-based diffusion model for relational database synthesis, selected as a published representative of this family over the methodologically similar RelDiff [20], which is available as a preprint; and 5) REaLTabFormer (REaLTabF.) [33], which uses an LLM-based model for parent-child table generation. Since existing relational database generators do not natively support textual attributes, we additionally implement two multi-table extensions of the single-table synthesizer GReaT [2], enabling a direct comparison with REMIX on text-rich relational databases: 6) GReaT-Cond synthesizes tables in parent-to-child order, conditioning each child table on its corresponding parent records; and 7) GReaT-Joint joins each leaf table with its parents and ancestors through many-to-one relationships, applies GReaT-style generation to the resulting wide records, and splits them back into separate tables. Metrics. To evaluate synthesis quality, we follow the evaluation protocol of SyntheRela [19]. We further adopt and extend the constraint violation metrics used by Constrained Deep Generative Models (C-DGMs) [34] to measure semantic consistency in synthetic databases. Specifically, we report five metrics: 1) classifier twosample test with aggregation (C2ST-Agg), which uses a classifier to assess how distinguishable synthetic records are from real records based on relationally aggregated features; 2) Intra-table similarity, which measures how well pairwise relationships between columns within each table are preserved; 3) Inter-table similarity, which measures how well pairwise relationships between columns across directly related tables are preserved; 4) constraint violation rate (CVR), for which we follow C-DGMs [34] by constructing a humanverified reference set of semantic dependencies and reporting the fraction of synthetic records violating at least one dependency; and 5) Utility, which measures downstream performance under the train-on-synthetic-test-on-real (TSTR) protocol, using AUC for classification and MAE for regression. For text-free databases, we retain the original fidelity and utility metric definitions in SyntheRela. For text-rich databases, we incorporate text-derived features into C2STAgg and text embeddings into downstream predictors, and extend intra- and inter-table similarity using embedding correlations and category-conditional text distribution similarity. CVR follows the same record-level definition in both settings. Implementation Details. For REMIX , we use DeepSeek-V4-Pro for the semantic dependency engine, all-MiniLM-L6-v2 for text embeddings, and Qwen3-0.6B as the decoder. The type-aware encoder outputs 384-dimensional row representations. For prompt information preparation, we use a two-layer heterogeneous GraphSAGE [14] with 512 hidden dimensions to encode relational context, set the residual mask ratio to 0.4, and use a two-layer MLP projector to produce one soft prompt token. We train each model for at most 20K steps with batch size 8, learning rate 1 × 10−4 . During synthesis, we replace each soft prompt with the aggregation of its 3 nearest same-table neighbors and sample from the best checkpoint with temperature 0.8. For the semantic dependency engine, we propose at most 30 candidate dependencies and perform up to 5 rounds of iterative validation and revision. We set the violation

tolerance to 0.1 and the total error budget to 0.1. For all baselines, we use their official implementations and default hyperparameters, with graph-based methods keeping the original relational graph fixed during generation. All methods are run with three random seeds on NVIDIA H800 GPUs with 80GB memory, and we report the mean and standard deviation. The source code is available at https://github.com/scsystem1/REMIX.

6.2

Synthesis Quality

Exp-1: Quality on text-free relational databases. Table 4 compares REMIX with all baselines on four text-free relational databases. The results show that REMIX achieves strong performance across all evaluated metrics. Specifically, REMIX achieves the lowest C2STAgg on three databases and only trails GRDM on Walmart. Its average reduction in C2ST-Agg is at least 7.36% over the baselines, indicating that the synthetic records are more realistic. Regarding pairwise relationships, REMIX ranks first on two databases and second on the other two in intra-table similarity. Its inter-table similarity is even stronger, ranking first on three databases and second on Walmart, with an average improvement of at least 9.21% over the baselines. These results demonstrate that REMIX effectively preserves relationships between columns both within and across tables. In terms of semantic consistency, REMIX achieves the lowest CVR on all four databases. The average relative reduction in CVR is at least 49.11% over the baselines on their applicable databases, reflecting better adherence to the verified dependencies. Finally, REMIX achieves the best TSTR performance on all four downstream tasks, suggesting that its synthetic data supports downstream training. Exp-2: Quality on text-rich relational databases. Table 5 compares REMIX with GReaT-Cond and GReaT-Joint on three text-rich relational databases. The results show that REMIX achieves the best performance across all databases and metrics, except for TSTR on ML-small, where its MAE is 2.30% higher than that of GReaT-Joint. On average, REMIX reduces C2ST-Agg by at least 15.43% and improves intra-table and inter-table similarities by at least 10.28% and 6.93%, respectively, over the baselines. It also achieves an average reduction of at least 47.69% in CVR and an average improvement of at least 13.79% in downstream utility. These results show gains in fidelity and semantic consistency alongside improved average downstream utility. They support a unified framework for jointly synthesizing structured values and text across related tables.

6.3

Quality-Efficiency Trade-off

Exp-3: Quality-efficiency trade-off. In this experiment, we evaluate the quality-efficiency trade-off on four text-free relational databases. We use 1 − C2ST-Agg to measure synthesis quality and record the total training and generation time. We plot the Pareto frontier of the baselines on each database to examine whether REMIX improves the existing balance between quality and efficiency. The results are presented in Figure 4. As shown in the figure, REMIX extends the baseline Pareto frontier on all four databases. Specifically, fast baselines such as SDV, RC-TGAN, and TabARGN offer lower time costs on some databases, but consistently yield lower synthesis quality than REMIX . Compared with GRDM, REMIX is 22.8×, 6.0×, and 3.7× faster on Biodeg., F1 (w/o text), and HM, respectively, while achieving higher synthesis quality. On Walmart, 9

Table 4: Synthesis quality on text-free relational databases. Results are mean ± standard deviation over three runs. All metrics except TSTR are reported in %. Arrows indicate the direction of improvement. Shaded bold and underlined values mark the best and second-best results, respectively. Blue rows report mean relative gains of REMIX over each baseline across available datasets. Dashes indicate unavailable results. Metrics

Datasets

C2ST-Agg (↓)

Walmart Biodeg. F1 (w/o text) HM

Avg. Improv. of REMIX

Intra-table (↑)

Walmart Biodeg. F1 (w/o text) HM

Avg. Improv. of REMIX

Inter-table (↑)

Walmart Biodeg. F1 (w/o text) HM

Avg. Improv. of REMIX

CVR (↓)

Walmart Biodeg. F1 (w/o text) HM

Avg. Improv. of REMIX TSTR (MAE) (↓) TSTR (MAE) (↓) TSTR (AUC) (↑) TSTR (AUC) (↑)

SDV

RC-TGAN

GRDM

TabARGN

REaLTabF.

GReaT-Cond

GReaT-Joint

REMIX

87.41±2.31 87.83±0.29 94.90±0.35 88.01±1.18

93.70±0.64 74.64±0.19 92.63±1.23 87.00±0.57

65.56±5.09 68.43±0.59 81.05±0.92 82.65±0.46

92.22±2.94 84.96±0.54 95.05±0.54 81.53±0.25

91.85±3.57 – – 86.56±0.23

94.07±0.64 85.57±0.07 89.78±0.69 85.58±0.15

98.89±0.00 82.72±0.10 90.71±0.42 90.53±0.06

71.85±3.57 57.67±0.45 64.97±0.50 79.79±0.29

+23.25%

+21.05%

+7.36%

+22.00%

+14.80%

+22.66%

+24.47%

–

87.08±0.00 96.46±0.00 86.97±0.68 65.32±0.11

86.88±1.10 85.01±3.58 90.99±0.58 61.71±1.06

96.29±0.34 94.79±1.39 95.61±0.04 84.88±0.43

86.86±0.56 72.54±0.34 91.54±0.16 78.20±0.11

87.89±0.80 – – 60.47±0.47

91.94±0.76 94.73±1.05 87.29±0.10 65.83±0.20

90.56±0.37 95.25±1.70 91.33±0.31 60.73±0.15

93.59±0.47 98.44±0.71 95.62±0.61 80.87±0.11

+10.82%

+14.91%

−0.92%

+12.83%

+20.11%

+9.53%

+11.14%

–

78.12±0.00 69.65±0.00 80.30±0.54 66.98±2.45

78.91±1.17 72.09±7.92 82.47±0.70 66.13±4.83

94.39±0.46 60.22±1.82 90.69±0.26 79.49±6.18

79.62±0.41 64.68±0.59 78.21±1.12 79.33±0.10

81.81±1.37 – – 73.47±1.20

84.50±1.32 63.68±2.89 75.55±0.90 71.89±2.62

78.46±3.23 68.61±0.87 83.01±0.09 70.90±0.21

90.65±0.67 81.11±12.18 92.04±0.10 83.15±0.52

+17.81%

+16.18%

+9.21%

+15.44%

+11.99%

+18.03%

+15.48%

–

1.085±0.000 35.063±0.008 44.416±1.262 23.240±0.000

1.527±0.083 32.038±0.776 34.642±3.265 26.053±2.331

0.649±0.053 0.253±0.065 31.346±0.069 11.735±9.240

0.842±0.080 8.713±0.186 31.442±0.114 11.313±2.713

0.000±0.000 – – 34.573±0.043

0.685±0.017 4.435±0.293 33.744±0.618 2.212±0.031

0.580±0.050 6.571±0.155 31.608±0.227 1.696±0.057

0.000±0.000 0.006±0.011 18.019±0.606 0.615±0.168

+89.19%

+86.40%

+83.72%

+84.30%

+49.11%

+79.66%

+76.65%

–

11601.78±90.01 1.2487±0.2471 0.3560±0.1142 0.6270±0.0103

11345.76±15.73 1.1917±0.0320 0.7838±0.0048 0.6098±0.0282

11555.76±16.86 1.1796±0.1129 0.3260±0.0203 0.6327±0.0105

11553.01±6.93 – – 0.6158±0.0133

11476.54±104.06 1.2518±0.2388 0.7021±0.0483 0.6343±0.0129

11615.60±29.02 1.1401±0.0452 0.5130±0.2037 0.6326±0.0093

11318.90±5.83 1.1250±0.0574 0.7935±0.0052 0.6362±0.0118

+34.18%

+2.85%

+37.66%

+2.67%

+6.21%

+14.78%

–

Walmart 12805.23±0.00 Biodeg. 1.1471±0.0473 F1 (w/o text) 0.5902±0.1686 HM 0.6266±0.0366

Avg. Improv. of REMIX

+12.38%

REMIX (ours)

although GRDM achieves higher quality, REMIX is 10.2× faster, providing strong synthesis quality at a substantially lower time cost. Collectively, these results show that REMIX achieves a superior balance between synthesis quality and efficiency across the evaluated databases. Total Time (min)

6.4

10

Ablation Study

Exp-4: Ablation study. In this experiment, we conduct an ablation study to evaluate the effectiveness of three key modules in REMIX , including the type-aware row encoder, the heterogeneous GNN, and the stochastic row residual. To evaluate the impact of the type-aware row encoder, we replace it with direct row serialization followed by SLM embedding while keeping the other components unchanged. To assess the effectiveness of the GNN-enhanced representation, we remove the heterogeneous GNN and directly project the dropout-masked row representations into soft prompt tokens. Lastly, we remove the stochastic row residual and project only the GNN-enhanced representation into soft prompt tokens. The results are summarized in Table 6. As shown, type-aware encoding reduces C2ST-Agg by 5.98%, highlighting its value in constructing informative representations for records with heterogeneous attributes. The GNN-enhanced representation contributes an average reduction of 4.24%, demonstrating the benefit of incorporating relational context into generation. Retaining the stochastic row residual lowers

−1

Baselines

Walmart

SDV

10

0

10

0

10

1

10

1

10

2

10

2

10

3

10

3

10

GRDM

−1

10

0

10

1

10

2

10

3

0.1

0.2

0.3

0.4

F1 (w/o text)

10

RC-TGAN

GRDM

−1

10

0

10

1

10

2

10

3

0.0

0.1

GReaT-Cond GRDM

0.0

0.1

0.2

0.3

0.4

0.2

0.3

0.4

HM

TabARGN

SDV RC-TGAN

Biodeg.

TabARGN

10

0.0

Baseline Pareto frontier

−1

TabARGN

0.0

0.1

0.2

0.3

0.4

Synthesis Quality (1 − C2ST-Agg)

Figure 4: Quality-efficiency trade-off on text-free relational databases. Synthesis quality is measured by 1−C2ST-Agg, and total time includes training and generation.

C2ST-Agg by 4.16% on average, indicating that row-level information complements the GNN-enhanced representation. These results collectively demonstrate the effectiveness of the three modules in improving synthesis fidelity. 10

Table 5: Synthesis quality on text-rich relational databases. Notation, highlighting, and average-improvement calculations follow Table 4. Metrics

Datasets

GReaT-Cond

GReaT-Joint

REMIX

C2ST-Agg (↓)

Chicago F1 (w/ text) ML-small

96.00±0.28 93.45±0.13 92.04±0.17

98.32±0.42 95.15±0.56 98.44±0.06

83.82±0.35 75.37±0.93 78.93±0.33

+15.43%

+18.45%

–

67.74±1.01 82.84±0.52 97.49±0.11

72.60±0.63 86.83±0.38 96.51±0.06

89.06±0.18 91.72±0.44 98.96±0.01

Avg. Improv. of REMIX Intra-table (↑)

Chicago F1 (w/ text) ML-small

Avg. Improv. of REMIX Inter-table (↑)

Chicago F1 (w/ text) ML-small

Avg. Improv. of REMIX CVR (↓)

Chicago F1 (w/ text) ML-small

Avg. Improv. of REMIX TSTR (AUC) (↑) Chicago TSTR (AUC) (↑) F1 (w/ text) TSTR (MAE) (↓) ML-small Avg. Improv. of REMIX

6.5

+14.57%

+10.28%

–

67.69±1.93 85.15±0.30 95.08±0.29

71.67±0.91 90.02±0.10 94.51±0.17

81.41±0.31 92.94±0.38 98.24±0.14

+10.91%

+6.93%

–

98.946±0.381 32.529±0.502 0.829±0.036

99.411±0.005 36.938±0.318 45.951±37.317

21.017±0.306 12.397±1.020 0.809±0.139

+47.69%

+81.18%

–

0.4946±0.0203 0.7899±0.0358 0.9148±0.0091

0.6351±0.1267 0.5613±0.0669 0.8917±0.0008

0.6815±0.0115 0.8159±0.0424 0.9122±0.0089

+13.79%

+16.79%

–

is sufficient to convey conditioning information to the decoder. Therefore, we use one token as the default setting. Exp-8: Varying the number of nearest neighbors (𝑘). We vary the number of same-table nearest neighbors used to aggregate soft prompts during synthesis, considering 𝑘 = 2, 3, and 4. The results are reported in Figure 5(d). Across these settings, REMIX maintains strong synthesis fidelity, suggesting that its performance is relatively insensitive to the choice of 𝑘. Different databases exhibit different preferences for the number of neighbors. We therefore adopt 𝑘 = 3 as the default setting, as it provides consistently strong fidelity across databases.

6.6

Semantic Dependency Engine Evaluation

Exp-9: Dependency engine analysis. We evaluate the effectiveness of the semantic dependency engine and its robustness across different LLMs. The results are summarized in Figure 6. Without semantic dependency enforcement, the average CVR reaches 21.58%. Our evaluation covers three frontier proprietary models, namely GPT-5.6-Sol, Claude-Opus-5, and Gemini-4-Argon, and three leading open-source models, namely DeepSeek-V4-Pro, Kimi-K3, and Qwen3.8-Max. With the semantic dependency engine, the three proprietary models lower the average CVR to 6.88%, 7.71%, and 8.78%, respectively, while the three open-source models achieve 7.55%, 10.59%, and 10.60%, respectively. All six configurations reduce CVR by more than 50%, demonstrating the engine’s effectiveness and robustness across the evaluated LLMs, although the extent of improvement varies with the underlying model. Considering reproducibility requirements and performance, we select the open-source DeepSeek-V4-Pro as the default LLM.

Hyperparameter Analysis

Exp-5: Varying decoding SLMs. We evaluate REMIX with three decoder sizes from the Qwen3 family: Qwen3-0.6B, Qwen3-1.7B, and Qwen3-4B. The results are presented in Figure 5(a). As shown, increasing the decoder size does not consistently improve fidelity. Qwen3-0.6B achieves the lowest C2ST-Agg on five of the seven databases and the best average of 73.20%. Although Qwen3-1.7B improves fidelity on Biodeg. and Qwen3-4B performs better on ML-small, these gains do not offset their degradation on the other databases. These results suggest that larger decoder capacity alone does not guarantee better synthesis fidelity. Therefore, we use Qwen3-0.6B as the default decoder. Exp-6: Varying decoding temperatures. We evaluate REMIX under decoding temperatures of 0.6, 0.8, and 1.0. Figure 5(b) summarizes the results. As illustrated, increasing the temperature generally improves fidelity, although the changes are moderate: the average C2ST-Agg varies by only 2.37% across the tested settings. Overall, REMIX maintains strong synthesis fidelity while different databases exhibit different temperature preferences. We therefore adopt 0.8 as the default temperature, choosing an intermediate setting that provides strong overall performance. Exp-7: Varying the number of soft prompt tokens. We evaluate REMIX with 1, 2, and 4 soft prompt tokens. As shown in Figure 5(c), using more tokens does not consistently improve fidelity. One token achieves the lowest average C2ST-Agg of 73.20%, compared with 75.94% and 74.89% for two and four tokens, respectively. Although additional tokens bring gains on a few databases, they provide no overall improvement. This suggests that one soft prompt token

7

RELATED WORK

Existing relational database synthesis methods can be broadly categorized into four groups: statistical methods, conventional learningbased methods, diffusion-based methods, and LLM-based methods. Statistical methods. Statistical methods explicitly model attribute distributions and inter-table relationships. The original SDV [30] combines Gaussian copulas with hierarchical modeling, propagating statistics of child groups into parent representations before sampling related tables. PrivLava [3] introduces latent variables to capture correlations among tuples sharing foreign-key references and synthesizes relational data under differential privacy. Conventional learning-based methods. Conventional learningbased methods learn attribute distributions and inter-table dependencies using GANs [12], VAEs [23], or autoregressive models [38]. RC-TGAN [13] adapts CTGAN [42] to relational database synthesis by conditioning child-table generators on parent rows. GraphVAE [26] combines graph neural networks with variational autoencoders to synthesize attributes while retaining the input relational graph structure. NeuralM2M [41] first generates a graph representing relationships between records across tables, then synthesizes attributes using neural autoregressive models conditioned on node embeddings and neighboring records. TabularARGN [37] follows a parent-to-child generation order, synthesizing child sequences with an autoregressive network conditioned on parent attributes and LSTM-encoded history. 11

Table 6: Ablation study of REMIX on synthesis fidelity. C2ST-Agg (↓, %) is reported as mean ± standard deviation over three runs. Avg. Improv. denotes the mean absolute reduction in C2ST-Agg achieved by the full model over each ablated variant. Variant REMIX w/o Encoder w/o GNN w/o Residual

Biodeg.

F1 (w/o text)

HM

Chicago

ML-small

F1 (w/ text)

Avg. Improv.

71.85 ± 3.57 89.63 ± 3.57 69.26 ± 5.01 67.41 ± 4.21

57.67 ± 0.45 57.35 ± 0.28 56.68 ± 0.60 66.97 ± 0.78

64.97 ± 0.50 74.12 ± 0.72 74.52 ± 0.23 70.59 ± 1.36

79.79 ± 0.29 89.74 ± 0.12 83.04 ± 0.58 85.89 ± 0.29

83.82 ± 0.35 78.21 ± 0.79 89.94 ± 0.98 81.24 ± 0.77

78.93 ± 0.33 78.12 ± 0.64 85.38 ± 0.05 86.46 ± 0.47

75.37 ± 0.93 87.07 ± 0.61 83.24 ± 0.91 82.94 ± 0.26

+5.98% +4.24% +4.16%

Qwen3-0.6B⋆

Qwen3-1.7B

Qwen3-4B

90 C2ST-Agg (%)

90 C2ST-Agg (%)

Walmart

80 70 60 50 40

1⋆

F1 (w/o text)

Biodeg.

HM

Chicago

ML-small

2

F1 (w/ text)

1.0

Biodeg.

F1 (w/o text)

HM

F1 (w/o text)

HM

80 70 60

40

Avg.

Walmart

Chicago

ML-small

Datasets (b) C2ST-Agg with varying decoding temperatures

4

90 C2ST-Agg (%)

90 C2ST-Agg (%)

0.8⋆

50 Walmart

Datasets (a) C2ST-Agg with varying decoding SLMs

80 70 60 50 40

0.6

–

2

3⋆

F1 (w/ text)

Avg.

F1 (w/ text)

Avg.

4

80 70 60 50

Walmart

Biodeg.

F1 (w/o text)

HM

Chicago

ML-small

F1 (w/ text)

40

Avg.

Datasets (c) C2ST-Agg with varying numbers of soft prompt tokens

Walmart

Biodeg.

Chicago

ML-small

Datasets (d) C2ST-Agg with varying KNN neighbors

Constraint Violation Rate (%)

Figure 5: Hyperparameter sensitivity of REMIX. Panels (a)–(d) vary decoder size, decoding temperature, the number of soft prompt tokens, and the number of nearest neighbors (𝑘), respectively. Results show C2ST-Agg (↓, %) for each database and the mean across databases. Stars mark the default settings. 25

LLM-based methods. LLM-based methods serialize records into token sequences and synthesize data using language-model architectures. REaLTabFormer [33] generates parent records with GPT2 [31], then uses a sequence-to-sequence model to generate child records conditioned on their parents. GReaTER [24] restructures related tables by joining correlated features and removing duplicate records. It also enhances the semantics of categorical labels before synthesizing relational databases using GPT-2-based models. These methods obtain relational context from serialized parent records or restructured tables, whereas REMIX aggregates information from connected records into soft prompts. It further applies tested computation and repair programs derived from validated semantic dependencies to reduce inconsistencies.

21.58

20 15 10

6.88

7.55

7.71

8.78

10.59

10.60

Kimi-K3

Qwen3.8-Max

5 0

w/o repair

GPT-5.6-Sol DeepSeek-V4-Pro Claude-Opus-5 Gemini-4-Argon

Semantic Dependency Engine Configuration

Figure 6: Mean CVR (↓, %) under different semantic dependency engine configurations over three generation runs, each averaged equally across seven databases.

Diffusion-based methods. Diffusion-based methods generate row attributes through iterative denoising conditioned on relational information. ClavaDDPM [29] jointly generates parent records and cluster-derived latent variables with diffusion, then uses these variables to guide child-row diffusion. RGCLD [18] generates tables sequentially with latent diffusion models conditioned on GNN embeddings. In contrast, GRDM [22] and RelDiff [20] first generate a graph representing the database structure, then jointly denoise row attributes across tables using heterogeneous GNNs that aggregate information from connected records at each diffusion step. These methods primarily model numerical and categorical attributes, whereas REMIX combines graph representations with language modeling to jointly synthesize structured values and text.

8

CONCLUSION

In this paper, we study mixed-type relational database synthesis and propose REMIX , a unified framework based on collaboration between an SLM and an LLM. Graph-to-Prompt Tuning jointly learns graph-conditioned soft prompts and tunes the SLM through attribute reconstruction. Collaborative SLM–LLM Decoding combines SLM generation with tested computation and repair programs derived from LLM-discovered, independently validated semantic dependencies. Experiments on seven real-world relational databases demonstrate the superiority of REMIX . Future work will explore scaling REMIX to larger relational databases and applying it to more downstream machine learning tasks. 12

REFERENCES

[18] Valter Hudovernik. 2024. Relational data generation with graph neural networks and latent diffusion models. In NeurIPS 2024 Third Table Representation Learning Workshop. [19] Valter Hudovernik, Martin Jurkovic, and Erik Strumbelj. 2026. SyntheRela: A Benchmark For Synthetic Relational Database Generation. Trans. Mach. Learn. Res. 2026 (2026). https://openreview.net/forum?id=Mi8XioazWy [20] Valter Hudovernik, Minkai Xu, Juntong Shi, Lovro Subelj, Stefano Ermon, Erik Strumbelj, and Jure Leskovec. 2025. RelDiff: Relational Data Generative Modeling with Graph-Based Diffusion Models. CoRR abs/2506.00710 (2025). https://doi. org/10.48550/ARXIV.2506.00710 arXiv:2506.00710 [21] Shivasankari Kannan, Yeounoh Chung, Amita Gondi, Tristan Swadell, and Fatma Özcan. 2026. High-Fidelity and Complex Test Data Generation for Google SQL Code Generation Services. In 42nd IEEE International Conference on Data Engineering, ICDE 2026, Montreal, QC, Canada, May 4-8, 2026. IEEE, 3694–3707. https://doi.org/10.1109/ICDE65706.2026.00274 [22] Mohamed Amine Ketata, David Lüdke, Leo Schwinn, and Stephan Günnemann. 2025. Joint Relational Database Generation via Graph-Conditional Diffusion Models. In Advances in Neural Information Processing Systems 38: Annual Conference on Neural Information Processing Systems 2025, NeurIPS 2025, San Diago, CA, USA, December 2-7, 2025 / Mexico City, Mexico, November 30 - December 5, 2025, Danielle Belgrave, Cheng Zhang, Laura N. Montoya, Hsuan-Tien Lin, Razvan Pascanu, Piotr Koniusz, Marzyeh Ghassemi, Nancy Chen, Iván Vladimir Meza Ruíz, and Arturo Loaiza-Bonilla (Eds.). http://papers.nips.cc/paper_files/paper/ 2025/hash/ef7f818e234b3d81ad13ea0430353415-Abstract-Conference.html [23] Diederik P. Kingma and Max Welling. 2014. Auto-Encoding Variational Bayes. In 2nd International Conference on Learning Representations, ICLR 2014, Banff, AB, Canada, April 14-16, 2014, Conference Track Proceedings, Yoshua Bengio and Yann LeCun (Eds.). https://doi.org/10.48550/ARXIV.1312.6114 [24] Tung Sum Thomas Kwok, Chi-Hua Wang, and Guang Cheng. 2025. GReaTER: Generate Realistic Tabular data after data Enhancement and Reduction. In 41st IEEE International Conference on Data Engineering, ICDE 2025 - Workshops, Hong Kong, May 19-23, 2025. IEEE, 218–229. https://doi.org/10.1109/ICDEW67478. 2025.00032 [25] Brian Lester, Rami Al-Rfou, and Noah Constant. 2021. The Power of Scale for Parameter-Efficient Prompt Tuning. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, EMNLP 2021, Virtual Event / Punta Cana, Dominican Republic, 7-11 November, 2021, Marie-Francine Moens, Xuanjing Huang, Lucia Specia, and Scott Wen-tau Yih (Eds.). Association for Computational Linguistics, 3045–3059. https://doi.org/10.18653/V1/2021.EMNLP-MAIN.243 [26] Ciro Antonio Mami, Andrea Coser, Eric Medvet, Alexander T. P. Boudewijn, Marco Volpe, Michael Whitworth, Borut Svara, Gabriele Sgroi, Daniele Panfilo, and Sebastiano Saccani. 2022. Generating Realistic Synthetic Relational Data through Graph Variational Autoencoders. CoRR abs/2211.16889 (2022). https: //doi.org/10.48550/ARXIV.2211.16889 arXiv:2211.16889 [27] OpenAI. 2026. OpenAI GPT-5 System Card. CoRR abs/2601.03267 (2026). https: //doi.org/10.48550/ARXIV.2601.03267 arXiv:2601.03267 [28] Long Ouyang, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroll L. Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, John Schulman, Jacob Hilton, Fraser Kelton, Luke Miller, Maddie Simens, Amanda Askell, Peter Welinder, Paul F. Christiano, Jan Leike, and Ryan Lowe. 2022. Training language models to follow instructions with human feedback. In Advances in Neural Information Processing Systems 35: Annual Conference on Neural Information Processing Systems 2022, NeurIPS 2022, New Orleans, LA, USA, November 28 December 9, 2022, Sanmi Koyejo, S. Mohamed, A. Agarwal, Danielle Belgrave, K. Cho, and A. Oh (Eds.). http://papers.nips.cc/paper_files/paper/2022/hash/ b1efde53be364a73914f58805a001731-Abstract-Conference.html [29] Wei Pang, Masoumeh Shafieinejad, Lucy Liu, Stephanie Hazlewood, and Xi He. 2024. ClavaDDPM: Multi-relational Data Synthesis with Cluster-guided Diffusion Models. In Advances in Neural Information Processing Systems 37: Annual Conference on Neural Information Processing Systems 2024, NeurIPS 2024, Vancouver, BC, Canada, December 10 - 15, 2024, Amir Globersons, Lester Mackey, Danielle Belgrave, Angela Fan, Ulrich Paquet, Jakub M. Tomczak, and Cheng Zhang (Eds.). http://papers.nips.cc/paper_files/paper/2024/hash/ 983876577ec81db17ecfae1521df9208-Abstract-Conference.html [30] Neha Patki, Roy Wedge, and Kalyan Veeramachaneni. 2016. The Synthetic Data Vault. In 2016 IEEE International Conference on Data Science and Advanced Analytics, DSAA 2016, Montreal, QC, Canada, October 17-19, 2016. IEEE, 399–410. https://doi.org/10.1109/DSAA.2016.49 [31] Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, Ilya Sutskever, et al. 2019. Language models are unsupervised multitask learners. OpenAI blog 1, 8 (2019), 9. [32] Joshua Robinson, Rishabh Ranjan, Weihua Hu, Kexin Huang, Jiaqi Han, Alejandro Dobles, Matthias Fey, Jan Eric Lenssen, Yiwen Yuan, Zecheng Zhang, Xinwei He, and Jure Leskovec. 2024. RelBench: A Benchmark for Deep Learning on Relational Databases. In Advances in Neural Information Processing Systems 37: Annual Conference on Neural Information Processing Systems 2024, NeurIPS 2024, Vancouver, BC, Canada, December 10 - 15, 2024, Amir Globersons, Lester Mackey, Danielle Belgrave, Angela Fan, Ulrich

[1] Rakesh Agrawal, Amit Somani, and Yirong Xu. 2001. Storage and Querying of E-Commerce Data. In VLDB 2001, Proceedings of 27th International Conference on Very Large Data Bases, September 11-14, 2001, Roma, Italy, Peter M. G. Apers, Paolo Atzeni, Stefano Ceri, Stefano Paraboschi, Kotagiri Ramamohanarao, and Richard T. Snodgrass (Eds.). Morgan Kaufmann, 149–158. http://www.vldb.org/ conf/2001/P149.pdf [2] Vadim Borisov, Kathrin Seßler, Tobias Leemann, Martin Pawelczyk, and Gjergji Kasneci. 2023. Language Models are Realistic Tabular Data Generators. In The Eleventh International Conference on Learning Representations, ICLR 2023, Kigali, Rwanda, May 1-5, 2023. OpenReview.net. https://openreview.net/forum?id= cEygmQNOeI [3] Kuntai Cai, Xiaokui Xiao, and Graham Cormode. 2023. PrivLava: Synthesizing Relational Data with Foreign Keys under Differential Privacy. Proc. ACM Manag. Data 1, 2 (2023), 142:1–142:25. https://doi.org/10.1145/3589287 [4] Riccardo Cappuzzo, Paolo Papotti, and Saravanan Thirumuruganathan. 2020. Creating Embeddings of Heterogeneous Relational Datasets for Data Integration Tasks. In Proceedings of the 2020 International Conference on Management of Data, SIGMOD Conference 2020, online conference [Portland, OR, USA], June 14-19, 2020, David Maier, Rachel Pottinger, AnHai Doan, Wang-Chiew Tan, Abdussalam Alawini, and Hung Q. Ngo (Eds.). ACM, 1335–1349. https://doi.org/10.1145/ 3318464.3389742 [5] Chicago Police Department. [n.d.]. Chicago Police Department—Illinois Uniform Crime Reporting Codes. https://data.cityofchicago.org/d/c7ck-438e. City of Chicago Data Portal; accessed October 6, 2026. [6] Chicago Police Department. [n.d.]. Crimes—2001 to Present. https://data. cityofchicago.org/d/ijzp-q8t2. City of Chicago Data Portal; accessed October 6, 2026. [7] Charles J Clopper and Egon S Pearson. 1934. The use of confidence or fiducial limits illustrated in the case of the binomial. Biometrika 26, 4 (1934), 404–413. [8] E. F. Codd. 1982. Relational Database: A Practical Foundation for Productivity. Commun. ACM 25, 2 (1982), 109–117. https://doi.org/10.1145/358396.358400 [9] Till Döhmen, Radu Geacu, Madelon Hulsebos, and Sebastian Schelter. 2024. SchemaPile: A Large Collection of Relational Database Schemas. Proc. ACM Manag. Data 2, 3 (2024), 172. https://doi.org/10.1145/3654975 [10] Raul Castro Fernandez, Pranav Subramaniam, and Michael J. Franklin. 2020. Data Market Platforms: Trading Data Assets to Solve Data Problems. Proc. VLDB Endow. 13, 11 (2020), 1933–1947. http://www.vldb.org/pvldb/vol13/p1933-fernandez.pdf [11] Yunqing Ge, Jianbin Qin, Shuyuan Zheng, Yongrui Zhong, Bo Tang, Yu-Xuan Qiu, Rui Mao, Ye Yuan, Makoto Onizuka, and Chuan Xiao. 2024. Privacy-Enhanced Database Synthesis for Benchmark Publishing. Proc. VLDB Endow. 18, 2 (2024), 413–425. https://doi.org/10.14778/3705829.3705855 [12] Ian J. Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron C. Courville, and Yoshua Bengio. 2014. Generative Adversarial Nets. In Advances in Neural Information Processing Systems 27: Annual Conference on Neural Information Processing Systems 2014, December 8-13 2014, Montreal, Quebec, Canada, Zoubin Ghahramani, Max Welling, Corinna Cortes, Neil D. Lawrence, and Kilian Q. Weinberger (Eds.). 2672–2680. https://proceedings.neurips.cc/paper/2014/hash/ 5ca3e9b122f61f8f06494c97b1afccf3-Abstract.html [13] Mohamed Gueye, Yazid Attabi, and Maxime Dumas. 2023. Row ConditionalTGAN for Generating Synthetic Relational Databases. In IEEE International Conference on Acoustics, Speech and Signal Processing ICASSP 2023, Rhodes Island, Greece, June 4-10, 2023. IEEE, 1–5. https://doi.org/10.1109/ICASSP49357.2023. 10096001 [14] William L. Hamilton, Zhitao Ying, and Jure Leskovec. 2017. Inductive Representation Learning on Large Graphs. In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach, CA, USA, Isabelle Guyon, Ulrike von Luxburg, Samy Bengio, Hanna M. Wallach, Rob Fergus, S. V. N. Vishwanathan, and Roman Garnett (Eds.). 1024–1034. https://proceedings.neurips.cc/paper/2017/hash/ 5dd9db5e033da9c6fb5ba83c7a7ebea9-Abstract.html [15] F. Maxwell Harper and Joseph A. Konstan. 2016. The MovieLens Datasets: History and Context. ACM Trans. Interact. Intell. Syst. 5, 4 (2016), 19:1–19:19. https://doi.org/10.1145/2827872 [16] Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2022. LoRA: Low-Rank Adaptation of Large Language Models. In The Tenth International Conference on Learning Representations, ICLR 2022, Virtual Event, April 25-29, 2022. OpenReview.net. https://openreview.net/forum?id=nZeVKeeFYf9 [17] Gui Huang, Xuntao Cheng, Jianying Wang, Yujie Wang, Dengcheng He, Tieying Zhang, Feifei Li, Sheng Wang, Wei Cao, and Qiang Li. 2019. X-Engine: An Optimized Storage Engine for Large-scale E-commerce Transaction Processing. In Proceedings of the 2019 International Conference on Management of Data, SIGMOD Conference 2019, Amsterdam, The Netherlands, June 30 - July 5, 2019, Peter Boncz, Stefan Manegold, Anastasia Ailamaki, Amol Deshpande, and Tim Kraska (Eds.). ACM, 651–665. https://doi.org/10.1145/3299869.3314041 13

[39] Alexander van Renen, Dominik Horn, Pascal Pfeil, Kapil Vaidya, Wenjian Dong, Murali Narayanaswamy, Zhengchun Liu, Gaurav Saxena, Andreas Kipf, and Tim Kraska. 2024. Why TPC Is Not Enough: An Analysis of the Amazon Redshift Fleet. Proc. VLDB Endow. 17, 11 (2024), 3694–3706. https://doi.org/10.14778/ 3681954.3682031 [40] Alexandre Verbitski, Anurag Gupta, Debanjan Saha, Murali Brahmadesam, Kamal Gupta, Raman Mittal, Sailesh Krishnamurthy, Sandor Maurice, Tengiz Kharatishvili, and Xiaofeng Bao. 2017. Amazon Aurora: Design Considerations for High Throughput Cloud-Native Relational Databases. In Proceedings of the 2017 ACM International Conference on Management of Data, SIGMOD Conference 2017, Chicago, IL, USA, May 14-19, 2017, Semih Salihoglu, Wenchao Zhou, Rada Chirkova, Jun Yang, and Dan Suciu (Eds.). ACM, 1041–1052. https://doi.org/10.1145/3035918.3056101 [41] Kai Xu, Georgi Ganev, Emile Joubert, Rees Davison, Olivier Van Acker, and Luke Robinson. 2023. Synthetic Data Generation of Many-to-Many Datasets via Random Graph Generation. In The Eleventh International Conference on Learning Representations, ICLR 2023, Kigali, Rwanda, May 1-5, 2023. OpenReview.net. https: //openreview.net/forum?id=Q120_4COf-K [42] Lei Xu, Maria Skoularidou, Alfredo Cuesta-Infante, and Kalyan Veeramachaneni. 2019. Modeling Tabular data using Conditional GAN. In Advances in Neural Information Processing Systems 32: Annual Conference on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC, Canada, Hanna M. Wallach, Hugo Larochelle, Alina Beygelzimer, Florence d’Alché-Buc, Emily B. Fox, and Roman Garnett (Eds.). 7333–7343. https://proceedings.neurips. cc/paper/2019/hash/254ed7d2de3b23ab10936522dd547b78-Abstract.html

Paquet, Jakub M. Tomczak, and Cheng Zhang (Eds.). http://papers.nips.cc/ paper_files/paper/2024/hash/25cd345233c65fac1fec0ce61d0f7836-AbstractDatasets_and_Benchmarks_Track.html [33] Aivin V. Solatorio and Olivier Dupriez. 2023. REaLTabFormer: Generating Realistic Relational and Tabular Data using Transformers. CoRR abs/2302.02041 (2023). https://doi.org/10.48550/ARXIV.2302.02041 arXiv:2302.02041 [34] Mihaela C. Stoian, Salijona Dyrmishi, Maxime Cordy, Thomas Lukasiewicz, and Eleonora Giunchiglia. 2024. How Realistic Is Your Synthetic Data? Constraining Deep Generative Models for Tabular Data. In The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna, Austria, May 7-11, 2024. OpenReview.net. https://openreview.net/forum?id=tBROYsEz9G [35] Walter V. Sujansky, Samuel A. Faus, Ethan Stone, and Patricia Flatley Brennan. 2010. A method to implement fine-grained access control for personal health records through standard relational database queries. J. Biomed. Informatics 43, 5-Supplement-1 (2010), S46–S50. https://doi.org/10.1016/J.JBI.2010.08.001 [36] Qwen Team. 2025. Qwen3 Technical Report. CoRR abs/2505.09388 (2025). https: //doi.org/10.48550/ARXIV.2505.09388 arXiv:2505.09388 [37] Paul Tiwald, Ivona Krchova, Andrey Sidorenko, Mariana Vargas Vieyra, Mario Scriminaci, and Michael Platzer. 2025. TabularARGN: A Flexible and Efficient Auto-Regressive Framework for Generating High-Fidelity Synthetic Data. CoRR abs/2501.12012 (2025). https://doi.org/10.48550/ARXIV.2501.12012 arXiv:2501.12012 [38] Benigno Uria, Marc-Alexandre Côté, Karol Gregor, Iain Murray, and Hugo Larochelle. 2016. Neural Autoregressive Distribution Estimation. J. Mach. Learn. Res. 17 (2016), 205:1–205:37. https://jmlr.org/papers/v17/16-272.html

14

Related documents

• Prompt as a Data Type: In-Database LLM Prompt Management and Rewriting#411179
• Graph-to-Table Interfaces Control Relational Generalisation#1401179
• Automated Construction of Relational Attributes ACORA: A Progress Report#933256
• Faithful Federated Tabular Data Synthesis#1455884
• Tracing Recurrent and Emergent Hallucination Patterns in Decomposed Text-to-SQL Generation#1403516