oracle: pouvez-vous utiliser DÉCODER entre les tables?

Vous pouvez l'utiliser entre les colonnes de différentes tables de la sorte:

select oi.order_id, oi.product_id, oi.unit_price, p.list_price, 
       decode(oi.unit_price, p.list_price, 'No Discount',
                   p.list_price - oi.unit_price||' discount') disc
from demo_ord_items oi 
  join demo_product_info p on p.product_id = oi.product_id
where oi.order_id = 1

En théorie, vous pouvez l'utiliser comme une condition de jointure

select oi.order_id, oi.product_id, oi.unit_price, p.list_price
from demo_ord_items oi 
  join demo_product_info p on p.product_id = oi.product_id 
                            and decode(oi.unit_price, p.list_price,0,1) = 1
where oi.order_id = 1

mais il n'est pas commun. Une condition est une valeur booléenne (true/false) et un décodage renvoie un nombre ou un caractère, de sorte que le décodage est un peu redondant (ou peut probablement être ré-écrit pour être plus clair).

Utilisation DECODE lorsqu'une des conditions suivantes est remplie:

• Vous souhaitez écrire des non-SQL portable
• Vous souhaitez écrire du code que seuls les développeurs Oracle de reconnaître et de comprendre
• Vous souhaitez écrire du code qui est difficile à lire
• Vous voulez augmenter le risque d'introduire des bogues, la prochaine fois que vous modifiez le code
• Vous voulez l'optimiseur de générer des sous-optimale des plans d'exécution (lorsqu'elle est utilisée dans la clause where).
• Vous écrivez jetez code

En bref, ne pas utiliser de DÉCODER à tous. Il n'y a rien, il ne peut faire que ne pouvait pas être fait avec un CASE/WHEN. Oui, il y aura plus de taper sur le clavier, et il "vaut" il.

Cela dit, il y a une poubelle cas lorsque je préfère toujours DECODE, qui a à voir avec la façon dont il traite avec NULL. Le scénario est alors que j'ai deux (espérons-le) de tableaux identiques avec la même clé, et quand je veux savoir s'il y a des lignes où les deux tables ne sont pas d'accord sur la valeur d'une colonne.

Par exemple, disons que vous avez réécrit un lot de la procédure pour des raisons de performances, et vous voulez vous assurer que la nouvelle version du produit les mêmes résultats que l'ancienne version. Dans cette situation, vous pourriez envisager NULL et NULL être la même "valeur". DECODE arrive à se comporter comme ça.

decode(a, b, 'Y', 'N') 

traduirait pour le cas suivant/lors de la construction de

case when a = b then 'Y'
     when a is null and b is null then 'Y'
     else 'N'
 end  

Voici un exemple de ce que je veux dire

with old_table as(
  select 1 as id, 'A'  as old_col from dual union all
  select 2 as id, 'A'  as old_col from dual union all
  select 3 as id, 'A'  as old_col from dual union all
  select 4 as id, null as old_col from dual
)
,new_table as(
  select 1 as id, 'A'   as new_col from dual union all
  select 2 as id, 'B'   as new_col from dual union all
  select 3 as id, null  as new_col from dual union all
  select 4 as id, null  as new_col from dual
)
select id
      ,old_col
      ,new_col
      ,decode(old_col, new_col, 'Y', 'N') as has_same_val
  from old_table 
  join new_table using(id);

ID OLD_COL NEW_COL HAS_SAME_VAL
-- ------- ------- ------------
 1 A       A       Y
 2 A       B       N
 3 A       null    N            <-- Note those
 4 null    null    Y            <-- two cases

Donc, pour trouver la différence que je ferais:

where decode(old_col1, new_col1, 'same', 'diff') = 'diff'
   or decode(old_col2, new_col2, 'same', 'diff') = 'diff'
   or decode(old_col3, new_col3, 'same', 'diff') = 'diff'
   or decode(old_col4, new_col4, 'same', 'diff') = 'diff'
   or decode(old_col5, new_col5, 'same', 'diff') = 'diff'