change - webmin rename mysql database




Come rinominare rapidamente un database MySQL(cambiare il nome dello schema)? (20)

Il manuale MySQL di MySQL copre questo.

Solitamente butto via il database e lo reimportò con un nuovo nome. Questa non è un'opzione per database molto grandi. Apparentemente RENAME {DATABASE | SCHEMA} db_name TO new_db_name; RENAME {DATABASE | SCHEMA} db_name TO new_db_name; MySQL .

Questo deve funzionare con InnoDB , che memorizza le cose in modo molto diverso da MyISAM .


Il modo semplice

Passare alla directory del database:

cd /var/lib/mysql/

Chiudi MySQL ... Questo è importante!

/etc/init.d/mysql stop

Ok, in questo modo non funziona con i database InnoDB o BDB.

Rinomina database:

mv old-name new-name

... o il tavolo ...

cd database/

mv old-name.frm new-name.frm

mv old-name.MYD new-name.MYD

mv old-name.MYI new-name.MYI

Riavvia MySQL

/etc/init.d/mysql start

Fatto...

OK, in questo modo non funziona con i database InnoDB o BDB. In questo caso devi scaricare il database e reimportarlo.


È possibile rinominare tutte le tabelle all'interno di un database in un altro database senza dover eseguire il dump e il ripristino completi.

DROP PROCEDURE IF EXISTS mysql.rename_db;
DELIMITER ||
CREATE PROCEDURE mysql.rename_db(IN old_db VARCHAR(100), IN new_db VARCHAR(100))
BEGIN
SELECT CONCAT('CREATE DATABASE ', new_db, ';') `# create new database`;
SELECT CONCAT('RENAME TABLE `', old_db, '`.`', table_name, '` TO `', new_db, '`.`', table_name, '`;') `# alter table` FROM information_schema.tables WHERE table_schema = old_db;
SELECT CONCAT('DROP DATABASE `', old_db, '`;') `# drop old database`;
END||
DELIMITER ;

$ time mysql -uroot -e "call mysql.rename_db('db1', 'db2');" | mysql -uroot

Tuttavia qualsiasi trigger nel db di destinazione non sarà felice. Dovrai prima eliminarli, quindi ricrearli dopo la rinomina.

mysql -uroot -e "call mysql.rename_db('test', 'blah2');" | mysql -uroot
ERROR 1435 (HY000) at line 4: Trigger in wrong schema

Bene, ci sono 2 metodi:

Metodo 1: un metodo ben noto per la ridenominazione dello schema del database consiste nel riversare lo schema utilizzando Mysqldump e ripristinarlo in un altro schema, quindi eliminare lo schema precedente (se necessario).

Da Shell

 mysqldump emp > emp.out
 mysql -e "CREATE DATABASE employees;"
 mysql employees < emp.out 
 mysql -e "DROP DATABASE emp;"

Sebbene il metodo di cui sopra sia facile, richiede tempo e spazio. Cosa succede se lo schema è superiore a 100 GB? Esistono metodi in cui è possibile reindirizzare i comandi sopra riportati per risparmiare spazio, tuttavia non consente di risparmiare tempo.

Per rimediare a tali situazioni, esiste un altro metodo rapido per rinominare gli schemi, tuttavia è necessario prestare particolare attenzione durante la sua esecuzione.

Metodo 2: MySQL ha una funzionalità molto buona per rinominare le tabelle che funzionano anche su schemi diversi. Questa operazione di rinomina è atomica e nessun altro può accedere alla tabella mentre viene rinominata. Questo richiede un po 'di tempo per essere completato poiché cambiare il nome di una tabella o il suo schema è solo una modifica dei metadati. Ecco l'approccio procedurale nel fare il cambio di nome:

Creare il nuovo schema del database con il nome desiderato. Rinominare le tabelle dal vecchio schema al nuovo schema, usando il comando "RENAME TABLE" di MySQL. Rilascia il vecchio schema del database. If there are views, triggers, functions, stored procedures in the schema, those will need to be recreated too . "RENAME TABLE" di MySQL fallisce se esistono dei trigger sulle tabelle. Per rimediare a questo possiamo fare le seguenti cose:

1) Dump the triggers, events and stored routines in a separate file. Questo fatto usando -E, -R flags (in aggiunta a -t -d che scarica i trigger) al comando mysqldump. Una volta scaricati i trigger, sarà necessario eliminarli dallo schema, affinché il comando RENAME TABLE funzioni.

 $ mysqldump <old_schema_name> -d -t -R -E > stored_routines_triggers_events.out

2) Genera una lista di sole tabelle "BASE". Questi possono essere trovati usando una query sulla tabella information_schema.TABLES .

 mysql> select TABLE_NAME from information_schema.tables where 
    table_schema='<old_schema_name>' and TABLE_TYPE='BASE TABLE';

3) Scarica le viste in un file esterno. Le viste possono essere trovate usando una query sulla stessa tabella information_schema.TABLES .

mysql> select TABLE_NAME from information_schema.tables where 
   table_schema='<old_schema_name>' and TABLE_TYPE='VIEW';
 $ mysqldump <database> <view1> <view2> … > views.out

4) Rilasciare i trigger nelle tabelle correnti in old_schema.

mysql> DROP TRIGGER <trigger_name>;
...

5) Ripristinare i file di dump di cui sopra una volta che tutte le tabelle "Base" trovate nel passaggio 2 sono state rinominate.

mysql> RENAME TABLE <old_schema>.table_name TO <new_schema>.table_name;
...
$ mysql <new_schema> < views.out
$ mysql <new_schema> < stored_routines_triggers_events.out

Intricatezze con i metodi di cui sopra: potremmo aver bisogno di aggiornare i GRANTS per gli utenti in modo che corrispondano al nome_schema corretto. Questi potrebbero essere corretti con un semplice UPDATE su mysql.columns_priv, mysql.procs_priv, mysql.tables_priv, mysql.db tabelle aggiornando il nome old_schema a new_schema e chiamando "Flush privileges;". Anche se il "metodo 2" sembra un po 'più complicato del "metodo 1", questo è totalmente programmabile. Un semplice script bash per eseguire i passaggi precedenti nella sequenza corretta, può aiutare a risparmiare spazio e tempo durante la ridenominazione degli schemi di database la prossima volta.

Il team DBA Remote di Percona ha scritto uno script chiamato "rename_db" che funziona nel modo seguente:

[[email protected]~]# /tmp/rename_db
rename_db <server> <database> <new_database>

Per dimostrare l'uso di questo script, utilizzato uno schema di esempio "emp", creato trigger di test, routine memorizzate su tale schema. Cercherà di rinominare lo schema del database utilizzando lo script, che richiede alcuni secondi per completare il metodo di dumping / ripristino in termini di tempo.

mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| emp                |
| mysql              |
| performance_schema |
| test               |
+--------------------+


[[email protected] ~]# time /tmp/rename_db localhost emp emp_test
create database emp_test DEFAULT CHARACTER SET latin1
drop trigger salary_trigger
rename table emp.__emp_new to emp_test.__emp_new
rename table emp._emp_new to emp_test._emp_new
rename table emp.departments to emp_test.departments
rename table emp.dept to emp_test.dept
rename table emp.dept_emp to emp_test.dept_emp
rename table emp.dept_manager to emp_test.dept_manager
rename table emp.emp to emp_test.emp
rename table emp.employees to emp_test.employees
rename table emp.salaries_temp to emp_test.salaries_temp
rename table emp.titles to emp_test.titles
loading views
loading triggers, routines and events
Dropping database emp

real    0m0.643s
user    0m0.053s
sys     0m0.131s


mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| emp_test           |
| mysql              |
| performance_schema |
| test               |
+--------------------+

Come si può vedere nell'output precedente lo schema del database "emp" è stato rinominato in "emp_test" in meno di un secondo. Infine, questo è lo script di Percona che viene usato in precedenza per "metodo 2".

#!/bin/bash
# Copyright 2013 Percona LLC and/or its affiliates
set -e
if [ -z "$3" ]; then
    echo "rename_db <server> <database> <new_database>"
    exit 1
fi
db_exists=`mysql -h $1 -e "show databases like '$3'" -sss`
if [ -n "$db_exists" ]; then
    echo "ERROR: New database already exists $3"
    exit 1
