Wie teile ich die Ausgabe von mysqldump in kleinere Dateien auf?

Dieses Bash-Skript teilt eine Datenbankdatei einer Datenbank in separate Dateien für jede Tabelle und Namen mit csplit auf und benennt sie entsprechend:

#!/bin/bash

####
# Split MySQL dump SQL file into one file per table
# based on https://Gist.github.com/jasny/1608062
####

#adjust this to your case:
START="/-- Table structure for table/"
# or 
#START="/DROP TABLE IF EXISTS/"


if [ $# -lt 1 ] || [[ $1 == "--help" ]] || [[ $1 == "-h" ]] ; then
        echo "USAGE: extract all tables:"
        echo " $0 DUMP_FILE"
        echo "extract one table:"
        echo " $0 DUMP_FILE [TABLE]"
        exit
fi

if [ $# -ge 2 ] ; then
        #extract one table $2
        csplit -s -ftable $1 "/-- Table structure for table/" "%-- Table structure for table \`$2\`%" "/-- Table structure for table/" "%40103 SET [email protected]_TIME_ZONE%1"
else
        #extract all tables
        csplit -s -ftable $1 "$START" {*}
fi

[ $? -eq 0 ] || exit

mv table00 head

FILE=`ls -1 table* | tail -n 1`
if [ $# -ge 2 ] ; then
        mv $FILE foot
else
        csplit -b '%d' -s -f$FILE $FILE "/40103 SET [email protected]_TIME_ZONE/" {*}
        mv ${FILE}1 foot
fi

for FILE in `ls -1 table*`; do
        NAME=`head -n1 $FILE | cut -d$'\x60' -f2`
        cat head $FILE foot > "$NAME.sql"
done

rm head foot table*

basierend auf https://Gist.github.com/jasny/1608062
und https://stackoverflow.com/a/16840625/1069083

Sie sagen, dass Sie keinen Zugriff auf den zweiten Server haben. Wenn Sie jedoch Shell-Zugriff auf den ersten Server haben, auf dem sich die Tabellen befinden, können Sie den Speicherauszug nach Tabelle aufteilen:

for T in `mysql -N -B -e 'show tables from dbname'`; \
   do echo $T; \
   mysqldump [connecting_options] dbname $T \
   | gzip -c > dbname_$T.dump.gz ; \
   done

Dadurch wird für jede Tabelle eine GZIP-Datei erstellt.

Eine andere Möglichkeit, die Ausgabe von mysqldump in separate Dateien aufzuteilen, ist die Option --tab.

mysqldump [connecting options] --tab=directory_name dbname 

woher verzeichnisname ist der Name eines leeren Verzeichnisses. Dieser Befehl erstellt für jede Tabelle eine SQL-Datei mit der Anweisung CREATE TABLE und eine TXT-Datei mit den Daten, die mit LOAD DATA INFILE wiederhergestellt werden sollen. Ich bin nicht sicher, ob phpMyAdmin diese Dateien mit Ihrer speziellen Einschränkung verarbeiten kann.

Späte Antwort suchte jedoch nach der gleichen Lösung und stieß auf folgenden Code von der folgenden Website:

for I in $(mysql -e 'show databases' -s --skip-column-names); do mysqldump $I | gzip > "$I.sql.gz"; done

http://www.commandlinefu.com/commands/view/2916/backup-all-mysql-databases-to-individualfiles

Ich habe kürzlich sqlsplit.com erstellt. Versuch es.

Es gibt dieses ausgezeichnete mysqldumpsplitter -skript, das eine Unmenge an Optionen für das Extrahieren von mysqldump enthält.

Ich würde das Rezept hier kopieren, um Ihren Fall auszuwählen:

1) Einzelne Datenbank aus mysqldump extrahieren:

sh mysqldumpsplitter.sh --source filename --extract DB --match_str database-name

Der obige Befehl erstellt sql für die angegebene Datenbank aus der angegebenen "Dateiname" SQL-Datei und speichern Sie es in komprimiertem Format in Datenbankname.sql.gz.

2) Einzelne Tabelle aus mysqldump extrahieren:

sh mysqldumpsplitter.sh --source filename --extract TABLE --match_str table-name

Der obige Befehl erstellt SQL aus der angegebenen .__ für die angegebene Tabelle. "Dateiname" mysqldump-Datei und speichern Sie sie im komprimierten Format unter Datenbankname.sql.gz.

3) Extrahieren Sie Tabellen, die mit regulären Ausdrücken übereinstimmen, aus mysqldump:

sh mysqldumpsplitter.sh --source filename --extract REGEXP --match_str regular-expression

Der obige Befehl erstellt sqls für Tabellen, die mit dem angegebenen regulären .__ übereinstimmen. Ausdruck aus der angegebenen "Dateiname" mysqldump-Datei und speichern Sie sie in komprimiertes Format in einzelne Tabellenname.sql.gz.

