¿Cómo puedo cambiar rápidamente el nombre de una base de datos MySQL (cambiar el nombre del esquema)?

Utilice estos pocos comandos simples:

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

O para reducir la E/S, use lo siguiente como lo sugiere @Pablo Marin-Garcia:

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

Creo que la solución es más simple y fue sugerida por algunos desarrolladores. phpMyAdmin tiene una operación para esto.

Desde phpMyAdmin, seleccione la base de datos que desea seleccionar. En las pestañas hay una llamada Operaciones, vaya a la sección de cambio de nombre. Eso es todo.

Como muchos sugieren, crea una nueva base de datos con el nuevo nombre, vuelca todas las tablas de la antigua base de datos en la nueva base de datos y elimina la antigua.

Puede usar SQL para generar un script SQL para transferir cada tabla en su base de datos de origen a la base de datos de destino.

Debe crear la base de datos de destino antes de ejecutar el script generado a partir del comando.

Puede usar cualquiera de estos dos scripts (originalmente sugerí el primero y alguien "mejoró" mi respuesta para usar GROUP_CONCAT. Elija su opción, pero prefiero el original):

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 y $ 2 son fuente y destino respectivamente)

Esto generará un comando SQL que tendrás que ejecutar.

Tenga en cuenta que GROUP_CONCAT tiene un límite de longitud predeterminado que puede excederse para las bases de datos con una gran cantidad de tablas. Puede modificar ese límite ejecutando SET SESSION group_concat_max_len = 100000000; (o algún otro número grande).

Emulando el comando RENAME DATABASE que falta en MySQL:

1. Crear una nueva base de datos

2. Crea las consultas de cambio de nombre 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. Ejecutar esa salida

4. Eliminar base de datos antigua

Se tomó deEmulando el comando faltante RENAME DATABASE en MySQL.

Tres opciones:

1. Cree la nueva base de datos, desactive el servidor, mueva los archivos de una carpeta de base de datos a la otra y reinicie el servidor. Tenga en cuenta que esto solo funcionará si TODAS sus tablas son MyISAM.

2. Cree la nueva base de datos, use las sentencias CREATE TABLE ... LIKE y luego use las sentencias INSERT ... SELECT * FROM.

3. Usa mysqldump y vuelve a cargar con ese archivo.

La forma sencilla

Cambie al directorio de la base de datos:

cd /var/lib/mysql/

Apaga MySQL ... ¡Esto es importante!

/etc/init.d/mysql stop

De acuerdo, esta manera no funciona para InnoDB o BDB-Databases.

Renombrar base de datos:

mv old-name new-name

... o la mesa ...

cd database/

mv old-name.frm new-name.frm

mv old-name.MYD new-name.MYD

mv old-name.MYI new-name.MYI

Reiniciar MySQL

/etc/init.d/mysql start

Hecho...

OK, de esta manera no funciona con bases de datos InnoDB o BDB. En este caso, debe volcar la base de datos y volver a importarla.

Recientemente he encontrado una muy buena forma de hacerlo, funciona con MyISAM e InnoDB y es muy rápido:

RENAME TABLE old_db.table TO new_db.table;

No recuerdo dónde lo leí, pero el crédito es para alguien que no soy yo.

Puedes usar este script de shell:

Referencia: ¿Cómo cambiar el nombre de una base de datos 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"

Esta funcionando:

$ sh rename_database.sh oldname newname

Esto es lo que 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;

La forma más simple de realizar un bullet-tonto a prueba de hacer/- complete rename (incluyendo eliminar la base de datos antigua al final, así es un cambio de nombre en lugar de una copia)

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

Pasos:

1. Copia las líneas en el Bloc de notas.
2. Reemplace todas las referencias a "olddbname", "newdbname", "mypassword" (+ opcionalmente "root") con sus equivalentes.
3. Ejecute uno por uno en la línea de comandos (ingrese "y" cuando se le solicite).

MySQL no admite el cambio de nombre de una base de datos a través de su interfaz de comandos en este momento, pero puede cambiar el nombre de la base de datos si tiene acceso al directorio en el que MySQL almacena sus bases de datos. Para las instalaciones de MySQL predeterminadas, esto generalmente se encuentra en el directorio de datos debajo del directorio donde se instaló MySQL. Localice el nombre de la base de datos que desea cambiar de nombre en el directorio de datos y cámbiele el nombre. Sin embargo, cambiar el nombre del directorio podría causar algunos problemas de permisos. Estar atentos.

