mysql - Hoe kan ik snel een MySQL-database hernoemen (schemanaam wijzigen)?

De MySQL-handleiding op MySQLdekt dit.

Meestal dump ik de database en importeer ik deze opnieuw met een nieuwe naam. Dit is geen optie voor zeer grote databases. Blijkbaar RENAME {DATABASE | SCHEMA} db_name TO new_db_name;doet slechte dingen, bestaat slechts in een handvol versies en is over het algemeen een slecht idee.

Dit moet werken met InnoDB, die dingen heel anders opslaat dan MijnISAM.

Antwoord 1, autoriteit 100%

Voor InnoDBlijkt het volgende te werken: maak de nieuwe lege database aan en hernoem elke tabel om de beurt in de nieuwe database:

RENAME TABLE old_db.table TO new_db.table;

Daarna moet u de rechten aanpassen.

Voor scripting in een shell kunt u een van de volgende gebruiken:

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

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;

Opmerkingen:

Er is geen spatie tussen de optie -pen het wachtwoord. Als uw database geen wachtwoord heeft, verwijder dan het gedeelte -u username -ppassword.
Als een tabel een trigger heeft, kan deze niet naar een andere database worden verplaatst met de bovenstaande methode (zal resulteren in een Trigger in wrong schema-fout). Als dat het geval is, gebruik dan een traditionele manier om een database te klonen en verwijder de oude:

mysqldump old_db | mysql new_db
Als je opgeslagen procedures hebt, kun je ze daarna kopiëren:

mysqldump -R old_db | mysql new_db

Antwoord 2, autoriteit 51%

Gebruik deze paar eenvoudige commando’s:

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

Of gebruik het volgende om I/O te verminderen, zoals voorgesteld door @Pablo Marin-Garcia:

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

Antwoord 3, autoriteit 24%

Ik denk dat de oplossing eenvoudiger is en werd voorgesteld door sommige ontwikkelaars. phpMyAdmin heeft hier een bewerking voor.

Selecteer in phpMyAdmin de database die u wilt selecteren. In de tabbladen is er een met de naam Operations, ga naar het gedeelte hernoemen. Dat is alles.

Het maakt, zoals velen suggereerden, een nieuwe database met de nieuwe naam, dumpt alle tabellen van de oude database in de nieuwe database en laat de oude database vallen.

Antwoord 4, autoriteit 12%

U kunt SQL gebruiken om een SQL-script te genereren om elke tabel in uw brondatabase over te brengen naar de doeldatabase.

U moet de doeldatabase maken voordat u het script uitvoert dat met de opdracht is gegenereerd.

U kunt een van deze twee scripts gebruiken (ik heb oorspronkelijk het eerste voorgesteld en iemand heeft mijn antwoord “verbeterd” om GROUP_CONCATte gebruiken. Maak uw keuze, maar ik geef de voorkeur aan het origineel):

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

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

($1 en $2 zijn respectievelijk bron en doel)

Dit genereert een SQL-opdracht die u vervolgens moet uitvoeren.

Houd er rekening mee dat GROUP_CONCATeen standaardlengtelimiet heeft die kan worden overschreden voor databases met een groot aantal tabellen. U kunt die limiet wijzigen door SET SESSION group_concat_max_len = 100000000;(of een ander groot aantal) uit te voeren.

Antwoord 5, autoriteit 6%

De ontbrekende opdracht RENAME DATABASEemuleren in MySQL:

Maak een nieuwe database

Maak de hernoemingsquery’s met:

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

Voer die uitvoer uit
Verwijder oude database

Het is overgenomen van Emuleren van het ontbrekende RENAME DATABASE-commando in MySQL.

Antwoord 6, autoriteit 3%

U kunt dit shellscript gebruiken:

Referentie: Hoe hernoem ik een MySQL-database?

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

Het werkt:

$ sh rename_database.sh oldname newname

Antwoord 7, autoriteit 3%

Drie opties:

Maak de nieuwe database aan, haal de server uit de lucht, verplaats de bestanden van de ene databasemap naar de andere en start de server opnieuw op. Merk op dat dit alleen werkt als AL je tabellen MyISAM zijn.
Maak de nieuwe database, gebruik CREATE TABLE … LIKE-instructies en gebruik vervolgens INSERT … SELECT * FROM-instructies.
Gebruik mysqldump en laad opnieuw met dat bestand.

