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

StackOverflow https://stackoverflow.com/questions/67093

  •  09-06-2019
  •  | 
  •  

Domanda

Il manuale MySQL su MySQL copre questo.

Di solito scarico semplicemente il database e lo reimporto con un nuovo nome.Questa non è un'opzione per database molto grandi.Apparentemente RENAME {DATABASE | SCHEMA} db_name TO new_db_name; fa cose brutte, esiste solo in una manciata di versioni e nel complesso è una cattiva idea.

È necessario lavorare con questo InnoDB, che memorizza le cose in modo molto diverso da MyISAM.

È stato utile?

Soluzione

Per InnoDB, quanto segue sembra funzionare:crea il nuovo database vuoto, quindi rinomina ciascuna tabella a sua volta nel nuovo database:

RENAME TABLE old_db.table TO new_db.table;

Successivamente dovrai modificare le autorizzazioni.

Per eseguire script 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;

Appunti:

  • Non c'è spazio tra le opzioni -p e la parola d'ordine.Se il tuo database non ha password, rimuovi il file -u username -ppassword parte.

  • Se una tabella ha un trigger, non può essere spostata in un altro database utilizzando il metodo sopra (il risultato sarà Trigger in wrong schema errore).In tal caso, utilizza un metodo tradizionale per clonare un database e quindi eliminare quello vecchio:

    mysqldump old_db | mysql new_db

  • Se disponi di procedure memorizzate, puoi copiarle in seguito:

    mysqldump -R old_db | mysql new_db

Altri suggerimenti

Utilizza 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

Oppure per ridurre l'I/O utilizzare 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, seleziona il database che desideri selezionare.Nelle schede ce n'è una chiamata Operazioni, vai alla sezione rinomina.È tutto.

Come molti hanno suggerito, crea un nuovo database con il nuovo nome, scarica tutte le tabelle del vecchio database nel nuovo database ed elimina il vecchio database.

Enter image description here

È possibile utilizzare SQL per generare uno script SQL per trasferire ogni 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 (originariamente avevo suggerito il primo e qualcuno ha "migliorato" la mia risposta da utilizzare GROUP_CONCAT.Scegli tu, 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 sorgente e destinazione)

Questo genererà un comando SQL che dovrai quindi eseguire.

Notare che GROUP_CONCAT ha un limite di lunghezza predefinito che può essere superato per i database con un numero elevato di tabelle.Puoi modificare questo limite correndo SET SESSION group_concat_max_len = 100000000; (o qualche altro numero grande).

Emulare i dispersi RENAME DATABASE comando in MySQL:

  1. Creare un nuovo database

  2. Crea le query di ridenominazione 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 Emulare il comando RENAME DATABASE mancante in MySQL.

Tre opzioni:

  1. Crea il nuovo database, disattiva il server, sposta i file da una cartella del database all'altra e riavvia il server.Tieni presente che funzionerà solo se TUTTE le tue tabelle sono MyISAM.

  2. Crea il nuovo database, usa CREATE TABLE ...LIKE istruzioni, quindi utilizzare INSERT ...SELECT * FROM istruzioni.

  3. Usa mysqldump e ricarica con quel file.

Il modo semplice

Passare alla directory del database:

cd /var/lib/mysql/

Spegni MySQL...Questo è importante!

/etc/init.d/mysql stop

Ok, in questo modo non funziona per 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 è necessario scaricare il database e reimportarlo.

