Alle MySQL-Tabellen automatisch in separate Dateien kopieren?

Ich möchte Dumps jeder MySQL-Tabelle in separate Dateien bekommen. Das Handbuch gibt an, dass die Syntax hierfür lautet

mysqldump [options] db_name [tbl_name ...]

Dies zeigt an, dass Sie die Tabellennamen vorher kennen. Ich könnte das Skript einrichten, das jetzt jeden Tabellennamen kennt, aber sagen, ich füge später eine neue Tabelle hinzu und vergesse, das Dump-Skript zu aktualisieren. Dann fehlen mir Dumps für einen oder mehrere Tische.

Gibt es eine Möglichkeit, jede vorhandene Tabelle automatisch in eine separate Datei zu kopieren? Oder muss ich ein Skript-Fu machen? Fragen Sie die Datenbank ab, rufen Sie alle Tabellennamen ab und sichern Sie sie nach Namen.

Welche Skriptsprachen können auf eine MySQL-Datenbank zugreifen, wenn ich die Script-Fu-Route gehe?

Das Befehlszeilenprogramm mysqldump erledigt dies für Sie - obwohl die Dokumente diesbezüglich sehr unklar sind.

Eine Sache zu beachten ist, dass ~ / output / dir von dem Benutzer, der mysqld besitzt, beschreibbar sein muss. Unter Mac OS X:

sudo chown -R _mysqld:_mysqld ~/output/dir
mysqldump --user=dbuser --password --tab=~/output/dir dbname

Nachdem Sie die obigen Schritte ausgeführt haben, verfügen Sie über eine Datei tablename.sql, die das Schema jeder Tabelle enthält (Anweisung create table), und eine Datei tablename.txt, die die Daten enthält.

Wenn Sie nur einen Speicherauszug mit Schema wünschen, fügen Sie das Flag --no-data hinzu:

mysqldump --user=dbuser --password --no-data --tab=~/output/dir dbname

Hier ist ein Skript, das Tabellendaten als SQL-Befehle in separate, komprimierte Dateien speichert. Es erfordert nicht, auf dem MySQL-Server-Host zu sein, das Kennwort im Skript nicht fest zu codieren und ist nur für eine bestimmte Datenbank, nicht für alle Datenbanken auf dem Server:

#!/bin/bash

# dump-tables-mysql.sh
# Descr: Dump MySQL table data into separate SQL files for a specified database.
# Usage: Run without args for usage info.
# Author: @Trutane
# Ref: http://stackoverflow.com/q/3669121/138325
# Notes:
#  * Script will prompt for password for db access.
#  * Output files are compressed and saved in the current working dir, unless DIR is
#    specified on command-line.

