WikiDBGraph Dataset

WikiDBGraph is a comprehensive dataset for database graph analysis, containing structural and semantic properties of 100,000 Wikidata-derived databases. The dataset includes graph representations, similarity metrics, community structures, and various statistical properties designed for federated learning research and database schema matching tasks.

Dataset Overview

This dataset provides graph-based analysis of database schemas, enabling research in:

• Database similarity and matching: Finding structurally and semantically similar databases
• Federated learning: Training machine learning models across distributed database pairs
• Graph analysis: Community detection, connected components, and structural properties
• Schema analysis: Statistical properties of database schemas including cardinality, entropy, and sparsity

Statistics

• Total Databases: 100,000
• Total Edges: 17,858,194 (at threshold 0.94)
• Connected Components: 6,109
• Communities: 6,133
• Largest Component: 10,703 nodes
• Modularity Score: 0.5366

Dataset Structure

The dataset consists of 15 files organized into four categories:

1. Graph Structure Files

graph_raw_0.94.dgl

DGL (Deep Graph Library) graph file containing the complete database similarity graph.

Structure:

• Nodes: 100,000 database IDs
• Edges: 17,858,194 pairs with similarity ≥ 0.94
• Node Data:
  • embedding: 768-dimensional node embeddings (if available)
• Edge Data:
  • weight: Edge similarity scores (float32)
  • gt_edge: Ground truth edge labels (float32)

Loading:

import dgl
import torch

# Load the graph
graphs, _ = dgl.load_graphs('graph_raw_0.94.dgl')
graph = graphs[0]

# Access nodes and edges
num_nodes = graph.num_nodes()  # 100000
num_edges = graph.num_edges()  # 17858194

# Access edge data
src, dst = graph.edges()
edge_weights = graph.edata['weight']
edge_labels = graph.edata['gt_edge']

# Access node embeddings (if available)
if 'embedding' in graph.ndata:
    node_embeddings = graph.ndata['embedding']  # shape: (100000, 768)

database_embeddings.pt

PyTorch tensor file containing pre-computed 768-dimensional embeddings for all databases.

Structure:

• Tensor shape: (100000, 768)
• Data type: float32
• Embeddings generated using BGE (BAAI General Embedding) model

Loading:

import torch

embeddings = torch.load('database_embeddings.pt', weights_only=True)
print(embeddings.shape)  # torch.Size([100000, 768])

# Get embedding for specific database
db_idx = 42
db_embedding = embeddings[db_idx]

2. Edge Files (Database Pair Relationships)

filtered_edges_threshold_0.94.csv

Main edge list with database pairs having similarity ≥ 0.94.

Columns:

• src (float): Source database ID
• tgt (float): Target database ID
• similarity (float): Cosine similarity score [0.94, 1.0]
• label (float): Ground truth label (0.0 or 1.0)
• edge (int): Edge indicator (always 1)

Loading:

import pandas as pd

edges = pd.read_csv('filtered_edges_threshold_0.94.csv')
print(f"Total edges: {len(edges):,}")

# Find highly similar pairs
high_sim = edges[edges['similarity'] >= 0.99]
print(f"Pairs with similarity ≥ 0.99: {len(high_sim):,}")

Example rows:

src       tgt       similarity  label  edge
26218.0   44011.0   0.9896456   0.0    1
26218.0   44102.0   0.9908572   0.0    1

edges_list_th0.6713.csv

Extended edge list with lower similarity threshold (≥ 0.6713).

Columns:

• src (str): Source database ID (padded format, e.g., "00000")
• tgt (str): Target database ID (padded format)
• similarity (float): Cosine similarity score [0.6713, 1.0]
• label (float): Ground truth label

Loading:

import pandas as pd

edges = pd.read_csv('edges_list_th0.6713.csv')

# Database IDs are strings with leading zeros
print(edges['src'].head())  # "00000", "00000", "00000", ...

# Filter by similarity threshold
threshold = 0.90
filtered = edges[edges['similarity'] >= threshold]

edge_structural_properties_GED_0.94.csv

Detailed structural properties for database pairs at threshold 0.94.