Nota: Debe detener MySQL antes de poder cambiar el nombre de la base de datos

Recomendaría crear una nueva base de datos (con el nombre que desee) y exportar/importar los datos que necesita de lo antiguo a lo nuevo. Bastante simple.

Cuando cambia el nombre de una base de datos en PHPMyAdmin, crea un volcado, luego cae y vuelve a crear la base de datos con el nuevo nombre.

Bueno, hay 2 métodos:

Método 1: Un método conocido para cambiar el nombre del esquema de la base de datos es volcar el esquema usando Mysqldump y restaurarlo en otro esquema, y ​​luego quitar el esquema antiguo (si es necesario).

De concha

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

Aunque el método anterior es fácil, consume tiempo y espacio. ¿Qué pasa si el esquema es más que un 100GB? Hay métodos en los que puede agrupar los comandos anteriores para ahorrar espacio, sin embargo, no ahorrará tiempo.

Para remediar tales situaciones, existe otro método rápido para cambiar el nombre de los esquemas, sin embargo, se debe tener cuidado al hacerlo.

Método 2: MySQL tiene una muy buena característica para cambiar el nombre de las tablas que incluso funciona en diferentes esquemas. Esta operación de cambio de nombre es atómica y nadie más puede acceder a la tabla mientras se le cambia el nombre. Esto toma poco tiempo para completarse, ya que cambiar el nombre de una tabla o su esquema es solo un cambio de metadatos. Aquí está el enfoque de procedimiento para hacer el cambio de nombre:

Cree el nuevo esquema de base de datos con el nombre deseado. Cambie el nombre de las tablas del esquema antiguo al esquema nuevo, usando el comando "RENAME TABLE" de MySQL. Suelte el esquema de base de datos anterior. If there are views, triggers, functions, stored procedures in the schema, those will need to be recreated too. "RENAME TABLE" de MySQL falla si hay activadores en las tablas. Para remediar esto podemos hacer las siguientes cosas:

1) Dump the triggers, events and stored routines in a separate file. Esto se hace usando los indicadores -E, -R (además de -t -d que vuelca los activadores) al comando mysqldump. Una vez que se descarguen los activadores, tendremos que eliminarlos del esquema para que funcione el comando RENAME TABLE.

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

2) Genera una lista de solo tablas "BASE". Estos se pueden encontrar utilizando una consulta en la tabla information_schema.TABLES.

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

3) Volcar las vistas en un archivo de salida. Las vistas se pueden encontrar utilizando una consulta en la misma tabla 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) Soltar los desencadenantes en las tablas actuales en el esquema antiguo.

mysql> DROP TRIGGER <trigger_name>;
...

5) Restaura los archivos de volcado anteriores una vez que todas las tablas "Base" encontradas en el paso # 2 cambian de nombre.

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

Intrincaciones con los métodos anteriores: es posible que tengamos que actualizar los GRANTS para los usuarios para que coincidan con el nombre de esquema correcto. Estos podrían solucionarse con una ACTUALIZACIÓN simple en mysql.columns_priv, mysql.procs_priv, mysql.tables_priv, mysql.db actualizando el nombre old_schema a new_schema y llamando a "Privilegios de Descarga". Aunque el "método 2" parece un poco más complicado que el "método 1", esto es totalmente programable. Una secuencia de comandos bash simple para llevar a cabo los pasos anteriores en la secuencia correcta, puede ayudarlo a ahorrar espacio y tiempo al cambiar el nombre de los esquemas de la base de datos la próxima vez.

El equipo de DBA de Percona Remote ha escrito un script llamado "rename_db" que funciona de la siguiente manera:

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

Para demostrar el uso de este script, se utilizó un esquema de muestra "emp", se crearon activadores de prueba, se almacenaron rutinas en ese esquema. Intentará cambiar el nombre del esquema de la base de datos mediante la secuencia de comandos, que tarda unos segundos en completarse en lugar de llevar a cabo el método de volcado/restauración.

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               |
+--------------------+

Como puede ver en la salida anterior, el esquema de la base de datos "emp" cambió su nombre a "emp_test" en menos de un segundo. Por último, este es el script de Percona que se usa anteriormente para el "método 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

