Most machine learning models for synthetic data generation assume that data lives in a single, isolated flat table. In this idealized view, every row is independent and identically distributed. However, real-world enterprise data rarely looks like this. As noted by Hoppe et al., the vast majority of practical data is structured relationally, spread across multiple interconnected tables.
If you attempt to synthesize a relational database by treating each table independently, the system breaks immediately. You lose two fundamental properties: referential integrity (ensuring foreign keys actually point to valid primary keys) and cross-table statistical correlations (such as user demographics in a Users table predicting purchasing behavior in a Transactions table). When these links are broken, the synthetic database becomes useless for downstream tasks like software testing, database benchmarking, or training robust foundation models.
The Structural Hurdles: Fanout and Relational Hops
To understand why relational synthesis is difficult, consider why we cannot simply join all tables into one massive flat table, synthesize it using a standard tabular model, and split it back apart.
First, relational data exhibits a property known as fanout. A single row in a parent table (e.g., a customer) can link to zero, one, or hundreds of rows in a child table (e.g., transactions). The distribution of these counts is a critical structural signature of the database. Hudovernik et al. demonstrated that these aggregated relational features—like the exact count of child records associated with a parent—are the primary indicators that distinguish synthetic databases from real ones. Standard single-table generators fail to replicate these ratios, leaving a detectable signature of artificiality.
[Parent Table: Users]
│
├─► (Fanout: 1 user to N transactions)
│
[Child Table: Transactions]
│
├─► (Relational Hop: Transactions to Merchants)
│
[Grandchild Table: Merchants]
Second, statistical dependencies often span multiple relational hops. As Pang et al. point out, an attribute in a root table might influence an attribute in a distant descendant table. Simultaneously conditioning a generative model on multiple parent tables is mathematically complex and computationally expensive, frequently causing models to lose these long-range dependencies.
Finally, if a synthetic database fails to preserve these joint distributions and fanouts, database engines will miscalculate cardinality estimations. As Zhong et al. argue, incorrect cardinality causes database optimizers to select highly inefficient execution plans, making the synthetic data useless for realistic performance benchmarking.
Graph-Based and Diffusion Solutions
To capture the multi-dimensional web of a database schema, researchers have reframed the problem using graph architectures. If a relational schema is viewed as a heterogeneous graph—where tables represent node types and foreign keys represent edges—graph neural networks and diffusion models can be leveraged to generate structure and attributes in tandem.
Xu et al. pioneered this perspective by reframing the synthesis of complex many-to-many datasets as a random graph generation task. By utilizing node and set embeddings, their framework successfully captures dense inter-table correlations that traditional tabular tools miss entirely.
Building on this, Hudovernik et al. introduced RELDIFF, a generative framework that models an entire database as a heterogeneous graph. RELDIFF pairs a specialized graph generator to establish the underlying relational structure with a joint diffusion process for the attributes. This ensures that referential integrity is baked directly into the denoising process, preventing the generation of broken links or orphaned rows.
For handling long-range dependencies across schemas, Pang et al. developed ClavaDDPM. This approach uses cluster-guided diffusion models to navigate the mathematical complexity of multi-parent conditioning, ensuring that constraints from all related parent records are satisfied simultaneously during data generation.
Bypassing Join Keys via Schema Decomposition
A significant challenge arises when trying to synthesize relational data under strict privacy constraints, such as Differential Privacy (DP). Explicitly generating synthetic primary and foreign keys under DP introduces substantial noise, which frequently destroys the utility of the join relationships.
To circumvent this, Cai introduced the PrivPetal framework, which utilizes a "join-then-decompose" strategy. Instead of generating noisy, artificial identifiers table-by-table, the framework synthesizes a differentially private version of the fully joined table. It then leverages "permutation relations" to mathematically decompose this unified representation back into the original relational schema.
[Original Schema] ──► [Join Tables] ──► [Synthesize Joined Data (with DP)]
│
[Final Synthetic Schema] ◄── [Decompose via Permutations] ◄──────┘
This approach bypasses the need to explicitly manage synthetic join keys while inherently preserving three distinct levels of correlation:
- Inter-attribute: Correlations between columns within a single row.
- Intra-group: How rows sharing a common key relate to one another.
- Inter-relational: How attributes in one table influence records in another.
This builds upon earlier multi-relational DP foundations, such as PrivLava by Cai et al., which utilized graphical models with latent variables to maintain foreign key integrity without sacrificing privacy.
Imposing Causal and Explicit Constraints
While deep learning models excel at capturing implicit statistical patterns, they can still produce logically impossible combinations or violate hard business rules. To combat this, researchers incorporate explicit domain logic and structural constraints directly into the synthesis pipeline.
One prominent approach is the integration of causal frameworks. Hoppe et al. utilize Structural Causal Models (SCMs) to guide relational synthesis. By explicitly modeling the directional, causal links between different data entities, the generator is forced to respect real-world dependencies rather than just surface-level statistical correlations.
This balances a wider design space that spans from fully automated "black-box" neural networks to highly transparent "white-box" programmatic tools:
- Visual Workflow Pipelines: Early frameworks, such as the one proposed by Adä et al., relied on conditional logic nodes to explicitly define dependencies between attributes across related tables, ensuring logical consistency at scale.
- Selective SQL Disclosure: Gavidia-Calderon et al. developed SqlSynthGen (SSG), a transparent framework that allows data custodians to use human-readable SQL queries to configure the generation process. This allows operators to explicitly enforce temporal logic and referential integrity constraints, ensuring that the synthetic output remains perfectly compatible with existing enterprise software pipelines.
Key Foundational Work
The new iris data: modular data generators (2010) — contributed 3 concept elements to this direction.
PrivBayes: private data release via bayesian networks (2014) — contributed 1 concept elements to this direction.