In MySQL, posso copiare una riga per inserirla nella stessa tabella?

insert into table select * from table where primarykey=1

Voglio solo copiare una riga da inserire nella stessa tabella (ad esempio, voglio duplicare una riga esistente nella tabella), ma voglio farlo senza dover elencare tutte le colonne dopo la "selezione", perché questa tabella ha troppe colonne.

Ma quando lo faccio, ricevo l'errore:

Voce duplicata "xxx" per la chiave 1

Posso gestirlo creando un'altra tabella con le stesse colonne di un contenitore temporaneo per il record che voglio copiare:

create table oldtable_temp like oldtable;
insert into oldtable_temp select * from oldtable where key=1;
update oldtable_tem set key=2;
insert into oldtable select * from oldtable where key=2;

C'è un modo più semplice per risolvere questo?

Ho usato la tecnica di Leonard Challis con alcune modifiche:

CREATE TEMPORARY TABLE tmptable_1 SELECT * FROM table WHERE primarykey = 1;
UPDATE tmptable_1 SET primarykey = NULL;
INSERT INTO table SELECT * FROM tmptable_1;
DROP TEMPORARY TABLE IF EXISTS tmptable_1;

Come tabella temporanea, non dovrebbe mai esserci più di un record, quindi non devi preoccuparti della chiave primaria. Impostandolo su null, MySQL può scegliere il valore stesso, quindi non c'è rischio di creare un duplicato.

Se vuoi essere sicuro che stai solo inserendo una riga, puoi aggiungere LIMIT 1 alla fine della riga INSERT INTO.

Nota che ho anche aggiunto il valore della chiave primaria (1 in questo caso) al nome della mia tabella temporanea.

Aggiornamento 07/07/2014 - La risposta basata sulla mia risposta, di Grim ... , è una soluzione migliore in quanto migliora la mia soluzione di seguito, quindi suggerirei di usarla.

Puoi farlo senza elencare tutte le colonne con la seguente sintassi:

CREATE TEMPORARY TABLE tmptable SELECT * FROM table WHERE primarykey = 1;
UPDATE tmptable SET primarykey = 2 WHERE primarykey = 1;
INSERT INTO table SELECT * FROM tmptable WHERE primarykey = 2;

Puoi decidere di cambiare la chiave primaria in un altro modo.

Suppongo che desideri che il nuovo disco ne abbia uno nuovo primarykey? Se primarykeyè AUTO_INCREMENTallora basta fare questo:

INSERT INTO table (col1, col2, col3, ...)
SELECT col1, col2, col3, ... FROM table
  WHERE primarykey = 1

... dove col1, col2, col3, ...sono tutte le colonne nella tabella tranne primarykey .

Se non è una AUTO_INCREMENTcolonna e vuoi essere in grado di scegliere il nuovo valore per primarykeyè simile:

INSERT INTO table (primarykey, col2, col3, ...)
SELECT 567, col2, col3, ... FROM table
  WHERE primarykey = 1

... dov'è 567il nuovo valore per primarykey.

L'hai quasi avuto con la tua prima query, devi solo specificare le colonne, in questo modo puoi escludere la chiave primaria nell'inserto che attiverà l'incremento automatico che probabilmente hai sulla tabella per creare automaticamente una nuova chiave primaria per il iscrizione.

Ad esempio, cambia questo:

insert into table select * from table where primarykey=1

A questa:

INSERT INTO table (col1, col2, col3) 
SELECT col1, col2, col3 
FROM table 
WHERE primarykey = 1

Basta non includere la colonna chiave primaria nell'elenco delle colonne per INSERT o per le parti SELECT della query.

Puoi anche provare a scaricare la tabella, trovando il comando insert e modificandolo:

mysqldump -umyuser -p mydatabase --skip-extended-insert mytable > outfile.sql

