¿Cómo copiar una fila e insertarla en la misma tabla con un campo de autoincremento en MySQL?

En MySQL estoy tratando de copiar una fila con un incremento automático column ID=1 e insertar los datos en la misma tabla con una nueva fila column ID=2.

¿Cómo puedo hacer esto en una sola consulta?

Uso INSERT ... SELECT:

insert into your_table (c1, c2, ...)
select c1, c2, ...
from your_table
where id = 1

donde c1, c2, ...están todas las columnas excepto id. Si desea insertar explícitamente con un id2, inclúyalo en su lista de columnas INSERT y su SELECT:

insert into your_table (id, c1, c2, ...)
select 2, c1, c2, ...
from your_table
where id = 1

Tendrás que ocuparte de un posible duplicado idde 2 en el segundo caso, por supuesto.

En mi opinión, lo mejor parece usar sentencias sql solo para copiar esa fila, mientras que al mismo tiempo solo hace referencia a las columnas que debe y desea cambiar.

CREATE TEMPORARY TABLE temp_table ENGINE=MEMORY

SELECT * FROM your_table WHERE id=1;
UPDATE temp_table SET id=NULL; /* Update other values at will. */

INSERT INTO your_table SELECT * FROM temp_table;
DROP TABLE temp_table;

Consulte también av8n.com - Cómo clonar un registro SQL

Beneficios:

• Las declaraciones SQL 2 mencionan solo los campos que deben cambiarse durante el proceso de clonación. No conocen ni se preocupan por otros campos. Los otros campos simplemente siguen el paseo, sin cambios. Esto hace que las instrucciones SQL sean más fáciles de escribir, más fáciles de leer, más fáciles de mantener y más extensibles.
• Solo se usan las declaraciones ordinarias de MySQL. No se requieren otras herramientas o lenguajes de programación.
• Se inserta un registro completamente correcto your_tableen una operación atómica.

Digamos que la mesa es user(id, user_name, user_email).

Puedes usar esta consulta:

INSERT INTO user (SELECT NULL,user_name, user_email FROM user WHERE id = 1)

Esto ayudó y admite columnas BLOB / TEXT.

CREATE TEMPORARY TABLE temp_table
AS
SELECT * FROM source_table WHERE id=2;
UPDATE temp_table SET id=NULL WHERE id=2;
INSERT INTO source_table SELECT * FROM temp_table;
DROP TEMPORARY TABLE temp_table;
USE source_table;

Para una solución rápida y limpia que no requiera que nombre columnas, puede usar una declaración preparada como se describe aquí: https://stackoverflow.com/a/23964285/292677

Si necesita una solución compleja para poder hacer esto con frecuencia, puede usar este procedimiento:

DELIMITER $$

CREATE PROCEDURE `duplicateRows`(_schemaName text, _tableName text, _whereClause text, _omitColumns text)
SQL SECURITY INVOKER
BEGIN
  SELECT IF(TRIM(_omitColumns) <> '', CONCAT('id', ',', TRIM(_omitColumns)), 'id') INTO @omitColumns;

  SELECT GROUP_CONCAT(COLUMN_NAME) FROM information_schema.columns 
  WHERE table_schema = _schemaName AND table_name = _tableName AND FIND_IN_SET(COLUMN_NAME,@omitColumns) = 0 ORDER BY ORDINAL_POSITION INTO @columns;

  SET @sql = CONCAT('INSERT INTO ', _tableName, '(', @columns, ')',
  'SELECT ', @columns, 
  ' FROM ', _schemaName, '.', _tableName, ' ',  _whereClause);

  PREPARE stmt1 FROM @sql;
  EXECUTE stmt1;
END

Puedes ejecutarlo con:

CALL duplicateRows('database', 'table', 'WHERE condition = optional', 'omit_columns_optional');

Ejemplos

duplicateRows('acl', 'users', 'WHERE id = 200'); -- will duplicate the row for the user with id 200
duplicateRows('acl', 'users', 'WHERE id = 200', 'created_ts'); -- same as above but will not copy the created_ts column value    
duplicateRows('acl', 'users', 'WHERE id = 200', 'created_ts,updated_ts'); -- same as above but also omits the updated_ts column
duplicateRows('acl', 'users'); -- will duplicate all records in the table

DESCARGO DE RESPONSABILIDAD: Esta solución es solo para alguien que repetidamente repetirá filas en muchas tablas, a menudo. Podría ser peligroso en manos de un usuario deshonesto.

