Kopieren / Duplizieren der Datenbank ohne Verwendung von mysqldump

Gibt es ohne lokalen Zugriff auf den Server eine Möglichkeit, eine MySQL-Datenbank (mit und ohne Inhalt) ohne Verwendung in eine andere zu duplizieren / klonen mysqldump?

Ich verwende derzeit MySQL 4.0.

Ich kann sehen, dass Sie gesagt haben, Sie wollten nicht verwenden mysqldump, aber ich habe diese Seite erreicht, als ich nach einer ähnlichen Lösung gesucht habe, und andere könnten sie auch finden. In diesem Sinne gibt es eine einfache Möglichkeit, eine Datenbank über die Befehlszeile eines Windows-Servers zu duplizieren:

1. Erstellen Sie die Zieldatenbank mit MySQLAdmin oder Ihrer bevorzugten Methode. In diesem Beispiel db2handelt es sich um die Zieldatenbank, in die die Quellendatenbank db1kopiert wird.
2. Führen Sie die folgende Anweisung in einer Befehlszeile aus:

mysqldump -h [server] -u [user] -p[password] db1 | mysql -h [server] -u [user] -p[password] db2

Hinweis: Zwischen -pund befindet sich KEIN Leerzeichen[password]

Sie können eine Tabelle ohne Daten duplizieren, indem Sie Folgendes ausführen:

CREATE TABLE x LIKE y;

(Siehe die MySQL CREATE TABLE Docs)

Sie können ein Skript schreiben, das die Ausgabe SHOW TABLESaus einer Datenbank übernimmt und das Schema in eine andere kopiert. Sie sollten in der Lage sein, auf Schema- und Tabellennamen wie folgt zu verweisen:

CREATE TABLE x LIKE other_db.y;

Was die Daten betrifft, können Sie dies auch in MySQL tun, aber es ist nicht unbedingt schnell. Nachdem Sie die Referenzen erstellt haben, können Sie Folgendes ausführen, um die Daten zu kopieren:

INSERT INTO x SELECT * FROM other_db.y;

Wenn Sie MyISAM verwenden, ist es besser, die Tabellendateien zu kopieren. es wird viel schneller sein. Sie sollten in der Lage sein, dasselbe zu tun, wenn Sie INNODB mit Tabellenbereichen pro Tabelle verwenden .

Wenn Sie am Ende eine machen INSERT INTO SELECT, stellen Sie sicher, dass Sie die Indizes mit vorübergehend deaktivierenALTER TABLE x DISABLE KEYS !

EDIT Maatkit hat auch einige Skripte , die für die Synchronisierung Daten hilfreich sein kann. Es ist möglicherweise nicht schneller, aber Sie könnten wahrscheinlich ihre Synchronisierungsskripte für Live-Daten ausführen, ohne viel zu sperren.

Wenn Sie Linux verwenden, können Sie dieses Bash-Skript verwenden: (Es erfordert möglicherweise eine zusätzliche Code-Bereinigung, funktioniert aber ... und ist viel schneller als mysqldump | mysql)

#!/bin/bash

DBUSER=user
DBPASSWORD=pwd
DBSNAME=sourceDb
DBNAME=destinationDb
DBSERVER=db.example.com

fCreateTable=""
fInsertData=""
echo "Copying database ... (may take a while ...)"
DBCONN="-h ${DBSERVER} -u ${DBUSER} --password=${DBPASSWORD}"
echo "DROP DATABASE IF EXISTS ${DBNAME}" | mysql ${DBCONN}
echo "CREATE DATABASE ${DBNAME}" | mysql ${DBCONN}
for TABLE in `echo "SHOW TABLES" | mysql $DBCONN $DBSNAME | tail -n +2`; do
        createTable=`echo "SHOW CREATE TABLE ${TABLE}"|mysql -B -r $DBCONN $DBSNAME|tail -n +2|cut -f 2-`
        fCreateTable="${fCreateTable} ; ${createTable}"
        insertData="INSERT INTO ${DBNAME}.${TABLE} SELECT * FROM ${DBSNAME}.${TABLE}"
        fInsertData="${fInsertData} ; ${insertData}"
done;
echo "$fCreateTable ; $fInsertData" | mysql $DBCONN $DBNAME

In PHP:

