it-swarm-eu.dev

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

Das MySQL-Handbuch unter MySQL behandelt dies.

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

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

896
deadprogrammer

Für InnoDB scheint Folgendes zu funktionieren: Erstellen Sie die neue leere Datenbank und benennen Sie 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 -p und dem Kennwort ist kein Leerzeichen. Wenn Ihre Datenbank kein Kennwort hat, entfernen Sie den Teil -u username -ppassword.
  • Wenn eine Tabelle einen Trigger hat, kann sie nicht mit der oben beschriebenen Methode in eine andere Datenbank verschoben werden (dies führt zu dem Fehler Trigger in wrong schema). Wenn dies der Fall ist, klonen Sie eine Datenbank auf herkömmliche Weise 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

780
Thorsten

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

Oder verwenden Sie zum Reduzieren der E/A 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
422
hendrasaputra

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

Wählen Sie in phpMyAdmin die Datenbank aus, die Sie auswählen möchten. In den Registerkarten gibt es eine namens Operationen, gehen Sie zum Umbenennungsabschnitt. Das ist alles.

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

Enter image description here

198
raphie

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.

Sie können eines dieser beiden Skripte verwenden (ich schlug ursprünglich das erstere vor und jemand "verbesserte" meine Antwort, um GROUP_CONCAT zu verwenden. 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 und Ziel)

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

Beachten Sie, dass GROUP_CONCAT eine Standardlängenbeschränkung hat, die 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 Zahl) ausführen.

100
ErichBSchulz

Den fehlenden Befehl RENAME DATABASE in MySQL emulieren:

  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 Emulieren des fehlenden RENAME DATABASE-Befehls in MySQL entnommen.

35
Marciano

Drei Möglichkeiten:

  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 CREATE TABLE ... LIKE-Anweisungen, und verwenden Sie dann INSERT ... SELECT * FROM-Anweisungen.

  3. Verwenden Sie mysqldump und laden Sie die Datei erneut.

24
longneck

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

Getan...

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

24
DeeCee

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
20
Grijesh Chauhan

Ich bin erst kürzlich auf eine sehr nette Art und Weise dazu gestoßen, arbeite mit MyISAM und InnoDB und ist sehr schnell:

RENAME TABLE old_db.table TO new_db.table;

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

19
Amr Mostafa

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;
15
eaykin

Einfachste Methode, um eine vollständige Umbenennung durchzuführen (einschließlich des Ablegens der alten Datenbank am Ende, damit diese nicht kopiert, sondern umbenannt wird) :

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).
15
Steve Chambers

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 die Datenbanken speichert. Bei Standard-MySQL-Installationen befindet sich dies 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 sie 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 (unter Verwendung des gewünschten Namens) zu erstellen und die benötigten Daten von der alten in die neue zu exportieren/importieren. Ziemlich einfach.

14
bryanpearson

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

13
UnkwnTech

Nun gibt es 2 Methoden:

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

Aus 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 ein 100 GB? ist? Es gibt Methoden, mit denen Sie die obigen Befehle zusammenfassen können, um Speicherplatz 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 aufgewendet werden.

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

Erstellen Sie das neue Datenbankschema mit dem gewünschten Namen. Benennen Sie die Tabellen mit dem MySQL-Befehl "RENAME TABLE" von einem alten in ein neues 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 die folgenden Dinge tun:

1)Dump the triggers, events and stored routines in a separate file. Dies erfolgt mit den Flags -E, -R (zusätzlich zu -t -d, mit dem die Trigger ausgegeben werden) 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) Erzeugt eine Liste von nur "BASE" -Tabellen. Diese können mit einer Abfrage in der Tabelle information_schema.TABLES gefunden werden.

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

) Die Ansichten in eine Ausgangsdatei ausgeben. Ansichten können mithilfe einer Abfrage in derselben information_schema.TABLES -Tabelle 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ösche die Trigger für die aktuellen Tabellen im old_schema.

