README.md

---
license: cc-by-sa-4.0
task_categories:
- text-retrieval
- text-generation
language:
- de
tags:
- wiktionary
- dictionary
- german
- linguistics
- morphology
- semantics
- normalized
size_categories:
- 100K<n<1M
---

# German Wiktionary - Normalized SQLite Database

A fully normalized, production-ready SQLite database of German Wiktionary with complete linguistic information and optimized query performance.

## 🎯 Key Features

- **✅ Zero data loss**: All information from original Wiktionary preserved
- **⚡ Lightning-fast queries**: Comprehensive indexing (< 5ms typical queries)
- **🔍 Full grammatical analysis**: Complete inflection paradigms, word forms, 185 unique grammatical tags
- **🔗 Semantic relations**: Synonyms, antonyms, derived/related terms
- **🌍 Multi-language**: Translations to 100+ languages
- **📱 Mobile-ready**: Optimized for Flutter/Dart apps on all platforms
- **🗣️ Pronunciation**: IPA, audio files, rhymes
- **📚 Rich examples**: Usage examples with citations
- **🎓 Proper normalization**: Tags/topics/categories deduplicated (3NF)

## 📊 Database Statistics

- **Entries**: 970,801 German words
- **Word senses**: 3.1M+ definitions with glosses
- **Translations**: 1.1M+ translations
- **Word forms**: 6.1M+ inflected forms
- **Pronunciations**: 2.3M+ IPA/audio entries
- **Examples**: 427K+ usage examples
- **Unique tags**: 185 grammatical tags
- **Unique topics**: 58 domain topics
- **Unique categories**: 352 Wiktionary categories
- **File size**: ~3.6 GB (uncompressed), ~1.8 GB (compressed)

## 🏗️ Database Schema

### Lookup Tables (Deduplicated)
- **tags**: Grammatical tags (nominative, plural, past, etc.)
- **topics**: Domain topics (biology, law, sports, etc.)
- **categories**: Wiktionary categories

### Core Tables
- **entries**: Main word entries
- **senses**: Word senses/meanings
- **glosses**: Definitions for each sense
- **examples**: Usage examples with citations

### Morphology
- **forms**: All inflected forms (declensions, conjugations)
- **form_tags**: Many-to-many: forms ↔ grammatical tags
- **hyphenations**: Syllable breaks

### Phonology
- **sounds**: IPA pronunciations, audio URLs, rhymes
- **sound_tags**: Pronunciation variants

### Semantics
- **synonyms**: Synonymous words
- **antonyms**: Opposite words
- **derived_terms**: Morphologically derived words
- **related_terms**: Semantically related words
- **synonym_tags/synonym_topics**: Synonym metadata

### Translation
- **translations**: Translations to other languages
- **translation_tags**: Translation grammatical tags

### Metadata
- **entry_tags**: Word-level tags
- **entry_categories**: Wiktionary categories
- **sense_tags/sense_topics/sense_categories**: Sense-level metadata

## 📖 Usage

### Download
```python
from huggingface_hub import hf_hub_download
import sqlite3
import gzip
import shutil

# Download compressed database
db_gz_path = hf_hub_download(
    repo_id="cstr/de-wiktionary-sqlite-normalized",
    filename="de_wiktionary_normalized.db",
    repo_type="dataset"
)

# Decompress if needed
if db_gz_path.endswith('.gz'):
    db_path = db_gz_path[:-3]
    with gzip.open(db_gz_path, 'rb') as f_in:
        with open(db_path, 'wb') as f_out:
            shutil.copyfileobj(f_in, f_out)
else:
    db_path = db_gz_path

# Connect
conn = sqlite3.connect(db_path)
```

