Chciałbym napisać skrypt, który kopiuje moją aktualną bazę danych sitedb1do sitedb2tej samej instancji bazy danych mysql. Wiem, że mogę zrzucić sitedb1 do skryptu sql:

mysqldump -u root -p sitedb1 >~/db_name.sql

a następnie zaimportuj go do sitedb2. Czy istnieje łatwiejszy sposób bez zrzucania pierwszej bazy danych do pliku sql?

Jak mówi podręcznik w sekcji Kopiowanie baz danych , możesz przesłać zrzut bezpośrednio do klienta mysql:

mysqldump db_name | mysql new_db_name

Jeśli używasz MyISAM ty mógł skopiować pliki, ale nie polecam go. To trochę podejrzane.

Zintegrowane z różnymi dobrymi innymi odpowiedziami

Oba polecenia mysqldumpi mysqlakceptują opcje ustawiania szczegółów połączenia (i wiele więcej), takie jak:

mysqldump -u <user name> --password=<pwd> <original db> | mysql -u <user name> -p <new db>

Ponadto, jeśli nowa baza danych jeszcze nie istnieje, musisz ją wcześniej utworzyć (np. Za pomocą echo "create database new_db_name" | mysql -u <dbuser> -p).

Korzystanie z narzędzi MySQL

Narzędzia MySQL zawierają przyjemne narzędzie, mysqldbcopyktóre domyślnie kopiuje bazę danych, w tym wszystkie powiązane obiekty („tabele, widoki, wyzwalacze, zdarzenia, procedury, funkcje i granty na poziomie bazy danych”) oraz dane z jednego serwera DB na ten sam lub inny Serwer DB. Dostępnych jest wiele opcji dostosowywania tego, co faktycznie jest kopiowane.

Tak więc, odpowiadając na pytanie PO:

mysqldbcopy \
    --source=root:your_password@localhost \
    --destination=root:your_password@localhost \
    sitedb1:sitedb2

mysqladmin create DB_name -u DB_user --password=DB_pass && \
        mysqldump -u DB_user --password=DB_pass DB_name | \
        mysql     -u DB_user --password=DB_pass -h DB_host DB_name

Musisz uruchomić polecenie z terminala / wiersza polecenia.

mysqldump -u <user name> -p <pwd> <original db> | mysql -u <user name> <pwd> <new db>

na przykład: mysqldump -u root test_db1 | mysql -u root test_db2

To kopiuje test_db1 do test_db2 i przyznaje dostęp do 'root' @ 'localhost'

Najlepszym i najłatwiejszym sposobem jest wprowadzenie tych poleceń w terminalu i ustawienie uprawnień dla użytkownika root. Pracuje dla mnie..!

:~$> mysqldump -u root -p db1 > dump.sql
:~$> mysqladmin -u root -p create db2
:~$> mysql -u root -p db2 < dump.sql

Możesz użyć (w pseudokodzie):

FOREACH tbl IN db_a:
    CREATE TABLE db_b.tbl LIKE db_a.tbl;
    INSERT INTO db_b.tbl SELECT * FROM db_a.tbl;

Powodem, dla którego nie używam składni CREATE TABLE ... SELECT ..., jest zachowanie indeksów. Oczywiście to tylko kopiuje tabele. Poglądy i procedury nie są kopiowane, chociaż można to zrobić w ten sam sposób.

Zobacz UTWÓRZ TABELĘ .

Najpierw utwórz zduplikowaną bazę danych:

CREATE DATABASE duplicateddb;

Upewnij się, że wszystkie uprawnienia itp. Są na miejscu i:

mysqldump -u admin -p originaldb | mysql -u backup -p password duplicateddb;

Możesz zrobić coś takiego:

mysqldump -u[username] -p[password] database_name_for_clone 
 | mysql -u[username] -p[password] new_database_name

To stwierdzenie zostało dodane w MySQL 5.1.7, ale zostało uznane za niebezpieczne i zostało usunięte w MySQL 5.1.23. Miało to na celu umożliwienie aktualizacji baz danych w wersji wcześniejszej niż 5.1 w celu wykorzystania kodowania zaimplementowanego w wersji 5.1 do mapowania nazw baz danych na nazwy katalogów baz danych. Jednak użycie tego oświadczenia mogło spowodować utratę zawartości bazy danych, dlatego zostało ono usunięte. Nie używaj RENAME DATABASE we wcześniejszych wersjach, w których jest obecny.

