Erreur MySQL 1093 - Impossible de spécifier la table cible pour la mise à jour dans la clause FROM

J'ai une table story_categorydans ma base de données avec des entrées corrompues. La requête suivante renvoie les entrées corrompues:

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

J'ai essayé de les supprimer en exécutant:

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

Mais j'obtiens l'erreur suivante:

# 1093 - Vous ne pouvez pas spécifier la table cible 'story_category' pour la mise à jour dans la clause FROM

Comment puis-je surmonter cela?

Mise à jour: cette réponse couvre la classification générale des erreurs. Pour une réponse plus spécifique sur la meilleure façon de traiter la requête exacte de l'OP, veuillez consulter les autres réponses à cette question

Dans MySQL, vous ne pouvez pas modifier la même table que vous utilisez dans la partie SELECT.
Ce comportement est documenté à: http://dev.mysql.com/doc/refman/5.6/en/update.html

Peut-être que vous pouvez simplement joindre la table à elle-même

Si la logique est suffisamment simple pour remodeler la requête, perdez la sous-requête et joignez la table à elle-même, en utilisant des critères de sélection appropriés. Cela amènera MySQL à voir la table comme deux choses différentes, permettant aux changements destructifs d'aller de l'avant.

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

Vous pouvez également essayer d'imbriquer la sous-requête plus profondément dans une clause from ...

Si vous avez absolument besoin de la sous-requête, il existe une solution de contournement, mais elle est moche pour plusieurs raisons, notamment les performances:

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

La sous-requête imbriquée dans la clause FROM crée une table temporaire implicite , donc elle ne compte pas comme la même table que vous mettez à jour.

... mais attention à l'optimiseur de requêtes

Cependant, sachez qu'à partir de MySQL 5.7.6 et versions ultérieures, l'optimiseur peut optimiser la sous-requête et toujours vous donner l'erreur. Heureusement, la optimizer_switchvariable peut être utilisée pour désactiver ce comportement; bien que je ne puisse pas recommander de faire cela comme quelque chose de plus qu'une solution à court terme ou pour de petites tâches ponctuelles.

SET optimizer_switch = 'derived_merge=off';

Merci à Peter V. Mørch pour ce conseil dans les commentaires.

L'exemple de technique provenait du baron Schwartz, initialement publié chez Nabble , paraphrasé et développé ici.

NexusRex a fourni une très bonne solution pour la suppression avec jointure de la même table.

Si tu fais ça:

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
)

vous allez obtenir une erreur.

Mais si vous enveloppez la condition dans une autre sélection:

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
)

ça ferait la bonne chose !!

Explication: L'optimiseur de requêtes effectue une optimisation de fusion dérivée pour la première requête (ce qui entraîne son échec avec l'erreur), mais la deuxième requête n'est pas admissible à l' optimisation de fusion dérivée . Par conséquent, l'optimiseur est obligé d'exécuter la sous-requête en premier.

Le inner joindans votre sous-requête n'est pas nécessaire. Il semble que vous souhaitiez supprimer les entrées story_categorylà où le category_idn'est pas dans le categorytableau.

Faites ceci:

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

Au lieu de:

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

Récemment, j'ai dû mettre à jour des enregistrements dans le même tableau que je l'ai fait ci-dessous:

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 tu ne peux pas faire

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

parce que c'est la même table, vous pouvez tromper et faire:

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

[mettre à jour ou supprimer ou autre]

C'est ce que j'ai fait pour mettre à jour une valeur de colonne Priority de 1 si elle est> = 1 dans une table et dans sa clause WHERE en utilisant une sous-requête sur la même table pour vous assurer qu'au moins une ligne contient Priority = 1 (car c'était le condition à vérifier lors de la mise à jour):

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

Je sais que c'est un peu moche mais ça marche bien.

La façon la plus simple de procéder consiste à utiliser un alias de table lorsque vous faites référence à une table de requête parent dans la sous-requête.

Exemple :

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

Changez-le en:

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

Vous pouvez insérer les identifiants des lignes souhaitées dans une table temporaire, puis supprimer toutes les lignes trouvées dans cette table.

ce qui peut être ce que @Cheekysoft voulait dire en le faisant en deux étapes.

Selon la syntaxe de mise à jour Mysql liée par @CheekySoft, il est indiqué tout en bas.

Actuellement, vous ne pouvez pas mettre à jour une table et sélectionner à partir de la même table dans une sous-requête.

Je suppose que vous supprimez de store_category tout en le sélectionnant dans l'union.

Pour la requête spécifique que l'OP tente de réaliser, le moyen idéal et le plus efficace de le faire est de ne PAS utiliser de sous-requête.

Voici les LEFT JOINversions des deux requêtes de l'OP:

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

Remarque: DELETE slimite les opérations de suppression à la story_categorytable.
Documentation

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

Si quelque chose ne fonctionne pas, en passant par la porte d'entrée, prenez la porte arrière:

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;

C'est rapide. Plus les données sont volumineuses, mieux c'est.

Essayez d'enregistrer le résultat de l'instruction Select dans une variable distincte, puis utilisez-le pour supprimer la requête.

essaye ça

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

que diriez-vous de cette requête j'espère que cela aide

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

En ce qui concerne les préoccupations, vous souhaitez supprimer les lignes story_categoryqui n'existent pas dans category.

Voici votre requête d'origine pour identifier les lignes à supprimer:

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 combinaison NOT INavec une sous-requête qui JOINest la table d'origine semble inutilement alambiquée. Cela peut être exprimé de manière plus directe avec not existset une sous-requête corrélée:

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

Maintenant, il est facile de transformer cela en une deletedéclaration:

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

Cette requête s'exécuterait sur n'importe quelle version de MySQL, ainsi que dans la plupart des autres bases de données que je connais.

Démo sur 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 |