database क्यों - मैं एक MySQL डेटाबेस का नाम बदल सकता हूं(स्कीमा नाम बदलें)?

में प्रणाली (25)

MySQL पर MySQL मैनुअल इसे शामिल करता है।

आम तौर पर मैं बस डेटाबेस को डंप करता हूं और इसे एक नए नाम से पुनः आयात करता हूं। यह बहुत बड़े डेटाबेस के लिए एक विकल्प नहीं है। स्पष्ट रूप से RENAME {DATABASE | SCHEMA} db_name TO new_db_name; RENAME {DATABASE | SCHEMA} db_name TO new_db_name; MySQL ।

इसे InnoDB साथ काम करने की ज़रूरत है, जो चीजों को MyISAM से बहुत अलग तरीके से स्टोर करता है।

Answers

एक पूर्ण नाम बदलने का सरलतम बुलेट-एंड-बेवकूफ तरीका (अंत में पुराने डेटाबेस को छोड़कर, इसलिए यह प्रतिलिपि के बजाय एक नाम है) :

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

कदम:

लाइनों को नोटपैड में कॉपी करें।
अपने समकक्षों के साथ सभी संदर्भों को "olddbname", "newdbname", "mypassword" (+ वैकल्पिक रूप से "रूट") पर बदलें।
कमांड लाइन पर एक करके एक निष्पादित करें (संकेत दिए जाने पर "y" दर्ज करना)।

आप अपने डेटाबेस डेटाबेस में प्रत्येक डेटाबेस को गंतव्य डेटाबेस में स्थानांतरित करने के लिए SQL स्क्रिप्ट उत्पन्न करने के लिए SQL का उपयोग कर सकते हैं।

आदेश से उत्पन्न स्क्रिप्ट चलाने से पहले आपको गंतव्य डेटाबेस बनाना होगा।

आप इनमें से किसी भी स्क्रिप्ट का उपयोग कर सकते हैं (मैंने मूल रूप से पूर्व और किसी को " GROUP_CONCAT का उपयोग करने के लिए" मेरे उत्तर में "सुधार" का सुझाव दिया है। अपना चयन करें, लेकिन मैं मूल पसंद करता हूं):

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 और $ 2 क्रमशः स्रोत और लक्ष्य हैं)

यह एक SQL कमांड उत्पन्न करेगा जिसे आपको तब चलाना होगा।

ध्यान दें कि GROUP_CONCAT की डिफ़ॉल्ट लंबाई सीमा है जो बड़ी संख्या में तालिकाओं वाले डेटाबेस के लिए पार हो सकती है। आप SET SESSION group_concat_max_len = 100000000; चलाकर उस सीमा को बदल सकते हैं SET SESSION group_concat_max_len = 100000000; (या कुछ अन्य बड़ी संख्या)।

मैं हाल ही में ऐसा करने के लिए एक बहुत अच्छा तरीका आया है, माईसाम और इनो डीबी के साथ काम करता है और बहुत तेज़ है:

RENAME TABLE old_db.table TO new_db.table;

मुझे याद नहीं है कि मैंने इसे कहाँ पढ़ा है लेकिन क्रेडिट किसी और के पास नहीं जाता है।

InnoDB के लिए, निम्न कार्य करने लगता है: नया खाली डेटाबेस बनाएं, फिर प्रत्येक तालिका को नए डेटाबेस में बदल दें:

RENAME TABLE old_db.table TO new_db.table;

इसके बाद आपको अनुमतियों को समायोजित करने की आवश्यकता होगी।

एक खोल में पटकथा के लिए, आप निम्न में से किसी एक का उपयोग कर सकते हैं:

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;

नोट्स: विकल्प -p और पासवर्ड के बीच कोई जगह नहीं है। यदि आपके डेटाबेस में कोई पासवर्ड नहीं है, तो -u username -ppassword भाग को हटा दें।

साथ ही, यदि आपने प्रक्रियाओं को संग्रहीत किया है, तो आप उन्हें बाद में कॉपी कर सकते हैं:

mysqldump -R old_db | mysql new_db

If you are using phpMyAdmin you can go to the "operations" tab once you have selected the database you want to rename. Then go to the last section "copy database to" (or something like that), give a name, and select the options below. In this case, I guess you must select "structure and data" and "create database before copying" checkboxes and, finally, press the "go" button in that section.

By the way, I'm using phpMyAdmin in Spanish so I'm not sure what the names of the sections are in English.

यही है वह जो मेरे द्वारा उपयोग किया जाता है:

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

सरल तरीका

डेटाबेस निर्देशिका में बदलें:

cd /var/lib/mysql/