L' --skip-extended-insertti dà un comando di inserimento per riga. È quindi possibile trovare la riga nel proprio editor di testo preferito, estrarre il comando e modificare la chiave primaria su "predefinita".

Questa procedura presuppone che:

• non hai _duplicate_temp_table
• la tua chiave primaria è int
• hai accesso per creare una tabella

Naturalmente questo non è perfetto, ma in alcuni casi (probabilmente la maggior parte) funzionerà.

DELIMITER $$
CREATE PROCEDURE DUPLICATE_ROW(copytable VARCHAR(255), primarykey VARCHAR(255), copyid INT, out newid INT)
BEGIN
        DECLARE EXIT HANDLER FOR SQLEXCEPTION SET @error=1;
        SET @temptable = '_duplicate_temp_table';
        SET @sql_text = CONCAT('CREATE TABLE ', @temptable, ' LIKE ', copytable);
        PREPARE stmt FROM @sql_text;
        EXECUTE stmt;
        DEALLOCATE PREPARE stmt;
        SET @sql_text = CONCAT('INSERT INTO ', @temptable, ' SELECT * FROM ', copytable, ' where ', primarykey,'=', copyid);
        PREPARE stmt FROM @sql_text;
        EXECUTE stmt;
        DEALLOCATE PREPARE stmt;
        SET @sql_text = CONCAT('SELECT max(', primarykey, ')+1 FROM ', copytable, ' INTO @newid');
        PREPARE stmt FROM @sql_text;
        EXECUTE stmt;
        DEALLOCATE PREPARE stmt;
        SET @sql_text = CONCAT('UPDATE ', @temptable, ' SET ', primarykey, '=@newid');
        PREPARE stmt FROM @sql_text;
        EXECUTE stmt;
        DEALLOCATE PREPARE stmt;
        SET @sql_text = CONCAT('INSERT INTO ', copytable, ' SELECT * FROM ', @temptable, '');
        PREPARE stmt FROM @sql_text;
        EXECUTE stmt;
        DEALLOCATE PREPARE stmt;
        SET @sql_text = CONCAT('DROP TABLE ', @temptable);
        PREPARE stmt FROM @sql_text;
        EXECUTE stmt;
        DEALLOCATE PREPARE stmt;
        SELECT @newid INTO newid;
END $$
DELIMITER ;

CALL DUPLICATE_ROW('table', 'primarykey', 1, @duplicate_id);
SELECT @duplicate_id;

Questo può essere ottenuto con un po 'di creatività:

SET @sql = CONCAT('INSERT INTO <table> SELECT null, 
    ', (SELECT GROUP_CONCAT(COLUMN_NAME) 
    FROM information_schema.columns 
    WHERE table_schema = '<database>' 
    AND table_name = '<table>' 
    AND column_name NOT IN ('id')), ' 
from <table> WHERE id = <id>');  

PREPARE stmt1 FROM @sql;
EXECUTE stmt1;

Ciò comporterà che la nuova riga ottenga un ID incrementato automaticamente anziché l'id dalla riga selezionata.

Se il campo chiave primaria della tabella è un campo di incremento automatico, è possibile utilizzare la query con colonne. Ad esempio, la tabella denominata test_tblha 3 campi come id, name, age. idè un campo chiave primaria e incremento automatico, quindi è possibile utilizzare la seguente query per duplicare la riga:

INSERT INTO `test_tbl` (`name`,`age`) SELECT `name`,`age` FROM `test_tbl`;

Questa query comporta la duplicazione di ogni riga.

Se il campo chiave primaria della tabella non è un campo di incremento automatico, è possibile utilizzare il seguente metodo:

INSERT INTO `test_tbl` (`id`,`name`,`age`)
  SELECT 20,`name`,`age` FROM `test_tbl` WHERE id = 19;

Il risultato di questa query è una riga duplicata di id=19come inserita id=20.

clona riga con campi di aggiornamento e valore di incremento automatico

