La Performance de imbriquée sélectionnez

Je sais que c'est une question commune et j'ai lu plusieurs autres postes et des papiers, mais je ne pouvais pas en trouver un qui prend en compte les champs indexés et le volume des dossiers que les deux requêtes pourraient revenir.

Ma question est simple, vraiment. Lequel des deux est recommandé ici, écrit dans une syntaxe de type SQL (en termes de performances).

Première requête:

Select *
from someTable s
where s.someTable_id in
                    (Select someTable_id 
                     from otherTable o
                     where o.indexedField = 123)

Deuxième requête:

Select *
from someTable
where someTable_id in
                  (Select someTable_id 
                   from otherTable o
                   where o.someIndexedField = s.someIndexedField
                   and o.anotherIndexedField = 123)

Ma compréhension est que la deuxième requête de requête de la base de données pour chaque n-uplet que la requête externe sera de retour où la première requête évaluer l'intérieure de la sélectionner, puis appliquer le filtre de la requête externe.

Maintenant la deuxième requête peut interroger la base de données ultra-rapides en considérant que la someIndexedField champ est indexé, mais dire que nous avons des milliers ou des millions d'enregistrements ne serait-il pas plus rapide d'utiliser la première requête?

Remarque: Dans une base de données Oracle.

. . En général, une performance de question sans spécifier la base de données est vide de sens. SQL est un langage de description, pas une langue de la procédure, de sorte que l'optimiseur (une partie du moteur) est libre de choisir n'importe quel plan de requête est le meilleur pour une requête donnée.
Bon point. La base de données est une base de données Oracle. La langue ne devrait pas vraiment d'importance, je suppose juste écrit-il dans un SQL syntaxe.
. . Selon Tom Kyte, l'optimiseur Oracle est assez intelligent pour reconnaître les sous-requêtes corrélées et de les transformer en les jointures appropriées (asktom.oracle.com/pls/apex/...). Oracle a une très bonne optimiseur. Ce qui est amusant, c'est que la première version a totalement aweful les performances de MySQL . . . jusqu'à la version 5.6 qui a réglé le problème.

OriginalL'auteur mixkat | 2013-07-04

Dans MySQL, si imbriqués sélectionne sont sur la même table, le temps d'exécution de la requête peut être l'enfer.

Une bonne manière d'améliorer les performances de MySQL, c'est de créer une table temporaire pour la imbriquée sélectionner et appliquer les principaux sélectionnez l'encontre de ce tableau.

Par exemple:

Select *
from someTable s1
where s1.someTable_id in
                    (Select someTable_id 
                     from someTable s2
                     where s2.Field = 123);

Pouvez avoir un meilleur rendement avec:

create temporary table 'temp_table' as (
  Select someTable_id 
  from someTable s2
  where s2.Field = 123
);

Select *
from someTable s1
where s1.someTable_id in
                    (Select someTable_id 
                     from tempTable s2);

Je ne suis pas sûr au sujet de la performance pour une grande quantité de données.

OriginalL'auteur vigoncas

2

Sur la première requête:

première requête évaluera la sélection interne d'abord, puis appliquer le
filtre de la requête externe.

Qui n'est pas si simple.

Dans SQL n'est généralement PAS possible de dire ce qui sera exécuté en premier et ce qui va être exécuté au plus tard.

Parce que SQL - langage déclaratif.

Votre "imbriqués sélectionne" - ne sont visuellement, n'est pas techniquement.

Exemple 1 "someTable" vous avez 10 lignes, dans "otherTable" - 10000 lignes.

Dans la plupart des cas de la base de données optimiseur de lire "someTable" d'abord, vérifiez otherTable avoir de match. Pour cela, il peut, ou ne peut pas utiliser les index en fonction de la situation, mon remplissage dans ce cas, il va utiliser le "indexedField" index.

Exemple 2 "someTable" vous avez 10000 lignes, dans "otherTable" - 10 lignes.

Dans la plupart des cas de la base de données optimiseur de lire toutes les lignes de "otherTable" en mémoire, de les filtrer par 123, et que la volonté de trouver une correspondance dans someTable PK(someTable_id) index. Comme résultat - pas d'index sera utilisé à partir de "otherTable".

Sur la deuxième requête:

Complètement différente de la première. Donc, je ne sais pas comment les comparer:
- Première requête lier les deux tables par une paire de: s.someTable_id = o.someTable_id
- Deuxième requête de lier les deux tables par deux paires: s.someTable_id = o.someTable_id ET de l'o.someIndexedField = s.someIndexedField.
Pratique courante pour lier les deux tables - est votre première requête.
Mais, ô.someTable_id doivent être indexés.

Donc des règles communes sont:
- toutes PK - devrait être indexé (ils indexés par défaut)
- de toutes les colonnes de filtrage (comme celle utilisée dans le cas OÙ une partie) doit être indexé
- toutes les colonnes utilisées pour fournir match entre les tables (y compris, JOINDRE, etc) - est également le filtrage, doivent être indexés.
- DB, le Moteur de l'auto choisissez le meilleur ordre des opérations (ou en parallèle). Dans la plupart des cas, vous ne pouvez pas déterminer ce.
- Utiliser Oracle EXPLIQUER le PLAN de (similaire existe pour la plupart des DBs) pour comparer les plans d'exécution des différentes requêtes sur des données réelles.
OriginalL'auteur vitrilo

Vous devez vous connecter pour publier un commentaire.