fi
TIMESTAMP=`date +%s`
character_set=`mysql -h $1 -e "show create database $2\G" -sss | grep ^Create | awk -F'CHARACTER SET ' '{print $2}' | awk '{print $1}'`
TABLES=`mysql -h $1 -e "select TABLE_NAME from information_schema.tables where table_schema='$2' and TABLE_TYPE='BASE TABLE'" -sss`
STATUS=$?
if [ "$STATUS" != 0 ] || [ -z "$TABLES" ]; then
    echo "Error retrieving tables from $2"
    exit 1
fi
echo "create database $3 DEFAULT CHARACTER SET $character_set"
mysql -h $1 -e "create database $3 DEFAULT CHARACTER SET $character_set"
TRIGGERS=`mysql -h $1 $2 -e "show triggers\G" | grep Trigger: | awk '{print $2}'`
VIEWS=`mysql -h $1 -e "select TABLE_NAME from information_schema.tables where table_schema='$2' and TABLE_TYPE='VIEW'" -sss`
if [ -n "$VIEWS" ]; then
    mysqldump -h $1 $2 $VIEWS > /tmp/${2}_views${TIMESTAMP}.dump
fi
mysqldump -h $1 $2 -d -t -R -E > /tmp/${2}_triggers${TIMESTAMP}.dump
for TRIGGER in $TRIGGERS; do
    echo "drop trigger $TRIGGER"
    mysql -h $1 $2 -e "drop trigger $TRIGGER"
done
for TABLE in $TABLES; do
    echo "rename table $2.$TABLE to $3.$TABLE"
    mysql -h $1 $2 -e "SET FOREIGN_KEY_CHECKS=0; rename table $2.$TABLE to $3.$TABLE"
done
if [ -n "$VIEWS" ]; then
    echo "loading views"
    mysql -h $1 $3 < /tmp/${2}_views${TIMESTAMP}.dump
fi
echo "loading triggers, routines and events"
mysql -h $1 $3 < /tmp/${2}_triggers${TIMESTAMP}.dump
TABLES=`mysql -h $1 -e "select TABLE_NAME from information_schema.tables where table_schema='$2' and TABLE_TYPE='BASE TABLE'" -sss`
if [ -z "$TABLES" ]; then
    echo "Dropping database $2"
    mysql -h $1 $2 -e "drop database $2"
fi
if [ `mysql -h $1 -e "select count(*) from mysql.columns_priv where db='$2'" -sss` -gt 0 ]; then
    COLUMNS_PRIV="    UPDATE mysql.columns_priv set db='$3' WHERE db='$2';"
fi
if [ `mysql -h $1 -e "select count(*) from mysql.procs_priv where db='$2'" -sss` -gt 0 ]; then
    PROCS_PRIV="    UPDATE mysql.procs_priv set db='$3' WHERE db='$2';"
fi
if [ `mysql -h $1 -e "select count(*) from mysql.tables_priv where db='$2'" -sss` -gt 0 ]; then
    TABLES_PRIV="    UPDATE mysql.tables_priv set db='$3' WHERE db='$2';"
fi
if [ `mysql -h $1 -e "select count(*) from mysql.db where db='$2'" -sss` -gt 0 ]; then
    DB_PRIV="    UPDATE mysql.db set db='$3' WHERE db='$2';"
fi
if [ -n "$COLUMNS_PRIV" ] || [ -n "$PROCS_PRIV" ] || [ -n "$TABLES_PRIV" ] || [ -n "$DB_PRIV" ]; then
    echo "IF YOU WANT TO RENAME the GRANTS YOU NEED TO RUN ALL OUTPUT BELOW:"
    if [ -n "$COLUMNS_PRIV" ]; then echo "$COLUMNS_PRIV"; fi
    if [ -n "$PROCS_PRIV" ]; then echo "$PROCS_PRIV"; fi
    if [ -n "$TABLES_PRIV" ]; then echo "$TABLES_PRIV"; fi
    if [ -n "$DB_PRIV" ]; then echo "$DB_PRIV"; fi
    echo "    flush privileges;"
fi

Ecco un file batch che ho scritto per automatizzarlo dalla riga di comando, ma per Windows / MS-DOS.