Antwoord 8, autoriteit 3%

De eenvoudige manier

Wijzigen in de databasedirectory:

cd /var/lib/mysql/

Sluit MySQL af… Dit is belangrijk!

/etc/init.d/mysql stop

Oké, op deze manier werkt niet voor Innodb of BDB-databases.

Hernoem de database:

mv old-name new-name

… of de tabel …

cd database/
mv old-name.frm new-name.frm
mv old-name.MYD new-name.MYD
mv old-name.MYI new-name.MYI

HERSTART MYSQL

/etc/init.d/mysql start

Gereed …

OK, op deze manier werkt niet met Innodb- of BDB-databases. In dit geval moet u de database dumpen en deze opnieuw importeren.

Antwoord 9, Autoriteit 2%

Ik heb maar onlangs een heel leuke manier overgekomen om het te doen, werkt met Myisam en Innodb en is erg snel:

RENAME TABLE old_db.table TO new_db.table;

Ik weet het niet meer waar ik het lees, maar het krediet gaat naar iemand anders die mij niet.

Antwoord 10, Autoriteit 2%

Eenvoudigste bullet-en-foolbestendige manier om een volledig te doen hernoemen (inclusief het laten vallen van de oude database aan het einde, dus het is een naam in plaats van een kopie) :

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

stappen:

Kopieer de lijnen naar Kladblok.
Vervang alle verwijzingen naar “Olddbname”, “Newdbname”, “MyPassword” (+ optioneel “root”) met uw equivalenten.
Voer één voor één uit op de opdrachtregel (die “y” invoeren wanneer daarom wordt gevraagd).

Antwoord 11, Autoriteit 2%

Dit is wat ik gebruik:

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

Antwoord 12, autoriteit 2%

Nou, er zijn 2 methoden:

Methode 1:Een bekende methode voor het hernoemen van databaseschema’s is door het schema te dumpen met Mysqldump en het te herstellen in een ander schema, en vervolgens het oude schema te verwijderen (indien nodig).

Van Shell

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

Hoewel de bovenstaande methode eenvoudig is, kost het veel tijd en ruimte. Wat als het schema meer dan 100 GB is?Er zijn methoden waarmee u de bovenstaande opdrachten kunt combineren om ruimte te besparen, maar het bespaart geen tijd.

Om dergelijke situaties te verhelpen, is er een andere snelle methode om schema’s te hernoemen, maar er moet enige voorzichtigheid in acht worden genomen.

Methode 2:MySQL heeft een zeer goede functie voor het hernoemen van tabellen die zelfs in verschillende schema’s werkt. Deze hernoemingsbewerking is atomair en niemand anders heeft toegang tot de tabel terwijl deze wordt hernoemd. Het duurt even voordat dit is voltooid, aangezien het wijzigen van de naam van een tabel of het schema ervan slechts een wijziging van de metagegevens is. Hier is een procedurele benadering bij het hernoemen:

Maak het nieuwe databaseschema met de gewenste naam.
Hernoem de tabellen van het oude schema naar het nieuwe schema met behulp van de MySQL-opdracht “RENAME TABLE”.
Verwijder het oude databaseschema.
If there are views, triggers, functions, stored procedures in the schema, those will need to be recreated too. MySQL’s “RENAME TABLE” mislukt als er triggers op de tabellen bestaan. Om dit te verhelpen kunnen we de volgende dingen doen:

1)Dump the triggers, events and stored routines in a separate file.Dit wordt gedaan met behulp van -E, -R vlaggen (naast -t -d die dumpt de triggers) naar de opdracht mysqldump. Zodra triggers zijn gedumpt, moeten we ze uit het schema verwijderen om de opdracht RENAME TABLE te laten werken.

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

2)Genereer een lijst met alleen “BASE”-tabellen. Deze kunnen worden gevonden met behulp van een zoekopdracht in de tabel information_schema.TABLES.

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

