Wie man die zweithöchsten Gehälter in einer Tabelle bekommt

 SELECT * von Mitarbeiter 
 WO Gehalt IN (SELECT MAX (Gehalt) 
 VON Mitarbeiter 
 WO Gehalt NICHT IN (SELECT MAX (Gehalt) 
 FFROM-Mitarbeiter); 

Versuchen Sie es so ..

Das könnte dir helfen

SELECT 
      MIN(SALARY) 
FROM 
      EMP 
WHERE 
      SALARY in (SELECT 
                      DISTINCT TOP 2 SALARY 
                 FROM 
                      EMP 
                 ORDER BY 
                      SALARY DESC
                )

Wir können jedes nth höchste Gehalt finden, indem wir n (wo n > 0) anstelle von 2 eingeben.

Beispiel für 5^th höchstes Gehalt setzen wir n = 5

Wie wäre es mit einem CTE?

;WITH Salaries AS
(
    SELECT Name, Salary,
       DENSE_RANK() OVER(ORDER BY Salary DESC) AS 'SalaryRank'
    FROM 
        dbo.Employees
)
SELECT Name, Salary
FROM Salaries  
WHERE SalaryRank = 2

Mit DENSE_RANK() erhalten Sie alle Mitarbeiter, die das zweithöchste Gehalt haben - unabhängig davon, wie viele Mitarbeiter das (identische) höchste Gehalt haben.

Ein anderer intuitiver Weg ist: - 

1) Mitarbeiter nach absteigender Reihenfolge des Gehalts sortieren 

2) Nehmen Sie die ersten N Datensätze mit Rownum auf. In diesem Schritt ist der N-te Datensatz das N-te höchste Gehalt

3) Sortieren Sie nun dieses temporäre Ergebnis in aufsteigender Reihenfolge. Das N-te höchste Gehalt ist jetzt der erste Rekord

4) Holen Sie sich den ersten Datensatz von diesem temporären Ergebnis. 

Es wird das n-te höchste Gehalt sein.

select * from 
 (select * from 
   (select * from  
       (select * from emp order by sal desc)  
   where rownum<=:N )  
 order by sal )
where rownum=1;

Falls es wiederkehrende Gehälter gibt, können in der innersten Abfrage unterschiedliche verwendet werden. 

select * from 
 (select * from 
   (select * from  
       (select distinct(sal) from emp order by 1 desc)  
   where rownum<=:N )  
 order by sal )
where rownum=1;

Alle folgenden Abfragen funktionieren für MySQL :

SELECT MAX(salary) FROM Employee WHERE Salary NOT IN (SELECT Max(Salary) FROM Employee);

SELECT MAX(Salary) From Employee WHERE Salary < (SELECT Max(Salary) FROM Employee);

SELECT Salary FROM Employee ORDER BY Salary DESC LIMIT 1 OFFSET 1;

SELECT Salary FROM (SELECT Salary FROM Employee ORDER BY Salary DESC LIMIT 2) AS Emp ORDER BY Salary LIMIT 1;

select MAX(Salary) from Employee WHERE Salary NOT IN (select MAX(Salary) from Employee );

Einfache Möglichkeit, OHNE spezielle Funktionen für Oracle, MySQL usw. zu verwenden.

Angenommen, die Tabelle EMPLOYEE enthält Daten wie folgt. Die Gehälter können wiederholt werden.

Durch manuelle Analyse können wir die Rangfolge wie folgt festlegen:

Dasselbe Ergebnis kann durch Abfrage erreicht werden

select  *
from  (
select tout.sal, id, (select count(*) +1 from (select distinct(sal) distsal from     
EMPLOYEE ) where  distsal >tout.sal)  as rank  from EMPLOYEE tout
) result
order by rank

Zuerst erfahren wir unterschiedliche Gehälter. .__ Dann ermitteln wir die Anzahl der unterschiedlichen Gehälter, die größer als jede Zeile sind. Dies ist nichts anderes als der Rang dieser ID. Für das höchste Gehalt ist diese Anzahl Null. Also wird +1 gesetzt, um den Rang von 1 zu beginnen.