Columns:

• db_id1 (int): First database ID
• db_id2 (int): Second database ID
• jaccard_table_names (float): Jaccard similarity of table names [0.0, 1.0]
• jaccard_columns (float): Jaccard similarity of column names [0.0, 1.0]
• jaccard_data_types (float): Jaccard similarity of data types [0.0, 1.0]
• hellinger_distance_data_types (float): Hellinger distance between data type distributions
• graph_edit_distance (float): Graph edit distance between schemas
• common_tables (int): Number of common table names
• common_columns (int): Number of common column names
• common_data_types (int): Number of common data types

Loading:

import pandas as pd

edge_props = pd.read_csv('edge_structural_properties_GED_0.94.csv')

# Find pairs with high structural similarity
high_jaccard = edge_props[edge_props['jaccard_columns'] >= 0.5]
print(f"Pairs with ≥50% column overlap: {len(high_jaccard):,}")

# Analyze graph edit distance
print(f"Mean GED: {edge_props['graph_edit_distance'].mean():.2f}")
print(f"Median GED: {edge_props['graph_edit_distance'].median():.2f}")

distdiv_results.csv

Distribution divergence metrics for database pairs.

Columns:

• src (int): Source database ID
• tgt (int): Target database ID
• distdiv (float): Distribution divergence score
• overlap_ratio (float): Column overlap ratio [0.0, 1.0]
• shared_column_count (int): Number of shared columns

Loading:

import pandas as pd

distdiv = pd.read_csv('distdiv_results.csv')

# Find pairs with low divergence (more similar distributions)
similar_dist = distdiv[distdiv['distdiv'] < 15.0]

# Analyze overlap patterns
high_overlap = distdiv[distdiv['overlap_ratio'] >= 0.3]
print(f"Pairs with ≥30% overlap: {len(high_overlap):,}")

all_join_size_results_est.csv

Estimated join sizes for databases (cardinality estimation).

Columns:

• db_id (int): Database ID
• all_join_size (float): Estimated size of full outer join across all tables

Loading:

import pandas as pd

join_sizes = pd.read_csv('all_join_size_results_est.csv')

# Analyze join complexity
print(f"Mean join size: {join_sizes['all_join_size'].mean():.2f}")
print(f"Max join size: {join_sizes['all_join_size'].max():.2f}")

# Large databases (complex joins)
large_dbs = join_sizes[join_sizes['all_join_size'] > 1000]

3. Node Files (Database Properties)

node_structural_properties.csv

Comprehensive structural properties for each database schema.

Columns:

• db_id (int): Database ID
• num_tables (int): Number of tables in the database
• num_columns (int): Total number of columns across all tables
• foreign_key_density (float): Ratio of foreign keys to possible relationships
• avg_table_connectivity (float): Average number of connections per table
• median_table_connectivity (float): Median connections per table
• min_table_connectivity (float): Minimum connections for any table
• max_table_connectivity (float): Maximum connections for any table
• data_type_proportions (str): JSON string with data type distribution
• data_types (str): JSON string with count of each data type
• wikidata_properties (int): Number of Wikidata properties used

Loading:

import pandas as pd
import json

node_props = pd.read_csv('node_structural_properties.csv')

# Parse JSON columns
node_props['data_type_dist'] = node_props['data_type_proportions'].apply(
    lambda x: json.loads(x.replace("'", '"'))
)

# Analyze database complexity
complex_dbs = node_props[node_props['num_tables'] > 10]
print(f"Databases with >10 tables: {len(complex_dbs):,}")

# Foreign key density analysis
print(f"Mean FK density: {node_props['foreign_key_density'].mean():.4f}")

Example row:

db_id: 88880
num_tables: 2
num_columns: 24
foreign_key_density: 0.0833
avg_table_connectivity: 1.5
data_type_proportions: {'string': 0.417, 'wikibase-entityid': 0.583}

data_volume.csv

Storage size information for each database.

Columns:

• db_id (str/int): Database ID (may have leading zeros)
• volume_bytes (int): Total data volume in bytes

Loading:

import pandas as pd

volumes = pd.read_csv('data_volume.csv')