mysql> DROP TRIGGER <trigger_name>;
...

5) Stellen Sie die obigen Speicherauszugsdateien wieder her, sobald 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

Schwierigkeiten mit den oben genannten Methoden: Möglicherweise müssen wir die GRANTS für Benutzer so aktualisieren, dass sie mit dem korrekten schemanamen übereinstimmen. Diese Probleme 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 alte_schema-Name in new_schema geändert und "Flush privileges;" aufgerufen wird. Obwohl "Methode 2" etwas komplizierter erscheint als "Methode 1", ist dies vollständig skriptfähig. Mithilfe eines einfachen Bash-Skripts können Sie die obigen Schritte in der richtigen Reihenfolge ausführen und beim nächsten Umbenennen von Datenbankschemata Platz und Zeit sparen.

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

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

Um die Verwendung dieses Skripts zu demonstrieren, wurde ein Beispielschema "emp" verwendet, Test-Trigger erstellt und Routinen in diesem Schema gespeichert. Versucht, das Datenbankschema mithilfe des Skripts umzubenennen. Der Vorgang dauert einige Sekunden, im Gegensatz zur zeitaufwendigen Sicherungs-/Wiederherstellungsmethode.

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. 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
12
Sathish D

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

12
Duke

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

  1. Sie können nicht einfach RENAME TABLE verwenden, da es möglicherweise Views und Trigger gibt. Wenn es Trigger gibt, schlägt RENAME TABLE fehl
  2. Sie können mysqldump nicht verwenden, wenn Sie eine große Datenbank "schnell" (wie in der Frage angefordert) 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 von Simon R Jones veröffentlichtes (gemachtes?) Skript, 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 mit dem Namen rename_db und machen Sie das Skript mit chmod +x rename_db ausführbar. Verwenden Sie es dann wie ./rename_db localhost old_db new_db

9
ryantm

Es ist möglich, alle Tabellen in einer Datenbank so umzubenennen, dass sie sich unter einer anderen Datenbank befinden, ohne dass ein vollständiger Speicherauszug und eine vollständige Wiederherstellung durchgeführt werden müssen.

 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,'` .` ', tabellenname, '`TO`', new_db, '`.`', tabellenname, '`;') `# alter table` FROM information_schema.tables WHERE tabellenname = 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 

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

 mysql -uroot -e "mysql.rename_db ('test', 'blah2') aufrufen" | mysql -uroot 
 FEHLER 1435 (HY000) in Zeile 4: Trigger in falschem Schema 
9
TodoInTX

Schritte :

  1. Drücken Sie http: // localhost/phpmyadmin /
  2. Wählen Sie Ihre DB
  3. Klicken Sie auf die Registerkarte Operations
  4. Es wird eine Registerkarte als "Datenbank umbenennen in" angezeigt. Fügen Sie einen neuen Namen hinzu und aktivieren Sie das Kontrollkästchen Berechtigungen anpassen.
  5. Klicken Sie auf Los.

enter image description here

8
Shubham Jain

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 [Kennwort]

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

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

 - gespeicherte Prozedur rename_db: Eine Datenbank umbenennen, mit der meine Tabelle kopiert werden kann. 
 - Vorsichtsmaßnahmen: 
 - Eine vorhandene Datenbank mit demselben Namen wie die 'neue' wird blockiert. Datenbankname. 
 - Kopiert NUR Tabellen; gespeicherte Prozeduren und andere Datenbankobjekte werden nicht kopiert. 
 - Tomer Altman ([email protected]) 
 
 Trennzeichen //[.____ 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 IN current_table; 
 WENN NICHT DANN 
 SET @output = CONCAT ('alter table', old_db, '.', Current_table, 'rename', new_db, '.', Current_table, ';'); 
 PREPARE stmt FROM @output; 
 EXECUTE stmt; 
 
 END IF; 
 BIS done END REPEAT; 
 
 CLOSE old_tables; 
 
 END //
 Delimiter; 