MySQL बंद करें ... यह महत्वपूर्ण है!

/etc/init.d/mysql stop

ठीक है, इस तरह InnoDB या बीडीबी-डेटाबेस के लिए काम नहीं करता है।

डेटाबेस का नाम बदलें:

mv old-name new-name

... या टेबल ...

cd database/

mv old-name.frm new-name.frm

mv old-name.MYD new-name.MYD

mv old-name.MYI new-name.MYI

MySQL पुनरारंभ करें

/etc/init.d/mysql start

किया हुआ...

ठीक है, इस तरह InnoDB या बीडीबी डेटाबेस के साथ काम नहीं करता है। इस मामले में आपको डेटाबेस को डंप करना होगा और इसे फिर से आयात करना होगा।

एक पूर्ण डंप और पुनर्स्थापित करने के बिना किसी अन्य डेटाबेस के अंतर्गत डेटाबेस के भीतर सभी तालिकाओं का नाम बदलना संभव है।

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

हालांकि लक्ष्य डीबी में कोई ट्रिगर्स खुश नहीं होंगे। आपको पहले उन्हें छोड़ना होगा और फिर नाम के बाद उन्हें फिर से बनाना होगा।

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

For mac users, you can use Sequel Pro (free), which just provide the option to rename Databases. Though it doesn't delete the old DB.

once open the relevant DB just click: Database --> Rename database...

सबसे आसान तरीका HeidiSQL सॉफ़्टवेयर का उपयोग करना है। यह मुफ़्त और खुला स्रोत है। यह विंडोज और Wine साथ किसी भी लिनक्स पर चलता है (लिनक्स, बीएसडी, सोलारिस और मैक ओएस एक्स पर विंडोज़ अनुप्रयोग चलाएं)।

HeidiSQL डाउनलोड करने के लिए, goto http://www.heidisql.com/download.php ।

शराब डाउनलोड करने के लिए, goto http://www.winehq.org/ ।

HeidiSQL में डेटाबेस का नाम बदलने के लिए, बस डेटाबेस नाम पर राइट क्लिक करें और 'संपादित करें' का चयन करें। फिर एक नया नाम दर्ज करें और 'ओके' दबाएं।

यह बहुत आसान है।

Seems noone mentioned this but here is another way:

create database NewDatabaseName like OldDatabaseName;

then for each table do:

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

then, if you want to,

drop database OldDatabaseName;

This approach would have the advantage of doing the entire transfer on server with near zero network traffic, so it will go a lot faster than a dump/restore.

If you do have stored procedures/views/etc you might want to transfer them as well.

मुझे लगता है कि समाधान सरल है और कुछ डेवलपर्स द्वारा सुझाव दिया गया था। phpMyAdmin के लिए एक ऑपरेशन है।

PhpMyAdmin से, उस डेटाबेस का चयन करें जिसे आप चुनना चाहते हैं। टैब में ऑपरेशंस कहा जाता है, नाम बदलें अनुभाग पर जाएं। बस इतना ही।

जैसा कि कई सुझाव दिए गए हैं, नए नाम के साथ एक नया डेटाबेस बनाएं, पुराने डेटाबेस की सभी तालिकाओं को नए डेटाबेस में डंप करें और पुराने डेटाबेस को छोड़ दें।

यहां एक बैच फ़ाइल है जिसे मैंने कमांड लाइन से स्वचालित करने के लिए लिखा था, लेकिन यह विंडोज / एमएस-डॉस के लिए है।

सिंटेक्स rename_mysqldb डेटाबेस newdatabase -u [उपयोगकर्ता] -p [पासवर्ड] है

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

मैंने MySQL प्रॉक्सी का उपयोग करके बहुत बड़े डेटाबेस को पुनर्स्थापित करते समय सर्वर फॉल्ट पर डाउनटाइम प्राप्त करने का प्रयास करने पर एक प्रश्न उठाया । मुझे कोई सफलता नहीं मिली, लेकिन मुझे अंत में एहसास हुआ कि मैं क्या चाहता था RENAME डाटाबेस कार्यक्षमता क्योंकि डंप / आयात हमारे डेटाबेस के आकार के कारण एक विकल्प नहीं था।

MySQL में निर्मित एक RENAME तालिका कार्यक्षमता है इसलिए मैंने मेरे लिए नौकरी करने के लिए एक साधारण पायथन लिपि लिखना समाप्त कर दिया। मैंने इसे गिटहब पर पोस्ट किया है यदि यह दूसरों के लिए उपयोग किया जा सकता है।

यहां दिए गए अधिकांश उत्तर दो कारणों में से एक के लिए गलत हैं:

