it-swarm-eu.dev

Jak rychle přejmenovat databázi MySQL (změna názvu schématu)?

Manuál MySQL na MySQL to pokrývá.

Obvykle jsem jen výpis databáze a znovu importovat s novým názvem. To není možnost pro velmi velké databáze. Zdá se, že RENAME {DATABASE | SCHEMA} db_name TO new_db_name;dělá špatné věci, existuje pouze v několika verzích a celkově je to špatný nápad .

To musí pracovat s InnoDB , který ukládá věci velmi odlišně než MyISAM .

866
deadprogrammer

Zdá se, že pro InnoDB funguje následující: vytvořte novou prázdnou databázi a poté každou tabulku přejmenujte na novou databázi:

RENAME TABLE old_db.table TO new_db.table;

Poté budete muset upravit oprávnění.

Pro skriptování v prostředí Shell můžete použít některou z následujících možností:

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

Nebo

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;

Poznámky:

  • Mezi volbou -p a heslem není mezera. Pokud vaše databáze nemá žádné heslo, odstraňte část -u username -ppassword.
  • Pokud má některá tabulka spoušť, nemůže být přesunuta do jiné databáze pomocí výše uvedené metody (výsledkem bude chyba Trigger in wrong schema). Pokud tomu tak je, použijte tradiční způsob, jak klonovat databázi a poté zrušit původní:

    mysqldump old_db | mysql new_db

  • Pokud máte uložené procedury, můžete je poté zkopírovat:

    mysqldump -R old_db | mysql new_db

756
Thorsten

Použijte těchto několik jednoduchých příkazů:

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

Chcete-li omezit I/O použití, postupujte takto, jak navrhl @Pablo Marin-Garcia:

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

Myslím, že řešení je jednodušší a bylo navrženo některými vývojáři. phpMyAdmin má k tomu operaci.

Z phpMyAdmin vyberte databázi, kterou chcete vybrat. V záložkách je jeden nazvaný Operations, přejděte do sekce přejmenování. To je vše.

To, jak mnozí navrhli, vytvořit novou databázi s novým názvem, výpis všech tabulek staré databáze do nové databáze a drop staré databáze.

Enter image description here

195
raphie

SQL můžete použít ke generování skriptu SQL pro přenos každé tabulky ve zdrojové databázi do cílové databáze.

Před spuštěním skriptu generovaného z příkazu musíte vytvořit cílovou databázi.

Můžete použít jeden z těchto dvou skriptů (původně jsem navrhl bývalého a někdo "vylepšil" mou odpověď na použití GROUP_CONCAT. Vezměte si svůj výběr, ale dávám přednost originálu):

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

nebo

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

($ 1 a $ 2 jsou zdroj a cíl)

Tím se vygeneruje příkaz SQL, který budete muset spustit.

GROUP_CONCAT má výchozí limit délky, který může být překročen pro databáze s velkým počtem tabulek. Tento limit můžete změnit spuštěním příkazu SET SESSION group_concat_max_len = 100000000; (nebo jiného velkého čísla).

97
ErichBSchulz

Emulace chybějícího příkazu RENAME DATABASE v MySQL:

  1. Vytvořit novou databázi
  2. Vytvořte přejmenované dotazy pomocí:

    SELECT CONCAT('RENAME TABLE ',table_schema,'.',table_name,
        ' TO ','new_schema.',table_name,';')
    FROM information_schema.TABLES
    WHERE table_schema LIKE 'old_schema';
    
  3. Spustit tento výstup

  4. Smazat starou databázi

Bylo převzato zEmulace příkazu Missing RENAME DATABASE v MySQL.

33
Marciano

Tři možnosti:

  1. Vytvořte novou databázi, spusťte server, přesuňte soubory z jedné složky databáze do druhé a restartujte server. Všimněte si, že to bude fungovat pouze v případě, že jsou všechny vaše tabulky MyISAM.

  2. Vytvořte novou databázi, použijte příkazy CREATE TABLE ... LIKE a potom použijte příkazy INSERT ... SELECT * FROM.

  3. Použijte mysqldump a znovu načtěte tento soubor.

