MYSQL-DATENBANKEN IMPORTIEREN & EXPORTIEREN – GROSSE DATENMENGEN RICHTIG HANDHABEN

Warum phpMyAdmin bei großen Datenbanken versagt

phpMyAdmin ist ein hervorragendes Werkzeug für die tägliche Datenbankarbeit. Tabellen durchsuchen, Abfragen ausführen, kleine Importe – kein Problem. Doch sobald Datenmengen in den dreistelligen Megabyte-Bereich steigen, treffen drei technische Schranken gleichzeitig aufeinander.

Das Tückische: phpMyAdmin zeigt oft keine klare Fehlermeldung. Der Import bricht einfach mittendrin ab – ohne Hinweis, wo genau und ob Daten korrekt importiert wurden. Das Resultat ist im schlimmsten Fall eine halbfertig befüllte Datenbank, die inkonsistente Zustände enthält.

Übersicht: Welche Methode passt zu deiner Situation?

Die richtige Methode hängt von deinen Zugriffsrechten und der Datenbankgröße ab:

mysqldump via SSH – der Goldstandard

mysqldump ist das offizielle Backup-Tool für MySQL und MariaDB. Es läuft direkt auf dem Server, kennt keine PHP-Timeouts und kann Datenbanken jeder Größe sichern. Voraussetzung: SSH-Zugang zu deinem Server.

Einfacher Export

# Einzelne Datenbank exportieren
mysqldump -u benutzername -p datenbankname > dump.sql

# Mit Passwort direkt (kein interaktiver Prompt)
mysqldump -u benutzername -p'MeinPasswort' datenbankname > dump.sql

# Alle Datenbanken auf einmal sichern
mysqldump -u root -p --all-databases > alle-datenbanken.sql

Optimierter Export für große Datenbanken

# Zusatzoptionen für große, produktive Datenbanken
mysqldump \
  -u benutzername -p \
  --single-transaction \     # Konsistenter Snapshot ohne Tabellensperren (InnoDB)
  --quick \                  # Zeilen einzeln laden, schont RAM
  --skip-extended-insert \   # Einzelne INSERTs – einfacher zu debuggen
  --set-gtid-purged=OFF \    # Für Replikationsumgebungen relevant
  datenbankname > dump.sql

Dump komprimieren: Dateigröße um bis zu 90 % reduzieren

SQL-Dumps bestehen aus reinem Text – und Text lässt sich hervorragend komprimieren. Ein 1-GB-Dump schrumpft mit gzip regelmäßig auf 80–150 MB. Das spart Speicherplatz und beschleunigt den Transfer erheblich.

Export direkt als gzip-Archiv

# Export + sofortige Komprimierung per Pipe
mysqldump -u benutzername -p datenbankname | gzip > dump.sql.gz

# Mit Datum im Dateinamen – praktisch für automatisierte Backups
mysqldump -u benutzername -p datenbankname | gzip > dump-$(date +%Y-%m-%d).sql.gz

Bestehenden Dump nachträglich komprimieren

# Komprimieren (die Originaldatei wird ersetzt)
gzip dump.sql

# Komprimieren ohne Original zu löschen
gzip -k dump.sql

# Entpacken
gunzip dump.sql.gz

Import via SSH – schnell, sicher, ohne Limits

Der Import via SSH ist genauso unkompliziert wie der Export. Der mysql-Client liest die SQL-Datei direkt ein und ist dabei nur durch die Netzwerkgeschwindigkeit und den Server begrenzt – nicht durch PHP.

Einfacher SQL-Import

# SQL-Datei in bestehende Datenbank importieren
mysql -u benutzername -p datenbankname < dump.sql

Komprimierten Dump importieren

# gzip-Dump direkt importieren ohne zwischenzeitliches Entpacken
gunzip -c dump.sql.gz | mysql -u benutzername -p datenbankname

# Alternative mit zcat
zcat dump.sql.gz | mysql -u benutzername -p datenbankname

Import mit Fortschrittsanzeige