You cannot just use RENAME TABLE, because there might be views and triggers. If there are triggers, RENAME TABLE fails
You cannot use mysqldump if you want to "quickly" (as requested in the question) rename a big database

Percona has a blog post about how to do this well: https://www.percona.com/blog/2013/12/24/renaming-database-schema-mysql/

and script posted (made?) by Simon R Jones that does what is suggested in that post. I fixed a bug I found in the script. You can see it here:

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

Here is a copy of it:

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

Save it to a file called rename_db and make the script executable with chmod +x rename_db then use it like ./rename_db localhost old_db new_db

MySQL में अनुपलब्ध RENAME DATABASE आदेश को अनुकरण करना:

नया डेटाबेस बनाएं

इसके साथ नाम बदलें:

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

उस आउटपुट को चलाएं
पुराना डेटाबेस हटाएं

यह MySQL में लापता नाम नाम डाटाबेस कमांड को नकल करने से लिया गया था।

वैसे 2 तरीके हैं:

विधि 1: डेटाबेस स्कीमा का नाम बदलने के लिए एक प्रसिद्ध विधि है MySQLldump का उपयोग करके स्कीमा को डंप करके और इसे किसी अन्य स्कीमा में बहाल करना, और फिर पुराने स्कीमा को छोड़ना (यदि आवश्यक हो)।

शैल से

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

हालांकि उपर्युक्त विधि आसान है, यह समय और स्थान उपभोग करने वाला है। क्या होगा यदि स्कीमा 100 जीबी से अधिक है ? ऐसी विधियां हैं जहां आप अंतरिक्ष पर सहेजने के लिए उपरोक्त आदेशों को एकसाथ पाइप कर सकते हैं, हालांकि यह समय बचा नहीं पाएगा।

ऐसी परिस्थितियों का समाधान करने के लिए, स्कीमा का नाम बदलने के लिए एक और त्वरित तरीका है, हालांकि, इसे करने के दौरान कुछ देखभाल की जानी चाहिए।

विधि 2: MySQL की तालिकाओं का नाम बदलने के लिए एक बहुत अच्छी सुविधा है जो विभिन्न स्कीमा में भी काम करता है। यह नामकरण ऑपरेशन परमाणु है और इसका नाम बदलने के दौरान कोई और भी तालिका तक नहीं पहुंच सकता है। तालिका के नाम को बदलने के बाद इसे पूरा करने में थोड़ा समय लगता है या इसकी स्कीमा केवल मेटाडाटा परिवर्तन है। नाम बदलने पर प्रक्रियात्मक दृष्टिकोण यहां दिया गया है:

वांछित नाम के साथ नया डेटाबेस स्कीमा बनाएँ। MySQL के "RENAME टैबलेट" कमांड का उपयोग करके पुरानी स्कीमा से नई स्कीमा तक तालिकाओं का नाम बदलें। पुराने डेटाबेस स्कीमा ड्रॉप करें। If there are views, triggers, functions, stored procedures in the schema, those will need to be recreated too । MySQL का "RENAME टेबल" विफल रहता है यदि टेबल पर ट्रिगर्स मौजूद हैं। इसका समाधान करने के लिए हम निम्नलिखित बातें कर सकते हैं:

1) Dump the triggers, events and stored routines in a separate file. यह mysqldump कमांड में -E, -R झंडे (-t -d के अलावा जो ट्रिगर्स को डंप करता है) का उपयोग करके किया जाता है। एक बार ट्रिगर्स डंप किए जाने के बाद, हमें काम करने के लिए RENAME टेबल कमांड के लिए स्कीमा से उन्हें छोड़ना होगा।

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

2) केवल "आधार" टेबल की एक सूची उत्पन्न करें। इन्हें info_schema.TABLES तालिका पर एक क्वेरी का उपयोग करके पाया जा सकता है।

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

3) बाहर की फाइल में विचारों को डंप करें। दृश्य एक ही information_schema.TABLES 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) पुरानी_शेमा में मौजूदा तालिकाओं पर ट्रिगर्स को छोड़ दें।

mysql> DROP TRIGGER <trigger_name>;
...

5) चरण # 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

उपरोक्त विधियों के साथ जटिलताओं: हमें उपयोगकर्ताओं के लिए GRANTS को अपडेट करने की आवश्यकता हो सकती है जैसे कि वे सही schema_name से मेल खाते हैं। ये mysql.columns_priv, mysql.procs_priv, mysql.tables_priv, mysql.db टेबल पर old_schema नाम को new_schema पर अपडेट करने और "फ़्लश विशेषाधिकार" को कॉल करने के लिए एक साधारण अद्यतन के साथ तय किया जा सकता है। हालांकि "विधि 2" "विधि 1" से थोड़ा अधिक जटिल लगता है, यह पूरी तरह से पठनीय है। उचित अनुक्रम में उपर्युक्त चरणों को पूरा करने के लिए एक सरल बैश स्क्रिप्ट, अगली बार डेटाबेस स्कीमा का नाम बदलने के दौरान आपको स्थान और समय बचाने में मदद कर सकती है।

