Error 1093 de MySQL: no se puede especificar la tabla de destino para la actualización en la cláusula FROM

Tengo una tabla story_categoryen mi base de datos con entradas corruptas. La siguiente consulta devuelve las entradas corruptas:

SELECT * 
FROM  story_category 
WHERE category_id NOT IN (
    SELECT DISTINCT category.id 
    FROM category INNER JOIN 
       story_category ON category_id=category.id);

Traté de eliminarlos ejecutando:

DELETE FROM story_category 
WHERE category_id NOT IN (
    SELECT DISTINCT category.id 
    FROM category 
      INNER JOIN story_category ON category_id=category.id);

Pero me sale el siguiente error:

# 1093 - No se puede especificar la tabla de destino 'story_category' para actualizar en la cláusula FROM

¿Cómo puedo superar esto?

Actualización: esta respuesta cubre la clasificación de error general. Para obtener una respuesta más específica sobre cómo manejar mejor la consulta exacta del OP, consulte otras respuestas a esta pregunta

En MySQL, no puede modificar la misma tabla que usa en la parte SELECT.
Este comportamiento está documentado en: http://dev.mysql.com/doc/refman/5.6/en/update.html

Quizás puedas unirte a la mesa

Si la lógica es lo suficientemente simple como para cambiar la forma de la consulta, pierda la subconsulta y una la tabla a sí misma, empleando los criterios de selección adecuados. Esto hará que MySQL vea la tabla como dos cosas diferentes, permitiendo que se produzcan cambios destructivos.

UPDATE tbl AS a
INNER JOIN tbl AS b ON ....
SET a.col = b.col

Alternativamente, intente anidar la subconsulta más profundamente en una cláusula from ...

Si realmente necesita la subconsulta, hay una solución alternativa, pero es fea por varias razones, incluido el rendimiento:

UPDATE tbl SET col = (
  SELECT ... FROM (SELECT.... FROM) AS x);

La subconsulta anidada en la cláusula FROM crea una tabla temporal implícita , por lo que no cuenta como la misma tabla que está actualizando.

... pero ten cuidado con el optimizador de consultas

Sin embargo, tenga en cuenta que desde MySQL 5.7.6 y posteriores, el optimizador puede optimizar la subconsulta y aún así le dará el error. Afortunadamente, la optimizer_switchvariable se puede usar para desactivar este comportamiento; aunque no podría recomendar hacer esto como algo más que una solución a corto plazo, o para pequeñas tareas puntuales.

SET optimizer_switch = 'derived_merge=off';

Gracias a Peter V. Mørch por este consejo en los comentarios.

La técnica de ejemplo fue del barón Schwartz, originalmente publicado en Nabble , parafraseado y extendido aquí.

NexusRex proporcionó una muy buena solución para eliminar con join de la misma tabla.

Si haces esto:

DELETE FROM story_category
WHERE category_id NOT IN (
        SELECT DISTINCT category.id AS cid FROM category 
        INNER JOIN story_category ON category_id=category.id
)

vas a obtener un error

Pero si envuelve la condición en una selección más:

DELETE FROM story_category
WHERE category_id NOT IN (
    SELECT cid FROM (
        SELECT DISTINCT category.id AS cid FROM category 
        INNER JOIN story_category ON category_id=category.id
    ) AS c
)

¡Haría lo correcto!

Explicación: El optimizador de consultas realiza una optimización de fusión derivada para la primera consulta (lo que hace que falle con el error), pero la segunda consulta no califica para la optimización de fusión derivada . Por lo tanto, el optimizador se ve obligado a ejecutar la subconsulta primero.

El inner joinen su subconsulta es innecesario. Parece que desea eliminar las entradas en story_categorydonde category_idno está en la categorytabla.

Hacer esto:

DELETE FROM story_category 
WHERE category_id NOT IN (
    SELECT DISTINCT category.id 
    FROM category);

En lugar de eso:

DELETE FROM story_category 
WHERE category_id NOT IN (
    SELECT DISTINCT category.id 
    FROM category INNER JOIN
         story_category ON category_id=category.id);

Recientemente tuve que actualizar registros en la misma tabla que hice a continuación:

UPDATE skills AS s, (SELECT id  FROM skills WHERE type = 'Programming') AS p
SET s.type = 'Development' 
WHERE s.id = p.id;

DELETE FROM story_category
WHERE category_id NOT IN (
    SELECT cid FROM (
        SELECT DISTINCT category.id AS cid FROM category INNER JOIN story_category ON category_id=category.id
    ) AS c
)

Si no puedes hacer

UPDATE table SET a=value WHERE x IN
    (SELECT x FROM table WHERE condition);

porque es la misma tabla, puedes engañar y hacer:

UPDATE table SET a=value WHERE x IN
    (SELECT * FROM (SELECT x FROM table WHERE condition) as t)

[actualizar o eliminar o lo que sea]

