Błąd MySQL 1093 - Nie można określić tabeli docelowej do aktualizacji w klauzuli FROM

Mam story_categorybazę danych w mojej bazie danych z uszkodzonymi wpisami. Następne zapytanie zwraca uszkodzone wpisy:

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

Próbowałem je usunąć, wykonując:

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

Ale pojawia się następny błąd:

# 1093 - Nie można określić tabeli docelowej „story_category” do aktualizacji w klauzuli FROM

Jak mogę to przezwyciężyć?

Aktualizacja: Ta odpowiedź obejmuje ogólną klasyfikację błędów. Aby uzyskać bardziej szczegółową odpowiedź na temat tego, jak najlepiej obsłużyć dokładne zapytanie OP, zobacz inne odpowiedzi na to pytanie

W MySQL nie można modyfikować tej samej tabeli, której używasz w części SELECT.
To zachowanie jest udokumentowane na stronie: http://dev.mysql.com/doc/refman/5.6/en/update.html

Może po prostu przyłączysz się do stołu

Jeśli logika jest wystarczająco prosta, aby zmienić kształt zapytania, należy utracić podzapytanie i dołączyć tabelę do siebie, stosując odpowiednie kryteria wyboru. Spowoduje to, że MySQL zobaczy tabelę jako dwie różne rzeczy, co pozwoli na destrukcyjne zmiany.

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

Alternatywnie spróbuj zagnieżdżić podkwerendę głębiej w klauzuli from ...

Jeśli absolutnie potrzebujesz podzapytania, istnieje obejście, ale jest brzydkie z kilku powodów, w tym wydajności:

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

Zagnieżdżone podzapytanie w klauzuli FROM tworzy domyślną tabelę tymczasową , więc nie jest liczona jako ta sama tabela, którą aktualizujesz.

... ale uważaj na optymalizator zapytań

Pamiętaj jednak, że od MySQL 5.7.6 i późniejszych optymalizator może zoptymalizować podkwerendę i nadal wyświetla błąd. Na szczęście optimizer_switchzmienna może zostać użyta do wyłączenia tego zachowania; chociaż nie mogłem zalecić robienia tego jako czegoś więcej niż krótkoterminowej naprawy lub w przypadku drobnych, jednorazowych zadań.

SET optimizer_switch = 'derived_merge=off';

Dziękuję Peterowi V. Mørchowi za tę radę w komentarzach.

Przykładowa technika pochodzi od barona Schwartza, pierwotnie opublikowana w Nabble , sparafrazowana i rozszerzona tutaj.

NexusRex zapewnił bardzo dobre rozwiązanie do usuwania z łączenia z tej samej tabeli.

Jeśli to zrobisz:

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
)

dostaniesz błąd.

Ale jeśli owiniesz warunek jeszcze jednym, wybierz:

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
)

zrobiłoby to właściwą rzecz !!

Objaśnienie: Optymalizator kwerendy wykonuje pochodną optymalizację scalania dla pierwszego zapytania (co powoduje błąd z błędem), ale drugie zapytanie nie kwalifikuje się do optymalizacji pochodnej scalania . Dlatego optymalizator jest zmuszony najpierw wykonać podzapytanie.

W inner joinpod-zapytaniu nie jest konieczne. Wygląda na to, że chcesz usunąć wpisy, story_categoryktórych category_idnie ma w categorytabeli.

Zrób to:

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

Zamiast tego:

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

Ostatnio musiałem zaktualizować rekordy w tej samej tabeli, co zrobiłem jak poniżej:

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
)

Jeśli nie możesz

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

ponieważ jest to ten sam stół, możesz oszukać i zrobić:

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

[zaktualizuj lub usuń lub cokolwiek]

Tak zrobiłem, aby zaktualizować wartość kolumny Priority o 1, jeśli jest ona> = 1 w tabeli i jej klauzuli WHERE, używając podzapytania w tej samej tabeli, aby upewnić się, że co najmniej jeden wiersz zawiera Priority = 1 (ponieważ to był warunek do sprawdzenia podczas aktualizacji):

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

Wiem, że to trochę brzydkie, ale działa dobrze.

Najprostszym sposobem na to jest użycie aliasu tabeli, gdy odwołujesz się do nadrzędnej tabeli zapytań wewnątrz zapytania podrzędnego.

Przykład:

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

Zmień na:

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

Możesz wstawić żądane identyfikatory wierszy do tabeli tymczasowej, a następnie usunąć wszystkie wiersze znajdujące się w tej tabeli.

co może oznaczać @Cheekysoft, robiąc to w dwóch krokach.

Zgodnie ze składnią Mysql UPDATE połączoną przez @CheekySoft, napisano na samym dole.

Obecnie nie można aktualizować tabeli i wybierać z tej samej tabeli w podzapytaniu.

Wydaje mi się, że usuwasz z store_category, wciąż wybierając z niej w unii.

W przypadku konkretnego zapytania, które OP próbuje osiągnąć, idealnym i najbardziej wydajnym sposobem na to NIE jest wcale korzystanie z podzapytania.

Oto LEFT JOINwersje dwóch zapytań PO:

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

Uwaga: DELETE sogranicza operacje usuwania do story_categorytabeli.
Dokumentacja

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

Jeśli coś nie działa, przechodząc przez drzwi frontowe, weź tylne drzwi:

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;

To jest szybkie. Im większe dane, tym lepiej.

Spróbuj zapisać wynik instrukcji Select w osobnej zmiennej, a następnie użyj go do usunięcia zapytania.

Spróbuj tego

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

co powiesz na to zapytanie? Mam nadzieję, że to pomoże

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

Jeśli chodzi o sprawy, chcesz usunąć wiersze story_category, które nie istnieją w category.

Oto twoje oryginalne zapytanie, aby zidentyfikować wiersze do usunięcia:

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

Łączenie NOT INz podzapytaniem, które JOINjest oryginalną tabelą, wydaje się niepotrzebnie zawiłe. Można to wyrazić w prostszy sposób za pomocą not existsi skorelowanego podkwerendy:

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

Teraz łatwo jest zmienić to w deletestwierdzenie:

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

To pytanie działałoby na dowolnej wersji MySQL, a także w większości innych baz danych, które znam.

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

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

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

| kategoria_id |
| ----------: |
| 4 |
| 5 |