# Convert to more readable units
volumes['volume_mb'] = volumes['volume_bytes'] / (1024 * 1024)
volumes['volume_gb'] = volumes['volume_bytes'] / (1024 * 1024 * 1024)

# Find largest databases
top_10 = volumes.nlargest(10, 'volume_bytes')
print(top_10[['db_id', 'volume_gb']])

4. Column-Level Statistics

column_cardinality.csv

Distinct value counts for all columns.

Columns:

• db_id (str/int): Database ID
• table_name (str): Table name
• column_name (str): Column name
• n_distinct (int): Number of distinct values

Loading:

import pandas as pd

cardinality = pd.read_csv('column_cardinality.csv')

# High cardinality columns (potentially good as keys)
high_card = cardinality[cardinality['n_distinct'] > 100]

# Analyze cardinality distribution
print(f"Mean distinct values: {cardinality['n_distinct'].mean():.2f}")
print(f"Median distinct values: {cardinality['n_distinct'].median():.2f}")

Example rows:

db_id  table_name          column_name         n_distinct
6      scholarly_articles  article_title       275
6      scholarly_articles  article_description 197
6      scholarly_articles  pub_med_id          269

column_entropy.csv

Shannon entropy for column value distributions.

Columns:

• db_id (str): Database ID (padded format)
• table_name (str): Table name
• column_name (str): Column name
• entropy (float): Shannon entropy value [0.0, ∞)

Loading:

import pandas as pd

entropy = pd.read_csv('column_entropy.csv')

# High entropy columns (high information content)
high_entropy = entropy[entropy['entropy'] > 3.0]

# Low entropy columns (low diversity)
low_entropy = entropy[entropy['entropy'] < 0.5]

# Distribution analysis
print(f"Mean entropy: {entropy['entropy'].mean():.3f}")

Example rows:

db_id   table_name                    column_name              entropy
00001   descendants_of_john_i         full_name                3.322
00001   descendants_of_john_i         gender                   0.881
00001   descendants_of_john_i         father_name              0.000

column_sparsity.csv

Missing value ratios for all columns.

Columns:

• db_id (str): Database ID (padded format)
• table_name (str): Table name
• column_name (str): Column name
• sparsity (float): Ratio of missing values [0.0, 1.0]

Loading:

import pandas as pd

sparsity = pd.read_csv('column_sparsity.csv')

# Dense columns (few missing values)
dense = sparsity[sparsity['sparsity'] < 0.1]

# Sparse columns (many missing values)
sparse = sparsity[sparsity['sparsity'] > 0.5]

# Quality assessment
print(f"Columns with >50% missing: {len(sparse):,}")
print(f"Mean sparsity: {sparsity['sparsity'].mean():.3f}")

Example rows:

db_id   table_name                      column_name       sparsity
00009   FamousPencilMoustacheWearers   Name              0.000
00009   FamousPencilMoustacheWearers   Biography         0.000
00009   FamousPencilMoustacheWearers   ViafId            0.222

5. Clustering and Community Files

community_assignment_0.94.csv

Community detection results using Louvain algorithm.

Columns:

• node_id (int): Database ID
• partition (int): Community/partition ID

Loading:

import pandas as pd

communities = pd.read_csv('community_assignment_0.94.csv')

# Analyze community structure
community_sizes = communities['partition'].value_counts()
print(f"Number of communities: {len(community_sizes)}")
print(f"Largest community size: {community_sizes.max()}")

# Get databases in a specific community
community_1 = communities[communities['partition'] == 1]['node_id'].tolist()

Statistics:

• Total communities: 6,133
• Largest community: 4,825 nodes
• Modularity: 0.5366

cluster_assignments_dim2_sz100_msNone.csv

Clustering results from dimensionality reduction (e.g., t-SNE, UMAP).

Columns:

• db_id (int): Database ID
• cluster (int): Cluster ID

Loading:

import pandas as pd

clusters = pd.read_csv('cluster_assignments_dim2_sz100_msNone.csv')

# Analyze cluster distribution
cluster_sizes = clusters['cluster'].value_counts()
print(f"Number of clusters: {len(cluster_sizes)}")