La sintassi è rename_mysqldb database newdatabase -u [utente] -p [password]

:: ***************************************************************************
:: FILE: RENAME_MYSQLDB.BAT
:: ***************************************************************************
:: DESCRIPTION
:: This is a Windows /MS-DOS batch file that automates renaming a MySQL database 
:: by using MySQLDump, MySQLAdmin, and MySQL to perform the required tasks.
:: The MySQL\bin folder needs to be in your environment path or the working directory.
::
:: WARNING: The script will delete the original database, but only if it successfully
:: created the new copy. However, read the disclaimer below before using.
::
:: DISCLAIMER
:: This script is provided without any express or implied warranties whatsoever.
:: The user must assume the risk of using the script.
::
:: You are free to use, modify, and distribute this script without exception.
:: ***************************************************************************

:INITIALIZE
@ECHO OFF
IF [%2]==[] GOTO HELP
IF [%3]==[] (SET RDB_ARGS=--user=root) ELSE (SET RDB_ARGS=%3 %4 %5 %6 %7 %8 %9)
SET RDB_OLDDB=%1
SET RDB_NEWDB=%2
SET RDB_DUMPFILE=%RDB_OLDDB%_dump.sql
GOTO START

:START
SET RDB_STEP=1
ECHO Dumping "%RDB_OLDDB%"...
mysqldump %RDB_ARGS% %RDB_OLDDB% > %RDB_DUMPFILE%
IF %ERRORLEVEL% NEQ 0 GOTO ERROR_ABORT
SET RDB_STEP=2
ECHO Creating database "%RDB_NEWDB%"...
mysqladmin %RDB_ARGS% create %RDB_NEWDB%
IF %ERRORLEVEL% NEQ 0 GOTO ERROR_ABORT
SET RDB_STEP=3
ECHO Loading dump into "%RDB_NEWDB%"...
mysql %RDB_ARGS% %RDB_NEWDB% < %RDB_DUMPFILE%
IF %ERRORLEVEL% NEQ 0 GOTO ERROR_ABORT
SET RDB_STEP=4
ECHO Dropping database "%RDB_OLDDB%"...
mysqladmin %RDB_ARGS% drop %RDB_OLDDB% --force
IF %ERRORLEVEL% NEQ 0 GOTO ERROR_ABORT
SET RDB_STEP=5
ECHO Deleting dump...
DEL %RDB_DUMPFILE%
IF %ERRORLEVEL% NEQ 0 GOTO ERROR_ABORT
ECHO Renamed database "%RDB_OLDDB%" to "%RDB_NEWDB%".
GOTO END

:ERROR_ABORT
IF %RDB_STEP% GEQ 3 mysqladmin %RDB_ARGS% drop %NEWDB% --force
IF %RDB_STEP% GEQ 1 IF EXIST %RDB_DUMPFILE% DEL %RDB_DUMPFILE%
ECHO Unable to rename database "%RDB_OLDDB%" to "%RDB_NEWDB%".
GOTO END

:HELP
ECHO Renames a MySQL database.
ECHO Usage: %0 database new_database [OPTIONS]
ECHO Options: Any valid options shared by MySQL, MySQLAdmin and MySQLDump.
ECHO          --user=root is used if no options are specified.
GOTO END    

:END
SET RDB_OLDDB=
SET RDB_NEWDB=
SET RDB_ARGS=
SET RDB_DUMP=
SET RDB_STEP=

Il modo più semplice, a prova di bomba, di eseguire un rinominare completo (incluso il rilascio del vecchio database alla fine, quindi è un rinominare piuttosto che una copia) :

mysqladmin -uroot -pmypassword create newdbname
mysqldump -uroot -pmypassword --routines olddbname | mysql -uroot -pmypassword newdbname
mysqladmin -uroot -pmypassword drop olddbname

passi:

  1. Copia le righe nel Blocco note.
  2. Sostituisci tutti i riferimenti a "olddbname", "newdbname", "mypassword" (+ opzionalmente "root") con i tuoi equivalenti.
  3. Esegui uno alla volta sulla riga di comando (inserendo "y" quando richiesto).

