La meilleure pratique de la clause Oracle USING

Disclaimer: je suis un développeur et pas un DBA.

J'ai été un grand fan de la clause using Oracle depuis que je suis tombé par hasard sur elle et l'ont utilisé à la place de l'ancienne, SUR la clause de jointure des tables de faits avec les tables de dimension depuis. Pour moi, il crée un beaucoup plus succincte SQL et produit une plus concis jeu avec pas de superflu dupliqué colonnes.

Cependant, j'ai été invité hier par une collègue pour convertir tous mes à l'AIDE de clauses dans les Modules complémentaires. Je vais vérifier avec lui et lui demander ce que ses raisons sont. Il travaille plus étroitement avec la base de données que je fais, donc je suppose qu'il a de bonnes raisons.

Je n'ai pas entendu parler de lui (nous travaillons dans différents fuseaux horaires), mais je me demande si il y a des lignes directrices ou des pratiques concernant l'utilisation de la clause "using"? J'ai googlé autour un peu, mais n'ont pas trouver quelque chose de définitif. En fait, je n'ai même pas encore un bon débat n'importe où.

Quelqu'un peut jeter quelque lumière sur ce point? Ou fournir un lien vers une bonne discussion sur le sujet?

Merci!

source d'informationauteur RAY

24

Vous êtes sans doute déjà au courant de la distinction, mais à partir de la documentation:

SUR condition Utiliser le ON clause de spécifier une condition de jointure. Faire
vous permet de spécifier les conditions de jointure distincte de toute recherche ou filtrer
les conditions dans le WHERE clause.

À l'AIDE de (colonne) Lorsque vous spécifiez une équi-jointure de colonnes
ont le même nom dans les deux tables, la USING column clause indique
les colonnes à utiliser. Vous pouvez utiliser cette clause que si la jointure
les colonnes des deux tables ont le même nom. Au sein de cette clause, ne pas
qualifier le nom de la colonne avec un nom de table ou de l'alias de la table.

De sorte que ces serait équivalent:
```
select e.ename, d.dname
from emp e join dept d using (deptno);

select e.ename, d.dname
from emp e join dept d on d.deptno = e.deptno;
```
Dans une large mesure que vous utilisez est une question de style, mais il y a (au moins) deux situations où vous ne pouvez pas utiliser using: (a) lorsque les noms de colonnes ne sont pas les mêmes dans les deux tables, et (b) lorsque vous souhaitez utiliser la colonne de jointure:
```
select e.ename, d.dname, d.deptno
from emp e join dept d using(deptno);

select e.ename, d.dname, d.deptno
                         *
ERROR at line 1:
ORA-25154: column part of USING clause cannot have qualifier
```
Bien sûr, vous pouvez simplement laisser tomber la qualification et select ..., deptnoaussi longtemps que vous n'avez pas d'autre table avec la même colonne qui n'est pas joint à l'aide de:
```
select e.ename, d.dname, deptno
from emp e join dept d using (deptno) join mytab m using (empno);

select e.ename, d.dname, deptno
                         *
ERROR at line 1:
ORA-00918: column ambiguously defined
```
Dans ce cas, vous pouvez seulement sélectionnez l'qualifié m.deptno. (OK, c'est plutôt artificiel,...).

La principale raison que je vois pour éviter using est juste de la consistance; car parfois vous ne pouvez pas l'utiliser, de temps en temps de commutation à on pour ces situations pourraient être un peu discordante. Mais encore une fois c'est plus une question de style que de profondément pour raison technique.

Peut-être votre collègue est tout simplement l'imposition (ou suggérer) les normes de codage, mais seulement qu'ils sachent que le. Ce n'est pas tout à fait clair si vous êtes invité à modifier certains nouveau code que vous avez écrit qui va par le biais de l'examen, ou de l'ancien code. Si c'est le dernier alors peu importe les raisons, à la préférant onje pense que vous auriez besoin d'obtenir une seconde justification de la modification prouvé code, car il y a un risque d'introduire de nouveaux problèmes, même lorsque le code modifié est contrôlé, - outre le coût/effort impliqué dans la reprise et de nouveaux tests.