Aby wykonać zadanie aktualizacji nazw baz danych z nowym kodowaniem, użyj zamiast tego ALTER DATABASE nazwa_bazy danych UPGRADE DATA DIRECTORY NAME: http://dev.mysql.com/doc/refman/5.1/en/alter-database.html

Prosty sposób na zrobienie tego, jeśli zainstalowałeś phpmyadmin :

Przejdź do swojej bazy danych, wybierz zakładkę „operacja”, a zobaczysz blok „kopiuj bazę danych do”. Użyj go i możesz skopiować bazę danych.

Jak wspomniano w odpowiedzi Grega , mysqldump db_name | mysql new_db_namejest to darmowy, bezpieczny i łatwy sposób przesyłania danych między bazami danych. Jednak jest też bardzo wolny .

Jeśli chcesz wykonać kopię zapasową danych, nie możesz pozwolić sobie na utratę danych (w tej lub innych bazach danych) lub używasz tabel innych niż innodb, powinieneś użyć mysqldump.

Jeśli szukasz czegoś do programowania, masz kopie zapasowe wszystkich baz danych w innym miejscu i możesz wygodnie czyścić i ponownie instalować mysql(prawdopodobnie ręcznie), gdy wszystko pójdzie nie tak, to mogę po prostu mieć dla Ciebie rozwiązanie.

Nie mogłem znaleźć dobrej alternatywy, więc stworzyłem scenariusz, aby zrobić to sam. Spędziłem dużo czasu, aby to zadziałało za pierwszym razem i szczerze mówiąc, trochę mnie przeraża, że ​​mogę teraz wprowadzić zmiany. Bazy danych Innodb nie były przeznaczone do kopiowania i wklejania w ten sposób. Drobne zmiany powodują, że kończy się to niepowodzeniem w wspaniały sposób. Nie miałem problemu, odkąd sfinalizowałem kod, ale to nie znaczy, że tego nie zrobisz.

Systemy testowane na (ale nadal mogą zawieść):

• Ubuntu 16.04, domyślny mysql, innodb, oddzielne pliki na tabelę
• Ubuntu 18.04, domyślny mysql, innodb, oddzielne pliki na tabelę

Co to robi

1. Uzyskuje sudouprawnienia i sprawdza, czy masz wystarczającą ilość miejsca do sklonowania bazy danych
2. Pobiera uprawnienia roota mysql
3. Tworzy nową bazę danych o nazwie zgodnej z bieżącą gałęzią git
4. Struktura klonów do nowej bazy danych
5. Przełącza się w tryb odzyskiwania dla innodb
6. Usuwa domyślne dane w nowej bazie danych
7. Zatrzymuje mysql
8. Klonuje dane do nowej bazy danych
9. Uruchamia mysql
10. Linki zaimportowane dane do nowej bazy danych
11. Wyłącza tryb odzyskiwania dla innodb
12. Ponownie uruchamia mysql
13. Daje użytkownikowi mysql dostęp do bazy danych
14. Czyści pliki tymczasowe

Jak to wypada w porównaniu z mysqldump

W przypadku bazy danych 3 GB użycie mysqldumpi mysqlzajęłoby 40-50 minut na moim komputerze. Używając tej metody, ten sam proces zajmie tylko ~ 8 minut.

Jak tego używamy

Zapisujemy nasze zmiany SQL wraz z naszym kodem, a proces uaktualniania jest zautomatyzowany zarówno pod względem produkcji, jak i rozwoju, a każdy zestaw zmian tworzy kopię zapasową bazy danych w celu przywrócenia w przypadku błędów. Jednym z problemów, na który natknęliśmy się, było to, że pracowaliśmy nad długoterminowym projektem ze zmianami w bazie danych i musieliśmy przełączać gałęzie w środku, aby naprawić błąd lub trzy.

W przeszłości używaliśmy jednej bazy danych dla wszystkich gałęzi i musielibyśmy odbudować bazę danych za każdym razem, gdy przełączaliśmy się na gałąź, która nie była zgodna z nowymi zmianami bazy danych. A kiedy wróciliśmy, musielibyśmy ponownie uruchomić aktualizacje.