La maggior parte delle risposte qui sono sbagliate per uno dei due motivi:

  1. Non puoi usare RENAME TABLE, perché potrebbero esserci visualizzazioni e trigger. Se ci sono trigger, RENAME TABLE fallisce
  2. Non è possibile utilizzare mysqldump se si desidera "rapidamente" (come richiesto nella domanda) rinominare un grande database

Percona ha un post sul blog su come farlo bene: https://www.percona.com/blog/2013/12/24/renaming-database-schema-mysql/

e sceneggiatura postata (realizzata?) da Simon R Jones che fa ciò che viene suggerito in quel post. Ho corretto un errore che ho trovato nella sceneggiatura. Potete vederlo qui:

https://gist.github.com/ryantm/76944318b0473ff25993ef2a7186213d

Ecco una copia di questo:

#!/bin/bash
# Copyright 2013 Percona LLC and/or its affiliates
# @see https://www.percona.com/blog/2013/12/24/renaming-database-schema-mysql/
set -e
if [ -z "$3" ]; then
    echo "rename_db <server> <database> <new_database>"
    exit 1
fi
db_exists=`mysql -h $1 -e "show databases like '$3'" -sss`
if [ -n "$db_exists" ]; then
    echo "ERROR: New database already exists $3"
    exit 1
fi
TIMESTAMP=`date +%s`
character_set=`mysql -h $1 -e "SELECT default_character_set_name FROM information_schema.SCHEMATA WHERE schema_name = '$2'" -sss`
TABLES=`mysql -h $1 -e "select TABLE_NAME from information_schema.tables where table_schema='$2' and TABLE_TYPE='BASE TABLE'" -sss`
STATUS=$?
if [ "$STATUS" != 0 ] || [ -z "$TABLES" ]; then
    echo "Error retrieving tables from $2"
    exit 1
fi
echo "create database $3 DEFAULT CHARACTER SET $character_set"
mysql -h $1 -e "create database $3 DEFAULT CHARACTER SET $character_set"
TRIGGERS=`mysql -h $1 $2 -e "show triggers\G" | grep Trigger: | awk '{print $2}'`
VIEWS=`mysql -h $1 -e "select TABLE_NAME from information_schema.tables where table_schema='$2' and TABLE_TYPE='VIEW'" -sss`
if [ -n "$VIEWS" ]; then
    mysqldump -h $1 $2 $VIEWS > /tmp/${2}_views${TIMESTAMP}.dump
fi
mysqldump -h $1 $2 -d -t -R -E > /tmp/${2}_triggers${TIMESTAMP}.dump
for TRIGGER in $TRIGGERS; do
    echo "drop trigger $TRIGGER"
    mysql -h $1 $2 -e "drop trigger $TRIGGER"
done
for TABLE in $TABLES; do
    echo "rename table $2.$TABLE to $3.$TABLE"
    mysql -h $1 $2 -e "SET FOREIGN_KEY_CHECKS=0; rename table $2.$TABLE to $3.$TABLE"
done
if [ -n "$VIEWS" ]; then
    echo "loading views"
    mysql -h $1 $3 < /tmp/${2}_views${TIMESTAMP}.dump
fi
echo "loading triggers, routines and events"
mysql -h $1 $3 < /tmp/${2}_triggers${TIMESTAMP}.dump
TABLES=`mysql -h $1 -e "select TABLE_NAME from information_schema.tables where table_schema='$2' and TABLE_TYPE='BASE TABLE'" -sss`
if [ -z "$TABLES" ]; then
    echo "Dropping database $2"
    mysql -h $1 $2 -e "drop database $2"
fi
if [ `mysql -h $1 -e "select count(*) from mysql.columns_priv where db='$2'" -sss` -gt 0 ]; then
    COLUMNS_PRIV="    UPDATE mysql.columns_priv set db='$3' WHERE db='$2';"
fi
if [ `mysql -h $1 -e "select count(*) from mysql.procs_priv where db='$2'" -sss` -gt 0 ]; then
    PROCS_PRIV="    UPDATE mysql.procs_priv set db='$3' WHERE db='$2';"
fi
if [ `mysql -h $1 -e "select count(*) from mysql.tables_priv where db='$2'" -sss` -gt 0 ]; then
    TABLES_PRIV="    UPDATE mysql.tables_priv set db='$3' WHERE db='$2';"
