Fonction pour calculer la médiane dans SQL Server
Selon MSDN , Median n'est pas disponible en tant que fonction d'agrégat dans Transact-SQL. Toutefois, j'aimerais savoir s'il est possible de créer cette fonctionnalité (à l'aide de la fonction Create Aggregate , d'une fonction définie par l'utilisateur ou d'une autre méthode).
Quel serait le meilleur moyen (si possible) de le faire - permettre le calcul d'une valeur médiane (en supposant un type de données numérique) dans une requête agrégée?
Il existe de nombreuses façons de le faire, avec des performances très différentes. Voici une solution particulièrement bien optimisée, de Medians, ROW_NUMBERs et performance. Cette solution est particulièrement optimale en ce qui concerne les E/S générées au cours de l'exécution. Elle semble plus coûteuse que d'autres solutions, mais elle est en réalité beaucoup plus rapide.
Cette page contient également une discussion sur d'autres solutions et détails de test de performance. Notez l’utilisation d’une colonne unique comme homonymie au cas où il y aurait plusieurs lignes avec la même valeur que la colonne médiane.
Comme pour tous les scénarios de performances de base de données, essayez toujours de tester une solution avec des données réelles sur du matériel réel - vous ne savez jamais quand un changement d'optimiseur de SQL Server ou une particularité de votre environnement ralentiront une solution normalement rapide.
SELECT
CustomerId,
AVG(TotalDue)
FROM
(
SELECT
CustomerId,
TotalDue,
-- SalesOrderId in the ORDER BY is a disambiguator to break ties
ROW_NUMBER() OVER (
PARTITION BY CustomerId
ORDER BY TotalDue ASC, SalesOrderId ASC) AS RowAsc,
ROW_NUMBER() OVER (
PARTITION BY CustomerId
ORDER BY TotalDue DESC, SalesOrderId DESC) AS RowDesc
FROM Sales.SalesOrderHeader SOH
) x
WHERE
RowAsc IN (RowDesc, RowDesc - 1, RowDesc + 1)
GROUP BY CustomerId
ORDER BY CustomerId;
Si vous utilisez SQL 2005 ou une version ultérieure, il s'agit d'un calcul de Nice, simple et médian pour une seule colonne dans un tableau:
SELECT
(
(SELECT MAX(Score) FROM
(SELECT TOP 50 PERCENT Score FROM Posts ORDER BY Score) AS BottomHalf)
+
(SELECT MIN(Score) FROM
(SELECT TOP 50 PERCENT Score FROM Posts ORDER BY Score DESC) AS TopHalf)
) / 2 AS Median
Dans SQL Server 2012, vous devez utiliser PERCENTILE_CONT :
SELECT SalesOrderID, OrderQty,
PERCENTILE_CONT(0.5)
WITHIN GROUP (ORDER BY OrderQty)
OVER (PARTITION BY SalesOrderID) AS MedianCont
FROM Sales.SalesOrderDetail
WHERE SalesOrderID IN (43670, 43669, 43667, 43663)
ORDER BY SalesOrderID DESC
Ma réponse rapide d'origine était:
select max(my_column) as [my_column], quartile
from (select my_column, ntile(4) over (order by my_column) as [quartile]
from my_table) i
--where quartile = 2
group by quartile
Cela vous donnera la médiane et l'intervalle interquartile d'un seul coup. Si vous ne voulez vraiment que la médiane d’une ligne, décommentez la clause where.
Lorsque vous en tenez compte dans un plan explicatif, 60% du travail consiste à trier les données, ce qui est inévitable lors du calcul de statistiques dépendant de la position comme celle-ci.
J'ai modifié la réponse pour suivre l'excellente suggestion de Robert Ševčík-Robajz dans les commentaires ci-dessous:
;with PartitionedData as
(select my_column, ntile(10) over (order by my_column) as [percentile]
from my_table),
MinimaAndMaxima as
(select min(my_column) as [low], max(my_column) as [high], percentile
from PartitionedData
group by percentile)
select
case
when b.percentile = 10 then cast(b.high as decimal(18,2))
else cast((a.low + b.high) as decimal(18,2)) / 2
end as [value], --b.high, a.low,
b.percentile
from MinimaAndMaxima a
join MinimaAndMaxima b on (a.percentile -1 = b.percentile) or (a.percentile = 10 and b.percentile = 10)
--where b.percentile = 5
Cela devrait permettre de calculer les valeurs correctes de la médiane et du centile lorsque vous avez un nombre pair d'éléments de données. Encore une fois, supprimez la mise en commentaire de la clause finale où vous ne voulez que la médiane et non la distribution entière des centiles.
Encore mieux:
SELECT @Median = AVG(1.0 * val)
FROM
(
SELECT o.val, rn = ROW_NUMBER() OVER (ORDER BY o.val), c.c
FROM dbo.EvenRows AS o
CROSS JOIN (SELECT c = COUNT(*) FROM dbo.EvenRows) AS c
) AS x
WHERE rn IN ((c + 1)/2, (c + 2)/2);
Du maître lui-même, Itzik Ben-Gan !
MS SQL Server 2012 (et versions ultérieures) comporte la fonction PERCENTILE_DISC qui calcule un centile spécifique pour les valeurs triées. PERCENTILE_DISC (0.5) calculera la médiane - https://msdn.Microsoft.com/en-us/library/hh231327.aspx
Si vous souhaitez utiliser la fonction Créer un agrégat dans SQL Server, procédez comme suit. Le faire de cette façon présente l’avantage de pouvoir écrire des requêtes propres. Notez que ce processus peut être adapté pour calculer une valeur de centile assez facilement.
Créez un nouveau projet Visual Studio et définissez le framework cible sur .NET 3.5 (pour SQL 2008, il peut être différent dans SQL 2012). Créez ensuite un fichier de classe et insérez le code suivant ou son équivalent en c #:
Imports Microsoft.SqlServer.Server
Imports System.Data.SqlTypes
Imports System.IO
<Serializable>
<SqlUserDefinedAggregate(Format.UserDefined, IsInvariantToNulls:=True, IsInvariantToDuplicates:=False, _
IsInvariantToOrder:=True, MaxByteSize:=-1, IsNullIfEmpty:=True)>
Public Class Median
Implements IBinarySerialize
Private _items As List(Of Decimal)
Public Sub Init()
_items = New List(Of Decimal)()
End Sub
Public Sub Accumulate(value As SqlDecimal)
If Not value.IsNull Then
_items.Add(value.Value)
End If
End Sub
Public Sub Merge(other As Median)
If other._items IsNot Nothing Then
_items.AddRange(other._items)
End If
End Sub
Public Function Terminate() As SqlDecimal
If _items.Count <> 0 Then
Dim result As Decimal
_items = _items.OrderBy(Function(i) i).ToList()
If _items.Count Mod 2 = 0 Then
result = ((_items((_items.Count / 2) - 1)) + (_items(_items.Count / 2))) / 2@
Else
result = _items((_items.Count - 1) / 2)
End If
Return New SqlDecimal(result)
Else
Return New SqlDecimal()
End If
End Function
Public Sub Read(r As BinaryReader) Implements IBinarySerialize.Read
'deserialize it from a string
Dim list = r.ReadString()
_items = New List(Of Decimal)
For Each value In list.Split(","c)
Dim number As Decimal
If Decimal.TryParse(value, number) Then
_items.Add(number)
End If
Next
End Sub
Public Sub Write(w As BinaryWriter) Implements IBinarySerialize.Write
'serialize the list to a string
Dim list = ""
For Each item In _items
If list <> "" Then
list += ","
End If
list += item.ToString()
Next
w.Write(list)
End Sub
End Class
Ensuite, compilez-le et copiez le fichier DLL et le fichier PDB sur votre ordinateur SQL Server, puis exécutez la commande suivante dans SQL Server:
CREATE Assembly CustomAggregate FROM '{path to your DLL}'
WITH PERMISSION_SET=SAFE;
GO
CREATE AGGREGATE Median(@value decimal(9, 3))
RETURNS decimal(9, 3)
EXTERNAL NAME [CustomAggregate].[{namespace of your DLL}.Median];
GO
Vous pouvez ensuite écrire une requête pour calculer la médiane de la manière suivante: SELECT dbo.Median (Champ) FROM Table
Simple, rapide, précis
SELECT x.Amount
FROM (SELECT amount,
Count(1) OVER (partition BY 'A') AS TotalRows,
Row_number() OVER (ORDER BY Amount ASC) AS AmountOrder
FROM facttransaction ft) x
WHERE x.AmountOrder = Round(x.TotalRows / 2.0, 0)
La requête suivante renvoie le médian à partir d'une liste de valeurs dans une colonne. Il ne peut pas être utilisé avec ou avec une fonction d'agrégat, mais vous pouvez toujours l'utiliser comme sous-requête avec une clause WHERE dans la sélection interne.
SQL Server 2005+:
SELECT TOP 1 value from
(
SELECT TOP 50 PERCENT value
FROM table_name
ORDER BY value
)for_median
ORDER BY value DESC
Je viens de tomber sur cette page en cherchant une solution basée sur la médiane. Après avoir examiné certaines des solutions ici, je suis venu avec ce qui suit. L'espoir est aide/fonctionne.
DECLARE @test TABLE(
i int identity(1,1),
id int,
score float
)
INSERT INTO @test (id,score) VALUES (1,10)
INSERT INTO @test (id,score) VALUES (1,11)
INSERT INTO @test (id,score) VALUES (1,15)
INSERT INTO @test (id,score) VALUES (1,19)
INSERT INTO @test (id,score) VALUES (1,20)
INSERT INTO @test (id,score) VALUES (2,20)
INSERT INTO @test (id,score) VALUES (2,21)
INSERT INTO @test (id,score) VALUES (2,25)
INSERT INTO @test (id,score) VALUES (2,29)
INSERT INTO @test (id,score) VALUES (2,30)
INSERT INTO @test (id,score) VALUES (3,20)
INSERT INTO @test (id,score) VALUES (3,21)
INSERT INTO @test (id,score) VALUES (3,25)
INSERT INTO @test (id,score) VALUES (3,29)
DECLARE @counts TABLE(
id int,
cnt int
)
INSERT INTO @counts (
id,
cnt
)
SELECT
id,
COUNT(*)
FROM
@test
GROUP BY
id
SELECT
drv.id,
drv.start,
AVG(t.score)
FROM
(
SELECT
MIN(t.i)-1 AS start,
t.id
FROM
@test t
GROUP BY
t.id
) drv
INNER JOIN @test t ON drv.id = t.id
INNER JOIN @counts c ON t.id = c.id
WHERE
t.i = ((c.cnt+1)/2)+drv.start
OR (
t.i = (((c.cnt+1)%2) * ((c.cnt+2)/2))+drv.start
AND ((c.cnt+1)%2) * ((c.cnt+2)/2) <> 0
)
GROUP BY
drv.id,
drv.start
Bien que la solution proposée par Justin Grant semble solide, j’ai constaté que lorsque vous avez plusieurs valeurs en double dans une clé de partition donnée, les numéros de ligne des valeurs en double ASC finissent par s’arrêter dans l’ordre et ne s’alignent donc pas correctement.
Voici un fragment de mon résultat:
KEY VALUE ROWA ROWD
13 2 22 182
13 1 6 183
13 1 7 184
13 1 8 185
13 1 9 186
13 1 10 187
13 1 11 188
13 1 12 189
13 0 1 190
13 0 2 191
13 0 3 192
13 0 4 193
13 0 5 194
J'ai utilisé le code de Justin comme base de cette solution. Bien que moins efficace compte tenu de l'utilisation de plusieurs tables dérivées, il résout le problème de classement des lignes que j'ai rencontré. Toute amélioration serait la bienvenue car je ne suis pas expérimenté dans T-SQL.
SELECT PKEY, cast(AVG(VALUE)as decimal(5,2)) as MEDIANVALUE
FROM
(
SELECT PKEY,VALUE,ROWA,ROWD,
'FLAG' = (CASE WHEN ROWA IN (ROWD,ROWD-1,ROWD+1) THEN 1 ELSE 0 END)
FROM
(
SELECT
PKEY,
cast(VALUE as decimal(5,2)) as VALUE,
ROWA,
ROW_NUMBER() OVER (PARTITION BY PKEY ORDER BY ROWA DESC) as ROWD
FROM
(
SELECT
PKEY,
VALUE,
ROW_NUMBER() OVER (PARTITION BY PKEY ORDER BY VALUE ASC,PKEY ASC ) as ROWA
FROM [MTEST]
)T1
)T2
)T3
WHERE FLAG = '1'
GROUP BY PKEY
ORDER BY PKEY
L'exemple de Justin ci-dessus est très bon. Mais ce besoin de clé primaire doit être énoncé très clairement. J'ai vu ce code dans la nature sans la clé et les résultats sont mauvais.
Le reproche que je reçois à propos de Percentile_Cont est qu'il ne vous donnera pas de valeur réelle à partir du jeu de données . Pour obtenir une "médiane" qui est une valeur réelle à partir du jeu de données, utilisez Percentile_Disc.
SELECT SalesOrderID, OrderQty,
PERCENTILE_DISC(0.5)
WITHIN GROUP (ORDER BY OrderQty)
OVER (PARTITION BY SalesOrderID) AS MedianCont
FROM Sales.SalesOrderDetail
WHERE SalesOrderID IN (43670, 43669, 43667, 43663)
ORDER BY SalesOrderID DESC
Dans un fichier UDF, écrivez:
Select Top 1 medianSortColumn from Table T
Where (Select Count(*) from Table
Where MedianSortColumn <
(Select Count(*) From Table) / 2)
Order By medianSortColumn
Pour une variable/mesure continue 'col1' à partir de 'table1'
select col1
from
(select top 50 percent col1,
ROW_NUMBER() OVER(ORDER BY col1 ASC) AS Rowa,
ROW_NUMBER() OVER(ORDER BY col1 DESC) AS Rowd
from table1 ) tmp
where tmp.Rowa = tmp.Rowd
Voir les autres solutions pour le calcul de la médiane en SQL ici: " Méthode simple pour calculer la médiane avec MySQL " (les solutions sont généralement indépendantes du fournisseur).
J'essaie avec plusieurs alternatives, mais comme mes enregistrements de données ont des valeurs répétées, les versions de ROW_NUMBER ne semblent pas être un choix pour moi. Alors voici la requête que j'ai utilisée (une version avec NTILE):
SELECT distinct
CustomerId,
(
MAX(CASE WHEN Percent50_Asc=1 THEN TotalDue END) OVER (PARTITION BY CustomerId) +
MIN(CASE WHEN Percent50_desc=1 THEN TotalDue END) OVER (PARTITION BY CustomerId)
)/2 MEDIAN
FROM
(
SELECT
CustomerId,
TotalDue,
NTILE(2) OVER (
PARTITION BY CustomerId
ORDER BY TotalDue ASC) AS Percent50_Asc,
NTILE(2) OVER (
PARTITION BY CustomerId
ORDER BY TotalDue DESC) AS Percent50_desc
FROM Sales.SalesOrderHeader SOH
) x
ORDER BY CustomerId;
C’est la solution la plus optimale pour trouver des médianes à laquelle je peux penser. Les noms dans l'exemple sont basés sur l'exemple de Justin. Assurez-vous qu'un index pour la table Sales.SalesOrderHeader existe avec les colonnes d'index CustomerId et TotalDue dans cet ordre.
SELECT
sohCount.CustomerId,
AVG(sohMid.TotalDue) as TotalDueMedian
FROM
(SELECT
soh.CustomerId,
COUNT(*) as NumberOfRows
FROM
Sales.SalesOrderHeader soh
GROUP BY soh.CustomerId) As sohCount
CROSS APPLY
(Select
soh.TotalDue
FROM
Sales.SalesOrderHeader soh
WHERE soh.CustomerId = sohCount.CustomerId
ORDER BY soh.TotalDue
OFFSET sohCount.NumberOfRows / 2 - ((sohCount.NumberOfRows + 1) % 2) ROWS
FETCH NEXT 1 + ((sohCount.NumberOfRows + 1) % 2) ROWS ONLY
) As sohMid
GROUP BY sohCount.CustomerId
METTRE &AGRAVE; JOUR
Je ne savais pas trop quelle méthode donnait les meilleures performances. J'ai donc comparé ma méthode Justin Grants à Jeff Atwoods en exécutant une requête basée sur les trois méthodes d'un lot et le coût de chaque requête était le suivant:
Sans index:
- Mine 30%
- Justin accorde 13%
- Jeff Atwoods 58%
Et avec index
- Mine 3%.
- Justin accorde 10%
- Jeff Atwoods 87%
J'ai essayé de voir si les requêtes évoluaient correctement avec l'index en créant plus de données à partir de 14 000 lignes environ par un facteur 2 à 512, ce qui représente finalement environ 7,2 millions de lignes. Remarque Je me suis assuré que le champ CustomeId était unique à chaque fois que je créais une seule copie. La proportion de lignes par rapport à une instance unique de CustomerId était donc maintenue constante. Pendant que je faisais cela, j’ai exécuté des exécutions où j’ai reconstruit l’index par la suite, et j’ai remarqué que les résultats se stabilisaient autour d’un facteur 128 avec les données que j’avais aux valeurs suivantes:
- Mine 3%.
- Justin accorde 5%
- Jeff Atwoods 92%
Je me demandais comment la performance aurait pu être affectée par la mise à l'échelle du nombre de lignes tout en conservant une constante CustomerId unique. J'ai donc configuré un nouveau test dans lequel je venais de le faire. Maintenant, au lieu de se stabiliser, le ratio de coût des lots a continué de diverger, au lieu d’environ 20 lignes par CustomerId par moyenne, j’avais finalement environ 10000 lignes par identifiant unique. Les chiffres où:
- Mine 4%
- Justins 60%
- Jeffs 35%
Je me suis assuré d’implémenter chaque méthode correctement en comparant les résultats. Ma conclusion est que la méthode que j'ai utilisée est généralement plus rapide tant que l'index existe. Vous avez également remarqué que cette méthode est recommandée pour ce problème particulier dans cet article https://www.microsoftpressstore.com/articles/article.aspx?p=2314819&seqNum=5
Un moyen d'améliorer encore les performances des appels ultérieurs à cette requête consiste à conserver les informations de comptage dans une table auxiliaire. Vous pouvez même le gérer en utilisant un déclencheur qui met à jour et qui contient des informations sur le nombre de lignes SalesOrderHeader dépendant de CustomerId. Bien entendu, vous pouvez également stocker simplement la médiane.
Pour les débutants comme moi qui apprennent les bases, je trouve personnellement cet exemple plus facile à suivre car il est plus facile de comprendre exactement ce qui se passe et d'où viennent les valeurs médianes ...
select
( max(a.[Value1]) + min(a.[Value1]) ) / 2 as [Median Value1]
,( max(a.[Value2]) + min(a.[Value2]) ) / 2 as [Median Value2]
from (select
datediff(dd,startdate,enddate) as [Value1]
,xxxxxxxxxxxxxx as [Value2]
from dbo.table1
)a
En admiration absolue de certains des codes ci-dessus !!!
--Create Temp Table to Store Results in
DECLARE @results AS TABLE
(
[Month] datetime not null
,[Median] int not null
);
--This variable will determine the date
DECLARE @IntDate as int
set @IntDate = -13
WHILE (@IntDate < 0)
BEGIN
--Create Temp Table
DECLARE @table AS TABLE
(
[Rank] int not null
,[Days Open] int not null
);
--Insert records into Temp Table
insert into @table
SELECT
rank() OVER (ORDER BY DATEADD(mm, DATEDIFF(mm, 0, DATEADD(ss, SVR.close_date, '1970')), 0), DATEDIFF(day,DATEADD(ss, SVR.open_date, '1970'),DATEADD(ss, SVR.close_date, '1970')),[SVR].[ref_num]) as [Rank]
,DATEDIFF(day,DATEADD(ss, SVR.open_date, '1970'),DATEADD(ss, SVR.close_date, '1970')) as [Days Open]
FROM
mdbrpt.dbo.View_Request SVR
LEFT OUTER JOIN dbo.dtv_apps_systems vapp
on SVR.category = vapp.persid
LEFT OUTER JOIN dbo.prob_ctg pctg
on SVR.category = pctg.persid
Left Outer Join [mdbrpt].[dbo].[rootcause] as [Root Cause]
on [SVR].[rootcause]=[Root Cause].[id]
Left Outer Join [mdbrpt].[dbo].[cr_stat] as [Status]
on [SVR].[status]=[Status].[code]
LEFT OUTER JOIN [mdbrpt].[dbo].[net_res] as [net]
on [net].[id]=SVR.[affected_rc]
WHERE
SVR.Type IN ('P')
AND
SVR.close_date IS NOT NULL
AND
[Status].[SYM] = 'Closed'
AND
SVR.parent is null
AND
[Root Cause].[sym] in ( 'RC - Application','RC - Hardware', 'RC - Operational', 'RC - Unknown')
AND
(
[vapp].[appl_name] in ('3PI','Billing Rpts/Files','Collabrent','Reports','STMS','STMS 2','Telco','Comergent','OOM','C3-BAU','C3-DD','DIRECTV','DIRECTV Sales','DIRECTV Self Care','Dealer Website','EI Servlet','Enterprise Integration','ET','ICAN','ODS','SB-SCM','SeeBeyond','Digital Dashboard','IVR','OMS','Order Services','Retail Services','OSCAR','SAP','CTI','RIO','RIO Call Center','RIO Field Services','FSS-RIO3','TAOS','TCS')
OR
pctg.sym in ('Systems.Release Health Dashboard.Problem','DTV QA Test.Enterprise Release.Deferred Defect Log')
AND
[Net].[nr_desc] in ('3PI','Billing Rpts/Files','Collabrent','Reports','STMS','STMS 2','Telco','Comergent','OOM','C3-BAU','C3-DD','DIRECTV','DIRECTV Sales','DIRECTV Self Care','Dealer Website','EI Servlet','Enterprise Integration','ET','ICAN','ODS','SB-SCM','SeeBeyond','Digital Dashboard','IVR','OMS','Order Services','Retail Services','OSCAR','SAP','CTI','RIO','RIO Call Center','RIO Field Services','FSS-RIO3','TAOS','TCS')
)
AND
DATEADD(mm, DATEDIFF(mm, 0, DATEADD(ss, SVR.close_date, '1970')), 0) = DATEADD(mm, DATEDIFF(mm,0,DATEADD(mm,@IntDate,getdate())), 0)
ORDER BY [Days Open]
DECLARE @Count AS INT
SELECT @Count = COUNT(*) FROM @table;
WITH MyResults(RowNo, [Days Open]) AS
(
SELECT RowNo, [Days Open] FROM
(SELECT ROW_NUMBER() OVER (ORDER BY [Days Open]) AS RowNo, [Days Open] FROM @table) AS Foo
)
insert into @results
SELECT
DATEADD(mm, DATEDIFF(mm,0,DATEADD(mm,@IntDate,getdate())), 0) as [Month]
,AVG([Days Open])as [Median] FROM MyResults WHERE RowNo = (@Count+1)/2 OR RowNo = ((@Count+1)%2) * ((@Count+2)/2)
set @IntDate = @IntDate+1
DELETE FROM @table
END
select *
from @results
order by [Month]
Je voulais trouver une solution moi-même, mais mon cerveau a trébuché et est tombé sur le chemin. Je pense cela fonctionne, mais ne me demandez pas de l'expliquer le matin. : P
DECLARE @table AS TABLE
(
Number int not null
);
insert into @table select 2;
insert into @table select 4;
insert into @table select 9;
insert into @table select 15;
insert into @table select 22;
insert into @table select 26;
insert into @table select 37;
insert into @table select 49;
DECLARE @Count AS INT
SELECT @Count = COUNT(*) FROM @table;
WITH MyResults(RowNo, Number) AS
(
SELECT RowNo, Number FROM
(SELECT ROW_NUMBER() OVER (ORDER BY Number) AS RowNo, Number FROM @table) AS Foo
)
SELECT AVG(Number) FROM MyResults WHERE RowNo = (@Count+1)/2 OR RowNo = ((@Count+1)%2) * ((@Count+2)/2)
Pour les jeux de données à grande échelle, vous pouvez essayer ce Gist:
https://Gist.github.com/chrisknoll/1b38761ce8c5016ec5b2
Cela fonctionne en agrégeant les valeurs distinctes que vous trouverez dans votre ensemble (telles que les âges, l'année de naissance, etc.) et utilise des fonctions de fenêtre SQL pour localiser toute position en centile spécifiée dans la requête.
Fréquemment, il peut être nécessaire de calculer la médiane non seulement pour l'ensemble du tableau, mais également pour les agrégats relatifs à certaines ID. En d’autres termes, calculez la médiane de chaque identifiant de notre tableau, où chaque identifiant comporte de nombreux enregistrements. (basé sur la solution éditée par @gdoron: bonne performance et fonctionne dans de nombreux SQL)
SELECT our_id, AVG(1.0 * our_val) as Median
FROM
( SELECT our_id, our_val,
COUNT(*) OVER (PARTITION BY our_id) AS cnt,
ROW_NUMBER() OVER (PARTITION BY our_id ORDER BY our_val) AS rnk
FROM our_table
) AS x
WHERE rnk IN ((cnt + 1)/2, (cnt + 2)/2) GROUP BY our_id;
J'espère que ça aide.
La solution suivante fonctionne sous ces hypothèses:
- Pas de doublons
- Pas de NULL
Code:
IF OBJECT_ID('dbo.R', 'U') IS NOT NULL
DROP TABLE dbo.R
CREATE TABLE R (
A FLOAT NOT NULL);
INSERT INTO R VALUES (1);
INSERT INTO R VALUES (2);
INSERT INTO R VALUES (3);
INSERT INTO R VALUES (4);
INSERT INTO R VALUES (5);
INSERT INTO R VALUES (6);
-- Returns Median(R)
select SUM(A) / CAST(COUNT(A) AS FLOAT)
from R R1
where ((select count(A) from R R2 where R1.A > R2.A) =
(select count(A) from R R2 where R1.A < R2.A)) OR
((select count(A) from R R2 where R1.A > R2.A) + 1 =
(select count(A) from R R2 where R1.A < R2.A)) OR
((select count(A) from R R2 where R1.A > R2.A) =
(select count(A) from R R2 where R1.A < R2.A) + 1) ;
S'appuyant sur la réponse de Jeff Atwood ci-dessus, c'est avec GROUP BY et une sous-requête corrélée pour obtenir la médiane de chaque groupe.
SELECT TestID,
(
(SELECT MAX(Score) FROM
(SELECT TOP 50 PERCENT Score FROM Posts WHERE TestID = Posts_parent.TestID ORDER BY Score) AS BottomHalf)
+
(SELECT MIN(Score) FROM
(SELECT TOP 50 PERCENT Score FROM Posts WHERE TestID = Posts_parent.TestID ORDER BY Score DESC) AS TopHalf)
) / 2 AS MedianScore,
AVG(Score) AS AvgScore, MIN(Score) AS MinScore, MAX(Score) AS MaxScore
FROM Posts_parent
GROUP BY Posts_parent.TestID
Pour votre question, Jeff Atwood avait déjà donné la solution simple et efficace. Toutefois, si vous recherchez une autre approche pour calculer la médiane, le code ci-dessous vous aidera.
create table employees(salary int);
insert into employees values(8); insert into employees values(23); insert into employees values(45); insert into employees values(123); insert into employees values(93); insert into employees values(2342); insert into employees values(2238);
select * from employees;
declare @odd_even int; declare @cnt int; declare @middle_no int;
set @cnt=(select count(*) from employees); set @middle_no=(@cnt/2)+1; select @odd_even=case when (@cnt%2=0) THEN -1 ELse 0 END ;
select AVG(tbl.salary) from (select salary,ROW_NUMBER() over (order by salary) as rno from employees group by salary) tbl where tbl.rno=@middle_no or tbl.rno=@middle_no+@odd_even;Si vous cherchez à calculer la médiane dans MySQL, ce lien github sera utile.
Constat médian
C'est la méthode la plus simple pour trouver la médiane d'un attribut.
Select round(S.salary,4) median from employee S where (select count(salary) from station where salary < S.salary ) = (select count(salary) from station where salary > S.salary)
Cela fonctionne avec SQL 2000:
DECLARE @testTable TABLE
(
VALUE INT
)
--INSERT INTO @testTable -- Even Test
--SELECT 3 UNION ALL
--SELECT 5 UNION ALL
--SELECT 7 UNION ALL
--SELECT 12 UNION ALL
--SELECT 13 UNION ALL
--SELECT 14 UNION ALL
--SELECT 21 UNION ALL
--SELECT 23 UNION ALL
--SELECT 23 UNION ALL
--SELECT 23 UNION ALL
--SELECT 23 UNION ALL
--SELECT 29 UNION ALL
--SELECT 40 UNION ALL
--SELECT 56
--
--INSERT INTO @testTable -- Odd Test
--SELECT 3 UNION ALL
--SELECT 5 UNION ALL
--SELECT 7 UNION ALL
--SELECT 12 UNION ALL
--SELECT 13 UNION ALL
--SELECT 14 UNION ALL
--SELECT 21 UNION ALL
--SELECT 23 UNION ALL
--SELECT 23 UNION ALL
--SELECT 23 UNION ALL
--SELECT 23 UNION ALL
--SELECT 29 UNION ALL
--SELECT 39 UNION ALL
--SELECT 40 UNION ALL
--SELECT 56
DECLARE @RowAsc TABLE
(
ID INT IDENTITY,
Amount INT
)
INSERT INTO @RowAsc
SELECT VALUE
FROM @testTable
ORDER BY VALUE ASC
SELECT AVG(amount)
FROM @RowAsc ra
WHERE ra.id IN
(
SELECT ID
FROM @RowAsc
WHERE ra.id -
(
SELECT MAX(id) / 2.0
FROM @RowAsc
) BETWEEN 0 AND 1
)
DECLARE @Obs int
DECLARE @RowAsc table
(
ID INT IDENTITY,
Observation FLOAT
)
INSERT INTO @RowAsc
SELECT Observations FROM MyTable
ORDER BY 1
SELECT @Obs=COUNT(*)/2 FROM @RowAsc
SELECT Observation AS Median FROM @RowAsc WHERE ID=@Obs
C'est une réponse aussi simple que possible. A bien travaillé avec mes données. Si vous souhaitez exclure certaines valeurs, ajoutez simplement une clause where à la sélection interne.
SELECT TOP 1
ValueField AS MedianValue
FROM
(SELECT TOP(SELECT COUNT(1)/2 FROM tTABLE)
ValueField
FROM
tTABLE
ORDER BY
ValueField) A
ORDER BY
ValueField DESC