SQL Server'da .NET'te Math.Max ​​gibi iki değer alan bir Max işlevi var mı?

Ben böyle bir sorgu yazmak istiyorum:

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

Fakat MAXfonksiyon bu şekilde çalışmaz , değil mi? Birleştirilmiş bir işlevdir, bu nedenle tek bir parametre bekler ve sonra tüm satırların MAX değerini döndürür.

Bunu nasıl yapacağımı bilen var mı?

User-Defined FunctionÖrneğinize benzer bir sözdizimine sahip olmak istiyorsanız bir yapmanız gerekir , ancak yapmak istediğiniz şeyi bir satırda, birCASE diğerleri söylediler, deyimi.

Bunun UDFgibi bir şey olabilir:

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

... ve öyle diyeceksin ...

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

SQL Server 2008 (veya üstü) kullanıyorsanız, bu daha iyi bir çözümdür:

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

Tüm kredi ve oylar, Sven'in "Birden fazla sütunun SQL MAX?" Sorusuna verdiği cevaba gitmelidir.
" En iyi cevap " diyorum çünkü:

1. Kodunuzu UNION'lar, PIVOT'lar, UNPIVOT'lar, UDF'ler ve çılgınca uzun CASE ifadeleriyle karmaşıklaştırmanız gerekmez.
2. Null'ları ele alma sorunu ile uğraşmaz, onları iyi işler.
3. "MAX" ile "MIN", "AVG" veya "SUM" arasında geçiş yapmak kolaydır. Bir çok farklı sütun üzerindeki toplamı bulmak için herhangi bir toplama işlevini kullanabilirsiniz.
4. Kullandığım isimlerle sınırlı değilsiniz (örn. "AllPrices" ve "Fiyat"). Bir sonraki adam için okumayı ve anlamayı kolaylaştırmak için kendi adlarınızı seçebilirsiniz.
5. SQL Server 2008'in türetilmiş tablolarını kullanarak birden çok toplama bulabilirsiniz :
   SELECT MAX (a), MAX (b) FROM (DEĞERLER (1, 2), (3, 4), (5, 6), (7, 8), (9, 10)) ASTable'ınız (a, b)

Tek satırda yapılabilir:

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

Düzenle: Çok büyük sayılarla uğraşıyorsanız, tamsayı taşmasını önlemek için değer değişkenlerini bigint'e dönüştürmeniz gerekir.

Ben öyle düşünmüyorum. Geçen gün bunu istedim. Aldığım en yakın şey:

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

Neden IIF işlevini denemiyorsunuz (SQL Server 2012 ve üstü gerekir)

IIF(a>b, a, b)

Bu kadar.

(İpucu: her ikisine de dikkat edin null, çünkü a>bher ikisi de null olduğunda yanlış bolur. Bu durumda sonuç olacaktır)

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

Diğer cevaplar iyidir, ancak NULL değerlere sahip olmak konusunda endişelenmeniz gerekiyorsa, bu varyantı isteyebilirsiniz:

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

SQL Server 2012 veya sonraki sürümlerde, en fazla 2 değeri elde etmek için IIFve ISNULL(veya COALESCE) birleşimlerini kullanabilirsiniz .
1 tanesi NULL olsa bile.

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

Veya her ikisi de NULL olduğunda 0 döndürmesini istiyorsanız

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

Örnek pasaj:

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

Sonuç:

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

Ama eğer birden fazla değeri TOPLAMALARI gerekiyorsa?
Daha sonra DEĞERLERİN bir araya gelmesi için ÇAPRAZ UYGULAMASI öneririm.
Bu aynı zamanda diğer şeyleri aynı anda hesaplayabilmesi avantajına da sahiptir.

Misal:

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

Alt Sorgular, Dış sorgudan sütunlara erişebilir, böylece bu yaklaşımıMAX sütunlar arası gibi toplamalar kullanmak için kullanabilirsiniz . (Bununla birlikte, daha fazla sayıda sütun olduğunda muhtemelen daha yararlıdır)

;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 tanıtıldı IIF:

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

Kullanırken NULL'ların kullanılması önerilir IIF , çünkü NULLher iki tarafınızdaki a , (aksine ) döndürmeye boolean_expressionneden olur .IIFfalse_valueNULL

Ben kcrumley tarafından sağlanan çözüm ile gitmek istiyorum Sadece NULLs işlemek için biraz değiştirin

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 Mark'ın yorumundan sonra değiştirildi . 3 değerli mantıkta doğru bir şekilde işaret ettiği gibi x> NULL veya x <NULL her zaman NULL döndürmelidir. Başka bir deyişle bilinmeyen sonuç.

Bu kadar basit:

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

Hata! Bu sorunun bir çiftini yayınladım ...

Cevap, Oracle'ın Greatest gibi yerleşik bir işlevi yoktur , ancak bir UDF ile 2 sütun için benzer bir sonuç elde edebilirsiniz, not, sql_variant kullanımı burada oldukça önemlidir.

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

Bu yanıtı gönderdi:

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

Burada null değerlerini işleyecek ve MSSQL'in eski sürümleriyle çalışacak bir örnek. Bu, popüler örneklerden birinde satır içi işleve dayanmaktadır:

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

Muhtemelen, bu şekilde yapmazdım, çünkü daha önce bahsedilen CASE yapılarından daha az verimlidir - belki de, her iki sorgu için de dizin oluşturmadığınız sürece. Her iki durumda da, benzer problemler için yararlı bir tekniktir:

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

Büyük sayılarla ilgili yukarıdaki cevap için, toplama / çıkarma işleminden önce çarpmayı yapabilirsiniz. Biraz daha hantal ama döküm gerektirmiyor. (Hız için konuşamam ama yine de oldukça hızlı olduğunu düşünüyorum)

SEÇ 0.5 * ((@ val1 + @ val2) + ABS (@ val1 - @ val2))

Değişiklikleri

SEÇ @ val1 * 0.5 + @ val2 * 0.5 + ABS (@ val1 * 0.5 - @ val2 * 0.5)

dökümden kaçınmak istiyorsanız en azından bir alternatif.

İşte NULL işlemeli bir IIF sürümü (Xin'in cevabına dayanarak):

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

Mantık aşağıdaki gibidir, değerlerden biri NULL ise, NULL olmayanı döndürür (her ikisi de NULL ise, NULL döndürülür). Aksi takdirde büyük olanı iade edin.

Aynı şey MIN için de yapılabilir.

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

Bunun gibi bir şey yapabilirsiniz:

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 basit haliyle ...

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

SQL Server 2012 için:

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

İşte @Scott Langham'ın basit NULL kullanımıyla yanıtı:

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;

Xin'in cevabına genişleyerek ve karşılaştırma değeri türünün INT olduğunu varsayarsak, bu yaklaşım da işe yarar:

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

Bu, örnek değerlerle dolu bir testtir:

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

MemSQL'de aşağıdakileri yapın:

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

Presto'da şunu kullanabilirsiniz:

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