Come funzionano le istruzioni SQL EXISTS?

Sto cercando di imparare SQL e sto avendo difficoltà a capire le dichiarazioni EXISTS. Mi sono imbattuto in questa citazione su "esiste" e non capisco qualcosa:

Utilizzando l'operatore exist, la sottoquery può restituire zero, una o più righe e la condizione controlla semplicemente se la sottoquery ha restituito righe. Se guardi la clausola select della sottoquery, vedrai che è costituita da un singolo letterale (1); poiché la condizione nella query che la contiene deve solo sapere quante righe sono state restituite, i dati effettivi restituiti dalla sottoquery sono irrilevanti.

Quello che non capisco è come fa la query esterna a sapere quale riga sta controllando la sottoquery? Per esempio:

SELECT *
  FROM suppliers
 WHERE EXISTS (select *
                 from orders
                where suppliers.supplier_id = orders.supplier_id);

Capisco che se l'ID del fornitore e la tabella degli ordini corrispondono, la sottoquery restituirà true e tutte le colonne dalla riga corrispondente nella tabella dei fornitori verranno emesse. Quello che non capisco è come la sottoquery comunica quale riga specifica (diciamo la riga con ID fornitore 25) deve essere stampata se viene restituito solo un vero o falso.

Mi sembra che non vi sia alcuna relazione tra la query esterna e la sottoquery.

Pensare in questo modo:

Per "ogni" riga da Suppliers, controlla se "esiste" una riga nella Ordertabella che soddisfa la condizione Suppliers.supplier_id(proviene dalla "riga" corrente della query esterna) = Orders.supplier_id. Quando trovi la prima riga corrispondente, fermati lì: WHERE EXISTSè stata soddisfatta.

Il collegamento magico tra la query esterna e la sottoquery risiede nel fatto che Supplier_idviene passato dalla query esterna alla sottoquery per ogni riga valutata.

Oppure, per dirla in un altro modo, la sottoquery viene eseguita per ogni riga della tabella della query esterna.

NON è come se la sottoquery venga eseguita nel suo insieme e ottiene il "vero / falso" e quindi cerca di far corrispondere questa condizione "vero / falso" con la query esterna.

Mi sembra che non vi sia alcuna relazione tra la query esterna e la sottoquery.

Cosa pensi che stia facendo la clausola WHERE nell'esempio EXISTS? Come si arriva a questa conclusione quando il riferimento FORNITORI non è nelle clausole FROM o JOIN all'interno della clausola EXISTS?

EXISTS valuta VERO / FALSO ed esce come VERO alla prima corrispondenza dei criteri: ecco perché può essere più veloce di IN. Tieni inoltre presente che la clausola SELECT in un EXISTS viene ignorata - IE:

SELECT s.*
  FROM SUPPLIERS s
 WHERE EXISTS (SELECT 1/0
                 FROM ORDERS o
                WHERE o.supplier_id = s.supplier_id)

... dovrebbe colpire una divisione per errore zero, ma non lo farà. La clausola WHERE è l'elemento più importante di una clausola EXISTS.

Inoltre, tieni presente che un JOIN non è una sostituzione diretta di EXISTS, perché ci saranno record padre duplicati se c'è più di un record figlio associato al padre.

È possibile produrre risultati identici utilizzando JOIN, EXISTS, IN, o INTERSECT:

SELECT s.supplier_id
FROM suppliers s
INNER JOIN (SELECT DISTINCT o.supplier_id FROM orders o) o
    ON o.supplier_id = s.supplier_id

SELECT s.supplier_id
FROM suppliers s
WHERE EXISTS (SELECT * FROM orders o WHERE o.supplier_id = s.supplier_id)

SELECT s.supplier_id 
FROM suppliers s 
WHERE s.supplier_id IN (SELECT o.supplier_id FROM orders o)

SELECT s.supplier_id
FROM suppliers s
INTERSECT
SELECT o.supplier_id
FROM orders o

Se hai una clausola where simile a questa:

WHERE id in (25,26,27) -- and so on

puoi facilmente capire perché alcune righe vengono restituite e altre no.

Quando la clausola where è così:

WHERE EXISTS (select * from orders where suppliers.supplier_id = orders.supplier_id);

significa semplicemente: restituisci righe che hanno un record esistente nella tabella degli ordini con lo stesso id.

Modello di tabella di database