También puede pasar '0' como valor para que la columna se incremente automáticamente, se usará el valor correcto cuando se cree el registro. Esto es mucho más fácil que las tablas temporales.

Fuente: Copiar filas en MySQL (ver el segundo comentario, por TRiG, ​​a la primera solución, por Lore)

Muchas respuestas geniales aquí. A continuación se muestra una muestra del procedimiento almacenado que escribí para realizar esta tarea para una aplicación web que estoy desarrollando:

-- SET NOCOUNT ON added to prevent extra result sets from
-- interfering with SELECT statements.
SET NOCOUNT ON

-- Create Temporary Table
SELECT * INTO #tempTable FROM <YourTable> WHERE Id = Id

--To trigger the auto increment
UPDATE #tempTable SET Id = NULL 

--Update new data row in #tempTable here!

--Insert duplicate row with modified data back into your table
INSERT INTO <YourTable> SELECT * FROM #tempTable

-- Drop Temporary Table
DROP TABLE #tempTable

insert into MyTable(field1, field2, id_backup)
    select field1, field2, uniqueId from MyTable where uniqueId = @Id;

Si puede usar MySQL Workbench, puede hacerlo haciendo clic con el botón derecho en la fila y seleccionando 'Copiar fila', y luego haciendo clic con el botón derecho en la fila vacía y seleccionando 'Pegar fila', y luego cambiando la ID, y luego haciendo clic en 'Aplicar'.

Copia la fila:

Pegue la fila copiada en la fila en blanco:

Cambiar la identificación:

Aplicar:

Estaba buscando la misma función pero no uso MySQL. Quería copiar TODOS los campos excepto, por supuesto, la clave principal (id). Esta fue una consulta de una sola vez, que no se utilizará en ningún script o código.

Encontré mi camino con PL / SQL, pero estoy seguro de que cualquier otro IDE de SQL lo haría. Hice un básico

SELECT * 
FROM mytable 
WHERE id=42;

Luego expórtelo a un archivo SQL donde podría encontrar el

INSERT INTO table (col1, col2, col3, ... , col42) 
VALUES (1, 2, 3, ..., 42);

Simplemente lo edité y lo usé:

INSERT INTO table (col1, col2, col3, ... , col42) 
VALUES (mysequence.nextval, 2, 3, ..., 42);

Tiendo a usar una variación de lo que mu es demasiado corto publicado:

INSERT INTO something_log
SELECT NULL, s.*
FROM something AS s
WHERE s.id = 1;

Siempre que las tablas tengan campos idénticos (excepto el incremento automático en la tabla de registro), esto funciona bien.

Como uso procedimientos almacenados siempre que sea posible (para facilitar la vida a otros programadores que no están demasiado familiarizados con las bases de datos), esto resuelve el problema de tener que volver y actualizar los procedimientos cada vez que agrega un nuevo campo a una tabla.

También garantiza que si agrega nuevos campos a una tabla, comenzarán a aparecer en la tabla de registro inmediatamente sin tener que actualizar las consultas de su base de datos (a menos que, por supuesto, tenga algunas que establezcan un campo explícitamente)

Advertencia: querrá asegurarse de agregar nuevos campos a ambas tablas al mismo tiempo para que el orden de los campos permanezca igual ... de lo contrario, comenzará a obtener errores extraños. Si usted es el único que escribe interfaces de base de datos Y tiene mucho cuidado, entonces esto funciona bien. De lo contrario, mantén el nombre de todos tus campos.

Nota: Pensándolo bien, a menos que esté trabajando en un proyecto en solitario que esté seguro de que no habrá otros trabajando en él, adhiérase a la lista explícita de todos los nombres de campo y actualice sus declaraciones de registro a medida que cambia su esquema. Este atajo probablemente no valga el dolor de cabeza a largo plazo que puede causar ... especialmente en un sistema de producción.

INSERTAR EN `dbMyDataBase`.`tblMyTable` 
(
    `IdAutoincrement`, 
    `Column2`, 
    `Column3`, 
    `Column4` 
) 

SELECCIONE 
    NULO,  
    `Column2`, 
    `Column3`, 
    'CustomValue' AS Column4 
DE `dbMyDataBase`.`tblMyTable` 
WHERE `tblMyTable``Column2` = 'UniqueValueOfTheKey' 
; 
/ * mySQL 5.6 * /

Vuelque la fila que desea sql y luego use el SQL generado, menos la columna ID para importarlo nuevamente.