Datasets:

Jerrylife
/

WikiDBGraph

	---
	license: cc-by-4.0
	task_categories:
	- graph-ml
	- tabular-classification
	- tabular-regression
	language:
	- en
	tags:
	- database-analysis
	- graph-similarity
	- federated-learning
	- schema-matching
	- wikidata
	size_categories:
	- 10B<n<100B
	---

	# 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:
	```python
	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:
	```python
	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:
	```python
	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:
	```python
	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:
	```python
	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:
	```python
	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:
	```python
	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:
	```python
	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:
	```python
	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:
	```python
	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:
	```python
	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:
	```python
	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:
	```python
	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:
	```python
	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:
	```python
	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

	```python
	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

	```python
	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

	```python
	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

	```python
	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

	```python
	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

	```python
	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:

	```bibtex
	@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.