Sql - How many people earn min and max salary? - sql

Question

I have a table with Employees, Departments and Salaries and I would like to get min and max salaries per department (what is just min/max with group by on department), but how to count how many Employees earn that min and max salary per department?
Select Department,
Count(distinct EmployeeID) as Employees,
Min(Salary) as Min,
Max(Salary) as Max
From Employees
Group by Department;

Answer 1

You need to make your query as a subquery for the following one :
Select Department, count(*) as "Count People"
From Employees
Where (Department,Salary) IN
(
Select Department, Min(Salary)
From Employees
Group by Department
Union all
Select Department, Max(Salary)
From Employees
Group by Department
)
Group by Department;
Rextester Demo

Answer 2

Maybe you need 2 distinct values for the counters of minimum and maximum salaries of each department:
SELECT t1.Department, t1.MinCounter, t2.MaxCounter FROM
(SELECT t.Department, COUNT(*) AS MinCounter
FROM
(SELECT Department, MIN(Salary) AS MinSalary FROM Employees
GROUP BY Department) AS t
INNER JOIN Employees
ON (t.MinSalary = Employees.Salary) AND (t.Department = Employees.Department)
GROUP BY t.Department) AS t1
INNER JOIN
(SELECT t.Department, COUNT(*) AS MaxCounter
FROM
(SELECT Department, MAX(Salary) AS MaxSalary FROM Employees
GROUP BY Department) AS t
INNER JOIN Employees
ON (t.MaxSalary = Employees.Salary) AND (t.Department = Employees.Department)
GROUP BY t.Department) AS t2
ON t1.Department = t2.Department
The above query consists of 2 subqueries joined by Department, each of which fetches the counter of the minimum and the maximum salary per department. If you also want included in the query the amounts of the minimum and the maximum salary per department, then check this:
SELECT t1.Department, t1.MinSalary, t1.MinCounter, t2.MaxSalary, t2.MaxCounter
FROM
(SELECT t.Department, t.MinSalary, COUNT(*) AS MinCounter
FROM (SELECT Department, MIN(Salary) AS MinSalary FROM Employees
GROUP BY Department) AS t
INNER JOIN Employees
ON (t.Department = Employees.Department)
AND (t.MinSalary = Employees.Salary)
GROUP BY t.Department, MinSalary) AS t1
INNER JOIN
(SELECT t.Department, t.MaxSalary, COUNT(*) AS MaxCounter
FROM (SELECT Department, MAX(Salary) AS MaxSalary FROM Employees
GROUP BY Department) AS t
INNER JOIN Employees
ON (t.Department = Employees.Department)
AND (t.MaxSalary = Employees.Salary)
GROUP BY t.Department, MaxSalary) AS t2
ON t1.Department = t2.Department

Answer 3

You can get the min and max salaries in a subquery, then count how many employees have those salaries in an outer query, like so: https://dbfiddle.uk/?rdbms=sqlserver_2017&fiddle=b89ac6b76112bf7db65ce6e37754198b
select agg.*
, count(case when e.Salary = agg.MinSalary then 1 end) EmployeesWithMin
, count(case when e.Salary = agg.MaxSalary then 1 end) EmployeesWithMax
from
(
select Department
, count(1) EmployeesInDepartment
, min(Salary) MinSalary
, max(Salary) MaxSalary
from Employees
group by Department
) agg
inner join Employees e
on e.Department = agg.department
and e.Salary in (agg.MaxSalary, agg.MinSalary)
group by agg.Department
, agg.EmployeesInDepartment
, agg.MinSalary
, agg.MaxSalary
Or an alternative approach: https://dbfiddle.uk/?rdbms=sqlserver_2017&fiddle=8a5e539fcd3e5985d44f86b1e331f030
select agg.Department
, min(agg.MinSalary) MinSalary
, max(agg.MaxSalary) MaxSalary
, count(case when Salary = MinSalary then 1 end) EmployeesWithMin
, count(case when Salary = MaxSalary then 1 end) EmployeesWithMax
from
(
select Department
, min(Salary) over (partition by Department) MinSalary
, max(Salary) over (partition by Department) MaxSalary
, Salary
from Employees
) agg
group by agg.Department
The former may be simpler to understand for a beginner. The latter is less verbose, so easier to read. i.e. Pick whichever you're more comfortable supporting / whichever makes most sense to you.
In terms of performance, the second performed slightly better for my sample data; but a number of variables may influence this (number of rows, spread of values, availability of indexes), so it's best to test on data as similar to real-world as possible if you need to pick the optimal query.
Let me know if any of the methods used here aren't familiar to you and I can add explanations as required.