Wie benenne ich schnell eine MySQL-Datenbank (ändern Schemaname)?

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

  •  09-06-2019
  •  | 
  •  

Frage

Das MySQL-Handbuch unter MySQL deckt diese.

In der Regel nur Dump ich die Datenbank und importieren Sie es mit einem neuen Namen. Dies ist keine Option für sehr große Datenbanken. Offenbar RENAME {DATABASE | SCHEMA} db_name TO new_db_name; tut schlechte Dinge, in einer Handvoll von Versionen nur existieren, und ist eine schlechte Idee Gesamt .

Dies muss mit InnoDB arbeiten, die Dinge ganz anders als MyISAM .

War es hilfreich?

Lösung

Für InnoDB, die folgende scheint zu funktionieren: die neue, leere Datenbank erstellen, dann jede Tabelle in die neue Datenbank wiederum umbenannt: 

RENAME TABLE old_db.table TO new_db.table;

Sie müssen die Berechtigungen danach einzustellen.

Für Scripting in einer Shell, können Sie eine der folgenden Aktionen 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;

Weitere Informationen:

  • Es gibt keinen Raum zwischen der Option -p und dem Passwort. Wenn Ihre Datenbank kein Passwort hat, entfernen Sie den -u username -ppassword Teil.

  • Wenn einige Tabelle einen Trigger hat, kann es nicht in eine andere Datenbank obige Verfahren unter Verwendung verschoben werden (wird Trigger in wrong schema Fehler führen). Wenn das der Fall ist, verwenden Sie eine traditionelle Art und Weise, eine Datenbank zu klonen und dann fällt die alten:

    mysqldump old_db | mysql new_db

  • Wenn Sie gespeicherte Prozeduren haben, können Sie diese kopieren danach:

    mysqldump -R old_db | mysql new_db

Andere Tipps

diese wenigen einfachen Befehle zur Verfügung: 

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

oder zu reduzieren I / O verwendet die folgende wie von @Pablo Marin-Garcia: 

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 eine Operation für diese.

Von phpMyAdmin, wählen Sie die Datenbank, die Sie auswählen möchten. In den Registerkarten gibt es eine namens Operationen, gehen Sie auf die Umbenennungs Abschnitt. Das ist alles.

Es tut, wie viele vorgeschlagen, eine neue Datenbank mit dem neuen Namen erstellen, sichern Sie alle Tabellen der alten Datenbank in die neue Datenbank und die alte Datenbank löscht.

Geben Sie Bildbeschreibung hier

Sie können mit SQL einem SQL-Skript generieren, jede Tabelle in der Quelldatenbank in die Zieldatenbank zu übertragen.

Sie müssen die Zieldatenbank erstellen, bevor das Skript aus dem Befehl erzeugt ausgeführt wird.

Sie eine dieser beiden Skripte verwenden können (Ich schlug vor, ursprünglich die ehemalige und jemand „verbessert“ meine Antwort GROUP_CONCAT verwenden Treffen Sie Ihre Wahl, aber ich ziehe 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 ist Quell- und Ziel respectively)

Damit wird ein SQL-Befehl generieren, die Sie haben werden, um dann ausgeführt werden.

Beachten Sie, dass GROUP_CONCAT eine Standard-Längengrenze hat, die mit einer großen Anzahl von Tabellen für die Datenbanken überschritten werden kann. Sie können diese Grenze ändern, indem SET SESSION group_concat_max_len = 100000000; (oder eine andere große Anzahl) ausgeführt wird.

emulieren den fehlenden RENAME DATABASE Befehl in MySQL:

  1. Erstellen Sie eine neue Datenbank

  2. Erstellen Sie die Umbenennungs Abfragen 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. , dass die Ausgabe starten

  4. Löschen Sie alte Datenbank

Es wurde von emulieren The Missing RENAME Befehl Datenbank in MySQL .

Drei Optionen:

  1. Erstellen Sie die neue Datenbank, bringen Sie den Server herunter, um die Dateien aus einer Datenbank-Ordner in den anderen bewegen, und den Server neu starten. Beachten Sie, dass dies nur funktioniert, wenn alle Ihre Tabellen MyISAM sind.

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

  3. Mit mysqldump und lädt mit dieser Datei.

Die einfache Art und Weise

Wechseln Sie in das Datenbankverzeichnis: 

cd /var/lib/mysql/

Shut down MySQL ... Das ist wichtig! 

