Errore MySQL 1093 - Impossibile specificare la tabella di destinazione per l'aggiornamento nella clausola FROM

Ho una tabella story_categorynel mio database con voci danneggiate. La query successiva restituisce le voci danneggiate:

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

Ho provato a eliminarli eseguendo:

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

Ma ricevo il prossimo errore:

# 1093 - Non è possibile specificare la tabella di destinazione 'story_category' per l'aggiornamento nella clausola FROM

Come posso superare questo?

Aggiornamento: questa risposta copre la classificazione generale dell'errore. Per una risposta più specifica su come gestire al meglio la query esatta del PO, consultare le altre risposte a questa domanda

In MySQL, non è possibile modificare la stessa tabella utilizzata nella parte SELECT.
Questo comportamento è documentato su: http://dev.mysql.com/doc/refman/5.6/en/update.html

Forse puoi semplicemente unirti al tavolo

Se la logica è abbastanza semplice per riformare la query, perdere la sottoquery e unire la tabella a se stessa, utilizzando criteri di selezione appropriati. Ciò farà sì che MySQL consideri la tabella come due cose diverse, consentendo di apportare modifiche distruttive.

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

In alternativa, prova a nidificare la subquery più in profondità in una clausola from ...

Se hai assolutamente bisogno della subquery, c'è una soluzione alternativa, ma è brutta per diversi motivi, tra cui le prestazioni:

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

La subquery nidificata nella clausola FROM crea una tabella temporanea implicita , quindi non conta come la stessa tabella che stai aggiornando.

... ma fai attenzione al Query Optimizer

Tuttavia, attenzione che da MySQL 5.7.6 e versioni successive, l'ottimizzatore può ottimizzare la subquery e comunque restituire l'errore. Fortunatamente, la optimizer_switchvariabile può essere utilizzata per disattivare questo comportamento; anche se non potrei raccomandare di farlo come qualcosa di più di una soluzione a breve termine o per piccole attività una tantum.

SET optimizer_switch = 'derived_merge=off';

Grazie a Peter V. Mørch per questo consiglio nei commenti.

La tecnica di esempio è stata del barone Schwartz, originariamente pubblicata su Nabble , qui parafrasata ed estesa.

NexusRex ha fornito un'ottima soluzione per l'eliminazione con join dalla stessa tabella.

Se lo fai:

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
)

stai per ricevere un errore.

Ma se avvolgi la condizione in un'altra, seleziona:

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
)

farebbe la cosa giusta !!

Spiegazione: Query Optimizer esegue un'ottimizzazione della fusione derivata per la prima query (che causa l'errore con l'errore), ma la seconda query non è idonea per l' ottimizzazione della fusione derivata . Quindi l'ottimizzatore è costretto a eseguire prima la sottoquery.

Il inner joinnella tua sottoquery non è necessario. Sembra che tu voglia eliminare le voci in story_categorycui category_idnon è presente nella categorytabella.

Fai questo:

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

Invece di quello:

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 ho dovuto aggiornare i record nella stessa tabella, l'ho fatto come di seguito:

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 non puoi farlo

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

perché è lo stesso tavolo, puoi ingannare e fare:

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

[aggiorna o elimina o altro]

Questo è quello che ho fatto per aggiornare un valore della colonna Priorità di 1 se è> = 1 in una tabella e nella sua clausola WHERE utilizzando una subquery sulla stessa tabella per assicurarsi che almeno una riga contenga Priority = 1 (perché quello era il condizione da verificare durante l'esecuzione dell'aggiornamento):

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

So che è un po 'brutto ma funziona benissimo.

Il modo più semplice per farlo è utilizzare un alias di tabella quando si fa riferimento alla tabella di query principale all'interno della query secondaria.

Esempio :

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

Modificalo in:

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

È possibile inserire gli ID delle righe desiderate in una tabella temporanea e quindi eliminare tutte le righe che si trovano in quella tabella.

che può essere quello che intendeva @Cheekysoft facendolo in due passaggi.

Secondo la sintassi di Mysql UPDATE collegata da @CheekySoft, dice proprio in fondo.

Attualmente, non è possibile aggiornare una tabella e selezionare dalla stessa tabella in una sottoquery.

Immagino che stai eliminando da store_category mentre selezioni ancora da esso nell'unione.

Per la query specifica che l'OP sta cercando di raggiungere, il modo ideale ed efficiente per farlo NON è affatto utilizzare una subquery.

Ecco le LEFT JOINversioni delle due query del PO:

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

Nota: DELETE slimita le operazioni di eliminazione alla story_categorytabella.
Documentazione

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

Se qualcosa non funziona, entrando dalla porta principale, prendi la porta posteriore:

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;

È veloce. Più grandi sono i dati, meglio è.

Prova a salvare il risultato dell'istruzione Select in una variabile separata, quindi utilizzalo per eliminare la query.

prova questo

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

che ne dite di questa query spero che sia d'aiuto

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

Per quanto riguarda, si desidera eliminare le righe in story_categorycui non esistono category.

Ecco la tua query originale per identificare le righe da eliminare:

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 combinazione NOT INcon una sottoquery che JOINè la tabella originale sembra inutilmente contorta. Questo può essere espresso in modo più diretto not existse con una sottoquery correlata:

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

Ora è facile trasformarlo in una deletedichiarazione:

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

Questa query verrebbe eseguita su qualsiasi versione di MySQL, così come nella maggior parte degli altri database che conosco.

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

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

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

| categoria_id |
| ----------: |
| 4 |
| 5 |