3)Dump de weergaven in een out-bestand. Weergaven kunnen worden gevonden met een zoekopdracht in dezelfde tabel information_schema.TABLES.

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)Laat de triggers op de huidige tabellen in het oude_schema vallen.

mysql> DROP TRIGGER <trigger_name>;
...

5)Herstel de bovenstaande dumpbestanden zodra alle “Base”-tabellen die in stap 2 zijn gevonden, zijn hernoemd.

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

Insluiten met bovenstaande methoden: we moeten mogelijk de subsidies voor gebruikers bijwerken, zodat ze overeenkomen met de juiste schema_name. Deze kunnen worden opgelost met een eenvoudige update op mysql.columns_priv, mysql.procs_priv, mysql.tables_priv, mysql.db-tafels die de oude_schema-naam updaten naar New_schema en het bellen “Flush-privileges”. Hoewel “methode 2” een beetje ingewikkelder lijkt dan de “methode 1”, is dit totaal schriftbaar. Een eenvoudig bashscript om de bovenstaande stappen in de juiste volgorde uit te voeren, kan u helpen ruimte en tijd te besparen tijdens het hernoemen van database-schema’s volgende keer.

Het DBA-team percona heeft een script geschreven dat “Rename_DB” wordt genoemd die op de volgende manier werkt:

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

Om het gebruik van dit script aan te tonen, gebruikte een voorbeeldschema “EMP”, gecreëerde testtriggers, opgeslagen routines op dat schema. Probeer het database-schema te hernoemen met behulp van het script, dat enkele seconden duurt om te voltooien in tegenstelling tot tijdrovende dump / herstelmethode.

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

Zoals u kunt zien in de bovenstaande uitvoer van de database schema “emp” werd omgedoopt tot “emp_test” in minder dan een seconde. Tenslotte Dit is het script van Percona die hierboven wordt gebruikt voor de “methode 2″.

#!/bin/bash
# Copyright 2013 Percona LLC and/or its affiliates
set -e
if [ -z "$3" ]; then
    echo "rename_db <server> <database> <new_database>"
    exit 1
fi
db_exists=`mysql -h $1 -e "show databases like '$3'" -sss`
if [ -n "$db_exists" ]; then
    echo "ERROR: New database already exists $3"
    exit 1
fi
TIMESTAMP=`date +%s`
character_set=`mysql -h $1 -e "show create database $2\G" -sss | grep ^Create | awk -F'CHARACTER SET ' '{print $2}' | awk '{print $1}'`
TABLES=`mysql -h $1 -e "select TABLE_NAME from information_schema.tables where table_schema='$2' and TABLE_TYPE='BASE TABLE'" -sss`
STATUS=$?
if [ "$STATUS" != 0 ] || [ -z "$TABLES" ]; then
    echo "Error retrieving tables from $2"
    exit 1
fi
echo "create database $3 DEFAULT CHARACTER SET $character_set"
mysql -h $1 -e "create database $3 DEFAULT CHARACTER SET $character_set"
TRIGGERS=`mysql -h $1 $2 -e "show triggers\G" | grep Trigger: | awk '{print $2}'`
VIEWS=`mysql -h $1 -e "select TABLE_NAME from information_schema.tables where table_schema='$2' and TABLE_TYPE='VIEW'" -sss`
if [ -n "$VIEWS" ]; then
    mysqldump -h $1 $2 $VIEWS > /tmp/${2}_views${TIMESTAMP}.dump
fi
mysqldump -h $1 $2 -d -t -R -E > /tmp/${2}_triggers${TIMESTAMP}.dump
for TRIGGER in $TRIGGERS; do
    echo "drop trigger $TRIGGER"
    mysql -h $1 $2 -e "drop trigger $TRIGGER"
done
for TABLE in $TABLES; do
    echo "rename table $2.$TABLE to $3.$TABLE"
    mysql -h $1 $2 -e "SET FOREIGN_KEY_CHECKS=0; rename table $2.$TABLE to $3.$TABLE"
done
if [ -n "$VIEWS" ]; then
    echo "loading views"
    mysql -h $1 $3 < /tmp/${2}_views${TIMESTAMP}.dump