# Get databases in a specific cluster
cluster_9 = clusters[clusters['cluster'] == 9]['db_id'].tolist()

6. Analysis Reports

analysis_0.94_report.txt

Comprehensive text report of graph analysis at threshold 0.94.

Contents:

• Graph statistics (nodes, edges)
• Connected components analysis
• Community detection results
• Top components and communities by size

Loading:

with open('analysis_0.94_report.txt', 'r') as f:
    report = f.read()
    print(report)

Key Metrics:

• Total Nodes: 100,000
• Total Edges: 17,858,194
• Connected Components: 6,109
• Largest Component: 10,703 nodes
• Communities: 6,133
• Modularity: 0.5366

Usage Examples

Example 1: Finding Similar Database Pairs

import pandas as pd

# Load edges with high similarity
edges = pd.read_csv('filtered_edges_threshold_0.94.csv')

# Find database pairs with similarity > 0.98
high_sim_pairs = edges[edges['similarity'] >= 0.98]
print(f"Found {len(high_sim_pairs)} pairs with similarity ≥ 0.98")

# Get top 10 most similar pairs
top_pairs = edges.nlargest(10, 'similarity')
for idx, row in top_pairs.iterrows():
    print(f"DB {int(row['src'])} ↔ DB {int(row['tgt'])}: {row['similarity']:.4f}")

Example 2: Analyzing Database Properties

import pandas as pd
import json

# Load node properties
nodes = pd.read_csv('node_structural_properties.csv')

# Find complex databases
complex_dbs = nodes[
    (nodes['num_tables'] > 10) & 
    (nodes['num_columns'] > 100)
]

print(f"Complex databases: {len(complex_dbs)}")

# Analyze data type distribution
for idx, row in complex_dbs.head().iterrows():
    db_id = row['db_id']
    types = json.loads(row['data_types'].replace("'", '"'))
    print(f"DB {db_id}: {types}")

Example 3: Loading and Analyzing the Graph

import dgl
import torch
import pandas as pd

# Load DGL graph
graphs, _ = dgl.load_graphs('graph_raw_0.94.dgl')
graph = graphs[0]

# Basic statistics
print(f"Nodes: {graph.num_nodes():,}")
print(f"Edges: {graph.num_edges():,}")

# Analyze degree distribution
in_degrees = graph.in_degrees()
out_degrees = graph.out_degrees()

print(f"Average in-degree: {in_degrees.float().mean():.2f}")
print(f"Average out-degree: {out_degrees.float().mean():.2f}")

# Find highly connected nodes
top_nodes = torch.topk(in_degrees, k=10)
print(f"Top 10 most connected databases: {top_nodes.indices.tolist()}")

Example 4: Federated Learning Pair Selection

import pandas as pd

# Load edges and structural properties
edges = pd.read_csv('filtered_edges_threshold_0.94.csv')
edge_props = pd.read_csv('edge_structural_properties_GED_0.94.csv')

# Merge data
pairs = edges.merge(
    edge_props, 
    left_on=['src', 'tgt'], 
    right_on=['db_id1', 'db_id2'],
    how='inner'
)

# Select pairs for federated learning
# Criteria: high similarity + high column overlap + low GED
fl_candidates = pairs[
    (pairs['similarity'] >= 0.98) &
    (pairs['jaccard_columns'] >= 0.4) &
    (pairs['graph_edit_distance'] <= 3.0)
]

print(f"FL candidate pairs: {len(fl_candidates)}")

# Sample pairs for experiments
sample = fl_candidates.sample(n=100, random_state=42)

Example 5: Column Statistics Analysis

import pandas as pd

# Load column-level statistics
cardinality = pd.read_csv('column_cardinality.csv')
entropy = pd.read_csv('column_entropy.csv')
sparsity = pd.read_csv('column_sparsity.csv')

# Merge on (db_id, table_name, column_name)
merged = cardinality.merge(entropy, on=['db_id', 'table_name', 'column_name'])
merged = merged.merge(sparsity, on=['db_id', 'table_name', 'column_name'])