24
longneck

Jednoduchý způsob

Změna adresáře databáze:

cd /var/lib/mysql/

Vypněte MySQL ... To je důležité!

/etc/init.d/mysql stop

Dobře, takhle nefunguje pro InnoDB nebo BDB databáze.

Přejmenovat databázi:

mv old-name new-name

... nebo stůl ...

cd database/

mv old-name.frm new-name.frm

mv old-name.MYD new-name.MYD

mv old-name.MYI new-name.MYI

Restartujte MySQL

/etc/init.d/mysql start

Hotovo...

OK, tímto způsobem nefunguje databáze InnoDB nebo BDB. V takovém případě musíte databázi vypsat a znovu importovat.

23
DeeCee

Nedávno jsem narazil na velmi pěkný způsob, jak to udělat, pracuje s MyISAM a InnoDB a je velmi rychlý:

RENAME TABLE old_db.table TO new_db.table;

Nevzpomínám si, kde jsem to četl, ale zásluhu na někoho jiného ne na mě.

19
Amr Mostafa

Tento skript Shell můžete použít:

Reference: Jak přejmenovat databázi MySQL?

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

Funguje to:

$ sh rename_database.sh oldname newname
18
Grijesh Chauhan

To je to, co používám:

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

Nejjednodušší způsob provádění a úplného rename (včetně zrušení staré databáze na konci, takže je to přejmenování místo kopie) :

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

Kroky:

  1. Zkopírujte řádky do programu Poznámkový blok.
  2. Nahraďte všechny odkazy na "olddbname", "newdbname", "mypassword" (+ volitelně "root") svými ekvivalenty.
  3. Proveďte jeden po druhém na příkazovém řádku (zadáním "y" po zobrazení výzvy).
15
Steve Chambers

MySQL v současné době nepodporuje přejmenování databáze prostřednictvím příkazového rozhraní, ale můžete přejmenovat databázi, pokud máte přístup k adresáři, ve kterém MySQL ukládá své databáze. Pro výchozí instalace MySQL je to obvykle v adresáři Data v adresáři, kde byl MySQL nainstalován. Vyhledejte název databáze, kterou chcete přejmenovat v adresáři Data a přejmenujte ji. Přejmenování adresáře však může způsobit některé problémy s oprávněními. Buďte si vědomi.

Poznámka: MySQL musíte před přejmenováním databáze zastavit

Doporučil bych vytvořit novou databázi (pomocí jména, které chcete) a exportovat/importovat data, která potřebujete, od starých po nová. Docela jednoduché.

14
bryanpearson

Když přejmenujete databázi v PHPMyAdmin, vytvoří se výpis, pak se kapky a znovu vytvoří databáze s novým názvem.

13
UnkwnTech

Existují 2 metody:

Metoda 1: Dobře známá metoda pro přejmenování schématu databáze je dumping schématu pomocí Mysqldump a jeho obnovení v jiném schématu a potom zrušení staré schéma (v případě potřeby).

Od Shell

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

Ačkoliv je výše uvedená metoda snadná, je časově a prostorově náročná. Co když je schéma více než 100 GB? Existují metody, ve kterých můžete výše uvedené příkazy propojit a ušetřit tak místo, ale nešetří čas.

K nápravě takových situací existuje další rychlá metoda, jak přejmenovat schémata, nicméně je třeba věnovat jim určitou pozornost.

Metoda 2: MySQL má velmi dobrou funkci pro přejmenování tabulek, které dokonce fungují napříč různými schématy. Tato operace přejmenování je atomová a nikdo jiný nemůže přistupovat k tabulce, zatímco je přejmenován. Dokončení trvá krátkou dobu, protože změna názvu tabulky nebo jejího schématu je pouze změnou metadat. Zde je procedurální přístup při přejmenování:

Vytvořte nové schéma databáze s požadovaným názvem. Přejmenujte tabulky ze starého schématu na nové schéma pomocí příkazu „RENAME TABLE“ MySQL. Zrušte staré schéma databáze. If there are views, triggers, functions, stored procedures in the schema, those will need to be recreated too. Pokud v tabulkách existují spouštěče, selže MySQL „RENAME TABLE“. K nápravě toho můžeme udělat následující věci:

1) Dump the triggers, events and stored routines in a separate file. To se provádí pomocí -E, -R příznaků (kromě -t -d, které vypíše triggery) do příkazu mysqldump. Jakmile jsou aktivační události dumpingové, budeme je muset vypustit ze schématu, aby příkaz RENAME TABLE fungoval.

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

2) Vytvořit seznam pouze „BASE“ tabulek. Naleznete je pomocí dotazu v tabulce information_schema.TABLES.

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

3) Výpis pohledů v out souboru. Zobrazení lze nalézt pomocí dotazu ve stejné tabulce 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) Drop aktivační události na aktuálních tabulkách v old_schema.

mysql> DROP TRIGGER <trigger_name>;
...

5) Obnovení výše uvedených souborů výpisu po přejmenování všech tabulek „Base“ nalezených v kroku # 2.

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

Složitosti s výše uvedenými metodami: Možná budeme muset aktualizovat GRANTS pro uživatele tak, aby odpovídaly správnému názvu schématu. Ty by mohly být opraveny pomocí jednoduchých tabulek UPDATE na mysql.columns_priv, mysql.procs_priv, mysql.tables_priv, mysql.db, které aktualizují název old_schema na new_schema a volají „Flush privilegia“. Ačkoliv se „metoda 2“ jeví o něco složitější než „metoda 1“, je to naprosto skriptovatelné. Jednoduchý bash skript k provedení výše uvedených kroků ve správném pořadí, vám může pomoci ušetřit místo a čas při přejmenování databázových schémat příště.

Tým Percona Remote DBA napsal skript nazvaný „rename_db“, který funguje následujícím způsobem:

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

Pro demonstraci použití tohoto skriptu bylo použito vzorové schéma „emp“, vytvořené testovací spouštěče, uložené rutiny na tomto schématu. Pokouší se přejmenovat schéma databáze pomocí skriptu, který trvá několik sekund, na rozdíl od časově náročné metody výpisu/obnovení.

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

Jak vidíte ve výše uvedeném výstupu, schéma databáze „emp“ bylo přejmenováno na „emp_test“ za méně než sekundu. Konečně, toto je skript od Percona to je používáno nahoře pro “metodu 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
12
Sathish D

Pro ty, kteří jsou uživatelé Mac, Sequel Pro má možnost Přejmenovat databázi v nabídce databáze. http://www.sequelpro.com/

12
Duke