fi
echo "loading triggers, routines and events"
mysql -h $1 $3 < /tmp/${2}_triggers${TIMESTAMP}.dump
TABLES=`mysql -h $1 -e "select TABLE_NAME from information_schema.tables where table_schema='$2' and TABLE_TYPE='BASE TABLE'" -sss`
if [ -z "$TABLES" ]; then
    echo "Dropping database $2"
    mysql -h $1 $2 -e "drop database $2"
fi
if [ `mysql -h $1 -e "select count(*) from mysql.columns_priv where db='$2'" -sss` -gt 0 ]; then
    COLUMNS_PRIV="    UPDATE mysql.columns_priv set db='$3' WHERE db='$2';"
fi
if [ `mysql -h $1 -e "select count(*) from mysql.procs_priv where db='$2'" -sss` -gt 0 ]; then
    PROCS_PRIV="    UPDATE mysql.procs_priv set db='$3' WHERE db='$2';"
fi
if [ `mysql -h $1 -e "select count(*) from mysql.tables_priv where db='$2'" -sss` -gt 0 ]; then
    TABLES_PRIV="    UPDATE mysql.tables_priv set db='$3' WHERE db='$2';"
fi
if [ `mysql -h $1 -e "select count(*) from mysql.db where db='$2'" -sss` -gt 0 ]; then
    DB_PRIV="    UPDATE mysql.db set db='$3' WHERE db='$2';"
fi
if [ -n "$COLUMNS_PRIV" ] || [ -n "$PROCS_PRIV" ] || [ -n "$TABLES_PRIV" ] || [ -n "$DB_PRIV" ]; then
    echo "IF YOU WANT TO RENAME the GRANTS YOU NEED TO RUN ALL OUTPUT BELOW:"
    if [ -n "$COLUMNS_PRIV" ]; then echo "$COLUMNS_PRIV"; fi
    if [ -n "$PROCS_PRIV" ]; then echo "$PROCS_PRIV"; fi
    if [ -n "$TABLES_PRIV" ]; then echo "$TABLES_PRIV"; fi
    if [ -n "$DB_PRIV" ]; then echo "$DB_PRIV"; fi
    echo "    flush privileges;"
fi

Antwoord 13, Autoriteit 2%

MySQL ondersteunt de hernieuwing van een database op dit moment niet via de opdrachtinterface, maar u kunt de database hernoemen als u toegang hebt tot de map waarin MySQL zijn databases opslaat. Voor standaard MySQL-installaties is dit meestal in de gegevensmap onder de map waarbij MySQL is geïnstalleerd. Zoek de naam van de database die u wilt wijzigen onder de gegevensmap en hernoem het. Het hernoemen van de map kan echter een aantal machtigingen veroorzaken. Houd er rekening mee.

Opmerking: U moet MySQL stoppen voordat u de database kunt hernoemen

Ik zou aanraden om een nieuwe database te maken (met behulp van de gewenste naam) en de gegevens exporteren / importeren die u nodig hebt van het oude aan het nieuwe. Vrij eenvoudig.

Antwoord 14, Autoriteit 2%

Stappen:

Hit http: // localhost / phpmyadmin /
Selecteer uw DB
Klik op het tabblad Operaties
Er is een tabblad als “de database hernoemen naar”. Voeg nieuwe naam toe en controleer de privileges aan.
Klik op GO.

Antwoord 15

Wanneer u een database in PHPMYADMIN hernoemt, maakt het een dump en laat vervolgens de database met de nieuwe naam opnieuw op.

Antwoord 16

Voor degenen die MAC-gebruikers zijn, heeft Sequel Pro een hernoemingsdatabase-optie in het database-menu.
http://www.quêtePro.com/

Antwoord 17

De meeste antwoorden hier zijn verkeerd voor een van de volgende twee redenen:

U kunt de naam van de hernootschap niet alleen gebruiken, omdat er mogelijk uitzicht en triggers kunnen zijn. Als er triggers zijn, mislukt de hernoemende tabel
U kunt MySqldump niet gebruiken als u “snel” (zoals gevraagd in de vraag) een grote database wilt wijzigen

PERCONA heeft een blogpost over hoe dit goed te doen:
https://www.percona.com/blog/ 2013 / 12/24 / Renaming-database-schema-mysql /