# pv zeigt Geschwindigkeit und geschätzte Restzeit
pv dump.sql | mysql -u benutzername -p datenbankname

# pv installieren falls nicht vorhanden (Debian/Ubuntu)
apt-get install pv

Kein SSH-Zugang? Import & Export per PHP-Skript

Auf Shared-Hosting-Tarifen ohne SSH-Zugang gibt es dennoch einen Weg zu mysqldump: PHP kann mit der system()-Funktion Server-Befehle ausführen – sofern der Hosting-Anbieter dies erlaubt. Das Skript wird per FTP hochgeladen und dann über den Browser aufgerufen.

Export-Skript (export.php)

<?php
// Zugangsdaten anpassen
$db_host = 'localhost';
$db_user = 'dein-datenbankbenutzer';
$db_pass = 'dein-passwort';
$db_name = 'dein-datenbankname';
$dump_pfad = '/absoluter/pfad/zum/webspace/dump/dump.sql';

// Dump erstellen
$befehl = '/usr/bin/mysqldump -u' . escapeshellarg($db_user)
        . ' -p' . escapeshellarg($db_pass)
        . ' -h' . escapeshellarg($db_host)
        . ' ' . escapeshellarg($db_name)
        . ' > ' . escapeshellarg($dump_pfad);

system($befehl, $exitcode);

if ($exitcode === 0 && chmod($dump_pfad, 0600)) {
    echo 'Export erfolgreich. Dump liegt unter: ' . $dump_pfad;
} else {
    echo 'Fehler beim Export. Exit-Code: ' . $exitcode;
}
?>

Export als gzip-Archiv (export-gz.php)

<?php
$db_host = 'localhost';
$db_user = 'dein-datenbankbenutzer';
$db_pass = 'dein-passwort';
$db_name = 'dein-datenbankname';
$dump_pfad = '/absoluter/pfad/zum/webspace/dump/dump.sql.gz';

$befehl = '/usr/bin/mysqldump -u' . escapeshellarg($db_user)
        . ' -p' . escapeshellarg($db_pass)
        . ' -h' . escapeshellarg($db_host)
        . ' ' . escapeshellarg($db_name)
        . ' | /bin/gzip > ' . escapeshellarg($dump_pfad);

system($befehl, $exitcode);

if ($exitcode === 0 && chmod($dump_pfad, 0600)) {
    echo 'Export als .gz erfolgreich.';
} else {
    echo 'Fehler beim Export. Exit-Code: ' . $exitcode;
}
?>

Import-Skript (import.php)

<?php
$db_host = 'localhost';
$db_user = 'dein-datenbankbenutzer';
$db_pass = 'dein-passwort';
$db_name = 'dein-datenbankname';
$dump_pfad = '/absoluter/pfad/zum/webspace/dump/dump.sql';

$befehl = '/usr/bin/mysql -u' . escapeshellarg($db_user)
        . ' -p' . escapeshellarg($db_pass)
        . ' -h' . escapeshellarg($db_host)
        . ' ' . escapeshellarg($db_name)
        . ' < ' . escapeshellarg($dump_pfad);

system($befehl, $exitcode);
echo $exitcode === 0 ? 'Import erfolgreich.' : 'Fehler beim Import. Code: ' . $exitcode;
?>

Den absoluten Pfad zu deinem Webspace findest du bei den meisten Hostern im Verwaltungspanel unter den Serverinformationen – er sieht meist aus wie /var/www/html/deinname oder /is/htdocs/wp1234567_ABC.

BigDump – web-basierter Import für große SQL-Dateien

Wer keinen SSH-Zugang hat und system() auf dem Server nicht verfügbar ist, kann auf BigDump zurückgreifen. Das PHP-Skript liest die hochgeladene SQL-Datei in kleinen, definierten Häppchen ein – und umgeht so den PHP-Timeout clever, indem es sich per Meta-Refresh selbst immer wieder neu aufruft.

