Wie kann ich eine MySQL-Datenbank schnell umbenennen (Schemanamen ändern)?

Das MySQL-Handbuch unter MySQL behandelt dies.

Normalerweise speichere ich die Datenbank einfach und importiere sie mit einem neuen Namen erneut. Dies ist keine Option für sehr große Datenbanken. AnscheinendRENAME {DATABASE | SCHEMA} db_name TO new_db_name; macht es schlechte Dinge, existiert nur in einer Handvoll Versionen und ist insgesamt eine schlechte Idee .

Dies muss mit InnoDB funktionieren , das die Dinge ganz anders speichert als MyISAM .

Für InnoDB scheint Folgendes zu funktionieren: Erstellen Sie die neue leere Datenbank und benennen Sie dann jede Tabelle der Reihe nach in die neue Datenbank um:

RENAME TABLE old_db.table TO new_db.table;

Danach müssen Sie die Berechtigungen anpassen.

Für die Skripterstellung in einer Shell können Sie eine der folgenden Methoden verwenden:

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

ODER

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;

Anmerkungen:

• Zwischen der Option -pund dem Passwort ist kein Leerzeichen . Wenn Ihre Datenbank kein Kennwort hat, entfernen Sie das -u username -ppasswordTeil.

• Wenn eine Tabelle einen Trigger hat, kann sie mit der obigen Methode nicht in eine andere Datenbank verschoben werden (führt zu einem Trigger in wrong schemaFehler). Wenn dies der Fall ist, verwenden Sie eine herkömmliche Methode, um eine Datenbank zu klonen, und löschen Sie dann die alte:

  mysqldump old_db | mysql new_db

• Wenn Sie Prozeduren gespeichert haben, können Sie diese anschließend kopieren:

  mysqldump -R old_db | mysql new_db

Verwenden Sie diese wenigen einfachen Befehle:

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

Um die E / A zu reduzieren, verwenden Sie Folgendes, wie von @Pablo Marin-Garcia vorgeschlagen:

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

Ich denke, die Lösung ist einfacher und wurde von einigen Entwicklern vorgeschlagen. phpMyAdmin hat hierfür eine Operation.

Wählen Sie in phpMyAdmin die Datenbank aus, die Sie auswählen möchten. In den Registerkarten gibt es eine mit dem Namen "Operationen". Gehen Sie zum Abschnitt "Umbenennen". Das ist alles.

Wie von vielen vorgeschlagen, wird eine neue Datenbank mit dem neuen Namen erstellt, alle Tabellen der alten Datenbank in die neue Datenbank kopiert und die alte Datenbank gelöscht.

Mit SQL können Sie ein SQL-Skript generieren, um jede Tabelle in Ihrer Quellendatenbank in die Zieldatenbank zu übertragen.

Sie müssen die Zieldatenbank erstellen, bevor Sie das aus dem Befehl generierte Skript ausführen können.

Sie können eines dieser beiden Skripte verwenden (ich habe ursprünglich das erstere vorgeschlagen und jemand hat meine Antwort "verbessert" GROUP_CONCAT. Treffen Sie Ihre Wahl, aber ich bevorzuge das Original):

SELECT CONCAT('RENAME TABLE $1.', table_name, ' TO $2.', table_name, '; ')
FROM information_schema.TABLES 
WHERE table_schema='$1';

oder

SELECT GROUP_CONCAT('RENAME TABLE $1.', table_name, ' TO $2.', table_name SEPARATOR '; ')
FROM information_schema.TABLES 
WHERE table_schema='$1';

($ 1 und $ 2 sind Quelle bzw. Ziel)

Dadurch wird ein SQL-Befehl generiert, den Sie dann ausführen müssen.

Beachten Sie, dass GROUP_CONCATdie Standardlängenbeschränkung für Datenbanken mit einer großen Anzahl von Tabellen überschritten werden kann. Sie können dieses Limit ändern, indem Sie SET SESSION group_concat_max_len = 100000000;(oder eine andere große Anzahl) ausführen.

Emulieren des fehlenden RENAME DATABASEBefehls in MySQL:

1. Erstellen Sie eine neue Datenbank

2. Erstellen Sie die Umbenennungsabfragen mit:

   SELECT CONCAT('RENAME TABLE ',table_schema,'.',table_name,
       ' TO ','new_schema.',table_name,';')
   FROM information_schema.TABLES
   WHERE table_schema LIKE 'old_schema';

3. Führen Sie diese Ausgabe aus

4. Alte Datenbank löschen