### Python Examples
```python
import sqlite3

conn = sqlite3.connect('de_wiktionary_normalized.db')
cursor = conn.cursor()

# Example 1: Get all inflections with grammatical tags
cursor.execute('''
    SELECT f.form_text, GROUP_CONCAT(t.tag, ', ') as tags
    FROM entries e
    JOIN forms f ON e.id = f.entry_id
    LEFT JOIN form_tags ft ON f.id = ft.form_id
    LEFT JOIN tags t ON ft.tag_id = t.id
    WHERE e.word = ? AND e.lang = 'Deutsch'
    GROUP BY f.id
''', ('Haus',))

for form, tags in cursor.fetchall():
    print(f"{form}: {tags}")

# Example 2: Get synonyms
cursor.execute('''
    SELECT s.synonym_word
    FROM entries e
    JOIN synonyms s ON e.id = s.entry_id
    WHERE e.word = ? AND e.lang = 'Deutsch'
''', ('schnell',))

synonyms = [row[0] for row in cursor.fetchall()]
print(f"Synonyms: {synonyms}")

# Example 3: Get IPA pronunciation
cursor.execute('''
    SELECT s.ipa
    FROM entries e
    JOIN sounds s ON e.id = s.entry_id
    WHERE e.word = ? AND s.ipa IS NOT NULL
''', ('Haus',))

print("IPA:", [row[0] for row in cursor.fetchall()])

# Example 4: Get definitions
cursor.execute('''
    SELECT g.gloss_text
    FROM entries e
    JOIN senses se ON e.id = se.entry_id
    JOIN glosses g ON se.id = g.sense_id
    WHERE e.word = ? AND e.lang = 'Deutsch'
''', ('Liebe',))

print("Definitions:")
for (gloss,) in cursor.fetchall():
    print(f"  - {gloss}")

# Example 5: Get English translations
cursor.execute('''
    SELECT t.word
    FROM entries e
    JOIN translations t ON e.id = t.entry_id
    WHERE e.word = ? AND t.lang_code = 'en'
''', ('Hund',))

print("English:", [row[0] for row in cursor.fetchall()])

# Example 6: Find words by topic
cursor.execute('''
    SELECT DISTINCT e.word
    FROM entries e
    JOIN senses s ON e.id = s.entry_id
    JOIN sense_topics st ON s.id = st.sense_id
    JOIN topics t ON st.topic_id = t.id
    WHERE t.topic = 'biology'
    LIMIT 20
''')

print("Biology terms:", [row[0] for row in cursor.fetchall()])

# Example 7: Autocomplete search
cursor.execute('''
    SELECT DISTINCT word
    FROM entries
    WHERE word LIKE ? AND lang = 'Deutsch'
    ORDER BY word
    LIMIT 10
''', ('Sch%',))

print("Words starting with 'Sch':", [row[0] for row in cursor.fetchall()])

conn.close()
```

### Flutter/Dart
```dart
import 'package:sqflite/sqflite.dart';
import 'package:http/http.dart' as http;
import 'package:path/path.dart';
import 'package:path_provider/path_provider.dart';
import 'dart:io';
import 'package:archive/archive_io.dart';

class WiktionaryDB {
  static Database? _database;
  
  Future<Database> get database async {
    if (_database != null) return _database!;
    _database = await initDB();
    return _database!;
  }
  
  Future<Database> initDB() async {
    final dir = await getApplicationDocumentsDirectory();
    final dbPath = join(dir.path, 'de_wiktionary.db');
    
    // Download and decompress on first run
    if (!await File(dbPath).exists()) {
      final url = 'https://huggingface.co/datasets/cstr/de-wiktionary-sqlite-normalized/resolve/main/de_wiktionary_normalized.db';
      
      print('Downloading database...');
      final response = await http.get(Uri.parse(url));
      
      final gzPath = join(dir.path, 'de_wiktionary.db.gz');
      await File(gzPath).writeAsBytes(response.bodyBytes);
      
      print('Decompressing...');
      final gzFile = File(gzPath);
      final dbFile = File(dbPath);
      
      // Decompress gzip
      final bytes = gzFile.readAsBytesSync();
      final archive = GZipDecoder().decodeBytes(bytes);
      await dbFile.writeAsBytes(archive);
      
      // Clean up
      await gzFile.delete();
      print('Database ready!');
    }
    
    return await openDatabase(dbPath, version: 1);
  }
  
  // Get word forms with grammatical tags
  Future<List<Map<String, dynamic>>> getWordForms(String word) async {
    final db = await database;
    return await db.rawQuery('''
      SELECT f.form_text, GROUP_CONCAT(t.tag, ', ') as tags
      FROM entries e
      JOIN forms f ON e.id = f.entry_id
      LEFT JOIN form_tags ft ON f.id = ft.form_id
      LEFT JOIN tags t ON ft.tag_id = t.id
      WHERE e.word = ? AND e.lang = 'Deutsch'
      GROUP BY f.id
    ''', [word]);
  }
  
  // Get synonyms
  Future<List<String>> getSynonyms(String word) async {
    final db = await database;
    final results = await db.rawQuery('''
      SELECT s.synonym_word
      FROM entries e
      JOIN synonyms s ON e.id = s.entry_id
      WHERE e.word = ? AND e.lang = 'Deutsch'
    ''', [word]);
    return results.map((r) => r['synonym_word'] as String).toList();
  }
  
  // Get IPA pronunciation
  Future<List<String>> getIPA(String word) async {
    final db = await database;
    final results = await db.rawQuery('''
      SELECT s.ipa
      FROM entries e
      JOIN sounds s ON e.id = s.entry_id
      WHERE e.word = ? AND s.ipa IS NOT NULL
    ''', [word]);
    return results.map((r) => r['ipa'] as String).toList();
  }
  
  // Get definitions
  Future<List<String>> getDefinitions(String word) async {
    final db = await database;
    final results = await db.rawQuery('''
      SELECT g.gloss_text
      FROM entries e
      JOIN senses se ON e.id = se.entry_id
      JOIN glosses g ON se.id = g.sense_id
      WHERE e.word = ? AND e.lang = 'Deutsch'
    ''', [word]);
    return results.map((r) => r['gloss_text'] as String).toList();
  }
  
  // Autocomplete search
  Future<List<String>> searchWords(String prefix) async {
    final db = await database;
    final results = await db.rawQuery('''
      SELECT DISTINCT word
      FROM entries
      WHERE word LIKE ? AND lang = 'Deutsch'
      ORDER BY word
      LIMIT 20
    ''', ['$prefix%']);
    return results.map((r) => r['word'] as String).toList();
  }
}
```

