SQL: Comparaison des performances pour l'exclusion (Join vs Not in)

Question

Je suis curieux sur la manière la plus efficace d'interroger l'exclusion sur sql. Par exemple. Il y a 2 tables (tableA et tableB) qui peuvent être jointes sur 1 colonne (col1). Je veux afficher les données de tableA pour toutes les lignes dont col1 n'existe pas dans la tableB.

(Donc, en d'autres termes, tableB contient un sous-ensemble de col1 de tableA. Et je veux afficher tableA sans les données qui existe dans tableB)

Disons que tableB a 100 lignes tandis que tableA est gigantesque (plus que 1M lignes). Je sais que 'pas dans (pas existe)' peut être utilisé mais peut-être y at-il des moyens plus efficaces (moins de temps) pour le faire. Je ne suis peut-être pas avec des jointures externes?

Les extraits de code et commentaires sont très appréciés.

Answer 1

Dépend du SGBDR. Pour Microsoft SQL Server NOT EXISTS is preferred à l'OUTER JOIN car il peut utiliser la jointure Anti-Semi plus efficace.

Pour Oracle Minus is apparently preferred de NE PAS EXISTE (où approprié)

Vous auriez besoin de regarder les plans d'exécution et de décider.

Answer 2

Les questions ont été posées plusieurs fois. La façon la plus rapide est souvent de le faire:

SELECT * FROM table1 
WHERE id in (SELECT id FROM table1 EXCEPT SELECT id FROM table2) 

Comme l'ensemble de rejoindre peut se faire sur les indices, où l'utilisation NOT IN ne peut généralement pas.

Answer 3

Je préfère utiliser

Select a.Col1 
From TableA a 
Left Join TableB b on a.Col1 = b.Col1 
Where b.Col1 Is Null 

Je crois que ce sera plus rapide que vous êtes en utilisant la contrainte FK (à condition que vous les avez bien sûr)

données Exemple:

create table #a 
(
Col1 int 
) 
Create table #b 
(
col1 int 
) 

insert into #a 
Values (1) 
insert into #a 
Values (2) 
insert into #a 
Values (3) 
insert into #a 
Values (4) 

insert into #b 
Values (1) 
insert into #b 
Values (2) 


Select a.Col1 
From #a a 
Left Join #b b on a.col1 = b.Col1 
Where b.Col1 is null 

Answer 4

Il n'y a pas de réponse correcte à cette question. Chaque SGBDR a un optimiseur de requêtes qui déterminera le meilleur plan d'exécution basé sur les indices disponibles, les statistiques de table (nombre de lignes, sélectivité d'index), les conditions de jointure, etc. , il y a souvent plusieurs façons d'obtenir des résultats en SQL. Tout RDBMS respectueux de soi reconnaîtra votre intention et créera le même plan d'exécution, quelle que soit la syntaxe utilisée (sous-requêtes avec opérateur IN ou EXISTS, requête avec JOIN, ...)

Donc, la meilleure solution ici est d'écrire le plus simple requête qui fonctionne, puis vérifiez le plan d'exécution.
Si cette solution n'est pas acceptable, vous devriez essayer de trouver une meilleure requête.