/etc/init.d/mysql stop

Okay, diese Art und Weise funktioniert nicht für InnoDB oder BDB-Datenbanken.

Umbenennen Datenbank: 

mv old-name new-name

... oder die Tabelle ... 

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 

/etc/init.d/mysql start

Fertig ...

OK, wird auf diese Weise nicht mit InnoDB oder BDB-Datenbanken arbeiten. In diesem Fall müssen Sie die Datenbank und Re-Import es auszugeben.

Ich habe erst vor kurzem kam in eine sehr schöne Art und Weise, es zu tun, arbeitet mit MyISAM und InnoDB und ist sehr schnell: 

RENAME TABLE old_db.table TO new_db.table;

Ich kann mich nicht erinnern, wo ich es gelesen, aber Kredit geht an jemand anderes mich nicht.

Sie können diesen Shell-Skript verwenden:

Referenz: Wie eine MySQL-Datenbank umbenennen 

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

Dies ist, was ich benutze: 

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

Einfachstes Kugel-and-todsichere Methode, ein vollständig zu tun, umbenennen (einschließlich der alte Datenbank am Ende fallen, so ist es eine Umbenennungs eher als eine Kopie) : 

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") mit dem Mittel.
  3. Ausführen eines nach dem anderen auf der Befehlszeile (Eingabe von „y“, wenn Sie dazu aufgefordert).

MySQL unterstützt nicht die Umbenennung einer Datenbank durch die Befehlsschnittstelle zur Zeit, aber Sie können die Datenbank umbenennen, wenn Sie den Zugriff auf das Verzeichnis, in dem MySQL seine Datenbanken speichert. Für Standard-MySQL-Installationen ist dies in der Regel im Data-Verzeichnis unter dem Verzeichnis, in dem MySQL installiert wurde. Suchen Sie den Namen der Datenbank, die Sie unter dem Data-Verzeichnis umbenennen möchten, und benennen Sie es. obwohl das Verzeichnis umbenennen könnte einige Probleme mit Berechtigungen führen. Seien Sie sich bewusst.

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

Ich würde empfehlen, eine neue Datenbank zu erstellen (mit dem Namen, den Sie möchten) und Export / die Daten importieren Sie von der alten an die neue. Ganz einfach.

Wenn Sie eine Datenbank in phpMyAdmin umbenennen es einen Dump erstellt, dann fällt und erstellt die Datenbank mit dem neuen Namen.

Für diejenigen, die Mac-Benutzer sind, hat Sequel Pro eine Datenbank umbenennen Option im Menü Datenbank. http://www.sequelpro.com/

Nun gibt es zwei Methoden:

. Methode 1: Ein gut bekanntes Verfahren zum Schema umbenennen Datenbank ist durch das Schema mit Mysqldump Dumping und es in einem anderen Schema wiederherstellen und dann das alte Schema löscht (falls erforderlich)

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 Raum verbrauchen. Was passiert, wenn das Schema mehr als ein 100 GB ist? Es gibt Verfahren, bei denen Sie die obigen Befehle Rohr zusammen auf Platz zu sparen, wird es jedoch nicht Zeit sparen.

solche Situationen zu beheben, gibt es eine weitere schnelle Methode ist Schemas zu umbenennen, müssen jedoch einige darauf geachtet werden, während es zu tun.

Methode 2: MySQL hat eine sehr gute Funktion für Tabellen umbenennen, die auch in verschiedenen Schemata funktionieren. Diese Umbenennung ist atomar und sonst niemand auf die Tabelle zugreifen können, während seine umbenannt werden. Dies dauert eine kurze Zeit, da abzuschließen eine Tabelle Namen oder sein Schema zu ändern ist nur eine Änderung von Metadaten. Hier ist prozeduralen Ansatz bei den Umbenennungs tun:

Erstellen Sie das neue Datenbankschema mit dem gewünschten Namen. Benennen Sie die Tabellen aus dem alten Schema neues Schema, mit MySQL „RENAME TABLE“ Befehl. Löschen Sie die alte Datenbankschema. If there are views, triggers, functions, stored procedures in the schema, those will need to be recreated too. MySQL „RENAME TABLE“ schlägt fehl, wenn es vorhanden ist Auslöser auf den Tischen. 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 -E, -R-Flags (zusätzlich -d -t, die die Trigger) mit dem mysqldump Befehl gibt. Sobald Auslöser abgeladen werden, müssen wir sie aus dem Schema löschen, für RENAME TABLE-Befehl an der Arbeit. 

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