fi
if [ `mysql -h $1 -e "select count(*) from mysql.db where db='$2'" -sss` -gt 0 ]; then
    DB_PRIV="    UPDATE mysql.db set db='$3' WHERE db='$2';"
fi
if [ -n "$COLUMNS_PRIV" ] || [ -n "$PROCS_PRIV" ] || [ -n "$TABLES_PRIV" ] || [ -n "$DB_PRIV" ]; then
    echo "IF YOU WANT TO RENAME the GRANTS YOU NEED TO RUN ALL OUTPUT BELOW:"
    if [ -n "$COLUMNS_PRIV" ]; then echo "$COLUMNS_PRIV"; fi
    if [ -n "$PROCS_PRIV" ]; then echo "$PROCS_PRIV"; fi
    if [ -n "$TABLES_PRIV" ]; then echo "$TABLES_PRIV"; fi
    if [ -n "$DB_PRIV" ]; then echo "$DB_PRIV"; fi
    echo "    flush privileges;"
fi

Salvalo in un file chiamato rename_db e rendi eseguibile lo script con chmod +x rename_db quindi ./rename_db localhost old_db new_db come ./rename_db localhost old_db new_db


Passi:

  1. Hit http://localhost/phpmyadmin/
  2. Seleziona il tuo DB
  3. Fare clic sulla scheda Operazioni
  4. Ci sarà una scheda come "Rinomina database in". Aggiungi un nuovo nome e seleziona Regola i privilegi.
  5. Clicca su Vai.


Penso che la soluzione sia più semplice ed è stata suggerita da alcuni sviluppatori. phpMyAdmin ha un'operazione per questo.

Da phpMyAdmin, selezionare il database che si desidera selezionare. Nelle schede ce n'è una chiamata Operazioni, vai alla sezione rinomina. È tutto.

Come molti suggeriscono, crea un nuovo database con il nuovo nome, carica tutte le tabelle del vecchio database nel nuovo database e rilascia il vecchio database.



Puoi usare questo script di shell:

Riferimento: come rinominare un database MySQL?

#!/bin/bash
set -e # terminate execution on command failure

mysqlconn="mysql -u root -proot"
olddb=$1
newdb=$2
$mysqlconn -e "CREATE DATABASE $newdb"
params=$($mysqlconn -N -e "SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES \
                           WHERE table_schema='$olddb'")
for name in $params; do
      $mysqlconn -e "RENAME TABLE $olddb.$name to $newdb.$name";
done;
$mysqlconn -e "DROP DATABASE $olddb"

Sta funzionando:

$ sh rename_database.sh oldname newname

Questo è quello che uso:

$ mysqldump -u root -p olddb >~/olddb.sql
$ mysql -u root -p
mysql> create database newdb;
mysql> use newdb
mysql> source ~/olddb.sql
mysql> drop database olddb;

Solo recentemente mi sono imbattuto in un modo molto carino per farlo, funziona con MyISAM e InnoDB ed è molto veloce:

RENAME TABLE old_db.table TO new_db.table;

Non ricordo dove l'ho letto, ma il merito va a qualcun altro, non a me.


Usa questi pochi semplici comandi:

mysqldump -u username -p -v olddatabase > olddbdump.sql
mysqladmin -u username -p create newdatabase
mysql -u username -p newdatabase < olddbdump.sql

O per ridurre I / O, usa quanto segue come suggerito da @Pablo Marin-Garcia:

mysqladmin -u username -p create newdatabase
mysqldump -u username -v olddatabase -p | mysql -u username -p -D newdatabase

ALTER DATABASEè il modo proposto intorno a questo da MySQL e RENAME DATABASEviene eliminato.

Da documentation :

RENAME {DATABASE | SCHEMA} db_name TO new_db_name;

Questa affermazione è stata aggiunta in MySQL 5.1.7, ma è stata trovata pericolosa ed è stata rimossa in MySQL 5.1.23.


Ecco uno snippet di Bash a una riga per spostare tutte le tabelle da uno schema a un altro:

history -d $((HISTCMD-1)) && mysql -udb_user -p'db_password' -Dold_schema -ABNnqre'SHOW TABLES;' | sed -e's/.*/RENAME TABLE old_schema.`&` TO new_schema.`&`;/' | mysql -udb_user -p'db_password' -Dnew_schema