Esto es lo que hice para actualizar un valor de columna de Prioridad en 1 si es> = 1 en una tabla y en su cláusula WHERE utilizando una subconsulta en la misma tabla para asegurarse de que al menos una fila contenga Prioridad = 1 (porque esa fue la condición a comprobar mientras se realiza la actualización):

UPDATE My_Table
SET Priority=Priority + 1
WHERE Priority >= 1
AND (SELECT TRUE FROM (SELECT * FROM My_Table WHERE Priority=1 LIMIT 1) as t);

Sé que es un poco feo, pero funciona bien.

La forma más sencilla de hacer esto es usar un alias de tabla cuando se refiere a una tabla de consulta principal dentro de la subconsulta.

Ejemplo:

insert into xxx_tab (trans_id) values ((select max(trans_id)+1 from xxx_tab));

Cámbielo a:

insert into xxx_tab (trans_id) values ((select max(P.trans_id)+1 from xxx_tab P));

Puede insertar los identificadores de las filas deseadas en una tabla temporal y luego eliminar todas las filas que se encuentran en esa tabla.

que puede ser lo que @Cheekysoft quiso decir al hacerlo en dos pasos.

De acuerdo con la sintaxis de ACTUALIZACIÓN de Mysql vinculada por @CheekySoft, dice justo en la parte inferior.

Actualmente, no puede actualizar una tabla y seleccionar de la misma tabla en una subconsulta.

Supongo que está eliminando de store_category mientras sigue seleccionando en la unión.

Para la consulta específica que el OP está tratando de lograr, la forma ideal y más eficiente de hacer esto NO es utilizar una subconsulta.

Estas son las LEFT JOINversiones de las dos consultas del OP:

SELECT s.* 
FROM story_category s 
LEFT JOIN category c 
ON c.id=s.category_id 
WHERE c.id IS NULL;

Nota: DELETE srestringe las operaciones de eliminación a la story_categorytabla.
Documentación

DELETE s 
FROM story_category s 
LEFT JOIN category c 
ON c.id=s.category_id 
WHERE c.id IS NULL;

Si algo no funciona, al pasar por la puerta principal, tome la puerta trasera:

drop table if exists apples;
create table if not exists apples(variety char(10) primary key, price int);

insert into apples values('fuji', 5), ('gala', 6);

drop table if exists apples_new;
create table if not exists apples_new like apples;
insert into apples_new select * from apples;

update apples_new
    set price = (select price from apples where variety = 'gala')
    where variety = 'fuji';
rename table apples to apples_orig;
rename table apples_new to apples;
drop table apples_orig;

Es rápido. Cuanto más grandes sean los datos, mejor.

Intente guardar el resultado de la instrucción Select en una variable separada y luego utilícelo para eliminar la consulta.

prueba esto

DELETE FROM story_category 
WHERE category_id NOT IN (
SELECT DISTINCT category.id 
FROM (SELECT * FROM STORY_CATEGORY) sc;

¿qué tal esta consulta espero que ayude

DELETE FROM story_category LEFT JOIN (SELECT category.id FROM category) cat ON story_category.id = cat.id WHERE cat.id IS NULL

En lo que respecta a las preocupaciones, desea eliminar filas story_categoryque no existen en category.

Aquí está su consulta original para identificar las filas a eliminar:

SELECT * 
FROM  story_category 
WHERE category_id NOT IN (
    SELECT DISTINCT category.id 
    FROM category INNER JOIN 
       story_category ON category_id=category.id
);

La combinación NOT INcon una subconsulta que JOINes la tabla original parece complicada de manera innecesaria. Esto se puede expresar de una manera más directa con not existsuna subconsulta correlacionada:

select sc.*
from story_category sc
where not exists (select 1 from category c where c.id = sc.category_id);

Ahora es fácil convertir esto en una deletedeclaración:

delete from story_category
where not exists (select 1 from category c where c.id = story_category.category_id);    

Este quer se ejecutaría en cualquier versión de MySQL, así como en la mayoría de las otras bases de datos que conozco.

Demostración en DB Fiddle :

-- set-up
create table story_category(category_id int);
create table category (id int);
insert into story_category values (1), (2), (3), (4), (5);
insert into category values (4), (5), (6), (7);

-- your original query to identify offending rows
SELECT * 
FROM  story_category 
WHERE category_id NOT IN (
    SELECT DISTINCT category.id 
    FROM category INNER JOIN 
       story_category ON category_id=category.id);

El | category_id |
El | ----------: |
El | 1 |
El | 2 |
El | 3 |

-- a functionally-equivalent, simpler query for this
select sc.*
from story_category sc
where not exists (select 1 from category c where c.id = sc.category_id)

El | category_id |
El | ----------: |
El | 1 |
El | 2 |
El | 3 |

-- the delete query
delete from story_category
where not exists (select 1 from category c where c.id = story_category.category_id);

-- outcome
select * from story_category;

El | category_id |
El | ----------: |
El | 4 |
El | 5 |