CREATE TEMPORARY TABLE `temp` SELECT * FROM `testing` WHERE id = 14;

UPDATE `temp` SET id = (SELECT id FROM testing ORDER by id DESC LIMIT 1
 )+1, user_id = 252 ,policy_no = "mysdddd12" where id = 14;

INSERT INTO `testing` SELECT * FROM `temp`;

DROP TEMPORARY TABLE IF EXISTS `temp`;

Alcune delle seguenti informazioni sono state rimosse da questo sito. Questo è quello che ho fatto per duplicare un record in una tabella con un numero qualsiasi di campi:

Ciò presuppone anche che tu abbia un campo AI all'inizio della tabella

function duplicateRow( $id = 1 ){
dbLink();//my db connection
$qColumnNames = mysql_query("SHOW COLUMNS FROM table") or die("mysql error");
$numColumns = mysql_num_rows($qColumnNames);

for ($x = 0;$x < $numColumns;$x++){
$colname[] = mysql_fetch_row($qColumnNames);
}

$sql = "SELECT * FROM table WHERE tableId = '$id'";
$row = mysql_fetch_row(mysql_query($sql));
$sql = "INSERT INTO table SET ";
for($i=1;$i<count($colname)-4;$i++){//i set to 1 to preclude the id field
//we set count($colname)-4 to avoid the last 4 fields (good for our implementation)
$sql .= "`".$colname[$i][0]."`  =  '".$row[$i]. "', ";
}
$sql .= " CreateTime = NOW()";// we need the new record to have a new timestamp
mysql_query($sql);
$sql = "SELECT MAX(tableId) FROM table";
$res = mysql_query($sql);
$row = mysql_fetch_row($res);
return $row[0];//gives the new ID from auto incrementing
}

Ho usato la tecnica di Grim con un piccolo cambiamento: se qualcuno che cerca questa query è perché non può fare una query semplice a causa di un problema chiave principale:

INSERT INTO table SELECT * FROM table WHERE primakey=1;

Con la mia installazione MySql 5.6.26, la chiave non è nulla e produce un errore:

#1048 - Column 'primakey' cannot be null 

Quindi, dopo aver creato una tabella temporanea, cambio la chiave primaria in nulla.

CREATE TEMPORARY TABLE tmptable_1 SELECT * FROM table WHERE primarykey = 1;
ALTER TABLE tmptable_1 MODIFY primarykey int(12) null;
UPDATE tmptable_1 SET primarykey = NULL;
INSERT INTO table SELECT * FROM tmptable_1;
DROP TEMPORARY TABLE IF EXISTS tmptable_1;

Potrei arrivare tardi, ma ho una soluzione simile che ha funzionato per me.

 INSERT INTO `orders` SELECT MAX(`order_id`)+1,`container_id`, `order_date`, `receive_date`, `timestamp` FROM `orders` WHERE `order_id` = 1

In questo modo non ho bisogno di creare una tabella temporanea e così via. Poiché la riga viene copiata nella stessa tabella, la Max(PK)+1funzione può essere utilizzata facilmente.

Sono venuto alla ricerca della soluzione di questa domanda (avevo dimenticato la sintassi) e ho finito per fare la mia query. Divertente come vanno le cose a volte.

Saluti

Se la chiave primaria è l'incremento automatico, basta specificare ciascun campo tranne la chiave primaria.

INSERT INTO table(field1,field2,field3) SELECT (field1,field2,field3) FROM table WHERE primarykey=1

Ho aggiornato la soluzione di @ LeonardChallis in quanto non ha funzionato per me come nessuno degli altri. Ho rimosso le WHEREclausole e SET primaryKey = 0nella tabella temporanea in modo che MySQL si auto-incrementa da solo chiave primaria

CREATE TEMPORARY TABLE tmptable SELECT * FROM myTable;
UPDATE tmptable SET primaryKey = 0;
INSERT INTO myTable SELECT * FROM tmptable;