function cloneDatabase($dbName, $newDbName){
    global $admin;
    $db_check = @mysql_select_db ( $dbName );
    $getTables  =   $admin->query("SHOW TABLES");   
    $tables =   array();
    while($row = mysql_fetch_row($getTables)){
        $tables[]   =   $row[0];
    }
    $createTable    =   mysql_query("CREATE DATABASE `$newDbName` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;") or die(mysql_error());
    foreach($tables as $cTable){
        $db_check   =   @mysql_select_db ( $newDbName );
        $create     =   $admin->query("CREATE TABLE $cTable LIKE ".$dbName.".".$cTable);
        if(!$create) {
            $error  =   true;
        }
        $insert     =   $admin->query("INSERT INTO $cTable SELECT * FROM ".$dbName.".".$cTable);
    }
    return !isset($error);
}


// usage
$clone  = cloneDatabase('dbname','newdbname');  // first: toCopy, second: new database

Beachten Sie, dass es einen mysqldbcopy-Befehl als Teil der Add-on-mysql-Dienstprogramme gibt .... https://dev.mysql.com/doc/mysql-utilities/1.5/en/utils-task-clone-db.html

Ich weiß nicht genau, was Sie unter "lokalem Zugang" verstehen. Für diese Lösung müssen Sie jedoch über ssh auf den Server zugreifen können, um die Dateien zu kopieren, in denen die Datenbank gespeichert ist .

Ich kann mysqldump nicht verwenden, da meine Datenbank groß ist (7Go, mysqldump fehlgeschlagen). Wenn die Version der 2 mysql-Datenbank zu unterschiedlich ist, funktioniert sie möglicherweise nicht. Sie können Ihre mysql-Version mit mysql -V überprüfen.

1) Kopieren Sie die Daten von Ihrem Remote-Server auf Ihren lokalen Computer (vps ist der Alias ​​für Ihren Remote-Server und kann durch [email protected] ersetzt werden.)

ssh vps:/etc/init.d/mysql stop
scp -rC vps:/var/lib/mysql/ /tmp/var_lib_mysql
ssh vps:/etc/init.d/apache2 start

2) Importieren Sie die auf Ihren lokalen Computer kopierten Daten

/etc/init.d/mysql stop
sudo chown -R mysql:mysql /tmp/var_lib_mysql
sudo nano /etc/mysql/my.cnf
-> [mysqld]
-> datadir=/tmp/var_lib_mysql
/etc/init.d/mysql start

Wenn Sie eine andere Version haben, müssen Sie diese möglicherweise ausführen

/etc/init.d/mysql stop
mysql_upgrade -u root -pPASSWORD --force #that step took almost 1hrs
/etc/init.d/mysql start

Alle früheren Lösungen kommen ein wenig auf den Punkt, aber sie kopieren einfach nicht alles über. Ich habe eine PHP-Funktion erstellt (wenn auch etwas langwierig), die alles kopiert, einschließlich Tabellen, Fremdschlüssel, Daten, Ansichten, Prozeduren, Funktionen, Trigger und Ereignisse. Hier ist der Code:

/* This function takes the database connection, an existing database, and the new database and duplicates everything in the new database. */
function copyDatabase($c, $oldDB, $newDB) {

    // creates the schema if it does not exist
    $schema = "CREATE SCHEMA IF NOT EXISTS {$newDB};";
    mysqli_query($c, $schema);

    // selects the new schema
    mysqli_select_db($c, $newDB);

    // gets all tables in the old schema
    $tables = "SELECT table_name
               FROM information_schema.tables
               WHERE table_schema = '{$oldDB}'
               AND table_type = 'BASE TABLE'";
    $results = mysqli_query($c, $tables);

    // checks if any tables were returned and recreates them in the new schema, adds the foreign keys, and inserts the associated data
    if (mysqli_num_rows($results) > 0) {

        // recreates all tables first
        while ($row = mysqli_fetch_array($results)) {
            $table = "CREATE TABLE {$newDB}.{$row[0]} LIKE {$oldDB}.{$row[0]}";
            mysqli_query($c, $table);
        }

        // resets the results to loop through again
        mysqli_data_seek($results, 0);

        // loops through each table to add foreign key and insert data
        while ($row = mysqli_fetch_array($results)) {

            // inserts the data into each table
            $data = "INSERT IGNORE INTO {$newDB}.{$row[0]} SELECT * FROM {$oldDB}.{$row[0]}";
            mysqli_query($c, $data);

            // gets all foreign keys for a particular table in the old schema
            $fks = "SELECT constraint_name, column_name, table_name, referenced_table_name, referenced_column_name
                    FROM information_schema.key_column_usage
                    WHERE referenced_table_name IS NOT NULL
                    AND table_schema = '{$oldDB}'
                    AND table_name = '{$row[0]}'";
            $fkResults = mysqli_query($c, $fks);

            // checks if any foreign keys were returned and recreates them in the new schema
            // Note: ON UPDATE and ON DELETE are not pulled from the original so you would have to change this to your liking
            if (mysqli_num_rows($fkResults) > 0) {
                while ($fkRow = mysqli_fetch_array($fkResults)) {
                    $fkQuery = "ALTER TABLE {$newDB}.{$row[0]}                              
                                ADD CONSTRAINT {$fkRow[0]}
                                FOREIGN KEY ({$fkRow[1]}) REFERENCES {$newDB}.{$fkRow[3]}({$fkRow[1]})
                                ON UPDATE CASCADE
                                ON DELETE CASCADE;";
                    mysqli_query($c, $fkQuery);
                }
            }
        }   
    }

    // gets all views in the old schema
    $views = "SHOW FULL TABLES IN {$oldDB} WHERE table_type LIKE 'VIEW'";                
    $results = mysqli_query($c, $views);

    // checks if any views were returned and recreates them in the new schema
    if (mysqli_num_rows($results) > 0) {
        while ($row = mysqli_fetch_array($results)) {
            $view = "SHOW CREATE VIEW {$oldDB}.{$row[0]}";
            $viewResults = mysqli_query($c, $view);
            $viewRow = mysqli_fetch_array($viewResults);
            mysqli_query($c, preg_replace("/CREATE(.*?)VIEW/", "CREATE VIEW", str_replace($oldDB, $newDB, $viewRow[1])));
        }
    }

    // gets all triggers in the old schema
    $triggers = "SELECT trigger_name, action_timing, event_manipulation, event_object_table, created
                 FROM information_schema.triggers
                 WHERE trigger_schema = '{$oldDB}'";                 
    $results = mysqli_query($c, $triggers);

    // checks if any triggers were returned and recreates them in the new schema
    if (mysqli_num_rows($results) > 0) {
        while ($row = mysqli_fetch_array($results)) {
            $trigger = "SHOW CREATE TRIGGER {$oldDB}.{$row[0]}";
            $triggerResults = mysqli_query($c, $trigger);
            $triggerRow = mysqli_fetch_array($triggerResults);
            mysqli_query($c, str_replace($oldDB, $newDB, $triggerRow[2]));
        }
    }

    // gets all procedures in the old schema
    $procedures = "SHOW PROCEDURE STATUS WHERE db = '{$oldDB}'";
    $results = mysqli_query($c, $procedures);

    // checks if any procedures were returned and recreates them in the new schema
    if (mysqli_num_rows($results) > 0) {
        while ($row = mysqli_fetch_array($results)) {
            $procedure = "SHOW CREATE PROCEDURE {$oldDB}.{$row[1]}";
            $procedureResults = mysqli_query($c, $procedure);
            $procedureRow = mysqli_fetch_array($procedureResults);
            mysqli_query($c, str_replace($oldDB, $newDB, $procedureRow[2]));
        }
    }

    // gets all functions in the old schema
    $functions = "SHOW FUNCTION STATUS WHERE db = '{$oldDB}'";
    $results = mysqli_query($c, $functions);

    // checks if any functions were returned and recreates them in the new schema
    if (mysqli_num_rows($results) > 0) {
        while ($row = mysqli_fetch_array($results)) {
            $function = "SHOW CREATE FUNCTION {$oldDB}.{$row[1]}";
            $functionResults = mysqli_query($c, $function);
            $functionRow = mysqli_fetch_array($functionResults);
            mysqli_query($c, str_replace($oldDB, $newDB, $functionRow[2]));
        }
    }

    // selects the old schema (a must for copying events)
    mysqli_select_db($c, $oldDB);

    // gets all events in the old schema
    $query = "SHOW EVENTS
              WHERE db = '{$oldDB}';";
    $results = mysqli_query($c, $query);

    // selects the new schema again
    mysqli_select_db($c, $newDB);

    // checks if any events were returned and recreates them in the new schema
    if (mysqli_num_rows($results) > 0) {
        while ($row = mysqli_fetch_array($results)) {
            $event = "SHOW CREATE EVENT {$oldDB}.{$row[1]}";
            $eventResults = mysqli_query($c, $event);
            $eventRow = mysqli_fetch_array($eventResults);
            mysqli_query($c, str_replace($oldDB, $newDB, $eventRow[3]));
        }
    }
}