Solo di recente 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 e a prova di errore per fare a completare rinominare (incluso l'eliminazione del vecchio database alla fine, quindi è una ridenominazione anziché una copia):

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

Passaggi:

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

MySQL al momento non supporta la ridenominazione di un database tramite la sua interfaccia di comando, ma puoi rinominare il database se hai accesso alla directory in cui MySQL memorizza i suoi database.Per le installazioni MySQL predefinite, di solito si trova nella directory Data sotto la directory in cui è stato installato MySQL.Individua il nome del database che desideri rinominare nella directory Dati e rinominalo.Rinominare la directory potrebbe tuttavia causare alcuni problemi di autorizzazione.Sii consapevole.

Nota: È necessario arrestare MySQL prima di poter rinominare il database

Consiglierei di creare un nuovo database (utilizzando il nome desiderato) ed esportare/importare i dati necessari dal vecchio al nuovo.Abbastanza semplice.

Quando rinomini un database in PHPMyAdmin, crea un dump, quindi elimina e ricrea il database con il nuovo nome.

Per coloro che sono utenti Mac, Sequel Pro ha un'opzione Rinomina database nel menu Database.http://www.sequelpro.com/

Ebbene ci sono 2 metodi:

Metodo 1: Un metodo noto per rinominare lo schema del database consiste nel scaricare lo schema utilizzando Mysqldump e ripristinarlo in un altro schema, quindi eliminare il vecchio schema (se necessario).

Dalla Shell

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

Sebbene il metodo sopra descritto sia semplice, richiede tempo e spazio.Cosa succede se lo schema è più di a 100GB? Esistono metodi in cui è possibile collegare insieme i comandi precedenti per risparmiare spazio, tuttavia non farà risparmiare tempo.

Per rimediare a tali situazioni, esiste un altro metodo rapido per rinominare gli schemi, tuttavia è necessario prestare una certa attenzione mentre lo si fa.

Metodo 2: MySQL ha un'ottima funzionalità per rinominare le tabelle che funziona anche su schemi diversi.Questa operazione di ridenominazione è atomica e nessun altro può accedere alla tabella mentre viene rinominata.Il completamento di questa operazione richiede poco tempo poiché la modifica del nome di una tabella o del suo schema è solo una modifica dei metadati.Ecco l'approccio procedurale per eseguire la ridenominazione:

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

1) Dump the triggers, events and stored routines in a separate file. Questo viene fatto utilizzando i flag -E, -R (oltre a -t -d che scarica i trigger) nel comando mysqldump.Una volta scaricati i trigger, dovremo eliminarli dallo schema affinché il comando RENAME TABLE funzioni.

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

2) Genera un elenco di sole tabelle “BASE”.Questi possono essere trovati utilizzando una query su information_schema.TABLES tavolo.

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

3) Scarica le visualizzazioni in un file di uscita.Le visualizzazioni possono essere trovate utilizzando una query sullo stesso information_schema.TABLES tavolo.

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 sulle tabelle correnti in old_schema.

mysql> DROP TRIGGER <trigger_name>;
...

5) Ripristinare i file di dump precedenti una volta rinominate tutte le tabelle "Base" trovate nel passaggio n. 2.

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

Complessità con i metodi di cui sopra:Potrebbe essere necessario aggiornare i GRANTS per gli utenti in modo che corrispondano allo schema_name corretto.Questi problemi potrebbero essere risolti con un semplice AGGIORNAMENTO sulle tabelle mysql.columns_priv, mysql.procs_priv, mysql.tables_priv, mysql.db aggiornando il nome old_schema in new_schema e chiamando "Privilegi Flush;".Anche se il “metodo 2″ sembra un po’ più complicato del “metodo 1″, è totalmente scriptabile.Un semplice script bash per eseguire i passaggi precedenti nella sequenza corretta può aiutarti a risparmiare spazio e tempo durante la successiva ridenominazione degli schemi di database.

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

[root@dba~]# /tmp/rename_db
rename_db <server> <database> <new_database>

Per dimostrare l'uso di questo script, è stato utilizzato uno schema di esempio "emp", creato trigger di test e memorizzato routine su quello schema.Tenterà di rinominare lo schema del database utilizzando lo script, il cui completamento richiede alcuni secondi rispetto al metodo di dump/ripristino che richiede molto tempo.

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


[root@dba ~]# 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 puoi vedere nell'output sopra, lo schema del database "emp" è stato rinominato in "emp_test" in meno di un secondo.Infine, questo è lo script di Percona utilizzato sopra per il “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

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

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

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