Il comando history all'inizio garantisce semplicemente che i comandi MySQL contenenti password non vengano salvati nella cronologia shell.

Assicurarsi di db_useravere autorizzazioni di lettura / scrittura / rilascio sul vecchio schema e autorizzazioni di lettura / scrittura / creazione sul nuovo schema.


In MySQL Administrator fai quanto segue:

  1. Sotto Cataloghi, crea un nuovo schema di database.
  2. Vai a Backup e crea un backup del vecchio schema.
  3. Esegui backup.
  4. Vai a Ripristina e apri il file creato nel passaggio 3.
  5. Selezionare 'Altro schema' in Schema di destinazione e selezionare il nuovo schema del database.
  6. Avvia ripristino.
  7. Verificare il nuovo schema e, se sembra buono, cancellare quello vecchio.

Ho posto una domanda su Server Fault cercando di evitare tempi di inattività durante il ripristino di database di grandi dimensioni utilizzando MySQL Proxy. Non ho avuto alcun successo, ma alla fine ho capito che volevo usare la funzionalità RENAME DATABASE perché dump / import non era un'opzione a causa delle dimensioni del nostro database.

C'è una funzionalità RENAME TABLE integrata in MySQL quindi ho finito per scrivere un semplice script Python per fare il lavoro per me. L'ho pubblicato su GitHub nel caso in cui potrebbe essere utile agli altri.


Il metodo più semplice è usare il software HeidiSQL. È gratuito e open source. Funziona su Windows e su qualsiasi Linux con Wine (esegui applicazioni Windows su Linux, BSD, Solaris e Mac OS X).

Per scaricare HeidiSQL, vai a http://www.heidisql.com/download.php .

Per scaricare Wine, vai a http://www.winehq.org/ .

Per rinominare un database in HeidiSQL, è sufficiente fare clic con il pulsante destro del mouse sul nome del database e selezionare "Modifica". Quindi inserire un nuovo nome e premere 'OK'.

È così semplice


La procedura memorizzata di TodoInTX non ha funzionato per me. Ecco la mia pugnalata:

-- stored procedure rename_db: Rename a database my means of table copying.
-- Caveats: 
-- Will clobber any existing database with the same name as the 'new' database name.
-- ONLY copies tables; stored procedures and other database objects are not copied.
-- Tomer Altman ([email protected])

delimiter //
DROP PROCEDURE IF EXISTS rename_db;
CREATE PROCEDURE rename_db(IN old_db VARCHAR(100), IN new_db VARCHAR(100))
BEGIN
    DECLARE current_table VARCHAR(100);
    DECLARE done INT DEFAULT 0;
    DECLARE old_tables CURSOR FOR select table_name from information_schema.tables where table_schema = old_db;
    DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = 1;

    SET @output = CONCAT('DROP SCHEMA IF EXISTS ', new_db, ';'); 
    PREPARE stmt FROM @output;
    EXECUTE stmt;

    SET @output = CONCAT('CREATE SCHEMA IF NOT EXISTS ', new_db, ';');
    PREPARE stmt FROM @output;
    EXECUTE stmt;

    OPEN old_tables;
    REPEAT
        FETCH old_tables INTO current_table;
        IF NOT done THEN
        SET @output = CONCAT('alter table ', old_db, '.', current_table, ' rename ', new_db, '.', current_table, ';');
        PREPARE stmt FROM @output;
        EXECUTE stmt;

        END IF;
    UNTIL done END REPEAT;

    CLOSE old_tables;

END//
delimiter ;

Se si utilizza phpMyAdmin è possibile accedere alla scheda "operazioni" dopo aver selezionato il database che si desidera rinominare. Poi vai all'ultima sezione "copia database in" (o qualcosa del genere), dai un nome e seleziona le opzioni di seguito. In questo caso, suppongo che devi selezionare le caselle di controllo "struttura e dati" e "crea il database prima di copiare" e, infine, premere il pulsante "vai" in quella sezione.

A proposito, sto usando phpMyAdmin in spagnolo, quindi non sono sicuro di quali siano i nomi delle sezioni in inglese.





rename