परकोना रिमोट डीबीए टीम ने "rename_db" नामक एक स्क्रिप्ट लिखी है जो निम्न तरीके से काम करती है:

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

इस स्क्रिप्ट के उपयोग को प्रदर्शित करने के लिए, उस स्कीमा पर एक नमूना स्कीमा "emp", परीक्षण परीक्षण ट्रिगर, संग्रहीत दिनचर्या का उपयोग किया गया। स्क्रिप्ट का उपयोग कर डेटाबेस स्कीमा का नाम बदलने का प्रयास करेगा, जो समय लेने वाली डंप / पुनर्स्थापना विधि के विपरीत पूर्ण होने में कुछ सेकंड लगते हैं।

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

जैसा कि आप उपर्युक्त आउटपुट में देख सकते हैं, डेटाबेस स्कीमा "emp" का नाम बदलकर "emp_test" कर दिया गया था। अंत में, यह पेर्कोनिया की लिपि है जिसका प्रयोग उपरोक्त "विधि 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

MySQL इस समय अपने कमांड इंटरफ़ेस के माध्यम से डेटाबेस के नामकरण का समर्थन नहीं करता है, लेकिन यदि आप उस निर्देशिका तक पहुंच प्राप्त करते हैं जिसमें MySQL अपने डेटाबेस संग्रहीत करता है तो आप डेटाबेस का नाम बदल सकते हैं। डिफ़ॉल्ट MySQL प्रतिष्ठानों के लिए यह आमतौर पर निर्देशिका के अंतर्गत डेटा निर्देशिका में होता है जहां MySQL स्थापित किया गया था। उस डेटाबेस का नाम ढूंढें जिसे आप डेटा निर्देशिका के अंतर्गत पुनर्नामित करना चाहते हैं और उसका नाम बदलें। निर्देशिका का नाम बदलने से कुछ अनुमति समस्याएं हो सकती हैं। ज़रा बच के।

नोट: डेटाबेस का नाम बदलने से पहले आपको MySQL को रोकना होगा

मैं एक नया डेटाबेस (जिस नाम को आप चाहते हैं उसका उपयोग करके) बनाने और पुराने से नए डेटा को निर्यात / आयात करने की अनुशंसा करता हूं। बहुत साधारण।

I did it this way: Take backup of your existing database. It will give you a db.zip.tmp and then in command prompt write following

"C:\Program Files (x86)\MySQL\MySQL Server 5.6\bin\mysql.exe" -h localhost -u root -p[password] [new db name] < "C:\Backups\db.zip.tmp"

In MySQL Administrator do the following:

Under Catalogs, create a new database schema.
Go to Backup and create a backup of the old schema.
Execute backup.
Go to Restore and open the file created in step 3.
Select 'Another Schema' under Target Schema and select the new database schema.
Start Restore.
Verify new schema and, if it looks good, delete the old one.

TodoInTX की संग्रहीत प्रक्रिया मेरे लिए काफी काम नहीं करती थी। यहां मेरा स्टैब है:

-- 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 ([email protected])

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 ;

आपकी सुविधा के लिए, नीचे एक छोटी शेलस्क्रिप्ट है जिसे दो पैरामीटर के साथ निष्पादित किया जाना है: डीबी-नाम और नया डीबी-नाम।

यदि आप अपनी होम-निर्देशिका में .my.cnf-file का उपयोग नहीं करते हैं तो आपको mysql-lines में लॉगिन-पैरामीटर जोड़ने की आवश्यकता हो सकती है। इस स्क्रिप्ट को निष्पादित करने से पहले कृपया बैकअप लें।

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

मैक उपयोगकर्ताओं के लिए, Sequel Pro डेटाबेस डेटाबेस में एक नाम बदलें डेटाबेस विकल्प है। http://www.sequelpro.com/

आप इस शेल स्क्रिप्ट का उपयोग कर सकते हैं:

संदर्भ: 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"

यह काम कर रहा है:

$ sh rename_database.sh oldname newname

संपादित करें

आप फ़ील्ड का उपयोग करके नाम बदल सकते हैं:

ALTER TABLE xyz CHANGE manufacurerid manufacturerid INT

http://dev.mysql.com/doc/refman/5.1/en/alter-table.html