Es wurde aus dem Emulieren des fehlenden Befehls RENAME DATABASE in MySQL übernommen .

Drei Optionen:

1. Erstellen Sie die neue Datenbank, fahren Sie den Server herunter, verschieben Sie die Dateien von einem Datenbankordner in den anderen und starten Sie den Server neu. Beachten Sie, dass dies nur funktioniert, wenn ALLE Ihre Tabellen MyISAM sind.

2. Erstellen Sie die neue Datenbank, verwenden Sie die Anweisungen CREATE TABLE ... LIKE und dann die Anweisungen INSERT ... SELECT * FROM.

3. Verwenden Sie mysqldump und laden Sie es mit dieser Datei neu.

Der einfache Weg

Wechseln Sie in das Datenbankverzeichnis:

cd /var/lib/mysql/

MySQL herunterfahren ... Das ist wichtig!

/etc/init.d/mysql stop

Okay, dieser Weg funktioniert nicht für InnoDB- oder BDB-Datenbanken.

Datenbank umbenennen:

mv old-name new-name

... oder der Tisch ...

cd database/

mv old-name.frm new-name.frm

mv old-name.MYD new-name.MYD

mv old-name.MYI new-name.MYI

Starten Sie MySQL neu

/etc/init.d/mysql start

Erledigt...

OK, diese Methode funktioniert nicht mit InnoDB- oder BDB-Datenbanken. In diesem Fall müssen Sie die Datenbank sichern und erneut importieren.

Sie können dieses Shell-Skript verwenden:

Referenz: Wie benenne ich eine MySQL-Datenbank um?

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

Es funktioniert:

$ sh rename_database.sh oldname newname

Ich bin erst kürzlich auf eine sehr schöne Art und Weise gestoßen, arbeite mit MyISAM und InnoDB und bin sehr schnell:

RENAME TABLE old_db.table TO new_db.table;

Ich erinnere mich nicht, wo ich es gelesen habe, aber das Verdienst geht an jemand anderen, nicht an mich.

Einfachste kugelsichere Methode zum vollständigen Umbenennen (einschließlich des Löschens der alten Datenbank am Ende, sodass es sich eher um eine Umbenennung als um eine Kopie handelt) :

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

Schritte:

1. Kopieren Sie die Zeilen in den Editor.
2. Ersetzen Sie alle Verweise auf "olddbname", "newdbname", "mypassword" (+ optional "root") durch Ihre Entsprechungen.
3. Führen Sie eine nach der anderen in der Befehlszeile aus (geben Sie "y" ein, wenn Sie dazu aufgefordert werden).

Das benutze ich:

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

MySQL unterstützt derzeit das Umbenennen einer Datenbank über die Befehlsoberfläche nicht. Sie können die Datenbank jedoch umbenennen, wenn Sie Zugriff auf das Verzeichnis haben, in dem MySQL seine Datenbanken speichert. Bei Standardinstallationen von MySQL befindet sich diese normalerweise im Datenverzeichnis unter dem Verzeichnis, in dem MySQL installiert wurde. Suchen Sie den Namen der Datenbank, die Sie umbenennen möchten, im Datenverzeichnis und benennen Sie ihn um. Das Umbenennen des Verzeichnisses kann jedoch zu Berechtigungsproblemen führen. Sei vorsichtig.

Hinweis: Sie müssen MySQL stoppen, bevor Sie die Datenbank umbenennen können

Ich würde empfehlen, eine neue Datenbank zu erstellen (unter Verwendung des gewünschten Namens) und die benötigten Daten von der alten in die neue zu exportieren / importieren. Ziemlich einfach.

Wenn Sie eine Datenbank in PHPMyAdmin umbenennen, wird ein Speicherauszug erstellt. Anschließend wird die Datenbank gelöscht und unter dem neuen Namen neu erstellt.

Nun, es gibt 2 Methoden:

Methode 1: Eine bekannte Methode zum Umbenennen des Datenbankschemas besteht darin, das Schema mit Mysqldump zu sichern, es in einem anderen Schema wiederherzustellen und dann das alte Schema zu löschen (falls erforderlich).

Von Shell

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

Obwohl die obige Methode einfach ist, ist sie zeit- und platzaufwendig. Was ist, wenn das Schema mehr als 100 GB umfasst?Es gibt Methoden, mit denen Sie die oben genannten Befehle zusammenfügen können, um Platz zu sparen. Dies spart jedoch keine Zeit.

