¿Existe una función Max en SQL Server que tome dos valores como Math.Max ​​en .NET?

Quiero escribir una consulta como esta:

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

Pero no es así como MAXfunciona la función, ¿verdad? Es una función agregada, por lo que espera un único parámetro y luego devuelve el MAX de todas las filas.

¿Alguien sabe cómo hacerlo a mi manera?

Tendría que hacer un User-Defined Functionsi desea tener una sintaxis similar a su ejemplo, pero podría hacer lo que quiere hacer, en línea, con bastante facilidad con una CASEdeclaración, como han dicho los demás.

El UDFpodría ser algo como esto:

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

... y lo llamarías así ...

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

Si está utilizando SQL Server 2008 (o superior), esta es la mejor solución:

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

Todo el crédito y los votos deben ir a la respuesta de Sven a una pregunta relacionada, "¿SQL MAX de varias columnas?"
Yo digo que es la " mejor respuesta " porque:

1. No requiere complicar su código con declaraciones UNION, PIVOT, UNPIVOT, UDF y CASE de larga duración.
2. No está plagado con el problema de manejar nulos, los maneja bien.
3. Es fácil cambiar el "MAX" por "MIN", "AVG" o "SUM". Puede usar cualquier función de agregado para encontrar el agregado en muchas columnas diferentes.
4. No está limitado a los nombres que utilicé (es decir, "Todos los precios" y "Precio"). Puede elegir sus propios nombres para que sea más fácil de leer y comprender para el próximo chico.
5. Puede encontrar múltiples agregados utilizando las tablas_de_productos de SQL Server 2008 de la siguiente manera:
   SELECCIONAR MÁXIMO (a), MÁX (b) DESDE (VALORES (1, 2), (3, 4), (5, 6), (7, 8), (9, 10)) COMO MyTable (a, b)

Se puede hacer en una línea:

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

Editar: si se trata de números muy grandes, tendrá que convertir las variables de valor en bigint para evitar un desbordamiento de enteros.

No lo creo. Quería esto el otro día. Lo más cerca que estuve fue:

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

¿Por qué no probar la función IIF (requiere SQL Server 2012 y posterior)

IIF(a>b, a, b)

Eso es.

(Sugerencia: tenga cuidado con cualquiera de los dos null, ya que el resultado a>bserá falso siempre que sea nulo. Así bserá el resultado en este caso)

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

Las otras respuestas son buenas, pero si tiene que preocuparse por tener valores NULL, es posible que desee esta 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

En SQL Server 2012 o superior, puede usar una combinación de IIFy ISNULL(o COALESCE) para obtener el máximo de 2 valores.
Incluso cuando 1 de ellos es NULL.

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

O si desea que devuelva 0 cuando ambos son NULL

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

Fragmento de ejemplo:

-- 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

Resultado:

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

Pero si uno necesita SUMAR múltiples valores?
Luego sugiero CRUZAR APLICAR a una agregación de los VALORES.
Esto también tiene el beneficio de que puede calcular otras cosas al mismo tiempo.

Ejemplo:

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

Las subconsultas pueden acceder a las columnas desde la consulta externa, por lo que puede utilizar este enfoque para utilizar agregados, como a MAXtravés de las columnas. (Probablemente sea más útil cuando haya una mayor cantidad de columnas involucradas)

;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 introducido IIF:

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

Se recomienda manejar NULLs cuando se usa IIF, ya que NULLa ambos lados de la suya boolean_expressionhará IIFque devuelva false_value(en lugar de NULL).

Yo iría con la solución provista por kcrumley. Solo modifíquelo ligeramente para manejar NULL

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

EDITAR Modificado después del comentario de Mark . Como señaló correctamente en la lógica de 3 valores x> NULL o x <NULL siempre debe devolver NULL. En otras palabras, resultado desconocido.

Es tan simple como esto:

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

Vaya, acabo de publicar un engaño de esta pregunta ...

La respuesta es que no hay una función integrada como Oracle's Greatest , pero puede lograr un resultado similar para 2 columnas con un UDF, tenga en cuenta que el uso de sql_variant es bastante importante aquí.

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

Publicado esta respuesta:

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

Aquí hay un ejemplo de caso que debería manejar nulos y funcionará con versiones anteriores de MSSQL. Esto se basa en la función en línea en uno de los ejemplos populares:

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

Probablemente no lo haría de esta manera, ya que es menos eficiente que las construcciones CASE ya mencionadas, a menos que, tal vez, haya tenido índices de cobertura para ambas consultas. De cualquier manera, es una técnica útil para problemas similares:

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

Para la respuesta anterior con respecto a los números grandes, puede hacer la multiplicación antes de la suma / resta. Es un poco más voluminoso pero no requiere yeso. (No puedo hablar por la velocidad, pero supongo que sigue siendo bastante rápido)

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

Cambios a

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

al menos una alternativa si quieres evitar el casting.

Aquí hay una versión IIF con manejo NULL (basado en la respuesta de Xin):

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

La lógica es la siguiente, si alguno de los valores es NULL, devuelve el que no es NULL (si ambos son NULL, se devuelve un NULL) De lo contrario, devuelva el mayor.

Lo mismo se puede hacer para MIN.

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

Puedes hacer algo como esto:

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

En su forma más 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

Para SQL Server 2012:

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

Aquí está la respuesta de @Scott Langham con un manejo simple de NULL:

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;

Ampliando la respuesta de Xin y suponiendo que el tipo de valor de comparación es INT, este enfoque también funciona:

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

Esta es una prueba completa con valores de ejemplo:

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

En MemSQL haga lo siguiente:

-- 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;

En Presto puedes usar use

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