In HR schema , I wanted to list all the employees that have salary < average salary by departments of different countries , and group them by countries and by department_name
SELECT E.FIRST_NAME , S.COUNTRY_NAME, S.DEPARTMENT_NAME, S.AVG_SALARY, E.SALARY
FROM EMPLOYEES E JOIN (SELECT COUNTRY_NAME, DEPARTMENT_NAME, ROUND(AVG(SALARY,0) AS "AVG_SALARY", DEPARTMENT_ID
FROM (SELECT SALARY, COUNTRY_NAME, DEPARTMENT_NAME, DEPARTMENT_ID
FROM EMPLOYEES JOIN DEPARTMENTS USING (DEPARTMENT_ID)
JOIN LOCATIONS USING (LOCATION_ID)
JOIN COUNTRIES USING (COUNTRY_ID)
)
GROUP BY COUNTRY_NAME, DEPARTMENT_NAME, DEPARTMENT_ID
) S ON (E.DEPARTMENT_ID=S.DEPARTMENT_ID)
WHERE E.SALARY< S.AVG_SALARY AND E.DEPARTMENT_ID = S.DEPARTMENT_ID
GROUP BY COUNTRY_NAME, DEPARTMENT_NAME, AVG_SALARY, FIRST_NAME, SALARY
ORDER BY COUNTRY_NAME;
Make sure you match your parentheses.
ROUND(AVG(SALARY,0)
Should be:
ROUND(AVG(SALARY),0)
Related
I am trying to select a highest earner in 'IT' department, but I keep selecting no rows.
Salary and names are in table called employees while department_name is in a table named departments.
Can anyone please explain why does this select no rows and how should I do it?
SELECT first_name, last_name, salary, department_name
FROM employees
JOIN departments on departments.department_id = employees.department_id
WHERE salary = (SELECT max(salary) FROM employees WHERE department_name = 'IT');
Why this select selects no rows?
Your query fails because there is no column department_name in the employees table. So your subquery does not do what you expect:
where salary = (SELECT max(salary) FROM employees WHERE department_name = 'IT');
If you want to do this with a subquery, you need to correlate it:
select e.first_name, e.last_name, e.salary, d.department_name
from employees e
inner join departments d on d.department_id = e.department_id
where
d.department_name = 'IT'
and e.salary = (select max(e1.salary)
from employees e1
where e1.department_id = e.department_id);
You can use dense_rank if there are more than one highest earner for IT department.
select
first_name,
last_name,
salary,
department_name
from
(
select
first_name,
last_name,
salary,
department_name,
dense_rank() over (partition by department_name order by salary desc) as rnk
FROM employees e
JOIN departments d
on d.department_id = e.department_id
where department_name = 'IT'
) val
where rnk = 1
Use row_number() :
SELECT t.*
FROM (SELECT emp.first_name, emp.last_name, dempt.salary, dempt.department_name,
ROW_NUMBER() OVER(PARTITION BY dept.department_name ORDER BY dept.salary DESC) AS SEQ
FROM employees emp JOIN
departments dept
ON dept.department_id = emp.department_id
WHERE dempt.department_name = 'IT'
) t
WHERE seq = 1;
If salary has ties then you can use rank() instead.
From default employees table I want to find managers who have only one employee
I have found only managers of employee
select e.first_name, e.last_name, e.manager_id
from employees e
inner join employees m on e.manager_id = m.employee_id;
result should show only employees having one manager
You could try cheking for having count(*) = 1 group by the manager_id
select manager_id
from employees
group by manager_id
having count(*) = 1
and if you need the name too
select e.first_name, e.last_name
from employees e
inner join (
select manager_id
from employees
group by manager_id
having count(*) = 1
) t on t.manager_id = e.employee_id
With this query:
select manager_id
from employees
group by manager_id
having count(*) = 1
you get all the managers who have only 1 employee.
If you need these employees:
select first_name, last_name, manager_id
from employees
where manager_id in (
select manager_id
from employees
group by manager_id
having count(*) = 1
)
You can hierarchical query for each manager( manager_id column ) to go deeply for all levels,
and filter by having count(distinct employee_id) = 1 to get managers who have only one employee.
select first_name, last_name, employee_id
from employees
where employee_id in
(
select manager_id
from employees
connect by prior employee_id = manager_id
start with manager_id in ( select distinct manager_id from employees )
group by manager_id
having count(distinct employee_id) = 1
);
Demo
I've written an SQL statement to display the department_id, job_id and of employees with the lowest salary, but one of the conditions required me to exclude departments with the names 'IT' and 'SALES', which were only accessible from another table departments. As such I joined the two tables using the shared column department_id and managed to filter the results as needed however, I am unable to select the department_id to display alongside the job_id and salaries. This is what I've managed so far:
SELECT EMPLOYEES.DEPARTMENT_ID JOB_ID, MIN(SALARY)
FROM EMPLOYEES JOIN DEPARTMENTS
ON DEPARTMENTS.DEPARTMENT_ID = EMPLOYEES.DEPARTMENT_ID
WHERE JOB_ID NOT LIKE '%REP'
AND DEPARTMENTS.DEPARTMENT_NAME NOT IN ('IT','SALES')
GROUP BY EMPLOYEES.DEPARTMENT_ID
HAVING MIN(SALARY) >= 6000 AND MIN(SALARY) <= 18000;
First, table aliases make the query much easier to write and read:
SELECT e.DEPARTMENT_ID, e.JOB_ID, MIN(e.SALARY)
FROM EMPLOYEES e JOIN
DEPARTMENTS d
ON d.DEPARTMENT_ID = e.DEPARTMENT_ID
WHERE e.JOB_ID NOT LIKE '%REP' AND d.DEPARTMENT_NAME NOT IN ('IT',' SALES')
GROUP BY e.DEPARTMENT_ID, e.JOB_ID
HAVING MIN(e.SALARY) >= 6000 AND MIN(e.SALARY) <= 18000;
You need all non-aggregated columns in the GROUP BY.
Comma is missing in your query after department id in SELECT - so it considers Job ID as Alias for department ID and displayed as Job ID in query result. But again you don't have Job ID in GROUP BY Clause and need to add that in group by or have to use any aggregate function
SELECT **EMPLOYEES.DEPARTMENT_ID, JOB_ID,** MIN(SALARY)
FROM EMPLOYEES JOIN DEPARTMENTS ON DEPARTMENTS.DEPARTMENT_ID=EMPLOYEES.DEPARTMENT_ID
WHERE JOB_ID NOT LIKE '%REP' AND DEPARTMENTS.DEPARTMENT_NAME NOT IN('IT','SALES')
GROUP BY EMPLOYEES.DEPARTMENT_ID,JOB_ID
HAVING MIN(SALARY) >= 6000 AND MIN(SALARY) <= 18000;
I found a couple of SQL tasks on Hacker News today, however I am stuck on solving the second task in Postgres, which I'll describe here:
You have the following, simple table structure:
List the employees who have the biggest salary in their respective departments.
I set up an SQL Fiddle here for you to play with. It should return Terry Robinson, Laura White. Along with their names it should have their salary and department name.
Furthermore, I'd be curious to know of a query which would return Terry Robinsons (maximum salary from the Sales department) and Laura White (maximum salary in the Marketing department) and an empty row for the IT department, with null as the employee; explicitly stating that there are no employees (thus nobody with the highest salary) in that department.
Return one employee with the highest salary per dept.
Use DISTINCT ON for a much simpler and faster query that does all you are asking for:
SELECT DISTINCT ON (d.id)
d.id AS department_id, d.name AS department
,e.id AS employee_id, e.name AS employee, e.salary
FROM departments d
LEFT JOIN employees e ON e.department_id = d.id
ORDER BY d.id, e.salary DESC;
->SQLfiddle (for Postgres).
Also note the LEFT [OUTER] JOIN that keeps departments with no employees in the result.
This picks only one employee per department. If there are multiple sharing the highest salary, you can add more ORDER BY items to pick one in particular. Else, an arbitrary one is picked from peers.
If there are no employees, the department is still listed, with NULL values for employee columns.
You can simply add any columns you need in the SELECT list.
Find a detailed explanation, links and a benchmark for the technique in this related answer:
Select first row in each GROUP BY group?
Aside: It is an anti-pattern to use non-descriptive column names like name or id. Should be employee_id, employee etc.
Return all employees with the highest salary per dept.
Use the window function rank() (like #Scotch already posted, just simpler and faster):
SELECT d.name AS department, e.employee, e.salary
FROM departments d
LEFT JOIN (
SELECT name AS employee, salary, department_id
,rank() OVER (PARTITION BY department_id ORDER BY salary DESC) AS rnk
FROM employees e
) e ON e.department_id = d.department_id AND e.rnk = 1;
Same result as with the above query with your example (which has no ties), just a bit slower.
This is with reference to your fiddle:
SELECT * -- or whatever is your columns list.
FROM employees e JOIN departments d ON e.Department_ID = d.id
WHERE (e.Department_ID, e.Salary) IN (SELECT Department_ID, MAX(Salary)
FROM employees
GROUP BY Department_ID)
EDIT :
As mentioned in a comment below, if you want to see the IT department also, with all NULL for the employee records, you can use the RIGHT JOIN and put the filter condition in the joining clause itself as follows:
SELECT e.name, e.salary, d.name -- or whatever is your columns list.
FROM employees e RIGHT JOIN departments d ON e.Department_ID = d.id
AND (e.Department_ID, e.Salary) IN (SELECT Department_ID, MAX(Salary)
FROM employees
GROUP BY Department_ID)
This is basically what you want. Rank() Over
SELECT ename ,
departments.name
FROM ( SELECT ename ,
dname
FROM ( SELECT employees.name as ename ,
departments.name as dname ,
rank() over (
PARTITION BY employees.department_id
ORDER BY employees.salary DESC
)
FROM Employees
JOIN Departments on employees.department_id = departments.id
) t
WHERE rank = 1
) s
RIGHT JOIN departments on s.dname = departments.name
Good old classic sql:
select e1.name, e1.salary, e1.department_id
from employees e1
where e1.salary=
(select maxsalary=max(e.salary) --, e. department_id
from employees e
where e.department_id = e1.department_id
group by e.department_id
)
Table1 is emp - empno, ename, sal, deptno
Table2 is dept - deptno, dname.
Query could be (includes ties & runs on 11.2g):
select e1.empno, e1.ename, e1.sal, e1.deptno as department
from emp e1
where e1.sal in
(SELECT max(sal) from emp e, dept d where e.deptno = d.deptno group by d.dname)
order by e1.deptno asc;
SELECT
e.first_name, d.department_name, e.salary
FROM
employees e
JOIN
departments d
ON
(e.department_id = d.department_id)
WHERE
e.first_name
IN
(SELECT TOP 2
first_name
FROM
employees
WHERE
department_id = d.department_id);
`select d.Name, e.Name, e.Salary from Employees e, Departments d,
(select DepartmentId as DeptId, max(Salary) as Salary
from Employees e
group by DepartmentId) m
where m.Salary = e.Salary
and m.DeptId = e.DepartmentId
and e.DepartmentId = d.DepartmentId`
The max salary of each department is computed in inner query using GROUP BY. And then select employees who satisfy those constraints.
Assuming Postgres
Return highest salary with employee details, assuming table name emp having employees department with dept_id
select e1.* from emp e1 inner join (select max(sal) avg_sal,dept_id from emp group by dept_id) as e2 on e1.dept_id=e2.dept_id and e1.sal=e2.avg_sal
Returns one or more people for each department with the highest salary:
SELECT result.Name Department, Employee2.Name Employee, result.salary Salary
FROM ( SELECT dept.name, dept.department_id, max(Employee1.salary) salary
FROM Departments dept
JOIN Employees Employee1 ON Employee1.department_id = dept.department_id
GROUP BY dept.name, dept.department_id ) result
JOIN Employees Employee2 ON Employee2.department_id = result.department_id
WHERE Employee2.salary = result.salary
SQL query:
select d.name,e.name,e.salary
from employees e, depts d
where e.dept_id = d.id
and (d.id,e.salary) in
(select dept_id,max(salary) from employees group by dept_id);
Take look at this solution
SELECT
MAX(E.SALARY),
E.NAME,
D.NAME as Department
FROM employees E
INNER JOIN DEPARTMENTS D ON D.ID = E.DEPARTMENT_ID
GROUP BY D.NAME
I am writing a query to find employees who earn greater than the average salary within their department. I need to display the employee ID, salary, department id, and average salary of that department.
I have a query that just almost works but it keeps giving me "ORA-00904: "AVG_SAL": invalid identifier" errors. Am I doing this correctly. Why am i getting this invalid identifier error?
SELECT employee_id, salary, department_id,
(SELECT ROUND(AVG(salary),2)
FROM employees e_inner
WHERE e_inner.department_id = e.department_id) AS avg_sal
FROM employees e
WHERE salary > avg_sal
ORDER BY avg_sal DESC
More efficient to use analytics:
select employee_id, salary, department_id, avg_sal
from
(
SELECT employee_id, salary, department_id,
round(avg(salary) over (partition by department_id), 2) avg_sal
from emp
)
where salary > avg_sal
order by avg_sal desc
I don't believe you can refer to a column alias (avg_sal in this case) in a WHERE clause.
You'll need to repeat that inner query, i.e.:
SELECT employee_id, salary, department_id,
(SELECT ROUND(AVG(salary),2)
FROM employees e_inner
WHERE e_inner.department_id = e.department_id) AS avg_sal
FROM employees e
WHERE salary >
(SELECT ROUND(AVG(salary),2)
FROM employees e_inner
WHERE e_inner.department_id = e.department_id)
ORDER BY avg_sal DESC
Not great, with those two inner queries, but that's the most-straightforward way to correct the error.
Update: Haven't tested this, but try the following:
SELECT e.employee_id, e.salary, e.department_id, b.avg_sal
FROM employees e
INNER JOIN
(SELECT department_id, ROUND(AVG(salary),2) AS avg_sal
FROM employees
GROUP BY department_id) e_avg ON e.department_id = e_avg.department_id AND e.salary > e_avg.avg_sal
ORDER BY e_avg.avg_sal DESC
You could rewrite it as a join:
SELECT e1.employee_id
, e1.salary
, e1.department_id
, ROUND(AVG(e2.salary),2) as Avg_Sal
FROM employees e
JOIN employees e2
ON e2.department_id = e.department_id
GROUP BY
e1.employee_id
, e1.salary
, e1.department_id
HAVING e1.salary > ROUND(AVG(e2.salary),2)
Or a subquery:
SELECT *
FROM (
SELECT employee_id
, salary
, department_id
, (
SELECT ROUND(AVG(salary),2)
FROM employees e_inner
WHERE e_inner.department_id = e.department_id
) AS avg_sal
FROM employees e
) as SubqueryAlias
WHERE salary > avg_sal
select *
from employees e
join(
select Round(avg(salary)) AvgSal,department_id,department_name as dept_name
from employees join departments
using (department_id)
group by department_id,department_name
) dd
using(department_id)
where e.salary > dd.AvgSal;
another solution
select *
from employees e,
(
select
department_id,
avg(salary) avg_sal
from employees
group by department_id
) e1
where e.department_id=e1.department_id
and e.salary > e1.avg_sal