Para aquellos que son usuarios de Mac, Sequel Pro tiene una opción Cambiar nombre de base de datos en el menú Base de datos. http://www.sequelpro.com/

Es posible cambiar el nombre de todas las tablas dentro de una base de datos para que estén debajo de otra base de datos sin tener que hacer un volcado completo y restaurar.

 DROP PROCEDIMIENTO SI EXISTE mysql.rename_db; 
 DELIMITER || 
 CREAR PROCEDIMIENTO mysql.rename_db (IN old_db VARCHAR (100), IN new_db VARCHAR (100)) 
 COMIENCE 
 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 

Sin embargo, cualquier desencadenante en la base de datos de destino no será feliz. Deberá soltarlos primero y luego volver a crearlos después del cambio de nombre.

 mysql -uroot -e "call mysql.rename_db ('prueba', 'blah2');" | mysql -uroot 
 ERROR 1435 (HY000) en la línea 4: Disparo en esquema incorrecto 

La mayoría de las respuestas aquí son incorrectas por una de dos razones:

1. No puedes usar RENAME TABLE, porque puede haber vistas y disparadores. Si hay disparadores, la tabla de nombres falla
2. No puede usar mysqldump si desea "rápidamente" (como se solicita en la pregunta) cambiar el nombre de una base de datos grande

Percona tiene una publicación en el blog sobre cómo hacer esto bien: https://www.percona.com/blog/2013/12/24/renaming-database-schema-mysql/

y el script publicado (hecho?) por Simon R Jones que hace lo que se sugiere en ese post. He arreglado un error que encontré en el script. Puedes verlo aqui:

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

Aquí está una copia de ella:

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

Guárdelo en un archivo llamado rename_db y haga que el script sea ejecutable con chmod +x rename_db luego utilícelo como ./rename_db localhost old_db new_db

Aquí hay un archivo por lotes que escribí para automatizarlo desde la línea de comandos, pero para Windows/MS-DOS.

La sintaxis es rename_mysqldb base de datos newdatabase -u [usuario] -p [contraseña]

:: ***************************************************************************
:: 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=

El procedimiento almacenado de TodoInTX no me funcionó del todo. Aquí está mi puñalada:

 - procedimiento almacenado rename_db: Renombrar una base de datos mis medios para copiar tablas. 
 - Advertencias: 
 - Obstruirá cualquier base de datos existente con el mismo nombre que la "nueva" nombre de la base de datos. 
 - SOLO copia tablas; los procedimientos almacenados y otros objetos de la base de datos no se copian. 
 - Tomer Altman ([email protected]) 
 
 delimitador //[.____.◆SOLECCIONE EL PROCEDIMIENTO SI EXISTE rename_db; 
 CREAR PROCEDIMIENTO 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 donde table_schema = old_db; 
 DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = 1; 
 
 SET @output = CONCAT ('DROP SCHEMA IF EXISTS', new_db, ';'); 
 PREPARAR ststt DE @output; 
 EJECUTAR stmt; 
 
 SET @output = CONCAT ('CREATE SCHEMA IF NOT EXISTS', new_db, ';'); 
 PREPARAR ststt DESDE @output; 
 EJECUTAR stmt; 
 
 OPEN old_tables; 
 REPEAT 
 FETCH old_tables EN current_table; 
 ____.] SI NO SE HACE ENTONCES 
 SET @output = CONCAT ('alter table', old_db, '.', Current_table, 'rename', new_db, '.', Current_table, ';'); 
 PREPARACIÓN DE LA PIEZA DESDE @output; 
 EJECUTAR stmt; 
 
 FIN SI; 
 HASTA HACER REPETIR; 
 
 CERRAR old_tables; 
 
 END // icono delimitador [...]. 

Para su comodidad, a continuación hay un pequeño shellscript que debe ejecutarse con dos parámetros: db-name y new db-name.

Es posible que deba agregar parámetros de inicio de sesión a las líneas mysql si no usa el archivo .my.cnf en su directorio de inicio. Por favor haga una copia de seguridad antes de ejecutar este 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 formuló una pregunta en Server Fault tratando de evitar el tiempo de inactividad al restaurar bases de datos muy grandes mediante el uso del proxy de MySQL. No tuve ningún éxito, pero al final me di cuenta de que lo que quería era la funcionalidad RENAME DATABASE porque dump/import no era una opción debido al tamaño de nuestra base de datos.