[ $# -lt 3 ] && echo "Usage: $(basename $0) <DB_HOST> <DB_USER> <DB_NAME> [<DIR>]" && exit 1

DB_host=$1
DB_user=$2
DB=$3
DIR=$4

[ -n "$DIR" ] || DIR=.
test -d $DIR || mkdir -p $DIR

echo -n "DB password: "
read -s DB_pass
echo
echo "Dumping tables into separate SQL command files for database '$DB' into dir=$DIR"

tbl_count=0

for t in $(mysql -NBA -h $DB_host -u $DB_user -p$DB_pass -D $DB -e 'show tables') 
do 
    echo "DUMPING TABLE: $DB.$t"
    mysqldump -h $DB_host -u $DB_user -p$DB_pass $DB $t | gzip > $DIR/$DB.$t.sql.gz
    tbl_count=$(( tbl_count + 1 ))
done

echo "$tbl_count tables dumped from database '$DB' into dir=$DIR"

Sie können dies erreichen, indem Sie:

1. Holen Sie sich die Liste der Datenbanken in MySQL
2. Dump jede Datenbank mit mysqldump

# Optional variables for a backup script
MYSQL_USER="root"
MYSQL_PASS="something"
BACKUP_DIR=/srv/backup/$(date +%Y-%m-%dT%H_%M_%S);
test -d "$BACKUP_DIR" || mkdir -p "$BACKUP_DIR"
# Get the database list, exclude information_schema
for db in $(mysql -B -s -u $MYSQL_USER --password=$MYSQL_PASS -e 'show databases' | grep -v information_schema)
do
  # dump each database in a separate file
  mysqldump -u $MYSQL_USER --password=$MYSQL_PASS "$db" | gzip > "$BACKUP_DIR/$db.sql.gz"
done

Hier ist der entsprechende Import.

#!/bin/bash

# import-files-mysql.sh
# Descr: Import separate SQL files for a specified database.
# Usage: Run without args for usage info.
# Author: Will Rubel
# Notes:
#  * Script will prompt for password for db access.

[ $# -lt 3 ] && echo "Usage: $(basename $0) <DB_HOST> <DB_USER> <DB_NAME> [<DIR>]" && exit 1

DB_host=$1
DB_user=$2
DB=$3
DIR=$4

DIR=$DIR/*


echo -n "DB password: "
read -s DB_pass
echo
echo "Importing separate SQL command files for database '$DB' into '$DB'"

file_count=0


for f in $DIR

do 
    echo "IMPORTING FILE: $f"

    gunzip -c $f | mysql -h $DB_host -u $DB_user -p$DB_pass $DB

    (( file_count++ ))
done

echo "$file_count files importing to database '$DB'"

#!/bin/bash

for i in $(mysql -uUser -pPASSWORD DATABASE -e "show tables;"|grep -v Tables_in_);do mysqldump -uUSER -pPASSWORD DATABASE $i > /backup/dir/$i".sql";done

tar -cjf "backup_mysql_"$(date +'%Y%m%d')".tar.bz2" /backup/dir/*.sql

Es sieht so aus, als hätten alle hier vergessen, autocommit=0;SET unique_checks=0;SET foreign_key_checks=0;dass dies den Importprozess beschleunigen soll ...

#!/bin/bash
MYSQL_USER="USER"
MYSQL_PASS="PASS"

if [ -z "$1" ]
  then
    echo "Dumping all DB ... in separate files"
    for I in $(mysql -u $MYSQL_USER --password=$MYSQL_PASS -e 'show databases' -s --skip-column-names); 
    do 
      echo "SET autocommit=0;SET unique_checks=0;SET foreign_key_checks=0;" > "$I.sql"
      mysqldump -u $MYSQL_USER --password=$MYSQL_PASS $I >> "$I.sql"; 
      echo "SET autocommit=1;SET unique_checks=1;SET foreign_key_checks=1;commit;" >> "$I.sql"
      gzip "$I.sql"
    done
    echo "END."
else
      echo "Dumping $1 ..."
      echo "SET autocommit=0;SET unique_checks=0;SET foreign_key_checks=0;" > "$1.sql"
      mysqldump -u $MYSQL_USER --password=$MYSQL_PASS $1 >> "$1.sql"; 
      echo "SET autocommit=1;SET unique_checks=1;SET foreign_key_checks=1;commit;" >> "$1.sql"
      gzip "$1.sql"
fi

Wenn Sie alle Tabellen aus allen Datenbanken sichern möchten, kombinieren Sie einfach die Antwort von Elias Torres Arroyo und Trutane: Wenn Sie Ihr Passwort nicht auf dem Terminal angeben möchten, speichern Sie Ihr Passwort einfach in einer zusätzlichen Konfigurationsdatei (chmod 0600) - siehe Start von Mysqldump durch Cron- und Passwortsicherheit

#!/bin/bash

# this file
# a) gets all databases from mysql
# b) gets all tables from all databases in a)
# c) creates subfolders for every database in a)
# d) dumps every table from b) in a single file

    # this is a mixture of scripts from Trutane (http://stackoverflow.com/q/3669121/138325) 
    # and Elias Torres Arroyo (https://stackoverflow.com/a/14711298/8398149)

# usage: 
# sk-db.bash parameters
# where pararmeters are:

# d "dbs to leave"
# t " tables to leave"
# u "user who connects to database"
# h "db host"
# f "/backup/folder"



user='root'
host='localhost'
backup_folder=''
leave_dbs=(information_schema mysql)
leave_tables=()
while getopts ":d:t:u:h:f:" opt; do
  case $opt in
    d) leave_dbs=( $OPTARG )
    ;;
    t) leave_tables=( $OPTARG )
    ;;
    u) user=$OPTARG
    ;;
    h) host=$OPTARG
    ;;
    f) backup_folder=$OPTARG
    ;;

    \?) echo "Invalid option -$OPTARG" >&2
    ;;
  esac
done
echo '****************************************'
echo "Database Backup with these options"
echo "Host $host"
echo "User $user"
echo "Backup in $backup_folder"
echo '----------------------------------------'
echo "Databases to emit:"
printf "%s\n" "${leave_dbs[@]}"
echo '----------------------------------------'
echo "Tables to emit:"
printf "%s\n" "${leave_tables[@]}"
echo '----------------------------------------'


BACKUP_DIR=$backup_folder/$(date +%Y-%m-%dT%H_%M_%S);
CONFIG_FILE=/root/db-config.cnf

function contains() {
    local n=$#
    local value=${!n}
    for ((i=1;i < $#;i++)) {
        if [ "${!i}" == "${value}" ]; then
            echo "y"
            return 0
        fi
    }
    echo "n"
    return 1
}


test -d "$BACKUP_DIR" || mkdir -p "$BACKUP_DIR"
# Get the database list, exclude information_schema
database_count=0
tbl_count=0

for db in $(mysql --defaults-extra-file=$CONFIG_FILE -B -s -u $user -e 'show databases' )
do
    if [ $(contains "${leave_dbs[@]}" "$db") == "y" ]; then
        echo "leave database $db as requested"
    else

       # dump each database in a separate file
       (( database_count++ ))
       DIR=$BACKUP_DIR/$db
       [ -n "$DIR" ] || DIR=.

       test -d $DIR || mkdir -p $DIR

       echo
       echo "Dumping tables into separate SQL command files for database '$db' into dir=$DIR"

       for t in $(mysql --defaults-extra-file=$CONFIG_FILE -NBA -h $host -u $user -D $db -e 'show tables')
       do
           if [ $(contains "${leave_tables[@]}" "$db.$t") == "y" ]; then
               echo "leave table $db.$t as requested"
           else
               echo "DUMPING TABLE: $db.$t"
  #            mysqldump --defaults-extra-file=$CONFIG_FILE -h $host -u $user $db $t  > $DIR/$db.$t.sql
               tbl_count=$(( tbl_count + 1 ))
           fi
       done

       echo "Database $db is finished"
       echo '----------------------------------------'

    fi
done
echo '----------------------------------------'
echo "Backup completed"
echo '**********************************************'

Und das hat auch geholfen:

Überprüfen Sie, ob das Bash-Array einen Wert enthält

Arrays in Bash

benannte Argumente im Skript

Ich bin kein Bash-Meister, aber ich würde es einfach mit einem Bash-Skript machen. Ohne MySQL zu treffen, können Sie mit Kenntnis des Datenverzeichnisses und des Datenbanknamens einfach nach allen .frm-Dateien (eine für jede Tabelle in dieser Datenbank / diesem Verzeichnis) nach einer Liste von Tabellen suchen.

Ich bin mir sicher, dass es Möglichkeiten gibt, es schlanker zu machen und Argumente oder so weiter zu akzeptieren, aber das hat bei mir gut funktioniert.

tables_in_a_db_to_sql.sh

#!/bin/bash

database="this_is_my_database"
datadir="/var/lib/mysql/"
datadir_escaped="\/var\/lib\/mysql\/"

all_tables=($(ls $datadir$database/*.frm | sed s/"$datadir_escaped$database\/"/""/g | sed s/.frm//g))

for t in "${all_tables[@]}"; do
        outfile=$database.$t.sql
        echo "-- backing up $t to $outfile"
        echo "mysqldump [options] $database $t > $outfile"
        # mysqldump [options] $database $t > $outfile
done

Füllen Sie die [Optionen] und die gewünschte Outfile-Konvention nach Bedarf aus und kommentieren Sie die letzte mysqldump-Zeile aus.

Für Windows-Server können Sie eine Batchdatei wie folgt verwenden:

set year=%DATE:~10,4%
set day=%DATE:~7,2%
set mnt=%DATE:~4,2%
set hr=%TIME:~0,2%
set min=%TIME:~3,2%

IF %day% LSS 10 SET day=0%day:~1,1%
IF %mnt% LSS 10 SET mnt=0%mnt:~1,1%
IF %hr% LSS 10 SET hr=0%hr:~1,1%
IF %min% LSS 10 SET min=0%min:~1,1%

set backuptime=%year%-%mnt%-%day%-%hr%-%min%
set backupfldr=C:\inetpub\wwwroot\backupfiles\
set datafldr="C:\Program Files\MySQL\MySQL Server 5.5\data"
set zipper="C:\inetpub\wwwroot\backupfiles\zip\7za.exe"
set retaindays=21

:: Switch to the data directory to enumerate the folders
pushd %datafldr%

:: Get all table names and save them in a temp file
mysql --skip-column-names --user=root --password=mypassword mydatabasename -e "show tables" > tables.txt

:: Loop through all tables in temp file so that we can save one backup file per table
for /f "skip=3 delims=|" %%i in (tables.txt) do (
  set tablename = %%i
  mysqldump --user=root --password=mypassword mydatabasename %%i > "%backupfldr%mydatabasename.%backuptime%.%%i.sql"
)
del tables.txt

:: Zip all files ending in .sql in the folder
%zipper% a -tzip "%backupfldr%backup.mydatabasename.%backuptime%.zip" "%backupfldr%*.sql"

echo "Deleting all the files ending in .sql only"
del "%backupfldr%*.sql"

echo "Deleting zip files older than 21 days now"
Forfiles /p %backupfldr% /m *.zip /d -%retaindays% /c "cmd /c del /q @path"

Planen Sie es dann mit dem Windows Task Scheduler.

Wenn Sie bestimmte Tabellen in Ihrer Sicherung ausschließen möchten, beachten Sie, dass Sie in der Anweisung "show tables" eine where-Klausel verwenden können, der Spaltenname jedoch von Ihrem Datenbanknamen abhängt.

Wenn Ihr Datenbankname beispielsweise "blah" lautet, lautet Ihr Spaltenname in der Ergebnismenge " show tables " "tables_in_blah". Das heißt, Sie könnten eine where-Klausel hinzufügen, die dieser ähnelt:

show tables where tables_in_blah <> 'badtable'

oder

show tables where tables_in_blah like '%goodtable%'

Siehe folgenden Artikel von Pauli Marcus:

So teilen Sie einen SQL-Datenbankspeicherauszug in tabellenweise Dateien auf

Das Aufteilen einer SQL-Datei, die eine gesamte Datenbank enthält, in Tabellen-Dateien ist ganz einfach: Überprüfen Sie die SQL-Datei auf das Auftreten von DROP TABLE. Generieren Sie den Dateinamen aus dem Tabellennamen, der in der Anweisung DROP TABLE enthalten ist. Echo die Ausgabe in eine Datei. Hier ist ein kleines Skript, das eine SQL-Datei als Eingabe erwartet:

#!/bin/bash

file=$1 # the input file
directory="$file-splitted" # the output directory
output="$directory/header" # the first file containing the header
GREP="DROP TABLE" # what we are looking for

mkdir $directory # create the output directory

while read line
do
   # if the current line contains the wanted statement
   if [ $(echo "$line" | grep -c "$GREP") == "1" ]
   then
      # extract the file name
      myfile=$(echo $line | awk '{print $5}' | sed -e 's/`//g' -e 's/;//g')
      # set the new file name
      output="$directory/$myfile"
   fi
       echo "$line" >> $output # write to file
done < $file