Überspringen Sie bestimmte Tabellen mit mysqldump

Aufbauend auf der Antwort von @ Brian-Fisher und dem Beantworten der Kommentare einiger Leute in diesem Beitrag, habe ich eine Reihe riesiger (und unnötiger) Tabellen in meiner Datenbank. Ich wollte deren Inhalt beim Kopieren überspringen, aber die Struktur beibehalten :

mysqldump -h <Host> -u <username> -p <schema> --no-data > db-structure.sql
mysqldump -h <Host> -u <username> -p <schema> --no-create-info --ignore-table=schema.table1 --ignore-table=schema.table2 > db-data.sql

Die resultierenden zwei Dateien sind strukturell einwandfrei, aber die ausgelagerten Daten sind jetzt ~ 500 MB statt 9 GB, viel besser für mich. Ich kann diese beiden Dateien jetzt zu Testzwecken in eine andere Datenbank importieren, ohne sich um die Manipulation von 9 GB an Daten oder den Speicherplatz auf der Festplatte sorgen zu müssen.

für mehrere Datenbanken:

mysqldump -u user -p --ignore-table=db1.tbl1 --ignore-table=db2.tbl1 --databases db1 db2 ..

Ein weiteres Beispiel für das Ignorieren mehrerer Tabellen

/usr/bin/mysqldump -uUSER -pPASS --ignore-table={db_test.test1,db_test.test3} db_test> db_test.sql

verwenden Sie --ignore-table und erstellen Sie ein Array von Tabellen mit Syntax wie database.table

--ignore-table={db_test.table1,db_test.table3,db_test.table4}

Links mit Informationen, die Ihnen helfen werden

compress Ausgabe mysqldump

• mysqldump & gzip
• mysqldump zu einem tar.gz

Hinweis: In Ubuntu-Server mit MySQL Ver 14.14 Distrib 5.5.55 getestet

Datenbank importieren

 mysql -uUSER  -pPASS db_test < db_test.sql

Einfaches Skript zum Ignorieren von Tabellen

#!/bin/bash

#tables to ignore
_TIGNORE=(
my_database.table1
my_database.table2
my_database.tablex
)