Hay una funcionalidad de RENAME TABLE incorporada en MySQL, por lo que terminé escribiendo un simple script de Python para hacer el trabajo por mí. He publicado en GitHub en caso de que pueda ser de utilidad para otros.

Pasos

1. Pulse http: // localhost/phpmyadmin/
2. Seleccione su DB
3. Haga clic en la pestaña Operaciones
4. Habrá una pestaña como "Cambiar el nombre de la base de datos a". Agregar nuevo nombre y verificar Ajustar privilegios.
5. Haga clic en Ir.

El método más simple es usar el software HeidiSQL. Es gratis y de código abierto. Se ejecuta en Windows y en cualquier Linux con Wine (ejecuta aplicaciones de Windows en Linux, BSD, Solaris y Mac OS X).

Para descargar HeidiSQL, goto http://www.heidisql.com/download.php .

Para descargar Wine, goto http://www.winehq.org/ .

Para cambiar el nombre de una base de datos en HeidiSQL, simplemente haga clic derecho en el nombre de la base de datos y seleccione 'Editar'. Luego ingrese un nuevo nombre y presione 'OK'.

Es tan simple.

Esta es una forma rápida de generar un script de cambio de nombre de SQL, si tiene muchas tablas para mover.

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

Parece que nadie mencionó esto pero aquí hay otra manera:

create database NewDatabaseName like OldDatabaseName;

entonces para cada tabla haz:

create NewDatabaseName.tablename like OldDatabaseName.tablename;
insert into NewDataBaseName.tablename select * from OldDatabaseName.tablename;

entonces, si quieres,

drop database OldDatabaseName;

Este enfoque tendría la ventaja de realizar la transferencia completa en el servidor con un tráfico de red casi cero, por lo que irá mucho más rápido que un volcado/restauración.

Si tiene procedimientos/vistas/etc almacenados, es posible que también desee transferirlos.

Para usuarios de mac, puede usar Sequel Pro (gratis), que solo brinda la opción de cambiar el nombre de las bases de datos. Aunque no borra el antiguo DB.

una vez que abra la base de datos relevante, haga clic en: Database -> Rename database...

En MySQL Administrator haga lo siguiente:

1. En Catálogos, crea un nuevo esquema de base de datos.
2. Vaya a Copia de seguridad y cree una copia de seguridad del esquema anterior.
3. Ejecutar copia de seguridad.
4. Vaya a Restaurar y abra el archivo creado en el paso 3.
5. Seleccione 'Otro esquema' en Esquema de destino y seleccione el nuevo esquema de base de datos.
6. Iniciar la restauración.
7. Verifique el nuevo esquema y, si se ve bien, elimine el anterior.

en phpmyadmin puedes cambiar fácilmente el nombre de la base de datos

select database 

  goto operations tab

  in that rename Database to :

  type your new database name and click go

pedir que se descarte la tabla antigua y que se vuelvan a cargar los datos de la tabla, haga clic en Aceptar en ambos

Su base de datos ha cambiado de nombre

Si está utilizando phpMyAdmin puede ir a la pestaña "operaciones" una vez que haya seleccionado la base de datos a la que desea cambiar el nombre. Luego vaya a la última sección "copiar base de datos a" (o algo así), dé un nombre y seleccione las opciones a continuación. En este caso, supongo que debe seleccionar "estructura y datos" y "crear base de datos antes de copiar" las casillas de verificación y, finalmente, presionar el botón "ir" en esa sección.

Por cierto, estoy usando phpMyAdmin en español, así que no estoy seguro de cuáles son los nombres de las secciones en inglés.

Aquí hay un fragmento de Bash de una línea para mover todas las tablas de un esquema a otro:

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

El comando de historial al inicio simplemente garantiza que los comandos de MySQL que contienen contraseñas no se guardan en el historial de Shell.

Asegúrese de que db_user tenga permisos de lectura/escritura/eliminación en el esquema anterior, y permisos de lectura/escritura/creación en el nuevo esquema.

Lo hice de esta manera: haga una copia de seguridad de su base de datos existente. Le proporcionará un db.Zip.tmp y luego en el comando Solicitud de escritura siguiente