7
user757945

Im Folgenden finden Sie ein kleines Shellscript, das mit zwei Parametern ausgeführt werden muss: db-name und new db-name.

Möglicherweise müssen Sie den mysql-Zeilen Login-Parameter hinzufügen, wenn Sie die .my.cnf-Datei nicht in Ihrem Home-Verzeichnis verwenden. Bitte erstellen Sie eine Sicherungskopie, 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"
6
gerrit damen

Ich stellte eine Frage zu Server Fault versuche, 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 haben wollte, da Dump/Import aufgrund der Größe unserer Datenbank keine Option war.

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

6
cclark

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 (Windows-Anwendungen unter Linux, BSD, Solaris und Mac OS X ausführen).

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

5
Fathah Rehman P

Hier ist eine schnelle Methode zum Generieren von SQL-Umbenennungsskripten, 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' ;
4
yantaq

Scheint niemand erwähnt, aber hier ist ein anderer Weg:

create database NewDatabaseName like OldDatabaseName;

dann mache für jeden Tisch:

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 ausgeführt wird, sodass sie viel schneller als ein Dump/Restore-Vorgang abläuft.

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

4

Für Mac-Benutzer können Sie Sequel Pro (kostenlos) verwenden. Dies bietet lediglich die Möglichkeit, Datenbanken umzubenennen. Die alte DB wird jedoch nicht gelöscht.

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

4
Roee Gavirel

Gehen Sie in MySQL Administrator wie folgt vor:

  1. Erstellen Sie unter Kataloge ein neues Datenbankschema.
  2. Gehen Sie zu Sicherung und erstellen Sie eine Sicherung des alten Schemas.
  3. Sicherung ausführen.
  4. Gehen Sie zu Wiederherstellen und öffnen Sie die in Schritt 3 erstellte Datei.
  5. Wählen Sie unter Zielschema die Option '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.
3
Tom

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, die alte Tabelle zu löschen und die Tabellendaten neu zu laden. Klicken Sie in beiden Fällen auf OK

Ihre Datenbank wird umbenannt

3
murtaza.webdev

Wenn Sie phpMyAdmin verwenden, können Sie zur Registerkarte "Operationen" wechseln, sobald 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 abschließend in diesem Bereich 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.

3
ecruz

Hier ist ein einzeiliges Bash-Snippet, um alle Tabellen von einem Schema in ein anderes zu verschieben:

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

Der Verlaufsbefehl beim Start stellt lediglich sicher, dass die MySQL-Befehle, die Kennwörter enthalten, nicht im Shell-Verlauf gespeichert werden.

Stellen Sie sicher, dass db_user über Lese-/Schreib-/Ablageberechtigungen für das alte Schema und über Lese-/Schreib-/Erstellungsberechtigungen für das neue Schema verfügt.

3
coffeefiend

Ich habe es so gemacht: Sichern Sie Ihre vorhandene Datenbank. Es wird dir eine db.Zip.tmp geben und dann in Eingabeaufforderung folgendes schreiben

"C:\Programme (x86)\MySQL\MySQL Server 5.6\bin\mysql.exe" -h localhost -u root -p [Kennwort] [neuer Datenbankname] <"C:\Backups\db.Zip.tmp "

3
Samra

ALTER DATABASE ist der von MySQL vorgeschlagene Weg, um dies zu umgehen, und _RENAME DATABASE_ wird verworfen.

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

3
xelber

Sie können dies auf zwei Arten tun.

  1. RENAME TABLE old_db.table_name TO new_db.table_name;
  2. Gehe zu Operationen -> dort siehst du die Registerkarte Tabellenoptionen. Dort können Sie den Tabellennamen bearbeiten.
2
jeeva

Dies ist das Batch-Skript, das ich zum Umbenennen einer Datenbank unter Windows geschrieben habe:

@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%"
2
Nadav Benedek