Jetzt können wir IDs im N-ten Rang erhalten, indem wir der obigen Abfrage eine where-Klausel hinzufügen.

select  *
from  (
select tout.sal, id, (select count(*) +1 from (select distinct(sal) distsal from     
EMPLOYEE ) where  distsal >tout.sal)  as rank  from EMPLOYEE tout
) result
where rank = N;

Die folgende Abfrage kann verwendet werden, um den n-ten Maximalwert zu finden. Ersetzen Sie einfach 2 von n-te Zahl

select * from emp e1 where 2 =(select count(distinct(salary)) from emp e2
   where e2.emp >= e1.emp)

Ich denke, Sie möchten DENSE_RANK verwenden, da Sie nicht wissen, wie viele Mitarbeiter dasselbe Gehalt haben und Sie sagten, Sie wollten einen Namen von Mitarbeitern haben.

CREATE TABLE #Test
(
    Id INT,
    Name NVARCHAR(12),
    Salary MONEY
)

SELECT x.Name, x.Salary
FROM
        (
        SELECT  Name, Salary, DENSE_RANK() OVER (ORDER BY Salary DESC) as Rnk
        FROM    #Test
        ) x
WHERE x.Rnk = 2

ROW_NUMBER würde Ihnen eine eindeutige Nummerierung geben, selbst wenn die Gehälter gebunden sind, und einfache RANK würde Ihnen nicht eine '2' als Rang geben, wenn Sie mehrere Personen für das höchste Gehalt haben. Ich habe dies korrigiert, da DENSE_RANK dafür die beste Arbeit leistet.

Versuchen Sie dies, um das jeweils n-te höchste Gehalt zu erhalten.

SELECT
    *
FROM
    emp e1
WHERE
    2 = (
        SELECT
            COUNT(salary)
        FROM
            emp e2
        WHERE
            e2.salary >= e1.salary
    )

select max(age) from yd where age<(select max(age) from HK) ; /// True two table Highest 

SELECT * FROM HK E1 WHERE 1 =(SELECT COUNT(DISTINCT age) FROM HK E2 WHERE E1.age < E2.age); ///Second Hightest age RT single table 

select age from hk e1 where (3-1) = (select count(distinct (e2.age)) from yd e2 where e2.age>e1.age);//// same True Second Hight age RT two table

select max(age) from YD where age not in (select max(age) from YD);  //second hight age in single table 

Hier habe ich zwei Abfragen für die folgenden Szenarien verwendet, die während eines Interviews gefragt werden
Erstes Szenario:
Alle zweithöchsten Gehälter in der Tabelle finden (zweithöchstes Gehalt mit mehr als Einem Mitarbeiter) 

select * from emp where salary
   In (select MAX(salary) from emp where salary NOT IN (Select MAX(salary) from 
   emp));

Zweites Szenario:
Finden Sie nur das zweithöchste Gehalt in der Tabelle 

select min(temp.salary) from (select * from emp order by salary desc limit 2) 
  temp;

Die meisten Antworten sind gültig. Sie können den Offset mit dem sortierten Gehalt wie folgt verwenden:

SELECT NAME
FROM EMPLOYEES
WHERE SALARY IN
(
    SELECT DISTINCT 
           SALARY
    FROM EMPLOYEES
    ORDER BY SALARY DESC
    OFFSET 1 ROWS FETCH NEXT 1 ROWS ONLY
);

Um das n-te höchste Gehalt zu ermitteln, ersetzen Sie Offset 1 durch n

dies ist die einfache Abfrage. Wenn Sie das zweite Minimum wünschen, ändern Sie einfach das Maximum in Min und ändern Sie das Zeichen kleiner als (<) in größer als (>).

    select max(column_name) from table_name where column_name<(select max(column_name) from table_name)

Wenn Sie den Namen des Mitarbeiters anzeigen möchten, der das zweithöchste Gehalt erhält, verwenden Sie Folgendes:

SELECT employee_name 
FROM employee
WHERE salary = (SELECT max(salary) 
                FROM employee
                WHERE salary < (SELECT max(salary) 
                                FROM employee);

Können wir auch verwenden

select e2.max(sal), e2.name
from emp e2
where (e2.sal <(Select max (Salary) from empo el))
group by e2.name

Bitte lassen Sie mich wissen, was mit diesem Ansatz falsch ist

Probier diese

    select * from
   (
    select name,salary,ROW_NUMBER() over( order by Salary desc) as
    rownum from    employee
   ) as t where t.rownum=2

http://askme.indianyouth.info/details/write-a-sql-query-to-find-the-10th-estest-employee-salary-von-anmitarbeiter-tabelle-explain-your-answer- 111

SELECT * 
FROM TABLE1 AS A 
WHERE NTH HIGHEST NO.(SELECT COUNT(ATTRIBUTE) FROM TABLE1 AS B) WHERE B.ATTRIBUTE=A.ATTRIBUTE;

select * from emp where salary = (  
    select salary from   
       (select ROW_NUMBER() over (order by salary) as 'rownum', *
        from emp) t -- Order employees according to salary  
    where rownum = 2 -- Get the second highest salary
)

SELECT name
FROM employee
WHERE salary =
(SELECT MIN(salary) 
  FROM (SELECT TOP (2) salary
  FROM employee
  ORDER BY salary DESC) )

stellen wir uns vor, wir haben einen Tisch

name       salary
 A           10
 B           30
 C           20
 D           40

wir werden also zuerst in absteigender Reihenfolge 40 30 20 10 => anordnen 

dann nehmen wir nur die ersten beiden Nummern => 40 30

dann ordnen wir es in aufsteigender Reihenfolge => 30 40

dann nehmen wir die erste Zahl => 30

so in MySQL:

SELECT * FROM (SELECT  * FROM employee   order by salary DESC LIMIT 2) order by salary ASC LIMIT 1;

in Oracle ::

SELECT * FROM (SELECT  * FROM employee  where rownum<=2 order by salary DESC )  where rownum<=1  order by salary ASC ;

SELECT `salary` AS emp_sal, `name` , `id`
FROM `employee`
GROUP BY `salary` ORDER BY `salary` DESC
LIMIT 1 , 1 

SELECT MIN(a.sal) 
FROM dbo.demo a 
WHERE a.sal IN (SELECT DISTINCT TOP 2 a.sal 
                FROM dbo.demo a 
                ORDER BY a.sal DESC) 

Diese Abfrage zeigt alle Details der Mitarbeiter mit dem zweithöchsten Gehalt an

SELECT
    *
FROM
    Employees
WHERE
    salary IN (
        SELECT
            max(salary)
        FROM
            Employees
        WHERE
            salary NOT IN (
                SELECT
                    max(salary)
                FROM
                    Employees
            )
    );

Eine Zusammenstellung von vier Lösungen für das Problem: 

Erste Lösung - Unterabfrage verwenden

SELECT MAX (Gehalt) von Mitarbeiter ---- Diese Abfrage gibt Ihnen maximales Gehalt 

Verwenden Sie nun die obige Abfrage als Unterabfrage, um das nächsthöhere Gehalt wie folgt zu erhalten:

SELECT MAX(salary) FROM employee WHERE salary <> (SELECT MAX(salary) from Employee) - Diese Abfrage wird Ihnen das zweithöchste Gehalt bieten 

Wenn Sie nun den Namen des Mitarbeiters erhalten möchten, der das zweithöchste Gehalt erhält, verwenden Sie oben die Abfrage als Unterabfrage 

SELECT name from employee WHERE salary = 
(SELECT MAX(salary) FROM employee WHERE salary <> (SELECT MAX(salary) from Employee)

- Diese Abfrage wird Ihnen das zweithöchste Gehalt bringen. 

Zweite Lösung - Verwendung der abgeleiteten Tabelle

SELECT TOP 2 DISTINCT(salary) FROM employee ORDER BY salary DESC - Dies wird Ihnen zwei höchste Gehälter geben. Was Sie hier tun, ist, die Gehälter in absteigender Reihenfolge anzuordnen und dann die beiden oberen Gehälter auszuwählen. 

Bestellen Sie nun die obige Ergebnismenge in aufsteigender Reihenfolge nach Gehalt und erhalten Sie TOP 1 

SELECT TOP 1 salary FROM
(SELECT TOP 2 DISTINCT(salary) FROM employee ORDER BY salary DESC) AS tab 
ORDER BY salary

Dritte Lösung - Korrelierte Unterabfrage verwenden

SELECT name, salary FROM Employee e WHERE 2=(SELECT COUNT(DISTINCT salary) FROM Employee p WHERE e.salary<=p.salary)

Vierte Lösung - Verwenden der Fensterfunktion

;WITH T AS
(
SELECT *, DENSE_RANK() OVER (ORDER BY Salary Desc) AS Rnk
FROM Employees
)
SELECT Name
FROM T
WHERE Rnk=2;

 - Method 1

    select max(salary) from Employees
        where salary< (select max(salary) from Employees)



 - Method 2

 select MAX(salary) from Employees 
    where salary not in(select MAX(salary) from Employees)



 - Method 3

select MAX(salary) from Employees 
    where salary!= (select MAX(salary) from Employees )

SELECT lastname, firstname
FROM employees
WHERE salary IN(
    SELECT MAX(salary) 
    FROM employees 
    WHERE salary < (SELECT MAX(salary) FROM employees));

Der folgende Code funktioniert also so:

Sie gibt die Nachnamen, gefolgt von den Vornamen der Angestellten, zurück, die ein Gehalt haben, das niedriger ist als das Höchstgehalt aller Angestellten, aber es ist auch das Höchstgehalt der übrigen Mitarbeiter, die nicht das Höchstgehalt haben.

Mit anderen Worten: Es gibt die Namen der Angestellten mit dem zweiten Höchstgehalt zurück.

Der einfache Weg ist, OFFSET zu verwenden. Nicht nur die zweite, sondern jede Position, die wir mit Offset abfragen können.

SELECT SALARY,NAME FROM EMPLOYEE ORDER BY SALARY DESC LIMIT 1 OFFSET 1 --Second am größten

SELECT SALARY,NAME FROM EMPLOYEE ORDER BY SALARY DESC LIMIT 1 OFFSET 9 --For 10. am größten

probiere diesen einfachen Weg

select name,salary from employee where salary =
(select max(salary) from employee where salary < (select max(salary) from employee ))

Zweithöchstes Gehalt zu finden ....

SELECT MAX( salary)  FROM tblEmp WHERE salary< ( SELECT MAX( salary) FROM tblEmp )

oder

SELECT max(salary) FROM tblEmp WHERE salary NOT IN (SELECT max(salary) FROM tblEmp)

dabei ist "Salary" der Spaltenname und TblEmp der Tabellenname ... Beide arbeiten zu 100% ...

Ich denke, das ist wahrscheinlich der einfachste von allen.

SELECT Name FROM Employees group BY Salary DESCENDING limit 2;

declare

cntr number :=0;

cursor c1 is

select salary from employees order by salary desc;

z c1%rowtype;

begin

open c1;

fetch c1 into z;

while (c1%found) and (cntr <= 1) loop


cntr := cntr + 1;

fetch c1 into z;

dbms_output.put_line(z.salary);

end loop;

end;

Temporäre Tabelle erstellen 

Create Table #Employee (Id int identity(1,1), Name varchar(500), Salary int)

Daten einfügen

Insert Into #Employee
    Select 'Abul', 5000
Union ALL 
    Select 'Babul', 6000
Union ALL 
    Select 'Kabul', 7000
Union ALL 
    Select 'Ibul', 8000
Union ALL 
    Select 'Dabul', 9000

Abfrage wird sein 

select top 1 * from #Employee a
Where a.id <> (Select top 1 b.id from #Employee b ORDER BY b.Salary desc)
order by a.Salary desc

Tisch ablegen 

drop table #Empoyee

SELECT
    salary
FROM
    Employee
ORDER BY
    salary DESC
LIMIT 1,
 1;

Hier ist ein einfacher Ansatz:

select name
from employee
where salary=(select max(salary)
              from(select salary from employee
                   minus
                   select max(salary) from employee));

Unter Verwendung dieser SQL wird das zweithöchste Gehalt mit dem Namen des Mitarbeiters verbunden

Select top 1 start at 2 salary from employee group by salary order by salary desc;

select 
    max(salary) 
from 
    emp_demo_table 
where 
    salary < (select max(salary) from emp_demo_table)

Hoffe, das löst die Frage auf einfachste Weise.

Vielen Dank

ich habe eine Tabelle wie diese in der folgenden Abbildung, und ich werde die zweitgrößte Zahl in der Spalte "to_user" finden ... _.  

Hier ist die Antwort

wähle MAX (to_user) FROM db.masterledger wobei to_user nicht in (SELECT MAX (to_user) FROM db.masterledger);

Select * from employee where salary = (Select max(salary) from employee where salary not in(Select max(salary)from employee))

Erklärung:

• Abfrage 1: Wählen Sie das Höchstgehalt (Gehalt) des Mitarbeiters aus, in dem das Gehalt nicht enthalten ist. (Wählen Sie das Höchstgehalt (Gehalt) des Mitarbeiters aus.) - Mit dieser Abfrage wird das zweithöchste Gehalt abgerufen

• Abfrage 2: Wählen Sie * von Mitarbeiter mit Gehalt = (Abfrage 1) - Diese Abfrage ruft alle Datensätze mit dem zweithöchsten Gehalt ab. (Das zweithöchste Gehalt kann mehrere Datensätze enthalten.)

SELECT MAX(Salary) FROM Employee
WHERE Salary NOT IN (SELECT MAX(Salary) FROM Employee)

Ich möchte hier eine möglichst einfachste Lösung posten. Es funktionierte in MySQL.

Bitte überprüfen Sie auch an Ihrem Ende:

SELECT name
FROM `emp`
WHERE salary = (
SELECT salary
FROM emp e
ORDER BY salary DESC
LIMIT 1
OFFSET 1 

Versuchen Sie es mit MSSQL:

SELECT
    TOP 1 salary
FROM
    (
        SELECT
            TOP 2 salary
        FROM
            Employees 
    ) sal
ORDER BY
    salary DESC;

Sie sollten jedoch diese generische SQL-Abfrage ausprobieren, die für alle Arten von Datenbanken geeignet ist.

SELECT
    MAX(salary)
FROM
    Employee
WHERE
    Salary NOT IN (
        SELECT
            Max(Salary)
        FROM
            Employee
    );

ODER

SELECT
    MAX(Salary)
FROM
    Employee
WHERE
    Salary < (
        SELECT
            Max(Salary)
        FROM
            Employee
    );

für das n-te höchste Gehalt. es ist leicht

select t.name,t.sal
from (select name,sal,dense_rank() over (order by sal desc) as rank from emp) t
where t.rank=6; //suppose i find 6th highest salary

Versuche dies

select * from (
   select ROW_NUMBER() over (order by [salary] desc) as sno,emp_name,   
   [salary] from [dbo].[Emp]
) t 
where t.sno =10

with t as
select top (1) * from       
  (select top (2) emp_name,salary from   [Emp]  e
   order by  salary desc) t
order  by salary asc

Versuchen Sie Folgendes : Dies führt zu dynamischen Ergebnissen unabhängig von der Anzahl der Zeilen

SELECT * FROM emp WHERE salary = (SELECT max(e1.salary) 
FROM emp e1 WHERE e1.salary < (SELECT Max(e2.salary) FROM emp e2))**