Próbowaliśmy mysqldumpzduplikować bazę danych dla różnych gałęzi, ale czas oczekiwania był zbyt długi (40-50 minut) i w międzyczasie nie mogliśmy zrobić nic więcej.

To rozwiązanie skróciło czas klonowania bazy danych do 1/5 czasu (pomyśl o przerwie na kawę i łazienkę zamiast długiego lunchu).

Wspólne zadania i ich czas

Przełączanie między gałęziami z niekompatybilnymi zmianami bazy danych zajmuje ponad 50 minut w jednej bazie danych, ale nie ma czasu po początkowym czasie konfiguracji z mysqldumptym kodem. Tak się składa, że ​​ten kod jest ~ 5 razy szybszy niż mysqldump.

Oto kilka typowych zadań i przybliżony czas ich trwania w przypadku każdej metody:

Utwórz gałąź funkcji ze zmianami w bazie danych i natychmiast scal:

• Pojedyncza baza danych: ~ 5 minut
• Klonuj za pomocą mysqldump: 50-60 minut
• Sklonuj z tym kodem: ~ 18 minut

Utwórz gałąź funkcji ze zmianami w bazie danych, przełącz się masterna, aby naprawić błąd, dokonaj edycji w gałęzi funkcji i scal:

• Pojedyncza baza danych: ~ 60 minut
• Klonuj za pomocą mysqldump: 50-60 minut
• Sklonuj z tym kodem: ~ 18 minut

Utwórz gałąź funkcji ze zmianami w bazie danych, przełącz się masterna 5 razy w celu usunięcia błędu, dokonując zmian w gałęzi funkcji między nimi i scal:

• Pojedyncza baza danych: ~ 4 godziny, 40 minut
• Klonuj za pomocą mysqldump: 50-60 minut
• Sklonuj z tym kodem: ~ 18 minut

Kod

Nie używaj tego, chyba że przeczytałeś i zrozumiałeś wszystko powyżej.

#!/bin/bash
set -e

# This script taken from: https://stackoverflow.com/a/57528198/526741

function now {
    date "+%H:%M:%S";
}

# Leading space sets messages off from step progress.
echosuccess () {
    printf "\e[0;32m %s: %s\e[0m\n" "$(now)" "$1"
    sleep .1
}
echowarn () {
    printf "\e[0;33m %s: %s\e[0m\n" "$(now)" "$1"
    sleep .1
}
echoerror () {
    printf "\e[0;31m %s: %s\e[0m\n" "$(now)" "$1"
    sleep .1
}
echonotice () {
    printf "\e[0;94m %s: %s\e[0m\n" "$(now)" "$1"
    sleep .1
}
echoinstructions () {
    printf "\e[0;104m %s: %s\e[0m\n" "$(now)" "$1"
    sleep .1
}
echostep () {
    printf "\e[0;90mStep %s of 13:\e[0m\n" "$1"
    sleep .1
}

MYSQL_CNF_PATH='/etc/mysql/mysql.conf.d/recovery.cnf'
OLD_DB='YOUR_DATABASE_NAME'
USER='YOUR_MYSQL_USER'

# You can change NEW_DB to whatever you like
# Right now, it will append the current git branch name to the existing database name
BRANCH=`git rev-parse --abbrev-ref HEAD`
NEW_DB="${OLD_DB}__$BRANCH"

THIS_DIR=./site/upgrades
DB_CREATED=false

tmp_file () {
    printf "$THIS_DIR/$NEW_DB.%s" "$1"
}
sql_on_new_db () {
    mysql $NEW_DB --unbuffered --skip-column-names -u root -p$PASS 2>> $(tmp_file 'errors.log')
}

general_cleanup () {
    echoinstructions 'Leave this running while things are cleaned up...'

    if [ -f $(tmp_file 'errors.log') ]; then
        echowarn 'Additional warnings and errors:'
        cat $(tmp_file 'errors.log')
    fi

    for f in $THIS_DIR/$NEW_DB.*; do
        echonotice 'Deleting temporary files created for transfer...'
        rm -f $THIS_DIR/$NEW_DB.*
        break
    done

    echonotice 'Done!'
    echoinstructions "You can close this now :)"
}