Dies funktioniert für alle Datenbanken und indem jede Tabelle mit maatkit mysql toolkit umbenannt wird

Verwenden Sie mk-find, um jede Tabelle zu drucken und umzubenennen. Die Manpage hat viele weitere Optionen und Beispiele

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

Wenn Sie ein Maatkit installiert haben ( was sehr einfach ist ), ist dies der einfachste Weg, dies zu tun.

Wenn Sie von einer Sicherungsdatei mit mehreren Datenbanken ausgehen, können Sie die Sicherung ausführen:

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

Dann importiere deinen Dump. Stellen Sie einfach sicher, dass es keinen Namenskonflikt gibt.

1
RotS

Weder die Lösung von TodoInTx noch die angepasste Lösung von user757945 funktionierten für mich unter MySQL 5.5.16. Daher ist hier meine angepasste Version:

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 ;

Hoffe es hilft jemandem, der in meiner Situation ist! Hinweis: @sql_string verweilt danach in der Sitzung. Ich konnte diese Funktion nicht schreiben, ohne sie zu benutzen.

1
Milosz

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 usw

  2. Öffnen Sie die Sicherungsdatei (zB 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

1
Adarsha

Wenn Sie hierarchische Ansichten verwenden (Ansichten, die Daten aus anderen Ansichten abrufen), funktioniert der Import von Rohdaten aus mysqldump möglicherweise nicht, da mysqldump nicht für die richtige Reihenfolge der Ansichten sorgt. Aus diesem Grund habe ich geschriebenes Skript , das Ansichten neu anordnet, um die Reihenfolge im laufenden Betrieb zu korrigieren.

Es sieht so aus:

#!/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);
            }
        }
    }
}

Verwendungszweck:
mysqldump -u username -v olddatabase -p | ./mysqldump_view_reorder.pl | mysql -u username -p -D newdatabase

1
gadelat

Ihr werdet mich dafür erschießen, und höchstwahrscheinlich wird das nicht jedes Mal funktionieren, und sicher ist es gegen jede Logik bla bla ... Aber was ich gerade versucht habe, ist ... Stoppt die MySQL-Engine, meldet euch an als root und einfach die DB auf Dateisystemebene umbenannt ....

Ich bin unter OSX und habe nur die Groß-/Kleinschreibung von bedbf auf BEDBF geändert. Zu meiner Überraschung hat es funktioniert ...

Ich würde es auf einer Produktions-DB nicht empfehlen. Ich habe das gerade als Experiment versucht ...

Viel Glück so oder so :-)

0
Lawrence

Ich habe dies gepostet Wie ändere ich den Datenbanknamen mit MySQL? heute nach Tagen des Kopfkratzens und Haarziehens. Die Lösung ist ganz einfach, ein Schema in eine .sql-Datei zu exportieren und die Datei zu öffnen und den Datenbank-/Schemanamen im Abschnitt sql CREAT TABLE oben zu ändern. Es gibt drei oder mehr Instanzen und möglicherweise nicht ganz oben auf der Seite, wenn mehrere Schemas in der Datei gespeichert sind. Es ist möglich, die gesamte Datenbank auf diese Weise zu bearbeiten, aber ich gehe davon aus, dass es in großen Datenbanken nach allen Instanzen einer Tabelleneigenschaft oder eines Indexes ziemlich schmerzhaft sein kann.

0
E.R.Rider

I). Es gibt keine direkte Möglichkeit, wie Sie den Namen einer vorhandenen Datenbank ändern können. Sie können Ihr Ziel jedoch erreichen, indem Sie die folgenden Schritte ausführen: 1). Erstelle eine neue Datenbank. 2). Benutze newdb. 3). create table table_name (wählen Sie * aus olddb.table_name);

Kopieren Sie dazu die Daten aus der Tabelle olddb und fügen Sie sie in die Tabelle newdb ein. Geben Sie den Namen der Tabelle gleich an.

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

0
rajesh