Benennen Sie die MySQL-Datenbank um

Falls Sie dies von der Kommandozeile aus tun müssen, kopieren Sie das Snippet und passen Sie es an:

mysql -e "CREATE DATABASE \`new_database\`;"
for table in `mysql -B -N -e "SHOW TABLES;" old_database`
do 
  mysql -e "RENAME TABLE \`old_database\`.\`$table\` to \`new_database\`.\`$table\`"
done
mysql -e "DROP DATABASE \`old_database\`;"

Es ist möglich, die Datenbank mit dem Befehl mysqldump zu kopieren, ohne Dump in einer Datei zu speichern:

1. mysql -u root -p -e "create database my_new_database"
2. mysqldump -u root -p original_database | mysql -u root -p my_new_database
3. mysql -u root -p -e "drop database original_database"

Sie können eine neue Datenbank genau wie die vorherige Datenbank erstellen und dann die alte Datenbank löschen, wenn Sie fertig sind. Erstellen Sie mit dem Tool mysqldump eine .sql-Sicherung der Datenbank über mysqldump orig_db > orig_db.sql. Wenn Sie einen Benutzernamen und ein Kennwort verwenden müssen, führen Sie mysqldump -u root -p orig_db > orig_db.sql aus. orig_db ist der Name der Datenbank, die Sie "umbenennen" möchten, root ist der Benutzer, unter dem Sie sich anmelden, und orig_db.sql ist die erstellte Datei, die die Sicherung enthält. Erstellen Sie nun eine neue, leere Datenbank mit dem gewünschten Namen für die Datenbank. Zum Beispiel mysql -u root -p -e "create database new_db". Sobald dies erledigt ist, führen Sie mysql -u root -p new_db < orig_db.sql aus. new_db existiert jetzt als perfekte Kopie von orig_db. Sie können die ursprüngliche Datenbank dann löschen, da sie jetzt mit dem gewünschten Datenbanknamen in der neuen Datenbank vorhanden ist.

Die kurzen, schnellen Schritte ohne alle obigen Erklärungen sind:

1. mysqldump -u root -p original_database > original_database.sql
2. mysql -u root -p -e "create database my_new_database"
3. mysql -u root -p my_new_database < original_database.sql
4. mysql -u root -p -e drop database originl_database

Ich hoffe, dies hilft und dies ist ein zuverlässiges Mittel, um dies zu erreichen, ohne eine Ad-hoc-Methode zu verwenden, die Ihre Daten beschädigen und Inkonsistenzen erzeugen wird.

Sie können dies mit der RENAME-Anweisung für jede Tabelle in "current_db" tun, nachdem Sie das neue Schema "other_db" erstellt haben.

RENAME TABLE current_db.tbl_name TO other_db.tbl_name

Quelle Tabellensyntax umbenennen

Nun, es gibt zwei Methoden: 

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

Von Shell

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

Obwohl das obige Verfahren einfach ist, ist es zeit- und platzaufwendig. Was ist, wenn das Schema mehr als 100 GB ist? Es gibt Methoden, mit denen Sie die obigen Befehle zusammen ausführen können, um Platz zu sparen. Dies spart jedoch keine Zeit.

Zur Behebung solcher Situationen gibt es eine andere schnelle Methode zum Umbenennen von Bei Schemata ist jedoch etwas Vorsicht geboten.

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

1. Erstellen Sie das neue Datenbankschema mit dem gewünschten Namen.
2. Benennen Sie die Tabellen vom alten Schema in ein neues Schema um. Verwenden Sie dazu den MySQL-Befehl "RENAME TABLE".
3. Löschen Sie das alte Datenbankschema.

Wenn views, triggers, functions, stored procedures im Schema vorhanden ist, müssen diese ebenfalls neu erstellt werden. MySQLs "RENAME TABLE" schlägt fehl, wenn in den Tabellen Auslöser vorhanden sind. Zur Abhilfe können wir folgende Dinge tun:

1) Dump the triggers, events and stored routines in a separate file. Dies erfolgt mithilfe von -E, -R-Flags (zusätzlich zu -t -d, die Die Auslöser speichert) für den Befehl mysqldump. Einmalige Auslöser sind entladen werden, müssen wir sie aus dem Schema löschen, für RENAME TABLE Befehl zur Arbeit.

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

2) Erzeugt eine Liste von nur "BASE" -Tabellen. Diese können mit einem .__ gefunden werden. Abfrage der Tabelle information_schema.TABLES.

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