#create text for ignore tables
_TDELIMITED="$(IFS=" "; echo "${_TIGNORE[*]/#/--ignore-table=}")"

#don't forget to include user and password
/usr/bin/mysqldump -uUSER -pPASSWORD --events ${_TDELIMITED} --databases my_database | gzip -v > backup_database.sql.gz

Einige Tabellen Daten ausschließen, nicht jedoch die Tabelle Struktur . So mache ich es:

Sichern Sie die Datenbankstruktur aller Tabellen ohne Daten:

mysqldump -u user -p --no-data database > database_structure.sql

Dann sichern Sie die Datenbank mit den Daten außer den ausgeschlossenen Tabellen, und geben Sie die Struktur nicht ab

mysqldump -u user -p --no-create-info \
    --ignore-table=database.table1 \
    --ignore-table=database.table2 database > database_data.sql

Dann, um es in eine neue Datenbank zu laden:

mysql -u user -p newdatabase < database_structure.sql
mysql -u user -p newdatabase < database_data.sql

Alle Datenbanken mit allen Tabellen ausgeben, aber bestimmte Tabellen überspringen

auf github: https://github.com/rubo77/mysql-backup.sh/blob/master/mysql-backup.sh

#!/bin/bash
# mysql-backup.sh

if [ -z "$1" ] ; then
  echo
  echo "ERROR: root password Parameter missing."
  exit
fi
DB_Host=localhost
MYSQL_USER=root
MYSQL_PASS=$1
MYSQL_CONN="-u${MYSQL_USER} -p${MYSQL_PASS}"
#MYSQL_CONN=""

BACKUP_DIR=/backup/mysql/

mkdir $BACKUP_DIR -p

MYSQLPATH=/var/lib/mysql/

IGNORE="database1.table1, database1.table2, database2.table1,"

# strpos $1 $2 [$3]
# strpos haystack needle [optional offset of an input string]
strpos()
{
    local str=${1}
    local offset=${3}
    if [ -n "${offset}" ]; then
        str=`substr "${str}" ${offset}`
    else
        offset=0
    fi
    str=${str/${2}*/}
    if [ "${#str}" -eq "${#1}" ]; then
        return 0
    fi
    echo $((${#str}+${offset}))
}

cd $MYSQLPATH
for i in */; do
    if [ $i != 'performance_schema/' ] ; then 
    DB=`basename "$i"` 
    #echo "backup $DB->$BACKUP_DIR$DB.sql.lzo"
    mysqlcheck "$DB" $MYSQL_CONN --silent --auto-repair >/tmp/tmp_grep_mysql-backup
    grep -E -B1 "note|warning|support|auto_increment|required|locks" /tmp/tmp_grep_mysql-backup>/tmp/tmp_grep_mysql-backup_not
    grep -v "$(cat /tmp/tmp_grep_mysql-backup_not)" /tmp/tmp_grep_mysql-backup

    tbl_count=0
    for t in $(mysql -NBA -h $DB_Host $MYSQL_CONN -D $DB -e 'show tables') 
    do
      found=$(strpos "$IGNORE" "$DB"."$t,")
      if [ "$found" == "" ] ; then 
        echo "DUMPING TABLE: $DB.$t"
        mysqldump -h $DB_Host $MYSQL_CONN $DB $t --events --skip-lock-tables | lzop -3 -f -o $BACKUP_DIR/$DB.$t.sql.lzo
        tbl_count=$(( tbl_count + 1 ))
      fi
    done
    echo "$tbl_count tables dumped from database '$DB' into dir=$BACKUP_DIR"
    fi
done

Mit etwas Hilfe von https://stackoverflow.com/a/17016410/1069083

Es verwendet lzop, was viel schneller ist, siehe: http://pokecraft.first-world.info/wiki/Quick_Benchmark:_Gzip_vs_Bzip2_vs_LZMA_vs_XZ_vs_LZ4_vs_LZO

Der Vollständigkeit halber ist hier ein Skript, das eigentlich ein Einzeiler sein könnte, um eine Sicherung von einer Datenbank zu erhalten, wobei alle Ansichten ausgeschlossen (ignoriert) werden. Es wird angenommen, dass der Name der Datenbank Mitarbeiter ist:

ignore=$(mysql --login-path=root1 INFORMATION_SCHEMA \
    --skip-column-names --batch \
    -e "select 
          group_concat(
            concat('--ignore-table=', table_schema, '.', table_name) SEPARATOR ' '
          ) 
        from tables 
        where table_type = 'VIEW' and table_schema = 'employees'")

mysqldump --login-path=root1 --column-statistics=0 --no-data employees $ignore > "./backups/som_file.sql"   

Sie können die Logik der Abfrage aktualisieren. Im Allgemeinen können Sie mit group_concat und concat fast jeden gewünschten String oder Shell-Befehl generieren.

Sie können den Befehl mysqlpump mit dem Befehl verwenden 

--exclude-tables=name

befehl. Es gibt eine durch Kommas getrennte Liste der auszuschließenden Tabellen an.

Die Syntax von mysqlpump ist der von mysqlump sehr ähnlich, aber sie ist leistungsfähiger ..__ Weitere Informationen zur Verwendung der Ausschlussoption finden Sie hier: https://dev.mysql.com/doc/refman/5.7/ de/mysqlpump.html # mysqlpump-filterung

Ich mag die Lösung von Rubo77, ich hatte sie nicht gesehen, bevor ich Pauls modifiziert habe. Diese Datenbank sichert eine einzige Datenbank und schließt dabei nicht benötigte Tabellen aus. Es wird dann gzip und löscht alle Dateien, die älter als 8 Tage sind. Ich werde wahrscheinlich 2 Versionen davon verwenden, die einmal pro Tag eine vollständige Tabelle (minus Protokolltabelle) ausführen, und eine andere, die nur die wichtigsten Tabellen sichert, die sich stündlich mit ein paar Cron-Jobs ändern.

#!/bin/sh
PASSWORD=XXXX
Host=127.0.0.1
USER=root
DATABASE=MyFavoriteDB

now="$(date +'%d_%m_%Y_%H_%M')"
filename="${DATABASE}_db_backup_$now"
backupfolder="/opt/backups/mysql"
DB_FILE="$backupfolder/$filename"
logfile="$backupfolder/"backup_log_"$(date +'%Y_%m')".txt

EXCLUDED_TABLES=(
logs
)
IGNORED_TABLES_STRING=''
for TABLE in "${EXCLUDED_TABLES[@]}"
do :
   IGNORED_TABLES_STRING+=" --ignore-table=${DATABASE}.${TABLE}"
done

echo "Dump structure started at $(date +'%d-%m-%Y %H:%M:%S')" >> "$logfile"
mysqldump --Host=${Host} --user=${USER} --password=${PASSWORD} --single-transaction --no-data --routines ${DATABASE}  > ${DB_FILE} 
echo "Dump structure finished at $(date +'%d-%m-%Y %H:%M:%S')" >> "$logfile"
echo "Dump content"
mysqldump --Host=${Host} --user=${USER} --password=${PASSWORD} ${DATABASE} --no-create-info --skip-triggers ${IGNORED_TABLES_STRING} >> ${DB_FILE}
gzip ${DB_FILE}

find "$backupfolder" -name ${DATABASE}_db_backup_* -mtime +8 -exec rm {} \;
echo "old files deleted" >> "$logfile"
echo "operation finished at $(date +'%d-%m-%Y %H:%M:%S')" >> "$logfile"
echo "*****************" >> "$logfile"
exit 0