Je možné přejmenovat všechny tabulky v databázi tak, aby se nacházely v jiné databázi, aniž by bylo nutné provádět úplný výpis a obnovení.

 POSTUP POKROKU POKUD EXISTUJE mysql.rename_db; 
 DELIMITER || 
 CREATE PROCEDURE mysql.rename_db (IN old_db VARCHAR (100), IN new_db VARCHAR (100)) 
 ZAČÁTEK 
 SELECT CONCAT ('CREATE DATABASE', new_db, ';') `# vytvořit novou databázi`; 
 SELECT CONCAT ('RENAME TABLE`', old_db, '`.`', table_name, '`TO`', new_db, '`.`', název_tabulky, '`;') `# alter table` Z informací_schema.tables WHERE table_schema = old_db; 
 SELECT CONCAT ('DROP DATABASE' ' , old_db, '`;')` # drop old database`; 
 END || 
 DELIMITER; 
 
 $ time mysql -uroot -e "volání mysql .rename_db ('db1', 'db2'); " | mysql -uroot 

Žádné spouštěče v cílovém db však nebudou šťastné. Nejdříve je budete muset po přejmenování znovu vytvořit a znovu vytvořit.

 mysql -uroot -e "volání mysql.rename_db ('test', 'blah2');" | mysql -uroot 
 ERROR 1435 (HY000) na řádku 4: Spuštění ve špatném schématu 
9
TodoInTX

Většina odpovědí je špatná z jednoho ze dvou důvodů:

  1. Nelze použít pouze tabulku RENAME TABLE, protože mohou existovat zobrazení a spouštěče. Pokud existují spouštěče, RENAME TABLE se nezdaří
  2. Nelze použít mysqldump, pokud chcete "rychle" (jak je požadováno v otázce) přejmenovat velkou databázi

Percona má blog o tom, jak to udělat dobře: https://www.percona.com/blog/2013/12/24/renaming-database-schema-mysql/

a napsal (vytvořil?) Simon R Jones, který dělá to, co je navrženo v tomto příspěvku. Opravil jsem chybu, kterou jsem našel ve skriptu. Můžete ji vidět zde:

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

Zde je jeho kopie:

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

Uložit soubor do souboru s názvem rename_db a provést skript spustitelný pomocí chmod +x rename_db a pak jej použít jako ./rename_db localhost old_db new_db

8
ryantm

Zde je dávkový soubor, který jsem napsal pro automatizaci z příkazového řádku, ale pro Windows/MS-DOS.

Syntaxe je rename_mysqldb databáze newdatabase -u [user] -p [heslo]

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

Uložená procedura TodoInTX pro mě nefungovala. Tady je moje bodnutí:

 - uložená procedura rename_db: Přejmenování databáze, kterou mám k dispozici pro kopírování tabulek. 
 - Caveats: 
 - Zablokuje všechny existující databáze se stejným názvem jako „nová“ název databáze. 
 - POUZE kopíruje tabulky; uložené procedury a další databázové objekty nejsou zkopírovány. 
 - Tomer Altman ([email protected]) 
 
 delimiter //
DROP POSTUP POKUD EXISTUJÍ 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 vyberte table_name z information_schema.tables kde 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; ____.] POKUD NENÍ provedeno TAK 
 SET @output = CONCAT ('alter table', old_db, '.', Current_table, 'přejmenovat', new_db, '.', Current_table, ';'); 
 PREPARE stmt FROM @output, 
 EXECUTE stmt; 
 
 END IF; 
 UNTIL provedeno END REPEAT; 
 
 CLOSE old_tables, 
 
 END // [.].] Oddělovač, 
7
user757945

Pro vaše pohodlí, níže je malý shell, který musí být proveden se dvěma parametry: db-name a nový db-name.

Pokud nepoužíváte soubor .my.cnf ve vašem domovském adresáři, budete možná muset přidat parametry login-lines do řádků mysql. Před provedením tohoto skriptu proveďte zálohu.


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

I jsem položil otázku na Server Fault snažil jsem se dostat přes výpadky při obnově velmi velkých databází pomocí MySQL Proxy. Neměl jsem žádný úspěch, ale nakonec jsem si uvědomil, co jsem chtěl, je funkce RENAME DATABASE, protože dump/import nebyl volbou kvůli velikosti naší databáze.

Do MySQL je zabudována funkce RENAME TABLE, takže jsem nakonec napsal jednoduchý skript Pythonu, abych to udělal za mě. Já to jsem poslal na GitHub v případě, že by to mohlo být užitečné ostatním.

6
cclark

Kroky:

  1. Hit http: // localhost/phpmyadmin/
  2. Vyberte svůj DB
  3. Klikněte na záložku Operace
  4. Bude mít kartu jako "Přejmenovat databázi na". Přidat nový název a zaškrtněte políčko Upravit oprávnění.
  5. Klikněte na Go.

 enter image description here

6
Shubham Jain

Nejjednodušší metodou je použití softwaru HeidiSQL. Je to volný a otevřený zdroj. Běží na Windows a na jakémkoliv Linuxu s Wine (spouštět Windows aplikace na Linuxu, BSD, Solarisu a Mac OS X).