Un couple de choses me frappent au sujet de votre question. Tout d'abord, vous décrit les on syntaxe comme "à l'ancienne", mais je ne pense pas que c'est juste les deux sont valables et actuel (en SQL:2011 je pense, mais citation nécessaire!). Et ceci:

produit une plus concis jeu avec pas de superflu dupliqué colonnes.

... qui, je pense, suggère que vous utilisez select *sinon vous suffit de sélectionner l'une des valeurs, mais avec quelques caractères supplémentaires pour la qualification. À l'aide de select * est généralement considéré comme une mauvaise pratique (ici par exemple) pour autre chose que des requêtes ad hoc et des sous-requêtes.
2

Une question relative à la.

Il semble que la principale différence est syntaxique: les colonnes sont regroupées dans un USING rejoindre.

Dans tous les cas, cela signifie que vous ne pouvez pas accéder à la valeur d'un joint de colonne d'une table particulière, en effet certains SQL ne compile pas, par exemple:
```
SQL> WITH t AS (SELECT 1 a, 2 b, 3 c FROM dual),
  2       v AS (SELECT 1 a, 2 b, 3 c FROM dual)
  3  SELECT t.* FROM t JOIN v USING (a);

SELECT t.* FROM t JOIN v USING (a)
         ^    
ORA-25154: column part of USING clause cannot have qualifier
```
Dans une jointure externe, cela signifie que vous ne pouvez pas accéder à la table externe de la valeur:
```
SQL> WITH t AS (SELECT 1 a, 2 b, 3 c FROM dual),
  2       v AS (SELECT NULL a, 2 b, 3 c FROM dual)
  3  SELECT * FROM t LEFT JOIN v USING (a)
  4   WHERE v.a IS NULL;

 WHERE v.a IS NULL
         ^
ORA-25154: column part of USING clause cannot have qualifier
```
Cela signifie qu'il n'y a pas d'équivalent pour ce anti-syntaxe de jointure avec la USING clause:
```
SQL> WITH t AS (SELECT 1 a, 2 b, 3 c FROM dual),
  2       v AS (SELECT NULL a, 2 b, 3 c FROM dual)
  3  SELECT * FROM t LEFT JOIN v ON v.a = t.a
  4   WHERE v.a IS NULL;

         A          B          C A          B          C
---------- ---------- ---------- - ---------- ----------
         1          2          3  
```
En dehors de cela, je ne suis pas au courant de toute différence une fois que le SQL est valable.

Toutefois, puisqu'il semble que cette syntaxe est moins couramment utilisé, je ne serais pas surpris s'il y avait des bogues spécifiques qui affectent uniquement la USING clause, en particulier dans les premières versions où la norme ANSI SQL a été introduit. Je n'ai rien trouvé sur les MOS qui pourrait confirmer ce, en partie parce que le à l'AIDE de parole est omniprésente dans la description des anomalies.

Si la raison de non utilisation de cette fonctionnalité est à cause de bugs, il me semble que le fardeau de la preuve incombe à votre collègue: les bugs doivent être référencées et documentés, de sorte que l'interdiction peut éventuellement être levée une fois que les bugs sont corrigés (base de données de mise à niveau...).

Si la raison est un cosmétique ou partie d'une convention de codage, il doit sûrement être documentées.
0

Avec l'AIDE de vous ne peut également faire une jointure comme:
sélectionnez une.id,aval,bval,cval
à partir d'un
left join b sur une.id = b.id
left join c sur c.id = b.id;

qui est, donnent seulement la colonne de C quand il est couplé à une ligne dans le B tableau.

Vous devez vous connecter pour publier un commentaire.