"C:\Archivos de programa (x86)\MySQL\MySQL Server 5.6\bin\mysql.exe" -h localhost -u root -p [contraseña] [nuevo nombre de la base de datos] <"C:\Backups\db.Zip.tmp "

Puedes hacerlo de dos maneras.

1. RENAME TABLE old_db.table_name TO new_db.table_name;
2. Ir a operaciones-> allí puede ver la pestaña Opciones de tabla. Puede editar el nombre de la tabla allí.

Este es el script por lotes que escribí para cambiar el nombre de una base de datos en 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 es la solución propuesta para esto por MySQL y RENAME DATABASE se elimina.

Sintaxis de13.1.32 RENAME DATABASE:

RENAME {DATABASE | SCHEMA} db_name TO new_db_name;

Esta declaración se agregó en MySQL 5.1.7, pero se encontró que era peligrosa y se eliminó en MySQL 5.1.23.

Esto funciona para todas las bases de datos y funciona cambiando el nombre de cada tabla con maatkit mysql toolkit

Use mk-find para imprimir y renombrar cada tabla. La página de manual tiene muchas más opciones y ejemplos.

mk-find --dblike OLD_DATABASE --print --exec "RENAME TABLE %D.%N TO NEW_DATABASE.%N"

Si tienes instalado maatkit ( que es muy fácil ), esta es la forma más sencilla de hacerlo.

En el caso de que se inicie desde un archivo de volcado con varias bases de datos, puede realizar un sed en el volcado:

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

Luego importa tu volcado. Sólo asegúrese de que no habrá conflicto de nombres.

Ni la solución de TodoInTx ni la solución adaptada del usuario 757945 me funcionaron en MySQL 5.5.16, por lo que aquí está mi versión adaptada:

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 ;

Espero que ayude a alguien que está en mi situación! Nota: @sql_string permanecerá en la sesión después. No pude escribir esta función sin usarla.

Usé el siguiente método para cambiar el nombre de la base de datos

1. haga una copia de seguridad del archivo usando mysqldump o cualquier herramienta de base de datos, por ejemplo, heidiSQL, mysql administrator, etc.

2. Abra un archivo de copia de seguridad (por ejemplo, backupfile.sql) en algún editor de texto.

3. Busque y reemplace el nombre de la base de datos y guarde el archivo.

4. Restaura el archivo sql editado

Si usa vistas jerárquicas (las vistas extraen datos de otras vistas), la importación de la salida en bruto de mysqldump puede no funcionar, ya que a mysqldump no le importa el orden correcto de las vistas. Debido a esto, I script escrito que reordena las vistas para corregir el orden sobre la marcha.

Se ve así:

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

Ustedes me van a disparar por esto, y lo más probable es que esto no funcione todas las veces, y seguro, es contra toda lógica bla bla ... Pero lo que acabo de intentar es ... DETENER el motor MySQL, inicie sesión como root y simplemente renombrado el DB en el nivel del sistema de archivos ....

Estoy en OSX, y solo cambié el caso, de bedbf a BEDBF. Para mi sorpresa, funcionó...

No lo recomendaría en un DB de producción. Acabo de intentar esto como un experimento ...

Buena suerte de cualquier manera :-)

Publiqué esto ¿Cómo cambio el nombre de la base de datos usando MySQL? Hoy después de días de rascarse la cabeza y arrancarse el pelo. La solución es bastante simple exportar un esquema a un archivo .sql y abrir el archivo y cambiar el nombre de la base de datos/esquema en la sección TABLE CREAT TABLE en la parte superior. Hay tres instancias o más y es posible que no estén en la parte superior de la página si se guardan varios esquemas en el archivo. Es posible editar la base de datos completa de esta manera, pero espero que en grandes bases de datos sea muy difícil seguir todas las instancias de una propiedad o índice de la tabla.

I). No hay forma directa por la cual u puede cambiar el nombre de una base de datos existente. Pero puede lograr su objetivo siguiendo los pasos a continuación: 1). Crear newdb. 2). Utilice newdb. 3). crear tabla table_name (seleccionar * de olddb.table_name);

Al hacer lo anterior, está copiando datos de la tabla de olddb e insertándolos en la tabla de newdb. Dale el nombre de la mesa igual.

II). RENAME TABLE old_db.table_name TO new_db.table_name;