Um solche Situationen zu beheben, gibt es eine andere schnelle Methode zum Umbenennen von Schemas. Dabei muss jedoch einige Sorgfalt angewendet werden.

Methode 2: MySQL bietet eine sehr gute Funktion zum Umbenennen von Tabellen, die sogar in verschiedenen Schemas funktioniert. Diese Umbenennungsoperation ist atomar und niemand anderes kann auf die Tabelle zugreifen, während sie umbenannt wird. Dies dauert nur kurze Zeit, da das Ändern des Namens oder des Schemas einer Tabelle nur eine Änderung der Metadaten ist. Hier ist ein prozeduraler Ansatz beim Umbenennen:

Erstellen Sie das neue Datenbankschema mit dem gewünschten Namen. Benennen Sie die Tabellen mit dem MySQL-Befehl "RENAME TABLE" vom alten in das neue Schema um. Löschen Sie das alte Datenbankschema. If there are views, triggers, functions, stored procedures in the schema, those will need to be recreated too. MySQLs "RENAME TABLE" schlägt fehl, wenn Trigger in den Tabellen vorhanden sind. Um dies zu beheben, können wir folgende Dinge tun:

1) Dump the triggers, events and stored routines in a separate file. Dies erfolgt mit -E, -R-Flags (zusätzlich zu -t -d, das die Trigger ausgibt) für den Befehl mysqldump. Sobald die Trigger ausgegeben wurden, müssen sie aus dem Schema entfernt werden, damit der Befehl RENAME TABLE funktioniert.

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

2) Erstellen Sie eine Liste mit nur "BASE" -Tabellen. Diese können mithilfe einer Abfrage in der information_schema.TABLESTabelle gefunden werden.

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

3) Speichern Sie die Ansichten in einer Out-Datei. Ansichten können mithilfe einer Abfrage in derselben information_schema.TABLESTabelle gefunden werden.

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) Löschen Sie die Trigger in den aktuellen Tabellen im old_schema.

mysql> DROP TRIGGER <trigger_name>;
...

5) Stellen Sie die obigen Speicherauszugsdateien wieder her, sobald alle in Schritt 2 gefundenen "Basistabellen" umbenannt wurden.

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

Komplikationen mit den oben genannten Methoden: Möglicherweise müssen wir die GRANTS für Benutzer so aktualisieren, dass sie mit dem richtigen Schemanamen übereinstimmen. Diese können mit einem einfachen UPDATE für die Tabellen mysql.columns_priv, mysql.procs_priv, mysql.tables_priv und mysql.db behoben werden, indem der Name des alten Schemas auf new_schema aktualisiert und "Flush privileges;" aufgerufen wird. Obwohl "Methode 2" etwas komplizierter erscheint als "Methode 1", ist dies vollständig skriptfähig. Ein einfaches Bash-Skript, mit dem Sie die oben genannten Schritte in der richtigen Reihenfolge ausführen können, kann Ihnen helfen, beim nächsten Umbenennen von Datenbankschemata Platz und Zeit zu sparen.

Das Percona Remote DBA-Team hat ein Skript namens "rename_db" geschrieben, das folgendermaßen funktioniert:

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

Um die Verwendung dieses Skripts zu demonstrieren, wurde ein Beispielschema "emp" verwendet, Testauslöser erstellt und Routinen in diesem Schema gespeichert. Versucht, das Datenbankschema mithilfe des Skripts umzubenennen. Der Vorgang dauert einige Sekunden, im Gegensatz zur zeitaufwändigen Dump / Restore-Methode.

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

Wie Sie in der obigen Ausgabe sehen können, wurde das Datenbankschema "emp" in weniger als einer Sekunde in "emp_test" umbenannt. Schließlich ist dies das Skript von Percona, das oben für "Methode 2" verwendet wird.

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

Schritte :

1. Hit http: // localhost / phpmyadmin /
2. Wählen Sie Ihre Datenbank aus
3. Klicken Sie auf die Registerkarte Operationen
4. Es wird eine Registerkarte als "Datenbank umbenennen in" angezeigt. Fügen Sie einen neuen Namen hinzu und aktivieren Sie die Option Berechtigungen anpassen.
5. Klicken Sie auf Los.

Für Mac-Benutzer bietet Sequel Pro im Menü "Datenbank" die Option "Datenbank umbenennen". http://www.sequelpro.com/

Die meisten Antworten hier sind aus einem von zwei Gründen falsch:

1. Sie können RENAME TABLE nicht einfach verwenden, da möglicherweise Ansichten und Trigger vorhanden sind. Wenn Trigger vorhanden sind, schlägt RENAME TABLE fehl
2. Sie können mysqldump nicht verwenden, wenn Sie "schnell" (wie in der Frage gefordert) eine große Datenbank umbenennen möchten

Percona hat einen Blog-Beitrag darüber, wie man das gut macht: https://www.percona.com/blog/2013/12/24/renaming-database-schema-mysql/

und ein Skript von Simon R Jones, das das tut, was in diesem Beitrag vorgeschlagen wird. Ich habe einen Fehler behoben, den ich im Skript gefunden habe. Sie können es hier sehen:

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

Hier ist eine Kopie davon:

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

Speichern Sie es in einer Datei namens rename_dbund machen Sie das Skript ausführbar mit chmod +x rename_dbund verwenden Sie es dann wie folgt./rename_db localhost old_db new_db

Es ist möglich, alle Tabellen in einer Datenbank so umzubenennen, dass sie sich unter einer anderen Datenbank befinden, ohne einen vollständigen Speicherauszug durchführen und wiederherstellen zu müssen.

DROP PROCEDURE IF EXISTS mysql.rename_db;
DELIMITER ||
VERFAHREN ERSTELLEN mysql.rename_db (IN old_db VARCHAR (100), IN new_db VARCHAR (100))
START
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`;
ENDE ||
DELIMITER;

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

Auslöser in der Ziel-Datenbank sind jedoch nicht zufriedenstellend. Sie müssen sie zuerst löschen und nach dem Umbenennen neu erstellen.

mysql -uroot -e "call mysql.rename_db ('test', 'blah2');" | mysql -uroot
FEHLER 1435 (HY000) in Zeile 4: Auslöser im falschen Schema

Hier ist eine Batch-Datei, die ich geschrieben habe, um sie über die Befehlszeile zu automatisieren, aber für Windows / MS-DOS.

Die Syntax lautet rename_mysqldb database newdatabase -u [Benutzer] -p [Passwort]

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

Die gespeicherte Prozedur von TodoInTX hat bei mir nicht ganz funktioniert. Hier ist mein Stich:

- gespeicherte Prozedur rename_db: Benennen Sie eine Datenbank um, um Tabellen zu kopieren.
- Vorsichtsmaßnahmen: 
- Überlastet alle vorhandenen Datenbanken mit demselben Namen wie der 'neue' Datenbankname.
- NUR Tabellen kopieren; gespeicherte Prozeduren und andere Datenbankobjekte werden nicht kopiert.
- Tomer Altman ([email protected])

Trennzeichen //
DROP PROCEDURE IF EXISTS rename_db;
CREATE PROCEDURE rename_db (IN old_db VARCHAR (100), IN new_db VARCHAR (100))
START
    DECLARE current_table VARCHAR (100);
    DECLARE done INT DEFAULT 0;
    DECLARE old_tables CURSOR FOR Wählen Sie table_name aus information_schema.tables aus, wobei table_schema = old_db;
    DECLARE CONTINUE HANDLER FÜR NICHT GEFUNDENES SET erledigt = 1;

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

    SET @output = CONCAT ('SCHEMA ERSTELLEN, WENN NICHT EXISTIERT', new_db, ';');
    PREPARE stmt FROM @output;
    EXECUTE stmt;

    OPEN old_tables;
    WIEDERHOLEN
        FETCH old_tables INTO current_table;
        WENN NICHT DANN getan
        SET @output = CONCAT ('alter table', old_db, '.', Current_table, 'rename', new_db, '.', Current_table, ';');
        PREPARE stmt FROM @output;
        EXECUTE stmt;

        END IF;
    BIS END REPEAT erledigt;

    CLOSE old_tables;

ENDE//
Trennzeichen;

Die einfachste Methode ist die Verwendung der HeidiSQL-Software. Es ist kostenlos und Open Source. Es läuft unter Windows und unter jedem Linux mit Wine (führen Sie Windows-Anwendungen unter Linux, BSD, Solaris und Mac OS X aus).

Um HeidiSQL herunterzuladen, gehen Sie zu http://www.heidisql.com/download.php .

Um Wine herunterzuladen, gehen Sie zu http://www.winehq.org/ .

Um eine Datenbank in HeidiSQL umzubenennen, klicken Sie einfach mit der rechten Maustaste auf den Datenbanknamen und wählen Sie 'Bearbeiten'. Geben Sie dann einen neuen Namen ein und drücken Sie 'OK'.

Es ist so einfach.

Für Mac-Benutzer können Sie Sequel Pro(kostenlos) verwenden, die nur die Option zum Umbenennen von Datenbanken bieten. Die alte Datenbank wird jedoch nicht gelöscht.

Sobald Sie die entsprechende Datenbank geöffnet haben, klicken Sie einfach auf: Database->Rename database...

Ich habe eine Frage zu Server Fault gestellt, bei der versucht wurde, Ausfallzeiten beim Wiederherstellen sehr großer Datenbanken mithilfe von MySQL Proxy zu umgehen. Ich hatte keinen Erfolg, aber am Ende wurde mir klar, dass ich die RENAME DATABASE-Funktionalität wollte, da Dump / Import aufgrund der Größe unserer Datenbank keine Option war.

In MySQL ist eine RENAME TABLE-Funktion integriert, sodass ich ein einfaches Python-Skript geschrieben habe, um die Aufgabe für mich zu erledigen. Ich habe es auf GitHub gepostet, falls es für andere von Nutzen sein könnte.

Im Folgenden finden Sie ein kleines Shellscript, das mit zwei Parametern ausgeführt werden muss: Datenbankname und neuer Datenbankname.

Möglicherweise müssen Sie den MySQL-Zeilen Anmeldeparameter hinzufügen, wenn Sie die Datei .my.cnf nicht in Ihrem Home-Verzeichnis verwenden. Bitte erstellen Sie ein Backup, bevor Sie dieses Skript ausführen.

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

Es scheint, dass niemand dies erwähnt hat, aber hier ist ein anderer Weg:

create database NewDatabaseName like OldDatabaseName;

dann für jede Tabelle:

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

dann, wenn du willst,

drop database OldDatabaseName;

Dieser Ansatz hätte den Vorteil, dass die gesamte Übertragung auf einem Server mit nahezu null Netzwerkverkehr durchgeführt wird, sodass er viel schneller abläuft als ein Dump / Restore.

Wenn Sie Prozeduren / Ansichten / usw. gespeichert haben, möchten Sie diese möglicherweise auch übertragen.

Hier ist eine schnelle Möglichkeit, ein SQL-Umbenennungsskript zu generieren, wenn Sie viele Tabellen verschieben müssen.

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

ALTER DATABASEist der von MySQL vorgeschlagene Weg, dies zu umgehen, und RENAME DATABASEwird verworfen.

Ab 13.1.32 RENAME DATABASE Syntax :

RENAME {DATABASE | SCHEMA} db_name TO new_db_name;

Diese Anweisung wurde in MySQL 5.1.7 hinzugefügt, wurde jedoch als gefährlich eingestuft und in MySQL 5.1.23 entfernt.

Gehen Sie in MySQL Administrator wie folgt vor:

1. Erstellen Sie unter Kataloge ein neues Datenbankschema.
2. Gehen Sie zu Backup und erstellen Sie eine Sicherung des alten Schemas.
3. Backup ausführen.
4. Gehen Sie zu Wiederherstellen und öffnen Sie die in Schritt 3 erstellte Datei.
5. Wählen Sie unter Zielschema die Option 'Ein anderes Schema' aus und wählen Sie das neue Datenbankschema aus.
6. Starten Sie die Wiederherstellung.
7. Überprüfen Sie das neue Schema und löschen Sie das alte, wenn es gut aussieht.

In phpmyadmin können Sie die Datenbank einfach umbenennen

select database 

  goto operations tab

  in that rename Database to :

  type your new database name and click go

Bitten Sie darum, die alte Tabelle zu löschen und die Tabellendaten neu zu laden. Klicken Sie in beiden Fällen auf OK

Ihre Datenbank wird umbenannt

Wenn Sie phpMyAdmin verwenden , können Sie zur Registerkarte "Operationen" wechseln, nachdem Sie die Datenbank ausgewählt haben, die Sie umbenennen möchten. Gehen Sie dann zum letzten Abschnitt "Datenbank kopieren nach" (oder so ähnlich), geben Sie einen Namen ein und wählen Sie die folgenden Optionen aus. In diesem Fall müssen Sie vermutlich die Kontrollkästchen "Struktur und Daten" und "Datenbank vor dem Kopieren erstellen" aktivieren und schließlich in diesem Abschnitt auf die Schaltfläche "Los" klicken.

Übrigens verwende ich phpMyAdmin auf Spanisch, daher bin ich mir nicht sicher, wie die Namen der Abschnitte auf Englisch lauten.