Ke stažení HeidiSQL, goto http://www.heidisql.com/download.php .

Ke stažení Wine, goto http://www.winehq.org/ .

Chcete-li přejmenovat databázi v HeidiSQL, klikněte pravým tlačítkem myši na název databáze a vyberte příkaz Upravit. Poté zadejte nový název a stiskněte tlačítko OK.

Je to tak jednoduché.

5
Fathah Rehman P

Zde je rychlý způsob, jak generovat přejmenování skriptu sql, pokud máte mnoho tabulek pro přesun.

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

Zdá se, že se o tom nikdo nezmínil, ale tady je jiný způsob:

create database NewDatabaseName like OldDatabaseName;

pak pro každou tabulku:

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

pak, pokud chcete,

drop database OldDatabaseName;

Tento přístup by měl tu výhodu, že celý přenos na server s téměř nulovým síťovým provozem bude probíhat mnohem rychleji než dump/restore.

Pokud máte uložené procedury/zobrazení/atd., Můžete je také přenést.

4

Pro uživatele systému Mac můžete použít Sequel Pro (zdarma), které poskytují pouze možnost přejmenovat databáze. Ačkoli staré DB neodstraní.

po otevření příslušné databáze stačí kliknout na: Database -> Rename database...

4
Roee Gavirel

V MySQL Administrator proveďte následující:

  1. V části Katalogy vytvořte nové schéma databáze.
  2. Přejděte na položku Zálohování a vytvořte zálohu starého schématu.
  3. Spusťte zálohování.
  4. Přejděte na Obnovit a otevřete soubor vytvořený v kroku 3.
  5. V části Schéma cíle vyberte možnost Další schéma a vyberte nové schéma databáze.
  6. Spusťte nástroj Obnovení.
  7. Ověřte nové schéma a pokud vypadá dobře, vymažte staré schéma.
3
Tom

v phpmyadmin můžete snadno přejmenovat databázi

select database 

  goto operations tab

  in that rename Database to :

  type your new database name and click go

požádejte o zrušení starých dat tabulky a opětovného načtení tabulky, klepněte na tlačítko OK v obou

Databáze je přejmenována

3
murtaza.webdev

Pokud používáte phpMyAdmin můžete vybrat záložku "operace", jakmile vyberete databázi, kterou chcete přejmenovat. Pak jděte na poslední sekci "kopírovat databázi do" (nebo něco takového), zadejte jméno a vyberte níže uvedené možnosti. V tomto případě, myslím, že musíte vybrat "strukturu a data" a "vytvořit databázi před kopírováním" zaškrtávací políčka a nakonec stiskněte tlačítko "jít" v této sekci.

Mimochodem, používám phpMyAdmin ve španělštině, takže si nejsem jistý, jaké jsou názvy sekcí v angličtině.

3
ecruz

Zde je jeden řádek fragmentu Bash pro přesunutí všech tabulek z jednoho schématu do druhého:

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

Příkaz historie na začátku jednoduše zajišťuje, že příkazy MySQL obsahující hesla nejsou uloženy do historie Shell.

Ujistěte se, že db_user má oprávnění ke čtení/zápisu/poklesu na starém schématu a oprávnění ke čtení/zápisu/vytvoření nového schématu.

3
coffeefiend

Udělal jsem to takhle: Vezměte si zálohu své stávající databáze. To vám dá db.Zip.tmp a pak v příkazu Prompt psát následující

"C: Program Files (x86) MySQL MySQL Server 5.6 bin mysql.exe" -h localhost -u root -p [heslo] [nový název db] <"C: Zálohy db.Zip.tmp "

3
Samra

Můžete to udělat dvěma způsoby.

  1. TABULKA RENAME old_db.table_name TO new_db.table_name;
  2. Přejděte na operace-> zde můžete vidět kartu Možnosti tabulky. zde můžete upravit název tabulky.
2
jeeva

Toto je dávkový skript, který jsem napsal pro přejmenování databáze v systému Windows:

