Gibt es eine Möglichkeit, bestimmte Tabellen mit dem Befehl mysqldump einzuschränken?

Zum Beispiel würde ich die folgende Syntax verwenden, um nur Tabelle1 und Tabelle2 zu sichern:

mysqldump -u username -p database table1 table2 > database.sql

Aber gibt es eine ähnliche Möglichkeit, alle Tabellen außer Tabelle1 und Tabelle2 zu sichern? Ich habe in der mysqldump-Dokumentation nichts gefunden. Ist Brute-Force (Angabe aller Tabellennamen) der einzige Weg?

Sie können die Option --ignore-table verwenden . Also könntest du es tun

mysqldump -u USERNAME -pPASSWORD DATABASE --ignore-table=DATABASE.table1 > database.sql

Es gibt kein Leerzeichen danach -p(dies ist kein Tippfehler).

Wenn Sie mehrere Tabellen ignorieren möchten, können Sie ein einfaches Skript wie dieses verwenden

#!/bin/bash
PASSWORD=XXXXXX
HOST=XXXXXX
USER=XXXXXX
DATABASE=databasename
DB_FILE=dump.sql
EXCLUDED_TABLES=(
table1
table2
table3
table4
tableN   
)

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

echo "Dump structure"
mysqldump --host=${HOST} --user=${USER} --password=${PASSWORD} --single-transaction --no-data --routines ${DATABASE} > ${DB_FILE}

echo "Dump content"
mysqldump --host=${HOST} --user=${USER} --password=${PASSWORD} ${DATABASE} --no-create-info --skip-triggers ${IGNORED_TABLES_STRING} >> ${DB_FILE}

Aufbauend auf der Antwort von @ Brian-Fisher und der Beantwortung der Kommentare einiger Leute in diesem Beitrag habe ich eine Reihe großer (und unnötiger) Tabellen in meiner Datenbank, daher wollte ich 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 ausgegebenen Daten sind jetzt ~ 500 MB anstatt 9 GB, viel besser für mich. Ich kann diese beiden Dateien jetzt zu Testzwecken in eine andere Datenbank importieren, ohne mir Gedanken über die Bearbeitung von 9 GB Daten oder den Speicherplatz machen 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 zum Ignorieren mehrerer Tabellen

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

Verwenden --ignore-tableund Erstellen eines Arrays von Tabellen mit Syntax wiedatabase.table

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

Links mit Informationen, die Ihnen helfen werden

Ausgabe komprimieren mysqldump

• mysqldump & gzip
• mysqldump zu einem tar.gz

Hinweis: Getestet auf einem Ubuntu-Server mit MySQL Ver 14.14 Distrib 5.5.55

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

Um einige Tabelle ausschließen Daten , aber nicht die Tabellenstruktur . So mache ich das:

Speichern Sie die Datenbankstruktur aller Tabellen ohne Daten:

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

Speichern Sie dann die Datenbank mit Daten, mit Ausnahme der ausgeschlossenen Tabellen, und sichern Sie die Struktur nicht:

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

So laden Sie es in eine neue Datenbank:

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

Sie können den mysqlpumpBefehl mit dem verwenden

--exclude-tables=name

Befehl. Es gibt eine durch Kommas getrennte Liste von Tabellen an, die ausgeschlossen werden sollen.

Die Syntax von mysqlpump ist mysqldump sehr ähnlich, aber viel leistungsfähiger. Weitere Informationen zur Verwendung der Ausschlussoption finden Sie hier: https://dev.mysql.com/doc/refman/5.7/en/mysqlpump.html#mysqlpump-filtering

Speichern Sie alle Datenbanken mit allen Tabellen, überspringen Sie jedoch bestimmte Tabellen

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 ein wenig Hilfe von https://stackoverflow.com/a/17016410/1069083

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

Ich mag die Lösung von Rubo77, ich hatte sie nicht gesehen, bevor ich Pauls modifiziert habe. Dieser wird eine einzelne Datenbank sichern, mit Ausnahme aller Tabellen, die Sie nicht möchten. Es wird dann gzip und löscht alle Dateien, die älter als 8 Tage sind. Ich werde wahrscheinlich 2 Versionen davon verwenden, die einmal am Tag eine vollständige (Minus-Protokoll-Tabelle) erstellen, und eine andere, die nur die wichtigsten Tabellen sichert, die sich stündlich am meisten ändern, mit ein paar Cron-Jobs.

#!/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

Der Vollständigkeit halber ist hier ein Skript, das tatsächlich ein Einzeiler sein kann, um ein Backup von einer Datenbank zu erhalten, wobei alle Ansichten ausgeschlossen (ignoriert) werden. Es wird angenommen, dass der Datenbankname 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_concatund concatfast jeden gewünschten String- oder Shell-Befehl generieren.