Home/ Questions/Q 8189
Next
In Process

askthedev.com Latest Questions

Asked: 2024-09-25T18:37:51+05:30 In:

How can I write a SQL query to determine the third highest salary in a company?

I’m working on a project where I need to analyze salary data for a company, and I’ve hit a bit of a wall. I need to write a SQL query to find out what the third highest salary is among the employees. It sounds simple, but I’m not sure the best way to go about it.

Here’s the dataset I’m working with: I have a table called `employees` which has two main columns, `name` and `salary`. The tricky part is that there might be employees with the same salary, so I want to make sure I get the right third highest salary, even if there are duplicates. For example, if the salaries are $70,000, $50,000, $50,000, $40,000, and $30,000, the third highest salary should still be $50,000, not $40,000.

I’ve read about using the `DISTINCT` keyword and how important it is in this situation to avoid counting duplicates, but I’m still confused about how to structure the query correctly. I’m also interested in knowing whether there are other ways to achieve this without writing overly complex code.

I don’t want to overcomplicate things, but I’m also mindful of performance—especially if I end up working with a larger dataset. Would using a subquery be a good approach? Or should I look into using `LIMIT` and `OFFSET` for this?

If anyone has experience with this sort of problem, I’d really appreciate any tips or examples of what a query might look like! It would be super helpful to know the thought process behind your solution too. I just want to make sure I’m grasping the concept clearly, so any insight, even if it sounds basic, is totally welcome!

Share

    Leave an answer

    You must login to add an answer.

    Need An Account,

    2 Answers



    1. SQL Query for Third Highest Salary

      To find the third highest salary in your `employees` table while accounting for duplicate salaries, you can effectively use the `DISTINCT` keyword along with an `ORDER BY` clause combined with `LIMIT`. For your specific requirement, the query would look like this:

          SELECT DISTINCT salary 
    FROM employees 
    ORDER BY salary DESC 
    LIMIT 1 OFFSET 2;

      This SQL statement first selects distinct salary values to ensure that duplicate salaries aren’t counted, then orders the salaries in descending order (highest to lowest). The `LIMIT 1 OFFSET 2` clause effectively skips the first two highest distinct salaries and returns the next (third) one. This approach is straightforward and maintains good performance, as it leverages indexing and avoids the need for complex joins or extra subqueries.

      Alternatively, if you prefer to use a subquery, you could achieve the same outcome with a nested SELECT statement. This method can be beneficial if you’re combining multiple conditions or want enhanced readability:

          SELECT MAX(salary) 
    FROM employees 
    WHERE salary IN (
        SELECT DISTINCT salary 
        FROM employees 
        ORDER BY salary DESC 
        LIMIT 3
    );

      This query first retrieves the top three distinct salaries and then uses the outer query to find the maximum of those, which effectively gives you the third highest salary. Both approaches are valid, so you can choose based on your preference for readability or simplicity.



    2. Finding the Third Highest Salary

      If you want to find the third highest salary in your employees table while ignoring duplicates, you can definitely use the DISTINCT keyword. This will ensure that only unique salaries are considered.

      Here’s a simple SQL query that does what you need:

      
SELECT DISTINCT salary 
FROM employees 
ORDER BY salary DESC 
LIMIT 1 OFFSET 2;

      Let’s break it down:

      1. SELECT DISTINCT salary – This part fetches unique salaries from your table.
      2. ORDER BY salary DESC – This orders the salaries from highest to lowest.
      3. LIMIT 1 OFFSET 2 – This tells the SQL engine to skip the first two highest salaries (which are 1st and 2nd) and then retrieve the next one, which is the third highest.

      This approach is not overly complex and should work well even with larger datasets, assuming you have proper indexing on the salary column.

      Another way to do this is to use a subquery, but for simplicity and clarity, the method shown above is often preferred. Here’s what it would look like if you chose to go with a subquery:

      
SELECT MAX(salary) 
FROM (SELECT DISTINCT salary FROM employees ORDER BY salary DESC LIMIT 3) AS top_salaries;

      This subquery first selects the top three distinct salaries and then finds the maximum among them, which would be the third highest. But honestly, for your case, the first query should do just fine!

      Hope this helps you get past that wall!


    Related Questions