Supponiamo di avere le seguenti due tabelle nel nostro database, che formano una relazione di tabella uno-a-molti.

La studenttabella è la tabella principale e la student_gradetabella figlia poiché ha una colonna Student_id Foreign Key che fa riferimento alla colonna id Primary Key nella tabella student.

Il student tablecontiene i seguenti due record:

| id | first_name | last_name | admission_score |
|----|------------|-----------|-----------------|
| 1  | Alice      | Smith     | 8.95            |
| 2  | Bob        | Johnson   | 8.75            |

Inoltre, la student_gradetabella memorizza i voti ricevuti dagli studenti:

| id | class_name | grade | student_id |
|----|------------|-------|------------|
| 1  | Math       | 10    | 1          |
| 2  | Math       | 9.5   | 1          |
| 3  | Math       | 9.75  | 1          |
| 4  | Science    | 9.5   | 1          |
| 5  | Science    | 9     | 1          |
| 6  | Science    | 9.25  | 1          |
| 7  | Math       | 8.5   | 2          |
| 8  | Math       | 9.5   | 2          |
| 9  | Math       | 9     | 2          |
| 10 | Science    | 10    | 2          |
| 11 | Science    | 9.4   | 2          |

SQL ESISTE

Diciamo che vogliamo ottenere tutti gli studenti che hanno ricevuto un voto 10 in una classe di matematica.

Se siamo interessati solo all'identificatore dello studente, possiamo eseguire una query come questa:

SELECT
    student_grade.student_id
FROM
    student_grade
WHERE
    student_grade.grade = 10 AND
    student_grade.class_name = 'Math'
ORDER BY
    student_grade.student_id

Tuttavia, l'applicazione è interessata a visualizzare il nome completo di a student, non solo l'identificatore, quindi abbiamo bisogno anche di informazioni dalla studenttabella.

Per filtrare i studentrecord che hanno un voto 10 in matematica, possiamo usare l'operatore SQL EXISTS, in questo modo:

SELECT
    id, first_name, last_name
FROM
    student
WHERE EXISTS (
    SELECT 1
    FROM
        student_grade
    WHERE
        student_grade.student_id = student.id AND
        student_grade.grade = 10 AND
        student_grade.class_name = 'Math'
)
ORDER BY id

Quando si esegue la query sopra, possiamo vedere che è selezionata solo la riga Alice:

| id | first_name | last_name |
|----|------------|-----------|
| 1  | Alice      | Smith     |

La query esterna seleziona le studentcolonne delle righe che ci interessa restituire al client. Tuttavia, la clausola WHERE utilizza l'operatore EXISTS con una sottoquery interna associata.

L'operatore EXISTS restituisce true se la sottoquery restituisce almeno un record e false se non è selezionata alcuna riga. Il motore di database non deve eseguire completamente la sottoquery. Se viene trovato un singolo record, l'operatore EXISTS restituisce true e viene selezionata l'altra riga di query associata.

La sottoquery interna è correlata perché la colonna student_id della student_gradetabella viene confrontata con la colonna id della tabella student esterna.

EXISTS significa che la sottoquery restituisce almeno una riga, è davvero così. In tal caso, è una sottoquery correlata perché controlla il fornitore_id della tabella esterna con il fornitore_id della tabella interna. Questa query dice, in effetti:

SELEZIONA tutti i fornitori Per ogni ID fornitore, verifica se esiste un ordine per questo fornitore Se il fornitore non è presente nella tabella ordini, rimuovi il fornitore dai risultati RETURN tutti i fornitori che hanno righe corrispondenti nella tabella ordini

Potresti fare la stessa cosa in questo caso con un INNER JOIN.

SELECT suppliers.* 
  FROM suppliers 
 INNER 
  JOIN orders 
    ON suppliers.supplier_id = orders.supplier_id;

Il commento dei pony è corretto. Avresti bisogno di raggruppare con quel join o selezionare distinti a seconda dei dati di cui hai bisogno.

Ciò che descrivi è una cosiddetta query con una sottoquery correlata .

(In generale) è qualcosa che dovresti cercare di evitare scrivendo la query utilizzando invece un join:

SELECT suppliers.* 
FROM suppliers 
JOIN orders USING supplier_id
GROUP BY suppliers.supplier_id

Perché altrimenti, la sottoquery verrà eseguita per ogni riga nella query esterna.