Questo ovviamente serve a duplicare tutte le righe nella tabella.

Vorrei usare di seguito,

insert into ORDER_ITEM select * from ORDER_ITEM where ITEM_NUMBER =123;

Ho usato nel mio database Koha per inserire elementi duplicati con il prefisso 'C' nella colonna del codice a barre :

INSERT INTO items (`biblionumber`, `biblioitemnumber`, `barcode`, `dateaccessioned` ) SELECT `biblionumber`, `biblioitemnumber`,  CONCAT('C',`barcode`), `dateaccessioned` FROM `items` WHERE barcode='14832';

Dovevo solo fare questo e questa era la mia soluzione manuale:

1. In phpmyadmin , seleziona la riga che desideri copiare
2. Nella parte inferiore delle operazioni sui risultati della query, fai clic su "Esporta"
3. Nella pagina successiva selezionare 'Salva come file' quindi fare clic su 'Vai'
4. Apri il file esportato con un editor di testo, trova il valore del campo primario e modificalo in qualcosa di unico.
5. Di nuovo in phpmyadmin, fai clic sulla scheda "Importa" , individua il file da importare in file .sql in Sfoglia , fai clic su "Vai" e la riga duplicata deve essere inserita.

Se non sai qual è il campo PRIMARY , guarda indietro alla tua pagina phpmyadmin , fai clic sulla scheda 'Struttura' e nella parte inferiore della pagina sotto 'Indici' ti mostrerà quale 'Campo' ha un 'Nome chiave' valore "PRIMARY" .

Un po 'lontano, ma se non vuoi occuparti del markup e devi solo duplicare una singola riga lì.

Questa soluzione mostrata sopra funziona perfettamente anche per le righe selezionate. Ad esempio, sto creando righe dimostrative per il mio progetto nice2work e questo funziona perfettamente.

CREATE TEMPORARY TABLE tmptable SELECT * FROM myTable WHERE id=500;
UPDATE tmptable SET id = 0;
UPDATE some fields I need to change
INSERT INTO myTable SELECT * FROM tmptable;
DROP TABLE tmptable;

//  You can use this same also directly into your code like (PHP Style)
$sql = "CREATE TEMPORARY TABLE tmptable SELECT * FROM myTable WHERE id=500;
UPDATE tmptable SET id = 0;
UPDATE some fields I need to change
INSERT INTO myTable SELECT * FROM tmptable;DROP TABLE tmptable;";

Ci scusiamo per il necropost ma questo è quello che ho scoperto con Google e da quando l'ho trovato utile ma problematico, volevo contribuire con una modifica importante per chiunque lo scovasse.

Prima di tutto, sto usando SQL Server, non MySQL, ma penso che dovrebbe funzionare in modo simile. Ho usato la soluzione di Leonard Challis perché è stata la più semplice e ha soddisfatto la necessità, tuttavia c'è un problema con questo: se prendi semplicemente il PK e lo incrementi di 1, cosa succede se hai aggiunto altri record da quando è stata aggiunta la riga in questione . Ho deciso che era meglio lasciare che il sistema gestisse l'autoincremento del PK, quindi ho fatto quanto segue:

SELECT * INTO #tmpTable FROM Table WHERE primarykey = 1
--Optionally you can modify one or more fields here like this: 
--UPDATE #tmpTable SET somefield = newData
ALTER TABLE #tmpTable DROP COLUMN TicketUpdateID
INSERT INTO Tickets SELECT * FROM #tmpTable
DROP TABLE #tmpTable

Credo che funzionerebbe in modo simile in MySQL, ma non posso provarlo, mi dispiace

So che è una vecchia domanda, ma ecco un'altra soluzione:

Ciò duplica una riga nella tabella principale, presupponendo che la chiave primaria sia l'auto-incremento e crea copie dei dati delle tabelle collegate con il nuovo ID tabella principale.