• BigDump herunterladen – das PHP-Skript von der offiziellen Projektseite laden (bigdump.php)
• Konfigurieren – Datenbankzugangsdaten direkt in der bigdump.php eintragen: $db_server, $db_username, $db_password, $db_name
• SQL-Dump hochladen – per FTP in dasselbe Verzeichnis wie bigdump.php legen
• bigdump.php im Browser aufrufen – den Pfad zur SQL-Datei auswählen und starten
• Fortschritt beobachten – BigDump zeigt prozentualen Fortschritt und Dauer
• Beide Dateien löschen – nach erfolgreichem Import bigdump.php und dump.sql sofort entfernen

WP-CLI: Datenbanken in WordPress-Projekten managen

Wer mit WordPress-Projekten arbeitet, hat mit WP-CLI ein mächtiges Tool an der Hand. Es liest Zugangsdaten direkt aus der wp-config.php – kein manuelles Eintippen von Host, User und Passwort.

# Datenbank exportieren (liest wp-config.php automatisch)
wp db export backup.sql

# Komprimiert exportieren
wp db export -- | gzip > backup.sql.gz

# Datenbank importieren
wp db import backup.sql

# URL nach Migration/Domainwechsel ersetzen
wp search-replace 'https://alte-domain.de' 'https://neue-domain.de' --all-tables

# Datenbankstruktur prüfen
wp db check

Der search-replace-Befehl ist besonders wertvoll bei Website-Migrationen. WordPress speichert URLs serialisiert in der Datenbank – ein einfaches Suchen-Ersetzen in der SQL-Datei zerstört dabei die Serialisierung. WP-CLI handhabt das korrekt. Mehr zur sicheren Wartung und Absicherung von WordPress-Installationen findest du in einem eigenen Leitfaden.

Troubleshooting: Häufige Fehler und ihre Ursachen

Fehler: 1044 – Access denied for user

Dieser Fehler beim Import bedeutet fast immer: Im SQL-Dump steckt der Befehl CREATE DATABASE. Shared-Hosting-Benutzer dürfen über ihren Datenbankbenutzer keine neuen Datenbanken anlegen – das geht nur über das Verwaltungspanel des Hosters.

Lösung: Öffne den Dump in einem Texteditor (bei großen Dateien: Notepad++, VS Code, oder per grep auf der Kommandozeile) und entferne die Zeilen mit CREATE DATABASE und USE datenbankname;. Danach klappt der Import.

Fehler: Zeichensatz-Probleme (krakelige Umlaute)

Wenn nach dem Import Umlaute falsch dargestellt werden, stimmt der Zeichensatz nicht. Häufige Ursache: Der Dump wurde mit einem anderen Charset erstellt als die Zieldatenbank erwartet.

# Export explizit mit UTF-8 erzwingen
mysqldump --default-character-set=utf8mb4 -u user -p datenbankname > dump.sql

# Import mit Zeichensatz-Angabe
mysql --default-character-set=utf8mb4 -u user -p datenbankname < dump.sql

Fehler: max_allowed_packet überschritten

Bei Dumps mit sehr langen INSERT-Statements – etwa wenn du ohne --skip-extended-insert exportiert hast – kann der max_allowed_packet-Wert beim Import überschritten werden.

# Temporär erhöhen beim Import
mysql --max_allowed_packet=512M -u user -p datenbankname < dump.sql

Import bricht ohne Fehlermeldung ab (PHP-Timeout)

Wenn der Import über ein PHP-Skript ohne Fehlermeldung abbricht, ist fast immer der PHP-Timeout der Schuldige. Du kannst versuchen, ihn am Anfang des Skripts zu setzen:

<?php
set_time_limit(0);     // Kein Timeout
ini_set('memory_limit', '512M');

Alternativ hilft es, den Timeout-Wert per .htaccess-Direktive anzuheben: php_value max_execution_time 3600. Ob dein Hoster das erlaubt, hängt vom Tarif ab.

Backup-Strategie: So verlierst du nie wieder Daten

Ein Datenbankdump der bei Bedarf nicht greifbar ist, ist wertlos. Verlässliche Backups brauchen Automatisierung, Redundanz und regelmäßige Tests.

Häufige Fragen zum Datenbankimport & -export