Sont un CAS et d'un état de DÉCODER équivalent?

Il semble que le CAS simple expression et le DÉCODAGE de la fonction sont équivalentes et que les résultats renvoyés par eux doivent être identiques. Sont-ils?

La documentation a dire au sujet de la CAS simple expression:

Le CAS simple expression retourne la première raison pour laquelle
selector_value correspond à un sélecteur. Reste expressions ne sont pas
évalué. Si aucun selector_value correspond sélecteur, le CAS de l'expression
retourne else_result, s'il existe, et NULL sinon.

De les comparer à la DÉCODER la fonction, les descriptions semblent être identiques.

DÉCODER compare expr pour chaque valeur de recherche, un par un. Si expr est égal
pour une recherche, puis la Base de données Oracle retourne le résultat correspondant. Si
aucune correspondance n'est trouvée, alors Oracle retourne par défaut. Si la valeur par défaut est omis,
puis Oracle renvoie la valeur null.

Comme le CAS recherché expression peut être équivalente à la simple, cela pourrait être interprété être le même.

Ces déclarations semblent tous retournent le même résultat, 0.

select case 1 when 2 then null else 0 end as simple_case
     , case when 1 = 2 then null else 0 end as searched_case
     , decode(1, 2, null, 0) as decode
  from dual

Faire le CAS simple expression et le DÉCODAGE de la fonction (et dans des circonstances spécifiques du CAS recherché expression) retourne toujours le même résultat?

OriginalL'auteur Ben | 2012-12-04

13

Ben a écrit une longue réponse sur les différences entre les DÉCODER et les CAS. Il démontre que les DÉCODER et les CAS de retour différents types de données pour apparemment le même ensemble de valeurs sans bien expliquer pourquoi cela se produit.

DECODE() est assez normative: c'est toujours le type de données de la première résultat paramètre. Oracle s'applique la conversion implicite de tous les autres paramètres de résultat. Il lèvera une erreur , si (par exemple) le premier paramètre est de type numérique et la valeur par défaut est une date.
```
ORA-00932: inconsistent datatypes: expected NUMBER got DATE
```
Cela est décrit dans la documentation: en savoir plus.

Dans le premier scénario, le premier paramètre est NULL, ce qui Oracle décide de les traiter comme des VARCHAR2. Si nous le modifier de sorte que le premier paramètre de résultat est numérique et la valeur par défaut est null, la DECODE() retournera un NOMBRE; un DUMP() prouve que c'est le cas.

Alors que les CAS insiste sur le fait que toutes les valeurs renvoyées ont le même type de données, et renvoient une erreur de compilation si ce n'est pas le cas. Il ne s'applique pas de conversion implicite. C'est aussi dans la documentation. Lire ici.

La différence se résume à ceci. La suite de DÉCODER instruction sera exécutée, l'instruction de CAS, de ne pas:
```
select decode(1, 1, 1, '1') from dual;

select case 1 when 1 then 1 else '1' end from dual;
```
Obligatoire SQL Violon.

Vous avez raison, c'est beaucoup plus simple :-).
Moins est souvent plus concernant les réponses à la.

OriginalL'auteur APC
24

Réponse courte, no.

Légèrement plus longue réponse est presque.

Il ne apparaît que le résultat obtenu à partir de chaque instruction est identique. Si nous utilisons la DUMP la fonction à évaluer les types de données retournés vous verrez ce que je veux dire:
```
SQL> select dump(case 1 when 2 then null else 0 end) as simple_case
  2       , dump(case when 1 = 2 then null else 0 end) as searched_case
  3       , dump(decode(1, 2, null, 0)) as decode
  4    from dual;

SIMPLE_CASE        SEARCHED_CASE      DECODE
------------------ ------------------ -----------------
Typ=2 Len=1: 128   Typ=2 Len=1: 128   Typ=1 Len=1: 48
```
SQL Violon

Vous pouvez voir que le type de données de la DÉCODER est 1, tandis que les deux CAS énoncés de "retour" à un type de données 2. À l'aide d'Oracle Résumé Des Types De Données, DÉCODER, c'est de revenir un VARCHAR2 (type de données 1) considérant que les CAS énoncés sont "le retour" à la nombre de données (de type 2).

