Existe-t-il une fonction Max dans SQL Server qui prend deux valeurs comme Math.Max ​​dans .NET?

Je veux écrire une requête comme celle-ci:

SELECT o.OrderId, MAX(o.NegotiatedPrice, o.SuggestedPrice)
FROM Order o

Mais ce n'est pas ainsi que la MAXfonction fonctionne, non? Il s'agit d'une fonction d'agrégation, elle attend donc un seul paramètre, puis retourne le MAX de toutes les lignes.

Est-ce que quelqu'un sait comment le faire à ma façon?

Vous auriez besoin de faire un User-Defined Functionsi vous vouliez avoir une syntaxe similaire à votre exemple, mais pourriez-vous faire ce que vous voulez faire, en ligne, assez facilement avec une CASEdéclaration, comme les autres l'ont dit.

Le UDFpourrait être quelque chose comme ceci:

create function dbo.InlineMax(@val1 int, @val2 int)
returns int
as
begin
  if @val1 > @val2
    return @val1
  return isnull(@val2,@val1)
end

... et tu appellerais ça comme ça ...

SELECT o.OrderId, dbo.InlineMax(o.NegotiatedPrice, o.SuggestedPrice) 
FROM Order o

Si vous utilisez SQL Server 2008 (ou supérieur), voici la meilleure solution:

SELECT o.OrderId,
       (SELECT MAX(Price)
        FROM (VALUES (o.NegotiatedPrice),(o.SuggestedPrice)) AS AllPrices(Price))
FROM Order o

Tous les crédits et votes devraient aller à la réponse de Sven à une question connexe, "SQL MAX de plusieurs colonnes?"
Je dis que c'est la " meilleure réponse " car:

1. Cela ne nécessite pas de compliquer votre code avec les déclarations UNION, PIVOT, UNPIVOT, UDF et folles.
2. Il n'est pas en proie au problème de la gestion des valeurs nulles, il les gère très bien.
3. Il est facile de remplacer le "MAX" par "MIN", "AVG" ou "SUM". Vous pouvez utiliser n'importe quelle fonction d'agrégation pour rechercher l'agrégat sur de nombreuses colonnes différentes.
4. Vous n'êtes pas limité aux noms que j'ai utilisés (c'est-à-dire "AllPrices" et "Price"). Vous pouvez choisir vos propres noms pour le rendre plus facile à lire et à comprendre pour le prochain gars.
5. Vous pouvez trouver plusieurs agrégats à l'aide des tables dérivées de SQL Server 2008 comme suit :
   SELECT MAX (a), MAX (b) FROM (VALUES (1, 2), (3, 4), (5, 6), (7, 8), (9, 10)) COMME MyTable (a, b)

Peut se faire en une seule ligne:

-- the following expression calculates ==> max(@val1, @val2)
SELECT 0.5 * ((@val1 + @val2) + ABS(@val1 - @val2)) 

Edit: Si vous avez affaire à de très grands nombres, vous devrez convertir les variables de valeur en bigint afin d'éviter un débordement d'entier.

Je ne pense pas. Je le voulais l'autre jour. Le plus proche que j'ai obtenu était:

SELECT
  o.OrderId,
  CASE WHEN o.NegotiatedPrice > o.SuggestedPrice THEN o.NegotiatedPrice 
     ELSE o.SuggestedPrice
  END
FROM Order o

Pourquoi ne pas essayer la fonction IIF (nécessite SQL Server 2012 et versions ultérieures)

IIF(a>b, a, b)

C'est ça.

(Astuce: soyez prudent dans les deux cas null, car le résultat de a>bsera faux chaque fois que l'un ou l'autre est nul. Il en bsera de même dans ce cas)

DECLARE @MAX INT
@MAX = (SELECT MAX(VALUE) 
               FROM (SELECT 1 AS VALUE UNION 
                     SELECT 2 AS VALUE) AS T1)

Les autres réponses sont bonnes, mais si vous devez vous soucier d'avoir des valeurs NULL, vous voudrez peut-être cette variante:

SELECT o.OrderId, 
   CASE WHEN ISNULL(o.NegotiatedPrice, o.SuggestedPrice) > ISNULL(o.SuggestedPrice, o.NegotiatedPrice)
        THEN ISNULL(o.NegotiatedPrice, o.SuggestedPrice)
        ELSE ISNULL(o.SuggestedPrice, o.NegotiatedPrice)
   END
FROM Order o

Dans SQL Server 2012 ou version ultérieure, vous pouvez utiliser une combinaison de IIFet ISNULL(ou COALESCE) pour obtenir le maximum de 2 valeurs.
Même lorsque l'un d'eux est NULL.

IIF(col1 >= col2, col1, ISNULL(col2, col1)) 

Ou si vous voulez qu'il renvoie 0 lorsque les deux sont NULL

IIF(col1 >= col2, col1, COALESCE(col2, col1, 0)) 

Exemple d'extrait:

-- use table variable for testing purposes
declare @Order table 
(
  OrderId int primary key identity(1,1),
  NegotiatedPrice decimal(10,2),
  SuggestedPrice decimal(10,2)
);

-- Sample data
insert into @Order (NegotiatedPrice, SuggestedPrice) values
(0, 1),
(2, 1),
(3, null),
(null, 4);

-- Query
SELECT 
     o.OrderId, o.NegotiatedPrice, o.SuggestedPrice, 
     IIF(o.NegotiatedPrice >= o.SuggestedPrice, o.NegotiatedPrice, ISNULL(o.SuggestedPrice, o.NegotiatedPrice)) AS MaxPrice
FROM @Order o

Résultat:

OrderId NegotiatedPrice SuggestedPrice  MaxPrice
1       0,00            1,00            1,00
2       2,00            1,00            2,00
3       3,00            NULL            3,00
4       NULL            4,00            4,00

Mais si l'on doit additionner plusieurs valeurs?
Ensuite, je suggère de CROSS APPLIQUER à une agrégation des VALEURS.
Cela a également l'avantage de pouvoir calculer d'autres choses en même temps.

Exemple:

SELECT t.*
, ca.[Total]
, ca.[Maximum]
, ca.[Minimum]
, ca.[Average]
FROM SomeTable t
CROSS APPLY (
   SELECT 
    SUM(v.col) AS [Total], 
    MIN(v.col) AS [Minimum], 
    MAX(v.col) AS [Maximum], 
    AVG(v.col) AS [Average]
   FROM (VALUES (t.Col1), (t.Col2), (t.Col3), (t.Col4)) v(col)
) ca

Les sous-requêtes peuvent accéder aux colonnes à partir de la requête externe, vous pouvez donc utiliser cette approche pour utiliser des agrégats tels que MAXsur plusieurs colonnes. (Probablement plus utile quand il y a un plus grand nombre de colonnes impliquées)

;WITH [Order] AS
(
SELECT 1 AS OrderId, 100 AS NegotiatedPrice, 110 AS SuggestedPrice UNION ALL
SELECT 2 AS OrderId, 1000 AS NegotiatedPrice, 50 AS SuggestedPrice
)
SELECT
       o.OrderId, 
       (SELECT MAX(price)FROM 
           (SELECT o.NegotiatedPrice AS price 
            UNION ALL SELECT o.SuggestedPrice) d) 
        AS MaxPrice 
FROM  [Order]  o

SQL Server 2012 a introduit IIF:

SELECT 
    o.OrderId, 
    IIF( ISNULL( o.NegotiatedPrice, 0 ) > ISNULL( o.SuggestedPrice, 0 ),
         o.NegotiatedPrice, 
         o.SuggestedPrice 
    )
FROM 
    Order o

La manipulation des valeurs NULL est recommandée lors de l'utilisation IIF, car un NULLde chaque côté de votre boolean_expressionvolonté provoquera IIFle retour de false_value(par opposition à NULL).

J'irais avec la solution fournie par kcrumley Il suffit de la modifier légèrement pour gérer les NULLs

create function dbo.HigherArgumentOrNull(@val1 int, @val2 int)
returns int
as
begin
  if @val1 >= @val2
    return @val1
  if @val1 < @val2
    return @val2

 return NULL
end

EDIT Modifié après commentaire de Mark . Comme il l'a correctement souligné dans 3 logiques de valeur, x> NULL ou x <NULL doit toujours retourner NULL. En d'autres termes, résultat inconnu.

C'est aussi simple que cela:

CREATE FUNCTION InlineMax
(
    @p1 sql_variant,
    @p2 sql_variant
)  RETURNS sql_variant
AS
BEGIN
    RETURN CASE 
        WHEN @p1 IS NULL AND @p2 IS NOT NULL THEN @p2 
        WHEN @p2 IS NULL AND @p1 IS NOT NULL THEN @p1
        WHEN @p1 > @p2 THEN @p1
        ELSE @p2 END
END;

SELECT o.OrderId,   
--MAX(o.NegotiatedPrice, o.SuggestedPrice)  
(SELECT MAX(v) FROM (VALUES (o.NegotiatedPrice), (o.SuggestedPrice)) AS value(v)) as ChoosenPrice  
FROM Order o

Oups, je viens de poster une dupe de cette question ...

La réponse est qu'il n'y a pas de fonction intégrée comme Oracle's Greatest , mais vous pouvez obtenir un résultat similaire pour 2 colonnes avec un UDF, notez que l'utilisation de sql_variant est assez importante ici.

create table #t (a int, b int) 

insert #t
select 1,2 union all 
select 3,4 union all
select 5,2

-- option 1 - A case statement
select case when a > b then a else b end
from #t

-- option 2 - A union statement 
select a from #t where a >= b 
union all 
select b from #t where b > a 

-- option 3 - A udf
create function dbo.GREATEST
( 
    @a as sql_variant,
    @b as sql_variant
)
returns sql_variant
begin   
    declare @max sql_variant 
    if @a is null or @b is null return null
    if @b > @a return @b  
    return @a 
end


select dbo.GREATEST(a,b)
from #t

kristof

Publié cette réponse:

create table #t (id int IDENTITY(1,1), a int, b int)
insert #t
select 1,2 union all
select 3,4 union all
select 5,2

select id, max(val)
from #t
    unpivot (val for col in (a, b)) as unpvt
group by id

Voici un exemple de cas qui devrait gérer les valeurs nulles et fonctionnera avec les anciennes versions de MSSQL. Ceci est basé sur la fonction inline dans l'un des exemples populaires:

case
  when a >= b then a
  else isnull(b,a)
end

Je ne le ferais probablement pas de cette façon, car il est moins efficace que les constructions CASE déjà mentionnées - sauf si, peut-être, vous aviez des index de couverture pour les deux requêtes. Quoi qu'il en soit, c'est une technique utile pour des problèmes similaires:

SELECT OrderId, MAX(Price) as Price FROM (
   SELECT o.OrderId, o.NegotiatedPrice as Price FROM Order o
   UNION ALL
   SELECT o.OrderId, o.SuggestedPrice as Price FROM Order o
) as A
GROUP BY OrderId

Pour la réponse ci-dessus concernant les grands nombres, vous pouvez faire la multiplication avant l'addition / soustraction. C'est un peu plus volumineux mais ne nécessite aucun casting. (Je ne peux pas parler de vitesse mais je suppose que c'est toujours assez rapide)

SELECT 0,5 * ((@ val1 + @ val2) + ABS (@ val1 - @ val2))

Modifications apportées à

SELECT @ val1 * 0.5 + @ val2 * 0.5 + ABS (@ val1 * 0.5 - @ val2 * 0.5)

au moins une alternative si vous voulez éviter de lancer.

Voici une version IIF avec une gestion NULL (basée sur la réponse de Xin):

IIF(a IS NULL OR b IS NULL, ISNULL(a,b), IIF(a > b, a, b))

La logique est la suivante, si l'une des valeurs est NULL, retourne celle qui n'est pas NULL (si les deux sont NULL, un NULL est retourné). Sinon, renvoyez le plus grand.

La même chose peut être faite pour MIN.

IIF(a IS NULL OR b IS NULL, ISNULL(a,b), IIF(a < b, a, b))

Vous pouvez faire quelque chose comme ça:

select case when o.NegotiatedPrice > o.SuggestedPrice 
then o.NegotiatedPrice
else o.SuggestedPrice
end

SELECT o.OrderID
CASE WHEN o.NegotiatedPrice > o.SuggestedPrice THEN
 o.NegotiatedPrice
ELSE
 o.SuggestedPrice
END AS Price

CREATE FUNCTION [dbo].[fnMax] (@p1 INT, @p2 INT)
RETURNS INT
AS BEGIN

    DECLARE @Result INT

    SET @p2 = COALESCE(@p2, @p1)

    SELECT
        @Result = (
                   SELECT
                    CASE WHEN @p1 > @p2 THEN @p1
                         ELSE @p2
                    END
                  )

    RETURN @Result

END

Dans sa forme la plus simple ...

CREATE FUNCTION fnGreatestInt (@Int1 int, @Int2 int )
RETURNS int
AS
BEGIN

    IF @Int1 >= ISNULL(@Int2,@Int1)
        RETURN @Int1
    ELSE
        RETURN @Int2

    RETURN NULL --Never Hit

END

Pour SQL Server 2012:

SELECT 
    o.OrderId, 
    IIF( o.NegotiatedPrice >= o.SuggestedPrice,
         o.NegotiatedPrice, 
         ISNULL(o.SuggestedPrice, o.NegiatedPrice) 
    )
FROM 
    Order o

Voici la réponse de @Scott Langham avec une gestion NULL simple:

SELECT
      o.OrderId,
      CASE WHEN (o.NegotiatedPrice > o.SuggestedPrice OR o.SuggestedPrice IS NULL) 
         THEN o.NegotiatedPrice 
         ELSE o.SuggestedPrice
      END As MaxPrice
FROM Order o

select OrderId, (
    select max([Price]) from (
        select NegotiatedPrice [Price]
        union all
        select SuggestedPrice
    ) p
) from [Order]

 -- Simple way without "functions" or "IF" or "CASE"
 -- Query to select maximum value
 SELECT o.OrderId
  ,(SELECT MAX(v)
   FROM (VALUES (o.NegotiatedPrice), (o.SuggestedPrice)) AS value(v)) AS MaxValue
  FROM Order o;

En développant la réponse de Xin et en supposant que le type de valeur de comparaison est INT, cette approche fonctionne également:

SELECT IIF(ISNULL(@A, -2147483648) > ISNULL(@B, -2147483648), @A, @B)

Il s'agit d'un test complet avec des exemples de valeurs:

DECLARE @A AS INT
DECLARE @B AS INT

SELECT  @A = 2, @B = 1
SELECT  IIF(ISNULL(@A, -2147483648) > ISNULL(@B, -2147483648), @A, @B)
-- 2

SELECT  @A = 2, @B = 3
SELECT  IIF(ISNULL(@A, -2147483648) > ISNULL(@B, -2147483648), @A, @B)
-- 3

SELECT  @A = 2, @B = NULL
SELECT  IIF(ISNULL(@A, -2147483648) > ISNULL(@B, -2147483648), @A, @B)
-- 2    

SELECT  @A = NULL, @B = 1
SELECT  IIF(ISNULL(@A, -2147483648) > ISNULL(@B, -2147483648), @A, @B)
-- 1

Dans MemSQL, procédez comme suit:

-- DROP FUNCTION IF EXISTS InlineMax;
DELIMITER //
CREATE FUNCTION InlineMax(val1 INT, val2 INT) RETURNS INT AS
DECLARE
  val3 INT = 0;
BEGIN
 IF val1 > val2 THEN
   RETURN val1;
 ELSE
   RETURN val2;
 END IF; 
END //
DELIMITER ;

SELECT InlineMax(1,2) as test;

Dans Presto, vous pouvez utiliser

SELECT array_max(ARRAY[o.NegotiatedPrice, o.SuggestedPrice])