2) Erstellen Sie eine Liste von nur „BASE“ Tabellen. Diese können über eine Abfrage auf information_schema.TABLES Tabelle. 

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

3) Dump die Ansichten in einer Out-Datei. Ansichten können mit einer Abfrage auf der gleichen information_schema.TABLES Tabelle zu finden. 

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 für die aktuellen Tabellen in der old_schema. 

mysql> DROP TRIGGER <trigger_name>;
...

5) Wiederherstellen der oben Dump-Dateien, wenn alle „Base“ Tabellen in Schritt 2 gefunden werden umbenannt. 

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

Feinheit mit obigen Methoden: Wir müssen können die Zuschüsse für Benutzer aktualisieren, so dass sie die richtige schema_name entsprechen. Diese könnten fixiert mit einem einfachen UPDATE auf mysql.columns_priv, mysql.procs_priv, mysql.tables_priv, mysql.db Tabellen Aktualisierung der old_schema Namen new_schema und rufen „Flush Privilegien;“. Obwohl „Verfahren 2" ein wenig komplizierter als die „1-Methode" erscheint, ist dies völlig skriptfähig. Ein einfacher Bash-Skript, um die oben genannten Schritte in der richtigen Reihenfolge durchführen, können Sie Raum und Zeit sparen, während Datenbankschemata beim nächsten Mal umbenennen.

Die Percona Remote DBA-Team hat ein Skript namens „rename_db“ geschrieben, die in der folgenden Art und Weise funktioniert: 

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

die Verwendung dieses Skripts zu demonstrieren, verwendet, um ein Beispielschema „emp“, erstellt Test Trigger, gespeicherte Routinen auf diesem Schema. Werden versuchen, das Datenbankschema mit dem Skript zu benennen, das einige Sekunden dauert, als zu zeitraubend dump / restore Methode im Gegensatz zu beenden. 

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 das Datenbankschema „emp“ umbenannt wurde in „Emp_test“ in weniger als einer Sekunde sehen. Schließlich Dies ist das Skript von Percona, die für „Verfahren 2" oben 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

Es ist möglich, alle Tabellen in einer Datenbank umbenennen unter einer anderen Datenbank zu sein, ohne einen vollständigen Dump zu tun zu haben und wiederherstellen. 

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

Jedoch alle Trigger in dem Ziel db werden nicht glücklich sein. Sie müssen sie fallen erst dann erstellen Sie sie nach dem Umbenennungs. 

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

Die meisten Antworten hier sind falsch für einen von zwei Gründen:

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

Percona hat eine Blog-Post über, wie dies gut zu tun: https://www.percona.com/blog/ 2013/12 / 24 / Umbenennung-Datenbank-Schema-mysql /

und Skript geschrieben (hergestellt?) Von Simon R Jones, der das tut, was in diesem Beitrag vorgeschlagen wird. Ich wurde ein Fehler behoben ich im Skript gefunden. 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 eine Datei namens rename_db und das Skript ausführbar machen mit chmod +x rename_db verwenden Sie es dann wie ./rename_db localhost old_db new_db

Hier ist eine Batch-Datei, die ich schrieb es von der Kommandozeile zu automatisieren, aber es für Windows / MS-DOS.

Die Syntax ist rename_mysqldb Datenbank newdatabase -u [user] -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=

TodoInTX gespeicherte Prozedur für mich nicht ganz funktionieren. Hier ist mein Stab an sie: 

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

Schritte:

  1. http: // localhost / phpmyadmin /
  2. Wählen Sie ein DB
  3. Klicken Sie auf die Registerkarte Operations
  4. Es wird ein Register als „Rename-Datenbank“ sein. Hinzufügen neuer Name und überprüfen Privilegien einstellen.
  5. Klicken Sie auf Go.

image description hier

I eine Frage auf Server Fehler gestellt versuchen, um Ausfallzeiten zu erhalten, wenn sie durch den Einsatz von MySQL Proxy sehr großen Datenbanken wiederherstellen. Ich habe keinen Erfolg haben, aber ich merkte, am Ende, was ich wollte, war DATABASE Funktionalität RENAME da dump / Import aufgrund der Größe unserer Datenbank keine Option war.

Es gibt eine RENAME TABLE-Funktionalität, um MySQL gebaut, so endete ich einen einfachen Python-Skript schreiben Sie sich für mich um den Job zu tun. Ich habe posted es auf GitHub , falls es von Nutzen für andere sein könnte.