4) Extrahieren Sie alle Datenbanken aus mysqldump:

sh mysqldumpsplitter.sh --source filename --extract ALLDBS

Der obige Befehl extrahiert alle Datenbanken aus dem angegebenen "Dateinamen" mysqldump-Datei und speichern Sie sie im komprimierten Format in einzelne Datenbankname.sql.gz.

5) Extrahieren Sie alle Tabelle aus mysqldump:

sh mysqldumpsplitter.sh --source filename --extract ALLTABLES

Der obige Befehl extrahiert alle Tabellen aus dem angegebenen "Dateinamen" mysqldump-Datei und speichern Sie sie im komprimierten Format in einzelne Tabellenname.sql.gz.

6) Liste der Tabellen aus mysqldump extrahieren:

sh mysqldumpsplitter.sh --source filename --extract REGEXP --match_str '(table1|table2|table3)'

Der obige Befehl extrahiert Tabellen aus dem angegebenen "Dateinamen" mysqldump-Datei und speichert sie in komprimiertem Format in einzelne Tabellenname.sql.gz.

7) Extrahieren Sie eine Datenbank aus komprimiertem mysqldump:

sh mysqldumpsplitter.sh --source filename.sql.gz --extract DB --match_str 'dbname' --decompression gzip

Der obige Befehl dekomprimiert filename.sql.gz mit gzip und extrahiert Datenbank mit dem Namen "dbname" aus "filename.sql.gz" und als .__ speichern. out/dbname.sql.gz

8) Extrahieren Sie eine Datenbank aus komprimiertem mysqldump in einem unkomprimierten Format:

sh mysqldumpsplitter.sh --source filename.sql.gz --extract DB --match_str 'dbname' --decompression gzip --compression none

Der obige Befehl dekomprimiert dateiname.sql.gz mit gzip und extrahiert Datenbank mit dem Namen "dbname" aus "filename.sql.gz" und als einfache SQL-Datei speichern out/dbname.sql

9) Extrahieren Sie alle Tabellen aus mysqldump in einen anderen Ordner:

sh mysqldumpsplitter.sh --source filename --extract ALLTABLES --output_dir /path/to/extracts/

Der obige Befehl extrahiert alle Tabellen aus dem angegebenen "Dateinamen" mysqldump-Datei und extrahiert Tabellen im komprimierten Format in einzelne Dateien, Tabellenname.sql.gz gespeichert unter/path/to/extract /. Das Skript erstellt den Ordner/Pfad/to/extract /, falls nicht vorhanden.

10) Extrahieren Sie eine oder mehrere Tabellen aus einer Datenbank in einem vollständigen Speicherauszug:

Stellen Sie sich vor, Sie haben einen vollständigen Speicherauszug mit mehreren Datenbanken und möchten extrahieren Sie einige Tabellen aus einer Datenbank.

Einzelne Datenbank extrahieren: sh mysqldumpsplitter.sh --source filename --extract DB --match_str DBNAME --compression none

Extrahieren Sie alle Tabellen sh mysqldumpsplitter.sh --source out/DBNAME.sql --extract REGEXP --match_str "(tbl1|tbl2)", obwohl wir eine andere Option verwenden können, um dies in einem einzelnen Befehl wie folgt auszuführen:

sh mysqldumpsplitter.sh --source filename --extract DBTABLE --match_str "DBNAME.(tbl1|tbl2)" --compression none

Der obige Befehl extrahiert sowohl tbl1 als auch tbl2 aus der DBNAME-Datenbank in SQL-Format unter Ordner "out" im aktuellen Verzeichnis.

Sie können eine einzelne Tabelle wie folgt extrahieren:

sh mysqldumpsplitter.sh --source filename --extract DBTABLE --match_str "DBNAME.(tbl1)" --compression none

11) Extrahieren Sie alle Tabellen aus einer bestimmten Datenbank:

mysqldumpsplitter.sh --source filename --extract DBTABLE --match_str "DBNAME.*" --compression none

Der obige Befehl extrahiert alle Tabellen aus der DBNAME-Datenbank in sql formatieren und unter "out" speichern.

12) Listen Sie den Inhalt der mysqldump-Datei auf

mysqldumpsplitter.sh --source filename --desc

Der obige Befehl listet Datenbanken und Tabellen aus der Dump-Datei auf.

Sie können später wählen, die Dateien zu laden: zcat Dateiname.sql.gz | mysql -uUSER -p -hHOSTNAME

• Sobald Sie eine einzelne Tabelle extrahiert haben, von der Sie glauben, dass sie noch größer ist, können Sie den Linux-Split-Befehl mit der Anzahl der Zeilen verwenden, um den Speicherauszug weiter zu teilen .split -l 10000 filename.sql

• Das heißt, wenn dies Ihr Bedürfnis ist (häufiger), könnten Sie mydumper in Betracht ziehen, das tatsächlich einzelne Dumps erstellt, die Sie nicht teilen müssen!