Eigentlich wollte ich genau das in PHP erreichen, aber keine der Antworten hier war sehr hilfreich. Hier ist meine - ziemlich einfache - Lösung mit MySQLi:

// Database variables

$DB_HOST = 'localhost';
$DB_USER = 'root';
$DB_PASS = '1234';

$DB_SRC = 'existing_db';
$DB_DST = 'newly_created_db';



// MYSQL Connect

$mysqli = new mysqli( $DB_HOST, $DB_USER, $DB_PASS ) or die( $mysqli->error );



// Create destination database

$mysqli->query( "CREATE DATABASE $DB_DST" ) or die( $mysqli->error );



// Iterate through tables of source database

$tables = $mysqli->query( "SHOW TABLES FROM $DB_SRC" ) or die( $mysqli->error );

while( $table = $tables->fetch_array() ): $TABLE = $table[0];


    // Copy table and contents in destination database

    $mysqli->query( "CREATE TABLE $DB_DST.$TABLE LIKE $DB_SRC.$TABLE" ) or die( $mysqli->error );
    $mysqli->query( "INSERT INTO $DB_DST.$TABLE SELECT * FROM $DB_SRC.$TABLE" ) or die( $mysqli->error );


endwhile;

Der beste Weg, um Datenbanktabellen ohne mysqldump zu klonen:

1. Erstellen Sie eine neue Datenbank.

2. Erstellen Sie Klonabfragen mit Abfrage:

   SET @NewSchema = 'your_new_db';
   SET @OldSchema = 'your_exists_db';
   SELECT CONCAT('CREATE TABLE ',@NewSchema,'.',table_name, ' LIKE ', TABLE_SCHEMA ,'.',table_name,';INSERT INTO ',@NewSchema,'.',table_name,' SELECT * FROM ', TABLE_SCHEMA ,'.',table_name,';') 
   FROM information_schema.TABLES where TABLE_SCHEMA = @OldSchema AND TABLE_TYPE != 'VIEW';

3. Führen Sie diese Ausgabe aus!

Beachten Sie jedoch, dass das Skript oben nur schnelle Klontabellen enthält - keine Ansichten, Trigger und Benutzerfunktionen: Sie können schnell Strukturen abrufen mysqldump --no-data --triggers -uroot -ppasswordund dann nur Insert-Anweisungen klonen.

Warum ist es eigentlich eine Frage? Weil das Hochladen von mysqldumps hässlich langsam ist, wenn DB über 2 GB ist. Und Sie können InnoDB-Tabellen nicht einfach durch Kopieren von DB-Dateien (wie Snapshot-Backup) klonen.

Ein SQL, das SQL-Befehle anzeigt, muss ausgeführt werden, um eine Datenbank von einer Datenbank in eine andere zu duplizieren. Für jede Tabelle gibt es eine Tabellenanweisung und eine Einfügeanweisung. Es wird davon ausgegangen, dass sich beide Datenbanken auf demselben Server befinden:

select @fromdb:="crm";
select @todb:="crmen";

SET group_concat_max_len=100000000;


SELECT  GROUP_CONCAT( concat("CREATE TABLE `",@todb,"`.`",table_name,"` LIKE `",@fromdb,"`.`",table_name,"`;\n",
"INSERT INTO `",@todb,"`.`",table_name,"` SELECT * FROM `",@fromdb,"`.`",table_name,"`;") 

SEPARATOR '\n\n')

as sqlstatement
 FROM information_schema.tables where table_schema=@fromdb and TABLE_TYPE='BASE TABLE';

Mysqldump ist keine schlechte Lösung. Einfachste Möglichkeit, eine Datenbank zu duplizieren:

mysqldump -uusername -ppass dbname1 | mysql -uusername -ppass dbname2

Sie können die Speicher-Engine auch folgendermaßen ändern:

mysqldump -uusername -ppass dbname1 | sed 's/InnoDB/RocksDB/' | mysql -uusername -ppass dbname2