Altre opzioni per ottenere i nomi di colonna:
-MOSTRA COLONNE DA tablename; (Nome colonna: Field)
-DESCRIBE tablename (Nome colonna: Field)
-SELECT nome_colonna DA information_schema.columns DOVE table_name = 'tablename' (Nome colonna: nome_colonna)

//First, copy main_table row
$ColumnHdr='';
$Query="SHOW COLUMNS FROM `main_table`;";
$Result=Wrappedmysql_query($Query,$link,__FILE__,__LINE__);
while($Row=mysql_fetch_array($Result))
{
    if($Row['Field']=='MainTableID')     //skip main table id in column list
        continue;
    $ColumnHdr.=",`" . $Row['Field'] . "`";
}
$Query="INSERT INTO `main_table` (" . substr($ColumnHdr,1) . ")
        (SELECT " . substr($ColumnHdr,1) . " FROM `main_table`
            WHERE `MainTableID`=" . $OldMainTableID . ");";
$Result=Wrappedmysql_query($Query,$link,__FILE__,__LINE__);
$NewMainTableID=mysql_insert_id($link);

//Change the name (assumes a 30 char field)
$Query="UPDATE `main_table` SET `Title`=CONCAT(SUBSTRING(`Title`,1,25),' Copy') WHERE `MainTableID`=" . $NewMainTableID . ";";
$Result=Wrappedmysql_query($Query,$link,__FILE__,__LINE__);

//now copy in the linked tables
$TableArr=array("main_table_link1","main_table_link2","main_table_link3");
foreach($TableArr as $TableArrK=>$TableArrV)
{
    $ColumnHdr='';
    $Query="SHOW COLUMNS FROM `" . $TableArrV . "`;";
    $Result=Wrappedmysql_query($Query,$link,__FILE__,__LINE__);
    while($Row=mysql_fetch_array($Result))
    {
        if($Row['Field']=='MainTableID')     //skip main table id in column list, re-added in query
            continue;
        if($Row['Field']=='dbID')    //skip auto-increment,primary key in linked table
            continue;
        $ColumnHdr.=",`" . $Row['Field'] . "`";
    }

    $Query="INSERT INTO `" . $TableArrV . "` (`MainTableID`," . substr($ColumnHdr,1) . ")
            (SELECT " . $NewMainTableID . "," . substr($ColumnHdr,1) . " FROM `" . $TableArrV . "`
             WHERE `MainTableID`=" . $OldMainTableID . ");";
    $Result=Wrappedmysql_query($Query,$link,__FILE__,__LINE__);
}

max233 era certamente sulla strada giusta, almeno per il caso di incremento automatico. Tuttavia, non eseguire ALTER TABLE. Basta impostare il campo di incremento automatico nella tabella temporanea su NULL. Ciò presenterà un errore, ma si verificherà il seguente INSERTO di tutti i campi nella tabella temporanea e il campo automatico NULL otterrà un valore univoco.

Crea una tabella

    CREATE TABLE `sample_table` (
       `sample_id` INT(10) unsigned NOT NULL AUTO_INCREMENT,
       `sample_name` VARCHAR(255) NOT NULL,
       `sample_col_1` TINYINT(1) NOT NULL,
       `sample_col_2` TINYINT(2) NOT NULL,

      PRIMARY KEY (`sample_id`),
      UNIQUE KEY `sample_id` (`sample_id`)

    ) ENGINE='InnoDB' DEFAULT CHARACTER SET 'utf8' COLLATE 'utf8_general_ci';

Inserisci una riga

INSERT INTO `sample_table`
   VALUES(NULL, 'sample name', 1, 2);

Clona l'inserzione di riga sopra

INSERT INTO `sample_table`
   SELECT 
    NULL AS `sample_id`, -- new AUTO_INCREMENT PRIMARY KEY from MySQL
    'new dummy entry' AS `sample_name`,  -- new UNIQUE KEY from you
    `sample_col_1`, -- col from old row
    `sample_col_2` -- col from old row
   FROM `sample_table`
   WHERE `sample_id` = 1;