@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

ALTER DATABASE je navrhovaná cesta kolem tohoto MySQL a RENAME DATABASE je vynechán.

Od13.1.32 RENAME DATABASE Syntaxe:

RENAME {DATABASE | SCHEMA} db_name TO new_db_name;

Toto prohlášení bylo přidáno do MySQL 5.1.7, ale bylo zjištěno, že je nebezpečné a bylo odstraněno v MySQL 5.1.23.

2
xelber

To funguje pro všechny databáze a funguje přejmenováním každé tabulky pomocí maatkit mysql toolkit

Použijte mk-find pro tisk a přejmenování každé tabulky. Stránka man má mnohem více možností a příkladů

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

Pokud máte nainstalovaný maatkit ( což je velmi snadné ), pak je to nejjednodušší způsob, jak to udělat.

2

V případě, že spouštíte soubor s výpisem s několika databázemi, můžete provést záznam na výpisu:

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

Pak importujte svůj výpis. Jen zajistěte, aby nedošlo ke konfliktu jména.

1
RotS

Řešení TodoInTx ani přizpůsobené řešení user757945 nepracovaly pro mě na MySQL 5.5.16, takže zde je moje upravená verze:

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 ;

Doufám, že to pomůže někomu, kdo je v mé situaci! Pozn .: @sql_string bude v relaci pokračovat. Tuto funkci jsem nemohl napsat bez použití.

1
Milosz

Pro přejmenování databáze jsem použil následující metodu

  1. zálohovat soubor pomocí mysqldump nebo libovolného DB nástroje, např. heidiSQL, správce mysql atd

  2. Otevřete soubor back up (např. Backupfile.sql) v nějakém textovém editoru.

  3. Vyhledejte a nahraďte název databáze a uložte soubor.

4.Restore upravený soubor sql

1
Adarsha

Pokud používáte hierarchické pohledy (pohledy tahající data z jiných pohledů), import surového výstupu z mysqldump nemusí fungovat, protože mysqldump nezajímá správné pořadí pohledů. Z tohoto důvodu I napsal skript který re-order pohledy na správné pořadí za běhu.

Takhle to vypadá:

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

Používání:
mysqldump -u username -v olddatabase -p | ./mysqldump_view_reorder.pl | mysql -u username -p -D newdatabase

1
gadelat

Vy mě za to budete střílet a nejspíš to nebude fungovat pokaždé a jistě, je to proti všem logickým bla bla ... Ale to, co jsem se snažil, je ... STOP motoru MySQL, přihlášení jako root a jednoduše přejmenován na DB na úrovni souborového systému.

Já jsem na OSX, a jen změnil případ, od bedbf k BEDBF. K mému překvapení to fungovalo ...

Nedoporučoval bych to na produkční DB. Zkoušel jsem to jako experiment ...

Hodně štěstí oběma směry :-)

0
Lawrence

Poslal jsem tento Jak změním název databáze pomocí MySQL? dnes po dnech škrábání hlavy a tahání za vlasy. Řešení je poměrně jednoduché exportovat schéma do souboru .sql a otevřít soubor a změnit název databáze/schématu v sekci sql CREAT TABLE nahoře. Existují tři nebo více instancí a nemusí být v horní části stránky, pokud jsou do souboru uložena různá schémata. Je možné upravovat celou databázi tímto způsobem, ale očekávám, že ve velkých databázích by to mohlo být docela bolest po všech instancích vlastnosti tabulky nebo indexu.

0
E.R.Rider

I). Neexistuje žádný způsob, kterým by přímo u mohl změnit název stávající DB Ale u lze dosáhnout ur cíl podle níže uvedených kroků: - 1). Vytvořit newdb. 2). Použít newdb. 3). vytvořit tabulku název_tabulky (select * from olddb.table_name);

Tímto způsobem u u kopírujete data z tabulky olddb a vkládáte je do tabulky newdb. Uveďte název tabulky.

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

0
rajesh