Il manuale MySQL su 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;
fa cose cattive, esiste solo in una manciata di versioni e nel complesso è una cattiva idea .
Questo deve funzionare con InnoDB , che memorizza le cose in modo molto diverso rispetto a MyISAM .
Per InnoDB, sembra funzionare quanto segue: creare il nuovo database vuoto, quindi rinominare ogni tabella a sua volta nel nuovo database:
RENAME TABLE old_db.table TO new_db.table;
Dopo questo dovrai modificare le autorizzazioni.
Per lo scripting in una shell, è possibile utilizzare uno dei seguenti:
mysql -u username -ppassword old_db -sNe 'show tables' | while read table; \
do mysql -u username -ppassword -sNe "rename table old_db.$table to new_db.$table"; done
O
for table in `mysql -u root -ppassword -s -N -e "use old_db;show tables from old_db;"`; do mysql -u root -ppassword -s -N -e "use old_db;rename table old_db.$table to new_db.$table;"; done;
Gli appunti:
-p
e la password. Se il tuo database non ha password, rimuovi la parte -u username -ppassword
.Se alcune tabelle hanno un trigger, non possono essere spostate in un altro database usando il metodo sopra (risulterà errore Trigger in wrong schema
). In tal caso, utilizzare un metodo tradizionale per clonare un database e quindi eliminare quello vecchio:
mysqldump old_db | mysql new_db
Se hai memorizzato le procedure, puoi copiarle in seguito:
mysqldump -R old_db | mysql new_db
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
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.
È possibile utilizzare SQL per generare uno script SQL per trasferire ciascuna tabella nel database di origine nel database di destinazione.
È necessario creare il database di destinazione prima di eseguire lo script generato dal comando.
Puoi utilizzare uno di questi due script (inizialmente ho suggerito il primo e qualcuno ha "migliorato" la mia risposta per utilizzare GROUP_CONCAT
. Fai la tua scelta, ma preferisco l'originale):
SELECT CONCAT('RENAME TABLE $1.', table_name, ' TO $2.', table_name, '; ')
FROM information_schema.TABLES
WHERE table_schema='$1';
o
SELECT GROUP_CONCAT('RENAME TABLE $1.', table_name, ' TO $2.', table_name SEPARATOR '; ')
FROM information_schema.TABLES
WHERE table_schema='$1';
($ 1 e $ 2 sono rispettivamente fonte e obiettivo)
Questo genererà un comando SQL che dovrai poi eseguire.
Si noti che GROUP_CONCAT
ha un limite di lunghezza predefinito che può essere superato per i database con un numero elevato di tabelle. È possibile modificare tale limite eseguendo SET SESSION group_concat_max_len = 100000000;
(o qualche altro grande numero).
Emulazione del comando RENAME DATABASE
mancante in MySQL:
Creare le query di rinomina con:
SELECT CONCAT('RENAME TABLE ',table_schema,'.',table_name,
' TO ','new_schema.',table_name,';')
FROM information_schema.TABLES
WHERE table_schema LIKE 'old_schema';
Esegui quell'output
È stato preso da Emulazione del comando RINAME DATABASE mancante in MySQL.
Tre opzioni:
Crea il nuovo database, abbassa il server, sposta i file da una cartella di database all'altra e riavvia il server. Nota che questo funzionerà solo se TUTTE le tue tabelle sono MyISAM.
Creare il nuovo database, utilizzare le istruzioni CREATE TABLE ... LIKE e quindi utilizzare le istruzioni INSERT ... SELECT * FROM.
Usa mysqldump e ricarica con quel file.
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.
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.
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;
Il modo più semplice di eseguire un completo rinominato (compreso 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:
MySQL non supporta la ridenominazione di un database tramite la sua interfaccia di comando al momento, ma è possibile rinominare il database se si ha accesso alla directory in cui MySQL memorizza i propri database. Per le installazioni MySQL predefinite questo di solito si trova nella directory Data nella directory in cui è stato installato MySQL. Individuare il nome del database che si desidera rinominare nella directory dei dati e rinominarlo. Rinominare la directory potrebbe tuttavia causare alcuni problemi di autorizzazione. Sii consapevole.
Nota: È necessario interrompere MySQL prima di poter rinominare il database
Consiglierei di creare un nuovo database (usando il nome che si desidera) ed esportare/importare i dati necessari dal vecchio al nuovo. Abbastanza semplice.
Quando si rinomina un database in PHPMyAdmin si crea un dump, quindi si elimina e ricrea il database con il nuovo nome.
Bene, ci sono 2 metodi:
Metodo 1: Un metodo ben noto per rinominare lo schema del database è scaricare lo schema utilizzando Mysqldump e ripristinarlo in un altro schema, quindi rilasciare 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 è più di un 100 GB? Ci sono metodi in cui è possibile reindirizzare insieme i comandi sopra riportati per risparmiare spazio, tuttavia non si risparmia tempo .
Per rimediare a tali situazioni, esiste un altro metodo rapido per rinominare gli schemi, tuttavia è necessario prestare particolare attenzione durante l'esecuzione.
Metodo 2: MySQL ha un'ottima funzionalità 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 ciò 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) Rilascia i trigger nelle tabelle correnti in old_schema.
mysql> DROP TRIGGER <trigger_name>;
...
5) Ripristina 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 volta successiva.
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. Proverà a 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 è usato sopra 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
Per coloro che sono utenti Mac, Sequel Pro ha un'opzione Rinomina database nel menu Database. http://www.sequelpro.com/
È possibile rinominare tutte le tabelle di un database in un altro database senza dover eseguire il dump e il ripristino completi.
PROCEDURA DROP SE ESISTE mysql.rename_db; DELIMITER || CREATE PROCEDURE mysql.rename_db (IN old_db VARCHAR (100), IN new_db VARCHAR (100)) BEGIN SELEZIONA CONCAT ('CREATE DATABASE', new_db, ';') `# crea un nuovo database`; SELEZIONA 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 "chiama 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 "chiama mysql.rename_db ('test', 'blah2');" | mysql -uroot ERRORE 1435 (HY000) alla riga 4: Trigger nello schema errato
La maggior parte delle risposte qui sono sbagliate per uno dei due motivi:
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 usalo come ./rename_db localhost old_db new_db
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=
La procedura memorizzata di TodoInTX non ha funzionato per me. Ecco la mia pugnalata:
- stored procedure rename_db: Rinomina un database come mezzo di copia delle tabelle. - Avvertenze: - Clobber qualsiasi database esistente con lo stesso nome del "nuovo" nome del database. - Copia solo le tabelle; le stored procedure e altri oggetti di database non vengono copiati. - Tomer Altman ([email protected]) delimitatore // PROCEDURA DI DROP SE ESISTE rename_db; CREATE PROCEDURE rename_db (IN old_db VARCHAR (100), IN new_db VARCHAR (100)) BEGIN DECLARE current_table VARCHAR (100); DECLARE fatto INT DEFAULT 0; DECLARE old_tables CURSOR PER selezionare table_name da information_schema.tables dove table_schema = old_db; DECLARE CONTINUA HANDLER PER NOT FOUND SET done = 1; SET @output = CONCAT ('DROP SCHEMA SE ESISTE', new_db, ';'); PREPARA stmt FROM @output; ESEGUI stmt; SET @output = CONCAT ('CREA SCHEMA SE NON ESISTE', new_db, ';'); PREPARA 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, 'rinomina', new_db, '.', Current_table, ';'); PREPARA stmt FROM @output; ESEGUI stmt; FINE SE; FINO A FINE RIPETIZIONE; CHIUDI old_tables; END // Delimiter;
Passi:
Per comodità, di seguito è riportato un piccolo script che deve essere eseguito con due parametri: nome-db e nuovo nome-db.
Potrebbe essere necessario aggiungere parametri di login alle linee mysql se non si utilizza il file .my.cnf nella propria directory home. Si prega di fare un backup prima di eseguire questo script.
#!/usr/bin/env bash
mysql -e "CREATE DATABASE $2 DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;"
for i in $(mysql -Ns $1 -e "show tables");do
echo "$1.$i -> $2.$i"
mysql -e "rename TABLE $1.$i to $2.$i"
done
mysql -e "DROP DATABASE $1"
I ha posto una domanda su Server Fault cercando di aggirare i tempi di inattività durante il ripristino di database molto grandi usando 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. Ho pubblicato su GitHub nel caso in cui potrebbe essere utile agli altri.
Il metodo più semplice è utilizzare il software HeidiSQL. È gratuito e open source. Funziona su Windows e su qualsiasi Linux con Wine (esegue applicazioni Windows su Linux, BSD, Solaris e Mac OS X).
Per scaricare HeidiSQL, goto http://www.heidisql.com/download.php .
Per scaricare Wine, goto 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.
Ecco un modo rapido per generare lo script di rinomina sql, se hai molte tabelle da spostare.
SELECT DISTINCT CONCAT('RENAME TABLE ', t.table_schema,'.', t.table_name, ' TO ',
t.table_schema, "_archive", '.', t.table_name, ';' ) as Rename_SQL
FROM information_schema.tables t
WHERE table_schema='your_db_name' ;
Sembra nessuno ha menzionato questo, ma qui è un altro modo:
create database NewDatabaseName like OldDatabaseName;
quindi per ogni tabella:
create NewDatabaseName.tablename like OldDatabaseName.tablename;
insert into NewDataBaseName.tablename select * from OldDatabaseName.tablename;
allora, se vuoi,
drop database OldDatabaseName;
Questo approccio avrebbe il vantaggio di eseguire l'intero trasferimento sul server con un traffico di rete quasi zero, quindi andrà molto più veloce di un dump/restore.
Se hai memorizzato procedure/viste/ecc. Potresti volerli trasferire anche tu.
Per gli utenti Mac, è possibile utilizzare Sequel Pro
(gratuito), che fornisce solo l'opzione per rinominare i database. Sebbene non cancelli il vecchio DB.
una volta aperto il DB pertinente clicca semplicemente: Database
-> Rename database...
In MySQL Administrator fai quanto segue:
in phpmyadmin puoi facilmente rinominare il database
select database
goto operations tab
in that rename Database to :
type your new database name and click go
chiedere di eliminare la tabella vecchia e ricaricare i dati della tabella, fare clic su OK in entrambi
Il tuo database è stato rinominato
Se stai usando phpMyAdmin puoi andare alla scheda "operazioni" una volta selezionato il database che vuoi 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.
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 di Shell.
Assicurati che db_user
abbia permessi di lettura/scrittura/rilascio sul vecchio schema e leggi/scrivi/crea permessi sul nuovo schema.
L'ho fatto in questo modo: prendi il backup del tuo database esistente. Vi darà un db.Zip.tmp e poi nel comando Prompt scriverà in seguito
"C:\Programmi (x86)\MySQL\MySQL Server 5.6\bin\mysql.exe" -h localhost -u root -p [password] [nuovo nome db] <"C:\Backups\db.Zip.tmp "
Puoi farlo in due modi.
Questo è lo script batch che ho scritto per rinominare un database su Windows:
@echo off
set olddb=olddbname
set newdb=newdbname
SET count=1
SET act=mysql -uroot -e "select table_name from information_schema.tables where table_schema='%olddb%'"
mysql -uroot -e "create database %newdb%"
echo %act%
FOR /f "tokens=*" %%G IN ('%act%') DO (
REM echo %count%:%%G
echo mysql -uroot -e "RENAME TABLE %olddb%.%%G to %newdb%.%%G"
mysql -uroot -e "RENAME TABLE %olddb%.%%G to %newdb%.%%G"
set /a count+=1
)
mysql -uroot -e "drop database %olddb%"
ALTER DATABASE
è il modo proposto intorno a questo da MySQL e RENAME DATABASE
viene eliminato.
Da 13.1.32 RENAME DATABASE Sintassi:
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.
Funziona su tutti i database e funziona rinominando ogni tabella con maatkit mysql toolkit
Usa mk-find per stampare e rinominare ogni tabella. La pagina man ha molte più opzioni ed esempi
mk-find --dblike OLD_DATABASE --print --exec "RENAME TABLE %D.%N TO NEW_DATABASE.%N"
Se hai installato maatkit ( che è molto facile ), allora questo è il modo più semplice per farlo.
Nel caso in cui si inizi da un file di dump con diversi database, è possibile eseguire un sed sulla discarica:
sed -i -- "s|old_name_database1|new_name_database1|g" my_dump.sql
sed -i -- "s|old_name_database2|new_name_database2|g" my_dump.sql
...
Quindi importa la tua discarica. Assicurati solo che non ci sia un conflitto di nomi.
Né la soluzione TodoInTx né la soluzione adattata di user757945 hanno funzionato per me su MySQL 5.5.16, quindi ecco la mia versione adattata:
DELIMITER //
DROP PROCEDURE IF EXISTS `rename_database`;
CREATE PROCEDURE `rename_database` (IN `old_name` VARCHAR(20), IN `new_name` VARCHAR(20))
BEGIN
DECLARE `current_table_name` VARCHAR(20);
DECLARE `done` INT DEFAULT 0;
DECLARE `table_name_cursor` CURSOR FOR SELECT `table_name` FROM `information_schema`.`tables` WHERE (`table_schema` = `old_name`);
DECLARE CONTINUE HANDLER FOR NOT FOUND SET `done` = 1;
SET @sql_string = CONCAT('CREATE DATABASE IF NOT EXISTS `', `new_name` , '`;');
PREPARE `statement` FROM @sql_string;
EXECUTE `statement`;
DEALLOCATE PREPARE `statement`;
OPEN `table_name_cursor`;
REPEAT
FETCH `table_name_cursor` INTO `current_table_name`;
IF NOT `done` THEN
SET @sql_string = CONCAT('RENAME TABLE `', `old_name`, '`.`', `current_table_name`, '` TO `', `new_name`, '`.`', `current_table_name`, '`;');
PREPARE `statement` FROM @sql_string;
EXECUTE `statement`;
DEALLOCATE PREPARE `statement`;
END IF;
UNTIL `done` END REPEAT;
CLOSE `table_name_cursor`;
SET @sql_string = CONCAT('DROP DATABASE `', `old_name`, '`;');
PREPARE `statement` FROM @sql_string;
EXECUTE `statement`;
DEALLOCATE PREPARE `statement`;
END//
DELIMITER ;
Spero che aiuti qualcuno che è nella mia situazione! Nota: @sql_string
permarrà nella sessione successiva. Non ero in grado di scrivere questa funzione senza usarla.
Ho usato il seguente metodo per rinominare il database
eseguire il backup del file utilizzando mysqldump o qualsiasi strumento DB, ad es. heidiSQL, amministratore mysql ecc
Aprire il file di backup (ad esempio backupfile.sql) in un editor di testo.
Cerca e sostituisci il nome del database e salva il file.
4. Ripristinare il file sql modificato
Se si utilizzano viste gerarchiche (viste che estraggono dati da altre viste), l'importazione di output non elaborato da mysqldump potrebbe non funzionare poiché a mysqldump non interessa l'ordine delle viste corretto. Per questo motivo ho scritto script che riordina le viste per correggere l'ordine al volo.
Sembra così:
#!/usr/bin/env Perl
use List::MoreUtils 'first_index'; #apt package liblist-moreutils-Perl
use strict;
use warnings;
my $views_sql;
while (<>) {
$views_sql .= $_ if $views_sql or index($_, 'Final view structure') != -1;
print $_ if !$views_sql;
}
my @views_regex_result = ($views_sql =~ /(\-\- Final view structure.+?\n\-\-\n\n.+?\n\n)/msg);
my @views = (join("", @views_regex_result) =~ /\-\- Final view structure for view `(.+?)`/g);
my $new_views_section = "";
while (@views) {
foreach my $view (@views_regex_result) {
my $view_body = ($view =~ /\/\*.+?VIEW .+ AS (select .+)\*\/;/g )[0];
my $found = 0;
foreach my $view (@views) {
if ($view_body =~ /(from|join)[ \(]+`$view`/) {
$found = $view;
last;
}
}
if (!$found) {
print $view;
my $name_of_view_which_was_not_found = ($view =~ /\-\- Final view structure for view `(.+?)`/g)[0];
my $index = first_index { $_ eq $name_of_view_which_was_not_found } @views;
if ($index != -1) {
splice(@views, $index, 1);
splice(@views_regex_result, $index, 1);
}
}
}
}
Uso:mysqldump -u username -v olddatabase -p | ./mysqldump_view_reorder.pl | mysql -u username -p -D newdatabase
Voi ragazzi mi sparerete per questo, e molto probabilmente questo non funzionerà ogni volta, e certo, è contro ogni logica bla bla ... Ma quello che ho appena provato è ... ARRESTARE il motore MySQL, accedere come root e semplicemente rinominato il DB a livello di file system ....
Sono su OSX e ho cambiato solo il caso, da bedbf a BEDBF. Con mia sorpresa ha funzionato ...
Non lo consiglierei su un DB di produzione. Ho appena provato questo come un esperimento ...
Buona fortuna in entrambi i casi :-)
Ho postato questo Come cambio il nome del database usando MySQL? oggi dopo giorni di grattarsi la testa e tirare i capelli. La soluzione è abbastanza semplice esportare uno schema in un file .sql e aprire il file e modificare il nome del database/schema nella sezione sql CREAT TABLE in alto. Ci sono tre istanze o più e potrebbe non essere nella parte superiore della pagina se gli schemi multi-blocco sono salvati nel file. È possibile modificare l'intero database in questo modo, ma mi aspetto che nei database di grandi dimensioni possa essere un problema seguire tutte le istanze di una proprietà o di un indice di una tabella.
I). Non c'è modo diretto in cui è possibile modificare il nome di un DB esistente, ma è possibile raggiungere il target seguendo i seguenti passaggi: - 1). Crea newdb. 2). Usa newdb. 3). crea tabella nome_tabella (seleziona * da olddb.table_name);
Effettuando sopra, copiare i dati dalla tabella di olddb e inserirli nella tabella newdb. Dare il nome del tavolo stesso.
II). RENAME TABLE old_db.table_name TO new_db.table_name;