Test

SELECT * FROM `sample_table`;

Ecco una risposta che ho trovato online in questo sito Descrive come fare quanto sopra 1 Puoi trovare la risposta in fondo alla pagina. Fondamentalmente, ciò che fai è copiare la riga da copiare in una tabella temporanea conservata in memoria. Quindi modificare il numero della chiave primaria mediante l'aggiornamento. Quindi reinserirlo nella tabella di destinazione. Quindi rilasciare il tavolo.

Questo è il codice per questo:

CREA rescueteamMOTORE TABELLA TEMPORANEA = SELEZIONE MEMORIA * DA fitnessreport4DOVE rID = 1; # 1 riga interessata. UPDATE rescueteamSET rID = Null DOVE rID = 1; # 1 riga interessata. INSERISCI IN fitnessreport4SELEZIONA * DA rescueteam; # 1 riga interessata. DROP TABLE rescueteam# MySQL ha restituito un set di risultati vuoto (ovvero zero
righe).

Ho creato il salvataggio temporaneo della tabella. Ho copiato la riga dal mio report fitness4 originale. Ho quindi impostato la chiave primaria per la riga nella tabella temporanea su null in modo da poterla copiare nella tabella originale senza ottenere un errore di chiave duplicata. Ho provato questo codice ieri sera e ha funzionato.

Questa è una soluzione aggiuntiva alla risposta di "Grim ..." Ci sono stati alcuni commenti che hanno una chiave primaria come null. Alcuni commenti non funzionano. E alcuni commenti sulle soluzioni. Nessuna delle soluzioni ha funzionato per noi. Abbiamo MariaDB con la tabella InnoDB.

Non è stato possibile impostare la chiave primaria per consentire null. L'uso di 0 anziché NULL ha portato a un errore di valore duplicato per la chiave primaria. SET SQL_SAFE_UPDATES = 0;Non ha funzionato neanche.

La soluzione di "Grim ..." ha funzionato SE abbiamo invece cambiato la nostra PRIMARY KEY in UNIQUE

Volevo solo pubblicare il mio pezzo di codice PHP, perché penso che il modo in cui raccolgo le colonne sia un po 'più pulito nel codice rispetto agli esempi precedenti. Anche questo mostra come è possibile modificare facilmente un campo, in questo caso aggiungendo una stringa. Ma potresti anche sostituire un campo chiave esterna con il record appena aggiunto, nel caso in cui desideri copiare anche alcuni record figlio.

  // Read columns, unset the PK (always the first field in my case)
  $stmt = $conn->prepare('SHOW COLUMNS FROM template');
  $stmt->execute();

  $columns = $stmt->fetchAll();
  $columns = array_map(function ($element) { return $element['Field']; }, $columns);

  unset($columns[0]);

  // Insert record in the database. Add string COPY to the name field.
  $sql = "INSERT INTO `template` (".implode(",", $columns).")";
  if ($key = array_search('name', $columns))
      $columns[$key] = "CONCAT(name, ' COPY')";
  $sql .= " SELECT ".implode(",", $columns)." FROM `template` WHERE `id` = ".$id;

  $stmt = $conn->prepare($sql);
  $stmt->execute();

Per una soluzione molto semplice, è possibile utilizzare PHPMyAdmin per esportare la riga come file CSV, quindi importare semplicemente il file CSV modificato. Modifica della colonna ID / chiave primaria per non mostrare alcun valore prima di importarlo.

SELECT * FROM table where primarykey=1

Quindi in fondo alla pagina:

Dove si dice "Esporta" è sufficiente esportare, quindi modificare il file CSV per rimuovere il valore della chiave primaria, quindi è vuoto e quindi importarlo nel database, una nuova chiave primaria verrà assegnata all'importazione.