error_cleanup () {
    exitcode=$?

    # Just in case script was exited while in a prompt
    echo

    if [ "$exitcode" == "0" ]; then
        echoerror "Script exited prematurely, but exit code was '0'."
    fi

    echoerror "The following command on line ${BASH_LINENO[0]} exited with code $exitcode:"
    echo "             $BASH_COMMAND"

    if [ "$DB_CREATED" = true ]; then
        echo
        echonotice "Dropping database \`$NEW_DB\` if created..."
        echo "DROP DATABASE \`$NEW_DB\`;" | sql_on_new_db || echoerror "Could not drop database \`$NEW_DB\` (see warnings)"
    fi

    general_cleanup

    exit $exitcode
}

trap error_cleanup EXIT

mysql_path () {
    printf "/var/lib/mysql/"
}
old_db_path () {
    printf "%s%s/" "$(mysql_path)" "$OLD_DB"
}
new_db_path () {
    printf "%s%s/" "$(mysql_path)" "$NEW_DB"
}
get_tables () {
    (sudo find /var/lib/mysql/$OLD_DB -name "*.frm" -printf "%f\n") | cut -d'.' -f1 | sort
}

STEP=0


authenticate () {
    printf "\e[0;104m"
    sudo ls &> /dev/null
    printf "\e[0m"
    echonotice 'Authenticated.'
}
echostep $((++STEP))
authenticate

TABLE_COUNT=`get_tables | wc -l`
SPACE_AVAIL=`df -k --output=avail $(mysql_path) | tail -n1`
SPACE_NEEDED=(`sudo du -s $(old_db_path)`)
SPACE_ERR=`echo "$SPACE_AVAIL-$SPACE_NEEDED" | bc`
SPACE_WARN=`echo "$SPACE_AVAIL-$SPACE_NEEDED*3" | bc`
if [ $SPACE_ERR -lt 0 ]; then
    echoerror 'There is not enough space to branch the database.'
    echoerror 'Please free up some space and run this command again.'
    SPACE_AVAIL_FORMATTED=`printf "%'d" $SPACE_AVAIL`
    SPACE_NEEDED_FORMATTED=`printf "%'${#SPACE_AVAIL_FORMATTED}d" $SPACE_NEEDED`
    echonotice "$SPACE_NEEDED_FORMATTED bytes needed to create database branch"
    echonotice "$SPACE_AVAIL_FORMATTED bytes currently free"
    exit 1
elif [ $SPACE_WARN -lt 0 ]; then
    echowarn 'This action will use more than 1/3 of your available space.'
    SPACE_AVAIL_FORMATTED=`printf "%'d" $SPACE_AVAIL`
    SPACE_NEEDED_FORMATTED=`printf "%'${#SPACE_AVAIL_FORMATTED}d" $SPACE_NEEDED`
    echonotice "$SPACE_NEEDED_FORMATTED bytes needed to create database branch"
    echonotice "$SPACE_AVAIL_FORMATTED bytes currently free"
    printf "\e[0;104m"
    read -p " $(now): Do you still want to branch the database? [y/n] " -n 1 -r CONFIRM
    printf "\e[0m"
    echo
    if [[ ! $CONFIRM =~ ^[Yy]$ ]]; then
        echonotice 'Database was NOT branched'
        exit 1
    fi
fi

