Erro MySQL 1093 - Não é possível especificar a tabela de destino para atualização na cláusula FROM

Eu tenho uma tabela story_categoryno meu banco de dados com entradas corrompidas. A próxima consulta retorna as entradas corrompidas:

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

Eu tentei excluí-los executando:

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

Mas eu recebo o próximo erro:

# 1093 - Você não pode especificar a tabela de destino 'story_category' para atualização na cláusula FROM

Como posso superar isso?

Atualização: Esta resposta cobre a classificação geral de erros. Para obter uma resposta mais específica sobre como lidar melhor com a consulta exata do OP, consulte outras respostas a esta pergunta

No MySQL, você não pode modificar a mesma tabela que você usa na parte SELECT.
Esse comportamento está documentado em: http://dev.mysql.com/doc/refman/5.6/en/update.html

Talvez você possa simplesmente juntar a mesa a si próprio

Se a lógica for simples o suficiente para remodelar a consulta, perca a subconsulta e junte a tabela a ela mesma, empregando critérios de seleção apropriados. Isso fará com que o MySQL veja a tabela como duas coisas diferentes, permitindo que mudanças destrutivas ocorram.

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

Como alternativa, tente aninhar a subconsulta mais profundamente na cláusula from ...

Se você absolutamente precisa da subconsulta, há uma solução alternativa, mas é feia por vários motivos, incluindo desempenho:

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

A subconsulta aninhada na cláusula FROM cria uma tabela temporária implícita , portanto não conta como a mesma tabela que você está atualizando.

... mas cuidado com o otimizador de consultas

No entanto, tenha cuidado com o MySQL 5.7.6 em diante, o otimizador pode otimizar a subconsulta e ainda assim fornecer o erro. Felizmente, a optimizer_switchvariável pode ser usada para desativar esse comportamento; embora eu não possa recomendar fazer isso como algo além de uma correção de curto prazo ou para pequenas tarefas pontuais.

SET optimizer_switch = 'derived_merge=off';

Obrigado a Peter V. Mørch por esse conselho nos comentários.

A técnica de exemplo foi do Barão Schwartz, originalmente publicada em Nabble , parafraseada e estendida aqui.

O NexusRex forneceu uma solução muito boa para excluir com junção da mesma tabela.

Se você fizer isto:

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
)

você receberá um erro.

Mas se você agrupar a condição em mais uma, selecione:

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
)

faria a coisa certa !!

Explicação: O otimizador de consulta faz uma otimização de mesclagem derivada para a primeira consulta (o que causa falha no erro), mas a segunda consulta não se qualifica para a otimização de mesclagem derivada . Portanto, o otimizador é forçado a executar a subconsulta primeiro.

A inner joinsubconsulta é desnecessária. Parece que você deseja excluir as entradas em story_categoryque category_idnão estão na categorytabela.

Faça isso:

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

Ao invés disso:

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

Recentemente, tive que atualizar registros na mesma tabela que fiz como abaixo:

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
)

Se você não pode fazer

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

porque é a mesma tabela, você pode enganar e fazer:

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

[atualizar ou excluir ou o que for]

Foi o que fiz para atualizar um valor da coluna Priority por 1 se for> = 1 em uma tabela e em sua cláusula WHERE usando uma subconsulta na mesma tabela para garantir que pelo menos uma linha contenha Priority = 1 (porque esse era o condição a ser verificada durante a atualização):

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);

Eu sei que é um pouco feio, mas funciona bem.

A maneira mais simples de fazer isso é usar um alias de tabela quando você estiver consultando a tabela de consulta pai dentro da subconsulta.

Exemplo:

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

Altere para:

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

Você pode inserir os IDs das linhas desejadas em uma tabela temporária e excluir todas as linhas encontradas nessa tabela.

que pode ser o que a @Cheekysoft quis dizer com isso em duas etapas.

De acordo com o Mysql UPDATE Syntax, vinculado por @CheekySoft, está escrito na parte inferior.

Atualmente, você não pode atualizar uma tabela e selecionar a mesma tabela em uma subconsulta.

Eu acho que você está excluindo da store_category enquanto ainda a seleciona na união.

Para a consulta específica que o OP está tentando realizar, a maneira ideal e mais eficiente de fazer isso é NÃO usar uma subconsulta.

Aqui estão as LEFT JOINversões das duas consultas do 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 as operações de exclusão à story_categorytabela.
Documentação

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

Se algo não funcionar, ao passar pela porta da frente, pegue a porta dos fundos:

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;

É rápido. Quanto maiores os dados, melhor.

Tente salvar o resultado da instrução Select em variável separada e use-o para excluir a consulta.

tente isso

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

que tal esta consulta espero que ajude

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

No que diz respeito às preocupações, você deseja excluir as linhas story_categoryque não existem category.

Aqui está sua consulta original para identificar as linhas a serem excluídas:

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

Combinar NOT INcom uma subconsulta que JOINé a tabela original parece involuntariamente complicado. Isso pode ser expresso de uma maneira mais direta e com not existsuma subconsulta correlacionada:

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

Agora é fácil transformar isso em uma deletedeclaração:

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

Essa consulta seria executada em qualquer versão do MySQL, assim como na maioria dos outros bancos de dados que eu conheço.

Demo no 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);

| category_id |
| ----------: |
| 1 |
| 2
| 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)

| category_id |
| ----------: |
| 1 |
| 2
| 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;

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