Tuttavia, eventuali trigger nel database di destinazione non saranno soddisfatti.Dovrai prima eliminarli e poi ricrearli dopo la ridenominazione.

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

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

  1. Non puoi semplicemente utilizzare RENAME TABLE, perché potrebbero esserci visualizzazioni e trigger.Se sono presenti trigger, RENAME TABLE fallisce
  2. Non puoi usare mysqldump se vuoi rinominare "rapidamente" (come richiesto nella domanda) 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 lo script pubblicato (realizzato?) da Simon R Jones che fa ciò che viene suggerito in quel post.Ho corretto un bug che ho trovato nello script.Potete vederlo qui:

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

Eccone una copia:

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

Salvatelo in un file chiamato rename_db e rendere 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 del tutto per me.Ecco il mio tentativo:

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

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

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

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

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

        END IF;
    UNTIL done END REPEAT;

    CLOSE old_tables;

END//
delimiter ;

Passaggi:

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

enter image description here

IO ha posto una domanda su Server Fault cercando di aggirare i tempi di inattività durante il ripristino di database di grandi dimensioni utilizzando MySQL Proxy.Non ho avuto alcun successo, ma alla fine ho capito che quello che volevo era 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 che svolgesse il lavoro per me.Io ho pubblicato su GitHub nel caso possa essere utile ad altri.

Per tua comodità, di seguito è riportato un piccolo script di shell che deve essere eseguito con due parametri:nome-db e nuovo nome-db.

Potrebbe essere necessario aggiungere parametri di accesso alle righe mysql se non usi il file .my.cnf nella tua directory home.Effettuare 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"

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

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

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

Per rinominare un database in HeidiSQL, basta fare clic con il pulsante destro del mouse sul nome del database e selezionare 'Modifica'.Quindi inserisci un nuovo nome e premi "OK".

È così semplice.

Ecco un modo rapido per generare uno script SQL di ridenominazione, 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 che nessuno ne abbia parlato, ma ecco un altro modo:

create database NewDatabaseName like OldDatabaseName;

quindi per ogni tabella fai:

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

poi, se vuoi,

drop database OldDatabaseName;

Questo approccio avrebbe il vantaggio di eseguire l'intero trasferimento su un server con traffico di rete quasi pari a zero, quindi sarà molto più veloce di un dump/ripristino.

Se disponi di procedure/viste/ecc. memorizzate, potresti voler trasferire anche quelle.

Per gli utenti Mac, puoi utilizzare Sequel Pro (gratuito), che fornisce solo la possibilità di rinominare i database.Sebbene non elimini il vecchio DB.

una volta aperto il DB interessato basta cliccare: Database --> Rename database...

In MySQL Administrator, procedi come segue:

  1. In Cataloghi creare un nuovo schema di database.
  2. Vai a backup e crea un backup del vecchio schema.
  3. Esegui il backup.
  4. Vai per ripristinare e aprire il file creato nel passaggio 3.
  5. Seleziona "un altro schema" in Schema target e seleziona il nuovo schema del database.
  6. Avvia ripristino.
  7. Verifica un nuovo schema e, se sembra buono, elimina 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 vecchia tabella e ricaricare i dati della tabella fare clic su OK in entrambi

Il tuo database viene rinominato

Se stai usando phpMyAdmin puoi andare alla scheda "operazioni" dopo aver selezionato il database che desideri rinominare.Quindi vai all'ultima sezione "copia database in" (o qualcosa del genere), dai un nome e seleziona le opzioni seguenti.In questo caso, immagino che tu debba selezionare le caselle di controllo "struttura e dati" e "crea 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 Bash di una riga per spostare tutte le tabelle da uno schema all'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 della shell.

Assicurati che db_user dispone di autorizzazioni di lettura/scrittura/eliminazione sul vecchio schema e autorizzazioni di lettura/scrittura/creazione sul nuovo schema.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top