PASS='badpass'
connect_to_db () {
    printf "\e[0;104m %s: MySQL root password: \e[0m" "$(now)"
    read -s PASS
    PASS=${PASS:-badpass}
    echo
    echonotice "Connecting to MySQL..."
}
create_db () {
    echonotice 'Creating empty database...'
    echo "CREATE DATABASE \`$NEW_DB\` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci" | mysql -u root -p$PASS 2>> $(tmp_file 'errors.log')
    DB_CREATED=true
}
build_tables () {
    echonotice 'Retrieving and building database structure...'
    mysqldump $OLD_DB --skip-comments -d -u root -p$PASS 2>> $(tmp_file 'errors.log') | pv --width 80  --name " $(now)" > $(tmp_file 'dump.sql')
    pv --width 80  --name " $(now)" $(tmp_file 'dump.sql') | sql_on_new_db
}
set_debug_1 () {
    echonotice 'Switching into recovery mode for innodb...'
    printf '[mysqld]\ninnodb_file_per_table = 1\ninnodb_force_recovery = 1\n' | sudo tee $MYSQL_CNF_PATH > /dev/null
}
set_debug_0 () {
    echonotice 'Switching out of recovery mode for innodb...'
    sudo rm -f $MYSQL_CNF_PATH
}
discard_tablespace () {
    echonotice 'Unlinking default data...'
    (
        echo "USE \`$NEW_DB\`;"
        echo "SET foreign_key_checks = 0;"
        get_tables | while read -r line;
            do echo "ALTER TABLE \`$line\` DISCARD TABLESPACE; SELECT 'Table \`$line\` imported.';";
        done
        echo "SET foreign_key_checks = 1;"
    ) > $(tmp_file 'discard_tablespace.sql')
    cat $(tmp_file 'discard_tablespace.sql') | sql_on_new_db | pv --width 80 --line-mode --size $TABLE_COUNT --name " $(now)" > /dev/null
}
import_tablespace () {
    echonotice 'Linking imported data...'
    (
        echo "USE \`$NEW_DB\`;"
        echo "SET foreign_key_checks = 0;"
        get_tables | while read -r line;
            do echo "ALTER TABLE \`$line\` IMPORT TABLESPACE; SELECT 'Table \`$line\` imported.';";
        done
        echo "SET foreign_key_checks = 1;"
    ) > $(tmp_file 'import_tablespace.sql')
    cat $(tmp_file 'import_tablespace.sql') | sql_on_new_db | pv --width 80 --line-mode --size $TABLE_COUNT --name " $(now)" > /dev/null
}
stop_mysql () {
    echonotice 'Stopping MySQL...'
    sudo /etc/init.d/mysql stop >> $(tmp_file 'log')
}
start_mysql () {
    echonotice 'Starting MySQL...'
    sudo /etc/init.d/mysql start >> $(tmp_file 'log')
}
restart_mysql () {
    echonotice 'Restarting MySQL...'
    sudo /etc/init.d/mysql restart >> $(tmp_file 'log')
}
copy_data () {
    echonotice 'Copying data...'
    sudo rm -f $(new_db_path)*.ibd
    sudo rsync -ah --info=progress2 $(old_db_path) --include '*.ibd' --exclude '*' $(new_db_path)
}
give_access () {
    echonotice "Giving MySQL user \`$USER\` access to database \`$NEW_DB\`"
    echo "GRANT ALL PRIVILEGES ON \`$NEW_DB\`.* to $USER@localhost" | sql_on_new_db
}

echostep $((++STEP))
connect_to_db

EXISTING_TABLE=`echo "SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = '$NEW_DB'" | mysql --skip-column-names -u root -p$PASS 2>> $(tmp_file 'errors.log')`
if [ "$EXISTING_TABLE" == "$NEW_DB" ]
    then
        echoerror "Database \`$NEW_DB\` already exists"
        exit 1
fi

echoinstructions "The hamsters are working. Check back in 5-10 minutes."
sleep 5

echostep $((++STEP))
create_db
echostep $((++STEP))
build_tables
echostep $((++STEP))
set_debug_1
echostep $((++STEP))
discard_tablespace
echostep $((++STEP))
stop_mysql
echostep $((++STEP))
copy_data
echostep $((++STEP))
start_mysql
echostep $((++STEP))
import_tablespace
echostep $((++STEP))
set_debug_0
echostep $((++STEP))
restart_mysql
echostep $((++STEP))
give_access

echo
echosuccess "Database \`$NEW_DB\` is ready to use."
echo

trap general_cleanup EXIT

Jeśli wszystko pójdzie gładko, powinieneś zobaczyć coś takiego:

Oprócz odpowiedzi Grega jest to najłatwiejszy i najszybszy sposób, jeśli new_db_namejeszcze nie istnieje:

echo "create database new_db_name" | mysql -u <user> -p <pwd> 
mysqldump -u <user> -p <pwd> db_name | mysql -u <user> -p <pwd> new_db_name

Jeśli masz wyzwalacze w swojej oryginalnej bazie danych, możesz uniknąć błędu „Wyzwalacz już istnieje”, umieszczając je potokowo przed importem:

mysqldump -u olddbuser -p -d olddbname | sed "s/`olddbname`./`newdbname`./" | mysql -u newdbuser -p -D newdbname

Myślę, że nie ma na to metody. Kiedy PHPMyAdmin to robi, zrzuca bazę danych, a następnie wstawia ją ponownie pod nową nazwą.