example - mysqldump no info
¿Cómo se divide la salida de mysqldump en archivos más pequeños? (16)
Necesito mover tablas enteras de una base de datos MySQL a otra. No tengo acceso completo al segundo, solo acceso phpMyAdmin. Solo puedo cargar archivos sql (comprimidos) de menos de 2 MB. Pero la salida comprimida de un mysqldump de las primeras tablas de la base de datos es más grande que 10MB.
¿Hay alguna manera de dividir la salida de mysqldump en archivos más pequeños? No puedo usar split (1) ya que no puedo catalogar (1) los archivos en el servidor remoto.
¿O hay otra solución que me he perdido?
Editar
La opción --extended-insert = FALSE a mysqldump sugerida por el primer póster produce un archivo .sql que luego puede dividirse en archivos importables, siempre que se llame a split (1) con una opción --lines adecuada. Por prueba y error encontré que bzip2 comprime los archivos .sql por un factor de 20, así que tuve que averiguar cuántas líneas de código sql corresponden aproximadamente a 40 MB.
Última respuesta, pero estaba buscando la misma solución y se encontró con el siguiente código del siguiente sitio web:
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-individual-files
Creé MySQLDumpSplitter.java que, a diferencia de los scripts bash, funciona en Windows. Está disponible aquí https://github.com/Verace/MySQLDumpSplitter .
Echa un vistazo a SQLDumpSplitter 2, acabo de usarlo para dividir un volcado de 40MB con éxito. Puedes obtenerlo en el siguiente enlace:
Espero que esto ayude.
Este script debería hacerlo:
#!/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
Este script bash divide un archivo de volcado de una base de datos en archivos separados para cada tabla y los nombres con csplit y los nombra en consecuencia:
#!/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 TIME_ZONE=@OLD_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 TIME_ZONE=@OLD_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*
basado en https://gist.github.com/jasny/1608062
y https://.com/a/16840625/1069083
Existe este excelente script mysqldumpsplitter que viene con toneladas de opciones para extraer de mysqldump.
Copiaría la receta aquí para elegir su caso de:
1) Extraiga una sola base de datos de mysqldump:
sh mysqldumpsplitter.sh --source filename --extract DB --match_str database-name
El comando anterior creará sql para la base de datos especificada desde el archivo sql "filename" especificado y lo almacenará en formato comprimido en database-name.sql.gz.
2) Extraiga una sola tabla de mysqldump:
sh mysqldumpsplitter.sh --source filename --extract TABLE --match_str table-name
El comando anterior creará sql para la tabla especificada del archivo mysqldump "filename" especificado y lo almacenará en formato comprimido en database-name.sql.gz.
3) Extraiga tablas que coincidan con la expresión regular de mysqldump:
sh mysqldumpsplitter.sh --source filename --extract REGEXP --match_str regular-expression
El comando anterior creará sqls para tablas que coincidan con la expresión regular especificada del archivo mysqldump "filename" especificado y lo almacenará en formato comprimido en nombre-tabla individual.sql.gz.
4) Extraiga todas las bases de datos de mysqldump:
sh mysqldumpsplitter.sh --source filename --extract ALLDBS
El comando anterior extraerá todas las bases de datos del archivo mysqldump "filename" especificado y lo almacenará en formato comprimido en nombre-base de datos individual.sql.gz.
5) Extraiga toda la tabla de mysqldump:
sh mysqldumpsplitter.sh --source filename --extract ALLTABLES
El comando anterior extraerá todas las tablas del archivo mysqldump "filename" especificado y lo almacenará en formato comprimido en nombre-tabla individual.sql.gz.
6) Extraiga la lista de tablas de mysqldump:
sh mysqldumpsplitter.sh --source filename --extract REGEXP --match_str ''(table1|table2|table3)''
El comando anterior extraerá las tablas del archivo mysqldump "filename" especificado y las almacenará en formato comprimido en nombre-tabla individual.sql.gz.
7) Extraiga una base de datos de mysqldump comprimido:
sh mysqldumpsplitter.sh --source filename.sql.gz --extract DB --match_str ''dbname'' --decompression gzip
El comando anterior descomprimirá filename.sql.gz usando gzip, extraerá la base de datos llamada "nombrebd" de "nombredearchivo.sql.gz" y la almacenará como out / nombrebd.sql.gz
8) Extraiga una base de datos de mysqldump comprimido en un formato sin comprimir:
sh mysqldumpsplitter.sh --source filename.sql.gz --extract DB --match_str ''dbname'' --decompression gzip --compression none
El comando anterior descomprimirá filename.sql.gz usando gzip y extraerá la base de datos llamada "dbname" de "filename.sql.gz" y la almacenará como simple sql out / dbname.sql
9) Extraiga todas las tablas de mysqldump en una carpeta diferente:
sh mysqldumpsplitter.sh --source filename --extract ALLTABLES --output_dir /path/to/extracts/
El comando anterior extraerá todas las tablas del archivo mysqldump de "nombre de archivo" especificado y extrae las tablas en formato comprimido en archivos individuales, table-name.sql.gz almacenado en / path / to / extracts /. El script creará la carpeta / ruta / a / extractos / si no existe.
10) Extraiga una o más tablas de una base de datos en un volcado completo:
Considere que tiene un volcado completo con múltiples bases de datos y desea extraer algunas tablas de una base de datos.
Extraiga una única base de datos:
sh mysqldumpsplitter.sh --source filename --extract DB --match_str DBNAME --compression none
Extraiga todas las tablas
sh mysqldumpsplitter.sh --source out/DBNAME.sql --extract REGEXP --match_str "(tbl1|tbl2)"
aunque podemos usar otra opción para hacer esto en un solo comando de la siguiente manera:
sh mysqldumpsplitter.sh --source filename --extract DBTABLE --match_str "DBNAME.(tbl1|tbl2)" --compression none
El comando anterior extraerá tanto tbl1 como tbl2 de la base de datos DBNAME en formato sql en la carpeta "out" en el directorio actual.
Puede extraer una sola tabla de la siguiente manera:
sh mysqldumpsplitter.sh --source filename --extract DBTABLE --match_str "DBNAME.(tbl1)" --compression none
11) Extraiga todas las tablas de una base de datos específica:
mysqldumpsplitter.sh --source filename --extract DBTABLE --match_str "DBNAME.*" --compression none
El comando anterior extraerá todas las tablas de la base de datos DBNAME en formato sql y las almacenará en el directorio "out".
12) Listar el contenido del archivo mysqldump
mysqldumpsplitter.sh --source filename --desc
El comando anterior listará bases de datos y tablas del archivo de volcado.
Posteriormente, puede elegir cargar los archivos: zcat filename.sql.gz | mysql -USUARIO -p -hHOSTOMBRE
Además, una vez que extrae una tabla única que cree que es aún más grande, puede usar el comando de división de Linux con el número de líneas para dividir aún más el volcado.
split -l 10000 filename.sql
Dicho esto, si esa es su necesidad (más a menudo), podría considerar usar mydumper que en realidad crea vertederos individuales que no necesitará dividir.
No necesita acceso ssh a ninguno de sus servidores. Solo un cliente de mysql [volcado] está bien. Con mysql [volcado], puede volcar su base de datos e importarla nuevamente.
En tu PC, puedes hacer algo como:
$ mysqldump -u originaluser -poriginalpassword -h originalhost originaldatabase | mysql -u newuser -pnewpassword -h newhost newdatabase
y tu estas listo. :-)
espero que esto ayude
Primero volcar el esquema (seguramente encaja en 2Mb, ¿no?)
mysqldump -d --all-databases
y restaurarlo.
Después, volque solo los datos en instrucciones de inserción separadas, para que pueda dividir los archivos y restaurarlos sin tener que concatenarlos en el servidor remoto.
mysqldump --all-databases --extended-insert=FALSE --no-create-info=TRUE
Pruebe csplit (1) para cortar el resultado en las tablas individuales en función de expresiones regulares (que coincidan con el límite de la tabla, creo).
Pruebe esto: https://github.com/shenli/mysqldump-hugetable Va a volcar datos en muchos archivos pequeños. Cada archivo contiene registros MAX_RECORDS menos o iguales. Puede establecer este parámetro en env.sh.
Puede dividir el archivo existente por AWK. Es muy rápido y simple
Vamos a dividir el volcado de tabla por ''tablas'':
cat dump.sql | awk ''BEGIN {output = "comments"; }
$data ~ /^CREATE TABLE/ {close(output); output = substr($3,2,length($3)-2); }
{ print $data >> output }'';
O puede dividir volcado por ''base de datos''
cat backup.sql | awk ''BEGIN {output="comments";} $data ~ /Current Database/ {close(output);output=$4;} {print $data>>output}'';
Puede volcar tablas individuales con mysqldump ejecutando la mysqldump database table1 table2 ... tableN
Si ninguna de las tablas es demasiado grande, será suficiente. De lo contrario, tendrá que comenzar a dividir los datos en las tablas más grandes.
Recientemente he creado sqlsplit.com . Pruébalo.
Una aclaración sobre la respuesta de @ Vérace:
Me gusta especialmente el método interactivo; puedes dividir un archivo grande en Eclipse. He intentado con éxito un archivo de 105 GB en Windows:
Simplemente agregue la biblioteca MySQLDumpSplitter a su proyecto: http://dl.bintray.com/verace/MySQLDumpSplitter/jar/
Nota rápida sobre cómo importar:
- 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.
Usted dice que no tiene acceso al segundo servidor. Pero si tiene acceso de shell al primer servidor, donde están las tablas, puede dividir su volcado por tabla:
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
Esto creará un archivo gzip para cada tabla.
Otra forma de dividir la salida de mysqldump en archivos separados es usar la opción --tab.
mysqldump [connecting options] --tab=directory_name dbname
donde directory_name es el nombre de un directorio vacío. Este comando crea un archivo .sql para cada tabla, que contiene la instrucción CREATE TABLE, y un archivo .txt, que contiene los datos, para restaurar utilizando LOAD DATA INFILE. Aunque no estoy seguro si phpMyAdmin puede manejar estos archivos con su restricción particular.
Yo recomendaría la utilidad bigdump, puedes conseguirla aquí. http://www.ozerov.de/bigdump.php esto tambalea la ejecución del volcado, lo más cerca que puede llegar a su límite, ejecutando líneas completas a la vez.