3) Die Ansichten in eine Ausgangsdatei ausgeben. Ansichten können mit einer Abfrage unter .__ gefunden werden. dieselbe information_schema.TABLES-Tabelle.

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ösche die Trigger für die aktuellen Tabellen im old_schema.

mysql> DROP TRIGGER <trigger_name>;
...

5) Stellen Sie die obigen Dump-Dateien wieder her, wenn alle in Schritt 2 gefundenen "Base" -Tabellen 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 schema_name übereinstimmen. Diese könnten mit einer einfachen UPDATE in mysql.columns_priv, mysql.procs_priv, mysql.tables_priv, mysql.db-Tabellen behoben werden, die die old_schema name auf new_schema aktualisieren und "Flush-Privilegien" aufrufen. . Obwohl "method 2" etwas komplizierter erscheint als "method 1", ist dies absolut skriptfähig. Mit einem einfachen Bash-Skript, das die oben genannten Schritte in der richtigen Reihenfolge ausführt, können Sie beim nächsten Umbenennen von Datenbankschemas Platz und Zeit sparen.

Das Percona Remote DBA-Team hat ein Skript namens "rename_db" geschrieben, das auf folgende Weise funktioniert:

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

Um die Verwendung dieses Skripts zu veranschaulichen, wurde ein Beispielschema "emp" verwendet, Testauslöser erstellt und Routinen in diesem Schema gespeichert. Es wird versucht, das Datenbankschema mithilfe des Skripts umzubenennen. Dies dauert einige Sekunden und nicht die zeitaufwändige Dump/Restore-Methode.

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

Wie Sie in der obigen Ausgabe sehen können, wurde das Datenbankschema "emp" in weniger als einer Sekunde in "emp_test" umbenannt .. _. Zuletzt ist dies das Skript von Percona, das oben für "method 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

Kurz nein Es wird allgemein für zu gefährlich gehalten, eine Datenbank umzubenennen. MySQL hatte dieses Feature für eine Weile, aber es wurde entfernt. Sie sollten die Workbench besser verwenden, um sowohl das Schema als auch die Daten nach SQL zu exportieren, und dann den CREATE DATABASE-Namen dort zu ändern, bevor Sie ihn ausführen/importieren.

Für ungeduldige Mysql-Benutzer (wie ich) lautet die Lösung:

/etc/init.d/mysql stop
mv /var/lib/mysql/old_database /var/lib/mysql/new_database 
/etc/init.d/mysql start

Ich habe folgende Methode verwendet, um die Datenbank umzubenennen

1. sichern Sie die Datei mit mysqldump oder einem anderen DB-Tool, z. B. heidiSQL, mysql administrator etc

2. Öffnen Sie die Sicherungsdatei (z. B. backupfile.sql) in einem Texteditor.

3. Suchen und ersetzen Sie den Datenbanknamen und speichern Sie die Datei.

4. Stellen Sie die bearbeitete SQL-Datei wieder her

Wenn Ihre Datenbank nur MyISAM-Tabellen enthält (do not verwenden Sie diese Methode, wenn Sie InnoDB-Tabellen haben):

1. fahren Sie den MySQL-Server herunter
2. gehen Sie in das Verzeichnis mysql data und benennen Sie das Datenbankverzeichnis um (Hinweis: Nicht-Alpha-Zeichen müssen auf besondere Weise codiert werden.)
3. starten Sie den Server neu
4. ggf. Berechtigungen anpassen (Zugriff auf den neuen DB-Namen gewähren)

Sie können alles in einem einzigen Befehl schreiben, sodass die Ausfallzeit nur ein oder zwei Sekunden beträgt.

Sichern Sie zuerst die alte Datenbank namens HRMS und bearbeiten Sie die Skriptdatei, indem Sie das Word HRMS in SUNHRM ersetzen. Nach diesem Schritt importieren Sie die Datenbankdatei in das mysql

Eine andere Möglichkeit, die Datenbank umzubenennen oder ein Image der Datenbank zu erstellen, ist die Option Reverse Engineering auf der Registerkarte "Datenbank". Es wird ein ERR-Diagramm für die Datenbank erstellt. Benennen Sie das Schema dort um.

danach gehen Sie zum Dateimenü und zum Exportieren und Weiterleiten der Datenbank.

Dann können Sie die Datenbank importieren.