Sie benötigen keinen SSH-Zugriff auf einen Ihrer Server. Nur ein mysql [dump] -Klient ist in Ordnung ..__ Mit dem mysql [dump] können Sie Ihre Datenbank sichern und erneut importieren.

In Ihrem PC können Sie Folgendes tun:

$ mysqldump -u originaluser -poriginalpassword -h originalhost originaldatabase | mysql -u neuer Benutzer -pnewpassword -h newhost newdatabase

und du bist fertig. :-)

hoffe das hilft

Sie können einzelne Tabellen mit mysqldump ausgeben, indem Sie mysqldump database table1 table2 ... tableN ausführen.

Wenn keine der Tabellen zu groß ist, reicht das aus. Andernfalls müssen Sie die Daten in den größeren Tabellen aufteilen.

Eine Klarstellung zur Antwort von @ Vérace:

Ich mag besonders die interaktive Methode; Sie können eine große Datei in Eclipse aufteilen. Ich habe eine 105GB-Datei in Windows erfolgreich getestet:

Fügen Sie einfach die MySQLDumpSplitter-Bibliothek zu Ihrem Projekt hinzu: http://dl.bintray.com/verace/MySQLDumpSplitter/jar/

Kurzer Hinweis zum Importieren:

- In Eclipse, Right click on your project --> Import
- Select "File System" and then "Next"
- Browse the path of the jar file and press "Ok"
- Select (thick) the "MySQLDumpSplitter.jar" file and then "Finish"
- It will be added to your project and shown in the project folder in Package Explorer in Eclipse
- Double click on the jar file in Eclipse (in Package Explorer)
- The "MySQL Dump file splitter" window opens which you can specify the address of your dump file and proceed with split.

ich würde das Dienstprogramm Bigdump empfehlen, Sie können es hier holen. http://www.ozerov.de/bigdump.php Dies versetzt die Ausführung des Speicherauszugs so nahe wie möglich an Ihr Limit und führt jeweils ganze Zeilen aus.

Schauen Sie sich SQLDumpSplitter 2 an. Ich habe es gerade verwendet, um einen 40-MB-Dump mit Erfolg zu teilen. Sie können es unter dem folgenden Link erhalten: 

sqldumpsplitter.com

Ich hoffe das hilft. 

Dieses Skript sollte es tun:

#!/bin/sh

#edit these
USER=""
PASSWORD=""
MYSQLDIR="/path/to/backupdir"

MYSQLDUMP="/usr/bin/mysqldump"
MYSQL="/usr/bin/mysql"

echo - Dumping tables for each DB
databases=`$MYSQL --user=$USER --password=$PASSWORD -e "SHOW DATABASES;" | grep -Ev "(Database|information_schema)"`
for db in $databases; do
    echo - Creating "$db" DB
    mkdir $MYSQLDIR/$db
    chmod -R 777 $MYSQLDIR/$db
    for tb in `$MYSQL  --user=$USER --password=$PASSWORD -N -B -e "use $db ;show tables"`
        do 
            echo -- Creating table $tb
            $MYSQLDUMP --opt  --delayed-insert --insert-ignore --user=$USER --password=$PASSWORD $db $tb | bzip2 -c > $MYSQLDIR/$db/$tb.sql.bz2
    done
    echo
done

Sie können vorhandene Dateien nach AWK aufteilen. Es ist sehr schnell und einfach

Lassen Sie uns den Tabellenauszug nach 'tables' aufteilen:

cat dump.sql | awk 'BEGIN {output = "comments"; }
$data ~ /^CREATE TABLE/ {close(output); output = substr($3,2,length($3)-2); }
{ print $data >> output }';

Oder Sie können Dump nach 'Datenbank' aufteilen

cat backup.sql | awk 'BEGIN {output="comments";} $data ~ /Current Database/ {close(output);output=$4;} {print $data>>output}';

Versuchen Sie Folgendes: https://github.com/shenli/mysqldump-hugetable .__ Es werden Daten in viele kleine Dateien gespeichert. Jede Datei enthält weniger oder gleich viele MAX_RECORDS-Datensätze. Sie können diesen Parameter in env.sh einstellen.

Ich habe eine neue Version von SQLDumpSplitter geschrieben, diesmal mit einem richtigen Parser, der es erlaubt, schöne Dinge wie INSERTs mit vielen Werten auf Dateien aufzuteilen, und es ist jetzt mehrere Plattformen: https://philiplb.de/sqldumpsplitter3/

Versuchen Sie csplit (1), um die Ausgabe basierend auf regulären Ausdrücken in die einzelnen Tabellen zu unterteilen (entspricht der Tabellengrenze, denke ich).

Ich habe MySQLDumpSplitter.Java erstellt, das im Gegensatz zu Bash-Skripts unter Windows funktioniert. Es ist hier verfügbar. https://github.com/Verace/MySQLDumpSplitter .