# Find high-quality columns for machine learning
# Criteria: high cardinality, high entropy, low sparsity
quality_columns = merged[
    (merged['n_distinct'] > 50) &
    (merged['entropy'] > 2.0) &
    (merged['sparsity'] < 0.1)
]

print(f"High-quality columns: {len(quality_columns)}")

Example 6: Community Analysis

import pandas as pd

# Load community assignments
communities = pd.read_csv('community_assignment_0.94.csv')
nodes = pd.read_csv('node_structural_properties.csv')

# Merge to get properties by community
community_props = communities.merge(
    nodes, 
    left_on='node_id', 
    right_on='db_id'
)

# Analyze each community
for comm_id in community_props['partition'].unique()[:5]:
    comm_data = community_props[community_props['partition'] == comm_id]
    print(f"\nCommunity {comm_id}:")
    print(f"  Size: {len(comm_data)}")
    print(f"  Avg tables: {comm_data['num_tables'].mean():.2f}")
    print(f"  Avg columns: {comm_data['num_columns'].mean():.2f}")

Applications

1. Federated Learning Research

Use the similarity graph to identify database pairs for federated learning experiments. The high-similarity pairs (≥0.98) are ideal for horizontal federated learning scenarios.

2. Schema Matching

Leverage structural properties and similarity metrics for automated schema matching and integration tasks.

3. Database Clustering

Use embeddings and community detection results to group similar databases for analysis or optimization.

4. Data Quality Assessment

Column-level statistics (cardinality, entropy, sparsity) enable systematic data quality evaluation across large database collections.

5. Graph Neural Networks

The DGL graph format is ready for training GNN models for link prediction, node classification, or graph classification tasks.

Technical Details

Similarity Computation

• Method: BGE (BAAI General Embedding) model for semantic embeddings
• Metric: Cosine similarity
• Thresholds: Multiple thresholds available (0.6713, 0.94, 0.96)

Graph Construction

• Nodes: Database IDs (0 to 99,999)
• Edges: Database pairs with similarity above threshold
• Edge weights: Cosine similarity scores
• Format: DGL binary format for efficient loading

Community Detection

• Algorithm: Louvain method
• Modularity: 0.5366 (indicates well-defined communities)
• Resolution: Default parameter

Data Processing Pipeline

1. Schema extraction from Wikidata databases
2. Semantic embedding generation using BGE
3. Similarity computation across all pairs
4. Graph construction and filtering
5. Property extraction and statistical analysis
6. Community detection and clustering

Data Format Standards

Database ID Formats

• Integer IDs: Used in most files (0-99999)
• Padded strings: Used in some files (e.g., "00000", "00001")
• Conversion: str(db_id).zfill(5) for integer to padded string

Missing Values

• Numerical columns: May contain NaN or -0.0
• String columns: Empty strings or missing entries
• Sparsity column: Explicit ratio of missing values

Data Types

• float32: Similarity scores, weights, entropy
• float64: Statistical measures, ratios
• int64: Counts, IDs
• string: Names, identifiers

File Size Information

Approximate file sizes:

• graph_raw_0.94.dgl: ~2.5 GB
• database_embeddings.pt: ~300 MB
• filtered_edges_threshold_0.94.csv: ~800 MB
• edge_structural_properties_GED_0.94.csv: ~400 MB
• node_structural_properties.csv: ~50 MB
• Column statistics CSVs: ~20-50 MB each
• Other files: <10 MB each

Citation

If you use this dataset in your research, please cite:

@article{wu2025wikidbgraph,
  title={WikiDBGraph: Large-Scale Database Graph of Wikidata for Collaborative Learning},
  author={Wu, Zhaomin and Wang, Ziyang and He, Bingsheng},
  journal={arXiv preprint arXiv:2505.16635},
  year={2025}
}

License

This dataset is licensed under Creative Commons Attribution 4.0 International (CC BY 4.0).

Acknowledgments

This dataset is derived from Wikidata and builds upon the WikiDBGraph system for graph-based database analysis and federated learning. We acknowledge the Wikidata community for providing the underlying data infrastructure.