Für Ihre Bequemlichkeit ist eine kleine Shell, die mit zwei Parametern ausgeführt werden muss. Db-Name und neuer db-name

Möglicherweise müssen Login-Parameter auf die mysql-Linien hinzuzufügen, wenn Sie nicht über die .my.cnf-Datei in Ihrem Home-Verzeichnis. Bitte legen Sie eine Sicherungs bevor das Skript ausgeführt wird. 

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

Die einfachste Methode ist HeidiSQL Software zu nutzen. Es ist kostenlos und Open Source. Es läuft unter Windows und auf jedem Linux mit Wine (Ausführen von Windows-Anwendungen auf Linux, BSD, Solaris und Mac OS X).

Zum Herunterladen HeidiSQL, zur http://www.heidisql.com/download.php .

Zum Herunterladen des Weines, zur http://www.winehq.org/ .

Um eine Datenbank in HeidiSQL, benennen Sie einen Rechtsklick auf den Namen der Datenbank und wählen Sie ‚Bearbeiten‘. Dann geben Sie einen neuen Namen ein und drücken Sie ‚OK‘.

Es ist so einfach.

Hier ist ein schneller Weg, Umbenennen SQL-Skript zu generieren, wenn Sie viele Tabellen zu bewegen. 

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

Es scheint niemand dies erwähnt, aber hier ist eine andere Art und Weise: 

create database NewDatabaseName like OldDatabaseName;

dann für jede Tabelle zu tun: 

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

dann, wenn Sie wollen, 

drop database OldDatabaseName;

Dieser Ansatz würde den Vorteil hat, den gesamten Transfer auf Server mit nahem Null Netzwerkverkehr zu tun, so wird es viel schneller als ein dump / restore gehen.

Wenn Sie tun gespeicherte Prozeduren / Ansichten / etc Sie könnten sie wollen auch übertragen.

Für Mac-Anwender können Sie Sequel Pro (kostenfrei), benutzen, die bieten nur die Möglichkeit, Datenbanken umbenennen. Obwohl es nicht die alte DB nicht löschen.

, sobald die entsprechenden DB öffnen klicken Sie einfach auf: Database -> Rename database...

In MySQL Administrator wie folgt vor:

  1. Unter Katalogen, erstellen Sie ein neues Datenbankschema.
  2. Backup-Gehen und erstellen Sie eine Sicherungskopie das alte Schema.
  3. Backup ausführen.
  4. Gehen Sie auf die Datei wiederherstellen und öffnen erstellt in Schritt 3.
  5. Wählen Sie ‚Ein anderes Schema‘ unter Ziel Schema und wählen Sie die neue Datenbank Schema.
  6. Start wiederherstellen.
  7. Überprüfen Sie neue Schema und wenn es so aussieht gut, die alte löschen.

in phpMyAdmin Sie die Datenbank einfach umbenennen 

select database 

  goto operations tab

  in that rename Database to :

  type your new database name and click go

fragen alten Tisch fallen zu lassen und Tabellendaten klicken Sie auf OK in beiden neu laden

Ihre Datenbank wird umbenannt

Wenn Sie mit phpMyAdmin auf die „Operationen“ Reiter gehen können, wenn Sie ausgewählt haben die Datenbank möchten Sie umbenennen. Gehen Sie dann zum letzten Abschnitt „Kopie-Datenbank“ (oder so ähnlich), geben einen Namen ein, und wählen Sie die folgenden Optionen aus. In diesem Fall denke ich, Sie wählen müssen „Struktur und Daten“ und „Datenbank erstellen, bevor das Kopieren“ Kontrollkästchen und schließlich drücken Sie die Schaltfläche „Go“ in diesem Abschnitt.

By the way, ich bin mit phpMyAdmin auf Spanisch so bin ich nicht sicher, was die Namen der Abschnitte sind in englischer Sprache.

Hier ist eine einzeilige Bash Schnipsel 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

Die Geschichte Befehl zu Beginn stellt lediglich sicher, dass die MySQL-Befehl Passwörter enthalten, werden an die Shell Geschichte nicht gespeichert.

Stellen Sie sicher, dass db_user gelesen / Schreib / Drop-Berechtigungen auf dem alten Schema und Lesen / Schreiben / Erstellen von Berechtigungen für das neue Schema.

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top