C'è un modo per limitare alcune tabelle dal comando mysqldump?

Ad esempio, utilizzerei la sintassi seguente per scaricare solo table1 e table2:

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

Ma esiste un modo simile per scaricare tutte le tabelle tranne table1 e table2? Non ho trovato nulla nella documentazione di mysqldump, quindi la forza bruta (specificando tutti i nomi delle tabelle) è l'unica strada da percorrere?

Puoi usare l' opzione --ignore-table . Quindi potresti farlo

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

Non c'è spazio dopo -p(non si tratta di un errore di battitura).

Se si desidera ignorare più tabelle, è possibile utilizzare uno script semplice come questo

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

Basandomi sulla risposta di @ Brian-Fisher e rispondendo ai commenti di alcune persone su questo post, ho un sacco di enormi (e non necessarie) tabelle nel mio database, quindi ho voluto saltare il loro contenuto durante la copia, ma mantenere la struttura :

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

I due file risultanti sono strutturalmente sani ma i dati scaricati sono ora ~ 500 MB anziché 9 GB, molto meglio per me. Ora posso importare questi due file in un altro database a scopo di test senza doversi preoccupare di manipolare 9 GB di dati o esaurire lo spazio su disco.

per più database:

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

Un altro esempio per ignorare più tabelle

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

utilizzando --ignore-tablee creare una matrice di tabelle, con sintassi comedatabase.table

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

Collegamenti con informazioni che ti aiuteranno

comprimi l'output mysqldump

• mysqldump & gzip
• mysqldump in un tar.gz

Nota: testato sul server Ubuntu con mysql Ver 14.14 Distrib 5.5.55

Importa database

 mysql -uUSER  -pPASS db_test < db_test.sql

Script semplice per ignorare le tabelle

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

Per escludere alcuni dati della tabella , ma non la struttura della tabella . Ecco come lo faccio:

Dump della struttura del database di tutte le tabelle, senza dati:

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

Quindi scaricare il database con i dati, ad eccezione delle tabelle escluse, e non scaricare la struttura:

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

Quindi, per caricarlo in un nuovo database:

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

È possibile utilizzare il mysqlpumpcomando con

--exclude-tables=name

comando. Specifica un elenco di tabelle separato da virgole da escludere.

La sintassi di mysqlpump è molto simile a mysqldump, ma è molto più performante. Ulteriori informazioni su come utilizzare l'opzione di esclusione sono disponibili qui: https://dev.mysql.com/doc/refman/5.7/en/mysqlpump.html#mysqlpump-filtering

Scarica tutti i database con tutte le tabelle ma salta alcune tabelle

su 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

Con un piccolo aiuto di https://stackoverflow.com/a/17016410/1069083

Usa lzop che è molto più veloce, vedi: http://pokecraft.first-world.info/wiki/Quick_Benchmark:_Gzip_vs_Bzip2_vs_LZMA_vs_XZ_vs_LZ4_vs_LZO

Mi piace la soluzione di Rubo77, non l'avevo mai vista prima di aver modificato quella di Paul. Questo eseguirà il backup di un singolo database, escluse tutte le tabelle che non si desidera. Quindi lo decomprimerà e cancellerà tutti i file più vecchi di 8 giorni. Probabilmente userò 2 versioni di questo che eseguono un full (meno la tabella dei registri) una volta al giorno, e un'altra che esegue il backup delle tabelle più importanti che cambiano di più ogni ora usando un paio di lavori cron.

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

Per completezza, ecco uno script che in realtà potrebbe essere un one-liner per ottenere un backup da un database, escludendo (ignorando) tutte le viste. Si presume che il nome db sia impiegato:

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"   

È possibile aggiornare la logica della query. In generale usando group_concate concatpuoi generare quasi tutti i comandi di stringa o shell desiderati.

In generale, è necessario utilizzare questa funzione quando non si desidera o non si ha il tempo di gestire un tavolo enorme. Se questo è il tuo caso, è meglio usare l'opzione --where del mysetldump che limita i risultati. Ad esempio mysqldump -uuser -ppass database --where="1 = 1 LIMIT 500000" > resultset.sql,.