Hoe kopieer, kloon of dupliceer ik de gegevens, structuur,
en indexen van een MySQL-tabel naar een nieuwe?
Dit is wat ik tot nu toe heb gevonden.
Hiermee worden de gegevens en de structuur gekopieerd,
maar niet de indices:
create table {new_table} select * from {old_table};
Hiermee worden de structuur en indices gekopieerd,
maar niet de gegevens:
create table {new_table} like {old_table};
Antwoord 1, autoriteit 100%
Als u wilt kopiëren met indexen en triggers, voert u deze 2 zoekopdrachten uit:
CREATE TABLE newtable LIKE oldtable;
INSERT INTO newtable SELECT * FROM oldtable;
Gebruik deze om alleen structuur en gegevens te kopiëren:
CREATE TABLE tbl_new AS SELECT * FROM tbl_old;
Ik heb dit eerder gevraagd:
Kopieer een MySQL-tabel inclusief indexen
Antwoord 2, autoriteit 2%
Afgezien van de bovenstaande oplossing, kun je ASgebruiken om het in één regel te maken.
CREATE TABLE tbl_new AS SELECT * FROM tbl_old;
Antwoord 3, autoriteit 2%
MySQL-manier:
CREATE TABLE recipes_new LIKE production.recipes;
INSERT recipes_new SELECT * FROM production.recipes;
4
Ik vond dezelfde situatie en de benadering die ik nam was als volgt:
- Volg
SHOW CREATE TABLE <table name to clone>: Dit geeft u deCreate TableSyntaxis voor de tabel die u wilt klonen - Voer de
Create Tablemaken door de naam van de tabel te wijzigen om de tabel te klonen.
Hiermee maakt u exacte replica van de tabel die u samen met indexen wilt klonen. Het enige dat u nodig heeft, is om de indexen (indien nodig) te hernoemen.
5
De betere manier om een tabel te dupliceren, gebruikt alleen DDLVerklaring. Op deze manier, onafhankelijk van het aantal records in de tabel, kunt u de duplicatie onmiddellijk uitvoeren.
Mijn doel is:
DROP TABLE IF EXISTS table_name_OLD;
CREATE TABLE table_name_NEW LIKE table_name;
RENAME TABLE table_name TO table_name_OLD;
RENAME TABLE table_name _NEW TO table_name;
Dit vermijdt de INSERT AS SELECTverklaring dat, in geval van een tabel met veel records kan duren om te worden uitgevoerd.
Ik stel voor om ook een PLSQL-procedure te maken als het volgende voorbeeld:
DELIMITER //
CREATE PROCEDURE backup_table(tbl_name varchar(255))
BEGIN
-- DROP TABLE IF EXISTS GLS_DEVICES_OLD;
SET @query = concat('DROP TABLE IF EXISTS ',tbl_name,'_OLD');
PREPARE stmt FROM @query;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
-- CREATE TABLE GLS_DEVICES_NEW LIKE GLS_DEVICES;
SET @query = concat('CREATE TABLE ',tbl_name,'_NEW LIKE ',tbl_name);
PREPARE stmt FROM @query;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
-- RENAME TABLE GLS_DEVICES TO GLS_DEVICES_OLD;
SET @query = concat('RENAME TABLE ',tbl_name,' TO ',tbl_name,'_OLD');
PREPARE stmt FROM @query;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
-- RENAME TABLE GLS_DEVICES_NEW TO GLS_DEVICES;
SET @query = concat('RENAME TABLE ',tbl_name,'_NEW TO ',tbl_name);
PREPARE stmt FROM @query;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
END//
DELIMITER ;
Fijne dag!
Alex
Antwoord 6
Gebruik dit om een tabel en zijn structuur te dupliceren zonder gegevens uit een andere database. Op de nieuwe database sql type
CREATE TABLE currentdatabase.tablename LIKE olddatabase.tablename
Antwoord 7
Uitbreiden op dit antwoordzou een opgeslagen procedure kunnen gebruiken:
CALL duplicate_table('tableName');
Wat resulteert in een dubbele tabel met de naam tableName_20181022235959Indien aangeroepen wanneer
SELECT NOW();
resultaten:
2018-10-22 23:59:59
Implementatie
DELIMITER $$
CREATE PROCEDURE duplicate_table(IN tableName VARCHAR(255))
BEGIN
DECLARE schemaName VARCHAR(255) DEFAULT SCHEMA();
DECLARE today VARCHAR(14) DEFAULT REPLACE(REPLACE(REPLACE(NOW(), '-', ''), ' ', ''), ':', ''); -- update @ year 10000
DECLARE backupTableName VARCHAR(255) DEFAULT CONCAT(tableName, '_', today);
IF fn_table_exists(schemaName, tableName)
THEN
CALL statement(CONCAT('CREATE TABLE IF NOT EXISTS ', backupTableName,' LIKE ', tableName));
CALL statement(CONCAT('INSERT INTO ', backupTableName,' SELECT * FROM ', tableName));
CALL statement(CONCAT('CHECKSUM TABLE ', backupTableName,', ', tableName));
ELSE
SELECT CONCAT('ERROR: Table "', tableName, '" does not exist in the schema "', schemaName, '".') AS ErrorMessage;
END IF;
END $$
DELIMITER ;
DELIMITER $$
CREATE FUNCTION fn_table_exists(schemaName VARCHAR(255), tableName VARCHAR(255))
RETURNS TINYINT(1)
BEGIN
DECLARE totalTablesCount INT DEFAULT (
SELECT COUNT(*)
FROM information_schema.TABLES
WHERE (TABLE_SCHEMA COLLATE utf8_general_ci = schemaName COLLATE utf8_general_ci)
AND (TABLE_NAME COLLATE utf8_general_ci = tableName COLLATE utf8_general_ci)
);
RETURN IF(
totalTablesCount > 0,
TRUE,
FALSE
);
END $$
DELIMITER ;
DELIMITER $$
CREATE PROCEDURE statement(IN dynamic_statement TEXT)
BEGIN
SET @dynamic_statement := dynamic_statement;
PREPARE prepared_statement FROM @dynamic_statement;
EXECUTE prepared_statement;
DEALLOCATE PREPARE prepared_statement;
END $$
DELIMITER ;
Antwoord 8
Nadat ik de bovenstaande oplossing heb geprobeerd, heb ik mijn eigen manier bedacht.
Mijn oplossing is een kleine handleiding en heeft DBMS nodig.
Exporteer eerst de gegevens.
Ten tweede, open de exportgegevens.
Ten derde, vervang de oude tafelnaam door de nieuwe tafelnaam.
Ten vierde, verander alle triggernaam in de gegevens (ik gebruik MySQL en er wordt een fout weergegeven als ik de triggernaam niet verander).
Ten vijfde: importeer uw bewerkte SQL-gegevens in de database.
Antwoord 9
Gebruik alleen deze onderstaande code om een tabelstructuur te maken:
CREATE TABLE new_table LIKE current_table;
Gebruik deze onderstaande code om gegevens van een tabel naar een andere te kopiëren:
INSERT INTO new_table SELECT * FROM current_table;
Antwoord 10
Het is de moeite waard om te vermelden hoe belangrijk het is om te controleren of de tabel al eerder bestaat
proberen te dupliceren:
CREATE TABLE IF NOT EXISTS new_table LIKE old_table;
INSERT new_table
SELECT * FROM old_table;
Zoals in de vorige antwoorden werd gezegd, kopieert dit de structuur, gegevensen
alle afhankelijke objectenvan de tabel.
Zie MySql-zelfstudie:
Antwoord 11
Probeer dit:
`CREATE TABLE new-table (id INT(11) auto_increment primary key) SELECT old-table.name, old-table.group, old-table.floor, old-table.age from old-table;`
Ik heb 4 kolommen uit de oude tabel geselecteerd en een nieuwe tabel gemaakt.
Antwoord 12
Eenvoudig klonen:
het maakt een tabel van een andere tabel zonder rekening te houden met kolomattributen en indexen.
CREATE TABLE new_table SELECT * FROM original_table;
Ondiep klonen:
Dit maakt alleen een lege tafelbasis op de structuur van de originele tafel
CREATE TABLE new_table LIKE original_table;
Het volgende commando zou een lege tafelbasis maken op de originele tafel.
CREATE TABLE adminUsers LIKE users;
Diep klonen:
Dit betekent dat de nieuwe tabel alle attributen van elke kolom en indexen van de bestaande tabel krijgt. Dit is erg handig als u de indexen en attributen van de bestaande tabel wilt behouden.
CREATE TABLE new_table LIKE original_table;
INSERT INTO new_table SELECT * FROM original_table;
https://towardsdatascience.com/how-to-clone -tables-in-sql-dd29586ec89c
Antwoord 13
VOOR MySQL
CREATE TABLE newtable LIKE oldtable ;
INSERT newtable SELECT * FROM oldtable ;
VOOR MSSQL
Gebruik MyDatabase:
Select * into newCustomersTable from oldCustomersTable;
Deze SQL wordt gebruikt voor het kopiëren van tabellen, hier wordt de inhoud van oldCustomersTable gekopieerd naar newCustomersTable.
Zorg ervoor dat de newCustomersTablenietbestaat in de database.