Je suppose que cela se produit parce que, comme le nom l'indique, le DÉCODAGE est un fonction et il ne l'est pas, ce qui implique qu'ils ont été mis en œuvre différemment en interne. Il n'y a vraiment aucun moyen de le prouver.

Vous pourriez penser que cela n'a pas vraiment d'incidence sur quoi que ce soit. Si vous avez besoin d'un certain nombre d'Oracle permettra de convertir implicitement le caractère d'un nombre sous la la conversion implicite des règles, droit? Ce n'est pas vrai non plus, il ne fonctionne pas dans une UNION que les types de données ont être identiques; Oracle ne pourra pas faire la conversion implicite de faire des choses facile pour vous. Deuxièmement, voici ce que l'Oracle dit à propos de la conversion implicite:
Oracle vous recommande de spécifier des conversions explicites, plutôt que de compter sur les implicites ou les conversions automatiques, pour ces raisons:
- SQL sont plus facile à comprendre lorsque vous utilisez des données explicites fonctions de conversion de type.
- Implicite de conversion de type de données peut avoir un impact négatif sur les performances, surtout si le type de données d'une valeur de colonne est converti à cette constante de l'un plutôt que l'inverse.
- Conversion implicite dépend du contexte dans lequel il se produit et ne peut pas travailler de la même façon dans tous les cas. Par exemple, la conversion implicite d'une valeur de type datetime à un VARCHAR2 valeur de retour inattendu de l'année en fonction de la valeur de la NLS_DATE_FORMAT
  le paramètre.
- Algorithmes pour la conversion implicite sont sujets à changement à l'échelle de logiciels et parmi les produits Oracle. Le comportement de conversions explicites est de plus en plus prévisible.
Qui n'est pas une jolie liste; mais l'avant-dernier point m'amène bien sur des dates. Si nous prenons la requête précédente et de le convertir en un qui utilise une date au lieu de cela:
```
select case sysdate when trunc(sysdate) then null 
                    else sysdate 
       end as simple_case
     , case when sysdate = trunc(sysdate) then null 
            else sysdate 
       end as searched_case
     , decode(sysdate, trunc(sysdate), null, sysdate) as decode
  from dual;
```
Une fois de plus, à l'aide de VIDAGE sur cette requête le CAS des déclarations de retour de données de type 12, une DATE. Le DECODE a converti sysdate dans un VARCHAR2.
```
SQL> select dump(case sysdate when trunc(sysdate) then null
  2                           else sysdate
  3              end) as simple_case
  4       , dump(case when sysdate = trunc(sysdate) then null
  5                   else sysdate
  6              end) as searched_case
  7       , dump(decode(sysdate, trunc(sysdate), null, sysdate)) as decode
  8    from dual;

SIMPLE_CASE          
---------------------------------- 
Typ=12 Len=7: 120,112,12,4,22,18,7 
SEARCHED_CASE
---------------------------------- 
Typ=12 Len=7: 120,112,12,4,22,18,7
DECODE
---------------------------------- 
Typ=1 Len=19: 50,48,49,50,45,49,50,45,48,52,32,50,49,58,49,55,58,48,54
```
SQL Violon

Note (dans le SQL Violon) que la DATE a été converti en un caractère à l'aide des séances d' NLS_DATE_FORMAT.

Avoir une date qui a été implicitement converti en un VARCHAR2 peut causer des problèmes. Si vous avez l'intention d'utiliser TO_CHAR, de convertir votre date dans un personnage, votre requête sera break où vous êtes ne s'y attendent pas.
```
SQL> select to_char( decode( sysdate
  2                         , trunc(sysdate), null
  3                         , sysdate )
  4                 , 'yyyy-mm-dd') as to_char
  5    from dual;
select to_char( decode( sysdate
                *
ERROR at line 1:
ORA-01722: invalid number
```
SQL Violon

Aussi, la date de l'arithmétique ne fonctionne plus:
```
SQL>
SQL>
SQL> select decode(sysdate, trunc(sysdate), null, sysdate) + 1 as decode
  2    from dual;
select decode(sysdate, trunc(sysdate), null, sysdate) + 1 as decode
       *
ERROR at line 1:
ORA-01722: invalid number
```
SQL Violon