## 🔍 Example Queries

### Get complete grammatical analysis
```sql
SELECT 
    e.word,
    f.form_text,
    GROUP_CONCAT(DISTINCT t.tag) as grammatical_tags,
    s.ipa
FROM entries e
JOIN forms f ON e.id = f.entry_id
LEFT JOIN form_tags ft ON f.id = ft.form_id
LEFT JOIN tags t ON ft.tag_id = t.id
LEFT JOIN sounds s ON e.id = s.entry_id
WHERE e.word = 'lieben'
GROUP BY f.id;
```

### Find words by grammatical features
```sql
SELECT DISTINCT e.word
FROM entries e
JOIN forms f ON e.id = f.entry_id
JOIN form_tags ft ON f.id = ft.form_id
JOIN tags t ON ft.tag_id = t.id
WHERE t.tag = 'irregular' AND e.pos = 'verb'
LIMIT 100;
```

### Get words with semantic relationships
```sql
SELECT 
    e.word,
    s.synonym_word,
    a.antonym_word
FROM entries e
LEFT JOIN synonyms s ON e.id = s.entry_id
LEFT JOIN antonyms a ON e.id = a.entry_id
WHERE e.word = 'gut';
```

## 📱 Platform Support

- **iOS**: ✅ Full support via sqflite
- **Android**: ✅ Full support via sqflite  
- **Windows**: ✅ Via sqflite_common_ffi
- **macOS**: ✅ Via sqflite_common_ffi
- **Linux**: ✅ Via sqflite_common_ffi
- **Web**: ⚠️ Via sql.js (WASM)

## 🚀 Performance

Typical query times (modern hardware):
- Word lookup: < 1ms
- Get all forms: < 5ms
- Complex multi-table joins: < 20ms
- Autocomplete search: < 10ms

## 🔗 Source

Original data: [cstr/de-wiktionary-extracted](https://huggingface.co/datasets/cstr/de-wiktionary-extracted)

## 📜 License

CC-BY-SA 4.0 (same as source)

## 🛠️ Technical Details

- **SQLite Version**: 3.x compatible
- **Encoding**: UTF-8
- **Foreign Keys**: Enabled
- **Indexes**: 38 indexes for optimal performance
- **Normalization**: 3NF with deduplicated tags/topics/categories

## 📊 Schema Overview
```
entries (970K rows)
├── senses (3.1M) → glosses (3.1M)
├── forms (6.1M) → form_tags (26M) → tags (185)
├── sounds (2.3M) → sound_tags
├── translations (1.1M) → translation_tags
├── synonyms (162K) → synonym_tags
├── antonyms
└── hyphenations (954K)
```

## 🤝 Contributing

Found an issue? Please report it on the source dataset repository.