en script gepost (gemaakt?) Door Simon R Jones die doet wat in die post wordt gesuggereerd. Ik heb een bug gerepareerd die ik in het script heb gevonden. Je kunt het hier zien:

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

Hier is een kopie hiervan:

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

Sla het op in een bestand met de naam rename_dben maak het script uitvoerbaar met chmod +x rename_dben gebruik het dan als ./rename_db localhost old_db new_db

Antwoord 18

Het is mogelijk om alle tabellen in een database te hernoemen zodat ze onder een andere database staan zonder een volledige dump en herstel uit te voeren.

DROP-PROCEDURE INDIEN BESTAAT mysql.rename_db;
DELIMITER ||
PROCEDURE MAKEN mysql.rename_db(IN old_db VARCHAR(100), IN new_db VARCHAR(100))
BEGINNEN
SELECT CONCAT('CREATE DATABASE ', new_db, ';') `# maak nieuwe database';
SELECT CONCAT('RENAME TABLE '', old_db, ''.'', table_name, '' TO '', new_db, ''.'', table_name, '';') `# alter table` FROM information_schema.tables WAAR table_schema = oude_db;
SELECT CONCAT('DROP DATABASE '', old_db, '';') `# laat oude database vallen';
EINDE||
DELIMITER ;
$ time mysql -uroot -e "bel mysql.rename_db('db1', 'db2');" | mysql -uroot

Maar eventuele triggers in de doel-db zullen niet blij zijn. Je moet ze eerst verwijderen en daarna opnieuw maken na de hernoeming.

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

Antwoord 19

Hier is een batchbestand dat ik heb geschreven om het vanaf de opdrachtregel te automatiseren, maar dan voor Windows/MS-DOS.

Syntaxis is rename_mysqldb database newdatabase -u [gebruiker] -p[wachtwoord]

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

Antwoord 20

Het lijkt erop dat niemand dit heeft genoemd, maar hier is een andere manier:

create database NewDatabaseName like OldDatabaseName;

doe voor elke tafel:

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

dan, als je wilt,

drop database OldDatabaseName;

Deze aanpak zou het voordeel hebben dat de volledige overdracht op de server wordt uitgevoerd met bijna nul netwerkverkeer, dus het zal een stuk sneller gaan dan een dump/restore.

Als je wel opgeslagen procedures/views/etc hebt, wil je ze misschien ook overzetten.

Antwoord 21

De opgeslagen procedure van TodointX werkte niet helemaal voor mij. Hier is mijn steek op:

- Opgeslagen procedure Rename_DB: Hernoem een database mijn middel voor tabel kopiëren.
- Bewaarslagen:
- Clobber elke bestaande database met dezelfde naam als de 'nieuwe' databasenaam.
- Alleen kopieert tabellen; Opgeslagen procedures en andere database-objecten worden niet gekopieerd.
- tomer altman ([email protected])
Afscheiding //
DROPPRODUCTIE ALS RENAST_DB;
Maak procedure Rename_DB (in Old_db Varchar (100), in New_DB VARCHAR (100))
BEGINNEN
  Verklaar van stroomstafelvarchar (100);
  Verklaar tot de standaard 0;
  Verklaar Old_tables Cursor voor Selecteer Table_Name van Information_schema.tables waar Table_schema = Old_db;
  Verklaar doorgaan met handler voor niet gevonden set gedaan = 1;
  SET @OUTPUT = CONCATISCH ('DROP SCHEMA ALS', NEW_DB, ';');
  Bereid Stmt voor van @output;
  EXECUTE STMT;
  Set @output = concat ('Schema maken, indien niet bestaat', new_db ';');
  Bereid Stmt voor van @output;
  EXECUTE STMT;
  Open old_tables;
  HERHALEN
    Halen oud_tables in huidigstabel;
    Zo niet gedaan
    Set @output = Concat ('Alter Table', Old_db, '.', Current_table, 'Hernoem', New_DB ',', Current_table ';');
    Bereid Stmt voor van @output;
    EXECUTE STMT;
    STOP ALS;
  Tot het einde van het einde wordt herhaald;
  Sluit oude_tables;
EINDE//
scheidingsteken;

Antwoord 22

De eenvoudigste methode is om HeidisQL-software te gebruiken. Het is gratis en open source. Het loopt op Windows en op elke Linux met wijn (voer Windows Toepassingen uit op Linux, BSD, Solaris en Mac & NBSP; OS & NBSP; X).

HeidisQL downloaden, goto http://www.heidisql.com/download.php .

Als u Wine wilt downloaden, gaat u naar http://www.winehq.org/.

Om de naam van een database in HeidiSQL te wijzigen, klikt u met de rechtermuisknop op de databasenaam en selecteert u ‘Bewerken’. Voer vervolgens een nieuwe naam in en druk op ‘OK’.

Het is zo eenvoudig.

Antwoord 23

Voor mac-gebruikers kunt u Sequel Pro(gratis) gebruiken, die alleen de mogelijkheid biedt om de databases te hernoemen. Hoewel het de oude DB niet verwijdert.

zodra de relevante DB is geopend, klikt u gewoon op: Database–> Rename database...

Antwoord 24

Ik stelde een vraag over Server Faultom downtime te omzeilen bij het herstellen van zeer grote databases met behulp van MySQL Proxy. Ik had geen succes, maar ik realiseerde me uiteindelijk dat ik de DATABASE-functionaliteit RENAME wilde, omdat dump/import geen optie was vanwege de grootte van onze database.

Er is een RENAME TABLE-functionaliteit ingebouwd in MySQL, dus ik heb uiteindelijk een eenvoudig Python-script geschreven om het werk voor mij te doen. Ik heb het op GitHub geplaatstvoor het geval anderen er iets aan hebben.

Antwoord 25

Voor uw gemak vindt u hieronder een klein shellscript dat moet worden uitgevoerd met twee parameters: db-name en new db-name.

Mogelijk moet u login-parameters toevoegen aan de mysql-regels als u het .my.cnf-bestand in uw home-directory niet gebruikt. Maak een back-up voordat u dit script uitvoert.

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

Antwoord 26

ALTER DATABASEis de door MySQL voorgestelde manier om dit te omzeilen en wordt RENAME DATABASEverwijderd.

Van 13.1.32 RENAME DATABASE-syntaxis:

RENAME {DATABASE | SCHEMA} db_name TO new_db_name;

Deze verklaring is toegevoegd in MySQL 5.1.7, maar werd gevaarlijk bevonden en werd verwijderd in MySQL 5.1.23.

Antwoord 27

Doe in MySQL Administrator het volgende:

Maak onder Catalogi een nieuw databaseschema.
Ga naar Back-up en maak een back-up van
het oude schema.
Voer een back-up uit.
Ga naar Herstellen en open het bestand
gemaakt in stap 3.
Selecteer ‘Een ander schema’ onder Doel
Schema en selecteer de nieuwe database
schema.
Herstellen starten.
Verifieer het nieuwe schema en, als het er uitziet
goed, verwijder de oude.

Antwoord 28

in phpmyadminkun je de database gemakkelijk hernoemen

select database 
  goto operations tab
  in that rename Database to :
  type your new database name and click go

vraag om de oude tabel te verwijderen en de tabelgegevens opnieuw te laden klik op OK in beide

Uw database is hernoemd

Antwoord 29

Hier is een snelle manier om het hernoemen van SQL-scripts te genereren, als u veel tabellen moet verplaatsen.

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

Antwoord 30

Als u phpMyAdmingebruikt, kunt u naar het tabblad “bewerkingen” gaan als u eenmaal hebt geselecteerd de database die u wilt hernoemen. Ga dan naar de laatste sectie “database kopiëren naar” (of iets dergelijks), geef een naam en selecteer de onderstaande opties. In dit geval denk ik dat je de selectievakjes “structuur en gegevens” en “database maken voordat je kopieert” moet selecteren en ten slotte op de knop “go” in die sectie moet drukken.

Trouwens, ik gebruik phpMyAdmin in het Spaans, dus ik weet niet zeker wat de namen van de secties in het Engels zijn.

Hoe kan ik snel een MySQL-database hernoemen (schemanaam wijzigen)?