Il est intéressant de DÉCODER convertit uniquement l'expression d'un VARCHAR2 si l'un des résultats possibles est NULL. Si la valeur par défaut est NULL alors que cela n'arrive pas. Par exemple:
```
SQL> select decode(sysdate, sysdate, sysdate, null) as decode
  2    from dual;

DECODE
-------------------
2012-12-04 21:18:32

SQL> select dump(decode(sysdate, sysdate, sysdate, null)) as decode
  2    from dual;

DECODE
------------------------------------------    
Typ=13 Len=8: 220,7,12,4,21,18,32,0
```
SQL Violon

Noter que le DECODE a retourné un type de données 13. Ce n'est pas documentée, mais elle est, je suppose, un type de date que la date de l'arithmétique, etc. des œuvres.

En bref, évitez de DÉCODER si vous le pouvez; vous ne pourriez pas nécessairement les types de données que vous êtes enceinte. Pour citation de Tom Kyte:

Décoder est quelque peu obscure de CAS est très très clair. Les choses qui sont
facile à faire dans les décoder sont faciles à faire, en CAS, de choses qui sont difficiles ou
près de impossible de le faire avec décodage sont faciles à faire, au CAS où. CAS, la logique
sage, gagne haut la main.

Juste pour être complet il y a deux fonctionnelle différences entre les DÉCODER et les CAS.
1. DÉCODAGE ne peut pas être utilisé au sein de PL/SQL.
2. CAS ne peut pas être utilisé pour comparer les valeurs null directement
```
SQL> select case null when null then null else 1 end as case1
  2        , case when null is null then null else 1 end as case2
  3        , decode(null, null, null, 1) as decode
  4    from dual
  5         ;

     CASE1      CASE2 DECODE
---------- ---------- ------
         1
```
  SQL Violon
+1 et je souhaite que je pourrais +5 - Maintenant, qu'est ce que j'appelle une réponse globale.
Merci beaucoup @Justin, haut de louange! J'ai réfléchi à cela pendant un mois depuis que j'ai attrapé le mal tellement j'en ai eu assez de temps pour formuler ce que je voulais écrire :-).
+1 moi aussi. J'aurais juré qu'ils sont identiques (bien que je préfère CAS pour les mêmes raisons que Tom Kyte n').
Complet mais hélas pas terminé

OriginalL'auteur Ben

-3

Je sais que je suis trop en retard, mais de poster ici parce que si quelqu'un recherche pour que nous espérons que cela pourrait les aider.
J'ai créé un MsSql script pour la même

Declare @Var varchar(399)='DECODE(MyColumnName,''A'',''Auto'',''M'',''Manual'')'

Begin
Declare @Count int, @Counter int=1
Declare @TempTable table (ID int identity(1,1),Items varchar(500))
Declare @SqlText varchar(max)
Select @Var=Replace(Replace(@Var,'DECODE(',''),')','')

Insert Into @TempTable
Select * FROM [dbo].[Split] ( @Var ,',')
--Select * from @TempTable
Select @Count=Count(ID) from @TempTable

While(@Counter<=@Count)
Begin
    If(@Counter=1)
    Begin
    Select @SqlText='Case ' +Items from @TempTable Where ID=1
    End

    Else If(@Counter=@Count)
    Begin
    Select @SqlText+=' Then ' +Items +' End' from @TempTable Where ID=@Counter 
    End

    Else If(@Counter%2=0)
    Begin
    Select @SqlText +=' When ' +Items from @TempTable Where ID=@Counter
    End

    Else If(@Counter%2=1)
    Begin
    Select @SqlText +=' Then ' +Items from @TempTable Where ID=@Counter
    End

    Set @Counter+=1
End

Select @SqlText SqlServerCaseStatement
End

J'ai utilisé la fonction "Split" dans le script ci-dessus, si vous avez besoin de cette fonction, vous pouvez vous référer Romil réponse - Comment scinder une valeurs séparées par des virgules pour les colonnes

Salut, je vous remercie, mais je pense que vous avez complètement raté le point de la question... et c'est pour Oracle, SQL Server...

OriginalL'auteur Anand Singh Sengar

Vous devez vous connecter pour publier un commentaire.