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

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:

1. Crea un nuovo database

2. 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';
   

3. Esegui quell'output

4. Elimina il vecchio database

È stato preso da Emulazione del comando RINAME DATABASE mancante in MySQL.

Tre opzioni:

1. 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.

2. Creare il nuovo database, utilizzare le istruzioni CREATE TABLE ... LIKE e quindi utilizzare le istruzioni INSERT ... SELECT * FROM.

3. Usa mysqldump e ricarica con quel file.

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.

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:

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

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:

1. Non puoi semplicemente 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 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:

1. Hit http: // localhost/phpmyadmin/
2. Seleziona il tuo DB
3. Fai 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.

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:

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.

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.

1. RENAME TABLE old_db.table_name TO new_db.table_name;
2. Vai alle operazioni-> lì puoi vedere la scheda Opzioni tabella. puoi modificare il nome della tabella lì.

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

1. eseguire il backup del file utilizzando mysqldump o qualsiasi strumento DB, ad es. heidiSQL, amministratore mysql ecc

2. Aprire il file di backup (ad esempio backupfile.sql) in un editor di testo.

3. 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;