SQL MAX di più colonne?
Come si restituisce 1 valore per riga del massimo di più colonne:
TableName
[Number, Date1, Date2, Date3, Cost]
Devo restituire qualcosa del genere:
[Number, Most_Recent_Date, Cost]
Query?
Bene, puoi usare l'istruzione CASE:
SELECT
CASE
WHEN Date1 >= Date2 AND Date1 >= Date3 THEN Date1
WHEN Date2 >= Date1 AND Date2 >= Date3 THEN Date2
WHEN Date3 >= Date1 AND Date3 >= Date2 THEN Date3
ELSE Date1
END AS MostRecentDate
[Per Microsoft SQL Server 2008 e versioni successive, si può prendere in considerazione la risposta più semplice di Sven di seguito.]
Ecco un'altra soluzione Nice per la funzionalità Max che utilizza T-SQL e SQL Server
SELECT [Other Fields],
(SELECT Max(v)
FROM (VALUES (date1), (date2), (date3),...) AS value(v)) as [MaxDate]
FROM [YourTableName]
Se stai usando MySQL, puoi usare
SELECT GREATEST(col1, col2 ...) FROM table
Ci sono altri 3 metodi in cui UNPIVOT (1) è il più veloce di gran lunga, seguito da Simulated Unpivot (3) che è molto più lento di (1) ma ancora più veloce di (2)
CREATE TABLE dates
(
number INT PRIMARY KEY ,
date1 DATETIME ,
date2 DATETIME ,
date3 DATETIME ,
cost INT
)
INSERT INTO dates
VALUES ( 1, '1/1/2008', '2/4/2008', '3/1/2008', 10 )
INSERT INTO dates
VALUES ( 2, '1/2/2008', '2/3/2008', '3/3/2008', 20 )
INSERT INTO dates
VALUES ( 3, '1/3/2008', '2/2/2008', '3/2/2008', 30 )
INSERT INTO dates
VALUES ( 4, '1/4/2008', '2/1/2008', '3/4/2008', 40 )
GO
Soluzione 1 (UNPIVOT)
SELECT number ,
MAX(dDate) maxDate ,
cost
FROM dates UNPIVOT ( dDate FOR nDate IN ( Date1, Date2,
Date3 ) ) as u
GROUP BY number ,
cost
GO
Soluzione 2 (interrogazione secondaria per riga)
SELECT number ,
( SELECT MAX(dDate) maxDate
FROM ( SELECT d.date1 AS dDate
UNION
SELECT d.date2
UNION
SELECT d.date3
) a
) MaxDate ,
Cost
FROM dates d
GO
Soluzione 3 (simulato UNPIVOT)
;WITH maxD
AS ( SELECT number ,
MAX(CASE rn
WHEN 1 THEN Date1
WHEN 2 THEN date2
ELSE date3
END) AS maxDate
FROM dates a
CROSS JOIN ( SELECT 1 AS rn
UNION
SELECT 2
UNION
SELECT 3
) b
GROUP BY Number
)
SELECT dates.number ,
maxD.maxDate ,
dates.cost
FROM dates
INNER JOIN MaxD ON dates.number = maxD.number
GO
DROP TABLE dates
GO
Uno dei due esempi seguenti funzionerà:
SELECT MAX(date_columns) AS max_date
FROM ( (SELECT date1 AS date_columns
FROM data_table )
UNION
( SELECT date2 AS date_columns
FROM data_table
)
UNION
( SELECT date3 AS date_columns
FROM data_table
)
) AS date_query
Il secondo è un add-on per lassevk's answer.
SELECT MAX(MostRecentDate)
FROM ( SELECT CASE WHEN date1 >= date2
AND date1 >= date3 THEN date1
WHEN date2 >= date1
AND date2 >= date3 THEN date2
WHEN date3 >= date1
AND date3 >= date2 THEN date3
ELSE date1
END AS MostRecentDate
FROM data_table
) AS date_query
La funzione scalare causa tutti i tipi di problemi di prestazioni, quindi è meglio avvolgere la logica in una funzione di valore in tabella, se possibile. Questa è la funzione che ho usato per sostituire alcune funzioni definite dall'utente che hanno selezionato le date Min/Max da un elenco di fino a dieci date. Quando è stato testato sul mio set di dati di 1 milione di righe, la funzione scalare impiegava più di 15 minuti prima che venissi uccisa la query che Inline TVF impiegava 1 minuto, ovvero la stessa quantità di tempo impostata per selezionare il set di risultati in una tabella temporanea. Per utilizzare questa chiamata la funzione da una sottoquery nella SELECT o in una CROSS APPLY.
CREATE FUNCTION dbo.Get_Min_Max_Date
(
@Date1 datetime,
@Date2 datetime,
@Date3 datetime,
@Date4 datetime,
@Date5 datetime,
@Date6 datetime,
@Date7 datetime,
@Date8 datetime,
@Date9 datetime,
@Date10 datetime
)
RETURNS TABLE
AS
RETURN
(
SELECT Max(DateValue) Max_Date,
Min(DateValue) Min_Date
FROM (
VALUES (@Date1),
(@Date2),
(@Date3),
(@Date4),
(@Date5),
(@Date6),
(@Date7),
(@Date8),
(@Date9),
(@Date10)
) AS Dates(DateValue)
)
DECLARE @TableName TABLE (Number INT, Date1 DATETIME, Date2 DATETIME, Date3 DATETIME, Cost MONEY)
INSERT INTO @TableName
SELECT 1, '20000101', '20010101','20020101',100 UNION ALL
SELECT 2, '20000101', '19900101','19980101',99
SELECT Number,
Cost ,
(SELECT MAX([Date])
FROM (SELECT Date1 AS [Date]
UNION ALL
SELECT Date2
UNION ALL
SELECT Date3
)
D
)
[Most Recent Date]
FROM @TableName
Per T-SQL (MSSQL 2008+)
SELECT
(SELECT
MAX(MyMaxName)
FROM ( VALUES
(MAX(iSortCode)),
(MAX(Field2))
) MyAlias(MyMaxName)
)
FROM MyTable1
SELECT
CASE
WHEN Date1 >= Date2 AND Date1 >= Date3 THEN Date1
WHEN Date2 >= Date3 THEN Date2
ELSE Date3
END AS MostRecentDate
Questo è leggermente più semplice da scrivere e salta i passaggi di valutazione quando l'istruzione case viene valutata in ordine.
Purtroppo La risposta di Lasse , anche se apparentemente ovvia, ha un difetto cruciale. Non può gestire valori NULL. Qualsiasi singolo valore NULL restituisce Data1 restituita. Sfortunatamente qualsiasi tentativo di risolvere questo problema tende a diventare estremamente disordinato e non si adatta a 4 o più valori molto bene.
prima risposta del databyss guardato (ed è) buono. Tuttavia, non era chiaro se la risposta avrebbe facilmente estrapolato a 3 valori da un join multi-table invece dei più semplici 3 valori da una singola tabella. Volevo evitare di trasformare una query di questo tipo in una sottoquery solo per ottenere il massimo di 3 colonne, inoltre ero abbastanza sicuro che l'eccellente idea di un databys potrebbe essere ripulita un po '.
Quindi, senza ulteriori indugi, ecco la mia soluzione (derivata dall'idea dei databys).
Utilizza cross-joins selezionando le costanti per simulare l'effetto di un join multi-table. La cosa importante da notare è che tutti gli alias necessari vengono eseguiti correttamente (il che non è sempre il caso) e ciò mantiene il pattern abbastanza semplice e abbastanza scalabile attraverso colonne aggiuntive.
DECLARE @v1 INT ,
@v2 INT ,
@v3 INT
--SET @v1 = 1 --Comment out SET statements to experiment with
--various combinations of NULL values
SET @v2 = 2
SET @v3 = 3
SELECT ( SELECT MAX(Vals)
FROM ( SELECT v1 AS Vals
UNION
SELECT v2
UNION
SELECT v3
) tmp
WHERE Vals IS NOT NULL -- This eliminates NULL warning
) AS MaxVal
FROM ( SELECT @v1 AS v1
) t1
CROSS JOIN ( SELECT @v2 AS v2
) t2
CROSS JOIN ( SELECT @v3 AS v3
) t3
Problema: scegli il valore minimo della tariffa assegnato a un'entità Requisiti: i tassi di agenzia possono essere nulli
[MinRateValue] =
CASE
WHEN ISNULL(FitchRating.RatingValue, 100) < = ISNULL(MoodyRating.RatingValue, 99)
AND ISNULL(FitchRating.RatingValue, 100) < = ISNULL(StandardPoorsRating.RatingValue, 99)
THEN FitchgAgency.RatingAgencyName
WHEN ISNULL(MoodyRating.RatingValue, 100) < = ISNULL(StandardPoorsRating.RatingValue , 99)
THEN MoodyAgency.RatingAgencyName
ELSE ISNULL(StandardPoorsRating.RatingValue, 'N/A')
END
Ispirato da questa risposta from Nat
Utilizzando CROSS APPLY (per 2005+) ....
SELECT MostRecentDate
FROM SourceTable
CROSS APPLY (SELECT MAX(d) MostRecentDate FROM (VALUES (Date1), (Date2), (Date3)) AS a(d)) md
Da SQL Server 2012 possiamo usare IIF .
DECLARE @Date1 DATE='2014-07-03';
DECLARE @Date2 DATE='2014-07-04';
DECLARE @Date3 DATE='2014-07-05';
SELECT IIF(@Date1>@Date2,
IIF(@Date1>@Date3,@Date1,@Date3),
IIF(@Date2>@Date3,@Date2,@Date3)) AS MostRecentDate
Se si utilizza SQL Server 2005, è possibile utilizzare la funzione UNPIVOT. Ecco un esempio completo:
create table dates
(
number int,
date1 datetime,
date2 datetime,
date3 datetime
)
insert into dates values (1, '1/1/2008', '2/4/2008', '3/1/2008')
insert into dates values (1, '1/2/2008', '2/3/2008', '3/3/2008')
insert into dates values (1, '1/3/2008', '2/2/2008', '3/2/2008')
insert into dates values (1, '1/4/2008', '2/1/2008', '3/4/2008')
select max(dateMaxes)
from (
select
(select max(date1) from dates) date1max,
(select max(date2) from dates) date2max,
(select max(date3) from dates) date3max
) myTable
unpivot (dateMaxes For fieldName In (date1max, date2max, date3max)) as tblPivot
drop table dates
Si prega di provare a utilizzare UNPIVOT:
SELECT MAX(MaxDt) MaxDt
FROM tbl
UNPIVOT
(MaxDt FOR E IN
(Date1, Date2, Date3)
)AS unpvt;
Preferisco le soluzioni basate sul caso-quando, il mio presupposto è che dovrebbe avere il minimo impatto sulla possibile caduta delle prestazioni rispetto ad altre possibili soluzioni come quelle con cross-apply, valori (), funzioni personalizzate, ecc.
Ecco il caso: quando la versione gestisce i valori nulli con la maggior parte dei possibili casi di test:
SELECT
CASE
WHEN Date1 > coalesce(Date2,'0001-01-01') AND Date1 > coalesce(Date3,'0001-01-01') THEN Date1
WHEN Date2 > coalesce(Date3,'0001-01-01') THEN Date2
ELSE Date3
END AS MostRecentDate
, *
from
(values
( 1, cast('2001-01-01' as Date), cast('2002-01-01' as Date), cast('2003-01-01' as Date))
,( 2, cast('2001-01-01' as Date), cast('2003-01-01' as Date), cast('2002-01-01' as Date))
,( 3, cast('2002-01-01' as Date), cast('2001-01-01' as Date), cast('2003-01-01' as Date))
,( 4, cast('2002-01-01' as Date), cast('2003-01-01' as Date), cast('2001-01-01' as Date))
,( 5, cast('2003-01-01' as Date), cast('2001-01-01' as Date), cast('2002-01-01' as Date))
,( 6, cast('2003-01-01' as Date), cast('2002-01-01' as Date), cast('2001-01-01' as Date))
,( 11, cast(NULL as Date), cast('2002-01-01' as Date), cast('2003-01-01' as Date))
,( 12, cast(NULL as Date), cast('2003-01-01' as Date), cast('2002-01-01' as Date))
,( 13, cast('2003-01-01' as Date), cast(NULL as Date), cast('2002-01-01' as Date))
,( 14, cast('2002-01-01' as Date), cast(NULL as Date), cast('2003-01-01' as Date))
,( 15, cast('2003-01-01' as Date), cast('2002-01-01' as Date), cast(NULL as Date))
,( 16, cast('2002-01-01' as Date), cast('2003-01-01' as Date), cast(NULL as Date))
,( 21, cast('2003-01-01' as Date), cast(NULL as Date), cast(NULL as Date))
,( 22, cast(NULL as Date), cast('2003-01-01' as Date), cast(NULL as Date))
,( 23, cast(NULL as Date), cast(NULL as Date), cast('2003-01-01' as Date))
,( 31, cast(NULL as Date), cast(NULL as Date), cast(NULL as Date))
) as demoValues(id, Date1,Date2,Date3)
order by id
;
e il risultato è:
MostRecent id Date1 Date2 Date3
2003-01-01 1 2001-01-01 2002-01-01 2003-01-01
2003-01-01 2 2001-01-01 2003-01-01 2002-01-01
2003-01-01 3 2002-01-01 2001-01-01 2002-01-01
2003-01-01 4 2002-01-01 2003-01-01 2001-01-01
2003-01-01 5 2003-01-01 2001-01-01 2002-01-01
2003-01-01 6 2003-01-01 2002-01-01 2001-01-01
2003-01-01 11 NULL 2002-01-01 2003-01-01
2003-01-01 12 NULL 2003-01-01 2002-01-01
2003-01-01 13 2003-01-01 NULL 2002-01-01
2003-01-01 14 2002-01-01 NULL 2003-01-01
2003-01-01 15 2003-01-01 2002-01-01 NULL
2003-01-01 16 2002-01-01 2003-01-01 NULL
2003-01-01 21 2003-01-01 NULL NULL
2003-01-01 22 NULL 2003-01-01 NULL
2003-01-01 23 NULL NULL 2003-01-01
NULL 31 NULL NULL NULL
Un altro modo di usare CASE WHEN
SELECT CASE true
WHEN max(row1) >= max(row2) THEN CASE true WHEN max(row1) >= max(row3) THEN max(row1) ELSE max(row3) end ELSE
CASE true WHEN max(row2) >= max(row3) THEN max(row2) ELSE max(row3) END END
FROM yourTable
Basato sulla soluzione ScottPletcher di http://www.experts-exchange.com/Microsoft/Development/MS-SQL-Server/Q_24204894.html Ho creato un set di funzioni (ad esempio GetMaxOfDates3, GetMaxOfDates13) per trovare fino a 13 valori di data utilizzando UNION ALL . Vedere Funzione T-SQL per ottenere il massimo di valori dalla stessa riga Tuttavia non l'ho considerata la soluzione UNPIVOT al momento della stesura di queste funzioni
È possibile creare una funzione in cui si passano le date e quindi aggiungere la funzione all'istruzione select come di seguito . Selezionare Number, dbo.fxMost_Recent_Date (Date1, Date2, Date3), Cost
create FUNCTION fxMost_Recent_Date
( @ Date1 smalldatetime, @ Date2 smalldatetime, @ Date3 smalldatetime ) RETURNS smalldatetime AS BEGIN DICHIARARE @Result smalldatetime
declare @MostRecent smalldatetime
set @MostRecent='1/1/1900'
if @Date1>@MostRecent begin set @[email protected] end
if @Date2>@MostRecent begin set @[email protected] end
if @Date3>@MostRecent begin set @[email protected] end
RETURN @MostRecent
FINE